Qt: PNG image transparency lost after opening - qt

Question

I'm trying to open a PNG image using QT but the alpha values for the pixels is always 255 even when the image is blank (i.e., the alpha value should be 0)
I tried converting the image to ARGB format after loading but that didn't help. Here is an example of a blank png I'm trying to load:
Image:
QImage im = QImage("JGbVc0r.png");
int p1 = 20;
int p2 = 20;
QImage img = im.convertToFormat(QImage::Format_ARGB32);
qInfo()<<qRed(img.pixel(p1,p2))<<qBlue(img.pixel(p1,p2))<<qGreen(img.pixel(p1,p2))<<qAlpha(img.pixel(p1,p2));
The expected output is
0 0 0 0
but I get
255 255 255 255
Any suggestions on how to get the desired output? Thanks in advance. I'm using Qt 5.11.

Answer 1

I tried to reproduce the issue of OP.
Unfortunately, imgur.com is blocked in my company (where I stumbled first into this question). Hence, I started with a small sample image I prepared on my own in GIMP.
← It's really small: 8x8 pixel with RGBA channels.
Next, I made a small sample application to inspect the outcome in a QImage – testQImageRGBA.cc:
#include <iomanip>
#include <iostream>
#include <QtWidgets>
void dump(
const QImage &qImg, int row, int col,
std::function<void(const QImage&, int, int)> dumpPixel)
{
qDebug() << qImg;
const int nR = qImg.height(), nC = qImg.width();
const int iR0 = row >= 0 ? row : 0;
const int iRN = row >= 0 ? row + 1 : nR;
const int iC0 = col >= 0 ? col : 0;
const int iCN = col >= 0 ? col + 1 : nC;
std::cout << "Dump of rows [" << iR0 << ", " << iRN << "),"
<< " cols [" << iC0 << ", " << iCN << ")\n"
<< "Pixel format: '#RRGGBBAA'\n";
for (int iR = iR0; iR < iRN; ++iR) {
for (int iC = iC0; iC < iCN; ++iC) {
dumpPixel(qImg, iR, iC);
}
std::cout << '\n';
}
}
int main(int argc, char **argv)
{
std::function<void(const QImage&, int, int)> dumpPixelOP // OPs flavor
= [](const QImage &qImg, int iR, int iC) {
std::cout << std::hex << "_#"
<< std::setw(2) << std::setfill('0') << qRed(qImg.pixel(iC, iR))
<< std::setw(2) << std::setfill('0') << qGreen(qImg.pixel(iC, iR))
<< std::setw(2) << std::setfill('0') << qBlue(qImg.pixel(iC, iR))
<< std::setw(2) << std::setfill('0') << qAlpha(qImg.pixel(iC, iR));
};
std::function<void(const QImage&, int, int)> dumpPixel // my flavor
= [](const QImage &qImg, int iR, int iC) {
const QColor pixel = qImg.pixelColor(iC, iR);
std::cout << std::hex << " #"
<< std::setw(2) << std::setfill('0') << pixel.red()
<< std::setw(2) << std::setfill('0') << pixel.green()
<< std::setw(2) << std::setfill('0') << pixel.blue()
<< std::setw(2) << std::setfill('0') << pixel.alpha();
};
qDebug() << "Qt Version:" << QT_VERSION_STR;
QApplication app(argc, argv);
const QStringList args = app.arguments();
const QString filePath = args.size() > 1 ? args[1] : "smiley.8x8.rgba.png";
const int row = args.size() > 2 ? args[2].toInt() : -1;
const int col = args.size() > 3 ? args[3].toInt() : -1;
const bool useDumpOP = args.size() > 4;
QImage qImg(filePath);
qImg = qImg.convertToFormat(QImage::Format_ARGB32);
dump(qImg, row, col, useDumpOP ? dumpPixelOP : dumpPixel);
return 0;
}
and a Qt project file – testQImageRGBA.pro:
SOURCES = testQImageRGBA.cc
QT += widgets
Compiled and tested in cygwin64:
$ qmake-qt5 testQImageRGBA.pro
$ make && ./testQImageRGBA
g++ -c -fno-keep-inline-dllexport -D_GNU_SOURCE -pipe -O2 -Wall -W -D_REENTRANT -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -I. -isystem /usr/include/qt5 -isystem /usr/include/qt5/QtWidgets -isystem /usr/include/qt5/QtGui -isystem /usr/include/qt5/QtCore -I. -I/usr/lib/qt5/mkspecs/cygwin-g++ -o testQImageRGBA.o testQImageRGBA.cc
g++ -o testQImageRGBA.exe testQImageRGBA.o -lQt5Widgets -lQt5Gui -lQt5Core -lGL -lpthread
Qt Version: 5.9.4
QImage(QSize(8, 8),format=5,depth=32,devicePixelRatio=1,bytesPerLine=32,byteCount=256)
Dump of rows [0, 8), cols [0, 8)
Pixel format: '#RRGGBBAA'
#00000000 #00000000 #000000ff #000000ff #000000ff #000000ff #00000000 #00000000
#00000000 #000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff #00000000
#000000ff #ffff00ff #0000ffff #ffff00ff #ffff00ff #0000ffff #ffff00ff #000000ff
#000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff
#000000ff #ffff00ff #ff0000ff #ffff00ff #ffff00ff #ff0000ff #ffff00ff #000000ff
#000000ff #ffff00ff #ffff00ff #ff0000ff #ff0000ff #ffff00ff #ffff00ff #000000ff
#00000000 #000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff #00000000
#00000000 #00000000 #000000ff #000000ff #000000ff #000000ff #00000000 #00000000
The dump reflects exactly what I have drawn in GIMP. Please, note the pixels of corners which are black transparent.
I prepared a CMake source file CMakeLists.txt:
project(QImageRGBA)
cmake_minimum_required(VERSION 3.10.0)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
find_package(Qt5Widgets CONFIG REQUIRED)
include_directories("${CMAKE_SOURCE_DIR}")
add_executable(testQImageRGBA testQImageRGBA.cc)
target_link_libraries(testQImageRGBA Qt5::Widgets)
and compiled the same source in VS2017. Tested in cmd.exe on Windows 10:
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>set PATH=%PATH%;D:\Scheff\Qt\5.11.2\msvc2017_64\bin;$(LocalDebuggerEnvironment)
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>build-VS2017\Debug\testQImageRGBA.exe
Qt Version: 5.11.2
QImage(QSize(8, 8),format=5,depth=32,devicePixelRatio=1,bytesPerLine=32,sizeInBytes=256)
Dump of rows [0, 8), cols [0, 8)
Pixel format: '#RRGGBBAA'
#00000000 #00000000 #000000ff #000000ff #000000ff #000000ff #00000000 #00000000
#00000000 #000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff #00000000
#000000ff #ffff00ff #0000ffff #ffff00ff #ffff00ff #0000ffff #ffff00ff #000000ff
#000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff
#000000ff #ffff00ff #ff0000ff #ffff00ff #ffff00ff #ff0000ff #ffff00ff #000000ff
#000000ff #ffff00ff #ffff00ff #ff0000ff #ff0000ff #ffff00ff #ffff00ff #000000ff
#00000000 #000000ff #ffff00ff #ffff00ff #ffff00ff #ffff00ff #000000ff #00000000
#00000000 #00000000 #000000ff #000000ff #000000ff #000000ff #00000000 #00000000
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>
There is effectively no difference.
Once at home (with access to imgur.com), I downloaded the image of OP JGbVc0r.png and tried again.
First in cygwin64:
$ make && ./testQImageRGBA JGbVc0r.png 20 20
make: Nothing to be done for 'first'.
Qt Version: 5.9.4
QImage(QSize(1000, 1000),format=5,depth=32,devicePixelRatio=1,bytesPerLine=4000,byteCount=4000000)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
#00000000
then in VS2017 and cmd.exe:
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>build-VS2017\Debug\testQImageRGBA.exe JGbVc0r.png 20 20
Qt Version: 5.11.2
QImage(QSize(1000, 1000),format=5,depth=32,devicePixelRatio=1,bytesPerLine=4000,sizeInBytes=4000000)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
#00000000
OP stated:
The expected output is 0 0 0 0
and that's exactly what I got.
replete provided an interesting hint about a trap concerning QColor::QColor(QRgb) which is subject of Q/A
SO: QImage setting alpha in PNG with transparency.
However, I came to the conclusion that this shouldn't be the issue here because in OPs code
qInfo()<<qRed(img.pixel(p1,p2))<<qBlue(img.pixel(p1,p2))<<qGreen(img.pixel(p1,p2))<<qAlpha(img.pixel(p1,p2));
QImage::pixel() is used which returns QRgb
qRed(), qGreen(), qBlue(), and qAlpha() take a QRgb and return an int.
Hence, the underhanding QColor::QColor(QRgb) is simply not involved. To eliminate my last doubts, I simply tried this as well in cygwin:
$ make && ./testQImageRGBA JGbVc0r.png 20 20 dumpLikeOP
make: Nothing to be done for 'first'.
Qt Version: 5.9.4
QImage(QSize(1000, 1000),format=5,depth=32,devicePixelRatio=1,bytesPerLine=4000,byteCount=4000000)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
_#00000000
and in VS2017 and cmd.exe:
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>build-VS2017\Debug\testQImageRGBA.exe JGbVc0r.png 20 20 dumpLikeOP
Qt Version: 5.11.2
QImage(QSize(1000, 1000),format=5,depth=32,devicePixelRatio=1,bytesPerLine=4000,sizeInBytes=4000000)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
_#00000000
So, I simply cannot reproduce the issue of OP although I tried hard.
The OP might take my code to test as well. Either OP overlooked something else which was not exposed in question or there is a specific issue on OP's system.
My last (desperate) idea was to check what happens if QImage was simply not loaded (e.g. due to file not found).
In cygwin:
$ make && ./testQImageRGBA ImageNotFound.png 20 20
make: Nothing to be done for 'first'.
Qt Version: 5.9.4
QImage(null)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
QImage::pixelColor: coordinate (20,20) out of range
#000000ff
$ make && ./testQImageRGBA ImageNotFound.png 20 20 dumpLikeOP
make: Nothing to be done for 'first'.
Qt Version: 5.9.4
QImage(null)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
QImage::pixel: coordinate (20,20) out of range
QImage::pixel: coordinate (20,20) out of range
QImage::pixel: coordinate (20,20) out of range
QImage::pixel: coordinate (20,20) out of range
_#00303900
Please note, that the out of range accesses are notified on console. Beside of this, the code seems to run properly but returns any arbitrary values.
In VS2017 / cmd.exe:
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>build-VS2017\Debug\testQImageRGBA.exe ImageNotFound.png 20 20
Qt Version: 5.11.2
QImage(null)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
QImage::pixelColor: coordinate (20,20) out of range
#000000ff
C:\Users\Scheff\tests\misc\Qt\QImageRGBA>build-VS2017\Debug\testQImageRGBA.exe ImageNotFound.png 20 20 dumpLikeOP
Qt Version: 5.11.2
QImage(null)
Dump of rows [20, 21), cols [20, 21)
Pixel format: '#RRGGBBAA'
_#QImage::pixel: coordinate (20,20) out of range
00QImage::pixel: coordinate (20,20) out of range
30QImage::pixel: coordinate (20,20) out of range
39QImage::pixel: coordinate (20,20) out of range
00
The order of output changed a bit. Beside of this, I even got the same "arbitrary" values (which IMHO means nothing).