Golangs Methode zur Bildsegmentierung und Inhaltserkennung

Golangs Methode zur Bildsegmentierung und Inhaltserkennung

Mit der Weiterentwicklung der künstlichen Intelligenz und der Computer-Vision-Technologie spielen Bildsegmentierung und Inhaltserkennung in verschiedenen Bereichen eine immer wichtigere Rolle. In diesem Artikel wird erläutert, wie Sie mit Golang Bildsegmentierung und Inhaltserkennung erreichen, und es werden Codebeispiele bereitgestellt.

Bevor wir beginnen, müssen wir mehrere notwendige Go-Pakete installieren. Zuerst müssen wir „github.com/otiai10/gosseract/v2“ installieren, eine Golang-Bibliothek zur Texterkennung. Zweitens müssen wir auch „gonum.org/v1/gonum/mat“ installieren, eine Golang-Bibliothek für Matrixoperationen. Zur Installation können Sie den folgenden Befehl verwenden:

go get github.com/otiai10/gosseract/v2
go get -u gonum.org/v1/gonum/...

Als nächstes implementieren wir die Bildsegmentierung und Inhaltserkennung durch die folgenden Schritte.

Schritt 1: Lesen Sie das Bild und verarbeiten Sie es in Graustufen.

Zuerst müssen wir das Bild aus der Datei lesen und es in ein Graustufenbild konvertieren. Das Codebeispiel lautet wie folgt:

package main

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

func main() {
    file, err := os.Open("image.jpg")
    if err != nil {
        fmt.Println("图片读取失败：", err)
        return
    }
    defer file.Close()

    img, err := jpeg.Decode(file)
    if err != nil {
        fmt.Println("图片解码失败：", err)
        return
    }

    gray := image.NewGray(img.Bounds())
    for x := gray.Bounds().Min.X; x < gray.Bounds().Max.X; x++ {
        for y := gray.Bounds().Min.Y; y < gray.Bounds().Max.Y; y++ {
            r, g, b, _ := img.At(x, y).RGBA()
            grayColor := color.Gray{(r + g + b) / 3}
            gray.Set(x, y, grayColor)
        }
    }
}

In diesem Code öffnen und lesen wir zunächst ein Bild mit dem Namen „image.jpg“. Anschließend dekodieren wir das Bild mithilfe der Funktion „jpeg.Decode“ in ein Bildobjekt. Als nächstes haben wir ein neues Graustufenbildobjekt „Gray“ erstellt und eine Doppelschleife verwendet, um das Originalbild in Graustufen umzuwandeln.

Schritt 2: Segmentieren Sie das Bild

Nachdem wir das Graustufenbild erhalten haben, können wir einige Bildverarbeitungsalgorithmen verwenden, um das Bild zu segmentieren. Hier verwenden wir den OTSU-Algorithmus zur Schwellenwertsegmentierung. Das Codebeispiel lautet wie folgt:

package main

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

func main() {
    // ...

    // 分割图片
    bounds := gray.Bounds()
    threshold := otsu(gray) // OTSU算法获取阈值
    binary := image.NewGray(bounds)
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            if gray.GrayAt(x, y).Y > threshold {
                binary.Set(x, y, color.Gray{255})
            } else {
                binary.Set(x, y, color.Gray{0})
            }
        }
    }
}

// OTSU算法计算阈值
func otsu(img *image.Gray) uint32 {
    var hist [256]int
    bounds := img.Bounds()
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            hist[img.GrayAt(x, y).Y]++
        }
    }

    total := bounds.Max.X * bounds.Max.Y
    var sum float64
    for i := 0; i < 256; i++ {
        sum += float64(i) * float64(hist[i])
    }
    var sumB float64
    wB := 0
    wF := 0
    var varMax float64
    threshold := 0

    for t := 0; t < 256; t++ {
        wB += hist[t]
        if wB == 0 {
            continue
        }
        wF = total - wB
        if wF == 0 {
            break
        }
        sumB += float64(t) * float64(hist[t])

        mB := sumB / float64(wB)
        mF := (sum - sumB) / float64(wF)

        var between float64 = float64(wB) * float64(wF) * (mB - mF) * (mB - mF)
        if between >= varMax {
            threshold = t
            varMax = between
        }
    }

    return uint32(threshold)
}

