First implementation to draw TT and catalog in a time series plot (#5973)

Benjamin Renard
1 parent 40f1fe40
Showing 13 changed files with 530 additions and 8 deletions Show diff stats
config/app/plotConfig.xml
config/app/plplot/cmap0_intervals.pal
config/xsd/request/plot.xsd
src/ParamOutputImpl/Plot/IntervalsNode.hh
src/ParamOutputImpl/Plot/IntervalsProperties.cc
src/ParamOutputImpl/Plot/IntervalsProperties.hh
src/ParamOutputImpl/Plot/PanelPlotOutput.cc
src/ParamOutputImpl/Plot/PanelPlotOutput.hh
src/ParamOutputImpl/Plot/ParameterAxes.cc
src/ParamOutputImpl/Plot/ParameterAxes.hh
src/ParamOutputImpl/Plot/ParamsNode.hh
src/ParamOutputImpl/Plot/Time/TimePlot.cc
src/ParamOutputImpl/Plot/Time/TimePlot.hh
@@ -49,6 +49,7 @@
 			<file index="0">cmap0_default.pal</file>
 			<file index="1">cmap1_default.pal</file>
 			<file index="2">cmap0_test.pal</file>
+			<file index="3">cmap0_intervals.pal</file>
 		</color>
 		<coloraxis default="0">
 			<file index="0">cmap1_default.pal</file>
@@ -0,0 +1,4 @@
+3
+#ff0000
+#00ff00
+#0000ff
@@ -218,7 +218,15 @@
              </xs:documentation>
          </xs:annotation>
     </xs:element>
-    
+
+    <xs:element name="intervals" type="ParameterIntervalsPropertiesType" substitutionGroup="ParameterDrawElement">
+                <xs:annotation>
+                <xs:documentation>
+                        define drawing properties for a
+                        intervals serie.
+             </xs:documentation>
+         </xs:annotation>
+    </xs:element>    
  
     <!-- Define additional plot objects  -->
     <xs:complexType name="AdditionalObjetctsType">
@@ -853,6 +861,11 @@ Note : This attribute may be unecessary since kind of line may be deduce from Pl
 		<xs:attribute name="colorSerieId" type="xs:integer"></xs:attribute>
 	</xs:complexType>
  
+	<xs:complexType name="ParameterIntervalsPropertiesType">
+		<xs:attribute name="index" type="xs:string" use="optional"></xs:attribute>
+		<xs:attribute name="colorMapIndex" type="xs:integer" use="optional"></xs:attribute>
+	</xs:complexType>
+
 	<xs:complexType name="ParameterSpectroPropertiesType">
     	<xs:attribute name="yAxis" type="xs:string" />
     	<xs:attribute name="index" type="xs:string" use="optional"></xs:attribute>
@@ -0,0 +1,76 @@
+/*
+ * IntervalsNode.hh
+ *
+ *  Created on: Feb 4, 2019
+ *      Author: AKKA
+ */
+
+#ifndef INTERVALSNODE_HH_
+#define INTERVALSNODE_HH_
+
+#include <libxml/globals.h>
+#include <libxml/tree.h>
+#include <libxml/xmlstring.h>
+#include <iosfwd>
+
+#include "FileConfigurator.hh"
+#include "DrawingPropertiesNode.hh"
+#include "PlotLogger.hh"
+#include "IntervalsProperties.hh"
+
+namespace plot {
+/**
+ * Class that handle a <intervals> xml node.
+ * Template class that should be instanciated for each subclass of PanelOutputPanel.
+ */
+
+template<class PlotType>
+class IntervalsNode: public plot::DrawingPropertiesNode<PlotType> {
+public:
+	IntervalsNode():
+		DrawingPropertiesNode<PlotType>() {
+	}
+	virtual ~IntervalsNode() {
+	}
+
+	void proceed(xmlNodePtr pNode_,const AMDA::Parameters::CfgContext& pContext_) {
+		LOG4CXX_DEBUG(gLogger, "IntervalsNode::proceed");
+		PlotType* plotOutput = pContext_.get<PlotType*>();
+		xmlChar* name = pContext_.get<xmlChar*>();
+
+		// initialize intervals with default properties
+		DrawingProperties defaultProps = plotOutput->getParameter(
+				(const char*) name).getDefaultProperties();
+
+		// read parent attributes
+		DrawingPropertiesNode<PlotType>::parseAttributes(pNode_, defaultProps);
+
+		// intervals properties
+		std::shared_ptr<IntervalsProperties> intervalsPropsPtr =
+				std::shared_ptr<IntervalsProperties>(new IntervalsProperties(defaultProps));
+
+		// read index definition
+		xmlChar * value = NULL;
+
+		value = xmlGetProp(pNode_, (const xmlChar*) "index");
+		if (value) {
+			intervalsPropsPtr->setIndexDef((const char*) value);
+			xmlFree(value);
+		}
+
+		// colorMapIndex attribute
+		value = xmlGetProp(pNode_, (const xmlChar *) "colorMapIndex");
+		if (value != nullptr) {
+			intervalsPropsPtr->setColorMapIndex(atoi((const char*) value));
+			xmlFree(value);
+		}
+
+		// add intervals definition to parameter
+		plotOutput->getParameter((const char*)name).addIntervalsProperties(intervalsPropsPtr);
+	}
+};
+
+}
+/* namespace plot */
+
+#endif /* INTERVALSNODE_HH_ */
@@ -0,0 +1,35 @@
+/*
+ * IntervalsProperties.cc
+ *
+ *  Created on: Feb 4, 2019
+ *      Author: AKKA
+ */
+#include "IntervalsProperties.hh"
+#include "DrawingProperties.hh"
+#include <sstream>
+
+namespace plot {
+
+/*
+ * Dumps properties for test.
+ */
+void IntervalsProperties::dump(std::ostream& out_, std::string& prefix_) {
+	out_ << "[INTERVALS PROPERTIES]" << std::endl;
+	out_ << prefix_ << "xAxisId=" << getXAxisId() << std::endl;
+	out_ << prefix_ << "paramId=" << getParamId() << std::endl;
+	out_ << prefix_ << "index=" << getIndexDef() << std::endl;
+	getColor().dump(out_, prefix_);
+}
+
+std::ostream& operator<<(std::ostream& out_, const IntervalsProperties& prop_) {
+	out_ << "[INTERVALS PROPERTIES]" << std::endl;
+	out_ << "{" << std::endl;
+	out_ << "  xAxis Id = " << prop_.getXAxisId() << std::endl;
+	out_ << "  index = " << prop_.getIndexDef() << std::endl;
+	
+	out_ << "}" << std::endl;
+	return out_;
+}
+
+}  // namespace plot
+
@@ -0,0 +1,116 @@
+/*
+ * IntervalsProperties.hh
+ *
+ *  Created on: Feb 4, 2019
+ *      Author: AKKA
+ */
+
+#ifndef INTERVALSPROPERTIES_HH_
+#define INTERVALSPROPERTIES_HH_
+
+#include <iostream>
+#include <cmath>
+#include <string>
+
+#include "DrawingProperties.hh"
+
+namespace plot {
+
+/**
+ * Drawing properties for a parameter intervals.
+ */
+class IntervalsProperties: public DrawingProperties {
+public:
+
+	friend std::ostream& operator<<(std::ostream& out_,
+			const IntervalsProperties& lprop_);
+
+	/*
+	 * @brief Dumps properties for test.
+	 */
+	void dump(std::ostream& out_, std::string& prefix_);
+
+	IntervalsProperties() :
+			DrawingProperties(), _paramId(""), _indexDef(""), _colorMapIndex(0) {
+	}
+
+	IntervalsProperties(const DrawingProperties& ref_) :
+			DrawingProperties(ref_), _paramId(""), _indexDef(""), _colorMapIndex(0) {
+
+	}
+
+	IntervalsProperties(const IntervalsProperties& pParamDrawingProperties_) :
+			DrawingProperties(pParamDrawingProperties_), _paramId(""), 
+				_indexDef(pParamDrawingProperties_._indexDef), _colorMapIndex(pParamDrawingProperties_._colorMapIndex) {
+	}
+
+	IntervalsProperties& operator=(const IntervalsProperties& ref_) {
+		DrawingProperties::operator=(ref_);
+		_paramId    = ref_._paramId;
+		_indexDef   = ref_._indexDef;
+		_colorMapIndex = ref_._colorMapIndex;
+		return *this;
+	}
+
+	virtual ~IntervalsProperties() {
+	}
+
+	std::string getParamId(){
+		return _paramId;
+	}
+
+	void setParamId(std::string paramId_) {
+		_paramId = paramId_;
+	}
+
+	std::string getIndexDef() const {
+		return _indexDef;
+	}
+
+	void setIndexDef(std::string indexDef) {
+		_indexDef = indexDef;
+	}
+
+	AMDA::Common::ParameterIndexComponentList& getIndexes()
+	{
+		return _indexList;
+	}
+
+	void setIndexes(AMDA::Common::ParameterIndexComponentList indexList)
+	{
+		_indexList = indexList;
+	}
+
+	void setColorMapIndex( int colorMapIndex){
+		_colorMapIndex = colorMapIndex;
+	}
+
+	int getColorMapIndex() const{
+		return _colorMapIndex;
+	}
+
+private:
+	/**
+	 * @brief Calculated paramId (from resolution).
+	 */
+	std::string _paramId;
+
+	/**
+	 * @brief Index definition (give by the request)
+	 */
+	std::string _indexDef;
+
+	/*
+	 * @brief List of components used by the spectro
+	 */
+	AMDA::Common::ParameterIndexComponentList _indexList;
+
+	/**
+	 * @brief Color Map index to use
+	 */
+	int _colorMapIndex;
+};
+
+} /* namespace plot */
+
+#endif /* INTERVALSPROPERTIES_HH_ */
@@ -1266,7 +1266,7 @@ bool PanelPlotOutput::getColoredValue(double value, double filterMin, double fil
 	// Restore color.
 	restoreColor(_pls, lInitialColor, _panel->_page->_mode);
 }
-
+ 
 /**
  * Draw list of lines
  */
@@ -1355,6 +1355,48 @@ void PanelPlotOutput::drawLines(LineType pType, LineStyle pStyle, int pWidth, Co
 	restoreColor(_pls, lInitialColor, _panel->_page->_mode);
 }
  
+/**
+ * Draw a rectangle
+ */
+void PanelPlotOutput::drawRectangle(double xmin, double xmax, double ymin, double ymax, int colorIndex, int colorMapIndex, double alpha)
+{
+        //set color map
+        std::string lFilePath = ColormapManager::getInstance().get(_panel->_page->_mode, colorMapIndex);
+	_pls->spal0(lFilePath.c_str());
+        
+        Color lInitialColor;
+        _pls->gcol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);
+        
+        PLFLT x[4], y[4];
+        x[0] = xmin;
+        x[1] = xmin;
+        x[2] = xmax;
+        x[3] = xmax;
+        y[0] = ymin;
+        y[1] = ymax;
+        y[2] = ymax;
+        y[3] = ymin;
+            
+        PLINT icol = (PLINT)colorIndex;
+        PLINT r, g, b = 0;
+        PLFLT a = 0;
+        _pls->gcol0a( icol, r, g, b, a);
+        a = alpha;
+        _pls->scol0a( icol, r, g, b, a );
+        _pls->col0( icol );
+            
+        _pls->fill(4, x, y);
+            
+        //restore to initial color context
+	lFilePath = ColormapManager::getInstance().get(_panel->_page->_mode, 0);
+	_pls->spal0(lFilePath.c_str());
+                
+	_pls->scol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);
+
+	// Restore color.
+	restoreColor(_pls, lInitialColor, _panel->_page->_mode);
+}
+
 /*
  * @brief Draw a matrix
  */
