CloudDetectionDialog.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/connector/clouddetection/CloudDetectionDialog.cpp

  \brief ....
*/

// TerraLib
#include "../../../rp/CloudDetection.h"
#include "../../../common/Exception.h"
#include "../../../common/progress/ProgressManager.h"
#include "../../../common/StringUtils.h"
#include "../../../core/translator/Translator.h"
#include "../../../dataaccess/datasource/DataSource.h"
#include "../../../dataaccess/datasource/DataSourceFactory.h"
#include "../../../dataaccess/datasource/DataSourceInfoManager.h"
#include "../../../dataaccess/datasource/DataSourceTransactor.h"
#include "../../../dataaccess/datasource/DataSourceManager.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/Utils.h"
#include "../../../memory/DataSet.h"
#include "../../../memory/DataSetItem.h"
#include "../../../raster/RasterSummaryManager.h"
#include "../../../raster/Utils.h"
#include "../../../maptools/CanvasConfigurer.h"
#include "../../../se/serialization/xml/Symbolizer.h"
#include "../../../se/Symbolizer.h"
#include "../../../se/Utils.h"
#include "../../../xml/AbstractWriter.h"
#include "../../../xml/AbstractWriterFactory.h"
#include "../../../xml/Reader.h"
#include "../../../xml/ReaderFactory.h"
#include "../se/PolygonSymbolizerWidget.h"
#include "../../widgets/utils/FileDialog.h"
#include "../../widgets/datasource/selector/DataSourceSelectorDialog.h"
#include "../../widgets/canvas/Canvas.h"
#include "../../widgets/canvas/MapDisplay.h"
#include "../../widgets/layer/utils/DataSet2Layer.h"
#include "../../widgets/progress/ProgressViewerDialog.h"
#include "../../widgets/rp/RasterHistogramWidget.h"
#include "../../widgets/layer/search/LayerSearchDialog.h"
#include "../../widgets/layer/search/LayerSearchWidget.h"
#include "../../widgets/tools/ExtentAcquire.h"
#include "ui_CloudDetectionDialogForm.h"
#include "CloudDetectionDialog.h"

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

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

Q_DECLARE_METATYPE(te::map::AbstractLayerPtr)

te::qt::widgets::CloudDetectionDialog::CloudDetectionDialog(QWidget* parent, Qt::WindowFlags f)
  : QDialog(parent, f),
    m_ui(new Ui::CloudDetectionDialogForm),
    m_mapDisplay(nullptr),
    m_symbolizer(nullptr)
{
// add controls
  m_ui->setupUi(this);

  m_lastText = "";
  m_lastSelectedRow = -1;

  // set icons
  m_ui->m_upToolButton->setIcon(QIcon::fromTheme("go-up"));
  m_ui->m_downToolButton->setIcon(QIcon::fromTheme("go-down"));
  m_ui->m_targetDatasourceToolButton->setIcon(QIcon::fromTheme("datasource"));
  m_ui->m_styleToolButton->setIcon(QIcon::fromTheme("style"));

  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_navigatorWidget->setEnabled(false);

  connect(m_ui->m_cloudLayerComboBox, SIGNAL(activated(int)), this, SLOT(onCloudLayerComboBoxActivated(int)));
  connect(m_ui->m_shadowLayerComboBox, SIGNAL(activated(int)), this, SLOT(onShadowLayerComboBoxActivated(int)));
  connect(m_ui->m_cloudSearchLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchCloudLayerToolButtonClicked()));
  connect(m_ui->m_shadowSearchLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchShadowLayerToolButtonClicked()));
  connect(m_ui->m_cloudBandComboBox, SIGNAL(activated(int)), this, SLOT(onCloudBandComboBoxActivated(int)));
  connect(m_ui->m_shadowBandComboBox, SIGNAL(activated(int)), this, SLOT(onShadowBandComboBoxActivated(int)));
  connect(m_ui->m_upToolButton, SIGNAL(clicked()), this, SLOT(onUpToolButtonClicked()));
  connect(m_ui->m_downToolButton, SIGNAL(clicked()), this, SLOT(onDownToolButtonClicked()));
  connect(m_ui->m_previewCheckBox, SIGNAL(toggled(bool)), this, SLOT(onPreviewCheckBoxToggled(bool)));
  connect(m_ui->m_targetDatasourceToolButton, SIGNAL(clicked()), this, SLOT(onTargetDatasourceToolButtonClicked()));
  connect(m_ui->m_targetFileToolButton, SIGNAL(clicked()), this, SLOT(onTargetFileToolButtonClicked()));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), this, SLOT(onOkPushButtonClicked()));
  connect(m_ui->m_styleToolButton, SIGNAL(clicked()), this, SLOT(onStyleToolButtonClicked()));

  connect(m_ui->m_tableWidget, SIGNAL(cellClicked(int, int)), this, SLOT(onCellClicked(int, int)));
  connect(m_ui->m_tableWidget, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(onCellDoubleClicked(int, int)));
  connect(m_ui->m_tableWidget, SIGNAL(cellChanged(int, int)), this, SLOT(onCellChanged(int, int)));

  connect(m_navigator.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));

  m_ui->m_filterTableWidget->setRowCount(2);

  QCheckBox* checkBox1 = new QCheckBox();
  checkBox1->setParent(m_ui->m_filterTableWidget);
  checkBox1->setChecked(true);
  m_ui->m_filterTableWidget->setCellWidget(0, 0, checkBox1);
  QTableWidgetItem *item = new QTableWidgetItem(QString("Opening"));
  item->setFlags(item->flags() & ~Qt::ItemIsEditable);
  m_ui->m_filterTableWidget->setItem(0, 1, item);
  QTableWidgetItem *item1 = new QTableWidgetItem(QString("2"));
  m_ui->m_filterTableWidget->setItem(0, 2, item1);

  QCheckBox* checkBox2 = new QCheckBox();
  checkBox2->setParent(m_ui->m_filterTableWidget);
  checkBox2->setChecked(true);
  m_ui->m_filterTableWidget->setCellWidget(1, 0, checkBox2);
  QTableWidgetItem *item2 = new QTableWidgetItem(QString("Closing"));
  item2->setFlags(item2->flags() & ~Qt::ItemIsEditable);
  m_ui->m_filterTableWidget->setItem(1, 1, item2);
  QTableWidgetItem *item3 = new QTableWidgetItem(QString("2"));
  m_ui->m_filterTableWidget->setItem(1, 2, item3);

  //build histogram
  QGridLayout* histogramLayout = new QGridLayout(m_ui->m_histWidget);
  m_histogramWidget.reset(new te::qt::widgets::RasterHistogramWidget(m_ui->m_histWidget));
  m_histogramWidget->setEnableTools(true);
  histogramLayout->addWidget(m_histogramWidget.get());
  histogramLayout->setContentsMargins(0, 0, 0, 0);

