rxlocalizermanager.cpp

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

		for(i = 0 ; i < m_szDib[iLocalizer].cy; i++) 
			for(j=0; j< m_szDib[iLocalizer].cx; j++)
				lpImageRef[i*m_szDib[iLocalizer].cx+j] = wht * m_pbyBufRef[iLocalizer][i*m_szDib[iLocalizer].cx+j];
				//lpTemp[i*m_szDib[iLocalizer].cx+j] = wht * m_pbyBufRef[iLocalizer][i*m_szDib[iLocalizer].cx+j];
		
		//MultiplyScale((BYTE*)lpTemp, (BYTE*)lpImageRef, CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 1.0f); 
		//GetDIBColor(m_pusBufRef[iLocalizer], lpImageRef, (__m128 *) m_pRefColorTable, iSize, (float) 1.0);
		GetDIBColor(m_pusBufFlt[iLocalizer], lpImageFlt, (__m128 *) m_pFltColorTable, iSize, (float) 1.0);
		FusionImages((BYTE*)lpImageRef, (BYTE*)lpImageFlt, (BYTE*)lpImage, CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), m_fRatioRef, 1.0f - m_fRatioRef);
	}
	else if (m_iInterleaving == 1){ // pixel interleaving
		// for gray
		for(i = 0 ; i < m_szDib[iLocalizer].cy; i++) 
			for(j=0; j< m_szDib[iLocalizer].cx; j++)
				lpTemp[i*m_szDib[iLocalizer].cx+j] = wht * m_pbyBufRef[iLocalizer][i*m_szDib[iLocalizer].cx+j];
		
		MultiplyScale((BYTE*)lpTemp, (BYTE*)lpImageRef, CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 0.7f);
		//GetDIBColor(m_pusBufRef[iLocalizer], lpImageRef, (__m128 *) m_pRefColorTable, iSize, 0.7f);
		GetDIBColor(m_pusBufFlt[iLocalizer], lpImageFlt, (__m128 *) m_pFltColorTable, iSize, 0.7f);
		
		BOOL bRefFirst = TRUE; // j啊 8狼 硅荐肺 官拆锭付促 茄锅究 函窃.
		int iGrid = m_szDib[iLocalizer].cx / 8;
		int iW = m_szDib[iLocalizer].cx/iGrid;
		int iH = m_szDib[iLocalizer].cy/iGrid;
		int idW = m_szDib[iLocalizer].cx - iW*iGrid;
		int idH = m_szDib[iLocalizer].cy - iH*iGrid;
		int iTemp;

		for(j = 0 ; j < iH; j ++) {
			for(i = 0; i < iW; i ++){ 
				iTemp = i & 0x01;
				if ((bRefFirst && !iTemp) || (!bRefFirst && iTemp)) // heewon if(bRefFirst != iTemp)
					for (y = 0; y < iGrid; y++){
						for (x = 0; x < iGrid; x++){
							iTemp = (j*iGrid + y) * m_szDib[iLocalizer].cx + (i*iGrid + x);
							ASSERT(iTemp < iSize);
							lpImage[iTemp] = lpImageRef[iTemp];
						}
					}
				else 			
					for (y = 0; y < iGrid; y++){
						for (x = 0; x < iGrid; x++){
							iTemp = (j*iGrid + y) * m_szDib[iLocalizer].cx + (i*iGrid + x);
							ASSERT(iTemp < iSize);
							lpImage[iTemp] = lpImageFlt[iTemp];
						}
					}
			}

			for (i = iW*iGrid ; i < m_szDib[iLocalizer].cx; i++){
				if ((bRefFirst && !iTemp) || (!bRefFirst && iTemp))
					for (y = 0; y < iGrid; y++){
						for (x = 0; x < idW; x++){
							iTemp = (j*iGrid + y) * m_szDib[iLocalizer].cx + (i + x);
							ASSERT(iTemp < iSize);
							lpImage[iTemp] = lpImageFlt[iTemp];
						}
					}
				else 			
					for (y = 0; y < iGrid; y++){
						for (x = 0; x < idW; x++){
							iTemp = (j*iGrid + y) * m_szDib[iLocalizer].cx + (i + x);
							ASSERT(iTemp < iSize);
							lpImage[iTemp] = lpImageRef[iTemp];
						}
					}
			}

			if (bRefFirst) bRefFirst = FALSE;	// heewon bRefFirst = !bRefFirst
			else bRefFirst = TRUE;
		}

		for(j = m_szDib[iLocalizer].cy-idH ; j < m_szDib[iLocalizer].cy; j ++) {
			for(i = 0; i < iW; i ++){ 
				iTemp = i & 0x01;
				if ((bRefFirst && !iTemp) || (!bRefFirst && iTemp))
					for (x = 0; x < iGrid; x++){
						iTemp = j * m_szDib[iLocalizer].cx + (i*iGrid + x);
						ASSERT(iTemp < iSize);
						lpImage[iTemp] = lpImageRef[iTemp];
					}
				else 			
					for (x = 0; x < iGrid; x++){
						iTemp = j * m_szDib[iLocalizer].cx + (i*iGrid + x);
						ASSERT(iTemp < iSize);
						lpImage[iTemp] = lpImageFlt[iTemp];
					}
			}

			for (i = iW*iGrid; i<m_szDib[iLocalizer].cx; i++){
				if ((bRefFirst && !iTemp) || (!bRefFirst && iTemp))
					for (x = 0; x < idW; x++){
						iTemp = j * m_szDib[iLocalizer].cx + (i + x);
						ASSERT(iTemp < iSize);
						lpImage[iTemp] = lpImageFlt[iTemp];
					}
				else 			
					for (x = 0; x < idW; x++){
						iTemp = j * m_szDib[iLocalizer].cx + (i + x);
						ASSERT(iTemp < iSize);
						lpImage[iTemp] = lpImageRef[iTemp];
					}
			}
		}
	}
	else if (m_iInterleaving == 2 && (m_szDib[iLocalizer].cx * m_szDib[iLocalizer].cy != 0)){ // edge interleaving
		RxxFilters Filter;
		LPBYTE pbyCanny;
		pbyCanny = Filter.CannyProcessing(m_pusBufRef[iLocalizer], m_szDib[iLocalizer].cx, m_szDib[iLocalizer].cy);
		
		for (j = 0; j< m_szDib[iLocalizer].cy; j++){
			for (i = 0; i< m_szDib[iLocalizer].cx; i++){
				iIndex = j*m_szDib[iLocalizer].cx+i;
				if (pbyCanny[iIndex])
					lpTemp[iIndex] = wht * m_pbyBufRef[iLocalizer][iIndex];
				else
					lpTemp[iIndex] = 0;
			}
		}

		MultiplyScale((BYTE*)lpTemp, (BYTE*)lpImageRef, CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 1.0);
		GetDIBColor(m_pusBufFlt[iLocalizer], lpImageFlt, (__m128 *) m_pFltColorTable, iSize, (float) 1.0);
		FusionImages((BYTE*)lpImageRef, (BYTE*)lpImageFlt, (BYTE*)lpImage, CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), m_fRatioRef, 1.0f - m_fRatioRef);
		delete [] pbyCanny;
	}

	delete [] lpTemp;
	delete pDibRef;
	delete pDibFlt;

	return pDib;
}

