deeptwins-engine-3d 0.1.32 → 0.1.34

package/dist/esm/plot/utils/ReminderTip.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 标绘提示弹窗tip
+ */
+declare const CreateRemindertip: (arr: any, position: any, show: boolean) => {
+    tooltip: HTMLElement | null;
+    style: any;
+    showAt: (position: any, text: any) => void;
+    show: (show: boolean) => void;
+};
+export default CreateRemindertip;

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

@@ -0,0 +1,67 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/**
+ * 标绘提示弹窗tip
+ */
+var CreateRemindertip = function CreateRemindertip(arr, position, show) {
+  var tooltip = document.getElementById('toolTip');
+  var style, _x, _y;
+  var _color = '';
+  if (arr && _typeof(arr) === 'object') {
+    style = arr;
+  }
+  if (style && style.origin) {
+    style.origin === 'center' && (_x = 15, _y = -12);
+    style.origin === 'top' && (_x = 15, _y = -44);
+    style.origin === 'bottom' && (_x = 15, _y = 20);
+  } else {
+    _x = 15, _y = 20;
+  }
+  if (style && style.color) {
+    style.color === 'white' && (_color = 'background: rgba(255, 255, 255, 0.8);color: black;');
+    style.color === 'black' && (_color = 'background: rgba(0, 0, 0, 0.8);color: white;');
+    style.color === 'yellow' && (_color = 'color: black;background-color: #ffcc33;border: 1px solid white;');
+  } else {
+    _color = 'background: rgba(0, 0, 0, 0.8);color: white;';
+  }
+  if (tooltip === null) {
+    var viewerDom = document.getElementsByClassName('cesium-viewer')[0];
+    var elementbottom = document.createElement('div');
+    viewerDom.append(elementbottom);
+    var html = '<div id="toolTip" style="display: none;pointer-events: none;position: absolute;z-index: 1000;opacity: 0.8;border-radius: 4px;padding: 4px 8px;white-space: nowrap;font-family:黑体;color:white;font-weight: bolder;font-size: 14px;' + _color + '"></div>';
+    viewerDom.insertAdjacentHTML('beforeend', html);
+    tooltip = document.getElementById('toolTip');
+  }
+  if (show) {
+    tooltip.innerHTML = arr;
+    tooltip.style.left = position.x + _x + 'px';
+    tooltip.style.top = position.y + _y + 'px';
+    tooltip.style.display = 'block';
+  } else {
+    tooltip.style.display = 'none';
+  }
+  return {
+    tooltip: tooltip,
+    style: style,
+    showAt: function showAt(position, text) {
+      this.tooltip.innerHTML = text;
+      if (this.style && this.style.origin) {
+        this.style.origin === 'center' && (_x = 15, _y = -this.tooltip.offsetHeight / 2);
+        this.style.origin === 'top' && (_x = 15, _y = -this.tooltip.offsetHeight - 20);
+        this.style.origin === 'bottom' && (_x = 15, _y = 20);
+      } else {
+        _x = 15, _y = -this.tooltip.offsetHeight / 2;
+      }
+      this.tooltip.style.left = position.x + _x + 'px';
+      this.tooltip.style.top = position.y + _y + 'px';
+      this.tooltip.style.display = 'block';
+    },
+    show: function show(_show) {
+      if (_show) {
+        this.tooltip.style.display = 'block';
+      } else {
+        this.tooltip.style.display = 'none';
+      }
+    }
+  };
+};
+export default CreateRemindertip;

package/dist/esm/plot/utils/Tooltip.d.ts

@@ -0,0 +1,3 @@
+declare const showToolTip: (type: string | undefined, toolTip: any, pos: any, bool: boolean) => void;
+declare const removeToolTip: (toolTip: any) => void;
+export { removeToolTip, showToolTip };

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

