MultipartToSinglepart.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 MultipartToSinglepart.h

  \brief Multipart to Singlepart Vector Processing functions.
*/

//Terralib

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

#include "../dataaccess/dataset/DataSet.h"
#include "../dataaccess/dataset/ObjectId.h"
#include "../dataaccess/dataset/ObjectIdSet.h"
#include "../dataaccess/utils/Utils.h"
#include "../datatype/Property.h"
#include "../datatype/SimpleProperty.h"
#include "../datatype/StringProperty.h"

#include "../geometry/Geometry.h"
#include "../geometry/GeometryProperty.h"
#include "../geometry/MultiLineString.h"
#include "../geometry/MultiPoint.h"
#include "../geometry/MultiPolygon.h"
#include "../geometry/Utils.h"

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

#include "MultipartToSinglepart.h"
#include "Config.h"
#include "Exception.h"
#include "Utils.h"

// STL
#include <map>
#include <cmath>
#include <string>
#include <vector>

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

te::vp::MultipartToSinglepart::MultipartToSinglepart()
  : m_oidSet(nullptr)
{
}

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

bool te::vp::MultipartToSinglepart::run()
{
  te::dt::Property* prop = te::da::GetFirstSpatialProperty(m_inDsType.get());
  te::gm::GeometryProperty* geomProp = dynamic_cast<te::gm::GeometryProperty*>(prop);

  if(!te::gm::IsMultiType(geomProp->getGeometryType()))
  {
    throw te::common::Exception(TE_TR("This layer has not a multipart geometry!"));
  }

  if(m_oidSet)
    return runSelected();
  else
    return runAll();
}

bool te::vp::MultipartToSinglepart::runAll()
{
  std::unique_ptr<te::da::DataSet> inDs;

  inDs = m_inDsrc->getDataSet(m_inDsName);

  std::size_t geomPos = te::da::GetFirstSpatialPropertyPos(inDs.get());

  std::unique_ptr<te::da::DataSetType> outDst = getOutDst();

  std::unique_ptr<te::mem::DataSet> outDs(new te::mem::DataSet(outDst.get()));

  inDs->moveBeforeFirst();

  int pkCount = 0;

  while(inDs->moveNext())
  {
    try
    {
      if (inDs->isNull(geomPos))
        continue;

      std::unique_ptr<te::gm::Geometry> geom = inDs->getGeometry(geomPos);

      std::vector<te::gm::Geometry*> geoms;
      te::gm::Multi2Single(geom.release(), geoms);

      if(geoms.size() == 1)
      {
        te::mem::DataSetItem* item = new te::mem::DataSetItem(outDs.get());

        for(std::size_t i = 0; i < inDs->getNumProperties(); ++i)
        {
          if(i == 0)
          {
            item->setInt32(0, (int32_t)pkCount);
            ++pkCount;
            item->setValue(1, inDs->getValue(i).release());
          }
          else if(i != geomPos)
            item->setValue((i+1), inDs->getValue(i).release());
          else
            item->setGeometry((i+1), geoms[0]);
        }

        outDs->add(item);
      }
      else
      {
        for(std::size_t g = 0; g < geoms.size(); ++g)
        {
          te::mem::DataSetItem* item = new te::mem::DataSetItem(outDs.get());

          for(std::size_t i = 0; i < inDs->getNumProperties(); ++i)
          {
            if(i == 0)
            {
              item->setInt32(0, (int32_t)pkCount);
              ++pkCount;
              item->setValue(1, inDs->getValue(i).release());
            }
            else if(i != geomPos)
              item->setValue((i+1), inDs->getValue(i).release());
            else
              item->setGeometry((i+1), geoms[g]);
          }

          outDs->add(item);
        }
      }
    }
    catch(te::common::Exception& e)
    {
      TE_LOG_ERROR("Vector Processing - Multipart to Singlepart - " + e.what());
      continue;
    }
  }

  te::vp::Save(m_outDsrc.get(), outDs.get(), outDst.get());

  return true;
}

