网页CAD SDK绘制规则多边形图形

lihao2014

前言

在 CAD（计算机辅助设计）领域，绘制多边形是常见的任务之一。MxCAD 是一款专注在线CAD的前端库，提供了丰富的绘图和设计功能，使得绘制多边形变得轻松而灵活。本文将带领您通过使用 MxCAD 实现绘制多边形的过程，深入了解其基本概念和功能。

mxcad 是一个基于 TypeScript 的前端库，专为 CAD 开发者设计。它提供了丰富的 API 和功能，用于创建、编辑和展示 CAD 图形。通过导入各种模块实现各种绘制任务。

我们以绘制规则多边形为例，介绍如何使用 mxcad 绘制多边形，将下面的代码片段导入 mxcad和mxdraw 在本文中会用到的模块。

1. import { DynamicInputType, MrxDbgUiPrInt, MrxDbgUiPrPoint, MxCursorType, MxFun } from "mxdraw";
   
2. import { MxCpp, McCmColor, McDbCircle, McDbPolyline, McGePoint3d, MxCADUiPrInt, MxCADUiPrPoint } from "mxcad";

复制代码

其中 DynamicInputType、MrxDbgUiPrInt 等是 MxCAD 提供的功能模块，而 McDbCircle、McDbPolyline 则是表示 CAD 图形的对象。

如果看了文中导出的API使用示例不理解可以在mxcadAPI文档或者mxdrawAPI文档中查找对应说明。

理解生成规则多边形的算法的每一步计算对于绘制正多边形非常重要。以下是 computeRegularPolygonVertices 函数的详细解释：

1. /**
   
2. * 生成规则多边形的顶点坐标
   
3. * @param {McGePoint3d} centerPoint - 多边形中心点
   
4. * @param {McGePoint3d} vertexPoint - 多边形顶点
   
5. * @param {number} sides - 多边形边数（至少为3）
   
6. * @returns {McGePoint3d[]} 多边形的顶点坐标数组
   
7. */
   
8. export function computeRegularPolygonVertices(centerPoint = new McGePoint3d(), vertexPoint = new McGePoint3d(), sides = 3): McGePoint3d[] {
   
9.     const verticesArray: McGePoint3d[] = [];
   
10.     sides = Math.max(3, sides);
    
11.     verticesArray.push(vertexPoint);
    
12. 
    
13.     // 计算每个顶点的角度增量
    
14.     const angleIncrement = (Math.PI * 2) / sides;
    
15. 
    
16.     for (let i = 1; i < sides; i++) {
    
17.         // 计算当前顶点对应的角度上的余弦和正弦值
    
18.         const cosValue = Math.cos(angleIncrement * i),
    
19.             sinValue = Math.sin(angleIncrement * i);
    
20. 
    
21.         // 复制中心点和顶点，以免修改原始点的值
    
22.         const startPt = centerPoint.clone();
    
23.         const endPt = vertexPoint.clone();
    
24. 
    
25.         // 计算相对于中心点的偏移量
    
26.         const deltaX = endPt.x - startPt.x;
    
27.         const deltaY = endPt.y - startPt.y;
    
28. 
    
29.         // 根据旋转公式计算新的顶点坐标
    
30.         const newX = deltaX * cosValue - deltaY * sinValue + startPt.x;
    
31.         const newY = deltaX * sinValue + deltaY * cosValue + startPt.y;
    
32. 
    
33.         // 创建新的顶点对象并加入数组
    
34.         const point = new McGePoint3d(newX, newY);
    
35.         verticesArray.push(point);
    
36.     }
    
37.    return verticesArray;
    
38. }

复制代码

多边形的计算

下面是算法的每一步计算的详细解释：

1.初始化参数： 首先，函数初始化了一个空数组 verticesArray 用于存储多边形的顶点坐标。同时，确保多边形的边数至少为3，如果用户输入的边数小于3，就将边数设置为3。

1. const verticesArray: McGePoint3d[] = [];
   
