OpenCV2没有了CvvImage,抄下低版本的CvvImage,可用于MFC中。

//////头文件CvvImage.h

 

 

#ifndef CVVIMAGE_CLASS_DEF_H  

#define CVVIMAGE_CLASS_DEF_H   

#include <cv.h>

#include <highgui.h>

#include <GdiPlus.h>

using namespace Gdiplus;

#pragma comment(lib,"gdiplus.lib")

 

/* CvvImage class definition */  

class  CvvImage  

{  

public:  

    CvvImage();  

    virtual ~CvvImage();  

 

    /* Create image (BGR or grayscale) */  

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

 

    /* Load image from specified file */  

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

 

    /* Load rectangle from the file */  

    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  

 

    /* Save entire image to specified file. */  

    virtual bool  Save( const char* filename );  

 

    /* Get copy of input image ROI */  

    virtual void  CopyOf( CvvImage& image, int desired_color = -1 );  

    virtual void  CopyOf( IplImage* img, int desired_color = -1 );  

 

    IplImage* GetImage() { return m_img; };  

    virtual void  Destroy(void);  

 

    /* width and height of ROI */  

    int Width() { return !m_img ? 0 : !m_img->roi ? m_img->width : m_img->roi->width; };  

    int Height() { return !m_img ? 0 : !m_img->roi ? m_img->height : m_img->roi->height;};  

    int Bpp() { return m_img ? (m_img->depth & 255)*m_img->nChannels : 0; };  

 

    virtual void  Fill( int color );  

 

    /* draw to highgui window */  

    virtual void  Show( const char* window );  

 /*convert picture format*/

void IplImageToBitmap(IplImage* pIplImg, Bitmap* &pBitmap);

void BitmapToIplImage(Bitmap* pBitmap, IplImage* &pIplImg);

  BOOL IplImage2CBtmap(HDC dc,IplImage *pImage,CBitmap *bitmap);

 

#if defined WIN32 || defined _WIN32  

    /* draw part of image to the specified DC */  

    virtual void  Show( HDC dc, int x, int y, int width, int height,  

        int from_x = 0, int from_y = 0 );  

    /* draw the current image ROI to the specified rectangle of the destination DC */  

    virtual void  DrawToHDC( HDC hDCDst, RECT* pDstRect );  

#endif  

 

protected:  //modify by deng

    IplImage*  m_img;  

public:

inline void SetIplImage(IplImage* pimg)

{

  m_img=pimg;

}

inline IplImage*  GetIplImage()

{

  return m_img;

}

};  

 

//typedef CvvImage CImage;  

 

#endif 

 

 

/////////////////////////////////////

///cpp文件 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 = 0;  

 

    return roi;  

}  

 

void  FillBitmapInfo( BITMAPINFO* bmi, int width, int height, int bpp, int origin )  

{  

    assert( bmi && width >= 0 && height >= 0 && (bpp == 8 || bpp == 24 || bpp == 32));  

 

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

 

    memset( bmih, 0, sizeof(*bmih));  

    bmih->biSize = sizeof(BITMAPINFOHEADER);  

    bmih->biWidth = width;  

    bmih->biHeight = origin ? abs(height) : -abs(height);  

    bmih->biPlanes = 1;  

    bmih->biBitCount = (unsigned short)bpp;  

    bmih->biCompression = BI_RGB;  

 

    if( bpp == 8 )  

    {  

        RGBQUAD* palette = bmi->bmiColors;  

        int i;  

        for( i = 0; i < 256; i++ )  

        {  

            palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;  

            palette[i].rgbReserved = 0;  

        }  

    }  

}  

 

CvvImage::CvvImage()  

{  

    m_img = 0;  

}  

 

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 = 10000;  

 

    if( (bpp != 8 && bpp != 24 && bpp != 32) ||  

        (unsigned)w >=  max_img_size || (unsigned)h >= max_img_size ||  

        (origin != IPL_ORIGIN_TL && origin != IPL_ORIGIN_BL))  

    {  

        assert(0); // 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();  

 

        /* prepare IPL header */  

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

    }  

 

    if( m_img )  

        m_img->origin = origin == 0 ? IPL_ORIGIN_TL : IPL_ORIGIN_BL;  

 

    return m_img != 0;  

}  

 

void  CvvImage::CopyOf( CvvImage& image, int desired_color )  

{  

    IplImage* img = image.GetImage();  

    if( img )  

    {  

        CopyOf( img, desired_color );  

    }  

}  

 

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

 

void  CvvImage::CopyOf( IplImage* img, int desired_color )  

{  

    if( HG_IS_IMAGE(img) )  

    {  

        int color = desired_color;  

        CvSize size = cvGetSize( img );   

 

        if( color < 0 )  

            color = img->nChannels > 1;  

 

        if( Create( size.width, size.height,  

            (!color ? 1 : img->nChannels > 1 ? img->nChannels : 3)*8,  

            img->origin ))  

        {  

            cvConvertImage( img, m_img, 0 );  

        }  

    }  

}  

 

 

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 < 0 || r.height < 0 ) return false;  

 

    IplImage* img = cvLoadImage( filename, desired_color );  

    if( !img )  

        return false;  

 

    if( r.width == 0 || r.height == 0 )  

    {  

        r.width = img->width;  

        r.height = img->height;  

        r.x = r.y = 0;  

    }  

 

    if( r.x > img->width || r.y > img->height ||  

        r.x + r.width < 0 || r.y + r.height < 0 )  

    {  

        cvReleaseImage( &img );  

        return false;  

    }  

 

    /* truncate r to source image */  

    if( r.x < 0 )  

    {  

        r.width += r.x;  

        r.x = 0;  

    }  

    if( r.y < 0 )  

    {  

        r.height += r.y;  

        r.y = 0;  

    }  

 

    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) + 1024];  

        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, 0 ), bmp_w - 1 );  

        from_y = MIN( MAX( from_y, 0 ), bmp_h - 1 );  

 

        int sw = MAX( MIN( bmp_w - from_x, w ), 0 );  

        int sh = MAX( MIN( bmp_h - from_y, h ), 0 );  

 

        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) + 1024];  

        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,           // handle to device context  

                HALFTONE );  

        }  

        else  

        {  

            SetStretchBltMode(  

                hDCDst,           // handle to device context  

                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&255,(color>>8)&255,(color>>16)&255,(color>>24)&255) );  

}  

 

// pIplImage 需要外部释放

 void CvvImage::BitmapToIplImage(Bitmap* pBitmap, IplImage* &pIplImg)

{

    if (!pBitmap)

    {

        return;

    }

    if(pIplImg)

    {

        cvReleaseImage(&pIplImg);

        pIplImg = NULL;

    }

    BitmapData bmpData;

    Rect rect(0,0,pBitmap->GetWidth(),pBitmap->GetHeight());

    pBitmap->LockBits(&rect, ImageLockModeRead, PixelFormat24bppRGB, &bmpData);

    IplImage* tempImg = cvCreateImage(cvSize(pBitmap->GetWidth(), pBitmap->GetHeight()), IPL_DEPTH_8U, 3);

    BYTE* temp = (bmpData.Stride>0)?((BYTE*)bmpData.Scan0):((BYTE*)bmpData.Scan0+bmpData.Stride*(bmpData.Height-1));

    memcpy(tempImg->imageData, temp, abs(bmpData.Stride)*bmpData.Height);

    pBitmap->UnlockBits(&bmpData);

    pIplImg = tempImg;

//判断Top-Down or Bottom-Up

 

    if (bmpData.Stride<0)       

 

        cvFlip(pIplImg, pIplImg);            

}

//OpenCV中 IplImage 转 Gdiplus::Bitmap

// pBitmap 同样需要外部释放!!

void CvvImage::IplImageToBitmap(IplImage* pIplImg, Bitmap* &pBitmap)

{

    if(!pIplImg)

        return;       

 

    BITMAPINFOHEADER bmih;

    memset(&bmih, 0, sizeof(BITMAPINFOHEADER));

    bmih.biSize = sizeof(BITMAPINFOHEADER);

    bmih.biWidth = pIplImg->width;

    bmih.biHeight = pIplImg->height;

    bmih.biPlanes = 1;

    bmih.biBitCount = pIplImg->depth*pIplImg->nChannels;

    bmih.biSizeImage = pIplImg->imageSize;

 

    BYTE* pData=new BYTE[bmih.biSizeImage];

    memcpy(pData, pIplImg->imageDataOrigin, pIplImg->imageSize);

 

   /* if (pBitmap)

    {

        delete pBitmap;

        pBitmap = NULL;

    }*/

    pBitmap = Gdiplus::Bitmap::FromBITMAPINFO((BITMAPINFO*)&bmih, pData);

 

BOOL CvvImage::IplImage2CBtmap(HDC dc,IplImage *pImage,CBitmap *bitmap)

{

if( pImage && pImage->depth == IPL_DEPTH_8U )

    {

        uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];

        BITMAPINFO* bmi = (BITMAPINFO*)buffer;

        int bmp_w = pImage->width, bmp_h = pImage->height;

 

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

int width=bmp_w;

int height=bmp_h;

int bpp=pImage ? (pImage->depth & 255)*pImage->nChannels : 0;

int origin=pImage->origin;

HBITMAP hBitmap;

char* dst_data = 0;

 

assert( bmi && width >= 0 && height >= 0 && (bpp == 8 || bpp == 24 || bpp == 32));

 

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

 

memset( bmih, 0, sizeof(*bmih));

bmih->biSize = sizeof(BITMAPINFOHEADER);

bmih->biWidth = width;

bmih->biHeight = origin ? abs(height) : -abs(height);

bmih->biPlanes = 1;

bmih->biBitCount = (unsigned short)bpp;

bmih->biCompression = BI_RGB;

 

if( bpp == 8 )

{

  RGBQUAD* palette = bmi->bmiColors;

  int i;

  for( i = 0; i < 256; i++ )

  {

palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;

palette[i].rgbReserved = 0;

  }

}

if(bitmap->m_hObject!=NULL)

{

  bitmap->Detach();

}

hBitmap=CreateDIBitmap(dc,bmih,CBM_INIT,pImage->imageData,bmi,DIB_RGB_COLORS);

bitmap->Attach(hBitmap);

return TRUE;

  }

return FALSE;

 

}

 

 

 

 

你可能感兴趣的:(OpenCV2没有了CvvImage,抄下低版本的CvvImage,可用于MFC中。)