@@ -2189,10 +2231,37 @@ bool PanelPlotOutput::draw(double startTime, double stopTime, int intervalIndex,
  
 			ParameterData &data = (*_pParameterValues)[parameter.getSpectroProperties()->getParamId()];
  
-			for (auto index : parameter.getSpectroProperties()->getIndexes()) {
-				if (noData)
-					noData = data.noData(index);
-			}
+                        if (parameter.getSpectroProperties()->getIndexes().empty()) {
+                            noData = data.noData();
+                        }
+                        else {
+                            for (auto index : parameter.getSpectroProperties()->getIndexes()) {
+                                    if (noData)
+                                            noData = data.noData(index);
+                            }
+                        }
+		}
+	}
+
+	//Draw intervals
+	for (auto parameter : _parameterAxesList) {
+		if (parameter.getIntervalsProperties() != nullptr) {
+			//draw intervals
+			LOG4CXX_DEBUG(gLogger, "Draw intervals for parameter " << parameter._originalParamId);
+			// Draw (configure) window for this series.
+			drawIntervals(startTime, stopTime, parameter._originalParamId, *(parameter.getIntervalsProperties()));
+
+			ParameterData &data = (*_pParameterValues)[parameter.getIntervalsProperties()->getParamId()];
+
+                        if (parameter.getIntervalsProperties()->getIndexes().empty()) {
+                            noData = data.noData();
+                        }
+                        else {
+                            for (auto index : parameter.getIntervalsProperties()->getIndexes()) {
+                                    if (noData)
+                                            noData = data.noData(index);
+                            }                            
+                        }
 		}
 	}
  
