rxlocalizermanager.cpp

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

#include "stdafx.h"
#include "fusion.h"
#include "fusionglobal.h"
#include "volumedata.h"
#include "fusiondefine.h"
#include "fusionenum.h"
#include "RxLocalizerManager.h"
#include "Transform3DInfo.h"
#include "fastinlinefuncs.h"
#include "dib.h"
#include "Filters.h"

CSize RxLocalizerManager::m_szLocalizer[3] = {CSize(0, 0), CSize(0, 0), CSize(0, 0)};
CSize RxLocalizerManager::m_szLocalizerCombine[3] = {CSize(0, 0), CSize(0, 0), CSize(0, 0)};
void* RxLocalizerManager::m_pRefColorTable = NULL;
void* RxLocalizerManager::m_pFltColorTable = NULL;
extern BOOL FusionImagesBYTE(BYTE *pBackgroundImage, BYTE *pForegroundImage, BYTE *pOutputImage, CSize szImage, float fBackWeight);
extern BOOL FusionImages(BYTE *pBackgroundImage, BYTE *pForegroundImage, BYTE *pOutputImage, CSize szImage, float fBackWeight, float fFrontWeight);
extern BOOL GetDIBColor(unsigned short *pSrc, unsigned int *pDst, __m128 *pPallete, int nPixelNum, float fWeight);
extern BOOL MultiplyScale(BYTE *pInputImage, BYTE *pOutputImage, CSize szImage, float fWeight);

// 酒贰 滴 窃荐绰 frame main俊辑 localizermanager 积己且 锭 鞘夸茄 何盒捞促.
RxLocalizerManager::RxLocalizerManager(int iRFC)
{
	m_iRFCNum = iRFC;
	m_iInterleaving = 0;
	m_fRatioRef = 0.5f;
	m_pMPRAgent = new RxMPRAgent(iRFC);
	m_pLocalizer[RX_AXIAL] = m_pLocalizer[RX_CORONAL] = m_pLocalizer[RX_SAGITTAL] = NULL;
	m_bModeFirst = TRUE;

	for (int i = 0; i<2;i++)
		for (int j = 0; j < 3; j++)
			m_piIdx[i][j] = NULL;

	for (int k = 0; k<3; k++){
		m_pusBufRef[k] = NULL;
		m_pusBufFlt[k] = NULL;
		m_pbyBufRef[k] = NULL;
		m_pbyBufFlt[k] = NULL;
	}
}

void RxLocalizerManager::Attach3ViewsToManager(RxFMWndLocalizer *pAxial, RxFMWndLocalizer *pCoronal, RxFMWndLocalizer *pSagittal)
{
	if (m_bModeFirst) {
		m_pLocalizer[RX_AXIAL] = pAxial;
		m_pLocalizer[RX_CORONAL] = pCoronal;
		m_pLocalizer[RX_SAGITTAL] = pSagittal;

		m_bModeFirst = FALSE;
	}
}
/////////////////////////////////////////////////////

RxLocalizerManager::~RxLocalizerManager()
{
	InitBuffers(RX_AXIAL);
	InitBuffers(RX_CORONAL);
	InitBuffers(RX_SAGITTAL);

	if (m_pMPRAgent)
		delete m_pMPRAgent;

	for (int i = 0; i<2;i++)
		for (int j = 0; j < 3; j++)
			if (m_piIdx[i][j])
				delete [] m_piIdx[i][j];


}

