deeptwins-engine-3d 0.1.63 → 0.1.65

package/dist/esm/{plot/utils/PlotCommon.js → drawer/common.js}

@@ -1,58 +1,9 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-/**
- * 态势标绘通用方法
- */
 import * as Cesium from 'deeptwins-cesium';
-import xp from "./Algorithm";
-import { calculateAngle, transformCartesianToWGS84, transformWGS84ToCartesian } from "./Coordinate";
-/**
- * 获取静态资源路径
- * @param url 路径
- * @returns
- */
-// export const getAssetsData = (url: string) => {
-//   return new URL(`../assets/${url}`, import.meta.url).href;
-// };
-
+import xp from "./algorithm";
+import { calculateAngle, transformCartesianToWGS84, transformWGS84ToCartesian } from "./coordinate";
 /**
- * 创建随机（唯一）ID
- * @param num
- * @returns
- */
-var newSessionid = function newSessionid(num) {
-  var len = num || 32;
-  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-  var maxPos = chars.length;
-  var pwd = '';
-  for (var i = 0; i < len; i++) {
-    pwd += chars.charAt(Math.floor(Math.random() * maxPos));
-  }
-  return pwd;
-};
-/**
- * 锁定视图
- * @param viewer - 三维场景
- * @param bool - 是否锁定
- */
-var lockingMap = function lockingMap(viewer, bool) {
-  // 如果为真，则允许用户旋转相机。如果为假，相机将锁定到当前标题。此标志仅适用于2D和3D。
-  viewer.scene.screenSpaceCameraController.enableRotate = bool;
-  // 如果为true，则允许用户平移地图。如果为假，相机将保持锁定在当前位置。此标志仅适用于2D和Columbus视图模式。
-  viewer.scene.screenSpaceCameraController.enableTranslate = bool;
-  // 如果为真，允许用户放大和缩小。如果为假，相机将锁定到距离椭圆体的当前距离
-  viewer.scene.screenSpaceCameraController.enableZoom = bool;
-  // 如果为真，则允许用户倾斜相机。如果为假，相机将锁定到当前标题。这个标志只适用于3D和哥伦布视图。
-  viewer.scene.screenSpaceCameraController.enableTilt = bool;
-};
-/**
- * 创建贝塞尔点集
- * @param anchorpoints
- * @returns
+ * 根据控制点生成贝塞尔曲线点集。
+ * 输入为 Cesium.Cartesian3 控制点，输出同样为 Cartesian3 点集。
  */
 var createBezierPoints = function createBezierPoints(anchorpoints) {
   var degrees = [];
@@ -69,47 +20,9 @@ var createBezierPoints = function createBezierPoints(anchorpoints) {
   }
   return points;
 };
+
 /**
- * 创建正多边形节点
- * @param centerPoint
- * @param endCartesian
- * @param num
- * @returns
- */
-var getRegularPoints = function getRegularPoints(centerPoint, endCartesian, num) {
-  var _geometry$attributes$;
-  var centerP = transformCartesianToWGS84(centerPoint);
-  var distance = 1;
-  if (endCartesian) {
-    var endDegree = transformCartesianToWGS84(endCartesian);
-    distance = Cesium.Cartesian3.distance(Cesium.Cartesian3.fromDegrees(centerP.x, centerP.y, 0), Cesium.Cartesian3.fromDegrees(endDegree.x, endDegree.y, 0));
-  }
-  var ellipse = new Cesium.EllipseOutlineGeometry({
-    center: centerPoint,
-    semiMajorAxis: distance,
-    semiMinorAxis: distance,
-    granularity: 0.0001 //0~1 圆的弧度角,该值非常重要,默认值0.02,如果绘制性能下降，适当调高该值可以提高性能
-  });
-  var geometry = Cesium.EllipseOutlineGeometry.createGeometry(ellipse);
-  var circlePoints = [];
-  var values = geometry === null || geometry === void 0 || (_geometry$attributes$ = geometry.attributes.position) === null || _geometry$attributes$ === void 0 ? void 0 : _geometry$attributes$.values;
-  if (!values) return;
-  var posNum = values.length / 3; //数组中以笛卡尔坐标进行存储(每3个值一个坐标)
-  for (var i = 0; i < posNum; i++) {
-    var curPos = new Cesium.Cartesian3(values[i * 3], values[i * 3 + 1], values[i * 3 + 2]);
-    circlePoints.push(curPos);
-  }
-  var resultPoints = [];
-  var pointsapart = Math.floor(circlePoints.length / num);
-  for (var j = 0; j < num; j++) {
-    resultPoints.push(circlePoints[j * pointsapart]);
-  }
-  return resultPoints;
-};
-/**
- * 创建攻击箭头节点
- * @param positions
- * @returns
+ * 根据控制点计算攻击箭头面顶点。
  */
 var getAttackArrowPoints = function getAttackArrowPoints(positions) {
   var lnglatArr = [];
@@ -125,9 +38,7 @@ var getAttackArrowPoints = function getAttackArrowPoints(positions) {
 };
 
 /**
- * 创建直角箭头节点
- * @param anchorpoints
- * @returns
+ * 根据控制点计算直角箭头面顶点。
  */
 var getRightAngleArrowPoints = function getRightAngleArrowPoints(anchorpoints) {
   var degreePoints = [];
@@ -142,6 +53,10 @@ var getRightAngleArrowPoints = function getRightAngleArrowPoints(anchorpoints) {
   });
   return Cesium.Cartesian3.fromDegreesArray(degreesArray);
 };
