android 图片缩小动画效果 android图片缩放

Android图片缩放总结及比较

[日期：2011-08-07]

来源：Linux社区  作者：lincyang

[字体：大 中 小]

在

Android中对大图片进行缩放真的很不尽如人意，不知道是不是我的方法不对。下面我列出3种对图片缩放的方法，并给出相应速度。请高人指教。

第一种是BitmapFactory和BitmapFactory.Options。

首先，BitmapFactory.Options有几个Fields很有用：

inJustDecodeBounds：If set to true, the decoder will return null (no bitmap), but the out...

也就是说，当inJustDecodeBounds设成true时，bitmap并不加载到内存，这样效率很高哦。而这时，你可以获得bitmap的高、宽等信息。

outHeight：The resulting height of the bitmap, set independent of the state of inJustDecodeBounds.

outWidth：The resulting width of the bitmap, set independent of the state of inJustDecodeBounds. 

看到了吧，上面3个变量是相关联的哦。

inSampleSize ：

If set to a value > 1, requests the decoder to subsample the original image, returning a smaller image to save memory.

这就是用来做缩放比的。这里有个技巧：

inSampleSize=（outHeight/Height+outWidth/Width）/2

实践证明，这样缩放出来的图片还是很好的。

最后用BitmapFactory.decodeFile(path, options)生成。

由于只是对bitmap加载到内存一次，所以效率比较高。解析速度快。

第二种是使用Bitmap加Matrix来缩放。

首先要获得原bitmap，再从原bitmap的基础上生成新图片。这样效率很低。

第三种是用2.2新加的类ThumbnailUtils来做。
让我们新看看这个类，从API中来看，此类就三个静态方法：createVideoThumbnail、extractThumbnail(Bitmap source, int width, int height, int options)、extractThumbnail(Bitmap source, int width, int height)。
我这里使用了第三个方法。再看看它的源码，下面会附上。是上面我们用到的BitmapFactory.Options和Matrix等经过人家一阵加工而成。
效率好像比第二种方法高一点点。

下面是我的例子：

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:orientation="vertical"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent"
6. >
7.       
8. <ImageView  
9. android:id="@+id/imageShow"
10. android:layout_width="wrap_content"
11. android:layout_height="wrap_content"
12. />
13. <ImageView  
14. android:id="@+id/image2"
15. android:layout_width="wrap_content"
16. android:layout_height="wrap_content"
17. />
18. <TextView    
19. android:id="@+id/text"
20. android:layout_width="fill_parent"
21. android:layout_height="wrap_content"
22. android:text="@string/hello"
23. />
24. </LinearLayout>

 

1. package
2.   
3. import
4. import
5. import
6. import
7.   
8. import
9. import
10. import
11. import
12. import
13. import
14. import
15. import
16. import
17. import
18. import
19.   
20. public class ResolvePicture extends
21. private static String tag="ResolvePicture";  
22.     Drawable bmImg;    
23.     ImageView imView;   
24.     ImageView imView2;   
25.     TextView text;  
26.     String theTime;  
27. long
28. /** Called when the activity is first created. */
29. @Override
30. public void
31. super.onCreate(savedInstanceState);  
32.         setContentView(R.layout.main);  
33.           
34.         text=(TextView)findViewById(R.id.text);  
35.           
36.         imView=(ImageView) findViewById(R.id.imageShow);  
37.         imView2=(ImageView) findViewById(R.id.image2);  
38.           
39.         Bitmap bitmap = BitmapFactory.decodeResource(getResources(),     
40.                 R.drawable.pic);  
41.           
42.         start=System.currentTimeMillis();  
43.           
44. //        imView.setImageDrawable(resizeImage(bitmap, 300, 100));  
45.           
46. "/sdcard/2.jpeg", 200, 100));   
47.           
48.         stop=System.currentTimeMillis();  
49.           
50. "\n1 iterative: (%d msec)",    
51.                 stop - start);    
52.           
53.         start=System.currentTimeMillis();  
54. 200,100));//2.2才加进来的新类，简单易用 
55. //        imView.setImageDrawable(resizeImage(bitmap, 30, 30));  
56.         stop=System.currentTimeMillis();  
57.           
58. "\n2 iterative: (%d msec)",    
59.                 stop - start);   
60.           
61.         text.setText(theTime);  
62.     }  
63.       
64. //使用Bitmap加Matrix来缩放 
65. public static Drawable resizeImage(Bitmap bitmap, int w, int
66.     {    
67.         Bitmap BitmapOrg = bitmap;    
68. int
69. int
70. int
71. int
72.   
73. float scaleWidth = ((float) newWidth) / width;    
74. float scaleHeight = ((float) newHeight) / height;    
75.   
76. new
77.         matrix.postScale(scaleWidth, scaleHeight);    
78. // if you want to rotate the Bitmap    
79. // matrix.postRotate(45);    
80. 0, 0, width,    
81. true);    
82. return new
83.     }  
84.       
85. //使用BitmapFactory.Options的inSampleSize参数来缩放 
86. public static
87. int width,int
88.     {  
89. new
90. true;//不加载bitmap到内存中 
91.         BitmapFactory.decodeFile(path,options);   
92. int
93. int
94. false;  
95.         options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
96. 1;  
97.           
98. if (outWidth != 0 && outHeight != 0 && width != 0 && height != 0)   
99.         {  
100. int sampleSize=(outWidth/width+outHeight/height)/2;  
101. "sampleSize = "
102.             options.inSampleSize = sampleSize;  
103.         }  
104.       
105. false;  
106. return new
107.     }  
108.   
109. //图片保存 
110. private void
111.     {  
112. new File("/sdcard/2.jpeg");  
113. try
114.         {  
115. new
116. if(bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos))  
117.             {  
118.                 fos.flush();  
119.                 fos.close();  
120.             }  
121.         }  
122. catch(FileNotFoundException e1)  
123.         {  
124.             e1.printStackTrace();  
125.         }  
126. catch(IOException e2)  
127.         {  
128.             e2.printStackTrace();  
129.         }  
130.     }  
131. }

ThumbnailUtils源码：

2. /*
3.  * Copyright (C) 2009 The Android Open Source Project
4.  *
5.  * Licensed under the Apache License, Version 2.0 (the "License");
6.  * you may not use this file except in compliance with the License.
7.  * You may obtain a copy of the License at
8.  *
9.  *      http://www.apache.org/licenses/LICENSE-2.0
10.  *
11.  * Unless required by applicable law or agreed to in writing, software
12.  * distributed under the License is distributed on an "AS IS" BASIS,
13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14.  * See the License for the specific language governing permissions and
15.  * limitations under the License.
16.  */
17.   
18. package
19.   
20. import
21. import
22. import
23. import
24. import
25. import
26. import
27. import
28. import
29. import
30. import
31. import
32. import
33. import
34. import
35. import
36. import
37.   
38. import
39. import
40. import
41. import
42.   
43. /**
44.  * Thumbnail generation routines for media provider.
45.  */
46.   
47. public class
48. private static final String TAG = "ThumbnailUtils";  
49.   
50. /* Maximum pixels size for created bitmap. */
51. private static final int MAX_NUM_PIXELS_THUMBNAIL = 512 * 384;  
52. private static final int MAX_NUM_PIXELS_MICRO_THUMBNAIL = 128 * 128;  
53. private static final int UNCONSTRAINED = -1;  
54.   
55. /* Options used internally. */
56. private static final int OPTIONS_NONE = 0x0;  
57. private static final int OPTIONS_SCALE_UP = 0x1;  
58.   
59. /**
60.      * Constant used to indicate we should recycle the input in
61.      * {@link #extractThumbnail(Bitmap, int, int, int)} unless the output is the input.
62.      */
63. public static final int OPTIONS_RECYCLE_INPUT = 0x2;  
64.   
65. /**
66.      * Constant used to indicate the dimension of mini thumbnail.
67.      * @hide Only used by media framework and media provider internally.
68.      */
69. public static final int TARGET_SIZE_MINI_THUMBNAIL = 320;  
70.   
71. /**
72.      * Constant used to indicate the dimension of micro thumbnail.
73.      * @hide Only used by media framework and media provider internally.
74.      */
75. public static final int TARGET_SIZE_MICRO_THUMBNAIL = 96;  
76.   
77. /**
78.      * This method first examines if the thumbnail embedded in EXIF is bigger than our target
79.      * size. If not, then it'll create a thumbnail from original image. Due to efficiency
80.      * consideration, we want to let MediaThumbRequest avoid calling this method twice for
81.      * both kinds, so it only requests for MICRO_KIND and set saveImage to true.
82.      *
83.      * This method always returns a "square thumbnail" for MICRO_KIND thumbnail.
84.      *
85.      * @param filePath the path of image file
86.      * @param kind could be MINI_KIND or MICRO_KIND
87.      * @return Bitmap
88.      *
89.      * @hide This method is only used by media framework and media provider internally.
90.      */
91. public static Bitmap createImageThumbnail(String filePath, int
92. boolean
93. int
94.                 ? TARGET_SIZE_MINI_THUMBNAIL  
95.                 : TARGET_SIZE_MICRO_THUMBNAIL;  
96. int
97.                 ? MAX_NUM_PIXELS_THUMBNAIL  
98.                 : MAX_NUM_PIXELS_MICRO_THUMBNAIL;  
99. new
100. null;  
101.         MediaFileType fileType = MediaFile.getFileType(filePath);  
102. if (fileType != null
103.             createThumbnailFromEXIF(filePath, targetSize, maxPixels, sizedThumbnailBitmap);  
104.             bitmap = sizedThumbnailBitmap.mBitmap;  
105.         }  
106.   
107. if (bitmap == null) {  
108. try
109. new
110. new
111. 1;  
112. true;  
113. null, options);  
114. if (options.mCancel || options.outWidth == -1
115. 1) {  
116. return null;  
117.                 }  
118.                 options.inSampleSize = computeSampleSize(  
119.                         options, targetSize, maxPixels);  
120. false;  
121.   
122. false;  
123.                 options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
124. null, options);  
125. catch
126. "", ex);  
127.             }  
128.         }  
129.   
130. if
131. // now we make it a "square thumbnail" for MICRO_KIND thumbnail 
132.             bitmap = extractThumbnail(bitmap,  
133.                     TARGET_SIZE_MICRO_THUMBNAIL,  
134.                     TARGET_SIZE_MICRO_THUMBNAIL, OPTIONS_RECYCLE_INPUT);  
135.         }  
136. return
137.     }  
138.   
139. /**
140.      * Create a video thumbnail for a video. May return null if the video is
141.      * corrupt or the format is not supported.
142.      *
143.      * @param filePath the path of video file
144.      * @param kind could be MINI_KIND or MICRO_KIND
145.      */
146. public static Bitmap createVideoThumbnail(String filePath, int
147. null;  
148. new
149. try
150.             retriever.setMode(MediaMetadataRetriever.MODE_CAPTURE_FRAME_ONLY);  
151.             retriever.setDataSource(filePath);  
152.             bitmap = retriever.captureFrame();  
153. catch
154. // Assume this is a corrupt video file 
155. catch
156. // Assume this is a corrupt video file. 
157. finally
158. try
159.                 retriever.release();  
160. catch
161. // Ignore failures while cleaning up. 
162.             }  
163.         }  
164. if (kind == Images.Thumbnails.MICRO_KIND && bitmap != null) {  
165.             bitmap = extractThumbnail(bitmap,  
166.                     TARGET_SIZE_MICRO_THUMBNAIL,  
167.                     TARGET_SIZE_MICRO_THUMBNAIL,  
168.                     OPTIONS_RECYCLE_INPUT);  
169.         }  
170. return
171.     }  
172.   
173. /**
174.      * Creates a centered bitmap of the desired size.
175.      *
176.      * @param source original bitmap source
177.      * @param width targeted width
178.      * @param height targeted height
179.      */
180. public static
181. int width, int
182. return
183.     }  
184.   
185. /**
186.      * Creates a centered bitmap of the desired size.
187.      *
188.      * @param source original bitmap source
189.      * @param width targeted width
190.      * @param height targeted height
191.      * @param options options used during thumbnail extraction
192.      */
193. public static
194. int width, int height, int
195. if (source == null) {  
196. return null;  
197.         }  
198.   
199. float
200. if
201. float) source.getWidth();  
202. else
203. float) source.getHeight();  
204.         }  
205. new
206.         matrix.setScale(scale, scale);  
207.         Bitmap thumbnail = transform(matrix, source, width, height,  
208.                 OPTIONS_SCALE_UP | options);  
209. return
210.     }  
211.   
212. /*
213.      * Compute the sample size as a function of minSideLength
214.      * and maxNumOfPixels.
215.      * minSideLength is used to specify that minimal width or height of a
216.      * bitmap.
217.      * maxNumOfPixels is used to specify the maximal size in pixels that is
218.      * tolerable in terms of memory usage.
219.      *
220.      * The function returns a sample size based on the constraints.
221.      * Both size and minSideLength can be passed in as IImage.UNCONSTRAINED,
222.      * which indicates no care of the corresponding constraint.
223.      * The functions prefers returning a sample size that
224.      * generates a smaller bitmap, unless minSideLength = IImage.UNCONSTRAINED.
225.      *
226.      * Also, the function rounds up the sample size to a power of 2 or multiple
227.      * of 8 because BitmapFactory only honors sample size this way.
228.      * For example, BitmapFactory downsamples an image by 2 even though the
229.      * request is 3. So we round up the sample size to avoid OOM.
230.      */
231. private static int
232. int minSideLength, int
233. int
234.                 maxNumOfPixels);  
235.   
236. int
237. if (initialSize <= 8
238. 1;  
239. while
240. 1;  
241.             }  
242. else
243. 7) / 8 * 8;  
244.         }  
245.   
246. return
247.     }  
248.   
249. private static int
250. int minSideLength, int
251. double
252. double
253.   
254. int lowerBound = (maxNumOfPixels == UNCONSTRAINED) ? 1
255. int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));  
256. int upperBound = (minSideLength == UNCONSTRAINED) ? 128
257. int) Math.min(Math.floor(w / minSideLength),  
258.                 Math.floor(h / minSideLength));  
259.   
260. if
261. // return the larger one when there is no overlapping zone. 
262. return
263.         }  
264.   
265. if
266.                 (minSideLength == UNCONSTRAINED)) {  
267. return 1;  
268. else if
269. return
270. else
271. return
272.         }  
273.     }  
274.   
275. /**
276.      * Make a bitmap from a given Uri, minimal side length, and maximum number of pixels.
277.      * The image data will be read from specified pfd if it's not null, otherwise
278.      * a new input stream will be created using specified ContentResolver.
279.      *
280.      * Clients are allowed to pass their own BitmapFactory.Options used for bitmap decoding. A
281.      * new BitmapFactory.Options will be created if options is null.
282.      */
283. private static Bitmap makeBitmap(int minSideLength, int
284.             Uri uri, ContentResolver cr, ParcelFileDescriptor pfd,  
285.             BitmapFactory.Options options) {  
286. null;  
287. try
288. if (pfd == null) pfd = makeInputStream(uri, cr);  
289. if (pfd == null) return null;  
290. if (options == null) options = new
291.   
292.             FileDescriptor fd = pfd.getFileDescriptor();  
293. 1;  
294. true;  
295. null, options);  
296. if (options.mCancel || options.outWidth == -1
297. 1) {  
298. return null;  
299.             }  
300.             options.inSampleSize = computeSampleSize(  
301.                     options, minSideLength, maxNumOfPixels);  
302. false;  
303.   
304. false;  
305.             options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
306. null, options);  
307. catch
308. "Got oom exception ", ex);  
309. return null;  
310. finally
311.             closeSilently(pfd);  
312.         }  
313. return
314.     }  
315.   
316. private static void
317. if (c == null) return;  
318. try
319.           c.close();  
320. catch
321. // do nothing 
322.       }  
323.     }  
324.   
325. private static
326.             Uri uri, ContentResolver cr) {  
327. try
328. return cr.openFileDescriptor(uri, "r");  
329. catch
330. return null;  
331.         }  
332.     }  
333.   
334. /**
335.      * Transform source Bitmap to targeted width and height.
336.      */
337. private static
338.             Bitmap source,  
339. int
340. int
341. int
342. boolean scaleUp = (options & OPTIONS_SCALE_UP) != 0;  
343. boolean recycle = (options & OPTIONS_RECYCLE_INPUT) != 0;  
344.   
345. int
346. int
347. if (!scaleUp && (deltaX < 0 || deltaY < 0)) {  
348. /*
349.             * In this case the bitmap is smaller, at least in one dimension,
350.             * than the target.  Transform it by placing as much of the image
351.             * as possible into the target and leaving the top/bottom or
352.             * left/right (or both) black.
353.             */
354.             Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight,  
355.             Bitmap.Config.ARGB_8888);  
356. new
357.   
358. int deltaXHalf = Math.max(0, deltaX / 2);  
359. int deltaYHalf = Math.max(0, deltaY / 2);  
360. new
361.             deltaXHalf,  
362.             deltaYHalf,  
363.             deltaXHalf + Math.min(targetWidth, source.getWidth()),  
364.             deltaYHalf + Math.min(targetHeight, source.getHeight()));  
365. int dstX = (targetWidth  - src.width())  / 2;  
366. int dstY = (targetHeight - src.height()) / 2;  
367. new
368.                     dstX,  
369.                     dstY,  
370.                     targetWidth - dstX,  
371.                     targetHeight - dstY);  
372. null);  
373. if
374.                 source.recycle();  
375.             }  
376. return
377.         }  
378. float
379. float
380.   
381. float
382. float viewAspect   = (float) targetWidth / targetHeight;  
383.   
384. if
385. float
386. if
387.                 scaler.setScale(scale, scale);  
388. else
389. null;  
390.             }  
391. else
392. float
393. if
394.                 scaler.setScale(scale, scale);  
395. else
396. null;  
397.             }  
398.         }  
399.   
400.         Bitmap b1;  
401. if (scaler != null) {  
402. // this is used for minithumb and crop, so we want to filter here. 
403. 0, 0,  
404. true);  
405. else
406.             b1 = source;  
407.         }  
408.   
409. if
410.             source.recycle();  
411.         }  
412.   
413. int dx1 = Math.max(0, b1.getWidth() - targetWidth);  
414. int dy1 = Math.max(0, b1.getHeight() - targetHeight);  
415.   
416.         Bitmap b2 = Bitmap.createBitmap(  
417.                 b1,  
418. 2,  
419. 2,  
420.                 targetWidth,  
421.                 targetHeight);  
422.   
423. if
424. if
425.                 b1.recycle();  
426.             }  
427.         }  
428.   
429. return
430.     }  
431.   
432. /**
433.      * SizedThumbnailBitmap contains the bitmap, which is downsampled either from
434.      * the thumbnail in exif or the full image.
435.      * mThumbnailData, mThumbnailWidth and mThumbnailHeight are set together only if mThumbnail
436.      * is not null.
437.      *
438.      * The width/height of the sized bitmap may be different from mThumbnailWidth/mThumbnailHeight.
439.      */
440. private static class
441. public byte[] mThumbnailData;  
442. public
443. public int
444. public int
445.     }  
446.   
447. /**
448.      * Creates a bitmap by either downsampling from the thumbnail in EXIF or the full image.
449.      * The functions returns a SizedThumbnailBitmap,
450.      * which contains a downsampled bitmap and the thumbnail data in EXIF if exists.
451.      */
452. private static void createThumbnailFromEXIF(String filePath, int
453. int
454. if (filePath == null) return;  
455.   
456. null;  
457. byte [] thumbData = null;  
458. try
459. new
460. if (exif != null) {  
461.                 thumbData = exif.getThumbnail();  
462.             }  
463. catch
464.             Log.w(TAG, ex);  
465.         }  
466.   
467. new
468. new
469. int exifThumbWidth = 0;  
470. int fullThumbWidth = 0;  
471.   
472. // Compute exifThumbWidth. 
473. if (thumbData != null) {  
474. true;  
475. 0, thumbData.length, exifOptions);  
476.             exifOptions.inSampleSize = computeSampleSize(exifOptions, targetSize, maxPixels);  
477.             exifThumbWidth = exifOptions.outWidth / exifOptions.inSampleSize;  
478.         }  
479.   
480. // Compute fullThumbWidth. 
481. true;  
482.         BitmapFactory.decodeFile(filePath, fullOptions);  
483.         fullOptions.inSampleSize = computeSampleSize(fullOptions, targetSize, maxPixels);  
484.         fullThumbWidth = fullOptions.outWidth / fullOptions.inSampleSize;  
485.   
486. // Choose the larger thumbnail as the returning sizedThumbBitmap. 
487. if (thumbData != null
488. int
489. int
490. false;  
491. 0,  
492.                     thumbData.length, exifOptions);  
493. if (sizedThumbBitmap.mBitmap != null) {  
494.                 sizedThumbBitmap.mThumbnailData = thumbData;  
495.                 sizedThumbBitmap.mThumbnailWidth = width;  
496.                 sizedThumbBitmap.mThumbnailHeight = height;  
497.             }  
498. else
499. false;  
500.             sizedThumbBitmap.mBitmap = BitmapFactory.decodeFile(filePath, fullOptions);  
501.         }  
502.     }  
503. }  

