fmwnd3dmpr.cpp

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

				}
			}
		}
	}		

	//Remove apSamplePt
	int nNewSampleNum = apSamplePt.GetSize();
	for(i=0; i<nNewSampleNum; i++)
	{
		RxPoint3D <double> *pPt = (RxPoint3D <double> *)apSamplePt.GetAt(i);
		delete pPt;
	}
	apSamplePt.RemoveAll();

	if (level == 1)
	{
		short *pRetImage = new short[szOriginal.cx*szOriginal.cy*sizeof(unsigned short)];
		memset(pRetImage, 0x00, szOriginal.cx*szOriginal.cy*sizeof(unsigned short));
		short *pTempImage = (short*)pImage;

		int x, y;
		for (y=0;y<szFittedImage.cy;y++)
			for (x=0;x<szFittedImage.cx;x++)
				pRetImage[2*x+2*y*szFittedImage.cx*2] = pTempImage[x+y*szFittedImage.cx];

		for (y=0;y<szFittedImage.cy*2;y+=2)
			for (x=1;x<szFittedImage.cx*2-1;x+=2)
				pRetImage[x+y*szFittedImage.cx*2] = (pRetImage[(x-1)+y*szFittedImage.cx*2]+pRetImage[(x+1)+y*szFittedImage.cx*2])/2;

		for (y=1;y<szFittedImage.cy*2-1;y+=2)
			for (x=0;x<szFittedImage.cx*2;x++)
				pRetImage[x+y*szFittedImage.cx*2] = (pRetImage[x+(y-1)*szFittedImage.cx*2]+pRetImage[x+(y+1)*szFittedImage.cx*2])/2;

		delete []pImage;

		return (unsigned short*)pRetImage;	
	}
	else
		return (unsigned short*)pImage;		
}


BOOL RxFMWnd3DMPR::GetMPRDirection(int iXSign, int iYSign, int &xStride, int &yStride, int &bRotated, int &bXMirror, int &bYMirror, CSize& szImage)
{
	int iTemp;

	if (iXSign==1 && iYSign==2) {
		xStride = 1;
		yStride = szImage.cx;
		bYMirror = TRUE;
	}
	else if (iXSign==1 && iYSign==3) {
		xStride = 1;
		yStride = szImage.cx;
	}
	else if (iXSign==2 && iYSign==3) {
		xStride = 1;
		yStride = szImage.cx;
	}
	else if (iXSign==1 && iYSign==-2) {
		xStride = 1;
		yStride = szImage.cx;
	}
	else if (iXSign==1 && iYSign==-3) {
		xStride = 1;
		yStride = szImage.cx;
		bYMirror = TRUE;
	}
	else if (iXSign==2 && iYSign==-3) {
		xStride = 1;
		yStride = szImage.cx;
		bYMirror = TRUE;
	}
	else if (iXSign==-2 && iYSign==3) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
	}
	else if (iXSign==-1 && iYSign==2) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==-1 && iYSign==3) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
	}
	else if (iXSign==-2 && iYSign==-3) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==-1 && iYSign==-2) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
	}
	else if (iXSign==-1 && iYSign==-3) {
		xStride = 1;
		yStride = szImage.cx;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==2 && iYSign==1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
	}
	else if (iXSign==3 && iYSign==1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
	}
	else if (iXSign==3 && iYSign==2) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
	}
	else if (iXSign==2 && iYSign==-1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==3 && iYSign==-1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==3 && iYSign==-2) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==-2 && iYSign==1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
	}
	else if (iXSign==-3 && iYSign==1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
	}
	else if (iXSign==-3 && iYSign==2) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
	}
	else if (iXSign==-2 && iYSign==-1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==-3 && iYSign==-1) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else if (iXSign==-3 && iYSign==-2) {
		xStride = szImage.cy;
		yStride = 1;
		iTemp = szImage.cx;
		szImage.cx = szImage.cy;
		szImage.cy = iTemp;
		bRotated = TRUE;
		bXMirror = TRUE;
		bYMirror = TRUE;
	}
	else {
		return FALSE;
	}
	return TRUE;
}

void RxFMWnd3DMPR::SetStartEndPt(CPoint ptSlantCenter, int nAngle, CSize szView)
{
	int nTempAngle = 180-(int)nAngle;
	if(nTempAngle<0) nTempAngle += 360;
	nTempAngle %= 180;

	double a, b;
	if(nTempAngle<= 45 || nTempAngle>=135)
	{
		a = tan((double)nTempAngle*M_PI/180);
		b = ptSlantCenter.y-a*ptSlantCenter.x;
		m_StartPt = CPoint(0, ROUNDOFF(b));
		m_EndPt = CPoint(szView.cx, ROUNDOFF(a*szView.cx+b));
	}
	else
	{
		a = tan((double)(90-nTempAngle)*M_PI/180);
		b = ptSlantCenter.x-a*ptSlantCenter.y;
		m_StartPt = CPoint(ROUNDOFF(b), 0);
		m_EndPt = CPoint(ROUNDOFF(a*szView.cy+b), szView.cy);
	}
}

void RxFMWnd3DMPR::RemoveSamplePt()
{
	int nSamplePtNum = m_apSamplePt.GetSize();
	for(int i=0; i<nSamplePtNum; i++)
	{
		RxPoint3D <double> *pPt = (RxPoint3D <double> *)m_apSamplePt.GetAt(i);
		delete pPt;
	}
	m_apSamplePt.RemoveAll();
}

short RxFMWnd3DMPR::trilinear(double x, double y, double z, int nSeries)
{
	unsigned short * OriginalVolume = RxGetVolumeData(nSeries)->GetBigVolume();

	int xsize, ysize, zsize;
	RxGetVolumeData(nSeries)->GetBigVolumeDmsn(&xsize, &ysize, &zsize);

	RxMainFrame *pMainFrm = (RxMainFrame*)AfxGetApp()->m_pMainWnd;
	RxFMWndVR* pVR = pMainFrm->m_pWndMain->m_pFMWndVR[m_nSeries];

	RxRayCastingCommonInfo *pVRInfo;
	if(nSeries == RXSERIES_FLT)			pVRInfo = pVR->m_pVRFltInfo;
	else if(nSeries == RXSERIES_REF)		pVRInfo = pVR->m_pVRRefInfo;

	int ixMin, ixMax, iyMin, iyMax, izMin, izMax;

	if (pVR)
	{		
		ixMin = pVRInfo->m_iCrop_XMin;
		ixMax = pVRInfo->m_iCrop_XMax;
		iyMin = pVRInfo->m_iCrop_YMin;
		iyMax = pVRInfo->m_iCrop_YMax;
		izMin = pVRInfo->m_iCrop_ZMin;
		izMax = pVRInfo->m_iCrop_ZMax;			
	} else {
		ixMin = 0;
		ixMax = xsize - 1;
		iyMin = 0;
		iyMax = ysize - 1;
		izMin = 0;
		izMax = zsize - 1;
	}
	
	if (!INCROPRANGE(x, y, z)) return 0;

	int x0, y0, z0, x1, y1, z1;
    unsigned short *dp;
	double fx, fy, fz;
	short d000, d001, d010, d011, d100, d101, d110, d111;
	double dx00, dx01, dx10, dx11, dxy0, dxy1;
    
    x0 = int (floor(x)); fx = x - x0;
    y0 = int (floor(y)); fy = y - y0;
    z0 = int (floor(z)); fz = z - z0;

    x1 = x0 + 1;
    y1 = y0 + 1;
    z1 = z0 + 1; 

	dp = &DENS(x0, y0, z0);
	d000 = dp[0];
	d100 = dp[1];
	dp += xsize;
	d010 = dp[0];
	d110 = dp[1];
	dp += xsize*ysize;
	d011 = dp[0];
	d111 = dp[1];
	dp -= xsize;
	d001 = dp[0];
	d101 = dp[1];


    dx00 = LERP(fx, d000, d100);
    dx01 = LERP(fx, d001, d101);
    dx10 = LERP(fx, d010, d110);
    dx11 = LERP(fx, d011, d111);

    dxy0 = LERP(fy, dx00, dx10);
    dxy1 = LERP(fy, dx01, dx11);

	short shValue = (short)LERP(fz, dxy0, dxy1);

    return shValue;
}

CPoint RxFMWnd3DMPR::CalcuPtOrigin()
{
	CPoint ptOrigin(m_szWindow - m_szDIB);
	ptOrigin.x /= 2; ptOrigin.y /= 2; 
	ptOrigin += m_ptPanOffset;
	
	return ptOrigin;
}

void RxFMWnd3DMPR::PerformWindowingByOffset(CPoint ptOffset)
{
	if(m_nSeries == RXSERIES_FLT || m_nSeries == RXSERIES_REF){
		/*
		if(abs(ptOffset.x) > abs(ptOffset.y)){
			m_iWindowingWidth -= ptOffset.x;
			if(m_iWindowingWidth<0)	m_iWindowingWidth =0;
			else if(m_iWindowingWidth >= 4095 ) m_iWindowingWidth = 4095;
			RxGetFrameTuning()->SetWindowingWidth(m_nSeries, m_iWindowingWidth);
		}
		else {
			m_iWindowingLevel += ptOffset.y;
			if(m_iWindowingLevel <= 0 ) m_iWindowingLevel = 0;
			else if(m_iWindowingLevel >= 4095 ) m_iWindowingLevel = 4095;
			RxGetFrameTuning()->SetWindowingLevel(m_nSeries, m_iWindowingLevel);		
		}
		*/
		RxGetFrameBottom()->GetWindowing(m_nSeries, m_iWindowingLevel, m_iWindowingWidth);
		if(abs(ptOffset.x) > abs(ptOffset.y))
			m_iWindowingWidth -= ptOffset.x;
			
		else 
			m_iWindowingLevel += ptOffset.y;
		RxGetFrameBottom()->SetWindowing(m_nSeries, m_iWindowingLevel, m_iWindowingWidth);				
	}
	//Implement to control Windowing of Reference image in combine mode
	
	else if(m_nSeries == RXSERIES_COM){
		RxGetFrameBottom()->GetWindowing(RXSERIES_REF, m_iWindowingLevel, m_iWindowingWidth);
		if(abs(ptOffset.x) > abs(ptOffset.y))
			m_iWindowingWidth -= ptOffset.x;
			
		else 
			m_iWindowingLevel += ptOffset.y;
		RxGetFrameBottom()->SetWindowing(RXSERIES_REF, m_iWindowingLevel, m_iWindowingWidth);
	}
	RedrawWnd(TRUE);		
}

