ZacharyZhang-NY/OmaPhoto
1
1 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity
Files
d1fc510e7815e724b9a9f661efac27671667aad8
OmaPhoto/tests/EffectsPreviewCacheTests.cpp
T

424 lines
19 KiB
C++
Raw Blame History

#include "Document/BrushStroke.h"
#include "Document/LayerEffects+Renderer.h"
#include "Rendering/EffectsPreviewCache.h"
#include "RenderFixtures.h"
#include <QThread>
#include <QElapsedTimer>
#include <QtTest>
#include <memory>
// Swift's EffectsPreviewCache: one worker, a delay, the newest request.
namespace {
QImage filled(int width, int height, const QColor &colour)
{
QImage image = BrushRaster::context(width, height, false);
image.fill(colour);
return image;
}
LayerEffects outline(double size)
{
LayerEffects effects;
effects.stroke = StrokeEffect{.size = size, .red = 1, .green = 1, .blue = 0, .opacity = 1};
return effects;
}
ImageLayer layerOf(const QImage &image, const LayerEffects &effects)
{
ImageLayer layer(ImportedImage(image, QImage(), QStringLiteral("Layer")), QPointF(0, 0));
layer.effects = effects;
return layer;
}
// Counts landings, and outlives the cache that calls it.
struct Landings {
std::shared_ptr<int> count = std::make_shared<int>(0);
std::function<void()> callback() const
{
return [count = count] { ++*count; };
}
};
std::optional<EffectsPreviewCache::Result> ask(EffectsPreviewCache &cache, const ImageLayer &layer, const Landings &landings,
const std::optional<QImage> &mask = std::nullopt,
const std::optional<LayerTransform> &placement = std::nullopt)
{
return cache.preview(layer, mask, layer.transform, placement, landings.callback());
}
// The result once the worker has had its turn.
EffectsPreviewCache::Result landed(EffectsPreviewCache &cache, const ImageLayer &layer, const Landings &landings, int count)
{
if (!QTest::qWaitFor([&] { return *landings.count == count; }, 5000))
throw std::runtime_error("no preview landed");
return cache.rendered(layer.id).value();
}
}
class EffectsPreviewCacheTests : public QObject {
Q_OBJECT
private slots:
void aPreviewLandsAfterItsDelayAsTheRendererDrawsIt();
void movingTheLayerKeepsThePreviewUnlessAMaskIsPlaced();
void settingsKeepTheLastPreviewButNewPixelsDropIt();
void onlyTheNewestRequestLands();
void aResultLandsOnlyOnTheRequestThatAskedForIt();
void seedsStandInUntilTheWorkerCatchesUp();
void preparingDropsLayersWithoutEffectsAndSharesTheBudget();
void aMaskHidesPixelsInTheReducedPreview();
void aReducedPreviewScalesEveryLength();
void aClosedCacheLandsNothing();
void undoneStepsReuseTheirEffects();
void renderNowRendersAtThePreviewSize();
};
void EffectsPreviewCacheTests::aPreviewLandsAfterItsDelayAsTheRendererDrawsIt()
{
EffectsPreviewCache cache;
const QImage image = filled(20, 10, QColor(0, 0, 255));
const ImageLayer layer = layerOf(image, outline(3));
const Landings landings;
QElapsedTimer clock;
clock.start();
QVERIFY(!ask(cache, layer, landings) && !cache.rendered(layer.id));
const EffectsPreviewCache::Result result = landed(cache, layer, landings, 1);
QVERIFY(clock.elapsed() >= 60);
// Small enough to render whole: the export's own pixels.
const LayerEffectsRenderer::Rendered expected = LayerEffectsRenderer::render(image, std::nullopt, outline(3));
QVERIFY(result.image == expected.image && result.inset == 5 && expected.inset == 5 && !result.placement);
// Asked again, the same pixels come back and nothing renders.
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), result.image.cacheKey());
QTest::qWait(150);
QCOMPARE(*landings.count, 1);
// No effects, or none shown: nothing, and the entry goes.
ImageLayer hidden = layer;
hidden.effects.value().stroke.value().enabled = false;
QVERIFY(!ask(cache, hidden, landings) && !cache.rendered(layer.id));
QTest::qWait(150);
QVERIFY(!cache.rendered(layer.id));
// No pixels, or effects out of bounds: nothing either.
ImageLayer blank(QStringLiteral("Blank"), QSizeF(20, 10));
blank.effects = outline(3);
QVERIFY(!ask(cache, blank, landings));
QVERIFY(!ask(cache, layerOf(image, outline(600)), landings));
QTest::qWait(150);
QCOMPARE(*landings.count, 1);
}
void EffectsPreviewCacheTests::movingTheLayerKeepsThePreviewUnlessAMaskIsPlaced()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
layer.mask = LayerMask(LayerMask::assetFrom(gray(20, 10, 255)));
const QImage mask = layer.mask.value().enabledImage().value();
const Landings landings;
ask(cache, layer, landings, mask);
const qint64 first = landed(cache, layer, landings, 1).image.cacheKey();
// Effects render in layer pixels: a move only moves them.
layer.transform.origin = QPointF(7, 3);
QCOMPARE(ask(cache, layer, landings, mask).value().image.cacheKey(), first);
QTest::qWait(150);
QCOMPARE(*landings.count, 1);
// A mask placed apart resamples, the last preview shown meanwhile.
const LayerTransform placement = placedAt(QPointF(2, 2), QSizeF(20, 10));
QCOMPARE(ask(cache, layer, landings, mask, placement).value().image.cacheKey(), first);
const qint64 second = landed(cache, layer, landings, 2).image.cacheKey();
layer.transform.origin = QPointF(9, 3);
QCOMPARE(ask(cache, layer, landings, mask, placement).value().image.cacheKey(), second);
QVERIFY(landed(cache, layer, landings, 3).image.cacheKey() != second);
// Without a mask the placement changes nothing.
ImageLayer bare = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
ask(cache, bare, landings, std::nullopt, placement);
const qint64 unmasked = landed(cache, bare, landings, 4).image.cacheKey();
bare.transform.origin = QPointF(1, 1);
QCOMPARE(ask(cache, bare, landings, std::nullopt, placedAt(QPointF(5, 5), QSizeF(20, 10))).value().image.cacheKey(), unmasked);
QTest::qWait(150);
QCOMPARE(*landings.count, 4);
}
void EffectsPreviewCacheTests::settingsKeepTheLastPreviewButNewPixelsDropIt()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
const Landings landings;
ask(cache, layer, landings);
const qint64 first = landed(cache, layer, landings, 1).image.cacheKey();
// Same kinds: the old preview shows while the new renders.
layer.effects = outline(5);
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), first);
const EffectsPreviewCache::Result second = landed(cache, layer, landings, 2);
QCOMPARE(second.inset, 7.0);
// Another kind shown or hidden: the last preview stands.
layer.effects.value().colorOverlay = ColorOverlayEffect();
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), second.image.cacheKey());
landed(cache, layer, landings, 3);
// New pixels drop it.
layer.asset = ImportedImage(filled(20, 10, QColor(255, 0, 0)), QImage(), QStringLiteral("Red"));
QVERIFY(!ask(cache, layer, landings));
const qint64 red = landed(cache, layer, landings, 4).image.cacheKey();
// A mask added or removed on those pixels keeps it.
layer.mask = LayerMask(LayerMask::assetFrom(gray(20, 10, 255)));
QCOMPARE(ask(cache, layer, landings, layer.mask.value().enabledImage()).value().image.cacheKey(), red);
QVERIFY(landed(cache, layer, landings, 5).image.cacheKey() != red);
// Switched off again, the unmasked effects are known: no render.
layer.mask.value().isEnabled = false;
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), red);
QTest::qWait(200);
QCOMPARE(*landings.count, 5);
}
void EffectsPreviewCacheTests::undoneStepsReuseTheirEffects()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
const Landings landings;
// Four pixels in turn, each rendered and landed.
std::vector<ImportedImage> images;
std::vector<qint64> keys;
for (int step = 0; step < 4; ++step) {
images.emplace_back(filled(20, 10, QColor(0, 0, 60 + 60 * step)), QImage(), QStringLiteral("Step"));
layer.asset = images.back();
QVERIFY(!ask(cache, layer, landings));
keys.push_back(landed(cache, layer, landings, step + 1).image.cacheKey());
}
// Undone and redone across draws: the three newest are known.
for (const int step : {2, 1, 3}) {
cache.prepare({layer});
layer.asset = images[size_t(step)];
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), keys[size_t(step)]);
}
QTest::qWait(200);
QCOMPARE(*landings.count, 4);
// Undone and redone across draws: three newest are known.
cache.seed(layer.id, filled(4, 4, QColor(0, 255, 0)), layer.transform);
layer.asset = images[2];
QCOMPARE(ask(cache, layer, landings).value().image.cacheKey(), keys[2]);
layer.asset = images[0];
QVERIFY(!ask(cache, layer, landings));
// A layer without effects forgets them.
cache.prepare({});
layer.asset = images[3];
QVERIFY(!ask(cache, layer, landings));
}
void EffectsPreviewCacheTests::renderNowRendersAtThePreviewSize()
{
EffectsPreviewCache cache;
const QImage large = filled(400, 200, QColor(0, 0, 255));
const LayerEffectsRenderer::Rendered whole = LayerEffectsRenderer::render(large, std::nullopt, outline(3));
// Within the default 1536 a side: the whole render.
const EffectsPreviewCache::Result now = cache.renderNow(large, std::nullopt, outline(3)).value();
QCOMPARE(now.image, whole.image);
QCOMPARE(now.inset, whole.inset);
// Sharing the budget with a thousand, as the worker reduces.
const ImageLayer layer = layerOf(large, outline(3));
std::vector<ImageLayer> many(999, layerOf(filled(2, 2, QColor(0, 0, 255)), outline(3)));
for (ImageLayer &each : many)
each.id = QUuid::createUuid();
many.push_back(layer);
cache.prepare(many);
const Landings landings;
ask(cache, layer, landings);
const EffectsPreviewCache::Result worker = landed(cache, layer, landings, 1);
const EffectsPreviewCache::Result reduced = cache.renderNow(large, std::nullopt, outline(3)).value();
QCOMPARE(reduced.image, worker.image);
QCOMPARE(reduced.inset, worker.inset);
// 129 a side: sides at 121 over the margined width.
const double factor = 121.0 / (400 + 2 * LayerEffectsRenderer::margin(outline(3)));
const LayerEffects scaledOutline = outline(3 * factor);
QCOMPARE(reduced.image.size(), LayerEffectsRenderer::render(filled(int(std::lround(400 * factor)), int(std::lround(200 * factor)), QColor(0, 0, 255)),
std::nullopt, scaledOutline).image.size());
}
void EffectsPreviewCacheTests::onlyTheNewestRequestLands()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
const Landings older, newer;
ask(cache, layer, older);
layer.effects = outline(6);
ask(cache, layer, newer);
QCOMPARE(landed(cache, layer, newer, 1).inset, 8.0);
QTest::qWait(150);
QCOMPARE(*older.count, 0);
}
void EffectsPreviewCacheTests::aResultLandsOnlyOnTheRequestThatAskedForIt()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(1500, 1500, QColor(0, 0, 255)), outline(40));
const Landings older, newer;
ask(cache, layer, older);
// Its render finishes while the UI thread is busy elsewhere.
QTest::qWait(70);
QThread::msleep(2000);
layer.effects = outline(6);
ask(cache, layer, newer);
QCOMPARE(landed(cache, layer, newer, 1).inset, 8.0);
QCOMPARE(*older.count, 0);
// A seed meanwhile leaves the late result nowhere to land.
layer.effects = outline(9);
const Landings late;
ask(cache, layer, late);
QTest::qWait(70);
QThread::msleep(2000);
cache.seed(layer.id, filled(4, 4, Qt::green), placedAt(QPointF(0, 0), QSizeF(4, 4)));
QTest::qWait(150);
QVERIFY(*late.count == 0 && cache.rendered(layer.id).value().placement);
}
void EffectsPreviewCacheTests::seedsStandInUntilTheWorkerCatchesUp()
{
EffectsPreviewCache cache;
const ImageLayer layer = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
const Landings dropped, landings;
ask(cache, layer, dropped);
// A seed replaces the render under way, which never lands.
const QImage warped = filled(30, 12, QColor(0, 255, 0));
const LayerTransform placement = placedAt(QPointF(4, 5), QSizeF(30, 12));
cache.seed(layer.id, warped, placement);
EffectsPreviewCache::Result seeded = cache.rendered(layer.id).value();
QVERIFY(seeded.image.cacheKey() == warped.cacheKey() && seeded.inset == 0 && seeded.placement == placement);
// It stands in for the next request, then gives way.
seeded = ask(cache, layer, landings).value();
QVERIFY(seeded.image.cacheKey() == warped.cacheKey() && seeded.placement == placement);
const EffectsPreviewCache::Result fresh = landed(cache, layer, landings, 1);
QVERIFY(fresh.image.cacheKey() != warped.cacheKey() && !fresh.placement);
QCOMPARE(*dropped.count, 0);
// Gone for good: new pixels find neither.
ImageLayer repainted = layer;
repainted.asset = ImportedImage(filled(20, 10, QColor(255, 0, 0)), QImage(), QStringLiteral("Red"));
QVERIFY(!ask(cache, repainted, landings));
}
void EffectsPreviewCacheTests::preparingDropsLayersWithoutEffectsAndSharesTheBudget()
{
EffectsPreviewCache cache;
const ImageLayer wide = layerOf(filled(6000, 100, QColor(0, 0, 255)), outline(4));
const ImageLayer small = layerOf(filled(20, 10, QColor(0, 0, 255)), outline(3));
const Landings landings;
cache.prepare({wide, small});
ask(cache, wide, landings);
ask(cache, small, landings);
QVERIFY(QTest::qWaitFor([&] { return *landings.count == 2; }, 5000));
// Two layers with effects: 1536 a side, margins included.
EffectsPreviewCache::Result result = cache.rendered(wide.id).value();
QVERIFY(result.image.size() == QSize(1533, 33) && result.inset == 4);
// 1024 layers share 128 a side; twenty thousand get 32.
std::vector<ImageLayer> many(1024, wide);
for (ImageLayer &layer : many)
layer.id = QUuid::createUuid();
many.front() = wide;
cache.prepare(many);
ask(cache, wide, landings);
result = landed(cache, wide, landings, 3);
QVERIFY(result.image.size() == QSize(126, 8) && result.inset == 3);
many.resize(20000, many.back());
for (ImageLayer &layer : many)
layer.id = QUuid::createUuid();
many.front() = wide;
cache.prepare(many);
ask(cache, wide, landings);
result = landed(cache, wide, landings, 4);
QVERIFY(result.image.size() == QSize(30, 7) && result.inset == 3);
// Layers without effects shown go, seeds too; none leaves 1536.
ask(cache, small, landings);
landed(cache, small, landings, 5);
ImageLayer off = small;
off.effects.value().stroke.value().enabled = false;
cache.seed(wide.id, filled(4, 4, Qt::green), placedAt(QPointF(0, 0), QSizeF(4, 4)));
cache.prepare({off});
QVERIFY(!cache.rendered(small.id) && !cache.rendered(wide.id));
ask(cache, wide, landings);
QCOMPARE(landed(cache, wide, landings, 6).image.size(), QSize(1533, 33));
}
void EffectsPreviewCacheTests::aMaskHidesPixelsInTheReducedPreview()
{
EffectsPreviewCache cache;
ImageLayer layer = layerOf(filled(3000, 100, QColor(0, 0, 255)), outline(4));
// Left half hidden: the preview shows the right half.
QImage mask = gray(3000, 100, 255);
for (int y = 0; y < 100; ++y)
std::fill(mask.scanLine(y), mask.scanLine(y) + 1500, uchar(0));
const Landings landings;
cache.prepare({layer});
ask(cache, layer, landings, mask);
const QImage image = landed(cache, layer, landings, 1).image;
QVERIFY(image.size() == QSize(1532, 61));
QCOMPARE(qAlpha(image.pixel(300, 30)), 0);
QCOMPARE(image.pixel(1200, 30), qRgba(0, 0, 255, 255));
// The outline runs round what shows, at the halfway line.
QCOMPARE(image.pixel(764, 30), qRgba(255, 255, 0, 255));
// A mask of another size is reduced by its own.
QImage coarse(2, 1, QImage::Format_Grayscale8);
coarse.scanLine(0)[0] = 0;
coarse.scanLine(0)[1] = 255;
layer.asset = ImportedImage(filled(6000, 100, QColor(0, 0, 255)), QImage(), QStringLiteral("Wide"));
ask(cache, layer, landings, coarse);
const QImage wide = landed(cache, layer, landings, 2).image;
QVERIFY(wide.size() == QSize(1533, 33));
QCOMPARE(qAlpha(wide.pixel(104, 16)), 0);
QCOMPARE(wide.pixel(1404, 16), qRgba(0, 0, 255, 255));
// Stripes a row high shrink across and grow down, unaliased.
QImage stripes(6000, 1, QImage::Format_Grayscale8);
for (int x = 0; x < 6000; ++x)
stripes.scanLine(0)[x] = uchar(x % 2 ? 255 : 0);
layer.mask = LayerMask(LayerMask::assetFrom(stripes));
ask(cache, layer, landings, stripes);
const QImage row = landed(cache, layer, landings, 3).image;
int low = 255, high = 0;
for (int x = 10; x < 1523; ++x) {
low = std::min(low, qAlpha(row.pixel(x, 16)));
high = std::max(high, qAlpha(row.pixel(x, 16)));
}
QVERIFY(low == 125 && high == 129);
layer.mask = LayerMask(LayerMask::assetFrom(stripes.scaled(6000, 100)));
ask(cache, layer, landings, layer.mask.value().enabledImage());
QVERIFY(landed(cache, layer, landings, 4).image == row);
}
void EffectsPreviewCacheTests::aReducedPreviewScalesEveryLength()
{
EffectsPreviewCache cache;
LayerEffects effects;
effects.stroke = StrokeEffect{.size = 4, .red = 1, .green = 1, .blue = 0, .opacity = 1};
effects.shadow = ShadowEffect{.angle = 45, .distance = 8, .blur = 3, .red = 1, .green = 0, .blue = 0, .opacity = 0.8};
effects.colorOverlay = ColorOverlayEffect{.red = 0, .green = 1, .blue = 0, .opacity = 0.5};
effects.innerShadow = InnerShadowEffect{.angle = 120, .distance = 30, .blur = 12, .red = 0, .green = 0, .blue = 0, .opacity = 0.7};
effects.outerGlow = OuterGlowEffect{.size = 5, .red = 0, .green = 0, .blue = 1, .opacity = 0.6};
effects.innerGlow = InnerGlowEffect{.size = 40, .red = 1, .green = 0, .blue = 1, .opacity = 0.8};
const QImage image = noise(6000, 100, 7);
const ImageLayer layer = layerOf(image, effects);
const Landings landings;
cache.prepare({layer});
ask(cache, layer, landings);
const EffectsPreviewCache::Result result = landed(cache, layer, landings, 1);
// The renderer on the reduced pixels, every length reduced alike.
const double factor = 1528.0 / (6000 + 2 * LayerEffectsRenderer::margin(effects));
const QImage reduced = image.scaled(1518, 25, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
effects.stroke.value().size *= factor;
effects.shadow.value().distance *= factor;
effects.shadow.value().blur *= factor;
effects.innerShadow.value().distance *= factor;
effects.innerShadow.value().blur *= factor;
effects.outerGlow.value().size *= factor;
effects.innerGlow.value().size *= factor;
QVERIFY(result.image == LayerEffectsRenderer::render(reduced, std::nullopt, effects).image);
}
void EffectsPreviewCacheTests::aClosedCacheLandsNothing()
{
const Landings landings;
{
EffectsPreviewCache cache;
ask(cache, layerOf(filled(1500, 1500, QColor(0, 0, 255)), outline(40)), landings);
QTest::qWait(70);
}
QTest::qWait(150);
QCOMPARE(*landings.count, 0);
}
QTEST_GUILESS_MAIN(EffectsPreviewCacheTests)
#include "EffectsPreviewCacheTests.moc"
Reference in new issue View Git Blame Copy Permalink