TimeViewerDockWidget.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/plugins/timeviewee/plugin.cpp

  \brief Add a plugin interface for dynamic loading of TimeViewer plugin.

  \author Matheus Cavassan Zaglia
  \author Carolina Galvão dos Santos
  \author Fabiana Zioti
 */

// Terralib
#include "TimeViewerDockWidget.h"
#include "../../..//dataaccess/query/EqualTo.h"
#include "../../../Exception.h"
#include "../../../color/ColorBar.h"
#include "../../../color/ColorScheme.h"
#include "../../../color/ColorSchemeCatalog.h"
#include "../../../color/ColorSchemeCatalogManager.h"
#include "../../../color/ColorSchemeGroup.h"
#include "../../../color/RGBAColor.h"
#include "../../../common/Globals.h"
#include "../../../common/STLUtils.h"
#include "../../../dataaccess/datasource/DataSourceManager.h"
#include "../../../dataaccess/query/And.h"
#include "../../../dataaccess/query/DataSetName.h"
#include "../../../dataaccess/query/Field.h"
#include "../../../dataaccess/query/From.h"
#include "../../../dataaccess/query/FromItem.h"
#include "../../../dataaccess/query/GreaterThanOrEqualTo.h"
#include "../../../dataaccess/query/LessThanOrEqualTo.h"
#include "../../../dataaccess/query/LiteralString.h"
#include "../../../dataaccess/query/OrderBy.h"
#include "../../../dataaccess/query/OrderByItem.h"
#include "../../../dataaccess/query/PropertyName.h"
#include "../../../dataaccess/query/SQLVisitor.h"
#include "../../../dataaccess/query/Select.h"
#include "../../../dataaccess/query/Where.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../fe.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../maptools/AbstractLayer.h"
#include "../../../maptools/Grouping.h"
#include "../../../maptools/GroupingAlgorithms.h"
#include "../../../maptools/MapDisplay.h"
#include "../../../maptools/Utils.h"
#include "../../../se/ColorMap.h"
#include "../../../se/PolygonSymbolizer.h"
#include "../../../se/Rule.h"
#include "../../../se/Style.h"
#include "../../../se/Utils.h"
#include "../../af/ApplicationController.h"
#include "../../af/BaseApplication.h"
#include "../../af/connectors/MapDisplay.h"
#include "../../af/events/LayerEvents.h"
#include "../../af/events/MapEvents.h"
#include "../../widgets/Utils.h"
#include "../../widgets/canvas/Canvas.h"
#include "../../widgets/canvas/MapDisplay.h"
#include "../../widgets/layer/explorer/LayerItemView.h"
#include "../../widgets/se/GroupingDialog.h"
#include "TimeViewerEditLegendDialog.h"
#include "ui_TimeViewerWidget.h"

// Boost
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

// QT
#include <QtConcurrent/qtconcurrentrun.h>
#include <QDateTime>
#include <QIcon>
#include <QList>
#include <QMenu>
#include <QMessageBox>
#include <QSize>
#include <QVBoxLayout>

// STL
#include <algorithm>
#include <iostream>

te::qt::plugins::tv::TimeViewerDockWidget::TimeViewerDockWidget(QWidget* parent)
    : QDockWidget(parent),
      m_ui(new Ui::TimeViewerWidget),
      m_accumulate(false),
      m_sliderThr(false),
      m_drawingLoop(nullptr),
      m_dsPtr(nullptr),
      m_layer(nullptr)

{
  te::qt::af::AppCtrlSingleton::getInstance().addListener(this,te::qt::af::BOTH);

  m_mainWidget = new QWidget(this);
  m_mainWidget->setMinimumSize(0, 0);

  m_ui->setupUi(m_mainWidget);
  m_app = qobject_cast<te::qt::af::BaseApplication*>(
      te::qt::af::AppCtrlSingleton::getInstance().getMainWindow());

  m_editLegendDialog.reset(new te::qt::plugins::tv::TimeViewerEditLegendDialog(this));
  m_editAccumulateDialog.reset(new te::qt::plugins::tv::TimeViewerEditAccumulateDialog(this));

  setWindowTitle("Time Viewer");
  setWindowIcon(QIcon::fromTheme("time-viewer"));

  // add button icons
  m_ui->m_stopToolButton->setIcon(QIcon::fromTheme("media-playback-stop"));
  m_ui->m_backToolButton->setIcon(QIcon::fromTheme("media-skip-backward"));
  m_ui->m_passToolButton->setIcon(QIcon::fromTheme("media-skip-forward"));
  m_ui->m_pauseToolButton->setIcon(QIcon::fromTheme("media-playback-pause"));
  m_ui->m_playToolButton->setIcon(QIcon::fromTheme("media-playback-start"));

  // slider buttons
  connect(m_ui->m_stopToolButton, SIGNAL(clicked()), this,SLOT(onStopButtonClicked()));
  connect(m_ui->m_backToolButton, SIGNAL(clicked()), this,SLOT(onBackButtonClicked()));
  connect(m_ui->m_passToolButton, SIGNAL(clicked()), this,SLOT(onPassButtonClicked()));
  connect(m_ui->m_playToolButton, SIGNAL(clicked()), this,SLOT(onPlayButtonClicked()));
  connect(m_ui->m_pauseToolButton, SIGNAL(clicked()), this,SLOT(onPauseButtonClicked()));

  setupLayerCombo();
  setupSlider();

  // accumulate
  m_ui->m_accumPushButton->setEnabled(false);
  connect(m_ui->m_accumulate, SIGNAL(toggled(bool)), this,SLOT(onAccumulateSelect()));

  // legend
  connect(m_ui->m_applyButton, SIGNAL(clicked()), this, SLOT(onApplyButtonClicked()));
  connect(m_ui->m_legendPushButton, SIGNAL(clicked()), this,SLOT(onLegendButtoClicked()));
  connect(m_ui->m_accumPushButton, SIGNAL(clicked()), this,SLOT(onAccumulateButtonClicked()));

  // dialog
  connect(m_editLegendDialog.get(), SIGNAL(okPushButtonClicked()), this,SLOT(onEditLegendApplyClicked()));
  connect(m_editAccumulateDialog.get(), SIGNAL(okAccPushButtonClicked()), this, SLOT(onAccumulateOkClicked()));

  this->setWidget(m_mainWidget);

  m_app->addDockWidget(Qt::BottomDockWidgetArea, this);
}

void te::qt::plugins::tv::TimeViewerDockWidget::setupSlider()
{
  m_ui->m_timeSlider->setMinimum(0);
  m_ui->m_timeSlider->setSingleStep(1);
  m_ui->m_timeSlider->setTracking(false);

  connect(m_ui->m_timeSlider, SIGNAL(valueChanged(int)), this,SLOT(onSliderChanged()));
}

te::qt::plugins::tv::TimeViewerDockWidget::~TimeViewerDockWidget()
{
  auto layerList = m_app->getLayerExplorer()->getAllLayers();
  auto it = std::find_if(layerList.begin(), layerList.end(),
                         [this](te::map::AbstractLayerPtr layer) {
                           return m_layer->getTitle() == layer->getTitle();
                         });

  if(it != layerList.end())
  {
    layerList.remove(*it);
    m_app->getLayerExplorer()->setLayers(layerList);
    auto mapDisplay = m_app->getMapDisplay();
    mapDisplay->setLayerList(m_app->getLayerExplorer()->getAllLayers());
  }

  te::qt::af::AppCtrlSingleton::getInstance().removeListener(this);
  delete m_ui;
}

void te::qt::plugins::tv::TimeViewerDockWidget::setupLayerCombo()
{
  te::qt::af::evt::GetAvailableLayers e;

  emit triggered(&e);

  m_ui->m_layerCBox->addItem("");
  for(auto layer : e.m_layers)
  {
    m_ui->m_layerCBox->addItem(layer->getDataSetName().c_str(),layer->getDataSourceId().c_str());
  }

  connect(m_ui->m_layerCBox, SIGNAL(activated(int)), this,SLOT(onLayerCBoxSelected(int)));
}

void te::qt::plugins::tv::TimeViewerDockWidget::onLayerCBoxSelected(int index)
{
  m_datasetName = m_ui->m_layerCBox->itemText(index).toUtf8().data();
  m_dsId = m_ui->m_layerCBox->itemData(index).toString().toUtf8().data();

  if(m_datasetName.empty())
    return;

  m_ui->m_startDateCBox->clear();
  m_ui->m_endDateCBox->clear();
  m_ui->m_startDateCBox->addItem("");
  m_ui->m_endDateCBox->addItem("");

  m_ui->m_accumulate->setChecked(false);
  m_ui->m_accumPushButton->setEnabled(false);

  m_dsPtr = te::da::DataSourceManager::getInstance().find(m_dsId);

  if(m_dsPtr->getType() != "POSTGIS")
  {
    QMessageBox::warning(0, "TimeViewer", "Unsupported datasource");
    return;
  }
  auto properties = m_dsPtr->getPropertyNames(m_datasetName);
  for(auto propertie : properties)
  {
    m_ui->m_startDateCBox->addItem(propertie.c_str());
    m_ui->m_endDateCBox->addItem(propertie.c_str());
  }
}

std::string generateId()
{
  static boost::uuids::basic_random_generator<boost::mt19937> gen;
  boost::uuids::uuid u = gen();
  return boost::uuids::to_string(u);
}

void te::qt::plugins::tv::TimeViewerDockWidget::setupLayer()
{
  auto dsTypePtr = m_dsPtr->getDataSetType(m_datasetName);
  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(dsTypePtr.get());

  if(m_layer == nullptr)
    m_layer.reset(new te::map::QueryLayer(generateId(), "TimeViewer Layer"));

  m_layer->setDataSourceId(m_dsId);
  m_layer->setDataSetName(m_datasetName);
  m_layer->setRendererType("QUERY_LAYER_RENDERER");
  m_layer->setSRID(gp->getSRID());
  m_layer->setGeomPropertytName(gp->getName());
  m_layer->setVisibility(te::map::VISIBLE);

  // if m_accumulate is true older geoms must have a different color
  if(m_layer->getStyle() == nullptr)
  {
    auto style = te::se::CreateFeatureTypeStyle(gp->getGeometryType());
    m_layer->setStyle(style);
  }
}

void te::qt::plugins::tv::TimeViewerDockWidget::onPauseButtonClicked()
{
  m_sliderThr = false;
  m_ui->m_timeSlider->setEnabled(true);
}

void te::qt::plugins::tv::TimeViewerDockWidget::onStopButtonClicked()
{
  m_sliderThr = false;
  m_ui->m_timeSlider->setValue(m_ui->m_timeSlider->maximum());
  m_ui->m_timeSlider->setEnabled(true);

  return;
}

void te::qt::plugins::tv::TimeViewerDockWidget::onPassButtonClicked()
{
  int value = m_ui->m_timeSlider->value();
  if(!(value == m_ui->m_timeSlider->maximum()))
  {
    m_ui->m_timeSlider->setValue(++value);
  }
}

void te::qt::plugins::tv::TimeViewerDockWidget::onBackButtonClicked()
{
  int value = m_ui->m_timeSlider->value();
  if(!(value == 0))
  {
    m_ui->m_timeSlider->setValue(--value);
  }
}

