Vc_C++实现笔锋效果代码实现

admin

C++实现笔锋效果
实现笔锋的理论可参考网上的文章：
https://www.cnblogs.com/zl03jsj/p/8051912.html
https://www.cnblogs.com/zl03jsj/p/8048102.html

本文主要介绍如何编写代码实现书写时带笔锋的功能。

为了实现模块的分割和封装，我们首先建立一个动态库项目，并向项目中添加几个文件：
HandWriteHelp.h文件

1. #pragma once
   
2. 
   
3. #include <vector>
   
4. 
   
5. #include "HandWriteMath.h"
   
6. 
   
7. class HandWriteHelp
   
8. 
   
9. {
   
10. 
    
11. public:
    
12. 
    
13.         HandWriteHelp();
    
14. 
    
15.         ~HandWriteHelp();
    
16. 
    
17.         int startNewTrace()
    
18. 
    
19.         {
    
20. 
    
21.                 pointArray = h_new_fpoint_array(24, 10, 1);
    
22. 
    
23.                 return 0;
    
24. 
    
25.         }
    
26. 
    
27.         int addNewPoint(float x, float y,
    
28. 
    
29.                 new_point_generated  callback,//生成了新的点的回调
    
30. 
    
31.                 void *context)
    
32. 
    
33.         {
    
34. 
    
35.                 h_point pt;
    
36. 
    
37.                 pt.x = x;
    
38. 
    
39.                 pt.y = y;
    
40. 
    
41.                 h_insert_point(pointArray, pt, callback, context);
    
42. 
    
43.                 return 0;
    
44. 
    
45.         }
    
46. 
    
47.         int endCurrentTrace(float x, float y,
    
48. 
    
49.                 new_point_generated  callback,//生成了新的点的回调
    
50. 
    
51.                 void *context)
    
52. 
    
53.         {
    
54. 
    
55.                 h_point pt;
    
56. 
    
57.                 pt.x = x;
    
58. 
    
59.                 pt.y = y;
    
60. 
    
61.                 h_insert_last_point(pointArray, pt, callback, context);
    
62. 
    
63.                 h_drop_fpoint_array(pointArray);
    
64. 
    
65.                 pointArray = NULL;
    
66. 
    
67.                 return 0;
    
68. 
    
69.         }
    
70. 
    
71. 
    
72. 
    
73. private:
    
74. 
    
75.         h_fpoint_array *pointArray;
    
76. 
    
77. };

复制代码

HandWriteMath.h文件：

1. #pragma once
   
2. #include <stdint.h>
   
3. #ifdef __cplusplus
   
4. extern "C" {
   
5. #endif
   
6. 
   
7. typedef struct h_point_s  h_point;
   
8. typedef struct h_fpoint_s h_fpoint;
   
9. typedef struct h_ipoint_s h_ipoint;
   
10. typedef struct h_fpoint_array_s h_fpoint_array;
    
11. 
    
12. typedef void(*new_point_generated)(float x, float y, float w, void* context);
    
13. 
    
14. struct h_point_s {
    
15.         float x, y;
    
16. };
    
17. 
    
18. struct h_fpoint_s {
    
19.         h_point p;
    
20.         float w;
    
21. };
    
22. 
    
23. struct h_ipoint_s {
    
24.         h_point p;
    
25.         int64_t t;
    
26. };
    
27. 
    
28. struct h_fpoint_array_s {
    
29.         h_fpoint *point;
    
30.         float maxwidth;
    
31.         float minwidth;
    
32.         int ref;
    
33.         int len;
    
34.         int cap;
    
35. 
    
36.         h_point last_point;
    
37.         float last_width;
    
38.         int64_t last_ms;
    
39. };
    
40. 
    
41. 
    
42. 
    
43. h_fpoint_array *h_keep_fpoint_array(h_fpoint_array *a);
    
44. void h_drop_fpoint_array(h_fpoint_array *a);
    
45. 
    
46. h_fpoint_array *h_new_fpoint_array(int initsize, float maxwidth, float minwidth);
    
47. h_fpoint_array *h_resize_fpoints_array(h_fpoint_array* a, int size);
    
48. 
    
49. 
    
50. float h_movespeed(h_ipoint s, h_ipoint e);
    
51. float h_distance(h_point s, h_point e);
    
52. void  h_fpoint_add_xyw(h_fpoint_array *a, float x, float y, float w);
    
53. void  h_fpoint_add(h_fpoint_array *a, h_fpoint p);
    
54. void  h_fpoint_differential_add(h_fpoint_array *a, h_fpoint p);
    
55. void  h_square_bezier(h_fpoint_array *a, h_fpoint b, h_point c, h_fpoint e);
    
56. float h_linewidth(h_ipoint b, h_ipoint e, float w, float step);
    
57. 
    
58. float h_insert_point(h_fpoint_array *arr, h_point point,
    
59.         new_point_generated  callback, void *context);
    
60. void  h_insert_last_point(h_fpoint_array *arr, h_point e,
    
61.         new_point_generated  callback, void *context);
    
62. 
    
63. #ifdef __cplusplus
    
64. }
    
