spatmod/imagefilterfocal.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGEFILTERFOCAL_H
#define  INC_SPATMOD_IMAGEFILTERFOCAL_H

#ifndef  INC_SPATMOD_IMAGEFILTER_H
#include <spatmod/imagefilter.h>
#endif

#ifndef  INC_SPATMOD_IMAGEBUFFER_H
#include <spatmod/imagebuffer.h>
#endif

#ifndef  INC_MI32_MIMATRIX_H
#include <mi32/mimatrix.h>
#endif

namespace SPATMOD {
namespace IMAGE {

//=====================================================================================================================

class FILTER_FOCAL : public FILTER {
   public:

      virtual ~FILTER_FOCAL ();

      double GetAmountFilter () const
         { return (m_AmountFilter); }

      double GetAmountSource () const
         { return (m_AmountSource); }

      UINT32 GetNumFocalCells () const
         { return (m_NumFocalCells); }

      UINT32 GetNumFocalColumns () const
         { return (m_NumFocalColumns); }

      UINT32 GetNumFocalRows () const
         { return (m_NumFocalRows); }

      bool IsUsingMask () const
         { return (m_UseMask); }

      void SetOutputDataType (DATATYPE DataType)
         { m_DataType = DataType; }

   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      // Internal.
      class WORKITERATOR;
      #endif

      FILTER_FOCAL (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100        
         );

      FILTER_FOCAL (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100        
         );

      ERRVALUE PullSubBuffers (const SECTION& SubSection, BUFFER& BufSrc, BUFFER& BufMask);

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullBegin (const SECTION_ITERATOR& iterator);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      double m_AmountFilter;
      double m_AmountSource;
      UINT32 m_NumFocalRows;
      UINT32 m_NumFocalColumns;
      UINT32 m_NumFocalCells;
      DATATYPE m_DataType;
      bool m_UseMask;

      // Unimplemented
      FILTER_FOCAL (const FILTER_FOCAL&);
      FILTER_FOCAL& operator= (const FILTER_FOCAL&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_MULTIPLICATIVE : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_MULTIPLICATIVE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         const MIMATRIX& matrix,             
         double AmountFilterPct = 100.0,     
         bool UseCenterForNull = false       
         );

      FILTER_FOCAL_MULTIPLICATIVE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         const MIMATRIX& matrix,             
         double AmountFilterPct = 100.0,     
         bool UseCenterForNull = false       
         );

      virtual ~FILTER_FOCAL_MULTIPLICATIVE ();

      const MIMATRIX& GetMatrix (
         ) const { return m_Matrix; }

      void SetMatrix (
         const MIMATRIX& matrix
         ) { m_Matrix = matrix; }