BOOL RxLocalizerManager::SetChangedOTF(void *pTable)
{
	switch(m_iRFCNum){
	case 0:
		m_pRefColorTable = pTable;
		break;
	case 1:
		m_pFltColorTable = pTable;
		break;
	case 2:
		return FALSE;
	}
	return TRUE;
}
		

BOOL RxLocalizerManager::IsPtInVolume(RxPoint3D<double> ptVol, int iMode)
{
	int x = 0 , y = 0, z = 0;
	RxVolumeData* pVolumeData;
	pVolumeData = RxGetVolumeData(iMode);
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	z = pVolumeData->GetInterpolatedSliceNum();
	
	if (ptVol.x < 1 || ptVol.x > x - 1 || ptVol.y < 1 || ptVol.y > y - 1 || ptVol.z < 1 || ptVol.z > z - 1)
		return FALSE;

	return TRUE;
}

float RxLocalizerManager::GetTLSample(RxPoint3D<double> ptVol, int iMode)
{
	RxVolumeData* pVolumeData;
	pVolumeData = RxGetVolumeData(iMode);
	unsigned short * pnVolume = pVolumeData->GetOriginalVolume();

	float fRatio = (float)pVolumeData->m_fRatioZ;

	int iMaxX, iMaxY, iMaxZ;
	pVolumeData->GetBigVolumeDmsn(&iMaxX, &iMaxY, &iMaxZ);

	ASSERT(fRatio != 0.0);

	float x,y,z,tx, ty, tz, txc, tyc;
	x = (float)ptVol.x;
	y = (float)ptVol.y;
	z = (float)ptVol.z;

	z/=(float)fRatio;
	int ix, iy, iz;
	int *rix = m_piIdx[iMode][0], *riy = m_piIdx[iMode][1], *riz = m_piIdx[iMode][2];

	ix = FloatToInt(x);
	iy = FloatToInt(y);
	iz = FloatToInt(z);

	tx = x-ix;
	ty = y-iy;
	tz = z-iz;

	txc = 1.f-tx;
	tyc = 1.f-ty;

	if (iz < iMaxZ - 1)
	return
		(((IntToFloat(pnVolume[rix[ix] + riy[iy] + riz[iz]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy] + riz[iz]]) * tx) * tyc +
		(IntToFloat(pnVolume[rix[ix] + riy[iy+1] + riz[iz]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy+1] + riz[iz]]) * tx) * ty) * (1 - tz) +
		((IntToFloat(pnVolume[rix[ix] + riy[iy] + riz[iz+1]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy] + riz[iz+1]]) * tx) * tyc +
		(IntToFloat(pnVolume[rix[ix] + riy[iy+1] + riz[iz+1]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy+1] + riz[iz+1]]) * tx) * ty) * tz);

	return 
		(((IntToFloat(pnVolume[rix[ix] + riy[iy] + riz[iz]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy] + riz[iz]]) * tx) * tyc +
		(IntToFloat(pnVolume[rix[ix] + riy[iy+1] + riz[iz]]) * txc +
		IntToFloat(pnVolume[rix[ix+1] + riy[iy+1] + riz[iz]]) * tx) * ty));
}

int RxLocalizerManager::GetNNSample(RxPoint3D<double> ptVol, int iMode)
{
	RxVolumeData* pVolumeData;
	pVolumeData = RxGetVolumeData(iMode);
	unsigned short * pnVolume = pVolumeData->GetOriginalVolume();

	float fRatio = (float)pVolumeData->m_fRatioZ;
	ASSERT(fRatio != 0.0);

	float x,y,z;
	x = (float)ptVol.x;
	y = (float)ptVol.y;
	z = (float)ptVol.z;

	z/=(float)fRatio;
	int ix, iy, iz;
	int *rix = m_piIdx[iMode][0], *riy = m_piIdx[iMode][1], *riz = m_piIdx[iMode][2];

	ix = FloatToInt(x);
	iy = FloatToInt(y);
	iz = FloatToInt(z);

	return
		(int)pnVolume[rix[ix] + riy[iy] + riz[iz]];
}

void RxLocalizerManager::RedrawAll(BOOL bUpdate)
{
	if (m_pLocalizer[RX_AXIAL])
		m_pLocalizer[RX_AXIAL]->Redraw(bUpdate);
	if (m_pLocalizer[RX_CORONAL])
		m_pLocalizer[RX_CORONAL]->Redraw(bUpdate);
	if (m_pLocalizer[RX_SAGITTAL])
		m_pLocalizer[RX_SAGITTAL]->Redraw(bUpdate);
}

void RxLocalizerManager::ResampleAll()
{
	if (m_pLocalizer[RX_AXIAL])
		m_pLocalizer[RX_AXIAL]->ResampleBasicMPR();
	if (m_pLocalizer[RX_CORONAL])
		m_pLocalizer[RX_CORONAL]->ResampleBasicMPR();
	if (m_pLocalizer[RX_SAGITTAL])
		m_pLocalizer[RX_SAGITTAL]->ResampleBasicMPR();
}

