fmwndvr.cpp

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

// 3. message handlers from frame side

void RxFMWndVR::FittingVR() 
{
	// rotation init.
	m_ptPan		= CPoint(0,0);

	int		x = 0, y = 0, z = 0, max = 0;
	RxGetVolumeData(RXSERIES_REF)->GetBigVolumeDmsn(&x, &y, &z);
	max = __max(__max(x, y), z);
	RxGetVolumeData(RXSERIES_FLT)->GetBigVolumeDmsn(&x, &y, &z);
	max = __max(__max(__max(x, y), z), max);
	int		iZoomFactor = 100 * __min(m_szWindow.cx, m_szWindow.cy) / max / 2;
	theFMDocVR.m_iVRZoomFactor = iZoomFactor;
	RxGetFrameBottom()->SetZoomFactor(iZoomFactor);

	RedrawWnd(TRUE);
}

// reset button 喘啡阑 版快. 阿辆 view俊 措茄 檬扁拳
void RxFMWndVR::ResetVR() 
{
	// rotation init.
	m_mxRotation.LoadIdentity();
	m_mxRotation.Rotate(0, 90);

	m_ptPan				= CPoint(0,0);
	theFMDocVR.m_iVRZoomFactor = 100;

	int		x = 0, y = 0, z = 0, zFloat;
	RxGetVolumeData(RXSERIES_REF)->GetBigVolumeDmsn(&x, &y, &z);
	m_pVRRefInfo->SetCropRange(0, x-1, 0, y-1, 0, z-1);
	m_pVRRefInfo->SetBgColor(0, 0, 0);
	m_pVRRefInfo->SetContrast(30);
	m_pVRRefInfo->SetBrightness(30);

	int iMin[3] = {0,0,0};
	int iMax[3] = {x-1, y-1, z-1};

	RxGetVolumeData(RXSERIES_FLT)->GetBigVolumeDmsn(&x, &y, &zFloat);
	m_pVRFltInfo->SetCropRange(0, x-1, 0, y-1, 0, zFloat-1);

	int iMin2[3] = {0,0,0};
	int iMax2[3] = {x-1, y-1, zFloat-1};

	if (zFloat > z)
		m_pVRFltInfo->SetRefCropRange(iMin2, iMax2);
	else
		m_pVRFltInfo->SetRefCropRange(iMin, iMax);

	m_pVRFltInfo->SetBgColor(0, 0, 0);
	m_pVRFltInfo->SetContrast(30);
	m_pVRFltInfo->SetBrightness(30);

	Reset_UI_LocalSlider();
	
	theFMDocVR.MPR_Initialize(m_szWindow);
}

void RxFMWndVR::OnRegistMode() 
{
	g_bSaveDicom = TRUE;

	g_Reg.SaveVolumeDicom();

	AfxMessageBox(_T("Save subtraction results as dicom format in c:/patient number/"));
}

void RxFMWndVR::OnDistance() 
{
	if(RxGetCurSeries() != RXSERIES_COM)
		RxGetFrameMain()->SetTBCurMode(BTN_MEASURE_DISTANCE);
}

void RxFMWndVR::OnArea() 
{
	if(RxGetCurSeries() != RXSERIES_COM)
		RxGetFrameMain()->SetTBCurMode(BTN_MEASURE_AREA);
}

void RxFMWndVR::OnVolume() 
{
	if(RxGetCurSeries() != RXSERIES_COM)
		RxGetFrameMain()->SetTBCurMode(BTN_MEASURE_VOLUME);
}

void RxFMWndVR::OnUpdateDistance(CCmdUI* pCmdUI) 
{
	if(RxGetCurSeries() != RXSERIES_COM)
	{
		pCmdUI->Enable(TRUE);
		if(RxGetFrameMain()->GetTBCurMode() == BTN_MEASURE_DISTANCE)
			pCmdUI->SetCheck(TRUE);
		else
			pCmdUI->SetCheck(FALSE);
	}
	else
	{
		pCmdUI->SetCheck(FALSE);
		pCmdUI->Enable(FALSE);
	}
}

void RxFMWndVR::OnUpdateArea(CCmdUI* pCmdUI) 
{
	if(RxGetCurSeries() != RXSERIES_COM)
	{
		pCmdUI->Enable(TRUE);
		if(RxGetFrameMain()->GetTBCurMode() == BTN_MEASURE_AREA)
			pCmdUI->SetCheck(TRUE);
		else
			pCmdUI->SetCheck(FALSE);
	}
	else
	{
		pCmdUI->SetCheck(FALSE);
		pCmdUI->Enable(FALSE);
	}
}

