ClassifierMAPStrategy.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/rp/ClassifierMAPStrategy.cpp

  \brief Maximum a posteriori probability strategy.
*/

// TerraLib

#include "ClassifierMAPStrategy.h"
#include "Macros.h"
#include "../raster/Band.h"
// #include "../common/MatrixUtils.h"
#include "ClassifierAdaptors.h"

#include <cfloat>

namespace
{
  static te::rp::ClassifierMAPStrategyFactory classifierMAPStrategyFactoryInstance;
}

//-----------------------------------------------------------------------------

te::rp::ClassifierMAPStrategy::Parameters::Parameters()
{
  reset();
}

te::rp::ClassifierMAPStrategy::Parameters::~Parameters() = default;

const te::rp::ClassifierMAPStrategy::Parameters& te::rp::ClassifierMAPStrategy::Parameters::operator=(const te::rp::ClassifierMAPStrategy::Parameters& rhs)
{
  reset();

  m_trainSamplesPtr = rhs.m_trainSamplesPtr;
  m_prioriProbs = rhs.m_prioriProbs;
  m_prioriCalcSampleStep = rhs.m_prioriCalcSampleStep;

  return *this;
}

void te::rp::ClassifierMAPStrategy::Parameters::reset() throw(te::rp::Exception)
{
  m_trainSamplesPtr.reset();
  m_prioriProbs.clear();
  m_prioriCalcSampleStep = 5;
}

te::common::AbstractParameters* te::rp::ClassifierMAPStrategy::Parameters::clone() const
{
  return new te::rp::ClassifierMAPStrategy::Parameters( *this );
}

//-----------------------------------------------------------------------------

te::rp::ClassifierMAPStrategy::ClassifierMAPStrategy()
{
  m_isInitialized = false;
  m_highestTrainClassID = 0;
}

te::rp::ClassifierMAPStrategy::~ClassifierMAPStrategy() = default;

bool te::rp::ClassifierMAPStrategy::initialize(
  te::rp::ClassifierStrategyParameters const* const strategyParams) throw(te::rp::Exception)
{
  m_isInitialized = false;
  m_initParams.reset();
  
  ClassifierMAPStrategy::Parameters const * const castParamsPtr = 
    dynamic_cast< ClassifierMAPStrategy::Parameters const * >( strategyParams );
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( castParamsPtr, "Invalid parameters" );
  
  // Checking the input parameters
  
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( castParamsPtr->m_trainSamplesPtr,
    "Invalid classes samples pointer" )
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( castParamsPtr->m_trainSamplesPtr->size() > 0,
    "Invalid classes samples number" )
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( castParamsPtr->m_trainSamplesPtr->begin()->second.size() > 0,
    "Invalid classes samples number" )    

  m_initParams = (*castParamsPtr);

  // Groupping samples

  std::vector< std::vector< double > > samples;
  std::vector<unsigned int> samplesLabels;
  std::vector<unsigned int> samplesAttributesIndices;

  {
    Parameters::MClassesSamplesCT::const_iterator classesSamplesIt = castParamsPtr->m_trainSamplesPtr->begin();
    const Parameters::MClassesSamplesCT::const_iterator classesSamplesItEnd = castParamsPtr->m_trainSamplesPtr->end();
    Parameters::ClassSamplesContainerT::const_iterator classSamplesIt;
    Parameters::ClassSamplesContainerT::const_iterator classSamplesItEnd;

    m_highestTrainClassID = 0;

    while( classesSamplesIt != classesSamplesItEnd )
    {
      classSamplesIt = classesSamplesIt->second.begin();
      classSamplesItEnd = classesSamplesIt->second.end();

      m_highestTrainClassID = std::max( m_highestTrainClassID,
        classesSamplesIt->first );

      while( classSamplesIt != classSamplesItEnd )
      {
        samples.push_back( *classSamplesIt);
        samplesLabels.push_back( classesSamplesIt->first );

        ++classSamplesIt;
      }

      ++classesSamplesIt;
    }

    if( !samples.empty() )
    {
      const std::size_t featuresNmb = samples[ 0 ].size();

      for( std::size_t featureIdx = 0 ; featureIdx < featuresNmb ; ++featureIdx )
      {
        samplesAttributesIndices.push_back(static_cast<unsigned int>(featureIdx));
      }
    }
  }

  // Initializing the generic classifier

  te::cl::MAP::Parameters genPars;
  genPars.m_prioriProbs = m_initParams.m_prioriProbs;
  genPars.m_prioriCalcSampleStep = m_initParams.m_prioriCalcSampleStep;

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_genClassInstance.initialize( genPars ),
    "Invalid parameters" )
  
  // Training the generic classifier

  te::cl::VectorOfVectorsInputAdaptor< double > samplesAdaptor(
    samples );

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_genClassInstance.train( samplesAdaptor, samplesAttributesIndices,
    samplesLabels, false ), "Classifier trainning error" );

  // Finalizing
  
  m_isInitialized = true;
  
  return true;
}

bool te::rp::ClassifierMAPStrategy::execute() throw(te::rp::Exception)
{
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_isInitialized,
    "Classification strategy not initialized" );

  // Creating the output raster

  std::vector< int > dt;
  dt.push_back( te::dt::UINT32_TYPE );

  std::vector< double > noDataValues;
  noDataValues.push_back( (double)( m_highestTrainClassID + 2 ) );

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( createOutputRaster( dt, noDataValues ),
    "Output raster creation error" );

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( setOutputRasterPalette( m_highestTrainClassID + 1 ),
    "Output raster palette creation error" );

  te::rp::ca::RasterInputAdaptor< double > inputRasterAdp( *m_inputRasterPtr );
  te::rp::ca::RasterOutputAdaptor< unsigned int > outputRasterAdp( *m_outputRasterPtr );

  std::vector< double > inputNoDataValues;
  for( unsigned int inputRasterBandsIdx = 0 ; inputRasterBandsIdx < m_inputRasterBands.size() ;
    ++inputRasterBandsIdx )
  {
    inputNoDataValues.push_back( m_inputRasterPtr->getBand(
      m_inputRasterBands[ inputRasterBandsIdx ] )->getProperty()->m_noDataValue );
  }

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_genClassInstance.classify( inputRasterAdp,
    m_inputRasterBands, inputNoDataValues, outputRasterAdp, 0,
    m_outputRasterPtr->getBand( 0 )->getProperty()->m_noDataValue,
    m_progressInterfaceEnabled ), "Classifier execution error" );

  return true;
}

//-----------------------------------------------------------------------------

te::rp::ClassifierMAPStrategyFactory::ClassifierMAPStrategyFactory()
  : te::rp::ClassifierStrategyFactory("map")
{
}

te::rp::ClassifierMAPStrategyFactory::~ClassifierMAPStrategyFactory() = default;

te::rp::ClassifierStrategy* te::rp::ClassifierMAPStrategyFactory::build()
{
  return new te::rp::ClassifierMAPStrategy();
}