add horizontal and vertical flip

src/GeneralAction.cpp

@@ -13,14 +13,18 @@ GeneralAction::GeneralAction(QObject* parent, const QString& title) :
     _colorAction(this, "Color"),
     _nameAction(this, "Name"),
     _positionAction(this, "Position"),
-    _scaleAction(this, "Scale", 0.0f, 1000000.0f, 100.0f, 1)
+    _scaleAction(this, "Scale", 0.0f, 1000000.0f, 100.0f, 1), 
+    _flipHorizontalAction(this, "Horizontal flip", false),
+    _flipVerticalAction(this, "Vertical flip", false)
 {
     addAction(&_visibleAction);
     addAction(&_datasetNameAction);
     addAction(&_colorAction);
     addAction(&_nameAction);
     addAction(&_positionAction);
     addAction(&_scaleAction);
+    addAction(&_flipHorizontalAction);
+    addAction(&_flipVerticalAction);
 
     _datasetNameAction.setConnectionPermissionsToForceNone();
     _datasetNameAction.setEnabled(false);
@@ -33,6 +37,8 @@ GeneralAction::GeneralAction(QObject* parent, const QString& title) :
     _datasetNameAction.setToolTip("Name of the images dataset");
     _nameAction.setToolTip("Name of the layer");
     _scaleAction.setToolTip("Layer scale in percentages");
+    _flipHorizontalAction.setToolTip("Flip the layer horizontally");
+    _flipVerticalAction.setToolTip("Flip the layer vertically");
 
     _scaleAction.setSuffix("%");
 }
@@ -67,6 +73,8 @@ void GeneralAction::initialize(Layer* layer)
     connect(&_visibleAction, &ToggleAction::toggled, this, updateBounds);
     connect(&_positionAction, &PositionAction::changed, this, updateBounds);
     connect(&_scaleAction, &DecimalAction::valueChanged, this, updateBounds);
+    connect(&_flipHorizontalAction, &ToggleAction::toggled, this, updateBounds);
+    connect(&_flipVerticalAction, &ToggleAction::toggled, this, updateBounds);
     connect(&_colorAction, &ColorAction::colorChanged, this, updateBounds);
     connect(&_colorAction, &ColorAction::colorChanged, this, render);
 
@@ -77,6 +85,27 @@ void GeneralAction::initialize(Layer* layer)
     updateDatasetNameAction();
 
     connect(_layer->getImagesDataset().get(), &DatasetImpl::locationChanged, this, updateDatasetNameAction);
+
+    const auto showNotificationFlipX = [this]() -> void {
+        static bool notificationShownFlipX = false;
+
+        if (!notificationShownFlipX) {
+            notificationShownFlipX = true;
+            _layer->getImageViewerPlugin().addNotification("Image is flipped horizontally for display purposes; the underlying data structure is not altered.");
+        }
+    };
+
+    const auto showNotificationFlipY = [this]() -> void {
+        static bool notificationShownFlipY = false;
+
+        if (!notificationShownFlipY) {
+            notificationShownFlipY = true;
+            _layer->getImageViewerPlugin().addNotification("Image is flipped vertically for display purposes; the underlying data structure is not altered.");
+        }
+	};
+
+    connect(&_flipHorizontalAction, &ToggleAction::toggled, this, showNotificationFlipX);
+    connect(&_flipVerticalAction, &ToggleAction::toggled, this, showNotificationFlipY);
 }
 
 void GeneralAction::connectToPublicAction(WidgetAction* publicAction, bool recursive)