@@ -0,0 +1,97 @@
+/**
+ * 封装提示内容方法
+ */
+import CreateRemindertip from "./ReminderTip";
+var ToolTip = {
+  Point: '左键选择点进行编辑',
+  Polyline: '左键点击折线进行编辑',
+  Polygon: '左键点击多边形进行编辑',
+  EditPoint: '点：左键摁下并拖动，左键抬起完成编辑',
+  EditPolyline: '折线：左键摁下并拖动，左键抬起完成编辑',
+  PolylineEditPoints: '折线节点：左键摁住拖动，右键删除，左键抬起完成编辑',
+  PolylineEditCenterPoints: '折线虚拟中点：左键点击增加节点',
+  EditPolygon: '多边形：左键摁下并拖动，左键抬起完成编辑',
+  PolygonEditPoints: '多边形节点：左键摁住拖动，右键删除，左键抬起完成编辑',
+  PolygonEditCenterPoints: '多边形虚拟中点：左键点击增加节点',
+  Billboard: '左键点击广告牌进行编辑',
+  EditBillboard: '广告牌：左键摁下并拖动，左键抬起完成编辑',
+  Curve: '左键点击曲线进行编辑',
+  EditCurve: '曲线：左键摁下并拖动，左键抬起完成编辑',
+  CurveEditPoints: '曲线节点：左键摁住拖动，右键删除，左键抬起完成编辑',
+  CurveEditCenterPoints: '曲线虚拟中点：左键点击增加节点',
+  LineArrow: '左键点击简单箭头进行编辑',
+  EditLineArrow: '简单箭头：左键摁下并拖动，左键抬起完成编辑',
+  LineArrowEditPoints: '简单箭头节点：左键摁住拖动，右键删除，左键抬起完成编辑',
+  LineArrowEditCenterPoints: '简单箭头虚拟中点：左键点击增加节点',
+  RegularPolygon: '左键点击正多边形进行编辑',
+  EditRegularPolygon: '正多边形:左键摁下拖动，左键抬起完成编辑',
+  RegularPolygonEditCenter: '正多边形中点：左键摁下拖动，左键抬起完成编辑',
+  RegularPolygonEditEnd: '正多边形节点：左键摁下拖动，左键抬起完成编辑',
+  AttackArrow: '左键点击攻击箭头进行编辑',
+  EditAttackArrow: '攻击箭头：左键摁下并拖动，左键抬起完成编辑',
+  AttackArrowEditPoints: '攻击箭头节点：左键摁住拖动，右键删除，左键抬起完成编辑',
+  AttackArrowEditCenterPoints: '攻击箭头虚拟中点：左键点击增加节点',
+  RightAngleArrow: '左键点击直角箭头进行编辑',
+  EditRightAngleArrow: '直角箭头：左键摁下并拖动，左键抬起完成编辑',
+  RightAngleArrowEditPoints: '攻击箭头节点：左键摁住拖动，左键抬起完成编辑',
+  RightAngleArrowEditCenterPoints: '攻击箭头中点：左键摁下并拖动，左键抬起完成编辑',
+  Elliptic: '左键点击椭圆进行编辑',
+  EditElliptic: '椭圆:左键摁下拖动，左键抬起完成编辑',
+  EllipticEditCenter: '椭圆中点：左键摁下拖动，左键抬起完成编辑',
+  EllipticEditEnd: '椭圆轴点：左键摁下拖动，左键抬起完成编辑',
+  Circle: '左键点击圆进行编辑',
+  EditCircle: '圆:左键摁下拖动，左键抬起完成编辑',
+  CircleEditCenter: '圆中点：左键摁下拖动，左键抬起完成编辑',
+  CircleEditEnd: '圆轴点：左键摁下拖动，左键抬起完成编辑',
+  Rectangle: '左键点击矩形进行编辑',
+  EditRectangle: '矩形:左键摁下拖动，左键抬起完成编辑',
+  RectangleEditPoint: '矩形节点：左键摁下拖动，左键抬起完成编辑',
+  AssemblePolygon: '左键点击集结地进行编辑',
+  EditAssemble: '集结地:左键摁下拖动，左键抬起完成编辑',
+  AssembleEditPoint: '集结地节点：左键摁下拖动，左键抬起完成编辑',
+  SwallowtailArrow: '左键点击燕尾箭头进行编辑',
+  EditSwallowtailArrow: '燕尾箭头:左键摁下拖动，左键抬起完成编辑',
+  SwallowtailArrowEditPoint: '燕尾箭头节点：左键摁下拖动，左键抬起完成编辑',
+  StraightArrow: '左键点击直线箭头进行编辑',
+  EditStraightArrow: '直线箭头:左键摁下拖动，左键抬起完成编辑',
+  StraightArrowEditPoint: '直线箭头节点：左键摁下拖动，左键抬起完成编辑',
+  PincerArrow: '左键点击钳击箭头进行编辑',
+  EditPincerArrow: '钳击箭头:左键摁下拖动，左键抬起完成编辑',
+  PincerArrowEditPoint: '钳击箭头节点：左键摁下拖动，左键抬起完成编辑',
+  CurveFlag: '左键点击曲线旗标进行编辑',
+  RectangleFlag: '左键点击矩形旗标进行编辑',
+  RegularTriangleFlag: '左键点击正三角旗标进行编辑',
+  InvertedTriangleFlag: '左键点击倒三角旗标进行编辑',
+  TriangleFlag: '左键点击对三角线旗标进行编辑',
+  EditFlag: '旗标:左键摁下拖动，左键抬起完成编辑',
+  FlagEditPoint: '旗标节点：左键摁下拖动，左键抬起完成编辑',
+  Formation: '左键点击阵型对象进行编辑',
+  EditFormation: '阵型:左键摁下拖动，左键抬起完成编辑',
+  FormationEditPoint: '阵型节点：左键摁下拖动，左键抬起完成编辑',
+  Bow: '左键点击弓形对象进行编辑',
+  EditBow: '弓形:左键摁下拖动，左键抬起完成编辑',
+  BowEditPoint: '弓形节点：左键摁下拖动，左键抬起完成编辑',
+  RoundRectangle: '左键点击圆角矩形对象进行编辑',
+  EditRoundRectangle: '圆角矩形:左键摁下拖动，左键抬起完成编辑',
+  RoundRectangleEditPoint: '圆角矩形节点：左键摁下拖动，左键抬起完成编辑',
+  Sector: '左键点击扇形对象进行编辑',
+  EditSector: '扇形:左键摁下拖动，左键抬起完成编辑',
+  SectorEditPoint: '扇形节点：左键摁下拖动，左键抬起完成编辑',
+  Label: '左键点击文本对象进行编辑',
+  EditLabel: '文本：左键摁下并拖动，右键编辑属性',
+  Gltf: '左键点击模型对象进行编辑',
+  EditGltf: '模型：左键编辑位置，右键编辑旋转，中间摁下并拖动进行缩放'
+};
+var showToolTip = function showToolTip(type, toolTip, pos, bool) {
+  if (type) {
+    toolTip = ToolTip[type];
+    CreateRemindertip(toolTip, pos, bool);
+  } else {
+    removeToolTip(toolTip);
+  }
+};
+var removeToolTip = function removeToolTip(toolTip) {
+  toolTip = '';
+  CreateRemindertip(toolTip, null, false);
+};
+export { removeToolTip, showToolTip };