引用自：http://www.linuxidc.com/Linux/2011-08/40109p2.htm

----------------------------------------------

参考2：

如何为你的Android应用缩放图片

您的评价:

收藏该经验

很难为你的应用程序得到正确的图像缩放吗？是你的图片过大，造成内存问题？还是图片不正确缩放造成不良用户体验的结果？为了寻求一个好的解决方案，我们咨询了Andreas Agvard（索尼爱立信软件部门），让他分享一些关于这方面的经验。

注意：本文没有完整显示出代码示例。你可以下载本文的PDF，来看完整的代码示例。

在索尼爱立信软件部门工作，我经常遇到需要图片缩放的应用，例如：当处理别人或者网络上提供的图片。缩放是必要的，因为通常情况下的图片不是你想要呈现的那样。

典型的例子，如果你正在为你的应用开发一个LiveView™扩展。大多数人开发应用利用LiveView™和其他第二屏幕设备，可能需要重新调整图片，重要的是要保持适当的缩放比例和图像质量。当然，在很多情况下，改变图片尺寸是一个有点困难，但是很有效的途径。

ImageView解决了许多的图片缩放问题，首先，至少你在设置完一个图片源后，不用去解码或缩放图片。但有时需要你自己去解码控制，这是本教程的用武之地。随着本教程，我写了一个代码示例，下载图片缩放代码示例。在文本中呈现的效果，可以通过编译和运行该项目来看到。

孤立的问题 
我做这个教程，是因为我已经有一些实用方法来实现图片的缩放，为了避免最常见的图片缩放问题。如下面的例子：

1	Bitmap unscaledBitmap = BitmapFactory.decodeResource(getResources(), mSourceId);

2	Bitmap scaledBitmap = Bitmap.createScaledBitmap(unscaledBitmap, wantedWidth, wantedHeight, true);

那么在上面的代码中，什么是正确的，什么是错的？让我们来看看在不同的代码行。

行1：整个源图像解码到一个位图。

• 这可能会导致内存不足的错误，如果图片太大的话。
• 这可能会导致在一个高分辨率上解码图像。这可能会很慢，但智能解码器可为解码提高性能。
• 缩放图片很多时候是，高分辨率位图缩放到低分辨率，会导致锯齿的问题。使用位图过滤（例如，通过传送`true`参数到Bitmap.createScaledBitmap(...)）减少了锯齿，但是还是不够。

行2：解码的位图缩放到想要的大小。

• 源图像的尺寸和想要的图像尺寸在长宽比上可能是不一样的。这将导致图像的拉伸。

左边的图片：原始图像。右边的图片：缩放后图片。可以看出明显的失真问题，如原图的眼睛非常的鲜明，缩放后就没有了。高度出现拉伸。

