Golang 画像処理: 画像をシャープにしてエッジ検出する方法を学びます

Golang 画像処理: 画像のシャープ化とエッジ検出の方法を学習します

概要
コンピューター ビジョンと画像処理において、シャープ化とエッジ検出は一般的な処理の 1 つです。使用された操作。シャープ化操作により、画像の細部とエッジを強調し、画像をより鮮明にすることができます。エッジ検出は画像内のエッジ情報をキャプチャするのに役立ち、画像の分析と識別に役立ちます。この記事では、Golang を使用して画像をシャープにし、エッジを検出する方法を紹介し、参考用のコード例を添付します。

画像をシャープにする
まず、画像をシャープにする方法を見てみましょう。 Golang では、image パッケージとdraw パッケージを使用してこれを実現できます。

まず、イメージ パッケージの Open 関数を使用してイメージ ファイルを開き、それを image.Image オブジェクトにデコードする必要があります。コードは次のとおりです。

package main

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

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

    // 解码为image.Image对象
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 对图像进行锐化处理
    sharpened := sharpenImage(img)

    // 将处理后的图像保存到文件
    output, err := os.Create("output_sharpened.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer output.Close()

    // 将处理后的图像编码为jpeg格式并保存
    err = jpeg.Encode(output, sharpened, nil)
    if err != nil {
        log.Fatal(err)
    }
}

// 锐化图像
func sharpenImage(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个RGBA图像，用于存储处理后的图像
    sharpened := image.NewRGBA(bounds)

    // 遍历图像的像素点，对每个像素点进行锐化处理
    for x := 1; x < width-1; x++ {
        for y := 1; y < height-1; y++ {
            // 获取周围的像素点
            pixel00 := img.At(x-1, y-1)
            pixel01 := img.At(x-1, y)
            pixel02 := img.At(x-1, y+1)
            pixel10 := img.At(x, y-1)
            pixel11 := img.At(x, y)
            pixel12 := img.At(x, y+1)
            pixel20 := img.At(x+1, y-1)
            pixel21 := img.At(x+1, y)
            pixel22 := img.At(x+1, y+1)

            // 对当前像素点进行锐化计算，可以使用Sobel算子等
            // 这里简化处理，使用当前像素点与周围像素点的平均值作为新的像素值
            r00, g00, b00, _ := pixel00.RGBA()
            r01, g01, b01, _ := pixel01.RGBA()
            r02, g02, b02, _ := pixel02.RGBA()
            r10, g10, b10, _ := pixel10.RGBA()
            r11, g11, b11, _ := pixel11.RGBA()
            r12, g12, b12, _ := pixel12.RGBA()
            r20, g20, b20, _ := pixel20.RGBA()
            r21, g21, b21, _ := pixel21.RGBA()
            r22, g22, b22, _ := pixel22.RGBA()

            avgR := uint8((r00 + r01 + r02 + r10 + r11 + r12 + r20 + r21 + r22) / 9)
            avgG := uint8((g00 + g01 + g02 + g10 + g11 + g12 + g20 + g21 + g22) / 9)
            avgB := uint8((b00 + b01 + b02 + b10 + b11 + b12 + b20 + b21 + b22) / 9)

            newPixel := color.RGBA{avgR, avgG, avgB, 255}

            // 设置锐化后的像素点
            sharpened.Set(x, y, newPixel)
        }
    }

    return sharpened
}

コード内の SharpImage 関数は、画像の鮮明化を実装します。各ピクセルについて、周囲のピクセルを使用して (ソーベル演算子、ラプラシアン演算子などを使用できます)、新しいピクセル値を計算して取得できます。コード例では、単に周囲のピクセルの平均を新しいピクセル値として取得します。

コードを実行すると、鮮明な画像が得られます。ニーズに応じて、より複雑なアルゴリズムを使用して、より高品質のシャープ効果を実現できます。

エッジ検出
以下では、画像に対してエッジ検出を実行する方法を学習します。同様に、image パッケージとdraw パッケージを使用してこれを実現できます。

package main

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

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

    // 解码为image.Image对象
    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    // 对图像进行边缘检测
    edges := detectEdges(img)

    // 将处理后的图像保存到文件
    output, err := os.Create("output_edges.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer output.Close()

    // 将处理后的图像编码为jpeg格式并保存
    err = jpeg.Encode(output, edges, nil)
    if err != nil {
        log.Fatal(err)
    }
}

// 边缘检测
func detectEdges(img image.Image) image.Image {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // 创建一个灰度图像，用于存储处理后的图像
    gray := image.NewGray(bounds)

    // 将图像转为灰度图像
    draw.Draw(gray, bounds, img, image.Point{}, draw.Src)

    // 创建一个RGBA图像，用于存储边缘检测结果
    edges := image.NewRGBA(bounds)

    // 设置边缘检测的阈值
    threshold := uint32(10000)

    for x := 1; x < width-1; x++ {
        for y := 1; y < height-1; y++ {
            // 获取周围的像素点
            pixel00 := gray.At(x-1, y-1)
            pixel01 := gray.At(x-1, y)
            pixel02 := gray.At(x-1, y+1)
            pixel10 := gray.At(x, y-1)
            pixel11 := gray.At(x, y)
            pixel12 := gray.At(x, y+1)
            pixel20 := gray.At(x+1, y-1)
            pixel21 := gray.At(x+1, y)
            pixel22 := gray.At(x+1, y+1)

            // 对当前像素点进行边缘检测计算
            g00 := luminance(pixel00)
            g01 := luminance(pixel01)
            g02 := luminance(pixel02)
            g10 := luminance(pixel10)
            g11 := luminance(pixel11)
            g12 := luminance(pixel12)
            g20 := luminance(pixel20)
            g21 := luminance(pixel21)
            g22 := luminance(pixel22)

            dx := -(g00 + 2*g10 + g20) + (g02 + 2*g12 + g22)
            dy := -(g00 + 2*g01 + g02) + (g20 + 2*g21 + g22)
            magnitude := math.Sqrt(float64(dx*dx + dy*dy))

            if magnitude > threshold {
                edges.Set(x, y, color.White)
            } else {
                edges.Set(x, y, color.Black)
            }
        }
    }

    return edges
}

// 计算像素的灰度值
func luminance(c color.Color) uint32 {
    r, g, b, _ := c.RGBA()
    return uint32(0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b))
}

サンプル コードでは、まずカラー イメージをグレースケール イメージに変換し、次に Sobel 演算子を使用してピクセルの勾配値を計算し、その勾配値を使用してピクセルがグレースケール イメージに属するかどうかを判断します。角。勾配値が設定されたしきい値より大きい場合、ピクセルは白に設定され、それ以外の場合は黒に設定されます。

コードを実行すると、エッジ検出後の画像が取得されます。しきい値などのパラメータを調整して、より良いエッジ検出結果を得ることができます。

概要
この記事では、Golang を使用して画像をシャープにし、エッジ検出する方法を紹介します。シャープ化アルゴリズムとエッジ検出アルゴリズムを理解して実装することで、画像の処理と分析をより適切に行うことができます。この記事が役立つ知識と助けを提供し、さらに画像処理テクノロジとアプリケーションを実際に検討するきっかけになれば幸いです。

以上がGolang 画像処理: 画像をシャープにしてエッジ検出する方法を学びますの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。