14.4: Image › Rotate Canvas 90° Clockwise and Counterclockwise; quarter turns on whole pixels copy exactly

tests/CanvasRotationTests.cpp

@@ -0,0 +1,189 @@
+#include "Document/EditorSession.h"
+#include "IO/ImageExporter.h"
+#include "SessionFixtures.h"
+#include <QSignalSpy>
+#include <QtTest>
+
+// Swift's CanvasRotationTests: a quarter turn, everything along.
+namespace {
+// Reds 10, 20, 30 over 40, 50, 60.
+QImage pixels()
+{
+    QImage image = BrushRaster::context(3, 2, false);
+    const int values[] = {10, 20, 30, 40, 50, 60};
+    for (int index = 0; index < 6; ++index)
+        image.setPixelColor(index % 3, index / 3, QColor(values[index], 0, 0));
+    return image;
+}
+
+void canvas(EditorSession &session)
+{
+    session.createDocument(3, 2);
+    session.insert(ImportedImage(pixels(), pixels(), QStringLiteral("Pixels")));
+}
+
+// The flattened canvas's reds, row by row.
+QList<int> reds(const EditorSession &session)
+{
+    const QImage image = ImageExporter::render(session.projectSnapshot().value()).image;
+    QList<int> values;
+    for (int y = 0; y < image.height(); ++y)
+        for (int x = 0; x < image.width(); ++x)
+            values << image.pixelColor(x, y).red();
+    return values;
+}
+}
+
+class CanvasRotationTests : public QObject {
+    Q_OBJECT
+private slots:
+    void clockwiseTurnsThePixelsExactly();
+    void counterclockwiseTurnsThePixelsExactly();
+    void turningBackAndUndoingRestoreTheCanvas();
+    void guidesAndSelectionTurnWithTheCanvas();
+    void turnedLayersAndPlacedMasksTurnAlong();
+    void itIsOneStepRefusedWhereLayersCannotChange();
+};
+
+void CanvasRotationTests::clockwiseTurnsThePixelsExactly()
+{
+    EditorSession session;
+    canvas(session);
+    session.rotateCanvas(true);
+    QCOMPARE(session.document().value().size(), QSizeF(2, 3));
+    // The left column, bottom to top, is the top row.
+    QCOMPARE(reds(session), (QList<int>{40, 10, 50, 20, 60, 30}));
+}
+
+void CanvasRotationTests::counterclockwiseTurnsThePixelsExactly()
+{
+    EditorSession session;
+    canvas(session);
+    session.rotateCanvas(false);
+    QCOMPARE(session.document().value().size(), QSizeF(2, 3));
+    // The right column, top to bottom, is the top row.
+    QCOMPARE(reds(session), (QList<int>{30, 60, 20, 50, 10, 40}));
+}
+
+void CanvasRotationTests::turningBackAndUndoingRestoreTheCanvas()
+{
+    EditorSession session;
+    canvas(session);
+    const QList<int> original = reds(session);
+    session.rotateCanvas(true);
+    session.rotateCanvas(false);
+    QCOMPARE(session.document().value().size(), QSizeF(3, 2));
+    QCOMPARE(reds(session), original);
+    session.rotateCanvas(true);
+    session.rotateCanvas(true);
+    // Two quarter turns are a half turn.
+    QList<int> reversed = original;
+    std::reverse(reversed.begin(), reversed.end());
+    QCOMPARE(reds(session), reversed);
+    QCOMPARE(session.activeLayer().value().transform.rotation, 180.0);
+    // Undo fits the view to the canvas it brings back.
+    session.zoom(4);
+    session.undo();
+    QCOMPARE(session.document().value().size(), QSizeF(2, 3));
+    const CanvasViewport fitted = [&] {
+        CanvasViewport viewport = session.viewport;
+        viewport.fit(QSizeF(2, 3));
+        return viewport;
+    }();
+    QCOMPARE(session.viewport, fitted);
+    session.undo();
+    QCOMPARE(session.document().value().size(), QSizeF(3, 2));
+    QCOMPARE(reds(session), original);
+}
+
+void CanvasRotationTests::guidesAndSelectionTurnWithTheCanvas()
+{
+    EditorSession session;
+    session.createDocument(100, 60);
+    rewrite(session, [](ProjectSnapshot &snapshot) {
+        snapshot.manifest.guides = std::vector<CanvasGuide>{{QUuid::createUuid(), CanvasGuide::Axis::vertical, 30},
+                                                            {QUuid::createUuid(), CanvasGuide::Axis::horizontal, 10}};
+    });
+    QPainterPath box;
+    box.addRect(0, 0, 20, 10);
+    session.setSelection(DocumentSelection{.path = box, .antialiased = false, .feather = 3}, QStringLiteral("Marquee"));
+    session.rotateCanvas(true);
+    const std::vector<CanvasGuide> &guides = session.document().value().guides;
+    // Clockwise: x becomes y; y, the new width less y.
+    QVERIFY(guides[0].axis == CanvasGuide::Axis::horizontal && guides[0].position == 30);
+    QVERIFY(guides[1].axis == CanvasGuide::Axis::vertical && guides[1].position == 50);
+    const DocumentSelection &selection = session.document().value().selection.value();
+    QCOMPARE(selection.path.boundingRect(), QRectF(50, 0, 10, 20));
+    QVERIFY(!selection.antialiased && selection.feather == 3);
+    // Counterclockwise from the start: the other way round.
+    session.undo();
+    session.rotateCanvas(false);
+    QVERIFY(session.document().value().guides[0].axis == CanvasGuide::Axis::horizontal && session.document().value().guides[0].position == 70);
+    QVERIFY(session.document().value().guides[1].axis == CanvasGuide::Axis::vertical && session.document().value().guides[1].position == 10);
+    QCOMPARE(session.document().value().selection.value().path.boundingRect(), QRectF(0, 80, 10, 20));
+}
+
+void CanvasRotationTests::turnedLayersAndPlacedMasksTurnAlong()
+{
+    EditorSession session;
+    session.createDocument(100, 60);
+    session.insert(ImportedImage(pixels(), pixels(), QStringLiteral("Pixels")), QPointF(20, 10));
+    const QUuid id = session.activeLayerID().value();
+    rewrite(session, [id](ProjectSnapshot &snapshot) {
+        record(snapshot, id).transform.rotation = 300;
+        record(snapshot, id).transform.flipX = true;
+        setMask(snapshot, id, coverage());
+        record(snapshot, id).maskPlacement = LayerTransform{.origin = QPointF(70, 40), .size = QSizeF(10, 4), .rotation = -30};
+        record(snapshot, id).maskLinked = false;
+    });
+    const QPointF before = session.activeLayer().value().transform.center();
+    session.rotateCanvas(true);
+    const ImageLayer layer = session.activeLayer().value();
+    // A centre (x, y) goes to (60 - y, x).
+    QCOMPARE(layer.transform.center(), QPointF(60 - before.y(), before.x()));
+    QCOMPARE(layer.transform.size, QSizeF(3, 2));
+    QCOMPARE(layer.transform.rotation, 30.0);
+    QVERIFY(layer.transform.flipX);
+    const LayerTransform placed = layer.mask.value().placement.value();
+    QCOMPARE(placed.center(), QPointF(18, 75));
+    QCOMPARE(placed.rotation, 60.0);
+    // Swift's truncatingRemainder keeps the sign: -60, then -150.
+    session.rotateCanvas(false);
+    QCOMPARE(session.activeLayer().value().transform.center(), before);
+    QCOMPARE(session.activeLayer().value().transform.rotation, -60.0);
+    session.rotateCanvas(false);
+    QCOMPARE(session.activeLayer().value().transform.rotation, -150.0);
+}
+
+void CanvasRotationTests::itIsOneStepRefusedWhereLayersCannotChange()
+{
+    EditorSession session;
+    session.rotateCanvas(true);
+    QVERIFY(!session.document());
+    canvas(session);
+    session.setIsProjectBusy(true);
+    QSignalSpy refused(&session, &EditorSession::changed);
+    session.rotateCanvas(true);
+    QCOMPARE(refused.count(), 0);
+    QCOMPARE(session.document().value().size(), QSizeF(3, 2));
+    session.setIsProjectBusy(false);
+    // A drawn crop frame goes first, as Swift's cancelCrop.
+    session.selectTool(NavigationTool::crop);
+    QVERIFY(session.cropRect());
+    session.zoom(3);
+    session.rotateCanvas(false);
+    QVERIFY(!session.cropRect());
+    QCOMPARE(session.history.undoName(), QString("Rotate Canvas 90° Counterclockwise"));
+    // The view fits the turned canvas.
+    CanvasViewport fitted = session.viewport;
+    fitted.fit(QSizeF(2, 3));
+    QCOMPARE(session.viewport, fitted);
+    session.undo();
+    session.rotateCanvas(true);
+    QCOMPARE(session.history.undoName(), QString("Rotate Canvas 90° Clockwise"));
+    session.undo();
+    QCOMPARE(session.document().value().size(), QSizeF(3, 2));
+}
+
+QTEST_GUILESS_MAIN(CanvasRotationTests)
+#include "CanvasRotationTests.moc"

