#include "ScatterplotPlugin.h"

#include "MappingUtils.h"

#include "ScatterplotWidget.h"

#include <Application.h>

#include <DataHierarchyItem.h>

#include <util/PixelSelectionTool.h>

#include <util/Timer.h>

#include <util/Serialization.h>

#include <ClusterData/ClusterData.h>

#include <ColorData/ColorData.h>

#include <PointData/PointData.h>

#include <SelectionGroup.h>

#include <graphics/Vector3f.h>

#include <widgets/DropWidget.h>

#include <widgets/ViewPluginLearningCenterOverlayWidget.h>

#include <actions/PluginTriggerAction.h>

#include <actions/ViewPluginSamplerAction.h>

#include <DatasetsMimeData.h>

#include <QAction>

#include <QApplication>

#include <QDebug>

#include <QMenu>

#include <QMetaType>

#include <QtCore>

#include <algorithm>

#include <cassert>

#include <exception>

#include <limits>

#include <map>

#include <stdexcept>

#include <vector>

#ifdef __cpp_lib_execution

#ifdef __GNUC__ // both TBB and Qt define emit keyword: undef

#undef emit

#endif

#include <execution>

#ifdef __GNUC__ // both TBB and Qt define emit keyword: def again

#define emit

#endif

#ifdef NDEBUG

#define MV_SCATTER_PARALLEL_EXECUTION std::execution::par,

#else

#define MV_SCATTER_PARALLEL_EXECUTION std::execution::seq,

#endif

#else

#define MV_SCATTER_PARALLEL_EXECUTION

#endif

#define VIEW_SAMPLING_HTML

//#define VIEW_SAMPLING_WIDGET

Q_PLUGIN_METADATA(IID "studio.manivault.ScatterplotPlugin")

using namespace mv;

using namespace mv::util;

namespace

{

Dataset<DatasetImpl> getTopDataset(const Dataset<DatasetImpl> dataset)

{

Dataset<DatasetImpl> topDataset = dataset;

while (topDataset->getParent().isValid())

topDataset = topDataset->getParent();

return topDataset;

}

}

ScatterplotPlugin::ScatterplotPlugin(const PluginFactory* factory) :

ViewPlugin(factory),

_dropWidget(nullptr),

_scatterPlotWidget(new ScatterplotWidget(this)),

_numPoints(0),

_settingsAction(new SettingsAction(this, "Settings")),

_primaryToolbarAction(new HorizontalToolbarAction(this, "Primary Toolbar"))

{

setObjectName("Scatterplot");

auto& shortcuts = getShortcuts();

shortcuts.add({ QKeySequence(Qt::Key_R), "Selection", "Rectangle (default)" });

shortcuts.add({ QKeySequence(Qt::Key_L), "Selection", "Lasso" });

shortcuts.add({ QKeySequence(Qt::Key_P), "Selection", "Polygon" });

shortcuts.add({ QKeySequence(Qt::Key_B), "Selection", "Circular brush (mouse wheel adjusts the radius)" });

shortcuts.add({ QKeySequence(Qt::SHIFT), "Selection", "Add to selection" });

shortcuts.add({ QKeySequence(Qt::CTRL), "Selection", "Remove from selection" });

shortcuts.add({ QKeySequence(Qt::Key_A), "Selection", "Select all" });

shortcuts.add({ QKeySequence(Qt::Key_E), "Selection", "Clear selection" });

shortcuts.add({ QKeySequence(Qt::Key_I), "Selection", "Invert selection" });

shortcuts.add({ QKeySequence(Qt::Key_S), "Render", "Scatter mode (default)" });

shortcuts.add({ QKeySequence(Qt::Key_D), "Render", "Density mode" });

shortcuts.add({ QKeySequence(Qt::Key_C), "Render", "Contour mode" });

shortcuts.add({ QKeySequence(Qt::Key_Plus), "Navigation", "Zoom in by 10%" });

shortcuts.add({ QKeySequence(Qt::Key_Minus), "Navigation", "Zoom out by 10%" });

shortcuts.add({ QKeySequence(Qt::ALT), "Navigation", "Pan (LMB down)" });

shortcuts.add({ QKeySequence(Qt::ALT), "Navigation", "Zoom (mouse wheel)" });

shortcuts.add({ QKeySequence(Qt::Key_O), "Navigation", "Original view" });

shortcuts.add({ QKeySequence(Qt::Key_H), "Navigation", "Zoom to selection" });

shortcuts.add({ QKeySequence(Qt::Key_F), "Navigation", "Zoom to window" });

_dropWidget = new DropWidget(_scatterPlotWidget);

getWidget().setFocusPolicy(Qt::ClickFocus);

_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());

