Golang Image Processing: Learn How to Make Color Adjustments and Color Mapping

Golang Image Processing: Learn how to perform color adjustment and color mapping

Introduction:
In the field of image processing, color adjustment is a very important operation. By adjusting the colors of an image, we can change the look and mood of the picture, making it more appealing. In this article, we will learn how to use Golang for color adjustment and color mapping, along with code examples.

1. Basics of Golang image processing
Before starting to learn color adjustment, we need to understand some basic knowledge of Golang image processing. First, we need to import the Golang image processing library.

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

We can then open an image and decode it into a Golang image object using the Decode function.

file, err := os.Open("input.jpg")
if err != nil {
    panic(err)
}
defer file.Close()

img, err := jpeg.Decode(file)
if err != nil {
    panic(err)
}

Through the above code, we successfully decoded an image named input.jpg into a Golang image object img. Next, we can perform color adjustment and color mapping operations on the image object.

2. Color adjustment

1. Brightness adjustment
   Brightness adjustment is to change the lightness and darkness of the image by changing the brightness value of the pixels. The code below shows how to increase the brightness value of an image by 50%.

func adjustBrightness(img image.Image, value float64) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    newImg := image.NewRGBA(bounds)

    for x := 0; x < width; x++ {
        for y := 0; y < height; y++ {
            r, g, b, a := img.At(x, y).RGBA()
            gray := (r + g + b) / 3
            newR := clamp(uint32(float64(r) + value*float64(gray)))
            newG := clamp(uint32(float64(g) + value*float64(gray)))
            newB := clamp(uint32(float64(b) + value*float64(gray)))

            newImg.Set(x, y, color.RGBA{R: uint8(newR), G: uint8(newG), B: uint8(newB), A: uint8(a)})
        }
    }

    return newImg
}

func clamp(value uint32) uint8 {
    if value > 255 {
        return 255
    }
    if value < 0 {
        return 0
    }
    return uint8(value)
}

In the above code, the adjustBrightness function accepts an image object and a brightness value, and then uses a double loop to traverse each pixel of the image, and performs the R, The G and B components are adjusted, and finally an adjusted image object is returned.

2. Contrast adjustment
   Contrast adjustment is to enhance or weaken the contrast of an image by expanding or compressing the brightness difference of the image. The code below shows how to increase the contrast of an image by 50%.

func adjustContrast(img image.Image, value float64) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    newImg := image.NewRGBA(bounds)

    for x := 0; x < width; x++ {
        for y := 0; y < height; y++ {
            r, g, b, a := img.At(x, y).RGBA()

            newR := clamp(uint32((float64(r) - 0.5*65535) * value + 0.5*65535))
            newG := clamp(uint32((float64(g) - 0.5*65535) * value + 0.5*65535))
            newB := clamp(uint32((float64(b) - 0.5*65535) * value + 0.5*65535))

            newImg.Set(x, y, color.RGBA{R: uint8(newR), G: uint8(newG), B: uint8(newB), A: uint8(a)})
        }
    }

    return newImg
}

In the above code, the adjustContrast function accepts an image object and a contrast value, and then uses a double loop to traverse each pixel of the image, and performs the R, The G and B components are adjusted, and finally an adjusted image object is returned.

3. Color mapping
Color mapping refers to changing the appearance and color of an image by mapping one or some colors in the original image to a new color value. The code below shows how to map red in an image to blue.

func colorMap(img image.Image, oldColor, newColor color.RGBA) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    newImg := image.NewRGBA(bounds)

    for x := 0; x < width; x++ {
        for y := 0; y < height; y++ {
            r, g, b, a := img.At(x, y).RGBA()

            if r == uint32(oldColor.R)*65535 && g == uint32(oldColor.G)*65535 && b == uint32(oldColor.B)*65535 {
                newImg.Set(x, y, newColor)
            } else {
                newImg.Set(x, y, color.RGBA{R: uint8(r / 256), G: uint8(g / 256), B: uint8(b / 256), A: uint8(a / 256)})
            }
        }
    }

    return newImg
}

In the above code, the colorMap function accepts an image object, an old color and a new color, and then uses a double loop to traverse each pixel of the image and determine whether the color of the current pixel Matches the old color, changes the color of the pixel to the new color if it matches, and finally returns a color-mapped image object.

Conclusion
By studying this article, we learned how to use Golang for color adjustment and color mapping. By adjusting the image's brightness, contrast, and mapping colors, we can change the appearance and color of the image to make it more appealing. I hope this article can be helpful to everyone's learning and practice in Golang image processing.

The above is the detailed content of Golang Image Processing: Learn How to Make Color Adjustments and Color Mapping. For more information, please follow other related articles on the PHP Chinese website!