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::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 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 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());
}
}
void KisFilterTest::testOldDataApiAfterCopy()
{
QRect updateRect(0,0,63,63);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
quint8 *whitePixel = new quint8[cs->pixelSize()];
cs->fromQColor(Qt::white, whitePixel);
cs->setOpacity(whitePixel, OPACITY_OPAQUE_U8, 1);
KisPaintDeviceSP tmp = new KisPaintDevice(cs);
KisPaintDeviceSP src = new KisPaintDevice(cs);
src->fill(0, 0, 50, 50, whitePixel);
/**
* Make a full copy here to catch the bug.
* Buggy memento manager would make a commit
* that is not good.
*/
KisPaintDeviceSP dst = new KisPaintDevice(*src);
/**
* This would write go to a new revision in a buggy
* memento manager
*/
dst->clear(updateRect);
KisFilterSP f = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
/**
* This filter reads from oldRawData, so if we have some
* weirdness with transactions it will read from old and non-cleared
* version of the device and we will see a black square instead
* of empty device in tmp
*/
f->process(dst, tmp, 0, updateRect, kfc);
/**
* In theory, both devices: dst and tmp must be empty by now
*/
KisPaintDeviceSP reference = new KisPaintDevice(cs);
QImage refImage = reference->convertToQImage(0,0,0,63,63);
QImage dstImage = dst->convertToQImage(0,0,0,63,63);
QImage tmpImage = tmp->convertToQImage(0,0,0,63,63);
QPoint pt;
QVERIFY(TestUtil::compareQImages(pt, refImage, dstImage));
QVERIFY(TestUtil::compareQImages(pt, refImage, tmpImage));
}
void KisTransparencyMaskTest::testApply()
{
QPoint errpoint;
KisImageSP image;
KisPaintLayerSP layer;
KisPaintDeviceSP dev;
KisTransparencyMaskSP mask;
QRect applyRect(0, 0, 200, 100);
// Everything is selected
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
QImage qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_2.png"),
qimage)) {
QFAIL(QString("Failed to mask out image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
// Invert the mask, so that nothing will be selected, then select a rect
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_1.png"),
qimage)) {
QFAIL(QString("Failed to mask in image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->select(QRect(50, 0, 100, 100));
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_3.png"),
qimage)) {
QFAIL(QString("Failed to apply partial mask, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void testWrappedLineIteratorReadMoreThanBounds(QString testName)
{
const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
KisPaintDeviceSP dst = new KisPaintDevice(cs);
// fill device with a gradient
QRect bounds = dev->defaultBounds()->bounds();
for (int y = bounds.y(); y < bounds.y() + bounds.height(); y++) {
for (int x = bounds.x(); x < bounds.x() + bounds.width(); x++) {
QColor c((10 * x) % 255, (10 * y) % 255, 0, 255);
dev->setPixel(x, y, c);
}
}
// test rect doesn't fit the wrap rect in both dimentions
const QRect &rect(bounds.adjusted(-6,-6,8,8));
KisRandomAccessorSP dstIt = dst->createRandomAccessorNG(rect.x(), rect.y());
IteratorSP it = createIterator<IteratorSP>(dev, rect);
for (int y = rect.y(); y < rect.y() + rect.height(); y++) {
for (int x = rect.x(); x < rect.x() + rect.width(); x++) {
quint8 *data = it->rawData();
QVERIFY(checkConseqPixels<IteratorSP>(it->nConseqPixels(), QPoint(x, y), KisWrappedRect(rect, bounds)));
dstIt->moveTo(x, y);
memcpy(dstIt->rawData(), data, cs->pixelSize());
QVERIFY(checkXY<IteratorSP>(QPoint(it->x(), it->y()), QPoint(x,y)));
bool stepDone = it->nextPixel();
QCOMPARE(stepDone, x < rect.x() + rect.width() - 1);
}
if (!nextRowGeneral(it, y, rect)) break;
}
testName = QString("%1_%2_%3_%4_%5")
.arg(testName)
.arg(rect.x())
.arg(rect.y())
.arg(rect.width())
.arg(rect.height());
QRect rc = rect;
QImage result = dst->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QImage ref = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators_huge", testName));
}
//#define SAVE_OUTPUT_IMAGES
void KisAutoBrushTest::testCopyMasking()
{
int w = 64;
int h = 64;
int x = 0;
int y = 0;
QRect rc(x, y, w, h);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KoColor black(Qt::black, cs);
KoColor red(Qt::red, cs);
KisPaintDeviceSP tempDev = new KisPaintDevice(cs);
tempDev->fill(0, 0, w, h, red.data());
#ifdef SAVE_OUTPUT_IMAGES
tempDev->convertToQImage(0).save("tempDev.png");
#endif
KisCircleMaskGenerator * mask = new KisCircleMaskGenerator(w, 1.0, 0.5, 0.5, 2, true);
KisAutoBrush brush(mask, 0, 0);
KisFixedPaintDeviceSP maskDab = new KisFixedPaintDevice(cs);
brush.mask(maskDab, black, KisDabShape(), KisPaintInformation());
maskDab->convertTo(KoColorSpaceRegistry::instance()->alpha8());
#ifdef SAVE_OUTPUT_IMAGES
maskDab->convertToQImage(0, 0, 0, 64, 64).save("maskDab.png");
#endif
QCOMPARE(tempDev->exactBounds(), rc);
QCOMPARE(maskDab->bounds(), rc);
KisFixedPaintDeviceSP dev2fixed = new KisFixedPaintDevice(cs);
dev2fixed->setRect(rc);
dev2fixed->initialize();
tempDev->readBytes(dev2fixed->data(), rc);
dev2fixed->convertToQImage(0).save("converted-tempDev-to-fixed.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
KisPainter painter(dev);
painter.setCompositeOp(COMPOSITE_COPY);
painter.bltFixedWithFixedSelection(x, y, dev2fixed, maskDab, 0, 0, 0, 0, rc.width(), rc.height());
//painter.bitBltWithFixedSelection(x, y, tempDev, maskDab, 0, 0, 0, 0, rc.width(), rc.height());
#ifdef SAVE_OUTPUT_IMAGES
dev->convertToQImage(0).save("final.png");
#endif
}
void testWrappedLineIterator(QString testName, const QRect &rect)
{
testName = QString("%1_%2_%3_%4_%5")
.arg(testName)
.arg(rect.x())
.arg(rect.y())
.arg(rect.width())
.arg(rect.height());
const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
// test rect fits the wrap rect in both dimensions
IteratorSP it = createIterator<IteratorSP>(dev, rect);
int y = 0;
do {
int x = 0;
do {
quint8 *data = it->rawData();
data[0] = 10 * x;
data[1] = 10 * y;
data[2] = 0;
data[3] = 255;
x++;
} while (it->nextPixel());
} while (nextRowGeneral(it, ++y, rect));
QRect rc = dev->defaultBounds()->bounds() | dev->exactBounds();
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators", testName));
}
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"));
}
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 KisConvolutionPainterTest::testGaussianBase(KisPaintDeviceSP dev, bool useFftw, const QString &prefix)
{
QBitArray channelFlags =
KoColorSpaceRegistry::instance()->rgb8()->channelFlags(true, true);
KisPainter gc(dev);
qreal horizontalRadius = 5, verticalRadius = 5;
for(int i = 0; i < 3 ; i++, horizontalRadius+=5, verticalRadius+=5)
{
QTime timer;
timer.start();
gc.beginTransaction();
if (( horizontalRadius > 0 ) && ( verticalRadius > 0 )) {
KisPaintDeviceSP interm = new KisPaintDevice(dev->colorSpace());
KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(horizontalRadius);
KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(verticalRadius);
const QRect applyRect = dev->exactBounds();
KisConvolutionPainter::TestingEnginePreference enginePreference =
useFftw ?
KisConvolutionPainter::FFTW :
KisConvolutionPainter::SPATIAL;
KisConvolutionPainter horizPainter(interm, enginePreference);
horizPainter.setChannelFlags(channelFlags);
horizPainter.applyMatrix(kernelHoriz, dev,
applyRect.topLeft() - QPoint(0, verticalRadius),
applyRect.topLeft() - QPoint(0, verticalRadius),
applyRect.size() + QSize(0, 2 * verticalRadius),
BORDER_REPEAT);
KisConvolutionPainter verticalPainter(dev, enginePreference);
verticalPainter.setChannelFlags(channelFlags);
verticalPainter.applyMatrix(kernelVertical, interm,
applyRect.topLeft(),
applyRect.topLeft(),
applyRect.size(), BORDER_REPEAT);
QImage result = dev->convertToQImage(0, applyRect.x(), applyRect.y(), applyRect.width(), applyRect.height());
QString engine = useFftw ? "fftw" : "spatial";
QString testCaseName = QString("test_gaussian_%1_%2_%3.png").arg(horizontalRadius).arg(verticalRadius).arg(engine);
TestUtil::checkQImage(result,
"convolution_painter_test",
QString("gaussian_") + prefix,
testCaseName);
gc.revertTransaction();
}
dbgKrita << "Elapsed time:" << timer.elapsed() << "ms";
}
}
void KisFilterSelectionsBenchmark::testGoodSelections(int num)
{
#if(USE_GOOD_SELECTIONS==1)
KisPaintDeviceSP projection =
new KisPaintDevice(m_device->colorSpace());
double avTime;
KisTimeCounter timer;
QRect filterRect = m_selection->selectedExactRect();
KisConstProcessingInformation src(m_device, filterRect.topLeft(), m_selection);
KisProcessingInformation dst(projection, filterRect.topLeft(), 0);
timer.restart();
for (int i = 0; i < num; i++) {
KisTransaction transac(0, projection, 0);
m_filter->processSpecial(src, dst, filterRect.size(), m_configuration, 0);
}
avTime = double(timer.elapsed()) / num;
projection->convertToQImage(0).save("TFS__GOOD_SELECTIONS.png");
if (num > WARMUP_CYCLES || SHOW_WARMUPS)
dbgKrita << "Selections with alpha (filter):\t" << avTime;
#else /* if (USE_GOOD_SELECTIONS!=1) */
if (num > WARMUP_CYCLES || SHOW_WARMUPS)
dbgKrita << "Selections with alpha (filter):\t [Disabled]";
#endif
}
void KisFilterSelectionsBenchmark::testBitBltSelections(int num)
{
KisPaintDeviceSP projection =
new KisPaintDevice(m_device->colorSpace());
double avTime;
KisTimeCounter timer;
QRect filterRect = m_selection->selectedExactRect();
timer.restart();
for (int i = 0; i < num; i++) {
KisPaintDeviceSP cacheDevice = new KisPaintDevice(projection->colorSpace());
KisTransaction transac(cacheDevice, 0);
m_filter->process(m_device, cacheDevice, 0, filterRect, m_configuration, 0);
KisPainter gc(projection);
gc.beginTransaction();
gc.setCompositeOp(projection->colorSpace()->compositeOp(COMPOSITE_ALPHA_DARKEN));
gc.setSelection(m_selection);
gc.bitBlt(filterRect.topLeft(), cacheDevice, filterRect);
gc.deleteTransaction();
}
avTime = double(timer.elapsed()) / num;
projection->convertToQImage(0).save("TFS__BITBLT_WITH_SELECTIONS.png");
if (num > WARMUP_CYCLES || SHOW_WARMUPS)
dbgKrita << "bitBlt with sel:\t\t\t" << avTime;
}
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 testShapedGradientPainterImpl(const QPolygonF &selectionPolygon,
const QString &testName,
const QPolygonF &selectionErasePolygon = QPolygonF())
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QRect imageRect(0,0,300,300);
KisSelectionSP selection = new KisSelection();
KisPixelSelectionSP pixelSelection = selection->pixelSelection();
KisPainter selPainter(pixelSelection);
selPainter.setFillStyle(KisPainter::FillStyleForegroundColor);
selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
selPainter.paintPolygon(selectionPolygon);
if (!selectionErasePolygon.isEmpty()) {
selPainter.setCompositeOp(COMPOSITE_ERASE);
selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
selPainter.paintPolygon(selectionErasePolygon);
}
selPainter.end();
pixelSelection->invalidateOutlineCache();
pixelSelection->convertToQImage(0, imageRect).save("sgt_selection.png");
QLinearGradient testGradient;
testGradient.setColorAt(0.0, Qt::white);
testGradient.setColorAt(0.5, Qt::green);
testGradient.setColorAt(1.0, Qt::black);
testGradient.setSpread(QGradient::ReflectSpread);
QScopedPointer<KoStopGradient> gradient(
KoStopGradient::fromQGradient(&testGradient));
KisGradientPainter gc(dev, selection);
gc.setGradient(gradient.data());
gc.setGradientShape(KisGradientPainter::GradientShapePolygonal);
gc.paintGradient(selectionPolygon.boundingRect().topLeft(),
selectionPolygon.boundingRect().bottomRight(),
KisGradientPainter::GradientRepeatNone,
0,
false,
imageRect.x(),
imageRect.y(),
imageRect.width(),
imageRect.height());
QVERIFY(TestUtil::checkQImageExternal(dev->convertToQImage(0, imageRect),
"shaped_gradient",
"fill",
testName, 1, 1, 0));
}
QImage utils::StrokeTester::doStroke(bool cancelled,
bool indirectPainting,
bool externalLayer,
bool testUpdates,
bool needQImage)
{
KisImageSP image = utils::createImage(0, m_imageSize);
KoCanvasResourceManager *manager = utils::createResourceManager(image, 0, m_presetFilename);
KisNodeSP currentNode;
for (int i = 0; i < m_numIterations; i++) {
modifyResourceManager(manager, image, i);
KisPainter *painter = new KisPainter();
KisResourcesSnapshotSP resources =
new KisResourcesSnapshot(image,
image->rootLayer()->firstChild(),
image->postExecutionUndoAdapter(),
manager);
if(externalLayer) {
KisNodeSP externalNode = new KisPaintLayer(0, "extlyr", OPACITY_OPAQUE_U8, image->colorSpace());
resources->setCurrentNode(externalNode);
Q_ASSERT(resources->currentNode() == externalNode);
}
initImage(image, resources->currentNode(), i);
KisStrokeStrategy *stroke = createStroke(indirectPainting, resources, painter, image);
m_strokeId = image->startStroke(stroke);
addPaintingJobs(image, resources, painter, i);
if(!cancelled) {
image->endStroke(m_strokeId);
}
else {
image->cancelStroke(m_strokeId);
}
image->waitForDone();
currentNode = resources->currentNode();
}
QImage resultImage;
if(needQImage) {
KisPaintDeviceSP device = testUpdates ?
image->projection() :
currentNode->paintDevice();
resultImage = device->convertToQImage(0, 0, 0, image->width(), image->height());
}
image = 0;
delete manager;
return resultImage;
}
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 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::testDeviceDuplication()
{
QRect fillRect(0,0,64,64);
quint8 fillPixel[4]={255,255,255,255};
QRect clearRect(10,10,20,20);
QImage referenceImage;
QImage resultImage;
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP device = new KisPaintDevice(cs);
// qDebug()<<"FILLING";
device->fill(fillRect.left(), fillRect.top(),
fillRect.width(), fillRect.height(),fillPixel);
referenceImage = device->convertToQImage(0);
KisTransaction transaction1(device);
// qDebug()<<"CLEARING";
device->clear(clearRect);
transaction1.revert();
resultImage = device->convertToQImage(0);
QVERIFY(resultImage == referenceImage);
KisPaintDeviceSP clone = new KisPaintDevice(*device);
KisTransaction transaction(clone);
// qDebug()<<"CLEARING";
clone->clear(clearRect);
transaction.revert();
resultImage = clone->convertToQImage(0);
QVERIFY(resultImage == referenceImage);
}
QImage KisScratchPad::cutoutOverlay() const
{
if(!m_paintLayer) return QImage();
KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::IntentPerceptual, KoColorConversionTransformation::BlackpointCompensation);
QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
Qt::IgnoreAspectRatio,
Qt::SmoothTransformation);
return scaledImage;
}
void KisPaintDeviceTest::testSharedDataManager()
{
QRect fillRect(0,0,100,100);
quint8 fillPixel[4]={255,255,255,255};
QRect clearRect(10,10,20,20);
QImage srcImage;
QImage dstImage;
const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP srcDevice = new KisPaintDevice(cs);
srcDevice->setX(10);
srcDevice->setY(20);
srcDevice->fill(fillRect.left(), fillRect.top(),
fillRect.width(), fillRect.height(),fillPixel);
KisPaintDeviceSP dstDevice = new KisPaintDevice(srcDevice->dataManager(), srcDevice);
QVERIFY(srcDevice->extent() == dstDevice->extent());
QVERIFY(srcDevice->exactBounds() == dstDevice->exactBounds());
QVERIFY(srcDevice->defaultBounds() == dstDevice->defaultBounds());
QVERIFY(srcDevice->x() == dstDevice->x());
QVERIFY(srcDevice->y() == dstDevice->y());
srcImage = srcDevice->convertToQImage(0);
dstImage = dstDevice->convertToQImage(0);
QVERIFY(srcImage == dstImage);
srcDevice->clear(clearRect);
srcImage = srcDevice->convertToQImage(0);
dstImage = dstDevice->convertToQImage(0);
QVERIFY(srcImage == dstImage);
}
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 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 KisScratchPad::paintEvent ( QPaintEvent * event ) {
if(!m_paintLayer) return;
QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
QRect alignedImageRect =
imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
QPointF offset = alignedImageRect.topLeft();
m_paintLayer->updateProjection(alignedImageRect);
KisPaintDeviceSP projection = m_paintLayer->projection();
QImage image = projection->convertToQImage(m_displayProfile,
alignedImageRect.x(),
alignedImageRect.y(),
alignedImageRect.width(),
alignedImageRect.height(),
KoColorConversionTransformation::IntentPerceptual,
KoColorConversionTransformation::BlackpointCompensation);
QPainter gc(this);
gc.fillRect(event->rect(), m_checkBrush);
gc.setRenderHints(QPainter::SmoothPixmapTransform);
gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
QBrush brush(Qt::lightGray);
QPen pen(brush, 1, Qt::DotLine);
gc.setPen(pen);
if (m_cutoutOverlay.isValid()) {
gc.drawRect(m_cutoutOverlay);
}
if(!isEnabled()) {
QColor color(Qt::lightGray);
color.setAlphaF(0.5);
QBrush disabledBrush(color);
gc.fillRect(event->rect(), disabledBrush);
}
gc.end();
}
void KisFilterTest::testBlurFilterApplicationRect()
{
QRect filterRect(10,10,40,40);
QRect src1Rect(5,5,50,50);
QRect src2Rect(0,0,60,60);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
quint8 *whitePixel = new quint8[cs->pixelSize()];
cs->fromQColor(Qt::white, whitePixel);
cs->setOpacity(whitePixel, OPACITY_OPAQUE_U8, 1);
KisPaintDeviceSP src1 = new KisPaintDevice(cs);
src1->fill(src1Rect.left(),src1Rect.top(),src1Rect.width(),src1Rect.height(), whitePixel);
KisPaintDeviceSP src2 = new KisPaintDevice(cs);
src2->fill(src2Rect.left(),src2Rect.top(),src2Rect.width(),src2Rect.height(), whitePixel);
KisPaintDeviceSP dst1 = new KisPaintDevice(cs);
KisPaintDeviceSP dst2 = new KisPaintDevice(cs);
KisFilterSP f = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
f->process(src1, dst1, 0, filterRect, kfc);
f->process(src2, dst2, 0, filterRect, kfc);
KisPaintDeviceSP reference = new KisPaintDevice(cs);
reference->fill(filterRect.left(),filterRect.top(),filterRect.width(),filterRect.height(), whitePixel);
QImage refImage = reference->convertToQImage(0,10,10,40,40);
QImage dst1Image = dst1->convertToQImage(0,10,10,40,40);
QImage dst2Image = dst2->convertToQImage(0,10,10,40,40);
//dst1Image.save("DST1.png");
//dst2Image.save("DST2.png");
QPoint pt;
QVERIFY(TestUtil::compareQImages(pt, refImage, dst1Image));
QVERIFY(TestUtil::compareQImages(pt, refImage, dst2Image));
}
void KisGmicBenchmarks::testKisPaintDeviceConversion()
{
gmic_image<float> gmicImage;
gmicImage.assign(m_qImage.width(),m_qImage.height(), 1,4);
// benchmark rgba2rgba
KisPaintDeviceSP result = new KisPaintDevice(m_device->colorSpace());
result->fill(QRect(0,0,m_qImage.width(),m_qImage.height()), KoColor(m_darkOrange, m_device->colorSpace()));
QBENCHMARK
{
KisGmicSimpleConvertor::convertToGmicImage(m_device, gmicImage, m_rect);
KisGmicSimpleConvertor::convertFromGmicImage(gmicImage, result, 1.0);
}
#ifdef SAVE_OUTPUT
QImage qResult = result->convertToQImage(0, 0,0, m_qImage.width(),m_qImage.height());
qResult.save("Device-Gmic-Device-new.bmp");
#endif
}
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 KisFixedPaintDeviceTest::testBltFixedSmall()
{
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "fixed_blit_small.png");
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice(cs);
fdev->convertFromQImage(image, 0);
// Without opacity
KisPaintDeviceSP dev = new KisPaintDevice(cs);
KisPainter gc(dev);
gc.bltFixed(QPoint(0, 0), fdev, image.rect());
QImage result = dev->convertToQImage(0, 0, 0, 51, 51);
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("kis_fixed_paint_device_test_blt_small_image.png");
result.save("kis_fixed_paint_device_test_blt_small_result.png");
QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisFilterSelectionsBenchmark::testNoSelections(int num)
{
KisPaintDeviceSP projection =
new KisPaintDevice(m_device->colorSpace());
double avTime;
KisTimeCounter timer;
QRect filterRect = m_selection->selectedExactRect();
timer.restart();
for (int i = 0; i < num; i++) {
KisTransaction transac(projection, 0);
m_filter->process(m_device, projection, 0, filterRect, m_configuration, 0);
}
avTime = double(timer.elapsed()) / num;
projection->convertToQImage(0).save("TFS__NO_SELECTIONS.png");
if (num > WARMUP_CYCLES || SHOW_WARMUPS)
dbgKrita << "No Selections:\t\t\t\t" << avTime;
}