GeometricOpDialog.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 terralib/vp/qt/GeometricOpDialog.cpp

  \brief A Qt dialog that allows users to run the basic geographic operations
  defined by VP module.
*/

// TerraLib
#include "../Enums.h"
#include "../../core/filesystem/FileSystem.h"
#include "../../core/logger/Logger.h"
#include "../../common/progress/ProgressManager.h"
#include "../../dataaccess/dataset/DataSet.h"
#include "../../dataaccess/dataset/DataSetType.h"
#include "../../dataaccess/dataset/DataSetTypeConverter.h"
#include "../../dataaccess/datasource/DataSourceCapabilities.h"
#include "../../dataaccess/datasource/DataSourceInfo.h"
#include "../../dataaccess/datasource/DataSourceInfoManager.h"
#include "../../dataaccess/datasource/DataSourceFactory.h"
#include "../../dataaccess/datasource/DataSourceManager.h"
#include "../../dataaccess/utils/Utils.h"

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

#include "../../maptools/AbstractLayer.h"

#include "../../qt/widgets/datasource/selector/DataSourceSelectorDialog.h"
#include "../../qt/widgets/progress/ProgressViewerDialog.h"
#include "../../qt/widgets/layer/utils/DataSet2Layer.h"
#include "../../qt/widgets/srs/SRSManagerDialog.h"
#include "../../qt/widgets/utils/FileDialog.h"

#include "../../srs/SpatialReferenceSystemManager.h"

#include "../Config.h"
#include "../Exception.h"

#include "GeometricOpDialog.h"
#include "ui_GeometricOpDialogForm.h"
#include "Utils.h"
#include "../GeometricOp.h"
#include "../GeometricOpMemory.h"
#include "../GeometricOpQuery.h"

// STL
#include <cassert>

// Qt
#include <QFileDialog>
#include <QMessageBox>

// Boost
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

te::vp::GeometricOpDialog::GeometricOpDialog(QWidget* parent,  Qt::WindowFlags f)
  : QDialog(parent, f),
    m_ui(new Ui::GeometricOpDialogForm),
    m_layers(std::list<te::map::AbstractLayerPtr>()),
    m_selectedLayer(nullptr)
{
  m_ui->setupUi(this);

  // icons
  QSize iconSize(32, 32);

  m_ui->m_convexHullCheckBox->setIconSize(iconSize);
  m_ui->m_convexHullCheckBox->setIcon(QIcon::fromTheme("vp-convex-hull-hint"));

  m_ui->m_centroidCheckBox->setIconSize(iconSize);
  m_ui->m_centroidCheckBox->setIcon(QIcon::fromTheme("vp-centroid-hint"));

  m_ui->m_mbrCheckBox->setIconSize(iconSize);
  m_ui->m_mbrCheckBox->setIcon(QIcon::fromTheme("vp-mbr-hint"));

  m_ui->m_areaCheckBox->setIconSize(iconSize);
  m_ui->m_areaCheckBox->setIcon(QIcon::fromTheme("vp-area-hint"));

  m_ui->m_lineCheckBox->setIconSize(iconSize);
  m_ui->m_lineCheckBox->setIcon(QIcon::fromTheme("vp-line-length-hint"));

  m_ui->m_perimeterCheckBox->setIconSize(iconSize);
  m_ui->m_perimeterCheckBox->setIcon(QIcon::fromTheme("vp-perimeter-hint"));

  m_ui->m_targetDatasourceToolButton->setIcon(QIcon::fromTheme("datasource"));

  m_ui->m_srsToolButton->setIcon(QIcon::fromTheme("srs"));

  connect(m_ui->m_inputLayerComboBox, SIGNAL(currentIndexChanged(int)), this,
          SLOT(onLayerComboBoxChanged(int)));
  connect(m_ui->m_attributesComboBox, SIGNAL(currentIndexChanged(int)), this,
          SLOT(onAttributeComboBoxChanged(int)));
  connect(m_ui->m_byObjectRadioButton, SIGNAL(toggled(bool)), this,
          SLOT(onAllObjectsToggled()));
  connect(m_ui->m_allLayerRadioButton, SIGNAL(toggled(bool)), this,
          SLOT(onAllLayerOperationToggled()));
  connect(m_ui->m_byAttributeRadioButton, SIGNAL(toggled(bool)), this,
          SLOT(onAttributeOperationToggled()));
  connect(m_ui->m_targetDatasourceToolButton, SIGNAL(pressed()), this,
          SLOT(onTargetDatasourceToolButtonPressed()));
  connect(m_ui->m_targetFileToolButton, SIGNAL(pressed()), this,
          SLOT(onTargetFileToolButtonPressed()));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), this,
          SLOT(onOkPushButtonClicked()));
  connect(m_ui->m_cancelPushButton, SIGNAL(clicked()), this,
          SLOT(onCancelPushButtonClicked()));
  connect(m_ui->m_srsToolButton, SIGNAL(clicked()), this,
          SLOT(onSrsToolButtonClicked()));

  m_ui->m_helpPushButton->setNameSpace("dpi.inpe.br.plugins");
  m_ui->m_helpPushButton->setPageReference("plugins/vp/vp_geometricOper.html");

  m_outputDatasource = te::da::DataSourceInfoPtr();
  m_ui->m_newLayerNameLineEdit->setEnabled(true);
}

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

