www.pudn.com > 医学图像处理示例源代码.rar > RightBar.cpp

// RightBar.cpp : implementation file 
 
#include "stdafx.h" 
#include "ImageLAB.h" 
#include "RightBar.h" 
#include "AllImage.h" 
#include "ImageLABDoc.h" 
#include "ImageLABView.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
extern double *ShowScaleType; 
 
#define RangeBright		255 
#define MidBright		127 
#define RangeContrast   50 
#define OverRange       50 
///////////////////////////////////////////////////////////////////////////// 
// CRightBar dialog 
 
CRightBar::CRightBar(CWnd* pParent /*=NULL*/) 
{ 
	//{{AFX_DATA_INIT(CRightBar) 
	m_Bright = 0; 
	m_Contrast = 0; 
	//}}AFX_DATA_INIT 
	bTempDCCreate = IsOpenImage = bTempBMPCreate = false; 
	IsImageFillStatic = IsButtonReset = false; 
	CursorInRedRect = CursorInImage = CursorGrab = LButtonDown = false; 
	RedPen.CreatePen(PS_SOLID, 2, RGB(255, 0, 0)); 
} 
 
BEGIN_MESSAGE_MAP(CRightBar, CDialogBar) 
	//{{AFX_MSG_MAP(CRightBar) 
	ON_WM_PAINT() 
	ON_WM_MOUSEMOVE() 
	ON_WM_LBUTTONDOWN() 
	ON_WM_LBUTTONUP() 
	ON_WM_SETCURSOR() 
	ON_MESSAGE(WM_INITDIALOG, HandleInitDialog) 
	ON_WM_HSCROLL() 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CRightBar message handlers 
void CRightBar::DrawMiniImage() 
{ 
	if(!IsWindowVisible() )  
	{ 
		TRACE("The window is not visible , so I return !!!\n"); 
		return; 
	} 
	slider_B = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_BRIGHTNESS); 
	slider_C = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_CONTRAST); 
 
    CFrameWnd* pFrameWnd = STATIC_DOWNCAST(CFrameWnd, AfxGetMainWnd()); 
	CImageLABView* pView = (CImageLABView*)pFrameWnd->GetActiveFrame()->GetActiveView(); 
	CStatic* pic = (CStatic*)GetDlgItem(IDC_MINIIMAGE); 
	CClientDC dc(pic); 
	pic->GetClientRect(&rect); 
	 
	if( pView != NULL ) 
	{ 
		CImageLABDoc *m_pDoc = pView->GetDocument(); 
		IsOpenImage = true; 
		if( m_pDoc != NULL && m_pDoc->Image.m_lpDibArray != NULL ) 
		{ 
			imgW = (int)m_pDoc->Image.m_ImageWidth; 
			imgH = (int)m_pDoc->Image.m_ImageHeight;			 
			BigImage = (imgW > 800) || (imgH > 800); 
 
			int ShowW = rect.Width()  - 8; 
			int ShowH = rect.Height() - 8; 
			int CenterPicx = rect.Width()/ 2; 
			int CenterPicy = rect.Height()/ 2; 
			float w = (float)imgW; 
            float h = (float)imgH; 
            float ratio1 = w/ h; 
			float ratio2 = (float)ShowW/ (float)ShowH; 
			if( ratio1 > ratio2 ) 
			{ 
				h = h * ShowW / w; 
				w = (float)ShowW; 
			} 
			else 
			{				 
				w = w * ShowH / h; 
				h = (float)ShowH; 
			} 
			//获得导游图像再 pic 控件上的位置(按比例计算得到) 
			ImageRect.left   = CenterPicx - int(w/2); 
			ImageRect.right  = CenterPicx + int(w/2); 
			ImageRect.top    = CenterPicy - int(h/2); 
            ImageRect.bottom = CenterPicy + int(h/2);			 
			 
			if(BigImage && m_pDoc->Image.m_wImageDepth>=8 ) //如果图像较大的话,则建立小的微缩图像写入pic 控件DC中 
			{ 
				if((m_pDoc->SmallImage.m_lpDibArray == NULL) || (OldBigFileName!=m_pDoc->ImageFileName)) 
				{ 
					m_pDoc->SmallImage.CreateMicroImg(m_pDoc->Image, ImageRect.Width() ,ImageRect.Height()); 
					m_pDoc->SmallImage.ShowCurrentImage(&dc, ImageRect); 
					OldBigFileName = m_pDoc->ImageFileName; 
				} 
				m_pDoc->SmallImage.ShowCurrentImage(&dc, ImageRect); 
			} 
			else        //否则将原图像写入pic 控件DC中 
			{ 
				m_pDoc->Image.ShowCurrentImage(&dc, ImageRect);				 
			} 
			 
			if(!bTempDCCreate) //建立临时的DC 
			{ 
				tempDC.CreateCompatibleDC(&dc); 
				tempDC.SetStretchBltMode(COLORONCOLOR);  
				bTempDCCreate = true;						 
			} 
			if(!bTempBMPCreate) //建立临时的BMP 
			{ 
				bitmap.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height()); 
			    pOldbmp = tempDC.SelectObject(&bitmap);	 
				bTempBMPCreate = true; 
			} 
			//将pic 控件DC的内容写入临时的DC中 
			tempDC.StretchBlt(0, 0, ImageRect.Width()+1, ImageRect.Height()+1, 
			                  &dc,   
							  ImageRect.left, ImageRect.top, ImageRect.Width()+1, ImageRect.Height()+1,  
							  SRCCOPY); 
			//bitmap.DeleteObject(); 
 
			pView->GetClientRect(&rect);			 
			TVS = pView->ScrollSize; 
			if(rect.Height()==TVS.cy&&rect.Width()>TVS.cx) rect.right = rect.left + TVS.cx; 
			CPoint VSPt = pView->ScrollOrgPt; 
			int iRedRectWidth  = int((float)rect.Width()/ (float)TVS.cx* ImageRect.Width()); 
			int iRedRectheight = int((float)rect.Height()/ (float)TVS.cy* ImageRect.Height()); 
			RedRect.left   = int((float)VSPt.x/ (float)TVS.cx* ImageRect.Width() ) + ImageRect.left+1;   
			RedRect.top    = int((float)VSPt.y/ (float)TVS.cy* ImageRect.Height() ) + ImageRect.top+1; 
			RedRect.right  = RedRect.left + iRedRectWidth-1; 
			RedRect.bottom = RedRect.top + iRedRectheight-1; 
			if(RedRect.Width()<4)  
			{ 
				RedRect.right += 4; 
				if(RedRect.right > ImageRect.right)  
				{ 
					RedRect.right = ImageRect.right; 
					RedRect.left  = RedRect.right - 4;  
				} 
				 
			} 
			if(RedRect.Height()<4)  
			{ 
				RedRect.bottom += 4; 
				if(RedRect.bottom > ImageRect.bottom)  
				{ 
					RedRect.bottom = ImageRect.bottom; 
					RedRect.top    = RedRect.top - 4;  
				} 
			} 
			IsImageFillStatic = abs(ImageRect.Width()-RedRect.Width())<3 && 
								abs(ImageRect.Height()-RedRect.Height())<3; 
			//绘制红色方框		 
			pOldPen = dc.SelectObject(&RedPen); 
			dc.SetROP2(R2_COPYPEN); 
			dc.SelectStockObject(NULL_BRUSH); 
			dc.Rectangle(RedRect);			 
			dc.SelectObject(pOldPen); 
 
			CPoint p1(0,0),p2(0,0); 
			ClientToScreen (&p1); 
			pic->ClientToScreen (&p2); 
			ImageOffset.cx= p2.x - p1.x; 
			ImageOffset.cy= p2.y - p1.y; 
			RedRect.OffsetRect(ImageOffset); 
			ImageRect.OffsetRect(ImageOffset); 
			rect.OffsetRect(ImageOffset); 
		} 
	 
		if( !pView->bFreeze ) 
		{ 
			slider_C->EnableWindow(false); 
			slider_B->EnableWindow(false); 
			IsButtonReset = false; 
		} 
		else 
		{ 
			if( !slider_C->IsWindowEnabled() ) 
			{ 
				slider_C->EnableWindow(true); 
				IsButtonReset = true; 
			} 
			if( m_pDoc->Image.m_Contrast < 0 ) 
			{ 
				slider_C->SetPos(RangeContrast); 
			} 
			else 
			{ 
				slider_C->SetPos(m_pDoc->Image.m_Contrast); 
			} 
 
			if( !slider_B->IsWindowEnabled() ) 
			{ 
				slider_B->EnableWindow(true); 
			} 
			if( m_pDoc->Image.m_Bright < 0 ) 
			{ 
				slider_B->SetPos(MidBright); 
			} 
			else 
			{ 
				slider_B->SetPos(m_pDoc->Image.m_Bright); 
			} 
		} 
	} 
	else 
	{ 
		IsOpenImage = false; 
		dc.SetBkMode(TRANSPARENT); 
		dc.SetTextColor(RGB(255,0,0)); 
		rect.top +=30;  
		dc.DrawText("湖南华美安全设备公司\n胶片管理系统", rect, DT_CENTER); 
		slider_C->EnableWindow(false); 
		slider_B->EnableWindow(false); 
		IsButtonReset = false; 
	} 
} 
 
