Resize image while keeping aspect ratio in Java

Question

im trying to resize bufferdImage in memory in java but to keep the aspect ratio of the image im have something like this but this is not good

int w = picture.getWidth();
int h = picture.getWidth();
int neww=w;
int newh=h;
int wfactor = w;
int hfactor = h;
if(w > DEFULT_PICTURE_WIDTH || h > DEFULT_PICTURE_HIGHT)
{
    while(neww > DEFULT_PICTURE_WIDTH)
    {
        neww = wfactor /2;
        newh = hfactor /2;
        wfactor = neww;
        hfactor = newh;
    }
}

picture = Utils.resizePicture(picture,neww,newh);

score 71 · Answer 1 · edited Dec 25 '22 at 01:00

Adding to Erik's point about getScaledInstance, if you moved away from it to using the recommended scaling mechanisms in Java2D, you might have noticed that your images look noticeably worse.

The reason for that is when the Java2D discouraged use of getScaledInstance and AreaAveragingScaleFilter, they didn't replace it with anything as easy to use in the API, instead we were left to our own devices using Java2D APIs directly. Fortunately, Chris Campbell (from the J2D team) followed up with the recommendation of using an incremental scaling technique that gives similar looking results to AreaAveragingScaleFilter and runs faster; unfortunately the code is of a decent size and doesn't address your original question of honoring proportions.

About 6 months ago I saw all these questions on SO again and again about "scaling images in Java" and eventually collected all the advice, did all the digging and research I could, and compiled all of into a single "best practices" image scaling library.

The API is dead simple as it is only 1 class and a bunch of static methods. Basic use looks like this:

BufferedImage img = ImageIO.read(...); // load image
BufferedImage scaledImg = Scalr.resize(img, 320);

This is the simplest call where the library will make a best-guess at the quality, honor your image proportions, and fit the result within a 320x320 bounding box. NOTE, the bounding box is just the maximum W/H used, since your image proportions are honored, the resulting image would still honor that, say 320x200.

If you want to override the automatic mode and force it to give you the best-looking result and even apply a very mild anti-alias filter to the result so it looks even better (especially good for thumbnails), that call would look like:

BufferedImage img = ImageIO.read(...); // load image
BufferedImage scaledImg = Scalr.resize(img, Method.QUALITY, 
                                       150, 100, Scalr.OP_ANTIALIAS);

These are all just examples, the API is broad and covers everything from super-simple use cases to very specialized. You can even pass in your own BufferedImageOps to be applied to the image (and the library automatically fixes the 6-year BufferedImageOp JDK bug for you!)

There is a lot more to scaling images in Java successfully that the library does for you, for example always keeping the image in one of the best supported RGB or ARGB image types while operating on it. Under the covers the Java2D image processing pipeline falls back to an inferior software pipeline if the image type used for any image operations is poorly supported.

If all that sounded like a lot of headache, it sort of is... that's why I wrote the library and open sourced it, so folks could just resize their images and move on with their lives without needing to worry about it.

Just had a look at this library and it helped a lot; would +2 this post if I could, with another +1 for fact your project has its own maven repo hosting. Thanks! — Andrew B, Sep 04 '11 at 16:02
Thank you for the kind words Andrew, I am glad you found it helpful! — Riyad Kalla, Sep 04 '11 at 20:34
@AndrewB I +1 him for you so he gets the +2.. This certainly deserves it. — arg20, Mar 18 '13 at 11:32
"...compiled all of into a single "best practices" image scaling library." this whole sentence is inspiring for me. — akshayb, Jun 12 '13 at 14:35
The problem of the lib (v4.2) is that it does not honor both height and width simultaneously. For example, I have an image 2000x2000. I'd like to fit it in 700x200 squire. I would expect to see output as 200x200 but got 700x700. Yes, I specified both target height and target width — long, Dec 04 '17 at 10:02

score 10 · Answer 2 · answered Dec 11 '09 at 00:49

If width, height of source and target are known, use following function to determine scale of the image.

private double determineImageScale(int sourceWidth, int sourceHeight, int targetWidth, int targetHeight) {

double scalex = (double) targetWidth / sourceWidth;
double scaley = (double) targetHeight / sourceHeight;
return Math.min(scalex, scaley);

}

Then use this scale to scale up/down the image using following code

Image scaledImage = sourceBufferedImage.getScaledInstance((int) (width * scale), (int) (height * scale), Image.SCALE_SMOOTH);

score 10 · Answer 3 · edited Apr 11 '12 at 14:24

10

For starters - take a look at line 2. Shouldnt that be getHeight()?

You dont want a while loop for the resizing, you want to find out the resizing ratio, which is a simple bit of math.

(width / height) = (new_width / new_height)

