基于FreeImage的图片局部放大镜实现

#define ZOOM_DLG_X 0
#define ZOOM_DLG_Y 0
#define ZOOM_DLG_WIDTH  300
#define ZOOM_DLG_HEIGHT 300

#pragma once
#include "FreeImagePlus.h"
#include "DlgMessage.h"


// CDlgImageZoom dialog

class CDlgImageZoom : public CDialogEx
{
 DECLARE_DYNAMIC(CDlgImageZoom)

public:
 CDlgImageZoom(CWnd* pParent = NULL);   // standard constructor
  virtual ~CDlgImageZoom();

// Dialog Data
 enum { IDD = IDD_DLG_IMAGE_ZOOM };

private:
  CString m_szImagePath;
  fipWinImage m_fip;

  CDC* m_pDC;
  CRect m_rect;
  CDC m_memDC;
 CBitmap* m_pOrgBMP;
  CBitmap m_memBitmap;

  int m_imageHeight;
  int m_imageWidth;
 vector<vector<CPoint>> m_pointList;
 CPoint m_center;

public:
 void SetImagePath(CString path);
  void UpdateDraw(CPoint point, BOOL isLeftDown=FALSE, BOOL isLine=FALSE);
  int GetHeight();
  int GetWidth();
 void AddList();
 void EraseLines();

protected:
  virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

  DECLARE_MESSAGE_MAP()

 virtual BOOL OnInitDialog();
  void prepareDraw(BOOL useBack=FALSE);
 void releaseDraw();
 void drawLine(vector<CPoint>& list, CPoint &point);
 void drawCross();
public:
  afx_msg BOOL OnEraseBkgnd(CDC* pDC);
};

// DlgImageZoom.cpp : implementation file
//

#include "stdafx.h"
#include "Coalmine.h"
#include "DlgImageZoom.h"
#include "afxdialogex.h"

// CDlgImageZoom dialog

IMPLEMENT_DYNAMIC(CDlgImageZoom, CDialogEx)

  static bool isDrawing;

CDlgImageZoom::CDlgImageZoom(CWnd* pParent /*=NULL*/)
 : CDialogEx(CDlgImageZoom::IDD, pParent/*, NULL, en_Wnd_Normal*/)
{
  isDrawing = false;
}

CDlgImageZoom::~CDlgImageZoom()
{
}

void CDlgImageZoom::DoDataExchange(CDataExchange* pDX)
{
 CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CDlgImageZoom, CDialogEx)
 ON_WM_ERASEBKGND()
END_MESSAGE_MAP()

void CDlgImageZoom::SetImagePath( CString path )
{
  m_szImagePath = getExePath()+path;
  if (!m_fip.loadU(m_szImagePath, 0))
 {
   CDlgMessage(L"系统错误", L"加载图片失败，放大镜失效").DoModal();
  }
 else
  {
   m_imageHeight = m_fip.getHeight();
    m_imageWidth = m_fip.getWidth();
    AddList();
    GetClientRect(&m_rect);
   m_center.x = m_rect.Width()/2;
    m_center.y = m_rect.Height()/2;
 }
}

BOOL CDlgImageZoom::OnInitDialog()
{
 CDialogEx::OnInitDialog();
  return TRUE;
}

void CDlgImageZoom::prepareDraw(BOOL useBack/*=FALSE*/)
{
 m_pDC=GetDC();
  GetClientRect(&m_rect);

 m_memDC.CreateCompatibleDC(m_pDC);
  m_memBitmap.CreateCompatibleBitmap(m_pDC,m_rect.Width(),m_rect.Height());
 m_pOrgBMP = m_memDC.SelectObject(&m_memBitmap);
 CBrush brush(RGB(255,255,255));
 m_memDC.FillRect(m_rect, &brush);

 //可以尝试在对内存DC绘图之前将显示DC图像做为背景复制到内存DC中.
  if (useBack)
  {
   m_memDC.BitBlt(0,0,m_rect.Width(),m_rect.Height(),m_pDC,0,0,SRCCOPY);
 }
}

void CDlgImageZoom::releaseDraw()
{
  m_pDC->BitBlt(0,0,m_rect.Width(),m_rect.Height(),&m_memDC,0,0,SRCCOPY);
 m_memDC.SelectObject(m_pOrgBMP);
  m_memDC.DeleteDC();
 m_memBitmap.DeleteObject();
 ReleaseDC(m_pDC);
}

void CDlgImageZoom::UpdateDraw( CPoint point, BOOL isLeftDown/*=false*/, BOOL isLine/*=FALSE*/)
{
  int size = m_pointList.size();
  if (isLeftDown)
 {
   if (isLine && m_pointList[size-1].size()==2)
    {
     m_pointList[size-1][1] = point;
   }
   else
    {
     m_pointList[size-1].push_back(point);
   }
 }

 if (isDrawing)
  {
   return;
 }

 isDrawing = true;

 prepareDraw();

  CRect rect(0, 0, m_imageWidth, m_imageHeight);
 
  rect.OffsetRect(-point);
  rect.OffsetRect(m_center);
  m_fip.draw(m_memDC, rect);

  CPen penBlue(PS_SOLID, 1, RGB(0,0,255));
  CPen penGreen(PS_SOLID, 1, RGB(0,255,0));
 CPen penRed(PS_SOLID, 1, RGB(255,0,0));

 if (isLeftDown)
 {
   if (size>1)
   {
     m_memDC.SelectObject(&penBlue);
   }
   else
    {
     m_memDC.SelectObject(&penGreen);
    }

   for (int i=0;i<size-1;i++)
    {
     drawLine(m_pointList[i], -point+m_center);
    }
   m_memDC.SelectObject(&penGreen);
    drawLine(m_pointList[size-1], -point+m_center);
 }
 else
  {
   m_memDC.SelectObject(&penBlue);
   for (int i=0; i<size; i++)
    {
     drawLine(m_pointList[i], -point+m_center);
    }
   m_memDC.SelectObject(&penRed);
    drawCross();
  }

 releaseDraw();
  isDrawing = false;
}

