[关闭]
@Tyhj 2017-02-24T13:04:26.000000Z 字数 5268 阅读 1452

背景模糊

Android

本文固定链接：https://www.zybuluo.com/Tyhj/note/666366
图片模糊，试过很多工具什么的，还是这个类比较好,直接用就好了

使用方法：

  1. imageView.setImageBitmap(BlurUtil.doBlur(drawable,10,15));
  3. package custom;
  5. import android.graphics.Bitmap;
  6. import android.media.ThumbnailUtils;
  8. /**
  9.  * 图片虚化辅助类
  10.  * Created by jay on 11/7/15.
  11.  */
  12. public class BlurUtil {
  14.     private static final String TAG = BlurUtil.class.getSimpleName();
  16.     /**
  17.      * 对图片进行毛玻璃化
  18.      * @param sentBitmap 位图
  19.      * @param radius 虚化程度
  20.      * @param canReuseInBitmap 是否重用
  21.      * @return 位图
  22.      */
  23.     public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {
  25.         // Stack Blur v1.0 from
  26.         // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
  27.         //
  28.         // Java Author: Mario Klingemann <mario at quasimondo.com>
  29.         // http://incubator.quasimondo.com
  30.         // created Feburary 29, 2004
  31.         // Android port : Yahel Bouaziz <yahel at kayenko.com>
  32.         // http://www.kayenko.com
  33.         // ported april 5th, 2012
  35.         // This is a compromise between Gaussian Blur and Box blur
  36.         // It creates much better looking blurs than Box Blur, but is
  37.         // 7x faster than my Gaussian Blur implementation.
  38.         //
  39.         // I called it Stack Blur because this describes best how this
  40.         // filter works internally: it creates a kind of moving stack
  41.         // of colors whilst scanning through the image. Thereby it
  42.         // just has to add one new block of color to the right side
  43.         // of the stack and remove the leftmost color. The remaining
  44.         // colors on the topmost layer of the stack are either added on
  45.         // or reduced by one, depending on if they are on the right or
  46.         // on the left side of the stack.
  47.         //
  48.         // If you are using this algorithm in your code please add
  49.         // the following line:
  50.         //
  51.         // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>
  53.         Bitmap bitmap;
  54.         if (canReuseInBitmap) {
  55.             bitmap = sentBitmap;
  56.         } else {
  57.             bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
  58.         }
  60.         if (radius < 1) {
  61.             return (null);
  62.         }
  64.         int w = bitmap.getWidth();
  65.         int h = bitmap.getHeight();
  67.         int[] pix = new int[w * h];
  68.         bitmap.getPixels(pix, 0, w, 0, 0, w, h);
  70.         int wm = w - 1;
  71.         int hm = h - 1;
  72.         int wh = w * h;
  73.         int div = radius + radius + 1;
  75.         int r[] = new int[wh];
  76.         int g[] = new int[wh];
  77.         int b[] = new int[wh];
  78.         int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
  79.         int vmin[] = new int[Math.max(w, h)];
  81.         int divsum = (div + 1) >> 1;
  82.         divsum *= divsum;
  83.         int dv[] = new int[256 * divsum];
  84.         for (i = 0; i < 256 * divsum; i++) {
  85.             dv[i] = (i / divsum);
  86.         }
  88.         yw = yi = 0;
  90.         int[][] stack = new int[div][3];
  91.         int stackpointer;
  92.         int stackstart;
  93.         int[] sir;
  94.         int rbs;
  95.         int r1 = radius + 1;
  96.         int routsum, goutsum, boutsum;
  97.         int rinsum, ginsum, binsum;
  99.         for (y = 0; y < h; y++) {
  100.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
  101.             for (i = -radius; i <= radius; i++) {
  102.                 p = pix[yi + Math.min(wm, Math.max(i, 0))];
  103.                 sir = stack[i + radius];
  104.                 sir[0] = (p & 0xff0000) >> 16;
  105.                 sir[1] = (p & 0x00ff00) >> 8;
  106.                 sir[2] = (p & 0x0000ff);
  107.                 rbs = r1 - Math.abs(i);
  108.                 rsum += sir[0] * rbs;
  109.                 gsum += sir[1] * rbs;
  110.                 bsum += sir[2] * rbs;
  111.                 if (i > 0) {
  112.                     rinsum += sir[0];
  113.                     ginsum += sir[1];
  114.                     binsum += sir[2];
  115.                 } else {
  116.                     routsum += sir[0];
  117.                     goutsum += sir[1];
  118.                     boutsum += sir[2];
  119.                 }
  120.             }
  121.             stackpointer = radius;
  123.             for (x = 0; x < w; x++) {
  125.                 r[yi] = dv[rsum];
  126.                 g[yi] = dv[gsum];
  127.                 b[yi] = dv[bsum];
  129.                 rsum -= routsum;
  130.                 gsum -= goutsum;
  131.                 bsum -= boutsum;
  133.                 stackstart = stackpointer - radius + div;
  134.                 sir = stack[stackstart % div];
  136.                 routsum -= sir[0];
  137.                 goutsum -= sir[1];
  138.                 boutsum -= sir[2];
  140.                 if (y == 0) {
  141.                     vmin[x] = Math.min(x + radius + 1, wm);
  142.                 }
  143.                 p = pix[yw + vmin[x]];
  145.                 sir[0] = (p & 0xff0000) >> 16;
  146.                 sir[1] = (p & 0x00ff00) >> 8;
  147.                 sir[2] = (p & 0x0000ff);
  149.                 rinsum += sir[0];
  150.                 ginsum += sir[1];
  151.                 binsum += sir[2];
  153.                 rsum += rinsum;
  154.                 gsum += ginsum;
  155.                 bsum += binsum;
  157.                 stackpointer = (stackpointer + 1) % div;
  158.                 sir = stack[(stackpointer) % div];
  160.                 routsum += sir[0];
  161.                 goutsum += sir[1];
  162.                 boutsum += sir[2];
  164.                 rinsum -= sir[0];
  165.                 ginsum -= sir[1];
  166.                 binsum -= sir[2];
  168.                 yi++;
  169.             }
  170.             yw += w;
  171.         }
  172.         for (x = 0; x < w; x++) {
  173.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
  174.             yp = -radius * w;
  175.             for (i = -radius; i <= radius; i++) {
  176.                 yi = Math.max(0, yp) + x;
  178.                 sir = stack[i + radius];
  180.                 sir[0] = r[yi];
  181.                 sir[1] = g[yi];
  182.                 sir[2] = b[yi];
  184.                 rbs = r1 - Math.abs(i);
  186.                 rsum += r[yi] * rbs;
  187.                 gsum += g[yi] * rbs;
  188.                 bsum += b[yi] * rbs;
  190.                 if (i > 0) {
  191.                     rinsum += sir[0];
  192.                     ginsum += sir[1];
  193.                     binsum += sir[2];
  194.                 } else {
  195.                     routsum += sir[0];
  196.                     goutsum += sir[1];
  197.                     boutsum += sir[2];
  198.                 }
  200.                 if (i < hm) {
  201.                     yp += w;
  202.                 }
  203.             }
  204.             yi = x;
  205.             stackpointer = radius;
  206.             for (y = 0; y < h; y++) {
  207.                 // Preserve alpha channel: ( 0xff000000 & pix[yi] )
  208.                 pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
  210.                 rsum -= routsum;
  211.                 gsum -= goutsum;
  212.                 bsum -= boutsum;
  214.                 stackstart = stackpointer - radius + div;
  215.                 sir = stack[stackstart % div];
  217.                 routsum -= sir[0];
  218.                 goutsum -= sir[1];
  219.                 boutsum -= sir[2];
  221.                 if (x == 0) {
  222.                     vmin[y] = Math.min(y + r1, hm) * w;
  223.                 }
  224.                 p = x + vmin[y];
  226.                 sir[0] = r[p];
  227.                 sir[1] = g[p];
  228.                 sir[2] = b[p];
  230.                 rinsum += sir[0];
  231.                 ginsum += sir[1];
  232.                 binsum += sir[2];
  234.                 rsum += rinsum;
  235.                 gsum += ginsum;
  236.                 bsum += binsum;
  238.                 stackpointer = (stackpointer + 1) % div;
  239.                 sir = stack[stackpointer];
  241.                 routsum += sir[0];
  242.                 goutsum += sir[1];
  243.                 boutsum += sir[2];
  245.                 rinsum -= sir[0];
  246.                 ginsum -= sir[1];
  247.                 binsum -= sir[2];
  249.                 yi += w;
  250.             }
  251.         }
  253.         bitmap.setPixels(pix, 0, w, 0, 0, w, h);
  255. //        print("虚化后 ",bitmap);
  256.         return (bitmap);
  257.     }
  259.     /**
  260.      * 对图片进行毛玻璃化
  261.      * @param originBitmap 位图
  262.      * @param scaleRatio 缩放比率
  263.      * @param blurRadius 毛玻璃化比率，虚化程度
  264.      * @return 位图
  265.      */
  266.     public static Bitmap doBlur(Bitmap originBitmap, int scaleRatio, int blurRadius){
  267. //        print("原图：：",originBitmap);
  268.         Bitmap scaledBitmap = Bitmap.createScaledBitmap(originBitmap,
  269.                 originBitmap.getWidth() / scaleRatio,
  270.                 originBitmap.getHeight() / scaleRatio,
  271.                 false);
  272.         Bitmap blurBitmap = doBlur(scaledBitmap, blurRadius, false);
  273.         scaledBitmap.recycle();
  274.         return blurBitmap;
  275.     }
  277. //    private static void print(String tag, Bitmap originBitmap) {
  278. //        StringBuilder sb = new StringBuilder(tag);
  279. //        sb.append( String.format("  width=%s,",originBitmap.getWidth()));
  280. //        sb.append( String.format(" height=%s,",originBitmap.getHeight()));
  281. //        Log.i(TAG,sb.toString());
  282. //    }
  284.     /**
  285.      * 对图片进行 毛玻璃化，虚化
  286.      * @param originBitmap 位图
  287.      * @param width 缩放后的期望宽度
  288.      * @param height 缩放后的期望高度
  289.      * @param blurRadius 虚化程度
  290.      * @return 位图
  291.      */
  292.     public static Bitmap doBlur(Bitmap originBitmap,int width,int height,int blurRadius){
  293.         Bitmap thumbnail = ThumbnailUtils.extractThumbnail(originBitmap, width, height);
  294.         Bitmap blurBitmap = doBlur(thumbnail, blurRadius, true);
  295.         thumbnail.recycle();
  296.         return blurBitmap;
  297.     }
  298. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注