_primaryToolbarAction->addAction(&_settingsAction->getClusteringAction());

_primaryToolbarAction->addAction(&_settingsAction->getSelectionAction());

_primaryToolbarAction->addAction(&getSamplerAction());

auto focusSelectionAction = new ToggleAction(this, "Focus selection");

focusSelectionAction->setIconByName("mouse-pointer");

connect(focusSelectionAction, &ToggleAction::toggled, this, [this](bool toggled) -> void {

_settingsAction->getPlotAction().getPointPlotAction().getFocusSelection().setChecked(toggled);

});

connect(&_settingsAction->getPlotAction().getPointPlotAction().getFocusSelection(), &ToggleAction::toggled, this, [this, focusSelectionAction](bool toggled) -> void {

focusSelectionAction->setChecked(toggled);

});

const auto updateReadOnly = [this, focusSelectionAction]() {

focusSelectionAction->setEnabled(getScatterplotWidget().getRenderMode() == ScatterplotWidget::SCATTERPLOT && _positionDataset.isValid());

};

updateReadOnly();

connect(_scatterPlotWidget, &ScatterplotWidget::renderModeChanged, this, updateReadOnly);

connect(&_positionDataset, &Dataset<Points>::changed, this, updateReadOnly);

//_secondaryToolbarAction.addAction(&_settingsAction->getMiscellaneousAction());

connect(_scatterPlotWidget, &ScatterplotWidget::customContextMenuRequested, this, [this](const QPoint& point) {

if (!_positionDataset.isValid())

return;

auto contextMenu = _settingsAction->getContextMenu();

contextMenu->addSeparator();

_positionDataset->populateContextMenu(contextMenu);

contextMenu->exec(getWidget().mapToGlobal(point));

});

_dropWidget->setDropIndicatorWidget(new DropWidget::DropIndicatorWidget(&getWidget(), "No data loaded", "Drag an item from the data hierarchy and drop it here to visualize data..."));

