Golang-Bildmanipulation: Wie man Bilder in Graustufen umwandelt und die Helligkeit anpasst

Golang-Bildoperation: So passen Sie Graustufen und Helligkeit des Bildes an

Einführung:
Beim Bildverarbeitungsprozess ist es häufig erforderlich, verschiedene Vorgänge am Bild durchzuführen, wie z. B. die Graustufen- und Helligkeitsanpassung des Bildes. In Golang können wir diese Vorgänge mithilfe von Bibliotheken von Drittanbietern erreichen. In diesem Artikel wird erläutert, wie Sie mit Golang Graustufen und Helligkeit von Bildern anpassen und entsprechende Codebeispiele beifügen.

1. Bild-Graustufen
Bild-Graustufen ist der Prozess der Umwandlung eines Farbbildes in ein Graustufenbild. Bei der Bildgrauskala müssen wir jedes Pixel im Bild durch einen bestimmten Algorithmus in den entsprechenden Graustufenwert umwandeln. Als Nächstes verwenden wir Golangs Drittanbieter-Bibliothek go-opencv, um Bildgraustufen zu erreichen.

Geben Sie zunächst den folgenden Befehl in das Terminal ein, um die go-opencv-Bibliothek zu installieren:

go get -u github.com/lazywei/go-opencv

Als nächstes zeigen wir ein Codebeispiel für die Grauskalierung eines Bildes:

package main

import (
    "fmt"
    "github.com/lazywei/go-opencv/opencv"
)

func main() {
    imagePath := "test.jpg"
    // 通过go-opencv的LoadImage方法读取图片
    image := opencv.LoadImage(imagePath)
    defer image.Release()

    // 使用go-opencv的CvtColor方法将图片转为灰度图像
    grayImage := opencv.CreateImage(image.Width(), image.Height(), 8, 1)
    opencv.CvtColor(image, grayImage, opencv.CV_BGR2GRAY)

    // 保存灰度图像
    outputPath := "output_gray.jpg"
    opencv.SaveImage(outputPath, grayImage, 0)
    fmt.Printf("Gray image saved to: %s
", outputPath)
}

Der obige Code lädt zuerst ein Farbbild und dann Verwendet die CvtColor-Methode, um das Bild in Graustufen umzuwandeln. Speichern Sie abschließend das generierte Graustufenbild im angegebenen Ausgabepfad.

2. Helligkeitsanpassung
Helligkeitsanpassung bezieht sich auf die Änderung der Gesamthelligkeit des Bildes. In Golang können wir die Drittanbieterbibliothek github.com/nfnt/resize verwenden, um die Helligkeit des Bildes anzupassen.

Geben Sie zunächst den folgenden Befehl in das Terminal ein, um die nfnt/resize-Bibliothek zu installieren:

go get -u github.com/nfnt/resize

Als nächstes zeigen wir ein Codebeispiel zum Anpassen der Bildhelligkeit:

package main

import (
    "fmt"
    "image"
    "image/color"
    "github.com/nfnt/resize"
)

func main() {
    imagePath := "test.jpg"
    // 使用Golang内置的image包加载图片
    img, err := loadImage(imagePath)
    if err != nil {
        fmt.Printf("Failed to load image: %s
", err)
        return
    }

    // 调整图片亮度
    brightness := 50
    brightImage := adjustBrightness(img, brightness)

    // 保存亮度调整后的图片
    outputPath := "output_bright.jpg"
    saveImage(outputPath, brightImage)
    fmt.Printf("Brightness adjusted image saved to: %s
", outputPath)
}

// 加载图片
func loadImage(path string) (image.Image, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()

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

    return img, nil
}

// 调整图片亮度
func adjustBrightness(img image.Image, brightness int) image.Image {
    b := img.Bounds()
    dst := image.NewRGBA(b)

    for y := 0; y < b.Max.Y; y++ {
        for x := 0; x < b.Max.X; x++ {
            oldColor := img.At(x, y)
            r, g, b, _ := oldColor.RGBA()

            newR := uint8(clamp(int(r)+brightness, 0, 0xffff))
            newG := uint8(clamp(int(g)+brightness, 0, 0xffff))
            newB := uint8(clamp(int(b)+brightness, 0, 0xffff))

            newColor := color.RGBA{newR, newG, newB, 0xff}
            dst.Set(x, y, newColor)
        }
    }

    return dst
}

// 保存图片
func saveImage(path string, img image.Image) {
    file, err := os.Create(path)
    if err != nil {
        fmt.Printf("Failed to save image: %s
", err)
        return
    }
    defer file.Close()

    png.Encode(file, img)
}

// 辅助函数，限定数值在指定范围内
func clamp(value, min, max int) int {
    if value < min {
        return min
    }
    if value > max {
        return max
    }
    return value
}

Der obige Code lädt zunächst ein Farbbild. und dann basierend auf den angegebenen Helligkeitsparametern die Helligkeit des Bildes anpassen und das angepasste Bild im angegebenen Ausgabepfad speichern.

Zusammenfassung:
In diesem Artikel wird erläutert, wie Sie mit Golang Graustufen und Helligkeit von Bildern anpassen. Durch die Verwendung von Bibliotheken von Drittanbietern können wir diese Bildverarbeitungsvorgänge problemlos implementieren. Ich hoffe, dass die Codebeispiele in diesem Artikel Ihnen bei der Bildverarbeitung in Golang hilfreich sein werden.

Das obige ist der detaillierte Inhalt vonGolang-Bildmanipulation: Wie man Bilder in Graustufen umwandelt und die Helligkeit anpasst. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!