// load 啊 场唱绊 檬扁拳甫 秦林绰 何盒捞促. 杭俘 单捞磐啊 付访登绢乐促绰 傈力窍俊..
void RxLocalizerManager::InitView_MPRAgent()
{
	int iVolX, iVolY, iVolZ, iSliceNum;

	if (m_iRFCNum != COMBINED_MODE){
		RxVolumeData* pVolumeData = RxGetVolumeData(m_iRFCNum);
		pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
		iVolZ = pVolumeData->GetInterpolatedSliceNum();

		m_pMPRAgent->SetVolumeInfo(iVolX, iVolY, iVolZ);
		m_pMPRAgent->MakeReferenceTable();

		m_pLocalizer[RX_AXIAL]->InitLocalizer();
		m_pLocalizer[RX_CORONAL]->InitLocalizer();
		m_pLocalizer[RX_SAGITTAL]->InitLocalizer();
		
		DetermineZoomFactor();
		
		m_pLocalizer[RX_AXIAL]->ResampleBasicMPR();
		m_pLocalizer[RX_CORONAL]->ResampleBasicMPR();
		m_pLocalizer[RX_SAGITTAL]->ResampleBasicMPR();
	}
	else{
		int mw, mh;
		//reference
		RxVolumeData* pVolumeData = RxGetVolumeData(REFERENCE_MODE);
		pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
		iVolZ = pVolumeData->GetInterpolatedSliceNum();
		m_pMPRAgent->SetVolumeInfo(iVolX, iVolY, iVolZ);
		m_pMPRAgent->MakeReferenceTable();
		m_pLocalizer[RX_AXIAL]->InitLocalizer();
		m_pLocalizer[RX_CORONAL]->InitLocalizer();
		m_pLocalizer[RX_SAGITTAL]->InitLocalizer();
		DetermineZoomFactor();
		m_pLocalizer[RX_AXIAL]->ResampleBasicMPR();
		m_pLocalizer[RX_CORONAL]->ResampleBasicMPR();
		m_pLocalizer[RX_SAGITTAL]->ResampleBasicMPR();

		int iZTableSize = __max(iSliceNum, iVolZ);

		for (int i = 0; i < 2; i++)
			for (int j = 0; j < 3; j++)
				if (m_piIdx[i][j]) {
					delete [] m_piIdx[i][j];
					m_piIdx[i][j] = NULL;
				}

		m_piIdx[REFERENCE_MODE][0] = new int[iVolX + 1];
		m_piIdx[REFERENCE_MODE][1] = new int[iVolY + 1];
		m_piIdx[REFERENCE_MODE][2] = new int[iZTableSize];
		
		mw = iVolX;
		mh = iVolY;

		for (i=0;i<iVolX + 1;i++)  // x index
			m_piIdx[REFERENCE_MODE][0][i] = i;

		for (i=0;i<iVolY + 1;i++)  // y index
			m_piIdx[REFERENCE_MODE][1][i] = i * mw;

		for (i=0;i<iZTableSize;i++)  // z index, interpolated 谅钎俊辑档 荤侩且 荐 乐促
			m_piIdx[REFERENCE_MODE][2][i] = i * mw * mh;


		//float
		pVolumeData = RxGetVolumeData(FLOAT_MODE);
		pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
		iVolZ = pVolumeData->GetInterpolatedSliceNum();

		iZTableSize = __max(iSliceNum, iVolZ);
		m_piIdx[FLOAT_MODE][0] = new int[iVolX + 1];
		m_piIdx[FLOAT_MODE][1] = new int[iVolY + 1];
		m_piIdx[FLOAT_MODE][2] = new int[iZTableSize];

		mw = iVolX;
		mh = iVolY;

		for (i=0;i<iVolX + 1;i++)  // x index
			m_piIdx[FLOAT_MODE][0][i] = i;

		for (i=0;i<iVolY + 1;i++)  // y index
			m_piIdx[FLOAT_MODE][1][i] = i * mw;

		for (i=0;i<iZTableSize;i++)  // z index, interpolated 谅钎俊辑档 荤侩且 荐 乐促
			m_piIdx[FLOAT_MODE][2][i] = i * mw * mh;
	}
}

void RxLocalizerManager::DetermineZoomFactor()
{
	int iZoomFactor;
	int iAxialZF, iCoronalZF, iSagittalZF;

	// Zoom factor甫 悼老窍霸 嘎冕促.
	// 唱吝俊 maximize扁瓷捞 眠啊登搁 ploutos upgrade甫 曼炼窍咯 促矫 coding 秦具 且巴.
	// 泅犁绰 芒 农扁啊 函拳凳俊 蝶扼 淋登绰 沥档甫 螟沥茄促.
	iAxialZF = m_pLocalizer[RX_AXIAL]->CalcZoomFactor();
	iCoronalZF = m_pLocalizer[RX_CORONAL]->CalcZoomFactor();
	iSagittalZF = m_pLocalizer[RX_SAGITTAL]->CalcZoomFactor();
	if (!iAxialZF * iCoronalZF * iSagittalZF)
		return;
	iZoomFactor = __min(iAxialZF, __min(iCoronalZF, iSagittalZF));
	ASSERT(iZoomFactor != 0);
	RxFMWndLocalizer::SetZoomFactor(iZoomFactor);
}


