TimeViewerEditLegendDialog.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/timeviewer/TimeViewEditLegendDialog.cpp

  \brief A dialog used to edit legend.
*/

// TerraLib
#include "TimeViewerEditLegendDialog.h"
#include "../../../color/ColorBar.h"
#include "../../../common/Globals.h"
#include "../../../common/STLUtils.h"
#include "../../../core/translator/Translator.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/datasource/DataSourceManager.h"
#include "../../../dataaccess/query_h.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../maptools/GroupingAlgorithms.h"
#include "../../../maptools/Utils.h"
#include "../../../se.h"
#include "../../../se/SymbolizerColorFinder.h"
#include "../../../se/Utils.h"
#include "../../widgets/colorbar/ColorBar.h"
#include "../../widgets/colorbar/ColorCatalogWidget.h"
#include "../../widgets/se/LineSymbolizerWidget.h"
#include "../../widgets/se/PointSymbolizerWidget.h"
#include "../../widgets/se/PolygonSymbolizerWidget.h"
#include "../../widgets/se/SymbologyPreview.h"
#include "ui_TimeViewerEditLegendDialog.h"

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

// Boost
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/json_parser.hpp>

#define NO_TITLE "No Value"
#define PRECISION 15

te::qt::plugins::tv::TimeViewerEditLegendDialog::TimeViewerEditLegendDialog(QWidget* parent, Qt::WindowFlags f)
    : QDialog(parent, f),
      m_ui(new Ui::TimeViewerEditLegendDialog),
      m_cb(0),
      m_colorBar(0)
{
  m_ui->setupUi(this);

  m_ui->m_okPushButton->setEnabled(false);

  m_ui->m_tableWidget->resizeColumnsToContents();

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

  // connects
  connect(m_colorBar, SIGNAL(colorBarChanged()), this, SLOT(onColorBarChanged()));
  connect(m_ui->m_applyPushButton, SIGNAL(clicked()), this, SLOT(onApplyPushButtonClicked()));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), this, SLOT(onOkPushButtonClicked()));
  connect(m_ui->m_cancelPushButton, SIGNAL(clicked()), this, SLOT(onCancelPushButtonClicked()));

  connect(m_ui->m_loadPushButton, SIGNAL(clicked()), this, SLOT(onLoadPushButtonClicked()));
  connect(m_ui->m_savePushButton, SIGNAL(clicked()), this, SLOT(onSavePushButtonClicked()));
  connect(m_ui->m_selectAllPushButton, SIGNAL(clicked()), this, SLOT(onSelectAllPushButtonClicked()));
  connect(m_ui->m_unselectAllPushButton, SIGNAL(clicked()), this, SLOT(onUnselectAllPushButtonClicked()));

  initialize();

  //  m_ui->m_helpPushButton->setPageReference(".html");
}

te::qt::plugins::tv::TimeViewerEditLegendDialog::~TimeViewerEditLegendDialog() = default;