int CDlgImageZoom::GetHeight()
{
  return m_imageHeight;
}

int CDlgImageZoom::GetWidth()
{
  return m_imageWidth;
}

void CDlgImageZoom::AddList()
{
 vector<CPoint> list;
  m_pointList.push_back(list);
}

void CDlgImageZoom::drawLine( vector<CPoint>& list, CPoint &point )
{
 for (size_t j=1; j<list.size();j++)
 {
   CPoint p1, p2;
    p1=list[j-1];
   p2=list[j];
   p1.Offset(point);
   p2.Offset(point);
   m_memDC.MoveTo(p1);
   m_memDC.LineTo(p2);
 }
}

// CDlgImageZoom message handlers

BOOL CDlgImageZoom::OnEraseBkgnd(CDC* pDC)
{
  return TRUE;
}

void CDlgImageZoom::drawCross()
{
 CPoint p1 = m_center+CPoint(-5,0);
  CPoint p2 = m_center+CPoint(+5,0);
  CPoint p3 = m_center+CPoint(0,-5);
  CPoint p4 = m_center+CPoint(0,+5);
  CPoint c1 = m_center+CPoint(-1,0);
  CPoint c2 = m_center+CPoint(+1,0);
  CPoint c3 = m_center+CPoint(0,-1);
  CPoint c4 = m_center+CPoint(0,+1);
  m_memDC.MoveTo(p1);
 m_memDC.LineTo(c1);
 m_memDC.MoveTo(p2);
 m_memDC.LineTo(c2);
 m_memDC.MoveTo(p3);
 m_memDC.LineTo(c3);
 m_memDC.MoveTo(p4);
 m_memDC.LineTo(c4);
}

void CDlgImageZoom::EraseLines()
{
 m_pointList.clear();
  AddList();
}

  m_dlgImageZoom.Create(IDD_DLG_IMAGE_ZOOM, this);
  m_dlgImageZoom.MoveWindow(ZOOM_DLG_X, ZOOM_DLG_Y, ZOOM_DLG_WIDTH, ZOOM_DLG_HEIGHT);
 m_dlgImageZoom.SetImagePath(m_FilePath);
  m_dlgImageZoom.SetForegroundWindow();

void CDlgImageOperation::ShowZoom( CPoint point, BOOL isShow/*=TRUE*/, BOOL isLeftDown/*=FALSE*/, BOOL isLine/*=FALSE*/ )
{
 if (isShow)
 {
   m_dlgImageZoom.SetFocus();
    m_dlgImageZoom.UpdateDraw(point, isLeftDown, isLine);
 }
 if (m_dlgImageZoom.IsWindowVisible()!=isShow)
 {
   m_dlgImageZoom.ShowWindow(isShow?SW_SHOW:SW_HIDE);
  }
}

void CDlgImageOperation::AddList()
{
 m_dlgImageZoom.AddList();
}

int CDlgImageOperation::GetHeight()
{
  return m_dlgImageZoom.GetHeight();
}

int CDlgImageOperation::GetWidth()
{
  return m_dlgImageZoom.GetWidth();
}

void ImageOperationView::OnMouseMove(UINT nFlags, CPoint point)
{
 isMoving = true;

  if (m_currentOperate==IMAGE_OPERATE_DRAW_PEN || m_currentOperate==IMAGE_OPERATE_DRAW_LINE)
  {
   CDlgImageOperation* pDlgImageOperation = (CDlgImageOperation*)GetParent();
    ClientToScreen(&point);
   CPoint tmpPoint = point;
    tmpPoint.Offset(-m_imageRect.TopLeft());
    tmpPoint.x = (LONG)(tmpPoint.x * pDlgImageOperation->GetWidth()/(m_imageRect.Width()*1.0));
   tmpPoint.y = (LONG)(tmpPoint.y * pDlgImageOperation->GetHeight()/(m_imageRect.Height()*1.0));
   CRect tmpRect(m_imageRect.left-30, m_imageRect.top-30, m_imageRect.right+30, m_imageRect.bottom+30);

    if (isLeftDown||tmpRect.PtInRect(point))
    {
     pDlgImageOperation->ShowZoom(tmpPoint, TRUE, isLeftDown, m_currentOperate==IMAGE_OPERATE_DRAW_LINE);
    }
   else
    {
     pDlgImageOperation->ShowZoom(tmpPoint, FALSE, isLeftDown);
    }
   ScreenToClient(&point);
 }
 /*...*/
}