Example usage for android.renderscript ScriptIntrinsicBlur setRadius

Introduction

In this page you can find the example usage for android.renderscript ScriptIntrinsicBlur setRadius.

Prototype

public void setRadius(float radius) 

Source Link

Document

Set the radius of the Blur.

Usage

From source file:Main.java

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap blur(Context context, Bitmap image) {
    int width = Math.round(image.getWidth() * BITMAP_SCALE);
    int height = Math.round(image.getHeight() * BITMAP_SCALE);

    Bitmap inputBitmap = Bitmap.createScaledBitmap(image, width, height, false);
    Bitmap outputBitmap = Bitmap.createBitmap(inputBitmap);

    RenderScript rs = RenderScript.create(context);
    ScriptIntrinsicBlur theIntrinsic = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
    Allocation tmpIn = Allocation.createFromBitmap(rs, inputBitmap);
    Allocation tmpOut = Allocation.createFromBitmap(rs, outputBitmap);
    theIntrinsic.setRadius(BLUR_RADIUS);
    theIntrinsic.setInput(tmpIn);//from w  w w.  j av a2  s.c o  m
    theIntrinsic.forEach(tmpOut);
    tmpOut.copyTo(outputBitmap);

    return outputBitmap;
}

---

From source file:Main.java

@SuppressLint("NewApi")
public static Bitmap blur(Context context, Bitmap bitmap) {
    if (Build.VERSION.SDK_INT > 16) {
        bitmap = bitmap.copy(bitmap.getConfig(), true);

        final RenderScript rs = RenderScript.create(context);
        final Allocation input = Allocation.createFromBitmap(rs, bitmap, Allocation.MipmapControl.MIPMAP_NONE,
                Allocation.USAGE_SCRIPT);
        final Allocation output = Allocation.createTyped(rs, input.getType());
        final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
        script.setRadius(24.f /* e.g. 3.f */);
        script.setInput(input);// ww  w .  j a  v a 2 s. c  om
        script.forEach(output);
        output.copyTo(bitmap);
    } else {
        bitmap = fastBlur(context, bitmap, 10);
    }
    return bitmap;
}

---

From source file:com.hellofyc.base.util.ViewUtils.java

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
static void blur(Context context, View view) {
    view.buildDrawingCache();//from  w  w  w. j  a  v a 2  s . c o  m
    Bitmap srcBitmap = view.getDrawingCache();
    float radius = 20f;

    Bitmap overlay = Bitmap.createBitmap(view.getMeasuredWidth(), view.getMeasuredHeight(),
            Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(overlay);
    canvas.translate(-view.getLeft(), -view.getTop());
    canvas.drawBitmap(srcBitmap, 0, 0, null);

    RenderScript script = RenderScript.create(context);
    Allocation allocation = Allocation.createFromBitmap(script, overlay);
    ScriptIntrinsicBlur blur = ScriptIntrinsicBlur.create(script, allocation.getElement());
    blur.setInput(allocation);
    blur.setRadius(radius);
    blur.forEach(allocation);
    allocation.copyTo(overlay);

    view.setBackground(new BitmapDrawable(context.getResources(), overlay));

    script.destroy();
}

---

From source file:Main.java

public static Bitmap blurBitmap(Context context, Bitmap bitmap, float blur) {
    Bitmap bitmapCopy = bitmap.copy(bitmap.getConfig(), false);
    //Let's create an empty bitmap with the same size of the bitmap we want to blur
    Bitmap outBitmap = (Bitmap.createBitmap(bitmapCopy.getWidth(), bitmapCopy.getHeight(),
            Bitmap.Config.ARGB_8888));//from w w w.j  a  v  a2 s  .c o m

    //Instantiate a new Renderscript
    RenderScript rs = RenderScript.create(context);

    //Create an Intrinsic Blur Script using the Renderscript
    ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));

    //Create the in/out Allocations with the Renderscript and the in/out bitmaps
    Allocation allIn = Allocation.createFromBitmap(rs, bitmapCopy);
    Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);

    //Set the radius of the blur
    blurScript.setRadius(blur);

    //Perform the Renderscript
    blurScript.setInput(allIn);
    blurScript.forEach(allOut);

    //Copy the final bitmap created by the out Allocation to the outBitmap
    allOut.copyTo(outBitmap);

    bitmapCopy.recycle();
    //After finishing everything, we destroy the Renderscript.
    rs.destroy();
    return outBitmap;
}

---

From source file:Main.java

public static Bitmap blurBitmap(Bitmap bitmap, Context context) {

    //Let's create an empty bitmap with the same size of the bitmap we want to blur  
    Bitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);

    //Instantiate a new Renderscript  
    RenderScript rs = RenderScript.create(context);

    //Create an Intrinsic Blur Script using the Renderscript  
    ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));

    //Create the Allocations (in/out) with the Renderscript and the in/out bitmaps  
    Allocation allIn = Allocation.createFromBitmap(rs, bitmap);
    Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);

    //Set the radius of the blur  
    blurScript.setRadius(25.f);

    //Perform the Renderscript  
    blurScript.setInput(allIn);/*from  w  w w .j  a v  a2s.co m*/
    blurScript.forEach(allOut);

    //Copy the final bitmap created by the out Allocation to the outBitmap  
    allOut.copyTo(outBitmap);

    //recycle the original bitmap  
    bitmap.recycle();

    //After finishing everything, we destroy the Renderscript.  
    rs.destroy();

    return outBitmap;

}

---

From source file:Main.java

/**
 * Apply a blur to a Bitmap//from w  w  w.  j  a  va  2s  . c o  m
 *
 * @param context    Application context
 * @param sentBitmap Bitmap to be converted
 * @param radius     Desired Radius, 0 < r < 25
 * @return a copy of the image with a blur
 */
@SuppressLint("InlinedApi")
public static Bitmap blur(Context context, Bitmap sentBitmap, int radius) {

    if (radius < 0) {
        radius = 0;
        if (DEBUG) {

        }
    } else if (radius > 25) {
        radius = 25;
        if (DEBUG) {

        }
    }

    if (Build.VERSION.SDK_INT > 16) {
        Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

        final RenderScript rs = RenderScript.create(context);
        final Allocation input = Allocation.createFromBitmap(rs, sentBitmap,
                Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
        final Allocation output = Allocation.createTyped(rs, input.getType());
        final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
        script.setRadius(radius /* e.g. 3.f */);
        script.setInput(input);
        script.forEach(output);
        output.copyTo(bitmap);
        return bitmap;
    }

    // Stack Blur v1.0 from
    // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
    //
    // Java Author: Mario Klingemann <mario at quasimondo.com>
    // http://incubator.quasimondo.com
    // created Feburary 29, 2004
    // Android port : Yahel Bouaziz <yahel at kayenko.com>
    // http://www.kayenko.com
    // ported april 5th, 2012

    // This is a compromise between Gaussian Blur and Box blur
    // It creates much better looking blurs than Box Blur, but is
    // 7x faster than my Gaussian Blur implementation.
    //
    // I called it Stack Blur because this describes best how this
    // filter works internally: it creates a kind of moving stack
    // of colors whilst scanning through the image. Thereby it
    // just has to add one new block of color to the right side
    // of the stack and remove the leftmost color. The remaining
    // colors on the topmost layer of the stack are either added on
    // or reduced by one, depending on if they are on the right or
    // on the left side of the stack.
    //
    // If you are using this algorithm in your code please add
    // the following line:
    //
    // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>

    Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

    if (radius < 1) {
        return (null);
    }

    int w = bitmap.getWidth();
    int h = bitmap.getHeight();

    int[] pix = new int[w * h];
    Log.e("pix", w + " " + h + " " + pix.length);
    bitmap.getPixels(pix, 0, w, 0, 0, w, h);

    int wm = w - 1;
    int hm = h - 1;
    int wh = w * h;
    int div = radius + radius + 1;

    int r[] = new int[wh];
    int g[] = new int[wh];
    int b[] = new int[wh];
    int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
    int vmin[] = new int[Math.max(w, h)];

    int divsum = (div + 1) >> 1;
    divsum *= divsum;
    int dv[] = new int[256 * divsum];
    for (i = 0; i < 256 * divsum; i++) {
        dv[i] = (i / divsum);
    }

    yw = yi = 0;

    int[][] stack = new int[div][3];
    int stackpointer;
    int stackstart;
    int[] sir;
    int rbs;
    int r1 = radius + 1;
    int routsum, goutsum, boutsum;
    int rinsum, ginsum, binsum;

    for (y = 0; y < h; y++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        for (i = -radius; i <= radius; i++) {
            p = pix[yi + Math.min(wm, Math.max(i, 0))];
            sir = stack[i + radius];
            sir[0] = (p & 0xff0000) >> 16;
            sir[1] = (p & 0x00ff00) >> 8;
            sir[2] = (p & 0x0000ff);
            rbs = r1 - Math.abs(i);
            rsum += sir[0] * rbs;
            gsum += sir[1] * rbs;
            bsum += sir[2] * rbs;
            if (i > 0) {
                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];
            } else {
                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];
            }
        }
        stackpointer = radius;

        for (x = 0; x < w; x++) {

            r[yi] = dv[rsum];
            g[yi] = dv[gsum];
            b[yi] = dv[bsum];

            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;

            stackstart = stackpointer - radius + div;
            sir = stack[stackstart % div];

            routsum -= sir[0];
            goutsum -= sir[1];
            boutsum -= sir[2];

            if (y == 0) {
                vmin[x] = Math.min(x + radius + 1, wm);
            }
            p = pix[yw + vmin[x]];

            sir[0] = (p & 0xff0000) >> 16;
            sir[1] = (p & 0x00ff00) >> 8;
            sir[2] = (p & 0x0000ff);

            rinsum += sir[0];
            ginsum += sir[1];
            binsum += sir[2];

            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;

            stackpointer = (stackpointer + 1) % div;
            sir = stack[(stackpointer) % div];

            routsum += sir[0];
            goutsum += sir[1];
            boutsum += sir[2];

            rinsum -= sir[0];
            ginsum -= sir[1];
            binsum -= sir[2];

            yi++;
        }
        yw += w;
    }
    for (x = 0; x < w; x++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        yp = -radius * w;
        for (i = -radius; i <= radius; i++) {
            yi = Math.max(0, yp) + x;

            sir = stack[i + radius];

            sir[0] = r[yi];
            sir[1] = g[yi];
            sir[2] = b[yi];

            rbs = r1 - Math.abs(i);

            rsum += r[yi] * rbs;
            gsum += g[yi] * rbs;
            bsum += b[yi] * rbs;

            if (i > 0) {
                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];
            } else {
                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];
            }

            if (i < hm) {
                yp += w;
            }
        }
        yi = x;
        stackpointer = radius;
        for (y = 0; y < h; y++) {
            // Preserve alpha channel: ( 0xff000000 & pix[yi] )
            pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];

            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;

            stackstart = stackpointer - radius + div;
            sir = stack[stackstart % div];

            routsum -= sir[0];
            goutsum -= sir[1];
            boutsum -= sir[2];

            if (x == 0) {
                vmin[y] = Math.min(y + r1, hm) * w;
            }
            p = x + vmin[y];

            sir[0] = r[p];
            sir[1] = g[p];
            sir[2] = b[p];

            rinsum += sir[0];
            ginsum += sir[1];
            binsum += sir[2];

            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;

            stackpointer = (stackpointer + 1) % div;
            sir = stack[stackpointer];

            routsum += sir[0];
            goutsum += sir[1];
            boutsum += sir[2];

            rinsum -= sir[0];
            ginsum -= sir[1];
            binsum -= sir[2];

            yi += w;
        }
    }

    Log.e("pix", w + " " + h + " " + pix.length);
    bitmap.setPixels(pix, 0, w, 0, 0, w, h);
    return (bitmap);
}

---

From source file:Main.java

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap fastblur(Context context, Bitmap sentBitmap, float radius) {

    if (Build.VERSION.SDK_INT > 16 && (!Build.MODEL.contains("google_sdk") && !Build.MODEL.contains("Emulator")
            && !Build.MODEL.contains("Android SDK") && !Build.FINGERPRINT.contains("vbox86p"))) {
        Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

        final RenderScript rs = RenderScript.create(context);
        final Allocation input = Allocation.createFromBitmap(rs, sentBitmap,
                Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
        final Allocation output = Allocation.createTyped(rs, input.getType());
        final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
        script.setRadius(radius /* e.g. 3.f */);
        script.setInput(input);/* w  w  w.  j a v a  2  s.  co m*/
        script.forEach(output);
        output.copyTo(bitmap);
        return bitmap;
    }

    radius *= 0.1;
    return blurfast(sentBitmap, (int) radius);

    // Stack Blur v1.0 from
    // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
    //
    // Java Author: Mario Klingemann <mario at quasimondo.com>
    // http://incubator.quasimondo.com
    // created Feburary 29, 2004
    // Android port : Yahel Bouaziz <yahel at kayenko.com>
    // http://www.kayenko.com
    // ported april 5th, 2012

    // This is a compromise between Gaussian Blur and Box blur
    // It creates much better looking blurs than Box Blur, but is
    // 7x faster than my Gaussian Blur implementation.
    //
    // I called it Stack Blur because this describes best how this
    // filter works internally: it creates a kind of moving stack
    // of colors whilst scanning through the image. Thereby it
    // just has to add one new block of color to the right side
    // of the stack and remove the leftmost color. The remaining
    // colors on the topmost layer of the stack are either added on
    // or reduced by one, depending on if they are on the right or
    // on the left side of the stack.
    //
    // If you are using this algorithm in your code please add
    // the following line:
    //
    // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>

    /*        try {
     Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
            
     radius *= 0.8;
     if (radius < 1) {
     return (null);
     }
            
     int w = bitmap.getWidth();
     int h = bitmap.getHeight();
            
     int[] pix = new int[w * h];
     Log.e("pix", w + " " + h + " " + pix.length);
     bitmap.getPixels(pix, 0, w, 0, 0, w, h);
            
     int wm = w - 1;
     int hm = h - 1;
     int wh = w * h;
     int div = (int) (radius + radius + 1);
            
     int r[] = new int[wh];
     int g[] = new int[wh];
     int b[] = new int[wh];
     int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
     int vmin[] = new int[Math.max(w, h)];
            
     int divsum = (div + 1) >> 1;
     divsum *= divsum;
     int dv[] = new int[256 * divsum];
     for (i = 0; i < 256 * divsum; i++) {
     dv[i] = (i / divsum);
     }
            
     yw = yi = 0;
            
     int[][] stack = new int[div][3];
     int stackpointer;
     int stackstart;
     int[] sir;
     int rbs;
     int r1 = (int) (radius + 1);
     int routsum, goutsum, boutsum;
     int rinsum, ginsum, binsum;
            
     for (y = 0; y < h; y++) {
     rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
     for (i = (int) -radius; i <= radius; i++) {
     p = pix[yi + Math.min(wm, Math.max(i, 0))];
     sir = stack[((int) (i + radius))];
     sir[0] = (p & 0xff0000) >> 16;
     sir[1] = (p & 0x00ff00) >> 8;
     sir[2] = (p & 0x0000ff);
     rbs = r1 - Math.abs(i);
     rsum += sir[0] * rbs;
     gsum += sir[1] * rbs;
     bsum += sir[2] * rbs;
     if (i > 0) {
     rinsum += sir[0];
     ginsum += sir[1];
     binsum += sir[2];
     } else {
     routsum += sir[0];
     goutsum += sir[1];
     boutsum += sir[2];
     }
     }
     stackpointer = (int) radius;
            
     for (x = 0; x < w; x++) {
            
     r[yi] = dv[rsum];
     g[yi] = dv[gsum];
     b[yi] = dv[bsum];
            
     rsum -= routsum;
     gsum -= goutsum;
     bsum -= boutsum;
            
     stackstart = (int) (stackpointer - radius + div);
     sir = stack[stackstart % div];
            
     routsum -= sir[0];
     goutsum -= sir[1];
     boutsum -= sir[2];
            
     if (y == 0) {
     vmin[x] = (int) Math.min(x + radius + 1, wm);
     }
     p = pix[yw + vmin[x]];
            
     sir[0] = (p & 0xff0000) >> 16;
     sir[1] = (p & 0x00ff00) >> 8;
     sir[2] = (p & 0x0000ff);
            
     rinsum += sir[0];
     ginsum += sir[1];
     binsum += sir[2];
            
     rsum += rinsum;
     gsum += ginsum;
     bsum += binsum;
            
     stackpointer = (stackpointer + 1) % div;
     sir = stack[(stackpointer) % div];
            
     routsum += sir[0];
     goutsum += sir[1];
     boutsum += sir[2];
            
     rinsum -= sir[0];
     ginsum -= sir[1];
     binsum -= sir[2];
            
     yi++;
     }
     yw += w;
     }
     for (x = 0; x < w; x++) {
     rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
     yp = (int) (-radius * w);
     for (i = (int) -radius; i <= radius; i++) {
     yi = Math.max(0, yp) + x;
            
     sir = stack[((int) (i + radius))];
            
     sir[0] = r[yi];
     sir[1] = g[yi];
     sir[2] = b[yi];
            
     rbs = r1 - Math.abs(i);
            
     rsum += r[yi] * rbs;
     gsum += g[yi] * rbs;
     bsum += b[yi] * rbs;
            
     if (i > 0) {
     rinsum += sir[0];
     ginsum += sir[1];
     binsum += sir[2];
     } else {
     routsum += sir[0];
     goutsum += sir[1];
     boutsum += sir[2];
     }
            
     if (i < hm) {
     yp += w;
     }
     }
     yi = x;
     stackpointer = (int) radius;
     for (y = 0; y < h; y++) {
     // Preserve alpha channel: ( 0xff000000 & pix[yi] )
     pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
            
     rsum -= routsum;
     gsum -= goutsum;
     bsum -= boutsum;
            
     stackstart = (int) (stackpointer - radius + div);
     sir = stack[stackstart % div];
            
     routsum -= sir[0];
     goutsum -= sir[1];
     boutsum -= sir[2];
            
     if (x == 0) {
     vmin[y] = Math.min(y + r1, hm) * w;
     }
     p = x + vmin[y];
            
     sir[0] = r[p];
     sir[1] = g[p];
     sir[2] = b[p];
            
     rinsum += sir[0];
     ginsum += sir[1];
     binsum += sir[2];
            
     rsum += rinsum;
     gsum += ginsum;
     bsum += binsum;
            
     stackpointer = (stackpointer + 1) % div;
     sir = stack[stackpointer];
            
     routsum += sir[0];
     goutsum += sir[1];
     boutsum += sir[2];
            
     rinsum -= sir[0];
     ginsum -= sir[1];
     binsum -= sir[2];
            
     yi += w;
     }
     }
            
     bitmap.setPixels(pix, 0, w, 0, 0, w, h);
     return (bitmap);
     } catch (OutOfMemoryError ex) {
     return sentBitmap;
     }*/
}

---

From source file:Main.java

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public static Bitmap blur(Context context, Bitmap bitmap) {

    //Let's create an empty bitmap with the same size of the bitmap we want to blur
    Bitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);

    //Instantiate a new Renderscript
    RenderScript rs = RenderScript.create(context);

    //Create an Intrinsic Blur Script using the Renderscript
    ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));

    //Create the Allocations (in/out) with the Renderscript and the in/out bitmaps
    Allocation allIn = Allocation.createFromBitmap(rs, bitmap);
    Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);

    //Set the radius of the blur
    blurScript.setRadius(25.f);

    //Perform the Renderscript
    blurScript.setInput(allIn);/* w  w w.ja va2  s  . com*/
    blurScript.forEach(allOut);

    //Copy the final bitmap created by the out Allocation to the outBitmap
    allOut.copyTo(outBitmap);

    //recycle the original bitmap
    bitmap.recycle();

    //After finishing everything, we destroy the Renderscript.
    rs.destroy();

    return outBitmap;
}

