[OpenCV] MFC-OpenCV 연동하기

개발환경

• Visual Studio V11 (2012)

• OpenCV V2.4.8

Step-by-Step 튜토리얼

[1.  프로젝트 생성하기]

다음과 같이 MFC 프로젝트를 생성합니다.

Template	Templates > MFC Application
Name	CapCaptureDemo
Application Type	Single Document
Project Style	MFC Standard

---

[2.  리소스 편집하기]

Resource View의 Menu > IDR_MAINFRAME을 더블클릭하여 메인 프레임 메뉴를 열고, 다음과 같이 메뉴를 추가합니다.

영상처리 > 카메라 뷰

카메라 뷰 메뉴의 ID는 ID_CAM_VIEW입니다.

---

[3.  Dialog 생성하기]

Resource View > Dialog를 오른쪽 마우스 클릭하고 Insert Dialog를 선택하여 Dialog를 생성합니다.

생성한 Dialog의 ID를 IDD_CAM_DIALOG로 합니다.

아래의 그림과 같이 Control을 배치하고 Caption 및 ID를 설정합니다.

---

[4.  Dialog에 대한 Class 추가하기]

3번에서 추가한 Dialog를 추가하기 위해 아래 그림과 같이 Project Name을 오른쪽 마우스 클릭하고 Class Wizard를 선택합니다(또는 Ctrl + Shift + X를 누릅니다).

Class Wizard가 열리면 Class Name에 CCameraDlg를 선택하면 자동으로 Bass Class가 CDialog로, Resource가 IDD_CAM_DIALOG가 선택된다. OK를 눌러 Class 추가를 완료합니다.

---

[5.  CCameraDlg Class에 멤버 추가하기]

Dialog Resource View에서 Picture Control 선택 후 오른쪽 마우스를 클릭하고 Add Variable을 선택합니다.

"CCameraDlg.h" 헤더 파일에 다음과 같이 멤버 추가에 대한 코드가 추가됩니다:

#pragma once
#include "afxwin.h"
 
 
// CCameraDlg dialog
 
class CCameraDlg : public CDialog
{
    DECLARE_DYNAMIC(CCameraDlg)
 
public:
    CCameraDlg(CWnd* pParent = NULL);   // standard constructor
    virtual ~CCameraDlg();
 
// Dialog Data
    enum { IDD = IDD_CAM_DIALOG };
 
protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
 
    DECLARE_MESSAGE_MAP()
public:
    CStatic m_ctrlPic;
};

---

[6.  OpenCV 환경설정 하기]

VC++ 프로젝트에 대한 OpenCV 환경설정은 이미 다른 글을 통해 다룬 바 있습니다. OpenCV 환경설정에 대해서는 Visual Studio에서 OpenCV 개발환경 구축하기를 참고하기 바랍니다.

---

[7.  카메라 뷰 메뉴에 대한 Event Handler 등록하기]

2번에서 편집한 메뉴 리소스에 대한 Event Handler를 등록하는 것이다. Resource View에서 Menu > IDR_MAINFRAME을 더블클릭하여 나온 메뉴 리소스에서 영상처리 > 카메라 뷰 메뉴를 선택한 후 오른쪽 마우스 클릭하여 Add Event Handler...를 선택합니다.

창이 열리면 Message type:은 COMMAND로, Class list:은 CMainFrame을 선택합니다.

이것은 메뉴와 관련있는 CMainFrame Class에 Event Handler를 등록하겠다는 뜻입니다. 올바로 등록이 되면 "MainFrm.h" 헤더 파일에 다음과 같이 멤버 함수가 등록됩니다:

// MainFrm.h : interface of the CMainFrame class
//
 
#pragma once
 
class CMainFrame : public CFrameWnd
{
    
protected: // create from serialization only
    CMainFrame();
    DECLARE_DYNCREATE(CMainFrame)
 
// Attributes
public:
 
// Operations
public:
 
// Overrides
public:
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
 
// Implementation
public:
    virtual ~CMainFrame();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
 
protected:  // control bar embedded members
    CToolBar          m_wndToolBar;
    CStatusBar        m_wndStatusBar;
 
// Generated message map functions
protected:
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    DECLARE_MESSAGE_MAP()
 
public:
    afx_msg void OnCamView();
};

---

[8.  추가한 Event Handler에 대한 멤버 함수 구현하기]

7번에서 추가한 OnCamView() 멤버 함수에 대한 내용을 "MainFrm.cpp" 소스 파일에 구현합니다. 우선 "CCameraDlg.h" 헤더 파일을 인클루드합니다:

// MainFrm.cpp : implementation of the CMainFrame class
//
 
#include "stdafx.h"
#include "CapCaptureDemo2.h"
 
#include "MainFrm.h"
#include "CameraDlg.h"
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

다음은 OnCamView() 함수에 대한 구현입니다:

void CMainFrame::OnCamView()
{
    // TODO: Add your command handler code here
    CCameraDlg Dlg;
    Dlg.DoModal();
}

여기까지 코드를 작성하고 실행해 봅니다. 실행된 초기 윈도우 화면은 다음 그림과 같습니다.

메뉴의 영상처리 > 카메라 뷰를 클릭하면 다음 그림과 같이 Dialog가 열립니다.

---

[9.  CvvImage Class 추가하기]

카메라로부터 얻어 온 영상 이미지를 MFC Dialog에 뿌리기 위해서는 CvvImage Class가 필요합니다.

CvvImage.cpp

CvvImage.h

우선 위의 첨부된 소스 및 헤더 파일을 다운받고, 프로젝트 폴더로 이동시킨 후, Solution Explorer에서 소스 파일과 헤더 파일을 각각 추가합니다. 위의 파일을 추가하면 Class View에서 CvvImage Class가 등록되어 있는 것을 확인할 수 있습니다.

---

[10.  CCameraDlg.h에 헤더 인클루드 하기]

"CCameraDlg.h" 헤더 파일에 다음 OpenCV 관련 헤더를 인클루드 합니다:

#include "opencv\cv.h"
#include "opencv\highgui.h"
#include "CvvImage.h"

---

[11.  CCameraDlg Class에 OpenCV 관련 멤버 추가하기]

CCmaeraDlg Class, 즉 "CCameraDlg.h" 헤더 파일에 다음과 같이 OpenCV 관련 멤버들을 추가합니다:

public:
    CStatic m_ctrlPic;
    IplImage* m_Image;
    CvvImage m_cImage;
    CvCapture* m_capture;

---

[12.  CCameraDlg Class에 멤버 함수 코드 작성하기]

Class View에서 CCameraDlg를 선택한 상태에서 Properties의 Overrides(함수 재정의)에서 OnInitDialog() 함수를 추가하여 함수를 재정의합니다.

 

"CameraDlg.cpp" 소스 파일에 다음과 같이 OnInitDialog() 함수를 작성합니다:

BOOL CCameraDlg::OnInitDialog()
{
    CDialog::OnInitDialog();

    // TODO:  여기에 추가 초기화 작업을 추가합니다.
    m_capture = cvCreateCameraCapture(0);
    if(!m_capture)
        AfxMessageBox(_T("해당하는 캠 장치가 없습니다."));

    return TRUE;  // return TRUE unless you set the focus to a control
    // 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}

Resource View > Dialog > IDD_CAM_DIALOG를 더블클릭하여 Dialog를 열고 "카메라 시작" 버튼을 더블 클릭하여 OnBlickedCamStart() 멤버 함수를 작성합니다:

void CCameraDlg::OnBnClickedCamStart()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
    SetTimer(1, 30, NULL); // WM_TIMER 메시지 발생
}

 

본 튜토리얼은 MFC-OpenCV 간 연동방법에 대해서만 집중할 것이기 때문에, 각 작성되는 함수들의 자세한 내용에 대해서는 설명을 생략합니다. 자세한 내용은 OpenCV 도큐먼트나 MSDN을 참고하기 바랍니다.

Class View에서 CCameraDlg Class를 선택한 상태에서 Properties의 Message에서 WM_TIMER를 선택합니다.

이에 대한 메시지 처리 함수인 OnTimer() 함수를 작성합니다:

void CCameraDlg::OnTimer(UINT_PTR nIDEvent)
{
    // TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
    m_Image = cvQueryFrame(m_capture);
    Invalidate(FALSE);

    CDialog::OnTimer(nIDEvent);
}




위의 함수는 WM_TIMER 메시지 발생 시 호출됩니다.

Class View에서 CCameraDlg Class를 선택한 상태에서 Properties의 Message에서 WM_PAINT를 선택합니다.

이에 대한 메시지 처리 함수인 OnPaint() 함수를 작성합니다:

void CCameraDlg::OnPaint()
{
    CPaintDC dc(this); // device context for painting
    // TODO: 여기에 메시지 처리기 코드를 추가합니다.
    // 그리기 메시지에 대해서는 CDialog::OnPaint()을(를) 호출하지 마십시오.
    CDC *pDC;
    CRect rect;

    pDC = m_ctrlPic.GetDC();
    m_ctrlPic.GetClientRect(rect);

    m_cImage.CopyOf(m_Image);
    m_cImage.DrawToHDC(pDC->m_hDC, rect);

    ReleaseDC(pDC);
}

이 함수는 MFC-OpenCV 연동에 있어 가장 핵심적인 함수입니다. 자세한 설명은 생략하겠지만 위 코드의 내용은 대략 Dialog의 Picture Control에 대한 클라이언트 영역을 얻어와서 이 영역에 OpeCV의 카메라 프레임 캡춰로 얻어 온 이미지를 m_hDC라는 Device Context로 뿌린 후, DC에 대한 메모리 반납을 하는 것입니다.

Class View에서 CCameraDlg Class를 선택한 상태에서 Properties의 Message에서 WM_DESTROY를 선택합니다.

이에 대한 메시지 처리 함수인 OnDestroy() 함수를 작성합니다:

void CCameraDlg::OnDestroy()
{
    CDialog::OnDestroy();

    // TODO: 여기에 메시지 처리기 코드를 추가합니다.
    KillTimer(1);

    if(m_capture)
        cvReleaseCapture(&m_capture);
}

Resource View > Dialog > IDD_CAM_DIALOG를 더블클릭하여 Dialog를 열고 "카메라 중지" 버튼을 더블 클릭하여 OnBlickedCamStop() 멤버 함수를 작성한다:

void CCameraDlg::OnBnClickedCamStop()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
    OnCancel();
}

만약 위의 버튼이  Cancel 버튼을 편집한 것이라면 굳이 위의 코드를 작성할 필요는 없습니다.

---

[13.  빌드 및 실행]

Ctrl + Shift + B를 눌러 빌드를 한 후, Ctrl + F5를 눌러 실행파일을 실행합니다. 다음 그림과 같이 실행되면 메뉴 > 영상처리 > 카메라 뷰를 클릭합니다.

다음 그림과 같이 Dialog 상자가 열리고 "카메라 시작" 버튼을 클릭하면 카메라 캡춰가 시작됩니다.

"카메라 중지" 버튼을 클릭하면 열려 있는 Dialog 상자가 닫힙니다.

카메라 프레임 이미지뿐만 아니라 OpenCV로부터 처리되는 이미지도 유사한 방식으로 MFC와 연동이 가능하므로 위의 내용을 이해하면 다양한 응용이 가능합니다.

---

[14.  Source Code]

"MainFrm.h"

// MainFrm.h : CMainFrame 클래스의 인터페이스
//
 
#pragma once
 
class CMainFrame : public CFrameWndEx
{
     
protected: // serialization에서만 만들어집니다.
    CMainFrame();
    DECLARE_DYNCREATE(CMainFrame)
 
// 특성입니다.
public:
 
// 작업입니다.
public:
 
// 재정의입니다.
public:
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    virtual BOOL LoadFrame(UINT nIDResource, DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, CWnd* pParentWnd = NULL, CCreateContext* pContext = NULL);
 
// 구현입니다.
public:
    virtual ~CMainFrame();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
 
protected:  // 컨트롤 모음이 포함된 멤버입니다.
    CMFCMenuBar       m_wndMenuBar;
    CMFCToolBar       m_wndToolBar;
    CMFCStatusBar     m_wndStatusBar;
    CMFCToolBarImages m_UserImages;
 
// 생성된 메시지 맵 함수
protected:
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    afx_msg void OnViewCustomize();
    afx_msg LRESULT OnToolbarCreateNew(WPARAM wp, LPARAM lp);
    afx_msg void OnApplicationLook(UINT id);
    afx_msg void OnUpdateApplicationLook(CCmdUI* pCmdUI);
    DECLARE_MESSAGE_MAP()
 
public:
    afx_msg void OnCamView();
};
 
 
"MainFrm.cpp"
 
 
// MainFrm.cpp : CMainFrame 클래스의 구현
//
 
#include "stdafx.h"
#include "CamCaptureDemo.h"
 
#include "MainFrm.h"
#include "CameraDlg.h"
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 
// CMainFrame
 
IMPLEMENT_DYNCREATE(CMainFrame, CFrameWndEx)
 
