ClippingWizardPage.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/qt/widgets/rp/ClippingWizardPage.cpp

  \brief This file defines a class for a Clipping Wizard page.
*/

// TerraLib
#include "../../../common/StringUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/dataset/ObjectIdSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/Geometry.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../geometry/GeometryCollection.h"
#include "../../../geometry/LinearRing.h"
#include "../../../geometry/Polygon.h"
#include "../../../geometry/Utils.h"
#include "../../../raster/Grid.h"
#include "../../../raster/Raster.h"
#include "../../../maptools/Utils.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "RpToolsWidget.h"

#include "ClippingWizardPage.h"
#include "ui_ClippingWizardPageForm.h"

// Qt
#include <QGridLayout>
#include <QCheckBox>
#include <QDoubleValidator>
#include <QIntValidator>
#include <QMessageBox>
#include <QTableWidgetItem>

// STL
#include <memory>

Q_DECLARE_METATYPE(te::map::AbstractLayerPtr)

te::qt::widgets::ClippingWizardPage::ClippingWizardPage(QWidget* parent)
  : QWizardPage(parent),
    m_ui(new Ui::ClippingWizardPageForm),
    m_layer(nullptr),
    m_mapDisplay(nullptr),
    m_count(0)
{
// setup controls
  m_ui->setupUi(this);

  fillClippingTypes();

//build form
  QGridLayout* displayLayout = new QGridLayout(m_ui->m_navigatorWidget);
  m_navigator.reset( new te::qt::widgets::RpToolsWidget(m_ui->m_navigatorWidget));
  displayLayout->addWidget(m_navigator.get());
  displayLayout->setContentsMargins(0,0,0,0);

  m_ui->m_removeRoiToolButton->setIcon(QIcon::fromTheme("edit-deletetool"));

//configure page
  this->setTitle(tr("Clipping"));
  this->setSubTitle(tr("Select the type of clipping and set their specific parameters."));

  m_ui->m_llxLineEdit->setValidator(new QDoubleValidator(this));
  m_ui->m_llyLineEdit->setValidator(new QDoubleValidator(this));
  m_ui->m_urxLineEdit->setValidator(new QDoubleValidator(this));
  m_ui->m_uryLineEdit->setValidator(new QDoubleValidator(this));

  m_ui->m_startRowLineEdit->setValidator(new QIntValidator(this));
  m_ui->m_startColumnLineEdit->setValidator(new QIntValidator(this));
  m_ui->m_widthLineEdit->setValidator(new QIntValidator(this));
  m_ui->m_heightLineEdit->setValidator(new QIntValidator(this));

//connects
  connect(m_ui->m_strategyTypeComboBox, SIGNAL(activated(int)), this, SLOT(onStrategyTypeComboBoxActivated(int)));
  connect(m_ui->m_strategyTypeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onStrategyTypeComboBoxChanged(int)));
  connect(m_ui->m_layerComboBox, SIGNAL(activated(int)), this, SLOT(onLayerComboBoxActivated(int)));
  connect(m_ui->m_extentLayerComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onExtentLayerComboBoxChanged(int)));

  connect(m_ui->m_roiTableWidget, SIGNAL(cellClicked(int, int)), this, SLOT(onSelectRoiItem()));
  connect(m_ui->m_removeRoiToolButton, SIGNAL(clicked()), this, SLOT(onRemoveRoiItem()));
  connect(m_ui->m_previewButton, SIGNAL(clicked()), this, SLOT(onPreviewClicked()));
  connect(m_ui->m_previewDimensionPushButton, SIGNAL(clicked()), this, SLOT(onPreviewDimensionClicked()));

  connect(m_navigator.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));
  connect(m_navigator.get(), SIGNAL(geomAquired(te::gm::Polygon*)), this, SLOT(onGeomAquired(te::gm::Polygon*)));
}

te::qt::widgets::ClippingWizardPage::~ClippingWizardPage()
{
  m_geomVec.clear();
}

bool te::qt::widgets::ClippingWizardPage::isComplete() const
{
  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  if (type == CLIPPING_ROI)
  {
     if(m_geomVec.empty())
        return false;

    return true;
  }
  else if(type == CLIPPING_LAYER_EXTENT)
  {
    if(m_ui->m_llxLineEdit->text().isEmpty() ||
            m_ui->m_llyLineEdit->text().isEmpty() ||
            m_ui->m_urxLineEdit->text().isEmpty() ||
            m_ui->m_uryLineEdit->text().isEmpty())
        return false;

    return true;
  }
  else if(type == CLIPPING_DIMENSION)
  {
    if(m_ui->m_startRowLineEdit->text().isEmpty() ||
       m_ui->m_startColumnLineEdit->text().isEmpty() ||
       m_ui->m_widthLineEdit->text().isEmpty() ||
       m_ui->m_heightLineEdit->text().isEmpty()
      )
      return false;

    return true;
  }
  else if(type == CLIPPING_LAYER)
  {
    if(m_ui->m_layerComboBox->currentText().isEmpty())
      return false;

    return true;
  }

  return false;
}

void te::qt::widgets::ClippingWizardPage::set(te::map::AbstractLayerPtr layer)
{
  m_layer = layer;
}

void te::qt::widgets::ClippingWizardPage::setList(std::list<te::map::AbstractLayerPtr>& layerList)
{
  m_layerList = layerList;
}

void te::qt::widgets::ClippingWizardPage::setMapDisplay(te::qt::widgets::MapDisplay* mapDisplay)
{
  m_navigator->setMapDisplay(mapDisplay);
  m_mapDisplay = mapDisplay;
}

void te::qt::widgets::ClippingWizardPage::setActionGroup(QActionGroup* actionGroup)
{
  //configure tools
  m_navigator->setActionGroup(actionGroup);
  m_navigator->enableGeomAction();
  m_navigator->enableBoxAction();
}

te::map::AbstractLayerPtr te::qt::widgets::ClippingWizardPage::get()
{
  return m_layer;
}

bool te::qt::widgets::ClippingWizardPage::isExtentClipping()
{
  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  return type == CLIPPING_ROI;
}

bool te::qt::widgets::ClippingWizardPage::isLayerExtentClipping()
{
  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  return type == CLIPPING_LAYER_EXTENT;
}

bool te::qt::widgets::ClippingWizardPage::isDimensionClipping()
{
  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  return type == CLIPPING_DIMENSION;
}

bool te::qt::widgets::ClippingWizardPage::isLayerClipping()
{
  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  return type == CLIPPING_LAYER;
}

bool te::qt::widgets::ClippingWizardPage::isSingleRasterResult()
{
  if(isLayerClipping())
  {
    if(m_ui->m_aggregAllRadioButton->isChecked())
       return true;
    if(m_ui->m_groupByRadioButton->isChecked())
       return false;
    if(m_ui->m_selectedGeomRadioButton->isChecked())
       return true;
  }
  else
  {
    if(m_ui->m_groupLayersRadioButton->isChecked())
      return true;
    if(m_ui->m_singleLayersRadioButton->isChecked())
      return false;
  }

  return true;
}

bool te::qt::widgets::ClippingWizardPage::isGroupByAttribute()
{
  return m_ui->m_groupByRadioButton->isChecked();
}

void te::qt::widgets::ClippingWizardPage::getExtentClipping(std::vector<te::gm::Geometry*> &geomVec)
{
  geomVec = m_geomVec;
}

void te::qt::widgets::ClippingWizardPage::getLayerExtentClipping(te::gm::Envelope &env)
{
  env = m_envExt;
}

void te::qt::widgets::ClippingWizardPage::getDimensionClipping(int& x, int& y, int& width, int& height)
{
  x = m_ui->m_startColumnLineEdit->text().toInt();
  y = m_ui->m_startRowLineEdit->text().toInt();
  width = m_ui->m_widthLineEdit->text().toInt();
  height = m_ui->m_heightLineEdit->text().toInt();
}

