ClassifierEDStrategy.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/ClassifierEDStrategy.cpp

  \brief Euclidean Distance Classifier strategy.
*/

// TerraLib

#include "ClassifierEDStrategy.h"
#include "Macros.h"
#include "../raster/Band.h"
#include "../raster/BandProperty.h"
#include "../common/MatrixUtils.h"

// STL
#include <memory>

#include <cfloat>

namespace
{
  static te::rp::ClassifierEDStrategyFactory classifierEDStrategyFactoryInstance;
}

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

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

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

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

  m_trainSamplesPtr = rhs.m_trainSamplesPtr;

  return *this;
}

void te::rp::ClassifierEDStrategy::Parameters::reset() _NOEXCEPT_OP(false)
{
  m_trainSamplesPtr.reset();
}

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

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

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

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

bool te::rp::ClassifierEDStrategy::initialize(
  te::rp::ClassifierStrategyParameters const* const strategyParams) _NOEXCEPT_OP(false)
{
  m_isInitialized = false;
  m_initParams.reset();
  m_classesIndex2ID.clear();
  m_classesMeans.clear();

  ClassifierEDStrategy::Parameters const* const castParamsPtr =
    dynamic_cast< ClassifierEDStrategy::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);

  // Calculating m_classesMeans and m_classesIndex2ID

  // Dimension number (bands number)
  const unsigned int dimsNumber = static_cast<unsigned int>(castParamsPtr->m_trainSamplesPtr->begin()->second.operator[]( 0 ).size());

  {
    Parameters::MClassesSamplesCT::const_iterator classesIt = 
      m_initParams.m_trainSamplesPtr->begin();
    const Parameters::MClassesSamplesCT::const_iterator classesItE = 
      m_initParams.m_trainSamplesPtr->end();

    m_highestTrainClassID = 0;

    // Iterate class
    while( classesIt != classesItE )
    {
      const Parameters::ClassIDT& classID = classesIt->first;

      const Parameters::ClassSamplesContainerT& classSamples = classesIt->second;
      TERP_INSTANCE_TRUE_OR_RETURN_FALSE( classSamples.size() > 0,
        "Invalid class samples number" );

      Parameters::ClassSampleT classMeans( dimsNumber, 0.0 );      

      unsigned int dimIdx = 0; 

      m_highestTrainClassID = std::max( m_highestTrainClassID, classID );

      // Iterate bands
      for( dimIdx = 0 ; dimIdx < dimsNumber ; ++dimIdx )
      {
        double& dimMean = classMeans[ dimIdx ];
        dimMean = 0.0;
        
        Parameters::ClassSamplesContainerT::const_iterator samplesIt = 
          classSamples.begin();
        const Parameters::ClassSamplesContainerT::const_iterator samplesItE = 
          classSamples.end();

        // Iterate samples
        while( samplesIt != samplesItE )
        {
          TERP_INSTANCE_TRUE_OR_RETURN_FALSE( samplesIt->size() == dimsNumber,
            "Sample size mismatch" )
          dimMean += samplesIt->operator[]( dimIdx );

          ++samplesIt;
        }

        // sum / simple size
        dimMean /= static_cast<double>( classSamples.size() );
      }

      // Adding to container
      m_classesMeans.push_back( classMeans );
      m_classesIndex2ID.push_back( classID );

      ++classesIt;
    }

  }

  // Finalizing
  
  m_isInitialized = true;
  
  return true;
}

bool te::rp::ClassifierEDStrategy::execute() _NOEXCEPT_OP(false)
{
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_isInitialized,
    "Classification strategy not initialized" );
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_inputRasterBands.size() > 0, "Invalid input bands" );
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( m_inputRasterBands.size() == m_classesMeans[ 0 ].size(),
    "Invalid input bands" );

  // Creating the output raster

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

  std::vector< double > noDataValues;
  noDataValues.push_back( static_cast<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" );
    
  // progress
  
  std::unique_ptr< te::common::TaskProgress > progressPtr;
  if( m_progressInterfaceEnabled )
  {
    progressPtr.reset( new te::common::TaskProgress );
    progressPtr->setTotalSteps( static_cast<int>(m_inputRasterPtr->getNumberOfRows()) );
    progressPtr->setMessage( "Classifying" );
  }

  // Classifying
  
  const unsigned int classesNumber = static_cast<unsigned int>(m_classesMeans.size());
  const unsigned int nRows = static_cast<unsigned int>(m_inputRasterPtr->getNumberOfRows());
  const unsigned int nCols = static_cast<unsigned int>(m_inputRasterPtr->getNumberOfColumns());
  const unsigned int nDims = static_cast<unsigned int>(m_inputRasterBands.size());
  const double outNoDataValue = m_outputRasterPtr->getBand( 0 )->getProperty()->m_noDataValue;
  const double inNoDataValue = m_inputRasterPtr->getBand( m_inputRasterBands[ 0 ] )->getProperty()->m_noDataValue;
  unsigned int col = 0;
  unsigned int dim = 0;
  boost::numeric::ublas::matrix< double > sample( nDims, 1 );
  unsigned int classIdx = 0;
  double dist = 0;
  double bestDist = 0;
  unsigned int bestClass = 0;

  
  for( unsigned int row = 0 ; row < nRows ; ++row )
  {
    for( col = 0 ; col < nCols ; ++col )
    {
      // Creating the sample

      for( dim = 0 ; dim < nDims ; ++dim )
      {
        m_inputRasterPtr->getValue( col, row, sample( dim, 0 ), m_inputRasterBands[ dim ] );
      }

      if( sample( 0, 0 ) == inNoDataValue )
      {
        m_outputRasterPtr->setValue(col, row, outNoDataValue);
      }
      else
      {
        unsigned int refClass = bestClass;
        bestDist = 0;

        for( unsigned int band = 0 ; band < nDims ; ++band )
  //        bestDist += (sample(band, 0) - m_classesMeans[refClass][band]) * (sample(band, 0) - m_classesMeans[refClass][band]) * 1/2;
          bestDist += (sample(band, 0) - m_classesMeans[refClass][band]) * (sample(band, 0) - m_classesMeans[refClass][band]);

        for( classIdx = 0 ; classIdx < classesNumber ; ++classIdx )
        {
          const Parameters::ClassSampleT& classMeans = m_classesMeans[ classIdx ];


          if( classIdx == refClass )
            continue;

          dist = 0;


          for( dim = 0 ; dim < nDims ; ++dim )
          {
  //          dist += (sample(dim, 0) - classMeans[classIdx]) * (sample(dim, 0) - classMeans[classIdx]) * 1/2;
            dist += (sample(dim, 0) - classMeans[classIdx]) * (sample(dim, 0) - classMeans[classIdx]);

            if(dist <= bestDist)
            break;
          }


          // considerar a condição invertida, inverter atribuições internas
          if( dist < bestDist )
          {
            bestDist = dist;
            bestClass = classIdx;
          }
        }

  //      double vClass = bestclass + 1;
        m_outputRasterPtr->setValue( col, row, m_classesIndex2ID[ bestClass ] );
      }
    }
    
    if( m_progressInterfaceEnabled )
    {
      progressPtr->pulse();
      if( ! progressPtr->isActive() ) return false;
    }         
  }    
  
  return true;
}

unsigned int te::rp::ClassifierEDStrategy::getOutputNumberBands(void) {
  return 0;
}
//-----------------------------------------------------------------------------

te::rp::ClassifierEDStrategyFactory::ClassifierEDStrategyFactory()
  : te::rp::ClassifierStrategyFactory("ed")
{
}

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

te::rp::ClassifierStrategy* te::rp::ClassifierEDStrategyFactory::build()
{
  return new te::rp::ClassifierEDStrategy();
}