dlgoptions.cpp

3D reconstruction, medical image processing from colons, using intel image processing for based clas

	{
		DrawHorz(pDC, 50,120,190);
		pDC->TextOut(73,137, _T("Sample count"));
		pDC->TextOut(73,162, _T("Threshold"));
		pDC->TextOut(73,187, _T("Tolerance"));
	}
	else if(m_nTabIndex == 2)
	{
		DrawHorz(pDC, 50,145,190);
	}

	pDC->SelectObject(pOldFont);
}

void RxDlgOptions::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if(m_rcTabRegist.PtInRect(point))
		SetTabCtrl(0);
	else if(m_rcTabSample.PtInRect(point))
		SetTabCtrl(1);
	else if(m_rcTabMIAnalysis.PtInRect(point))
		SetTabCtrl(2);
	
	RxDlgCommon::OnLButtonUp(nFlags, point);
}

/////////////////////////////////////////////////////////////////////////////

void RxDlgOptions::SetTabCtrl(int nIndex)
{
	if(m_nTabIndex == nIndex)			return;

	if(m_nTabIndex == 0)
	{
		m_pEdIterate->ShowWindow(SW_HIDE);
		m_pEdVarF->ShowWindow(SW_HIDE);
		m_pEdCoVarR->ShowWindow(SW_HIDE);
		m_pEdCoVarF->ShowWindow(SW_HIDE);
		m_pEdLearnTrans->ShowWindow(SW_HIDE);
		m_pEdLearnRot->ShowWindow(SW_HIDE);
	}
	else if(m_nTabIndex == 1)
	{
		m_pBtnUniform->ShowWindow(SW_HIDE);
		m_pBtnRandom->ShowWindow(SW_HIDE);
		m_pBtnSobel->ShowWindow(SW_HIDE);
		m_pBtnSobelLevoy->ShowWindow(SW_HIDE);

		m_pEdCount->ShowWindow(SW_HIDE);
		m_pEdThreshold->ShowWindow(SW_HIDE);
		m_pEdTolerance->ShowWindow(SW_HIDE);
	}
	else if(m_nTabIndex == 2)
	{
		m_pBtnMIOriginal->ShowWindow(SW_HIDE);
		m_pBtnMIFast->ShowWindow(SW_HIDE);
		m_pBtnSurface->ShowWindow(SW_HIDE);

		m_pBtnPartial->ShowWindow(SW_HIDE);
		m_pBtnTrilinear->ShowWindow(SW_HIDE);
		m_pBtnNearest->ShowWindow(SW_HIDE);
	}

	m_nTabIndex = nIndex;

	if(nIndex == 0)
	{
		m_pEdIterate->ShowWindow(SW_SHOW);
		m_pEdVarF->ShowWindow(SW_SHOW);
		m_pEdCoVarR->ShowWindow(SW_SHOW);
		m_pEdCoVarF->ShowWindow(SW_SHOW);
		m_pEdLearnTrans->ShowWindow(SW_SHOW);
		m_pEdLearnRot->ShowWindow(SW_SHOW);
	}
	else if(nIndex == 1)
	{
		m_pBtnUniform->ShowWindow(SW_SHOW);
		m_pBtnRandom->ShowWindow(SW_SHOW);
		m_pBtnSobel->ShowWindow(SW_SHOW);
		m_pBtnSobelLevoy->ShowWindow(SW_SHOW);

		m_pEdCount->ShowWindow(SW_SHOW);
		m_pEdThreshold->ShowWindow(SW_SHOW);
		m_pEdTolerance->ShowWindow(SW_SHOW);
	}
	else if(nIndex == 2)
	{
		m_pBtnMIOriginal->ShowWindow(SW_SHOW);
		m_pBtnMIFast->ShowWindow(SW_SHOW);
		m_pBtnSurface->ShowWindow(SW_SHOW);

		m_pBtnPartial->ShowWindow(SW_SHOW);
		m_pBtnTrilinear->ShowWindow(SW_SHOW);
		m_pBtnNearest->ShowWindow(SW_SHOW);
	}

	InvalidateRect(m_rcTabBorder);
}

void RxDlgOptions::SendMessageToParent()
{
	_NMDLG_REGIST			hdrRegist;

	hdrRegist.hdr.hwndFrom	= m_pBtnApply->GetSafeHwnd();
	hdrRegist.hdr.idFrom	= IDD_OPTIONS_BTN_APPLY;
	hdrRegist.hdr.code		= NM_DLG_REGIST_APPLY;
	hdrRegist.stpRegist		= &m_stRegist;
	hdrRegist.stpSampling	= &m_stSampling;

	if (m_pParentWnd)
		m_pParentWnd->SendMessage(WM_NOTIFY, hdrRegist.hdr.idFrom, (LPARAM)&hdrRegist);
}

