Golang image manipulation: how to grayscale and adjust brightness of images

Golang Image Operation: How to Grayscale and Brightness Adjust the Image

Introduction:
In the process of image processing, it is often necessary to perform various operations on the image. Operations such as image grayscale and brightness adjustment. In Golang, we can achieve these operations by using third-party libraries. This article will introduce how to use Golang to grayscale and brightness adjust images, and attach corresponding code examples.

1. Image grayscale
Image grayscale is the process of converting a color image into a grayscale image. In the process of image grayscale, we need to convert each pixel in the image into the corresponding grayscale value through a certain algorithm. Next, we will use Golang's third-party library go-opencv to achieve image grayscale.

First, enter the following command in the terminal to install the go-opencv library:

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

Next, we will show a code example of how to grayscale an image:

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

The above code first loads a color image and then uses the CvtColor method to convert the image to a grayscale image. Finally, save the generated grayscale image to the specified output path.

2. Brightness adjustment
Brightness adjustment refers to modifying the overall brightness level of the image. In Golang, we can use the third-party library github.com/nfnt/resize to adjust the brightness of the image.

First, enter the following command in the terminal to install the nfnt/resize library:

go get -u github.com/nfnt/resize

Next, we will show a code example of how to perform image brightness adjustment:

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
}

Above The code first loads a color picture, then adjusts the brightness of the picture according to the given brightness parameters, and saves the adjusted picture to the specified output path.

Summary:
This article introduces how to use Golang to grayscale and brightness adjust images. By using third-party libraries, we can easily implement these image processing operations. I hope the code examples in this article will be helpful to you for image processing in Golang.

The above is the detailed content of Golang image manipulation: how to grayscale and adjust brightness of images. For more information, please follow other related articles on the PHP Chinese website!