      void SetTestWeightGreaterThanOne (
         ) { m_TestWeightGreaterThanOne = true; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      bool m_DoReplaceCenter;
      bool m_TestWeightGreaterThanOne;
      MIMATRIX m_Matrix;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_MULTIPLICATIVE (const FILTER_FOCAL_MULTIPLICATIVE&);
      FILTER_FOCAL_MULTIPLICATIVE& operator= (const FILTER_FOCAL_MULTIPLICATIVE&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_GRADIENT : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_GRADIENT (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         const MIMATRIX& matrixA,            
         const MIMATRIX& matrixB,            
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_GRADIENT (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         const MIMATRIX& matrixA,            
         const MIMATRIX& matrixB,            
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_GRADIENT ();

      const MIMATRIX& GetMatrixA (
         ) const { return m_MatrixA; }

      void SetMatrixA (
         const MIMATRIX& matrix
         ) { m_MatrixA = matrix; }

      const MIMATRIX& GetMatrixB (
         ) const { return m_MatrixB; }

      void SetMatrixB (
         const MIMATRIX& matrix
         ) { m_MatrixB = matrix; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MIMATRIX m_MatrixA;
      MIMATRIX m_MatrixB;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_GRADIENT (const FILTER_FOCAL_GRADIENT&);
      FILTER_FOCAL_GRADIENT& operator= (const FILTER_FOCAL_GRADIENT&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_STATISTICS : public FILTER_FOCAL {
   public:

      enum STAT_TYPE {
         STAT_TYPE_Mean,
         STAT_TYPE_Median,
         STAT_TYPE_Majority,
         STAT_TYPE_Minority,
         STAT_TYPE_Maximum,
         STAT_TYPE_Minimum,
         STAT_TYPE_StdDev,
         STAT_TYPE_Sum,
         STAT_TYPE_Variance,
         STAT_TYPE_Variety
         };

      FILTER_FOCAL_STATISTICS (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAT_TYPE Type,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_STATISTICS (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         STAT_TYPE Type,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_STATISTICS ();      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      STAT_TYPE m_Type;
      DOUBLE_ARRAY<double> m_ValueArray;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_STATISTICS (const FILTER_FOCAL_STATISTICS&);
      FILTER_FOCAL_STATISTICS& operator= (const FILTER_FOCAL_STATISTICS&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_LUM : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_LUM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         int EdgeParam,                      
         int NoiseParam,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_LUM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         int EdgeParam,                      
         int NoiseParam,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_LUM ();    

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_EdgeParam;
      int m_NoiseParam;
      DOUBLE_ARRAY<double> m_ValueArray;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_LUM (const FILTER_FOCAL_LUM&);
      FILTER_FOCAL_LUM& operator= (const FILTER_FOCAL_LUM&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_CS : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_CS (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         int RankParam,                      
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_CS (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         int RankParam,                      
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_CS ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_RankParam;
      DOUBLE_ARRAY<double> m_ValueArray;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_CS (const FILTER_FOCAL_CS&);
      FILTER_FOCAL_CS& operator= (const FILTER_FOCAL_CS&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_WMMR : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_WMMR (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         double WeightParam,                 
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      FILTER_FOCAL_WMMR (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         double WeightParam,                 
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      virtual ~FILTER_FOCAL_WMMR ();      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_WeightParam;
      DOUBLE_ARRAY<double> m_ValueArray;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_WMMR (const FILTER_FOCAL_WMMR&);
      FILTER_FOCAL_WMMR& operator= (const FILTER_FOCAL_WMMR&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_PMEDIAN : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_PMEDIAN (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         double WeightParam,                 
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      FILTER_FOCAL_PMEDIAN (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         double WeightParam,                 
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      virtual ~FILTER_FOCAL_PMEDIAN ();      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_WeightParam;
      DOUBLE_ARRAY<double> m_ValueArrayA;
      DOUBLE_ARRAY<double> m_ValueArrayB;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_PMEDIAN (const FILTER_FOCAL_PMEDIAN&);
      FILTER_FOCAL_PMEDIAN& operator= (const FILTER_FOCAL_PMEDIAN&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_LEE : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_LEE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_LEE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_LEE ();    

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_LEE (const FILTER_FOCAL_LEE&);
      FILTER_FOCAL_LEE& operator= (const FILTER_FOCAL_LEE&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_MLM : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_MLM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_MLM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_MLM ();    

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DOUBLE_ARRAY<double> m_ValueArrayA;
      DOUBLE_ARRAY<double> m_ValueArrayB;
      DOUBLE_ARRAY<double> m_ValueArrayC;
      DOUBLE_ARRAY<double> m_ValueArrayD;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_MLM (const FILTER_FOCAL_MLM&);
      FILTER_FOCAL_MLM& operator= (const FILTER_FOCAL_MLM&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_RANGE : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_RANGE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         double ContrastParam,               
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_RANGE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         double ContrastParam,               
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_RANGE ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ContrastParam;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_RANGE (const FILTER_FOCAL_RANGE&);
      FILTER_FOCAL_RANGE& operator= (const FILTER_FOCAL_RANGE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_OLYMPIC : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_OLYMPIC (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         int NumDiscard,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_OLYMPIC (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         int NumDiscard,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_OLYMPIC ();      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_NumDiscard;
      DOUBLE_ARRAY<double> m_ValueArray;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_OLYMPIC (const FILTER_FOCAL_OLYMPIC&);
      FILTER_FOCAL_OLYMPIC& operator= (const FILTER_FOCAL_OLYMPIC&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_TEAGER : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_TEAGER (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_TEAGER (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_TEAGER ();    

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MIMATRIX m_Matrix;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_TEAGER (const FILTER_FOCAL_TEAGER&);
      FILTER_FOCAL_TEAGER& operator= (const FILTER_FOCAL_TEAGER&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_VOLTERRA : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_VOLTERRA (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         double ContrastParam,               
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_VOLTERRA (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         double ContrastParam,               
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_VOLTERRA ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ContrastParam;

      MIMATRIX m_Matrix;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_VOLTERRA (const FILTER_FOCAL_VOLTERRA&);
      FILTER_FOCAL_VOLTERRA& operator= (const FILTER_FOCAL_VOLTERRA&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_FROST : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_FROST (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_FROST (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_FROST ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MIMATRIX m_MatDistance;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_FROST (const FILTER_FOCAL_FROST&);
      FILTER_FOCAL_FROST& operator= (const FILTER_FOCAL_FROST&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_AMPM : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_AMPM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STATSVALIDITY StatsValidity,        
         double WeightParam,                 
         double SigmaParam,                  
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      FILTER_FOCAL_AMPM (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         STATSVALIDITY StatsValidity,        
         double WeightParam,                 
         double SigmaParam,                  
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns                    
         );

      virtual ~FILTER_FOCAL_AMPM ();      

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_WeightParam;
      double m_SigmaParam;
      DOUBLE_ARRAY<double> m_Sigmas;
      STATSVALIDITY m_StatsValidity;
      DOUBLE_ARRAY<double> m_ValueArrayA;
      DOUBLE_ARRAY<double> m_ValueArrayB;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_AMPM (const FILTER_FOCAL_AMPM&);
      FILTER_FOCAL_AMPM& operator= (const FILTER_FOCAL_AMPM&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_KUANADAPTIVE : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_KUANADAPTIVE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STATSVALIDITY StatsValidity,        
         double SigmaParam,                  
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_KUANADAPTIVE (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         STATSVALIDITY StatsValidity,        
         double SigmaParam,                  
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_KUANADAPTIVE ();    

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_SigmaParam;
      DOUBLE_ARRAY<double> m_Sigmas;
      STATSVALIDITY m_StatsValidity;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_KUANADAPTIVE (const FILTER_FOCAL_KUANADAPTIVE&);
      FILTER_FOCAL_KUANADAPTIVE& operator= (const FILTER_FOCAL_KUANADAPTIVE&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_SIGMA : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_SIGMA (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STATSVALIDITY StatsValidity,        
         double SigmaParam,                  
         int KThreshold,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      FILTER_FOCAL_SIGMA (
         STAGE *pSourceImage,                
         bool TakeOwnershipSource,           
         STAGE *pMaskImage,                  
         bool TakeOwnershipMask,             
         STATSVALIDITY StatsValidity,        
         double SigmaParam,                  
         int KThreshold,                     
         UINT32 NumFocalRows,                
         UINT32 NumFocalColumns,             
         double AmountFilterPct = 100.0      
         );

      virtual ~FILTER_FOCAL_SIGMA ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_SigmaParam;
      DOUBLE_ARRAY<double> m_Sigmas;
      STATSVALIDITY m_StatsValidity;
      int m_KThreshold;
      DOUBLE_ARRAY<double> m_ValueArrayA;
      DOUBLE_ARRAY<double> m_ValueArrayB;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_SIGMA (const FILTER_FOCAL_SIGMA&);
      FILTER_FOCAL_SIGMA& operator= (const FILTER_FOCAL_SIGMA&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class FILTER_FOCAL_CONTRAST : public FILTER_FOCAL {
   public:

      FILTER_FOCAL_CONTRAST (
         STAGE *pSourceImage,                   
         bool TakeOwnershipSource,              
         STATSVALIDITY StatsValidity,           
         double SigmaParam,                     
         double ContrastParam,                  
         UINT32 NumFocalRows,                   
         UINT32 NumFocalColumns,                
         double AmountFilterPct = 100.0         
         );

      FILTER_FOCAL_CONTRAST (
         STAGE *pSourceImage,                   
         bool TakeOwnershipSource,              
         STAGE *pMaskImage,                     
         bool TakeOwnershipMask,                
         STATSVALIDITY StatsValidity,           
         double SigmaParam,                     
         double ContrastParam,                  
         UINT32 NumFocalRows,                   
         UINT32 NumFocalColumns,                
         double AmountFilterPct = 100.0         
         );

      virtual ~FILTER_FOCAL_CONTRAST ();     

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ContrastParam;
      double m_SigmaParam;

      DOUBLE_ARRAY<double> m_Means;
      DOUBLE_ARRAY<double> m_Sigmas;
      STATSVALIDITY m_StatsValidity;
      DOUBLE_ARRAY<double> m_ValueArrayA;
      DOUBLE_ARRAY<double> m_ValueArrayB;

      // STAGE/FILTER overrides.
      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullSubSection (const SECTION& SubSection, BUFFER& buffer);

      // Unimplemented
      FILTER_FOCAL_CONTRAST (const FILTER_FOCAL_CONTRAST&);
      FILTER_FOCAL_CONTRAST& operator= (const FILTER_FOCAL_CONTRAST&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

}  // End namespace IMAGE
}  // End namespace SPATMOD

#endif   // INC_SPATMOD_IMAGEFILTERFOCAL_H

---