_dropWidget->initialize([this](const QMimeData* mimeData) -> DropWidget::DropRegions {

DropWidget::DropRegions dropRegions;

const auto datasetsMimeData = dynamic_cast<const DatasetsMimeData*>(mimeData);

if (datasetsMimeData == nullptr)

return dropRegions;

if (datasetsMimeData->getDatasetsCount() != 1)

return dropRegions;

const auto& dataset = datasetsMimeData->getDatasetsRef().first();

const auto datasetGuiName = dataset->text();

const auto datasetId = dataset->getId();

const auto dataType = dataset->getDataType();

const auto dataTypes = DataTypes({ PointType , ColorType, ClusterType });

// Check if the data type can be dropped

if (!dataTypes.contains(dataType))

dropRegions << new DropWidget::DropRegion(this, "Incompatible data", "This type of data is not supported", "exclamation-circle", false);

// Points dataset is about to be dropped

if (dataType == PointType) {

// Get points dataset from the core

auto candidateDataset = mv::data().getDataset<Points>(datasetId);

// Establish drop region description

const auto description = QString("Visualize %1 as points or density/contour map").arg(datasetGuiName);

if (!_positionDataset.isValid()) {

// Load as point positions when no dataset is currently loaded

dropRegions << new DropWidget::DropRegion(this, "Point position", description, "map-marker-alt", true, [this, candidateDataset]() {

_positionDataset = candidateDataset;

_settingsAction->getColoringAction().setCurrentColorDataset(nullptr);

});

}

else {

if (_positionDataset != candidateDataset && candidateDataset->getNumDimensions() >= 2) {

// The number of points is equal, so offer the option to replace the existing points dataset

dropRegions << new DropWidget::DropRegion(this, "Point position", description, "map-marker-alt", true, [this, candidateDataset]() {

_positionDataset = candidateDataset;

_settingsAction->getColoringAction().setCurrentColorDataset(nullptr);

});

}

// Accept for recoloring:

// 1. data with the same number of points

// 2. data which is derived from a parent that has the same number of points (e.g. for HSNE embeddings), where we can use global indices for mapping

// 3. data which has a fully-covering selection mapping, that we can use for setting colors. Mapping in order of preference:

// a) from color (or it's parent) to position

// b) from color to position (or it's parent)

// c) from source of position to color

// [1. Same number of points]

const auto numPointsCandidate = candidateDataset->getNumPoints();

const auto numPointsPosition = _positionDataset->getNumPoints();

const bool hasSameNumPoints = numPointsPosition == numPointsCandidate;

// [2. Derived from a parent]

const bool hasSameNumPointsAsFull = fullSourceHasSameNumPoints(_positionDataset, candidateDataset);

// [3. Full selection mapping]

const bool hasSelectionMapping = checkSelectionMapping(candidateDataset, _positionDataset);

if (hasSameNumPoints || hasSameNumPointsAsFull || hasSelectionMapping) {

// Offer the option to use the points dataset as source for points colors

dropRegions << new DropWidget::DropRegion(this, "Point color", QString("Colorize %1 points with %2").arg(_positionDataset->text(), candidateDataset->text()), "palette", true, [this, candidateDataset]() {

_settingsAction->getColoringAction().setCurrentColorDataset(candidateDataset); // calls addColorDataset internally

});

}

// Accept for resizing and opacity: Only data with the same number of points

if (hasSameNumPoints) {

// Offer the option to use the points dataset as source for points size

dropRegions << new DropWidget::DropRegion(this, "Point size", QString("Size %1 points with %2").arg(_positionDataset->text(), candidateDataset->text()), "ruler-horizontal", true, [this, candidateDataset]() {

_settingsAction->getPlotAction().getPointPlotAction().setCurrentPointSizeDataset(candidateDataset);

});

// Offer the option to use the points dataset as source for points opacity

dropRegions << new DropWidget::DropRegion(this, "Point opacity", QString("Set %1 points opacity with %2").arg(_positionDataset->text(), candidateDataset->text()), "brush", true, [this, candidateDataset]() {

_settingsAction->getPlotAction().getPointPlotAction().setCurrentPointOpacityDataset(candidateDataset);

});

}

}

}

// Cluster dataset is about to be dropped

if (dataType == ClusterType) {

// Get clusters dataset from the core

auto candidateDataset = mv::data().getDataset<Clusters>(datasetId);

// Establish drop region description

const auto description = QString("Color points by %1").arg(candidateDataset->text());

// Only allow user to color by clusters when there is a positions dataset loaded

if (_positionDataset.isValid()) {

if (_settingsAction->getColoringAction().hasColorDataset(candidateDataset)) {

// The clusters dataset is already loaded

dropRegions << new DropWidget::DropRegion(this, "Color", description, "palette", true, [this, candidateDataset]() {

_settingsAction->getColoringAction().setCurrentColorDataset(candidateDataset);

});

}

else {

if (candidateDataset.isValid())

{

// Check that the max index in the cluster data does not exceed the max index of the shown point data

auto getMaxIndex = [](const QVector<Cluster>& clusters) -> std::uint32_t

{

if (clusters.empty())

return std::numeric_limits<std::uint32_t>::lowest();

std::vector<std::uint32_t> clusterIndicesMax(clusters.size());

std::transform(

MV_SCATTER_PARALLEL_EXECUTION

clusters.cbegin(), clusters.cend(),

clusterIndicesMax.begin(),

[](const Cluster& cluster) -> std::uint32_t {

const std::vector<std::uint32_t>& indices = cluster.getIndices();

if (indices.empty())

return std::numeric_limits<std::uint32_t>::lowest();

return *std::ranges::max_element(indices);

});

return *std::max_element(

MV_SCATTER_PARALLEL_EXECUTION

clusterIndicesMax.cbegin(), clusterIndicesMax.cend());

};

const auto maxIndex = getMaxIndex(candidateDataset->getClusters());

if (maxIndex < numTotalPoints())

{

// Use the clusters set for points color

dropRegions << new DropWidget::DropRegion(this, "Color", description, "palette", true, [this, candidateDataset]() {

_settingsAction->getColoringAction().addColorDataset(candidateDataset);

_settingsAction->getColoringAction().setCurrentColorDataset(candidateDataset);

});

}

else

{

// Number of indices in clusters doesn't match point dataset

dropRegions << new DropWidget::DropRegion(this, "Incompatible data", "Cluster data does not match number of data points", "exclamation-circle", false);

}

}

}

}

else {

// Only allow user to color by clusters when there is a positions dataset loaded

dropRegions << new DropWidget::DropRegion(this, "No points data loaded", "Clusters can only be visualized in concert with points data", "exclamation-circle", false);

}

}

return dropRegions;

});

auto& selectionAction = _settingsAction->getSelectionAction();

getSamplerAction().initialize(this, &selectionAction.getPixelSelectionAction(), &selectionAction.getSamplerPixelSelectionAction());

getSamplerAction().getEnabledAction().setChecked(false);

getLearningCenterAction().addVideos(QStringList({ "Practitioner", "Developer" }));

setOverlayActionsTargetWidget(_scatterPlotWidget);

connect(&mv::projects(), &AbstractProjectManager::projectOpened, this, &ScatterplotPlugin::updateHeadsUpDisplay);

}