2. sides = Math.max(3, sides);
   
3. verticesArray.push(vertexPoint);

复制代码

2.计算角度增量： 通过将完整的圆周角（2π）除以多边形的边数，计算出每个顶点之间的角度增量。

1. const angleIncrement = (Math.PI * 2) / sides;

复制代码

3.计算顶点坐标： 利用余弦和正弦值计算每个顶点相对于起始点的偏移量。这里采用了旋转公式，通过旋转坐标系来计算新的顶点坐标。

1. const cosValue = Math.cos(angleIncrement * i),
   
2. sinValue = Math.sin(angleIncrement * i);

复制代码

4.复制中心点和顶点： 为了防止修改原始点的值，创建了中心点和顶点的副本。

1. const startPt = centerPoint.clone();
   
2. const endPt = vertexPoint.clone();

复制代码

5.计算偏移量： 计算相对于中心点的偏移量，即顶点相对于中心点的位置。

1. const deltaX = endPt.x - startPt.x;
   
2. const deltaY = endPt.y - startPt.y;

复制代码

6.旋转计算新坐标： 利用旋转公式计算新的顶点坐标，并将其添加到顶点数组中。

1. const newX = deltaX * cosValue - deltaY * sinValue + startPt.x;
   
2. const newY = deltaX * sinValue + deltaY * cosValue + startPt.y;
   
3. const point = new McGePoint3d(newX, newY);
   
4. verticesArray.push(point);

复制代码

7.返回结果： 最终，返回计算得到的多边形的顶点坐标数组。

1. return verticesArray;

复制代码

通过这个算法，我们可以在 CAD 中绘制出规则多边形，而不仅仅是简单的直角坐标系中的顶点。这使得多边形的绘制更加灵活和适应性强。

与之对应的，我们从注释可以看出, 他们是通过多边形中心点和多边形顶点来计算出整个多边形的顶点坐标。

其他的计算方法

那么在AutoCAD中,还有其他方式可以绘制正多边形，那么我们接下来一一将这些算法实现。

下面是 computePolygonVerticesFromEdge 函数的详细解释：

1. /**
   
2. * 计算多边形顶点坐标（基于边）
   
3. * @param {McGePoint3d} startPoint - 多边形边的起始点
   
4. * @param {McGePoint3d} endPoint - 多边形边的结束点
   
5. * @param {number} sides - 多边形边数（至少为3）
   
6. * @returns {McGePoint3d[]} 多边形的顶点坐标数组
   
7. */
   
8. export function computePolygonVerticesFromEdge(startPoint: McGePoint3d, endPoint: McGePoint3d, sides: number): McGePoint3d[] {
   
9.     // 计算边的长度和角度
   
10.     let dx = endPoint.x - startPoint.x;
    
11.     let dy = endPoint.y - startPoint.y;
    
12.     let length = Math.sqrt(dx * dx + dy * dy);
    
13.     let angle = Math.atan2(dy, dx);
    
14. 
    
15.     // 计算每个顶点的角度增量
    
16.     let angleIncrement = (2 * Math.PI) / Math.max(3, sides);
    
17. 
    
18.     let polygonVertices = [startPoint, endPoint];
    
19. 
    
20.     for (let i = 0; i < sides; i++) {
    
21.         // 计算当前顶点的坐标
    
22.         let x = startPoint.x + length * Math.cos(angle + i * angleIncrement);
    
23.         let y = startPoint.y + length * Math.sin(angle + i * angleIncrement);
    
24. 
    
25.         // 更新起始点并加入数组
    
26.         startPoint = new McGePoint3d(x, y);
    
27.         polygonVertices.push(startPoint);
    
28.     }
    
29. 
    
30.     return polygonVertices;
    
31. }

复制代码

以下是该算法的每一步计算的详细解释：

1.计算边的长度和角度： 首先，计算给定边的长度和角度。这是通过计算起始点和结束点的横向和纵向差异，然后使用勾股定理计算长度，最后使用反正切函数计算角度。