65. #endif

复制代码

HandWritLib.h文件：

1. #ifndef HandWrite_h_
   
2. #define HandWrite_h_
   
3. #ifdef HANDWRITE_EXPORT
   
4. #define DLL_EXPORT __declspec(dllexport)
   
5. #else
   
6. #define DLL_EXPORT __declspec(dllimport)
   
7. #endif
   
8. #ifdef __cplusplus
   
9. extern "C" {
   
10. #endif
    
11. 
    
12. struct HandWritPoint {
    
13.                 float x;
    
14.                 float y;
    
15.                 float w;
    
16. };
    
17. 
    
18. typedef void(*new_point_generated)(float x, float y, float w, void* context);
    
19. 
    
20. //获取手写处理器
    
21. DLL_EXPORT  void* getHandWriteHelp();
    
22. 
    
23. //释放手写处理器
    
24. DLL_EXPORT  void releaseHandWriteHelp(void** handWriter);
    
25. 
    
26. //开始一次笔迹生成
    
27. DLL_EXPORT int startNewTrace(void * handWriter);
    
28. 
    
29. //增加一个书写点
    
30. DLL_EXPORT int addNewPoint(float x, float y, void * handWriter,
    
31.         new_point_generated  callback,//生成了新的点的回调
    
32.         void *context);//当前上下文，回调函数会传回来
    
33. 
    
34. //输入最后一个点
    
35. DLL_EXPORT int endCurrentTrace(float x, float y, void * handWriter,
    
36.         new_point_generated  callback,//生成了新的点的回调
    
37.         void *context);
    
38. 
    
39. 
    
40. #ifdef __cplusplus
    
41. }
    
42. #endif
    
43. #endif

复制代码

HandWriteHelp.cpp文件：

1. [hide]<div class="blockcode"><blockquote>#include "HandWriteHelp.h"
   
2. 
   
3. 
   
4. 
   
5. HandWriteHelp::HandWriteHelp()
   
6. {
   
7. }
   
8. 
   
9. 
   
10. HandWriteHelp::~HandWriteHelp()
    
11. {
    
12. }

复制代码

[/hide]

HandWriteLib.cpp文件：

游客，如果您要查看本帖隐藏内容请回复

HandWriteMath.c文件：

游客，如果您要查看本帖隐藏内容请回复

然后编译这个动态库项目，生成lib文件和dll文件,   编译动态库时预定义HANDWRITE_EXPORT宏。

然后我们新建一个基于对话框的MFC程序，项目中导入上面的lib文件，HandWriteLib.h头文件，dll文件也放到exe目录下。
对话框的代码如下：
对话框的头文件：

1. 
   
2. // HandWritingDlg.h: 头文件
   
3. //
   
4. 
   
5. #pragma once
   
6. 
   
7. #include "HandWritLib.h"
   
8. #include <vector>
   
9. 
   
10. #define WM_RCV_NEWPOINT (WM_USER + 100)
    
11. #define MAX_WIDTH 10
    
12. 
    
13. class CFPoint
    
