fusionglobalimage.cpp

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

	case DIR_INVERT_90:
		ptReal.x = szImg.cx - ptReal.y;
		ptReal.y = szImg.cy - nTemp;
//		ptReal.x = szImg.cy - ptReal.y;
//		ptReal.y = szImg.cx - nTemp;
		break;
	case DIR_INVERT_180:
		ptReal.x = ptReal.x;
		ptReal.y = szImg.cy - ptReal.y;
		break;
	case DIR_INVERT_270:
		ptReal.x = ptReal.y;
		ptReal.y = nTemp;
		break;
	}

	float fZoom = (float)rcBitmap.Width()/szImg.cx;

	ptReal.x=(short)(ptReal.x*fZoom + .5 );
	ptReal.y=(short)(ptReal.y*fZoom + .5 );

	ptReal.x = short(ptReal.x + rcBitmap.left);
	ptReal.y = short(ptReal.y + rcBitmap.top);

	return ptReal;
}

RxPoint2D <short> RxItplVP2IP(RxPoint2D <double> point, CRect rcBitmap, CSize szImg, int nAngle)
{
	RxPoint2D <double> ptReal = point;
	
	double fTemp = ptReal.x;
	switch(nAngle){
	case DIR_NORMAL_90:
		ptReal.x = szImg.cy - ptReal.y;
		ptReal.y = fTemp;
		break;
	case DIR_NORMAL_180:
		ptReal.x = szImg.cx - ptReal.x;
		ptReal.y = szImg.cy - ptReal.y;
		break;
	case DIR_NORMAL_270:
		ptReal.x = ptReal.y;
		ptReal.y = szImg.cx - fTemp;
		break;
	case DIR_INVERT_0:
		ptReal.x = szImg.cx - ptReal.x;
		ptReal.y = ptReal.y;
		break;
	case DIR_INVERT_90:
		ptReal.x = szImg.cy - ptReal.y;
		ptReal.y = szImg.cx - fTemp;
		break;
	case DIR_INVERT_180:
		ptReal.x = ptReal.x;
		ptReal.y = szImg.cy - ptReal.y;
		break;
	case DIR_INVERT_270:
		ptReal.x = ptReal.y;
		ptReal.y = fTemp;
		break;
	}

	float fZoom = (float)rcBitmap.Width()/szImg.cx;

	ptReal.x=(short)(ptReal.x*fZoom + .5 );
	ptReal.y=(short)(ptReal.y*fZoom + .5 );

	ptReal.x = short(ptReal.x + rcBitmap.left);
	ptReal.y = short(ptReal.y + rcBitmap.top);

	return ptReal;
}

RxPoint2D <short> RxIP2VP(RxPoint2D <short> point, double fZoomFactor)
{
	RxPoint2D <short> ptVolume;

	ptVolume.x = ROUNDOFF(point.x*100./fZoomFactor);
	ptVolume.y = ROUNDOFF(point.y*100./fZoomFactor);

	return ptVolume;
}

RxPoint2D <short> RxVP2IP(RxPoint2D <short> point, double fZoomFactor)
{
	RxPoint2D <short> ptImage;

	ptImage.x = ROUNDOFF(point.x*fZoomFactor/100.);
	ptImage.y = ROUNDOFF(point.y*fZoomFactor/100.);

	return ptImage;
}

RxPoint2D <short> RxItplVP2IP(RxPoint2D <double> point, double fZoomFactor)
{
	RxPoint2D <short> ptImage;

	ptImage.x = ROUNDOFF(point.x*fZoomFactor/100.);
	ptImage.y = ROUNDOFF(point.y*fZoomFactor/100.);

	return ptImage;
}

// BEGIN:: Interpolated Volume Space惑狼 函券
RxPoint2D <short> RxItplVP2IP(RxPoint3D <short> point, double fRatioZ, RxMatrix4D mxViewing)
{
	//EndoscopyView俊辑狼 measure档 啊瓷窍霸..
	RxVect4D vtImage = mxViewing * RxVect4D(point.x, point.y, point.z/fRatioZ, 1); 

	RxPoint2D <short> ptImage;

	if ( mxViewing.m[3][2] == 0 )
		ptImage = RxPoint2D <short>(ROUNDOFF(vtImage[0]), ROUNDOFF(vtImage[1]));
	else //EndoscopyView俊辑狼 measure
		ptImage = RxPoint2D <short>(ROUNDOFF(vtImage[0]/vtImage[3]), ROUNDOFF(vtImage[1]/vtImage[3]));

	return ptImage;
}

RxPoint3D <short> RxIP2ItplVP(RxPoint2D <short> point, double fRatioZ, RxMatrix4D mxViewing)
{
	RxMatrix4D mx_InvViewing = mxViewing.Inverse();
	RxVect4D vtVolume = mx_InvViewing * RxVect4D(point.x, point.y, 0, 1); 

	RxPoint3D <short> ptVolume;
	
	if ( mxViewing.m[3][2] == 0 )
		ptVolume = RxPoint3D <short>(ROUNDOFF(vtVolume[0]), ROUNDOFF(vtVolume[1]), ROUNDOFF(vtVolume[2]*fRatioZ));
	else {//EndoscopyView俊辑狼 measure
		ptVolume = RxPoint3D <short>(ROUNDOFF(vtVolume[0]/vtVolume[3]), ROUNDOFF(vtVolume[1]/vtVolume[3]), ROUNDOFF(vtVolume[2]/vtVolume[3]));
	}

	return ptVolume;
}

RxVect4D RxItplVP2IP(RxVect4D point, double fRatioZ, RxMatrix4D mxViewing)
{
	RxVect4D vtImage = mxViewing * RxVect4D(point[0], point[1], point[2]/fRatioZ, 1); 
	return vtImage;
}

RxVect4D RxIP2ItplVP(RxVect4D point, double fRatioZ, RxMatrix4D mxViewing)
{
	RxMatrix4D mx_InvViewing = mxViewing.Inverse();

	RxVect4D vtVolume = mx_InvViewing * point;
	vtVolume = RxVect4D(vtVolume[0], vtVolume[1], vtVolume[2]*fRatioZ, vtVolume[3]);
	
	return vtVolume;
}

RxPoint2D <double> RxItplVP2IP(RxPoint3D <double> point, double fRatioZ, RxMatrix4D mxViewing)
{
	//EndoscopyView俊辑狼 measure档 啊瓷窍霸..
	RxVect4D vtImage = mxViewing * RxVect4D(point.x, point.y, point.z/fRatioZ, 1); 

	RxPoint2D <double> ptImage;

	if ( mxViewing.m[3][2] == 0 )
		ptImage = RxPoint2D <double>(vtImage[0], vtImage[1]);
	else //EndoscopyView俊辑狼 measure: Curve俊辑 sparept 弊副 锭 荤侩
		ptImage = RxPoint2D <double>(vtImage[0]/vtImage[3], vtImage[1]/vtImage[3]);

	return ptImage;
}
// END:: Interpolated Volume Space惑狼 函券

///////////////////////////////
//BEGIN:: EndoscopyView俊辑狼 measure 
RxPoint2D <short> RxVP2IPEndo(RxPoint2D <double> point, CRect rcBitmap, CSize szImg, int nAngle)
{
	RxPoint2D <double> ptReal = point;
	
	double fTemp = ptReal.x;
	switch(nAngle){
	case DIR_NORMAL_90:
		ptReal.x = szImg.cy - ptReal.y;
		ptReal.y = fTemp;
		break;
	case DIR_NORMAL_180:
		ptReal.x = szImg.cx - ptReal.x;
		ptReal.y = szImg.cy - ptReal.y;
		break;
	case DIR_NORMAL_270:
		ptReal.x = ptReal.y;
		ptReal.y = szImg.cx - fTemp;
		break;
	case DIR_INVERT_0:
		ptReal.x = szImg.cx - ptReal.x;
		ptReal.y = ptReal.y;
		break;
	case DIR_INVERT_90:
		ptReal.x = szImg.cy - ptReal.y;
		ptReal.y = szImg.cx - fTemp;
		break;
	case DIR_INVERT_180:
		ptReal.x = ptReal.x;
		ptReal.y = szImg.cy - ptReal.y;
		break;
	case DIR_INVERT_270:
		ptReal.x = ptReal.y;
		ptReal.y = fTemp;
		break;
	}

	double fZoom = (rcBitmap.Width() == 0) ? 1 : (double)rcBitmap.Width()/szImg.cx;

	ptReal.x=ptReal.x*fZoom;
	ptReal.y=ptReal.y*fZoom;

	ptReal.x = ptReal.x + rcBitmap.left;
	ptReal.y = ptReal.y + rcBitmap.top;

	ptReal.x = (ptReal.x > 0) ? (int)(ptReal.x+.5) : (int)(ptReal.x-.5);
	ptReal.y = (ptReal.y > 0) ? (int)(ptReal.y+.5) : (int)(ptReal.y-.5);

	return ptReal;
}


RxPoint2D <double> RxVP2IPEndo(RxPoint2D <double> point, double fZoomFactor)
{
	RxPoint2D <double> ptImage;

	ptImage.x = point.x*fZoomFactor/100.;
	ptImage.y = point.y*fZoomFactor/100.;

	return ptImage;
}