void te::vp::GeometricOpDialog::setLayers(std::list<te::map::AbstractLayerPtr> layers)
{
  m_layers = layers;

  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();

  while(it != m_layers.end())
  {
    std::unique_ptr<te::da::DataSetType> dsType = it->get()->getSchema();
    if(dsType.get() && dsType->hasGeom())
    {
      m_ui->m_inputLayerComboBox->addItem(
          QString(it->get()->getTitle().c_str()),
          QVariant(it->get()->getId().c_str()));
    }
    ++it;
  }
}

te::map::AbstractLayerPtr te::vp::GeometricOpDialog::getInLayer()
{
  return m_selectedLayer;
}

std::vector<te::map::AbstractLayerPtr> te::vp::GeometricOpDialog::getOutLayer()
{
  return m_outputLayer;
}

bool te::vp::GeometricOpDialog::hasConvexHull()
{
  return m_ui->m_convexHullCheckBox->isChecked();
}

bool te::vp::GeometricOpDialog::hasCentroid()
{
  return m_ui->m_centroidCheckBox->isChecked();
}

bool te::vp::GeometricOpDialog::hasMBR()
{
  return m_ui->m_mbrCheckBox->isChecked();
}

bool te::vp::GeometricOpDialog::hasArea()
{
  return m_ui->m_areaCheckBox->isChecked();
}

bool te::vp::GeometricOpDialog::hasLine()
{
  return m_ui->m_lineCheckBox->isChecked();
}

bool te::vp::GeometricOpDialog::hasPerimeter()
{
  return m_ui->m_perimeterCheckBox->isChecked();
}

void te::vp::GeometricOpDialog::enableOperations(
    te::gm::GeomType type)
{
  switch(type)
  {
    case te::gm::PointType:
    case te::gm::PointMType:
    case te::gm::PointZType:
    case te::gm::PointZMType:
    case te::gm::PointKdType:
    case te::gm::MultiPointType:
    case te::gm::MultiPointMType:
    case te::gm::MultiPointZType:
    case te::gm::MultiPointZMType:
      m_ui->m_areaCheckBox->setEnabled(false);
      m_ui->m_lineCheckBox->setEnabled(false);
      m_ui->m_perimeterCheckBox->setEnabled(false);
      m_ui->m_byObjectRadioButton->setEnabled(false);
      m_ui->m_byAttributeRadioButton->setEnabled(false);
      m_ui->m_allLayerRadioButton->setChecked(true);
      break;
    case te::gm::LineStringType:
    case te::gm::LineStringMType:
    case te::gm::LineStringZType:
    case te::gm::LineStringZMType:
    case te::gm::MultiLineStringType:
    case te::gm::MultiLineStringMType:
    case te::gm::MultiLineStringZType:
    case te::gm::MultiLineStringZMType:
      m_ui->m_areaCheckBox->setEnabled(false);
      m_ui->m_lineCheckBox->setEnabled(true);
      m_ui->m_perimeterCheckBox->setEnabled(false);
      m_ui->m_byObjectRadioButton->setEnabled(true);
      m_ui->m_byAttributeRadioButton->setEnabled(true);
      m_ui->m_byObjectRadioButton->setChecked(true);
      break;
    default:
      m_ui->m_areaCheckBox->setEnabled(true);
      m_ui->m_lineCheckBox->setEnabled(false);
      m_ui->m_perimeterCheckBox->setEnabled(true);
      m_ui->m_byObjectRadioButton->setEnabled(true);
      m_ui->m_byAttributeRadioButton->setEnabled(true);
      m_ui->m_byObjectRadioButton->setChecked(true);
      break;
  }
}

