GeometricOpMemory.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 GeographicOpMemory.h

  \brief Geographic Vector Processing functions.
*/

//Terralib
#include "../core/logger/Logger.h"
#include "../core/translator/Translator.h"

#include "../dataaccess/dataset/DataSetAdapter.h"
#include "../dataaccess/datasource/DataSourceFactory.h"
#include "../dataaccess/utils/Utils.h"

#include "../geometry/GeometryProperty.h"
#include "../geometry/GeometryCollection.h"
#include "../geometry/LineString.h"
#include "../geometry/MultiLineString.h"
#include "../geometry/MultiPolygon.h"
#include "../geometry/Point.h"
#include "../geometry/Polygon.h"
#include "../geometry/Utils.h"

#include "../memory/DataSet.h"
#include "../memory/DataSetItem.h"

#include "GeometricOpMemory.h"
#include "Utils.h"

// STL
#include <map>

// BOOST
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>

te::vp::GeometricOpMemory::GeometricOpMemory() = default;

te::vp::GeometricOpMemory::~GeometricOpMemory() = default;

bool te::vp::GeometricOpMemory::run() throw(te::common::Exception)
{
// get the geometric operation and/or tabular operation. 
  std::vector<int> opGeom;
  std::vector<int> opTab;
  std::vector<te::da::DataSetType*> dsTypeVec;

  for(std::size_t i = 0; i < m_operations.size(); ++i)
  {
    switch (m_operations[i])
    {
    case te::vp::CENTROID:
      opGeom.push_back(te::vp::CENTROID);
      break;
    case te::vp::CONVEX_HULL:
      opGeom.push_back(te::vp::CONVEX_HULL);
      break;
    case te::vp::MBR:
      opGeom.push_back(te::vp::MBR);
      break;
    case te::vp::AREA:
      opTab.push_back(te::vp::AREA);
      break;
    case te::vp::LINE:
      opTab.push_back(te::vp::LINE);
      break;
    case te::vp::PERIMETER:
      opTab.push_back(te::vp::PERIMETER);
      break;
    default:
      {
        TE_LOG_INFO("Vector Processing - Geometric Operation - The operation is not valid.");
      }
    }
  }

  bool hasMultiGeomColumns = false;
  bool result = false;

  switch(m_objStrategy)
  {
    case te::vp::ALL_OBJ:
      {
        if(hasMultiGeomColumns)  // Condição se o DataSource suporta mais de uma
                                 // coluna geometrica...
        {
          dsTypeVec.push_back(
              te::vp::GeometricOp::GetDataSetType(te::vp::ALL_OBJ, true));
        }
        else
        {
          if(opGeom.size() > 0)
          {
            for(std::size_t i = 0; i < opGeom.size(); ++i)
              dsTypeVec.push_back(te::vp::GeometricOp::GetDataSetType(
                  te::vp::ALL_OBJ, false, opGeom[i]));
          }
          else
          {
            dsTypeVec.push_back(
                te::vp::GeometricOp::GetDataSetType(te::vp::ALL_OBJ, false));
          }
        }

        for(std::size_t dsTypePos = 0; dsTypePos < dsTypeVec.size();
            ++dsTypePos)
        {
          m_outDsetNameVec.push_back(dsTypeVec[dsTypePos]->getName());

          std::unique_ptr<te::da::DataSetType> outDataSetType(
              dsTypeVec[dsTypePos]);
          std::unique_ptr<te::mem::DataSet> outDataSet(
              SetAllObjects(dsTypeVec[dsTypePos], opTab, opGeom));

          if(m_outDsrc->getType() == "OGR")
          {
            std::string dsinfo("file://");

            dsinfo += m_outDsrc->getConnectionInfo().host() + m_outDsrc->getConnectionInfo().path() + "/" + m_outDsetNameVec[dsTypePos] + ".shp";

            std::unique_ptr<te::da::DataSource> dsOGR = te::da::DataSourceFactory::make("OGR", dsinfo);

            dsOGR->open();

            te::vp::Save(dsOGR.get(), outDataSet.get(), outDataSetType.get());

            dsOGR->close();
          }
          else
          {
            te::vp::Save(m_outDsrc.get(), outDataSet.get(), outDataSetType.get());
          }
          result = true;

          if(!result)
          {
            m_outDsrc->close();
            return result;
          }
        }
      }
      break;
    case te::vp::AGGREG_OBJ:
      {
        if(hasMultiGeomColumns)  // Condição se o DataSource suporta mais de uma
                                 // coluna geometrica...
        {
          dsTypeVec.push_back(
              te::vp::GeometricOp::GetDataSetType(te::vp::AGGREG_OBJ, true));
        }
        else
        {
          if(opGeom.size() > 0)
          {
            for(std::size_t i = 0; i < opGeom.size(); ++i)
              dsTypeVec.push_back(te::vp::GeometricOp::GetDataSetType(
                  te::vp::AGGREG_OBJ, false, opGeom[i]));
          }
          else
          {
            dsTypeVec.push_back(
                te::vp::GeometricOp::GetDataSetType(te::vp::AGGREG_OBJ, false));
          }
        }

        for(std::size_t dsTypePos = 0; dsTypePos < dsTypeVec.size();
            ++dsTypePos)
        {
          m_outDsetNameVec.push_back(dsTypeVec[dsTypePos]->getName());

          std::unique_ptr<te::da::DataSetType> outDataSetType(
              dsTypeVec[dsTypePos]);
          std::unique_ptr<te::mem::DataSet> outDataSet(
              SetAggregObj(dsTypeVec[dsTypePos], opTab, opGeom));

          if(outDataSet->size() == 0)
          {
            m_outDsrc->close();
            TE_LOG_INFO("Vector Processing - Geometric Operation - Result layer is empty! Verify input layer consistency.");
            return false;
          }

          if(m_outDsrc->getType() == "OGR")
          {
            std::string dsinfo("file://");

            dsinfo += m_outDsrc->getConnectionInfo().host() + m_outDsrc->getConnectionInfo().path() + "/" + m_outDsetNameVec[dsTypePos] + ".shp";

            std::unique_ptr<te::da::DataSource> dsOGR = te::da::DataSourceFactory::make("OGR", dsinfo);
            dsOGR->open();

            te::vp::Save(dsOGR.get(), outDataSet.get(), outDataSetType.get());

            dsOGR->close();
          }
          else
          {
            te::vp::Save(m_outDsrc.get(), outDataSet.get(), outDataSetType.get());
          }

          result = true;

          if(!result)
          {
            m_outDsrc->close();
            return result;
          }
        }
      }
      break;
    case te::vp::AGGREG_BY_ATTRIBUTE:
      {
        if(hasMultiGeomColumns)  // Condição se o DataSource suporta mais de uma
                                 // coluna geometrica...
        {
          dsTypeVec.push_back(te::vp::GeometricOp::GetDataSetType(
              te::vp::AGGREG_BY_ATTRIBUTE, true));
        }
        else
        {
          if(opGeom.size() > 0)
          {
            for(std::size_t i = 0; i < opGeom.size(); ++i)
              dsTypeVec.push_back(te::vp::GeometricOp::GetDataSetType(
                  te::vp::AGGREG_BY_ATTRIBUTE, false, opGeom[i]));
          }
          else
          {
            dsTypeVec.push_back(te::vp::GeometricOp::GetDataSetType(
                te::vp::AGGREG_BY_ATTRIBUTE, false));
          }
        }

        for(std::size_t dsTypePos = 0; dsTypePos < dsTypeVec.size();
            ++dsTypePos)
        {
          m_outDsetNameVec.push_back(dsTypeVec[dsTypePos]->getName());

          std::unique_ptr<te::da::DataSetType> outDataSetType(
              dsTypeVec[dsTypePos]);
          std::unique_ptr<te::mem::DataSet> outDataSet(
              SetAggregByAttribute(dsTypeVec[dsTypePos], opTab, opGeom));

          if(outDataSet->size() == 0)
          {
            m_outDsrc->close();
            TE_LOG_INFO("Vector Processing - Geometric Operation - Result layer is empty! Verify input layer consistency.");
            return false;
          }

          if(m_outDsrc->getType() == "OGR")
          {
            std::string dsinfo("file://");

            dsinfo += m_outDsrc->getConnectionInfo().host() + m_outDsrc->getConnectionInfo().path() + "/" + m_outDsetNameVec[dsTypePos] + ".shp";

            std::unique_ptr<te::da::DataSource> dsOGR = te::da::DataSourceFactory::make("OGR", dsinfo);
            dsOGR->open();

            te::vp::Save(dsOGR.get(), outDataSet.get(), outDataSetType.get());

            dsOGR->close();
          }
          else
          {
            te::vp::Save(m_outDsrc.get(), outDataSet.get(), outDataSetType.get());
          }

          result = true;

          if(!result)
          {
            m_outDsrc->close();
            return result;
          }
        }
      }
      break;
    default:
      {
        m_outDsrc->close();
        TE_LOG_INFO("Vector Processing - Geometric Operation - Strategy Not found!");
      }
      return false;
  }

  m_outDsrc->close();

  return result;
}

te::mem::DataSet* te::vp::GeometricOpMemory::SetAllObjects(
    te::da::DataSetType* dsType, std::vector<int> tabVec,
    std::vector<int> geoVec)
{
  std::unique_ptr<te::mem::DataSet> outDSet(new te::mem::DataSet(dsType));
  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dsType);

  int pk = 0;

  std::unique_ptr<te::da::DataSetType> inDsType =
      m_inDsrc->getDataSetType(m_inDsetName);

  std::unique_ptr<te::da::DataSet> inDsetSrc = m_inDsrc->getDataSet(m_inDsetName);
  std::unique_ptr<te::da::DataSetAdapter> inDset(
      te::da::CreateAdapter(inDsetSrc.get(), m_converter.get()));

  inDset->moveBeforeFirst();
  
  std::size_t geom_pos = te::da::GetFirstSpatialPropertyPos(inDset.get());

  while(inDset->moveNext())
  {
    try
    {
      te::mem::DataSetItem* item = new te::mem::DataSetItem(outDSet.get());

      item->setInt32(0, pk);
      bool geom = true;

      if(m_selectedProps.size() > 0)
      {
        for(std::size_t prop_pos = 0; prop_pos < m_selectedProps.size();
            ++prop_pos)
        {
          std::size_t inputPropertyPos =
              inDsType->getPropertyPosition(m_selectedProps[prop_pos]);

          if(!inDset->isNull(inputPropertyPos))
          {
            item->setValue(m_selectedProps[prop_pos],
                           inDset->getValue(m_selectedProps[prop_pos]).release());
          }
        }
      }

      std::unique_ptr<te::gm::Geometry> in_geom = inDset->getGeometry(geom_pos);

      if(tabVec.size() > 0)
      {
        for(std::size_t tabPos = 0; tabPos < tabVec.size(); ++tabPos)
        {
          switch(tabVec[tabPos])
          {
            case te::vp::AREA:
              {
                double area = 0;
                area = CalculateTabularOp(tabVec[tabPos], *in_geom.get());
                item->setDouble("area", area);
              }
              break;
            case te::vp::LINE:
              {
                double line = 0;
                line = CalculateTabularOp(tabVec[tabPos], *in_geom.get());
                item->setDouble("line_length", line);
              }
              break;
            case te::vp::PERIMETER:
              {
                double perimeter = 0;
                perimeter = CalculateTabularOp(tabVec[tabPos], *in_geom.get());
                item->setDouble("perimeter", perimeter);
              }
              break;
            default:
              {
                TE_LOG_INFO(
                    "Vector Processing - Geometric Operation - Could not "
                    "insert the tabular value.");
              }
          }
        }
      }

      if(geoVec.size() > 0)
      {
        for(std::size_t geoPos = 0; geoPos < geoVec.size(); ++geoPos)
        {
          switch(geoVec[geoPos])
          {
            case te::vp::CONVEX_HULL:
              {
                std::size_t pos = te::da::GetPropertyPos(dsType, "convex_hull");
                if(pos < dsType->size())
                {
                  std::unique_ptr<te::gm::Geometry> convexHull(
                      in_geom->convexHull());
                  convexHull->setSRID(geomProp->getSRID());

                  if((convexHull->getGeomTypeId() == te::gm::PolygonType) ||
                    (convexHull->getGeomTypeId() == te::gm::PolygonMType) ||
                    (convexHull->getGeomTypeId() == te::gm::PolygonZType) ||
                    (convexHull->getGeomTypeId() == te::gm::PolygonZMType))
                  {
                    item->setGeometry("convex_hull", convexHull.release());
                    geom = true;
                  }
                  else
                  {
                    geom = false;
                  }
                }
              }
              break;
            case te::vp::CENTROID:
              {
                std::size_t pos = te::da::GetPropertyPos(dsType, "centroid");
                if(pos < dsType->size())
                {
                  te::gm::Coord2D center = in_geom->getCentroid();
                  te::gm::Point* point =
                    new te::gm::Point(center.x, center.y, geomProp->getSRID());
                  item->setGeometry("centroid", point);
                  geom = true;
                }
              }
              break;
            case te::vp::MBR:
              {
                std::size_t pos = te::da::GetPropertyPos(dsType, "mbr");
                if(pos < dsType->size())
                {
                  std::unique_ptr<te::gm::Geometry> mbr(in_geom->getEnvelope());
                  mbr->setSRID(geomProp->getSRID());
                  if((mbr->getGeomTypeId() == te::gm::PolygonType) ||
                    (mbr->getGeomTypeId() == te::gm::PolygonMType) ||
                    (mbr->getGeomTypeId() == te::gm::PolygonZType) ||
                    (mbr->getGeomTypeId() == te::gm::PolygonZMType))
                  {
                    item->setGeometry("mbr", mbr.release());
                    geom = true;
                  }
                  else
                  {
                    geom = false;
                  }
                }
              }
              break;
            default:
              {
                TE_LOG_INFO(
                    "Vector Processing - Geometric Operation - Could not "
                    "insert the geometric value.");
              }
          }
        }
      }
      else
      {
        std::unique_ptr<te::gm::Geometry> g(in_geom.release());
        g->setSRID(geomProp->getSRID());
        te::gm::GeometryCollection* teGeomColl = new te::gm::GeometryCollection(
            0, te::gm::GeometryCollectionType, g->getSRID());

        switch(g->getGeomTypeId())
        {
          case te::gm::PointType:
          case te::gm::PointMType:
          case te::gm::PointZType:
          case te::gm::PointZMType:
          case te::gm::LineStringType:
          case te::gm::LineStringMType:
          case te::gm::LineStringZType:
          case te::gm::LineStringZMType:
          case te::gm::PolygonType:
          case te::gm::PolygonMType:
          case te::gm::PolygonZType:
          case te::gm::PolygonZMType:
            {
              if(g->isValid())
                teGeomColl->add(g.release());
            }
            break;
          default:
            {
              TE_LOG_INFO(
                  "Vector Processing - Geometric Operation - Could not insert "
                  "the geometry in collection.");
            }
        }
        if(teGeomColl->getNumGeometries() != 0)
          item->setGeometry("geom", teGeomColl);
        else
          item->setGeometry("geom", g.release());
      }

      if(geom)
      {
        outDSet->add(item);
        ++pk;
      }
    }
    catch(te::common::Exception& e)
    {
      TE_LOG_ERROR("Vector Processing - Geometric Operation - " + e.what());
      continue;
    }
  }

  return outDSet.release();
}

