Swift手动访问图像像素数据及创建CGImage掩码的技术咨询

手动操作CGImage的像素数据确实有点让人头大，尤其是刚开始接触Core Graphics的时候——我刚学的时候也踩过不少坑。不过别担心，我来一步步帮你拆解从CGImage生成目标掩码的实现思路，把每一步都讲清楚。

1. 第一步：把CGImage像素数据读到可操作的内存缓冲区 #

要处理像素，首先得把CGImage里的像素数据拷贝到我们能直接读写的内存里。这里我们用CGContext创建一个位图上下文，把图像数据转存进去：

func createPixelBuffer(from cgImage: CGImage) -> (buffer: UnsafeMutablePointer<UInt8>, width: Int, height: Int, bytesPerRow: Int)? {
    let width = cgImage.width
    let height = cgImage.height
    let bytesPerRow = cgImage.bytesPerRow
    
    // 为像素数据分配内存（每个像素占4字节：R/G/B/A各8位）
    guard let buffer = malloc(width * height * 4) else {
        print("无法分配内存存储像素数据")
        return nil
    }
    
    // 创建RGB颜色空间的位图上下文，参数要和原图像格式匹配
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    guard let context = CGContext(
        data: buffer,
        width: width,
        height: height,
        bitsPerComponent: 8,
        bytesPerRow: bytesPerRow,
        space: colorSpace,
        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
    ) else {
        free(buffer) // 创建失败要及时释放内存
        print("无法创建位图上下文")
        return nil
    }
    
    // 将原CGImage绘制到上下文，把像素数据拷贝到我们的缓冲区
    context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
    
    return (buffer, width, height, bytesPerRow)
}

这里要注意：bitmapInfo选premultipliedLast是因为它对应最常见的RGB+Alpha像素顺序，和大多数图像格式兼容；bytesPerRow必须用原图像的数值，因为Core Graphics会为了内存对齐给每行像素补额外字节，直接用width*4会导致读取错误。

2. 第二步：遍历像素，筛选目标值并处理 #

拿到缓冲区后，就可以逐个像素检查，把非目标像素转成黑白（或调整透明度）：

func processPixelBuffer(
    _ buffer: UnsafeMutablePointer<UInt8>,
    width: Int,
    height: Int,
    bytesPerRow: Int,
    targetRGB: (red: UInt8, green: UInt8, blue: UInt8)
) {
    for y in 0..<height {
        for x in 0..<width {
            // 计算当前像素在缓冲区的位置：每行bytesPerRow字节，每个像素4字节
            let pixelIndex = y * bytesPerRow + x * 4
            
            // 读取当前像素的RGBA值
            let red = buffer[pixelIndex]
            let green = buffer[pixelIndex + 1]
            let blue = buffer[pixelIndex + 2]
            let alpha = buffer[pixelIndex + 3]
            
            // 检查是否是目标像素
            if red == targetRGB.red && green == targetRGB.green && blue == targetRGB.blue {
                // 保留目标像素，不做修改
                continue
            } else {
                // 将非目标像素转黑白：计算RGB平均值作为灰度值
                let grayValue = UInt8((Int(red) + Int(green) + Int(blue)) / 3)
                buffer[pixelIndex] = grayValue
                buffer[pixelIndex + 1] = grayValue
                buffer[pixelIndex + 2] = grayValue
                
                // 如果需要调整透明度，比如设为半透明，直接修改Alpha通道：
                // buffer[pixelIndex + 3] = 128
            }
        }
    }
}

3. 第三步：从处理后的缓冲区生成新的CGImage（掩码） #

处理完像素后，把缓冲区转成可用的CGImage：

func createMaskImage(from buffer: UnsafeMutablePointer<UInt8>, width: Int, height: Int, bytesPerRow: Int) -> CGImage? {
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    let bitmapInfo = CGImageAlphaInfo.premultipliedLast.rawValue
    
    // 创建数据提供者，注意这里的release回调要留空——因为内存是我们手动分配的，后续要自己释放
    guard let dataProvider = CGDataProvider(
        dataInfo: nil,
        data: buffer,
        size: height * bytesPerRow,
        releaseData: { _, _, _ in }
    ) else {
        return nil
    }
    
    // 生成最终的CGImage
    let maskImage = CGImage(
        width: width,
        height: height,
        bitsPerComponent: 8,
        bitsPerPixel: 32,
        bytesPerRow: bytesPerRow,
        space: colorSpace,
        bitmapInfo: bitmapInfo,
        provider: dataProvider,
        decode: nil,
        shouldInterpolate: false,
        intent: .defaultIntent
    )
    
    return maskImage
}

4. 完整调用流程 #

把上面的函数串起来，就能实现从原图像生成目标掩码的功能：

func generateImageMask(from originalImage: CGImage, targetRGB: (UInt8, UInt8, UInt8)) -> CGImage? {
    guard let pixelData = createPixelBuffer(from: originalImage) else {
        return nil
    }
    defer {
        free(pixelData.buffer) // 用defer确保函数结束时一定会释放内存，避免泄漏
    }
    
    // 处理像素
    processPixelBuffer(
        pixelData.buffer,
        width: pixelData.width,
        height: pixelData.height,
        bytesPerRow: pixelData.bytesPerRow,
        targetRGB: (red: targetRGB.0, green: targetRGB.1, blue: targetRGB.2)
    )
    
    // 生成掩码图像
    return createMaskImage(
        from: pixelData.buffer,
        width: pixelData.width,
        height: pixelData.height,
        bytesPerRow: pixelData.bytesPerRow
    )
}

// 调用示例
if let originalCGImage = UIImage(named: "yourImage")?.cgImage {
    let targetColor = (255, 0, 0) // 比如识别纯红色像素
    if let maskImage = generateImageMask(from: originalCGImage, targetRGB: targetColor) {
        let resultUIImage = UIImage(cgImage: maskImage)
        // 这里可以把resultUIImage用作掩码或者直接显示
    }
}

几个关键注意事项 #

• 内存管理：手动分配的buffer一定要记得释放，用defer语句是最稳妥的方式，不管函数正常结束还是报错退出，都会执行内存释放。
• 像素格式匹配：如果原图像是不带Alpha的格式（比如灰度图），要调整CGContext的bitmapInfo参数，否则会出现颜色错乱。
• 性能优化：如果处理超大图像，双重循环可能有点慢，可以考虑用Accelerate框架做向量运算加速，但普通需求下上面的代码完全够用。

内容的提问来源于stack exchange，提问作者Michael