]> Creatis software - clitk.git/blob - utilities/CxImage/ximaiter.h
Merge branch 'master' of git.creatis.insa-lyon.fr:clitk
[clitk.git] / 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