Traitement d'image Golang : comment effectuer un mappage de dégradés de couleurs et d'échelles de gris d'images

Traitement d'images Golang : Comment effectuer un mappage de dégradés de couleurs et d'échelles de gris d'images

Introduction : Avec le développement des médias numériques, le traitement d'images est devenu un élément indispensable de notre vie quotidienne. Dans le langage Go, nous pouvons utiliser certaines bibliothèques pour le traitement d'images, comme github.com/disintegration/imaging. Cet article explique comment utiliser cette bibliothèque pour effectuer un mappage de dégradés de couleurs et d'échelles de gris d'images.

1. Présentez la bibliothèque

Tout d'abord, nous devons introduire la bibliothèque github.com/disintegration/imaging dans le projet Go. Vous pouvez utiliser la commande suivante pour installer :

go get -u github.com/disintegration/imaging

2. Dégradé de couleurs

Si nous voulons créer un effet de dégradé de couleur dans une image, nous pouvons le faire de la manière suivante étapes :

1 .Lire des images

Grâce à la fonction Ouvrir de la bibliothèque d'images, nous pouvons lire une image. Le code suivant montre comment lire une image :

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

func main() {
    srcImg, err := imaging.Open("input.jpg")
    if err != nil {
        panic(err)
    }
}

2. Créer une image dégradée

Ensuite, nous pouvons utiliser la fonction New de la bibliothèque d'imagerie pour créer une nouvelle image comme image cible pour l'effet dégradé. Le code suivant montre comment créer une image cible et spécifier sa largeur et sa hauteur :

dstImg := imaging.New(800, 600, color.NRGBA{R: 0, G: 0, B: 0, A: 0})

Dans cet exemple, nous créons une image 800x600 de couleur noire (toutes les valeurs RVB sont 0).

3. Effet dégradé

En continuant à utiliser les fonctions de la bibliothèque d'imagerie, nous pouvons mapper tour à tour les couleurs des pixels de l'image source sur l'image cible pour obtenir l'effet dégradé. Le code suivant montre comment obtenir l'effet de dégradé linéaire :

for y := 0; y < srcImg.Bounds().Dy(); y++ {
    for x := 0; x < srcImg.Bounds().Dx(); x++ {
        c := srcImg.At(x, y)
        r, g, b, a := c.RGBA()
        // 根据像素位置和颜色进行渐变计算
        c = color.RGBA{
            R: uint8(x * 255 / srcImg.Bounds().Dx()),
            G: uint8(y * 255 / srcImg.Bounds().Dy()),
            B: uint8(b / 65535 * 255),
            A: uint8(a / 65535 * 255),
        }
        dstImg.Set(x, y, c)
    }
}

4. Enregistrez l'image

Enfin, nous pouvons utiliser la fonction Save de la bibliothèque d'imagerie pour enregistrer l'image cible dans un fichier :

err = imaging.Save(dstImg, "output.jpg")
if err != nil {
    panic(err)
}

De cette façon. , nous avons terminé un traitement du dégradé de couleurs des images.

3. Cartographie des niveaux de gris

En plus des dégradés de couleurs, nous pouvons également convertir une image en niveaux de gris. Le code suivant montre comment implémenter le mappage en niveaux de gris d'une image :

func grayscaleMapping() {
    srcImg, err := imaging.Open("input.jpg")
    if err != nil {
        panic(err)
    }
    
    // 新建一张灰度图像
    dstImg := imaging.New(srcImg.Bounds().Dx(), srcImg.Bounds().Dy(), color.NRGBA{R: 0, G: 0, B: 0, A: 0})
    
    for y := 0; y < srcImg.Bounds().Dy(); y++ {
        for x := 0; x < srcImg.Bounds().Dx(); x++ {
            c := srcImg.At(x, y)
            r, g, b, _ := c.RGBA()
            intensity := (r + g + b) / 3
            // 根据像素灰度值映射为新的颜色
            c = color.RGBA{R: uint8(intensity), G: uint8(intensity), B: uint8(intensity), A: 255}
            dstImg.Set(x, y, c)
        }
    }
    
    err = imaging.Save(dstImg, "output_grayscale.jpg")
    if err != nil {
        panic(err)
    }
}

Le code ci-dessus fait la moyenne de la valeur RVB de chaque pixel de l'image source, puis utilise le résultat comme valeur RVB du nouveau pixel, obtenant ainsi un mappage en niveaux de gris.

Conclusion :

En introduisant la bibliothèque github.com/disintegration/imaging, nous pouvons effectuer diverses opérations de traitement d'image dans le langage Go. Cet article prend comme exemples le dégradé de couleurs et le mappage des niveaux de gris pour donner des exemples de code spécifiques. Les lecteurs peuvent sur cette base effectuer des opérations de traitement d’image plus complexes en fonction de leurs besoins.

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!