Kaedah Golang untuk melaksanakan pembahagian imej dan pengecaman kandungan

Kaedah Golang untuk mencapai pembahagian imej dan pengecaman kandungan

Dengan kemajuan kecerdasan buatan dan teknologi penglihatan komputer, pembahagian imej dan pengecaman kandungan memainkan peranan yang semakin penting dalam pelbagai bidang. Artikel ini akan memperkenalkan cara menggunakan Golang untuk mencapai pembahagian imej dan pengecaman kandungan, serta disertakan dengan contoh kod.

Sebelum kita mula, kita perlu memasang beberapa pakej Go yang diperlukan. Pertama, kita perlu memasang "github.com/otiai10/gosseract/v2", yang merupakan perpustakaan Golang untuk pengecaman teks. Kedua, kita juga perlu memasang "gonum.org/v1/gonum/mat", yang merupakan perpustakaan Golang untuk operasi matriks. Anda boleh menggunakan arahan berikut untuk memasang:

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

Seterusnya, kami akan melaksanakan pembahagian imej dan pengecaman kandungan melalui langkah berikut.

Langkah 1: Baca imej dan proses dalam skala kelabu

Pertama, kita perlu membaca imej daripada fail dan menukarnya kepada imej skala kelabu. Contoh kod adalah seperti berikut:

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

Dalam kod ini, kita mula-mula membuka dan membaca imej bernama "image.jpg". Kemudian, kami menyahkod gambar menjadi objek imej melalui fungsi "jpeg.Decode". Seterusnya, kami mencipta objek imej skala kelabu baharu "kelabu" dan menggunakan gelung berganda untuk menukar imej asal kepada skala kelabu.

Langkah 2: Bahagikan imej

Selepas mendapatkan imej skala kelabu, kita boleh menggunakan beberapa algoritma pemprosesan imej untuk membahagikan imej. Di sini kami menggunakan algoritma OTSU untuk pembahagian ambang Contoh kod adalah seperti berikut:

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

Dalam kod ini, kami mentakrifkan fungsi bernama "otsu" untuk mengira ambang algoritma OTSU. Kami kemudian menggunakan fungsi ini dalam fungsi "utama" untuk mendapatkan ambang. Seterusnya, kami mencipta imej binari baharu "binari" dan segmen ambang imej skala kelabu menggunakan gelung berganda.

Langkah 3: Pengenalpastian kandungan

Selepas membahagikan imej, kita boleh menggunakan perpustakaan "gosseract" untuk mengenal pasti kandungan setiap kawasan. Contoh kod adalah seperti berikut:

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

Dalam kod ini, kami menggunakan fungsi "NewClient" dan "Close" dalam perpustakaan "gosseract" untuk mencipta dan menutup klien pengecaman. Kami kemudian menggunakan gelung berganda untuk mengulangi imej perduaan tersegmen. Untuk kawasan bukan putih, kami mendapat julat koordinat kawasan itu dan menukarnya menjadi sub-imej. Seterusnya, kami mengira perkadaran piksel hitam dalam sub-imej untuk mengeluarkan bunyi. Akhir sekali, kami menukar subimej kepada teks melalui fungsi "ImageToText" dan menyimpan hasilnya dalam tatasusunan "teks".

Melalui langkah di atas, kami telah melengkapkan kaedah penggunaan Golang untuk mencapai pembahagian imej dan pengecaman kandungan. Anda boleh mengubah suai dan mengoptimumkan kod mengikut keperluan anda sendiri untuk menyesuaikan diri dengan senario dan keperluan yang berbeza. Saya harap artikel ini dapat memberikan sedikit bantuan untuk anda memahami dan menggunakan teknologi pembahagian imej dan pengecaman kandungan.

Atas ialah kandungan terperinci Kaedah Golang untuk melaksanakan pembahagian imej dan pengecaman kandungan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!