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

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

// TerraLib
#include "../../../common/progress/ProgressManager.h"
#include "../../../common/StringUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/Utils.h"
#include "../../../raster/Utils.h"
#include "../../../rp/Functions.h"
#include "../../../se/ChannelSelection.h"
#include "../../../se/CoverageStyle.h"
#include "../../../se/RasterSymbolizer.h"
#include "../../../raster/RasterSummaryManager.h"
#include "../../../se/Rule.h"
#include "../../../se/SelectedChannel.h"
#include "../../../se/Utils.h"
#include "../../widgets/tools/ExtentAcquire.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "../progress/ProgressViewerDialog.h"
#include "../layer/search/LayerSearchDialog.h"
#include "../layer/search/LayerSearchWidget.h"
#include "ColorTransformDialog.h"
#include "Utils.h"
#include "ui_ColorTransformDialogForm.h"

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

// stl
#include <memory>

Q_DECLARE_METATYPE(te::map::AbstractLayerPtr)

te::qt::widgets::ColorTransformDialog::ColorTransformDialog(QWidget* parent)
  : QDialog(parent),
  m_ui(new Ui::ColorTransformDialogForm)
{
// setup controls
  m_ui->setupUi(this);

  m_geom = nullptr;
  m_mapDisplay = nullptr;

  m_ui->m_rgb2ihsNbitsComboBox->setEnabled(false);
  m_ui->m_rgb2hlsNbitsComboBox->setEnabled(false);

  fillColorTransformTypes();

  //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_colorTransformTypeComboBox, SIGNAL(activated(int)), this, SLOT(colorTransformTypeComboBoxActivated(int)));

  connect(m_ui->m_rgbRComboBox, SIGNAL(activated(int)), this, SLOT(rgbRComboBoxActivated(int)));
  connect(m_ui->m_rgbGComboBox, SIGNAL(activated(int)), this, SLOT(rgbGComboBoxActivated(int)));
  connect(m_ui->m_rgbBComboBox, SIGNAL(activated(int)), this, SLOT(rgbBComboBoxActivated(int)));

  connect(m_ui->m_ihsIComboBox, SIGNAL(activated(int)), this, SLOT(ihsIComboBoxActivated(int)));
  connect(m_ui->m_ihsHComboBox, SIGNAL(activated(int)), this, SLOT(ihsHComboBoxActivated(int)));
  connect(m_ui->m_ihsSComboBox, SIGNAL(activated(int)), this, SLOT(ihsSComboBoxActivated(int)));

  connect(m_ui->m_rgb2hlsRComboBox, SIGNAL(activated(int)), this, SLOT(rgb2hlsRComboBoxActivated(int)));
  connect(m_ui->m_rgb2hlsGComboBox, SIGNAL(activated(int)), this, SLOT(rgb2hlsGComboBoxActivated(int)));
  connect(m_ui->m_rgb2hlsBComboBox, SIGNAL(activated(int)), this, SLOT(rgb2hlsBComboBoxActivated(int)));

  connect(m_ui->m_hlsHComboBox, SIGNAL(activated(int)), this, SLOT(hlsHComboBoxActivated(int)));
  connect(m_ui->m_hlsLComboBox, SIGNAL(activated(int)), this, SLOT(hlsLComboBoxActivated(int)));
  connect(m_ui->m_hlsSComboBox, SIGNAL(activated(int)), this, SLOT(hlsSComboBoxActivated(int)));

  connect(m_ui->m_newROIRToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIGToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIBToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIIToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIHToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROISToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIRedToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIGreenToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIBlueToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROIHueToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROILightToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));
  connect(m_ui->m_newROISatToolButton, SIGNAL(clicked()), this, SLOT(onNewROIPushButtonClicked()));

  connect(m_ui->m_searchRLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchGLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchBLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));

  connect(m_ui->m_searchIRGBLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchHRGBLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchSRGBLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));

  connect(m_ui->m_searchRedLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchGreenLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchBlueLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));

  connect(m_ui->m_searchHueLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchSatLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));
  connect(m_ui->m_searchLightLayerToolButton, SIGNAL(clicked()), this, SLOT(onSearchLayerToolButtonClicked()));

  connect(m_ui->m_okPushButton, SIGNAL(clicked()), SLOT(onOkPushButtonClicked()));

  //set icons
  m_ui->m_newROIRToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIGToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIBToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIIToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIHToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROISToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIRedToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIGreenToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIBlueToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROIHueToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROILightToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_newROISatToolButton->setIcon(QIcon::fromTheme("edit-box"));
}

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

bool te::qt::widgets::ColorTransformDialog::isRGB2IHS()
{
  int idx = m_ui->m_colorTransformTypeComboBox->currentIndex();

  int type = m_ui->m_colorTransformTypeComboBox->itemData(idx).toInt();

  return (type == COLORTRANSFORM_RGB2IHS);
}

bool te::qt::widgets::ColorTransformDialog::isIHS2RGB()
{
  int idx = m_ui->m_colorTransformTypeComboBox->currentIndex();

  int type = m_ui->m_colorTransformTypeComboBox->itemData(idx).toInt();

  return (type == COLORTRANSFORM_IHS2RGB);
}

bool te::qt::widgets::ColorTransformDialog::isRGB2HLS()
{
  int idx = m_ui->m_colorTransformTypeComboBox->currentIndex();

  int type = m_ui->m_colorTransformTypeComboBox->itemData(idx).toInt();

  return (type == COLORTRANSFORM_RGB2HLS);
}

bool te::qt::widgets::ColorTransformDialog::isHLS2RGB()
{
  int idx = m_ui->m_colorTransformTypeComboBox->currentIndex();

  int type = m_ui->m_colorTransformTypeComboBox->itemData(idx).toInt();

  return (type == COLORTRANSFORM_HLS2RGB);
}

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

void te::qt::widgets::ColorTransformDialog::colorTransformTypeComboBoxActivated(int index)
{
  m_ui->m_stackedWidget->setCurrentIndex(index);

  if (index == 0 || index == 2)
    m_ui->m_decomposeCheckBox->setChecked(true);
  else
    m_ui->m_decomposeCheckBox->setChecked(false);

  clearCanvas();
}

void te::qt::widgets::ColorTransformDialog::rgbRComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgbRComboBox->itemData(index, Qt::UserRole);
  m_layerR = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgbRComboBox, index, m_ui->m_rgbRBandComboBox);

  std::unique_ptr<te::da::DataSetType> dsType = m_layerR->getSchema();
  te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());
  std::unique_ptr<te::da::DataSet> dsRaster = m_layerR->getData();
  std::unique_ptr<te::rst::Raster> raster = dsRaster->getRaster(rasterProp->getName());

  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(0).m_minVal;
  const std::complex<double>* cmax = rsMax->at(0).m_maxVal;
  double min = cmin->real();
  double max = cmax->real();

  for (size_t b = 1; 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;

    min = std::min(min, cmin->real());
    max = std::max(max, cmax->real());
  }

  //get data type range
  double range = max - min;
  unsigned int nbits = (unsigned int)(std::ceil(log(range) / log(2.)));

  int i = 0;
  switch (nbits)
  {
    case 10:
      i = 1;
      break;

    case 16:
      i = 2;
      break;

    case 24:
      i = 3;
      break;

    case 32:
      i = 4;
      break;

    default:
      break;
  }

  m_ui->m_rgb2ihsNbitsComboBox->setCurrentIndex(i);
}

void te::qt::widgets::ColorTransformDialog::rgbGComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgbGComboBox->itemData(index, Qt::UserRole);
  m_layerG = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgbGComboBox, index, m_ui->m_rgbGBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::rgbBComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgbBComboBox->itemData(index, Qt::UserRole);
  m_layerB = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgbBComboBox, index, m_ui->m_rgbBBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::ihsIComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_ihsIComboBox->itemData(index, Qt::UserRole);
  m_layerR = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_ihsIComboBox, index, m_ui->m_ihsIBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::ihsHComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_ihsHComboBox->itemData(index, Qt::UserRole);
  m_layerG = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_ihsHComboBox, index, m_ui->m_ihsHBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::ihsSComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_ihsSComboBox->itemData(index, Qt::UserRole);
  m_layerB = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_ihsSComboBox, index, m_ui->m_ihsSBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::rgb2hlsRComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgb2hlsRComboBox->itemData(index, Qt::UserRole);
  m_layerR = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgb2hlsRComboBox, index, m_ui->m_rgb2hlsRBandComboBox);

  std::unique_ptr<te::da::DataSetType> dsType = m_layerR->getSchema();
  te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());
  std::unique_ptr<te::da::DataSet> dsRaster = m_layerR->getData();
  std::unique_ptr<te::rst::Raster> raster = dsRaster->getRaster(rasterProp->getName());

  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(0).m_minVal;
  const std::complex<double>* cmax = rsMax->at(0).m_maxVal;
  double min = cmin->real();
  double max = cmax->real();

  for (size_t b = 1; 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();

    min = std::min(min, cmin->real());
    max = std::max(max, cmax->real());
  }

  //get data type range
  double range = max - min;
  unsigned int nbits = (unsigned int)(std::ceil(log(range) / log(2.)));

  int i = 0;
  switch (nbits)
  {
  case 10:
    i = 1;
    break;

  case 16:
    i = 2;
    break;

  case 24:
    i = 3;
    break;

  case 32:
    i = 4;
    break;

  default:
    break;
  }

  m_ui->m_rgb2hlsNbitsComboBox->setCurrentIndex(i);
}

void te::qt::widgets::ColorTransformDialog::rgb2hlsGComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgb2hlsGComboBox->itemData(index, Qt::UserRole);
  m_layerG = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgb2hlsGComboBox, index, m_ui->m_rgb2hlsGBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::rgb2hlsBComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_rgb2hlsBComboBox->itemData(index, Qt::UserRole);
  m_layerB = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_rgb2hlsBComboBox, index, m_ui->m_rgb2hlsBBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::hlsHComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_hlsHComboBox->itemData(index, Qt::UserRole);
  m_layerR = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_hlsHComboBox, index, m_ui->m_hlsHBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::hlsLComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_hlsLComboBox->itemData(index, Qt::UserRole);
  m_layerG = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_hlsLComboBox, index, m_ui->m_hlsLBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::hlsSComboBoxActivated(int index)
{
  //get layer
  QVariant varLayer = m_ui->m_hlsSComboBox->itemData(index, Qt::UserRole);
  m_layerB = varLayer.value<te::map::AbstractLayerPtr>();

  getRasterBands(m_ui->m_hlsSComboBox, index, m_ui->m_hlsSBandComboBox);
}

void te::qt::widgets::ColorTransformDialog::onNewROIPushButtonClicked()
{
  if ((m_ui->m_stackedWidget->currentIndex() == 0 && (m_ui->m_newROIRToolButton->isChecked() || m_ui->m_newROIGToolButton->isChecked() || m_ui->m_newROIBToolButton->isChecked())) ||
    (m_ui->m_stackedWidget->currentIndex() == 1 && (m_ui->m_newROIIToolButton->isChecked() || m_ui->m_newROIHToolButton->isChecked() || m_ui->m_newROISToolButton->isChecked())) ||
    (m_ui->m_stackedWidget->currentIndex() == 2 && (m_ui->m_newROIRedToolButton->isChecked() || m_ui->m_newROIGreenToolButton->isChecked() || m_ui->m_newROIBlueToolButton->isChecked())) || 
    (m_ui->m_stackedWidget->currentIndex() == 3 && (m_ui->m_newROIHueToolButton->isChecked() || m_ui->m_newROILightToolButton->isChecked() || m_ui->m_newROISatToolButton->isChecked())))
  {
    te::qt::widgets::ExtentAcquire* ea = new te::qt::widgets::ExtentAcquire(m_mapDisplay, Qt::ArrowCursor);
    m_mapDisplay->setCurrentTool(ea);

    connect(ea, SIGNAL(extentAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));
  }
  else
  {
    m_mapDisplay->setCurrentTool(nullptr);

    if (m_geom && m_geom->isValid())
      clearCanvas();
  }
}

