Golang-Bildmanipulation: So führen Sie Farbbalance und Farbkonvertierung an Bildern durch-Golang-php.cn

Golang-Bildmanipulation: So führen Sie Farbbalance und Farbkonvertierung an Bildern durch

王林

Freigeben： 2023-08-19 09:21:53

Original

809 Leute haben es durchsucht

Golang-Bildmanipulation: So führen Sie Farbbalance und Farbkonvertierung an Bildern durch

Golang-Bildoperation: So führen Sie Farbbalance und Farbkonvertierung an Bildern durch

Einführung: Im Bereich der Bildverarbeitung gehören Farbbalance und Farbkonvertierung zu den am häufigsten verwendeten Vorgängen. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache die Farbbalance und Farbkonvertierung von Bildern durchführen und entsprechende Codebeispiele bereitstellen.

1. Farbbalance
Farbbalance bezieht sich auf die Anpassung der Intensität jedes Farbkanals im Bild, um die Gesamtfarbe des Bildes gleichmäßiger und natürlicher zu machen. Zu den häufig verwendeten Farbausgleichsalgorithmen gehören Helligkeitsausgleich, Weißabgleich und Histogrammausgleich.

Helligkeitsbalance
Die Helligkeitsbalance wird durch Anpassen der Verteilung der Bildhelligkeit erreicht. Hier ist ein einfacher Beispielcode, um einen Helligkeitsausgleich zu erreichen:

package main

import (
    "image"
    "image/color"
    "image/png"
    "os"
)

func brightnessBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    balanceImg := image.NewRGBA(img.Bounds())

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = r * 2
            g = g * 2
            b = b * 2

            balanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return balanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    balanceImg := brightnessBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, balanceImg)
    if err != nil {
        panic(err)
    }
}

Nach dem Login kopieren

Im obigen Code durchlaufen wir jedes Pixel des Bildes und multiplizieren den Wert der roten, grünen und blauen Kanäle jedes Pixels mit 2. Die Gesamthelligkeit beträgt verbessert. Indem wir das Originalbild laden und das verarbeitete Bild speichern, können wir ein farblich ausgeglichenes Bild erhalten.

Weißabgleich
Der Weißabgleich dient dazu, Farbstiche in Bildern zu beseitigen, die durch ungleichmäßige Beleuchtung verursacht werden. Das Folgende ist ein einfacher Beispielcode zum Erreichen des Weißabgleichs:

package main

import (
    "image"
    "image/color"
    "image/png"
    "math"
    "os"
)

func whiteBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    whiteBalanceImg := image.NewRGBA(img.Bounds())

    var sumR, sumG, sumB float64
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            sumR += math.Log(float64(r))
            sumG += math.Log(float64(g))
            sumB += math.Log(float64(b))
        }
    }
    avgR := math.Exp(sumR / (float64(width * height)))
    avgG := math.Exp(sumG / (float64(width * height)))
    avgB := math.Exp(sumB / (float64(width * height)))

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = uint32(math.Log(float64(r)) * avgR / float64(r))
            g = uint32(math.Log(float64(g)) * avgG / float64(g))
            b = uint32(math.Log(float64(b)) * avgB / float64(b))

            whiteBalanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return whiteBalanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    whiteBalanceImg := whiteBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, whiteBalanceImg)
    if err != nil {
        panic(err)
    }
}

Nach dem Login kopieren

Im obigen Code berechnen wir den Durchschnitt der logarithmischen Werte aller Pixel im Bild und multiplizieren den logarithmischen Wert jedes Pixels mit dem Durchschnitt. Um den Weißabgleich zu erreichen, wird eine exponentielle Operation durchgeführt. Ebenso können wir durch Laden des Originalbilds und Speichern des verarbeiteten Bilds ein weißabgeglichenes Bild erhalten.

2. Farbkonvertierung
Farbkonvertierung bezieht sich auf die Konvertierung von Farben in einem Farbraum in Farben in einem anderen Farbraum. Zu den häufig verwendeten Farbkonvertierungen gehören RGB in HSV und RGB in YUV.

