spatmod/imagefilterdatatype.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGEFILTERDATATYPE_H
#define  INC_SPATMOD_IMAGEFILTERDATATYPE_H

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

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

namespace SPATMOD {
namespace IMAGE {

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

class FILTER_DATATYPE : public FILTER {
   public:

      enum MODE {
         MODE_Source =           0,    
         MODE_RoundLimit =       1,    
         MODE_RoundInvalidate =  2,    
         MODE_RoundRescale =     3,    
         MODE_RoundNoCheck =     4,    
         MODE_FloorLimit =       5,    
         MODE_FloorInvalidate =  6,    
         MODE_FloorRescale =     7,    
         MODE_FloorNoCheck =     8,    
         MODE_Limit = MODE_RoundLimit,
         MODE_Invalidate = MODE_RoundInvalidate,
         MODE_Rescale = MODE_RoundRescale,
         MODE_NoCheck = MODE_RoundNoCheck,
         };

      class SETTINGS {
         public:
            SETTINGS ();
            SETTINGS (
               DATATYPE DataType,
               MODE Mode
               );
            SETTINGS (
               DATATYPE DataType,
               MODE Mode,
               double MinValue,
               double MaxValue
               );
            MODE GetMode (
               ) const { return (m_Mode); }
            DATATYPE GetDataType (
               ) const { return (m_DataType); }
            bool GetDoFloor (
               ) const { return (m_DoFloor); }
            double GetMaxValue (
               ) const { return (m_MaxValue); }
            double GetMinValue (
               ) const { return (m_MinValue); }
            double GetOffset (
               ) const { return (m_Offset); }
            int GetPrecision (
               ) const {return (m_Precision); }
            double GetScale (
               ) const { return (m_Scale); }
            bool IsRangeFull (
               ) const { return (m_IsRangeFull); }
            bool IsRangeValid (
               ) const;
            void SetDataType (
               DATATYPE DataType
               );
            void SetDoFloor (
               bool DoFloor = true
               ) { m_DoFloor = DoFloor; }
            void SetMode (
               MODE Mode
               ) { m_Mode = Mode; }
            void SetPrecision (
               int Precision
               ) { m_Precision = Precision; }
            void SetRange (
               double MinValue,
               double MaxValue
               );

            #ifndef GENERATING_DOXYGEN_OUTPUT
            // Compute default range based on data type.
            void ComputeRangeDefault (
               );
            // Compute scale/offset for MODE_Round/FloorRescale.
            void ComputeScaleOffset (
               double SrcMinValue,
               double SrcMaxValue
               );
            // Process samples 
            void Process (
               SAMPLEITERATOR& itTgt,
               UINT8 *TgtValidity,
               SAMPLEITERATOR& itSrc,
               INT32 NumColumns
               ) const;
         private:
            double m_MinValue;
            double m_MaxValue;
            double m_Scale;
            double m_Offset;
            int m_Precision;
            MODE m_Mode;
            DATATYPE m_DataType;
            bool m_IsRangeFull;
            bool m_DoFloor;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      FILTER_DATATYPE (
         STAGE *pSourceImage,                
         bool TakeOwnership,                 
         DATATYPE TargetDataType,            
         MODE Mode,                          
         bool PassOpacity = true             
         );

      FILTER_DATATYPE (
         STAGE *pSourceImage,                
         bool TakeOwnership,                 
         DATATYPE TargetDataType,            
         MODE Mode,                          
         double MinValue,                    
         double MaxValue,                    
         bool PassOpacity = true             
         );

      FILTER_DATATYPE (
         STAGE *pSourceImage,                
         bool TakeOwnership,                 
         DATATYPE TargetDataType,            
         int Precision,                   
         MODE Mode,                          
         bool PassOpacity = true             
         );

      FILTER_DATATYPE (
         STAGE *pSourceImage,                
         bool TakeOwnership,                 
         DATATYPE TargetDataType,            
         int Precision,                   
         MODE Mode,                          
         double MinValue,                    
         double MaxValue,                    
         bool PassOpacity = true             
         );

      FILTER_DATATYPE (
         STAGE *pSourceImage,                
         bool TakeOwnership,                 
         const SETTINGS *Settings            
         );

      // Destructor.
      virtual ~FILTER_DATATYPE ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SETTINGS *m_Settings;                  // Settings indexed by sample number

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

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

   };

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

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

#endif   // INC_SPATMOD_IMAGEFILTERDATATYPE_H

---