te::mem::DataSet* te::vp::GeometricOpMemory::SetAggregObj(
    te::da::DataSetType* dsType, std::vector<int> tabVec,
    std::vector<int> geoVec)
{
  std::unique_ptr<te::mem::DataSet> outDSet(new te::mem::DataSet(dsType));
  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dsType);

  int pk = 0;

  std::unique_ptr<te::da::DataSet> inDsetSrc = m_inDsrc->getDataSet(m_inDsetName);
  std::unique_ptr<te::da::DataSetAdapter> inDset(
      te::da::CreateAdapter(inDsetSrc.get(), m_converter.get()));

  std::size_t geom_pos = te::da::GetFirstSpatialPropertyPos(inDset.get());

  inDset->moveBeforeFirst();
  te::mem::DataSetItem* item = new te::mem::DataSetItem(outDSet.get());
  
  item->setInt32(0, pk);

  std::vector<te::gm::Geometry*> geometriesToUnion;
  std::unique_ptr<te::gm::Geometry> dissolvedGeometry;

  if(inDset->size() > 1)
  {
    while(inDset->moveNext())
    {
      try
      {
        if (inDset->isNull(geom_pos))
          continue;

        std::unique_ptr<te::gm::Geometry> c_geom = inDset->getGeometry(geom_pos);

        if(c_geom->isValid())
          geometriesToUnion.push_back(c_geom.release());

      }
      catch(te::common::Exception& e)
      {
        TE_LOG_ERROR("Vector Processing - Geometric Operation - " + e.what());
        continue;
      }
    }
  }

  if(geometriesToUnion.empty())
    return outDSet.release();

  dissolvedGeometry = GetGeometryUnion(geometriesToUnion);

  if(!dissolvedGeometry->isValid())
    return outDSet.release();

  if(tabVec.size() > 0)
  {
    for(std::size_t tabPos = 0; tabPos < tabVec.size(); ++tabPos)
    {
      switch(tabVec[tabPos])
      {
        case te::vp::AREA:
          {
            double area = 0;
            area = CalculateTabularOp(tabVec[tabPos], *dissolvedGeometry.get());
            item->setDouble("area", area);
          }
          break;
        case te::vp::LINE:
          {
            double line = 0;
            line = CalculateTabularOp(tabVec[tabPos], *dissolvedGeometry.get());
            item->setDouble("line_length", line);
          }
          break;
        case te::vp::PERIMETER:
          {
            double perimeter = 0;
            perimeter = CalculateTabularOp(tabVec[tabPos], *dissolvedGeometry.get());
            item->setDouble("perimeter", perimeter);
          }
          break;
        default:
          {
            TE_LOG_INFO(
                "Vector Processing - Geometric Operation - Could not insert "
                "the tabular value.");
          }
      }
    }
  }

  if(geoVec.size() > 0)
  {
    for(std::size_t geoPos = 0; geoPos < geoVec.size(); ++geoPos)
    {
      switch(geoVec[geoPos])
      {
        case te::vp::CONVEX_HULL:
          {
            std::size_t pos = te::da::GetPropertyPos(dsType, "convex_hull");
            if(pos < dsType->size())
            {
              std::unique_ptr<te::gm::Geometry> convexHull(
                  dissolvedGeometry->convexHull());
              convexHull->setSRID(geomProp->getSRID());

              item->setGeometry("convex_hull", convexHull.release());
            }
          }
          break;
        case te::vp::CENTROID:
          {
            std::size_t pos = te::da::GetPropertyPos(dsType, "centroid");
            if(pos < dsType->size())
            {
              const te::gm::Envelope* env = dissolvedGeometry->getMBR();
              te::gm::Coord2D center = env->getCenter();
              te::gm::Point* point =
                new te::gm::Point(center.x, center.y, geomProp->getSRID());
              item->setGeometry("centroid", point);
            }
          }
          break;
        case te::vp::MBR:
          {
            std::size_t pos = te::da::GetPropertyPos(dsType, "mbr");
            if(pos < dsType->size())
            {
              std::unique_ptr<te::gm::Geometry> mbr(dissolvedGeometry->getEnvelope());
              mbr->setSRID(geomProp->getSRID());
              item->setGeometry("mbr", mbr.release());
            }
          }
          break;
        default:
          {
            TE_LOG_INFO(
                "Vector Processing - Geometric Operation - Could not insert "
                "the geometry in collection.");
          }
      }
    }
  }
  else
  {
    std::unique_ptr<te::gm::Geometry> g(dissolvedGeometry.release());
    g->setSRID(geomProp->getSRID());
    te::gm::GeometryCollection* teGeomColl = new te::gm::GeometryCollection(
        0, te::gm::GeometryCollectionType, g->getSRID());

    switch(g->getGeomTypeId())
    {
      case te::gm::PointType:
      case te::gm::PointMType:
      case te::gm::PointZType:
      case te::gm::PointZMType:
      case te::gm::LineStringType:
      case te::gm::LineStringMType:
      case te::gm::LineStringZType:
      case te::gm::LineStringZMType:
      case te::gm::PolygonType:
      case te::gm::PolygonMType:
      case te::gm::PolygonZType:
      case te::gm::PolygonZMType:
      {
        if(g->isValid())
          teGeomColl->add(g.release());
      }
      break;
      default:
      {
        TE_LOG_INFO(
            "Vector Processing - Geometric Operation - Could not insert the "
            "geometry in collection.");
      }
    }
    if(teGeomColl->getNumGeometries() != 0)
      item->setGeometry("geom", teGeomColl);
    else
      item->setGeometry("geom", g.release());
  }

  outDSet->add(item);

  return outDSet.release();
}

te::mem::DataSet* te::vp::GeometricOpMemory::SetAggregByAttribute(
    te::da::DataSetType* dsType, std::vector<int> tabVec,
    std::vector<int> geoVec)
{
  std::map<std::string, te::gm::Geometry*> geometries;

  std::unique_ptr<te::da::DataSet> inDsetSrc = m_inDsrc->getDataSet(m_inDsetName);
  std::unique_ptr<te::da::DataSetAdapter> inDset(
      te::da::CreateAdapter(inDsetSrc.get(), m_converter.get()));

  std::unique_ptr<te::mem::DataSet> outDSet(new te::mem::DataSet(dsType));

  std::size_t geom_pos = te::da::GetFirstSpatialPropertyPos(inDset.get());

  inDset->moveBeforeFirst();

  if(inDset->size() > 0)
  {
    std::map<std::string, std::vector<te::gm::Geometry*> > groups;
    std::map<std::string, std::vector<te::gm::Geometry*> >::iterator itg;

    inDset->moveBeforeFirst();
    while(inDset->moveNext())
    {
      try
      {
        std::string key = inDset->getAsString(m_attribute);
        std::unique_ptr<te::gm::Geometry> geom = inDset->getGeometry(geom_pos);

        if(!geom->isValid())
          continue;

        itg = groups.find(key);

        if (itg==groups.end())
        {
          std::vector<te::gm::Geometry*> geometriesToDissolve;

          geometriesToDissolve.push_back(geom.release());

          groups.insert(std::pair<std::string, std::vector<te::gm::Geometry*> >(
              key, geometriesToDissolve));
        }
        else
        {
          itg->second.push_back(geom.release());
        }
      }
      catch(te::common::Exception& e)
      {
        TE_LOG_ERROR("Vector Processing - Geometric Operation - " + e.what());
        continue;
      }
    }

    itg = groups.begin();
    while(itg != groups.end())
    {
      try
      {
        // calculate the spatial aggregation
        std::unique_ptr<te::gm::Geometry> geometry = te::gm::GetGeometryUnion(itg->second);

        if(geometry->isValid())
          geometries.insert(std::pair<std::string, te::gm::Geometry*>(itg->first, geometry.release()));

        ++itg;
      }
      catch(te::common::Exception& e)
      {
        TE_LOG_ERROR("Vector Processing - Geometric Operation - " + e.what());
        ++itg;
        continue;
      }
    }

  }
  else
  {
    return outDSet.release();
  }

// insert result in dataset.
  std::map<std::string, te::gm::Geometry*>::iterator itGeom;
  int i = 0;

  itGeom = geometries.begin();
  while(itGeom != geometries.end())
  {
    te::mem::DataSetItem* outItem = new te::mem::DataSetItem(outDSet.get());
    
    // inserting the id in dataSet.
    outItem->setInt32(0, i);
    // inserting aggregated attribute.
    te::dt::Property* prop = m_converter->getResult()->getProperty(m_attribute);
    switch(prop->getType())
    {
      case te::dt::STRING_TYPE:
          outItem->setString(1, itGeom->first);
          break;
      case te::dt::INT16_TYPE:
          outItem->setInt16(1, boost::lexical_cast<int16_t>(itGeom->first));
          break;
      case te::dt::INT32_TYPE:
          outItem->setInt32(1, boost::lexical_cast<int>(itGeom->first));
          break;
      case te::dt::INT64_TYPE:
          outItem->setInt64(1, boost::lexical_cast<int>(itGeom->first));
          break;
      case te::dt::DOUBLE_TYPE:
          outItem->setDouble(1, boost::lexical_cast<double>(itGeom->first));
          break;
      default:
        TE_LOG_INFO(
            "Vector Processing - Geometric Operation - Could not insert the "
            "aggregated value.");
        break;
    }
    
    // inserting geometries.
    if(tabVec.size() > 0)
    {
      for(std::size_t tabPos = 0; tabPos < tabVec.size(); ++tabPos)
      {
        switch(tabVec[tabPos])
        {
          case te::vp::AREA:
            {
              double area = 0;
              area = CalculateTabularOp(tabVec[tabPos], *itGeom->second);
              outItem->setDouble("area", area);
            }
            break;
          case te::vp::LINE:
            {
              double line = 0;
              line = CalculateTabularOp(tabVec[tabPos], *itGeom->second);
              outItem->setDouble("line_length", line);
            }
            break;
          case te::vp::PERIMETER:
            {
              double perimeter = 0;
              perimeter = CalculateTabularOp(tabVec[tabPos], *itGeom->second);
              outItem->setDouble("perimeter", perimeter);
            }
            break;
          default:
            {
              TE_LOG_INFO(
                  "Vector Processing - Geometric Operation - Could not insert "
                  "the tabular value.");
            }
        }
      }
    }

    if(geoVec.size() > 0)
    {
      for(std::size_t geoPos = 0; geoPos < geoVec.size(); ++geoPos)
      {
        switch(geoVec[geoPos])
        {
          case te::vp::CONVEX_HULL:
            {
              std::size_t pos = te::da::GetPropertyPos(dsType, "convex_hull");
              if(pos < dsType->size())
              {
                std::unique_ptr<te::gm::Geometry> convexHull(
                    itGeom->second->convexHull());
                convexHull->setSRID(itGeom->second->getSRID());
                
                outItem->setGeometry("convex_hull", convexHull.release());
              }
            }
            break;
          case te::vp::CENTROID:
            {
              std::size_t pos = te::da::GetPropertyPos(dsType, "centroid");
              if(pos < dsType->size())
              {
                const te::gm::Envelope* env = itGeom->second->getMBR();
                te::gm::Coord2D center = env->getCenter();
                te::gm::Point* point =
                  new te::gm::Point(center.x, center.y, itGeom->second->getSRID());
                outItem->setGeometry("centroid", point);
              }
            }
            break;
          case te::vp::MBR:
            {
              std::size_t pos = te::da::GetPropertyPos(dsType, "mbr");
              if(pos < dsType->size())
              {
                std::unique_ptr<te::gm::Geometry> mbr(
                    itGeom->second->getEnvelope());
                mbr->setSRID(itGeom->second->getSRID());
                outItem->setGeometry("mbr", mbr.release());
              }
            }
            break;
          default:
            {
              TE_LOG_INFO(
                  "Vector Processing - Geometric Operation - Could not insert "
                  "the geometric value.");
            }
        }
      }
    }
    else
    {
      te::gm::GeometryCollection* teGeomColl = new te::gm::GeometryCollection(
          0, te::gm::GeometryCollectionType, itGeom->second->getSRID());

      switch(itGeom->second->getGeomTypeId())
      {
        case te::gm::PointType:
        case te::gm::PointMType:
        case te::gm::PointZType:
        case te::gm::PointZMType:
        case te::gm::LineStringType:
        case te::gm::LineStringMType:
        case te::gm::LineStringZType:
        case te::gm::LineStringZMType:
        case te::gm::PolygonType:
        case te::gm::PolygonMType:
        case te::gm::PolygonZType:
        case te::gm::PolygonZMType:
        {
          if(itGeom->second->isValid())
            teGeomColl->add(itGeom->second);
        }
        break;
        default:
        {
          TE_LOG_INFO(
              "Vector Processing - Geometric Operation - Could not insert the "
              "geometry in collection.");
        }
      }
      if(teGeomColl->getNumGeometries() != 0)
        outItem->setGeometry("geom", teGeomColl);
      else
        outItem->setGeometry("geom", itGeom->second);
    }

    outDSet->add(outItem);
    ++itGeom;
    ++i;
  }

  return outDSet.release();
}