@@ -94,6 +123,8 @@ void GeneralAction::connectToPublicAction(WidgetAction* publicAction, bool recur
         actions().connectPrivateActionToPublicAction(&_nameAction, &publicGeneralAction->getNameAction(), recursive);
         actions().connectPrivateActionToPublicAction(&_positionAction, &publicGeneralAction->getPositionAction(), recursive);
         actions().connectPrivateActionToPublicAction(&_scaleAction, &publicGeneralAction->getScaleAction(), recursive);
+        actions().connectPrivateActionToPublicAction(&_flipHorizontalAction, &publicGeneralAction->getFlipHorizontalAction(), recursive);
+        actions().connectPrivateActionToPublicAction(&_flipVerticalAction, &publicGeneralAction->getFlipVerticalAction(), recursive);
     }
 
     GroupAction::connectToPublicAction(publicAction, recursive);
@@ -110,6 +141,8 @@ void GeneralAction::disconnectFromPublicAction(bool recursive)
         actions().disconnectPrivateActionFromPublicAction(&_nameAction, recursive);
         actions().disconnectPrivateActionFromPublicAction(&_positionAction, recursive);
         actions().disconnectPrivateActionFromPublicAction(&_scaleAction, recursive);
+        actions().disconnectPrivateActionFromPublicAction(&_flipHorizontalAction, recursive);
+        actions().disconnectPrivateActionFromPublicAction(&_flipVerticalAction, recursive);
     }
 
     GroupAction::disconnectFromPublicAction(recursive);
@@ -124,6 +157,8 @@ void GeneralAction::fromVariantMap(const QVariantMap& variantMap)
     _nameAction.fromParentVariantMap(variantMap);
     _positionAction.fromParentVariantMap(variantMap);
     _scaleAction.fromParentVariantMap(variantMap);
+    _flipHorizontalAction.fromParentVariantMap(variantMap);
+    _flipVerticalAction.fromParentVariantMap(variantMap);
 }
 
 QVariantMap GeneralAction::toVariantMap() const
@@ -135,6 +170,8 @@ QVariantMap GeneralAction::toVariantMap() const
     _nameAction.insertIntoVariantMap(variantMap);
     _positionAction.insertIntoVariantMap(variantMap);
     _scaleAction.insertIntoVariantMap(variantMap);
+    _flipHorizontalAction.insertIntoVariantMap(variantMap);
+    _flipVerticalAction.insertIntoVariantMap(variantMap);
 
     return variantMap;
 }

src/GeneralAction.h

@@ -75,6 +75,8 @@ class GeneralAction : public GroupAction
     StringAction& getNameAction() { return _nameAction; }
     PositionAction& getPositionAction() { return _positionAction; }
     DecimalAction& getScaleAction() { return _scaleAction; }
+    ToggleAction& getFlipHorizontalAction() { return _flipHorizontalAction; }
+    ToggleAction& getFlipVerticalAction() { return _flipVerticalAction; }
 
 protected:
     Layer*          _layer;                 /** Pointer to owning layer */
@@ -84,6 +86,8 @@ class GeneralAction : public GroupAction
     StringAction    _nameAction;            /** Name action */
     PositionAction  _positionAction;        /** Position action */
     DecimalAction   _scaleAction;           /** Scale action */
+    ToggleAction    _flipHorizontalAction; /** Flip horizontal action */
+    ToggleAction    _flipVerticalAction;   /** Flip vertical action */
 };
 
 Q_DECLARE_METATYPE(GeneralAction)

src/Layer.cpp

