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

package/dist/index.cjs

@@ -21,10 +21,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const cesium = __toESM(require("cesium"));
-const vesium = __toESM(require("vesium"));
-const __vueuse_core = __toESM(require("@vueuse/core"));
-const vue = __toESM(require("vue"));
+let cesium = require("cesium");
+cesium = __toESM(cesium);
+let vesium = require("vesium");
+vesium = __toESM(vesium);
+let __vueuse_core = require("@vueuse/core");
+__vueuse_core = __toESM(__vueuse_core);
+let vue = require("vue");
+vue = __toESM(vue);
+let __vesium_geometry = require("@vesium/geometry");
+__vesium_geometry = __toESM(__vesium_geometry);
+let __turf_turf = require("@turf/turf");
+__turf_turf = __toESM(__turf_turf);
 
 //#region usePlot/PlotScheme.ts
 var PlotScheme = class PlotScheme {
@@ -34,9 +42,7 @@ var PlotScheme = class PlotScheme {
 		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.initRender = options.initRender;
 		this.render = options.render;
 	}
 	/**
@@ -63,17 +69,9 @@ var PlotScheme = class PlotScheme {
 	*/
 	skeletons;
 	/**
-	* 初始化时创建`Entity`的函数，创建后的`Entity`会作为配置项传入`render`中
-	*/
-	initEntites;
-	/**
-	* 初始化时创建`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-	*/
-	initPrimitives;
-	/**
 	* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
 	*/
-	initGroundPrimitives;
+	initRender;
 	/**
 	* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
 	*/
@@ -213,16 +211,13 @@ var SampledPlotProperty = class SampledPlotProperty {
 		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: {
+			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 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;
@@ -232,11 +227,10 @@ var SampledPlotProperty = class SampledPlotProperty {
 		const nextIndex = Math.min(prevIndex, this._times.length - 1);
 		const prevMs = cesium.JulianDate.toDate(this._times[prevIndex]).getTime();
 		const nextMs = cesium.JulianDate.toDate(this._times[nextIndex]).getTime();
-		const ms = cesium.JulianDate.toDate(time).getTime();
 		return {
 			prevIndex,
 			nextIndex,
-			proportion: (ms - prevMs) / (nextMs - prevMs) || 0
+			proportion: (cesium.JulianDate.toDate(time).getTime() - prevMs) / (nextMs - prevMs) || 0
 		};
 	}
 	/**
@@ -248,10 +242,13 @@ var SampledPlotProperty = class SampledPlotProperty {
 	* @template D 数据类型。
 	*/
 	getValue(time, result) {
-		result ??= { time };
+		result ??= {
+			time,
+			positions: []
+		};
 		Object.assign(result, {
 			time: time?.clone(),
-			positions: void 0,
+			positions: [],
 			derivative: void 0
 		});
 		if (!time) {
@@ -325,8 +322,7 @@ var SampledPlotProperty = class SampledPlotProperty {
 		if (index !== -1) {
 			this._sampleds.splice(index, 1);
 			this._derivatives.splice(index, 1);
-			const removed = this._times.splice(index, 1);
-			if (removed.length) {
+			if (this._times.splice(index, 1).length) {
 				this._definitionChanged.raiseEvent(this);
 				return true;
 			}
@@ -367,9 +363,10 @@ var PlotFeature = class {
 		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?.() ?? []];
+		const init = this._scheme.initRender?.() ?? {};
+		this._entities = [...init.entities ?? []];
+		this._primitives = [...init.primitives ?? []];
+		this._groundPrimitives = [...init.groundPrimitives ?? []];
 		this._skeletons = [];
 	}
 	/**
@@ -555,19 +552,27 @@ function useRender(plots, current, getCurrentTime) {
 		}
 	});
 	const update = async (plot) => {
-		const reslut = await plot.scheme.render?.({
-			packable: plot.sampled.getValue(getCurrentTime()),
-			mouse: plot.defining ? mouseCartesian.value : void 0,
+		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 = reslut?.entities ?? [];
-		plot.primitives = reslut?.primitives ?? [];
-		plot.groundPrimitives = reslut?.groundPrimitives ?? [];
+		plot.entities = result?.entities ?? [];
+		plot.primitives = result?.primitives ?? [];
+		plot.groundPrimitives = result?.groundPrimitives ?? [];
 	};
 	(0, vue.watch)(current, (plot, previous) => {
 		previous && update(previous);
@@ -610,8 +615,7 @@ function useSampled(current, getCurrentTime) {
 		packable.value.positions ??= [];
 		packable.value.positions.push(position);
 		sampled.setSample(packable.value);
-		const completed = scheme.complete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
+		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;
@@ -620,10 +624,8 @@ function useSampled(current, getCurrentTime) {
 		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);
+		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;
@@ -673,13 +675,11 @@ function useSkeleton(plots, current, getCurrentTime) {
 			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({
+			plot.scheme.skeletons.forEach((skeleton) => {
+				if ((0, vesium.isFunction)(skeleton.disabled) ? skeleton.disabled({
 					active,
 					defining
-				}) : skeleton.disabled;
-				if (disabled) return;
+				}) : 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);
@@ -706,9 +706,9 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 		plot.skeletons = entities;
 	};
-	const { addGraphicEvent } = (0, vesium.useGraphicEvent)();
+	const graphicEvent = (0, vesium.useGraphicEvent)();
 	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
+		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;
@@ -741,8 +741,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
 				}
 			}
-		});
-		onCleanup(remove);
+		}));
 	});
 	(0, __vueuse_core.onKeyStroke)((keyEvent) => {
 		if (activeEntity.value) {
@@ -761,16 +760,13 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 	});
 	(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);
+		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) => {
-		const remove = addGraphicEvent("global", "LEFT_CLICK", ({ event, pick }) => {
+		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;
@@ -788,8 +784,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					event
 				});
 			} else activeEntity.value = void 0;
-		});
-		onCleanup(remove);
+		}));
 	});
 	(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
 		added.forEach((plot) => update(plot));
@@ -854,8 +849,7 @@ function usePlot(options) {
 		if (previous) {
 			if (previous.defining) {
 				const packable$1 = previous.sampled.getValue(getCurrentTime());
-				const completed = previous.scheme.allowManualComplete?.(packable$1);
-				if (completed) {
+				if (previous.scheme.allowManualComplete?.(packable$1)) {
 					PlotFeature.setDefining(previous, false);
 					operateResolve?.(previous);
 				} else collection.delete(previous);
@@ -939,10 +933,9 @@ function control() {
 			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);
+			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,
@@ -951,16 +944,15 @@ function control() {
 			});
 		},
 		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],
+					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)
@@ -1007,16 +999,15 @@ function interval() {
 		},
 		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],
+					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)
@@ -1061,16 +1052,15 @@ function intervalNonclosed() {
 			});
 		},
 		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],
+					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)
@@ -1095,10 +1085,7 @@ function moved() {
 			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)];
-			}
+			else return [(0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions)))];
 		},
 		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
 			dragging && lockCamera();
@@ -1114,18 +1101,17 @@ function moved() {
 			});
 		},
 		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],
+					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,
@@ -1195,17 +1181,17 @@ async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
 		else resolve([]);
 	});
 	const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
-	const resluts = [];
+	const results = [];
 	positions.forEach((item, index) => {
 		const position = tilesetPositions[index] || terrainPositions[index] ? cesium.Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
-		resluts.push(position);
+		results.push(position);
 	});
-	return resluts;
+	return results;
 }
 
 //#endregion
 //#region measure/utils/triangleGrid.ts
-function defaultOptions$1(original) {
+function defaultOptions$2(original) {
 	const clampToGround = original?.clampToGround ?? false;
 	const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
 	const density = Math.floor(original?.density ?? 10);
@@ -1224,13 +1210,12 @@ function defaultOptions$1(original) {
 */
 async function triangleGrid(positions, options) {
 	if (positions.length < 3) throw new Error("positions must >= 3");
-	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(options);
+	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 max = Math.max(horizontal, vertical);
-	const granularity = max / density;
+	const granularity = Math.max(horizontal, vertical) / density;
 	const polygonGeometry = cesium.PolygonGeometry.fromPositions({
 		positions,
 		vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
@@ -1249,13 +1234,12 @@ async function triangleGrid(positions, options) {
 	}
 	if (clampToGround) {
 		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
-		const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+		cartesian3List = await clampToHeightMostDetailedByTilesetOrTerrain({
 			scene,
 			terrainProvider,
 			positions: cartesian3List,
 			classificationType
 		});
-		cartesian3List = detaileds;
 	}
 	const grid = [];
 	while (cartesian3List?.length) {
@@ -1283,7 +1267,7 @@ function triangleArea(p0, p1, p2) {
 	const cross = cesium.Cartesian3.cross(v0, v1, v0);
 	return cesium.Cartesian3.magnitude(cross) * .5;
 }
-function defaultOptions(original) {
+function defaultOptions$1(original) {
 	const clampToGround = original?.clampToGround ?? false;
 	const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
 	const density = Math.floor(original?.density ?? 10);
@@ -1301,40 +1285,121 @@ function defaultOptions(original) {
 */
 async function area(positions, options) {
 	if (positions.length < 2) throw new Error("positions.length must >= 2");
-	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions(options);
+	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(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, {
+	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 measure/utils/lerpArray.ts
+/**
+* 在起点和终点间进行插值, 返回的数组包括起点和终点，数组长度为 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 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;
+		}
+	});
+	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);
+	});
+	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
+		});
 	});
-	return triangles.reduce((count, current) => count += triangleArea(...current), 0);
+	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 measure/measureArea.ts
 const schemeMeasureArea = new PlotScheme({
-	type: "measureArea",
+	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({
+	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) {
@@ -1366,19 +1431,67 @@ const schemeMeasureArea = new PlotScheme({
 });
 
 //#endregion
-//#region scheme/billboard.ts
-/**
-*  广告牌标绘方案
-*/
-const schemeBillboard = new PlotScheme({
-	type: "billboard",
+//#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"
+				})
+			});
+		});
+		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);
+			});
+			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;
+			}
+		});
+		return { entities };
+	}
+});
+
+//#endregion
+//#region scheme/Billboard.ts
+const PlotSchemeBillboard = new PlotScheme({
+	type: "Billboard",
 	complete: (packable) => packable.positions.length >= 1,
 	skeletons: [moved],
-	initEntites: () => [new cesium.Entity({ billboard: {
-		image: "/favicon.svg",
-		width: 32,
-		height: 32
-	} })],
+	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: {} });
@@ -1389,47 +1502,130 @@ const schemeBillboard = new PlotScheme({
 });
 
 //#endregion
-//#region scheme/label.ts
-/**
-*  标签文字标绘方案
-*/
-const schemeLabel = new PlotScheme({
-	type: "label",
+//#region scheme/BillboardPinBuilder.ts
+const PlotSchemeBillboardPinBuilder = new PlotScheme({
+	type: "BillboardPinBuilder",
 	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;
+	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] };
 	}
 });
 
 //#endregion
-//#region scheme/polygon.ts
-/**
-* 内置的多边形标绘方案
-*/
-const schemePolygon = new PlotScheme({
-	type: "polygon",
-	allowManualComplete: (packable) => packable.positions.length >= 3,
+//#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] };
+	}
+});
+
+//#endregion
+//#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: {} })] };
+	},
+	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.ellipse.semiMinorAxis = new cesium.CallbackProperty(() => radius || 1, false);
+		entity.ellipse.semiMajorAxis = entity.ellipse.semiMinorAxis;
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#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(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 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(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 scheme/Polygon.ts
+const PlotSchemePolygon = new PlotScheme({
+	type: "Polygon",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
 	skeletons: [
+		moved,
 		control,
-		interval,
-		moved
+		interval
 	],
-	initEntites: () => [new cesium.Entity({
-		polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-		polygon: { material: cesium.Color.YELLOW.withAlpha(.5) }
-	})],
+	initRender: () => {
+		return { entities: [new cesium.Entity({
+			polyline: {},
+			polygon: {}
+		})] };
+	},
 	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 entity = options.previous.entities[0];
 		const positions = [...packable.positions ?? []];
 		mouse && positions.push(mouse);
 		if (positions.length === 2) {
@@ -1450,51 +1646,362 @@ const schemePolygon = new PlotScheme({
 });
 
 //#endregion
-//#region scheme/polyline.ts
-/**
-* 内置的线段标绘方案
-*/
-const schemePolyline = new PlotScheme({
-	type: "polyline",
-	allowManualComplete: (packable) => packable.positions.length >= 2,
+//#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(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 scheme/PolygonArrowAttackDirection.ts
+const PlotSchemePolygonArrowAttackDirection = new PlotScheme({
+	type: "PolygonArrowAttackDirection",
+	allowManualComplete: (packable) => packable.positions.length >= 3,
 	skeletons: [
+		moved,
 		control,
-		intervalNonclosed,
-		moved
+		intervalNonclosed
 	],
-	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);
+	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 scheme/rectangle.ts
-/**
-* 内置的多边形标绘方案
-*/
-const schemeRectangle = new PlotScheme({
-	type: "rectangle",
+//#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] };
+	}
+});
+
+//#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] };
+	}
+});
+
+//#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] };
+	}
+});
+
+//#endregion
+//#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] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowUnitCombatOperation.ts
+const PlotSchemePolygonArrowUnitCombatOperation = new PlotScheme({
+	type: "PolygonArrowUnitCombatOperation",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
 	skeletons: [
+		moved,
 		control,
-		interval,
-		moved
+		intervalNonclosed
 	],
-	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;
+	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] };
+	}
+});
+
+//#endregion
+//#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] };
+	}
+});
+
+//#endregion
+//#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/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/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] };
+	}
+});
+
+//#endregion
+//#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 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] };
 	}
 });
@@ -1503,6 +2010,26 @@ const schemeRectangle = new PlotScheme({
 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;
@@ -1510,11 +2037,7 @@ 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;
 //# sourceMappingURL=index.cjs.map