fmwndlocalizer.cpp

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

		m_pLocalizerManager->Reset(1);
	}
	else if(nID == IDF_MAIN_WND_3DLOCALC_R || nID == IDF_MAIN_WND_3DLOCALC_F || nID == IDF_MAIN_WND_3DLOCALC_C){
		nIndex = 1;
		RxGetFrameMain()->Frame3DF_Local_Max(nIndex);
		m_pLocalizerManager->Reset(2);
	}
	else if(nID == IDF_MAIN_WND_3DLOCALS_R || nID == IDF_MAIN_WND_3DLOCALS_F || nID == IDF_MAIN_WND_3DLOCALS_C){
		nIndex = 2;
		RxGetFrameMain()->Frame3DF_Local_Max(nIndex);
		m_pLocalizerManager->Reset(3);
	}
	
}

void RxFMWndLocalizer::OnLocalRestore()
{
	RxGetFrameMain()->Frame3DF_Local_Nor();
	m_pLocalizerManager->Reset();
}

void RxFMWndLocalizer::OnNcSliderChanging()
{
	RxFMWndVR	*pFMWndVR = RxGetFrameMain()->m_pFMWndVR[m_nSeries];

	switch (GetDlgCtrlID())
	{
		case IDF_MAIN_WND_3DLOCALA_R:
		case IDF_MAIN_WND_3DLOCALA_F:
		case IDF_MAIN_WND_3DLOCALA_C:
			pFMWndVR->SetCropRange(m_nMinPo, m_nMaxPo, Z_AXIS);
			break;
		case IDF_MAIN_WND_3DLOCALC_R:
		case IDF_MAIN_WND_3DLOCALC_F:
		case IDF_MAIN_WND_3DLOCALC_C:
			pFMWndVR->SetCropRange(m_nMinPo, m_nMaxPo, Y_AXIS);
			break;
		case IDF_MAIN_WND_3DLOCALS_R:
		case IDF_MAIN_WND_3DLOCALS_F:
		case IDF_MAIN_WND_3DLOCALS_C:
			pFMWndVR->SetCropRange(m_nMinPo, m_nMaxPo, X_AXIS);
			break;
	}
}

void RxFMWndLocalizer::OnNcSliderChanged()
{
	int		nCurSeries = RxGetCurSeries();

	if(nCurSeries == RXSERIES_REF)
	{
		RxGetFrameMain()->m_pFMWndVR[0]->ReCalMeasureVolume(TRUE);
		RxGetFrameMain()->m_pFMWndVR[1]->SetNeedRecalVolume();
	}
	else if(nCurSeries == RXSERIES_FLT)
	{
		RxGetFrameMain()->m_pFMWndVR[1]->ReCalMeasureVolume(TRUE);
		RxGetFrameMain()->m_pFMWndVR[0]->SetNeedRecalVolume();
	} else {
		RxGetFrameMain()->m_pFMWndVR[0]->SetNeedRecalVolume();
		RxGetFrameMain()->m_pFMWndVR[1]->SetNeedRecalVolume();
	}
}