@@ -120,6 +120,8 @@ void Layer::initialize(ImageViewerPlugin* imageViewerPlugin, const mv::Dataset<I
 
     connect(&_generalAction.getScaleAction(), &DecimalAction::valueChanged, this, updateModelMatrixAndReRender);
     connect(&_generalAction.getPositionAction(), &PositionAction::changed, this, updateModelMatrixAndReRender);
+    connect(&_generalAction.getFlipHorizontalAction(), &ToggleAction::toggled, this, updateModelMatrixAndReRender);
+    connect(&_generalAction.getFlipVerticalAction(), &ToggleAction::toggled, this, updateModelMatrixAndReRender);
 
     updateChannelScalarData(_imageSettingsAction.getScalarChannel1Action());
     updateChannelScalarData(_imageSettingsAction.getScalarChannel2Action());
@@ -253,7 +255,20 @@ void Layer::updateModelMatrix()
         // Get reference to general action for getting the layer position and scale
         auto& generalAction = _generalAction;
 
-        QMatrix4x4 translateMatrix, scaleMatrix;
+        QMatrix4x4 translateMatrix, scaleMatrix, flipMatrix;
+        // Compute the flip matrix
+        if (generalAction.getFlipHorizontalAction().isChecked() && generalAction.getFlipVerticalAction().isChecked())
+        {
+            flipMatrix.scale(-1.0f, -1.0f, 1.0f);
+        }
+        else if (generalAction.getFlipHorizontalAction().isChecked())
+        {
+            flipMatrix.scale(-1.0f, 1.0f, 1.0f);
+        }
+        else if (generalAction.getFlipVerticalAction().isChecked())
+        {
+            flipMatrix.scale(1.0f, -1.0f, 1.0f);
+        }
 
         // Compute the translation matrix
         translateMatrix.translate(generalAction.getPositionAction().getXAction().getValue(), generalAction.getPositionAction().getYAction().getValue(), 0.0f);
@@ -265,7 +280,7 @@ void Layer::updateModelMatrix()
         scaleMatrix.scale(scaleFactor, scaleFactor, scaleFactor);
 
         // Assign model matrix
-        setModelMatrix(translateMatrix * scaleMatrix);
+        setModelMatrix(translateMatrix * scaleMatrix * flipMatrix);
     }
     catch (std::exception& e)
     {

src/LayersModel.cpp

@@ -113,6 +113,78 @@ void LayersModel::VisibleItem::setData(const QVariant& value, int role /* = Qt::
     }
 }
 
+LayersModel::FlipHorizontalItem::FlipHorizontalItem(Layer* layer) :
+    Item(layer)
+{
+    setCheckable(true);
+    setCheckState(getLayer()->getGeneralAction().getFlipHorizontalAction().isChecked() ? Qt::Checked : Qt::Unchecked);
+}
+
+QVariant LayersModel::FlipHorizontalItem::data(int role /*= Qt::UserRole + 1*/) const
+{
+    switch (role) {
+        case Qt::EditRole:
+            return getLayer()->getGeneralAction().getFlipHorizontalAction().isChecked();
+
+        case Qt::ToolTipRole:
+            return QString("Layer is flipped horizontally: %1").arg(data(Qt::EditRole).toBool() ? "yes" : "no");
+
+        case Qt::CheckStateRole:
+            return data(Qt::EditRole).toBool() ? Qt::CheckState::Checked : Qt::CheckState::Unchecked;
+
+        default:
+            break;
+    }
+
+    return Item::data(role);
+}
+void LayersModel::FlipHorizontalItem::setData(const QVariant& value, int role /* = Qt::UserRole + 1 */)
+{
+    switch (role) {
+        case Qt::CheckStateRole:
+            getLayer()->getGeneralAction().getFlipHorizontalAction().setChecked(value.toBool());
+            break;
+
+        default:
+            Item::setData(value, role);
+    }
+}
+LayersModel::FlipVerticalItem::FlipVerticalItem(Layer* layer) :
+    Item(layer)
+{
+    setCheckable(true);
+    setCheckState(getLayer()->getGeneralAction().getFlipVerticalAction().isChecked() ? Qt::Checked : Qt::Unchecked);
+}
+QVariant LayersModel::FlipVerticalItem::data(int role /*= Qt::UserRole + 1*/) const
+{
+    switch (role) {
+        case Qt::EditRole:
+            return getLayer()->getGeneralAction().getFlipVerticalAction().isChecked();
+
+        case Qt::ToolTipRole:
+            return QString("Layer is flipped vertically: %1").arg(data(Qt::EditRole).toBool() ? "yes" : "no");
+
+        case Qt::CheckStateRole:
+            return data(Qt::EditRole).toBool() ? Qt::CheckState::Checked : Qt::CheckState::Unchecked;
+
+        default:
+            break;
+    }
+
+    return Item::data(role);
+}
+void LayersModel::FlipVerticalItem::setData(const QVariant& value, int role /* = Qt::UserRole + 1 */)
+{
+    switch (role) {
+        case Qt::CheckStateRole:
+            getLayer()->getGeneralAction().getFlipVerticalAction().setChecked(value.toBool());
+            break;
+
+        default:
+            Item::setData(value, role);
+    }
+}
+
 LayersModel::ColorItem::ColorItem(Layer* layer) :
     Item(layer)
 {
@@ -389,6 +461,8 @@ LayersModel::Row::Row(Layer* layer)
     append(new HeightItem(layer));
     append(new ScaleItem(layer));
     append(new OpacityItem(layer));
+    append(new FlipHorizontalItem(layer));
+    append(new FlipVerticalItem(layer));
 }
 
 QMap<LayersModel::Column, LayersModel::ColumHeaderInfo> LayersModel::columnInfo = QMap<LayersModel::Column, LayersModel::ColumHeaderInfo>({
@@ -400,7 +474,9 @@ QMap<LayersModel::Column, LayersModel::ColumHeaderInfo> LayersModel::columnInfo
     { LayersModel::Column::ImageWidth, { "Width",  "Width", "Width of the image" } },
     { LayersModel::Column::ImageHeight, { "Height",  "Height", "Height of the image" } },
     { LayersModel::Column::Scale, { "Scale", "Scale", "Scale of the image" } },
-    { LayersModel::Column::Opacity, { "Opacity", "Opacity", "Layer transparency" } }
+    { LayersModel::Column::Opacity, { "Opacity", "Opacity", "Layer transparency" } }, 
+    { LayersModel::Column::FlipHorizontal, { "Horizontal Flip", "Horizontal Flip", "Whether the layer is flipped horizontally or not" } },
+    { LayersModel::Column::FlipVertical, { "Vertical Flip", "Vertical Flip", "Whether the layer is flipped vertically or not" } }
 });
 
 LayersModel::LayersModel(ImageViewerPlugin* imageViewerPlugin) :

src/LayersModel.h

@@ -28,6 +28,8 @@ class LayersModel final : public QStandardItemModel, public mv::util::Serializab
         ImageHeight,    /** Height of the image(s) */
         Scale,          /** Layer scale */
         Opacity,        /** Layer opacity */
+        FlipHorizontal, /** Flip layer horizontally */
+        FlipVertical,   /** Flip layer vertically */
 
         Count
     };
