Restoration.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>.
 */
 
 
#ifndef __TERRALIB_RP_INTERNAL_RESTORATION_H
#define __TERRALIB_RP_INTERNAL_RESTORATION_H
 
#include "Algorithm.h"
 
#include "../raster/Raster.h"
 
#include <vector>
#include <string>
#include <map>
 
namespace te
{
  namespace rp
  {
    /*!
      \class Restoration
      \brief This class implements the combining interpolation and restoration operation.
      \note The restoration operation compensates the degradation due
        the optics, detector and electronic filtering in the interpolation process.
        The image to be processed must be in the original resolution. For example
        Spot-X ( 20 m ), Spot-Pan ( 10 m ) and TM ( 30 m ).
        Filters and Resamples the input image in disk using a filter 
        in the vertical and horizontal directions.
      \ingroup rp_enh
     */
    class TERPEXPORT Restoration : public Algorithm
    {
      public:
 
        /*!
          \class InputParameters
          \brief Restoration input parameters
         */
        class TERPEXPORT InputParameters : public AlgorithmInputParameters
        {
          public:
 
            /*! \enum The sensor type.*/
            enum SensorType
            {
              INVALID_RESTORATION_TYPE,
              SPOTP,
              SPOTX,
              TM,
              ETMX,
              ETMP,
              LANDSAT_8,
              CBERS_CCD,
              CBERS_CCRX,
              CBERS2_CCD,
              CBERS2B_CCD,
              CBERS2B_HRC,
              CBERS_4_MUX,
              CBERS_4_PAN10,
              CBERS_4_PAN5,
              CBERS_4_WFI,
              RAPIDEYE,
              QUICKBIRD,
              WORLDVIEW2,
              MODIS_250,
              MODIS_500
            };
            
            /*! \enum The available sampling factors.*/
            enum SamplingFactorType
            {
              INVALID_SAMPLING_FACTOR_TYPE,
              SAMPLING_FACTOR_1_BY_2,
              SAMPLING_FACTOR_1_BY_3,
              SAMPLING_FACTOR_1_BY_4,
              SAMPLING_FACTOR_1_BY_5,
              SAMPLING_FACTOR_1_BY_6,
              SAMPLING_FACTOR_2_BY_3,
              SAMPLING_FACTOR_3_BY_4
            };
            
 
            SensorType m_sensorType; //!< The sensor type.
            
            std::vector< unsigned int > m_sensorBandDesignations; //!< Sensor band designations (starting from 1).
 
            te::rst::Raster const* m_inRasterPtr; //!< Input raster.
 
            std::vector< unsigned int > m_inRasterBands; //!< Bands to be used from the input raster (starting from zero).
 
            SamplingFactorType m_samplingFactor; //!< The samnpling factor.
            
            bool m_enableProgress; //!< Enable/Disable the progress interface (default:false).
 
            bool m_enableRasterCache; //!< Enable/Disable the use of a raster data cache (default:true).
 
            InputParameters();
 
            InputParameters( const InputParameters& );
 
            ~InputParameters();
 
            //overload
            void reset() _NOEXCEPT_OP(false);
 
            //overload
            const  InputParameters& operator=( const InputParameters& params );
 
            //overload
            AbstractParameters* clone() const;
            
            /*!
              \brief Returns all supported sensor types.
              \param infos All supported sensor types.
             */ 
            static void getSupportedSensorTypes( 
              std::map< SensorType, std::string >& infos );
            
            /*!
              \brief Returns all supported sampling factor types.
              \param infos All supported sampling factor types.
             */ 
            static void getSupportedSamplingFactorsTypes( 
              std::map< SamplingFactorType, std::string >& infos );
            
            /*!
              \brief Get Resolution sampling factor given the type.
              \param sFactortype Sampling factor type.
              \param resSamplingFactor Resolution sampling factor type.
              \note Output_resolution = input_resolution * resSamplingFactor.
             */ 
            static void getResolutionSamplingFactor( 
              const InputParameters::SamplingFactorType& sFactortype,
              double& resSamplingFactor );
        };
 
        /*!
          \class OutputParameters
          \brief Restoration output parameters
         */
        class TERPEXPORT OutputParameters : public AlgorithmOutputParameters
        {
          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 raster (as described in te::raster::RasterFactory).
 
            std::unique_ptr< te::rst::Raster > m_outputRasterPtr; //!< A pointer the ge generated output raster (label image).
 
            OutputParameters();
 
            OutputParameters( const OutputParameters& );
 
            ~OutputParameters();
 
            //overload
            void reset() _NOEXCEPT_OP(false);
 
            //overload
            const  OutputParameters& operator=( const OutputParameters& params );
 
            //overload
            AbstractParameters* clone() const;
        };
 
        Restoration();
 
        ~Restoration();
 
        //overload
        bool execute( AlgorithmOutputParameters& outputParams ) _NOEXCEPT_OP(false);
 
        //overload
        void reset() _NOEXCEPT_OP(false);
 
        //overload
        bool initialize( const AlgorithmInputParameters& inputParams ) _NOEXCEPT_OP(false);
 
        //overload
        bool isInitialized() const;
 
      protected:
 
        bool m_isInitialized; //!< Is this instance already initialized?
 
        Restoration::InputParameters m_inputParameters; //!< Input parameters.
        
        /*!
          \brief Calculate the weights of the restoration filter in the vertical and horizontal directions.
          \param bandDesignation Sensor band designation (starting from 1).
          \param XCoefs X coeficients.
          \param YCoefs Y coeficients.
          \return true if OK, false on erros.
         */  
        bool getFilterCoefs( 
          const unsigned int bandDesignation,
          std::vector< double >& XCoefs,
          std::vector< double >& YCoefs ) const;
          
        /*!
          \brief Apply the restorafion filter on the input rasters.
          \param bandsXCoefs X coeficients.
          \param bandsYCoefs Y coeficients.
          \param inputRaster Input raster.
          \param outputRaster Pré-initialized Output raster.
          \return true if OK, false on erros.
         */  
        bool applyFilterCoefs( 
          const std::vector< std::vector< double > >& bandsXCoefs,
          const std::vector< std::vector< double > >& bandsYCoefs,
          const te::rst::Raster& inputRaster,
          te::rst::Raster& outputRaster );
        
        /*!
          \brief Decompose sampling factor.
          \param sFactortype Sampling factor type.
          \param upperValue Upper value.
          \param lowerValue Lower value.
          \note SamplingFactor = ( upperValue / lowerValue ).
         */ 
        static void getDecomposedSamplingFactor( 
          const InputParameters::SamplingFactorType& sFactortype,
          unsigned int& upperValue,
          unsigned int& lowerValue );
          
        /*!
          \brief Return the target filter size following the current sensor.
          \return Return the target filter size following the current sensor.
         */ 
        unsigned int getFilterSize() const;
 
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif  // __TERRALIB_RP_INTERNAL_RESTORATION_H