spatmod/imagebuffer.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGEBUFFER_H
#define  INC_SPATMOD_IMAGEBUFFER_H

#ifndef  INC_SPATMOD_IMAGEPIXEL_H
#include <spatmod/imagepixel.h>
#endif

#ifndef  INC_SPATMOD_LOGICALOP_H
#include <spatmod/logicalop.h>
#endif

namespace SPATMOD {

class DATABUFFER;

namespace IMAGE {

class SAMPLEITERATOR;
class SAMPLEITERATOR_CONST;

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

class BUFFER {
   public:

      enum COPYFLAGS {
         COPYFLAG_None =         0x0000,
         COPYFLAG_KeepValid =    0x0001,  
         COPYFLAG_NoInvalid =    0x0002,  
         };

      BUFFER (
         );

      BUFFER (
         const BUFFER& rhs
         );

      ~BUFFER ();

      BUFFER& operator= (
         const BUFFER& rhs
         );

      ERRVALUE CheckRectangle (
         INT32 StartColumn,
         INT32 StartRow,
         UINT32 NumColumns,
         UINT32 NumRows
         ) const;

      ERRVALUE CopyFrom (
         INT32 TgtMinColumn,
         INT32 TgtMinRow,
         const BUFFER& SrcBuffer,
         INT32 SrcMinColumn,
         INT32 SrcMinRow,
         UINT32 SrcNumColumns,
         UINT32 SrcNumRows
         );

      ERRVALUE Create (
         const PIXEL& PixelProperties,
         UINT32 NumColumns,
         UINT32 NumRows,
         void **data = 0,
         UINT8 *validity = 0
         );

      ERRVALUE Create (
         BUFFER& existing,                
         INT32 ColOffset,                 
         INT32 RowOffset,                 
         UINT32 WinColumns,               
         UINT32 WinRows                   
         );

      ERRVALUE CreateSubset (
         BUFFER& existing,                
         const UINT16 *SampleIdxs,        
         UINT16 NumSamples,               
         bool OwnValidity                 
         );

      void Destroy (
         );

      ERRVALUE ExportRowBIP (
         void *target,                    
         UINT32 row,                      
         UINT32 StartColumn = 0,          
         UINT32 NumColumns = 0,           
         bool SkipInvalid = false,        
         const UINT16 *SampleTrans = 0,   
         UINT16 NumSamplesTrans = 0,      
         int OutputPixelBytes = 0         
         ) const;

      ERRVALUE ExportRowBIP (
         void *target,                    
         const PIXEL& nullpixel,          
         UINT32 row,                      
         UINT32 StartColumn = 0,          
         UINT32 NumColumns = 0            
         ) const;

      ERRVALUE GetIterator (
         SAMPLEITERATOR_CONST& iterator,  
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         ) const;

      ERRVALUE GetIterator (
         SAMPLEITERATOR& iterator,        
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         );

      UINT32 GetNumColumns (
         ) const { return (m_WinNumColumns); }

      UINT32 GetNumRows (
         ) const { return (m_WinNumRows); }

      UINT32 GetNumRowBytes (
         UINT16 SampleNum
         ) const { return (m_WinNumColumns * m_SampleBytes[SampleNum]); }

      UINT32 GetNumSampleBytes (
         UINT16 SampleNum
         ) const { return (m_SampleBytes[SampleNum]); }

      UINT16 GetNumSamples (
         ) const { return (m_PixelProperties.GetNumSamples()); }

      const PIXEL& GetPixelProperties (
         ) const { return (m_PixelProperties); }

      const void *GetPtrSample (
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         ) const;

      void *GetPtrSample (
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         );

      const void *GetPtrSampleFast (
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         ) const {
         #ifdef PTRS_ARE_64_BIT
            return (static_cast<const UINT8*>(m_TotSampleBase[SampleNum]) + (row + static_cast<INT64>(m_WinOffRow)) * static_cast<INT64>(m_RowBytes[SampleNum]) + (column + static_cast<INT64>(m_WinOffColumn)) * static_cast<INT64>(m_SampleBytes[SampleNum]));
         #else
            return (static_cast<const UINT8*>(m_TotSampleBase[SampleNum]) + (row + m_WinOffRow) * m_RowBytes[SampleNum] + (column + m_WinOffColumn) * m_SampleBytes[SampleNum]);
         #endif
         }

