Golang-Bildmanipulation: Erfahren Sie, wie Sie einen Histogrammausgleich und eine globale Schwellenwertberechnung von Bildern durchführen-Golang-php.cn

Golang-Bildmanipulation: Erfahren Sie, wie Sie einen Histogrammausgleich und eine globale Schwellenwertberechnung von Bildern durchführen

Golang-Bildoperation: Erfahren Sie, wie Sie einen Histogrammausgleich und eine globale Schwellenwertbildung für Bilder durchführen.

Einführung:
Die Bildverarbeitung ist eine der wichtigsten Aufgaben im Bereich Computer Vision und Bildverarbeitung. In praktischen Anwendungen müssen wir häufig einige Bildverbesserungsvorgänge durchführen, um die Bildqualität zu verbessern oder bestimmte Merkmale im Bild hervorzuheben. In diesem Artikel wird erläutert, wie Sie mit Golang einen Histogrammausgleich und globale Schwellenwertoperationen für Bilder durchführen, um eine Bildverbesserung zu erzielen.

1. Histogrammausgleich
Der Histogrammausgleich ist eine häufig verwendete Bildverbesserungsmethode. Er verbessert den Kontrast des Bildes, indem er die Graustufenverteilung der Bildpixel anpasst. Bei dieser Methode berechnen wir zunächst das kumulative Histogramm des Bildes und passen dann die Pixelwerte des Bildes basierend auf dem kumulativen Histogramm an.

Das Folgende ist ein einfaches Golang-Codebeispiel zum Implementieren des Histogrammausgleichs von Bildern:

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/jpeg"
    "os"
)

func main() {
    // 打开图片文件
    file, err := os.Open("input.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 计算直方图
    hist := histogram(img)

    // 计算累积直方图
    cumHist := cumulativeHistogram(hist)

    // 根据累积直方图对图像进行像素值调整
    newImg := adjustPixels(img, cumHist)

    // 保存处理后的图像
    outFile, err := os.Create("output.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer outFile.Close()

    // 编码图像
    err = jpeg.Encode(outFile, newImg, &jpeg.Options{Quality: 100})
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("图像处理完成！")
}

// 计算直方图
func histogram(img image.Image) []int {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    hist := make([]int, 256)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, _, _, _ := img.At(x, y).RGBA()
            gray := color.Gray{uint8(r / 256)}
            hist[gray.Y]++
        }
    }

    return hist
}

// 计算累积直方图
func cumulativeHistogram(hist []int) []int {
    cumHist := make([]int, len(hist))
    cumHist[0] = hist[0]

    for i := 1; i < len(hist); i++ {
        cumHist[i] = cumHist[i-1] + hist[i]
    }

    return cumHist
}

// 根据累积直方图调整像素值
func adjustPixels(img image.Image, cumHist []int) image.Image {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    newImg := image.NewRGBA(bounds)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, g, b, a := img.At(x, y).RGBA()

            gray := color.Gray{uint8(r / 256)}
            val := uint8(float64(cumHist[gray.Y]) / float64(w*h) * 255)

            newImg.Set(x, y, color.RGBA{val, val, val, uint8(a / 256)})
        }
    }

    return newImg
}

Nach dem Login kopieren

Im obigen Code übergeben wir zunächst die Funktion Decode des Pakets image dekodiert die Eingabebilddatei in ein Objekt vom Typ image.Image. Dann rufen wir die Funktion histogram auf, um das Histogramm des Bildes zu berechnen, und die Funktion cumulativeHistogram, um das kumulative Histogramm des Bildes zu berechnen. Schließlich passen wir die Pixelwerte des Bildes basierend auf dem kumulativen Histogramm an und speichern das verarbeitete Bild mithilfe der Funktion Encode des Pakets jpeg in einer Datei. image包的Decode函数将输入图像文件解码为image.Image类型的对象。然后，我们分别调用histogram函数计算图像的直方图，cumulativeHistogram函数计算图像的累积直方图。最后，我们根据累积直方图调整图像的像素值，并使用jpeg包的Encode函数将处理后的图像保存到文件中。

二、全局阈值化
全局阈值化是一种简单但有效的图像二值化方法，它将图像的像素值分为两个互不重叠的光滑区域，分别代表目标物体和背景。这种方法通常应用于具有明显的前景和背景差异的图像。

下面是一个简单的Golang代码示例，用于实现图像的全局阈值化：

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/jpeg"
    "os"
)

func main() {
    // 打开图片文件
    file, err := os.Open("input.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 根据全局阈值对图像进行二值化处理
    newImg := binarize(img)

    // 保存处理后的图像
    outFile, err := os.Create("output.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer outFile.Close()

    // 编码图像
    err = jpeg.Encode(outFile, newImg, &jpeg.Options{Quality: 100})
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("图像处理完成！")
}

// 根据全局阈值对图像进行二值化处理
func binarize(img image.Image) image.Image {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    newImg := image.NewRGBA(bounds)

    threshold := calculateThreshold(img)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, g, b, a := img.At(x, y).RGBA()

            gray := color.Gray{uint8(r / 256)}
            var val uint8
            if gray.Y > threshold {
                val = 255
            } else {
                val = 0
            }

            newImg.Set(x, y, color.RGBA{val, val, val, uint8(a / 256)})
        }
    }

    return newImg
}

// 根据图像的直方图计算全局阈值
func calculateThreshold(img image.Image) uint8 {
    hist := histogram(img)
    totalPixels := img.Bounds().Max.X * img.Bounds().Max.Y

    // 计算背景像素值的总和
    var bgSum, bgCount, fgSum, fgCount int
    for i := 0; i < len(hist); i++ {
        if i <= 128 {
            bgSum += i * hist[i]
            bgCount += hist[i]
        } else {
            fgSum += i * hist[i]
            fgCount += hist[i]
        }
    }

    // 计算背景和前景的平均灰度值
    bgMean := bgSum / bgCount
    fgMean := fgSum / fgCount

    // 根据背景和前景的平均灰度值计算阈值
    return uint8((bgMean + fgMean) / 2)
}

// 计算直方图
func histogram(img image.Image) []int {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    hist := make([]int, 256)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, _, _, _ := img.At(x, y).RGBA()
            gray := color.Gray{uint8(r / 256)}
            hist[gray.Y]++
        }
    }

    return hist
}

Nach dem Login kopieren

在上述代码中，我们首先通过image包的Decode函数将输入图像文件解码为image.Image类型的对象。然后，我们调用calculateThreshold函数计算图像的全局阈值。最后，我们根据全局阈值将图像进行二值化处理，并使用jpeg包的Encode

2. Globales Thresholding

Globales Thresholding ist eine einfache, aber effektive Bildbinarisierungsmethode. Es unterteilt den Pixelwert des Bildes in zwei nicht überlappende glatte Bereiche, die das Zielobjekt bzw. den Hintergrund darstellen. Diese Methode wird normalerweise auf Bilder mit deutlichen Unterschieden zwischen Vorder- und Hintergrund angewendet.

Das Folgende ist ein einfaches Golang-Codebeispiel für die globale Schwellenwertermittlung von Bildern: 🎜rrreee🎜Im obigen Code übergeben wir zunächst die Funktion Decode des Pakets image Geben Sie eine Bilddatei in ein Objekt vom Typ image.Image ein. Anschließend rufen wir die Funktion calculateThreshold auf, um den globalen Schwellenwert des Bildes zu berechnen. Schließlich binarisieren wir das Bild gemäß dem globalen Schwellenwert und speichern das verarbeitete Bild mithilfe der Funktion Encode des Pakets jpeg in einer Datei. 🎜🎜Zusammenfassung: 🎜In diesem Artikel haben wir vorgestellt, wie man mit Golang Histogrammausgleichs- und globale Schwellenwertoperationen für Bilder durchführt. Der Histogrammausgleich kann verwendet werden, um den Kontrast des Bildes zu verbessern, wodurch das Bild klarer und deutlicher wird. Mithilfe globaler Schwellenwerte kann das Bild in ein Binärbild umgewandelt werden, um die Zielobjekte im Bild hervorzuheben. Durch den flexiblen Einsatz dieser beiden Methoden können wir eine Bildverbesserung und Merkmalsextraktion erreichen, um den unterschiedlichen Anwendungsanforderungen gerecht zu werden. In praktischen Anwendungen können wir sie mit anderen Bildverarbeitungsalgorithmen kombinieren, um die Wirkung und Qualität der Bildverarbeitung weiter zu verbessern. 🎜

Das obige ist der detaillierte Inhalt vonGolang-Bildmanipulation: Erfahren Sie, wie Sie einen Histogrammausgleich und eine globale Schwellenwertberechnung von Bildern durchführen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!