14. {
    
15. public:
    
16.         float x;
    
17.         float y;
    
18. 
    
19.         CFPoint()
    
20.         {
    
21.                 x = 0;
    
22.                 y = 0;
    
23.         }
    
24.         CFPoint(float _x, float _y)
    
25.         {
    
26.                 x = _x;
    
27.                 y = _y;
    
28.         }
    
29.         CFPoint(const CFPoint &pt)
    
30.         {
    
31.                 x = pt.x;
    
32.                 y = pt.y;
    
33.         }
    
34.         inline CFPoint operator-(const CFPoint &initPt)
    
35.         {
    
36.                 return CFPoint(x - initPt.x, y - initPt.y);
    
37.         }
    
38.         inline CFPoint operator+(const CFPoint &initPt)
    
39.         {
    
40.                 return CFPoint(x + initPt.x, y + initPt.y);
    
41.         }
    
42.         inline CFPoint operator*(float value)
    
43.         {
    
44.                 return CFPoint(x*value, y*value);
    
45.         }
    
46. 
    
47. };
    
48. 
    
49. // CHandWritingDlg 对话框
    
50. class CHandWritingDlg : public CDialogEx
    
51. {
    
52. // 构造
    
53. public:
    
54.         CHandWritingDlg(CWnd* pParent = nullptr);        // 标准构造函数
    
55. 
    
56. // 对话框数据
    
57. #ifdef AFX_DESIGN_TIME
    
58.         enum { IDD = IDD_HANDWRITING_DIALOG };
    
59. #endif
    
60. 
    
61.         protected:
    
62.         virtual void DoDataExchange(CDataExchange* pDX);        // DDX/DDV 支持
    
63. 
    
64. // 实现
    
65. protected:
    
66.         HICON m_hIcon;
    
67. 
    
68.         // 生成的消息映射函数
    
69.         virtual BOOL OnInitDialog();
    
70.         afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
    
71.         afx_msg void OnPaint();
    
72.         afx_msg HCURSOR OnQueryDragIcon();
    
73. 
    
74.         afx_msg HRESULT rcvNewPoint(WPARAM wParam, LPARAM lParam);
    
75. 
    
76.         DECLARE_MESSAGE_MAP()
    
77. public:
    
78.         afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
    
79. 
    
80. 
    
81. public:
    
82.         afx_msg void OnBnClickedButton1();
    
83.         void drawLine(const CFPoint &b, const CFPoint &e, int lineWidth);
    
84.         afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    
85.         afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    
86. private:
    
87. 
    
88.         //是否开始生成
    
89.         bool isStartWrite;
    
90.         long lastPointTime;
    
91.         std::vector<HandWritPoint> lastPoint;
    
92.         void *handWriter;
    
93. 
    
94. public:
    
95.         afx_msg void OnClose();
    
96.         afx_msg void OnDestroy();
    
97. };
    

复制代码

对话框的cpp文件如下：

1. 
   
2. // HandWritingDlg.cpp: 实现文件
   
3. //
   
4. 
   
5. #include "stdafx.h"
   
6. #include "HandWriting.h"
   
7. #include "HandWritingDlg.h"
   
8. #include "afxdialogex.h"
   
9. #include <algorithm>
   
10. #include <vector>
    
11. 
    
12. #ifdef _DEBUG
    
13. #define new DEBUG_NEW
    
14. #endif
    
15. 
    
16. 
    
17. // 用于应用程序“关于”菜单项的 CAboutDlg 对话框
    
18. 
    
19. class CAboutDlg : public CDialogEx
    
20. {
    
21. public:
    
22.         CAboutDlg();
    
23. 
    
24. // 对话框数据
    
25. #ifdef AFX_DESIGN_TIME
    
26.         enum { IDD = IDD_ABOUTBOX };
    
27. #endif
    
28. 
    
29.         protected:
    
30.         virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
    
31. 
    
32. // 实现
    
33. protected:
    
34.         DECLARE_MESSAGE_MAP()
    
35. };
    
36. 
    
37. CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
    
38. {
    
39. }
    
40. 
    
41. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
    
42. {
    
43.         CDialogEx::DoDataExchange(pDX);
    
44. }
    
45. 
    
46. BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
    
47.         
    
48. END_MESSAGE_MAP()
    
49. 
    
50. 
    
51. // CHandWritingDlg 对话框
    
52. 
    
53. 
    
54. 
    
55. CHandWritingDlg::CHandWritingDlg(CWnd* pParent /*=nullptr*/)
    
56.         : CDialogEx(IDD_HANDWRITING_DIALOG, pParent)
    
57. {
    
58.         m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    
59. }
    
60. 
    
61. void CHandWritingDlg::DoDataExchange(CDataExchange* pDX)
    
62. {
    
63.         CDialogEx::DoDataExchange(pDX);
    
64. }
    
65. 
    
66. BEGIN_MESSAGE_MAP(CHandWritingDlg, CDialogEx)
    
67.         ON_WM_SYSCOMMAND()
    
68.         ON_WM_PAINT()
    
69.         ON_WM_QUERYDRAGICON()
    
70.         ON_WM_LBUTTONUP()
    
71.         ON_BN_CLICKED(IDC_BUTTON1, &CHandWritingDlg::OnBnClickedButton1)
    
72.         ON_WM_LBUTTONDOWN()
    
73.         ON_WM_MOUSEMOVE()
    
74.         ON_MESSAGE(WM_RCV_NEWPOINT, &CHandWritingDlg::rcvNewPoint)
    
75.         ON_WM_CLOSE()
    
76.         ON_WM_DESTROY()
    
77. END_MESSAGE_MAP()
    
78. 
    
79. 
    
80. // CHandWritingDlg 消息处理程序
    
81. #include <math.h>
    
82. BOOL CHandWritingDlg::OnInitDialog()
    
83. {
    
84.         CDialogEx::OnInitDialog();
    
85. 
    
86.         // 将“关于...”菜单项添加到系统菜单中。
    
87. 
    
88.         // IDM_ABOUTBOX 必须在系统命令范围内。
    
89.         ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    
90.         ASSERT(IDM_ABOUTBOX < 0xF000);
    
91. 
    
92.         CMenu* pSysMenu = GetSystemMenu(FALSE);
    
93.         if (pSysMenu != nullptr)
    
94.         {
    
95.                 BOOL bNameValid;
    
96.                 CString strAboutMenu;
    
97.                 bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
    
98.                 ASSERT(bNameValid);
    
99.                 if (!strAboutMenu.IsEmpty())
    
100.                 {
     
101.                         pSysMenu->AppendMenu(MF_SEPARATOR);
     
102.                         pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
     
103.                 }
     
104.         }
     
105. 
     
106.         // 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
     
107.         //  执行此操作
     
108.         SetIcon(m_hIcon, TRUE);                        // 设置大图标
     
109.         SetIcon(m_hIcon, FALSE);                // 设置小图标
     
110. 
     
111.         handWriter = getHandWriteHelp();
     
112.         return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
     
113. }
     
114. 
     
115. void CHandWritingDlg::OnSysCommand(UINT nID, LPARAM lParam)
     
116. {
     
117.         if ((nID & 0xFFF0) == IDM_ABOUTBOX)
     
118.         {
     
119.                 CAboutDlg dlgAbout;
     
120.                 dlgAbout.DoModal();
     
121.         }
     
122.         else
     
123.         {
     
124.                 CDialogEx::OnSysCommand(nID, lParam);
     
125.         }
     
126. }
     
127. 
     
128. // 如果向对话框添加最小化按钮，则需要下面的代码
     
129. //  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
     
130. //  这将由框架自动完成。
     
131. 
     
132. void CHandWritingDlg::OnPaint()
     
133. {
     
134.         if (IsIconic())
     
135.         {
     
136.                 CPaintDC dc(this); // 用于绘制的设备上下文
     
137. 
     
138.                 SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
     
139. 
     
140.                 // 使图标在工作区矩形中居中
     
141.                 int cxIcon = GetSystemMetrics(SM_CXICON);
     
142.                 int cyIcon = GetSystemMetrics(SM_CYICON);
     
143.                 CRect rect;
     
144.                 GetClientRect(&rect);
     
145.                 int x = (rect.Width() - cxIcon + 1) / 2;
     
146.                 int y = (rect.Height() - cyIcon + 1) / 2;
     
147. 
     
148.                 // 绘制图标
     
149.                 dc.DrawIcon(x, y, m_hIcon);
     
150.         }
     
151.         else
     
152.         {
     
153.                 CDialogEx::OnPaint();
     
154.         }
     
155. }
     
156. 
     
157. //当用户拖动最小化窗口时系统调用此函数取得光标
     
158. //显示。
     
159. HCURSOR CHandWritingDlg::OnQueryDragIcon()
     
160. {
     
161.         return static_cast<HCURSOR>(m_hIcon);
     
162. }
     
163. 
     
164. 
     
165. void CHandWritingDlg::drawLine(const CFPoint &b, const CFPoint &e, int lineWidth)
     