void RxLocalizerManager::ResampleAfterFusion(int iLocal)
{
	RxDib *pDib = NULL;
	switch(iLocal){
	case RX_AXIAL:
		pDib = MakeFusionDib(RX_AXIAL);
		m_pLocalizer[RX_AXIAL]->RedrawForFusion(pDib);
		break;
	case RX_CORONAL:
		pDib = MakeFusionDib(RX_CORONAL);
		m_pLocalizer[RX_CORONAL]->RedrawForFusion(pDib);
		break;
	case RX_SAGITTAL:
		pDib = MakeFusionDib(RX_SAGITTAL);
		m_pLocalizer[RX_SAGITTAL]->RedrawForFusion(pDib);
		break;
	}
}


void RxLocalizerManager::MaximizeView(int iViewMode)
{
	int iZoomFactor;

	switch (iViewMode) {
	case IDF_MAIN_WND_3DLOCALA_R:
	case IDF_MAIN_WND_3DLOCALA_F:
	case IDF_MAIN_WND_3DLOCALA_C:
		iZoomFactor = m_pLocalizer[RX_AXIAL]->CalcZoomFactor();
		RxFMWndLocalizer::SetZoomFactor(iZoomFactor);
		m_pLocalizer[RX_AXIAL]->Redraw(TRUE);
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		iZoomFactor = m_pLocalizer[RX_SAGITTAL]->CalcZoomFactor();
		RxFMWndLocalizer::SetZoomFactor(iZoomFactor);
		m_pLocalizer[RX_SAGITTAL]->Redraw(TRUE);
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		iZoomFactor = m_pLocalizer[RX_CORONAL]->CalcZoomFactor();
		RxFMWndLocalizer::SetZoomFactor(iZoomFactor);
		m_pLocalizer[RX_CORONAL]->Redraw(TRUE);
		break;
	}
}

// 泅犁 maximize 等 惑怕俊辑绰 焊捞瘤 臼绰 滴俺狼 扩档快档 弊妨具 窍绰 坷滚庆靛啊 乐促. 荐沥夸噶.
void RxLocalizerManager::ChangeZoomFactor(int iOldZF, int iNewZF)
{
	m_pLocalizer[RX_AXIAL]->UpdateByZoomChange(iOldZF, iNewZF);
	m_pLocalizer[RX_CORONAL]->UpdateByZoomChange(iOldZF, iNewZF);
	m_pLocalizer[RX_SAGITTAL]->UpdateByZoomChange(iOldZF, iNewZF);

	switch(m_iRFCNum){
	case 0:
	case 1:
	case 2:
		m_pLocalizer[RX_AXIAL]->Redraw(TRUE);
		m_pLocalizer[RX_CORONAL]->Redraw(TRUE);
		m_pLocalizer[RX_SAGITTAL]->Redraw(TRUE);
		break;
	}
}

void RxLocalizerManager::ChangeXYZIndex(int iXYZ)
{
	if (iXYZ & RX_MPR_X)
		m_pLocalizer[RX_SAGITTAL]->ResampleBasicMPR();
	else
		m_pLocalizer[RX_SAGITTAL]->Redraw();

	if (iXYZ & RX_MPR_Y)
		m_pLocalizer[RX_CORONAL]->ResampleBasicMPR();
	else
		m_pLocalizer[RX_CORONAL]->Redraw();

	if (iXYZ & RX_MPR_Z)
		m_pLocalizer[RX_AXIAL]->ResampleBasicMPR();
	else
		m_pLocalizer[RX_AXIAL]->Redraw();
}

void RxLocalizerManager::ChangeXYZIndexForFusion(int iXYZ)
{
	if (iXYZ & RX_MPR_X)
		m_pLocalizer[RX_SAGITTAL]->RedrawForFusion(MakeFusionDib(RX_SAGITTAL));
	else
		m_pLocalizer[RX_SAGITTAL]->RedrawForFusion(NULL);

	if (iXYZ & RX_MPR_Y)
		m_pLocalizer[RX_CORONAL]->RedrawForFusion(MakeFusionDib(RX_CORONAL));
	else
		m_pLocalizer[RX_CORONAL]->RedrawForFusion(NULL);

	if (iXYZ & RX_MPR_Z)
		m_pLocalizer[RX_AXIAL]->RedrawForFusion(MakeFusionDib(RX_AXIAL));
	else
		m_pLocalizer[RX_AXIAL]->RedrawForFusion(NULL);
}


