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 KritaShape::tryLoadFromImageData(KoImageData *data)
{
if (data == 0)
return;
// TODO maybe we want to use the image rawData for that
QImage image = data->image();
if (image.isNull())
return;
delete m_d->doc;
m_d->doc = new KisDoc2(0, 0, false);
connect(m_d->doc, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
// Create an empty image
KisImageSP img = m_d->doc->newImage(i18n("Converted from KoImageData"), image.width(), image.height(), 0);
// Convert the QImage to a paint device
KisPaintLayer * layer = dynamic_cast<KisPaintLayer*>(img->root()->firstChild().data());
if (layer)
layer->paintDevice()->convertFromQImage(image, "", 0, 0);
// emits sigLoadingFinished
m_d->doc->setCurrentImage(img);
}
void testObligeSingleChildImpl(bool transpDefaultPixel)
{
QString id = !transpDefaultPixel ?
"single_layer_no_channel_flags_nontransp_def_pixel.kra" :
"single_layer_no_channel_flags_transp_def_pixel.kra";
QString fileName = TestUtil::fetchDataFileLazy(id);
KisDocument *doc = KisPart::instance()->createDocument();
doc->loadNativeFormat(fileName);
KisImageSP image = doc->image();
QVERIFY(image);
QCOMPARE(image->nlayers(), 2);
KisNodeSP root = image->root();
KisNodeSP child = root->firstChild();
QVERIFY(child);
QCOMPARE(root->original(), root->projection());
if (transpDefaultPixel) {
QCOMPARE(root->original(), child->projection());
} else {
QVERIFY(root->original() != child->projection());
}
delete doc;
}
void KisKraLoaderTest::testLoading()
{
KisDocument *doc = KisPart::instance()->createDocument();
doc->loadNativeFormat(QString(FILES_DATA_DIR) + QDir::separator() + "load_test.kra");
KisImageSP image = doc->image();
image->lock();
QCOMPARE(image->nlayers(), 12);
QCOMPARE(doc->documentInfo()->aboutInfo("title"), QString("test image for loading"));
QCOMPARE(image->height(), 753);
QCOMPARE(image->width(), 1000);
QCOMPARE(image->colorSpace()->id(), KoColorSpaceRegistry::instance()->rgb8()->id());
KisNodeSP node = image->root()->firstChild();
QVERIFY(node);
QCOMPARE(node->name(), QString("Background"));
QVERIFY(node->inherits("KisPaintLayer"));
node = node->nextSibling();
QVERIFY(node);
QCOMPARE(node->name(), QString("Group 1"));
QVERIFY(node->inherits("KisGroupLayer"));
QCOMPARE((int) node->childCount(), 2);
delete doc;
}
void KisKraLoaderTest::testLoadAnimated()
{
KisDocument *doc = KisPart::instance()->createDocument();
doc->loadNativeFormat(QString(FILES_DATA_DIR) + QDir::separator() + "load_test_animation.kra");
KisImageSP image = doc->image();
KisNodeSP node1 = image->root()->firstChild();
KisNodeSP node2 = node1->nextSibling();
QVERIFY(node1->inherits("KisPaintLayer"));
QVERIFY(node2->inherits("KisPaintLayer"));
KisPaintLayerSP layer1 = qobject_cast<KisPaintLayer*>(node1.data());
KisPaintLayerSP layer2 = qobject_cast<KisPaintLayer*>(node2.data());
KisKeyframeChannel *channel1 = layer1->getKeyframeChannel(KisKeyframeChannel::Content.id());
KisKeyframeChannel *channel2 = layer2->getKeyframeChannel(KisKeyframeChannel::Content.id());
QCOMPARE(channel1->keyframeCount(), 3);
QCOMPARE(channel2->keyframeCount(), 1);
QCOMPARE(image->animationInterface()->framerate(), 17);
QCOMPARE(image->animationInterface()->fullClipRange(), KisTimeRange::fromTime(15, 45));
QCOMPARE(image->animationInterface()->currentTime(), 19);
KisPaintDeviceSP dev = layer1->paintDevice();
const KoColorSpace *cs = dev->colorSpace();
KoColor transparent(Qt::transparent, cs);
KoColor white(Qt::white, cs);
KoColor red(Qt::red, cs);
image->animationInterface()->switchCurrentTimeAsync(0);
image->waitForDone();
QCOMPARE(dev->exactBounds(), QRect(506, 378, 198, 198));
QCOMPARE(dev->x(), -26);
QCOMPARE(dev->y(), -128);
QCOMPARE(dev->defaultPixel(), transparent);
image->animationInterface()->switchCurrentTimeAsync(20);
image->waitForDone();
QCOMPARE(dev->nonDefaultPixelArea(), QRect(615, 416, 129, 129));
QCOMPARE(dev->x(), 502);
QCOMPARE(dev->y(), 224);
QCOMPARE(dev->defaultPixel(), white);
image->animationInterface()->switchCurrentTimeAsync(30);
image->waitForDone();
QCOMPARE(dev->nonDefaultPixelArea(), QRect(729, 452, 45, 44));
QCOMPARE(dev->x(), 645);
QCOMPARE(dev->y(), -10);
QCOMPARE(dev->defaultPixel(), red);
}
void KisImageTest::testConvertImageColorSpace()
{
const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
Q_ASSERT(configuration);
KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
image->addNode(paint1, image->root());
image->addNode(blur1, image->root());
image->refreshGraph();
const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
image->lock();
image->convertImageColorSpace(cs16,
KoColorConversionTransformation::InternalRenderingIntent,
KoColorConversionTransformation::InternalConversionFlags);
image->unlock();
QVERIFY(*cs16 == *image->colorSpace());
QVERIFY(*cs16 == *image->root()->colorSpace());
QVERIFY(*cs16 == *paint1->colorSpace());
QVERIFY(*cs16 == *blur1->colorSpace());
QVERIFY(!image->root()->compositeOp());
QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
image->refreshGraph();
}
void KisImageTest::testGlobalSelection()
{
const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
QCOMPARE(image->globalSelection(), KisSelectionSP(0));
QCOMPARE(image->canReselectGlobalSelection(), false);
QCOMPARE(image->root()->childCount(), 0U);
KisSelectionSP selection1 = new KisSelection(new KisDefaultBounds(image));
KisSelectionSP selection2 = new KisSelection(new KisDefaultBounds(image));
image->setGlobalSelection(selection1);
QCOMPARE(image->globalSelection(), selection1);
QCOMPARE(image->canReselectGlobalSelection(), false);
QCOMPARE(image->root()->childCount(), 1U);
image->setGlobalSelection(selection2);
QCOMPARE(image->globalSelection(), selection2);
QCOMPARE(image->canReselectGlobalSelection(), false);
QCOMPARE(image->root()->childCount(), 1U);
image->deselectGlobalSelection();
QCOMPARE(image->globalSelection(), KisSelectionSP(0));
QCOMPARE(image->canReselectGlobalSelection(), true);
QCOMPARE(image->root()->childCount(), 0U);
image->reselectGlobalSelection();
QCOMPARE(image->globalSelection(), selection2);
QCOMPARE(image->canReselectGlobalSelection(), false);
QCOMPARE(image->root()->childCount(), 1U);
// mixed deselecting/setting/reselecting
image->deselectGlobalSelection();
QCOMPARE(image->globalSelection(), KisSelectionSP(0));
QCOMPARE(image->canReselectGlobalSelection(), true);
QCOMPARE(image->root()->childCount(), 0U);
image->setGlobalSelection(selection1);
QCOMPARE(image->globalSelection(), selection1);
QCOMPARE(image->canReselectGlobalSelection(), false);
QCOMPARE(image->root()->childCount(), 1U);
}
void test(const QString &testname, KisProcessingVisitorSP visitor) {
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisImageSP image = createImage(undoStore);
image->initialRefreshGraph();
QVERIFY(checkLayersInitial(image));
KisProcessingApplicator applicator(image, image->root(),
KisProcessingApplicator::RECURSIVE);
applicator.applyVisitor(visitor);
applicator.end();
image->waitForDone();
QVERIFY(checkLayers(image, testname));
undoStore->undo();
image->waitForDone();
QVERIFY(checkLayersInitial(image));
}
/**
* This benchmark runs a series of huge strokes on a canvas with a
* particular configuration of the swapper/pooler and history
* management. After the test is done you can visualize the results
* with the GNU Octave. Please use kis_low_memory_show_report.m file
* for that.
*/
void KisLowMemoryBenchmark::benchmarkWideArea(const QString presetFileName,
const QRectF &rect, qreal vstep,
int numCycles,
bool createTransaction,
int hardLimitMiB,
int softLimitMiB,
int poolLimitMiB,
int index)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(QString(FILES_DATA_DIR) + QDir::separator() + presetFileName);
LOAD_PRESET_OR_RETURN(preset, presetFileName);
/**
* Initialize image and painter
*/
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, HUGE_IMAGE_SIZE, HUGE_IMAGE_SIZE, colorSpace, "stroke sample image", true);
KisLayerSP layer = new KisPaintLayer(image, "temporary for stroke sample", OPACITY_OPAQUE_U8, colorSpace);
KisLayerSP layerExtra = new KisPaintLayer(image, "temporary for threading", OPACITY_OPAQUE_U8, colorSpace);
image->addNode(layer, image->root());
image->addNode(layerExtra, image->root());
KisPainter *painter = new KisPainter(layer->paintDevice());
painter->setPaintColor(KoColor(Qt::black, colorSpace));
painter->setPaintOpPreset(preset, layer, image);
/**
* A simple adapter that will store all the transactions for us
*/
KisSurrogateUndoAdapter undoAdapter;
/**
* Reset configuration to the desired settings
*/
KisImageConfig config;
qreal oldHardLimit = config.memoryHardLimitPercent();
qreal oldSoftLimit = config.memorySoftLimitPercent();
qreal oldPoolLimit = config.memoryPoolLimitPercent();
const qreal _MiB = 100.0 / KisImageConfig::totalRAM();
config.setMemoryHardLimitPercent(hardLimitMiB * _MiB);
config.setMemorySoftLimitPercent(softLimitMiB * _MiB);
config.setMemoryPoolLimitPercent(poolLimitMiB * _MiB);
KisTileDataStore::instance()->testingRereadConfig();
/**
* Create an empty the log file
*/
QString fileName;
fileName = QString("log_%1_%2_%3_%4_%5.txt")
.arg(createTransaction)
.arg(hardLimitMiB)
.arg(softLimitMiB)
.arg(poolLimitMiB)
.arg(index);
QFile logFile(fileName);
logFile.open(QFile::WriteOnly | QFile::Truncate);
QTextStream logStream(&logFile);
logStream.setFieldWidth(10);
logStream.setFieldAlignment(QTextStream::AlignRight);
/**
* Start painting on the image
*/
QTime cycleTime;
QTime lineTime;
cycleTime.start();
lineTime.start();
qreal rectBottom = rect.y() + rect.height();
for (int i = 0; i < numCycles; i++) {
cycleTime.restart();
QLineF line(rect.topLeft(), rect.topLeft() + QPointF(rect.width(), 0));
if (createTransaction) {
painter->beginTransaction();
}
KisDistanceInformation currentDistance;
while(line.y1() < rectBottom) {
lineTime.restart();
KisPaintInformation pi1(line.p1(), 0.0);
KisPaintInformation pi2(line.p2(), 1.0);
painter->paintLine(pi1, pi2, ¤tDistance);
painter->device()->setDirty(painter->takeDirtyRegion());
logStream << "L 1" << i << lineTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction << endl;
line.translate(0, vstep);
}
painter->device()->setDirty(painter->takeDirtyRegion());
if (createTransaction) {
painter->endTransaction(&undoAdapter);
}
// comment/uncomment to emulate user waiting after the stroke
QTest::qSleep(1000);
logStream << "C 2" << i << cycleTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction
<< config.memoryHardLimitPercent() / _MiB
<< config.memorySoftLimitPercent() / _MiB
<< config.memoryPoolLimitPercent() / _MiB << endl;
}
config.setMemoryHardLimitPercent(oldHardLimit * _MiB);
config.setMemorySoftLimitPercent(oldSoftLimit * _MiB);
config.setMemoryPoolLimitPercent(oldPoolLimit * _MiB);
delete painter;
}
void KisOcioDisplayFilterTest::test()
{
KisExposureGammaCorrectionInterface *egInterface =
new KisDumbExposureGammaCorrectionInterface();
OcioDisplayFilter filter(egInterface);
QString configFile = TestUtil::fetchDataFileLazy("./psyfiTestingConfig-master/config.ocio");
dbgKrita << ppVar(configFile);
Q_ASSERT(QFile::exists(configFile));
OCIO::ConstConfigRcPtr ocioConfig =
OCIO::Config::CreateFromFile(configFile.toUtf8());
filter.config = ocioConfig;
filter.inputColorSpaceName = ocioConfig->getColorSpaceNameByIndex(0);
filter.displayDevice = ocioConfig->getDisplay(1);
filter.view = ocioConfig->getView(filter.displayDevice, 0);
filter.gamma = 1.0;
filter.exposure = 0.0;
filter.swizzle = RGBA;
filter.blackPoint = 0.0;
filter.whitePoint = 1.0;
filter.forceInternalColorManagement = false;
filter.setLockCurrentColorVisualRepresentation(false);
filter.updateProcessor();
dbgKrita << ppVar(filter.inputColorSpaceName);
dbgKrita << ppVar(filter.displayDevice);
dbgKrita << ppVar(filter.view);
dbgKrita << ppVar(filter.gamma);
dbgKrita << ppVar(filter.exposure);
const KoColorSpace *paintingCS =
KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
KisImageSP image = utils::createImage(0, QSize(100, 100));
image->convertImageColorSpace(paintingCS, KoColorConversionTransformation::InternalRenderingIntent, KoColorConversionTransformation::InternalConversionFlags);
image->waitForDone();
dbgKrita << ppVar(paintingCS) << ppVar(image->root()->firstChild()->colorSpace());
KoCanvasResourceManager *resourceManager =
utils::createResourceManager(image,
image->root(), "");
KisDisplayColorConverter converter(resourceManager, 0);
dbgKrita << ppVar(image->root()->firstChild());
QVariant v;
v.setValue(KisNodeWSP(image->root()->firstChild()));
resourceManager->setResource(KisCanvasResourceProvider::CurrentKritaNode, v);
converter.setDisplayFilter(&filter);
dbgKrita << ppVar(converter.paintingColorSpace());
{
QColor refColor(255, 128, 0);
KoColor realColor = converter.approximateFromRenderedQColor(refColor);
QColor roundTripColor = converter.toQColor(realColor);
dbgKrita << ppVar(refColor);
dbgKrita << ppVar(realColor.colorSpace()) << ppVar(KoColor::toQString(realColor));
dbgKrita << ppVar(roundTripColor);
}
{
KoColor realColor(Qt::red, paintingCS);
QColor roundTripColor = converter.toQColor(realColor);
dbgKrita << ppVar(realColor.colorSpace()) << ppVar(KoColor::toQString(realColor));
dbgKrita << ppVar(roundTripColor);
}
}
void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisImageSP image = createTrivialImage(undoStore);
image->initialRefreshGraph();
KisNodeSP paint1 = findNode(image->root(), "paint1");
QVERIFY(paint1->extent().isEmpty());
KisPainter gc(paint1->paintDevice());
QScopedPointer<KoCanvasResourceManager> manager(
utils::createResourceManager(image, 0, m_presetFileName));
KisPaintOpPresetSP preset =
manager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
preset->settings()->setCanvasRotation(rotation);
preset->settings()->setCanvasMirroring(mirrorY, mirrorX);
if (mirrorDabX || mirrorDabY) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureMirrorOption mirrorOption;
mirrorOption.readOptionSetting(settings);
mirrorOption.setChecked(true);
mirrorOption.setCurveUsed(false);
mirrorOption.enableHorizontalMirror(mirrorDabX);
mirrorOption.enableVerticalMirror(mirrorDabY);
mirrorOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
if (dabRotation != 0.0) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureRotationOption rotationOption;
rotationOption.readOptionSetting(settings);
rotationOption.setChecked(true);
rotationOption.setCurveUsed(false);
rotationOption.setValue(dabRotation / 360.0);
rotationOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
QString testName =
QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
.arg(mirrorY)
.arg(mirrorX)
.arg(rotation)
.arg(mirrorDabX)
.arg(mirrorDabY)
.arg(std::fmod(360.0 - dabRotation, 360.0))
.arg(m_prefix);
KisResourcesSnapshotSP resources =
new KisResourcesSnapshot(image,
paint1,
manager.data());
resources->setupPainter(&gc);
doPaint(gc);
checkOneLayer(image, paint1, testName);
}
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());
}