ScatterplotPlugin::~ScatterplotPlugin()

{

}

void ScatterplotPlugin::init()

{

getWidget().setMouseTracking(true);

auto layout = new QVBoxLayout();

layout->setContentsMargins(0, 0, 0, 0);

layout->setSpacing(0);

layout->addWidget(_primaryToolbarAction->createWidget(&getWidget()));

layout->addWidget(_scatterPlotWidget, 100);

auto& navigationAction = _scatterPlotWidget->getPointRendererNavigator().getNavigationAction();

if (auto navigationWidget = navigationAction.createWidget(&getWidget())) {

layout->addWidget(navigationWidget);

layout->setAlignment(navigationWidget, Qt::AlignCenter);

navigationAction.setParent(_settingsAction);

}

getWidget().setLayout(layout);

connect(_scatterPlotWidget, &ScatterplotWidget::initialized, this, &ScatterplotPlugin::updateData);

connect(&_scatterPlotWidget->getPixelSelectionTool(), &PixelSelectionTool::areaChanged, [this]() {

if (_scatterPlotWidget->getPixelSelectionTool().isNotifyDuringSelection()) {

selectPoints();

}

});

connect(&_scatterPlotWidget->getPixelSelectionTool(), &PixelSelectionTool::ended, [this]() {

if (_scatterPlotWidget->getPixelSelectionTool().isNotifyDuringSelection())

return;

selectPoints();

});

connect(&getSamplerAction(), &ViewPluginSamplerAction::sampleContextRequested, this, &ScatterplotPlugin::samplePoints);

connect(&_positionDataset, &Dataset<Points>::changed, this, &ScatterplotPlugin::positionDatasetChanged);

connect(&_positionDataset, &Dataset<Points>::dataChanged, this, [this]() -> void {

updateData();

updateHeadsUpDisplay();

});

connect(&_positionDataset, &Dataset<Points>::dataSelectionChanged, this, &ScatterplotPlugin::updateSelection);

connect(&_positionDataset, &Dataset<>::guiNameChanged, this, &ScatterplotPlugin::updateHeadsUpDisplay);

connect(&_settingsAction->getMiscellaneousAction().getBackgroundColorAction(), &ColorAction::colorChanged, this, &ScatterplotPlugin::updateHeadsUpDisplayTextColor);

connect(&getScatterplotWidget().getPointRendererNavigator().getNavigationAction().getZoomSelectionAction(), &TriggerAction::triggered, this, [this]() -> void {

if (_selectionBoundaries.isValid())

_scatterPlotWidget->getPointRendererNavigator().setZoomRectangleWorld(_selectionBoundaries);

});

_scatterPlotWidget->installEventFilter(this);

getLearningCenterAction().getViewPluginOverlayWidget()->setTargetWidget(_scatterPlotWidget);

#ifdef VIEW_SAMPLING_HTML

getSamplerAction().setHtmlViewGeneratorFunction([this](const ViewPluginSamplerAction::SampleContext& toolTipContext) -> QString {

QStringList localPointIndices, globalPointIndices;

for (const auto& localPointIndex : toolTipContext["LocalPointIndices"].toList())

localPointIndices << QString::number(localPointIndex.toInt());

for (const auto& globalPointIndex : toolTipContext["GlobalPointIndices"].toList())

globalPointIndices << QString::number(globalPointIndex.toInt());

if (localPointIndices.isEmpty())

return {};

return QString("<table> \

<tr> \

<td><b>Point ID's: </b></td> \

<td>%1</td> \

</tr> \

</table>").arg(globalPointIndices.join(", "));

});

#endif

#ifdef VIEW_SAMPLING_WIDGET

auto pointIndicesTableWidget = new QTableWidget(5, 2);

pointIndicesTableWidget->setHorizontalHeaderLabels({ "Local point index", "Global point index" });

getSamplerAction().setWidgetViewGeneratorFunction([this, pointIndicesTableWidget](const ViewPluginSamplerAction::SampleContext& sampleContext) -> QWidget* {

const auto localPointIndices = sampleContext["LocalPointIndices"].toList();

const auto globalPointIndices = sampleContext["GlobalPointIndices"].toList();

pointIndicesTableWidget->setRowCount(localPointIndices.count());

for (int i = 0; i < localPointIndices.count(); ++i) {

pointIndicesTableWidget->setItem(i, 0, new QTableWidgetItem(QString::number(localPointIndices[i].toInt())));

pointIndicesTableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(globalPointIndices[i].toInt())));

}

pointIndicesTableWidget->resizeColumnsToContents();

return pointIndicesTableWidget;

});

#endif

auto& datasetsAction = _settingsAction->getDatasetsAction();

