src/terralib/maptools/Utils.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 terralib/maptools/Utils.cpp
   
  \brief Utility functions for MapTools module.
*/

// TerraLib
#include "../common/progress/TaskProgress.h"
#include "../core/translator/Translator.h"
#include "../common/STLUtils.h"
#include "../common/StringUtils.h"
#include "../dataaccess/dataset/DataSetType.h"
#include "../dataaccess/query/And.h"
#include "../dataaccess/query/DataSetName.h"
#include "../dataaccess/query/Field.h"
#include "../dataaccess/query/LiteralEnvelope.h"
#include "../dataaccess/query/PropertyName.h"
#include "../dataaccess/query/Select.h"
#include "../dataaccess/query/ST_Intersects.h"
#include "../dataaccess/query/Where.h"
#include "../dataaccess/utils/Utils.h"
#include "../fe/Literal.h"
#include "../geometry/GeometryProperty.h"
#include "../geometry/Utils.h"
#include "../memory/DataSet.h"
#include "../raster/Grid.h"
#include "../raster/Raster.h"
#include "../raster/RasterFactory.h"
#include "../raster/RasterProperty.h"
#include "../raster/RasterSummary.h"
#include "../raster/RasterSummaryManager.h"
#include "../raster/Utils.h"
#include "../se/ChannelSelection.h"
#include "../se/CoverageStyle.h"
#include "../se/FeatureTypeStyle.h"
#include "../se/ImageOutline.h"
#include "../se/RasterSymbolizer.h"
#include "../se/Rule.h"
#include "../se/Utils.h"
#include "../srs/Config.h"
#include "../srs/Converter.h"
#include "../srs/SpatialReferenceSystemManager.h"

#include "Canvas.h"
#include "CanvasConfigurer.h"
#include "Chart.h"
#include "DataSetLayer.h"
#include "Exception.h"
#include "Grouping.h"
#include "QueryEncoder.h"
#include "RasterContrast.h"
#include "RasterTransform.h"
#include "RasterTransformConfigurer.h"
#include "Utils.h"

// Boost
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

// STL
#include <cassert>
#include <cstdlib>
#include <memory>

#ifndef TeCDR
#define TeCDR 0.01745329251994329576    //!< Conversion factor: degrees to radians
#endif

#ifndef TeCRD
#define TeCRD 57.29577951308232087679  //!< Conversion factor: radians to degrees
#endif

te::gm::Envelope te::map::GetSelectedExtent(const std::list<te::map::AbstractLayerPtr> layers, int srid, bool onlyVisibles)
{
  std::list<te::map::AbstractLayerPtr>::const_iterator it = layers.begin();

  te::gm::Envelope finalEnv;

  while(it != layers.end())
  {
    if(it == layers.begin())
      finalEnv = GetSelectedExtent((*it), srid, onlyVisibles);
    else
      finalEnv.Union(GetSelectedExtent((*it), srid, onlyVisibles));

    ++it;
  }

  return finalEnv;
}

te::gm::Envelope te::map::GetSelectedExtent(const te::map::AbstractLayerPtr layer, int srid, bool onlyVisibles)
{
  if(onlyVisibles && layer->getVisibility() == te::map::NOT_VISIBLE)
    return te::gm::Envelope();

  te::gm::Envelope finalEnv;

  bool isFirst = true;

  if(!layer->hasChildren())
  {
    std::unique_ptr<te::da::DataSetType> dt(layer->getSchema());

    const te::da::ObjectIdSet* objSet = layer->getSelected();

    if(!objSet)
      return te::gm::Envelope();

    std::unique_ptr<te::da::DataSet> ds(layer->getData(objSet));

    te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dt.get());

    while(ds->moveNext())
    {
      if (ds->isNull(geomProp->getName()))
        continue;

      std::unique_ptr<te::gm::Geometry> geom = ds->getGeometry(geomProp->getName());

      te::gm::Envelope auxEnv(*geom->getMBR());

      if(layer->getSRID() != srid)
        auxEnv.transform(layer->getSRID(), srid);

      if(isFirst)
      {
        finalEnv = auxEnv;
        isFirst = false;
        continue;
      }

      finalEnv.Union(auxEnv);
    }
  }
  else
  {
    for(std::size_t i = 0; i < layer->getChildrenCount(); ++i)
    {
      te::map::AbstractLayerPtr child(boost::dynamic_pointer_cast<AbstractLayer>(layer->getChild(i)));
      
      if(i == 0)
        finalEnv = GetSelectedExtent(child, srid, onlyVisibles);
      else
        finalEnv.Union(GetSelectedExtent(child, srid, onlyVisibles));
    }
  }

  return finalEnv;
}

void te::map::GetDashStyle(const std::string& dasharray, std::vector<double>& style)
{
  std::vector<std::string> values;
  te::common::Tokenize(dasharray, values);
  for(std::size_t i = 0; i < values.size(); ++i)
    style.push_back(atof(values[i].c_str()));
}

te::rst::RasterProperty* te::map::GetRasterProperty(AbstractLayer* layer)
{
  if(layer == nullptr)
    throw Exception(TE_TR("The layer is invalid!"));

// name of referenced data set
  std::string dsname = layer->getDataSetName();

  if(dsname.empty())
    throw Exception(TE_TR("The data set name referenced by the layer is empty!"));

// retrieve the associated data source
  te::da::DataSourcePtr ds = te::da::GetDataSource(layer->getDataSourceId(), true);

// gets the data set type 
  std::unique_ptr<te::da::DataSetType> dstype(ds->getDataSetType(dsname));

  if(dstype.get() == nullptr)
    throw Exception(TE_TR("Could not get the data set type!"));

// gets the raster property
  std::unique_ptr<te::rst::RasterProperty> rasterProperty(dynamic_cast<te::rst::RasterProperty*>(dstype->getProperties()[0]->clone()));

  if(rasterProperty.get() == nullptr)
     throw Exception(TE_TR("Could not get the raster property!"));

  return rasterProperty.release();
}

te::rst::Raster* te::map::GetRaster(AbstractLayer* layer)
{
  if(layer == nullptr)
    throw Exception(TE_TR("The layer is invalid!"));

  std::unique_ptr<te::da::DataSet> dataset(layer->getData());

  if (dataset.get() == nullptr)
    throw Exception(TE_TR("Could not get the data set reference by the layer!"));


  std::size_t rpos = te::da::GetFirstPropertyPos(dataset.get(), te::dt::RASTER_TYPE);

  dataset->moveFirst();

  std::unique_ptr<te::da::DataSetType> dsType = layer->getSchema();
  std::unique_ptr<te::rst::Raster> raster = dataset->getRaster(rpos);

  if (raster.get() == nullptr)
    throw Exception(TE_TR("Could not get the raster referenced by the layer!"));

  //get visual information
  te::se::Style* style = layer->getStyle();

  if (style == nullptr || style->getRules().empty())
  {
    // try create an appropriate style
    te::rst::RasterProperty* rasterProperty = te::da::GetFirstRasterProperty(dsType.get());

    style = te::se::CreateCoverageStyle(rasterProperty->getBandProperties());

    if (style == 0)
      throw Exception(TE_TR("Could not get the raster style referenced by the layer!"));

    layer->setStyle(style);
  }

  // for while, consider one rule
  const te::se::Rule* rule = style->getRule(0);

  const std::vector<te::se::Symbolizer*>& symbolizers = rule->getSymbolizers();

  if (symbolizers.empty())
    throw Exception(TE_TR("Could not get the symbolizers referenced by the rule!"));

  // for while, consider one raster symbolizer
  te::se::RasterSymbolizer* rasterSymbolizer = dynamic_cast<te::se::RasterSymbolizer*>(symbolizers[0]);

  if (rasterSymbolizer == nullptr)
    throw Exception(TE_TR("Could not get the raster symbolizers referenced by the style!"));

  if (rasterSymbolizer->getNoDataValue())
  {
    double noDataValue = te::se::GetDouble(rasterSymbolizer->getNoDataValue());

    for (std::size_t t = 0; t < raster->getNumberOfBands(); ++t)
    {
      te::rst::BandProperty* bp = raster->getBand(t)->getProperty();
      bp->m_noDataValue = noDataValue;
    }
  }

//set srid information
  raster->getGrid()->setSRID(layer->getSRID());

  return raster.release();
}

void te::map::GetVisibleLayers(const te::map::AbstractLayerPtr& layer, std::list<te::map::AbstractLayerPtr>& visibleLayers)
{
  te::map::Visibility visibility = layer->getVisibility();

  if(visibility == te::map::NOT_VISIBLE)
    return;

  if(visibility == te::map::VISIBLE && layer->isValid())
    visibleLayers.push_back(layer);

  for(std::size_t i = 0; i < layer->getChildrenCount(); ++i)
  {
    te::map::AbstractLayerPtr child(boost::dynamic_pointer_cast<AbstractLayer>(layer->getChild(i)));

    GetVisibleLayers(child, visibleLayers);
  }
}

void te::map::GetVisibleLayers(const std::list<te::map::AbstractLayerPtr>& layers, std::list<te::map::AbstractLayerPtr>& visibleLayers)
{
  for(std::list<te::map::AbstractLayerPtr>::const_iterator it = layers.begin(); it != layers.end(); ++it)
    GetVisibleLayers(*it, visibleLayers);
}

te::gm::Envelope te::map::GetExtent(const std::list<te::map::AbstractLayerPtr>& layers, int srid, bool onlyVisibles)
{
  te::gm::Envelope e;

  for(std::list<te::map::AbstractLayerPtr>::const_iterator it = layers.begin(); it != layers.end(); ++it)
    e.Union(GetExtent(*it, srid, onlyVisibles));

  return e;
}

te::gm::Envelope te::map::GetExtent(const  te::map::AbstractLayerPtr& layer, int srid, bool onlyVisibles)
{
  if(onlyVisibles && layer->getVisibility() == te::map::NOT_VISIBLE)
    return te::gm::Envelope();

  te::gm::Envelope e = layer->getExtent();

  if((layer->getSRID() != TE_UNKNOWN_SRS) && (srid != TE_UNKNOWN_SRS))
    e.transform(layer->getSRID(), srid);

  for(std::size_t i = 0; i < layer->getChildrenCount(); ++i)
  {
    te::map::AbstractLayerPtr child(boost::dynamic_pointer_cast<AbstractLayer>(layer->getChild(i)));
    e.Union(GetExtent(child, srid, onlyVisibles));
  }

  return e;
}

te::da::DataSet* te::map::DataSet2Memory(te::da::DataSet* dataset)
{
  assert(dataset);

  if(!dataset->moveNext())
    throw Exception(TE_TR("Could not copy the data set to memory!"));

  return new te::mem::DataSet(*dataset);
}

void te::map::DrawGeometries(te::da::DataSetType* type, te::da::DataSourcePtr ds,
                             Canvas* canvas, const te::gm::Envelope& bbox, int bboxSRID,
                             int srid, te::se::FeatureTypeStyle* style)
{
  assert(type);
  assert(type->hasGeom());
  assert(canvas);
  assert(bbox.isValid());
  assert(style);

  const std::string& datasetName = type->getName();
  assert(!datasetName.empty());

// for while, default geometry. TODO: need a visitor to get which properties the style references
  te::gm::GeometryProperty* geometryProperty = te::da::GetFirstGeomProperty(type);

// create a canvas configurer
  te::map::CanvasConfigurer cc(canvas);

// number of rules defined on feature type style
  std::size_t nRules = style->getRules().size();

  for(std::size_t i = 0; i < nRules; ++i) // for each <Rule>
  {
// the current rule
    const te::se::Rule* rule = style->getRule(i);
    assert(rule);

// TODO: should be verified the MinScaleDenominator and MaxScaleDenominator. Where will we put the current scale information? Method parameter?

// gets the rule filter
    const te::fe::Filter* filter = rule->getFilter();

// let's retrieve the correct dataset
    std::unique_ptr<te::da::DataSet> dataset;
    if(!filter)
    {
// there isn't a Filter expression. Gets the dataset using only box restriction...
      dataset = ds->getDataSet(datasetName, geometryProperty->getName(), &bbox, te::gm::INTERSECTS);
    }
    else
    {
// get an enconder
      te::map::QueryEncoder queryConverter; 

// convert the Filter expression to a TerraLib Expression!
      te::da::Expression* exp = queryConverter.getExpression(filter);
      if(exp == nullptr)
        throw Exception(TE_TR("Could not convert the OGC Filter expression to TerraLib expression!"));

/* 1) Creating te::da::Where object with this expression + box restriction */

// the box restriction
      te::da::LiteralEnvelope* lenv = new te::da::LiteralEnvelope(bbox, srid);
      te::da::PropertyName* geometryPropertyName = new te::da::PropertyName(geometryProperty->getName());
      te::da::ST_Intersects* intersects = new te::da::ST_Intersects(geometryPropertyName, lenv);

// combining the expressions (Filter expression + box restriction)
      te::da::And* finalRestriction = new te::da::And(exp, intersects);
      
      te::da::Where* wh = new te::da::Where(exp);
      wh->setExp(finalRestriction);

// fields
      te::da::Fields* all = new te::da::Fields;
      all->push_back(new te::da::Field("*"));

// from
      te::da::FromItem* fi = new te::da::DataSetName(datasetName);
      te::da::From* from = new te::da::From;
      from->push_back(fi);

// build the Select
      te::da::Select select(all, from, wh);

/* 2) Calling the datasource query method to get the correct restricted dataset. */
      dataset = ds->query(select);
    }

    if(dataset.get() == nullptr)
      throw Exception((boost::format(TE_TR("Could not retrieve the data set %1%.")) % datasetName).str());

    if(dataset->moveNext() == false)
      continue;

// get the set of symbolizers defined on current rule
    const std::vector<te::se::Symbolizer*>& symbolizers = rule->getSymbolizers();
    std::size_t nSymbolizers = symbolizers.size();

// build task message; e.g. ("Drawing the dataset Countries. Rule 1 of 3.")
    std::string message = TE_TR("Drawing the dataset");
    message += " " + datasetName + ". ";
    message += TE_TR("Rule");
    message += " " + boost::lexical_cast<std::string>(i + 1) + " " + TE_TR("of") + " ";
    message += boost::lexical_cast<std::string>(nRules) + ".";

// create a draw task
    te::common::TaskProgress task(message, te::common::TaskProgress::DRAW);
    //task.setTotalSteps(nSymbolizers * dataset->size()); // Removed! The te::da::DataSet size() method would be too costly to compute.

    for(std::size_t j = 0; j < nSymbolizers; ++j) // for each <Symbolizer>
    {
// the current symbolizer
      te::se::Symbolizer* symb = symbolizers[j];

// let's config de canvas based on the current symbolizer
      cc.config(symb);

// for while, first geometry. TODO: get which property the symbolizer references
      std::size_t gpos = te::da::GetFirstPropertyPos(dataset.get(), te::dt::GEOMETRY_TYPE);

// let's draw! for each data set geometry...
      DrawGeometries(dataset.get(), gpos, canvas, bboxSRID, srid, &task);

// prepare to draw the other symbolizer
      dataset->moveFirst();

    } // end for each <Symbolizer>

  }   // end for each <Rule>
}

void te::map::DrawGeometries(te::da::DataSet* dataset, const std::size_t& gpos, Canvas* canvas, int fromSRID, int toSRID, te::common::TaskProgress* task)
{
  assert(dataset);
  assert(canvas);

// verify if is necessary convert the data set geometries to the given srid
  bool needRemap = false;
  if((fromSRID != TE_UNKNOWN_SRS) && (toSRID != TE_UNKNOWN_SRS) && (fromSRID != toSRID))
    needRemap = true;

  do
  {
    if(task)
    {
      if(!task->isActive())
        return;

      // update the draw task
      task->pulse();
    }

    std::unique_ptr<te::gm::Geometry> geom;
    try
    {
      geom = dataset->getGeometry(gpos);
      if(geom.get() == nullptr)
        continue;
    }
    catch(std::exception& /*e*/)
    {
      continue;
    }

// if necessary, geometry remap
    if(needRemap)
    {
      geom->setSRID(fromSRID);
      geom->transform(toSRID);
    }

    canvas->draw(geom.get());

  }while(dataset->moveNext()); // next geometry!
}

void te::map::DrawRaster(te::da::DataSetType* type, te::da::DataSourcePtr ds, Canvas* canvas,
  const te::gm::Envelope& bbox, int bboxSRID, const te::gm::Envelope& visibleArea, int srid, te::se::CoverageStyle* style, te::map::RasterContrast* rc, const double& scale, bool* cancel)
{
  assert(type);
  assert(type->hasRaster());
  assert(canvas);
  assert(bbox.isValid());
  assert(visibleArea.isValid());
  assert(style);

  const std::string& datasetName = type->getName();
  assert(!datasetName.empty());

// for while, first raster property
  te::rst::RasterProperty* rasterProperty = te::da::GetFirstRasterProperty(type);

// retrieve the data set
  std::unique_ptr<te::da::DataSet> dataset(ds->getDataSet(datasetName, rasterProperty->getName(), &bbox, te::gm::INTERSECTS));
  if(dataset.get() == nullptr)
    throw Exception((boost::format(TE_TR("Could not retrieve the data set %1%.")) % datasetName).str());

// retrieve the raster
  std::size_t rpos = te::da::GetFirstPropertyPos(dataset.get(), te::dt::RASTER_TYPE);
  std::unique_ptr<te::rst::Raster> raster(dataset->getRaster(rpos));
  if(dataset.get() == nullptr)
    throw Exception((boost::format(TE_TR("Could not retrieve the raster from the data set %1%.")) % datasetName).str());

  DrawRaster(raster.get(), canvas, bbox, bboxSRID, visibleArea, srid, style, rc, scale, cancel);
}

void te::map::DrawRaster(te::rst::Raster* raster, Canvas* canvas, const te::gm::Envelope& /*bbox*/, int bboxSRID,
  const te::gm::Envelope& visibleArea, int srid, te::se::CoverageStyle* style, te::map::RasterContrast* rc, const double& scale, bool* cancel)
{
  // for while, consider one rule
  const te::se::Rule* rule = style->getRule(0);

  if (!(scale >= rule->getMinScaleDenominator() && scale < rule->getMaxScaleDenominator()))
  {
    return;
  }

// build the grid canvas. i.e. a grid with canvas dimensions and requested mbr
  te::gm::Envelope* gmbr = new te::gm::Envelope(visibleArea);
  std::unique_ptr<te::rst::Grid> gridCanvas(new te::rst::Grid(static_cast<unsigned int>(canvas->getWidth()), static_cast<unsigned int>(canvas->getHeight()), gmbr, srid));

// compute the best level
  te::gm::Envelope* visibleAreaRasterProj = new te::gm::Envelope(visibleArea);
  visibleAreaRasterProj->transform(srid, bboxSRID);

  double resx = visibleAreaRasterProj->getWidth() / static_cast<double>(canvas->getWidth());
  double resy = visibleAreaRasterProj->getHeight() / static_cast<double>(canvas->getHeight());

  double rx = resx / raster->getResolutionX();
  double ry = resy / raster->getResolutionY();

  double factor = std::min(rx, ry);
  factor = std::max(factor, 1.0);

  std::size_t level = static_cast<std::size_t>(std::log(factor) / std::log(2.0));

// get the raster overview
  te::rst::Raster* overview = raster;
  bool needDelete = false;
  std::size_t numberOfLevels = raster->getMultiResLevelsCount();
  if(level != 0 && numberOfLevels != 0) // need overview? has overview?
  {
    if(numberOfLevels >= level)
      overview = raster->getMultiResLevel(static_cast<unsigned int>(level - 1));
    else 
      overview = raster->getMultiResLevel(static_cast<unsigned int>(numberOfLevels - 1));

    assert(overview);

    //adjust raster overview parameters

    if (raster->getNumberOfBands() == overview->getNumberOfBands())
    {
      for (std::size_t t = 0; t < raster->getNumberOfBands(); ++t)
      {
        te::rst::BandProperty* bp = raster->getBand(t)->getProperty();
        te::rst::BandProperty* bpOverView = overview->getBand(t)->getProperty();
        bpOverView->m_noDataValue = bp->m_noDataValue;
      }
    }

    overview->getGrid()->setSRID(raster->getSRID());

    needDelete = true;
  }

// create a raster transform
  RasterTransform rasterTransform(overview, nullptr);

//check band data type
  if(raster->getBandDataType(0) != te::dt::UCHAR_TYPE)
  {
    // raster min / max values
    for (int b = 0; b < static_cast<int>(raster->getNumberOfBands()); b++)
    {
      const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(raster, te::rst::SUMMARY_MIN, true);
      const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(raster, te::rst::SUMMARY_MAX, true);
      const std::complex<double>* cmin = rsMin->at(b).m_minVal;
      const std::complex<double>* cmax = rsMax->at(b).m_maxVal;
      double min = cmin->real();
      double max = cmax->real();

      rasterTransform.setLinearTransfParameters(min, max, 0, 255, b);
    }
  }
  else
  {
    rasterTransform.setLinearTransfParameters(0, 255, 0, 255);
  }

  const std::vector<te::se::Symbolizer*>& symbolizers = rule->getSymbolizers();
  assert(!symbolizers.empty());

// for while, consider one raster symbolizer
  te::se::RasterSymbolizer* rasterSymbolizer = dynamic_cast<te::se::RasterSymbolizer*>(symbolizers[0]);
  assert(rasterSymbolizer);

// configure the raster transformation based on the raster symbolizer
  RasterTransformConfigurer rtc(rasterSymbolizer, &rasterTransform);
  rtc.configure();

  if (rc)
  {
    int type = rc->getType();

    std::vector<double> gain;
    std::vector<double> offset1;
    std::vector<double> offset2;
    std::vector<double> min;
    std::vector<double> max;
    rc->getValues(gain, offset1, offset2, min, max);

    rasterTransform.setContrastType(static_cast<te::map::RasterTransform::ContrastType>(type));
    rasterTransform.setContrastGainsAndOffsets(gain, offset1, offset2);
  }

// verify if is necessary convert the raster to the given srid
  bool needRemap = false;
  if((bboxSRID != TE_UNKNOWN_SRS) && (srid != TE_UNKNOWN_SRS) && (bboxSRID != srid))
    needRemap = true;

// build task message; e.g. ("Drawing the raster cbers_sao_jose_dos_campos.")
  std::string message = TE_TR("Drawing raster");
  const std::string& rasterName = raster->getName();
  !rasterName.empty() ? message += " " + raster->getName() + ". " : message += ".";

// create the draw task
  te::common::TaskProgress task(message, te::common::TaskProgress::DRAW, static_cast<int>(gridCanvas->getNumberOfRows()));

// create a RGBA array that will be drawn in the canvas. i.e. This array is the result of the render process.
  //te::color::RGBAColor** rgba = new te::color::RGBAColor*[gridCanvas->getNumberOfRows()];

// create a RGBA array that will be drawn in the canvas. i.e. This array represents a row of the render process.
  te::color::RGBAColor** row = new te::color::RGBAColor*[1];
  te::color::RGBAColor* columns = new te::color::RGBAColor[gridCanvas->getNumberOfColumns()];
  row[0] = columns;

// create a SRS converter
  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());
    
  if(needRemap)
  {
    converter->setSourceSRID(srid);
    converter->setTargetSRID(bboxSRID);
  }

// fill the result RGBA array
  for(unsigned int r = 0; r < gridCanvas->getNumberOfRows(); ++r)
  {
    for(unsigned int c = 0; c < gridCanvas->getNumberOfColumns(); ++c)
    {
      te::gm::Coord2D inputGeo = gridCanvas->gridToGeo(c, r);

      if(needRemap)
        converter->convert(inputGeo.x, inputGeo.y, inputGeo.x, inputGeo.y);

      te::gm::Coord2D outputGrid = overview->getGrid()->geoToGrid(inputGeo.x, inputGeo.y);

// TODO: round or truncate?
      int x = te::rst::Round(outputGrid.x);
      int y = te::rst::Round(outputGrid.y);

      te::color::RGBAColor color(0, 0, 0, 0);

      if((x >= 0 && x < static_cast<int>(overview->getNumberOfColumns())) &&
         (y >= 0 && y < static_cast<int>(overview->getNumberOfRows())))
           color = rasterTransform.apply(x, y);

      columns[c] = color;
    }

    //rgba[r] = columns;

    if(!task.isActive())
    {
// draw the part of result
      //canvas->drawImage(0, 0, rgba, canvas->getWidth(), r + 1);
      canvas->drawImage(0, static_cast<int>(r), row, canvas->getWidth(), 1);

// free memory
      //te::common::Free(rgba, r + 1);
      te::common::Free(row, 1);

      *cancel = true;

      return;
    }

    if (cancel != nullptr && (*cancel))
      return;

    canvas->drawImage(0, static_cast<int>(r), row, canvas->getWidth(), 1);

    task.pulse();
  }

  if(needDelete)
    delete overview;

// put the result in the canvas
  //canvas->drawImage(0, 0, rgba, canvas->getWidth(), canvas->getHeight());

// free memory
  //te::common::Free(rgba, gridCanvas->getNumberOfRows());
  te::common::Free(row, 1);

// image outline
  if(rasterSymbolizer->getImageOutline() == nullptr)
    return;

// get the symbolizer that will be used to draw the image outline
  te::se::Symbolizer* outlineSymbolizer = rasterSymbolizer->getImageOutline()->getSymbolizer();
  if(outlineSymbolizer == nullptr)
    return;

// create a canvas configurer
  te::map::CanvasConfigurer cc(canvas);
  cc.config(outlineSymbolizer);

// creates the image outline
  std::unique_ptr<te::gm::Geometry> geom(te::gm::GetGeomFromEnvelope(raster->getExtent(), bboxSRID));
  if(needRemap)
  {
    geom->setSRID(bboxSRID);
    geom->transform(srid);
  }

  canvas->draw(geom.get());
}

te::rst::Raster* te::map::GetExtentRaster(te::rst::Raster* raster, int w, int h, const te::gm::Envelope& /*bbox*/, int bboxSRID,
                         const te::gm::Envelope& visibleArea, int srid)
{
  std::vector<te::rst::BandProperty*> bprops;

  for(size_t t = 0; t < raster->getNumberOfBands(); ++t)
  {
    te::rst::Band* band = raster->getBand(t);

    te::rst::BandProperty* bp = new te::rst::BandProperty(t, band->getProperty()->getType(), "");

    bprops.push_back(bp);
  }

// build the grid canvas. i.e. a grid with canvas dimensions and requested mbr
  te::gm::Envelope* gmbr = new te::gm::Envelope(visibleArea);
  te::rst::Grid* gridCanvas = new te::rst::Grid(static_cast<unsigned int>(w), static_cast<unsigned int>(h), gmbr, srid);

//build output raster
  te::rst::Raster* rasterOut = te::rst::RasterFactory::make("MEM", gridCanvas, bprops, std::map<std::string, std::string>());

// verify if is necessary convert the raster to the given srid
  bool needRemap = false;
  if((bboxSRID != TE_UNKNOWN_SRS) && (srid != TE_UNKNOWN_SRS) && (bboxSRID != srid))
    needRemap = true;

// create a SRS converter
  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());
    
  if(needRemap)
  {
    converter->setSourceSRID(srid);
    converter->setTargetSRID(bboxSRID);
  }

// fill the result RGBA array
  for(unsigned int r = 0; r < gridCanvas->getNumberOfRows(); ++r)
  {
    for(unsigned int c = 0; c < gridCanvas->getNumberOfColumns(); ++c)
    {
      te::gm::Coord2D inputGeo = gridCanvas->gridToGeo(c, r);

      if(needRemap)
        converter->convert(inputGeo.x, inputGeo.y, inputGeo.x, inputGeo.y);

      te::gm::Coord2D outputGrid = raster->getGrid()->geoToGrid(inputGeo.x, inputGeo.y);

// TODO: round or truncate?
      int x = te::rst::Round(outputGrid.x);
      int y = te::rst::Round(outputGrid.y);

      if((x >= 0 && x < static_cast<int>(raster->getNumberOfColumns())) &&
         (y >= 0 && y < static_cast<int>(raster->getNumberOfRows())))
      {
        std::vector<double> values;
        raster->getValues(static_cast<unsigned int>(x), static_cast<unsigned int>(y), values);
        rasterOut->setValues(c, r, values);
      }
    }
  }

  return rasterOut;
}

te::gm::GeomType te::map::GetGeomType(const  te::map::AbstractLayerPtr& layer)
{
  assert(layer.get());

  std::unique_ptr<te::map::LayerSchema> schema(layer->getSchema());

  te::gm::GeometryProperty* geometryProperty = te::da::GetFirstGeomProperty(schema.get());
  assert(geometryProperty);

  te::gm::GeomType gtype = geometryProperty->getGeometryType();

  switch(gtype)
  {
    case te::gm::UnknownGeometryType:
    case te::gm::GeometryType:
    case te::gm::GeometryZType:
    case te::gm::GeometryMType:
    case te::gm::GeometryZMType:
      break;

    default:
      return gtype;
  }

  // Here, tries fetch a geometry and retrieve its type

  std::unique_ptr<te::da::DataSet> dataset(layer->getData());
  assert(dataset.get());

  dataset->moveNext();

  std::size_t gpos = te::da::GetFirstPropertyPos(dataset.get(), te::dt::GEOMETRY_TYPE);

  std::unique_ptr<te::gm::Geometry> g(dataset->getGeometry(gpos));
  assert(g.get());

  return g->getGeomTypeId();
}