void te::qt::plugins::tv::TimeViewerEditLegendDialog::setLayers(te::map::AbstractLayerPtr selectedLayer)
{
  m_layer = selectedLayer;

  m_ui->m_layerNameLineEdit->setText(m_layer->getTitle().c_str());

  listAtrributes();
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::listAtrributes()
{
  std::unique_ptr<te::map::LayerSchema> dsType(m_layer->getSchema());

  m_ui->m_attributeComboBox->clear();

  for(size_t t = 0; t < dsType->getProperties().size(); ++t)
  {
    te::dt::Property* p = dsType->getProperty(t);

    int dataType = p->getType();

    switch(dataType)
    {
      case te::dt::INT16_TYPE:
      case te::dt::INT32_TYPE:
      case te::dt::INT64_TYPE:
      case te::dt::FLOAT_TYPE:
      case te::dt::DOUBLE_TYPE:
      case te::dt::NUMERIC_TYPE:
      case te::dt::STRING_TYPE:
        m_ui->m_attributeComboBox->addItem(p->getName().c_str(), p->getType());
        break;

      default:
        continue;
    }
  }
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::getDataAsString(std::vector<std::string>& vec, const std::string& attrName, int& nullValues)
{
  assert(m_layer.get());

  std::unique_ptr<te::map::LayerSchema> dsType(m_layer->getSchema());

  std::size_t idx;

  for(std::size_t t = 0; t < dsType->getProperties().size(); ++t)
  {
    if(dsType->getProperty(t)->getName() == attrName)
    {
      idx = t;
      break;
    }
  }

  std::unique_ptr<te::da::DataSet> ds(m_layer->getData());

  ds->moveBeforeFirst();

  while(ds->moveNext())
  {
    if(!ds->isNull(idx))
      vec.push_back(ds->getAsString(idx));
    else
      ++nullValues;
  }
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onApplyPushButtonClicked()
{
  int prec = m_ui->m_precisionSpinBox->value();

  std::string attr = m_ui->m_attributeComboBox->currentText().toUtf8().data();
  int attrIdx = m_ui->m_attributeComboBox->currentIndex();
  int attrType = m_ui->m_attributeComboBox->itemData(attrIdx).toInt();

  te::common::FreeContents(m_legend);
  m_legend.clear();

  std::string mean;

  int nullValues = 0;

  bool update = false;

  std::vector<std::string> vec;

  getDataAsString(vec, attr, nullValues);

  if(!vec.empty())
  {
    te::map::GroupingByUniqueValues(attr, vec, attrType, m_legend, prec);

    buildSymbolizer(mean);
  }

  updateUi(update);

  m_ui->m_okPushButton->setEnabled(true);

  m_manual = false;
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::initialize()
{
  // create color bar
  m_colorBar->getColorBar()->setHeight(20);
  m_colorBar->getColorBar()->setScaleVisible(false);

  // set number of precision
  m_ui->m_precisionSpinBox->setMinimum(1);
  m_ui->m_precisionSpinBox->setMaximum(PRECISION);
  m_ui->m_precisionSpinBox->setValue(6);
  m_ui->m_precisionSpinBox->setSingleStep(1);

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

  m_manual = false;
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::buildSymbolizer(std::string meanTitle)
{
  delete m_cb;

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

  int legendSize = m_legend.size();

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

  if(meanTitle.empty())
  {
    colorVec = m_cb->getSlices(legendSize);
  }
  else
  {
    int beforeMean = 0;
    int afterMean = 0;

    for(size_t t = 0; t < m_legend.size(); ++t)
    {
      std::string ruleName = *m_legend[t]->getName();

      if(ruleName != meanTitle)
      {
        beforeMean++;
      }
      else
      {
        afterMean = (int)(m_legend.size() - t - 1);
        break;
      }
    }

    std::vector<te::color::RGBAColor> lowerColorVec = m_cb->getLowerMeanSlices(beforeMean);
    te::color::RGBAColor meanColor = m_cb->getMeanSlice();
    std::vector<te::color::RGBAColor> upperColorVec = m_cb->getUpperMeanSlices(afterMean);

    for(size_t t = 0; t < lowerColorVec.size(); ++t)
      colorVec.push_back(lowerColorVec[t]);

    colorVec.push_back(meanColor);

    for(size_t t = 0; t < upperColorVec.size(); ++t)
      colorVec.push_back(upperColorVec[t]);
  }

  if(colorVec.size() != m_legend.size())
    return;

  int geomType = getGeometryType();

  for(size_t t = 0; t < colorVec.size(); ++t)
  {
    std::vector<te::se::Symbolizer*> symbVec;

    te::se::Symbolizer* s = te::se::CreateSymbolizer((te::gm::GeomType)geomType, colorVec[t].getColor());

    symbVec.push_back(s);

    m_legend[t]->setSymbolizers(symbVec);
  }
}

int te::qt::plugins::tv::TimeViewerEditLegendDialog::getGeometryType()
{
  assert(m_layer.get());

  return te::map::GetGeomType(m_layer);
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::updateUi(
    bool loadColorBar)
{
  disconnect(m_ui->m_tableWidget, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(onTableWidgetItemChanged(QTableWidgetItem*)));

  m_ui->m_tableWidget->setRowCount(0);

  QStringList list;
  list.append(tr("Symbol"));
  list.append(tr("Title"));
  list.append(tr("Value"));

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

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

  if(loadColorBar)
  {
    if(!m_legend.empty() && !m_legend[0]->getSymbolizers().empty() && !m_legend[m_legend.size() - 1]->getSymbolizers().empty())
    {
      te::se::SymbolizerColorFinder scf;

      scf.find(m_legend[0]->getSymbolizers()[0]);
      te::color::RGBAColor initColor = scf.getColor();

      scf.find(m_legend[m_legend.size() - 1]->getSymbolizers()[0]);
      te::color::RGBAColor endColor = scf.getColor();

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

  std::size_t count = 0;

  for(std::size_t t = 0; t < m_legend.size(); ++t)
  {
    te::se::Rule* ruleItem = m_legend[t];

    const te::fe::Filter* ruleFilter = ruleItem->getFilter();

    if(!ruleFilter)
      continue;

    int newrow = m_ui->m_tableWidget->rowCount();
    m_ui->m_tableWidget->insertRow(newrow);

    // symbol
    {
      const std::vector<te::se::Symbolizer*>& ss = ruleItem->getSymbolizers();
      QPixmap pix = te::qt::widgets::SymbologyPreview::build(ss, QSize(24, 24));
      QIcon icon(pix);
      QTableWidgetItem* item = new QTableWidgetItem(icon, "");
      item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
      m_ui->m_tableWidget->setItem(newrow, 0, item);
    }

    // title
    {
      QTableWidgetItem* item = new QTableWidgetItem( QString::fromUtf8((*ruleItem->getName()).c_str()));
      item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
      m_ui->m_tableWidget->setItem(newrow, 1, item);
    }

    if(loadColorBar)
    {
      if(count != 0 && count != m_legend.size() - 1)
      {
        double pos = (1. / (m_legend.size() - 1)) * count;

        if(!ruleItem->getSymbolizers().empty())
        {
          te::se::SymbolizerColorFinder scf;

          scf.find(ruleItem->getSymbolizers()[0]);

          te::color::RGBAColor color = scf.getColor();

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

    ++count;

    std::string ruleName = *ruleItem->getName();

    if(ruleName != NO_TITLE)
    {
      // Value
      std::string value;
      te::fe::GetFilterUniqueValue(ruleFilter, value);

      QTableWidgetItem* item =  new QTableWidgetItem(QString::fromUtf8(value.c_str()));
      item->setFlags(Qt::ItemIsEnabled);
      m_ui->m_tableWidget->setItem(newrow, 2, item);
    }
  }

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

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

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

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

  connect(m_ui->m_tableWidget, SIGNAL(itemChanged(QTableWidgetItem*)), this,  SLOT(onTableWidgetItemChanged(QTableWidgetItem*)));
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onColorBarChanged()
{
  if(m_layer.get())
  {
    buildSymbolizer();

    updateUi();
  }
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog:: onCancelPushButtonClicked()
{
  reject();
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onOkPushButtonClicked()
{
  accept();

  emit okPushButtonClicked();
}

const std::vector<te::se::Rule*>&te::qt::plugins::tv::TimeViewerEditLegendDialog::getRules() const
{
  return m_legend;
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onSavePushButtonClicked()
{
  QString fileName = QFileDialog::getSaveFileName(this, tr("Save as..."), QString(), tr("LEG (*.leg *.LEG);;"), 0,QFileDialog::DontConfirmOverwrite);

  saveLegend(fileName.toUtf8().data());
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::saveLegend( const std::string& path)
{
  int rowCount = m_ui->m_tableWidget->rowCount();

  if(rowCount < 1)
    return;

  if(path.empty())
    return;

  boost::property_tree::ptree pt;
  boost::property_tree::ptree legend;

  std::string attrName = m_ui->m_attributeComboBox->currentText().toUtf8().data();
  std::string precision = m_ui->m_precisionSpinBox->text().toUtf8().data();

  legend.add("Attribute", attrName);
  legend.add("Precision", precision);

  boost::property_tree::ptree items;

  for(int i = 0; i < m_ui->m_tableWidget->rowCount(); ++i)
  {
    std::string className =  m_ui->m_tableWidget->item(i, 0)->text().toUtf8().data();
    std::string r = m_ui->m_tableWidget->item(i, 1)->text().toUtf8().data();
    std::string g = m_ui->m_tableWidget->item(i, 2)->text().toUtf8().data();
    std::string b = m_ui->m_tableWidget->item(i, 3)->text().toUtf8().data();

    boost::property_tree::ptree item;
    item.add("ClassName", className);
    item.add("Red", r);
    item.add("Green", g);
    item.add("Blue", b);

    items.add_child("Item", item);
  }

  legend.add_child("Items", items);

  pt.add_child("Legend", legend);

  boost::property_tree::write_json(path, pt);
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onSelectAllPushButtonClicked()
{
  int size = m_ui->m_tableWidget->rowCount();

  for(int i = 0; i < size; ++i)
  {
    QTableWidgetItem* item = m_ui->m_tableWidget->item(i, 5);
    item->setCheckState(Qt::Checked);
  }
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onUnselectAllPushButtonClicked()
{
  int size = m_ui->m_tableWidget->rowCount();

  for(int i = 0; i < size; ++i)
  {
    QTableWidgetItem* item = m_ui->m_tableWidget->item(i, 5);
    item->setCheckState(Qt::Unchecked);
  }
}

void te::qt::plugins::tv::TimeViewerEditLegendDialog::onLoadPushButtonClicked()
{
  QString fileName = QFileDialog::getOpenFileName( this, tr("Open..."), QString(), tr("LEG (*.leg *.LEG);;"), 0,
      QFileDialog::DontConfirmOverwrite);

  if(fileName.isEmpty())
    return;

  m_ui->m_tableWidget->setRowCount(0);

  boost::property_tree::ptree pt;
  boost::property_tree::json_parser::read_json(fileName.toUtf8().data(), pt);

  boost::property_tree::ptree legend = pt.get_child("Legend");

  std::string attrName = legend.get<std::string>("Attribute");
  std::string precision = legend.get<std::string>("Precision");

  m_ui->m_attributeComboBox->setCurrentIndex( m_ui->m_attributeComboBox->findText(attrName.c_str()));
  m_ui->m_precisionSpinBox->setValue(boost::lexical_cast<double>(precision));

  std::vector<std::vector<std::string> > items;

  for(boost::property_tree::ptree::value_type& v : legend.get_child("Items"))
  {
    std::vector<std::string> item;
    item.push_back(v.second.get<std::string>("ClassName"));
    item.push_back(v.second.get<std::string>("Red"));
    item.push_back(v.second.get<std::string>("Green"));
    item.push_back(v.second.get<std::string>("Blue"));

    items.push_back(item);
  }

  m_ui->m_tableWidget->setRowCount(items.size());

  for(std::size_t i = 0; i < items.size(); ++i)
  {
    m_ui->m_tableWidget->setItem(i, 0,new QTableWidgetItem(items[i][0].c_str()));
    m_ui->m_tableWidget->setItem(i, 1,new QTableWidgetItem(items[i][1].c_str()));
    m_ui->m_tableWidget->setItem(i, 2,new QTableWidgetItem(items[i][2].c_str()));
    m_ui->m_tableWidget->setItem(i, 3,new QTableWidgetItem(items[i][3].c_str()));

    QColor color;

    color.setRgb(boost::lexical_cast<int>(items[i][1]),
                 boost::lexical_cast<int>(items[i][2]),
                 boost::lexical_cast<int>(items[i][3]));

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

    p.fillRect(0, 0, 12, 24, color);
    p.fillRect(12, 0, 12, 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->setBackgroundColor(color);
    item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
    m_ui->m_tableWidget->setItem(i, 4, item);

    {
      QTableWidgetItem* item = new QTableWidgetItem();
      item->setCheckState(Qt::Checked);
      m_ui->m_tableWidget->setItem(i, 5, item);
    }
  }
}