So verarbeiten Sie Bilder in Golang

Mit der rasanten Entwicklung des Internets ist die Bildverarbeitung zu einem unvermeidlichen Bestandteil der Webentwicklung geworden, und Golang bildet da keine Ausnahme. Golang verfügt bereits über einen sehr umfangreichen Satz an Werkzeugen für die Bildverarbeitung, z. B. das Bildpaket in der Standardbibliothek, goimage, imagick usw. in der Bibliothek eines Drittanbieters.

In diesem Artikel werden die Methoden und Techniken der Golang-Bildverarbeitung ausführlich vorgestellt, um den Lesern zu helfen, zu verstehen, wie Bilder in Golang verarbeitet werden.

1. Verwenden Sie das Bildpaket in der Golang-Standardbibliothek.

Das Bildpaket ist eine in Golang bereitgestellte Standard-Bildoperationsbibliothek. Es wird hauptsächlich zur Verarbeitung gängiger Bilddateiformate wie PNG, JPEG, BMP und GIF verwendet. Es bietet eine Reihe grundlegender Schnittstellen und Funktionen, mit denen Funktionen wie Dekodierung, Kodierung, Zuschneiden, Skalierung, Drehung und Transformation von Bilddateien implementiert werden können.

Sehen wir uns an, wie die Bildskalierungsfunktion basierend auf dem Bildpaket implementiert wird:

package main

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

func main() {
    // 读取源图片文件
    file, err := os.Open("source.jpg")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 解码源图片文件
    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    // 计算新图片尺寸
    newWidth := 640
    newHeight := (newWidth * int(img.Bounds().Dy())) / int(img.Bounds().Dx())

    // 缩放图片
    resized := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
    if err := resize(resized, img); err != nil {
        panic(err)
    }

    // 保存新图片文件
    newFile, err := os.Create("resized.jpg")
    if err != nil {
        panic(err)
    }
    defer newFile.Close()

    // 编码新图片
    if err := jpeg.Encode(newFile, resized, &jpeg.Options{Quality: 80}); err != nil {
        panic(err)
    }
}

// 缩放图片函数
func resize(dst *image.RGBA, src image.Image) error {
    sw, sh := src.Bounds().Dx(), src.Bounds().Dy()
    dw, dh := dst.Bounds().Dx(), dst.Bounds().Dy()
    scaleW, scaleH := float64(sw)/float64(dw), float64(sh)/float64(dh)
    if scaleW > scaleH {
        scaleH = scaleW
    } else {
        scaleW = scaleH
    }
    w, h := int(float64(sw)/scaleW), int(float64(sh)/scaleH)
    tmp := image.NewRGBA(image.Rect(0, 0, w, h))
    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            tmp.Set(x, y, src.At(int(float64(x)*scaleW), int(float64(y)*scaleH)))
        }
    }
    return resize2(dst, tmp)
}

// 缩放图片函数
func resize2(dst *image.RGBA, src image.Image) error {
    sw, sh := src.Bounds().Dx(), src.Bounds().Dy()
    dw, dh := dst.Bounds().Dx(), dst.Bounds().Dy()
    scaleW, scaleH := float64(sw)/float64(dw), float64(sh)/float64(dh)
    if scaleW > scaleH {
        scaleH = scaleW
    } else {
        scaleW = scaleH
    }
    for y := 0; y < dh; y++ {
        for x := 0; x < dw; x++ {
            dst.Set(x, y, src.At(int(float64(x)*scaleW), int(float64(y)*scaleH)))
        }
    }
    return nil
}

Dieser Code liest zuerst eine Bilddatei mit dem Namen source.jpg und ruft dann die Funktion image.Decode() auf, um die Bilddatei zu dekodieren in das image.Image-Objekt in Golang; berechnen Sie dann die Größe des neuen Bildes, indem Sie im Berechnungsprozess das Seitenverhältnis des Originalbilds verwenden, um sicherzustellen, dass die skalierte Bildgröße schließlich nicht verzerrt wird, indem Sie jpeg.Encode aufrufen; ) Die Funktion speichert das in der Größe geänderte Bild als neue Datei mit dem Namen resized.jpg.

2. Verwenden Sie die Drittanbieter-Bibliothek goimage.

goimage ist eine leistungsstarke Bildverarbeitungsbibliothek in Golang. Sie bietet eine Fülle von Funktionen und Schnittstellen zur Implementierung verschiedener Bildverarbeitungsvorgänge wie Skalierung, Drehung, Zuschneiden, Filter usw. Warten. Und damit nicht genug: Es bietet auch einige komplexere Funktionen wie Bildzusammenfügung, Ausschnitt, HDR-Synthese usw.

