histogram.cpp

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

// Histogram.cpp : implementation file
//

#include "stdafx.h"
#include "fusion.h"
#include "Histogram.h"
#include "FusionColorUI.h"

#include "Dib.h"

#include <math.h>

// yeni
//#include "FusionGlobal.h"
		// yeni 2004.02.11
//		int		nSeries = RxGetCurSeries();
//		RxGetFrameMain()->m_pLocalizerManager[nSeries]->RedrawAll();

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

/////////////////////////////////////////////////////////////////////////////
// RxHistogram

RxHistogram::RxHistogram()
{
	// color information
	m_crBackHistogram_in	= RGB(  0,  0,  0);
	m_crBackHistogram_out	= RGB(122,122,122);
	m_crBackground			= RXCOLOR_11;
	m_crBackOTFMargin		= RGB( 78, 93, 98);
	m_crBackSpectrum		= RGB(255,255,  0);
	m_crHistogram			= RGB(110,135,140);
	m_crGrid				= RGB(168,168,168);
	m_crWindowing			= RGB(0,220,220);

	// scroll information
	m_stScroll.nRangeMinOut	= -1300;
	m_stScroll.nRangeMaxOut	= 3300;
	m_stScroll.nRangeMinIn	= -1024;
	m_stScroll.nRangeMaxIn	= 3071;
	m_stScroll.nPoMin		= -1024;
	m_stScroll.nPoMax		= 1300;
	m_stScroll.nPiMin		= 0;
	m_stScroll.nPiMax		= 0;
	m_stScroll.nMinSize		= 50;

	// histogram information
	m_stHistogram.nSize		= 0;
	m_stHistogram.nMaxMagnitude	= 0;
	m_stHistogram.pHistogram	= NULL;

	// windowing information
	m_stWindowing.bVisible	= TRUE;
	m_stWindowing.nLevel	= 0;
	m_stWindowing.nWidth	= 500;

	// OTF information
	m_nActiveOTF			= -1;
	m_ArrayOTFPolygon.SetSize(0, 4);
}

RxHistogram::~RxHistogram()
{
}


BEGIN_MESSAGE_MAP(RxHistogram, CWnd)
	//{{AFX_MSG_MAP(RxHistogram)
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_SETCURSOR()
	ON_WM_LBUTTONDOWN()
	ON_WM_DESTROY()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// RxHistogram message handlers

void RxHistogram::PostNcDestroy() 
{
	CWnd::PostNcDestroy();

	delete this;
}

void RxHistogram::OnDestroy() 
{
	CWnd::OnDestroy();
	
	RemoveHistogram();
	RemoveAllOTFPolygon();
}

/////////////////////////////////////////////////////////////////////////////
// Draw functions

void RxHistogram::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	RedrawWnd();

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

void RxHistogram::RedrawWnd()
{
	CRect	rcClient, rect;
	GetClientRect(rcClient);

	CDC		*pDC = GetDC();

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

	// draw scroll
	rect.SetRect(rcClient.left, rcClient.top, rcClient.right, rcClient.top+HGSZ_SCROLL);
	DrawScroll(&dcMem, rect);
	// fill scroll - histogram gab
	rect.top = rect.bottom;					rect.bottom = rect.top+HGSZ_SCROLL_MARGIN;
	DrawFillRect(&dcMem, rect, m_crBackground);
	// fill whole histogram background
	rect.top = rect.bottom;					rect.bottom = rect.top + m_szWindow.cy;
	DrawBackground(&dcMem, rect);
	// draw histogram
	rect.top = rect.top+HGSZ_OTF_TMARGIN;	rect.bottom = rcClient.bottom-(HGSZ_OTF_BMARGIN+HGSZ_SPECTRUM);
	DrawHistogram(&dcMem, rect);
	// draw histogram grid
	rect.bottom += HGSZ_OTF_BMARGIN;
	DrawHistogramGrid(&dcMem, rect);
	// draw windowing grid
	rect.bottom -= HGSZ_OTF_BMARGIN;
	if(m_stWindowing.bVisible)
		DrawWindowing(&dcMem, rect);
	// draw OTF
	DrawOTF(&dcMem);
	rect.bottom += HGSZ_OTF_BMARGIN;

	rect.top = rect.bottom;			rect.bottom = rcClient.bottom;
	DrawSpectrum(&dcMem, rect);

	pDC->BitBlt(0, 0, rcClient.Width(), rcClient.Height(), &dcMem, 0, 0, SRCCOPY);

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

	ReleaseDC(pDC);
}