#if (QT_VERSION >= 0x050000)
  m_ui->m_filterTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
#else
  m_ui->m_filterTableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
#endif

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

}

te::qt::widgets::CloudDetectionDialog::~CloudDetectionDialog()
{
  writeStyle();
}

void te::qt::widgets::CloudDetectionDialog::setLayers(std::list<te::map::AbstractLayerPtr> layers)
{
  int i = 0;

  QApplication::setOverrideCursor(Qt::WaitCursor);

  std::list<te::map::AbstractLayerPtr>::iterator it = layers.begin();
  //Filter only raster layers
  while (it != layers.end())
  {
    std::unique_ptr<te::da::DataSetType> dsType = it->get()->getSchema();
    if (dsType->hasRaster())
    {
      m_layers.push_back(it->get());
      m_ui->m_cloudLayerComboBox->insertItem(i, it->get()->getTitle().c_str());
      m_ui->m_shadowLayerComboBox->insertItem(i, it->get()->getTitle().c_str());
      ++i;
    }
      
    ++it;
  }

  m_cloudLayer = m_layers.begin()->get();
  m_shadowLayer = m_layers.begin()->get();

  QTableWidgetItem *itemCloudMin = new QTableWidgetItem(QString(""));
  itemCloudMin->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
  m_ui->m_tableWidget->setItem(0, 0, itemCloudMin);
  QTableWidgetItem *itemCloudMax = new QTableWidgetItem(QString(""));
  itemCloudMax->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
  m_ui->m_tableWidget->setItem(0, 1, itemCloudMax);
  QTableWidgetItem *itemShadowMin = new QTableWidgetItem(QString(""));
  itemShadowMin->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
  m_ui->m_tableWidget->setItem(1, 0, itemShadowMin);
  QTableWidgetItem *itemShadowMax = new QTableWidgetItem(QString(""));
  itemShadowMax->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
  m_ui->m_tableWidget->setItem(1, 1, itemShadowMax);

  setCloudBands();
  setShadowBands();

  setCloudMinMax();
  setShadowMinMax();

  m_ui->m_tableWidget->setCurrentCell(0, 0);

  m_ui->m_tableWidget->resizeColumnsToContents();

  m_ui->m_tableWidget->selectRow(0);

#if (QT_VERSION >= 0x050000)
  m_ui->m_tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
#else
  m_ui->m_tableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
#endif

  onCellClicked(0,0);

  QApplication::restoreOverrideCursor();
}

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

  connect(m_mapDisplay, SIGNAL(extentChanged()), this, SLOT(onMapDisplayExtentChanged()));
}

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

void te::qt::widgets::CloudDetectionDialog::setUserPath(std::string path)
{
  m_userPath = path;

  QString style = QString::fromUtf8(m_userPath.c_str())+ "/styleCloudDetection.xml";

  QFile file(style);

  if(file.exists())
     readStyle();
}

void te::qt::widgets::CloudDetectionDialog::onCloudLayerComboBoxActivated(int index)
{
  auto l_front = m_layers.begin();

  std::advance(l_front, index);
  m_cloudLayer = *l_front;

  setCloudBands();
  setCloudMinMax();

  int row = m_ui->m_tableWidget->currentRow();

  if (row == -1)
  {
    row = 0;
    m_ui->m_tableWidget->setCurrentCell(0, 0);
  }

  if (row == 0)
    m_histogramWidget->setInputRaster(m_cloudRaster.get());
  else if (row == 1)
    m_histogramWidget->setInputRaster(m_shadowRaster.get());

  m_lastSelectedRow = row;

  drawHistogram();
}

void te::qt::widgets::CloudDetectionDialog::onShadowLayerComboBoxActivated(int index)
{
  auto l_front = m_layers.begin();

  std::advance(l_front, index);
  m_shadowLayer = *l_front;

  setShadowBands();
  setShadowMinMax();

  int row = m_ui->m_tableWidget->currentRow();

  if (row == -1)
  {
    row = 1;
    m_ui->m_tableWidget->setCurrentCell(1, 0);
  }

  if (row == 0)
    m_histogramWidget->setInputRaster(m_cloudRaster.get());
  else if (row == 1)
    m_histogramWidget->setInputRaster(m_shadowRaster.get());

  m_lastSelectedRow = row;

  drawHistogram();
}

