usedlgs.cpp

医学图象处理系统

// UseDlgs.cpp : implementation file
//

#include "stdafx.h"
#include "ImageLAB.h"
#include "AllImage.h"
#include "ImageLABDoc.h"
#include "ImageLABView.h"
#include "UseDlgs.h"
#include "CommonProc.h"

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

/////////////////////////////////////////////////////////////////////////////
// CHistBinDlg dialog
CHistBinDlg::CHistBinDlg(CImageLABDoc *_pDoc, CWnd* pParent /*=NULL*/)
	: CDialog(CHistBinDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CHistBinDlg)
	//}}AFX_DATA_INIT
	DrawType  = 0;
	m_pDoc    =_pDoc;
	StartPt.x = 10;	// the ORIGINAL point.
	StartPt.y = 110;
	int HistogramSize = 256 * sizeof(int);
	memset(HistogramR,		0, HistogramSize);
	memset(HistogramG,		0, HistogramSize);
	memset(HistogramB,		0, HistogramSize);
	memset(HistogramRGB,	0, HistogramSize);
	memset(HistogramSigma,  0, HistogramSize);
	int ImgSize;

	pView = m_pDoc->m_pView;
    
	if(pView!=NULL)
	{
		if(m_pDoc->Image.m_lpDibArray!=NULL)
		{			
			if(pView->DashRectDrawed)
			{
				CPoint p1, p2;
				pView->GetSelectArea(p1, p2);
				ImgSize = abs( (p2.y - p1.y) * (p2.x - p1.x) );
				if(m_pDoc->Image.m_wImageDepth == 8) //灰度图像
				{
					eImageType ImgType = m_pDoc->Image.GetImageType();
					if( ImgType == IndexColorImage )
					{
						RGBTRIPLE ColorIndex;
						for(int j= p1.y; j< p2.y; j++)
						{
							BYTE *temp = m_pDoc->Image.RowAddress[j] + p1.x;
							for(int i= p1.x; i< p2.x; i++, temp++)
							{
								ColorIndex = m_pDoc->Image.ColorIndex[*temp];
								HistogramR[ColorIndex.rgbtRed]++;
								HistogramG[ColorIndex.rgbtGreen]++;
								HistogramB[ColorIndex.rgbtBlue]++;
								HistogramRGB[(ColorIndex.rgbtRed+ ColorIndex.rgbtGreen+ ColorIndex.rgbtBlue+2)/3]++;
							}
						}
					}
					else if( ImgType == IndexGrayImage )
					{
						for(int j= p1.y; j< p2.y; j++)
						{
							BYTE *temp = m_pDoc->Image.RowAddress[j] + p1.x;
							for(int i= p1.x; i< p2.x; i++, temp++)
							{
								 HistogramRGB[*temp]++;
							}
						}
						memcpy(HistogramR, HistogramRGB, HistogramSize);
						memcpy(HistogramG, HistogramRGB, HistogramSize);
						memcpy(HistogramB, HistogramRGB, HistogramSize);
					}
				}
				else if(m_pDoc->Image.m_wImageDepth == 24) // 24位真彩色图像
				{
					for(int j= p1.y; j< p2.y; j++)
					{
						RGBTRIPLE *temp = (RGBTRIPLE*)m_pDoc->Image.RowAddress[j] + 3* p1.x;
						for(int i= p1.x; i< p2.x; i++, temp++)
						{
							HistogramR[temp->rgbtRed]++;
							HistogramG[temp->rgbtGreen]++;
							HistogramB[temp->rgbtBlue]++;
							HistogramRGB[(temp->rgbtRed+ temp->rgbtGreen+ temp->rgbtBlue+2)/3]++;
						}
					}
				}
				else
				{
					for(int j= p1.y; j< p2.y; j++)
					{
						for(int i= p1.x; i< p2.x; i++)
						{
							 RGBTRIPLE temp = m_pDoc->Image.GetRGBPixel(i,j);
							 HistogramR[temp.rgbtRed]++;
							 HistogramG[temp.rgbtGreen]++;
							 HistogramB[temp.rgbtBlue]++;
							 HistogramRGB[(temp.rgbtRed+temp.rgbtGreen+temp.rgbtBlue+2)/3]++;
						}
					}
				}
			}
			else
			{
				ImgSize = m_pDoc->Image.m_ImageHeight * m_pDoc->Image.m_ImageWidth;
				if(m_pDoc->Image.m_wImageDepth == 8) //灰度图像
				{
					eImageType ImgType = m_pDoc->Image.GetImageType();
					if( ImgType == IndexColorImage )
					{
						RGBTRIPLE ColorIndex;
						for(int j=0;j<m_pDoc->Image.m_ImageHeight;j++)
						{
							BYTE *temp = m_pDoc->Image.RowAddress[j];
							for(int i=0; i<m_pDoc->Image.m_ImageWidth; i++, temp++)
							{							
								ColorIndex = m_pDoc->Image.ColorIndex[*temp];
								HistogramR[ColorIndex.rgbtRed]++;
								HistogramG[ColorIndex.rgbtGreen]++;
								HistogramB[ColorIndex.rgbtBlue]++;
								HistogramRGB[(ColorIndex.rgbtRed+ ColorIndex.rgbtGreen+ ColorIndex.rgbtBlue+2)/3]++;
							}						
						}
					}
					else if( ImgType == IndexGrayImage )
					{
						for(int j=0;j<m_pDoc->Image.m_ImageHeight;j++)
						{
							BYTE *temp = m_pDoc->Image.RowAddress[j];
							for(int i=0; i<m_pDoc->Image.m_ImageWidth; i++, temp++)
							{							
								HistogramRGB[*temp]++;
							}						
						}
						memcpy(HistogramR, HistogramRGB, HistogramSize);
						memcpy(HistogramG, HistogramRGB, HistogramSize);
						memcpy(HistogramB, HistogramRGB, HistogramSize);
					}
				} 
				else if(m_pDoc->Image.m_wImageDepth == 24) // 24位真彩色图像
				{
					for(int j=0;j<m_pDoc->Image.m_ImageHeight;j++)
					{
						RGBTRIPLE *temp = (RGBTRIPLE *)m_pDoc->Image.RowAddress[j];
						for(int i=0; i<m_pDoc->Image.m_ImageWidth; i++, temp++)
						{
							HistogramR[temp->rgbtRed]++;
							HistogramG[temp->rgbtGreen]++;
							HistogramB[temp->rgbtBlue]++;
							HistogramRGB[(temp->rgbtRed+ temp->rgbtGreen+ temp->rgbtBlue+2)/3]++;
						}
					}
				}
				else // 其它位的图像
				{
					for(int j=0;j<m_pDoc->Image.m_ImageHeight;j++)
					{
						for(int i=0; i<m_pDoc->Image.m_ImageWidth; i++)
						{
							RGBTRIPLE temp = m_pDoc->Image.GetRGBPixel(i,j);
							HistogramR[temp.rgbtRed]++;
							HistogramG[temp.rgbtGreen]++;
							HistogramB[temp.rgbtBlue]++;
							HistogramRGB[(temp.rgbtRed+ temp.rgbtGreen+ temp.rgbtBlue+2)/3]++;
						}
					}
				}
			}
		}
	}
	//
	int   i, IntegralHist[256], IntegralHistL[256];
	memcpy(IntegralHist,  HistogramRGB, HistogramSize);
	memcpy(IntegralHistL, HistogramRGB, HistogramSize);

	for(IntegralHistL[0] = 0, i=1; i<256; i++)
	{
		IntegralHist[i] += IntegralHist[i-1];
		IntegralHistL[i] = i* IntegralHistL[i] + IntegralHistL[i-1];
	}
	
	int Inverse1, Inverse2;
	double MaxV =0, m02 = (double) IntegralHistL[255] / (double)ImgSize;
	m02 *= m02;

	double ma, mb, pa, pb, Sigma;
	for(i=1; i<256; i++)
	{
		Inverse1 = ImgSize - IntegralHist[i];
		Inverse2 = IntegralHistL[255] - IntegralHistL[i];
		if(Inverse1 == 0 || IntegralHist[i] == 0) continue;

		pa = (double)IntegralHist[i]  / ImgSize;
		pb = (double)Inverse1		  / ImgSize;
		ma = (double)IntegralHistL[i] / IntegralHist[i];
		mb = (double)Inverse2		  / Inverse1;
		Sigma = pa* ma* ma + pb* mb* mb - m02 + 0.5;
		HistogramSigma[i] = int (pa* ma* ma + pb* mb* mb - m02 + 0.5);
	}

	MaxFrequencyR = MaxFrequencyG = MaxFrequencyB = MaxFrequencyRGB = MaxFrequencySigma = 0;
	for(i= 0; i< 256; i++)
	{
		if(  MaxFrequencyR< HistogramR[i])   MaxFrequencyR = HistogramR[i];
		if(  MaxFrequencyG< HistogramG[i])   MaxFrequencyG = HistogramG[i];
		if(  MaxFrequencyB< HistogramB[i])   MaxFrequencyB = HistogramB[i];
		if(MaxFrequencyRGB< HistogramRGB[i]) MaxFrequencyRGB = HistogramRGB[i];
		if(MaxFrequencySigma< HistogramSigma[i]) MaxFrequencySigma = HistogramSigma[i];
	}
}

void CHistBinDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHistBinDlg)
	DDX_Control(pDX, IDC_COMBO1, m_Combo1);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CHistBinDlg, CDialog)
	//{{AFX_MSG_MAP(CHistBinDlg)
	ON_CBN_SELCHANGE(IDC_COMBO1, OnSelchangeCombo1)
	ON_WM_PAINT()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHistBinDlg message handlers
BOOL CHistBinDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();

	m_Combo1.InsertString(0,"RGB");
	m_Combo1.InsertString(1,"Red");
	m_Combo1.InsertString(2,"Green");
	m_Combo1.InsertString(3,"Blue");
	m_Combo1.SetCurSel(0);
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CHistBinDlg::OnSelchangeCombo1() 
{
	DrawType = m_Combo1.GetCurSel();
	Invalidate();
}

void CHistBinDlg::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	CPen  BlackPen(PS_SOLID, 1, RGB(  0,   0,   0)), *pOldPen;
	CPen  RedPen  (PS_SOLID, 1, RGB(255,   0,   0));
	CPen  GreenPen(PS_SOLID, 1, RGB(  0, 255,   0));
	CPen  BluePen (PS_SOLID, 1, RGB(  0,   0, 255));

	dc.SetROP2(R2_BLACK);

	CPoint tmpP(StartPt.x+255,StartPt.y+1);
	dc.MoveTo(StartPt.x,StartPt.y+1);
	dc.LineTo(tmpP);
	dc.MoveTo(StartPt.x,StartPt.y+2);
	dc.LineTo(tmpP.x,   tmpP.y+1);

	dc.SetBkMode(TRANSPARENT);
	dc.TextOut(StartPt.x,StartPt.y+2,"0");
	dc.TextOut(StartPt.x+240,StartPt.y+2,"255");
	//draw histogram picture
	
	dc.SetROP2(R2_COPYPEN);

	int  i, px, py, *Data = NULL;
	double scale;
	if(DrawType==0)
	{		
		Data = HistogramRGB;
		scale =  100.0 / MaxFrequencyRGB;
		pOldPen = dc.SelectObject(&BlackPen);
	}
	else if(DrawType==1)
	{
		Data = HistogramR;
		scale =  100.0 / MaxFrequencyR;
		pOldPen = dc.SelectObject(&RedPen);
	}
	else if(DrawType==2)
	{
		Data = HistogramG;
		scale =  100.0 / MaxFrequencyG;
		pOldPen = dc.SelectObject(&GreenPen);
	}
	else 
	{
		Data = HistogramB;
		scale =  100.0 / MaxFrequencyB;
		pOldPen = dc.SelectObject(&BluePen);
	}

	for(px= StartPt.x, i= 0; i < 256; i++, px++)
	{
		py = StartPt.y - int(Data[i]* scale);
		dc.MoveTo(px, StartPt.y);
		dc.LineTo(px, py);
	}
	dc.SelectObject(pOldPen);

	if(DrawType==0)
	{
		scale   = 100.0 / MaxFrequencySigma;
		pOldPen = dc.SelectObject(&RedPen);
		dc.MoveTo( StartPt );
		for(px= StartPt.x, i= 0; i < 256; i++, px++)
		{
			py = StartPt.y - int(HistogramSigma[i]* scale);
			dc.LineTo(px, py);
		}
		dc.SelectObject(pOldPen);
	}	
}

