Resize to biggest possible image while mantaining the ratio

Question

Sometimes my images are too big and I get this error:

Exception in thread "main" java.lang.NegativeArraySizeException at java.awt.image.DataBufferByte.(Unknown Source) at java.awt.image.Raster.createInterleavedRaster(Unknown Source) at java.awt.image.BufferedImage.(Unknown Source)

Whenever I get this I want to adjust my image to the highest possible size while maintaining the ratio.

I ended up with the following formulas:

    if ( targetWidth * targetHeight >= Integer.MAX_VALUE || targetWidth * targetHeight < 0 ) {
        System.out.println( "Target image too big... Size will be adjusted!" );
        if ( targetWidth > targetHeight ) {
            targetWidth = (int)Math.sqrt( ( Integer.MAX_VALUE ) * (float)( targetWidth / targetHeight ) );
            targetHeight = ( Integer.MAX_VALUE ) / targetWidth;
        } else {
            targetHeight = (int)Math.sqrt( ( Integer.MAX_VALUE ) * (float)( targetHeight / targetWidth ) );
            targetWidth = ( Integer.MAX_VALUE ) / targetHeight;
        }
    }

I still get the same problem, and my conditions are satisfied. I guess that

WIDTH * HEIGHT < Integer.MAX_VALUE

Is clearly not the condition I am looking for Any help?

Edit: After some discussion I think the real question to this problem is: What is the biggest possible size that I can pass to the BufferedImage constructor in order to not get a NegativeArraySizeException at:

at java.awt.image.DataBufferByte.(Unknown Source)

Check this for array size: http://stackoverflow.com/questions/31382531/why-i-cant-create-an-array-with-large-size — Berin Loritsch, Jun 08 '16 at 16:23
Are width and height integers? If width * height is indeed greater than Integer.MAX_VALUE, it means you cannot hold the product in an int. Trying will truncate it, so the result in Java will always be <= Integer.MAX_VALUE no matter the true value. One way is to convert width and height to a data type that can always hold the product, for instance, long, before multiplying. After that the comparison to Integer.MAX_VALUE should work nicely. — Ole V.V., Jun 08 '16 at 16:43
in case it gets too big this condition will trigger : targetWidth * targetHeight < 0. So it should be fine in any point in the code after that. — Tiago Bértolo, Jun 08 '16 at 16:45
@Tiago, that is not for sure. If the true result is just a little bit greater than MAX_VALUE, it will appear negative in the int, but if it is much bigger, it can end up positive or negative. — Ole V.V., Jun 08 '16 at 16:49
BufferedImage finalImage = new BufferedImage( 32767, 32768 sourceImage.getType() ); gives me a java.lang.NegativeArraySizeException and 32767 * 32768 < Integer.MAX_VALUE — Tiago Bértolo, Jun 08 '16 at 16:55
Note that there's no single size limit for `BufferedImage`s, it all depends on the backing type of the `DataBuffer`, the number and size of the samples, and wether the `SampleModel` requires a (single) contiguous array, *and of course, that you have a a large enough heap to allocate such a monster array in the first place.* Most likely you can create a `BufferedImage` of `TYPE_INT_ARGB` that is 4 times as large as the largest `TYPE_4BYTE_ABGR`, given a large enough heap. With a custom "banded" `SampleModel` that uses 4 arrays, you could achieve the same size with a `byte` backed `DataBuffer`. — Harald K, Jun 08 '16 at 19:57

score 1 · Answer 1 · edited May 23 '17 at 12:00

BufferedImage limit is the same limit of having a byte[Integer.MAX_VALUE] due to limitations in the Raster class (ref). You also have the overhead of the header which is platform and implementation dependent. That's why I recommend a safety buffer of the length of a long.

(Integer.MAX_VALUE - 8) / 4 should be a good safe limit.

NOTE: You MUST account for the size of each pixel (ref). For example, BufferedImage.TYPE_4BYTE_ABGR is 4 bytes per pixel. That means your area limit is Integer.MAX_VALUE / 4 in that case. Of course, the number of bytes consumed by each pixel will vary for the type you use. Adjust your test max area by the number of bytes to represent each pixel. You'll have to look at the API to figure that out: https://docs.oracle.com/javase/7/docs/api/java/awt/image/BufferedImage.html.

In order to resize an image while retaining the aspect ratio the math is pretty simple:

double aspectRatio = width / height;

if (aspectRatio < 1) {
    // taller than wide
    targetHeight = maxDimension;
    targetWidth = (int)(targetHeight * aspectRatio);
} else {
    // wider than tall
    targetWidth = maxDimension;
    targetHeight = (int)(targetWidth / aspectRatio);
}

That leaves is the question of calculating maxDimension based off of the total area of the image. For the sake of argument, let's say our maximum area is Integer.MAX_VALUE - 8 (relatively safe). We can extrapolate this using algebra. We know width * height = area, and with the formula above, we have two ways we need to solve for our max area.

For aspectRatio < 1 we substitute width with the formula to get it:

height * height * aspectRatio = area

Solving for height:

height^2 * aspectRatio = area
height^2 = area / aspectRatio
height = Math.sqrt(area / aspectRatio

For asptectRatio >= 1 we substitute height with the formulat to get it:

width * width / aspectRatio = area

Solving for width:

width^2 / aspectRatio = area
width^2 = area * aspectRatio
width = Math.sqrt(area * aspectRatio)

Now we can update the basic formula to account for a shape in the max area:

public static final long MAX_AREA = (Integer.MAX_VALUE - 8) / 4;

if (aspectRatio < 1) {
    targetHeight = Math.sqrt(MAX_AREA / aspectRatio);
    targetWidth = (int)(targetHeight * aspectRatio);
} else {
    // wider than tall
    targetWidth = Math.sqrt(MAX_AREA * aspectRatio);
    targetHeight = (int)(targetWidth / aspectRatio);
}

Of course, this leaves the basic question of testing if you are above your max area threshold. That needs to be done with something other than an int.

public static final long MAX_AREA = (Integer.MAX_VALUE - 8) / 4;
long area = (long)width * (long)height;

if(area < MAX_AREA) {
    // recalculate size
}

Otherwise you will get an overflow issue.

Added references for proper limits, and testing area robustly. — Berin Loritsch, Jun 08 '16 at 16:58
Added BufferedImage limit at the top, and the reasoning is based on it's dependencies. — Berin Loritsch, Jun 08 '16 at 17:08
Does not work. Integer.MAX_VALUE / 3 was not working either. — Tiago Bértolo, Jun 08 '16 at 17:16
OK. Dug more into it. The data is backed ultimately by a `byte[]`. You need to account for the number of bytes consumed by each pixel. In most cases that's 4, so your limit should be `Integer.MAX_VALUE / 4` — Berin Loritsch, Jun 08 '16 at 17:31
does not work either: BufferedImage finalImage = new BufferedImage(1, (Integer.MAX_VALUE-8)/4, sourceImage.getType()); gave me Exception in thread "main" java.lang.OutOfMemoryError: Java heap space — Tiago Bértolo, Jun 08 '16 at 17:58
Let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/114151/discussion-between-berin-loritsch-and-tiago-bertolo). — Berin Loritsch, Jun 08 '16 at 18:05

Resize to biggest possible image while mantaining the ratio

1 Answers1