Merge from master

CMakeLists.txt

@@ -67,10 +67,14 @@ set(Actions
     src/ScalarSourceAction.cpp
     src/SelectionAction.h
     src/SelectionAction.cpp
+    src/SelectionRestrictionAction.h
+    src/SelectionRestrictionAction.cpp
     src/SettingsAction.h
     src/SettingsAction.cpp
     src/SubsetAction.h
     src/SubsetAction.cpp
+    src/ZOrderingAction.h
+    src/ZOrderingAction.cpp
     src/ExportAction.h
     src/ExportAction.cpp
     src/DatasetsAction.h

src/MiscellaneousAction.cpp

@@ -10,15 +10,13 @@ const QColor MiscellaneousAction::DEFAULT_BACKGROUND_COLOR = qRgb(255, 255, 255)
 MiscellaneousAction::MiscellaneousAction(QObject* parent, const QString& title) :
     VerticalGroupAction(parent, title),
     _scatterplotPlugin(dynamic_cast<ScatterplotPlugin*>(parent->parent())),
-    _backgroundColorAction(this, "Background color"),
-    _randomizedDepthAction(this, "Randomized depth", true)
+    _backgroundColorAction(this, "Background color")
 {
     setIconByName("cog");
     setLabelSizingType(LabelSizingType::Auto);
     setConfigurationFlag(WidgetAction::ConfigurationFlag::ForceCollapsedInGroup);
 
     addAction(&_backgroundColorAction);
-    addAction(&_randomizedDepthAction);
 
     _backgroundColorAction.setColor(DEFAULT_BACKGROUND_COLOR);
 
@@ -32,15 +30,6 @@ MiscellaneousAction::MiscellaneousAction(QObject* parent, const QString& title)
 
     updateBackgroundColor();
 
-    const auto updateRandomizedDepth = [this]() -> void {
-        _scatterplotPlugin->getScatterplotWidget().setRandomizedDepthEnabled(_randomizedDepthAction.isChecked());
-    };
-
-    connect(&_randomizedDepthAction, &ToggleAction::toggled, this, [this, updateRandomizedDepth](bool toggled) {
-        updateRandomizedDepth();
-    });
-
-    updateRandomizedDepth();
 }
 
 QMenu* MiscellaneousAction::getContextMenu()
@@ -85,15 +74,13 @@ void MiscellaneousAction::fromVariantMap(const QVariantMap& variantMap)
     GroupAction::fromVariantMap(variantMap);
 
     _backgroundColorAction.fromParentVariantMap(variantMap);
-    _randomizedDepthAction.fromParentVariantMap(variantMap);
 }
 
 QVariantMap MiscellaneousAction::toVariantMap() const
 {
     auto variantMap = GroupAction::toVariantMap();
 
     _backgroundColorAction.insertIntoVariantMap(variantMap);
-    _randomizedDepthAction.insertIntoVariantMap(variantMap);
 
     return variantMap;
-}
+}

src/MiscellaneousAction.h

@@ -2,7 +2,6 @@
 
 #include <actions/VerticalGroupAction.h>
 #include <actions/ColorAction.h>
-#include <actions/ToggleAction.h>
 
 using namespace mv::gui;
 
@@ -66,12 +65,10 @@ class MiscellaneousAction : public VerticalGroupAction
 public: // Action getters
 
     ColorAction& getBackgroundColorAction() { return _backgroundColorAction; }
-    ToggleAction& getRandomizedDepthAction() { return _randomizedDepthAction; }
 
 private:
     ScatterplotPlugin*  _scatterplotPlugin;         /** Pointer to scatter plot plugin */
     ColorAction         _backgroundColorAction;     /** Color action for setting the background color action */
-    ToggleAction        _randomizedDepthAction;     /** whether the z-order of each point is to be randomized or not */
 
     static const QColor DEFAULT_BACKGROUND_COLOR;
 
@@ -80,4 +77,4 @@ class MiscellaneousAction : public VerticalGroupAction
 
 Q_DECLARE_METATYPE(MiscellaneousAction)
 
-inline const auto miscellaneousActionMetaTypeId = qRegisterMetaType<MiscellaneousAction*>("MiscellaneousAction");
+inline const auto miscellaneousActionMetaTypeId = qRegisterMetaType<MiscellaneousAction*>("MiscellaneousAction");

src/ScatterplotPlugin.cpp

@@ -117,6 +117,7 @@ ScatterplotPlugin::ScatterplotPlugin(const PluginFactory* factory) :
     _primaryToolbarAction->addAction(&_settingsAction->getDatasetsAction());
     _primaryToolbarAction->addAction(&_settingsAction->getRenderModeAction(), 3, GroupAction::Horizontal);
     _primaryToolbarAction->addAction(&_settingsAction->getPositionAction(), 1, GroupAction::Horizontal);
+    _primaryToolbarAction->addAction(&_settingsAction->getZOrderingAction(), 1, GroupAction::Horizontal);
     _primaryToolbarAction->addAction(&_settingsAction->getPlotAction(), 2, GroupAction::Horizontal);
     _primaryToolbarAction->addAction(&_settingsAction->getColoringAction());
     _primaryToolbarAction->addAction(&_settingsAction->getSubsetAction());
@@ -499,6 +500,78 @@ void ScatterplotPlugin::createSubset(const bool& fromSourceData /*= false*/, con
     subset->getDataHierarchyItem().select();
 }
 
+void ScatterplotPlugin::selectAllEligiblePoints()
+{
+    if (!_positionDataset.isValid())
+        return;
+
+    std::vector<std::uint32_t> globalIndices;
+    _positionDataset->getGlobalIndices(globalIndices);
+
+    std::vector<std::uint32_t> eligibleIndices;
+    eligibleIndices.reserve(globalIndices.size());
+
+    for (std::uint32_t localIndex = 0; localIndex < globalIndices.size(); ++localIndex) {
+        if (!_scatterPlotWidget->isSelectionExcluded(localIndex))
+            eligibleIndices.push_back(globalIndices[localIndex]);
+    }
+
+    _positionDataset->setSelectionIndices(eligibleIndices);
+    events().notifyDatasetDataSelectionChanged(_positionDataset->getSourceDataset<Points>());
+}
+
+void ScatterplotPlugin::invertEligiblePointSelection()
+{
+    if (!_positionDataset.isValid())
+        return;
+
+    const auto selection = _positionDataset->getSelection<Points>();
+
+    std::vector<bool> selected;
+    _positionDataset->selectedLocalIndices(selection->indices, selected);
+
+    std::vector<std::uint32_t> globalIndices;
+    _positionDataset->getGlobalIndices(globalIndices);
+
+    std::vector<std::uint32_t> invertedIndices;
+    invertedIndices.reserve(globalIndices.size());
+
+    for (std::uint32_t localIndex = 0; localIndex < globalIndices.size(); ++localIndex) {
+        if (!_scatterPlotWidget->isSelectionExcluded(localIndex) && (localIndex >= selected.size() || !selected[localIndex]))
+            invertedIndices.push_back(globalIndices[localIndex]);
+    }
+
+    _positionDataset->setSelectionIndices(invertedIndices);
+    events().notifyDatasetDataSelectionChanged(_positionDataset->getSourceDataset<Points>());
+}
+
+void ScatterplotPlugin::filterSelectionExcludedIndices(std::vector<std::uint32_t>& globalIndices) const
+{
+    if (!_positionDataset.isValid()) {
+        globalIndices.clear();
+        return;
+    }
+
+    std::vector<bool> selected;
+    _positionDataset->selectedLocalIndices(globalIndices, selected);
+
+    std::vector<std::uint32_t> localGlobalIndices;
+    _positionDataset->getGlobalIndices(localGlobalIndices);
+
+    globalIndices.clear();
+    globalIndices.reserve(localGlobalIndices.size());
+
+    for (std::uint32_t localIndex = 0; localIndex < localGlobalIndices.size(); ++localIndex) {
+        if (localIndex < selected.size() && selected[localIndex] && !_scatterPlotWidget->isSelectionExcluded(localIndex))
+            globalIndices.push_back(localGlobalIndices[localIndex]);
+    }
+}
+
+void ScatterplotPlugin::refreshSelection()
+{
+    updateSelection();
+}
+
 void ScatterplotPlugin::selectPoints()
 {
     if (getSettingsAction().getSelectionAction().getFreezeSelectionAction().isChecked())
@@ -536,6 +609,9 @@ void ScatterplotPlugin::selectPoints()
 
     // Go over all points in the dataset to see if they are selected
     for (std::uint32_t localPointIndex = 0; localPointIndex < _positions.size(); localPointIndex++) {
+	    if (_scatterPlotWidget->isSelectionExcluded(localPointIndex))
+	        continue;
+
 	    const auto& point = _positions[localPointIndex];
 
     	// Compute the offset of the point in the world space
@@ -610,6 +686,8 @@ void ScatterplotPlugin::selectPoints()
         }
     }
 
+    filterSelectionExcludedIndices(targetSelectionIndices);
+
     auto& navigationAction = navigator.getNavigationAction();
 
     navigationAction.getZoomSelectionAction().setEnabled(!targetSelectionIndices.empty() && navigationAction.isNavigationActive());
