OpenCV3.0+MFC+VS2010打开图像

最新推荐文章于 2020-06-27 09:59:40 发布
最新推荐文章于 2020-06-27 09:59:40 发布
阅读量507 收藏 1
点赞数 1

最近刚开始学OpenCV3.0结合MFC进行图像处理，做了一个非常简单的OpenCV3.0在VS2010中建立一个MFC程序打开图片的小程序，具体过程如下。 
【1】首先按照链接中的步骤 
http://blog.csdn.net/poem_qianmo/article/details/19809337，在VS2010中配置好OpenCV3.0。 
【2】打开VS2010，新建一个MFC程序，如下图所示： 
这里写图片描述

【3】点击下一步： 
这里写图片描述

【4】选择设置如下： 
这里写图片描述

【5】点击“完成”，显示如下界面： 
这里写图片描述

【6】在“工具箱”中找到“Button”控件，添加至界面： 
这里写图片描述

【7】右击“Button1”,选择属性，将”Caption“属性改为”打开图像“： 
这里写图片描述

【8】在“工具箱”中找到“Picture Control”控件，添加至界面，右击新添加的“Picture Control”控件，选择属性，将里面的“Type”属性改为“Rectangle”： 
这里写图片描述

【9】右击“打开图像”，选择“添加事件处理程序（A）”，选择后，其他设置如图： 
这里写图片描述

【10】点击“添加编辑”，转到如下界面： 
这里写图片描述

【11】在该函数中添加如下代码：（此时D盘应该有一张命名为“1.jpg”的图像） 
void CMFC_DEMODlg::OnBnClickedOpenImg() 
{ 
// TODO: 在此添加控件通知处理程序代码 
IplImage *image=NULL; //原始图像 
if(image) cvReleaseImage(&image); 
image = cvLoadImage(“D:\1.jpg”,1); //显示图片 
DrawPicToHDC(image, IDC_STATIC); 
} 
此时会报错，不用担心，因为还没有添加相应的头文件等。 
这里写图片描述

【12】在“头文件”和“源文件”中分别添加“CvvImage.h”和“CvvImage.cpp”,（添加过程：右击”头文件“->”添加“->”新建项”）添加后如图所示： 
这里写图片描述

【13】“CvvImage.h”源代码：

#include "opencv/cv.h"
#include "opencv/highgui.h"
#pragma once

#ifndef CVVIMAGE_CLASS_DEF

#define CVVIMAGE_CLASS_DEF

#include "opencv.hpp"

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 CImage;
namespace cv
{
    typedef CvvImage CImage;
}
#endif
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106

【14】“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();

        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) );
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259

【15】双击“OpenCV3_MFCDlg.h”: 
这里写图片描述

【16】在打开的“OpenCV3_MFCDlg.h”的最上面添加如下代码：

#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "CvvImage.h"
   
   
  • 1
  • 2
  • 3

   
   
  • 1
  • 2
  • 3

这里写图片描述

【17】在OpenCV3_MFCDlg.h文件中COpenCV3_MFCDlg类的声明中添加函数DrawPicToHDC()的声明 
void DrawPicToHDC(IplImage *img, UINT ID); 
这里写图片描述

[18]在OpenCV3_MFCDlg.cpp中添加