void te::qt::widgets::ClippingWizardPage::getLayerClipping(std::vector<te::gm::Geometry*> &geomVec)
{
  //get layer
  int index = m_ui->m_layerComboBox->currentIndex();
  QVariant varLayer = m_ui->m_layerComboBox->itemData(index, Qt::UserRole);
  te::map::AbstractLayerPtr layer = varLayer.value<te::map::AbstractLayerPtr>();

  //get geometry property data
  std::unique_ptr<te::da::DataSetType> dsType = layer->getSchema();
  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dsType.get());
  std::string name = geomProp->getName();
  std::unique_ptr<te::gm::Geometry> geom;
  std::unique_ptr< te::dt::AbstractData > adCloned;

  if(m_ui->m_aggregAllRadioButton->isChecked())
  {
    std::unique_ptr<te::da::DataSet> ds = layer->getData();
    ds->moveBeforeFirst();

    while(ds->moveNext())
    {
      geom.reset( ds->getGeometry(name).release() );

      if (geom.get())
      {
        if(geom->isValid())
        {
          adCloned.reset( geom->clone() );

          if(geom->getSRID() != get()->getSRID())
             geom->transform(get()->getSRID());

          if(geom->getMBR()->intersects(get()->getExtent()))
             geomVec.push_back(static_cast<te::gm::Geometry*>(adCloned.release()));
        }

      }
    }
  }
  else if(m_ui->m_selectedGeomRadioButton->isChecked())
  {
    const te::da::ObjectIdSet* oidSet = layer->getSelected();
    if(!oidSet)
    {
      QMessageBox::information(this, tr("Clipping"), tr("Select the layer objects to perform the clipping operation."));
      return;
    }

    std::unique_ptr< te::gm::Geometry > geomSelected;

    std::unique_ptr<te::da::DataSet> ds = layer->getData(oidSet);

    ds->moveBeforeFirst();
  
    while(ds->moveNext())
    {
      geomSelected.reset( static_cast<te::gm::Geometry*>(ds->getGeometry(name)->clone()) );

      if(geomSelected->isValid())
      {
        if(geomSelected->getSRID() != get()->getSRID())
          geomSelected->transform(get()->getSRID());

        if(geomSelected->getMBR()->intersects(get()->getExtent()))
          geomVec.push_back(geomSelected.release() );
      }
    }

    if(geomVec.empty())
    {
      QMessageBox::information(this, tr("Clipping"), tr("The seleceted geometries does not intersects the raster extent."));
      return;
    }
  }
}

void te::qt::widgets::ClippingWizardPage::getLayerClippingAttribute(std::map<std::string, te::gm::Geometry*> &geomMap)
{
  //get layer
  int index = m_ui->m_layerComboBox->currentIndex();
  QVariant varLayer = m_ui->m_layerComboBox->itemData(index, Qt::UserRole);
  te::map::AbstractLayerPtr layer = varLayer.value<te::map::AbstractLayerPtr>();

  //get geometry property data
  std::unique_ptr<te::da::DataSetType> dsType = layer->getSchema();
  te::gm::GeometryProperty* geomProp = te::da::GetFirstGeomProperty(dsType.get());
  std::string name = geomProp->getName();

  if(m_ui->m_groupByRadioButton->isChecked())
  {
    std::string propName = m_ui->m_layerAttrComboBox->currentText().toUtf8().data();

    std::map<std::string, std::vector<te::gm::Geometry*> > groups;
    std::map<std::string, std::vector<te::gm::Geometry*> >::iterator itg;

    std::unique_ptr<te::da::DataSet> ds = layer->getData();

    ds->moveBeforeFirst();
    while(ds->moveNext())
    {
      te::gm::Geometry* geomIntersected = static_cast<te::gm::Geometry*>(ds->getGeometry(name)->clone());

      if(geomIntersected->isValid())
      {
        if(geomIntersected->getSRID() != get()->getSRID())
           geomIntersected->transform(get()->getSRID());

        std::string value = ds->getAsString(propName);

        itg = groups.find(value);

        if(geomIntersected->getMBR()->intersects(get()->getExtent()))
        {
          if (itg==groups.end())
          {
             std::vector<te::gm::Geometry*> geomVec;

             geomVec.push_back(geomIntersected);
             groups.insert(std::pair<std::string, std::vector<te::gm::Geometry*> >(value,geomVec));
          }
          else
            itg->second.push_back(geomIntersected);
        }
      }
    }

    if(groups.empty())
    {
      QMessageBox::information(this, tr("Clipping"), tr("There are not geometries intersecting with the raster extent."));
      return;
    }

    itg = groups.begin();
    while(itg != groups.end())
    {
      std::unique_ptr<te::gm::Geometry> geom = te::gm::GetGeometryUnion(itg->second);

      geomMap.insert(std::pair<std::string, te::gm::Geometry*>(itg->first, geom.release()));

      ++itg;
    }
  }
}