@@ -2340,6 +2409,55 @@ void PanelPlotOutput::drawSpectro(double /*startDate*/, double /*stopDate*/, std
 		}
 }
  
+void PanelPlotOutput::drawIntervals(double /*startDate*/, double /*stopDate*/, std::string /*pParamId*/,
+		IntervalsProperties& pIntervals) {
+    
+                boost::shared_ptr<Axis> lXAxis(_panel->getAxis(pIntervals.getXAxisId()));
+
+		PlWindow lPlWindow;
+		Range lXRange, lYRange;
+		if (lXAxis.get() == nullptr) {
+			std::stringstream lError;
+			lError << "PanelPlotOutput::drawIntervals" << ": X axis with id '"
+					<< pIntervals.getXAxisId() << "' not found.";
+			BOOST_THROW_EXCEPTION(
+					PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
+		}
+		
+                lXRange = lXAxis->getRange();
+		
+		lYRange = Range(0,1);
+
+		lPlWindow = PlWindow(lXRange.getMin(), lXRange.getMax(), lYRange.getMin(), lYRange.getMax());
+
+		// Calculate X and Y tick
+		TickConf lTickConf;
+		double lXMajorTickSpace = nan("");
+		int lXMinorTickNumber = 0;
+		double lYMajorTickSpace = nan("");
+		int lYMinorTickNumber = 0;
+
+                lXMajorTickSpace = getMajorTickSpace(lXAxis.get(),
+					std::get<0>(lPlWindow), std::get<1>(lPlWindow));
+                lXMinorTickNumber = getMinorTickNumber(lXAxis.get(),
+					std::get<0>(lPlWindow), std::get<1>(lPlWindow),	lXMajorTickSpace);
+		
+                lTickConf = TickConf(lXMajorTickSpace, lXMinorTickNumber, lYMajorTickSpace, lYMinorTickNumber);
+
+		// Draw X axis and legend
+		if (!lXAxis->_drawn) {
+
+			drawXAxis(lXAxis, lPlWindow, _plotAreaBounds, lTickConf);
+
+			// Draw legend.
+			drawLegends(lXAxis, lPlWindow, _plotAreaBounds);
+		}
+
+
+                _pls->vpor( _plotAreaBounds._x, _plotAreaBounds._x + _plotAreaBounds._width,
+				_plotAreaBounds._y,     _plotAreaBounds._y + _plotAreaBounds._height);
+}
+
 void PanelPlotOutput::drawFills(double /*startDate*/, double /*stopDate*/) {
 	// Nothing done here except setting the viewport, see subclasses for specific implementation
 	_pls->vpor( _plotAreaBounds._x,	_plotAreaBounds._x + _plotAreaBounds._width,
@@ -2804,6 +2922,31 @@ void PanelPlotOutput::createParameters(std::list&lt;std::string&gt;&amp; usedParametersId_
 					usedParametersId_.push_back(tableParamId);
 			}
 		}
+
+		//For intervals if defined
+		std::shared_ptr<IntervalsProperties> pIntProp = it->getIntervalsProperties();
+		if (pIntProp != nullptr) {
+			//get corrected sampling value in relation with max resolution
+			double correctedSamplingValue = getCorrectedSamplingValue(pIntProp->getMaxResolution(), samplingValue);
+			AMDA::Parameters::ParameterSPtr usedParam;
+
+			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());
+			pIntProp->setParamId(usedParam->getId());
+		}
 	}
 }
  
