Android：从图库加载的位图在ImageView中旋转

当我从媒体库加载一个图像到一个位图，一切都工作正常，除了用相机拍摄的照片，而垂直拿着手机，旋转，使我总是得到一个水平的图片，即使它出现在垂直的画廊。 为什么是这样的，如何正确加载它？

Answer 1

你看过图像的EXIF数据吗？ 拍摄照片时可以知道照相机的方向。

Answer 2

所以，作为一个例子…

首先你需要创build一个ExifInterface：

ExifInterface exif = new ExifInterface(filename); 

然后你可以抓住图像的方向：

 orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); 

以下是定位值的含义： http : //sylvana.net/jpegcrop/exif_orientation.html

所以，最重要的值是3,6和8.例如，如果方向为6，则可以像这样旋转图像：

 Matrix matrix = new Matrix(); matrix.postRotate(90); rotatedBitmap = Bitmap.createBitmap(sourceBitmap, 0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight(), matrix, true); 

虽然这只是一个简单的例子。 我相信还有其他方法来执行实际的旋转。 但是你也可以在StackOverflow上find它们。

Answer 3

这是一个完整的解决scheme（可在Facebook SDK的Hackbook示例中find）。 它具有不需要访问文件本身的优点。 如果你从内容parsing器中加载一个图片，这是非常有用的（例如，如果你的应用程序正在响应共享图片的意图）。

 public static int getOrientation(Context context, Uri photoUri) { /* it's on the external media. */ Cursor cursor = context.getContentResolver().query(photoUri, new String[] { MediaStore.Images.ImageColumns.ORIENTATION }, null, null, null); if (cursor.getCount() != 1) { return -1; } cursor.moveToFirst(); return cursor.getInt(0); } 

然后你可以得到一个旋转的位图如下。 此代码也缩小图像（很不幸）到MAX_IMAGE_DIMENSION。 否则，你可能会用完内存。

 public static Bitmap getCorrectlyOrientedImage(Context context, Uri photoUri) throws IOException { InputStream is = context.getContentResolver().openInputStream(photoUri); BitmapFactory.Options dbo = new BitmapFactory.Options(); dbo.inJustDecodeBounds = true; BitmapFactory.decodeStream(is, null, dbo); is.close(); int rotatedWidth, rotatedHeight; int orientation = getOrientation(context, photoUri); if (orientation == 90 || orientation == 270) { rotatedWidth = dbo.outHeight; rotatedHeight = dbo.outWidth; } else { rotatedWidth = dbo.outWidth; rotatedHeight = dbo.outHeight; } Bitmap srcBitmap; is = context.getContentResolver().openInputStream(photoUri); if (rotatedWidth > MAX_IMAGE_DIMENSION || rotatedHeight > MAX_IMAGE_DIMENSION) { float widthRatio = ((float) rotatedWidth) / ((float) MAX_IMAGE_DIMENSION); float heightRatio = ((float) rotatedHeight) / ((float) MAX_IMAGE_DIMENSION); float maxRatio = Math.max(widthRatio, heightRatio); // Create the bitmap from file BitmapFactory.Options options = new BitmapFactory.Options(); options.inSampleSize = (int) maxRatio; srcBitmap = BitmapFactory.decodeStream(is, null, options); } else { srcBitmap = BitmapFactory.decodeStream(is); } is.close(); /* * if the orientation is not 0 (or -1, which means we don't know), we * have to do a rotation. */ if (orientation > 0) { Matrix matrix = new Matrix(); matrix.postRotate(orientation); srcBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true); } return srcBitmap; } 

Answer 4

解决它在我的情况下使用这个post的帮助下面的代码：

  Bitmap myBitmap = getBitmap(imgFile.getAbsolutePath()); try { ExifInterface exif = new ExifInterface(imgFile.getAbsolutePath()); int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); Log.d("EXIF", "Exif: " + orientation); Matrix matrix = new Matrix(); if (orientation == 6) { matrix.postRotate(90); } else if (orientation == 3) { matrix.postRotate(180); } else if (orientation == 8) { matrix.postRotate(270); } myBitmap = Bitmap.createBitmap(myBitmap, 0, 0, myBitmap.getWidth(), myBitmap.getHeight(), matrix, true); // rotating bitmap } catch (Exception e) { } ImageView img = (ImageView) findViewById(R.id.imgTakingPic); img.setImageBitmap(myBitmap); 

希望能节省一些时间！

Answer 5

使用实用程序来执行重起重。

9创build了一个简单的工具来处理繁重的处理EXIF数据和旋转图像到正确的方向。

您可以在这里find实用程序代码： https ： //gist.github.com/9re/1990019

只需下载它，将其添加到项目的src目录中，然后使用ExifUtil.rotateBitmap()获取正确的方向，如下所示：

 String imagePath = photoFile.getAbsolutePath(); // photoFile is a File class. Bitmap myBitmap = BitmapFactory.decodeFile(imagePath); Bitmap orientedBitmap = ExifUtil.rotateBitmap(imagePath, myBitmap); 

Answer 6

它因为画廊正确显示旋转的图像，而不是ImageView看这里：

  myBitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath(),optionss); ExifInterface exif = new ExifInterface(selectedImagePath); int rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); int rotationInDegrees = exifToDegrees(rotation); deg = rotationInDegrees; Matrix matrix = new Matrix(); if (rotation != 0f) { matrix.preRotate(rotationInDegrees); myBitmap = Bitmap.createBitmap(myBitmap, 0, 0, myBitmap.getWidth(), myBitmap.getHeight(), matrix, true); } 

