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

package/dist/index.mjs

@@ -1,7 +1,9 @@
-import { CallbackPositionProperty, CallbackProperty, Cartesian3, Cartographic, ClassificationType, Color, ConstantPositionProperty, ConstantProperty, CoplanarPolygonGeometry, CustomDataSource, Ellipsoid, Entity, Event, HorizontalOrigin, JulianDate, PerInstanceColorAppearance, PolygonGeometry, PolygonHierarchy, PrimitiveCollection, Rectangle, ScreenSpaceEventType, TimeInterval, VertexFormat, VerticalOrigin, createGuid, sampleTerrainMostDetailed } from "cesium";
-import { arrayDiff, assertError, canvasCoordToCartesian, isFunction, pickHitGraphic, toCartesian3, toCartographic, useCesiumEventListener, useDataSource, useEntityScope, useGraphicEvent, usePrimitive, usePrimitiveScope, useScreenSpaceEventHandler, useViewer } from "vesium";
+import { CallbackPositionProperty, CallbackProperty, Cartesian3, Cartographic, ClassificationType, Color, ConstantPositionProperty, ConstantProperty, CoplanarPolygonGeometry, CustomDataSource, Ellipsoid, Entity, Event, HorizontalOrigin, JulianDate, LabelGraphics, PerInstanceColorAppearance, PolygonGeometry, PolygonHierarchy, PolylineGraphics, PrimitiveCollection, Rectangle, ScreenSpaceEventType, TimeInterval, VertexFormat, VerticalOrigin, createGuid, sampleTerrainMostDetailed } from "cesium";
+import { arrayDiff, assertError, canvasCoordToCartesian, isFunction, pickHitGraphic, toCartesian3, toCartographic, toCoord, toProperty, toPropertyValue, useCesiumEventListener, useDataSource, useEntityScope, useGraphicEvent, usePrimitive, usePrimitiveScope, useScreenSpaceEventHandler, useViewer } from "vesium";
 import { assert, onKeyStroke, promiseTimeout, watchArray } from "@vueuse/core";
 import { computed, nextTick, ref, shallowReactive, shallowRef, toValue, watch, watchEffect } from "vue";
+import { arc, arrowAttackDirection, arrowAttackDirectionTailed, arrowClamped, arrowStraight, arrowStraightSharp, arrowUnitCombatOperation, arrowUnitCombatOperationTailed, assemblingPlace } from "@vesium/geometry";
+import * as turf from "@turf/turf";
 
 //#region usePlot/PlotScheme.ts
 var PlotScheme = class PlotScheme {
@@ -11,9 +13,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;
 	}
 	/**
@@ -40,17 +40,9 @@ var PlotScheme = class PlotScheme {
 	*/
 	skeletons;
 	/**
-	* 初始化时创建`Entity`的函数，创建后的`Entity`会作为配置项传入`render`中
-	*/
-	initEntites;
-	/**
-	* 初始化时创建`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-	*/
-	initPrimitives;
-	/**
 	* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
 	*/
-	initGroundPrimitives;
+	initRender;
 	/**
 	* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
 	*/
@@ -190,16 +182,13 @@ var SampledPlotProperty = class SampledPlotProperty {
 		const end = this._times[this._times.length - 1];
 		if (JulianDate.lessThan(time, start) || JulianDate.greaterThan(time, end)) switch (this.strategy) {
 			case SampledPlotStrategy.STRICT: return;
-			case SampledPlotStrategy.NEAR: {
+			case SampledPlotStrategy.NEAR:
 				time = JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
 				break;
-			}
 			case SampledPlotStrategy.CYCLE: {
 				const startMS = JulianDate.toDate(this._times[0]).getTime();
-				const endMS = JulianDate.toDate(this._times[this._times.length - 1]).getTime();
-				const duration = endMS - startMS;
-				const timeMS = JulianDate.toDate(time).getTime();
-				const diff = (timeMS - startMS) % duration;
+				const duration = JulianDate.toDate(this._times[this._times.length - 1]).getTime() - startMS;
+				const diff = (JulianDate.toDate(time).getTime() - startMS) % duration;
 				const dete = new Date(startMS + diff);
 				time = JulianDate.fromDate(dete);
 				break;
@@ -209,11 +198,10 @@ var SampledPlotProperty = class SampledPlotProperty {
 		const nextIndex = Math.min(prevIndex, this._times.length - 1);
 		const prevMs = JulianDate.toDate(this._times[prevIndex]).getTime();
 		const nextMs = JulianDate.toDate(this._times[nextIndex]).getTime();
-		const ms = JulianDate.toDate(time).getTime();
 		return {
 			prevIndex,
 			nextIndex,
-			proportion: (ms - prevMs) / (nextMs - prevMs) || 0
+			proportion: (JulianDate.toDate(time).getTime() - prevMs) / (nextMs - prevMs) || 0
 		};
 	}
 	/**
@@ -225,10 +213,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) {
@@ -302,8 +293,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;
 			}
@@ -344,9 +334,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 = [];
 	}
 	/**
@@ -532,19 +523,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 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 ?? [];
 	};
 	watch(current, (plot, previous) => {
 		previous && update(previous);
@@ -587,8 +586,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);
 	});
 	useScreenSpaceEventHandler(ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
 		if (!current.value || !packable.value) return;
@@ -597,10 +595,8 @@ function useSampled(current, getCurrentTime) {
 		doubleClicking.value = false;
 		const { scheme, defining } = current.value;
 		if (!defining) return;
-		const position = canvasCoordToCartesian(ctx.position, viewer.value.scene);
-		if (!position) return;
-		const completed = scheme.allowManualComplete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
+		if (!canvasCoordToCartesian(ctx.position, viewer.value.scene)) return;
+		scheme.allowManualComplete?.(packable.value) && PlotFeature.setDefining(current.value, false);
 	});
 	useScreenSpaceEventHandler(ScreenSpaceEventType.RIGHT_CLICK, async () => {
 		if (!current.value || !packable.value) return;
@@ -650,13 +646,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 = isFunction(skeleton.disabled) ? skeleton.disabled({
+			plot.scheme.skeletons.forEach((skeleton) => {
+				if (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);
@@ -683,9 +677,9 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 		plot.skeletons = entities;
 	};
-	const { addGraphicEvent } = useGraphicEvent();
+	const graphicEvent = useGraphicEvent();
 	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;
@@ -718,8 +712,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					return isFunction(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : toValue(skeleton?.dragCursor);
 				}
 			}
-		});
-		onCleanup(remove);
+		}));
 	});
 	onKeyStroke((keyEvent) => {
 		if (activeEntity.value) {
@@ -738,16 +731,13 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 	});
 	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;
+		}));
 	});
 	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;
@@ -765,8 +755,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					event
 				});
 			} else activeEntity.value = void 0;
-		});
-		onCleanup(remove);
+		}));
 	});
 	watchArray(plots, (value, oldValue, added, removed = []) => {
 		added.forEach((plot) => update(plot));
@@ -831,8 +820,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);
@@ -916,10 +904,9 @@ function control() {
 			const newHeading = (viewer.camera.heading + headingAdjust) % (2 * Math.PI);
 			const positions = [...packable.positions ?? []];
 			const cartographic = 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] = toCartesian3(cartographic);
 			sampled.setSample({
 				time: packable.time,
@@ -928,16 +915,15 @@ function control() {
 			});
 		},
 		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: Color.BLUE.withAlpha(.4),
-				[PlotAction.HOVER]: Color.BLUE.withAlpha(.6),
-				[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
-			};
 			return {
 				position,
 				point: {
 					pixelSize: 8,
-					color: colors[action],
+					color: {
+						[PlotAction.IDLE]: Color.BLUE.withAlpha(.4),
+						[PlotAction.HOVER]: Color.BLUE.withAlpha(.6),
+						[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
+					}[action],
 					disableDepthTestDistance: Number.POSITIVE_INFINITY,
 					outlineWidth: 1,
 					outlineColor: Color.WHITE.withAlpha(.4)
@@ -984,16 +970,15 @@ function interval() {
 		},
 		render: ({ position, action, active }) => {
 			if (!active) return;
-			const colors = {
-				[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
-				[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
-			};
 			return {
 				position,
 				point: {
 					pixelSize: 6,
-					color: colors[action],
+					color: {
+						[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
+						[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
+						[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
+					}[action],
 					disableDepthTestDistance: Number.POSITIVE_INFINITY,
 					outlineWidth: 1,
 					outlineColor: Color.WHITE.withAlpha(.4)
@@ -1038,16 +1023,15 @@ function intervalNonclosed() {
 			});
 		},
 		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
-				[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
-			};
 			return {
 				position,
 				point: {
 					pixelSize: 6,
-					color: colors[action],
+					color: {
+						[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
+						[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
+						[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
+					}[action],
 					disableDepthTestDistance: Number.POSITIVE_INFINITY,
 					outlineWidth: 1,
 					outlineColor: Color.WHITE.withAlpha(.4)
@@ -1072,10 +1056,7 @@ function moved() {
 			const positions = packable.positions ?? [];
 			if (positions.length === 0) return [];
 			else if (positions.length === 1) return [positions[0]];
-			else {
-				const center = Rectangle.center(Rectangle.fromCartesianArray(positions));
-				return [toCartesian3(center)];
-			}
+			else return [toCartesian3(Rectangle.center(Rectangle.fromCartesianArray(positions)))];
 		},
 		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
 			dragging && lockCamera();
@@ -1091,18 +1072,17 @@ function moved() {
 			});
 		},
 		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: Color.WHITE,
-				[PlotAction.HOVER]: Color.WHITE,
-				[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
-			};
 			return {
 				position,
 				billboard: {
 					image: svg,
 					width: 20,
 					height: 20,
-					color: colors[action],
+					color: {
+						[PlotAction.IDLE]: Color.WHITE,
+						[PlotAction.HOVER]: Color.WHITE,
+						[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
+					}[action],
 					pixelOffset: new Cartesian3(0, -20),
 					horizontalOrigin: HorizontalOrigin.CENTER,
 					verticalOrigin: VerticalOrigin.BOTTOM,
@@ -1172,17 +1152,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] ? 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 ?? ClassificationType.BOTH;
 	const density = Math.floor(original?.density ?? 10);
@@ -1201,13 +1181,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 = 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 = PolygonGeometry.fromPositions({
 		positions,
 		vertexFormat: PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
@@ -1226,13 +1205,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) {
@@ -1260,7 +1238,7 @@ function triangleArea(p0, p1, p2) {
 	const cross = Cartesian3.cross(v0, v1, v0);
 	return Cartesian3.magnitude(cross) * .5;
 }
-function defaultOptions(original) {
+function defaultOptions$1(original) {
 	const clampToGround = original?.clampToGround ?? false;
 	const classificationType = original?.classificationType ?? ClassificationType.BOTH;
 	const density = Math.floor(original?.density ?? 10);
@@ -1278,40 +1256,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 = Cartesian3.lerp(start, end, 1 / count, new 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 ?? 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 = 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 Entity({
-		label: { font: "14pt" },
-		polyline: { material: Color.YELLOW.withAlpha(.5) },
-		polygon: { material: Color.YELLOW.withAlpha(.5) }
-	})],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new Entity({
+	initRender() {
+		return { entities: [new Entity({
 			label: { font: "14pt" },
 			polyline: { material: Color.YELLOW.withAlpha(.5) },
 			polygon: { material: 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) {
@@ -1343,19 +1402,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 Entity({ polyline: {
+			width: 2,
+			material: 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 PolylineGraphics();
+		pl.polyline.positions = new CallbackProperty(() => positions, false);
+		positions.forEach((item, index) => {
+			if (!entities[index + 1]) entities[index + 1] = new Entity({
+				position: item,
+				label: new LabelGraphics({
+					backgroundColor: 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 CallbackPositionProperty(() => Cartesian3.midpoint(positions[index], positions[index + 1], new Cartesian3()), false);
+				entities[index + 1].label.text = new CallbackProperty(() => `${stage.toFixed(2)} m`, false);
+			});
+			if (stages.length > 1) {
+				entities[entities.length - 1].position = new CallbackPositionProperty(() => positions[positions.length - 1], false);
+				entities[entities.length - 1].label.text = new 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 Entity({ billboard: {
-		image: "/favicon.svg",
-		width: 32,
-		height: 32
-	} })],
+	initRender: () => {
+		return { entities: [new Entity({ billboard: {
+			image: "/favicon.svg",
+			width: 32,
+			height: 32
+		} })] };
+	},
 	render(options) {
 		const { mouse, packable } = options;
 		const entity = options.previous.entities?.[0] ?? new Entity({ billboard: {} });
@@ -1366,47 +1473,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 Entity({ label: { text: "Label" } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new Entity({ label: {} });
-		const position = packable.positions?.[0] ?? mouse;
+	initRender() {
+		return { entities: [new Entity({ billboard: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
 		entity.position = new 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 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 ConstantPositionProperty(positions[0]);
+		const radius = Cartesian3.distance(positions[0], positions[1]);
+		entity.cylinder.bottomRadius = new CallbackProperty(() => radius, false);
+		if (context.defining || !toPropertyValue(entity.cylinder.length)) entity.cylinder.length = 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 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 ConstantPositionProperty(positions[0]);
+		const radius = Cartesian3.distance(positions[0], positions[1]);
+		entity.ellipse.semiMinorAxis = new 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 Entity({ label: { text: "Label" } })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
+		entity.position = new 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 Entity({ point: {
+			pixelSize: 10,
+			color: Color.RED
+		} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
+		entity.position = new 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 Entity({
-		polyline: { material: Color.YELLOW.withAlpha(.5) },
-		polygon: { material: Color.YELLOW.withAlpha(.5) }
-	})],
+	initRender: () => {
+		return { entities: [new Entity({
+			polyline: {},
+			polygon: {}
+		})] };
+	},
 	render(options) {
 		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new Entity({
-			polyline: { material: Color.YELLOW.withAlpha(.5) },
-			polygon: { material: Color.YELLOW.withAlpha(.5) }
-		});
+		const entity = options.previous.entities[0];
 		const positions = [...packable.positions ?? []];
 		mouse && positions.push(mouse);
 		if (positions.length === 2) {
@@ -1427,55 +1617,366 @@ 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 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) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const hierarchy = new PolygonHierarchy(arc(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 Entity({ polyline: { width: 1 } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new Entity({ polyline: {} });
-		entity.polyline.positions = new CallbackProperty(() => {
-			const positions = [...packable.positions ?? []].concat(mouse ? [mouse] : []);
-			return positions.length >= 2 ? positions : [];
-		}, false);
+	initRender() {
+		return { entities: [new 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) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const hierarchy = new PolygonHierarchy(arrowAttackDirection(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const hierarchy = new PolygonHierarchy(arrowAttackDirectionTailed(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length >= 3) {
+			const hierarchy = new PolygonHierarchy(arrowClamped(coords).map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length >= 2) {
+			const hierarchy = new PolygonHierarchy(arrowStraight(coords).map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length >= 2) {
+			const hierarchy = new PolygonHierarchy(arrowStraightSharp(coords).map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new 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 Entity({ rectangle: { material: Color.YELLOW.withAlpha(.5) } })],
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new Entity({ rectangle: { material: Color.YELLOW.withAlpha(.5) } });
-		const positions = [...packable.positions ?? []];
-		mouse && positions.push(mouse);
-		if (positions.length >= 2) entity.rectangle.coordinates = new CallbackProperty(() => Rectangle.fromCartesianArray(positions), false);
-		else entity.rectangle.coordinates = void 0;
+	initRender() {
+		return { entities: [new 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) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const hierarchy = new PolygonHierarchy(arrowUnitCombatOperation(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const hierarchy = new PolygonHierarchy(arrowUnitCombatOperationTailed(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		if (coords.length === 2) {
+			const c0 = toCartographic(coords[0]);
+			const c1 = toCartographic(coords[1]);
+			const latitude = c0.latitude;
+			const height = c0.height;
+			const longitude = c1.longitude - (c0.longitude - c1.longitude);
+			coords.push(toCoord(new Cartographic(longitude, latitude, height)));
+		}
+		const hierarchy = new PolygonHierarchy(assemblingPlace(coords).map((item) => toCartesian3(item)));
+		entity.polygon.hierarchy = new 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 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) => toCoord(e));
+		wgs84s.push(wgs84s[0]);
+		const { features } = turf.polygonSmooth(turf.polygon([wgs84s]), { iterations: 3 });
+		const hierarchy = new PolygonHierarchy(features[0].geometry.coordinates[0].map((item) => toCartesian3(item)).filter((e) => !!e));
+		entity.polygon.hierarchy = new 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 Entity({ polyline: {
+			material: 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 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 Entity({ polyline: {
+			material: 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) => toCoord(position));
+		const { geometry: { coordinates } } = turf.bezierSpline(turf.lineString(coords));
+		entity.polyline.positions = new CallbackProperty(() => coordinates.map(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 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 = Rectangle.fromCartesianArray(positions ?? []);
+		entity.rectangle.coordinates = new CallbackProperty(() => coordinates, false);
 		return { entities: [entity] };
 	}
 });
 
 //#endregion
-export { PlotAction, PlotFeature, PlotScheme, PlotSkeletonEntity, SampledPlotProperty, SampledPlotStrategy, control, interval, intervalNonclosed, moved, schemeBillboard, schemeLabel, schemeMeasureArea, schemePolygon, schemePolyline, schemeRectangle, usePlot };
+export { PlotAction, PlotFeature, PlotScheme, PlotSchemeBillboard, PlotSchemeBillboardPinBuilder, PlotSchemeCylinder, PlotSchemeEllipse, PlotSchemeLabel, PlotSchemePoint, PlotSchemePolygon, PlotSchemePolygonArc, PlotSchemePolygonArrowAttackDirection, PlotSchemePolygonArrowAttackDirectionTailed, PlotSchemePolygonArrowClamped, PlotSchemePolygonArrowStraight, PlotSchemePolygonArrowStraightSharp, PlotSchemePolygonArrowUnitCombatOperation, PlotSchemePolygonArrowUnitCombatOperationTailed, PlotSchemePolygonAssemblingPlace, PlotSchemePolygonSmooth, PlotSchemePolyline, PlotSchemePolylineCurve, PlotSchemeRectangle, PlotSkeletonEntity, SampledPlotProperty, SampledPlotStrategy, control, interval, intervalNonclosed, moved, schemeMeasureArea, schemeMeasureDistance, usePlot };
 //# sourceMappingURL=index.mjs.map