void RxFMWnd3DMPR::ChangeZoomFactorByDiff(int iDiff)
{
	CPoint ptCenterInImg(m_szWindow.cx/2, m_szWindow.cy/2);
	RxPoint2D <double> ptCenterInVol = IP2VP(ptCenterInImg);
				
	m_iZoomFactor += AdjustMouseOffset4Zoom(-iDiff);
	m_iZoomFactor = min(max(MIN_ZOOM, m_iZoomFactor),MAX_ZOOM);	
	
	RxGetFrameBottom()->SetZoomFactor(m_iZoomFactor);
	//END:: Zoom factor 货肺 拌魂

	ptCenterInImg = VP2IP(ptCenterInVol);

	m_ptPanOffset.x += (m_szWindow.cx / 2) - ptCenterInImg.x;
	m_ptPanOffset.y += (m_szWindow.cy / 2) - ptCenterInImg.y;

	RedrawWnd(TRUE);
}

RxPoint2D <double> RxFMWnd3DMPR::IP2VP(CPoint ptImage)
{
	RxPoint2D <double> ptVolume;

	double fZoom = m_iZoomFactor/100.;
	CPoint ptImgCenter(m_szWindow.cx/2, m_szWindow.cy/2);
	
	ptVolume.x = (ptImage.x - (m_ptPanOffset.x + ptImgCenter.x))/fZoom + m_szMPRImage.cx/2.;
	ptVolume.y = (ptImage.y - (m_ptPanOffset.y + ptImgCenter.y))/fZoom + m_szMPRImage.cy/2.;

	return ptVolume;
}

CPoint RxFMWnd3DMPR::VP2IP(RxPoint2D <double> ptVolume)
{
	CPoint ptImage;

	double fZoom = m_iZoomFactor/100.;
	CPoint ptImgCenter(m_szWindow.cx/2 , m_szWindow.cy/2);
	
	ptImage.x = ROUNDOFF((ptVolume.x - m_szMPRImage.cx / 2.)*fZoom + m_ptPanOffset.x + ptImgCenter.x);
	ptImage.y = ROUNDOFF((ptVolume.y - m_szMPRImage.cy / 2.)*fZoom + m_ptPanOffset.y + ptImgCenter.y);

	return ptImage;
}

int RxFMWnd3DMPR::AdjustMouseOffset4Zoom(int iOffset)
{
	int iRet;

	if (abs(iOffset) < MOUSE_OFFSET_THRESHOLD)
		iRet = iOffset;
	else {
		if (iOffset < 0)
			iRet = -MOUSE_OFFSET_THRESHOLD + iOffset / MOUSE_OFFSET_THRESHOLD;
		else
			iRet = MOUSE_OFFSET_THRESHOLD + iOffset / MOUSE_OFFSET_THRESHOLD;
	}

	return iRet;
}


void RxFMWnd3DMPR::ApplyMixingRatio(float fRatioOfRef)
{
	m_fRatioRef = fRatioOfRef;
	RedrawWnd(TRUE);
}

BOOL RxFMWnd3DMPR::MakeMixedDibForFusion(unsigned int* pRefMap, unsigned short* pFittedFltMap, CSize szFittedCombineImg, CSize &szDib)
{
	void* ptFltColorTable = RxGetFrameTuning()->m_pHistogramWnd[RXSERIES_FLT]->GetSpectrum();
	int iSize = szFittedCombineImg.cx*szFittedCombineImg.cy;

	RxDib *pDib = new RxDib(szFittedCombineImg, 32);
	RxDib *pDibRef = new RxDib(szFittedCombineImg, 32);
	RxDib *pDibFlt	= new RxDib(szFittedCombineImg, 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;		

	MultiplyScale((BYTE*)pRefMap, (BYTE*)lpImageRef, szFittedCombineImg, 1.0f);
	GetDIBColor(pFittedFltMap, lpImageFlt, (__m128 *)ptFltColorTable, iSize, 1.0f);
	FusionImages((BYTE*)lpImageRef, (BYTE*)lpImageFlt, (BYTE*)lpImage, szFittedCombineImg, m_fRatioRef, 1.0f-m_fRatioRef);	
	
	if(m_pDib){	delete m_pDib;	m_pDib = NULL; }
	m_pDib = (RxDib*)RxRawImgToDIBForFusion(pDib, szDib, m_iZoomFactor);	

	delete pDibRef;
	delete pDibFlt;
	delete pDib;

	if(m_pDib)	return TRUE;
	return FALSE;
}