OpenCV 使用问题记录

    OpenCV从1.0到现在的3.0，变化还是相当大的。大趋势是从C结构层次到C++类层次的转变。
先从OpenCV底层的图像数据结构谈起，1.0时 图像数据结构是IplImage，之后是cvmat,之后2.2中出现了CvvImage，之后就是cv::mat，2.3之后CvvImage就被废弃了。

opencv中对图像的处理是最基本的操作，一般的图像类型为IplImage类型，但是当我们对图像进行处理的时候，多数都是对像素矩阵进行处理，所以这三个类型之间的转换会对我们的工作带来便利

Mat类型较CvMat和IplImage有更强的矩阵运算能力，支持常见的矩阵运算（参照Matlab中的各种矩阵运算），所以将IplImage类型和CvMat类型转换为Mat类型更易于数据处理。

Mat类型可用于直接存储图像信息，通过函数imread、imwrite、imshow等实现（与Matlab中的函数相似），似乎在某种程度上可以取代IplImage类型。

（1）将IplImage类型转换到Mat类型

Mat::Mat(const IplImage* img, bool copyData=false);

默认情况下，新的Mat类型与原来的IplImage类型共享图像数据，转换只是创建一个Mat矩阵头。当将参数copyData设为true后，就会复制整个图像数据。

例：

IplImage*iplImg = cvLoadImage("greatwave.jpg", 1);

Matmtx(iplImg); // IplImage* ->Mat 共享数据

// or : Mat mtx = iplImg;

（2）将Mat类型转换到IplImage类型

同样只是创建图像头，而没有复制数据。

例：

IplImage ipl_img = img; // Mat -> IplImage

（3）将CvMat类型转换为Mat类型

与IplImage的转换类似，可以选择是否复制数据。

Mat::Mat(const CvMat* m, bool copyData=false);

（4）将Mat类型转换为CvMat类型

与IplImage的转换类似，不复制数据，只创建矩阵头。

例：

// 假设Mat类型的imgMat图像数据存在

CvMat cvMat = imgMat; // Mat -> CvMat
Mat转换成IplImage类型

Mat 类有一个IplImage()运算符成员函数：

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. class CV_EXPORT Mat  
  2. {  
  3. // ...  
  4. //! converts header to IplImage; no data is copied  
  5.     operator IplImage() const;  
  6. //...  
  7. };  


利用该成员函数可以实现Mat类向IplImage类的转换，调用方法如下：

 

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. #include <opencv2/core/core.hpp>  
  2. #include <opencv2/highgui/highgui.hpp>  
  3. #include <iostream>  
  4.   
  5. using namespace cv;  
  6. using namespace std;  
  7.   
  8. int main( int argc, char** argv )  
  9. {  
  10.     Mat image = imread("Debug/lena_std.tif", IMREAD_COLOR); // Read the file  
  11.   
  12.     if(! image.data ) // Check for invalid input  
  13.     {  
  14.         cout << "Could not open or find the image" << std::endl ;  
  15.         return -1;  
  16.     }  
  17.   
  18.   
  19.     //convert to IplImage  
  20.     IplImage ipl_img(image);  //(1)  
  21.     //IplImage ipl_img = image; //(2)  
  22.     cvShowImage("ipl_img", &ipl_img);  
  23.     cvWaitKey(0);  
  24.   
  25.     return 0;  
  26. }  

(1)和(2)都会调用Mat类的operator IplImage()成员函数，实现向IplImage类的转换
那如何mat怎么转化为CvvImage呢？
先将mat转换为IplImage再到CvvImage，其实我们将mat转换为CvvImage的目的就是在Handel中显示图像。
eg：

CvvImage类以及在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

注意事项：

  • 由于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类
CvvImage.h

#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF

#include <opencv/cv.h>
#include <opencv/highgui.h>