void COpenCV3_MFCDlg::DrawPicToHDC(IplImage *img, UINT ID)
{
    CDC *pDC = GetDlgItem(ID)->GetDC();
    HDC hDC= pDC->GetSafeHdc();
    CRect rect;
    GetDlgItem(ID)->GetClientRect(&rect);
    CvvImage cimg;
    cimg.CopyOf( img ); // 复制图片
    cimg.DrawToHDC( hDC, &rect ); // 将图片绘制到显示控件的指定区域内
    ReleaseDC( pDC );
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

这里写图片描述

【19】编译运行 
这里写图片描述

【20】点击“打开图像” 
这里写图片描述

顶
0
踩
chenyin8293
关注
【图像处理】windows 10 + vs2015+ opencv3.0.0 +附加模块opencv_contrib编译和配置
生活没有if-else
03-02 1万+
win 10 64位系统，使用vs2015，基于opencv3.0.0，集成附加模块opencv_contrib，并编译、配置，正常使用SIFT等功能。
OpenCV3.3.0+MFC利用PictureControl显示图片，并完成简单的图片操作
weixin_36193572的博客
06-21 3608
根据项目需求，需要在MFC中显示多种格式的图片(包括tif等)，并且需要对图像进行简单的操作，所以使用了OpenCV来进行这方面的功能的实现。在上一篇博客中，我们介绍了如何在windows下利用VS2013配置64位的Opencv3.3.0这里我们接着上一篇之后的配置结果继续。先给出我们想要完成的功能1、图片的读取和展示2、图片的反转3、图片的对比度和亮度的调整一、首先，是图片的读取和展示。在高版...
MFC+VS2013+OPENCV3.0打开摄像头，拍照并处理图片的简单程序
08-21
MFC+VS2013+OPENCV3.0打开摄像头拍照 工程压缩了大于60M不让传，我把主要的放了。.sln啥的去掉了。想要真个工程的留个言啥的吧。不过挺简单的，我都写出来，估计大家看看就懂了。--注意：适合初学者。
重新搭建opencv3.0和vs2010
Fighting_Li
02-21 2012
过了几个月，之前能用的opencv3.0不知道为什么不能用了，可能搞开发的时候顺便设置了什么东西吧。 因为opencv3.0的bin下只有vc11,vc12，与vs2012，vs2013对应，所以用cmake重新生成一个与vs2010对应的版本。 先下载cmake-3.5.0-rc3-win32-x86.msi，下载安装。 Where is the source code
VS2013 MFC + OpenCV3.0 打开图片
04-19 6519
本文仅涉及一些核心步骤，具体 OpenCV 的配置以及其他的细节问题，请参考 VS2010 / MFC + OpenCV 2.4.1打开图片。1. 新建 MFC 对话框项目基于对话框，不使用Unicode库，在静态库中使用MFC，完成2. 配置 OpenCV 3.略OpenCV 3. 的配置相较 OpenCV 2 在依赖项的添加上会简略很多。3. 添加和设置控件 （1）菜单，视图，工具箱，打开工具箱
MFC+OpenCV3.3.0+VS2013配置
weixin_36193572的博客
06-20 3802
参考博客https://blog.csdn.net/amusi1994/article/details/76768775?locationNum=10&amp;fps=1这篇博客里面有下载和编译Opencv的全部过程，但是他是用Win32控制台程序做的测试。我这里需要在MFC的项目里使用，所以在本文中，使用MFC进行测试，后续还会记录一些项目中用到的小技术点按照前文连接中的博客的说明，完成将“bi...
vs2013+opencv3.0播放图片例程
01-03
总的来说，"vs2013+opencv3.0播放图片例程"项目展示了如何集成OpenCV到MFC应用中，实现基本的图片播放功能。这个项目对于初学者来说，是一个很好的起点，帮助他们理解如何在VS2013中使用OpenCV进行图像处理和展示。...
Visual Studio 2013 + OpenCV3.0: 机械工程学院图像处理代码
"集美大学机械工程学院的郑东强教授分享了关于使用Visual Studio 2013和OpenCV 3.0进行图像处理的资料，包括OpenCV的中文教材、教程、参考手册和用户指南，以及OpenCV 3.0版本的信息。此外，还提到了不同版本的...
基于Dialog的MFC对话框上利用OpenCV 3.0显示图片
ymyqs的博客
07-09 4744
1. 操作准备 A.Win 7 x64 旗舰版 B.VS 2012 旗舰版 C.OpenCV 3.0.0 http://www.cnblogs.com/Romi/archive/2012/05/07/2487652.html http://blog.csdn.net/fangpian/article/details/6233310 注：   a.此处不累赘描述OpenCV 3.0在
VS2015+opencv3.0 MFC显示图片
newbie‘s 博客
11-10 8145
相关资料内容来自互联网，本人测试后总结而成 开发环境 系统：Window10 IDE： VS2015 opencv版本： v3.0 在opencv中，使用cv::imshow函数可以方便的显示图片，但是如果要在windows窗体中显示opencv中Mat格式的图片，就不是那么方便了，查阅相关网络资料，找到以下几种方法，经测试有效。 来源：https://www.zhihu.co
win7 笔记本内置摄像头开启+MFC+OPENCV+VS2010
04-25
入门USB摄像头通过opencv的方式打开，通过MFC显示
win7+vs2010+opencv3.0.0+安装
05-20
win7，vs2010下怎么配置opencv3.0库,并能正确输出图片实例。其中，也例出了一些在配置过程中出现的问题。
OpenCV和MFC的实例+界面程序+各种图像处理操作
06-18
OpenCV和MFC的实例功能如下： 有良好的mfc界面，可以打开图像、视频，并作简单的数字图象处理，视频目标检测、跟踪等等，包含大量的基础算法，基于opencv1.0和vc6.0（vs2008）都可以应用，不用安装，直接编译运行就可以，对于初学者熟悉opencv的常用函数很有帮助。 新手共享资源，多多交流。
mfc基于单文档打开bmp图片
12-03
通过资源管理器打开一张bmp图片，并实现图片按原始比例放大或缩小
OpenCV+MFC制作视频播放器
11-10
包括整个工程的源代码，在OpenCV2.4.3+VS2008平台编译通过。
OpenCV学习笔记之（二）：图像的基本操作（VS2010+OpenCV3.0）
fjqlldg的专栏
08-14 1499
本节对应OpenCV.2.Computer.Vision.Application.Programming.Cookbook -----第3章ProcessingImages with Classes 中的Using a Controller to communicate with processing modules的部分。   本节把书中的提要详细化，给自已备份的同时也希望给别人一点启发。
OpenCV学习笔记之一：OpenCV中显示图片（VS2010+OpenCV3.0版本）
fjqlldg的专栏
08-12 4662
在写的过程中，参考了网上许多网友的blog，在此谢过。如有雷同，不是巧合。 一、OpenCV3.0的配置（百度） 1、  opencv下载： 具体下载地址，http://opencv.org/，因为我的操作系统是win7，所以选择了基于windows的opencv最新版opencv3.0.0。   2、  opencv解压 opencv下载完成后是一个rar文件，直接解压到要放的文
***OpenCV3.0+Visiual Studio2012图像处理(一)***
weixin_44346508的博客
06-27 145
OpenCV3.0+Visiual Studio2012图像处理(一) 一．OpenCV3.0介绍与环境搭建 OpenCV3.0介绍：OpenCV是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。OpenCV用C++语言编写，它的主要接口也是C++语言，但是依
VS2010 + OPENCV3.0 +WIN7
billbliss的专栏
12-31 1784
VS2010 + OPENCV3.0 +WIN7
VS2010+OpenCV+MFC：图像与视频在Picture控件显示教程
本篇文章详细讲解了如何在Visual Studio 2010（VS2010）环境中结合OpenCV（计算机视觉库）和MFC（Microsoft Foundation Classes，微软基础类库）实现图像和视频的读取并在Picture控件中显示。以下步骤将帮助开发人员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值