FixGeometryTopology.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 FixGeometryTopology.cpp
 */

#include "../common/progress/TaskProgress.h"
#include "../common/STLUtils.h"
#include "../core/logger/Logger.h"
#include "../core/translator/Translator.h"

#include "Curve.h"
#include "FixGeometryTopology.h"
#include "LineString.h"
#include "Polygon.h"
#include "MultiPolygon.h"

bool te::gm::FixGeometryTopology::fixTopology(const te::gm::Geometry& geometry,
                                              std::vector<Geometry *>& fixedGeometryVector,
                                              TopologyValidationError topologyError)
{
  std::unique_ptr<te::gm::Geometry> newGeometry(dynamic_cast<te::gm::Geometry*>(geometry.clone()));

  if(!closeGeometryRing(*newGeometry.get(), topologyError))
  {
    return false;
  }

  if(!fixSelfIntersection(*newGeometry.get(), fixedGeometryVector, topologyError))
  {
    return false;
  }

  return true;
}

bool te::gm::FixGeometryTopology::closeGeometryRing(const te::gm::Geometry& geometry,
                                                    TopologyValidationError topologyError)
{
  te::gm::GeomType type = geometry.getGeomTypeId();
  if(type == te::gm::PolygonType ||
     type == te::gm::PolygonZType ||
     type == te::gm::PolygonMType ||
     type == te::gm::PolygonZMType)
  {
    const te::gm::Polygon* polygon = dynamic_cast<const te::gm::Polygon*>(&geometry);
    std::vector<te::gm::Curve*> curveVec = polygon->getRings();
    for(auto c : curveVec)
    {
      if (!c->isClosed())
      {
        std::unique_ptr<te::gm::Point> startPoint = c->getStartPoint();
        te::gm::LineString* ls = dynamic_cast<te::gm::LineString*>(c);

        std::size_t nPoints = ls->getNPoints();
        ls->setNumCoordinates(nPoints + 1);

        ls->setPointN(nPoints, *startPoint);
      }
    }

    return true;
  }
  else if (type == te::gm::MultiPolygonType ||
           type == te::gm::MultiPolygonZType ||
           type == te::gm::MultiPolygonMType ||
           type == te::gm::MultiPolygonZMType)
  {
    const te::gm::MultiPolygon* mPolygon = dynamic_cast<const te::gm::MultiPolygon*>(&geometry);
    std::vector<te::gm::Geometry*> geometryVec = mPolygon->getGeometries();
    for (auto g : geometryVec)
    {
      if(!closeGeometryRing(*g, topologyError))
      {
        return false;
      }
    }
    return true;
  }
  else
  {
    topologyError.m_message = TE_TR("Unexpected geometry type!");
    return false;
  }
}


bool te::gm::FixGeometryTopology::fixSelfIntersection(const te::gm::Geometry& geometry,
                                                      std::vector<te::gm::Geometry*>& fixedGeometryVector,
                                                      TopologyValidationError topologyError)
{
  std::unique_ptr<te::gm::Geometry> geomBuffer(geometry.buffer(0.0));

  if(geomBuffer->getGeomTypeId() != te::gm::MultiPolygonType &&
     geomBuffer->getGeomTypeId() != te::gm::PolygonType)
  {
    topologyError.m_coordinate = geomBuffer->getCentroid();
    topologyError.m_message = TE_TR("It was generated a geometry with an unexpected type.");
    return false;
  }

  std::vector<te::gm::Geometry*> vecSingleGeoms;
  te::gm::Multi2Single(geomBuffer.get(), vecSingleGeoms);

  for(auto g : vecSingleGeoms)
  {
    bool isValid = CheckValidity(g, topologyError);

    if(!isValid)
    {
      te::common::FreeContents(vecSingleGeoms);
      return false;
    }
  }

  if (geometry.getGeomTypeId() == te::gm::MultiPolygonType)
  {
    for (std::size_t i = 0; i < vecSingleGeoms.size(); ++i)
    {
      te::gm::MultiPolygon* pol = new te::gm::MultiPolygon(0, te::gm::MultiPolygonType, geometry.getSRID());

      pol->add((te::gm::Geometry*)vecSingleGeoms[i]);

      fixedGeometryVector.push_back(pol);
    }
  }
  else if (geometry.getGeomTypeId() == te::gm::PolygonType)
  {
    for (std::size_t i = 0; i < vecSingleGeoms.size(); ++i)
    {
      fixedGeometryVector.push_back((te::gm::Geometry*)vecSingleGeoms[i]);
    }
  }
  else
  {
    te::common::FreeContents(vecSingleGeoms);
    topologyError.m_coordinate = geometry.getCentroid();
    topologyError.m_message = TE_TR("Unexpected geometry type!");

    return false;
  }

  return true;
}