void RxHistogram::DrawFillRect(CDC *pDC, CRect rect, COLORREF color)
{
	CBrush		brush, *pOldBrush;
	brush.CreateSolidBrush(color);
	pOldBrush = pDC->SelectObject(&brush);
	pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATCOPY);
	pDC->SelectObject(pOldBrush);
	brush.DeleteObject();
}

void RxHistogram::DrawScroll(CDC *pDC, CRect rect)
{
	// draw background
	rect.left  = 0;
	rect.right = PoToPiH(m_stScroll.nRangeMinIn, m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);
	DrawFillRect(pDC, rect, m_crBackHistogram_out);
	rect.left  = rect.right;
	rect.right = PoToPiH(m_stScroll.nRangeMaxIn, m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);
	DrawFillRect(pDC, rect, m_crBackHistogram_in);
	rect.left  = rect.right;
	rect.right = m_szWindow.cx;
	DrawFillRect(pDC, rect, m_crBackHistogram_out);

	// draw OTF Position
	int		nOTFCount = m_ArrayOTFPolygon.GetSize();
	for(int i = 0; i < nOTFCount; i++)
	{
		_OTF_POLYGON* pOTFPolygon = (_OTF_POLYGON *)m_ArrayOTFPolygon.GetAt(i);

		rect.left  = PoToPiH(pOTFPolygon->nPointPoX[0], m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);
		rect.right = PoToPiH(pOTFPolygon->nPointPoX[3], m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);

		DrawFillRect(pDC, rect, m_crHistogram);
	}

	// draw windowing grid
	if(m_stWindowing.bVisible)
	{
		CPen	pen, *pOldPen;
		pen.CreatePen(PS_SOLID, 1, m_crWindowing);
		pOldPen = pDC->SelectObject(&pen);

		int nWindowing;
		// low 
		nWindowing = m_stWindowing.nLevel - m_stWindowing.nWidth/2;
		nWindowing = PoToPiH(nWindowing, m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);
		pDC->MoveTo(nWindowing, rect.bottom);
		pDC->LineTo(nWindowing, rect.top-1);
		// high
		nWindowing = m_stWindowing.nLevel + m_stWindowing.nWidth/2;
		nWindowing = PoToPiH(nWindowing, m_stScroll.nRangeMinOut, m_stScroll.nRangeMaxOut);
		pDC->MoveTo(nWindowing, rect.bottom);
		pDC->LineTo(nWindowing, rect.top-1);

		pDC->SelectObject(pOldPen);
		pen.DeleteObject();
	}

	// draw scroll bar
	rect.left	= m_stScroll.nPiMin;
	rect.right	= m_stScroll.nPiMax;
	pDC->Draw3dRect(rect, RGB(222,222,222), RGB( 98, 98, 98));
	rect.DeflateRect(1,1,1,1);
	pDC->Draw3dRect(rect, RGB( 98, 98, 98), RGB(222,222,222));
}

void RxHistogram::DrawBackground(CDC *pDC, CRect rect)
{
	// draw background
	// CT Value蔼捞 绝绰 镑阑 拌魂窍咯 后傍埃栏肺 磨茄促.
	rect.left  = 0;
	if(m_stScroll.nRangeMinIn > m_stScroll.nPoMin)
	{
		rect.right = PoToPiH(m_stScroll.nRangeMinIn, m_stScroll.nPoMin, m_stScroll.nPoMax);
		DrawFillRect(pDC, rect, m_crBackHistogram_out);
		rect.left  = rect.right;
	}

	if(m_stScroll.nRangeMaxIn >= m_stScroll.nPoMax)
	{
		rect.right = m_szWindow.cx;
		DrawFillRect(pDC, rect, m_crBackHistogram_in);
	}
	else
	{
		rect.right = PoToPiH(m_stScroll.nRangeMaxIn, m_stScroll.nPoMin, m_stScroll.nPoMax);
		DrawFillRect(pDC, rect, m_crBackHistogram_in);

		rect.left  = rect.right;
		rect.right = m_szWindow.cx;
		DrawFillRect(pDC, rect, m_crBackHistogram_out);
	}
}

void RxHistogram::DrawHistogram(CDC *pDC, CRect rect)
{
	if(m_stHistogram.pHistogram == NULL)
		return;

	CPen pen, *pOldPen;
	pen.CreatePen(PS_SOLID, 1, m_crHistogram);
	pOldPen=pDC->SelectObject(&pen);

	// 拳搁惑俊 焊捞绰 何盒
	int		nPoBegin, nPoEnd, nPiBegin, nPiEnd;
	nPoBegin = max(m_stScroll.nRangeMinIn, m_stScroll.nPoMin);
	nPoEnd   = min(m_stScroll.nRangeMaxIn, m_stScroll.nPoMax);
	nPiBegin = PoToPiH(nPoBegin, m_stScroll.nPoMin, m_stScroll.nPoMax);
	nPiEnd   = PoToPiH(nPoEnd,   m_stScroll.nPoMin, m_stScroll.nPoMax);

	// 茄 pixel寸 绢蠢沥档狼 CT interval俊 秦寸窍绰瘤..
	double	dIncrease = 1.0 * (nPoEnd - nPoBegin) / (nPiEnd-nPiBegin); 
	// 泅犁 困摹甫 0 Base, 硅凯 牢郸胶肺 函券茄促.
	int		nIndex;
	double	dIndex = (nPoBegin - m_stScroll.nRangeMinIn);
	// 厚啦 拌魂
	double	dMagRatio  = (double)(rect.bottom-rect.top+1) / (double)(m_stHistogram.nMaxMagnitude);
	double	dFrac, dFreq;

	for(int nPixel = nPiBegin; nPixel < nPiEnd; nPixel++)
	{
		nIndex = (int)(floor(dIndex));
		dFrac = dIndex - nIndex;

		if(nIndex >= 0 && nIndex < m_stHistogram.nSize-1)
		{
			if(m_stHistogram.pHistogram[nIndex])
			{
				pDC->MoveTo(nPixel, rect.bottom);
				dFreq = (m_stHistogram.pHistogram[nIndex] * (1.-dFrac) + 
										m_stHistogram.pHistogram[nIndex+1]*dFrac);
				pDC->LineTo(nPixel, rect.bottom - (int)(dFreq * dMagRatio));
			}
		}

		dIndex += dIncrease;
	}

	pDC->SelectObject(pOldPen);
	pen.DeleteObject();
}