创建一个解决方案 
我们的解决方案，将有一个结构类似上述代码，其中的一部分将取代行1，这样为缩放做准备。另一部分将取代行2，做最后的缩放。我们将开始替换行2的部分代码，引入两个新的概念，裁剪和合适。

替换行2 
在这一部分，我们将缩放位图到我们所需要的。这一步很必要，因为之前的解码能力是有限的。此外，在这一步为了避免拉伸，我们可能要重新调整图片到想要的大小。

有两种可能性可以避免拉伸。不管是那种，我们都要调整尺寸，以确保他们有相同的宽高比；即缩放图像作为源图像，直到它适合想要的尺寸，或裁剪具有相同的宽高比的源图像为想要的尺寸。

左边的图片：图像通过fit方法缩放。图片已被缩小到适合的尺寸和高度，结果是小于想要的高度。右边的图像：图像crop方法缩放。图像已被缩放到适应至少想要的尺寸。因此原图已被裁剪，切割了成左边和右边二部分。

为了缩放这样的效果，我们的实现代码如下：

1	publicstatic Bitmap createScaledBitmap(Bitmap unscaledBitmap, int dstWidth, intdstHeight, ScalingLogic scalingLogic) {

2	Rect srcRect = calculateSrcRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);

3	Rect dstRect = calculateDstRect(unscaledBitmap.getWidth(), unscaledBitmap.getHeight(), dstWidth, dstHeight, scalingLogic);