void te::qt::plugins::tv::TimeViewerDockWidget::onPlayButtonClicked()
{
  m_future = QtConcurrent::run(this, &te::qt::plugins::tv::TimeViewerDockWidget::setupPlayer);
}
void te::qt::plugins::tv::TimeViewerDockWidget::setupPlayer()
{
  int min_value;
  int max_value = m_ui->m_timeSlider->maximum();

  m_sliderThr = true;

  if(m_ui->m_timeSlider->value() == max_value)
  {
    m_ui->m_timeSlider->setValue(0);
  }

  m_ui->m_timeSlider->setEnabled(false);

  for(min_value = m_ui->m_timeSlider->value(); min_value <= max_value;
      min_value++)
  {
    while(m_drawing == true)
    {
      QThread::currentThread()->msleep(250);
    }
    if(m_sliderThr == true && m_drawing == false)
    {
      QThread::currentThread()->msleep(2000);
      m_ui->m_timeSlider->setValue(min_value);
    }
  }

  m_ui->m_timeSlider->setEnabled(true);

  m_sliderThr = false;
}

void te::qt::plugins::tv::TimeViewerDockWidget::setupLayerInt()
{
  // create layer with all attr
  std::string query = "SELECT * FROM " + m_datasetName;
  auto result = m_dsPtr->query(query);

  setupLayer();

  std::string alias = "timeviewer";

  te::da::FromItem* fromItem = new te::da::DataSetName(m_datasetName, alias);
  te::da::From* from = new te::da::From;
  from->push_back(fromItem);

  te::da::Fields* fields = new te::da::Fields;

  auto properties = m_dsPtr->getPropertyNames(m_datasetName);
  for(auto propertie : properties)
  {
    fields->push_back(new te::da::Field(alias + "." + propertie));
  }

  auto dsTypePtr = m_dsPtr->getDataSetType(m_datasetName);

  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(dsTypePtr.get());

  fields->push_back(new te::da::Field(alias + "." + gp->getName()));

  te::da::Select* select = new te::da::Select();
  select->setFrom(from);
  select->setFields(fields);

  std::string sql;
  te::da::SQLVisitor visitor(*m_dsPtr->getDialect(), sql);
  visitor.visit(select);

  m_layer->setQuery(select);
  m_layer->computeExtent();
}

void te::qt::plugins::tv::TimeViewerDockWidget::onAccumulateButtonClicked()
{
  m_editAccumulateDialog->show();
  m_editAccumulateDialog->setColors(m_accumColor);
}

void te::qt::plugins::tv::TimeViewerDockWidget::onLegendButtoClicked()
{
  if(m_datasetName.empty())
  {
    QMessageBox::warning(
        0, "TimeViewer",
        "There is no layer selected. \nPlease select one before edit legend");
    return;
  }

  // create layer with all attr
  setupLayerInt();

  m_editLegendDialog->show();
  m_editLegendDialog->setLayers(m_layer);
}

void te::qt::plugins::tv::TimeViewerDockWidget::onApplyButtonClicked()
{
  if(m_datasetName.empty())
  {
    QMessageBox::warning(
        0, "TimeViewer",
        "There is no layer selected. \nPlease select one before applying");
    return;
  }

  m_start = m_ui->m_startDateCBox->currentText().toUtf8().data();
  m_end = m_ui->m_endDateCBox->currentText().toUtf8().data();

  if(m_start.empty())
  {
    QMessageBox::warning(0, "TimeViewer",
                         "There is no start date attribute selected. \nPlease "
                         "select one before applying");
    return;
  }

  std::string query = "SELECT " + m_start +
                      " as date"
                      " FROM " +
                      m_datasetName + " GROUP BY " + m_start;

  if(!m_end.empty())
  {
    query +=
        " UNION"
        " SELECT " +
        m_end +
        " as date"
        " FROM " +
        m_datasetName + " GROUP BY " + m_end;
  }

  query += " ORDER BY date";

  auto result = m_dsPtr->query(query);

  result->moveBeforeFirst();

  while(result->moveNext())
  {
    m_dates.push_back(result->getAsString("date"));
  }

  m_ui->m_timeSlider->setMaximum(m_dates.size() - 1);

  setupLayerInt();

  auto layerList = m_app->getLayerExplorer()->getAllLayers();
  auto it = std::find_if(layerList.begin(), layerList.end(),
                         [this](te::map::AbstractLayerPtr layer) {
                           return m_layer->getTitle() == layer->getTitle();
                         });

  if(it == layerList.end())
  {
    layerList.push_front(m_layer);
    m_app->getLayerExplorer()->setLayers(layerList);
    auto mapDisplay = m_app->getMapDisplay();
    mapDisplay->setLayerList(m_app->getLayerExplorer()->getAllLayers());
  }

  m_ui->m_timeSlider->blockSignals(true);
  m_ui->m_timeSlider->setValue(0);
  m_ui->m_timeSlider->blockSignals(false);

  onSliderChanged();
}

