ContrastDialogForm.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/ContrastDialogForm.cpp

  \brief This file defines a class for a Contrast dialog.
*/

// TerraLib
#include "../../af/ApplicationController.h"
#include "../../../raster/Grid.h"
#include "../../../common/progress/ProgressManager.h"
#include "../../../common/StringUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../geometry/Utils.h"
#include "../../../memory/DataSet.h"
#include "../../../memory/DataSetItem.h"
#include "../../../raster/Raster.h"
#include "../../../raster/RasterProperty.h"
#include "../../../raster/RasterSummaryManager.h"
#include "../../../raster/Utils.h"
#include "../../../maptools/Utils.h"
#include "../../../rp/Module.h"
#include "../../../qt/widgets/rp/Utils.h"
#include "../../../qt/widgets/utils/ScopedCursor.h"
#include "../../../se/CoverageStyle.h"
#include "../../../se/RasterSymbolizer.h"
#include "../../../se/Rule.h"
#include "../../../se/SelectedChannel.h"
#include "../../../se/Symbolizer.h"
#include "../../../se/Utils.h"
#include "../../af/ApplicationController.h"
#include "../../af/events/ApplicationEvents.h"
#include "../../af/events/LayerEvents.h"
#include "../../widgets/tools/ExtentAcquire.h"
#include "../canvas/Canvas.h"
#include "../progress/ProgressViewerDialog.h"
#include "Utils.h"
#include "ContrastDialogForm.h"
#include "RasterHistogramWidget.h"
#include "RasterNavigatorWidget.h"
#include "OutputRasterWidget.h"
#include "ui_ContrastDialogForm.h"

// Qt
#include <QGridLayout>
#include <QMessageBox>

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

//STL
#include <memory>

te::qt::widgets::ContrastDialogForm::ContrastDialogForm(QWidget* parent)
  : QDialog(parent),
  m_ui(new Ui::ContrastDialogForm),
    m_layer(nullptr),
    m_outputWidget(nullptr),
    m_mapDisplay(nullptr)
{
  m_lastText = "";
  m_updatePreview = false;
  m_bandChecked = true;

// setup controls
  m_ui->setupUi(this);

  fillContrastTypes();

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

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

  m_ui->m_resetToolButton->setIcon(QIcon::fromTheme("edit-undo"));

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

//connects
  connect(m_ui->m_contrastTypeComboBox, SIGNAL(activated(int)), this, SLOT(onContrastTypeComboBoxActivated(int)));
  connect(m_ui->m_bandTableWidget, SIGNAL(cellClicked(int, int)), this, SLOT(onCellClicked(int, int)));
  connect(m_ui->m_bandTableWidget, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(onCellDoubleClicked(int, int)));
  connect(m_ui->m_bandTableWidget, SIGNAL(cellChanged(int, int)), this, SLOT(onCellChanged(int,int)));

  connect(m_ui->m_previewCheckBox, SIGNAL(toggled(bool)), this, SLOT(onPreviewCheckBoxToggled(bool)));
  connect(m_ui->m_resetToolButton, SIGNAL(clicked()), this, SLOT(onResetValuesToolButtonClicked()));

  connect(m_ui->m_allImageRadioButton, SIGNAL(toggled(bool)), this, SLOT(onAllImageRadioButtonToggled(bool)));
  connect(m_ui->m_visibleAreaRadioButton, SIGNAL(toggled(bool)), this, SLOT(onVisibleAreaRadioButtonToggled(bool)));
  connect(m_ui->m_roiRadioButton, SIGNAL(toggled(bool)), this, SLOT(onRoiRadioButtonToggled(bool)));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), this, SLOT(onOkPushButtonClicked()));
  connect(m_navigator.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));

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

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

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

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

  for (std::size_t b = 0; b < 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_minValue.push_back(min);
    m_maxValue.push_back(max);
  }

  if (raster->getBand(0)->getProperty()->getType() == te::dt::UCHAR_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT16_TYPE ||
    raster->getBand(0)->getProperty()->getType() == te::dt::UINT32_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT64_TYPE)
  {
    connect(m_histogramWidget.get(), SIGNAL(minValueSelected(int, int)), this, SLOT(onMinValueSelected(int, int)));
    connect(m_histogramWidget.get(), SIGNAL(maxValueSelected(int, int)), this, SLOT(onMaxValueSelected(int, int)));
  }
  else
  {
    connect(m_histogramWidget.get(), SIGNAL(minValueSelected(double, int)), this, SLOT(onMinValueSelected(double, int)));
    connect(m_histogramWidget.get(), SIGNAL(maxValueSelected(double, int)), this, SLOT(onMaxValueSelected(double, int)));
  }

  m_histogramWidget->setEnableNavigationTools(true);

  listBands();
}

