Android examples for android.graphics:Bitmap Operation
Bitmap blur fast
package com.luciofm.ifican.app.anim; import android.animation.Animator; import android.animation.AnimatorSet; import android.animation.ObjectAnimator; import android.annotation.TargetApi; import android.content.Context; import android.graphics.Bitmap; import android.graphics.drawable.BitmapDrawable; import android.os.Build; import android.renderscript.Allocation; import android.renderscript.Element; import android.renderscript.RenderScript; import android.renderscript.ScriptIntrinsicBlur; import android.transition.TransitionManager; import android.view.View; import android.view.ViewGroup; /**/*from ww w. ja va2s . co m*/ * Created by luciofm on 5/25/14. */ public class AnimUtils { private AnimUtils() { } public static void shakeView(final View view) { ObjectAnimator physX = ObjectAnimator.ofFloat(view, "translationX", -12f, 12f); physX.setDuration(50); physX.setRepeatCount(10); physX.setRepeatMode(ObjectAnimator.RESTART); physX.addListener(new SimpleAnimatorListener() { @Override public void onAnimationEnd(Animator animation) { view.animate().translationX(0f).setDuration(10); } }); physX.start(); } public static void beginDelayedTransition(ViewGroup container) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) TransitionManager.beginDelayedTransition(container); } public static Animator createXTransition(View view, boolean enter) { ObjectAnimator x; ObjectAnimator y; if (enter) { x = ObjectAnimator.ofFloat(view, "translationX", 1f, 0f); y = ObjectAnimator.ofFloat(view, "translationY", 1f, 0f); } else { x = ObjectAnimator.ofFloat(view, "translationX", 0f, -1f); y = ObjectAnimator.ofFloat(view, "translationY", 0f, -1f); } AnimatorSet set = new AnimatorSet(); set.playTogether(x, y); return set; } /** * This method of image pixelization utilizes the bitmap scaling operations built * into the framework. By downscaling the bitmap and upscaling it back to its * original size (while setting the filter flag to false), the same effect can be * achieved with much better performance. */ public static BitmapDrawable builtInPixelization(Context context, float pixelizationFactor, Bitmap bitmap) { int width = bitmap.getWidth(); int height = bitmap.getHeight(); int downScaleFactorWidth = (int) (pixelizationFactor * width); downScaleFactorWidth = downScaleFactorWidth > 0 ? downScaleFactorWidth : 1; int downScaleFactorHeight = (int) (pixelizationFactor * height); downScaleFactorHeight = downScaleFactorHeight > 0 ? downScaleFactorHeight : 1; int downScaledWidth = width / downScaleFactorWidth; int downScaledHeight = height / downScaleFactorHeight; Bitmap pixelatedBitmap = Bitmap.createScaledBitmap(bitmap, downScaledWidth, downScaledHeight, false); /* Bitmap's createScaledBitmap method has a filter parameter that can be set to either * true or false in order to specify either bilinear filtering or point sampling * respectively when the bitmap is scaled up or now. * * Similarly, a BitmapDrawable also has a flag to specify the same thing. When the * BitmapDrawable is applied to an ImageView that has some scaleType, the filtering * flag is taken into consideration. However, for optimization purposes, this flag was * ignored in BitmapDrawables before Jelly Bean MR1. * * Here, it is important to note that prior to JBMR1, two bitmap scaling operations * are required to achieve the pixelization effect. Otherwise, a BitmapDrawable * can be created corresponding to the downscaled bitmap such that when it is * upscaled to fit the ImageView, the upscaling operation is a lot faster since * it uses internal optimizations to fit the ImageView. * */ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { BitmapDrawable bitmapDrawable = new BitmapDrawable( context.getResources(), pixelatedBitmap); bitmapDrawable.setFilterBitmap(false); return bitmapDrawable; } else { Bitmap upscaled = Bitmap.createScaledBitmap(pixelatedBitmap, width, height, false); return new BitmapDrawable(context.getResources(), upscaled); } } public static final float DEFAULT_BLUR_RADIUS = 12f; public static Bitmap fastblur(Context context, Bitmap sentBitmap) { return fastblur(context, sentBitmap, DEFAULT_BLUR_RADIUS); } @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); 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; }*/ } static Bitmap blurfast(Bitmap bmp, int radius) { try { Bitmap bitmap = bmp.copy(bmp.getConfig(), true); int w = bmp.getWidth(); int h = bmp.getHeight(); int[] pix = new int[w * h]; bmp.getPixels(pix, 0, w, 0, 0, w, h); for (int r = radius; r >= 1; r /= 2) { for (int i = r; i < h - r; i++) { for (int j = r; j < w - r; j++) { int tl = pix[(i - r) * w + j - r]; int tr = pix[(i - r) * w + j + r]; int tc = pix[(i - r) * w + j]; int bl = pix[(i + r) * w + j - r]; int br = pix[(i + r) * w + j + r]; int bc = pix[(i + r) * w + j]; int cl = pix[i * w + j - r]; int cr = pix[i * w + j + r]; pix[(i * w) + j] = 0xFF000000 | (((tl & 0xFF) + (tr & 0xFF) + (tc & 0xFF) + (bl & 0xFF) + (br & 0xFF) + (bc & 0xFF) + (cl & 0xFF) + (cr & 0xFF)) >> 3) & 0xFF | (((tl & 0xFF00) + (tr & 0xFF00) + (tc & 0xFF00) + (bl & 0xFF00) + (br & 0xFF00) + (bc & 0xFF00) + (cl & 0xFF00) + (cr & 0xFF00)) >> 3) & 0xFF00 | (((tl & 0xFF0000) + (tr & 0xFF0000) + (tc & 0xFF0000) + (bl & 0xFF0000) + (br & 0xFF0000) + (bc & 0xFF0000) + (cl & 0xFF0000) + (cr & 0xFF0000)) >> 3) & 0xFF0000; } } } bitmap.setPixels(pix, 0, w, 0, 0, w, h); return bitmap; } catch (Exception e) { return bmp; } } }