Manipulasi imej Golang: Cara melakukan keseimbangan warna dan penukaran warna pada imej

Operasi imej Golang: Cara melakukan keseimbangan warna dan penukaran warna pada gambar

Pengenalan: Dalam bidang pemprosesan imej, keseimbangan warna dan penukaran warna adalah salah satu operasi yang biasa digunakan. Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk melaksanakan keseimbangan warna dan penukaran warna gambar serta memberikan contoh kod yang sepadan.

1. Keseimbangan warna
Imbangan warna merujuk kepada melaraskan keamatan setiap saluran warna dalam imej untuk menjadikan warna keseluruhan imej lebih seragam dan semula jadi. Algoritma imbangan warna yang biasa digunakan termasuk imbangan kecerahan, imbangan putih dan penyamaan histogram.

1. Imbangan Kecerahan
   Imbangan kecerahan dicapai dengan melaraskan taburan kecerahan imej. Berikut ialah kod contoh mudah untuk mencapai keseimbangan kecerahan:

package main

import (
    "image"
    "image/color"
    "image/png"
    "os"
)

func brightnessBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    balanceImg := image.NewRGBA(img.Bounds())

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = r * 2
            g = g * 2
            b = b * 2

            balanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return balanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    balanceImg := brightnessBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, balanceImg)
    if err != nil {
        panic(err)
    }
}

Dalam kod di atas, kami melingkari setiap piksel imej dan mendarabkan nilai saluran merah, hijau dan biru bagi setiap piksel dengan 2. Kecerahan keseluruhan ialah bertambah baik. Dengan memuatkan imej asal dan menyimpan imej yang diproses, kita boleh mendapatkan imej yang seimbang warna.

2. White balance
   White balance adalah untuk menghapuskan tuangan warna dalam gambar yang disebabkan oleh pencahayaan yang tidak sekata. Berikut ialah kod sampel mudah untuk mencapai imbangan putih:

package main

import (
    "image"
    "image/color"
    "image/png"
    "math"
    "os"
)

func whiteBalance(img image.Image) image.Image {
    width := img.Bounds().Dx()
    height := img.Bounds().Dy()

    whiteBalanceImg := image.NewRGBA(img.Bounds())

    var sumR, sumG, sumB float64
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            sumR += math.Log(float64(r))
            sumG += math.Log(float64(g))
            sumB += math.Log(float64(b))
        }
    }
    avgR := math.Exp(sumR / (float64(width * height)))
    avgG := math.Exp(sumG / (float64(width * height)))
    avgB := math.Exp(sumB / (float64(width * height)))

    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()
            r = uint32(math.Log(float64(r)) * avgR / float64(r))
            g = uint32(math.Log(float64(g)) * avgG / float64(g))
            b = uint32(math.Log(float64(b)) * avgB / float64(b))

            whiteBalanceImg.Set(x, y, color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)})
        }
    }

    return whiteBalanceImg
}

func main() {
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    whiteBalanceImg := whiteBalance(img)

    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    err = png.Encode(outputFile, whiteBalanceImg)
    if err != nil {
        panic(err)
    }
}

Dalam kod di atas, kami mengira purata nilai logaritma semua piksel dalam imej dan mendarabkan nilai logaritma setiap piksel dengan purata. Operasi eksponen dilakukan untuk mencapai imbangan putih. Begitu juga, dengan memuatkan imej asal dan menyimpan imej yang diproses, kita boleh mendapatkan imej seimbang putih.

2. Penukaran warna
Penukaran warna merujuk kepada menukar warna dalam satu ruang warna kepada warna dalam ruang warna yang lain. Penukaran warna yang biasa digunakan termasuk RGB kepada HSV dan RGB kepada YUV.

1. Penukaran RGB ke HSV
   RGB dan HSV ialah dua ruang warna biasa RGB digunakan untuk mewakili tiga komponen warna merah, hijau dan biru, dan HSV digunakan untuk mewakili tiga sifat warna: rona, ketepuan. dan kecerahan.

Berikut ialah contoh kod mudah untuk menukar warna RGB kepada warna HSV:

package main

import (
    "fmt"
    "image/color"
)

func rgbToHsv(r, g, b uint8) (uint16, uint8, uint8) {
    var h, s, v uint16

    max := uint16(r)
    if uint16(g) > max {
        max = uint16(g)
    }
    if uint16(b) > max {
        max = uint16(b)
    }

    min := uint16(r)
    if uint16(g) < min {
        min = uint16(g)
    }
    if uint16(b) < min {
        min = uint16(b)
    }

    v = max
    delta := max - min

    if max != 0 {
        s = uint8(delta) * 255 / uint8(max)
    } else {
        s = 0
    }

    if delta != 0 {
        if max == uint16(r) {
            h = (uint16(g) - uint16(b)) * 60 / delta
            if uint16(g) < uint16(b) {
                h += 360
            }
        } else if max == uint16(g) {
            h = (2 + (uint16(b)-uint16(r))/delta) * 60
        } else {
            h = (4 + (uint16(r)-uint16(g))/delta) * 60
        }
    } else {
        h = 0
    }

    return h, s, uint8(v)
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    h, s, v := rgbToHsv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> HSV(%d, %d, %d)
", r, g, b, h, s, v)
}

Dalam kod di atas, kami mengira komponen warna HSV yang sepadan berdasarkan nilai komponen warna RGB melalui satu siri pengiraan. nilai. Kami mengeluarkan warna RGB merah tulen dengan menetapkan nilai komponen RGB kepada nilai maksimum merah, dan mengira warna HSV yang sepadan.

2. Penukaran RGB ke YUV
   YUV juga merupakan ruang warna biasa, di mana Y mewakili kecerahan dan U dan V mewakili kroma. Berikut ialah contoh kod mudah untuk menukar warna RGB kepada warna YUV:

package main

import (
    "fmt"
    "image/color"
)

func rgbToYuv(r, g, b uint8) (uint8, uint8, uint8) {
    y := uint8(float32(r)*0.299 + float32(g)*0.587 + float32(b)*0.114)
    u := uint8((-float32(r)*0.14713 - float32(g)*0.28886 + float32(b)*0.436 + 128) / 2)
    v := uint8((float32(r)*0.615 + float32(g)*0.51499 - float32(b)*0.10001 + 128) / 2)
    return y, u, v
}

func main() {
    r := uint8(255)
    g := uint8(0)
    b := uint8(0)

    y, u, v := rgbToYuv(r, g, b)

    fmt.Printf("RGB(%d, %d, %d) -> YUV(%d, %d, %d)
", r, g, b, y, u, v)
}

Dalam kod di atas, kami mengira nilai komponen warna YUV yang sepadan melalui satu siri pengiraan berdasarkan nilai komponen warna RGB . Begitu juga, kami mengeluarkan warna RGB merah tulen dengan menetapkan nilai komponen RGB kepada nilai maksimum merah, dan mengira warna YUV yang sepadan.

Kesimpulan: Artikel ini memperkenalkan kaedah keseimbangan warna dan penukaran warna imej menggunakan bahasa Go, dan menyediakan contoh kod yang sepadan. Saya berharap pembaca akan mempunyai pemahaman yang lebih mendalam tentang operasi imej Golang melalui artikel ini dan dapat mengaplikasikannya pada projek sebenar.

Atas ialah kandungan terperinci Manipulasi imej Golang: Cara melakukan keseimbangan warna dan penukaran warna pada imej. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!