高斯模糊处理alpha透明度

Question

我一直在尝试在C＃中实现一个高斯模糊算法来处理透明度。我尝试了以下两个实现，每个实现似乎给了我不同类型的结果。但两者都没有考虑到alpha通道。

http://code.google.com/p/imagelibrary/downloads/detail?name=ImageLibrary-source-1_2_4.zip&can=2&q= http://www.smokycogs.com/blog/image-processing-in-c-sharp-smoothing-using-convolution/

我的测试图像在透明背景PNG上有一个简单的圆圈。

有人能指出我正确的方向让高斯模糊处理具有透明度的图像吗？ 我能找到的唯一链接是盒子模糊。 http://www.codeproject.com/Articles/6162/Gausian-and-Alpha-Blurring

Answer 1

如果您使用premultiplied alpha透明度，则可以像RGB通道一样模糊Alpha通道。

如果你的alpha不是预乘的，你可以得到奇怪的边缘文物。为避免这种情况，您可以尝试将图像转换为预乘，过滤，然后将其转换回来。在这个过程中存在缺陷，但结果可能比天真地平滑未经过相应的alpha图像更好。

Answer 2

您必须将每个RGB值与Alpha值相乘，然后将结果除以最大可能的alpha值。

假设你想平均只有​​三个像素：

newBlue = (
  src[-1].Blue * src[-1].Alpha + 
  src[0].Blue * src[0].Alpha + 
  src[1].Blue * src[1].Alpha ) / (255*3);

正如你所看到的：如果所有三个像素都是实心的（alpha = 255），那么与忽略alpha通道（这确实是我们想要的）相比，这个计算不会产生任何影响。

这是一个没有 alpha的3x3卷积：

            for (var i = nWidth - 2; i > 0; i--)
            {
                n = ((((pT[-sourcePixelSize]*m.TL) + (pT[0]*m.TM) + (pT[sourcePixelSize]*m.TR) +
                       (pM[-sourcePixelSize]*m.ML) + (pM[0]*m.MM) + (pM[sourcePixelSize]*m.MR) +
                       (pB[-sourcePixelSize]*m.BL) + (pB[0]*m.BM) + (pB[sourcePixelSize]*m.BR) + 5)/m.Factor) + m.Offset);
                *pD = (byte) (n <= 0 ? 0 : n >= 255 ? 255 : n);
                pT += sourcePixelSize;
                pM += sourcePixelSize;
                pB += sourcePixelSize;
                pD += 4;
            }

以下是带有 alpha的等效：

            for (var i = nWidth - 2; i > 0; i--)
            {
                alphaSum = (pT[-4 + ao] + pT[ao] + pT[4 + ao] +
                            pM[-4 + ao] + pM[ao] + pM[4 + ao] +
                            pB[-4 + ao] + pB[ao] + pB[4 + ao] + 5)/9;
                n = alphaSum != 0
                        ? ((((pT[-4]*pT[-4 + ao]*m.TL) + (pT[0]*pT[ao]*m.TM) + (pT[4]*pT[4 + ao]*m.TR) +
                             (pM[-4]*pM[-4 + ao]*m.ML) + (pM[0]*pM[ao]*m.MM) + (pM[4]*pM[4 + ao]*m.MR) +
                             (pB[-4]*pB[-4 + ao]*m.BL) + (pB[0]*pB[ao]*m.BM) + (pB[4]*pB[4 + ao]*m.BR) + 5)/
                            (m.Factor*alphaSum)) + m.Offset)
                        : 0;
                *pD = (byte) (n <= 0 ? 0 : n >= 255 ? 255 : n);
                pT += 4;
                pM += 4;
                pB += 4;
                pD += 4;
             }