utilities/CxImage/ximaiter.h

   1 /*\r
   2  * File:        ImaIter.h\r
   3  * Purpose:     Declaration of the Platform Independent Image Base Class\r
   4  * Author:      Alejandro Aguilar Sierra\r
   5  * Created:     1995\r
   6  * Copyright:   (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>\r
   7  *\r
   8  * 07/08/2001 Davide Pizzolato - www.xdp.it\r
   9  * - removed slow loops\r
  10  * - added safe checks\r
  11  *\r
  12  * Permission is given by the author to freely redistribute and include\r
  13  * this code in any program as long as this credit is given where due.\r
  14  *\r
  15  * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY\r
  16  * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES\r
  17  * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE\r
  18  * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED\r
  19  * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT\r
  20  * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY\r
  21  * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL\r
  22  * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER\r
  23  * THIS DISCLAIMER.\r
  24  *\r
  25  * Use at your own risk!\r
  26  * ==========================================================\r
  27  */\r
  28 \r
  29 #if !defined(__ImaIter_h)\r
  30 #define __ImaIter_h\r
  31 \r
  32 #include "ximage.h"\r
  33 #include "ximadef.h"\r
  34 \r
  35 class CImageIterator\r
  36 {\r
  37 friend class CxImage;\r
  38 protected:\r
  39         int Itx, Ity;           // Counters\r
  40         int Stepx, Stepy;\r
  41         BYTE* IterImage;        //  Image pointer\r
  42         CxImage *ima;\r
  43 public:\r
  44         // Constructors\r
  45         CImageIterator ( void );\r
  46         CImageIterator ( CxImage *image );\r
  47         operator CxImage* ();\r
  48 \r
  49         // Iterators\r
  50         BOOL ItOK ();\r
  51         void Reset ();\r
  52         void Upset ();\r
  53         void SetRow(BYTE *buf, int n);\r
  54         void GetRow(BYTE *buf, int n);\r
  55         BYTE GetByte( ) { return IterImage[Itx]; }\r
  56         void SetByte(BYTE b) { IterImage[Itx] = b; }\r
  57         BYTE* GetRow(void);\r
  58         BYTE* GetRow(int n);\r
  59         BOOL NextRow();\r
  60         BOOL PrevRow();\r
  61         BOOL NextByte();\r
  62         BOOL PrevByte();\r
  63 \r
  64         void SetSteps(int x, int y=0) {  Stepx = x; Stepy = y; }\r
  65         void GetSteps(int *x, int *y) {  *x = Stepx; *y = Stepy; }\r
  66         BOOL NextStep();\r
  67         BOOL PrevStep();\r
  68 \r
  69         void SetY(int y);       /* AD - for interlace */\r
  70         int  GetY() {return Ity;}\r
  71         BOOL GetCol(BYTE* pCol, DWORD x);\r
  72         BOOL SetCol(BYTE* pCol, DWORD x);\r
  73 };\r
  74 \r
  75 /////////////////////////////////////////////////////////////////////\r
  76 inline\r
  77 CImageIterator::CImageIterator(void)\r
  78 {\r
  79         ima = 0;\r
  80         IterImage = 0;\r
  81         Itx = Ity = 0;\r
  82         Stepx = Stepy = 0;\r
  83 }\r
  84 /////////////////////////////////////////////////////////////////////\r
  85 inline\r
  86 CImageIterator::CImageIterator(CxImage *imageImpl): ima(imageImpl)\r
  87 {\r
  88         if (ima) IterImage = ima->GetBits();\r
  89         Itx = Ity = 0;\r
  90         Stepx = Stepy = 0;\r
  91 }\r
  92 /////////////////////////////////////////////////////////////////////\r
  93 inline\r
  94 CImageIterator::operator CxImage* ()\r
  95 {\r
  96         return ima;\r
  97 }\r
  98 /////////////////////////////////////////////////////////////////////\r
  99 inline BOOL CImageIterator::ItOK ()\r
 100 {\r
 101         if (ima) return ima->IsInside(Itx, Ity);\r
 102         else     return FALSE;\r
 103 }\r
 104 /////////////////////////////////////////////////////////////////////\r
 105 inline void CImageIterator::Reset()\r
 106 {\r
 107         if (ima) IterImage = ima->GetBits();\r
 108         else     IterImage=0;\r
 109         Itx = Ity = 0;\r
 110 }\r
 111 /////////////////////////////////////////////////////////////////////\r
 112 inline void CImageIterator::Upset()\r
 113 {\r
 114         Itx = 0;\r
 115         Ity = ima->GetHeight()-1;\r
 116         IterImage = ima->GetBits() + ima->GetEffWidth()*(ima->GetHeight()-1);\r
 117 }\r
 118 /////////////////////////////////////////////////////////////////////\r
 119 inline BOOL CImageIterator::NextRow()\r
 120 {\r
 121         if (++Ity >= (int)ima->GetHeight()) return 0;\r
 122         IterImage += ima->GetEffWidth();\r
 123         return 1;\r
 124 }\r
 125 /////////////////////////////////////////////////////////////////////\r
 126 inline BOOL CImageIterator::PrevRow()\r
 127 {\r
 128         if (--Ity < 0) return 0;\r
 129         IterImage -= ima->GetEffWidth();\r
 130         return 1;\r
 131 }\r
 132 /* AD - for interlace */\r
 133 inline void CImageIterator::SetY(int y)\r
 134 {\r
 135         if ((y < 0) || (y > (int)ima->GetHeight())) return;\r
 136         Ity = y;\r
 137         IterImage = ima->GetBits() + ima->GetEffWidth()*y;\r
 138 }\r
 139 /////////////////////////////////////////////////////////////////////\r
 140 inline void CImageIterator::SetRow(BYTE *buf, int n)\r
 141 {\r
 142         if (n<0) n = (int)ima->GetEffWidth();\r
 143         else n = min(n,(int)ima->GetEffWidth());\r
 144 \r
 145         if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);\r
 146 }\r
 147 /////////////////////////////////////////////////////////////////////\r
 148 inline void CImageIterator::GetRow(BYTE *buf, int n)\r
 149 {\r
 150         if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))\r
 151                 memcpy(buf,IterImage,min(n,(int)ima->GetEffWidth()));\r
 152 }\r
 153 /////////////////////////////////////////////////////////////////////\r
 154 inline BYTE* CImageIterator::GetRow()\r
 155 {\r
 156         return IterImage;\r
 157 }\r
 158 /////////////////////////////////////////////////////////////////////\r
 159 inline BYTE* CImageIterator::GetRow(int n)\r
 160 {\r
 161         SetY(n);\r
 162         return IterImage;\r
 163 }\r
 164 /////////////////////////////////////////////////////////////////////\r
 165 inline BOOL CImageIterator::NextByte()\r
 166 {\r
 167         if (++Itx < (int)ima->GetEffWidth()) return 1;\r
 168         else\r
 169                 if (++Ity < (int)ima->GetHeight()){\r
 170                         IterImage += ima->GetEffWidth();\r
 171                         Itx = 0;\r
 172                         return 1;\r
 173                 } else\r
 174                         return 0;\r
 175 }\r
 176 /////////////////////////////////////////////////////////////////////\r
 177 inline BOOL CImageIterator::PrevByte()\r
 178 {\r
 179   if (--Itx >= 0) return 1;\r
 180   else\r
 181           if (--Ity >= 0){\r
 182                   IterImage -= ima->GetEffWidth();\r
 183                   Itx = 0;\r
 184                   return 1;\r
 185           } else\r
 186                   return 0;\r
 187 }\r
 188 /////////////////////////////////////////////////////////////////////\r
 189 inline BOOL CImageIterator::NextStep()\r
 190 {\r
 191         Itx += Stepx;\r
 192         if (Itx < (int)ima->GetEffWidth()) return 1;\r
 193         else {\r
 194                 Ity += Stepy;\r
 195                 if (Ity < (int)ima->GetHeight()){\r
 196                         IterImage += ima->GetEffWidth();\r
 197                         Itx = 0;\r
 198                         return 1;\r
 199                 } else\r
 200                         return 0;\r
 201         }\r
 202 }\r
 203 /////////////////////////////////////////////////////////////////////\r
 204 inline BOOL CImageIterator::PrevStep()\r
 205 {\r
 206         Itx -= Stepx;\r
 207         if (Itx >= 0) return 1;\r
 208         else {       \r
 209                 Ity -= Stepy;\r
 210                 if (Ity >= 0 && Ity < (int)ima->GetHeight()) {\r
 211                         IterImage -= ima->GetEffWidth();\r
 212                         Itx = 0;\r
 213                         return 1;\r
 214                 } else\r
 215                         return 0;\r
 216         }\r
 217 }\r
 218 /////////////////////////////////////////////////////////////////////\r
 219 inline BOOL CImageIterator::GetCol(BYTE* pCol, DWORD x)\r
 220 {\r
 221         if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))\r
 222                 return 0;\r
 223         DWORD h = ima->GetHeight();\r
 224         //DWORD line = ima->GetEffWidth();\r
 225         BYTE bytes = (BYTE)(ima->GetBpp()>>3);\r
 226         BYTE* pSrc;\r
 227         for (DWORD y=0;y<h;y++){\r
 228                 pSrc = ima->GetBits(y) + x*bytes;\r
 229                 for (BYTE w=0;w<bytes;w++){\r
 230                         *pCol++=*pSrc++;\r
 231                 }\r
 232         }\r
 233         return 1;\r
 234 }\r
 235 /////////////////////////////////////////////////////////////////////\r
 236 inline BOOL CImageIterator::SetCol(BYTE* pCol, DWORD x)\r
 237 {\r
 238         if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))\r
 239                 return 0;\r
 240         DWORD h = ima->GetHeight();\r
 241         //DWORD line = ima->GetEffWidth();\r
 242         BYTE bytes = (BYTE)(ima->GetBpp()>>3);\r
 243         BYTE* pSrc;\r
 244         for (DWORD y=0;y<h;y++){\r
 245                 pSrc = ima->GetBits(y) + x*bytes;\r
 246                 for (BYTE w=0;w<bytes;w++){\r
 247                         *pSrc++=*pCol++;\r
 248                 }\r
 249         }\r
 250         return 1;\r
 251 }\r
 252 /////////////////////////////////////////////////////////////////////\r
 253 #endif\r