package/dist/esm/plot/utils/plotUtil.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 绘制方法
+ */
+declare const P: any;
+export default P;

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

@@ -0,0 +1,268 @@
+/**
+ * 绘制方法
+ */
+var P = {
+  version: '1.0.0'
+};
+P.Constants = {
+  TWO_PI: 2 * Math.PI,
+  HALF_PI: Math.PI / 2,
+  FITTING_COUNT: 100,
+  ZERO_TOLERANCE: 1e-4
+};
+P.PlotUtils = {};
+P.PlotUtils.distance = function (t, o) {
+  return Math.sqrt(Math.pow(t[0] - o[0], 2) + Math.pow(t[1] - o[1], 2));
+};
+P.PlotUtils.wholeDistance = function (t) {
+  var distance = 0;
+  for (var e = 0; e < t.length - 1; e++) {
+    distance += P.PlotUtils.distance(t[e], t[e + 1]);
+  }
+  return distance;
+};
+P.PlotUtils.getBaseLength = function (t) {
+  return Math.pow(P.PlotUtils.wholeDistance(t), 0.99);
+};
+P.PlotUtils.mid = function (t, o) {
+  return [(t[0] + o[0]) / 2, (t[1] + o[1]) / 2];
+};
+P.PlotUtils.getCircleCenterOfThreePoints = function (t, o, e) {
+  var r = [(t[0] + o[0]) / 2, (t[1] + o[1]) / 2];
+  var n = [r[0] - t[1] + o[1], r[1] + t[0] - o[0]];
+  var g = [(t[0] + e[0]) / 2, (t[1] + e[1]) / 2];
+  var i = [g[0] - t[1] + e[1], g[1] + t[0] - e[0]];
+  return P.PlotUtils.getIntersectPoint(r, n, g, i);
+};
+P.PlotUtils.getIntersectPoint = function (t, o, e, r) {
+  var g, n, i, s;
+  if (t[1] == o[1]) {
+    n = (r[0] - e[0]) / (r[1] - e[1]);
+    g = n * (t[1] - e[1]) + e[0];
+    i = t[1];
+    return [g, i];
+  }
+  if (e[1] == r[1]) {
+    s = (o[0] - t[0]) / (o[1] - t[1]);
+    g = s * (e[1] - t[1]) + t[0];
+    i = e[1];
+    return [g, i];
+  }
+  s = (o[0] - t[0]) / (o[1] - t[1]);
+  n = (r[0] - e[0]) / (r[1] - e[1]);
+  i = (s * t[1] - t[0] - n * e[1] + e[0]) / (s - n);
+  g = s * i - s * t[1] + t[0];
+  return [g, i];
+};
+P.PlotUtils.getAzimuth = function (t, o) {
+  var e = 0;
+  var r = Math.asin(Math.abs(o[1] - t[1]) / P.PlotUtils.distance(t, o));
+  o[1] >= t[1] && o[0] >= t[0] ? e = r + Math.PI : o[1] >= t[1] && o[0] < t[0] ? e = P.Constants.TWO_PI - r : o[1] < t[1] && o[0] < t[0] ? e = r : o[1] < t[1] && o[0] >= t[0] && (e = Math.PI - r);
+  return e;
+};
+P.PlotUtils.getAngleOfThreePoints = function (t, o, e) {
+  var r = P.PlotUtils.getAzimuth(o, t) - P.PlotUtils.getAzimuth(o, e);
+  return 0 > r ? r + P.Constants.TWO_PI : r;
+};
+P.PlotUtils.isClockWise = function (t, o, e) {
+  return (e[1] - t[1]) * (o[0] - t[0]) > (o[1] - t[1]) * (e[0] - t[0]);
+};
+P.PlotUtils.getPointOnLine = function (t, o, e) {
+  var r = o[0] + t * (e[0] - o[0]),
+    n = o[1] + t * (e[1] - o[1]);
+  return [r, n];
+};
+P.PlotUtils.getCubicValue = function (t, o, e, r, n) {
+  t = Math.max(Math.min(t, 1), 0);
+  var g = 1 - t,
+    i = t * t,
+    s = i * t,
+    a = g * g,
+    l = a * g,
+    u = l * o[0] + 3 * a * t * e[0] + 3 * g * i * r[0] + s * n[0],
+    c = l * o[1] + 3 * a * t * e[1] + 3 * g * i * r[1] + s * n[1];
+  return [u, c];
+};
+P.PlotUtils.getThirdPoint = function (t, o, e, r, n) {
+  var g = P.PlotUtils.getAzimuth(t, o),
+    i = n ? g + e : g - e,
+    s = r * Math.cos(i),
+    a = r * Math.sin(i);
+  return [o[0] + s, o[1] + a];
+};
+P.PlotUtils.getArcPoints = function (t, o, e, r) {
+  var n = [];
+  var g = [];
+  var i = [];
+  var s = r - e;
+  s = 0 > s ? s + P.Constants.TWO_PI : s;
+  for (var a = 0; a <= P.Constants.FITTING_COUNT; a++) {
+    var l = e + s * a / P.Constants.FITTING_COUNT;
+    n = t[0] + o * Math.cos(l), g = t[1] + o * Math.sin(l), i.push([n, g]);
+  }
+  return i;
+};
+P.PlotUtils.getBisectorNormals = function (t, o, e, r) {
+  var n = P.PlotUtils.getNormal(o, e, r),
+    g = Math.sqrt(n[0] * n[0] + n[1] * n[1]),
+    i = n[0] / g,
+    s = n[1] / g,
+    a = P.PlotUtils.distance(o, e),
+    l = P.PlotUtils.distance(e, r);
+  var u, c, p, h, d;
+  if (g > P.Constants.ZERO_TOLERANCE) {
+    if (P.PlotUtils.isClockWise(o, e, r)) {
+      u = t * a, c = e[0] - u * s, p = e[1] + u * i, h = [c, p];
+      u = t * l, c = e[0] + u * s, p = e[1] - u * i;
+      d = [c, p];
+    } else u = t * a, c = e[0] + u * s, p = e[1] - u * i, h = [c, p], u = t * l, c = e[0] - u * s, p = e[1] + u * i, d = [c, p];
+  } else c = e[0] + t * (o[0] - e[0]), p = e[1] + t * (o[1] - e[1]), h = [c, p], c = e[0] + t * (r[0] - e[0]), p = e[1] + t * (r[1] - e[1]), d = [c, p];
+  return [h, d];
+};
+P.PlotUtils.getNormal = function (t, o, e) {
+  var r = t[0] - o[0];
+  var n = t[1] - o[1];
+  var g = Math.sqrt(r * r + n * n);
+  r /= g, n /= g;
+  var i = e[0] - o[0];
+  var s = e[1] - o[1];
+  var a = Math.sqrt(i * i + s * s);
+  i /= a, s /= a;
+  var l = r + i;
+  var u = n + s;
+  return [l, u];
+};
+P.PlotUtils.getCurvePoints = function (t, o) {
+  var e = P.PlotUtils.getLeftMostControlPoint(o);
+  var r = [e];
+  var g, i;
+  for (var n = 0; n < o.length - 2; n++) {
+    g = o[n];
+    i = o[n + 1];
+    var s = o[n + 2];
+    var a = P.PlotUtils.getBisectorNormals(t, g, i, s);
+    r = r.concat(a);
+  }
+  var l = P.PlotUtils.getRightMostControlPoint(o);
+  r.push(l);
+  var u = [];
+  for (var _n = 0; _n < o.length - 1; _n++) {
+    g = o[_n], i = o[_n + 1], u.push(g);
+    for (var _t = 0; _t < P.Constants.FITTING_COUNT; _t++) {
+      var c = P.PlotUtils.getCubicValue(_t / P.Constants.FITTING_COUNT, g, r[2 * _n], r[2 * _n + 1], i);
+      u.push(c);
+    }
+    u.push(i);
+  }
+  return u;
+};
+P.PlotUtils.getLeftMostControlPoint = function (o) {
+  var e = o[0],
+    r = o[1],
+    n = o[2],
+    g = P.PlotUtils.getBisectorNormals(0, e, r, n),
+    i = g[0],
+    s = P.PlotUtils.getNormal(e, r, n),
+    a = Math.sqrt(s[0] * s[0] + s[1] * s[1]);
+  var m = e[0],
+    O = e[1];
+  if (a > P.Constants.ZERO_TOLERANCE) {
+    var l = P.PlotUtils.mid(e, r);
+    var u = e[0] - l[0];
+    var c = e[1] - l[1];
+    var p = P.PlotUtils.distance(e, r);
+    var h = 2 / p;
+    var d = -h * c;
+    var f = h * u;
+    var E = d * d - f * f;
+    var v = 2 * d * f;
+    var A = f * f - d * d;
+    var _ = i[0] - l[0];
+    var y = i[1] - l[1];
+    m = l[0] + E * _ + v * y;
+    O = l[1] + v * _ + A * y;
+  }
+  return [m, O];
+};
+P.PlotUtils.getRightMostControlPoint = function (o) {
+  var e = o.length;
+  var r = o[e - 3];
+  var n = o[e - 2];
+  var g = o[e - 1];
+  var i = P.PlotUtils.getBisectorNormals(0, r, n, g);
+  var s = i[1];
+  var a = P.PlotUtils.getNormal(r, n, g);
+  var l = Math.sqrt(a[0] * a[0] + a[1] * a[1]);
+  var O = g[0];
+  var T = g[1];
+  if (l > P.Constants.ZERO_TOLERANCE) {
+    var u = P.PlotUtils.mid(n, g);
+    var c = g[0] - u[0];
+    var p = g[1] - u[1];
+    var h = P.PlotUtils.distance(n, g);
+    var d = 2 / h;
+    var f = -d * p;
+    var E = d * c;
+    var v = f * f - E * E;
+    var A = 2 * f * E;
+    var _ = E * E - f * f;
+    var y = s[0] - u[0];
+    var m = s[1] - u[1];
+    O = u[0] + v * y + A * m;
+    T = u[1] + A * y + _ * m;
+  }
+  return [O, T];
+};
+P.PlotUtils.getBezierPoints = function (t) {
+  if (t.length <= 2) return t;
+  var o = [];
+  var e = t.length - 1;
+  for (var r = 0; 1 >= r; r += 0.01) {
+    var n = 0,
+      y = 0;
+    for (var g = 0; e >= g; g++) {
+      var i = P.PlotUtils.getBinomialFactor(e, g),
+        s = Math.pow(r, g),
+        a = Math.pow(1 - r, e - g);
+      n += i * s * a * t[g][0], y += i * s * a * t[g][1];
+    }
+    o.push([n, y]);
+  }
+  return o.push(t[e]), o;
+};
+P.PlotUtils.getBinomialFactor = function (t, o) {
+  return P.PlotUtils.getFactorial(t) / (P.PlotUtils.getFactorial(o) * P.PlotUtils.getFactorial(t - o));
+};
+P.PlotUtils.getFactorial = function (t) {
+  if (1 >= t) return 1;
+  if (2 == t) return 2;
+  if (3 == t) return 6;
+  if (4 == t) return 24;
+  if (5 == t) return 120;
+  var o = 1;
+  for (var e = 1; t >= e; e++) {
+    o *= e;
+  }
+  return o;
+};
+P.PlotUtils.getQBSplinePoints = function (t) {
+  if (t.length <= 2) return t;
+  var o = 2;
+  var e = [];
+  var r = t.length - o - 1;
+  e.push(t[0]);
+  for (var n = 0; r >= n; n++) for (var g = 0; 1 >= g; g += 0.05) {
+    var i = 0,
+      y = 0;
+    for (var s = 0; o >= s; s++) {
+      var a = P.PlotUtils.getQuadricBSplineFactor(s, g);
+      i += a * t[n + s][0], y += a * t[n + s][1];
+    }
+    e.push([i, y]);
+  }
+  return e.push(t[t.length - 1]), e;
+};
+P.PlotUtils.getQuadricBSplineFactor = function (t, o) {
+  return 0 == t ? Math.pow(o - 1, 2) / 2 : 1 == t ? (-2 * Math.pow(o, 2) + 2 * o + 1) / 2 : 2 == t ? Math.pow(o, 2) / 2 : 0;
+};
+export default P;

