TIFF: Colors brightened when reading and then writing a 32-bpc integer linear grayscale image

[danielperano]

Describe the bug
When reading and then writing a 32-bit per channel grayscale TIFF image in linear colorspace, the written colors are brightened.

Version information

1. The version of the TwelveMonkeys ImageIO library in use.
   imageio-tiff:3.12.0

2. The exact output of java --version (or java -version for older Java releases).

openjdk 23 2024-09-17
OpenJDK Runtime Environment (build 23+37-2369)
OpenJDK 64-Bit Server VM (build 23+37-2369, mixed mode, sharing)

3. Extra information about OS version, server version, standalone program or web application packaging, executable wrapper, etc. Please state exact version numbers where applicable.

This is on a Linux Mint 21.3 desktop, running directly from a jar.

To Reproduce
Steps to reproduce the behavior:

1. Compile the below sample code
2. Download the sample image file
3. Run the code with the sample file
4. See error

Expected behavior
The output image is a 32-bit per channel integer grayscale image in linear colorspace with the same shade of grey as the input.

Example code

System.out.println("Is headless? " + System.getProperty("java.awt.headless"));
var image = ImageIO.read(new File("./Untitled_32bit.tif"));

System.out.println("Width: " + image.getWidth());
System.out.println("Height: " + image.getHeight());
System.out.println("Color model: " + image.getColorModel().toString());
System.out.println("Color space is sRGB: " + image.getColorModel().getColorSpace().isCS_sRGB());
System.out.println("Channels: " + image.getColorModel().getColorSpace().getNumComponents());
System.out.println("Channel size: " + image.getColorModel().getComponentSize()[0]);
            
var writer = ImageIO.getImageWritersBySuffix("tif").next();

var params = writer.getDefaultWriteParam();
params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
params.setCompressionType("Deflate");

writer.setOutput(ImageIO.createImageOutputStream(new File("./out.tif")));
writer.write(image);

Sample file(s)
Attach any sample files needed to reproduce the problem. Use a ZIP-file if the format is not directly supported by GitHub.

Untitled_32bit.tif.zip

Stak trace
No stack trace.

Screenshots
PNG of input image (totally different encoding, just for visual demo):

PNG of output image:

[haraldk]

Sorry, must have missed this one... Will look into it!

[AlexanderSchuetz97]

I have the same problem with 8 bit grayscale tiff.

The problem is that java's ComponentColorModel unconditonally applies this lookup table to EVERY grayscale image.

    static byte[] getLinearRGB8TosRGB8LUT() {
        if (l8Tos8 == null) {
            l8Tos8 = new byte[256];
            float input, output;
            // algorithm for linear RGB to nonlinear sRGB conversion
            // is from the IEC 61966-2-1 International Standard,
            // Colour Management - Default RGB colour space - sRGB,
            // First Edition, 1999-10,
            // available for order at http://www.iec.ch
            for (int i = 0; i <= 255; i++) {
                input = ((float) i) / 255.0f;
                if (input <= 0.0031308f) {
                    output = input * 12.92f;
                } else {
                    output = 1.055f * ((float) Math.pow(input, (1.0 / 2.4)))
                             - 0.055f;
                }
                l8Tos8[i] = (byte) Math.round(output * 255.0f);
            }
        }
        return l8Tos8;
    }

In my case the first pixel has a value of 49 which gimp reads and displays correctly. after bufferedImage.getRGB performs lookup with the value 49 in the table returned by this function it will output the wrong value of 121.

My workaround for this problem is the following:

if (bufferedImage.getColorModel().getColorSpace().getType() == ColorSpace.TYPE_GRAY) {
    //JAVA IS BUGGY WITH GRAY SCALE TIFFS IT APPLIES A LOOKUP TABLE FOR SOME REASON
    BufferedImage grayImage = new BufferedImage(bufferedImage.getWidth(), bufferedImage.getHeight(), BufferedImage.TYPE_4BYTE_ABGR);
    var graphics = grayImage.getGraphics();
    try {
        graphics.drawImage(bufferedImage, 0, 0, null);
    } finally {
        graphics.dispose();
    }

    return grayImage;
}

return bufferedImage;

Java's internal drawImage method bypasses the getRGB method and operates directly on the data buffers. This means it bypasses this dodgy lookup table. This workaround will not work for grayscale images with more than 8 bit per pixel. You would have to use some other BufferedImageType or possible do the conversion manually by going to the data buffers yourself.

What a pain.