Comment coloriser et séparer les tons des images à l'aide de Golang

Comment utiliser Golang pour colorer et tonifier des images séparées

Résumé : Cet article explique comment utiliser le langage de programmation Golang pour colorer et tonifier des images séparées. Nous utiliserons la bibliothèque de traitement d'image de Golang pour implémenter ces fonctions et démontrerons le processus d'implémentation spécifique à travers des exemples de code.

1. Introduction
   Dans les applications modernes de traitement d'images, le traitement des couleurs et la séparation des tons des images sont des exigences courantes. Le traitement des couleurs peut rendre la couleur de l'image plus vive et plus vive, tandis que la séparation des tons peut séparer les couleurs de l'image, lui donnant un aspect plus artistique. En tant que langage de programmation concis et performant, Golang fournit une riche bibliothèque de traitement d'images qui peut être utilisée pour implémenter ces fonctions.
2. Utilisez Golang pour colorer les images
   Le traitement des couleurs signifie changer la couleur de l'image, modifiant ainsi le ton général de l'image. Dans Golang, vous pouvez utiliser le package image pour effectuer des opérations de traitement d'image. Ce qui suit est un exemple de code simple qui montre comment utiliser Golang pour mettre en niveaux de gris une image :

package main

import (
    "image"
    "image/color"
    "image/jpeg"
    "log"
    "os"
)

func main() {
    // 打开图片文件
    file, err := os.Open("input.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // 解码图片
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 创建一个新的灰度化图片
    grayImg := image.NewGray(img.Bounds())

    // 遍历图片像素，将每个像素灰度化
    for x := 0; x < img.Bounds().Max.X; x++ {
        for y := 0; y < img.Bounds().Max.Y; y++ {
            c := img.At(x, y)
            gray := color.GrayModel.Convert(c)
            grayImg.Set(x, y, gray)
        }
    }

    // 保存灰度化后的图片
    outFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outFile.Close()
    jpeg.Encode(outFile, grayImg, nil)
}

Dans le code ci-dessus, nous ouvrons d'abord un fichier image nommé input.jpg via la fonction Open du package os. Utilisez ensuite la fonction Decode du package jpeg pour décoder l'image et obtenir un objet image.Image. Ensuite, nous créons une nouvelle image en niveaux de gris à l’aide de la fonction NewGray du package image. Utilisez ensuite une double boucle pour parcourir les pixels de l'image d'origine, calculez la valeur en niveaux de gris correspondante via la valeur de couleur du pixel et définissez-la comme valeur de pixel de la nouvelle image en niveaux de gris. Enfin, utilisez la fonction Encode du package jpeg pour enregistrer l'image en niveaux de gris dans le fichier output.jpg.

3. Utilisez Golang pour séparer les images par tons
   La séparation des tons fait référence à la séparation des couleurs de l'image pour former un effet artistique. Dans Golang, la séparation des teintes peut être obtenue à l'aide de la fonction de conversion des couleurs du package image/couleur. Voici un exemple de code qui montre comment séparer les tons d'une image à l'aide de Golang :

package main

import (
    "image"
    "image/color"
    "image/jpeg"
    "log"
    "os"
)

func main() {
    // 打开图片文件
    file, err := os.Open("input.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // 解码图片
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 创建一个新的彩色图片
    colorImg := image.NewRGBA(img.Bounds())

    // 遍历图片像素，将每个像素的R、G、B颜色值分离出来
    for x := 0; x < img.Bounds().Max.X; x++ {
        for y := 0; y < img.Bounds().Max.Y; y++ {
            c := img.At(x, y)
            r, g, b, _ := c.RGBA()
            colorImg.Set(x, y, color.RGBA{R: uint8(r), G: 0, B: 0})
        }
    }

    // 保存分离后的图片
    outFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outFile.Close()
    jpeg.Encode(outFile, colorImg, nil)
}

Dans le code ci-dessus, nous avons utilisé la fonction RGBA du package image/color pour séparer les valeurs de couleur des pixels de l'image d'origine et créer a Nouvelles images couleur. Ensuite, en parcourant les pixels de l'image originale, les valeurs de couleur R, V et B de chaque pixel sont séparées et les valeurs de G et B sont définies sur 0, réalisant ainsi l'opération de séparation de teinte du image. Enfin, utilisez la fonction Encode du package jpeg pour enregistrer l'image séparée dans le fichier output.jpg.

4. Conclusion
   Cet article explique comment utiliser Golang pour colorer et tonifier des images séparées. En utilisant la bibliothèque de traitement d'image de Golang, nous pouvons facilement implémenter ces fonctions, et le code est concis et efficace. Les lecteurs peuvent étendre et optimiser davantage ces exemples de codes en fonction de leurs propres besoins pour mettre en œuvre des opérations de traitement d'image plus complexes.

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!