void te::qt::widgets::ContrastDialogForm::setConfigurations()
{
  m_ui->m_roiRadioButton->setChecked(true);
}

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

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

te::map::AbstractLayerPtr te::qt::widgets::ContrastDialogForm::getOutputLayer()
{
  return m_outputLayer;
}

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

te::rp::Contrast::InputParameters te::qt::widgets::ContrastDialogForm::getInputParams()
{
  //get contrast type
  int index = m_ui->m_contrastTypeComboBox->currentIndex();
  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();
  int nBands = m_ui->m_bandTableWidget->rowCount();

  te::rp::Contrast::InputParameters algoInputParams;

  if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::LinearContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);
        QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(i, 2);

        if (item)
        {
          QString valueMin = item->text();
          algoInputParams.m_lCMinInput.push_back(valueMin.toDouble());
        }

        if (item1)
        {
          QString valueMax = item1->text();
          algoInputParams.m_lCMaxInput.push_back(valueMax.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::HistogramEqualizationContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);

        if (item)
        {
          QString valueMax = item->text();
          algoInputParams.m_hECMaxInput.push_back(valueMax.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::MeanAndStdContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);
        QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(i, 2);

        if (item)
        {
          QString valueMean = item->text();
          algoInputParams.m_sMASCMeanInput.push_back(valueMean.toDouble());
        }

        if (item1)
        {
          QString valueStdDev = item1->text();
          algoInputParams.m_sMASCStdInput.push_back(valueStdDev.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::SquareContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::SquareContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);
        QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(i, 2);

        if (item)
        {
          QString valueMin = item->text();
          algoInputParams.m_squareCMinInput.push_back(valueMin.toDouble());
        }

        if (item1)
        {
          QString valueMax = item1->text();
          algoInputParams.m_squareCMaxInput.push_back(valueMax.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::SquareRootContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);
        QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(i, 2);

        if (item)
        {
          QString valueMin = item->text();
          algoInputParams.m_squareRootCMinInput.push_back(valueMin.toDouble());
        }

        if (item1)
        {
          QString valueMax = item1->text();
          algoInputParams.m_squareRootCMaxInput.push_back(valueMax.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::LogContrastT;

    for(int i = 0; i < nBands; ++i)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

      if(bandCheckBox->isChecked())
      {
        QTableWidgetItem* item = m_ui->m_bandTableWidget->item(i, 1);

        if (item)
        {
          QString valueMin = item->text();
          algoInputParams.m_logCMinInput.push_back(valueMin.toDouble());
        }

        QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(i, 2);

        if (item1)
        {
          QString valueMax = item1->text();
          algoInputParams.m_logCMaxInput.push_back(valueMax.toDouble());
        }
      }
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::DecorrelationEnhancementT)
  {
    algoInputParams.m_type = te::rp::Contrast::InputParameters::DecorrelationEnhancementT;
  }

  QVector<unsigned int> bandsSelected;

  for(int i = 0; i < nBands; ++i)
  {
    QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

    if(bandCheckBox->isChecked())
      bandsSelected.push_back(i);
  }

  if(!getChannelSelection()->getGrayChannel())
  {
    QString bRed = QString::fromStdString(getChannelSelection()->getRedChannel()->getSourceChannelName());

    QString bGreen = QString::fromStdString(getChannelSelection()->getGreenChannel()->getSourceChannelName());

    QString bBlue = QString::fromStdString(getChannelSelection()->getBlueChannel()->getSourceChannelName());

    algoInputParams.m_inRasterBands.clear();

    if(bandsSelected.contains(bRed.toInt()))
       algoInputParams.m_inRasterBands.push_back(bRed.toInt());

    if(bandsSelected.contains(bGreen.toInt()))
       algoInputParams.m_inRasterBands.push_back(bGreen.toInt());

    if(bandsSelected.contains(bBlue.toInt()))
       algoInputParams.m_inRasterBands.push_back(bBlue.toInt());
  }
  else
    algoInputParams.m_inRasterBands = bandsSelected.toStdVector();

  return algoInputParams;
}

void te::qt::widgets::ContrastDialogForm::onAllImageRadioButtonToggled(bool isChecked)
{
  if(isChecked)
  {
    te::qt::widgets::ScopedCursor cursor(Qt::WaitCursor);

    if(!m_mapDisplay->getExtent().isValid())
      return;

    if(m_layer)
    {
      te::gm::Envelope* env = new te::gm::Envelope(m_layer->getExtent());

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

      m_raster.reset(raster->trim(env, info));

      m_histogramWidget->setInputRaster(m_raster.get());

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

      delete env;
    }
  }
}

void te::qt::widgets::ContrastDialogForm::fillContrastTypes()
{
  m_ui->m_contrastTypeComboBox->clear();

  m_ui->m_contrastTypeComboBox->addItem(tr("Linear"), te::rp::Contrast::InputParameters::LinearContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Histogram Equalization"), te::rp::Contrast::InputParameters::HistogramEqualizationContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Square Constrast"), te::rp::Contrast::InputParameters::SquareContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Square Root Constrast"), te::rp::Contrast::InputParameters::SquareRootContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Log Constrast"), te::rp::Contrast::InputParameters::LogContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Mean and Standard Deviation"), te::rp::Contrast::InputParameters::MeanAndStdContrastT);
  m_ui->m_contrastTypeComboBox->addItem(tr("Decorrelation Enhancement"), te::rp::Contrast::InputParameters::DecorrelationEnhancementT);
}

void te::qt::widgets::ContrastDialogForm::listBands()
{
  assert(m_layer.get());

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

    if(inputRst.get())
    {
      m_ui->m_bandTableWidget->setRowCount((int)inputRst->getNumberOfBands());

      for (std::size_t b = 0; b < inputRst->getNumberOfBands(); ++b)
      {
        QString bandName(tr("Band "));
        bandName.append(QString::number(b));

        QCheckBox* bandCheckBox = new QCheckBox(bandName, this);
        bandCheckBox->setChecked(true);

        connect(bandCheckBox, SIGNAL(stateChanged(int)), this, SLOT(onBandChecked()));

        m_ui->m_bandTableWidget->setCellWidget(static_cast<int>(b), 0, bandCheckBox);
      }
    }
  }

  m_ui->m_bandTableWidget->resizeColumnsToContents();

  m_ui->m_bandTableWidget->selectRow(0);

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

  onContrastTypeComboBoxActivated(m_ui->m_contrastTypeComboBox->currentIndex());
}

void te::qt::widgets::ContrastDialogForm::applyPreview()
{
  if (!m_raster)
    return;

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

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

  //set contrast parameters
  te::rp::Contrast::InputParameters algoInputParams = getInputParams();

  algoInputParams.m_inRasterPtr = m_raster.get();

  double vmin = std::numeric_limits<double>::max();
  double vmax = std::numeric_limits<double>::min();

  vmin = std::min(vmin, m_minValue[0]);
  vmax = std::max(vmax, m_maxValue[0]);

  double range = vmax - vmin;
  unsigned int nbits = (unsigned int)(std::ceil(log(range) / log(2.)));
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  algoInputParams.m_outRangeMin = 0;
  algoInputParams.m_outRangeMax = maxValue;

  te::rp::Contrast::OutputParameters algoOutputParams;

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

  algoOutputParams.m_createdOutRasterDSType = "MEM";
  algoOutputParams.m_createdOutRasterInfo = rinfo;

  //run contrast
  te::rp::Contrast algorithmInstance;

  try
  {
    if (algorithmInstance.initialize(algoInputParams))
    {
      if (algorithmInstance.execute(algoOutputParams))
      {
        te::dt::AbstractData* abs = algoOutputParams.m_outRasterPtr->clone();

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

        m_histogramWidget->setOutputRaster(algoOutputParams.m_createdOutRasterPtr.release());

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

        drawHistogram();
      }
    }
  }
  catch (...)
  {
    QMessageBox::warning(this, tr("Warning"), tr("Constrast error."));

    QApplication::restoreOverrideCursor();
  }
}

void te::qt::widgets::ContrastDialogForm::getRasterFromROI()
{
  if (m_geom->getGeomTypeId() == te::gm::PolygonType)
  {
    te::qt::widgets::ScopedCursor cursor(Qt::WaitCursor);

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

    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_raster.reset(raster->trim(env, info));

    m_histogramWidget->setInputRaster(m_raster.get());

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

    delete env;
  }
}

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

  if(m_ui->m_roiRadioButton->isChecked())
  {
    if(!m_geom.get() || !m_geom->isValid())
    {
      QMessageBox::warning(this, tr("Contrast"), tr("The region of interest informed is invalid."));
      return false;
    }
  }

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

  //run contrast
  te::rp::Contrast algorithmInstance;

  te::rp::Contrast::InputParameters algoInputParams = getInputParams();
  algoInputParams.m_inRasterPtr = inputRst.get();
  algoInputParams.m_enableProgress = true;

  double vmin = std::numeric_limits<double>::max();
  double vmax = std::numeric_limits<double>::min();

  vmin = std::min(vmin, m_minValue[0]);
  vmax = std::max(vmax, m_maxValue[0]);

  double range = vmax - vmin;
  unsigned int nbits = (unsigned int)(std::ceil(log(range) / log(2.)));
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  algoInputParams.m_outRangeMin = 0;
  algoInputParams.m_outRangeMax = maxValue;

  te::rp::Contrast::OutputParameters algoOutputParams;
  algoOutputParams.m_createdOutRasterDSType = m_outputWidget->getType();
  algoOutputParams.m_createdOutRasterInfo = m_outputWidget->getInfo();
  algoOutputParams.m_outRasterBands = algoInputParams.m_inRasterBands;

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

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

  try
  {
    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("Contrast"), tr("Contrast enhencement ended sucessfully"));
      }
      else
      {
        QMessageBox::critical(this, tr("Contrast"), tr("Contrast enhencement execution error.") +
          (" " + algorithmInstance.getErrorMessage()).c_str());

        QApplication::restoreOverrideCursor();

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

      QApplication::restoreOverrideCursor();

      return false;
    }
  }
  catch (const std::exception& e)
  {
    QMessageBox::warning(this, tr("Contrast"), e.what());

    QApplication::restoreOverrideCursor();

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

    QApplication::restoreOverrideCursor();

    return false;
  }

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

  emit addLayer(m_outputLayer);

  return true;
}

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

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

