¿Cómo difumina el programador la pantalla? Desarrollador de registros, desarrollo de aplicaciones

Aquí hay un algoritmo que porté desde Quasimondo. Es una especie de mezcla entre un desenfoque de caja y un desenfoque gaussiano, también es muy bonito y bastante rápido:

/ **
* Stack Blur v1.0 de
* http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
* Autor Java: Mario Klingemann
* http://incubator.quasimondo.com
* *
* creado el 29 de febrero de 2004
* Puerto de Android: Yahel Bouaziz
* http://www.kayenko.com
* portado el 5 de abril de 2012
* *
* Este es un compromiso entre Gaussian Blur y Box blur
* Crea desenfoques mucho mejores que Box Blur, pero es
* 7 veces más rápido que mi implementación Gaussian Blur.
* *
* Lo llamé Stack Blur porque esto describe mejor cómo esto
* El filtro funciona internamente: crea una especie de pila móvil
* de colores mientras se escanea a través de la imagen. Por eso
* solo tiene que agregar un nuevo bloque de color al lado derecho
* de la pila y elimine el color más a la izquierda. El restante
* los colores en la capa superior de la pila se agregan en
* o reducido en uno, dependiendo de si están a la derecha o
* en el lado izquierdo de la pila.
* *
* Si está utilizando este algoritmo en su código, agregue
* la siguiente línea:
* Algoritmo de Desenfoque de pila por Mario Klingemann
* /

Desenfoque rápido de mapa de bits público (mapa de bits enviado Mapa de bits, escala flotante, radio int) {

ancho int = Math.round (sentBitmap.getWidth () * scale);
int height = Math.round (sentBitmap.getHeight () * scale);
sentBitmap = Bitmap.createScaledBitmap (sentBitmap, ancho, alto, falso);

Mapa de bits mapa de bits = sentBitmap.copy (sentBitmap.getConfig (), verdadero);

if (radio <1) {
retorno (nulo);
}

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

int [] pix = nuevo 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 = radio + radio + 1;

int r [] = nuevo int [wh];
int g [] = nuevo int [wh];
int b [] = nuevo 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 [] = nuevo int [256 * divsum];
para (i = 0; i <256 * divsum; i ++) {
dv [i] = (i / divsum);
}

yw = yi = 0;

int [] [] stack = nuevo int [div] [3];
int stackpointer;
int stackstart;
int [] señor;
int rbs;
int r1 = radio + 1;
int rousum, goutsum, boutsum;
int rinsum, ginsum, binsum;

para (y = 0; y <h; y ++) {
rinsum = ginsum = binsum = rousum = goutsum = boutsum = rsum = gsum = bsum = 0;
para (i = -radius; i <= radio; i ++) {
p = pix [yi + Math.min (wm, Math.max (i, 0))];
sir = pila [i + radio];
señor [0] = (p & 0xff0000) >> 16;
señor [1] = (p & 0x00ff00) >> 8;
señor [2] = (p & 0x0000ff);
rbs = r1 – Math.abs (i);
rsum + = sir [0] * rbs;
gsum + = sir [1] * rbs;
bsum + = sir [2] * rbs;
si (i> 0) {
enjuague + = señor [0];
ginsum + = señor [1];
binsum + = señor [2];
} más {
enrutamiento + = señor [0];
gota de agua + = señor [1];
boutsum + = señor [2];
}
}
stackpointer = radio;

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

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

rsum – = enrutamiento;
gsum – = goutsum;
bsum – = boutsum;

stackstart = stackpointer – radio + div;
sir = stack [stackstart% div];

enrutamiento – = señor [0];
gota de agua – = señor [1];
boutsum – = señor [2];

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

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

enjuague + = señor [0];
ginsum + = señor [1];
binsum + = señor [2];

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

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

enrutamiento + = señor [0];
gota de agua + = señor [1];
boutsum + = señor [2];

enjuague – = señor [0];
ginsum – = señor [1];
binsum – = señor [2];

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

sir = pila [i + radio];

señor [0] = r [yi];
señor [1] = g [yi];
señor [2] = b [yi];

rbs = r1 – Math.abs (i);

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

si (i> 0) {
enjuague + = señor [0];
ginsum + = señor [1];
binsum + = señor [2];
} más {
enrutamiento + = señor [0];
gota de agua + = señor [1];
boutsum + = señor [2];
}

si (i <hm) {
yp + = w;
}
}
yi = x;
stackpointer = radio;
para (y = 0; y <h; y ++) {
// Preservar el canal alfa: (0xff000000 y pix [yi])
pix [yi] = (0xff000000 y pix [yi]) | (dv [rsum] << 16) | (dv [gsum] << 8) | dv [bsum];

rsum – = enrutamiento;
gsum – = goutsum;
bsum – = boutsum;

stackstart = stackpointer – radio + div;
sir = stack [stackstart% div];

enrutamiento – = señor [0];
gota de agua – = señor [1];
boutsum – = señor [2];

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

señor [0] = r [p];
señor [1] = g [p];
señor [2] = b [p];

enjuague + = señor [0];
ginsum + = señor [1];
binsum + = señor [2];

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

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

enrutamiento + = señor [0];
gota de agua + = señor [1];
boutsum + = señor [2];

enjuague – = señor [0];
ginsum – = señor [1];
binsum – = señor [2];

yi + = w;
}
}

Log.e (“pix”, w + “” + h + “” + pix.length);
bitmap.setPixels (pix, 0, w, 0, 0, w, h);

retorno (mapa de bits);
}

Si esto no funciona, recomendaría las siguientes bibliotecas de github:

patrickfav / Dali (Probablemente lo que necesitas)
Manabu-GT / EtsyBlur (Probablemente lo que necesitas)
wasabeef / borrosa
500px / 500px-android-blur
Blur Module – Genius-Android Helper Site
Dimezis / BlurView
wl9739 / BlurredView

¡Espero que esto ayude! ¡Buena suerte!

Fuente: Fast Bitmap Blur para Android SDK