void KisMaskTest::testDeferredOffsetInitialization()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
KisMaskSP mask = new TestMask;
QCOMPARE(mask->x(), 0);
QCOMPARE(mask->y(), 0);
mask->setX(10);
QCOMPARE(mask->x(), 10);
QCOMPARE(mask->y(), 0);
mask->setY(11);
QCOMPARE(mask->x(), 10);
QCOMPARE(mask->y(), 11);
mask->initSelection(image->rootLayer());
// IMPORTANT: a bit weird behavior, but it is needed for
// KisKraLoadVisitor to work properly
QCOMPARE(mask->x(), 10);
QCOMPARE(mask->y(), 11);
// Now there is no deferred initialization, so the offest
// should simply be reset
mask->initSelection(image->rootLayer());
QCOMPARE(mask->x(), 0);
QCOMPARE(mask->y(), 0);
KisSelectionSP selection = mask->selection();
QCOMPARE(selection->parentNode(), KisNodeSP(mask));
}
void KisAsyncMergerTest::debugObligeChild()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 640, 441, colorSpace, "merger test");
QImage sourceImage1(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
device1->convertFromQImage(sourceImage1, 0, 0, 0);
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisLayerSP groupLayer = new KisGroupLayer(image, "group", OPACITY_OPAQUE_U8);
image->addNode(groupLayer, image->rootLayer());
image->addNode(paintLayer1, groupLayer);
QRect testRect1(0,0,640,441);
QRect cropRect(image->bounds());
KisMergeWalker walker(cropRect);
KisAsyncMerger merger;
walker.collectRects(paintLayer1, testRect1);
merger.startMerge(walker);
KisLayerSP rootLayer = image->rootLayer();
QVERIFY(rootLayer->original() == groupLayer->projection());
QVERIFY(groupLayer->original() == paintLayer1->projection());
}
void KisImageTest::testLayerComposition()
{
KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
QVERIFY(image->rootLayer() != 0);
QVERIFY(image->rootLayer()->firstChild() == 0);
KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
image->addNode(layer);
KisLayerSP layer2 = new KisPaintLayer(image, "layer 2", OPACITY_OPAQUE_U8);
image->addNode(layer2);
QVERIFY(layer->visible());
QVERIFY(layer2->visible());
KisLayerComposition comp(image, "comp 1");
comp.store();
layer2->setVisible(false);
QVERIFY(layer->visible());
QVERIFY(!layer2->visible());
KisLayerComposition comp2(image, "comp 2");
comp2.store();
comp.apply();
QVERIFY(layer->visible());
QVERIFY(layer2->visible());
comp2.apply();
QVERIFY(layer->visible());
QVERIFY(!layer2->visible());
}
void KisSimpleUpdateQueueTest::testChecksum()
{
QRect imageRect(0,0,512,512);
QRect dirtyRect(100,100,100,100);
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), colorSpace, "test");
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
KisAdjustmentLayerSP adjustmentLayer = new KisAdjustmentLayer(image, "adj", 0, 0);
image->lock();
image->addNode(paintLayer1, image->rootLayer());
image->addNode(adjustmentLayer, image->rootLayer());
image->unlock();
KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
KisTestableSimpleUpdateQueue queue;
KisWalkersList& walkersList = queue.getWalkersList();
{
TestUtil::LodOverride l(1, image);
queue.addUpdateJob(adjustmentLayer, dirtyRect, imageRect, 1);
QCOMPARE(walkersList[0]->checksumValid(), true);
QCOMPARE(walkersList[0]->levelOfDetail(), 1);
}
adjustmentLayer->setFilter(configuration);
{
TestUtil::LodOverride l(1, image);
QCOMPARE(walkersList[0]->checksumValid(), false);
}
QVector<KisUpdateJobItem*> jobs;
KisTestableUpdaterContext context(2);
{
TestUtil::LodOverride l(1, image);
queue.processQueue(context);
}
jobs = context.getJobs();
{
TestUtil::LodOverride l(1, image);
QCOMPARE(jobs[0]->walker()->checksumValid(), true);
}
}
void KisImageTest::layerTests()
{
KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
QVERIFY(image->rootLayer() != 0);
QVERIFY(image->rootLayer()->firstChild() == 0);
KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
image->addNode(layer);
QVERIFY(image->rootLayer()->firstChild()->objectName() == layer->objectName());
}
void KisGmicTests::testGatherLayers()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
QImage background(QString(FILES_DATA_DIR) + QDir::separator() + "00_BG.png");
QImage colorMarks(QString(FILES_DATA_DIR) + QDir::separator() + "01_ColorMarks.png");
QImage artLine(QString(FILES_DATA_DIR) + QDir::separator() + "02_Artline.png");
KisImageSP image = new KisImage(0, 2408, 3508, colorSpace, "filter test");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
KisPaintDeviceSP device2 = new KisPaintDevice(colorSpace);
KisPaintDeviceSP device3 = new KisPaintDevice(colorSpace);
device1->convertFromQImage(background, 0, 0, 0);
device2->convertFromQImage(colorMarks, 0, 0, 0);
device3->convertFromQImage(artLine, 0, 0, 0);
KisLayerSP paintLayer1 = new KisPaintLayer(image, "background", OPACITY_OPAQUE_U8, device1);
KisLayerSP paintLayer2 = new KisPaintLayer(image, "colorMarks", OPACITY_OPAQUE_U8, device2);
KisLayerSP paintLayer3 = new KisPaintLayer(image, "artLine", OPACITY_OPAQUE_U8, device3);
image->addNode(paintLayer1, image->rootLayer());
image->addNode(paintLayer2, image->rootLayer());
image->addNode(paintLayer3, image->rootLayer());
KisNodeSP activeNode = static_cast<KisNodeSP>(paintLayer2);
KisNodeListSP result;
KisInputOutputMapper mapper(image, activeNode);
result = mapper.inputNodes(ACTIVE_LAYER);
QCOMPARE(result->at(0)->name(), activeNode->name());
result = mapper.inputNodes(ACTIVE_LAYER_ABOVE_LAYER);
QCOMPARE(result->size(), 2);
QCOMPARE(result->at(0)->name(), activeNode->name());
QCOMPARE(result->at(1)->name(), paintLayer3->name());
result = mapper.inputNodes(ACTIVE_LAYER_BELOW_LAYER);
QCOMPARE(result->size(), 2);
QCOMPARE(result->at(0)->name(), activeNode->name());
QCOMPARE(result->at(1)->name(), paintLayer1->name());
result = mapper.inputNodes(ALL_LAYERS);
QCOMPARE(result->size(), 3);
QCOMPARE(result->at(0)->name(), paintLayer3->name());
QCOMPARE(result->at(1)->name(), paintLayer2->name());
QCOMPARE(result->at(2)->name(), paintLayer1->name());
}
void KisPasteNewActionFactory::run(KisViewManager *viewManager)
{
Q_UNUSED(viewManager);
KisPaintDeviceSP clip = KisClipboard::instance()->clip(QRect(), true);
if (!clip) return;
QRect rect = clip->exactBounds();
if (rect.isEmpty()) return;
KisDocument *doc = KisPart::instance()->createDocument();
KisImageSP image = new KisImage(doc->createUndoStore(),
rect.width(),
rect.height(),
clip->colorSpace(),
i18n("Pasted"));
KisPaintLayerSP layer =
new KisPaintLayer(image.data(), clip->objectName(),
OPACITY_OPAQUE_U8, clip->colorSpace());
KisPainter::copyAreaOptimized(QPoint(), clip, layer->paintDevice(), rect);
image->addNode(layer.data(), image->rootLayer());
doc->setCurrentImage(image);
KisPart::instance()->addDocument(doc);
KisMainWindow *win = viewManager->mainWindow();
win->addViewAndNotifyLoadingCompleted(doc);
}
void KisProcessingApplicatorTest::testRecursiveProcessing()
{
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisPaintLayerSP paintLayer1;
KisPaintLayerSP paintLayer2;
KisImageSP image = createImage(undoStore, paintLayer1, paintLayer2);
QRect cropRect1(40,40,86,86);
QVERIFY(checkLayers(image, "recursive_initial"));
{
KisProcessingApplicator applicator(image, image->rootLayer(),
KisProcessingApplicator::RECURSIVE);
KisProcessingVisitorSP visitor =
new KisCropProcessingVisitor(cropRect1, true, true);
applicator.applyVisitor(visitor);
applicator.end();
image->waitForDone();
}
QVERIFY(checkLayers(image, "recursive_crop"));
undoStore->undo();
image->waitForDone();
QVERIFY(checkLayers(image, "recursive_initial"));
}
void KisProcessingApplicatorTest::testNoUIUpdates()
{
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisPaintLayerSP paintLayer1;
KisPaintLayerSP paintLayer2;
KisImageSP image = createImage(undoStore, paintLayer1, paintLayer2);
QSignalSpy uiSignalsCounter(image.data(), SIGNAL(sigImageUpdated(const QRect&)));
QRect cropRect1(40,40,86,86);
{
KisProcessingApplicator applicator(image, image->rootLayer(),
KisProcessingApplicator::RECURSIVE |
KisProcessingApplicator::NO_UI_UPDATES);
KisProcessingVisitorSP visitor =
new KisCropProcessingVisitor(cropRect1, true, true);
applicator.applyVisitor(visitor);
applicator.end();
image->waitForDone();
}
QCOMPARE(uiSignalsCounter.size(), 0);
uiSignalsCounter.clear();
undoStore->undo();
image->waitForDone();
QCOMPARE(uiSignalsCounter.size(), 0);
}
void KisLayerTest::testMoveLayer()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->colorSpace("RGBA", 0);
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "layer test");
KisLayerSP node1 = new TestLayer(image, "layer1", OPACITY_OPAQUE);
KisLayerSP node2 = new TestLayer(image, "layer2", OPACITY_OPAQUE);
KisLayerSP node3 = new TestLayer(image, "layer3", OPACITY_OPAQUE);
node1->setName("node1");
node2->setName("node2");
node3->setName("node3");
QVERIFY(image->addNode(node1));
QVERIFY(image->addNode(node2));
QVERIFY(image->addNode(node3));
QVERIFY(image->root()->at(0) == node1.data());
QVERIFY(image->root()->at(1) == node2.data());
QVERIFY(image->root()->at(2) == node3.data());
QVERIFY(image->moveNode(node3, image->rootLayer(), node1));
QVERIFY(image->root()->at(0) == node1.data());
QVERIFY(image->root()->at(1) == node3.data());
QVERIFY(image->root()->at(2) == node2.data());
}
void KisPrescaledProjectionTest::testScalingUndeferredSmoothing()
{
// Set up a nice image
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "lena.png");
// Undo adapter not necessary
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, qimage.width(), qimage.height(), cs, "projection test");
// 300 dpi recalculated to pixels per point (of which there are 72
// to the inch)
image->setResolution(100, 100);
KisPaintLayerSP layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8, cs);
image->addNode(layer.data(), image->rootLayer(), 0);
layer->paintDevice()->convertFromQImage(qimage, 0);
KisPrescaledProjection projection;
KisCoordinatesConverter converter;
converter.setImage(image);
projection.setCoordinatesConverter(&converter);
projection.setMonitorProfile(0,
KoColorConversionTransformation::internalRenderingIntent(),
KoColorConversionTransformation::internalConversionFlags());
projection.setImage(image);
testProjectionScenario(projection, &converter, "120dpi");
}
void KisPasteNewActionFactory::run(KisView2 *view)
{
Q_UNUSED(view);
KisPaintDeviceSP clip = KisClipboard::instance()->clip(QRect(), true);
if (!clip) return;
QRect rect = clip->exactBounds();
if (rect.isEmpty()) return;
KisDoc2 *doc = new KisDoc2();
if (!doc) return;
KisImageSP image = new KisImage(doc->createUndoStore(),
rect.width(),
rect.height(),
clip->colorSpace(),
i18n("Pasted"));
KisPaintLayerSP layer =
new KisPaintLayer(image.data(), clip->objectName(),
OPACITY_OPAQUE_U8, clip->colorSpace());
KisPainter p(layer->paintDevice());
p.setCompositeOp(COMPOSITE_COPY);
p.bitBlt(0, 0, clip, rect.x(), rect.y(), rect.width(), rect.height());
p.end();
image->addNode(layer.data(), image->rootLayer());
doc->setCurrentImage(image);
KoMainWindow *win = doc->documentPart()->createMainWindow();
win->show();
win->setRootDocument(doc);
}
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 KisPrescaledProjectionTest::benchmarkUpdate()
{
QImage referenceImage(QString(FILES_DATA_DIR) + QDir::separator() + "lena.png");
QRect imageRect = QRect(QPoint(0,0), referenceImage.size());
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "projection test");
// set up 300dpi
image->setResolution(300 / 72 , 300 / 72);
KisPaintLayerSP layer = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, cs);
layer->paintDevice()->convertFromQImage(referenceImage, 0);
image->addNode(layer, image->rootLayer(), 0);
KisPrescaledProjection projection;
KisCoordinatesConverter converter;
converter.setImage(image);
projection.setCoordinatesConverter(&converter);
projection.setMonitorProfile(0,
KoColorConversionTransformation::internalRenderingIntent(),
KoColorConversionTransformation::internalConversionFlags());
projection.setImage(image);
// Emulate "Use same aspect as pixels"
converter.setResolution(image->xRes(), image->yRes());
converter.setZoom(1.0);
KisUpdateInfoSP info = projection.updateCache(image->bounds());
projection.recalculateCache(info);
QCOMPARE(imageRect, QRect(0,0,512,512));
QRect dirtyRect(0,0,20,20);
const qint32 numShifts = 25;
const QPoint offset(dirtyRect.width(),dirtyRect.height());
//CALLGRIND_START_INSTRUMENTATION;
QBENCHMARK {
for(qint32 i = 0; i < numShifts; i++) {
KisUpdateInfoSP tempInfo = projection.updateCache(dirtyRect);
projection.recalculateCache(tempInfo);
dirtyRect.translate(offset);
}
}
//CALLGRIND_STOP_INSTRUMENTATION;
}
void addLayers(const QVector<Layer> &layers, KisImageSP image, int depth)
{
for(int i = 0; i < layers.size(); i++) {
const Layer &layer = layers[i];
if (layer.depth == depth) {
KisGroupLayerSP group = (depth == 0 ? image->rootLayer() : findGroup(layers, layer, i));
image->addNode(layer.layer, group);
if (layer.mask) {
image->addNode(layer.mask, layer.layer);
}
}
}
}
void KisMaskTest::testSelectionParent()
{
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
KisMaskSP mask = new TestMask;
mask->initSelection(image->rootLayer());
KisSelectionSP selection = mask->selection();
QCOMPARE(selection->parentNode(), KisNodeSP(mask));
}
{
KisMaskSP mask = new TestMask;
mask->setSelection(new KisSelection());
KisSelectionSP selection = mask->selection();
QCOMPARE(selection->parentNode(), KisNodeSP(mask));
}
}
void KisPasteNewActionFactory::run(KisView2 *view)
{
Q_UNUSED(view);
KisPaintDeviceSP clip = KisClipboard::instance()->clip(QPoint());
if (!clip) return;
QRect rect = clip->exactBounds();
if (rect.isEmpty()) return;
const QByteArray mimetype = KoServiceProvider::readNativeFormatMimeType();
KoDocumentEntry entry = KoDocumentEntry::queryByMimeType(mimetype);
QString error;
KisPart2* part = dynamic_cast<KisPart2*>(entry.createKoPart(&error));
if (!part) return;
KisDoc2 *doc = new KisDoc2(part);
if (!doc) return;
part->setDocument(doc);
KisImageSP image = new KisImage(doc->createUndoStore(),
rect.width(),
rect.height(),
clip->colorSpace(),
i18n("Pasted"));
KisPaintLayerSP layer =
new KisPaintLayer(image.data(), clip->objectName(),
OPACITY_OPAQUE_U8, clip->colorSpace());
KisPainter p(layer->paintDevice());
p.setCompositeOp(COMPOSITE_COPY);
p.bitBlt(0, 0, clip, rect.x(), rect.y(), rect.width(), rect.height());
p.end();
image->addNode(layer.data(), image->rootLayer());
doc->setCurrentImage(image);
KoMainWindow *win = new KoMainWindow(part->componentData());
win->show();
win->setRootDocument(doc);
}
KisImportExportFilter::ConversionStatus KisBMPImport::convert(const QByteArray& from, const QByteArray& to)
{
dbgFile << "BMP import! From:" << from << ", To:" << to << 0;
if (to != "application/x-krita")
return KisImportExportFilter::BadMimeType;
KisDocument * doc = outputDocument();
if (!doc)
return KisImportExportFilter::NoDocumentCreated;
QString filename = inputFile();
doc->prepareForImport();
if (!filename.isEmpty()) {
QFileInfo fi(filename);
if (!fi.exists()) {
return KisImportExportFilter::FileNotFound;
}
QImage img(filename);
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(doc->createUndoStore(), img.width(), img.height(), colorSpace, "imported from bmp");
KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), 255);
layer->paintDevice()->convertFromQImage(img, 0, 0, 0);
image->addNode(layer.data(), image->rootLayer().data());
doc->setCurrentImage(image);
return KisImportExportFilter::OK;
}
return KisImportExportFilter::StorageCreationError;
}
void KisAsyncMergerTest::testSubgraphingWithoutUpdatingParent()
{
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 128, 128, colorSpace, "clones test");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
device1->fill(image->bounds(), KoColor(Qt::white, colorSpace));
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisPaintDeviceSP device2 = new KisPaintDevice(colorSpace);
device2->fill(image->bounds(), KoColor(Qt::black, colorSpace));
KisLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", 128, device2);
image->addNode(paintLayer1, image->rootLayer());
image->addNode(paintLayer2, image->rootLayer());
image->initialRefreshGraph();
QImage refImage(QString(FILES_DATA_DIR) + QDir::separator() + "subgraphing_without_updating.png");
{
QImage resultImage = image->projection()->convertToQImage(0);
QCOMPARE(resultImage, refImage);
}
QRect cropRect(image->bounds());
KisRefreshSubtreeWalker walker(cropRect);
KisAsyncMerger merger;
walker.collectRects(paintLayer2, image->bounds());
merger.startMerge(walker);
{
QImage resultImage = image->projection()->convertToQImage(0);
QCOMPARE(resultImage, refImage);
}
}
KisImageSP createImage(KisUndoStore *undoStore,
KisPaintLayerSP &paintLayer1,
KisPaintLayerSP &paintLayer2)
{
const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(undoStore, 300, 300, cs, "test");
QRect fillRect1(50,50,100,100);
QRect fillRect2(75,75,50,50);
paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
paintLayer1->paintDevice()->fill(fillRect1, KoColor(Qt::white, cs));
paintLayer2->paintDevice()->fill(fillRect2, KoColor(Qt::red, cs));
image->addNode(paintLayer1, image->rootLayer());
image->addNode(paintLayer2, image->rootLayer());
image->initialRefreshGraph();
return image;
}
void KisLayerTest::testCreation()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->colorSpace("RGBA", 0);
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "layer test");
KisLayerSP layer = new TestLayer(image, "test", OPACITY_OPAQUE);
QCOMPARE(layer->name(), QString("test"));
QCOMPARE(layer->opacity(), OPACITY_OPAQUE);
QCOMPARE(layer->image(), image);
QCOMPARE(layer->colorSpace(), image->colorSpace());
QCOMPARE(layer->visible(), true);
QCOMPARE(layer->userLocked(), false);
QCOMPARE(layer->temporary(), false);
image->addNode(layer, image->rootLayer());
QBitArray channels(4);
channels.fill(true);
layer->setChannelFlags(channels);
QVERIFY(layer->channelFlags().count() == 4);
QCOMPARE(layer->channelFlags().at(0), true);
QCOMPARE(layer->channelFlags().at(1), true);
QCOMPARE(layer->channelFlags().at(2), true);
QCOMPARE(layer->channelFlags().at(3), true);
layer->setOpacity(OPACITY_TRANSPARENT);
QCOMPARE(layer->opacity(), OPACITY_TRANSPARENT);
layer->setPercentOpacity(100);
QCOMPARE(layer->opacity(), OPACITY_OPAQUE);
layer->setPercentOpacity(0);
QCOMPARE(layer->opacity(), OPACITY_TRANSPARENT);
}
void KisLayerTest::testOrdering()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->colorSpace("RGBA", 0);
KisImageSP image = new KisImage(0, 512, 512, colorSpace, "layer test");
KisLayerSP layer1 = new TestLayer(image, "layer1", OPACITY_OPAQUE);
KisLayerSP layer2 = new TestLayer(image, "layer2", OPACITY_OPAQUE);
KisLayerSP layer3 = new TestLayer(image, "layer3", OPACITY_OPAQUE);
QVERIFY(layer1->name() == "layer1");
QVERIFY(layer2->name() == "layer2");
QVERIFY(layer3->name() == "layer3");
/*
+---------+
| layer 2 |
| layer 3 |
| layer 1 |
|root |
+---------+
*/
QVERIFY(image->addNode(layer1, image->rootLayer()));
QVERIFY(image->addNode(layer2, image->rootLayer()));
QVERIFY(image->addNode(layer3, image->rootLayer(), layer1));
QCOMPARE((int) image->nlayers(), 4);
QVERIFY(layer1->parent() == image->root());
QVERIFY(layer2->parent() == image->root());
QVERIFY(layer3->parent() == image->root());
QVERIFY(image->rootLayer()->firstChild() == layer1.data());
QVERIFY(image->rootLayer()->lastChild() == layer2.data());
QVERIFY(image->rootLayer()->at(0) == layer1.data());
QVERIFY(image->rootLayer()->at(1) == layer3.data());
QVERIFY(image->rootLayer()->at(2) == layer2.data());
QVERIFY(image->rootLayer()->index(layer1) == 0);
QVERIFY(image->rootLayer()->index(layer3) == 1);
QVERIFY(image->rootLayer()->index(layer2) == 2);
QVERIFY(layer3->prevSibling() == layer1.data());
QVERIFY(layer2->prevSibling() == layer3.data());
QVERIFY(layer1->prevSibling() == 0);
QVERIFY(layer3->nextSibling() == layer2.data());
QVERIFY(layer2->nextSibling() == 0);
QVERIFY(layer1->nextSibling() == layer3.data());
/*
+---------+
| layer 3 |
| layer 2 |
| layer 1 |
|root |
+---------+
*/
QVERIFY(image->moveNode(layer2, image->rootLayer(), layer1));
QVERIFY(image->rootLayer()->at(0) == layer1.data());
QVERIFY(image->rootLayer()->at(1) == layer2.data());
QVERIFY(image->rootLayer()->at(2) == layer3.data());
QVERIFY(image->rootLayer()->firstChild() == layer1.data());
QVERIFY(image->rootLayer()->lastChild() == layer3.data());
QVERIFY(image->rootLayer()->index(layer1) == 0);
QVERIFY(image->rootLayer()->index(layer2) == 1);
QVERIFY(image->rootLayer()->index(layer3) == 2);
QVERIFY(layer3->prevSibling() == layer2.data());
QVERIFY(layer2->prevSibling() == layer1.data());
QVERIFY(layer1->prevSibling() == 0);
QVERIFY(layer3->nextSibling() == 0);
QVERIFY(layer2->nextSibling() == layer3.data());
QVERIFY(layer1->nextSibling() == layer2.data());
}
KoFilter::ConversionStatus KisOpenEXRImport::convert(const QByteArray& from, const QByteArray& to)
{
if (from != "image/x-exr" || to != "application/x-krita") {
return KoFilter::NotImplemented;
}
dbgFile << "\n\n\nKrita importing from OpenEXR";
KisDoc2 * doc = dynamic_cast<KisDoc2*>(m_chain -> outputDocument());
if (!doc) {
return KoFilter::CreationError;
}
doc -> prepareForImport();
QString filename = m_chain -> inputFile();
if (filename.isEmpty()) {
return KoFilter::FileNotFound;
}
RgbaInputFile file(QFile::encodeName(filename));
Box2i dataWindow = file.dataWindow();
Box2i displayWindow = file.displayWindow();
dbgFile << "Data window:" << QRect(dataWindow.min.x, dataWindow.min.y, dataWindow.max.x - dataWindow.min.x + 1, dataWindow.max.y - dataWindow.min.y + 1);
dbgFile << "Display window:" << QRect(displayWindow.min.x, displayWindow.min.y, displayWindow.max.x - displayWindow.min.x + 1, displayWindow.max.y - displayWindow.min.y + 1);
int imageWidth = displayWindow.max.x - displayWindow.min.x + 1;
int imageHeight = displayWindow.max.y - displayWindow.min.y + 1;
QString imageName = "Imported from OpenEXR";
int dataWidth = dataWindow.max.x - dataWindow.min.x + 1;
int dataHeight = dataWindow.max.y - dataWindow.min.y + 1;
const KoColorSpace *cs = static_cast<const KoColorSpace *>((KoColorSpaceRegistry::instance()->colorSpace(KoID("RgbAF16", ""), "")));
if (cs == 0) {
return KoFilter::InternalError;
}
doc -> undoAdapter() -> setUndo(false);
KisImageSP image = new KisImage(doc->undoAdapter(), imageWidth, imageHeight, cs, imageName);
if (!image) {
return KoFilter::CreationError;
}
image->lock();
KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE, cs);
layer->setCompositeOp(COMPOSITE_OVER);
if (!layer) {
return KoFilter::CreationError;
}
Q3MemArray<Rgba> pixels(dataWidth);
for (int y = 0; y < dataHeight; ++y) {
file.setFrameBuffer(pixels.data() - dataWindow.min.x - (dataWindow.min.y + y) * dataWidth, 1, dataWidth);
file.readPixels(dataWindow.min.y + y);
KisHLineIterator it = layer->paintDevice()->createHLineIterator(dataWindow.min.x, dataWindow.min.y + y, dataWidth);
Rgba *rgba = pixels.data();
while (!it.isDone()) {
// XXX: For now unmultiply the alpha, though compositing will be faster if we
// keep it premultiplied.
half unmultipliedRed = rgba -> r;
half unmultipliedGreen = rgba -> g;
half unmultipliedBlue = rgba -> b;
if (rgba -> a >= HALF_EPSILON) {
unmultipliedRed /= rgba -> a;
unmultipliedGreen /= rgba -> a;
unmultipliedBlue /= rgba -> a;
}
setPixel(it.rawData(), unmultipliedRed, unmultipliedGreen, unmultipliedBlue, rgba -> a);
++it;
++rgba;
}
}
image->addNode(layer.data(), image->rootLayer().data());
layer->setDirty();
doc -> setCurrentImage(image);
doc -> undoAdapter() -> setUndo(true);
doc -> setModified(false);
image->unlock();
return KoFilter::OK;
}
void KisAsyncMergerTest::testFullRefreshWithClones()
{
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 128, 128, colorSpace, "clones test");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
device1->fill(image->bounds(), KoColor( Qt::white, colorSpace));
KisFilterSP filter = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
Q_ASSERT(configuration);
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisFilterMaskSP invertMask1 = new KisFilterMask();
invertMask1->initSelection(0, paintLayer1);
invertMask1->setFilter(configuration);
KisLayerSP cloneLayer1 = new KisCloneLayer(paintLayer1, image, "clone_of_1", OPACITY_OPAQUE_U8);
/**
* The clone layer must have a projection to allow us
* to read what it got from its source. Just shift it.
*/
cloneLayer1->setX(10);
cloneLayer1->setY(10);
image->addNode(cloneLayer1, image->rootLayer());
image->addNode(paintLayer1, image->rootLayer());
image->addNode(invertMask1, paintLayer1);
QRect cropRect(image->bounds());
KisFullRefreshWalker walker(cropRect);
KisAsyncMerger merger;
walker.collectRects(image->rootLayer(), image->bounds());
merger.startMerge(walker);
// Wait for additional jobs generated by the clone are finished
image->waitForDone();
QRect filledRect(10, 10,
image->width() - cloneLayer1->x(),
image->height() - cloneLayer1->y());
const int pixelSize = device1->pixelSize();
const int numPixels = filledRect.width() * filledRect.height();
QByteArray bytes(numPixels * pixelSize, 13);
cloneLayer1->projection()->readBytes((quint8*)bytes.data(), filledRect);
KoColor desiredPixel(Qt::black, colorSpace);
quint8 *srcPtr = (quint8*)bytes.data();
quint8 *dstPtr = desiredPixel.data();
for(int i = 0; i < numPixels; i++) {
if(memcmp(srcPtr, dstPtr, pixelSize)) {
qDebug() << "expected:" << dstPtr[0] << dstPtr[1] << dstPtr[2] << dstPtr[3];
qDebug() << "result: " << srcPtr[0] << srcPtr[1] << srcPtr[2] << srcPtr[3];
QFAIL("Failed to compare pixels");
}
srcPtr += pixelSize;
}
}
void KisAsyncMergerTest::testMerger()
{
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 640, 441, colorSpace, "merger test");
QImage sourceImage1(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QImage sourceImage2(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
QImage referenceProjection(QString(FILES_DATA_DIR) + QDir::separator() + "merged_hakonepa.png");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
KisPaintDeviceSP device2 = new KisPaintDevice(colorSpace);
device1->convertFromQImage(sourceImage1, 0, 0, 0);
device2->convertFromQImage(sourceImage2, 0, 0, 0);
KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
Q_ASSERT(configuration);
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8, device2);
KisLayerSP groupLayer = new KisGroupLayer(image, "group", 200/*OPACITY_OPAQUE*/);
KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
image->addNode(paintLayer1, image->rootLayer());
image->addNode(groupLayer, image->rootLayer());
image->addNode(paintLayer2, groupLayer);
image->addNode(blur1, groupLayer);
QRect testRect1(0,0,100,441);
QRect testRect2(100,0,400,441);
QRect testRect3(500,0,140,441);
QRect testRect4(580,381,40,40);
QRect cropRect(image->bounds());
KisMergeWalker walker(cropRect);
KisAsyncMerger merger;
walker.collectRects(paintLayer2, testRect1);
merger.startMerge(walker);
walker.collectRects(paintLayer2, testRect2);
merger.startMerge(walker);
walker.collectRects(paintLayer2, testRect3);
merger.startMerge(walker);
walker.collectRects(paintLayer2, testRect4);
merger.startMerge(walker);
// Old style merging: has artefacts at x=100 and x=500
// And should be turned on inside KisLayer
/* paintLayer2->setDirty(testRect1);
QTest::qSleep(3000);
paintLayer2->setDirty(testRect2);
QTest::qSleep(3000);
paintLayer2->setDirty(testRect3);
QTest::qSleep(3000);
paintLayer2->setDirty(testRect4);
QTest::qSleep(3000);
*/
KisLayerSP rootLayer = image->rootLayer();
QVERIFY(rootLayer->exactBounds() == image->bounds());
QImage resultProjection = rootLayer->projection()->convertToQImage(0);
resultProjection.save(QString(FILES_OUTPUT_DIR) + QDir::separator() + "actual_merge_result.png");
QPoint pt;
QVERIFY(TestUtil::compareQImages(pt, resultProjection, referenceProjection, 1));
}
