fmwndlocalizer.bak.txt

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

void RxFMWndLocalizer::OnPaint() 
{
	CPaintDC dc(this);
	// CDC *pDC = GetDC();

	CRect		rect;
	GetClientRect(rect);

	int iBkMode;
	CDC memDC, transparentMemDC;
	memDC.CreateCompatibleDC(&dc);

	CBitmap bitmap, transparentBitmap;
	CBitmap *pOldBitmap;

	CPen penGreen, *pOldPen;
	bitmap.CreateCompatibleBitmap(&dc, m_szWindow.cx, m_szWindow.cy);
	pOldBitmap = (CBitmap*)memDC.SelectObject(&bitmap);
	
	if (m_pDib && m_bUpdate) {
		CPoint ptOrigin(m_szWindow - m_szDIB);
		CSingleLock lockDib(GetOwnCriticalSection());
		lockDib.Lock();
		ptOrigin.x /= 2;
		ptOrigin.y /= 2;
		if (!m_bAfterFusion) //Fusion捞饶俊绰 捞固 PanOffset阑 利侩秦辑 捞固瘤甫 夺惑怕促.
			ptOrigin += m_ptImgPanOffset;
		m_pDib->Draw(&memDC, ptOrigin, m_szDIB);
		lockDib.Unlock();
		// calculate hvindex
		Vol2HVIndex();
	}

	// cross line drawing
/*	penGreen.CreatePen(PS_SOLID, 1, RGB_CROSS_HAIR);
	iBkMode = memDC.SetBkMode(TRANSPARENT);
	pOldPen = memDC.SelectObject(&penGreen);
	memDC.MoveTo(0, m_iVIndex);
	memDC.LineTo(m_szWindow.cx, m_iVIndex);
	memDC.MoveTo(m_iHIndex, 0);
	memDC.LineTo(m_iHIndex, m_szWindow.cy);
	memDC.SelectObject(pOldPen);
*/
	dc.BitBlt(0, 0, m_szWindow.cx, m_szWindow.cy, &memDC, 0, 0, SRCCOPY);

	// DC 汗盔 
	memDC.SelectObject(pOldBitmap);	
	memDC.DeleteDC();

	transparentMemDC.CreateCompatibleDC(&dc);
	transparentBitmap.CreateCompatibleBitmap(&dc, m_szWindow.cx, m_szWindow.cy);
	pOldBitmap = (CBitmap*)transparentMemDC.SelectObject(&transparentBitmap);
/*
	// draw lung nodules
	RxPoint3D<double> pt3DPathInImage;
	int i;

	if (m_btnMode == BTN_PAN)//m_bNoduleDisplay)
	{
		switch(m_iRFCNum)
		{
		case REFERENCE_MODE:
			// Reference Nodule
			for(i = 0; i < g_arrRefNodule.m_nNumNodule; i++) 
			{
				pt3DPathInImage.x = g_arrRefNodule.m_arrNodulePosX[i];
				pt3DPathInImage.y = g_arrRefNodule.m_arrNodulePosY[i];
				pt3DPathInImage.z = g_arrRefNodule.m_arrNodulePosZ[i];
				
				DrawLungNodule(pt3DPathInImage, &dc, TRUE);
			}
			break;
		case FLOAT_MODE:
			// Float Nodule
			for(i = 0; i < g_arrFloatNodule.m_nNumNodule; i++) 
			{
				pt3DPathInImage.x = g_arrFloatNodule.m_arrNodulePosX[i];
				pt3DPathInImage.y = g_arrFloatNodule.m_arrNodulePosY[i];
				pt3DPathInImage.z = g_arrFloatNodule.m_arrNodulePosZ[i];
				
				DrawLungNodule(pt3DPathInImage, &dc, FALSE);
			}
			break;
		case COMBINED_MODE:
			// Reference Nodule
			for(i = 0; i < g_arrRefNodule.m_nNumNodule; i++) 
			{
				pt3DPathInImage.x = g_arrRefNodule.m_arrNodulePosX[i];
				pt3DPathInImage.y = g_arrRefNodule.m_arrNodulePosY[i];
				pt3DPathInImage.z = g_arrRefNodule.m_arrNodulePosZ[i];
				
				DrawLungNodule(pt3DPathInImage, &dc, TRUE);
			}
			// Float Nodule
			for(i = 0; i < g_arrFloatNodule.m_nNumNodule; i++) 
			{
				RxVolumeData* pRefVolume;	
				int x, y, z, nIntVolZ;
				pRefVolume = RxGetVolumeData(1);	
				pRefVolume->GetBigVolumeDmsn(&x, &y, &z);	
				nIntVolZ = pRefVolume->GetInterpolatedSliceNum();
		
				RxMatrix4D m_mxRegistration;

				RxFMWndVR* pFMWndVR = RxGetFrameMain()->m_pFMWndVR[2];
				RxTransform3DInfo *pTransform = pFMWndVR->m_pTransform;

				m_mxRegistration.LoadIdentity();
				m_mxRegistration.Translate(-g_FloatCenX, -g_FloatCenY, g_iFloatBinaryTransZ - g_FloatCenZ);
				m_mxRegistration.Scale(pTransform->xscale, pTransform->yscale, g_lfFloatRatioZ*pTransform->zscale);
				m_mxRegistration.Rotate(0, pTransform->xrot);
				m_mxRegistration.Rotate(1, pTransform->yrot);
				m_mxRegistration.Rotate(2, pTransform->zrot);
				m_mxRegistration.Translate(g_RefCenX + pTransform->xmove, g_RefCenY + pTransform->ymove, 0.0);
				m_mxRegistration.Scale(1.0, 1.0, 1.0/g_lfRefRatioZ);
				m_mxRegistration.Translate(0.0, 0.0, -g_iRefBinaryTransZ + g_RefCenZ + pTransform->zmove);
			
				pt3DPathInImage.x = g_arrFloatNodule.m_arrNodulePosX[i];
				pt3DPathInImage.y = g_arrFloatNodule.m_arrNodulePosY[i];
				pt3DPathInImage.z = g_arrFloatNodule.m_arrNodulePosZ[i]/(double)nIntVolZ*(double)z;;

				RxVect4D registPoint;
				registPoint = m_mxRegistration * RxVect4D (pt3DPathInImage.x, pt3DPathInImage.y, pt3DPathInImage.z, 1.0);
				pt3DPathInImage.x = registPoint.m[0];
				pt3DPathInImage.y = registPoint.m[1];
				pt3DPathInImage.z = registPoint.m[2]*(double)nIntVolZ/(double)z;

				DrawLungNodule(pt3DPathInImage, &dc, FALSE);
			}
			break;
		}
	}
*/
	/////////////////////////////////////////////////////////////
	// yeni
	// for outlining the lung surface

	float fRatioZ;
	int nNumOfFeatureR, nNumOfFeatureL;
	int iVolX, iVolY, iSliceNum, iIntVolZ;
	RxVolumeData* pVolumeData;
	CPoint pt;
	int i, j, k, nSlice;
	int nFeatureIndex;
	CPoint feature, ptFeatureInImage;

	// ref mode
	if(RxGetCurSeries() == RXSERIES_REF && RxGetFrameMain()->m_bRefSegmented == true) {
		pVolumeData = RxGetVolumeData(0);
	}
	// float mode
	else if(RxGetCurSeries() == RXSERIES_FLT && RxGetFrameMain()->m_bFloatSegmented == true) {
		pVolumeData = RxGetVolumeData(1);
	}

	BOOL bRef, bFlt, bCom;
	// ref & float mode
	bRef = (RxGetCurSeries() == RXSERIES_REF) && (RxGetFrameMain()->m_bRefSegmented == true);
	bFlt = (RxGetCurSeries() == RXSERIES_FLT && RxGetFrameMain()->m_bFloatSegmented == true);
	bCom = (RxGetCurSeries() == RXSERIES_COM) && (RxGetFrameMain()->m_bRefSegmented == true) 
		&& (RxGetFrameMain()->m_bFloatSegmented == true);
	
	COLORREF lung;
	if(bRef) lung = RGB(255, 0, 0);
	else if(bFlt) lung = RGB(0, 0, 255);

	COLORREF airway = RGB(0, 255, 0);
	COLORREF left = RGB(128, 51, 0); // 柳茄 林炔 
	COLORREF right = RGB(204, 128, 51); // 慷篮 畴尔
	//COLORREF vessel = RGB(255, 255, 0);

	if( bRef || bFlt ) {	
		// white pen for drawing contour line
		CPen penWhite;
		penWhite.CreatePen(PS_SOLID, 2, COLOR_CONTOUR_LINE);
		pOldPen = transparentMemDC.SelectObject(&penWhite);
		
		pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
		fRatioZ = pVolumeData->m_fRatioZ;

		RxMaskVolume *pMask = pVolumeData->GetEditVolume();			  // region of two lungs
		RxMaskVolume *pRightMask = pVolumeData->GetRightEditVolume(); // boundary of right lung
		RxMaskVolume *pLeftMask  = pVolumeData->GetLeftEditVolume();  // boundary of left lung

		//RxMaskVolume *pVesselMask = pVolumeData->GetVesselVolume();
		RxMaskVolume *pAirwayMask = pVolumeData->GetAirwayVolume();
		// Axial
		switch (m_iViewMode) {
		case IDF_MAIN_WND_3DLOCALA_R:
		case IDF_MAIN_WND_3DLOCALA_F:
			nSlice = ROUNDOFF(m_pMPRAgent->GetAxialIndex()/(float)fRatioZ);
				for( j=0; j<iVolY; j++) { 
					for( i=0; i<iVolX; i++) {		
						// Edit volume
						if(pMask->GetMask(i, j, nSlice)) {
							RxPoint3D<double> ptVol3D(i, j, m_pMPRAgent->GetAxialIndex()); 
							DrawLungBoundary(ptVol3D, &transparentMemDC, lung);
						}
						if(pAirwayMask->GetMask(i, j, nSlice)) {
							RxPoint3D<double> ptVol3D(i, j, m_pMPRAgent->GetAxialIndex()); 
							DrawLungBoundary(ptVol3D, &transparentMemDC, airway);
						}					
						// Edge detected in right lung
						if(pRightMask->GetMask(i, j, nSlice)) {
							RxPoint3D<double> ptVol3D(i, j, m_pMPRAgent->GetAxialIndex()); 
							DrawLungBoundary(ptVol3D, &transparentMemDC, right);
						}
						// Edge detected in left lung
						if(pLeftMask->GetMask(i, j, nSlice)) {
							RxPoint3D<double> ptVol3D(i, j, m_pMPRAgent->GetAxialIndex()); 
							DrawLungBoundary(ptVol3D, &transparentMemDC, left);
						}

					}
				}	
				// draw feature point for smoothing
/*				if(RxGetFrameMain()->m_SegmentAgent.m_ppFeatureR!=NULL) {
					nNumOfFeatureR = RxGetFrameMain()->m_SegmentAgent.m_nNumOfFeatureR[nSlice];
					if(nNumOfFeatureR) {
						for(i=0; i<nNumOfFeatureR; i++) {
							// feature point狼 谅钎甫 浇扼捞胶 郴俊辑狼 胶某醋 牢郸胶肺 历厘 
							nFeatureIndex = RxGetFrameMain()->m_SegmentAgent.m_ppFeatureR[nSlice][i];
							RxPoint3D<double> ptVol3D(nFeatureIndex%iVolX, nFeatureIndex/iVolX, nSlice*fRatioZ);
							CPoint ptFeatureInImage = Vol2Img(ptVol3D);
							RxDrawNodule(ptFeatureInImage, 1, COLOR_CONTOUR_POINT, &transparentMemDC);
						}
					}
				}
				if(RxGetFrameMain()->m_SegmentAgent.m_ppFeatureL!=NULL) {
					nNumOfFeatureL = RxGetFrameMain()->m_SegmentAgent.m_nNumOfFeatureL[nSlice];
					if(nNumOfFeatureL) {
						for(i=0; i<nNumOfFeatureL; i++) {
							// feature point狼 谅钎甫 浇扼捞胶 郴俊辑狼 胶某醋 牢郸胶肺 历厘 
						
							nFeatureIndex = RxGetFrameMain()->m_SegmentAgent.m_ppFeatureL[nSlice][i];
							RxPoint3D<double> ptVol3D(nFeatureIndex%iVolX, nFeatureIndex/iVolX, nSlice*fRatioZ);
							CPoint ptFeatureInImage = Vol2Img(ptVol3D);
							RxDrawNodule(ptFeatureInImage, 1, COLOR_CONTOUR_POINT, &transparentMemDC);
						}
					}
				}
*/
			break;
			
		case IDF_MAIN_WND_3DLOCALS_R:
		case IDF_MAIN_WND_3DLOCALS_F:
			// Sagittal
			for( k=0; k<iSliceNum*fRatioZ; k++) {
				nSlice = k/(float)fRatioZ;
				for( j=0; j<iVolY; j++) { 
					if(pMask->GetMask( (int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
						// interpolated 3d coordinate	
						RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
						DrawLungBoundary(ptVol3D, &transparentMemDC, lung);
					}
				
					// Edge detected in right lung
					if(pRightMask->GetMask((int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
						RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
						DrawLungBoundary(ptVol3D, &transparentMemDC, right);
					}
					// Edge detected in left lung
					if(pLeftMask->GetMask((int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
						RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
						DrawLungBoundary(ptVol3D, &transparentMemDC, left);
					}
				}
			}
			break;
		case IDF_MAIN_WND_3DLOCALC_R:
		case IDF_MAIN_WND_3DLOCALC_F:
			// Coronal
			for( k=0; k<iSliceNum*fRatioZ; k++) {
				nSlice = k/(float)fRatioZ;
				for( i=0; i<iVolX; i++) { 
					if(pMask->GetMask( i, (int)(m_pMPRAgent->GetCoronalIndex()), nSlice )) {