      void *GetPtrSampleFast (
         UINT16 SampleNum,                
         INT32 row,                       
         INT32 column = 0                 
         ) {
         #ifdef PTRS_ARE_64_BIT
            return (static_cast<UINT8*>(m_TotSampleBase[SampleNum]) + (row + static_cast<INT64>(m_WinOffRow)) * static_cast<INT64>(m_RowBytes[SampleNum]) + (column + static_cast<INT64>(m_WinOffColumn)) * static_cast<INT64>(m_SampleBytes[SampleNum]));
         #else
            return (static_cast<UINT8*>(m_TotSampleBase[SampleNum]) + (row + m_WinOffRow) * m_RowBytes[SampleNum] + (column + m_WinOffColumn) * m_SampleBytes[SampleNum]);
         #endif
         }

      void ** GetPtrSamplesBase (
         ) { return (m_TotSampleBase); }

      const UINT8 *GetPtrValidity (
         INT32 row,                       
         INT32 column = 0                 
         ) const;

      UINT8 *GetPtrValidity (
         INT32 row,                       
         INT32 column = 0                 
         );

      const UINT8 *GetPtrValidityFast (
         INT32 row,                       
         INT32 column = 0                 
         ) const { return (m_TotValidityBase + (row + m_WinOffRow) * m_TotNumColumns + column + m_WinOffColumn); }

      UINT8 *GetPtrValidityFast (
         INT32 row,                       
         INT32 column = 0                 
         ) { return (m_TotValidityBase + (row + m_WinOffRow) * m_TotNumColumns + column + m_WinOffColumn); }

      UINT32 GetTotalColumns (
         ) const { return (m_TotNumColumns); }

      UINT32 GetTotalRows (
         ) const { return (m_TotNumRows); }

      UINT32 GetTotalRowBytes (
         UINT16 SampleNum
         ) const { return (m_RowBytes[SampleNum]); }

      UINT32 GetWindowColumn (
         ) const { return (m_WinOffColumn); }

      UINT32 GetWindowRow (
         ) const { return (m_WinOffRow); }

      ERRVALUE ImportRowBIP (
         const void *source,              
         const UINT8 *validity,           
         UINT32 row,                      
         UINT32 StartColumn = 0,          
         UINT32 NumColumns = 0            
         );

      ERRVALUE ImportRowBIP (
         const void *source,              
         const PIXEL& nullpixel,          
         UINT32 row,                      
         UINT32 StartColumn = 0,          
         UINT32 NumColumns = 0            
         );

      bool IsContiguous (
         ) const { return (m_IsContiguous); }

      bool IsCreated (
         ) const;

      ERRVALUE SetInvalid (
         INT32 StartColumn,               
         INT32 StartRow,                  
         UINT32 NumColumns,               
         UINT32 NumRows                   
         );

      void SetValidityAll (
         bool validity                    
         );

      ERRVALUE SetValidityLogical (
         LOGICALOP operation,             
         const BUFFER& buffer             
         );

      void ShiftWindowFast (
         INT32 DeltaColumn,
         INT32 DeltaRow
         ) { m_WinOffColumn += DeltaColumn; m_WinOffRow += DeltaRow; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DATABUFFER *m_pSampleBuffer;
      DATABUFFER *m_pValidityBuffer;
      void **m_TotSampleBase;
      UINT8 *m_TotValidityBase;
      UINT32 *m_SampleBytes;
      UINT32 *m_RowBytes;
      PIXEL m_PixelProperties;
      UINT32 m_TotNumRows;
      UINT32 m_TotNumColumns;
      UINT32 m_WinNumRows;
      UINT32 m_WinNumColumns;
      UINT32 m_WinOffRow;
      UINT32 m_WinOffColumn;
      bool m_IsContiguous;

      void CopyRef (const BUFFER& rhs);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(BUFFER::COPYFLAGS);
#endif

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

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

#endif    // INC_SPATMOD_IMAGEBUFFER_H

---