void RxLocalizerManager::RaysumBtnsToRawBtns()
{
	ChangeXYZIndex(RX_MPR_X | RX_MPR_Y | RX_MPR_Z);
}

void RxLocalizerManager::RawBtnsToRaysumBtns(int iThickness)
{
	ChangeXYZIndex(RX_MPR_X | RX_MPR_Y | RX_MPR_Z);
}

void RxLocalizerManager::Reset(int iTag)
{
	//windowing篮 3DOutlineView俊辑 reset登菌澜
	ResetImagePanOffset();
	DetermineZoomFactor();
	m_pMPRAgent->Reset();

	if(!m_pLocalizer[RX_AXIAL]->m_bAfterFusion)
		ResampleAll();

	switch (iTag){
	case 0 :
		RedrawAll(TRUE);
		break;
	case 1:
		m_pLocalizer[RX_AXIAL]->Redraw(TRUE);
		break;
	case 2:
		m_pLocalizer[RX_CORONAL]->Redraw(TRUE);
		break;
	case 3:
		m_pLocalizer[RX_SAGITTAL]->Redraw(TRUE);
		break;
	}
}

void RxLocalizerManager::ResetImagePanOffset()
{
	m_pLocalizer[RX_AXIAL]->SetImagePanOffset(CPoint(0, 0));
	m_pLocalizer[RX_CORONAL]->SetImagePanOffset(CPoint(0, 0));
	m_pLocalizer[RX_SAGITTAL]->SetImagePanOffset(CPoint(0, 0));
}


BOOL RxLocalizerManager::CursorInViews()
{
	POINT ptMouse;
	CRect rcClient;
	BOOL bInViews = FALSE;

	::GetCursorPos(&ptMouse);
	m_pLocalizer[RX_AXIAL]->GetClientRect(rcClient);
	m_pLocalizer[RX_AXIAL]->ClientToScreen(rcClient);
	bInViews = bInViews || rcClient.PtInRect(ptMouse);

	m_pLocalizer[RX_CORONAL]->GetClientRect(rcClient);
	m_pLocalizer[RX_CORONAL]->ClientToScreen(rcClient);
	bInViews = bInViews || rcClient.PtInRect(ptMouse);

	m_pLocalizer[RX_SAGITTAL]->GetClientRect(rcClient);
	m_pLocalizer[RX_SAGITTAL]->ClientToScreen(rcClient);
	bInViews = bInViews || rcClient.PtInRect(ptMouse);

	return bInViews;
}

void RxLocalizerManager::SetLoadedSeriesNum(int iRFC)
{
	m_iRFCNum = iRFC;
}

void RxLocalizerManager::MouseWheelManager(int iASC, short nDiff)
{
	int iIndex;
	switch(iASC){
	case 0:
		iIndex = m_pLocalizer[RX_CORONAL]->GetVIndex();
		iIndex -= nDiff;
		m_pLocalizer[RX_CORONAL]->SetVIndex(iIndex);
		m_pLocalizer[RX_CORONAL]->AdjustVolIndexFromVIndex();
		break;
	case 1:
		iIndex = m_pLocalizer[RX_AXIAL]->GetHIndex();
		iIndex -= nDiff;
		m_pLocalizer[RX_AXIAL]->SetHIndex(iIndex);
		m_pLocalizer[RX_AXIAL]->AdjustVolIndexFromHIndex();
		break;
	case 2:
		iIndex = m_pLocalizer[RX_AXIAL]->GetVIndex();
		iIndex -= nDiff;
		m_pLocalizer[RX_AXIAL]->SetVIndex(iIndex);
		m_pLocalizer[RX_AXIAL]->AdjustVolIndexFromVIndex();
		break;
	}
}