MixtureModelStrategy.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/MixtureModelStrategy.h

  \brief Raster mixture model strategy base class.
 */

#ifndef __TERRALIB_RP_INTERNAL_MIXTUREMODELSTRATEGY_H
#define __TERRALIB_RP_INTERNAL_MIXTUREMODELSTRATEGY_H

// TerraLib
#include "../raster/Raster.h"
#include "StrategyParameters.h"
#include "Config.h"
#include "Exception.h"

// STL
#include <vector>

// Boost
#include <boost/numeric/ublas/matrix.hpp>

namespace te
{
  namespace rp
  {
    /*!
      \class MixtureModelStrategy
      \brief Raster mixture model strategy base class.
     */
    class TERPEXPORT MixtureModelStrategy
    {
      public:

        /*! \brief Virtual destructor. */
        virtual ~MixtureModelStrategy();

        /*!
          \brief Initialize the segmentation strategy.
          \param strategyParams A pointer to the user given specific segmentation strategy parameters ou NULL if no parameters are present.
          \return true if OK, false on errors.
        */
        virtual bool initialize(StrategyParameters const* const strategyParams) throw(te::rp::Exception) = 0;

        /*!
          \brief Executes the segmentation strategy.

          \param inputRaster                Input raster.
          \param inputRasterBands           Input raster bands.
          \param components                 The set of endmembers and its radiances.
          \param outputRaster               Output raster vector, contains output raster and error raster if requested.
          \param enableProgressInterface    Enable the internal strategy to update the progress interface.

          \return true if OK, false on errors.
        */
        virtual bool execute(const te::rst::Raster& inputRaster, const std::vector<unsigned int>& inputRasterBands,
                             const std::vector<std::string>& inputSensorBands, const std::map<std::string, std::vector<double> >& components,
                             std::vector<te::rst::Raster*>& outputRaster, const bool normalize, const bool enableProgressInterface) throw(te::rp::Exception) = 0;

        /*!
          \brief Returns the used transformation matrix (when applicable).
          \param matrix The transformation matrix.
          \return true if OK, false on errors or not applicable cases.
        */
        virtual bool getTransformMatrix( boost::numeric::ublas::matrix<double>& matrix ) const = 0;

        /*!
        \brief Sets the used transformation matrix.
        \param matrix The transformation matrix.
        \return true if OK, false on errors or not applicable cases.
        */
        virtual bool setTransformMatrix(boost::numeric::ublas::matrix<double>& matrix) = 0;

        /*!
        \brief Generates the used transformation matrix (when applicable).
        \param inputRasterBands Input raster bands.
        \param inputSensorBands Input names of the sensor/bands.
        \param components A set of endmembers and its radiances.
        \return true if OK, false on errors or not applicable cases.
        */
        virtual bool generateTransformMatrix(const std::vector<unsigned int>& inputRasterBands, const std::vector<std::string>& inputSensorBands,
          const std::map<std::string, std::vector<double> >& components) = 0;

        virtual bool getMinMax(std::vector<double>&, std::vector<double>&) const = 0;
        virtual bool getMinMaxError(std::vector<double>&, std::vector<double>&) const = 0;

        /*!
          \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;

      protected:

        /*! \brief Default constructor. */
        MixtureModelStrategy();

        /*!
          \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.
        */
        MixtureModelStrategy(const MixtureModelStrategy& rhs);

        /*!
          \brief Assignment operator.

          \param rhs The right-hand-side copy that would be used to copy from.

          \return A reference to this object.
        */
        MixtureModelStrategy& operator=(const MixtureModelStrategy& rhs);


    };

  } // end namespace rp
}   // end namespace te

#endif  // __TERRALIB_RP_INTERNAL_MIXTUREMODELSTRATEGY_H