void CRightBar::OnPaint()  
{ 
	CPaintDC dc(this); // device context for painting	 
	DrawMiniImage(); 
} 
 
void CRightBar::OnLButtonDown(UINT nFlags, CPoint point)  
{	 
	LButtonDown = true; 
	if(IsOpenImage && rect.PtInRect(point)) 
	{  
		if(RedRect.PtInRect(point)) 
		{ 
			CursorInRedRect = true; 
			StartPt = point; 
			SetCursor(AfxGetApp()->LoadCursor(IDC_HANDGRABED)); 
		} 
		else 
		{ 
			CursorInRedRect = false;  
			if(ImageRect.PtInRect(point)) 
			{ 
				CursorInImage = true; 
				SetCursor( AfxGetApp()->LoadCursor(IDC_HANDPOINT)); 
			} 
			else 
			{ 
				CursorInImage = false; 
			} 
		} 
 
		if(CursorInImage&&!CursorInRedRect) 
		{ 
			int dx = point.x - (RedRect.left + RedRect.right)/2; 
			int dy = point.y - (RedRect.top + RedRect.bottom)/2; 
			RedRect.OffsetRect(dx, dy); 
			if(!IsImageFillStatic) 
				DrawRedRect(RedRect); 
		} 
	} 
	else 
		CDialogBar::OnLButtonDown(nFlags, point); 
} 
 
void CRightBar::OnLButtonUp(UINT nFlags, CPoint point)  
{ 
	LButtonDown = false; 
	if(IsOpenImage && rect.PtInRect(point)) 
	{  
		if(RedRect.PtInRect(point)) 
		{ 
			CursorInRedRect = true; 
			::SetCursor( ((CImageLABApp *)AfxGetApp())->LoadCursor(IDC_HANDWANTGRAB)); 
		} 
	} 
	CDialogBar::OnLButtonUp(nFlags, point);	 
} 
 
void CRightBar::OnMouseMove(UINT nFlags, CPoint point)  
{ 
	if(IsOpenImage && rect.PtInRect(point)) 
	{  
		CursorInRedRect = RedRect.PtInRect(point); 
		CursorInImage   = ImageRect.PtInRect(point);	 
		 
		if(CursorInRedRect&&LButtonDown)// 开始拖动红框 
		{ 
			int dx = point.x - StartPt.x; 
			int dy = point.y - StartPt.y; 
 
			RedRect.OffsetRect(dx, dy); 
			if(!IsImageFillStatic) 
			{ 
				DrawRedRect(RedRect); 
			} 
			StartPt = point; 
		} 
	} 
	else 
	{ 
		CDialogBar::OnMouseMove(nFlags, point); 
	} 
} 
 
void CRightBar::PostNcDestroy()  
{ 
	if(bTempDCCreate && bTempBMPCreate) 
	{ 
		tempDC.SelectObject(pOldbmp); 
		tempDC.DeleteDC(); 
		bTempDCCreate = false; 
		bTempBMPCreate = false; 
	} 
	CDialogBar::PostNcDestroy(); 
} 
 
BOOL CRightBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)  
{ 
	if(nHitTest == HTCLIENT && IsOpenImage) 
	{		  
		if(CursorInImage) 
		{ 
			if(CursorInRedRect) 
			{ 
			 if(LButtonDown)  
				 SetCursor( AfxGetApp()->LoadCursor(IDC_HANDGRABED)); 
			 else 
				 SetCursor( AfxGetApp()->LoadCursor(IDC_HANDWANTGRAB));	 
			 return true; 
			} 
			SetCursor( AfxGetApp()->LoadCursor(IDC_HANDPOINT)); 
			return true; 
		} 
		switch(pWnd->GetDlgCtrlID()) 
		{ 
		case  IDC_SLIDER_BRIGHTNESS: 
		case  IDC_SLIDER_CONTRAST: 
			SetCursor( AfxGetApp()->LoadCursor(IDC_HANDWANTGRAB)); 
			return TRUE; 
		}			 
	} 
	return CDialogBar::OnSetCursor(pWnd, nHitTest, message); 
} 
 
void CRightBar::DrawRedRect(CRect RedRect) 
{ 
	int dx, dy; 
	if(RedRect.leftImageRect.right) 
	{    
		dx = ImageRect.right - RedRect.right; 
		RedRect.OffsetRect(dx, 0); 
	} 
 
	if(RedRect.topImageRect.bottom) 
	{ 
		dy = ImageRect.bottom - RedRect.bottom; 
		RedRect.OffsetRect(0, dy); 
	} 
 
	CClientDC dc(this); 
	dc.StretchBlt(ImageRect.left, ImageRect.top, ImageRect.Width()+1, ImageRect.Height()+1, 
			      &tempDC, 
				  0, 0,	 ImageRect.Width()+1, ImageRect.Height()+1,  
				  SRCCOPY); 
 
	pOldPen = dc.SelectObject(&RedPen); 
	dc.SetROP2(R2_COPYPEN); 
	dc.SelectStockObject(NULL_BRUSH); 
	dc.Rectangle(RedRect); 
	dc.SelectObject(pOldPen); 
 
	CPoint SCT; 
	SCT.x = int( (float)(RedRect.left - ImageRect.left-1) /(float)ImageRect.Width()*TVS.cx+0.5 ); 
	SCT.y = int( (float)(RedRect.top - ImageRect.top-1) /(float)ImageRect.Height()*TVS.cy+0.5 ); 
 
	CFrameWnd* pFrameWnd = STATIC_DOWNCAST(CFrameWnd, AfxGetMainWnd()); 
	CImageLABView* pView = (CImageLABView*)pFrameWnd->GetActiveFrame()->GetActiveView(); 
	 
	if(pView->fShowScale > 1) 
	{ 
		int ImageSclae = int(pView->fShowScale); 
		SCT.x = (SCT.x+ ImageSclae- 1)/ImageSclae*ImageSclae; 
		SCT.y = (SCT.y+ ImageSclae- 1)/ImageSclae*ImageSclae; 
	} 
 
    if(pView->IsKindOf(RUNTIME_CLASS(CImageLABView))) 
	{ 
		pView->ScrollToPosition(SCT); 
		pView->ScrollOrgPt = SCT; 
	} 
} 
LRESULT CRightBar::HandleInitDialog(WPARAM wparam, LPARAM lparam) 
{ 
	slider_B = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_BRIGHTNESS); 
	slider_C = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_CONTRAST); 
 
	m_Bright   = MidBright; 
	m_Contrast = RangeContrast; 
 
	slider_B->SetRange(0, RangeBright); 
	slider_B->SetPos(m_Bright); 
	slider_B->SetTic(0); 
	slider_B->SetTic(25); 
	slider_B->SetTic(50); 
	slider_B->SetTic(75); 
	slider_B->SetTic(100); 
	slider_B->SetTic(125); 
	slider_B->SetTic(151); 
	slider_B->SetTic(177); 
	slider_B->SetTic(203); 
	slider_B->SetTic(229); 
	slider_B->SetTic(255); 
 
	slider_C->SetRange(0, RangeContrast+ RangeContrast); 
	slider_C->SetPos(RangeContrast); 
	slider_C->SetTic(0); 
	slider_C->SetTic(13); 
	slider_C->SetTic(25); 
	slider_C->SetTic(38); 
	slider_C->SetTic(50); 
	slider_C->SetTic(63); 
	slider_C->SetTic(75); 
	slider_C->SetTic(88); 
	slider_C->SetTic(102); 
	slider_C->SetTic(114); 
	slider_C->SetTic(127); 
 
	lpClip = Clip + 200; 
	memset(Clip, 255, 800); 
	for(int i= 0; i< 200; i++) 
	{ 
		Clip[i] = 0;		 
	} 
	for(i= 0; i< 256; i++) 
	{ 
		lpClip[i] = BYTE(i);		 
	} 
 
	return TRUE; 
} 
 
void CRightBar::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)  
{ 
	CSliderCtrl* pSlider = (CSliderCtrl*)pScrollBar; 
	slider_B = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_BRIGHTNESS); 
	slider_C = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_CONTRAST); 
 
	CFrameWnd* pFrameWnd = STATIC_DOWNCAST(CFrameWnd, AfxGetMainWnd()); 
	CImageLABView* pView = (CImageLABView*)pFrameWnd->GetActiveFrame()->GetActiveView(); 
	 
	if( pView == NULL ) return; 
	 
	CImageLABDoc *m_pDoc = pView->GetDocument(); 
	if( m_pDoc == NULL || m_pDoc->Image.m_lpDibArray == NULL ) return; 
 
	int ImageSize = m_pDoc->Image.m_ImageSize; 
	BYTE *lpImageStart, *lpImageEnd, *lpImageBakup; 
	if( m_pDoc->Image.m_lpDibArrayBuff == NULL )  
		m_pDoc->Image.BackUp(); 
 
 
	if(pSlider == slider_B) 
	{ 
		lpImageStart = m_pDoc->Image.m_lpDibArray; 
		lpImageEnd   = m_pDoc->Image.m_lpDibArray + ImageSize; 
		lpImageBakup = m_pDoc->Image.m_lpDibArrayBuff; 
 
		m_Bright = pSlider->GetPos(); 
		m_pDoc->Image.m_Bright = m_Bright; 
		m_AddB	 = m_Bright - MidBright; 
		for(BYTE* NowPixel= lpImageStart; NowPixel< lpImageEnd; NowPixel++, lpImageBakup++) 
			*NowPixel = *(lpClip + *lpImageBakup + m_AddB); 
		pView->Invalidate(false); 
	} 
	else if(pSlider == slider_C) 
	{ 
		lpImageStart = m_pDoc->Image.m_lpDibArrayBuff; 
		lpImageEnd   = m_pDoc->Image.m_lpDibArrayBuff + ImageSize; 
 
		m_Contrast = pSlider->GetPos(); 
		m_pDoc->Image.m_Contrast = m_Bright; 
		m_AddB	   = m_Contrast - RangeContrast; 
		int max_r = *lpImageStart++; 
		int min_r = max_r;				 
 
		for(BYTE* NowPixel= lpImageStart; NowPixel< lpImageEnd; NowPixel++) 
		{ 
			if ( *NowPixel > max_r ) 
			   max_r = *NowPixel; 
			else if ( *NowPixel < min_r ) 
			   min_r = *NowPixel; 
		} 
		int GrayRange = max_r - min_r;		 
		if( GrayRange == 0 ) return; 
 
		double a, b, fTemp; 
		if( m_AddB > 0 ) 
		{ 
			a = min_r - (double)(min_r + OverRange)* m_AddB/ OverRange; 
			b = (double)(255 + OverRange - max_r)* m_AddB/ OverRange + max_r; 
		} 
		else 
		{ 
			int mid = GrayRange / 2; 
			a = min_r -  (double) mid* m_AddB/ (double)OverRange; 
			b = max_r +  (double) mid* m_AddB/ (double)OverRange; 
			if( fabs(b-a)< 2 ) 
			{ 
				a -= 1;  
				b += 1; 
			} 
		} 
 
		double  ratio = (double)(b- a)/(double)(max_r - min_r); 
		// -----建立查找表----- 
		BYTE LUT[256]; 
		for(int i= min_r; i<256; i++) 
		{ 
			fTemp  = (i- min_r)* ratio + a + 0.5; 
			if( fTemp < 0 ) 
				LUT[i] = 0; 
			else if( fTemp < 255 ) 
				LUT[i] = BYTE( fTemp ); 
			else 
				LUT[i] = 255; 
		} 
		// -----进行线性变换----- 
		lpImageStart = m_pDoc->Image.m_lpDibArray; 
		lpImageEnd   = m_pDoc->Image.m_lpDibArray + ImageSize; 
		lpImageBakup = m_pDoc->Image.m_lpDibArrayBuff; 
		for(NowPixel= lpImageStart; NowPixel< lpImageEnd; NowPixel++, lpImageBakup++) 
		{ 
			*NowPixel = LUT[ *lpImageBakup ];  
		} 
		pView->Invalidate(false); 
	} 
	CDialogBar::OnHScroll(nSBCode, nPos, pScrollBar); 
} 
 
void CRightBar::ButtonReset()  
{ 
	slider_B = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_BRIGHTNESS); 
	slider_C = (CSliderCtrl *)GetDlgItem(IDC_SLIDER_CONTRAST); 
	if( !slider_B->IsWindowEnabled() ) return; 
 
	CFrameWnd* pFrameWnd = STATIC_DOWNCAST(CFrameWnd, AfxGetMainWnd()); 
	CImageLABView* pView = (CImageLABView*)pFrameWnd->GetActiveFrame()->GetActiveView(); 
	 
	if( pView == NULL ) return; 
	 
	CImageLABDoc *m_pDoc = pView->GetDocument(); 
	if( m_pDoc == NULL || m_pDoc->Image.m_lpDibArray == NULL ) return; 
 
	int ImageSize = m_pDoc->Image.m_ImageSize; 
 
	m_Bright   = MidBright; 
	m_Contrast = RangeContrast; 
	slider_B->SetPos(m_Bright); 
	slider_C->SetPos(m_Contrast); 
 
	m_pDoc->Image.m_Contrast = -1; 
	m_pDoc->Image.m_Bright   = -1; 
	m_pDoc->Image.ImgSwap(); 
	m_pDoc->Image.BackUp(); 
	pView->Invalidate(false);	 
}