@vesium/plot 1.0.1-beta.51 → 1.0.1-beta.54

package/dist/index.iife.js

@@ -1,1510 +1,2031 @@
-(function(exports, cesium, vesium, __vueuse_core, vue) {
+(function(exports, cesium, vesium, __vueuse_core, vue, __vesium_geometry, __turf_turf) {
 
 //#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
 
 //#endregion
 cesium = __toESM(cesium);
 vesium = __toESM(vesium);
 __vueuse_core = __toESM(__vueuse_core);
 vue = __toESM(vue);
+__vesium_geometry = __toESM(__vesium_geometry);
+__turf_turf = __toESM(__turf_turf);
 
 //#region usePlot/PlotScheme.ts
-var PlotScheme = class PlotScheme {
-	constructor(options) {
-		this.type = options.type;
-		this.complete = options.complete;
-		this.allowManualComplete = options.allowManualComplete;
-		this.definingCursor = options.definingCursor ?? "crosshair";
-		this.skeletons = options.skeletons?.map((item) => item()) ?? [];
-		this.initEntites = options.initEntites;
-		this.initPrimitives = options.initPrimitives;
-		this.initGroundPrimitives = options.initGroundPrimitives;
-		this.render = options.render;
-	}
-	/**
-	* 标绘类型。应当是全局唯一的字符串，会作为键名缓存
-	*/
-	type;
-	/**
-	* 判断是否立即完成标绘.
-	* 每次控制点发生变变化时，执行该回调函数，返回`true`则完成标绘
-	*/
-	complete;
-	/**
-	* 判断是否允许手动完成标绘。
-	* 每次控制点发生变变化时，执行该回调函数，返回`true`则后续左键双击即完成标绘
-	*/
-	allowManualComplete;
-	/**
-	* 处于定义态时鼠标的样式
-	* @default 'crosshair'
-	*/
-	definingCursor;
-	/**
-	* 当前标绘的框架点数据
-	*/
-	skeletons;
-	/**
-	* 初始化时创建`Entity`的函数，创建后的`Entity`会作为配置项传入`render`中
-	*/
-	initEntites;
-	/**
-	* 初始化时创建`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-	*/
-	initPrimitives;
-	/**
-	* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-	*/
-	initGroundPrimitives;
-	/**
-	* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
-	*/
-	render;
-	static _record = /* @__PURE__ */ new Map();
-	/**
-	* 标绘方案缓存。
-	* 每次标绘时都会将`PlotScheme.type`作为键名缓存，
-	* 后续可用过`PlotScheme.getCache(type)`获取完整的`PlotScheme`配置。
-	*/
-	static getCacheTypes() {
-		return [...this._record.keys()];
-	}
-	/**
-	* 通过`PlotScheme.type`获取缓存中的`PlotScheme`配置。
-	*/
-	static getCache(type) {
-		return PlotScheme._record.get(type);
-	}
+	var PlotScheme = class PlotScheme {
+		constructor(options) {
+			this.type = options.type;
+			this.complete = options.complete;
+			this.allowManualComplete = options.allowManualComplete;
+			this.definingCursor = options.definingCursor ?? "crosshair";
+			this.skeletons = options.skeletons?.map((item) => item()) ?? [];
+			this.initRender = options.initRender;
+			this.render = options.render;
+		}
+		/**
+		* 标绘类型。应当是全局唯一的字符串，会作为键名缓存
+		*/
+		type;
+		/**
+		* 判断是否立即完成标绘.
+		* 每次控制点发生变变化时，执行该回调函数，返回`true`则完成标绘
+		*/
+		complete;
+		/**
+		* 判断是否允许手动完成标绘。
+		* 每次控制点发生变变化时，执行该回调函数，返回`true`则后续左键双击即完成标绘
+		*/
+		allowManualComplete;
+		/**
+		* 处于定义态时鼠标的样式
+		* @default 'crosshair'
+		*/
+		definingCursor;
+		/**
+		* 当前标绘的框架点数据
+		*/
+		skeletons;
+		/**
+		* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
+		*/
+		initRender;
+		/**
+		* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
+		*/
+		render;
+		static _record = /* @__PURE__ */ new Map();
+		/**
+		* 标绘方案缓存。
+		* 每次标绘时都会将`PlotScheme.type`作为键名缓存，
+		* 后续可用过`PlotScheme.getCache(type)`获取完整的`PlotScheme`配置。
+		*/
+		static getCacheTypes() {
+			return [...this._record.keys()];
+		}
+		/**
+		* 通过`PlotScheme.type`获取缓存中的`PlotScheme`配置。
+		*/
+		static getCache(type) {
+			return PlotScheme._record.get(type);
+		}
+		/**
+		* 缓存标绘方案。
+		*/
+		static setCache(scheme) {
+			(0, vesium.assertError)(!scheme.type, "`scheme.type` is required");
+			PlotScheme._record.set(scheme.type, scheme);
+		}
+		/**
+		* 解析传入的maybeScheme，maybeScheme可能是一个完整的PlotScheme，也可能是缓存中的`PlotScheme.type`，并返回 PlotScheme 实例。
+		* 若传入的是`PlotScheme.type`字符串，并且缓存中不存在该标绘方案，则抛出错误。
+		*/
+		static resolve(maybeScheme) {
+			if (typeof maybeScheme === "string") {
+				const _scheme = PlotScheme.getCache(maybeScheme);
+				(0, __vueuse_core.assert)(!!_scheme, `scheme ${maybeScheme} not found`);
+				return _scheme;
+			} else if (!(maybeScheme instanceof PlotScheme)) return new PlotScheme(maybeScheme);
+			else return maybeScheme;
+		}
+	};
+
+//#endregion
+//#region usePlot/SampledPlotProperty.ts
+	let SampledPlotStrategy = /* @__PURE__ */ function(SampledPlotStrategy$1) {
+		SampledPlotStrategy$1[SampledPlotStrategy$1["NEAR"] = 0] = "NEAR";
+		SampledPlotStrategy$1[SampledPlotStrategy$1["CYCLE"] = 1] = "CYCLE";
+		SampledPlotStrategy$1[SampledPlotStrategy$1["STRICT"] = 2] = "STRICT";
+		return SampledPlotStrategy$1;
+	}({});
 	/**
-	* 缓存标绘方案。
+	* 默认插值算法
+	*
+	* @param time 时间
+	* @param previous 前一个数据点
+	* @param next 后一个数据点
+	* @param proportion 比例
+	* @returns 插值结果
 	*/
-	static setCache(scheme) {
-		(0, vesium.assertError)(!scheme.type, "`scheme.type` is required");
-		PlotScheme._record.set(scheme.type, scheme);
-	}
+	const defaultInterpolationAlgorithm = (time, previous, next, proportion) => {
+		if (proportion === 0) return {
+			time,
+			positions: previous.positions?.map((item) => item.clone()),
+			derivative: previous.derivative
+		};
+		else if (proportion === 1) return {
+			time,
+			positions: next.positions?.map((item) => item.clone()),
+			derivative: previous.derivative
+		};
+		return {
+			time,
+			positions: next.positions?.map((right, index) => {
+				const left = previous.positions?.[index];
+				return !left ? right : cesium.Cartesian3.lerp(left, right, proportion, new cesium.Cartesian3());
+			}),
+			derivative: previous.derivative
+		};
+	};
 	/**
-	* 解析传入的maybeScheme，maybeScheme可能是一个完整的PlotScheme，也可能是缓存中的`PlotScheme.type`，并返回 PlotScheme 实例。
-	* 若传入的是`PlotScheme.type`字符串，并且缓存中不存在该标绘方案，则抛出错误。
+	* 标绘采样点数据。
+	* 标绘采样点数据是一个时间序列数据，包含时间、位置和附带的额外数据。
+	* 具体用法可参考 [Cesium.SampledProperty](https://cesium.com/learn/cesiumjs/ref-doc/SampledProperty.html)
 	*/
-	static resolve(maybeScheme) {
-		if (typeof maybeScheme === "string") {
-			const _scheme = PlotScheme.getCache(maybeScheme);
-			(0, __vueuse_core.assert)(!!_scheme, `scheme ${maybeScheme} not found`);
-			return _scheme;
-		} else if (!(maybeScheme instanceof PlotScheme)) return new PlotScheme(maybeScheme);
-		else return maybeScheme;
-	}
-};
+	var SampledPlotProperty = class SampledPlotProperty {
+		constructor(options) {
+			this.interpolationAlgorithm = options?.interpolationAlgorithm;
+			this.strategy = options?.strategy ?? SampledPlotStrategy.NEAR;
+			options?.packables?.forEach((packable) => this.setSample(packable));
+			if (!this._times.length) this.setSample({
+				time: new cesium.JulianDate(0, 0),
+				positions: [],
+				derivative: void 0
+			});
+		}
+		static defaultInterpolationAlgorithm = defaultInterpolationAlgorithm;
+		strategy;
+		interpolationAlgorithm;
+		/**
+		* @internal
+		*/
+		_times = [];
+		/**
+		* @internal
+		*/
+		_sampleds = [];
+		/**
+		* @internal
+		*/
+		_derivatives = [];
+		get isConstant() {
+			return this._times.length === 0;
+		}
+		/**
+		* @internal
+		*/
+		_definitionChanged = new cesium.Event();
+		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 SampledPlotStrategy.STRICT: return;
+				case SampledPlotStrategy.NEAR:
+					time = cesium.JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
+					break;
+				case SampledPlotStrategy.CYCLE: {
+					const startMS = cesium.JulianDate.toDate(this._times[0]).getTime();
+					const duration = cesium.JulianDate.toDate(this._times[this._times.length - 1]).getTime() - startMS;
+					const diff = (cesium.JulianDate.toDate(time).getTime() - 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();
+			return {
+				prevIndex,
+				nextIndex,
+				proportion: (cesium.JulianDate.toDate(time).getTime() - prevMs) / (nextMs - prevMs) || 0
+			};
+		}
+		/**
+		* 根据给定的儒略日期（JulianDate）获取插值后的样本点数据。
+		*
+		* @param time 指定的儒略日期（JulianDate）。
+		* @param result 可选参数，用于存储结果的容器。如果未提供，则创建一个新的容器。
+		* @returns 插值后的样本点数据，存储在提供的或新创建的result容器中。
+		* @template D 数据类型。
+		*/
+		getValue(time, result) {
+			result ??= {
+				time,
+				positions: []
+			};
+			Object.assign(result, {
+				time: time?.clone(),
+				positions: [],
+				derivative: void 0
+			});
+			if (!time) {
+				result.time = this._times[0].clone();
+				result.positions = this._sampleds[0]?.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) {
+			const time = value.time?.clone() ?? this._times[0].clone();
+			const positions = value.positions?.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);
+				if (this._times.splice(index, 1).length) {
+					this._definitionChanged.raiseEvent(this);
+					return true;
+				}
+			}
+			return false;
+		}
+		/**
+		* 从样本中移除指定时间间隔内的样本。
+		*
+		* @param interval 要移除样本的时间间隔
+		*/
+		removeSamples(interval$1) {
+			for (let i = 0; i < this._times.length; i++) {
+				const time = this._times[i];
+				cesium.TimeInterval.contains(interval$1, time) && this.removeSample(time);
+			}
+		}
+		/**
+		* 判断两个property是否相等
+		*/
+		equals(other) {
+			return other === this;
+		}
+	};
 
 //#endregion
-//#region usePlot/SampledPlotProperty.ts
-let SampledPlotStrategy = /* @__PURE__ */ function(SampledPlotStrategy$1) {
-	SampledPlotStrategy$1[SampledPlotStrategy$1["NEAR"] = 0] = "NEAR";
-	SampledPlotStrategy$1[SampledPlotStrategy$1["CYCLE"] = 1] = "CYCLE";
-	SampledPlotStrategy$1[SampledPlotStrategy$1["STRICT"] = 2] = "STRICT";
-	return SampledPlotStrategy$1;
-}({});
+//#region usePlot/PlotFeature.ts
 /**
-* 默认插值算法
-*
-* @param time 时间
-* @param previous 前一个数据点
-* @param next 后一个数据点
-* @param proportion 比例
-* @returns 插值结果
-*/
-const defaultInterpolationAlgorithm = (time, previous, next, proportion) => {
-	if (proportion === 0) return {
-		time,
-		positions: previous.positions?.map((item) => item.clone()),
-		derivative: previous.derivative
-	};
-	else if (proportion === 1) return {
-		time,
-		positions: next.positions?.map((item) => item.clone()),
-		derivative: previous.derivative
-	};
-	return {
-		time,
-		positions: next.positions?.map((right, index) => {
-			const left = previous.positions?.[index];
-			return !left ? right : cesium.Cartesian3.lerp(left, right, proportion, new cesium.Cartesian3());
-		}),
-		derivative: previous.derivative
+	* 标绘实例
+	*/
+	var PlotFeature = class {
+		constructor(options) {
+			const { id, disabled = false, sampled } = options;
+			this._id = id || (0, cesium.createGuid)();
+			this._scheme = PlotScheme.resolve(options.scheme);
+			this._definitionChanged = new cesium.Event();
+			this._defining = true;
+			this._disabled = disabled;
+			this._sampled = sampled instanceof SampledPlotProperty ? sampled : new SampledPlotProperty(sampled);
+			this._sampled.definitionChanged.addEventListener((property) => this._definitionChanged.raiseEvent(this, "sampled", property, property), this);
+			const init = this._scheme.initRender?.() ?? {};
+			this._entities = [...init.entities ?? []];
+			this._primitives = [...init.primitives ?? []];
+			this._groundPrimitives = [...init.groundPrimitives ?? []];
+			this._skeletons = [];
+		}
+		/**
+		* @internal
+		*/
+		_id;
+		get id() {
+			return this._id;
+		}
+		/**
+		* @internal
+		*/
+		_scheme;
+		get scheme() {
+			return this._scheme;
+		}
+		/**
+		* @internal
+		*/
+		_definitionChanged;
+		get definitionChanged() {
+			return this._definitionChanged;
+		}
+		/**
+		* @internal
+		*/
+		_defining;
+		get defining() {
+			return this._defining;
+		}
+		/**
+		* @internal
+		*/
+		static setDefining(plot, value) {
+			if (plot._defining !== value) {
+				plot._definitionChanged.raiseEvent(plot, "defining", value, plot._defining);
+				plot._defining = value;
+			}
+		}
+		/**
+		* @internal
+		*/
+		_disabled;
+		/**
+		* 获取禁用状态
+		*
+		* 当为 `true` 时，标绘实例将停止响应交互和更新；
+		* 为 `false` 时恢复正常功能。
+		*/
+		get disabled() {
+			return this._disabled;
+		}
+		set disabled(value) {
+			this.disabled = value;
+		}
+		/**
+		* @internal
+		*/
+		_sampled;
+		get sampled() {
+			return this._sampled;
+		}
+		/**
+		* @internal
+		*/
+		_entities;
+		get entities() {
+			return this._entities;
+		}
+		set entities(value) {
+			this._definitionChanged.raiseEvent(this, "entities", value, this._entities);
+			this._entities = value;
+		}
+		/**
+		* @internal
+		*/
+		_primitives;
+		get primitives() {
+			return this._primitives;
+		}
+		/**
+		* @internal
+		*/
+		set primitives(value) {
+			this._definitionChanged.raiseEvent(this, "primitives", value, this._primitives);
+			this._primitives = value;
+		}
+		/**
+		* @internal
+		*/
+		_groundPrimitives;
+		get groundPrimitives() {
+			return this._groundPrimitives;
+		}
+		/**
+		* @internal
+		*/
+		set groundPrimitives(value) {
+			this._definitionChanged.raiseEvent(this, "groundPrimitives", value, this._groundPrimitives);
+			this._groundPrimitives = value;
+		}
+		/**
+		* @internal
+		*/
+		_skeletons;
+		get skeletons() {
+			return this._skeletons;
+		}
+		/**
+		* @internal
+		*/
+		set skeletons(value) {
+			this._definitionChanged.raiseEvent(this, "skeletons", value, this._skeletons);
+			this._skeletons = value;
+		}
 	};
-};
+
+//#endregion
+//#region usePlot/PlotSkeleton.ts
 /**
-* 标绘采样点数据。
-* 标绘采样点数据是一个时间序列数据，包含时间、位置和附带的额外数据。
-* 具体用法可参考 [Cesium.SampledProperty](https://cesium.com/learn/cesiumjs/ref-doc/SampledProperty.html)
-*/
-var SampledPlotProperty = class SampledPlotProperty {
-	constructor(options) {
-		this.interpolationAlgorithm = options?.interpolationAlgorithm;
-		this.strategy = options?.strategy ?? SampledPlotStrategy.NEAR;
-		options?.packables?.forEach((packable) => this.setSample(packable));
-		if (!this._times.length) this.setSample({
-			time: new cesium.JulianDate(0, 0),
-			positions: [],
-			derivative: void 0
-		});
-	}
-	static defaultInterpolationAlgorithm = defaultInterpolationAlgorithm;
-	strategy;
-	interpolationAlgorithm;
-	/**
-	* @internal
+	* 框架点执行状态枚举
+	* - IDLE 空闲状态
+	* - HOVER 悬停状态
+	* - ACTIVE 激活状态
 	*/
-	_times = [];
+	let PlotAction = /* @__PURE__ */ function(PlotAction$1) {
+		PlotAction$1[PlotAction$1["IDLE"] = 0] = "IDLE";
+		PlotAction$1[PlotAction$1["HOVER"] = 1] = "HOVER";
+		PlotAction$1[PlotAction$1["ACTIVE"] = 2] = "ACTIVE";
+		return PlotAction$1;
+	}({});
 	/**
-	* @internal
+	* 标绘框架点 Entity
 	*/
-	_sampleds = [];
-	/**
-	* @internal
-	*/
-	_derivatives = [];
-	get isConstant() {
-		return this._times.length === 0;
-	}
-	/**
-	* @internal
-	*/
-	_definitionChanged = new cesium.Event();
-	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 SampledPlotStrategy.STRICT: return;
-			case SampledPlotStrategy.NEAR: {
-				time = cesium.JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
-				break;
-			}
-			case SampledPlotStrategy.CYCLE: {
-				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;
-			}
+	var PlotSkeletonEntity = class extends cesium.Entity {
+		constructor(options) {
+			super(options);
 		}
-		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();
+	};
+
+//#endregion
+//#region usePlot/useRender.ts
+	function useRender(plots, current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const primitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection());
+		const groundPrimitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection(), { collection: "ground" });
+		const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
+		const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
+		const primitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => primitiveCollection.value });
+		const groundPrimitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => groundPrimitiveCollection.value });
+		const mouseCartesian = (0, vue.shallowRef)();
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.MOUSE_MOVE, (event) => {
+			mouseCartesian.value = (0, vesium.canvasCoordToCartesian)(event?.endPosition, viewer.value.scene);
+		});
+		(0, __vueuse_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,
+			flush: "post"
+		});
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (_scope, key, newValue, oldValue) => {
+			if (key === "entities") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => entityScope.add(item));
+				removed.forEach((item) => entityScope.remove(item));
+			} else if (key === "primitives") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => primitiveScope.add(item));
+				removed.forEach((item) => primitiveScope.remove(item));
+			} else if (key === "groundPrimitives") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => groundPrimitiveScope.add(item));
+				removed.forEach((item) => groundPrimitiveScope.remove(item));
+			}
+		});
+		const update = async (plot) => {
+			await (0, vue.nextTick)();
+			const packable = plot.sampled.getValue(getCurrentTime());
+			const mouse = plot.defining ? mouseCartesian.value : void 0;
+			const result = await plot.scheme.render?.({
+				packable,
+				mouse,
+				defining: plot.defining,
+				previous: {
+					entities: plot.entities,
+					primitives: plot.primitives,
+					groundPrimitives: plot.groundPrimitives
+				},
+				getPositions() {
+					const points = packable.positions;
+					mouse && points.push(mouse);
+					return points;
+				}
+			});
+			plot.entities = result?.entities ?? [];
+			plot.primitives = result?.primitives ?? [];
+			plot.groundPrimitives = result?.groundPrimitives ?? [];
+		};
+		(0, vue.watch)(current, (plot, previous) => {
+			previous && update(previous);
+		});
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (plot, key) => {
+			if ([
+				"disabled",
+				"defining",
+				"scheme",
+				"sampled",
+				"time"
+			].includes(key)) update(plot);
+		});
+		(0, vue.watch)(mouseCartesian, () => {
+			plots.value.forEach((plot) => plot.defining && update(plot));
+		});
 		return {
-			prevIndex,
-			nextIndex,
-			proportion: (ms - prevMs) / (nextMs - prevMs) || 0
+			primitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
+			groundPrimitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
+			entities: (0, vue.computed)(() => Array.from(entityScope.scope))
 		};
 	}