package/dist/esm/tool/utils.d.ts

@@ -1,12 +1,13 @@
 import * as Cesium from 'deeptwins-cesium';
+import { Cartesian3 } from 'deeptwins-cesium';
 export declare const loadUMDModule: (url: string, moduleName: string) => Promise<unknown>;
 export declare function sleep(ms: number): Promise<unknown>;
 export declare const getDeepTwinsFile: (url: string) => string;
 export declare const colorString: (color: any) => any;
 export declare const colorInstanceString: (color: any) => any;
 export declare const colorMaterialString: (color: any) => any;
-export declare const arrCartesian2: (data: any[]) => any[] | Cesium.Cartesian2;
-export declare const arrCartesian3: (data: any[]) => any[] | Cesium.Cartesian3;
+export declare const arrCartesian2: (data: any[]) => Cesium.Cartesian2;
+export declare const arrCartesian3: (data: any[]) => Cesium.Cartesian3;
 export declare const toDegrees: (radians: number, precision?: number) => number;
 export declare const toRadians: (degrees: number) => number;
 export declare const lngLatAltToCartographic: (lng: number, lat: number, alt?: number) => Cesium.Cartographic;
@@ -17,11 +18,6 @@ export declare const cartesian3ToLngLatAlt: (cartesian3: any) => {
 };
 export declare const lngLatAltToCartesian3: (lng: number, lat: number, alt?: number) => Cesium.Cartesian3;
 export declare const lngLatAltArrayToCartesian3Array: (lngLatAltArray: any[]) => Cesium.Cartesian3[];
-export declare const isString: (v: any) => boolean;
-export declare const isObject: (v: any) => boolean;
-export declare const isArray: (v: any) => boolean;
-export declare const isFunction: (v: any) => boolean;
-export declare const isNumber: (v: any) => boolean;
 export declare const isWKT: (str: string) => boolean;
 export declare const styleFun: (style: any, properties: any) => any;
 export declare const dateToJulianDate: (date: Date) => Cesium.JulianDate;
@@ -53,3 +49,8 @@ export declare function error(message: string): void;
  * @returns Float32Array ST 坐标
  */
 export declare function computeSTAlongPlane(positions: any, rotation?: number): Float32Array;
+export declare function getMidpoint(position1: Cartesian3, position2: Cartesian3): {
+    lng: number;
+    lat: number;
+    alt: number;
+};

package/dist/esm/tool/utils.js

@@ -21,7 +21,7 @@ function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyri
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 import * as Cesium from 'deeptwins-cesium';
-import { isNil, round } from 'lodash';
+import { isArray, isFunction, isNil, isString, round } from 'lodash';
 
 // 加载umd脚本
 export var loadUMDModule = /*#__PURE__*/function () {
@@ -177,21 +177,8 @@ export var lngLatAltArrayToCartesian3Array = function lngLatAltArrayToCartesian3
   });
   return Cesium.Cartesian3.fromDegreesArrayHeights(lngLatAltArrayString);
 };
-export var isString = function isString(v) {
-  return Object.prototype.toString.call(v) === '[object String]';
-};
-export var isObject = function isObject(v) {
-  return Object.prototype.toString.call(v) === '[object Object]';
-};
-export var isArray = function isArray(v) {
-  return Object.prototype.toString.call(v) === '[object Array]';
-};
-export var isFunction = function isFunction(v) {
-  return Object.prototype.toString.call(v) === '[object Function]';
-};
-export var isNumber = function isNumber(v) {
-  return Object.prototype.toString.call(v) === '[object Number]';
-};
+
+// 是否是wkt类型的字符串
 export var isWKT = function isWKT(str) {
   return str.startsWith('POINT') || str.startsWith('LINESTRING') || str.startsWith('POLYGON') || str.startsWith('MULTIPOINT') || str.startsWith('MULTILINESTRING') || str.startsWith('GEOMETRYCOLLECTION');
 };
@@ -398,4 +385,21 @@ export function computeSTAlongPlane(positions) {
     stValues[i * 2 + 1] = t;
   });
   return stValues;
+}
+
+// 计算两点的中心点
+export function getMidpoint(position1, position2) {
+  // 计算中心点（线性插值）
+  var center = new Cesium.Cartesian3();
+  Cesium.Cartesian3.add(position1, position2, center);
+  Cesium.Cartesian3.multiplyByScalar(center, 0.5, center);
+  var cartographic = Cesium.Cartographic.fromCartesian(center);
+  var lng = Cesium.Math.toDegrees(cartographic.longitude);
+  var lat = Cesium.Math.toDegrees(cartographic.latitude);
+  var alt = cartographic.height;
+  return {
+    lng: lng,
+    lat: lat,
+    alt: alt
+  };
 }

