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

  \brief Raster classifier strategy base class.
*/

#include "ClassifierStrategy.h"
#include "Macros.h"
#include "../raster.h"
#include "Functions.h"

te::rp::ClassifierStrategy::ClassifierStrategy()
{
  reset();
}

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

te::rp::ClassifierStrategy::ClassifierStrategy(const te::rp::ClassifierStrategy& other )
{
  reset();
  operator=( other );
}

const te::rp::ClassifierStrategy& te::rp::ClassifierStrategy::operator=(const te::rp::ClassifierStrategy&)
{
  reset();
  return *this;
}

void te::rp::ClassifierStrategy::setInputRaster( const te::rst::Raster& raster )
{
  m_inputRasterPtr = &raster;
}

void te::rp::ClassifierStrategy::setInputRasterBands( const  std::vector<unsigned int>& rasterBands )
{
  m_inputRasterBands = rasterBands;
}

std::unique_ptr< te::rst::Raster > te::rp::ClassifierStrategy::releaseOutputRaster()
{
  return std::unique_ptr< te::rst::Raster >( m_outputRasterPtr.release() );
}

void te::rp::ClassifierStrategy::setInputPolygons( const std::vector<te::gm::Polygon*>& polygonsPtrs )
{
  m_inputPolygonsPtr = &polygonsPtrs;
}

void te::rp::ClassifierStrategy::enableProgressInterface( const bool& enable )
{
  m_progressInterfaceEnabled = enable;
}

void te::rp::ClassifierStrategy::enableRasterCache( const bool& enable )
{
  m_enableRasterCache = enable;
}

void te::rp::ClassifierStrategy::enableMultiThread( const bool& enable )
{
  m_enableMultiThread = enable;
}

void te::rp::ClassifierStrategy::getMetaData( std::map< std::string, std::string >& metadata ) const
{
  metadata = m_metaData;
}

void te::rp::ClassifierStrategy::enableOutputPalette( const bool enabled )
{
  m_createRasterPalette = enabled;
}

void te::rp::ClassifierStrategy::setUserOutputPalette( std::vector< te::rst::BandProperty::ColorEntry >& userPalette )
{
  m_userOutputPalette = userPalette;
}

const std::string& te::rp::ClassifierStrategy::getErrorMessage() const
{
  return m_errorMessage;
}

bool te::rp::ClassifierStrategy::createOutputRaster(
  const std::vector< int >& bandsDataTypes,
  const std::vector< double >& noDataValues )
{
  TERP_TRUE_OR_THROW( m_inputRasterPtr != nullptr, "Invalid input raster pointer" );
  TERP_TRUE_OR_THROW( !bandsDataTypes.empty(), "Invalid bands data types" );
  TERP_TRUE_OR_THROW( noDataValues.size() == bandsDataTypes.size(), "Invalid no-data values" );

  // Creating the output raster

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

  for(unsigned int bandsDataTypesIdx=0; bandsDataTypesIdx < bandsDataTypes.size();
    bandsDataTypesIdx++)
  {
    te::rst::BandProperty* newbprop = new te::rst::BandProperty(*(m_inputRasterPtr->getBand(
      m_inputRasterBands[0])->getProperty()));
    newbprop->m_colorInterp = te::rst::GrayIdxCInt;
    newbprop->m_type = bandsDataTypes[bandsDataTypesIdx];
    newbprop->m_noDataValue = noDataValues[ bandsDataTypesIdx ];
    bandsProperties.push_back(newbprop);
  }
  // creating the output raster

  te::rst::Grid* newgrid = new te::rst::Grid(*(m_inputRasterPtr->getGrid()));
  std::map< std::string, std::string > m_rInfo;

  try
  {
    m_outputRasterPtr.reset( te::rst::RasterFactory::make( "EXPANSIBLE", newgrid,
      bandsProperties, std::map< std::string, std::string >(), nullptr, nullptr));
  }
  catch(...)
  {
    m_outputRasterPtr.reset();
  }

  return ( m_outputRasterPtr.get() != nullptr );
}

bool te::rp::ClassifierStrategy::setOutputRasterPalette( const unsigned int size )
{
  if( m_createRasterPalette && ( size > 0 ) )
  {
    if( m_outputRasterPtr.get() == nullptr ) return false;
    if( m_outputRasterPtr->getNumberOfBands() < 1 ) return false;

    std::vector< te::rst::BandProperty::ColorEntry > palette;

    if( m_userOutputPalette.empty() )
    {
      te::rp::CreateFixedStepPalette( size, true, palette );
    }
    else
    {
      const std::size_t userOutputPaletteSize = m_userOutputPalette.size();
      if( userOutputPaletteSize < size ) return false;

      for( std::size_t pIdx = 0 ; pIdx < userOutputPaletteSize ; ++pIdx )
      {
        palette.push_back( m_userOutputPalette[ pIdx ] );
      }
    }

    m_outputRasterPtr->getBand( 0 )->getProperty()->m_colorInterp =
      te::rst::PaletteIdxCInt;
    m_outputRasterPtr->getBand( 0 )->getProperty()->m_paletteInterp =
      te::rst::RGBPalInt;
    m_outputRasterPtr->getBand( 0 )->getProperty()->m_palette =
      palette;
  }

  return true;
}

void te::rp::ClassifierStrategy::setErrorMessage( const std::string& newErrorMessage )
{
  m_errorMessage = newErrorMessage;
}

void te::rp::ClassifierStrategy::reset()
{
  m_inputRasterPtr = nullptr;
  m_progressInterfaceEnabled = false;
  m_enableRasterCache = true;
  m_enableMultiThread = true;
  m_createRasterPalette = true;
  m_outputRasterPtr.reset();
  m_inputRasterBands.clear();
  m_inputPolygonsPtr = nullptr;
  m_metaData.clear();
  m_userOutputPalette.clear();
  m_errorMessage.clear();
}