DeleteGeometryByAreaTool.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/DeleteGeometryTool.cpp

  \brief This class implements a concrete tool to remove geometries by drawing an area (polygon).
*/

// TerraLib
#include "../../../geometry/GeometryProperty.h"
#include "../../../geometry/MultiPolygon.h"
#include "../../../dataaccess/dataset/ObjectIdSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../datatype/SimpleData.h"
#include "../../../qt/widgets/canvas/MapDisplay.h"
#include "../../../qt/widgets/utils/ScopedCursor.h"
#include "../../../qt/widgets/Utils.h"
#include "../../Feature.h"
#include "../../RepositoryManager.h"
#include "../../Utils.h"
#include "../Renderer.h"
#include "../Utils.h"
#include "DeleteGeometryByAreaTool.h"

// Qt
#include <QMessageBox>
#include <QMouseEvent>

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

te::edit::DeleteGeometryByAreaTool::DeleteGeometryByAreaTool(te::qt::widgets::MapDisplay* display, const te::map::AbstractLayerPtr& layer, QObject* parent)
  : GeometriesUpdateTool(display, layer.get(), parent),
  m_selectionStarted(false),
  m_keepPreviousSelection(false),
  m_selectionByPointing(false),
  m_area(nullptr)
{
  updateCursor();
}

te::edit::DeleteGeometryByAreaTool::~DeleteGeometryByAreaTool() = default;

bool te::edit::DeleteGeometryByAreaTool::mousePressEvent(QMouseEvent* e)
{
  if (e->button() != Qt::LeftButton)
    return false;

  m_selectionStarted = true;

  QPointF pw = m_display->transform(te::edit::GetPosition(e));

  te::gm::Coord2D coord = te::gm::Coord2D(pw.x(), pw.y());

  te::edit::TrySnap(coord, m_display->getSRID());

  m_coords.push_back(coord);

  return true;
}

bool te::edit::DeleteGeometryByAreaTool::mouseMoveEvent(QMouseEvent* e)
{
  if (m_coords.size() < 1 || !m_selectionStarted)
    return false;

  QPointF pos = te::edit::GetPosition(e);
  pos += QPointF(0.0001, 0.0001); // To avoid collinear points on polygon

  QPointF pw = m_display->transform(pos);

  te::gm::Coord2D coord = te::gm::Coord2D(pw.x(), pw.y());

  te::edit::TrySnap(coord, m_display->getSRID());

  m_coords.push_back(coord);

  m_lastPos = te::gm::Coord2D(coord.x, coord.y);

  draw();

  return false;
}

bool te::edit::DeleteGeometryByAreaTool::mouseReleaseEvent(QMouseEvent* e)
{
  if (e->button() == Qt::MiddleButton)
    return false;

  te::qt::widgets::ScopedCursor cursor(Qt::WaitCursor);

  m_selectionStarted = false;

  m_coords.clear();

  m_keepPreviousSelection = false;

  Qt::KeyboardModifiers keys = e->modifiers();

  if (keys & Qt::ControlModifier)
    m_keepPreviousSelection = true;

  m_selectionByPointing = false;

  te::gm::Envelope env;
  if (m_area == nullptr)
  {
    m_selectionByPointing = true;
    env = buildEnvelope(te::edit::GetPosition(e));
  }
  else
  {
    env = *m_area->getMBR();
  }

  // Select the draft layer
  executeSelection(env);

  emit geometriesEdited();

  delete m_area;
  m_area = nullptr;

  return true;
}