/////////////////////////////////////////////////////////////////////////////
// CWallisParam dialog
CWallisParam::CWallisParam(CImageLABDoc *_pDoc,CWnd* pParent /*=NULL*/)
	: CDialog(CWallisParam::IDD, pParent)
{
	//{{AFX_DATA_INIT(CWallisParam)
	m_a = 0.1;
	m_mean = 128;
	m_sigam = 85;
	m_A = 6;
	//}}AFX_DATA_INIT
	m_pDoc = _pDoc;
}


void CWallisParam::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CWallisParam)
	DDX_Text(pDX, IDC_EDIT1, m_a);
	DDV_MinMaxDouble(pDX, m_a, 0., 1.);
	DDX_Text(pDX, IDC_EDIT2, m_mean);
	DDV_MinMaxInt(pDX, m_mean, 0, 255);
	DDX_Text(pDX, IDC_EDIT3, m_sigam);
	DDV_MinMaxInt(pDX, m_sigam, 0, 255);
	DDX_Text(pDX, IDC_EDIT4, m_A);
	DDV_MinMaxInt(pDX, m_A, 0, 10);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CWallisParam, CDialog)
	//{{AFX_MSG_MAP(CWallisParam)
	ON_BN_CLICKED(IDC_APPLY, OnApply)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWallisParam message handlers

