imagepview.cpp

这是VC++ 2003.net图像处理的光盘源程序!!!非常好的

// ImagePView.cpp : implementation of the CImagePView class
//

#include "stdafx.h"
#include "ImageP.h"

#include "ImagePDoc.h"
#include "ImagePView.h"
#include ".\ImagePview.h"

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

/////////////////////////////////////////////////////////////////////////////
// CImagePView

IMPLEMENT_DYNCREATE(CImagePView, CView)

BEGIN_MESSAGE_MAP(CImagePView, CView)
	//{{AFX_MSG_MAP(CImagePView)
	ON_WM_PAINT()
	ON_COMMAND(ID_256COLOR_IMAGE_EXAM, On256colorImageExam)
	ON_COMMAND(ID_TRUECOLOR_IMAGE_EXAM, OnTrueColorImageExam)
	ON_COMMAND(ID_REFRESH, OnRefresh)

	ON_COMMAND(ID_GRAY_PALETTE, OnGrayPalette)
	ON_COMMAND(ID_BLUE_PALETTE, OnBluePalette)
	ON_COMMAND(ID_DEFAULT_PALETTE, OnDefaultPalette)
 	ON_COMMAND(ID_RESTORE_PALETTE, OnRestorePalette)
	ON_COMMAND(ID_MOV_PALETTE, OnMovPalette)

	ON_COMMAND(ID_IMAGE_PALETTE, OnImagePalette)
	ON_COMMAND(ID_PASTE_REFRESH, OnPasteRefresh)
	ON_COMMAND(ID_CONSERVATION_IMAGE, OnConservationImage)
	ON_COMMAND(ID_CLOSE_IMAGE, OnCloseImage)
 	ON_COMMAND(ID_CLEAR_WINDOW, OnClearWindow)
	ON_COMMAND(ID_DRAW_REFRESH, OnDrawRefresh)
 	ON_COMMAND(ID_SELECT_IMAGE, OnSelectImage)
	ON_COMMAND(ID_SELECT_WINDOW, OnSelectWindow)
	ON_COMMAND(ID_IMAGE_PARAMENT, OnImageParament)

 	ON_COMMAND(ID_DRAW_PIXEL, OnDrawPixel)
  	ON_COMMAND(ID_DRAW_TEXT, OnDrawText)
	ON_COMMAND(ID_GRAPH_FILL, OnGraphFill)
	ON_COMMAND(ID_COPY_BITMAP, OnCopyBitmap)
	ON_COMMAND(ID_RAND_CIRCLE, OnRandCircle)

	ON_UPDATE_COMMAND_UI(ID_REFRESH, OnUpdateRefresh)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_PALETTE, OnUpdateImagePalette)
	ON_UPDATE_COMMAND_UI(ID_GRAY_PALETTE, OnUpdateGrayPalette)
	ON_UPDATE_COMMAND_UI(ID_BLUE_PALETTE, OnUpdateBluePalette)
 	ON_UPDATE_COMMAND_UI(ID_RESTORE_PALETTE, OnUpdateRestorePalette)
	ON_UPDATE_COMMAND_UI(ID_MOV_PALETTE, OnUpdateMovPalette)
	ON_UPDATE_COMMAND_UI(ID_PASTE_REFRESH, OnUpdatePasteRefresh)
 	ON_UPDATE_COMMAND_UI(ID_CONSERVATION_IMAGE, OnUpdateConservationImage)
	ON_UPDATE_COMMAND_UI(ID_CLOSE_IMAGE, OnUpdateCloseImage)
	ON_UPDATE_COMMAND_UI(ID_DRAW_REFRESH, OnUpdateDrawRefresh)
 	ON_UPDATE_COMMAND_UI(ID_SELECT_IMAGE, OnUpdateSelectImage)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_PARAMENT, OnUpdateImageParament)
 	ON_WM_TIMER()

	ON_COMMAND(ID_GRAY_IMAGE, OnColorToGray)
 	ON_COMMAND(ID_INDEX_IMAGE, OnIndexImage)
	ON_COMMAND(ID_IMAGE_INVERT, OnImageInvert)
	ON_COMMAND(ID_IMAGE_MONOCHROM, OnColorToMonochrom)
	ON_UPDATE_COMMAND_UI(ID_GRAY_IMAGE, OnUpdateColorToGray)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_INVERT, OnUpdateImageInvert)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_MONOCHROM, OnUpdateColorToMonochrom)
 	ON_UPDATE_COMMAND_UI(ID_INDEX_IMAGE, OnUpdateIndexImage)

	ON_COMMAND(ID_FLIP_HORIZON, OnFlipHorizon)
	ON_COMMAND(ID_FLIP_VERT, OnFlipVert)
	ON_COMMAND(ID_ROTATE_90, OnRotate90)
	ON_COMMAND(ID_ROTATE_180, OnRotate180)
	ON_COMMAND(ID_ROTATE_270, OnRotate270)
	ON_COMMAND(ID_ZOOM_IN, OnZoomIn)
	ON_COMMAND(ID_ZOOM_OUT, OnZoomOut)
	ON_COMMAND(ID_IMAGE_MASAIC, OnImageMasaic)
	ON_COMMAND(ID_IMAGE_ROTATE, OnImageRotate)
	ON_COMMAND(ID_IMAGE_SCALE, OnImageScale)
	ON_UPDATE_COMMAND_UI(ID_FLIP_HORIZON, OnUpdateFlipHorizon)
	ON_UPDATE_COMMAND_UI(ID_FLIP_VERT, OnUpdateFlipVert)
	ON_UPDATE_COMMAND_UI(ID_ROTATE_90, OnUpdateRotate90)
	ON_UPDATE_COMMAND_UI(ID_ROTATE_180, OnUpdateRotate180)
	ON_UPDATE_COMMAND_UI(ID_ROTATE_270, OnUpdateRotate270)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_IN, OnUpdateZoomIn)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_OUT, OnUpdateZoomOut)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_MASAIC, OnUpdateImageMasaic)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_ROTATE, OnUpdateImageRotate)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_SCALE, OnUpdateImageScale)

	ON_COMMAND(ID_AREA_SELECT, OnAreaSelect)
	ON_COMMAND(ID_AREA_CUT, OnAreaCut)
	ON_COMMAND(ID_BITMAP_COPY, OnBitmapCopy)
	ON_COMMAND(ID_AREA_WANDER, OnAreaWander)
	ON_COMMAND(ID_AREA_MOVE, OnAreaMove)
	ON_COMMAND(ID_PIXEL_VALUE, OnPixelValue)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_UPDATE_COMMAND_UI(ID_AREA_SELECT, OnUpdateAreaSelect)
	ON_UPDATE_COMMAND_UI(ID_AREA_CUT, OnUpdateAreaCut)
	ON_UPDATE_COMMAND_UI(ID_BITMAP_COPY, OnUpdateBitmapCopy)
 	ON_UPDATE_COMMAND_UI(ID_AREA_WANDER, OnUpdateAreaWander)
	ON_UPDATE_COMMAND_UI(ID_AREA_MOVE, OnUpdateAreaMove)
	ON_UPDATE_COMMAND_UI(ID_PIXEL_VALUE, OnUpdatePixelValue)

	ON_COMMAND(ID_AREA_COPY, OnAreaCopy)
	ON_COMMAND(ID_AREA_PASTE, OnAreaPaste)
	ON_UPDATE_COMMAND_UI(ID_AREA_COPY, OnUpdateAreaCopy)
	ON_UPDATE_COMMAND_UI(ID_AREA_PASTE, OnUpdateAreaPaste)

	ON_COMMAND(ID_HATCH_FILL, OnHatchFill)
	ON_COMMAND(ID_DRAW_LINE, OnDrawLine)
	ON_COMMAND(ID_PATTERN_FILL, OnPatternFill)