tests/CompositorMenusTests.cpp

@@ -20,7 +20,6 @@ private slots:
     void transformEntriesFollowTheMoveTool();
     void deleteMeansTheMaskTheLayerOrTheLayers();
     void theMenusFollowTheFrontTab();
-    void imageEntriesSizeAndFlipTheCanvas();
 };
 
 void CompositorMenusTests::everyEntryHasSwiftsShortcutWithCtrlForCommand()
@@ -36,7 +35,7 @@ void CompositorMenusTests::everyEntryHasSwiftsShortcutWithCtrlForCommand()
         {"mergeLayers", "Ctrl+E"}, {"flipHorizontal", ""}, {"flipVertical", ""}, {"deleteLayer", ""},
         {"selectAll", "Ctrl+A"}, {"deselect", "Ctrl+D"}, {"inverse", "Ctrl+Shift+I"}, {"layerPixels", ""}, {"subject", "Ctrl+Alt+A"}, {"colorRange", ""}, {"maskBlackAreas", ""},
         {"expandSelection", ""}, {"contractSelection", ""}, {"featherSelection", ""}, {"curves", "Ctrl+M"}, {"levels", "Ctrl+L"}, {"hueSaturation", "Ctrl+U"}, {"blackWhite", ""}, {"colorBalance", ""}, {"exposure", ""}, {"gradientMap", ""}, {"grain", ""}, {"invert", "Ctrl+I"},
-        {"canvasSize", "Ctrl+Alt+C"}, {"imageSize", "Ctrl+Alt+I"}, {"trim", ""}, {"flipCanvasHorizontal", ""}, {"flipCanvasVertical", ""},
+        {"canvasSize", "Ctrl+Alt+C"}, {"imageSize", "Ctrl+Alt+I"}, {"trim", ""}, {"rotateCanvasClockwise", ""}, {"rotateCanvasCounterclockwise", ""}, {"flipCanvasHorizontal", ""}, {"flipCanvasVertical", ""},
         {"gaussianBlur", ""}, {"motionBlur", ""}, {"addNoise", ""}, {"lensCorrection", ""}, {"removeBackground", ""}, {"newAdjustmentLayer", ""}, {"editAdjustment", ""},
         {"newHueSaturationAdjustment", ""}, {"newLevelsAdjustment", ""}, {"newCurvesAdjustment", ""}, {"newExposureAdjustment", ""},
         {"newGradientMapAdjustment", ""}, {"newGrainAdjustment", ""}, {"newInvertAdjustment", ""}, {"newBlackWhiteAdjustment", ""},
@@ -57,7 +56,7 @@ void CompositorMenusTests::everyEntryHasSwiftsShortcutWithCtrlForCommand()
     // Swift 1.3.4's Color Range… follows Subject.
     const QList<QAction *> select = menus[3]->actions();
     QCOMPARE(select.indexOf(&bar.action("colorRange")), select.indexOf(&bar.action("subject")) + 1);
