rotation de l'image golang

Golang est un langage de programmation puissant avec une bibliothèque de traitement d'images intégrée qui fournit de nombreuses fonctionnalités puissantes, particulièrement utiles lors du traitement d'images. Golang fournit une bibliothèque de conversion d'images très utile grâce à laquelle vous pouvez effectuer divers traitements sur les images. L'un d'eux est la rotation de l'image.

Dans de nombreux scénarios d'application, nous devons faire pivoter les images, souvent parce que les photos que nous prenons comportent des erreurs ou que les angles ne sont pas beaux. Dans ce cas, nous devons faire pivoter l’image selon un certain angle pour obtenir de meilleurs résultats. La rotation d'une image peut la rendre plus belle et plus artistique, et contribuer à refléter le niveau artistique du photographe.

Alors, comment faire pivoter une image dans Go ? Nous pouvons utiliser la bibliothèque de traitement d'image de Golang pour fonctionner.

Tout d'abord, nous devons importer les packages "image" et "image/draw".

import (
    "image"
    "image/draw"
)

Ensuite, nous devons ouvrir une image, et également définir une variable pour stocker l'image pivotée.

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

Ici, on ouvre un fichier image. Décodez-le via la fonction image.Decode() et stockez-le dans la variable img. Ensuite, nous devons définir la variable rotatedImg pour stocker l'image pivotée. Nous utilisons img.Bounds() pour définir la taille et la forme de la nouvelle image, puis transmettons image.NewRGBA() pour créer une nouvelle image.

Maintenant, nous pouvons commencer à faire pivoter l'image. Tout d’abord, nous devons définir l’angle de rotation, puis utiliser une boucle pour parcourir chaque pixel de l’image et le dessiner vers la position correspondante de la nouvelle 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)
    }
}

Dans cette partie du code, on définit d'abord l'angle de rotation, ici on prend 45 degrés comme exemple. Ensuite, nous avons calculé la relation de position après rotation, ce qui constitue une étape très importante. Nous utilisons la fonction image.Rect() pour créer une nouvelle zone rectangulaire dont la taille est opposée à la taille de l'image avant rotation. Nous utilisons ensuite la fonction draw.Quadrant() pour créer une variable Quadrant et initialiser sa valeur à 0, ce qui signifie que nous faisons pivoter l'image de 0 degré dans le sens des aiguilles d'une montre. Cette variable Quadrant est combinée avec la zone de l'image avant rotation pour générer une nouvelle zone pivotée. Enfin, nous faisons pivoter le quadrant à l’aide de la fonction utilitaire draw.RotateQuadrant() pour faire pivoter l’image de l’angle spécifié.

Ensuite, nous utilisons une boucle for imbriquée pour parcourir tous les pixels. Pour obtenir les coordonnées correctes des pixels pivotés, nous effectuons quelques calculs mathématiques. Nous multiplions d’abord les coordonnées du pixel par la fonction cos et la fonction sin pour calculer les coordonnées de rotation du pixel. Nous ajoutons ensuite les coordonnées de chaque pixel pivoté à l'image finale et la dessinons dans une nouvelle image à l'aide de la fonction utilitaire draw.Draw().

Enfin, nous pouvons enregistrer l'image pivotée sur le disque.

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

png.Encode(rotatedImgFile, rotatedImg)

Ici, nous utilisons os.Create() pour ouvrir un nouveau fichier, puis utilisons png.Encode() pour écrire notre image pivotée dans le fichier. Une fois la rotation terminée, nous devons fermer les fichiers et autres ressources ouvertes.

Résumé :

Golang fournit de nombreuses bibliothèques de traitement d'image puissantes qui peuvent facilement faire pivoter une image. Dans cet article, nous avons expliqué comment faire pivoter une image dans Golang et l'enregistrer en tant que nouveau fichier image. Si vous devez également effectuer un traitement de rotation d'image dans votre projet, vous pouvez également essayer la méthode de rotation d'image dans Golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!