VectorizationWizard.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 "../../../common/progress/ProgressManager.h"
#include "../../../dataaccess/datasource/DataSource.h"
#include "../../../dataaccess/datasource/DataSourceInfoManager.h"
#include "../../../dataaccess/datasource/DataSourceInfoManager.h"
#include "../../../dataaccess/datasource/DataSourceManager.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../core/filesystem/FileSystem.h"
#include "../../../datatype/SimpleProperty.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../memory/DataSet.h"
#include "../../../memory/DataSetItem.h"
#include "../../widgets/layer/utils/DataSet2Layer.h"
#include "../help/HelpPushButton.h"
#include "../layer/search/LayerSearchWidget.h"
#include "../layer/search/LayerSearchWizardPage.h"
#include "../progress/ProgressViewerDialog.h"
#include "VectorizationWizard.h"
#include "VectorizationWizardPage.h"

// BOOST
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

// Qt
#include <QApplication>
#include <QMessageBox>

te::qt::widgets::VectorizationWizard::VectorizationWizard(QWidget* parent) :
QWizard(parent)
{
  this->setWizardStyle(QWizard::ModernStyle);
  this->setWindowTitle(tr("Vectorization"));

  this->setOption(QWizard::HaveHelpButton, true);
  this->setOption(QWizard::HelpButtonOnRight, false);

  te::qt::widgets::HelpPushButton* helpButton = new te::qt::widgets::HelpPushButton(this);

  this->setButton(QWizard::HelpButton, helpButton);

  helpButton->setPageReference("plugins/rp/rp_vectorization.html");

  connect(this, SIGNAL(currentIdChanged(int)), SLOT(onPageChanged(int)));

  addPages();
}

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

bool te::qt::widgets::VectorizationWizard::validateCurrentPage()
{
  if(currentPage() ==  m_layerSearchPage.get())
  {
    std::list<te::map::AbstractLayerPtr> list = m_layerSearchPage->getSearchWidget()->getSelecteds();

    if(list.empty() == false)
    {
      te::map::AbstractLayerPtr l = *list.begin();

      m_vectorPage->setLayer(l);
    }

    return m_layerSearchPage->isComplete();
  }
  else if(currentPage() ==  m_vectorPage.get())
  {
    return execute();
  }

  return true;
}

void te::qt::widgets::VectorizationWizard::setList(std::list<te::map::AbstractLayerPtr> &layerList)
{
  m_layerSearchPage->getSearchWidget()->setList(layerList);
  m_layerSearchPage->getSearchWidget()->filterOnlyByRaster();
}

te::map::AbstractLayerPtr te::qt::widgets::VectorizationWizard::getOutputLayer()
{
  return m_outputLayer;
}

void te::qt::widgets::VectorizationWizard::addPages()
{
  m_layerSearchPage.reset(new LayerSearchWizardPage(this));
  addPage(m_layerSearchPage.get());

  m_vectorPage.reset(new VectorizationWizardPage(this));
  addPage(m_vectorPage.get());
}

