C#图像对比问题：如何将两图差异像素叠加至空参考图？

问题背景 #

我有三张图像：

• 无云的空参考底图
• 两张带有不同云层的待对比图像

需求是：把两张待对比图中**各自独有的像素（即只在其中一张出现的云层区域）**叠加到空参考图上。但现有C#代码生成的结果漏了部分肉眼可见的差异（比如右上角的差异区域），明显是逻辑问题，求修正实现。

常见错误逻辑分析 #

大概率原代码犯了以下某类错误：

1. 只判断单张图与参考图的差异，没排除两张图都和参考不同但彼此相同的区域（这类是共同云层，不需要叠加）
2. 直接用像素对象Equals判断，没考虑图像压缩/拍摄带来的细微色彩偏差，导致部分差异被误判为相同
3. 只对比了RGB通道中的部分通道（比如忽略Alpha通道，或者只对比亮度）

修复后的完整代码 #

using System.Drawing;
using System.Drawing.Imaging;

public class CloudDifferenceMerger
{
    // 色彩容差：允许像素间的细微差异，避免误判
    private const int ColorTolerance = 15;

    public static Bitmap MergeUniqueClouds(Bitmap reference, Bitmap cloudImgA, Bitmap cloudImgB)
    {
        // 确保三张图尺寸一致
        if (reference.Size != cloudImgA.Size || reference.Size != cloudImgB.Size)
            throw new ArgumentException("所有图像必须具有相同的尺寸");

        Bitmap result = new Bitmap(reference.Width, reference.Height, PixelFormat.Format32bppArgb);

        // 锁定内存以提升处理速度
        using (var referenceData = reference.LockBits(new Rectangle(0, 0, reference.Width, reference.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb))
        using (var imgAData = cloudImgA.LockBits(new Rectangle(0, 0, cloudImgA.Width, cloudImgA.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb))
        using (var imgBData = cloudImgB.LockBits(new Rectangle(0, 0, cloudImgB.Width, cloudImgB.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb))
        using (var resultData = result.LockBits(new Rectangle(0, 0, result.Width, result.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb))
        {
            int stride = referenceData.Stride;
            int pixelCount = reference.Width * reference.Height;
            IntPtr referencePtr = referenceData.Scan0;
            IntPtr imgAPtr = imgAData.Scan0;
            IntPtr imgBPtr = imgBData.Scan0;
            IntPtr resultPtr = resultData.Scan0;

            // 转换为字节数组处理
            byte[] referenceBytes = new byte[stride * reference.Height];
            byte[] imgABytes = new byte[stride * cloudImgA.Height];
            byte[] imgBBytes = new byte[stride * cloudImgB.Height];
            byte[] resultBytes = new byte[stride * result.Height];

            System.Runtime.InteropServices.Marshal.Copy(referencePtr, referenceBytes, 0, referenceBytes.Length);
            System.Runtime.InteropServices.Marshal.Copy(imgAPtr, imgABytes, 0, imgABytes.Length);
            System.Runtime.InteropServices.Marshal.Copy(imgBPtr, imgBBytes, 0, imgBBytes.Length);

            for (int i = 0; i < pixelCount; i++)
            {
                int pixelIndex = i * 4; // 32bppArgb每个像素占4字节：B, G, R, A

                // 获取各图当前像素的RGB值
                Color refColor = Color.FromArgb(
                    referenceBytes[pixelIndex + 3],
                    referenceBytes[pixelIndex + 2],
                    referenceBytes[pixelIndex + 1],
                    referenceBytes[pixelIndex]
                );
                Color colorA = Color.FromArgb(
                    imgABytes[pixelIndex + 3],
                    imgABytes[pixelIndex + 2],
                    imgABytes[pixelIndex + 1],
                    imgABytes[pixelIndex]
                );
                Color colorB = Color.FromArgb(
                    imgBBytes[pixelIndex + 3],
                    imgBBytes[pixelIndex + 2],
                    imgBBytes[pixelIndex + 1],
                    imgBBytes[pixelIndex]
                );

                // 判断逻辑：只保留A独有或B独有的像素
                bool isAUnique = !ColorsAreSimilar(colorA, refColor) && !ColorsAreSimilar(colorA, colorB);
                bool isBUnique = !ColorsAreSimilar(colorB, refColor) && !ColorsAreSimilar(colorB, colorA);

                if (isAUnique)
                {
                    // 写入A的像素
                    resultBytes[pixelIndex] = imgABytes[pixelIndex];
                    resultBytes[pixelIndex + 1] = imgABytes[pixelIndex + 1];
                    resultBytes[pixelIndex + 2] = imgABytes[pixelIndex + 2];
                    resultBytes[pixelIndex + 3] = imgABytes[pixelIndex + 3];
                }
                else if (isBUnique)
                {
                    // 写入B的像素
                    resultBytes[pixelIndex] = imgBBytes[pixelIndex];
                    resultBytes[pixelIndex + 1] = imgBBytes[pixelIndex + 1];
                    resultBytes[pixelIndex + 2] = imgBBytes[pixelIndex + 2];
                    resultBytes[pixelIndex + 3] = imgBBytes[pixelIndex + 3];
                }
                else
                {
                    // 保留参考图像素
                    resultBytes[pixelIndex] = referenceBytes[pixelIndex];
                    resultBytes[pixelIndex + 1] = referenceBytes[pixelIndex + 1];
                    resultBytes[pixelIndex + 2] = referenceBytes[pixelIndex + 2];
                    resultBytes[pixelIndex + 3] = referenceBytes[pixelIndex + 3];
                }
            }

            System.Runtime.InteropServices.Marshal.Copy(resultBytes, 0, resultPtr, resultBytes.Length);
        }

        return result;
    }

    // 判断两个颜色是否在容差范围内相似
    private static bool ColorsAreSimilar(Color c1, Color c2)
    {
        int diffR = Math.Abs(c1.R - c2.R);
        int diffG = Math.Abs(c1.G - c2.G);
        int diffB = Math.Abs(c1.B - c2.B);
        int diffA = Math.Abs(c1.A - c2.A);

        return diffR <= ColorTolerance && diffG <= ColorTolerance && diffB <= ColorTolerance && diffA <= ColorTolerance;
    }
}

代码说明 #

1. 尺寸校验：先确保三张图尺寸一致，避免索引越界
2. 内存锁定：使用LockBits直接操作内存字节数组，比逐像素调用GetPixel/SetPixel快10倍以上
3. 色彩容差：通过ColorsAreSimilar方法判断像素是否接近，避免因图像压缩或拍摄噪声导致的差异误判
4. 核心逻辑：
   • 只有当某张图的像素与参考图不同，且与另一张待对比图的像素也不同时，才判定为独有区域
   • 否则保留参考图的像素，排除了两张图共有的云层区域

使用示例 #

using (Bitmap reference = new Bitmap("reference.png"))
using (Bitmap cloudA = new Bitmap("cloudA.png"))
using (Bitmap cloudB = new Bitmap("cloudB.png"))
{
    Bitmap mergedResult = CloudDifferenceMerger.MergeUniqueClouds(reference, cloudA, cloudB);
    mergedResult.Save("unique_clouds.png", ImageFormat.Png);
}

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