imagewnd.cpp

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

// WndComLoad.cpp : implementation file
//

#include "stdafx.h"
#include "fusion.h"
#include "ImageWnd.h"
#include "TooltipCtrl.h"
#include "MemDC.h"
#include "fusionglobal.h"
#include "fusiondefine.h"
#include "Dib.h"
#include "dicomobject.h"

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

/////////////////////////////////////////////////////////////////////////////
// RxImageWnd

RxImageWnd::RxImageWnd(int iRFCNum)
{
	m_iRFNum = iRFCNum;
	m_nNcGripSize		= 13;
	m_nNcMin			= 0;
	m_nNcMax			= 100;
	m_nNcPos			= 50;
	m_nNcPixel			= 0;
	m_pnRawImage		= NULL;
	m_pnRawImageColor	= NULL;
	m_pDib				= NULL;
}

RxImageWnd::~RxImageWnd()
{
	if(m_hWnd)				
		DestroyWindow();
	
	if (m_pnRawImage){
		delete m_pnRawImage;
		m_pnRawImage = NULL;
	}
	
	if(m_pnRawImageColor){
		delete m_pnRawImageColor;
		m_pnRawImageColor = NULL;
	}

	if (m_pDib) {
		delete m_pDib;
		m_pDib = NULL;
	}
}


BEGIN_MESSAGE_MAP(RxImageWnd, CWnd)
	//{{AFX_MSG_MAP(RxImageWnd)
	ON_WM_NCCALCSIZE()
	ON_WM_NCHITTEST()
	ON_WM_NCLBUTTONDOWN()
	ON_WM_SETCURSOR()
	ON_WM_NCPAINT()
	ON_WM_ERASEBKGND()
	ON_WM_SIZE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// RxImageWnd message handlers

void RxImageWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
{
	lpncsp->rgrc[0].left	+= 2;
	lpncsp->rgrc[0].top		+= 2;
	lpncsp->rgrc[0].right	-= 2;
	lpncsp->rgrc[0].bottom	-= 22;
	
	CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
}

UINT RxImageWnd::OnNcHitTest(CPoint point) 
{
	CRect		rcWindow, rcTemp;
	GetWindowRect(rcWindow);

	if(point.y > rcWindow.bottom - 22)
	{
		rcTemp.SetRect(m_nNcPixel, rcWindow.bottom-18, m_nNcPixel+m_nNcGripSize, rcWindow.bottom-4);
		if(rcTemp.PtInRect(point))
			return HT_GRIP;
		return HT_BOTTOM;
	}

	return CWnd::OnNcHitTest(point);
}

void RxImageWnd::OnNcLButtonDown(UINT nHitTest, CPoint point) 
{
	if(nHitTest == HT_GRIP)
	{
		int		nDiff = point.x - m_nNcPixel;
		int		nTempPos;

		DrawSlider(FALSE, TRUE);
		SetCapture();

		for (;;)
		{
			MSG msg;
			VERIFY(::GetMessage(&msg, NULL, 0, 0));
		
			switch (msg.message)
			{
				case WM_MOUSEMOVE :
					nTempPos	= m_nNcPos;		// 蔼狼 函拳蜡公甫 魄窜窍扁 困秦
					m_nNcPixel	= msg.pt.x - nDiff;
					DrawSlider(FALSE, TRUE);
					if(nTempPos != m_nNcPos)
						GetOwner()->SendMessage(UM_GRIP_MOVE, m_iRFNum, (LPARAM)m_nNcPos);
					break;	
				case WM_LBUTTONUP :
			        goto EndLButtonDown;
				default :	// just dispatch rest of the messages
					DispatchMessage(&msg);
					break;
			}// end switch
		}// end loop

	EndLButtonDown :
		ReleaseCapture();
		DrawSlider(FALSE, FALSE);
	}
	
	CWnd::OnNcLButtonDown(nHitTest, point);
}

BOOL RxImageWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if(nHitTest == HT_GRIP)
	{
		SetCursor(AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649)));
		return TRUE;
	}
	
	return CWnd::OnSetCursor(pWnd, nHitTest, message);
}

