geometry/Geometry.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/geometry/Geometry.cpp

  \brief Geometry is the root class of the geometries hierarchy, it follows OGC Simple Feature Specification - SFS (Simple Feature Access - Part 1: Common Architecture) and ISO SQL/MM Spatial.
*/

// TerraLib
#include "../common/Globals.h"
#include "../core/translator/Translator.h"
#include "../datatype/Enums.h"
#include "Envelope.h"
#include "Exception.h"
#include "Geometry.h"
#include "GEOSReader.h"
#include "GEOSWriter.h"
#include "Utils.h"
#include "WKTReader.h"
#include "WKTWriter.h"
#include "WKBSize.h"
#include "WKBWriter.h"

// STL
#include <cassert>
#include <cstring>
#include <memory>
#include <sstream>

#ifdef TERRALIB_GEOS_ENABLED
// GEOS
#include <geos/geom/Geometry.h>
#include <geos/geom/IntersectionMatrix.h>
#include <geos/geom/Point.h>
#include <geos/operation/buffer/OffsetCurveBuilder.h>
#include <geos/operation/union/CascadedPolygonUnion.h>
#include <geos/util/GEOSException.h>
#endif

std::map<std::string, te::gm::GeomType> te::gm::Geometry::sm_geomTypeMap;

te::gm::Geometry::Geometry(GeomType t, int srid, Envelope* mbr) _NOEXCEPT_OP(true)
  : m_gType(t),
    m_srid(srid),
    m_mbr(mbr)
{
}

te::gm::Geometry::Geometry(const Geometry& rhs) _NOEXCEPT_OP(true)
  : m_gType(rhs.m_gType),
    m_srid(rhs.m_srid),
    m_mbr(nullptr)
{
}

te::gm::Geometry::~Geometry()
{
  delete m_mbr;
}

te::gm::Geometry& te::gm::Geometry::operator=(const Geometry& rhs) _NOEXCEPT_OP(true)
{
  if(this != &rhs)
  {
    m_gType = rhs.m_gType;

    m_srid = rhs.m_srid;

    delete m_mbr;

    m_mbr = rhs.m_mbr ? new Envelope(*rhs.m_mbr) : nullptr;
  }

  return *this;
}

int te::gm::Geometry::getCoordinateDimension() const _NOEXCEPT_OP(true)
{
  return GetCoordDimension(m_gType);
}

te::gm::Geometry* te::gm::Geometry::getEnvelope() const _NOEXCEPT_OP(true)
{
  return GetGeomFromEnvelope(getMBR(), m_srid);
}

const te::gm::Envelope* te::gm::Geometry::getMBR() const _NOEXCEPT_OP(true)
{
  if(m_mbr == nullptr)
    computeMBR(true);

  return m_mbr;
}

std::string te::gm::Geometry::asText() const _NOEXCEPT_OP(true)
{
  std::stringstream stream(std::ios_base::in | std::ios_base::out);

  stream.precision(18);

  WKTWriter::write(this, stream);

  return stream.str();
}

char* te::gm::Geometry::asBinary(std::size_t& size) const _NOEXCEPT_OP(false)
{
  size = WKBSize::size(this);

  char* wkb = new char[size];

  getWkb(wkb, te::common::Globals::sm_machineByteOrder);

  return wkb;
}

std::size_t te::gm::Geometry::getWkbSize() const _NOEXCEPT_OP(true)
{
  return WKBSize::size(this);
}

void te::gm::Geometry::getWkb(char* wkb, te::common::MachineByteOrder byteOrder) const _NOEXCEPT_OP(false)
{
  WKBWriter::write(this, wkb, byteOrder);
}