Konvertierung von RGB in HSV
RGB und HSV sind zwei gängige Farbräume. RGB wird zur Darstellung der drei Farbkomponenten Rot, Grün und Blau verwendet, und HSV wird zur Darstellung der drei Farbattribute verwendet: Farbton, Sättigung, und Helligkeit.

Das Folgende ist ein einfacher Beispielcode zum Konvertieren von RGB-Farben in HSV-Farben:

package main

import (
    "fmt"
    "image/color"
)

func rgbToHsv(r, g, b uint8) (uint16, uint8, uint8) {
    var h, s, v uint16

    max := uint16(r)
    if uint16(g) > max {
        max = uint16(g)
    }
    if uint16(b) > max {
        max = uint16(b)
    }

    min := uint16(r)
    if uint16(g) < min {
        min = uint16(g)
    }
    if uint16(b) < min {
        min = uint16(b)
    }

    v = max
    delta := max - min

    if max != 0 {
        s = uint8(delta) * 255 / uint8(max)
    } else {
        s = 0
    }

    if delta != 0 {
        if max == uint16(r) {
            h = (uint16(g) - uint16(b)) * 60 / delta
            if uint16(g) < uint16(b) {
                h += 360
            }
        } else if max == uint16(g) {
            h = (2 + (uint16(b)-uint16(r))/delta) * 60
        } else {
            h = (4 + (uint16(r)-uint16(g))/delta) * 60
        }
    } else {
        h = 0
    }

    return h, s, uint8(v)
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    h, s, v := rgbToHsv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> HSV(%d, %d, %d)
", r, g, b, h, s, v)
}

Nach dem Login kopieren

Im obigen Code berechnen wir die entsprechenden HSV-Farbkomponenten basierend auf den Werten der RGB-Farbkomponenten durch eine Reihe von Berechnungen. Wert. Wir geben eine reine rote RGB-Farbe aus, indem wir den Wert der RGB-Komponente auf den Maximalwert von Rot setzen und die entsprechende HSV-Farbe berechnen.

Konvertierung von RGB in YUV
YUV ist ebenfalls ein gängiger Farbraum, wobei Y für Helligkeit und U und V für Chroma stehen. Das Folgende ist ein einfacher Beispielcode zum Konvertieren von RGB-Farben in YUV-Farben:

package main

import (
    "fmt"
    "image/color"
)

func rgbToYuv(r, g, b uint8) (uint8, uint8, uint8) {
    y := uint8(float32(r)*0.299 + float32(g)*0.587 + float32(b)*0.114)
    u := uint8((-float32(r)*0.14713 - float32(g)*0.28886 + float32(b)*0.436 + 128) / 2)
    v := uint8((float32(r)*0.615 + float32(g)*0.51499 - float32(b)*0.10001 + 128) / 2)
    return y, u, v
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    y, u, v := rgbToYuv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> YUV(%d, %d, %d)
", r, g, b, y, u, v)
}

Nach dem Login kopieren

Im obigen Code berechnen wir die entsprechenden YUV-Farbkomponentenwerte durch eine Reihe von Berechnungen basierend auf den Werten der RGB-Farbkomponenten . In ähnlicher Weise geben wir eine reine rote RGB-Farbe aus, indem wir den Wert der RGB-Komponente auf den Maximalwert von Rot setzen und die entsprechende YUV-Farbe berechnen.

Fazit: In diesem Artikel wird die Methode zur Farbbalance und Farbkonvertierung von Bildern mithilfe der Go-Sprache vorgestellt und entsprechende Codebeispiele bereitgestellt. Ich hoffe, dass die Leser durch diesen Artikel ein tieferes Verständnis der Golang-Bildoperationen erlangen und diese auf tatsächliche Projekte anwenden können.

Das obige ist der detaillierte Inhalt vonGolang-Bildmanipulation: So führen Sie Farbbalance und Farbkonvertierung an Bildern durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!