Opencv on chai2010 的博客

CvImage中的陷阱和BUG

Sun, 06 Dec 2009 00:00:00 +0000

CvImage类的定义

class CV_EXPORTS CvImage {
public:
    CvImage() : image(0), refcount(0) {}
    CvImage( CvSize size, int depth, int channels ) {
        image = cvCreateImage( size, depth, channels );
        refcount = image ? new int(1) : 0;
    }
    CvImage( IplImage* img ): image(img)  {
        refcount = image ? new int(1) : 0;
    }
    ~CvImage() {
        if( refcount && !(--*refcount) ) {
            cvReleaseImage( &image );
            delete refcount;
        }
    }
    void attach( IplImage* img, bool use_refcount=true ) {
        if( refcount ) {
            if( --*refcount == 0 ) cvReleaseImage( &image );
            delete refcount;
        }
        image = img;
        refcount = use_refcount && image ? new int(1) : 0;
    }
    void detach() {
        if( refcount ) {
            if( --*refcount == 0 )  cvReleaseImage( &image );
            delete refcount;
            refcount = 0;
        }
        image = 0;
    }
    CvImage& operator = (const CvImage& img)   {
        if( img.refcount ) ++*img.refcount;
        if( refcount && !(--*refcount) ) cvReleaseImage( &image );
        image=img.image;
        refcount=img.refcount;
        return *this;
    }
protected:
    IplImage* image; // 实际影象
    int* refcount;   // 引用计数
};

CvImage类的相关代码在以下位置： OpenCV\cxcore\include\cxcore.hpp/OpenCV\cxcore\src\cximage.cpp 这里给出的只是部分函数。

为了提高效率，CvImage采用的是引用计数。不过目前的CvImage实现中，引用计数机制存在bug。

关于引用计数

引用计数应该也可以叫写时复制技术。就是在复制一个数据时，先只是简单地复制数据的指针（地址），只有在数据被修改的时候才真的进行数据的复制操作。写时复制技术对用户是透明的，也就是说用户可以当作数据是真的复制了。

一般数据（或者是文件，类等）都会对应创建/销毁操作。因此，采用写时复制技术的数据一般还对应一个计数，记录该数据被别人引用的次数。数据在第一次被创建的时候被设置为1，以后每次被重复创建则增加1，如果是被销毁则减少1。再销毁数据减少引用计数的时候，如果记录变为0则真的执行删除数据操作，否则的话只执行逻辑删除。

这里需要注意的一点是，每个引用计数和它对应的数据是绑定的。因此，任何一个引用计数都不应该独立于数据存在。

CvImage中的引用计数机制

class CV_EXPORTS CvImage {
    IplImage* image;
    int* refcount;
};

image指向影像数据的地址，refcount指向影像数据对应的引用计数的地址。需要强调的一点是， refcount指向的引用计数并不属于哪个类，而是属于image指向影像数据！任何将影像数据和其对应的引用计数分离的操作都是错误的。

`CvImage(IplImage* img)` 陷阱

假设有下面一个段代码：

IplImage *pIplImg = cvLoadImage("load.tiff");  {
    CvImage cvImg(pIplImg);
}
cvSaveImage("save.tiff", pIplImg);

虽然逻辑上好像没有错误，但再执行到cvSaveImage语句的时候却会产生异常！跟踪调试后发现，原来pIplImg对应的数据在cvImg析构的时候被释放了！

仔细分析后会发现，CvImage将pIplImg对应的数据和它本身的refcount绑定到一起了。pIplImg 对应的数据虽然不属于CvImage，但是它却依据refcount对其进行管理，直到(*refcount)变为0 的时候私自释放了pIplImg影像。

对于这个问题，我不建议使用引用计数，因此可以将代码修改为：

CvImage( IplImage* img, bool use_refcount=false) : image(img)  {
    refcount = use_refcount && image ? new int(1) : 0;
}

在默认的时候不使用引用计数机制，用户自己维护img内存空间。

attach问题

void attach( IplImage* img, bool use_refcount=true ) {
    if( refcount ) {
        if( --*refcount == 0 ) cvReleaseImage( &image );
        delete refcount;
    }
    image = img;
    refcount = use_refcount && image ? new int(1) : 0;
}

attach是将一个IplImage影像绑定到CvImage。

其中的一个陷阱和前面的CvImage类似：

IplImage *pIplImg = cvLoadImage("load.tiff");
{
    CvImage cvImg;
    cvImg.attach(pIplImg);
}  cvSaveImage("save.tiff", pIplImg); // 异常

处理是方法是把参数use_refcount的默认值改为false。

除了和CvImage类型的陷阱外，attach本身还有一个bug！

前面我们分析过，CvImage类中 refcount指向的空间和image指向的空间是绑在一起的。因此，if( --*refcount == 0 ) 语句中将cvReleaseImage( &image )和delete refcount 分离的操作肯定是错误的！！

假设有以下代码：

IplImage *pIplImg = cvLoadImage("load.tiff");
{
    CvImage cvImg;
    cvImg.create(cvSize(600,400), 8, 1); // 创建一个600*400的单字节单通道影像
    CvImage cvImgX(cvImg);               // 由cvImg拷贝构造cvImgX
    cvImgX.attach(pIplImg);
}
cvSaveImage("save.tiff", pIplImg);

代码将在执行完cvImgX.attach(pIplImg)语句后发生异常！

分析代码可以发现，cvImg.create先创建了一个影像，同时影像还对应一个引用计数。由于cvImgX 是有cvImg拷贝构造得到，因此cvImgX也保存了和cvImg一样的image和refcount。在接着执行的 attach中，cvImgX将refcount指向的空间释放（delete refcount）。注意, cvImgX和cvImg的refcount 对应同一个空间！！

那么在，cvImg退出花括号执行析构函数的时候，delete refcount语句就非法了！

修改bug后的attach代码：

void attach( IplImage* img, bool use_refcount=false ) // use_refcount默认值没有修改
{
    if( refcount )   {
        if( --*refcount == 0 ) { // 同时释放
            cvReleaseImage( &image );
            delete refcount;
        }
    }
    image = img;
    refcount = use_refcount && image ? new int(1) : 0;
}

由于CvImage中的许多函数都基于attach实现，因此没有修改use_refcount的默认值。 detach中的问题和attach相似，代码修改如下：

void detach() {
    if( refcount ) {
        if( --*refcount == 0 ) { // 同时释放
            cvReleaseImage( &image );
            delete refcount;
        }
        refcount = 0;
    }
    image = 0;
}

重载操作符“=”时的内存泄漏

CvImage& operator = (const CvImage& img)  {
    if( img.refcount ) ++*img.refcount;
    if( refcount && !(--*refcount) ) cvReleaseImage( &image );
    image=img.image;
    refcount=img.refcount;
    return *this;
}

假设有以下类似代码：

CvImage cvImg1, cvImg2;
cvImg1.create(cvSize(600,400), 8, 1);
cvImg2.create(cvSize(800,500), 8, 1);
cvImg1 = cvImg2;

虽然看着很清晰，但是该代码却存在内存泄漏！分析如下：

cvImg1先创建一个(600,400)大小的影像，默认还对应一个引用计数（refcount指向的空间）。 cvImg2 也采用同样的方式创建一个类似的影像。

注意：cvImg1和cvImg1中refcount指向的空间是不同的！！

下面执行“=”操作时，cvImg1的image空间被释放（cvReleaseImage( &image )），但是cvImg1的 refcount指向的空间却没有释放！然后，cvImg1的refcount指向了cvImg2的refcount。这样，cvImg1 的refcount指向内存就丢失了！

修改后的代码：

CvImage& operator = (const CvImage& img)  {
    if( img.refcount ) ++*img.refcount;
    if( refcount && !(--*refcount) ) {
        cvReleaseImage( &image ); // 释放refcount
        delete refcount;
    }
    image=img.image;
    refcount=img.refcount;
    return *this;
}

小节

虽然讲了这么多关于CvImage的陷阱和bug，单主要目的还是为了更好地使用CvImage。这里给出一个建议：在将IplImage数据和CvImage进行绑定，或者是基于IplImage数据构造CvImage对象的时候，要清楚是否需要使用CvImage的引用计数技术（有哪些好处/坏处）。特别是attach默认是采用引用计数的（没改的理由前面已经说明）。

附：修复的CvImage

class CV_EXPORTS CvImage  {
public:
    CvImage() : image(0), refcount(0) {}
    CvImage( CvSize size, int depth, int channels )
    {
        image = cvCreateImage( size, depth, channels );
        refcount = image ? new int(1) : 0;
    }
    // 修改
    CvImage( IplImage* img, bool use_refcount=false): image(img)
    {
        refcount = use_refcount && image ? new int(1) : 0;
    }
    ~CvImage()
    {
        if( refcount && !(--*refcount) ) {
            cvReleaseImage( &image );
            delete refcount;
        }
    }
    // 修改
    void attach( IplImage* img, bool use_refcount=false ) // use_refcount默认值没有修改
    {
        if( refcount )    {
            if( --*refcount == 0 ) { // 同时释放
                cvReleaseImage( &image );
                delete refcount;
            }
        }
        image = img;
        refcount = use_refcount && image ? new int(1) : 0;
    }
    // 修改
    void detach()   {
        if( refcount )    {
            if( --*refcount == 0 ) { // 同时释放
                cvReleaseImage( &image );
                delete refcount;
            }
            refcount = 0;
        }
        image = 0;
    }
    // 修改
    CvImage& operator = (const CvImage& img)   {
        if( img.refcount ) ++*img.refcount;
        if( refcount && !(--*refcount) )    {
            cvReleaseImage( &image );
            // 释放refcount
            delete refcount;
        }
        image=img.image;
        refcount=img.refcount;
        return *this;
    }
protected:
    IplImage* image; // 实际影象
    int* refcount;   // 引用计数
};

OpenCV中的内存泄漏检测

Sun, 06 Dec 2009 00:00:00 +0000

内存泄漏时程序开发中经常遇到的问题. 而且出现内存泄漏很难检测, 但是其导致的结果却是灾难性的. 这里讲一下opencv中内存泄漏检测的一些技巧.

OpenCV中关于内存管理主要涉及到以下3个函数:

CV_IMPL void  cvSetMemoryManager( CvAllocFunc alloc_func, CvFreeFunc free_func, void* userdata );
CV_IMPL void* cvAlloc( size_t size );
CV_IMPL void  cvFree_( void* ptr );

还有一个对应 cvFree_ 的宏:

#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)

宏 cvFree 的用处是在释放ptr指针对应的内存后, 将ptr设置为NULL.

这里我们先做个假设: opencv中所有的内存分配和释放都是通过cvAlloc和cvFree合作完成的. 如果你使用cvAlloc分配一个内存, 然后用delete来是释放内存是错误的(切记)!!!

因此, 如果我们能够跟踪到cvAlloc/cvFree的调用流程, 就可以分析内存泄漏的情况了.

一般情况下, 一个cvAlloc分配的内存最终必然要对应cvFree来释放, 如果cvAlloc/cvFree不是匹配出现, 那么可以认为出现了内存泄漏.

为此, 我们需要定义自己的内存管理函数, 然后通过cvSetMemoryManager装载到opencv中. 内存管理函数的类型如下:

typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);

其中的userdata是用户通过cvSetMemoryManager来设置的. 我们可以简单的吧userdata当作一个容器指针, 在每次执行我们自己的alloc_func/free_func函数时, 将内存的分配/释放情况记录到 userdata对应的容器.

为此, 我自己简单设计了一个MemTracker类:

#ifndef OPENCV_MEM_TRACKER_H
#define OPENCV_MEM_TRACKER_H

#include <stdio.h>
#include <vector>

// 内存泄漏追踪

class MemTracker
{
public:
    MemTracker(void);
    ~MemTracker(void);

private:

    // 登记分配/释放的内存
    void regAlloc(void *ptr, size_t size);
    void regFree(void *ptr);

    // 输出泄漏的内存
    int output(FILE* fp=stderr);

private:

    // 分配内存
    static void* alloc_func(size_t size, void *userdata);
    // 释放内存
    static int free_func(void *ptr, void *userdata);

private:

    struct Ptr
    {
        void *ptr;      // 内存地址
        size_t size;    // 内存大小

        Ptr(void *ptr, size_t size)
        {
            this->ptr = ptr;
            this->size = size;
        }
    };

    // 记录当前使用中的内存
    std::vector<Ptr>   m_memTracker;
};

#endif   // OPENCV_MEM_TRACKER_H

类的实现如下:

#include "MemTracker.h"

#include <assert.h>
#include <cv.h>

MemTracker::MemTracker(void)
{
    // 注册管理函数
    cvSetMemoryManager(alloc_func, free_func, (void*)this);
}

MemTracker::~MemTracker(void)
{
    // 取消管理函数
    cvSetMemoryManager(NULL, NULL, NULL);

    // 输出结果
    this->output();
}

// 登记分配/释放的内存
void MemTracker::regAlloc(void *ptr, size_t size)
{
    m_memTracker.push_back(Ptr(ptr, size));
}

void MemTracker::regFree(void *ptr)
{
    int i;
    for(i = 0; i < m_memTracker.size(); ++i)
    {
        // 删除记录
        if(m_memTracker[i].ptr == ptr)
        {
            m_memTracker[i] = m_memTracker[m_memTracker.size()-1];
            m_memTracker.pop_back();
            return;
        }
    }
}

// 输出泄漏的内存

int MemTracker::output(FILE* fp)
{
    int n = m_memTracker.size();
    int i;

    for(i = 0; i < n; ++i)
    {
        fprintf(fp, "%d: %p, %u\n", i, m_memTracker[i].ptr, m_memTracker[i].size);
    }
    return n;
}

// 分配内存

void* MemTracker::alloc_func(size_t size, void *userdata)
{
    assert(size > 0 && userdata != NULL);

    // 分配内存
    void *ptr = malloc(size);
    if(!ptr) return NULL;

    // 登记
    MemTracker *tracker = (MemTracker*)userdata;
    tracker->regAlloc(ptr, size);
    return ptr;
}

// 释放内存
int MemTracker::free_func(void *ptr, void *userdata)
{
    assert(ptr != NULL && userdata != NULL);

    // 释放内存
    free(ptr);

    // 登记
    MemTracker *tracker = (MemTracker*)userdata;
    tracker->regFree(ptr);

    // CV_OK == 0
    return 0;
}

MemTracker在构造的时候会注册自己的内存管理函数, 在析构的时候会输出没有被释放的内存. 下面我们编写一个测试程序:

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

#include "MemTracker.h"

int main()
{
    MemTracker mem;

    IplImage *img = cvLoadImage("lena.jpg", 1);
    if(!img) return -1;

    // 没有释放img内存
    // cvReleaseImage(&img);

    return 0;
}

在main函数退出的时候mem会被析构, 然后输出内存的泄漏情况. 下面是在我的电脑上测试的结果:

C:\work\vs2005\MemTracker\debug>MemTracker.exe
0: 00C750C0, 112
1: 00D90040, 786432

OK, 先说到这里吧, 下次再补充…

前面我们已经解决了内存泄漏的检测, 但是在出现内存泄漏的时候我们怎么才能跟踪到出现内存泄漏的代码呢? 如果能够调试到没有被释放内存对应的cvAlloc函数就好了.

这个我们可以通过m_memTracker[i].ptr来比较内存的地址来检测, 例如在alloc_func中添加以下代码, 然后设置断点:

// 检测00C750C0内存
if(ptr == (void*)00C750C0)
{
    // 设置断点
}

但是这个方法可能还有缺陷. 因为每次运行程序的时候, 内存的布局可能是有区别的. 最好的方法是把cvAlloc的调用顺序记录下来.

变动的部分代码:

class MemTracker
{
    struct Ptr
    {
        void *ptr;      // 内存地址
        size_t size;    // 内存大小
        int   id;

        Ptr(void *ptr, size_t size, int id)
        {
            this->ptr = ptr;
            this->size = size;
            this->id = id;
        }
    };

    // 记录当前使用中的内存
    std::vector<Ptr>   m_memTracker;

    // alloc_func对应的编号
    int               m_id;
};

MemTracker::MemTracker(void)
{
    m_id = 0;

    // 注册管理函数

    cvSetMemoryManager(alloc_func, free_func, (void*)this);
}

void MemTracker::regAlloc(void *ptr, size_t size)
{
    // 每次记录一个新的m_id
    m_memTracker.push_back(Ptr(ptr, size, m_id++));
}

// 输出泄漏的内存
int MemTracker::output(FILE* fp)
{
    int n = m_memTracker.size();
    int i;

    for(i = 0; i < n; ++i)
    {
        fprintf(fp, "%d: %p, %u\n", m_memTracker[i].id, m_memTracker[i].ptr, m_memTracker[i].size);
    }
    return n;
}

以后就可以根据m_memTracker[i].id来设置断点跟踪调试. 因为每次运行程序的时候, cvAlloc的调用次序是不变的, 因此可以认为每次cvAlloc对应的id也是不变的. 这样就可以根据id来追踪出现内存泄漏的cvAlloc了.

前面的帖子中我们已经讨论了cvAlloc/cvFree_/cvSetMemoryManager等函数的使用技巧. 下面开始分析OpenCV中以上函数的实现代码. 我觉得如果在阅读代码之前, 如果能对函数的用法有个基本的认识, 那么对于分析源代码是很有帮助的.

CV_IMPL  void*  cvAlloc( size_t size )
{
    void* ptr = 0;

    CV_FUNCNAME( "cvAlloc" );

    __BEGIN__;

    if( (size_t)size > CV_MAX_ALLOC_SIZE )
        CV_ERROR( CV_StsOutOfRange,
                "Negative or too large argument of cvAlloc function" );

    ptr = p_cvAlloc( size, p_cvAllocUserData );
    if( !ptr )
        CV_ERROR( CV_StsNoMem, "Out of memory" );

    __END__;

    return ptr;
}

从代码我们可以直观的看出, cvAlloc分配的内存不得大于CV_MAX_ALLOC_SIZE, 即使是使用我们自己的内存管理函数也会有这个限制.

然后通过p_cvAlloc对应的函数指针对应的函数来分配内存. p_cvAlloc是一个全局static变量, 对应的还有p_cvFree和p_cvAllocUserData, 分别对应释放内存函数和用户数据. 它们的定义如下:

// pointers to allocation functions, initially set to default
static CvAllocFunc p_cvAlloc = icvDefaultAlloc;
static CvFreeFunc p_cvFree = icvDefaultFree;
static void* p_cvAllocUserData = 0;

默认的内存管理函数分别为icvDefaultAlloc和icvDefaultFree(icv开头的表示为内部函数), 用户数据指针为空.

继续跟踪默认的内存分配函数icvDefaultAlloc, 代码如下:

static void*
icvDefaultAlloc( size_t size, void* )
{
    char *ptr, *ptr0 = (char*)malloc(
        (size_t)(size + CV_MALLOC_ALIGN*((size >= 4096) + 1) + sizeof(char*)));

    if( !ptr0 )
        return 0;

    // align the pointer
    ptr = (char*)cvAlignPtr(ptr0 + sizeof(char*) + 1, CV_MALLOC_ALIGN);
    *(char**)(ptr - sizeof(char*)) = ptr0;

    return ptr;
}

内部使用的是C语言中的malloc函数, 在分配的时候多申请了CV_MALLOC_ALIGN*((size >= 4096) + 1) + sizeof(char*) 大小的空间. 多申请空间的用处暂时先不分析.

下面的cvAlignPtr函数用于将指针对其到CV_MALLOC_ALIGN边界, 对于我们常规的PC来说是32bit, 也就是4字节. cvAlignPtr函数在后面会详细讨论.

下面语句将ptr0记录到(ptr - sizeof(char*)), 可以把它看作一个指针. 最后返回ptr. 细心的朋友可能会发现, 前面malloc分配的是ptr0, 现在返回的却是ptr, 这个是为什么呢?

这个的原因还是先放下, 但是返回ptr而不返回ptr0带来的影响至少有2个:

返回的ptr指针不能通过C语言的free函数释放(这也是cvAlloc/cvFree必须配对使用的原因).
在cvFree的时候, 可以根据(ptr - sizeof(char*))对应的值来检测该内存是不是由icvDefaultAlloc申请.

这样应该说可以增加程序的健壮性, icvDefaultFree可以不像傻瓜似的对于任何指针都进行释放.

下面来看看cvAlignPtr函数:

CV_INLINE void* cvAlignPtr( const void* ptr, int align=32 )
{
    assert( (align & (align-1)) == 0 );
    return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) );
}

该函数的目的主要是将指针ptr调整到align的整数倍

其中align必须为2的幂, assert语言用于该检测. 语句(align & (align-1)) 一般用于将align的最低的为1的bit位设置为0. 如果为2的幂那么就只有1个为1 的bit位, 因此语句(x&(x-1) == 0)可以完成该检测.

return语句简化后为 (ptr+align-1)&~(align-1), 等价于((ptr+align-1)/align)*align. 就是找到不小于ptr, 且为align整数倍的最小整数, 这里对应为将指针对其到4字节(32bit).

cvFree_函数和cvAlloc类似, 就不详细分析了:

CV_IMPL  void  cvFree_( void* ptr )
{
    CV_FUNCNAME( "cvFree_" );

    __BEGIN__;

    if( ptr )
    {
        CVStatus status = p_cvFree( ptr, p_cvAllocUserData );
        if( status < 0 )
            CV_ERROR( status, "Deallocation error" );
    }

    __END__;
}

p_cvFree默认值为icvDefaultFree:

static int
icvDefaultFree( void* ptr, void* )
{
    // Pointer must be aligned by CV_MALLOC_ALIGN
    if( ((size_t)ptr & (CV_MALLOC_ALIGN-1)) != 0 )
        return CV_BADARG_ERR;
    free( *((char**)ptr - 1) );

    return CV_OK;
}

最后我们简要看下cvSetMemoryManager函数, 它主要用来设置用户自己定义的内存管理函数:

CV_IMPL void cvSetMemoryManager( CvAllocFunc alloc_func, CvFreeFunc free_func, void* userdata )
{
    CV_FUNCNAME( "cvSetMemoryManager" );

    __BEGIN__;

    // 必须配套出现
    if( (alloc_func == 0) ^ (free_func == 0) )
        CV_ERROR( CV_StsNullPtr, "Either both pointers should be NULL or none of them");

    p_cvAlloc = alloc_func ? alloc_func : icvDefaultAlloc;
    p_cvFree = free_func ? free_func : icvDefaultFree;
    p_cvAllocUserData = userdata;

    __END__;
}

如果函数指针不为空, 则记录到p_cvAlloc和p_cvFree指针, 如果为空则恢复到默认的内存管理函数. 需要注意的是if语句的条件(alloc_func == 0) ^ (free_func == 0), 只有当2个函数1个为NULL, 1个不为NULL的时候才会出现, 出现这个的原因是内存管理函数的分配和释放函数不匹配了, 这个是不允许的.

因此, 我们需要设置自己的内存管理函数, 就需要同时指定alloc_func和free_func函数, 清空的时候则把2个参数都设置NULL就可以了.

今天再来补充一个小技巧 :)

我们前面通过cvSetMemoryManager函数来重新设置了自己的内存管理函数. 但是前面也说到过, 如果cvAlloc/cvFree覆盖的周期和MemTracker相交, 那么内存会出现错误.

即,

原来OpenCV默认函数分配的内存可能使用我们自己的cvFree函数来释放.
我们自己定义的cvAlloc分配的内存可能使用原来OpenCV默认的函数来释放.

这都会造成错误!

其实我们定义的目的只是要统计内存的使用情况, 我们并不想真的使用自己的函数的管理 OpenCV的内存. 道理很简单, OpenCV的内存经过优化, 对齐到某个字节, 效率更好.

如果能获取OpenCV原始的内存管理函数就好了, 但是没有这样的函数!!!

但是, 我们任然有方法来绕过这个缺陷.

我们可以在MemTracker::alloc_func函数进入之后, 在用cvSetMemoryManager恢复原来的内存管理函数, 这样我们统计目的也达到了, 而且还是用了OpenCV本身的函数来分配内存.

代码如下:

void* MemTracker::alloc_func(size_t size, void *userdata)
{
    assert(size > 0 && userdata != NULL);

    // 取消管理函数
    cvSetMemoryManager(NULL, NULL, NULL);

    // 用OpenCV的方式分配内存
    void *ptr = cvAlloc(size);

    // 登记
    if(ptr)
    {
        MemTracker *tracker = (MemTracker*)userdata;
        tracker->regAlloc(ptr, size);
    }

    // 重新注册注册管理函数
    cvSetMemoryManager(alloc_func, free_func, userdata);

    return ptr;
}

MemTracker::free_func的方法和上面类似, 就不贴代码了.

以后我们就可以透明的使用MemTracker了, 不管MemTracker对象在那个地方定义, 它对OpenCV的内存管理都不会有影响.

前面的方法虽然使得 MemTracker 可以在任何地方使用, 但是可能带来理解的难度.

因为在cvAlloc之后进入的是 MemTracker::alloc_func, 但是在这个函数中又调用了cvAlloc! 这看起来很像一个无穷递归调用!!

但是实际的运行结果却没有出现无穷递归导致的栈溢出情形. 仔细分析就知道原理了:

1. 定义MemTracker对象

中间调用了 cvSetMemoryManager(alloc_func, free_func, (void*)this); 函数, 设置 MemTracker::alloc_func 为分配函数.

2. 调用cvAlloc

内部执行到 MemTracker::alloc_func, 依次执行

// 取消管理函数
cvSetMemoryManager(NULL, NULL, NULL);

此刻, 分配函数又恢复为OpenCV的icvDefaultAlloc函数.

执行

// 用OpenCV的方式分配内存
void *ptr = cvAlloc(size);

// 登记
if(ptr)
{
    CvxMemTracker *tracker = (CvxMemTracker*)userdata;
    tracker->regAlloc(ptr, size);
}

这里的cvAlloc函数内部调用的是icvDefaultAlloc函数, 并不是MemTracker::alloc_func !! 就是这里了, alloc_func内部虽然调用了cvAlloc, 但是没有执行到alloc_func.

因此alloc_func不会出现递归.

OpenCV的图像读写框架

Sun, 06 Dec 2009 00:00:00 +0000

cvSaveImage/cvLoadImage函数用于保存和读取图像，两者的结构基本相似。下面我们主要分析cvSaveImage函数的实现。

cvLoadImage函数位于 “OpenCV\otherlibs\highgui\loadsave.cpp” 文件：

CV_IMPL IplImage*
cvLoadImage( const char* filename, int iscolor )
{
    return (IplImage*)icvLoadImage( filename, iscolor, false );
}

内部基于icvLoadImage函数实现。其中icvLoadImage函数的第三个参数可以用于装载矩阵，这里被忽略（false表示读图像）。

icvLoadImage函数的主要部分如下：

static void*
icvLoadImage( const char* filename, int flags, bool )
{
    // 查找图像的读驱动

    GrFmtReader* reader = g_Filters.FindReader( filename );

    // 利用图像读驱动读出图像头信息（高宽等属性）

    reader->ReadHeader();

    // 高度/宽度

    size.width = reader->GetWidth();
    size.height = reader->GetHeight();

    // 是否彩色

    int iscolor = reader->IsColor();

    // 彩色通道数为3，灰度为1

    int cn = iscolor ? 3 : 1;

    // 创建影像

    IplImage* image = cvCreateImage( size, type, cn );

    // 利用读驱动读图像的所有像素
    // image->data.ptr对应数据的开始地址
    // image->step表示每行像素所在内存的大小

    reader->ReadData( image->data.ptr, image->step, iscolor );

    return image;
}

其中g_Filters是一个静态变量：

// global image I/O filters
static CvImageFilters  g_Filters;

CvImageFilters在构造的时候，将已知的图像读写驱动保存到一个链表中。

CvImageFilters::CvImageFilters()
{
    m_factories = new GrFmtFactoriesList;

    m_factories->AddFactory( new GrFmtBmp() );
    m_factories->AddFactory( new GrFmtJpeg() );
    m_factories->AddFactory( new GrFmtSunRaster() );
    m_factories->AddFactory( new GrFmtPxM() );
    m_factories->AddFactory( new GrFmtTiff() );

    ...
}

GrFmtFactoriesList在grfmt_base.h/grfmt_base.cpp中定义，用于保存GrFmtFilterFactory 对象指针的链表。GrFmtFilterFactory为各种格式图像读写驱动的构造工厂基类：

class   GrFmtFilterFactory
{
public:

    GrFmtFilterFactory();
    virtual ~GrFmtFilterFactory() {};

    const char*  GetDescription() { return m_description; };
    int     GetSignatureLength()  { return m_sign_len; };
    virtual bool CheckSignature( const char* signature );
    virtual bool CheckExtension( const char* filename );
    virtual GrFmtReader* NewReader( const char* filename ) = 0;
    virtual GrFmtWriter* NewWriter( const char* filename ) = 0;

protected:
    const char* m_description;
        // graphic format description in form:
        // <Some textual description>( *.<extension1> [; *.<extension2> ...]).
        // the textual description can not contain symbols '(', ')'
        // and may be, some others. It is safe to use letters, digits and spaces only.
        // e.g. "Targa (*.tga)",
        // or "Portable Graphic Format (*.pbm;*.pgm;*.ppm)"

    int          m_sign_len;    // length of the signature of the format
    const char*  m_signature;   // signature of the format
};

其中GetDescription()用于获取图像文件名的描述，类似于”文本文件 (*.txt)“格式。

GetSignatureLength()用于获取图像文件的标志大小。对于tiff格式，开头有一个”II”或者是”MM”的标志，长度为2。如果是算上tiff后面的42版本号，长度则为4。长度大小和CheckSignature相关。

CheckSignature用于匹配图像文件的标志。如果对应的图像不需要标志，则可以在从GrFmtFilterFactory派生的子类中将其屏蔽。

CheckExtension匹配图像文件名的后缀名，用于也可以自己重新实现。

NewReader/NewWriter为读写驱动对应的构造函数，利用它们可以针对不同图像构造相应的驱动。

工厂类链表定义如下：

class   GrFmtFactoriesList
{
public:

    GrFmtFactoriesList();
    virtual ~GrFmtFactoriesList();
    void  RemoveAll();
    bool  AddFactory( GrFmtFilterFactory* factory );
    int   FactoriesCount() { return m_curFactories; };
    ListPosition  GetFirstFactoryPos();
    GrFmtFilterFactory*  GetNextFactory( ListPosition& pos );
    virtual GrFmtReader*  FindReader( const char* filename );
    virtual GrFmtWriter*  FindWriter( const char* filename );

protected:

    GrFmtFilterFactory** m_factories;
    int  m_maxFactories;
    int  m_curFactories;
};

FindReader/FindWriter用于查找图像对应的驱动。如果想修改查找的规则，可以通过 GetNextFactory遍历链表来实现。

真正的读写类从GrFmtReader派生，分别对应grfmt_bmp/grfmt_jpeg等各种格式驱动。然后通过前面的CvImageFilters::CvImageFilters()来讲各个驱动串到g_Filters.m_factories链表中。

class   GrFmtReader
{
public:

    GrFmtReader( const char* filename );
    virtual ~GrFmtReader();

    int   GetWidth()  { return m_width; };
    int   GetHeight() { return m_height; };
    bool  IsColor()   { return m_iscolor; };
    int   GetDepth()  { return m_bit_depth; };
    void  UseNativeDepth( bool yes ) { m_native_depth = yes; };
    bool  IsFloat()   { return m_isfloat; };

    virtual bool  ReadHeader() = 0;
    virtual bool  ReadData( uchar* data, int step, int color ) = 0;
    virtual void  Close();

protected:

    bool    m_iscolor;
    int     m_width;    // width  of the image ( filled by ReadHeader )
    int     m_height;   // height of the image ( filled by ReadHeader )
    int     m_bit_depth;// bit depth per channel (normally 8)
    char    m_filename[_MAX_PATH]; // filename
    bool    m_native_depth;// use the native bit depth of the image
    bool    m_isfloat;  // is image saved as float or double?
};

GrFmtReader比较核心的地方是3个virtual函数，分表用于读图像文件头、读数据、关闭图像文件。图像文件在读图像头的时候被打开。

对于图像的其他属性，可以通过在子类中直接操作m_iscolor等protected成员完成。

先大概说这么多，下一步将在上述分析的基础上，自己定义一个图像格式，然后提供相应的读写驱动，然后集成到cvSaveImage/cvLoadImage函数中。

OpenCV的测试框架

Sun, 06 Dec 2009 00:00:00 +0000

OpenCV提供了一套测试, 这里做简要的分析.

我选择的是 cvFindContours对应的测试, cvFindContours 函数本身的说明请参考:

http://wiki.opencv.org.cn/index.php/Cv图像处理#FindContours

cvFindContours 的测试函数对应 OpenCV\tests\cv\src\acontours.cpp 文件.

下面我们来分析一下测试代码的结构, 这样可以方便我们以后向opencv集成自己的代码以及代码测试. 测试对应的类为 CV_FindContourTest:

class CV_FindContourTest : public CvTest
{
public:
    enum { NUM_IMG = 4 };

    CV_FindContourTest();
    ~CV_FindContourTest();
    int write_default_params(CvFileStorage* fs);
    void clear();

protected:
    int read_params( CvFileStorage* fs );
    int prepare_test_case( int test_case_idx );
    int validate_test_results( int test_case_idx );
    void run_func();

    int min_blob_size, max_blob_size;
    int blob_count, max_log_blob_count;
    int retr_mode, approx_method;

    int min_log_img_size, max_log_img_size;
    CvSize img_size;
    int count, count2;

    IplImage *img[NUM_IMG];
    CvMemStorage* storage;
    CvSeq *contours, *contours2, *chain;
};

CV_FindContourTest 从 CvTest 派生, CvTest 位于 OpenCV\tests\cxts\cxts.h. 我们主要关注的是基类CvTest的构造函数:

CvTest::CvTest( const char* _test_name, const char* _test_funcs, const char* _test_descr ) :
    name(_test_name ? _test_name : ""), tested_functions(_test_funcs ? _test_funcs : ""),
    description(_test_descr ? _test_descr : ""), ts(0)
{
    if( last )
        last->next = this;
    else
        first = this;
    last = this;
    test_count++;

...
}

其中 first 等都是 CvTest 中的 static 成员:

protected:
    static CvTest* first;
    static CvTest* last;
    static int test_count;

到这里我们就可以基本断定, CV_FindContourTest 在构造的是被连接到了 CvTest::first 的链表. 我们通过这个链表就可以访问所有从 CvTest 派生的子类, 也就是用户自己实现的测试类.

OpenCV\tests\cv\src\acontours.cpp 文件的末尾有一下代码:

CV_FindContourTest find_contour_test;

该 find_contour_test 对象的主要功能是在构造的时候将自身串到 CvTest::first 链表.

下面就是测试代码的驱动了. 查看 OpenCV\tests\cv\src\tsysa.cpp 中的 main 函数:

#include "cvtest.h"

CvTS test_system;

int main(int argC,char *argV[])
{
    test_system.run( argC, argV );
    return 0;
}

CvTS::run 的基本功能就是遍历 CvTest::first 链表上的每个测试类, 然后调用测试类的 safe_run函数. safe_run 函数可以包含具体的测试代码, 具体的细节这里这里先不讨论.

C/C++的单元测试框架还有很多, 比如: CppUint, GTest 等.

补充(2014):

还有本人仿造Go语言测试根据而设计的迷你版C++单元测试库: https://github.com/chai2010/cc-mini-test

PyQt&OpenCV实现边缘检测

Sun, 06 Dec 2009 00:00:00 +0000

首先设计UI界面, 调整自己满意的布局. 其中黑色为 QLabel, 对象名为labelImage, 用于显示图像. 左下角为拖动条, 对称为sliderThreshold, 用于修改参数. Open按钮用于打开文件, 对象名为openButton. 在界面编辑器中, 将Close按钮的clicked信号连接到窗口的close槽.

窗口设计完成后保存到edge.ui, 然后基于edge.ui文件构造程序:

# -*- coding:utf-8 -*-
###########################################################
# PyQt+OpenCV example
#
# 查找图像中的边界.
# 参考 OpenCV\samples\python\edge.py 改写
#
# By chaishushan{AT}gmail.com 2008
###########################################################

import sys

# 导入PyQt模块
from PyQt4.Qt import *
from PyQt4 import uic

# 导入OpenCV模块
from opencv.cv import *
from opencv.highgui import *

# 边界检测类
class WinEdge(QWidget):
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)
        uic.loadUi("edge.ui", self)

        # OpenCV相关参数
        self.cv_img = None
        self.cv_col_edge = None
        self.cv_gray = None
        self.cv_edge = None

        # 标题
        self.defaultTitle = self.windowTitle()


    @pyqtSignature("")
    def on_openButton_clicked(self):
        filename = QFileDialog.getOpenFileName(self,
                            self.tr("Choose a Image"), ".",
                            self.tr("Image Files (*.jpg;*.bmp);;All Files (*)"))

        if not filename.isEmpty():
            self.sliderThreshold.setEnabled(False)

            self.openImage(filename)
            self.dectorEdge(self.sliderThreshold.value())

            # 更新UI
            if self.cv_col_edge:
                self.setWindowTitle(filename)
                self.sliderThreshold.setEnabled(True)
            else:
                self.setWindowTitle(self.defaultTitle)
                self.sliderThreshold.setEnabled(False)

    @pyqtSignature("int")
    def on_sliderThreshold_valueChanged(self, val):

        # 重新计算边界
        self.dectorEdge(val)

    def resizeEvent(self, event):
        self.showImage()

    # 打开图像
    def openImage(self, qstringName):
        # 将QString转换为char *
        filename = qstringName.toLocal8Bit().data()

        # 释放以前的图像
        if self.cv_img :
            cvReleaseImage( self.cv_img ); self.cv_img = None
            cvReleaseImage( self.cv_col_edge ); self.cv_col_edge = None
            cvReleaseImage( self.cv_gray ); self.cv_gray = None
            cvReleaseImage( self.cv_edge ); self.cv_edge = None

        # 打开新的图像
        self.cv_img = cvLoadImage(filename)
        if not self.cv_img:
            msg = self.tr("Can't open %1 file!").arg(filename)
            QMessageBox.warning (self, "Warning", msg)
            return False

        # 创建辅助空间
        size = cvSize(self.cv_img.width, self.cv_img.height)

        self.cv_col_edge = cvCreateImage (size, 8, 3)
        self.cv_gray = cvCreateImage (size, 8, 1)
        self.cv_edge = cvCreateImage (size, 8, 1)

        return True

    # 生成边界

    def dectorEdge(self, position):

        if not self.cv_img: return

        # 转换为灰度
        cvCvtColor (self.cv_img, self.cv_gray, CV_BGR2GRAY)

        cvSmooth (self.cv_gray, self.cv_edge, CV_BLUR, 3, 3, 0)
        cvNot (self.cv_gray, self.cv_edge)

        # run the edge dector on gray scale
        cvCanny (self.cv_gray, self.cv_edge, position, position * 3, 3)

        # 结构保存到cv_col_edge中
        cvSetZero (self.cv_col_edge)
        cvCopy (self.cv_img, self.cv_col_edge, self.cv_edge)

        # 显示
        self.showImage()

    # 显示图像
    def showImage(self):
        if not self.cv_col_edge: return

        # 转化IplImage为QImage
        w = self.cv_col_edge.width
        h = self.cv_col_edge.height

        step = self.cv_col_edge.widthStep
        data = self.cv_col_edge.imageData

        img = QImage(data, w, h, step, QImage.Format_RGB888).rgbSwapped()

        # 显示图像[缩放到窗口大小]
        size = self.labelImage.size()
        self.labelImage.setPixmap(QPixmap.fromImage(img.scaled(size)))

if __name__ == '__main__':
    app = QApplication(sys.argv)
    widget = WinEdge()
    widget.show()
    app.exec_()

运行结果如图:

完整的代码以后补充。

给OpenCV增加新的图像格式支持

Sun, 06 Dec 2009 00:00:00 +0000

在中提供了cvSaveImage/cvLoadImage两个函数用来读写影像。opencv本身支持一些常见的格式。

但是如果是自己定义的特殊影像格式，cvSaveImage/cvLoadImage则不能正确处理。

不过opencv本身的影像读写模块设计的比较好，很容易进行扩充。而且opencv在处理 tiff等格式的图像的时候也是借用了libtiff库。因此，我们自己也可以给opencv的 cvSaveImage/cvLoadImage增加新的图像格式支持。

例如，假设定义了一个txt格式的图像。那么就可以用以下代码进行读写：

IplImage *img;
img = cvLoadImage("test.txt", 1);
cvSaveImage("save.txt", img);

具体的示例代码现在没有完全写好，等完善之后会将驱动的实现细节整理出来。

由于内容比较多，我另开了一帖 OpenCV的图像读写框架.

关于cvLoadImage/cvSaveImage的读写框架已经分析过。现在我们来尝试自己实现一个图像格式的读写操作。

现在，我们定义图像后缀名为bin，例如image.bin等。 bin格式的结构和IplImage结构基本对应，具体如下：

"BIN"          // 文件类型，三个字节
width          // 图像宽度，int
height         // 图像高度，int
depth          // 像素深度，int
channels       // 通道数，int
data           // 每个像素数据

bin格式图像文件为二进制格式。由于opencv内部实现的一些限制，对于文本格式的图像文件支持可能相对困难一些（后面会提到）。

现在，参考grfmt_bmp代码，创建对应的grfmt_bin.h/grfmt_bin.cpp文件。

grfmt_bin.h内容如下：

#ifndef _GRFMT_BIN_H_
#define _GRFMT_BIN_H_

#include "grfmt_base.h"

// 测试：自己实现的图像格式

// 采用内存格式
// 内部保存一个img图像
// IplImage

class GrFmtBinReader : public GrFmtReader
{
public:

    GrFmtBinReader( const char* filename );
    ~GrFmtBinReader();

    bool  ReadData( uchar* data, int step, int color );
    bool  ReadHeader();
    void  Close();

protected:

FILE*   m_fp;        // 文件指针
int     m_channels;  // 通道数
};


// ... writer
class GrFmtBinWriter : public GrFmtWriter
{
public:

    GrFmtBinWriter( const char* filename );
    ~GrFmtBinWriter();

    bool  WriteImage( const uchar* data, int step,
                    int width, int height, int depth, int channels );
protected:

FILE*   m_fp;  // 文件指针
};


// ... and filter factory
class GrFmtBin : public GrFmtFilterFactory
{
public:

    GrFmtBin();
    ~GrFmtBin();

    GrFmtReader* NewReader( const char* filename );
    GrFmtWriter* NewWriter( const char* filename );

};

#endif/*_GRFMT_BIN_H_*/

grfmt_bin.cpp对应各个成员函数的实现。首先包含必要的头文件：

#include "_highgui.h"
#include "grfmt_bin.h"

GrFmtBin对应bin格式的对象工厂，其中NewReader/NewWriter用于创建用于读/写bin格式图像的驱动。

GrFmtBin::GrFmtBin()
{
    // 文件标志在开头，对应3个字节
    m_sign_len = 3;

    // 文件标志为"BIN"
    m_signature = "BIN";

    // 图像文件名描述，小括弧中的为后缀名
    m_description = "Bin image (*.bin)";

    // 只有后缀名为bin，并且以"BIN"3个字节开头的
    // 文件才会被当作bin格式图像。
}

GrFmtBin::~GrFmtBin()
{
}

// 构造读驱动
GrFmtReader* GrFmtBin::NewReader( const char* filename )
{
    return new GrFmtBinReader( filename );
}

// 构造写驱动
GrFmtWriter* GrFmtBin::NewWriter( const char* filename )
{
    return new GrFmtBinWriter( filename );
}

读驱动为GrFmtBinReader，从GrFmtReader派生：

GrFmtBinReader::GrFmtBinReader( const char* filename ) : GrFmtReader( filename )
{
    m_fp = NULL;
}

GrFmtBinReader::~GrFmtBinReader()
{
}

// 关闭图像文件
void  GrFmtBinReader::Close()
{
    if(m_fp) fclose(m_fp);
    GrFmtReader::Close();
}

// 读图像的属性
bool  GrFmtBinReader::ReadHeader()
{
    // 打开图像文件
    m_fp = fopen(m_filename, "rb");
    if(!m_fp) return false;

    // 跳过图像格式"BIN"
    char signature[3];
    fread(signature, 1, 3, m_fp);

    // int t[] = { width, height, depth, channels };
    // fwrite(t, sizeof(t), 1, m_fp);

    int t[4];
    fread(t, sizeof(t), 1, m_fp);

    m_width      = t[0];
    m_height   = t[1];
    m_bit_depth   = t[2];
    m_channels   = t[3];

    m_iscolor   = (m_channels>1)? true: false;

    assert(m_height > 0 && m_width > 0);
    return true;
}

// 图像的像素数据
bool  GrFmtBinReader::ReadData( uchar* data, int step, int color)
{
    if(color && m_channels == 1)
    {
        // 转换为彩色
        int y;
        for( y = 0; y < m_height; y++, data += step )
        {
            int x;
            for(x = 0; x < m_width; ++x)
            {
                int size = m_channels*m_bit_depth/8;

                char buf[8];
                fread(buf, 1, size, m_fp);

                data[size*x+0] = buf[0];
                data[size*x+1] = buf[1];
                data[size*x+2] = buf[2];
            }
        }
    }
    else
    {
        // 这里有待完善
        int y;
        for( y = 0; y < m_height; y++, data += step )
        {
            int size = m_channels*m_bit_depth*m_width/8;
            fread(data, 1, size, m_fp);
        }
    }

    return true;
}

写驱动为GrFmtBinWriter，从GrFmtWriter派生：

GrFmtBinWriter::GrFmtBinWriter( const char* filename ) : GrFmtWriter( filename )
{
}

GrFmtBinWriter::~GrFmtBinWriter()
{
}

bool  GrFmtBinWriter::WriteImage( const uchar* data, int step,
                                int width, int height, int depth, int channels )
{
    m_fp = fopen(m_filename, "wb");
    if(!m_fp) return false;

    const char *signature = fmtSignBin;
    fwrite(signature, 1, 3, m_fp);

    {
        int t[] = { width, height, depth, channels };
        fwrite(t, sizeof(t), 1, m_fp);
    }

    int i;
    for(i = 0; i < height; ++i, data += step)
    {
        fwrite(data, depth*channels/8, width, m_fp);
    }

    fclose(m_fp);

    return true;
}

到这里bin格式的驱动已经基本实现。下面还需要将驱动集成到opencv中。

1. 在grfmts.h包含bin格式图像驱动

#include "grfmt_bin.h"

2. 在loadsave.cpp中构造g_Filters的时候，添加驱动到链表

具体代码在CvImageFilters构造函数中完成：

CvImageFilters::CvImageFilters()
{
    m_factories = new GrFmtFactoriesList;

    m_factories->AddFactory( new GrFmtBmp() );
    m_factories->AddFactory( new GrFmtJpeg() );
    m_factories->AddFactory( new GrFmtSunRaster() );
    m_factories->AddFactory( new GrFmtPxM() );
    m_factories->AddFactory( new GrFmtTiff() );
#ifdef HAVE_PNG
    m_factories->AddFactory( new GrFmtPng() );
#endif
#ifdef HAVE_JASPER
    m_factories->AddFactory( new GrFmtJpeg2000() );
#endif
#ifdef HAVE_ILMIMF
    m_factories->AddFactory( new GrFmtExr() );
#endif

    // Bin格式图像驱动
    m_factories->AddFactory( new GrFmtBin() );
}

这里需要补充的是，m_factories链表中的顺序可能会影响 FindReader/FindWriter查找结果。在默认实现中是顺序查找，因此链表中排在前面的驱动被优先查找。

现在bin格式图像的驱动已经全部实现，重新编译highgui工程。

下一节将讲述cvLoadImage/cvSaveImage的具体执行流程。

测试bin格式的驱动代码：

#include <assert.h>
#include <highgui.h>

int main()
{
    const char *file_bmp = "E:\\TestXX\\gtalk-Alien.bmp";
    const char *file_bin = "E:\\TestXX\\gtalk-Alien.bin";

    // 将bmp转换为bin格式

    IplImage *img_bmp = cvLoadImage(file_bmp, 1);
    assert(img_bmp != NULL);

    cvSaveImage(file_bin, img_bmp);

    // 从bin格式装载图像
    // 目前bin驱动还不完善，第二个参数需设置为1

    IplImage *img_bin = cvLoadImage(file_bin, 1);
    assert(img_bin != NULL);

    // 创建窗口，用于显示图像

    const char *win_bmp = "Bmp Image";
    const char *win_bin = "Bin Image";

    cvNamedWindow(win_bmp);
    cvNamedWindow(win_bin);

    // 显示2个图像
    cvShowImage(win_bmp, img_bmp);
    cvShowImage(win_bin, img_bin);

    // 等待
    cvWaitKey(0);

    // 释放资源
    cvDestroyAllWindows();

    cvReleaseImage(&img_bmp);
    cvReleaseImage(&img_bin);

    return 0;
}

转换后的bin格式图像见附件，用户可以自己尝试打开bin图像文件。

调试驱动：

假设上面的测试对应的程序为C:\testBin.exe。用VC6打开opencv的工程，设置highgui工程的属性：在调试可以执行栏中输入C:\testBin.exe。

现在就可以调试highgui了。可以单步调试，也可以在bin的相关位置设置断点。需要注意的是，highgui工程和testBin工程默认的路径可能不同，因此在打开/保存图像的时候最好使用绝对路径。

Opencv on chai2010 的博客

CvImage中的陷阱和BUG

CvImage类的定义

关于引用计数

CvImage中的引用计数机制

CvImage(IplImage* img) 陷阱

attach问题

小节

OpenCV中的内存泄漏检测

OpenCV的图像读写框架

OpenCV的测试框架

PyQt&OpenCV实现边缘检测

给OpenCV增加新的图像格式支持

`CvImage(IplImage* img)` 陷阱