Go语言中创建与管理颜色对象：深入理解image.Color接口

type Color interface {
    RGBA() (r, g, b, a uint32)
}

type Gray struct {
    Y uint8
}

package main

import (
    "fmt"
    "image"
    "image/color" // 引入 color 包
)

func main() {
    // 假设从某个像素获取到RGBA值
    var red, green, blue, alpha uint32 = 0xAAAA, 0xBBBB, 0xCCCC, 0xFFFF

    // 将16位RGBA值转换为8位，并计算平均灰度值
    // 注意：RGBA()方法返回的uint32值是0-0xFFFF范围，需要除以257转换为0-0xFF范围
    r8 := uint8(red >> 8)
    g8 := uint8(green >> 8)
    b8 := uint8(blue >> 8)

    averagedGrayValue := uint8((int(r8) + int(g8) + int(b8)) / 3)

    // 使用 image.Gray 构造灰度颜色对象
    grayColor := color.Gray{Y: averagedGrayValue}

    // 验证：调用 RGBA() 方法
    r, g, b, a := grayColor.RGBA()
    fmt.Printf("灰度颜色对象RGBA值: R=%d, G=%d, B=%d, A=%d\n", r, g, b, a)
    // 预期输出：R=averagedGrayValue*257, G=averagedGrayValue*257, B=averagedGrayValue*257, A=0xFFFF
}

package main

import (
    "fmt"
    "image/color"
)

func main() {
    // 假设从某个像素获取到RGBA值 (uint32, 0-0xFFFF)
    var red, green, blue, alpha uint32 = 0xAAAA, 0xBBBB, 0xCCCC, 0xFFFF

    // 转换为 uint8 (0-0xFF)
    r8 := uint8(red >> 8)
    g8 := uint8(green >> 8)
    b8 := uint8(blue >> 8)
    a8 := uint8(alpha >> 8)

    // 使用 image.RGBA 构造颜色对象
    rgbaColor := color.RGBA{R: r8, G: g8, B: b8, A: a8}

    // 验证：调用 RGBA() 方法
    r, g, b, a := rgbaColor.RGBA()
    fmt.Printf("RGBA颜色对象RGBA值: R=%d, G=%d, B=%d, A=%d\n", r, g, b, a)
    // 预期输出：R=0xAAAA, G=0xBBBB, B=0xCCCC, A=0xFFFF
}

package main

import (
    "fmt"
    "image/color" // 引入 color 包
)

// 定义自定义的灰度颜色类型
type MyGray struct {
    Y uint32 // 存储灰度值，使用 uint32 以匹配 RGBA() 的返回类型精度
}

// 实现 image.Color 接口的 RGBA() 方法
func (g *MyGray) RGBA() (r, gVal, b, a uint32) {
    // 对于灰度颜色，R, G, B 分量都等于灰度值 Y
    // Alpha 分量通常设置为完全不透明 (0xFFFF)
    return g.Y, g.Y, g.Y, 0xFFFF
}

// 辅助方法：从原始RGBA值创建 MyGray 对象
func (g *MyGray) FromRGBA(rIn, gIn, bIn, aIn uint32) {
    // 简单平均计算灰度值
    g.Y = (rIn + gIn + bIn) / 3
    // 注意：这里我们只关心亮度，忽略原始的 alpha 值
}

func main() {
    // 假设从某个像素获取到RGBA值
    var pixelRed, pixelGreen, pixelBlue, pixelAlpha uint32 = 0x1234, 0x5678, 0xABCD, 0xFFFF

    // 创建 MyGray 对象并使用 FromRGBA 方法初始化
    myGrayColor := &MyGray{} // 需要指针类型，因为 FromRGBA 修改了接收者
    myGrayColor.FromRGBA(pixelRed, pixelGreen, pixelBlue, pixelAlpha)

    // 现在 myGrayColor 就是一个实现了 image.Color 接口的对象
    // 可以调用其 RGBA() 方法
    r, g, b, a := myGrayColor.RGBA()
    fmt.Printf("自定义灰度颜色对象RGBA值: R=%d, G=%d, B=%d, A=%d\n", r, g, b, a)
    // 预期输出：R=(pixelRed+pixelGreen+pixelBlue)/3, G=(pixelRed+pixelGreen+pixelBlue)/3, B=(pixelRed+pixelGreen+pixelBlue)/3, A=0xFFFF
}

package main

import (
    "fmt"
    "image"
    "image/color"
    _ "image/gif"
    _ "image/jpeg"
    _ "image/png"
    "os"
)

func main() {
    reader, err := os.Open("test-image.jpg") // 确保 test-image.jpg 存在
    if err != nil {
        fmt.Fprintf(os.Stderr, "打开文件失败: %v\n", err)
        return
    }
    defer reader.Close()

    img, _, err := image.Decode(reader)
    if err != nil {
        fmt.Fprintf(os.Stderr, "解码图像失败: %s\n", err)
        return
    }

    bounds := img.Bounds()

    // 遍历图像像素，并转换为灰度
    for i := bounds.Min.X; i < bounds.Max.X; i++ {
        for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
            pixel := img.At(i, j)
            red, green, blue, _ := pixel.RGBA() // 获取像素的RGBA值 (uint32, 0-0xFFFF)

            // 转换为8位灰度值
            r8 := uint8(red >> 8)
            g8 := uint8(green >> 8)
            b8 := uint8(blue >> 8)
            averagedGrayValue := uint8((int(r8) + int(g8) + int(b8)) / 3)

            // 方式一：使用 image.Gray
            grayColorStd := color.Gray{Y: averagedGrayValue}
            // 可以对 grayColorStd 进行后续操作，例如写入新的灰度图像

            // 方式二：使用自定义 MyGray 类型 (如果需要自定义逻辑)
            myGrayColor := &MyGray{} // 使用自定义类型
            myGrayColor.FromRGBA(red, green, blue, 0xFFFF) // 注意：这里使用了原始 uint32 值
            // 可以对 myGrayColor 进行后续操作

            if i == bounds.Min.X && j == bounds.Min.Y {
                fmt.Printf("原始像素(%d,%d)的RGBA: R=%d, G=%d, B=%d\n", i, j, red, green, blue)
                fmt.Printf("标准库灰度对象RGBA: R=%d, G=%d, B=%d, A=%d\n", grayColorStd.RGBA())
                fmt.Printf("自定义灰度对象RGBA: R=%d, G=%d, B=%d, A=%d\n", myGrayColor.RGBA())
            }
        }
    }
    fmt.Println("图像处理完成。")
}

// MyGray 类型及其方法定义，同上文示例
type MyGray struct {
    Y uint32
}

func (g *MyGray) RGBA() (r, gVal, b, a uint32) {
    return g.Y, g.Y, g.Y, 0xFFFF
}

func (g *MyGray) FromRGBA(rIn, gIn, bIn, aIn uint32) {
    g.Y = (rIn + gIn + bIn) / 3
}