summaryrefslogtreecommitdiffstats
path: root/tests/auto/gui/image/qimage/tst_qimage.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/gui/image/qimage/tst_qimage.cpp')
-rw-r--r--tests/auto/gui/image/qimage/tst_qimage.cpp193
1 files changed, 193 insertions, 0 deletions
diff --git a/tests/auto/gui/image/qimage/tst_qimage.cpp b/tests/auto/gui/image/qimage/tst_qimage.cpp
index 1d0cdfcc4e..8086ffcc28 100644
--- a/tests/auto/gui/image/qimage/tst_qimage.cpp
+++ b/tests/auto/gui/image/qimage/tst_qimage.cpp
@@ -15,6 +15,7 @@
#include <stdio.h>
#include <qpainter.h>
+#include <private/qcmyk_p.h>
#include <private/qimage_p.h>
#include <private/qdrawhelper_p.h>
@@ -110,6 +111,8 @@ private slots:
void smoothScaleFormats();
void smoothScaleNoConversion_data();
void smoothScaleNoConversion();
+ void smoothScale_CMYK_data();
+ void smoothScale_CMYK();
void transformed_data();
void transformed();
@@ -173,6 +176,10 @@ private slots:
void colorSpaceRgbConversion();
void colorSpaceCmykConversion_data();
void colorSpaceCmykConversion();
+ void colorSpaceFromGrayConversion_data();
+ void colorSpaceFromGrayConversion();
+ void colorSpaceToGrayConversion_data();
+ void colorSpaceToGrayConversion();
void deepCopyWhenPaintingActive();
void scaled_QTBUG19157();
@@ -2091,6 +2098,76 @@ void tst_QImage::smoothScaleNoConversion()
QVERIFY(img.hasAlphaChannel());
}
+void tst_QImage::smoothScale_CMYK_data()
+{
+ QTest::addColumn<int>("size");
+
+ const int sizes[] = { 2, 3, 4, 6, 7, 8, 10, 16, 20, 32, 40, 64, 100, 101, 128 };
+ for (int size : sizes)
+ QTest::addRow("%d x %d", size, size) << size;
+}
+
+void tst_QImage::smoothScale_CMYK()
+{
+ QFETCH(int, size);
+ QImage img(size, size, QImage::Format_CMYK8888);
+ QCmyk32 expected(31, 63, 127, 127);
+ img.fill(expected.toUint());
+
+ auto getCmykPixel = [](const QImage &image, int x, int y) {
+ Q_ASSERT(image.format() == QImage::Format_CMYK8888);
+ const uint *line = reinterpret_cast<const uint *>(image.scanLine(y));
+ const uint pixel = line[x];
+ return QCmyk32::fromCmyk32(pixel);
+ };
+
+ // scale x down, y down
+ QImage scaled = img.scaled(QSize(1, 1), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ QCmyk32 pixel = getCmykPixel(scaled, 0, 0);
+ QCOMPARE(pixel, expected);
+
+ // scale x down, y up
+ scaled = img.scaled(QSize(1, size * 2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ for (int y = 0; y < scaled.height(); ++y) {
+ pixel = getCmykPixel(scaled, 0, y);
+ QCOMPARE(pixel, expected);
+ }
+
+ // scale x up, y down
+ scaled = img.scaled(QSize(size * 2, 1), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ for (int x = 0; x < scaled.width(); ++x) {
+ pixel = getCmykPixel(scaled, x, 0);
+ QCOMPARE(pixel, expected);
+ }
+
+ // scale x up
+ scaled = img.scaled(QSize(size, size * 2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ for (int y = 0; y < scaled.height(); ++y) {
+ for (int x = 0; x < scaled.width(); ++x) {
+ pixel = getCmykPixel(scaled, x, y);
+ QCOMPARE(pixel, expected);
+ }
+ }
+
+ // scale y up
+ scaled = img.scaled(QSize(size * 2, size), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ for (int y = 0; y < scaled.height(); ++y) {
+ for (int x = 0; x < scaled.width(); ++x) {
+ pixel = getCmykPixel(scaled, x, y);
+ QCOMPARE(pixel, expected);
+ }
+ }
+
+ // scale x up, y up
+ scaled = img.scaled(QSize(size * 2, size * 2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+ for (int y = 0; y < scaled.height(); ++y) {
+ for (int x = 0; x < scaled.width(); ++x) {
+ pixel = getCmykPixel(scaled, x, y);
+ QCOMPARE(pixel, expected);
+ }
+ }
+}
+
static int count(const QImage &img, int x, int y, int dx, int dy, QRgb pixel)
{
int i = 0;
@@ -3387,6 +3464,120 @@ void tst_QImage::colorSpaceCmykConversion()
}
}
+void tst_QImage::colorSpaceFromGrayConversion_data()
+{
+ QTest::addColumn<QImage::Format>("fromFormat");
+ QTest::addColumn<QColorSpace>("fromCS");
+ QTest::addColumn<QColorSpace>("toCS");
+
+ QImage::Format formats[] = {
+ QImage::Format_Grayscale8,
+ QImage::Format_Grayscale16,
+ };
+
+ QList<QColorSpace> colorSpaces = {
+ QColorSpace::SRgbLinear,
+ QColorSpace::DisplayP3,
+ QColorSpace(QPointF(0.31271, 0.32902), QColorSpace::TransferFunction::SRgb),
+ QColorSpace(QPointF(0.30, 0.33), QColorSpace::TransferFunction::Linear)
+ };
+ std::string names[] = {
+ "sRgbLinear",
+ "displayP3",
+ "graySRgb",
+ "grayOther",
+ "videoHD(A2B)"
+ };
+
+ QFile iccProfile(m_prefix + "VideoHD.icc");
+ iccProfile.open(QIODevice::ReadOnly);
+ colorSpaces.append(QColorSpace::fromIccProfile(iccProfile.readAll()));
+
+ for (auto fromFormat : formats) {
+ for (int from = 0; from < 5; ++from) {
+ for (int to = 0; to < 4; ++to) {
+ QTest::addRow("%s: %s -> %s", formatToString(fromFormat).data(), names[from].c_str(), names[to].c_str())
+ << fromFormat << colorSpaces[from] << colorSpaces[to];
+ }
+ }
+ }
+}
+
+void tst_QImage::colorSpaceFromGrayConversion()
+{
+ QFETCH(QImage::Format, fromFormat);
+ QFETCH(QColorSpace, fromCS);
+ QFETCH(QColorSpace, toCS);
+
+ QImage image(16, 16, fromFormat);
+ image.setColorSpace(fromCS);
+ QVERIFY(image.colorSpace().isValid());
+
+ for (int i = 0; i < image.height(); ++i) {
+ for (int j = 0; j < image.width(); ++j) {
+ image.setPixel(j, i, qRgb((i + j) * 8, (i + j) * 8, (i + j) * 8));
+ }
+ }
+ QImage imageConverted = image.convertedToColorSpace(toCS);
+ QCOMPARE(imageConverted.format(), fromFormat);
+ QCOMPARE(imageConverted.size(), image.size());
+ int gray = 0;
+ for (int x = 0; x < image.width(); ++x) {
+ int newGray = qGray(imageConverted.pixel(x, 3));
+ QCOMPARE_GE(newGray, gray);
+ gray = newGray;
+ }
+}
+
+void tst_QImage::colorSpaceToGrayConversion_data()
+{
+ QTest::addColumn<QImage::Format>("fromFormat");
+
+ QImage::Format formats[] = {
+ QImage::Format_RGB32,
+ QImage::Format_ARGB32,
+ QImage::Format_ARGB32_Premultiplied,
+ QImage::Format_RGBX64,
+ QImage::Format_RGBA64,
+ QImage::Format_RGBA64_Premultiplied,
+ QImage::Format_RGBX32FPx4,
+ QImage::Format_RGBA32FPx4,
+ QImage::Format_RGBA32FPx4_Premultiplied,
+ QImage::Format_Grayscale8,
+ QImage::Format_Grayscale16,
+ };
+
+ for (auto fromFormat : formats)
+ QTest::addRow("%s -> Gray", formatToString(fromFormat).data()) << fromFormat;
+}
+
+void tst_QImage::colorSpaceToGrayConversion()
+{
+ QFETCH(QImage::Format, fromFormat);
+
+ QImage image(16, 16, fromFormat);
+ image.setColorSpace(QColorSpace::DisplayP3);
+ QVERIFY(image.colorSpace().isValid());
+
+ for (int i = 0; i < image.height(); ++i) {
+ for (int j = 0; j < image.width(); ++j) {
+ image.setPixel(j, i, qRgb((i + j) * 8, (i + j) * 8, (i + j) * 8));
+ }
+ }
+
+ QColorSpace grayColorSpace(QPointF(0.31271, 0.32902), QColorSpace::TransferFunction::SRgb);
+
+ QImage imageConverted = image.convertedToColorSpace(grayColorSpace);
+ QVERIFY(imageConverted.format() == QImage::Format_Grayscale8 || imageConverted.format() == QImage::Format_Grayscale16);
+ QCOMPARE(imageConverted.size(), image.size());
+ int gray = 0;
+ for (int x = 0; x < image.width(); ++x) {
+ int newGray = qGray(imageConverted.pixel(x, 11));
+ QCOMPARE_GE(newGray, gray);
+ gray = newGray;
+ }
+}
+
void tst_QImage::deepCopyWhenPaintingActive()
{
QImage image(64, 64, QImage::Format_ARGB32_Premultiplied);
@@ -3863,10 +4054,12 @@ void tst_QImage::metadataPassthrough()
QCOMPARE(alphaMask.dotsPerMeterY(), a.dotsPerMeterY());
QCOMPARE(alphaMask.devicePixelRatio(), a.devicePixelRatio());
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
QImage heuristicMask = a.createHeuristicMask();
QCOMPARE(heuristicMask.dotsPerMeterX(), a.dotsPerMeterX());
QCOMPARE(heuristicMask.dotsPerMeterY(), a.dotsPerMeterY());
QCOMPARE(heuristicMask.devicePixelRatio(), a.devicePixelRatio());
+#endif
QImage maskFromColor = a.createMaskFromColor(qRgb(0, 0, 0));
QCOMPARE(maskFromColor.dotsPerMeterX(), a.dotsPerMeterX());
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-08 15:01:02 +0000