src/terralib/rp/Classifier.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/Classifier.cpp

  \brief Raster classification.
 */

// TerraLib
#include "../geometry/Envelope.h"
#include "../geometry/Polygon.h"
#include "../raster/Raster.h"
#include "../raster/RasterFactory.h"
#include "../raster/Band.h"
#include "../raster/BandProperty.h"
#include "../raster/Grid.h"
#include "Algorithm.h"
#include "Classifier.h"
#include "ClassifierStrategy.h"
#include "ClassifierStrategyFactory.h"
#include "Config.h"
#include "Matrix.h"

te::rp::Classifier::InputParameters::InputParameters()
  : m_classifierStrategyParamsPtr(nullptr)
{
  reset();
}

te::rp::Classifier::InputParameters::InputParameters(const InputParameters& rhs)
  : m_classifierStrategyParamsPtr(nullptr)
{
  reset();

  operator=(rhs);
}

te::rp::Classifier::InputParameters::~InputParameters()
{
  reset();
}

void te::rp::Classifier::InputParameters::setClassifierStrategyParams(const ClassifierStrategyParameters& p)
{
  if(m_classifierStrategyParamsPtr)
  {
    delete m_classifierStrategyParamsPtr;
    m_classifierStrategyParamsPtr = nullptr;
  }

  m_classifierStrategyParamsPtr = (ClassifierStrategyParameters*)p.clone();
}

te::rp::ClassifierStrategyParameters const* te::rp::Classifier::InputParameters::getClassifierStrategyParams() const
{
  return m_classifierStrategyParamsPtr;
}

void te::rp::Classifier::InputParameters::reset() throw(te::rp::Exception)
{
  m_inputRasterPtr = nullptr;
  m_enableProgressInterface = false;
  m_enableRasterCache = true;
  m_enableMultiThread = true;
  m_createRasterPalette = true;
  m_inputRasterBands.clear();
  m_inputPolygons.clear();
  m_strategyName.clear();

  if(m_classifierStrategyParamsPtr)
  {
    delete m_classifierStrategyParamsPtr;
    m_classifierStrategyParamsPtr = nullptr;
  }

  m_userOutputPalette.clear();
}

const te::rp::Classifier::InputParameters& te::rp::Classifier::InputParameters::operator=(const te::rp::Classifier::InputParameters& params)
{
  reset();

  m_inputRasterPtr = params.m_inputRasterPtr;
  m_enableProgressInterface = params.m_enableProgressInterface;
  m_enableRasterCache = params.m_enableRasterCache;
  m_enableMultiThread = params.m_enableMultiThread;
  m_createRasterPalette = params.m_createRasterPalette;
  m_inputRasterBands = params.m_inputRasterBands;
  m_inputPolygons = params.m_inputPolygons;
  m_strategyName = params.m_strategyName;

  setClassifierStrategyParams(*params.m_classifierStrategyParamsPtr);

  m_userOutputPalette = params.m_userOutputPalette;

  return *this;
}

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

te::rp::Classifier::OutputParameters::OutputParameters()
{
  reset();
}

te::rp::Classifier::OutputParameters::OutputParameters(const OutputParameters& rhs)
{
  reset();

  operator=(rhs);
}

te::rp::Classifier::OutputParameters::~OutputParameters()
{
  reset();
}

void te::rp::Classifier::OutputParameters::reset() throw(te::rp::Exception)
{
  m_rType.clear();
  m_rInfo.clear();
  m_outputRasterPtr.reset();
}

const te::rp::Classifier::OutputParameters& te::rp::Classifier::OutputParameters::operator=(const te::rp::Classifier::OutputParameters& params)
{
  reset();

  m_rType = params.m_rType;
  m_rInfo = params.m_rInfo;
  m_outputRasterPtr.reset( params.m_outputRasterPtr.release() );

  return *this;
}

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

te::rp::Classifier::Classifier()
  : m_instanceInitialized(false)
{
}

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

bool te::rp::Classifier::execute(AlgorithmOutputParameters& outputParams) throw(te::rp::Exception)
{
  if(!m_instanceInitialized)
    return false;

  // executing the classification strategy

  boost::shared_ptr<te::rp::ClassifierStrategy> strategyPtr(ClassifierStrategyFactory::make(m_inputParameters.m_strategyName));

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(strategyPtr.get(), "Unable to create the classifier strategy");

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(strategyPtr->initialize(
    m_inputParameters.getClassifierStrategyParams()),
    "Unable to initialize the classification strategy - "
    + strategyPtr->getErrorMessage() );

  strategyPtr->setInputRaster( *m_inputParameters.m_inputRasterPtr );
  strategyPtr->setInputRasterBands( m_inputParameters.m_inputRasterBands );
  strategyPtr->setInputPolygons( m_inputParameters.m_inputPolygons );
  strategyPtr->enableProgressInterface( m_inputParameters.m_enableProgressInterface );
  strategyPtr->enableRasterCache( m_inputParameters.m_enableRasterCache );
  strategyPtr->enableOutputPalette( m_inputParameters.m_createRasterPalette );
  strategyPtr->setUserOutputPalette( m_inputParameters.m_userOutputPalette );
  strategyPtr->enableMultiThread( m_inputParameters.m_enableMultiThread );

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE( strategyPtr->execute(),
    "Unable to execute the classification strategy - " +
    strategyPtr->getErrorMessage() );

  // Creating the output raster

  std::unique_ptr< te::rst::Raster > memOutRasterPtr = strategyPtr->releaseOutputRaster();
  assert( memOutRasterPtr.get() != (te::rst::Raster*)nullptr );

  std::vector<te::rst::BandProperty*> bandsProperties;

  for(unsigned int memBandIdx=0; memBandIdx < memOutRasterPtr->getNumberOfBands(); memBandIdx++)
  {
    te::rst::BandProperty* newbprop = new te::rst::BandProperty(
      *( memOutRasterPtr->getBand( memBandIdx )->getProperty() ) );

    // Change the first band data type to 8-bits
    // if there is enought room for the current pallete there.
    if(
        ( memBandIdx == 0 )
        &&
        (
          memOutRasterPtr->getBand( 0 )->getProperty()->m_colorInterp
          ==
          te::rst::PaletteIdxCInt
        )
        &&
        (
          memOutRasterPtr->getBand( 0 )->getProperty()->m_palette.size()
          <
          257
        )
      )
    {
      newbprop->m_type = te::dt::UCHAR_TYPE;
    }

    bandsProperties.push_back(newbprop);
  }
 
  te::rp::Classifier::OutputParameters* outputParamsPtr = dynamic_cast<te::rp::Classifier::OutputParameters*>(&outputParams);
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(outputParamsPtr, "Invalid parameters");

  te::rst::Grid* newgrid = new te::rst::Grid(*(memOutRasterPtr->getGrid()));

  outputParamsPtr->m_outputRasterPtr.reset(
    te::rst::RasterFactory::make(outputParamsPtr->m_rType, newgrid, bandsProperties,
    outputParamsPtr->m_rInfo, nullptr, nullptr));
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(outputParamsPtr->m_outputRasterPtr.get(),
    "Output raster creation error");

  // Output raster data copy

  const unsigned int nBands = static_cast<unsigned int>(memOutRasterPtr->getNumberOfBands());
  const unsigned int nCols = memOutRasterPtr->getNumberOfColumns();
  const unsigned int nRows = memOutRasterPtr->getNumberOfRows();
  unsigned int row = 0;
  unsigned int col = 0;
  std::complex< double > value;

  for( unsigned int bandIdx = 0 ; bandIdx < nBands ; ++bandIdx )
  {
    const te::rst::Band& inBand = *memOutRasterPtr->getBand( bandIdx );
    te::rst::Band& outBand = *outputParamsPtr->m_outputRasterPtr->getBand( bandIdx );

    for( row = 0 ; row < nRows ; ++row )
    {
      for( col = 0 ; col < nCols ; ++col )
      {
        inBand.getValue( col, row, value );
        outBand.setValue( col, row, value );
      }
    }
  }

  strategyPtr->getMetaData( outputParamsPtr->m_metadata );

  return true;
}

void te::rp::Classifier::reset() throw(te::rp::Exception)
{
  Algorithm::reset();

  m_instanceInitialized = false;

  m_inputParameters.reset();
}

bool te::rp::Classifier::initialize(const AlgorithmInputParameters& inputParams) throw(te::rp::Exception)
{
  reset();

  te::rp::Classifier::InputParameters const* inputParamsPtr = dynamic_cast<te::rp::Classifier::InputParameters const* >(&inputParams);

// check if input raster is ok
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr, "Invalid parameters");

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_inputRasterPtr, "Invalid raster pointer");

  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_inputRasterPtr->getAccessPolicy() &
                            te::common::RAccess, "Invalid raster");

// check if input raster and bands fit
  TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_inputRasterBands.size() > 0,
                            "Invalid raster bands number");

  for(unsigned int i = 0; i < inputParamsPtr->m_inputRasterBands.size(); i++)
    TERP_INSTANCE_TRUE_OR_RETURN_FALSE(inputParamsPtr->m_inputRasterBands[i] <
                              inputParamsPtr->m_inputRasterPtr->getNumberOfBands(),
                              "Invalid raster bands" );

// check if input raster and geometries fit
    
  const std::vector< te::gm::Polygon* >& inputPolygons = 
    inputParamsPtr->m_inputPolygons;
  const te::rst::Raster& inputRaster = *inputParamsPtr->m_inputRasterPtr;
    
  const std::size_t inputPolygonsSize = inputPolygons.size();
    
  for (std::size_t inputPolygonsIdx = 0; inputPolygonsIdx > inputPolygonsSize; 
    inputPolygonsIdx++)
  {
    TERP_INSTANCE_TRUE_OR_RETURN_FALSE( inputPolygons[ inputPolygonsIdx ],
                              "Invalid input polygon pointer");
    TERP_INSTANCE_TRUE_OR_RETURN_FALSE(
      inputPolygons[ inputPolygonsIdx ]->getSRID() == 
      inputRaster.getSRID(), "Invalid input polygon SRID" );
    TERP_INSTANCE_TRUE_OR_RETURN_FALSE(
        inputPolygons[ inputPolygonsIdx ]->getMBR()->within(*inputRaster.getExtent()),
        "Raster and Polygons does not fit");
  }

// everything is ok
  m_instanceInitialized = true;

  m_inputParameters = *inputParamsPtr;

  return true;
}

bool te::rp::Classifier::isInitialized() const
{
  return m_instanceInitialized;
}