registgraph1df.cpp

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

// RegistGraph1DF.cpp : implementation file
//

#include "stdafx.h"
#include "fusion.h"
#include "RegistGraph1DF.h"
#include "DlgRegistReport.h"
#include <math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// RxRegistGraph1DF

RxRegistGraph1DF::RxRegistGraph1DF()
{
	m_dRangeMin		= 0.;
	m_dRangeMax		= 100.;
	m_dPos			= 100.;

	m_iGripSize		= 10;
}

RxRegistGraph1DF::~RxRegistGraph1DF()
{
	if(m_hWnd)		DestroyWindow();
}


BEGIN_MESSAGE_MAP(RxRegistGraph1DF, CWnd)
	//{{AFX_MSG_MAP(RxRegistGraph1DF)
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_SETCURSOR()
	ON_WM_LBUTTONDOWN()
	ON_WM_MOUSEACTIVATE()
	ON_WM_MOUSEWHEEL()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// RxRegistGraph1DF message handlers

void RxRegistGraph1DF::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
	RedrawWnd();
	
	// Do not call CWnd::OnPaint() for painting messages
}

void RxRegistGraph1DF::RedrawWnd()
{
	RxDlgRegistReport	*pParentWnd = (RxDlgRegistReport *)GetParent();
	CDC					*pDC = GetDC();

	CRect		rect;
	GetClientRect(rect);

	CDC			dcMem;
	CBitmap		bmpMem, *pOldBitmap;
	dcMem.CreateCompatibleDC(pDC);
	bmpMem.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
	pOldBitmap = dcMem.SelectObject(&bmpMem);

	// fill the background
	CBrush		brush, *pOldBrush;
	brush.CreateSolidBrush(RGB(  0,  0,  0));
	pOldBrush = dcMem.SelectObject(&brush);
	dcMem.PatBlt(0, 0, rect.Width(), rect.Height(), PATCOPY);
	dcMem.SelectObject(pOldBrush);
	brush.DeleteObject();

	// draw border.
	CRect		rcTemp = rect;
	rcTemp.DeflateRect(19,19,19,19);
	dcMem.Draw3dRect(rcTemp, RGB(200,  0,  0), RGB(200,  0,  0));

	// draw horizontal index
	CFont	font, *pOldFont;
	font.CreateFont(14, 0, 0, 0, FW_BOLD, FALSE, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS,
					CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, _T("Arial"));
	pOldFont = dcMem.SelectObject(&font);
	dcMem.SetBkMode(TRANSPARENT);
	dcMem.SetTextColor(RGB(255,255,255));
	
	CRect		rcText;
	CString		strText;
	rcText.SetRect(rcTemp.left, rcTemp.bottom, rcTemp.right, rect.bottom);
	strText.Format(_T("%d"), 0);
	dcMem.DrawText(strText, rcText, DT_SINGLELINE|DT_VCENTER|DT_LEFT);
	dcMem.DrawText(_T("Float"), rcText, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
	strText.Format(_T("%d"), pParentWnd->m_iRow);
	dcMem.DrawText(strText, rcText, DT_SINGLELINE|DT_VCENTER|DT_RIGHT);

	dcMem.SelectObject(pOldFont);
	font.DeleteObject();

	// draw vertical index
	CPoint	ptOldViewportOrg = dcMem.SetViewportOrg(rect.left, rcTemp.bottom);
	LOGFONT lf;
	::ZeroMemory(&lf, sizeof(lf));
	lf.lfHeight = 83;
	lf.lfWeight = FW_BOLD;
	lf.lfEscapement = 900;
	lf.lfOrientation = 900;
	::lstrcpy(lf.lfFaceName, _T("Arial"));
	font.CreatePointFontIndirect(&lf);
	pOldFont = dcMem.SelectObject(&font);

	strText.Format(_T("%d"), 0);
	dcMem.TextOut(3, 0, strText);
	strText = _T("Reference");
	dcMem.TextOut(3, -((rcTemp.Height() - dcMem.GetTextExtent(strText).cx)/2), strText);
	strText.Format(_T("%.2f"), m_dPos);
	dcMem.TextOut(3, -(rcTemp.Height() - dcMem.GetTextExtent(strText).cx), strText);

	dcMem.SelectObject(pOldFont);
	font.DeleteObject();
	dcMem.SetViewportOrg(ptOldViewportOrg);

	// draw slider
	DrawSlider(&dcMem);

	// Draw Line
	rcTemp.DeflateRect(1,1,1,1);
	int		i, iIndexX;
	double	dRatioX = (double)(pParentWnd->m_iCol) / (double)(rcTemp.right  - rcTemp.left);
	double	dRatioY = (double)(rcTemp.top - rcTemp.bottom) / (double)(m_dPos - m_dRangeMin);

	int		iHeight;

	CPen	pen, *pOldPen;
	pen.CreatePen(PS_SOLID, 1, RGB(100,155,155));
	pOldPen = dcMem.SelectObject(&pen);

	for(i = rcTemp.left; i < rcTemp.right; i++)
	{
		iIndexX	= (int)((i - rcTemp.left) * dRatioX);

		if(iIndexX >= pParentWnd->m_iCol - 2)
			iIndexX = pParentWnd->m_iCol - 2;

		iHeight = (int)(dRatioY * (pParentWnd->m_pTableRow[iIndexX] - m_dRangeMin) + rcTemp.bottom);
		if(iHeight <= rcTemp.top)		iHeight = rcTemp.top;

		dcMem.MoveTo(i, iHeight);
		dcMem.LineTo(i, rcTemp.bottom);
	}

	dcMem.SelectObject(pOldPen);
	pen.DeleteObject();

	pDC->BitBlt(0, 0, rect.Width(), rect.Height(), &dcMem, 0, 0, SRCCOPY);
	
	dcMem.SelectObject(pOldBitmap);
	bmpMem.DeleteObject();
	dcMem.DeleteDC();

	ReleaseDC(pDC);
}

void RxRegistGraph1DF::DrawSlider(CDC *pDC)
{
	pDC->Draw3dRect(m_rcSlider, RGB(255,255,255), RGB(255,255,255));

	CRect	rcGrip;
	rcGrip.SetRect(m_rcSlider.left+1, m_iPixel, m_rcSlider.right-1, m_iPixel+m_iGripSize);
	pDC->Draw3dRect(rcGrip, RGB(255,  0,  0), RGB(255,  0,  0));
}

void RxRegistGraph1DF::OnSize(UINT nType, int cx, int cy) 
{
	CWnd::OnSize(nType, cx, cy);
	
	m_rcSlider.SetRect(cx - 16, 19, cx-2, cy - 19);

	UpdateGripPixel(TRUE);
}

void RxRegistGraph1DF::UpdateGripPixel(BOOL bUpdate)
{
	if(bUpdate)
	{
		m_iPixel = (int)((m_dPos - m_dRangeMin) / (m_dRangeMax - m_dRangeMin) *
				   (double)(m_rcSlider.top+1 - (m_rcSlider.bottom-1 - m_iGripSize)) +
				   m_rcSlider.bottom-1 - m_iGripSize);
		
		if(m_iPixel <= m_rcSlider.top+1)
			m_iPixel = m_rcSlider.top+1;
		else if(m_iPixel >= (m_rcSlider.bottom-1 - m_iGripSize))
			m_iPixel = m_rcSlider.bottom-1 - m_iGripSize;
	}
	else
	{
		m_dPos = (double)(m_iPixel - (m_rcSlider.bottom-1 - m_iGripSize)) /
				 (double)(m_rcSlider.top+1 - (m_rcSlider.bottom-1 - m_iGripSize)) *
						(m_dRangeMax - m_dRangeMin) + m_dRangeMin;

		if(m_dPos <= m_dRangeMin)
			m_dPos = m_dRangeMin;
		if(m_dPos >= m_dRangeMax)
			m_dPos = m_dRangeMax;
	}

}

BOOL RxRegistGraph1DF::HitTestGrip(CPoint point)
{
	CRect	rcGrip;
	rcGrip.SetRect(m_rcSlider.left, m_iPixel, m_rcSlider.right, m_iPixel + m_iGripSize);

	return rcGrip.PtInRect(point);
}

BOOL RxRegistGraph1DF::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	POINT		point;
	GetCursorPos(&point);
	ScreenToClient(&point);
	if(HitTestGrip(point))
	{
		SetCursor(AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649)));
		return TRUE;
	}

	return CWnd::OnSetCursor(pWnd, nHitTest, message);
}

