maskvolume.cpp

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

	_mm_free(pTmpSlice2);
	_mm_free(pTmpSlice3);
	
	return TRUE;
}

inline BOOL RxMaskVolume::SliceMinMax2x2(unsigned char *pMask, unsigned char *pSliceMinMax)
{
	int nScanlineSize = m_iVolX / 8;

	unsigned char *pTmp1 = (unsigned char *)_mm_malloc(nScanlineSize, CACHESIZE);
	unsigned char *pTmp2 = (unsigned char *)_mm_malloc(nScanlineSize, CACHESIZE);

	// first scanline
	memcpy(pTmp1, pMask, nScanlineSize);

	int nSliceIndex = 0;

	// main
	for (int y = 1; y < m_iVolY - 2; y += 2) {
		int nMaskIndex1 = y * nScanlineSize;
		int nMaskIndex2 = nMaskIndex1 + nScanlineSize;

		for (int x = 0; x < nScanlineSize; x++) {
			pTmp2[x] = pMask[nMaskIndex1 + x] | pMask[nMaskIndex1 + x];
			pSliceMinMax[nSliceIndex] = pTmp1[x] | pTmp2[x];

			nSliceIndex++;
		}

		// for reuse, swap
		unsigned char *tmp = pTmp1;
		pTmp1 = pTmp2;
		pTmp2 = tmp;
	}

	// last scanline
	int nIndex = (m_iVolY - 1) * nScanlineSize;
	memcpy(pTmp2, pMask + nIndex, nScanlineSize);

	for (int x = 0; x < nScanlineSize; x++) {
		pSliceMinMax[nSliceIndex] = pTmp1[x] | pTmp2[x];

		nSliceIndex++;
	}

	// free
	_mm_free(pTmp1);
	_mm_free(pTmp2);

	return TRUE;
}