void CWallisParam::OnApply() 
{
	UpdateData(TRUE);
	m_pDoc->Image.ImgSwap();
	m_pDoc->Image.BackUp();
	m_pView = m_pDoc->m_pView;
	if(m_pView!=NULL&&m_pView->DashRectDrawed)
	{
		CPoint p1=m_pView->SelectLTPt,  p2=m_pView->SelectRBPt;
		m_pView->CheckRect(p1,  p2);
		m_pDoc->Image.Wallis2(p1,  p2 ,
			                 m_a, m_mean, m_sigam, m_A);
	}
	else
	{
		m_pDoc->Image.Wallis2(m_a, m_mean, m_sigam, m_A);
	}
	m_pView->Invalidate(FALSE);
}


void CWallisParam::OnOK() 
{
	// TODO: Add extra validation here
	OnApply();
	CDialog::OnOK();
}
/////////////////////////////////////////////////////////////////////////////
// CEhanceLinearDlg dialog


CEhanceLinearDlg::CEhanceLinearDlg(CImageLABDoc *_pDoc,CWnd* pParent /*=NULL*/)
	: CDialog(CEhanceLinearDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CEhanceLinearDlg)
	m_OutMaxGray = 255;
	m_OutMinGray = 0;
	//}}AFX_DATA_INIT
	m_pDoc = _pDoc;
}


void CEhanceLinearDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CEhanceLinearDlg)
	DDX_Control(pDX, IDC_SPIN2, m_Spin2);
	DDX_Control(pDX, IDC_SPIN1, m_Spin1);
	DDX_Text(pDX, IDC_OUTMAXGRAY, m_OutMaxGray);
	DDX_Text(pDX, IDC_OUTMINGRAY, m_OutMinGray);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CEhanceLinearDlg, CDialog)
	//{{AFX_MSG_MAP(CEhanceLinearDlg)
	ON_BN_CLICKED(IDC_APPLY, OnApply)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CEhanceLinearDlg message handlers

void CEhanceLinearDlg::OnApply() 
{
	UpdateData(TRUE);
	m_pDoc->Image.ImgSwap();
	m_pDoc->Image.BackUp();
	m_pView = m_pDoc->m_pView;
	if(m_pView!=NULL&&m_pView->DashRectDrawed)
	{
		CPoint p1, p2;
		m_pView->GetSelectArea(p1, p2);
		m_pDoc->Image.EnhaceLinear(p1,  p2 ,  m_OutMinGray,  m_OutMaxGray);
	}
	else
	{
		m_pDoc->Image.EnhaceLinear(m_OutMinGray, m_OutMaxGray);
	}
	m_pView->Invalidate(FALSE);	
}

void CEhanceLinearDlg::OnOK() 
{
	OnApply();
	CDialog::OnOK();
}

BOOL CEhanceLinearDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	m_Spin1.SetRange(-500, 500);
	m_Spin2.SetRange(-500, 500);
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}
/////////////////////////////////////////////////////////////////////////////
// CLineGrayInfoDlg dialog
CLineGrayInfoDlg::CLineGrayInfoDlg(CImageLABDoc *_pDoc,CPoint _p1,CPoint _p2, CWnd* pParent /*=NULL*/)
	: CDialog(CLineGrayInfoDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CLineGrayInfoDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	m_pDoc = _pDoc;
	p1 = _p1;
	p2 = _p2;
	Height = 128;
	LineGray = LineRed = LineGreen = LineBlue = NULL;
}

void CLineGrayInfoDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CLineGrayInfoDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CLineGrayInfoDlg, CDialog)
	//{{AFX_MSG_MAP(CLineGrayInfoDlg)
	ON_WM_PAINT()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLineGrayInfoDlg message handlers

BOOL CLineGrayInfoDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	PtNum = max(abs(p1.x-p2.x), abs(p1.y-p2.y)) + 1;
	if(PtNum>1)
	{
		BOOL   IsHorizontal; 
		double dx,dy;