+
+/**
+ * 构建直角箭头多控制点情况下的左右边界与箭头头部。
+ */
 function calculateMorePoints(anchorpoints) {
   var ratio = 6;
   var pointsR;
@@ -150,27 +65,25 @@ function calculateMorePoints(anchorpoints) {
       pointS,
       pointE;
     for (var i = 0; i < anchorpoints.length - 1; i++) {
-      pointS = anchorpoints[i]; //取出首尾两个点
+      pointS = anchorpoints[i];
       pointE = anchorpoints[i + 1];
       l += Math.sqrt((pointE.y - pointS.y) * (pointE.y - pointS.y) + (pointE.x - pointS.x) * (pointE.x - pointS.x));
     }
     var w = l / ratio;
-    var points_C_l = []; //定义左右控制点集合
+    var points_C_l = [];
     var points_C_r = [];
     var point_t_l = {
       x: undefined,
       y: undefined
-    }; //定义尾部左右的起始点
+    };
     var point_t_r = {
       x: undefined,
       y: undefined
     };
-    //计算中间的所有交点
     for (var j = 0; j < anchorpoints.length - 2; j++) {
-      var pointU_1 = anchorpoints[j]; //第一个用户传入的点
-      var pointU_2 = anchorpoints[j + 1]; //第二个用户传入的点
-      var pointU_3 = anchorpoints[j + 2]; //第三个用户传入的点
-      //计算向量
+      var pointU_1 = anchorpoints[j];
+      var pointU_2 = anchorpoints[j + 1];
+      var pointU_3 = anchorpoints[j + 2];
       var v_U_1_2 = {
         x: pointU_2.x - pointU_1.x,
         y: pointU_2.y - pointU_1.y
@@ -185,7 +98,6 @@ function calculateMorePoints(anchorpoints) {
       var v_lr_2_3 = calculateVector(v_U_2_3, Math.PI / 2, w / 2);
       var v_l_2_3 = v_lr_2_3[0];
       var v_r_2_3 = v_lr_2_3[1];
-      //获取左右
       var point_l_1 = {
         x: pointU_1.x + (v_l_1_2 === null || v_l_1_2 === void 0 ? void 0 : v_l_1_2.x),
         y: pointU_1.y + (v_l_1_2 === null || v_l_1_2 === void 0 ? void 0 : v_l_1_2.y)
@@ -202,21 +114,13 @@ function calculateMorePoints(anchorpoints) {
         x: pointU_2.x + (v_r_2_3 === null || v_r_2_3 === void 0 ? void 0 : v_r_2_3.x),
         y: pointU_2.y + (v_r_2_3 === null || v_r_2_3 === void 0 ? void 0 : v_r_2_3.y)
       };
-      //向量v_U_1_2和向量v-point_l_1和point_r_1是平行的
-      //如果向量a=(x1，y1)，b=(x2，y2)，则a//b等价于x1y2－x2y1=0
-      //得到(x-point_l_1.x)*v_U_1_2.y=v_U_1_2.x*(y-point_l_1.y)
-      //得到(point_l_2.x-x)*v_U_2_3.y=v_U_2_3.x*(point_l_2.y-y)
-      //可以求出坐边的交点(x,y)，即控制点
       var point_C_l = calculateIntersection(v_U_1_2, v_U_2_3, point_l_1, point_l_2);
       var point_C_r = calculateIntersection(v_U_1_2, v_U_2_3, point_r_1, point_r_2);
-      //定义中间的控制点
       var point_C_l_c = void 0;
       var point_C_r_c = void 0;
       if (j == 0) {
-        //记录下箭头尾部的左右两个端点
         point_t_l = point_l_1;
         point_t_r = point_r_1;
-        //计算第一个曲线控制点
         point_C_l_c = {
           x: (point_t_l.x + point_C_l.x) / 2,
           y: (point_t_l.y + point_C_l.y) / 2
@@ -225,14 +129,11 @@ function calculateMorePoints(anchorpoints) {
           x: (point_t_r.x + point_C_r.x) / 2,
           y: (point_t_r.y + point_C_r.y) / 2
         };
-        //添加两个拐角控制点中间的中间控制点
         points_C_l.push(point_C_l_c);
         points_C_r.push(point_C_r_c);
       } else {
-        //获取前一个拐角控制点
         var point_C_l_q = points_C_l[points_C_l.length - 1];
         var point_C_r_q = points_C_r[points_C_r.length - 1];
-        //计算两个拐角之间的中心控制点
         point_C_l_c = {
           x: (point_C_l_q.x + point_C_l.x) / 2,
           y: (point_C_l_q.y + point_C_l.y) / 2
@@ -241,28 +142,21 @@ function calculateMorePoints(anchorpoints) {
           x: (point_C_r_q.x + point_C_r.x) / 2,
           y: (point_C_r_q.y + point_C_r.y) / 2
         };
-        //添加两个拐角控制点中间的中间控制点
         points_C_l.push(point_C_l_c);
         points_C_r.push(point_C_r_c);
       }
-      //添加后面的拐角控制点
       points_C_l.push(point_C_l);
       points_C_r.push(point_C_r);
     }
-    //计算
-    //进入计算头部
-    //计算一下头部的长度
-    var pointU_E2 = anchorpoints[anchorpoints.length - 2]; //倒数第二个用户点
-    var pointU_E1 = anchorpoints[anchorpoints.length - 1]; //最后一个用户点
+    var pointU_E2 = anchorpoints[anchorpoints.length - 2];
+    var pointU_E1 = anchorpoints[anchorpoints.length - 1];
     var v_U_E2_E1 = {
       x: pointU_E1.x - pointU_E2.x,
       y: pointU_E1.y - pointU_E2.y
     };
     var head_d = Math.sqrt(v_U_E2_E1.x * v_U_E2_E1.x + v_U_E2_E1.y * v_U_E2_E1.y);
-    //定义头部的左右两结束点
     var point_h_l;
     var point_h_r;
-    //头部左右两向量数组
     var v_lr_h = [];
     var v_l_h = {
       x: undefined,
@@ -272,7 +166,6 @@ function calculateMorePoints(anchorpoints) {
       x: undefined,
       y: undefined
     };
-    //定义曲线最后一个控制点，也就是头部结束点和最后一个拐角点的中点
     var point_C_l_e = {
       x: undefined,
       y: undefined
@@ -281,7 +174,6 @@ function calculateMorePoints(anchorpoints) {
       x: undefined,
       y: undefined
     };
-    //定义三角形的左右两个点
     var point_triangle_l = {
       x: undefined,
       y: undefined
@@ -290,15 +182,12 @@ function calculateMorePoints(anchorpoints) {
       x: undefined,
       y: undefined
     };
-    //获取当前的最后的控制点，也就是之前计算的拐角点
     var point_C_l_eq = points_C_l[points_C_l.length - 1];
     var point_C_r_eq = points_C_r[points_C_r.length - 1];
-    //三角的高度都不够
     if (head_d <= w) {
       v_lr_h = calculateVector(v_U_E2_E1, Math.PI / 2, w / 2);
       v_l_h = v_lr_h[0];
       v_r_h = v_lr_h[1];
-      //获取头部的左右两结束点
       point_h_l = {
         x: pointU_E2.x + v_l_h.x,
         y: pointU_E2.y + v_l_h.y
@@ -307,7 +196,6 @@ function calculateMorePoints(anchorpoints) {
         x: pointU_E2.x + v_r_h.x,
         y: pointU_E2.y + v_r_h.y
       };
-      //计算最后的控制点
       point_C_l_e = {
         x: (point_C_l_eq.x + point_h_l.x) / 2,
         y: (point_C_l_eq.y + point_h_l.y) / 2
@@ -316,10 +204,8 @@ function calculateMorePoints(anchorpoints) {
         x: (point_C_r_eq.x + point_h_r.x) / 2,
         y: (point_C_r_eq.y + point_h_r.y) / 2
       };
-      //添加最后的控制点（中心点）
       points_C_l.push(point_C_l_e);
       points_C_r.push(point_C_r_e);
-      //计算三角形的左右两点
       point_triangle_l = {
         x: 2 * point_h_l.x - pointU_E2.x,
         y: 2 * point_h_l.y - pointU_E2.y
@@ -328,27 +214,19 @@ function calculateMorePoints(anchorpoints) {
         x: 2 * point_h_r.x - pointU_E2.x,
         y: 2 * point_h_r.y - pointU_E2.y
       };
-    }
-    //足够三角的高度
-    else {
-      //由于够了三角的高度，所以首先去掉三角的高度
-      //计算向量
+    } else {
       var v_E2_E1 = {
         x: pointU_E1.x - pointU_E2.x,
         y: pointU_E1.y - pointU_E2.y
       };
-      //取模
       var v_E2_E1_d = Math.sqrt(v_E2_E1.x * v_E2_E1.x + v_E2_E1.y * v_E2_E1.y);
-      //首先需要计算三角形的底部中心点
       var point_c = {
         x: pointU_E1.x - v_E2_E1.x * w / v_E2_E1_d,
         y: pointU_E1.y - v_E2_E1.y * w / v_E2_E1_d
       };
-      //计算出在三角形上底边上头部结束点
       v_lr_h = calculateVector(v_U_E2_E1, Math.PI / 2, w / 2);
       v_l_h = v_lr_h[0];
       v_r_h = v_lr_h[1];
-      //获取头部的左右两结束点
       point_h_l = {
         x: point_c.x + v_l_h.x,
         y: point_c.y + v_l_h.y
@@ -357,7 +235,6 @@ function calculateMorePoints(anchorpoints) {
         x: point_c.x + v_r_h.x,
         y: point_c.y + v_r_h.y
       };
-      //计算最后的控制点
       point_C_l_e = {
         x: (point_C_l_eq.x + point_h_l.x) / 2,
         y: (point_C_l_eq.y + point_h_l.y) / 2
@@ -366,10 +243,8 @@ function calculateMorePoints(anchorpoints) {
         x: (point_C_r_eq.x + point_h_r.x) / 2,
         y: (point_C_r_eq.y + point_h_r.y) / 2
       };
-      //添加最后的控制点（中心点）
       points_C_l.push(point_C_l_e);
       points_C_r.push(point_C_r_e);
-      //计算三角形的左右点
       point_triangle_l = {
         x: 2 * point_h_l.x - point_c.x,
         y: 2 * point_h_l.y - point_c.y
@@ -379,8 +254,6 @@ function calculateMorePoints(anchorpoints) {
         y: 2 * point_h_r.y - point_c.y
       };
     }
-    //使用控制点计算差值
-    //计算贝塞尔的控制点
     var points_BC_l = [],
       points_BC_r = [];
     for (var _i = 0; _i < points_C_l.length - 2; _i++) {
@@ -399,50 +272,39 @@ function calculateMorePoints(anchorpoints) {
       points_BC_l = points_BC_l.concat(points_temp_l);
       points_BC_r = points_BC_r.concat(points_temp_r);
     }
-    //组合左右点集和三角形三个点
     pointsR = [point_t_l];
-    //首先连接左边的差值曲线
     pointsR = pointsR.concat(points_BC_l);
-    //添加左边头部结束点
     pointsR.push(point_h_l);
-    //添加三角形左边点
     pointsR.push(point_triangle_l);
-    //添加三角形顶点
     pointsR.push(pointU_E1);
-    //添加三角形右边点
     pointsR.push(point_triangle_r);
-    //添加右边头部结束点
     pointsR.push(point_h_r);
-    //合并右边的所有点（先把右边的点倒序）
     pointsR = pointsR.concat(points_BC_r.reverse());
-
-    //添加右边尾部起始点
     pointsR.push(point_t_r);
   } else {
     pointsR = calculateTwoPoints(anchorpoints);
   }
   return pointsR;
 }
+
 /**
- * 绘制直角箭头相关
- * @param anchorpoints
- * @param type 1-平尾直角；2-燕尾直角
- * @returns
+ * 构建双点控制下的基础箭头骨架。
+ * type: 1-平尾直角箭头，2-燕尾直角箭头。
  */
 function calculateTwoPoints(anchorpoints) {
   var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
   var ratio = 6;
-  var pointS = anchorpoints[0]; //箭头起点
-  var pointE = anchorpoints[1]; //箭头终点
+  var pointS = anchorpoints[0];
+  var pointE = anchorpoints[1];
   var controlPois = [];
   var v_based = {
     x: pointE.x - pointS.x,
     y: pointE.y - pointS.y
-  }; //计算基准向量
-  var l = Math.sqrt((pointE.x - pointS.x) * (pointE.x - pointS.x) + (pointE.y - pointS.y) * (pointE.y - pointS.y)); //计算箭头长度
-  var w = l / ratio; //箭头宽度
-  var x_ = pointS.x + 5 * (pointE.x - pointS.x) / ratio; //箭头前端三角形中点坐标x
-  var y_ = pointS.y + 5 * (pointE.y - pointS.y) / ratio; //箭头前端三角形中点坐标y
+  };
+  var l = Math.sqrt((pointE.x - pointS.x) * (pointE.x - pointS.x) + (pointE.y - pointS.y) * (pointE.y - pointS.y));
+  var w = l / ratio;
+  var x_ = pointS.x + 5 * (pointE.x - pointS.x) / ratio;
+  var y_ = pointS.y + 5 * (pointE.y - pointS.y) / ratio;
   var v_lr = calculateVector(v_based, Math.PI / 2, w / 2);
   var v_l = v_lr[0];
   var v_r = v_lr[1];
@@ -490,6 +352,10 @@ function calculateTwoPoints(anchorpoints) {
   }
   return controlPois;
 }
+
+/**
+ * 计算向量左右两侧的偏移向量。
+ */
 function calculateVector(v, theta, d) {
   if (!theta) theta = Math.PI / 2;
   if (!d) d = 1;
@@ -549,6 +415,10 @@ function calculateVector(v, theta, d) {
   }
   return [v_l, v_r];
 }
+
+/**
+ * 计算两条方向线的交点。
+ */
 function calculateIntersection(v_1, v_2, point1, point2) {
   var x;
   var y;
@@ -561,7 +431,6 @@ function calculateIntersection(v_1, v_2, point1, point2) {
       y = point2.y;
     }
   } else {
-    //
     x = (v_1.x * v_2.x * (point2.y - point1.y) + point1.x * v_1.y * v_2.x - point2.x * v_2.y * v_1.x) / (v_1.y * v_2.x - v_1.x * v_2.y);
     if (v_1.x != 0) {
       y = (x - point1.x) * v_1.y / v_1.x + point1.y;
@@ -576,19 +445,15 @@ function calculateIntersection(v_1, v_2, point1, point2) {
 }
 
 /**
- * 计算贝塞尔曲线特征点
- * @param anchorpoints
- * @param t
- * @returns -  {{x: number, y: number}}
- * @private
+ * 计算贝塞尔曲线参数点。
  */
 var computeBezierPoints = function computeBezierPoints(anchorpoints, t) {
   var x = 0,
     y = 0;
-  var Binomial_coefficient = computeBinomial(anchorpoints);
+  var binomialCoefficient = computeBinomial(anchorpoints);
   for (var j = 0; j < anchorpoints.length; j++) {
     var tempPoint = anchorpoints[j];
-    var coefficient = Math.pow(1 - t, anchorpoints.length - 1 - j) * Math.pow(t, j) * Binomial_coefficient[j];
+    var coefficient = Math.pow(1 - t, anchorpoints.length - 1 - j) * Math.pow(t, j) * binomialCoefficient[j];
     x += tempPoint.x * coefficient;
     y += tempPoint.y * coefficient;
   }
@@ -597,16 +462,14 @@ var computeBezierPoints = function computeBezierPoints(anchorpoints, t) {
     y: y
   };
 };
+
 /**
- * 计算二项式系数
- * @param anchorpoints
- * @returns - {Array}
- * @private
+ * 计算贝塞尔曲线的二项式系数。
  */
 var computeBinomial = function computeBinomial(anchorpoints) {
   var lens = anchorpoints.length;
-  var Binomial_coefficient = [];
-  Binomial_coefficient.push(1);
+  var binomialCoefficient = [];
+  binomialCoefficient.push(1);
   for (var k = 1; k < lens - 1; k++) {
     var cs = 1,
       bcs = 1;
@@ -614,24 +477,21 @@ var computeBinomial = function computeBinomial(anchorpoints) {
       cs = cs * (lens - 1 - m);
       bcs = bcs * (k - m);
     }
-    Binomial_coefficient.push(cs / bcs);
+    binomialCoefficient.push(cs / bcs);
   }
-  Binomial_coefficient.push(1);
-  return Binomial_coefficient;
+  binomialCoefficient.push(1);
+  return binomialCoefficient;
 };
 
 /**
- * 获取椭圆和圆形的轴长
- * @param points
- * @returns
+ * 计算圆/椭圆的半长轴长度。
  */
 var getSemiAxis = function getSemiAxis(points) {
   return points.length === 2 ? Cesium.Cartesian3.distance(points[0], points[1]) : 0;
 };
+
 /**
- * 获取椭圆旋转的角度
- * @param points
- * @returns
+ * 计算椭圆长轴相对正北方向的旋转角。
  */
 var getEllipticAngle = function getEllipticAngle(points) {
   var p1 = transformCartesianToWGS84(points[0]);
@@ -641,21 +501,8 @@ var getEllipticAngle = function getEllipticAngle(points) {
 };
 
 /**
- * 获取矩形顶点
- * @param points
- * @returns
- */
-var calculateRectanglePoints = function calculateRectanglePoints(points) {
-  var p1 = transformCartesianToWGS84(points[0]);
-  var p2 = points[1] ? transformCartesianToWGS84(points[1]) : p1;
-  return Cesium.Cartesian3.fromDegreesArray([p1.x, p1.y, p2.x, p1.y, p2.x, p2.y, p1.x, p2.y]);
-};
-
-/**
- * 计算集结地特征点
- * @param anchorpoints
- * @returns {Array}
- * @private
+ * 计算集结地面的闭合曲线顶点。
+ * 返回值为经纬高扁平数组：[lng, lat, 0, ...]。
  */
 var computeAssemblePoints = function computeAssemblePoints(anchorpoints) {
   var points = [];
@@ -704,40 +551,26 @@ var computeAssemblePoints = function computeAssemblePoints(anchorpoints) {
   }
   return result;
 };
+
 /**
- * 生成闭合的样条点
- * @param points
- * @returns {*}
+ * 为闭合形状生成 Cardinal 样条控制点。
  */
 function createCloseCardinal(points) {
   if (points == null || points.length < 3) {
     return points;
   }
-  //获取起点，作为终点，以闭合曲线。
   var lastP = points[0];
   points.push(lastP);
-  //定义传入的点数组，将在点数组中央（每两个点）插入两个控制点
   var cPoints = points;
-  //包含输入点和控制点的数组
   var cardinalPoints = [];
-  //至少三个点以上
-  //这些都是相关资料测出的经验数值
-  //定义张力系数，取值在0<t<0.5
   var t = 0.4;
-  //为端点张力系数因子，取值在0<b<1
-  // let b = 0.5;
-  //误差控制，是一个大于等于0的数，用于三点非常趋近与一条直线时，减少计算量
   var e = 0.005;
-  //传入的点数量，至少有三个，n至少为2
   var n = cPoints.length - 1;
-  //从开始遍历到倒数第二个，其中倒数第二个用于计算起点（终点）的插值控制点
   for (var k = 0; k <= n - 1; k++) {
     var p0 = void 0,
       p1 = void 0,
       p2 = void 0;
-    //计算起点（终点）的左右控制点
     if (k == n - 1) {
-      //三个基础输入点
       p0 = cPoints[n - 1];
       p1 = cPoints[0];
       p2 = cPoints[1];
@@ -746,7 +579,6 @@ function createCloseCardinal(points) {
       p1 = cPoints[k + 1];
       p2 = cPoints[k + 2];
     }
-    //定义p1的左控制点和右控制点
     var p1l = {
       x: undefined,
       y: undefined
@@ -755,8 +587,6 @@ function createCloseCardinal(points) {
       x: undefined,
       y: undefined
     };
-    //通过p0、p1、p2计算p1点的做控制点p1l和又控制点p1r
-    //计算向量p0_p1和p1_p2
     var p0_p1 = {
       x: p1.x - p0.x,
       y: p1.y - p0.y
@@ -765,10 +595,8 @@ function createCloseCardinal(points) {
       x: p2.x - p1.x,
       y: p2.y - p1.y
     };
-    //并计算模
     var d01 = Math.sqrt(p0_p1.x * p0_p1.x + p0_p1.y * p0_p1.y);
     var d12 = Math.sqrt(p1_p2.x * p1_p2.x + p1_p2.y * p1_p2.y);
-    //向量单位化
     var p0_p1_1 = {
       x: p0_p1.x / d01,
       y: p0_p1.y / d01
@@ -777,46 +605,33 @@ function createCloseCardinal(points) {
       x: p1_p2.x / d12,
       y: p1_p2.y / d12
     };
-    //计算向量p0_p1和p1_p2的夹角平分线向量
     var p0_p1_p2 = {
       x: p0_p1_1.x + p1_p2_1.x,
       y: p0_p1_1.y + p1_p2_1.y
     };
-    //计算向量 p0_p1_p2 的模
     var d012 = Math.sqrt(p0_p1_p2.x * p0_p1_p2.x + p0_p1_p2.y * p0_p1_p2.y);
-    //单位化向量p0_p1_p2
     var p0_p1_p2_1 = {
       x: p0_p1_p2.x / d012,
       y: p0_p1_p2.y / d012
     };
-    //判断p0、p1、p2是否共线，这里判定向量p0_p1和p1_p2的夹角的余弦和1的差值小于e就认为三点共线
     var cosE_p0p1p2 = (p0_p1_1.x * p1_p2_1.x + p0_p1_1.y * p1_p2_1.y) / 1;
-    //共线
     if (Math.abs(1 - cosE_p0p1p2) < e) {
-      //计算p1l的坐标
       p1l.x = p1.x - p1_p2_1.x * d01 * t;
       p1l.y = p1.y - p1_p2_1.y * d01 * t;
-      //计算p1r的坐标
       p1r.x = p1.x + p0_p1_1.x * d12 * t;
       p1r.y = p1.y + p0_p1_1.y * d12 * t;
-    }
-    //非共线
-    else {
-      //计算p1l的坐标
+    } else {
       p1l.x = p1.x - p0_p1_p2_1.x * d01 * t;
       p1l.y = p1.y - p0_p1_p2_1.y * d01 * t;
-      //计算p1r的坐标
       p1r.x = p1.x + p0_p1_p2_1.x * d12 * t;
       p1r.y = p1.y + p0_p1_p2_1.y * d12 * t;
     }
-    //记录起点（终点）的左右插值控制点及倒数第二个控制点
     if (k == n - 1) {
       cardinalPoints[0] = p1;
       cardinalPoints[1] = p1r;
       cardinalPoints[(n - 2) * 3 + 2 + 3] = p1l;
       cardinalPoints[(n - 2) * 3 + 2 + 4] = cPoints[n];
     } else {
-      //记录下这三个控制点
       cardinalPoints[k * 3 + 2 + 0] = p1l;
       cardinalPoints[k * 3 + 2 + 1] = p1;
       cardinalPoints[k * 3 + 2 + 2] = p1r;
@@ -824,32 +639,24 @@ function createCloseCardinal(points) {
   }
   return cardinalPoints;
 }
+
 /**
- * 计算三阶贝塞尔点
- * @param points
- * @param part
- * @returns {Array}
+ * 根据三次贝塞尔控制点插值生成闭合曲线点集。
  */
 function calculatePointsFBZ3(points, part) {
   if (!part) part = 20;
-  //获取待拆分的点
   var bezierPts = [];
   var scale = 0.05;
   if (part > 0) {
     scale = 1 / part;
   }
   for (var i = 0; i < points.length - 3;) {
-    //起始点
     var pointS = points[i];
-    //第一个控制点
     var pointC1 = points[i + 1];
-    //第二个控制点
     var pointC2 = points[i + 2];
-    //结束点
     var pointE = points[i + 3];
     bezierPts.push(pointS);
     for (var t = 0; t < 1;) {
-      //三次贝塞尔曲线公式
       var x = (1 - t) * (1 - t) * (1 - t) * pointS.x + 3 * t * (1 - t) * (1 - t) * pointC1.x + 3 * t * t * (1 - t) * pointC2.x + t * t * t * pointE.x;
       var y = (1 - t) * (1 - t) * (1 - t) * pointS.y + 3 * t * (1 - t) * (1 - t) * pointC1.y + 3 * t * t * (1 - t) * pointC2.y + t * t * t * pointE.y;
       var point = {
@@ -866,6 +673,11 @@ function calculatePointsFBZ3(points, part) {
   }
   return bezierPts;
 }
+
+/**
+ * 统一计算燕尾/直线箭头顶点。
+ * type: 1-燕尾箭头，2-燕尾箭头变体，3-直线箭头。
+ */
 var calculateSwallowPoints = function calculateSwallowPoints(anchorpoints, type) {
   var points = [];
   switch (type) {
@@ -882,11 +694,9 @@ var calculateSwallowPoints = function calculateSwallowPoints(anchorpoints, type)
   }
   return points;
 };
+
 /**
- * 计算燕尾箭头特征点
- * @param anchorpoints
- * @returns {number[]}
- * @private
+ * 计算标准燕尾箭头或直线箭头的经纬高扁平数组。
  */
 var computeSwallowtailArrow = function computeSwallowtailArrow(anchorpoints) {
   var swallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
@@ -935,16 +745,16 @@ var computeSwallowtailArrow = function computeSwallowtailArrow(anchorpoints) {
     x: xt - 0.85 / 3.2 * (y1 - yt),
     y: yt + 0.85 / 3.2 * (x1 - xt)
   };
-  var degress = [];
+  var degrees = [];
   for (var index = 0; index < ap.length; index++) {
     var ele = ap[index];
-    ele && degress.push(ele.x, ele.y, 0);
+    ele && degrees.push(ele.x, ele.y, 0);
   }
-  return degress;
+  return degrees;
 };
+
 /**
- * 计算燕尾箭头2特征点
- * @param anchorpoints
+ * 计算双点燕尾箭头变体的经纬高扁平数组。
  */
 var computeSwallowtailArrow2 = function computeSwallowtailArrow2(anchorpoints) {
   var p0 = transformCartesianToWGS84(anchorpoints[0]);
@@ -960,10 +770,9 @@ var computeSwallowtailArrow2 = function computeSwallowtailArrow2(anchorpoints) {
   });
   return degreesArray;
 };
+
 /**
- * 计算钳击箭头特征点
- * @param points
- * @returns
+ * 根据控制点计算钳击箭头面顶点。
  */
 var calculatePincerArrowPoint = function calculatePincerArrowPoint(points) {
   if (points.length < 3) return null;
@@ -978,150 +787,10 @@ var calculatePincerArrowPoint = function calculatePincerArrowPoint(points) {
   if (index == -1) result = res.polygonalPoint;
   return result;
 };
-var calculateFlagPoints = function calculateFlagPoints(points) {
-  var _ref;
-  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var p0 = transformCartesianToWGS84(points[0]);
-  var p1 = points[1] ? transformCartesianToWGS84(points[1]) : {
-    x: p0.x + 0.00001,
-    y: p0.y + 0.00001,
-    z: p0.z
-  };
-  var pnts = [[p0.x, p0.y], [p1.x, p1.y]];
-  var arcArr = getFlagPoints(pnts, type);
-  return Cesium.Cartesian3.fromDegreesArray((_ref = []).concat.apply(_ref, _toConsumableArray(arcArr)));
-};
-/**
- *
- * @param {*} points
- * @param {*} type 0-曲线，1-直线，2-正三角，3-倒三角，4-对三角
- * @returns
- */
-function getFlagPoints(points) {
-  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  type = type ? type : 0;
-  var components = [];
-  // 至少需要两个控制点
-  if (points.length > 1) {
-    // 取第一个
-    var startPoint = points[0];
-    // 取最后一个
-    var endPoint = points[points.length - 1];
-    // 中间点
-    var pointCenter = [endPoint[0], (endPoint[1] - startPoint[1]) / 4 + startPoint[1]];
-    // 上曲线起始点
-    var point1 = startPoint;
-    // 上曲线第一控制点
-    var point2 = [(endPoint[0] - startPoint[0]) / 4 + startPoint[0], (endPoint[1] - startPoint[1]) / 8 + startPoint[1]];
-    // 上曲线第二个点
-    var point3 = [(startPoint[0] + endPoint[0]) / 2, startPoint[1]];
-    // 上曲线第二控制点
-    var point4 = [(endPoint[0] - startPoint[0]) * 3 / 4 + startPoint[0], -(endPoint[1] - startPoint[1]) / 8 + startPoint[1]];
-    // 上曲线结束点
-    var point5 = [endPoint[0], startPoint[1]];
-    // 下曲线结束点
-    var point6 = [endPoint[0], (startPoint[1] + endPoint[1]) / 2];
-    // 下曲线第二控制点
-    var point7 = [(endPoint[0] - startPoint[0]) * 3 / 4 + startPoint[0], (endPoint[1] - startPoint[1]) * 3 / 8 + startPoint[1]];
-    // 下曲线第二个点
-    var point8 = [(startPoint[0] + endPoint[0]) / 2, (startPoint[1] + endPoint[1]) / 2];
-    // 下曲线第一控制点
-    var point9 = [(endPoint[0] - startPoint[0]) / 4 + startPoint[0], (endPoint[1] - startPoint[1]) * 5 / 8 + startPoint[1]];
-    // 下曲线起始点
-    var point10 = [startPoint[0], (startPoint[1] + endPoint[1]) / 2];
-    // 旗杆底部点
-    var point11 = [startPoint[0], endPoint[1]];
-    // 底部左点
-    var point12 = [startPoint[0] - (endPoint[0] - startPoint[0]) / 30, endPoint[1]];
-    // 顶部左点
-    var point13 = [startPoint[0] - (endPoint[0] - startPoint[0]) / 30, startPoint[1]];
-    var curve1Points, curve2Points;
-    //type：0-曲线，1-直线，2-正三角，3-倒三角，4-对三角
-    switch (type) {
-      case 0:
-        curve1Points = [point1, point2, point3, point4, point5];
-        curve2Points = [point6, point7, point8, point9, point10, point10, point10, point10, point10];
-        break;
-      case 1:
-        curve1Points = [point1, point5];
-        curve2Points = [point6, point10, point10, point10, point10, point10];
-        break;
-      case 2:
-        curve1Points = [point1, point6];
-        curve2Points = [point6, point10, point10, point10, point10, point10];
-        break;
-      case 3:
-        curve1Points = [point1, point5];
-        curve2Points = [point5, point10, point10, point10, point10, point10];
-        break;
-      case 4:
-        curve1Points = [point1, pointCenter];
-        curve2Points = [pointCenter, point10, point10, point10, point10, point10];
-        break;
-    }
-    // 计算上曲线
-    var curveTop = getBezierPoints(curve1Points);
-    // 计算下曲线
-    var curveBottom = getBezierPoints(curve2Points);
-    // 合并
-    components = curveTop.concat(curveBottom);
-    components.push(point11, point12);
-    components.push(point13);
-  }
-  return components;
-}
-/**
- * 贝塞尔曲线
- * @param points
- * @returns {*}
- */
-function getBezierPoints(points) {
-  if (points.length <= 2) {
-    return points;
-  } else {
-    var bezierPoints = [];
-    var n = points.length - 1;
-    for (var t = 0; t <= 1; t += 0.01) {
-      var x = 0,
-        y = 0;
-      for (var index = 0; index <= n; index++) {
-        var factor = getBinomialFactor(n, index);
-        var a = Math.pow(t, index);
-        var b = Math.pow(1 - t, n - index);
-        x += factor * a * b * points[index][0];
-        y += factor * a * b * points[index][1];
-      }
-      bezierPoints.push([x, y]);
-    }
-    bezierPoints.push(points[n]);
-    return bezierPoints;
-  }
-}
-/**
- * 获取二项分布
- * @param n
- * @param index
- * @returns {number}
- */
-function getBinomialFactor(n, index) {
-  return getFactorial(n) / (getFactorial(index) * getFactorial(n - index));
-}
-/**
- * 获取阶乘数据
- * @param n
- * @returns {number}
- */
-function getFactorial(n) {
-  var result = 1;
-  for (var i = 1; i <= n; i++) {
-    result *= i;
-  }
-  return result;
-}
+
 /**
- * 计算并构建阵型过程点
- * @param {*} anchorpoints
- * @returns
+ * 根据两个控制点生成阵型折线点集。
+ * type: 0-防御阵型，1-进攻阵型。
  */
 var calculateFormationPoints = function calculateFormationPoints(anchorpoints, type) {
   var pos0 = transformCartesianToWGS84(anchorpoints[0]);
@@ -1135,13 +804,13 @@ var calculateFormationPoints = function calculateFormationPoints(anchorpoints, t
   var center = {
     x: centerX,
     y: centerY
-  }; //起点和终点的中间点坐标
-  var lectCartesian3 = Cesium.Cartesian3.fromDegrees(pos0.x, pos0.y);
+  };
+  var leftCartesian3 = Cesium.Cartesian3.fromDegrees(pos0.x, pos0.y);
   var rightCartesian3 = Cesium.Cartesian3.fromDegrees(pos1.x, pos1.y);
-  var diameter = Cesium.Cartesian3.distance(lectCartesian3, rightCartesian3); //起终点距离，单位m
-  var radius = diameter / 2; //半径
-  var angle = calculateAngle(center, pos1); //中点指向终点的角度，0-360
-  var sourcePos = getPointByAngleDistance(center.x, center.y, 90 + angle, radius); //获取模拟的圆心坐标
+  var diameter = Cesium.Cartesian3.distance(leftCartesian3, rightCartesian3);
+  var radius = diameter / 2;
+  var angle = calculateAngle(center, pos1);
+  var sourcePos = getPointByAngleDistance(center.x, center.y, 90 + angle, radius);
   var angle_left = calculateAngle(sourcePos, pos0);
   var circleRadius = Math.pow(2, 0.5) * radius;
   var points = [];
@@ -1171,10 +840,9 @@ var calculateFormationPoints = function calculateFormationPoints(anchorpoints, t
   });
   return Cesium.Cartesian3.fromDegreesArray(resultPos);
 };
+
 /**
- * 计算并构建弓形过程点
- * @param {*} anchorpoints
- * @returns
+ * 根据两个控制点生成弓形折线点集。
  */
 var calculateBowPoints = function calculateBowPoints(anchorpoints) {
   var pos0 = transformCartesianToWGS84(anchorpoints[0]);
@@ -1188,13 +856,13 @@ var calculateBowPoints = function calculateBowPoints(anchorpoints) {
   var center = {
     x: centerX,
     y: centerY
-  }; //起点和终点的中间点坐标
-  var lectCartesian3 = Cesium.Cartesian3.fromDegrees(pos0.x, pos0.y);
+  };
+  var leftCartesian3 = Cesium.Cartesian3.fromDegrees(pos0.x, pos0.y);
   var rightCartesian3 = Cesium.Cartesian3.fromDegrees(pos1.x, pos1.y);
-  var diameter = Cesium.Cartesian3.distance(lectCartesian3, rightCartesian3); //起终点距离，单位m
-  var radius = diameter / 2; //半径
-  var angle = calculateAngle(center, pos1); //中点指向终点的角度，0-360
-  var sourcePos = getPointByAngleDistance(center.x, center.y, 90 + angle, radius); //获取模拟的圆心坐标
+  var diameter = Cesium.Cartesian3.distance(leftCartesian3, rightCartesian3);
+  var radius = diameter / 2;
+  var angle = calculateAngle(center, pos1);
+  var sourcePos = getPointByAngleDistance(center.x, center.y, 90 + angle, radius);
   var angle_left = calculateAngle(sourcePos, pos0);
   var circleRadius = Math.pow(2, 0.5) * radius;
   var points = [];
@@ -1212,19 +880,15 @@ var calculateBowPoints = function calculateBowPoints(anchorpoints) {
   });
   return Cesium.Cartesian3.fromDegreesArray(resultPos);
 };
+
 /**
- * 已知点根据角度和距离求取另一点坐标（二维）  注：WGS84坐标系
- * @param {*} lng 经度
- * @param {*} lat 纬度
- * @param {*} angle 角度 (0~360度)
- * @param {*} distance 距离 (米)
- *
+ * 已知起点经纬度、角度与距离，反解目标点经纬度。
+ * 这里采用 WGS84 椭球近似计算，供弓形、阵型、扇形等算法复用。
  */
 function getPointByAngleDistance(lng, lat, angle, distance) {
-  var a = 6378137; // 赤道半径
-  var b = 6356752.3142; // 短半径
-  var f = 1 / 298.257223563; // 扁率
-
+  var a = 6378137;
+  var b = 6356752.3142;
+  var f = 1 / 298.257223563;
   var alpha1 = angle * (Math.PI / 180);
   var sinAlpha1 = Math.sin(alpha1);
   var cosAlpha1 = Math.cos(alpha1);
@@ -1260,112 +924,10 @@ function getPointByAngleDistance(lng, lat, angle, distance) {
     y: lat2 * (180 / Math.PI)
   };
 }
+
 /**
- * 计算圆角矩形节点
- * @param anchor
- * @returns
+ * 根据圆心、半径点、终止角方向点生成扇形顶点。
  */
-var computeRoundedRectanglePoints = function computeRoundedRectanglePoints(anchorpoints) {
-  var pos0 = transformCartesianToWGS84(anchorpoints[0]);
-  var pos1 = anchorpoints[1] ? transformCartesianToWGS84(anchorpoints[1]) : {
-    x: pos0.x + 0.00001,
-    y: pos0.y + 0.00001,
-    z: pos0.z
-  };
-  var o_x = (pos0.x + pos1.x) / 2;
-  var o_y = (pos0.y + pos1.y) / 2;
-  //a为矩形的长边，b为矩形的短边
-  var a = Math.abs(pos0.x - pos1.x);
-  var b = Math.abs(pos0.y - pos1.y);
-  var r = 1 / 10 * Math.min(a, b);
-  //从左上点开始，顺时针求四个圆弧的圆心
-  var o1_x = o_x - a / 2 + r;
-  var o1_y = o_y - b / 2 + r;
-  var o1 = {
-    x: o1_x,
-    y: o1_y
-  };
-  var o2 = {
-    x: o_x + a / 2 - r,
-    y: o_y - b / 2 + r
-  };
-  var o3 = {
-    x: o_x + a / 2 - r,
-    y: o_y + b / 2 - r
-  };
-  var o4 = {
-    x: o_x - a / 2 + r,
-    y: o_y + b / 2 - r
-  };
-  //从左上角开始画圆弧
-  var step = Math.PI / 180;
-  var points1 = [];
-  var theta1 = Math.PI;
-  var theta2 = 3 / 2 * Math.PI;
-  var radius1 = theta1;
-  for (var i = 0; i < Math.abs(theta1 - theta2); i += step) {
-    var X = o1.x + r * Math.cos(radius1);
-    var Y = o1.y + r * Math.sin(radius1);
-    radius1 = radius1 + step;
-    radius1 = radius1 < 0 ? 2 * Math.PI + radius1 : radius1;
-    radius1 = radius1 > 2 * Math.PI ? 2 * Math.PI - radius1 : radius1;
-    points1.push({
-      x: X,
-      y: Y
-    });
-  }
-  var points2 = points1;
-  var theta3 = Math.PI * 3 / 2;
-  var theta4 = 2 * Math.PI;
-  var radius2 = theta3;
-  for (var _i2 = 0; _i2 < Math.abs(theta3 - theta4); _i2 += step) {
-    var _X = o2.x + r * Math.cos(radius2);
-    var _Y = o2.y + r * Math.sin(radius2);
-    radius2 = radius2 + step;
-    radius2 = radius2 < 0 ? 2 * Math.PI + radius2 : radius2;
-    radius2 = radius2 > 2 * Math.PI ? 2 * Math.PI - radius2 : radius2;
-    points2.push({
-      x: _X,
-      y: _Y
-    });
-  }
-  var points3 = points2;
-  var theta5 = 0;
-  var theta6 = 1 / 2 * Math.PI;
-  var radius3 = theta5;
-  for (var _i3 = 0; _i3 < Math.abs(theta5 - theta6); _i3 += step) {
-    var _X2 = o3.x + r * Math.cos(radius3);
-    var _Y2 = o3.y + r * Math.sin(radius3);
-    radius3 = radius3 + step;
-    radius3 = radius3 < 0 ? 2 * Math.PI + radius3 : radius3;
-    radius3 = radius3 > 2 * Math.PI ? 2 * Math.PI - radius3 : radius3;
-    points3.push({
-      x: _X2,
-      y: _Y2
-    });
-  }
-  var points = points3;
-  var theta7 = 1 / 2 * Math.PI;
-  var theta8 = Math.PI;
-  var radius4 = theta7;
-  for (var _i4 = 0; _i4 < Math.abs(theta7 - theta8); _i4 += step) {
-    var _X3 = o4.x + r * Math.cos(radius4);
-    var _Y3 = o4.y + r * Math.sin(radius4);
-    radius4 = radius4 + step;
-    radius4 = radius4 < 0 ? 2 * Math.PI + radius4 : radius4;
-    radius4 = radius4 > 2 * Math.PI ? 2 * Math.PI - radius4 : radius4;
-    points.push({
-      x: _X3,
-      y: _Y3
-    });
-  }
-  var GeoPoints = [];
-  points.forEach(function (item) {
-    GeoPoints.push(item.x, item.y, 0);
-  });
-  var result = Cesium.Cartesian3.fromDegreesArrayHeights(GeoPoints);
-  return result;
-};
 var calculateSectorPoints = function calculateSectorPoints(points) {
   var pos0 = transformCartesianToWGS84(points[0]);
   pos0.z = 0;
@@ -1382,15 +944,11 @@ var calculateSectorPoints = function calculateSectorPoints(points) {
   };
   var startAngle = calculateAngle(pos0, pos1);
   var endAngle = calculateAngle(pos0, pos2);
-  // // 将角度转换为弧度
   var startAngleRad = Math.min(startAngle, endAngle);
   var endAngleRad = Math.max(startAngle, endAngle);
-  // 获取扇形的所有坐标值
   var coordinates = [];
-  coordinates.push(pos0.x, pos0.y); // 扇形中心坐标
-
-  // 扇形边界点坐标
-  var numPoints = 100; // 分割圆弧的点数，可以根据需要调整
+  coordinates.push(pos0.x, pos0.y);
+  var numPoints = 100;
   var angleStep = (endAngleRad - startAngleRad) / numPoints;
   for (var i = 0; i <= numPoints; i++) {
     var angle = startAngleRad + i * angleStep;
@@ -1400,13 +958,8 @@ var calculateSectorPoints = function calculateSectorPoints(points) {
   coordinates.push(pos0.x, pos0.y);
   return Cesium.Cartesian3.fromDegreesArray(coordinates);
 };
-var getLabelText = function getLabelText(text, type) {
-  var textArr = type ? text.split(' ') : text.split('\\n');
-  var result = '';
-  for (var index = 0; index < textArr.length; index++) {
-    var element = textArr[index];
-    result += index === 0 ? element : '\n ' + element;
-  }
-  return result;
-};
-export { calculateBowPoints, calculateFlagPoints, calculateFormationPoints, calculatePincerArrowPoint, calculateRectanglePoints, calculateSectorPoints, calculateSwallowPoints, computeAssemblePoints, computeRoundedRectanglePoints, createBezierPoints, getAttackArrowPoints, getEllipticAngle, getLabelText, getRegularPoints, getRightAngleArrowPoints, getSemiAxis, lockingMap, newSessionid };
+
+/**
+ * 对外暴露给 drawer/shape 的最小算法集合。
+ */
+export { calculateBowPoints, calculateFormationPoints, calculatePincerArrowPoint, calculateSectorPoints, calculateSwallowPoints, computeAssemblePoints, createBezierPoints, getAttackArrowPoints, getEllipticAngle, getPointByAngleDistance, getRightAngleArrowPoints, getSemiAxis };