www.pudn.com > Gesture[20040824].rar > GestureView.cpp

// GestureView.cpp : implementation of the CGestureView class 
// 
 
#include "stdafx.h" 
#include "Gesture.h" 
 
#include "GestureDoc.h" 
#include "GestureView.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
///////////////////////////////////////////////////////////////////////////// 
// CGestureView 
 
IMPLEMENT_DYNCREATE(CGestureView, CView) 
 
BEGIN_MESSAGE_MAP(CGestureView, CView) 
	//{{AFX_MSG_MAP(CGestureView) 
	ON_COMMAND(ID_SHOW_BKGVIDEO, OnShowBkgvideo) 
	ON_UPDATE_COMMAND_UI(ID_SHOW_BKGVIDEO, OnUpdateShowBkgvideo) 
	ON_COMMAND(ID_SHOW_HANDVIDEO, OnShowHandvideo) 
	ON_UPDATE_COMMAND_UI(ID_SHOW_HANDVIDEO, OnUpdateShowHandvideo) 
	ON_COMMAND(ID_MEDIA_NEXTFRAME, OnMediaNextframe) 
	ON_UPDATE_COMMAND_UI(ID_MEDIA_NEXTFRAME, OnUpdateMediaNextframe) 
	ON_COMMAND(ID_MEDIA_PAUSE, OnMediaPause) 
	ON_UPDATE_COMMAND_UI(ID_MEDIA_PAUSE, OnUpdateMediaPause) 
	ON_COMMAND(ID_MEDIA_PLAY, OnMediaPlay) 
	ON_UPDATE_COMMAND_UI(ID_MEDIA_PLAY, OnUpdateMediaPlay) 
	ON_COMMAND(ID_MEDIA_PREVFRAME, OnMediaPrevframe) 
	ON_UPDATE_COMMAND_UI(ID_MEDIA_PREVFRAME, OnUpdateMediaPrevframe) 
	ON_COMMAND(ID_MEDIA_STOP, OnMediaStop) 
	ON_UPDATE_COMMAND_UI(ID_MEDIA_STOP, OnUpdateMediaStop) 
	ON_COMMAND(ID_SHOW_THRESHOLDRESULT, OnShowThresholdresult) 
	ON_UPDATE_COMMAND_UI(ID_SHOW_THRESHOLDRESULT, OnUpdateShowThresholdresult) 
	ON_COMMAND(ID_SHOW_FEATURERESULT, OnShowFeatureresult) 
	ON_UPDATE_COMMAND_UI(ID_SHOW_FEATURERESULT, OnUpdateShowFeatureresult) 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CGestureView construction/destruction 
 
CGestureView::CGestureView() 
{ 
	m_ShowState = Empty; 
	m_AviState = Stopped; 
	m_bPlayingLoop = false; 
} 
 
CGestureView::~CGestureView() 
{ 
} 
 
