ComposerRuleValidNeighborhood.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_COMPOSER_RULE_VALID_NEIGHBORHOOD_H
#define __TERRALIB_RP_INTERNAL_COMPOSER_RULE_VALID_NEIGHBORHOOD_H
 
#include "ComposerRule.h"
#include "../srs/Converter.h"
 
#include <memory>
 
namespace te
{
  namespace rp
  {
    /*!
      \class ComposerRuleValidNeighborhood A basic composer rule capable of choosing the valid pixels (all bands with no no-data values).
      \brief A basic composer rule capable of choosing the valid pixels (all bands with no no-data values).
      \ingroup rp_optical
     */
    class TERPEXPORT ComposerRuleValidNeighborhood : public ComposerRule
    {
      public:
        
        ComposerRuleValidNeighborhood();
 
        ~ComposerRuleValidNeighborhood();
        
        /*!
          \brief Set the valid values ranges.
          \param ranges1 Raster 1 values ranges.
          \param ranges2 Raster 2 values ranges.
          \note Valid values ranges for each band (first=min, second=max).
          \note Ranges min and max are considered valid values.
        */       
        void setValidValuesRanges( 
          const std::vector< std::pair< double, double > >& ranges1,
          const std::vector< std::pair< double, double > >& ranges2 );
        
        /*!
          \brief Get the valid values ranges.
          \param ranges1 Raster 1 values ranges.
          \param ranges2 Raster 2 values ranges.
        */       
        void getValidValuesRanges( 
          std::vector< std::pair< double, double > >& ranges1,
          std::vector< std::pair< double, double > >& ranges2 ) const;
        
        /*!
          \brief Set the valid values neighbors window radius.
          \param newRadius New radius.
          \note All pixels within the radius must be valid for the center pixel be considered valid.
        */       
        void setWindowRadius( const unsigned int newRadius );
 
        /*!
          \brief Get the valid values neighbors window radius.
          \return Get the valid values neighbors window radius.
        */       
        unsigned int getWindowRadius() const;
        
        /*!
          \brief Set the mimimum percentual of valid pixels considering the entire neighborhood for a center pixel to be considered valid.
          \param newPercent New value (Range 0 -> 100).
        */       
        void setNeiborMinValidPercent( const double newPercent );
        
        /*!
          \brief Get the mimimum percentual of valid pixels considering the entire neighborhood for a center pixel to be considered valid.
          \return Get the mimimum percentual of valid pixels considering the entire neighborhood for a center pixel to be considered valid.
        */       
        double getNeiborMinValidPercent() const;
 
      protected:
        
        // overload
        void getComposedValues( const double& line, const double& col, 
          double* const composedValuesPtr ) const;
 
        // overload
        ComposerRule* clone() const;
        
        // overload
        bool initialize( 
          const te::rst::Raster& raster1, 
          const std::vector< unsigned int >& raster1Bands, 
          const te::rst::Raster& raster2, 
          const std::vector< unsigned int >& raster2Bands,
          te::rst::Raster& raster3, 
          const std::vector< unsigned int >& raster3Bands,
          const te::rst::Interpolator::Method& interpMethod1,
          const te::rst::Interpolator::Method& interpMethod2,
          const double& noDataValue,
          const bool forceRaster1NoDataValue,
          const bool forceRaster2NoDataValue,
          const std::vector< double >& pixelOffsets1,
          const std::vector< double >& pixelScales1,
          const std::vector< double >& pixelOffsets2,
          const std::vector< double >& pixelScales2 );
        
      private :
        
        te::srs::Converter m_converter1;  //<! Raster 1 converter.
        
        te::srs::Converter m_converter2;  //<! Raster 2 converter.
        
        std::vector< double > m_raster1NoDataValues; //!< Raster 1 no-data values (on value per band).
        
        std::vector< double > m_raster2NoDataValues; //!< Raster 2 no-data values (on value per band).        
        
        /*!
          \brief Valid pixels windows radius.
         */
        long int m_windowRadius;
        
        /*!
          \brief Maximum number of pixels in a window (center included)
         */
        long int m_windowMaxNPixels;        
        
        double m_neiborMinValidPercent;  //>! Mimimum percentual of valid pixels considering the entire neighborhood.
        
        /*!
          \brief Valid values ranges for each raster 1 band (first=min, second=max).
         */
        std::vector< std::pair< double, double > > m_ranges1;        
        
        /*!
          \brief Valid values ranges for each raster 1 band (first=min, second=max).
         */
        std::vector< std::pair< double, double > > m_ranges2;
        
        unsigned int m_NBands; //<! Rasters bands number.
        
        long int m_r1NRows; //<! Raster 1 rows number.
        
        long int m_r1NCols; //<! Raster 1 columns number.
        
        long int m_r2NRows; //<! Raster 2 rows number.
        
        long int m_r2NCols; //<! Raster 2 columns number.        
        
        // variables used by getComposedValues method        
        mutable double m_getComposedValues_centerX3;
        mutable double m_getComposedValues_centerY3;        
        mutable double m_getComposedValues_centerX;
        mutable double m_getComposedValues_centerY;
        mutable double m_getComposedValues_centerCol;
        mutable double m_getComposedValues_centerRow;        
        mutable unsigned int m_getComposedValues_r1PixelQuality;
        mutable unsigned int m_getComposedValues_r2PixelQuality;
        mutable long int m_getComposedValues_row;
        mutable long int m_getComposedValues_col;
        mutable unsigned int m_getComposedValues_bandIdx;
        mutable long int m_getComposedValues_centerRow1;
        mutable long int m_getComposedValues_centerCol1;
        mutable long int m_getComposedValues_centerRow2;
        mutable long int m_getComposedValues_centerCol2;
        mutable long int m_getComposedValues_startRow;
        mutable long int m_getComposedValues_startCol;
        mutable long int m_getComposedValues_rowBound;
        mutable long int m_getComposedValues_colBound;
        mutable bool m_getComposedValues_pixelIsValid;
        mutable double m_getComposedValues_pixelValue;
        
        ComposerRuleValidNeighborhood( const ComposerRuleValidNeighborhood& other );
        
        const ComposerRuleValidNeighborhood& operator=( const ComposerRuleValidNeighborhood& other );        
        
        void initState();
        
        void clear();
 
    };
 
  } // end namespace rp
}   // end namespace te
 
#endif