golang picture rotation

Golang is a powerful programming language, and its built-in image processing library provides many powerful functions, which is especially useful when processing images. Golang provides a very useful image conversion library through which you can perform various processing on images. One of them is image rotation.

In many application scenarios, we need to rotate pictures, often because the pictures we take have errors or the angles are not good-looking. In this case, we need to rotate the image to a certain angle to achieve better results. Rotating a picture can make the image more beautiful and artistic, and help reflect the photographer's artistic level.

So, how to rotate an image in Go? We can use Golang's image processing library to operate.

First, we need to import the "image" and "image/draw" packages.

import (
    "image"
    "image/draw"
)

Then, we need to open a picture, and also need to define a variable to store the rotated picture.

file, err := os.Open("example_image.png")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

img, _, err := image.Decode(file)
if err != nil {
    log.Fatal(err)
}

// 定义旋转后的图片
rotatedImg := image.NewRGBA(img.Bounds())

Here, we open an image file. Decode it through the image.Decode() function and store it in the img variable. Next, we need to define the variable rotatedImg to store the rotated image. We use img.Bounds() to set the size and shape of the new image, and then pass in image.NewRGBA() to create a new image.

Now, we can start rotating the image. First, we need to define the angle of rotation, and then use a loop to traverse each pixel of the image and draw it to the corresponding position of the new image.

angle := 45.0

// 计算旋转前后的位置关系
rotatedImgRect := image.Rect(0, 0, img.Bounds().Dy(), img.Bounds().Dx())
rotation := draw.Quadrant(0)
switch (int(angle) / 90) % 4 {
case 0:
  rotation = draw.Quadrant(0)
  break
case 1:
  rotation = draw.Quadrant(1)
  break
case 2:
  rotation = draw.Quadrant(2)
  break
case 3:
  rotation = draw.Quadrant(3)
  break
}
rotation = draw.RotateQuadrant(rotation, img.Bounds())

// 遍历图片的每一个像素并将其绘制到新图像上
for x := 0; x < rotatedImg.Bounds().Dx(); x++ {
    for y := 0; y < rotatedImg.Bounds().Dy(); y++ {
        // 计算旋转后的像素坐标
        newX := float64(x)*math.Cos(angle) - float64(y)*math.Sin(angle)
        newY := float64(x)*math.Sin(angle) + float64(y)*math.Cos(angle)

        newX += float64(img.Bounds().Dx() - 1)
        newY += float64(img.Bounds().Dy() - 1)

        // 将旋转后的像素绘制到新图像上
        draw.Draw(rotatedImg, rotatedImg.Bounds(), img, image.Point{X: int(newX), Y: int(newY)}, draw.Over)
    }
}

In this part of the code, we first define the angle of rotation, here we take 45 degrees as an example. Next, we calculated the positional relationship after rotation, which is a very important step. We use the image.Rect() function to create a new rectangular area whose size is opposite to the size of the image before rotation. We then use the draw.Quadrant() function to create a Quadrant variable and initialize its value to 0, meaning we rotate the image 0 degrees clockwise. This Quadrant variable is combined with the area of ​​the image before rotation to generate a new rotated area. Finally, we rotate the Quadrant using the utility function draw.RotateQuadrant() to rotate the image by the specified angle.

Next, we use a nested for loop to iterate through all pixels. To get the rotated pixel coordinates correct, we perform some mathematical calculations. We first multiply the coordinates of the pixel by the cos function and the sin function to calculate the rotated coordinates of the pixel. We then add the coordinates of each rotated pixel to the final image and draw it into a new image using the utility function draw.Draw().

Finally, we can save the rotated image to disk.

rotatedImgFile, err := os.Create("rotated_image.png")
if err != nil {
    log.Fatal(err)
}
defer rotatedImgFile.Close()

png.Encode(rotatedImgFile, rotatedImg)

Here, we use os.Create() to open a new file, and then use png.Encode() to write our rotated image to the file. Once the rotation is complete, we need to close files and other open resources.

Summary:

Golang provides many powerful image processing libraries that can easily rotate an image. In this article, we introduced how to rotate an image in Golang and save it as a new image file. If you also need to perform image rotation processing in your project, you might as well try the image rotation method in Golang.

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