mi32/contrastparm.h

Go to the documentation of this file.

#ifndef  INC_MI32_CONTRASTPARM_H
#define  INC_MI32_CONTRASTPARM_H

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef  INC_MI32_RANGE_H
   #include <mi32/range.h>
#endif

#ifndef  INC_MI32_NUMTYPE_H
   #include <mi32/numtype.h>
#endif

#ifdef RVCSYSDLL
   #define LIBEXPORT MI_DLLEXPORT
   #define CLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define LIBEXPORT MI_DLLIMPORT
   #define CLASSEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class STAT_UNIVARIATE;
class SERIALIZERITEM;
#endif

//  If changed must rebuild DLL and all dependent executables.
class CLASSEXPORT CONTRASTPARM {
   public:

      // Values are stored in files and may not change.
      enum METHOD {
         METHOD_None =              0, 
         METHOD_Linear =            1, 
         METHOD_Normalize =         2, 
         METHOD_Equalize =          3, 
         METHOD_Exponential =       4, 
//       METHOD_PiecewiseLinear =   5, //!< Piecewise linear
//       METHOD_Threshold =         6, //!< Thresholding
         METHOD_SavedTable =        7, 
                                 // 8 skipped to avoid conflict with legacy code
         METHOD_Logarithmic =       9, 
         METHOD_Constant =          10
         };

      CONTRASTPARM ();

      CONTRASTPARM (
         const CONTRASTPARM& rhs
         );

      ~CONTRASTPARM ();

      CONTRASTPARM& operator= (
         const CONTRASTPARM& rhs
         );

      void AttachTable (
         UINT8 *& Table,                     
         UINT32 NumItems,                    
         double TableBinMinimum,             
         double TableBinInterval             
         );

      bool CanComputeWithoutStats () const;

      void Clear ();

      void ClearTable ();

      ERRVALUE ComputeTable (
         const STAT_UNIVARIATE& stats,    
         const float *outspec = 0         
         );

      ERRVALUE ComputeTable ();

      void DetachTable (
         SIMPLE_ARRAY<UINT8>& Table
         ) { Table.Swap(m_Table); m_Table.Clear(); }

      const DOUBLE_RANGE& GetInputRangePct (
         ) const { return (m_InputRangePct); }

      const DOUBLE_RANGE& GetInputStretchRange (
         ) const { return (m_InputRangeAbsolute); }

      bool GetInvert (
         ) const { return (m_Invert); }

      METHOD GetMethod (
         ) const { return (m_Method); }

      double GetPower (
         ) const { return (m_Power); }

      UINT8 GetOutputAboveMaxBin (
         ) const { return (m_OutAboveMaxBin); }

      UINT8 GetOutputBelowMinBin (
         ) const { return (m_OutBelowMinBin); }

      UINT8 GetOutputConstant (
         ) const { return (m_OutConstant); }

      UINT8 GetOutputInvalid (
         ) const { return (m_OutInvalid); }

      UINT8 GetOutputMedian (
         ) const { return (m_OutMedian); }

      UINT8 GetOutputStdDevAboveMedian (
         ) const { return (m_OutStdDevAboveMedian); }

      UINT8 GetOutputStdDevBelowMedian (
         ) const { return (m_OutStdDevBelowMedian); }

      UINT8 GetOutputStretchMax (
         ) const { return (m_OutStretchMax); }

      UINT8 GetOutputStretchMin (
         ) const { return (m_OutStretchMin); }

      const SIMPLE_ARRAY<UINT8>& GetTable (
         ) const { return (m_Table); }

      double GetTableBinInterval (
         ) const { return (m_TableBinInterval); }

      const DOUBLE_RANGE& GetTableBinRange (
         ) const { return (m_TableBinRange); }

      bool HasTable (
         ) const { return (!m_Table.IsEmpty()); }

      bool IsInputRangePct (
         ) const { return (m_InputRangeUsePct); }

      ERRVALUE Process (
         UINT32 count,                       
         const UINT8 *ibuffer,               
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const INT8 *ibuffer,                
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const UINT16 *ibuffer,              
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const INT16 *ibuffer,               
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const UINT32 *ibuffer,              
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const INT32 *ibuffer,               
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const float *ibuffer,               
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const double *ibuffer,              
         const UINT8 *validity,              
         UINT8 *obuffer                      
         ) const;

      ERRVALUE Process (
         UINT32 count,                       
         const void *ibuffer,                
         const UINT8 *validity,              
         UINT8 *obuffer,                     
         NUMTYPE NumType                     
         ) const;

      void SetConstant (
         UINT8 OutConstant
         );

      void SetExponential (
         double power
         );

      void SetInputRangePct (
         double MinPct,                
         double MaxPct                 
         );

      void SetInputRangeUsePct (
         bool InputRangeUsePct               
         ) { m_InputRangeUsePct = InputRangeUsePct; }

      void SetInputStretchMax (
         double value
         ) { m_InputRangeAbsolute.SetMaximum(value); }

      void SetInputStretchMin (
         double value
         ) { m_InputRangeAbsolute.SetMinimum(value); }

      void SetInputStretchRange (
         const DOUBLE_RANGE InputRangeAbsolute
         ) { m_InputRangeUsePct = false; m_InputRangeAbsolute = InputRangeAbsolute; }

      void SetInvert (
         bool Invert
         ) { m_Invert = Invert; }

      void SetMethod (
         METHOD method,                   
         bool usedefaults = true          
         );

      void SetNormalize (
         UINT8 median,
         UINT8 StDevBelowMedian = 50,
         UINT8 StDevAboveMedian = 50
         );

      void SetOutputAboveMaxBin (
         UINT8 OutAboveMaxBin
         ) { m_OutAboveMaxBin = OutAboveMaxBin; }

      void SetOutputBelowMinBin (
         UINT8 OutBelowMinBin
         ) { m_OutBelowMinBin = OutBelowMinBin; }

      void SetOutputInvalid (
         UINT8 OutInvalid
         ) { m_OutInvalid = OutInvalid; }

      void SetOutputMedian (
         UINT8 median
         ) { m_OutMedian = median; }

      void SetOutputStdDevAboveMedian (
         UINT8 StdDevAboveMedian
         ) { m_OutStdDevAboveMedian = StdDevAboveMedian; }

      void SetOutputStdDevBelowMedian (
         UINT8 StdDevBelowMedian
         ) { m_OutStdDevBelowMedian = StdDevBelowMedian; }

      void SetOutputStretchMax (
         UINT8 OutStretchMax
         ) { m_OutStretchMax = OutStretchMax; }

      void SetOutputStretchMin (
         UINT8 OutStretchMin
         ) { m_OutStretchMin = OutStretchMin; }

      ERRVALUE SetTable (
         const SIMPLE_ARRAY<UINT8>& Table,   
         double TableBinMinimum,             
         double TableBinInterval             
         );

      ERRVALUE SetTableBinRange (
         const DOUBLE_RANGE TableBinRange,
         double BinInterval
         );

      static const SERIALIZERITEM* SerialGetItemDef ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      typedef CONTRASTPARM THISCLASS;
      DOUBLE_RANGE m_InputRangePct;       // Input stretch percentage range
      DOUBLE_RANGE m_InputRangeAbsolute;  // Input stretch absolute range
      DOUBLE_RANGE m_TableBinRange;       // Table bin range
      double m_TableBinInterval;          // Table bin interval
      double m_Power;                     // Power for exponential methd
      METHOD m_Method;                    // Contrast method
      UINT8 m_OutStretchMin;              // Output value for minimum stretch value
      UINT8 m_OutStretchMax;              // Output value for maximum stretch value
      UINT8 m_OutMedian;                  // Median for normalization method
      UINT8 m_OutStdDevBelowMedian;       // Std deviation below median for normalization
      UINT8 m_OutStdDevAboveMedian;       // Std deviation above median for normalization
      UINT8 m_OutBelowMinBin;             // Value to output if input < bin range minimum
      UINT8 m_OutAboveMaxBin;             // Value to output if input >= bin range maximum
      UINT8 m_OutInvalid;                 // Value to output if input not valid
      UINT8 m_OutConstant;                // Value to output if IsConstant bit set
      bool m_Invert;                      // Invert table
      bool m_UseDirectUINT8;
      bool m_InputRangeUsePct;               // Input range is percentage
      SIMPLE_ARRAY<UINT8> m_Table;        // Lookup table

      ERRVALUE ComputeBinIdxRangeUsed (int& MinBinIdx, int& MaxBinIdx) const;
      void ComputeNormalSpec (float *spec) const;
      ERRVALUE ComputeTableNoStats (int NumBins = 0);
      void GetBinMinMaxInt (INT32& BinMinVal, INT32& BinMaxVal, INT32& BinInterval) const;
      void GetBinMinMaxInt (UINT32& BinMinVal, UINT32& BinMaxVal, UINT32& BinInterval) const;
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


#undef   LIBEXPORT
#undef   CLASSEXPORT

#endif   // INC_CONTRASTPARM_H

---