@@ -2882,6 +3025,30 @@ std::vector&lt;AMDA::Common::ParameterIndexComponent&gt; PanelPlotOutput::getParamUsed
 			}
 		}
  
+		//get indexes for intervals
+		std::shared_ptr<IntervalsProperties> pIntProp = paramAxeIt->getIntervalsProperties();
+		if (pIntProp != nullptr)
+		{
+			if (pIntProp->getParamId() == paramId)
+			{
+				if (pIntProp->getIndexes().empty())
+                                {
+					//get used indexes by the intervals thanks to the index definition in the request
+					AMDA::Common::ParameterIndexComponentList indexList;
+					AMDA::Common::ParameterIndexesTool::parse(pIntProp->getIndexDef(),
+							dim1Size, dim2Size, indexList);
+					pIntProp->setIndexes(indexList);
+				}
+
+				for (auto index : pIntProp->getIndexes())
+				{
+					if (std::find(indexes.begin(),indexes.end(),index) != indexes.end())
+						continue;
+					indexes.push_back(index);
+				}
+			}
+		}
+
 		//get indexes for series of this ParameterAxe
 		std::vector<AMDA::Common::ParameterIndexComponent> seriesIndexes = paramAxeIt->getParamUsedIndexes(paramId);
  
@@ -325,8 +325,11 @@ protected:
 			int pNbData, double* pXData, double* pYData,
 			double* pZData = NULL, double filterZMin = -DBL_MAX, double filterZMax = DBL_MAX);
  
-
-
+        /**
+         * Draw a rectangle
+         */
+        void drawRectangle(double xmin, double xmax, double ymin, double ymax, int colorIndex, int colorMapIndex, double alpha = 1.);
+        
 	/**
 	 * Draw errors segments
 	 */
@@ -345,6 +348,9 @@ protected:
 	virtual void drawSpectro(double startDate, double stopDate, std::string pParamId,
 			SpectroProperties& pSpectro);
  
+	virtual void drawIntervals(double startDate, double stopDate, std::string pParamId,
+			IntervalsProperties& pIntervals);
+
 	/*
 	 * @brief Draw interval
 	 */
@@ -47,6 +47,10 @@ void ParameterAxes::addSpectroProperties(std::shared_ptr&lt;SpectroProperties&gt; pSPe
 	_spectroPropertiesPtr = pSPectroProperties;
 }
  
+void ParameterAxes::addIntervalsProperties(std::shared_ptr<IntervalsProperties> pIntervalsProperties){
+	_intervalsPropertiesPtr = pIntervalsProperties;
+}
+
 void ParameterAxes::addColorSerieProperties(const ColorSeriesProperties& s_) {
 	_colorSeriesProperties.push_back(s_);
 }
@@ -67,6 +71,15 @@ std::vector&lt;AMDA::Common::ParameterIndexComponent&gt; ParameterAxes::getParamUsedIn
  
 	}
  