Wir zeigen Ihnen, wie Sie die Bildskalierung basierend auf goimage implementieren:

package main

import (
    "github.com/disintegration/imaging"
    "image/jpeg"
    "os"
)

func main() {
    // 读取源图片文件
    file, err := os.Open("source.jpg")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 解码源图片文件
    img, err := jpeg.Decode(file)
    if err != nil {
        panic(err)
    }

    // 缩放图片
    resized := imaging.Resize(img, 640, 0, imaging.Lanczos)

    // 保存新图片文件
    newFile, err := os.Create("resized.jpg")
    if err != nil {
        panic(err)
    }
    defer newFile.Close()

    // 编码新图片
    if err := jpeg.Encode(newFile, resized, &jpeg.Options{Quality: 80}); err != nil {
        panic(err)
    }
}

Dieser Code implementiert auch die Bildskalierungsfunktion, verwendet jedoch die Funktion „imaging.Resize()“ in der Goimage-Bibliothek, anstatt den Skalierungsalgorithmus manuell selbst zu implementieren. Dadurch wird die Belastung der Entwickler bis zu einem gewissen Grad reduziert und gleichzeitig die Bildqualität und -stabilität gewährleistet.

3. Verwenden Sie die imagick-Drittanbieterbibliothek

Zusätzlich zum Bildpaket und der goimage-Drittanbieterbibliothek in der Standardbibliothek können Sie auch die imagick-Bibliothek verwenden, um die Bildverarbeitung in Golang zu implementieren. Imagick ist die Golang-gebundene Version von ImageMagick, die grundlegende Bildverarbeitungsfunktionen und erweiterte Bildbearbeitungsfunktionen bietet.

Lassen Sie uns demonstrieren, wie Sie die Imagick-Bibliothek verwenden, um die Bildskalierungsfunktion zu implementieren:

package main

import (
    "github.com/gographics/imagick/imagick"
    "io/ioutil"
    "os"
)

func main() {
    // 初始化imagick库
    err := imagick.Initialize()
    if err != nil {
        panic(err)
    }
    defer imagick.Terminate()

    // 读取源图片文件
    file, err := os.Open("source.jpg")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 解码源图片文件
    buffer, err := ioutil.ReadAll(file)
    if err != nil {
        panic(err)
    }
    wand := imagick.NewMagickWand()
    if err := wand.ReadImageBlob(buffer); err != nil {
        panic(err)
    }

    // 缩放图片
    if err := wand.ResizeImage(640, 0, imagick.FILTER_LANCZOS, 1); err != nil {
        panic(err)
    }

    // 保存新图片文件
    if err := wand.WriteImageFile(imagick.NewMagickWand().NewCollection(), "resized.jpg"); err != nil {
        panic(err)
    }
}

Dieser Code implementiert die Initialisierung der Imagick-Bibliothek und den Bildskalierungsvorgang. Der spezifische Implementierungsprozess ähnelt den beiden vorherigen Beispielen. Es ist jedoch zu beachten, dass die Schnittstelle der Imagick-Bibliothek möglicherweise von einigen der üblichen Gewohnheiten bei der Verwendung von Golang abweicht und daher besondere Aufmerksamkeit erforderlich ist. Gleichzeitig bietet die Imagick-Bibliothek auch eine umfangreiche Bildbetriebsoberfläche, die Entwickler je nach tatsächlichem Bedarf verwenden können.

Zusammenfassend erklärt dieser Artikel hauptsächlich verschiedene Methoden zur Bildverarbeitung in Golang: Verwendung des Bildpakets in der Standardbibliothek, Verwendung der Goimage-Drittanbieterbibliothek und Verwendung der Imagick-Drittanbieterbibliothek. Wenn Bibliotheken von Drittanbietern nicht verwendet werden können, wird empfohlen, das Bildpaket in der Standardbibliothek zu verwenden. Für umfangreichere und komplexere Bildoperationen können Sie die beiden Bibliotheken goimage oder imagick verwenden. Abschließend hoffe ich aufrichtig, dass die Leser entsprechend ihrer tatsächlichen Situation die geeignete Methode zur Bildverarbeitung auswählen können.

Das obige ist der detaillierte Inhalt vonSo verarbeiten Sie Bilder in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!