qt/widgets/canvas/Grid.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

This file is part of the TerraLib - a Framework for building GIS enabled applications.

TerraLib is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.

TerraLib is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with TerraLib. See COPYING. If not, write to
TerraLib Team at <terralib-team@terralib.org>.
*/

/*!
 * \file canvas/Grid.cpp
 */

#include "Grid.h"

// TerraLib
#include "../../../common/StringUtils.h"
#include "../../../geometry/Envelope.h"
#include "../../../geometry/MultiLineString.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/Utils.h"
#include "../Utils.h"

#include "MapDisplay.h"

// Qt
#include <QPainter>
#include <QPixmap>

// STL
#include <vector>

/*!
 * \class WorldTransformer
 *
 * \brief This class is used to transform coordinates in world coordinate system to the screen coordinate system.
 */
class WorldTransformer
{
public:

  /** @name Constructor and destructor methods.
  *  Methods related to instantiation and destruction.
  */
  //@{

  /*!
   * \brief Default constructor.
   */
  WorldTransformer()

  {
  }

  /*!
   * \brief Parameterized constructor.
   */
  WorldTransformer(const double& s1llx, const double& s1lly,
                   const double& s1urx, const double& s1ury,
                   double s2width, double s2height) :
    m_mirroring(true)
  {
    te::gm::Envelope system1Box(s1llx, s1lly, s1urx, s1ury);
    te::gm::Envelope system2Box(0, 0, s2width, s2height);

    setTransformationParameters(system1Box, system2Box);
  }

  /*!
   * \brief Parameterized constructor.
   */
  WorldTransformer(const te::gm::Envelope& system1Box, const te::gm::Envelope& system2Box) :
    m_mirroring(true)
  {
    setTransformationParameters(system1Box, system2Box);
  }

  /*!
   * \brief Copy constructor.
   *
   * \param other The object to be copied.
   */
  WorldTransformer(const WorldTransformer& other)
  {
    m_scaleX = other.m_scaleX;
    m_scaleY = other.m_scaleY;
    m_translateX = other.m_translateX;
    m_translateY = other.m_translateY;
    m_s1llx = other.m_s1llx;
    m_s1lly = other.m_s1lly;
    m_s1urx = other.m_s1urx;
    m_s1ury = other.m_s1ury;
    m_s1Width = other.m_s1Width;
    m_s1Height = other.m_s1Height;
    m_s2llx = other.m_s2llx;
    m_s2lly = other.m_s2lly;
    m_s2urx = other.m_s2urx;
    m_s2ury = other.m_s2ury;
    m_s2Width = other.m_s2Width;
    m_s2Height = other.m_s2Height;
    m_valid = other.m_valid;
    m_mirroring = other.m_mirroring;
  }

  /*!
   * \brief Destructor.
   */
  ~WorldTransformer() = default;
  //@}

  /** @name Transformation methods.
  *  Methods used to change coordinates of a coordinate system to another.
  */
  //@{

  /*!
   * \brief Updates the matrix of transformation to be used.
   *
   * \param system1Box Box in world coordinate system.
   *
   * \param system2Box Box in screen coordinate system.
  */
  void setTransformationParameters(const te::gm::Envelope& system1Box, const te::gm::Envelope& system2Box)
  {
    m_valid = true;
    if ((!system1Box.isValid()) || (!system2Box.isValid()))
    {
      m_valid = false;
      return;
    }

    initVariables(system1Box, system2Box);

    m_scaleX = m_s2Width / m_s1Width;   // map units per unit along x-direction
    m_scaleY = m_s2Height / m_s1Height; // map units per unit along y-direction

    m_translateX = m_s2llx - m_s1llx * m_scaleX;
    m_translateY = m_s2lly - m_s1lly * m_scaleY;
  }

  /*!
   * \brief Transforms the coordinate from world system to screen coordinate system.
   *
   * \param[out] wx Coordinate in X-axis.
   *
   * \param[out] wy Coordinate in Y-axis.
  */
  void system1Tosystem2(double& wx, double& wy) const
  {
    wx = (m_scaleX * wx) + m_translateX;
    wy = (m_scaleY * wy) + m_translateY;

    if (m_mirroring)
    {
      double dyCopy = wy;
      wy = m_s2Height - 1 - dyCopy; // mirror
    }
  }

  /*!
  * \overload void WorldTransformer::system1Tosystem2(const double& wx, const double& wy, double& dx, double& dy) const
  *
  * \param wx Coordinate, in X-axis, to be transformed to screen coordinate system.
  *
  * \param wy Coordinate, in Y-axis, to be transformed to screen coordinate system.
  *
  * \param[out] dx Coodinate, in X-axis, transformed.
  *
  * \param[out] dy Coodinate, in Y-axis, transformed.
  */
  void system1Tosystem2(const double& wx, const double& wy, double& dx, double& dy) const
  {
    dx = (m_scaleX * wx) + m_translateX;
    dy = (m_scaleY * wy) + m_translateY;

    if (m_mirroring)
    {
      double dyCopy = dy;
      dy = m_s2Height - 1 - dyCopy; // mirror
    }
  }

  /*!
  * \overload void WorldTransformer::system1Tosystem2(const te::gm::Coord2D& c1) const
  *
  * \param c1 Coordinate to be transformed.
  *
  * \return Returns the coordinate transformed.
  */
  te::gm::Coord2D system1Tosystem2(const te::gm::Coord2D& c1) const
  {
    double x2 = 0.;
    double y2 = 0.;

    system1Tosystem2(c1.getX(), c1.getY(), x2, y2);

    te::gm::Coord2D c2(x2, y2);
    return c2;
  }

  /*!
   * \brief Transforms the coordinate from screen system to world coordinate system.
   *
   * \param[out] dx Coordinate in X-axis.
   *
   * \param[out] dy Coordinate in Y-axis.
   */
  void system2Tosystem1(double& dx, double& dy) const
  {
    double dyCopy = dy;

    if (m_mirroring)
    {
      dy = m_s2Height - 1 - dyCopy; // mirror
    }

    dx = (dx - m_translateX) / m_scaleX;
    dy = (dyCopy - m_translateY) / m_scaleY;
  }

  /*!
  * \overload void WorldTransformer::system2Tosystem1(double dx, double dy, double& wx, double& wy) const
  *
  * \param dx Coordinate, in X-axis, to be transformed to world coordinate system.
  *
  * \param dy Coordinate, in Y-axis, to be transformed to world coordinate system.
  *
  * \param[out] wx Coodinate, in X-axis, transformed.
  *
  * \param[out] wy Coodinate, in Y-axis, transformed.
  */
  void system2Tosystem1(double dx, double dy, double& wx, double& wy) const
  {
    double dyCopy = dy;

    if (m_mirroring)
    {
      dyCopy = m_s2Height - 1 - dyCopy; // mirror
    }

    wx = (dx - m_translateX) / m_scaleX;
    wy = (dyCopy - m_translateY) / m_scaleY;
  }
  //@}

  /** @name Getter methods of matrix parameters.
  *  Methods used to retrieve informations about the matrix of transformation.
  */
  //@{

  /*!
   * \brief Returns the scale in X-axis.
   *
   * \return The scale in X-axis.
   */
  double getScaleX()
  {
    return m_scaleX;
  }

  /*!
   * \brief Returns the scale in Y-axis.
   *
   * \return The scale in Y-axis.
   */
  double getScaleY()
  {
    return m_scaleY;
  }

  /*!
   * \brief Returns the translation in X-axis.
   *
   * \return The transation in X-axis.
   */
  double getTranslateX()
  {
    return m_translateX;
  }

  /*!
   * \brief Returns the translation in Y-axis.
   *
   * \return The transation in Y-axis.
   */
  double getTranslateY()
  {
    return m_translateY;
  }
  //@}

