Android實現圖片高斯模糊，以及圖片映象翻轉。

阿新 • • 發佈：2019-01-16

好久沒寫部落格，發現不止手癢，，原來不學習還是會頹廢的…..

哎…..

速速找了網上比較感興趣的功能，，看著前人大神門的方法實現,方便自己也方便別人：

上圖：
這裡寫圖片描述
程式碼：

MainActivity.class

package com.hero.zhaoq.bitmapdemo;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import 
 android.graphics.Paint;
import android.renderscript.Allocation;
import android.renderscript.Element;
import android.renderscript.RenderScript;
import android.renderscript.ScriptIntrinsicBlur;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.MotionEvent;
import 
 android.view.View;
import android.widget.ImageView;

/**
 * Android實現映象效果
 */
public class MainActivity extends AppCompatActivity {

    private ImageView imageView1;
    private ImageView imageView2;
    private ImageView imageView3;
    private ImageView imageView4;

    @Override
    protected void 
 onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    //
    private void initView() {
        imageView1 = (ImageView) findViewById(R.id.imageView1);
        imageView2 = (ImageView) findViewById(R.id.imageView2);
        imageView3 = (ImageView) findViewById(R.id.imageView3);
        imageView4 = (ImageView) findViewById(R.id.imageView4);

        //獲取資源圖片
        Bitmap bm =  BitmapFactory.decodeResource(getResources(),R.mipmap.demo);

        //顯示原圖形
        imageView1.setImageBitmap(bm);

        //處理
        Bitmap modBm = Bitmap.createBitmap(bm.getWidth(),bm.getHeight(),bm.getConfig());

        //處理畫布  重新繪製圖形  形成映象
        Canvas canvas = new Canvas(modBm);

        Paint paint = new Paint();
//        paint.setColor(Color.BLACK);
//        paint.setAntiAlias(true);

        //繪製矩陣  Matrix主要用於對平面進行平移(Translate)，縮放(Scale)，旋轉(Rotate)以及斜切(Skew)操作。
        Matrix matrix = new Matrix();
//        matrix.setRotate(90,bm.getWidth()/2,bm.getHeight());
//        matrix.setTranslate(20,20);
        //鏡子效果：
        matrix.setScale(-1,1);//翻轉
        matrix.postTranslate(bm.getWidth(),0);

        canvas.drawBitmap(bm,matrix,paint);
        imageView2.setImageBitmap(modBm);


        Bitmap bm2 =  BitmapFactory.decodeResource(getResources(),R.mipmap.demo);
        imageView3.setImageBitmap(blurBitmap(bm2));

        //設定 觸控事件  實現  觸控改變  模糊狀態
        imageView3.setOnTouchListener(new View.OnTouchListener() {

            private float mLastY;

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        mLastY = event.getY();
                        break;
                    case MotionEvent.ACTION_MOVE:
                        float y = event.getY();
                        float alphaDelt = (y - mLastY) / 1000;
                        float alpha = imageView3.getAlpha() + alphaDelt;
                        if (alpha > 1.0) {
                            alpha = 1.0f;
                        } else if (alpha < 0.0) {
                            alpha = 0.0f;
                        }
                        imageView3.setAlpha(alpha);
                        break;
                    case MotionEvent.ACTION_UP:
                        break;
                }
                return true;
            }
        });



        Bitmap bm3 =  BitmapFactory.decodeResource(getResources(),R.mipmap.demo);
        imageView4.setImageBitmap(blurBitmap(bm3));

        //設定 觸控事件  實現  觸控改變  模糊狀態
        imageView4.setOnTouchListener(new View.OnTouchListener() {

            private float mLastY;

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        mLastY = event.getY();
                        break;
                    case MotionEvent.ACTION_MOVE:
                        float y = event.getY();
                        float alphaDelt = (y - mLastY) / 1000;
                        float alpha = imageView4.getAlpha() + alphaDelt;
                        if (alpha > 1.0) {
                            alpha = 1.0f;
                        } else if (alpha < 0.0) {
                            alpha = 0.0f;
                        }
                        imageView4.setAlpha(alpha);
                        break;
                    case MotionEvent.ACTION_UP:
                        break;
                }
                return true;
            }
        });
    }

    //該方法   要求版本最低為  17   API
    public Bitmap blurBitmap(Bitmap bitmap){

        //Let's create an empty bitmap with the same size of the bitmap we want to blur
        Bitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);

        //Instantiate a new Renderscript
        RenderScript rs = RenderScript.create(getApplicationContext());

        //Create an Intrinsic Blur Script using the Renderscript
        ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));

        //Create the Allocations (in/out) with the Renderscript and the in/out bitmaps
        Allocation allIn = Allocation.createFromBitmap(rs, bitmap);
        Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);

        //Set the radius of the blur
        blurScript.setRadius(5.f);

        //Perform the Renderscript
        blurScript.setInput(allIn);
        blurScript.forEach(allOut);

        //Copy the final bitmap created by the out Allocation to the outBitmap
        allOut.copyTo(outBitmap);

        //recycle the original bitmap
        bitmap.recycle();

        //After finishing everything, we destroy the Renderscript.
        rs.destroy();

        return outBitmap;
    }


    //高斯模糊   方法二  效率較低：
    public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {

        // Stack Blur v1.0 from
        // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
        //
        // Java Author: Mario Klingemann <mario at quasimondo.com>
        // http://incubator.quasimondo.com
        // created Feburary 29, 2004
        // Android port : Yahel Bouaziz <yahel at kayenko.com>
        // http://www.kayenko.com
        // ported april 5th, 2012

        // This is a compromise between Gaussian Blur and Box blur
        // It creates much better looking blurs than Box Blur, but is
        // 7x faster than my Gaussian Blur implementation.
        //
        // I called it Stack Blur because this describes best how this
        // filter works internally: it creates a kind of moving stack
        // of colors whilst scanning through the image. Thereby it
        // just has to add one new block of color to the right side
        // of the stack and remove the leftmost color. The remaining
        // colors on the topmost layer of the stack are either added on
        // or reduced by one, depending on if they are on the right or
        // on the left side of the stack.
        //
        // If you are using this algorithm in your code please add
        // the following line:
        //
        // Stack Blur Algorithm by Mario Klingemann <[email protected]>

        Bitmap bitmap;
        if (canReuseInBitmap) {
            bitmap = sentBitmap;
        } else {
            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];
        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;
            }
        }

        bitmap.setPixels(pix, 0, w, 0, 0, w, h);

        return (bitmap);
    }
}

