Display webcam input in window

edit

With Win32 GUI (and MFC) you can use one of below:

1. to draw the cv::Mat into dc memory context of a static control: see here
2. or to map a cv::window as child of some static control: see cvWin2MfcControl below for a complete example

In both cases you have to define a static control that will holds the image from opencv.

Some note about thread control:

• May be your code is incomplete but the grabbing thread will be never stopped because stop (pointer to StopGrab) variable is never set to true.

• Doing StopGrab=true in StopThread you will have a race condition because 2 threads can access to StopGrab. In general, to stop a thread you should use an event or a control var under a mutex or a critical section to protect the var from a shared access. In this case you can use atomic<bool> that is lock free and faster than mutex or critical section.

For you and other user, here is correct code using 2nd method and atomic<bool>.

EDIT: because atomic<bool> is C++11 and isn't available in VS2008, a very simple class that defines a protected shared variable has been provided

#include <opencv2/opencv.hpp>
#if __cplusplus >= 199711L //is C++11 available ?
    // Use std::atomic<bool> because is lock free
    #include <atomic>
    std::atomic<bool>StopGrab; //needed to protect the grab loop on/off flag
#else 
    // With old C++ compiler we create a very simple class to define
    // a protected shared variable using CriticalSection
    template<class T>  class AtomicSimple
    {
    public:
        AtomicSimple(){
            InitializeCriticalSection(&CriticalSection);
        };
        AtomicSimple(T newVal) {
            InitializeCriticalSection(&CriticalSection); 
            store(newVal);
        }
        ~AtomicSimple(){
            DeleteCriticalSection(&CriticalSection);
        };
        T load()
        {
            T curVal;
            EnterCriticalSection(&CriticalSection);
            curVal = val;
            LeaveCriticalSection(&CriticalSection);
            return curVal;
        }
        void store(T newVal)
        {
            EnterCriticalSection(&CriticalSection);
            val = newVal;
            LeaveCriticalSection(&CriticalSection);
            }
    private:
        T val;
        CRITICAL_SECTION CriticalSection;
    };
    AtomicSimple<bool>StopGrab; //needed to protect the grab loop on/off flag
#endif
HANDLE HStopThread, HStopEvent, HThread;
HINSTANCE hInst;
HWND SmplHwnd, GrabHwnd;
HWND HStop, HGrab, HQuit;
const char * WIN_NAME_CV = "OCV Image Display";

LRESULT CALLBACK SmplProc(HWND hWnd, UINT iMessage, UINT wParam, LONG lParam);
int OnGrabClick(void);  

/** ------------------------------------------------------------------------------------------
    \brief Map an OpenCV window over a MFC/Win32 control
    \param parentWnd the handle of MFC/Win32 static control
*/
bool cvWin2MfcControl(HWND parentWnd)
{
    cv::namedWindow(WIN_NAME_CV, CV_WINDOW_KEEPRATIO);  // create an OpenCV win
    HWND cvWnd = (HWND)cvGetWindowHandle(WIN_NAME_CV);  // get the handle of OpenCV Window
    if (!cvWnd) return false;

    HWND hOldParent = ::GetParent(cvWnd);
    ::SetParent(cvWnd, parentWnd);     // move the OpenCV window to the new parent (your static control)
    ::ShowWindow(hOldParent, SW_HIDE); // hide the old parent window

    // Resize the OpenCV window to fit your static control
    RECT parentRect;
    ::GetClientRect(parentWnd, &parentRect);
    cvResizeWindow(WIN_NAME_CV, parentRect.right, parentRect.bottom);
    return true;
}
//------------------------------------------------------------------------------------------
DWORD GrabThread(LPDWORD lpdwParam)
{
    cv::VideoCapture captures;
    captures.open(0);
    if (!captures.isOpened())
            return -1;
    cv::Mat frame;
    EnableWindow(HStop, TRUE);
    EnableWindow(HGrab, FALSE);
    EnableWindow(HQuit, FALSE);
    while (!StopGrab.load())
    {
        captures >> frame;
        cv::imshow(WIN_NAME_CV, frame); //display video here
        //cvWaitKey(1); not needed 
    }
    EnableWindow(HStop, FALSE);
    EnableWindow(HGrab, TRUE);
    EnableWindow(HQuit, TRUE);
    return 0;
}
//------------------------------------------------------------------------------------------
DWORD StopThread(LPDWORD lpdwParam)
{
    DWORD dwResult;
    HANDLE ...