void RxDlgOptions::UpdateData(BOOL bSaveAndValidate)
{
	if(bSaveAndValidate)
	{
		m_stRegist.nIterate		= m_pEdIterate->GetEdit();
		m_stRegist.fVarF		= m_pEdVarF->GetEdit();
		m_stRegist.fCoVarR		= m_pEdCoVarR->GetEdit();
		m_stRegist.fCoVarF		= m_pEdCoVarF->GetEdit();
		m_stRegist.fLearnTrans	= m_pEdLearnTrans->GetEdit();
		m_stRegist.fLearnRot	= m_pEdLearnRot->GetEdit();

		if(m_pBtnUniform->GetCheck())			m_stSampling.nMode = 0;
		else if(m_pBtnRandom->GetCheck())		m_stSampling.nMode = 1;
		else if(m_pBtnSobel->GetCheck())		m_stSampling.nMode = 2;
		else if(m_pBtnSobelLevoy->GetCheck())	m_stSampling.nMode = 3;
		else									m_stSampling.nMode = -1;

		m_stSampling.nCount		= m_pEdCount->GetEdit();
		m_stSampling.nThreshold	= m_pEdThreshold->GetEdit();
		m_stSampling.fTolerance	= m_pEdTolerance->GetEdit();
	}
	else
	{
		m_pEdIterate->SetEdit		(m_stRegist.nIterate);
		m_pEdVarF->SetEdit			(m_stRegist.fVarF);
		m_pEdCoVarR->SetEdit		(m_stRegist.fCoVarR);
		m_pEdCoVarF->SetEdit		(m_stRegist.fCoVarF);
		m_pEdLearnTrans->SetEdit	(m_stRegist.fLearnTrans);
		m_pEdLearnRot->SetEdit		(m_stRegist.fLearnRot);

		switch(m_stSampling.nMode)
		{
			case	0 :
				m_pBtnUniform->SetCheck(1);
				break;
			case	1 :
				m_pBtnRandom->SetCheck(1);
				break;
			case	2 :
				m_pBtnSobel->SetCheck(1);
				break;
			case	3 :
				m_pBtnSobelLevoy->SetCheck(1);
				break;
		}

		m_pEdCount->SetEdit		(m_stSampling.nCount);
		m_pEdThreshold->SetEdit	(m_stSampling.nThreshold);
		m_pEdTolerance->SetEdit	(m_stSampling.fTolerance);

		switch(m_stMIAnalysis.nRadio1)
		{
			case	0 :
				m_pBtnMIOriginal->SetCheck(1);
				m_pBtnPartial->EnableWindow(TRUE);
				m_pBtnTrilinear->EnableWindow(TRUE);
				m_pBtnNearest->EnableWindow(TRUE);
				break;
			case	1 :
				m_pBtnMIFast->SetCheck(1);
				m_pBtnPartial->EnableWindow(TRUE);
				m_pBtnTrilinear->EnableWindow(TRUE);
				m_pBtnNearest->EnableWindow(TRUE);
				break;
			case	2 :
				m_pBtnSurface->SetCheck(1);
				m_pBtnPartial->EnableWindow(FALSE);
				m_pBtnTrilinear->EnableWindow(FALSE);
				m_pBtnNearest->EnableWindow(FALSE);
				break;
		}

		switch(m_stMIAnalysis.nRadio2)
		{
			case	0 :
				m_pBtnPartial->SetCheck(1);
				break;
			case	1 :
				m_pBtnTrilinear->SetCheck(1);
				break;
			case	2 :
				m_pBtnNearest->SetCheck(1);
				break;
		}
	}
}