---

From source file:com.slownet5.pgprootexplorer.filemanager.ui.TabsFragmentOne.java

public static Bitmap blur(Context context, Bitmap image) {
    int width = Math.round(image.getWidth() * BITMAP_SCALE);
    int height = Math.round(image.getHeight() * BITMAP_SCALE);

    Bitmap inputBitmap = Bitmap.createScaledBitmap(image, width, height, false);
    Bitmap outputBitmap = Bitmap.createBitmap(inputBitmap);

    RenderScript rs = RenderScript.create(context);
    ScriptIntrinsicBlur theIntrinsic = null;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
        theIntrinsic = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
        Allocation tmpIn = Allocation.createFromBitmap(rs, inputBitmap);
        Allocation tmpOut = Allocation.createFromBitmap(rs, outputBitmap);
        theIntrinsic.setRadius(BLUR_RADIUS);
        theIntrinsic.setInput(tmpIn);// w w  w  .jav  a 2 s .  c  o m
        theIntrinsic.forEach(tmpOut);
        tmpOut.copyTo(outputBitmap);
    } else {
        outputBitmap = BlurHelper.doBlur(image, (int) BLUR_RADIUS, false);
    }

    return outputBitmap;

}

---

From source file:com.truebanana.bitmap.BitmapUtils.java

