-/*\r
- * File: ImaIter.h\r
- * Purpose: Declaration of the Platform Independent Image Base Class\r
- * Author: Alejandro Aguilar Sierra\r
- * Created: 1995\r
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>\r
- *\r
- * 07/08/2001 Davide Pizzolato - www.xdp.it\r
- * - removed slow loops\r
- * - added safe checks\r
- *\r
- * Permission is given by the author to freely redistribute and include\r
- * this code in any program as long as this credit is given where due.\r
- *\r
- * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY\r
- * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES\r
- * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE\r
- * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED\r
- * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT\r
- * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY\r
- * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL\r
- * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER\r
- * THIS DISCLAIMER.\r
- *\r
- * Use at your own risk!\r
- * ==========================================================\r
- */\r
-\r
-#if !defined(__ImaIter_h)\r
-#define __ImaIter_h\r
-\r
-#include "ximage.h"\r
-#include "ximadef.h"\r
-\r
-class CImageIterator\r
-{\r
-friend class CxImage;\r
-protected:\r
- int Itx, Ity; // Counters\r
- int Stepx, Stepy;\r
- BYTE* IterImage; // Image pointer\r
- CxImage *ima;\r
-public:\r
- // Constructors\r
- CImageIterator ( void );\r
- CImageIterator ( CxImage *image );\r
- operator CxImage* ();\r
-\r
- // Iterators\r
- BOOL ItOK ();\r
- void Reset ();\r
- void Upset ();\r
- void SetRow(BYTE *buf, int n);\r
- void GetRow(BYTE *buf, int n);\r
- BYTE GetByte( ) { return IterImage[Itx]; }\r
- void SetByte(BYTE b) { IterImage[Itx] = b; }\r
- BYTE* GetRow(void);\r
- BYTE* GetRow(int n);\r
- BOOL NextRow();\r
- BOOL PrevRow();\r
- BOOL NextByte();\r
- BOOL PrevByte();\r
-\r
- void SetSteps(int x, int y=0) { Stepx = x; Stepy = y; }\r
- void GetSteps(int *x, int *y) { *x = Stepx; *y = Stepy; }\r
- BOOL NextStep();\r
- BOOL PrevStep();\r
-\r
- void SetY(int y); /* AD - for interlace */\r
- int GetY() {return Ity;}\r
- BOOL GetCol(BYTE* pCol, DWORD x);\r
- BOOL SetCol(BYTE* pCol, DWORD x);\r
-};\r
-\r
-/////////////////////////////////////////////////////////////////////\r
-inline\r
-CImageIterator::CImageIterator(void)\r
-{\r
- ima = 0;\r
- IterImage = 0;\r
- Itx = Ity = 0;\r
- Stepx = Stepy = 0;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline\r
-CImageIterator::CImageIterator(CxImage *imageImpl): ima(imageImpl)\r
-{\r
- if (ima) IterImage = ima->GetBits();\r
- Itx = Ity = 0;\r
- Stepx = Stepy = 0;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline\r
-CImageIterator::operator CxImage* ()\r
-{\r
- return ima;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::ItOK ()\r
-{\r
- if (ima) return ima->IsInside(Itx, Ity);\r
- else return FALSE;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline void CImageIterator::Reset()\r
-{\r
- if (ima) IterImage = ima->GetBits();\r
- else IterImage=0;\r
- Itx = Ity = 0;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline void CImageIterator::Upset()\r
-{\r
- Itx = 0;\r
- Ity = ima->GetHeight()-1;\r
- IterImage = ima->GetBits() + ima->GetEffWidth()*(ima->GetHeight()-1);\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::NextRow()\r
-{\r
- if (++Ity >= (int)ima->GetHeight()) return 0;\r
- IterImage += ima->GetEffWidth();\r
- return 1;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::PrevRow()\r
-{\r
- if (--Ity < 0) return 0;\r
- IterImage -= ima->GetEffWidth();\r
- return 1;\r
-}\r
-/* AD - for interlace */\r
-inline void CImageIterator::SetY(int y)\r
-{\r
- if ((y < 0) || (y > (int)ima->GetHeight())) return;\r
- Ity = y;\r
- IterImage = ima->GetBits() + ima->GetEffWidth()*y;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline void CImageIterator::SetRow(BYTE *buf, int n)\r
-{\r
- if (n<0) n = (int)ima->GetEffWidth();\r
- else n = min(n,(int)ima->GetEffWidth());\r
-\r
- if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline void CImageIterator::GetRow(BYTE *buf, int n)\r
-{\r
- if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))\r
- memcpy(buf,IterImage,min(n,(int)ima->GetEffWidth()));\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BYTE* CImageIterator::GetRow()\r
-{\r
- return IterImage;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BYTE* CImageIterator::GetRow(int n)\r
-{\r
- SetY(n);\r
- return IterImage;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::NextByte()\r
-{\r
- if (++Itx < (int)ima->GetEffWidth()) return 1;\r
- else\r
- if (++Ity < (int)ima->GetHeight()){\r
- IterImage += ima->GetEffWidth();\r
- Itx = 0;\r
- return 1;\r
- } else\r
- return 0;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::PrevByte()\r
-{\r
- if (--Itx >= 0) return 1;\r
- else\r
- if (--Ity >= 0){\r
- IterImage -= ima->GetEffWidth();\r
- Itx = 0;\r
- return 1;\r
- } else\r
- return 0;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::NextStep()\r
-{\r
- Itx += Stepx;\r
- if (Itx < (int)ima->GetEffWidth()) return 1;\r
- else {\r
- Ity += Stepy;\r
- if (Ity < (int)ima->GetHeight()){\r
- IterImage += ima->GetEffWidth();\r
- Itx = 0;\r
- return 1;\r
- } else\r
- return 0;\r
- }\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::PrevStep()\r
-{\r
- Itx -= Stepx;\r
- if (Itx >= 0) return 1;\r
- else { \r
- Ity -= Stepy;\r
- if (Ity >= 0 && Ity < (int)ima->GetHeight()) {\r
- IterImage -= ima->GetEffWidth();\r
- Itx = 0;\r
- return 1;\r
- } else\r
- return 0;\r
- }\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::GetCol(BYTE* pCol, DWORD x)\r
-{\r
- if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))\r
- return 0;\r
- DWORD h = ima->GetHeight();\r
- //DWORD line = ima->GetEffWidth();\r
- BYTE bytes = (BYTE)(ima->GetBpp()>>3);\r
- BYTE* pSrc;\r
- for (DWORD y=0;y<h;y++){\r
- pSrc = ima->GetBits(y) + x*bytes;\r
- for (BYTE w=0;w<bytes;w++){\r
- *pCol++=*pSrc++;\r
- }\r
- }\r
- return 1;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-inline BOOL CImageIterator::SetCol(BYTE* pCol, DWORD x)\r
-{\r
- if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))\r
- return 0;\r
- DWORD h = ima->GetHeight();\r
- //DWORD line = ima->GetEffWidth();\r
- BYTE bytes = (BYTE)(ima->GetBpp()>>3);\r
- BYTE* pSrc;\r
- for (DWORD y=0;y<h;y++){\r
- pSrc = ima->GetBits(y) + x*bytes;\r
- for (BYTE w=0;w<bytes;w++){\r
- *pSrc++=*pCol++;\r
- }\r
- }\r
- return 1;\r
-}\r
-/////////////////////////////////////////////////////////////////////\r
-#endif\r
+/*
+ * File: ImaIter.h
+ * Purpose: Declaration of the Platform Independent Image Base Class
+ * Author: Alejandro Aguilar Sierra
+ * Created: 1995
+ * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
+ *
+ * 07/08/2001 Davide Pizzolato - www.xdp.it
+ * - removed slow loops
+ * - added safe checks
+ *
+ * Permission is given by the author to freely redistribute and include
+ * this code in any program as long as this credit is given where due.
+ *
+ * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+ * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+ * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+ * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+ * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+ * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+ * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+ * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER.
+ *
+ * Use at your own risk!
+ * ==========================================================
+ */
+
+#if !defined(__ImaIter_h)
+#define __ImaIter_h
+
+#include "ximage.h"
+#include "ximadef.h"
+
+class CImageIterator
+{
+friend class CxImage;
+protected:
+ int Itx, Ity; // Counters
+ int Stepx, Stepy;
+ BYTE* IterImage; // Image pointer
+ CxImage *ima;
+public:
+ // Constructors
+ CImageIterator ( void );
+ CImageIterator ( CxImage *image );
+ operator CxImage* ();
+
+ // Iterators
+ BOOL ItOK ();
+ void Reset ();
+ void Upset ();
+ void SetRow(BYTE *buf, int n);
+ void GetRow(BYTE *buf, int n);
+ BYTE GetByte( ) { return IterImage[Itx]; }
+ void SetByte(BYTE b) { IterImage[Itx] = b; }
+ BYTE* GetRow(void);
+ BYTE* GetRow(int n);
+ BOOL NextRow();
+ BOOL PrevRow();
+ BOOL NextByte();
+ BOOL PrevByte();
+
+ void SetSteps(int x, int y=0) { Stepx = x; Stepy = y; }
+ void GetSteps(int *x, int *y) { *x = Stepx; *y = Stepy; }
+ BOOL NextStep();
+ BOOL PrevStep();
+
+ void SetY(int y); /* AD - for interlace */
+ int GetY() {return Ity;}
+ BOOL GetCol(BYTE* pCol, DWORD x);
+ BOOL SetCol(BYTE* pCol, DWORD x);
+};
+
+/////////////////////////////////////////////////////////////////////
+inline
+CImageIterator::CImageIterator(void)
+{
+ ima = 0;
+ IterImage = 0;
+ Itx = Ity = 0;
+ Stepx = Stepy = 0;
+}
+/////////////////////////////////////////////////////////////////////
+inline
+CImageIterator::CImageIterator(CxImage *imageImpl): ima(imageImpl)
+{
+ if (ima) IterImage = ima->GetBits();
+ Itx = Ity = 0;
+ Stepx = Stepy = 0;
+}
+/////////////////////////////////////////////////////////////////////
+inline
+CImageIterator::operator CxImage* ()
+{
+ return ima;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::ItOK ()
+{
+ if (ima) return ima->IsInside(Itx, Ity);
+ else return FALSE;
+}
+/////////////////////////////////////////////////////////////////////
+inline void CImageIterator::Reset()
+{
+ if (ima) IterImage = ima->GetBits();
+ else IterImage=0;
+ Itx = Ity = 0;
+}
+/////////////////////////////////////////////////////////////////////
+inline void CImageIterator::Upset()
+{
+ Itx = 0;
+ Ity = ima->GetHeight()-1;
+ IterImage = ima->GetBits() + ima->GetEffWidth()*(ima->GetHeight()-1);
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::NextRow()
+{
+ if (++Ity >= (int)ima->GetHeight()) return 0;
+ IterImage += ima->GetEffWidth();
+ return 1;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::PrevRow()
+{
+ if (--Ity < 0) return 0;
+ IterImage -= ima->GetEffWidth();
+ return 1;
+}
+/* AD - for interlace */
+inline void CImageIterator::SetY(int y)
+{
+ if ((y < 0) || (y > (int)ima->GetHeight())) return;
+ Ity = y;
+ IterImage = ima->GetBits() + ima->GetEffWidth()*y;
+}
+/////////////////////////////////////////////////////////////////////
+inline void CImageIterator::SetRow(BYTE *buf, int n)
+{
+ if (n<0) n = (int)ima->GetEffWidth();
+ else n = min(n,(int)ima->GetEffWidth());
+
+ if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);
+}
+/////////////////////////////////////////////////////////////////////
+inline void CImageIterator::GetRow(BYTE *buf, int n)
+{
+ if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))
+ memcpy(buf,IterImage,min(n,(int)ima->GetEffWidth()));
+}
+/////////////////////////////////////////////////////////////////////
+inline BYTE* CImageIterator::GetRow()
+{
+ return IterImage;
+}
+/////////////////////////////////////////////////////////////////////
+inline BYTE* CImageIterator::GetRow(int n)
+{
+ SetY(n);
+ return IterImage;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::NextByte()
+{
+ if (++Itx < (int)ima->GetEffWidth()) return 1;
+ else
+ if (++Ity < (int)ima->GetHeight()){
+ IterImage += ima->GetEffWidth();
+ Itx = 0;
+ return 1;
+ } else
+ return 0;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::PrevByte()
+{
+ if (--Itx >= 0) return 1;
+ else
+ if (--Ity >= 0){
+ IterImage -= ima->GetEffWidth();
+ Itx = 0;
+ return 1;
+ } else
+ return 0;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::NextStep()
+{
+ Itx += Stepx;
+ if (Itx < (int)ima->GetEffWidth()) return 1;
+ else {
+ Ity += Stepy;
+ if (Ity < (int)ima->GetHeight()){
+ IterImage += ima->GetEffWidth();
+ Itx = 0;
+ return 1;
+ } else
+ return 0;
+ }
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::PrevStep()
+{
+ Itx -= Stepx;
+ if (Itx >= 0) return 1;
+ else {
+ Ity -= Stepy;
+ if (Ity >= 0 && Ity < (int)ima->GetHeight()) {
+ IterImage -= ima->GetEffWidth();
+ Itx = 0;
+ return 1;
+ } else
+ return 0;
+ }
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::GetCol(BYTE* pCol, DWORD x)
+{
+ if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))
+ return 0;
+ DWORD h = ima->GetHeight();
+ //DWORD line = ima->GetEffWidth();
+ BYTE bytes = (BYTE)(ima->GetBpp()>>3);
+ BYTE* pSrc;
+ for (DWORD y=0;y<h;y++){
+ pSrc = ima->GetBits(y) + x*bytes;
+ for (BYTE w=0;w<bytes;w++){
+ *pCol++=*pSrc++;
+ }
+ }
+ return 1;
+}
+/////////////////////////////////////////////////////////////////////
+inline BOOL CImageIterator::SetCol(BYTE* pCol, DWORD x)
+{
+ if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))
+ return 0;
+ DWORD h = ima->GetHeight();
+ //DWORD line = ima->GetEffWidth();
+ BYTE bytes = (BYTE)(ima->GetBpp()>>3);
+ BYTE* pSrc;
+ for (DWORD y=0;y<h;y++){
+ pSrc = ima->GetBits(y) + x*bytes;
+ for (BYTE w=0;w<bytes;w++){
+ *pSrc++=*pCol++;
+ }
+ }
+ return 1;
+}
+/////////////////////////////////////////////////////////////////////
+#endif
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff