Animazione sfocatura Android Image

Question

Sto cercando di aggiungere un'animazione sfocata a ImageView, ma con una durata impostata. Quindi, ad esempio, voglio che l'immagine si offuschi nel tempo.

Ho già il metodo per sfocare l'immagine, ma ciò di cui ho bisogno è di passare da sfocatura a nessuna sfocatura su, diciamo, 2 secondi.

Qualcuno può aiutarmi?

MODIFICA: questo è il metodo che attualmente devo sfocare l'immagine.

public Bitmap blur(Bitmap sentBitmap, int radius) { 

    // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com> 

    Bitmap 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]; 
    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 = 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; 
     } 
    } 

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

    return (bitmap); 
} 

Answer 1

Gli effetti di sfocatura sono sempre difficili su Android. In sostanza devi decidere tra aspetto e prestazioni. Migliore è l'aspetto sfocato, più tempo è necessario e se la sfocatura non è istantanea, non è possibile animare realmente la sfocatura.

L'algoritmo di sfocatura originale produce risultati davvero buoni, ma per questo è anche molto lento rendendo impossibile l'animazione sfocata. Giusto per dimostrare che cosa ci vorrebbe per sfocare efficacemente questa immagine ho creato un semplice animazione sfocatura scalando la bitmap giù:

public class BlurAnimation extends Animation { 

    private final ImageView imageView; 
    private final Bitmap bitmap; 
    private final float startValue; 
    private final float stopValue; 
    private final float difValue; 

    private BlurAnimation(ImageView imageView, Bitmap bitmap, int startValue, int stopValue) { 
     this.imageView = imageView; 
     this.bitmap = bitmap; 
     this.startValue = startValue; 
     this.stopValue = stopValue; 
     this.difValue = stopValue - startValue; 
    } 

    @Override 
    protected void applyTransformation(float interpolatedTime, Transformation t) { 
     super.applyTransformation(interpolatedTime, t); 

     int current = (int)(this.difValue * interpolatedTime + this.startValue + 0.5f); 
     Bitmap blurred = quickBlur(this.bitmap, current); 
     this.imageView.setImageBitmap(blurred); 
    } 

    public Bitmap quickBlur(Bitmap bitmap, int factor) { 
     if(factor <= 0) { 
      return Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888); 
     } 
     return Bitmap.createScaledBitmap(bitmap, bitmap.getWidth()/factor, bitmap.getHeight()/factor, true); 
    } 
} 

Questo funziona abbastanza bene (anche se c'è ancora un certo ritardo), ma i risultati non possono essere confrontato con l'algoritmo sfocatura, sembra proprio terribile:

Quindi, vedete, è molto difficile da coniugare prestazioni ed estetica quando si tratta di sfocatura di un'immagine, ma ci sono alcune opzioni prima e primo RenderScript. RenderScript è molto veloce e ha un filtro sfocatura gaussiano incorporato. Non l'ho mai usato, ma da quello che ho sentito potrebbe essere la soluzione al tuo problema.

Si può anche provare a caricare versioni già ridimensionate di un'immagine, questo produrrebbe lo stesso effetto della gif in alto, ma sarebbe ancora più veloce. Lo svantaggio è che l'utilizzo di questo in un Animation è di nuovo problematico, ma se hai solo bisogno di un'immagine sfocata e non ti interessa davvero la qualità, allora dovresti optare per questa opzione.

Potete trovare ulteriori informazioni su RenderScript e altre opzioni veloce sfocatura in this answer

Answer 2

La sfocatura si prende un sacco di tempo, anche sui nuovi dispositivi. Animare la sfocatura sarebbe anche peggio. Anche RenderScript non sarebbe di grande aiuto. La cosa migliore è la dissolvenza incrociata tra un immagini sfocate e non sfocate:

package com.example.simon.crossfadeblur; 

import android.app.Activity; 
import android.content.Context; 
import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.graphics.drawable.BitmapDrawable; 
import android.graphics.drawable.Drawable; 
import android.os.Bundle; 
import android.util.AttributeSet; 
import android.util.Log; 
import android.view.View; 
import android.widget.FrameLayout; 
import android.widget.ImageView; 

public class MainActivity extends Activity { 

    public Bitmap blur(Bitmap sentBitmap, int radius) { 

     // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com> 

     Bitmap 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]; 
     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 = 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; 
      } 
     } 

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

     return (bitmap); 
    } 

    public class FadeView extends FrameLayout { 
     private long mFadeDelay = 1000; 
     private ImageView mFirst; 
     private ImageView mSecond; 
     private boolean mFirstShowing; 

     public FadeView(Context context) { 
      super(context); 
      init(context); 
     } 

     public FadeView(Context context, AttributeSet attrs) { 
      super(context, attrs); 
      init(context); 
     } 

     public FadeView(Context context, AttributeSet attrs, int defStyle) { 
      super(context, attrs, defStyle); 
      init(context); 
     } 

     private void init(Context c){ 
      mFirst = new ImageView(c); 
      mSecond = new ImageView(c); 

      mFirst.setAlpha(1.0f); 
      mSecond.setAlpha(0.0f); 

      mFirstShowing = true; 

      addView(mFirst); 
      addView(mSecond); 
     } 

     public void setFadeDelay(long fadeDelay) { 
      mFadeDelay = fadeDelay; 
     } 

     public void ShowImage(Drawable d){ 
      if(mFirstShowing){ 
       mSecond.setImageDrawable(d); 
       mSecond.animate().alpha(1.0f).setDuration(mFadeDelay); 
       mFirst.animate().alpha(0.0f).setDuration(mFadeDelay); 
      }else { 
       mFirst.setImageDrawable(d); 
       mSecond.animate().alpha(0.0f).setDuration(mFadeDelay); 
       mFirst.animate().alpha(1.0f).setDuration(mFadeDelay); 
      } 

      mFirstShowing = !mFirstShowing; 
     } 
    } 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 

     final FadeView fw = new FadeView(this); 
     setContentView(fw); 

     fw.setOnClickListener(new View.OnClickListener() { 

      Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image); 
      Bitmap blurredBitmap = blur(bitmap, 100); 

      Drawable d1 = new BitmapDrawable(getResources(), blurredBitmap); 
      Drawable d2 = getResources().getDrawable(R.drawable.image); 
      boolean flag; 

      @Override 
      public void onClick(View view) { 
       if(flag){ 
        fw.ShowImage(d1); 
       }else { 
        fw.ShowImage(d2); 
       } 
       flag = !flag; 
      } 
     }); 
    } 

} 

Nota: Il codice di dissolvenza incrociata è stato preso da: Source (anima al clic)

Un altro modo che posso pensare Per fare ciò, è necessario utilizzare JQuery e animare la sfocatura all'interno di una WebView.

Answer 3

Non prolungherò troppo la mia risposta con il codice perché sinceramente non ce l'ho, ma cercherò di indicare le cose fondamentali da tenere in considerazione e alcuni link utili.

prima, l'approccio:

• sfocatura più velocemente possibile
• cache risultato sfocato
• dissolvenza incrociata

sfocatura più velocemente possibile:

il tuo algoritmo sembra davvero bello e credo che dia un buon effetto, ma la realtà è che è in esecuzione in Java VM in un singolo thread. Avrai sicuramente delle prestazioni molto migliori usando RenderScript. Questo perché RenderScript riduce automaticamente il processo di rendering al multiprocessore e alla GPU.

il codice di base perché è al di sotto, preso direttamente dal android-developers.blogspot.com:

RenderScript rs = RenderScript.create(theActivity); 
ScriptIntrinsicBlur theIntrinsic = ScriptIntrinsicBlur.create(mRS, Element.U8_4(rs));; 
Allocation tmpIn = Allocation.createFromBitmap(rs, inputBitmap); 
Allocation tmpOut = Allocation.createFromBitmap(rs, outputBitmap); 
theIntrinsic.setRadius(25.f); 
theIntrinsic.setInput(tmpIn); 
theIntrinsic.forEach(tmpOut); 
tmpOut.copyTo(outputBitmap); 

cache i risultati sfocate:

Questo perché Blur richiede tempo. Ci saranno anche molte implicazioni sulla memoria e dovresti guardarlo attentamente. Certamente non sarai in grado di farlo molto bene in una lista a scorrimento che sta riciclando visualizzazioni e cose del genere. Un suggerimento potrebbe essere quello di usare la libreria Picasso (LINK) e gestire anche il threading. Qualcosa di simile a questo:

Picasso 
    .with(context) 
    .load(/* asset/res/file/url */) 
    .transform(new BlurTransformation(value)) 
    .into(target); 

// The transform method is automatically called by Picasso in a background thread 
public class BlurTransformation implements com.squareup.picasso.Transformation { 
    private final float radius; 

    // radius is corner radii in dp 
    public BlurTransformation(final float radius) { 
     this.radius = radius; 
    } 

    @Override 
    public Bitmap transform(final Bitmap source) { 
     // do the transformation and return it here 
    } 

    @Override 
    public String key() { 
     return "blur"+Float.toString(radius); 
    } 
} 

// you can also use this to get it instantly 
Picasso... all the code... .get(); 