auto& pointPlotAction = _settingsAction->getPlotAction().getPointPlotAction();

connect(&datasetsAction.getPositionDatasetPickerAction(), &DatasetPickerAction::currentIndexChanged, this, &ScatterplotPlugin::updateHeadsUpDisplay);

connect(&datasetsAction.getColorDatasetPickerAction(), &DatasetPickerAction::currentIndexChanged, this, &ScatterplotPlugin::updateHeadsUpDisplay);

connect(&pointPlotAction.getSizeAction(), &ScalarAction::sourceSelectionChanged, this, &ScatterplotPlugin::updateHeadsUpDisplay);

connect(&pointPlotAction.getOpacityAction(), &ScalarAction::sourceSelectionChanged, this, &ScatterplotPlugin::updateHeadsUpDisplay);

updateHeadsUpDisplay();

updateHeadsUpDisplayTextColor();

if (mv::projects().isOpeningProject()) {

connect(&mv::projects(), &AbstractProjectManager::projectOpened, this, [this, &datasetsAction]() -> void {

datasetsAction.invalidateDatasetPickerActionFilters();

});

} else {

datasetsAction.invalidateDatasetPickerActionFilters();

}

connect(&_settingsAction->getPlotAction().getPointPlotAction().getSizeAction(), &ScalarAction::sourceDataChanged, this, [this]() -> void {

_scatterPlotWidget->update();

});

connect(&_settingsAction->getPlotAction().getPointPlotAction().getOpacityAction(), &ScalarAction::sourceDataChanged, this, [this]() -> void {

_scatterPlotWidget->update();

});

}

void ScatterplotPlugin::loadData(const Datasets& datasets)

{

// Exit if there is nothing to load

if (datasets.isEmpty())

return;

// Load the first dataset

_positionDataset = datasets.first();

// And set the coloring mode to constant

_settingsAction->getColoringAction().getColorByAction().setCurrentIndex(0);

}

void ScatterplotPlugin::createSubset(const bool& fromSourceData /*= false*/, const QString& name /*= ""*/)

{

// Create the subset

mv::Dataset<DatasetImpl> subset;

if (fromSourceData)

// Make subset from the source data, this is not the displayed data, so no restrictions here

subset = _positionSourceDataset->createSubsetFromSelection(name, _positionSourceDataset);

else

// Avoid making a bigger subset than the current data by restricting the selection to the current data

subset = _positionDataset->createSubsetFromVisibleSelection(name, _positionDataset);

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())

return;

auto& pixelSelectionTool = _scatterPlotWidget->getPixelSelectionTool();

auto renderer = _settingsAction->getRenderModeAction().getCurrentIndex() > 0 ? dynamic_cast<Renderer2D*>(&_scatterPlotWidget->_densityRenderer) : dynamic_cast<Renderer2D*>(&_scatterPlotWidget->_pointRenderer);

auto& navigator = renderer->getNavigator();

// Only proceed with a valid points position dataset and when the pixel selection tool is active

if (!_positionDataset.isValid() || !pixelSelectionTool.isActive() || navigator.isNavigating() || !pixelSelectionTool.isEnabled())

return;

auto selectionAreaImage = pixelSelectionTool.getAreaPixmap().toImage();

auto selectionSet = _positionDataset->getSelection<Points>();

std::vector<std::uint32_t> targetSelectionIndices;

targetSelectionIndices.reserve(_positionDataset->getNumPoints());

std::vector<std::uint32_t> localGlobalIndices;

_positionDataset->getGlobalIndices(localGlobalIndices);

const auto zoomRectangleWorld = navigator.getZoomRectangleWorld();

const auto screenRectangle = QRect(QPoint(), renderer->getRenderSize());

float boundaries[4]{

std::numeric_limits<float>::max(),

std::numeric_limits<float>::lowest(),

std::numeric_limits<float>::max(),

std::numeric_limits<float>::lowest()

};

// 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

const auto pointOffsetWorld = QPointF(point.x - zoomRectangleWorld.left(), point.y - zoomRectangleWorld.top());

// Normalize it

const auto pointOffsetWorldNormalized = QPointF(pointOffsetWorld.x() / zoomRectangleWorld.width(), pointOffsetWorld.y() / zoomRectangleWorld.height());

// Convert it to screen space

const auto pointOffsetScreen = QPoint(pointOffsetWorldNormalized.x() * screenRectangle.width(), screenRectangle.height() - pointOffsetWorldNormalized.y() * screenRectangle.height());

// Continue to next point if the point is outside the screen

if (!screenRectangle.contains(pointOffsetScreen))

continue;

// If the corresponding pixel is not transparent, add the point to the selection