void te::qt::widgets::ColorTransformDialog::onOkPushButtonClicked()
{
  //check input layer
  if(m_layerList.empty())
  {
    QMessageBox::information(this, tr("Color Transform"), tr("Input image is empty."));
    return;
  }

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

  if(!execute())
  {
    QMessageBox::information(this, tr("Color Transform"), tr("Error to execute the color transformation."));
    return;
  }

  accept();
}

void te::qt::widgets::ColorTransformDialog::onEnvelopeAcquired(te::gm::Envelope env)
{
  if (!env.isValid())
    return;

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

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

  te::gm::Envelope envOut = env;

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

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

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

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

  m_geom = nullptr;

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

  getRasterFromROI();

  drawGeom();
}

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

  if (m_rasterPreview)
  {
    drawPreview(m_rasterPreview);
  }
}

void te::qt::widgets::ColorTransformDialog::onSearchLayerToolButtonClicked()
{
  std::unique_ptr<te::qt::widgets::LayerSearchDialog> dlg(new te::qt::widgets::LayerSearchDialog(this));
  dlg->getWidget()->setList(m_layerList);
  dlg->getWidget()->filterOnlyByRaster();

  if(dlg->exec())
  {
    int idx = m_ui->m_colorTransformTypeComboBox->currentIndex();
    int type = m_ui->m_colorTransformTypeComboBox->itemData(idx).toInt();

    std::list<te::map::AbstractLayerPtr> layerList = dlg->getWidget()->getSelecteds();

    if(layerList.empty())
      return;

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

    m_layerR = *it;
    m_layerG = *it;
    m_layerB = *it;

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

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

      if(dst.get())
      {
        if(type == COLORTRANSFORM_RGB2IHS)
        {
          if(m_ui->m_rgbRComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgbRComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgbRComboBox->setCurrentIndex(m_ui->m_rgbRComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_rgbGComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgbGComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgbGComboBox->setCurrentIndex(m_ui->m_rgbGComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_rgbBComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgbBComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgbBComboBox->setCurrentIndex(m_ui->m_rgbBComboBox->findText(l->getTitle().c_str()));
          }
        }
        else if(type == COLORTRANSFORM_IHS2RGB)
        {
          if(m_ui->m_ihsIComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_ihsIComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_ihsIComboBox->setCurrentIndex(m_ui->m_ihsIComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_ihsHComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_ihsHComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_ihsHComboBox->setCurrentIndex(m_ui->m_ihsHComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_ihsSComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_ihsSComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_ihsSComboBox->setCurrentIndex(m_ui->m_ihsSComboBox->findText(l->getTitle().c_str()));
          }
        }
        else if(type == COLORTRANSFORM_RGB2HLS)
        {
          if(m_ui->m_rgb2hlsRComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgb2hlsRComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgb2hlsRComboBox->setCurrentIndex(m_ui->m_rgb2hlsRComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_rgb2hlsGComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgb2hlsGComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgb2hlsGComboBox->setCurrentIndex(m_ui->m_rgb2hlsGComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_rgb2hlsBComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_rgb2hlsBComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_rgb2hlsBComboBox->setCurrentIndex(m_ui->m_rgb2hlsBComboBox->findText(l->getTitle().c_str()));
          }
        }
        else
        {
          if(m_ui->m_hlsHComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_hlsHComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_hlsHComboBox->setCurrentIndex(m_ui->m_hlsHComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_hlsLComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_hlsLComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_hlsLComboBox->setCurrentIndex(m_ui->m_hlsLComboBox->findText(l->getTitle().c_str()));
          }

          if(m_ui->m_hlsSComboBox->findText(l->getTitle().c_str()) == -1)
          {
            m_ui->m_hlsSComboBox->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
            m_ui->m_hlsSComboBox->setCurrentIndex(m_ui->m_hlsSComboBox->findText(l->getTitle().c_str()));
          }
        }
      }

      ++it;
    }

    if(type == COLORTRANSFORM_RGB2IHS)
    {
      rgbRComboBoxActivated(0);
      rgbGComboBoxActivated(0);
      rgbBComboBoxActivated(0);
    }
    else if(type == COLORTRANSFORM_IHS2RGB)
    {
      ihsIComboBoxActivated(0);
      ihsHComboBoxActivated(0);
      ihsSComboBoxActivated(0);
    }
    else if(type == COLORTRANSFORM_RGB2HLS)
    {
      rgb2hlsRComboBoxActivated(0);
      rgb2hlsGComboBoxActivated(0);
      rgb2hlsBComboBoxActivated(0);
    }
    else
    {
      hlsHComboBoxActivated(0);
      hlsLComboBoxActivated(0);
      hlsSComboBoxActivated(0);
    }
  }
}

bool te::qt::widgets::ColorTransformDialog::execute()
{
  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  try
  {
    bool res = false;

    if (isRGB2IHS())
      res = executeRGB2IHS();
    else if (isIHS2RGB())
      res = executeIHS2RGB();
    if (isRGB2HLS())
      res = executeRGB2HLS();
    else if (isHLS2RGB())
      res = executeHLS2RGB();

    if (res)
    {
      //set output layer
      if (!m_ui->m_decomposeCheckBox->isChecked())
      {
        te::map::AbstractLayerPtr outputLayer = te::qt::widgets::createLayer(m_outputWidget->getType(),
          m_outputWidget->getInfo());

        te::qt::widgets::applyRasterMultiResolution(tr("Color Transform"), te::map::GetRaster(outputLayer.get()));

        emit addLayer(outputLayer);
      }
      else
      {
        for (std::size_t t = 0; t < 3; ++t)
        {
          std::map<std::string, std::string> rinfo;

          double index = (double)t + (double)1;

          rinfo["URI"] = m_outputWidget->getFilePath() + "_" + TE_TR("Band") + "_" + te::common::Convert2String(index, 0) + "." + m_outputWidget->getFileExtension();

          te::map::AbstractLayerPtr outputLayer = te::qt::widgets::createLayer(m_outputWidget->getType(), rinfo);

          te::qt::widgets::applyRasterMultiResolution(tr("Color Transform"), te::map::GetRaster(outputLayer.get()));

          emit addLayer(outputLayer);
        }
      }

      QApplication::restoreOverrideCursor();

      QMessageBox::information(this, tr("Color Transform"), tr("Color Transform ended sucessfully"));
    }
    else
    {
      QApplication::restoreOverrideCursor();

      QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());

      return false;
    }
  }
  catch (const std::exception& e)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::warning(this, tr("Color Transform"), e.what());

    return false;
  }
  catch (...)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::warning(this, tr("Color Transform"), tr("An exception has occurred!"));

    return false;
  }

  return true;
}

bool te::qt::widgets::ColorTransformDialog::executeRGB2IHS()
{
  te::rst::Raster* inputRRaster = getRRaster();
  te::rst::Raster* inputGRaster = getGRaster();
  te::rst::Raster* inputBRaster = getBRaster();
  te::rst::Raster* outputRaster;
  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;
  std::vector< std::map<std::string, std::string> > outputRastersInfos;

  if (!m_ui->m_decomposeCheckBox->isChecked())
    outputRaster = buildOutputRaster();
  else
  {
    outputRaster = buildMemRaster();

    for (std::size_t t = 0; t < 3; ++t)
    {
      std::map<std::string, std::string> rinfo;

      double index = (double)t + (double)1;
      rinfo["URI"] = m_outputWidget->getFilePath() + "_" + TE_TR("Band") + "_" + te::common::Convert2String(index, 0) + "." + m_outputWidget->getFileExtension();
      outputRastersInfos.push_back(rinfo);
    }
  }

  if (!outputRaster)
    return false;

  unsigned int rBand = m_ui->m_rgbRBandComboBox->currentText().toUInt();
  unsigned int gBand = m_ui->m_rgbGBandComboBox->currentText().toUInt();
  unsigned int bBand = m_ui->m_rgbBBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_rgb2ihsNbitsComboBox->currentIndex());
  double minValue = 0;
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertRGB2IHS(*inputRRaster, rBand, *inputGRaster, gBand, *inputBRaster, bBand, minValue, maxValue, *outputRaster);

  std::vector<unsigned int> rasterBands;
  rasterBands.push_back(0);
  rasterBands.push_back(1);
  rasterBands.push_back(2);

  if (m_ui->m_decomposeCheckBox->isChecked())
  {
    //get output raster info
    std::string type = m_outputWidget->getType();

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  delete inputRRaster;
  delete inputGRaster;
  delete inputBRaster;
  delete outputRaster;

  return res;
}

bool te::qt::widgets::ColorTransformDialog::executeIHS2RGB()
{
  te::rst::Raster* inputIRaster = getIRaster();
  te::rst::Raster* inputHRaster = getHRaster();
  te::rst::Raster* inputSRaster = getSRaster();
  te::rst::Raster* outputRaster;

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;
  std::vector< std::map<std::string, std::string> > outputRastersInfos;

  if (!m_ui->m_decomposeCheckBox->isChecked())
    outputRaster = buildOutputRaster();
  else
  {
    outputRaster = buildMemRaster();

    for (std::size_t t = 0; t < 3; ++t)
    {
      std::map<std::string, std::string> rinfo;

      double index = (double)t + (double)1;

      rinfo["URI"] = m_outputWidget->getFilePath() + "_" + TE_TR("Band") + "_" + te::common::Convert2String(index, 0) + "." + m_outputWidget->getFileExtension();
      outputRastersInfos.push_back(rinfo);
    }
  }

  if (!outputRaster)
    return false;

  unsigned int iBand = m_ui->m_ihsIBandComboBox->currentText().toUInt();
  unsigned int hBand = m_ui->m_ihsHBandComboBox->currentText().toUInt();
  unsigned int sBand = m_ui->m_ihsSBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_ihs2rgbNbitsComboBox->currentIndex());
  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertIHS2RGB(*inputIRaster, iBand, *inputHRaster, hBand, *inputSRaster, sBand, minValue, maxValue, *outputRaster);

  std::vector<unsigned int> rasterBands;
  rasterBands.push_back(0);
  rasterBands.push_back(1);
  rasterBands.push_back(2);

  if (m_ui->m_decomposeCheckBox->isChecked())
  {
    //get output raster info
    std::string type = m_outputWidget->getType();

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  delete inputIRaster;
  delete inputHRaster;
  delete inputSRaster;
  delete outputRaster;

  return res;
}

bool te::qt::widgets::ColorTransformDialog::executeRGB2HLS()
{
  te::rst::Raster* inputRRaster = getRRaster();
  te::rst::Raster* inputGRaster = getGRaster();
  te::rst::Raster* inputBRaster = getBRaster();
  te::rst::Raster* outputRaster;
  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;
  std::vector< std::map<std::string, std::string> > outputRastersInfos;

  if (!m_ui->m_decomposeCheckBox->isChecked())
    outputRaster = buildOutputRaster();
  else
  {
    outputRaster = buildMemRaster();

    for (std::size_t t = 0; t < 3; ++t)
    {
      std::map<std::string, std::string> rinfo;

      double index = (double)t + (double)1;
      rinfo["URI"] = m_outputWidget->getFilePath() + "_" + TE_TR("Band") + "_" + te::common::Convert2String(index, 0) + "." + m_outputWidget->getFileExtension();
      outputRastersInfos.push_back(rinfo);
    }
  }

  if (!outputRaster)
    return false;

  unsigned int rBand = m_ui->m_rgb2hlsRBandComboBox->currentText().toUInt();
  unsigned int gBand = m_ui->m_rgb2hlsGBandComboBox->currentText().toUInt();
  unsigned int bBand = m_ui->m_rgb2hlsBBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_rgb2hlsNbitsComboBox->currentIndex());
  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertRGB2HLS(*inputRRaster, rBand, *inputGRaster, gBand, *inputBRaster, bBand, minValue, maxValue, *outputRaster);

  std::vector<unsigned int> rasterBands;
  rasterBands.push_back(0);
  rasterBands.push_back(1);
  rasterBands.push_back(2);

  if (m_ui->m_decomposeCheckBox->isChecked())
  {
    //get output raster info
    std::string type = m_outputWidget->getType();

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  delete inputRRaster;
  delete inputGRaster;
  delete inputBRaster;
  delete outputRaster;

  return res;
}

bool te::qt::widgets::ColorTransformDialog::executeHLS2RGB()
{
  te::rst::Raster* inputHRaster = getHRaster();
  te::rst::Raster* inputLRaster = getLRaster();
  te::rst::Raster* inputSRaster = getSRaster();
  te::rst::Raster* outputRaster;

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;
  std::vector< std::map<std::string, std::string> > outputRastersInfos;

  if (!m_ui->m_decomposeCheckBox->isChecked())
    outputRaster = buildOutputRaster();
  else
  {
    outputRaster = buildMemRaster();

    for (std::size_t t = 0; t < 3; ++t)
    {
      std::map<std::string, std::string> rinfo;

      double index = (double)t + (double)1;

      rinfo["URI"] = m_outputWidget->getFilePath() + "_" + TE_TR("Band") + "_" + te::common::Convert2String(index, 0) + "." + m_outputWidget->getFileExtension();
      outputRastersInfos.push_back(rinfo);
    }
  }

  if (!outputRaster)
    return false;

  unsigned int hBand = m_ui->m_hlsHBandComboBox->currentText().toUInt();
  unsigned int lBand = m_ui->m_hlsLBandComboBox->currentText().toUInt();
  unsigned int sBand = m_ui->m_hlsSBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_hls2rgbNbitsComboBox->currentIndex());
  double minValue = 0;
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertHLS2RGB(*inputHRaster, hBand, *inputLRaster, lBand, *inputSRaster, sBand, minValue, maxValue, *outputRaster);

  std::vector<unsigned int> rasterBands;
  rasterBands.push_back(0);
  rasterBands.push_back(1);
  rasterBands.push_back(2);

  if (m_ui->m_decomposeCheckBox->isChecked())
  {
    //get output raster info
    std::string type = m_outputWidget->getType();

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  delete inputHRaster;
  delete inputLRaster;
  delete inputSRaster;
  delete outputRaster;

  return res;
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::buildOutputRaster()
{
  te::rst::Raster* rasterOut;

  //check output data type
  int dataType = te::dt::UNKNOWN_TYPE;

  if (isRGB2IHS() || isRGB2HLS())
    dataType = te::dt::FLOAT_TYPE;
  else if (isIHS2RGB() || isHLS2RGB())
  {
    int nbits;
    if (isIHS2RGB())
      nbits = getNBits(m_ui->m_ihs2rgbNbitsComboBox->currentIndex());
    else
      nbits = getNBits(m_ui->m_hls2rgbNbitsComboBox->currentIndex());

    dataType = te::dt::UCHAR_TYPE;

    if (nbits == 10 || nbits == 16)
      dataType = te::dt::UINT16_TYPE;
    else if (nbits == 24 || nbits == 32)
      dataType = te::dt::UINT32_TYPE;
  }

  //get output raster info
  std::string type = m_outputWidget->getType();

  std::map<std::string, std::string> info = m_outputWidget->getInfo();

  //get input raster
  te::rst::Raster* inputRaster;

  if (isRGB2IHS() || isRGB2HLS())
    inputRaster = getRRaster();
  else if (isIHS2RGB())
    inputRaster = getIRaster();
  else if (isHLS2RGB())
    inputRaster = getHRaster();
  else
    return nullptr;

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*inputRaster->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);

    if (t >= 2 || m_ui->m_decomposeCheckBox->isChecked())
      break;
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*inputRaster->getGrid());

  //build output raster
  rasterOut = te::rst::RasterFactory::make(type, grid, bands, info);

  return rasterOut;
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::buildMemRaster()
{
  te::rst::Raster* rasterOut;

  //check output data type
  int dataType = te::dt::UNKNOWN_TYPE;

  if (isRGB2IHS() || isRGB2HLS())
    dataType = te::dt::FLOAT_TYPE;
  else if (isIHS2RGB() || isHLS2RGB())
  {
    int nbits;
    if (isIHS2RGB())
      nbits = getNBits(m_ui->m_ihs2rgbNbitsComboBox->currentIndex());
    else
      nbits = getNBits(m_ui->m_hls2rgbNbitsComboBox->currentIndex());

    dataType = te::dt::UCHAR_TYPE;

    if (nbits == 10 || nbits == 16)
      dataType = te::dt::UINT16_TYPE;
    else if (nbits == 24 || nbits == 32)
      dataType = te::dt::UINT32_TYPE;
  }

  //get output raster info
  std::string type = "MEM";

  //get input raster
  te::rst::Raster* inputRaster;

  if (isRGB2IHS() || isRGB2HLS())
    inputRaster = getRRaster();
  else if (isIHS2RGB())
    inputRaster = getIRaster();
  else if (isHLS2RGB())
    inputRaster = getHRaster();
  else
    return nullptr;

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

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*inputRaster->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);

    if (t >= 2)
      break;
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*inputRaster->getGrid());

  //build output raster
  rasterOut = te::rst::RasterFactory::make(type, grid, bands, info);

  return rasterOut;
}

void te::qt::widgets::ColorTransformDialog::fillColorTransformTypes()
{
  //colorTransform types
  m_ui->m_colorTransformTypeComboBox->clear();

  m_ui->m_colorTransformTypeComboBox->addItem(tr("RGB - IHS"), COLORTRANSFORM_RGB2IHS);
  m_ui->m_colorTransformTypeComboBox->addItem(tr("IHS - RGB"), COLORTRANSFORM_IHS2RGB);
  m_ui->m_colorTransformTypeComboBox->addItem(tr("RGB - HLS"), COLORTRANSFORM_RGB2HLS);
  m_ui->m_colorTransformTypeComboBox->addItem(tr("HLS - RGB"), COLORTRANSFORM_HLS2RGB);
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getRRaster()
{
  QVariant varLayer;
  if (m_ui->m_colorTransformTypeComboBox->currentIndex() == 0)
    varLayer = m_ui->m_rgbRComboBox->itemData(m_ui->m_rgbRComboBox->currentIndex(), Qt::UserRole);
  else
    varLayer = m_ui->m_rgb2hlsRComboBox->itemData(m_ui->m_rgb2hlsRComboBox->currentIndex(), Qt::UserRole);

  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getGRaster()
{
  QVariant varLayer;
  if (m_ui->m_colorTransformTypeComboBox->currentIndex() == 0)
    varLayer = m_ui->m_rgbGComboBox->itemData(m_ui->m_rgbGComboBox->currentIndex(), Qt::UserRole);
  else
    varLayer = m_ui->m_rgb2hlsGComboBox->itemData(m_ui->m_rgb2hlsGComboBox->currentIndex(), Qt::UserRole);

  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getBRaster()
{
  QVariant varLayer;
  if (m_ui->m_colorTransformTypeComboBox->currentIndex() == 0)
    varLayer = m_ui->m_rgbBComboBox->itemData(m_ui->m_rgbBComboBox->currentIndex(), Qt::UserRole);
  else
    varLayer = m_ui->m_rgb2hlsBComboBox->itemData(m_ui->m_rgb2hlsBComboBox->currentIndex(), Qt::UserRole);

  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getIRaster()
{
  QVariant varLayer = m_ui->m_ihsIComboBox->itemData(m_ui->m_ihsIComboBox->currentIndex(), Qt::UserRole);
  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getHRaster()
{
  QVariant varLayer;
  if (m_ui->m_colorTransformTypeComboBox->currentIndex() == 1)
    varLayer = m_ui->m_ihsHComboBox->itemData(m_ui->m_ihsHComboBox->currentIndex(), Qt::UserRole);
  else
    varLayer = m_ui->m_hlsHComboBox->itemData(m_ui->m_hlsHComboBox->currentIndex(), Qt::UserRole);

  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getSRaster()
{
  QVariant varLayer;
  if (m_ui->m_colorTransformTypeComboBox->currentIndex() == 1)
    varLayer = m_ui->m_ihsSComboBox->itemData(m_ui->m_ihsSComboBox->currentIndex(), Qt::UserRole);
  else
    varLayer = m_ui->m_hlsSComboBox->itemData(m_ui->m_hlsSComboBox->currentIndex(), Qt::UserRole);

  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

te::rst::Raster* te::qt::widgets::ColorTransformDialog::getLRaster()
{
  QVariant varLayer = m_ui->m_hlsLComboBox->itemData(m_ui->m_hlsLComboBox->currentIndex(), Qt::UserRole);
  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

  return ds->getRaster(rpos).release();
}

int te::qt::widgets::ColorTransformDialog::getNBits(int index)
{
  int nbits = 8;

  switch (index)
  {
    case 1:
      nbits = 10;
      break;

    case 2:
      nbits = 16;
      break;

    case 3:
      nbits = 24;
      break;

    case 4:
      nbits = 32;
      break;

    default:
      break;
  }

  return nbits;
}

void te::qt::widgets::ColorTransformDialog::getRasterBands(QComboBox* layer, int index, QComboBox* band)
{
  //get layer
  QVariant varLayer = layer->itemData(index, Qt::UserRole);
  te::map::AbstractLayerPtr l = varLayer.value<te::map::AbstractLayerPtr>();

  //get raster
  std::unique_ptr<te::da::DataSet> ds = l->getData();
  std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
  std::unique_ptr<te::rst::Raster> rst = ds->getRaster(rpos);

  //fill band info
  if(rst.get())
  {
    band->clear();

    for(std::size_t t = 0; t < rst->getNumberOfBands(); ++t)
      band->addItem(QString::number(t));
  }
}

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

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

    // verify if is necessary convert the raster to the given srid
    bool needRemap = false;
    if ((m_mapDisplay->getSRID() != TE_UNKNOWN_SRS) && (m_layerR->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_layerR->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_layerR->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_layerR->getSchema();
    te::rst::RasterProperty* rasterProp = te::da::GetFirstRasterProperty(dsType.get());
    std::unique_ptr<te::da::DataSet> dsRasterR = m_layerR->getData();
    std::unique_ptr<te::rst::Raster> rasterR = dsRasterR->getRaster(rasterProp->getName());

    std::unique_ptr<te::da::DataSet> dsRasterG = m_layerG->getData();
    std::unique_ptr<te::rst::Raster> rasterG = dsRasterG->getRaster(rasterProp->getName());

    std::unique_ptr<te::da::DataSet> dsRasterB = m_layerB->getData();
    std::unique_ptr<te::rst::Raster> rasterB = dsRasterB->getRaster(rasterProp->getName());

    std::map<std::string, std::string> info;
    info["FORCE_MEM_DRIVER"] = "TRUE";
    //execute clipping
    m_rasterRPreview = rasterR->trim(env, info);
    m_rasterGPreview = rasterG->trim(env, info);
    m_rasterBPreview = rasterB->trim(env, info);

    applyPreview();

    QApplication::restoreOverrideCursor();
  }
}

void te::qt::widgets::ColorTransformDialog::applyPreview()
{
  if (!m_rasterRPreview || !m_rasterGPreview || !m_rasterBPreview)
    return;

    if (isRGB2IHS())
      applyPreviewRGB2IHS();
    else if (isIHS2RGB())
      applyPreviewIHS2RGB();
    else if (isRGB2HLS())
      applyPreviewRGB2HLS();
    else if (isHLS2RGB())
      applyPreviewHLS2RGB();
}

void te::qt::widgets::ColorTransformDialog::applyPreviewRGB2IHS()
{
  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  //check output data type
  int dataType = te::dt::FLOAT_TYPE;

  //get output raster info
  std::string type = "MEM";
  std::map<std::string, std::string> info;
  info["MEM_RASTER_NROWS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfRows());
  info["MEM_RASTER_NCOLS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfColumns());
  info["MEM_RASTER_DATATYPE"] = dataType;
  info["MEM_RASTER_NBANDS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfBands());

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*m_rasterRPreview->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*m_rasterRPreview->getGrid());

  //build output raster
  te::rst::Raster* outputRaster = te::rst::RasterFactory::make(type, grid, bands, info);

  if (!outputRaster)
  {
    QApplication::restoreOverrideCursor();

    return;
  }

  unsigned int rBand = m_ui->m_rgbRBandComboBox->currentText().toUInt();
  unsigned int gBand = m_ui->m_rgbGBandComboBox->currentText().toUInt();
  unsigned int bBand = m_ui->m_rgbBBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_rgb2ihsNbitsComboBox->currentIndex());
  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertRGB2IHS(*m_rasterRPreview, rBand, *m_rasterGPreview, gBand, *m_rasterBPreview, bBand, minValue, maxValue, *outputRaster);

  if (!res)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
    return;
  }

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;

  if (!m_ui->m_newROIRToolButton->isChecked() || !m_ui->m_newROIGToolButton->isChecked() || !m_ui->m_newROIBToolButton->isChecked())
  {
    std::vector< std::map<std::string, std::string> > outputRastersInfos;

    for (std::size_t t = 0; t < 3; ++t)
    {
      outputRastersInfos.push_back(info);
    }

    std::vector<unsigned int> rasterBands;
    rasterBands.push_back(0);
    rasterBands.push_back(1);
    rasterBands.push_back(2);

    //get output raster info
    std::string type = "MEM";

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  QApplication::restoreOverrideCursor();

  if (res)
  {
    te::dt::AbstractData* abs = nullptr;

    if (m_ui->m_newROIRToolButton->isChecked() && m_ui->m_newROIGToolButton->isChecked() && m_ui->m_newROIBToolButton->isChecked())
      abs = outputRaster->clone();
    else if (m_ui->m_newROIRToolButton->isChecked())
      abs = outputRastersPtrs[0]->clone();
    else if (m_ui->m_newROIGToolButton->isChecked())
      abs = outputRastersPtrs[1]->clone();
    else if (m_ui->m_newROIBToolButton->isChecked())
      abs = outputRastersPtrs[2]->clone();

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

    m_rasterPreview = rst;

    drawPreview(m_rasterPreview);
  }
  else
  {
    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
  }

  delete outputRaster;
}

void te::qt::widgets::ColorTransformDialog::applyPreviewIHS2RGB()
{
  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  //check output data type
  int dataType = te::dt::UCHAR_TYPE;

  int nbits = getNBits(m_ui->m_ihs2rgbNbitsComboBox->currentIndex());

  if (nbits == 10 || nbits == 16)
    dataType = te::dt::UINT16_TYPE;
  else if (nbits == 24 || nbits == 32)
    dataType = te::dt::UINT32_TYPE;

  //get output raster info
  std::string type = "MEM";
  std::map<std::string, std::string> info;
  info["MEM_RASTER_NROWS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfRows());
  info["MEM_RASTER_NCOLS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfColumns());
  info["MEM_RASTER_DATATYPE"] = dataType;
  info["MEM_RASTER_NBANDS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfBands());

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*m_rasterRPreview->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*m_rasterRPreview->getGrid());

  //build output raster
  te::rst::Raster* outputRaster = te::rst::RasterFactory::make(type, grid, bands, info);

  if (!outputRaster)
  {
    QApplication::restoreOverrideCursor();

    return;
  }

  unsigned int iBand = m_ui->m_ihsIBandComboBox->currentText().toUInt();
  unsigned int hBand = m_ui->m_ihsHBandComboBox->currentText().toUInt();
  unsigned int sBand = m_ui->m_ihsSBandComboBox->currentText().toUInt();

  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertIHS2RGB(*m_rasterRPreview, iBand, *m_rasterGPreview, hBand, *m_rasterBPreview, sBand, minValue, maxValue, *outputRaster);

  if (!res)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
    return;
  }

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;

  if (!m_ui->m_newROIIToolButton->isChecked() || !m_ui->m_newROIHToolButton->isChecked() || !m_ui->m_newROISToolButton->isChecked())
  {
    std::vector< std::map<std::string, std::string> > outputRastersInfos;

    for (std::size_t t = 0; t < 3; ++t)
    {
      outputRastersInfos.push_back(info);
    }

    std::vector<unsigned int> rasterBands;
    rasterBands.push_back(0);
    rasterBands.push_back(1);
    rasterBands.push_back(2);

    //get output raster info
    std::string type = "MEM";

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  QApplication::restoreOverrideCursor();

  if (res)
  {
    te::dt::AbstractData* abs = nullptr;

    if (m_ui->m_newROIIToolButton->isChecked() && m_ui->m_newROIHToolButton->isChecked() && m_ui->m_newROISToolButton->isChecked())
      abs = outputRaster->clone();
    else if (m_ui->m_newROIIToolButton->isChecked())
      abs = outputRastersPtrs[0]->clone();
    else if (m_ui->m_newROIHToolButton->isChecked())
      abs = outputRastersPtrs[1]->clone();
    else if (m_ui->m_newROISToolButton->isChecked())
      abs = outputRastersPtrs[2]->clone();

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

    m_rasterPreview = rst;

    drawPreview(m_rasterPreview);
  }
  else
  {
    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
  }

  delete outputRaster;
}

void te::qt::widgets::ColorTransformDialog::applyPreviewRGB2HLS()
{
  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  //check output data type
  int dataType = te::dt::FLOAT_TYPE;

  //get output raster info
  std::string type = "MEM";
  std::map<std::string, std::string> info;
  info["MEM_RASTER_NROWS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfRows());
  info["MEM_RASTER_NCOLS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfColumns());
  info["MEM_RASTER_DATATYPE"] = dataType;
  info["MEM_RASTER_NBANDS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfBands());

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*m_rasterRPreview->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*m_rasterRPreview->getGrid());

  //build output raster
  te::rst::Raster* outputRaster = te::rst::RasterFactory::make(type, grid, bands, info);

  if (!outputRaster)
  {
    QApplication::restoreOverrideCursor();

    return;
  }

  unsigned int rBand = m_ui->m_rgb2hlsRBandComboBox->currentText().toUInt();
  unsigned int gBand = m_ui->m_rgb2hlsGBandComboBox->currentText().toUInt();
  unsigned int bBand = m_ui->m_rgb2hlsBBandComboBox->currentText().toUInt();

  int nbits = getNBits(m_ui->m_rgb2hlsNbitsComboBox->currentIndex());
  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertRGB2HLS(*m_rasterRPreview, rBand, *m_rasterGPreview, gBand, *m_rasterBPreview, bBand, minValue, maxValue, *outputRaster);

  if (!res)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
    return;
  }

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;

  if (!m_ui->m_newROIRedToolButton->isChecked() || !m_ui->m_newROIGreenToolButton->isChecked() || !m_ui->m_newROIBlueToolButton->isChecked())
  {
    std::vector< std::map<std::string, std::string> > outputRastersInfos;

    for (std::size_t t = 0; t < 3; ++t)
    {
      outputRastersInfos.push_back(info);
    }

    std::vector<unsigned int> rasterBands;
    rasterBands.push_back(0);
    rasterBands.push_back(1);
    rasterBands.push_back(2);

    //get output raster info
    std::string type = "MEM";

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  QApplication::restoreOverrideCursor();

  if (res)
  {
    te::dt::AbstractData* abs = nullptr;

    if (m_ui->m_newROIRedToolButton->isChecked() && m_ui->m_newROIGreenToolButton->isChecked() && m_ui->m_newROIBlueToolButton->isChecked())
      abs = outputRaster->clone();
    else if (m_ui->m_newROIRedToolButton->isChecked())
      abs = outputRastersPtrs[0]->clone();
    else if (m_ui->m_newROIGreenToolButton->isChecked())
      abs = outputRastersPtrs[1]->clone();
    else if (m_ui->m_newROIBlueToolButton->isChecked())
      abs = outputRastersPtrs[2]->clone();

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

    m_rasterPreview = rst;

    drawPreview(m_rasterPreview);
  }
  else
  {
    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
  }

  delete outputRaster;
}

void te::qt::widgets::ColorTransformDialog::applyPreviewHLS2RGB()
{
  //progress
  te::qt::widgets::ProgressViewerDialog v(this);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  //check output data type
  int dataType = te::dt::UCHAR_TYPE;

  int nbits = getNBits(m_ui->m_hls2rgbNbitsComboBox->currentIndex());

  if (nbits == 10 || nbits == 16)
    dataType = te::dt::UINT16_TYPE;
  else if (nbits == 24 || nbits == 32)
    dataType = te::dt::UINT32_TYPE;

  //get output raster info
  std::string type = "MEM";
  std::map<std::string, std::string> info;
  info["MEM_RASTER_NROWS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfRows());
  info["MEM_RASTER_NCOLS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfColumns());
  info["MEM_RASTER_DATATYPE"] = dataType;
  info["MEM_RASTER_NBANDS"] = boost::lexical_cast<std::string>(m_rasterRPreview->getNumberOfBands());

  //get input bands info
  std::vector<te::rst::BandProperty*> bands;

  for (std::size_t t = 0; t < 3; ++t)
  {
    te::rst::BandProperty* bProp = new te::rst::BandProperty(*m_rasterRPreview->getBand(0)->getProperty());

    bProp->m_type = dataType;

    bands.push_back(bProp);
  }

  //get input grid
  te::rst::Grid* grid = new te::rst::Grid(*m_rasterRPreview->getGrid());

  //build output raster
  te::rst::Raster* outputRaster = te::rst::RasterFactory::make(type, grid, bands, info);

  if (!outputRaster)
  {
    QApplication::restoreOverrideCursor();

    return;
  }

  unsigned int hBand = m_ui->m_hlsHBandComboBox->currentText().toUInt();
  unsigned int lBand = m_ui->m_hlsLBandComboBox->currentText().toUInt();
  unsigned int sBand = m_ui->m_hlsSBandComboBox->currentText().toUInt();

  double minValue = 0;

  //get data type range
  double maxValue = (double)(pow(2.0, (double)nbits)) - 1;

  bool res = te::rp::ConvertHLS2RGB(*m_rasterRPreview, hBand, *m_rasterGPreview, lBand, *m_rasterBPreview, sBand, minValue, maxValue, *outputRaster);

  if (!res)
  {
    QApplication::restoreOverrideCursor();

    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
    return;
  }

  std::vector< boost::shared_ptr< te::rst::Raster > > outputRastersPtrs;

  if (!m_ui->m_newROIHueToolButton->isChecked() || !m_ui->m_newROILightToolButton->isChecked() || !m_ui->m_newROISatToolButton->isChecked())
  {
    std::vector< std::map<std::string, std::string> > outputRastersInfos;

    for (std::size_t t = 0; t < 3; ++t)
    {
      outputRastersInfos.push_back(info);
    }

    std::vector<unsigned int> rasterBands;
    rasterBands.push_back(0);
    rasterBands.push_back(1);
    rasterBands.push_back(2);

    //get output raster info
    std::string type = "MEM";

    //decompose bands
    res = te::rp::DecomposeBands(*outputRaster, rasterBands, outputRastersInfos, type, outputRastersPtrs);
  }

  QApplication::restoreOverrideCursor();

  if (res)
  {
    te::dt::AbstractData* abs = nullptr;

    if (m_ui->m_newROIHueToolButton->isChecked() && m_ui->m_newROILightToolButton->isChecked() && m_ui->m_newROISatToolButton->isChecked())
      abs = outputRaster->clone();
    else if (m_ui->m_newROIHueToolButton->isChecked())
      abs = outputRastersPtrs[0]->clone();
    else if (m_ui->m_newROILightToolButton->isChecked())
      abs = outputRastersPtrs[1]->clone();
    else if (m_ui->m_newROISatToolButton->isChecked())
      abs = outputRastersPtrs[2]->clone();

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

    m_rasterPreview = rst;

    drawPreview(m_rasterPreview);
  }
  else
  {
    QMessageBox::critical(this, tr("Color Transform"), tr("Color Transform execution error.") + (" " + te::rp::Module::getLastLogStr()).c_str());
  }

  delete outputRaster;
}

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

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

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

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

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

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

  for(std::size_t b = 0; b < raster->getNumberOfBands(); ++b)
  {
    const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(raster, te::rst::SUMMARY_MIN, true);
    const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(raster, 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();

    raster->getBand(static_cast<unsigned long>(b))->getProperty()->m_min = min;
    raster->getBand(static_cast<unsigned long>(b))->getProperty()->m_max = max;
  }

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

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

  canvasInstance->draw(m_geom);

  m_mapDisplay->repaint();

  delete canvasInstance;
  delete style;

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::ColorTransformDialog::drawGeom()
{
  if (!m_geom || !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));

  canvasInstance.draw(m_geom);

  m_mapDisplay->repaint();
}

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

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

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

  emit closeTool();
}

void te::qt::widgets::ColorTransformDialog::setMapDisplay(te::qt::widgets::MapDisplay* mapDisplay)
{
  m_mapDisplay = mapDisplay;
}