/*
 * PanelPlotOutput.cc
 *
 *  Created on: 29 oct. 2013
 *      Author: CS
 */

#include "PanelPlotOutput.hh"

#include "Catalog.hh"

#include "ColorAxis.hh"

#include "ColormapManager.hh"
#include "DecoratorPlot.hh"

#include "Page.hh"

#include "ParamMgr.hh"

#include "ParameterManager.hh"

#include "PlPlotUtil.hh"

#include "PlotLogger.hh"
#include "ShadesTools.hh"

#include "TimeTableCatalogFactory.hh"

#include "TimeUtil.hh"

#include <boost/range/adaptor/reversed.hpp>

#include <string>

using namespace AMDA::Parameters;
using namespace AMDA::Info;

namespace plot

{

	/**
	 * Width character proportion is approximatively 0.83 times smaller than height.
	 */
	const float PanelPlotOutput::CHAR_RATIO = 5. / 6.;

	const float PanelPlotOutput::DEFAULT_TICK_LENGTH_FACTOR = 0.75;

	// Vertical is for Y axis.
	const float PanelPlotOutput::VERTICAL_TICK_LENGTH_LIMIT = 0.5;
	// Horizontal is for X axis.
	const float PanelPlotOutput::HORIZONTAL_TICK_LENGTH_LIMIT = 0.75;
	// margin in case of constante curve
	const float YAXISMARGIN = 0.05;

	PanelPlotOutput::PanelPlotOutput(AMDA::Parameters::ParameterManager &manager, boost::shared_ptr<Panel> panel, bool isStandalone) : _panel(panel),
																																	   _parameterManager(manager),
																																	   _pParameterValues(NULL),
																																	   _timeIntervalListPtr(NULL),
																																	   _panelPlotXYRatio(1),
																																	   _leftAxisTickMarkWidth(0),
																																	   _automaticSerieColorCursor(0),
																																	   _isStandalone(isStandalone)

	{

	}

	PanelPlotOutput::~PanelPlotOutput()
	{
	}

	double getVerticalTickLength(Axis *pAxis, double charHeight)
	{
		float horizontalTickLengthLimit = PanelPlotOutput::HORIZONTAL_TICK_LENGTH_LIMIT;
		float defaultTickLengthFactor = PanelPlotOutput::DEFAULT_TICK_LENGTH_FACTOR;
		double tickLengthFactor = pAxis->_tick._lengthFactor;

		if ((!isnan(tickLengthFactor)) && (tickLengthFactor > horizontalTickLengthLimit))
		{
			// 1 character size is equal to 0.75 tick length.
			return charHeight + (((tickLengthFactor - horizontalTickLengthLimit) * charHeight) / (defaultTickLengthFactor));
		}
		else if ((isnan(tickLengthFactor)) && (defaultTickLengthFactor > horizontalTickLengthLimit))
		{
			// 1 character size is equal to 0.75 tick length.
			return charHeight + (((defaultTickLengthFactor - horizontalTickLengthLimit) * charHeight) / (defaultTickLengthFactor));
		}
		else
		{
			return charHeight;
		}

	}

	double getHorizontalTickLength(Axis *pAxis, double charHeight)
	{
		float verticalTickLengthLimit = PanelPlotOutput::VERTICAL_TICK_LENGTH_LIMIT;
		float defaultTickLengthFactor = PanelPlotOutput::DEFAULT_TICK_LENGTH_FACTOR;
		double tickLengthFactor = pAxis->_tick._lengthFactor;

		if ((!isnan(tickLengthFactor)) && (tickLengthFactor > verticalTickLengthLimit))
		{
			// 1 character size is equal to 0.75 tick length.
			return charHeight + (((tickLengthFactor - verticalTickLengthLimit) * charHeight * PanelPlotOutput::CHAR_RATIO) / (defaultTickLengthFactor));
		}
		else if ((isnan(tickLengthFactor)) && (defaultTickLengthFactor > verticalTickLengthLimit))
		{
			// 1 character size is equal to 0.75 tick length.
			return charHeight + (((defaultTickLengthFactor - verticalTickLengthLimit) * charHeight * PanelPlotOutput::CHAR_RATIO) / (defaultTickLengthFactor));
		}
		else
		{
			return charHeight;
		}
	}

	void PanelPlotOutput::calculatePlotArea(const Bounds & /*panelBounds_*/, Bounds &bounds_)
	{
		double topSpace = 0;
		double bottomSpace = 0;
		double leftSpace = 0;
		double rightSpace = 0;

		// Init
		_plotAreaSideSet[PlotCommon::Position::POS_TOP] = false;
		_plotAreaSideSet[PlotCommon::Position::POS_BOTTOM] = false;
		_plotAreaSideSet[PlotCommon::Position::POS_RIGHT] = false;
		_plotAreaSideSet[PlotCommon::Position::POS_LEFT] = false;
		_plotAreaSideSet[PlotCommon::Position::POS_CENTER] = false;

		// Reserve space for title
		double titleHeight = 0;
		_panel->reserveSpaceForTitle(topSpace, bottomSpace, titleHeight);

		// Reserve space for axes

		//
		std::map<PlotCommon::Position, int> nbAxesBySide;
		nbAxesBySide[PlotCommon::Position::POS_TOP] = 0;
		nbAxesBySide[PlotCommon::Position::POS_BOTTOM] = 0;
		nbAxesBySide[PlotCommon::Position::POS_RIGHT] = 0;
		nbAxesBySide[PlotCommon::Position::POS_LEFT] = 0;
		for (Axes::iterator it = _panel->_axes.begin(); it != _panel->_axes.end(); ++it)
		{
			boost::shared_ptr<Axis> lAxis = it->second;
			if ((lAxis == nullptr) || (lAxis->_isZAxis) || (!lAxis->_used) || (!lAxis->_visible) || (lAxis->_position == PlotCommon::Position::POS_CENTER))
				continue;
			++nbAxesBySide[lAxis->_position];
		}

		// ZAxis must be drawn at last!
		for (Axes::iterator it = _panel->_axes.begin(); it != _panel->_axes.end(); ++it)
		{
			// Add X and Y axis
			boost::shared_ptr<Axis> lAxis = it->second;
			if ((lAxis == nullptr) || (lAxis->_isZAxis))
				continue;
			reserveSpaceForAxis(lAxis, titleHeight, nbAxesBySide, topSpace, bottomSpace, leftSpace, rightSpace);
		}

		for (Axes::iterator it = _panel->_axes.begin(); it != _panel->_axes.end(); ++it)
		{
			// Add Z axis
			boost::shared_ptr<Axis> lAxis = it->second;
			if ((lAxis == nullptr) || (!lAxis->_isZAxis))
				continue;
			reserveSpaceForAxis(lAxis, titleHeight, nbAxesBySide, topSpace, bottomSpace, leftSpace, rightSpace);
		}

		// Get character size for panel.
		PlPlotUtil::setPlFont(_panel->getFont());
		CharSize lCharSizePanel = PlPlotUtil::getCharacterSizeInPlPage(_panel->_page);
		double panelCharWidth = lCharSizePanel.first;
		double panelCharHeight = lCharSizePanel.second;

		// add params legend right space when outside
		if (!_panel->_paramsLegendProperties.getLegendLines().empty() &&
			_panel->_paramsLegendProperties.isVisible() &&
			(_panel->_paramsLegendProperties.getPosition() == ParamsLegendPosition::POS_OUTSIDE))
		{
			PlPlotUtil::setPlFont(_panel->_paramsLegendProperties.getFont());
			CharSize lCharSizeLegend = PlPlotUtil::getCharacterSizeInPlPage(_panel->_page);
			double legendCharWidth = lCharSizeLegend.first;

			// set offset
			_panel->_paramsLegendProperties.setLeftOffset(rightSpace);

			// reserve place for legend
			rightSpace += _panel->_paramsLegendProperties.getEstimateWidth(legendCharWidth);
		}

		// Reserve space for text legend ( maximum 1 text legend by position
		/*bool	leftTextLegendFound		= false;
		bool	rightTextLegendFound 	= false;
		bool	topTextLegendFound 		= false;
		bool	bottomTextLegendFound 	= false; */

		for (auto textLegendProp : _panel->_textLegendPropertiesList)
		{
			bool toDraw = true;

			/*	switch (textLegendProp->getPosition()) {
				case TextLegendPosition::POS_LEFT :
					if (leftTextLegendFound)
						toDraw = false;
					leftTextLegendFound = true;
					break;
				case TextLegendPosition::POS_RIGHT :
					if (rightTextLegendFound)
						toDraw = false;
					rightTextLegendFound = true;
					break;
				case TextLegendPosition::POS_TOP :
					if (topTextLegendFound)
						toDraw = false;
					topTextLegendFound = true;
					break;
				case TextLegendPosition::POS_BOTTOM :
					if (bottomTextLegendFound)
						toDraw = false;
					bottomTextLegendFound = true;
					break;

			}*/

			if (toDraw)
				reserveSpaceForTextLegend(textLegendProp, titleHeight, topSpace, bottomSpace, leftSpace, rightSpace);
		}

		// Set specified left, right, top and bottom margins and display a warning
		// message if computed margins are bigger than specified ones
		if (_panel->_leftMargin != -1)
		{
			if ((_panel->_leftMargin * panelCharWidth) < leftSpace)
				LOG4CXX_WARN(gLogger, "Left margin for the panel was forced beyond computed size");
			leftSpace = _panel->_leftMargin * panelCharWidth;
		}
		if (_panel->_rightMargin != -1)
		{
			if ((_panel->_rightMargin * panelCharWidth) < rightSpace)
				LOG4CXX_WARN(gLogger, "Right margin for the panel was forced beyond computed size");
			rightSpace = _panel->_rightMargin * panelCharWidth;
		}
		if (_panel->_topMargin != -1)
		{
			if ((_panel->_topMargin * panelCharHeight) < topSpace)
				LOG4CXX_WARN(gLogger, "Top margin for the panel was forced beyond computed size");
			topSpace = _panel->_topMargin * panelCharHeight;
		}
		if (_panel->_bottomMargin != -1)
		{
			if ((_panel->_bottomMargin * panelCharHeight) < bottomSpace)
				LOG4CXX_WARN(gLogger, "Bottom margin for the panel was forced beyond computed size");
			bottomSpace = _panel->_bottomMargin * panelCharHeight;
		}

		// Update plot area bounds
		bounds_._x += leftSpace;
		bounds_._y += bottomSpace;
		bounds_._width -= (leftSpace + rightSpace);
		bounds_._height -= (bottomSpace + topSpace);
	}

	void PanelPlotOutput::reserveSpaceForAxis(boost::shared_ptr<Axis> &pAxis, double titleHeight, std::map<PlotCommon::Position, int> nbAxesBySide,
											  double &topSpace, double &bottomSpace, double &leftSpace, double &rightSpace)
	{
		if (pAxis == nullptr || !pAxis->_used || !pAxis->_visible)
			return;

		// Get number of line to draw for legend.
		int nbLegendRows = pAxis->_legend.getNbLines();
		if ((nbLegendRows == 0) && pAxis->_showLegend)
			nbLegendRows = 1;

		// Compute legend character size
		Font legendFont(pAxis->getLegendFont(this->_panel.get()));
		PlPlotUtil::setPlFont(legendFont);
		CharSize legendCharSizePanel = PlPlotUtil::getCharacterSizeInPlPage(_panel->_page);

		std::tuple<float, float> pageSize = _panel->_page->getSizeInMm();

		// Reserve place in relation with the axis position
		switch (pAxis->_position)
		{

		case PlotCommon::Position::POS_BOTTOM:
			if (pAxis->isZAxis())
				LOG4CXX_WARN(gLogger, "PanelPlotOutput::calculatePlotArea: Unrecognized position for z axis '" << pAxis->_position << "'");

			// This attribute is used later (in function PanelPlotOutput::drawSeries).
			if (!pAxis->isZAxis())
				_plotAreaSideSet[pAxis->_position] = true;

			// Reserve space for ticks

			if (pAxis->_tick._position == Tick::TickPosition::OUTWARDS)
			{

				double tickSize = getVerticalTickLength(pAxis.get(), legendCharSizePanel.second);
				bottomSpace += tickSize;

				if (nbAxesBySide[PlotCommon::Position::POS_TOP] == 0)

					// add space for oposite axis

					topSpace += tickSize;

			}

			// Reserve space for ticks labels

			if (pAxis->_showTickMark == true)
				bottomSpace += legendCharSizePanel.second * (1 + 0.25);

			// Reserve space for legend

			if ((pAxis->_showLegend == true) && (nbLegendRows != 0))
			{

				bottomSpace += PlPlotUtil::LINE_SPACE_TITLE * legendCharSizePanel.second;

				double legendOffset = bottomSpace + 0.5 * legendCharSizePanel.second;
				if (!_panel->getTitle()->_text.empty() && (_panel->_titlePosition == PlotCommon::Position::POS_BOTTOM))
					legendOffset -= titleHeight;
				pAxis->setLegendOffset(legendOffset);

				bottomSpace += (nbLegendRows + PlPlotUtil::LINE_SPACE_TITLE * (nbLegendRows + 1)) * legendCharSizePanel.second;

			}

			break;
		case PlotCommon::Position::POS_TOP:
			if (pAxis->isZAxis())
				LOG4CXX_WARN(gLogger, "PanelPlotOutput::calculatePlotArea: Unrecognized position for z axis '" << pAxis->_position << "'");

			// This attribute is used later (in function PanelPlotOutput::drawSeries).
			if (!pAxis->isZAxis())
				_plotAreaSideSet[pAxis->_position] = true;

			// Reserve space for ticks

			if (pAxis->_tick._position == Tick::TickPosition::OUTWARDS)
			{

				double tickSize = getVerticalTickLength(pAxis.get(), legendCharSizePanel.second);
				topSpace += tickSize;

				if (nbAxesBySide[PlotCommon::Position::POS_BOTTOM] == 0)

					// add space for oposite axis

					bottomSpace += tickSize;

			}

			// Reserve space for ticks labels

			if (pAxis->_showTickMark == true)
				topSpace += legendCharSizePanel.second * (1 + 0.25);

			// Reserve space for legend

			if ((pAxis->_showLegend == true) && (nbLegendRows != 0))
			{

				topSpace += PlPlotUtil::LINE_SPACE_TITLE * legendCharSizePanel.second;

				double legendOffset = topSpace - 0.5 * legendCharSizePanel.second;
				if (!_panel->getTitle()->_text.empty() && (_panel->_titlePosition == PlotCommon::Position::POS_TOP))
					legendOffset += titleHeight;
				pAxis->setLegendOffset(legendOffset);

				topSpace += (nbLegendRows + PlPlotUtil::LINE_SPACE_TITLE * (nbLegendRows + 1)) * legendCharSizePanel.second;
			}

			break;
		case PlotCommon::Position::POS_LEFT:
			// Record axis offset used for multi-axes

			pAxis->setAxisOffset(leftSpace);

			if (pAxis->isZAxis())
			{

				leftSpace += estimateZAxisWidth(pAxis);
				break;
			}

			// This attribute is used later (in function PanelPlotOutput::drawSeries).
			_plotAreaSideSet[pAxis->_position] = true;

			// Reserve space for ticks labels

			if (pAxis->_showTickMark == true)
				leftSpace += legendCharSizePanel.first * (pAxis->getTickMarkSize().first + 2 * PlPlotUtil::LINE_SPACE_TITLE + 0.25);

			// Reserve space for ticks

			if (pAxis->_tick._position == Tick::TickPosition::OUTWARDS)
			{

				double tickSize = getHorizontalTickLength(pAxis.get(), legendCharSizePanel.second);
				leftSpace += tickSize;

				if (nbAxesBySide[PlotCommon::Position::POS_RIGHT] == 0)

					// add space for oposite axis

					rightSpace += tickSize;

			}

			// Reserve space for legend

			if ((pAxis->_showLegend == true) && (nbLegendRows != 0))
			{

				leftSpace += PlPlotUtil::LINE_SPACE_TITLE * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize);
				pAxis->setLegendOffset(leftSpace + 0.5 * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize));

				leftSpace += (nbLegendRows + PlPlotUtil::LINE_SPACE_TITLE * (nbLegendRows + 1)) * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize);

			}

			break;
		case PlotCommon::Position::POS_RIGHT:
			// Record axis offset used for multi-axes

			pAxis->setAxisOffset(rightSpace);

			if (pAxis->isZAxis())
			{

				rightSpace += estimateZAxisWidth(pAxis);
				break;
			}

			// This attribute is used later (in function PanelPlotOutput::drawSeries).
			_plotAreaSideSet[pAxis->_position] = true;

			// Reserve space for ticks labels

			if (pAxis->_showTickMark == true)
				rightSpace += legendCharSizePanel.first * (pAxis->getTickMarkSize().first + 2 * PlPlotUtil::LINE_SPACE_TITLE + 0.25);

			// Reserve space for ticks

			if (pAxis->_tick._position == Tick::TickPosition::OUTWARDS)
			{

				double tickSize = getHorizontalTickLength(pAxis.get(), legendCharSizePanel.second);
				rightSpace += tickSize;

				if (nbAxesBySide[PlotCommon::Position::POS_LEFT] == 0)

					// add space for oposite axis

					leftSpace += tickSize;

			}

			// Reserve space for legend
			if ((pAxis->_showLegend == true) && (nbLegendRows != 0))
			{

				rightSpace += PlPlotUtil::LINE_SPACE_TITLE * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize);

				pAxis->setLegendOffset(rightSpace + 0.5 * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize));

				rightSpace += (nbLegendRows + PlPlotUtil::LINE_SPACE_TITLE * (nbLegendRows + 1)) * legendCharSizePanel.second * std::get<1>(pageSize) / std::get<0>(pageSize);

			}

			break;
		case PlotCommon::Position::POS_CENTER:
		default:
			LOG4CXX_WARN(gLogger, "PanelPlotOutput::drawPlotArea: Unrecognized position for axis '" << pAxis->_position << "'");

		}

	}

	void PanelPlotOutput::reserveSpaceForTextLegend(boost::shared_ptr<TextLegendProperties> &pTextLegendProp, double titleHeight, double &topSpace, double &bottomSpace, double &leftSpace, double &rightSpace)
	{
		int textLegendLinesNb = pTextLegendProp->getTextLinesNb();

		if (textLegendLinesNb == 0)
			return;

		PlPlotUtil::setPlFont(pTextLegendProp->getFont());
		CharSize lCharSizeLegend = PlPlotUtil::getCharacterSizeInPlPage(_panel->_page);

		std::tuple<float, float> pageSize = _panel->_page->getSizeInMm();

		switch (pTextLegendProp->getPosition())
		{
		case TextLegendPosition::POS_LEFT:
			pTextLegendProp->setOffset(leftSpace);

			leftSpace += (textLegendLinesNb + PlPlotUtil::LINE_SPACE_TITLE * (textLegendLinesNb + 1)) * lCharSizeLegend.second * std::get<1>(pageSize) / std::get<0>(pageSize);
			break;

		case TextLegendPosition::POS_RIGHT:
			pTextLegendProp->setOffset(rightSpace);

			rightSpace += (textLegendLinesNb + PlPlotUtil::LINE_SPACE_TITLE * (textLegendLinesNb + 1)) * lCharSizeLegend.second * std::get<1>(pageSize) / std::get<0>(pageSize);
			break;

		case TextLegendPosition::POS_TOP:

			if (_panel->_titlePosition == PlotCommon::Position::POS_TOP)

				pTextLegendProp->setOffset(topSpace - titleHeight);

			else

				pTextLegendProp->setOffset(topSpace);

			topSpace += (textLegendLinesNb + PlPlotUtil::LINE_SPACE_TITLE * (textLegendLinesNb + 1)) * lCharSizeLegend.second;
			break;

		case TextLegendPosition::POS_BOTTOM:

			if (_panel->_titlePosition == PlotCommon::Position::POS_BOTTOM)

				pTextLegendProp->setOffset(bottomSpace - titleHeight);

			else

				pTextLegendProp->setOffset(bottomSpace);

			bottomSpace += (textLegendLinesNb + PlPlotUtil::LINE_SPACE_TITLE * (textLegendLinesNb + 1)) * lCharSizeLegend.second;
			break;

		}

	}

	/**
	 * @brief Compute panel XY ratio used for angular conversions
	 */
	void PanelPlotOutput::computePanelPlotXYRatio(void)
	{
		// panel plot XY ratio = page ratio * plot area bound size ratio
		_panelPlotXYRatio = (std::get<0>(_panel->_page->getSize()) / std::get<1>(_panel->_page->getSize())) * (_plotAreaBounds._width / _plotAreaBounds._height);
	}

	/**
	 * @brief Draw legend for each axis.
	 */
	void PanelPlotOutput::drawLegends(boost::shared_ptr<Axis> &pAxis, PlWindow &pPlWindow, Bounds &pPlotAreaSize)
	{
		LOG4CXX_DEBUG(gLogger, "Drawing legend for axis " << pAxis->_id << " : " << pAxis->_legend.getText());

		// Set legend font
		Font legendFont(pAxis->getLegendFont(this->_panel.get()));
		PlPlotUtil::setPlFont(legendFont);

		// Get legend row info
		std::list<std::pair<std::string, Color>> lines = pAxis->_legend.getLines();

		// Check if there is something to draw !
		if ((pAxis->_visible == true) &&
			(pAxis->_showLegend == true) &&
			(lines.size() != 0))
		{

			Color lInitialColor;
			// If legend has not it's own color set axis color.
			if ((pAxis->_legend.getColor()._colorIndex == -1) && ((pAxis->_legend.getColor()._red == -1) && (pAxis->_legend.getColor()._green == -1) && (pAxis->_legend.getColor()._blue == -1)))
			{
				lInitialColor = changeColor(_pls, pAxis->_color,
											_panel->_page->_mode);
			}
			else
			{
				Color legendColor = pAxis->_legend.getColor();
				lInitialColor = changeColor(_pls, legendColor,
											_panel->_page->_mode);
			}

			// Init position
			double lPosition = PlPlotUtil::LINE_SPACE_TITLE;
			unsigned int lineIndex = 0;

			// Depending on the way to draw legend, for BOTTOM position we have to draw from first legend line to last.
			switch (pAxis->_position)
			{
			case PlotCommon::Position::POS_BOTTOM:

				_pls->vpor(pPlotAreaSize._x,
						   pPlotAreaSize._x + pPlotAreaSize._width,
						   pPlotAreaSize._y - pAxis->getLegendOffset(),
						   pPlotAreaSize._y - pAxis->getLegendOffset() + pPlotAreaSize._height);

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw lines, beginning by the first one
				for (auto line : lines)

				{

					std::string lineToDraw = line.first;
					if (lineIndex == lines.size() - 1)

					{

						// add unit if defined
						if (!pAxis->getAxisUnits().empty())
						{
							lineToDraw += " (";
							lineToDraw += pAxis->getAxisUnits();
							lineToDraw += ")";
						}

					}

					Color lSavedColor;
					if (line.second.isSet())
					{
						lSavedColor = changeColor(_pls, line.second, _panel->_page->_mode);
					}
					_pls->mtex(getPlSide(pAxis->_position).c_str(), lPosition, 0.5, 0.5, lineToDraw.c_str());
					lPosition += (1 + PlPlotUtil::LINE_SPACE_TITLE);
					if (line.second.isSet())
					{
						restoreColor(_pls, lSavedColor, _panel->_page->_mode);
					}
					++lineIndex;

				}

				break;

			case PlotCommon::Position::POS_TOP:
				_pls->vpor(pPlotAreaSize._x,
						   pPlotAreaSize._x + pPlotAreaSize._width,
						   pPlotAreaSize._y + pAxis->getLegendOffset(),
						   pPlotAreaSize._y + pAxis->getLegendOffset() + pPlotAreaSize._height);

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw lines, beginning by the last one
				for (auto line : boost::adaptors::reverse(lines))

				{

					std::string lineToDraw = line.first;
					if (lineIndex == lines.size() - 1)

					{

						// add unit if defined
						if (!pAxis->getAxisUnits().empty())
						{
							lineToDraw += " (";
							lineToDraw += pAxis->getAxisUnits();
							lineToDraw += ")";
						}

					}

					Color lSavedColor;
					if (line.second.isSet())
					{
						lSavedColor = changeColor(_pls, line.second, _panel->_page->_mode);
					}
					_pls->mtex(getPlSide(pAxis->_position).c_str(), lPosition, 0.5, 0.5, lineToDraw.c_str());
					lPosition += (1 + PlPlotUtil::LINE_SPACE_TITLE);
					if (line.second.isSet())
					{
						restoreColor(_pls, lSavedColor, _panel->_page->_mode);
					}
					++lineIndex;

				}

				break;

			case PlotCommon::Position::POS_RIGHT:

				_pls->vpor(pPlotAreaSize._x,
						   pPlotAreaSize._x + pAxis->getLegendOffset() + pPlotAreaSize._width,
						   pPlotAreaSize._y,
						   pPlotAreaSize._y + pPlotAreaSize._height);

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw lines, beginning by the first one
				for (auto line : lines)

				{

					std::string lineToDraw = line.first;
					if (lineIndex == lines.size() - 1)

					{

						// add unit if defined
						if (!pAxis->getAxisUnits().empty())
						{
							lineToDraw += " (";
							lineToDraw += pAxis->getAxisUnits();
							lineToDraw += ")";
						}

					}

					Color lSavedColor;
					if (line.second.isSet())
					{
						lSavedColor = changeColor(_pls, line.second, _panel->_page->_mode);
					}
					_pls->mtex(getPlSide(pAxis->_position).c_str(), lPosition, 0.5, 0.5, lineToDraw.c_str());
					lPosition += (1 + PlPlotUtil::LINE_SPACE_TITLE);
					if (line.second.isSet())
					{
						restoreColor(_pls, lSavedColor, _panel->_page->_mode);
					}
					++lineIndex;

				}

				break;

			case PlotCommon::Position::POS_LEFT:

				_pls->vpor(pPlotAreaSize._x - pAxis->getLegendOffset(),
						   pPlotAreaSize._x + pPlotAreaSize._width,
						   pPlotAreaSize._y,
						   pPlotAreaSize._y + pPlotAreaSize._height);

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw lines, beginning by the last one
				for (auto line : boost::adaptors::reverse(lines))

				{

					std::string lineToDraw = line.first;
					if (lineIndex == lines.size() - 1)

					{

						// add unit if defined
						if (!pAxis->getAxisUnits().empty())
						{
							lineToDraw += " (";
							lineToDraw += pAxis->getAxisUnits();
							lineToDraw += ")";
						}

					}

					Color lSavedColor;
					if (line.second.isSet())
					{
						lSavedColor = changeColor(_pls, line.second, _panel->_page->_mode);
					}
					_pls->mtex(getPlSide(pAxis->_position).c_str(), lPosition, 0.5, 0.5, lineToDraw.c_str());
					lPosition += (1 + PlPlotUtil::LINE_SPACE_TITLE);
					if (line.second.isSet())
					{
						restoreColor(_pls, lSavedColor, _panel->_page->_mode);
					}
					++lineIndex;

				}

				break;

			case PlotCommon::Position::POS_CENTER:
			default:
				LOG4CXX_WARN(gLogger, "PanelPlotOutput::drawPlotArea: Unrecognized position for axis '" << pAxis->_position << "'");
			}

			_pls->vpor(pPlotAreaSize._x,
					   pPlotAreaSize._x + pPlotAreaSize._width,
					   pPlotAreaSize._y,
					   pPlotAreaSize._y + pPlotAreaSize._height);

			_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
					   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

			// Restore initial color.
			restoreColor(_pls, lInitialColor, _panel->_page->_mode);
		}

	}

	void PanelPlotOutput::drawAxis(boost::shared_ptr<Axis> pAxis, TickConf &pTickConf,
								   std::string pXAxisOptions, std::string pYAxisOptions)
	{
		Color lInitialColor = changeColor(_pls, pAxis->_color, _panel->_page->_mode);

		// Set axis thickness.
		_pls->width(pAxis->_thickness);

		// Set tick (major and minor) length factor
		PLFLT lTickLenFact = DEFAULT_TICK_LENGTH_FACTOR;
		if (!isnan(pAxis->_tick._lengthFactor))
		{
			lTickLenFact = pAxis->_tick._lengthFactor;
		}
		else
		{
			// Nothing to do.
		}
		// 0 => keep tick height in millimeters.
		_pls->smaj(0, lTickLenFact);
		_pls->smin(0, lTickLenFact);

		// if options contains "o" character we need to set label function
		if ((pXAxisOptions.find("o") != std::string::npos) || (pYAxisOptions.find("o") != std::string::npos))
		{
			_pls->slabelfunc(pAxis->_labelGenerator->_function, pAxis->_labelGenerator->_data);
		}

		// Set line style (force to be plain)
		_pls->lsty(static_cast<int>(getPlLineStyle(LineStyle::PLAIN)));

		// Set font to draw axes.
		Font axisFont(pAxis->getLegendFont(this->_panel.get()));
		axisFont.setStyle(Font::Style::NORMAL);
		axisFont.setWeight(Font::Weight::NORMAL);
		PlPlotUtil::setPlFont(axisFont);

		size_t lPos;

		double xMajorTickSpace = std::get<0>(pTickConf);
		double xMinorTickNumber = std::get<1>(pTickConf);
		double yMajorTickSpace = std::get<2>(pTickConf);
		double yMinorTickNumber = std::get<3>(pTickConf);

		// if options contains "a" character we need to draw origin separately.
		if ((lPos = pXAxisOptions.find("a")) != std::string::npos)
		{
			pXAxisOptions.replace(lPos, 1, "");
			_pls->box("a", xMajorTickSpace, xMinorTickNumber, "", yMajorTickSpace, yMinorTickNumber);
		}
		else if ((lPos = pYAxisOptions.find("a")) != std::string::npos)
		{
			pYAxisOptions.replace(lPos, 1, "");
			_pls->box("", xMajorTickSpace, xMinorTickNumber, "a", yMajorTickSpace, yMinorTickNumber);
		}
		else
		{
			// Nothing to do.
		}

		// Draw axis.
		_pls->box(pXAxisOptions.c_str(), xMajorTickSpace, xMinorTickNumber,
				  pYAxisOptions.c_str(), yMajorTickSpace, yMinorTickNumber);

		// Restore initial color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);

		// Set axis as drawn.
		pAxis->_drawn = true;
	}

	void PanelPlotOutput::drawXAxis(boost::shared_ptr<Axis> pXAxis, PlWindow &pPlWindow, Bounds &pPlotAreaSize, TickConf &pTickConf)
	{
		// Set option to draw origin.
		std::string lAxisOption = pXAxis->getPlotOpt();
		std::string lTmpAxisOption = "xi";

		// plplot doesn't provide solution to set space between tick and tick mark.
		// To do that we need to play with viewport position and size.
		// So axis will be drawn in two times:
		//		- first draw tick marks
		//		- second draw tick and edge
		// Custom space  between tick marks and tick is only done when tick length is greater than 0.75.
		// Get extra tick mark space (only if they are outwards)
		if (pXAxis->_tick._position == Tick::TickPosition::OUTWARDS)
		{
			float lTickLengthFactor = 0;
			if ((!isnan(pXAxis->_tick._lengthFactor)) && (pXAxis->_tick._lengthFactor > HORIZONTAL_TICK_LENGTH_LIMIT))
			{
				lTickLengthFactor = pXAxis->_tick._lengthFactor;
			}
			else if ((isnan(pXAxis->_tick._lengthFactor)) && (DEFAULT_TICK_LENGTH_FACTOR > HORIZONTAL_TICK_LENGTH_LIMIT))
			{
				lTickLengthFactor = DEFAULT_TICK_LENGTH_FACTOR;
			}

			if (lTickLengthFactor != 0)
			{
				// 1 character size is equal to 0.75 tick length.
				PlPlotUtil::setPlFont(_panel->getFont());
				float lTickMarkSpace = (lTickLengthFactor - HORIZONTAL_TICK_LENGTH_LIMIT) * (PlPlotUtil::getCharacterSizeInPlPage(_panel->_page).second) / (DEFAULT_TICK_LENGTH_FACTOR);

				size_t lPos;

				if ((lPos = lAxisOption.find("m")) != std::string::npos)
				{
					lTmpAxisOption += "m";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("n")) != std::string::npos)
				{
					lTmpAxisOption += "n";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("o")) != std::string::npos)
				{
					lTmpAxisOption += "o";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("d")) != std::string::npos)
				{
					lTmpAxisOption += "d";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("f")) != std::string::npos)
				{
					lTmpAxisOption += "f";
					lAxisOption.replace(lPos, 1, "");
				}

				if (pXAxis->_position == PlotCommon::Position::POS_BOTTOM)
				{
					_pls->vpor(pPlotAreaSize._x,
							   pPlotAreaSize._x + pPlotAreaSize._width,
							   pPlotAreaSize._y - lTickMarkSpace,
							   pPlotAreaSize._y + pPlotAreaSize._height);
				}
				else
				{
					_pls->vpor(pPlotAreaSize._x,
							   pPlotAreaSize._x + pPlotAreaSize._width,
							   pPlotAreaSize._y,
							   pPlotAreaSize._y + pPlotAreaSize._height + lTickMarkSpace);
				}

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw tick mark.
				drawAxis(pXAxis, pTickConf, lTmpAxisOption, "");

			}

		}
		// Restore default plot area
		_pls->vpor(pPlotAreaSize._x,
				   pPlotAreaSize._x + pPlotAreaSize._width,
				   pPlotAreaSize._y,
				   pPlotAreaSize._y + pPlotAreaSize._height);
		// Set window.
		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
				   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		// Check if origin must be drawn.
		if (std::get<0>(pPlWindow) != 0 && std::get<1>(pPlWindow) && pXAxis->_origin == 0)
		{
			lAxisOption += "a";

		}

		// Check if opposite plot area side need to be drawn
		lAxisOption += drawOppositeSide(pXAxis);

		// Draw rest of axis.
		drawAxis(pXAxis, pTickConf, lAxisOption, "");

	}

	void PanelPlotOutput::drawYAxis(boost::shared_ptr<Axis> pYAxis, PlWindow &pPlWindow, Bounds &pPlotAreaSize, TickConf &pTickConf)
	{

		// Get axis offset in case of multi-axes
		double axisOffset = pYAxis->getAxisOffset();

		// Set option to draw origin ("v" is set to have numeric labels parallel to X axis).
		std::string lAxisOption = pYAxis->getPlotOpt();
		std::string lTmpAxisOption = "xiv";

		// plplot doesn't provide solution to set space between tick and tick mark.
		// To do that we need to play with viewport position and size.
		// So axis will be drawn in two times:
		//		- first draw tick marks
		//		- second draw tick and edge
		// Custom space  between tick marks and tick is only done when tick length is greater than 0.5.
		// Get extra tick mark space (only if they are outwards)

		pPlotAreaSize._width = pPlotAreaSize._width;

		if (pYAxis->_tick._position == Tick::TickPosition::OUTWARDS)
		{
			float lTickLengthFactor = 0;
			if ((!isnan(pYAxis->_tick._lengthFactor)) && (pYAxis->_tick._lengthFactor > VERTICAL_TICK_LENGTH_LIMIT))
			{
				lTickLengthFactor = pYAxis->_tick._lengthFactor;
			}
			else if ((isnan(pYAxis->_tick._lengthFactor)) && (DEFAULT_TICK_LENGTH_FACTOR > VERTICAL_TICK_LENGTH_LIMIT))
			{
				lTickLengthFactor = DEFAULT_TICK_LENGTH_FACTOR;
			}

			if (lTickLengthFactor != 0)
			{
				// 1 character size is equal to 0.75 tick length.
				PlPlotUtil::setPlFont(_panel->getFont());
				double lTickMarkSpace = (lTickLengthFactor - VERTICAL_TICK_LENGTH_LIMIT) * (PlPlotUtil::getCharacterSizeInPlPage(_panel->_page).second) / (DEFAULT_TICK_LENGTH_FACTOR);

				size_t lPos;

				if ((lPos = lAxisOption.find("m")) != std::string::npos)
				{
					lTmpAxisOption += "m";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("n")) != std::string::npos)
				{
					lTmpAxisOption += "n";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("o")) != std::string::npos)
				{
					lTmpAxisOption += "o";
					lAxisOption.replace(lPos, 1, "");
				}
				if ((lPos = lAxisOption.find("f")) != std::string::npos)
				{
					lTmpAxisOption += "f";
					lAxisOption.replace(lPos, 1, "");
				}
				if (lAxisOption.find("l") != std::string::npos)
				{
					// Do not remove on original axis option
					// because option is needed to draw logarithmic tick.
					lTmpAxisOption += "l";
				}

				// Set plot area used to draw tick mark
				if (pYAxis->_position == PlotCommon::Position::POS_LEFT)
				{
					_pls->vpor(pPlotAreaSize._x - lTickMarkSpace - axisOffset,
							   pPlotAreaSize._x + pPlotAreaSize._width,
							   pPlotAreaSize._y,
							   pPlotAreaSize._y + pPlotAreaSize._height);
				}
				else
				{
					_pls->vpor(pPlotAreaSize._x,
							   pPlotAreaSize._x + pPlotAreaSize._width + lTickMarkSpace + axisOffset,
							   pPlotAreaSize._y,
							   pPlotAreaSize._y + pPlotAreaSize._height);
				}

				_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
						   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

				// Draw tick mark.
				drawAxis(pYAxis, pTickConf, "", lTmpAxisOption);

			}

		}

		// Set plot area used to draw tick
		if (pYAxis->_position == PlotCommon::Position::POS_LEFT)
		{
			_pls->vpor(pPlotAreaSize._x - axisOffset,
					   pPlotAreaSize._x + pPlotAreaSize._width,
					   pPlotAreaSize._y,
					   pPlotAreaSize._y + pPlotAreaSize._height);
		}
		else
		{
			_pls->vpor(pPlotAreaSize._x,
					   pPlotAreaSize._x + pPlotAreaSize._width + axisOffset,
					   pPlotAreaSize._y,
					   pPlotAreaSize._y + pPlotAreaSize._height);
		}

		// Set window.
		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
				   std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		// Check if origin must be drawn.
		if (std::get<0>(pPlWindow) != 0 && std::get<1>(pPlWindow) && pYAxis->_origin == 0)
		{
			lAxisOption += "a";
		}

		// Check if opposite plot area side need to be drawn
		lAxisOption += drawOppositeSide(pYAxis);

		// Draw rest of axis.
		drawAxis(pYAxis, pTickConf, "", lAxisOption);

		// Restore default plot area
		_pls->vpor(pPlotAreaSize._x,
				   pPlotAreaSize._x + pPlotAreaSize._width,
				   pPlotAreaSize._y,
				   pPlotAreaSize._y + pPlotAreaSize._height);

		// Set window.
		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow),
				   std::get<2>(pPlWindow), std::get<3>(pPlWindow));
	}

#define COLORBAR_X_OFFSET 0.01
#define COLORBAR_BODY_WIDTH 0.0375

	double PanelPlotOutput::estimateZAxisWidth(boost::shared_ptr<Axis> pZAxis)
	{
		double axisWidth = (COLORBAR_X_OFFSET + COLORBAR_BODY_WIDTH) * _panel->_bounds._width;

		PlPlotUtil::setPlFont(_panel->getFont());
		CharSize lCharSize = PlPlotUtil::getCharacterSizeInPlPage(_panel->_page);

		int nbLineLegend = pZAxis->_legend.getNbLines();

		if ((pZAxis->_showLegend == true) && (nbLineLegend != 0))
		{
			if (_panel->_page->_orientation == PlotCommon::Orientation::LANDSCAPE)
				axisWidth += lCharSize.second * (2 * nbLineLegend + 1);
			else
				axisWidth += lCharSize.first * (2 * nbLineLegend + 1);
		}

		return axisWidth;
	}

	void PanelPlotOutput::drawZAxis(boost::shared_ptr<Axis> pZAxis, PlWindow &pPlWindow, Bounds &pPlotAreaSize, TickConf & /*pTickConf*/)
	{
		Color lInitialColor;
		_pls->gcol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);

		// Set axis thickness.
		_pls->width(pZAxis->_thickness);

		// Set line style (force to be plain)
		_pls->lsty(static_cast<int>(getPlLineStyle(LineStyle::PLAIN)));

		// Set font to draw axes.
		PlPlotUtil::setPlFont(_panel->getFont());

		std::string lAxisOption = pZAxis->getPlotOpt();
		std::string lAxisLegend = "";
		std::list<std::pair<std::string, Color>> lines = pZAxis->_legend.getLines();
		for (auto line : lines)
		{
			if (line.first.empty())
			{
				continue;
			}
			if (!lAxisLegend.empty())
			{
				lAxisLegend += "\n";
			}
			lAxisLegend += line.first;

		}

		PLFLT colorbar_width, colorbar_height;
		const int cont_color = 0;
		const PLFLT cont_width = 0.0;

		// set legend
		const PLINT n_labels = (lAxisLegend.empty()) ? 0 : 1;
		std::string label = lAxisLegend;

		const char *labels[n_labels];
		if (!lAxisLegend.empty())
			labels[0] = label.c_str();

		// set axis options
		const PLINT n_axis_opts = 1;
		const char *axis_opts[n_axis_opts] = {

			lAxisOption.c_str(),

		};

		PLFLT axis_ticks[n_axis_opts] = {
			0};
		PLINT axis_subticks[n_axis_opts] = {
			0};

		// if options contains "o" character we need to set label function
		if (lAxisOption.find("o") != std::string::npos)
		{
			_pls->slabelfunc(pZAxis->_labelGenerator->_function, pZAxis->_labelGenerator->_data);
		}

		// set nb og colors
		const int nbCol = 20;

		PLINT num_values[1] = {
			nbCol + 1};

		Range r = pZAxis->getRange();

		PLFLT *shedge = new PLFLT[nbCol + 1];

		ShadesTools::computeEdgesLevels(r, nbCol + 1, shedge);

		PLFLT *values[1];
		values[0] = shedge;

		// set color map
		_pls->spal1(

			ColormapManager::getInstance().getColorAxis(pZAxis->_color._colorMapIndex).c_str(), true);

		// set color bar and legend position
		PLINT position = PL_POSITION_OUTSIDE | PL_POSITION_VIEWPORT;
		PLINT label_opts[1];

		switch (pZAxis->_position)
		{
		case PlotCommon::Position::POS_LEFT:

			position |= PL_POSITION_LEFT;
			label_opts[0] = PL_COLORBAR_LABEL_LEFT;

			_pls->vpor(pPlotAreaSize._x - pZAxis->getAxisOffset(), pPlotAreaSize._x + pPlotAreaSize._width, pPlotAreaSize._y, pPlotAreaSize._y + pPlotAreaSize._height);

			break;

		case PlotCommon::Position::POS_RIGHT:

			position |= PL_POSITION_RIGHT;
			label_opts[0] = PL_COLORBAR_LABEL_RIGHT;

			_pls->vpor(pPlotAreaSize._x, pPlotAreaSize._x + pPlotAreaSize._width + pZAxis->getAxisOffset(), pPlotAreaSize._y, pPlotAreaSize._y + pPlotAreaSize._height);

			break;
		default:
		{
			std::stringstream lError;
			lError << "PanelPlotOutput::drawZAxis : Bad Z axis position";
			BOOST_THROW_EXCEPTION(

				PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
		}

		}

		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow), std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		_pls->colorbar(

			&colorbar_width,
			&colorbar_height,

			PL_COLORBAR_GRADIENT, // PL_COLORBAR_SHADE,
			position,
			0.0, // COLORBAR_X_OFFSET,
			0.0,
			COLORBAR_BODY_WIDTH,
			0.875,
			0, /*bg_color*/
			1,
			1,
			0.0,
			0.0,
			cont_color,
			cont_width,
			n_labels,
			label_opts,
			labels,
			n_axis_opts,
			axis_opts,
			axis_ticks,
			axis_subticks,
			num_values,
			(const PLFLT *const *)values);

		// reset color map
		_pls->spal1(
			ColormapManager::getInstance().get(_panel->_page->_mode,
											   ColormapManager::DEFAULT_COLORMAP_1)
				.c_str(),
			true);

		_pls->scol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);

		delete[] shedge;

		// Restore initial color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);

		// Restore default plot area
		_pls->vpor(pPlotAreaSize._x,
				   pPlotAreaSize._x + pPlotAreaSize._width,
				   pPlotAreaSize._y,
				   pPlotAreaSize._y + pPlotAreaSize._height);

		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow), std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		// Set axis as drawn.
		pZAxis->_drawn = true;

	}

	Range PanelPlotOutput::getXAxisRange(SeriesProperties &pSeries, boost::shared_ptr<Axis> pAxis)
	{

		if (pSeries.hasXAxis() && pAxis.get() == nullptr)
		{
			std::stringstream lError;
			lError << "PanelPlotOutput::drawSeries"
				   << ": X axis with id '"
				   << pSeries.getXAxisId() << "' not found.";
			BOOST_THROW_EXCEPTION(

				PanelPlotOutputException() << AMDA::ex_msg(lError.str()));

		}
		else if (pSeries.hasXAxis())
		{
			// fill X range (plplot window).
			return (pAxis->getRange());
		}
		return Range();

	}

	Range PanelPlotOutput::getYAxisRange(SeriesProperties &pSeries, boost::shared_ptr<Axis> pAxis)
	{

		if (pSeries.hasYAxis() && pAxis.get() == nullptr)
		{
			std::stringstream lError;
			lError << "PanelPlotOutput::drawSeries"
				   << ": Y axis with id '"
				   << pSeries.getYAxisId() << "' not found.";
			BOOST_THROW_EXCEPTION(

				PanelPlotOutputException() << AMDA::ex_msg(lError.str()));

		}
		else if (pSeries.hasYAxis())
		{
			// fill Y range (plplot window).
			return (pAxis->getRange());
		}
		return Range();

	}

	Range PanelPlotOutput::getZAxisRange(SeriesProperties &pSeries, boost::shared_ptr<Axis> pAxis)
	{

		if (pSeries.hasZAxis() && pAxis.get() == nullptr)
		{
			std::stringstream lError;
			lError << "PanelPlotOutput::drawSeries"
				   << ": Z axis with id '"
				   << pSeries.getYAxisId() << "' not found.";
			BOOST_THROW_EXCEPTION(
				PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
		}
		else if (pSeries.hasZAxis())
		{
			// fill Z range (plplot window).
			return (pAxis->getRange());
		}
		return Range();
	}

	/**
	 * Convert an X axis string value to a double X value
	 */
	double PanelPlotOutput::convertXAxisValue(const std::string &value)
	{
		return std::stod(value);
	}

	/**
	 * Convert an Y axis string value to a double Y value
	 */
	double PanelPlotOutput::convertYAxisValue(const std::string &value)
	{
		return std::stod(value);
	}

	/**
	 * Get colored value associated to a data value. Return false if the value is filtered.
	 */
	bool PanelPlotOutput::getColoredValue(double value, double filterMin, double filterMax, bool useLog0AsMin, PLFLT &col)
	{
		boost::shared_ptr<ColorAxis> lZAxis = _panel->getColorAxis();

		if (lZAxis == nullptr)
			return false;

		bool filterMinMax = (isNAN(filterMin) == false) || (isNAN(filterMax) == false);

		Range r = lZAxis->getRange();

		if (isnan(value))
			return false;

		if ((filterMinMax == true) && ((value < filterMin) || (value > filterMax)))

			return false;

		double correctedValue = value;
		if (lZAxis->_scale == Axis::Scale::LOGARITHMIC)
		{
			if (correctedValue <= 0)
			{
				if (useLog0AsMin)
				{
					col = 0;
					return true;
				}
				return false;
			}

			correctedValue = log10(correctedValue);
		}

		if (!lZAxis->_reverse)
			col = (correctedValue - r.getMin()) / (r.getMax() - r.getMin());
		else
			col = (correctedValue - r.getMax()) / (r.getMin() - r.getMax());

		return true;
	}

	/**
	 * Draw list of symbols
	 */
	void PanelPlotOutput::drawSymbols(SymbolType pType, int pSize, double pFactor, Color pColor,
									  int pNbData, double *pXData, double *pYData, double *pZData, double filterZMin, double filterZMax)
	{
		if (pType == SymbolType::NO)
			return;

		Color lInitialColor;

		// Set color.
		lInitialColor = changeColor(_pls, pColor, _panel->_page->_mode);

		PlPlotUtil::setPlFont(_panel->_page->getFont());

		// Set size.
		_pls->ssym(pSize, pFactor);

		// Get colored axis
		boost::shared_ptr<ColorAxis> lZAxis = _panel->getColorAxis();

		// draw symbols
		if ((pZData == NULL) || (lZAxis == nullptr))
			_pls->poin(pNbData, pXData, pYData, static_cast<int>(pType));
		else
		{
			// set color map
			_pls->spal1(
				ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);

			// get specific colors for min / max values
			Color minValColor = lZAxis->getMinValColor();
			Color maxValColor = lZAxis->getMaxValColor();

			PLFLT col;
			for (int i = 0; i < pNbData; ++i)
			{
				if (!getColoredValue(pZData[i], filterZMin, filterZMax, false, col))
					continue;

				if (col <= 0.)
				{
					if (minValColor.isSet())
					{
						restoreColor(_pls, minValColor, _panel->_page->_mode);
						_pls->poin(1, &pXData[i], &pYData[i], static_cast<int>(pType));
						_pls->spal1(ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);
					}
					else
					{
						_pls->col1(0);
						_pls->poin(1, &pXData[i], &pYData[i], static_cast<int>(pType));
					}
				}
				else if (col >= 1.)
				{
					if (maxValColor.isSet())
					{
						restoreColor(_pls, maxValColor, _panel->_page->_mode);
						_pls->poin(1, &pXData[i], &pYData[i], static_cast<int>(pType));
						_pls->spal1(ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);
					}
					else
					{
						_pls->col1(1);
						_pls->poin(1, &pXData[i], &pYData[i], static_cast<int>(pType));
					}
				}
				else
				{
					_pls->col1(col);

					_pls->poin(1, &pXData[i], &pYData[i], static_cast<int>(pType));

				}
			}
		}

		// Restore color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);

	}

	/**
	 * Draw list of lines
	 */
	void PanelPlotOutput::drawLines(LineType pType, LineStyle pStyle, int pWidth, Color &pColor,
									int pNbData, double *pXData, double *pYData, double *pZData, double filterZMin, double filterZMax)
	{
		if (pType == LineType::EMPTY)
			return;

		if (pType != LineType::LINE)
		{
			BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg("HISTO line type can't be used in time plot. Use LINE or EMPTY type"));
		}

		Color lInitialColor;

		// Set color.
		lInitialColor = changeColor(_pls, pColor, _panel->_page->_mode);

		// Set line type.
		_pls->lsty(static_cast<int>(getPlLineStyle(pStyle)));

		// Set line thickness.
		_pls->width(pWidth);

		// Get colored axis
		boost::shared_ptr<ColorAxis> lZAxis = _panel->getColorAxis();

		// draw lines.
		if ((pZData == NULL) || (lZAxis == nullptr))

		{

			_pls->line(pNbData, pXData, pYData);
		}
		else
		{
			// set color map
			_pls->spal1(
				ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);

			// get specific colors for min / max values
			Color minValColor = lZAxis->getMinValColor();
			Color maxValColor = lZAxis->getMaxValColor();

			PLFLT col;
			for (int i = 0; i < pNbData - 1; ++i)
			{
				if (!getColoredValue(pZData[i], filterZMin, filterZMax, false, col))
					continue;

				if (col <= 0.)
				{
					if (minValColor.isSet())
					{
						restoreColor(_pls, minValColor, _panel->_page->_mode);
						_pls->line(2, &pXData[i], &pYData[i]);
						_pls->spal1(ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);
					}
					else
					{
						_pls->col1(0);
						_pls->line(2, &pXData[i], &pYData[i]);
					}
				}
				else if (col >= 1.)
				{
					if (maxValColor.isSet())
					{
						restoreColor(_pls, maxValColor, _panel->_page->_mode);
						_pls->line(2, &pXData[i], &pYData[i]);
						_pls->spal1(ColormapManager::getInstance().getColorAxis(lZAxis->_color._colorMapIndex).c_str(), true);
					}
					else
					{
						_pls->col1(1);
						_pls->line(2, &pXData[i], &pYData[i]);
					}
				}
				else
				{
					_pls->col1(col);

					_pls->line(2, &pXData[i], &pYData[i]);

				}
			}
		}

		// Restore color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);
	}

	/**
	 * Draw a rectangle
	 */
	void PanelPlotOutput::drawRectangle(double xmin, double xmax, double ymin, double ymax, Color &color, double alpha)
	{
		if (!color.isSet())
		{
			return;
		}

		Color lInitialColor;

		// Set color.
		lInitialColor = changeColor(_pls, color, _panel->_page->_mode);

		// Draw rectangle
		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;

		// Fill rectangle
		PLINT icol = 0;
		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 color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);
	}

	/*
	 * @brief Draw a matrix
	 */
	void PanelPlotOutput::drawMatrix(MatrixGrid &matrixGrid, double minDataVal, double maxDataVal,
									 Color minValColor, Color maxValColor, int colorMapIndex, bool useLog0AsMin)

	{

		// set color map
		_pls->spal1(
			ColormapManager::getInstance().getColorAxis(colorMapIndex).c_str(), true);

		Color lInitialColor;
		_pls->gcol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);

		// plot matrix
		PLFLT x[4], y[4];
		PLFLT col;

		for (auto part : matrixGrid)

		{

			x[0] = part.x[0];
			x[1] = part.x[1];
			x[2] = x[1];
			x[3] = x[0];

			y[0] = part.y[0];
			y[1] = y[0];
			y[2] = part.y[1];
			y[3] = y[2];

			if (isNAN(part.value))

				continue;

			if (!part.isColorIndex)

			{

				if (!getColoredValue(part.value, minDataVal, maxDataVal, useLog0AsMin, col))
					continue;

			}
			else
			{

				Color dataValueColor(colorMapIndex, (int)part.value);
				restoreColor(_pls, dataValueColor, _panel->_page->_mode);

				_pls->fill(4, x, y);

				_pls->spal1(ColormapManager::getInstance().getColorAxis(colorMapIndex).c_str(), true);
				continue;

			}

			if (col <= 0.)

			{

				if (minValColor.isSet())
				{
					restoreColor(_pls, minValColor, _panel->_page->_mode);
					_pls->fill(4, x, y);
					_pls->spal1(ColormapManager::getInstance().getColorAxis(colorMapIndex).c_str(), true);
				}
				else
				{
					_pls->col1(0);
					_pls->fill(4, x, y);
				}
			}
			else if (col >= 1.)
			{
				if (maxValColor.isSet())
				{
					restoreColor(_pls, maxValColor, _panel->_page->_mode);
					_pls->fill(4, x, y);
					_pls->spal1(ColormapManager::getInstance().getColorAxis(colorMapIndex).c_str(), true);
				}
				else
				{
					_pls->col1(1);
					_pls->fill(4, x, y);
				}

			}
			else
			{

				_pls->col1(col);

				_pls->fill(4, x, y);
			}
		}

		// restore to initial color context
		_pls->spal1(

			ColormapManager::getInstance().get(_panel->_page->_mode,

											   ColormapManager::DEFAULT_COLORMAP_1)
				.c_str(),
			true);
		_pls->scol0(0, lInitialColor._red, lInitialColor._green, lInitialColor._blue);

		// Restore color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);
	}

	/**
	 * Draw errors segments
	 */
	void PanelPlotOutput::drawYErrors(
		LineType pType,
		LineStyle pStyle,
		int pWidth,
		Color &pColor,
		int pNbData,
		double *pXData,
		double *pYMinData,
		double *pYMaxData)

	{

		if (pType == LineType::EMPTY)
			return;

		if (pType != LineType::LINE)
		{
			BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg("HISTO line type can't be used in time plot. Use LINE or EMPTY type"));
		}

		Color lInitialColor;

		// Set color.
		lInitialColor = changeColor(_pls, pColor, _panel->_page->_mode);

		// Set line type.
		_pls->lsty(static_cast<int>(getPlLineStyle(pStyle)));

		// Set line thickness.
		_pls->width(pWidth);

		// Set the default tich with
		_pls->smin(0, 0.5);

		// Draw error bars
		_pls->erry(pNbData, pXData, pYMinData, pYMaxData);

		// Restore color.
		restoreColor(_pls, lInitialColor, _panel->_page->_mode);
	}

	/**
	 * Draws X constant lines linked to axis
	 */
	void PanelPlotOutput::drawXConstantLines(boost::shared_ptr<Axis> pAxis, PlWindow &pPlWindow)
	{
		double x[2], y[2];

		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow), std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		for (auto constantLine : pAxis->_constantLines)
		{
			if (constantLine->isDrawn())
				continue;
			x[0] = convertXAxisValue(constantLine->getValue());
			x[1] = convertXAxisValue(constantLine->getValue());
			y[0] = std::get<2>(pPlWindow);
			y[1] = std::get<3>(pPlWindow);

			if (pAxis->_scale == Axis::Scale::LOGARITHMIC)
			{
				x[0] = log10(x[0]);
				x[1] = log10(x[1]);
			}

			drawLines(

				LineType::LINE,
				constantLine->getStyle(),
				constantLine->getWidth(),
				constantLine->getColor(),
				2, x, y);

			constantLine->setDrawn(true);
		}

	}

	/**
	 * Draws Y constant lines linked to axis
	 */
	void PanelPlotOutput::drawYConstantLines(boost::shared_ptr<Axis> pAxis, PlWindow &pPlWindow)
	{
		double x[2], y[2];

		_pls->wind(std::get<0>(pPlWindow), std::get<1>(pPlWindow), std::get<2>(pPlWindow), std::get<3>(pPlWindow));

		for (auto constantLine : pAxis->_constantLines)
		{
			if (constantLine->isDrawn())
				continue;

			x[0] = std::get<0>(pPlWindow);
			x[1] = std::get<1>(pPlWindow);
			y[0] = convertYAxisValue(constantLine->getValue());
			y[1] = convertYAxisValue(constantLine->getValue());

			if (pAxis->_scale == Axis::Scale::LOGARITHMIC)
			{
				y[0] = log10(y[0]);
				y[1] = log10(y[1]);
			}

			drawLines(

				LineType::LINE,
				constantLine->getStyle(),
				constantLine->getWidth(),
				constantLine->getColor(),
				2, x, y);

			constantLine->setDrawn(true);
		}

	}

	/**
	 * Draws TextPlots
	 */
	void PanelPlotOutput::drawTextPlots(boost::shared_ptr<Axis> pXAxis, boost::shared_ptr<Axis> pYAxis, PlWindow &pPlWindow, const TextPlots &textPlots)
	{
		double x, y;
		double x1, x2, y1, y2;

		x1 = std::get<0>(pPlWindow);
		x2 = std::get<1>(pPlWindow);
		y1 = std::get<2>(pPlWindow);
		y2 = std::get<3>(pPlWindow);

		_pls->wind(x1, x2, y1, y2);

		for (auto textPlot : textPlots)
		{
			if (textPlot->isDrawn())
				continue;

			if (!textPlot->_xAxisId.empty() && (textPlot->_xAxisId.compare(pXAxis->_id) != 0))
				continue;

			if (!textPlot->_yAxisId.empty() && (textPlot->_yAxisId.compare(pYAxis->_id) != 0))
				continue;

			// Compute x y position for the text
			if (textPlot->_x.find("%") != std::string::npos)
			{
				// Remove % before conversion
				int pos = textPlot->_x.find("%");
				std::string xPos = textPlot->_x;
				xPos.erase(pos);
				// Compute x value as a percent of the x value
				x = x1 + (x2 - x1) * std::stod(xPos) / 100.0;
			}
			else
			{
				x = convertXAxisValue(textPlot->_x);
			}

			if (textPlot->_y.find("%") != std::string::npos)
			{
				// Remove % before conversion
				int pos = textPlot->_y.find("%");
				std::string yPos = textPlot->_y;
				yPos.erase(pos);
				// Compute x value as a percent of the x value
				y = y1 + (y2 - y1) * std::stod(yPos) / 100.0;
			}
			else
			{
				y = convertYAxisValue(textPlot->_y);
			}

			// Select font family, size, style and weight
			PlPlotUtil::setPlFont(textPlot->getFont());

			// Set color
			Color lInitialColor = changeColor(_pls, textPlot->_color, _panel->_page->_mode);

			// Compute dx & dy orientation
			double dx = cos(textPlot->_angle * M_PI / 180) * (x2 - x1) / 10.0;
			double dy = sin(textPlot->_angle * M_PI / 180) * (y2 - y1) / 10.0 * _panelPlotXYRatio;

			// Draw text
			_pls->ptex(x, y, dx, dy, textPlot->_align, textPlot->_text.c_str());

			// Restore initial color.
			restoreColor(_pls, lInitialColor, _panel->_page->_mode);

			textPlot->setDrawn(true);
		}

	}

	/*
	 * @brief Draw interval
	 */
	void PanelPlotOutput::drawSerieInterval(SeriesProperties &pSeries,
											double *xValues, double *yValues, double *timeValues,
											int nbValues, int intervalIndex)
	{
		LOG4CXX_DEBUG(gLogger, "PanelPlotOutput::drawSerieInterval");

		IntervalTickProperties itProps = pSeries.getIntervalTickProperties();

		// Draw Interval ticks if required !
		if (itProps.getMode() == IntervalTickMode::NONE)
			return;

		// Get X and Y axis.
		boost::shared_ptr<Axis> lXAxis(_panel->getAxis(pSeries.getXAxisId()));
		boost::shared_ptr<Axis> lYAxis(_panel->getAxis(pSeries.getYAxisId()));

		Range lXRange = getXAxisRange(pSeries, lXAxis);
		Range lYRange = getYAxisRange(pSeries, lYAxis);

		PlWindow lPlWindow = PlWindow(lXRange.getMin(), lXRange.getMax(), lYRange.getMin(), lYRange.getMax());

		// prepare data for plot
		double xData[2] = {NAN, NAN};
		double yData[2] = {NAN, NAN};
		double timeData[2] = {NAN, NAN};

		// skip NAN values
		for (int i = 0; i < nbValues; ++i)
			if (!isNAN(xValues[i]) && !isNAN(yValues[i]))
			{
				xData[0] = xValues[i];
				yData[0] = yValues[i];
				timeData[0] = timeValues[i];
				break;
			}

		for (int i = nbValues - 1; i >= 0; --i)
			if (!isNAN(xValues[i]) && !isNAN(yValues[i]))
			{
				xData[1] = xValues[i];
				yData[1] = yValues[i];
				timeData[1] = timeValues[i];
				break;
			}

		// draw symbols
		drawSymbols(
			itProps.getSymbol().getType(),
			itProps.getSymbol().getSize(), 1.,
			itProps.getSymbol().getColor(),
			2, (double *)&xData, (double *)&yData, NULL);

		if (itProps.getMode() == IntervalTickMode::SYMBOL_ONLY)
			return;

		// Add start interval info to a list of TextPlot
		TextPlots textPlots;

		TextPlot baseTextPlot;
		baseTextPlot._color = itProps.getColor();
		baseTextPlot.setFont(itProps.getFont());

		boost::shared_ptr<TextPlot> startTextPlot(new TextPlot(baseTextPlot));

		double xPos = (xData[0] - lXRange.getMin()) / (lXRange.getMax() - lXRange.getMin()) * 100;
		startTextPlot->_x = boost::lexical_cast<std::string>(xPos);
		startTextPlot->_x += "%";

		double yPos = (yData[0] - lYRange.getMin()) / (lYRange.getMax() - lYRange.getMin()) * 100 + 1.5;
		startTextPlot->_y = boost::lexical_cast<std::string>(yPos);
		startTextPlot->_y += "%";

		if (itProps.getMode() == IntervalTickMode::INTERVAL_INDEX)
		{
			startTextPlot->_text = "I";
			startTextPlot->_text += std::to_string(intervalIndex);
		}
		else
			startTextPlot->_text = AMDA::TimeUtil::formatTimeDateInIso(timeData[0]);

		textPlots.push_back(startTextPlot);