void RxHistogram::DrawHistogramGrid(CDC *pDC, CRect rect)
{
	// draw grid
	CFont		font, *pOldFont;
	LOGFONT		logFont;
	memset(&logFont, 0, sizeof(logFont));
	font.Attach(::GetStockObject(ANSI_VAR_FONT));

	pOldFont = pDC->SelectObject(&font);
	pDC->SetBkMode(TRANSPARENT);
	pDC->SetTextColor(m_crGrid);

	CPen		pen, *pOldPen;
	pen.CreatePen(PS_SOLID, 1, m_crGrid);
	pOldPen = pDC->SelectObject(&pen);

	int			i, nGridBegin, nGridEnd, nGridGab, nPixelIndex;
	CString		strText;
	CRect		rcText;

	// calculate a grid gab, number 5 is a minimun grid count
	nGridGab = (m_stScroll.nPoMax-m_stScroll.nPoMin) / 5;
	if (nGridGab >= 1000)
		nGridGab = nGridGab/1000*1000;
	else if (nGridGab >= 500)
		nGridGab = nGridGab/500*500;
	else if (nGridGab >= 200)
		nGridGab = nGridGab/200*200;
	else if (nGridGab >= 100)
		nGridGab = nGridGab/100*100;
	else if (nGridGab >= 50)
		nGridGab = nGridGab/50*50;
	else if (nGridGab >= 20)
		nGridGab = nGridGab/20*20;
	else
		nGridGab = nGridGab/10*10;
	if (nGridGab == 0)	nGridGab = 10;

	nGridBegin = (m_stScroll.nPoMin / nGridGab) * nGridGab;
	nGridEnd   = (m_stScroll.nPoMax / nGridGab) * nGridGab;

	for(i = nGridBegin; i <= nGridEnd; i += nGridGab)
	{
		nPixelIndex = PoToPiH(i, m_stScroll.nPoMin, m_stScroll.nPoMax, FALSE);

		pDC->MoveTo(nPixelIndex, rect.bottom-HGSZ_OTF_BMARGIN);
		pDC->LineTo(nPixelIndex, rect.top-1);
		strText.Format(_T("%d"), i);
		rcText.SetRect(nPixelIndex-20, rect.bottom-HGSZ_OTF_BMARGIN+3, nPixelIndex+20, rect.bottom);
		pDC->DrawText(strText, rcText, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldFont);
	pen.DeleteObject();
	font.DeleteObject();
}

void RxHistogram::DrawWindowing(CDC *pDC, CRect rect)
{
	CPen	pen, *pOldPen;
	pen.CreatePen(PS_SOLID, 1, m_crWindowing);
	pOldPen = pDC->SelectObject(&pen);

	int nWindowing;
	// low 
	nWindowing = m_stWindowing.nLevel - m_stWindowing.nWidth/2;
	nWindowing = PoToPiH(nWindowing, m_stScroll.nPoMin, m_stScroll.nPoMax, FALSE);
	pDC->MoveTo(nWindowing, rect.bottom);
	pDC->LineTo(nWindowing, rect.top-1);
	// high
	nWindowing = m_stWindowing.nLevel + m_stWindowing.nWidth/2;
	nWindowing = PoToPiH(nWindowing, m_stScroll.nPoMin, m_stScroll.nPoMax, FALSE);
	pDC->MoveTo(nWindowing, rect.bottom);
	pDC->LineTo(nWindowing, rect.top-1);

	pDC->SelectObject(pOldPen);
	pen.DeleteObject();
}

void RxHistogram::DrawOTF(CDC *pDC)
{
	int		nOTFCount = m_ArrayOTFPolygon.GetSize();
	if(nOTFCount <= 0)	return;

	int		i,j,k;
	_OTF_POLYGON	*pOTFPolygon;

	CRect	rcPoint;

	CPen	pen, *pOldPen;
	int		nPenWidth;
	COLORREF crPenColor;

	// draw Inactive OTF and then draw Active OTF
	for(i = 0; i <= nOTFCount; i++)
	{
		if(i == nOTFCount)
		{
			j = m_nActiveOTF;
			nPenWidth = 2;
		}
		else
		{
			j = i;
			nPenWidth = 1;
		}
		if(i == m_nActiveOTF)		continue;

		pOTFPolygon = (_OTF_POLYGON *)m_ArrayOTFPolygon.GetAt(j);

		if(pOTFPolygon->bEnable)	crPenColor = RGB(255,255,255);
		else						crPenColor = RGB( 98, 98, 98);
		pen.CreatePen(PS_SOLID, nPenWidth, crPenColor);
		pOldPen = pDC->SelectObject(&pen);

		pDC->MoveTo(pOTFPolygon->nPointPiX[0], pOTFPolygon->nPointPiY[0]);
		pDC->LineTo(pOTFPolygon->nPointPiX[1], pOTFPolygon->nPointPiY[1]);
		pDC->LineTo(pOTFPolygon->nPointPiX[2], pOTFPolygon->nPointPiY[2]);
		pDC->LineTo(pOTFPolygon->nPointPiX[3], pOTFPolygon->nPointPiY[3]);

		for(k = 0; k < 4; k++)