-    QCOMPARE(menus[4]->actions().size(), 16);
+    QCOMPARE(menus[4]->actions().size(), 18);
     // Swift's Trim… follows Image Size….
     const QList<QAction *> image = menus[4]->actions();
     QCOMPARE(image.indexOf(&bar.action("trim")), image.indexOf(&bar.action("imageSize")) + 1);
@@ -458,42 +457,5 @@ void CompositorMenusTests::theMenusFollowTheFrontTab()
     QCOMPARE(bar.action("undo").text(), QString("Undo New Blank Layer"));
 }
 
-void CompositorMenusTests::imageEntriesSizeAndFlipTheCanvas()
-{
-    Bar bar;
-    bar.window.show();
-    const char *entries[] = {"canvasSize", "imageSize", "trim", "flipCanvasHorizontal", "flipCanvasVertical"};
-    for (const char *name : entries)
-        QVERIFY2(!bar.action(name).isEnabled(), name);
-    bar.session().createDocument(100, 50);
-    bar.session().insert(white(), QPointF(20.5, 10.5));
-    for (const char *name : entries)
-        QVERIFY2(bar.action(name).isEnabled(), name);
-    // Busy holds them all; a drawn frame holds the flips.
-    bar.session().setIsProjectBusy(true);
-    for (const char *name : entries)
-        QVERIFY2(!bar.action(name).isEnabled(), name);
-    bar.session().setIsProjectBusy(false);
-    bar.session().selectTool(NavigationTool::crop);
-    QVERIFY(bar.action("canvasSize").isEnabled() && bar.action("trim").isEnabled() && !bar.action("flipCanvasHorizontal").isEnabled());
-    bar.session().selectTool(NavigationTool::move);
-    bar.action("flipCanvasHorizontal").trigger();
-    QCOMPARE(bar.session().activeLayer().value().origin(), QPointF(79, 10));
-    QCOMPARE(bar.session().history.undoName(), QString("Flip Canvas Horizontal"));
-    bar.action("flipCanvasVertical").trigger();
-    QCOMPARE(bar.session().activeLayer().value().origin(), QPointF(79, 39));
-    // The size entries open their sheets over the window.
-    for (const auto &[name, title] : {std::pair("canvasSize", "Canvas Size"), std::pair("imageSize", "Image Size"), std::pair("trim", "Trim")}) {
-        bar.action(name).trigger();
-        auto *sheet = bar.window.findChild<QDialog *>();
-        QVERIFY(sheet && sheet->isVisible());
-        QCOMPARE(sheet->windowTitle(), QString::fromLatin1(title));
-        QVERIFY(!bar.action(name).isEnabled());
-        QTest::keyClick(sheet, Qt::Key_Escape);
-        QTRY_VERIFY(!bar.session().isProjectBusy());
-        QTRY_VERIFY(!bar.window.findChild<QDialog *>());
-    }
-}
-
 QTEST_MAIN(CompositorMenusTests)
 #include "CompositorMenusTests.moc"

tests/ImageMenuTests.cpp

