HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1432:db5304cf6c8c

MultiComponent TS almost complete...

jeandet -

r1432:db5304cf6c8c

parent child

Context file:

r1432:db5304cf6c8c

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 41273d8529cddde1c8b6bcea03d71d9cd1a18c06		1	Subproject commit 9a080a34054c21a67236f761e8843005c07ff0ba

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

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <Variable/Variable2.h>
             #include <Visualization/SqpColorScale.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace
             {
             /// 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 std::string& unit, bool isTime,
                 QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(QString::fromStdString(unit));
                 // 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(isTime, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter
             {
                 static void setProperties(QCustomPlot&, SqpColorScale&)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
                 static void setUnits(T&, QCustomPlot&, SqpColorScale&)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis units: 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<ScalarTimeSerie, T>::value
-                    or std::is_base_of<VectorTimeSerie, T>::value>>
+                    or std::is_base_of<VectorTimeSerie, T>::value
+                    or std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static void setProperties(QCustomPlot&, SqpColorScale&)
                 {
                     // Nothing to do
                 }
                 static void setUnits(T& dataSeries, QCustomPlot& plot, SqpColorScale&)
                 {
                     auto serie = dynamic_cast<TimeSeries::ITimeSerie*>(&dataSeries);
                     setAxisProperties(*plot.xAxis, "s", true);
                     setAxisProperties(*plot.yAxis, serie->unit(1), false);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setProperties(QCustomPlot& plot, SqpColorScale& colorScale)
                 {
                     // 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
                     colorScale.m_AutomaticThreshold = true;
                 }
                 static void setUnits(T& dataSeries, QCustomPlot& plot, SqpColorScale& colorScale)
                 {
                     auto serie = dynamic_cast<TimeSeries::ITimeSerie*>(&dataSeries);
                     setAxisProperties(*plot.xAxis, "s", true);
                     setAxisProperties(*plot.yAxis, serie->unit(1), false, QCPAxis::stLogarithmic);
                     setAxisProperties(
                         *colorScale.m_Scale->axis(), serie->unit(2), false, 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(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}
                 void setProperties(QCustomPlot& plot, SqpColorScale& colorScale) override
                 {
                     AxisSetter<T>::setProperties(plot, colorScale);
                 }
                 void setUnits(QCustomPlot& plot, SqpColorScale& colorScale) override
                 {
                     if (m_DataSeries)
                     {
                         AxisSetter<T>::setUnits(*m_DataSeries, plot, colorScale);
                     }
                     else
                     {
                         qCCritical(LOG_AxisRenderingUtils()) << "Can't set units: inconsistency between the "
                                                                 "type of data series and the type supposed";
                     }
                 }
                 std::shared_ptr<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, NUMBER_FORMAT, NUMBER_PRECISION);
                 }
             }
             std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(Variable2& variable) noexcept
             {
                 switch (variable.type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<AxisHelper<ScalarTimeSerie>>(
                             std::dynamic_pointer_cast<ScalarTimeSerie>(variable.data()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<AxisHelper<SpectrogramTimeSerie>>(
                             std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable.data()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<AxisHelper<VectorTimeSerie>>(
                             std::dynamic_pointer_cast<VectorTimeSerie>(variable.data()));
+                    case DataSeriesType::MULTICOMPONENT:
+                        return std::make_unique<AxisHelper<MultiComponentTimeSerie>>(
+                            std::dynamic_pointer_cast<MultiComponentTimeSerie>(variable.data()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<AxisHelper<TimeSeries::ITimeSerie>>(nullptr);
             }

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

             #include "Visualization/PlottablesRenderingUtils.h"
             #include <Common/ColorUtils.h>
             #include <Variable/Variable2.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
             namespace
             {
             /**
              * Delegate used to set plottables properties
              */
             template <typename T, typename Enabled = void>
             struct PlottablesSetter
             {
                 static void setProperties(PlottablesMap&)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_PlottablesRenderingUtils())
                         << "Can't set plottables properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of PlottablesSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                 typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value
-                    or std::is_base_of<VectorTimeSerie, T>::value>>
+                    or std::is_base_of<VectorTimeSerie, T>::value
+                    or std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static void setProperties(PlottablesMap& plottables)
                 {
                     // Finds the plottable with the highest index to determine the number of colors to generate
                     auto end = plottables.cend();
                     auto maxPlottableIndexIt = std::max_element(plottables.cbegin(), end,
                         [](const auto& it1, const auto& it2) { return it1.first < it2.first; });
                     auto componentCount = maxPlottableIndexIt != end ? maxPlottableIndexIt->first + 1 : 0;
                     // Generates colors for each component
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i)
                     {
                         auto graphIt = plottables.find(i);
                         if (graphIt != end)
                         {
                             graphIt->second->setPen(QPen { colors.at(i) });
                         }
                     }
                 }
             };
             /**
              * Specialization of PlottablesSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setProperties(PlottablesMap& plottables)
                 {
                     // Checks that for a spectrogram there is only one plottable, that is a colormap
                     if (plottables.size() != 1)
                     {
                         return;
                     }
                     if (auto colormap = dynamic_cast<QCPColorMap*>(plottables.begin()->second))
                     {
                         colormap->setInterpolate(false); // No value interpolation
                         colormap->setTightBoundary(true);
                         // Finds color scale in the colormap's plot to associate with it
                         auto plot = colormap->parentPlot();
                         auto plotElements = plot->plotLayout()->elements(false);
                         for (auto plotElement : plotElements)
                         {
                             if (auto colorScale = dynamic_cast<QCPColorScale*>(plotElement))
                             {
                                 colormap->setColorScale(colorScale);
                             }
                         }
                         colormap->rescaleDataRange();
                     }
                     else
                     {
                         qCCritical(LOG_PlottablesRenderingUtils()) << "Can't get colormap of the spectrogram";
                     }
                 }
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to set plottables properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 void setProperties(PlottablesMap& plottables) override
                 {
                     PlottablesSetter<T>::setProperties(plottables);
                 }
             };
             } // namespace
             std::unique_ptr<IPlottablesHelper> IPlottablesHelperFactory::create(Variable2& variable) noexcept
             {
                 switch (variable.type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>();
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>();
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>();
+                    case DataSeriesType::MULTICOMPONENT:
+                        return std::make_unique<PlottablesHelper<MultiComponentTimeSerie>>();
                     default:
                         // Returns default helper
                         break;
                 }
                 return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>();
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +15 -7

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <Variable/Variable2.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace
             {
             class SqpDataContainer : public QCPGraphDataContainer
             {
             public:
                 void appendGraphData(const QCPGraphData& data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator
             {
                 static PlottablesMap createPlottables(QCustomPlot&, const std::shared_ptr<T>& dataSeries)
                 {
                     return {};
                 }
             };
             PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
             {
                 PlottablesMap result {};
                 // Creates {nbGraphs} QCPGraph to add to the plot
                 for (auto i = 0; i < nbGraphs; ++i)
                 {
                     auto graph = plot.addGraph();
                     result.insert({ i, graph });
                 }
                 plot.replot();
                 return result;
             }
             /**
              * Specialization of PlottablesCreator for scalars
              * @sa ScalarSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, 1);
                 }
             };
             /**
              * Specialization of PlottablesCreator for vectors
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, 3);
                 }
             };
             /**
              * Specialization of PlottablesCreator for MultiComponentTimeSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, dataSeries->size(1));
                 }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     PlottablesMap result {};
                     result.insert({ 0, new QCPColorMap { plot.xAxis, plot.yAxis } });
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater
             {
                 static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T&, PlottablesMap&, const DateTimeRange&, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                     {
                         if (serie->size())
                         {
                             maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
                             minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
                         }
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                             {
                                 std::for_each(
                                     std::begin(*serie), std::end(*serie), [&dataContainer](const auto& value) {
                                         dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
                                     });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                     {
                         std::for_each(
                             std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
                                 minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
                                 maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
                             });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                             {
                                 switch (plottable.first)
                                 {
                                     case 0:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().x));
                                             });
                                         break;
                                     case 1:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().y));
                                             });
                                         break;
                                     case 2:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().z));
                                             });
                                         break;
                                     default:
                                         break;
                                 }
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
-            struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
+            struct PlottablesUpdater<T,
+                typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
                     {
                         // TODO
-            //            std::for_each(
+                        //            std::for_each(
-            //                std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
+                        //                std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const
-            //                    minValue = std::min({ minValue, std::min_element(v.begin(),v.end()) });
+                        //                auto& v) {
-            //                    maxValue = std::max({ maxValue, std::max_element(v.begin(),v.end()) });
+                        //                    minValue = std::min({ minValue,
-            //                });
+                        //                    std::min_element(v.begin(),v.end()) }); maxValue = std::max({
+                        //                    maxValue, std::max_element(v.begin(),v.end()) });
+                        //                });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
                             {
-            // TODO
+                                // TODO
+                                std::for_each(std::begin(*serie), std::end(*serie),
+                                    [&dataContainer, component = plottable.first](const auto& value) {
+                                        dataContainer->appendGraphData(
+                                            QCPGraphData(value.t(), value[component]));
+                                    });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     // TODO
                     //        double min, max;
                     //        std::tie(min, max) = dataSeries.yBounds();
                     //        if (!std::isnan(min) && !std::isnan(max))
                     //        {
                     //            plot.yAxis->setRange(QCPRange { min, max });
                     //        }
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // TODO
                     //        if (plottables.empty())
                     //        {
                     //            qCDebug(LOG_VisualizationGraphHelper())
                     //                << QObject::tr("Can't update spectrogram: no colormap has been
                     //                associated");
                     //            return;
                     //        }
                     //        // Gets the colormap to update (normally there is only one colormap)
                     //        Q_ASSERT(plottables.size() == 1);
                     //        auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
                     //        Q_ASSERT(colormap != nullptr);
                     //        dataSeries.lockRead();
                     //        // Processing spectrogram data for display in QCustomPlot
                     //        auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     //        // Computes logarithmic y-axis resolution for the spectrogram
                     //        auto yData = its.first->y();
                     //        auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
                     //        // Generates mesh for colormap
                     //        auto mesh = DataSeriesUtils::regularMesh(its.first, its.second,
                     //            DataSeriesUtils::Resolution { dataSeries.xResolution() }, yResolution);
                     //        dataSeries.unlock();
                     //        colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
                     //        if (!mesh.isEmpty())
                     //        {
                     //            colormap->data()->setRange(QCPRange { mesh.m_XMin, mesh.xMax() },
                     //                // y-axis range is converted to linear values
                     //                QCPRange { std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax()) });
                     //            // Sets values
                     //            auto index = 0;
                     //            for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it,
                     //            ++index)
                     //            {
                     //                auto xIndex = index % mesh.m_NbX;
                     //                auto yIndex = index / mesh.m_NbX;
                     //                colormap->data()->setCell(xIndex, yIndex, *it);
                     //                // Makes the NaN values to be transparent in the colormap
                     //                if (std::isnan(*it))
                     //                {
                     //                    colormap->data()->setAlpha(xIndex, yIndex, 0);
                     //                }
                     //            }
                     //        }
                     //        // Rescales axes
                     //        auto plot = colormap->parentPlot();
                     //        if (rescaleAxes)
                     //        {
                     //            plot->rescaleAxes();
                     //        }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper
             {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot& plot) const = 0;
                 virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
                 virtual void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}
                 PlottablesMap create(QCustomPlot& plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(plot, m_DataSeries);
                 }
                 void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 std::shared_ptr<T> m_DataSeries;
             };
             /// Creates IPlottablesHelper according to the type of data series a variable holds
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
             {
                 switch (variable->type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
                             std::dynamic_pointer_cast<ScalarTimeSerie>(variable->data()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
                             std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable->data()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
                             std::dynamic_pointer_cast<VectorTimeSerie>(variable->data()));
                     case DataSeriesType::MULTICOMPONENT:
                         return std::make_unique<PlottablesHelper<MultiComponentTimeSerie>>(
                             std::dynamic_pointer_cast<MultiComponentTimeSerie>(variable->data()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap {};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(
                 PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
             {
                 auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

plugins/python_providers/resources/amda.py +11 -5

             import sys
             sys.path.append("/home/jeandet/Documents/prog/build-SciQLop-Desktop-Debug/core")
             import traceback
             import os
             from datetime import datetime, timedelta, timezone
             import PythonProviders
             import pysciqlopcore
             import numpy as np
             import pandas as pds
             import requests
+            import copy
             from spwc.amda import AMDA
             amda = AMDA()
             def get_sample(metadata,start,stop):
                 ts_type = pysciqlopcore.ScalarTimeSerie
                 try:
                     param_id = None
                     for key,value in metadata:
                         if key == 'xml:id':
                             param_id = value
                         elif key == 'type':
                             if value == 'vector':
                                 ts_type = pysciqlopcore.VectorTimeSerie
-                    tstart=datetime.datetime.utcfromtimestamp(start)
+                            elif value == 'multicomponent':
-                    tend=datetime.datetime.utcfromtimestamp(stop)
+                                ts_type = pysciqlopcore.MultiComponentTimeSerie
+                    tstart=datetime.datetime.fromtimestamp(start, tz=timezone.utc)
+                    tend=datetime.datetime.fromtimestamp(stop, tz=timezone.utc)
                     df = amda.get_parameter(start_time=tstart, stop_time=tend, parameter_id=param_id)
                     #t = np.array([d.timestamp()-7200 for d in df.index])
                     t = np.array([d.timestamp() for d in df.index])
                     values = df.values
-                    return ts_type(t,values)
+                    return ts_type(t,values.transpose())
                     return ts_type(1)
                 except Exception as e:
                     print(traceback.format_exc())
                     print("Error in amda.py ",str(e))
                     return ts_type(1)
             if len(amda.component) is 0:
                 amda.update_inventory()
-            parameters = amda.parameter.copy()
+            parameters = copy.deepcopy(amda.parameter)
             for name,component in amda.component.items():
                 if 'components' in parameters[component['parameter']]:
                     parameters[component['parameter']]['components'].append(component)
                 else:
                     parameters[component['parameter']]['components']=[component]
             products = []
             for key,parameter in parameters.items():
                 path = f"/AMDA/{parameter['mission']}/{parameter['instrument']}/{parameter['dataset']}/{parameter['name']}"
                 components = [component['name'] for component in parameter.get('components',[])]
                 metadata = [ (key,item) for key,item in parameter.items() if key is not 'components' ]
-                if parameter.get('size',0) is '3':
+                n_components = parameter.get('size',0)
+                if n_components is '3':
                     metadata.append(("type","vector"))
+                elif n_components !=0:
+                    metadata.append(("type","multicomponent"))
                 else:
                     metadata.append(("type","scalar"))
                 products.append( (path, components, metadata))
             PythonProviders.register_product(products, get_sample)

plugins/python_providers/resources/test.py +30 -3

@@ -1,17 +1,44
1	import sys	1	import sys
2	sys.path.append("/home/jeandet/Documents/prog/build-SciQLop-Desktop-Debug/core")	2	sys.path.append("/home/jeandet/Documents/prog/build-SciQLop-Desktop-Debug/core")
3	import PythonProviders	3	import PythonProviders
4	import pysciqlopcore	4	import pysciqlopcore
5	import numpy as np	5	import numpy as np
6		6
7	someglobal = 1	7	someglobal = 1
8		8
9	def test(name,start,stop):	9	def make_scalar(x):
10	x = np.arange(start, stop)
11	y = np.cos(x/10.)	10	y = np.cos(x/10.)
12	return pysciqlopcore.ScalarTimeSerie(x,y)	11	return pysciqlopcore.ScalarTimeSerie(x,y)
13		12
		13	def make_vector(x):
		14	v=np.ones((3,len(x)))
		15	for i in range(3):
		16	v[:][i] = np.cos(x/10. + float(i))
		17	return pysciqlopcore.VectorTimeSerie(x,v)
		18
		19
		20	def make_multicomponent(x):
		21	v=np.ones((4,len(x)))
		22	for i in range(4):
		23	v[:][i] = float(i+1) * np.cos(x/10. + float(i))
		24	return pysciqlopcore.MultiComponentTimeSerie(x,v)
		25
		26
		27	def get_data(metadata,start,stop):
		28	x = np.arange(start, stop)
		29	for key,value in metadata:
		30	if key == 'xml:id':
		31	param_id = value
		32	elif key == 'type':
		33	if value == 'vector':
		34	return make_vector(x)
		35	elif value == 'multicomponent':
		36	return make_multicomponent(x)
		37	return make_scalar(x)
		38
		39
		40
14		41
15	#PythonProviders.register_product(["/folder1/folder2/product1", "/folder1/folder3/product2", "/folder4/folder5/product3"],test)	42	PythonProviders.register_product([("/tests/scalar",[],[("type","scalar")]), ("/tests/vector",[],[("type","vector")]), ("/tests/multicomponent",[],[("type","multicomponent"),('size','4')])],get_data)
16		43
17		44

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