void te::qt::widgets::CloudDetectionDialog::onCloudBandComboBoxActivated(int index)
{
  QApplication::setOverrideCursor(Qt::WaitCursor);

  if (m_cloudMinValue[index] == std::numeric_limits<double>::min() && m_cloudMaxValue[index] == std::numeric_limits<double>::max())
  {
    // get minimun and maximun values from cloud layer

    const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(m_cloudRaster.get(), te::rst::SUMMARY_MIN, true);
    const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(m_cloudRaster.get(), te::rst::SUMMARY_MAX, true);
    const std::complex<double>* cmin = rsMin->at(index).m_minVal;
    const std::complex<double>* cmax = rsMax->at(index).m_maxVal;
    double min = cmin->real();
    double max = cmax->real();

    m_cloudMinValue[index] = min;
    m_cloudMaxValue[index] = max;
  }

  setCloudMinMax();

  int row = m_ui->m_tableWidget->currentRow();

  if (row == -1)
  {
    row = 0;
    m_ui->m_tableWidget->setCurrentCell(0, 0);
  }

  if (row == 0)
    m_histogramWidget->setInputRaster(m_cloudRaster.get());
  else if (row == 1)
    m_histogramWidget->setInputRaster(m_shadowRaster.get());

  m_lastSelectedRow = row;

  drawHistogram();

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::CloudDetectionDialog::onShadowBandComboBoxActivated(int index)
{
  QApplication::setOverrideCursor(Qt::WaitCursor);

  if (m_shadowMinValue[index] == std::numeric_limits<double>::min() && m_shadowMaxValue[index] == std::numeric_limits<double>::max())
  {
    // get minimun and maximun values from shadow layer
    const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(m_shadowRaster.get(), te::rst::SUMMARY_MIN, true);
    const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(m_shadowRaster.get(), te::rst::SUMMARY_MAX, true);
    const std::complex<double>* cmin = rsMin->at(index).m_minVal;
    const std::complex<double>* cmax = rsMax->at(index).m_maxVal;
    double min = cmin->real();
    double max = cmax->real();

    m_shadowMinValue[index] = min;
    m_shadowMaxValue[index] = max;
  }

  setShadowMinMax();

  int row = m_ui->m_tableWidget->currentRow();

  if (row == -1)
  {
    row = 1;
    m_ui->m_tableWidget->setCurrentCell(1, 0);
  }

  if (row == 0)
    m_histogramWidget->setInputRaster(m_cloudRaster.get());
  else if (row == 1)
    m_histogramWidget->setInputRaster(m_shadowRaster.get());

  m_lastSelectedRow = row;

  drawHistogram();

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::CloudDetectionDialog::onSearchCloudLayerToolButtonClicked()
{
  te::qt::widgets::LayerSearchDialog* dlg = new te::qt::widgets::LayerSearchDialog(this);
  dlg->getWidget()->filterOnlyByRaster();
  dlg->getWidget()->setList(m_layers);
  if (dlg->exec())
  {
    std::list<te::map::AbstractLayerPtr> layerList = dlg->getWidget()->getSelecteds();

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

    m_cloudLayer = *it;

    std::list<te::map::AbstractLayerPtr>::iterator itLayer = std::find(m_layers.begin(), m_layers.end(), *it);
    const int pos = std::distance(m_layers.begin(), itLayer);
    m_ui->m_cloudLayerComboBox->setCurrentIndex(pos);

    setCloudBands();
    setCloudMinMax();
  }
}

void te::qt::widgets::CloudDetectionDialog::onSearchShadowLayerToolButtonClicked()
{
  te::qt::widgets::LayerSearchDialog* dlg = new te::qt::widgets::LayerSearchDialog(this);
  dlg->getWidget()->filterOnlyByRaster();
  dlg->getWidget()->setList(m_layers);
  if (dlg->exec())
  {
    std::list<te::map::AbstractLayerPtr> layerList = dlg->getWidget()->getSelecteds();

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

    m_shadowLayer = *it;

    std::list<te::map::AbstractLayerPtr>::iterator itLayer = std::find(m_layers.begin(), m_layers.end(), *it);
    const int pos = std::distance(m_layers.begin(), itLayer);
    m_ui->m_shadowLayerComboBox->setCurrentIndex(pos);

    // get minimun and maximun values from shadow layer
    std::unique_ptr<te::da::DataSetType> dsType = m_shadowLayer->getSchema();
    te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());
    std::unique_ptr<te::da::DataSet> dsRaster = m_shadowLayer->getData();
    std::unique_ptr<te::rst::Raster> raster = dsRaster->getRaster(rasterProp->getName());

    for (int b = 0; b < static_cast<int>(raster->getNumberOfBands()); b++)
    {
      const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(raster.get(), te::rst::SUMMARY_MIN, true);
      const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(raster.get(), te::rst::SUMMARY_MAX, true);
      const std::complex<double>* cmin = rsMin->at(b).m_minVal;
      const std::complex<double>* cmax = rsMax->at(b).m_maxVal;

      double min = cmin->real();
      double max = cmax->real();

      m_shadowMinValue.push_back(min);
      m_shadowMaxValue.push_back(max);
    }

    setShadowBands();
    setShadowMinMax();
  }
}

void te::qt::widgets::CloudDetectionDialog::onDownToolButtonClicked()
{
  if (m_ui->m_filterTableWidget->currentRow() == -1)
  {
    QMessageBox::warning(this, tr("Warning"), tr("Please, select a entry first to move!"));
    return;
  }

  int row = m_ui->m_filterTableWidget->currentRow();

  if (row == m_ui->m_filterTableWidget->rowCount() - 1)
    return;

  QTableWidgetItem *item1Col0 = m_ui->m_filterTableWidget->takeItem(row, 0);
  QTableWidgetItem *item1Col1 = m_ui->m_filterTableWidget->takeItem(row, 1);
  QTableWidgetItem *item1Col2 = m_ui->m_filterTableWidget->takeItem(row, 2);
  QTableWidgetItem *item2Col0 = m_ui->m_filterTableWidget->takeItem(row + 1, 0);
  QTableWidgetItem *item2Col1 = m_ui->m_filterTableWidget->takeItem(row + 1, 1);
  QTableWidgetItem *item2Col2 = m_ui->m_filterTableWidget->takeItem(row + 1, 2);

  m_ui->m_filterTableWidget->setItem(row, 0, item2Col0);
  m_ui->m_filterTableWidget->setItem(row, 1, item2Col1);
  m_ui->m_filterTableWidget->setItem(row, 2, item2Col2);
  m_ui->m_filterTableWidget->setItem(row + 1, 0, item1Col0);
  m_ui->m_filterTableWidget->setItem(row + 1, 1, item1Col1);
  m_ui->m_filterTableWidget->setItem(row + 1, 2, item1Col2);
}

void te::qt::widgets::CloudDetectionDialog::onUpToolButtonClicked()
{
  if (m_ui->m_filterTableWidget->currentRow() == -1)
  {
    QMessageBox::warning(this, tr("Warning"), tr("Please, select a entry first to move!"));
    return;
  }

  int row = m_ui->m_filterTableWidget->currentRow();

  if (row == 0)
    return;

  QTableWidgetItem *item1Col0 = m_ui->m_filterTableWidget->takeItem(row, 0);
  QTableWidgetItem *item1Col1 = m_ui->m_filterTableWidget->takeItem(row, 1);
  QTableWidgetItem *item1Col2 = m_ui->m_filterTableWidget->takeItem(row, 2);
  QTableWidgetItem *item2Col0 = m_ui->m_filterTableWidget->takeItem(row - 1, 0);
  QTableWidgetItem *item2Col1 = m_ui->m_filterTableWidget->takeItem(row - 1, 1);
  QTableWidgetItem *item2Col2 = m_ui->m_filterTableWidget->takeItem(row - 1, 2);

  m_ui->m_filterTableWidget->setItem(row, 0, item2Col0);
  m_ui->m_filterTableWidget->setItem(row, 1, item2Col1);
  m_ui->m_filterTableWidget->setItem(row, 2, item2Col2);
  m_ui->m_filterTableWidget->setItem(row - 1, 0, item1Col0);
  m_ui->m_filterTableWidget->setItem(row - 1, 1, item1Col1);
  m_ui->m_filterTableWidget->setItem(row - 1, 2, item1Col2);
}

void te::qt::widgets::CloudDetectionDialog::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::CloudDetectionDialog::onCellClicked(int row,
                                                          int /*column*/)
{
  if (row == m_lastSelectedRow)
    return;

  if (row == 0)
    m_histogramWidget->setInputRaster(m_cloudRaster.get());
  else if (row == 1)
    m_histogramWidget->setInputRaster(m_shadowRaster.get());

  m_lastSelectedRow = row;

  drawHistogram();
}

void te::qt::widgets::CloudDetectionDialog::onCellDoubleClicked(int row, int column)
{
  m_lastText = m_ui->m_tableWidget->item(row, column)->text().toUtf8().data();
}

void te::qt::widgets::CloudDetectionDialog::onCellChanged(int row, int column)
{
  if (!isdigit(*m_ui->m_tableWidget->item(row, column)->text().toUtf8().data()))
  {
    m_ui->m_tableWidget->item(row, column)->setText(m_lastText.c_str());
    return;
  }
}

void te::qt::widgets::CloudDetectionDialog::onFilterCellClicked(int /*row*/,
                                                                int column)
{
  if (column != 0)
    return;
}

void te::qt::widgets::CloudDetectionDialog::onFilterCellDoubleClicked(int row, int column)
{
  if (column != 2)
    return;

  m_lastText = m_ui->m_filterTableWidget->item(row, column)->text().toUtf8().data();
}

void te::qt::widgets::CloudDetectionDialog::onFilterCellChanged(int row, int column)
{
  if (column != 2)
    return;

  if (!isdigit(*m_ui->m_filterTableWidget->item(row, column)->text().toUtf8().data()))
  {
    m_ui->m_filterTableWidget->item(row, column)->setText(m_lastText.c_str());
    return;
  }
}

void te::qt::widgets::CloudDetectionDialog::onTargetDatasourceToolButtonClicked()
{
  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()));
}