-	/**
-	* 根据给定的儒略日期（JulianDate）获取插值后的样本点数据。
-	*
-	* @param time 指定的儒略日期（JulianDate）。
-	* @param result 可选参数，用于存储结果的容器。如果未提供，则创建一个新的容器。
-	* @returns 插值后的样本点数据，存储在提供的或新创建的result容器中。
-	* @template D 数据类型。
-	*/
-	getValue(time, result) {
-		result ??= { time };
-		Object.assign(result, {
-			time: time?.clone(),
-			positions: void 0,
-			derivative: void 0
+
+//#endregion
+//#region usePlot/useSampled.ts
+	function useSampled(current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const doubleClicking = (0, vue.ref)(false);
+		const packable = (0, vue.computed)(() => {
+			return current.value?.sampled.getValue(getCurrentTime());
 		});
-		if (!time) {
-			result.time = this._times[0].clone();
-			result.positions = this._sampleds[0]?.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]
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, async (ctx) => {
+			await (0, __vueuse_core.promiseTimeout)(1);
+			if (!current.value || !packable.value) return;
+			if (doubleClicking.value) return;
+			const { scheme, defining, sampled } = current.value;
+			if (!defining) return;
+			const position = (0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene);
+			if (!position) return;
+			packable.value.positions ??= [];
+			packable.value.positions.push(position);
+			sampled.setSample(packable.value);
+			scheme.complete?.(packable.value) && PlotFeature.setDefining(current.value, false);
+		});
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
+			if (!current.value || !packable.value) return;
+			doubleClicking.value = true;
+			await (0, __vueuse_core.promiseTimeout)(2);
+			doubleClicking.value = false;
+			const { scheme, defining } = current.value;
+			if (!defining) return;
+			if (!(0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene)) return;
+			scheme.allowManualComplete?.(packable.value) && PlotFeature.setDefining(current.value, false);
+		});
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.RIGHT_CLICK, async () => {
+			if (!current.value || !packable.value) return;
+			const { defining, sampled } = current.value;
+			if (!defining) return;
+			packable.value.positions ??= [];
+			if (packable.value.positions.length === 0) return;
+			packable.value.positions.splice(packable.value.positions.length - 1, 1);
+			sampled.setSample(packable.value);
+		});
+		const definingCursorCss = (0, vue.ref)();
+		const setDefiningCursorCss = () => {
+			if (!current.value?.defining) {
+				if (definingCursorCss.value) {
+					definingCursorCss.value = void 0;
+					viewer.value.container.parentElement.style.removeProperty("cursor");
+				}
+			} else {
+				const definingCursor = current.value.scheme.definingCursor;
+				definingCursorCss.value = (0, vesium.isFunction)(definingCursor) ? definingCursor(packable.value) : definingCursor;
+				if (definingCursorCss.value) viewer.value?.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
+			}
 		};
