Golang-Bildverarbeitung: So führen Sie die Erkennung konvexer Hüllen und die Konturanpassung von Bildern durch

Golang-Bildverarbeitung: So führen Sie die Erkennung konvexer Hüllen und die Konturanpassung von Bildern durch

Zusammenfassung: Die Bildverarbeitung ist eine der wichtigsten Forschungsrichtungen im Bereich Computer Vision. In diesem Artikel wird die Verwendung von Golang zur Erkennung konvexer Hüllen und zur Konturanpassung von Bildern vorgestellt und relevante Codebeispiele bereitgestellt.

Einleitung: Die Bildverarbeitung ist eine der wichtigsten Anwendungen im Bereich Computer Vision. Im Bildverarbeitungsprozess sind die Erkennung konvexer Hüllen und die Konturanpassung sehr häufige Vorgänge und können zur Zielerkennung, Kantenerkennung und anderen Anwendungen verwendet werden. Dieser Artikel konzentriert sich auf die Verwendung von Golang zur Erkennung konvexer Hüllen und zur Konturanpassung von Bildern.

Teil Eins: Erkennung konvexer Hüllen

Die konvexe Hülle ist ein minimales konvexes Polygon, das alle Punkte enthält. In der Bildverarbeitung können wir die konvexe Hülle verwenden, um die Form des Ziels zu identifizieren und Vorgänge wie Zielpositionierung und -segmentierung durchzuführen. Hier ist ein einfacher Beispielcode:

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("凸包检测完成！")
}

Codeanalyse:

1. Zuerst verwenden wir die Bildbibliothek, um das Bild zu laden und die Größe des Bildes auf die angegebene Größe zu ändern.
2. Als nächstes konvertieren wir das Bild in Graustufen und digitalisieren es anschließend.
3. Erstellen Sie eine Leinwand und zeichnen Sie das binarisierte Bild auf die Leinwand.
4. Konstruieren Sie einen konvexen Hüllenpfad und durchlaufen Sie jedes Pixel des Bildes. Wenn das Pixel schwarz ist, fügen Sie es dem konvexen Hüllenpfad hinzu.
5. Führen Sie abschließend die Erkennung der konvexen Hülle durch, zeichnen Sie die konvexe Hülle und speichern Sie das Ergebnis als Bilddatei.

Teil 2: Konturanpassung

Bei der Konturanpassung wird der Rand des Ziels angepasst, um die geometrische Form des Ziels zu erhalten. Hier ist ein einfacher Beispielcode:

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("轮廓拟合完成！")
}

Codeanalyse:

1. Ähnlich wie bei der Erkennung konvexer Hüllen laden wir zunächst das Bild und ändern die Größe auf die angegebenen Abmessungen.
2. Konvertieren Sie das Bild in Graustufen und führen Sie die Binarisierung durch.
3. Erstellen Sie eine Leinwand und zeichnen Sie das binarisierte Bild auf die Leinwand.
4. Konstruieren Sie einen Konturpfad und durchlaufen Sie jedes Pixel des Bildes. Wenn das Pixel schwarz ist, fügen Sie es dem Konturpfad hinzu.
5. Führen Sie eine Konturanpassung durch, zeichnen Sie das Ergebnis auf die Leinwand und speichern Sie es als Bilddatei.

Fazit:
In diesem Artikel wird die Verwendung von Golang zur Erkennung konvexer Hüllen und zur Konturanpassung von Bildern vorgestellt und relevante Codebeispiele bereitgestellt. Die Bildverarbeitung ist eine der wichtigsten Anwendungen im Bereich Computer Vision. Die Beherrschung der grundlegenden Algorithmen der Bildverarbeitung ist für das Verständnis und die Anwendung der Computer Vision-Technologie von großer Bedeutung. Ich hoffe, dass dieser Artikel den Lesern bei ihrem Studium und ihrer Forschung im Bereich der Bildverarbeitung helfen kann.

Das obige ist der detaillierte Inhalt vonGolang-Bildverarbeitung: So führen Sie die Erkennung konvexer Hüllen und die Konturanpassung von Bildern durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!