Android實現圖片高斯模糊，以及圖片映象翻轉。

好久沒寫部落格，發現不止手癢，，原來不學習還是會頹廢的….. 哎….. 速速找了網上比較感興趣的功能，，看著前人大神門的方法實現,方便自己也方便別人：上圖：程式碼： MainActivity.class package com.hero.

Android實現快速高斯模糊

高斯模糊想必大家都聽說過，百度百科對於高斯模糊的解釋為：高斯模糊（英語：Gaussian Blur），也叫高斯平滑，是在Adobe Photoshop、GIMP以及Paint.NET等影象處理軟體中廣泛使用的處理效果，通常用它來減少影象噪聲以及降低細節層次。所謂"模糊"，

Android 實現圖片高斯模糊演算法，真正有效的工具類

import android.graphics.Bitmap; import android.graphics.Color; public class FastBlur { /*** * 高斯模糊演算法 * @param bmp 要處理的影象

Android 圖片高斯模糊解決方案

Android 圖片高斯模糊解決方案近年來，圖片高斯模糊備受設計師的青睞，在各大知名APP中，如微信、手機QQ、網易雲音樂等等都有對背景高斯圖模糊的設計，在Adnroid 中，現在常用的圖片高斯模糊技術有三種：RenderScript 、fastBlur、對RenderScript和

Glide中MultiTransformation使用,實現多種變換效果組合（圓形，圓角，高斯模糊，黑白...）

Glide中MultiTransformation使用 MultiTransformation可以實現多個Transformation效果結合實現一些需求 1、例如Glide載入一張圖片，我們需要把這張

Android區域性動態高斯模糊以及側滑選單配合高斯模糊

最近在專案開發中遇到一個需求，需要滿足兩種情況： 1.在應用的某個介面會彈出透明對話方塊，對話方塊的背景高斯模糊，介面其他部分正常； 2.在介面中有一個透明側拉選單，在側拉選單滑動的過程總，選單背景會隨之高斯模糊；當時碰

使用RenderScript來實現高斯模糊，相容低版本

這兩天看到公司工程裡有用到高斯模糊，是通過java實現的，很慢，所以找了一些資料，看到RenderScript，效能很好，而且RenderScript是可以相容低版本的，實現方式也是jni。相容低版本的教程網上有很多，就是在sdk目錄裡把RenderScript v8包新增

Android 圖片高斯模糊處理

/** 水平方向模糊度 */ private static float hRadius = 10; /** 豎直方向模糊度 */ private static float vRadius = 10; /** 模糊迭代度 */ private static int iterations = 7;

Android本地圖片或者網路圖片高斯模糊效果（毛玻璃效果）圖片模糊效果一行程式碼搞定

一，實現本地圖片或者網路圖片的毛玻璃效果特別方便，只需要把下面的FastBlurUtil類複製到你的專案中就行 package com.testdemo.blur_image_lib10; import android.graphics.Bitmap; import andr

少造輪子之--android高斯模糊，使用簡單，帶漸變！！！

簡單粗暴，使用方法：BitmapBlurUtil.getInstance().setImageBlurBitmap(…); 完整程式碼： import android.content.Context; import android.graphics.Bi

android 實現mqtt訊息推送，以及不停斷線重連的問題解決

前段時間專案用到mqtt的訊息推送，整理一下程式碼，程式碼的原型是網上找的，具體哪個地址已經忘記了。程式碼的實現是新建了一個MyMqttService，全部功能都在裡面實現，包括連伺服器，斷線重連，訂閱訊息，處理訊息，釋出訊息等基本操作。首先新增依賴： dependencies { &

CSS3 filter濾鏡屬性小專案——圖片高斯模糊、高亮、對比度、灰度、色調、色彩旋轉、透明、飽和、褐色調整

學到了CSS3的filter屬性，心血來潮做了個filter濾鏡組工具，可以多重給自己的圖片新增濾鏡。拿走不謝，別忘了更改對應的路徑名。程式碼如下 html部分 <!DOCTYPE html> <html> <head>

使用canvas實現區域性高斯模糊效果

這個功能目的是為了模糊一些人的臉部，一些文字資訊。主要用於使用者手動操作進行模糊。實現的功能：本人實現了再pc端上面進行拖拽模糊。實現思路：首先載入圖片，然後再載入完成的回撥中，建立一個高斯模糊過的圖片畫布。接著，繫結滑鼠的互動事件，在裡面獲取到在畫布

iOS開發-圖片高斯模糊效果

iOS開發的時候有的時候需要將圖片設定模糊，或者通過點選下拉方法，去除模糊，一切都是為了應用更受使用者歡迎，iOS7之後半透明模糊效果得到大範圍使用的比較大，現在也可以看到很多應用區域性用到了圖片模糊效果，關於圖片實現高斯模糊效果有三種方式，CoreImage，GPUImag

基於正態分佈的圖片高斯模糊演算法

前言：先來看看下面這張圖，我把一張圖進行了二等份了，左邊是經過高斯模糊過的，右邊是原圖。圖-1 高斯模糊效果對比圖概述：高斯模糊也叫做高斯平滑，是一種影象平滑處理的技術。高斯模糊演算法的原理是選取一箇中心點，以及一個半徑周圍的所有點，再計算這些畫素點

圖片高斯模糊[python]

簡介畢業設計圖片處理部分需要模擬日常生活中的一些圖片模糊情況，於是在百度百科”高斯模糊”後自己簡單實現了下，高斯模糊原理很簡單，就是用高斯分佈對影象畫素值進行卷積。本篇部落格建議看完百度百科後再看。高斯函式(正太分佈) 一維高斯分佈公式 σ 為

圖片高斯模糊效果簡單優化

模糊背景現在已經很流行了，固定圖片的模糊可以讓設計師處理，那麼動態模糊，或者每個使用者個人主頁用自己頭像的圖片模糊做背景，這就需要我們程式設計師通過程式碼來實現了，實現的方案在github上已經有比較完善和得到大家公認的開源專案： Blurry 。前者主要通過

【複習筆記】 cocos2d-x 2.x 渲染特效實現四高斯模糊效果二

在上文末，我們已經完成了高斯模糊橫向上的模糊效果，而且提到，縱向模糊要在橫向模糊的結果上進行，所以為了得到橫向模糊的貼圖，我們使用離屏渲染。顧名思義，現在渲染的目的地不是螢幕了~一般狀況下，gl是直接把渲染好的紋理繪製到螢幕緩衝區的，進而直接顯示在螢幕上。但是現在，我們要把

使用遞迴高斯濾波器實現快速高斯模糊

高斯窗常用於對影象進行模糊或低通濾噪，但是隨著高斯半徑的增加，時間消耗會逐級增加如高斯半徑為N時，計算每個輸出取樣點需要計算的乘法次數為（2N+1）*模糊方向數，加法次數為2N*模糊方向數，這種情況下，當N=100時，甚至更大時，計算量是非常大的，即使進行SIMD指令集優

CSS｜backdrop-filter 和filter 寫出高斯模糊效果以及兩者區別

backdrop-filter：blur(10px);只支援ios端；只作用於當前元素；適用場景：為背景新增模糊效果；如果目標元素內包裹著其他內容則應用filter屬性；（不支援安卓，效果不明顯）filter：blur(10px); 相容性比較好，

Android實現圖片 高斯模糊，以及圖片映象 翻轉。

相關推薦

Android實現圖片高斯模糊，以及圖片映象翻轉。