resize image from file

Question

I am uploading an image to a server and before that happens, I would like to resize the image dimensions. I get the image with a URI like this:

Constants.currImageURI = data.getData();

this is the call to upload the image:

String response = uploadUserPhoto(new File(getRealPathFromURI(Constants.currImageURI)));

    public String uploadUserPhoto(File image) {

    DefaultHttpClient mHttpClient;
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    mHttpClient = new DefaultHttpClient(params);

    try {
        HttpPost httppost = new HttpPost("http://myurl/mobile/image");

        MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);  
        multipartEntity.addPart("userID", new StringBody(Constants.userID));
        multipartEntity.addPart("uniqueMobileID", new StringBody(Constants.uniqueMobileID));
        multipartEntity.addPart("userfile", new FileBody(image, "mobileimage.jpg", "image/jpeg", "UTF-8"));
        httppost.setEntity(multipartEntity);

        HttpResponse response = mHttpClient.execute(httppost);
        String responseBody = EntityUtils.toString(response.getEntity());

        Log.d(TAG, "response: " + responseBody);
        return responseBody;

    } catch (Exception e) {
       Log.d(TAG, e.getMessage());
    }
    return "";
}

Is there a way to resize the file based on pixel dimensions?

Thanks.

Pointer Null · Answer 1 · 2012-11-06T14:14:46.003

Use Bitmap.createScaledBitmap as others suggested.

However, this function is not very smart. If you're scaling to less than 50% size, you're likely to get this:

enter image description here

Instead of this:

enter image description here

Do you see bad antialiasing of 1st image? createScaledBitmap will get you this result.

Reason is pixel filtering, where some pixels are completely skipped from source if scaling to < 50%.

To get 2nd quality result, you need to halve the Bitmap's resolution if it's more than 2x larger than desired result, then finally you make call to createScaledBitmap.

And there're more approaches to halve (or quarter, or eighten) images. If you have Bitmap in memory, you recursively call Bitmap.createScaledBitmap to halve image.

If you load image from JPG file, implementation is even faster: you use BitmapFactory.decodeFile and setup Options parameter properly, mainly field inSampleSize, which controls subsambling of loaded images, utilizing JPEG's characteristics.

Many apps which provide image thumbnails use blindly Bitmap.createScaledBitmap, and the thumbnails are just ugly. Be smart and use proper image downsampling.

That's not "bad antialiasing", that aliasing itself. – Agent_L Nov 22 '18 at 13:14 — Agent_L, Nov 22 '18 at 13:14

score 9 · Accepted Answer · edited Nov 09 '13 at 03:29

This is taken from ThinkAndroid at this url: http://thinkandroid.wordpress.com/2009/12/25/resizing-a-bitmap/

I would look into the possibility of creating a Bitmap or Drawable from the resource and if you want to change it's size use the code below.

public Bitmap getResizedBitmap(Bitmap bm, int newHeight, int newWidth) {
    int width = bm.getWidth();
    int height = bm.getHeight();
    float scaleWidth = ((float) newWidth) / width;
    float scaleHeight = ((float) newHeight) / height;

    // Create a matrix for the manipulation
    Matrix matrix = new Matrix();

    // Resize the bit map
    matrix.postScale(scaleWidth, scaleHeight);

    // Recreate the new Bitmap
    Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, false);
    return resizedBitmap;

}

EDIT: As suggested in other comment Bitmap.createScaledBitmap should be used for better quality when resizing.

score 5 · Answer 3 · edited May 23 '17 at 11:47

See what Google recommends doing (as @Pointer Null advised):

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

I call the above to resize a large image:

// Check if source and destination exist
// Check if we have read/write permissions

int desired_width = 200;
int desired_height = 200;

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;

BitmapFactory.decodeFile(SOME_PATH_TO_LARGE_IMAGE, options);

options.inSampleSize = calculateInSampleSize(options, desired_width, desired_height);
options.inJustDecodeBounds = false;

Bitmap smaller_bm = BitmapFactory.decodeFile(src_path, options);

FileOutputStream fOut;
try {
    File small_picture = new File(SOME_PATH_STRING);
    fOut = new FileOutputStream(small_picture);
    // 0 = small/low quality, 100 = large/high quality
    smaller_bm.compress(Bitmap.CompressFormat.JPEG, 50, fOut);
    fOut.flush();
    fOut.close();
    smaller_bm.recycle();
} catch (Exception e) {
    Log.e(LOG_TAG, "Failed to save/resize image due to: " + e.toString());
}

score 5 · Answer 4 · answered Dec 07 '11 at 19:42

5

How to resize a bitmap:

Bitmap.createScaledBitmap(src, dstWidth, dstHeight, filter)

answered Dec 07 '11 at 19:42

Jave

31,598
14
77
90

resize image from file

4 Answers4

Linked

Related