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

443 lines
19 KiB
C++
Raw Blame History

#include "Rendering/EditorCanvas.h"
#include "IO/ImageExporter.h"
#include "RenderFixtures.h"
#include "SessionFixtures.h"
#include <QtTest>
// What the canvas paints: the checkerboard, the layers, the grid.
namespace {
ImportedImage filled(int width, int height, QRgb premultiplied, const QString &name)
{
const QImage image = solid(width, height, premultiplied);
return ImportedImage(image, image, name);
}
// A sized canvas whose viewport is set by hand.
struct Scene {
EditorSession session;
CanvasView canvas{session};
Scene(int width, int height, int canvasWidth, int canvasHeight, double zoom = 1)
{
session.createDocument(width, height);
// Pixels alone: Swift's overlay view draws the box apart.
session.setShowsTransformControls(false);
// The built-in dark's Base, Swift's surround gray.
QPalette dark = canvas.palette();
dark.setColor(QPalette::Base, QColor(0x1b, 0x1b, 0x1b));
canvas.setPalette(dark);
canvas.resize(canvasWidth, canvasHeight);
session.viewport.resize(QSizeF(canvasWidth, canvasHeight), 1, QSizeF(width, height));
session.zoom(zoom);
}
QImage shot() { return canvas.grab().toImage().convertToFormat(QImage::Format_ARGB32); }
QPointF origin() { return session.viewport.viewPoint(QPointF(0, 0), session.document().value().size()); }
};
// The worst channel gap, pixel centre against the export.
int gapToExport(Scene &scene, const std::function<bool(int)> &counts = [](int) { return true; })
{
const QImage exported = ImageExporter::render(scene.session.projectSnapshot().value()).image.convertToFormat(QImage::Format_ARGB32);
const QImage shot = scene.shot();
const QPointF origin = scene.origin();
const double zoom = scene.session.viewport.pointsPerPixel();
int worst = 0;
for (int y = 1; y < exported.height() - 1; ++y) {
for (int x = 1; x < exported.width() - 1; ++x) {
if (!counts(x))
continue;
const QRgb expected = exported.pixel(x, y), actual = shot.pixel(int(origin.x() + (x + 0.5) * zoom), int(origin.y() + (y + 0.5) * zoom));
worst = std::max({worst, std::abs(qRed(expected) - qRed(actual)), std::abs(qGreen(expected) - qGreen(actual)),
std::abs(qBlue(expected) - qBlue(actual))});
}
}
return worst;
}
int level(const QImage &image, int x, int y)
{
return qRed(image.pixel(x, y));
}
// A two by two layer: black column, white column.
ImportedImage blackWhite()
{
QImage image = BrushRaster::context(2, 2, false);
for (int y = 0; y < 2; ++y) {
image.setPixel(0, y, qRgba(0, 0, 0, 255));
image.setPixel(1, y, qRgba(255, 255, 255, 255));
}
return ImportedImage(image, image, "Edge");
}
}
class CanvasDisplayTests : public QObject {
Q_OBJECT
private slots:
void theBackgroundCheckerboardShadowAndBorderSurroundTheDocument();
void layersCompositeAsTheExportDoes();
void photoshopsOwnModesShowAsTheExportDoes();
void blendModesMeetNoCheckerboardButTranslucencyDoes();
void thePixelGridAppearsFromEightHundredPercent();
void fromTwoHundredPercentPixelsAreHardEdged();
void aPartialRepaintKeepsTheTilesAligned();
void theLiveCompositeDrawsWhatTheExportDraws();
void adjustmentsShowAsTheExportDoes();
void anAdjustmentsMaskClipsItOnTheCanvas();
void grainFollowsTheViewOnTheCanvas();
};
void CanvasDisplayTests::theBackgroundCheckerboardShadowAndBorderSurroundTheDocument()
{
Scene scene(100, 50, 300, 200);
QCOMPARE(scene.origin(), QPointF(100, 75));
const QImage shot = scene.shot();
QCOMPARE(shot.size(), QSize(300, 200));
QCOMPARE(level(shot, 10, 10), 27);
// Ten-point tiles, the even ones lighter.
QCOMPARE(level(shot, 105, 80), 89);
QCOMPARE(level(shot, 115, 80), 77);
QCOMPARE(level(shot, 125, 90), 77);
QCOMPARE(level(shot, 195, 120), 77);
QCOMPARE(level(shot, 135, 90), 89);
// The shadow darkens below and fades over fourteen points.
QVERIFY(level(shot, 150, 127) < 22);
const int fading = level(shot, 150, 135);
QVERIFY2(fading > 18 && fading < 27, qPrintable(QString::number(fading)));
QCOMPARE(level(shot, 150, 145), 27);
QCOMPARE(level(shot, 150, 60), 27);
// The border brightens the edge, astride it.
QVERIFY(std::max(level(shot, 99, 80), level(shot, 100, 80)) >= 95);
}
// Hue, opacity, a clip, a placed mask, a folder mask.
void richScene(EditorSession &session)
{
if (!session.linkMask(QUuid(), QUuid()))
session.insert(filled(20, 10, qRgba(0, 0, 255, 255), "Blue"), QPointF(10, 5));
session.insert(filled(6, 4, qRgba(255, 0, 0, 255), "Red"), QPointF(5, 3));
const QUuid red = session.activeLayerID().value();
session.setLayerOpacity(0.5);
session.insert(filled(20, 10, qRgba(0, 255, 0, 255), "Green"), QPointF(10, 5));
const QUuid green = session.activeLayerID().value();
if (!session.linkMask(red, green))
throw std::runtime_error("the green layer could not be clipped");
session.insert(filled(8, 5, qRgba(255, 255, 0, 255), "Yellow"), QPointF(14, 5));
const QUuid yellow = session.activeLayerID().value();
session.setLayerBlendMode(LayerBlendMode::hue);
session.groupSelectedLayers();
const QUuid folder = session.activeLayerID().value();
// Red's mask is soft and offset; the folder's is hard.
rewrite(session, [&](ProjectSnapshot &snapshot) {
setMask(snapshot, red, LayerMask::assetFrom(gray(6, 4, 100)));
record(snapshot, red).maskPlacement = LayerTransform{.origin = {3, 1}, .size = {6, 4}};
record(snapshot, red).maskLinked = false;
setMask(snapshot, green, LayerMask::assetFrom(gray(20, 10, 180)));
QImage half = QImage(20, 10, QImage::Format_Grayscale8);
half.fill(255);
for (int y = 0; y < 10; ++y) {
for (int x = 0; x < 15; ++x)
half.setPixel(x, y, qRgb(0, 0, 0));
}
setMask(snapshot, folder, LayerMask::assetFrom(half));
record(snapshot, yellow).transform.origin = QPointF(11, 3);
});
}
void CanvasDisplayTests::layersCompositeAsTheExportDoes()
{
Scene scene(20, 10, 60, 40);
EditorSession &session = scene.session;
richScene(session);
session.zoom(1);
const QImage exported = ImageExporter::render(session.projectSnapshot().value()).image.convertToFormat(QImage::Format_ARGB32);
const QImage shot = scene.shot();
const QPointF origin = scene.origin();
QCOMPARE(origin, QPointF(20, 15));
// Inside the border's hairline every pixel is the export's.
int worst = 0;
for (int y = 1; y < 9; ++y) {
for (int x = 1; x < 19; ++x) {
const QRgb expected = exported.pixel(x, y), actual = shot.pixel(int(origin.x()) + x, int(origin.y()) + y);
QCOMPARE(qAlpha(expected), 255);
worst = std::max({worst, std::abs(qRed(expected) - qRed(actual)), std::abs(qGreen(expected) - qGreen(actual)),
std::abs(qBlue(expected) - qBlue(actual))});
}
}
QVERIFY2(worst <= 1, qPrintable(QString::number(worst)));
// The edge carries half the hairline: 13% white, halved.
const int edge = qRed(shot.pixel(int(origin.x()), int(origin.y()) + 5)) - qRed(exported.pixel(0, 5));
QVERIFY2(edge >= 15 && edge <= 18, qPrintable(QString::number(edge)));
// The scene holds hue, opacity, a live mask, two masks.
QCOMPARE(exported.pixel(0, 0), qRgb(0, 0, 255));
const QRgb clipped = exported.pixel(4, 2);
QVERIFY(qGreen(clipped) > qRed(clipped) && qRed(clipped) > 0 && qBlue(clipped) > qGreen(clipped));
QCOMPARE(exported.pixel(12, 4), qRgb(0, 0, 255));
const QRgb hued = exported.pixel(16, 4);
QVERIFY(qRed(hued) == qGreen(hued) && qRed(hued) > 0 && qBlue(hued) == 0);
// A tried blend mode and an open edit both show.
const QUuid yellow = session.document().value().layers.back().id;
session.selectLayer(yellow);
session.previewBlendMode(LayerBlendMode::normal, yellow);
QCOMPARE(scene.shot().pixel(int(origin.x()) + 16, int(origin.y()) + 4), qRgb(255, 255, 0));
session.previewBlendMode(std::nullopt, std::nullopt);
// A drag's edit: hidden controls keep the pixels bare.
session.beginTransform(false);
LayerTransform draft = session.transformEdit().value().draft;
draft.origin += QPointF(0, 2);
session.previewTransform(draft);
const QImage moved = scene.shot();
QCOMPARE(moved.pixel(int(origin.x()) + 16, int(origin.y()) + 6), hued);
QCOMPARE(moved.pixel(int(origin.x()) + 16, int(origin.y()) + 4), qRgb(0, 0, 255));
session.cancelTransform();
}
void CanvasDisplayTests::photoshopsOwnModesShowAsTheExportDoes()
{
// Blended by hand on the canvas's surface, as exported.
for (const LayerBlendMode mode : {LayerBlendMode::linearDodge, LayerBlendMode::subtract, LayerBlendMode::hardMix, LayerBlendMode::hardLight}) {
Scene scene(20, 10, 60, 40);
scene.session.insert(filled(20, 10, qRgba(90, 140, 200, 255), "Ground"), QPointF(10, 5));
scene.session.insert(filled(10, 6, qRgba(120, 60, 160, 255), "Top"), QPointF(8, 5));
scene.session.setLayerBlendMode(mode);
scene.session.zoom(1);
const QImage exported = ImageExporter::render(scene.session.projectSnapshot().value()).image.convertToFormat(QImage::Format_ARGB32);
const QImage shot = scene.shot();
const QPointF origin = scene.origin();
for (const QPoint at : {QPoint(5, 4), QPoint(16, 4)})
QCOMPARE(shot.pixel(int(origin.x()) + at.x(), int(origin.y()) + at.y()), exported.pixel(at));
QVERIFY(exported.pixel(5, 4) != qRgb(120, 60, 160) && exported.pixel(5, 4) != qRgb(90, 140, 200));
}
}
void CanvasDisplayTests::blendModesMeetNoCheckerboardButTranslucencyDoes()
{
Scene multiplied(20, 10, 60, 40);
multiplied.session.insert(filled(20, 10, qRgba(255, 255, 255, 255), "White"), QPointF(10, 5));
multiplied.session.setLayerBlendMode(LayerBlendMode::multiply);
const QImage white = multiplied.shot();
QCOMPARE(level(white, 25, 20), 255);
QCOMPARE(level(white, 35, 20), 255);
// Half red over the tiles: half red, half tile.
Scene translucent(20, 10, 60, 40);
translucent.session.insert(filled(20, 10, qRgba(128, 0, 0, 128), "Red"), QPointF(10, 5));
const QImage red = translucent.shot();
const QRgb even = red.pixel(25, 20), odd = red.pixel(35, 20);
QVERIFY(std::abs(qRed(even) - 172) <= 2 && std::abs(qGreen(even) - 44) <= 2);
QVERIFY(std::abs(qRed(odd) - 166) <= 2 && std::abs(qGreen(odd) - 38) <= 2);
}
void CanvasDisplayTests::thePixelGridAppearsFromEightHundredPercent()
{
Scene scene(4, 2, 80, 60, 8);
scene.session.insert(filled(4, 2, qRgba(0, 0, 0, 255), "Black"), QPointF(2, 1));
QCOMPARE(scene.origin(), QPointF(24, 22));
QImage shot = scene.shot();
QCOMPARE(level(shot, 28, 26), 0);
// A hairline on each pixel boundary, half in each neighbour.
QVERIFY(level(shot, 31, 26) > 15 && level(shot, 32, 26) > 15);
QVERIFY(level(shot, 32, 26) < 60);
QVERIFY(level(shot, 28, 30) > 15 && level(shot, 28, 29) > 15);
// Half a point over: whole pixels, crossings filled once.
scene.session.viewport.translate(QSizeF(0.5, 0.5));
shot = scene.shot();
QCOMPARE(level(shot, 32, 27), 63);
QCOMPARE(level(shot, 28, 30), 63);
QCOMPARE(level(shot, 32, 30), 63);
QCOMPARE(level(shot, 28, 27), 0);
scene.session.viewport.translate(QSizeF(-0.5, -0.5));
scene.session.setShowsPixelGrid(false);
shot = scene.shot();
QCOMPARE(level(shot, 31, 26), 0);
QCOMPARE(level(shot, 32, 26), 0);
QCOMPARE(level(shot, 28, 30), 0);
// Below 800% there is no grid, whatever the flag.
scene.session.setShowsPixelGrid(true);
scene.session.zoom(7.9);
shot = scene.shot();
const QPointF origin = scene.origin();
for (int x = int(origin.x()) + 2; x < int(origin.x()) + 29; ++x)
QCOMPARE(level(shot, x, int(origin.y()) + 7), 0);
}
void CanvasDisplayTests::fromTwoHundredPercentPixelsAreHardEdged()
{
Scene scene(2, 2, 40, 20, 4);
scene.session.insert(blackWhite(), QPointF(1, 1));
QCOMPARE(scene.origin(), QPointF(16, 6));
QImage shot = scene.shot();
QCOMPARE(level(shot, 19, 10), 0);
QCOMPARE(level(shot, 20, 10), 255);
scene.session.zoom(2);
shot = scene.shot();
QCOMPARE(scene.origin(), QPointF(18, 8));
QCOMPARE(level(shot, 19, 10), 0);
QCOMPARE(level(shot, 20, 10), 255);
// Below 200% the boundary blends into its neighbours.
scene.session.zoom(1.9);
shot = scene.shot();
QCOMPARE(scene.origin(), QPointF(18.1, 8.1));
const int left = level(shot, 19, 10), right = level(shot, 20, 10);
QVERIFY2(left >= 40 && left <= 80, qPrintable(QString::number(left)));
QVERIFY2(right >= 175 && right <= 215, qPrintable(QString::number(right)));
}
void CanvasDisplayTests::aPartialRepaintKeepsTheTilesAligned()
{
Scene scene(100, 50, 300, 200);
QImage target(300, 200, QImage::Format_ARGB32);
target.fill(Qt::magenta);
// The region lands at the offset: its own top left.
scene.canvas.render(&target, QPoint(120, 80), QRegion(QRect(120, 80, 30, 30)));
QCOMPARE(target.pixel(125, 85), qRgb(77, 77, 77));
QCOMPARE(target.pixel(135, 85), qRgb(89, 89, 89));
QCOMPARE(target.pixel(125, 95), qRgb(89, 89, 89));
QCOMPARE(target.pixel(200, 10), qRgb(255, 0, 255));
}
void CanvasDisplayTests::theLiveCompositeDrawsWhatTheExportDraws()
{
EditorSession session;
session.createDocument(20, 10);
richScene(session);
const QImage exported = ImageExporter::render(session.projectSnapshot().value()).image;
QImage composite = BrushRaster::context(20, 10, false);
{
QPainter painter(&composite);
session.drawLiveComposite(session.document().value(), painter);
}
QCOMPARE(composite, exported);
// An open edit shows its draft, not the stored transform.
const QUuid yellow = session.document().value().layers.back().id;
session.selectLayer(yellow);
session.beginTransform();
LayerTransform draft = session.transformEdit().value().draft;
draft.origin += QPointF(0, 2);
session.previewTransform(draft);
const auto composed = [&] {
QImage image = BrushRaster::context(20, 10, false);
QPainter painter(&image);
session.drawLiveComposite(session.document().value(), painter);
return image;
};
const QImage moved = composed();
QVERIFY(moved != exported);
QCOMPARE(moved.pixel(16, 6), exported.pixel(16, 4));
QCOMPARE(moved.pixel(16, 4), qRgba(0, 0, 255, 255));
session.cancelTransform();
// A blend mode tried on shows as well.
session.previewBlendMode(LayerBlendMode::normal, yellow);
const QImage previewed = composed();
QCOMPARE(previewed.pixel(16, 4), qRgba(255, 255, 0, 255));
session.previewBlendMode(std::nullopt, std::nullopt);
QCOMPARE(composed(), exported);
}
void CanvasDisplayTests::adjustmentsShowAsTheExportDoes()
{
Scene scene(20, 10, 60, 40);
EditorSession &session = scene.session;
richScene(session);
const QImage before = ImageExporter::render(session.projectSnapshot().value()).image;
session.selectLayer(session.document().value().layers.back().id);
session.addAdjustment(AdjustmentKind::levels);
session.setAdjustmentEditingID(std::nullopt);
const QUuid levels = session.activeLayerID().value();
LayerAdjustment darker{AdjustmentKind::levels};
darker.levels.ranges[0].outputWhite = 160;
session.updateAdjustment(levels, darker);
session.zoom(1);
QVERIFY(ImageExporter::render(session.projectSnapshot().value()).image != before);
QVERIFY2(gapToExport(scene) <= 1, qPrintable(QString::number(gapToExport(scene))));
// The adjustment layer's own changes repaint the view.
scene.canvas.synchronizeDisplay();
QVERIFY(!scene.canvas.synchronizeDisplay());
session.setLayerOpacity(0.5);
QVERIFY(scene.canvas.synchronizeDisplay());
QVERIFY(gapToExport(scene) <= 1);
// Undo restores settings, no revision: still a repaint.
LayerAdjustment lighter = darker;
lighter.levels.ranges[0].outputWhite = 220;
session.beginEdit(QStringLiteral("Edit Levels"));
session.updateAdjustment(levels, lighter);
session.endEdit();
scene.canvas.synchronizeDisplay();
session.undo();
QVERIFY(scene.canvas.synchronizeDisplay());
}
void CanvasDisplayTests::anAdjustmentsMaskClipsItOnTheCanvas()
{
// At 200%, its left half hidden by a hard mask.
Scene scene(20, 10, 80, 60, 2);
EditorSession &session = scene.session;
session.insert(filled(20, 10, qRgba(200, 120, 40, 255), "Orange"));
session.addAdjustment(AdjustmentKind::levels);
session.setAdjustmentEditingID(std::nullopt);
const QUuid levels = session.activeLayerID().value();
LayerAdjustment darker{AdjustmentKind::levels};
darker.levels.ranges[0].outputWhite = 60;
session.updateAdjustment(levels, darker);
QImage half(20, 10, QImage::Format_Grayscale8);
half.fill(255);
for (int y = 0; y < 10; ++y) {
for (int x = 0; x < 10; ++x)
half.setPixel(x, y, qRgb(0, 0, 0));
}
rewrite(session, [&](ProjectSnapshot &snapshot) { setMask(snapshot, levels, LayerMask::assetFrom(half)); });
// Installing fits the view: back to two hundred percent.
session.zoom(2);
QVERIFY2(gapToExport(scene) <= 1, qPrintable(QString::number(gapToExport(scene))));
// Smooth at 150%, the mask takes the view's scale.
session.zoom(1.5);
QVERIFY(gapToExport(scene, [](int x) { return x < 9 || x > 10; }) <= 1);
session.zoom(2);
// A disabled mask hides nothing.
session.toggleLayerMask();
QVERIFY(!session.activeLayer().value().mask.value().isEnabled);
QVERIFY(gapToExport(scene) <= 1);
session.toggleLayerMask();
// Mid-stroke, new paint on the mask shows at once.
const QPointF origin = scene.origin();
const QPoint left(int(origin.x() + 3.5 * 2), int(origin.y() + 5.5 * 2));
const int hidden = qRed(scene.shot().pixel(left));
session.selectLayerTarget(levels, true);
session.setMaskPaintWhite(true);
session.selectTool(NavigationTool::brush);
session.beginBrush(QPointF(3.5, 5.5));
session.continueBrush(QPointF(4, 5.5));
QVERIFY(session.brushStroke());
const int painted = qRed(scene.shot().pixel(left));
QVERIFY2(hidden == 200 && painted < 70, qPrintable(QStringLiteral("%1 %2").arg(hidden).arg(painted)));
session.cancelBrush();
}
void CanvasDisplayTests::grainFollowsTheViewOnTheCanvas()
{
// Swift's canvas hands Grain the view's region, not the document's.
Scene scene(40, 40, 120, 120);
EditorSession &session = scene.session;
session.insert(filled(40, 40, qRgba(128, 128, 128, 255), "Gray"));
session.addAdjustment(AdjustmentKind::grain);
session.setAdjustmentEditingID(std::nullopt);
LayerAdjustment grain = session.activeLayer().value().adjustment.value();
GrainSettings strong = grain.grain();
strong.amount = 100;
// Pinned: under some seeds the pan keeps one pixel's tone.
strong.seed = 7;
grain.setGrain(strong);
session.updateAdjustment(session.activeLayerID().value(), grain);
session.zoom(1);
QVERIFY(gapToExport(scene) > 20);
// A pan moves the pattern under the same document pixel.
const auto pixel = [&scene] {
const QPointF origin = scene.origin();
return scene.shot().pixel(int(origin.x() + 20.5), int(origin.y() + 20.5));
};
const QRgb before = pixel();
session.viewport.translate(QSizeF(3, 0));
QVERIFY(pixel() != before);
}
QTEST_MAIN(CanvasDisplayTests)
#include "CanvasDisplayTests.moc"
Reference in new issue View Git Blame Copy Permalink