const int  iMaxUserToolbars = 10;
const UINT uiFirstUserToolBarId = AFX_IDW_CONTROLBAR_FIRST + 40;
const UINT uiLastUserToolBarId = uiFirstUserToolBarId + iMaxUserToolbars - 1;
 
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWndEx)
    ON_WM_CREATE()
    ON_COMMAND(ID_VIEW_CUSTOMIZE, &CMainFrame::OnViewCustomize)
    ON_REGISTERED_MESSAGE(AFX_WM_CREATETOOLBAR, &CMainFrame::OnToolbarCreateNew)
    ON_COMMAND_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_OFF_2007_AQUA, &CMainFrame::OnApplicationLook)
    ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_OFF_2007_AQUA, &CMainFrame::OnUpdateApplicationLook)
    ON_COMMAND(ID_CAM_VIEW, &CMainFrame::OnCamView)
END_MESSAGE_MAP()
 
static UINT indicators[] =
{
    ID_SEPARATOR,           // 상태 줄 표시기
    ID_INDICATOR_CAPS,
    ID_INDICATOR_NUM,
    ID_INDICATOR_SCRL,
};
 
// CMainFrame 생성/소멸
 
CMainFrame::CMainFrame()
{
    // TODO: 여기에 멤버 초기화 코드를 추가합니다.
    theApp.m_nAppLook = theApp.GetInt(_T("ApplicationLook"), ID_VIEW_APPLOOK_VS_2005);
}
 
CMainFrame::~CMainFrame()
{
}
 
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CFrameWndEx::OnCreate(lpCreateStruct) == -1)
        return -1;
 
    BOOL bNameValid;
    // 보관된 값에 따라 비주얼 관리자 및 스타일을 설정합니다.
    OnApplicationLook(theApp.m_nAppLook);
 
    if (!m_wndMenuBar.Create(this))
    {
        TRACE0("메뉴 모음을 만들지 못했습니다.\n");
        return -1;      // 만들지 못했습니다.
    }
 
    m_wndMenuBar.SetPaneStyle(m_wndMenuBar.GetPaneStyle() | CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY);
 
    // 메뉴 모음을 활성화해도 포커스가 이동하지 않게 합니다.
    CMFCPopupMenu::SetForceMenuFocus(FALSE);
 
    if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
        !m_wndToolBar.LoadToolBar(theApp.m_bHiColorIcons ? IDR_MAINFRAME_256 : IDR_MAINFRAME))
    {
        TRACE0("도구 모음을 만들지 못했습니다.\n");
        return -1;      // 만들지 못했습니다.
    }
 
    CString strToolBarName;
    bNameValid = strToolBarName.LoadString(IDS_TOOLBAR_STANDARD);
    ASSERT(bNameValid);
    m_wndToolBar.SetWindowText(strToolBarName);
 
    CString strCustomize;
    bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
    ASSERT(bNameValid);
    m_wndToolBar.EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
 
    // 사용자 정의 도구 모음 작업을 허용합니다.
    InitUserToolbars(NULL, uiFirstUserToolBarId, uiLastUserToolBarId);
 
    if (!m_wndStatusBar.Create(this))
    {
        TRACE0("상태 표시줄을 만들지 못했습니다.\n");
        return -1;      // 만들지 못했습니다.
    }
    m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
 
    // TODO: 도구 모음 및 메뉴 모음을 도킹할 수 없게 하려면 이 다섯 줄을 삭제하십시오.
    m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);
    m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
    EnableDocking(CBRS_ALIGN_ANY);
    DockPane(&m_wndMenuBar);
    DockPane(&m_wndToolBar);
 
 
    // Visual Studio 2005 스타일 도킹 창 동작을 활성화합니다.
    CDockingManager::SetDockingMode(DT_SMART);
    // Visual Studio 2005 스타일 도킹 창 자동 숨김 동작을 활성화합니다.
    EnableAutoHidePanes(CBRS_ALIGN_ANY);
 
    // 도구 모음 및 도킹 창 메뉴 바꾸기를 활성화합니다.
    EnablePaneMenu(TRUE, ID_VIEW_CUSTOMIZE, strCustomize, ID_VIEW_TOOLBAR);
 
    // 빠른(<Alt> 키를 누른 채 끌기) 도구 모음 사용자 지정을 활성화합니다.
    CMFCToolBar::EnableQuickCustomization();
 
    if (CMFCToolBar::GetUserImages() == NULL)
    {
        // 사용자 정의 도구 모음 이미지를 로드합니다.
        if (m_UserImages.Load(_T(".\\UserImages.bmp")))
        {
            m_UserImages.SetImageSize(CSize(16, 16), FALSE);
            CMFCToolBar::SetUserImages(&m_UserImages);
        }
    }
 
    // 메뉴 개인 설정을 활성화합니다(가장 최근에 사용한 명령).
    // TODO: 사용자의 기본 명령을 정의하여 각 풀다운 메뉴에 하나 이상의 기본 명령을 포함시킵니다.
    CList<UINT, UINT> lstBasicCommands;
 
    lstBasicCommands.AddTail(ID_FILE_NEW);
    lstBasicCommands.AddTail(ID_FILE_OPEN);
    lstBasicCommands.AddTail(ID_FILE_SAVE);
    lstBasicCommands.AddTail(ID_FILE_PRINT);
    lstBasicCommands.AddTail(ID_APP_EXIT);
    lstBasicCommands.AddTail(ID_EDIT_CUT);
    lstBasicCommands.AddTail(ID_EDIT_PASTE);
    lstBasicCommands.AddTail(ID_EDIT_UNDO);
    lstBasicCommands.AddTail(ID_APP_ABOUT);
    lstBasicCommands.AddTail(ID_VIEW_STATUS_BAR);
    lstBasicCommands.AddTail(ID_VIEW_TOOLBAR);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2003);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_VS_2005);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLUE);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_SILVER);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLACK);
    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_AQUA);
 
    CMFCToolBar::SetBasicCommands(lstBasicCommands);
 
    return 0;
}
 
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
    if( !CFrameWndEx::PreCreateWindow(cs) )
        return FALSE;
    // TODO: CREATESTRUCT cs를 수정하여 여기에서
    //  Window 클래스 또는 스타일을 수정합니다.
 
    return TRUE;
}
 