RxPoint2D <double> RxItplVP2IPEndo(RxPoint3D <double> point, CRect rcBitmap, CSize szImg, int nViewID, int iRealVolZ)
{
	RxPoint2D<double> ptTemp;

	switch(nViewID){
	case RXID_VIEW_3DLOCAL_AXIAL_LS1:
	case RXID_VIEW_3DLOCAL_AXIAL_LS2:
		ptTemp.x = point.x;
		ptTemp.y = point.y;
		break;
	case RXID_VIEW_3DLOCAL_CORONAL_LS1:
	case RXID_VIEW_3DLOCAL_CORONAL_LS2:
		ptTemp.x = point.x;
		ptTemp.y = (iRealVolZ-point.z);
		break;
	case RXID_VIEW_3DLOCAL_SAGITTAL_LS1:
	case RXID_VIEW_3DLOCAL_SAGITTAL_LS2:
		ptTemp.x = point.y;
		ptTemp.y = (iRealVolZ-point.z);
		break;
	default:
		ptTemp.x = -1000;
		ptTemp.x = -1000;

		return ptTemp;

		break;
	}

	RxPoint2D <double> ptReal;
	double fZoom = (double)rcBitmap.Width()/szImg.cx;
	double rad, dis;
	RxPoint2D <double> ptCenter(szImg.cx / 2 , szImg.cy / 2);
	
	rad= atan2(ptTemp.y-ptCenter.y, ptTemp.x-ptCenter.x);
	dis= sqrt( pow(ptTemp.x-ptCenter.x, 2) + pow(ptTemp.y-ptCenter.y, 2) ) *fZoom;

	ptReal.x=dis*cos(rad);
	ptReal.y=dis*sin(rad);

	ptReal.x += rcBitmap.CenterPoint().x;
	ptReal.y += rcBitmap.CenterPoint().y;

	return ptReal;
}

RxPoint3D <double> RxItplVP2IPEndo(RxPoint3D <double> point, RxMatrix4D mxViewing)
{
	ASSERT ( mxViewing.m[3][2] != 0. ); //perspective projection

	RxVect4D vtImage = mxViewing * RxVect4D(point.x, point.y, point.z); 

	RxPoint3D <double> ptImage;
	ptImage = RxPoint3D <double>(vtImage[0]/vtImage[3], vtImage[1]/vtImage[3], vtImage[2]);

	return ptImage;
}
//END:: EndoscopyView俊辑狼 measure 
///////////////////////////////

RxVect4D RxVP2IP(RxVect4D point, RxMatrix4D mxViewing)
{
	RxVect4D vtImage = mxViewing * RxVect4D(point[0], point[1], point[2], 1); 
	
	return vtImage;
}

RxVect4D RxIP2VP(RxVect4D point, RxMatrix4D mxViewing)
{
	RxMatrix4D mx_InvViewing = mxViewing.Inverse();

	RxVect4D vtVolume = mx_InvViewing * point;
	vtVolume = RxVect4D(vtVolume[0], vtVolume[1], vtVolume[2], vtVolume[3]);
	
	return vtVolume;
}
*/
void RxDrawCircle(CPoint ptCenter, int iRadius, COLORREF color, CDC *pDC)
{
	CPen pen,* pOldPen;
	CBrush brush,* pOldBrush;

	pen.CreatePen(PS_SOLID, 3, color);
	pOldPen = pDC->SelectObject(&pen);
	
	brush.CreateSolidBrush(color);
	pOldBrush = pDC->SelectObject(&brush);

	pDC->Ellipse(ptCenter.x-iRadius, ptCenter.y-iRadius, ptCenter.x+iRadius, ptCenter.y+iRadius);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	
	pen.DeleteObject();
	brush.DeleteObject();
}

void RxDrawOpenCircle(CPoint ptCenter, int iRadius, COLORREF color, CDC *pDC)
{
	CBrush *pOldBrush = (CBrush *)pDC->SelectStockObject(NULL_BRUSH);
	int prevBackMode = pDC->SetBkMode(TRANSPARENT);

	CPen penRearCircle(PS_COSMETIC, 2, RGB(10,10,10));

	CPen *pOldPen = pDC->SelectObject(&penRearCircle);
	pDC->Ellipse(ptCenter.x+2-iRadius, ptCenter.y+2-iRadius, ptCenter.x+2+iRadius, ptCenter.y+2+iRadius);
	pDC->SelectObject(pOldPen);

	//CPen penCircle(PS_SOLID, 2, color);
	CPen penCircle(PS_COSMETIC, 2, color);

	pOldPen = pDC->SelectObject(&penCircle);
	pDC->Ellipse(ptCenter.x-iRadius, ptCenter.y-iRadius, ptCenter.x+iRadius, ptCenter.y+iRadius);
	pDC->SelectObject(pOldPen);

	pDC->SetBkMode(prevBackMode);
	pDC->SelectObject(pOldBrush);
}

void RxDrawMark(CPoint ptCenter, int iRadius, COLORREF color, CDC *pDC, int iInxMark)
{
	CBrush *pOldBrush = (CBrush *)pDC->SelectStockObject(NULL_BRUSH);
	int prevBackMode = pDC->SetBkMode(TRANSPARENT);

	CPen penRearCircle(PS_COSMETIC, 2, RGB(10,10,10));
	CPen *pOldPen = pDC->SelectObject(&penRearCircle);
	pDC->Ellipse(ptCenter.x+2-iRadius, ptCenter.y+2-iRadius, ptCenter.x+2+iRadius, ptCenter.y+2+iRadius);
	pDC->SelectObject(pOldPen);

	CPen penCircle(PS_COSMETIC, 2, color);
	pOldPen = pDC->SelectObject(&penCircle);
	pDC->Ellipse(ptCenter.x-iRadius, ptCenter.y-iRadius, ptCenter.x+iRadius, ptCenter.y+iRadius);
	pDC->SelectObject(pOldPen);

	pDC->SelectObject(pOldBrush);

	/////////////////
	// BEGIN:: font 瘤沥
	LOGFONT logFont;
	logFont.lfHeight		= -24;
	logFont.lfWidth			= 0;
	logFont.lfEscapement	= 0;
	logFont.lfOrientation	= 0;
	logFont.lfWeight		= FW_NORMAL;
	logFont.lfItalic		= FALSE;
	logFont.lfUnderline		= FALSE;
	logFont.lfStrikeOut		= FALSE;
	logFont.lfCharSet		= DEFAULT_CHARSET;
	logFont.lfOutPrecision	= OUT_CHARACTER_PRECIS;
	logFont.lfClipPrecision	= CLIP_CHARACTER_PRECIS;
	logFont.lfQuality			= DEFAULT_QUALITY;
	logFont.lfPitchAndFamily	= DEFAULT_PITCH|FF_DONTCARE;
	_tcscpy(logFont.lfFaceName, _T("Arial"));

	CFont gdiFont;
	gdiFont.CreateFontIndirect(&logFont);

	CFont *pOldFont = (CFont *)pDC->SelectObject(&gdiFont);
	// END:: font 瘤沥
	/////////////////

	CString strInxMark; 
	strInxMark.Format(_T("%d"), iInxMark+1);

	COLORREF prevColor; 

	prevColor = pDC->SetTextColor(RGB(10, 10, 10));
	pDC->TextOut(ptCenter.x+2*iRadius+2, ptCenter.y-12+2, strInxMark);
	pDC->SetTextColor(prevColor);

	prevColor = pDC->SetTextColor(color);
	pDC->TextOut(ptCenter.x+2*iRadius, ptCenter.y-12, strInxMark);
	pDC->SetTextColor(prevColor);

	pDC->SetBkMode(prevBackMode);
	pDC->SelectObject(pOldFont);
	gdiFont.DeleteObject();
}

void RxDrawRectangle(CPoint ptCenter, int iHalfWidth, COLORREF colorIn, CDC *pDC, COLORREF colorBound = RGB(0,0,0))
{
	CPen pen,* pOldPen;
	CBrush brush,* pOldBrush;

	if ( colorBound == RGB(0,0,0)){ //酒公 巴档 救 甸攫 版快
		pen.CreatePen(PS_SOLID, 1, colorIn);
		pOldPen = pDC->SelectObject(&pen);
	}
	else{
		pen.CreatePen(PS_SOLID, 1, RGB(0,0,0));
		pOldPen = pDC->SelectObject(&pen);
	}
	
	brush.CreateSolidBrush(colorIn);
	pOldBrush = pDC->SelectObject(&brush);

	pDC->Rectangle(ptCenter.x-iHalfWidth, ptCenter.y-iHalfWidth, ptCenter.x+iHalfWidth, ptCenter.y+iHalfWidth);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	
	pen.DeleteObject();
	brush.DeleteObject();
}

void RxDrawCross(CPoint ptCenter, int iHalfLen, COLORREF color, CDC *pDC)
{
	CPen pen, *pOldPen;
	pen.CreatePen(PS_SOLID, 1, color);

	pOldPen =pDC->SelectObject(&pen);
	
	pDC->MoveTo(ptCenter.x - iHalfLen-1, ptCenter.y);
	pDC->LineTo(ptCenter.x + 2*iHalfLen, ptCenter.y);

	pDC->MoveTo(ptCenter.x, ptCenter.y - iHalfLen-1);
	pDC->LineTo(ptCenter.x, ptCenter.y + 2*iHalfLen);

	pDC->SelectObject(pOldPen);
	pen.DeleteObject();
}