Golang-Bildverarbeitung: Farbbalance und Histogrammausgleich von Bildern

Golang-Bildverarbeitung: So führen Sie Farbbalance und Histogrammausgleich von Bildern durch

Einführung:
Im Bereich der Bildverarbeitung sind Farbbalance und Histogrammausgleich zwei häufig verwendete Techniken. Der Farbausgleich wird verwendet, um die Farbverteilung in einem Bild anzupassen, um ein natürlicheres Aussehen zu erzielen, während der Histogrammausgleich dazu dient, die Kontrast- und Helligkeitsverteilung eines Bildes zu verbessern. In diesem Artikel wird erläutert, wie Sie mit Golang die Farbbalance und den Histogrammausgleich von Bildern durchführen und entsprechende Codebeispiele bereitstellen.

1. Farbbalance
   Die Farbbalance kann durch Anpassen der RGB-Kanäle des Bildes erreicht werden. Insbesondere können wir eine Farbbalance erreichen, indem wir die Farbverteilung des Bildes ändern, um es gleichmäßiger zu machen.

Das Folgende ist ein Codebeispiel für den Bildfarbausgleich mit 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. Histogrammausgleich
   Der Histogrammausgleich ist eine Technik, die die Pixelwerte eines Bildes neu verteilt, um den Bildkontrast und die Helligkeit zu verbessern. Dies kann durch Statistik und Konvertierung des Grauwerts des Bildes erreicht werden.

Das Folgende ist ein Codebeispiel für die Verwendung von Golang für den Bildhistogrammausgleich:

// 导入所需的包
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
}

Fazit:
Dieser Artikel stellt die Verwendung von Golang für den Bildfarbausgleich und den Histogrammausgleich vor und stellt entsprechende Codebeispiele bereit. Farbausgleich und Histogrammausgleich sind zwei häufig verwendete Bildverarbeitungstechniken, die dazu beitragen können, die Farbverteilung, den Kontrast und die Helligkeit eines Bildes zu verbessern. Leser können diese Technologien flexibel nutzen, um Bilder entsprechend ihren eigenen Bedürfnissen und tatsächlichen Bedingungen zu verarbeiten und so bessere visuelle Effekte zu erzielen.

Das obige ist der detaillierte Inhalt vonGolang-Bildverarbeitung: Farbbalance und Histogrammausgleich von Bildern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!