pcadoc.cpp

face recognition test source code

// pcadoc.cpp : implementation of the CPcaDoc class
//

#include "stdafx.h"
#include "pca.h"
#include "pcaview.h"

#include "utilcpp.h"

extern CPcaApp		*gApplication;

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CPcaDoc

IMPLEMENT_DYNCREATE(CPcaDoc, CDocument)

BEGIN_MESSAGE_MAP(CPcaDoc, CDocument)
	//{{AFX_MSG_MAP(CPcaDoc)
	ON_UPDATE_COMMAND_UI(ID_VIEW_EIGENFACES, OnUpdateViewEigenfaces)
	ON_COMMAND(ID_VIEW_EIGENFACES, OnViewEigenfaces)
	ON_UPDATE_COMMAND_UI(ID_VIEW_RECOGNIZEDFACES, OnUpdateViewRecognizedfaces)
	ON_COMMAND(ID_VIEW_RECOGNIZEDFACES, OnViewRecognizedfaces)
	ON_COMMAND(ID_VIEW_RECONSTRUCTEDFACES, OnViewReconstructedfaces)
	ON_UPDATE_COMMAND_UI(ID_VIEW_RECONSTRUCTEDFACES, OnUpdateViewReconstructedfaces)
	ON_COMMAND(ID_VIEW_TRAININGFACES, OnViewTrainingfaces)
	ON_UPDATE_COMMAND_UI(ID_VIEW_TRAININGFACES, OnUpdateViewTrainingfaces)
	ON_COMMAND(ID_VIEW_SAMMON, OnViewSammon)
	ON_UPDATE_COMMAND_UI(ID_VIEW_SAMMON, OnUpdateViewSammon)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPcaDoc construction/destruction

CPcaDoc::CPcaDoc()
	{
	bViewTraining		= FALSE;
	bViewEigen			= FALSE;
	bViewReconstruct	= FALSE;
	bViewRecognize		= FALSE;
	bViewSammon			= FALSE;

	pViewTraining		= NULL;
	pViewEigen			= NULL;
	pViewReconstruct	= NULL;
	pViewRecognize		= NULL;
	pViewSammon			= NULL;
   
   strcpy(filename, "");
	}

CPcaDoc::~CPcaDoc()
{
}

BOOL CPcaDoc::OnNewDocument()
	{
	if (!CDocument::OnNewDocument())
		return FALSE;

	return TRUE;
	}

void CPcaDoc::SetFileName(char *str)
	{
	strcpy(filename, str);
	}

/////////////////////////////////////////////////////////////////////////////
// CPcaDoc serialization

void CPcaDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}
}


/////////////////////////////////////////////////////////////////////////////
// CPcaDoc diagnostics

#ifdef _DEBUG
void CPcaDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CPcaDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CPcaDoc commands

void CPcaDoc::ProjectNew()
	{
	pAAM = new CAAM;
	
	if (strcmp(filename, "") == 0)
		{
		CFileDialog *pDialog = new CFileDialog(TRUE, "pca", NULL, 0, "PCA file (*.pca) | *.pca | All files (*.*) | *.* ||", NULL);
		if (pDialog->DoModal() != IDOK)
			return;												//No file chosen
		
		lstrcpy(filename, pDialog->m_ofn.lpstrFile);
		}
	
	pAAM->Load(filename);
	}

void CPcaDoc::OnViewTrainingfaces()
	{
	BOOL bView = DoesWndExist(pViewTraining);
	
	if (bView == FALSE)
		{
		bViewTraining = TRUE;
		pViewTraining = new CDrawFace;
		pViewTraining->SetFaceDB(pAAM->GetTrainingDB());
		pViewTraining->Create(NULL, "Training Faces", WS_VSCROLL | WS_OVERLAPPEDWINDOW);
   	pViewTraining->ShowWindow(SW_SHOW);
		}
	else
		{
		bViewTraining = FALSE;
		delete pViewTraining;
		pViewTraining = NULL;
		}
	}

void CPcaDoc::OnViewEigenfaces()
	{
	BOOL bView = DoesWndExist(pViewEigen);
	
	if (bView == FALSE)
		{
		pViewEigen = new CDrawFace;
		pViewEigen->SetFaceDB(pAAM->GetEigenDB());
		pViewEigen->Create(NULL, "Eigen Faces", WS_VSCROLL | WS_OVERLAPPEDWINDOW);
		pViewEigen->ShowWindow(SW_SHOW);
		}
	else
		{
		delete pViewEigen;
		pViewEigen = NULL;
		}
	}

void CPcaDoc::OnViewReconstructedfaces()
	{
	BOOL bView = DoesWndExist(pViewReconstruct);
	
	if (bView == FALSE)
		{
		bViewReconstruct = TRUE;
		pViewReconstruct = new CDrawReconstruction;
		pViewReconstruct->SetFaceDB(pAAM->GetReconstructionDB(), pAAM->GetReconstructedDB());
		pViewReconstruct->Create(NULL, "Reconstructed Faces", WS_HSCROLL | WS_VSCROLL | 
			WS_OVERLAPPEDWINDOW);
   	pViewReconstruct->ShowWindow(SW_SHOW);
		}
	else
		{
		bViewReconstruct = FALSE;
		delete pViewReconstruct;
		pViewReconstruct = NULL;
		}
	}

void CPcaDoc::OnViewRecognizedfaces()
	{
	BOOL bView = DoesWndExist(pViewRecognize);
	
	if (bView == FALSE)
		{
		bViewRecognize = TRUE;
		pViewRecognize = new CDrawReconstruction;
		pViewRecognize->SetFaceDB(pAAM->GetRecognitionDB(), pAAM->GetRecognizedDB());
		pViewRecognize->Create(NULL, "Recognized Faces", WS_HSCROLL | WS_VSCROLL | 
			WS_OVERLAPPEDWINDOW);
   	pViewRecognize->ShowWindow(SW_SHOW);
		}
	else
		{
		bViewRecognize = FALSE;
		delete pViewRecognize;
		pViewRecognize = NULL;
		}
	}

void CPcaDoc::OnUpdateViewTrainingfaces(CCmdUI* pCmdUI)
	{
	if (pAAM->IsCommand(CMD_TRAINING) == TRUE)
		{
		pCmdUI->Enable();
		if (DoesWndExist(pViewTraining) == TRUE)
			pCmdUI->SetCheck();
		else
			pCmdUI->SetCheck(0);
 		}
 	else
 		pCmdUI->Enable(FALSE);
	}

void CPcaDoc::OnUpdateViewEigenfaces(CCmdUI* pCmdUI)
	{
	if (pAAM->IsCommand(CMD_TRAINING) == TRUE || pAAM->IsCommand(CMD_LOAD_EIGEN) == TRUE)
		{
		pCmdUI->Enable();
		if (DoesWndExist(pViewEigen) == TRUE)
			pCmdUI->SetCheck();
		else
			pCmdUI->SetCheck(0);
		}
 	else
 		pCmdUI->Enable(FALSE);
	}

void CPcaDoc::OnUpdateViewReconstructedfaces(CCmdUI* pCmdUI)
	{
	if (pAAM->IsCommand(CMD_RECONSTRUCTION) == TRUE)
		{
		pCmdUI->Enable();
		if (DoesWndExist(pViewReconstruct) == TRUE)
			pCmdUI->SetCheck();
		else
			pCmdUI->SetCheck(0);
		}
 	else
 		pCmdUI->Enable(FALSE);
	}

void CPcaDoc::OnUpdateViewRecognizedfaces(CCmdUI* pCmdUI)
	{
	if (pAAM->IsCommand(CMD_RECOGNIZE) == TRUE)
		{
		pCmdUI->Enable();
		if (DoesWndExist(pViewRecognize) == TRUE)
			pCmdUI->SetCheck();
		else
			pCmdUI->SetCheck(0);
      }
 	else
 		pCmdUI->Enable(FALSE);
	}

void CPcaDoc::SetMsg(char *msg)
	{          
	POSITION pos = GetFirstViewPosition();
	CPcaView *view = (CPcaView*)GetNextView(pos);
	view->AppendMsg(msg);
	
	GiveProcess();												/*Give the control to windows, so the application*/
																	/*has a chance to process the WM_PAINT message*/
	}

int CPcaDoc::SaveReport(char *filename)
	{
	POSITION pos = GetFirstViewPosition();
	CPcaView *view = (CPcaView*)GetNextView(pos);
	view->Save(filename);
	return 0;
	}

BOOL DoesWndExist(CWnd *pWnd)
	{	
	if (pWnd != NULL && pWnd->GetSafeHwnd() && IsWindow((HWND)(pWnd->GetSafeHwnd())))
		return TRUE;
	else
		return FALSE;
	}

void CPcaDoc::OnViewSammon()
	{
	BOOL bView = DoesWndExist(pViewReconstruct);
	
	if (bView == FALSE && pAAM->pSammon != NULL)
		{
		bViewSammon = TRUE;
		pViewSammon = new CViewSammon(pAAM->pSammon);
		pViewSammon->Create(NULL, "Sammon View", WS_OVERLAPPEDWINDOW);
   	pViewSammon->ShowWindow(SW_SHOW);
   	pViewSammon->Play();
		}
	else
		{
		bViewSammon = FALSE;
		delete pViewSammon;
		pViewSammon = NULL;
		}
	}

void CPcaDoc::OnUpdateViewSammon(CCmdUI* pCmdUI)
	{
	if (pAAM->pSammon != NULL)
		pCmdUI->Enable();
   else
		pCmdUI->Enable(FALSE);
	}