@@ -0,0 +1,58 @@
+#include "MenuFixtures.h"
+#include <QDialog>
+#include <QtTest>
+
+// The Image menu's canvas entries, out of CompositorMenusTests.
+class ImageMenuTests : public QObject {
+    Q_OBJECT
+private slots:
+    void imageEntriesSizeAndFlipTheCanvas();
+};
+
+void ImageMenuTests::imageEntriesSizeAndFlipTheCanvas()
+{
+    Bar bar;
+    bar.window.show();
+    const char *entries[] = {"canvasSize", "imageSize", "trim", "rotateCanvasClockwise", "rotateCanvasCounterclockwise", "flipCanvasHorizontal", "flipCanvasVertical"};
+    for (const char *name : entries)
+        QVERIFY2(!bar.action(name).isEnabled(), name);
+    bar.session().createDocument(100, 50);
+    bar.session().insert(white(), QPointF(20.5, 10.5));
+    for (const char *name : entries)
+        QVERIFY2(bar.action(name).isEnabled(), name);
+    // Busy holds them all; a drawn frame holds the flips.
+    bar.session().setIsProjectBusy(true);
+    for (const char *name : entries)
+        QVERIFY2(!bar.action(name).isEnabled(), name);
+    bar.session().setIsProjectBusy(false);
+    bar.session().selectTool(NavigationTool::crop);
+    QVERIFY(bar.action("canvasSize").isEnabled() && bar.action("trim").isEnabled() && !bar.action("flipCanvasHorizontal").isEnabled());
+    QVERIFY(!bar.action("rotateCanvasClockwise").isEnabled() && !bar.action("rotateCanvasCounterclockwise").isEnabled());
+    bar.session().selectTool(NavigationTool::move);
+    bar.action("flipCanvasHorizontal").trigger();
+    QCOMPARE(bar.session().activeLayer().value().origin(), QPointF(79, 10));
+    QCOMPARE(bar.session().history.undoName(), QString("Flip Canvas Horizontal"));
+    bar.action("flipCanvasVertical").trigger();
+    QCOMPARE(bar.session().activeLayer().value().origin(), QPointF(79, 39));
+    // A quarter turn swaps the sides and carries the layer.
+    bar.action("rotateCanvasClockwise").trigger();
+    QCOMPARE(bar.session().document().value().size(), QSizeF(50, 100));
+    QCOMPARE(bar.session().history.undoName(), QString("Rotate Canvas 90° Clockwise"));
+    bar.action("rotateCanvasCounterclockwise").trigger();
+    QCOMPARE(bar.session().document().value().size(), QSizeF(100, 50));
+    QCOMPARE(bar.session().activeLayer().value().origin(), QPointF(79, 39));
+    // The size entries open their sheets over the window.
+    for (const auto &[name, title] : {std::pair("canvasSize", "Canvas Size"), std::pair("imageSize", "Image Size"), std::pair("trim", "Trim")}) {
+        bar.action(name).trigger();
+        auto *sheet = bar.window.findChild<QDialog *>();
+        QVERIFY(sheet && sheet->isVisible());
+        QCOMPARE(sheet->windowTitle(), QString::fromLatin1(title));
+        QVERIFY(!bar.action(name).isEnabled());
+        QTest::keyClick(sheet, Qt::Key_Escape);
+        QTRY_VERIFY(!bar.session().isProjectBusy());
+        QTRY_VERIFY(!bar.window.findChild<QDialog *>());
+    }
+}
+
+QTEST_MAIN(ImageMenuTests)
+#include "ImageMenuTests.moc"

tests/SharpCanvasTests.cpp

@@ -56,6 +56,7 @@ class SharpCanvasTests : public QObject {
 private slots:
     void anUprightLayerPixelForPixelTakesNoFilter();
     void plainMaskedAndTiledLayersCopyAcross();
+    void aQuarterTurnOnWholePixelsCopiesAcross();
 };
 
 void SharpCanvasTests::anUprightLayerPixelForPixelTakesNoFilter()
@@ -96,5 +97,62 @@ void SharpCanvasTests::plainMaskedAndTiledLayersCopyAcross()
     }
 }
 