你需要这个：

 private static int exifToDegrees(int exifOrientation) { if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) { return 90; } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) { return 180; } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) { return 270; } return 0; } 

Answer 7

得到它的工作后，许多尝试感谢一个职位，我不能再find:-(

Exif似乎总是工作，难度是得到文件path。 我发现的代码在4.4之前和4.4之后的API之间有所不同。 基本上4.4+的图片URI包含“com.android.providers”。 对于这种types的URI，代码使用DocumentsContract获取图片ID，然后使用ContentResolver运行查询，而对于较旧的SDK，代码直接使用ContentResolver查询URI。

这里是代码（抱歉，我不能相信谁发布它）：

 /** * Handles pre V19 uri's * @param context * @param contentUri * @return */ public static String getPathForPreV19(Context context, Uri contentUri) { String res = null; String[] proj = { MediaStore.Images.Media.DATA }; Cursor cursor = context.getContentResolver().query(contentUri, proj, null, null, null); if(cursor.moveToFirst()){; int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); res = cursor.getString(column_index); } cursor.close(); return res; } /** * Handles V19 and up uri's * @param context * @param contentUri * @return path */ @TargetApi(Build.VERSION_CODES.KITKAT) public static String getPathForV19AndUp(Context context, Uri contentUri) { String wholeID = DocumentsContract.getDocumentId(contentUri); // Split at colon, use second item in the array String id = wholeID.split(":")[1]; String[] column = { MediaStore.Images.Media.DATA }; // where id is equal to String sel = MediaStore.Images.Media._ID + "=?"; Cursor cursor = context.getContentResolver(). query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column, sel, new String[]{ id }, null); String filePath = ""; int columnIndex = cursor.getColumnIndex(column[0]); if (cursor.moveToFirst()) { filePath = cursor.getString(columnIndex); } cursor.close(); return filePath; } public static String getRealPathFromURI(Context context, Uri contentUri) { String uriString = String.valueOf(contentUri); boolean goForKitKat= uriString.contains("com.android.providers"); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && goForKitKat) { Log.i("KIKAT","YES"); return getPathForV19AndUp(context, contentUri); } else { return getPathForPreV19(context, contentUri); } } 

Answer 8

你可以从SD卡读取path，并执行下面的代码…它将在旋转后replace现有的照片..

不是：Exif不适用于大多数设备，它提供了错误的数据，因此在保存到任何你想要的程度之前硬编码旋转是很好的，你只需要将postRotate中的angular度值更改为任何你想要的。

  String photopath = tempphoto.getPath().toString(); Bitmap bmp = BitmapFactory.decodeFile(photopath); Matrix matrix = new Matrix(); matrix.postRotate(90); bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true); FileOutputStream fOut; try { fOut = new FileOutputStream(tempphoto); bmp.compress(Bitmap.CompressFormat.JPEG, 85, fOut); fOut.flush(); fOut.close(); } catch (FileNotFoundException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 

Answer 9

你需要的第一件事是真正的文件path如果你有它的好，如果你使用URI然后使用这个方法来获得真正的path：

  public static String getRealPathFromURI(Uri contentURI,Context context) { String path= contentURI.getPath(); try { Cursor cursor = context.getContentResolver().query(contentURI, null, null, null, null); cursor.moveToFirst(); String document_id = cursor.getString(0); document_id = document_id.substring(document_id.lastIndexOf(":") + 1); cursor.close(); cursor = context.getContentResolver().query( android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI, null, MediaStore.Images.Media._ID + " = ? ", new String[]{document_id}, null); cursor.moveToFirst(); path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA)); cursor.close(); } catch(Exception e) { return path; } return path; } 