@@ -650,6 +728,9 @@ void ScatterplotPlugin::samplePoints()
     // Go over all points in the dataset to see if they should be sampled
     for (std::uint32_t localPointIndex = 0; localPointIndex < _positions.size(); localPointIndex++) {
 
+        if (_scatterPlotWidget->isSelectionExcluded(localPointIndex))
+            continue;
+
         // Compute the offset of the point in the world space
         const auto pointOffsetWorld = QPointF(_positions[localPointIndex].x - zoomRectangleWorld.left(), _positions[localPointIndex].y - zoomRectangleWorld.top());
 
@@ -1069,13 +1150,15 @@ void ScatterplotPlugin::updateData()
 
         // Pass the 2D points to the scatter plot widget
         _scatterPlotWidget->setData(&_positions);
+        _settingsAction->getZOrderingAction().updateScatterplotWidget();
 
         updateSelection();
     }
     else {
         _numPoints = 0;
         _positions.clear();
         _scatterPlotWidget->setData(&_positions);
+        _settingsAction->getZOrderingAction().updateScatterplotWidget();
     }
 }
 
@@ -1109,14 +1192,16 @@ void ScatterplotPlugin::updateSelection()
 
         sampledPoints.reserve(_positions.size());
 
-        for (auto selectionIndex : selection->indices)
-            sampledPoints.push_back(selectionIndex);
+        for (std::uint32_t localIndex = 0; localIndex < selected.size(); ++localIndex) {
+            if (selected[localIndex] && !_scatterPlotWidget->isSelectionExcluded(localIndex))
+                sampledPoints.push_back(localIndex);
+        }
 
         std::int32_t numberOfPoints = 0;
 
         QVariantList localPointIndices, globalPointIndices;
 
-        const auto numberOfSelectedPoints = selection->indices.size();
+        const auto numberOfSelectedPoints = sampledPoints.size();
 
         localPointIndices.reserve(static_cast<std::int32_t>(numberOfSelectedPoints));
         globalPointIndices.reserve(static_cast<std::int32_t>(numberOfSelectedPoints));
@@ -1152,6 +1237,8 @@ void ScatterplotPlugin::updateSelection()
             { "RenderMode", _settingsAction->getRenderModeAction().getCurrentText() }
 		});
     }
+
+    updateHeadsUpDisplay();
 }
 
 void ScatterplotPlugin::updateHeadsUpDisplay()
@@ -1181,6 +1268,16 @@ void ScatterplotPlugin::updateHeadsUpDisplay()
         //qDebug() << "ScatterplotPlugin::updateHeadsUpDisplay: point size dataset: " << pointPlotAction.getSizeAction().getCurrentDataset().isValid() << ", opacity dataset: " << pointPlotAction.getOpacityAction().getCurrentDataset().isValid();
         addMetaDataToHeadsUpDisplay("Size",    pointPlotAction.getSizeAction().getCurrentDataset(), datasetsItem);
         addMetaDataToHeadsUpDisplay("Opacity", pointPlotAction.getOpacityAction().getCurrentDataset(), datasetsItem);
+
+        const auto selectionItem = getHeadsUpDisplayAction().addHeadsUpDisplayItem("Selection", "", "");
+        const auto numberOfSelectedPoints   = _scatterPlotWidget->getNumberOfEffectivelySelectedPoints();
+        const auto numberOfSelectablePoints = _scatterPlotWidget->getNumberOfSelectablePoints();
+
+        getHeadsUpDisplayAction().addHeadsUpDisplayItem(
+            "Selected:",
+            QString("%1 of %2 selectable points").arg(numberOfSelectedPoints).arg(numberOfSelectablePoints),
+            "",
+            selectionItem);
     } else {
         getHeadsUpDisplayAction().addHeadsUpDisplayItem("No datasets loaded", "", "");
     }

src/ScatterplotPlugin.h

@@ -44,6 +44,9 @@ class ScatterplotPlugin : public ViewPlugin
 
 public:
     void createSubset(const bool& fromSourceData = false, const QString& name = "");
+    void selectAllEligiblePoints();
+    void invertEligiblePointSelection();
+    void refreshSelection();
 
 public: // Dimension picking
     void setXDimension(const std::int32_t& dimensionIndex);
@@ -111,6 +114,7 @@ class ScatterplotPlugin : public ViewPlugin
     void updateData();
     void updateSelection();
     void updateHeadsUpDisplayTextColor();
+    void filterSelectionExcludedIndices(std::vector<std::uint32_t>& globalIndices) const;
 
 public:
 
@@ -190,4 +194,4 @@ class ScatterplotPluginFactory : public ViewPluginFactory
      * @return URL of the GitHub repository (or readme markdown URL if set)
      */
     QUrl getRepositoryUrl() const override;
-};
+};