if (selectionAreaImage.pixelColor(pointOffsetScreen).alpha() > 0) {

targetSelectionIndices.push_back(localGlobalIndices[localPointIndex]);

boundaries[0] = std::min(boundaries[0], point.x);

boundaries[1] = std::max(boundaries[1], point.x);

boundaries[2] = std::min(boundaries[2], point.y);

boundaries[3] = std::max(boundaries[3], point.y);

}

}

_selectionBoundaries = QRectF(boundaries[0], boundaries[2], boundaries[1] - boundaries[0], boundaries[3] - boundaries[2]);

switch (const auto selectionModifier = pixelSelectionTool.isAborted() ? PixelSelectionModifierType::Subtract : pixelSelectionTool.getModifier())

{

case PixelSelectionModifierType::Replace:

break;

case PixelSelectionModifierType::Add:

case PixelSelectionModifierType::Subtract:

{

// Get reference to the indices of the selection set

auto& selectionSetIndices = selectionSet->indices;

// Create a set from the selection set indices

QSet<std::uint32_t> set(selectionSetIndices.begin(), selectionSetIndices.end());

switch (selectionModifier)

{

// Add points to the current selection

case PixelSelectionModifierType::Add:

{

// Add indices to the set

for (const auto& targetIndex : targetSelectionIndices)

set.insert(targetIndex);

break;

}

// Remove points from the current selection

case PixelSelectionModifierType::Subtract:

{

// Remove indices from the set

for (const auto& targetIndex : targetSelectionIndices)

set.remove(targetIndex);

break;

}

case PixelSelectionModifierType::Replace:

break;

}

targetSelectionIndices = std::vector<std::uint32_t>(set.begin(), set.end());

break;

}

}

filterSelectionExcludedIndices(targetSelectionIndices);

auto& navigationAction = navigator.getNavigationAction();

navigationAction.getZoomSelectionAction().setEnabled(!targetSelectionIndices.empty() && navigationAction.isNavigationActive());

_positionDataset->setSelectionIndices(targetSelectionIndices);

events().notifyDatasetDataSelectionChanged(_positionDataset->getSourceDataset<Points>());

}

void ScatterplotPlugin::samplePoints()

{

auto& samplerPixelSelectionTool = _scatterPlotWidget->getSamplerPixelSelectionTool();

if (!_positionDataset.isValid() || _scatterPlotWidget->_pointRenderer.getNavigator().isNavigating() || !samplerPixelSelectionTool.isActive())

return;

auto selectionAreaImage = samplerPixelSelectionTool.getAreaPixmap().toImage();

std::vector<std::uint32_t> targetSelectionIndices;

targetSelectionIndices.reserve(_positionDataset->getNumPoints());

std::vector<std::uint32_t> localGlobalIndices;

_positionDataset->getGlobalIndices(localGlobalIndices);

std::vector<char> focusHighlights(_positions.size());

std::vector<std::pair<float, std::uint32_t>> sampledPoints;

auto& pointRenderer = _scatterPlotWidget->_pointRenderer;

auto& navigator = pointRenderer.getNavigator();

const auto zoomRectangleWorld = navigator.getZoomRectangleWorld();

const auto screenRectangle = QRect(QPoint(), pointRenderer.getRenderSize());

const auto mousePositionWorld = pointRenderer.getScreenPointToWorldPosition(pointRenderer.getNavigator().getViewMatrix(), _scatterPlotWidget->mapFromGlobal(QCursor::pos()));

// 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());

// Normalize it

const auto pointOffsetWorldNormalized = QPointF(pointOffsetWorld.x() / zoomRectangleWorld.width(), pointOffsetWorld.y() / zoomRectangleWorld.height());

// Convert it to screen space

const auto pointOffsetScreen = QPoint(pointOffsetWorldNormalized.x() * screenRectangle.width(), screenRectangle.height() - pointOffsetWorldNormalized.y() * screenRectangle.height());

// Continue to next point if the point is outside the screen

if (!screenRectangle.contains(pointOffsetScreen))

continue;

// If the corresponding pixel is not transparent, add the point to the selection

if (selectionAreaImage.pixelColor(pointOffsetScreen).alpha() > 0) {

const auto sample = std::pair((QVector2D(_positions[localPointIndex].x, _positions[localPointIndex].y) - mousePositionWorld.toVector2D()).length(), localPointIndex);

sampledPoints.emplace_back(sample);

}

}

QVariantList localPointIndices, globalPointIndices, distances;

localPointIndices.reserve(static_cast<std::int32_t>(sampledPoints.size()));

globalPointIndices.reserve(static_cast<std::int32_t>(sampledPoints.size()));

