无法显示该文件夹。此邮件存储区已达到它的最大大小。若要减少此邮件存储区中的数据量，请选中一些您不再需要的邮件，永久(SHIFT+DEL)删除它们。
打开控制面板，找到MAil
找到数据文件
打开数据文件后，找到打开文件位置。
查看邮件的Outlook文件的大小。
右击outlook文件属性 ，查看到此outlook文件大小是47.6G
为什么会提示报如上所示报错信息，是因为outlook邮件总大小是有限制的。
 参考微软给出的解决方案：
https://support.microsoft.com/zh-cn/help/832925/how-to-configure-the-size-limit-for-both-pst-and-ost-files-in-outlook
Microsoft Outlook 2016、Outlook 2013、Outlook 2010、Outlook 2007 和 Outlook 2003 支持 American National Standards Institute (ANSI) 以及 UNICODE 个人文件夹 (.pst) 和脱机文件夹 (.ost) 文件。
本文描述如何使用以下四个注册表项来限制 .pst 和 .ost 文件的大小：
MaxFileSize 注册表项
WarnFileSize 注册表项
MaxLargeFileSize 注册表项
WarnLargeFileSize 注册表项
注意 在达到文件大小限制之前，WarnLargeFileSize 和 WarnFileSize 注册表项不会使 Outlook 向你发出警告。
MaxFileSize 注册表项
MaxFileSize 注册表项决定 .pst 和 .ost 文件可以增长到的最大绝对大小。达到此最大大小后，Outlook 不允许文件大小的增长超过此大小。
WarnFileSize 注册表项
WarnFileSize 注册表项决定 .pst 和 .ost 文件可以拥有的最大数据量。达到此最大数据量后，将不允许 .pst 和 .ost 文件再添加任何数据。但是，物理文件的大小仍会因内部进程而增长。在下表中，MaxLargeFileSize 注册表项和 WarnLargeFileSize 注册表项指的是 UNICODE 格式(新的 Large 格式)文件；MaxFileSize 注册表项和 WarnFileSize 注册表项指的是 ANSI 格式(早期的 Microsoft Outlook 格式)文件。UNICODE 值是以兆字节 (MB) 增量设置的，而 ANSI 值是以字节增量设置的。
请执行下列步骤配置 .pst 和 .ost 文件的大小限制。
注意 本文中讨论的设置同时适用于 .ost 和 .pst 文件。如果修改这些注册表值，可能会影响与缓存 Exchange 模式、自动存档以及 .pst 文件一起使用的 .ost 文件。如果将 Outlook 配置为下载共享文件夹，则共享文件夹的内容将存储在本地脱机 Outlook 数据 (.ost) 文件中。如果共享文件夹包含许多项目或大型附件，则 .ost 文件的大小可能会显著增长。此外，Outlook 2013 还引入了对站点邮箱的支持。如果 Outlook 2013 客户端在 Microsoft Exchange Server 2013/Microsoft SharePoint 2013 环境下运行，且被授予站点邮箱的权限，则站点邮箱将自动添加到 Outlook 2013 配置文件中。如果启用了“下载共享文件夹”，则站点邮箱内容将同步到本地 .ost 文件。这可能导致 .ost 文件超出设置的限制。
注册表修改不当可能会出现严重问题。因此，请务必严格按照这些步骤操作。为了获得进一步的保护，请在修改注册表之前对其进行备份，这样就可以在出现问题时还原注册表。 
手动备份注册表
从开始菜单中的搜索框中，键入regedit.exe ，然后按 enter 键。如果提示您输入管理员密码或进行确认，请键入密码或提供确认。
在注册表编辑器中，找到并单击您要备份的子项的注册表项。
单击文件>导出。
在导出注册表文件对话框中，选择您要保存的备份副本的位置，然后在 [文件名]字段中键入备份文件的名称。
单击保存。
将手动还原备份
从开始菜单中，键入regedit.exe，，然后按 enter 键。如果提示您输入管理员密码或进行确认，请键入密码或提供确认。
在注册表编辑器中，单击文件>导入。
在导入注册表文件对话框中，选择备份副本保存到的位置，选择该备份文件，然后单击打开。
1、单击“开始”，然后单击“运行”。
2、在“打开”框中，键入regedit，然后单击“确定”。
3、在左窗格中，展开“我的电脑”，然后展开 HKEY_CURRENT_USER。
4、展开 Software，然后展开Policies。
5、展开 Microsoft，然后展开Office。
6、展开 11.0(对于 Outlook 2003)、12.0(对于 Outlook 2007)，或 14.0(对于 Outlook 2010)、15.0(对于 Outlook 2013)，或 16.0(对于 Outlook 2016)，然后展开 Outlook。
7、单击 PST，然后在右窗格中右键单击MaxFileSize。
8、单击“修改”，然后在“数值数据”框中键入值。
9、单击“确定”。
10、右键单击 WarnFileSize，然后重复步骤 8 至 9。
11、右键单击 MaxLargeFileSize，然后重复步骤 8 至 9。
12、右键单击 WarnLargeFileSize，然后重复步骤 8 至 9。
注意 你可能需要创建注册表值(如果不存在)。如果这些注册表值不存在，请按照下列步骤创建它们。
1、单击“开始”，单击“运行”，键入 Regedit，然后单击“确定”。
2、在左窗格中，展开下列注册表项：
对于 Outlook 2016
HKEY_CURRENT_USERSoftwarePoliciesMicrosoftOffice16.0Outlook
对于 Outlook 2013
HKEY_CURRENT_USERSoftwarePoliciesMicrosoftOffice15.0Outlook 
对于 Outlook 2010
HKEY_CURRENT_USERSoftwarePoliciesMicrosoftOffice14.0Outlook 
对于 Outlook 2007
HKEY_CURRENT_USERSoftwarePoliciesMicrosoftOffice12.0Outlook 
对于 Outlook 2003
HKEY_CURRENT_USERSoftwarePoliciesMicrosoftOffice11.0Outlook
3、右键单击 Outlook，指向“新建”，然后单击“项”。
4、键入 PST，然后按 Enter 键。
5、右键单击“PST”，指向“新建”，然后单击“DWORD 值”。
6、键入 MaxFileSize，然后按两次 Enter。
7、在“编辑 DWORD 值”窗口中，选择“十进制”，并在“数值数据”框中键入值，然后单击“确定”。注意1GB=1*1024*1024*1024 字节；1MB=1*1024*1024 字节；1KB=1*1024 字节，以下示例为 1GB。
8、重复步骤 3 至 7，创建另一个 DWORD WarnFileSize。
9、重复步骤 3 至 7，创建另一个 DWORD MaxLargeFileSize。
10、重复步骤 3 至 7，创建另一个 DWORD WarnLargeFileSize，然后关闭注册表。
注意 若要在最终用户计算机上大量部署这些注册表项，可以使用 ORK 工具。
若要在最终用户的计算机上自动创建注册表，可以使用 ORK 部署方案。
建议 MaxFileSize 注册表项与 WarnFileSize 注册表项之间的值以及 MaxLargeFileSize 注册表项与 WarnLargeFileSize 注册表项之间的值至少为 5%，以便不会阻碍内部进程继续执行。
如果 MaxFileSize 注册表项的值超过 .pst 或 .ost 文件的 ANSI 2 GB 限制，则忽略该值，将大小限制在 2 GB 以防止文件损坏。对于 UNICODE 文件，WarnFileSizeregistry 注册表项的默认值计算为 MaxFileSize 注册表项的 95%，而对于小的 ANSI 文件，它保留为 1,950,368,768 字节。
注意 可以将 UNICODE 限制设置为超出表中列出的值。但是，由于会引起性能下降，建议您不要这样做。
如果 .ost 文件或 .pst 文件达到 WarnFileSize 或 WarnLargeFileSize 注册表项中指定的限制，则触发压缩功能以尝试将文件大小减小到可用级别。当达到 WarnFileSize 或 WarnLargeFileSize 限制时，将无法发送电子邮件(假设已发送的电子邮件存储在“已发送的邮件”文件夹中)，且无法在文件中复制或移动项目。如果此文件是用于自动存档的存档 .pst 文件，则自动存档操作将失败。但是，可以删除电子邮件或从当前作为默认传送位置使用的 .pst 或 .ost 文件来对其进行存档。
下面是文件达到注册表项中指定的最大值时可能出现的一些错误：
当尝试将项目移动到已达到限制的 .pst 或 .ost 文件中时，你会收到以下错误信息：
Can't move the items. 文件 .pst 已达到它的最大大小。要减少该文件中的数据量，选择你不再需要的邮件，然后永久删除它们。
当电子邮件传送到使用缓存 Exchange 模式的 .pst 或 .ost 文件，并且此文件已达到限制时，将启动“邮箱清除”向导。

