FilterDialogForm.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/FilterDialogForm.h

  \brief This file has the FilterDialogForm class.
*/

// TerraLib
#include "../../../common/progress/ProgressManager.h"
#include "../../../common/StringUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/dataset/DataSetType.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/Utils.h"
#include "../../../raster/RasterProperty.h"
#include "../../../rp/Filter.h"
#include "../../../rp/Module.h"
#include "../../../se/CoverageStyle.h"
#include "../../../se/RasterSymbolizer.h"
#include "../../../se/Rule.h"
#include "../../../se/SelectedChannel.h"
#include "../../../se/Utils.h"
#include "../../af/events/LayerEvents.h"
#include "../../widgets/tools/ExtentAcquire.h"
#include "../../widgets/utils/DoubleListWidget.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "../progress/ProgressViewerDialog.h"
#include "FilterDialogForm.h"
#include "MaskDialog.h"
#include "Utils.h"
#include "ui_FilterDialogForm.h"

//QT
#include <QApplication>
#include <QGridLayout>
#include <QMessageBox>
#include <QCheckBox>

//Boost
#include <boost/lexical_cast.hpp>

te::qt::widgets::FilterDialogForm::FilterDialogForm(QWidget* parent)
  : QDialog(parent),
    m_ui(new Ui::FilterDialogForm),
    m_previewRaster(nullptr),
    m_geom(nullptr),
    m_mapDisplay(nullptr)
{
//build form
  m_ui->setupUi(this);

  m_ui->m_maskToolButton->setIcon(QIcon::fromTheme("mask"));
  m_ui->m_loadMaskToolButton->setIcon(QIcon::fromTheme("mask-fill"));
  m_ui->m_maskDefaultValueLineEdit->setValidator(new QDoubleValidator(this));

  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);

  //build input layer
  QGridLayout* inputLayout = new QGridLayout(m_ui->m_inputWidget);
  inputLayout->setContentsMargins(0, 0, 0, 0);
  m_inputWidget = new te::qt::widgets::InputLayerWidget(m_ui->m_inputWidget);
  inputLayout->addWidget(m_inputWidget);

  //build output parameters
  QGridLayout* outputLayout = new QGridLayout(m_ui->m_outputWidget);
  outputLayout->setContentsMargins(0, 0, 0, 0);
  m_outputWidget = new te::qt::widgets::OutputRasterWidget(m_ui->m_outputWidget);
  outputLayout->addWidget(m_outputWidget);

  //add double list widget to this form
  m_doubleListWidget.reset(new te::qt::widgets::DoubleListWidget(m_ui->m_bandsGroupBox));
  m_doubleListWidget->setLeftLabel("Input Bands");
  m_doubleListWidget->setRightLabel("Output Bands");

  QGridLayout* layout = new QGridLayout(m_ui->m_bandsGroupBox);
  layout->addWidget(m_doubleListWidget.get());
  layout->setContentsMargins(0, 0, 0, 0);

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

  m_ui->m_navigatorWidget->setEnabled(false);

  //connects
  connect(m_ui->m_typeComboBox, SIGNAL(activated(int)), SLOT(onFilterTypeComboBoxActivated(int)));
  connect(m_ui->m_iterationsSpinBox, SIGNAL(valueChanged(int)), SLOT(onIterationsChanged(int)));
  connect(m_ui->m_maskToolButton, SIGNAL(clicked()), SLOT(onMaskToolButtonClicked()));
  connect(m_ui->m_loadMaskToolButton, SIGNAL(clicked()), SLOT(onLoadMaskToolButtonClicked()));
  connect(m_ui->m_previewCheckBox, SIGNAL(toggled(bool)), SLOT(onPreviewCheckBoxToggled(bool)));
  connect(m_inputWidget, SIGNAL(layerChanged()), this, SLOT(layerChanged()));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), SLOT(onOkPushButtonClicked()));
  connect(m_navigator.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));

  listFilterTypes();
}