void RxImageWnd::OnNcPaint() 
{
	// get window DC that is clipped to the non-client area
	CWindowDC	dc(this);

	CRect		rcWindow, rcTemp;
	GetWindowRect(rcWindow);
	rcWindow.OffsetRect(-rcWindow.left, -rcWindow.top);

	// draw Edge
	dc.Draw3dRect(rcWindow, RGB( 98, 98, 98), RGB(255,255,255));
	rcWindow.DeflateRect(1,1,1,1);
	dc.Draw3dRect(rcWindow, RGB(  0,  0,  0), RGB(198,198,198));

	ReleaseDC(&dc);
	
	DrawSlider(TRUE, FALSE);

	// Do not call CWnd::OnNcPaint() for painting messages
}

BOOL RxImageWnd::OnEraseBkgnd(CDC* pDC) 
{
	RxMemDC		dc(pDC);

	OnDraw(&dc);

	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CWndComAirway override functions

void RxImageWnd::OnDraw(CDC *pDC)
{
	CRect	rcClient;
	GetClientRect(rcClient);

	CBrush		brush, *pOldBrush;
	brush.CreateSolidBrush(RGB(  0,  0,  0));
	pOldBrush = pDC->SelectObject(&brush);
	pDC->PatBlt(rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height(), PATCOPY);
	pDC->SelectObject(pOldBrush);
	brush.DeleteObject();
	
	CPoint ptOrigin(m_szWindow - m_szDIB);
	ptOrigin.x /= 2;
	ptOrigin.y /= 2;

	if (m_pDib)
		m_pDib->Draw(pDC, ptOrigin, m_szDIB);
}

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

int  RxImageWnd::PosToPixel(int nValue, int nPosMin, int nPosMax, int nPixelMin, int nPixelMax, BOOL bPosToPixel)
{
	int		nReturn;
	float	fRatio = (float)(nPixelMax - nPixelMin) / (float)(nPosMax - nPosMin);

	if(bPosToPixel)
		nReturn = (int)((nValue - nPosMin) * fRatio + nPixelMin + 0.5f); // Pos ==> Pixel
	else
		nReturn = (int)((nValue - nPixelMin) / fRatio + nPosMin + 0.5f); // Pixel ==> Pos

	return nReturn;
}

void RxImageWnd::DrawSlider(BOOL bCallByPos, BOOL bCheck)
{
	CWindowDC	dc(this);

	CRect		rcWindow, rcTemp;
	GetWindowRect(rcWindow);

	CSize		szMem(rcWindow.Width()-4, 20);
	int			nSliderMin		= 100;
	int			nSliderMax		= szMem.cx - 60;
	int			nCenterY		= szMem.cy / 2;
	int			nWindowPixelMin = rcWindow.left+2;
	int			nGripPixel;

	rcWindow.OffsetRect(-rcWindow.left, -rcWindow.top);

	CDC		dcMem;
	CBitmap	bmpMem, *pOldBitmap;
	dcMem.CreateCompatibleDC(&dc);
	bmpMem.CreateCompatibleBitmap(&dc, szMem.cx, szMem.cy);
	pOldBitmap = dcMem.SelectObject(&bmpMem);

	// fill the background
	CBrush	brush, *pOldBrush;
	brush.CreateSolidBrush(RGB(138,138,138));
	pOldBrush = dcMem.SelectObject(&brush);
	dcMem.PatBlt(0, 0, szMem.cx, szMem.cy, PATCOPY);
	dcMem.SelectObject(pOldBrush);
	brush.DeleteObject();

	{
		// draw top border
		CPen	pen, *pOldPen;
		pen.CreatePen(PS_SOLID, 1, RGB(255,255,255));
		pOldPen = dcMem.SelectObject(&pen);
		dcMem.MoveTo( 0, 0);			dcMem.LineTo(szMem.cx, 0);
		dcMem.SelectObject(pOldPen);
		pen.DeleteObject();

		// draw title string
		CFont		font, *pOldFont;
		font.CreateFont(17, 0, 0, 0, FW_BOLD, TRUE, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS,
						CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, _T("Arial"));
		pOldFont = dcMem.SelectObject(&font);
		CString		strTitle;
		GetWindowText(strTitle);
		rcTemp.SetRect(0, 1, nSliderMin, szMem.cy);
		dcMem.SetBkMode(TRANSPARENT);
		dcMem.SetTextColor(RGB(208,198,198));
		dcMem.DrawText(strTitle, rcTemp, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
		dcMem.SelectObject(pOldFont);
		font.DeleteObject();

		// draw slider guide line
		pen.CreatePen(PS_SOLID, 1, RGB(198,198,198));
		pOldPen = dcMem.SelectObject(&pen);
		dcMem.MoveTo(nSliderMin+m_nNcGripSize/2, nCenterY);		dcMem.LineTo(nSliderMax+m_nNcGripSize/2, nCenterY);
		dcMem.SelectObject(pOldPen);
		pen.DeleteObject();
		pen.CreatePen(PS_SOLID, 1, RGB(255,255,255));
		pOldPen = dcMem.SelectObject(&pen);
		dcMem.MoveTo(nSliderMin+m_nNcGripSize/2, nCenterY+1);	dcMem.LineTo(nSliderMax+m_nNcGripSize/2, nCenterY+1);
		dcMem.SelectObject(pOldPen);
		pen.DeleteObject();
		// calculate grip position
		if(bCallByPos)
		{
			nGripPixel = PosToPixel(m_nNcPos, m_nNcMin, m_nNcMax, nSliderMin, nSliderMax, TRUE);
			m_nNcPixel   = nWindowPixelMin + nGripPixel;
		}
		else
		{
			if(m_nNcPixel-nWindowPixelMin < nSliderMin)
				m_nNcPixel = nWindowPixelMin+nSliderMin;
			if(m_nNcPixel-nWindowPixelMin > nSliderMax)
				m_nNcPixel = nWindowPixelMin+nSliderMax;
			nGripPixel	= m_nNcPixel - nWindowPixelMin;
			m_nNcPos	= PosToPixel(nGripPixel, m_nNcMin, m_nNcMax, nSliderMin, nSliderMax, FALSE);
		}

		// draw grip
		CDC		dcTemp;
		CBitmap	bmpTemp, *pOldBmpTemp;
		dcTemp.CreateCompatibleDC(&dcMem);
		bmpTemp.LoadBitmap(IDB_SLIDER_GRIP_HORZ);
		pOldBmpTemp = dcTemp.SelectObject(&bmpTemp);
		TransparentBlt(dcMem.m_hDC, nGripPixel, 5, 13, 13, 
			dcTemp.m_hDC, bCheck ? 13 : 0, 0, 13, 13, RGB(255,255,255));
		dcTemp.SelectObject(pOldBmpTemp);
		bmpTemp.DeleteObject();

		// draw position text
		font.CreateFont(-12, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS,
						CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, _T("Arial"));
		pOldFont = dcMem.SelectObject(&font);

		CString		strPosition;
		strPosition.Format(_T("%d"), m_nNcPos);
		rcTemp.SetRect(nSliderMax+20, 3, szMem.cx-5, szMem.cy - 2);

		pen.CreatePen(PS_SOLID, 1, RGB(198,198,198));
		brush.CreateSolidBrush(RGB(  0,  0,  0));
		pOldPen   = dcMem.SelectObject(&pen);
		pOldBrush = dcMem.SelectObject(&brush);
		dcMem.Rectangle(rcTemp);

		dcMem.SetTextColor(RGB(255,255,  0));
		dcMem.DrawText(strPosition, rcTemp, DT_SINGLELINE|DT_VCENTER|DT_CENTER);

		dcMem.SelectObject(pOldPen);
		dcMem.SelectObject(pOldBrush);
		dcMem.SelectObject(pOldFont);
		pen.DeleteObject();
		brush.DeleteObject();
		font.DeleteObject();
	}

	dc.BitBlt(rcWindow.left+2, rcWindow.bottom-22, szMem.cx, szMem.cy, &dcMem, 0, 0, SRCCOPY);

	dcMem.SelectObject(pOldBitmap);
	bmpMem.DeleteObject();

	ReleaseDC(&dc);
}

void RxImageWnd::SetSliderRange(int nMin, int nMax, BOOL bRedraw)
{
	m_nNcMin = nMin;
	m_nNcMax = nMax;

	SetSliderPos(m_nNcPos, bRedraw);
}

void RxImageWnd::SetSliderPos(int nPos, BOOL bRedraw)
{
	if(nPos < m_nNcMin)		nPos = m_nNcMin;
	if(nPos > m_nNcMax)		nPos = m_nNcMax;

	m_nNcPos = nPos;

	if(bRedraw)				DrawSlider(TRUE, FALSE);
}

void RxImageWnd::GetSliderRange(int &nMin, int &nMax)
{
	nMin = m_nNcMin;
	nMax = m_nNcMax;
}

int  RxImageWnd::GetSliderPos()
{
	return m_nNcPos;
}

void RxImageWnd::OnSize(UINT nType, int cx, int cy) 
{
	CWnd::OnSize(nType, cx, cy);
	
	m_szWindow.cx = cx;
	m_szWindow.cy = cy;
}

void RxImageWnd::RedrawScreen()
{
	CDC *pDC = GetDC();

	OnEraseBkgnd(pDC);

	ReleaseDC(pDC);
}


void RxImageWnd::Resample(CString strFilePath)
{
	LPBYTE pword;

	if (m_pnRawImage) {
		delete m_pnRawImage;
		m_pnRawImage = NULL;
	}

	if (m_pnRawImageColor){
		delete m_pnRawImageColor;
		m_pnRawImageColor = NULL;
	}

	int iType;
	RxDicomObject *pDcm = new RxDicomObject();
	if (!pDcm->LoadHeader(strFilePath, TRUE)){
		if(pDcm)
			delete pDcm;
		return;
	}

	int iX = 0, iY = 0, iBpp = 0, iSpp = 0;
	CString strModal;
	pDcm->GetDicomInfo(DI_ROW, &iY, &iType);
	pDcm->GetDicomInfo(DI_COLUMN, &iX, &iType);
	pDcm->GetDicomInfo(DI_BITALLOCATED, &iBpp, &iType);
	pDcm->GetDicomInfo(DI_SAMPLEPERPIXEL, &iSpp, &iType);
	pDcm->GetDicomInfo(DI_MODALITY, &strModal, &iType);


	if (iSpp == 1){
		int iSize = iX * iY;
		m_pnRawImage = new unsigned short[iSize];
		memcpy((unsigned short*)m_pnRawImage , (unsigned short*)pDcm->GetImageData(), iBpp*iSize/8);
		
		for(int i = 0; i < iSize; i++) {
			if(m_pnRawImage[i]>4095) {
				if (m_pnRawImage[i]<20000)
					m_pnRawImage[i]=4095;
				else
					m_pnRawImage[i]=0;
			} else if (m_pnRawImage[i] < 0)
				m_pnRawImage[i]=0;
		}
	}
	else{
		pword = (LPBYTE)pDcm->GetImageData();
	}

	m_szRawImg = CSize(iX, iY);

	unsigned char *pWindowingTable;
	
	if(strModal == "CT")
//		RxGetFrameBottom()->SetWindowing(m_iRFNum, -1024 + 251, 500);
		RxGetFrameBottom()->SetWindowing(m_iRFNum, 1060 - 1024, 500);
//		RxGetFrameBottom()->SetWindowing(m_iRFNum, 394, 1067);
	else 
		RxGetFrameBottom()->SetWindowing(m_iRFNum, 90 - 1024, 190);

	pWindowingTable = RxGetFrameTuning()->GetWindowingTable(m_iRFNum);

	if (m_pDib) {
		delete m_pDib;
		m_pDib = NULL;
	}

	// 技肺 绵 fitting阑 困秦 zoom factor炼例
	int iZoomFactor = int(100. * m_szWindow.cy / m_szRawImg.cy);

	if (iSpp ==1)
		m_pDib = (RxDib*)RxRawImgToDIB(m_pnRawImage, m_szRawImg, m_szDIB, iZoomFactor, pWindowingTable, TRUE);

	// 促矫 弊赴促
	RedrawScreen();

	if(pDcm)
		delete pDcm;

}


void RxImageWnd::ClearScreen()
{
	if (m_pDib)
		delete m_pDib;

	m_pDib = NULL;
	RedrawScreen();
}