Android中对图片处理应用比较常见，所以整理了一些对图片的基本操作处理功能方法：
1. /**
2. * 图片反转
3. * @param img
4. * @return
5. */
6. public
7. new
8. 90); /*翻转90度*/
9. int
10. int
11. 0, 0, width, height, matrix, true);
12. return
13. }
14. /**
15. * 图片缩放
16. * @param bigimage
17. * @param newWidth
18. * @param newHeight
19. * @return
20. */
21. public Bitmap tochange(Bitmap bigimage,int newWidth,int
22. // 获取这个图片的宽和高
23. int
24. int
25. // 创建操作图片用的matrix对象
26. new
27. // 计算缩放率，新尺寸除原始尺寸
28. float scaleWidth = ((float) newWidth)/width;
29. float scaleHeight = ((float) newHeight)/height;
30. // 缩放图片动作
31. matrix.postScale(scaleWidth, scaleHeight);
32. 0, 0, width, height,matrix, true);
33. return
34. }
1. /**
2. * 程序切割图片
3. * @param bitmap
4. * @param x
5. * @param y
6. * @param w
7. * @param h
8. * @return
9. */
10. public Bitmap BitmapClipBitmap(Bitmap bitmap,int x, int y, int w, int
11. return
12. }
1. /**
2. * 图片叠加
3. * @param b
4. * @return
5. */
6. public
7.
8. if(!b.isMutable()){
9. //设置图片为背景为透明
10. true);//
11. }
12. new
13. Bitmap lock=BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);
14. //叠加新图b2
15. //注意此时绘制坐标是相对于图片b
16. 0, 0, null);
17. canvas.save(Canvas.ALL_SAVE_FLAG);
18. canvas.restore();
19. lock.recycle();
20. null;
21. return
22. }
图片居中叠加：
1. Bitmap centerToFit(Bitmap bitmap, int width, int
2. final int
3. final int
4.
5. if
6. int
7.
8. Bitmap centered = Bitmap.createBitmap(bitmapWidth < width ? width : bitmapWidth,
9. bitmapHeight < height ? height : bitmapHeight, Bitmap.Config.RGB_565);
10. centered.setDensity(bitmap.getDensity());
11. new
12. canvas.drawColor(color);
13. 2.0f, (height - bitmapHeight) / 2.0f,
14. null);
15.
16. bitmap = centered;
17. }
18.
19. return
20. }
对图像进行相关参数转换，重新形成新的图片数据参数展示形式（Drawble）
1. /**
2. * Create a drawable from file path name.
3. */
4. public
5. if (pathName == null) {
6. return null;
7. }
8.
9. new
10. true;
11.
12. true;
13. BitmapFactory.decodeFile(pathName, opts);
14.
15. 1, 1280 * 720);
16. false;
17.
18. Bitmap bm = BitmapFactory.decodeFile(pathName, opts);
19.
20. if (bm != null) {
21. return drawableFromBitmap(null, bm, null, null, pathName);
22. }
23.
24. return null;
25. }
26.
27. private Drawable drawableFromBitmap(Resources res, Bitmap bm, byte[] np,
28. Rect pad, String srcName) {
29.
30. if (np != null) {
31. return new
32. }
33.
34. return new
35. }
36.
37. public int
38. int minSideLength, int
39. int
40. maxNumOfPixels);
41.
42. int
43. if (initialSize <= 8) {
44. 1;
45. while
46. 1;
47. }
48. else
49. 7) / 8 * 8;
50. }
51.
52. return
53. }
54.
55. private int
56. int minSideLength, int
57. double
58. double
59.
60. int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math
61. .sqrt(w * h / maxNumOfPixels));
62. int upperBound = (minSideLength == -1) ? 128 : (int) Math.min(
63. Math.floor(w / minSideLength), Math.floor(h / minSideLength));
64.
65. if
66. // return the larger one when there is no overlapping zone.
67. return
68. }
69.
70. if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
71. return 1;
72. else if (minSideLength == -1) {
73. return
74. else
75. return
76. }
77. }
1. /**
2. * create the bitmap from a byte array
3. *生成水印图片
4. * @param src the bitmap object you want proecss
5. * @param watermark the water mark above the src
6. * @return return a bitmap object ,if paramter's length is 0,return null
7. */
8. private
9. {
10. "createBitmap";
11. "create a new bitmap"
12. if( src == null
13. {
14. return null;
15. }
16.
17. int
18. int
19. int
20. int
21. //create the new blank bitmap
22. //创建一个新的和SRC长度宽度一样的位图
23. new
24. //draw src into
25. 0, 0, null );//在 0，0坐标开始画入src
26. //draw watermark into
27. 5, h - wh + 5, null );//在src的右下角画入水印
28. //save all clip
29. //保存
30. //store
31. //存储
32. return
33. }
更多处理
1. /**圆角处理
2. * 实际上是在原图片上画了一个圆角遮罩。对于paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
3. * 方法我刚看到也是一知半解Mode.SRC_IN参数是个画图模式，该类型是指只显 示两层图案的交集部分，且交集部位只显示上层图像。
4. * 实际就是先画了一个圆角矩形的过滤框，于是形状有了，再将框中的内容填充为图片
5. * @param bitmap
6. * @param roundPx
7. * @return
8. */
9. public static Bitmap getRoundedCornerBitmap(Bitmap bitmap,float
10. {
11.
12. Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
13. bitmap.getHeight(), Config.ARGB_8888);
14. new
15.
16. final int color =0xff424242;
17. final Paint paint =new
18. final Rect rect =new Rect(0,0, bitmap.getWidth(), bitmap.getHeight());
19. final RectF rectF =new
20.
21. true);
22. 0,0,0,0);
23. paint.setColor(color);
24. canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
25.
26. new
27. canvas.drawBitmap(bitmap, rect, rect, paint);
28.
29. return
30. }
31. /**
32. * 灰白处理
33. 就是利用了ColorMatrix 类自带的设置饱和度的方法setSaturation()。
34. 不过其方法内部实现的更深一层是利用颜色矩阵的乘法实现的，对于颜色矩阵的乘法下面还有使用
35. * @param bmpOriginal
36. * @return
37. */
38. public static
39. {
40. int
41. height = bmpOriginal.getHeight();
42. width = bmpOriginal.getWidth();
43.
44. Bitmap bmpGrayscale = Bitmap.createBitmap(width, height,
45. Bitmap.Config.RGB_565);
46. new
47. new
48. new
49. 0);
50. new
51. paint.setColorFilter(f);
52. 0,0, paint);
53. return
54. }
55.
56. /**
57. * 黑白处理
58. 这张图片不同于灰白处理的那张，不同之处是灰白处理虽然没有了颜色，
59. 但是黑白的程度层次依然存在，而此张图片连层次都没有了，只有两个区别十分明显的黑白 颜色。
60. 实现的算法也很简单，对于每个像素的rgb值求平均数，如果高于100算白色，低于100算黑色。
61. 不过感觉100这个标准值太大了，导致图片白色区 域太多，把它降低点可能效果会更好
62. * @param mBitmap
63. * @return
64. */
65. public static
66. {
67. int mBitmapWidth =0;
68. int mBitmapHeight =0;
69.
70. mBitmapWidth = mBitmap.getWidth();
71. mBitmapHeight = mBitmap.getHeight();
72. Bitmap bmpReturn = Bitmap.createBitmap(mBitmapWidth, mBitmapHeight,
73. Bitmap.Config.ARGB_8888);
74. int iPixel =0;
75. for(int i =0; i < mBitmapWidth; i++)
76. {
77. for(int j =0; j < mBitmapHeight; j++)
78. {
79. int
80.
81. int
82. 3;
83. if(avg >=100)
84. {
85. 255;
86. }
87. else
88. {
89. 0;
90. }
91. int modif_color = Color.argb(255, iPixel, iPixel, iPixel);
92.
93. bmpReturn.setPixel(i, j, modif_color);
94. }
95. }
96. return
97. }
98. /**
99. * 镜像处理
100. * 原理就是将原图片反转一下，调整一 下它的颜色作出倒影效果，再将两张图片续加在一起，
101. * 不过如果在反转的同时再利用Matrix加上一些倾斜角度就更好了，不过那样做的话加工后的图片的高度需要同比例计算出来，
102. * 不能简单的相加了，否则就图片大小就容不下现有的像素内容。
103. * @param bitmap
104. * @return
105. */
106. public static
107. {
108. final int reflectionGap =4;
109. int
110. int
111.
112. new
113. 1, -1);
114.
115. 0, height /2,
116. 2, matrix,false);
117.
118. Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
119. 2), Config.ARGB_8888);
120.
121. new
122. 0,0,null);
123. new
124. 0, height, width, height + reflectionGap, deafalutPaint);
125.
126. 0, height + reflectionGap,null);
127.
128. new
129. new LinearGradient(0, bitmap.getHeight(),0,
130. 0x70ffffff,
131. 0x00ffffff, TileMode.CLAMP);
132. paint.setShader(shader);
133. // Set the Transfer mode to be porter duff and destination in
134. new
135. // Draw a rectangle using the paint with our linear gradient
136. 0, height, width, bitmapWithReflection.getHeight()
137. + reflectionGap, paint);
138.
139. return
140. }
141. /**
142. * 加旧处理
143. * @param bitmap
144. * @return
145. */
146. public static
147. {
148. Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
149. bitmap.getHeight(), Config.RGB_565);
150.
151. new
152.
153. new
154. new
155. float[] array = {1,0,0,0,50,
156. 0,1,0,0,50,
157. 0,0,1,0,0,
158. 0,0,0,1,0};
159. cm.set(array);
160. new
161.
162. 0,0, paint);
163. return
164. }
165. /**
166. * 浮雕处理
167. * 观察浮雕就不难发现，其实浮雕的特点就是在颜色有跳变的地方就刻条痕迹。127，127,127为深灰色，
168. * 近似于石头的颜色，此处取该颜色为底色。算法是将上一个点的rgba值减去当前点的rgba值然后加上127得到当前点的颜色。
169. * @param mBitmap
170. * @return
171. */
172. public static
173. {
174.
175.
176. int mBitmapWidth =0;
177. int mBitmapHeight =0;
178.
179. mBitmapWidth = mBitmap.getWidth();
180. mBitmapHeight = mBitmap.getHeight();
181. Bitmap bmpReturn = Bitmap.createBitmap(mBitmapWidth, mBitmapHeight,
182. Bitmap.Config.RGB_565);
183. int preColor =0;
184. int prepreColor =0;
185. 0,0);
186.
187. for(int i =0; i < mBitmapWidth; i++)
188. {
189. for(int j =0; j < mBitmapHeight; j++)
190. {
191. int
192. int r = Color.red(curr_color) - Color.red(prepreColor) +127;
193. int g = Color.green(curr_color) - Color.red(prepreColor) +127;
194. int b = Color.green(curr_color) - Color.blue(prepreColor) +127;
195. int
196. int
197. bmpReturn.setPixel(i, j, modif_color);
198. prepreColor = preColor;
199. preColor = curr_color;
200. }
201. }
202.
203. new
204. new
205. new
206. 0);
207. new
208. paint.setColorFilter(f);
209. 0,0, paint);
210.
211. return
212. }
213. /**
214. * 油画处理
215. * 其实油画因为是用画笔画的，彩笔画的时候没有那么精确会将本该这点的颜色滑到另一个点处。
216. * 算法实现就是取一个一定范围内的随机数，每个点的颜色是该点减去随机数坐标后所得坐标的颜色。
217. * @param bmpSource
218. * @return
219. */
220. public static
221. {
222. Bitmap bmpReturn = Bitmap.createBitmap(bmpSource.getWidth(),
223. bmpSource.getHeight(), Bitmap.Config.RGB_565);
224. int color =0;
225. int Radio =0;
226. int
227. int
228.
229. new
230. int iModel =10;
231. int
232. while(i >1)
233. {
234. int
235. while(j >1)
236. {
237. int iPos = rnd.nextInt(100000) % iModel;
238. color = bmpSource.getPixel(i + iPos, j + iPos);
239. bmpReturn.setPixel(i, j, color);
240. 1;
241. }
242. 1;
243. }
244. return
245. }
246.
247. /**
248. * 模糊处理
249. * 算法实现其实是取每三点的平均值做为当前点颜色，这样看上去就变得模糊了。
250. * 这个算法是三点的平均值，如果能够将范围扩大，并且不是单纯的平均值，
251. * 而是加权 平均肯定效果会更好。不过处理速度实在是太慢了，而Muzei这种软件在处理的时候
252. * ，不仅仅速度特别快，而且还有逐渐变模糊的变化过程，显然人家不是用这 种算法实现的。
253. * 他们的实现方法正在猜测中，实现后也来更新。
254. * @param bmpSource
255. * @param Blur
256. * @return
257. */
258. public static Bitmap blurBitmap(Bitmap bmpSource,int
259. {
260. int mode =5;
261. Bitmap bmpReturn = Bitmap.createBitmap(bmpSource.getWidth(),
262. bmpSource.getHeight(), Bitmap.Config.ARGB_8888);
263. int pixels[] =new int[bmpSource.getWidth() * bmpSource.getHeight()];
264. int pixelsRawSource[] =new int[bmpSource.getWidth()
265. 3];
266. int pixelsRawNew[] =new int[bmpSource.getWidth()
267. 3];
268.
269. 0, bmpSource.getWidth(),0,0,
270. bmpSource.getWidth(), bmpSource.getHeight());
271.
272. for(int k =1; k <= Blur; k++)
273. {
274.
275. for(int i =0; i < pixels.length; i++)
276. {
277. 3+0] = Color.red(pixels[i]);
278. 3+1] = Color.green(pixels[i]);
279. 3+2] = Color.blue(pixels[i]);
280. }
281.
282. int CurrentPixel = bmpSource.getWidth() *3+3;
283.
284. for(int i =0; i < bmpSource.getHeight() -3; i++)
285. {
286. for(int j =0; j < bmpSource.getWidth() *3; j++)
287. {
288. 1;
289. int sumColor =0;
290. sumColor = pixelsRawSource[CurrentPixel
291. 3];
292. 3];
293. 3];
294. sumColor = sumColor
295. + pixelsRawSource[CurrentPixel
296. 3];
297. 4);
298. }
299. }
300.
301. for(int i =0; i < pixels.length; i++)
302. {
303. 3+0],
304. 3+1], pixelsRawNew[i *3+2]);
305. }
306. }
307.
308. 0, bmpSource.getWidth(),0,0,
309. bmpSource.getWidth(), bmpSource.getHeight());
310. return
311. }
312. /**
313. * 图片合并
314. * @param bitmap1
315. * @param bitmap2
316. * @param path
317. * @return
318. * @throws FileNotFoundException
319. */
320. public static Bitmap toJoinbitmap(Bitmap bitmap1,Bitmap bitmap2,String path) throws
321.
322. Bitmap bitmap3 = Bitmap.createBitmap(bitmap1.getWidth(), bitmap1.getHeight(), bitmap1.getConfig());
323. new
324. new Matrix(),null);
325. 120,350,null); //120、350为bitmap2写入点的x、y坐标
326. //将合并后的bitmap3保存为png图片到本地
327. new FileOutputStream(path+"/image3.png");
328. 90, out);
329. return
330. }
331.
332. /**文字保存为png图片
333. * @param path 文件保存路径
334. * @param data 保存数据
335. * @throws FileNotFoundException
336. * */
337. public static void textToImage(String path,ArrayList<String> data) throws
338.
339. int height = data.size()*20; //图片高
340. 270,height, Config.ARGB_8888);
341. new
342. //背景颜色
343.
344. new
345. //画笔颜色
346. 15); //画笔粗细
347. for(int i=0;i<data.size();i++){
348. 20,(i+1)*20,p);
349. }
350. new
351. 90, out);
352. }
353.本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
