headtrackerdlg.cpp

人头跟踪算法

		{
			if (headtrackerDlg->m_input_mode == LIVE_VIDEO)  {
//				left = 0; top = 0;
				if (Digitizer_FillBuffer(0,&Image,&timestamp)) {
					Image.Display(my_hdc,LEFT_MARGIN,TOP_MARGIN);
				}
				if (headtrackerDlg->m_tracking)  {
					TrackAndDisplay();
				}
				if (recording_sequence)  {
					int filenum_rel = headtrackerDlg->m_filenum - headtrackerDlg->m_first_filenum;
					int *ptres = ellipse_states+filenum_rel*3;
					memcpy(recorded_images+(filenum_rel)*BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY,
						Image.GetImagePtr(), BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY);
//						sprintf(msg, "fn %3d state %3d %3d %3d       ", filenum_rel, curr_state.x, curr_state.y, curr_state.sz);
//						my_cdc->TextOut(5,220,msg);
					*ptres++ = curr_state.x;
					*ptres++ = curr_state.y;
					*ptres++ = curr_state.sz;
					sprintf(msg, "%4d", headtrackerDlg->m_filenum);
					headtrackerDlg->GetDlgItem(IDC_FRAME_NUMBER)->SetWindowText(msg);
					headtrackerDlg->m_filenum++;
//					sprintf(msg, "m_filenum %d < %d relative %d            ", m_filenum, headtrackerDlg->m_last_filenum,
//						m_filenum-headtrackerDlg->m_first_filenum);
//					my_cdc->TextOut(5,220,msg);
					if (headtrackerDlg->m_filenum > headtrackerDlg->m_last_filenum) {
//							Digitizer_Shutdown(0);
						int i, i_rel;
						recording_sequence = FALSE;
//						sprintf(msg, "                           ", m_filenum, headtrackerDlg->m_last_filenum);
//						my_cdc->TextOut(5,220,msg);
						sprintf(fname, fname_ellipse_states);
						FILE *fp = fopen(fname, "w");
						if (fp==NULL) {
							sprintf(msg, "Couldn't open file '%s' for writing!!", fname);
							AfxMessageBox(msg, MB_OK|MB_ICONSTOP, 0);
							Digitizer_Shutdown(0);
						}
						fprintf(fp, "frame x   y sz\n");
						for (i=headtrackerDlg->m_first_filenum ; i<=headtrackerDlg->m_last_filenum ; i++) {
							i_rel = i - headtrackerDlg->m_first_filenum;
							sprintf(fname, headtrackerDlg->m_basename, i_rel);
							if (BYTES_PER_PIXEL_IN_SEQUENCE==1) {
								memcpy(img_tmp8.GetImagePtr(), 
									recorded_images+i_rel*BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY, BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY);
								img_tmp8.Write8BitBMP(fname);
							} else if (BYTES_PER_PIXEL_IN_SEQUENCE==3) {
								memcpy(img_tmp24.GetImagePtr(), 
									recorded_images+i_rel*BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY, BYTES_PER_PIXEL_IN_SEQUENCE*ISIZEX*ISIZEY);
								img_tmp24.Write24BitBMP(fname);
							}
							fprintf(fp, "%3d %3d %3d %2d\n", i, 
								*(ellipse_states+3*i_rel), *(ellipse_states+3*i_rel+1), *(ellipse_states+3*i_rel+2));
						}
						fclose(fp);

//						fp=fopen("tmp.dat", "wb");
//						sprintf(msg, "file %d   ", fp);
//						my_cdc->TextOut(5,220,msg);
//						fwrite(ellipse_states, sizeof(int), 51, fp);
//						fclose(fp);
						free(recorded_images);
						free(ellipse_states);
						headtrackerDlg->m_use_camera = FALSE;
						StopCamera();
						((CButton *) headtrackerDlg->GetDlgItem(IDC_CAMERA_OFF))->SetCheck(1);
						((CComboBox *) headtrackerDlg->GetDlgItem(IDC_INPUT_MODE))->SetCurSel(IMAGE_SEQUENCE);
						headtrackerDlg->m_input_mode = IMAGE_SEQUENCE;
						headtrackerDlg->EnableDisableWindows();
						img_blankdot.Display(my_hdc,RECORDING_DOT_X, RECORDING_DOT_Y);
					}
				}
			}
		}
		else 
			;//?
	}
	
	return 0;
}

void StartVideoThread(void)
{
	static DWORD threadIdentifier;
	VideoThread = CreateThread( NULL,	// use default security
		 						0,		// use default stack size
						  		(LPTHREAD_START_ROUTINE) &VideoLoop,
						  		0,		// thread parameter value
						  		CREATE_SUSPENDED,
						  		&threadIdentifier );
	SetThreadPriority ( VideoThread, 
						THREAD_PRIORITY_TIME_CRITICAL );		
	ResumeThread ( VideoThread );
}

/////////////////////////////////////////////////////////////////////////////
// CHeadtrackerDlg message handlers

BOOL CHeadtrackerDlg::OnInitDialog()
{
	m_input_mode = LIVE_VIDEO;
//	m_input_mode = IMAGE_SEQUENCE;
	m_use_camera = FALSE;
//	m_basename = "../../seq1/img%03d.bmp";
	m_basename = "../../seq_stans_head/img%03d.bmp";
//	m_basename = "../../seq_ptz_complex2/img%03d.bmp";
//	m_basename = "../../seq_head1/img%03d.bmp";
//	m_basename = "../../seq_untex/untex_%04d.bmp";
//	m_basename = "../../seq_untexb_largehead/untexb_%04d.bmp";
	m_first_filenum = 0;
	m_last_filenum = 500;
	m_filenum = m_first_filenum;
	m_enable_recording = FALSE;
	m_tracking = FALSE;
//	m_tracking = TRUE;
	use_gradient = TRUE;
	use_color = TRUE;
	zoom_control = FALSE;
	adapt_histogram = FALSE;
	sum_gradient_magnitude = FALSE;
	show_details = FALSE;
	m_input_file_bw_instead_of_color = FALSE;
	display_speed = display_speeds[INITIAL_DISPLAY_SPEED];

	ReadModel(filename_model);
	CDialog::OnInitDialog();

	{
		CScrollBar *pSB = (CScrollBar *) GetDlgItem(IDC_SCROLLBAR_SPEED);
		pSB->SetScrollRange(0, N_DISPLAY_SPEEDS-1);
		pSB->SetScrollPos(INITIAL_DISPLAY_SPEED, TRUE);
	}

	((CButton *) GetDlgItem(IDC_USE_GRADIENT))->SetCheck(use_gradient);
	((CButton *) GetDlgItem(IDC_USE_COLOR))->SetCheck(use_color);
	((CButton *) GetDlgItem(IDC_ZOOM))->SetCheck(zoom_control);
	((CButton *) GetDlgItem(IDC_ADAPT_HISTOGRAM))->SetCheck(adapt_histogram);
	((CButton *) GetDlgItem(IDC_GRADIENT_MAG))->SetCheck(sum_gradient_magnitude);
	((CButton *) GetDlgItem(IDC_GRADIENT_DOT))->SetCheck(1-sum_gradient_magnitude);
	((CButton *) GetDlgItem(IDC_SHOW_DETAILS))->SetCheck(show_details);

	my_cdc = GetDC();
	my_hdc = GetDC()->m_hDC;

	EnableDisableWindows();
	headtrackerDlg = (CHeadtrackerDlg *) (AfxGetApp()->m_pMainWnd);
	TRACE("here %d\n", headtrackerDlg);

	///// ->
	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	CString strAboutMenu;
	strAboutMenu.LoadString(IDS_ABOUTBOX);
	if (!strAboutMenu.IsEmpty())
	{
		pSysMenu->AppendMenu(MF_SEPARATOR);
		pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	///// <-

	//	CMyCheckListBox mychecklist;
	// To change from SVIDEO to NTSC, manually edit the file C:\PROGRAM FILES\WINNOV VIDEUM\VIDEUM.INI: Change 2001 to 4001 for FmtFlagsLo
	// dparams.NTSC = TRUE;			// Note this is ignored in VFWs case
	// dparams.SVIDEO = 0;			// Note this is ignored in VFWs case	
	dparams.HALFRES = TRUE;
	dparams.sizex = ISIZEX;
	dparams.sizey = ISIZEY;
	dparams.EveryNthFrame = 1;
	dparams.TotalSize = ISIZEX*ISIZEY;
	dparams.ImageFormatDesired = APTOS_BGR24PACKED;// YUV_24;
	dparams.CaptureFormatDesired = APTOS_BGR24PACKED;
	dparams.app_win = this->m_hWnd;
	dparams.Device_Number = DIG_WINNOV; // 0 -> Buster, 1 - > Winnov

	imageready=CreateEvent(NULL,FALSE,FALSE,NULL);
	dparams.event = imageready;

	if (!OpenCamera(2)) {
		AfxMessageBox("Failed to Open Camera", MB_OK|MB_ICONSTOP, 0);
	}

	InitTracker(&curr_state);

	if (Digitizer_Init(0,dparams) == TRUE) {
		StartVideoThread();
	} else
		AfxMessageBox("Failed to Connect To Digitizer",MB_OK|MB_ICONSTOP,0);

	blankimg = DIALOG_BACKGROUND_COLOR;
	img_reddot.Set(0,0,255);
	img_blankdot = DIALOG_BACKGROUND_COLOR;

	if (SetTimer(TIMER_ID, 1000/display_speeds[INITIAL_DISPLAY_SPEED], NULL) == 0)
		AfxMessageBox("Failed to Set Timer",MB_OK|MB_ICONSTOP,0);

	my_cdc->SetBkColor(0x00C0C0C0);
	PrintEditNumber4D(IDC_FRAME_NUMBER, m_filenum);

	return TRUE;  // return TRUE  unless you set the focus to a control
}

// Without the OnOK function, pressing the RETURN key inside an edit box
// causes the dialog to exit.
void CHeadtrackerDlg::OnOK() 
{
	int edit_box_id = GetFocus()->GetDlgCtrlID();
	UpdateData(TRUE);

	switch (edit_box_id) {
	case IDC_FRAME_NUMBER: 
		if (m_filenum < m_first_filenum || m_filenum > m_last_filenum) m_filenum = m_first_filenum;
		PrintEditNumber4D(IDC_FRAME_NUMBER, m_filenum);
		break;
	case IDC_BASENAME:
		PrintEditString(IDC_BASENAME, (char *) ((LPCTSTR) m_basename));
		break;
	case IDC_FIRST:
		PrintEditNumber4D(IDC_FIRST, m_first_filenum);
		if (m_filenum < m_first_filenum) m_filenum = m_first_filenum;
		break;
	case IDC_LAST:
		PrintEditNumber4D(IDC_LAST, m_last_filenum);
		if (m_filenum > m_last_filenum) m_filenum = m_last_filenum;
		break;
	default:
		break;
	}
}

void CHeadtrackerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CHeadtrackerDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
		if (m_input_mode == IMAGE_SEQUENCE) PrintDisplaySpeed(display_speed);
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CHeadtrackerDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CHeadtrackerDlg::OnDestroy() 
{
	CDialog::OnDestroy();
	
	// TODO: Add your message handler code here
	Sleep(2000);
//	Digitizer_Stop(0);
	Digitizer_Shutdown(0);
	StopCamera();
	CloseCamera();
}


/////////////////////////////////////////////////////////////////////////////
// General functions

void NegateBoolean(BOOL *b) { *b = 1 - *b; }


/////////////////////////////////////////////////////////////////////////////
// Input Mode (Live vs. Image Sequence) functions

void CHeadtrackerDlg::OnSelchangeInputMode() 
{
	UpdateData(TRUE);
	TRACE("input mode: %d\n", m_input_mode);
	EnableDisableWindows();
}


/////////////////////////////////////////////////////////////////////////////
// Tracking functions

void CHeadtrackerDlg::OnUseGradient() { 
	if (use_color) {
		NegateBoolean(&use_gradient); 
		EnableDisableMagDot(use_gradient);
	}
	else ((CButton *) GetDlgItem(IDC_USE_GRADIENT))->SetCheck(use_gradient);
}
void CHeadtrackerDlg::OnUseColor() { 
	if (use_gradient) NegateBoolean(&use_color); 
	else ((CButton *) GetDlgItem(IDC_USE_COLOR))->SetCheck(use_color);
}
void CHeadtrackerDlg::OnGradientMag() {	sum_gradient_magnitude = TRUE; }
void CHeadtrackerDlg::OnGradientDot() {	sum_gradient_magnitude = FALSE; }
void CHeadtrackerDlg::OnSaveModel() { WriteModel(filename_model); }

void CHeadtrackerDlg::OnCheckTracking() 
{
	if (!m_tracking) {	// start tracking
	//	InitTracker(&curr_state);  // redundant now
	} else {			// stop tracking
	//	if (!Image.Write24BitBMP("image.bmp")) {
	//		AfxMessageBox("Error writing BMP file",MB_OK|MB_ICONSTOP,0);
	//	}
	}
	m_tracking = 1 - m_tracking;
}

void CHeadtrackerDlg::OnAdaptHistogram() 
{
	NegateBoolean(&adapt_histogram);
	if (!adapt_histogram) CopyModelHistogramToRef();
}

void CHeadtrackerDlg::OnBuildingModel() 
{
	UpdateData(TRUE);
	building_model = m_building_model;
	if (building_model) {
		InitBuildingOfModel();
	} else {
		StopBuildingOfModel();
	}
}

void CHeadtrackerDlg::OnShowDetails() 
{
	int left = 0, top = 0;

	NegateBoolean(&show_details);