int RxRegistGraph1DF::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message) 
{
	HWND hWndFocus = ::GetFocus();
	if (m_hWnd != hWndFocus && !::IsChild(m_hWnd, hWndFocus))
		::SetFocus(m_hWnd);
	
	return CWnd::OnMouseActivate(pDesktopWnd, nHitTest, message);
}

void RxRegistGraph1DF::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if(!HitTestGrip(point))
	{
		CWnd::OnLButtonDown(nFlags, point);
		return;
	}

	int		iDiff, iOldPixel;
	iDiff = point.y - m_iPixel;
	SetCapture();

	for (;;)
	{
		MSG		msg;
		VERIFY(::GetMessage(&msg, NULL, 0, 0));
		ScreenToClient(&msg.pt);

		switch (msg.message)
		{
			case WM_MOUSEMOVE :
				// Set Pixel Position
				iOldPixel	= m_iPixel;
				m_iPixel	= msg.pt.y - iDiff;

				if(m_iPixel < m_rcSlider.top+1)
					m_iPixel = m_rcSlider.top+1;
				else if(m_iPixel > (m_rcSlider.bottom-1 - m_iGripSize))
					m_iPixel = m_rcSlider.bottom-1 - m_iGripSize;

				if(iOldPixel != m_iPixel)
				{
					UpdateGripPixel(FALSE);
					RedrawWnd();
				}
				break;
			case WM_LBUTTONUP :
				goto EndLButtonDown;
			default :	// just dispatch rest of the messages
				DispatchMessage(&msg);
				break;
		}
	}

EndLButtonDown :
	ReleaseCapture();

	CWnd::OnLButtonDown(nFlags, point);
}

BOOL RxRegistGraph1DF::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	if(zDelta >= 0)
	{
		double dOldPos = m_dPos;

		m_dPos += 100;

		if(m_dPos >= m_dRangeMax)
			m_dPos = m_dRangeMax;

		if(dOldPos != m_dPos)
		{
			UpdateGripPixel(TRUE);
			RedrawWnd();
		}
	}
	else
	{
		double dOldPos = m_dPos;

		m_dPos -= 100;

		if(m_dPos <= m_dRangeMin)
			m_dPos = m_dRangeMin;

		if(dOldPos != m_dPos)
		{
			UpdateGripPixel(TRUE);
			RedrawWnd();
		}
	}
	
	return CWnd::OnMouseWheel(nFlags, zDelta, pt);
}