Comment utiliser Golang pour égaliser la luminosité et décolorer les images

Comment utiliser Golang pour égaliser la luminosité et décolorer les images

1. Contexte

Avec le développement de la technologie de traitement d'image, il est devenu une exigence courante d'égaliser la luminosité et de décolorer les images. L'égalisation de la luminosité fait référence au réglage de la luminosité d'une image dans une plage appropriée pour améliorer l'effet visuel de l'image. Le processus de décoloration supprime les informations de couleur de l'image et conserve uniquement les informations d'échelle de gris, qui sont utilisées pour certains scénarios d'application spéciaux.

Cet article expliquera comment utiliser le langage de programmation Golang pour obtenir une égalisation de la luminosité et une décoloration des images.

2. Balance de luminosité

Le but de la balance de luminosité est d'ajuster la plage de luminosité de l'image des extrêmes les plus sombres ou les plus lumineux à une plage appropriée. Un algorithme courant d’égalisation de la luminosité est l’égalisation de l’histogramme.

Ce qui suit est un exemple de code qui montre comment utiliser Golang pour implémenter l'algorithme d'égalisation d'histogramme :

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)
    }

    // 创建一个新的灰度图像
    bounds := img.Bounds()
    gray := image.NewGray(bounds)

    // 计算每个灰度级的像素个数
    count := make([]int, 256)
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            grayColor := color.GrayModel.Convert(img.At(x, y)).(color.Gray)
            count[grayColor.Y]++
        }
    }

    // 计算累积分布函数
    cdf := make([]int, 256)
    cdf[0] = count[0]
    for i := 1; i < 256; i++ {
        cdf[i] = cdf[i-1] + count[i]
    }

    // 将累积分布函数映射到[0, 255]的范围
    for i := 0; i < 256; i++ {
        cdf[i] = cdf[i] * 255 / (bounds.Dx() * bounds.Dy())
    }

    // 对每个像素进行亮度均衡化处理
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            grayColor := color.GrayModel.Convert(img.At(x, y)).(color.Gray)
            grayColor.Y = uint8(cdf[grayColor.Y])
            gray.Set(x, y, grayColor)
        }
    }

    // 保存处理后的图像
    outputFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    err = jpeg.Encode(outputFile, gray, nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dans le code ci-dessus, nous ouvrons d'abord un fichier image, puis le décodons en un objet image. Ensuite, nous créons un nouvel objet image en niveaux de gris et comptons le nombre de pixels à chaque niveau de gris dans l'image d'origine. Ensuite, nous avons calculé la fonction de distribution cumulative et l'avons mappée à la plage [0, 255]. Enfin, nous effectuons une égalisation de la luminosité sur chaque pixel et sauvegardons l'image traitée.

3. Décoloration

La décoloration supprime les informations de couleur de l'image et ne conserve que les informations en niveaux de gris. Voici un exemple de code qui montre comment utiliser Golang pour implémenter la décoloration :

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)
    }

    // 创建一个新的灰度图像
    bounds := img.Bounds()
    gray := image.NewGray(bounds)

    // 对每个像素进行去色处理
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            grayColor := color.GrayModel.Convert(img.At(x, y)).(color.Gray)
            grayColor.Y = uint8(grayColor.Y)
            gray.Set(x, y, grayColor)
        }
    }

    // 保存处理后的图像
    outputFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    err = jpeg.Encode(outputFile, gray, nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dans le code ci-dessus, nous utilisons la même méthode pour ouvrir et décoder un fichier image, et créer un nouvel objet image en niveaux de gris. Ensuite, nous décolorons chaque pixel, c'est-à-dire que nous définissons les informations de couleur du pixel sur les informations d'échelle de gris du pixel. Enfin, nous sauvegardons l'image traitée.

4. Résumé

Cet article explique comment utiliser Golang pour obtenir une égalisation de la luminosité et une décoloration des images. Grâce à l'algorithme d'égalisation de l'histogramme et à l'algorithme de traitement de décoloration, nous pouvons ajuster efficacement la luminosité de l'image et supprimer les informations de couleur de l'image. L'utilisation de Golang pour implémenter des fonctions de traitement d'image peut traiter rapidement et efficacement de grandes quantités de données d'image pour répondre aux besoins de divers scénarios d'application pratiques. J'espère que cet article pourra aider les lecteurs à comprendre et à appliquer les algorithmes 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!