Parlons de la façon de comparer les couleurs dans Golang

Golang est un langage de programmation open source développé par Google et est largement utilisé dans le développement Web, le cloud computing, le traitement du Big Data et d'autres domaines. Dans Golang, le traitement des images est une tâche très courante, et le traitement des couleurs des images est également un travail important. Cet article explique comment comparer les couleurs dans Golang.

1. Représentation de la couleur

Dans Golang, les méthodes de représentation de la couleur couramment utilisées sont la valeur RVB et la valeur hexadécimale. La valeur RVB (Rouge, Vert, Bleu) fait référence à la valeur des trois couleurs primaires, généralement exprimée sous la forme de trois nombres entiers (0~255) :

type RGB struct {
    R, G, B uint8
}

la valeur hexadécimale est la valeur de la couleur exprimée en hexadécimal, généralement exprimée sous la forme d'un six- chaîne de chiffres (telle que "#FFFFFF" signifie blanc) :

type Hex struct {
    R, G, B uint8
}

De plus, il existe également une méthode de représentation des couleurs appelée valeur HSV (Teinte, Saturation, Valeur), qui est une méthode de représentation des couleurs relativement intuitive, mais dans cet article Sans autre introduction.

2. Comparaison des couleurs

La comparaison de la similitude de deux couleurs peut généralement être obtenue en calculant leur distance. Dans Golang, nous pouvons utiliser la distance euclidienne ou la distance de Manhattan pour calculer la distance entre les couleurs.

La distance euclidienne fait référence à la distance en ligne droite entre deux points :

func euclideanDistance(c1, c2 RGB) float64 {
    r := float64(c1.R) - float64(c2.R)
    g := float64(c1.G) - float64(c2.G)
    b := float64(c1.B) - float64(c2.B)
    return math.Sqrt(r*r + g*g + b*b)
}

La distance de Manhattan fait référence à la somme des distances entre deux points dans les directions horizontale et verticale :

func manhattanDistance(c1, c2 RGB) float64 {
    r := math.Abs(float64(c1.R) - float64(c2.R))
    g := math.Abs(float64(c1.G) - float64(c2.G))
    b := math.Abs(float64(c1.B) - float64(c2.B))
    return r + g + b
}

Bien sûr, nous pouvons également appliquer la fonction ci-dessus à la représentation des couleurs de la valeur hexadécimale :

func euclideanDistance(c1, c2 Hex) float64 {
    r1, g1, b1 := hexToRGB(c1)
    r2, g2, b2 := hexToRGB(c2)
    r := float64(r1) - float64(r2)
    g := float64(g1) - float64(g2)
    b := float64(b1) - float64(b2)
    return math.Sqrt(r*r + g*g + b*b)
}

func manhattanDistance(c1, c2 Hex) float64 {
    r1, g1, b1 := hexToRGB(c1)
    r2, g2, b2 := hexToRGB(c2)
    r := math.Abs(float64(r1) - float64(r2))
    g := math.Abs(float64(g1) - float64(g2))
    b := math.Abs(float64(b1) - float64(b2))
    return r + g + b
}

func hexToRGB(c Hex) (uint8, uint8, uint8) {
    return c.R, c.G, c.B
}

3. Application du contraste des couleurs

Le contraste des couleurs est souvent utilisé dans des scénarios tels que le remplacement des couleurs et l'analyse des couleurs dans le traitement d'image. Par exemple, nous pouvons remplacer une certaine couleur par une autre couleur grâce à la fonction de remplacement de couleur :

func replaceColor(img image.Image, oldColor, newColor RGB, threshold float64) image.Image {
    bounds := img.Bounds()
    out := image.NewRGBA(bounds)
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            pixel := img.At(x, y)
            c := RGBModel.Convert(pixel).(RGB)
            distance := euclideanDistance(c, oldColor)
            if distance <= threshold {
                out.Set(x, y, newColor)
            } else {
                out.Set(x, y, pixel)
            }
        }
    }
    return out
}

Nous pouvons également utiliser la fonction d'analyse des couleurs pour trouver les pixels d'une couleur spécifique dans une image et compter leur nombre :

func getColorCount(img image.Image, color RGB, threshold float64) int {
    bounds := img.Bounds()
    count := 0
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            pixel := img.At(x, y)
            c := RGBModel.Convert(pixel).(RGB)
            distance := euclideanDistance(c, color)
            if distance <= threshold {
                count++
            }
        }
    }
    return count
}

4. Résumé

Cet article explique comment comparer les couleurs dans Golang et comment appliquer la fonction de contraste des couleurs pour le traitement de l'image. Le contraste des couleurs est une technologie importante dans le traitement de l’image, et sa maîtrise est d’une grande importance pour améliorer l’efficacité et la précision du traitement de l’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!