@SuppressLint("NewApi")
public static Bitmap blur(Context context, Bitmap bitmap, float scale, int radius) {
    if (SystemUtils.getSDKVersion() >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        int width = Math.round(bitmap.getWidth() * scale);
        int height = Math.round(bitmap.getHeight() * scale);

        bitmap = Bitmap.createScaledBitmap(bitmap, width, height, false);
        Bitmap processedBitmap = Bitmap.createBitmap(bitmap);

        RenderScript rs = RenderScript.create(context);
        ScriptIntrinsicBlur sib = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
        Allocation tmpIn = Allocation.createFromBitmap(rs, bitmap);
        Allocation tmpOut = Allocation.createFromBitmap(rs, processedBitmap);
        sib.setRadius(radius);
        sib.setInput(tmpIn);/*from   ww  w  .  j  ava2 s. c o  m*/
        sib.forEach(tmpOut);
        tmpOut.copyTo(processedBitmap);

        return processedBitmap;
    } else {
        int width = Math.round(bitmap.getWidth() * scale);
        int height = Math.round(bitmap.getHeight() * scale);
        bitmap = Bitmap.createScaledBitmap(bitmap, width, height, false);

        Bitmap processedBitmap = bitmap.copy(bitmap.getConfig(), true);

        if (radius < 1) {
            return null;
        }

        int w = processedBitmap.getWidth();
        int h = processedBitmap.getHeight();

        int[] pix = new int[w * h];
        processedBitmap.getPixels(pix, 0, w, 0, 0, w, h);

        int wm = w - 1;
        int hm = h - 1;
        int wh = w * h;
        int div = radius + radius + 1;

        int r[] = new int[wh];
        int g[] = new int[wh];
        int b[] = new int[wh];
        int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
        int vmin[] = new int[Math.max(w, h)];

        int divsum = (div + 1) >> 1;
        divsum *= divsum;
        int dv[] = new int[256 * divsum];
        for (i = 0; i < 256 * divsum; i++) {
            dv[i] = (i / divsum);
        }

        yw = yi = 0;

        int[][] stack = new int[div][3];
        int stackpointer;
        int stackstart;
        int[] sir;
        int rbs;
        int r1 = radius + 1;
        int routsum, goutsum, boutsum;
        int rinsum, ginsum, binsum;

        for (y = 0; y < h; y++) {
            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
            for (i = -radius; i <= radius; i++) {
                p = pix[yi + Math.min(wm, Math.max(i, 0))];
                sir = stack[i + radius];
                sir[0] = (p & 0xff0000) >> 16;
                sir[1] = (p & 0x00ff00) >> 8;
                sir[2] = (p & 0x0000ff);
                rbs = r1 - Math.abs(i);
                rsum += sir[0] * rbs;
                gsum += sir[1] * rbs;
                bsum += sir[2] * rbs;
                if (i > 0) {
                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];
                } else {
                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];
                }
            }
            stackpointer = radius;

            for (x = 0; x < w; x++) {
                r[yi] = dv[rsum];
                g[yi] = dv[gsum];
                b[yi] = dv[bsum];

                rsum -= routsum;
                gsum -= goutsum;
                bsum -= boutsum;

                stackstart = stackpointer - radius + div;
                sir = stack[stackstart % div];

                routsum -= sir[0];
                goutsum -= sir[1];
                boutsum -= sir[2];

                if (y == 0) {
                    vmin[x] = Math.min(x + radius + 1, wm);
                }
                p = pix[yw + vmin[x]];

                sir[0] = (p & 0xff0000) >> 16;
                sir[1] = (p & 0x00ff00) >> 8;
                sir[2] = (p & 0x0000ff);

                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];

                rsum += rinsum;
                gsum += ginsum;
                bsum += binsum;

                stackpointer = (stackpointer + 1) % div;
                sir = stack[(stackpointer) % div];

                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];

                rinsum -= sir[0];
                ginsum -= sir[1];
                binsum -= sir[2];

                yi++;
            }
            yw += w;
        }
        for (x = 0; x < w; x++) {
            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
            yp = -radius * w;
            for (i = -radius; i <= radius; i++) {
                yi = Math.max(0, yp) + x;

                sir = stack[i + radius];

                sir[0] = r[yi];
                sir[1] = g[yi];
                sir[2] = b[yi];

                rbs = r1 - Math.abs(i);

                rsum += r[yi] * rbs;
                gsum += g[yi] * rbs;
                bsum += b[yi] * rbs;

                if (i > 0) {
                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];
                } else {
                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];
                }

                if (i < hm) {
                    yp += w;
                }
            }
            yi = x;
            stackpointer = radius;
            for (y = 0; y < h; y++) {
                // Preserve alpha channel: ( 0xff000000 & pix[yi] )
                pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];

                rsum -= routsum;
                gsum -= goutsum;
                bsum -= boutsum;

                stackstart = stackpointer - radius + div;
                sir = stack[stackstart % div];

                routsum -= sir[0];
                goutsum -= sir[1];
                boutsum -= sir[2];

                if (x == 0) {
                    vmin[y] = Math.min(y + r1, hm) * w;
                }
                p = x + vmin[y];

                sir[0] = r[p];
                sir[1] = g[p];
                sir[2] = b[p];

                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];

                rsum += rinsum;
                gsum += ginsum;
                bsum += binsum;

                stackpointer = (stackpointer + 1) % div;
                sir = stack[stackpointer];

                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];

                rinsum -= sir[0];
                ginsum -= sir[1];
                binsum -= sir[2];

                yi += w;
            }
        }
        processedBitmap.setPixels(pix, 0, w, 0, 0, w, h);

        return processedBitmap;
    }
}

---

• «
• 1
• 2
• 3
• »