-		const packable = (this.interpolationAlgorithm || SampledPlotProperty.defaultInterpolationAlgorithm)(time, previous, next, proportion);
-		Object.assign(result, packable);
-		return result;
-	}
-	/**
-	* 设置样本数据，如果传入的数据不含时间，则会存入时间最早的集合中
-	* @param value 样本数据对象，包含时间、位置和导数信息
-	*/
-	setSample(value) {
-		const time = value.time?.clone() ?? this._times[0].clone();
-		const positions = value.positions?.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);
+		(0, vesium.useCesiumEventListener)(() => current.value?.definitionChanged, (plot, key) => {
+			if (key === "defining" || key === "sampled") setDefiningCursorCss();
+		});
+		(0, vue.watch)(current, () => setDefiningCursorCss());
 	}
-	/**
-	* 设置样本数据
-	*
-	* @param values 样本数据数组，每个元素都是类型为SampledPlotPackable<D>的对象
-	*/
-	setSamples(values) {
-		values.forEach((value) => this.setSample(value));
+
+//#endregion
+//#region usePlot/useSkeleton.ts
+	function useSkeleton(plots, current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
+		const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
+		const hoverEntity = (0, vue.shallowRef)();
+		const activeEntity = (0, vue.shallowRef)();
+		const getPointAction = (entity) => {
+			if (!entity) return PlotAction.IDLE;
+			return activeEntity.value?.id === entity.id ? PlotAction.ACTIVE : hoverEntity.value?.id === entity.id ? PlotAction.HOVER : PlotAction.IDLE;
+		};
+		const update = (plot, destroyed) => {
+			const oldEntities = plot.skeletons;
+			const entities = [];
+			if (destroyed || plot.disabled) plot.skeletons = [];
+			else {
+				const packable = plot.sampled.getValue(getCurrentTime());
+				const defining = plot.defining;
+				const active = current.value === plot;
+				plot.scheme.skeletons.forEach((skeleton) => {
+					if ((0, vesium.isFunction)(skeleton.disabled) ? skeleton.disabled({
+						active,
+						defining
+					}) : skeleton.disabled) return;
+					const positions = skeleton.format?.(packable) ?? packable?.positions ?? [];
+					positions.forEach((position, index) => {
+						let entity = oldEntities.find((item) => item.index === index && item.skeleton === skeleton);
+						const options = skeleton.render?.({
+							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.skeletons = entities;
+		};
+		const graphicEvent = (0, vesium.useGraphicEvent)();
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
+				if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+					const entity = pick.id;
+					const plot = entity.plot;
+					if (plot.defining) return;
+					activeEntity.value = entity;
+					const skeleton = entity.skeleton;
+					const index = entity.index;
+					const packable = plot.sampled.getValue(getCurrentTime());
+					skeleton.onDrag?.({
+						viewer: viewer.value,
+						sampled: plot.sampled,
+						packable,
+						active: current.value === plot,
+						index,
+						event,
+						dragging,
+						lockCamera
+					});
+				} else activeEntity.value = void 0;
+			}, {
+				cursor: ({ pick }) => {
+					if (!current.value?.defining && entityScope.scope.has(pick.id)) {
+						const skeleton = pick.id.skeleton;
+						return (0, vesium.isFunction)(skeleton?.cursor) ? skeleton.cursor(pick) : (0, vue.toValue)(skeleton?.cursor);
+					}
+				},
+				dragCursor: ({ pick }) => {
+					if (!current.value?.defining && entityScope.scope.has(pick.id)) {
+						const skeleton = pick.id.skeleton;
+						return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
+					}
+				}
+			}));
+		});
+		(0, __vueuse_core.onKeyStroke)((keyEvent) => {
+			if (activeEntity.value) {
+				const entity = activeEntity.value;
+				const plot = entity.plot;
+				const skeleton = entity.skeleton;
+				const index = entity.index;
+				const packable = plot.sampled.getValue(getCurrentTime());
+				skeleton.onKeyPressed?.({
+					viewer: viewer.value,
+					sampled: plot.sampled,
+					packable,
+					index,
+					keyEvent
+				});
+			}
+		});
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("global", "HOVER", ({ hovering, pick }) => {
+				if (hovering && pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) hoverEntity.value = pick.id;
+				else hoverEntity.value = void 0;
+			}));
+		});
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("global", "LEFT_CLICK", ({ event, pick }) => {
+				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.sampled.getValue(getCurrentTime());
+					skeleton.onLeftClick?.({
+						viewer: viewer.value,
+						sampled: plot.sampled,
+						packable,
+						active: current.value === plot,
+						defining: plot.defining,
+						index,
+						event
+					});
+				} else activeEntity.value = void 0;
+			}));
+		});
+		(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
+			added.forEach((plot) => update(plot));
+			removed.forEach((plot) => update(plot, true));
+		});
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
+			if ([
+				"disabled",
+				"defining",
+				"scheme",
+				"sampled",
+				"time"
+			].includes(key)) (0, vue.nextTick)(() => update(plot));
+			else if (key === "skeletons") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => entityScope.add(item));
+				removed.forEach((item) => entityScope.remove(item));
+			}
+		});
+		(0, vue.watch)(current, (plot, previous) => {
+			plot && update(plot);
+			previous && update(previous);
+		});
+		return { dataSource };
 	}
