Jak znaleźć orientację zdjęcia zrobionego za pomocą programu Intent MediaStore.ACTION_IMAGE_CAPTURE?

Question

Kiedy robię zdjęcie za pomocą aplikacji aparatu Android, wykrywa orientację telefonu i zapisuje zdjęcie odpowiednio. Jeśli więc zrobię zdjęcie budynku, dach będzie na górze, niezależnie od tego, czy trzymam telefon w pozycji poziomej, czy portretowej.

Jednak podczas korzystania

Intent imageCaptureIntent = nowy Intent (MediaStore.ACTION_IMAGE_CAPTURE); Aby uzyskać zdjęcie, aplikacja aparatu nie reaguje na orientację, aby uzyskać

. Jeśli trzymam telefon pionowo (portret), powstały obraz zostanie obrócony, z dachem budynku po lewej stronie ekranu.

Jak ustawić cel, aby aparat uwzględnił orientację?

Czy mogę w jakiś sposób wydedukować, w jakiej orientacji został zrobiony pic i sam go obracać?

Lub jakakolwiek inna sugestia zostanie bardzo doceniona.

~ Z góry dzięki, pozdrawiam.

Answer 1

Znaleziono odpowiedź. Exif obrazu ma wskaźnik orientacji. Tylko w przypadku, Exif mogą być przeglądane w Androidzie tak:

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

Answer 2

Odczyt z Exif jeśli są dostępne, inaczej odczytać z 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

Dla szybkiej i taniej można sprawdzić, czy szerokość obrazu jest większa niż wysokość obrazu. to znaczy, że jest krajobrazem i możesz go zmienić na portret.

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; 
    }