How to process images in golang

With the rapid development of the Internet, image processing has become an inevitable part of Web development, and Golang is no exception. Golang already has a very rich set of tools for image processing, such as the image package in the standard library, goimage, imagick, etc. in the third-party library.

This article will introduce in detail the methods and techniques of Golang image processing to help readers understand how to process images in Golang.

1. Use the image package in the Golang standard library

The image package is a standard image operation library provided in Golang. It is mainly used to process common image file formats, such as PNG, JPEG, Formats such as BMP and GIF. It provides a set of basic interfaces and functions that can implement functions such as decoding, encoding, cropping, scaling, rotation and transformation of image files.

Let's take a look at how to implement the image scaling function based on the image package:

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
}

This code first reads an image file named source.jpg, and then calls image.Decode The () function decodes the image file into an image.Image object in Golang; then calculates the size of the new image, using the aspect ratio of the original image in the calculation process to ensure that the scaled image size will not be distorted; finally , save the scaled image as a new file named resized.jpg by calling the jpeg.Encode() function.

2. Use the goimage third-party library

goimage is a powerful image processing library in Golang. It provides a wealth of functions and interfaces that can implement various image processing operations, such as zooming. , rotate, crop, filter, etc. And its functions don't stop there. It also provides some more complex operations, such as picture stitching, cutout, HDR synthesis, etc.

Let’s show how to implement the image scaling operation based on 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)
    }
}

This code also implements the image scaling function, but uses imaging.Resize() in the goimage library function instead of manually implementing the scaling algorithm yourself. This reduces the burden on developers to a certain extent, while also ensuring image quality and stability.

3. Use imagick third-party library

In addition to the image package and goimage third-party library in the standard library, you can also use the imagick library to implement image processing in Golang. Imagick is the Golang-bound version of ImageMagick, which provides underlying image processing capabilities and advanced image manipulation functions.

Let’s demonstrate how to use the imagick library to implement the image scaling function:

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

This code implements the initialization of the imagick library and the image scaling operation. The specific implementation process is the same as the previous two The examples are almost the same. However, it should be noted that the interface of the imagick library may be different from some of the usual habits of using Golang, so special attention is required. At the same time, the imagick library also provides a rich image operation interface, which developers can use according to actual needs.

To sum up, this article mainly explains several methods of processing images in Golang: using the image package in the standard library, using the goimage third-party library and using the imagick third-party library. When third-party libraries cannot be used, it is recommended to use the image package in the standard library. For more rich and complex image operations, you can use the two libraries goimage or imagick. Finally, I sincerely hope that readers can choose the appropriate method for image processing according to their actual situation.

The above is the detailed content of How to process images in golang. For more information, please follow other related articles on the PHP Chinese website!