void RxDlgOptions::OnControls(UINT nID)
{
	int		nIndex;

	switch(nID)
	{
		case IDD_OPTIONS_BTN_UNIFORM :
		case IDD_OPTIONS_BTN_RANDOM :
		case IDD_OPTIONS_BTN_SOBEL :
		case IDD_OPTIONS_BTN_SOBEL_LEVOY :
			nIndex = nID - IDD_OPTIONS_BTN_UNIFORM;
			if(m_stSampling.nMode != nIndex)
			{
				if(m_pBtnUniform->GetCheck())			m_pBtnUniform->SetCheck(0);
				else if(m_pBtnRandom->GetCheck())		m_pBtnRandom->SetCheck(0);
				else if(m_pBtnSobel->GetCheck())		m_pBtnSobel->SetCheck(0);
				else if(m_pBtnSobelLevoy->GetCheck())	m_pBtnSobelLevoy->SetCheck(0);

				m_stSampling.nMode = nIndex;

				switch(nIndex)
				{
					case	0 :
						m_pBtnUniform->SetCheck(1);
						break;
					case	1 :
						m_pBtnRandom->SetCheck(1);
						break;
					case	2 :
						m_pBtnSobel->SetCheck(1);
						break;
					case	3 :
						m_pBtnSobelLevoy->SetCheck(1);
						break;
				}
			}
			break;
		case IDD_OPTIONS_BTN_MI_ORIGINAL :
		case IDD_OPTIONS_BTN_MI_FAST :
		case IDD_OPTIONS_BTN_SURFACE :
			nIndex = nID - IDD_OPTIONS_BTN_MI_ORIGINAL;
			if(m_stMIAnalysis.nRadio1 != nIndex)
			{
				if(m_pBtnMIOriginal->GetCheck())			m_pBtnMIOriginal->SetCheck(0);
				else if(m_pBtnMIFast->GetCheck())			m_pBtnMIFast->SetCheck(0);
				else if(m_pBtnSurface->GetCheck())			m_pBtnSurface->SetCheck(0);

				m_stMIAnalysis.nRadio1 = nIndex;

				switch(nIndex)
				{
					case	0 :
						m_pBtnMIOriginal->SetCheck(1);
						m_pBtnPartial->EnableWindow(TRUE);
						m_pBtnTrilinear->EnableWindow(TRUE);
						m_pBtnNearest->EnableWindow(TRUE);
						break;
					case	1 :
						m_pBtnMIFast->SetCheck(1);
						m_pBtnPartial->EnableWindow(TRUE);
						m_pBtnTrilinear->EnableWindow(TRUE);
						m_pBtnNearest->EnableWindow(TRUE);
						break;
					case	2 :
						m_pBtnSurface->SetCheck(1);
						m_pBtnPartial->EnableWindow(FALSE);
						m_pBtnTrilinear->EnableWindow(FALSE);
						m_pBtnNearest->EnableWindow(FALSE);
						break;
				}
			}
			break;
		case IDD_OPTIONS_BTN_PARTIAL :
		case IDD_OPTIONS_BTN_TRILINEAR :
		case IDD_OPTIONS_BTN_NEAREST :
			nIndex = nID - IDD_OPTIONS_BTN_PARTIAL;
			if(m_stMIAnalysis.nRadio2 != nIndex)
			{
				if(m_pBtnPartial->GetCheck())			m_pBtnPartial->SetCheck(0);
				else if(m_pBtnTrilinear->GetCheck())	m_pBtnTrilinear->SetCheck(0);
				else if(m_pBtnNearest->GetCheck())		m_pBtnNearest->SetCheck(0);

				m_stMIAnalysis.nRadio2 = nIndex;

				switch(nIndex)
				{
					case	0 :
						m_pBtnPartial->SetCheck(1);
						break;
					case	1 :
						m_pBtnTrilinear->SetCheck(1);
						break;
					case	2 :
						m_pBtnNearest->SetCheck(1);
						break;
				}
			}
			break;
	}
}

void RxDlgOptions::OnOK()
{
	UpdateData(TRUE);

	RxDlgCommon::OnOK();
}

/////////////////////////////////////////////////////////////////////////////

void RxDlgOptions::SetRegistStruct(int nIterate, float fVarF,
							float fCoVarR, float fCoVarF, float fLearnTrans, float fLearnRot)
{
	m_stRegist.nIterate		= nIterate;
	m_stRegist.fVarF		= fVarF;
	m_stRegist.fCoVarR		= fCoVarR;
	m_stRegist.fCoVarF		= fCoVarF;
	m_stRegist.fLearnTrans	= fLearnTrans;
	m_stRegist.fLearnRot	= fLearnRot;
}

void RxDlgOptions::SetRegistStruct(DLG_REGIST *stRegist)
{
	m_stRegist.nIterate		= stRegist->nIterate;
	m_stRegist.fVarF		= stRegist->fVarF;
	m_stRegist.fCoVarR		= stRegist->fCoVarR;
	m_stRegist.fCoVarF		= stRegist->fCoVarF;
	m_stRegist.fLearnTrans	= stRegist->fLearnTrans;
	m_stRegist.fLearnRot	= stRegist->fLearnRot;
}

DLG_REGIST* RxDlgOptions::GetRegistStruct()
{
	return &m_stRegist;
}

void RxDlgOptions::SetSamplingStruct(int nMode, int nCount, int nThreshold, float fTolerance)
{
	m_stSampling.nMode		= nMode;
	m_stSampling.nCount		= nCount;
	m_stSampling.nThreshold = nThreshold;
	m_stSampling.fTolerance	= fTolerance;
}

void RxDlgOptions::SetSamplingStruct(DLG_SAMPLING	*stSampling)
{
	m_stSampling.nMode		= stSampling->nMode;
	m_stSampling.nCount		= stSampling->nCount;
	m_stSampling.nThreshold = stSampling->nThreshold;
	m_stSampling.fTolerance	= stSampling->fTolerance;
}

DLG_SAMPLING* RxDlgOptions::GetSamplingStruct()
{
	return &m_stSampling;
}

void RxDlgOptions::SetMIAnalysisStruct(int nRadio1, int nRadio2)
{
	m_stMIAnalysis.nRadio1 = nRadio1;
	m_stMIAnalysis.nRadio2 = nRadio2;
}

void RxDlgOptions::SetMIAnalysisStruct(DLG_MI_ANALYSIS *stMIAnalysis)
{
	m_stMIAnalysis.nRadio1 = stMIAnalysis->nRadio1;
	m_stMIAnalysis.nRadio2 = stMIAnalysis->nRadio2;
}

DLG_MI_ANALYSIS* RxDlgOptions::GetMIAnalysisStruct()
{
	return &m_stMIAnalysis;
}