+void SharpCanvasTests::aQuarterTurnOnWholePixelsCopiesAcross()
+{
+    // The columns stood up, centred at (10, 60).
+    const auto standing = [](double rotation, double nudge) {
+        return LayerTransform{.origin = {-40 + nudge, 58}, .size = {100, 4}, .rotation = rotation};
+    };
+    QImage surface = BrushRaster::context(20, 120, false);
+    QPainter painter(&surface);
+    const auto upright = [&](const LayerTransform &transform) {
+        QTransform placement;
+        placement.translate(transform.center().x(), transform.center().y());
+        placement.rotateRadians(transform.radians());
+        const QSizeF size = transform.size;
+        return LayerRenderer::upright(transform, placement, QRectF(-size.width() / 2, -size.height() / 2, size.width(), size.height()), painter);
+    };
+    for (double rotation : {90.0, -90.0, 180.0, 270.0, 450.0})
+        QVERIFY2(upright(standing(rotation, 0)), qPrintable(QString::number(rotation)));
+    QVERIFY(!upright(standing(90, 0.5)) && !upright(standing(90, 0.002)) && upright(standing(90, 0.0009)));
+    QVERIFY(!upright(standing(45, 0)) && !upright(standing(90.000001, 0)));
+    // Either axis off, or a side stretched: off the pixels.
+    LayerTransform low = standing(90, 0);
+    low.origin.ry() += 0.25;
+    // 4.5 across: one corner on a pixel, one between.
+    const LayerTransform stretched{.origin = {-40.25, 57.75}, .size = {100, 4.5}, .rotation = 90};
+    QVERIFY(!upright(low) && !upright(stretched));
+    // Swift's own upright holds off whole pixels too.
+    QVERIFY(upright(standing(0, 0.3)));
+    // The painter's own place counts.
+    painter.translate(0.5, 0);
+    QVERIFY(!upright(standing(90, 0)) && upright(standing(90, 0.5)));
+    painter.end();
+    const QImage image = columns();
+    const auto raster = std::make_shared<const RasterSnapshot>(100, 4, image, QRectF(0, 0, 100, 4), std::vector<BrushPatch>{});
+    const auto mids = [&](const LayerTransform &transform, bool tiled) {
+        QImage drawn = BrushRaster::context(20, 120, false);
+        QPainter onto(&drawn);
+        if (tiled)
+            TiledLayerRenderer::drawRaster(raster, transform, transform.center(), onto);
+        else
+            LayerRenderer::draw(image, transform, transform.center(), onto);
+        onto.end();
+        int count = 0;
+        for (int y = 10; y < 110; ++y) {
+            for (int x = 8; x < 12; ++x)
+                count += qRed(drawn.pixel(x, y)) % 255 != 0 || qAlpha(drawn.pixel(x, y)) != 255;
+        }
+        return count;
+    };
+    for (bool tiled : {false, true}) {
+        // On whole pixels: each column a row, exact.
+        QCOMPARE(mids(standing(90, 0), tiled), 0);
+        QCOMPARE(mids(standing(-90, 0), tiled), 0);
+        // Half a pixel off: filtered, as CoreGraphics blends it.
+        QVERIFY(mids(standing(90, 0.5), tiled) > 100);
+    }
+}
+
 QTEST_GUILESS_MAIN(SharpCanvasTests)
 #include "SharpCanvasTests.moc"

tests/Tests.cmake

@@ -100,6 +100,7 @@ compositor_test(CanvasThumbnailTests)
 compositor_test(ClippingStackTests)
 compositor_test(CompositorTests)
 compositor_test(CompositorMenusTests)
+compositor_test(ImageMenuTests)
 compositor_test(ViewMenuTests)
 compositor_test(KeyboardShortcutsTests)
 compositor_test(KeyboardShortcutsSheetTests)
@@ -319,6 +320,7 @@ compositor_test(CameraRawGroupWordsTests)
 target_include_directories(CameraRawWiringTests PRIVATE ${OMAPHOTO_KERNELS})
 compositor_test(LayerEffectsRendererTests)
 compositor_test(LayerFlipTests)
+compositor_test(CanvasRotationTests)
 compositor_test(LayerMergeTests)
 compositor_test(PixelEditTests)
 compositor_test(PixelInvertTests)