void te::qt::widgets::ClippingWizardPage::addRoiItem()
{
  int row = m_ui->m_roiTableWidget->rowCount();

  m_ui->m_roiTableWidget->insertRow(row);

  m_count++;

  QTableWidgetItem* item = new QTableWidgetItem("ROI Item "+QString::number(m_count));
  m_ui->m_roiTableWidget->setItem(row, 0, item);

  m_ui->m_roiTableWidget->resizeRowsToContents();
  m_ui->m_roiTableWidget->resizeColumnToContents(0);
}

void te::qt::widgets::ClippingWizardPage::onStrategyTypeComboBoxActivated(
    int /*index*/)
{
  emit completeChanged();
}

void te::qt::widgets::ClippingWizardPage::onStrategyTypeComboBoxChanged(int index)
{
  clearCanvas();

  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();

  if(type == CLIPPING_LAYER_EXTENT)
  {
    m_ui->m_extentLayerComboBox->clear();

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

    while(it != m_layerList.end())
    {
      te::map::AbstractLayerPtr l = *it;

      if(m_layer.get() != l.get())
        m_ui->m_extentLayerComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));

      ++it;
    }

    onExtentLayerComboBoxChanged(0);
  }
  else if(type == CLIPPING_LAYER)
  {
    m_ui->m_layerComboBox->clear();

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

    while(it != m_layerList.end())
    {
      te::map::AbstractLayerPtr l = *it;

      std::unique_ptr<te::da::DataSetType> dsType = l->getSchema();

      if((m_layer.get() != l.get()) && dsType->hasGeom())
        m_ui->m_layerComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));

      ++it;
    }

    if(m_ui->m_layerComboBox->count() > 0)
      onLayerComboBoxActivated(0);
  }

  drawGeom();
}

void te::qt::widgets::ClippingWizardPage::onLayerComboBoxActivated(int index)
{
  m_ui->m_layerAttrComboBox->clear();

  QVariant varLayer = m_ui->m_layerComboBox->itemData(index, Qt::UserRole);
  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();

  std::unique_ptr<te::da::DataSetType> dsType = l->getSchema();

  std::vector<te::dt::Property*> prop = dsType->getProperties();

  for(std::size_t t = 0; t < dsType->getProperties().size(); ++t)
  {
    if(prop[t]->getType() != te::dt::GEOMETRY_TYPE)
      m_ui->m_layerAttrComboBox->addItem(dsType->getProperties()[t]->getName().c_str());
  }
}

void te::qt::widgets::ClippingWizardPage::onExtentLayerComboBoxChanged(int index)
{
  if(isLayerExtentClipping() && m_ui->m_extentLayerComboBox->count() > 0)
  {
    QVariant varLayer = m_ui->m_extentLayerComboBox->itemData(index, Qt::UserRole);
    te::map::AbstractLayerPtr layer = varLayer.value<te::map::AbstractLayerPtr>();

    te::gm::Envelope e = layer->getExtent();

    e.transform(layer->getSRID(), m_layer->getSRID());

    if(!e.intersects(m_layer->getExtent()))
    {
      m_ui->m_llxLineEdit->clear();
      m_ui->m_llyLineEdit->clear();
      m_ui->m_urxLineEdit->clear();
      m_ui->m_uryLineEdit->clear();

      clearCanvas();

      return;
    }

    m_ui->m_llxLineEdit->setText(QString::number(e.getLowerLeftX(), 'f', 5));
    m_ui->m_llyLineEdit->setText(QString::number(e.getLowerLeftY(), 'f', 5));
    m_ui->m_urxLineEdit->setText(QString::number(e.getUpperRightX(), 'f', 5));
    m_ui->m_uryLineEdit->setText(QString::number(e.getUpperRightY(), 'f', 5));
  }
}

void te::qt::widgets::ClippingWizardPage::onEnvelopeAcquired(te::gm::Envelope env)
{
  if(m_mapDisplay->getSRID() != m_layer->getSRID())
    env.transform(m_mapDisplay->getSRID(), m_layer->getSRID());

  if (!env.isValid() || !env.intersects(m_layer->getExtent()))
    return;

  m_geomVec.push_back(te::gm::GetGeomFromEnvelope(&env, m_layer->getSRID()));

  addRoiItem();

  drawGeom();

  emit completeChanged();
}

void te::qt::widgets::ClippingWizardPage::onGeomAquired(te::gm::Polygon *poly)
{
  if(m_mapDisplay->getSRID() != m_layer->getSRID())
    poly->transform(m_layer->getSRID());

  if(!poly->isValid() || !poly->intersects(te::gm::GetGeomFromEnvelope(&m_layer->getExtent(), m_layer->getSRID())))
     return;

  m_geomVec.push_back(poly);

  addRoiItem();

  drawGeom();

  emit completeChanged();
}

void te::qt::widgets::ClippingWizardPage::onSelectRoiItem()
{
  drawGeom();

  int selectedRow = m_ui->m_roiTableWidget->currentIndex().row();

  const te::gm::Envelope& mapExt = m_mapDisplay->getExtent();

  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());
  canvasInstance.setWindow(mapExt.m_llx, mapExt.m_lly, mapExt.m_urx, mapExt.m_ury);

  canvasInstance.setPolygonContourWidth(1);
  canvasInstance.setPolygonContourColor(te::color::RGBAColor(100, 177, 216, 222));
  canvasInstance.setPolygonFillColor(te::color::RGBAColor(100, 177, 216, 220));

  canvasInstance.draw(m_geomVec.at(selectedRow));

  m_mapDisplay->repaint();
}

void te::qt::widgets::ClippingWizardPage::onRemoveRoiItem()
{
  int row = m_ui->m_roiTableWidget->currentIndex().row();

  if(m_geomVec.empty())
  {
    m_count = 0;
    return;
  }

  m_ui->m_roiTableWidget->removeRow(row);

  m_geomVec.erase(m_geomVec.begin()+row);

  drawGeom();
}

void te::qt::widgets::ClippingWizardPage::onPreviewClicked()
{
  if (m_ui->m_llxLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Lower Left X is empty, please enter value for preview."));
    return;
  }
  else if (m_ui->m_llyLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Lower Left Y is empty, please enter value for preview."));
    return;
  }
  else if (m_ui->m_urxLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Upper Right X is empty, please enter value for preview."));
    return;
  }
  else if (m_ui->m_uryLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Upper Right Y is empty, please enter value for preview."));
    return;
  }

  const double& llx = m_ui->m_llxLineEdit->text().toDouble();
  const double& lly = m_ui->m_llyLineEdit->text().toDouble();
  const double& urx = m_ui->m_urxLineEdit->text().toDouble();
  const double& ury = m_ui->m_uryLineEdit->text().toDouble();

  te::gm::Envelope env(llx, lly, urx, ury);

  if (!env.isValid())
  {
    QMessageBox::information(this, tr("Clipping"), tr("The values informed does not valid."));
    return;
  }

  m_envExt = env;

  drawGeom();

  emit completeChanged();
}

