spatmod/imagesampleiterator.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGESAMPLEITERATOR_H
#define  INC_SPATMOD_IMAGESAMPLEITERATOR_H

#ifndef  INC_SPATMOD_DATATYPE_H
#include <spatmod/datatype.h>
#endif

#ifndef  INC_MI32_DELEGATE_H
#include <mi32/delegate.h>
#endif

namespace SPATMOD {
namespace IMAGE {

class SAMPLEITERATOR;

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

class SAMPLEITERATOR_CONST {
   public:

      SAMPLEITERATOR_CONST ();

      SAMPLEITERATOR_CONST (
         void *pSample,
         DATATYPE DataType
         );

      ~SAMPLEITERATOR_CONST ();

      SAMPLEITERATOR_CONST& operator++ (
         ) { m_pSample += m_SampleBytes; return (*this); }

      SAMPLEITERATOR_CONST& operator-- (
         ) { m_pSample -= m_SampleBytes; return (*this); }

      SAMPLEITERATOR_CONST& operator+= (
         int num
         ) { m_pSample += m_SampleBytes * num; return (*this); }

      SAMPLEITERATOR_CONST& operator-= (
         int num
         ) { m_pSample -= m_SampleBytes * num; return (*this); }

      ERRVALUE Attach (
         void *pSample,                
         DATATYPE DataType             
         );

      void Attach (
         void *pSample                 
         ) { m_pSample = static_cast<UINT8*>(pSample); }

      bool GetBool (
         ) const { return (m_DelegateGetBool(m_pSample)); }

      bool GetBool (
         int offset                    
         ) const { return (m_DelegateGetBool(m_pSample+offset*m_SampleBytes)); }

      double GetDouble (
         ) const { return (m_DelegateGetDouble(m_pSample)); }

      double GetDouble (
         int offset                    
         ) const { return (m_DelegateGetDouble(m_pSample+offset*m_SampleBytes)); }

      void GetDoubles (
         double *values,               
         int count                     
         ) const { m_DelegateGetDoubles(m_pSample,values,count); }

      void GetDoubles (
         double *values,               
         int count,                    
         int offset                    
         ) const { m_DelegateGetDoubles(m_pSample+offset*m_SampleBytes,values,count); }

      INT32 GetINT32_Floor (
         ) const { return (static_cast<INT32>(m_DelegateGetUINT32_Floor(m_pSample))); }

      INT32 GetINT32_Floor (
         int offset                    
         ) const { return (static_cast<INT32>(m_DelegateGetUINT32_Floor(m_pSample+offset*m_SampleBytes))); }

      UINT32 GetUINT32_Floor (
         ) const { return (m_DelegateGetUINT32_Floor(m_pSample)); }

      UINT32 GetUINT32_Floor (
         int offset                    
         ) const { return (m_DelegateGetUINT32_Floor(m_pSample+offset*m_SampleBytes)); }

      const void *GetPtr (
         ) const { return (m_pSample); }

      const void *GetPtr (
         int offset                    
         ) const { return (m_pSample+offset*m_SampleBytes); }

      int GetSampleBytes (
         ) const { return (m_SampleBytes); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      typedef FastDelegate<bool(const void*)> DELEGATE_GETBOOL;
      typedef FastDelegate<double(const void*)> DELEGATE_GETDOUBLE;
      typedef FastDelegate<void(const void*, double*, int)> DELEGATE_GETDOUBLES;
      typedef FastDelegate<UINT32(const void*)> DELEGATE_GETUINT32;
      typedef FastDelegate<void(void*, bool)> DELEGATE_PUTBOOL;
      typedef FastDelegate<void(void*, double)> DELEGATE_PUTDOUBLE;
      UINT8 *m_pSample;
      int m_SampleBytes;
      DELEGATE_GETBOOL m_DelegateGetBool;
      DELEGATE_GETDOUBLE m_DelegateGetDouble;
      DELEGATE_GETDOUBLES m_DelegateGetDoubles;
      DELEGATE_GETUINT32 m_DelegateGetUINT32_Floor;
      DELEGATE_PUTBOOL m_DelegatePutBool;
      DELEGATE_PUTDOUBLE m_DelegatePutDoubleFastRound;
      DELEGATE_PUTDOUBLE m_DelegatePutDoubleFastFloor;
      DELEGATE_PUTDOUBLE m_DelegatePutDoubleLimitRound;
      DELEGATE_PUTDOUBLE m_DelegatePutDoubleLimitFloor;
      friend class SAMPLEITERATOR;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

class SAMPLEITERATOR : public SAMPLEITERATOR_CONST {
   public:

      SAMPLEITERATOR (
         ) { }

      SAMPLEITERATOR (
         void *pSample,
         DATATYPE DataType
         ): SAMPLEITERATOR_CONST(pSample,DataType) { }

      SAMPLEITERATOR& operator++ (
         ) { m_pSample += m_SampleBytes; return (*this); }

      SAMPLEITERATOR& operator-- (
         ) { m_pSample -= m_SampleBytes; return (*this); }

      void *GetPtr (
         ) const { return (m_pSample); }

      void *GetPtr (
         int offset                    
         ) const { return (m_pSample+offset*m_SampleBytes); }

      void PutBool (
         bool value
         ) const { m_DelegatePutBool(m_pSample,value); }

      void PutValueFast (
         const void *pValue            
         ) const { if (m_SampleBytes == 1) *m_pSample = *static_cast<const UINT8*>(pValue); else memcpy(m_pSample,pValue,m_SampleBytes); }

      void PutValueFastRound (
         double value
         ) const { m_DelegatePutDoubleFastRound(m_pSample,value); }

      void PutValueFastFloor (
         double value
         ) const { m_DelegatePutDoubleFastFloor(m_pSample,value); }

      void PutValueLimitRound (
         double value
         ) const { m_DelegatePutDoubleLimitRound(m_pSample,value); }

      void PutValueLimitFloor (
         double value
         ) const { m_DelegatePutDoubleLimitFloor(m_pSample,value); }

   };

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

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

#endif   // INC_SPATMOD_IMAGESAMPLEITERATOR_H

---