  /** @name Getter parameters of the world box.
  *  Methods used to retrieve informations about the box in world coordinate system.
  */
  //@{

  /*!
   * \brief Returns the lower left corner x value.
   *
   * \return The lower left corner x value.
   */
  double getS1llx()
  {
    return m_s1llx;
  }

  /*!
   * \brief Returns the lower left corner y value.
   *
   * \return The lower left corner y value.
   */
  double getS1lly()
  {
    return m_s1lly;
  }

  /*!
   * \brief Returns the upper right corner x value.
   *
   * \return The upper right corner x value.
   */
  double getS1urx()
  {
    return m_s1urx;
  }

  /*!
   * \brief Returns the upper right corner y value.
   *
   * \return The upper right corner y value.
   */
  double getS1ury()
  {
    return m_s1ury;
  }

  /*!
   * \brief Returns the width of the world box.
   *
   * \return The width of the world box.
   */
  double getS1Width()
  {
    return m_s1Width;
  }

  /*!
   * \brief Returns the height of the world box.
   *
   * \return The height of the world box.
   */
  double getS1Height()
  {
    return m_s1Height;
  }
  //@}

  /** @name Getter parameters of the device box.
  *  Methods used to retrieve informations about the box in device coordinate system.
  */
  //@{

  /*!
   * \brief Returns the lower left corner x value.
   *
   * \return The lower left corner x value.
   */
  double getS2llx()
  {
    return m_s2llx;
  }

  /*!
   * \brief Returns the lower left corner y value.
   *
   * \return The lower left corner y value.
   */
  double getS2lly()
  {
    return m_s2lly;
  }

  /*!
   * \brief Returns the upper right corner x value.
   *
   * \return The upper right corner x value.
   */
  double getS2urx()
  {
    return m_s2urx;
  }

  /*!
   * \brief Returns the upper right corner y value.
   *
   * \return The upper right corner y value.
   */
  double getS2ury()
  {
    return m_s2ury;
  }

  /*!
   * \brief Returns the width of the device box.
   *
   * \return The width of the device box.
   */
  double getS2Width()
  {
    return m_s2Width;
  }

  /*!
   * \brief Returns the height of the device box.
   *
   * \return The height of the device box.
   */
  double getS2Height()
  {
    return m_s2Height;
  }
  //@}

  /*!
   * \brief Returns TRUE if transformation is ok and FALSE otherwise.
   *
   * \return True if the transformation is valid and false otherwise.
   */
  bool isValid()
  {
    if ((m_scaleX <= 0.) && (m_scaleY <= 0.))
      return false;

    return true;
  }

  /*!
   * \brief Returns TRUE if transformation is mirrored and FALSE otherwise.
   *
   * \return True if the transformation is mirrored and false otherwise.
   */
  bool isMirroring()
  {
    return m_mirroring;
  }

  /*!
   * \brief Updates mirroring internal attribute.
   *
   * \param mirror New mirroring state.
   */
  void setMirroring(bool mirror)
  {
    m_mirroring = mirror;
  }

protected:

  /*!
   * \brief Initializes the transformer using the arguments.
   *
   * \param system1Box Box in world coordinate system.
   *
   * \param system2Box Box in device coordinate system.
   */
  void initVariables(const te::gm::Envelope& system1Box, const te::gm::Envelope& system2Box)
  {
    m_scaleX = 0.;
    m_scaleY = 0.;

    m_translateX = 0.;
    m_translateY = 0.;

    m_s1llx = system1Box.getLowerLeftX();
    m_s1lly = system1Box.getLowerLeftY();
    m_s1urx = system1Box.getUpperRightX();
    m_s1ury = system1Box.getUpperRightY();
    m_s1Width = system1Box.getWidth();
    m_s1Height = system1Box.getHeight();

    m_s2llx = system2Box.getLowerLeftX();
    m_s2lly = system2Box.getLowerLeftY();
    m_s2urx = system2Box.getUpperRightX();
    m_s2ury = system2Box.getUpperRightY();
    m_s2Width = system2Box.getWidth();
    m_s2Height = system2Box.getHeight();
  }

  double m_scaleX{0.};  //!< Map units per unit along x-direction between
                        //!< Coordinate Systems.
  double m_scaleY{0.};  //!< Map units per unit along y-direction between
                        //!< Coordinate Systems.
  double m_translateX{
      0};  //!< The value corresponds to the X-Axis translation of system 2.
  double m_translateY{
      0};  //!< The value corresponds to the Y-Axis translation of system 2.
  double m_s1llx{0.};      //!< Lower left x-coordinate of the System 1
  double m_s1lly{0.};      //!< Lower left y-coordinate of the System 1
  double m_s1urx{0.};      //!< Upper right x-coordinate of the System 1
  double m_s1ury{0.};      //!< Upper right y-coordinate of the System 1
  double m_s1Width{0.};    //!< Width of System 1 coordinate system.
  double m_s1Height{0.};   //!< Height of System 1 coordinate system.
  double m_s2llx{0.};      //!< Lower left x-coordinate of the System 2
  double m_s2lly{0.};      //!< Lower left y-coordinate of the System 2
  double m_s2urx{0.};      //!< Upper right x-coordinate of the System 2
  double m_s2ury{0.};      //!< Upper right y-coordinate of the System 2
  double m_s2Width{0.};    //!< Width of System 2 coordinate system.
  double m_s2Height{0.};   //!< Height of System 2 coordinate system.
  bool m_valid{false};     //!< Flag specifying the state of validation of the
                           //!< transformation being used.
  bool m_mirroring{true};  //!< Flag sinalizing the mirroring.
};

/*!
 * \brief Giving a box in world coordinate system and another in device coordinates, returns the WorldTransformer.
 *
 * \param boxgeo Bounding rectangle in world coordinate system.
 *
 * \param boxmm Bounding rectangle in device coordinate system.
 *
 * \return The WorldTransformer object.
 */
WorldTransformer GetTransformGeo(te::gm::Envelope boxgeo, te::gm::Envelope boxmm)
{
  WorldTransformer transf; // World Transformer.

  if (!boxgeo.isValid())
    return transf;

  if (!boxmm.isValid())
    return transf;

  // Adjust internal renderer transformer
  transf.setTransformationParameters(boxgeo, boxmm);

  return transf;
}

// --------------------------------------------------
// Planar Grid functions
// --------------------------------------------------

/*!
 * \brief Calculates the initial coordinate in x-axis.
 *
 * \param env Bounding rect in world coordinate system.
 *
 * \param verticalLineInitial Initial coordinate in y-axis.
 *
 * \param verticalLineGap Distance between two grid lines.
 *
 * \return The initial value in the x-axis.
 */
double CalculateInitialX(const te::gm::Envelope& env, const double& verticalLineInitial, const double& verticalLineGap)
{
  double xInit = verticalLineInitial;

  if (xInit < env.getLowerLeftX())
  {
    double difx = env.getLowerLeftX() - xInit;
    int nParts = static_cast<int>(difx / verticalLineGap);

    xInit = (nParts == 0) ?
              verticalLineInitial :
              xInit + (nParts * verticalLineGap);
  }

  return xInit;
}

/*!
 * \brief Calculates the initial coordinate in y-axis.
 *
 * \param env Bounding rect in world coordinate system.
 *
 * \param horizontalLineInitial Initial coordinate in X-axis.
 *
 * \param horizontalLineGap Distance between two grid lines.
 *
 * \return The initial value in the y-axis.
 */
double CalculateInitialY(const te::gm::Envelope& env, const double& horizontalLineInitial, const double& horizontalLineGap)
{
  double yInit = horizontalLineInitial;

  if (yInit < env.getLowerLeftY())
  {
    double dify = env.getLowerLeftY() - yInit;
    int nParts = static_cast<int>(dify / horizontalLineGap);

    yInit = (nParts == 0) ?
              horizontalLineInitial :
              yInit + (nParts * horizontalLineGap);
  }

  return yInit;
}

/*!
 * \brief Calculates the lines in y-axis.
 *
 * \param planarBox Box in world coordinate system (MUST BE in a planar coordinate system).
 *
 * \param verticalLineInitial Inital Y.
 *
 * \param verticalLineGap Distance between lines in y-axis.
 *
 * \param maxGaps Maximum number of lines to be presented on the grid.
 *
 * \return A vector with the calculated lines in y-axis.
 */
std::vector<te::gm::LineString> CalculateVerticalLines(const te::gm::Envelope& planarBox, const double& verticalLineInitial, const double& verticalLineGap,
                                                       const int& maxGaps)
{
  std::vector<te::gm::LineString> res;

  //here we check if the gap count would exceed the maximum number of gaps
  if (planarBox.getWidth() / verticalLineGap > maxGaps)
    return res;

  // Getting a suggar initial x.
  double initialX = CalculateInitialX(planarBox, verticalLineInitial, verticalLineGap);

  // Calculating the lines.
  for (; initialX <= planarBox.getUpperRightX(); initialX += verticalLineGap)
  {
    if (initialX < planarBox.getLowerLeftX())
      continue;

    te::gm::LineString lineString(2, te::gm::LineStringType);

    lineString.setPoint(0, initialX, planarBox.getLowerLeftY());
    lineString.setPoint(1, initialX, planarBox.getUpperRightY());

    res.push_back(lineString);
  }

  return res;
}

/*!
 * \brief Calculates the lines in x-axis.
 *
 * \param world Box in world coordinate system (MUST BE in a planar coordinate system).
 *
 * \param horizontalLineInitial Inital X.
 *
 * \param horizontalLineGap Distance between lines in x-axis.
 *
 * \param maxGaps Maximum number of lines to be presented on the grid.
 *
 * \return A vector with the calculated lines in x-axis.
 */
std::vector<te::gm::LineString> CalculateHorizontalLines(const te::gm::Envelope& world, const double& horizontalLineInitial, const double& horizontalLineGap,
                                                         const int& maxGaps)
{
  std::vector<te::gm::LineString> lines;

  //here we check if the gap count would exceed the maximum number of gaps
  if (world.getHeight() / horizontalLineGap > maxGaps)
    return lines;

  double initialY = CalculateInitialY(world, horizontalLineInitial, horizontalLineGap);

  for (; initialY <= world.getUpperRightY(); initialY += horizontalLineGap)
  {
    if (initialY < world.getLowerLeftY())
      continue;

    te::gm::LineString lineString(2, te::gm::LineStringType);

    lineString.setPoint(0, world.getLowerLeftX(), initialY);
    lineString.setPoint(1, world.getUpperRightX(), initialY);

    lines.push_back(lineString);
  }

  return lines;
}

/*!
 * \brief Calculates a suggar initial coordinate in world coordinate system.
 *
 * \param initialCoord Initial coordinate.
 *
 * \param distance The distance to be used.
 *
 * \param[out] gap The value of the distance between lines in axis.
 *
 * \return A suggar value for initial coordinate.
 */
double GetInitialCoord(const double& initialCoord, const double& distance, double& gap)
{
  if (distance <= 0)
  {
    gap = 0;
    return 0;
  }

  const size_t size = 25;
  int gaps[size] = { 1000, 1500, 2000, 2500, 5000, 7500, 10000, 12500, 15000, 20000, 25000, 50000, 100000, 125000, 150000, 175000, 200000, 250000, 500000, 750000, 1000000, 1250000, 1500000,
                     1750000, 2000000 };
  int numberOfIntervals = 5;

  gap = distance / numberOfIntervals;

  for (size_t i = 0; i < size; i++)
  {
    if (gap <= gaps[i])
    {
      if (i > 0)
        gap = gaps[i - 1];

      break;
    }
  }

  int interval = static_cast<int>(initialCoord / gap);

  return interval * gap;
}

/*!
 * \brief Giving a box in world coordinate system, calculates the better SRID we must use to transform.
 *
 * \param worldBox Box in world coordinate system.
 *
 * \return The id of the projection we must use to transform.
 */
int PlanarSRID(const te::gm::Envelope& worldBox)
{
  int srid = TE_UNKNOWN_SRS;
  int zone = te::map::CalculatePlanarZone(worldBox); // get zone number
  double hemisphere = worldBox.getCenter().getY(); // lat (y) < 0 is south

  if (hemisphere > 0)
    srid = 32600 + zone; // 32600 - WGS 84 / UTM grid system (northern hemisphere)
  else
    srid = 32700 + zone; // 32700 - WGS 84 / UTM grid system (southern hemisphere)

  return srid;
}

/*!
 * \brief Returns the dimensions of a text giving a font.
 *
 * \param font The font being used for the texts.
 *
 * \param text The text analysed.
 *
 * \param[out] w The calculated text width.
 *
 * \param[out] h The calculated text height.
 */
void GetTextDimensions(const QFont font, const QString& text, int& w, int& h)
{
  QFontMetrics fm(font);

  w = fm.width(text);
  h = fm.height();
}

/*!
 * \brief Draws the line using the giving painter.
 *
 * \param painter The painter being used for rendering.
 *
 * \param line The line to be drawed.
 *
 * \param txtOffSet Position of the text.
 *
 * \param vertical Sinalizes that the line analysed is a vertical or horizontal line.
 */
void DrawLine(QPainter* painter, QLineF& line, const int& txtOffSet, const bool& vertical)
{
  QPaintDevice* device = painter->device();

  // 1mm of margin of the texts on top and bottom.
  int oneMMPx = te::qt::widgets::MillimetersToPixels(device, 1, false);

  int offSet = oneMMPx/2 + txtOffSet;

  // Calculating the text positions on top and bottom.
  double x1 = 0,
      x2 = 0,
      y1 = 0,
      y2 = 0;

  if(vertical)
  {
    x1 = line.x1();
    y1 = offSet;
    x2 = line.x2();
    y2 = device->height() - (offSet + oneMMPx + oneMMPx/2);
  }
  else
  {
    x1 = offSet;
    y1 = line.y1();
    x2 = device->width() - offSet;
    y2 = line.y2();
  }

  line.setP1(QPointF(x1, y1));
  line.setP2(QPointF(x2, y2));

  painter->drawLine(line);
}

/*!
 * \brief Draws lines on painter.
 *
 * \param transf The world transformer being used.
 *
 * \param painter The painter being used.
 *
 * \param lines The set of lines to be drawed
 *
 * \param txtOffSet Position of the text.
 *
 * \param vertical Sinalizes that the lines being analysed are vertical or horizontal lines.
 */
void DrawLines(WorldTransformer transf, QPainter* painter, const std::vector<te::gm::LineString>& lines, const int& txtOffSet, const bool& vertical)
{
  std::vector<te::gm::LineString>::const_iterator it;
  QLineF line;

  double x1 = 0,
      y1 = 0,
      x2 = 0,
      y2 = 0;

  for(it = lines.cbegin(); it != lines.cend(); ++it)
  {
    transf.system1Tosystem2((*it).getPointN(0)->getX(), (*it).getPointN(0)->getY(), x1, y1);
    transf.system1Tosystem2((*it).getPointN(1)->getX(), (*it).getPointN(1)->getY(), x2, y2);

    line.setP1(QPointF(x1, y1));
    line.setP2(QPointF(x2, y2));

    DrawLine(painter, line, txtOffSet, vertical);
  }
}

/*!
 * \brief Draw horizontal and vertical lines.
 *
 * \param transf The world transformer being used.
 *
 * \param painter The painter being used.
 *
 * \param vlines Set of vertical lines.
 *
 * \param hlines Set of horizontal lines.
 *
 * \param font The font to be used to render the texts.
 */
void DrawAllLines(WorldTransformer transf, QPainter* painter, const std::vector<te::gm::LineString>& vlines, const std::vector<te::gm::LineString>& hlines,
                  const QFont& font)
{
  int txtW = 0,
      txtH = 0;

  GetTextDimensions(font, "0", txtW, txtH);

  DrawLines(transf, painter, vlines, txtH, true);
  DrawLines(transf, painter, hlines, txtW, false);
}

/*!
 * \brief Returns a pixmap with the text.
 *
 * \param txt The text to be drawed.
 *
 * \param font The font to be used.
 *
 * \param pen The pen being used.
 *
 * \return A pixmap with text and dimensions calculated based on \a font parameter.
 */
QPixmap* GetTextPixmap(const QString& txt, const QFont& font, const QPen& pen)
{
  int txtW = 0,
      txtH = 0;
  QPainter p;
  QPixmap* res = nullptr;
  QRect pixRect;
  QSize pixDimensions;

  // Getting the text dimensions
  GetTextDimensions(font, txt, txtW, txtH);

  pixDimensions.setWidth(txtW);
  pixDimensions.setHeight(txtH);

  res = new QPixmap(pixDimensions);
  res->fill(Qt::white);

  pixRect.setWidth(pixDimensions.width());
  pixRect.setHeight(pixDimensions.height());

  p.begin(res);

  p.setPen(pen);
  p.setFont(font);

  p.drawText(QRect(0, 0, pixDimensions.width(), pixDimensions.height()), Qt::AlignLeft, txt);

  return res;
}

/*!
 * \brief Returns an image with the headers of the grid.
 *
 * \param transf The world transformer being used.
 *
 * \param lines The calculated grid lines.
 *
 * \param font The font to be used.
 *
 * \param pen The pen being used.
 *
 * \param vertical Sinalizes that the lines being analysed are vertical or horizontal lines.
 *
 * \param displayDimensions Dimensions of the canvas being used.
 *
 * \return A pixmap with the header, over some axis, of the grid.
 */
QPixmap* GetTextsPixmap(WorldTransformer transf, const std::vector<te::gm::LineString>& lines, const QFont& font, const QPen& pen, const bool& vertical,
                        const QSize& displayDimensions)
{
  double col = 0,
      row = 0;
  int txtW = 0,
      txtH = 0;
  long lValue;
  QPainter p;
  QPixmap* res = nullptr;
  QPoint center;
  QRect subpixRect;
  QSize pixDimensions;
  QString sValue;
  std::vector<te::gm::LineString>::const_iterator it;

  GetTextDimensions(font, "0", txtW, txtH);

  if(vertical)
  {
    pixDimensions.setWidth(displayDimensions.width());
    pixDimensions.setHeight(txtH);
  }
  else
  {
    pixDimensions.setWidth(displayDimensions.height());
    pixDimensions.setHeight(txtH);
  }

  res = new QPixmap(pixDimensions);

  res->fill(Qt::transparent);

  p.begin(res);

  for(it = lines.cbegin(); it != lines.cend(); ++it)
  {
    std::unique_ptr<QPixmap> pixValue;


    transf.system1Tosystem2((*it).getPointN(0)->getX(), (*it).getPointN(0)->getY(), col, row);

    lValue = (vertical) ?
               static_cast<long>((*it).getPointN(0)->getX()) :
               static_cast<long>((*it).getPointN(0)->getY());

    sValue = QString::number(lValue);

    pixValue.reset(GetTextPixmap(sValue, font, pen));

    subpixRect.setSize(pixValue->size());

    if(vertical)
    {
      center.setX(static_cast<int>(col));
      center.setY(subpixRect.height()/2);
    }
    else
    {
      center.setX(static_cast<int>(row));
      center.setY(subpixRect.height()/2);
    }

    subpixRect.moveCenter(center);

    p.drawPixmap(subpixRect, *pixValue.get());
  }

  return res;
}

/*!
 * \brief Draws all texts of the lines on the grid.
 *
 * \param transf The world transformer being used.
 *
 * \param painter The painter being used.
 *
 * \param vlines Set of vertical lines.
 *
 * \param hlines Set of vertical lines.
 *
 * \param font The font being used to draw texts.
 */
void DrawTexts(WorldTransformer transf, QPainter* painter, const std::vector<te::gm::LineString>& vlines, const std::vector<te::gm::LineString>& hlines,
               const QFont& font)
{
  double dx = 0,
      dy = 0;
  int oneMMPx = te::qt::widgets::MillimetersToPixels(painter->device(), 1, false);
  std::unique_ptr<QPixmap> horizontalLabel;
  std::unique_ptr<QPixmap> verticalLabel;

  QSize deviceSize(painter->device()->width(), painter->device()->height());

  QRect devR;
  devR.setSize(deviceSize);

  // Drawing horizontal labels
  horizontalLabel.reset(GetTextsPixmap(transf, vlines, font, painter->pen(), true, deviceSize));
  painter->drawPixmap(0, oneMMPx, *horizontalLabel.get());
  painter->drawPixmap(0, deviceSize.height() - (oneMMPx+horizontalLabel->height()), *horizontalLabel.get());

  dx = devR.center().x();
  dy = devR.center().y();

  // Drawing vertical labels
  verticalLabel.reset(GetTextsPixmap(transf, hlines, font, painter->pen(), false, deviceSize));
  painter->save();
  painter->translate(devR.center());
  painter->rotate(90);
  painter->translate(-dy, -dx);

  painter->drawPixmap(oneMMPx, 0, *verticalLabel.get());
  painter->drawPixmap(oneMMPx, deviceSize.width() - verticalLabel->height(), *verticalLabel.get());

  painter->restore();
}
// --------------------------------------------------
// End planar grid functions
// --------------------------------------------------


// --------------------------------------------------
// Geodesic grid functions
// --------------------------------------------------

/*!
 * \brief Transforms the coordinates of an envelope from a system of coordinates to another.
 *
 * \param worldBox Bounding rectangle.
 *
 * \param sourceSRID Srid of the bounding rectangle.
 *
 * \param targetSRID Srid of the new bounding rectangle.
 *
 * \return The bounding rectangle in the \a targetSRID coordinate system.
 */
te::gm::Envelope WorldBoxTo(const te::gm::Envelope& worldBox, const unsigned int& sourceSRID, const unsigned int& targetSRID)
{
  te::gm::Envelope copyWorldBox = worldBox;

  // Checks if is Planar Geographic
  std::string authName = "EPSG"; // Now: So far it is the only one supported by TerraLib 5. Future: Review this line!
  te::srs::SpatialReferenceSystemManager::getInstance().isGeographic(sourceSRID, authName);
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(sourceSRID, authName);

  // check if srid exist and worldbox is valid
  if (!unitPtr || !copyWorldBox.isValid())
    return copyWorldBox;

  // Remapping
  copyWorldBox.transform(static_cast<int>(sourceSRID), static_cast<int>(targetSRID));
  return copyWorldBox;
}

/*!
 * \brief Transforms a LineString from a coordinate system to another.
 *
 * \param line Line to be converted.
 *
 * \param sourceSRID Srid of the line.
 *
 * \param planarSRID Srid of the output.
 */
void RemapToPlanar(te::gm::LineString* line, int sourceSRID, int planarSRID)
{
  if (!line)
    return;

  /* Optimization so that the convert object is created only once, decreasing the execution time of this method,
  since it will no longer use the Envelope::transform method (for each point). */

  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

  try
  {
    converter->setSourceSRID(sourceSRID);
    converter->setTargetSRID(planarSRID);
  }
  catch (te::common::Exception& /* ex */)
  {
    return;
  }

  // convert the four corners
  std::size_t npoints = line->getNPoints();

  std::vector<te::gm::Coord2D> vecValidCoords;

  for (std::size_t i = 0; i < npoints; ++i)
  {
    double xin = line->getX(i);
    double yin = line->getY(i);
    double xout = 0;
    double yout = 0;

    bool wasConverted = converter->convert(xin, yin, xout, yout);

    if (wasConverted)
    {
      te::gm::Coord2D coord(xout, yout);
      vecValidCoords.push_back(coord);
    }
  }

  line->makeEmpty();
  line->setNumCoordinates(vecValidCoords.size());

  for (std::size_t i = 0; i < vecValidCoords.size(); ++i)
    line->setPoint(i, vecValidCoords[i].x, vecValidCoords[i].y);

  line->computeMBR(true);
  line->setSRID(planarSRID);
}

/*!
 * \brief Converts the \a line from world coordinate system to device coordinate system.
 *
 * \param transf WorldTransformer previously created with the both world rectangle and device rectangle.
 *
 * \param line The line to be converted.
 */
void ConvertToMillimeter( const WorldTransformer& transf, te::gm::LineString* line )
{
  if(!line)
    return;

  std::size_t npoints = line->getNPoints();

  for(std::size_t i = 0 ; i < npoints ; ++i)
  {
    double currentX = line->getX(i);
    double currentY = line->getY(i);

    double x = 0;
    double y = 0;

    transf.system1Tosystem2(currentX, currentY, x, y);
    line->setPoint(i, x, y);
  }

  line->computeMBR(true);
  line->setSRID(TE_UNKNOWN_SRS);
}

/*!
 * \brief Calculates the vertical lines of the grid.
 *
 * \param planarBox Bounding rectangle in planar coordinate system.
 *
 * \param geographicBox Bounding rectangle in geographic coordinates.
 *
 * \param boxMM Bounding rectangle of the device in pixel coordinate system.
 *
 * \param verticalLineInitial Initial coordinate.
 *
 * \param verticalLineGap Difference between the coordinates.
 *
 * \param maxGaps Maximum number of lines to be created.
 *
 * \param planarSRID Srid of a planar coordinate system.
 *
 * \param geodesicSRID Srid of a geographic coordinate system.
 *
 * \return A vector with the created lines.
 *
 * \note If display is in a geographic coordinate system, \a planarBox MUST be an invalid rectangle and \a planarSRID MUST be the value -1. If both weren't correctly passed, this method may not work properly.
 */
std::vector<te::gm::LineString> CalculateVerticalLines(const te::gm::Envelope& planarBox, const te::gm::Envelope& geographicBox,
                                                       const te::gm::Envelope& boxMM, const double& verticalLineInitial, const double& verticalLineGap,
                                                       const int& maxGaps, const int& planarSRID, const int& geodesicSRID)
{
  std::vector<te::gm::LineString> verticalLines;

  // Draw a vertical line and the x coordinate change(horizontal)
  WorldTransformer transf = GetTransformGeo((planarBox.isValid()) ? planarBox : geographicBox, boxMM);
  transf.setMirroring(true);

  if (geodesicSRID == -1)
    return verticalLines;

  //here we check if the gap count would exceed the maximum number of gaps
  if (geographicBox.getWidth() / verticalLineGap > maxGaps)
    return verticalLines;

  //as the geographic grid comes from the result of a reprojection, the geographic box sometimes can be smaller than the planar box, maninly when the distance from equator gets higher.
  //when this happens, these calculated lines do not reach the boundaries of the item, and consequently the texts are not drawn in the correct position
  //to fix this, we calculate a grid bigger than we need, and then we clip the lines by making an intertection operation with the item
  double x1 = CalculateInitialX(geographicBox, verticalLineInitial, verticalLineGap);
  double x2 = geographicBox.getUpperRightX();
  double y1 = geographicBox.getLowerLeftY();
  double y2 = geographicBox.getUpperRightY();

  if (x1 < -178.)
    x1 = -178.;
  if (x2 > 178.)
    x2 = 178.;
  if (y1 < -89.)
    y1 = -89.;
  if (y2 > 89.)
    y2 = 89.;

  te::gm::LineString topBorderLine(2, te::gm::LineStringType);
  topBorderLine.setPoint(0, boxMM.getLowerLeftX(), boxMM.getUpperRightY());
  topBorderLine.setPoint(1, boxMM.getUpperRightX(), boxMM.getUpperRightY());

  te::gm::LineString bottomBorderLine(2, te::gm::LineStringType);
  bottomBorderLine.setPoint(0, boxMM.getLowerLeftX(), boxMM.getLowerLeftY());
  bottomBorderLine.setPoint(1, boxMM.getUpperRightX(), boxMM.getLowerLeftY());

  for (; x1 <= x2; x1 += verticalLineGap)
  {
    te::gm::Coord2D c1(x1, y1);
    te::gm::Coord2D c2(x1, y2);

    te::gm::LineString line = CreateLine(c1, c2, geodesicSRID, 32);

    // Line curvature: of latlong to planar;
    // Draw line: planar to mm
    if(planarSRID != -1)
      RemapToPlanar(&line, geodesicSRID, planarSRID);

    ConvertToMillimeter(transf, &line);

    //here we clip the line using the boundaries of the item in MM
    std::unique_ptr<te::gm::Geometry> rectPolygon(te::gm::GetGeomFromEnvelope(&boxMM, line.getSRID()));
    std::unique_ptr<te::gm::Geometry> clippedGeometry(line.intersection(rectPolygon.get()));

    if (clippedGeometry == nullptr || !clippedGeometry->isValid())
      continue;

    //as the grid lines are curved, the intersection may result in more than one part for each line. Here we handle it
    if (clippedGeometry->getGeomTypeId() == te::gm::LineStringType)
    {
      te::gm::LineString lineString(*static_cast<te::gm::LineString*>(clippedGeometry.get()));
      verticalLines.push_back(lineString);
    }
    else if (clippedGeometry->getGeomTypeId() == te::gm::MultiLineStringType)
    {
      te::gm::MultiLineString multiLineString(*static_cast<te::gm::MultiLineString*>(clippedGeometry.get()));

      for (std::size_t i = 0; i < multiLineString.getNumGeometries(); ++i)
        verticalLines.push_back(*static_cast<te::gm::LineString*>(multiLineString.getGeometryN(i)));
    }
    else
      continue;
  }

  return verticalLines;
}

/*!
 * \brief Calculates the horizontal lines of the grid.
 *
 * \param planarBox Bounding rectangle in planar coordinate system.
 *
 * \param geographicBox Bounding rectangle in geographic coordinates.
 *
 * \param boxMM Bounding rectangle of the device in pixel coordinate system.
 *
 * \param horizontalLineInitial Initial coordinate.
 *
 * \param horizontalLineGap Difference between the coordinates.
 *
 * \param maxGaps Maximum number of lines to be created.
 *
 * \param planarSRID Srid of a planar coordinate system.
 *
 * \param geodesicSRID Srid of a geographic coordinate system.
 *
 * \return A vector with the created lines.
 *
 * \note If display is in a geographic coordinate system, \a planarBox MUST be an invalid rectangle and \a planarSRID MUST be the value -1. If both weren't correctly passed, this method may not work properly.
 */
std::vector<te::gm::LineString> CalculateHorizontalLines(const te::gm::Envelope& planarBox, const te::gm::Envelope& geographicBox,
                                                         const te::gm::Envelope& boxMM, const double& horizontalLineInitial, const double& horizontalLineGap,
                                                         const int& maxGaps, const int& planarSRID, const int& geodesicSRID)
{
  std::vector<te::gm::LineString> horizontalLines;

  // Draw a horizontal line and the y coordinate change(vertical)
  WorldTransformer transf = GetTransformGeo((planarBox.isValid()) ? planarBox : geographicBox, boxMM);
  transf.setMirroring(true);

  if (geodesicSRID == -1)
    return horizontalLines;

  //here we check if the gap count would exceed the maximum number of gaps
  if (geographicBox.getHeight() / horizontalLineGap > maxGaps)
    return horizontalLines;

  double x1 = geographicBox.getLowerLeftX();
  double x2 = geographicBox.getUpperRightX();
  double y1 = CalculateInitialY(geographicBox, horizontalLineInitial, horizontalLineGap);
  double y2 = geographicBox.getUpperRightY();

  if (x1 < -178.)
    x1 = -178.;
  if (x2 > 178.)
    x2 = 178.;
  if (y1 < -89.)
    y1 = -89.;
  if (y2 > 89.)
    y2 = 89.;

  te::gm::LineString leftBorderLine(2, te::gm::LineStringType);
  leftBorderLine.setPoint(0, boxMM.getLowerLeftX(), boxMM.getLowerLeftY());
  leftBorderLine.setPoint(1, boxMM.getLowerLeftX(), boxMM.getUpperRightY());

  te::gm::LineString rightBorderLine(2, te::gm::LineStringType);
  rightBorderLine.setPoint(0, boxMM.getUpperRightX(), boxMM.getLowerLeftY());
  rightBorderLine.setPoint(1, boxMM.getUpperRightX(), boxMM.getUpperRightY());

  for (; y1 <= y2; y1 += horizontalLineGap)
  {
    te::gm::Coord2D c1(x1, y1);
    te::gm::Coord2D c2(x2, y1);

    te::gm::LineString line = CreateLine(c1, c2, geodesicSRID, 32);

    // Line curvature: of latlong to planar;
    // Draw line: planar to mm
    if(planarSRID != -1)
      RemapToPlanar(&line, geodesicSRID, planarSRID);

    ConvertToMillimeter(transf, &line);

    //here we clip the line using the boundaries of the item in MM
    std::unique_ptr<te::gm::Geometry> rectPolygon(te::gm::GetGeomFromEnvelope(&boxMM, line.getSRID()));
    std::unique_ptr<te::gm::Geometry> clippedGeometry(line.intersection(rectPolygon.get()));

    if (clippedGeometry == nullptr || !clippedGeometry->isValid())
      continue;

    //as the grid lines are curved, the intersection may result in more than one part for each line. Here we handle it
    if (clippedGeometry->getGeomTypeId() == te::gm::LineStringType)
    {
      te::gm::LineString lineString(*static_cast<te::gm::LineString*>(clippedGeometry.get()));

      horizontalLines.push_back(lineString);
    }
    else if (clippedGeometry->getGeomTypeId() == te::gm::MultiLineStringType)
    {
      te::gm::MultiLineString multiLineString(*static_cast<te::gm::MultiLineString*>(clippedGeometry.get()));

      for (std::size_t i = 0; i < multiLineString.getNumGeometries(); ++i)
        horizontalLines.push_back(*static_cast<te::gm::LineString*>(multiLineString.getGeometryN(i)));
    }
    else
      continue;
  }

  return horizontalLines;
}

/*!
 * \brief Returns a default description for a geodesic coordinate system.
 *
 * \return Default srid for the geodesic coordinate system. (EPSG:4326)
 */
std::string Proj4DescToGeodesic()
{
  // EPSG:4326
  std::string proj4;

  proj4 += "+proj=longlat";
  proj4 += " +datum=WGS84";
  proj4 += " +no_defs ";

  return proj4;
}

/*!
 * \brief Returns the unit of measure of the given \a srid.
 *
 * \param srid Srid of interest.
 *
 * \return The corresponding unit of measure.
 */
te::common::UnitOfMeasurePtr UnitMeasure( int srid )
{
  te::common::UnitOfMeasurePtr unitPtr;

  // Checks if is Planar Geographic
  std::string authName = "EPSG"; // Now: So far it is the only one supported by TerraLib 5. Future: Review this line!
  te::srs::SpatialReferenceSystemManager::getInstance().isGeographic(static_cast<unsigned int>(srid), authName);
  unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(srid), authName);

  return unitPtr;
}

/*!
 * \brief Transforms a bounding rectangle from a srid into another one.
 *
 * \param worldBox Bounding rectangle in some coordinate system.
 *
 * \param sourceSRID The srid of the rectangle.
 *
 * \param targetSRID The srid of the output rectangle.
 *
 * \return A bounding rectangle in the \a targetSRID coordinate system, or an invalid bounding rectangle, if the operation couldn't be done.
 */
te::gm::Envelope WorldBoxTo(const te::gm::Envelope& worldBox, int sourceSRID, int targetSRID)
{
  te::gm::Envelope copyWorldBox = worldBox;

  // Checks if is Planar Geographic
  std::string authName = "EPSG"; // Now: So far it is the only one supported by TerraLib 5. Future: Review this line!
  te::srs::SpatialReferenceSystemManager::getInstance().isGeographic(static_cast<unsigned int>(sourceSRID), authName);
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(sourceSRID), authName);

  // check if srid exist and worldbox is valid
  if (!unitPtr || !copyWorldBox.isValid())
    return copyWorldBox;

  // Remapping
  copyWorldBox.transform(sourceSRID, targetSRID);

  return copyWorldBox;
}

/*!
 * \brief Calculates the srid for the better planar coordinate system, given a bounding rectangle and it's srid.
 *
 * \param worldBox Bounding rectangle in a geodesic coordinate system.
 *
 * \param sourceSRID The srid of the input bounding rectangle.
 *
 * \return Srid of the better planar coordinate system found.
 */
int ToPlanar(const te::gm::Envelope& worldBox, int sourceSRID)
{
  int targetSRID = TE_UNKNOWN_SRS;
  te::common::UnitOfMeasurePtr unitPtr = UnitMeasure(sourceSRID);

  if (!unitPtr || !worldBox.isValid())
    return targetSRID;

  targetSRID = sourceSRID;
  std::string unitPtrStr = unitPtr->getName();
  unitPtrStr = te::common::Convert2UCase(unitPtrStr);

  if (unitPtrStr.compare("DEGREE") == 0)
    // Get the id of the projection of destination
    targetSRID = PlanarSRID(worldBox);

  return targetSRID;
}

/*!
 * \brief Calculates the srid for the better geodesic coordinate system, given a bounding rectangle and it's srid.
 *
 * \param worldBox Bounding rectangle in a planar coordinate system.
 *
 * \param sourceSRID The srid of the input bounding rectangle.
 *
 * \return Srid of the geodesic coordinate.
 */
int ToGeographic(const te::gm::Envelope& worldBox, int sourceSRID)
{
  int targetSRID = TE_UNKNOWN_SRS;
  te::gm::Envelope worldBoxPlanar = worldBox;
  te::common::UnitOfMeasurePtr unitPtr = UnitMeasure(sourceSRID);

  if (!unitPtr || !worldBoxPlanar.isValid())
    return targetSRID;

  targetSRID = sourceSRID;
  std::string unitPtrStr = unitPtr->getName();
  unitPtrStr = te::common::Convert2UCase(unitPtrStr);

  if (unitPtrStr.compare("DEGREE") != 0)
  {
    std::string proj4 = Proj4DescToGeodesic();
    // Get the id of the projection of destination
    std::pair<std::string, unsigned int> projGeographic = te::srs::SpatialReferenceSystemManager::getInstance().getIdFromP4Txt(proj4);

    targetSRID = static_cast<int>(projGeographic.second);
  }

  return targetSRID;
}

/*!
 * \brief Transforms a line from a coordinate system to another.
 *
 * \param transf WorldTransformer created with a planar bounding rectangle and the device bounding rectangle.
 *
 * \param line A line in device coordinate system.
 *
 * \param geoSRID The srid of the geodesic coordinate system.
 */
void GetGeographicCoordLine(WorldTransformer transf, te::gm::LineString& line, const int& geoSRID)
{
  double x,
      y;
  size_t nPts = line.getNPoints();

  for(size_t i = 0; i < nPts; i++)
  {
    transf.system2Tosystem1(line.getPointN(i)->getX(), line.getPointN(i)->getY(), x, y);
    line.setPointN(i, te::gm::Point(x, y));
  }

  line.transform(geoSRID);
}

/*!
 * \brief Retuns an rounded number. If the decimal part of number is less than \a .5, rounds to the floor, otherwise it will be rounded up.
 *
 * \param value Value to be calculated.
 *
 * \return The rounded number.
 */
int RoundNumber( const double& value )
{
  if (value >= 0)
    return static_cast<int>(value+.5);
  else
    return static_cast<int>(value-.5);
}

/*!
 * \brief Converts a value to a degree-minute-second description. For presentation purposes.
 *
 * \param value Value to be converted. (MUST be in a geodesic coordinate system)
 *
 * \param bDegrees True to degrees section to be presented, false otherwise.
 *
 * \param bMinutes True to minutes section to be presented, false otherwise.
 *
 * \param bSeconds True to seconds section to be presented, false otherwise.
 *
 * \param precision Number of the decimals to be used.
 *
 * \return Returns a text formatted as a degree-minute-second value.
 */
std::string ConvertDecimalToDegree(const double& value, bool bDegrees, bool bMinutes, bool bSeconds, int precision)
{
  std::string    degreeValue;
  double      dbValue;
  double      degree;
  double      sec;
  double      min;

  degree = static_cast<int>(value);
  dbValue = value - degree;

  min = std::fabs((dbValue-static_cast<int>(dbValue)*60.));
  sec = std::fabs(std::fabs((min-int(min))*60.));

  if(RoundNumber(sec) >= 60)
  {
    min++;
    sec=0;
  }

  min = std::floor(min);

  if(min >= 60.0)
  {
    min = 0;
    dbValue++;
  }

  std::string space;

  const QChar degreeChar(0260);

  if (bDegrees)
  {
    degreeValue = te::common::Convert2String(std::floor(degree), 0) + QString(degreeChar).toStdString();
    space = " ";
  }
  if (bMinutes)
  {
    degreeValue += space + te::common::Convert2String(std::floor(min), 0) + "'";
    space = " ";
  }
  if (bSeconds)
  {
    degreeValue += space + te::common::Convert2String(std::fabs(sec), precision) + "''";
  }

  if(bDegrees == false && bMinutes == false && bSeconds == false)
    degreeValue = te::common::Convert2String(std::floor(degree), 0) + QString(degreeChar).toStdString() + " " + te::common::Convert2String(std::fabs(min), 0) + "' " + te::common::Convert2String(std::fabs(sec), precision) + "''";

  return degreeValue;
}

/*!
 * \brief Returns a pixmap with the values of the coordinates to be presented.
 *
 * \param transf WorldTransformer object previously created.
 *
 * \param lines The lines that are being processed
 *
 * \param painter A QPainter object previously configured with the the color and font to use on presentation.
 *
 * \param vertical Flag that sinalyzes if the pixmap is for the vertical lines or horizontal. (Depends on what lines are passed)
 *
 * \param top Flag that sinalyzes in wich side will be placed the pixmap: \a true -> top and right, \a false -> bottom and left.
 *
 * \param geoSrid The srid of the geodesic coordinate system to be used.
 *
 * \return The pixmap to be placed on top, bottom, left or right position.
 *
 * \note If the display is in a geodesic coordinate the \a geoSrid MUST be defined as a valor different of -1.
 */
QPixmap* GetTextsPixmap(WorldTransformer transf, const std::vector<te::gm::LineString>& lines, QPainter& painter,
                        const bool& vertical, const bool& top, const int& geoSrid)
{
  double x = 0,
      y = 0;
  int txtW = 0,
      txtH = 0;
  double lValue;
  QPainter p;
  QPixmap* res = nullptr;
  QPoint center;
  QRect subpixRect;
  QSize pixDimensions;
  QString sValue;
  std::vector<te::gm::LineString>::const_iterator it;
  size_t lineIdx;

  GetTextDimensions(painter.font(), "0", txtW, txtH);

  QSize displayDimensions(painter.device()->width(), painter.device()->height());

  if(vertical)
  {
    pixDimensions.setWidth(displayDimensions.width());
    pixDimensions.setHeight(txtH);
  }
  else
  {
    pixDimensions.setWidth(displayDimensions.height());
    pixDimensions.setHeight(txtH);
  }

  res = new QPixmap(pixDimensions);

  res->fill(Qt::transparent);

  p.begin(res);

  for(it = lines.cbegin(); it != lines.cend(); ++it)
  {
    std::unique_ptr<QPixmap> pixValue;

    te::gm::LineString line = *it;

    size_t nPts = line.getNPoints();

    lineIdx = (top) ?
                nPts - 1 :
                0;

    if(geoSrid != -1)
    {
      GetGeographicCoordLine(transf, line, geoSrid);
      x = line.getPointN(0)->getX();
      y = line.getPointN(0)->getY();
    }
    else
      transf.system2Tosystem1(line.getPointN(0)->getX(), line.getPointN(0)->getY(), x, y);

    lValue = (!vertical) ?
               y :
               x;

    sValue = QString::fromUtf8(ConvertDecimalToDegree(lValue, true, true, true, 3).c_str());

    pixValue.reset(GetTextPixmap(sValue, painter.font(), painter.pen()));

    subpixRect.setSize(pixValue->size());

    if(vertical)
    {
      center.setX(static_cast<int>((*it).getPointN(lineIdx)->getX()));
      center.setY(subpixRect.height()/2);
    }
    else
    {
      center.setX(static_cast<int>((*it).getPointN(lineIdx)->getY()));
      center.setY(subpixRect.height()/2);
    }

    subpixRect.moveCenter(center);

    p.drawPixmap(subpixRect, *pixValue.get());
  }

  return res;
}

/*!
 * \brief Sets the srid of a set of lines.
 *
 * \param lines The lines to be updated.
 *
 * \param srid The new srid to be used.
 *
 * \note This method just sets the srid of the lines. It DOES NOT make any coordinate transformations.
 */
void SetSRID(std::vector<te::gm::LineString>& lines, const int& srid)
{
  std::vector<te::gm::LineString>::iterator it;

  for(it = lines.begin(); it != lines.end(); ++it)
    (*it).setSRID(srid);
}

// --------------------------------------------------
// End geodesic grid functions
// --------------------------------------------------

// --------------------------------------------------
// End of utility functions.
// --------------------------------------------------

te::qt::widgets::Grid::Grid(MapDisplay* parent) :
  QFrame(parent, Qt::SubWindow),
  m_display(parent),
  m_maxGap(30),
  m_verticalGap(0),
  m_horizontalGap(0),
  m_initialX(0),
  m_initialY(0),
  m_backGround(nullptr),
  m_srid(-1),
  m_geoSrid(-1),
  m_color(Qt::black),
  m_font(QFont("times", 10)),
  m_type(PLANAR)
{
  setAttribute(Qt::WA_TranslucentBackground);

  initialize();

  redraw();

  connect(m_display, SIGNAL(drawLayersFinished(const QMap<QString, QString>&)), SLOT(redraw()));
}

te::qt::widgets::Grid::~Grid()
{
  delete m_backGround;
}

QColor te::qt::widgets::Grid::getColor() const
{
  return m_color;
}

QFont te::qt::widgets::Grid::getFont() const
{
  return m_font;
}

int te::qt::widgets::Grid::getType() const
{
  return m_type;
}

void te::qt::widgets::Grid::setColor(const QColor& color)
{
  m_color = color;

  redraw();
}

void te::qt::widgets::Grid::setFont(const QFont& font)
{
  m_font = font;

  redraw();
}

void te::qt::widgets::Grid::setGridType(const int& type)
{
  m_type = static_cast<GridTypes>(type);

  redraw();
}

void te::qt::widgets::Grid::redraw()
{
  switch (m_type)
  {
    case PLANAR:
      makePlanarGrid();
    break;

    case GEOGRAPHIC:
      makeGeographicGrid();
    break;
  }

  // Getting the size of the widget.
  QSize s = m_display->size();

  // Changing the widget dimensions.
  setFixedSize(s);
  setMinimumSize(s);

  // Deleting old image.
  delete m_backGround;
  m_backGround = nullptr;

  // Getting a transparent image.45
  m_backGround = GetCleanImage(s, Qt::transparent);

  // Configuring painter
  QPen pen(QBrush(m_color), 1);
  QPainter p(m_backGround);
  p.setPen(pen);
  p.setFont(m_font);

  te::gm::Envelope planarBox = m_display->getExtent(),
      viewport(0, 0, m_display->width(), m_display->height());

  if (m_display->getSRID() != m_srid)
    planarBox.transform(m_display->getSRID(), m_srid);

  WorldTransformer transf = GetTransformGeo(planarBox, viewport);
  transf.setMirroring(true);

  if(m_type == PLANAR)
  {
    DrawAllLines(transf, &p, m_vlines, m_hlines, m_font);
    DrawTexts(transf, &p, m_vlines, m_hlines, m_font);
  }
  else
  {
    std::vector<te::gm::LineString>::iterator it;
    QPainterPath path;

    for(it = m_vlines.begin(); it != m_vlines.end(); ++it)
    {
      te::gm::LineString line = *it;

      size_t nPts = line.getNPoints();

      for(size_t i = 0; i < nPts; i++)
      {
        if(i == 0)
          path.moveTo(line.getPointN(i)->getX(), line.getPointN(i)->getY());
        else
          path.lineTo(line.getPointN(i)->getX(), line.getPointN(i)->getY());
      }
    }

    for(it = m_hlines.begin(); it != m_hlines.end(); ++it)
    {
      te::gm::LineString line = *it;

      size_t nPts = line.getNPoints();

      for(size_t i = 0; i < nPts; i++)
      {
        if(i == 0)
          path.moveTo(line.getPointN(i)->getX(), line.getPointN(i)->getY());
        else
          path.lineTo(line.getPointN(i)->getX(), line.getPointN(i)->getY());
      }
    }

    SetSRID(m_vlines, m_srid);
    SetSRID(m_hlines, m_srid);

    p.drawPath(path);

    int oneMMPx = te::qt::widgets::MillimetersToPixels(p.device(), 1, false);

    std::unique_ptr<QPixmap> hori(GetTextsPixmap(transf, m_vlines, p, true, true, m_geoSrid));
    std::unique_ptr<QPixmap> hori2(GetTextsPixmap(transf, m_vlines, p, true, false, m_geoSrid));
    std::unique_ptr<QPixmap> vert(GetTextsPixmap(transf, m_hlines, p, false, true, m_geoSrid));
    std::unique_ptr<QPixmap> vert2(GetTextsPixmap(transf, m_hlines, p, false, false, m_geoSrid));

    p.drawPixmap(0, oneMMPx, *hori.get());
    p.drawPixmap(0, s.height() - hori2->height(), *hori2.get());

    double dx = 0,
        dy = 0;

    QRect devR;
    devR.setSize(s);

    dx = devR.center().x();
    dy = devR.center().y();

    // Drawing vertical labels
    p.save();
    p.translate(devR.center());
    p.rotate(90);
    p.translate(-dy, -dx);
    p.drawPixmap(oneMMPx, 0, *vert.get());

    p.drawPixmap(oneMMPx, 0, *vert.get());
    p.drawPixmap(oneMMPx, s.width() - vert2->height(), *vert2.get());

    p.restore();
  }

  // Repaint widget
  QFrame::update();
}

void te::qt::widgets::Grid::initialize()
{
  // Checks if is Geographic
  std::string authName = "EPSG"; // Now: So far it is the only one supported by TerraLib 5. Future: Review this line!
  bool isGeo = te::srs::SpatialReferenceSystemManager::getInstance().isGeographic(static_cast<unsigned int>(m_display->getSRID()), authName);

  // Storing the better zone to use.
  if(m_type == PLANAR)
  {
    m_srid = (isGeo) ?
               ToPlanar(m_display->getExtent(), m_display->getSRID()) :
               m_display->getSRID();
  }
  else
  {
    m_srid = (isGeo) ?
               m_display->getSRID() :
               ToGeographic(m_display->getExtent(), m_display->getSRID());
  }
}

void te::qt::widgets::Grid::makePlanarGrid()
{
  initialize();

  te::gm::Envelope bbox = m_display->getExtent();

  if (m_srid != m_display->getSRID())
    bbox.transform(m_display->getSRID(), m_srid);

  m_hlines.clear();
  m_vlines.clear();

  // Get the bounding rect of the visible area in planar system of coordinates.
  m_initialX = GetInitialCoord(bbox.getLowerLeftY(), bbox.getHeight(), m_horizontalGap);
  m_initialY = GetInitialCoord(bbox.getLowerLeftX(), bbox.getWidth(), m_verticalGap);

  // Getting the lines to build the grid.
  m_vlines = CalculateVerticalLines(bbox, m_initialY, m_verticalGap, m_maxGap);
  m_hlines = CalculateHorizontalLines(bbox, m_initialX, m_horizontalGap, m_maxGap);
}

void te::qt::widgets::Grid::makeGeographicGrid()
{
  int planarSRID = 0,
      geodesicSRID = 0;
  te::gm::Envelope bbox = m_display->getExtent();
  int srid = m_display->getSRID();

  initialize();

  bool isGeo = (srid == m_srid);
  te::gm::Envelope planarBox;
  te::gm::Envelope geographicBox;
  te::gm::Envelope referenceBoxMM(0, 0, width(), height());

  if(!isGeo)
  {
    geodesicSRID = m_srid;
    planarSRID = ToPlanar(bbox, srid);
    m_geoSrid = geodesicSRID;

    geographicBox = WorldBoxTo(bbox, srid, m_geoSrid);
    planarBox = WorldBoxTo(geographicBox, geodesicSRID, planarSRID);
  }
  else
  {
    planarSRID = -1;
    geodesicSRID = m_srid;
    m_geoSrid = geodesicSRID;
    geographicBox = bbox;
  }

  m_hlines.clear();
  m_vlines.clear();

  if (!bbox.isValid())
    return;

  // Optimized way to reproject a box, between source and destination projections.
  //Box required to draw curvature
  if (!geographicBox.isValid())
    return;

  // Get the bounding rect of the visible area in planar system of coordinates.
  m_initialX = GetInitialCoord(geographicBox.getLowerLeftY(), geographicBox.getHeight(), m_horizontalGap);
  m_initialY = GetInitialCoord(geographicBox.getLowerLeftX(), geographicBox.getWidth(), m_verticalGap);

  m_vlines = CalculateVerticalLines(planarBox, geographicBox, referenceBoxMM, m_initialY, m_verticalGap, m_maxGap, planarSRID, geodesicSRID);
  m_hlines = CalculateHorizontalLines(planarBox, geographicBox, referenceBoxMM, m_initialX, m_horizontalGap, m_maxGap, planarSRID, geodesicSRID);
}

void te::qt::widgets::Grid::paintEvent(QPaintEvent* event)
{
  QPainter p(this);

  p.drawPixmap(0, 0, *m_backGround);

  QFrame::paintEvent(event);
}

void te::qt::widgets::Grid::closeEvent(QCloseEvent* event)
{
  emit aboutToBeclosed();

  QFrame::closeEvent(event);
}