1. let dx = endPoint.x - startPoint.x;
   
2. let dy = endPoint.y - startPoint.y;
   
3. let length = Math.sqrt(dx * dx + dy * dy);
   
4. let angle = Math.atan2(dy, dx);

复制代码

2.计算每个顶点的角度增量： 为了均匀地分布多边形的顶点，计算每个顶点之间的角度增量。

1. let angleIncrement = (2 * Math.PI) / Math.max(3, sides);

复制代码

3.初始化顶点数组： 创建一个数组，其中包含起始点和结束点，这是为了确保多边形是封闭的。

1. let polygonVertices = [startPoint, endPoint];

复制代码

4.计算顶点坐标： 循环计算每个顶点的坐标。利用极坐标系的转换，通过给定的角度增量计算出每个顶点相对于起始点的坐标。

1. for (let i = 0; i < sides; i++) {
   
2.     let x = startPoint.x + length * Math.cos(angle + i * angleIncrement);
   
3.     let y = startPoint.y + length * Math.sin(angle + i * angleIncrement);
   
4.     startPoint = new McGePoint3d(x, y);
   
5.     polygonVertices.push(startPoint);
   
6. }

复制代码

5.返回结果： 最终，返回计算得到的多边形的顶点坐标数组。

1. return polygonVertices;

复制代码

通过这个算法，我们可以根据给定的起始点和结束点绘制多边形。

下面是 computePolygonVerticesFromMidpoint 函数的详细解释：

1. /**
   
2. * 计算多边形顶点坐标（基于中点）
   
3. * @param {McGePoint3d} centerPoint - 多边形中心点
   
4. * @param {McGePoint3d} edgeMidPoint - 多边形一条边的中点
   
5. * @param {number} sides - 多边形边数（至少为3）
   
6. * @returns {McGePoint3d[]} 多边形的顶点坐标数组
   
7. */
   
8. function computePolygonVerticesFromMidpoint(centerPoint = new McGePoint3d(), edgeMidPoint = new McGePoint3d(), sides = 3): McGePoint3d[] {
   
9.     const midX = edgeMidPoint.x;
   
10.     const midY = edgeMidPoint.y;
    
11.     const centerX = centerPoint.x;
    
12.     const centerY = centerPoint.y;
    
13.     const numberOfSides = Math.max(3, sides);
    
14. 
    
15.     // 计算中点到多边形中心的距离
    
16.     const distanceToCenter = Math.sqrt((midX - centerX) ** 2 + (midY - centerY) ** 2);
    
17. 
    
18.     // 计算中点到多边形中心的半径
    
19.     const radius = distanceToCenter / Math.cos(Math.PI / numberOfSides);
    
20. 
    
21.     // 计算起始角度
    
22.     const startAngle = Math.atan2(midY - centerY, midX - centerX) - Math.PI / numberOfSides;
    
23. 
    
24.     const vertices = [];
    
25. 
    
26.     for (let i = 0; i < numberOfSides; i++) {
    
27.         // 计算当前顶点的角度
    
28.         const angle = startAngle + (i * 2 * Math.PI / numberOfSides);
    
29. 
    
30.         // 根据极坐标系转换成直角坐标系的坐标
    
31.         const x = centerX + radius * Math.cos(angle);
    
32.         const y = centerY + radius * Math.sin(angle);
    
33. 
    
34.         // 创建新的顶点对象并加入数组
    
35.         vertices.push(new McGePoint3d(x, y));
    
36.     }
    
37. 
    
38.     return vertices;
    
39. }

复制代码

以下是该算法的每一步计算的详细解释：

1.获取中点和中心点的坐标： 首先，获取给定边的中点（edgeMidPoint）和多边形的中心点（centerPoint）的坐标。

1. const midX = edgeMidPoint.x;
   
2. const midY = edgeMidPoint.y;
   
3. const centerX = centerPoint.x;
   
