Android fuzzy processing simply achieves frosted glass effect

Updated: February 19, 2016 15:10:36 Submission: lijiao

This article mainly introduces relevant information on Android fuzzy processing to simply achieve frosted glass effects. Friends who need it can refer to it

Since the iOS system introduced the Blur effect, it is calledFrosted glass, blurring effect, matte effect, major systems began to imitate. What is the effect? Let’s take a look at the picture below:

Everyone knows the effect. How to implement it in Android? To put it bluntly, it is to blur the pictures. The editor will first tell you the principles of Android's advanced blur technology, as follows:

First I create an empty bitmap and copy part of the background in it. After that, I will blur this bitmap and set it as the background of the TextView.
Save the Canvas state through this bitmap;
Move Canvas to the TextView location in the parent layout file;
Draw the content of the ImageView into the bitmap;
At this time, we have a bitmap of the same size as TextView, which contains part of the content of the ImageView, which is the content of the layout layer behind the TextView;
Create an instance of Renderscript;
Copy a copy of the bitmap into the data slice required by Renderscript;
Create an instance of Renderscript fuzzy processing;
Set the input, radius range and then blur;
Copy the processed results back to the previous bitmap;
OK, we have already blurred bitmap, and we can set it as TextView background;

I am recently working on an app, which has a function that requires the special effects of frosted glass for image processing. After some research, I found three implementation solutions, each of which have advantages and disadvantages. If the system's API is above 16, you can use the methods provided by the system to process the pictures directly, but the editor believes that the solution below is the best achievement.
The code is as follows:

public Bitmap fastblur(Context context, Bitmap sentBitmap, int radius) { 
 
    Bitmap bitmap = ((), true); 
 
    if (radius < 1) { 
      return (null); 
    } 
 
    int w = (); 
    int h = (); 
 
    int[] pix = new int[w * h]; 
    (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[(w, h)]; 
 
    int divsum = (div + 1) >> 1; 
    divsum *= divsum; 
    int temp = 256 * divsum; 
    int dv[] = new int[temp]; 
    for (i = 0; i < temp; 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 + (wm, (i, 0))]; 
        sir = stack[i + radius]; 
        sir[0] = (p & 0xff0000) >> 16; 
        sir[1] = (p & 0x00ff00) >> 8; 
        sir[2] = (p & 0x0000ff); 
        rbs = r1 - (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] = (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 = (0, yp) + x; 
 
        sir = stack[i + radius]; 
 
        sir[0] = r[yi]; 
        sir[1] = g[yi]; 
        sir[2] = b[yi]; 
 
        rbs = r1 - (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++) { 
        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] = (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; 
      } 
    } 
 
    (pix, 0, w, 0, 0, w, h); 
    return (bitmap); 
  }

The above is all about this article, helping you easily achieve frosted glass effect. I hope you like it.

Android
Fuzzy processing
Frosted glass effect

In-depth analysis of android life cycle (II)

The life cycle of an Android program is controlled by the system rather than directly controlled by the program itself. This is a bit different from our thinking when writing desktop applications. This article will introduce it in detail. Friends who need to know can refer to it.
2012-12-12
An example analysis of the third-level caching mechanism of Android pictures

This article mainly introduces relevant information on the analysis of the third-level caching mechanism of Android pictures. Friends who need it can refer to it.
2017-05-05
How to package and upload Android gradle automatically

This article mainly introduces the method of packaging and automatically uploading Android gradle. The editor thinks it is quite good. Now I will share it with you and give you a reference. Let's take a look with the editor
2017-09-09
Android implementation of Zhihu tab dynamic hidden effect example

I believe that tabs should be familiar to everyone. Recently, I found that the dynamic hidden effect of Zhihu tabs is good. The following article mainly introduces relevant information about Android's dynamic hidden effect of Zhihu tabs. The article introduces the example code in detail. Friends who need it can refer to it. Let's learn and learn together with the editor.
2018-02-02
Generate code of Android local verification code

This article mainly introduces the generation of Android local verification code in detail. The sample code in the article is introduced in detail and has certain reference value. Interested friends can refer to it.
2021-01-01
Android UI design and development introduction and simple implementation boot interface

This article mainly introduces the ViewPager introduction and simple implementation guidance interface for Android UI design and development. It has certain reference value. Interested friends can refer to it.
2017-08-08
Android Bluetooth chat open source project

This article mainly introduces the development of Android Bluetooth chat open source project in detail, which has certain reference value. Interested friends can refer to it.
2018-06-06
Solution to the sliding conflict of DrawerLayout+ViewPager in Android

This article mainly introduces the solution to the sliding conflict of DrawerLayout+ViewPager in Android in detail. It has certain reference value. Interested friends can refer to it.
2017-06-06
Fragment + RadioButton implements the bottom navigation bar in android

This article mainly introduces the bottom navigation bar implemented by Fragment+RadioButton in Android, which has certain reference value. Interested friends can refer to it.
2017-03-03
Solution to the conflict of listview nested scrollveiw in Android

This article mainly introduces the solution to the conflict of listview nested scrollveiw in Android in detail. It has certain reference value. Interested friends can refer to it.
2017-01-01

Android fuzzy processing simply achieves frosted glass effect

Related Articles

Latest Comments