fmwndlocalizer.cpp

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

							}
							if(pMaskR->GetMask( (int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}

							if(pVesselMask->GetMask( (int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pManualMask->GetMask( (int)(m_pMPRAgent->GetSagittalIndex()), j, nSlice)) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( (int)(m_pMPRAgent->GetSagittalIndex()), j, k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
						}*/

						nSlice = k/(float)fRatioZ;
						
						unsigned int nSagittalIndex = m_pMPRAgent->GetSagittalIndex();
						
						RxPoint3D<double> ptVol3D(nSagittalIndex, j, k );
						nIndex = nSagittalIndex + j*iVolX + nSlice*iVolX*iVolY;
						if (pMask->GetMask(nSagittalIndex, j, nSlice) && !pVesselMask->GetMask(nSagittalIndex, j, nSlice))
							DrawLungPerfusion(ptVol3D, &memDC, TRUE, pnDensity[nIndex]);
					}
				}
				break;
			case IDF_MAIN_WND_3DLOCALC_R:
				// Coronal
				for( k=0; k<iSliceNum*fRatioZ; k++) {
					nSlice = k/(float)fRatioZ;
					for( i=0; i<iVolX; i++) { 
/*						if (!g_bColorPerfusion)
						{
							if(pMaskL->GetMask( i, (int)(m_pMPRAgent->GetCoronalIndex()), nSlice )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, (int)(m_pMPRAgent->GetCoronalIndex()), k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							if(pMaskR->GetMask( i, (int)(m_pMPRAgent->GetCoronalIndex()), nSlice )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, (int)(m_pMPRAgent->GetCoronalIndex()), k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}

							if(pVesselMask->GetMask( i, (int)(m_pMPRAgent->GetCoronalIndex()), nSlice )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, (int)(m_pMPRAgent->GetCoronalIndex()), k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
						
							if(pManualMask->GetMask( i, (int)(m_pMPRAgent->GetCoronalIndex()), nSlice )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, (int)(m_pMPRAgent->GetCoronalIndex()), k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
						}*/

						nSlice = k/(float)fRatioZ;

						unsigned int nCoronalIndex = m_pMPRAgent->GetCoronalIndex();

						RxPoint3D<double> ptVol3D( i, nCoronalIndex, k );
						nIndex = i + nCoronalIndex*iVolX + nSlice*iVolX*iVolY;
						if (pMask->GetMask(i, nCoronalIndex, nSlice) && !pVesselMask->GetMask(i, nCoronalIndex, nSlice))
							DrawLungPerfusion(ptVol3D, &memDC, TRUE, pnDensity[nIndex]);
					}
				}
				break;
			}
			
		}
		else if(RxGetCurSeries() == RXSERIES_FLT && RxGetFrameMain()->m_bFloatSegmented == true) {
				pVolumeData = RxGetVolumeData(1);
				pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
				fRatioZ = pVolumeData->m_fRatioZ;
			
				RxMaskVolume *pMaskL = pVolumeData->GetEditVolumeL();
				RxMaskVolume *pMaskR = pVolumeData->GetEditVolumeR();

				RxMaskVolume *pVesselMask = pVolumeData->GetVesselVolume();
//				RxMaskVolume *pManualMask = pVolumeData->GetManualEditVolume();

				// Axial
				switch (m_iViewMode) {
				case IDF_MAIN_WND_3DLOCALA_F:
					nSlice = m_pMPRAgent->GetAxialIndex()/(float)fRatioZ;
					for( j=0; j<iVolY; j++) { 
						for( i=0; i<iVolX; i++) {		
/*							if(pMaskL->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pMaskR->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pVesselMask->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							if(pManualMask->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}*/
						}
					}
					break;
				
				case IDF_MAIN_WND_3DLOCALS_F:
					// Sagittal
					for( k=0; k<iSliceNum*fRatioZ; k++) {
						for( j=0; j<iVolY; j++) { 
/*							if(pMaskL->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pMaskR->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pVesselMask->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							if(pManualMask->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}*/
						}
					}
					break;
				
				case IDF_MAIN_WND_3DLOCALC_F:
					// Coronal
					for( k=0; k<iSliceNum*fRatioZ; k++) {
						for( i=0; i<iVolX; i++) { 
/*							if(pMaskL->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pMaskR->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
							if(pVesselMask->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							
							if(pManualMask->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
								// interpolated 3d coordinate	
								RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}*/
						}
					}
					break;
				}
			
		}
		else if( (RxGetCurSeries() == RXSERIES_COM) && (RxGetFrameMain()->m_bRefSegmented == true) 
			&& (RxGetFrameMain()->m_bFloatSegmented == true) ) {
/*			pVolumeData = RxGetVolumeData(0);
			pVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
			fRatioZ = pVolumeData->m_fRatioZ;
			RxMaskVolume *pMaskL = pVolumeData->GetEditVolumeL();
			RxMaskVolume *pMaskR = pVolumeData->GetEditVolumeR();
						
			for( j=0; j<iVolY; j++) { 
				for( i=0; i<iVolX; i++) {
					nSlice = m_pMPRAgent->GetAxialIndex()/(float)fRatioZ;
					
					if( nSlice == (int)nSlice ) {
						if(pMaskL->GetMask(i, j, nSlice )) {
							// interpolated 3d coordinate	
							RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
							DrawLungBoundary(ptVol3D, &memDC, TRUE);
						}
						if(pMaskR->GetMask(i, j, nSlice )) {
							// interpolated 3d coordinate	
							RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ );
							DrawLungBoundary(ptVol3D, &memDC, TRUE);
						}
					}
				}
			}
			
			for( k=0; k<iSliceNum*fRatioZ; k++) {
				for( j=0; j<iVolY; j++) { 
					if(pMaskL->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
						// interpolated 3d coordinate	
						RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
						DrawLungBoundary(ptVol3D, &memDC, TRUE);
					}
					if(pMaskR->GetMask( m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRatioZ )) {
						// interpolated 3d coordinate	
						RxPoint3D<double> ptVol3D( m_pMPRAgent->GetSagittalIndex(), j, k );
						DrawLungBoundary(ptVol3D, &memDC, TRUE);
					}
				}
			}
			
			for( k=0; k<iSliceNum*fRatioZ; k++) {
				for( i=0; i<iVolX; i++) { 
					if(pMaskL->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
						// interpolated 3d coordinate	
						RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
						DrawLungBoundary(ptVol3D, &memDC, TRUE);
					}
					if(pMaskR->GetMask( i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRatioZ )) {
						// interpolated 3d coordinate	
						RxPoint3D<double> ptVol3D( i, m_pMPRAgent->GetCoronalIndex(), k );
						DrawLungBoundary(ptVol3D, &memDC, TRUE);
					}
				}
			}
/////////////////////
		
			RxVolumeData* pFloatVolume;	
			int iFloatVolX, iFloatVolY, iFloatSliceNum;
			double dX, dY, dZ;
			pFloatVolume = RxGetVolumeData(1);	
			pFloatVolume->GetBigVolumeDmsn(&iFloatVolX, &iFloatVolY, &iFloatSliceNum);
			pFloatVolume->GetVoxelSize(&dX, &dY, &dZ);
			double lfZFltRatio = dZ/dX;
			fRatioZ = pFloatVolume->m_fRatioZ;
			pMaskL = pFloatVolume->GetEditVolumeL();
			pMaskR = pFloatVolume->GetEditVolumeR();

			RxMatrix4D m_mxRegistration, m_mxInverse;

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

			double lfSHx = pTransform->xshear;
			double lfSHy = pTransform->yshear;
			double lfSHz = pTransform->zshear;

			RxMatrix4D SH(1.0, lfSHx, lfSHx, 0.0, 
				lfSHy, 1.0, lfSHy, 0.0,
				lfSHz, lfSHz, 1.0, 0.0,
				0.0, 0.0, 0.0, 1.0);
			RxMatrix4D Temp;

			m_mxRegistration.LoadIdentity();
			m_mxRegistration.Translate(-g_FloatCenX, -g_FloatCenY, -g_FloatCenZ);
			m_mxRegistration.Scale(pTransform->xscale, pTransform->yscale, pTransform->zscale);
			m_mxRegistration.Rotate(0, pTransform->xrot);
			m_mxRegistration.Rotate(1, pTransform->yrot);
			m_mxRegistration.Rotate(2, pTransform->zrot);

			Temp = m_mxRegistration;
			m_mxRegistration = SH * Temp;

			m_mxRegistration.Translate(g_RefCenX + pTransform->xmove, g_RefCenY + pTransform->ymove, g_RefCenZ + pTransform->zmove - g_iRefBinaryTransZ);

			RxVolumeData* pRefVolumeData = RxGetVolumeData(0);
			pRefVolumeData->GetBigVolumeDmsn(&iVolX, &iVolY, &iSliceNum);
			double fRefRatioZ = pRefVolumeData->m_fRatioZ;

			m_mxInverse = m_mxRegistration.Inverse();
			
			RxVect4D registPoint;			
			
			for( j=0; j<iVolY; j++) { 
				for( i=0; i<iVolX; i++) {
					nSlice = m_pMPRAgent->GetAxialIndex()/(float)fRefRatioZ;
					
					if( nSlice == (int)nSlice ) {
						registPoint = m_mxInverse * RxVect4D (i, j, nSlice, 1.0);
						
						if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
							0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
							0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
							pMaskL->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

							RxPoint3D<double> ptVol3D(i, j, nSlice*(float)fRefRatioZ );
							DrawLungBoundary(ptVol3D, &memDC, FALSE);
						}
						if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
							0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
							0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
							pMaskR->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

							RxPoint3D<double> ptVol3D(i, j, nSlice*(float)fRefRatioZ );
							DrawLungBoundary(ptVol3D, &memDC, FALSE);
						}
					}
				}
			}
			
			for( k=0; k<iSliceNum*(float)fRefRatioZ; k++) {
				for( j=0; j<iVolY; j++) { 
					registPoint = m_mxInverse * RxVect4D (m_pMPRAgent->GetSagittalIndex(), j, k/(float)fRefRatioZ, 1.0);
			
					if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
						0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
						0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
						pMaskL->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

						RxPoint3D<double> ptVol3D(m_pMPRAgent->GetSagittalIndex(), j, k );
						DrawLungBoundary(ptVol3D, &memDC, FALSE);
					}
					if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
						0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
						0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
						pMaskR->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

						RxPoint3D<double> ptVol3D(m_pMPRAgent->GetSagittalIndex(), j, k );
						DrawLungBoundary(ptVol3D, &memDC, FALSE);
					}
				}
			}
			
			for( k=0; k<iSliceNum*(float)fRefRatioZ; k++) {
				for( i=0; i<iVolX; i++) { 
					registPoint = m_mxInverse * RxVect4D (i, m_pMPRAgent->GetCoronalIndex(), k/(float)fRefRatioZ, 1.0);
					
					if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
						0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
						0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
						pMaskL->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

						RxPoint3D<double> ptVol3D(i, m_pMPRAgent->GetCoronalIndex(), k );
						DrawLungBoundary(ptVol3D, &memDC, FALSE);
					}
					if(0 <= registPoint.m[0] && registPoint.m[0] < iFloatVolX &&
						0 <= registPoint.m[1] && registPoint.m[1] < iFloatVolY &&
						0 <= registPoint.m[2] && registPoint.m[2] < iFloatSliceNum &&
						pMaskR->GetMask(registPoint.m[0], registPoint.m[1], registPoint.m[2])) {

						RxPoint3D<double> ptVol3D(i, m_pMPRAgent->GetCoronalIndex(), k );
						DrawLungBoundary(ptVol3D, &memDC, FALSE);
					}
				}
			}*/
			//////////////////////////
		}

		dc.BitBlt(0, 0, m_szWindow.cx, m_szWindow.cy, &memDC, 0, 0, SRCCOPY);
