MergeGeometriesTool.cpp

Go to the documentation of this file.

/*  Copyright (C) 2001-2009 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 terralib/edit/qt/tools/MergeGeometriesTool.cpp

  \brief This class implements a concrete tool to merge polygons.
*/

// TerraLib
#include "../../../common/STLUtils.h"
#include "../../../geometry/Envelope.h"
#include "../../../geometry/MultiPolygon.h"
#include "../../../geometry/Point.h"
#include "../../../geometry/Utils.h"
#include "../../../qt/widgets/canvas/MapDisplay.h"
#include "../../../qt/widgets/Utils.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../Feature.h"
#include "../../RepositoryManager.h"
#include "../../Utils.h"
#include "../Renderer.h"
#include "../Utils.h"
#include "../core/command/AddCommand.h"
#include "../core/UndoStackManager.h"
#include "MergeGeometriesTool.h"

// Qt
#include <QMessageBox>
#include <QMouseEvent>
#include <QPainter>
#include <QPixmap>
#include <QInputDialog>

// STL
#include <cassert>
#include <memory>

te::edit::MergeGeometriesTool::MergeGeometriesTool(te::qt::widgets::MapDisplay* display, const te::map::AbstractLayerPtr& layer, const QCursor& cursor, QObject* parent)
  : GeometriesUpdateTool(display, layer.get(), parent),
  m_gc(new te::gm::GeometryCollection(0, te::gm::MultiPolygonType, m_layer->getSRID())),
  m_oidSet(nullptr)
{
  setCursor(cursor);

  editingFinished();
}

te::edit::MergeGeometriesTool::~MergeGeometriesTool()
{
  //Removes from the repository
  std::set<te::da::ObjectId*, te::common::LessCmp<te::da::ObjectId*> >::const_iterator it;
  for (it = m_oidSet->begin(); it != m_oidSet->end(); ++it)
  {
    if (RepositoryManager::getInstance().hasIdentify(m_layer->getId(), (*it)))
      RepositoryManager::getInstance().removeFeature(m_layer->getId(), (*it));
  }

  delete m_oidSet;
}

void te::edit::MergeGeometriesTool::editingFinished()
{
  try
  {
    te::gm::Geometry* geom = nullptr;

    const te::da::ObjectIdSet* objSet = m_layer->getSelected();

    std::unique_ptr<te::da::DataSet> ds(m_layer->getData(objSet));

    std::unique_ptr<te::da::DataSetType> dt(m_layer->getSchema()) ;

    te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dt.get());

    if (m_oidSet == nullptr)
      m_oidSet = new te::da::ObjectIdSet();

    while (ds->moveNext())
      m_gc->add(dynamic_cast<te::gm::Geometry*>(ds->getGeometry(geomProp->getName()).release()));

    if (spatialRelationDisjoint(*m_gc))
    {
      m_gc->removeGeometryN(m_gc->getNumGeometries() - 1);

      QMessageBox::critical(m_display, tr("Error"), QString(tr("All geometries selected must touch!")));
      return;
    }

    getBaseOID(*objSet, tr("Allow to merge geometries selecting the geom_id that will keep the attributes."));

    if (m_chosenOid == "")
      return;

    te::gm::Envelope env(getRefEnvelope());
    if (!env.isValid())
    {
      QMessageBox::warning(m_display, tr("Merge Geometries"), tr("Invalid bounding box."));
      return;
    }

    m_feature = PickFeature(m_layer, env, m_display->getSRID());
    if (m_feature == nullptr)
    {
      QMessageBox::information(m_display, tr("Merge Geometries"), tr("Pick Feature Failed."));
      return;
    }

    geom = dynamic_cast<te::gm::Geometry*>(m_gc->getGeometryN(0)->clone());
    for (std::size_t i = 1; i < m_gc->getNumGeometries(); ++i)
      geom = te::gm::Validate(geom)->Union(te::gm::Validate(m_gc->getGeometryN(i)));

    std::set<te::da::ObjectId*, te::common::LessCmp<te::da::ObjectId*> >::const_iterator it;
    for (it = m_oidSet->begin(); it != m_oidSet->end(); ++it)
    {
      if ((*it)->getValueAsString() == m_chosenOid)
      {
        m_feature->setId((*it)->clone());
        break;
      }
    }

    m_feature->setGeometry(dynamic_cast<te::gm::Geometry*>(geom->clone()));

    delete geom;

    draw();

    storeFeature();

    emit geometriesEdited();
  }
  catch (std::exception& e)
  {
    QMessageBox::critical(m_display, tr("Merge Geometries"), QString(tr("Could not merge.") + " %1.").arg(e.what()));
    return;
  }
}

bool te::edit::MergeGeometriesTool::spatialRelationDisjoint(te::gm::GeometryCollection& gc)
{
  bool result = false;
  std::size_t j = 0;

  for (std::size_t i = 0; i < gc.getNumGeometries(); ++i)
  {
    std::size_t aux = 0;

    te::gm::Geometry* g1 = gc.getGeometryN(i);

    for (j = 0; j < gc.getNumGeometries(); j++)
    {
      if (j != i)
      {
        if (g1->disjoint(gc.getGeometryN(j)))
          aux++;
      }
    }

    if (aux == (j-1))
    {
      result = true;
      break;
    }

  }

  return result;
}

