ClassifierStrategy.h

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.h
 
  \brief Raster classifier strategy base class.
 */
 
#ifndef __TERRALIB_RP_INTERNAL_CLASSIFIERSTRATEGY_H
#define __TERRALIB_RP_INTERNAL_CLASSIFIERSTRATEGY_H
 
// TerraLib
#include "../raster/Raster.h"
#include "../raster/BandProperty.h"
#include "ClassifierStrategyParameters.h"
#include "ClassifierStrategyOutParameters.h"
#include "Config.h"
#include "Exception.h"
 
// STL
#include <vector>
#include <memory>
 
namespace te
{
  namespace rp
  {
    /*!
      \class ClassifierStrategy
      \brief Raster classifier strategy base class.
     */
    class TERPEXPORT ClassifierStrategy
    {
      public:
 
        /*! \brief Virtual destructor. */
        virtual ~ClassifierStrategy();
 
        /*!
          \brief Initialize the classification strategy.
 
          \param strategyParams A pointer to the user given specific classification strategy parameters ou NULL if no parameters are present.
 
          \return true if OK, false on errors.
        */
        virtual bool initialize(ClassifierStrategyParameters const* const strategyParams) _NOEXCEPT_OP(false) = 0;
 
        /*!
          \brief Executes the classification strategy.
          \return true if OK, false on errors.
        */
        virtual bool execute() _NOEXCEPT_OP(false) = 0;
 
        /*!
          \brief Set the input raster.
          \param raster Input raster.
        */
        void setInputRaster( const te::rst::Raster& raster );
 
        /*!
          \brief Set the input raste bandsr.
          \param rasterBands Input raster bands.
        */
        void setInputRasterBands( const  std::vector<unsigned int>& rasterBands );
 
        /*!
          \brief Returns a pointer to the output raster or a void pointer if there is none.
          \return Returns a pointer to the output raster or a void pointer if there is none.
          \note The caller of this method must take the ownership of the returned object.
        */
        std::unique_ptr< te::rst::Raster > releaseOutputRaster();
 
        /*!
          \brief Set the input polygons.
          \param polygonsPtrs Input polygons pointers.
          \note The caller of this method must keep the ownership of the objects.
        */
        void setInputPolygons( const std::vector<te::gm::Polygon*>& polygonsPtrs );
 
        /*!
          \brief Enable / disable the progress interface.
          \param enable Enable (true) or disable (false) the progress interface.
        */
        void enableProgressInterface( const bool& enable );
 
        /*!
          \brief Enable / disable the use of raster data cache.
          \param enable Enable (true) or disable (false) the use of raster cache.
        */
        void enableRasterCache( const bool& enable );
 
        /*!
          \brief Enable / disable the use of multiple threads.
          \param enable Enable (true) or disable (false) the use of multiple threads.
        */
        void enableMultiThread( const bool& enable );
 
        /*!
          \brief Returns strategy-dependent metadata.
          \param metadata Strategy-dependent metadata.
        */
        void getMetaData( std::map< std::string, std::string >& metadata ) const;
 
        /*!
          \brief Enable (true) or disable (false) the creation of a paletted output raster.
          \param enabled Enable (true) or disable (false) the creation of a paletted output raster.
        */
        void enableOutputPalette( const bool enabled );
 
        /*!
          \brief Set the output user palette.
          \param userPalette User output raster palette (it must be large enough to accomodate all classifyier generated classes or an empty vector to automatically generate an random palette.
        */
        void setUserOutputPalette( std::vector< te::rst::BandProperty::ColorEntry >& userPalette );
 
        /*!
          \brief Return the current error message if there is any.
 
          \return Return the current error message if there is any.
         */
        const std::string& getErrorMessage() const;
        
        /*!
          \brief Returns a pointer to the strategy output execution parameters or a null pointer if there are none.
 
          \return Returns a pointer to the strategy output execution parameters or a null pointer if there are none.
         */        
        virtual ClassifierStrategyOutParameters const* getOutputParameters() const;
 
      protected:
 
        /*!
          \brief A pointer to the input raster.
        */
        te::rst::Raster const * m_inputRasterPtr;
 
        /*!
          \brief Progress interface status.
        */
        bool m_progressInterfaceEnabled;
 
        /*!
          \brief Enable or disable the use a raster data cache.
        */
        bool m_enableRasterCache;
 
        /*!
          \brief Enable or disable the use multipe threads.
        */
        bool m_enableMultiThread;
 
        /*!
          \brief Enable (true) or disable (false) the creation of a paletted output raster.
        */
        bool m_createRasterPalette;
 
        /*!
          \brief A pointer to the output raster.
        */
        std::unique_ptr< te::rst::Raster > m_outputRasterPtr;
 
        /*!
          \brief Input raster bands.
        */
        std::vector<unsigned int> m_inputRasterBands;
 
        /*!
          \brief Input polygons.
        */
        std::vector<te::gm::Polygon*> const * m_inputPolygonsPtr;
 
        /*!
          \brief Strategy-dependent metadata.
        */
        std::map< std::string, std::string > m_metaData;
 
        /*!
          \brief User output raster palette (it must be large enough to accomodate all classifyier generated classes or an empty vector to automatically generate an random palette.
        */
        std::vector< te::rst::BandProperty::ColorEntry > m_userOutputPalette;
 
        /*! \brief Default constructor. */
        ClassifierStrategy();
 
        /*!
          \brief Create the output raster using the EXPANSIBLE driver.
          \param bandsDataTypes Bands data types.
          \param noDataValues A vector of no-data values for each band.
          \return true if ok,false on errors.
          \note A pointer to the created raster will be handled by m_outputRasterPtr.
        */
        bool createOutputRaster( const std::vector< int >& bandsDataTypes,
          const std::vector< double >& noDataValues );
 
        /*!
          \brief Create and set the output raster palette folowing the current internal settings.
          \param size Palette size.
          \return true if ok,false on errors.
        */
        bool setOutputRasterPalette( const unsigned int size );
 
        /*!
          \brief Set the current error message.
 
          \param newErrorMessage New error message;
         */
        void setErrorMessage( const std::string& newErrorMessage );
 
        /*!
          \brief Reset to an initial state
        */
        virtual void reset();
 
      private:
 
        /*!
          \brief Current error message.
         */
        std::string m_errorMessage;
 
        /*!
          \brief Copy constructor.
 
          \param rhs The right-hand side Raster.
        */
        ClassifierStrategy(const ClassifierStrategy& rhs);
 
        /*!
          \brief Assignment operator.
 
          \param rhs The right-hand-side copy that would be used to copy from.
 
          \return A reference to this object.
        */
        const ClassifierStrategy& operator=(const ClassifierStrategy& rhs);
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif  // __TERRALIB_RP_INTERNAL_CLASSIFIERSTRATEGY_H