te::qt::widgets::FilterDialogForm::~FilterDialogForm() = default;

bool te::qt::widgets::FilterDialogForm::isComplete() const
{
  if (m_doubleListWidget->getOutputValues().empty())
    return false;

  return true;
}

void te::qt::widgets::FilterDialogForm::setParams()
{
  m_doubleListWidget->clearInputValues();
  m_doubleListWidget->clearOutputValues();

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

  std::vector<std::string> bands;
  for (unsigned int b = 0; b < raster->getNumberOfBands(); b++)
    bands.push_back(te::common::Convert2String(b));

  m_doubleListWidget->setInputValues(bands);
}

void te::qt::widgets::FilterDialogForm::setList(std::list<te::map::AbstractLayerPtr>& layerList, te::map::AbstractLayerPtr selectedlayer)
{
  std::list<te::map::AbstractLayerPtr> layersRasterList;

  std::list<te::map::AbstractLayerPtr>::iterator it = layerList.begin();
  //Filter only raster layers
  while (it != layerList.end())
  {
    std::unique_ptr<te::da::DataSetType> dsType = it->get()->getSchema();
    if (dsType->hasRaster())
      layersRasterList.push_back(it->get());
    ++it;
  }

  m_inputWidget->setLayerList(layersRasterList);

  if (!layersRasterList.empty())
  {
    m_layer = layersRasterList.begin()->get();
    setParams();
  }

  if (selectedlayer && selectedlayer->isValid())
  {
    std::unique_ptr<te::rst::Raster> raster(te::map::GetRaster(m_layer.get()));

    // for while, consider one rule
    te::se::ChannelSelection* channelSelect = getChannelSelection();

    //get visible bands
    std::vector<std::string> bands;
    if (channelSelect->getColorCompositionType() == te::se::RGB_COMPOSITION)
    {
      std::string channelName = channelSelect->getRedChannel()->getSourceChannelName();
      bands.push_back(channelName);

      channelName = channelSelect->getGreenChannel()->getSourceChannelName();
      bands.push_back(channelName);

      channelName = channelSelect->getBlueChannel()->getSourceChannelName();
      bands.push_back(channelName);
    }
    else
    {
      std::string channelName = channelSelect->getGrayChannel()->getSourceChannelName();
      bands.push_back(channelName);
    }

    std::vector<std::string> inputBands;
    for (unsigned int i = 0; i < raster->getNumberOfBands(); i++)
    {
      bool isOutputBand = false;
      for (unsigned int b = 0; b < bands.size(); b++)
      {
        if (bands[b] == te::common::Convert2String(i))
        {
          isOutputBand = true;
          break;
        }
      }

      if (!isOutputBand)
        inputBands.push_back(te::common::Convert2String(i));
    }

    m_doubleListWidget->clearInputValues();
    m_doubleListWidget->setInputValues(inputBands);
    m_doubleListWidget->setOutputValues(bands);
  }
}

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

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

te::rp::Filter::InputParameters  te::qt::widgets::FilterDialogForm::getInputParams()
{
  int idx = m_ui->m_typeComboBox->currentIndex();

  te::rp::Filter::InputParameters algoInputParams;
  algoInputParams.m_iterationsNumber = m_ui->m_iterationsSpinBox->value();
  algoInputParams.m_enableProgress = true;
  algoInputParams.m_filterType = (te::rp::Filter::InputParameters::FilterType)m_ui->m_typeComboBox->itemData(idx).toInt();

  if(
      (
        ( algoInputParams.m_filterType == te::rp::Filter::InputParameters::UserDefinedWindowT)
        ||
        ( algoInputParams.m_filterType == te::rp::Filter::InputParameters::ErosionFilterT)
        ||
        ( algoInputParams.m_filterType == te::rp::Filter::InputParameters::DilationFilterT)
      )
      &&
      (
        m_window.size1() > 0
      )
    )
  {
    algoInputParams.m_windowH = static_cast<unsigned int>(m_window.size1());
    algoInputParams.m_windowW = static_cast<unsigned int>(m_window.size2());
    algoInputParams.m_window = m_window;
  }
  else
  {
    algoInputParams.m_windowH = m_ui->m_maskSizeSpinBox->value();
    algoInputParams.m_windowW = m_ui->m_maskSizeSpinBox->value();
  }

  int nBands = static_cast<int>(m_doubleListWidget->getOutputValues().size());
  for(int i = 0; i < nBands; ++i)
  {
    algoInputParams.m_inRasterBands.push_back(std::atoi(m_doubleListWidget->getOutputValues()[i].c_str()));
  }

  return algoInputParams;
}

