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

#include "../common/progress/TaskProgress.h"
#include "../core/logger/Logger.h"
#include "../core/translator/Translator.h"
#include "../dataaccess/dataset/DataSet.h"
#include "../dataaccess/query/DataSetName.h"
#include "../dataaccess/query/EqualTo.h"
#include "../dataaccess/query/Field.h"
#include "../dataaccess/query/Fields.h"
#include "../dataaccess/query/From.h"
#include "../dataaccess/query/FromItem.h"
#include "../dataaccess/query/LiteralString.h"
#include "../dataaccess/query/PropertyName.h"
#include "../dataaccess/query/Select.h"
#include "../dataaccess/query/ST_Buffer.h"
#include "../dataaccess/query/ST_IsValid.h"
#include "../dataaccess/query/ST_MakeValid.h"
#include "../dataaccess/query/ST_Multi.h"
#include "../dataaccess/query/Where.h"

#include "../dataaccess/datasource/DataSourceCapabilities.h"
#include "../dataaccess/datasource/DataSourceTransactor.h"

#include "../dataaccess/utils/Utils.h"

#include "../geometry/FixGeometryTopology.h"
#include "../geometry/Geometry.h"
#include "../geometry/GeometryProperty.h"
#include "../geometry/Utils.h"

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

#include "MakeGeometryValid.h"
#include "Utils.h"

#include "boost/lexical_cast.hpp"

bool te::vp::MakeGeometryValid::makeValid(const te::da::DataSourcePtr dataSource,
                                          const std::string &dataSetName,
                                          std::string& errorMessage,
                                          te::da::ObjectIdSet* oidSet)
{
  const te::da::DataSourceCapabilities dsCapabilities = dataSource->getCapabilities();
  te::da::QueryCapabilities queryCapabilities = dsCapabilities.getQueryCapabilities();

  if(queryCapabilities.supportsSpatialSQLDialect())
    return makeValidQuery(dataSource, dataSetName, errorMessage, oidSet);
  else
    return makeValidMemory(dataSource, dataSetName, errorMessage, oidSet);
}

bool te::vp::MakeGeometryValid::makeValidQuery(
    const te::da::DataSourcePtr dataSource, const std::string& dataSetName,
    std::string& errorMessage, da::ObjectIdSet* /*oidSet*/)
{
  // Creating and executing a query to fix geometries.
  //
  // NOTE: This code creates and executes a query using ST_MakeValid clause.
  //       The result is a te::da::DataSet with same attributes from input table
  //       plus fixed geometries.
  //

  std::unique_ptr<te::da::DataSetType> dsType(
      te::da::GetDataSetType(dataSetName, dataSource->getId()));

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

  te::da::Fields fields;

  std::vector<te::dt::Property*> props = dsType->getProperties();
  for(std::size_t p = 0; p < props.size(); ++p)
  {
    if(props[p]->getType() == te::dt::GEOMETRY_TYPE)
      continue;

    te::da::Field* field = new te::da::Field(props[p]->getName());
    fields.push_back(field);
  }

  te::da::ST_MakeValid st_makeValid(
      te::da::PropertyName(geometryProperty->getName()));
  te::da::Expression* e_makeValid = new te::da::ST_MakeValid(st_makeValid);

  te::da::Expression* e_buffer = new te::da::ST_Buffer(*e_makeValid, 0);

  te::da::Field* f_geometry;

  if(te::gm::IsMultiType(geometryProperty->getGeometryType()))
  {
    te::da::Expression* e_multi = new te::da::ST_Multi(*e_buffer);
    f_geometry = new te::da::Field(*e_multi, geometryProperty->getName());
  }
  else
  {
    f_geometry = new te::da::Field(*e_buffer, geometryProperty->getName());
  }

  fields.push_back(f_geometry);

  te::da::From from;
  te::da::FromItem* fromItem = new te::da::DataSetName(dataSetName);
  from.push_back(fromItem);

  te::da::ST_IsValid st_isValid(
      te::da::PropertyName(geometryProperty->getName()));
  te::da::Expression* e_isValid = new te::da::ST_IsValid(st_isValid);

  te::da::Expression* e_false = new te::da::LiteralString("f");

  te::da::EqualTo equal(e_isValid, e_false);

  te::da::Where where(equal);

  te::da::Select select(fields, from, where);

  std::unique_ptr<te::da::DataSet> ds;

  try
  {
    ds.reset(dataSource->query(select).release());
  }
  catch (const te::common::Exception& e)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " + e.what());

    errorMessage = e.what();
    return false;
  }
  catch (const std::exception& e)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " + e.what());

    errorMessage = e.what();
    return false;
  }
  catch (...)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": Unknown Excption.");

    errorMessage = "Unknown Excption.";
    return false;
  }


  // Updating input table.
  //
  // NOTE: This code uptades the invalid geometries.
  //

  // Get position of attr used as pk
  te::da::PrimaryKey* pk = dsType->getPrimaryKey();

  size_t numProps = pk->getProperties().size();
  std::vector<std::size_t> ids;

  for (size_t i = 0; i < numProps; ++i)
  {
    std::string propName = pk->getProperties()[i]->getName();
    ids.push_back(dsType->getPropertyPosition(propName));
  }

  std::set<int> posSet;
  posSet.insert((int)dsType->getPropertyPosition(geometryProperty->getName()));
  std::vector< std::set<int> > propsPos;

  for(std::size_t p = 0; p < ds->size(); ++p)
    propsPos.push_back(posSet);

  std::unique_ptr<te::da::DataSourceTransactor> transactor =
      dataSource->getTransactor();

  try
  {
    transactor->update(dataSetName, ds.get(), propsPos, ids);
  }
  catch (const te::common::Exception& e)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " + e.what());

    errorMessage = e.what();

    transactor->rollBack();
    return false;
  }
  catch (const std::exception& e)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " + e.what());

    errorMessage = e.what();

    transactor->rollBack();
    return false;
  }
  catch (...)
  {
    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": Unknown Excption.");

    errorMessage = "Unknown Excption.";

    transactor->rollBack();
    return false;
  }

  transactor->commit();

  return true;
}