void RxFMWndVR::OnUpdateVolume(CCmdUI* pCmdUI) 
{
	if(RxGetCurSeries() != RXSERIES_COM)
	{
		pCmdUI->Enable(TRUE);
		if(RxGetFrameMain()->GetTBCurMode() == BTN_MEASURE_VOLUME)
			pCmdUI->SetCheck(TRUE);
		else
			pCmdUI->SetCheck(FALSE);
	}
	else
	{
		pCmdUI->SetCheck(FALSE);
		pCmdUI->Enable(FALSE);
	}
}

void RxFMWndVR::OnUpdateRegistReport(CCmdUI* pCmdUI) 
{
	if(RxGetCurSeries() == RXSERIES_COM)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

////////////////////////////////////////////
// 4. message handlers from caption bar

void RxFMWndVR::OnBtnMixing()
{
	SetBtnMixing(!GetBtnCheck(IDFM_VR_BTN_MIXING));
}

/*
void RxFMWndVR::ShowDlgSampling() 
{
	RxDlgSampling		dlg(this);

	dlg.SetSamplingStruct(m_SampleMode, m_SampleNum, m_Threshold, (float)m_Tolerance);

	if(dlg.DoModal() == IDOK)
	{
		DLG_SAMPLING	*stpSampling = dlg.GetSamplingStruct();
		m_SampleMode	= stpSampling->nMode;
		m_SampleNum		= stpSampling->nCount;
		m_Threshold		= stpSampling->nThreshold;
		m_Tolerance		= stpSampling->fTolerance;
	}
}

void RxFMWndVR::ShowDlgRegistration()
{
	RxDlgRegist			dlg(this);

	dlg.SetRegistStruct(m_maxIter, (float)m_varFloat, (float)m_covarRefer,
							(float)m_covarFloat, (float)m_etaTrans, (float)m_etaRot);

	if(dlg.DoModal() == IDOK)
	{
		DLG_REGIST		*stpRegist = dlg.GetRegistStruct();
		m_maxIter		= stpRegist->nIterate;
		m_varFloat		= stpRegist->fVarF;
		m_covarRefer	= stpRegist->fCoVarR;
		m_covarFloat	= stpRegist->fCoVarF;
		m_etaTrans		= stpRegist->fLearnTrans;
		m_etaRot		= stpRegist->fLearnRot;
	}
}
*/

void RxFMWndVR::ShowDlgMixing(BOOL bShow)
{
	m_pDlgMixing->ShowWindow(bShow ? SW_SHOW : SW_HIDE);
}

void RxFMWndVR::SetBtnMixing(BOOL bCheck)
{
	if(bCheck)
	{
		SetBtnCheck(IDFM_VR_BTN_MIXING, TRUE);
		CRect	rcWindow;
		GetWindowRect(rcWindow);

		m_pDlgMixing->SetWindowPos(NULL, rcWindow.right-220, rcWindow.top+18, -1, -1,
										SWP_SHOWWINDOW|SWP_NOZORDER|SWP_NOSIZE);;
	}
	else
	{
		SetBtnCheck(IDFM_VR_BTN_MIXING, FALSE);
		m_pDlgMixing->ShowWindow(SW_HIDE);
	}
}

BOOL RxFMWndVR::GetBtnMixing()
{
	return GetBtnCheck(IDFM_VR_BTN_MIXING);
}

void RxFMWndVR::OnBtnMin()
{
	RxGetFrameMain()->Frame3DF_Local_Max(0);
}

void RxFMWndVR::OnBtnMax()
{
	RxGetFrameMain()->Frame3DF_Local_Nor();
}

////////////////////////////////////////////
// 5. message handlers from client area

void RxFMWndVR::OnOrientBtn(UINT nID)
{
	m_mxRotation.LoadIdentity();

	switch(nID)
	{
		case IDFM_VR_ORIENT_A :
			m_mxRotation.Rotate(0, 90);
			break;
		case IDFM_VR_ORIENT_P :
			m_mxRotation.Rotate(0, -90);
			m_mxRotation.Rotate(2, 180);
			break;
		case IDFM_VR_ORIENT_L :
			m_mxRotation.Rotate(0, -90);
			m_mxRotation.Rotate(1, 90);
			m_mxRotation.Rotate(2, 180);
			break;
		case IDFM_VR_ORIENT_R :
			m_mxRotation.Rotate(0, -90);
			m_mxRotation.Rotate(1, -90);
			m_mxRotation.Rotate(2, 180);
			break;
		case IDFM_VR_ORIENT_H :
			m_mxRotation.Rotate(0, 180);
			m_mxRotation.Rotate(2, 180);
			break;
		case IDFM_VR_ORIENT_F :
			break;
	}

	RedrawWnd(TRUE);
}

////////////////////////////////////////////
// 6. message handlers from dialog box

/*
void RxFMWndVR::OnDlgApplySampling(NMHDR* pNMHDR, LRESULT* pResult)
{
	_NMDLG_SAMPLING	*pNMSampling = (_NMDLG_SAMPLING *)pNMHDR;

	m_SampleMode	= pNMSampling->stpSampling->nMode;
	m_SampleNum		= pNMSampling->stpSampling->nCount;
	m_Threshold		= pNMSampling->stpSampling->nThreshold;
	m_Tolerance		= pNMSampling->stpSampling->fTolerance;

	*pResult = 0;
}

void RxFMWndVR::OnDlgApplyRegist(NMHDR* pNMHDR, LRESULT* pResult)
{
	_NMDLG_REGIST	*pNMRegist = (_NMDLG_REGIST *)pNMHDR;

	m_maxIter		= pNMRegist->stpRegist->nIterate;
	m_varFloat		= pNMRegist->stpRegist->fVarF;
	m_covarRefer	= pNMRegist->stpRegist->fCoVarR;
	m_covarFloat	= pNMRegist->stpRegist->fCoVarF;
	m_etaTrans		= pNMRegist->stpRegist->fLearnTrans;
	m_etaRot		= pNMRegist->stpRegist->fLearnRot;

	*pResult = 0;
}
*/

void RxFMWndVR::OnDlgApplyMixing(NMHDR* pNMHDR, LRESULT* pResult)
{
	_NMDLG_MIXING	*pNMMixing = (_NMDLG_MIXING *)pNMHDR;

	m_pVRFusAgent->ChangeWeight(0.01f * pNMMixing->nMixingRate);
	RedrawWnd(FALSE);
	
	BOOL bAfterFusion = RxGetFrameMain()->m_pLocalizerManager[m_nSeries]->m_pLocalizer[0]->m_bAfterFusion;

	if(m_nSeries == RXSERIES_COM && bAfterFusion) {
		
	}
	if(m_nSeries == RXSERIES_COM){
		float fRaitoOfRef = pNMMixing->nMixingRate * 0.01f;
		if(bAfterFusion){			
			RxGetFrameMain()->m_pLocalizerManager[m_nSeries]->ApplyMixingRatio(fRaitoOfRef);
		}
		RxFMWnd3DMPR	*pFMWnd3DMPR = RxGetFrameMain()->m_pFMWnd3DMPR[m_nSeries];
		pFMWnd3DMPR->ApplyMixingRatio(fRaitoOfRef);
	}

	*pResult = 0;
}

void RxFMWndVR::OnDlgCancelMixing(NMHDR* pNMHDR, LRESULT* pResult)
{
	SetBtnCheck(IDFM_VR_BTN_MIXING, FALSE);

	*pResult = 0;
}

void RxFMWndVR::Reset_UI_LocalSlider()
{
	// localizer window slider bar reset
	RxFMWndLocalizer	*pFMWnd3DLocalA = RxGetFrameMain()->m_pFMWnd3DLocalA[m_nSeries];
	RxFMWndLocalizer	*pFMWnd3DLocalC = RxGetFrameMain()->m_pFMWnd3DLocalC[m_nSeries];
	RxFMWndLocalizer	*pFMWnd3DLocalS = RxGetFrameMain()->m_pFMWnd3DLocalS[m_nSeries];
	pFMWnd3DLocalA->SetSliderPos(0, 100, TRUE);
	pFMWnd3DLocalC->SetSliderPos(0, 100, TRUE);
	pFMWnd3DLocalS->SetSliderPos(0, 100, TRUE);
}

void RxFMWndVR::CalcuBoundingBox() 
{
	int		x, y, z;
	RxRayCastingCommonInfo *pVRInfo;

//	RxGetVolumeData(RXSERIES_REF)->GetBigVolumeDmsn(&x, &y, &z);
	RxGetVolumeData(m_nSeries)->GetBigVolumeDmsn(&x, &y, &z);
/*	if(m_nSeries == RXSERIES_REF)
		pVRInfo = m_pVRRefInfo;
	else if (m_nSeries == RXSERIES_FLT)
		pVRInfo = m_pVRFltInfo;
	else*/
		
	pVRInfo = m_pVRRefInfo;
	
/*
	m_aptApex[0] = m_mxRefView * RxVect4D(  0,   0,   0, 1);	
	m_aptApex[1] = m_mxRefView * RxVect4D(x-1,   0,   0, 1);	
	m_aptApex[2] = m_mxRefView * RxVect4D(x-1, y-1,   0, 1);
	m_aptApex[3] = m_mxRefView * RxVect4D(  0, y-1,   0, 1);
	m_aptApex[4] = m_mxRefView * RxVect4D(  0,   0, z-1, 1);	
	m_aptApex[5] = m_mxRefView * RxVect4D(x-1,   0, z-1, 1);	
	m_aptApex[6] = m_mxRefView * RxVect4D(x-1, y-1, z-1, 1);
	m_aptApex[7] = m_mxRefView * RxVect4D(  0, y-1, z-1, 1);	
*/
	m_aptApex[0] = m_mxView * m_mxRegistration * RxVect4D(  0,   0,   0, 1);	
	m_aptApex[1] = m_mxView * m_mxRegistration * RxVect4D(x-1,   0,   0, 1);	
	m_aptApex[2] = m_mxView * m_mxRegistration * RxVect4D(x-1, y-1,   0, 1);
	m_aptApex[3] = m_mxView * m_mxRegistration * RxVect4D(  0, y-1,   0, 1);
	m_aptApex[4] = m_mxView * m_mxRegistration * RxVect4D(  0,   0, z-1, 1);	
	m_aptApex[5] = m_mxView * m_mxRegistration * RxVect4D(x-1,   0, z-1, 1);	
	m_aptApex[6] = m_mxView * m_mxRegistration * RxVect4D(x-1, y-1, z-1, 1);
	m_aptApex[7] = m_mxView * m_mxRegistration * RxVect4D(  0, y-1, z-1, 1);	

	m_aptApexCrop[0] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMin,
														pVRInfo->m_iCrop_YMin, pVRInfo->m_iCrop_ZMin, 1);	
	m_iWMin = m_iWMax = (int)m_aptApexCrop[0][2];
	m_iVMin = m_iVMax = (int)m_aptApexCrop[0][1];
	m_iUMin = m_iUMax = (int)m_aptApexCrop[0][0];
	m_aptApexCrop[1] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMax,
														pVRInfo->m_iCrop_YMin, pVRInfo->m_iCrop_ZMin, 1);	
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[1][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[1][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[1][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[1][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[1][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[1][0]);
	m_aptApexCrop[2] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMax,
														pVRInfo->m_iCrop_YMax, pVRInfo->m_iCrop_ZMin, 1);
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[2][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[2][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[2][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[2][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[2][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[2][0]);
	m_aptApexCrop[3] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMin,
														pVRInfo->m_iCrop_YMax, pVRInfo->m_iCrop_ZMin, 1);
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[3][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[3][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[3][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[3][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[3][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[3][0]);
	m_aptApexCrop[4] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMin,
														pVRInfo->m_iCrop_YMin, pVRInfo->m_iCrop_ZMax, 1);	
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[4][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[4][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[4][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[4][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[4][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[4][0]);
	m_aptApexCrop[5] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMax,
														pVRInfo->m_iCrop_YMin, pVRInfo->m_iCrop_ZMax, 1);	
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[5][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[5][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[5][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[5][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[5][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[5][0]);
	m_aptApexCrop[6] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMax,
														pVRInfo->m_iCrop_YMax, pVRInfo->m_iCrop_ZMax, 1);
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[6][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[6][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[6][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[6][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[6][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[6][0]);
	m_aptApexCrop[7] = m_mxRefView * RxVect4D(pVRInfo->m_iCrop_XMin,
														pVRInfo->m_iCrop_YMax, pVRInfo->m_iCrop_ZMax, 1);	
	m_iWMin = min(m_iWMin, (int)m_aptApexCrop[7][2]);
	m_iWMax = max(m_iWMax, (int)m_aptApexCrop[7][2]);
	m_iVMin = min(m_iVMin, (int)m_aptApexCrop[7][1]);
	m_iVMax = max(m_iVMax, (int)m_aptApexCrop[7][1]);
	m_iUMin = min(m_iUMin, (int)m_aptApexCrop[7][0]);
	m_iUMax = max(m_iUMax, (int)m_aptApexCrop[7][0]);

	CalcRgnOfVisiblePlanes();
}

void RxFMWndVR::CalcRgnOfVisiblePlanes()
{
	double		x, y, z;
	if(m_nSeries == RXSERIES_FLT)
		m_pVRFltInfo->m_mxInvViewing.TransformVect3D(0, 0, -1, &x, &y, &z);		// (0, 0, -1) 氦磐甫 object space肺
	else
		m_pVRRefInfo->m_mxInvViewing.TransformVect3D(0, 0, -1, &x, &y, &z);		// (0, 0, -1) 氦磐甫 object space肺
		
	RxVect4D viewV(x, y, z, 1);