golang image type conversion

Go is a programming language that is widely used in network programming, cloud computing, distributed systems and other fields. Its application in image processing has also gradually attracted attention. In the Go language, image type conversion is a common image processing operation, which can convert images in one format to another format, such as converting images in JPEG format to images in PNG format. This article will introduce how to convert image types in Go language.

1. Read pictures

Before converting the image type, you need to read the image first. The image package is provided in the standard library of the Go language. In addition to supporting basic pixel operations, it also provides interfaces for image reading and writing. We can use the Decode function in the image package to read images. The parameter of the Decode function is an io.Reader type parameter, so we can use the Open function in the os package to open a file, and then pass the file handle to the Decode function.

The following is a sample code:

package main

import (
    "fmt"
    "image"
    "os"
)

func main() {
    file, err := os.Open("image.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

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

    fmt.Println(img.Bounds())
}

In the above sample code, we use the Open function in the os package to open a file named image.jpg, and then pass the file handle to image The .Decode function reads images. The Decode function returns an image.Image type object img and a string type encoding format. We use the _ symbol to ignore the encoding format. Finally, we print the boundary information of the image (img.Bounds()), which includes the width, height and other information of the image.

2. Image type conversion

Obviously, converting an image in one format to an image in another format requires the use of two different encoders. The standard library of Go language provides a variety of image encoders, including JPEG, PNG, GIF, BMP and other formats. Different image formats have different encoders, but they implement the same interface, so that we can use the same way in the code to convert images in different formats.

The following is a sample code to convert a JPEG format image to a PNG format image:

package main

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

func main() {
    file, err := os.Open("image.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

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

    out, err := os.Create("image.png")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer out.Close()

    err = png.Encode(out, img)
    if err != nil {
        fmt.Println(err)
        return
    }
}

In the above sample code, we first use the Decode function in the image/jpeg package to read Take the image in JPEG format, and then use the Encode function in the image/png package to write the image into a PNG format file. It should be noted that although we use the png.Encode function, it can handle images in different formats because the encoder implements the same interface.

3. Image resizing

When converting image types, you may also need to resize the image. The standard library of Go language provides the image package to process pixel data. Developers can directly operate on pixels to adjust the image size. The image package provides a variety of resizing methods, including Resize, ResizeNRGBA, ResizeRGBA, etc. The following is a sample code that resizes the image to a width of 200 pixels:

package main

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

func main() {
    file, err := os.Open("image.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

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

    newImg := resize(img, 200, 0)

    out, err := os.Create("image.png")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer out.Close()

    err = png.Encode(out, newImg)
    if err != nil {
        fmt.Println(err)
        return
    }
}

func resize(img image.Image, width, height uint) image.Image {
    if height == 0 {
        height = uint(float64(width) * float64(img.Bounds().Dy()) / float64(img.Bounds().Dx()))
    }
    newImg := image.NewRGBA(image.Rect(0, 0, int(width), int(height)))
    draw.CatmullRom.Scale(newImg, newImg.Bounds(), img, img.Bounds(), draw.Src, nil)
    return newImg
}

In the above sample code, we define a resize function, in which CatmullRom.Scale in the draw package is used Function resizes the original image to the specified size. It should be noted that the width and height parameters we pass to the resize function represent the width and height of the adjusted image respectively, where the width is 200 pixels and the height is calculated from the aspect ratio of the image. This allows you to scale the image proportionally.

Summary:

This article briefly introduces the method of image type conversion in Go language, including reading images, adjusting image size, etc. In actual development, developers can choose a variety of image encoders and image resizing tools based on specific needs to implement their own image processing functions.

The above is the detailed content of golang image type conversion. For more information, please follow other related articles on the PHP Chinese website!