bool te::vp::MakeGeometryValid::makeValidMemory(const te::da::DataSourcePtr dataSource,
                                                const std::string& dataSetName,
                                                std::string& errorMessage,
                                                te::da::ObjectIdSet* oidSet)
{
  std::unique_ptr<te::da::DataSourceTransactor> transactor =
      dataSource->getTransactor();

  std::unique_ptr<te::da::DataSetType> dataSetType(
      te::da::GetDataSetType(dataSetName, dataSource->getId()));

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

  std::unique_ptr<te::da::DataSet> dataSetToFix;
  std::unique_ptr<te::mem::DataSet> fixedDataSet(new te::mem::DataSet(dataSetType.get()));

  try
  {
    // Get the object id properties.
    std::vector<std::string> oidprops;
    te::da::GetOIDPropertyNames(dataSetType.get(), oidprops);

    // Get dataSet.
    if(oidSet && oidSet->size() > 0) // Based on Object Id Set.
    {
      dataSetToFix = dataSource->getDataSet(dataSetName, oidSet);
      oidSet->clear();
    }
    else
    {
      dataSetToFix = dataSource->getDataSet(dataSetName);
    }

    oidSet = new te::da::ObjectIdSet();

    // Scrolls through the dataset.
    dataSetToFix->moveBeforeFirst();

    te::common::TaskProgress task("Fixing...");
    task.setTotalSteps((int)dataSetToFix->size());

    while(dataSetToFix->moveNext())
    {
      if (!task.isActive())
      {
        errorMessage = TE_TR("Fix geometry canceled!");
        return false;
      }

      task.pulse();

      std::unique_ptr<te::gm::Geometry> geometryToFix =
          dataSetToFix->getGeometry(geometryProperty->getName());

      std::vector<te::gm::Geometry*> fixedGeometryVec;

      te::gm::TopologyValidationError topologyError;

      bool isValid = te::gm::CheckValidity(geometryToFix.get(), topologyError);

      if(!isValid)
      {
        isValid = te::gm::FixGeometryTopology::fixTopology(*geometryToFix.get(), fixedGeometryVec, topologyError);

        if(!isValid)
        {
          TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                       TE_TR("Fix Geometry") + ": " +
                       TE_TR("Could not fix geometry") + ": " + topologyError.m_message + "; " +
                       TE_TR("Coordinate") + ": (" + boost::lexical_cast<std::string>(topologyError.m_coordinate.getX()) + "," +
                                                                  boost::lexical_cast<std::string>(topologyError.m_coordinate.getY()) + "); " +
                       TE_TR("Geometry WKT") + ": " + geometryToFix->asText());

          errorMessage = "Some geometries could not be fixed. Check the log file for more information.";

          continue;
        }

        for(std::size_t i = 0; i < fixedGeometryVec.size(); ++i)
        {
          te::mem::DataSetItem* dataSetItemMemory = GetFilledItemMemory(dataSetToFix.get());

          dataSetItemMemory->setGeometry(geometryProperty->getName(), fixedGeometryVec[i]);

          fixedDataSet->add(dataSetItemMemory);
        }

        // Add the current object id, to remove from input dataset.
        te::da::ObjectId* oid = te::da::GenerateOID(dataSetToFix.get(), oidprops);
        oidSet->add(oid);

        for (std::string p : oidprops)
        {
          te::dt::Property* prop = dataSetType->getProperty(p);
          oidSet->addProperty(p, te::da::GetPropertyPos(dataSetType.get(), p), prop->getType());
        }

      }
    }

    std::map<std::string, std::string> options;

    transactor->remove(dataSetName, oidSet);
    transactor->add(dataSetName, fixedDataSet.get(), options);
  }
  catch (const te::common::Exception& e)
  {
    std::unique_ptr<te::gm::Geometry> geometryToFix = dataSetToFix->getGeometry(geometryProperty->getName());

    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " +
                 TE_TR("Could not fix geometry") + ": " + e.what() + "; " +
                 TE_TR("Geometry WKT") + ": " + geometryToFix->asText());

    errorMessage = e.what();
    return false;
  }
  catch (const std::exception& e)
  {
    std::unique_ptr<te::gm::Geometry> geometryToFix = dataSetToFix->getGeometry(geometryProperty->getName());

    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " +
                 TE_TR("Could not fix geometry") + ": " + e.what() + "; " +
                 TE_TR("Geometry WKT") + ": " + geometryToFix->asText());

    errorMessage = e.what();
    return false;
  }
  catch (...)
  {
    std::unique_ptr<te::gm::Geometry> geometryToFix = dataSetToFix->getGeometry(geometryProperty->getName());

    TE_LOG_ERROR(TE_TR("Vector Processing") + " - " +
                 TE_TR("Fix Geometry") + ": " +
                 TE_TR("Could not fix geometry") + ": Unknown Excption; " +
                 TE_TR("Geometry WKT") + ": " + geometryToFix->asText());

    errorMessage = "Unknown Excption.";
    return false;
  }

  return true;
}