4	Bitmap scaledBitmap = Bitmap.createBitmap(dstRect.width(), dstRect.height(), Config.ARGB_8888);

5	Canvas canvas = new Canvas(scaledBitmap);

6	canvas.drawBitmap(unscaledBitmap, srcRect, dstRect, newPaint(Paint.FILTER_BITMAP_FLAG));return scaledBitmap;

7

}

在上面的代码，我们使用canvas.drawBitmap(...)做缩放。这种方法的裁剪区域是从源图像的规模面积定义画布的矩形为指定的目标矩形区域。为了避免拉伸，这两个矩形需要有相同的长宽比。我们还调用了两个实用的方法，一个为创建源矩形和另一个为创建目标矩形。方法如下：

01	publicstatic Rect calculateSrcRect(int srcWidth, int srcHeight, int dstWidth, intdstHeight, ScalingLogic scalingLogic) {

02	if (scalingLogic == ScalingLogic.CROP) {

03	finalfloat srcAspect = (float)srcWidth / (float)srcHeight;

04	finalfloat dstAspect = (float)dstWidth / (float)dstHeight;

05	if (srcAspect > dstAspect) {

06	finalint srcRectWidth = (int)(srcHeight * dstAspect);

07	finalint srcRectLeft = (srcWidth - srcRectWidth) / 2;

08	returnnew Rect(srcRectLeft, 0, srcRectLeft + srcRectWidth, srcHeight);

09

} else {

10	finalint srcRectHeight = (int)(srcWidth / dstAspect);

11	finalint scrRectTop = (int)(srcHeight - srcRectHeight) / 2;

12	returnnew Rect(0, scrRectTop, srcWidth, scrRectTop + srcRectHeight);

13

}

14

} else {

15	returnnew Rect(0, 0, srcWidth, srcHeight);

16

}

17

}

18	publicstatic Rect calculateDstRect(int srcWidth, int srcHeight, int dstWidth, intdstHeight, ScalingLogic scalingLogic) {

19	if (scalingLogic == ScalingLogic.FIT) {

20	finalfloat srcAspect = (float)srcWidth / (float)srcHeight;

21	finalfloat dstAspect = (float)dstWidth / (float)dstHeight;

22	if (srcAspect > dstAspect) {

23	returnnew Rect(0, 0, dstWidth, (int)(dstWidth / srcAspect));

24

} else {

25	returnnew Rect(0, 0, (int)(dstHeight * srcAspect), dstHeight);

26

}

27

} else {

28	returnnew Rect(0, 0, dstWidth, dstHeight);

29

}

30

}