void RxFMWndLocalizer::Vol2HVIndex()
{
	double fZoom = m_iZoomFactor / 100.;
	switch (m_iViewMode) {
	case IDF_MAIN_WND_3DLOCALA_R:
	case IDF_MAIN_WND_3DLOCALA_F:
	case IDF_MAIN_WND_3DLOCALA_C:
		m_iHIndex = ROUNDOFF((m_pMPRAgent->GetSagittalIndex() - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		m_iVIndex = ROUNDOFF((m_pMPRAgent->GetCoronalIndex() - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		m_iHIndex = ROUNDOFF((m_pMPRAgent->GetCoronalIndex() - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		m_iVIndex = ROUNDOFF((m_pMPRAgent->m_iVolZ - 1 - m_pMPRAgent->GetAxialIndex() - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		m_iHIndex = ROUNDOFF((m_pMPRAgent->GetSagittalIndex() - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		m_iVIndex = ROUNDOFF((m_pMPRAgent->m_iVolZ - 1 - m_pMPRAgent->GetAxialIndex() - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		break;
	}
}

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

	CRect		rect;
	GetClientRect(rect);

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

	CBitmap bitmap;
	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);

	// print slice number
	BOOL bTransparent;
	COLORREF colorText;
	COLORREF colorBk;
	LOGFONT logFont;

	bTransparent = FALSE;
	colorText = RGB(0, 0, 0);
	colorBk = RGB(255, 255, 255);
	
	logFont.lfHeight = 0;
	logFont.lfWidth = 0;
	logFont.lfEscapement = 0;
	logFont.lfOrientation = 0;
	logFont.lfWeight = FW_NORMAL;
	logFont.lfItalic = FALSE;
	logFont.lfUnderline = FALSE;
	logFont.lfStrikeOut = FALSE;
	logFont.lfCharSet = DEFAULT_CHARSET;
	logFont.lfOutPrecision = OUT_CHARACTER_PRECIS;
	logFont.lfClipPrecision = OUT_CHARACTER_PRECIS;
	logFont.lfQuality = DEFAULT_QUALITY;
	logFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
	strcpy(logFont.lfFaceName, "Arial");

	CFont newFont, *pOldFont;
	newFont.CreateFontIndirect(&logFont);

	pOldFont = (CFont *)memDC.SelectObject(&newFont);

	memDC.SetTextColor(colorText);
	memDC.SetBkColor(colorBk);
	memDC.SetBkMode(OPAQUE);

	int nIndex; 
	short nSliceNum;
	RxVolumeData* pVolumeData;
	pVolumeData = RxGetVolumeData(0);

	if (m_pMPRAgent)
	{
		switch (m_iViewMode) {
		case IDF_MAIN_WND_3DLOCALA_R:
		case IDF_MAIN_WND_3DLOCALA_F:
		case IDF_MAIN_WND_3DLOCALA_C:
			nSliceNum = nIndex = m_pMPRAgent->GetAxialIndex()/(float)pVolumeData->m_fRatioZ;
			break;

		case IDF_MAIN_WND_3DLOCALS_R:
		case IDF_MAIN_WND_3DLOCALS_F:
		case IDF_MAIN_WND_3DLOCALS_C:
			nIndex = m_pMPRAgent->GetSagittalIndex();
			break;
		case IDF_MAIN_WND_3DLOCALC_R:
		case IDF_MAIN_WND_3DLOCALC_F:
		case IDF_MAIN_WND_3DLOCALC_C:
			nIndex = m_pMPRAgent->GetCoronalIndex();
			break;
		}
	}

	CString str("000");

	str.SetAt(0, '0' + (nIndex / 100));
	nIndex = nIndex % 100;
	str.SetAt(1, '0' + (nIndex / 10));
	nIndex = nIndex % 10;
	str.SetAt(2, '0' + (nIndex));

	rect.left = 0;
	rect.top = 0;
	rect.right = 50;
	rect.bottom = 20;

	memDC.DrawText(str, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

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

	RxGetFrameBottom()->GetWindowing(RXSERIES_REF, m_iWindowingLevel, m_iWindowingWidth);

	int		nWindowingHigh	= m_iWindowingLevel + 1024 + m_iWindowingWidth/2;
	int		nWindowingLow	= m_iWindowingLevel + 1024 - m_iWindowingWidth/2;
	int		nMin = max(   0, nWindowingLow);
	int		nMax = min(4095, nWindowingHigh);

	CString str2("0000");

	nIndex = nMin;

	str2.SetAt(0, '0' + (nIndex / 1000));
	nIndex = nIndex % 1000;
	str2.SetAt(1, '0' + (nIndex / 100));
	nIndex = nIndex % 100;
	str2.SetAt(2, '0' + (nIndex / 10));
	nIndex = nIndex % 10;
	str2.SetAt(3, '0' + (nIndex));

	rect.left = 60;
	rect.top = 0;
	rect.right = 110;
	rect.bottom = 20;

	memDC.DrawText(str2, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

	CString str3("0000");

	str3.SetAt(0, '0' + (nIndex / 1000));
	nIndex = nIndex % 1000;
	str3.SetAt(1, '0' + (nIndex / 100));
	nIndex = nIndex % 100;
	str3.SetAt(2, '0' + (nIndex / 10));
	nIndex = nIndex % 10;
	str3.SetAt(3, '0' + (nIndex));

	rect.left = 120;
	rect.top = 0;
	rect.right = 170;
	rect.bottom = 20;

	memDC.DrawText(str3, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

	GetClientRect(&rect);

	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;

				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, 0.0);
				m_mxRegistration.Translate(0.0, 0.0, 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 iVolX, iVolY, iSliceNum, iIntVolZ;
		CPoint pt;
		int j, k, nSlice;

		if(RxGetCurSeries() == RXSERIES_REF && RxGetFrameMain()->m_bRefSegmented == true) {
					
			pVolumeData = RxGetVolumeData(0);
			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();

			RxMaskVolume *pMask = pVolumeData->GetEditVolume();
			RxMaskVolume *pEdgeMask = pVolumeData->GetEdgeVolume();

			unsigned short* pnDensity;
			long nIndex;

			pnDensity = pVolumeData->GetBigVolume();

			// Axial
			switch (m_iViewMode) {
			case IDF_MAIN_WND_3DLOCALA_R:
				nSlice = m_pMPRAgent->GetAxialIndex()/(float)fRatioZ;
				
				short nSlice1 = (m_pMPRAgent->GetAxialIndex() - 1)/(float)fRatioZ;
				
				if (nSlice > nSlice1) {

				for( j=0; j<iVolY; j++) { 
					for( i=0; i<iVolX; i++) {
						
/*						if (!g_bColorPerfusion)
						{
							if(pMaskL->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ); 
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							if(pMaskR->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ); 
								DrawLungBoundary(ptVol3D, &memDC, TRUE);
							}
							if(pVesselMask->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ); 
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
						
							if(pManualMask->GetMask(i, j, nSlice)) {
								RxPoint3D<double> ptVol3D(i, j, nSlice*fRatioZ); 
								DrawLungBoundary(ptVol3D, &memDC, FALSE);
							}
						}*/

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