@vesium/plot 1.0.1-beta.25

package/dist/index.cjs

@@ -0,0 +1,1177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const cesium = require("cesium");
+const shared = require("@vesium/shared");
+const core = require("@vueuse/core");
+const core$1 = require("@vesium/core");
+const useViewer = require("@vesium/core/useViewer");
+const vue = require("vue");
+var PlotAction = /* @__PURE__ */ ((PlotAction2) => {
+  PlotAction2[PlotAction2["IDLE"] = 0] = "IDLE";
+  PlotAction2[PlotAction2["HOVER"] = 1] = "HOVER";
+  PlotAction2[PlotAction2["ACTIVE"] = 2] = "ACTIVE";
+  return PlotAction2;
+})(PlotAction || {});
+function control() {
+  return {
+    diabled: ({ active }) => !active,
+    cursor: "pointer",
+    dragCursor: "crosshair",
+    onDrag({ viewer, sample, packable, context, index, lockCamera }) {
+      lockCamera();
+      const position = shared.canvasCoordToCartesian(context.endPosition, viewer.scene);
+      if (position) {
+        const positions = [...packable.positions ?? []];
+        positions[index] = position;
+        sample.setSample({
+          time: packable.time,
+          derivative: packable.derivative,
+          positions
+        });
+      }
+    },
+    onKeyPressed({ viewer, keyEvent, sample, packable, index }) {
+      var _a;
+      const height = (_a = shared.toCartographic(viewer.camera.position)) == null ? void 0 : _a.height;
+      if (!height || !["ArrowUp", "ArrowRight", "ArrowDown", "ArrowLeft"].includes(keyEvent.key))
+        return;
+      keyEvent.preventDefault();
+      let headingAdjust = 0;
+      switch (keyEvent.key) {
+        case "ArrowRight":
+          headingAdjust = Math.PI / 2;
+          break;
+        case "ArrowDown":
+          headingAdjust = Math.PI;
+          break;
+        case "ArrowLeft":
+          headingAdjust = -Math.PI / 2;
+          break;
+        case "ArrowUp":
+          headingAdjust = 0;
+          break;
+      }
+      const newHeading = (viewer.camera.heading + headingAdjust) % (2 * Math.PI);
+      const positions = [...packable.positions ?? []];
+      const cartographic = shared.toCartographic(positions[index]);
+      const r = height / 1e5;
+      const distance = r * Math.PI / 180 / 1e3;
+      cartographic.latitude += distance * Math.cos(newHeading);
+      cartographic.longitude += distance * Math.sin(newHeading);
+      positions[index] = shared.toCartesian3(cartographic);
+      sample.setSample({
+        time: packable.time,
+        derivative: packable.derivative,
+        positions
+      });
+    },
+    render: ({ position, action }) => {
+      const colors = {
+        [PlotAction.IDLE]: cesium.Color.BLUE.withAlpha(0.4),
+        [PlotAction.HOVER]: cesium.Color.BLUE.withAlpha(0.6),
+        [PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+      };
+      return {
+        position,
+        point: {
+          pixelSize: 8,
+          color: colors[action],
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          outlineWidth: 1,
+          outlineColor: cesium.Color.WHITE.withAlpha(0.4)
+        }
+      };
+    }
+  };
+}
+function interval() {
+  let dragIndex = -1;
+  return {
+    diabled: ({ active, defining }) => !active || defining,
+    cursor: "pointer",
+    dragCursor: "crosshair",
+    format(packable) {
+      const _positions = packable.positions ?? [];
+      if (_positions.length < 2) {
+        return [];
+      }
+      return _positions.map((position, i) => {
+        const next = i === _positions.length - 1 ? _positions[0] : _positions[i + 1];
+        return cesium.Cartesian3.midpoint(position, next, new cesium.Cartesian3());
+      });
+    },
+    onDrag({ viewer, sample, packable, context, index, lockCamera, dragging }) {
+      lockCamera();
+      const position = shared.canvasCoordToCartesian(context.endPosition, viewer.scene);
+      if (!position) {
+        return;
+      }
+      const positions = [...packable.positions ?? []];
+      if (dragIndex === -1) {
+        dragIndex = index;
+        positions.splice(index + 1, 0, position);
+      } else {
+        positions[dragIndex + 1] = position;
+      }
+      if (!dragging) {
+        dragIndex = -1;
+      }
+      sample.setSample({
+        time: packable.time,
+        derivative: packable.derivative,
+        positions
+      });
+    },
+    render: ({ position, action, active }) => {
+      if (!active) {
+        return;
+      }
+      const colors = {
+        [PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(0.4),
+        [PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(0.6),
+        [PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+      };
+      return {
+        position,
+        point: {
+          pixelSize: 6,
+          color: colors[action],
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          outlineWidth: 1,
+          outlineColor: cesium.Color.WHITE.withAlpha(0.4)
+        }
+      };
+    }
+  };
+}
+function intervalNonclosed() {
+  let dragIndex = -1;
+  return {
+    diabled: ({ active, defining }) => !active || defining,
+    cursor: "pointer",
+    dragCursor: "crosshair",
+    format(packable) {
+      const _positions = packable.positions ?? [];
+      if (_positions.length < 2) {
+        return [];
+      }
+      return _positions.slice(0, _positions.length - 1).map((position, i) => {
+        return cesium.Cartesian3.midpoint(position, _positions[i + 1], new cesium.Cartesian3());
+      });
+    },
+    onDrag({ viewer, sample, packable, context, index, lockCamera, dragging }) {
+      lockCamera();
+      const position = shared.canvasCoordToCartesian(context.endPosition, viewer.scene);
+      if (!position) {
+        return;
+      }
+      const positions = [...packable.positions ?? []];
+      if (dragIndex === -1) {
+        dragIndex = index;
+        positions.splice(index + 1, 0, position);
+      } else {
+        positions[dragIndex + 1] = position;
+      }
+      if (!dragging) {
+        dragIndex = -1;
+      }
+      sample.setSample({
+        time: packable.time,
+        derivative: packable.derivative,
+        positions
+      });
+    },
+    render: ({ position, action }) => {
+      const colors = {
+        [PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(0.4),
+        [PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(0.6),
+        [PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+      };
+      return {
+        position,
+        point: {
+          pixelSize: 6,
+          color: colors[action],
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          outlineWidth: 1,
+          outlineColor: cesium.Color.WHITE.withAlpha(0.4)
+        }
+      };
+    }
+  };
+}
+const svg = `data:image/svg+xml;utf8,${encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><path  stroke="#ffffff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="m18 9l3 3l-3 3m-3-3h6M6 9l-3 3l3 3m-3-3h6m0 6l3 3l3-3m-3-3v6m3-15l-3-3l-3 3m3-3v6"/></svg>'
+)}`;
+function moved() {
+  return {
+    diabled: ({ active, defining }) => !active || defining,
+    cursor: "pointer",
+    dragCursor: "crosshair",
+    format(packable) {
+      const positions = packable.positions ?? [];
+      if (positions.length === 0) {
+        return [];
+      } else if (positions.length === 1) {
+        return [positions[0]];
+      } else {
+        const center = cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions));
+        return [shared.toCartesian3(center)];
+      }
+    },
+    onDrag({ viewer, sample, packable, context, lockCamera, dragging }) {
+      dragging && lockCamera();
+      const startPosition = shared.canvasCoordToCartesian(context.startPosition, viewer.scene);
+      const endPosition = shared.canvasCoordToCartesian(context.endPosition, viewer.scene);
+      if (!startPosition || !endPosition) {
+        return;
+      }
+      const offset = cesium.Cartesian3.subtract(endPosition, startPosition, new cesium.Cartesian3());
+      const positions = [...packable.positions ?? []];
+      sample.setSample({
+        time: packable.time,
+        derivative: packable.derivative,
+        positions: positions.map((position) => cesium.Cartesian3.add(position, offset, new cesium.Cartesian3()))
+      });
+    },
+    render: ({ position, action }) => {
+      const colors = {
+        [PlotAction.IDLE]: cesium.Color.WHITE,
+        [PlotAction.HOVER]: cesium.Color.WHITE,
+        [PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+      };
+      return {
+        position,
+        billboard: {
+          image: svg,
+          width: 20,
+          height: 20,
+          color: colors[action],
+          pixelOffset: new cesium.Cartesian3(0, -20),
+          horizontalOrigin: cesium.HorizontalOrigin.CENTER,
+          verticalOrigin: cesium.VerticalOrigin.BOTTOM,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        }
+      };
+    }
+  };
+}
+const PLOT_BILLBOARD_SCHEME = {
+  scheme: {
+    type: "Billboard",
+    complete: (packable) => packable.positions.length >= 1,
+    skeletons: [
+      moved
+    ],
+    render(options) {
+      var _a, _b;
+      const { mouse, packable } = options;
+      const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new cesium.Entity({
+        billboard: {}
+      });
+      const position = ((_b = packable.positions) == null ? void 0 : _b[0]) ?? mouse;
+      entity.position = new cesium.CallbackPositionProperty(() => position, true);
+      return {
+        entities: [entity]
+      };
+    }
+  }
+};
+const PLOT_LABEL_SCHEME = {
+  scheme: {
+    type: "Label",
+    complete: (packable) => packable.positions.length >= 1,
+    skeletons: [
+      moved
+    ],
+    render(options) {
+      var _a, _b;
+      const { mouse, packable } = options;
+      const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new cesium.Entity({
+        label: {
+          text: "Label"
+        }
+      });
+      const position = ((_b = packable.positions) == null ? void 0 : _b[0]) ?? mouse;
+      entity.position = new cesium.CallbackPositionProperty(() => position, true);
+      return {
+        entities: [entity]
+      };
+    }
+  }
+};
+const PLOT_LINE_STRING_SCHEME = {
+  scheme: {
+    type: "LineString",
+    forceComplete: (packable) => packable.positions.length >= 2,
+    skeletons: [
+      control,
+      intervalNonclosed,
+      moved
+    ],
+    render(options) {
+      var _a;
+      const { mouse, packable } = options;
+      const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new cesium.Entity({
+        polyline: {
+          width: 1
+        }
+      });
+      entity.polyline.positions = new cesium.CallbackProperty(() => {
+        const positions = [...packable.positions ?? []].concat(mouse ? [mouse] : []);
+        return positions.length >= 2 ? positions : [];
+      }, false);
+      return {
+        entities: [entity]
+      };
+    }
+  }
+};
+const PLOT_POLYGON_SCHEME = {
+  scheme: {
+    type: "Polygon",
+    forceComplete: (packable) => packable.positions.length >= 3,
+    skeletons: [
+      control,
+      interval,
+      moved
+    ],
+    render(options) {
+      var _a;
+      const { mouse, packable } = options;
+      const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new cesium.Entity({
+        polyline: {
+          material: cesium.Color.YELLOW.withAlpha(0.5)
+        },
+        polygon: {
+          material: cesium.Color.YELLOW.withAlpha(0.5)
+        }
+      });
+      const positions = [...packable.positions ?? []];
+      mouse && positions.push(mouse);
+      if (positions.length === 2) {
+        entity.polygon.hierarchy = void 0;
+        entity.polyline.positions = new cesium.CallbackProperty(() => positions, false);
+      } else if (positions.length >= 3) {
+        entity.polyline.positions = void 0;
+        entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
+          positions.push(positions[0]);
+          return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
+        }, false);
+      } else {
+        entity.polygon.hierarchy = void 0;
+        entity.polyline.positions = void 0;
+      }
+      return {
+        entities: [entity]
+      };
+    }
+  }
+};
+const _PlotScheme = class _PlotScheme {
+  constructor(options) {
+    __publicField(this, "type");
+    /**
+     * 是否立即执行完成标绘操作
+     *
+     * 每次控制点发生变变化时，执行该回调函数，如果返回`true`则标绘完成
+     */
+    __publicField(this, "complete");
+    /**
+     * 双击时，是否执行完成标绘操作
+     */
+    __publicField(this, "forceComplete");
+    /**
+     * 处于定义态时的鼠标样式
+     * @default 'crosshair'
+     */
+    __publicField(this, "definingCursor");
+    /**
+     * 框架点渲染配置
+     */
+    __publicField(this, "skeletons");
+    /**
+     */
+    __publicField(this, "render");
+    var _a;
+    this.type = options.type;
+    this.complete = options.complete;
+    this.forceComplete = options.forceComplete;
+    this.definingCursor = options.definingCursor ?? "crosshair";
+    this.skeletons = ((_a = options.skeletons) == null ? void 0 : _a.map((item) => shared.isFunction(item) ? item() : item)) ?? [];
+    this.render = options.render;
+  }
+  static getRecordTypes() {
+    return [...this._record.keys()];
+  }
+  static getRecord(type) {
+    return _PlotScheme._record.get(type);
+  }
+  static setRecord(scheme) {
+    shared.assertError(!scheme.type, "`scheme.type` is required");
+    _PlotScheme._record.set(scheme.type, scheme);
+  }
+  /**
+   * 解析传入的 scheme，并返回 PlotScheme 实例
+   */
+  static resolve(maybeScheme) {
+    if (typeof maybeScheme === "string") {
+      const _scheme = _PlotScheme.getRecord(maybeScheme);
+      core.assert(!!_scheme, `scheme ${maybeScheme} not found`);
+      return _scheme;
+    } else if (!(maybeScheme instanceof _PlotScheme)) {
+      return new _PlotScheme(maybeScheme);
+    } else {
+      return maybeScheme;
+    }
+  }
+};
+/**
+ * @internal
+ */
+__publicField(_PlotScheme, "_record", /* @__PURE__ */ new Map());
+let PlotScheme = _PlotScheme;
+var SampledPlotStrategy = /* @__PURE__ */ ((SampledPlotStrategy2) => {
+  SampledPlotStrategy2[SampledPlotStrategy2["NEAR"] = 0] = "NEAR";
+  SampledPlotStrategy2[SampledPlotStrategy2["CYCLE"] = 1] = "CYCLE";
+  SampledPlotStrategy2[SampledPlotStrategy2["STRICT"] = 2] = "STRICT";
+  return SampledPlotStrategy2;
+})(SampledPlotStrategy || {});
+const defaultInterpolationAlgorithm = (time, previous, next, proportion) => {
+  var _a, _b, _c;
+  if (proportion === 0) {
+    return {
+      time,
+      positions: (_a = previous.positions) == null ? void 0 : _a.map((item) => item.clone()),
+      derivative: previous.derivative
+    };
+  } else if (proportion === 1) {
+    return {
+      time,
+      positions: (_b = next.positions) == null ? void 0 : _b.map((item) => item.clone()),
+      derivative: previous.derivative
+    };
+  }
+  return {
+    time,
+    positions: (_c = next.positions) == null ? void 0 : _c.map((right, index) => {
+      var _a2;
+      const left = (_a2 = previous.positions) == null ? void 0 : _a2[index];
+      return !left ? right : cesium.Cartesian3.lerp(left, right, proportion, new cesium.Cartesian3());
+    }),
+    derivative: previous.derivative
+  };
+};
+const _SampledPlotProperty = class _SampledPlotProperty {
+  constructor(options) {
+    __publicField(this, "strategy");
+    __publicField(this, "interpolationAlgorithm");
+    /**
+     * @internal
+     */
+    __publicField(this, "_times", []);
+    /**
+     * @internal
+     */
+    __publicField(this, "_sampleds", []);
+    /**
+     * @internal
+     */
+    __publicField(this, "_derivatives", []);
+    /**
+     * @internal
+     */
+    __publicField(this, "_definitionChanged", new cesium.Event());
+    var _a;
+    this.interpolationAlgorithm = options == null ? void 0 : options.interpolationAlgorithm;
+    this.strategy = (options == null ? void 0 : options.strategy) ?? 0;
+    (_a = options == null ? void 0 : options.packables) == null ? void 0 : _a.forEach((packable) => this.setSample(packable));
+    if (!this._times.length) {
+      this.setSample({
+        time: cesium.JulianDate.now(),
+        positions: [],
+        derivative: void 0
+      });
+    }
+  }
+  get isConstant() {
+    return this._times.length === 0;
+  }
+  get definitionChanged() {
+    return this._definitionChanged;
+  }
+  /**
+   * 获取时间数组
+   *
+   * @returns 返回包含所有时间的 JulianDate 数组
+   */
+  getTimes() {
+    return this._times.map((t) => t.clone());
+  }
+  /**
+   * 根据给定的儒略日期获取时间索引范围及比例
+   *
+   * @param time 给定的儒略日期
+   * @returns 返回包含前一个索引、后一个索引及时间比例的对象，若不符合条件则返回undefined
+   * @internal
+   */
+  getIndexScope(time) {
+    if (!this._times.length) {
+      return;
+    }
+    const start = this._times[0];
+    const end = this._times[this._times.length - 1];
+    if (cesium.JulianDate.lessThan(time, start) || cesium.JulianDate.greaterThan(time, end)) {
+      switch (this.strategy) {
+        case 2: {
+          return;
+        }
+        case 0: {
+          time = cesium.JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
+          break;
+        }
+        case 1: {
+          const startMS = cesium.JulianDate.toDate(this._times[0]).getTime();
+          const endMS = cesium.JulianDate.toDate(this._times[this._times.length - 1]).getTime();
+          const duration = endMS - startMS;
+          const timeMS = cesium.JulianDate.toDate(time).getTime();
+          const diff = (timeMS - startMS) % duration;
+          const dete = new Date(startMS + diff);
+          time = cesium.JulianDate.fromDate(dete);
+          break;
+        }
+      }
+    }
+    const prevIndex = this._times.findIndex((t) => cesium.JulianDate.lessThanOrEquals(time, t));
+    const nextIndex = Math.min(prevIndex, this._times.length - 1);
+    const prevMs = cesium.JulianDate.toDate(this._times[prevIndex]).getTime();
+    const nextMs = cesium.JulianDate.toDate(this._times[nextIndex]).getTime();
+    const ms = cesium.JulianDate.toDate(time).getTime();
+    return {
+      prevIndex,
+      nextIndex,
+      proportion: (ms - prevMs) / (nextMs - prevMs) || 0
+    };
+  }
+  /**
+   * 根据给定的儒略日期（JulianDate）获取插值后的样本点数据。
+   *
+   * @param time 指定的儒略日期（JulianDate）。
+   * @param result 可选参数，用于存储结果的容器。如果未提供，则创建一个新的容器。
+   * @returns 插值后的样本点数据，存储在提供的或新创建的result容器中。
+   * @template D 数据类型。
+   */
+  getValue(time, result) {
+    var _a, _b;
+    result ?? (result = { time });
+    Object.assign(result, {
+      time: time.clone(),
+      positions: void 0,
+      derivative: void 0
+    });
+    if (!time) {
+      result.time = (_a = this._times[0]) == null ? void 0 : _a.clone();
+      result.positions = (_b = this._sampleds[0]) == null ? void 0 : _b.map((c) => c.clone(c));
+      result.derivative = this._derivatives[0];
+      return result;
+    }
+    const scope = this.getIndexScope(time);
+    if (!scope) {
+      return result;
+    }
+    result.time = time;
+    const { prevIndex, nextIndex, proportion } = scope;
+    const previous = {
+      time: this._times[prevIndex],
+      positions: this._sampleds[prevIndex],
+      derivative: this._derivatives[prevIndex]
+    };
+    const next = {
+      time: this._times[nextIndex],
+      positions: this._sampleds[nextIndex],
+      derivative: this._derivatives[nextIndex]
+    };
+    const packable = (this.interpolationAlgorithm || _SampledPlotProperty.defaultInterpolationAlgorithm)(time, previous, next, proportion);
+    Object.assign(result, packable);
+    return result;
+  }
+  /**
+   * 设置样本数据
+   *
+   * @param value 样本数据对象，包含时间、位置和导数信息
+   */
+  setSample(value) {
+    var _a;
+    const time = value.time.clone();
+    const positions = ((_a = value.positions) == null ? void 0 : _a.map((item) => item.clone())) ?? [];
+    const derivative = value.derivative;
+    const index = this._times.findIndex((t) => cesium.JulianDate.equals(time, t));
+    if (index !== -1) {
+      this._times[index] = time;
+      this._sampleds[index] = positions;
+      this._derivatives[index] = value.derivative;
+    } else if (this._times.length === 0) {
+      this._times[0] = time;
+      this._sampleds[0] = positions;
+      this._derivatives[0] = value.derivative;
+    } else if (cesium.JulianDate.lessThan(time, this._times[0])) {
+      this._times.splice(0, 0, time);
+      this._sampleds.splice(0, 0, positions);
+      this._derivatives.splice(0, 0, derivative);
+    } else if (cesium.JulianDate.greaterThan(time, this._times[this._times.length - 1])) {
+      this._times.push(time);
+      this._sampleds.push(positions);
+      this._derivatives.push(derivative);
+    }
+    this.definitionChanged.raiseEvent(this);
+  }
+  /**
+   * 设置样本数据
+   *
+   * @param values 样本数据数组，每个元素都是类型为SampledPlotPackable<D>的对象
+   */
+  setSamples(values) {
+    values.forEach((value) => this.setSample(value));
+  }
+  /**
+   * 从样本中移除指定时间点的数据
+   *
+   * @param time 需要移除的时间点，使用儒略日期表示
+   * @returns 如果成功移除，则返回 true；否则返回 false
+   */
+  removeSample(time) {
+    const index = this._times.findIndex((t) => t.equals(time));
+    if (index !== -1) {
+      this._sampleds.splice(index, 1);
+      this._derivatives.splice(index, 1);
+      const removed = this._times.splice(index, 1);
+      if (removed.length) {
+        this._definitionChanged.raiseEvent(this);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 从样本中移除指定时间间隔内的样本。
+   *
+   * @param interval 要移除样本的时间间隔
+   */
+  removeSamples(interval2) {
+    for (let i = 0; i < this._times.length; i++) {
+      const time = this._times[i];
+      cesium.TimeInterval.contains(interval2, time) && this.removeSample(time);
+    }
+  }
+  equals(other) {
+    return other === this;
+  }
+};
+__publicField(_SampledPlotProperty, "defaultInterpolationAlgorithm", defaultInterpolationAlgorithm);
+let SampledPlotProperty = _SampledPlotProperty;
+class Plot {
+  constructor(options) {
+    /**
+     * @internal
+     */
+    __publicField(this, "_definitionChanged", new cesium.Event());
+    __publicField(this, "time");
+    shared.assertError(!core.notNullish(options.scheme), "options.scheme is required");
+    this.id = options.id || cesium.createGuid();
+    shared.createCesiumAttribute(this, "disabled", !!options.disabled);
+    shared.createCesiumAttribute(this, "defining", true);
+    shared.createCesiumAttribute(this, "scheme", PlotScheme.resolve(options.scheme), { readonly: true });
+    const sample = options.sample instanceof SampledPlotProperty ? options.sample : new SampledPlotProperty(options.sample);
+    shared.createCesiumProperty(this, "sample", sample);
+    shared.createCesiumAttribute(this, "entities", []);
+    shared.createCesiumAttribute(this, "primitives", []);
+    shared.createCesiumAttribute(this, "groundPrimitives", []);
+    shared.createCesiumAttribute(this, "skeletonEntities", []);
+  }
+  get definitionChanged() {
+    return this._definitionChanged;
+  }
+  isDefining() {
+    return this.defining;
+  }
+  getEntities() {
+    return [...this.entities];
+  }
+  getPrimitives() {
+    return [...this.primitives];
+  }
+  getGroundPrimitives() {
+    return [...this.groundPrimitives];
+  }
+  /**
+   * 获取该标绘的骨架点entity数组
+   *
+   */
+  getSkeletonEntities() {
+    return [...this.skeletonEntities];
+  }
+}
+function useRender(plots, current, getCurrentTime) {
+  const viewer = core$1.useViewer();
+  const primitiveCollection = core$1.usePrimitive(new cesium.PrimitiveCollection());
+  const groundPrimitiveCollection = core$1.usePrimitive(new cesium.PrimitiveCollection(), { collection: "ground" });
+  const dataSource = core$1.useDataSource(new cesium.CustomDataSource());
+  const entityScope = core$1.useEntityScope({ collection: () => dataSource.value.entities });
+  const primitiveScope = core$1.usePrimitiveScope({ collection: () => primitiveCollection.value });
+  const groundPrimitiveScope = core$1.usePrimitiveScope({ collection: () => groundPrimitiveCollection.value });
+  const mouseCartesian = vue.shallowRef();
+  core$1.useScreenSpaceEventHandler(
+    cesium.ScreenSpaceEventType.MOUSE_MOVE,
+    shared.throttle((context) => {
+      mouseCartesian.value = shared.canvasCoordToCartesian(context == null ? void 0 : context.endPosition, viewer.value.scene);
+    }, 10)
+  );
+  core.watchArray(plots, (_value, _oldValue, added, removed = []) => {
+    removed.forEach((plot) => {
+      entityScope.removeWhere((item) => plot.entities.includes(item));
+      primitiveScope.removeWhere((item) => plot.primitives.includes(item));
+      groundPrimitiveScope.removeWhere((item) => plot.groundPrimitives.includes(item));
+    });
+    added.forEach((plot) => {
+      plot.entities.forEach((item) => entityScope.add(item));
+      plot.primitives.forEach((item) => primitiveScope.add(item));
+      plot.groundPrimitives.forEach((item) => groundPrimitiveScope.add(item));
+    });
+  }, {
+    immediate: true
+  });
+  core$1.useCesiumEventListener(
+    () => plots.value.map((item) => item.definitionChanged),
+    (_scope, key, newValue, oldValue) => {
+      if (key === "entities") {
+        const { added, removed } = shared.arrayDifference(newValue, oldValue);
+        added.forEach((item) => entityScope.add(item));
+        removed.forEach((item) => entityScope.remove(item));
+      } else if (key === "primitives") {
+        const { added, removed } = shared.arrayDifference(newValue, oldValue);
+        added.forEach((item) => primitiveScope.add(item));
+        removed.forEach((item) => primitiveScope.remove(item));
+      } else if (key === "groundPrimitives") {
+        const { added, removed } = shared.arrayDifference(newValue, oldValue);
+        added.forEach((item) => groundPrimitiveScope.add(item));
+        removed.forEach((item) => groundPrimitiveScope.remove(item));
+      }
+    }
+  );
+  const update = shared.throttle(async (plot) => {
+    var _a, _b;
+    const reslut = await ((_b = (_a = plot.scheme).render) == null ? void 0 : _b.call(_a, {
+      packable: plot.sample.getValue(getCurrentTime()),
+      mouse: plot.defining ? mouseCartesian.value : void 0,
+      defining: plot.defining,
+      previous: {
+        entities: plot.entities,
+        primitives: plot.primitives,
+        groundPrimitives: plot.groundPrimitives
+      }
+    }));
+    plot.entities = (reslut == null ? void 0 : reslut.entities) ?? [];
+    plot.primitives = (reslut == null ? void 0 : reslut.primitives) ?? [];
+    plot.groundPrimitives = (reslut == null ? void 0 : reslut.groundPrimitives) ?? [];
+  }, 1);
+  vue.watch(current, (plot, previous) => {
+    previous && update(previous);
+  });
+  core$1.useCesiumEventListener(
+    () => plots.value.map((item) => item.definitionChanged),
+    (plot, key) => {
+      if (["disabled", "defining", "scheme", "sample", "time"].includes(key)) {
+        update(plot);
+      }
+    }
+  );
+  vue.watch(mouseCartesian, () => {
+    plots.value.forEach((plot) => plot.defining && update(plot));
+  });
+  return {
+    primitives: vue.computed(() => Array.from(primitiveScope.scope)),
+    groundPrimitives: vue.computed(() => Array.from(primitiveScope.scope)),
+    entities: vue.computed(() => Array.from(entityScope.scope))
+  };
+}
+function useSampled(current, getCurrentTime) {
+  const viewer = core$1.useViewer();
+  const doubleClicking = vue.ref(false);
+  const packable = vue.computed(() => {
+    var _a;
+    return (_a = current.value) == null ? void 0 : _a.sample.getValue(getCurrentTime());
+  });
+  core$1.useScreenSpaceEventHandler(
+    cesium.ScreenSpaceEventType.LEFT_CLICK,
+    async (ctx) => {
+      var _a, _b;
+      await core.promiseTimeout(1);
+      if (!current.value || !packable.value) {
+        return;
+      }
+      if (doubleClicking.value) {
+        return;
+      }
+      const { scheme, defining, sample } = current.value;
+      if (!defining) {
+        return;
+      }
+      const position = shared.canvasCoordToCartesian(ctx.position, viewer.value.scene);
+      if (!position) {
+        return;
+      }
+      (_a = packable.value).positions ?? (_a.positions = []);
+      packable.value.positions.push(position);
+      sample.setSample(packable.value);
+      const completed = (_b = scheme.complete) == null ? void 0 : _b.call(scheme, packable.value);
+      completed && (current.value.defining = false);
+    }
+  );
+  core$1.useScreenSpaceEventHandler(
+    cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK,
+    async (ctx) => {
+      var _a;
+      if (!current.value || !packable.value) {
+        return;
+      }
+      doubleClicking.value = true;
+      await core.promiseTimeout(2);
+      doubleClicking.value = false;
+      const { scheme, defining } = current.value;
+      if (!defining) {
+        return;
+      }
+      const position = shared.canvasCoordToCartesian(ctx.position, viewer.value.scene);
+      if (!position) {
+        return;
+      }
+      const completed = (_a = scheme.forceComplete) == null ? void 0 : _a.call(scheme, packable.value);
+      completed && (current.value.defining = false);
+    }
+  );
+  core$1.useScreenSpaceEventHandler(
+    cesium.ScreenSpaceEventType.RIGHT_CLICK,
+    async () => {
+      var _a;
+      if (!current.value || !packable.value) {
+        return;
+      }
+      const { defining, sample } = current.value;
+      if (!defining) {
+        return;
+      }
+      (_a = packable.value).positions ?? (_a.positions = []);
+      if (packable.value.positions.length === 0) {
+        return;
+      }
+      packable.value.positions.splice(packable.value.positions.length - 1, 1);
+      sample.setSample(packable.value);
+    }
+  );
+  const definingCursorCss = vue.ref();
+  const setDefiningCursorCss = () => {
+    var _a, _b;
+    if (!((_a = current.value) == null ? void 0 : _a.defining)) {
+      if (definingCursorCss.value) {
+        definingCursorCss.value = void 0;
+        viewer.value.container.parentElement.style.removeProperty("cursor");
+      }
+    } else {
+      const definingCursor = current.value.scheme.definingCursor;
+      definingCursorCss.value = shared.isFunction(definingCursor) ? definingCursor(packable.value) : vue.toValue(definingCursor);
+      if (definingCursorCss.value) {
+        (_b = viewer.value) == null ? void 0 : _b.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
+      }
+    }
+  };
+  core$1.useCesiumEventListener(() => {
+    var _a;
+    return (_a = current.value) == null ? void 0 : _a.definitionChanged;
+  }, (plot, key) => {
+    if (key === "defining" || key === "sample") {
+      setDefiningCursorCss();
+    }
+  });
+  vue.watch(current, () => setDefiningCursorCss());
+}
+class PlotSkeletonEntity extends cesium.Entity {
+  constructor(options) {
+    super(options);
+  }
+}
+function useSkeleton(plots, current, getCurrentTime) {
+  const viewer = core$1.useViewer();
+  const dataSource = core$1.useDataSource(new cesium.CustomDataSource());
+  const entityScope = core$1.useEntityScope({ collection: () => dataSource.value.entities });
+  const hoverEntity = vue.shallowRef();
+  const activeEntity = vue.shallowRef();
+  const getPointAction = (entity) => {
+    var _a, _b;
+    if (!entity) {
+      return PlotAction.IDLE;
+    }
+    return ((_a = activeEntity.value) == null ? void 0 : _a.id) === entity.id ? PlotAction.ACTIVE : ((_b = hoverEntity.value) == null ? void 0 : _b.id) === entity.id ? PlotAction.HOVER : PlotAction.IDLE;
+  };
+  const update = shared.throttle((plot, destroyed) => {
+    const oldEntities = plot.getSkeletonEntities();
+    const entities = [];
+    if (destroyed || plot.disabled) {
+      plot.skeletonEntities = [];
+    } else {
+      const packable = plot.sample.getValue(getCurrentTime());
+      const defining = plot.defining;
+      const active = current.value === plot;
+      const skeletons = plot.scheme.skeletons;
+      skeletons.forEach((skeleton) => {
+        var _a;
+        const diabled = shared.isFunction(skeleton.diabled) ? skeleton.diabled({ active, defining }) : skeleton.diabled;
+        if (diabled) {
+          return;
+        }
+        const positions = ((_a = skeleton.format) == null ? void 0 : _a.call(skeleton, packable)) ?? (packable == null ? void 0 : packable.positions) ?? [];
+        positions.forEach((position, index) => {
+          var _a2;
+          let entity = oldEntities.find((item) => item.index === index && item.skeleton === skeleton);
+          const options = (_a2 = skeleton.render) == null ? void 0 : _a2.call(skeleton, {
+            defining,
+            active,
+            index,
+            packable,
+            positions,
+            position,
+            action: getPointAction(entity)
+          });
+          const merge = new PlotSkeletonEntity(options ?? {});
+          if (entity) {
+            merge.propertyNames.forEach((key) => {
+              if (key !== "id") {
+                entity[key] = merge[key];
+              }
+            });
+          } else {
+            entity = merge;
+          }
+          entity.plot = plot;
+          entity.skeleton = skeleton;
+          entity.index = index;
+          entities.push(entity);
+        });
+      });
+    }
+    plot.skeletonEntities = entities;
+  }, 1);
+  core$1.useGraphicDrag({
+    cursor: (pick) => {
+      var _a;
+      if (!((_a = current.value) == null ? void 0 : _a.defining) && entityScope.scope.has(pick.id)) {
+        const skeleton = pick.id.skeleton;
+        return shared.isFunction(skeleton == null ? void 0 : skeleton.cursor) ? skeleton.cursor(pick) : vue.toValue(skeleton == null ? void 0 : skeleton.cursor);
+      }
+    },
+    dragCursor: (pick) => {
+      var _a;
+      if (!((_a = current.value) == null ? void 0 : _a.defining) && entityScope.scope.has(pick.id)) {
+        const skeleton = pick.id.skeleton;
+        return shared.isFunction(skeleton == null ? void 0 : skeleton.dragCursor) ? skeleton.dragCursor(pick) : vue.toValue(skeleton == null ? void 0 : skeleton.dragCursor);
+      }
+    },
+    listener: (params) => {
+      var _a;
+      if (params.pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(params.pick.id)) {
+        const entity = params.pick.id;
+        const plot = entity.plot;
+        if (plot.defining) {
+          return;
+        }
+        activeEntity.value = entity;
+        const skeleton = entity.skeleton;
+        const index = entity.index;
+        const packable = plot.sample.getValue(getCurrentTime());
+        (_a = skeleton.onDrag) == null ? void 0 : _a.call(skeleton, {
+          viewer: viewer.value,
+          sample: plot.sample,
+          packable,
+          active: current.value === plot,
+          index,
+          context: params.context,
+          dragging: params.dragging,
+          lockCamera: params.lockCamera
+        });
+      } else {
+        activeEntity.value = void 0;
+      }
+    }
+  });
+  core.onKeyStroke((keyEvent) => {
+    var _a;
+    if (activeEntity.value) {
+      const entity = activeEntity.value;
+      const plot = entity.plot;
+      const skeleton = entity.skeleton;
+      const index = entity.index;
+      const packable = plot.sample.getValue(getCurrentTime());
+      (_a = skeleton.onKeyPressed) == null ? void 0 : _a.call(skeleton, {
+        viewer: viewer.value,
+        sample: plot.sample,
+        packable,
+        index,
+        keyEvent
+      });
+    }
+  });
+  core$1.useGraphicHover({
+    listener: ({ hovering, pick }) => {
+      if (hovering && pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+        const entity = pick.id;
+        hoverEntity.value = entity;
+      } else {
+        hoverEntity.value = void 0;
+      }
+    }
+  });
+  core$1.useGraphicLeftClick({
+    listener: ({ context, pick }) => {
+      var _a;
+      if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+        const entity = pick.id;
+        activeEntity.value = entity;
+        const plot = entity.plot;
+        const skeleton = entity.skeleton;
+        const index = entity.index;
+        const packable = plot.sample.getValue(getCurrentTime());
+        (_a = skeleton.onLeftClick) == null ? void 0 : _a.call(skeleton, {
+          viewer: viewer.value,
+          sample: plot.sample,
+          packable,
+          active: current.value === plot,
+          defining: plot.defining,
+          index,
+          context
+        });
+      } else {
+        activeEntity.value = void 0;
+      }
+    }
+  });
+  core.watchArray(plots, (value, oldValue, added, removed = []) => {
+    added.forEach((plot) => update(plot));
+    removed.forEach((plot) => update(plot, true));
+  });
+  core$1.useCesiumEventListener(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
+    if (["disabled", "defining", "scheme", "sample", "time"].includes(key)) {
+      update(plot);
+    }
+    if (key === "skeletonEntities") {
+      const { added, removed } = shared.arrayDifference(newValue, oldValue);
+      added.forEach((item) => entityScope.add(item));
+      removed.forEach((item) => entityScope.remove(item));
+    }
+  });
+  vue.watch(current, (plot, previous) => {
+    plot && update(plot);
+    setTimeout(() => {
+      previous && update(previous);
+    }, 2);
+  });
+  return {
+    dataSource
+  };
+}
+function usePlot(options) {
+  const time = (options == null ? void 0 : options.time) || vue.shallowRef();
+  const viewer = useViewer.useViewer();
+  const getCurrentTime = () => {
+    var _a, _b, _c;
+    return ((_a = time.value) == null ? void 0 : _a.clone()) || ((_c = (_b = viewer.value) == null ? void 0 : _b.clock.currentTime) == null ? void 0 : _c.clone()) || cesium.JulianDate.now();
+  };
+  const collection = vue.shallowReactive(/* @__PURE__ */ new Set());
+  const plots = vue.computed(() => Array.from(collection));
+  const current = vue.shallowRef();
+  const packable = vue.shallowRef();
+  core$1.useCesiumEventListener([
+    () => {
+      var _a;
+      return (_a = current.value) == null ? void 0 : _a.sample.definitionChanged;
+    }
+  ], () => {
+    var _a;
+    packable.value = (_a = current.value) == null ? void 0 : _a.sample.getValue(getCurrentTime());
+  });
+  useSampled(current, getCurrentTime);
+  useRender(plots, current, getCurrentTime);
+  useSkeleton(plots, current, getCurrentTime);
+  core$1.useScreenSpaceEventHandler(cesium.ScreenSpaceEventType.LEFT_CLICK, (data) => {
+    var _a, _b, _c;
+    if ((_a = current.value) == null ? void 0 : _a.defining) {
+      return;
+    }
+    const pick = (_b = viewer.value) == null ? void 0 : _b.scene.pick(data.position.clone());
+    if (((_c = pick == null ? void 0 : pick.id) == null ? void 0 : _c.plot) instanceof Plot) {
+      return;
+    }
+    if (!pick) {
+      current.value = void 0;
+      return;
+    }
+    current.value = plots.value.find((plot) => shared.pickHitGraphic(pick, [...plot.entities, ...plot.primitives, ...plot.groundPrimitives]));
+  });
+  let operateResolve;
+  let operateReject;
+  vue.watch(current, (plot, previous) => {
+    var _a, _b;
+    if (previous) {
+      if (previous.defining) {
+        const packable2 = previous.sample.getValue(getCurrentTime());
+        const completed = (_b = (_a = previous.scheme).forceComplete) == null ? void 0 : _b.call(_a, packable2);
+        if (completed) {
+          previous.defining = false;
+          operateResolve == null ? void 0 : operateResolve(previous);
+        } else {
+          collection.delete(previous);
+        }
+      }
+    }
+  });
+  const operate = async (plot) => {
+    return new Promise((resolve, reject) => {
+      operateResolve = resolve;
+      operateReject = reject;
+      const _plot = plot instanceof Plot ? plot : new Plot(plot);
+      if (!collection.has(_plot)) {
+        collection.add(_plot);
+      }
+      current.value = _plot;
+      return resolve(_plot);
+    });
+  };
+  const remove = (plot) => {
+    if (plot === current.value) {
+      current.value = void 0;
+    }
+    if (collection.has(plot)) {
+      collection.delete(plot);
+      return true;
+    }
+    return false;
+  };
+  return {
+    plots,
+    time,
+    operate,
+    remove,
+    cancel: operateReject
+  };
+}
+exports.PLOT_BILLBOARD_SCHEME = PLOT_BILLBOARD_SCHEME;
+exports.PLOT_LABEL_SCHEME = PLOT_LABEL_SCHEME;
+exports.PLOT_LINE_STRING_SCHEME = PLOT_LINE_STRING_SCHEME;
+exports.PLOT_POLYGON_SCHEME = PLOT_POLYGON_SCHEME;
+exports.Plot = Plot;
+exports.PlotScheme = PlotScheme;
+exports.SampledPlotProperty = SampledPlotProperty;
+exports.SampledPlotStrategy = SampledPlotStrategy;
+exports.usePlot = usePlot;
+//# sourceMappingURL=index.cjs.map