+	if (_intervalsPropertiesPtr != nullptr)
+	{
+		if (_intervalsPropertiesPtr->getParamId() == paramId_)
+		{
+			keyset.push_back(AMDA::Common::ParameterIndexComponent(-1,-1));
+			return keyset;
+		}
+	}
+
 	for (std::vector<SeriesProperties>::iterator it =
 			_ySeriesProperties.begin(); it != _ySeriesProperties.end(); ++it) {
 			// add index only if serie has same paramId to not store
@@ -158,6 +171,14 @@ void ParameterAxes::dump(std::ostream&amp; out_, std::string&amp; prefix_) {
 		_spectroPropertiesPtr->dump(out_, subPrefix);
 	}
  
+	if (_intervalsPropertiesPtr != nullptr)
+	{
+		os.str("");
+		os << prefix_ << "intervals" << ".";
+		subPrefix = os.str();
+		_intervalsPropertiesPtr->dump(out_, subPrefix);
+	}
+
 	std::vector<ColorSeriesProperties>::iterator colorit;
 	for (colorit = _colorSeriesProperties.begin(); colorit != _colorSeriesProperties.end();
 			++colorit) {
@@ -17,6 +17,7 @@
 #include "XSeriesProperties.hh"
 #include "DrawingProperties.hh"
 #include "SpectroProperties.hh"
+#include "IntervalsProperties.hh"
 #include "ColorSeriesProperties.hh"
 #include "Parameter.hh"
 #include "ParameterData.hh"
@@ -42,6 +43,7 @@ public:
 			_defaultProperties(),
 			_ySeriesProperties(),
 			_spectroPropertiesPtr(nullptr),
+			_intervalsPropertiesPtr(nullptr),
 			_colorSeriesProperties()
 	{
  
@@ -52,6 +54,7 @@ public:
 			_defaultProperties(),
 			_ySeriesProperties(),
 			_spectroPropertiesPtr(nullptr),
+			_intervalsPropertiesPtr(nullptr),
 			_colorSeriesProperties()
 	{
  
@@ -63,6 +66,7 @@ public:
 			_ySeriesProperties(pParamAxes._ySeriesProperties),
 			_xSeriesProperties(pParamAxes._xSeriesProperties),
 			_spectroPropertiesPtr(pParamAxes._spectroPropertiesPtr),
+			_intervalsPropertiesPtr(pParamAxes._intervalsPropertiesPtr),
 			_colorSeriesProperties(pParamAxes._colorSeriesProperties) {
  
 	}
@@ -73,6 +77,7 @@ public:
 		_ySeriesProperties = pParamAxes_._ySeriesProperties;
 		_xSeriesProperties = pParamAxes_._xSeriesProperties;
 		_spectroPropertiesPtr = pParamAxes_._spectroPropertiesPtr;
+		_intervalsPropertiesPtr = pParamAxes_._intervalsPropertiesPtr;
 		_colorSeriesProperties = pParamAxes_._colorSeriesProperties;
 		return *this;
 	}
@@ -104,6 +109,11 @@ public:
 	void addSpectroProperties(std::shared_ptr<SpectroProperties> pSPectroProperties);
  
 	/**
+	 * add a new intervals
+	 */
+	void addIntervalsProperties(std::shared_ptr<IntervalsProperties> pIntervalsProperties);
+
+	/**
 	 * add a new color serie
 	 */
 	void addColorSerieProperties(const ColorSeriesProperties&);
@@ -125,6 +135,10 @@ public:
 		return _spectroPropertiesPtr;
 	}
  
+	std::shared_ptr<IntervalsProperties> getIntervalsProperties() {
+		return _intervalsPropertiesPtr;
+	}
+
 	std::vector<ColorSeriesProperties>& getColorSeriePropertiesList() {
 		return _colorSeriesProperties;
 	}
@@ -175,6 +189,11 @@ private:
 	std::shared_ptr<SpectroProperties> _spectroPropertiesPtr;
  
 	/**
+	 * Intervals
+	 */
+	std::shared_ptr<IntervalsProperties> _intervalsPropertiesPtr;
+
+	/**
 	 * Color Series
 	 */
 	std::vector<ColorSeriesProperties> _colorSeriesProperties;
@@ -16,6 +16,7 @@
 #include "DrawingPropertiesNode.hh"
 #include "SeriesNode.hh"
 #include "SpectroNode.hh"
+#include "IntervalsNode.hh"
  
 namespace plot {
  
@@ -30,6 +31,8 @@ public:
 				new SeriesNode<PlotType>());
 		getChildList()["spectro"] = AMDA::XMLConfigurator::NodeCfgSPtr(
 						new SpectroNode<PlotType>());
+		getChildList()["intervals"] = AMDA::XMLConfigurator::NodeCfgSPtr(
+						new IntervalsNode<PlotType>());
 		getChildList()["colorserie"] = AMDA::XMLConfigurator::NodeCfgSPtr(
 				new ColorSeriesNode<PlotType>());
 	}
@@ -1016,6 +1016,60 @@ void TimePlot::drawSpectro(double startDate, double stopDate, std::string pParam
 			minValColor, maxValColor, lZAxis->_color._colorMapIndex, FALSE, pSpectro.getUseLog0AsMin());
 }
  
