Manipulation d'images Golang : comment effectuer la balance des couleurs et la conversion des couleurs sur les images

Opération d'image Golang : Comment effectuer la balance des couleurs et la conversion des couleurs sur des images

Introduction : Dans le domaine du traitement d'image, la balance des couleurs et la conversion des couleurs sont l'une des opérations couramment utilisées. Cet article explique comment utiliser le langage Go pour effectuer la balance des couleurs et la conversion des couleurs des images, et fournit des exemples de code correspondants.

1. Balance des couleurs
La balance des couleurs fait référence au réglage de l'intensité de chaque canal de couleur dans l'image pour rendre la couleur globale de l'image plus uniforme et naturelle. Les algorithmes de balance des couleurs couramment utilisés incluent la balance de la luminosité, la balance des blancs et l’égalisation de l’histogramme.

1. Brightness Balance
   L'équilibre de la luminosité est obtenu en ajustant la répartition de la luminosité de l'image. Voici un exemple de code simple pour obtenir l'équilibre de la luminosité :

package main

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

func brightnessBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    balanceImg := image.NewRGBA(img.Bounds())

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = r * 2
            g = g * 2
            b = b * 2

            balanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return balanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    balanceImg := brightnessBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, balanceImg)
    if err != nil {
        panic(err)
    }
}

Dans le code ci-dessus, nous parcourons chaque pixel de l'image et multiplions la valeur des canaux rouge, vert et bleu de chaque pixel par 2. La luminosité globale est amélioré. En chargeant l'image originale et en enregistrant l'image traitée, nous pouvons obtenir une image aux couleurs équilibrées.

2. Balance des blancs
   La balance des blancs consiste à éliminer les dominantes de couleur dans les images causées par un éclairage inégal. Voici un exemple de code simple pour obtenir la balance des blancs :

package main

import (
    "image"
    "image/color"
    "image/png"
    "math"
    "os"
)

func whiteBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    whiteBalanceImg := image.NewRGBA(img.Bounds())

    var sumR, sumG, sumB float64
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            sumR += math.Log(float64(r))
            sumG += math.Log(float64(g))
            sumB += math.Log(float64(b))
        }
    }
    avgR := math.Exp(sumR / (float64(width * height)))
    avgG := math.Exp(sumG / (float64(width * height)))
    avgB := math.Exp(sumB / (float64(width * height)))

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = uint32(math.Log(float64(r)) * avgR / float64(r))
            g = uint32(math.Log(float64(g)) * avgG / float64(g))
            b = uint32(math.Log(float64(b)) * avgB / float64(b))

            whiteBalanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return whiteBalanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    whiteBalanceImg := whiteBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, whiteBalanceImg)
    if err != nil {
        panic(err)
    }
}

Dans le code ci-dessus, nous calculons la moyenne des valeurs logarithmiques de tous les pixels de l'image et multiplions la valeur logarithmique de chaque pixel par la moyenne. Une opération exponentielle est effectuée pour obtenir la balance des blancs. De même, en chargeant l’image originale et en enregistrant l’image traitée, nous pouvons obtenir l’image équilibrée en blancs.

2. Conversion des couleurs
La conversion des couleurs fait référence à la conversion des couleurs d'un espace colorimétrique en couleurs d'un autre espace colorimétrique. Les conversions de couleurs couramment utilisées incluent RVB vers HSV et RVB vers YUV.

1. Conversion RVB en HSV
   RVB et HSV sont deux espaces colorimétriques courants. RVB est utilisé pour représenter les trois composantes de couleur rouge, vert et bleu, et HSV est utilisé pour représenter les trois attributs de la couleur : teinte, saturation, et la luminosité.

Ce qui suit est un exemple de code simple pour convertir la couleur RVB en couleur HSV :

package main

import (
    "fmt"
    "image/color"
)

func rgbToHsv(r, g, b uint8) (uint16, uint8, uint8) {
    var h, s, v uint16

    max := uint16(r)
    if uint16(g) > max {
        max = uint16(g)
    }
    if uint16(b) > max {
        max = uint16(b)
    }

    min := uint16(r)
    if uint16(g) < min {
        min = uint16(g)
    }
    if uint16(b) < min {
        min = uint16(b)
    }

    v = max
    delta := max - min

    if max != 0 {
        s = uint8(delta) * 255 / uint8(max)
    } else {
        s = 0
    }

    if delta != 0 {
        if max == uint16(r) {
            h = (uint16(g) - uint16(b)) * 60 / delta
            if uint16(g) < uint16(b) {
                h += 360
            }
        } else if max == uint16(g) {
            h = (2 + (uint16(b)-uint16(r))/delta) * 60
        } else {
            h = (4 + (uint16(r)-uint16(g))/delta) * 60
        }
    } else {
        h = 0
    }

    return h, s, uint8(v)
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    h, s, v := rgbToHsv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> HSV(%d, %d, %d)
", r, g, b, h, s, v)
}

Dans le code ci-dessus, nous calculons la composante de couleur HSV correspondante en fonction de la valeur de la composante de couleur RVB grâce à une série de valeurs de calcul. Nous produisons une couleur RVB rouge pur en définissant la valeur du composant RVB sur la valeur maximale du rouge et calculons la couleur HSV correspondante.

2. Conversion RVB en YUV
   YUV est également un espace colorimétrique commun, où Y représente la luminosité et U et V représentent la chrominance. Ce qui suit est un exemple de code simple pour convertir les couleurs RVB en couleurs YUV :

package main

import (
    "fmt"
    "image/color"
)

func rgbToYuv(r, g, b uint8) (uint8, uint8, uint8) {
    y := uint8(float32(r)*0.299 + float32(g)*0.587 + float32(b)*0.114)
    u := uint8((-float32(r)*0.14713 - float32(g)*0.28886 + float32(b)*0.436 + 128) / 2)
    v := uint8((float32(r)*0.615 + float32(g)*0.51499 - float32(b)*0.10001 + 128) / 2)
    return y, u, v
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    y, u, v := rgbToYuv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> YUV(%d, %d, %d)
", r, g, b, y, u, v)
}

Dans le code ci-dessus, nous calculons les valeurs des composants de couleur YUV correspondantes grâce à une série de calculs basés sur les valeurs des composants de couleur RVB. . De même, nous produisons une couleur RVB rouge pur en définissant la valeur du composant RVB sur la valeur maximale du rouge et calculons la couleur YUV correspondante.

Conclusion : cet article présente la méthode de balance des couleurs et de conversion des couleurs des images à l'aide du langage Go, et fournit des exemples de code correspondants. J'espère que les lecteurs auront une compréhension plus approfondie des opérations sur les images Golang grâce à cet article et pourront l'appliquer à des projets réels.

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!