dissolvenza incrociata:

qui è dove si equilibrio tra prestazioni ed estetica. La realtà è che un'animazione reale è impossibile senza effettivamente rendere ogni fotogramma per ogni passaggio, ma con una dissolvenza incrociata tra alcuni fotogrammi chiave è possibile ottenere grandi risultati.

Quanti fotogrammi chiave che userete dipenderà dalle prestazioni che si desidera, la quantità di memoria disponibile sul dispositivo, ecc

Se stai bene con solo 2 fotogrammi chiave (non 1 sfocato e 1 completamente sfocato) è possibile applicare un TransitionDrawable ad esso. Se vuoi un effetto dall'aspetto più fine, dovrai creare una serie di transizioni di dissolvenza incrociata o probabilmente creare il tuo drawable personalizzato.

per solo 2 fotogrammi chiave è possibile vedere un esempio su Yahoo Weather app, se si desidera vedere un esempio con alcuni fotogrammi chiave che si desidera controllare Muzei live wallpaper.

link

molto utili *

sul link seguente vedrete una bella discussione con Muzei creatore (Roman Nurik, che è anche uno degli ingegneri di Google che lavorano per l'Android) su come ha ottenuto i fotogrammi chiave, perché questo è l'unico modo per farlo e perché, anche se codice più complesso, crea alla fine un risultato molto più bello: (versione breve) https://plus.google.com/+RomanNurik/posts/2sTQ1X2Cb2Z (versione completa) https://medium.com/@romannurik/serendipitous-ideas-3a1721a6f716

Questo link è la fonte codice per Muzei live-wallpaper in cui è possibile verificare come calcola i fotogrammi chiave e anima lo sfondo: https://github.com/romannurik/muzei

Buona fortuna e buona programmazione!

Answer 4

imageview = (ImageView) itemView.findViewById(R.id.imageView); 

     BitmapDrawable drawable = (BitmapDrawable) imageview.getDrawable(); 
     Bitmap bitmap = drawable.getBitmap(); 
     Bitmap blurred = blurRenderScript(bitmap, 25); 
     imageview.setImageBitmap(blurred); 

metodi // queste sono sfocatura

@SuppressLint("NewApi") 
    private Bitmap blurRenderScript(Bitmap smallBitmap, int radius) { 

     try { 
      smallBitmap = RGB565toARGB888(smallBitmap); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 


     Bitmap bitmap = Bitmap.createBitmap(
       smallBitmap.getWidth(), smallBitmap.getHeight(), 
       Bitmap.Config.ARGB_8888); 

     RenderScript renderScript = RenderScript.create(context); 

     Allocation blurInput = Allocation.createFromBitmap(renderScript, smallBitmap); 
     Allocation blurOutput = Allocation.createFromBitmap(renderScript, bitmap); 

     ScriptIntrinsicBlur blur = ScriptIntrinsicBlur.create(renderScript, 
       Element.U8_4(renderScript)); 
     blur.setInput(blurInput); 
     blur.setRadius(radius); // radius must be 0 < r <= 25 
     blur.forEach(blurOutput); 

     blurOutput.copyTo(bitmap); 
     renderScript.destroy(); 

     return bitmap; 

    } 

    private Bitmap RGB565toARGB888(Bitmap img) throws Exception { 
     int numPixels = img.getWidth() * img.getHeight(); 
     int[] pixels = new int[numPixels]; 

     //Get JPEG pixels. Each int is the color values for one pixel. 
     img.getPixels(pixels, 0, img.getWidth(), 0, 0, img.getWidth(), img.getHeight()); 

     //Create a Bitmap of the appropriate format. 
     Bitmap result = Bitmap.createBitmap(img.getWidth(), img.getHeight(), Bitmap.Config.ARGB_8888); 

     //Set RGB pixels. 
     result.setPixels(pixels, 0, result.getWidth(), 0, 0, result.getWidth(), result.getHeight()); 
     return result; 
    } 

Answer 5

Sono un po 'in ritardo alla festa, ma se io unstderstand correttamente si vuole "dissolvenza nella sfocatura", così aumenta cnstantly ?

È possibile ottenere questo effetto impilando due ImageViews l'uno sull'altro. Quello inferiore mostra l'immagine non trattata, quella superiore è un blured che è pre-renderizzato. Quello superiore deve essere invisibile (alfa = 0f). Successivamente si dissolvenza in alto ImageView e si dissolve in basso il ImageView inferiore. Questo ti darà l'effetto desiderato. Puoi personalizzare l'effetto giocando con i tempi e le transperanzioni.

Buona fortuna :)