package/dist/esm/toolTip/index.d.ts

@@ -1,11 +1,12 @@
 import './index.css';
 export default class ToolTip {
+    private readonly _mapContext;
     tooltip: any;
-    private _map;
     private _isShow;
     private _handleMove;
     private _handleLeave;
     constructor(map: any, options?: any);
+    getMap(): any;
     private _init;
     show(isShow: boolean): void;
     setOptions(options: any): void;

package/dist/esm/toolTip/index.js

@@ -7,15 +7,17 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import * as Cesium from 'deeptwins-cesium';
 import "./index.css";
+
+// 跟随鼠标的提示框
 var ToolTip = /*#__PURE__*/function () {
   function ToolTip(map, options) {
     _classCallCheck(this, ToolTip);
+    _defineProperty(this, "_mapContext", void 0);
     _defineProperty(this, "tooltip", void 0);
-    _defineProperty(this, "_map", void 0);
     _defineProperty(this, "_isShow", true);
     _defineProperty(this, "_handleMove", void 0);
     _defineProperty(this, "_handleLeave", void 0);
-    this._map = map;
+    this._mapContext = map._mapContext;
     this.tooltip = document.createElement('div');
     this.tooltip.className = 'deepTwins-toolTip';
     map.container.appendChild(this.tooltip);
@@ -23,11 +25,16 @@ var ToolTip = /*#__PURE__*/function () {
     this._init();
   }
   _createClass(ToolTip, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+  }, {
     key: "_init",
     value: function _init() {
       var _this = this;
       var self = this;
-      this._handleMove = this._map.on(Cesium.ScreenSpaceEventType.MOUSE_MOVE, function (e) {
+      this._handleMove = this.getMap().on(Cesium.ScreenSpaceEventType.MOUSE_MOVE, function (e) {
         if (_this._isShow) {
           var position = e.original.endPosition;
           _this.tooltip.style.left = position.x + 'px';
@@ -39,9 +46,9 @@ var ToolTip = /*#__PURE__*/function () {
         _this.tooltip.style.display = 'none';
       };
       this._handleLeave.off = function () {
-        self._map.scene.canvas.removeEventListener('mouseleave', this);
+        self.getMap().scene.canvas.removeEventListener('mouseleave', this);
       };
-      this._map.scene.canvas.addEventListener('mouseleave', this._handleLeave);
+      this.getMap().scene.canvas.addEventListener('mouseleave', this._handleLeave);
     }
   }, {
     key: "show",
@@ -65,7 +72,6 @@ var ToolTip = /*#__PURE__*/function () {
       this.tooltip.remove();
       this._handleMove.off();
       this._handleLeave.off();
-      this._map = null;
     }
   }]);
   return ToolTip;

package/dist/esm/typings.d.ts

@@ -5,6 +5,7 @@ declare module '*.glsl' {
 interface Window {
   Cesium: any;
   CESIUM_BASE_URL: string;
+  toolTip: string;
 }
 // 版本
 declare const VERSION: string;