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

  \brief Line To Polygon Vector Processing functions.
*/

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

#include "../datatype/Property.h"

#include "../dataaccess/query/And.h"
#include "../dataaccess/query/DataSetName.h"
#include "../dataaccess/query/EqualTo.h"
#include "../dataaccess/query/Expression.h"
#include "../dataaccess/query/Field.h"
#include "../dataaccess/query/Fields.h"
#include "../dataaccess/query/From.h"
#include "../dataaccess/query/FromItem.h"
#include "../dataaccess/query/GreaterThan.h"
#include "../dataaccess/query/GroupBy.h"
#include "../dataaccess/query/GroupByItem.h"
#include "../dataaccess/query/LiteralBool.h"
#include "../dataaccess/query/LiteralInt32.h"
#include "../dataaccess/query/PropertyName.h"
#include "../dataaccess/query/Select.h"
#include "../dataaccess/query/ST_AddPoint.h"
#include "../dataaccess/query/ST_Collect.h"
#include "../dataaccess/query/ST_Dump.h"
#include "../dataaccess/query/ST_IsClosed.h"
#include "../dataaccess/query/ST_MakePolygon.h"
#include "../dataaccess/query/ST_NPoints.h"
#include "../dataaccess/query/ST_SetSRID.h"
#include "../dataaccess/query/ST_StartPoint.h"
#include "../dataaccess/query/SubSelect.h"
#include "../dataaccess/query/Where.h"
#include "../dataaccess/utils/Utils.h"

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

#include "LineToPolygonQuery.h"
#include "Utils.h"

// STL
#include <memory>
#include <vector>

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

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

bool te::vp::LineToPolygonQuery::run() _NOEXCEPT_OP(false)
{
// Build output dataSetType.
  std::unique_ptr<te::da::DataSetType> outDsType = buildOutDataSetType();

// Make a query to build Polygons.
  te::da::Select select = getSelectQueryClosedLines(outDsType.get());

// Execute query to return a dataSet.
  std::unique_ptr<te::da::DataSet> dsQuery = m_inDsrc->query(select);

// Save result.
  te::vp::Save(m_outDsrc.get(), dsQuery.get(), outDsType.get());

  if(m_forceClose)
  {
// Make a query to build not closed lines.
    select = getSelectQueryForceCloseLines(outDsType.get());

// Execute query to return a dataSet.
    dsQuery = m_inDsrc->query(select);

// Save result.
    te::vp::Save(m_outDsrc.get(), dsQuery.get(), outDsType.get());
  }

  return true;
}

te::da::Select te::vp::LineToPolygonQuery::getSelectQueryClosedLines(te::da::DataSetType *dataSetType)
{
/************************************************
 * Get a vector of properties from dataSetType. *
 ************************************************/
  std::vector<te::dt::Property*> props = dataSetType->getProperties();



/***************************************************************************************
 * Get DataSetType from DataSource to compare geometry SRID with DataSetType of Layer. *
 ***************************************************************************************/
  std::unique_ptr<te::da::DataSetType> sourceDSetType = m_inDsrc->getDataSetType(m_inDsetName);
  te::gm::GeometryProperty* geomPropSource = te::da::GetFirstGeomProperty(sourceDSetType.get());

  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(m_converter->getResult());



/******************************************************************************************
 * Subselect that apply the ST_Dump function in geometric column to separate multi lines. *
 ******************************************************************************************/
  te::da::Fields* tabFields = new te::da::Fields;
  te::da::Fields* makePolygonFields = new te::da::Fields;
  te::da::Fields* collectFields = new te::da::Fields;


  for(std::size_t i = 0; i < props.size(); ++i)
  {
    if(props[i]->getType() != te::dt::GEOMETRY_TYPE)
    {
      te::da::PropertyName* pName = new te::da::PropertyName(props[i]->getName());
      te::da::Field* field = new te::da::Field(pName);
      tabFields->push_back(field);
    }
    else
    {
      te::da::Expression* e_geometry;

      if (geomPropSource->getSRID() != geomProp->getSRID())
      {
        te::da::LiteralInt32* srid = new te::da::LiteralInt32(geomProp->getSRID());
        e_geometry = new te::da::ST_SetSRID(new te::da::PropertyName(props[i]->getName()), srid);
      }
      else
      {
        e_geometry = new te::da::PropertyName(props[i]->getName());
      }

      makePolygonFields = tabFields->clone().release();

      te::da::Expression* e_dump = new te::da::ST_Dump(e_geometry);
      te::da::Expression* e_makePolygon = new te::da::ST_MakePolygon(e_dump);
      te::da::Field* f_makePolygon = new te::da::Field(*e_makePolygon, " polygon");

      makePolygonFields->push_back(f_makePolygon);
    }
  }

  te::da::FromItem* fromItemPol = new te::da::DataSetName(m_inDsetName);
  te::da::From* fromPol = new te::da::From;
  fromPol->push_back(fromItemPol);

  te::da::Expression* e_isClosed = new te::da::ST_IsClosed(te::da::PropertyName(geomProp->getName()));

  te::da::Where* w = nullptr;

  if(m_oidSet)
  {
    te::da::Expression* e_and = new te::da::And(e_isClosed, m_oidSet->getExpression());
    w = new te::da::Where(e_and);
  }
  else
  {
    w = new te::da::Where(e_isClosed);
  }


  te::da::Select select_Pol(makePolygonFields, fromPol, w);
  te::da::SubSelect subSelect_Pol(select_Pol, "pol");



/******************************************
 * SubSelect to create polygons by lines. *
 ******************************************/
  collectFields = tabFields->clone().release();

  te::da::PropertyName* gName = new te::da::PropertyName("polygon");
  te::da::Expression* e_collect = new te::da::ST_Collect(gName);
  te::da::Field* f_collect = new te::da::Field(*e_collect, geomProp->getName());

  collectFields->push_back(f_collect);

  te::da::FromItem* fromItem = new te::da::SubSelect(subSelect_Pol);
  te::da::From* from = new te::da::From;
  from->push_back(fromItem);

  te::da::GroupBy* groupBy = new te::da::GroupBy();

  te::da::Fields::iterator f_it;

  for(f_it = tabFields->begin(); f_it < tabFields->end(); ++f_it)
  {
    te::da::GroupByItem* e_groupBy = new te::da::GroupByItem(f_it->getExpression());
    groupBy->push_back(e_groupBy);
  }

  te::da::Select select(collectFields, from, groupBy);

  return select;
}

