raycastingcommoninfo.cpp

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

// RxRayCastingCommonAgent.cpp : implementation file
//
//////////////////////////////////////////////////////////////////////
//
//	Title: Container of Rendering Parameters & Informations
//
//////////////////////////////////////////////////////////////////////
//
//	Author: H.W.Kye
//	138-dong 417-ho Seoul National University
//	San 56-1 Shinlim-dong Kwanak-gu Seoul, Korea
//	Email. 
//
//	Date	:
//	Update	:
//
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
//	include
//////////////////////////////////////////////////////////////////////

#include "stdAfx.h"
#include "RayCastingCommonInfo.h"
#include "Transform3DInfo.h"

RxRayCastingCommonInfo::RxRayCastingCommonInfo()
{
	m_bTramsforum3D = FALSE;
	m_pTransform3DInfo = new RxTransform3DInfo;

	m_iWMax = 200;
	m_iWMin = -100;
	m_iLodLevel = 0;
	m_pnVolume = NULL;
	m_pBlockData = NULL;
	m_iVolX = m_iVolY = m_iVolZ = 0;
	m_szImage = CSize(0,0);
	m_fRatioZ = 1;
	m_piSliceTable = NULL;
	m_iBrightness = m_iContrast = 30;
	m_fCOPX = m_fCOPY = m_fCOPZ = 0;
	m_bReuse = FALSE;
	m_iWhichPlane = 0;;
	m_bShade = TRUE;
	m_p3DVOI = NULL;
	m_pSculptVolume = NULL;
	m_fZoomFactor = 1;
	m_fRayMagnitude = 1;
	m_iWhichPlane = ENDO_PLANE_NONE;
	m_pEditMask = NULL;
	m_pPolypMask = NULL;
	m_bAxialON = FALSE;
	m_bCoronalON = FALSE;
	m_bSagittalON = FALSE;
	m_bObject = FALSE;
	m_bSubtract = FALSE;
	m_iCrop_XMin = 0;
	m_iCrop_XMax = 0;
	m_iCrop_YMin = 0;
	m_iCrop_YMax = 0;
	m_iCrop_ZMin = 0;
	m_iCrop_ZMax = 0;
}

RxRayCastingCommonInfo::~RxRayCastingCommonInfo()
{
	delete m_pTransform3DInfo;
}

void RxRayCastingCommonInfo::SetLodLevel(int level)
{
	m_iLodLevel = level;
}

void RxRayCastingCommonInfo::SetVolume(unsigned short *pVol, int x, int y, int z)
{
	m_pnVolume = pVol;
	m_iVolX = x;
	m_iVolY = y;
	m_iVolZ = z;

	m_iCrop_XMin = 0;
	m_iCrop_XMax = m_iVolX-1;
	m_iCrop_YMin = 0;
	m_iCrop_YMax = m_iVolY-1;
	m_iCrop_ZMin = 0;
	m_iCrop_ZMax = m_iVolZ-1;

	m_afBoundingMin[0] = m_afBoundingMin[1] = m_afBoundingMin[2] = 0;
	m_afBoundingMax[0] = (float)m_iVolX-1;
	m_afBoundingMax[1] = (float)m_iVolY-1;
	m_afBoundingMax[2] = (float)m_iVolZ-1;
}

void RxRayCastingCommonInfo::SetBlockData(void *pblockdata)
{
	m_pBlockData = pblockdata;
}

void RxRayCastingCommonInfo::SetImgSize(CSize img)
{
	m_szImage = img;
}

void RxRayCastingCommonInfo::SetBrightness(int iVal)
{
	m_iBrightness = iVal;
}

void RxRayCastingCommonInfo::SetContrast(int iVal)
{
	m_iContrast = iVal;
}

void RxRayCastingCommonInfo::MakeBoundingBox(RxMatrix4D refReg, int rx, int ry, int rz)
{
	RxMatrix4D mxRef2Flt;
	mxRef2Flt.Translate(-rx/2, -ry/2, -rz/2);
	mxRef2Flt = refReg.Inverse3D() * mxRef2Flt;
	mxRef2Flt.Translate(m_iVolX/2, m_iVolY/2, m_iVolZ/2);

	RxVect4D vecPoint[8] = {
		RxVect4D(m_iRefCropMin[0], m_iRefCropMin[1], m_iRefCropMin[2]),
		RxVect4D(m_iRefCropMin[0], m_iRefCropMin[1], m_iRefCropMax[2]),
		RxVect4D(m_iRefCropMin[0], m_iRefCropMax[1], m_iRefCropMin[2]),
		RxVect4D(m_iRefCropMin[0], m_iRefCropMax[1], m_iRefCropMax[2]),
		RxVect4D(m_iRefCropMax[0], m_iRefCropMin[1], m_iRefCropMin[2]),
		RxVect4D(m_iRefCropMax[0], m_iRefCropMin[1], m_iRefCropMax[2]),
		RxVect4D(m_iRefCropMax[0], m_iRefCropMax[1], m_iRefCropMin[2]),
		RxVect4D(m_iRefCropMax[0], m_iRefCropMax[1], m_iRefCropMax[2])
	};

	RxVect4D vecMin = mxRef2Flt * vecPoint[0];
	RxVect4D vecMax = mxRef2Flt * vecPoint[0];
	for(int i=1; i<8; i++) {
		RxVect4D vec = mxRef2Flt * vecPoint[i];
		vecMin = vecMin.Min(vec);
		vecMax = vecMax.Max(vec);
	}


	int aiMaxCrop[3]={m_iVolX-1, m_iVolY-1, m_iVolZ-1};
	for(i=0; i<3; i++) {
		m_afBoundingMin[i] = __max((float)vecMin.m[i], 0);
		m_afBoundingMax[i] = __min((float)vecMax.m[i], (float)aiMaxCrop[i]);
	}
}

void RxRayCastingCommonInfo::SetViewingMatrix(RxMatrix4D mxView)
{
	m_mxViewing = mxView;
	m_mxInvViewing = mxView.Inverse();
}

void RxRayCastingCommonInfo::SetRefViewingMatrix(RxMatrix4D mxRef)
{
	m_mxRefViewing = mxRef;
	m_mxInvRefViewing = m_mxRefViewing.Inverse();

	RxVect4D eye(0,0,1,0);
	eye = m_mxInvRefViewing * eye;
	m_fRayMagnitude = (float)eye.Magnitude();
}

void RxRayCastingCommonInfo::SetCOP(float iX, float iY, float iZ)
{
	m_fCOPX = iX;
	m_fCOPY = iY;
	m_fCOPZ = iZ;
}

void RxRayCastingCommonInfo::SetRatio(float ratio)
{
	m_fRatioZ = ratio;
}

void RxRayCastingCommonInfo::SetPixelInc(float fPixelInc)
{
	m_fPixelInc = fPixelInc;
}

void RxRayCastingCommonInfo::SetReuseMode(BOOL bReuse)
{
	m_bReuse = bReuse;
}

void RxRayCastingCommonInfo::Set3DLocalPlaneONflagsInEndo(BOOL bAxialON, BOOL bCoronalON, BOOL bSagittalON)
{
	if (bAxialON)
		m_iWhichPlane = ENDO_PLANE_AXIAL;
	else if (bSagittalON)
		m_iWhichPlane = ENDO_PLANE_SAGITTAL;
	else if (bCoronalON)
		m_iWhichPlane = ENDO_PLANE_CORONAL;
	else
		m_iWhichPlane = ENDO_PLANE_NONE;
}

void RxRayCastingCommonInfo::Set3DLocalPlaneONflags(BOOL bAxialON, BOOL bCoronalON, BOOL bSagittalON)
{
	m_bAxialON = bAxialON;
	m_bCoronalON = bCoronalON;
	m_bSagittalON = bSagittalON;
}
	
// interpolated space
void RxRayCastingCommonInfo::Set3DLocalPlaneOffset(int iAxialOffset, int iCoronalOffset, int iSagittalOffset)
{
	m_iSagittalOffset = max(0, min(iSagittalOffset, m_iVolX-1));
	m_iCoronalOffset = max(0, min(iCoronalOffset, m_iVolY-1));
	m_iAxialOffset = max(0, min(iAxialOffset, m_iVolZ-1));

	ASSERT(0 <= m_iSagittalOffset && m_iSagittalOffset < m_iVolX);
	ASSERT(0 <= m_iCoronalOffset && m_iCoronalOffset < m_iVolY);
	ASSERT(0 <= m_iAxialOffset && m_iAxialOffset < m_iVolZ);
}

void RxRayCastingCommonInfo::Set3DLocalPlaneOpacities(float fAxialOpacity, float fCoronalOpacity, float fSagittalOpacity)
{
	m_fSagittalOpacity = fSagittalOpacity;
	m_fCoronalOpacity = fCoronalOpacity;
	m_fAxialOpacity = fAxialOpacity;
}

void RxRayCastingCommonInfo::SetShadingMode(BOOL bShade)
{
	m_bShade = bShade;
}

void RxRayCastingCommonInfo::Set3DVOI(void *pvoi)
{
	m_p3DVOI = pvoi;
}

void RxRayCastingCommonInfo::SetSculptVolume(void *psculpt)
{
	m_pSculptVolume = psculpt;
}

// volume 谅钎拌, original coordinate 2002.11.06
void RxRayCastingCommonInfo::SetCropRange(int iXMin, int iXMax, int iYMin, int iYMax, int iZMin, int iZMax)
{
	m_iCrop_XMin = iXMin;
	m_iCrop_XMax = iXMax;
	m_iCrop_YMin = iYMin;
	m_iCrop_YMax = iYMax;
	m_iCrop_ZMin = iZMin;
	m_iCrop_ZMax = iZMax;
}

// volume 谅钎拌, original coordinate 2002.11.06
void RxRayCastingCommonInfo::SetCropRange(int iMin, int iMax, int iAxis)
{
	if(iAxis == 0) {
		m_iCrop_XMin = iMin;
		m_iCrop_XMax = iMax;
	} else if(iAxis == 1) {
		m_iCrop_YMin = iMin;
		m_iCrop_YMax = iMax;
	} else if(iAxis == 2) {
		m_iCrop_ZMin = iMin;
		m_iCrop_ZMax = iMax;
	}
}

// volume 谅钎拌, original coordinate 2002.11.06
void RxRayCastingCommonInfo::SetRefCropRange(int iMin[3], int iMax[3])
{
	for(int i=0; i<3; i++) {
		m_iRefCropMin[i] = iMin[i];
		m_iRefCropMax[i] = iMax[i];
	}	
}

// volume 谅钎拌, original coordinate 2002.11.06
void RxRayCastingCommonInfo::SetRefCropRange(int iMin, int iMax, int iAxis)
{
	m_iRefCropMin[iAxis] = iMin;
	m_iRefCropMax[iAxis] = iMax;
}

void RxRayCastingCommonInfo::SetWminMaxInImgSpace(int iWmin, int iWMax)
{
	m_iWMin = iWmin;
	m_iWMax = iWMax;
}

void RxRayCastingCommonInfo::SetGradientMag(int iGradMag)
{
	m_iGradientMag = iGradMag;
}


void RxRayCastingCommonInfo::SetRenderThreadKillEvent(HANDLE hevent)
{
	m_hThreadKillEvent = hevent;
}

void RxRayCastingCommonInfo::SetZoomFactor(double fZoomFactor)
{
	m_fZoomFactor = fZoomFactor;
}

void RxRayCastingCommonInfo::SetBgColor(float r, float g, float b)
{
	m_fBkR = r;
	m_fBkG = g;
	m_fBkB = b;
}

void RxRayCastingCommonInfo::SetTransform3DInfo(RxTransform3DInfo *pTransform3DInfo)
{
	ASSERT(pTransform3DInfo);

	m_bTramsforum3D = TRUE;
	memcpy(m_pTransform3DInfo, pTransform3DInfo, sizeof(RxTransform3DInfo));
}

void RxRayCastingCommonInfo::SetPolypMask(RxMaskVolume* pPolypMask)
{
	m_pPolypMask = pPolypMask;
}

void RxRayCastingCommonInfo::SetSliceMappingTable(int *pTable)
{
	ASSERT(pTable);
	m_piSliceTable = pTable;
}