RasterSlicingWizardPage.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>.
*/

//Terralib
#include "../../../dataaccess/utils/Utils.h"
#include "../../../raster/Band.h"
#include "../../../raster/Raster.h"
#include "../../../geometry/Utils.h"
#include "../../../rp/Functions.h"
#include "../../../maptools/Utils.h"
#include "../../../se/Categorize.h"
#include "../../../se/ColorMap.h"
#include "../../../se/CoverageStyle.h"
#include "../../../se/Utils.h"
#include "../../../se/ParameterValue.h"
#include "../../../common/STLUtils.h"
#include "../charts/ChartDisplay.h"
#include "../charts/ChartStyle.h"
#include "../charts/Histogram.h"
#include "../charts/HistogramChart.h"
#include "../charts/HistogramStyle.h"
#include "../charts/Utils.h"
#include "../se/SlicingColorMapWidget.h"
#include "../utils/ScopedCursor.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "../progress/ProgressViewerDialog.h"
#include "RasterSlicingWizardPage.h"
#include "ui_SlicingColorMapForm.h"
#include "ui_RasterSlicingWizardPageForm.h"

// QT
#include <QComboBox>
#include <QString>
#include <QMessageBox>

te::qt::widgets::RasterSlicingWizardPage::RasterSlicingWizardPage(QWidget *parent) :
  QWizardPage(parent)
{
  m_ui.reset(new Ui::RasterSlicingWizardPageForm);
  m_mapDisplay = nullptr;

  m_ui->setupUi(this);
  m_ui->m_histogramToolButton->setIcon(QIcon::fromTheme("chart-bar"));

  //configure page
  this->setTitle(tr("Raster Slicing"));
  this->setSubTitle(tr("Define the raster slicing parameters."));

  //Creating and adjusting the chart Display's style.
  te::qt::widgets::ChartStyle* chartStyle = new te::qt::widgets::ChartStyle();
  chartStyle->setTitle(tr(""));
  chartStyle->setAxisX(tr(""));
  chartStyle->setAxisY(tr(""));
  chartStyle->setGridChecked(true);

  QGridLayout* displayLayout = new QGridLayout(m_ui->m_toolWidget);
  m_tool.reset(new te::qt::widgets::RpToolsWidget(m_ui->m_toolWidget));
  displayLayout->addWidget(m_tool.get());
  displayLayout->setContentsMargins(0,0,0,0);

  //Creating and adjusting the chart Display
  QGridLayout* chartLayout = new QGridLayout(m_ui->m_histWidget);

  m_chartDisplay = new te::qt::widgets::ChartDisplay(m_ui->m_histWidget, QString::fromUtf8(""), chartStyle);
  m_chartDisplay->adjustDisplay();
  m_chartDisplay->show();
  m_chartDisplay->replot();

  chartLayout->addWidget(m_chartDisplay, 0, 0);
  chartLayout->setContentsMargins(0, 0, 0, 0);

  m_histogramChart = new te::qt::widgets::HistogramChart(new te::qt::widgets::Histogram());
  m_histogramChart->attach(m_chartDisplay);
  
  m_colorMapWidget = new te::qt::widgets::SlicingColorMapWidget(m_ui->m_slicesWidget);
  m_colorMapWidget->setColorMap(new te::se::ColorMap());

  QGridLayout* slicesWidgetLayout = new QGridLayout(m_ui->m_slicesWidget);

  slicesWidgetLayout->addWidget(m_colorMapWidget);
  slicesWidgetLayout->setContentsMargins(0, 0, 0, 0);

  m_extent.makeInvalid();
  m_srid = 0;
  m_ui->m_visibleAreaCheckBox->setEnabled(false);

  connect(m_ui->m_histogramToolButton, SIGNAL(clicked()), this, SLOT(updateHistogram()));
  connect(m_ui->m_bandComboBox, SIGNAL(currentIndexChanged(int)), m_colorMapWidget, SLOT(onBandSelected(int)));
  connect(m_colorMapWidget->getForm()->m_tableWidget, SIGNAL(cellChanged(int, int)), this, SIGNAL(completeChanged()));
  connect(m_tool.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));
}

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

te::se::ColorMap * te::qt::widgets::RasterSlicingWizardPage::getColorMap()
{
  return m_colorMapWidget->getColorMap();
}

std::string te::qt::widgets::RasterSlicingWizardPage::getCurrentBand()
{
  return m_ui->m_bandComboBox->currentText().toUtf8().data();
}

const te::gm::Envelope& te::qt::widgets::RasterSlicingWizardPage::getExtent()
{
  return m_extent;
}

int te::qt::widgets::RasterSlicingWizardPage::getSRID()
{
  return m_srid;
}

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

void te::qt::widgets::RasterSlicingWizardPage::setActionGroup(QActionGroup* actionGroup)
{
  m_tool->setActionGroup(actionGroup);
  m_tool->enableBoxAction();
}

bool te::qt::widgets::RasterSlicingWizardPage::trimRaster()
{
  bool useVisibleArea = m_ui->m_visibleAreaCheckBox->isChecked();
  bool extValid = m_extent.isValid();
  bool isWithinRaster = m_raster->getExtent()->contains(m_extent);

  if (useVisibleArea && extValid && isWithinRaster)
    return true;
  else
    return false;
}