提取你的位图，例如：

  try { Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImage); } catch (IOException e) { Log.e("IOException",e.toString()); } 

如果你愿意，你可以使用decodeFile（）。

现在你已经有了位图和真正的path获取图像的方向：

  private static int getExifOrientation(String src) throws IOException { int orientation = 1; ExifInterface exif = new ExifInterface(src); String orientationString=exif.getAttribute(ExifInterface.TAG_ORIENTATION); try { orientation = Integer.parseInt(orientationString); } catch(NumberFormatException e){} return orientation; } 

最后旋转到正确的位置，如下所示：

 public static Bitmap rotateBitmap(String src, Bitmap bitmap) { try { int orientation = getExifOrientation(src); if (orientation == 1) { return bitmap; } Matrix matrix = new Matrix(); switch (orientation) { case 2: matrix.setScale(-1, 1); break; case 3: matrix.setRotate(180); break; case 4: matrix.setRotate(180); matrix.postScale(-1, 1); break; case 5: matrix.setRotate(90); matrix.postScale(-1, 1); break; case 6: matrix.setRotate(90); break; case 7: matrix.setRotate(-90); matrix.postScale(-1, 1); break; case 8: matrix.setRotate(-90); break; default: return bitmap; } try { Bitmap oriented = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); bitmap.recycle(); return oriented; } catch (OutOfMemoryError e) { e.printStackTrace(); return bitmap; } } catch (IOException e) { e.printStackTrace(); } return bitmap; } 

就是这样，你现在将位图旋转到正确的位置。

干杯。

Answer 10

这有效，但可能不是最好的办法，但它可能有助于某人。

 String imagepath = someUri.getAbsolutePath(); imageview = (ImageView)findViewById(R.id.imageview); imageview.setImageBitmap(setImage(imagepath, 120, 120)); public Bitmap setImage(String path, final int targetWidth, final int targetHeight) { Bitmap bitmap = null; // Get exif orientation try { ExifInterface exif = new ExifInterface(path); int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); if (orientation == 6) { orientation_val = 90; } else if (orientation == 3) { orientation_val = 180; } else if (orientation == 8) { orientation_val = 270; } } catch (Exception e) { } try { // First decode with inJustDecodeBounds=true to check dimensions final BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeFile(path, options); // Adjust extents int sourceWidth, sourceHeight; if (orientation_val == 90 || orientation_val == 270) { sourceWidth = options.outHeight; sourceHeight = options.outWidth; } else { sourceWidth = options.outWidth; sourceHeight = options.outHeight; } // Calculate the maximum required scaling ratio if required and load the bitmap if (sourceWidth > targetWidth || sourceHeight > targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); options.inJustDecodeBounds = false; options.inSampleSize = (int)maxRatio; bitmap = BitmapFactory.decodeFile(path, options); } else { bitmap = BitmapFactory.decodeFile(path); } // Rotate the bitmap if required if (orientation_val > 0) { Matrix matrix = new Matrix(); matrix.postRotate(orientation_val); bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); } // Re-scale the bitmap if necessary sourceWidth = bitmap.getWidth(); sourceHeight = bitmap.getHeight(); if (sourceWidth != targetWidth || sourceHeight != targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); sourceWidth = (int)((float)sourceWidth / maxRatio); sourceHeight = (int)((float)sourceHeight / maxRatio); bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true); } } catch (Exception e) { } return bitmap; } 

Answer 11

使用下面的代码来正确旋转图像：

 private Bitmap rotateImage(Bitmap bitmap, String filePath) { Bitmap resultBitmap = bitmap; try { ExifInterface exifInterface = new ExifInterface(filePath); int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); Matrix matrix = new Matrix(); if (orientation == ExifInterface.ORIENTATION_ROTATE_90) { matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_90); } else if (orientation == ExifInterface.ORIENTATION_ROTATE_180) { matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_180); } else if (orientation == ExifInterface.ORIENTATION_ROTATE_270) { matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_270); } // Rotate the bitmap resultBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); } catch (Exception exception) { Logger.d("Could not rotate the image"); } return resultBitmap; } 

Answer 12

也许这会帮助（旋转90度）（这对我工作）

 private Bitmap rotateBitmap(Bitmap image){ int width=image.getHeight(); int height=image.getWidth(); Bitmap srcBitmap=Bitmap.createBitmap(width, height, image.getConfig()); for (int y=width-1;y>=0;y--) for(int x=0;x<height;x++) srcBitmap.setPixel(width-y-1, x,image.getPixel(x, y)); return srcBitmap; } 

Answer 13