//}}AFX_MSG_MAP
// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CImagePView construction/destruction

extern CImage	SaveCanvus,WorkCanvus,img2,img3,img4,img5,img6,img7,img8,WindowCanvus;
extern CImage*	pImg[10];
extern CString	m_FileName;
extern int		m_nFArea;

CImagePView::CImagePView()
{
	// TODO: add construction code here
  	m_nGraphicFlag=0;
	m_nFlag=0;
 	m_fAlpha=30*PI/180;
	m_fTheta=1.3;
}

CImagePView::~CImagePView()
{
}

BOOL CImagePView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CImagePView drawing

void CImagePView::OnDraw(CDC* pDC)
{
	CImagePDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here

	if (SaveCanvus.IsNull()) return;
	OnClearWindow();                             
  	WriteTitle(pImg[1],m_FileName,"");           
   	WorkCanvusToWindow();                      
 	m_nSize=1;
	m_nFlag=0;
	m_nFArea=0;
}

/////////////////////////////////////////////////////////////////////////////
// CImagePView printing

BOOL CImagePView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CImagePView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CImagePView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CImagePView diagnostics

#ifdef _DEBUG
void CImagePView::AssertValid() const
{
	CView::AssertValid();
}

void CImagePView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CImagePDoc* CImagePView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CImagePDoc)));
	return (CImagePDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CImagePView message handlers

void CImagePView::OnUpdateRefresh(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateImagePalette(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(WorkCanvus.GetBPP()<=8));
}

void CImagePView::OnUpdateGrayPalette(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(WorkCanvus.GetBPP()==8));
}

void CImagePView::OnUpdateBluePalette(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(WorkCanvus.GetBPP()==8));
}

void CImagePView::OnUpdateRestorePalette(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(WorkCanvus.GetBPP()==8));
}

void CImagePView::OnUpdateMovPalette(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(WorkCanvus.GetBPP()==8));
}

void CImagePView::OnUpdatePasteRefresh(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateConservationImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateCloseImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateDrawRefresh(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateSelectImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateImageParament(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateColorToGray(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(ImageType(pImg[0]))>2);
}

void CImagePView::OnUpdateImageInvert(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateColorToMonochrom(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(ImageType(pImg[0]))>2);
}

void CImagePView::OnUpdateFlipHorizon(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateFlipVert(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateRotate90(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateRotate180(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateRotate270(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateZoomIn(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateZoomOut(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateImageRotate(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateImageScale(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateImageMasaic(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateBinaryImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdate16colorImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

void CImagePView::OnUpdateIndexImage(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(ImageType(pImg[0]))<2);
}

void CImagePView::OnUpdateAreaSelect(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(SaveCanvus.GetBPP()>4));
}

void CImagePView::OnUpdateAreaCopy(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdateAreaCut(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!SaveCanvus.IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdateBitmapCopy(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!pImg[3]->IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdateAreaPaste(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!pImg[3]->IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdateAreaWander(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!pImg[3]->IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdateAreaMove(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable((!pImg[3]->IsNull())&&(m_nFArea));
}

void CImagePView::OnUpdatePixelValue(CCmdUI *pCmdUI)
{
 	pCmdUI->Enable(!SaveCanvus.IsNull());
}

//----------------------------------------------------

void DrawPixelOnCanvus(CDC *pDC,int x1,int y1)
{
 	for(int y=y1;y<130+y1;y++)
		for(int x=x1;x<1022;x++)
			pDC->SetPixel(x,y,(COLORREF)x*y);
}

void CImagePView::OnDrawPixel()
{
	m_nFlag=0;
	if (m_nGraphicFlag==0) {
  		CWnd*	pMain = AfxGetMainWnd();
 		CDC*	pDC = pMain->GetDC();
		DrawPixelOnCanvus(pDC,2,26);
 		pMain->ReleaseDC(pDC);
	}
	else {
		CDC	*pWorkImgDC= CDC::FromHandle(WorkCanvus.GetDC());
		DrawPixelOnCanvus(pWorkImgDC,0,0);
		WorkCanvus.ReleaseDC();

		WorkCanvusToWindow();
	}
}

void DrawLineOnCanvus(CDC *pDC,int x,int y)
{
	COLORREF  rgbPen=RGB(0,255,0);
	CPen	  penGreen(PS_SOLID,2,rgbPen),
              penBlack(PS_SOLID,2,RGB(0,255,255)),
			  *pOldPen=NULL;
  	int       i,j,n;
 
	n=400;

 	pOldPen=pDC->SelectObject(&penGreen);
	pDC->MoveTo(x,y);
	for (i=0;i<n;i++) {
		j=(int) (50.0*(n-3*i/4)/n*sin(PI*i/(n/15)));
		pDC->LineTo(x+i,y-j);
	}

 	pDC->SelectObject(&penBlack);
	pDC->MoveTo(x-20,y);
	pDC->LineTo(x+n+20,y);

 	pDC->SelectObject(pOldPen);

	penGreen.DeleteObject();
	penBlack.DeleteObject();
}

void CImagePView::OnDrawLine()
{
	m_nFlag=0;
	if (m_nGraphicFlag==0) {
  		CWnd*	pMain = AfxGetMainWnd();
 		CDC*	pDC = pMain->GetDC();
		DrawLineOnCanvus(pDC,2+56,26+65);
 		pMain->ReleaseDC(pDC);
	}
	else {
		CDC	*pWorkImgDC= CDC::FromHandle(WorkCanvus.GetDC());
		DrawLineOnCanvus(pWorkImgDC,56,65);
		WorkCanvus.ReleaseDC();

		WorkCanvusToWindow();
	}
}

void DrawGraphFillOnCanvus(CDC *pDC,int x1,int y1)
{
	int		x,y;
 
	x=35+x1;		y=130+y1;
 
	pDC->SelectStockObject(BLACK_PEN);
	pDC->SelectStockObject(HOLLOW_BRUSH);
 
	pDC->Rectangle(x,y+50,x+50,y+100);
	pDC->RoundRect(x,y+150,x+50,y+200,15,15);
	pDC->Ellipse(x+75,y+50,x+125,y+100);
	pDC->Chord(x+75,y+150,x+125,y+200,x+75,y+150,x+125,y+200);
	pDC->Pie(x+150,y+50,x+200,y+100,x+150,y+50,x+200,y+50);

	x=280+x1;
	pDC->SelectStockObject(DKGRAY_BRUSH);
 
	pDC->Rectangle(x,y+50,x+50,y+100);
	pDC->RoundRect(x,y+150,x+50,y+200,15,15);
	pDC->Ellipse(x+75,y+50,x+125,y+100);
	pDC->Chord(x+75,y+150,x+125,y+200,x+75,y+150,x+125,y+200);
	pDC->Pie(x+150,y+50,x+200,y+100,x+150,y+50,x+200,y+50);
}

void CImagePView::OnGraphFill()
{
	m_nFlag=0;
	if (m_nGraphicFlag==0) {
  		CWnd*	pMain = AfxGetMainWnd();
 		CDC*	pDC = pMain->GetDC();
		DrawGraphFillOnCanvus(pDC,2,26);
 		pMain->ReleaseDC(pDC);
	}
	else {
		CDC	*pWorkImgDC= CDC::FromHandle(WorkCanvus.GetDC());
		DrawGraphFillOnCanvus(pWorkImgDC,0,0);
		WorkCanvus.ReleaseDC();

		WorkCanvusToWindow();
	}
}

void DrawHatchFillOnCanvus(CDC *pDC,int x,int y)
{
	CBrush brBrush[6];
	int	   i,k;
  
	pDC->SelectStockObject(BLACK_PEN);
  	brBrush[0].CreateHatchBrush(HS_HORIZONTAL,RGB(0,0,0));
	brBrush[1].CreateHatchBrush(HS_VERTICAL,RGB(255,0,0));
	brBrush[2].CreateHatchBrush(HS_CROSS,RGB(255,0,255));
	brBrush[3].CreateHatchBrush(HS_FDIAGONAL,RGB(0,255,0));
	brBrush[4].CreateHatchBrush(HS_BDIAGONAL,RGB(0,0,255));
	brBrush[5].CreateHatchBrush(HS_DIAGCROSS,RGB(0,255,255));

	k=75;
	for (i=0;i<6;i++) {
		pDC->SelectObject(&brBrush[i]);
		pDC->Rectangle(x+k*i+10,y+10,x+k*(i+1),y+200);
		brBrush[0].DeleteObject();
	}
}

void CImagePView::OnHatchFill()
{
	m_nFlag=0;
	if (m_nGraphicFlag==0) {
  		CWnd*	pMain = AfxGetMainWnd();
 		CDC*	pDC = pMain->GetDC();
		DrawHatchFillOnCanvus(pDC,550,175);
 		pMain->ReleaseDC(pDC);
	}
	else {
		CDC	*pWorkImgDC= CDC::FromHandle(WorkCanvus.GetDC());
		DrawHatchFillOnCanvus(pWorkImgDC,25,70);
		WorkCanvus.ReleaseDC();

		WorkCanvusToWindow();
	}
}

void DrawPatternFillOnCanvus(CDC *pDC,int x,int y)
{
	CBrush	brBrush;
	CBitmap	pBitmap;
	short   lpBits[8]={0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa};
  
   	pBitmap.CreateBitmap(8,8,1,1,lpBits);