bool te::gm::Geometry::isEmpty() const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    return g->isEmpty();
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw Exception(TE_TR("isEmpty routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::isSimple() const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    return g->isSimple();
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw Exception(TE_TR("isSimple routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::isValid() const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    return g->isValid();
  }
  catch(const geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw Exception(TE_TR("isValid routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::is3D() const _NOEXCEPT_OP(true)
{
  if((m_gType & 0xF00) == 0xB00)    // it is zm
    return true;

  if((m_gType & 0x0F00) == 0x300)   // it is z
    return true;

  return false;                     // it is 2D or M
}

bool te::gm::Geometry::isMeasured() const _NOEXCEPT_OP(true)
{
  if((m_gType & 0xF00) == 0xB00)  // it is zm
    return true;

  if((m_gType & 0xF00) == 0x700)  // it is m
    return true;

  return false;                   // it is 2D or z
}

bool te::gm::Geometry::isCollection() const _NOEXCEPT_OP(true)
{
  te::gm::GeomType gType = this->get2DGeomTypeId();

  switch (gType)
  {
  case te::gm::GeometryCollectionType:
  case te::gm::MultiPointType:
  case te::gm::MultiLineStringType:
  case te::gm::MultiPolygonType :
  case te::gm::MultiSurfaceType:
    return true;
  default:
    return false;
  }
}

te::gm::Geometry* te::gm::Geometry::getBoundary() const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> b(g->getBoundary());

    return GEOSReader::read(b.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("getBoundary routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Coord2D te::gm::Geometry::getCentroid() const _NOEXCEPT_OP(false)
{
  te::gm::Coord2D coord2d;

#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Point> point(thisGeom->getCentroid());

    coord2d.x = point->getX();
    coord2d.y = point->getY();
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("getCentroid routine is supported by GEOS! Please, enable the GEOS support."));
#endif

  return coord2d;
}

bool te::gm::Geometry::equals(const Geometry* const rhs, const bool exact) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    if(exact == true)
      return thisGeom->equalsExact(rhsGeom.get());
    else
      return thisGeom->equals(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("equals routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::disjoint(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->disjoint(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("disjoint routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::intersects(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->intersects(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }

#else
  throw te::common::Exception(TE_TR("intersects routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::touches(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->touches(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("touches routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::crosses(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->crosses(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("crosses routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::within(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->within(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("within routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::contains(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->contains(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("contains routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::overlaps(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->overlaps(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("overlaps routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::relate(const Geometry* const rhs, const std::string& matrix) const _NOEXCEPT_OP(false)
{
  assert(matrix.size() == 9);

#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->relate(rhsGeom.get(), matrix);
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }

#else
  throw te::common::Exception(TE_TR("relate routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

std::string te::gm::Geometry::relate(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    std::unique_ptr<geos::geom::IntersectionMatrix> m(thisGeom->relate(rhsGeom.get()));

    return m->toString();
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("relate routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::covers(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->covers(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("covers routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::coveredBy(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->coveredBy(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("coveredBy routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::locateBetween(const double& /*mStart*/, const double& /*mEnd*/) const _NOEXCEPT_OP(false)
{
  return nullptr;
}

double te::gm::Geometry::distance(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->distance(rhsGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("distance routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::buffer(const double& distance) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  return buffer(distance, TE_GEOS_DEFAULT_QUADRANT_SEGMENTS, CapRoundType);
#else
  return buffer(distance, 16, CapRoundType);
#endif
}

te::gm::Geometry* te::gm::Geometry::buffer(const double& distance, int quadrantSegments) const _NOEXCEPT_OP(false)
{
  return buffer(distance, quadrantSegments, CapRoundType);  
}

te::gm::Geometry* te::gm::Geometry::buffer(const double& distance,
                                           int quadrantSegments,
                                           BufferCapStyle endCapStyle) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> bg(g->buffer(distance, quadrantSegments, static_cast<int>(endCapStyle)));

    bg->setSRID(m_srid);

    return GEOSReader::read(bg.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("buffer routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::convexHull() const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  try
  {
    std::unique_ptr<geos::geom::Geometry> g(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> hull(g->convexHull());

    hull->setSRID(m_srid);

    return GEOSReader::read(hull.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("convexHull routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::intersection(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    std::unique_ptr<geos::geom::Geometry> intersectionGeom(thisGeom->intersection(rhsGeom.get()));

    intersectionGeom->setSRID(m_srid);

    return GEOSReader::read(intersectionGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("intersection routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::Union(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    std::unique_ptr<geos::geom::Geometry> unionGeom(thisGeom-> Union(rhsGeom.get()));

    unionGeom->setSRID(m_srid);

    return GEOSReader::read(unionGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("Union routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::difference(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    std::unique_ptr<geos::geom::Geometry> differenceGeom(thisGeom->difference(rhsGeom.get()));

    differenceGeom->setSRID(m_srid);

    return GEOSReader::read(differenceGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("difference routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::Geometry* te::gm::Geometry::symDifference(const Geometry* const rhs) const _NOEXCEPT_OP(false)
{
#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    std::unique_ptr<geos::geom::Geometry> symDifferenceGeom(thisGeom->symDifference(rhsGeom.get()));

    symDifferenceGeom->setSRID(m_srid);

    return GEOSReader::read(symDifferenceGeom.get());
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("symDifference routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

bool te::gm::Geometry::dWithin(const Geometry* const rhs, const double& distance) const _NOEXCEPT_OP(false)
{
  assert(distance >= 0.0);

#ifdef TERRALIB_GEOS_ENABLED
  if( m_srid != rhs->m_srid )
  {
    throw te::common::Exception(TE_TR("this method must not be used with different SRIDs geometries."));
  }

  try
  {
    std::unique_ptr<geos::geom::Geometry> thisGeom(GEOSWriter::write(this));

    std::unique_ptr<geos::geom::Geometry> rhsGeom(GEOSWriter::write(rhs));

    return thisGeom->isWithinDistance(rhsGeom.get(), distance);
  }
  catch(geos::util::GEOSException& e)
  {
    throw te::common::Exception(e.what());
  }
#else
  throw te::common::Exception(TE_TR("dWithin routine is supported by GEOS! Please, enable the GEOS support."));
#endif
}

te::gm::GeomType te::gm::Geometry::getGeomTypeId(const std::string& gtype)
{
  std::map<std::string, GeomType>::const_iterator it = sm_geomTypeMap.find(gtype);

  if(it != sm_geomTypeMap.end())
    return it->second;

  return te::gm::UnknownGeometryType;
}

const std::string te::gm::Geometry::get2DGeometryType() const _NOEXCEPT_OP(true)
{
  switch (m_gType)
  {
  case te::gm::GeometryType:
  case te::gm::GeometryZType:
  case te::gm::GeometryMType:
  case te::gm::GeometryZMType:
    return "Geometry";

  case te::gm::PointType:
  case te::gm::PointZType:
  case te::gm::PointMType:
  case te::gm::PointZMType:
    return "Point";

  case te::gm::LineStringType:
  case te::gm::LineStringZType:
  case te::gm::LineStringMType:
  case te::gm::LineStringZMType:
    return "LineString";

  case te::gm::PolygonType:
  case te::gm::PolygonZType:
  case te::gm::PolygonMType:
  case te::gm::PolygonZMType:
    return "Polygon";

  case te::gm::GeometryCollectionType:
  case te::gm::GeometryCollectionZType:
  case te::gm::GeometryCollectionMType:
  case te::gm::GeometryCollectionZMType:
    return "GeometryCollection";

  case te::gm::MultiPointType:
  case te::gm::MultiPointZType:
  case te::gm::MultiPointMType:
  case te::gm::MultiPointZMType:
    return "MultiPoint";

  case te::gm::MultiLineStringType:
  case te::gm::MultiLineStringZType:
  case te::gm::MultiLineStringMType:
  case te::gm::MultiLineStringZMType:
    return "MultiLineString";

  case te::gm::MultiPolygonType:
  case te::gm::MultiPolygonZType:
  case te::gm::MultiPolygonMType:
  case te::gm::MultiPolygonZMType:
    return "MultiPolygon";

  case te::gm::CircularStringType:
  case te::gm::CircularStringZType:
  case te::gm::CircularStringMType:
  case te::gm::CircularStringZMType:
    return "CircularString";

  case te::gm::CompoundCurveType:
  case te::gm::CompoundCurveZType:
  case te::gm::CompoundCurveMType:
  case te::gm::CompoundCurveZMType:
    return "CompoundCurve";

  case te::gm::CurvePolygonType:
  case te::gm::CurvePolygonZType:
  case te::gm::CurvePolygonMType:
  case te::gm::CurvePolygonZMType:
    return "CurvePolygon";

  case te::gm::MultiSurfaceType:
  case te::gm::MultiSurfaceZType:
  case te::gm::MultiSurfaceMType:
  case te::gm::MultiSurfaceZMType:
    return "MultiSurface";

  default:
    return "UnknownGeometry";
  }
}

te::gm::GeomType te::gm::Geometry::get2DGeomTypeId() const _NOEXCEPT_OP(true)
{
  switch (m_gType)
  {
  case te::gm::GeometryType:
  case te::gm::GeometryZType:
  case te::gm::GeometryMType:
  case te::gm::GeometryZMType:
    return te::gm::GeometryType;

  case te::gm::PointType:
  case te::gm::PointZType:
  case te::gm::PointMType:
  case te::gm::PointZMType:
    return te::gm::PointType;

  case te::gm::LineStringType:
  case te::gm::LineStringZType:
  case te::gm::LineStringMType:
  case te::gm::LineStringZMType:
    return te::gm::LineStringType;

  case te::gm::PolygonType:
  case te::gm::PolygonZType:
  case te::gm::PolygonMType:
  case te::gm::PolygonZMType:
    return te::gm::PolygonType;

  case te::gm::GeometryCollectionType:
  case te::gm::GeometryCollectionZType:
  case te::gm::GeometryCollectionMType:
  case te::gm::GeometryCollectionZMType:
    return te::gm::GeometryCollectionType;

  case te::gm::MultiPointType:
  case te::gm::MultiPointZType:
  case te::gm::MultiPointMType:
  case te::gm::MultiPointZMType:
    return te::gm::MultiPointType;

  case te::gm::MultiLineStringType:
  case te::gm::MultiLineStringZType:
  case te::gm::MultiLineStringMType:
  case te::gm::MultiLineStringZMType:
    return te::gm::MultiLineStringType;

  case te::gm::MultiPolygonType:
  case te::gm::MultiPolygonZType:
  case te::gm::MultiPolygonMType:
  case te::gm::MultiPolygonZMType:
    return te::gm::MultiPolygonType;

  case te::gm::CircularStringType:
  case te::gm::CircularStringZType:
  case te::gm::CircularStringMType:
  case te::gm::CircularStringZMType:
    return te::gm::CircularStringType;

  case te::gm::CompoundCurveType:
  case te::gm::CompoundCurveZType:
  case te::gm::CompoundCurveMType:
  case te::gm::CompoundCurveZMType:
    return te::gm::CompoundCurveType;

  case te::gm::CurvePolygonType:
  case te::gm::CurvePolygonZType:
  case te::gm::CurvePolygonMType:
  case te::gm::CurvePolygonZMType:
    return te::gm::CurvePolygonType;

  case te::gm::MultiSurfaceType:
  case te::gm::MultiSurfaceZType:
  case te::gm::MultiSurfaceMType:
  case te::gm::MultiSurfaceZMType:
    return te::gm::MultiSurfaceType;

  default:
    return te::gm::UnknownGeometryType;
  }
}

std::string te::gm::Geometry::getGeomTypeString(const int& gId)
{
  std::map<std::string, GeomType>::const_iterator it;

  for (it = sm_geomTypeMap.begin(); it != sm_geomTypeMap.end(); ++it)
  {
    if (it->second == static_cast<GeomType>(gId))
      return it->first;
  }

  return "UNKNOWGEOMETRYTYPE";
}

bool te::gm::Geometry::isGeomType(const std::string& stype)
{
  return getGeomTypeId(stype) != te::gm::UnknownGeometryType;
}

void te::gm::Geometry::loadGeomTypeId()
{
  if(!sm_geomTypeMap.empty())
    return;

  sm_geomTypeMap["GEOMETRY"] = te::gm::GeometryType;
  sm_geomTypeMap["GEOMETRYZ"] = te::gm::GeometryZType;
  sm_geomTypeMap["GEOMETRYM"] = te::gm::GeometryMType;
  sm_geomTypeMap["GEOMETRYZM"] = te::gm::GeometryZMType;

  sm_geomTypeMap["POINT"] = te::gm::PointType;
  sm_geomTypeMap["POINTM"] = te::gm::PointMType;
  sm_geomTypeMap["POINTZ"] = te::gm::PointZType;
  sm_geomTypeMap["POINTZM"] = te::gm::PointZMType;      

  sm_geomTypeMap["LINESTRING"] = te::gm::LineStringType;
  sm_geomTypeMap["LINESTRINGM"] = te::gm::LineStringMType;
  sm_geomTypeMap["LINESTRINGZ"] = te::gm::LineStringZType;
  sm_geomTypeMap["LINESTRINGZM"] = te::gm::LineStringZMType;
  
  sm_geomTypeMap["POLYGON"] = te::gm::PolygonType;
  sm_geomTypeMap["POLYGONM"] = te::gm::PolygonMType;
  sm_geomTypeMap["POLYGONZ"] = te::gm::PolygonZType;
  sm_geomTypeMap["POLYGONZM"] = te::gm::PolygonZMType;      

  sm_geomTypeMap["MULTIPOINT"] = te::gm::MultiPointType;
  sm_geomTypeMap["MULTIPOINTM"] = te::gm::MultiPointMType;
  sm_geomTypeMap["MULTIPOINTZ"] = te::gm::MultiPointZType;
  sm_geomTypeMap["MULTIPOINTZM"] = te::gm::MultiPointZMType;      

  sm_geomTypeMap["MULTILINESTRING"] = te::gm::MultiLineStringType;
  sm_geomTypeMap["MULTILINESTRINGM"] = te::gm::MultiLineStringMType;
  sm_geomTypeMap["MULTILINESTRINGZ"] = te::gm::MultiLineStringZType;
  sm_geomTypeMap["MULTILINESTRINGZM"] = te::gm::MultiLineStringZMType;

  sm_geomTypeMap["MULTIPOLYGON"] = te::gm::MultiPolygonType;
  sm_geomTypeMap["MULTIPOLYGONM"] = te::gm::MultiPolygonMType;
  sm_geomTypeMap["MULTIPOLYGONZ"] = te::gm::MultiPolygonZType;
  sm_geomTypeMap["MULTIPOLYGONZM"] = te::gm::MultiPolygonZMType;

  sm_geomTypeMap["MULTISURFACE"] = te::gm::MultiSurfaceType;
  sm_geomTypeMap["MULTISURFACEM"] = te::gm::MultiSurfaceMType;
  sm_geomTypeMap["MULTISURFACEZ"] = te::gm::MultiSurfaceZType;
  sm_geomTypeMap["MULTISURFACEZM"] = te::gm::MultiSurfaceZMType;

  sm_geomTypeMap["GEOMETRYCOLLECTION"] = te::gm::GeometryCollectionType;
  sm_geomTypeMap["GEOMETRYCOLLECTIONM"] = te::gm::GeometryCollectionMType;
  sm_geomTypeMap["GEOMETRYCOLLECTIONZ"] = te::gm::GeometryCollectionZType;
  sm_geomTypeMap["GEOMETRYCOLLECTIONZM"] = te::gm::GeometryCollectionZMType;
}

int te::gm::Geometry::getTypeCode() const
{
  return te::dt::GEOMETRY_TYPE;
}