/* 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 );

#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:

    IplImage* m_img;
};

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

opencv DrawToHDC图像处理问题

UpdateData(true);
// TODO: Add your control notification handler code here
CFileDialog fd(TRUE,_T("bmp"),_T(".bmp"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,"位图文件(*.bmp)|*.bmp||",this);
CString path;
if(fd.DoModal()==IDOK)
{
path=fd.GetPathName();
}
else return false;
//if(pImgEmbed.nSize!=0)cvReleaseImage(&pImgEmbed);   
IplImage * pImgEmbed = cvLoadImage((const char *)(LPCTSTR)path, CV_LOAD_IMAGE_UNCHANGED);
CDC* pDC = GetDlgItem(IDC_STATIC1) ->GetDC(); // 获得显示控件的 DC   
HDC hDC = pDC ->GetSafeHdc(); // 获取 HDC(设备句柄) 来进行绘图操作   
CRect rect;//,rect2; //
//((CStatic*)GetDlgItem(IDC_STATIC1))->GetWindowRect(&rect2);   
GetDlgItem(IDC_STATIC1) ->GetClientRect( &rect );   
int rw = rect.right - rect.left; // 求出图片控件的宽和高   
int rh = rect.bottom - rect.top;   
int iw = pImgEmbed->width; // 读取图片的宽和高   
int ih = pImgEmbed->height;   
int tx = (int)(rw - iw)/2; // 使图片的显示位置正好在控件的正中   
int ty = (int)(rh - ih)/2;   
SetRect( rect, tx, ty, tx+iw, ty+ih );   
//if(TraceFlag==FALSE) DrawFrame(pImgEmbed,TraceLocation);   
CvvImage cimg; 
cimg.CopyOf(pImgEmbed); // 复制图片   
cimg.DrawToHDC( hDC, &rect ); // 将图片绘制到显示控件的指定区域内   
cvWaitKey(50);   
ReleaseDC( pDC );  

//cvShowImage("水印图像", pImgEmbed);
GetDlgItem(IDC_STATIC1)->ShowWindow(SW_SHOW);
UpdateData(FALSE);
return TRUE;

我用以上程序显示第一幅图片很正常，但是载入以后的图片才发现前面的图片还是存在的，请问高手们，怎么判断是否已显示有图片，并删除旧图片只显示新图片 

OpenCV与MFC

OpenCV是计算机视觉自由软件的宝库。但是，由于历史的原因它的软件主要采用类似DOS操作系统的命令行方式，使用十分不便，这也影响了它的推广。如果能将它应用到VC++文档结构中就好了。OpenCV程序在MFC中实现的方法通常是采用CvvImage类，这个类的成员函数DrawToHDC可将位图整体经缩放后显示到视图窗口中，解决了位图的显示问题，也就解决了OpenCV在MFC中的使用问题。但是，也有两个致命的弱点，一是显示方式不合图像处理使用习惯，二是位图必须采用CvvImage类。显示方面，虽然已经能够察看图像，但当位图与窗口的长宽比不一致时会造成图像失真，这是浏览器的显示习惯，并不适用于图像处理应用。图像采集与处理的使用习惯是显示比例1：1，图像未经缩放，显示画面可按窗口大小进行裁剪并可使用滚动条选择显示部位。数据结构方面，采用CvvImage类以后程序中所有位图必须修改成这个类，这对于利用大量OpenCV现成软件来说是十分不方便的。显然，在VC++文档结构中使用OpenCV，其关键还是在于OpenCV位图在MFC中的显示。因此，有必要先比较一下两者的位图结构，然后寻找新的解决方法。

 StretchDIBits 函数

由于OpenCV位图结构中的像素数据与DIB中的像素具有类似的存储结构，可以考虑直接用来在视图窗口中显示。知道位图像素的存放地址直接往视图窗口显示的函数虽然不多，但还是有Windows API中的StretchDIBits函数可以利用，由下面列出的StretchDIBits函数原型中可知，只要为它构造一个DIB的位图信息就行了。

int StretchDIBits( HDC hdc, // 显示设备句柄
int XDest, YDest, nDestWidth, nDestHeight, // 目标矩形区域参数
 int XSrc, YSrc, nSrcWidth, nSrcHeight, // 源矩形区域参数 // 源区域与目标区域参数相同时为 1：1 比例显示
 CONST VOID *lpBits, // 位图的像素存放首地址
 CONST BITMAPINFO *lpBitsInfo, // 位图信息存放地址
UINT iUsage, // 位图中的颜色类型，RGB模式用DIB_RGB_COLORS DWORD dwRop // 像素操作码，简单复制用SRCCOPY );

为此，演示程序CCVMFC中增加了3个函数，即CtreateMapInfo、imageClone与imageReplace。其中，CtreateMapInfo 函数用于建立OpenCV位图的位图信息，其特点是可以为单通道位图设置黑白灰阶调色板。ImageClone函数使用OpenCV函数实现位图的复制，自动释放老的指针所指向的存储单元以防止内存泄漏，同时返回的m_dibFlag标志可以用于激发刷新工作位图workImg的位图信息m_lpBmi (见后面说明)。imageReplace与ImageClone相似，但不建立新位图，只用输入位图替换输出位图。

LPBITMAPINFO CtreateMapInfo(IplImage* workImg) // 建立位图信息
{
    BITMAPINFOHEADER BIH={40,1,1,1,8,0,0,0,0,0,0};
    LPBITMAPINFO lpBmi;
    int wid, hei, bits, colors,i;
     RGBQUAD ColorTab[256];
     wid =workImg->width;
    hei =workImg->height;
    bits=workImg->depth*workImg->nChannels;
    if (bits>8) colors=0; else colors=1<<bits;
    lpBmi=(LPBITMAPINFO) malloc(40+4*colors);
    BIH.biWidth =wid;
    BIH.biHeight =hei;
    BIH.biBitCount=(BYTE) bits;
    memcpy(lpBmi,&BIH,40); // 复制位图信息头
    if (bits==8) { // 256 色位图
        for (i=0;i<256;i++) { // 设置灰阶调色板
             ColorTab[i].rgbRed=ColorTab[i].rgbGreen=ColorTab[i].rgbBlue=(BYTE) i; }
        memcpy(lpBmi->bmiColors, ColorTab, 1024); }
     return(lpBmi); }
int imageClone(IplImage* pi, IplImage** ppo) // 复制 IplImage 位图 (OpenCV)
 {
    if (*ppo)
         cvReleaseImage(ppo); // 释放原来位图
*ppo) = cvCloneImage(pi); // 复制新位图
    return(true); } 

演示程序

演示程序CVMFC采用VC++多文档带滚动条结构，图像的存放与处理则采用OpenCV的位图结构与函数，图像的显示通过建立相应的位图信息m_lpBmi来实现，为了便于管理对m_lpBmi的操作集中在OnDraw程序中。待显示位图结构发生改变时用m_dibFlag标志激发m_lpBmi的刷新。除了文件结构与图像显示外，其馀部分基本上都是OpenCV程序。


位图数据：

CVMFCDoc中， pImg (读入图像文件所得原始位图)

CVMFCView中， workImg (工作位图)、saveImg (备份位图)、m_lpBmi (工作位图的位图信息)

CVDSCap中， m_Frame (视频采集所得位图)


视图的显示管理集中在OnDraw函数中：

void CCVMFC0View::OnDraw(CDC* pDC) { …… // 其馀部分内容
     if (m_dibFlag) { // 刷新 DIB位图信息
         if (m_lpBmi) free(m_lpBmi);
          m_lpBmi = CtreateMapInfo(workImg);
         m_dibFlag = 0; }
         if (workImg) { // 刷新视图窗口
              StretchDIBits(pDC->m_hDC, 0, 0, workImg->width, workImg->height, 0, 0, workImg->width, workImg->height, workImg->imageData, m_lpBmi, DIB_RGB_COLORS, SRCCOPY); } }

像素数据类型

图像处理主要是对像素数据的处理。需要注意的是，在OpenCV中像素存放地址imageData为char* 类型。因此，在图像处理时必须转换成BYTE* 类型才可以使用。下面以识别图像类型函数imageType为例来作说明。

int imageType(IplImage* p) // 识别图像类型 { int i,j,k,bpl,n,pg[256]; BYTE *buf; k=p->nChannels; // 1 与 3 分别表示灰阶图像与彩色图像 if ( k==1 ) { // 检查二值图像 for ( i = 0; i < 256; i++ ) pg[i] = 0; buf = (BYTE*) p->imageData; // 修改像素数据类型 bpl = p->widthStep; for ( i = 0; i < p->height; i++ ) { for ( j = 0; j < p->width; j++) pg[buf[j]]++; // 直方图统计 buf += bpl; } for ( i = 0, n = 0; i < 256; i++ ) if (pg[i]) n++; // 统计使用色阶数 if (n == 2) k = -1; // -1 表示二值图像 } return(k); }

 

图像镜像

在位图的像素方面，除了imageData的类型问题外，DIB位图与IplImage结构间还有一个显着的不同，那就是坐标原点位置的不同。前者的坐标原点在位图底部左侧，而后者在顶部左侧。因此，当在OpenCV中需要使用MFC的函数显示时位图应作垂直镜像，反之亦然。典型的例子是在OpenCV中调用DirectShow视频采集程序CameraDS中的获取当前帧函数QueryFrame，其程序如下：

IplImage* CCameraDS::QueryFrame() { …… m_pSampleGrabber->GetCurrentBuffer(&m_nBufferSize, (long*) m_pFrame->imageData); cvFlip(m_pFrame); return m_pFrame; }

演示程序CVMFC的图像输入输出采用OpenCV的cvLoadImage与cvSaveImage函数实现，而显示采用Windows API中的 StretchDIBits函数。为了能正常工作，图像读入后需作垂直镜像，图像存盘前也需作垂直镜像。也就是说，内存中存放的是经过垂直镜像的OpenCV位图。同样，因为结构相同，它也是DIB位图的像素数据。

BOOL CCVMFCDoc::Load(IplImage** pp,LPCTSTR csFileName) { IplImage* pImg=NULL; pImg = cvLoadImage(csFileName,-1); // 读图像文件 if (!pImg) return(false); cvFlip(pImg); // 使与 DIB 像素结构一致 if (*pp) cvReleaseImage(pp); (*pp)=pImg; m_Display=0; return(true); } BOOL CCVMFCDoc::Save(LPCTSTR csFileName,IplImage* pImg) { int bl; cvFlip(pImg); // 恢复原 OpenCV 位图结构 bl=cvSaveImage(csFileName,pImg); // 图像存盘 return(bl); }

对于大多数的图像处理算法来说位图的镜像与否没有什么影响。但是，对于某些OpenCV函数，例如涉及旋转方向以及需要往IplImage结构的位图上绘制图形、显示文字时就会使位置出错。这时就需要与存盘时一样先作垂直镜像，旋转角度反向，操作结束返回Windows视图显示处理结果时再转换回来。

 驱动模式与人机交互

众所周知，DOS操作系统采用过程驱动与文本模式，Windows操作系统采用事件驱动与图形模式，它们分别使用键盘与鼠标器作为主要输入工具。OpenCV编程环境基于DOS操作系统，因此显示图像需要调用cvNamedWindow函数建立专门的窗口，然后调用cvShowImage函数进行显示。画面的保持则使用cvWaitKey(0)语句，或使用内含cvWaitKey语句的死循环来实现。为了避免出现死机故障，出现OpenCV函数所开窗口时，务必使用ESCAPE键关闭窗口并退出。注意：菜单中带 (ESC) 字样的命令必须使用ESCAPE键退出。

同时，OpenCV编程环境人机交互的功能有限，只有鼠标、键盘与滑动条。其中，鼠标与滑动条属于事件驱动，而键盘属于过程驱动。由于没有菜单功能，只能使用键盘命令控制程序走向并等待键盘输入选择不同功能。

在驱动模式方面为了便于比较，提供了两个[点集凸包]命令，一个采用过程驱动，另一个采用事件驱动，不妨比较具体功能及其实现的程序。

程序移植例

演示程序CVMFC中待处理图像与处理结果都放在工作位图workImg中。同时，工作位图workImg也是窗口画面显示的内容。所以，处理程序中仅源图像的获取与结果图像的显示与OpenCV中的程序有所不同，中间处理部分可以完全相同，现以《学习OpenCV》一书中的例2-6为例来作修改说明。

void CCVMFC0View::OnCannyBorddetec() // Canny 边缘检测 { // 根据《学习OpenCV》例 2-6 改编 // 定义工作位图 IplImage* pImage; IplImage* pImg8u = NULL; IplImage* pImg8uSmooth = NULL; IplImage* pImgCanny = NULL; //** 输入待处理图像 ** // 修改部分 1 pImage = workImg; // 建立辅助位图 pImg8u =cvCreateImage(cvGetSize(pImage),IPL_DEPTH_8U,1); pImg8uSmooth=cvCreateImage(cvGetSize(pImage),IPL_DEPTH_8U,1); pImgCanny =cvCreateImage(cvGetSize(pImage),IPL_DEPTH_8U,1); // 图像处理 cvCvtColor(pImage, pImg8u,CV_BGR2GRAY); cvSmooth(pImg8u, pImg8uSmooth,CV_GAUSSIAN,3,0,0); cvCanny(pImg8uSmooth, pImgCanny,100,200,3); // 释放位图 cvReleaseImage(&pImg8u); cvReleaseImage(&pImg8uSmooth); //** 输出处理结果 ** // 修改部分 2 m_dibFlag = ImageReplace(pImgCanny, &workImg); //** 设置标志及刷新窗口 ** m_ImageType=1; Invalidate(); }

形参书写顺序

演示程序CVMFC是Windows API系统与OpenCV两种体系函数的混合使用，而它们的函数参数的书写习惯是不同的，极容易引起混淆。这里作一简要说明，请看下面例子：

目标参数Dest <-- 源参数Src

C： memcpy( pDest, pSrc, size); Windows API： BitBlt( hDestDC, 0, 0, wid, hei, hSrcDC, 0, 0, SRCCOPY); VC++: pDestDC->BitBlt( 0, 0, p->wid, p->hei, pSrcDC, 0, 0, SRCCOPY);

源参数Src --> 目标参数Dest

OpenCV： cvCvtColor( pSrcImg, pDestcImg, CV_BGR2GRAY); cvSmooth( pSrcImg, pDestcImg, CV_GAUSSIAN, 3, 0, 0);

演示程序中除了OpenCV函数采用后一书写形式外，其他函数都采用前一书写形式，千万注意不能混淆。OpenCV函数很容易辨认，都以前缀cv-开头，如cvCvtColor、cvSmooth。新增函数ImageClone与imageReplace因为调用OpenCV函数，故也采用后一书写形式。


Reference:在MFC中使用OpenCV
 

posted on 2015-12-06 12:20 Daywei 阅读(1928) 评论(0)  编辑 收藏 引用 所属分类: OpenCV


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


<2016年6月>
日一二三四五六
2930311234
567891011
12131415161718
19202122232425
262728293012
3456789

导航

统计

常用链接

留言簿

随笔分类

随笔档案

文章档案

牛人博客

搜索

积分与排名

最新评论

阅读排行榜