在vc或mfc中显示IplImage的方法

平常使用Open CV时总是跳出一个个窗口，很难将项目进行系统集成，特别是在MFC等Windows环境中加载显示Open CV中的IplImage图像；


/****************************************
  使用Open CVhighgui.h 中定义的CvvImage类，可以很好的实现Open CV和Windows MFC显示接口；先介绍一下CvvImage类：


 由于CvvImage是在 highgui.h 头文件中声明的，因此如果您的程序中需要使用，则必须在开头包含此头文件


#include <highgui.h>


CvvImage对应CImage宏:


#define CImage CvvImage
/***************************************
特别注意:由于OpenCV 2.0以后的版本将CvvImage类从highgui.h文件中删除了，故现已不能正常使用了
但可以使用以前老版本中的文件，故提取出CvvImage.h，与CvvImage.cpp供使用
使用时在用到的地方加入#include "CvvImage.h"即可
/***************************************




注意事项：


由于CImage太常见， 很容易造成冲突， 因此建议不要使用该宏(可以直接删去此宏定义)。 
警告：参数中含有HDC（注：一种windows系统下定义的变量类型，用来描述设备描述表的句柄类型）类型的并不能保证移植到其他平台，例如Show/DrawToHDC等。 
后文中的DC，即device context（设备环境），一般可以理解为windows操作系统为方便绘图而抽象的”绘图表面“，“往窗口上绘图”，有时也被说成是“往窗口DC上绘图”。 
CvvImage::Create
bool CvvImage::Create(int w, int h, int bpp, int origin);
创建一个图像。 成功返回true， 失败返回false。


w 图像宽


h 图像高


bpp 每个像素的bit数， 值等于像素深度乘以通道数


origin 0 - 顶—左结构， 1 - 底—左结构 (Windows bitmaps 风格)


例:// 创建一个400行600列的， IPL_DEPTH_8U类型的3通道图像， 顶—左结构


CvvImage img;


bool flag = img.Create(600, 400, IPL_DEPTH_8U*3, 0);


if(!flag)     printf("创建图像失败!");


 


CvvImage::CopyOf


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


从img复制图像到当前的对象中。
img 要复制的图像。
desired_color 为复制后图像的通道数， 复制后图像的像素深度为8bit。
例:// 读一个图像，然后复制为1个3通道的彩色图像


CvvImage img1, img2;


img1.Load("example.tiff");


img2.CopyOf(img1, 3);




CvvImage::Load
bool CvvImage::Load(const char* filename, int desired_color);
装载一个图像。
filename 图像文件名称。 
desired_color 图像波段数， 和cvLoadImage类似。 
 


 


CvvImage::LoadRect
bool CvvImage::LoadRect(const char* filename, int desired_color, CvRect rect);
从图像读出一个区域。


filename 图像名称。 
desired_color 图像波段数， 和cvLoadImage类似。 
rect 要读取的图像范围。 
注   LoadRect是先用Load装载一个图像，然后再将rect设置为图像的ROI区域，然后复制图像得到，因此，如果一个图像很大(例如几百MB)，即使想从中只读几个像素也是会失败的。 
CvvImage::Save
bool CvvImage::Save(const char* filename);保存图像。 和cvSaveImage相似。
CvvImage::Show
void CvvImage::Show(const char* window);显示一个图像。 和cvShowImage相似。
CvvImage::Show
void CvvImage::Show(HDC dc, int x, int y, int w, int h, int from_x, int from_y);
绘制图像的部分到DC。 图像没有缩放。此函数仅在Windows下有效。


dc 设备描述符。 
x 局部图像显示在DC上,从DC上的第x列开始。 
y 局部图像显示在DC上,从DC上的第y列开始。 
(x,y)为局部图像显示在DC上的起始位置。 
w 局部图像宽度。 
h 局部图像高度。 
from_x 从图像的第from_x列开始显示。 
from_y 从图像的第from_y行开始显示。 


例:// 从图像10行20列开始，显示400行600列图像到设备描述符的100行200列开始的位置


CvvImage img;
img.Load("example.tiff");
img.Show(hDC, 200, 100, 600, 400, 20, 10);




CvvImage::DrawToHDC
void CImage::DrawToHDC(HDC hDCDst, RECT* pDstRect);
绘制图像的ROI区域到DC的pDstRect，如果图像大小和pDstRect不一致，图像会拉伸/压缩。此函数仅在Windows下有效。


hDCDst 设备描述符。 
pDstRect 对应的设备描述符区域。 
例:


CvvImage img; img.Load("example.tiff"); CRect rect; rect.left = 100; rect.top = 200; rect.right = rect.left + 600; rect.bottom = rect.top + 400; img.DrawToHDC(hDC, &rect); 
CvvImage::Fill
void CvvImage::Fill(int color);


以color颜色填充图像。
CvvImage类定义
 class CV_EXPORTS CvvImage 
{public: 
 CvvImage(); 
 virtual ~CvvImage(); 
 virtual bool Create( int width,int height,int bits_per_pixel,int image_origin=0 ); virtual bool Load( const char* filename, int desired_color = 1 ); 
 virtual bool LoadRect( const char* filename,int desired_color, CvRect r ); 
#ifdef 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 = -1 ); 
 virtual void CopyOf( IplImage* img, int desired_color = -1 ); 
 IplImage* GetImage() { return m_img; }; 
 virtual void Destroy(void); 
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 ); 
virtual void Show( const char* window ); #ifdef WIN32 
virtual void Show(HDC dc,int x,int y,int width,int height,int from_x = 0,int from_y = 0 ); virtual void DrawToHDC( HDC hDCDst, RECT* pDstRect ); #endif 
protected: 
 IplImage* m_img; }; 
 有了上面对CvvImage类的介绍，可以很容易的在Windows窗口中显示图像了，下面是在MFC的CView窗口中 
中显示IplImage图像的函数代码 
void CMyView::ShowIplImage(IplImage* img) { CDC* pDC = GetDC();HDC hDC= pDC->GetSafeHdc(); CRect rect; rect.SetRect(0 , 0 , img->width , img->height); CvvImage cimg; cimg.CopyOf(img); cimg.DrawToHDC(hDC,&rect); ReleaseDC(pDC); 
} 
 
void Cdialog_iplImageDlg::DrawPicToHDC(IplImage* iplimg , UINT ID){CDC *pDC = GetDlgItem(ID)->GetDC();HDC hDC= pDC->GetSafeHdc();CRect rect;GetDlgItem(ID)->GetClientRect(&rect);CvvImage cimg; 
 cimg.CopyOf(iplimg);cimg.DrawToHDC(hDC,&rect);ReleaseDC(pDC);} 

 

CvvImage类：

#pragma once

#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgproc/imgproc_c.h"


class  CvvImage
{
public:
	CvvImage();
    virtual ~CvvImage();
    virtual bool  Create( int width, int height, int bits_per_pixel, int image_origin = 0 );
    virtual bool  Load( const char* filename, int desired_color = 1 );
    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 = -1 );
    virtual void  CopyOf( IplImage* img, int desired_color = -1 );
    IplImage* GetImage() { return m_img; };
    virtual void  Destroy(void);
  
    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 );
    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 = 0, int from_y = 0 );
    virtual void  DrawToHDC( HDC hDCDst, RECT* pDstRect );
#endif

protected:
	IplImage*  m_img;
};

typedef CvvImage CvImage;

#endif

#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();
		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;
   }

 
   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) );
}