Golang图像处理：深度解析PNG通道交换技术

package main

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

// ImageSet 接口定义了设置像素的方法，适用于所有支持像素写入的图像类型
type ImageSet interface {
    Set(x, y int, c color.Color)
}

// 示例：从 color.Color 提取并转换通道值
col := pic.At(x, y)
r32, g32, b32, a32 := col.RGBA() // 获取 uint32 格式的 RGBA 值 (0-65535)

// 转换为 uint8 格式 (0-255)
r := uint8(r32 >> 8)
g := uint8(g32 >> 8)
b := uint8(b32 >> 8)
a := uint8(a32 >> 8)

// 现在 r, g, b, a 都是 uint8 类型，可以进行交换操作

// 假设 pic 是 png.Decode 返回的 image.Image
// 尝试将 pic 断言为 ImageSet 接口
picSet, ok := pic.(ImageSet)
if !ok {
    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)
        r32, g32, b32, a32 := col.RGBA()

        // 转换为 uint8
        r := uint8(r32 >> 8)
        g := uint8(g32 >> 8)
        b := uint8(b32 >> 8)
        a := uint8(a32 >> 8)

        // 假设我们想交换红色和绿色通道
        newCol := color.RGBA{R: g, G: r, B: b, A: a} // 交换 R 和 G
        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
        col := rgba.At(x, y).(color.RGBA)

        // 假设我们想交换红色和绿色通道
        col.G, col.R = col.R, col.G // 直接交换 uint8 字段

        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", "A"} // 增加A通道选项
    for _, v := range goodchoices {
        if c.value == v {
            c.valid = true
            return
        }
    }
    c.valid = false
}

// swapChannels 根据指定的通道名称交换颜色通道
func swapChannels(c color.RGBA, ch1, ch2 string) color.RGBA {
    tempR, tempG, tempB, tempA := c.R, c.G, c.B, c.A

    // 使用 map 存储指向通道值的指针，方便动态交换
    channelPtrs := map[string]*uint8{
        "R": &tempR,
        "G": &tempG,
        "B": &tempB,
        "A": &tempA,
    }

    // 检查通道是否存在且有效
    ptr1, ok1 := channelPtrs[ch1]
    ptr2, ok2 := channelPtrs[ch2]

    if ok1 && ok2 {
        // 执行交换
        *ptr1, *ptr2 = *ptr2, *ptr1
    } else {
        fmt.Fprintf(os.Stderr, "警告: 无效的通道名称 '%s' 或 '%s'，未执行交换。\n", ch1, ch2)
    }

    return color.RGBA{R: tempR, G: tempG, B: tempB, A: tempA}
}

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

    // 定义命令行参数
    flag.StringVar(&c1.value, "c1", "", "要交换的颜色通道 (R, G, B, A)")
    flag.StringVar(&c2.value, "c2", "", "与之交换的颜色通道 (R, G, B, A)")
    flag.StringVar(&fname, "f", "", "输入的 .png 图像文件路径")
    flag.StringVar(&outputFname, "o", "output.png", "输出的 .png 图像文件路径")
    flag.Parse()

    // 验证通道选择
    c1.validate()
    c2.validate()

    if !c1.valid || !c2.valid {
        fmt.Println("错误: 无效的通道选择。请使用 R, G, B 或 A。")
        flag.Usage()
        return
    }
    if fname == "" {
        fmt.Println("错误: 未指定输入文件。请使用 -f 参数。")
        flag.Usage()
        return
    }
    if c1.value == c2.value {
        fmt.Println("警告: 两个通道相同，无需交换。")
        return
    }

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

    // 1. 打开输入文件
    file, err := os.Open(fname)
    if err != nil {
        fmt.Fprintf(os.Stderr, "无法打开文件 %s: %v\n", fname, err)
        return
    }
    defer file.Close()

    // 2. 解码PNG图像
    pic, err := png.Decode(file)
    if err != nil {
        fmt.Fprintf(os.Stderr, "无法解码PNG图像 %s: %v\n", fname, err)
        return
    }

    // 3. 尝试将图像断言为 *image.RGBA 类型
    // 这是最常见且高效的8位RGBA图像处理方式
    rgbaImg, ok := pic.(*image.RGBA)
    if !ok {
        // 如果不是 *image.RGBA 类型，则创建一个新的 *image.RGBA 图像
        // 并将原始图像的内容复制过去，以便进行修改
        fmt.Println("图像不是 *image.RGBA 类型，正在转换为 *image.RGBA 进行处理。")
        b := pic.Bounds()
        rgbaImg = image.NewRGBA(b)
        for y := b.Min.Y; y < b.Max.Y; y++ {
            for x := b.Min.X; x < b.Max.X; x++ {
                rgbaImg.Set(x, y, pic.At(x, y))
            }
        }
    }

    // 4. 获取图像边界
    b := rgbaImg.Bounds()

    // 5. 遍历像素并交换通道
    for y := b.Min.Y; y < b.Max.Y; y++ {
        for x := b.Min.X; x < b.Max.X; x++ {
            // 获取当前像素的 RGBA 值
            originalColor := rgbaImg.At(x, y).(color.RGBA) // 假设已是 color.RGBA

            // 调用 swapChannels 函数进行通道交换
            newColor := swapChannels(originalColor, c1.value, c2.value)

            // 将修改后的颜色设置回图像
            rgbaImg.Set(x, y, newColor)
        }
    }

    // 6. 创建输出文件
    outFile, err := os.Create(outputFname)
    if err != nil {
        fmt.Fprintf(os.Stderr, "无法创建输出文件 %s: %v\n", outputFname, err)
        return
    }
    defer outFile.Close()

    // 7. 将修改后的图像编码为PNG并写入文件
    err = png.Encode(outFile, rgbaImg)
    if err != nil {
        fmt.Fprintf(os.Stderr, "无法编码PNG图像到文件 %s: %v\n", outputFname, err)
        return
    }

    fmt.Printf("通道交换完成。修改后的图像已保存到 %s\n", outputFname)
}