Manipulation d'images Golang : apprenez à pixeliser des images

Golang Image Operation : Apprenez à mettre en œuvre la pixellisation des images

Introduction :
Le traitement d'image est un domaine important de la vision par ordinateur. La pixellisation est un effet qui convertit une image en zones de couleur plus grandes, qui peuvent être utilisées pour protéger la confidentialité d'une image ou créer un effet artistique. Cet article explique comment utiliser Golang pour pixeliser des images.

1. Préparation
Avant de pixeliser les images, nous devons installer les bibliothèques pertinentes dans l'environnement Golang. Utilisez la commande suivante pour installer :

go get github.com/nfnt/resize
go get github.com/disintegration/imaging

2. Charger les images
Tout d'abord, nous devons charger les images à traiter en mémoire. Nous utilisons la fonction Open de la bibliothèque disintegration/imaging pour accomplir cette tâche. Voici un exemple de code pour charger une image : disintegration/imaging库的Open函数来完成这一任务。以下是加载图片的示例代码：

package main

import (
    "fmt"
    "github.com/disintegration/imaging"
)

func loadImage(imagePath string) (image *imaging.NRGBA, err error) {
    image, err = imaging.Open(imagePath)
    if err != nil {
        fmt.Println("Failed to open image:", err)
        return nil, err
    }
    return image, nil
}

func main() {
    imagePath := "input.jpg"
    image, err := loadImage(imagePath)
    if err != nil {
        return
    }
    fmt.Println("Image loaded successfully!")
}

在上述代码中，loadImage函数接受一个图片路径作为参数，并返回加载成功的图片对象。在main函数中，我们调用loadImage函数加载input.jpg图片，并打印出加载成功的消息。

三、像素化处理
在加载图片之后，我们可以开始进行像素化处理了。我们使用nfnt/resize库的Resize函数将原始图片调整为指定大小，然后再将调整后的图片进行像素化处理。以下是像素化处理的示例代码：

package main

import (
    "fmt"
    "github.com/disintegration/imaging"
    "github.com/nfnt/resize"
    "image"
    "image/color"
)

func loadImage(imagePath string) (image *imaging.NRGBA, err error) {
    // 省略代码...
}

func pixelateImage(image *imaging.NRGBA, blockSize int) *image.NRGBA {
    bounds := image.Bounds()
    width := bounds.Max.X - bounds.Min.X
    height := bounds.Max.Y - bounds.Min.Y

    resizedImage := resize.Resize(uint(width/blockSize), uint(height/blockSize), image, resize.NearestNeighbor)

    pixelatedImage := imaging.New(width, height, color.NRGBA{0, 0, 0, 0})

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, _ := resizedImage.At(x/blockSize, y/blockSize).RGBA()
            pixelatedImage.Set(x, y, color.NRGBA{uint8(r>>8), uint8(g>>8), uint8(b>>8), 255})
        }
    }
    return pixelatedImage
}

func main() {
    imagePath := "input.jpg"
    image, err := loadImage(imagePath)
    if err != nil {
        return
    }
    fmt.Println("Image loaded successfully!")

    blockSize := 10
    pixelatedImage := pixelateImage(image, blockSize)
    fmt.Println("Image pixelated successfully!")
}

在上述代码中，pixelateImage函数接受一个imaging.NRGBA类型的图片对象和一个像素块大小作为参数。函数首先将原始图片调整为指定大小，然后通过遍历调整后的图片的每个像素块，将块内的颜色设置为相应块内的平均颜色。最后，函数返回处理后的图片对象。

在main函数中，我们调用pixelateImage函数进行像素化处理，并设置像素块大小为10。处理完成后，打印出处理成功的消息。

四、保存处理结果
最后，我们将处理后的图片保存到文件中。我们使用imaging库的Save函数进行保存。以下是保存处理结果的示例代码：

package main

import (
    "fmt"
    "github.com/disintegration/imaging"
    "github.com/nfnt/resize"
    "image"
    "image/color"
)

func loadImage(imagePath string) (image *imaging.NRGBA, err error) {
    // 省略代码...
}

func pixelateImage(image *imaging.NRGBA, blockSize int) *image.NRGBA {
    // 省略代码...
}

func saveImage(image *image.NRGBA, outputPath string) error {
    err := imaging.Save(image, outputPath)
    if err != nil {
        fmt.Println("Failed to save image:", err)
        return err
    }
    return nil
}

func main() {
    imagePath := "input.jpg"
    image, err := loadImage(imagePath)
    if err != nil {
        return
    }
    fmt.Println("Image loaded successfully!")

    blockSize := 10
    pixelatedImage := pixelateImage(image, blockSize)
    fmt.Println("Image pixelated successfully!")

    outputPath := "output.jpg"
    err = saveImage(pixelatedImage, outputPath)
    if err != nil {
        return
    }
    fmt.Println("Image saved successfully!")
}

在上述代码中，我们定义了saveImage函数，接受一个图片对象和保存路径作为参数，并使用imaging.Save函数保存图片。在main函数中，我们调用saveImage函数保存像素化处理后的图片，并指定保存路径为output.jpgrrreee

Dans le code ci-dessus, la fonction loadImage accepte un chemin d'image comme paramètre et renvoie l'objet image chargé avec succès. Dans la fonction main, nous appelons la fonction loadImage pour charger l'image input.jpg et imprimer un message de chargement réussi.

3. Traitement de la pixellisation🎜Après avoir chargé l'image, nous pouvons démarrer le traitement de la pixellisation. Nous utilisons la fonction Resize de la bibliothèque nfnt/resize pour redimensionner l'image originale à la taille spécifiée, puis pixeliser l'image ajustée. Voici un exemple de code pour le traitement de la pixellisation : 🎜rrreee🎜Dans le code ci-dessus, la fonction pixelateImage accepte un objet image de type imaging.NRGBA et une taille de bloc de pixels comme paramètres. La fonction redimensionne d'abord l'image d'origine à la taille spécifiée, puis définit la couleur du bloc sur la couleur moyenne du bloc correspondant en parcourant chaque bloc de pixels de l'image redimensionnée. Enfin, la fonction renvoie l'objet image traité. 🎜🎜Dans la fonction main, nous appelons la fonction pixelateImage pour effectuer le traitement de pixellisation et définir la taille du bloc de pixels sur 10. Une fois le traitement terminé, un message de traitement réussi est imprimé. 🎜🎜4. Enregistrez les résultats du traitement🎜Enfin, nous enregistrons l'image traitée dans un fichier. Nous utilisons la fonction Save de la bibliothèque imaging pour sauvegarder. Voici un exemple de code pour enregistrer les résultats du traitement : 🎜rrreee🎜Dans le code ci-dessus, nous définissons la fonction saveImage, qui accepte un objet image et le chemin de sauvegarde comme paramètres, et utilise La fonction Imaging.Save code> enregistre l'image. Dans la fonction main, nous appelons la fonction saveImage pour enregistrer l'image pixélisée et spécifions le chemin de sauvegarde comme output.jpg. Une fois l'enregistrement terminé, un message indiquant que l'enregistrement a réussi est imprimé. 🎜🎜Conclusion : A travers cet article, nous avons appris à utiliser Golang pour pixeliser des images. Nous chargeons l'image à traiter, puis traitons l'image à l'aide de l'algorithme de pixellisation et enregistrons le résultat du traitement. J'espère que cet article vous aidera à apprendre le traitement d'image. 🎜

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!