SegmenterAdvancedOptionsWizardPage.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/SegmenterAdvancedOptionsWizardPage.h

  \brief This file defines a class for a Segmenter Advanced Options Wizard page.
*/

// TerraLib
#include "../../../common/Exception.h"
#include "../../../core/translator/Translator.h"
#include "../../../rp/Segmenter.h"
#include "../../../maptools/Utils.h"
#include "SegmenterAdvancedOptionsWizardPage.h"
#include "ui_SegmenterAdvancedOptionsWizardPageForm.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>

te::qt::widgets::SegmenterAdvancedOptionsWizardPage::SegmenterAdvancedOptionsWizardPage(QWidget* parent)
  : QWizardPage(parent),
    m_ui(new Ui::SegmenterAdvancedOptionsWizardPageForm)
{
// setup controls
  m_ui->setupUi(this);

//configure page
  this->setTitle(tr("Segmenter Advanced Options"));
  this->setSubTitle(tr("Used to set the segmenter advanced options."));

  te::rp::Segmenter::InputParameters input;

  QString threadNumber;
  threadNumber.setNum(input.m_maxSegThreads);

  QString maxBlockSize;
  maxBlockSize.setNum(input.m_maxBlockSize);

  m_ui->m_enableThreadedProcessingcheckBox->setChecked(input.m_enableThreadedProcessing);
  m_ui->m_maximumThreadsNumberLineEdit->setText(threadNumber);
//  m_ui->m_enableBlockProcessingcheckBox->setChecked(input.m_enableBlockProcessing);
  m_ui->m_blockOverlapPercentSpinBox->setValue(input.m_blocksOverlapPercent);
  m_ui->m_maximumBlockSizeLineEdit->setText(maxBlockSize);
}

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

Ui::SegmenterAdvancedOptionsWizardPageForm* te::qt::widgets::SegmenterAdvancedOptionsWizardPage::getForm() const
{
  return m_ui.get();
}

void te::qt::widgets::SegmenterAdvancedOptionsWizardPage::applyVectorization()
{
  //check output datasource parameters
  te::da::DataSourceInfoPtr outDSInfo;

  std::string outputdataset = m_name.append(".shp");

  boost::filesystem::path uri(m_path.append("/"+outputdataset));

  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;

  //input parameters
  te::rst::Raster* raster = te::map::GetRaster(m_layer.get());
  unsigned int band = 0;
  unsigned int maxGeom = 0;

  //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)
  {
    throw te::common::Exception(TE_TR(e.what()));

    QApplication::restoreOverrideCursor();

    return;
  }
  catch(...)
  {
    throw te::common::Exception(TE_TR("An exception has occurred!"));

    QApplication::restoreOverrideCursor();

    return;
  }

  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);
  }
  catch(const std::exception& e)
  {
    throw te::common::Exception(TE_TR(e.what()));

    QApplication::restoreOverrideCursor();

    return;
  }
  catch(...)
  {
    throw te::common::Exception(TE_TR("An exception has occurred saving geometries!"));

    QApplication::restoreOverrideCursor();

    return;
  }

  QApplication::restoreOverrideCursor();
}

void te::qt::widgets::SegmenterAdvancedOptionsWizardPage::set(te::map::AbstractLayerPtr layer)
{
  m_layer = layer;
}

void te::qt::widgets::SegmenterAdvancedOptionsWizardPage::setOutputLayerPath(const std::string& path)
{
  m_path = path;
}

void te::qt::widgets::SegmenterAdvancedOptionsWizardPage::setOutputLayerName(const std::string& name)
{
  m_name = name;
}

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

std::unique_ptr<te::da::DataSetType> te::qt::widgets::SegmenterAdvancedOptionsWizardPage::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::SegmenterAdvancedOptionsWizardPage::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::SegmenterAdvancedOptionsWizardPage::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);
}