void RxLocalizerManager::SetRegistrationMatrix(RxTransform3DInfo *pTransform)
{
/*
RxMatrix4D m_mxRegistration, m_mxInverse;

RxFMWndVR* pFMWndVR = RxGetFrameMain()->m_pFMWndVR[2];
RxTransform3DInfo *pTransform = pFMWndVR->m_pTransform;

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;

m_mxRegistration.LoadIdentity();
m_mxRegistration.Translate(-g_FloatCenX, -g_FloatCenY, -g_FloatCenZ + g_iFloatBinaryTransZ);
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);

Temp = m_mxRegistration;
m_mxRegistration = SH * Temp;

m_mxRegistration.Translate(g_RefCenX + pTransform->xmove, g_RefCenY + pTransform->ymove, g_RefCenZ + pTransform->zmove - g_iRefBinaryTransZ);
*/
	
	RxMatrix4D Mreg;
	int x,y,z,refZ,floatZ;
	double dX, dY, dZ; // added by Ho Lee
	
	RxVolumeData* pVolumeData = RxGetVolumeData(FLOAT_MODE);
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	floatZ = z;
	pVolumeData->GetVoxelSize(&dX, &dY, &dZ); // added by Ho Lee
	double lfZFltRatio = dZ/dX; // added by Ho Lee

	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;

	Mreg.Translate(-g_FloatCenX, -g_FloatCenY, -g_FloatCenZ*lfZFltRatio + g_iFloatBinaryTransZ*lfZFltRatio);
	Mreg.Scale(pTransform->xscale,pTransform->yscale,pTransform->zscale*pTransform->xscale); // zscale阑 官层林电瘤 趣篮, 咯扁辑 官层林带瘤
	Mreg.Rotate(0, pTransform->xrot);
	Mreg.Rotate(1, pTransform->yrot);
	Mreg.Rotate(2, pTransform->zrot);

	Temp = Mreg;
	Mreg = SH * Temp;

	pVolumeData = RxGetVolumeData(REFERENCE_MODE);
	pVolumeData->GetBigVolumeDmsn(&x, &y, &z);
	refZ = z;
	pVolumeData->GetVoxelSize(&dX, &dY, &dZ);
	double lfZRefRatio = dZ/dX;

	Mreg.Translate(g_RefCenX + pTransform->xmove, g_RefCenY + pTransform->ymove, g_RefCenZ*lfZRefRatio + pTransform->zmove*lfZRefRatio - g_iRefBinaryTransZ*lfZRefRatio);

	m_mxInversReg = Mreg.Inverse();

	CWaitCursor wait;

	RxDib *pDib1 = MakeFusionDib(RX_AXIAL);
	RxDib *pDib2 = MakeFusionDib(RX_CORONAL);
	RxDib *pDib3 = MakeFusionDib(RX_SAGITTAL);

	m_pLocalizer[RX_AXIAL]->RedrawForFusion(pDib1);
	m_pLocalizer[RX_CORONAL]->RedrawForFusion(pDib2);
	m_pLocalizer[RX_SAGITTAL]->RedrawForFusion(pDib3);

	wait.Restore();
}

void RxLocalizerManager::ApplyMixingRatio(float fRatioOfRef)
{
	m_fRatioRef = fRatioOfRef;

	m_iInterleaving = m_pLocalizer[RX_AXIAL]->GetInterleavingMode();
	
	if(m_iInterleaving == 1)
		return;

	GetGrayPlaneThruWT(RX_AXIAL);
	GetGrayPlaneThruWT(RX_CORONAL);
	GetGrayPlaneThruWT(RX_SAGITTAL);
	RxDib *pDib1 = MakeDibFromBuffers(RX_AXIAL);
	RxDib *pDib2 = MakeDibFromBuffers(RX_CORONAL);
	RxDib *pDib3 = MakeDibFromBuffers(RX_SAGITTAL);

	m_pLocalizer[RX_AXIAL]->RedrawForFusion(pDib1);
	m_pLocalizer[RX_CORONAL]->RedrawForFusion(pDib2);
	m_pLocalizer[RX_SAGITTAL]->RedrawForFusion(pDib3);
}

RxDib* RxLocalizerManager::MakeFusionDib(int iLocalizer)
{	
	int iWidth = m_szLocalizerCombine[iLocalizer].cx;
	int iHeight = m_szLocalizerCombine[iLocalizer].cy;
	if (iWidth * iHeight == 0)
		return NULL;
	InitBuffers(iLocalizer);
	GetRawPlanes(iLocalizer);
	GetGrayPlaneThruWT(iLocalizer);
	return MakeDibFromBuffers(iLocalizer);
}

void RxLocalizerManager::InitBuffers(int iLocalizer)
{
	if(m_pusBufRef[iLocalizer]){
		delete [] m_pusBufRef[iLocalizer];
		m_pusBufRef[iLocalizer] = NULL;
	}
	if(m_pusBufFlt[iLocalizer]){
		delete [] m_pusBufFlt[iLocalizer];
		m_pusBufFlt[iLocalizer] = NULL;
	}

	if(m_pbyBufRef[iLocalizer]){
		delete [] m_pbyBufRef[iLocalizer];
		m_pbyBufRef[iLocalizer] = NULL;
	}
	if(m_pbyBufFlt[iLocalizer]){
		delete [] m_pbyBufFlt[iLocalizer];
		m_pbyBufFlt[iLocalizer] = NULL;
	}
}

BOOL RxLocalizerManager::GetRawPlanes(int iLocalizer)
{
	int iWndWidth = m_szLocalizerCombine[iLocalizer].cx;
	int iWndHeight = m_szLocalizerCombine[iLocalizer].cy;
	int iTemp;
	if (iWndWidth * iWndHeight == 0)
		return NULL;
	int iNewWndWidth = (iWndWidth + 7) / 8 * 8; 	//8byte allign : 仁朝 捞固瘤 fusion阑 困茄 器籍.
	m_szDib[iLocalizer] = CSize(iNewWndWidth, iWndHeight);
	int iSize = m_szDib[iLocalizer].cx * m_szDib[iLocalizer].cy;
	
	RxPoint3D<double>	volRefI, volRefJ, volRefO, volptRef, volptScan;
	RxPoint3D<double>	volFltI, volFltJ, volFltO, volptFlt; 
	RxPoint3D<double>	ptVolRef, ptVolFlt;
	RxVect4D			vecTemp;
	
	volRefO = m_pLocalizer[iLocalizer]->Img2Vol(CPoint(0,0));
	volRefI = m_pLocalizer[iLocalizer]->Img2Vol(CPoint(1,0));
	volRefJ = m_pLocalizer[iLocalizer]->Img2Vol(CPoint(0,1));

	vecTemp = RxVect4D(volRefO.x, volRefO.y, volRefO.z);
	vecTemp = m_mxInversReg * vecTemp;
	volFltO.x = vecTemp.m[0];
	volFltO.y = vecTemp.m[1];
	volFltO.z = vecTemp.m[2];

	vecTemp = RxVect4D(volRefI.x, volRefI.y, volRefI.z);
	vecTemp = m_mxInversReg * vecTemp;
	volFltI.x = vecTemp.m[0] - volFltO.x;
	volFltI.y = vecTemp.m[1] - volFltO.y;
	volFltI.z = vecTemp.m[2] - volFltO.z;

	vecTemp = RxVect4D(volRefJ.x, volRefJ.y, volRefJ.z);
	vecTemp = m_mxInversReg * vecTemp;
	volFltJ.x = vecTemp.m[0] - volFltO.x;
	volFltJ.y = vecTemp.m[1] - volFltO.y;
	volFltJ.z = vecTemp.m[2] - volFltO.z;

	volRefI = volRefI - volRefO;
	volRefJ = volRefJ - volRefO;

	if(m_pusBufRef[iLocalizer]){
		delete [] m_pusBufRef[iLocalizer];
		m_pusBufRef[iLocalizer] = NULL;
	}

	if(m_pusBufFlt[iLocalizer]){
		delete [] m_pusBufFlt[iLocalizer];
		m_pusBufFlt[iLocalizer] = NULL;
	}

	m_pusBufRef[iLocalizer] = new unsigned short[iSize];
	m_pusBufFlt[iLocalizer] = new unsigned short[iSize];
	memset(m_pusBufRef[iLocalizer], 0, iSize * sizeof(unsigned short));
	memset(m_pusBufFlt[iLocalizer], 0, iSize * sizeof(unsigned short));

	for (int j = 0 ; j < m_szDib[iLocalizer].cy ; j++){
		volptRef = volRefO + volRefJ*j; // scan line狼 贸澜 
		volptFlt = volFltO + volFltJ*j; // scan line狼 贸澜 
		for (int i = 0 ; i < m_szDib[iLocalizer].cx; i++){
			
			// (i,j) : image window 惑狼 谅钎.
			// volptRef : Reference volume 惑狼 谅钎.

			if(IsPtInVolume(volptRef, REFERENCE_MODE)){
				iTemp = m_pusBufRef[iLocalizer][(m_szDib[iLocalizer].cy - j - 1)*m_szDib[iLocalizer].cx + i] = (unsigned short)(GetTLSample(volptRef, REFERENCE_MODE) + 0.5);
			}
			else{	
				volptRef += volRefI;
				volptFlt += volFltI;
				continue;
			}
			
			if(IsPtInVolume(volptFlt, FLOAT_MODE)){
				iTemp = m_pusBufFlt[iLocalizer][(m_szDib[iLocalizer].cy - j - 1)*m_szDib[iLocalizer].cx + i] = (unsigned short)(GetTLSample(volptFlt, FLOAT_MODE) + 0.5);
			}
			volptRef += volRefI;
			volptFlt += volFltI;
		}
	}

	return TRUE;
}