+void TimePlot::drawIntervals(double startDate, double stopDate, std::string pParamId,
+		IntervalsProperties& pIntervals) {
+	LOG4CXX_DEBUG(gLogger, "TimePlot::drawIntervals Drawing intervals for parameter "<<pParamId);
+	// This will configure window, draw axes (if needed) and legend of axes.
+	PanelPlotOutput::drawIntervals(startDate, stopDate, pParamId, pIntervals);
+        
+        PlWindow lPlWindow = PlWindow(getTimeAxis()->getRange().getMin(), getTimeAxis()->getRange().getMax(), 0, 1);
+
+	_pls->wind(std::get<0>(lPlWindow), std::get<1>(lPlWindow),
+				std::get<2>(lPlWindow), std::get<3>(lPlWindow));
+
+	ParameterData& data = (*_pParameterValues)[pIntervals.getParamId()];
+        
+        std::string lFilePath = ColormapManager::getInstance().get(_panel->_page->_mode,
+				pIntervals.getColorMapIndex());
+		_pls->spal0(lFilePath.c_str());
+        
+        //get computed values
+        int startIndex, nbData;
+        data.getIntervalBounds(startDate, stopDate, startIndex, nbData);
+        
+        // Draw intervals
+        double crtVal = NAN;
+        double tmin, tmax = 0;
+        for (int i = 0; i < nbData - 1; ++i) {
+            double t1 = data.getTimes()[startIndex+i];
+            double t2 = data.getTimes()[startIndex+i+1];
+            double v = *data.getValues(AMDA::Common::ParameterIndexComponent(-1,-1), startIndex+i);
+            
+            if (isNAN(crtVal)) {
+                tmin = t1;
+                tmax = t2;
+                crtVal = v;
+                continue;
+            }
+            else if (crtVal == v) {
+                tmax = t2;
+                continue;
+            }
+            
+            //Draw interval between tmin and tmax
+            PanelPlotOutput::drawRectangle(tmin, tmax, 0., 1., (int)crtVal, pIntervals.getColorMapIndex(), 0.25);
+            
+            tmin = t1;
+            tmax = t2;
+            crtVal = v;
+        }
+        
+        //Draw last interval if need
+        if (!isNAN(crtVal)) {
+            PanelPlotOutput::drawRectangle(tmin, tmax, 0., 1., (int)crtVal, pIntervals.getColorMapIndex(), 0.25);
+        }
+}
+
 /**
  * @brief Draw further information (for instance start date).
  */
@@ -102,6 +102,13 @@ protected:
 			SpectroProperties& pSpectro);
  
  
+	/**
+	 * @overload PanelPlotOutput::drawIntervals(double startDate, double stopDate, std::string pParamId, IntervalsProperties& pIntervals)
+	 * @brief Draw intervals defined by a parameter
+	 */
+	virtual void drawIntervals(double startDate, double stopDate, std::string pParamId,
+			IntervalsProperties& pIntervals);
+
 	void drawXAxis(boost::shared_ptr<Axis> pXAxis, PlWindow& pPlWindow, Bounds& pPlotAreaSize, TickConf& pTickConf);
  
 	/**