bool KisOpenGLImageTextures::imageCanUseHDRExposureProgram(KisImageSP image)
{
#ifdef HAVE_GLEW
if (!image->colorSpace()->hasHighDynamicRange()) {
return false;
}
KisConfig cfg;
if (!cfg.useOpenGLShaders()) {
return false;
}
if (HDRExposureProgram == 0) {
return false;
}
if (!HDRExposureProgram->isValid()) {
return false;
}
if (!haveHDRTextureFormat(image->colorSpace())) {
return false;
}
return true;
#else
Q_UNUSED(image);
return false;
#endif
}
void KisProjectionTest::testDirty()
{
KisImageSP image = new KisImage(0, 1000, 1000, 0, "layer tests");
// Two layers so the single-layer-is-rootlayer optimization doesn't kick in
KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
KisLayerSP layer2 = new KisPaintLayer(image, "layer 2", OPACITY_OPAQUE_U8);
image->addNode(layer);
image->addNode(layer2);
KisFillPainter gc(layer2->paintDevice());
KoColor c(Qt::red, layer2->colorSpace());
gc.fillRect(0, 0, 1000, 1000, c);
gc.end();
layer2->setDirty(gc.takeDirtyRegion());
// wait a little for the projection to finish
QTest::qSleep(250);
// Check that the projection is totally redistribute
KisSequentialConstIterator it(image->projection(), QRect(0, 0, 1000, 1000));
do {
QColor c;
image->colorSpace()->toQColor(it.oldRawData(), &c, image->profile());
QVERIFY(c == Qt::red);
} while (it.nextPixel());
}
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 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 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);
}
bool KisOpenGLImageTextures::imageCanShareTextures(KisImageSP image)
{
return !image->colorSpace()->hasHighDynamicRange() || imageCanUseHDRExposureProgram(image);
}
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;
}
bool doPartialTests(const QString &prefix, KisImageSP image, KisLayerSP paintLayer,
KisLayerSP visibilityToggleLayer, KisTransformMaskSP mask)
{
TestUtil::ExternalImageChecker chk(prefix, "transform_mask_updates");
bool result = true;
QRect refRect = image->bounds();
int testIndex = 1;
QString testName;
for (int y = 0; y < refRect.height(); y += 512) {
for (int x = 0; x < refRect.width(); x += 512) {
QRect rc(x, y, 512, 512);
if (rc.right() > refRect.right()) {
rc.setRight(refRect.right());
if (rc.isEmpty()) continue;
}
if (rc.bottom() > refRect.bottom()) {
rc.setBottom(refRect.bottom());
if (rc.isEmpty()) continue;
}
paintLayer->setDirty(rc);
image->waitForDone();
testName = QString("tm_%1_partial_%2_%3").arg(testIndex++).arg(x).arg(y);
result &= chk.checkImage(image, testName);
}
}
// initial update of the mask to clear the unused portions of the projection
// (it updates only when we call set dirty on the mask itself, which happens
// in Krita right after the addition of the mask onto a layer)
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_initial_mask_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
// start layer visibility testing
paintLayer->setVisible(false);
paintLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_layer_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
paintLayer->setVisible(true);
paintLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_layer_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
if (paintLayer != visibilityToggleLayer) {
visibilityToggleLayer->setVisible(false);
visibilityToggleLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_extra_layer_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
visibilityToggleLayer->setVisible(true);
visibilityToggleLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_extra_layer_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
}
// toggle mask visibility
mask->setVisible(false);
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
mask->setVisible(true);
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
// entire bounds update
// no clearing, just don't hang up
paintLayer->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
// no clearing, just don't hang up
mask->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_mask_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
if (paintLayer != visibilityToggleLayer) {
// no clearing, just don't hang up
visibilityToggleLayer->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_extra_layer_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
}
QRect fillRect;
// partial updates outside
fillRect = QRect(-100, 0.5 * refRect.height(), 50, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
fillRect = QRect(0.5 * refRect.width(), -100, 100, 50);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
fillRect = QRect(refRect.width() + 50, 0.2 * refRect.height(), 50, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
// partial update inside
fillRect = QRect(0.5 * refRect.width() - 50, 0.5 * refRect.height() - 50, 100, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_inside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
// clear explicitly
image->projection()->clear();
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
KisDumbTransformMaskParams *params =
dynamic_cast<KisDumbTransformMaskParams*>(mask->transformParams().data());
QTransform t = params->testingGetTransform();
t *= QTransform::fromTranslate(400, 300);
params->testingSetTransform(t);
mask->setTransformParams(mask->transformParams());
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_dirty_after_offset").arg(testIndex++);
result &= chk.checkImage(image, testName);
return result;
}