-	/**
-	* 从样本中移除指定时间点的数据
-	*
-	* @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);
+
+//#endregion
+//#region usePlot/usePlot.ts
+	function usePlot(options) {
+		const time = options?.time || (0, vue.shallowRef)();
+		const viewer = (0, vesium.useViewer)();
+		const getCurrentTime = () => {
+			return time.value?.clone() || new cesium.JulianDate(0, 0);
+		};
+		const collection = (0, vue.shallowReactive)(/* @__PURE__ */ new Set());
+		const plots = (0, vue.computed)(() => Array.from(collection));
+		const current = (0, vue.shallowRef)();
+		const packable = (0, vue.shallowRef)();
+		(0, vesium.useCesiumEventListener)([() => current.value?.sampled.definitionChanged], () => {
+			packable.value = current.value?.sampled.getValue(getCurrentTime());
+		});
+		useSampled(current, getCurrentTime);
+		useRender(plots, current, getCurrentTime);
+		useSkeleton(plots, current, getCurrentTime);
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, (data) => {
+			if (current.value?.defining) return;
+			const pick = viewer.value?.scene.pick(data.position.clone());
+			if (pick?.id?.plot instanceof PlotFeature) return;
+			if (!pick) {
+				current.value = void 0;
+				return;
+			}
+			current.value = plots.value.find((plot) => (0, vesium.pickHitGraphic)(pick, [
+				...plot.entities,
+				...plot.primitives,
+				...plot.groundPrimitives
+			]));
+		});
+		let operateResolve;
+		let operateReject;
+		(0, vue.watch)(current, (plot, previous) => {
+			if (previous) {
+				if (previous.defining) {
+					const packable$1 = previous.sampled.getValue(getCurrentTime());
+					if (previous.scheme.allowManualComplete?.(packable$1)) {
+						PlotFeature.setDefining(previous, false);
+						operateResolve?.(previous);
+					} else collection.delete(previous);
+				}
+			}
+		});
+		const operate = async (plot) => {
+			return new Promise((resolve, reject) => {
+				operateResolve = resolve;
+				operateReject = reject;
+				const _plot = plot instanceof PlotFeature ? plot : new PlotFeature(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;
-	}
-	/**
-	* 从样本中移除指定时间间隔内的样本。
-	*
-	* @param interval 要移除样本的时间间隔
-	*/
-	removeSamples(interval$1) {
-		for (let i = 0; i < this._times.length; i++) {
-			const time = this._times[i];
-			cesium.TimeInterval.contains(interval$1, time) && this.removeSample(time);
-		}
-	}
-	/**
-	* 判断两个property是否相等
-	*/
-	equals(other) {
-		return other === this;
+			return false;
+		};
+		return {
+			plots,
+			time,
+			operate,
+			remove,
+			cancel: operateReject
+		};
 	}
-};
 
 //#endregion
-//#region usePlot/PlotFeature.ts
+//#region skeleton/control.ts
 /**
-* 标绘实例
-*/
-var PlotFeature = class {
-	constructor(options) {
-		const { id, disabled = false, sampled } = options;
-		this._id = id || (0, cesium.createGuid)();
-		this._scheme = PlotScheme.resolve(options.scheme);
-		this._definitionChanged = new cesium.Event();
-		this._defining = true;
-		this._disabled = disabled;
-		this._sampled = sampled instanceof SampledPlotProperty ? sampled : new SampledPlotProperty(sampled);
-		this._sampled.definitionChanged.addEventListener((property) => this._definitionChanged.raiseEvent(this, "sampled", property, property), this);
-		this._entities = [...this._scheme.initEntites?.() ?? []];
-		this._primitives = [...this._scheme.initPrimitives?.() ?? []];
-		this._groundPrimitives = [...this._scheme.initGroundPrimitives?.() ?? []];
-		this._skeletons = [];
-	}
-	/**
-	* @internal
+	* 绘制控制的框架点，拖拽时，将更新该控制点的实时位置
 	*/
-	_id;
-	get id() {
-		return this._id;
+	function control() {
+		return {
+			disabled: ({ active }) => !active,
+			cursor: "pointer",
+			dragCursor: "crosshair",
+			onDrag({ viewer, sampled, packable, event, index, lockCamera }) {
+				lockCamera();
+				const position = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
+				if (position) {
+					const positions = [...packable.positions ?? []];
+					positions[index] = position;
+					sampled.setSample({
+						time: packable.time,
+						derivative: packable.derivative,
+						positions
+					});
+				}
+			},
+			onKeyPressed({ viewer, keyEvent, sampled, packable, index }) {
+				const height = (0, vesium.toCartographic)(viewer.camera.position)?.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 = (0, vesium.toCartographic)(positions[index]);
+				const distance$1 = height / 1e5 * Math.PI / 180 / 1e3;
+				cartographic.latitude += distance$1 * Math.cos(newHeading);
+				cartographic.longitude += distance$1 * Math.sin(newHeading);
+				positions[index] = (0, vesium.toCartesian3)(cartographic);
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions
+				});
+			},
+			render: ({ position, action }) => {
+				return {
+					position,
+					point: {
+						pixelSize: 8,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.BLUE.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.BLUE.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
+			}
+		};
 	}
-	/**
-	* @internal
+
+//#endregion
+//#region skeleton/interval.ts
+/**
+	* 绘制封闭的间隔框架点，如多边形。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
 	*/
-	_scheme;
-	get scheme() {
-		return this._scheme;
+	function interval() {
+		let dragIndex = -1;
+		return {
+			disabled: ({ 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, sampled, packable, event, index, lockCamera, dragging }) {
+				lockCamera();
+				const position = (0, vesium.canvasCoordToCartesian)(event.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;
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions
+				});
+			},
+			render: ({ position, action, active }) => {
+				if (!active) return;
+				return {
+					position,
+					point: {
+						pixelSize: 6,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
+			}
+		};
 	}
-	/**
-	* @internal
+
+//#endregion
+//#region skeleton/intervalNonclosed.ts
+/**
+	* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
 	*/
-	_definitionChanged;
-	get definitionChanged() {
-		return this._definitionChanged;
+	function intervalNonclosed() {
+		let dragIndex = -1;
+		return {
+			disabled: ({ active, defining }) => !active || defining,
+			cursor: "pointer",
+			dragCursor: "crosshair",
+			format(packable) {
+				const _positions = packable.positions ?? [];
+				if (_positions.length < 2) return [];
+				const midpoints = [];
+				for (let i = 0; i < _positions.length - 1; i++) midpoints.push(cesium.Cartesian3.midpoint(_positions[i], _positions[i + 1], new cesium.Cartesian3()));
+				return midpoints;
+			},
+			onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
+				lockCamera();
+				const position = (0, vesium.canvasCoordToCartesian)(event.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;
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions
+				});
+			},
+			render: ({ position, action }) => {
+				return {
+					position,
+					point: {
+						pixelSize: 6,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
+			}
+		};
 	}
+
+//#endregion
+//#region skeleton/moved.ts
+	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>")}`;
 	/**
-	* @internal
+	* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
 	*/
-	_defining;
-	get defining() {
-		return this._defining;
+	function moved() {
+		return {
+			disabled: ({ 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 return [(0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions)))];
+			},
+			onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
+				dragging && lockCamera();
+				const startPosition = (0, vesium.canvasCoordToCartesian)(event.startPosition, viewer.scene);
+				const endPosition = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
+				if (!startPosition || !endPosition) return;
+				const offset = cesium.Cartesian3.subtract(endPosition, startPosition, new cesium.Cartesian3());
+				const positions = [...packable.positions ?? []];
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions: positions.map((position) => cesium.Cartesian3.add(position, offset, new cesium.Cartesian3()))
+				});
+			},
+			render: ({ position, action }) => {
+				return {
+					position,
+					billboard: {
+						image: svg,
+						width: 20,
+						height: 20,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.WHITE,
+							[PlotAction.HOVER]: cesium.Color.WHITE,
+							[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+						}[action],
+						pixelOffset: new cesium.Cartesian3(0, -20),
+						horizontalOrigin: cesium.HorizontalOrigin.CENTER,
+						verticalOrigin: cesium.VerticalOrigin.BOTTOM,
+						disableDepthTestDistance: Number.POSITIVE_INFINITY
+					}
+				};
+			}
+		};
 	}
-	/**
-	* @internal
+
+//#endregion
+//#region measure/utils/tesselate.ts
+/**
+	* 将多个边界点组成的面切割成多个三角形
+	* @param positions
 	*/
-	static setDefining(plot, value) {
-		if (plot._defining !== value) {
-			plot._definitionChanged.raiseEvent(plot, "defining", value, plot._defining);
-			plot._defining = value;
+	function tesselate(positions) {
+		if (positions.length < 3) throw new Error("positions must >= 3");
+		if (positions.length === 3) return [[
+			positions[0].clone(),
+			positions[1].clone(),
+			positions[2].clone()
+		]];
+		const geometry = cesium.CoplanarPolygonGeometry.createGeometry(cesium.CoplanarPolygonGeometry.fromPositions({
+			positions,
+			vertexFormat: cesium.VertexFormat.POSITION_ONLY
+		}));
+		if (!geometry) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
+		const values = geometry.attributes.position.values;
+		const indices = geometry.indices;
+		const result = [];
+		for (let i = 0; i < indices.length; i += 3) {
+			const a = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
+			const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
+			const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
+			result.push([
+				a,
+				b,
+				c
+			]);
 		}
+		return result;
 	}
-	/**
-	* @internal
-	*/
-	_disabled;
-	/**
-	* 获取禁用状态
-	*
-	* 当为 `true` 时，标绘实例将停止响应交互和更新；
-	* 为 `false` 时恢复正常功能。
-	*/
-	get disabled() {
-		return this._disabled;
-	}
-	set disabled(value) {
-		this.disabled = value;
-	}
-	/**
-	* @internal
-	*/
-	_sampled;
-	get sampled() {
-		return this._sampled;
-	}
-	/**
-	* @internal
-	*/
-	_entities;
-	get entities() {
-		return this._entities;
-	}
-	set entities(value) {
-		this._definitionChanged.raiseEvent(this, "entities", value, this._entities);
-		this._entities = value;
-	}
-	/**
-	* @internal
+
+//#endregion
+//#region measure/utils/clampToGround.ts
+/**
+	* 将传入的点位列表进行贴地处理,若某个点位获取高程失败则将此进行克隆返回
+	* @param options - 配置项
 	*/
-	_primitives;
-	get primitives() {
-		return this._primitives;
+	async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
+		const { positions, scene, classificationType = cesium.ClassificationType.BOTH, terrainProvider = scene.terrainProvider } = options;
+		const tileset = [cesium.ClassificationType.BOTH, cesium.ClassificationType.CESIUM_3D_TILE].includes(classificationType);
+		const terrain = [cesium.ClassificationType.BOTH, cesium.ClassificationType.TERRAIN].includes(classificationType);
+		const tilesetPromise = new Promise((resolve) => {
+			if (tileset) scene.clampToHeightMostDetailed(positions.map((e) => e.clone())).then(resolve).catch((error) => {
+				console.warn(error);
+				resolve([]);
+			});
+			else resolve([]);
+		});
+		const terrainPromise = new Promise((resolve) => {
+			if (terrain && terrainProvider) (0, cesium.sampleTerrainMostDetailed)(terrainProvider, positions.map((e) => cesium.Cartographic.fromCartesian(e))).then((e) => resolve(e)).catch((error) => {
+				console.warn(error);
+				resolve([]);
+			});
+			else resolve([]);
+		});
+		const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
+		const results = [];
+		positions.forEach((item, index) => {
+			const position = tilesetPositions[index] || terrainPositions[index] ? cesium.Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
+			results.push(position);
+		});
+		return results;
 	}
-	/**
-	* @internal
-	*/
-	set primitives(value) {
-		this._definitionChanged.raiseEvent(this, "primitives", value, this._primitives);
-		this._primitives = value;
+
+//#endregion
+//#region measure/utils/triangleGrid.ts
+	function defaultOptions$2(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
+		const density = Math.floor(original?.density ?? 10);
+		return {
+			scene: original?.scene,
+			clampToGround,
+			classificationType,
+			terrainProvider: original?.terrainProvider,
+			density
+		};
 	}
 	/**
-	* @internal
+	* 生成三角网数组
+	* @param positions - 边界点数组
+	* @param options - 配置项
 	*/
-	_groundPrimitives;
-	get groundPrimitives() {
-		return this._groundPrimitives;
+	async function triangleGrid(positions, options) {
+		if (positions.length < 3) throw new Error("positions must >= 3");
+		const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$2(options);
+		if (density <= 0) throw new Error("options.density must > 0");
+		const bbox = cesium.Rectangle.fromCartesianArray(positions);
+		const vertical = bbox.north - bbox.south;
+		const horizontal = bbox.east - bbox.west;
+		const granularity = Math.max(horizontal, vertical) / density;
+		const polygonGeometry = cesium.PolygonGeometry.fromPositions({
+			positions,
+			vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
+			granularity
+		});
+		const geometry = cesium.PolygonGeometry.createGeometry(polygonGeometry);
+		const values = geometry.attributes.position.values;
+		if (!geometry || !values) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
+		const indices = geometry.indices;
+		let cartesian3List = [];
+		for (let i = 0; i < indices.length; i += 3) {
+			const a = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
+			const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
+			const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
+			cartesian3List.push(a, b, c);
+		}
+		if (clampToGround) {
+			if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+			cartesian3List = await clampToHeightMostDetailedByTilesetOrTerrain({
+				scene,
+				terrainProvider,
+				positions: cartesian3List,
+				classificationType
+			});
+		}
+		const grid = [];
+		while (cartesian3List?.length) {
+			const [a, b, c] = cartesian3List.splice(0, 3);
+			grid.push([
+				a,
+				b,
+				c
+			]);
+		}
+		return grid;
 	}
-	/**
-	* @internal
+
+//#endregion
+//#region measure/utils/area.ts
+/**
+	* 计算三维坐标系下三角形面积
+	* @param p0 - 三角形第一个点
+	* @param p1 - 三角形第二个点
+	* @param p2 - 三角形第三个点
 	*/
-	set groundPrimitives(value) {
-		this._definitionChanged.raiseEvent(this, "groundPrimitives", value, this._groundPrimitives);
-		this._groundPrimitives = value;
+	function triangleArea(p0, p1, p2) {
+		const v0 = cesium.Cartesian3.subtract(p0, p1, new cesium.Cartesian3());
+		const v1 = cesium.Cartesian3.subtract(p2, p1, new cesium.Cartesian3());
+		const cross = cesium.Cartesian3.cross(v0, v1, v0);
+		return cesium.Cartesian3.magnitude(cross) * .5;
 	}
-	/**
-	* @internal
-	*/
-	_skeletons;
-	get skeletons() {
-		return this._skeletons;
+	function defaultOptions$1(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
+		const density = Math.floor(original?.density ?? 10);
+		return {
+			scene: original?.scene,
+			clampToGround,
+			classificationType,
+			terrainProvider: original?.terrainProvider,
+			density
+		};
 	}
 	/**
-	* @internal
+	* 计算三维坐标系下图形面积
+	* @param positions - 图形各点的笛卡尔数组
 	*/
-	set skeletons(value) {
-		this._definitionChanged.raiseEvent(this, "skeletons", value, this._skeletons);
-		this._skeletons = value;
+	async function area(positions, options) {
+		if (positions.length < 2) throw new Error("positions.length must >= 2");
+		const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(options);
+		if (density <= 0) throw new Error("options.density must > 0");
+		if (!clampToGround) return tesselate(positions).reduce((count, current) => count += triangleArea(...current), 0);
+		return (await triangleGrid(positions, {
+			density,
+			scene,
+			clampToGround,
+			classificationType,
+			terrainProvider
+		})).reduce((count, current) => count += triangleArea(...current), 0);
 	}
-};
 
 //#endregion
-//#region usePlot/PlotSkeleton.ts
+//#region measure/utils/lerpArray.ts
 /**
-* 框架点执行状态枚举
-* - IDLE 空闲状态
-* - HOVER 悬停状态
-* - ACTIVE 激活状态
-*/
-let PlotAction = /* @__PURE__ */ function(PlotAction$1) {
-	PlotAction$1[PlotAction$1["IDLE"] = 0] = "IDLE";
-	PlotAction$1[PlotAction$1["HOVER"] = 1] = "HOVER";
-	PlotAction$1[PlotAction$1["ACTIVE"] = 2] = "ACTIVE";
-	return PlotAction$1;
-}({});
-/**
-* 标绘框架点 Entity
-*/
-var PlotSkeletonEntity = class extends cesium.Entity {
-	constructor(options) {
-		super(options);
+	* 在起点和终点间进行插值, 返回的数组包括起点和终点，数组长度为 count+1
+	*/
+	async function lerpArray(options) {
+		const { start, end, count, scene, clampToGround, classificationType, terrainProvider } = options;
+		const result = [];
+		for (let i = 0; i < count; i++) {
+			const position = cesium.Cartesian3.lerp(start, end, 1 / count, new cesium.Cartesian3());
+			result.push(position);
+		}
+		result.push(end.clone());
+		if (!clampToGround) return result;
+		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+		return await clampToHeightMostDetailedByTilesetOrTerrain({
+			scene,
+			terrainProvider,
+			positions: result,
+			classificationType
+		});
 	}
-};
 
 //#endregion
-//#region usePlot/useRender.ts
-function useRender(plots, current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const primitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection());
-	const groundPrimitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection(), { collection: "ground" });
-	const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
-	const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
-	const primitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => primitiveCollection.value });
-	const groundPrimitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => groundPrimitiveCollection.value });
-	const mouseCartesian = (0, vue.shallowRef)();
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.MOUSE_MOVE, (event) => {
-		mouseCartesian.value = (0, vesium.canvasCoordToCartesian)(event?.endPosition, viewer.value.scene);
-	});
-	(0, __vueuse_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));
+//#region measure/utils/distance.ts
+	function defaultOptions(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
+		const density = Math.floor(original?.density ?? 50);
+		return {
+			scene: original?.scene,
+			clampToGround,
+			classificationType,
+			terrainProvider: original?.terrainProvider,
+			density
+		};
+	}
+	/**
+	* 计算多点位之间的距离
+	* @param positions
+	*/
+	async function distance(positions, options) {
+		if (positions.length < 2) throw new Error("positions.length must >= 2");
+		const _options = defaultOptions(options);
+		const stages = [];
+		let count = 0;
+		positions.forEach((position, index) => {
+			if (index !== positions.length - 1) {
+				const next = positions[index + 1];
+				const distance$1 = cesium.Cartesian3.distance(position, next);
+				stages.push(distance$1);
+				count += distance$1;
+			}
 		});
-		added.forEach((plot) => {
-			plot.entities.forEach((item) => entityScope.add(item));
-			plot.primitives.forEach((item) => primitiveScope.add(item));
-			plot.groundPrimitives.forEach((item) => groundPrimitiveScope.add(item));
+		if (!_options.clampToGround) return {
+			stages,
+			count
+		};
+		const density = _options.density;
+		if (density <= 0) throw new Error("options.density must > 0");
+		const densities = stages.map((stage) => {
+			return Math.floor(stage / count * density);
 		});
-	}, {
-		immediate: true,
-		flush: "post"
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (_scope, key, newValue, oldValue) => {
-		if (key === "entities") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => entityScope.add(item));
-			removed.forEach((item) => entityScope.remove(item));
-		} else if (key === "primitives") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => primitiveScope.add(item));
-			removed.forEach((item) => primitiveScope.remove(item));
-		} else if (key === "groundPrimitives") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => groundPrimitiveScope.add(item));
-			removed.forEach((item) => groundPrimitiveScope.remove(item));
-		}
-	});
-	const update = async (plot) => {
-		const reslut = await plot.scheme.render?.({
-			packable: plot.sampled.getValue(getCurrentTime()),
-			mouse: plot.defining ? mouseCartesian.value : void 0,
-			defining: plot.defining,
-			previous: {
-				entities: plot.entities,
-				primitives: plot.primitives,
-				groundPrimitives: plot.groundPrimitives
-			}
+		const diff = density - densities.reduce((count$1, current) => count$1 += current, 0);
+		if (diff) densities[densities.length - 1] += diff;
+		const positionListPromises = densities.map((density$1, i) => {
+			return lerpArray({
+				scene: _options.scene,
+				start: positions[i],
+				end: positions[i + 1],
+				count: density$1,
+				clampToGround: true,
+				classificationType: _options.classificationType,
+				terrainProvider: _options.terrainProvider
+			});
 		});
-		plot.entities = reslut?.entities ?? [];
-		plot.primitives = reslut?.primitives ?? [];
-		plot.groundPrimitives = reslut?.groundPrimitives ?? [];
-	};
-	(0, vue.watch)(current, (plot, previous) => {
-		previous && update(previous);
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (plot, key) => {
-		if ([
-			"disabled",
-			"defining",
-			"scheme",
-			"sampled",
-			"time"
-		].includes(key)) update(plot);
-	});
-	(0, vue.watch)(mouseCartesian, () => {
-		plots.value.forEach((plot) => plot.defining && update(plot));
-	});
-	return {
-		primitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
-		groundPrimitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
-		entities: (0, vue.computed)(() => Array.from(entityScope.scope))
-	};
-}
+		const stagePromises = (await Promise.all(positionListPromises)).map(async (positions$1) => {
+			const { count: count$1 } = await distance(positions$1);
+			return count$1;
+		});
+		const groundStages = await Promise.all(stagePromises);
+		return {
+			stages: groundStages,
+			count: groundStages.reduce((count$1, current) => count$1 += current, 0)
+		};
+	}
 
 //#endregion
-//#region usePlot/useSampled.ts
-function useSampled(current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const doubleClicking = (0, vue.ref)(false);
-	const packable = (0, vue.computed)(() => {
-		return current.value?.sampled.getValue(getCurrentTime());
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, async (ctx) => {
-		await (0, __vueuse_core.promiseTimeout)(1);
-		if (!current.value || !packable.value) return;
-		if (doubleClicking.value) return;
-		const { scheme, defining, sampled } = current.value;
-		if (!defining) return;
-		const position = (0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene);
-		if (!position) return;
-		packable.value.positions ??= [];
-		packable.value.positions.push(position);
-		sampled.setSample(packable.value);
-		const completed = scheme.complete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
-		if (!current.value || !packable.value) return;
-		doubleClicking.value = true;
-		await (0, __vueuse_core.promiseTimeout)(2);
-		doubleClicking.value = false;
-		const { scheme, defining } = current.value;
-		if (!defining) return;
-		const position = (0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene);
-		if (!position) return;
-		const completed = scheme.allowManualComplete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.RIGHT_CLICK, async () => {
-		if (!current.value || !packable.value) return;
-		const { defining, sampled } = current.value;
-		if (!defining) return;
-		packable.value.positions ??= [];
-		if (packable.value.positions.length === 0) return;
-		packable.value.positions.splice(packable.value.positions.length - 1, 1);
-		sampled.setSample(packable.value);
-	});
-	const definingCursorCss = (0, vue.ref)();
-	const setDefiningCursorCss = () => {
-		if (!current.value?.defining) {
-			if (definingCursorCss.value) {
-				definingCursorCss.value = void 0;
-				viewer.value.container.parentElement.style.removeProperty("cursor");
+//#region measure/measureArea.ts
+	const schemeMeasureArea = new PlotScheme({
+		type: "MeasureArea",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [control, interval],
+		initRender() {
+			return { entities: [new cesium.Entity({
+				label: { font: "14pt" },
+				polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
+				polygon: { material: cesium.Color.YELLOW.withAlpha(.5) }
+			})] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const { mouse, packable } = context;
+			const positions = [...packable.positions ?? []];
+			mouse && positions.push(mouse);
+			if (positions.length === 2) {
+				entity.position = void 0;
+				entity.label.text = void 0;
+				entity.polygon.hierarchy = void 0;
+				entity.polyline.positions = new cesium.CallbackProperty(() => positions, false);
+			} else if (positions.length >= 3) {
+				positions.push(positions[0]);
+				entity.position = new cesium.ConstantPositionProperty((0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions))));
+				entity.label.text = new cesium.ConstantProperty("");
+				area(positions).then((e) => {
+					let text = "";
+					if (e / 1e3 / 1e3 > 10) text = `${(e / 1e3 / 1e3).toFixed(2)}km²`;
+					else text = `${(+e).toFixed(2)}m²`;
+					entity.label.text = new cesium.ConstantProperty(text);
+				});
+				entity.polyline.positions = void 0;
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
+					return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
+				}, false);
+			} else {
+				entity.position = void 0;
+				entity.polygon.hierarchy = void 0;
+				entity.polyline.positions = void 0;
 			}
-		} else {
-			const definingCursor = current.value.scheme.definingCursor;
-			definingCursorCss.value = (0, vesium.isFunction)(definingCursor) ? definingCursor(packable.value) : definingCursor;
-			if (definingCursorCss.value) viewer.value?.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
+			return { entities: [entity] };
 		}
-	};
-	(0, vesium.useCesiumEventListener)(() => current.value?.definitionChanged, (plot, key) => {
-		if (key === "defining" || key === "sampled") setDefiningCursorCss();
 	});
-	(0, vue.watch)(current, () => setDefiningCursorCss());
-}
 
 //#endregion
-//#region usePlot/useSkeleton.ts
-function useSkeleton(plots, current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
-	const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
-	const hoverEntity = (0, vue.shallowRef)();
-	const activeEntity = (0, vue.shallowRef)();
-	const getPointAction = (entity) => {
-		if (!entity) return PlotAction.IDLE;
-		return activeEntity.value?.id === entity.id ? PlotAction.ACTIVE : hoverEntity.value?.id === entity.id ? PlotAction.HOVER : PlotAction.IDLE;
-	};
-	const update = (plot, destroyed) => {
-		const oldEntities = plot.skeletons;
-		const entities = [];
-		if (destroyed || plot.disabled) plot.skeletons = [];
-		else {
-			const packable = plot.sampled.getValue(getCurrentTime());
-			const defining = plot.defining;
-			const active = current.value === plot;
-			const skeletons = plot.scheme.skeletons;
-			skeletons.forEach((skeleton) => {
-				const disabled = (0, vesium.isFunction)(skeleton.disabled) ? skeleton.disabled({
-					active,
-					defining
-				}) : skeleton.disabled;
-				if (disabled) return;
-				const positions = skeleton.format?.(packable) ?? packable?.positions ?? [];
-				positions.forEach((position, index) => {
-					let entity = oldEntities.find((item) => item.index === index && item.skeleton === skeleton);
-					const options = skeleton.render?.({
-						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);
+//#region measure/measureDistance.ts
+	const schemeMeasureDistance = new PlotScheme({
+		type: "MeasureDistance",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				width: 2,
+				material: cesium.Color.YELLOW.withAlpha(.5)
+			} })] };
+		},
+		render(context) {
+			context.previous.entities[0];
+			const { mouse, packable, previous } = context;
+			const entities = previous.entities;
+			const positions = [...packable.positions ?? []];
+			mouse && positions.push(mouse);
+			if (positions.length < 2) return { entities };
+			const pl = entities[0];
+			pl.polyline ??= new cesium.PolylineGraphics();
+			pl.polyline.positions = new cesium.CallbackProperty(() => positions, false);
+			positions.forEach((item, index) => {
+				if (!entities[index + 1]) entities[index + 1] = new cesium.Entity({
+					position: item,
+					label: new cesium.LabelGraphics({
+						backgroundColor: cesium.Color.fromCssColorString("#fff"),
+						font: "12pt sans-serif"
+					})
 				});
 			});
-		}
-		plot.skeletons = entities;
-	};
-	const { addGraphicEvent } = (0, vesium.useGraphicEvent)();
-	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
-			if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
-				const entity = pick.id;
-				const plot = entity.plot;
-				if (plot.defining) return;
-				activeEntity.value = entity;
-				const skeleton = entity.skeleton;
-				const index = entity.index;
-				const packable = plot.sampled.getValue(getCurrentTime());
-				skeleton.onDrag?.({
-					viewer: viewer.value,
-					sampled: plot.sampled,
-					packable,
-					active: current.value === plot,
-					index,
-					event,
-					dragging,
-					lockCamera
+			entities.splice(positions.length, entities.length - positions.length - 1);
+			distance(positions).then(({ count, stages }) => {
+				stages.forEach((stage, index) => {
+					entities[index + 1].position = new cesium.CallbackPositionProperty(() => cesium.Cartesian3.midpoint(positions[index], positions[index + 1], new cesium.Cartesian3()), false);
+					entities[index + 1].label.text = new cesium.CallbackProperty(() => `${stage.toFixed(2)} m`, false);
 				});
-			} else activeEntity.value = void 0;
-		}, {
-			cursor: ({ pick }) => {
-				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
-					const skeleton = pick.id.skeleton;
-					return (0, vesium.isFunction)(skeleton?.cursor) ? skeleton.cursor(pick) : (0, vue.toValue)(skeleton?.cursor);
-				}
-			},
-			dragCursor: ({ pick }) => {
-				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
-					const skeleton = pick.id.skeleton;
-					return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
+				if (stages.length > 1) {
+					entities[entities.length - 1].position = new cesium.CallbackPositionProperty(() => positions[positions.length - 1], false);
+					entities[entities.length - 1].label.text = new cesium.CallbackProperty(() => `${count.toFixed(2)} m`, false);
+				} else {
+					entities[entities.length - 1].position = void 0;
+					entities[entities.length - 1].label.text = void 0;
 				}
-			}
-		});
-		onCleanup(remove);
-	});
-	(0, __vueuse_core.onKeyStroke)((keyEvent) => {
-		if (activeEntity.value) {
-			const entity = activeEntity.value;
-			const plot = entity.plot;
-			const skeleton = entity.skeleton;
-			const index = entity.index;
-			const packable = plot.sampled.getValue(getCurrentTime());
-			skeleton.onKeyPressed?.({
-				viewer: viewer.value,
-				sampled: plot.sampled,
-				packable,
-				index,
-				keyEvent
 			});
+			return { entities };
 		}
 	});
-	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "HOVER", ({ 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;
-		});
-		onCleanup(remove);
-	});
-	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "LEFT_CLICK", ({ event, pick }) => {
-			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.sampled.getValue(getCurrentTime());
-				skeleton.onLeftClick?.({
-					viewer: viewer.value,
-					sampled: plot.sampled,
-					packable,
-					active: current.value === plot,
-					defining: plot.defining,
-					index,
-					event
-				});
-			} else activeEntity.value = void 0;
-		});
-		onCleanup(remove);
-	});
-	(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
-		added.forEach((plot) => update(plot));
-		removed.forEach((plot) => update(plot, true));
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
-		if ([
-			"disabled",
-			"defining",
-			"scheme",
-			"sampled",
-			"time"
-		].includes(key)) (0, vue.nextTick)(() => update(plot));
-		else if (key === "skeletons") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => entityScope.add(item));
-			removed.forEach((item) => entityScope.remove(item));
+
+//#endregion
+//#region scheme/Billboard.ts
+	const PlotSchemeBillboard = new PlotScheme({
+		type: "Billboard",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender: () => {
+			return { entities: [new cesium.Entity({ billboard: {
+				image: "/favicon.svg",
+				width: 32,
+				height: 32
+			} })] };
+		},
+		render(options) {
+			const { mouse, packable } = options;
+			const entity = options.previous.entities?.[0] ?? new cesium.Entity({ billboard: {} });
+			const position = packable.positions?.[0] ?? mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
 		}
 	});
