Comment traiter des images dans Golang

Avec le développement rapide d'Internet, le traitement d'images est devenu un élément incontournable du développement Web, et Golang ne fait pas exception. Golang dispose déjà d'un ensemble très riche d'outils de traitement d'images, tels que le package image dans la bibliothèque standard, goimage, imagick, etc. dans la bibliothèque tierce.

Cet article présentera en détail les méthodes et techniques de traitement d'images Golang pour aider les lecteurs à comprendre comment traiter les images dans Golang.

1. Utilisez le package d'images dans la bibliothèque standard de Golang

Le package d'images est une bibliothèque d'opérations d'image standard fournie dans Golang. Il est principalement utilisé pour traiter les formats de fichiers image courants, tels que PNG, JPEG, BMP et GIF. Il fournit un ensemble d'interfaces et de fonctions de base pouvant implémenter des fonctions telles que le décodage, l'encodage, le recadrage, la mise à l'échelle, la rotation et la transformation des fichiers image.

Voyons comment implémenter la fonction de mise à l'échelle d'image basée sur le package image :

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
}

Ce code lit d'abord un fichier image nommé source.jpg, puis appelle la fonction image.Decode() pour décoder le fichier image dans l'objet image.Image dans Golang ; puis calculez la taille de la nouvelle image en utilisant le rapport hauteur/largeur de l'image d'origine dans le processus de calcul pour vous assurer que la taille de l'image mise à l'échelle ne sera finalement pas déformée, en appelant jpeg.Encode( ) La fonction enregistre l'image redimensionnée dans un nouveau fichier nommé resized.jpg.

2. Utilisez la bibliothèque tierce goimage

goimage est une puissante bibliothèque de traitement d'image dans Golang. Elle fournit une multitude de fonctions et d'interfaces pour implémenter diverses opérations de traitement d'image, telles que la mise à l'échelle, la rotation, le recadrage, les filtres, etc. attendez. Et ses fonctions ne s'arrêtent pas là. Il propose également des opérations plus complexes, comme l'assemblage d'images, le découpage, la synthèse HDR, etc.

Montrons comment implémenter la mise à l'échelle d'image basée sur goimage :

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)
    }
}

Ce code implémente également la fonction de mise à l'échelle d'image, mais utilise la fonction Imaging.Resize() dans la bibliothèque goimage au lieu d'implémenter manuellement l'algorithme de mise à l'échelle vous-même. Cela réduit dans une certaine mesure la charge des développeurs, tout en garantissant la qualité et la stabilité de l'image.

3. Utilisez la bibliothèque tierce imagick

En plus du package d'images et de la bibliothèque tierce goimage dans la bibliothèque standard, vous pouvez également utiliser la bibliothèque imagick pour implémenter le traitement d'image dans Golang. Imagick est la version Golang d'ImageMagick, qui fournit des capacités de traitement d'image sous-jacentes et des fonctions avancées de manipulation d'image.

Montrons comment utiliser la bibliothèque imagick pour implémenter la fonction de mise à l'échelle d'image :

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)
    }
}

Ce code implémente l'initialisation de la bibliothèque imagick et l'opération de mise à l'échelle d'image. Le processus d'implémentation spécifique est similaire aux deux exemples précédents. Cependant, il convient de noter que l'interface de la bibliothèque imagick peut être différente de certaines des habitudes habituelles d'utilisation de Golang, une attention particulière est donc requise. Dans le même temps, la bibliothèque imagick fournit également une interface riche d'exploitation d'images, que les développeurs peuvent utiliser en fonction des besoins réels.

Pour résumer, cet article explique principalement plusieurs méthodes de traitement d'images dans Golang : en utilisant le package image dans la bibliothèque standard, en utilisant la bibliothèque tierce goimage et en utilisant la bibliothèque tierce imagick. Lorsque les bibliothèques tierces ne peuvent pas être utilisées, il est recommandé d'utiliser le package d'images dans la bibliothèque standard. Pour des opérations sur les images plus riches et complexes, vous pouvez utiliser les deux bibliothèques goimage ou imagick. Enfin, j'espère sincèrement que les lecteurs pourront choisir la méthode de traitement d'image appropriée en fonction de leur situation réelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!