te::se::ChannelSelection* te::qt::widgets::ContrastDialogForm::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::ContrastDialogForm::closeEvent(QCloseEvent* e)
{
  clearCanvas();

  emit closeTool();
}

void te::qt::widgets::ContrastDialogForm::resetWindow(te::map::AbstractLayerPtr layer)
{
  std::unique_ptr<te::da::DataSetType> dsType = layer->getSchema();
  //Checking if the layer contains a raster property
  if (!dsType->hasRaster())
  {
    QMessageBox::warning(this, tr("Warning"), tr("There is no selected raster layer."));

    m_ui->m_typeGroupBox->setEnabled(false);
    m_ui->m_bandsGroupBox->setEnabled(false);
    m_ui->m_histogramGroupBox->setEnabled(false);
    m_ui->m_histWidget->setEnabled(false);
    m_ui->m_histAreaGroupBox->setEnabled(false);
    m_ui->m_outputWidget->setEnabled(false);

    m_histogramWidget->clear();

    m_ui->m_bandTableWidget->setRowCount(0);

    m_layer = nullptr;

    return;
  }

  te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());

  if (rasterProp->getBandProperties().empty())
  {
    QMessageBox::warning(this, tr("Warning"), tr("Layers without Band information!"));

    m_ui->m_typeGroupBox->setEnabled(false);
    m_ui->m_bandsGroupBox->setEnabled(false);
    m_ui->m_histogramGroupBox->setEnabled(false);
    m_ui->m_histWidget->setEnabled(false);
    m_ui->m_histAreaGroupBox->setEnabled(false);
    m_ui->m_outputWidget->setEnabled(false);

    m_histogramWidget->clear();

    m_ui->m_bandTableWidget->setRowCount(0);

    m_layer = 0;

    return;
  }

  if (rasterProp->getBandProperties()[0]->m_colorInterp == te::rst::PaletteIdxCInt)
  {
    QMessageBox::warning(this, tr("Warning"), tr("Layers with raster palette are not able to apply contrast!"));
    
    m_ui->m_typeGroupBox->setEnabled(false);
    m_ui->m_bandsGroupBox->setEnabled(false);
    m_ui->m_histogramGroupBox->setEnabled(false);
    m_ui->m_histWidget->setEnabled(false);
    m_ui->m_histAreaGroupBox->setEnabled(false);
    m_ui->m_outputWidget->setEnabled(false);

    m_histogramWidget->clear();

    m_ui->m_bandTableWidget->setRowCount(0);

    m_layer = nullptr;

    return;
  }

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

  m_ui->m_typeGroupBox->setEnabled(true);
  m_ui->m_bandsGroupBox->setEnabled(true);
  m_ui->m_histogramGroupBox->setEnabled(true);
  m_ui->m_histWidget->setEnabled(true);
  m_ui->m_histAreaGroupBox->setEnabled(true);
  m_ui->m_outputWidget->setEnabled(true);

  clearCanvas();

  m_histogramWidget->clear();

  m_ui->m_bandTableWidget->setRowCount(0);

  m_ui->m_roiRadioButton->setChecked(true);

  set(layer);

  std::list<te::map::AbstractLayerPtr> layerList;
  layerList.push_back(layer);

  te::gm::Envelope displayExtent = te::map::GetExtent(layerList, m_mapDisplay->getSRID(), true);

  m_mapDisplay->setExtent(displayExtent, false);

  m_mapDisplay->setLayerList(layerList);

  m_mapDisplay->refresh(true);
}

void te::qt::widgets::ContrastDialogForm::drawPreview(te::rst::Raster* raster)
{
  te::qt::widgets::ScopedCursor cursor(Qt::WaitCursor);

  m_ui->m_bandTableWidget->setEnabled(false);

  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));
  canvasInstance->setPolygonFillColor(te::color::RGBAColor(100, 177, 216, 0));

  // 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_ui->m_roiRadioButton->isChecked())
  {
    if (!m_geom.get() || !m_geom->isValid())
      return;

    if(m_geom->getSRID() != m_mapDisplay->getSRID())
      m_geom->transform(m_mapDisplay->getSRID());

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

  m_ui->m_bandTableWidget->setEnabled(true);

  m_mapDisplay->repaint();

  delete canvasInstance;

  delete style;
}

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

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

  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());
  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));

  if(m_geom->getSRID() != m_mapDisplay->getSRID())
    m_geom->transform(m_mapDisplay->getSRID());

  canvasInstance.draw(m_geom.get());

  m_mapDisplay->repaint();
}

void te::qt::widgets::ContrastDialogForm::setDefaultValues(int contrastType)
{
  int row = m_ui->m_bandTableWidget->currentRow();

  if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
     contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    bool reset = true;

    if(m_ui->m_bandTableWidget->horizontalHeaderItem(2) && m_ui->m_bandTableWidget->horizontalHeaderItem(2)->text() == tr("Minimum") &&
       m_ui->m_bandTableWidget->horizontalHeaderItem(3) && m_ui->m_bandTableWidget->horizontalHeaderItem(3)->text() == tr("Maximum"))
       reset = false;

    if(reset)
    {
      QStringList list;
      list.append(tr("Band"));
      list.append(tr("Minimum"));
      list.append(tr("Maximum"));

      m_ui->m_bandTableWidget->setColumnCount(3);
      m_ui->m_bandTableWidget->setHorizontalHeaderLabels(list);

      int nBands = m_ui->m_bandTableWidget->rowCount();

      for(int i = 0; i < nBands; ++i)
      {
        QTableWidgetItem* itemMin = new QTableWidgetItem(te::common::Convert2String(m_minValue[i], 2).c_str());
        itemMin->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
        m_ui->m_bandTableWidget->setItem(i, 1, itemMin);

        QTableWidgetItem* itemMax = new QTableWidgetItem(te::common::Convert2String(m_maxValue[i], 2).c_str());
        itemMax->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
        m_ui->m_bandTableWidget->setItem(i, 2, itemMax);
      }
    }

    m_histogramWidget->setMinimumValueEnabled(true);
    m_histogramWidget->setMaximumValueEnabled(true);

    m_histogramWidget->updateMinimumValueLabel(tr("Minimum"));
    m_histogramWidget->updateMaximumValueLabel(tr("Maximum"));

    m_histogramWidget->updateMinimumValueLine(m_minValue[row], false);
    m_histogramWidget->updateMaximumValueLine(m_maxValue[row], false);

    m_ui->m_tipLabel->setText(tr("Use left button to set minimum value and right button to define maximum value over the histogram."));
  }
  else if(contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT)
  {
    QStringList list;
    list.append(tr("Band"));
    list.append(tr("Maximum"));

    m_ui->m_bandTableWidget->setColumnCount(2);
    m_ui->m_bandTableWidget->setHorizontalHeaderLabels(list);

    std::unique_ptr<te::rst::Raster> raster(te::map::GetRaster(m_layer.get()));
    int nBands = m_ui->m_bandTableWidget->rowCount();
    double currentRowMaxValue = 0;

    for(int i = 0; i < nBands; ++i)
    {
      const int bandDataType = raster->getBand( i )->getProperty()->m_type;
      const bool isRealValuesBand = ( bandDataType == te::dt::FLOAT_TYPE ) ||
        ( bandDataType == te::dt::DOUBLE_TYPE );
      double bandMaxValue = isRealValuesBand ? 255.0 : m_maxValue[i];

      QTableWidgetItem* itemMax = new QTableWidgetItem(te::common::Convert2String(bandMaxValue, 2).c_str());
      itemMax->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
      m_ui->m_bandTableWidget->setItem(i, 1, itemMax);

      if( i == row )
      {
        currentRowMaxValue = bandMaxValue;
      }
    }

    m_histogramWidget->setMinimumValueEnabled(true);
    m_histogramWidget->setMaximumValueEnabled(false);

    m_histogramWidget->updateMinimumValueLabel(tr("Maximum"));

    m_histogramWidget->updateMinimumValueLine(currentRowMaxValue, false);

    m_ui->m_tipLabel->setText(tr("Use left button to set maximum value over the histogram."));
  }
  else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    QStringList list;
    list.append(tr("Band"));
    list.append(tr("Mean"));
    list.append(tr("Std Dev"));

    m_ui->m_bandTableWidget->setColumnCount(3);
    m_ui->m_bandTableWidget->setHorizontalHeaderLabels(list);

    int nBands = m_ui->m_bandTableWidget->rowCount();

    for(int i = 0; i < nBands; ++i)
    {
      QTableWidgetItem* itemMean = new QTableWidgetItem("127");
      itemMean->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
      m_ui->m_bandTableWidget->setItem(i, 1, itemMean);

      QTableWidgetItem* itemStdDev = new QTableWidgetItem("50");
      itemStdDev->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
      m_ui->m_bandTableWidget->setItem(i, 2, itemStdDev);
    }

    m_histogramWidget->setMinimumValueEnabled(true);
    m_histogramWidget->setMaximumValueEnabled(true);

    m_histogramWidget->updateMinimumValueLabel(tr("Mean"));
    m_histogramWidget->updateMaximumValueLabel(tr("Std Dev"));

    m_histogramWidget->updateMinimumValueLine(127, false);
    m_histogramWidget->updateMaximumValueLine(50, false);

    m_ui->m_tipLabel->setText(tr("Use left button to set Mean value and right button to define Std Dev value over the histogram."));
  }
  else if(contrastType == te::rp::Contrast::InputParameters::DecorrelationEnhancementT)
  {
    QStringList list;
    list.append(tr("Band"));

    m_ui->m_bandTableWidget->setColumnCount(1);
    m_ui->m_bandTableWidget->setHorizontalHeaderLabels(list);

    m_histogramWidget->setMinimumValueEnabled(false);
    m_histogramWidget->setMaximumValueEnabled(false);

    m_ui->m_tipLabel->setText(tr(""));
  }

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

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

void te::qt::widgets::ContrastDialogForm::onContrastTypeComboBoxActivated(int index)
{
  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  setDefaultValues(contrastType);
}

void te::qt::widgets::ContrastDialogForm::onCellClicked(int row, int /*column*/)
{
  QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(row, 0);

  if(bandCheckBox->isChecked())
    drawHistogram();
}

void te::qt::widgets::ContrastDialogForm::onCellDoubleClicked(int row, int column)
{
  if (column == 0)
    return;

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

void te::qt::widgets::ContrastDialogForm::onCellChanged(int row, int column)
{
  bool isNumeric;

  m_ui->m_bandTableWidget->item(row, column)->text().toDouble(&isNumeric);

  if(!isNumeric)
  {
    m_ui->m_bandTableWidget->item(row, column)->setText(m_lastText.c_str());
    return;
  }

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

    int index = m_ui->m_contrastTypeComboBox->currentIndex();

    int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

    m_updatePreview = false;

    if(column == 1)
    {
      if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
         contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
         contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
         contrastType == te::rp::Contrast::InputParameters::LogContrastT)
      {
        if(raster->getBand(0)->getProperty()->getType() == te::dt::UCHAR_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT16_TYPE ||
           raster->getBand(0)->getProperty()->getType() == te::dt::UINT32_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT64_TYPE)
        {
          int value = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();
          int maxValue = m_ui->m_bandTableWidget->item(row, 2)->text().toDouble();

          if(value > maxValue)
          {
            m_ui->m_bandTableWidget->item(row, column)->setText(m_lastText.c_str());
            return;
          }

          m_histogramWidget->updateMinimumValueLine(value, true);
        }
        else
        {
          double value = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();
          double maxValue = m_ui->m_bandTableWidget->item(row, 2)->text().toDouble();

          if(value > maxValue)
          {
            m_ui->m_bandTableWidget->item(row, column)->setText(m_lastText.c_str());
            return;
          }

          m_histogramWidget->updateMinimumValueLine(value, true);
        }
      }
      else if(contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT ||
              contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
      {
        if(raster->getBand(0)->getProperty()->getType() == te::dt::UCHAR_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT16_TYPE ||
           raster->getBand(0)->getProperty()->getType() == te::dt::UINT32_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT64_TYPE)
        {
           int minValue = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();

           m_histogramWidget->updateMinimumValueLine(minValue, true);
        }
        else
        {
          double minValue = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();

          m_histogramWidget->updateMinimumValueLine(minValue, true);
        }
      }
    }
    else if(column == 2)
    {
      if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
         contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
         contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
         contrastType == te::rp::Contrast::InputParameters::LogContrastT)
      {
        if(raster->getBand(0)->getProperty()->getType() == te::dt::UCHAR_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT16_TYPE ||
           raster->getBand(0)->getProperty()->getType() == te::dt::UINT32_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT64_TYPE)
        {
          int value = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();
          int minValue = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

          if(value < minValue)
          {
            m_ui->m_bandTableWidget->item(row, column)->setText(m_lastText.c_str());
            return;
          }

          m_histogramWidget->updateMaximumValueLine(value, true);
        }
        else
        {
          double value = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();
          double minValue = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

          if(value < minValue)
          {
            m_ui->m_bandTableWidget->item(row, column)->setText(m_lastText.c_str());
            return;
          }

          m_histogramWidget->updateMaximumValueLine(value, true);
        }
      }
      else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
      {
        if(raster->getBand(0)->getProperty()->getType() == te::dt::UCHAR_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT16_TYPE ||
           raster->getBand(0)->getProperty()->getType() == te::dt::UINT32_TYPE || raster->getBand(0)->getProperty()->getType() == te::dt::UINT64_TYPE)
        {
           int maxValue = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();

           m_histogramWidget->updateMaximumValueLine(maxValue, true);
        }
        else
        {
          double maxValue = m_ui->m_bandTableWidget->item(row, column)->text().toDouble();

          m_histogramWidget->updateMaximumValueLine(maxValue, true);
        }
      }
    }

    applyPreview();
  }
}

void te::qt::widgets::ContrastDialogForm::onMinValueSelected(int value,
                                                             int /*band*/)
{
  if (!m_layer || !m_raster)
    return;

  m_updatePreview = true;

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

  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
     contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    int max = m_ui->m_bandTableWidget->item(row, 2)->text().toDouble();

    if(value > max)
      return;

    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else if(contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT)
  {
    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else
  {
    return;
  }
}

void te::qt::widgets::ContrastDialogForm::onMinValueSelected(double value,
                                                             int /*band*/)
{
  if (!m_layer || !m_raster)
    return;

  m_updatePreview = true;

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

  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  if (contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
    contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
    contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
    contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    double max = m_ui->m_bandTableWidget->item(row, 2)->text().toDouble();

    if(value > max)
      return;

    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else if (contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT)
  {
    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else if (contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    m_ui->m_bandTableWidget->item(row, 1)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 1);

    m_histogramWidget->updateMinimumValueLine(value, true);
  }
  else
  {
    return;
  }
}

void te::qt::widgets::ContrastDialogForm::onMaxValueSelected(int value,
                                                             int /*band*/)
{
  if (!m_layer || !m_raster)
    return;

  m_updatePreview = true;

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

  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
     contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    int min = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

    if(value < min)
      return;

    m_ui->m_bandTableWidget->item(row, 2)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 2);

    m_histogramWidget->updateMaximumValueLine(value, true);
  }
  else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    if (!m_ui->m_bandTableWidget->item(row, 1)->text().isEmpty())
    {
      double mean = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

      double stdDev = std::abs(mean - (double)value); 

      m_ui->m_bandTableWidget->item(row, 2)->setText(QString::number(stdDev));
      m_ui->m_bandTableWidget->setCurrentCell(row, 2);

      m_histogramWidget->updateMaximumValueLine(value, true);
    }
  }
  else
  {
    return;
  }
}

