[Android]-圖片JNI（C++\Java）高斯模糊的實現與比較
前幾天一直在弄android上的圖片模糊效果的實現！
一直找不到方法，看別人說都是呼叫JNI，但是JNI這個東西我還真不熟悉啊！
只好從零開始了！這裡不講JNI的平臺搭建，只講JNI的關鍵程式碼，具體的專案我會共享出來給大家！
對於JNI下使用C++來模糊圖片這個我真的沒找到，只好自己寫C++的來實現了。
在國外的一個專案中找到了一個”堆疊模糊效果“，原型如下：
// Stack Blur v1.0 // // Author: Mario Klingemann <[email protected]> // http://incubator.quasimondo.com // created Feburary 29, 2004 // 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]> PImage a; PImage b; void setup() { a=loadImage("dog.jpg"); size(a.width, a.height); b=new PImage(a.width, a.height); fill(255); noStroke(); frameRate(25); } void draw() { System.arraycopy(a.pixels,0,b.pixels,0,a.pixels.length); fastblur(b,mouseY/4); image(b, 0, 0); } void fastblur(PImage img,int radius){ if (radius<1){ return; } int[] pix=img.pixels; int w=img.width; int h=img.height; 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[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+min(wm,max(i,0))]; sir=stack[i+radius]; sir[0]=(p & 0xff0000)>>16; sir[1]=(p & 0x00ff00)>>8; sir[2]=(p & 0x0000ff); rbs=r1-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]=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=max(0,yp)+x; sir=stack[i+radius]; sir[0]=r[yi]; sir[1]=g[yi]; sir[2]=b[yi]; rbs=r1-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++){ pix[yi]=0xff000000 | (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]=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; } } img.updatePixels(); }
同時找到一個借鑑這個所改進後成為Java的程式碼，具體如下：
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 < 借鑑於此我弄了一個C的程式碼，基本上的整體過程都沒有變化，只是改變成了C（C++也可已）的而已：
檔名：ImageBlur.c
/*************************************************
Copyright: Copyright QIUJUER 2013.
Author: Qiujuer
Date: 2014-04-18
Description:實現圖片模糊處理
**************************************************/
#include<malloc.h>
#define ABS(a) ((a)<(0)?(-a):(a))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
/*************************************************
Function: StackBlur(堆疊模糊)
Description: 使用堆疊方式進行圖片畫素模糊處理
Calls: malloc
Table Accessed: NULL
Table Updated: NULL
Input: 畫素點集合，圖片寬，圖片高，模糊半徑
Output: 返回模糊後的畫素點集合
Return: 返回模糊後的畫素點集合
Others: NULL
*************************************************/
static int* StackBlur(int* pix, int w, int h, int radius) {
int wm = w - 1;
int hm = h - 1;
int wh = w * h;
int div = radius + radius + 1;
int *r = (int *)malloc(wh * sizeof(int));
int *g = (int *)malloc(wh * sizeof(int));
int *b = (int *)malloc(wh * sizeof(int));
int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
int *vmin = (int *)malloc(MAX(w,h) * sizeof(int));
int divsum = (div + 1) >> 1;
divsum *= divsum;
int *dv = (int *)malloc(256 * divsum * sizeof(int));
for (i = 0; i < 256 * divsum; i++) {
dv[i] = (i / divsum);
}
yw = yi = 0;
int(*stack)[3] = (int(*)[3])malloc(div * 3 * sizeof(int));
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 + (MIN(wm, MAX(i, 0)))];
sir = stack[i + radius];
sir[0] = (p & 0xff0000) >> 16;
sir[1] = (p & 0x00ff00) >> 8;
sir[2] = (p & 0x0000ff);
rbs = r1 - 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] = 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 = MAX(0, yp) + x;
sir = stack[i + radius];
sir[0] = r[yi];
sir[1] = g[yi];
sir[2] = b[yi];
rbs = r1 - 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] = 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;
}
}
free(r);
free(g);
free(b);
free(vmin);
free(dv);
free(stack);
return(pix);
}然後找了一下，發現果然是。只好進行free了。然後一下就好了，發現記憶體佔用的確比Java的要少，速度也是要快一些！
在JNI中的實現我使用了兩種方案，一種是直接傳遞檔案，一直是傳遞畫素點集合進行模糊！分別如下：
/*
* Class: com_accumulation_imageblurring_app_jni_ImageBlur
* Method: blurIntArray
* Signature: ([IIII)V
*/
JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurIntArray
(JNIEnv *, jclass, jintArray, jint, jint, jint);
/*
* Class: com_accumulation_imageblurring_app_jni_ImageBlur
* Method: blurBitMap
* Signature: (Landroid/graphics/Bitmap;I)V
*/
JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurBitMap
(JNIEnv *, jclass, jobject, jint);
對應的Java呼叫：
public class ImageBlur {
public static native void blurIntArray(int[] pImg, int w, int h, int r);
public static native void blurBitMap(Bitmap bitmap, int r);
static {
System.loadLibrary("JNI_ImageBlur");
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
此時我做了3種測試，一種是直接在Java層實現，一種是傳遞畫素點集合模糊，還有就是直接傳遞圖片進行模糊，結果如下：
通過上面的比較我們可以得出這樣的結論：
1.Java的確最慢，但是其實也慢不了多少，虛擬機器優化好了一樣猛。
2.C中直接傳遞畫素集合的速度最快（第一次啟動）
3.在我多次切換介面後發現，直接傳遞畫素點集合的耗時會增加，從60多到120多。
4.多次切換後發現，其實直接傳遞畫素點的速度與傳遞圖片過去的速度幾乎一樣。
5.多次操作後發現傳遞檔案的波動較小，在100~138之間，其次是傳遞畫素點集合的波動較大，java的波動最大！
以上就是我的結論，可能有些不正確，但是在我的機器上的確是這樣！
注：勾選選擇框“Downscale before blur”會先壓縮圖片後模糊然後放大圖片，這樣的情況下，模糊效果會稍微損失一些效果，但是其速度確實無法比擬的。
其耗時在：1~10ms內可運算完成。當然與你要模糊的大小有關係！
原創作品，轉載請註明出處！
QIUJUER([email protected])
相關推薦
[Android]-圖片JNI（C++\Java）高斯模糊的實現與比較
前幾天一直在弄android上的圖片模糊效果的實現！ 一直找不到方法，看別人說都是呼叫JNI，但是JNI這個東西我還真不熟悉啊！ 只好從零開始了！這裡不講JNI的平臺搭建，只講JNI的關鍵程式碼，具體的專案我會共享出來給大家！ 對於JNI下使用C++來模糊圖片這個我真的沒
Android service 命令記錄（Binder（c++/java））
經常使用命令：service list 但是你有沒有執行過service --h,察看過其他的Option Usage: service [-h|-?] service list &nbs
Java 7.21 遊戲：豆機（C++&Java）
PS： 難點在於，隨機之後的分隔,理解就很容易了 注意：槽的奇偶情況 C++: #include<iostream> #include<ctime> #include<string> using name
Nobleman__ ACM 比賽模板 （C++ && Java）個人總結 （不斷更新） （自用）
宣告 ： 本人剛學演算法一年，都是自己做題常用的模板，不時總結下。 大致分為：亂七八糟， 數論，圖論，動態規劃，幾何，Java 還有一些奇葩定理， 奇葩定理： 【1】高效求出n的約數的個
（C語言）高精度乘法
題目描述 這道題很簡單，只需要計算a*b即可，唯一有點麻煩的就是a和b的長度可能有點長，什麼int啊，long long啊，double啊都可能從不下，怎麼辦？啟明星軟體組組長給了我一堆資料讓我幫他計算結果，你們誰來幫幫我。。。 輸入 輸入有多組資料。對於每組測
斐波拉契數列的遞迴和非遞迴寫法（c/java）
C語言版本：#include <stdio.h> long fib(long n) { if(n<=2) return(1); if(n>=3) return(fi
SIFT（2）-----高斯模糊
SIFT演算法是在不同的尺度空間上查詢關鍵點，而尺度空間的獲取需要使用高斯模糊來實現 。 一維正態分佈公式： （x-μ）在高斯影象模糊中對應模糊半徑，指的是模板元素到模板中心的距離。 eg： 二維模板大小為m*n，則
快速高斯模糊（IIR遞迴高斯模糊）
本人是影象處理的初學者，在http://www.cnblogs.com/Imageshop/p/3145216.html博文中看到有關影象柔光的特效處理原理後自己也動手實現了一下，這裡包括一個快速高斯模糊的演算法，具體原理可以參考論文《Recursive Imp
EasyPR--開發詳解（3）高斯模糊、灰度化和Sobel運算元
在上篇文章中我們瞭解了PlateLocate的過程中的所有步驟。在本篇文章中我們對前3個步驟，分別是高斯模糊、灰度化和Sobel運算元進行分析。 一、高斯模糊 1.目標 對影象去噪，為邊緣檢測演算法做準備。 2.效果 在我們的車牌定位中的第一步就是高斯模糊處理。 圖1 高斯
Android深度探索（卷2）系統應用原始碼分析與ROM定製 讀書筆記1
1.在config檔案中如果加上CONFIG_IKCONFIG_PROC=y，編譯下載開機後就會在/proc下面生成config.gz的檔案，這個檔案可以直接解壓使用。 2.Android原始碼下面就有編譯器，alps/prebuild目錄下即是，可以在目錄下搜尋arm-e
DrawerLayout側滑高斯模糊實現
國際慣例，先上效果圖： 背景圖是一張1080p的，手機一加3，大概會佔用7兆多記憶體。滑動過程記憶體一點都不會抖。 最近自己在寫一個音樂app，想實現這樣一個效果，在網上只找到了一篇2014年的文章，但是他是每次滑動都去截圖，生成模糊bitmap，記憶體會劇烈抖動。我參考網
[原始碼和文件分享]基於C++的八大排序演算法的實現與比較
1 概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。我們這裡說說八大排序就是內部排序。 當 n 較大，則應採用時間複雜度為 O(nlog2n) 的排序方法：快速排序、堆排序或歸併排
高斯模糊實現毛玻璃效果
首先需要匯入依賴： compile 'com.github.bumptech.glide:glide:3.7.0' compile 'jp.wasabeef:glide-transformations
Android筆記之（圖片高斯+Glide實現微信圖片載入策略+仿微信進度條）
很久以前就想自己實現一下仿微信圖片載入的那種策略了，先載入一張模糊的圖片，然後再載入清晰大圖，今天研究了一下，不過要是Glide支援進度條顯示就好了，不得不說Glide很強大， 不囉嗦了，直接上程式碼了。 首先看看高斯模糊到底怎麼實現，你問我我也不會(^__
Android——圖片設定為高斯模糊效果（ImageView）
效果圖：//模糊 Resources res = ShowActivity.this.getResources(); //拿到初始圖 Bitmap bmp= BitmapFactory.decodeRe
Android本地圖片或者網路圖片高斯模糊效果（毛玻璃效果）圖片模糊效果一行程式碼搞定
一，實現本地圖片或者網路圖片的毛玻璃效果特別方便，只需要把下面的FastBlurUtil類複製到你的專案中就行 package com.testdemo.blur_image_lib10; import android.graphics.Bitmap; import andr
Ndk學習之JNI建構函式（java-->C-->Java）
1.在Java中定義建構函式（無參的不寫沒事，不被覆蓋就行）並獲取 public native Object accessConstaructor(); 2.javah生成標頭檔案 JNIEXP
android與C# WebService基於ksoap通信（C#篇）
ldo art fadein length col scripts append hid ldoc 1.打開VS 2013新建項目>>ASP.NET空WEB應用程序(我用的是.net 4.0) 2.在剛建立的項目上加入新建項（Web
Android學習筆記（四四） 第三方Java庫的使用
分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
Android學習之---（重回Java（03））資料型別、資料型別強轉、轉義字元、邏輯運算子、位運算子、三目運算子，簡單通俗教學
基本資料型別-數值型-整數型別 整數分為4個型別，byte、short、int、long，為什麼一個整數要劃分為這麼多型別呢，可能很多人知道，但也有人不知道，這裡還是講一下，其實就是因為它們在記憶體當