Pfthb

Comparing two identical images which are loaded in the format QImage::Format_Indexed8 have different pixel data only when running in Release mode.

The following code shows differences when running in Release, but not when running in Debug:

int main()

 QImage _img1("C:\tmp\diff\identicals\file1.png");
 QImage _img2("C:\tmp\diff\identicals\file2.png");

 std::cout << QString("Format 1: %1").arg(_img1.format()).toStdString().c_str() << std::endl;
 std::cout << QString("Format 2: %2").arg(_img2.format()).toStdString().c_str() << std::endl;

 const unsigned char * _bits1 = _img1.bits();
 const unsigned char * _bits2 = _img2.bits();

 std::cout << QString("Byte count 1: %1 

Output:

Format 1: 3
Format 2: 3
Byte count 1: 23424 | Byte count 2: 23424
--DIFFERENCE--
i --> 1535
Bit1: 0 | Bit2: 217

--DIFFERENCE--
i --> 1663
Bit1: 0 | Bit2: 35

--DIFFERENCE--
i --> 1791
Bit1: 0 | Bit2: 94

--DIFFERENCE--
i --> 1919
Bit1: 0 | Bit2: 166

--DIFFERENCE--
i --> 2047
Bit1: 0 | Bit2: 143

--DIFFERENCE--
i --> 2175
Bit1: 0 | Bit2: 104

--DIFFERENCE--
i --> 2303
Bit1: 0 | Bit2: 240

--DIFFERENCE--
i --> 2431
Bit1: 0 | Bit2: 190

--DIFFERENCE--
i --> 2559
Bit1: 0 | Bit2: 129

--DIFFERENCE--
i --> 2687
Bit1: 0 | Bit2: 11

--DIFFERENCE--
i --> 2815
Bit1: 0 | Bit2: 30

--DIFFERENCE--
i --> 2943
Bit1: 0 | Bit2: 163

--DIFFERENCE--
i --> 3071
Bit1: 0 | Bit2: 206

--DIFFERENCE--
i --> 3199
Bit1: 0 | Bit2: 232

--DIFFERENCE--
i --> 3327
Bit1: 0 | Bit2: 124

--DIFFERENCE--
i --> 3455
Bit1: 0 | Bit2: 225

--DIFFERENCE--
i --> 12287
Bit1: 0 | Bit2: 240

--DIFFERENCE--
i --> 12415
Bit1: 0 | Bit2: 224

--DIFFERENCE--
i --> 12543
Bit1: 0 | Bit2: 240

A few notes:

• This is no longer reproducible When changing the format of the images to, for example QImage::Format_ARGB32, using convertToFormat
  


• This is no longer reproducible when using pixelIndex to compare each pixel


• It is always the same indices that fail


• The indices that fail change when running on a different machine.

My current guess would be that Qt does some optimization when loading images in this format. I can't explain why this doesn't result in the same data for two identical images however.

If you care to reproduce the issue, here is my input image:

I think I can see what's going on here.

Your image is 8-bit grayscale with a width of 127 pixels. All those indices where the differences occur are multiples of 128 (minus 1, i.e the last column in a 128-byte row). Since you have obtained the raw image bits, it's most likely that row data in the image is aligned (commonly 2 or 4 bytes).

Qt is probably not writing anything into those padding bytes, since they're not considered part of the image. So you're really seeing undefined behavior, as your program cannot guarantee repeatable results (loading data from an uninitialized memory location).

To properly compare your image data, you will need to skip over any padding bytes. That means you'll need to know the padding amount. Given the richness of the Qt library, I'm sure that there will be some way to access or infer that information.

[Edit] I quickly looked up the reference for QImage, and indeed I can see that scanlines are 32-bit aligned. The simplest way to achieve to compare is to call QImage::bytesPerLine() to determine how many bytes to compare for each scanline, and then get each scanline individually via QImage::scanLine(int)

Your implementation of image comparison is incorrect. Why didn't you use QImage::operator==? You can also refer to its source code for an idea of how it should be done, but that's sort of pointless since Qt already provides this code for you - unless you real question was how to correctly iterate over all pixels in an image, because that's specifically where the mistake is. Your code has undefined behavior, since it can read locations that were likely never written to, per QImage and C++ semantics.