// CMainFrame 진단
 
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
    CFrameWndEx::AssertValid();
}
 
void CMainFrame::Dump(CDumpContext& dc) const
{
    CFrameWndEx::Dump(dc);
}
#endif //_DEBUG
 
 
// CMainFrame 메시지 처리기
 
void CMainFrame::OnViewCustomize()
{
    CMFCToolBarsCustomizeDialog* pDlgCust = new CMFCToolBarsCustomizeDialog(this, TRUE /* 메뉴를 검색합니다. */);
    pDlgCust->EnableUserDefinedToolbars();
    pDlgCust->Create();
}
 
LRESULT CMainFrame::OnToolbarCreateNew(WPARAM wp,LPARAM lp)
{
    LRESULT lres = CFrameWndEx::OnToolbarCreateNew(wp,lp);
    if (lres == 0)
    {
        return 0;
    }
 
    CMFCToolBar* pUserToolbar = (CMFCToolBar*)lres;
    ASSERT_VALID(pUserToolbar);
 
    BOOL bNameValid;
    CString strCustomize;
    bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
    ASSERT(bNameValid);
 
    pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
    return lres;
}
 
void CMainFrame::OnApplicationLook(UINT id)
{
    CWaitCursor wait;
 
    theApp.m_nAppLook = id;
 
    switch (theApp.m_nAppLook)
    {
    case ID_VIEW_APPLOOK_WIN_2000:
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManager));
        break;
 
    case ID_VIEW_APPLOOK_OFF_XP:
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOfficeXP));
        break;
 
    case ID_VIEW_APPLOOK_WIN_XP:
        CMFCVisualManagerWindows::m_b3DTabsXPTheme = TRUE;
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
        break;
 
    case ID_VIEW_APPLOOK_OFF_2003:
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2003));
        CDockingManager::SetDockingMode(DT_SMART);
        break;
 
    case ID_VIEW_APPLOOK_VS_2005:
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2005));
        CDockingManager::SetDockingMode(DT_SMART);
        break;
 
    default:
        switch (theApp.m_nAppLook)
        {
        case ID_VIEW_APPLOOK_OFF_2007_BLUE:
            CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_LunaBlue);
            break;
 
        case ID_VIEW_APPLOOK_OFF_2007_BLACK:
            CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_ObsidianBlack);
            break;
 
        case ID_VIEW_APPLOOK_OFF_2007_SILVER:
            CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Silver);
            break;
 
        case ID_VIEW_APPLOOK_OFF_2007_AQUA:
            CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Aqua);
            break;
        }
 
        CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2007));
        CDockingManager::SetDockingMode(DT_SMART);
    }
 
    RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ERASE);
 
    theApp.WriteInt(_T("ApplicationLook"), theApp.m_nAppLook);
}
 