void te::qt::plugins::tv::TimeViewerDockWidget::onSliderChanged()
{
  int index = m_ui->m_timeSlider->value();

  std::string date = m_dates[index];

  te::da::LiteralString* literal = new te::da::LiteralString(date);

  std::string alias = "timeviewer";

  te::da::FromItem* fromItem = new te::da::DataSetName(m_datasetName, alias);
  te::da::From* from = new te::da::From;
  from->push_back(fromItem);

  te::da::Fields* fields = new te::da::Fields;

  auto properties = m_dsPtr->getPropertyNames(m_datasetName);
  for(auto propertie : properties)
  {
    fields->push_back(new te::da::Field(alias + "." + propertie));
  }

  auto dsTypePtr = m_dsPtr->getDataSetType(m_datasetName);

  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(dsTypePtr.get());

  fields->push_back(new te::da::Field(alias + "." + gp->getName()));

  te::da::Where* where = nullptr;
  te::da::PropertyName* start = new te::da::PropertyName(m_start);
  te::da::PropertyName* end = new te::da::PropertyName(m_end);
  te::da::Expression* expression = nullptr;
  te::da::Expression* expression2 = nullptr;
  te::da::And* aand = nullptr;

  // form Query
  if(m_ui->m_accumulate->isChecked())
  {
    if(m_end.empty())
      expression = new te::da::LessThanOrEqualTo(start, literal);

    else
      expression = new te::da::LessThanOrEqualTo(end, literal);

    where = new te::da::Where(expression);
  }

  else
  {
    if(m_end.empty())
    {
      expression = new te::da::EqualTo(start, literal);

      where = new te::da::Where(expression);
    }
    else
    {
      expression = new te::da::GreaterThanOrEqualTo(start, literal);
      te::da::LiteralString* literal2 = new te::da::LiteralString(date);
      expression2 = new te::da::LessThanOrEqualTo(end, literal2);
      aand = new te::da::And(expression, expression2);

      where = new te::da::Where(aand);
    }
  }

  te::da::Select* select = new te::da::Select();
  select->setWhere(where);
  select->setFrom(from);
  select->setFields(fields);

  std::string sql;
  te::da::SQLVisitor visitor(*m_dsPtr->getDialect(), sql);
  visitor.visit(select);

  m_layer->setQuery(select);
  m_layer->computeExtent();

  // Use Legend
  if(m_ui->m_accumulate->isChecked())
  {
    te::se::Style* sty = m_layer->getStyle()->clone();

    sty->removeRules();

    std::string dateAttr = m_ui->m_startDateCBox->currentText().toUtf8().data();

    te::fe::PropertyName* propName = new te::fe::PropertyName(dateAttr);
    te::fe::Literal* propValue = new te::fe::Literal(date);

    te::fe::BinaryComparisonOp* less = new te::fe::BinaryComparisonOp(te::fe::Globals::sm_propertyIsLessThan, propName, propValue);

    te::fe::Filter* filter = new te::fe::Filter;
    filter->setOp(less);

    te::se::Rule* general = new te::se::Rule;
    general->setFilter(filter);

    std::vector<te::se::Symbolizer*> symbVec;
    te::se::Symbolizer* s;
    s = te::se::CreateSymbolizer(gp->getGeometryType(),m_accumColor.toUtf8().data());

    symbVec.push_back(s);
    general->setSymbolizers(symbVec);

    sty->push_back(general);

    if(m_rules.empty())
    {
      te::se::Rule* ruleActual = new te::se::Rule;
      ruleActual->setFilter(te::fe::CreateFilterByUniqueValue(dateAttr, date));

      std::vector<te::se::Symbolizer*> symbVecAct;
      te::se::Symbolizer* symbAct;
      symbAct = te::se::CreateSymbolizer(gp->getGeometryType(), "#3c9c3d");

      symbVecAct.push_back(symbAct);
      ruleActual->setSymbolizers(symbVecAct);

      sty->push_back(ruleActual);
    }

    else
    {
      for(std::size_t t = 0; t < m_rules.size(); ++t)
      {
        te::se::Rule* r = new te::se::Rule;
        r = m_rules[t]->clone();

        const te::fe::Filter* currentFilter = m_rules[t]->getFilter();
        te::fe::AbstractOp* currentOp = currentFilter->getOp()->clone();

        te::fe::PropertyName* currentPropName = new te::fe::PropertyName(dateAttr);
        te::fe::Literal* currentPropValue = new te::fe::Literal(date);
        te::fe::BinaryComparisonOp* equal = new te::fe::BinaryComparisonOp(te::fe::Globals::sm_propertyIsEqualTo, currentPropName,currentPropValue);
        te::fe::BinaryLogicOp* andOp = new te::fe::BinaryLogicOp(te::fe::Globals::sm_and, currentOp, equal);

        te::fe::Filter* filterB = new te::fe::Filter;
        filterB->setOp(andOp);
        r->setFilter(filterB);

        sty->push_back(r);
      }
    }

    m_layer->setStyle(sty);
  }

  else if(!m_rules.empty() && m_ui->m_timeSlider->value() == 0)
  {
    te::se::Style* style_t = m_layer->getStyle();
    te::se::Style* style = style_t->clone();

    style->removeRules();

    for(std::size_t t = 0; t < m_rules.size(); ++t)
    {
      te::se::Rule* rule = m_rules[t]->clone();
      style->push_back(rule);
    }

    m_layer->setStyle(style);
  }

  drawLayer();
}

void te::qt::plugins::tv::TimeViewerDockWidget::drawLayer()
{
  auto mapDisplay = m_app->getMapDisplay();
  if(mapDisplay->getSRID() == 0)
  {
    mapDisplay->setSRID(m_layer->getSRID());
    std::pair<int, std::string> srid(mapDisplay->getSRID(), "EPSG");
    te::qt::af::evt::MapSRIDChanged evt(srid);
    emit triggered(&evt);
  }

  auto extent = m_layer->getExtent();

  m_drawing = true;
  mapDisplay->setExtent(extent, true);
}

void te::qt::plugins::tv::TimeViewerDockWidget::onEditLegendApplyClicked()
{
  m_rules = m_editLegendDialog->getRules();
}

void te::qt::plugins::tv::TimeViewerDockWidget::onAccumulateOkClicked()
{
  m_accumColor = m_editAccumulateDialog->getAccumColor();
}
void te::qt::plugins::tv::TimeViewerDockWidget::onAccumulateSelect()
{
  m_ui->m_accumPushButton->setEnabled(true);
}

void te::qt::plugins::tv::TimeViewerDockWidget::onApplicationTriggered(
    te::qt::af::evt::Event* e)
{
  switch(e->m_id)
  {
    case te::qt::af::evt::DRAWING_FINISHED:
    {
      m_drawing = false;
      break;
    }
    default:
      break;
  }
}