raycastingcommonagent.cpp

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

// RayCastingCommonAgent.cpp : implementation file
//
//////////////////////////////////////////////////////////////////////
//
//	Title: Super Class of Rendering Agent
//
//////////////////////////////////////////////////////////////////////
//
//	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 "RayCastingCommonAgent.h"
#include "VRUtil.h"
#include <winbase.h>
#include <math.h>
#include "matrix4d.h"
#include "RayCastingCommonInfo.h"
#include "voxelshader.h"
#include "FastInlineFuncs.h"
#include "MaskVolume.h"

//////////////////////////////////////////////////////////////////////
//	declaration
//////////////////////////////////////////////////////////////////////

#define MAX_DIM 1.0e+5
RxMaskVolume* RxRayCastingCommonAgent::m_pVisitMask[2];
RxMaskVolume* RxRayCastingCommonAgent::m_pVisitMask2See[2];
extern void Zoom(BYTE *in_image, int in_width, int in_height, unsigned char *out_image, int out_width, int out_height, int color);

//////////////////////////////////////////////////////////////////////
// RxRayCastingCommonAgent

RxRayCastingCommonAgent::RxRayCastingCommonAgent(int iLSN)
{
	m_iLoadedSeriesNum = iLSN; 

	m_fZoomFactor = 1.0;
	m_iBrightness = 50;
	m_iContrast = 50;
	m_iImgX = 0;
	m_iImgY = 0;
	m_pImage = NULL;
	m_pImageOnce = NULL;
	m_pImageTwice = NULL;
	m_piSliceTable = NULL;

	m_bCreated = FALSE;

	// multi processor 瘤盔
//	RxSystemInfo si;
	m_dwNumberOfCPU = 1; //si.GetCPUCount();

	m_pVisitMask[m_iLoadedSeriesNum] = NULL;
	m_pVisitMask2See[m_iLoadedSeriesNum] = NULL;

}

RxRayCastingCommonAgent::~RxRayCastingCommonAgent()
{
	if (m_pImage) delete[] m_pImage;
	if (m_pImageOnce) delete[] m_pImageOnce;
	if (m_pImageTwice) delete[] m_pImageTwice;

	if (m_pVisitMask[m_iLoadedSeriesNum]) {
		delete m_pVisitMask[m_iLoadedSeriesNum];
		m_pVisitMask[m_iLoadedSeriesNum] = NULL;
	}
}

static int compareIsoRenderInfo(const void *p1, const void *p2)
{
	unsigned short i1 = *(unsigned short*)p1;
	unsigned short i2 = *(unsigned short*)p2;
	if (i1 > i2)
		return 1;
	else
		return 0;
}


// bounding box of projected volume cube
void RxRayCastingCommonAgent::GetRayImageBound(int* min_x, int* min_y, int* max_x, int* max_y)
{
	float vmin_x, vmin_y, vmax_x, vmax_y;
	int i;

	vmin_x = MAX_DIM;
	vmin_y = MAX_DIM;
	vmax_x = -MAX_DIM;
	vmax_y = -MAX_DIM;

	float vect[4], vectRes[4];
	vect[3] = 1;

	for (i=0;i<8;i++) {
		vect[0] = (i&1) ? IntToFloat(m_iVolX-1) : 0;
		vect[1] = (i&2) ? IntToFloat(m_iVolY-1) : 0;
		vect[2] = (i&4) ? IntToFloat(m_iVolZ-1) : 0;

		m4v4mulf(vectRes, m_afViewingM, vect);

		if (vectRes[0] < vmin_x) vmin_x = vectRes[0];
		if (vectRes[1] < vmin_y) vmin_y = vectRes[1];
		if (vectRes[0] > vmax_x) vmax_x = vectRes[0];
		if (vectRes[1] > vmax_y) vmax_y = vectRes[1];
	}

	*min_x = __max(*min_x, FloatToInt(vmin_x));
	*min_y = __max(*min_y, FloatToInt(vmin_y));
	*max_x = __min(*max_x, FloatToInt(vmax_x));
	*max_y = __min(*max_y, FloatToInt(vmax_y));
}

// ray, cube intersection 
BOOL RxRayCastingCommonAgent::GetRaySampleBound(float* afRayDirection, float *min_t, float *max_t)
{
	float tmin, tmax, tmp;
	int i;

	*min_t = 0;
	*max_t = MAX_T;

	for (i=0;i<3;i++) {
		if (__abs(afRayDirection[i])>0.00001) {
			tmax = (m_afMaxVol[i]-m_afRayOrigin[i]-0.1f)/afRayDirection[i];
			tmin = (0.1f-m_afRayOrigin[i])/afRayDirection[i];
			if (tmax < tmin) {
				tmp = tmax;
				tmax = tmin;
				tmin = tmp;
			}
			if (tmin > *min_t)
				*min_t = tmin;
			if (tmax < *max_t)
				*max_t = tmax;
		}
	}

	if (*min_t > *max_t)
		return FALSE;

	return TRUE;
}

float RxRayCastingCommonAgent::GetTLSample(float x, float y, float z)
{
	z/=(float)m_fRatio;

	float tx, ty, tz, txc, tyc;
	int ix, iy, iz;
	int *rix = m_piIdx[0], *riy = m_piIdx[1], *riz = m_piIdx[2];

	ix = FloatToInt(x);
	iy = FloatToInt(y);
	iz = FloatToInt(z);

	tx = x-ix;
	ty = y-iy;
	tz = z-iz;

	txc = 1.f-tx;
	tyc = 1.f-ty;

	return
		(((IntToFloat(m_pnVolume[rix[ix] + riy[iy] + riz[iz]]) * txc +
		IntToFloat(m_pnVolume[rix[ix+1] + riy[iy] + riz[iz]]) * tx) * tyc +
		(IntToFloat(m_pnVolume[rix[ix] + riy[iy+1] + riz[iz]]) * txc +
		IntToFloat(m_pnVolume[rix[ix+1] + riy[iy+1] + riz[iz]]) * tx) * ty) * (1 - tz) +
		((IntToFloat(m_pnVolume[rix[ix] + riy[iy] + riz[iz+1]]) * txc +
		IntToFloat(m_pnVolume[rix[ix+1] + riy[iy] + riz[iz+1]]) * tx) * tyc +
		(IntToFloat(m_pnVolume[rix[ix] + riy[iy+1] + riz[iz+1]]) * txc +
		IntToFloat(m_pnVolume[rix[ix+1] + riy[iy+1] + riz[iz+1]]) * tx) * ty) * tz);

}

// assume: x, y, z are at value region
// returns raw normal; not normalized central difference values
void RxRayCastingCommonAgent::GetNormal(float x, float y, float z, float *nx, float *ny, float *nz)
{

	int ix = FloatToInt(x), iy = FloatToInt(y), iz = FloatToInt(z);

	float x1 = ISVOXELINVOLUME(ix-2, iy, iz)?GetTLSample(x-1, y, z):0;
	float x2 = ISVOXELINVOLUME(ix+2, iy, iz)?GetTLSample(x+1, y, z):0;
	float y1 = ISVOXELINVOLUME(ix, iy-2, iz)?GetTLSample(x, y-1, z):0;
	float y2 = ISVOXELINVOLUME(ix, iy+2, iz)?GetTLSample(x, y+1, z):0;
	float z1 = ISVOXELINVOLUME(ix, iy, iz-2)?GetTLSample(x, y, z-1):0;
	float z2 = ISVOXELINVOLUME(ix, iy, iz+2)?GetTLSample(x, y, z+1):0;

	*nx = x1 - x2;
	*ny = y1 - y2;
	*nz = z1 - z2;
}

unsigned char *RxRayCastingCommonAgent::Render(RxRayCastingCommonInfo* pIsoEndoInfo)
{

	COLORREF rgbLocalizer=0; // = RxGetOptionInfo()->Get3DDisplayLocalPlaneColor();
	m_fRGBLocalizer[0] = 0; // FloatToInt(GetRValue(rgbLocalizer)/255.f);
	m_fRGBLocalizer[1] = 0; // FloatToInt(GetGValue(rgbLocalizer)/255.f);
	m_fRGBLocalizer[2] = 0; // FloatToInt(GetBValue(rgbLocalizer)/255.f);

	unsigned char *pImage;
	int iLevel = pIsoEndoInfo->m_iLodLevel;
	m_iLevel = iLevel;


	int i=0;
	COLORREF *prgbBKImage = NULL;
	COLORREF rgbBKColor = RGB( (BYTE)(pIsoEndoInfo->m_fBkB*255.0f), (BYTE)(pIsoEndoInfo->m_fBkG*255.0f), (BYTE)(pIsoEndoInfo->m_fBkR*255.0f));
	// colorref甫 静瘤父, rgbQuad肺 历厘登骨肺 bgr鉴辑啊 嘎澜

	switch (iLevel) {
	case 0 :
		pImage = m_pImage;
		prgbBKImage = (COLORREF *)m_pImage;

		for(i=0; i<m_iImgX*m_iImgY; i++) {
			prgbBKImage[i] = rgbBKColor;
		}
//		memset(m_pImage, 0, m_iImgX*m_iImgY*4);
		if (pIsoEndoInfo->m_bReuse) {
			for (int yy=0;yy<m_iImgY/2;yy++) {
				for (int xx=0;xx<m_iImgX/2;xx++) {
					memcpy(&m_pImage[4*(xx*2+(yy*2)*(m_iImgX))], &m_pImageOnce[4*(xx+yy*(m_iImgX/2))], 4);
				}
			}
		}
		break;
	case 1 :
		pImage = m_pImageOnce;
		prgbBKImage = (COLORREF *)m_pImageOnce;
		for(i=0; i<(m_iImgX/2)*(m_iImgY/2); i++) {
			prgbBKImage[i] = rgbBKColor;
		}
//		memset(m_pImageOnce, 0, (m_iImgX/2)*(m_iImgY/2)*4);
		if (pIsoEndoInfo->m_bReuse) {
			for (int yy=0;yy<m_iImgY/4;yy++) {
				for (int xx=0;xx<m_iImgX/4;xx++) {
					memcpy(&m_pImageOnce[4*(xx*2+(yy*2)*(m_iImgX/2))], &m_pImageTwice[4*(xx+yy*(m_iImgX/4))], 4);
				}
			}
		}
		break;
	case 2 :
		pImage = m_pImageTwice;
		prgbBKImage = (COLORREF *)m_pImageTwice;
		for(i=0; i<(m_iImgX/4)*(m_iImgY/4); i++) {
			prgbBKImage[i] = rgbBKColor;
		}
//		memset(m_pImageTwice, 0, (m_iImgX/4)*(m_iImgY/4)*4);
		break;
	}

	unsigned char *pOrgImage = pImage;
	int iSkip = 1<<iLevel;

	BOOL bRenderSucceed = FALSE;
	if (m_dwNumberOfCPU > 1) {	// Dual processor老 版快
		m_pEndoThread = AfxBeginThread(EndoThreadFunc, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
		if (m_pEndoThread) {
			::DuplicateHandle(GetCurrentProcess(), m_pEndoThread->m_hThread,
							  GetCurrentProcess(), &m_hEndoThread,
							  0L, FALSE, DUPLICATE_SAME_ACCESS);
			m_pEndoThread->ResumeThread();
		}
		bRenderSucceed = PartialRender(1);
		::WaitForSingleObject(m_hEndoThread, INFINITE);
	} 
	else
		bRenderSucceed = PartialRender(1);

	if(!bRenderSucceed)
		return NULL;


	if (iLevel != 0) {
		Zoom(pOrgImage, m_iImgX/iSkip, m_iImgY/iSkip, m_pImage, m_iImgX, m_iImgY, 4);
	}
	return m_pImage;
}

UINT RxRayCastingCommonAgent::EndoThreadFunc(LPVOID pParam)
{
	RxRayCastingCommonAgent* pThread = (RxRayCastingCommonAgent*)pParam;
	BOOL bRet = pThread->PartialRender(2);

	return bRet;
}