void te::qt::widgets::ContrastDialogForm::onMaxValueSelected(double value,
                                                             int /*band*/)
{
  if (!m_layer || !m_raster)
    return;

  m_updatePreview = true;

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

  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  if (contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
    contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
    contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
    contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    double min = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

    if(value < min)
      return;

    m_ui->m_bandTableWidget->item(row, 2)->setText(QString::number(value));
    m_ui->m_bandTableWidget->setCurrentCell(row, 2);

    m_histogramWidget->updateMaximumValueLine(value, true);
  }
  else if (contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    if (!m_ui->m_bandTableWidget->item(row, 1)->text().isEmpty())
    {
      double mean = m_ui->m_bandTableWidget->item(row, 1)->text().toDouble();

      double stdDev = std::abs(mean - value);

      m_ui->m_bandTableWidget->item(row, 2)->setText(QString::number(stdDev));
      m_ui->m_bandTableWidget->setCurrentCell(row, 2);

      m_histogramWidget->updateMaximumValueLine(value, true);
    }
  }
  else
  {
    return;
  }
}

void te::qt::widgets::ContrastDialogForm::onOkPushButtonClicked()
{
  //check output parameters
  if (m_outputWidget->getOutputRaster().empty())
  {
    QMessageBox::information(this, tr("Contrast"), tr("Output image is not defined."));
    return;
  }

  if(!m_bandChecked)
  {
    QMessageBox::information(this, tr("Contrast"), tr("Invalid number of bands."));
    return;
  }

  if (!execute())
  {
    QMessageBox::information(this, tr("Contrast"), tr("Error to apply contrast."));
    return;
  }

  clearCanvas();

  emit closeTool();
}

