GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1068:e3aea966fca1

Tooltip for spectrograms (4)...

Alexandre Leroux -

r1068:e3aea966fca1

parent child

Context file:

r1068:e3aea966fca1

Collapse all files

gui/src/Visualization/AxisRenderingUtils.cpp +4 -1

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/SqpColorScale.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
+            const auto NUMBER_FORMAT = 'g';
+            const auto NUMBER_PRECISION = 9;
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis, QCPAxis::ScaleType scaleType)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else if (scaleType == QCPAxis::stLogarithmic) {
                     return QSharedPointer<QCPAxisTickerLog>::create();
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /**
              * Sets properties of the axis passed as parameter
              * @param axis the axis to set
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
             void setAxisProperties(QCPAxis &axis, const Unit &unit,
                                    QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(unit.m_Name);
                 // scale type
                 axis.setScaleType(scaleType);
                 if (scaleType == QCPAxis::stLogarithmic) {
                     // Scientific notation
                     axis.setNumberPrecision(0);
                     axis.setNumberFormat("eb");
                 }
                 // ticker (depending on the type of unit)
                 axis.setTicker(axisTicker(unit.m_TimeUnit, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
                 static void setProperties(T &, QCustomPlot &, SqpColorScale &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of AxisSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                            or std::is_base_of<VectorSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto yAxisUnit = dataSeries.yAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, colorScale.m_Scale);
                     colorScale.m_Scale->setType(QCPAxis::atTop);
                     colorScale.m_Scale->setMinimumMargins(QMargins{0, 0, 0, 0});
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
                     for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
                         colorScale.m_Scale->setMarginGroup(it.key(), it.value());
                     }
                     // Set color scale properties
                     setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
                 }
             };
             /**
              * Default implementation of IAxisHelper, which takes data series to set axes properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
                 explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) override
                 {
                     AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
-                    return QString::number(value);
+                    return QString::number(value, NUMBER_FORMAT, NUMBER_PRECISION);
                 }
             }
             std::unique_ptr<IAxisHelper>
             IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
                 }
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +6 0

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/AxisRenderingUtils.h"
             #include "Visualization/ColorScaleEditor.h"
             #include "Visualization/PlottablesRenderingUtils.h"
             #include "Visualization/SqpColorScale.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             namespace {
             /// Name of the axes layer in QCustomPlot
             const auto AXES_LAYER = QStringLiteral("axes");
             /// Icon used to show x-axis properties
             const auto HIDE_AXIS_ICON_PATH = QStringLiteral(":/icones/down.png");
             /// Name of the overlay layer in QCustomPlot
             const auto OVERLAY_LAYER = QStringLiteral("overlay");
             /// Pixmap used to show x-axis properties
             const auto SHOW_AXIS_ICON_PATH = QStringLiteral(":/icones/up.png");
             /// Tooltip format for graphs
             const auto GRAPH_TOOLTIP_FORMAT = QStringLiteral("key: %1\nvalue: %2");
+            /// Tooltip format for colormaps
+            const auto COLORMAP_TOOLTIP_FORMAT = QStringLiteral("x: %1\ny: %2\nvalue: %3");
             /// Offset used to shift the tooltip of the mouse
             const auto TOOLTIP_OFFSET = QPoint{20, 20};
             /// Tooltip display rectangle (the tooltip is hidden when the mouse leaves this rectangle)
             const auto TOOLTIP_RECT = QRect{10, 10, 10, 10};
             /// Timeout after which the tooltip is displayed
             const auto TOOLTIP_TIMEOUT = 500;
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsCircle);
                 tracer.setSize(3);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
             }
             QPixmap pixmap(const QString &iconPath) noexcept
             {
                 return QIcon{iconPath}.pixmap(QSize{16, 16});
             }
             void initClosePixmapStyle(QCPItemPixmap &pixmap) noexcept
             {
                 // Icon
                 pixmap.setPixmap(
                     sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton).pixmap(QSize{16, 16}));
                 // Position
                 pixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 pixmap.topLeft->setCoords(1, 0);
                 pixmap.setClipToAxisRect(false);
                 // Can be selected
                 pixmap.setSelectable(true);
             }
             void initXAxisPixmapStyle(QCPItemPixmap &itemPixmap) noexcept
             {
                 // Icon
                 itemPixmap.setPixmap(pixmap(HIDE_AXIS_ICON_PATH));
                 // Position
                 itemPixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 itemPixmap.topLeft->setCoords(0, 1);
                 itemPixmap.setClipToAxisRect(false);
                 // Can be selected
                 itemPixmap.setSelectable(true);
             }
             void initTitleTextStyle(QCPItemText &text) noexcept
             {
                 // Font and background styles
                 text.setColor(Qt::gray);
                 text.setBrush(Qt::white);
                 // Position
                 text.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 text.position->setType(QCPItemPosition::ptAxisRectRatio);
                 text.position->setCoords(0.5, 0);
             }
             /**
              * Returns the cell index (x or y) of a colormap according to the coordinate passed in parameter.
              * This method handles the fact that a colormap axis can be logarithmic or linear.
              * @param colormap the colormap for which to calculate the index
              * @param coord the coord to convert to cell index
              * @param xCoord calculates the x index if true, calculates y index if false
              * @return the cell index
              */
             int colorMapCellIndex(const QCPColorMap &colormap, double coord, bool xCoord)
             {
                 // Determines the axis of the colormap according to xCoord, and whether it is logarithmic or not
                 auto isLogarithmic = (xCoord ? colormap.keyAxis() : colormap.valueAxis())->scaleType()
                                      == QCPAxis::stLogarithmic;
                 if (isLogarithmic) {
                     // For a logarithmic axis we can't use the conversion method of colormap, so we calculate
                     // the index manually based on the position of the coordinate on the axis
                     // Gets the axis range and the number of values between range bounds to calculate the step
                     // between each value of the range
                     auto range = xCoord ? colormap.data()->keyRange() : colormap.data()->valueRange();
                     auto nbValues = (xCoord ? colormap.data()->keySize() : colormap.data()->valueSize()) - 1;
                     auto valueStep
                         = (std::log10(range.upper) - std::log10(range.lower)) / static_cast<double>(nbValues);
                     // According to the coord position, calculates the closest index in the range
                     return std::round((std::log10(coord) - std::log10(range.lower)) / valueStep);
                 }
                 else {
                     // For a linear axis, we use the conversion method of colormap
                     int index;
                     if (xCoord) {
                         colormap.data()->coordToCell(coord, 0., &index, nullptr);
                     }
                     else {
                         colormap.data()->coordToCell(0., coord, nullptr, &index);
                     }
                     return index;
                 }
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget &graphWidget)
                         : m_Plot{graphWidget.plot()},
                           m_PointTracer{new QCPItemTracer{&m_Plot}},
                           m_TracerTimer{},
                           m_ClosePixmap{new QCPItemPixmap{&m_Plot}},
                           m_TitleText{new QCPItemText{&m_Plot}},
                           m_XAxisPixmap{new QCPItemPixmap{&m_Plot}},
                           m_ShowXAxis{true},
                           m_XAxisLabel{},
                           m_ColorScale{SqpColorScale{m_Plot}}
                 {
                     initPointTracerStyle(*m_PointTracer);
                     m_TracerTimer.setInterval(TOOLTIP_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                     // Inits "close button" in plot overlay
                     m_ClosePixmap->setLayer(OVERLAY_LAYER);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
                     QObject::connect(m_ClosePixmap, &QCPItemPixmap::selectionChanged,
                                      [&graphWidget](bool selected) {
                                          if (selected) {
                                              graphWidget.close();
                                          }
                                      });
                     // Inits graph name in plot overlay
                     m_TitleText->setLayer(OVERLAY_LAYER);
                     m_TitleText->setText(graphWidget.name());
                     initTitleTextStyle(*m_TitleText);
                     // Inits "show x-axis button" in plot overlay
                     m_XAxisPixmap->setLayer(OVERLAY_LAYER);
                     initXAxisPixmapStyle(*m_XAxisPixmap);
                     // Connects pixmap selection to graph x-axis showing/hiding
                     QObject::connect(m_XAxisPixmap, &QCPItemPixmap::selectionChanged, [this]() {
                         if (m_XAxisPixmap->selected()) {
                             // Changes the selection state and refreshes the x-axis
                             m_ShowXAxis = !m_ShowXAxis;
                             updateXAxisState();
                             m_Plot.layer(AXES_LAYER)->replot();
                             // Deselects the x-axis pixmap and updates icon
                             m_XAxisPixmap->setSelected(false);
                             m_XAxisPixmap->setPixmap(
                                 pixmap(m_ShowXAxis ? HIDE_AXIS_ICON_PATH : SHOW_AXIS_ICON_PATH));
                             m_Plot.layer(OVERLAY_LAYER)->replot();
                         }
                     });
                 }
                 /// Updates state of x-axis according to the current selection of x-axis pixmap
                 /// @remarks the method doesn't call plot refresh
                 void updateXAxisState() noexcept
                 {
                     m_Plot.xAxis->setTickLabels(m_ShowXAxis);
                     m_Plot.xAxis->setLabel(m_ShowXAxis ? m_XAxisLabel : QString{});
                 }
                 QCustomPlot &m_Plot;
                 QCPItemTracer *m_PointTracer;
                 QTimer m_TracerTimer;
                 QCPItemPixmap *m_ClosePixmap; /// Graph's close button
                 QCPItemText *m_TitleText;     /// Graph's title
                 QCPItemPixmap *m_XAxisPixmap;
                 bool m_ShowXAxis; /// X-axis properties are shown or hidden
                 QString m_XAxisLabel;
                 SqpColorScale m_ColorScale; /// Color scale used for some types of graphs (as spectrograms)
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
                 VisualizationGraphWidget &graphWidget)
                     : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(graphWidget)}
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 // Opens color scale editor if color scale is double clicked
                 auto colorScale = dynamic_cast<QCPColorScale *>(impl->m_Plot.layoutElementAt(event->pos()));
                 if (impl->m_ColorScale.m_Scale == colorScale) {
                     if (ColorScaleEditor{impl->m_ColorScale}.exec() == QDialog::Accepted) {
                         impl->m_Plot.replot();
                     }
                 }
             }
             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 // Reinits tracers
                 impl->m_PointTracer->setGraph(nullptr);
                 impl->m_PointTracer->setVisible(false);
                 impl->m_Plot.replot();
                 QString tooltip{};
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
                 if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
                     auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                     auto graphData = graph->data();
                     // Gets the closest data point to the mouse
                     auto graphDataIt = graphData->findBegin(mouseKey);
                     if (graphDataIt != graphData->constEnd()) {
                         // Sets tooltip
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         tooltip = GRAPH_TOOLTIP_FORMAT.arg(key, value);
                         // Displays point tracer
                         impl->m_PointTracer->setGraph(graph);
                         impl->m_PointTracer->setGraphKey(graphDataIt->key);
                         impl->m_PointTracer->setLayer(
                             impl->m_Plot.layer("main")); // Tracer is set on top of the plot's main layer
                         impl->m_PointTracer->setVisible(true);
                         impl->m_Plot.replot();
                     }
                 }
                 else if (auto colorMap = qobject_cast<QCPColorMap *>(impl->m_Plot.plottableAt(eventPos))) {
                     // Gets x and y coords
                     auto x = colorMap->keyAxis()->pixelToCoord(eventPos.x());
                     auto y = colorMap->valueAxis()->pixelToCoord(eventPos.y());
                     // Calculates x and y cell indexes, and retrieves the underlying value
                     auto xCellIndex = colorMapCellIndex(*colorMap, x, true);
                     auto yCellIndex = colorMapCellIndex(*colorMap, y, false);
                     auto value = colorMap->data()->cell(xCellIndex, yCellIndex);
+                    // Sets tooltips
+                    tooltip = COLORMAP_TOOLTIP_FORMAT.arg(formatValue(x, *colorMap->keyAxis()),
+                                                          formatValue(y, *colorMap->valueAxis()),
+                                                          formatValue(value, *colorMap->colorScale()->axis()));
                 }
                 if (!tooltip.isEmpty()) {
                     // Starts timer to show tooltip after timeout
                     auto showTooltip = [tooltip, eventPos, this]() {
                         QToolTip::showText(impl->m_Plot.mapToGlobal(eventPos) + TOOLTIP_OFFSET, tooltip,
                                            &impl->m_Plot, TOOLTIP_RECT);
                     };
                     QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTooltip);
                     impl->m_TracerTimer.start();
                 }
             }
             void VisualizationGraphRenderingDelegate::onPlotUpdated() noexcept
             {
                 // Updates color scale bounds
                 impl->m_ColorScale.updateDataRange();
                 impl->m_Plot.replot();
             }
             void VisualizationGraphRenderingDelegate::setAxesProperties(
                 std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
                 impl->m_XAxisLabel = dataSeries->xAxisUnit().m_Name;
                 auto axisHelper = IAxisHelperFactory::create(dataSeries);
                 axisHelper->setProperties(impl->m_Plot, impl->m_ColorScale);
                 // Updates x-axis state
                 impl->updateXAxisState();
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
             void VisualizationGraphRenderingDelegate::setPlottablesProperties(
                 std::shared_ptr<IDataSeries> dataSeries, PlottablesMap &plottables) noexcept
             {
                 auto plottablesHelper = IPlottablesHelperFactory::create(dataSeries);
                 plottablesHelper->setProperties(plottables);
             }
             void VisualizationGraphRenderingDelegate::showGraphOverlay(bool show) noexcept
             {
                 auto overlay = impl->m_Plot.layer(OVERLAY_LAYER);
                 overlay->setVisible(show);
                 overlay->replot();
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages