blockdata.cpp

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

// BlockData.cpp : implementation file
//
//////////////////////////////////////////////////////////////////////
//
//	Title: Container of Block Information
//
//////////////////////////////////////////////////////////////////////
//
//	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 <malloc.h>
#include <xmmintrin.h>
#include "Fusion3DConst.h"
#include "ipl.h"
#include "progresswnd.h"
#include "BlockData.h"
#include "fastinlinefuncs.h"

#pragma warning(disable : 964)

//////////////////////////////////////////////////////////////////////
// RxBlockData

RxBlockData::RxBlockData()
{
	m_iVolumeSizeX = m_iVolumeSizeY = m_iVolumeSizeZ = 0;
	m_iBlockNumberX = m_iBlockNumberY = m_iBlockNumberZ = 0;
	m_iSBlockNumberY = 0;

	m_iScanlineSizeofByte = 0;
	m_iScanlineSizeofByteX = 0;
	m_iBlockSizeofByte = 0;

	m_iBufferSize = 0;
	m_iBuffer8x8Size = 0;

	m_pmmBlock = NULL;
	m_pmmScanline = NULL;
	m_pmmScanlineX = NULL;

	m_pmmBuffer = NULL;
	m_pmmBuffer8x8 = NULL;

	m_pWndProgress = NULL;

	// by jjchoi, 10/16
	m_piIdx[0] = NULL;
	m_piIdx[1] = NULL;
	m_piIdx[2] = NULL;

	m_piSkipIdx[0] = NULL;
	m_piSkipIdx[1] = NULL;
	m_piSkipIdx[2] = NULL;

	m_piBlockIdx[0] = NULL;
	m_piBlockIdx[1] = NULL;
	m_piBlockIdx[2] = NULL;
	// by jjchoi
}

RxBlockData::~RxBlockData()
{
	DestroyData();
}


///////////////////////////////////////////////////
// Create, Destroy

BOOL RxBlockData::DestroyData()
{
	BOOL bRetval = TRUE;

	if(m_pmmBlock) {
		VirtualFree(m_pmmBlock, m_iBlockSizeofByte, MEM_DECOMMIT);
		VirtualFree(m_pmmBlock, 0, MEM_RELEASE);
		m_pmmBlock = NULL;
	}
	if(m_pmmScanline) {
		VirtualFree(m_pmmScanline, m_iScanlineSizeofByte, MEM_DECOMMIT);
		VirtualFree(m_pmmScanline, 0, MEM_RELEASE);
		m_pmmScanline = NULL;
	}
	if(m_pmmScanlineX) {
		VirtualFree(m_pmmScanlineX, m_iScanlineSizeofByteX, MEM_DECOMMIT);
		VirtualFree(m_pmmScanlineX, 0, MEM_RELEASE);
		m_pmmScanlineX = NULL;
	}

	if(m_pmmBuffer) {
		VirtualFree(m_pmmBuffer, m_iBufferSize, MEM_DECOMMIT);
		VirtualFree(m_pmmBuffer, 0, MEM_RELEASE);
		m_pmmBuffer = NULL;
	}
	if(m_pmmBuffer8x8) {
		VirtualFree(m_pmmBuffer8x8, m_iBuffer8x8Size, MEM_DECOMMIT);
		VirtualFree(m_pmmBuffer8x8, 0, MEM_RELEASE);
		m_pmmBuffer8x8 = NULL;
	}


	m_pWndProgress = NULL;

	// by jjchoi, 10/16
	if (m_piIdx[0])
		delete[] m_piIdx[0];
	if (m_piIdx[1])
		delete[] m_piIdx[1];
	if (m_piIdx[2])
		delete[] m_piIdx[2];
	if (m_piSkipIdx[0])
		delete[] m_piSkipIdx[0];
	if (m_piSkipIdx[1])
		delete[] m_piSkipIdx[1];
	if (m_piSkipIdx[2])
		delete[] m_piSkipIdx[2];
	if (m_piBlockIdx[0])
		delete[] m_piBlockIdx[0];
	if (m_piBlockIdx[1])
		delete[] m_piBlockIdx[1];
	if (m_piBlockIdx[2])
		delete[] m_piBlockIdx[2];
	// by jjchoi, end

	for(int i=0; i<3; i++) {
		m_piIdx[i] = NULL;
		m_piSkipIdx[i] = NULL;
		m_piBlockIdx[i] = NULL;
	}
	_mm_empty();
	return bRetval;
}



BOOL RxBlockData::CreateMinMaxVolume8x8(int iX, int iY, int iZ, const unsigned short *pVolume)
{
	// alloc
	m_iBuffer8x8Size = ((iX + 7) / 8) * ((iY + 7) / 8) * ((iZ + 7) / 8) * sizeof(stMinMax);
	m_pmmBuffer8x8 = (stMinMax *)VirtualAlloc(NULL, m_iBuffer8x8Size, MEM_RESERVE | MEM_TOP_DOWN | MEM_COMMIT, PAGE_READWRITE);

	if (m_pmmBuffer8x8 == NULL)
		return FALSE;

	__m64 *vVolume = (__m64 *)pVolume;

	int nVolIndex;
	int nIndex = 0;
	int nBlockNumX = (iX + 7) / 8;
	int nBlockNumY = (iY + 7) / 8;
	int nBufSize = nBlockNumY * nBlockNumX;

	__m64 *pvTmpMin1 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMin2 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMin3 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);

	__m64 *pvTmpMax1 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMax2 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMax3 = (__m64 *)_mm_malloc(nBufSize * sizeof(__m64), CACHESIZE);

	memset(pvTmpMin1, 0x7f, nBufSize * sizeof(__m64));
	memset(pvTmpMax1, 0x00, nBufSize * sizeof(__m64));

	// z啊 4厘 捞窍老锭 抗寇 贸府
	if (iZ < 5) {
		for (int z = 0; z < iZ; z++) {
			nVolIndex = z * iY * iX / 4;
			SliceMinMax8x8(iX, iY, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

			for (int i = 0; i < nBufSize; i++) {
				pvTmpMin1[i] = _mm_min_pi16(pvTmpMin1[i], pvTmpMin3[i]);
				pvTmpMax1[i] = _mm_max_pi16(pvTmpMax1[i], pvTmpMax3[i]);
			}
		}

		for (int i = 0; i < nBufSize; i++) {
			unsigned short *nMin = (unsigned short *)&pvTmpMin1[i];
			unsigned short *nMax = (unsigned short *)&pvTmpMax1[i];

			unsigned short nMinValue, nMaxValue;
			nMinValue = __min(nMin[0], nMin[1]);
			nMinValue = __min(nMinValue, nMin[2]);
			nMinValue = __min(nMinValue, nMin[3]);

			nMaxValue = __max(nMax[0], nMax[1]);
			nMaxValue = __max(nMaxValue, nMax[2]);
			nMaxValue = __max(nMaxValue, nMax[3]);

			m_pmmBuffer8x8[i].nMin = nMinValue;
			m_pmmBuffer8x8[i].nMax = nMaxValue;
		}
	}
	else {
		// 霉何盒 抗寇 贸府
		for (int z = 0; z < 4; z++) {
			nVolIndex = z * iY * iX / 4;
			SliceMinMax8x8(iX, iY, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

			for (int i = 0; i < nBufSize; i++) {
				pvTmpMin1[i] = _mm_min_pi16(pvTmpMin1[i], pvTmpMin3[i]);
				pvTmpMax1[i] = _mm_max_pi16(pvTmpMax1[i], pvTmpMax3[i]);
			}
		}

		// main loop
		for (z = 4; z < iZ - 8; z += 8) {
			if (m_pWndProgress && m_pWndProgress->Cancelled()) {
				return FALSE;
			} 
			else if (m_pWndProgress) {
				m_pWndProgress->SetPos(50+z*50/iZ);
				m_pWndProgress->PeekAndPump();
			}

			memset(pvTmpMin2, 0x7f, nBufSize * sizeof(__m64));
			memset(pvTmpMax2, 0x00, nBufSize * sizeof(__m64));

			for (int i = 0; i < 8; i++) {
				nVolIndex = (z + i) * iY * iX / 4;
				SliceMinMax8x8(iX, iY, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

				for (int j = 0; j < nBufSize; j++) {
					pvTmpMin2[j] = _mm_min_pi16(pvTmpMin2[j], pvTmpMin3[j]);
					pvTmpMax2[j] = _mm_max_pi16(pvTmpMax2[j], pvTmpMax3[j]);
				}
			}

			int nBufIndex = nIndex * nBufSize;
			__m64 vMin, vMax;

			for (int j = 0; j < nBufSize; j++) {
				vMin = _mm_min_pi16(pvTmpMin1[j], pvTmpMin2[j]);
				vMax = _mm_max_pi16(pvTmpMax1[j], pvTmpMax2[j]);

				unsigned short *nMin = (unsigned short *)&vMin;
				unsigned short *nMax = (unsigned short *)&vMax;

				unsigned short nMinValue, nMaxValue;
				nMinValue = __min(nMin[0], nMin[1]);
				nMinValue = __min(nMinValue, nMin[2]);
				nMinValue = __min(nMinValue, nMin[3]);

				nMaxValue = __max(nMax[0], nMax[1]);
				nMaxValue = __max(nMaxValue, nMax[2]);
				nMaxValue = __max(nMaxValue, nMax[3]);

				m_pmmBuffer8x8[nBufIndex + j].nMin = nMinValue;
				m_pmmBuffer8x8[nBufIndex + j].nMax = nMaxValue;
			}

			// for reues
			__m64 *pMin = pvTmpMin1;
			__m64 *pMax = pvTmpMax1;

			pvTmpMin1 = pvTmpMin2;
			pvTmpMax1 = pvTmpMax2;

			pvTmpMin2 = pMin;
			pvTmpMax2 = pMax;

			nIndex++;
		}

		// 付瘤阜 何盒 抗寇 贸府
		if ((iZ - 1) % 8 < 4) {
			memset(pvTmpMin2, 0x7f, nBufSize * sizeof(__m64));
			memset(pvTmpMax2, 0x00, nBufSize * sizeof(__m64));

			for (int z = (iZ - 1) / 8 * 8 - 4; z < iZ; z++) {
				nVolIndex = z * iY * iX / 4;
				SliceMinMax8x8(iX, iY, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

				for (int i = 0; i < nBufSize; i++) {
					pvTmpMin2[i] = _mm_min_pi16(pvTmpMin2[i], pvTmpMin3[i]);
					pvTmpMax2[i] = _mm_max_pi16(pvTmpMax2[i], pvTmpMax3[i]);
				}
			}

			int nBufIndex = nIndex * nBufSize;
			int nBufIndex1 = (nIndex + 1) * nBufSize;
			__m64 vMin, vMax;

			for (int i = 0; i < nBufSize; i++) {
				vMin = _mm_min_pi16(pvTmpMin1[i], pvTmpMin2[i]);
				vMax = _mm_max_pi16(pvTmpMax1[i], pvTmpMax2[i]);

				unsigned short *nMin = (unsigned short *)&vMin;
				unsigned short *nMax = (unsigned short *)&vMax;

				unsigned short nMinValue, nMaxValue;
				nMinValue = __min(nMin[0], nMin[1]);
				nMinValue = __min(nMinValue, nMin[2]);
				nMinValue = __min(nMinValue, nMin[3]);

				nMaxValue = __max(nMax[0], nMax[1]);
				nMaxValue = __max(nMaxValue, nMax[2]);
				nMaxValue = __max(nMaxValue, nMax[3]);

				m_pmmBuffer8x8[nBufIndex + i].nMin = nMinValue;
				m_pmmBuffer8x8[nBufIndex + i].nMax = nMaxValue;

				// 付瘤阜 何盒 slice
				unsigned short *nMin1 = (unsigned short *)&pvTmpMin2[i];
				unsigned short *nMax1 = (unsigned short *)&pvTmpMax2[i];

				unsigned short nMinValue1, nMaxValue1;
				nMinValue1 = __min(nMin1[0], nMin1[1]);
				nMinValue1 = __min(nMinValue1, nMin1[2]);
				nMinValue1 = __min(nMinValue1, nMin1[3]);

				nMaxValue1 = __max(nMax1[0], nMax1[1]);
				nMaxValue1 = __max(nMaxValue1, nMax1[2]);
				nMaxValue1 = __max(nMaxValue1, nMax1[3]);

				m_pmmBuffer8x8[nBufIndex1 + i].nMin = nMinValue1;
				m_pmmBuffer8x8[nBufIndex1 + i].nMax = nMaxValue1;
			}
		}
		else {
			memset(pvTmpMin2, 0x7f, nBufSize * sizeof(__m64));
			memset(pvTmpMax2, 0x00, nBufSize * sizeof(__m64));

			for (int z = (iZ - 1) / 8 * 8 + 4; z < iZ; z++) {
				nVolIndex = z * iY * iX / 4;
				SliceMinMax8x8(iX, iY, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

				for (int i = 0; i < nBufSize; i++) {
					pvTmpMin2[i] = _mm_min_pi16(pvTmpMin2[i], pvTmpMin3[i]);
					pvTmpMax2[i] = _mm_max_pi16(pvTmpMax2[i], pvTmpMax3[i]);
				}
			}

			int nBufIndex = nIndex * nBufSize;
			__m64 vMin, vMax;

			for (int i = 0; i < nBufSize; i++) {
				vMin = _mm_min_pi16(pvTmpMin1[i], pvTmpMin2[i]);
				vMax = _mm_max_pi16(pvTmpMax1[i], pvTmpMax2[i]);

				unsigned short *nMin = (unsigned short *)&vMin;
				unsigned short *nMax = (unsigned short *)&vMax;

				unsigned short nMinValue, nMaxValue;
				nMinValue = __min(nMin[0], nMin[1]);
				nMinValue = __min(nMinValue, nMin[2]);
				nMinValue = __min(nMinValue, nMin[3]);

				nMaxValue = __max(nMax[0], nMax[1]);
				nMaxValue = __max(nMaxValue, nMax[2]);
				nMaxValue = __max(nMaxValue, nMax[3]);

				m_pmmBuffer8x8[nBufIndex + i].nMin = nMinValue;
				m_pmmBuffer8x8[nBufIndex + i].nMax = nMaxValue;
			}
		}
	}

	// free
	_mm_free(pvTmpMin1);
	_mm_free(pvTmpMin2);
	_mm_free(pvTmpMin3);

	_mm_free(pvTmpMax1);
	_mm_free(pvTmpMax2);
	_mm_free(pvTmpMax3);

	_mm_empty();

	return TRUE;
}

BOOL inline RxBlockData::SliceMinMax8x8(int iX, int iY, __m64 *vVolume, __m64 *pMinBuf, __m64 *pMaxBuf)
{
	int nVolIndex;
	int nIndex = 0;
	int nBlockNumX = (iX + 7) / 8;

	__m64 *pvTmpMin1 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMin2 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMin3 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);

	__m64 *pvTmpMax1 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMax2 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);
	__m64 *pvTmpMax3 = (__m64 *)_mm_malloc(nBlockNumX * sizeof(__m64), CACHESIZE);

	memset(pvTmpMin1, 0x7f, nBlockNumX * sizeof(__m64));
	memset(pvTmpMax1, 0x00, nBlockNumX * sizeof(__m64));

	// 霉 何盒 抗寇 贸府
	for (int y = 0; y < 4; y++) {
		nVolIndex = y * iX / 4;
		ScanlineMinMax8x8(iX, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

		for (int i = 0; i < nBlockNumX; i++) {
			pvTmpMin1[i] = _mm_min_pi16(pvTmpMin1[i], pvTmpMin3[i]);
			pvTmpMax1[i] = _mm_max_pi16(pvTmpMax1[i], pvTmpMax3[i]);
		}
	}

	// main loop
	for (y = 4; y < iY - 7; y += 8) {
		memset(pvTmpMin2, 0x7f, nBlockNumX * sizeof(__m64));
		memset(pvTmpMax2, 0x00, nBlockNumX * sizeof(__m64));

		for (int i = 0; i < 8; i++) {
			nVolIndex = (y + i) * iX / 4;
			ScanlineMinMax8x8(iX, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

			for (int j = 0; j < nBlockNumX; j++) {
				pvTmpMin2[j] = _mm_min_pi16(pvTmpMin2[j], pvTmpMin3[j]);
				pvTmpMax2[j] = _mm_max_pi16(pvTmpMax2[j], pvTmpMax3[j]);
			}
		}

		int nBufIndex = nIndex * nBlockNumX;

		for (int j = 0; j < nBlockNumX; j++) {
			pMinBuf[nBufIndex + j] = _mm_min_pi16(pvTmpMin1[j], pvTmpMin2[j]);
			pMaxBuf[nBufIndex + j] = _mm_max_pi16(pvTmpMax1[j], pvTmpMax2[j]);
		}

		// for reuse
		__m64 *pMin = pvTmpMin1;
		__m64 *pMax = pvTmpMax1;

		pvTmpMin1 = pvTmpMin2;
		pvTmpMax1 = pvTmpMax2;

		pvTmpMin2 = pMin;
		pvTmpMax2 = pMax;

		nIndex++;
	}

	// 付瘤阜 何盒 抗寇 贸府
	if (iY % 8 == 0) {
		memset(pvTmpMin2, 0x7f, nBlockNumX * sizeof(__m64));
		memset(pvTmpMax2, 0x00, nBlockNumX * sizeof(__m64));

		for (int i = 0; i < 4; i++) {
			nVolIndex = (iY - 4 + i) * iX / 4;
			ScanlineMinMax8x8(iX, vVolume + nVolIndex, pvTmpMin3, pvTmpMax3);

			for (int j = 0; j < nBlockNumX; j++) {
				pvTmpMin2[j] = _mm_min_pi16(pvTmpMin2[j], pvTmpMin3[j]);
				pvTmpMax2[j] = _mm_max_pi16(pvTmpMax2[j], pvTmpMax3[j]);
			}

		}

		int nBufIndex = nIndex * nBlockNumX;

		for (int j = 0; j < nBlockNumX; j++) {
			pMinBuf[nBufIndex + j] = _mm_min_pi16(pvTmpMin1[j], pvTmpMin2[j]);
			pMaxBuf[nBufIndex + j] = _mm_max_pi16(pvTmpMax1[j], pvTmpMax2[j]);
		}
	}
	else {
		int nBufIndex = nIndex * nBlockNumX;

		for (int j = 0; j < nBlockNumX; j++) {