Android截屏并对图片做高斯模糊处理

最新推荐文章于 2022-06-07 15:23:37 发布
最新推荐文章于 2022-06-07 15:23:37 发布
阅读量424 收藏
点赞数
分类专栏： 动画特效 文章标签： 移动开发 java photoshop
这几天项目中需要模仿一下iOS版本的微博菜单弹出界面，如下图：

[img]http://dl2.iteye.com/upload/attachment/0106/9193/c74ca419-1c7c-3579-8a80-f831104e9f96.jpg[/img]

用微博的同学都知道这个效果吧，这篇文章先实现模糊效果，进入、退出动画后面文章分析；

一、说一下实现思路，很简单的：
1、截图：就是获取我们app得截图
获取我们Activity得根view即DecorView，关于DecorView，sdk里面是这么说明的： 

Retrieve the top-level window decor view (containing the standard window frame/decorations and the client's content inside of that), which can be added as a window to the window manager.

就是说获取最顶层的window，可以添加到window manager里面；
拿到view之后可以调用view的getDrawingCache方法获取bitmap截图；

2、对图片做高斯模糊；
高斯模糊在Photoshop里面用的比较多，可以用来去痘痘。
大致原理是：对指定像素和其周围像素进行加权平均来得到最终结果，使用高斯分布作为滤波器。
这儿可以了解详细的算法原理：http://www.ruanyifeng.com/blog/2012/11/gaussian_blur.html


二、代码实现：
代码比较简单，我自己加了注释贴出来了： 

	private void applyBlur() {
		View view = getWindow().getDecorView();
		view.setDrawingCacheEnabled(true);
		view.buildDrawingCache(true);
		/**
		 * 获取当前窗口快照，相当于截屏
		 */
		Bitmap bmp1 = view.getDrawingCache();
		int height = getOtherHeight();
		/**
		 * 除去状态栏和标题栏
		 */
		Bitmap bmp2 = Bitmap.createBitmap(bmp1, 0, height,bmp1.getWidth(), bmp1.getHeight() - height);
		blur(bmp2, text);
	}

	@SuppressLint("NewApi")
	private void blur(Bitmap bkg, View view) {
		long startMs = System.currentTimeMillis();
		float scaleFactor = 8;//图片缩放比例；
		float radius = 20;//模糊程度

		Bitmap overlay = Bitmap.createBitmap(
				(int) (view.getMeasuredWidth() / scaleFactor),
				(int) (view.getMeasuredHeight() / scaleFactor),
				Bitmap.Config.ARGB_8888);
		Canvas canvas = new Canvas(overlay);
		canvas.translate(-view.getLeft() / scaleFactor, -view.getTop()/ scaleFactor);
		canvas.scale(1 / scaleFactor, 1 / scaleFactor);
		Paint paint = new Paint();
		paint.setFlags(Paint.FILTER_BITMAP_FLAG);
		canvas.drawBitmap(bkg, 0, 0, paint);


		overlay = FastBlur.doBlur(overlay, (int) radius, true);
		view.setBackground(new BitmapDrawable(getResources(), overlay));
		/**
		 * 打印高斯模糊处理时间，如果时间大约16ms，用户就能感到到卡顿，时间越长卡顿越明显，如果对模糊完图片要求不高，可是将scaleFactor设置大一些。
		 */
		Log.i("jerome", "blur time:" + (System.currentTimeMillis() - startMs));
	}

	/**
	 * 获取系统状态栏和软件标题栏，部分软件没有标题栏，看自己软件的配置；
	 * @return
	 */
	private int getOtherHeight() {
		Rect frame = new Rect();
		getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
		int statusBarHeight = frame.top;
		int contentTop = getWindow().findViewById(Window.ID_ANDROID_CONTENT).getTop();
		int titleBarHeight = contentTop - statusBarHeight;
		return statusBarHeight + titleBarHeight;
	}


我这里用了外国开源项目中的一个Java算法，地址：https://github.com/paveldudka/blurring 

package com.jerome.popdemo;

import android.graphics.Bitmap;

/**
 * Created by paveld on 3/6/14.
 */
public class FastBlur {

	public static Bitmap doBlur(Bitmap sentBitmap, int radius,
			boolean canReuseInBitmap) {
		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);
	}
}



如果用C/C++实现jni调用，效果会高一些，可以参考：https://github.com/qiujuer/ImageBlurring/blob/master/README-ZH.md 

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


最后来一张屌丝做demo专业效果图：

[img]http://dl2.iteye.com/upload/attachment/0106/7950/3e1cebb4-fcb4-3c6e-bd64-7a56b63187ac.png[/img]


[img]http://dl2.iteye.com/upload/attachment/0106/7954/5a629564-9e38-34b8-ba27-4beed1b03931.png[/img]
iteye_3916
关注
专栏目录
Android 高斯模糊效果
Jimmy的专栏
01-26 959
【代码】Android 高斯模糊效果。
android 截屏以及对该图进行模糊
12-09
android 截屏以及对该图进行模糊 一个很小的demo，包含FastBlur算法. (编码格式utf-8).
android pop 截图,Android截屏对图片做高斯模糊处理
weixin_39524147的博客
05-28 309
这几天项目中需要模仿一下iOS版本的微博菜单弹出界面，如下图：用微博的同学都知道这个效果吧，这篇文章先实现模糊效果，进入、退出动画后面文章分析；一、说一下实现思路，很简单的：1、截图：就是获取我们app得截图获取我们Activity得根view即DecorView，关于DecorView，sdk里面是这么说明的：Java代码Retrievethetop-levelwindowdecorv...
Android截屏并做模糊处理
TXM12138的博客
08-23 840
点击事件中调用 View view; view = MainActivity.this.getWindow().getDecorView(); initPopuptWindow(view); //释放资源，防止多次截屏后显示的是同一张图片 view.destroyDrawingCache(); private void initPopuptWindow(View layout) { //...
Android 图片实现高斯模糊
mingtiannihao623的博客
03-11 588
http://blog.csdn.net/zhangli_ http://blog.csdn.net/zhangli_/article/details/52105490package com.example.administrator.myapplication;import android.graphics.Bitmap; import android.graphics.BitmapFactory
Android实现动态高斯模糊效果
09-01
在Android开发中常常会用到高斯模糊，但有的时候我们可能会需要一个图片以不同的模糊程度展现出来，那如何实现呢，一起通过本文来学习学习吧。
Android-高斯模糊实时模糊
08-12
在Android开发中，实现高斯模糊（Gaussian Blur）是一种常见的图像处理技术，它能够为UI元素添加一种柔和且专业的视觉效果。实时模糊则是在用户交互过程中动态地应用这种效果，提升用户体验。本文将深入探讨如何在...
BlurView:android高斯模糊实现启动界面效果
06-07
高斯模糊是一种图像处理技术，通过对图像中的每个像素应用高斯函数进行加权平均，使得图像变得模糊，但同时保留了边缘的清晰度。在Android中，我们可以使用 Renderscript 或者自定义视图（View）的方式实现这一效果...
blur android 高斯模糊 背景模糊
06-25
首先，高斯模糊是一种常见的图像处理技术，它通过对图像应用特定的权重函数（高斯函数）来模糊图像，使得边缘逐渐过渡，产生平滑的模糊效果。在Android中，我们通常使用Bitmap对象进行图像处理，包括高斯模糊。 `...
Android高仿IOS动态高斯模糊背景
01-03
Android高仿IOS动态高斯模糊背景，如图演示，效率很高，无卡顿，测试机红米2
截屏 高斯模糊效果
zuojinmin的博客
12-10 443
1.先截取当前屏幕view 2.添加模糊效果   CIContext *context = [CIContext contextWithOptions:nil];     CIImage *inputImage = [[CIImage alloc] initWithImage:image];     // create gaussian blur filter
截屏并高斯模糊
Lu_Ca的博客
08-05 1314
//截屏获得当前的image - (UIImage *)imageOfView:(UIView *)view {     UIGraphicsBeginImageContext(view.bounds.size); //currentView 当前的view          [view.layer renderInContext:UIGraphicsGetCurrent
Android利用RenderScript对图片处理实现高斯模糊效果。
三颗猴面包树
11-04 690
Android中关于图片高斯模糊 网上有众多方法，一种比较简单的方法就是使用RenderScript进行图片处理： Google在API 11中引入了 RenderScript，ScriptIntrinsicBlur的相关方法只支持API 17及以上版本的系统。因此需要minSdkVersion18以上版本。public class OneActivity extends Activity {
Android图片高斯模糊的一些方法
chenrunhua的专栏
03-08 1100
原文：http://blog.csdn.net/xu_fu/article/details/23131241 高斯模糊 高斯模糊就是将指定像素变换为其与周边像素加权平均后的值，权重就是高斯分布函数计算出来的值。 一种实现 点击打开链接 [java] view plain copy  print? public static vo
Android开发 获取截屏后图片 + 高斯模糊
Tom天天的博客
05-12 910
产品需求： 每个界面调起需要设置前一个界面的高斯模糊为背景，经解析大概是需要3部： 1.在Activity的onCreate中截取图片 2.对截取到图片进行高斯模糊 3.设置高斯模糊后的图片为Activity的background 总结了网上的一些方法使用了MediaProjectionManager+EasyBlur，经测试截屏+模糊需要300~600ms，时间有点长慎重使用。 下面介绍一种截屏方法：使用MediaProjectionManager 1.添加权限： <uses-pe
Android 动态毛玻璃背景的简单实现(高斯模糊)
热门推荐
大大大大大乔的博客
07-20 1万+
Android 动态毛玻璃背景的简单实现(高斯模糊) 做APP的时候，UI总是会搞一些这种高斯模糊的效果，为了方便使用，简单讲一下怎么实现，以及提供封装好的View。 我这里是采用RenderScript来实现的高斯模糊，RenderScript 是用于在 Android 上以高性能运行计算密集型任务的框架，性能比较能满足需求。 大概效果如下，可以看一下是否满足你的需求 实现步骤 实现步骤大概可以分为三步 截取需要模糊的区域的背景 对截取到的bitmap进行高斯模糊处理 为ImageView设置Bi
Android 实现图片的高斯模糊（两种方式）
qq_43227422的博客
06-07 6995
做项目时遇到要做图片模糊的需求，和微信语音通话的背景效果一样。网上有很多不错的博客，记录一下使用的两种方式。
使用RenderScript在Android上实现高效高斯模糊
3. Bitmap压缩与高斯模糊处理：接下来，对Bitmap进行压缩（如果必要），然后使用RenderScript执行高斯模糊操作。关键代码包括创建一个新的Bitmap（`outBitmap`）用于存储模糊后的结果，以及初始化一个RenderScript...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值