1.按照文章《OpenCV+MFC显示图像》，完成配置。
2.创建相应的图像控件，按钮控件。
3.进行类型转换。
在当前OpenCV2版本内，图像格式为cv::Mat ，而该格式无法直接在MFC内显示。因此，需要将其转换为可以在MFC内显示的CvvImage类格式，该类内有函数 DrawToHDC()支持MFC。试了一下无法直接实现，需要曲线救国。首先，将 格式cv::Mat变换为格式IplImage，再转换格式为 CvvImage。
还有问题，目前openCV2版本不再支持CvvImage，故需要导入该类的CvvImage.h和CvvImage.cpp。具体方法可以百度。
4.代码：
Mat mat=imread("llz.jpg");  
CDC* pDC = GetDlgItem(IDC_STATIC)->GetDC();
HDC hDC = pDC->GetSafeHdc();
IplImage img = mat;
CvvImage cimg;
cimg.CopyOf( &img );
CRect rect;
GetDlgItem(IDC_STATIC)->GetClientRect(&rect);
cimg.DrawToHDC(hDC, &rect);
ReleaseDC( pDC );

5.运行结果。

参考文献：
1.MFC中使用openCV显示、处理图像，http://licong1018.blog.163.com/blog/static/9026978420129239178934/
PS，需要加上namespace....http://blog.csdn.net/superdont/article/details/24851727