te::vp::GeometricOpObjStrategy
te::vp::GeometricOpDialog::getObjectStrategy()
{
  if(m_ui->m_byObjectRadioButton->isChecked())
    return te::vp::ALL_OBJ;
  if(m_ui->m_allLayerRadioButton->isChecked())
    return te::vp::AGGREG_OBJ;
  if(m_ui->m_byAttributeRadioButton->isChecked())
    return te::vp::AGGREG_BY_ATTRIBUTE;

  return te::vp::ALL_OBJ;
}

void te::vp::GeometricOpDialog::onLayerComboBoxChanged(int index)
{
  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  std::string layerID =
      m_ui->m_inputLayerComboBox->itemData(index, Qt::UserRole)
          .toString()
          .toUtf8()
          .data();

  m_ui->m_propertiesListWidget->clear();
  m_ui->m_attributesComboBox->clear();

  while(it != m_layers.end())
  {
    if(layerID == it->get()->getId())
    {
      std::size_t type;
      te::map::AbstractLayerPtr selectedLayer = it->get();
      m_selectedLayer = selectedLayer;
      std::unique_ptr<const te::map::LayerSchema> schema(selectedLayer->getSchema());

      int srid = selectedLayer->getSRID();
      if(srid > 0)
      {
        m_ui->m_layerSRIDLabel->setText(te::srs::SpatialReferenceSystemManager::getInstance().getName(srid).c_str());
        m_ui->m_resSRIDLabel->setText(te::srs::SpatialReferenceSystemManager::getInstance().getName(srid).c_str());
        m_newSRID = srid;
      }
      else
        m_ui->m_layerSRIDLabel->setText("No SRS defined");

      if(schema->size() == 0)
        return;

      const std::vector<te::dt::Property*>& properties = schema->getProperties();

      for(size_t i = 0; i < properties.size(); ++i)
      {
        type = properties[i]->getType();

        if(type == te::dt::GEOMETRY_TYPE)
        {
          te::gm::GeometryProperty* geomProperty =
              dynamic_cast<te::gm::GeometryProperty*>(properties[i]->clone());

          te::gm::GeomType geomType = geomProperty->getGeometryType();
          enableOperations(geomType);
        }
        else
        {
          m_ui->m_propertiesListWidget->addItem(
              properties[i]->getName().c_str());

          m_ui->m_attributesComboBox->addItem(properties[i]->getName().c_str());
        }
      }
      return;
    }
    ++it;
  }
}

void te::vp::GeometricOpDialog::onAttributeComboBoxChanged(int index)
{
  if(m_ui->m_byAttributeRadioButton->isChecked())
    m_attribute = m_ui->m_attributesComboBox->itemText(index).toUtf8().data();
  else
    m_attribute = "";
}

void te::vp::GeometricOpDialog::onAllObjectsToggled()
{
  m_ui->m_attributesComboBox->setEnabled(false);
  onAttributeComboBoxChanged(0);
}

void te::vp::GeometricOpDialog::onAllLayerOperationToggled()
{
  m_ui->m_attributesComboBox->setEnabled(false);
  onAttributeComboBoxChanged(0);
}

void te::vp::GeometricOpDialog::onAttributeOperationToggled()
{
  m_ui->m_attributesComboBox->setEnabled(true);
}

void te::vp::GeometricOpDialog::onTargetDatasourceToolButtonPressed()
{
  m_ui->m_newLayerNameLineEdit->clear();
  m_ui->m_newLayerNameLineEdit->setEnabled(true);
  te::qt::widgets::DataSourceSelectorDialog dlg(this);
  dlg.exec();

  std::list<te::da::DataSourceInfoPtr> dsPtrList = dlg.getSelecteds();

  if(dsPtrList.empty())
    return;

  std::list<te::da::DataSourceInfoPtr>::iterator it = dsPtrList.begin();

  m_ui->m_repositoryLineEdit->setText(QString(it->get()->getTitle().c_str()));

  m_outputDatasource = *it;

  m_toFile = false;
}

void te::vp::GeometricOpDialog::onTargetFileToolButtonPressed()
{
  m_ui->m_newLayerNameLineEdit->clear();
  m_ui->m_repositoryLineEdit->clear();

  te::qt::widgets::FileDialog fileDialog(this, te::qt::widgets::FileDialog::VECTOR);

  try {
    fileDialog.exec();
  }
  catch (te::common::Exception& ex) {
    QMessageBox::warning(this, tr("File information"), ex.what());
    return;
  }

  m_ui->m_repositoryLineEdit->setText(fileDialog.getPath().c_str());
  m_ui->m_newLayerNameLineEdit->setText(fileDialog.getFileName().c_str());

  m_toFile = true;
  m_ui->m_newLayerNameLineEdit->setEnabled(false);
}

void te::vp::GeometricOpDialog::onOkPushButtonClicked()
{
  // Progress bar
  te::qt::widgets::ProgressViewerDialog v(this);

  try
  {
    te::map::DataSetLayer* dsLayer =
        dynamic_cast<te::map::DataSetLayer*>(m_selectedLayer.get());

    te::da::DataSourcePtr inDataSource =
        te::da::GetDataSource(dsLayer->getDataSourceId(), true);


    // Get the selected properties of input layer
    std::vector<std::string> geoProps;
    QList<QListWidgetItem*> selection = m_ui->m_propertiesListWidget->selectedItems();
    for(int i = 0; i < selection.size(); ++i)
      geoProps.push_back(selection.at(i)->text().toUtf8().data());


    // Get checked operations
    m_ops.clear();

    if(hasConvexHull())
      m_ops.push_back(te::vp::CONVEX_HULL);

    if(hasCentroid())
      m_ops.push_back(te::vp::CENTROID);

    if(hasMBR())
      m_ops.push_back(te::vp::MBR);

    if(hasLine())
      m_ops.push_back(te::vp::LINE);

    if(hasArea())
      m_ops.push_back(te::vp::AREA);

    if(hasPerimeter())
      m_ops.push_back(te::vp::PERIMETER);

    // Verify if it has at least one operation checked.
    if(m_ops.empty())
    {
      QMessageBox::information(this, tr("Geometric Operation"),
                               tr("Check at least one operation."));

      return;
    }

    // Verify if the projection is lat/long
    if(IsProjectionLatLong(m_newSRID))
    {
      if(hasArea() || hasPerimeter() || hasLine())
      {
        int reply = QMessageBox::question(this, tr("Geometric Operation"),
                                          tr("The tabular operations will be calculated with Geographic SRS. Would you like to continue?"),
                                          QMessageBox::No, QMessageBox::Yes);

        if(reply == QMessageBox::No)
        {
          return;
        }
      }
    }


    // Get the strategy (All objects / All layer dissolved / Dissolved by attribute)
    te::vp::GeometricOpObjStrategy strategy = getObjectStrategy();

    // Get the selected property if the operation is by attribute
    if(strategy == te::vp::AGGREG_BY_ATTRIBUTE)
      m_attribute = m_ui->m_attributesComboBox->currentText().toUtf8().data();

    // Get the output layer name.
    std::string outputdataset =
        m_ui->m_newLayerNameLineEdit->text().toUtf8().data();

    std::vector<std::string> outputDSetNames;

    // Verify output datasource
    if(m_toFile)
    {
      std::string path = m_ui->m_repositoryLineEdit->text().toUtf8().data();
      boost::filesystem::path uri(path);

      bool ops_selected = false;

      if(hasConvexHull())
      {
        std::vector<std::string> splitedName;
        boost::split(splitedName, outputdataset, boost::is_any_of("."));

        boost::filesystem::path uri_file(path + "/" + splitedName[0] + "_convex_hull.shp");

        if(te::core::FileSystem::exists(uri_file.string()))
        {
          QMessageBox::information(
              this, tr("Geometric Operation"),
              tr("The convex hull output file already "
                 "exists. Remove it or select a new name and "
                 "try again."));

          return;
        }

        ops_selected = true;
      }
      if(hasCentroid())
      {
        std::vector<std::string> splitedName;
        boost::split(splitedName, outputdataset, boost::is_any_of("."));

        boost::filesystem::path uri_file(path + "/" + splitedName[0] + "_centroid.shp");

        if(te::core::FileSystem::exists(uri_file.string()))
        {
          QMessageBox::information(
              this, tr("Geometric Operation"),
              tr("The centroid output file already exists. "
                 "Remove it or select a new name and try "
                 "again."));

          return;
        }

        ops_selected = true;
      }
      if(hasMBR())
      {
        std::vector<std::string> splitedName;
        boost::split(splitedName, outputdataset, boost::is_any_of("."));

        boost::filesystem::path uri_file(path + "/" + splitedName[0] + "_mbr.shp");

        if(te::core::FileSystem::exists(uri_file.string()))
        {
          QMessageBox::information(
              this, tr("Geometric Operation"),
              tr("The mbr output file already exists. Remove "
                 "it or select a new name and try again."));

          return;
        }

        ops_selected = true;
      }
      if(!ops_selected)
      {
        std::vector<std::string> splitedName;
        boost::split(splitedName, outputdataset, boost::is_any_of("."));

        boost::filesystem::path uri_file(path + "/" + splitedName[0] + ".shp");

        if(te::core::FileSystem::exists(uri_file.string()))
        {
          QMessageBox::information(
              this, tr("Geometric Operation"),
              tr("Output file already exists. Remove it or "
                 "select a new name and try again."));

          return;
        }
      }

      std::size_t idx = outputdataset.find(".");
      if (idx != std::string::npos)
        outputdataset=outputdataset.substr(0,idx);

      std::string dsinfo("file://");
      dsinfo += uri.string();
      std::unique_ptr<te::da::DataSource> dsOGR = te::da::DataSourceFactory::make("OGR", dsinfo);
      dsOGR->open();

      std::unique_ptr<te::da::DataSetTypeConverter> converter(
          new te::da::DataSetTypeConverter(dsLayer->getSchema().get(),
                                           dsOGR->getCapabilities(),
                                           dsOGR->getEncoding()));

      te::da::AssociateDataSetTypeConverterSRID(converter.get(),
                                                dsLayer->getSRID());

      this->setCursor(Qt::WaitCursor);

      // sera feito por algum tipo de factory
      te::vp::GeometricOp* geomOp = nullptr;

      // select a strategy based on the capabilities of the input datasource
      const te::da::DataSourceCapabilities dsCapabilities =
          inDataSource->getCapabilities();

      if(dsCapabilities.supportsPreparedQueryAPI() &&
         dsCapabilities.getQueryCapabilities().supportsSpatialSQLDialect())
      {
        geomOp = new te::vp::GeometricOpQuery();
      }
      else
      {
        geomOp = new te::vp::GeometricOpMemory();
      }

      geomOp->setInput(inDataSource, dsLayer->getDataSetName(), std::move(converter));
      geomOp->setOutput(std::move(dsOGR), outputdataset);
      geomOp->setParams(geoProps, m_ops, strategy, m_attribute, m_newSRID);

      bool result;

      if(!geomOp->paramsAreValid())
        result = false;
      else
        result = geomOp->run();

      if(!result)
      {
        this->setCursor(Qt::ArrowCursor);
        QMessageBox::information(
            this, tr("Geometric Operation"),
            tr("Error: could not generate the operation, check the log file."));

        return;
      }

      outputDSetNames = geomOp->GetOutputDSetNames();

      delete geomOp;

      // let's include the new datasource in the managers
      boost::uuids::basic_random_generator<boost::mt19937> gen;
      boost::uuids::uuid u = gen();
      std::string id = boost::uuids::to_string(u);

      te::da::DataSourceInfoPtr ds(new te::da::DataSourceInfo);
      ds->setConnInfo(dsinfo);
      ds->setTitle(uri.stem().string());
      ds->setAccessDriver("OGR");
      ds->setType("OGR");
      ds->setDescription(uri.string());
      ds->setId(id);

      te::da::DataSourcePtr newds =
          te::da::DataSourceManager::getInstance().get(id, "OGR",
                                                       ds->getConnInfo());
      newds->open();
      te::da::DataSourceInfoManager::getInstance().add(ds);
      m_outputDatasource = ds;
    }
    else
    {
      std::unique_ptr<te::da::DataSource> trgDs =
          te::da::DataSourceFactory::make(m_outputDatasource->getType(),
                                          m_outputDatasource->getConnInfo());
      trgDs->open();

      if(!trgDs.get())
      {
        QMessageBox::information(
            this, tr("Geometric Operation"),
            tr("The selected output datasource can not be accessed."));

        return;
      }

      if(trgDs->dataSetExists(outputdataset))
      {
        QMessageBox::information(
            this, tr("Geometric Operation"),
            tr("Dataset already exists. Remove it or select "
               "a new name and try again."));

        return;
      }

      std::unique_ptr<te::da::DataSetTypeConverter> converter(
          new te::da::DataSetTypeConverter(dsLayer->getSchema().get(),
                                           trgDs->getCapabilities(),
                                           trgDs->getEncoding()));

      te::da::AssociateDataSetTypeConverterSRID(converter.get(),
                                                dsLayer->getSRID());

      this->setCursor(Qt::WaitCursor);

      te::vp::GeometricOp* geomOp = nullptr;

      // select a strategy based on the capabilities of the input datasource
      const te::da::DataSourceCapabilities dsCapabilities =
          inDataSource->getCapabilities();

      if(dsCapabilities.supportsPreparedQueryAPI() &&
         dsCapabilities.getQueryCapabilities().supportsSpatialSQLDialect())
      {
        geomOp = new te::vp::GeometricOpQuery();
      }
      else
      {
        geomOp = new te::vp::GeometricOpMemory();
      }

      geomOp->setInput(inDataSource, dsLayer->getDataSetName(), std::move(converter));
      geomOp->setOutput(std::move(trgDs), outputdataset);
      geomOp->setParams(geoProps, m_ops, strategy, m_attribute, m_newSRID);

      bool result;
      if(!geomOp->paramsAreValid())
        result = false;
      else
        result = geomOp->run();

      if(!result)
      {
        this->setCursor(Qt::ArrowCursor);
        QMessageBox::information(
            this, tr("Geometric Operation"),
            tr("Error: could not generate the operation."));

        return;
      }

      outputDSetNames = geomOp->GetOutputDSetNames();

      delete geomOp;
    }

    // creating a layer for the result
    te::da::DataSourcePtr outDataSource =
        te::da::GetDataSource(m_outputDatasource->getId());

    // force to close database connection to refresh dataSets.
    outDataSource->close();
    outDataSource->open();

    te::qt::widgets::DataSet2Layer converter(m_outputDatasource->getId());

    for(std::size_t i = 0; i < outputDSetNames.size(); ++i)
    {
      te::da::DataSetTypePtr dt(
          outDataSource->getDataSetType(outputDSetNames[i]).release());
      if(dt)
        m_outputLayer.push_back(converter(dt));
    }
  }
  catch(const std::exception& e)
  {
    this->setCursor(Qt::ArrowCursor);
    QMessageBox::information(this, tr("Geometric Operation"), e.what());

#ifdef TERRALIB_LOGGER_ENABLED
    std::string str = "Geometric Operation - ";
    str += e.what();
    TE_CORE_LOG_DEBUG("vp", str);
#endif

    return;
  }

  this->setCursor(Qt::ArrowCursor);

  accept();
}

void te::vp::GeometricOpDialog::onCancelPushButtonClicked()
{
  reject();
}

void te::vp::GeometricOpDialog::onSrsToolButtonClicked()
{
  te::qt::widgets::SRSManagerDialog srsDialog(this);
  srsDialog.setWindowTitle(tr("Choose the SRS"));

  if(srsDialog.exec() == QDialog::Rejected)
    return;

  m_newSRID =  srsDialog.getSelectedSRS().first;

  if (m_newSRID <= 0)
  {
    m_ui->m_resSRIDLabel->setText("No SRS defined");
  }
  else
  {
    std::string name = te::srs::SpatialReferenceSystemManager::getInstance().getName(m_newSRID);
    m_ui->m_resSRIDLabel->setText(name.c_str());
  }
}