fmwndlocalizer.cpp

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

			CheckCrosslineRange(point);
			m_iHIndex = point.x;
			AdjustVolIndexFromHIndex();
			break;

		case ON_CROSS:
			CheckCrosslineRange(point);
			m_iVIndex = point.y;
			m_iHIndex = point.x;
			AdjustVolIndexFromBothHVIndex();
			break;

		case ON_NONE:
			switch (m_btnMode) {
			case BTN_PAN:
				m_ptImgPanOffset += ptOffset;
				bRedraw = TRUE;
				break;

			case BTN_ZOOM:					// change zoom factor
				bRedraw = FALSE;
				iOldZoomFactor = m_iZoomFactor;
				m_iZoomFactor += AdjustMouseOffset4Zoom(-ptOffset.y);
				m_iZoomFactor = __min(MAX_ZOOM, __max(MIN_ZOOM, m_iZoomFactor));
				m_pLocalizerManager->ChangeZoomFactor(iOldZoomFactor, m_iZoomFactor);
				RxGetFrameBottom()->m_pEdZoom->SetEdit(m_iZoomFactor);
				break;
			}
		}
	} else if (nFlags & MK_RBUTTON) {
		// cursor status甫 ON_NONE栏肺 茄促.
		m_iHitStatus = ON_NONE;

		ChangeMouseCursor(CURSOR_WINDOWING);

		if (m_iRFCNum == COMBINED_MODE){
			RxGetFrameBottom()->GetWindowing(RXSERIES_REF, m_iWindowingLevel, m_iWindowingWidth);
			if(abs(ptOffset.x) > abs(ptOffset.y))
				m_iWindowingWidth -= ptOffset.x;			
			else  m_iWindowingLevel += ptOffset.y;
			m_iWindowingLevel = __max(-1024, __min(3071, m_iWindowingLevel));
			m_iWindowingWidth = __max(0, __min(4095, m_iWindowingWidth));
			RxGetFrameBottom()->SetWindowing(RXSERIES_REF, m_iWindowingLevel, m_iWindowingWidth);			
		}
		else {
			RxGetFrameBottom()->GetWindowing(m_iRFCNum, m_iWindowingLevel, m_iWindowingWidth);
			if(abs(ptOffset.x) > abs(ptOffset.y))
				m_iWindowingWidth -= ptOffset.x;
				
			else 
				m_iWindowingLevel += ptOffset.y;
			m_iWindowingLevel = __max(-1024, __min(3071, m_iWindowingLevel));
			m_iWindowingWidth = __max(0, __min(4095, m_iWindowingWidth));
			RxGetFrameBottom()->SetWindowing(m_iRFCNum, m_iWindowingLevel, m_iWindowingWidth);
		}
		m_pLocalizerManager->RedrawAll();
	}

	if(bRedraw)
		Redraw();

	m_ptOld = point;
	RxFMWnd::OnMouseMove(nFlags, point);
}

void RxFMWndLocalizer::OnRButtonDown(UINT nFlags, CPoint point) 
{
	if (m_btnMode == BTN_CROP)
	{
		m_nEdgeDilationFactor--;
		if (m_nEdgeDilationFactor < 0)
			m_nEdgeDilationFactor = 0;
		EdgeDilation(m_nEdgeDilationFactor);
		Redraw();
	}

	SetCapture();
	m_ptOld = point;
	RxFMWnd::OnRButtonDown(nFlags, point);
}

void RxFMWndLocalizer::OnRButtonUp(UINT nFlags, CPoint point) 
{
	::ReleaseCapture();	
	RxFMWnd::OnRButtonUp(nFlags, point);
}

void RxFMWndLocalizer::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if (m_btnMode == BTN_CROP)
	{
		m_nEdgeDilationFactor++;
		EdgeDilation(m_nEdgeDilationFactor);
		Redraw();
	}

	SetCapture();
	m_ptOld = point;
	
	RxPoint3D <double> ptNodule;
	ptNodule = Img2Vol(m_ptOld);


///////////////////////////////

	RxFMWnd::OnLButtonDown(nFlags, point);
}

void RxFMWndLocalizer::OnLButtonUp(UINT nFlags, CPoint point) 
{
	::ReleaseCapture();
	RxFMWnd::OnLButtonUp(nFlags, point);

}

void RxFMWndLocalizer::ChangeMouseCursor(int iMode)
{
	if (iMode != m_iCursorMode) {
		if (iMode == -1)
			iMode = m_iCursorMode;
		m_iCursorMode = iMode;

		switch (m_iCursorMode) {
		case CURSOR_PAN:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_PAN));
			break;
		case CURSOR_ZOOM:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_ZOOM));
			break;
		case CURSOR_WINDOWING:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_WINDOWING));
			break;
		case CURSOR_HORIZONTAL_LINE:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_OBJECT));
			break;
		case CURSOR_VERTICAL_LINE:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_OBJECT));
			break;
		case CURSOR_CROSS_LINE:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_OBJECT));
			break;
		case CURSOR_INCLINED_LINE:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_OBJECT));
			break;
		case CURSOR_MOVE_OBJECT:
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_OBJECT));
			break;
		case CURSOR_NONE:
			::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
			break;
		}
	}
}

int RxFMWndLocalizer::SetMousePosStatus(CPoint ptMouse)
{
	int iHitStatus = ON_NONE;
	BOOL bOnHLine = FALSE, bOnVLine = FALSE;

	// Test on HLine
	if (m_iVIndex - HIT_DISTANCE <= ptMouse.y && ptMouse.y <= m_iVIndex + HIT_DISTANCE) {
		bOnHLine = TRUE;
		iHitStatus = ON_HLINE;
	}
	// Test on VLine
	if (m_iHIndex - HIT_DISTANCE <= ptMouse.x && ptMouse.x <= m_iHIndex + HIT_DISTANCE) {
		bOnVLine = TRUE;
		iHitStatus = ON_VLINE;
	}

	// Test on CrossLine
	if (bOnHLine && bOnVLine)
		iHitStatus = ON_CROSS;

	return iHitStatus;
}

bool RxFMWndLocalizer::DrawLungNodule(RxPoint3D<double> ptVol, CDC* pDC, BOOL bRef)
{
	RxPoint2D<double> pt2DPathInImage;
	double fDiff;
	#define THRD_SAME_ZVALUE 1.0

	switch (m_iViewMode) {
	case IDF_MAIN_WND_3DLOCALA_R:
	case IDF_MAIN_WND_3DLOCALA_F:
	case IDF_MAIN_WND_3DLOCALA_C:
		fDiff = fabs(ptVol.z - m_pMPRAgent->GetAxialIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.y;
		}
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		fDiff = fabs(ptVol.x - m_pMPRAgent->GetSagittalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.y;
			pt2DPathInImage.y = ptVol.z;
		}
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		fDiff = fabs(ptVol.y - m_pMPRAgent->GetCoronalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.z;
		}
		break;
	}

	if (fDiff < THRD_SAME_ZVALUE)
	{
		CPoint ptImage;
		ptImage = Vol2D2Img(pt2DPathInImage);
		
		if (bRef)
			RxDrawNodule(ptImage, RADIUS, COLOR_REF_NODULE, pDC);
		else
			RxDrawNodule(ptImage, RADIUS, COLOR_FLOAT_NODULE, pDC);
	}

	return TRUE;
}

bool RxFMWndLocalizer::DrawLungBoundary(RxPoint3D<double> ptVol, CDC* pDC, BOOL bRef)
{
	RxPoint2D<double> pt2DPathInImage;
	double fDiff;
	#define THRD_SAME_ZVALUE 1.0

	switch (m_iViewMode) {
	case IDF_MAIN_WND_3DLOCALA_R:
	case IDF_MAIN_WND_3DLOCALA_F:
	case IDF_MAIN_WND_3DLOCALA_C:
		fDiff = fabs(ptVol.z - m_pMPRAgent->GetAxialIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.y;
		}
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		fDiff = fabs(ptVol.x - m_pMPRAgent->GetSagittalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.y;
			pt2DPathInImage.y = ptVol.z;
		}
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		fDiff = fabs(ptVol.y - m_pMPRAgent->GetCoronalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.z;
		}
		break;
	}

	if (fDiff < THRD_SAME_ZVALUE)
	{
		CPoint ptImage;
		ptImage = Vol2D2Img(pt2DPathInImage);
		
		COLORREF color;
		if (bRef) 
			color = COLOR_REF_NODULE;
		else 
			color = COLOR_FLOAT_NODULE;
		
		pDC->SetPixel(ptImage, color);
	}

	return TRUE;
}

bool RxFMWndLocalizer::DrawLungBoundary(RxPoint3D<double> ptVol, CDC* pDC, COLORREF color)
{
	RxPoint2D<double> pt2DPathInImage;
	double fDiff;
	#define THRD_SAME_ZVALUE 1.0

	switch (m_iViewMode) {
	case IDF_MAIN_WND_3DLOCALA_R:
	case IDF_MAIN_WND_3DLOCALA_F:
	case IDF_MAIN_WND_3DLOCALA_C:
		fDiff = fabs(ptVol.z - m_pMPRAgent->GetAxialIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.y;
		}
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		fDiff = fabs(ptVol.x - m_pMPRAgent->GetSagittalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.y;
			pt2DPathInImage.y = ptVol.z;
		}
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		fDiff = fabs(ptVol.y - m_pMPRAgent->GetCoronalIndex());
		if (fDiff < THRD_SAME_ZVALUE)
		{
			pt2DPathInImage.x = ptVol.x;
			pt2DPathInImage.y = ptVol.z;
		}
		break;
	}

	if (fDiff < THRD_SAME_ZVALUE)
	{
		CPoint ptImage;
		ptImage = Vol2D2Img(pt2DPathInImage);
		pDC->SetPixel(ptImage, color);
	}

	return TRUE;
}

RxPoint2D<double> RxFMWndLocalizer::Img2Vol2D(CPoint ptImg)
{
	RxPoint2D<double> ptVol;
	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:
		ptVol.x = (ptImg.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.y = (ptImg.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.;
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		ptVol.x = (ptImg.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.y = m_pMPRAgent->m_iVolZ - 1 - ((ptImg.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.);
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		ptVol.x = (ptImg.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.y = m_pMPRAgent->m_iVolZ - 1 - ((ptImg.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.);
		break;
	}

	return ptVol;
}
RxPoint3D<double> RxFMWndLocalizer::Img2Vol(CPoint pt)
{
	RxPoint3D<double> ptVol;
	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:
		ptVol.x = (pt.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.y = (pt.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.;
		ptVol.z = m_pMPRAgent->GetAxialIndex();
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		ptVol.x = m_pMPRAgent->GetSagittalIndex();
		ptVol.y = (pt.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.z = m_pMPRAgent->m_iVolZ - 1 - ((pt.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.);
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		ptVol.x = (pt.x - m_ptImgPanOffset.x - m_ptImgCenter.x) / fZoom + m_szRawImg.cx / 2.;
		ptVol.y = m_pMPRAgent->GetCoronalIndex();
		ptVol.z = m_pMPRAgent->m_iVolZ - 1 - ((pt.y - m_ptImgPanOffset.y - m_ptImgCenter.y) / fZoom + m_szRawImg.cy / 2.);
		break;
	}

	return ptVol;
}
////
CPoint RxFMWndLocalizer::Vol2Img(RxPoint3D<double> vptVol)
{
	CPoint ptImg;
	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:
		ptImg.x = ROUNDOFF((vptVol.x - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		ptImg.y = ROUNDOFF((vptVol.y - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		//m_pMPRAgent->SetAxialIndex(ROUNDOFF(vptVol.z));
		break;

	case IDF_MAIN_WND_3DLOCALS_R:
	case IDF_MAIN_WND_3DLOCALS_F:
	case IDF_MAIN_WND_3DLOCALS_C:
		ptImg.x = ROUNDOFF((vptVol.y - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		ptImg.y = ROUNDOFF((m_pMPRAgent->m_iVolZ - 1 - vptVol.z - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		//m_pMPRAgent->SetSagittalIndex(ROUNDOFF(vptVol.x));
		break;

	case IDF_MAIN_WND_3DLOCALC_R:
	case IDF_MAIN_WND_3DLOCALC_F:
	case IDF_MAIN_WND_3DLOCALC_C:
		ptImg.x = ROUNDOFF((vptVol.x - m_szRawImg.cx / 2.) * fZoom + m_ptImgPanOffset.x + m_ptImgCenter.x);
		ptImg.y = ROUNDOFF((m_pMPRAgent->m_iVolZ - 1 - vptVol.z - m_szRawImg.cy / 2.) * fZoom + m_ptImgPanOffset.y + m_ptImgCenter.y);
		//m_pMPRAgent->SetCoronalIndex(ROUNDOFF(vptVol.y));