src/terralib/vp/Identity.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 Identity.cpp
 */

#include "../common/StringUtils.h"

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

#include "../dataaccess/dataset/DataSet.h"
#include "../dataaccess/dataset/ObjectIdSet.h"

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

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

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

#include "ComplexData.h"
#include "Identity.h"
#include "Utils.h"

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

bool te::vp::Identity::executeMemory(te::vp::AlgorithmParams* mainParams)
{
  te::vp::ValidateAlgorithmParams(mainParams, te::vp::MEMORY);

  // Validating parameters
  std::vector<te::vp::InputParams> inputParams = mainParams->getInputParams();

  if(inputParams.size() < 2)
    throw te::common::Exception(TE_TR(
        "It is necessary more than one item for performing the operation."));

  // Get input data.
  std::unique_ptr<te::da::DataSetType> inputDsType(
      inputParams[0].m_inputDataSetType);

  te::gm::GeometryProperty* inputGeomProp =
      te::da::GetFirstGeomProperty(inputDsType.get());

  std::unique_ptr<te::da::DataSet> inputDataSet(inputParams[0].m_inputDataSet);

  std::string inputDsName = inputDsType->getName();

  std::vector<std::string> tokens;
  te::common::Tokenize(inputDsName, tokens, ".");

  if(tokens.size() > 1)
    inputDsName = tokens[1];
  else
    inputDsName = tokens[0];

  // Get intersection data.
  std::unique_ptr<te::da::DataSetType> intersectionDsType(
      inputParams[1].m_inputDataSetType);

  te::gm::GeometryProperty* intersectionGeomProp =
      te::da::GetFirstGeomProperty(intersectionDsType.get());

  std::unique_ptr<te::da::DataSet> intersectionDataSet(
      inputParams[1].m_inputDataSet);

  std::string intersectionDsName = intersectionDsType->getName();

  tokens.clear();
  te::common::Tokenize(intersectionDsName, tokens, ".");

  if(tokens.size() > 1)
    intersectionDsName = tokens[1];
  else
    intersectionDsName = tokens[0];

  // Get output datasource.
  te::da::DataSourcePtr outputDataSource = mainParams->getOutputDataSource();

  // Build output dataset type
  std::unique_ptr<te::da::DataSetType> outputDataSetType(
      getOutputDataSetType(mainParams));

  // Get the first geometry property from output datasettype.
  te::gm::GeometryProperty* geomProp =
      te::da::GetFirstGeomProperty(outputDataSetType.get());

  // Insert intersection dataset in rtree.
  DataSetRTree rtree(new te::sam::rtree::Index<size_t, 8>);

  // Get specific params.
  const std::map<std::string, te::dt::AbstractData*>& specificParams =
      mainParams->getSpecificParams();

  // Create output dataset in memory.
  std::unique_ptr<te::mem::DataSet> outputDataSet(
      new te::mem::DataSet(outputDataSetType.get()));

  size_t p = 0;
  int inputSRID = inputGeomProp->getSRID();
  int intersectionSRID = intersectionGeomProp->getSRID();

  std::string intupGeomName = inputGeomProp->getName();
  std::string intersectionGeomName = intersectionGeomProp->getName();

  intersectionDataSet->moveBeforeFirst();
  while(intersectionDataSet->moveNext())
  {
    try
    {
      if (intersectionDataSet->isNull(intersectionGeomName))
        continue;

      std::unique_ptr<te::gm::Geometry> g =
          intersectionDataSet->getGeometry(intersectionGeomName);

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

      rtree->insert(*g->getMBR(), p);
      ++p;
    }
    catch(te::common::Exception& e)
    {
      TE_LOG_ERROR("Vector Processing - Identity - Intersection Layer: " + e.what());
      continue;
    }
  }

  std::vector<std::string> inputPropNames =
      this->getPropNames(specificParams, inputDsType->getName());

  std::vector<std::string> intersectionPropNames =
      this->getPropNames(specificParams, intersectionDsType->getName());

  inputDataSet->moveBeforeFirst();
  while(inputDataSet->moveNext())
  {
    try
    {
      // Create DataSetItem based on output DataSet;
      std::unique_ptr<te::mem::DataSetItem> item(
          new te::mem::DataSetItem(outputDataSet.get()));

      // Populate item with tabular data.
      for(std::size_t p = 0; p < inputPropNames.size(); ++p)
      {
        int pos = static_cast<int>(inputDsType->getPropertyPosition(inputPropNames[p]));

        if(!inputDataSet->isNull(pos))
        {
          item->setValue("A_" + inputPropNames[p],
                         inputDataSet->getValue(pos).release());
        }
      }

      if(inputDataSet->isNull(intupGeomName))
        continue;

      // Current geometry from Input Layer.
      std::unique_ptr<te::gm::Geometry> inputGeometry =
          inputDataSet->getGeometry(intupGeomName);

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

      // If is different srid, transform current geom to the "intersection"
      // projection, to search in rtree the candidates.
      if(inputSRID != intersectionSRID)
        inputGeometry->transform(intersectionSRID);

      std::vector<size_t> report;
      rtree->search(*inputGeometry->getMBR(), report);

      // If the geom SRID was changed, return to original SRID.
      if(inputGeometry->getSRID() != inputSRID)
        inputGeometry->transform(inputSRID);

      // If the search is empty, insert this item into Output dataSet;
      if(report.empty())
      {
        std::vector<te::gm::Geometry*> inputGeomVec;

        te::gm::Multi2Single(inputGeometry.get(), inputGeomVec);

        for(std::size_t g = 0; g < inputGeomVec.size(); ++g)
        {
          if(geomProp->getGeometryType() == inputGeomVec[g]->getGeomTypeId())
          {
            std::unique_ptr<te::mem::DataSetItem> currentItem = item->clone();
            currentItem->setGeometry(geomProp->getName(), inputGeomVec[g]);
            outputDataSet->add(currentItem.release());
          }
        }

        continue;
      }

      // Difference and Intersection Operation.
      std::vector<te::gm::Geometry*> geomUnionVec;

      for(size_t i = 0; i < report.size(); ++i)
      {
        intersectionDataSet->move(report[i]);

        std::unique_ptr<te::gm::Geometry> geometry =
            intersectionDataSet->getGeometry(intersectionGeomName);

        if(geometry->getSRID() != inputSRID)
          geometry->transform(inputSRID);

        std::unique_ptr<te::mem::DataSetItem> intersectionItem = item->clone();

        // Populate item with tabular data.
        for(std::size_t p = 0; p < intersectionPropNames.size(); ++p)
        {
          int pos = static_cast<int>(intersectionDsType->getPropertyPosition(intersectionPropNames[p]));

          if(!intersectionDataSet->isNull(pos))
          {
            intersectionItem->setValue("B_" + intersectionPropNames[p],
                                       intersectionDataSet->getValue(pos).release());
          }
        }

        geomUnionVec.push_back(
            dynamic_cast<te::gm::Geometry*>(geometry->clone()));

        geometry.reset(geometry->intersection(inputGeometry.get()));
        if(!geometry->isEmpty())
        {
          // Insert the current geometry into item;
          std::vector<te::gm::Geometry*> intersectionGeomVec;

          te::gm::Multi2Single(geometry.get(), intersectionGeomVec);

          for(std::size_t g = 0; g < intersectionGeomVec.size(); ++g)
          {
            if(geomProp->getGeometryType() ==
               intersectionGeomVec[g]->getGeomTypeId())
            {
              std::unique_ptr<te::mem::DataSetItem> currentItem =
                  intersectionItem->clone();

              currentItem->setGeometry(geomProp->getName(),
                                       intersectionGeomVec[g]);

              outputDataSet->add(currentItem.release());
            }
          }
        }
      }

    std::unique_ptr<te::gm::Geometry> geometryUnion;
    if(!geomUnionVec.empty())
      geometryUnion = te::gm::GetGeometryUnion(geomUnionVec);

      if(geometryUnion.get())
      {
        if(inputSRID != intersectionSRID)
          geometryUnion->transform(inputSRID);

        inputGeometry.reset(inputGeometry->difference(geometryUnion.get()));
      }

      if(!inputGeometry->isEmpty())
      {
        // Insert the current geometry into item;
        std::vector<te::gm::Geometry*> inputGeomVec;

        te::gm::Multi2Single(inputGeometry.get(), inputGeomVec);

        for(std::size_t g = 0; g < inputGeomVec.size(); ++g)
        {
          std::unique_ptr<te::mem::DataSetItem> currentItem = item->clone();
          currentItem->setGeometry(geomProp->getName(), inputGeomVec[g]);
          outputDataSet->add(currentItem.release());
        }
      }
    }
    catch(te::common::Exception& e)
    {
      TE_LOG_ERROR("Vector Processing - Identity - Input Layer: " + e.what());
      continue;
    }
  }

  std::unique_ptr<te::da::DataSet> dataSetPrepared =
      PrepareAdd(outputDataSet.release(), outputDataSetType.get());

  if(!dataSetPrepared.get())
    throw te::common::Exception(
        TE_TR("Output DataSet was not prepared to save."));

  if(dataSetPrepared->size() == 0)
    throw te::common::Exception("The resultant layer is empty!");

  Save(outputDataSource.get(), dataSetPrepared.get(), outputDataSetType.get());

  return true;
}

