Scale and correct image orientation

Question

I am trying to scale the size of an image and at the same time make the image orientation correct. Both are working properly if we use them individually. But I need to find a way for combining both. That means, I need to scale down the image and at the same time correct it's orientation and display it on ImageView.

Code for image scaling:

public static Bitmap decodeSampledBitmapFromResource(String imageFileName,int reqWidth, int reqHeight) 
    {
        // First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(imageFileName,options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(imageFileName, options);
    }


/**
     * Function to calculate the size of am image
     */
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight)
    {
        // Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) 
        {
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
            // height and width larger than the requested height and width.
            while ((halfHeight / inSampleSize) > reqHeight
                    && (halfWidth / inSampleSize) > reqWidth) 
            {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

Here is the code for correcting the orientation:

/**
 * Function to manage the orientation of the image
 */
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;
}

/**
 * Function to get the orientation of an image
 */
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);
}

Please suggest me a way for combining both.

Look at my ans here : http://stackoverflow.com/questions/24128346/getting-rotation-from-exifinterface-always-returns-0/24219714#24219714 — Haresh Chhelana, Jun 20 '14 at 06:31
@Haresh: Can you suggest a way by combining the methods given in my question? — roy mathew, Jun 20 '14 at 06:34

score 0 · Answer 1 · answered Jun 20 '14 at 06:38

try this

public static Bitmap decodeFile(File f) {
        try {
            // decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(new FileInputStream(f), null, o);

            // Find the correct scale value. It should be the power of 2.
            final int REQUIRED_SIZE = 70;
            int width_tmp = o.outWidth, height_tmp = o.outHeight;
            int scale = 1;
            while (true) {
                if (width_tmp / 2 < REQUIRED_SIZE
                        || height_tmp / 2 < REQUIRED_SIZE)
                    break;
                width_tmp /= 2;
                height_tmp /= 2;
                scale++;
            }

            // decode with inSampleSize
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inSampleSize = scale;
            return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
        } catch (FileNotFoundException e) {
        }
        return null;
    }

    public static Bitmap getCorrectBitmap(Bitmap bitmap, String filePath) {
        ExifInterface ei;
        try {
            ei = new ExifInterface(filePath);

            int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);

            switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                return rotateImage(bitmap, 90);

            case ExifInterface.ORIENTATION_ROTATE_180:
                return rotateImage(bitmap, 180);

            case ExifInterface.ORIENTATION_ROTATE_270:
                return rotateImage(bitmap, 270);

            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return bitmap;
    }

score 0 · Accepted Answer · edited May 23 '17 at 12:27

0

I found the solution in this link:

Picture taken from camera or gallery when using in imageview its orientation getting changed, and sometimes vertically stretched in Android

I called decodeSampledBitmapFromResource() inside the RotateOrientationCall() method in the above link after checking whether it needs to be rotated or not.

edited May 23 '17 at 12:27

Community

1
1

answered Jun 20 '14 at 07:25

roy mathew

7,782
4
29
40

Scale and correct image orientation

2 Answers2