-	(0, vue.watch)(current, (plot, previous) => {
-		plot && update(plot);
-		previous && update(previous);
-	});
-	return { dataSource };
-}
 
 //#endregion
-//#region usePlot/usePlot.ts
-function usePlot(options) {
-	const time = options?.time || (0, vue.shallowRef)();
-	const viewer = (0, vesium.useViewer)();
-	const getCurrentTime = () => {
-		return time.value?.clone() || new cesium.JulianDate(0, 0);
-	};
-	const collection = (0, vue.shallowReactive)(/* @__PURE__ */ new Set());
-	const plots = (0, vue.computed)(() => Array.from(collection));
-	const current = (0, vue.shallowRef)();
-	const packable = (0, vue.shallowRef)();
-	(0, vesium.useCesiumEventListener)([() => current.value?.sampled.definitionChanged], () => {
-		packable.value = current.value?.sampled.getValue(getCurrentTime());
-	});
-	useSampled(current, getCurrentTime);
-	useRender(plots, current, getCurrentTime);
-	useSkeleton(plots, current, getCurrentTime);
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, (data) => {
-		if (current.value?.defining) return;
-		const pick = viewer.value?.scene.pick(data.position.clone());
-		if (pick?.id?.plot instanceof PlotFeature) return;
-		if (!pick) {
-			current.value = void 0;
-			return;
+//#region scheme/BillboardPinBuilder.ts
+	const PlotSchemeBillboardPinBuilder = new PlotScheme({
+		type: "BillboardPinBuilder",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ billboard: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
 		}
-		current.value = plots.value.find((plot) => (0, vesium.pickHitGraphic)(pick, [
-			...plot.entities,
-			...plot.primitives,
-			...plot.groundPrimitives
-		]));
 	});
-	let operateResolve;
-	let operateReject;
-	(0, vue.watch)(current, (plot, previous) => {
-		if (previous) {
-			if (previous.defining) {
-				const packable$1 = previous.sampled.getValue(getCurrentTime());
-				const completed = previous.scheme.allowManualComplete?.(packable$1);
-				if (completed) {
-					PlotFeature.setDefining(previous, false);
-					operateResolve?.(previous);
-				} else collection.delete(previous);
+
+//#endregion
+//#region scheme/Cylinder.ts
+	const PlotSchemeCylinder = new PlotScheme({
+		type: "Cylinder",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ cylinder: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = [...context.packable.positions];
+			if (positions.length === 0) return context.previous;
+			if (positions.length === 1) {
+				const position = context.mouse;
+				position && positions.push(position);
 			}
+			if (positions.length < 2) return context.previous;
+			entity.position = new cesium.ConstantPositionProperty(positions[0]);
+			const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
+			entity.cylinder.bottomRadius = new cesium.CallbackProperty(() => radius, false);
+			if (context.defining || !(0, vesium.toPropertyValue)(entity.cylinder.length)) entity.cylinder.length = (0, vesium.toProperty)(radius * 2);
+			return { entities: [entity] };
 		}
 	});
-	const operate = async (plot) => {
-		return new Promise((resolve, reject) => {
-			operateResolve = resolve;
-			operateReject = reject;
-			const _plot = plot instanceof PlotFeature ? plot : new PlotFeature(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
-	};
-}
 
 //#endregion
-//#region skeleton/control.ts
-/**
-* 绘制控制的框架点，拖拽时，将更新该控制点的实时位置
-*/
-function control() {
-	return {
-		disabled: ({ active }) => !active,
-		cursor: "pointer",
-		dragCursor: "crosshair",
-		onDrag({ viewer, sampled, packable, event, index, lockCamera }) {
-			lockCamera();
-			const position = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
-			if (position) {
-				const positions = [...packable.positions ?? []];
-				positions[index] = position;
-				sampled.setSample({
-					time: packable.time,
-					derivative: packable.derivative,
-					positions
-				});
-			}
+//#region scheme/Ellipse.ts
+	const PlotSchemeEllipse = new PlotScheme({
+		type: "Ellipse",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ ellipse: {} })] };
 		},
-		onKeyPressed({ viewer, keyEvent, sampled, packable, index }) {
-			const height = (0, vesium.toCartographic)(viewer.camera.position)?.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;
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = [...context.packable.positions];
+			if (positions.length === 0) return context.previous;
+			if (positions.length === 1) {
+				const position = context.mouse;
+				position && positions.push(position);
 			}
-			const newHeading = (viewer.camera.heading + headingAdjust) % (2 * Math.PI);
-			const positions = [...packable.positions ?? []];
-			const cartographic = (0, vesium.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] = (0, vesium.toCartesian3)(cartographic);
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions
-			});
-		},
-		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: cesium.Color.BLUE.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.BLUE.withAlpha(.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(.4)
-				}
-			};
+			if (positions.length < 2) return context.previous;
+			entity.position = new cesium.ConstantPositionProperty(positions[0]);
+			const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
+			entity.ellipse.semiMinorAxis = new cesium.CallbackProperty(() => radius || 1, false);
+			entity.ellipse.semiMajorAxis = entity.ellipse.semiMinorAxis;
+			return { entities: [entity] };
 		}
-	};
-}
+	});
 
 //#endregion
