Comment utiliser Golang pour effectuer la restauration des couleurs et le traitement de la balance des blancs sur les images

Comment utiliser Golang pour effectuer la restauration des couleurs et le traitement de la balance des blancs sur les images

Résumé :
Cet article présentera comment utiliser le langage de programmation Golang pour effectuer la restauration des couleurs et le traitement de la balance des blancs sur les images. En utilisant la bibliothèque de traitement d'image de Golang, nous pouvons facilement effectuer diverses opérations sur les images, notamment la restauration des couleurs et la balance des blancs. Cet article vous guide étape par étape tout au long du processus et fournit des exemples de code correspondants.

Introduction :
Dans les tâches de traitement d'images numériques, la restauration des couleurs et la balance des blancs sont deux opérations très courantes. Le but de la restauration des couleurs est d'ajuster la couleur et le contraste d'une image afin qu'elle paraisse plus réaliste et naturelle. La balance des blancs est l’ajustement de la température de couleur d’une image pour lui donner un aspect plus équilibré et naturel. Ces deux opérations sont très importantes pour améliorer l'effet visuel de l'image, et nous pouvons les implémenter en utilisant Golang.

Étape 1 : Importer les bibliothèques et les outils nécessaires
Tout d'abord, nous devons importer la bibliothèque de traitement d'image et la bibliothèque d'opérations de fichiers de Golang.

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

Étape 2 : Charger le fichier image
Ensuite, nous devons charger le fichier image que nous voulons traiter. Nous pouvons y parvenir en utilisant la bibliothèque de manipulation de fichiers de Golang.

func loadImage(filepath string) (image.Image, error) {
    imgFile, err := os.Open(filepath)
    if err != nil {
        return nil, err
    }
    defer imgFile.Close()

    img, err := jpeg.Decode(imgFile)
    if err != nil {
        return nil, err
    }

    return img, nil
}

Étape 3 : Correction des couleurs
Maintenant que le fichier image est chargé, nous pouvons commencer la correction des couleurs. La restauration des couleurs peut être obtenue en ajustant la teinte, la saturation et la luminosité de l'image. Voici un exemple simple qui augmente simplement la valeur du canal rouge de chaque pixel de l'image de 100.

func colorCorrection(img image.Image) image.Image {
    bounds := img.Bounds()
    newImg := image.NewRGBA(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            oldPixel := img.At(x, y)
            r, g, b, a := oldPixel.RGBA()

            // 色调修复
            r += 100

            newPixel := color.RGBA{
                R: uint8(r),
                G: uint8(g),
                B: uint8(b),
                A: uint8(a),
            }

            newImg.Set(x, y, newPixel)
        }
    }

    return newImg
}

Étape 4 : Effectuer le traitement de la balance des blancs
Ensuite, nous pouvons effectuer le traitement de la balance des blancs pour garantir une température de couleur équilibrée dans l'image. Vous trouverez ci-dessous un exemple simple qui échange simplement les valeurs des canaux rouge et bleu pour chaque pixel de l'image.

func whiteBalance(img image.Image) image.Image {
    bounds := img.Bounds()
    newImg := image.NewRGBA(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            oldPixel := img.At(x, y)
            r, g, b, a := oldPixel.RGBA()

            // 白平衡处理
            newPixel := color.RGBA{
                R: uint8(b),
                G: uint8(g),
                B: uint8(r),
                A: uint8(a),
            }

            newImg.Set(x, y, newPixel)
        }
    }

    return newImg
}

Étape 5 : Enregistrez l'image traitée
Enfin, nous devons enregistrer l'image traitée dans un fichier.

func saveImage(filepath string, img image.Image) error {
    outFile, err := os.Create(filepath)
    if err != nil {
        return err
    }
    defer outFile.Close()

    err = jpeg.Encode(outFile, img, nil)
    if err != nil {
        return err
    }

    return nil
}

Intégration des étapes ci-dessus :

func main() {
    // 加载图像
    img, err := loadImage("input.jpg")
    if err != nil {
        panic(err)
    }

    // 进行色彩修复
    correctedImg := colorCorrection(img)

    // 进行白平衡处理
    finalImg := whiteBalance(correctedImg)

    // 保存处理后的图像
    err = saveImage("output.jpg", finalImg)
    if err != nil {
        panic(err)
    }
}

Conclusion :
Dans cet article, nous avons présenté comment corriger les couleurs et équilibrer les blancs des images à l'aide du langage de programmation Golang. En utilisant la bibliothèque de traitement d'image de Golang, vous pouvez facilement implémenter ces deux opérations de traitement d'image courantes. Qu'elles soient utilisées pour des projets personnels ou des applications commerciales, ces opérations peuvent vous aider à améliorer l'impact visuel de vos images. Espérons que cet article vous aidera à comprendre comment effectuer ces opérations dans Golang et vous fournira une assistance pour vos tâches de 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!