void te::qt::widgets::ClippingWizardPage::onPreviewDimensionClicked()
{
  if(m_ui->m_startRowLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Initial row is empty, please enter value for preview."));
    return;
  }
  else if(m_ui->m_startColumnLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Initial column is empty, please enter value for preview."));
    return;
  }
  else if(m_ui->m_heightLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Height is empty, please enter value for preview."));
    return;
  }
  else if(m_ui->m_widthLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Clipping"), tr("Width is empty, please enter value for preview."));
    return;
  }

  int x = m_ui->m_startColumnLineEdit->text().toInt();
  int y = m_ui->m_startRowLineEdit->text().toInt();
  int width = m_ui->m_widthLineEdit->text().toInt();
  int height = m_ui->m_heightLineEdit->text().toInt();

  std::unique_ptr<te::rst::Raster> inputRst(te::map::GetRaster(m_layer.get()));

  if(inputRst.get())
  {
    te::gm::Coord2D ulc = inputRst->getGrid()->gridToGeo(((double)x) - 0.5, ((double)y) - 0.5);
    te::gm::Coord2D lrc = inputRst->getGrid()->gridToGeo(((double)(x + width)) - 0.5, ((double)(y + height)) - 0.5);

    m_envDim = te::gm::Envelope(ulc.x, lrc.y, lrc.x, ulc.y);
  }

  drawGeom();

  emit completeChanged();
}

void te::qt::widgets::ClippingWizardPage::fillClippingTypes()
{
  m_ui->m_strategyTypeComboBox->clear();

  m_ui->m_strategyTypeComboBox->addItem(tr("Region of interest"), CLIPPING_ROI);
  m_ui->m_strategyTypeComboBox->addItem(tr("Layer Extent"), CLIPPING_LAYER_EXTENT);
  m_ui->m_strategyTypeComboBox->addItem(tr("Layer"), CLIPPING_LAYER);
  m_ui->m_strategyTypeComboBox->addItem(tr("Dimension"), CLIPPING_DIMENSION);
}

void te::qt::widgets::ClippingWizardPage::drawGeom()
{
  m_mapDisplay->getDraftPixmap()->fill(Qt::transparent);

  const te::gm::Envelope& mapExt = m_mapDisplay->getExtent();

  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());
  canvasInstance.setWindow(mapExt.m_llx, mapExt.m_lly, mapExt.m_urx, mapExt.m_ury);

  canvasInstance.setPolygonContourWidth(2);
  canvasInstance.setPolygonContourColor(te::color::RGBAColor(100, 177, 216, TE_OPAQUE));
  canvasInstance.setPolygonFillColor(te::color::RGBAColor(100, 177, 216, 80));

  te::gm::Geometry* geom = nullptr;

  int index = m_ui->m_strategyTypeComboBox->currentIndex();
  int type = m_ui->m_strategyTypeComboBox->itemData(index).toInt();


  if(type == CLIPPING_LAYER_EXTENT)
  {
    if(m_envExt.isValid())
    {
      canvasInstance.setPolygonContourDashStyle(te::map::LineDashStyle::DashLine);

      te::gm::Envelope ext = m_envExt.intersection(m_layer->getExtent());

      geom = te::gm::GetGeomFromEnvelope(&ext, m_layer->getSRID());
    }
  }

  if(type == CLIPPING_DIMENSION)
  {
    if(m_envDim.isValid())
      geom = te::gm::GetGeomFromEnvelope(&m_envDim, m_layer->getSRID());
  }

  if(type == CLIPPING_ROI)
  {
    for(std::size_t i = 0; i < m_geomVec.size(); ++i)
    {
      if(m_geomVec[i]->getSRID() != m_mapDisplay->getSRID())
         m_geomVec[i]->transform(m_mapDisplay->getSRID());

      canvasInstance.draw(m_geomVec[i]);
    }
  }

  if(geom)
  {
    if(geom->getSRID() != m_mapDisplay->getSRID())
      geom->transform(m_mapDisplay->getSRID());

    canvasInstance.draw(geom);

    delete geom;
  }

  m_mapDisplay->repaint();
}

void te::qt::widgets::ClippingWizardPage::clearCanvas()
{
  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());

  canvasInstance.clear();

  m_mapDisplay->repaint();
}