Golang 이미지 조작: 이미지에서 색상 균형 및 색상 변환을 수행하는 방법

Golang 이미지 작업: 사진에서 색상 균형 및 색상 변환을 수행하는 방법

소개: 이미지 처리 분야에서 색상 균형 및 색상 변환은 일반적으로 사용되는 작업 중 하나입니다. 이 기사에서는 Go 언어를 사용하여 그림의 색상 균형 및 색상 변환을 수행하는 방법을 소개하고 해당 코드 예제를 제공합니다.

1. 색상 균형
색상 균형이란 이미지의 각 색상 채널의 강도를 조정하여 이미지의 전체적인 색상을 보다 균일하고 자연스럽게 만드는 것을 말합니다. 일반적으로 사용되는 색상 균형 알고리즘에는 밝기 균형, 화이트 밸런스 및 히스토그램 균등화가 포함됩니다.

1. 밝기 균형
   밝기 균형은 이미지 밝기 분포를 조정하여 달성됩니다. 다음은 밝기 균형을 달성하는 간단한 예제 코드입니다.

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

위 코드에서는 이미지의 각 픽셀을 반복하고 각 픽셀의 빨간색, 녹색 및 파란색 채널 값에 2를 곱합니다. 전체 밝기는 다음과 같습니다. 향상. 원본 이미지를 로드하고 처리된 이미지를 저장하면 색상 균형이 잡힌 이미지를 얻을 수 있습니다.

2. 화이트 밸런스
   화이트 밸런스는 고르지 못한 조명으로 인해 발생하는 사진의 색조를 제거하는 것입니다. 다음은 화이트 밸런스를 달성하기 위한 간단한 샘플 코드입니다.

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

위 코드에서는 이미지의 모든 픽셀의 로그 값의 평균을 계산하고, 각 픽셀의 로그 값에 평균을 곱합니다. 화이트 밸런스를 달성하기 위해 지수 연산이 수행됩니다. 마찬가지로 원본 이미지를 로드하고 처리된 이미지를 저장하면 화이트 밸런스 이미지를 얻을 수 있습니다.

2. 색상 변환
색상 변환은 한 색상 공간의 색상을 다른 색상 공간의 색상으로 변환하는 것을 의미합니다. 일반적으로 사용되는 색상 변환에는 RGB에서 HSV로, RGB에서 YUV로의 변환이 포함됩니다.

1. RGB에서 HSV로 변환
   RGB와 HSV는 두 가지 일반적인 색상 공간입니다. RGB는 빨간색, 녹색, 파란색의 세 가지 색상 구성 요소를 나타내는 데 사용되며 HSV는 색상의 세 가지 속성인 색조, 채도, 채도를 나타내는 데 사용됩니다. 그리고 밝기.

다음은 RGB 색상을 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)
}

위 코드에서는 일련의 계산을 통해 RGB 색상 구성 요소의 값을 기반으로 해당 HSV 색상 구성 요소를 계산합니다. 값. RGB 성분의 값을 빨간색의 최대값으로 설정하여 순수한 빨간색 RGB 색상을 출력하고, 이에 해당하는 HSV 색상을 계산합니다.

2. RGB에서 YUV로 변환
   YUV도 일반적인 색상 공간으로 Y는 밝기를 나타내고 U와 V는 채도를 나타냅니다. 다음은 RGB 색상을 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)
}

위 코드에서는 RGB 색상 구성 요소의 값을 기반으로 일련의 계산을 통해 해당 YUV 색상 구성 요소 값을 계산합니다. . 마찬가지로 RGB 구성요소의 값을 빨간색의 최대값으로 설정하여 순수한 빨간색 RGB 색상을 출력하고 해당 YUV 색상을 계산합니다.

결론: 이 기사에서는 Go 언어를 사용하여 이미지의 색상 균형 및 색상 변환 방법을 소개하고 해당 코드 예제를 제공합니다. 독자들이 이 글을 통해 Golang 이미지 연산에 대해 더 깊이 이해하고 실제 프로젝트에 적용할 수 있기를 바랍니다.

위 내용은 Golang 이미지 조작: 이미지에서 색상 균형 및 색상 변환을 수행하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!