void te::qt::widgets::FilterDialogForm::onFilterTypeComboBoxActivated(int index)
{
  int filterType = m_ui->m_typeComboBox->itemData(index).toInt();

  bool flag =
    (
      ( filterType == te::rp::Filter::InputParameters::UserDefinedWindowT )
      ||
      ( filterType == te::rp::Filter::InputParameters::DilationFilterT )
      ||
      ( filterType == te::rp::Filter::InputParameters::ErosionFilterT )
    );

  m_ui->m_maskSizeSpinBox->setEnabled(flag);
  m_ui->m_maskToolButton->setEnabled(flag);
  m_ui->m_maskDefaultValueLineEdit->setEnabled(flag);

  if(m_ui->m_previewCheckBox->isChecked())
     applyPreview();
}

void te::qt::widgets::FilterDialogForm::onIterationsChanged(int /*iteration*/)
{
  getInputParams();

  if(m_ui->m_previewCheckBox->isChecked())
     applyPreview();
}

void te::qt::widgets::FilterDialogForm::onMaskToolButtonClicked()
{
  te::qt::widgets::MaskDialog dlg(this);

  dlg.setMaskSize(m_ui->m_maskSizeSpinBox->value(), m_ui->m_maskSizeSpinBox->value(),
    m_ui->m_maskDefaultValueLineEdit->text().isEmpty() ? 0 : m_ui->m_maskDefaultValueLineEdit->text().toDouble());

  if(dlg.exec() == QDialog::Accepted)
  {
    m_window = dlg.getMatrix();

    m_ui->m_loadMaskToolButton->setEnabled(true);
  }
}

void te::qt::widgets::FilterDialogForm::onLoadMaskToolButtonClicked()
{
  te::qt::widgets::MaskDialog dlg(this);

  dlg.setMaskSize(m_window);

  m_ui->m_maskSizeSpinBox->setValue(static_cast<int>(m_window.size1()));

  if(dlg.exec() == QDialog::Accepted)
  {
    m_window = dlg.getMatrix();
  }
}

void te::qt::widgets::FilterDialogForm::onPreviewCheckBoxToggled(bool isChecked)
{
  if (isChecked)
  {
    m_ui->m_navigatorWidget->setEnabled(true);
    m_navigator->setEnvelopeTool(true);
  }
  else
  {
    m_ui->m_navigatorWidget->setEnabled(false);
    m_navigator->setEnvelopeTool(false);
  }
}

void te::qt::widgets::FilterDialogForm::onOkPushButtonClicked()
{
  if(!m_inputWidget->getInputLayer().get())
  {
    QMessageBox::information(this, tr("Filter"), tr("Input image is not defined."));
    return;
  }

  //check output parameters
  if (m_outputWidget->getOutputRaster().empty())
  {
    QMessageBox::information(this, tr("Filter"), tr("Output image is not defined."));
    return;
  }

  if (!execute())
  {
    QMessageBox::information(this, tr("Filter"), tr("Error to execute the filter."));
    return;
  }

  clearCanvas();

  emit closeTool();
}

void te::qt::widgets::FilterDialogForm::layerChanged()
{
  m_layer = m_inputWidget->getInputLayer();
}

void te::qt::widgets::FilterDialogForm::onEnvelopeAcquired(te::gm::Envelope env)
{
  if (!m_ui->m_previewCheckBox->isChecked() || !env.isValid())
    return;

  if (env.getLowerLeftX() == 0 && env.getLowerLeftY() == 0 && env.getUpperRightX() == 0 && env.getUpperRightY() == 0)
    return;

  // verify if is necessary convert the raster to the given srid
  bool needRemap = false;
  if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_layer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_layer->getSRID()))
    needRemap = true;

  te::gm::Envelope envOut = env;

  // create a SRS converter
  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

  if (needRemap)
  {
    converter->setSourceSRID(m_mapDisplay->getSRID());
    converter->setTargetSRID(m_layer->getSRID());

    converter->convert(envOut.getLowerLeftX(), envOut.getLowerLeftY(), envOut.m_llx, envOut.m_lly);
    converter->convert(envOut.getUpperRightX(), envOut.getUpperRightY(), envOut.m_urx, envOut.m_ury);
  }

  if (!envOut.intersects(m_layer->getExtent()))
  {
    QMessageBox::warning(this, tr("Warning"), tr("ROI is invalid."));
    return;
  }

  m_geom = nullptr;

  m_geom = te::gm::GetGeomFromEnvelope(&env, m_mapDisplay->getSRID());

  if(!m_geom->isValid())
     return;

  getRasterFromROI();

  drawGeom();
}

void te::qt::widgets::FilterDialogForm::onMapDisplayExtentChanged()
{
  drawGeom();

  if (m_ui->m_previewCheckBox->isChecked() && m_previewRaster)
  {
    drawPreview(m_previewRaster);
  }
}

bool te::qt::widgets::FilterDialogForm::execute()
{
  if(m_outputWidget->fileExists())
  {
    QMessageBox::warning(this, tr("Filter"), tr("File already exists."));
    return false;
  }

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

  //run filter
  te::rp::Filter algorithmInstance;

  te::rp::Filter::InputParameters algoInputParams = getInputParams();
  algoInputParams.m_inRasterPtr = inputRst.get();

  te::rp::Filter::OutputParameters algoOutputParams;
  algoOutputParams.m_rInfo = m_outputWidget->getInfo();
  algoOutputParams.m_rType = m_outputWidget->getType();

  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  if (algorithmInstance.initialize(algoInputParams))
  {
    if (algorithmInstance.execute(algoOutputParams))
    {
      algoOutputParams.reset();

      //set output layer
      m_outputLayer = te::qt::widgets::createLayer(m_outputWidget->getType(),
                                                   m_outputWidget->getInfo());

      QMessageBox::information(this, tr("Filter"), tr("Filter ended sucessfully"));
    }
    else
    {
      QMessageBox::critical(this, tr("Filter"), tr("Filter execution error.") +
        (" " + algorithmInstance.getErrorMessage()).c_str());

      QApplication::restoreOverrideCursor();

      return false;
    }
  }
  else
  {
    QMessageBox::critical(this, tr("Filter"), tr("Filter initialization error.") +
      (" " + algorithmInstance.getErrorMessage() ).c_str());

    QApplication::restoreOverrideCursor();

    return false;
  }

  QApplication::restoreOverrideCursor();

  te::qt::widgets::applyRasterMultiResolution(tr("Filter"), te::map::GetRaster(m_outputLayer.get()));

  emit addLayer(m_outputLayer);

  return true;
}

void te::qt::widgets::FilterDialogForm::listBands()
{
  m_doubleListWidget->clearInputValues();
  m_doubleListWidget->clearOutputValues();

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

  if(inputRst.get())
  {
    std::vector<std::string> bands;

    for(unsigned int i = 0; i < inputRst->getNumberOfBands(); ++i)
       bands.push_back(te::common::Convert2String(i));

    m_doubleListWidget->setOutputValues(bands);
  }
}

