spatmod/imagesection.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGESECTION_H
#define  INC_SPATMOD_IMAGESECTION_H

#ifndef  INC_SPATMOD_IMAGESPANS_H
#include <spatmod/imagespans.h>
#endif

#ifndef  INC_MI32_MATH_H
#include <mi32/math.h>
#endif

struct DRECT2D;
struct LRECT2D;

namespace SPATMOD {
namespace IMAGE {

class BASE;
class DIMENSIONS;
class SECTION_ITERATOR;

//=====================================================================================================================
class SECTION {
   public:

      enum POSITION {
         POSITION_Unknown =               0,
         POSITION_TileColumnFirst =       0x0001,
         POSITION_TileColumnInterior =    0x0002,
         POSITION_TileColumnLast =        0x0004,
         POSITION_TileRowFirst =          0x0010,
         POSITION_TileRowInterior =       0x0020,
         POSITION_TileRowLast =           0x0040,
         POSITION_StripFirst =            0x0100,
         POSITION_StripInterior =         0x0200,
         POSITION_StripLast =             0x0400,
         };

      SECTION ();

      SECTION (
         const BASE& image,
         double zoom = 1
         );

      explicit SECTION (
         const DRECT2D& rect,
         double zoom = 1
         );

      explicit SECTION (
         const LRECT2D& rect,
         double zoom = 1
         );

      SECTION (
         double MinX,
         double MinY,
         double SizeX,
         double SizeY,
         double zoom = 1,
         POSITION position = POSITION_Unknown
         );

      INT32 ComputeMaxColumn (
         ) const;

      INT32 ComputeMaxRow (
         ) const;

      INT32 ComputeMinColumn (
         ) const;

      INT32 ComputeMinRow (
         ) const;

      INT32 ComputeNumColumns (
         ) const;

      INT32 ComputeNumRows (
         ) const;

      void ComputeRect (
         LRECT2D& rect              
         ) const;

      MISTRING GetLogString (
         bool showzoom = true
         ) const;

      double GetMaxX (
         ) const { return (m_MinX + m_SizeX); }

      double GetMaxY (
         ) const { return (m_MinY + m_SizeY); }

      double GetMinX (
         ) const { return (m_MinX); }

      double GetMinY (
         ) const { return (m_MinY); }

      POSITION GetPosition (
         ) const { return (m_Position); }

      void GetRect (
         DRECT2D& rect              
         ) const;

      double GetSizeX (
         ) const { return (m_SizeX); }

      double GetSizeY (
         ) const { return (m_SizeY); }

      double GetZoom (
         ) const { return (m_Zoom); }

      bool IsEqual (
         const SECTION& rhs
         ) const;

      void SetMin (
         double MinX,
         double MinY
         ) { m_MinX = MinX; m_MinY = MinY; }

   private:
      #ifndef  GENERATING_DOXYGEN_OUTPUT
      double m_MinX;
      double m_MinY;
      double m_SizeX;
      double m_SizeY;
      double m_Zoom;
      POSITION m_Position;
      friend class SECTION_ITERATOR;
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(SECTION::POSITION);
#endif

inline bool operator== (
   const SECTION& lhs,
   const SECTION& rhs
   ) { return (lhs.IsEqual(rhs)); }

inline bool operator!= (
   const SECTION& lhs,
   const SECTION& rhs
   ) { return (!lhs.IsEqual(rhs)); }


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

class SECTION_ITERATOR {
   public:

      SECTION_ITERATOR ();

      ~SECTION_ITERATOR ();

      const SECTION& operator* (
         ) const { return (m_CurSection); }

      const SECTION* operator-> (
         ) const { return (&m_CurSection); }

      SECTION_ITERATOR& operator++ (
         );

      ERRVALUE Begin (
         const SECTION& TotalSection,        
         double StripSizeY                   
         );

      ERRVALUE Begin (
         const SECTION& TotalSection,        
         const SPANS& SpansX,                
         const SPANS& SpansY,                
         double StripSizeY = 0,              
         double FirstStripSizeY = 0          
         );

      ERRVALUE Begin (
         const SECTION& TotalSection,        
         double StripSizeY,                  
         double InteriorTileSizeX,           
         double InteriorTileSizeY,           
         double FirstTileSizeX = 0,          
         double FirstTileSizeY = 0,          
         double LastTileSizeX = 0,           
         double LastTileSizeY = 0,           
         double FirstStripSizeY = 0          
         );

      ERRVALUE Begin (
         const SECTION& TotalSection,        
         const BASE& Image,                  
         double StripSizeY = 0               
         );

      ERRVALUE Begin (
         const SECTION& TotalSection,        
         const BASE& TargetImage,            
         const BASE& SourceImage,            
         double StripSizeY = 0               
         );

      void Begin (
         );

      INT32 ComputeMaxSubSectionColumns (
         ) const;

      INT32 ComputeMaxSubSectionRows (
         ) const;

      double ComputeMaxSubSectionSizeX (
         ) const;

      double ComputeMaxSubSectionSizeY (
         ) const;

      INT32 ComputeNumIterations (
         ) const;

      double GetFirstStripSizeY (
         ) const { return (m_FirstStripSizeY); }

      double GetFirstTileSizeX (
         ) const { return (m_SpansX.GetSpanSizeFirst()); }

      double GetFirstTileSizeY (
         ) const { return (m_SpansY.GetSpanSizeFirst()); }

      double GetInteriorTileSizeX (
         ) const { return (m_SpansX.GetSpanSizeInterior()); }

      double GetInteriorTileSizeY (
         ) const { return (m_SpansY.GetSpanSizeInterior()); }

      double GetLastTileSizeX (
         ) const { return (m_SpansX.GetSpanSizeLast()); }

      double GetLastTileSizeY (
         ) const { return (m_SpansY.GetSpanSizeLast()); }

      double GetMinX () const
         { return (m_MinX); }

      double GetMinY () const
         { return (m_MinY); }

      UINT32 GetNumColumnsOfTiles (
         ) const { return (m_SpansX.GetNumSpans()); }

      UINT32 GetNumRowsOfTiles (
         ) const { return (m_SpansY.GetNumSpans()); }

      const SPANS& GetSpansX (
         ) const { return (m_SpansX); }

      const SPANS& GetSpansY (
         ) const { return (m_SpansY); }

      double GetStripSizeY (
         ) const { return (m_StripSizeY); }

      const SECTION& GetTotalSection (
         ) const { return (m_TotSection); }

      bool IsEnd (
         ) const { return (m_CurTileRow >= m_SpansY.GetNumSpans()); }

      bool IsIrregular (
         ) const { return (m_IsIrregular); }

      bool IsTileAligned (
         const DIMENSIONS& dimensions        
         ) const;

      void SetIrregular (
         const SECTION& TotalSection,        
         UINT32 MaxColumns,                  
         UINT32 MaxRows                      
         );

   private:
      #ifndef  GENERATING_DOXYGEN_OUTPUT
      SECTION m_TotSection;
      SECTION m_CurSection;
      SPANS m_SpansX;
      SPANS m_SpansY;
      double m_MinX;
      double m_MinY;
      double m_StripSizeY;
      double m_FirstStripSizeY;
      double m_CurTileSizeY;
      UINT32 m_CurTileRow;
      UINT32 m_CurTileColumn;
      UINT32 m_CurTileNumStrips;
      UINT32 m_CurStripRow;
      bool m_IsIrregular;

      void ComputeCurSection ();
      void ComputeCurTile ();
      void Setup (
         const SECTION& TotalSection,
         double StripSizeY,
         double InteriorTileSizeX,
         double InteriorTileSizeY,
         double FirstTileSizeX,
         double FirstTileSizeY
         );
      bool TestEfficiency (
         const BASE& TargetImage,
         const BASE& SourceImage,
         float& BestEfficiency,
         SECTION_ITERATOR& BestIterator
         ) const;

      #endif   // GENERATING_DOXYGEN_OUTPUT

   };

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

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

#endif    // INC_SPATMOD_IMAGESECTION_H

---