fusionglobalimage.cpp

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

#include "stdafx.h"

#include "fusion.h"
#include "fusiondefine.h"
#include "VolumeData.h"
#include "Dib.h"
#include "Primitive.h"
#include "Matrix4D.h"

// include by kyobum
//#include "2D_constant.h"
//#include "2DDraw.h"
#include "math.h"

extern RxVolumeData *RxGetVolumeData(int iLSN);

extern void Zoom(BYTE *in_image, int in_width, int in_height, 
				 unsigned char *out_image, int out_width, int out_height, int color);

void *RxRawImgToDIB(unsigned short *pnRawImg, CSize szRawImg, CSize &szDIB, int iZoomFactor, BYTE *pWindowingTable, BOOL bReverse) 
{
	CSize szInImage = szRawImg;

	if (szInImage.cx %4) szInImage.cx -= szInImage.cx%4; 
	if (szInImage.cx == 0 || szInImage.cy == 0) 
		return NULL;

	szDIB = CSize(ROUNDOFF(szInImage.cx*iZoomFactor/100.),
                    ROUNDOFF(szInImage.cy*iZoomFactor/100.));

	if (szDIB.cx %4) szDIB.cx -= szDIB.cx%4;
	if (szDIB.cx == 0 || szDIB.cy == 0) 
		return NULL;

	BYTE *p_inImage = new BYTE[szInImage.cx*szInImage.cy];
	memset(p_inImage, 0X00, szInImage.cx*szInImage.cy);

	int inStartInx;
	int x,y;
	for(y=0 ; y<szInImage.cy; y++){
		if (bReverse)
			inStartInx = (szInImage.cy-1-y)*szInImage.cx;
		else
			inStartInx = y*szInImage.cx;

		for(x=0 ; x<szInImage.cx ; x++)
			p_inImage[inStartInx+x] = pWindowingTable[(short)(pnRawImg[szRawImg.cx * y + x])];
	}

	RxDib *pDib = new RxDib(szDIB, 8);

	LPBYTE lpImage = pDib->m_lpImage;

	Zoom(p_inImage, szInImage.cx, szInImage.cy, lpImage, szDIB.cx, szDIB.cy, 1);
	delete []p_inImage;

	return pDib;
}

void *RxRawImgToDIBForFusion(RxDib *pInDib, CSize &szDib, int iZoomFactor)
{
	CSize szInImage = szDib;
	if (szInImage.cx %4) szInImage.cx -= szInImage.cx%4; 
	if (szInImage.cx == 0 || szInImage.cy == 0) 
		return NULL;

	szDib = CSize(ROUNDOFF(szInImage.cx*iZoomFactor/100.),
                    ROUNDOFF(szInImage.cy*iZoomFactor/100.));

	if (szDib.cx %4) szDib.cx -= szDib.cx%4;
	if (szDib.cx == 0 || szDib.cy == 0) 
		return NULL;


	LPBYTE p_inImage = (LPBYTE) pInDib->m_lpImage;
	
	RxDib *pOutDib = new RxDib(szDib, 32);

	LPBYTE lpImage = pOutDib->m_lpImage;

	Zoom(p_inImage, szInImage.cx, szInImage.cy, lpImage, szDib.cx, szDib.cy, 4);
	
//	delete []p_inImage;

	return pOutDib;
}


void *RxRawImgToDIB32(unsigned short *pnRawImg, CSize szRawImg, CSize &szDIB, int iZoomFactor, BYTE *pWindowingTable, int iMin=0, int iMax=0) 
{
	#define COLOROVERLAP(X)  ((X) < 150) ? 150 : (X)
	
	CSize szInImage = szRawImg;

	if (szInImage.cx %4) szInImage.cx -= szInImage.cx%4; 
	if (szInImage.cx == 0 || szInImage.cy == 0) 
		return NULL;

	szDIB = CSize(ROUNDOFF(szInImage.cx*iZoomFactor/100.),
                    ROUNDOFF(szInImage.cy*iZoomFactor/100.));

	if (szDIB.cx %4) szDIB.cx -= szDIB.cx%4;
	if (szDIB.cx == 0 || szDIB.cy == 0) 
		return NULL;

	BYTE *p_inImage = new BYTE[szInImage.cx*szInImage.cy*4]; //茄 pixel寸 4 byte..
	memset(p_inImage, 0X00, szInImage.cx*szInImage.cy*4);

	int inStartInx;
	int x,y;
	
	if ( iMin == 0 && iMax == 0 ){ //般媚弊副 郴侩 绝澜..
		for(y=0 ; y<szInImage.cy; y++){
			inStartInx = (szInImage.cy-1-y)*szInImage.cx*4;

			for(x=0 ; x<szInImage.cx ; x++) {
				short nValue = pnRawImg[szRawImg.cx * y + x];
				BYTE nIntensity = pWindowingTable[nValue];
				int nBitmapPos = inStartInx + x*4;

				p_inImage[nBitmapPos] = nIntensity;
				p_inImage[nBitmapPos+1] = nIntensity;
				p_inImage[nBitmapPos+2] = nIntensity;
				p_inImage[nBitmapPos+3] = 0;
			}
		}
	}
	else { //iMin苞 iMax 荤捞俊 乐绰 蔼阑 
		for(y=0 ; y<szInImage.cy; y++){
			inStartInx = (szInImage.cy-1-y)*szInImage.cx*4;

			for(x=0 ; x<szInImage.cx ; x++) {
				short nValue = pnRawImg[szRawImg.cx * y + x];
				BYTE nIntensity = pWindowingTable[nValue];
				int nBitmapPos = inStartInx + x*4;

				if( iMin <= nValue && nValue <= iMax){
					p_inImage[nBitmapPos] = COLOROVERLAP(nIntensity);
					p_inImage[nBitmapPos+1] = COLOROVERLAP(nIntensity);
					p_inImage[nBitmapPos+2] = 0;
					p_inImage[nBitmapPos+3] = 0;
				} else {
					p_inImage[nBitmapPos] = nIntensity;
					p_inImage[nBitmapPos+1] = nIntensity;
					p_inImage[nBitmapPos+2] = nIntensity;
					p_inImage[nBitmapPos+3] = 0;
				}
			}
		}
	}

	RxDib *pDib = new RxDib(szDIB, 32);

	LPBYTE lpImage = pDib->m_lpImage;

	Zoom(p_inImage, szInImage.cx, szInImage.cy, lpImage, szDIB.cx, szDIB.cy, 4);
	delete []p_inImage;

	return pDib;
}

void *RxRawImgToDIB16(unsigned short *pnRawImg, CSize szRawImg) 
{
	CSize szInImage = szRawImg;

	if (szInImage.cx %4) szInImage.cx -= szInImage.cx%4; 
	if (szInImage.cx == 0 || szInImage.cy == 0) 
		return NULL;

	RxDib *pDib = new RxDib(szInImage, 16);

	memcpy(pDib->m_lpImage, pnRawImg, szRawImg.cx * szRawImg.cy * sizeof(unsigned short));

	return pDib;
}

void RxMemDCToPrinter(CPrintDialog *pDlgPrint, HDC hPrinterDC, CDC *pMemDC, CSize szWindow)
{
	/////// START:: sungeui 20001/1/16

	DEVMODE * pDevMode = pDlgPrint->GetDevMode ();
	int PrinterWidth = 0, PrinterHeight = 0;
		
	PrinterWidth = GetDeviceCaps (hPrinterDC, HORZRES);
	PrinterHeight = GetDeviceCaps (hPrinterDC, VERTRES);

	// preserving the ratio.
	if (pDevMode->dmOrientation == DMORIENT_PORTRAIT) {
		float Ratio = float (szWindow.cy) / float (szWindow.cx);
		int OriginalHeight = PrinterHeight;

		PrinterHeight = (int)(Ratio * PrinterWidth);

		OriginalHeight = (OriginalHeight - PrinterHeight) / 2;

		StretchBlt (hPrinterDC, 0, OriginalHeight, PrinterWidth, PrinterHeight, 
					pMemDC->GetSafeHdc(), 0, 0, szWindow.cx, szWindow.cy, SRCCOPY);
	}
	else {
		
		float Ratio = float (szWindow.cx) / float (szWindow.cy);
		int OriginalWidth = PrinterWidth;

		PrinterWidth = (int)(Ratio * PrinterHeight);

		OriginalWidth = (OriginalWidth - PrinterWidth) / 2;

		StretchBlt (hPrinterDC, OriginalWidth, 0, PrinterWidth, PrinterHeight, 
					pMemDC->GetSafeHdc(), 0, 0, szWindow.cx, szWindow.cy, SRCCOPY);
	}
	////// END:: sungeui
}
/*
void *RxRawImgToDIB(unsigned short *pnRawImg, CSize szRawImg, CSize &szDIB, int iZoomFactor, BYTE *pWindowingTable, BOOL bReverse) 
{
	CSize szInImage = szRawImg;

	if (szInImage.cx %4) szInImage.cx -= szInImage.cx%4; 
	if (szInImage.cx == 0 || szInImage.cy == 0) 
		return NULL;

	szDIB = CSize(ROUNDOFF(szInImage.cx*iZoomFactor/100.),
                    ROUNDOFF(szInImage.cy*iZoomFactor/100.));

	if (szDIB.cx %4) szDIB.cx -= szDIB.cx%4;
	if (szDIB.cx == 0 || szDIB.cy == 0) 
		return NULL;

	BYTE *p_inImage = new BYTE[szInImage.cx*szInImage.cy];
	memset(p_inImage, 0X00, szInImage.cx*szInImage.cy);

	int inStartInx;
	int x,y;
	for(y=0 ; y<szInImage.cy; y++){
		if (bReverse)
			inStartInx = (szInImage.cy-1-y)*szInImage.cx;
		else
			inStartInx = y*szInImage.cx;

		for(x=0 ; x<szInImage.cx ; x++)
			p_inImage[inStartInx+x] = pWindowingTable[(short)(pnRawImg[szRawImg.cx * y + x])];
	}

	RxDib *pDib = new RxDib(szDIB, 8);

	LPBYTE lpImage = pDib->m_lpImage;

	Zoom(p_inImage, szInImage.cx, szInImage.cy, lpImage, szDIB.cx, szDIB.cy, 1);
	delete []p_inImage;

	return pDib;
}
*/

/*CDib *RxDC2DIB(CDC *pDC, CSize szWindow)
{
	CDC memDC;
	memDC.CreateCompatibleDC(pDC);

	CBitmap bitmap;
	bitmap.CreateCompatibleBitmap(pDC, szWindow.cx, szWindow.cy);

	CBitmap *pOldBitmap = (CBitmap*)memDC.SelectObject(&bitmap);
	
	memDC.BitBlt(0, 0, szWindow.cx, szWindow.cy, pDC, 0, 0, SRCCOPY);

	BITMAP temp_bitmap;
	bitmap.GetBitmap(&temp_bitmap);

	DWORD size = temp_bitmap.bmWidth * temp_bitmap.bmHeight * temp_bitmap.bmBitsPixel / 8;
	int bytePerPixel = temp_bitmap.bmBitsPixel / 8;
	
	LPBYTE lpBits = new BYTE[size];
	bitmap.GetBitmapBits (size, lpBits); 

	CDib *pDib = new CDib(szWindow,temp_bitmap.bmBitsPixel); 

	LPBITMAPINFOHEADER lpMem = (LPBITMAPINFOHEADER) new BYTE[pDib->GetSizeHeader()+pDib->GetSizeImage()];
	*lpMem = *pDib->m_lpBMIH;
	pDib->AttachMemory(lpMem, TRUE, NULL);

	LPBYTE lpImage = pDib->m_lpImage;
	DWORD bpl = pDib->Bpl();
	
	for(int y=0 ; y<szWindow.cy; y++)
		memcpy(lpImage+(szWindow.cy-1-y)*bpl, lpBits+y*temp_bitmap.bmWidthBytes, temp_bitmap.bmWidthBytes); 

	memDC.SelectObject(pOldBitmap);
	bitmap.DeleteObject ();
	memDC.DeleteDC ();
	
	delete []lpBits;

	return pDib;
}*/

/*RxPoint2D <short> RxIP2VP(RxPoint3D <short> point, CRect rcBitmap, CSize szImg, int nViewID)
{
	RxPoint2D<short> ptTemp;

	switch(nViewID){
	case RXID_VIEW_3DLOCAL_AXIAL:
		ptTemp.x = point.x;
		ptTemp.y = point.y;
		break;
	case RXID_VIEW_3DLOCAL_CORONAL:
		ptTemp.x = point.x;
		ptTemp.y = point.z;
		break;
	case RXID_VIEW_3DLOCAL_SAGITTAL:
		ptTemp.x = point.y;
		ptTemp.y = point.z;
		break;
	default:
		ptTemp.x = -1000;
		ptTemp.x = -1000;

		return ptTemp;

		break;
	}

	RxPoint2D <short> ptLogical;
	float fZoom = (float)rcBitmap.Width()/szImg.cx;
	float rad, dis;
	RxPoint2D <short> ptCenter(rcBitmap.CenterPoint());
	
	rad= (float)atan2(ptTemp.y-ptCenter.y, ptTemp.x-ptCenter.x);
	dis= (float)sqrt( pow(ptTemp.x-ptCenter.x, 2) + pow(ptTemp.y-ptCenter.y, 2) ) / fZoom;

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

	ptLogical.x += (short)(szImg.cx/2);
	ptLogical.y += (short)(szImg.cy/2);

	return ptLogical;
}

RxPoint2D <short> RxVP2IP(RxPoint3D <short> point, CRect rcBitmap, CSize szImg, int nViewID, int iRealVolZ)
{
	RxPoint2D<short> 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 <short> ptReal;
	float fZoom = (float)rcBitmap.Width()/szImg.cx;
	float rad, dis;
	RxPoint2D <short> ptCenter(szImg.cx / 2 , szImg.cy / 2);
	
	rad= (float)atan2(ptTemp.y-ptCenter.y, ptTemp.x-ptCenter.x);
	dis= (float)sqrt( pow(ptTemp.x-ptCenter.x, 2) + pow(ptTemp.y-ptCenter.y, 2) ) *fZoom;

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

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

	return ptReal;
}

RxPoint2D <short> RxIP2VP(RxPoint2D <short> point, CRect rcBitmap, CSize szImg, int nAngle)
{
	RxPoint2D <short> ptLogical;
	float fZoom = (float)rcBitmap.Width()/szImg.cx;
	
	ptLogical.x = ROUNDOFF((float)(point.x - rcBitmap.left)/fZoom + .5);
	ptLogical.y = ROUNDOFF((float)(point.y - rcBitmap.top)/ fZoom + .5);

	int nTemp = ptLogical.x;
	switch(nAngle){
	case DIR_NORMAL_90:
		ptLogical.x = ptLogical.y;
		ptLogical.y = szImg.cx - nTemp;
		break;
	case DIR_NORMAL_180:
		ptLogical.x = szImg.cx - ptLogical.x;
		ptLogical.y = szImg.cy - ptLogical.y;
		break;
	case DIR_NORMAL_270:
		ptLogical.x = szImg.cy - ptLogical.y;
		ptLogical.y = nTemp;
		break;
	case DIR_INVERT_0:
		ptLogical.x = szImg.cx - ptLogical.x;
		ptLogical.y = ptLogical.y;
		break;
	case DIR_INVERT_90:
		ptLogical.x = szImg.cy - ptLogical.y;
		ptLogical.y = szImg.cx - nTemp;
		break;
	case DIR_INVERT_180:
		ptLogical.x = ptLogical.x;
		ptLogical.y = szImg.cy - ptLogical.y;
		break;
	case DIR_INVERT_270:
		ptLogical.x = ptLogical.y;
		ptLogical.y = nTemp;
		break;
	}

	return ptLogical;
}

RxPoint2D <short> RxVP2IP(RxPoint2D <short> point, CRect rcBitmap, CSize szImg, int nAngle)
{
	RxPoint2D <short> ptReal = point;
	
	int nTemp = ptReal.x;
	switch(nAngle){
	case DIR_NORMAL_90:
//		ptReal.x = szImg.cy - ptReal.y;
		ptReal.x = szImg.cx - ptReal.y;
		ptReal.y = nTemp;
		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 - nTemp;
		ptReal.y = szImg.cy - nTemp;
		break;
	case DIR_INVERT_0:
		ptReal.x = szImg.cx - ptReal.x;
		ptReal.y = ptReal.y;
		break;