Android : Les bitmaps chargés depuis une galerie sont pivotés dans ImageView

Question

Lorsque je charge une image de la galerie multimédia dans un bitmap, tout fonctionne bien, sauf que les photos qui ont été prises avec l'appareil photo en tenant le téléphone verticalement, sont tournées de sorte que j'obtienne toujours une image horizontale même si elle apparaît verticalement dans la galerie. Pourquoi et comment puis-je les charger correctement ?

Answer 1

Donc, à titre d'exemple...

Tout d'abord, vous devez créer une ExifInterface :

ExifInterface exif = new ExifInterface(filename);

Vous pouvez alors saisir l'orientation de l'image :

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

Voici ce que signifient les valeurs d'orientation : http://sylvana.net/jpegcrop/exif_orientation.html

Ainsi, les valeurs les plus importantes sont 3, 6 et 8. Si l'orientation est ExifInterface.ORIENTATION_ROTATE_90 (qui est 6), par exemple, vous pouvez faire pivoter l'image comme ceci :

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

Mais ce n'est qu'un exemple rapide. Je suis sûr qu'il existe d'autres façons d'effectuer la rotation réelle. Mais vous les trouverez également sur StackOverflow.

Answer 2

Il s'agit d'une solution complète (trouvée dans l'exemple Hackbook du SDK de Facebook). Elle a l'avantage de ne pas nécessiter l'accès au fichier lui-même. C'est extrêmement utile si vous chargez une image à partir du résolveur de contenu (par exemple, si votre application répond à une intention de partage de photo).

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

Et ensuite, vous pouvez obtenir un Bitmap pivoté comme suit. Ce code réduit également la taille de l'image (malheureusement mal) à MAX_IMAGE_DIMENSION. Sinon, vous risquez de manquer de mémoire.

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 3

Je l'ai résolu dans mon cas avec ce code en utilisant l'aide de ce 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);

J'espère que cela fera gagner du temps à quelqu'un !

Answer 4

Utilisez un utilitaire pour faire le gros du travail.

9re a créé un utilitaire simple pour traiter les données EXIF et faire pivoter les images dans leur orientation correcte.

Vous pouvez trouver le code de l'utilitaire ici : https://gist.github.com/9re/1990019

Il suffit de le télécharger, de l'ajouter au dossier de votre projet. src et utiliser ExifUtil.rotateBitmap() pour obtenir l'orientation correcte, comme ceci :

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

Bitmap orientedBitmap = ExifUtil.rotateBitmap(imagePath, myBitmap);

Answer 5

Avez-vous regardé les données EXIF des images ? Elles peuvent connaître l'orientation de l'appareil photo au moment où la photo a été prise.