MixtureModel.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/MixtureModel.h
 
  \brief Raster decomposition using mixture model.
 */
 
#ifndef __TERRALIB_RP_INTERNAL_MIXTUREMODEL_H
#define __TERRALIB_RP_INTERNAL_MIXTUREMODEL_H
 
// TerraLib
#include "Algorithm.h"
#include "Config.h"
#include "Matrix.h"
#include "StrategyParameters.h"
 
// Boost
#include <boost/numeric/ublas/matrix.hpp>
 
namespace te
{
  namespace rst
  {
    class Raster;
    class Band;
  }
 
  namespace rp
  {
    /*!
      \class MixtureModel
 
      \brief Raster decomposition using mixture model.
 
      \details Raster decomposition following the choosed mixture model strategy.
 
      \note The created output image will be written to the raster instance
      pointed by m_outRasterPtr (in this case the output band must also be
      passed by m_outRasterBand).
 
      \ingroup rp_class
    */
 
    class TERPEXPORT MixtureModel : public Algorithm
    {
      public:
 
        /*!
          \class InputParameters
 
          \brief MixtureModel input parameters
        */
 
        class TERPEXPORT InputParameters : public AlgorithmInputParameters
        {
          public:
 
            /*! \brief Default constructor. */
            InputParameters();
 
            /*!
              \brief Copy constructor.
 
              \param rhs The right-hand side Raster.
            */
            InputParameters(const InputParameters& rhs);
 
            ~InputParameters();
 
            /*!
              \brief Set specific mixture model strategy parameters.
 
              \param p The specific mixture model strategy parameters.
            */
            void setMixtureModelStrategyParams(const StrategyParameters& p);
 
            /*!
              \brief Returns a pointer to the internal specific mixture model strategy parameters, or null if no parameters are present.
            */
            StrategyParameters const* getMixtureModelStrategyParams() const;
 
            //overload
            void reset() throw(te::rp::Exception);
 
            //overload
            const MixtureModel::InputParameters& operator=(const MixtureModel::InputParameters& params);
 
            //overload
            te::common::AbstractParameters* clone() const;
 
        public:
 
            te::rst::Raster const* m_inputRasterPtr;                      //!< Input raster.
            std::vector<unsigned int> m_inputRasterBands;                 //!< Bands to be processed from the input raster.
            std::vector<std::string> m_inputSensorBands;                  //!< The names of the sensor/bands.
            std::map<std::string, std::vector<double> > m_components;     //!< A set of endmembers and its radiances.
            std::string m_strategyName;                                   //!< The mixture model strategy name see each te::rp::MixtureModelStrategyFactory inherited classes documentation for reference.
            StrategyParameters* m_mixtureModelStrategyParamsPtr;          //!< Internal specific mixture model strategy parameters.
            boost::numeric::ublas::matrix<double> m_transfMatrix;         //!< Used transformation matrix (when applicable).
            std::vector< std::complex< double > > m_inputRasterNoDataValues; //!< A vector of values to be used as input raster no-data values or an empty vector indicating to use the default values from the input raster..
        };
 
        /*!
          \class OutputParameters
 
          \brief MixtureModel output parameters
        */
 
        class TERPEXPORT OutputParameters : public AlgorithmOutputParameters
        {
          public:
 
            /*! \brief Default constructor. */
            OutputParameters();
 
            /*!
              \brief Copy constructor.
 
              \param rhs The right-hand side Raster.
            */
            OutputParameters(const OutputParameters& rhs);
 
            ~OutputParameters();
 
           /*!\brief Reset all variables*/
            void reset() throw(te::rp::Exception);
 
            /*!\brief assigment operator*/
            const MixtureModel::OutputParameters& operator=(const MixtureModel::OutputParameters& params);
 
            /*!\brief Copy paramters*/
            te::common::AbstractParameters* clone() const;
 
          public:
 
            std::string m_rType;                                          //!< Output raster data source type (as described in te::raster::RasterFactory ).
            std::map< std::string, std::string > m_rInfo;                 //!< The necessary information to create the output raster (as described in te::raster::RasterFactory).
            mutable std::unique_ptr<te::rst::Raster> m_outputRasterPtr;     //!< A pointer to the generated output raster, one band per component plus one error band per component (when parameter m_createErrorRaster is true).
            mutable std::unique_ptr<te::rst::Raster> m_errorRasterPtr;     //!< A pointer to the generated output error raster, one band per component plus one error band per component (when parameter m_createErrorRaster is true).
            std::map< std::string, std::string > m_rInfoError;                 //!< The necessary information to create the error raster (as described in te::raster::RasterFactory).
            bool m_normalizeOutput;                                       //!< A flag to indicate that output raster will be normalized , default [0, 1].
            double m_normalMin;                                           //!< Lower limit to normalized
            double m_normalMax;                                           //!< Upper limit to normalized
            bool m_createErrorRaster;                                     //!< A flag to indicate that output raster will include the error bands.
            std::vector<double> m_min;                                    //!< Minimun value calculeted in output raster
            std::vector<double> m_max;                                    //!< Maximum value calculeted in output raster
            std::vector<double> m_minerror;                                    //!< Minimun value calculeted in output raster
            std::vector<double> m_maxerror;                                    //!< Maximum value calculeted in output raster
 
        };
 
        MixtureModel();
 
        ~MixtureModel();
 
        /*!\brief Executes the mixing model using the parameters defined in inputParams and outputParams */
        bool execute(AlgorithmOutputParameters& outputParams) throw(te::rp::Exception);
 
        /*!\brief Resets all variables */
        void reset() throw(te::rp::Exception);
 
        /*!\brief Initializes model with paramters defined in inputParams*/
        bool initialize(const AlgorithmInputParameters& inputParams) throw(te::rp::Exception);
 
        /*!\brief Model already initialized?*/
        bool isInitialized() const;
 
        /*!\brief Sets Transform Matrix, read from a file or pre-calculated*/
        bool setTransformMatrix(boost::numeric::ublas::matrix<double>& matrix);
 
        /*!\brief Generates a Transform Matrix*/
        bool generateTransformMatrix(boost::numeric::ublas::matrix<double>& matrix);
 
      protected :
 
        bool m_instanceInitialized;                        //!< Is this instance already initialized?
        MixtureModel::InputParameters m_inputParameters;   //!< Mixture model execution parameters.
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif