Manipulation d'images Golang : découvrez comment effectuer l'égalisation d'histogramme et le seuillage global des images

Opération d'image Golang : Apprenez à effectuer l'égalisation d'histogramme et le seuillage global des images

Introduction :
Le traitement d'image est l'une des tâches importantes dans le domaine de la vision par ordinateur et du traitement d'image. Dans les applications pratiques, nous devons souvent effectuer certaines opérations d'amélioration de l'image pour améliorer la qualité de l'image ou mettre en évidence certaines caractéristiques de l'image. Cet article expliquera comment utiliser Golang pour effectuer des opérations d'égalisation d'histogramme et de seuillage global sur les images afin d'obtenir une amélioration de l'image.

1. Égalisation de l'histogramme
L'égalisation de l'histogramme est une méthode d'amélioration de l'image couramment utilisée. Elle améliore le contraste de l'image en ajustant la répartition des niveaux de gris des pixels de l'image. Dans cette méthode, nous calculons d'abord l'histogramme cumulé de l'image, puis ajustons les valeurs de pixels de l'image en fonction de l'histogramme cumulé.

Ce qui suit est un exemple simple de code Golang pour implémenter l'égalisation d'histogramme d'images :

package main

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

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

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 计算直方图
    hist := histogram(img)

    // 计算累积直方图
    cumHist := cumulativeHistogram(hist)

    // 根据累积直方图对图像进行像素值调整
    newImg := adjustPixels(img, cumHist)

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

    // 编码图像
    err = jpeg.Encode(outFile, newImg, &jpeg.Options{Quality: 100})
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("图像处理完成！")
}

// 计算直方图
func histogram(img image.Image) []int {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    hist := make([]int, 256)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, _, _, _ := img.At(x, y).RGBA()
            gray := color.Gray{uint8(r / 256)}
            hist[gray.Y]++
        }
    }

    return hist
}

// 计算累积直方图
func cumulativeHistogram(hist []int) []int {
    cumHist := make([]int, len(hist))
    cumHist[0] = hist[0]

    for i := 1; i < len(hist); i++ {
        cumHist[i] = cumHist[i-1] + hist[i]
    }

    return cumHist
}

// 根据累积直方图调整像素值
func adjustPixels(img image.Image, cumHist []int) image.Image {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    newImg := image.NewRGBA(bounds)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, g, b, a := img.At(x, y).RGBA()

            gray := color.Gray{uint8(r / 256)}
            val := uint8(float64(cumHist[gray.Y]) / float64(w*h) * 255)

            newImg.Set(x, y, color.RGBA{val, val, val, uint8(a / 256)})
        }
    }

    return newImg
}

Dans le code ci-dessus, nous transmettons d'abord le Decode du package image La fonction décode le fichier image d'entrée en un objet de type image.Image. Ensuite, nous appelons la fonction histogram pour calculer l'histogramme de l'image, et la fonction cumulativeHistogram pour calculer l'histogramme cumulé de l'image. Enfin, nous ajustons les valeurs de pixels de l'image en fonction de l'histogramme cumulé et enregistrons l'image traitée dans un fichier à l'aide de la fonction Encode du package jpeg. image包的Decode函数将输入图像文件解码为image.Image类型的对象。然后，我们分别调用histogram函数计算图像的直方图，cumulativeHistogram函数计算图像的累积直方图。最后，我们根据累积直方图调整图像的像素值，并使用jpeg包的Encode函数将处理后的图像保存到文件中。

二、全局阈值化
全局阈值化是一种简单但有效的图像二值化方法，它将图像的像素值分为两个互不重叠的光滑区域，分别代表目标物体和背景。这种方法通常应用于具有明显的前景和背景差异的图像。

下面是一个简单的Golang代码示例，用于实现图像的全局阈值化：

package main

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

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

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 根据全局阈值对图像进行二值化处理
    newImg := binarize(img)

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

    // 编码图像
    err = jpeg.Encode(outFile, newImg, &jpeg.Options{Quality: 100})
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("图像处理完成！")
}

// 根据全局阈值对图像进行二值化处理
func binarize(img image.Image) image.Image {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    newImg := image.NewRGBA(bounds)

    threshold := calculateThreshold(img)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, g, b, a := img.At(x, y).RGBA()

            gray := color.Gray{uint8(r / 256)}
            var val uint8
            if gray.Y > threshold {
                val = 255
            } else {
                val = 0
            }

            newImg.Set(x, y, color.RGBA{val, val, val, uint8(a / 256)})
        }
    }

    return newImg
}

// 根据图像的直方图计算全局阈值
func calculateThreshold(img image.Image) uint8 {
    hist := histogram(img)
    totalPixels := img.Bounds().Max.X * img.Bounds().Max.Y

    // 计算背景像素值的总和
    var bgSum, bgCount, fgSum, fgCount int
    for i := 0; i < len(hist); i++ {
        if i <= 128 {
            bgSum += i * hist[i]
            bgCount += hist[i]
        } else {
            fgSum += i * hist[i]
            fgCount += hist[i]
        }
    }

    // 计算背景和前景的平均灰度值
    bgMean := bgSum / bgCount
    fgMean := fgSum / fgCount

    // 根据背景和前景的平均灰度值计算阈值
    return uint8((bgMean + fgMean) / 2)
}

// 计算直方图
func histogram(img image.Image) []int {
    bounds := img.Bounds()
    w, h := bounds.Max.X, bounds.Max.Y
    hist := make([]int, 256)

    for y := 0; y < h; y++ {
        for x := 0; x < w; x++ {
            r, _, _, _ := img.At(x, y).RGBA()
            gray := color.Gray{uint8(r / 256)}
            hist[gray.Y]++
        }
    }

    return hist
}

在上述代码中，我们首先通过image包的Decode函数将输入图像文件解码为image.Image类型的对象。然后，我们调用calculateThreshold函数计算图像的全局阈值。最后，我们根据全局阈值将图像进行二值化处理，并使用jpeg包的Encode

2. Seuil global

Le seuil global est une méthode de binarisation d'image simple mais efficace. Elle divise la valeur en pixels de l'image en deux zones lisses qui ne se chevauchent pas, représentant respectivement l'objet cible et l'arrière-plan. Cette méthode est généralement appliquée aux images présentant des différences nettes au premier plan et à l’arrière-plan.

Ce qui suit est un exemple simple de code Golang pour le seuillage global des images : 🎜rrreee🎜Dans le code ci-dessus, nous passons d'abord la fonction Decode du package image Décoder le fichier image d'entrée dans un objet de type image.Image. Ensuite, nous appelons la fonction calculateThreshold pour calculer le seuil global de l'image. Enfin, nous binarisons l'image en fonction du seuil global et enregistrons l'image traitée dans un fichier à l'aide de la fonction Encode du package jpeg. 🎜🎜Résumé : 🎜Dans cet article, nous avons présenté comment utiliser Golang pour effectuer des opérations d'égalisation d'histogramme et de seuillage global sur les images. L'égalisation de l'histogramme peut être utilisée pour améliorer le contraste de l'image, rendant l'image plus claire et plus distincte ; un seuillage global peut être utilisé pour convertir l'image en une image binaire afin de mettre en évidence les objets cibles dans l'image. En utilisant de manière flexible ces deux méthodes, nous pouvons réaliser une amélioration de l’image et une extraction de fonctionnalités pour répondre à divers besoins d’applications. Dans les applications pratiques, nous pouvons combiner avec d’autres algorithmes de traitement d’image pour améliorer encore l’effet et la qualité du 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!