fmwndvr.cpp

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

	for(int i = 0; i < 6 ; i++)
		m_abPlaneVisible[i] = FALSE;

	double vector;

	// Z-Min 乞搁捞 visible
	vector = viewV * RxVect4D( 0, 0,-1, 1);
	if(viewV * RxVect4D( 0, 0,-1, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_ZMIN] = TRUE;

	// Z-Max 乞搁捞 visible	
	if(viewV * RxVect4D( 0, 0, 1, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_ZMAX] = TRUE;
	
	// X-Max 乞搁捞 visible
	if(viewV * RxVect4D( 1, 0, 0, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_XMAX] = TRUE;
	
	// X-Min 乞搁捞 visible
	if(viewV * RxVect4D(-1, 0, 0, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_XMIN] = TRUE;
	
	// Y-Min 乞搁捞 visible
	if(viewV * RxVect4D( 0,-1, 0, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_YMIN] = TRUE;
	
	// Y-Max 乞搁捞 visible
	if(viewV * RxVect4D( 0, 1, 0, 1) >= ZERO_EPSILON)
		m_abPlaneVisible[PLANE_YMAX] = TRUE;
}

void RxFMWndVR::UpdateMPRWindow()
{
	RxFMWnd3DMPR	*pFMWnd3DMPR = RxGetFrameMain()->m_pFMWnd3DMPR[m_nSeries];
	pFMWnd3DMPR->RedrawWnd(TRUE);	
}

/////////////////////////////////////////////////////////////////////////////
// End (H.S.Kim)
/////////////////////////////////////////////////////////////////////////////

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

// load甫 货肺 且锭付促 角青凳, 3俺狼 wnd捞瘤父 茄锅父 阂覆
// volume包访 阿辆 檬扁拳 累诀
// 扩档 农扁绰 酒流 舅荐 绝栏骨肺 农扁炼累篮 窍瘤 臼绰促.
BOOL RxFMWndVR::VR_Initialize()
{
	InitRigidRegistration();
	m_pTransform->Initialize();
	m_pTransformRight->Initialize();
	m_pTransformLeft->Initialize();
	m_pVRFltInfo->SetTransform3DInfo(m_pTransform);

	int x,y,z;

	// volume 檬扁拳
	RxVolumeData *pVolumeData = RxGetVolumeData(RXSERIES_REF);
	ASSERT(pVolumeData);
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	m_pVRRefInfo->SetVolume(pVolumeData->GetBigVolume(), x,y,z);
	m_pVRRefInfo->SetSliceMappingTable(pVolumeData->m_piInterpolatedMap);
	m_pVRRefInfo->SetBlockData(pVolumeData->GetBlockData());

	pVolumeData = RxGetVolumeData(RXSERIES_FLT);
	ASSERT(pVolumeData);
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	m_pVRFltInfo->SetVolume(pVolumeData->GetBigVolume(), x,y,z);
	m_pVRFltInfo->SetSliceMappingTable(pVolumeData->m_piInterpolatedMap);
	m_pVRFltInfo->SetBlockData(pVolumeData->GetBlockData());

	// viewing system 檬扁拳
	ResetVR();

	return TRUE;
}

UINT RxFMWndVR::VRThreadFunc(LPVOID pParam)
{
	RxFMWndVR *pWnd = (RxFMWndVR *)pParam;
	unsigned char *pResultImage = NULL;

	// for each frame
	if(pWnd->m_nSeries == RXSERIES_REF) {
		m_pVRRefInfo->m_iLodLevel = 1;
		pWnd->AssignRenderInfos(RxGetVolumeData(RXSERIES_REF), m_pVRRefInfo);
		if(pWnd->m_pVRRefAgent->InitRendering(m_pVRRefInfo)) {
			pResultImage = pWnd->m_pVRRefAgent->Render(m_pVRRefInfo);
		}

	} else if(pWnd->m_nSeries == RXSERIES_FLT) {
		m_pVRFltInfo->m_iLodLevel = 1;
		pWnd->AssignRenderInfos(RxGetVolumeData(RXSERIES_FLT), m_pVRFltInfo);
		if(pWnd->m_pVRFltAgent->InitRendering(m_pVRFltInfo))
			pResultImage = pWnd->m_pVRFltAgent->Render(m_pVRFltInfo);

	} else if(pWnd->m_nSeries == RXSERIES_COM) {
		m_pVRRefInfo->m_iLodLevel = 1;
		m_pVRFltInfo->m_iLodLevel = 1;
		pWnd->AssignRenderInfos(RxGetVolumeData(RXSERIES_REF), m_pVRRefInfo);
		pWnd->AssignRenderInfos(RxGetVolumeData(RXSERIES_FLT), m_pVRFltInfo);

		pWnd->m_pVRFusAgent->SetAgents(m_pVRRefAgent, m_pVRFltAgent);
		if(pWnd->m_pVRFusAgent->InitRendering(m_pVRRefInfo, m_pVRFltInfo))
			pResultImage = pWnd->m_pVRFusAgent->Render(m_pVRRefInfo, m_pVRFltInfo);
	}

	if(pResultImage) {
		pWnd->m_pbyFinalImage = pResultImage;
		TRACE(_T("\nthread success"));
		pWnd->RedrawWnd(FALSE);
	}
	pWnd->m_pVRThread = NULL;

	return 0;
}

BOOL RxFMWndVR::KillRenderThread()
{
	DWORD dwExitCode;
	
	// thread啊 累悼吝捞搁 thread 辆丰
	if (m_hVRThread && ::GetExitCodeThread(m_hVRThread, &dwExitCode) && (dwExitCode == STILL_ACTIVE)) {
		::SetEvent(g_hVRThreadKillEvent);
		::WaitForSingleObject(m_hVRThread, INFINITE);
		::ResetEvent(g_hVRThreadKillEvent);
		m_pVRThread = NULL;
//		m_howRenderThreadKilled = KILL_INTERRUPT;
	}
	else {
	}
//		m_howRenderThreadKilled = KILL_FINISH;

	return TRUE;
}

BOOL RxFMWndVR::RenderVolume()
{
	KillRenderThread();
	m_pbyFinalImage = NULL;

	if(m_nSeries == RXSERIES_REF)
	{
		TRACE(_T("ref start\n"));
		m_pVRRefInfo->m_iLodLevel = 2;
		AssignRenderInfos(RxGetVolumeData(RXSERIES_REF), m_pVRRefInfo);
		if(m_pVRRefAgent->InitRendering(m_pVRRefInfo)) 
			m_pbyFinalImage = m_pVRRefAgent->Render(m_pVRRefInfo);
		TRACE(_T("ref end\n"));

	}
	else if(m_nSeries == RXSERIES_FLT)
	{
		m_pVRFltInfo->m_iLodLevel = 2;
		AssignRenderInfos(RxGetVolumeData(RXSERIES_FLT), m_pVRFltInfo);
		if(m_pVRFltAgent->InitRendering(m_pVRFltInfo))
			m_pbyFinalImage = m_pVRFltAgent->Render(m_pVRFltInfo);

	}
	else if(m_nSeries == RXSERIES_COM)
	{
		TRACE(_T("com start\n"));
		m_pVRRefInfo->m_iLodLevel = 2;
		m_pVRFltInfo->m_iLodLevel = 2;
		AssignRenderInfos(RxGetVolumeData(RXSERIES_REF), m_pVRRefInfo);
		AssignRenderInfos(RxGetVolumeData(RXSERIES_FLT), m_pVRFltInfo);

		m_pVRFusAgent->SetAgents(m_pVRRefAgent, m_pVRFltAgent);
		if(m_pVRFusAgent->InitRendering(m_pVRRefInfo, m_pVRFltInfo))
			m_pbyFinalImage = m_pVRFusAgent->Render(m_pVRRefInfo, m_pVRFltInfo);
		TRACE(_T("com end\n"));
	}

	if(m_pbyFinalImage)
		return TRUE;
	else 
		return FALSE;
}

/////////////////////////////////////////////
// render info

RxMatrix4D RxFMWndVR::MakeViewingMatrix(RxVolumeData* pVolumeData)
{
	RxMatrix4D view;

	int x,y,z;
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);

	// 吝缴 颗扁绊
	view.LoadIdentity();
	view.Translate( -x/2, -y/2, -z/2);
	view.Scale(1., 1., pVolumeData->m_fRatioZ);

	// 雀傈 饶
	float fZoom = 0.01f * float(theFMDocVR.m_iVRZoomFactor);
	view.Scale(fZoom,fZoom,fZoom);
	view = m_mxRotation * view;

	// 捞固瘤 乞搁俊 嘿烙
	view.Translate(m_szWindow.cx/2+m_ptPan.x, m_szWindow.cy/2+m_ptPan.y, 0);
	return view;
}

BOOL RxFMWndVR::PerformRotateByOffset(CPoint offset)
{
	int iMaxOffset = max( abs(offset.x), abs(offset.y));
	if(iMaxOffset < 2)
		return FALSE;

	if ( abs(offset.x) > abs(offset.y)) {
		double yDegree = -1.*offset.x/MOUSE_SCALE_FACTOR;
		m_mxRotation.Rotate(1, yDegree);	// Y_AXIS
	}
	else {
		double xDegree = 1.*offset.y/MOUSE_SCALE_FACTOR;	
		m_mxRotation.Rotate(0, xDegree);	// X_AXIS
	}
	return TRUE;
}

void RxFMWndVR::SetChangedOTF(void *pTable)
{
	ASSERT(pTable);
	RxGetVolumeData(m_nSeries)->GetVoxelShader()->SetSpectrumTable((__m128*)pTable);

	RedrawWnd(TRUE);
}

// input: 0-100
// info俊绰 volume谅钎拌肺 函券秦辑 傈崔
void RxFMWndVR::SetCropRange(int iMin, int iMax, int iAxis)
{
	ASSERT(0 <= iAxis && iAxis <= 2);
	ASSERT(0 <= iMin && iMin <= iMax && iMax <= 100);

	int		rx = 0, ry = 0, rz = 0;
	int		fx = 0, fy = 0, fz = 0;
	RxGetVolumeData(RXSERIES_REF)->GetBigVolumeDmsn(&rx, &ry, &rz);
	RxGetVolumeData(RXSERIES_FLT)->GetBigVolumeDmsn(&fx, &fy, &fz);

	int iMinCoord=0, iMaxCoord=0;
	if(iAxis==0) { // x-axis
		iMinCoord = (rx-1) * iMin / 100;
		iMaxCoord = (rx-1) * iMax / 100;
		m_pVRRefInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// ref绰 crop捞 官柴

		m_pVRFltInfo->SetRefCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 ref狼 康开阑 函版

		iMinCoord = (fx-1) * iMin / 100;
		iMaxCoord = (fx-1) * iMax / 100;
		m_pVRFltInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 crop捞 官柴

	} else if(iAxis==1) { // y-axis
		iMinCoord = (ry-1) * iMin / 100;
		iMaxCoord = (ry-1) * iMax / 100;
		m_pVRRefInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// ref绰 crop捞 官柴
		m_pVRFltInfo->SetRefCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 ref狼 康开阑 函版

		iMinCoord = (fy-1) * iMin / 100;
		iMaxCoord = (fy-1) * iMax / 100;
		m_pVRFltInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 crop捞 官柴
	} else if(iAxis==2) { // z-axis
		iMinCoord = (rz-1) * (100-iMax) / 100;
		iMaxCoord = (rz-1) * (100-iMin) / 100;
		m_pVRRefInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// ref绰 crop捞 官柴
		m_pVRFltInfo->SetRefCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 ref狼 康开阑 函版

		iMinCoord = (fz-1) * (100-iMax) / 100;
		iMaxCoord = (fz-1) * (100-iMin) / 100;

		m_pVRFltInfo->SetCropRange(iMinCoord, iMaxCoord, iAxis);	// flt绰 crop捞 官柴		
	}

	m_pVRFltInfo->MakeBoundingBox(m_mxRegistration, rx, ry, rz);

	RedrawWnd(TRUE);
}

/*  Ho's contribution
	RxTransform3DInfo *pTransform = pVRInfo->GetTransform3DInfo();
	m_mxRegistration.LoadIdentity();
	m_mxRegistration.Translate(-x/2, -y/2, -z/2);
	m_mxRegistration.Scale(1.0f,1.0f,lfZFltRatio);
	m_mxRegistration.Scale(pTransform->xscale,pTransform->yscale,pTransform->zscale);
	m_mxRegistration.Rotate(0, pTransform->xrot);
	m_mxRegistration.Rotate(1, pTransform->yrot);
	m_mxRegistration.Rotate(2, pTransform->zrot);
	m_mxRegistration.Translate(pTransform->xmove,pTransform->ymove,pTransform->zmove);
	m_mxRegistration.Scale(1.0f,1.0f,1/lfZFltRatio);
	m_mxRegistration.Translate(x/2, y/2, z/2);
*/

BOOL RxFMWndVR::AssignRenderInfos(RxVolumeData* pVolumeData, RxRayCastingCommonInfo *pVRInfo)
{
	ASSERT(pVolumeData && pVRInfo);

	int x,y,z;
	int refX, refY, refZ;
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	RxGetVolumeData(RXSERIES_REF)->GetBigVolumeDmsn(&refX, &refY, &refZ);
	double dX, dY, dZ;
	pVolumeData->GetVoxelSize(&dX, &dY, &dZ);
	double lfZFltRatio = dZ/dX;

	CRect	rcClient;
	GetClientRect(rcClient);

	pVRInfo->SetImgSize(CSize(rcClient.Width(), rcClient.Height()) );

//		pVRInfo->SetPixelInc(float(100./m_fZoomFactor));

	RxTransform3DInfo *pTransform = pVRInfo->GetTransform3DInfo();
	m_mxRegistration.LoadIdentity();

	double lfSHx = pTransform->xshear;
	double lfSHy = pTransform->yshear;
	double lfSHz = pTransform->zshear;

	RxMatrix4D SH(1.0, lfSHx, lfSHx, 0.0, 
		lfSHy, 1.0, lfSHy, 0.0,
		lfSHz, lfSHz, 1.0, 0.0,
		0.0, 0.0, 0.0, 1.0);
	RxMatrix4D Temp;

	if (pVRInfo == m_pVRFltInfo)
	{
		m_mxRegistration.Translate(-g_FloatCenX, -g_FloatCenY, g_iFloatBinaryTransZ - g_FloatCenZ);
		m_mxRegistration.Scale(pTransform->xscale,pTransform->yscale,pTransform->zscale*pTransform->xscale);
		m_mxRegistration.Rotate(0, pTransform->xrot);
		m_mxRegistration.Rotate(1, pTransform->yrot);
		m_mxRegistration.Rotate(2, pTransform->zrot);

		Temp = m_mxRegistration;
		m_mxRegistration = SH * Temp;

		m_mxRegistration.Translate(g_RefCenX, g_RefCenY, -g_iRefBinaryTransZ + g_RefCenZ);
		float fUnequalZ = (float)(z - refZ)/2.0;
		m_mxRegistration.Translate(pTransform->xmove, pTransform->ymove, pTransform->zmove + fUnequalZ);
	}
	
	m_mxView = MakeViewingMatrix(pVolumeData);
	m_mxRefView = MakeViewingMatrix(RxGetVolumeData(RXSERIES_REF));
	pVRInfo->SetRefViewingMatrix(m_mxRefView);

	pVRInfo->SetViewingMatrix(m_mxView * m_mxRegistration);
	CalcuBoundingBox();

//	pVRInfo->SetWminMaxInImgSpace(m_iWMin-10, m_iWMax+10 );//老何矾 20父怒究 菊 第肺 歹 哗敌促.

	pVRInfo->SetShadingMode(TRUE);
	pVRInfo->Set3DVOI(NULL);
	pVRInfo->SetSculptVolume(NULL);

	RxVoxelShader *pShader = pVolumeData->GetVoxelShader();
	pVRInfo->SetShader(pShader);
	

//	if ( RxGetOptionInfo()->Get3DDisplayHQModeFlag() )
//		pVRInfo->SetGradientMag(RxGetOptionInfo()->Get3DDisplayHQValue());
//	else
		pVRInfo->SetGradientMag(0);

	pVRInfo->SetZoomFactor(100);
	pVRInfo->m_pEditMask = NULL;

	return TRUE;
}

//********************************************************************
//	InitialRigidRegistration(): Intialize rigid-body registration
//							    (by H.Hong)
//********************************************************************
BOOL RxFMWndVR::InitRigidRegistration()
{
	m_SampleMode			= 3;		// 0: uniform 1: random 2: sobel 3: sobel-levoy
	m_SampleNum				= 10;		// number of sampling points
	m_maxIter				= 20;		// maximum iteration (20, 30, 40, 50)
	m_Threshold				= 200;		// threshold for automatic sampling
	m_Tolerance				= 1.0;		// tolerance for automatic sampling
	m_varFloat				= 4.0;		// variance of float image
	m_covarRefer			= 2.0;		// covariance of reference image
	m_covarFloat			= 2.0;		// covariance of float image
	m_etaTrans				= 0.001;	// learning rate for translation (0.001)
	m_etaRot				= 0.0001;	// learning rate for rotation (0.0001)
	m_TransLimit			= 0.01;		// converge limitation of translation (0.01)
	m_RotLimit				= 0.01;		// converge limitation of rotating (0.001)

	m_MIAnalysis			= 1;		// 0: original MI 1: fast MI 2: surface
	m_MIInterpolation		= 2;		// 0: partial volume 1: trilinear 2: nearest neighbor
	
	m_bOutputTransform		= FALSE;

	return TRUE;
}

//********************************************************************
//	RigidRegistration3D_FastMI(): Perform 3D rigid-body registration 
//						          function (by H.Hong)
//********************************************************************
BOOL RxFMWndVR::Subtraction()
{
	BeginWaitCursor();

/*	m_SegmentAgent.Segmentation(0);
	m_SegmentAgent.Segmentation(1);
	RxGetFrameMain()->m_bRefSegmented == true;
	RxGetFrameMain()->m_bFloatSegmented == true;*/

//	g_Reg.m_isREGISTRATION = FALSE;
	// exempt near lung boundaries from following processing.
//	g_Reg.EdgeDilation();
	// POST and PRE histogram except near lung boundaries
//	g_Reg.PrintHistogram(0);
//	g_Reg.SubtractionWithOutReg();

/*	m_pTransformRight->xmove = 0.0;
	m_pTransformRight->ymove = 0.0;
	m_pTransformRight->zmove = 0.0;
	m_pTransformRight->xrot = 0.0;
	m_pTransformRight->yrot = 0.0;
	m_pTransformRight->zrot = 0.0;
	m_pTransformRight->xscale = 1.0;
	m_pTransformRight->yscale = 1.0;
	m_pTransformRight->zscale = 1.0;	
	m_pTransformRight->xshear = 0.0;
	m_pTransformRight->yshear = 0.0;
	m_pTransformRight->zshear = 0.0;
	m_pTransformLeft->xmove = 0.0;
	m_pTransformLeft->ymove = 0.0;
	m_pTransformLeft->zmove = 0.0;
	m_pTransformLeft->xrot = 0.0;
	m_pTransformLeft->yrot = 0.0;
	m_pTransformLeft->zrot = 0.0;
	m_pTransformLeft->xscale = 1.0;
	m_pTransformLeft->yscale = 1.0;
	m_pTransformLeft->zscale = 1.0;	
	m_pTransformLeft->xshear = 0.0;
	m_pTransformLeft->yshear = 0.0;
	m_pTransformLeft->zshear = 0.0;*/

//	g_nDistanc