4. const centerY = centerPoint.y;

复制代码

2.计算中点到中心的距离和半径： 利用勾股定理计算中点到中心的距离，然后计算出多边形的半径。

1. const distanceToCenter = Math.sqrt((midX - centerX) ** 2 + (midY - centerY) ** 2);
   
2. const radius = distanceToCenter / Math.cos(Math.PI / numberOfSides);

复制代码

3.计算起始角度： 利用反正切函数计算出中点到中心的方向角，并减去角度增量的一半，以确保多边形顶点的均匀分布。

1. const startAngle = Math.atan2(midY - centerY, midX - centerX) - Math.PI / numberOfSides;

复制代码

4.计算顶点坐标： 循环计算每个顶点的坐标。通过极坐标系转换，将极坐标系中的角度转换为直角坐标系中的坐标。

1. for (let i = 0; i < numberOfSides; i++) {
   
2.     const angle = startAngle + (i * 2 * Math.PI / numberOfSides);
   
3.     const x = centerX + radius * Math.cos(angle);
   
4.     const y = centerY + radius * Math.sin(angle);
   
5.     vertices.push(new McGePoint3d(x, y));
   
6. }

复制代码

5.返回结果： 最终，返回计算得到的多边形的顶点坐标数组。

1. return vertices;

复制代码

通过这个算法，我们可以根据给定的边的中点和多边形的中心点绘制多边形。

交互绘制过程

以上我们介绍了这三种算法，已经把autoCAD中绘制正多边形的算法都模拟出来了，那么接下来就是模拟它的交互绘制过程了，代码如下:

1. /**
   
2. * 绘制多边形的函数
   
3. */
   
4. export async function drawPolygon() {
   
5.     // 创建用户输入对象，用于获取侧面数
   
6.     const getNum = new MxCADUiPrInt();
   
7.     getNum.setMessage("\n输入侧面数 <5>")
   
8.    
   
9.     // 获取用户输入的侧面数
   
10.     let sideNum = await getNum.go() as number;
    
11.     if (!sideNum) sideNum = 5;
    
12. 
    
13.     // 创建用户输入对象，用于获取多边形的中心点或边
    
14.     const getPoint = new MxCADUiPrPoint();
    
15.     getPoint.setMessage("\n指定正多变形的中心点");
    
16.     getPoint.setKeyWords("[边(E)]");
    
17. 
    
18.     // 设置光标类型
    
19.     getPoint.setCursorType(MxCursorType.kCross);
    
20. 
    
21.     // 获取用户输入的中心点或边
    
22.     const centerPoint = await getPoint.go();
    
23. 
    
24.     if (!centerPoint) {
    
25.         // 如果用户选择边，进入边绘制流程
    
26.         if (getPoint.isKeyWordPicked("e")) {
    
27.             // 获取用户输入的边的第一个端点
    
28.             getPoint.setMessage("\n指定边的第一个端点");
    
29.             getPoint.setKeyWords("");
    
30.             const startPoint = await getPoint.go();
    
31. 
    
32.             if (!startPoint) return;
    
33. 
    
34.             // 设置用户绘制回调函数，用于实时绘制多边形
    
35.             getPoint.setUserDraw((currentPoint, pWorldDraw) => {
    
36.                 const pPolyline = new McDbPolyline();
    
37.                 // 计算多边形顶点
    
38.                 const points = computePolygonVerticesFromEdge(startPoint, currentPoint, sideNum);
    
39. 
    
40.                 // 将顶点添加到多边形
    
41.                 points.forEach((point) => {
    
42.                     pPolyline.addVertexAt(point);
    
43.                 });
    
44. 
    
45.                 // 设置多边形为闭合状态
    
46.                 pPolyline.isClosed = true;
    
47. 
    
48.                 // 实时绘制多边形
    
49.                 pWorldDraw.drawMcDbEntity(pPolyline);
    
50.             });
    
51. 
    
52.             // 获取用户输入的边的第二个端点
    
53.             getPoint.setMessage("\n指定边的第二个端点");
    
54.             await getPoint.go();
    
55. 
    
56.             // 绘制多边形并清除绘制保留
    
57.             getPoint.drawReserve();
    
58.         }
    
59.         return;
    
60.     }
    
61.     // 用户选择中心点后的绘制流程
    
62.     getPoint.setMessage("\n输入选项");
    
63.     getPoint.setKeyWords("[内接于圆(I)/外切于圆(C)]");
    
64.     // 获取用户选择的是内切圆还是外切圆
    
65.     await getPoint.go();
    
66.     let isTangentToTheCircle = true;
    
67.     if(getPoint.isKeyWordPicked("i")) isTangentToTheCircle = false;
    
68. 
    
69.     // 设置用户绘制回调函数，用于实时绘制多边形
    
70.     getPoint.setUserDraw((currentPoint, pWorldDraw) => {
    
71.         // 获取当前绘图颜色
    
72.         let drawColor = MxCpp.getCurrentMxCAD().getCurrentDatabaseDrawColor();
    
73. 
    
74.         // 创建多边形对象
    
75.         const pPolyline = new McDbPolyline();
    
76.         pPolyline.trueColor = new McCmColor(drawColor.r, drawColor.g, drawColor.b);
    
77. 
    
78.         // 计算多边形顶点
    
79.         const points = isTangentToTheCircle ? computePolygonVerticesFromMidpoint(centerPoint, currentPoint, sideNum) : computeRegularPolygonVertices(centerPoint, currentPoint, sideNum);
    
80. 
    
81.         // 将顶点添加到多边形
    
82.         points.forEach((pt) => {
    
83.             pPolyline.addVertexAt(pt);
    
84.         });
    
85. 
    
86.         // 设置多边形为闭合状态
    
87.         pPolyline.isClosed = true;
    
88. 
    
89.         // 实时绘制多边形
    
90.         pWorldDraw.drawMcDbEntity(pPolyline);
    
91.     });
    
92. 
    
93.     // 获取用户输入的圆的半径
    
94.     getPoint.setMessage("\n指定圆的半径");
    
95.     await getPoint.go();
    
96. 
    
97.     // 绘制多边形并清除绘制保留
    
98.     getPoint.drawReserve();
    
99. }
    