-//#region skeleton/interval.ts
-/**
-* 绘制封闭的间隔框架点，如多边形。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
-*/
-function interval() {
-	let dragIndex = -1;
-	return {
-		disabled: ({ 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, sampled, packable, event, index, lockCamera, dragging }) {
-			lockCamera();
-			const position = (0, vesium.canvasCoordToCartesian)(event.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;
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions
-			});
+//#region scheme/Label.ts
+	const PlotSchemeLabel = new PlotScheme({
+		type: "Label",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ label: { text: "Label" } })] };
 		},
-		render: ({ position, action, active }) => {
-			if (!active) return;
-			const colors = {
-				[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.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(.4)
-				}
-			};
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
 		}
-	};
-}
+	});
 
 //#endregion
-//#region skeleton/intervalNonclosed.ts
-/**
-* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
-*/
-function intervalNonclosed() {
-	let dragIndex = -1;
-	return {
-		disabled: ({ active, defining }) => !active || defining,
-		cursor: "pointer",
-		dragCursor: "crosshair",
-		format(packable) {
-			const _positions = packable.positions ?? [];
-			if (_positions.length < 2) return [];
-			const midpoints = [];
-			for (let i = 0; i < _positions.length - 1; i++) midpoints.push(cesium.Cartesian3.midpoint(_positions[i], _positions[i + 1], new cesium.Cartesian3()));
-			return midpoints;
-		},
-		onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
-			lockCamera();
-			const position = (0, vesium.canvasCoordToCartesian)(event.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;
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions
-			});
+//#region scheme/Point.ts
+	const PlotSchemePoint = new PlotScheme({
+		type: "Point",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ point: {
+				pixelSize: 10,
+				color: cesium.Color.RED
+			} })] };
 		},
-		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.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(.4)
-				}
-			};
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
 		}
-	};
-}
+	});
 
 //#endregion
-//#region skeleton/moved.ts
-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 {
-		disabled: ({ 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 [(0, vesium.toCartesian3)(center)];
-			}
+//#region scheme/Polygon.ts
+	const PlotSchemePolygon = new PlotScheme({
+		type: "Polygon",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender: () => {
+			return { entities: [new cesium.Entity({
+				polyline: {},
+				polygon: {}
+			})] };
 		},
-		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
-			dragging && lockCamera();
-			const startPosition = (0, vesium.canvasCoordToCartesian)(event.startPosition, viewer.scene);
-			const endPosition = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
-			if (!startPosition || !endPosition) return;
-			const offset = cesium.Cartesian3.subtract(endPosition, startPosition, new cesium.Cartesian3());
+		render(options) {
+			const { mouse, packable } = options;
+			const entity = options.previous.entities[0];
 			const positions = [...packable.positions ?? []];
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions: positions.map((position) => cesium.Cartesian3.add(position, offset, new cesium.Cartesian3()))
-			});
+			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] };
+		}
+	});
+
+//#endregion
+//#region scheme/PolygonArc.ts
+	const PlotSchemePolygonArc = new PlotScheme({
+		type: "PolygonArc",
+		complete: (packable) => packable.positions.length >= 3,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
 		},
-		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
-				}
-			};
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			if (points.length < 3) context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arc)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-	};
-}
+	});
 
 //#endregion
-//#region measure/utils/tesselate.ts
-/**
-* 将多个边界点组成的面切割成多个三角形
-* @param positions
-*/
-function tesselate(positions) {
-	if (positions.length < 3) throw new Error("positions must >= 3");
-	if (positions.length === 3) return [[
-		positions[0].clone(),
-		positions[1].clone(),
-		positions[2].clone()
-	]];
-	const geometry = cesium.CoplanarPolygonGeometry.createGeometry(cesium.CoplanarPolygonGeometry.fromPositions({
-		positions,
-		vertexFormat: cesium.VertexFormat.POSITION_ONLY
-	}));
-	if (!geometry) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
-	const values = geometry.attributes.position.values;
-	const indices = geometry.indices;
-	const result = [];
-	for (let i = 0; i < indices.length; i += 3) {
-		const a = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
-		const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
-		const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
-		result.push([
-			a,
-			b,
-			c
-		]);
-	}
-	return result;
-}
+//#region scheme/PolygonArrowAttackDirection.ts
+	const PlotSchemePolygonArrowAttackDirection = new PlotScheme({
+		type: "PolygonArrowAttackDirection",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowAttackDirection)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
-//#region measure/utils/clampToGround.ts
-/**
-* 将传入的点位列表进行贴地处理,若某个点位获取高程失败则将此进行克隆返回
-* @param options - 配置项
-*/
-async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
-	const { positions, scene, classificationType = cesium.ClassificationType.BOTH, terrainProvider = scene.terrainProvider } = options;
-	const tileset = [cesium.ClassificationType.BOTH, cesium.ClassificationType.CESIUM_3D_TILE].includes(classificationType);
-	const terrain = [cesium.ClassificationType.BOTH, cesium.ClassificationType.TERRAIN].includes(classificationType);
-	const tilesetPromise = new Promise((resolve) => {
-		if (tileset) scene.clampToHeightMostDetailed(positions.map((e) => e.clone())).then(resolve).catch((error) => {
-			console.warn(error);
-			resolve([]);
-		});
-		else resolve([]);
+//#region scheme/PolygonArrowAttackDirectionTailed.ts
+	const PlotSchemePolygonArrowAttackDirectionTailed = new PlotScheme({
+		type: "PolygonArrowAttackDirectionTailed",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowAttackDirectionTailed)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
+		}
 	});
-	const terrainPromise = new Promise((resolve) => {
-		if (terrain && terrainProvider) (0, cesium.sampleTerrainMostDetailed)(terrainProvider, positions.map((e) => cesium.Cartographic.fromCartesian(e))).then((e) => resolve(e)).catch((error) => {
-			console.warn(error);
-			resolve([]);
-		});
-		else resolve([]);
+
+//#endregion
+//#region scheme/PolygonArrowClamped.ts
+	const PlotSchemePolygonArrowClamped = new PlotScheme({
+		type: "PolygonArrowClamped",
+		complete: (packable) => packable.positions.length >= 5,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			if (points.length < 5) {
+				const mouse = context.mouse;
+				mouse && points.push(mouse.clone());
+			}
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length >= 3) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowClamped)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
+		}
 	});
-	const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
-	const resluts = [];
-	positions.forEach((item, index) => {
-		const position = tilesetPositions[index] || terrainPositions[index] ? cesium.Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
-		resluts.push(position);
+
+//#endregion
+//#region scheme/PolygonArrowStraight.ts
+	const PlotSchemePolygonArrowStraight = new PlotScheme({
+		type: "PolygonArrowStraight",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			if (points.length < 2) {
+				const mouse = context.mouse;
+				mouse && points.push(mouse.clone());
+			}
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length >= 2) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowStraight)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
+		}
 	});
-	return resluts;
-}
 
 //#endregion
-//#region measure/utils/triangleGrid.ts
-function defaultOptions$1(original) {
-	const clampToGround = original?.clampToGround ?? false;
-	const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
-	const density = Math.floor(original?.density ?? 10);
-	return {
-		scene: original?.scene,
-		clampToGround,
-		classificationType,
-		terrainProvider: original?.terrainProvider,
-		density
-	};
-}
-/**
-* 生成三角网数组
-* @param positions - 边界点数组
-* @param options - 配置项
-*/
-async function triangleGrid(positions, options) {
-	if (positions.length < 3) throw new Error("positions must >= 3");
-	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(options);
-	if (density <= 0) throw new Error("options.density must > 0");
-	const bbox = cesium.Rectangle.fromCartesianArray(positions);
-	const vertical = bbox.north - bbox.south;
-	const horizontal = bbox.east - bbox.west;
-	const max = Math.max(horizontal, vertical);
-	const granularity = max / density;
-	const polygonGeometry = cesium.PolygonGeometry.fromPositions({
-		positions,
-		vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
-		granularity
+//#region scheme/PolygonArrowStraightSharp.ts
+	const PlotSchemePolygonArrowStraightSharp = new PlotScheme({
+		type: "PolygonArrowStraightSharp",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			if (points.length < 2) {
+				const mouse = context.mouse;
+				mouse && points.push(mouse.clone());
+			}
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length >= 2) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowStraightSharp)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
+		}
 	});
-	const geometry = cesium.PolygonGeometry.createGeometry(polygonGeometry);
-	const values = geometry.attributes.position.values;
-	if (!geometry || !values) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
-	const indices = geometry.indices;
-	let cartesian3List = [];
-	for (let i = 0; i < indices.length; i += 3) {
-		const a = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
-		const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
-		const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
-		cartesian3List.push(a, b, c);
-	}
-	if (clampToGround) {
-		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
-		const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
-			scene,
-			terrainProvider,
-			positions: cartesian3List,
-			classificationType
-		});
-		cartesian3List = detaileds;
-	}
-	const grid = [];
-	while (cartesian3List?.length) {
-		const [a, b, c] = cartesian3List.splice(0, 3);
-		grid.push([
-			a,
-			b,
-			c
-		]);
-	}
-	return grid;
-}
 
 //#endregion
-//#region measure/utils/area.ts
-/**
-* 计算三维坐标系下三角形面积
-* @param p0 - 三角形第一个点
-* @param p1 - 三角形第二个点
-* @param p2 - 三角形第三个点
-*/
-function triangleArea(p0, p1, p2) {
-	const v0 = cesium.Cartesian3.subtract(p0, p1, new cesium.Cartesian3());
-	const v1 = cesium.Cartesian3.subtract(p2, p1, new cesium.Cartesian3());
-	const cross = cesium.Cartesian3.cross(v0, v1, v0);
-	return cesium.Cartesian3.magnitude(cross) * .5;
-}
-function defaultOptions(original) {
-	const clampToGround = original?.clampToGround ?? false;
-	const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
-	const density = Math.floor(original?.density ?? 10);
-	return {
-		scene: original?.scene,
-		clampToGround,
-		classificationType,
-		terrainProvider: original?.terrainProvider,
-		density
-	};
-}
-/**
-* 计算三维坐标系下图形面积
-* @param positions - 图形各点的笛卡尔数组
-*/
-async function area(positions, options) {
-	if (positions.length < 2) throw new Error("positions.length must >= 2");
-	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions(options);
-	if (density <= 0) throw new Error("options.density must > 0");
-	if (!clampToGround) {
-		const triangles$1 = tesselate(positions);
-		return triangles$1.reduce((count, current) => count += triangleArea(...current), 0);
-	}
-	const triangles = await triangleGrid(positions, {
-		density,
-		scene,
-		clampToGround,
-		classificationType,
-		terrainProvider
+//#region scheme/PolygonArrowUnitCombatOperation.ts
+	const PlotSchemePolygonArrowUnitCombatOperation = new PlotScheme({
+		type: "PolygonArrowUnitCombatOperation",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowUnitCombatOperation)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
+		}
 	});
-	return triangles.reduce((count, current) => count += triangleArea(...current), 0);
-}
 
 //#endregion