在刚好合适的情况下源矩形会包含整个源尺寸。在需要裁剪的情况下，它会计算好具有相同宽高比的目标图像，来裁剪源图像的宽度或高度，以达到你想要的尺寸。而刚好在合适的情况下，将有相同宽高比的源图像，调整成你想要的尺寸的宽度或高度。

替换行1 
解码器很智能，特别是用于JPEG和PNG的格式。这些解码器在图片解码时可以进行缩放，并且性能也有所改善，这样锯齿问题也可以避免。此外，由于图片解码后变小了，需要的内存也会较少。

缩放解码的时候，只要简单设置上BitmapFactory.Options对象的inSampleSize参数，并把它传递给BitmapFactory。样本大小指定一个缩放图像大小的抽象因素，例如2是640×480图像在320×240图像上解码的因素。样本大小设置时，你不能保证严格按照这个数字，图像将被缩减，但至少它不会更小。例如，3倍640×480的图像可能会导致在一个320×240图像不支持值。通常情况下，至少2的一次方支持[1，2，4，8，...]。

下一步是指定一个合适的样本大小。合适的样本大小将产生最大的缩放，但仍然是大于等于你想要的图像尺寸。如下面代码：

01	publicstatic Bitmap decodeFile(String pathName, int dstWidth, int dstHeight, ScalingLogic scalingLogic) {

02	Options options = new Options();

03	options.inJustDecodeBounds = true;

04	BitmapFactory.decodeFile(pathName, options);

05	options.inJustDecodeBounds = false;

06	options.inSampleSize = calculateSampleSize(options.outWidth, options.outHeight, dstWidth, dstHeight, scalingLogic);

07	Bitmap unscaledBitmap = BitmapFactory.decodeFile(pathName, options);

08	return unscaledBitmap;

09

}

10	publicstaticint calculateSampleSize(int srcWidth, int srcHeight, int dstWidth, intdstHeight, ScalingLogic scalingLogic) {

11	if (scalingLogic == ScalingLogic.FIT) {

12	finalfloat srcAspect = (float)srcWidth / (float)srcHeight;

13	finalfloat dstAspect = (float)dstWidth / (float)dstHeight;

14	if (srcAspect > dstAspect) {

15	return srcWidth / dstWidth;

16

} else {

17	return srcHeight / dstHeight;

18

}

19

} else {

20	finalfloat srcAspect = (float)srcWidth / (float)srcHeight;

21	finalfloat dstAspect = (float)dstWidth / (float)dstHeight;

22	if (srcAspect > dstAspect) {

23	return srcHeight / dstHeight;

24

} else {

25	return srcWidth / dstWidth;

26

}

27

}

28

}

在decodeFile（...）方法中，我们解码一个文件进行了最终缩放尺度。这是首先要通过解码源图片尺寸，然后使用calculateSampleSize（...）计算最佳样本大小，最后使用此样本的大小解码图像。如果你有兴趣的话，你可以更深入了解calculateSampleSize（...）方法，但以上方法基本可确保图片进行缩放。

全部放在一起 
根据上面我们指定的方法的，现在可以执行替换最初的代码行：

1	Bitmap unscaledBitmap = decodeFile(pathname, dstWidth, dstHeight, scalingLogic);

2	Bitmap scaledBitmap = createScaledBitmap(unscaledBitmap, dstWidth, dstHeight, scalingLogic);

左边的图像：原始解决方案，解码消耗6693 KB的内存和1/4秒左右。结果被拉长失真。中间的图像：同比缩放解决方案，解码消耗418 KB的内存和1/10秒左右。右边的图像：裁剪解决方案，解码消耗418 KB的内存和1/10秒左右。

想要了解更多信息，请下载我们的代码示例。有了这个源码项目，你可以看到你的Android手机上运行的结果。

引用自：http://www.open-open.com/lib/view/open1329994992015.html

---------------------------

参考3：

http://wenku.baidu.com/view/9ab59c0690c69ec3d5bb750e.html

http://wenku.baidu.com/link?url=8LPD7R0QEUHpybZ4xmw5WckufpCOc_N9EZTb9-lo-27aBn12vogDZfSURw-NM3HLseXrGXU1GIyq9vWbId-3P71Elh8nSC_x5hjt6SuV5RS

-----------------------------

参考4：

[Android实例] 图片察看程序,支持缩放,滚动  [复制链接]

| 来自  51CTO网页

[只看他] 楼主

java:
01.package snowfox.android;

02.

03.import android.app.Activity;

04.import android.graphics.Bitmap;

05.import android.graphics.BitmapFactory;

06.import android.graphics.Matrix;

07.import android.graphics.drawable.BitmapDrawable;

08.import android.os.Bundle;

09.import android.util.Log;

10.import android.view.KeyEvent;

11.import android.widget.ImageView;

12.

13.public class MainActivity extends Activity {

14.    /** Called when the activity is first created. */

15.        private ImageView v1;

16.        private int widthOrg, heightOrg, w;

17.        float scale = 1;

18.        float scaleWidth, scaleHeight;

19.        Bitmap OrgMap, newMap;

20.        BitmapDrawable bmd;

21.        Matrix matrix = new Matrix();

22.         @Override

23.    public void onCreate(Bundle savedInstanceState) {

24.        super.onCreate(savedInstanceState);

25.        setContentView(R.layout.main);

26.        v1 = (ImageView)findViewById(R.id.image01);

27.        OrgMap = BitmapFactory.decodeResource(getResources(), R.drawable.test);

28.        widthOrg = OrgMap.getWidth();

29.        heightOrg = OrgMap.getHeight();

30.        //确定图片初始缩放比例,一般以适应屏幕宽度为准

31.        w = 320;        

32.        scale = (float)w/widthOrg;

33.  

34.        matrix = new Matrix();

35.        matrix.postScale(scale, scale);

36.        newMap = Bitmap.createBitmap(OrgMap, 0, 0, widthOrg, heightOrg, matrix, true);

37.        

38.        bmd = new BitmapDrawable(newMap);

39.        v1.setImageDrawable(bmd);

40.    }

41.         @Override

42.        public boolean onKeyDown(int keyCode, KeyEvent event)

43.        {

44.                //放大图片

45.                if(keyCode == KeyEvent.KEYCODE_VOLUME_UP)

46.                {

47.                        //设置放大尺寸,若大于2倍,则停止放大,另外,小于1200是为了防止因图片太大造成内存泄露

48.                        if(scale < 2.0 && w < 1200)

49.                        {

50.                                scale += 0.1;

51.                                matrix.reset();                                                //重置矩阵

52.                                matrix.postScale(scale, scale);                //设置矩阵属性

53.                                //重新绘图

54.                                newMap = Bitmap.createBitmap(OrgMap, 0, 0, widthOrg, heightOrg, matrix, true);

55.                        

56.                                //转化为drawable图像，使其可以显示在imageview中

57.                                bmd = new BitmapDrawable(newMap);

58.                                v1.setImageDrawable(bmd);

59.                                w = newMap.getWidth();

60.                                int h = newMap.getHeight();

61.                                Log.i("ta==========", w + " " +h);

62.                        }

63.                        return true;

64.                }

65.                

66.                //缩小图片

67.                if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN)

68.                {

69.                        //设置缩放尺寸,若小于0.1倍,则停止缩小

70.                        if(scale > 0.1)

71.                        {

72.                                scale -= 0.05;

73.                        

74.                                matrix.reset();                                                //重置矩阵

75.                                matrix.postScale(scale, scale);                //设置矩阵属性

76.                                //重新绘图

77.                                newMap = Bitmap.createBitmap(OrgMap, 0, 0, widthOrg, heightOrg, matrix, true);

78.                        

79.                                //转化为drawable图像，使其可以显示在imageview中

80.                        bmd = new BitmapDrawable(newMap);

81.                        v1.setImageDrawable(bmd);

82.                        

83.                        w = newMap.getWidth();

84.                        int h = newMap.getHeight();

85.                        Log.i("ta==========", w + " " +h);

86.                        }

87.                        return true;

88.                }

89.                else

90.                        return super.onKeyDown(keyCode, event);        //在其他情况下才调用super是为了屏蔽音量按键原来的功能,同时保证其他按键原功能可用

91.        }

92.}
复制代码

01.<ScrollView xmlns:android="http://schemas.android.com/apk/res/android" 

02.    android:layout_width="fill_parent" android:layout_height="fill_parent" 

03.    android:fillViewport="true"> 

04.    <HorizontalScrollView 

05.            android:layout_width = "fill_parent" 

06.            android:layout_height = "fill_parent"

07.            android:fillViewport = "true">

08.            <LinearLayout 

09.                    android:gravity ="center"

10.                    android:orientation="horizontal" 

11.                android:layout_width="fill_parent" android:layout_height="fill_parent"> 

12.                <ImageView

13.                        android:id = "@+id/image01"

14.                        android:layout_width="wrap_content" 

15.                    android:layout_height="wrap_content"

16.                    android:scaleType ="fitCenter"/>

17.                   </LinearLayout> 

18.    </HorizontalScrollView>

19.</ScrollView>
复制代码

引用自：http://bbs.51cto.com/thread-834394-1.html

--------------------------------------

参考5：

SimpleTouchImageView一个支持缩放平移及多点缩放的显示图片的Activi...

收藏人：[e-mail] 2012-01-12 | 阅：1736  转：0  |  分享   来源

参考6：