void te::qt::widgets::FilterDialogForm::listFilterTypes()
{
  m_ui->m_typeComboBox->clear();

  m_ui->m_typeComboBox->addItem(tr("Sobel"), te::rp::Filter::InputParameters::SobelFilterT);
  m_ui->m_typeComboBox->addItem(tr("Roberts"), te::rp::Filter::InputParameters::RobertsFilterT);
  m_ui->m_typeComboBox->addItem(tr("Mean"), te::rp::Filter::InputParameters::MeanFilterT);
  m_ui->m_typeComboBox->addItem(tr("Mode"), te::rp::Filter::InputParameters::ModeFilterT);
  m_ui->m_typeComboBox->addItem(tr("Median"), te::rp::Filter::InputParameters::MedianFilterT);
  m_ui->m_typeComboBox->addItem(tr("Dilation"), te::rp::Filter::InputParameters::DilationFilterT);
  m_ui->m_typeComboBox->addItem(tr("Erosion"), te::rp::Filter::InputParameters::ErosionFilterT);
  m_ui->m_typeComboBox->addItem(tr("User Defined"), te::rp::Filter::InputParameters::UserDefinedWindowT);

  onFilterTypeComboBoxActivated(0);
}

void te::qt::widgets::FilterDialogForm::applyPreview()
{
  if (!m_rasterPreview)
    return;

  //run filter
  te::rp::Filter algorithmInstance;

  te::rp::Filter::InputParameters algoInputParams = getInputParams();
  algoInputParams.m_inRasterPtr = m_rasterPreview;

  te::rp::Filter::OutputParameters algoOutputParams;

  std::map<std::string, std::string> rinfo;
  rinfo["MEM_RASTER_NROWS"] = boost::lexical_cast<std::string>(m_rasterPreview->getNumberOfRows());
  rinfo["MEM_RASTER_NCOLS"] = boost::lexical_cast<std::string>(m_rasterPreview->getNumberOfColumns());
  rinfo["MEM_RASTER_DATATYPE"] = boost::lexical_cast<std::string>(m_rasterPreview->getBandDataType(0));
  rinfo["MEM_RASTER_NBANDS"] = boost::lexical_cast<std::string>(m_rasterPreview->getNumberOfBands());

  algoOutputParams.m_rType = "MEM";
  algoOutputParams.m_rInfo = rinfo;

  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  if (algorithmInstance.initialize(algoInputParams))
  {
    if (algorithmInstance.execute(algoOutputParams))
    {
      //set output layer
      te::dt::AbstractData* abs = algoOutputParams.m_outputRasterPtr->clone();

      te::rst::Raster* rst = static_cast<te::rst::Raster*>(abs);
      m_previewRaster = rst;

      if (m_ui->m_previewCheckBox->isChecked())
        drawPreview(m_previewRaster);

      QApplication::restoreOverrideCursor();
    }
    else
    {
      QApplication::restoreOverrideCursor();

      QMessageBox::critical(this, tr("Filter"), tr("Filter execution error.") +
        (" " + algorithmInstance.getErrorMessage()).c_str());

      return;
    }
  }
  else
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::critical(this, tr("Filter"), tr("Filter initialization error.") +
      (" " + algorithmInstance.getErrorMessage()).c_str());

    return;
  }
}

void te::qt::widgets::FilterDialogForm::drawPreview(te::rst::Raster* raster)
{
  QApplication::setOverrideCursor(Qt::WaitCursor);

  const te::gm::Envelope& envRaster = *raster->getExtent();
  const te::gm::Envelope& env = m_mapDisplay->getExtent();

  te::se::Style* style = te::se::CreateCoverageStyle(raster->getNumberOfBands());

  te::se::CoverageStyle* cs = dynamic_cast<te::se::CoverageStyle*>(style);
  assert(cs);

  te::qt::widgets::Canvas* canvasInstance = new Canvas(m_mapDisplay->width(), m_mapDisplay->height());
  canvasInstance->setDevice(m_mapDisplay->getDraftPixmap(), false);
  canvasInstance->setWindow(env.m_llx, env.m_lly, env.m_urx, env.m_ury);

  canvasInstance->setPolygonContourWidth(2);
  canvasInstance->setPolygonContourColor(te::color::RGBAColor(100, 177, 216, TE_OPAQUE));

  // Draw raster
  bool cancel = false;
  te::map::DrawRaster(raster, canvasInstance, envRaster, raster->getSRID(), env, m_mapDisplay->getSRID(), cs, nullptr, m_mapDisplay->getScale(), &cancel);
 
  if (!m_geom->isValid())
    return;

  canvasInstance->draw(m_geom);

  m_mapDisplay->repaint();

  delete canvasInstance;

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::FilterDialogForm::drawGeom()
{
  if(!m_geom || !m_geom->isValid())
    return;

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

  te::qt::widgets::Canvas* canvasInstance = new Canvas(m_mapDisplay->width(), m_mapDisplay->height());
  canvasInstance->setDevice(m_mapDisplay->getDraftPixmap(), false);
  canvasInstance->setWindow(env.m_llx, env.m_lly, env.m_urx, env.m_ury);

  canvasInstance->setPolygonContourWidth(2);
  canvasInstance->setPolygonContourColor(te::color::RGBAColor(100, 177, 216, TE_OPAQUE));

  canvasInstance->draw(m_geom);

  m_mapDisplay->repaint();

  delete canvasInstance;
}

te::se::ChannelSelection* te::qt::widgets::FilterDialogForm::getChannelSelection()
{
  te::se::Style* style = m_layer->getStyle();
  assert(style);

  te::se::CoverageStyle* cs = dynamic_cast<te::se::CoverageStyle*>(style);
  assert(cs);

  // for while, consider one rule
  const te::se::Rule* rule = cs->getRule(0);

  const std::vector<te::se::Symbolizer*>& symbolizers = rule->getSymbolizers();
  assert(!symbolizers.empty());

  // for while, consider one raster symbolizer
  te::se::RasterSymbolizer* symbolizer = dynamic_cast<te::se::RasterSymbolizer*>(symbolizers[0]);
  assert(symbolizer);

  return symbolizer->getChannelSelection();
}

void te::qt::widgets::FilterDialogForm::getRasterFromROI()
{
  if (m_geom->getGeomTypeId() == te::gm::PolygonType)
  {
    QApplication::setOverrideCursor(Qt::WaitCursor);

    te::gm::Envelope* env = new te::gm::Envelope(*m_geom->getMBR());

    // verify if is necessary convert the raster to the given srid
    bool needRemap = false;
    if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_layer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_layer->getSRID()))
      needRemap = true;

    // create a SRS converter
    std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

    if (needRemap)
    {
      converter->setSourceSRID(m_mapDisplay->getSRID());
      converter->setTargetSRID(m_layer->getSRID());

      converter->convert(env->getLowerLeftX(), env->getLowerLeftY(), env->m_llx, env->m_lly);
      converter->convert(env->getUpperRightX(), env->getUpperRightY(), env->m_urx, env->m_ury);
    }

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

    std::map<std::string, std::string> info;
    info["FORCE_MEM_DRIVER"] = "TRUE";
    //execute clipping
    m_rasterPreview = raster->trim(env, info);

    if (m_ui->m_previewCheckBox->isChecked())
    {
      applyPreview();
    }

    QApplication::restoreOverrideCursor();
  }
}

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

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

void te::qt::widgets::FilterDialogForm::closeEvent(QCloseEvent* /*e*/)
{
  clearCanvas();

  emit closeTool();
}