Teo Inke的回答得到了改进。 除非实际需要，否则不再旋转图像。 阅读起来也比较容易，而且运行速度要快一些。

 // Load Image Bitmap bitmap = BitmapFactory.decodeFile(filePath); // Rotate Image if Needed try { // Determine Orientation ExifInterface exif = new ExifInterface(filePath); int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); // Determine Rotation int rotation = 0; if (orientation == 6) rotation = 90; else if (orientation == 3) rotation = 180; else if (orientation == 8) rotation = 270; // Rotate Image if Necessary if (rotation != 0) { // Create Matrix Matrix matrix = new Matrix(); matrix.postRotate(rotation); // Rotate Bitmap Bitmap rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); // Pretend none of this ever happened! bitmap.recycle(); bitmap = rotated; rotated = null; } } catch (Exception e) { // TODO: Log Error Messages Here } // TODO: Use Result Here xxx.setBitmap(bitmap); 

Answer 14

光标在打开后应该closures。

这是一个例子。

  public static int getOrientation(Context context, Uri selectedImage) { int orientation = -1; Cursor cursor = context.getContentResolver().query(selectedImage, new String[] { MediaStore.Images.ImageColumns.ORIENTATION }, null, null, null); if (cursor.getCount() != 1) return orientation; cursor.moveToFirst(); orientation = cursor.getInt(0); cursor.close(); // ADD THIS LINE return orientation; } 

Answer 15

在Timmmm的基础上改进上面的解决scheme，在最后添加一些额外的缩放比例，以确保图像符合范围：

 public static Bitmap loadBitmap(String path, int orientation, final int targetWidth, final int targetHeight) { Bitmap bitmap = null; try { // First decode with inJustDecodeBounds=true to check dimensions final BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeFile(path, options); // Adjust extents int sourceWidth, sourceHeight; if (orientation == 90 || orientation == 270) { sourceWidth = options.outHeight; sourceHeight = options.outWidth; } else { sourceWidth = options.outWidth; sourceHeight = options.outHeight; } // Calculate the maximum required scaling ratio if required and load the bitmap if (sourceWidth > targetWidth || sourceHeight > targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); options.inJustDecodeBounds = false; options.inSampleSize = (int)maxRatio; bitmap = BitmapFactory.decodeFile(path, options); } else { bitmap = BitmapFactory.decodeFile(path); } // Rotate the bitmap if required if (orientation > 0) { Matrix matrix = new Matrix(); matrix.postRotate(orientation); bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); } // Re-scale the bitmap if necessary sourceWidth = bitmap.getWidth(); sourceHeight = bitmap.getHeight(); if (sourceWidth != targetWidth || sourceHeight != targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); sourceWidth = (int)((float)sourceWidth / maxRatio); sourceHeight = (int)((float)sourceHeight / maxRatio); bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true); } } catch (Exception e) { } return bitmap; } 

Answer 16

下面的方法缩放并根据方向旋转位图：

 public Bitmap scaleAndRotateImage(String path, int orientation, final int targetWidth, final int targetHeight) { Bitmap bitmap = null; try { // Check the dimensions of the Image final BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeFile(path, options); // Adjust the Width and Height int sourceWidth, sourceHeight; if (orientation == 90 || orientation == 270) { sourceWidth = options.outHeight; sourceHeight = options.outWidth; } else { sourceWidth = options.outWidth; sourceHeight = options.outHeight; } // Calculate the maximum required scaling ratio if required and load the bitmap if (sourceWidth > targetWidth || sourceHeight > targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); options.inJustDecodeBounds = false; options.inSampleSize = (int)maxRatio; bitmap = BitmapFactory.decodeFile(path, options); } else { bitmap = BitmapFactory.decodeFile(path); } // We need to rotate the bitmap (if required) int orientationInDegrees = exifToDegrees(orientation); if (orientation > 0) { Matrix matrix = new Matrix(); if (orientation != 0f) { matrix.preRotate(orientationInDegrees); }; bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); } // Re-scale the bitmap if necessary sourceWidth = bitmap.getWidth(); sourceHeight = bitmap.getHeight(); if (sourceWidth != targetWidth || sourceHeight != targetHeight) { float widthRatio = (float)sourceWidth / (float)targetWidth; float heightRatio = (float)sourceHeight / (float)targetHeight; float maxRatio = Math.max(widthRatio, heightRatio); sourceWidth = (int)((float)sourceWidth / maxRatio); sourceHeight = (int)((float)sourceHeight / maxRatio); bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true); } } catch (Exception e) { Logger.d("Could not rotate the image"); Logger.d(e.getMessage()); } return bitmap; } 

例：

 public void getPictureFromDevice(Uri Uri,ImageView imageView) { try { ExifInterface exifInterface = new ExifInterface(Uri.getPath()); int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); Bitmap bitmap = scaleAndRotateImage(Uri.getPath(), orientation, imageView.getWidth(), imageView.getHeight()); imageView.setImageBitmap(bitmap); } catch (OutOfMemoryError outOfMemoryError) { Logger.d(outOfMemoryError.getLocalizedMessage()); Logger.d("Failed to load image from filePath (out of memory)"); Logger.d(Uri.toString()); } catch (Exception e) { Logger.d("Failed to load image from filePath"); Logger.d(Uri.toString()); } } 

Answer 17

我融化了@Timmmm答案和@Manuel。 如果你做这个解决scheme，你将不会得到一个内存不足的例外。

此方法检索图像方向：

 private static final int ROTATION_DEGREES = 90; // This means 512 px private static final Integer MAX_IMAGE_DIMENSION = 512; public static int getOrientation(Uri photoUri) throws IOException { ExifInterface exif = new ExifInterface(photoUri.getPath()); int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1); switch (orientation) { case ExifInterface.ORIENTATION_ROTATE_90: orientation = ROTATION_DEGREES; break; case ExifInterface.ORIENTATION_ROTATE_180: orientation = ROTATION_DEGREES * 2; break; case ExifInterface.ORIENTATION_ROTATE_270: orientation = ROTATION_DEGREES * 3; break; default: // Default case, image is not rotated orientation = 0; } return orientation; } 

因此，您可以在将图像加载到内存之前使用此方法调整图像大小。 这样，你不会得到一个内存exception。

 public static Bitmap getCorrectlyOrientedImage(Context context, Uri photoUri) throws IOException { InputStream is = context.getContentResolver().openInputStream(photoUri); BitmapFactory.Options dbo = new BitmapFactory.Options(); dbo.inJustDecodeBounds = true; BitmapFactory.decodeStream(is, null, dbo); is.close(); int rotatedWidth, rotatedHeight; int orientation = getOrientation(photoUri); if (orientation == 90 || orientation == 270) { rotatedWidth = dbo.outHeight; rotatedHeight = dbo.outWidth; } else { rotatedWidth = dbo.outWidth; rotatedHeight = dbo.outHeight; } Bitmap srcBitmap; is = context.getContentResolver().openInputStream(photoUri); if (rotatedWidth > MAX_IMAGE_DIMENSION || rotatedHeight > MAX_IMAGE_DIMENSION) { float widthRatio = ((float) rotatedWidth) / ((float) MAX_IMAGE_DIMENSION); float heightRatio = ((float) rotatedHeight) / ((float) MAX_IMAGE_DIMENSION); float maxRatio = Math.max(widthRatio, heightRatio); // Create the bitmap from file BitmapFactory.Options options = new BitmapFactory.Options(); options.inSampleSize = (int) maxRatio; srcBitmap = BitmapFactory.decodeStream(is, null, options); } else { srcBitmap = BitmapFactory.decodeStream(is); } is.close(); // if the orientation is not 0, we have to do a rotation. if (orientation > 0) { Matrix matrix = new Matrix(); matrix.postRotate(orientation); srcBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true); } return srcBitmap; } 

这对我来说是完美的。 我希望这可以帮助别人

Answer 18

我解决了以下解决方法的问题。 请注意，我也在缩放图像，这是避免OutOfMemoryExceptions所必需的。

请注意，这种解决scheme将不能正常使用肖像图像或倒置图像（感谢Timmmm的注意）。 Timmmm的解决scheme可能是更好的select，如果这是必需的，它也看起来更优雅： https : //stackoverflow.com/a/8914291/449918

 File path = // ... location of your bitmap file int w = 512; int h = 384; // size that does not lead to OutOfMemoryException on Nexus One Bitmap b = BitmapFactory.decodeFile(path); // Hack to determine whether the image is rotated boolean rotated = b.getWidth() > b.getHeight(); Bitmap resultBmp = null; // If not rotated, just scale it if (!rotated) { resultBmp = Bitmap.createScaledBitmap(b, w, h, true); b.recycle(); b = null; // If rotated, scale it by switching width and height and then rotated it } else { Bitmap scaledBmp = Bitmap.createScaledBitmap(b, h, w, true); b.recycle(); b = null; Matrix mat = new Matrix(); mat.postRotate(90); resultBmp = Bitmap.createBitmap(scaledBmp, 0, 0, h, w, mat, true); // Release image resources scaledBmp.recycle(); scaledBmp = null; } // resultBmp now contains the scaled and rotated image 

干杯