If you know one of the 'new' sizes, the other can be found via multiplication

new_height * (width / height) = new_width

You can also use the lazy method provided by BufferedImage's superclass Image, getScaledInstance() - using -1 for either width or height will maintain aspect ratio

ex:
scaledPic = picture.getScaledInstance(new_width, -1, Image.SCALE_FAST);

edited Apr 11 '12 at 14:24

Trikaldarshiii

11,174
16
67
95

answered Jun 13 '09 at 19:58

Max

1,528
1
11
17

yeah its getHeight wrong typo is there any Reason i cant use getScaledInstance with BufferdImage? – user63898 Jun 14 '09 at 03:11
That should be fine because BufferedImage extends Image – Max Jun 16 '09 at 00:05
Hah, thanks for that first equation. Made something click in my confuddled brain! – Cameron Jan 03 '12 at 05:32

score 6 · Accepted Answer · edited Mar 24 '18 at 18:31

6

You may have a look at perils-of-image-getscaledinstance.html that explains why getScaledInstance(), used in some of the answers, should be avoided.

The article also provides alternative code.

edited Mar 24 '18 at 18:31

Martin Hlavňa

648
7
20

answered Dec 09 '10 at 22:39

Erik

76
1
1

score 3 · Answer 5 · answered Nov 28 '13 at 14:08

I use these two methods to scale images, where max is the bigger dimension of your destination image. For 100x100 image it will be 100, for 200x300 image it will be 300.

    public static BufferedImage scale(InputStream is, int max) {
    Image image = null;
    try {
        image = ImageIO.read(is);
    } catch (IOException e) {
        e.printStackTrace();
    }
    int width = image.getWidth(null);
    int height = image.getHeight(null);
    double dWidth = 0;
    double dHeight = 0;
    if (width == height) {
        dWidth = max;
        dHeight = max;
    } 
    else if (width > height) {
        dWidth = max;
        dHeight = ((double) height / (double) width) * max;
    }
    else {
        dHeight = max;
        dWidth = ((double) width / (double) height) * max;
    }
    image = image.getScaledInstance((int) dWidth, (int) dHeight, Image.SCALE_SMOOTH);
    BufferedImage bImage = toBufferedImage(image);
    return bImage;

}

public static BufferedImage toBufferedImage(Image img)
{
    if (img instanceof BufferedImage)
    {
        return (BufferedImage) img;
    }

    BufferedImage bimage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_ARGB);

    Graphics2D bGr = bimage.createGraphics();
    bGr.drawImage(img, 0, 0, null);
    bGr.dispose();

    return bimage;
}

score 0 · Answer 6 · answered Dec 01 '19 at 18:29

private static BufferedImage resize(BufferedImage img, int width, int height) {

        double scalex = (double) width / img.getWidth();
        double scaley = (double) height / img.getHeight();
        double scale = Math.min(scalex, scaley);

        int w = (int) (img.getWidth() * scale);
        int h = (int) (img.getHeight() * scale);

        Image tmp = img.getScaledInstance(w, h, Image.SCALE_SMOOTH);

        BufferedImage resized = new BufferedImage(w, h, img.getType());
        Graphics2D g2d = resized.createGraphics();
        g2d.drawImage(tmp, 0, 0, null);
        g2d.dispose();

        return resized;
    }

score 0 · Answer 7 · answered Jun 13 '09 at 20:00

If you want to resize a picture of w0 x h0 to w1 x h1 by keeping the aspect ratio, then calculate the vertical and horizontal scale and select the smaller one.

double scalex = 1;
double scaley = 1;
if (scalingMode == ScalingMode.WINDOW_SIZE) {
  scalex = (double)getWidth() / frontbuffer.getWidth();
  scaley = (double)getHeight() / frontbuffer.getHeight();
} else
if (scalingMode == ScalingMode.KEEP_ASPECT) {
  double sx = (double)getWidth() / frontbuffer.getWidth();
  double sy = (double)getHeight() / frontbuffer.getHeight();
  scalex = Math.min(sx, sy);
  scaley = scalex;
  // center the image
  g2.translate((getWidth() - (frontbuffer.getWidth() * scalex)) / 2,
    (getHeight() - (frontbuffer.getHeight() * scaley)) / 2);
}
g2.scale(scalex, scaley);
if (interpolation != ImageInterpolation.NONE) {
  g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolation.hint);
}
g2.drawImage(frontbuffer, 0, 0, null);

This is an excerpt from one of my codes which renders an animation using swap buffering. frontbuffer is just the BufferedImage which needs to be shown at the moment. — akarnokd, Jun 14 '09 at 09:05

Resize image while keeping aspect ratio in Java

7 Answers7

Linked