In diesem Code definieren wir eine Funktion namens „otsu“, um den Schwellenwert des OTSU-Algorithmus zu berechnen. Anschließend verwenden wir diese Funktion in der „Haupt“-Funktion, um den Schwellenwert zu ermitteln. Als nächstes erstellen wir ein neues Binärbild „binary“ und segmentieren das Graustufenbild mithilfe einer Doppelschleife mit einem Schwellenwert.

Schritt 3: Inhaltsidentifizierung

Nach der Segmentierung des Bildes können wir die „gosseract“-Bibliothek verwenden, um den Inhalt jedes Bereichs zu identifizieren. Das Codebeispiel lautet wie folgt:

package main

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

    "github.com/otiai10/gosseract/v2"
)

func main() {
    // ...

    client := gosseract.NewClient()
    defer client.Close()

    texts := make([]string, 0)
    bounds := binary.Bounds()
    for x := bounds.Min.X; x < bounds.Max.X; x++ {
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            if binary.GrayAt(x, y).Y == 255 {
                continue
            }
            sx := x
            sy := y
            ex := x
            ey := y
            for ; ex < bounds.Max.X && binary.GrayAt(ex, y).Y == 0; ex++ {
            }
            for ; ey < bounds.Max.Y && binary.GrayAt(x, ey).Y == 0; ey++ {
            }
            rect := image.Rect(sx, sy, ex, ey)
            subImg := binary.SubImage(rect)

            pix := subImg.Bounds().Max.X * subImg.Bounds().Max.Y
            blackNum := 0
            for i := subImg.Bounds().Min.X; i < subImg.Bounds().Max.X; i++ {
                for j := subImg.Bounds().Min.Y; j < subImg.Bounds().Max.Y; j++ {
                    if subImg.At(i, j) == color.Gray{255} {
                        blackNum++
                    }
                }
            }
            if float64(blackNum)/float64(pix) < 0.1 { // 去除噪音
                continue
            }

            output, _ := client.ImageToText(subImg)
            output = strings.ReplaceAll(output, "
", "")
            output = strings.ReplaceAll(output, " ", "")
            texts = append(texts, output)
        }
    }

    fmt.Println(texts)
}

In diesem Code verwenden wir die Funktionen „NewClient“ und „Close“ in der „gosseract“-Bibliothek, um den Erkennungsclient zu erstellen und zu schließen. Anschließend verwenden wir eine Doppelschleife, um die segmentierten Binärbilder zu durchlaufen. Für nicht weiße Bereiche ermitteln wir den Koordinatenbereich des Bereichs und wandeln ihn in ein Unterbild um. Als nächstes berechnen wir den Anteil der schwarzen Pixel im Teilbild, um Rauschen zu entfernen. Abschließend wandeln wir das Unterbild über die Funktion „ImageToText“ in Text um und speichern das Ergebnis im Array „texts“.

Durch die oben genannten Schritte haben wir die Methode zur Verwendung von Golang zur Bildsegmentierung und Inhaltserkennung abgeschlossen. Sie können den Code entsprechend Ihren eigenen Anforderungen ändern und optimieren, um ihn an verschiedene Szenarien und Anforderungen anzupassen. Ich hoffe, dieser Artikel kann Ihnen dabei helfen, Bildsegmentierungs- und Inhaltserkennungstechnologie zu verstehen und anzuwenden.

Das obige ist der detaillierte Inhalt vonGolangs Methode zur Bildsegmentierung und Inhaltserkennung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!