100. 
     
101. // 将绘制多边形的函数注册为MxCAD命令
     
102. MxFun.addCommand("Mx_Polygon", drawPolygon);

复制代码

1.用户输入

首先，我们需要从用户那里获取一些信息，包括多边形的侧面数以及中心点或边的位置。为了实现这一点，我们使用了 MxCADUiPrInt 和 MxCADUiPrPoint 类。

1. const getNum = new MxCADUiPrInt();
   
2. getNum.setMessage("\n输入侧面数 <5>")
   
3. let sideNum = await getNum.go() as number;
   
4. if (!sideNum) sideNum = 5;
   
5. 
   
6. const getPoint = new MxCADUiPrPoint();
   
7. getPoint.setMessage("\n指定正多变形的中心点");
   
8. getPoint.setKeyWords("[边(E)]");

复制代码

在这里，我们设置了一个消息，提示用户输入多边形的侧面数。如果用户没有输入，默认为5。然后，我们创建了一个用于获取点的对象，并设置了一些参数，包括用户可能的关键字（在这里是选择边的标志）。

2.选择中心点或边

通过 getPoint.go()，我们等待用户选择中心点或边。如果用户选择了边，我们进入边绘制的流程，否则，我们将继续中心点的绘制。

1. const centerPoint = await getPoint.go();
   
2. if (!centerPoint) {
   
3.     if (getPoint.isKeyWordPicked("e")) {
   
4.         // 边绘制流程...
   
5.     }
   
6.     return;
   
7. }

复制代码

这一步是用户与程序的第一次交互，用户可以选择是通过中心点绘制多边形，还是选择一条边开始绘制。这增加了用户的灵活性，使得工具更加实用。

3.边绘制流程

如果用户选择了边，我们首先获取边的起始点，然后设置用户绘制回调函数。这个回调函数用于实时绘制多边形，以便用户在选择边的过程中看到预览效果。

1. const startPoint = await getPoint.go();
   
2. if (!startPoint) return;
   
3. 
   
4. getPoint.setUserDraw((currentPoint, pWorldDraw) => {
   
5.     // 实时绘制多边形...
   
6. });
   
7. 
   
8. await getPoint.go();
   
9. getPoint.drawReserve();

复制代码

在这一步中，我们利用用户输入的起始点，实时计算并绘制多边形的预览效果。用户可以看到一个动态的多边形，随着鼠标移动而更新。

4.中心点绘制流程

如果用户选择了中心点，我们首先获取用户选择的是内切圆还是外切圆。然后，我们设置用户绘制回调函数，用于实时绘制多边形，并获取用户输入的圆的半径。

1. getPoint.setMessage("\n输入选项");
   
2. getPoint.setKeyWords("[内接于圆(I)/外切于圆(C)]");
   
3. await getPoint.go();
   
4. 
   
5. getPoint.setUserDraw((currentPoint, pWorldDraw) => {
   
6.     // 实时绘制多边形...
   
7. });
   
8. 
   
9. getPoint.setMessage("\n指定圆的半径");
   
10. await getPoint.go();
    
11. getPoint.drawReserve();

复制代码

这一步用户有选择地指定了多边形是内接于圆还是外切于圆，进一步增加了工具的功能。

5.实时绘制多边形

在用户选择中心点或边后，通过用户绘制回调函数，我们实时计算多边形的顶点，并使用 MxCAD 提供的绘图工具实时绘制多边形的预览效果。

1. getPoint.setUserDraw((currentPoint, pWorldDraw) => {
   
2.     // 获取当前绘图颜色...
   
3.     let drawColor = MxCpp.getCurrentMxCAD().getCurrentDatabaseDrawColor();
   
4. 
   
5.     // 创建多边形对象...
   
6.     const pPolyline = new McDbPolyline();
   
7.     pPolyline.trueColor = new McCmColor(drawColor.r, drawColor.g, drawColor.b);
   
8. 
   
9.     // 计算多边形顶点...
   
10.     const points = isTangentToTheCircle ? computePolygonVerticesFromMidpoint(centerPoint, currentPoint, sideNum) : computeRegularPolygonVertices(centerPoint, currentPoint, sideNum);
    
11. 
    
12.     // 将顶点添加到多边形...
    
13.     points.forEach((pt) => {
    
14.         pPolyline.addVertexAt(pt);
    
15.     });
    
16. 
    
17.     // 设置多边形为闭合状态...
    
18.     pPolyline.isClosed = true;
    
19. 
    
20.     // 实时绘制多边形...
    
21.     pWorldDraw.drawMcDbEntity(pPolyline);
    
22. });

复制代码

这一步是整个流程的关键，它展示了用户如何与实时绘制进行交互。用户在选择中心点或边后，可以通过鼠标移动来动态地看到多边形的形状。这种实时反馈是提高用户体验的重要因素。

6.注册为MxCAD命令

最后，我们将绘制多边形的函数注册为 MxCAD 命令，以便用户可以通过命令行调用。

1. MxFun.addCommand("Mx_Polygon", drawPolygon);

复制代码

通过这一系列步骤，我们演示了如何使用 MxCAD 来实现一个交互式的多边形绘制。 这不仅涵盖了用户输入的处理，还展示了如何结合 MxCAD 提供的功能来实现实时绘制和用户选择的功能。 通过使用mxcad，使开发者能够专注于业务逻辑而不是底层图形处理和交互处理。

实际效果查看:https://demo.mxdraw3d.com:3000/mxcad/ 在页面的命令行输入Mx_Polygon

liangda6

whng

感谢楼主的无私分享