void KisPaintDeviceTest::testMakeClone()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
srcDev->convertFromQImage(image, 0);
srcDev->move(10,10);
const KoColorSpace * weirdCS = KoColorSpaceRegistry::instance()->lab16();
KisPaintDeviceSP dstDev = new KisPaintDevice(weirdCS);
dstDev->move(1000,1000);
QVERIFY(!dstDev->fastBitBltPossible(srcDev));
QRect cloneRect(100,100,200,200);
QPoint errpoint;
dstDev->makeCloneFrom(srcDev, cloneRect);
QVERIFY(*dstDev->colorSpace() == *srcDev->colorSpace());
QCOMPARE(dstDev->pixelSize(), srcDev->pixelSize());
QCOMPARE(dstDev->x(), srcDev->x());
QCOMPARE(dstDev->y(), srcDev->y());
QCOMPARE(dstDev->exactBounds(), cloneRect);
QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
if (!TestUtil::compareQImages(errpoint, dstImage, srcImage)) {
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
bool KisCrashFilterTest::applyFilter(const KoColorSpace * cs, KisFilterSP f)
{
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
// dev->fill(0, 0, 100, 100, dev->defaultPixel());
dev->convertFromQImage(qimage, 0, 0, 0);
// Get the predefined configuration from a file
KisFilterConfigurationSP kfc = f->defaultConfiguration(dev);
QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
dbgKrita << "creating new file for " << f->id();
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
out.setCodec("UTF-8");
out << kfc->toXML();
} else {
QString s;
QTextStream in(&file);
in.setCodec("UTF-8");
s = in.readAll();
kfc->fromXML(s);
}
dbgKrita << f->id() << ", " << cs->id() << ", " << cs->profile()->name();// << kfc->toXML() << "\n";
f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc);
return true;
}
void KisPaintDeviceTest::testBltPerformance()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP fdev = new KisPaintDevice(cs);
fdev->convertFromQImage(image, 0);
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
QTime t;
t.start();
int x;
for (x = 0; x < 1000; ++x) {
KisPainter gc(dev);
gc.bitBlt(QPoint(0, 0), fdev, image.rect());
}
qDebug() << x
<< "blits"
<< " done in "
<< t.elapsed()
<< "ms";
}
void KisFilterTest::testDifferentSrcAndDst()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QImage inverted(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
KisPaintDeviceSP src = new KisPaintDevice(cs);
KisPaintDeviceSP dst = new KisPaintDevice(cs);
KisSelectionSP sel = new KisSelection(new KisSelectionDefaultBounds(src));
sel->getOrCreatePixelSelection()->invert(); // select everything
sel->updateProjection();
src->convertFromQImage(qimage, 0, 0, 0);
KisFilterSP f = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
f->process(src, dst, sel, QRect(QPoint(0,0), qimage.size()), kfc);
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, inverted, dst->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
dst->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save("filtertest.png");
QFAIL(QString("Failed to create inverted image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisTransformWorkerTest::testIdentity()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 1.0, 1.0,
0.0, 0.0,
0.0, 0.0,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() ==image.width());
QVERIFY(rc.height() == image.height());
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("test_identity_source.png");
result.save("test_identity_result.png");
QFAIL(QString("Failed to apply identity transformation to image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
void KisFilterMaskTest::testProjectionSelected()
{
KisImageSP image;
KisPaintLayerSP layer;
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QImage inverted(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
KisFilterSP f = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
KisFilterMaskSP mask = new KisFilterMask();
mask->setFilter(kfc);
mask->createNodeProgressProxy();
KisPaintDeviceSP projection = new KisPaintDevice(cs);
initImage(image, layer, projection, mask);
projection->convertFromQImage(qimage, 0, 0, 0);
mask->initSelection(layer);
mask->select(qimage.rect(), MAX_SELECTED);
mask->apply(projection, qimage.rect(), qimage.rect(), KisNode::N_FILTHY);
QCOMPARE(mask->exactBounds(), QRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT));
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, inverted, projection->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
projection->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save("filtermasktest2.png");
QFAIL(QString("Failed to create inverted image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisFilterTest::testWithProgressUpdater()
{
TestUtil::TestProgressBar * bar = new TestUtil::TestProgressBar();
KoProgressUpdater* pu = new KoProgressUpdater(bar);
KoUpdaterPtr updater = pu->startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QImage inverted(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(qimage, 0, 0, 0);
KisFilterSP f = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc, updater);
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, inverted, dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save("filtertest.png");
QFAIL(QString("Failed to create inverted image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
delete pu;
delete bar;
}
void KisFillPainterTest::benchmarkFillingScanlineColor()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage srcImage(TestUtil::fetchDataFileLazy("heavy_labyrinth.png"));
QVERIFY(!srcImage.isNull());
QRect imageRect = srcImage.rect();
dev->convertFromQImage(srcImage, 0, 0, 0);
QBENCHMARK_ONCE {
KisScanlineFill gc(dev, QPoint(), imageRect);
gc.setThreshold(THRESHOLD);
gc.fillColor(KoColor(Qt::red, dev->colorSpace()));
}
QImage resultImage =
dev->convertToQImage(0,
imageRect.x(), imageRect.y(),
imageRect.width(), imageRect.height());
QVERIFY(TestUtil::checkQImage(resultImage,
"fill_painter",
"scanline_",
"heavy_labyrinth_top_left"));
}
bool applyFilter(const KoColorSpace * cs, KisFilterSP f)
{
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "lena.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
// dev->fill(0, 0, 100, 100, dev->defaultPixel());
dev->convertFromQImage(qimage, "", 0, 0);
// Get the predefined configuration from a file
KisFilterConfiguration * kfc = f->defaultConfiguration(dev);
QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "creating new file for " << f->id();
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
out << kfc->toXML();
} else {
QString s;
QTextStream in(&file);
s = in.readAll();
kfc->fromXML(s);
}
qDebug() << f->id() << ", " << cs->id() << ", " << cs->profile()->name();// << kfc->toXML() << "\n";
KisConstProcessingInformation src(dev, QPoint(0, 0), 0);
KisProcessingInformation dst(dev, QPoint(0, 0), 0);
f->process(src, dst, qimage.size(), kfc);
return true;
}
void KisConvolutionPainterTest::testIdentityConvolution()
{
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
KisPaintDeviceSP dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
dev->convertFromQImage(qimage, 0, 0, 0);
KisConvolutionKernelSP kernel = new KisConvolutionKernel(3, 3, 0, 0);
kernel->data()(0) = 0;
kernel->data()(1) = 0;
kernel->data()(2) = 0;
kernel->data()(3) = 0;
kernel->data()(4) = 1;
kernel->data()(5) = 0;
kernel->data()(6) = 0;
kernel->data()(7) = 0;
kernel->data()(8) = 0;
KisConvolutionPainter gc(dev);
gc.beginTransaction();
gc.applyMatrix(kernel, dev, QPoint(0, 0), QPoint(0, 0), QSize(qimage.width(), qimage.height()));
gc.deleteTransaction();
QImage resultImage = dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height());
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, qimage, resultImage)) {
resultImage.save("identity_convolution.png");
QFAIL(QString("Identity kernel did change image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisConvolutionPainterTest::testGaussianDetails(bool useFftw)
{
QImage referenceImage(TestUtil::fetchDataFileLazy("resolution_test.png"));
KisPaintDeviceSP dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
dev->convertFromQImage(referenceImage, 0, 0, 0);
testGaussianBase(dev, useFftw, "details");
}
void KisTransformWorkerTest::testXScaleDown()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 0.123, 1.0,
0.0, 0.0,
0.0, 0.0,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() == qRound(image.width() * 0.123));
QVERIFY(rc.height() == image.height() - 1); // the height is reduced by 1 because in the source image
// at the bottom line most pixels (except 1 or 2) are
// entirely transparent.
// when scaling down the image by ~ 1/10, the few non-tranparent
// pixels disappear when "mixed" with the transparent ones
// around
// KisTransaction t2("test", dev);
// KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
// for(int x = rc.x(); x < rc.width(); ++x) {
// for(int y = rc.y(); y < rc.height(); ++y) {
// ac->moveTo(x, y);
// cs->setOpacity(ac->rawData(), 0.5, 1);
// }
// }
// t2.end();
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaledownx_result.png");
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("scaledownx_source.png");
result.save("scaledownx_result.png");
QFAIL(QString("Failed to scale down the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
void KisPaintDeviceTest::testRoundtripConversion()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, 0);
QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("kis_paint_device_test_test_roundtrip_qimage.png");
result.save("kis_paint_device_test_test_roundtrip_result.png");
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisPaintDeviceTest::testColorSpaceConversion()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
const KoColorSpace* srcCs = KoColorSpaceRegistry::instance()->rgb8();
const KoColorSpace* dstCs = KoColorSpaceRegistry::instance()->lab16();
KisPaintDeviceSP dev = new KisPaintDevice(srcCs);
dev->convertFromQImage(image, 0);
dev->move(10, 10); // Unalign with tile boundaries
KUndo2Command* cmd = dev->convertTo(dstCs);
QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
QCOMPARE(dev->pixelSize(), dstCs->pixelSize());
QVERIFY(*dev->colorSpace() == *dstCs);
delete cmd;
}
void KisTransformWorkerTest::testYShear()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 1.0, 1.0,
0.0, 1.0,
300., 200.,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() == image.width());
QVERIFY(rc.height() == 959);
// KisTransaction t2("test", dev);
// KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
// for(int x = rc.x(); x < rc.width(); ++x) {
// for(int y = rc.y(); y < rc.height(); ++y) {
// ac->moveTo(x, y);
// cs->setOpacity(ac->rawData(), 0.5, 1);
// }
// }
// t2.end();
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
image.load(QString(FILES_DATA_DIR) + QDir::separator() + "sheary_result.png");
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("sheary_source.png");
result.save("sheary_result.png");
QFAIL(QString("Failed to shear the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
void KisPaintDeviceTest::testThumbnailDeviceWithOffset()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, 0);
dev->setX(10);
dev->setY(10);
QImage thumb = dev->createThumbnail(640,441,QRect(10,10,640,441));
image.save("oring.png");
thumb.save("thumb.png");
QPoint pt;
QVERIFY(TestUtil::compareQImages(pt, thumb, image));
}
void KisScratchPad::paintPresetImage()
{
if(!m_paintLayer) return;
KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
QRect imageRect(QPoint(), overlayRect.size());
QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
Qt::IgnoreAspectRatio,
Qt::SmoothTransformation);
KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
device->convertFromQImage(scaledImage, 0);
KisPainter painter(paintDevice);
painter.bitBlt(overlayRect.topLeft(), device, imageRect);
update();
}
void KisPaintDeviceTest::testThumbnail()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, 0);
{
KisPaintDeviceSP thumb = dev->createThumbnailDevice(50, 50);
QRect rc = thumb->exactBounds();
QVERIFY(rc.width() <= 50);
QVERIFY(rc.height() <= 50);
}
{
QImage thumb = dev->createThumbnail(50, 50);
QVERIFY(!thumb.isNull());
QVERIFY(thumb.width() <= 50);
QVERIFY(thumb.height() <= 50);
image.save("kis_paint_device_test_test_thumbnail.png");
}
}
// #include <valgrind/callgrind.h>
void KisConvolutionPainterTest::benchmarkConvolution()
{
QImage referenceImage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QRect imageRect(QPoint(), referenceImage.size());
KisPaintDeviceSP dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
dev->convertFromQImage(referenceImage, 0, 0, 0);
qreal offset = 0.0;
qreal factor = 1.0;
Matrix<qreal, 3, 3> filter = initAsymmFilter(offset, factor);
int diameter = 1;
for (int i = 0; i < 10; i++) {
KisCircleMaskGenerator* kas = new KisCircleMaskGenerator(diameter, 1.0, 5, 5, 2);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMaskGenerator(kas);
KisConvolutionPainter gc(dev);
QTime timer; timer.start();
// CALLGRIND_START_INSTRUMENTATION;
gc.beginTransaction(0);
gc.applyMatrix(kernel, dev, imageRect.topLeft(), imageRect.topLeft(),
imageRect.size());
gc.deleteTransaction();
// CALLGRIND_STOP_INSTRUMENTATION;
qDebug() << "Diameter:" << diameter << "time:" << timer.elapsed();
if(diameter < 10) {
diameter += 2;
} else {
diameter += 8;
}
}
}
void KisPaintDeviceTest::testFastBitBlt()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dstDev = new KisPaintDevice(cs);
KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
srcDev->convertFromQImage(image, 0);
QRect cloneRect(100,100,200,200);
QPoint errpoint;
QVERIFY(dstDev->fastBitBltPossible(srcDev));
dstDev->fastBitBlt(srcDev, cloneRect);
QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
// Test Rough version
dstDev->clear();
dstDev->fastBitBltRough(srcDev, cloneRect);
srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
cloneRect.width(), cloneRect.height());
if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
srcDev->move(10,10);
QVERIFY(!dstDev->fastBitBltPossible(srcDev));
}
void KisFillPainterTest::benchmarkFillPainter(const QPoint &startPoint, bool useCompositioning)
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage srcImage(TestUtil::fetchDataFileLazy("heavy_labyrinth.png"));
QVERIFY(!srcImage.isNull());
QRect imageRect = srcImage.rect();
dev->convertFromQImage(srcImage, 0, 0, 0);
QBENCHMARK_ONCE {
KisFillPainter gc(dev);
gc.setFillThreshold(THRESHOLD);
gc.setWidth(imageRect.width());
gc.setHeight(imageRect.height());
gc.setPaintColor(KoColor(Qt::red, dev->colorSpace()));
gc.setUseCompositioning(useCompositioning);
gc.fillColor(startPoint.x(), startPoint.y(), dev);
}
QImage resultImage =
dev->convertToQImage(0,
imageRect.x(), imageRect.y(),
imageRect.width(), imageRect.height());
QString testName = QString("heavy_labyrinth_%1_%2_%3")
.arg(startPoint.x())
.arg(startPoint.y())
.arg(useCompositioning ? "composed" : "direct");
QVERIFY(TestUtil::checkQImage(resultImage,
"fill_painter",
"general_",
testName));
}
void KisPaintDeviceTest::testRoundtripReadWrite()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
dev->convertFromQImage(image, 0);
quint8* bytes = new quint8[cs->pixelSize() * image.width() * image.height()];
memset(bytes, 0, image.width() * image.height() * dev->pixelSize());
dev->readBytes(bytes, image.rect());
KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
dev2->writeBytes(bytes, image.rect());
QVERIFY(dev2->exactBounds() == image.rect());
dev2->convertToQImage(0, 0, 0, image.width(), image.height()).save("readwrite.png");
QPoint pt;
if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
QFAIL(QString("Failed round trip using readBytes and writeBytes, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
}
}
void KisShapeLayerCanvas::repaint()
{
QRect r;
{
QMutexLocker locker(&m_dirtyRegionMutex);
r = m_dirtyRegion.boundingRect();
m_dirtyRegion = QRegion();
}
if (r.isEmpty()) return;
r = r.intersected(m_parentLayer->image()->bounds());
QImage image(r.width(), r.height(), QImage::Format_ARGB32);
image.fill(0);
QPainter p(&image);
p.setRenderHint(QPainter::Antialiasing);
p.setRenderHint(QPainter::TextAntialiasing);
p.translate(-r.x(), -r.y());
p.setClipRect(r);
#ifdef DEBUG_REPAINT
QColor color = QColor(random() % 255, random() % 255, random() % 255);
p.fillRect(r, color);
#endif
m_shapeManager->paint(p, *m_viewConverter, false);
p.end();
KisPaintDeviceSP dev = new KisPaintDevice(m_projection->colorSpace());
dev->convertFromQImage(image, 0);
KisPainter::copyAreaOptimized(r.topLeft(), dev, m_projection, QRect(QPoint(), r.size()));
m_parentLayer->setDirty(r);
}
void KisPaintDeviceTest::testOpacity()
{
// blt a semi-transparent image on a white paint device
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP fdev = new KisPaintDevice(cs);
fdev->convertFromQImage(image, 0);
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
KisPainter gc(dev);
gc.bitBlt(QPoint(0, 0), fdev, image.rect());
QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
QImage checkResult(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent_result.png");
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, checkResult, result, 1)) {
checkResult.save("kis_paint_device_test_test_blt_fixed_opactiy_expected.png");
result.save("kis_paint_device_test_test_blt_fixed_opacity_result.png");
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}