void te::qt::widgets::RasterSlicingWizardPage::setLayer(te::map::AbstractLayerPtr layer)
{
  m_rasterLayer = layer;

  //get input raster
  std::unique_ptr<te::da::DataSet> ds = m_rasterLayer->getData();

  if (ds.get())
  {
    std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

    std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

    if (inputRst.get())
    {
      m_raster.reset(inputRst.release());

      m_colorMapWidget->setRaster(m_raster.get());

      size_t bandsNumber = m_raster->getNumberOfBands();

      m_ui->m_bandComboBox->clear();
      for (size_t band = 0; band < bandsNumber; ++band)
      {
        m_ui->m_bandComboBox->addItem(QString::number(band));
      }
    }
  }
}

void te::qt::widgets::RasterSlicingWizardPage::setExtent(const te::gm::Envelope& extent)
{
  m_extent = extent;

  if (m_extent.isValid())
    m_ui->m_visibleAreaCheckBox->setEnabled(true);
  else
    m_ui->m_visibleAreaCheckBox->setEnabled(false);
}

void te::qt::widgets::RasterSlicingWizardPage::setSRID(int srid)
{
  m_srid = srid;
}

void te::qt::widgets::RasterSlicingWizardPage::updateHistogram()
{
  te::qt::widgets::ScopedCursor cursor(Qt::WaitCursor);

  std::unique_ptr<te::da::DataSet> dataset(m_rasterLayer->getData().release());
  std::unique_ptr<te::da::DataSetType> dsType(m_rasterLayer->getSchema().release());

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

    if (inputRst.get())
    {
      int band = m_ui->m_bandComboBox->currentIndex();

      m_histogramChart->setHistogram(te::qt::widgets::createHistogram(m_rasterLayer, band, 0, -1));
      m_histogramChart->setData();
    }
  }

  m_chartDisplay->updateLayout();
  m_chartDisplay->replot();
}

void te::qt::widgets::RasterSlicingWizardPage::onSliceBandComboBoxIndexCHanged(int index)
{
  m_ui->m_bandComboBox->setCurrentIndex(index);
}

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

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

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

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

  getRasterFromROI();

  drawGeom();
}

void te::qt::widgets::RasterSlicingWizardPage::getParameters(
  unsigned int& inputRasterBand, bool& eqHistogram)
{
  inputRasterBand = (unsigned int)m_ui->m_bandComboBox->currentText().toUInt();
  eqHistogram = m_ui->m_equalizeHistogramCheckBox->isChecked();
}

bool te::qt::widgets::RasterSlicingWizardPage::isComplete() const
{
  if (m_colorMapWidget->getForm()->m_tableWidget->rowCount() > 0)
    return true;
  else
    return false;
}

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

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

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

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

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

  m_mapDisplay->repaint();

  delete canvasInstance;
}

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

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

void te::qt::widgets::RasterSlicingWizardPage::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_rasterLayer->getSRID() != TE_UNKNOWN_SRS) && (m_mapDisplay->getSRID() != m_rasterLayer->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_rasterLayer->getSRID());

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

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

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

    applyPreview();

    QApplication::restoreOverrideCursor();
  }
}

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

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

  std::unique_ptr<te::se::CoverageStyle> cs(dynamic_cast<te::se::CoverageStyle*>(
                                                te::se::CreateCoverageStyle(raster->getNumberOfBands())));
  assert(cs);

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

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

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

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

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

  m_mapDisplay->repaint();

  delete canvasInstance;

  QApplication::restoreOverrideCursor();
}

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

  unsigned int inputRasterBand = 0;
  bool eqHistogram = false;
  getParameters( inputRasterBand, eqHistogram );

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

  // Execute slicing
  QApplication::setOverrideCursor(Qt::WaitCursor);
  std::unique_ptr< te::rst::Raster > outRasterPtr;

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

  //Creating the color palette
  std::unique_ptr<te::se::ColorMap> colorMap(getColorMap());

  std::vector<te::se::ParameterValue*> values = colorMap->getCategorize()->getThresholds();
  std::map<double, double> slice_limits;
  for (size_t i = 0; i < values.size(); ++i)
  {
    std::string limits = te::se::GetString(values[i]);
    size_t pos = limits.find(" ");
    double min = std::stod(limits.substr(0, pos));
    double max = std::stod(limits.substr(pos));
    slice_limits.insert(std::pair< double, double >(min,max));
  }

  std::vector<te::se::ParameterValue*> colors = colorMap->getCategorize()->getThresholdValues();

  std::vector< te::rst::BandProperty::ColorEntry > palette;

  for(size_t i = 0; i < colors.size(); ++i)
  {
    //Acquiring each color and inserting it in the palette
    std::string colorName = te::se::GetString(colors[i]);
    te::color::RGBAColor rgbac(colorName);

    te::rst::BandProperty::ColorEntry color;
    color.c1 = rgbac.getRed();
    color.c2 = rgbac.getGreen();
    color.c3 = rgbac.getBlue();
    color.c4 = rgbac.getAlpha();
    palette.push_back(color);
  }

  if( te::rp::RasterSlicing( *m_rasterPreview, inputRasterBand, true,
    static_cast<int>(palette.size()), eqHistogram, rinfo,
    "MEM", true, &palette, outRasterPtr, slice_limits ) )
  {
    drawPreview(outRasterPtr.get());

    QApplication::restoreOverrideCursor();

  }
  else
  {
    QMessageBox::critical(this, tr("Raster slicing"), tr("Raster slicing execution error.") +
      ( " " + te::rp::Module::getLastLogStr() ).c_str());

    te::common::FreeContents(colors);

    QApplication::restoreOverrideCursor();

    return;
  }
}