double te::vp::GeometricOpMemory::CalculateTabularOp(const int& tabOperation,
                                                     te::gm::Geometry& geom)
{
  double value = 0;
  te::gm::GeomType geomType = geom.getGeomTypeId();

  switch(tabOperation)
  {
    case te::vp::AREA:
      {
        if(geomType == te::gm::PolygonType)
        {
          std::unique_ptr<te::gm::Polygon> pol(dynamic_cast<te::gm::Polygon*>(geom.clone()));

          if(pol.get())
          {
            if(pol->getSRID() != m_newSRID)
              pol->transform(m_newSRID);

            value = pol->getArea();
          }
        }
        if(geomType == te::gm::MultiPolygonType)
        {
          std::string type = geom.getGeometryType();

          if(type == "GeometryCollection")
          {
            std::unique_ptr<te::gm::GeometryCollection> m_geoColl(dynamic_cast<te::gm::GeometryCollection*>(geom.clone()));

            if(m_geoColl.get())
            {
              if(m_geoColl->getSRID() != m_newSRID)
                m_geoColl->transform(m_newSRID);

              std::vector<te::gm::Geometry*> geomVec =
                  m_geoColl->getGeometries();

              for(std::size_t i = 0; i < geomVec.size(); ++i)
              {
                te::gm::GeomType inType = geomVec[i]->getGeomTypeId();
                if(inType == te::gm::PolygonType)
                {
                  te::gm::Polygon* m_pol =
                      dynamic_cast<te::gm::Polygon*>(geomVec[i]);
                  if(m_pol)
                    value += m_pol->getArea();
                }
                if(inType == te::gm::MultiPolygonType)
                {
                  te::gm::MultiPolygon* m_pol =
                      dynamic_cast<te::gm::MultiPolygon*>(geomVec[i]);
                  if(m_pol)
                    value += m_pol->getArea();
                }
              }
            }
          }
          else
          {
            std::unique_ptr<te::gm::MultiPolygon> m_pol(dynamic_cast<te::gm::MultiPolygon*>(geom.clone()));

            if(m_pol.get())
            {
              if(m_pol->getSRID() != m_newSRID)
                m_pol->transform(m_newSRID);

              value = m_pol->getArea();
            }

          }
        }
        return value;
      }
      break;
    case te::vp::LINE:
      {
        if(geomType == te::gm::LineStringType)
        {
          std::unique_ptr<te::gm::LineString> lineString(dynamic_cast<te::gm::LineString*>(geom.clone()));

          if(lineString.get())
          {
            if(lineString->getSRID() != m_newSRID)
              lineString->transform(m_newSRID);

            value = lineString->getLength();
          }
        }
        if(geomType == te::gm::MultiLineStringType)
        {
          std::unique_ptr<te::gm::MultiLineString> m_lineString(dynamic_cast<te::gm::MultiLineString*>(geom.clone()));

          if(m_lineString.get())
          {
            if(m_lineString->getSRID() != m_newSRID)
              m_lineString->transform(m_newSRID);

            value = m_lineString->getLength();
          }
        }
        return value;
      }
      break;
    case te::vp::PERIMETER:
      {
        if(geomType == te::gm::PolygonType)
        {
          std::unique_ptr<te::gm::Polygon> pol(dynamic_cast<te::gm::Polygon*>(geom.clone()));
          if(pol.get())
          {
            if(pol->getSRID() != m_newSRID)
              pol->transform(m_newSRID);

            value = pol->getPerimeter();
          }
        }
        if(geomType == te::gm::MultiPolygonType)
        {
          std::string type = geom.getGeometryType();

          if(type == "GeometryCollection")
          {
            std::unique_ptr<te::gm::GeometryCollection> m_geoColl(dynamic_cast<te::gm::GeometryCollection*>(geom.clone()));

            if(m_geoColl.get())
            {
              if(m_geoColl->getSRID() != m_newSRID)
                m_geoColl->transform(m_newSRID);

              std::vector<te::gm::Geometry*> geomVec =
                  m_geoColl->getGeometries();

              for(std::size_t i = 0; i < geomVec.size(); ++i)
              {
                te::gm::GeomType inType = geomVec[i]->getGeomTypeId();
                if(inType == te::gm::PolygonType)
                {
                  te::gm::Polygon* m_pol =
                      dynamic_cast<te::gm::Polygon*>(geomVec[i]);
                  if(m_pol)
                    value += m_pol->getPerimeter();
                }
                if(inType == te::gm::MultiPolygonType)
                {
                  te::gm::MultiPolygon* m_pol =
                      dynamic_cast<te::gm::MultiPolygon*>(geomVec[i]);
                  if(m_pol)
                    value += m_pol->getPerimeter();
                }
              }
            }
          }
          else
          {
            std::unique_ptr<te::gm::MultiPolygon> m_pol(dynamic_cast<te::gm::MultiPolygon*>(geom.clone()));

            if(m_pol.get())
            {
              if(m_pol->getSRID() != m_newSRID)
                m_pol->transform(m_newSRID);

              value = m_pol->getPerimeter();
            }
          }
        }
        return value;
      }
      break;
    default:
      {
        TE_LOG_INFO(
            "Vector Processing - Geometric Operation - Could not calculate the "
            "operation.");
      }
  }

  return value;
}