¿Cómo puedo encontrar la orientación de una imagen tomada con Intent MediaStore.ACTION_IMAGE_CAPTURE?

Question

Cuando tomo una foto con la aplicación de la cámara Androids, ésta detecta la orientación del teléfono y guarda la imagen como corresponde. Entonces, si tomo una foto de un edificio, el techo estará en la parte superior, ya sea que mantenga el teléfono en posición horizontal o vertical.

Sin embargo, cuando se utiliza

Intención imageCaptureIntent = new Intención (MediaStore.ACTION_IMAGE_CAPTURE);

para obtener una imagen, la aplicación de la cámara no reacciona a la orientación. Si sostengo el teléfono verticalmente (retrato), la imagen resultante se rotará, con el techo de dicho edificio a la izquierda de la pantalla.

¿Cómo puedo configurar el intento para que la cámara tenga en cuenta la orientación?

¿O puedo deducir de alguna manera en qué orientación se tomó la imagen y rotarla después?

O cualquier otra sugerencia será muy apreciada.

~ Gracias de antemano, saludos cordiales.

Answer 1

Encontrado la respuesta. El exif de la imagen tiene un indicador de la orientación. Por si acaso, Exif puede ser visto en Android como esto:

ExifInterface exif = new ExifInterface("filepath"); 
exif.getAttribute(ExifInterface.TAG_ORIENTATION); 

Answer 2

Leer de Exif, si está disponible, leer de otra forma de MediaStore

public static int getImageOrientation(Context context, String imagePath) { 
    int orientation = getOrientationFromExif(imagePath); 
    if(orientation <= 0) { 
     orientation = getOrientationFromMediaStore(context, imagePath); 
    } 

    return orientation; 
} 

private static int getOrientationFromExif(String imagePath) { 
    int orientation = -1; 
    try { 
     ExifInterface exif = new ExifInterface(imagePath); 
     int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 
       ExifInterface.ORIENTATION_NORMAL); 

     switch (exifOrientation) { 
      case ExifInterface.ORIENTATION_ROTATE_270: 
       orientation = 270; 

       break; 
      case ExifInterface.ORIENTATION_ROTATE_180: 
       orientation = 180; 

       break; 
      case ExifInterface.ORIENTATION_ROTATE_90: 
       orientation = 90; 

       break; 

      case ExifInterface.ORIENTATION_NORMAL: 
       orientation = 0; 

       break; 
      default: 
       break; 
     } 
    } catch (IOException e) { 
     Log.e(LOG_TAG, "Unable to get image exif orientation", e); 
    } 

    return orientation; 
} 

private static int getOrientationFromMediaStore(Context context, String imagePath) { 
    Uri imageUri = getImageContentUri(context, imagePath); 
    if(imageUri == null) { 
     return -1; 
    } 

    String[] projection = {MediaStore.Images.ImageColumns.ORIENTATION}; 
    Cursor cursor = context.getContentResolver().query(imageUri, projection, null, null, null); 

    int orientation = -1; 
    if (cursor != null && cursor.moveToFirst()) { 
     orientation = cursor.getInt(0); 
     cursor.close(); 
    } 

    return orientation; 
} 

private static Uri getImageContentUri(Context context, String imagePath) { 
    String[] projection = new String[] {MediaStore.Images.Media._ID}; 
    String selection = MediaStore.Images.Media.DATA + "=? "; 
    String[] selectionArgs = new String[] {imagePath}; 
    Cursor cursor = context.getContentResolver().query(IMAGE_PROVIDER_URI, projection, 
      selection, selectionArgs, null); 

    if (cursor != null && cursor.moveToFirst()) { 
     int imageId = cursor.getInt(0); 
     cursor.close(); 

     return Uri.withAppendedPath(IMAGE_PROVIDER_URI, Integer.toString(imageId)); 
    } 

    if (new File(imagePath).exists()) { 
     ContentValues values = new ContentValues(); 
     values.put(MediaStore.Images.Media.DATA, imagePath); 

     return context.getContentResolver().insert(
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values); 
    } 

    return null; 
} 

Answer 3

Para una solución rápida se puede comprobar si el ancho de la imagen es más grande que la altura de la imagen significa que es un paisaje y puedes cambiarlo a retrato.

private Bitmap fromGallery(final Uri selectedImageUri) { 
     try { 
      Bitmap bm = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri); 

      ExifInterface exif = new ExifInterface(selectedImageUri.getPath()); 
      int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 

      int angle = 0; 
      switch (orientation) { 
       case ExifInterface.ORIENTATION_ROTATE_90: 
        angle = 90; 
        break; 
       case ExifInterface.ORIENTATION_ROTATE_180: 
        angle = 180; 
        break; 
       case ExifInterface.ORIENTATION_ROTATE_270: 
        angle = 270; 
        break; 
       default: 
        angle = 0; 
        break; 
      } 
      Matrix mat = new Matrix(); 
      if (angle == 0 && bm.getWidth() > bm.getHeight()) 
       mat.postRotate(90); 
      else 
       mat.postRotate(angle); 

      return Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), mat, true); 

     } catch (IOException e) { 
      Log.e("", "-- Error in setting image"); 
     } catch (OutOfMemoryError oom) { 
      Log.e("", "-- OOM Error in setting image"); 
     } 
     return null; 
    }