te::da::Select te::vp::LineToPolygonQuery::getSelectQueryForceCloseLines(te::da::DataSetType *dataSetType)
{
/************************************************
 * Get a vector of properties from dataSetType. *
 ************************************************/
  std::vector<te::dt::Property*> props = dataSetType->getProperties();



/***************************************************************************************
 * Get DataSetType from DataSource to compare geometry SRID with DataSetType of Layer. *
 ***************************************************************************************/
  std::unique_ptr<te::da::DataSetType> sourceDSetType = m_inDsrc->getDataSetType(m_inDsetName);
  te::gm::GeometryProperty* geomPropSource = te::da::GetFirstGeomProperty(sourceDSetType.get());

  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(m_converter->getResult());



/******************************************************************************************
 * Subselect that apply the ST_Dump function in geometric column to separate multi lines. *
 ******************************************************************************************/
  te::da::Fields* tabFields = new te::da::Fields;
  te::da::Fields* dumpFields = new te::da::Fields;
  te::da::Fields* makePolygonFields = new te::da::Fields;
  te::da::Fields* collectFields = new te::da::Fields;

  for(std::size_t i = 0; i < props.size(); ++i)
  {
    if(props[i]->getType() != te::dt::GEOMETRY_TYPE)
    {
      te::da::PropertyName* pName = new te::da::PropertyName(props[i]->getName());
      te::da::Field* field = new te::da::Field(pName);
      tabFields->push_back(field);
    }
    else
    {
      te::da::Expression* e_geometry;

      if (geomPropSource->getSRID() != geomProp->getSRID())
      {
        te::da::LiteralInt32* srid = new te::da::LiteralInt32(geomProp->getSRID());
        e_geometry = new te::da::ST_SetSRID(new te::da::PropertyName(props[i]->getName()), srid);
      }
      else
      {
        e_geometry = new te::da::PropertyName(props[i]->getName());
      }

      dumpFields = tabFields->clone().release();

      te::da::Expression* e_dump = new te::da::ST_Dump(e_geometry);
      te::da::Field* f_dump = new te::da::Field(*e_dump, "dumpedGeom");
      dumpFields->push_back(f_dump);
    }
  }

  te::da::FromItem* fromItemDumped = new te::da::DataSetName(m_inDsetName);
  te::da::From* fromDumped = new te::da::From;
  fromDumped->push_back(fromItemDumped);

  te::da::Select dumpSelect(dumpFields, fromDumped);
  te::da::SubSelect dumpSubSelect(dumpSelect, "t1");



/******************************************
 * SubSelect to create polygons by lines. *
 ******************************************/
  makePolygonFields = tabFields->clone().release();

  te::da::Expression* e_startPoint = new te::da::ST_StartPoint(te::da::PropertyName("t1.dumpedGeom"));

  te::da::Expression* e_addPoint = new te::da::ST_AddPoint(te::da::PropertyName("t1.dumpedGeom"), *e_startPoint);

  te::da::Expression* e_makePolygon = new te::da::ST_MakePolygon(e_addPoint);

  te::da::Field* f_makePolygon = new te::da::Field(*e_makePolygon, "polygon");
  makePolygonFields->push_back(f_makePolygon);

  te::da::FromItem* fromItemMakePol = new te::da::SubSelect(dumpSubSelect);
  te::da::From* fromMakePol = new te::da::From;
  fromMakePol->push_back(fromItemMakePol);

  te::da::Expression* e_nPoints = new te::da::ST_NPoints(te::da::PropertyName("t1.dumpedGeom"));
  te::da::Expression* e_literalInt = new te::da::LiteralInt32(2);
  te::da::Expression* e_greaterThan = new te::da::GreaterThan(e_nPoints, e_literalInt);

  te::da::Expression* e_isClosed = new te::da::ST_IsClosed(te::da::PropertyName("t1.dumpedGeom"));
  te::da::Expression* e_false = new te::da::LiteralBool(false);
  te::da::Expression* e_equal = new te::da::EqualTo(e_isClosed, e_false);

  te::da::Expression* e_and = new te::da::And(e_greaterThan, e_equal);

  te::da::Where* w = nullptr;

  if(m_oidSet)
  {
    te::da::Expression* e_andOid = new te::da::And(e_and, m_oidSet->getExpression());
    w = new te::da::Where(e_andOid);
  }
  else
  {
    w = new te::da::Where(e_and);
  }

  te::da::Select selectMakePol(makePolygonFields, fromMakePol, w);
  te::da::SubSelect subSelectMakePol(selectMakePol, "pol");



/********************************************************
 * Select that apply Collect of all generated Polygons. *
 ********************************************************/
  collectFields = tabFields->clone().release();

  te::da::PropertyName* gName = new te::da::PropertyName("polygon");
  te::da::Expression* e_collect = new te::da::ST_Collect(gName);
  te::da::Field* f_collect = new te::da::Field(*e_collect, geomProp->getName());

  collectFields->push_back(f_collect);

  te::da::FromItem* fromItem = new te::da::SubSelect(subSelectMakePol);
  te::da::From* from = new te::da::From;
  from->push_back(fromItem);

  te::da::GroupBy* groupBy = new te::da::GroupBy();

  te::da::Fields::iterator f_it;

  for(f_it = tabFields->begin(); f_it < tabFields->end(); ++f_it)
  {
    te::da::GroupByItem* e_groupBy = new te::da::GroupByItem(f_it->getExpression());
    groupBy->push_back(e_groupBy);
  }

  te::da::Select select(collectFields, from, groupBy);

  return select;
}