Traitement d'images Golang : comment effectuer la détection de coque convexe et l'ajustement des contours des images

Traitement d'images Golang : Comment effectuer une détection de coque convexe et un ajustement des contours d'images

Résumé : Le traitement d'images est l'une des directions de recherche importantes dans le domaine de la vision par ordinateur. Cet article expliquera comment utiliser Golang pour la détection de coque convexe et l'ajustement des contours des images, et fournira des exemples de code pertinents.

Introduction : Le traitement d'image est l'une des applications importantes dans le domaine de la vision par ordinateur. Dans le processus de traitement d'image, la détection de coque convexe et l'ajustement de contour sont des opérations très courantes et peuvent être utilisées pour la reconnaissance de cibles, la détection de bords et d'autres applications. Cet article se concentrera sur la façon d'utiliser Golang pour la détection de coque convexe et l'ajustement des contours des images.

Première partie : Détection de coque convexe

La coque convexe est un polygone convexe minimum qui contient tous les points. En traitement d'image, nous pouvons utiliser une coque convexe pour identifier la forme de la cible et effectuer des opérations telles que le positionnement et la segmentation de la cible. Voici un exemple de code simple :

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "image/jpeg"
    "log"
    "os"

    "github.com/disintegration/imaging"
    "github.com/llgcode/draw2d/draw2dimg"
    "github.com/nfnt/resize"
)

func ConvexHullDetection(inputPath, outputPath string) {
    // 加载图像
    inputImg, err := imaging.Open(inputPath)
    if err != nil {
        log.Fatal(err)
    }

    // 将图像大小调整为指定尺寸
    resizedImg := resize.Resize(800, 0, inputImg, resize.Lanczos3)

    // 将图像转换为灰度图
    grayImg := imaging.Grayscale(resizedImg)

    // 二值化处理
    binaryImg := imaging.AdjustContrast(grayImg, 20)

    // 构建图像的矩形区域
    rectangle := image.Rect(0, 0, binaryImg.Bounds().Size().X, binaryImg.Bounds().Size().Y)

    // 创建画布
    canvas := image.NewRGBA(rectangle)
    draw.Draw(canvas, canvas.Bounds(), binaryImg, image.Point{}, draw.Src)

    // 构建凸包路径
    path := draw2dimg.NewGraphicsPath()

    // 遍历每个像素点
    bounds := binaryImg.Bounds()
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            // 获取像素值
            r, _, _, _ := canvas.At(x, y).RGBA()

            // 如果像素为黑色，则添加到凸包路径中
            if r < 65535/2 {
                path.LineTo(float64(x), float64(y))
            }
        }
    }

    // 进行凸包检测
    path.Close()
    hull := path.ConvexHull()

    // 绘制凸包
    context := draw2dimg.NewGraphicContext(canvas)
    context.SetStrokeColor(color.RGBA{R: 255, G: 0, B: 0, A: 255})
    context.SetLineWidth(2)
    for _, point := range hull {
        context.LineTo(float64(point.X), float64(point.Y))
    }
    context.Stroke()

    // 保存图像
    outputFile, err := os.Create(outputPath)
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    err = jpeg.Encode(outputFile, canvas, &jpeg.Options{Quality: 100})
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    inputPath := "input.jpg"
    outputPath := "output.jpg"
    ConvexHullDetection(inputPath, outputPath)
    fmt.Println("凸包检测完成！")
}

Analyse du code :

1. Tout d'abord, nous utilisons la bibliothèque d'imagerie pour charger l'image et redimensionner l'image à la taille spécifiée.
2. Ensuite, nous convertissons l'image en niveaux de gris puis la binarisons.
3. Créez une toile et dessinez l'image binarisée sur la toile.
4. Construisez un chemin de coque convexe et parcourez chaque pixel de l'image. Si le pixel est noir, ajoutez-le au chemin de coque convexe.
5. Enfin, effectuez la détection de coque convexe et dessinez la coque convexe, en enregistrant le résultat sous forme de fichier image.

Partie 2 : Ajustement du contour

L'ajustement du contour consiste à ajuster le bord de la cible pour obtenir la forme géométrique de la cible. Voici un exemple de code simple :

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "image/jpeg"
    "log"
    "os"

    "github.com/disintegration/imaging"
    "github.com/llgcode/draw2d/draw2dimg"
    "github.com/nfnt/resize"
)

func ContourFitting(inputPath, outputPath string) {
    // 加载图像
    inputImg, err := imaging.Open(inputPath)
    if err != nil {
        log.Fatal(err)
    }

    // 将图像大小调整为指定尺寸
    resizedImg := resize.Resize(800, 0, inputImg, resize.Lanczos3)

    // 将图像转换为灰度图
    grayImg := imaging.Grayscale(resizedImg)

    // 二值化处理
    binaryImg := imaging.AdjustContrast(grayImg, 20)

    // 构建图像的矩形区域
    rectangle := image.Rect(0, 0, binaryImg.Bounds().Size().X, binaryImg.Bounds().Size().Y)

    // 创建画布
    canvas := image.NewRGBA(rectangle)
    draw.Draw(canvas, canvas.Bounds(), binaryImg, image.Point{}, draw.Src)

    // 构建轮廓路径
    path := draw2dimg.NewGraphicsPath()

    // 遍历每个像素点
    bounds := binaryImg.Bounds()
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            // 获取像素值
            r, _, _, _ := canvas.At(x, y).RGBA()

            // 如果像素为黑色，则添加到轮廓路径中
            if r < 65535/2 {
                path.LineTo(float64(x), float64(y))
            }
        }
    }

    // 进行轮廓拟合
    fitting := path.FitPath(5)

    // 绘制轮廓
    context := draw2dimg.NewGraphicContext(canvas)
    context.SetStrokeColor(color.RGBA{R: 255, G: 0, B: 0, A: 255})
    context.SetLineWidth(2)
    for _, bezier := range fitting {
        context.CubicBezierTo(
            float64(bezier.Control1.X), float64(bezier.Control1.Y),
            float64(bezier.Control2.X), float64(bezier.Control2.Y),
            float64(bezier.To.X), float64(bezier.To.Y))
    }
    context.Stroke()

    // 保存图像
    outputFile, err := os.Create(outputPath)
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    err = jpeg.Encode(outputFile, canvas, &jpeg.Options{Quality: 100})
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    inputPath := "input.jpg"
    outputPath := "output.jpg"
    ContourFitting(inputPath, outputPath)
    fmt.Println("轮廓拟合完成！")
}

Analyse du code :

1. Semblable à la détection de coque convexe, nous chargeons d'abord l'image et la redimensionnons aux dimensions spécifiées.
2. Convertissez l'image en niveaux de gris et effectuez la binarisation.
3. Créez une toile et dessinez l'image binarisée sur la toile.
4. Construisez un chemin de contour et parcourez chaque pixel de l'image. Si le pixel est noir, ajoutez-le au chemin de contour.
5. Effectuez un ajustement de contour, dessinez le résultat sur la toile et enregistrez-le sous forme de fichier image.

Conclusion :
Cet article présente comment utiliser Golang pour la détection de coque convexe et l'ajustement des contours des images, et fournit des exemples de code pertinents. Le traitement d'images est l'une des applications importantes dans le domaine de la vision par ordinateur. La maîtrise des algorithmes de base du traitement d'images est d'une grande importance pour comprendre et appliquer la technologie de vision par ordinateur. J'espère que cet article pourra aider les lecteurs dans leurs études et recherches dans le domaine 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!