PCAWizard.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>.
 */

#include "PCAWizard.h"

//Terralib
#include "../../../dataaccess/utils/Utils.h"
#include "../../../rp/Functions.h"
#include "../../../common/StringUtils.h"
#include "../../../raster/Band.h"
#include "../../../raster/BandProperty.h"
#include "../../../raster/RasterFactory.h"
#include "../../../raster/Grid.h"
#include "../help/HelpPushButton.h"
#include "../layer/search/LayerSearchWidget.h"
#include "../layer/search/LayerSearchWizardPage.h"
#include "../progress/ProgressViewerDialog.h"
#include "../utils/ScopedCursor.h"
#include "PCAWizardPage.h"
#include "../raster/RasterInfoWidget.h"
#include "RasterInfoWizardPage.h"
#include "Utils.h"

#include <boost/lexical_cast.hpp>

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

#include <fstream>
#include <cstdio>
#include <cmath>

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

  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_pca.html");

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

  addPages();
}

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

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

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

      if( layerPtr.get() != nullptr )
        m_wizardPage->setLayer(layerPtr);
    }

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

  return true;
}

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

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

void te::qt::widgets::PCAWizard::addPages()
{
  m_layerSearchPage.reset(new LayerSearchWizardPage(this));
  m_layerSearchPage->getSearchWidget()->enableMultiSelection(false);
  addPage(m_layerSearchPage.get());

  m_wizardPage.reset(new PCAWizardPage(this));
  addPage(m_wizardPage.get());
  
  m_rasterInfoPage.reset(new te::qt::widgets::RasterInfoWizardPage(this));
  addPage(m_rasterInfoPage.get());

  this->resize(m_wizardPage->sizeHint());
}

void te::qt::widgets::PCAWizard::setLayer(te::map::AbstractLayerPtr layer)
{
  m_wizardPage->setLayer( layer );
}

