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

  \brief This file defines a class for a ArithmeticOp Dialog.
*/

// TerraLib
#include "../../../common/PlatformUtils.h"
#include "../../../common/StringUtils.h"
#include "../../../core/utils/Platform.h"
#include "../../../core/translator/Translator.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "LoadArithmeticOpDialog.h"
#include "ui_LoadArithmeticOpDialogForm.h"

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

// Qt
#include <QApplication>
#include <QGridLayout>
#include <QMessageBox>
#include <QComboBox>
#include <QFile>
#include <QTextStream>

// stl
#include <memory>

Q_DECLARE_METATYPE(te::map::AbstractLayerPtr)

te::qt::widgets::LoadArithmeticOpDialog::LoadArithmeticOpDialog(QWidget* parent, Qt::WindowFlags f)
  : QDialog(parent, f),
  m_ui(new Ui::LoadArithmeticOpDialogForm)
{
// setup controls
  m_ui->setupUi(this);

  m_ui->m_removeToolButton->setIcon(QIcon::fromTheme("list-remove"));

  //connects
  connect(m_ui->m_operationComboBox, SIGNAL(activated(QString)), this, SLOT(onOperationComboBoxActivated(QString)));
  connect(m_ui->m_removeToolButton, SIGNAL(clicked()), this, SLOT(onRemoveOperation()));
  connect(m_ui->m_okPushButton, SIGNAL(clicked()), this, SLOT(onOkPushButtonClicked()));
}

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

void te::qt::widgets::LoadArithmeticOpDialog::loadOperations()
{
  m_ui->m_layersTableWidget->clear();
  m_ui->m_operationComboBox->clear();

  m_ui->m_layersTableWidget->setRowCount(0);

  QStringList list;
  list.append(tr("Layer"));
  list.append(tr("Band"));

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

  std::string jsonfile = m_userPath + "/arithmeticOperations.json";

  if (jsonfile.empty())
    throw te::common::Exception(TE_TR("Could not find arithmeticOperations.json file!"));

  try
  {
   // Reading JSON
    boost::property_tree::ptree pt;

    boost::property_tree::json_parser::read_json(jsonfile, pt);

    for(boost::property_tree::ptree::value_type &v: pt.get_child("operations"))
    {
      std::string op = v.second.get<std::string>("operation");
      m_ui->m_operationComboBox->addItem(op.c_str());
    }
  }
  catch(boost::property_tree::json_parser::json_parser_error& e)
  {
    std::string msg = "Error parsing: " + e.filename() + ": " + e.message();
    te::common::Exception ex(TE_TR(msg));
    throw(ex);
  }
  catch(boost::property_tree::ptree_error& e)
  {
    throw te::common::Exception(TE_TR(e.what()));
  }
  catch(...)
  {
    throw te::common::Exception(TE_TR("Load arithmetic operations error."));
  }
}

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

void te::qt::widgets::LoadArithmeticOpDialog::setUserPath(std::string path)
{
  m_userPath = path;
}

std::string te::qt::widgets::LoadArithmeticOpDialog::getExpression()
{
  return m_operationExt;
}

std::map<std::string, te::map::AbstractLayer*> te::qt::widgets::LoadArithmeticOpDialog::getLayers()
{
  return m_mapLayer;
}

std::string te::qt::widgets::LoadArithmeticOpDialog::getOperation()
{
  return m_operation;
}

