Golang image operation: How to perform gradient and texture mapping of images

Overview:
In image processing, gradient and texture mapping are two commonly used technologies . Gradients can create smooth transitions of color effects, while texture mapping can map a texture image to a target image. This article will introduce how to use the Golang programming language to perform gradient and texture mapping operations on images.

1. Picture Gradient
   First, we need to import Golang’s image processing package image and image/color. The following is a sample code that creates a gradient image to achieve a gradient effect.

package main

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

// 漸變圖片函數(shù)
func createGradient(width, height int) *image.RGBA {
    img := image.NewRGBA(image.Rect(0, 0, width, height))
    // 漸變色起始顏色和結(jié)束顏色
    startColor := color.RGBA{255, 0, 0, 255}    // 紅色
    endColor := color.RGBA{0, 0, 255, 255}      // 藍(lán)色

    // 計(jì)算每個(gè)像素的顏色并設(shè)置到圖片上
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            percent := float64(x) / float64(width-1)
            r := uint8(float64(startColor.R)*(1-percent) + float64(endColor.R)*percent)
            g := uint8(float64(startColor.G)*(1-percent) + float64(endColor.G)*percent)
            b := uint8(float64(startColor.B)*(1-percent) + float64(endColor.B)*percent)
            img.SetRGBA(x, y, color.RGBA{r, g, b, 255})
        }
    }
    return img
}

func main() {
    width, height := 640, 480
    img := createGradient(width, height)
    
    // 保存圖片
    file, _ := os.Create("gradient.png")
    defer file.Close()
    png.Encode(file, img)
}

In the above code, we first create an image.RGBA object and specify the width and height. Then it traverses each pixel through a double loop, calculates the color of each pixel based on the ratio of the starting color and the ending color, and sets it to the picture. Finally, we save the generated gradient image as a gradient.png file.

After executing the above code, you will get a gradient image with a width of 640 pixels and a height of 480 pixels.

2. Picture texture mapping
   Texture mapping is the process of mapping a small picture (texture image) to a target image. In Golang, we can use the draw.Draw function to complete texture mapping operations. The following is a sample code to add a texture mapping effect to the target image.

package main

import (
    "image"
    "image/color"
    "image/draw"
    "image/png"
    "os"
)

// 紋理映射函數(shù)
func applyTexture(targetImg draw.Image, textureImg image.Image, offsetX, offsetY int) {
    bounds := targetImg.Bounds()
    textureBounds := textureImg.Bounds()

    // 遍歷目標(biāo)圖像的每個(gè)像素點(diǎn)，并根據(jù)紋理圖像的坐標(biāo)系獲取對(duì)應(yīng)的顏色值
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            textureX := (x-offsetX)%textureBounds.Dx()
            textureY := (y-offsetY)%textureBounds.Dy()
            textureColor := textureImg.At(textureX, textureY)
            targetImg.Set(x, y, textureColor)
        }
    }
}

func main() {
    targetImgFile, _ := os.Open("target.png")     // 目標(biāo)圖像文件
    targetImg, _ := png.Decode(targetImgFile)

    textureImgFile, _ := os.Open("texture.png")   // 紋理圖像文件
    textureImg, _ := png.Decode(textureImgFile)

    offsetX, offsetY := 100, 100                  // 紋理映射的偏移值

    // 創(chuàng)建一個(gè)新的圖像作為結(jié)果
    resultImg := image.NewRGBA(targetImg.Bounds())
    draw.Draw(resultImg, resultImg.Bounds(), targetImg, image.ZP, draw.Src)

    // 應(yīng)用紋理映射
    applyTexture(resultImg, textureImg, offsetX, offsetY)

    // 保存結(jié)果圖像
    resultFile, _ := os.Create("result.png")
    defer resultFile.Close()
    png.Encode(resultFile, resultImg)
}

In the above code, we first open the target image and texture image files, and decode them into Golang image objects through the png.Decode function. Then create a new image.RGBA object as the result image and use the draw.Draw function to draw the target image onto the result image.

Finally, we call the applyTexture function to map the texture image to the result image. By traversing each pixel of the result image and obtaining the corresponding color value according to the coordinate system of the texture image, the texture color is set to the result image.

After executing the above code, you will get a resulting image with a texture mapping effect added to the target image.

Summary:
Through the above examples, we have learned how to use Golang to perform gradient and texture mapping operations on images. These technologies can be applied to areas such as image processing, computer graphics, and game development to increase the beauty and visual effects of images. I hope this article can be helpful to your study and practice.

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