Golang-Bildverarbeitung: So führen Sie Farbverlaufs- und Graustufenzuordnungen von Bildern durch

Golang-Bildverarbeitung: So führen Sie Farbverläufe und Graustufen-Mapping von Bildern durch

Einführung: Mit der Entwicklung digitaler Medien ist die Bildverarbeitung zu einem unverzichtbaren Bestandteil unseres täglichen Lebens geworden. In der Go-Sprache können wir einige Bibliotheken für die Bildverarbeitung verwenden, beispielsweise github.com/disintegration/imaging. In diesem Artikel wird erläutert, wie Sie mit dieser Bibliothek Farbverläufe und Graustufenzuordnungen für Bilder durchführen.

1. Stellen Sie die Bibliothek vor

Zuerst müssen wir die Bibliothek github.com/disintegration/imaging in das Go-Projekt einführen. Zur Installation können Sie den folgenden Befehl verwenden:

go get -u github.com/disintegration/imaging

2. Farbverlauf

Wenn wir einen Farbverlaufseffekt in einem Bild erzeugen möchten, können wir dies wie folgt tun Schritte:

1 .Bilder lesen

Mit der Funktion „Öffnen“ der Bildbibliothek können wir ein Bild lesen. Der folgende Code zeigt, wie man ein Bild liest:

import (
    "github.com/disintegration/imaging"
)

func main() {
    srcImg, err := imaging.Open("input.jpg")
    if err != nil {
        panic(err)
    }
}

2. Erstellen Sie ein Verlaufsbild

Als nächstes können wir die Funktion „Neu“ der Bildbibliothek verwenden, um ein neues Bild als Zielbild für den Verlaufseffekt zu erstellen. Der folgende Code zeigt, wie man ein Zielbild erstellt und dessen Breite und Höhe angibt:

dstImg := imaging.New(800, 600, color.NRGBA{R: 0, G: 0, B: 0, A: 0})

In diesem Beispiel erstellen wir ein 800x600-Bild mit schwarzer Farbe (alle RGB-Werte sind 0).

3. Verlaufseffekt

Wenn wir weiterhin die Funktionen der Bildbibliothek nutzen, können wir die Pixelfarben des Quellbilds nacheinander dem Zielbild zuordnen, um den Verlaufseffekt zu erzielen. Der folgende Code zeigt, wie man den Effekt eines linearen Farbverlaufs erzielt:

for y := 0; y < srcImg.Bounds().Dy(); y++ {
    for x := 0; x < srcImg.Bounds().Dx(); x++ {
        c := srcImg.At(x, y)
        r, g, b, a := c.RGBA()
        // 根据像素位置和颜色进行渐变计算
        c = color.RGBA{
            R: uint8(x * 255 / srcImg.Bounds().Dx()),
            G: uint8(y * 255 / srcImg.Bounds().Dy()),
            B: uint8(b / 65535 * 255),
            A: uint8(a / 65535 * 255),
        }
        dstImg.Set(x, y, c)
    }
}

4. Speichern Sie das Bild

Abschließend können wir die Speicherfunktion der Bildbibliothek verwenden, um das Zielbild in einer Datei zu speichern:

err = imaging.Save(dstImg, "output.jpg")
if err != nil {
    panic(err)
}

Auf diese Weise , wir haben eine Farbverlaufsverarbeitung von Bildern abgeschlossen.

3. Graustufen-Mapping

Zusätzlich zu Farbverläufen können wir ein Bild auch in Graustufen umwandeln. Der folgende Code zeigt, wie die Graustufenzuordnung eines Bildes implementiert wird:

func grayscaleMapping() {
    srcImg, err := imaging.Open("input.jpg")
    if err != nil {
        panic(err)
    }
    
    // 新建一张灰度图像
    dstImg := imaging.New(srcImg.Bounds().Dx(), srcImg.Bounds().Dy(), color.NRGBA{R: 0, G: 0, B: 0, A: 0})
    
    for y := 0; y < srcImg.Bounds().Dy(); y++ {
        for x := 0; x < srcImg.Bounds().Dx(); x++ {
            c := srcImg.At(x, y)
            r, g, b, _ := c.RGBA()
            intensity := (r + g + b) / 3
            // 根据像素灰度值映射为新的颜色
            c = color.RGBA{R: uint8(intensity), G: uint8(intensity), B: uint8(intensity), A: 255}
            dstImg.Set(x, y, c)
        }
    }
    
    err = imaging.Save(dstImg, "output_grayscale.jpg")
    if err != nil {
        panic(err)
    }
}

Der obige Code mittelt den RGB-Wert jedes Pixels des Quellbilds und verwendet das Ergebnis dann als RGB-Wert des neuen Pixels, wodurch eine Graustufenzuordnung erreicht wird.

Fazit:

Durch die Einführung der Bibliothek github.com/disintegration/imaging können wir verschiedene Bildverarbeitungsvorgänge in der Go-Sprache durchführen. In diesem Artikel werden Farbverläufe und Graustufenzuordnungen als Beispiele verwendet, um spezifische Codebeispiele zu geben. Der Leser kann auf dieser Basis je nach Bedarf komplexere Bildverarbeitungsvorgänge durchführen.

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