bool te::qt::widgets::VectorizationWizard::execute()
{
  if(te::core::FileSystem::exists(m_vectorPage->getRepositoryName()))
  {
    QMessageBox::warning(this, tr("Vectorization"), tr("File already exists."));
    return false;
  }

  //check output parameters
  std::string outputdataset = m_vectorPage->getLayerName();

  if(outputdataset.empty())
  {
    QMessageBox::warning(this, tr("Vectorizer"), tr("Output dataset name not defined."));
    return false;
  }

  std::string uriStr = m_vectorPage->getRepositoryName();

  if(uriStr.empty())
  {
    QMessageBox::warning(this, tr("Vectorizer"), tr("Output repository name not defined."));
    return false;
  }

  //check output datasource parameters
  te::da::DataSourceInfoPtr outDSInfo;

  bool toFile = m_vectorPage->outputDataSourceToFile();

  if(toFile)
  {
    boost::filesystem::path uri(uriStr);

    std::size_t idx = outputdataset.find(".");
    if(idx != std::string::npos)
      outputdataset = outputdataset.substr(0,idx);

    const std::string connInfo("file://" + uri.string());

    // let's include the new datasource in the managers
    boost::uuids::basic_random_generator<boost::mt19937> gen;
    boost::uuids::uuid u = gen();
    std::string id = boost::uuids::to_string(u);

    te::da::DataSourceInfoPtr ds(new te::da::DataSourceInfo);
    ds->setConnInfo(connInfo);
    ds->setTitle(uri.stem().string());
    ds->setAccessDriver("OGR");
    ds->setType("OGR");
    ds->setDescription(uri.string());
    ds->setId(id);
 
    te::da::DataSourceInfoManager::getInstance().add(ds);
    outDSInfo = ds;
  }
  else
  {
    outDSInfo = m_vectorPage->getDataSourceInfo();
  }

  //input parameters
  std::unique_ptr<te::rst::Raster> raster = m_vectorPage->getRaster();
  unsigned int band = m_vectorPage->getBand();
  unsigned int maxGeom = 0;
  m_vectorPage->hasMaxGeom(maxGeom);

  //output parameters
  std::vector<te::gm::Geometry*> geomVec;
  std::vector< double > geomsValues;

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

  QApplication::setOverrideCursor(Qt::WaitCursor);

  try
  {
    //run operation
    raster->vectorize(geomVec, band, maxGeom, &geomsValues);
  }
  catch(const std::exception& e)
  {
    QMessageBox::warning(this, tr("Vectorizer"), e.what());

    QApplication::restoreOverrideCursor();

    return false;
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("Vectorizer"), tr("An exception has occurred!"));

    QApplication::restoreOverrideCursor();

    return false;
  }

  try
  {
    //save data
    std::unique_ptr<te::da::DataSetType> dsType = createDataSetType(outputdataset, raster->getSRID());

    std::unique_ptr<te::mem::DataSet> dsMem = createDataSet(dsType.get(), geomVec, geomsValues);

    te::da::DataSourcePtr ds = te::da::DataSourceManager::getInstance().get(outDSInfo->getId(), outDSInfo->getType(), outDSInfo->getConnInfo());

    saveDataSet(dsMem.get(), dsType.get(), ds, outputdataset);

    //create output layer
    te::da::DataSourcePtr outDataSource = te::da::GetDataSource(outDSInfo->getId());
    
    te::qt::widgets::DataSet2Layer converter(outDSInfo->getId());
      
    te::da::DataSetTypePtr dt(outDataSource->getDataSetType(outputdataset).release());

    m_outputLayer = converter(dt);

    QMessageBox::information(this, tr("Vectorizer"), tr("Vectorizer ended sucessfully."));
  }
  catch(const std::exception& e)
  {
    QMessageBox::warning(this, tr("Vectorizer"), e.what());

    QApplication::restoreOverrideCursor();

    return false;
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("Vectorizer"), tr("An exception has occurred saving geometries!"));

    QApplication::restoreOverrideCursor();

    return false;
  }

  QApplication::restoreOverrideCursor();

  return true;
}

std::unique_ptr<te::da::DataSetType> te::qt::widgets::VectorizationWizard::createDataSetType(std::string dataSetName, int srid)
{
  std::unique_ptr<te::da::DataSetType> dsType(new te::da::DataSetType(dataSetName));

  //create id property
  te::dt::SimpleProperty* idProperty = new te::dt::SimpleProperty("id", te::dt::INT32_TYPE);
  dsType->add(idProperty);
  
  te::dt::SimpleProperty* valueProperty = new te::dt::SimpleProperty("value", te::dt::DOUBLE_TYPE, true);
  dsType->add(valueProperty);

  //create geometry property
  te::gm::GeometryProperty* geomProperty = new te::gm::GeometryProperty("geom", srid, te::gm::PolygonType);
  dsType->add(geomProperty);

  //create primary key
  std::string pkName = "pk_id";
              pkName+= "_" + dataSetName;
  te::da::PrimaryKey* pk = new te::da::PrimaryKey(pkName, dsType.get());
  pk->add(idProperty);

  return dsType;
}

std::unique_ptr<te::mem::DataSet> te::qt::widgets::VectorizationWizard::createDataSet(te::da::DataSetType* dsType, std::vector<te::gm::Geometry*>& geoms, std::vector< double >& geomsValues)
{
  std::unique_ptr<te::mem::DataSet> ds(new te::mem::DataSet(dsType));

  for(std::size_t t = 0; t < geoms.size(); ++t)
  {
    //create dataset item
    te::mem::DataSetItem* item = new te::mem::DataSetItem(ds.get());

    //set id
    item->setInt32(0, (int)t);
    
    //set Value
    item->setDouble( 1, geomsValues[ t ] );

    //set geometry
    item->setGeometry(2, geoms[t]);

    ds->add(item);
  }

  return ds;
}

void te::qt::widgets::VectorizationWizard::saveDataSet(te::mem::DataSet* dataSet, te::da::DataSetType* dsType, te::da::DataSourcePtr ds, std::string dataSetName)
{
  //save dataset
  dataSet->moveBeforeFirst();

  std::map<std::string, std::string> options;

  ds->createDataSet(dsType, options);

  ds->add(dataSetName, dataSet, options);
}

void te::qt::widgets::VectorizationWizard::onPageChanged(int /*index*/)
{
  this->adjustSize();
}