bool te::qt::widgets::PCAWizard::execute()
{
  if(m_rasterInfoPage->getWidget()->fileExists())
  {
    QMessageBox::warning(this, tr("PCA"), tr("File already exists."));
    return false;
  }

  //get layer

  std::list<te::map::AbstractLayerPtr> list = m_layerSearchPage->getSearchWidget()->getSelecteds();
  te::map::AbstractLayerPtr l = *list.begin();

  // input raster

  std::unique_ptr<te::rst::Raster> inputRst;

  {
    //get input raster
    std::unique_ptr<te::da::DataSet> ds = l->getData();

    if (ds.get() == nullptr )
    {
      QMessageBox::critical(this, tr("PCA"), tr("Invalid layer.") );
      return false;
    }

    std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);

    inputRst = ds->getRaster(rpos);
  }

  const std::vector< unsigned int > inputRasterBands = m_wizardPage->getSelectedBands();

  if( inputRasterBands.empty() )
  {
    QMessageBox::critical(this, tr("PCA"), tr("No selected bands.") );
    return false;
  }

  // matrix

  const std::string matrixFileName = m_wizardPage->getMatrixFileName();

  if( m_wizardPage->inversePCASelected() && matrixFileName.empty() )
  {
    QMessageBox::critical(this, tr("PCA"), tr("Invalid matrix file name.") );
    return false;
  }

  std::fstream matrixFile;
  boost::numeric::ublas::matrix< double >  matrix;

  if( m_wizardPage->inversePCASelected() )
  {
    matrixFile.open( matrixFileName.c_str(), std::fstream::in );
    if( !matrixFile.good() )
    {
      QMessageBox::critical(this, tr("PCA"), tr("Invalid matrix file.") );
      return false;
    }

    matrixFile.seekg( 0 );

    std::string lineStr;
    std::getline( matrixFile, lineStr );

    std::vector< std::string > tokens;
    te::common::Tokenize( lineStr, tokens, ";" );

    const std::size_t matrixSize = (std::size_t)std::sqrt( tokens.size() );
    std::size_t tokensIdx = 0;

    matrix.resize( matrixSize, matrixSize );

    for( std::size_t row = 0 ; row < matrixSize ; ++row )
    {
      for( std::size_t col = 0 ; col < matrixSize ; ++col )
      {
        if( tokensIdx >= tokens.size() )
        {
          QMessageBox::critical(this, tr("PCA"), tr("Invalid matrix file.") );
          return false;
        }

        matrix( row, col ) = boost::lexical_cast< double >( tokens[ tokensIdx ] );
        ++tokensIdx;
      }
    }
  }
  else
  {
    if( ! matrixFileName.empty() )
    {
      matrixFile.open( matrixFileName.c_str(), std::fstream::out | std::fstream::trunc );

      if( !matrixFile.good() )
      {
        QMessageBox::critical(this, tr("PCA"), tr("Invalid matrix file.") );
        return false;
      }
    }
  }

  // output raster

  std::unique_ptr<te::rst::Raster> outputRasterPtr;
  std::vector< unsigned int > outputRasterBands;

  {
    std::vector< te::rst::BandProperty * > bandProps;

    for( unsigned int bandIdx = 0 ; bandIdx < inputRasterBands.size() ;
      ++bandIdx )
    {
      bandProps.push_back( new te::rst::BandProperty(
        *( inputRst->getBand( inputRasterBands[ bandIdx ] )->getProperty() ) ) );
      bandProps.back()->m_type = m_wizardPage->getOutputRasterDataType();
      bandProps.back()->m_blkh = bandProps.front()->m_blkh;
      bandProps.back()->m_blkw = bandProps.front()->m_blkw;
      bandProps.back()->m_nblocksx = bandProps.front()->m_nblocksx;
      bandProps.back()->m_nblocksy = bandProps.front()->m_nblocksy;

      outputRasterBands.push_back( bandIdx );
    }

    try
    {
      outputRasterPtr.reset( te::rst::RasterFactory::make(
        m_rasterInfoPage->getWidget()->getType(),
        new te::rst::Grid( *( inputRst->getGrid() ) ), bandProps,
        m_rasterInfoPage->getWidget()->getInfo(), nullptr, nullptr ) );
    }
    catch(...)
    {
      outputRasterPtr.reset();
    }

    if( outputRasterPtr.get() == nullptr )
    {
      QMessageBox::critical(this, tr("PCA"), tr("Output raster creation error.") );
      return false;
    }
  }

  // Execute

  QApplication::setOverrideCursor(Qt::WaitCursor);

  if( m_wizardPage->inversePCASelected() )
  {
    // inverse PCA

    if( ! te::rp::InversePrincipalComponents( *inputRst, matrix, *outputRasterPtr,
      outputRasterBands, 0 ) )
    {
      QMessageBox::critical(this, tr("PCA"), tr("PCA processing error.") );

      QApplication::restoreOverrideCursor();

      return false;
    }
  }
  else
  {
    // direct PCA

    if( ! te::rp::DirectPrincipalComponents( *inputRst, inputRasterBands, matrix,
        *outputRasterPtr, outputRasterBands, 0 ) )
    {
      QMessageBox::critical(this, tr("PCA"), tr("PCA processing error.") );

      QApplication::restoreOverrideCursor();

      return false;
    }

    for( std::size_t row = 0 ; row < matrix.size1() ; ++row )
    {
      for( std::size_t col = 0 ; col < matrix.size2() ; ++col )
      {
        matrixFile << boost::lexical_cast< std::string >( matrix( row, col ) );
        matrixFile << ";";
      }
    }
  }

  QApplication::restoreOverrideCursor();

  //set output layer

  outputRasterPtr.reset();

  m_outputLayer = te::qt::widgets::createLayer(m_rasterInfoPage->getWidget()->getType(),
    m_rasterInfoPage->getWidget()->getInfo());

  QMessageBox::information(this, tr("PCA"), tr("PCA ended sucessfully"));

  return true;
}

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