Manipulasi imej Golang: pelajari cara ambang dan denoise imej

Pengendalian Imej Golang: Ketahui cara ambang dan denoise imej

Pengenalan
Dalam bidang pemprosesan imej dan penglihatan komputer, ambang dan denoising adalah operasi pemprosesan imej biasa. Artikel ini akan memperkenalkan cara menggunakan Golang untuk mengambang dan mengecilkan imej serta memberikan contoh kod yang sepadan.

1. Ambang
   Ambang ialah kaedah pemprosesan biasa untuk menukar warna atau imej skala kelabu kepada imej hitam putih. Kaedah ini membandingkan nilai kecerahan piksel imej dengan ambang tertentu dan membahagikan nilai piksel kepada dua kategori: piksel di atas ambang berwarna putih dan piksel di bawah ambang adalah hitam.

Mula-mula, kita perlu memasang pakej pemprosesan imej Golang - github.com/disintegration/imaging, pasangkannya melalui arahan berikut: github.com/disintegration/imaging，通过以下命令进行安装：

go get -u github.com/disintegration/imaging

接下来，我们可以编写代码来实现图像的阈值化处理：

package main

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

    "github.com/disintegration/imaging"
)

func main() {
    // 打开图像文件
    file, err := os.Open("input.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // 解码图像
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 阈值化处理
    threshold := 128
    bounds := img.Bounds()
    grayImage := image.NewGray(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            originalColor := img.At(x, y)
            red, green, blue, _ := originalColor.RGBA()
            grayValue := (int(red) + int(green) + int(blue)) / 3

            var colorValue uint8
            if grayValue > threshold {
                colorValue = 255
            } else {
                colorValue = 0
            }

            grayImage.Set(x, y, color.Gray{colorValue})
        }
    }

    // 保存阈值化后的图像
    outputFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    jpeg.Encode(outputFile, grayImage, nil)
}

上述代码首先打开了名为input.jpg的图像文件，并使用jpeg.Decode函数对图像进行解码。然后，我们创建了一个新的灰度图像用于保存阈值化处理后的结果。接下来，我们遍历图像的每个像素，计算其灰度值，并根据阈值的设定将像素设置为黑色或白色。最后，我们使用jpeg.Encode函数将结果保存为output.jpg。

2. 去噪
   图像去噪是指在图像处理过程中，通过一定的算法和技术，将图像中的噪声减小或消除的过程。常见的图像去噪算法有中值滤波、高斯滤波等。

我们可以使用Golang的draw包来实现简单的中值滤波算法：

package main

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

func medianFilter(img image.Image, size int) image.Image {
    bounds := img.Bounds()
    result := image.NewRGBA(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            mr, mg, mb := 0, 0, 0
            count := 0

            for dy := -size; dy <= size; dy++ {
                for dx := -size; dx <= size; dx++ {
                    nx := x + dx
                    ny := y + dy

                    if nx >= bounds.Min.X && nx < bounds.Max.X && ny >= bounds.Min.Y && ny < bounds.Max.Y {
                        r, g, b, _ := img.At(nx, ny).RGBA()
                        mr += int(r)
                        mg += int(g)
                        mb += int(b)
                        count++
                    }
                }
            }

            rr := uint8(mr / count)
            gg := uint8(mg / count)
            bb := uint8(mb / count)

            result.Set(x, y, color.RGBA{rr, gg, bb, 255})
        }
    }

    return result
}

func main() {
    // 打开图像文件
    file, err := os.Open("input.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // 解码图像
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 中值滤波处理
    filtered := medianFilter(img, 1)

    // 保存去噪后的图像
    outputFile, err := os.Create("output.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    jpeg.Encode(outputFile, filtered, nil)
}

上述代码中，我们定义了一个medianFilter函数来实现简单的中值滤波算法。函数中，我们使用一个size参数来指定滤波窗口的大小。我们遍历图像的每个像素，并根据窗口内的像素计算该像素的中值，并将结果保存到新创建的图像中。最后，我们使用jpeg.Encode函数将结果保存为output.jpgrrreee

Seterusnya, kita boleh menulis kod untuk melaksanakan Thresholding imej :

rrreee
Kod di atas mula-mula membuka fail imej bernama input.jpg dan menggunakan fungsi jpeg.Decode untuk menyahkod imej. Kemudian, kami mencipta imej skala kelabu baharu untuk menyimpan hasil ambang. Seterusnya, kami mengulangi setiap piksel imej, mengira nilai skala kelabunya dan menetapkan piksel kepada hitam atau putih bergantung pada ambang. Akhir sekali, kami menggunakan fungsi jpeg.Encode untuk menyimpan hasil sebagai output.jpg.

🎜Denoising🎜Denoising imej merujuk kepada proses mengurangkan atau menghapuskan hingar dalam imej melalui algoritma dan teknik tertentu semasa pemprosesan imej. Algoritma denoising imej biasa termasuk penapisan median, penapisan Gaussian, dsb. 🎜🎜🎜Kami boleh menggunakan pakej draw Golang untuk melaksanakan algoritma penapisan median mudah: 🎜rrreee🎜Dalam kod di atas, kami mentakrifkan fungsi medianFilter untuk melaksanakan penapis Median ringkas algoritma. Dalam fungsi, kami menggunakan parameter size untuk menentukan saiz tetingkap penapis. Kami melingkari setiap piksel imej dan mengira nilai median piksel tersebut berdasarkan piksel dalam tetingkap dan menyimpan hasilnya pada imej yang baru dibuat. Akhir sekali, kami menggunakan fungsi jpeg.Encode untuk menyimpan hasil sebagai output.jpg. 🎜🎜Ringkasan🎜Artikel ini memperkenalkan cara menggunakan Golang untuk ambang dan denoise imej. Ambang boleh menukar imej berwarna atau skala kelabu kepada imej hitam dan putih untuk pemprosesan seterusnya. Denoising boleh mengurangkan atau menghapuskan hingar dalam imej dan meningkatkan kualiti imej. Melalui kod sampel, kita boleh lebih memahami dan menggunakan teknik pemprosesan imej ini. Saya harap artikel ini dapat membantu kajian dan latihan anda dalam bidang pemprosesan imej. 🎜

Atas ialah kandungan terperinci Manipulasi imej Golang: pelajari cara ambang dan denoise imej. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!