void te::qt::widgets::CloudDetectionDialog::onTargetFileToolButtonClicked()
{
  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;
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("File information"), tr("Output layer is invalid."));
    return;
  }

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

  m_ui->m_newLayerNameLineEdit->setEnabled(false);
}

void te::qt::widgets::CloudDetectionDialog::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_ui->m_tableWidget->currentRow() == 0)
  {
    if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_cloudLayer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_cloudLayer->getSRID()))
      needRemap = true;
  }
  else if (m_ui->m_tableWidget->currentRow() == 1)
  {
    if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_shadowLayer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_shadowLayer->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());

    if (m_ui->m_tableWidget->currentRow() == 0)
      converter->setTargetSRID(m_cloudLayer->getSRID());
    else if (m_ui->m_tableWidget->currentRow() == 1)
      converter->setTargetSRID(m_shadowLayer->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 ((m_ui->m_tableWidget->currentRow() == 0) && (!envOut.intersects(m_cloudLayer->getExtent())))
  {
    QMessageBox::warning(this, tr("Warning"), tr("ROI is invalid."));
    return;
  }
  else if ((m_ui->m_tableWidget->currentRow() == 1) && (!envOut.intersects(m_shadowLayer->getExtent())))
  {
    QMessageBox::warning(this, tr("Warning"), tr("ROI is invalid."));
    return;
  }

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

  drawGeom();

  getRasterFromROI();
}

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

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

void te::qt::widgets::CloudDetectionDialog::onOkPushButtonClicked()
{
  //check output parameters
  if (m_ui->m_newLayerNameLineEdit->text().isEmpty())
  {
    QMessageBox::information(this, tr("Cloud Detection"), tr("Output image is not defined."));
    return;
  }

  if (!execute())
    return;

  clearCanvas();

  emit closeTool();
}

void te::qt::widgets::CloudDetectionDialog::onStyleToolButtonClicked()
{
  QDialog* dialog = new QDialog(this);
  QBoxLayout* layout = new QBoxLayout(QBoxLayout::TopToBottom, dialog);

  QDialogButtonBox* bbox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, dialog);

  QWidget* symbWidget = nullptr;

  symbWidget = new te::qt::widgets::PolygonSymbolizerWidget(dialog);
  m_polygonSymbolizerWidget.reset((te::qt::widgets::PolygonSymbolizerWidget*)symbWidget);

  if(m_symbolizer != nullptr)
    m_polygonSymbolizerWidget->setSymbolizer((te::se::PolygonSymbolizer*)m_symbolizer);

  layout->addWidget(symbWidget);
  layout->addWidget(bbox);

  connect(bbox, SIGNAL(accepted()), dialog, SLOT(accept()));
  connect(bbox, SIGNAL(rejected()), dialog, SLOT(reject()));

  if(dialog->exec() == QDialog::Rejected)
    return;
}

void te::qt::widgets::CloudDetectionDialog::writeStyle()
{
  if (m_symbolizer == nullptr)
    return;

  std::unique_ptr<te::xml::AbstractWriter> writer(te::xml::AbstractWriterFactory::make());

  QString path = QString::fromStdString(m_userPath)+ "/styleCloudDetection.xml";

  writer->setURI(path.toUtf8().data());

  writer->writeStartDocument("UTF-8", "no");

  writer->writeStartElement("PolygonSymbolizer");

  writer->writeAttribute("xmlns", "http://www.opengis.net/sld");
  writer->writeAttribute("xmlns:ogc", "http://www.opengis.net/ogc");
  writer->writeAttribute("xmlns:se", "http://www.opengis.net/se");
  writer->writeAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
  writer->writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
  writer->writeAttribute("xsi:schemaLocation", "http://www.opengis.net/sld PolygonSymbolizer.xsd");

  writer->writeAttribute("version", m_symbolizer->getVersion());

  te::se::serialize::Symbolizer::getInstance().write(m_symbolizer, *writer.get());

  writer->writeEndElement("PolygonSymbolizer");

  writer->writeToFile();
}

void te::qt::widgets::CloudDetectionDialog::readStyle()
{
  std::unique_ptr<te::xml::Reader> reader(te::xml::ReaderFactory::make());
  reader->setValidationScheme(false);

  QString path = QString::fromStdString(m_userPath)+ "/styleCloudDetection.xml";

  reader->read(path.toUtf8().data());
  reader->next();

  if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
    (reader->getElementLocalName() == "PolygonSymbolizer"))
    reader->next();

  m_symbolizer = te::se::serialize::Symbolizer::getInstance().read(*reader.get());
}