void te::qt::widgets::ContrastDialogForm::onPreviewCheckBoxToggled(bool isChecked)
{
  if (isChecked)
  {
    applyPreview();
  }
  else
  {
    if (m_raster)
      drawPreview(m_raster.get());
  }
}

void te::qt::widgets::ContrastDialogForm::onRoiRadioButtonToggled(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::ContrastDialogForm::onVisibleAreaRadioButtonToggled(bool isChecked)
{
  if(isChecked)
  {
    if(!m_mapDisplay->getExtent().isValid())
      return;

    m_ui->m_navigatorWidget->setEnabled(false);

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

    te::gm::Envelope reprojectedBBOX(m_mapDisplay->getExtent());
    reprojectedBBOX.transform(m_mapDisplay->getSRID(), m_layer->getSRID());

    if (!reprojectedBBOX.intersects(m_layer->getExtent()))
    {
      QMessageBox::warning(this, tr("Warning"), tr("Visible area doesn't intersect with the layer."));
      return;
    }

    te::gm::Envelope ibbox = reprojectedBBOX.intersection(m_layer->getExtent());

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

    getRasterFromROI();

    drawGeom();
  }
}

void te::qt::widgets::ContrastDialogForm::drawHistogram()
{
  int bandIdx = -1;

  for(int i = 0; i <= m_ui->m_bandTableWidget->currentRow(); ++i)
  {
    QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

    if(bandCheckBox->isChecked())
      ++bandIdx;
  }

  if(bandIdx == -1)
    return;

  if (!m_raster)
    return;

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

  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  int contrastType = m_ui->m_contrastTypeComboBox->itemData(index).toInt();

  if(contrastType == te::rp::Contrast::InputParameters::LinearContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareContrastT ||
     contrastType == te::rp::Contrast::InputParameters::SquareRootContrastT ||
     contrastType == te::rp::Contrast::InputParameters::LogContrastT)
  {
    QTableWidgetItem* item = m_ui->m_bandTableWidget->item(bandIdx, 1);
    QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(bandIdx, 2);

    if (item && item1)
    {
      double min = item->text().toDouble();
      double max = item1->text().toDouble();

      m_histogramWidget->updateMinimumValueLine(min, false);
      m_histogramWidget->updateMaximumValueLine(max, false);
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::HistogramEqualizationContrastT)
  {
    QTableWidgetItem* item = m_ui->m_bandTableWidget->item(bandIdx, 1);
    if (item)
    {
      double min = item->text().toDouble();

      m_histogramWidget->updateMinimumValueLine(min, false);
    }
  }
  else if(contrastType == te::rp::Contrast::InputParameters::MeanAndStdContrastT)
  {
    QTableWidgetItem* item = m_ui->m_bandTableWidget->item(bandIdx, 1);
    QTableWidgetItem* item1 = m_ui->m_bandTableWidget->item(bandIdx, 2);

    if (item && item1)
    {
      double min = item->text().toDouble();
      double max = item1->text().toDouble();

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

  m_histogramWidget->drawHistogram(bandIdx);
}

void te::qt::widgets::ContrastDialogForm::onApplicationTriggered(te::qt::af::evt::Event* e)
{
  if (e->m_id == te::qt::af::evt::LAYER_SELECTED)
  {
    te::qt::af::evt::LayerSelected* evt = static_cast<te::qt::af::evt::LayerSelected*>(e);

    te::map::AbstractLayerPtr layer = evt->m_layer;
    assert(layer);

    if (layer == nullptr)
    {
      return;
    }

    resetWindow(layer);
  }
}

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

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

void te::qt::widgets::ContrastDialogForm::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_geom.reset(te::gm::GetGeomFromEnvelope(&env, m_layer->getSRID()));

  getRasterFromROI();

  drawGeom();
}

void te::qt::widgets::ContrastDialogForm::onBandChecked()
{
  int band = -1;

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

  for(unsigned int i = 0; i < inputRst->getNumberOfBands(); ++i)
  {
    QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);

    if(bandCheckBox->isChecked())
      ++band;
  }

  if(band == -1)
  {
    m_bandChecked = false;
    return;
  }

  m_bandChecked = true;

  applyPreview();
}

void te::qt::widgets::ContrastDialogForm::onResetValuesToolButtonClicked()
{
  int index = m_ui->m_contrastTypeComboBox->currentIndex();

  setDefaultValues(m_ui->m_contrastTypeComboBox->itemData(index).toInt());
}