-
Notifications
You must be signed in to change notification settings - Fork 150
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge pull request #17 from Manabu-GT/develop
Develop
- Loading branch information
Showing
12 changed files
with
463 additions
and
204 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,6 +1,6 @@ | ||
| #Wed Apr 10 15:27:10 PDT 2013 | ||
| #Fri Mar 17 20:20:19 MDT 2017 | ||
| distributionBase=GRADLE_USER_HOME | ||
| distributionPath=wrapper/dists | ||
| zipStoreBase=GRADLE_USER_HOME | ||
| zipStorePath=wrapper/dists | ||
| distributionUrl=http\://services.gradle.org/distributions/gradle-2.2.1-all.zip | ||
| distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -2,8 +2,10 @@ | |
|
|
||
| import android.content.Context; | ||
| import android.graphics.Bitmap; | ||
| import android.support.annotation.NonNull; | ||
| import android.support.v8.renderscript.Allocation; | ||
| import android.support.v8.renderscript.Element; | ||
| import android.support.v8.renderscript.RSRuntimeException; | ||
| import android.support.v8.renderscript.RenderScript; | ||
| import android.support.v8.renderscript.ScriptIntrinsicBlur; | ||
|
|
||
|
|
@@ -16,27 +18,282 @@ public class Blur { | |
|
|
||
| private static final int DEFAULT_BLUR_RADIUS = 10; | ||
|
|
||
| public static Bitmap apply(Context context, Bitmap sentBitmap) { | ||
| public static Bitmap apply(@NonNull Context context, @NonNull Bitmap sentBitmap) { | ||
| return apply(context, sentBitmap, DEFAULT_BLUR_RADIUS); | ||
| } | ||
|
|
||
| public static Bitmap apply(Context context, Bitmap sentBitmap, int radius) { | ||
| 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); | ||
| script.setInput(input); | ||
| script.forEach(output); | ||
| output.copyTo(bitmap); | ||
|
|
||
| // clean up renderscript resources | ||
| rs.destroy(); | ||
| input.destroy(); | ||
| output.destroy(); | ||
| script.destroy(); | ||
| public static Bitmap apply(@NonNull Context context, @NonNull Bitmap bitmap, int radius) { | ||
|
|
||
| RenderScript rs = null; | ||
| Allocation input = null; | ||
| Allocation output = null; | ||
| ScriptIntrinsicBlur scriptBlur = null; | ||
|
|
||
| try { | ||
| rs = RenderScript.create(context); | ||
| input = Allocation.createFromBitmap(rs, bitmap, Allocation.MipmapControl.MIPMAP_NONE, | ||
| Allocation.USAGE_SCRIPT); | ||
| output = Allocation.createTyped(rs, input.getType()); | ||
| scriptBlur = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs)); | ||
|
|
||
| scriptBlur.setRadius(radius); | ||
| scriptBlur.setInput(input); | ||
| scriptBlur.forEach(output); | ||
| output.copyTo(bitmap); | ||
| } catch (RSRuntimeException e) { | ||
| // if renderscript is not available, fallback to the Stack Blur | ||
| bitmap = fastBlur(bitmap, radius, true); | ||
| } finally { | ||
| // clean up renderscript resources | ||
| if (rs != null) { | ||
| rs.destroy(); | ||
| } | ||
| if (input != null) { | ||
| input.destroy(); | ||
| } | ||
| if (output != null) { | ||
| output.destroy(); | ||
| } | ||
| if (scriptBlur != null) { | ||
| scriptBlur.destroy(); | ||
| } | ||
| } | ||
|
|
||
| return bitmap; | ||
| } | ||
|
|
||
| // Ref...http://stackoverflow.com/questions/2067955/fast-bitmap-blur-for-android-sdk | ||
| private static Bitmap fastBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) { | ||
|
|
||
| // 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 <[email protected]> | ||
|
|
||
| Bitmap bitmap; | ||
| if (canReuseInBitmap) { | ||
| bitmap = sentBitmap; | ||
| } else { | ||
| 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]; | ||
| 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; | ||
| } | ||
| } | ||
|
|
||
| bitmap.setPixels(pix, 0, w, 0, 0, w, h); | ||
|
|
||
| return bitmap; | ||
| } | ||
|
|
||
Oops, something went wrong.