bool te::qt::widgets::CloudDetectionDialog::execute()
{
  //get cloud layer
  std::unique_ptr<te::rst::Raster> cloudRst(te::map::GetRaster(m_cloudLayer.get()));

  //get shadow layer
  std::unique_ptr<te::rst::Raster> shadowRst(te::map::GetRaster(m_shadowLayer.get()));

  if (!cloudRst->getExtent()->intersects(*shadowRst->getExtent()))
  {
    QMessageBox::warning(this, tr("Cloud Detection"), tr("Input layers don't intersect!"));
    return false;
  }

  if ((cloudRst->getNumberOfColumns() != shadowRst->getNumberOfColumns()) ||
    (cloudRst->getNumberOfRows() != shadowRst->getNumberOfRows()))
  {
    QMessageBox::warning(this, tr("Cloud Detection"), tr("Input layers has diferents sizes!"));
    return false;
  }

  int cloudBand = m_ui->m_cloudBandComboBox->currentText().toUtf8().toInt();
  int shadowBand = m_ui->m_shadowBandComboBox->currentText().toUtf8().toInt();

  double minCloud = atof(m_ui->m_tableWidget->item(0, 0)->text().toUtf8().data());
  double maxCloud = atof(m_ui->m_tableWidget->item(0, 1)->text().toUtf8().data());
  double minShadow = atof(m_ui->m_tableWidget->item(1, 0)->text().toUtf8().data());
  double maxShadow = atof(m_ui->m_tableWidget->item(1, 1)->text().toUtf8().data());

  std::vector<te::rp::Filter::InputParameters::FilterType> vecFilter;
  std::vector<int> vecIt;

  int nrows = m_ui->m_filterTableWidget->rowCount();

  for (int i = 0; i < nrows; i++)
  {
    if (!dynamic_cast<QCheckBox*>(m_ui->m_filterTableWidget->cellWidget(i, 0))->isChecked())
      continue;

    std::string filter = m_ui->m_filterTableWidget->item(i, 1)->text().toUtf8().data();
    int nIt = m_ui->m_filterTableWidget->item(i, 2)->text().toUtf8().toInt();

    if (te::common::Convert2LCase(filter) == "opening")
    {
      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::ErosionFilterT);
      vecIt.push_back(nIt);

      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::DilationFilterT);
      vecIt.push_back(nIt);
    }
    else if (te::common::Convert2LCase(filter) == "closing")
    {
      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::DilationFilterT);
      vecIt.push_back(nIt);

      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::ErosionFilterT);
      vecIt.push_back(nIt);
    }
  }

  std::unique_ptr<te::rp::CloudDetection> cloudDetection(new te::rp::CloudDetection());

  try
  {
    QApplication::setOverrideCursor(Qt::WaitCursor);

    //run cloud detection operation
    te::rst::Raster* raster = cloudDetection->executeCloudDetection(cloudRst.get(), shadowRst.get(), cloudBand, shadowBand,
      minCloud, maxCloud, minShadow, maxShadow, vecFilter, vecIt);

    //check output parameters
    std::string outputdataset = m_ui->m_newLayerNameLineEdit->text().toUtf8().data();

    if (outputdataset.empty())
    {
      QApplication::restoreOverrideCursor();
      QMessageBox::warning(this, tr("Vectorizer"), tr("Output dataset name not defined."));
      return false;
    }

    std::string uriStr = m_ui->m_repositoryLineEdit->text().toUtf8().data();

    if (uriStr.empty())
    {
      QApplication::restoreOverrideCursor();
      QMessageBox::warning(this, tr("Vectorizer"), tr("Output repository name not defined."));
      return false;
    }

    //check output datasource parameters
    te::da::DataSourceInfoPtr outDSInfo;

    boost::filesystem::path uri(uriStr);

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

    std::string dsinfo("file://" + uri.string());

    // 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::DataSourceInfoManager::getInstance().add(ds);
    outDSInfo = ds;

    //output parameters
    std::vector<te::gm::Geometry*> geomVec;
    std::vector< double > geomsValues;

    //vectorize
    if (!vectorize(raster, geomVec, geomsValues))
    {
      QApplication::restoreOverrideCursor();
      return false;
    }

    //save data
    std::unique_ptr<te::da::DataSetType> dsType = createDataSetType(outputdataset, raster->getSRID());

    std::unique_ptr<te::mem::DataSet> dsMem = createDataSet(dsType.get(), geomVec, geomsValues);

    te::da::DataSourcePtr dataSource = te::da::DataSourceManager::getInstance().get(outDSInfo->getId(), outDSInfo->getType(), outDSInfo->getConnInfo());

    saveDataSet(dsMem.get(), dsType.get(), dataSource, outputdataset);

    //create output layer
    te::da::DataSourcePtr outDataSource = te::da::GetDataSource(outDSInfo->getId());

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

    te::da::DataSetTypePtr dt(outDataSource->getDataSetType(outputdataset).release());

    m_outputLayer = converter(dt);

    delete raster;
  }
  catch (te::common::Exception& e)
  {
    QApplication::restoreOverrideCursor();
    QMessageBox::warning(this, tr("Cloud Detection"), e.what());
    return false;
  }

  QApplication::restoreOverrideCursor();

  emit addLayer(m_outputLayer);

  return true;
}

bool te::qt::widgets::CloudDetectionDialog::vectorize(te::rst::Raster* raster, std::vector<te::gm::Geometry*>& geomVec, std::vector< double >& geomsValues)
{
  //input parameters
  unsigned int band = 0;
  unsigned int maxGeom = 0;

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

  QApplication::setOverrideCursor(Qt::WaitCursor);

  try
  {
    //run operation
    raster->vectorize(geomVec, band, maxGeom, &geomsValues);
  }
  catch (const std::exception& e)
  {
    QMessageBox::warning(this, tr("Vectorizer"), e.what());

    QApplication::restoreOverrideCursor();

    return false;
  }
  catch (...)
  {
    QMessageBox::warning(this, tr("Vectorizer"), tr("An exception has occurred!"));

    QApplication::restoreOverrideCursor();

    return false;
  }

  QApplication::restoreOverrideCursor();

  return true;
}

void te::qt::widgets::CloudDetectionDialog::setCloudBands()
{
  m_ui->m_cloudBandComboBox->clear();
  m_cloudMinValue.clear();
  m_cloudMaxValue.clear();

  m_cloudRaster.reset(te::map::GetRaster(m_cloudLayer.get()));

  for (int b = 0; b < static_cast<int>(m_cloudRaster->getNumberOfBands()); b++)
  {
    m_ui->m_cloudBandComboBox->addItem(te::common::Convert2String(b).c_str());

    m_cloudMinValue.push_back(std::numeric_limits<double>::min());
    m_cloudMaxValue.push_back(std::numeric_limits<double>::max());
  }

  // get minimun and maximun values from cloud layer
  const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(m_cloudRaster.get(), te::rst::SUMMARY_MIN, true);
  const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(m_cloudRaster.get(), te::rst::SUMMARY_MAX, true);
  const std::complex<double>* cmin = rsMin->at(0).m_minVal;
  const std::complex<double>* cmax = rsMax->at(0).m_maxVal;
  double min = cmin->real();
  double max = cmax->real();

  m_cloudMinValue[0] = min;
  m_cloudMaxValue[0] = max;
}

void te::qt::widgets::CloudDetectionDialog::setShadowBands()
{
  m_ui->m_shadowBandComboBox->clear();
  m_shadowMinValue.clear();
  m_shadowMaxValue.clear();

  m_shadowRaster.reset(te::map::GetRaster(m_shadowLayer.get()));

  for (int b = 0; b < static_cast<int>(m_shadowRaster->getNumberOfBands()); b++)
  {
    m_ui->m_shadowBandComboBox->addItem(te::common::Convert2String(b).c_str());

    m_shadowMinValue.push_back(std::numeric_limits<double>::min());
    m_shadowMaxValue.push_back(std::numeric_limits<double>::max());
  }

  // get minimun and maximun values from shadow layer
  const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(m_shadowRaster.get(), te::rst::SUMMARY_MIN, true);
  const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(m_shadowRaster.get(), te::rst::SUMMARY_MAX, true);
  const std::complex<double>* cmin = rsMin->at(0).m_minVal;
  const std::complex<double>* cmax = rsMax->at(0).m_maxVal;
  double min = cmin->real();
  double max = cmax->real();

  m_shadowMinValue[0] = min;
  m_shadowMaxValue[0] = max;
}

void te::qt::widgets::CloudDetectionDialog::setCloudMinMax()
{
  std::string vmin = te::common::Convert2String(m_cloudMinValue[m_ui->m_cloudBandComboBox->currentIndex()], 2);
  m_ui->m_tableWidget->item(0, 0)->setText(QString(vmin.c_str()));

  std::string vmax = te::common::Convert2String(m_cloudMaxValue[m_ui->m_cloudBandComboBox->currentIndex()], 2);
  m_ui->m_tableWidget->item(0, 1)->setText(QString(vmax.c_str()));
}

void te::qt::widgets::CloudDetectionDialog::setShadowMinMax()
{
  std::string vmin = te::common::Convert2String(m_shadowMinValue[m_ui->m_shadowBandComboBox->currentIndex()], 2);
  m_ui->m_tableWidget->item(1, 0)->setText(QString(vmin.c_str()));

  std::string vmax = te::common::Convert2String(m_shadowMaxValue[m_ui->m_shadowBandComboBox->currentIndex()], 2);
  m_ui->m_tableWidget->item(1, 1)->setText(QString(vmax.c_str()));
}

void te::qt::widgets::CloudDetectionDialog::drawHistogram()
{
  int i = m_ui->m_tableWidget->currentRow();

  if (i == -1)
    return;

  QApplication::setOverrideCursor(Qt::WaitCursor);

  m_histogramWidget->setChartInputColor(127, 127, 127);

  int bandIdx = -1;

  if (i == 0)
    bandIdx = m_ui->m_cloudBandComboBox->currentIndex();
  else if (i == 1)
    bandIdx = m_ui->m_shadowBandComboBox->currentIndex();

  double min = m_ui->m_tableWidget->item(i, 0)->text().toDouble();
  double max = m_ui->m_tableWidget->item(i, 1)->text().toDouble();

  m_histogramWidget->updateMinimumValueLine(min, false);
  m_histogramWidget->updateMaximumValueLine(max, false);

  m_histogramWidget->drawHistogram(bandIdx);

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::CloudDetectionDialog::applyPreview()
{
  if (!m_cloudRasterPreview.get() || !m_shadowRasterPreview.get())
    return;

  QApplication::setOverrideCursor(Qt::WaitCursor);

  if (!m_cloudRasterPreview->getExtent()->intersects(*m_shadowRasterPreview->getExtent()))
  {
    QApplication::restoreOverrideCursor();
    QMessageBox::warning(this, tr("Cloud Detection"), tr("Input layers don't intersect!"));
    return;
  }

  if ((m_cloudRasterPreview->getNumberOfColumns() != m_shadowRasterPreview->getNumberOfColumns()) ||
    (m_cloudRasterPreview->getNumberOfRows() != m_shadowRasterPreview->getNumberOfRows()))
  {
    QApplication::restoreOverrideCursor();
    QMessageBox::warning(this, tr("Cloud Detection"), tr("Input layers has diferents sizes!"));
    return;
  }

  int cloudBand = m_ui->m_cloudBandComboBox->currentText().toUtf8().toInt();
  int shadowBand = m_ui->m_shadowBandComboBox->currentText().toUtf8().toInt();

  double minCloud = atof(m_ui->m_tableWidget->item(0, 0)->text().toUtf8().data());
  double maxCloud = atof(m_ui->m_tableWidget->item(0, 1)->text().toUtf8().data());
  double minShadow = atof(m_ui->m_tableWidget->item(1, 0)->text().toUtf8().data());
  double maxShadow = atof(m_ui->m_tableWidget->item(1, 1)->text().toUtf8().data());

  std::vector<te::rp::Filter::InputParameters::FilterType> vecFilter;
  std::vector<int> vecIt;

  int nrows = m_ui->m_filterTableWidget->rowCount();

  for (int i = 0; i < nrows; i++)
  {
    if (!dynamic_cast<QCheckBox*>(m_ui->m_filterTableWidget->cellWidget(i, 0))->isChecked())
    {
      continue;
    }

    std::string filter = m_ui->m_filterTableWidget->item(i, 1)->text().toUtf8().data();
    int nIt = m_ui->m_filterTableWidget->item(i, 2)->text().toUtf8().toInt();

    if (te::common::Convert2LCase(filter) == "opening")
    {
      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::ErosionFilterT);
      vecIt.push_back(nIt);

      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::DilationFilterT);
      vecIt.push_back(nIt);
    }
    else if (te::common::Convert2LCase(filter) == "closing")
    {
      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::DilationFilterT);
      vecIt.push_back(nIt);

      vecFilter.push_back(te::rp::Filter::InputParameters::FilterType::ErosionFilterT);
      vecIt.push_back(nIt);
    }
  }

  std::unique_ptr<te::rp::CloudDetection> cloudDetection(new te::rp::CloudDetection());

  try
  {
    //run cloud detection operation
    te::rst::Raster* raster = cloudDetection->executeCloudDetection(m_cloudRasterPreview.get(), m_shadowRasterPreview.get(), cloudBand, shadowBand,
      minCloud, maxCloud, minShadow, maxShadow, vecFilter, vecIt);

    //output parameters
    std::vector<te::gm::Geometry*> geomVec;
    std::vector< double > geomsValues;

    //vectorize
    if (!vectorize(raster, geomVec, geomsValues))
    {
      QApplication::restoreOverrideCursor();
      return;
    }

    delete raster;

    if (m_ui->m_previewCheckBox->isChecked())
    {
      //draw geometries

      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(1);
      canvasInstance->setPolygonContourColor(te::color::RGBAColor(217, 17, 27, TE_OPAQUE));

      te::map::CanvasConfigurer cc(canvasInstance);

      if(m_polygonSymbolizerWidget.get())
      {
        m_symbolizer = m_polygonSymbolizerWidget->getSymbolizer();

        cc.config(m_symbolizer);
      }
      else if(m_symbolizer != 0)
      {
        cc.config(m_symbolizer);
      }

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

        canvasInstance->draw(geomVec[i]);
      }

      m_mapDisplay->repaint();

      delete canvasInstance;

      drawGeom();

    }
  }
  catch (te::common::Exception& e)
  {
    QApplication::restoreOverrideCursor();
    QMessageBox::warning(this, tr("Cloud Detection"), e.what());
    return;
  }

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::CloudDetectionDialog::drawGeom()
{
  if(!m_geom.get() || 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(1);
  canvasInstance->setPolygonContourColor(te::color::RGBAColor(100, 177, 216, TE_OPAQUE));

  canvasInstance->draw(m_geom.get());

  m_mapDisplay->repaint();

  delete canvasInstance;
}

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

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

    //get cloud raster from ROI
    // verify if is necessary convert the raster to the given srid
    bool needRemap = false;
    if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_cloudLayer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_cloudLayer->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_cloudLayer->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::da::DataSetType> dsType = m_cloudLayer->getSchema();

    te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());
    std::unique_ptr<te::da::DataSet> dsRaster = m_cloudLayer->getData();

    std::unique_ptr<te::rst::Raster> raster = dsRaster->getRaster(rasterProp->getName());

    std::map<std::string, std::string> infoCloud;
    infoCloud["FORCE_MEM_DRIVER"] = "TRUE";
    //execute clipping
    m_cloudRasterPreview.reset(raster->trim(env, infoCloud));

    //get shadow raster from ROI
    // verify if is necessary convert the raster to the given srid
    needRemap = false;
    if ((m_cloudLayer->getSRID() != TE_UNKNOWN_SRS) && (m_shadowLayer->getSRID() != TE_UNKNOWN_SRS) && (m_cloudLayer->getSRID() != m_shadowLayer->getSRID()))
      needRemap = true;

    if (needRemap)
    {
      converter->setSourceSRID(m_cloudLayer->getSRID());
      converter->setTargetSRID(m_shadowLayer->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);
    }

    dsType = m_shadowLayer->getSchema();
    rasterProp = te::da::GetFirstRasterProperty(dsType.get());
    dsRaster = m_shadowLayer->getData();

    raster = dsRaster->getRaster(rasterProp->getName());

    std::map<std::string, std::string> infoShadow;
    infoShadow["FORCE_MEM_DRIVER"] = "TRUE";
    //execute clipping
    m_shadowRasterPreview.reset(raster->trim(env, infoShadow));

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

    QApplication::restoreOverrideCursor();
  }
}