void CMainFrame::OnUpdateApplicationLook(CCmdUI* pCmdUI)
{
    pCmdUI->SetRadio(theApp.m_nAppLook == pCmdUI->m_nID);
}
 
BOOL CMainFrame::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext) 
{
    // 기본 클래스가 실제 작업을 수행합니다.
 
    if (!CFrameWndEx::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext))
    {
        return FALSE;
    }
 
 
    // 모든 사용자 도구 모음에 사용자 지정 단추를 활성화합니다.
    BOOL bNameValid;
    CString strCustomize;
    bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
    ASSERT(bNameValid);
 
    for (int i = 0; i < iMaxUserToolbars; i ++)
    {
        CMFCToolBar* pUserToolbar = GetUserToolBarByIndex(i);
        if (pUserToolbar != NULL)
        {
            pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
        }
    }
 
    return TRUE;
}
 
 
void CMainFrame::OnCamView()
{
    // TODO: 여기에 명령 처리기 코드를 추가합니다.
    CCameraDlg Dlg;
    Dlg.DoModal();
}

"CvvImage.h"

#pragma once
#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF
 
#include "opencv2/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 CImage1;
#endif

"CvvImage.cpp"

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

"CameraDlg.cpp"

// CameraDlg.cpp : 구현 파일입니다.
//
 
#include "stdafx.h"
#include "CamCaptureDemo.h"
#include "CameraDlg.h"
 
// CCameraDlg 대화 상자입니다.
 
IMPLEMENT_DYNAMIC(CCameraDlg, CDialog)
 
CCameraDlg::CCameraDlg(CWnd* pParent /*=NULL*/)
    : CDialog(CCameraDlg::IDD, pParent)
    , m_Image(0)
    , m_capture(0)
{
 
}
 
CCameraDlg::~CCameraDlg()
{
}
 
void CCameraDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_CAM, m_ctrlPic);
}
 
 
BEGIN_MESSAGE_MAP(CCameraDlg, CDialog)
    ON_BN_CLICKED(IDC_CAM_START, &CCameraDlg::OnBnClickedCamStart)
    ON_WM_TIMER()
    ON_WM_PAINT()
    ON_WM_DESTROY()
    ON_BN_CLICKED(IDC_CAM_STOP, &CCameraDlg::OnBnClickedCamStop)
END_MESSAGE_MAP()
 
 
// CCameraDlg 메시지 처리기입니다.
 
BOOL CCameraDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
 
    // TODO:  여기에 추가 초기화 작업을 추가합니다.
    //m_capture = cvCaptureFromCAM(1);
    m_capture = cvCreateCameraCapture(0);
    if(!m_capture)
        AfxMessageBox(_T("해당하는 캠 장치가 없습니다."));
 
    return TRUE;  // return TRUE unless you set the focus to a control
    // 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}
 
void CCameraDlg::OnBnClickedCamStart()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
    SetTimer(1, 30, NULL);
}
 
void CCameraDlg::OnTimer(UINT_PTR nIDEvent)
{
    // TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
    m_Image = cvQueryFrame(m_capture);
    Invalidate(FALSE);
 
    CDialog::OnTimer(nIDEvent);
}
 
void CCameraDlg::OnPaint()
{
    CPaintDC dc(this); // device context for painting
    // TODO: 여기에 메시지 처리기 코드를 추가합니다.
    // 그리기 메시지에 대해서는 CDialog::OnPaint()을(를) 호출하지 마십시오.
    CDC *pDC;
    CRect rect;
 
    pDC = m_ctrlPic.GetDC();
    m_ctrlPic.GetClientRect(rect);
 
    m_cImage.CopyOf(m_Image);
    m_cImage.DrawToHDC(pDC->m_hDC, rect);
 
    ReleaseDC(pDC);
}
 
void CCameraDlg::OnDestroy()
{
    CDialog::OnDestroy();
 
    // TODO: 여기에 메시지 처리기 코드를 추가합니다.
    KillTimer(1);
 
    if(m_capture)
        cvReleaseCapture(&m_capture);
}
 
void CCameraDlg::OnBnClickedCamStop()
{
    // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
    OnCancel();
}