void te::qt::widgets::LoadArithmeticOpDialog::onOperationComboBoxActivated(QString operation)
{
  int r = 0;

  m_layersComboBox.clear();
  m_bandsComboBox.clear();
  m_ui->m_layersTableWidget->setRowCount(0);

  m_ui->m_gainLineEdit->setEnabled(false);
  m_ui->m_offsetLineEdit->setEnabled(false);
  m_ui->m_gainLineEdit->setText("");
  m_ui->m_offsetLineEdit->setText("");

  std::string op = operation.toUtf8().data();

  std::vector<std::string> arithExpVec;
  boost::split(arithExpVec, op, boost::is_any_of(" "));

  for (size_t i = 0; i < arithExpVec.size(); i++)
  {
    if (arithExpVec[i].find(":") != std::string::npos)
    {
      std::vector<std::string> rasterVec;
      boost::split(rasterVec, arithExpVec[i], boost::is_any_of(":"));

      bool exist = false;
      for (int j = 0; j < m_ui->m_layersTableWidget->rowCount(); j++)
      {
        std::string header = m_ui->m_layersTableWidget->verticalHeaderItem(j)->text().toUtf8().data();
        if (rasterVec[0] == header)
          exist = true;
      }

      if (!exist)
      {
        m_ui->m_layersTableWidget->setRowCount(r + 1);

        QTableWidgetItem* item = new QTableWidgetItem(rasterVec[0].c_str());
        m_ui->m_layersTableWidget->setVerticalHeaderItem(r, item);

        QComboBox* layerComboBox = new QComboBox(m_ui->m_layersTableWidget);
        m_layersComboBox.push_back(layerComboBox);

        QComboBox* bandComboBox = new QComboBox(m_ui->m_layersTableWidget);
        m_bandsComboBox.push_back(bandComboBox);

        connect(m_layersComboBox[r], SIGNAL(activated(int)), this, SLOT(onLayerComboBoxActivated(int)));

        r++;
      }
    }
    else if (te::common::Convert2LCase(arithExpVec[i]) == "gain")
    {
      m_ui->m_gainLineEdit->setEnabled(true);
      m_ui->m_gainLineEdit->setText("1");
    }
    else if (te::common::Convert2LCase(arithExpVec[i]) == "offset")
    {
      m_ui->m_offsetLineEdit->setEnabled(true);
      m_ui->m_offsetLineEdit->setText("0");
    }
  }

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

  m_layers.clear();

  int count = 0;

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

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

    if (dst.get() && dst->hasRaster())
    {
      if (count == 0)
      {
        std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
        std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

        int nbands = static_cast<int>(inputRst->getNumberOfBands());

        for (int i = 0; i < static_cast<int>(m_layersComboBox.size()); i++)
        {
          for (int b = 0; b < nbands; b++)
            m_bandsComboBox[i]->addItem(te::common::Convert2String(b).c_str());
        }
      }

      m_layers.push_back(l);

      for (size_t i = 0; i < m_layersComboBox.size(); i++)
      {
        m_layersComboBox[i]->addItem(l->getTitle().c_str(), QVariant::fromValue(l));
      }

      ++count;
    }

    ++it;
  }

  for (int i = 0; i < static_cast<int>(m_layersComboBox.size()); i++)
  {
    m_ui->m_layersTableWidget->setCellWidget(i, 0, m_layersComboBox[i]);
    m_ui->m_layersTableWidget->setCellWidget(i, 1, m_bandsComboBox[i]);
  }

  m_ui->m_layersTableWidget->resizeColumnsToContents();
}

void te::qt::widgets::LoadArithmeticOpDialog::onLayerComboBoxActivated(int index)
{
  int row = -1;

  int nrows = m_ui->m_layersTableWidget->rowCount();
  for (int i = 0; i < nrows; i++)
  {
    if (QObject::sender() == m_layersComboBox[i])
    {
      row = i;
      break;
    }
  }

  te::map::AbstractLayerPtr layer = m_layers[index];

  std::unique_ptr<te::da::DataSet> ds = layer->getData();
  std::unique_ptr<te::da::DataSetType> dst = layer->getSchema();

  if (dst.get() && dst->hasRaster())
  {
    std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
    std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

    m_bandsComboBox[row]->clear();

    int nbands = static_cast<int>(inputRst->getNumberOfBands());

    for (int i = 0; i < nbands; i++)
    {
      m_bandsComboBox[row]->addItem(te::common::Convert2String(i).c_str());
    }
  }
}

void te::qt::widgets::LoadArithmeticOpDialog::onRemoveOperation()
{
  int index = m_ui->m_operationComboBox->currentIndex();

  std::string selectedOperation = m_ui->m_operationComboBox->itemText(index).toUtf8().data();

  int reply = QMessageBox::question(this, tr("Arithmetic Operations"),
                                             tr("The operation ") + QString::fromStdString(selectedOperation) + (" will be removed from the list, are you certain?"),
                                             QMessageBox::Yes | QMessageBox::No);

  if(reply == QMessageBox::No)
    return;

  try
  {
    if(isDefaultArithmeticOperation(selectedOperation))
    {
      QMessageBox::warning(this, tr("Warning"), tr("The default operation can not be removed from the list."));
      return;
    }

    QString path = QString::fromStdString(m_userPath) + "/arithmeticOperations.json";

    QFile file(path);

    if(!file.exists())
    {
      QMessageBox::warning(this, tr("Warning"), tr("File not found."));
      return;
    }

    boost::property_tree::ptree pt;

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

    for(boost::property_tree::ptree::value_type &v: pt.get_child("operations"))
    {
      std::string op = v.second.get<std::string>("operation");

      if (te::common::Convert2UCase(op) == te::common::Convert2UCase(selectedOperation))
         pt.get_child("operations").erase(v.first);
    }

    boost::property_tree::write_json(path.toUtf8().data(), pt);

    loadOperations();

    QMessageBox::information(this, tr("Arithmetic Operation"), tr("The operation was deleted sucessfully."));
  }
  catch(te::common::Exception& e)
  {
    QMessageBox::warning(this, tr("Warning"), tr(e.what()));
    return;
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("Arithmetic Operations"), tr("An error has occurred."));
    return;
  }
}