@@ -115,6 +117,43 @@ class LayersModel final : public QStandardItemModel, public mv::util::Serializab
         void setData(const QVariant& value, int role /* = Qt::UserRole + 1 */) override;
     };
 
+    class FlipHorizontalItem final : public Item {
+    public:
+
+        /**
+         * Construct with \p layer
+         * @param layer Pointer to layer to display item for
+         */
+        FlipHorizontalItem(Layer* layer);
+
+        /**
+         * Get model data for \p role
+         * @return Data for \p role in variant form
+         */
+        QVariant data(int role = Qt::UserRole + 1) const override;
+
+        /** Set model data to \p value for \p role */
+        void setData(const QVariant& value, int role /* = Qt::UserRole + 1 */) override;
+    };
+    class FlipVerticalItem final : public Item {
+    public:
+
+        /**
+         * Construct with \p layer
+         * @param layer Pointer to layer to display item for
+         */
+        FlipVerticalItem(Layer* layer);
+
+        /**
+         * Get model data for \p role
+         * @return Data for \p role in variant form
+         */
+        QVariant data(int role = Qt::UserRole + 1) const override;
+
+        /** Set model data to \p value for \p role */
+        void setData(const QVariant& value, int role /* = Qt::UserRole + 1 */) override;
+    };
+
     /** Standard model item class for the layer color */
     class ColorItem final : public Item {
     public: