Go语言PNG图像通道互换：深入解析image包的颜色处理与实践

type ImageSet interface {
    Set(x, y int, c color.Color)
}

// 假设 pic 是 png.Decode 返回的 image.Image
picSet, ok := pic.(ImageSet)
if !ok {
    // 处理错误：图像类型不支持 Set 方法
    fmt.Println("图像类型不支持像素设置。")
    return
}

for y := b.Min.Y; y < b.Max.Y; y++ {
    for x := b.Min.X; x < b.Max.X; x++ {
        col := pic.At(x, y)
        r, g, b, a := col.RGBA() // 获取 uint32 16位颜色分量

        // 假设我们想交换红色和绿色通道
        // newR, newG, newB, newA := swapChannels(r, g, b, a, c1.value, c2.value) // 使用辅助函数

        // 示例：直接交换红绿通道
        newCol := color.RGBA{uint8(g >> 8), uint8(r >> 8), uint8(b >> 8), uint8(a >> 8)}
        picSet.Set(x, y, newCol)
    }
}

// 假设 pic 是 png.Decode 返回的 image.Image
rgba, ok := pic.(*image.RGBA)
if !ok {
    fmt.Println("图像不是 *image.RGBA 类型，无法使用此优化方法。")
    return
}

for y := b.Min.Y; y < b.Max.Y; y++ {
    for x := b.Min.X; x < b.Max.X; x++ {
        // 直接获取 color.RGBA 结构体，避免接口调用和 uint32 转换
        col := rgba.At(x, y).(color.RGBA) 

        // 假设我们想交换红色和绿色通道
        // col.R, col.G = col.G, col.R // 简化后的通道交换

        // 更通用的通道交换（需要根据c1, c2动态调整）
        // 这里需要一个辅助函数来处理 col.R, col.G, col.B
        // 例如：
        // r, g, b, a := col.R, col.G, col.B, col.A
        // newR, newG, newB, newA := swapChannels(uint32(r), uint32(g), uint32(b), uint32(a), c1.value, c2.value)
        // col.R, col.G, col.B, col.A = uint8(newR), uint8(newG), uint8(newB), uint8(newA)

        // 示例：直接交换红绿通道
        col.R, col.G = col.G, col.R
        rgba.Set(x, y, col)
    }
}

package main

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

// Choice 结构体用于命令行参数校验
type Choice struct {
    value string
    valid bool
}

// validate 检查通道选择是否有效
func (c *Choice) validate() {
    goodchoices := []string{"R", "G", "B"}
    for _, v := range goodchoices {
        if c.value == v {
            c.valid = true
            return
        }
    }
    c.valid = false
}

// ImageSet 接口定义了设置像素的方法
type ImageSet interface {
    Set(x, y int, c color.Color)
}

// swapChannels 辅助函数根据用户选择交换颜色分量
// 注意：输入为 uint32，输出也为 uint32，以便后续转换为 uint8
func swapChannels(r, g, b, a uint32, c1, c2 string) (uint32, uint32, uint32, uint32) {
    newR, newG, newB := r, g, b

    switch {
    case (c1 == "R" && c2 == "G") || (c1 == "G" && c2 == "R"):
        newR, newG = g, r
    case (c1 == "R" && c2 == "B") || (c1 == "B" && c2 == "R"):
        newR, newB = b, r
    case (c1 == "G" && c2 == "B") || (c1 == "B" && c2 == "G"):
        newG, newB = b, g
    }
    return newR, newG, newB, a
}

func main() {
    var fname string
    var c1 Choice
    var c2 Choice

    flag.StringVar(&c1.value, "c1", "", "要交换的颜色通道 - R 或 G 或 B")
    flag.StringVar(&c2.value, "c2", "", "与哪个颜色通道交换 - R 或 G 或 B")
    flag.StringVar(&fname, "f", "", "一个 .png 图像文件路径")
    flag.Parse()

    c1.validate()
    c2.validate()

    if !(c1.valid && c2.valid) {
        fmt.Println("无效的通道选择。请使用 R, G 或 B。")
        return
    }
    if c1.value == c2.value {
        fmt.Println("不能交换相同的通道。")
        return
    }

    fmt.Printf("正在交换通道: %s <-> %s 在文件: %s\n", c1.value, c2.value, fname)

    // 1. 打开并解码PNG文件
    file, err := os.Open(fname)
    if err != nil {
        fmt.Println("打开文件失败:", err)
        return
    }
    defer file.Close()

    pic, err := png.Decode(file)
    if err != nil {
        fmt.Fprintf(os.Stderr, "解码PNG文件失败 %s: %v\n", fname, err)
        return
    }

    b := pic.Bounds()

    // 2. 尝试使用 *image.RGBA 优化，否则回退到通用 ImageSet 接口
    rgbaImage, isRGBA := pic.(*image.RGBA)
    if isRGBA {
        fmt.Println("图像是 *image.RGBA 类型，使用优化方法。")
        for y := b.Min.Y; y < b.Max.Y; y++ {
            for x := b.Min.X; x < b.Max.X; x++ {
                col := rgbaImage.At(x, y).(color.RGBA) // 直接获取 color.RGBA
                r, g, b, a := uint32(col.R), uint32(col.G), uint32(col.B), uint32(col.A)
                newR, newG, newB, newA := swapChannels(r, g, b, a, c1.value, c2.value)
                rgbaImage.Set(x, y, color.RGBA{uint8(newR), uint8(newG), uint8(newB), uint8(newA)})
            }
        }
    } else {
        // 回退到通用 ImageSet 接口
        picSet, ok := pic.(ImageSet)
        if !ok {
            fmt.Println("图像类型不支持像素设置，无法进行通道交换。")
            return
        }
        fmt.Println("图像不是 *image.RGBA 类型，使用通用 ImageSet 接口。")
        for y := b.Min.Y; y < b.Max.Y; y++ {
            for x := b.Min.X; x < b.Max.X; x++ {
                col := pic.At(x, y)
                r, g, b, a := col.RGBA() // 获取 uint32 16位颜色分量

                newR, newG, newB, newA := swapChannels(r, g, b, a, c1.value, c2.value)
                // 转换为 uint8 8位颜色分量，注意右移8位
                newCol := color.RGBA{uint8(newR >> 8), uint8(newG >> 8), uint8(newB >> 8), uint8(newA >> 8)}
                picSet.Set(x, y, newCol)
            }
        }
    }

    // 3. 保存修改后的图像
    outputFileName := "output_" + fname
    outFile, err := os.Create(outputFileName)
    if err != nil {
        fmt.Println("创建输出文件失败:", err)
        return
    }
    defer outFile.Close()

    err = png.Encode(outFile, pic) // pic 变量现在持有修改后的图像数据
    if err != nil {
        fmt.Println("编码图像失败:", err)
        return
    }
    fmt.Printf("修改后的图像已保存到: %s\n", outputFileName)
}

go build -o swap_channels swap_channels.go
./swap_channels -f your_image.png -c1 R -c2 G