//	}

	memDC.SelectObject(pOldBitmap);
	memDC.SetBkMode(iBkMode);

	bitmap.DeleteObject();

	
	//TRACE(_T("\n Onpaint : m_iHIndex = %d,  m_iVIndex = %d"), m_iHIndex, m_iVIndex);
}

BOOL RxFMWndLocalizer::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	CPoint point;
	GetCursorPos(&point);
	ScreenToClient(&point);

	m_iHitStatus = SetMousePosStatus(point);
	
	if(pWnd->GetSafeHwnd() == GetSafeHwnd() && nHitTest == HTCLIENT){
		switch(m_iHitStatus){
			case ON_HLINE:
				ChangeMouseCursor(CURSOR_HORIZONTAL_LINE);
				return TRUE;

			case ON_VLINE:
				ChangeMouseCursor(CURSOR_VERTICAL_LINE);
				return TRUE;

			case ON_CROSS:
				ChangeMouseCursor(CURSOR_CROSS_LINE);
				return TRUE;

			case ON_NONE:
				ChangeMouseCursor(CURSOR_NONE);
				break;
		}
		
		m_btnMode = RxGetFrameMain()->GetTBCurMode();
		switch(m_btnMode){
		case BTN_PAN:
			ChangeMouseCursor(CURSOR_PAN);
			return TRUE;

		case BTN_WINDOWING:
			ChangeMouseCursor(CURSOR_WINDOWING);
			return TRUE;

		case BTN_ZOOM:
			ChangeMouseCursor(CURSOR_ZOOM);
			return TRUE;
		}
	}

	return RxFMWnd::OnSetCursor(pWnd, nHitTest, message); // 捞赤籍篮 公炼扒 目辑甫 拳混钎(default)肺 技泼茄促.
	//return TRUE;
}

void RxFMWndLocalizer::OnMouseMove(UINT nFlags, CPoint point) 
{
	if(GetCapture() != this){
		RxFMWnd::OnMouseMove(nFlags, point);
		return;
	}

	BOOL bRedraw = FALSE;
	CPoint ptOffset = point - m_ptOld;
	RxHistogram* pHistogram;
	int iOldZoomFactor;
	//RxPoint3D<double> ptVol = Img2Vol(point);
	RxPoint2D<short int> ptReal, pt;
	m_btnMode = RxGetFrameMain()->GetTBCurMode();

	if (nFlags & MK_LBUTTON) {			// While left button is pressed
		switch (m_iHitStatus) {
		case ON_HLINE:
			CheckCrosslineRange(point);
			m_iVIndex = point.y;
			AdjustVolIndexFromVIndex();
			break;

		case ON_VLINE: