deeptwins-engine-3d 0.1.32 → 0.1.34

package/dist/esm/plot/utils/PlotCommon.js

@@ -0,0 +1,1412 @@
+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;
+// };
+
+/**
+ * 创建随机（唯一）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
+ */
+var createBezierPoints = function createBezierPoints(anchorpoints) {
+  var degrees = [];
+  for (var index = 0; index < anchorpoints.length; index++) {
+    var degree = transformCartesianToWGS84(anchorpoints[index]);
+    degrees.push(degree);
+  }
+  var numpoints = 100;
+  var points = [];
+  for (var i = 0; i <= numpoints; i++) {
+    var point = computeBezierPoints(degrees, i / numpoints);
+    var cartesian = transformWGS84ToCartesian(point);
+    points.push(cartesian);
+  }
+  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 = [];
+  for (var i = 0; i < positions.length; i++) {
+    var lnglat = transformCartesianToWGS84(positions[i]);
+    lnglatArr.push([lnglat.x, lnglat.y]);
+  }
+  var res = xp.algorithm.tailedAttackArrow(lnglatArr);
+  var index = JSON.stringify(res.polygonalPoint).indexOf('null');
+  var points = [];
+  if (index == -1) points = res.polygonalPoint;
+  return points;
+};
+
+/**
+ * 创建直角箭头节点
+ * @param anchorpoints
+ * @returns
+ */
+var getRightAngleArrowPoints = function getRightAngleArrowPoints(anchorpoints) {
+  var degreePoints = [];
+  for (var index = 0; index < anchorpoints.length; index++) {
+    var degree = transformCartesianToWGS84(anchorpoints[index]);
+    degreePoints.push(degree);
+  }
+  var pointlist = calculateMorePoints(degreePoints);
+  var degreesArray = [];
+  pointlist.forEach(function (item) {
+    degreesArray.push(item.x, item.y);
+  });
+  return Cesium.Cartesian3.fromDegreesArray(degreesArray);
+};
+function calculateMorePoints(anchorpoints) {
+  var ratio = 6;
+  var pointsR;
+  if (anchorpoints.length > 2) {
+    var l = 0,
+      pointS,
+      pointE;
+    for (var i = 0; i < anchorpoints.length - 1; 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_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 v_U_1_2 = {
+        x: pointU_2.x - pointU_1.x,
+        y: pointU_2.y - pointU_1.y
+      };
+      var v_U_2_3 = {
+        x: pointU_3.x - pointU_2.x,
+        y: pointU_3.y - pointU_2.y
+      };
+      var v_lr_1_2 = calculateVector(v_U_1_2, Math.PI / 2, w / 2);
+      var v_l_1_2 = v_lr_1_2[0];
+      var v_r_1_2 = v_lr_1_2[1];
+      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)
+      };
+      var point_r_1 = {
+        x: pointU_1.x + (v_r_1_2 === null || v_r_1_2 === void 0 ? void 0 : v_r_1_2.x),
+        y: pointU_1.y + (v_r_1_2 === null || v_r_1_2 === void 0 ? void 0 : v_r_1_2.y)
+      };
+      var point_l_2 = {
+        x: pointU_2.x + (v_l_2_3 === null || v_l_2_3 === void 0 ? void 0 : v_l_2_3.x),
+        y: pointU_2.y + (v_l_2_3 === null || v_l_2_3 === void 0 ? void 0 : v_l_2_3.y)
+      };
+      var point_r_2 = {
+        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
+        };
+        point_C_r_c = {
+          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
+        };
+        point_C_r_c = {
+          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 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,
+      y: undefined
+    };
+    var v_r_h = {
+      x: undefined,
+      y: undefined
+    };
+    //定义曲线最后一个控制点，也就是头部结束点和最后一个拐角点的中点
+    var point_C_l_e = {
+      x: undefined,
+      y: undefined
+    };
+    var point_C_r_e = {
+      x: undefined,
+      y: undefined
+    };
+    //定义三角形的左右两个点
+    var point_triangle_l = {
+      x: undefined,
+      y: undefined
+    };
+    var point_triangle_r = {
+      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
+      };
+      point_h_r = {
+        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
+      };
+      point_C_r_e = {
+        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
+      };
+      point_triangle_r = {
+        x: 2 * point_h_r.x - pointU_E2.x,
+        y: 2 * point_h_r.y - pointU_E2.y
+      };
+    }
+    //足够三角的高度
+    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
+      };
+      point_h_r = {
+        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
+      };
+      point_C_r_e = {
+        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
+      };
+      point_triangle_r = {
+        x: 2 * point_h_r.x - point_c.x,
+        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++) {
+      var temp_l = [];
+      var temp_r = [];
+      var temp1_l = points_C_l[_i];
+      var temp2_l = points_C_l[_i + 1];
+      var temp3_l = points_C_l[_i + 2];
+      var temp1_r = points_C_r[_i];
+      var temp2_r = points_C_r[_i + 1];
+      var temp3_r = points_C_r[_i + 2];
+      temp_l.push(temp1_l, temp2_l, temp3_l);
+      temp_r.push(temp1_r, temp2_r, temp3_r);
+      var points_temp_l = createBezierPoints(temp_l);
+      var points_temp_r = createBezierPoints(temp_r);
+      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
+ */
+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 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 v_lr = calculateVector(v_based, Math.PI / 2, w / 2);
+  var v_l = v_lr[0];
+  var v_r = v_lr[1];
+  var point1 = {
+    x: pointS.x + (v_l === null || v_l === void 0 ? void 0 : v_l.x),
+    y: pointS.y + (v_l === null || v_l === void 0 ? void 0 : v_l.y)
+  };
+  var point2 = {
+    x: x_ + (v_l === null || v_l === void 0 ? void 0 : v_l.x),
+    y: y_ + (v_l === null || v_l === void 0 ? void 0 : v_l.y)
+  };
+  var point3 = {
+    x: x_ + 2 * (v_l === null || v_l === void 0 ? void 0 : v_l.x),
+    y: y_ + 2 * (v_l === null || v_l === void 0 ? void 0 : v_l.y)
+  };
+  var point4 = {
+    x: pointE.x,
+    y: pointE.y
+  };
+  var point5 = {
+    x: x_ + 2 * (v_r === null || v_r === void 0 ? void 0 : v_r.x),
+    y: y_ + 2 * (v_r === null || v_r === void 0 ? void 0 : v_r.y)
+  };
+  var point6 = {
+    x: x_ + (v_r === null || v_r === void 0 ? void 0 : v_r.x),
+    y: y_ + (v_r === null || v_r === void 0 ? void 0 : v_r.y)
+  };
+  var point7 = {
+    x: pointS.x + (v_r === null || v_r === void 0 ? void 0 : v_r.x),
+    y: pointS.y + (v_r === null || v_r === void 0 ? void 0 : v_r.y)
+  };
+  switch (type) {
+    case 1:
+      controlPois.push(point1, point2, point3, point4, point5, point6, point7);
+      break;
+    case 2:
+      var point8 = {
+        x: pointS.x + (pointE.x - pointS.x) / 10,
+        y: pointS.y + (pointE.y - pointS.y) / 10
+      };
+      controlPois.push(point1, point2, point3, point4, point5, point6, point7, point8);
+      break;
+    default:
+      break;
+  }
+  return controlPois;
+}
+function calculateVector(v, theta, d) {
+  if (!theta) theta = Math.PI / 2;
+  if (!d) d = 1;
+  var x_1;
+  var x_2;
+  var y_1;
+  var y_2;
+  var v_l;
+  var v_r;
+  var d_v = Math.sqrt(v.x * v.x + v.y * v.y);
+  if (v.y == 0) {
+    x_1 = x_2 = d_v * d * Math.cos(theta) / v.x;
+    if (v.x > 0) {
+      y_1 = Math.sqrt(d * d - x_1 * x_1);
+      y_2 = -y_1;
+    } else if (v.x < 0) {
+      y_2 = Math.sqrt(d * d - x_1 * x_1);
+      y_1 = -y_2;
+    }
+    v_l = {
+      x: x_1,
+      y: y_1
+    };
+    v_r = {
+      x: x_2,
+      y: y_2
+    };
+  } else {
+    var n = -v.x / v.y;
+    var m = d * d_v * Math.cos(theta) / v.y;
+    var a = 1 + n * n;
+    var b = 2 * n * m;
+    var c = m * m - d * d;
+    x_1 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);
+    x_2 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);
+    y_1 = n * x_1 + m;
+    y_2 = n * x_2 + m;
+    if (v.y >= 0) {
+      v_l = {
+        x: x_1,
+        y: y_1
+      };
+      v_r = {
+        x: x_2,
+        y: y_2
+      };
+    } else if (v.y < 0) {
+      v_l = {
+        x: x_2,
+        y: y_2
+      };
+      v_r = {
+        x: x_1,
+        y: y_1
+      };
+    }
+  }
+  return [v_l, v_r];
+}
+function calculateIntersection(v_1, v_2, point1, point2) {
+  var x;
+  var y;
+  if (v_1.y * v_2.x - v_1.x * v_2.y == 0) {
+    if (v_1.x * v_2.x > 0 || v_1.y * v_2.y > 0) {
+      x = (point1.x + point2.x) / 2;
+      y = (point1.y + point2.y) / 2;
+    } else {
+      x = point2.x;
+      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;
+    } else {
+      y = (x - point2.x) * v_2.y / v_2.x + point2.y;
+    }
+  }
+  return {
+    x: x,
+    y: y
+  };
+}
+
+/**
+ * 计算贝塞尔曲线特征点
+ * @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);
+  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];
+    x += tempPoint.x * coefficient;
+    y += tempPoint.y * coefficient;
+  }
+  return {
+    x: x,
+    y: y
+  };
+};
+/**
+ * 计算二项式系数
+ * @param anchorpoints
+ * @returns - {Array}
+ * @private
+ */
+var computeBinomial = function computeBinomial(anchorpoints) {
+  var lens = anchorpoints.length;
+  var Binomial_coefficient = [];
+  Binomial_coefficient.push(1);
+  for (var k = 1; k < lens - 1; k++) {
+    var cs = 1,
+      bcs = 1;
+    for (var m = 0; m < k; m++) {
+      cs = cs * (lens - 1 - m);
+      bcs = bcs * (k - m);
+    }
+    Binomial_coefficient.push(cs / bcs);
+  }
+  Binomial_coefficient.push(1);
+  return Binomial_coefficient;
+};
+
+/**
+ * 获取椭圆和圆形的轴长
+ * @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]);
+  var p2 = transformCartesianToWGS84(points[1]);
+  var angle = 450 - calculateAngle(p1, p2);
+  return Cesium.Math.toRadians(angle);
+};
+
+/**
+ * 获取矩形顶点
+ * @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
+ */
+var computeAssemblePoints = function computeAssemblePoints(anchorpoints) {
+  var points = [];
+  var originP = transformCartesianToWGS84(anchorpoints[0]);
+  var lastP = anchorpoints[1] ? transformCartesianToWGS84(anchorpoints[1]) : {
+    x: originP.x + 0.00001,
+    y: originP.y + 0.00001,
+    z: originP.z
+  };
+  var vectorOL = {
+    x: lastP.x - originP.x,
+    y: lastP.y - originP.y
+  };
+  var dOL = Math.sqrt(vectorOL.x * vectorOL.x + vectorOL.y * vectorOL.y);
+  var v_O_P1_lr = calculateVector(vectorOL, Math.PI / 3, Math.sqrt(3) / 12 * dOL);
+  var originP_P1 = v_O_P1_lr[1];
+  var p1 = {
+    x: originP.x + (originP_P1 === null || originP_P1 === void 0 ? void 0 : originP_P1.x),
+    y: originP.y + (originP_P1 === null || originP_P1 === void 0 ? void 0 : originP_P1.y)
+  };
+  var p2 = {
+    x: (originP.x + lastP.x) / 2,
+    y: (originP.y + lastP.y) / 2
+  };
+  var v_L_P3_lr = calculateVector(vectorOL, Math.PI * 2 / 3, Math.sqrt(3) / 12 * dOL);
+  var lastP_P3 = v_L_P3_lr[1];
+  var p3 = {
+    x: lastP.x + lastP_P3.x,
+    y: lastP.y + lastP_P3.y
+  };
+  var v_O_P5_lr = calculateVector(vectorOL, Math.PI / 2, 1 / 2 * dOL);
+  var v_O_P5 = v_O_P5_lr[0];
+  var p5 = {
+    x: v_O_P5.x + p2.x,
+    y: v_O_P5.y + p2.y
+  };
+  var p0 = originP;
+  var p4 = lastP;
+  points.push(p0, p1, p2, p3, p4, p5);
+  var closeCardinal = createCloseCardinal(points);
+  var fb_points = calculatePointsFBZ3(closeCardinal, 100);
+  var result = [];
+  for (var index = 0; index < fb_points.length; index++) {
+    var ele = fb_points[index];
+    result.push(ele.x, ele.y, 0);
+  }
+  return result;
+};
+/**
+ * 生成闭合的样条点
+ * @param points
+ * @returns {*}
+ */
+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];
+    } else {
+      p0 = cPoints[k];
+      p1 = cPoints[k + 1];
+      p2 = cPoints[k + 2];
+    }
+    //定义p1的左控制点和右控制点
+    var p1l = {
+      x: undefined,
+      y: undefined
+    };
+    var p1r = {
+      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
+    };
+    var p1_p2 = {
+      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
+    };
+    var p1_p2_1 = {
+      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的坐标
+      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;
+    }
+  }
+  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 = {
+        x: x,
+        y: y
+      };
+      bezierPts.push(point);
+      t += scale;
+    }
+    i += 3;
+    if (i >= points.length) {
+      bezierPts.push(pointS);
+    }
+  }
+  return bezierPts;
+}
+var calculateSwallowPoints = function calculateSwallowPoints(anchorpoints, type) {
+  var points = [];
+  switch (type) {
+    case 1:
+      points = computeSwallowtailArrow(anchorpoints);
+      break;
+    case 2:
+      points = computeSwallowtailArrow2(anchorpoints);
+      break;
+    case 3:
+      points = computeSwallowtailArrow(anchorpoints, false);
+    default:
+      break;
+  }
+  return points;
+};
+/**
+ * 计算燕尾箭头特征点
+ * @param anchorpoints
+ * @returns {number[]}
+ * @private
+ */
+var computeSwallowtailArrow = function computeSwallowtailArrow(anchorpoints) {
+  var swallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var p0 = transformCartesianToWGS84(anchorpoints[0]);
+  var p1 = anchorpoints[1] ? transformCartesianToWGS84(anchorpoints[1]) : {
+    x: p0.x + 0.00001,
+    y: p0.y + 0.00001,
+    z: p0.z
+  };
+  var x0 = p0.x;
+  var y0 = p0.y;
+  var x1 = p1.x;
+  var y1 = p1.y;
+  var xt = (15.8 * x1 + 3.2 * x0) / 19;
+  var yt = (15.8 * y1 + 3.2 * y0) / 19;
+  var ap = new Array(7);
+  ap[0] = {
+    x: x1,
+    y: y1
+  };
+  ap[1] = {
+    x: xt + 0.85 / 3.2 * (y1 - yt),
+    y: yt - 0.85 / 3.2 * (x1 - xt)
+  };
+  ap[2] = {
+    x: xt + 0.25 / 3.2 * (y1 - yt),
+    y: yt - 0.25 / 3.2 * (x1 - xt)
+  };
+  ap[3] = {
+    x: x0 + 1.6 / 19 * (y1 - y0),
+    y: y0 - 1.6 / 19 * (x1 - x0)
+  };
+  ap[4] = swallow ? {
+    x: (3.2 * x1 + 15.8 * x0) / 19,
+    y: (3.2 * y1 + 15.8 * y0) / 19
+  } : undefined;
+  ap[5] = {
+    x: x0 - 1.6 / 19 * (y1 - y0),
+    y: y0 + 1.6 / 19 * (x1 - x0)
+  };
+  ap[6] = {
+    x: xt - 0.25 / 3.2 * (y1 - yt),
+    y: yt + 0.25 / 3.2 * (x1 - xt)
+  };
+  ap[7] = {
+    x: xt - 0.85 / 3.2 * (y1 - yt),
+    y: yt + 0.85 / 3.2 * (x1 - xt)
+  };
+  var degress = [];
+  for (var index = 0; index < ap.length; index++) {
+    var ele = ap[index];
+    ele && degress.push(ele.x, ele.y, 0);
+  }
+  return degress;
+};
+/**
+ * 计算燕尾箭头2特征点
+ * @param anchorpoints
+ */
+var computeSwallowtailArrow2 = function computeSwallowtailArrow2(anchorpoints) {
+  var p0 = transformCartesianToWGS84(anchorpoints[0]);
+  var p1 = anchorpoints[1] ? transformCartesianToWGS84(anchorpoints[1]) : {
+    x: p0.x + 0.00001,
+    y: p0.y + 0.00001,
+    z: p0.z
+  };
+  var pointlist = calculateTwoPoints([p0, p1], 2);
+  var degreesArray = [];
+  pointlist.forEach(function (item) {
+    degreesArray.push(item.x, item.y, 0);
+  });
+  return degreesArray;
+};
+/**
+ * 计算钳击箭头特征点
+ * @param points
+ * @returns
+ */
+var calculatePincerArrowPoint = function calculatePincerArrowPoint(points) {
+  if (points.length < 3) return null;
+  var lnglatArr = [];
+  for (var i = 0; i < points.length; i++) {
+    var degree = transformCartesianToWGS84(points[i]);
+    lnglatArr.push([degree.x, degree.y]);
+  }
+  var res = xp.algorithm.doubleArrow(lnglatArr);
+  var result = [];
+  var index = JSON.stringify(res.polygonalPoint).indexOf('null');
+  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
+ */
+var calculateFormationPoints = function calculateFormationPoints(anchorpoints, type) {
+  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 centerX = (pos0.x + pos1.x) / 2;
+  var centerY = (pos0.y + pos1.y) / 2;
+  var center = {
+    x: centerX,
+    y: centerY
+  }; //起点和终点的中间点坐标
+  var lectCartesian3 = 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 angle_left = calculateAngle(sourcePos, pos0);
+  var circleRadius = Math.pow(2, 0.5) * radius;
+  var points = [];
+  type = type === 0 ? 0.9 : 1.1;
+  for (var index = 0; index < 90; index++) {
+    var cur_angle = angle_left + index;
+    var cur_point = getPointByAngleDistance(sourcePos.x, sourcePos.y, cur_angle, circleRadius);
+    points.push({
+      x: cur_point.x,
+      y: cur_point.y
+    });
+    if (index != 0 && index % 15 == 0) {
+      var cur_point1 = getPointByAngleDistance(sourcePos.x, sourcePos.y, cur_angle, circleRadius * type);
+      points.push({
+        x: cur_point1.x,
+        y: cur_point1.y
+      });
+      points.push({
+        x: cur_point.x,
+        y: cur_point.y
+      });
+    }
+  }
+  var resultPos = [];
+  points.forEach(function (item) {
+    resultPos.push(item.x, item.y);
+  });
+  return Cesium.Cartesian3.fromDegreesArray(resultPos);
+};
+/**
+ * 计算并构建弓形过程点
+ * @param {*} anchorpoints
+ * @returns
+ */
+var calculateBowPoints = function calculateBowPoints(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 centerX = (pos0.x + pos1.x) / 2;
+  var centerY = (pos0.y + pos1.y) / 2;
+  var center = {
+    x: centerX,
+    y: centerY
+  }; //起点和终点的中间点坐标
+  var lectCartesian3 = 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 angle_left = calculateAngle(sourcePos, pos0);
+  var circleRadius = Math.pow(2, 0.5) * radius;
+  var points = [];
+  for (var index = 0; index < 90; index++) {
+    var cur_angle = angle_left + index;
+    var cur_point = getPointByAngleDistance(sourcePos.x, sourcePos.y, cur_angle, circleRadius);
+    points.push({
+      x: cur_point.x,
+      y: cur_point.y
+    });
+  }
+  var resultPos = [];
+  points.forEach(function (item) {
+    resultPos.push(item.x, item.y);
+  });
+  return Cesium.Cartesian3.fromDegreesArray(resultPos);
+};
+/**
+ * 已知点根据角度和距离求取另一点坐标（二维）  注：WGS84坐标系
+ * @param {*} lng 经度
+ * @param {*} lat 纬度
+ * @param {*} angle 角度 (0~360度)
+ * @param {*} distance 距离 (米)
+ *
+ */
+function getPointByAngleDistance(lng, lat, angle, distance) {
+  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);
+  var tanU1 = (1 - f) * Math.tan(lat * (Math.PI / 180));
+  var cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1),
+    sinU1 = tanU1 * cosU1;
+  var sigma1 = Math.atan2(tanU1, cosAlpha1);
+  var sinAlpha = cosU1 * sinAlpha1;
+  var cosSqAlpha = 1 - sinAlpha * sinAlpha;
+  var uSq = cosSqAlpha * (a * a - b * b) / (b * b);
+  var A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  var B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  var sigma = distance / (b * A),
+    sigmaP = 2 * Math.PI;
+  var cos2SigmaM;
+  var sinSigma;
+  var cosSigma;
+  while (Math.abs(sigma - sigmaP) > 1e-12) {
+    cos2SigmaM = Math.cos(2 * sigma1 + sigma);
+    sinSigma = Math.sin(sigma);
+    cosSigma = Math.cos(sigma);
+    var deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+    sigmaP = sigma;
+    sigma = distance / (b * A) + deltaSigma;
+  }
+  var tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1;
+  var lat2 = Math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1, (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp));
+  var lambda = Math.atan2(sinSigma * sinAlpha1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1);
+  var C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
+  var L = lambda - (1 - C) * f * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+  return {
+    x: lng + L * (180 / Math.PI),
+    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;
+  var pos1 = points[1] ? transformCartesianToWGS84(points[1]) : {
+    x: pos0.x + 0.00001,
+    y: pos0.y,
+    z: 0
+  };
+  var distance = points[1] ? Cesium.Cartesian3.distance(points[0], points[1]) : 0.1;
+  var pos2 = points[2] ? transformCartesianToWGS84(points[2]) : {
+    x: pos1.x + 0.0000001,
+    y: pos1.y,
+    z: 0
+  };
+  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; // 分割圆弧的点数，可以根据需要调整
+  var angleStep = (endAngleRad - startAngleRad) / numPoints;
+  for (var i = 0; i <= numPoints; i++) {
+    var angle = startAngleRad + i * angleStep;
+    var point = getPointByAngleDistance(pos0.x, pos0.y, angle, distance);
+    coordinates.push(point.x, point.y);
+  }
+  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 };