std::unique_ptr<te::da::DataSetType> te::qt::widgets::CloudDetectionDialog::createDataSetType(std::string dataSetName, int srid)
{
  std::unique_ptr<te::da::DataSetType> dsType(new te::da::DataSetType(dataSetName));

  //create id property
  te::dt::SimpleProperty* idProperty = new te::dt::SimpleProperty("id", te::dt::INT32_TYPE);
  dsType->add(idProperty);

  //create geometry property
  te::gm::GeometryProperty* geomProperty = new te::gm::GeometryProperty("geom", srid, te::gm::PolygonType);
  dsType->add(geomProperty);

  //create primary key
  std::string pkName = "pk_id";
  pkName += "_" + dataSetName;
  te::da::PrimaryKey* pk = new te::da::PrimaryKey(pkName, dsType.get());
  pk->add(idProperty);

  return dsType;
}

std::unique_ptr<te::mem::DataSet>
te::qt::widgets::CloudDetectionDialog::createDataSet(
    te::da::DataSetType* dsType, std::vector<te::gm::Geometry*>& geoms,
    std::vector<double>& /*geomsValues*/)
{
  std::unique_ptr<te::mem::DataSet> ds(new te::mem::DataSet(dsType));

  for (std::size_t t = 0; t < geoms.size(); ++t)
  {
    //create dataset item
    te::mem::DataSetItem* item = new te::mem::DataSetItem(ds.get());

    //set id
    item->setInt32(0, (int)t);

    //set geometry
    item->setGeometry(1, geoms[t]);

    ds->add(item);
  }

  return ds;
}

void te::qt::widgets::CloudDetectionDialog::saveDataSet(te::mem::DataSet* dataSet, te::da::DataSetType* dsType, te::da::DataSourcePtr ds, std::string dataSetName)
{
  //save dataset
  dataSet->moveBeforeFirst();

  std::map<std::string, std::string> options;

  ds->createDataSet(dsType, options);

  ds->add(dataSetName, dataSet, options);
}

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

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

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

  emit closeTool();
}