带alpha的Android位图模糊

我找到了如何模糊位图，但仍然有一个黑色光晕。我知道它可以通过在模糊之前对图像alpha进行预乘来修复，但我不知道如何做到这一点

谢谢你的帮助

圈法：

模糊法

公共位图getBlurredBitmap（原始位图，整数半径）{
如果（半径<1）
归还原件；
int width=original.getWidth（）；
int height=original.getHeight（）；
int wm=宽度-1；
int hm=高度-1；
int wh=宽度*高度；
int div=半径+半径+1；
int a[]=新int[wh]；
int r[]=新的int[wh]；
int g[]=新的int[wh]；
int b[]=新int[wh]；
内测，rsum，gsum，bsum，x，y，i，p，p1，p2，yp，yi，yw；
int vmin[]=新的int[Math.max（宽度、高度）]；
int vmax[]=新的int[Math.max（宽度、高度）]；
int dv[]=新的int[256*div]；
对于（i=0；i<256*div；i++）
dv[i]=i/div；
int[]模糊位图=新int[wh]；
原始.getPixels（模糊位图，0，宽度，0，0，宽度，高度）；
yw=yi=0；
对于（y=0；y<高度；y++）{
asum=rsum=gsum=bsum=0；
对于（i=-半径；i>24；
rsum+=（p&0xff0000）>>16；
gsum+=（p&0x00ff00）>>8；
bsum+=（p&0x0000ff）；
}
对于（x=0；x>24）和0xff）-（p2>>24）和0xff）；
rsum+=（（p1&0x00ff0000）-（p2&0x00ff0000））>>16；
gsum+=（（p1&0x0000ff00）-（p2&0x0000ff00））>>8；
bsum+=（p1&0x000000ff）-（p2&0x000000ff）；
易++；
}
yw+=宽度；
}
对于（x=0；xprivate void drawCircle() {
    ImageView img = (ImageView) findViewById(R.id.brushPreview);
    Bitmap bmp = Bitmap.createBitmap(260, 260, Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(bmp);
    Paint mPaint = new Paint();
    SeekBar[] seekBar = { (SeekBar) findViewById(R.id.seekBarSize), (SeekBar) findViewById(R.id.seekBarTrans), (SeekBar) findViewById(R.id.seekBarHard) };

    mPaint.setDither(true);
    mPaint.setColor(0xFFfff000);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeWidth(seekBar[0].getProgress());
    c.drawPoint(130, 130, mPaint);

    bmp = getBlurredBitmap(bmp, seekBar[2].getProgress());

    img.setImageBitmap(bmp);
}

public Bitmap getBlurredBitmap(Bitmap original, int radius) {
    if (radius < 1)
        return original;

    int width = original.getWidth();
    int height = original.getHeight();
    int wm = width - 1;
    int hm = height - 1;
    int wh = width * height;
    int div = radius + radius + 1;
    int a[] = new int[wh];
    int r[] = new int[wh];
    int g[] = new int[wh];
    int b[] = new int[wh];
    int asum, rsum, gsum, bsum, x, y, i, p, p1, p2, yp, yi, yw;
    int vmin[] = new int[Math.max(width, height)];
    int vmax[] = new int[Math.max(width, height)];
    int dv[] = new int[256 * div];
    for (i = 0; i < 256 * div; i++)
        dv[i] = i / div;

    int[] blurredBitmap = new int[wh];
    original.getPixels(blurredBitmap, 0, width, 0, 0, width, height);

    yw = yi = 0;

    for (y = 0; y < height; y++) {
        asum = rsum = gsum = bsum = 0;
        for (i = -radius; i <= radius; i++) {
            p = blurredBitmap[yi + Math.min(wm, Math.max(i, 0))];
            asum += (p & 0xff) >> 24;
            rsum += (p & 0xff0000) >> 16;
            gsum += (p & 0x00ff00) >> 8;
            bsum += (p & 0x0000ff);
        }
        for (x = 0; x < width; x++) {
            a[yi] = dv[asum];
            r[yi] = dv[rsum];
            g[yi] = dv[gsum];
            b[yi] = dv[bsum];

            if (y == 0) {
                vmin[x] = Math.min(x + radius + 1, wm);
                vmax[x] = Math.max(x - radius, 0);
            }
            p1 = blurredBitmap[yw + vmin[x]];
            p2 = blurredBitmap[yw + vmax[x]];

            asum += ((p1 >> 24) & 0xff) - ((p2 >> 24) & 0xff);
            rsum += ((p1 & 0x00ff0000) - (p2 & 0x00ff0000)) >> 16;
            gsum += ((p1 & 0x0000ff00) - (p2 & 0x0000ff00)) >> 8;
            bsum += (p1 & 0x000000ff) - (p2 & 0x000000ff);
            yi++;
        }
        yw += width;
    }

    for (x = 0; x < width; x++) {
        asum = rsum = gsum = bsum = 0;
        yp = -radius * width;
        for (i = -radius; i <= radius; i++) {
            yi = Math.max(0, yp) + x;
            asum += a[yi];
            rsum += r[yi];
            gsum += g[yi];
            bsum += b[yi];
            yp += width;
        }
        yi = x;
        for (y = 0; y < height; y++) {
            blurredBitmap[yi] = (dv[asum]<<24) | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
            if (x == 0) {
                vmin[y] = Math.min(y + radius + 1, hm) * width;
                vmax[y] = Math.max(y - radius, 0) * width;
            }
            p1 = x + vmin[y];
            p2 = x + vmax[y];

            asum += a[p1] - a[p2];
            rsum += r[p1] - r[p2];
            gsum += g[p1] - g[p2];
            bsum += b[p1] - b[p2];

            yi += width;
        }
    }

    return Bitmap.createBitmap(blurredBitmap, width, height, Bitmap.Config.ARGB_8888);
}