te::gm::Envelope te::map::GetWorldBoxInPlanar(const te::gm::Envelope& worldBox, int srid)
{
  te::gm::Envelope worldBoxPlanar = 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>(srid), authName);
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(srid), authName);

  if(!unitPtr)
    return worldBoxPlanar;

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

  if(unitPtrStr.compare("DEGREE") == 0)
  {
    int zone = CalculatePlanarZone(worldBox);
    std::string proj4 = GetUTMProj4FromZone(zone);

    // Get the id of the projection of destination
    std::pair<std::string, unsigned int> projPlanar = te::srs::SpatialReferenceSystemManager::getInstance().getIdFromP4Txt(proj4);

    // Remapping
    worldBoxPlanar.transform(srid, static_cast<int>(projPlanar.second));
  }

  return worldBoxPlanar;
}

int te::map::CalculatePlanarZone( te::gm::Envelope latLongBox )
{
  double longitude = latLongBox.getCenter().x;
  int meridiano = static_cast<int>(longitude / 6);
  meridiano = meridiano * 6;

  meridiano = abs(meridiano) + 3;

  double long0 = -meridiano * TeCDR;

  // TeUTM T4
  int zone = (static_cast<int>((long0*TeCRD+183.0)/6.0));

  return zone;
}

std::string te::map::GetUTMProj4FromZone( int zone )
{
  /*
  PROJ4
  +proj      Projection name
  +datum  Datum name
  +lat_0    Latitude of origin
  +lon_0   Central meridian
  +x_0       False easting
  +y_0       False northing
  +lat_1     Latitude of first standard parallel
  +lat_2     Latitude of second standard parallel
  +units     meters, US survey feet, etc.
  +lat_ts    Latitude of true scale
  +south   Denotes southern hemisphere UTM zone
  +no_defs Don't use the /usr/share/proj/proj_def.dat defaults file
  */

  std::stringstream szone;
  szone << zone;

  std::string proj4 = "+proj=utm";
  proj4+= " +zone="+ szone.str();
  proj4+= " +south"; // pode ser +north?
  proj4+= " +ellps=aust_SA";
  proj4+= " +towgs84=-57,1,-41,0,0,0,0";
  proj4+= " +units=m";
  proj4+= " +no_defs ";

  return proj4;
}

void te::map::CopyAbstractLayerInfo(const te::map::AbstractLayer* refLayer, te::map::AbstractLayer* layer)
{
  boost::uuids::basic_random_generator<boost::mt19937> gen;
  boost::uuids::uuid u = gen();
  std::string id = boost::uuids::to_string(u);

  layer->setId(id);
  layer->setTitle(refLayer->getTitle());
  layer->setExtent(refLayer->getExtent());
  layer->setSRID(refLayer->getSRID());
  layer->setVisibility(refLayer->getVisibility());

  te::se::Style* style = refLayer->getStyle();
  layer->setStyle(style ? style->clone() : nullptr);

  te::se::Style* selectionStyle = refLayer->getSelectionStyle();
  layer->setSelectionStyle(selectionStyle ? selectionStyle->clone() : nullptr);

  te::map::Grouping* grouping = refLayer->getGrouping();
  layer->setGrouping(grouping ? grouping->clone() : nullptr);

  te::map::Chart* chart = refLayer->getChart();
  layer->setChart(chart ? chart->clone() : nullptr);

  te::map::RasterContrast* rasterContrast = refLayer->getRasterContrast();
  layer->setRasterContrast(rasterContrast ? new te::map::RasterContrast(*rasterContrast) : nullptr);

  layer->setGeomPropertytName(refLayer->getGeomPropertyName());
  layer->setCompositionMode(refLayer->getCompositionMode());
  layer->setDataSetName(refLayer->getDataSetName());
  layer->setDataSourceId(refLayer->getDataSourceId());
  layer->setEncoding(refLayer->getEncoding());
}