Méthode Golang de segmentation d'images et de reconnaissance de contenu

La méthode de Golang pour réaliser la segmentation d'images et la reconnaissance de contenu

Avec les progrès de l'intelligence artificielle et de la technologie de vision par ordinateur, la segmentation d'images et la reconnaissance de contenu jouent un rôle de plus en plus important dans divers domaines. Cet article expliquera comment utiliser Golang pour réaliser la segmentation d'images et la reconnaissance de contenu, et sera accompagné d'exemples de code.

Avant de commencer, nous devons installer plusieurs packages Go nécessaires. Tout d'abord, nous devons installer "github.com/otiai10/gosseract/v2", qui est une bibliothèque Golang pour la reconnaissance de texte. Deuxièmement, nous devons également installer "gonum.org/v1/gonum/mat", qui est une bibliothèque Golang pour les opérations matricielles. Vous pouvez utiliser la commande suivante pour installer :

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

Ensuite, nous mettrons en œuvre la segmentation d'image et la reconnaissance de contenu à travers les étapes suivantes.

Étape 1 : Lire l'image et la traiter en niveaux de gris

Tout d'abord, nous devons lire l'image à partir du fichier et la convertir en image en niveaux de gris. L'exemple de code est le suivant :

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)
        }
    }
}

Dans ce code, nous ouvrons et lisons d'abord une image nommée "image.jpg". Ensuite, nous décodons l'image en un objet image via la fonction "jpeg.Decode". Ensuite, nous avons créé un nouvel objet image en niveaux de gris "gris" et utilisé une double boucle pour convertir l'image originale en niveaux de gris.

Étape 2 : Segmenter l'image

Après avoir obtenu l'image en niveaux de gris, nous pouvons utiliser certains algorithmes de traitement d'image pour segmenter l'image. Ici, nous utilisons l'algorithme OTSU pour la segmentation de seuil. L'exemple de code est le suivant :

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)
}

Dans ce code, nous définissons une fonction nommée "otsu" pour calculer le seuil de l'algorithme OTSU. On utilise ensuite cette fonction dans la fonction "main" pour obtenir le seuil. Ensuite, nous créons une nouvelle image binaire "binaire" et segmentons l'image en niveaux de gris à l'aide d'une double boucle.

Étape 3 : Identification du contenu

Après avoir segmenté l'image, nous pouvons utiliser la bibliothèque "gosseract" pour identifier le contenu de chaque zone. L'exemple de code est le suivant :

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)
}

Dans ce code, nous utilisons les fonctions "NewClient" et "Close" de la bibliothèque "gosseract" pour créer et fermer le client de reconnaissance. Nous utilisons ensuite une double boucle pour parcourir les images binaires segmentées. Pour les zones non blanches, nous obtenons la plage de coordonnées de la zone et la convertissons en sous-image. Ensuite, nous calculons la proportion de pixels noirs dans la sous-image pour supprimer le bruit. Enfin, nous convertissons la sous-image en texte via la fonction "ImageToText" et enregistrons le résultat dans le tableau "textes".

Grâce aux étapes ci-dessus, nous avons complété la méthode d'utilisation de Golang pour réaliser la segmentation d'images et la reconnaissance de contenu. Vous pouvez modifier et optimiser le code en fonction de vos propres besoins pour vous adapter à différents scénarios et besoins. J'espère que cet article pourra vous aider à comprendre et à appliquer la technologie de segmentation d'images et de reconnaissance de contenu.

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!