void te::qt::widgets::LoadArithmeticOpDialog::onOkPushButtonClicked()
{
  if (m_ui->m_gainLineEdit->isEnabled() && m_ui->m_gainLineEdit->text().isEmpty())
  {
    QMessageBox::warning(this, tr("Warning"), tr("Gain value is not defined."));
    return;
  }

  if (m_ui->m_offsetLineEdit->isEnabled() && m_ui->m_offsetLineEdit->text().isEmpty())
  {
    QMessageBox::warning(this, tr("Warning"), tr("Offset value is not defined."));
    return;
  }

  if(m_ui->m_layersTableWidget->rowCount() != 0)
  {
    m_operationExt = "";
    m_operation = "";

    std::string operation = m_ui->m_operationComboBox->currentText().toUtf8().data();

    std::vector<std::string> arithExpVec;
    boost::split(arithExpVec, operation, boost::is_any_of(" "));

    for (int i = 0; i < static_cast<int>(arithExpVec.size()); i++)
    {
      if (te::common::Convert2LCase(arithExpVec[static_cast<size_t>(i)]) == "gain")
      {
        m_operationExt += " " + std::string(m_ui->m_gainLineEdit->text().toUtf8().data());
        m_operation += " " + std::string(m_ui->m_gainLineEdit->text().toUtf8().data());
      }
      else if (te::common::Convert2LCase(arithExpVec[i]) == "offset")
      {
        m_operationExt += " " + std::string(m_ui->m_offsetLineEdit->text().toUtf8().data());
        m_operation += " " + std::string(m_ui->m_offsetLineEdit->text().toUtf8().data());
      }
      else
      {
        std::vector<std::string> layerVec;
        boost::split(layerVec, arithExpVec[i], boost::is_any_of(":"));

        if (layerVec.size() == 1)
        {
          m_operationExt += " " + arithExpVec[i];
          m_operation += " " + arithExpVec[i];
        }
        else
        {
          int nrows = m_ui->m_layersTableWidget->rowCount();

          for (int j = 0; j < nrows; j++)
          {
            std::string header = m_ui->m_layersTableWidget->verticalHeaderItem(j)->text().toUtf8().data();

            if (header == layerVec[0])
            {
              int index = m_layersComboBox[j]->currentIndex();
              m_mapLayer.insert(std::map<std::string, te::map::AbstractLayer*>::value_type(header, m_layers[index].get()));

              m_operationExt += " " + std::string(m_layersComboBox[j]->currentText().toUtf8().data()) + ":B" + m_bandsComboBox[j]->currentText().toUtf8().data();
              m_operation += " " + std::string(m_ui->m_layersTableWidget->verticalHeaderItem(j)->text().toUtf8().data()) + ":" + m_bandsComboBox[j]->currentText().toUtf8().data();
              break;
            }
          }
        }
      }
    }
  }

  accept();
}

bool te::qt::widgets::LoadArithmeticOpDialog::isDefaultArithmeticOperation(const std::string& operation)
{
  std::string path = te::core::FindInTerraLibPath("share/terralib/json/arithmeticOperations.json");

  QFile file(QString::fromStdString(path));

  if(!file.exists())
    throw te::common::Exception(TE_TR("The file with default operations was not found."));

  bool isDefaultOperation = false;

  boost::property_tree::ptree pt;

  boost::property_tree::json_parser::read_json(path, pt);

  for(boost::property_tree::ptree::value_type &v: pt.get_child("operations"))
  {
    std::string op = v.second.get<std::string>("operation");

    if (te::common::Convert2UCase(op) == te::common::Convert2UCase(operation))
        isDefaultOperation = true;
  }

  return isDefaultOperation;
}