एंड्रॉइड इमेज व्यू ब्लर एनीमेशन

Question

मैं ImageView पर एक धुंध एनीमेशन जोड़ना चाहता हूं, लेकिन एक निश्चित अवधि के साथ। तो, उदाहरण के लिए मैं समय के साथ एक छवि को धुंधला करना चाहता हूं।

मेरे पास पहले से ही छवि को धुंधला करने का तरीका है, लेकिन मुझे इसकी आवश्यकता है कि इसे धुंध से दूर करने के लिए, 2 सेकंड कहें।

क्या कोई मेरी मदद कर सकता है?

संपादित करें: यह वह तरीका है जिसे मुझे वर्तमान में छवि को धुंधला करना है।

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

एंड्रॉइड पर ब्लर प्रभाव हमेशा कठिन होते हैं। अनिवार्य रूप से आपको दिखने और प्रदर्शन के बीच फैसला करना होगा। बेहतर धुंध जितना लंबा लगता है, और यदि धुंधला तात्कालिक नहीं है तो आप वास्तव में धुंध को एनिमेट नहीं कर सकते हैं।

आप मूल धुंधला एल्गोरिदम वास्तव में अच्छे परिणाम उत्पन्न करते हैं, लेकिन इसके कारण यह धुंधला एनीमेशन असंभव बनाने में भी धीमा है। बस प्रदर्शित करने के लिए क्या यह प्रभावी रूप से इस छवि को मैं एक साधारण कलंक एनीमेशन बनाया है धुंधला करने के लिए ले जाएगा बिटमैप का आकार छोटा करने से:

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); 
    } 
} 

यह काफी अच्छी तरह से काम करता है (अभी भी कुछ अंतराल है, भले ही), लेकिन परिणाम नहीं कर सकते है प्रदर्शन और अच्छा दिखता है गठबंधन करने के लिए जब यह एक छवि को धुंधला करने के लिए आता

तो आप देखते हैं, यह बहुत मुश्किल है, लेकिन वहाँ कुछ विकल्प पहले कर रहे हैं और: अपने कलंक एल्गोरिथ्म साथ तुलना की जा, यह सिर्फ भयानक लग रहा है सबसे महत्वपूर्ण RenderScript। RenderScript बहुत तेज है और गॉसियन ब्लर फ़िल्टर में बनाया गया है। मैंने कभी इसका इस्तेमाल नहीं किया है, लेकिन जो मैंने सुना है, वह आपकी समस्या का समाधान हो सकता है।

आप किसी छवि के पहले से स्केल किए गए संस्करणों को लोड करने का भी प्रयास कर सकते हैं, यह उपरोक्त gif में समान प्रभाव उत्पन्न करेगा, लेकिन यह भी तेज़ होगा। दोष यह है कि Animation में इसका उपयोग फिर से समस्याग्रस्त है, लेकिन अगर आपको केवल धुंधली छवि की आवश्यकता है और आपको वास्तव में गुणवत्ता की परवाह नहीं है तो आपको इस विकल्प के लिए जाना चाहिए।

आप अधिक जानकारी के बारे में RenderScript और अन्य तेजी से कलंक विकल्प in this answer

Answer 2

ही धुंधला बहुत समय लेता है, यहां तक ​​कि नए उपकरणों पर पा सकते हैं। धुंध को एनिमेट करना और भी बदतर होगा। रेंडरस्क्रिप्ट बहुत मदद नहीं करेगा। आपका सबसे अच्छा शर्त एक धुंधली और गैर धुंधला छवियों के बीच crossfade के लिए है:

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; 
      } 
     }); 
    } 

} 

नोट: crossfade कोड से लिया गया है: Source (क्लिक पर एनिमेट)

एक और तरीका है मुझे लगता है कि कर सकते हैं ऐसा करने के लिए, JQuery का उपयोग करना और वेबव्यू के अंदर धुंध को एनिमेट करना है।

Answer 3

मैं कोड के साथ अपने उत्तर को बहुत अधिक नहीं बढ़ाऊंगा क्योंकि ईमानदारी से मेरे पास यह नहीं है, लेकिन मैं उन महत्वपूर्ण चीजों को इंगित करने का प्रयास करूंगा जिन पर आपको विचार करना चाहिए और कुछ उपयोगी लिंक।

पहले दृष्टिकोण:

• कलंक के रूप में तेजी से संभव
• कैश धुंधला परिणाम
• पार फीका

कलंक के रूप में जितनी जल्दी संभव के रूप में:

आपका एल्गोरिदम वास्तव में अच्छा लग रहा है और मेरा मानना ​​है कि यह एक अच्छा प्रभाव देता है, लेकिन वास्तविकता यह है कि यह एक ही थ्रेड में जावा वीएम में चल रहा है। आप निश्चित रूप से रेंडरस्क्रिप्ट का उपयोग करके बेहतर प्रदर्शन करेंगे। ऐसा इसलिए है क्योंकि रेंडरस्क्रिप्ट बहु-प्रोसेसर और जीपीयू को प्रतिपादन प्रक्रिया को स्वतः स्केल करता है।

इसके लिए आधार कोड के नीचे, 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); 

कैश धुंधला परिणाम:

ऐसा इसलिए है क्योंकि धुंधला समय लगता है। उस पर बहुत मेमोरी प्रभाव भी होंगे और आपको इसे ध्यान से देखना होगा। आप निश्चित रूप से स्क्रॉलिंग सूची में इसे बहुत अच्छी तरह से करने में सक्षम नहीं होंगे जो विचारों और सामानों को रीसाइक्लिंग कर रहा है। इसके लिए एक टिप शायद Picasso लाइब्रेरी (LINK) का उपयोग करना है और आपके थ्रेडिंग को भी संभालना है। कुछ इस तरह:

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(); 

पार फीका: जहां प्रदर्शन और महान दिखता के बीच संतुलन जाएगा

यहाँ

है। वास्तविकता यह है कि वास्तविक एनीमेशन वास्तव में प्रत्येक चरण के लिए प्रत्येक फ्रेम को प्रस्तुत किए बिना असंभव है, लेकिन कुछ कुंजी-फ्रेम के बीच एक क्रॉस-फीड के साथ आप अच्छे परिणाम प्राप्त कर सकते हैं।

कितने कुंजी-फ्रेम आप प्रदर्शन आप चाहते हैं, डिवाइस पर मुक्त स्मृति की मात्रा, आदि

तुम सिर्फ 2 मुख्य फ्रेम के साथ ठीक कर रहे हैं पर निर्भर करेगा इस्तेमाल करेंगे (1 नहीं धुंधला हुआ और 1 पूरी तरह से धुंधला हुआ) आप शायद TransitionDrawable लागू कर सकते हैं। यदि आप एक बेहतर दिखने वाले प्रभाव चाहते हैं, तो आपको क्रॉस-फेड संक्रमणों की एक श्रृंखला बनाना होगा या शायद अपना खुद का कस्टम ड्रायबल बनाना होगा।

केवल 2 कुंजी-फ्रेम के लिए आप Yahoo Weather app पर एक उदाहरण देख सकते हैं, यदि आप कुछ कुंजी-फ्रेम के साथ उदाहरण देखना चाहते हैं, तो आप Muzei live wallpaper जांचना चाहते हैं।

बहुत उपयोगी लिंक्स *

दिए गए लिंक आप Muzei निर्माता (रोमन Nurik, जिनसे आपको Google के इंजीनियरों Android के लिए काम कर में से एक है) वह कैसे हासिल की पर से एक अच्छा चर्चा देखेंगे पर कुंजी-फ्रेम, यह क्यों करने का एकमात्र तरीका है और क्यों, हालांकि अधिक जटिल कोड, यह अंत में एक बहुत ही सुंदर परिणाम बनाता है: (लघु संस्करण) https://plus.google.com/+RomanNurik/posts/2sTQ1X2Cb2Z (पूर्ण संस्करण) https://medium.com/@romannurik/serendipitous-ideas-3a1721a6f716

यह लिंक स्रोत है मुज़ी लाइव वॉलपेपर के लिए कोड जहां आप जांच सकते हैं कि वह कुंजी-फ्रेम की गणना कैसे करता है और वॉलपेपर को एनिमेट करता है: https://github.com/romannurik/muzei

शुभकामनाएं और खुश कोडिंग!

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); 

// इन धुंधला कर रहे हैं तरीकों

@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

मैं पार्टी के लिए एक छोटा सा देर हो रही है, लेकिन अगर मैं आप सही तरीके से unstderstand आप तो यह cnstantly बढ़ जाता है "कलंक में फीका" करना चाहते हैं ?

आप एक दूसरे के शीर्ष पर दो छवि दृश्यों को ढेर करके इस प्रभाव को प्राप्त कर सकते हैं। निचला व्यक्ति छूटे हुए चित्र को दिखाता है, ऊपरी वाला एक धुंधला जो पूर्व-प्रस्तुत होता है। ऊपरी एक अदृश्य होना चाहिए (अल्फा = 0 एफ)। इसके बाद आप ऊपरी ImageView में फीका और निचले ImageView को फीका करें। यह आपको वांछित प्रभाव देगा। आप समय और transperancies के साथ खेलकर प्रभाव को अनुकूलित कर सकते हैं।

शुभकामनाएं :)