目录标题
写在前面
先看效果
函数代码

写在前面
以前的版本会出现音频播放与波形显示不同步的情况，且还需手动调整步长，并不能算是严格意义上的播放器。为此，在新版本中添加了定时器功能。

“最近整理音频相关的资料，有时候需要根据音频的波形来人为地判断哪一段数据是可取的，哪一段又是该删掉的。这个小问题却连续困扰了我多日：普通的音频播放软件只能流畅的播放音频，却无法显示数据波形.  为此，我利用Matlab编写一个小程序来解决这个问题。”
先看效果
如图所示：


随着音频的播放，窗口中有两个实时显示的图像：

第一个图像为整段音频的波形，红色部分为当前播放处的实时波形.

第二个图像聚焦于上图音频中的红色部分，用于查看实时波形的细节.
函数代码
两个子程序：

第一个为定时器结构；第二个为播放器。
% 定时器：播放窗口设置
function sound_timer(signal,player,half_space)
% 计算片段左右侧索引
left = player.CurrentSample - half_space;
right = player.CurrentSample + half_space;
left = max(1,left);
right = min(right,length(signal));
fragment = signal(left:right);
t = ([left:right]-1)/player.SampleRate;
if left<=1
    fragment = [zeros(1,right-left+1),fragment];
    t = [(2*left-right-1:left-1)/player.SampleRate,t];
end
if right>=length(signal)
    fragment = [fragment,zeros(1,right-left+1)];
    t = [t,(right+1:2*right-left+1)/player.SampleRate];
end
subplot(2,1,1)
plot(([1:length(signal)]-1)/player.SampleRate,signal,'k-')
hold on,plot(t,fragment,'r-')
set(gca,'xlim',([1 length(signal)]+[-1 1]*half_space)/player.SampleRate,'ylim',[min(signal) max(signal)]);
xlabel('时间/s')
ylabel('幅值')
subplot(2,1,2)
plot(t,fragment,'r-')
set(gca,'xlim',[t(1),t(end)],'ylim',[min(signal) max(signal)]);
xlabel('时间/s')
ylabel('幅值')
end

% 播放器
function sound_play(signal,fs,fragment)
warning off
if nargin<4
    fragment = length(signal)/fs/50;
end
player = audioplayer(signal,fs);
half_space = round(fragment*fs/2);
figure,set(gcf,'position',[680   673   683   305]);
subplot(2,1,1)
plot(([1:length(signal)]-1)/fs,signal,'k-')
set(gca,'xlim',([1 length(signal)]+[-1 1]*half_space)/fs,'ylim',[min(signal) max(signal)]);
xlabel('时间/s')
ylabel('幅值')
subplot(2,1,2)
set(gca,'xlim',([1 length(signal)]+[-1 1]*half_space)/fs,'ylim',[min(signal) max(signal)]);
xlabel('时间/s')
ylabel('幅值')
pause(fragment);
play(player);
my_timer = timer('BusyMode','drop','ExecutionMode', 'fixedSpacing', 'Period', fragment);
my_timer.StartDelay = 0;
my_timer.TimerFcn = @(~,~) sound_timer(signal,player,half_space);
start(my_timer)
pause(length(signal)/fs+2)
delete(my_timer)
end


运行示例：
clear;clc;close all;warning off
fs = 20000;
signal = sin(2*pi*1000*[0:4*fs]/fs)+randn(1,4*fs+1);
sound_play(signal,fs,0.1);

输入参数有三个，分别为音频信号（signal）、采样率（fs）、定时器时间（fragment）；

其中，定时器时间可省略，定时器的时间设置越小，看起来越流畅，但对计算机内存的占用也越多.
2021/01/11

在当前OpenCV2版本内，图像格式为cv::Mat ，而该格式无法直接在MFC内显示。因此，需要将其转换为可以在MFC内显示的CvvImage类格式，该类内有函数 DrawToHDC()支持MFC。
在做数字图像处理大作业时，碰到了MFC框架下图片显示的问题，在早期的opencv版本中，可以使用CvvImage类解决图片显示问题，但较新版本的opencv已废弃了此类，因此需要我们在项目中手动添加。
下面是CvvImage类的头文件及源文件代码:


CvvImage.h

#pragma once

#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF

#include "opencv.hpp"

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

可以直接在项目中引用这两个文件，用法如下：



void Ctest1Dlg::ShowPic()
{
    mat = imread(tstring);
    if(!mat.data) {
        MessageBox(_T("error"), _T("no image loaded!"), MB_OK);
        return;
    }
    CDC* pDC = GetDlgItem(IDC_RENDER)->GetDC();
    HDC hDC = pDC->GetSafeHdc();
    IplImage img = mat;
    CvvImage cimg;
    cimg.CopyOf( &img );
    CRect rect;
    GetDlgItem(IDC_RENDER)->GetClientRect(&rect);
    cimg.DrawToHDC(hDC, &rect);
    ReleaseDC( pDC );
}

其结果如下：