BOOL CGestureView::PreCreateWindow(CREATESTRUCT& cs) 
{ 
	// TODO: Modify the Window class or styles here by modifying 
	//  the CREATESTRUCT cs 
 
	return CView::PreCreateWindow(cs); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CGestureView drawing 
 
void CGestureView::OnDraw(CDC* pDC) 
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
	if (pDoc->GetCBackground()->Gettestflag()){ 
		char temp[50]; 
		sprintf(temp,"从EM方法得到的mu是"); 
		pDC->TextOut(300,20,temp); 
		sprintf(temp,"               %f",pDoc->GetCBackground()->GetEMmu0()); 
		pDC->TextOut(300,50,temp); 
		sprintf(temp,"               %f",pDoc->GetCBackground()->GetEMmu1()); 
		pDC->TextOut(300,70,temp); 
		sprintf(temp,"               %f",pDoc->GetCBackground()->GetEMmu2()); 
		pDC->TextOut(300,90,temp); 
 
		/*sprintf(temp,"概率分布"); 
		pDC->TextOut(10,200,temp); 
		pDC->MoveTo(10,400); 
		for (int b=0;b<256;b++){ 
			pDC->LineTo(10+b,400-(pDoc->GetCBackground()->Getprobb(b))*100); 
		}*/ 
 
		CPen *pOldPen,cNewPen(PS_SOLID,1,0X02ff0000),cNewPen1(PS_SOLID,1,0x0200ff00),cNewPen2(PS_SOLID,1,0x020000ff); 
		sprintf(temp,"Gauss过程  运算后的密度  各象素值有多少点取"); 
		pDC->TextOut(300,200,temp); 
		pOldPen = pDC->SelectObject(&cNewPen); 
		pDC->MoveTo(200,400); 
		for (int a=0;a<256;a++){ 
			pDC->LineTo(200+a*2,400-(pDoc->GetCBackground()->Getgauss(a))*10000); 
		} 
		cNewPen.DeleteObject(); 
 
		pDC->SelectObject(&cNewPen1); 
		pDC->MoveTo(200,400); 
		for (int aa=0;aa<256;aa++){ 
			pDC->LineTo(200+aa*2,400-(pDoc->GetCBackground()->Getgauss2(aa))*10000); 
		} 
		cNewPen1.DeleteObject(); 
 
		pDC->SelectObject(&cNewPen2); 
		pDC->MoveTo(200,400); 
		for (int aaa=0;aaa<256;aaa++){ 
			pDC->LineTo(200+aaa*2,400-(pDoc->GetCBackground()->Getgeshu(aaa)/12000.0)*10000); 
		} 
		cNewPen2.DeleteObject(); 
		pDC->SelectObject(pOldPen); 
	} 
	if ( m_ShowState == Empty ) return; 
 
	CImage *image; 
	char AviInfo[50]; 
 
	if ( pDoc->GetCBackground()->GetBkgStatus() ) { 
		image = pDoc->GetCBackground()->GetBkgImage(); 
 		image->Show( pDC->m_hDC, m_BkgImageWin.left, m_BkgImageWin.top,  
                     image->Width(), image->Height(), 0 , 0 ); 
		pDC->TextOut(m_BkgImageWin.left, m_BkgImageWin.top-20, "Background Image"); 
	} 
 
	if (( pDoc->GetBkgAVI()->GetInitStatus() )&&(pDoc->Getshowflag())) { 
		image = pDoc->GetBkgAVI()->GetFramePointer(); 
		image->Show( pDC->m_hDC, m_BkgAviWin.left, m_BkgAviWin.top-22,  
                     image->Width(), image->Height(), 0 , 0 ); 
		sprintf(AviInfo, "Background Video Frame %d", pDoc->GetBkgAVI()->GetReaderPosition()+1); 
		pDC->TextOut(m_BkgAviWin.left, m_BkgAviWin.top-40, AviInfo); 
	} 
 
	if ( pDoc->GetHandAVI()->GetInitStatus() ) { 
		image = pDoc->GetHandAVI()->GetFramePointer(); 
		image->Show( pDC->m_hDC, m_HandAviWin.left, m_HandAviWin.top, 
                     image->Width(), image->Height(), 0 , 0 ); 
		sprintf(AviInfo, "Hand Video Frame %d", pDoc->GetHandAVI()->GetReaderPosition()+1); 
		pDC->TextOut(m_HandAviWin.left, m_HandAviWin.top-20, AviInfo); 
	} 
 
	if ( m_ShowState == ShowThreshImage ) { 
		image = pDoc->GetCGesture()->GetHnadBinImage(); 
		image->Show( pDC->m_hDC, m_ResultWin.left, m_ResultWin.top, 
                     image->Width(), image->Height(), 0 , 0 ); 
		sprintf(AviInfo, "Thresholoding Result Frame %d", pDoc->GetHandAVI()->GetReaderPosition()+1); 
		pDC->TextOut(m_ResultWin.left, m_ResultWin.top-20, AviInfo); 
	} 
 
	if ( m_ShowState == ShowFeatureImage ) { 
		image = pDoc->GetCGesture()->GetHnadBinImage(); 
		CImage FeatureImage; 
		FeatureImage.Create(image->Width(),image->Height(),8); 
		cvDrawContours(FeatureImage.GetImage(), pDoc->GetCGesture()->GetContours(), 255, 0, 0); 
		pDoc->GetCGesture()->DrawContourFeaturesToImage(FeatureImage.GetImage()); 
		pDoc->GetCGesture()->DrawStatisticFeaturesToImage(FeatureImage.GetImage()); 
		FeatureImage.Show( pDC->m_hDC, m_ResultWin.left, m_ResultWin.top, 
                           FeatureImage.Width(), FeatureImage.Height(), 0 , 0 ); 
		sprintf(AviInfo, "Feature Detection Result Frame %d", pDoc->GetHandAVI()->GetReaderPosition()+1); 
		pDC->TextOut(m_ResultWin.left, m_ResultWin.top-20, AviInfo); 
	} 
 
	if (pDoc->GetCBackground()->Getdisplayflag()){ 
		int h = GetDocument()->GetCBackground()->GetBkgAvi()->GetFramePointer()->Height(); 
		int w = GetDocument()->GetCBackground()->GetBkgAvi()->GetFramePointer()->Width(); 
 
		CImage *image1=pDoc->GetCBackground()->GetImageshow1(); 
		CImage *image2=pDoc->GetCBackground()->GetImageshow2(); 
		CImage *image3=pDoc->GetCBackground()->GetImageshow3(); 
		image1->Show(pDC->m_hDC,m_BkgImageWin.left,m_BkgAviWin.top-22,w,h,0,0);	 
		image2->Show(pDC->m_hDC,m_BkgAviWin.left,m_BkgImageWin.top+h-22,w,h,0,0); 
		image3->Show(pDC->m_hDC,m_BkgImageWin.left,m_BkgImageWin.top+h-22,w,h,0,0); 
		//pDoc->GetCBackground()->Setdisplayflag(); 
		//Invalidate(true); 
	} 
} 
 
void CGestureView::InitializeShowingWindows( CImage *image ) 
{ 
	const int offset_x = 20, offset_y = 40; 
	int w = image->Width(), h = image->Height(); 
 
	m_BkgAviWin.left   = offset_x; 
	m_BkgAviWin.top    = offset_y; 
	m_BkgAviWin.right  = m_BkgAviWin.left+w; 
	m_BkgAviWin.bottom = m_BkgAviWin.top+h; 
 
	m_HandAviWin.left   = offset_x; 
	m_HandAviWin.top    = m_BkgAviWin.bottom+offset_y; 
	m_HandAviWin.right  = m_HandAviWin.left+w; 
	m_HandAviWin.bottom = m_HandAviWin.top+h; 
 
	m_BkgImageWin.left   = m_BkgAviWin.right+offset_x; 
	m_BkgImageWin.top    = offset_y; 
	m_BkgImageWin.right  = m_BkgImageWin.left+w; 
	m_BkgImageWin.bottom = m_BkgImageWin.top+h; 
 
	m_ResultWin.left   = m_BkgAviWin.right+offset_x; 
	m_ResultWin.top    = m_BkgAviWin.bottom+offset_y; 
	m_ResultWin.right  = m_ResultWin.left+w; 
	m_ResultWin.bottom = m_ResultWin.top+h; 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CGestureView diagnostics 
 
#ifdef _DEBUG 
void CGestureView::AssertValid() const 
{ 
	CView::AssertValid(); 
} 
 
void CGestureView::Dump(CDumpContext& dc) const 
{ 
	CView::Dump(dc); 
} 
 
CGestureDoc* CGestureView::GetDocument() // non-debug version is inline 
{ 
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGestureDoc))); 
	return (CGestureDoc*)m_pDocument; 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CGestureView message handlers 
 
///////////////////////////////////////////////////////////////////////////// 
// Animation Control Functions 
 
 
void CGestureView::OnShowBkgvideo()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetBkgAVI(); 
 
	if ( avi->GetInitStatus() ) { 
		pDoc->SetCurrAvi(avi); 
		m_ShowState = ShowBkgAvi; 
		avi->FirstFrame(); 
		avi->GetFrameFromAvi(); 
		SetAviStatus( Stopped ); 
		Invalidate(true); 
	} 
} 
 
void CGestureView::OnUpdateShowBkgvideo(CCmdUI* pCmdUI)  
{ 
	pCmdUI->SetCheck( m_ShowState == ShowBkgAvi ); 
} 
 
void CGestureView::OnShowHandvideo()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetHandAVI(); 
 
	if ( avi->GetInitStatus() ) { 
		pDoc->SetCurrAvi(avi); 
		m_ShowState = ShowHandAvi; 
		avi->FirstFrame(); 
		avi->GetFrameFromAvi(); 
		SetAviStatus( Stopped ); 
		Invalidate(true); 
	} 
} 
 
void CGestureView::OnUpdateShowHandvideo(CCmdUI* pCmdUI)  
{ 
	pCmdUI->SetCheck( m_ShowState == ShowHandAvi ); 
} 
 
void CGestureView::OnShowThresholdresult()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetHandAVI(); 
	CBackground *bkg = pDoc->GetCBackground(); 
 
	if ( avi->GetInitStatus() && bkg->GetBkgStatus() ) { 
		pDoc->SetCurrAvi(avi); 
		m_ShowState = ShowThreshImage; 
		Invalidate(true); 
	} 
} 
 
void CGestureView::OnUpdateShowThresholdresult(CCmdUI* pCmdUI)  
{ 
	pCmdUI->SetCheck( m_ShowState == ShowThreshImage ); 
} 
 
void CGestureView::OnShowFeatureresult()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetHandAVI(); 
	CBackground *bkg = pDoc->GetCBackground(); 
 
	if ( avi->GetInitStatus() && bkg->GetBkgStatus() ) { 
		pDoc->SetCurrAvi(avi); 
		m_ShowState = ShowFeatureImage; 
		Invalidate(true); 
	} 
} 
 
void CGestureView::OnUpdateShowFeatureresult(CCmdUI* pCmdUI)  
{ 
	pCmdUI->SetCheck( m_ShowState == ShowFeatureImage ); 
} 
 
void CGestureView::OnMediaPlay()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetCurrAVI(); 
	CHandGesture *gesture = pDoc->GetCGesture(); 
 
	m_AviState = Playing; 
 
	MSG msg; 
	while ( m_AviState==Playing ) { 
		avi->NextFrame(); 
 
		avi->GetFrameFromAvi(); 
 
		switch ( m_ShowState ) { 
		case ShowThreshImage : 
			gesture->ExtractHandRegion(avi->GetFramePointer()->GetImage()); 
			break; 
		case ShowFeatureImage : 
			gesture->ExtractHandRegion(avi->GetFramePointer()->GetImage()); 
			gesture->ExtractStatisticFeatures(); 
			gesture->ExtractContourFeatures(); 
			break; 
		case ShowCompositedImage : 
			break; 
		default : 
			break; 
		} 
 
		Invalidate(false); 
 
		Sleep(40); 
 
		while (::PeekMessage(&msg,0,0,0,PM_REMOVE)) 
		{ 
			if (msg.message == WM_QUIT)	SetMediaStop(); 
			// Dispatch any messages as needed 
			if (!AfxGetApp()->PreTranslateMessage(&msg)) { 
				::TranslateMessage(&msg); 
				::DispatchMessage(&msg); 
			} 
			// Give the Idle system some time 
			AfxGetApp()->OnIdle(0); 
			AfxGetApp()->OnIdle(1); 
		} 
		if ( !m_bPlayingLoop && avi->IsLastFrame() ) 
			SetMediaStop(); 
	} 
 
	if (msg.message == WM_QUIT)	::PostQuitMessage(0); 
} 
 
void CGestureView::OnUpdateMediaPlay(CCmdUI* pCmdUI)  
{ 
	pCmdUI->Enable( CanPlay() ); 
} 
 
void CGestureView::OnMediaPause()  
{ 
	m_AviState = Paused; 
} 
 
void CGestureView::OnUpdateMediaPause(CCmdUI* pCmdUI)  
{ 
	pCmdUI->Enable( CanPause() ); 
} 
 
void CGestureView::OnMediaStop()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetCurrAVI(); 
 
	m_AviState = Stopped; 
 
	avi->SetReaderPosition(0); 
	avi->GetFrameFromAvi(); 
	Invalidate(true); 
} 
 
void CGestureView::OnUpdateMediaStop(CCmdUI* pCmdUI)  
{ 
	pCmdUI->Enable( CanStop() ); 
} 
 
void CGestureView::OnMediaNextframe()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetCurrAVI(); 
 
	avi->NextFrame(); 
	avi->GetFrameFromAvi(); 
	Invalidate(true); 
} 
 
void CGestureView::OnUpdateMediaNextframe(CCmdUI* pCmdUI)  
{ 
	pCmdUI->Enable( CanPlay() ); 
} 
 
void CGestureView::OnMediaPrevframe()  
{ 
	CGestureDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	CCamAvi *avi = pDoc->GetCurrAVI(); 
 
	avi->PrevFrame(); 
	avi->GetFrameFromAvi(); 
	Invalidate(true); 
} 
 
void CGestureView::OnUpdateMediaPrevframe(CCmdUI* pCmdUI)  
{ 
	pCmdUI->Enable( CanPlay() ); 
} 
 
void CGestureView::SetMediaPause()  
{ 
	if ( CanPause() ) m_AviState = Paused; 
} 
 
void CGestureView::SetMediaPlay()  
{ 
	if ( CanPlay() ) m_AviState = Playing; 
} 
 
void CGestureView::SetMediaStop()  
{ 
	if ( CanStop() ) m_AviState = Stopped; 
}