SlicingColorMapWidget.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/se/SlicingColorMapWidget.cpp

\brief A widget used to adjust the color map with the minimal required parameters.
*/

// TerraLib
#include "../../../color/ColorBar.h"
#include "../../../common/STLUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/dataset/DataSetType.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../datatype.h"
#include "../../../maptools/DataSetLayer.h"
#include "../../../maptools/GroupingAlgorithms.h"
#include "../../../maptools/RasterLayer.h"
#include "../../../fe/Literal.h"
#include "../../../fe/Utils.h"
#include "../../../raster.h"
#include "../../../raster/RasterSummary.h"
#include "../../../raster/RasterSummaryManager.h"
#include "../../../se/ColorMap.h"
#include "../../../se/Categorize.h"
#include "../../../se/MapItem.h"
#include "../../../se/ParameterValue.h"
#include "../../../se/RasterSymbolizer.h"
#include "../../../se/Rule.h"
#include "../../../se/Utils.h"
#include "../../widgets/colorbar/ColorBar.h"
#include "../../widgets/colorbar/ColorCatalogWidget.h"
#include "SlicingColorMapWidget.h"
#include "ui_SlicingColorMapForm.h"

// Qt
#include <QColorDialog>
#include <QMessageBox>
#include <QPainter>
#include <QTableWidget>
#include <QValidator>

// STL
#include <cassert>

te::qt::widgets::SlicingColorMapWidget::SlicingColorMapWidget(QWidget* parent, Qt::WindowFlags f)
  : QWidget(parent, f),
  m_ui(new Ui::SlicingColorMapForm),
  m_cm(nullptr),
  m_cb(nullptr),
  m_raster(nullptr)
{
  m_ui->setupUi(this);

  QGridLayout* l = new QGridLayout(m_ui->m_colorBarWidget);
  l->setContentsMargins(0, 0, 0, 0);
  m_colorBar = new  te::qt::widgets::ColorCatalogWidget(m_ui->m_colorBarWidget);
  l->addWidget(m_colorBar);

  m_ui->m_minValueLineEdit->setValidator(new QDoubleValidator(this));
  m_ui->m_maxValueLineEdit->setValidator(new QDoubleValidator(this));

  m_colorBar->getColorBar()->setHeight(20);
  m_colorBar->getColorBar()->setScaleVisible(false);

  // Signals & slots
  connect(m_colorBar, SIGNAL(colorBarChanged()), this, SLOT(onApplyPushButtonClicked()));
  connect(m_ui->m_applyPushButton, SIGNAL(clicked()), this, SLOT(onApplyPushButtonClicked()));
  connect(m_ui->m_tableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem*)), this, SLOT(onTableWidgetItemDoubleClicked(QTableWidgetItem*)));
}

te::qt::widgets::SlicingColorMapWidget::~SlicingColorMapWidget()
{
  delete m_cb;

  delete m_cm;
}

void te::qt::widgets::SlicingColorMapWidget::setRaster(te::rst::Raster* r)
{
  assert(r);

  m_raster = r;

  int nBands = static_cast<int>(m_raster->getNumberOfBands());
  if (nBands > 0)
    onBandSelected(0);
}

void te::qt::widgets::SlicingColorMapWidget::setColorMap(te::se::ColorMap* cm)
{
  assert(cm);

  m_cm = cm->clone();

  updateUi(true);
}

te::se::ColorMap* te::qt::widgets::SlicingColorMapWidget::getColorMap()
{
  te::se::Categorize* c = new te::se::Categorize();

  c->setFallbackValue("#000000");
  c->setLookupValue(new te::se::ParameterValue("Rasterdata"));

  for (int i = 0; i < m_ui->m_tableWidget->rowCount(); ++i)
  {
    QColor color = QColor::fromRgb(m_ui->m_tableWidget->item(i, 0)->icon().pixmap(24, 24).toImage().pixel(1, 1));

    std::string rangeStr = m_ui->m_tableWidget->item(i, 1)->text().toUtf8().data();
    rangeStr += " ";
    rangeStr += m_ui->m_tableWidget->item(i, 2)->text().toUtf8().data();
    std::string colorStr = color.name().toUtf8().data();

    c->addThreshold(new te::se::ParameterValue(rangeStr));
    c->addValue(new te::se::ParameterValue(colorStr));
  }

  if (m_cm)
  {
    m_cm->setCategorize(c);
    m_cm->setInterpolate(nullptr);
    m_cm->setRecode(nullptr);
  }

  return m_cm->clone();
}

Ui::SlicingColorMapForm * te::qt::widgets::SlicingColorMapWidget::getForm()
{
  return m_ui.get();
}

void te::qt::widgets::SlicingColorMapWidget::updateUi(bool loadColorBar)
{
    m_ui->m_tableWidget->setRowCount(0);

    if (!m_cm)
    {
      return;
    }

    te::color::ColorBar* cb = nullptr;

    if (m_cm->getCategorize())
    {
      std::vector<te::se::ParameterValue*> t = m_cm->getCategorize()->getThresholds();
      std::vector<te::se::ParameterValue*> tV = m_cm->getCategorize()->getThresholdValues();

      m_ui->m_slicesSpinBox->setValue(static_cast<int>(tV.size() - 2));

      m_ui->m_tableWidget->setRowCount(static_cast<int>(tV.size() - 2));

      te::color::RGBAColor initColor(te::se::GetString(tV[1]));
      te::color::RGBAColor endColor(te::se::GetString(tV[tV.size() - 2]));

      if (loadColorBar)
        cb = new te::color::ColorBar(initColor, endColor, 256);

      int count = 0;

      for (size_t i = 1; i < tV.size() - 1; ++i)
      {
        QColor color;
        std::string lowerLimit;
        std::string upperLimit;

        if (i == 0)
        {
          lowerLimit = "...";
          upperLimit = te::se::GetString(t[i]);
          color.setNamedColor(te::se::GetString(tV[i]).c_str());
        }
        else if (i == tV.size() - 1)
        {
          lowerLimit = te::se::GetString(t[i - 1]);
          upperLimit = "...";
          color.setNamedColor(te::se::GetString(tV[i]).c_str());
        }
        else
        {
          lowerLimit = te::se::GetString(t[i - 1]);
          upperLimit = te::se::GetString(t[i]);
          color.setNamedColor(te::se::GetString(tV[i]).c_str());
        }

        if (loadColorBar)
        {
          if (count != 0 && count != static_cast<int>(tV.size()) - 2)
          {
            double pos = (1. / (tV.size() - 2)) * count;

            te::color::RGBAColor color(te::se::GetString(tV[i]));

            cb->addColor(color, pos);
          }
        }

        ++count;

        //color
        QPixmap pix(24, 24);
        QPainter p(&pix);

        p.fillRect(0, 0, 24, 24, color);
        p.setBrush(Qt::transparent);
        p.setPen(Qt::black);
        p.drawRect(0, 0, 23, 23);

        QIcon icon(pix);

        QTableWidgetItem* item = new QTableWidgetItem(pix, "");
        item->setFlags(Qt::ItemIsEnabled);
        m_ui->m_tableWidget->setItem(static_cast<int>(i - 1), 0, item);

        //value From
        std::string rangeLower = lowerLimit;
        QTableWidgetItem* itemRangeLower = new QTableWidgetItem();
        itemRangeLower->setText(rangeLower.c_str());
        itemRangeLower->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
        m_ui->m_tableWidget->setItem(static_cast<int>(i - 1), 1, itemRangeLower);

        //value To
        std::string rangeUpper = upperLimit;
        QTableWidgetItem* itemRangeUpper = new QTableWidgetItem();
        itemRangeUpper->setText(rangeUpper.c_str());
        itemRangeUpper->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
        m_ui->m_tableWidget->setItem(static_cast<int>(i - 1), 2, itemRangeUpper);
      }
    }

    if (cb)
    {
      disconnect(m_colorBar, SIGNAL(colorBarChanged()), this, SLOT(onApplyPushButtonClicked()));

      te::qt::widgets::colorbar::ColorBar* cbW = m_colorBar->getColorBar();
      cbW->setColorBar(cb);

      connect(m_colorBar, SIGNAL(colorBarChanged()), this, SLOT(onApplyPushButtonClicked()));
    }

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

void te::qt::widgets::SlicingColorMapWidget::onBandSelected(int band)
{
  const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(m_raster, te::rst::SUMMARY_MIN);
  const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(m_raster, te::rst::SUMMARY_MAX);
  const std::complex<double>* cmin = rsMin->at(band).m_minVal;
  const std::complex<double>* cmax = rsMax->at(band).m_maxVal;
  double min = cmin->real();
  double max = cmax->real();

  QString strMin;
  strMin.setNum(min);
  m_ui->m_minValueLineEdit->setText(strMin);

  QString strMax;
  strMax.setNum(max);
  m_ui->m_maxValueLineEdit->setText(strMax);

  emit applyPushButtonClicked();
}

void te::qt::widgets::SlicingColorMapWidget::onApplyPushButtonClicked()
{
  delete m_cb;

  m_cb = m_colorBar->getColorBar()->getColorBar();

  int sliceValue = m_ui->m_slicesSpinBox->value();

  std::vector<te::color::RGBAColor> colorVec;

  colorVec = m_cb->getSlices(sliceValue);

  std::vector<te::se::Rule*> legVec;

  std::vector<double> vec;
  vec.push_back(m_ui->m_minValueLineEdit->text().toDouble());
  vec.push_back(m_ui->m_maxValueLineEdit->text().toDouble());

  te::map::GroupingByEqualSteps("raster", vec.begin(), vec.end(), sliceValue, legVec, m_ui->m_precisionSpinBox->value());

  m_ui->m_tableWidget->setRowCount(static_cast<int>(legVec.size()));


  for (std::size_t t = 0; t < legVec.size(); ++t)
  {
    //color
    QColor color(colorVec[t].getRed(), colorVec[t].getGreen(), colorVec[t].getBlue(), colorVec[t].getAlpha());

    QPixmap pix(24, 24);
    QPainter p(&pix);

    p.fillRect(0, 0, 24, 24, color);
    p.setBrush(Qt::transparent);
    p.setPen(Qt::black);
    p.drawRect(0, 0, 23, 23);

    QIcon icon(pix);

    QTableWidgetItem* item = new QTableWidgetItem(icon, "");
    item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
    m_ui->m_tableWidget->setItem(static_cast<int>(t), 0, item);

    std::string rangeStrLower;
    std::string rangeStrUpper;

    te::fe::GetFilterStepValues(legVec[t]->getFilter(), rangeStrLower, rangeStrUpper);

    //value lower
    QTableWidgetItem* itemRangeLower = new QTableWidgetItem();
    itemRangeLower->setText(rangeStrLower.c_str());
    itemRangeLower->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
    m_ui->m_tableWidget->setItem(static_cast<int>(t), 1, itemRangeLower);

    //value upper
    QTableWidgetItem* itemRangeUpper = new QTableWidgetItem();
    itemRangeUpper->setText(rangeStrUpper.c_str());
    itemRangeUpper->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
    m_ui->m_tableWidget->setItem(static_cast<int>(t), 2, itemRangeUpper);
  }

  m_ui->m_tableWidget->resizeColumnsToContents();

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

  emit applyPushButtonClicked();
}

void te::qt::widgets::SlicingColorMapWidget::onTableWidgetItemDoubleClicked(QTableWidgetItem* item)
{
  int curCol = m_ui->m_tableWidget->currentColumn();

  if (curCol == 0)
  {
    QColor bgColor = QColor::fromRgb(item->icon().pixmap(24, 24).toImage().pixel(1, 1));

    QColor newBgColor = QColorDialog::getColor(bgColor, m_ui->m_tableWidget);

    if (newBgColor.isValid())
      bgColor = newBgColor;

    QPixmap pix(24, 24);
    pix.fill(bgColor);
    QIcon icon(pix);

    item->setIcon(icon);
  }

  emit applyPushButtonClicked();
}