ximaiter.h
上传用户:pass2008
上传日期:2021-07-05
资源大小:3299k
文件大小:7k
源码类别:

Internet/IE编程

开发平台:

Visual C++

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