android - アルファ付きのAndroidビットマップブラー

Question

ビットマップをぼかす方法を見つけましたが、まだ黒い光輪が残っています。ぼかしの前に画像のアルファを乗算することで修正できることは知っていますが、その方法はわかりません...

助けてくれてありがとう！

サークル方式:

private 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);
}