CvvImage在高级别的Opencv2.4.11下的配置以及错误解决办法。

由于高版本的OpenCV2.4.11里取消了CImage(CvvImage)，在此我们可以用老的版本替代。

在需要的地方引入 #include "CvvImage.h" 就可以用了。

需要将CvvIamge.h和CvvImage.cpp重新加入进来

 #pragma once
 // CvvImage.h
 #ifndef CVVIMAGE_CLASS_DEF
 #define CVVIMAGE_CLASS_DEF

 #include "opencv.hpp"

 class  CvvImage{
 public:
     CvvImage();
     virtual ~CvvImage();

     virtual bool  Create( int width, int height, int bits_per_pixel, int image_origin =  );

     virtual bool  Load( const char* filename, int desired_color =  );

     virtual bool  LoadRect( const char* filename,
         int desired_color, CvRect r );

 #if defined WIN32 || defined _WIN32
     virtual bool  LoadRect( const char* filename,
         int desired_color, RECT r )
     {
         return LoadRect( filename, desired_color,
             cvRect( r.left, r.top, r.right - r.left, r.bottom - r.top ));
     }
 #endif

     virtual bool  Save( const char* filename );

     virtual void  CopyOf( CvvImage& image, int desired_color = - );
     virtual void  CopyOf( IplImage* img, int desired_color = - );

     IplImage* GetImage() { return m_img; };
     virtual void  Destroy(void);

     int Width() { return !m_img ?  : !m_img->roi ? m_img->width : m_img->roi->width; };
     int Height() { return !m_img ?  : !m_img->roi ? m_img->height : m_img->roi->height;};
     int Bpp() { return m_img ? (m_img->depth & )*m_img->nChannels : ; };

     virtual void  Fill( int color );

     virtual void  Show( const char* window );

 #if defined WIN32 || defined _WIN32
     virtual void  Show( HDC dc, int x, int y, int width, int height, int from_x = , int from_y =  );
     virtual void  DrawToHDC( HDC hDCDst, RECT* pDstRect );
 #endif

 protected:

     IplImage*  m_img;
 };

 //typedef CvvImage CImage;
 namespace cv
 {
     typedef CvvImage CImage;
 }

 #endif

 //CvvImage.cpp

 #include "StdAfx.h"
 #include "CvvImage.h"

 // Construction/Destruction

 CV_INLINE RECT NormalizeRect( RECT r );
 CV_INLINE RECT NormalizeRect( RECT r ) {
     int t;

     if( r.left > r.right ){
         t = r.left;
         r.left = r.right;
         r.right = t;
     }

     if( r.top > r.bottom ) {
         t = r.top;
         r.top = r.bottom;
         r.bottom = t;
     }

     return r;
 }

 CV_INLINE CvRect RectToCvRect( RECT sr );
 CV_INLINE CvRect RectToCvRect( RECT sr ) {
     sr = NormalizeRect( sr );
     return cvRect( sr.left, sr.top, sr.right - sr.left, sr.bottom - sr.top );
 }

 CV_INLINE RECT CvRectToRect( CvRect sr );
 CV_INLINE RECT CvRectToRect( CvRect sr ) {
     RECT dr;
     dr.left = sr.x;
     dr.top = sr.y;
     dr.right = sr.x + sr.width;
     dr.bottom = sr.y + sr.height;

     return dr;
 }

 CV_INLINE IplROI RectToROI( RECT r );
 CV_INLINE IplROI RectToROI( RECT r ) {
     IplROI roi;
     r = NormalizeRect( r );
     roi.xOffset = r.left;
     roi.yOffset = r.top;
     roi.width = r.right - r.left;
     roi.height = r.bottom - r.top;
     roi.coi = ;

     return roi;
 }

 void  FillBitmapInfo( BITMAPINFO* bmi, int width, int height, int bpp, int origin ) {
     assert( bmi && width >=  && height >=  && (bpp ==  || bpp ==  || bpp == ));

     BITMAPINFOHEADER* bmih = &(bmi->bmiHeader);

     memset( bmih, , sizeof(*bmih));
     bmih->biSize = sizeof(BITMAPINFOHEADER);
     bmih->biWidth = width;
     bmih->biHeight = origin ? abs(height) : -abs(height);
     bmih->biPlanes = ;
     bmih->biBitCount = (unsigned short)bpp;
     bmih->biCompression = BI_RGB;

     if( bpp ==  ) {
         RGBQUAD* palette = bmi->bmiColors;
         int i;
         for( i = ; i < ; i++ ) {
             palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;
             palette[i].rgbReserved = ;
         }
     }
 }

 CvvImage::CvvImage() { m_img = ; }

 void CvvImage::Destroy() { cvReleaseImage( &m_img ); }

 CvvImage::~CvvImage() {  Destroy(); }

 bool  CvvImage::Create( int w, int h, int bpp, int origin ) {
     const unsigned max_img_size = ;

     if( (bpp !=  && bpp !=  && bpp != ) || (unsigned)w >=  max_img_size || (unsigned)h >= max_img_size ||
         (origin != IPL_ORIGIN_TL && origin != IPL_ORIGIN_BL)) {
             assert(); // most probably, it is a programming error
             return false;
     }

     if( !m_img || Bpp() != bpp || m_img->width != w || m_img->height != h ) {
         if( m_img && m_img->nSize == sizeof(IplImage))
             Destroy();    

         m_img = cvCreateImage( cvSize( w, h ), IPL_DEPTH_8U, bpp/ );
     }

     if( m_img )
         m_img->origin = origin ==  ? IPL_ORIGIN_TL : IPL_ORIGIN_BL;

     return m_img != ;
 }

 void  CvvImage::CopyOf( CvvImage& image, int desired_color ) {
     IplImage* img = image.GetImage();
     if( img )  {
         CopyOf( img, desired_color );
     }
 }

 #define HG_IS_IMAGE(img)                                                  \
     ((img) !=  && ((const IplImage*)(img))->nSize == sizeof(IplImage) && \
     ((IplImage*)img)->imageData != )

 void  CvvImage::CopyOf( IplImage* img, int desired_color ){
     if( HG_IS_IMAGE(img) )   {
         int color = desired_color;
         CvSize size = cvGetSize( img );

         if( color <  )
             color = img->nChannels > ;

         if( Create( size.width, size.height, (!color ?  : img->nChannels >  ? img->nChannels : )*,  img->origin )) {
             cvConvertImage( img, m_img,  );
         }
     }
 }

 bool  CvvImage::Load( const char* filename, int desired_color ){
     IplImage* img = cvLoadImage( filename, desired_color );
     if( !img )  return false;

     CopyOf( img, desired_color );
     cvReleaseImage( &img );

     return true;
 }

 bool  CvvImage::LoadRect( const char* filename, int desired_color, CvRect r ){
     if( r.width <  || r.height <  ) return false;

     IplImage* img = cvLoadImage( filename, desired_color );
     if( !img )      return false;

     if( r.width ==  || r.height ==  )   {
         r.width = img->width;
         r.height = img->height;
         r.x = r.y = ;
     }

     if( r.x > img->width || r.y > img->height ||  r.x + r.width <  || r.y + r.height <  )   {
         cvReleaseImage( &img );
         return false;
     }

     if( r.x <  )   {
         r.width += r.x;
         r.x = ;
     }
     if( r.y <  )   {
         r.height += r.y;
         r.y = ;
     }

     if( r.x + r.width > img->width )     r.width = img->width - r.x;

     if( r.y + r.height > img->height )      r.height = img->height - r.y;

     cvSetImageROI( img, r );
     CopyOf( img, desired_color );

     cvReleaseImage( &img );
     return true;
 }

 bool  CvvImage::Save( const char* filename ){
     if( !m_img )      return false;
     cvSaveImage( filename, m_img );
     return true;
 }

 void  CvvImage::Show( const char* window ){
     if( m_img )      cvShowImage( window, m_img );
 }

 void  CvvImage::Show( HDC dc, int x, int y, int w, int h, int from_x, int from_y ){
     if( m_img && m_img->depth == IPL_DEPTH_8U )   {
         uchar buffer[sizeof(BITMAPINFOHEADER) + ];
         BITMAPINFO* bmi = (BITMAPINFO*)buffer;
         int bmp_w = m_img->width, bmp_h = m_img->height;

         FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );

         from_x = MIN( MAX( from_x,  ), bmp_w -  );
         from_y = MIN( MAX( from_y,  ), bmp_h -  );

         int sw = MAX( MIN( bmp_w - from_x, w ),  );
         int sh = MAX( MIN( bmp_h - from_y, h ),  );

         SetDIBitsToDevice(
             dc, x, y, sw, sh, from_x, from_y, from_y, sh,
             m_img->imageData + from_y*m_img->widthStep,
             bmi, DIB_RGB_COLORS );
     }
 }

 void  CvvImage::DrawToHDC( HDC hDCDst, RECT* pDstRect ){
     if( pDstRect && m_img && m_img->depth == IPL_DEPTH_8U && m_img->imageData )   {
         uchar buffer[sizeof(BITMAPINFOHEADER) + ];
         BITMAPINFO* bmi = (BITMAPINFO*)buffer;
         int bmp_w = m_img->width, bmp_h = m_img->height;

         CvRect roi = cvGetImageROI( m_img );
         CvRect dst = RectToCvRect( *pDstRect );

         if( roi.width == dst.width && roi.height == dst.height )     {
             Show( hDCDst, dst.x, dst.y, dst.width, dst.height, roi.x, roi.y );
             return;
         }

         if( roi.width > dst.width )     {
             SetStretchBltMode( hDCDst,   HALFTONE );  // handle to device context

         }
         else     {
             SetStretchBltMode(hDCDst,  COLORONCOLOR );
         }

         FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );

         ::StretchDIBits(
             hDCDst,
             dst.x, dst.y, dst.width, dst.height,
             roi.x, roi.y, roi.width, roi.height,
             m_img->imageData, bmi, DIB_RGB_COLORS, SRCCOPY );
     }
 }

 void  CvvImage::Fill( int color ){
     cvSet( m_img, cvScalar(color&,(color>>)&,(color>>)&,(color>>)&) );
 }