bool te::vp::Identity::executeQuery(te::vp::AlgorithmParams* /*mainParams*/)
{
  return false;
}

std::vector<std::string> te::vp::Identity::getPropNames(
    const std::map<std::string, te::dt::AbstractData*>& specificParams,
    const std::string& dataSetName)
{
  std::vector<std::string> propNameVec;

  if(specificParams.empty())
    return propNameVec;

  std::map<std::string, te::dt::AbstractData*>::const_iterator it =
      specificParams.find(dataSetName);

  if(it != specificParams.end())
  {
    te::vp::ComplexData<std::vector<std::string> >* cd =
        dynamic_cast<te::vp::ComplexData<std::vector<std::string> >*>(
            it->second);

    if(cd)
      propNameVec = cd->getValue();
  }

  return propNameVec;
}

te::da::DataSetType* te::vp::Identity::getOutputDataSetType(
    te::vp::AlgorithmParams* mainParams)
{
  // Get the input parameters
  std::vector<te::vp::InputParams> inputParams = mainParams->getInputParams();

  // Get the output dataset name.
  std::string outputDataSetName = mainParams->getOutputDataSetName();
  te::da::DataSetType* outputDataSetType =
      new te::da::DataSetType(outputDataSetName);

  // Set to output datasettype the primary key property.
  if(mainParams->getOutputDataSource()->getType() != "OGR")
  {
    te::dt::SimpleProperty* pkProperty = new te::dt::SimpleProperty(
        outputDataSetName + "_id", te::dt::INT32_TYPE);
    pkProperty->setAutoNumber(true);
    outputDataSetType->add(pkProperty);

    te::da::PrimaryKey* pk =
        new te::da::PrimaryKey(outputDataSetName + "_pk", outputDataSetType);
    pk->add(pkProperty);
    outputDataSetType->setPrimaryKey(pk);
  }

  // Get input geometry property.
  te::gm::GeometryProperty* intputGeomProp=nullptr;

  // Get tabular attributes.
  const std::map<std::string, te::dt::AbstractData*> specificParams =
      mainParams->getSpecificParams();

  te::da::DataSetType* dsType = nullptr;

  for(std::size_t i = 0; i < inputParams.size(); ++i)
  {
    if(inputParams[i].m_inputDataSetType)
      dsType = inputParams[i].m_inputDataSetType;
    else
      dsType =
          te::da::GetDataSetType(inputParams[i].m_inputDataSetName,
                                 inputParams[i].m_inputDataSource->getId());

    std::string alias;

    if(i == 0)
    {
      alias = "A_";
      intputGeomProp = te::da::GetFirstGeomProperty(dsType);
    }
    else
    {
      alias = "B_";
    }

    std::vector<std::string> propNames =
        getPropNames(specificParams, dsType->getName());

    for(std::size_t i = 0; i < propNames.size(); ++i)
    {
      te::dt::Property* prop = dsType->getProperty(propNames[i])->clone();

      prop->setName(alias + propNames[i]);

      if(!prop)
        continue;

      outputDataSetType->add(prop);
    }
  }

  // Get input geometry property.
  te::gm::GeomType inputGeomType = intputGeomProp->getGeometryType();
  te::gm::GeomType outputGeomType;

  if(te::gm::IsMultiType(inputGeomType))
    outputGeomType = te::gm::GetSimpleType(inputGeomType);
  else
    outputGeomType = inputGeomType;

  // Creating the geometry property.
  te::gm::GeometryProperty* newGeomProp = new te::gm::GeometryProperty("geom");
  newGeomProp->setGeometryType(outputGeomType);
  newGeomProp->setSRID(intputGeomProp->getSRID());

  outputDataSetType->add(newGeomProp);

  return outputDataSetType;
}