166. {
     
167.         CRect rect;
     
168.         CDC* pdc = this->GetDC();
     
169.         if (pdc == NULL)
     
170.         {
     
171.                 DWORD dw = ::GetLastError();
     
172.                 dw = dw;
     
173.                 return;
     
174.         }
     
175. 
     
176.         Graphics graphics(pdc->m_hDC);
     
177.         graphics.SetSmoothingMode(SmoothingModeAntiAlias);
     
178.         graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
     
179. 
     
180.         static long drawtimes = 0;
     
181.         Pen pen(Color(255, 255, 0, 0), lineWidth);
     
182.         pen.SetStartCap(LineCapRound);
     
183.         pen.SetEndCap(LineCapRound);
     
184.         Gdiplus::Point points[2];
     
185.         points[0].X = b.x;
     
186.         points[0].Y = b.y;
     
187.         points[1].X = e.x;
     
188.         points[1].Y = e.y;
     
189.         graphics.DrawCurve(&pen, points, 2, 0.5);        
     
190.         DeleteObject(pdc->m_hDC);
     
191. }
     
192. 
     
193. 
     
194. void newPointCallback(float x, float y, float w, void *context)
     
195. {
     
196.         CHandWritingDlg *pThis = (CHandWritingDlg*)context;
     
197.         HandWritPoint *point = new HandWritPoint();
     
198.         point->x = x;
     
199.         point->y = y;
     
200.         point->w = w;
     
201.         pThis->SendMessage(WM_RCV_NEWPOINT, 0, (LPARAM)point);
     
202. }
     
203. 
     
204. 
     
205. void CHandWritingDlg::OnLButtonUp(UINT nFlags, CPoint point)
     
206. {
     
207.         isStartWrite = false;
     
208.         endCurrentTrace(point.x, point.y, handWriter, newPointCallback, this);
     
209.         CDialogEx::OnLButtonUp(nFlags, point);
     
210.         
     
211. }
     
212. 
     
213. 
     
214. void CHandWritingDlg::OnBnClickedButton1()
     
215. {
     
216.         lastPoint.clear();
     
217.         Invalidate();
     
218. }
     
219. 
     
220. HRESULT CHandWritingDlg::rcvNewPoint(WPARAM wParam, LPARAM lParam)
     
221. {
     
222.         HandWritPoint *point = (HandWritPoint*)lParam;
     
223. 
     
224.         if (lastPoint.size() > 0)
     
225.         {
     
226.                 HandWritPoint p = lastPoint.back();
     
227.                 drawLine(CFPoint(p.x, p.y),
     
228.                         CFPoint(point->x, point->y),
     
229.                         MAX_WIDTH * (p.w) + 0.5);
     
230. 
     
231.         }
     
232.         lastPoint.push_back(*point);
     
233.         delete point;
     
234.         return 0;
     
235. }
     
236. 
     
237. 
     
238. 
     
239. void CHandWritingDlg::OnLButtonDown(UINT nFlags, CPoint point)
     
240. {
     
241.         lastPoint.clear();
     
242.         startNewTrace(handWriter);
     
243.         addNewPoint(point.x, point.y, handWriter, newPointCallback, this);
     
244.         isStartWrite = true;        
     
245.         CDialogEx::OnLButtonDown(nFlags, point);
     
246. }
     
247. 
     
248. 
     
249. void CHandWritingDlg::OnMouseMove(UINT nFlags, CPoint point)
     
250. {
     
251.         if (isStartWrite == true)
     
252.         {
     
253.                 addNewPoint(point.x, point.y, handWriter, newPointCallback, this);
     
254.         }
     
255.         
     
256.         CDialogEx::OnMouseMove(nFlags, point);
     
257. }
     
258. 
     
259. 
     
260. void CHandWritingDlg::OnClose()
     
261. {
     
262.         // TODO: 在此添加消息处理程序代码和/或调用默认值
     
263. 
     
264.         CDialogEx::OnClose();
     
265. }
     
266. 
     
267. 
     
268. void CHandWritingDlg::OnDestroy()
     
269. {
     
270.         CDialogEx::OnDestroy();
     
271. 
     
272.         // TODO: 在此处添加消息处理程序代码
     
273.         releaseHandWriteHelp(&handWriter);
     
274. }
     

复制代码

程序运行的结果如下：