Java:getHeight() on BufferedImage is returning image width and getWidth() is returning image height

Question

I am compressing an image doing Jpeg compression in Java and then resizing them before storing. I am keeping the storage height as 480 and calculating the height based on aspect ratio, so to keep the original height:width ratio same.

This is the code I am using

String inputImagePath = "1.JPG";
String outputImagePath = "Test Compression\\" + "1.JPG";

File imageFile = new File(inputImagePath);
File compressedImageFile = new File(outputImagePath);

int height = 640;

System.out.print("Conversion Start!\n");

if (imageFile != null)
{

    InputStream is = new FileInputStream(imageFile);
    OutputStream os = new FileOutputStream(compressedImageFile);

    float quality = 0.2 f;

    BufferedImage image = ImageIO.read(is);

    double aspectRatio = (double) image.getWidth() / image.getHeight();

    width = (int)(height * aspectRatio);
    System.out.println("Original height = " + image.getHeight() + " Original  width = " + image.getWidth());
    System.out.println(" aspect ratio = " + aspectRatio);
    System.out.println("height = " + height + " width = " + width + " aspect ratio = " + aspectRatio);

    BufferedImage resizedImage = new BufferedImage(width, height, image.getType());
    Graphics2D g = resizedImage.createGraphics();
    g.drawImage(image, 0, 0, width, height, null);
    g.dispose();

    Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");

    if (!writers.hasNext())
        throw new IllegalStateException("No writers found");

    ImageWriter writer = (ImageWriter) writers.next();
    ImageOutputStream ios = ImageIO.createImageOutputStream(os);
    writer.setOutput(ios);

    ImageWriteParam param = writer.getDefaultWriteParam();
    param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    param.setCompressionQuality(quality);

    writer.write(null, new IIOImage(resizedImage, null, null), param);
}

System.out.print("Conversion compete!");

Here is the image metadata

Here is the printed content:

Original height = 1920 Original  width = 2560
aspect ratio = 1.3333333333333333

height = 480 width = 640
aspect ratio = 1.3333333333333333

I applied the code to other images which actually had width > height and I had no rotation issues. This rotaion issue is only occuring for the images with height > width As far as I know there is nothing wrong in my code, I must be missing something related to getHeight() and getWidth() functions. Please help me out

Could you update your code sample with your height variable as well? It seems to be missing. — Flipbed, Nov 29 '16 at 15:18
I update the code with `height` variable. I got desired results using [metadata extractor](https://github.com/drewnoakes/metadata-extractor) as suggested by Sergey Grinev by the way. I posted it below. — vamsidhar muthireddy, Nov 29 '16 at 18:38

score 3 · Accepted Answer · edited May 23 '17 at 12:24

3

There can be rotation metadata in the jpeg images which Java doesn't recognize by default.

It looks like: Orientation : rotate 90 in the jpeg properties.

You need a 3rd party library to handle it, see How to rotate JPEG images based on the orientation metadata?

edited May 23 '17 at 12:24

Community

1
1

answered Nov 29 '16 at 15:28

Sergey Grinev

34,078
10
128
141

score 1 · Answer 2 · answered Nov 29 '16 at 18:31

For future references, I got through the references given by Sergey Grinev and altered the code a little bit and got desired results. Here is the code

Metadata metadata = ImageMetadataReader.readMetadata(imageFile);
Directory directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
   
int orientation = 1;
try{
orientation = directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);
} catch (MetadataException me) {
System.out.println("Could not get orientation");
}

int orgWidth = image.getWidth();
int orgHeight = image.getHeight();
   
double orgAspectRatio = (double)orgWidth/orgHeight;
   
   
AffineTransform affineTransform = new AffineTransform();
AffineTransformOp affineTransformOp;
BufferedImage orientedImage = new BufferedImage(image.getHeight(), image.getWidth(), image.getType());
  
boolean rotation = false;
         
switch (orientation) {
  case 1:
        orientedImage = image;
        break;
  case 2: // Flip X
        affineTransform.scale(-1.0, 1.0);
        affineTransform.translate(-orgWidth, 0);
     affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);  
     orientedImage = affineTransformOp.filter(image, orientedImage);
     break;
   case 3: // PI rotation
          affineTransform.translate(orgWidth, orgHeight);
          affineTransform.rotate(Math.PI);
          affineTransformOp = new AffineTransformOp(affineTransform,AffineTransformOp.TYPE_BILINEAR);
         orientedImage = affineTransformOp.filter(image, orientedImage);
         break;
   case 4: // Flip Y
          affineTransform.scale(1.0, -1.0);
          affineTransform.translate(0, -orgHeight);
  affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
          orientedImage = affineTransformOp.filter(image, orientedImage);
          break;
   case 5: // - PI/2 and Flip X
         rotation = true;
            affineTransform.rotate(-Math.PI / 2);
            affineTransform.scale(-1.0, 1.0);
   affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
            orientedImage = affineTransformOp.filter(image, orientedImage);
            break;
   case 6: // -PI/2 and -width
         rotation = true;
            affineTransform.translate(orgHeight, 0);
            affineTransform.rotate(Math.PI/2);
   affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
            orientedImage = affineTransformOp.filter(image, orientedImage);
            break;
   case 7: // PI/2 and Flip
         rotation = true;
            affineTransform.scale(-1.0, 1.0);
            affineTransform.translate(-orgHeight, 0);
            affineTransform.translate(0, orgWidth);
            affineTransform.rotate(3 * Math.PI / 2);
   affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
            orientedImage = affineTransformOp.filter(image, orientedImage);
            break;
   case 8: // PI / 2
         rotation = true;
            affineTransform.translate(0, orgWidth);
            affineTransform.rotate(3 * Math.PI / 2);
   affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
            orientedImage = affineTransformOp.filter(image, orientedImage);
            break;
   default:
         orientedImage = image;
            break;
        }       
         
double aspectRatio;
         
if(rotation){
     aspectRatio = (double)orientedImage.getWidth()/orientedImage.getHeight();
       width = outWidth;
        height = (int)(width/aspectRatio);
        }
        else{
         aspectRatio = (double)orientedImage.getWidth()/orientedImage.getHeight();
          width = (int)(height*aspectRatio);
        }

Java:getHeight() on BufferedImage is returning image width and getWidth() is returning image height

2 Answers2