distances.reserve(static_cast<std::int32_t>(sampledPoints.size()));

std::int32_t numberOfPoints = 0;

std::sort(sampledPoints.begin(), sampledPoints.end(), [](const auto& sampleA, const auto& sampleB) -> bool {

return sampleB.first > sampleA.first;

});

for (const auto& sampledPoint : sampledPoints) {

if (getSamplerAction().getRestrictNumberOfElementsAction().isChecked() && numberOfPoints >= getSamplerAction().getMaximumNumberOfElementsAction().getValue())

break;

const auto& distance = sampledPoint.first;

const auto& localPointIndex = sampledPoint.second;

const auto& globalPointIndex = localGlobalIndices[localPointIndex];

distances << distance;

localPointIndices << localPointIndex;

globalPointIndices << globalPointIndex;

focusHighlights[localPointIndex] = true;

numberOfPoints++;

}

if (getSamplerAction().getHighlightFocusedElementsAction().isChecked())

const_cast<PointRenderer&>(_scatterPlotWidget->getPointRenderer()).setFocusHighlights(focusHighlights, static_cast<std::int32_t>(focusHighlights.size()));

_scatterPlotWidget->update();

auto& coloringAction = _settingsAction->getColoringAction();

getSamplerAction().setSampleContext({

{ "PositionDatasetID", _positionDataset.getDatasetId() },

{ "ColorDatasetID", _settingsAction->getColoringAction().getCurrentColorDataset().getDatasetId() },

{ "LocalPointIndices", localPointIndices },

{ "GlobalPointIndices", globalPointIndices },

{ "Distances", distances },

{ "ColorBy", coloringAction.getColorByAction().getCurrentText() },

{ "ConstantColor", coloringAction.getConstantColorAction().getColor() },

{ "ColorMap1D", coloringAction.getColorMap1DAction().getColorMapImage() },

{ "ColorMap2D", coloringAction.getColorMap2DAction().getColorMapImage() },

{ "ColorDimensionIndex", coloringAction.getDimensionAction().getCurrentDimensionAction().getCurrentIndex() },

{ "RenderMode", _settingsAction->getRenderModeAction().getCurrentText() }

});

}

Dataset<Points>& ScatterplotPlugin::getPositionDataset()

{

return _positionDataset;

}

Dataset<Points>& ScatterplotPlugin::getPositionSourceDataset()

{

return _positionSourceDataset;

}

void ScatterplotPlugin::positionDatasetChanged()

{

_dropWidget->setShowDropIndicator(!_positionDataset.isValid());

_scatterPlotWidget->getPixelSelectionTool().setEnabled(_positionDataset.isValid());

if (!_positionDataset.isValid())

return;

_positionSourceDataset = _positionDataset->getSourceDataset<Points>();

_numPoints = _positionDataset->getNumPoints();

_scatterPlotWidget->getPointRendererNavigator().resetView(true);

_scatterPlotWidget->getDensityRendererNavigator().resetView(true);

updateData();

}

std::uint64_t ScatterplotPlugin::numTotalPoints() const

{

if (!_positionDataset.isValid())

return 0;

return _positionDataset->isDerivedData()

? _positionSourceDataset->getFullDataset<Points>()->getNumPoints()

: _positionDataset->getFullDataset<Points>()->getNumPoints();

}

bool ScatterplotPlugin::mapColorScalars(const Dataset<Points>& pointsColor, const std::uint32_t& dimensionIndex, std::vector<float>& colorScalars)

{

// Only proceed with valid points dataset

if (!pointsColor.isValid())

return false;

const auto numColorPoints = pointsColor->getNumPoints();

// Generate point colorScalars for color mapping

colorScalars.clear();

pointsColor->extractDataForDimension(colorScalars, dimensionIndex);

// If number of points do not match, use a mapping

// prefer global IDs (for derived data) over selection mapping

// prefer color to position over position to color over source of position to color

if (numColorPoints != _numPoints) {

std::vector<float> mappedColorScalars(_numPoints, std::numeric_limits<float>::lowest());

try {

const bool hasSameNumPointsAsFull = fullSourceHasSameNumPoints(_positionDataset, pointsColor);

if (hasSameNumPointsAsFull) {

std::vector<std::uint32_t> globalIndices = {};

_positionDataset->getGlobalIndices(globalIndices);

for (std::int32_t localIndex = 0; localIndex < globalIndices.size(); localIndex++) {

mappedColorScalars[localIndex] = colorScalars[globalIndices[localIndex]];

}

}

else if ( // mapping from color data set to position data set

const auto [selectionMapping, numPointsTarget] = getSelectionMappingColorsToPositions(pointsColor, _positionDataset);

/* check if valid */

selectionMapping != nullptr &&

numPointsTarget == _numPoints &&

checkSurjectiveMapping(*selectionMapping, numPointsTarget)

)

{

// Map values like selection

const mv::SelectionMap::Map& mapColorsToPositions = selectionMapping->getMapping().getMap();

for (const auto& [fromColorID, vecOfPositionIDs] : mapColorsToPositions) {

for (const std::uint32_t toPositionID : vecOfPositionIDs) {

mappedColorScalars[toPositionID] = colorScalars[fromColorID];

}

}

}

else if ( // mapping from position data set to color data set

const auto [selectionMapping, numPointsTarget] = getSelectionMappingPositionsToColors(_positionDataset, pointsColor);

/* check if valid */

selectionMapping != nullptr &&

numPointsTarget == numColorPoints &&

checkSurjectiveMapping(*selectionMapping, numPointsTarget)

)

{

// Map values like selection (in reverse, use first value that occurs)

const mv::SelectionMap::Map& mapPositionsToColors = selectionMapping->getMapping().getMap();

for (const auto& [fromPositionID, vecOfColorIDs] : mapPositionsToColors) {

if (mappedColorScalars[fromPositionID] != std::numeric_limits<float>::lowest())

continue;

for (const std::uint32_t toColorID : vecOfColorIDs) {

mappedColorScalars[fromPositionID] = colorScalars[toColorID];

}

}

}

else if ( // mapping from source of position data set to color data set

const auto [selectionMapping, numPointsTarget] = getSelectionMappingPositionSourceToColors(_positionDataset, pointsColor);

/* check if valid */

selectionMapping != nullptr &&

numPointsTarget == numColorPoints &&

checkSurjectiveMapping(*selectionMapping, numPointsTarget)

)

{

// the selection map is from full source data of positions data to pointsColor

// we need to use both the global indices of the positions (i.e. in the source) and the linked data mapping

const mv::SelectionMap::Map& mapGlobalToColors = selectionMapping->getMapping().getMap();

std::vector<std::uint32_t> globalIndices = {};

_positionDataset->getGlobalIndices(globalIndices);

for (std::int32_t localIndex = 0; localIndex < globalIndices.size(); localIndex++) {

if (mappedColorScalars[localIndex] != std::numeric_limits<float>::lowest())

continue;

const auto& indxColors = mapGlobalToColors.at(globalIndices[localIndex]); // from full source (parent) to colorDataset

for (const auto& indColors : indxColors) {

mappedColorScalars[localIndex] = colorScalars[indColors];

}

}

}

else {

throw std::runtime_error("Coloring data set does not match position data set in a known way, aborting attempt to color plot");

}

}

catch (const std::exception& e) {

qDebug() << "ScatterplotPlugin::mapColorScalars: mapping failed -> " << e.what();

return false;

}

catch (...) {

qDebug() << "ScatterplotPlugin::mapColorScalars: mapping failed for an unknown reason.";

return false;

}

std::swap(mappedColorScalars, colorScalars);

}

assert(colorScalars.size() == _numPoints);

return true;

}

void ScatterplotPlugin::loadColors(const Dataset<Points>& pointsColor, const std::uint32_t& dimensionIndex)

{

std::vector<float> colorScalars = {};

if (!mapColorScalars(pointsColor, dimensionIndex, colorScalars)) {

_settingsAction->getColoringAction().getColorByAction().setCurrentIndex(0); // reset to color by constant

return;

}

// Assign colorScalars and scalar effect

_scatterPlotWidget->setScalars(colorScalars);

_scatterPlotWidget->setScalarEffect(PointEffect::Color);

_settingsAction->getColoringAction().updateColorMapActionScalarRange();

// Render

getWidget().update();

}

void ScatterplotPlugin::loadColors2D(const Dataset<Points>& pointsColor, const std::uint32_t& dimensionIndexX, const std::uint32_t& dimensionIndexY)

{

std::vector<float> colorScalarsX = {};

std::vector<float> colorScalarsY = {};

if (!mapColorScalars(pointsColor, dimensionIndexX, colorScalarsX) ||

!mapColorScalars(pointsColor, dimensionIndexY, colorScalarsY)) {

_settingsAction->getColoringAction().getColorByAction().setCurrentIndex(0); // reset to color by constant

return;

}

// Assign both channels and the two-channel 2D coloring effect

_scatterPlotWidget->setScalars(colorScalarsX);

_scatterPlotWidget->setScalars2(colorScalarsY);

_scatterPlotWidget->setScalarEffect(PointEffect::Color2DChannels);

// Render

getWidget().update();

}