Traitement d'image Golang : apprenez à affiner et à détecter les contours des images

Traitement d'images Golang : Apprenez à affiner et à détecter les bords des images

Vue d'ensemble
Dans la vision par ordinateur et le traitement d'images, la netteté et la détection des bords sont l'une des opérations couramment utilisées. Grâce aux opérations de netteté, nous pouvons améliorer les détails et les bords de l’image, rendant ainsi l’image plus claire. La détection des contours peut nous aider à capturer des informations sur les contours des images, ce qui est utile pour l'analyse et l'identification des images. Cet article expliquera comment utiliser Golang pour affiner et détecter les bords des images, et joindra des exemples de code pour votre référence.

Aiguiser l'image
Voyons d'abord comment affiner une image. Dans Golang, nous pouvons utiliser le package image et le package draw pour y parvenir.

Tout d'abord, vous devez utiliser la fonction Open du package image pour ouvrir un fichier image et le décoder en un objet image.Image. Le code est le suivant :

package main

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

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

    // 解码为image.Image对象
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 对图像进行锐化处理
    sharpened := sharpenImage(img)

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

    // 将处理后的图像编码为jpeg格式并保存
    err = jpeg.Encode(output, sharpened, nil)
    if err != nil {
        log.Fatal(err)
    }
}

// 锐化图像
func sharpenImage(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个RGBA图像，用于存储处理后的图像
    sharpened := image.NewRGBA(bounds)

    // 遍历图像的像素点，对每个像素点进行锐化处理
    for x := 1; x < width-1; x++ {
        for y := 1; y < height-1; y++ {
            // 获取周围的像素点
            pixel00 := img.At(x-1, y-1)
            pixel01 := img.At(x-1, y)
            pixel02 := img.At(x-1, y+1)
            pixel10 := img.At(x, y-1)
            pixel11 := img.At(x, y)
            pixel12 := img.At(x, y+1)
            pixel20 := img.At(x+1, y-1)
            pixel21 := img.At(x+1, y)
            pixel22 := img.At(x+1, y+1)

            // 对当前像素点进行锐化计算，可以使用Sobel算子等
            // 这里简化处理，使用当前像素点与周围像素点的平均值作为新的像素值
            r00, g00, b00, _ := pixel00.RGBA()
            r01, g01, b01, _ := pixel01.RGBA()
            r02, g02, b02, _ := pixel02.RGBA()
            r10, g10, b10, _ := pixel10.RGBA()
            r11, g11, b11, _ := pixel11.RGBA()
            r12, g12, b12, _ := pixel12.RGBA()
            r20, g20, b20, _ := pixel20.RGBA()
            r21, g21, b21, _ := pixel21.RGBA()
            r22, g22, b22, _ := pixel22.RGBA()

            avgR := uint8((r00 + r01 + r02 + r10 + r11 + r12 + r20 + r21 + r22) / 9)
            avgG := uint8((g00 + g01 + g02 + g10 + g11 + g12 + g20 + g21 + g22) / 9)
            avgB := uint8((b00 + b01 + b02 + b10 + b11 + b12 + b20 + b21 + b22) / 9)

            newPixel := color.RGBA{avgR, avgG, avgB, 255}

            // 设置锐化后的像素点
            sharpened.Set(x, y, newPixel)
        }
    }

    return sharpened
}

La fonction SharpenImage dans le code implémente la netteté de l'image. Pour chaque pixel, nous pouvons utiliser les pixels environnants (vous pouvez utiliser l'opérateur de Sobel, l'opérateur laplacien, etc.) pour calculer et obtenir une nouvelle valeur de pixel. Dans l’exemple de code, nous prenons simplement la moyenne des pixels environnants comme nouvelle valeur de pixel.

Après avoir exécuté le code, vous obtiendrez une image plus nette. En fonction de vos besoins, vous pouvez utiliser des algorithmes plus complexes pour obtenir des effets de netteté de meilleure qualité.

Détection des contours
Ci-dessous, nous apprendrons comment effectuer une détection des contours sur les images. De même, nous pouvons utiliser le package image et le package draw pour y parvenir.

package main

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

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

    // 解码为image.Image对象
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 对图像进行边缘检测
    edges := detectEdges(img)

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

    // 将处理后的图像编码为jpeg格式并保存
    err = jpeg.Encode(output, edges, nil)
    if err != nil {
        log.Fatal(err)
    }
}

// 边缘检测
func detectEdges(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个灰度图像，用于存储处理后的图像
    gray := image.NewGray(bounds)

    // 将图像转为灰度图像
    draw.Draw(gray, bounds, img, image.Point{}, draw.Src)

    // 创建一个RGBA图像，用于存储边缘检测结果
    edges := image.NewRGBA(bounds)

    // 设置边缘检测的阈值
    threshold := uint32(10000)

    for x := 1; x < width-1; x++ {
        for y := 1; y < height-1; y++ {
            // 获取周围的像素点
            pixel00 := gray.At(x-1, y-1)
            pixel01 := gray.At(x-1, y)
            pixel02 := gray.At(x-1, y+1)
            pixel10 := gray.At(x, y-1)
            pixel11 := gray.At(x, y)
            pixel12 := gray.At(x, y+1)
            pixel20 := gray.At(x+1, y-1)
            pixel21 := gray.At(x+1, y)
            pixel22 := gray.At(x+1, y+1)

            // 对当前像素点进行边缘检测计算
            g00 := luminance(pixel00)
            g01 := luminance(pixel01)
            g02 := luminance(pixel02)
            g10 := luminance(pixel10)
            g11 := luminance(pixel11)
            g12 := luminance(pixel12)
            g20 := luminance(pixel20)
            g21 := luminance(pixel21)
            g22 := luminance(pixel22)

            dx := -(g00 + 2*g10 + g20) + (g02 + 2*g12 + g22)
            dy := -(g00 + 2*g01 + g02) + (g20 + 2*g21 + g22)
            magnitude := math.Sqrt(float64(dx*dx + dy*dy))

            if magnitude > threshold {
                edges.Set(x, y, color.White)
            } else {
                edges.Set(x, y, color.Black)
            }
        }
    }

    return edges
}

// 计算像素的灰度值
func luminance(c color.Color) uint32 {
    r, g, b, _ := c.RGBA()
    return uint32(0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b))
}

Dans l'exemple de code, nous convertissons d'abord l'image couleur en une image en niveaux de gris, puis utilisons l'opérateur Sobel pour calculer la valeur de dégradé du pixel et utilisons la valeur de dégradé pour déterminer si le pixel appartient au bord. Lorsque la valeur du dégradé est supérieure au seuil défini, nous définissons le pixel sur blanc, sinon nous le définissons sur noir.

Après avoir exécuté le code, vous obtiendrez une image après détection des contours. Vous pouvez ajuster des paramètres tels que le seuil pour obtenir de meilleurs résultats de détection des contours.

Résumé
Cet article explique comment utiliser Golang pour effectuer des opérations de netteté d'image et de détection de contours. En comprenant et en mettant en œuvre des algorithmes de netteté et de détection des contours, nous pouvons mieux traiter et analyser les images. J'espère que cet article pourra vous fournir des connaissances et une aide utiles, et vous encourager également à explorer davantage de technologies et d'applications de traitement d'image dans la pratique.

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!