解决Opencv高低版本不兼容问题

目前OpenCV版本已更新到2.4...由此出现了一系列问题，解决如下：

1、cxcore.h等头文件找不到：

法一、将opencv1.0中的各种.h或者.lib文件拷到opencv2.3.1对应include/library的路径的文件夹下。

e.g.   Cannot open include file: 'cxtypes.h': No such file or directory

像这种情况，在opencv1.0中又搜索不到的，果断把#include"cxtypes.h"删掉，其他问题慢慢解决。

2、CvFilter未定义：

opencv高级版本不在含有CvFilter，那么就把类型改成int吧……

3、CvvImage类找不到定义……

高级版本中，以前版本的CvvImage类不见了...为了能够继续使用这个类，下面把这个类的源代码贴出来，使用的时候将该代码加入到工程中便可以使用了。为了方便切换OpenCV的版本，这里用到了一些条件编译宏，来保证代码的灵活性。

不过OpenCV 2.2.0取消CvvImage这个类，一定是有它的原因的，具体可以在做实验的时候体会这些原因。

========================================================================

CvvImage头文件

1. #ifndef CVVIMAGE_CLASS_DEF
2. #define CVVIMAGE_CLASS_DEF
3. #ifndef RC_OPENCV_2_1_0
4. #include <opencv/cv.h>
5. #include <opencv/highgui.h>
6. /* CvvImage class definition */
7. class  CvvImage
8. {
9. public:
10. CvvImage();
11. virtual ~CvvImage();
12. /* Create image (BGR or grayscale) */
13. virtual bool  Create( int width, int height, int bits_per_pixel, int image_origin = 0 );
14. /* Load image from specified file */
15. virtual bool  Load( const char* filename, int desired_color = 1 );
16. /* Load rectangle from the file */
17. virtual bool  LoadRect( const char* filename,
18. int desired_color, CvRect r );
19. #if defined WIN32 || defined _WIN32
20. virtual bool  LoadRect( const char* filename,
21. int desired_color, RECT r )
22. {
23. return LoadRect( filename, desired_color,
24. cvRect( r.left, r.top, r.right - r.left, r.bottom - r.top ));
25. }
26. #endif
27. /* Save entire image to specified file. */
28. virtual bool  Save( const char* filename );
29. /* Get copy of input image ROI */
30. virtual void  CopyOf( CvvImage& image, int desired_color = -1 );
31. virtual void  CopyOf( IplImage* img, int desired_color = -1 );
32. IplImage* GetImage() { return m_img; };
33. virtual void  Destroy(void);
34. /* width and height of ROI */
35. int Width() { return !m_img ? 0 : !m_img->roi ? m_img->width : m_img->roi->width; };
36. int Height() { return !m_img ? 0 : !m_img->roi ? m_img->height : m_img->roi->height;};
37. int Bpp() { return m_img ? (m_img->depth & 255)*m_img->nChannels : 0; };
38. virtual void  Fill( int color );
39. /* draw to highgui window */
40. virtual void  Show( const char* window );
41. #if defined WIN32 || defined _WIN32
42. /* draw part of image to the specified DC */
43. virtual void  Show( HDC dc, int x, int y, int width, int height,
44. int from_x = 0, int from_y = 0 );
45. /* draw the current image ROI to the specified rectangle of the destination DC */
46. virtual void  DrawToHDC( HDC hDCDst, RECT* pDstRect );
47. #endif
48. protected:
49. IplImage*  m_img;
50. };
51. typedef CvvImage CImage;
52. #endif
53. #endif

CvvImage源文件

1. #include "stdafx.h"
2. #ifndef RC_OPENCV_2_1_0
3. #include "CvvImage.h"
4. //////////////////////////////////////////////////////////////////////
5. // Construction/Destruction
6. //////////////////////////////////////////////////////////////////////
7. CV_INLINE RECT NormalizeRect( RECT r );
8. CV_INLINE RECT NormalizeRect( RECT r )
9. {
10. int t;
11. if( r.left > r.right )
12. {
13. t = r.left;
14. r.left = r.right;
15. r.right = t;
16. }
17. if( r.top > r.bottom )
18. {
19. t = r.top;
20. r.top = r.bottom;
21. r.bottom = t;
22. }
23. return r;
24. }
25. CV_INLINE CvRect RectToCvRect( RECT sr );
26. CV_INLINE CvRect RectToCvRect( RECT sr )
27. {
28. sr = NormalizeRect( sr );
29. return cvRect( sr.left, sr.top, sr.right - sr.left, sr.bottom - sr.top );
30. }
31. CV_INLINE RECT CvRectToRect( CvRect sr );
32. CV_INLINE RECT CvRectToRect( CvRect sr )
33. {
34. RECT dr;
35. dr.left = sr.x;
36. dr.top = sr.y;
37. dr.right = sr.x + sr.width;
38. dr.bottom = sr.y + sr.height;
39. return dr;
40. }
41. CV_INLINE IplROI RectToROI( RECT r );
42. CV_INLINE IplROI RectToROI( RECT r )
43. {
44. IplROI roi;
45. r = NormalizeRect( r );
46. roi.xOffset = r.left;
47. roi.yOffset = r.top;
48. roi.width = r.right - r.left;
49. roi.height = r.bottom - r.top;
50. roi.coi = 0;
51. return roi;
52. }
53. void  FillBitmapInfo( BITMAPINFO* bmi, int width, int height, int bpp, int origin )
54. {
55. assert( bmi && width >= 0 && height >= 0 && (bpp == 8 || bpp == 24 || bpp == 32));
56. BITMAPINFOHEADER* bmih = &(bmi->bmiHeader);
57. memset( bmih, 0, sizeof(*bmih));
58. bmih->biSize = sizeof(BITMAPINFOHEADER);
59. bmih->biWidth = width;
60. bmih->biHeight = origin ? abs(height) : -abs(height);
61. bmih->biPlanes = 1;
62. bmih->biBitCount = (unsigned short)bpp;
63. bmih->biCompression = BI_RGB;
64. if( bpp == 8 )
65. {
66. RGBQUAD* palette = bmi->bmiColors;
67. int i;
68. for( i = 0; i < 256; i++ )
69. {
70. palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;
71. palette[i].rgbReserved = 0;
72. }
73. }
74. }
75. CvvImage::CvvImage()
76. {
77. m_img = 0;
78. }
79. void CvvImage::Destroy()
80. {
81. cvReleaseImage( &m_img );
82. }
83. CvvImage::~CvvImage()
84. {
85. Destroy();
86. }
87. bool  CvvImage::Create( int w, int h, int bpp, int origin )
88. {
89. const unsigned max_img_size = 10000;
90. if( (bpp != 8 && bpp != 24 && bpp != 32) ||
91. (unsigned)w >=  max_img_size || (unsigned)h >= max_img_size ||
92. (origin != IPL_ORIGIN_TL && origin != IPL_ORIGIN_BL))
93. {
94. assert(0); // most probably, it is a programming error
95. return false;
96. }
97. if( !m_img || Bpp() != bpp || m_img->width != w || m_img->height != h )
98. {
99. if( m_img && m_img->nSize == sizeof(IplImage))
100. Destroy();
101. /* prepare IPL header */
102. m_img = cvCreateImage( cvSize( w, h ), IPL_DEPTH_8U, bpp/8 );
103. }
104. if( m_img )
105. m_img->origin = origin == 0 ? IPL_ORIGIN_TL : IPL_ORIGIN_BL;
106. return m_img != 0;
107. }
108. void  CvvImage::CopyOf( CvvImage& image, int desired_color )
109. {
110. IplImage* img = image.GetImage();
111. if( img )
112. {
113. CopyOf( img, desired_color );
114. }
115. }
116. #define HG_IS_IMAGE(img)                                                  \
117. ((img) != 0 && ((const IplImage*)(img))->nSize == sizeof(IplImage) && \
118. ((IplImage*)img)->imageData != 0)
119. void  CvvImage::CopyOf( IplImage* img, int desired_color )
120. {
121. if( HG_IS_IMAGE(img) )
122. {
123. int color = desired_color;
124. CvSize size = cvGetSize( img );
125. if( color < 0 )
126. color = img->nChannels > 1;
127. if( Create( size.width, size.height,
128. (!color ? 1 : img->nChannels > 1 ? img->nChannels : 3)*8,
129. img->origin ))
130. {
131. cvConvertImage( img, m_img, 0 );
132. }
133. }
134. }
135. bool  CvvImage::Load( const char* filename, int desired_color )
136. {
137. IplImage* img = cvLoadImage( filename, desired_color );
138. if( !img )
139. return false;
140. CopyOf( img, desired_color );
141. cvReleaseImage( &img );
142. return true;
143. }
144. bool  CvvImage::LoadRect( const char* filename,
145. int desired_color, CvRect r )
146. {
147. if( r.width < 0 || r.height < 0 ) return false;
148. IplImage* img = cvLoadImage( filename, desired_color );
149. if( !img )
150. return false;
151. if( r.width == 0 || r.height == 0 )
152. {
153. r.width = img->width;
154. r.height = img->height;
155. r.x = r.y = 0;
156. }
157. if( r.x > img->width || r.y > img->height ||
158. r.x + r.width < 0 || r.y + r.height < 0 )
159. {
160. cvReleaseImage( &img );
161. return false;
162. }
163. /* truncate r to source image */
164. if( r.x < 0 )
165. {
166. r.width += r.x;
167. r.x = 0;
168. }
169. if( r.y < 0 )
170. {
171. r.height += r.y;
172. r.y = 0;
173. }
174. if( r.x + r.width > img->width )
175. r.width = img->width - r.x;
176. if( r.y + r.height > img->height )
177. r.height = img->height - r.y;
178. cvSetImageROI( img, r );
179. CopyOf( img, desired_color );
180. cvReleaseImage( &img );
181. return true;
182. }
183. bool  CvvImage::Save( const char* filename )
184. {
185. if( !m_img )
186. return false;
187. cvSaveImage( filename, m_img );
188. return true;
189. }
190. void  CvvImage::Show( const char* window )
191. {
192. if( m_img )
193. cvShowImage( window, m_img );
194. }
195. void  CvvImage::Show( HDC dc, int x, int y, int w, int h, int from_x, int from_y )
196. {
197. if( m_img && m_img->depth == IPL_DEPTH_8U )
198. {
199. uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
200. BITMAPINFO* bmi = (BITMAPINFO*)buffer;
201. int bmp_w = m_img->width, bmp_h = m_img->height;
202. FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );
203. from_x = MIN( MAX( from_x, 0 ), bmp_w - 1 );
204. from_y = MIN( MAX( from_y, 0 ), bmp_h - 1 );
205. int sw = MAX( MIN( bmp_w - from_x, w ), 0 );
206. int sh = MAX( MIN( bmp_h - from_y, h ), 0 );
207. SetDIBitsToDevice(
208. dc, x, y, sw, sh, from_x, from_y, from_y, sh,
209. m_img->imageData + from_y*m_img->widthStep,
210. bmi, DIB_RGB_COLORS );
211. }
212. }
213. void  CvvImage::DrawToHDC( HDC hDCDst, RECT* pDstRect )
214. {
215. if( pDstRect && m_img && m_img->depth == IPL_DEPTH_8U && m_img->imageData )
216. {
217. uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
218. BITMAPINFO* bmi = (BITMAPINFO*)buffer;
219. int bmp_w = m_img->width, bmp_h = m_img->height;
220. CvRect roi = cvGetImageROI( m_img );
221. CvRect dst = RectToCvRect( *pDstRect );
222. if( roi.width == dst.width && roi.height == dst.height )
223. {
224. Show( hDCDst, dst.x, dst.y, dst.width, dst.height, roi.x, roi.y );
225. return;
226. }
227. if( roi.width > dst.width )
228. {
229. SetStretchBltMode(
230. hDCDst,           // handle to device context
231. HALFTONE );
232. }
233. else
234. {
235. SetStretchBltMode(
236. hDCDst,           // handle to device context
237. COLORONCOLOR );
238. }
239. FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );
240. ::StretchDIBits(
241. hDCDst,
242. dst.x, dst.y, dst.width, dst.height,
243. roi.x, roi.y, roi.width, roi.height,
244. m_img->imageData, bmi, DIB_RGB_COLORS, SRCCOPY );
245. }
246. }
247. void  CvvImage::Fill( int color )
248. {
249. cvSet( m_img, cvScalar(color&255,(color>>8)&255,(color>>16)&255,(color>>24)&255) );
250. }
251. #endif