mpragent.cpp

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

// RxMPRAgent.cpp: implementation of the RxMPRAgent class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Matrix4d.h"
#include "Vect4d.h"
#include "MPRAgent.h"
#include "fusionglobal.h"
#include "math.h"
#include "afxtempl.h"
#include "xmmintrin.h"
#include "VoxelShader.h"
#include "volumedata.h"
#include "blockdata.h"
#include "fusiondefine.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

inline int* RxGetXIndexTable(int iState)
{
	RxBlockData* pBlock = RxGetVolumeData(iState)->GetBlockData();
	return pBlock->m_piIdx[0];
}

inline int* RxGetYIndexTable(int iState)
{
	RxBlockData* pBlock = RxGetVolumeData(iState)->GetBlockData();
	return pBlock->m_piIdx[1];
}

inline int* RxGetZIndexTable(int iState)
{
	RxBlockData* pBlock = RxGetVolumeData(iState)->GetBlockData();
	return pBlock->m_piIdx[2];
}


RxMPRAgent::RxMPRAgent(int iState)
{
	m_iRFCNum = iState;
	m_piSliceTable = NULL;
	m_pfWeightTable = NULL;
}

RxMPRAgent::~RxMPRAgent()
{
}

BOOL RxMPRAgent::MakeReferenceTable()
{
	if(m_iRFCNum == 2){
		m_piSliceTable = RxGetVolumeData(0)->m_piInterpolatedMap;
		m_pfWeightTable = RxGetVolumeData(0)->m_pfInterpolatedWeightTable;
	}else{
		m_piSliceTable = RxGetVolumeData(m_iRFCNum)->m_piInterpolatedMap;
		m_pfWeightTable = RxGetVolumeData(m_iRFCNum)->m_pfInterpolatedWeightTable;
	}

	return TRUE;
}

unsigned short* RxMPRAgent::GetAxialHighResImage()
{
	int iIndex = ROUNDOFF(m_fZIndex);
	int x, y, z, iStart, iEnd, i = 0, iCount = 0, iZStrada = m_iVolX * m_iVolY;
	unsigned short* pnImage = new unsigned short[m_iVolX * m_iVolY];
	unsigned int* puBuffer = new unsigned int[m_iVolX * m_iVolY];
	RxVolumeData* pVolumeData;
	if (m_iRFCNum == 2)
		pVolumeData = RxGetVolumeData(0);
	else
		pVolumeData = RxGetVolumeData(m_iRFCNum);
	unsigned short *pnOriginalVolume = pVolumeData->GetOriginalVolume();
	int *pXIdx, *pYIdx, *pZIdx;
	
	if (m_iRFCNum == 2){
		pXIdx = RxGetXIndexTable(0);
		pYIdx = RxGetYIndexTable(0);
		pZIdx = RxGetZIndexTable(0);
	}else {
		pXIdx = RxGetXIndexTable(m_iRFCNum);
		pYIdx = RxGetYIndexTable(m_iRFCNum);
		pZIdx = RxGetZIndexTable(m_iRFCNum);
	}

	memset(pnImage, 0xFF, iZStrada * sizeof(unsigned short));
	memset(puBuffer, 0, iZStrada * sizeof(unsigned int));

	iStart = iEnd = iIndex;

	for (z = iStart; z <= iEnd; z++) {
		i = 0;
		if (iIndex >= 0 && iIndex < m_iVolZ) {
			iCount++;
			for (y = 0; y < m_iVolY; y++)
				for (x = 0; x < m_iVolX; x++, i++)
					puBuffer[i] += ROUNDOFF(pnOriginalVolume[pZIdx[m_piSliceTable[z]] + pYIdx[y] + pXIdx[x]] * (1.0 - m_pfWeightTable[z]) + pnOriginalVolume[pZIdx[m_piSliceTable[z] + 1] + pYIdx[y] + pXIdx[x]] * m_pfWeightTable[z]);
		}
	}

	if (iCount) {
		for (i = 0; i < iZStrada; i++)
			pnImage[i] = puBuffer[i] / iCount;
	}
	delete[] puBuffer;

	return pnImage;
}

unsigned short* RxMPRAgent::GetCoronalHighResImage()
{
	int iIndex = ROUNDOFF(m_fYIndex);
	int x, y, z, iStart, iEnd, i = 0, iCount = 0, iZStrada = m_iVolX * m_iVolY;
	unsigned short* pnImage = new unsigned short[m_iVolX * m_iVolZ];
	unsigned int* puBuffer = new unsigned int[m_iVolX * m_iVolZ];
	RxVolumeData* pVolumeData;
	if (m_iRFCNum == 2)
		pVolumeData = RxGetVolumeData(0);
	else
		pVolumeData = RxGetVolumeData(m_iRFCNum);
	unsigned short *pnOriginalVolume = pVolumeData->GetOriginalVolume();
	int *pXIdx, *pYIdx, *pZIdx;

	if (m_iRFCNum == 2){
		pXIdx = RxGetXIndexTable(0);
		pYIdx = RxGetYIndexTable(0);
		pZIdx = RxGetZIndexTable(0);
	}else {
		pXIdx = RxGetXIndexTable(m_iRFCNum);
		pYIdx = RxGetYIndexTable(m_iRFCNum);
		pZIdx = RxGetZIndexTable(m_iRFCNum);
	}

	memset(pnImage, 0xFF, m_iVolX * m_iVolZ * sizeof(unsigned short));
	memset(puBuffer, 0, m_iVolX * m_iVolZ * sizeof(unsigned int));
	iStart = iEnd = iIndex;

	for (y = iStart; y <= iEnd; y++) {
		i = 0;
		iCount++;
		if (iIndex >= 0 && iIndex < m_iVolY) {
			for (z = m_iVolZ - 1; z >= 0 ; z--) {
				for (x = 0; x < m_iVolX;x++, i++) {
//					puBuffer[i] += ROUNDOFF(pnOriginalVolume[pZIdx[m_piSliceTable[z]] + pYIdx[y] + pXIdx[x]] * (1.0 - m_pfWeightTable[z]) + pnOriginalVolume[pZIdx[m_piSliceTable[z] + 1] + pYIdx[y] + pXIdx[x]] * m_pfWeightTable[z]);
					long ix, iy, iz, ix2, iy2, iz2;
					double data, data2;
					ix = 0;
					ix = pXIdx[x];
					iy = 0;
					iy = pYIdx[y];
					iz = 0;
					iz = pZIdx[m_piSliceTable[z]];
					iz2 = 0;
					iz2 = pZIdx[m_piSliceTable[z] + 1];

					data = pnOriginalVolume[ix + iy + iz];
					data2 = pnOriginalVolume[ix + iy + iz2];
					puBuffer[i] += ROUNDOFF(data * (1.0 - m_pfWeightTable[z]) + data2 * m_pfWeightTable[z]);
				}
			}
		}
	}

	if (iCount) {
		for (i = 0; i < m_iVolX * m_iVolZ; i++)
			pnImage[i] = puBuffer[i] / iCount;
	}
	delete[] puBuffer;

	return pnImage;
}


unsigned short* RxMPRAgent::GetSagittalHighResImage()
{
	int iIndex = ROUNDOFF(m_fXIndex);
	int x, y, z, iStart, iEnd, i = 0, iCount = 0, iZStrada = m_iVolX * m_iVolY;
	unsigned short* pnImage = new unsigned short[m_iVolY * m_iVolZ];
	unsigned int* puBuffer = new unsigned int[m_iVolY * m_iVolZ];
	RxVolumeData* pVolumeData;
	if (m_iRFCNum == 2)
		pVolumeData = RxGetVolumeData(0);
	else
		pVolumeData = RxGetVolumeData(m_iRFCNum);
	unsigned short *pnOriginalVolume = pVolumeData->GetOriginalVolume();
	int *pXIdx, *pYIdx, *pZIdx;

	if (m_iRFCNum == 2){
		pXIdx = RxGetXIndexTable(0);
		pYIdx = RxGetYIndexTable(0);
		pZIdx = RxGetZIndexTable(0);
	}else {
		pXIdx = RxGetXIndexTable(m_iRFCNum);
		pYIdx = RxGetYIndexTable(m_iRFCNum);
		pZIdx = RxGetZIndexTable(m_iRFCNum);
	}

	memset(pnImage, 0xFF, m_iVolY * m_iVolZ * sizeof(unsigned short));
	memset(puBuffer, 0, m_iVolY * m_iVolZ * sizeof(unsigned int));
	iStart = iEnd = iIndex;

	for (x = iStart; x <= iEnd; x++) {
		i = 0;
		iCount++;
		if (iIndex >= 0 && iIndex < m_iVolX) {
			for (z = m_iVolZ - 1; z >= 0 ; z--) {
				for (y = 0; y < m_iVolY; y++, i++) {
					puBuffer[i] += ROUNDOFF(pnOriginalVolume[pZIdx[m_piSliceTable[z]] + pYIdx[y] + pXIdx[x]] * (1.0 - m_pfWeightTable[z]) + pnOriginalVolume[pZIdx[m_piSliceTable[z] + 1] + pYIdx[y] + pXIdx[x]] * m_pfWeightTable[z]);
				}
			}
		}
	}

	if (iCount) {
		for (i = 0; i < m_iVolY * m_iVolZ; i++)
			pnImage[i] = puBuffer[i] / iCount;
	}
	delete[] puBuffer;

	return pnImage;
}

void RxMPRAgent::SetAxialIndex(double fIndex)
{
	m_fZIndex = fIndex;
}

void RxMPRAgent::SetCoronalIndex(double fIndex)
{
	m_fYIndex = fIndex;
}

void RxMPRAgent::SetSagittalIndex(double fIndex)
{
	m_fXIndex = fIndex;
}

void RxMPRAgent::SetVolumeInfo(int iVolX, int iVolY, int iVolZ)
{
	m_iVolX = iVolX;	m_fXIndex = m_iVolX / 2.;
	m_iVolY = iVolY;	m_fYIndex = m_iVolY / 2.;
	m_iVolZ = iVolZ;	m_fZIndex = m_iVolZ / 2.;
}

void RxMPRAgent::GetVolumeDimension(int& iVolX, int& iVolY, int& iVolZ)
{
	iVolX = m_iVolX;
	iVolY = m_iVolY;
	iVolZ = m_iVolZ;
}

void RxMPRAgent::Reset()
{
	m_fXIndex = m_iVolX / 2.;
	m_fYIndex = m_iVolY / 2.;
	m_fZIndex = m_iVolZ / 2.;
}

void RxMPRAgent::SetVolIndex(RxPoint3D<double> vpt)
{
	m_fXIndex = vpt.x;
	m_fYIndex = vpt.y;
	m_fZIndex = vpt.z;
}