-//#region measure/measureArea.ts
-const schemeMeasureArea = new PlotScheme({
-	type: "measureArea",
-	allowManualComplete: (packable) => packable.positions.length >= 3,
-	skeletons: [control, interval],
-	initEntites: () => [new cesium.Entity({
-		label: { font: "14pt" },
-		polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-		polygon: { material: cesium.Color.YELLOW.withAlpha(.5) }
-	})],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({
-			label: { font: "14pt" },
-			polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-			polygon: { material: cesium.Color.YELLOW.withAlpha(.5) }
-		});
-		const positions = [...packable.positions ?? []];
-		mouse && positions.push(mouse);
-		if (positions.length === 2) {
-			entity.position = void 0;
-			entity.label.text = void 0;
-			entity.polygon.hierarchy = void 0;
-			entity.polyline.positions = new cesium.CallbackProperty(() => positions, false);
-		} else if (positions.length >= 3) {
-			positions.push(positions[0]);
-			entity.position = new cesium.ConstantPositionProperty((0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions))));
-			entity.label.text = new cesium.ConstantProperty("");
-			area(positions).then((e) => {
-				let text = "";
-				if (e / 1e3 / 1e3 > 10) text = `${(e / 1e3 / 1e3).toFixed(2)}km²`;
-				else text = `${(+e).toFixed(2)}m²`;
-				entity.label.text = new cesium.ConstantProperty(text);
-			});
-			entity.polyline.positions = void 0;
-			entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
-				return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
-			}, false);
-		} else {
-			entity.position = void 0;
-			entity.polygon.hierarchy = void 0;
-			entity.polyline.positions = void 0;
+//#region scheme/PolygonArrowUnitCombatOperationTailed.ts
+	const PlotSchemePolygonArrowUnitCombatOperationTailed = new PlotScheme({
+		type: "PolygonArrowUnitCombatOperationTailed",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowUnitCombatOperationTailed)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		return { entities: [entity] };
-	}
-});
+	});
 
 //#endregion
-//#region scheme/billboard.ts
-/**
-*  广告牌标绘方案
-*/
-const schemeBillboard = new PlotScheme({
-	type: "billboard",
-	complete: (packable) => packable.positions.length >= 1,
-	skeletons: [moved],
-	initEntites: () => [new cesium.Entity({ billboard: {
-		image: "/favicon.svg",
-		width: 32,
-		height: 32
-	} })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({ billboard: {} });
-		const position = packable.positions?.[0] ?? mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		return { entities: [entity] };
-	}
-});
+//#region scheme/PolygonAssemblingPlace.ts
+	const PlotSchemePolygonAssemblingPlace = new PlotScheme({
+		type: "PolygonAssemblingPlace",
+		complete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const points = context.packable.positions;
+			context.mouse && points.push(context.mouse.clone());
+			const coords = points.map((e) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			if (coords.length === 2) {
+				const c0 = (0, vesium.toCartographic)(coords[0]);
+				const c1 = (0, vesium.toCartographic)(coords[1]);
+				const latitude = c0.latitude;
+				const height = c0.height;
+				const longitude = c1.longitude - (c0.longitude - c1.longitude);
+				coords.push((0, vesium.toCoord)(new cesium.Cartographic(longitude, latitude, height)));
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.assemblingPlace)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
-//#region scheme/label.ts
-/**
-*  标签文字标绘方案
-*/
-const schemeLabel = new PlotScheme({
-	type: "label",
-	complete: (packable) => packable.positions.length >= 1,
-	skeletons: [moved],
-	initEntites: () => [new cesium.Entity({ label: { text: "Label" } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({ label: {} });
-		const position = packable.positions?.[0] ?? mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		return { entities: [entity] };
-	}
-});
+//#region scheme/PolygonSmooth.ts
+	const PlotSchemePolygonSmooth = new PlotScheme({
+		type: "PolygonSmooth",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polygon: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = context.packable.positions;
+			const mousePosition = context.mouse;
+			mousePosition && positions.push(mousePosition.clone());
+			if (positions.length <= 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const wgs84s = positions.map((e) => (0, vesium.toCoord)(e));
+			wgs84s.push(wgs84s[0]);
+			const { features } = __turf_turf.polygonSmooth(__turf_turf.polygon([wgs84s]), { iterations: 3 });
+			const hierarchy = new cesium.PolygonHierarchy(features[0].geometry.coordinates[0].map((item) => (0, vesium.toCartesian3)(item)).filter((e) => !!e));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
-//#region scheme/polygon.ts
-/**
-* 内置的多边形标绘方案
-*/
-const schemePolygon = new PlotScheme({
-	type: "polygon",
-	allowManualComplete: (packable) => packable.positions.length >= 3,
-	skeletons: [
-		control,
-		interval,
-		moved
-	],
-	initEntites: () => [new cesium.Entity({
-		polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-		polygon: { material: cesium.Color.YELLOW.withAlpha(.5) }
-	})],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({
-			polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-			polygon: { material: cesium.Color.YELLOW.withAlpha(.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;
+//#region scheme/Polyline.ts
+	const PlotSchemePolyline = new PlotScheme({
+		type: "Polyline",
+		allowManualComplete: (packable) => packable.positions.length > 1,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				material: cesium.Color.RED,
+				width: 2
+			} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = [...context.packable.positions];
+			const mouse = context.mouse;
+			mouse && positions.push(mouse.clone());
+			const cache = positions.length >= 2 ? positions : [];
+			entity.polyline.positions = new cesium.CallbackProperty(() => cache, false);
+			return { entities: [entity] };
 		}
-		return { entities: [entity] };
-	}
-});
+	});
 
 //#endregion
-//#region scheme/polyline.ts
-/**
-* 内置的线段标绘方案
-*/
-const schemePolyline = new PlotScheme({
-	type: "polyline",
-	allowManualComplete: (packable) => packable.positions.length >= 2,
-	skeletons: [
-		control,
-		intervalNonclosed,
-		moved
-	],
-	initEntites: () => [new cesium.Entity({ polyline: { width: 1 } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({ polyline: {} });
-		entity.polyline.positions = new cesium.CallbackProperty(() => {
-			const positions = [...packable.positions ?? []].concat(mouse ? [mouse] : []);
-			return positions.length >= 2 ? positions : [];
-		}, false);
-		return { entities: [entity] };
-	}
-});
+//#region scheme/PolylineCurve.ts
+	const PlotSchemePolylineCurve = new PlotScheme({
+		type: "PolylineCurve",
+		allowManualComplete: (packable) => packable.positions.length > 1,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				material: cesium.Color.RED,
+				width: 2
+			} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = [...context.packable.positions];
+			const mouse = context.mouse;
+			mouse && positions.push(mouse.clone());
+			if (positions.length < 2) {
+				entity.polyline.positions = void 0;
+				return context.previous;
+			}
+			const coords = positions.map((position) => (0, vesium.toCoord)(position));
+			const { geometry: { coordinates } } = __turf_turf.bezierSpline(__turf_turf.lineString(coords));
+			entity.polyline.positions = new cesium.CallbackProperty(() => coordinates.map(vesium.toCartesian3), false);
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
-//#region scheme/rectangle.ts
-/**
-* 内置的多边形标绘方案
-*/
-const schemeRectangle = new PlotScheme({
-	type: "rectangle",
-	complete: (packable) => packable.positions.length >= 2,
-	skeletons: [
-		control,
-		interval,
-		moved
-	],
-	initEntites: () => [new cesium.Entity({ rectangle: { material: cesium.Color.YELLOW.withAlpha(.5) } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({ rectangle: { material: cesium.Color.YELLOW.withAlpha(.5) } });
-		const positions = [...packable.positions ?? []];
-		mouse && positions.push(mouse);
-		if (positions.length >= 2) entity.rectangle.coordinates = new cesium.CallbackProperty(() => cesium.Rectangle.fromCartesianArray(positions), false);
-		else entity.rectangle.coordinates = void 0;
-		return { entities: [entity] };
-	}
-});
+//#region scheme/Rectangle.ts
+	const PlotSchemeRectangle = new PlotScheme({
+		type: "Rectangle",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.Entity({ rectangle: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const positions = [...context.packable.positions];
+			const mouse = context.mouse;
+			mouse && positions.push(mouse.clone());
+			if (positions.length < 2) {
+				entity.rectangle.coordinates = void 0;
+				return context.previous;
+			}
+			const coordinates = cesium.Rectangle.fromCartesianArray(positions ?? []);
+			entity.rectangle.coordinates = new cesium.CallbackProperty(() => coordinates, false);
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
 exports.PlotAction = PlotAction;
 exports.PlotFeature = PlotFeature;
 exports.PlotScheme = PlotScheme;
+exports.PlotSchemeBillboard = PlotSchemeBillboard;
+exports.PlotSchemeBillboardPinBuilder = PlotSchemeBillboardPinBuilder;
+exports.PlotSchemeCylinder = PlotSchemeCylinder;
+exports.PlotSchemeEllipse = PlotSchemeEllipse;
+exports.PlotSchemeLabel = PlotSchemeLabel;
+exports.PlotSchemePoint = PlotSchemePoint;
+exports.PlotSchemePolygon = PlotSchemePolygon;
+exports.PlotSchemePolygonArc = PlotSchemePolygonArc;
+exports.PlotSchemePolygonArrowAttackDirection = PlotSchemePolygonArrowAttackDirection;
+exports.PlotSchemePolygonArrowAttackDirectionTailed = PlotSchemePolygonArrowAttackDirectionTailed;
+exports.PlotSchemePolygonArrowClamped = PlotSchemePolygonArrowClamped;
+exports.PlotSchemePolygonArrowStraight = PlotSchemePolygonArrowStraight;
+exports.PlotSchemePolygonArrowStraightSharp = PlotSchemePolygonArrowStraightSharp;
+exports.PlotSchemePolygonArrowUnitCombatOperation = PlotSchemePolygonArrowUnitCombatOperation;
+exports.PlotSchemePolygonArrowUnitCombatOperationTailed = PlotSchemePolygonArrowUnitCombatOperationTailed;
+exports.PlotSchemePolygonAssemblingPlace = PlotSchemePolygonAssemblingPlace;
+exports.PlotSchemePolygonSmooth = PlotSchemePolygonSmooth;
+exports.PlotSchemePolyline = PlotSchemePolyline;
+exports.PlotSchemePolylineCurve = PlotSchemePolylineCurve;
+exports.PlotSchemeRectangle = PlotSchemeRectangle;
 exports.PlotSkeletonEntity = PlotSkeletonEntity;
 exports.SampledPlotProperty = SampledPlotProperty;
 exports.SampledPlotStrategy = SampledPlotStrategy;
@@ -1512,12 +2033,8 @@ exports.control = control;
 exports.interval = interval;
 exports.intervalNonclosed = intervalNonclosed;
 exports.moved = moved;
-exports.schemeBillboard = schemeBillboard;
-exports.schemeLabel = schemeLabel;
 exports.schemeMeasureArea = schemeMeasureArea;
-exports.schemePolygon = schemePolygon;
-exports.schemePolyline = schemePolyline;
-exports.schemeRectangle = schemeRectangle;
+exports.schemeMeasureDistance = schemeMeasureDistance;
 exports.usePlot = usePlot;
-})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue);
+})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue, Vesium, turf);
 //# sourceMappingURL=index.iife.js.map