bool te::vp::MultipartToSinglepart::runSelected()
{
  std::unique_ptr<te::da::DataSet> inDs;

  inDs = m_inDsrc->getDataSet(m_inDsName);

  std::size_t geomPos = te::da::GetFirstSpatialPropertyPos(inDs.get());

  std::unique_ptr<te::da::DataSetType> outDst = getOutDst(true);

  std::unique_ptr<te::mem::DataSet> outDs(new te::mem::DataSet(outDst.get()));

  inDs->moveBeforeFirst();

  int pkCount = 0;

  while(inDs->moveNext())
  {
    try
    {
      if (inDs->isNull(geomPos))
        continue;

      std::unique_ptr<te::gm::Geometry> geom = inDs->getGeometry(geomPos);

      te::da::ObjectId* geomOid = te::da::GenerateOID(inDs.get(), m_oidSet->getPropertyNames());

      std::vector<te::gm::Geometry*> geoms;
      std::vector<te::gm::Geometry*> multiGeoms;

      if(m_oidSet->contains(geomOid))
      {
        te::gm::Multi2Single(geom.release(), geoms);

        for(std::size_t i = 0; i < geoms.size(); ++i)
        {
          multiGeoms.push_back(single2multi(geoms[i]));
        }
      }
      else
      {
        geoms.push_back(geom.release());
      }

      if(geoms.size() == 1)
      {
        te::mem::DataSetItem* item = new te::mem::DataSetItem(outDs.get());

        for(std::size_t i = 0; i < inDs->getNumProperties(); ++i)
        {
          if(i == 0)
          {
            item->setInt32(0, (int32_t)pkCount);
            ++pkCount;
            item->setValue(1, inDs->getValue(i).release());
          }
          else if(i != geomPos)
            item->setValue((i+1), inDs->getValue(i).release());
          else
            item->setGeometry((i+1), geoms[0]);
        }

        outDs->add(item);
      }
      else
      {
        for(std::size_t g = 0; g < multiGeoms.size(); ++g)
        {
          te::mem::DataSetItem* item = new te::mem::DataSetItem(outDs.get());

          for(std::size_t i = 0; i < inDs->getNumProperties(); ++i)
          {
            if(i == 0)
            {
              item->setInt32(0, (int32_t)pkCount);
              ++pkCount;
              item->setValue(1, inDs->getValue(i).release());
            }
            else if(i != geomPos)
              item->setValue((i+1), inDs->getValue(i).release());
            else
              item->setGeometry((i+1), multiGeoms[g]);
          }

          outDs->add(item);
        }
      }
    }
    catch(te::common::Exception& e)
    {
      TE_LOG_ERROR("Vector Processing - Multipart to Singlepart - " + e.what());
      continue;
    }
  }

  te::vp::Save(m_outDsrc.get(), outDs.get(), outDst.get());
  return true;
}

void te::vp::MultipartToSinglepart::setInput(te::da::DataSourcePtr inDsrc,
                                             std::string inDsName,
                                             std::unique_ptr<te::da::DataSetType> inDsType,
                                             const te::da::ObjectIdSet* oidSet)
{
  m_inDsrc = inDsrc;
  m_inDsName = inDsName;
  m_inDsType = std::move(inDsType);
  m_oidSet = oidSet;
}

void te::vp::MultipartToSinglepart::setOutput(te::da::DataSourcePtr outDsrc, std::string outDsName)
{
  m_outDsrc = outDsrc;
  m_outDsName = outDsName;
}

std::unique_ptr<te::da::DataSetType> te::vp::MultipartToSinglepart::getOutDst(bool onlySelected)
{
  std::unique_ptr<te::da::DataSetType> outDst(new te::da::DataSetType(m_outDsName));

  te::dt::Property* newId = new te::dt::SimpleProperty("newid", te::dt::INT32_TYPE, true);

  outDst->add(newId);

  te::da::PrimaryKey* pk = new te::da::PrimaryKey(m_outDsName + "mpk", outDst.get());
  std::vector<te::dt::Property*> pkProps{ newId };

  pk->setProperties(pkProps);

  outDst->setPrimaryKey(pk);

  for(std::size_t i = 0; i < m_inDsType->size(); ++i)
  {
    te::dt::Property* oldP = m_inDsType->getProperty(i);
    te::dt::Property* newP = oldP->clone();

    if(!onlySelected)
    {
      if(newP->getType() == te::dt::GEOMETRY_TYPE)
      {
        te::gm::GeometryProperty* geomP = dynamic_cast<te::gm::GeometryProperty*>(newP);

        geomP->setGeometryType(te::gm::GetSimpleType(geomP->getGeometryType()));
      }
    }

    outDst->add(newP);
  }

  return outDst;
}

te::gm::Geometry* te::vp::MultipartToSinglepart::single2multi(te::gm::Geometry* geom)
{
  switch(geom->getGeomTypeId())
  {
    case te::gm::LineStringType:
    {
      te::gm::MultiLineString* g = new te::gm::MultiLineString(0, te::gm::MultiLineStringType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::LineStringMType:
    {
      te::gm::MultiLineString* g = new te::gm::MultiLineString(0, te::gm::MultiLineStringMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::LineStringZType:
    {
      te::gm::MultiLineString* g = new te::gm::MultiLineString(0, te::gm::MultiLineStringZType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::LineStringZMType:
    {
      te::gm::MultiLineString* g = new te::gm::MultiLineString(0, te::gm::MultiLineStringZMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PointType:
    {
      te::gm::MultiPoint* g = new te::gm::MultiPoint(0, te::gm::MultiPointType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PointMType:
    {
      te::gm::MultiPoint* g = new te::gm::MultiPoint(0, te::gm::MultiPointMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PointZType:
    {
      te::gm::MultiPoint* g = new te::gm::MultiPoint(0, te::gm::MultiPointZType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PointZMType:
    {
      te::gm::MultiPoint* g = new te::gm::MultiPoint(0, te::gm::MultiPointZMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PolygonType:
    {
      te::gm::MultiPolygon* g = new te::gm::MultiPolygon(0, te::gm::MultiPolygonType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PolygonMType:
    {
      te::gm::MultiPolygon* g = new te::gm::MultiPolygon(0, te::gm::MultiPolygonMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PolygonZType:
    {
      te::gm::MultiPolygon* g = new te::gm::MultiPolygon(0, te::gm::MultiPolygonZType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    case te::gm::PolygonZMType:
    {
      te::gm::MultiPolygon* g = new te::gm::MultiPolygon(0, te::gm::MultiPolygonZMType);
      g->add(geom);
      g->setSRID(geom->getSRID());
      return g;
    }
    default:
      return nullptr;
  }
}