Traitement d'image Golang : comment équilibrer les couleurs et égaliser l'histogramme des images

Traitement d'image Golang : Comment effectuer la balance des couleurs et l'égalisation de l'histogramme des images

Introduction :
Dans le domaine du traitement d'image, la balance des couleurs et l'égalisation de l'histogramme sont deux techniques couramment utilisées. L'équilibrage des couleurs est utilisé pour ajuster la répartition des couleurs dans une image pour un aspect plus naturel, tandis que l'égalisation de l'histogramme est utilisée pour améliorer la répartition du contraste et de la luminosité d'une image. Cet article expliquera comment utiliser Golang pour effectuer la balance des couleurs et l'égalisation de l'histogramme des images, et fournira des exemples de code correspondants.

1. Balance des couleurs
   La balance des couleurs peut être obtenue en ajustant les canaux RVB de l'image. Plus précisément, nous pouvons atteindre l’équilibre des couleurs en modifiant la distribution des couleurs de l’image pour la rendre plus uniforme.

Ce qui suit est un exemple de code pour l'équilibrage des couleurs d'une image à l'aide de Golang :

// 导入所需的包
import (
    "image"
    "image/color"
    "math"
)

// 颜色平衡函数
func balanceColors(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个新的RGBA图像
    balancedImg := image.NewRGBA(image.Rect(0, 0, width, height))

    rTotal, gTotal, bTotal := 0, 0, 0
    numPixels := width * height

    // 遍历图像的每一个像素
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            // 获取像素的RGB值
            r, g, b, _ := img.At(x, y).RGBA()

            // 累加RGB值
            rTotal += int(r >> 8)
            gTotal += int(g >> 8)
            bTotal += int(b >> 8)
        }
    }

    // 计算平均RGB值
    rAvg := float64(rTotal) / float64(numPixels)
    gAvg := float64(gTotal) / float64(numPixels)
    bAvg := float64(bTotal) / float64(numPixels)

    // 遍历图像的每一个像素
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            // 获取像素的RGB值
            r, g, b, a := img.At(x, y).RGBA()

            // 计算调整后的RGB值
            rBalanced := uint8(math.Min(float64(r>>8)*(rAvg/255), 255))
            gBalanced := uint8(math.Min(float64(g>>8)*(gAvg/255), 255))
            bBalanced := uint8(math.Min(float64(b>>8)*(bAvg/255), 255))

            // 设置新图像的像素值
            balancedImg.Set(x, y, color.RGBA{rBalanced, gBalanced, bBalanced, uint8(a>>8)})
        }
    }

    return balancedImg
}

2. Égalisation de l'histogramme
   L'égalisation de l'histogramme est une technique qui redistribue les valeurs de pixels d'une image pour améliorer le contraste et la luminosité de l'image. Cela peut être réalisé par des statistiques et une conversion de la valeur de gris de l'image.

Ce qui suit est un exemple de code d'utilisation de Golang pour l'égalisation d'histogramme d'image :

// 导入所需的包
import (
    "image"
    "image/color"
    "math"
)

// 直方图均衡化函数
func equalizeHistogram(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个新的RGBA图像
    equalizedImg := image.NewRGBA(image.Rect(0, 0, width, height))

    // 计算像素值的累计分布
    var hist [256]int
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            // 获取像素的灰度值
            r, g, b, _ := img.At(x, y).RGBA()
            gray := color.GrayModel.Convert(color.RGBA{uint8(r>>8), uint8(g>>8), uint8(b>>8), 0}).(color.Gray)

            // 累加灰度值分布
            hist[gray.Y]++
        }
    }

    // 计算像素值的累积直方图
    var cumHist [256]int
    cumHist[0] = hist[0]
    for i := 1; i < 256; i++ {
        cumHist[i] = cumHist[i-1] + hist[i]
    }

    // 计算像素值的映射关系
    var mapping [256]uint8
    for i := 0; i < 256; i++ {
        mapping[i] = uint8(math.Round(float64(cumHist[i]) * 255 / float64(width*height)))
    }

    // 遍历图像的每一个像素
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            // 获取像素的灰度值
            r, g, b, a := img.At(x, y).RGBA()
            gray := color.GrayModel.Convert(color.RGBA{uint8(r>>8), uint8(g>>8), uint8(b>>8), uint8(a>>8)}).(color.Gray)

            // 获取映射后的灰度值
            newGray := mapping[gray.Y]

            // 设置新图像的像素值
            equalizedColor := color.Gray{newGray}
            equalizedImg.Set(x, y, equalizedColor)
        }
    }

    return equalizedImg
}

Conclusion :
Cet article présente comment utiliser Golang pour l'équilibrage des couleurs d'image et l'égalisation d'histogramme, et fournit des exemples de code correspondants. L'équilibrage des couleurs et l'égalisation de l'histogramme sont deux techniques de traitement d'image couramment utilisées qui peuvent aider à améliorer la répartition des couleurs, le contraste et la luminosité d'une image. Les lecteurs peuvent utiliser ces technologies de manière flexible pour traiter les images en fonction de leurs propres besoins et conditions réelles afin d'obtenir de meilleurs effets visuels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!