Rotating Image with AffineTransform Produces Visually Correct Pixels, but getRGB Doesn't Match

I'm attempting to rotate an image 180 using AffineTransform. My "out.jpg" visually appears rotated, however when I attempt to programatically verify that the output image has been rotated , the code disagrees. Here's my code:

public static void main(String[] args) throws Exception {
    BufferedImage origImage = ImageIO.read(new File("input.jpg"));
    
    AffineTransform af = new AffineTransform();
    int centerX = origImage.getWidth() / 2;
    int centerY = origImage.getHeight() / 2;
    // Rotate 180 degrees
    af.quadrantRotate(2, centerX, centerY);

    AffineTransformOp affineTransformOp = new AffineTransformOp(af, null);
    BufferedImage destImage =
        new BufferedImage(origImage.getWidth(), origImage.getHeight(), origImage.getType());
    affineTransformOp.filter(origImage, destImage);

    // Verify that destImage has indeed been rotated by point checking a random pixel.
    int origX = 90;
    int origY = 32;
    // Where we expect this pixel to have been translated to.
    int expX = destImage.getWidth()-origX;
    int expY = destImage.getHeight()-origY;

    // Always prints false. Why????
    System.out.println("Pixels are equal: " +
      origImage.getRGB(origX, origY) == destImage.getRGB(expX, expY));

    ImageIO.write(destImage, "jpg", new File("out.jpg"));

}

What am I doing wrong with either my rotation or the programatic check?

I've verified in the documentation:

• getRGB() returns an int, there's no need to use .equals()
• BufferedImage indexes from (0,0) in the upper left corner
• AffineTransform.quadrantRotate() with an anchor, translates back to (0,0) once it completes the rotation
• AffineTransform.quadrantRotate() goes clockwise (although this shouldn't matter for 180 rotation)

Thanks for your help!

I ran your code using a png image of mine. Here are my test results. Image type 6 is TYPE_4BYTE_ABGR from the BufferedImage source code.

Image size: 416 x 199
Image type: 6
Origin pixel: 90,32
Destination pixel: 326,167
Pixel values: ffeeeeee ffffffff
Pixels are equal: false

Here's the image.

Here's the rotated image.

I'm not sure why the colors are different. I can't visually distinguish the difference between an eeeeee pixel and an ffffff pixel.

Edited to add: I did a little more research and found this bit of documentation for the Image getRGB method.

> Returns an integer pixel in the default RGB color model(TYPE_INT_ARGB)
> and default sRGB colorspace. Color conversion takes place if this
> default model does not match the image ColorModel.

So, it appears that the getRGB method itself could be causing the color conversion.

Here's the code I ran.

import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
public class RotateImage {
public static void main(String[] args) throws Exception {
String input = "C:\\Users\\Owner\\OneDrive\\Pictures"
+ "\\Saved Pictures\\CustomJTextField.png";
BufferedImage origImage = ImageIO.read(new File(input));
AffineTransform af = new AffineTransform();
int centerX = origImage.getWidth() / 2;
int centerY = origImage.getHeight() / 2;
// Rotate 180 degrees
af.quadrantRotate(2, centerX, centerY);
AffineTransformOp affineTransformOp = new AffineTransformOp(
af, null);
System.out.println("Image size: " + origImage.getWidth() +
" x " + origImage.getHeight());
System.out.println("Image type: " + origImage.getType());
BufferedImage destImage = new BufferedImage(
origImage.getWidth(), origImage.getHeight(),
origImage.getType());
affineTransformOp.filter(origImage, destImage);
// Verify that destImage has indeed been rotated by point
// checking a random
// pixel.
int origX = 90;
int origY = 32;
// Where we expect this pixel to have been translated to.
int expX = destImage.getWidth() - origX;
int expY = destImage.getHeight() - origY;
System.out.println("Origin pixel: " + origX + "," + origY);
System.out.println("Destination pixel: " + expX + "," + expY);
int origPixel = origImage.getRGB(origX, origY);
int expPixel = destImage.getRGB(expX, expY);
System.out.println("Pixel values: " +
Integer.toHexString(origPixel) + " " +
Integer.toHexString(expPixel));
// Always prints false. Why????
System.out.println("Pixels are equal: " +
(origPixel == expPixel));
String output = "C:\\Eclipse\\Eclipse-2020-workspace"
+ "\\com.ggl.testing2\\resources\\output.png";
ImageIO.write(destImage, "png", new File(output));
}
}

Edited to add: I wrote my own transform to see whether or not it was the transform changing the color or the getRGB method changing the color.

Here are the test results from my own transform.

Image size: 416 x 199
Image type: 6
Origin pixel: 90,32
Destination pixel: 326,167
Pixel values: ffeeeeee ffeeeeee
Pixels are equal: true

I created an int array of pixels from the original image and wrote those pixels to the rotated image.

Here's the code.

import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
public class RotateImage {
public static void main(String[] args) throws Exception {
String input = "C:\\Users\\Owner\\OneDrive\\Pictures"
+ "\\Saved Pictures\\CustomJTextField.png";
BufferedImage origImage = ImageIO.read(new File(input));
System.out.println("Image size: " + origImage.getWidth() +
" x " + origImage.getHeight());
System.out.println("Image type: " + origImage.getType());
int[] pixels = getPixels(origImage);
BufferedImage destImage = new BufferedImage(
origImage.getWidth(), origImage.getHeight(),
origImage.getType());
destImage = putPixels(destImage, pixels);
// Verify that destImage has indeed been rotated by point
// checking a random
// pixel.
int origX = 90;
int origY = 32;
// Where we expect this pixel to have been translated to.
int expX = destImage.getWidth() - origX;
int expY = destImage.getHeight() - origY;
System.out.println("Origin pixel: " + origX + "," + origY);
System.out.println("Destination pixel: " + expX + "," + expY);
int origPixel = origImage.getRGB(origX, origY);
int expPixel = destImage.getRGB(expX, expY);
System.out.println("Pixel values: " +
Integer.toHexString(origPixel) + " " +
Integer.toHexString(expPixel));
System.out.println("Pixels are equal: " +
(origPixel == expPixel));
String output = "C:\\Eclipse\\Eclipse-2020-workspace"
+ "\\com.ggl.testing2\\resources\\output.png";
ImageIO.write(destImage, "png", new File(output));
}
private static int[] getPixels(BufferedImage image) {
int length = image.getWidth() * image.getHeight();
int[] pixels = new int[length];
int index = 0;
for (int h = 0; h < image.getHeight(); h++) {
for (int w = 0; w < image.getWidth(); w++) {
pixels[index++] = image.getRGB(w, h);
}
}
return pixels;
}
private static BufferedImage putPixels(BufferedImage image,
int[] pixels) {
int index = 0;
for (int i = pixels.length - 1; i >= 0; i--) {
int h = index / image.getWidth();
int w = index % image.getWidth();
image.setRGB(w, h, pixels[i]);
index++;
}
return image;
}
}

You are looking at the wrong pixel.

Assume your image is 1x1 pixel in size. You're originally looking at pixel (0, 0). Then with your code, in the destination image, you're looking at pixel (width - 0, height - 1), which turns out to be pixel (1, 1). When clearly you still need to be looking at (0, 0) as the image doesn't have a pixel at (1, 1).

In your case, your transformed coordinate isn't outside your image, but it points to the wrong pixel.

To fix your code, change the lines that calculate your expX and expY values, and subtract 1 from each:

int expX = destImage.getWidth() - origX - 1;
int expY = destImage.getHeight() - origY - 1;

That returns the correct pixel values when I run your code (on my own image, as you haven't provided the image that you used).

There is another issue in the code that will only surface with an odd-numbered width or height: you're using integer arithmetic to determine the center of rotation, which rounds down when it shouldn't. Change the lines that determine the center to (to use floating-point numbers, so that you can get a fractional number as a result) :

double centerX = origImage.getWidth() / 2.0;
double centerY = origImage.getHeight() / 2.0;