BOOL RxLocalizerManager::GetGrayPlaneThruWT(int iLocalizer)
{
	if(m_pbyBufRef[iLocalizer]){
		delete [] m_pbyBufRef[iLocalizer];
		m_pbyBufRef[iLocalizer] = NULL;
	}

	if(m_pbyBufFlt[iLocalizer]){
		delete [] m_pbyBufFlt[iLocalizer];
		m_pbyBufFlt[iLocalizer] = NULL;
	}

	// for gray
	unsigned char *pWTReference, *pWTFloat;
	pWTReference	= RxGetFrameTuning()->GetWindowingTable(REFERENCE_MODE);
	pWTFloat		= RxGetFrameTuning()->GetWindowingTable(FLOAT_MODE);

	int iSize = m_szDib[iLocalizer].cx * m_szDib[iLocalizer].cy;
	int iIndex;
	
	m_pbyBufRef[iLocalizer] = new BYTE[iSize];
	m_pbyBufFlt[iLocalizer] = new BYTE[iSize];
	memset(m_pbyBufRef[iLocalizer], 0, iSize * sizeof(BYTE));
	memset(m_pbyBufFlt[iLocalizer], 0, iSize * sizeof(BYTE));

	// if 巩栏肺 唱穿绢具 且 累诀鞍促.
	for (int j = 0 ; j < m_szDib[iLocalizer].cy ; j++){
		for (int i = 0 ; i < m_szDib[iLocalizer].cx; i++){
			iIndex = j*m_szDib[iLocalizer].cx + i;
			m_pbyBufRef[iLocalizer][iIndex] = pWTReference[(int)(m_pusBufRef[iLocalizer][iIndex])];
			m_pbyBufFlt[iLocalizer][iIndex] = pWTFloat[(int)(m_pusBufFlt[iLocalizer][iIndex])];
		}
	}
	return TRUE;
}

RxDib* RxLocalizerManager::GetColorImage(unsigned short* pusOriginal, CSize szImage)
{
	int iSize = szImage.cx * szImage.cy;
	RxDib *pDib	= new RxDib(szImage, 32);
	unsigned int* lpImage = (unsigned int*)pDib->m_lpImage;
	GetDIBColor(pusOriginal, lpImage, (__m128 *) m_pFltColorTable, iSize, (float) 1.0);
	return pDib;
}

RxDib* RxLocalizerManager::MakeDibFromBuffers(int iLocalizer)
{
	int i,j,x,y,iIndex;
	int iSize = m_szDib[iLocalizer].cx * m_szDib[iLocalizer].cy;
	RxDib *pDib					= new RxDib(CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 32);
	RxDib *pDibRef				= new RxDib(CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 32);
	RxDib *pDibFlt				= new RxDib(CSize(m_szDib[iLocalizer].cx,m_szDib[iLocalizer].cy), 32);
	unsigned int* lpImage		= (unsigned int*)pDib->m_lpImage;
	unsigned int* lpImageRef	= (unsigned int*)pDibRef->m_lpImage;
	unsigned int* lpImageFlt	= (unsigned int*)pDibFlt->m_lpImage;
	unsigned int* lpTemp		= new unsigned int[iSize];

	m_iInterleaving = m_pLocalizer[RX_AXIAL]->GetInterleavingMode();	
	DWORD wht = 0x00010101;
	if (m_iInterleaving == 0){ // frame interleaving
		// for gray