rxysegment_temp.cpp

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

		nPatient = 3;
	if (PATIENT_4)
		nPatient = 4;
	if (PATIENT_5)
		nPatient = 5;
	if (PATIENT_6)
		nPatient = 6;
	if (PATIENT_7)
		nPatient = 7;
	if (PATIENT_8)
		nPatient = 8;
	if (PATIENT_9)
		nPatient = 9;
	if (PATIENT_10)
		nPatient = 10;

	switch (nPatient)
	{
	case 1:		{
		nNumNodule = 1;
		int TMPthreshold[100] = {500};
		int TMPnErose[100] = {3};
		int TMPRefNodulePos[100] = {124, 375, 358 - 175};
		int TMPFloatNodulePos[100] = {134, 371, 316 - 175};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 2:		{
		nNumNodule = 1;
		int TMPthreshold[100] = {500};
		int TMPnErose[100] = {2};
		int TMPRefNodulePos[100] = {397, 209, 270 - (111 - 30)};
		int TMPFloatNodulePos[100] = {393, 241, 270 - (127 - 60)};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 3:		{
		nNumNodule = 1;
		int TMPthreshold[100] = {500};
		int TMPnErose[100] = {3};
		int TMPRefNodulePos[100] = {321, 205, 407 - 91};
		int TMPFloatNodulePos[100] = {322, 176, 454 - 111};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 4:		{
		nNumNodule = 2;
		int TMPthreshold[100] = {500, 500};
		int TMPnErose[100] = {2, 2}; 
		if (nMode == 1)
			TMPnErose[0] = 3;
		int TMPRefNodulePos[100] = {115, 335, 446 - 91, 193, 290, 446 - 239}; 
		int TMPFloatNodulePos[100] = {117, 351, 379 - 71, 180, 302, 379 - 215};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 5:		{
		nNumNodule = 8; 
		int TMPthreshold[100] = {500, 500, 500, 1050, 500, 500, 500, 500};
		int TMPnErose[100] = {1, 3, 3, 1, 1, 4, 5, 1};
		if (nMode == 1)
		{
			TMPnErose[1] = 1; // 4鳖瘤 沁菌澜
		}
		int TMPRefNodulePos[100] = {367, 319, 301 -  51, 114, 358, 301 -  83, 336, 292, 301 -  83, 434, 290, 301 -  107, 
			407, 279, 301 -  147, 99, 245, 301 -  187, 140, 304, 301 -  187, 369, 246, 301 - 183, 369, 246, 301 - 183}; 
		int TMPFloatNodulePos[100] = {383, 305, 311 - 47, 96, 349, 311 - 87, 345, 269, 311 - 87, 465, 263, 311 - 103, 
			437, 246, 311 - 147, 75, 213, 311 - 191, 123, 280, 311 - 191, 390, 205, 311 - 183, 390, 205, 311 - 183};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 6:		{
		nNumNodule = 1;
		int TMPthreshold[100] = {500};
		int TMPnErose[100] = {2};
		if (nMode == 1)
		{
			TMPnErose[0] = 3;
		}
		int TMPRefNodulePos[100] = {427, 349, 60 - 40};
		int TMPFloatNodulePos[100] = {414, 339, 54 - 36};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 7:		{
		nNumNodule = 3;
		int TMPthreshold[100] = {250, 500, 250};
		int TMPnErose[100] = {1, 1, 1};
		int TMPRefNodulePos[100] = {379, 368, 41 - 15, 104, 330, 41 - 21, 198, 414, 41 - 28};
		int TMPFloatNodulePos[100] = {354, 366, 37 - 13, 113, 297, 37 - 19, 190, 384, 37 - 26};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 8:		{
		nNumNodule = 2;
		int TMPthreshold[100] = {500, 500};
		int TMPnErose[100] = {1, 2};
		int TMPRefNodulePos[100] = {394, 161, 62 - 26, 448, 321, 62 - 49};
		int TMPFloatNodulePos[100] = {379, 179, 57 - 28, 443, 306, 57 - 51};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 9:		{
		nNumNodule = 2;
		int TMPthreshold[100] = {200, 400};
		int TMPnErose[100] = {3, 2};
		if (nMode == 1)
		{
			TMPnErose[0] = 2;
			TMPthreshold[0] = 500;
			TMPnErose[1] = 1;
			TMPthreshold[1] = 400;
		}
		int TMPRefNodulePos[100] = {380, 268, 62 - 16, 213, 121, 62 - 39};
		int TMPFloatNodulePos[100] = {392, 277, 61 - 16, 216, 95, 61 - 38};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	case 10:	{
		nNumNodule = 4;
		int TMPthreshold[100] = {1000, 800, 520, 900};
		int TMPnErose[100] = {1, 1, 1, 1};
		if (nMode == 1)
		{
			TMPthreshold[2] = 800;
			TMPthreshold[3] = 500;
		}
		int TMPRefNodulePos[100] = {183, 369, 68 - 40, 327, 323, 68 - 48, 159, 373, 68 - 52, 438, 142, 68 - 55};
		int TMPFloatNodulePos[100] = {171, 357, 57 - 34, 317, 333, 57 - 41, 144, 357, 57 - 46, 453, 177, 57 - 48};

		for (int i = 0; i < nNumNodule; i++)
		{
			threshold[i] = TMPthreshold[i];
			nErose[i] = TMPnErose[i];
			RefNodulePos[3*i] = TMPRefNodulePos[3*i];
			RefNodulePos[3*i + 1] = TMPRefNodulePos[3*i + 1];
			RefNodulePos[3*i + 2] = TMPRefNodulePos[3*i + 2];
			FloatNodulePos[3*i] = TMPFloatNodulePos[3*i];
			FloatNodulePos[3*i + 1] = TMPFloatNodulePos[3*i + 1];
			FloatNodulePos[3*i + 2] = TMPFloatNodulePos[3*i + 2];
		}		}
		break;
	}

	/*unsigned char pErosionMask[49];
	unsigned char pDilationMask[49];
	// Erosion Mask
	for(j=0; j<7; j++) {
		for(i=0; i<7; i++) {
			if( (i-3)*(i-3) + (j-3)*(j-3) <= 9)
				pErosionMask[i + 7*j] = 255;
			else pErosionMask[i + 7*j] = 0;
		}
	}
	// Dilation mask		
	for(j=0; j<7; j++) {
		for(i=0; i<7; i++) {
			if( (i-3)*(i-3) + (j-3)*(j-3) <= 9)
				pDilationMask[i + 7*j] = 0;
			else pDilationMask[i + 7*j] = 255;
		}
	}*/

	CurrentTime = GetTickCount ();

	pVolumeData = RxGetVolumeData(nMode); // 0 : Reference, 1 : float, 2 : combine
	pVolumeData->m_nMode = nMode;
	RxMaskVolume *pMask = pVolumeData->GetNoduleVolume();
	unsigned short *pRefVolume = pVolumeData->GetBigVolume();
	pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
	nImageSize = iVolX*iVolY*iSliceNum;
	nSliceSize = iVolX*iVolY;
	pVolumeData->m_nNumNodule = nNumNodule;

	for (int num = 0; num < pVolumeData->m_nNumNodule; num++)
	{
		if (nMode == 0)
		{
			ptNudulePos.x = RefNodulePos[num*3];
			ptNudulePos.y = RefNodulePos[num*3 + 1];
			ptNudulePos.z = RefNodulePos[num*3 + 2];
		} else
		{
			ptNudulePos.x = FloatNodulePos[num*3];
			ptNudulePos.y = FloatNodulePos[num*3 + 1];
			ptNudulePos.z = FloatNodulePos[num*3 + 2];
		}

		ptMinBound.x = ptNudulePos.x - NoduleSizeXY;
		ptMinBound.y = ptNudulePos.y - NoduleSizeXY;
		ptMinBound.z = ptNudulePos.z - NoduleSizeZ;

		if (ptMinBound.x < 0)
			ptMinBound.x = 0;
		if (ptMinBound.y < 0)
			ptMinBound.y = 0;
		if (ptMinBound.z < 0)
			ptMinBound.z = 0;

		ptMaxBound.x = ptNudulePos.x + NoduleSizeXY;
		ptMaxBound.y = ptNudulePos.y + NoduleSizeXY;
		ptMaxBound.z = ptNudulePos.z + NoduleSizeZ;

		if (nPatient == 4 && nMode == 1 && num == 1)
		{
			ptMinBound.x = ptNudulePos.x - 10;
			ptMinBound.y = ptNudulePos.y - 10;
			ptMinBound.z = ptNudulePos.z - 2;

			if (ptMinBound.z < 0)
				ptMinBound.z = 0;

			ptMaxBound.x = ptNudulePos.x + 10;
			ptMaxBound.y = ptNudulePos.y + 10;
			ptMaxBound.z = ptNudulePos.z + 2;
		}

		if ((nPatient == 5 && num == 1 && nMode == 1) || (nPatient == 5 && num == 4 && nMode == 1))
		{
			ptMinBound.x = ptNudulePos.x - 10;
			ptMinBound.y = ptNudulePos.y - 10;
			ptMinBound.z = ptNudulePos.z - 4;

			if (ptMinBound.z < 0)
				ptMinBound.z = 0;

			ptMaxBound.x = ptNudulePos.x + 10;
			ptMaxBound.y = ptNudulePos.y + 10;
			ptMaxBound.z = ptNudulePos.z + 4;
		}

		if (nPatient == 8 && num == 1)
		{
			ptMinBound.x = ptNudulePos.x - 5;
			ptMinBound.y = ptNudulePos.y - 5;
			ptMinBound.z = ptNudulePos.z - 1;

			if (ptMinBound.z < 0)
				ptMinBound.z = 0;

			ptMaxBound.x = ptNudulePos.x + 5;
			ptMaxBound.y = ptNudulePos.y + 5;
			ptMaxBound.z = ptNudulePos.z + 1;
		}

		if (nPatient == 9 && num == 1)
		{
			ptMinBound.x = ptNudulePos.x - 5;
			ptMinBound.y = ptNudulePos.y - 5;
			ptMinBound.z = ptNudulePos.z - 1;

			if (ptMinBound.z < 0)
				ptMinBound.z = 0;

			ptMaxBound.x = ptNudulePos.x + 5;
			ptMaxBound.y = ptNudulePos.y + 5;
			ptMaxBound.z = ptNudulePos.z + 1;
		}

		if (nPatient == 10 && num == 3 && nMode == 1)
		{
			ptMinBound.x = ptNudulePos.x - 5;
			ptMinBound.y = ptNudulePos.y - 5;
			ptMinBound.z = ptNudulePos.z - 1;

			if (ptMinBound.z < 0)
				ptMinBound.z = 0;

			ptMaxBound.x = ptNudulePos.x + 5;
			ptMaxBound.y = ptNudulePos.y + 5;
			ptMaxBound.z = ptNudulePos.z + 1;
		}

		// 3D region growing
		pLabel = new unsigned char[nImageSize];
		memset(pLabel, 0x00, sizeof(unsigned char)*nImageSize);
		SRG3D_LineMinMax(ptNudulePos.x, ptNudulePos.y, ptNudulePos.z, 
			pRefVolume, pLabel, iVolX, iVolY, iSliceNum, 
			threshold[num], 2000);

		// erosion
		unsigned char* pSrc = new unsigned char[nSliceSize];
		unsigned char* pTmp = new unsigned char[nSliceSize];
		
		for(k = ptMinBound.z; k <= ptMaxBound.z; k++) 
		{
			for(j = 0; j < iVolY; j++) 
			{
				for(i = 0; i < iVolX; i++) 
				{
					index = i + j*iVolX + k*iVolX*iVolY;
					if(pLabel[index] != 0)
						pSrc[i+j*iVolX] = 255;
					else
						pSrc[i+j*iVolX] = 0;		
				}
			}
			Erose(pSrc, pTmp, iVolX, iVolY, nErose[num]);
			for(j = 0; j < iVolY; j++) 
			{
				for(i = 0; i < iVolX; i++) 
				{
					index = i + j*iVolX + k*iVolX*iVolY;
					if(pTmp[i+j*iVolX])
						pLabel[index] = 1;
					else
						pLabel[index] = 0;
				}
			}
		}
		
		pTempVol = new unsigned short[nImageSize];
		memset(pTempVol, 0x00, sizeof(unsigned short)*nImageSize);
		
		for(k = 0; k < iSliceNum; k++) 
		{
			for(j = 0; j < iVolY; j++) 
			{
				for(i = 0; i < iVolX; i++) 
				{
					index = i + j*iVolX + k*iVolX*iVolY;
					if(pLabel[index] != 0)
						pTempVol[index] = 1000;
				}
			}
		}
		
		// 3D region growing in erosion volume
		memset(pLabel, 0x00, sizeof(unsigned char)*nImageSize);
		SRG3D_LineMinMax(ptNudulePos.x, ptNudulePos.y, ptNudulePos.z,
			pTempVol, pLabel, iVolX, iVolY, iSliceNum, 
			500, 2000);
		delete [] pTempVol;

		int nCountVoxelInNodule = 0;
		pVolumeData->m_nNoduleCenterX[num] = 0;
		pVolumeData->m_nNoduleCenterY[num] = 0;
		pVolumeData->m_nNoduleCenterZ[num] = 0;

		// dilation
		for(k = ptMinBound.z; k <= ptMaxBound.z; k++) 
		{
			for(j = 0; j < iVolY; j++) 
			{
				for(i = 0; i < iVolX; i++) 
				{
					index = i + j*iVolX + k*iVolX*iVolY;
					if(pLabel[index] != 0)
						pSrc[i+j*iVolX] = 255;
					else
						pSrc[i+j*iVolX] = 0;		
				}
			}
			Dilate(pSrc, pTmp, iVolX, iVolY, nErose[num]);
			for(j = ptMinBound.y; j < ptMaxBound.y; j++) 
			{
				for(i = ptMinBound.x; i < ptMaxBound.x; i++) 
				{
					index = i + j*iVolX + k*iVolX*iVolY;
					if(pTmp[i+j*iVolX])
					{
						pMask->SetMask(i, j, k);

						nCountVoxelInNodule++;
						pVolumeData->m_nNoduleCenterX[num] += i;
						pVolumeData->m_nNoduleCenterY[num] += j;
						pVolumeData->m_nNoduleCenterZ[num] += k;
					}
				}
			}
		}

		pVolumeData->m_nNoduleCenterX[num] = pVolumeData->m_nNoduleCenterX[num]/nCountVoxelInNodule;
		pVolumeData->m_nNoduleCenterY[num] = pVolumeData->m_nNoduleCenterY[num]/nCountVoxelInNodule;
		pVolumeData->m_nNoduleCenterZ[num] = pVolumeData->m_nNoduleCenterZ[num]/nCountVoxelInNodule;

		delete[] pSrc;
		delete[] pTmp;

		if(pLabel)
			delete [] pLabel;

	}
}