void te::edit::MergeGeometriesTool::getBaseOID(const te::da::ObjectIdSet& objSet, QString msg)
{
  bool ok;
  QStringList qValues;

  std::set<te::da::ObjectId*, te::common::LessCmp<te::da::ObjectId*> >::const_iterator it;

  for (it = objSet.begin(); it != objSet.end(); ++it)
    qValues.append((*it)->getValueAsString().c_str());

  QString qValue = QInputDialog::getItem(m_display, QString(tr("Merge Geometries")), QObject::tr(msg.toUtf8().data()), qValues, 0, false, &ok);

  if (qValue.isEmpty() || !ok)
    return;

  for (it = objSet.begin(); it != objSet.end(); ++it)
  {
    if ((*it)->getValueAsString() == qValue.toUtf8().data())
      m_chosenOid = (*it)->clone()->getValueAsString();
    
    m_oidSet->add((*it)->clone());
  }
}

te::gm::Envelope te::edit::MergeGeometriesTool::getRefEnvelope()
{
  std::size_t pType = 0;
  std::string convOid;
  std::vector<std::string> oidPropertyNames;
  te::gm::Envelope env;

  std::unique_ptr<te::da::DataSet> ds(m_layer->getData(m_layer->getSelected()));

  std::unique_ptr<te::da::DataSetType> dt(m_layer->getSchema());

  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dt.get());

  te::da::GetOIDPropertyNames(m_layer->getSchema().get(), oidPropertyNames);

  pType = ds->getPropertyDataType(te::da::GetPropertyPos(ds.get(), oidPropertyNames[0]));

  ds->moveBeforeFirst();
  while (ds->moveNext())
  {
    switch (pType)
    {
      case te::dt::INT16_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getInt16(oidPropertyNames[0]));
        break;

      case te::dt::INT32_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getInt32(oidPropertyNames[0]));
        break;

      case te::dt::INT64_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getInt64(oidPropertyNames[0]));
        break;

      case te::dt::FLOAT_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getFloat(oidPropertyNames[0]));
        break;

      case te::dt::DOUBLE_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getDouble(oidPropertyNames[0]));
        break;

      case te::dt::NUMERIC_TYPE:
        convOid = boost::lexical_cast<std::string>(ds->getNumeric(oidPropertyNames[0]));
        break;

      case te::dt::STRING_TYPE:
        convOid = ds->getString(oidPropertyNames[0]);
        break;
    }
    if (m_chosenOid == convOid)
    {
      env = *((ds->getGeometry(geomProp->getName()))->getMBR());

      if ((m_layer->getSRID() != TE_UNKNOWN_SRS) && (m_display->getSRID() != TE_UNKNOWN_SRS) && (m_layer->getSRID() != m_display->getSRID()))
        env.transform(m_layer->getSRID(), m_display->getSRID());

      break;
    }
  }

  return env;
}

void te::edit::MergeGeometriesTool::draw()
{
  const te::gm::Envelope& env = m_display->getExtent();
  if (!env.isValid())
    return;

  // Clear!
  QPixmap* draft = m_display->getDraftPixmap();
  draft->fill(Qt::transparent);

  // Initialize the renderer
  Renderer& renderer = Renderer::getInstance();
  renderer.begin(draft, env, m_display->getSRID());

  // Draw the layer edited geometries
  renderer.drawRepository(m_layer->getId(), env, m_display->getSRID());

  // Draw the current geometry and the vertexes
  renderer.draw(m_feature->getGeometry(), true);

  renderer.end();

  m_display->repaint();
}

void te::edit::MergeGeometriesTool::storeFeature()
{
  std::set<te::da::ObjectId*, te::common::LessCmp<te::da::ObjectId*> >::const_iterator it;

  for (it = m_oidSet->begin(); it != m_oidSet->end(); ++it)
  {
    if ((*it)->getValueAsString() == m_chosenOid)
      m_feature->setId((*it)->clone());
    else
    {
      Feature* f = new Feature((*it)->clone(), new te::gm::Point(0, 0));
      f->setOperationTypeId(DELETE);

      RepositoryManager::getInstance().addFeature(m_layer->getId(), f->clone());

      delete f;
      f = nullptr;
    }
  }

  RepositoryManager::getInstance().addFeature(m_layer->getId(), m_feature->clone());
}

void te::edit::MergeGeometriesTool::pickFeature(const te::map::AbstractLayerPtr& layer, const QPointF& pos)
{
  delete m_feature;

  te::gm::Envelope env = buildEnvelope(pos);

  try
  {
    m_feature = PickFeature(layer, env, m_display->getSRID());
    if (m_feature)
      m_feature->setOperationTypeId(UPDATE);
  }
  catch (std::exception& e)
  {
    QMessageBox::critical(m_display, tr("Error"), QString(tr("The geometry cannot be selected from the layer. Details:") + " %1.").arg(e.what()));
  }
}

te::gm::Envelope te::edit::MergeGeometriesTool::buildEnvelope(const QPointF& pos)
{
  QPointF pixelOffset(4.0, 4.0);

  QRectF rect(pos - pixelOffset, pos + pixelOffset);

  // Converts rect boundary to world coordinates
  QPointF ll(rect.left(), rect.bottom());
  QPointF ur(rect.right(), rect.top());
  ll = m_display->transform(ll);
  ur = m_display->transform(ur);

  te::gm::Envelope env(ll.x(), ll.y(), ur.x(), ur.y());

  return env;
}