Change nbEchantillons to ParamsNbPoints

Menouard AZIB
1 parent edef04ea
Showing 5 changed files with 757 additions and 2 deletions Show diff stats
config/xsd/request/plotFunction.xsd
src/ParamOutputImpl/Plot/InstantPlot/PlotFunction.cc
src/ParamOutputImpl/Plot/InstantPlot/PlotFunction.hh
src/ParamOutputImpl/Plot/InstantPlot/PlotFunctionNode.cc
src/ParamOutputImpl/Plot/InstantPlot/PlotFunctionNode.hh
@@ -37,8 +37,7 @@
 	    <xs:attribute name="scale_abscisse" type="xs:string"></xs:attribute>
 		<xs:attribute name="scale_ordonnee" type="xs:string"></xs:attribute>
 		<xs:attribute name="type" type="xs:string"></xs:attribute>
-        <xs:complexType name="param_nb_points">
-        </xs:complexType>
+		<xs:attribute name="param_nb_points" type="xs:string"></xs:attribute>
       </xs:complexType>
     </xs:element>      
 </xs:schema>
@@ -0,0 +1,379 @@
+#include <boost/lexical_cast.hpp>
+#include <fstream>
+#include <iomanip>
+
+#include "AxesNode.hh"
+#include "AxisLegendManager.hh"
+#include "ParamMgr.hh"
+#include "ParamsNode.hh"
+#include "PlPlotUtil.hh"
+#include "PlotFunction.hh"
+#include "PlotLogger.hh"
+#include "PlotOutput.hh"
+#include "TimeUtil.hh"
+#include "fonctions/fourier/DiscreteFourierTransform.cc"
+#include "fonctions/fourier/DiscreteFourierTransform.hh"
+#include <algorithm>
+#include <limits>
+#include <numeric>
+
+#include "DefaultTimeAxisDecorator.hh"
+
+#include "TimeAxisDecorator.hh"
+
+using namespace AMDA::Parameters;
+using namespace AMDA::Info;
+
+namespace plot
+{
+    QSASConfig *PlotFunction::qsasconfig = NULL;
+
+    PlotFunction::PlotFunction(AMDA::Parameters::ParameterManager &manager,
+                               boost::shared_ptr<Panel> panel, TimeAxisDecorator *timeAxisDecorator) : PanelPlotOutput(manager, panel), function(PlotFunction::Function::NONE), abscisse("Time. ", "(s)", Abscisse::Abscisse_Type::TIME)
+
+    {
+        LOG4CXX_DEBUG(gLogger, "Function to apply " << function);
+        setTimeAxisDecorator(std::shared_ptr<TimeAxisDecorator>(timeAxisDecorator));
+    }
+
+    PlotFunction::~PlotFunction()
+    {
+        if (qsasconfig != NULL)
+        {
+            free(qsasconfig);
+            qsasconfig = nullptr;
+        }
+    }
+
+    void PlotFunction::drawSeries(double startDate, double stopDate, int intervalIndex, std::string pParamId,
+                                  SeriesProperties &pSerie,
+                                  AMDA::Common::ParameterIndexComponent pParamIndex,
+                                  ParameterAxes &param, bool moreThanOneSerieForAxis)
+    {
+        std::string id = std::to_string(pSerie.getId()) + "_" + pSerie.getParamId() + "_" + std::to_string(pParamIndex.getDim1Index());
+        std::vector<double> xValues = xValuesMap[id];
+        std::vector<double> yValues = yValuesMap[id];
+
+        double *coloredComputedValues = NULL;
+        int nbValues = yValues.size();
+
+        double *yValuesTemp = &yValues[0];
+        double *xValuesTemp = &xValues[0];
+
+        pSerie.setXAxisId(X_AXIS_ID);
+        pSerie.setYAxisId(Y_AXIS_ID);
+
+        PanelPlotOutput::drawSeries(startDate, stopDate, intervalIndex, pParamId,
+                                    pSerie, pParamIndex, param, moreThanOneSerieForAxis);
+        // draw serie
+        Color lineColor = getSerieLineColor(pSerie, moreThanOneSerieForAxis);
+        Color symbolColor = getSerieSymbolColor(pSerie, lineColor);
+
+        drawSymbols(
+            pSerie.getSymbolProperties().getType(),
+            pSerie.getSymbolProperties().getSize(), 1.,
+            symbolColor,
+            nbValues, xValuesTemp, yValuesTemp, coloredComputedValues);
+
+        drawLines(
+            pSerie.getLineProperties().getType(),
+            pSerie.getLineProperties().getStyle(),
+            pSerie.getLineProperties().getWidth() + 1,
+            lineColor,
+            nbValues, xValuesTemp, yValuesTemp, coloredComputedValues);
+    }
+
+    void PlotFunction::configureSeriesAxis()
+    {
+        //_panel->_leftMargin = 10;
+        //_panel->_rightMargin = 5;
+        //_panel->_bottomMargin = 4;
+
+        SeriesProperties lSeries;
+        for (auto parameter : _parameterAxesList)
+        {
+            for (auto lSeries : parameter.getYSeriePropertiesList())
+            {
+                for (auto lIndex : lSeries.getIndexList(_pParameterValues))
+                {
+                    std::string id = std::to_string(lSeries.getId()) + "_" + lSeries.getParamId() + "_" + std::to_string(lIndex.getDim1Index());
+                    plot::ParameterData data = (*_pParameterValues)[lSeries.getParamId()];
+                    PlotFunction::compute(lIndex, data, id);
+                }
+            }
+        }
+
+        PlotFunction::createXAxis();
+        PlotFunction::createYAxis();
+    }
+
+    void PlotFunction::createXAxis()
+    {
+        double minValue = 0;
+        double maxValue = 0;
+        PlotFunction::getMinMax(xValuesMap, &minValue, &maxValue);
+        // Create X axis
+        boost::shared_ptr<TimeAxis> lXAxis(new TimeAxis());
+        lXAxis.get()->_timeFormat = "%H:%M";
+        plot::Range range_x = Range(minValue, maxValue);
+        lXAxis.get()->setRange(range_x);
+        lXAxis.get()->_drawn = false;
+        lXAxis.get()->_position = PlotCommon::Position::POS_BOTTOM;
+        Label label1 = Label();
+        // lXAxis.get()->setLegendOffset(0.03);
+        label1._text = abscisse.getLabel() + abscisse.getUnit();
+        lXAxis.get()->_legend.pushLabel(label1);
+        lXAxis.get()->_scale = abscisseScale;
+        lXAxis.get()->_showLegend = true;
+        lXAxis.get()->_showTickMark = true;
+        lXAxis.get()->_used = true;
+
+        //  add X Axis to panel
+        _panel->addAxis(X_AXIS_ID, lXAxis);
+    }
+
+    void PlotFunction::createYAxis()
+    {
+        std::string y_label = "";
+        if (function == PlotFunction::Function::SUM)
+            y_label = "Sum";
+        else
+            y_label = "Amplitude";
+
+        double minValue = 0;
+        double maxValue = 0;
+
+        PlotFunction::getMinMax(yValuesMap, &minValue, &maxValue);
+        LOG4CXX_DEBUG(gLogger, "Min value " << minValue << " "
+                                            << "Max Value" << maxValue);
+        // Create X axis
+        boost::shared_ptr<Axis> lYAxis(new Axis(false));
+        plot::Range range_x = Range(minValue - minValue * 0.1, maxValue + maxValue * 0.1);
+        lYAxis.get()->setRange(range_x);
+        lYAxis.get()->_drawn = false;
+        lYAxis.get()->_position = PlotCommon::Position::POS_LEFT;
+        Label label1 = Label();
+        // lYAxis.get()->setLegendOffset(0.05);
+        label1._text = y_label;
+        lYAxis.get()->_legend.pushLabel(label1);
+        lYAxis.get()->_scale = ordonneeScale;
+        lYAxis.get()->_showLegend = true;
+        lYAxis.get()->_showTickMark = true;
+        lYAxis.get()->_used = true;
+        //  add X Axis to panel
+        _panel->addAxis(Y_AXIS_ID, lYAxis);
+    }
+
+    void PlotFunction::getMinMax(std::map<std::string, std::vector<double>> dataMap, double *minToFill, double *maxToFill)
+    {
+        double maxValue = INT_MIN;
+        double minValue = INT_MAX;
+        std::map<std::string, std::vector<double>>::iterator it;
+        for (it = dataMap.begin(); it != dataMap.end(); it++)
+        {
+            std::vector<double> data = it->second;
+            double max_x = *max_element(data.begin(), data.end());
+            double min_x = *min_element(data.begin(), data.end());
+            if (max_x > maxValue)
+                maxValue = max_x;
+            if (min_x < minValue)
+                minValue = min_x;
+        }
+        *minToFill = minValue;
+        *maxToFill = maxValue;
+    }
+
+    void PlotFunction::compute(AMDA::Common::ParameterIndexComponent pParamIndex, plot::ParameterData data, std::string id)
+    {
+        double samplingValue = 60.0;
+        double *values = data.getValues(pParamIndex, 0);
+        int startIndex;
+        int nbValues = 0;
+
+        // data.getIntervalBounds(startTime, stopTime, &startIndex, &nbValues);
+
+        double *timeValues = &data.getTimes()[0];
+        LOG4CXX_DEBUG(gLogger, " First Time : " << timeValues[0]);
+
+        std::vector<double> signal;
+        for (int i = 0; i < data.getSize(); i++)
+            signal.push_back(values[i]);
+
+        std::vector<double> xValues;
+        std::vector<double> yValues;
+
+        if (function == PlotFunction::Function::SUM)
+        {
+            double sum = std::accumulate(signal.begin(), signal.end(), 0);
+            for (int i = 0; i < data.getSize(); i++)
+            {
+                yValues.push_back(sum);
+                xValues.push_back(timeValues[i]);
+            }
+        }
+        else
+        {
+            DiscreteFourierTransform<double, double> DFT(std::min(nbEchantillons, data.getSize()), signal, 1 / samplingValue);
+            DFT.compute();
+
+            yValues = DFT.getAmplitudes();
+
+            if (abscisse.getType() == Abscisse::Abscisse_Type::FREQUENCY)
+                xValues = DFT.getFrequences();
+            else
+                xValues = DFT.getPeriodes();
+        }
+
+        if (ordonneeScale == Axis::Scale::LOGARITHMIC)
+        {
+            std::for_each(yValues.begin(), yValues.end(), [&](double &i)
+                          { return log10(i); });
+        }
+
+        if (abscisseScale == Axis::Scale::LOGARITHMIC)
+        {
+            std::for_each(xValues.begin(), xValues.end(), [&](double &i)
+                          { return log10(i); });
+        }
+
+        PlotFunction::xValuesMap[id] = xValues;
+        PlotFunction::yValuesMap[id] = yValues;
+    }
+
+    void PlotFunction::configureAxisLegend()
+    {
+        // Y axis
+        AxisLegendManager::configureYAxisLegendForSpectro(this);
+        AxisLegendManager::configureYAxisLegendForSeries(this);
+
+        // Z axis
+        AxisLegendManager::configureColorAxisLegendForSpectro(this);
+        AxisLegendManager::configureColorAxisLegendForSeries(this);
+    }
+
+    void PlotFunction::drawStartDate(std::string _timeFormat, double startTime, double stopTime)
+    {
+        Font font(_panel->getFont());
+        Bounds lPanelBounds(_panel->getBoundsInPlPage());
+
+        PLFLT lXMin, lXMax, lYMin, lYMax;
+        _pls->gvpd(lXMin, lXMax, lYMin, lYMax);
+
+        float lPosition = 0.0;
+        // display it one line above the main panel bottom border :
+        float disp = -1;
+
+        long int lTime = static_cast<long int>(startTime);
+        tm *lTimeTm = gmtime(&lTime);
+        char lTimeChr[80];
+
+        // Format date.
+        strftime(lTimeChr, 80,
+                 getPlStartTimeFormat(_timeFormat,
+                                      startTime,
+                                      stopTime)
+                     .c_str(),
+                 lTimeTm);
+
+        PLFLT mxmin, mxmax, mymin, mymax;
+        plgspa(&mxmin, &mxmax, &mymin, &mymax);
+        float x_subpage_per_mm = 1. / (mxmax - mxmin);
+
+        LOG4CXX_DEBUG(gLogger, "Start date to draw : " << lTimeChr);
+
+        // Set font
+        PlPlotUtil::setPlFont(font);
+
+        PLFLT dateWidthInMm;
+        dateWidthInMm = plstrl(lTimeChr);
+
+        // set viewport for start date :
+        _pls->vpor(lXMin, lXMax, lPanelBounds._y, lPanelBounds._y + lPanelBounds._height);
+
+        lPosition = 0.;
+        if (dateWidthInMm * x_subpage_per_mm > lXMin - lPanelBounds._x)
+            lPosition = (dateWidthInMm * x_subpage_per_mm - lXMin + lPanelBounds._x) / (lXMax - lXMin);
+        _pls->mtex("b", disp, lPosition, 1., lTimeChr);
+
+        // restore viewport :
+        _pls->vpor(lXMin, lXMax, lYMin, lYMax);
+    }
+
+    void PlotFunction::preparePlotArea(double startTime, double stopTime, int intervalIndex)
+    {
+        PlotFunction::configureSeriesAxis();
+
+        if (abscisse.getType() == Abscisse::TIME)
+        {
+            boost::shared_ptr<Axis> xAxis = _panel->getAxis(X_AXIS_ID);
+            getTimeAxisDecorator()->configure(this, dynamic_cast<TimeAxis *>(xAxis.get()), startTime, stopTime, _pParameterValues);
+            _pls->timefmt(getTimeAxisDecorator()->getPlFormat().c_str());
+        }
+            PanelPlotOutput::preparePlotArea(startTime, stopTime, intervalIndex);
+        }
+
+        void PlotFunction::createParameters(std::list<std::string> & usedParametersId_)
+        {
+            // -- for each y serie on each parameter, calculate
+            // y serie sampling according to max resolution
+            for (ParameterAxesList::iterator it = _parameterAxesList.begin();
+                 it != _parameterAxesList.end(); ++it)
+            {
+                AMDA::Parameters::ParameterSPtr originalParam =
+                    _parameterManager.getParameter(it->_originalParamId);
+
+                LOG4CXX_DEBUG(gLogger, "before resampling : " << it->_originalParamId);
+
+                // original parameter sampling
+                double samplingValue = getSamplingInTreeParameter(originalParam);
+
+                // For each series
+                std::vector<SeriesProperties>::iterator ity;
+                for (ity = it->getYSeriePropertiesList().begin(); ity != it->getYSeriePropertiesList().end();
+                     ++ity)
+                {
+                    // get corrected sampling value in relation with max resolution
+                    double correctedSamplingValue = getCorrectedSamplingValue(ity->getMaxResolution(), samplingValue);
+
+                    AMDA::Parameters::ParameterSPtr usedParam;
+                    // create resampling parameters for param
+                    if (abs(samplingValue - correctedSamplingValue) > 1.)
+                    {
+                        // more than one second between samplingValue and correctedSamplingValue
+                        //=> use resampling parameter
+                        usedParam = createSampledParameter(originalParam, correctedSamplingValue);
+                    }
+                    else
+                    {
+                        // use original parameter
+                        usedParam = originalParam;
+                    }
+
+                    // Add used parameter to parameters list
+                    if (std::find(usedParametersId_.begin(), usedParametersId_.end(),
+                                  usedParam->getId()) == usedParametersId_.end())
+                        usedParametersId_.push_back(usedParam->getId());
+
+                    // link this paramter to the serie
+                    ity->setParamId(usedParam->getId());
+                }
+            }
+        }
+
+        /**
+         * @brief draw the plot for the current time interval
+         */
+        bool PlotFunction::draw(double startTime, double stopTime, int intervalIndex,
+                                bool isFirstInterval, bool isLastInterval)
+        {
+            bool out = PanelPlotOutput::draw(startTime, stopTime, intervalIndex, isFirstInterval, isLastInterval);
+
+            if (abscisse.getType() == Abscisse::TIME)
+            {
+                std::string _timeFormat = "hh:mm:ss";
+                PlotFunction::drawStartDate(_timeFormat, startTime, stopTime);
+            }
+
+        return out;
+    }
+}
@@ -0,0 +1,172 @@
+
+#ifndef PLOTFUNCTION_HH_
+#define PLOTFUNCTION_HH_
+
+// includes boost
+#include <boost/shared_ptr.hpp>
+
+#include "NodeCfg.hh"
+#include "PanelPlotOutput.hh"
+#include "PlPlotUtil.hh"
+#include "PlotFunctionNode.hh"
+#include "plotFunctionElements/Abscisse.hh"
+#include <climits>
+
+#include "DefaultTimeAxisDecorator.hh"
+
+#include "TimeAxisDecorator.hh"
+
+#include "plplot/plplot.h"
+#include "plplot/plplotP.h"
+#include "plplot/plstream.h"
+#include <map>
+
+#include "plplot/plstream.h"
+
+extern "C"
+{
+#include <plplot/qsastime.h>
+}
+
+#define X_AXIS_ID "x_axis_id"
+#define Y_AXIS_ID ""
+
+namespace plot
+{
+
+    class PlotFunction : public PanelPlotOutput
+    {
+    public:
+        enum Function
+        {
+            NONE,
+            FFT,
+            SUM
+        };
+
+        PlotFunction(AMDA::Parameters::ParameterManager &manager,
+                     boost::shared_ptr<Panel> panel, TimeAxisDecorator *timeAxisDecorator = new DefaultTimeAxisDecorator());
+        virtual ~PlotFunction();
+
+        /**
+         * @overload plot::PanelPlotOutput
+         */
+        virtual const std::string typeName()
+        {
+            return PlotFunction_NODENAME;
+        }
+
+        void setOriginalParamId(std::string originalParamId_)
+        {
+            originalParamId = originalParamId_;
+        };
+
+        void setAbscisse(Abscisse abscisse_)
+        {
+            abscisse = abscisse_;
+        };
+
+        Abscisse getAbscisse()
+        {
+            return abscisse;
+        };
+
+        Function getFunction()
+        {
+            return function;
+        };
+
+        void setFunction(Function function_)
+        {
+            function = function_;
+        };
+
+        void setParamsNbPoints(std::string nb)
+        {
+            paramsNbPoints = nb;
+        };
+
+        void setAbscisseScale(Axis::Scale scale)
+        {
+            abscisseScale = scale;
+        };
+
+        Axis::Scale getAbscisseScale()
+        {
+            return abscisseScale;
+        };
+
+        Axis::Scale getOrdonneeScale()
+        {
+            return ordonneeScale;
+        };
+
+        void setOrdonneeScale(Axis::Scale scale)
+        {
+            ordonneeScale = scale;
+        };
+        static QSASConfig *qsasconfig;
+
+        void setTimeAxisDecorator(std::shared_ptr<TimeAxisDecorator> pDecorator_)
+        {
+            _xdecoratorPtr = pDecorator_;
+        }
+
+        std::shared_ptr<TimeAxisDecorator> getTimeAxisDecorator()
+        {
+            return _xdecoratorPtr;
+        }
+
+    protected:
+        /**
+         *@brief Draw the serie of a parameter component on plot.
+         */
+        virtual void
+        drawSeries(double startDate, double stopDate, int intervalIndex, std::string pParamId,
+                   SeriesProperties &pSerie,
+                   AMDA::Common::ParameterIndexComponent pParamIndex,
+                   ParameterAxes &param, bool moreThanOneSerieForAxis);
+
+        virtual void preparePlotArea(double startTime, double stopTime, int intervalIndex);
+        /**
+         * @brief Get original id of the concerned parameter (for the plot) then add it to the usedParametersId_ and store it in originalParamId
+         *
+         * @param usedParametersId_
+         */
+        virtual void createParameters(std::list<std::string> &usedParametersId_);
+        /**
+         * @brief draw the plot for the current time interval
+         */
+        virtual bool draw(double startTime, double stopTime, int intervalIndex,
+                          bool isFirstInterval, bool isLastInterval);
+
+        // virtual void drawFills(double startDate, double stopDate);
+
+    private:
+        void configureSeriesAxis();
+        void configureAxisLegend();
+        void drawStartDate(std::string _timeFormat, double startTime, double stopTime);
+        void createYAxis();
+        void createXAxis();
+        void getMinMax(std::map<std::string, std::vector<double>>, double *minToFill, double *maxToFill);
+
+        void compute(AMDA::Common::ParameterIndexComponent pParamIndex, plot::ParameterData data, std::string id);
+        std::map<std::string, std::vector<double>> xValuesMap;
+        std::map<std::string, std::vector<double>> yValuesMap;
+        Function function;
+        std::string paramsNbPoints = "";
+        Abscisse abscisse;
+        Axis::Scale abscisseScale;
+        Axis::Scale ordonneeScale;
+        std::shared_ptr<TimeAxisDecorator> _xdecoratorPtr;
+
+        /**
+         * @brief original param Id.
+         */
+        std::string originalParamId;
+        std::list<std::string> listParamsId;
+        // std::vector<double> xValues;
+        // std::vector<double> yValues;
+    };
+}
+#endif
@@ -0,0 +1,148 @@
+
+
+#include "PlotFunctionNode.hh"
+#include "AxesNode.hh"
+#include "FillsNode.hh"
+#include "PanelPlotNodeRegistry.hh"
+#include "ParamsNode.hh"
+#include "PlotFunction.hh"
+#include "PlotLegendNode.hh"
+#include "PlotLogger.hh"
+
+// DD_Client_r_lib module includes
+#include "TimeUtil.hh"
+
+namespace plot
+{
+
+    const std::string PlotFunctionNode::NODENAME = PlotFunction_NODENAME;
+
+    std::string PlotFunctionNode::_key = PanelPlotNodeRegistry::getInstance().addElement(
+        NODENAME, boost::shared_ptr<PlotFunctionNode>(new PlotFunctionNode()));
+
+    PlotFunctionNode::PlotFunctionNode() : AbstractPanelPlotNode()
+    {
+        getChildList()["legends"] = AMDA::XMLConfigurator::NodeCfgSPtr(
+            new PlotLegendNode());
+        getChildList()["params"] = AMDA::XMLConfigurator::NodeCfgSPtr(
+            new ParamsNode<PlotFunction>());
+        getChildList()["axes"] = AMDA::XMLConfigurator::NodeCfgSPtr(new AxesNode());
+    }
+
+    PlotFunctionNode::~PlotFunctionNode()
+    {
+    }
+
+    boost::shared_ptr<PanelPlotOutput> PlotFunctionNode::proceed(xmlNodePtr pNode_,
+                                                                 PlotOutput *plotManager_, Panel *panel_)
+    {
+
+        LOG4CXX_DEBUG(gLogger, "PlotFunctionNode::proceed");
+        boost::shared_ptr<PlotFunction> plot(
+            new PlotFunction(plotManager_->getParameterManager(),
+                             boost::shared_ptr<Panel>(panel_)));
+
+        // Copy default pages values for the panel if not already specified
+        if (panel_->_leftMargin == -1)
+            panel_->_leftMargin = panel_->_page->_defaultXYPlotLeftMargin;
+        if (panel_->_rightMargin == -1)
+            panel_->_rightMargin = panel_->_page->_defaultXYPlotRightMargin;
+        if (panel_->_topMargin == -1)
+            panel_->_topMargin = panel_->_page->_defaultXYPlotTopMargin;
+        if (panel_->_bottomMargin == -1)
+            panel_->_bottomMargin = panel_->_page->_defaultXYPlotBottomMargin;
+
+        if (panel_->_preferedWidth == -1)
+            panel_->_preferedWidth = panel_->_page->_defaultXYPlotWidth;
+        if (panel_->_preferedHeight == -1)
+            panel_->_preferedHeight = panel_->_page->_defaultXYPlotHeight;
+
+        // Read PlotFunction attributes
+        xmlChar *value;
+        value = xmlGetProp(pNode_, (const xmlChar *)PlotFunctuion_Type);
+        if (value)
+        {
+            const char *valueString = (const char *)value;
+            if (strcmp(valueString, PlotFunctuion_Type_SUM) == 0)
+                plot->setFunction(PlotFunction::Function::SUM);
+            else if (strcmp(valueString, PlotFunctuion_Type_FFT) == 0)
+                plot->setFunction(PlotFunction::Function::FFT);
+            else
+                plot->setFunction(PlotFunction::Function::NONE);
+            xmlFree(value);
+        }
+
+        value = xmlGetProp(pNode_, (const xmlChar *)PlotFunction_Abscisse);
+        if (value && plot->getFunction() == PlotFunction::Function::FFT)
+        {
+            const char *valueString = (const char *)value;
+            if (strcmp(valueString, PlotFunction_Abscisse_Frequency) == 0)
+            {
+                Abscisse abscisse("Freq. ", "(Hz)", Abscisse::Abscisse_Type::FREQUENCY);
+                plot->setAbscisse(abscisse);
+            }
+            else if (strcmp(valueString, PlotFunction_Abscisse_Period) == 0)
+            {
+                Abscisse abscisse("Period. ", "(S)", Abscisse::Abscisse_Type::PERIOD);
+                plot->setAbscisse(abscisse);
+            }
+
+            xmlFree(value);
+        }
+        else
+        {
+            Abscisse abscisse("Time, ", "UT", Abscisse::Abscisse_Type::TIME);
+            plot->setAbscisse(abscisse);
+        }
+
+        value = xmlGetProp(pNode_, (const xmlChar *)PlotFunctuion_Params_Nb_Points);
+        if (value)
+        {
+            const char *newValueBrut = (char *)value;
+            std::string newValue = std::str(newValueBrut);
+            plot->setParamsNbPoints(newValue);
+            xmlFree(value);
+        }
+
+        value = xmlGetProp(pNode_, (const xmlChar *)PlotFunction_Scale_Abscisse);
+        if (value)
+        {
+            const char *valueAbscisseScale = (char *)value;
+            if (strcmp(valueAbscisseScale, PlotFunction_Linear) == 0)
+                plot->setAbscisseScale(Axis::Scale::LINEAR);
+            else if (strcmp(valueAbscisseScale, PlotFunction_Log) == 0)
+                plot->setAbscisseScale(Axis::Scale::LOGARITHMIC);
+
+            LOG4CXX_DEBUG(gLogger, valueAbscisseScale);
+            LOG4CXX_DEBUG(gLogger, plot->getAbscisseScale());
+            xmlFree(value);
+        }
+
+        value = xmlGetProp(pNode_, (const xmlChar *)PlotFunction_Scale_Ordonnee);
+        if (value)
+        {
+            const char *valueOrdonneeScale = (char *)value;
+            if (strcmp(valueOrdonneeScale, PlotFunction_Linear) == 0)
+                plot->setOrdonneeScale(Axis::Scale::LINEAR);
+
+            else if (strcmp(valueOrdonneeScale, PlotFunction_Log) == 0)
+                plot->setOrdonneeScale(Axis::Scale::LOGARITHMIC);
+            LOG4CXX_DEBUG(gLogger, valueOrdonneeScale);
+            LOG4CXX_DEBUG(gLogger, plot->getOrdonneeScale());
+            xmlFree(value);
+        }
+        else
+        {
+            LOG4CXX_DEBUG(gLogger, "non value");
+        }
+
+        AMDA::Parameters::CfgContext context;
+        context.push<PanelPlotOutput *>(plot.get());
+        context.push<PlotFunction *>(plot.get());
+        context.push<Panel *>(panel_);
+        AMDA::XMLConfigurator::NodeGrpCfg::proceed(pNode_, context);
+
+        return plot;
+    }
+
+} /* namespace plot */
@@ -0,0 +1,57 @@
+
+#ifndef PlotFunctionNODE_HH_
+#define PlotFunctionNODE_HH_
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <libxml/tree.h>
+
+#include "AbstractPanelPlotNode.hh"
+#include "Panel.hh"
+#include "PanelPlotOutput.hh"
+#include "PlotOutput.hh"
+
+namespace plot
+{
+/**
+ * xml node name, this name is used in both config and request xml files.
+ */
+#define PlotFunction_NODENAME "plotFunction"
+#define PlotFunction_Abscisse "abscisse"
+#define PlotFunction_Scale_Abscisse "scale_abscisse"
+#define PlotFunction_Scale_Ordonnee "scale_ordonnee"
+#define PlotFunction_Abscisse_Frequency "Frequency"
+#define PlotFunction_Abscisse_Period "Period"
+#define PlotFunction_Abscisse_Time "Time"
+#define PlotFunctuion_Type "type"
+#define PlotFunctuion_Type_FFT "FFT"
+#define PlotFunctuion_Type_SUM "SUM"
+#define PlotFunctuion_Params_Nb_Points "param_nb_points"
+#define PlotFunction_Linear "Linear"
+#define PlotFunction_Log "Log"
+
+    class PlotFunctionNode : public plot::AbstractPanelPlotNode
+    {
+    public:
+        PlotFunctionNode();
+        virtual ~PlotFunctionNode();
+
+    protected:
+        /**
+         * @overload plot::AbstractPanelPlotNode::proceed
+         */
+        boost::shared_ptr<PanelPlotOutput> proceed(xmlNodePtr, PlotOutput *, Panel *);
+
+    private:
+        /**
+         * constant to uniquely identify this node in the registry
+         */
+        static const std::string NODENAME;
+        /**
+         * artificial special attribute to force registering node.
+         */
+        static std::string _key;
+    };
+
+} // namespace plot
+
+#endif /* TIMEPLOTNODE_HH_ */