BOOL RxMaskVolume::CreateMinMax8x8()
{
	// (X+7)/8 * (Y+7)/8 * (Z+7)/8 / 8
	m_iMinMaxSize8x8 = m_iVolX8x8 * m_iVolY8x8 * m_iVolZ8x8 / 8;
//	m_iMinMaxSize8x8 = (m_iVolX8x8/8) * ((m_iVolY+7)/8) * ((m_iVolZ+7)/8) / 8;

	m_pbyMinMax8x8 = (LPBYTE)VirtualAlloc(NULL, m_iMinMaxSize8x8, MEM_RESERVE | MEM_TOP_DOWN | MEM_COMMIT, PAGE_READWRITE);

	if (m_pbyMinMax2x2 == NULL)
		return NULL;

	int nSliceSize = m_iVolY8x8 * m_iVolX / 8;
	int nScanlineSize = m_iVolX / 8;

	// tmp buffer
	// size = X * (Y+7)/8 * (Z+7)/8 / 8;
	unsigned char *pbyTmpMinMax = (unsigned char *)_mm_malloc(m_iVolX * ((m_iVolY+7)/8) * ((m_iVolZ+7)/8) / 8, CACHESIZE);

	unsigned char *pTmpSlice1 = (unsigned char *)_mm_malloc(nSliceSize, CACHESIZE);
	unsigned char *pTmpSlice2 = (unsigned char *)_mm_malloc(nSliceSize, CACHESIZE);
	unsigned char *pTmpSlice3 = (unsigned char *)_mm_malloc(nSliceSize, CACHESIZE);

	int nMaskSize = m_iVolY * m_iVolX / 8;

	// z啊 4厘 捞窍老锭 抗寇 贸府
	if (m_iVolZ < 5) {
		memset(pTmpSlice1, 0, nSliceSize);

		for (int z = 0; z < m_iVolZ; z++) {
			int nMaskIndex = z * nMaskSize;

			SliceMinMax8x8(m_pbyMask + nMaskIndex, pTmpSlice3);

			int nIndex = 0;

			for (int y = 0; y < m_iVolY8x8; y++) {
				for (int x = 0; x < nScanlineSize; x++) {
					pTmpSlice1[nIndex] |= pTmpSlice3[nIndex];
					
					nIndex++;
				}
			}
		}
	}
	else {
		// 霉何盒 抗寇 贸府
		memset(pTmpSlice1, 0, nSliceSize);

		for (int z = 0; z < 4; z++) {
			int nMaskIndex = z * nMaskSize;

			SliceMinMax8x8(m_pbyMask + nMaskIndex, pTmpSlice3);

			int nIndex = 0;

			for (int y = 0; y < m_iVolY8x8; y++) {
				for (int x = 0; x < nScanlineSize; x++) {
					pTmpSlice1[nIndex] |= pTmpSlice3[nIndex];

					nIndex++;
				}
			}
		}

		int nMinMaxIndex = 0;

		// main
		for (z = 4; z < m_iVolZ - 8; z += 8) {
			memset(pTmpSlice2, 0, nSliceSize);

			for (int i = 0; i < 8; i++) {
				int nMaskIndex = (z + i) * nMaskSize;

				SliceMinMax8x8(m_pbyMask + nMaskIndex, pTmpSlice3);

				int nIndex = 0;

				for (int y = 0; y < m_iVolY8x8; y++) {
					for (int x = 0; x < nScanlineSize; x++) {
						pTmpSlice2[nIndex] |= pTmpSlice3[nIndex];

						nIndex++;
					}
				}
			}

			int nIndex = 0;

			for (int y = 0; y < m_iVolY8x8; y++) {
				for (int x = 0; x < nScanlineSize; x++) {
					pbyTmpMinMax[nMinMaxIndex] = pTmpSlice1[nIndex] | pTmpSlice2[nIndex];

					nIndex++;
					nMinMaxIndex++;
				}
			}

			// for reuse, swap
			unsigned char *tmp = pTmpSlice1;
			pTmpSlice1 = pTmpSlice2;
			pTmpSlice2 = tmp;
		}

		// 场何盒 抗寇 贸府
		if ((m_iVolZ - 1) % 8 < 4) {
			memset(pTmpSlice2, 0, nSliceSize);

			for (z = (m_iVolZ - 1) / 8 * 8 - 4; z < m_iVolZ; z++) {
				int nMaskIndex = z * nMaskSize;

				SliceMinMax8x8(m_pbyMask + nMaskIndex, pTmpSlice3);

				int nIndex = 0;

				for (int y = 0; y < m_iVolY8x8; y++) {
					for (int x = 0; x < nScanlineSize; x++) {
						pTmpSlice2[nIndex] |= pTmpSlice3[nIndex];

						nIndex++;
					}
				}
			}

			int nIndex = 0;

			for (int y = 0; y < m_iVolY8x8; y++) {
				for (int x = 0; x < nScanlineSize; x++) {
					pbyTmpMinMax[nMinMaxIndex] = pTmpSlice1[nIndex] | pTmpSlice2[nIndex];

					nIndex++;
					nMinMaxIndex++;
				}
			}
		}
		else {
			memcpy(pbyTmpMinMax + nMinMaxIndex, pTmpSlice1, nSliceSize);
		}
	}

	// x绵
	IplImage *srcImage = iplCreateImageHeader(
		1, 0, IPL_DEPTH_1U, // data of byte type
		"Gray", "Gray", // color order
		IPL_DATA_ORDER_PIXEL, // channel arrangement
		IPL_ORIGIN_TL, // top left orientation
		IPL_ALIGN_DWORD, // 4 bytes align
		m_iVolX, m_iVolY8x8,	// image height
		NULL, NULL, NULL, NULL); // not tiled

	if (NULL == srcImage)
		return FALSE;

	IplImage *dstImage = iplCreateImageHeader(
		1, 0, IPL_DEPTH_1U, // data of byte type
		"Gray", "Gray", // color order
		IPL_DATA_ORDER_PIXEL, // channel arrangement
		IPL_ORIGIN_TL, // top left orientation
		IPL_ALIGN_DWORD, // 4 bytes align
		m_iVolX, m_iVolY8x8,	// image height
		NULL, NULL, NULL, NULL); // not tiled

	if (NULL == dstImage)
		return FALSE;

	dstImage->imageData = (char *)pTmpSlice1;

	IplImage *DecimateImage = iplCreateImageHeader(
		1, 0, IPL_DEPTH_1U, // data of byte type
		"Gray", "Gray", // color order
		IPL_DATA_ORDER_PIXEL, // channel arrangement
		IPL_ORIGIN_TL, // top left orientation
		IPL_ALIGN_DWORD, // 4 bytes align
		m_iVolX8x8, m_iVolY8x8,	// image height
		NULL, NULL, NULL, NULL); // not tiled

	if (NULL == DecimateImage)
		return FALSE;

	// z * (Y+7)/8 * (X+7)/8 / 8
	int nSize = m_iVolY8x8 * m_iVolX8x8 / 8;

	for (int z = 0; z < (m_iVolZ + 7) / 8; z++) {
		srcImage->imageData = (char *)(pbyTmpMinMax + z * nSliceSize);
		DecimateImage->imageData = (char *)(m_pbyMinMax8x8 + z * nSize);

		iplMaxFilter(srcImage, dstImage, 12, 1, 0, 0);

		iplDecimate(dstImage, DecimateImage, m_iVolX8x8, m_iVolX, m_iVolY8x8, m_iVolY8x8, IPL_INTER_NN);
	}

	iplDeallocate(srcImage, IPL_IMAGE_HEADER);
	iplDeallocate(dstImage, IPL_IMAGE_HEADER);
	iplDeallocate(DecimateImage, IPL_IMAGE_HEADER);

	_mm_free(pbyTmpMinMax);
	_mm_free(pTmpSlice1);
	_mm_free(pTmpSlice2);
	_mm_free(pTmpSlice3);

	return TRUE;
}

inline BOOL RxMaskVolume::SliceMinMax8x8(unsigned char *pMask, unsigned char *pSliceMinMax)
{
	int nScanlineSize = m_iVolX / 8;

	unsigned char *pTmp1 = (unsigned char *)_mm_malloc(nScanlineSize, CACHESIZE);
	unsigned char *pTmp2 = (unsigned char *)_mm_malloc(nScanlineSize, CACHESIZE);

	memset(pTmp1, 0, nScanlineSize);

	// 霉何盒 抗寇 贸府
	for (int y = 0; y < 4; y++) {
		int nMaskIndex = y * nScanlineSize;

		for (int x = 0; x < nScanlineSize; x++) {
			pTmp1[x] |= pMask[nMaskIndex + x];
		}
	}

	int nSliceIndex = 0;

	// main
	for (y = 4; y < m_iVolY - 7; y += 8) {
		memset(pTmp2, 0, nScanlineSize);

		for (int i = 0; i < 8; i++) {
			int nMaskIndex = (y + i) * nScanlineSize;

			for (int x = 0; x < nScanlineSize; x++) {
				pTmp2[x] |= pMask[nMaskIndex + x];
			}
		}

		for (int x = 0; x < nScanlineSize; x++) {
			pSliceMinMax[nSliceIndex] = pTmp1[x] | pTmp2[x];

			nSliceIndex++;
		}

		// for reuse, swap
		unsigned char *tmp = pTmp1;
		pTmp1 = pTmp2;
		pTmp2 = tmp;
	}

	// 付瘤阜 何盒 抗寇 贸府
	// y绰 4狼 硅荐
	if (m_iVolY % 8 == 0) {
		memset(pTmp2, 0, nScanlineSize);

		for (int i = 0; i < 4; i++) {
			int nMaskIndex = (m_iVolY - 4 + i) * nScanlineSize;

			for (int x = 0; x < nScanlineSize; x++) {
				pTmp2[x] |= pMask[nMaskIndex + x];
			}
		}

		for (int x = 0; x < nScanlineSize; x++) {
			pSliceMinMax[nSliceIndex] = pTmp1[x] | pTmp2[x];

			nSliceIndex++;
		}
	}
	else {
		memcpy(pSliceMinMax + nSliceIndex, pTmp1, nScanlineSize);
	}	

	_mm_free(pTmp1);
	_mm_free(pTmp2);

	return TRUE;
}

void RxMaskVolume::AssignMaskVolume(unsigned char* pbyNewMaskVol)
{
	DestroyMaskVolume();

	m_pbyMask = pbyNewMaskVol;
}

BOOL RxMaskVolume::CreateMinMax()
{
	BOOL bRet = TRUE;

	// x : 4 byte padding 困秦
	m_iVolX2x2 = ((m_iVolX / 2) + 31) / 32 * 32;
	m_iVolY2x2 = m_iVolY / 2;
	m_iVolZ2x2 = (m_iVolZ + 1) / 2;

	m_iVolX8x8 = (((m_iVolX+7) / 8) + 31) / 32 * 32;
	m_iVolY8x8 = (m_iVolY + 7) / 8;
	m_iVolZ8x8 = (m_iVolZ + 7) / 8;

	bRet &= CreateMinMax2x2();
	bRet &= CreateMinMax8x8();

	// memset(m_pbyMinMax2x2, 0xff, m_iMinMaxSize2x2);

	return bRet;
}

BOOL RxMaskVolume::CopyMaskVolume(const RxMaskVolume* pmvSrc)
{
	// size啊 促弗搁 copy 救凳
	if (m_iVolX != pmvSrc->m_iVolX || m_iVolY != pmvSrc->m_iVolY || m_iVolZ != pmvSrc->m_iVolZ)
		return FALSE;

	::CopyMemory(m_pbyMask, pmvSrc->m_pbyMask, m_iMaskSize);

	return TRUE;
}