void te::edit::DeleteGeometryByAreaTool::executeSelection(const te::gm::Envelope& e)
{
  if (m_layer->getVisibility() != te::map::VISIBLE ||
    !m_layer->isValid() || m_layer->getType() == "FOLDERLAYER")
    return;

  te::gm::Envelope reprojectedEnvelope(e);

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

  if (!reprojectedEnvelope.intersects(m_layer->getExtent()))
    return;

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

  if (!schema->hasGeom())
    return;

  // Clear previous selection?
  if (!m_keepPreviousSelection)
    te::edit::RepositoryManager::getInstance().clear(m_layer->getId());

  try
  {
    // Gets the layer schema
    std::unique_ptr<const te::map::LayerSchema> schema(m_layer->getSchema());
    if (!schema->hasGeom())
      return;

    te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(schema.get());

    // Gets the dataset
    std::unique_ptr<te::da::DataSet> dataset = m_layer->getData(gp->getName(), &reprojectedEnvelope, te::gm::INTERSECTS);
    assert(dataset.get());

    std::vector<std::string> pnames;
    te::da::GetOIDPropertyNames(schema.get(), pnames);

    if (m_selectionByPointing == false)
    {
      while (dataset->moveNext())
      {
        std::unique_ptr<te::gm::Geometry> g(dataset->getGeometry(gp->getName()));

        if (g.get() == nullptr)
          continue;

        if (g->getSRID() == TE_UNKNOWN_SRS)
          g->setSRID(m_layer->getSRID());

        if (!g->intersects(m_area))
          continue;

        te::edit::OperationType oType = DELETE;

        if (RepositoryManager::getInstance().hasIdentify(m_layer->getId(), te::da::GenerateOID(dataset.get(), pnames)))
        {
          m_feature = RepositoryManager::getInstance().getFeature(m_layer->getId(), te::da::GenerateOID(dataset.get(), pnames));
          m_feature->getOperationTypeId() == UPDATE ? oType = DELETE : oType = UPDATE;
        }

        // Feature found!
        m_feature = new Feature(te::da::GenerateOID(dataset.get(), pnames), g.release());
        m_feature->setOperationTypeId(oType);

        storeFeature();

        delete m_feature;
        m_feature = nullptr;
      }
    }
    else
    {
      while (dataset->moveNext())
      {
        std::unique_ptr<te::gm::Geometry> g(dataset->getGeometry(gp->getName()));

        if (g.get() == nullptr)
          continue;

        if (g->getSRID() == TE_UNKNOWN_SRS)
          g->setSRID(m_layer->getSRID());

        te::edit::OperationType oType = DELETE;

        if (RepositoryManager::getInstance().hasIdentify(m_layer->getId(), te::da::GenerateOID(dataset.get(), pnames)))
          m_feature->getOperationTypeId() == UPDATE ? oType = DELETE : oType = UPDATE;

        m_feature = new Feature(te::da::GenerateOID(dataset.get(), pnames), g.release());
        m_feature->setOperationTypeId(oType);

        storeFeature();

        delete m_feature;
        m_feature = nullptr;
      }

    }
  }
  catch (std::exception& e)
  {
    QMessageBox::critical(m_display, tr("Error"), QString(tr("The selection cannot be retrieved from the layer. Details:") + " %1.").arg(e.what()));
    // TODO: catch the exceptions...
  }
}

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

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

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

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

  renderer.setPolygonStyle(QColor(255, 255, 255, 0), QColor(255, 0, 0), 1);
  if (!m_coords.empty())
  {
    // Draw the geometry being created
    if (m_coords.size() > 2)
      drawPolygon();
  }

  renderer.end();

  m_display->repaint();
}

void te::edit::DeleteGeometryByAreaTool::drawPolygon()
{
  // Build the geometry
  m_area= buildPolygon();

  // Draw the current geometry and the vertexes
  te::edit::Renderer& renderer = te::edit::Renderer::getInstance();
  renderer.draw(m_area);

}

te::gm::Geometry* te::edit::DeleteGeometryByAreaTool::buildPolygon()
{
  // Build the geometry
  te::gm::LinearRing* ring = new te::gm::LinearRing(m_coords.size() + 1, te::gm::LineStringType);
  for (std::size_t i = 0; i < m_coords.size(); ++i)
    ring->setPoint(i, m_coords[i].x, m_coords[i].y);
  ring->setPoint(m_coords.size(), m_coords[0].x, m_coords[0].y); // Closing...

  te::gm::Polygon* polygon = new te::gm::Polygon(1, te::gm::PolygonType);
  polygon->setRingN(0, ring);

  polygon->setSRID(m_display->getSRID());

  if (polygon->getSRID() == m_layer->getSRID())
    return polygon;

  // else, need conversion...
  polygon->transform(m_layer->getSRID());

  return polygon;
}

te::gm::Envelope te::edit::DeleteGeometryByAreaTool::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;
}

void te::edit::DeleteGeometryByAreaTool::updateCursor()
{
  setCursor(Qt::ArrowCursor);
}

void te::edit::DeleteGeometryByAreaTool::storeFeature()
{
  RepositoryManager::getInstance().addFeature(m_layer->getId(), m_feature->clone());
}