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

package/dist/index.iife.js

@@ -1,4 +1,4 @@
-(function(exports, cesium, vesium, __vueuse_core, vue) {
+(function(exports, cesium, vesium, __vueuse_core, vue, __turf_turf) {
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -27,6 +27,7 @@ cesium = __toESM(cesium);
 vesium = __toESM(vesium);
 __vueuse_core = __toESM(__vueuse_core);
 vue = __toESM(vue);
+__turf_turf = __toESM(__turf_turf);
 
 //#region usePlot/PlotScheme.ts
 var PlotScheme = class PlotScheme {
@@ -36,9 +37,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;
 	}
 	/**
@@ -65,17 +64,9 @@ var PlotScheme = class PlotScheme {
 	*/
 	skeletons;
 	/**
-	* 初始化时创建`Entity`的函数，创建后的`Entity`会作为配置项传入`render`中
-	*/
-	initEntites;
-	/**
-	* 初始化时创建`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-	*/
-	initPrimitives;
-	/**
 	* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
 	*/
-	initGroundPrimitives;
+	initRender;
 	/**
 	* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
 	*/
@@ -250,10 +241,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) {
@@ -369,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 = [];
 	}
 	/**
@@ -942,9 +937,9 @@ function control() {
 			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 = r * 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,
@@ -1207,7 +1202,7 @@ async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
 
 //#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);
@@ -1226,7 +1221,7 @@ 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;
@@ -1285,7 +1280,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);
@@ -1303,7 +1298,7 @@ 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);
@@ -1319,24 +1314,111 @@ async function area(positions, options) {
 	return triangles.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`.");
+	const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+		scene,
+		terrainProvider,
+		positions: result,
+		classificationType
+	});
+	return detaileds;
+}
+
+//#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
+		});
+	});
+	const detaileds = await Promise.all(positionListPromises);
+	const stagePromises = detaileds.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) {
@@ -1368,19 +1450,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) {
+		const entity = 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: {} });
@@ -1391,47 +1521,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) {
@@ -1452,51 +1665,1362 @@ const schemePolygon = new PlotScheme({
 });
 
 //#endregion
-//#region scheme/polyline.ts
+//#region geom/helper.ts
+const FITTING_COUNT = 100;
+const HALF_PI = Math.PI / 2;
+const ZERO_TOLERANCE = 1e-4;
+const TWO_PI = Math.PI * 2;
+/**
+* 计算两个坐标之间的距离
+* @param coord1
+* @param coord2
+*/
+function mathDistance(coord1, coord2) {
+	return Math.hypot(coord1[0] - coord2[0], coord1[1] - coord2[1]);
+}
+/**
+* 计算点集合的总距离
+* @param points
+*/
+function wholeDistance(points) {
+	let distance$1 = 0;
+	if (points && Array.isArray(points) && points.length > 0) points.forEach((item, index) => {
+		if (index < points.length - 1) distance$1 += mathDistance(item, points[index + 1]);
+	});
+	return distance$1;
+}
+/**
+* 获取基础长度
+* @param points
+*/
+const getBaseLength = (points) => wholeDistance(points) ** .99;
+/**
+* 求取两个坐标的中间坐标
+* @param coord1
+* @param coord2
+*/
+function mid(coord1, coord2) {
+	return [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
+}
+/**
+* 通过三个点确定一个圆的中心点
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getCircleCenterOfThreeCoords(coord1, coord2, coord3) {
+	const coordA = [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
+	const coordB = [coordA[0] - coord1[1] + coord2[1], coordA[1] + coord1[0] - coord2[0]];
+	const coordC = [(coord1[0] + coord3[0]) / 2, (coord1[1] + coord3[1]) / 2];
+	const coordD = [coordC[0] - coord1[1] + coord3[1], coordC[1] + coord1[0] - coord3[0]];
+	return getIntersectCoord(coordA, coordB, coordC, coordD);
+}
+/**
+* 获取交集的点
+* @param coordA
+* @param coordB
+* @param coordC
+* @param coordD
+*/
+function getIntersectCoord(coordA, coordB, coordC, coordD) {
+	if (coordA[1] === coordB[1]) {
+		const f$1 = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
+		const x$1 = f$1 * (coordA[1] - coordC[1]) + coordC[0];
+		const y$1 = coordA[1];
+		return [x$1, y$1];
+	}
+	if (coordC[1] === coordD[1]) {
+		const e$1 = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
+		const x$1 = e$1 * (coordC[1] - coordA[1]) + coordA[0];
+		const y$1 = coordC[1];
+		return [x$1, y$1];
+	}
+	const e = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
+	const f = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
+	const y = (e * coordA[1] - coordA[0] - f * coordC[1] + coordC[0]) / (e - f);
+	const x = e * y - e * coordA[1] + coordA[0];
+	return [x, y];
+}
+/**
+* 获取方位角（地平经度）
+* @param startCoord
+* @param endCoord
+*/
+function getAzimuth(startCoord, endCoord) {
+	let azimuth = 0;
+	const angle = Math.asin(Math.abs(endCoord[1] - startCoord[1]) / mathDistance(startCoord, endCoord));
+	if (endCoord[1] >= startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = angle + Math.PI;
+	else if (endCoord[1] >= startCoord[1] && endCoord[0] < startCoord[0]) azimuth = Math.PI * 2 - angle;
+	else if (endCoord[1] < startCoord[1] && endCoord[0] < startCoord[0]) azimuth = angle;
+	else if (endCoord[1] < startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = Math.PI - angle;
+	return azimuth;
+}
+/**
+* 通过三个点获取方位角
+* @param coordA
+* @param coordB
+* @param coordC
+*/
+function getAngleOfThreeCoords(coordA, coordB, coordC) {
+	const angle = getAzimuth(coordB, coordA) - getAzimuth(coordB, coordC);
+	return angle < 0 ? angle + Math.PI * 2 : angle;
+}
+/**
+* 判断是否是顺时针
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function isClockWise(coord1, coord2, coord3) {
+	return (coord3[1] - coord1[1]) * (coord2[0] - coord1[0]) > (coord2[1] - coord1[1]) * (coord3[0] - coord1[0]);
+}
+/**
+* 获取立方值
+*/
+function getCubicValue(t, startCoord, coord1, coord2, endCoord) {
+	t = Math.max(Math.min(t, 1), 0);
+	const [tp, t2] = [1 - t, t * t];
+	const t3 = t2 * t;
+	const tp2 = tp * tp;
+	const tp3 = tp2 * tp;
+	const x = tp3 * startCoord[0] + 3 * tp2 * t * coord1[0] + 3 * tp * t2 * coord2[0] + t3 * endCoord[0];
+	const y = tp3 * startCoord[1] + 3 * tp2 * t * coord1[1] + 3 * tp * t2 * coord2[1] + t3 * endCoord[1];
+	return [x, y];
+}
+/**
+* 根据起止点和旋转方向求取第三个点
+* @param startCoord
+* @param endCoord
+* @param angle
+* @param distance
+* @param clockWise
+*/
+function getThirdCoord(startCoord, endCoord, angle, distance$1, clockWise) {
+	const azimuth = getAzimuth(startCoord, endCoord);
+	const alpha = clockWise ? azimuth + angle : azimuth - angle;
+	const dx = distance$1 * Math.cos(alpha);
+	const dy = distance$1 * Math.sin(alpha);
+	return [endCoord[0] + dx, endCoord[1] + dy];
+}
+/**
+* 插值弓形线段点
+* @param center
+* @param radius
+* @param startAngle
+* @param endAngle
+*/
+function getArcCoords(center, radius, startAngle, endAngle) {
+	let [x, y, coords, angleDiff] = [
+		0,
+		0,
+		[],
+		endAngle - startAngle
+	];
+	angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
+	for (let i = 0; i <= 100; i++) {
+		const angle = startAngle + angleDiff * i / 100;
+		x = center[0] + radius * Math.cos(angle);
+		y = center[1] + radius * Math.sin(angle);
+		coords.push([x, y]);
+	}
+	return coords;
+}
+/**
+* getBisectorNormals
+* @param t
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getBisectorNormals(t, coord1, coord2, coord3) {
+	const normal = getNormal(coord1, coord2, coord3);
+	let [bisectorNormalRight, bisectorNormalLeft, dt, x, y] = [
+		[0, 0],
+		[0, 0],
+		0,
+		0,
+		0
+	];
+	const dist = Math.hypot(normal[0], normal[1]);
+	const uX = normal[0] / dist;
+	const uY = normal[1] / dist;
+	const d1 = mathDistance(coord1, coord2);
+	const d2 = mathDistance(coord2, coord3);
+	if (dist > ZERO_TOLERANCE) if (isClockWise(coord1, coord2, coord3)) {
+		dt = t * d1;
+		x = coord2[0] - dt * uY;
+		y = coord2[1] + dt * uX;
+		bisectorNormalRight = [x, y];
+		dt = t * d2;
+		x = coord2[0] + dt * uY;
+		y = coord2[1] - dt * uX;
+		bisectorNormalLeft = [x, y];
+	} else {
+		dt = t * d1;
+		x = coord2[0] + dt * uY;
+		y = coord2[1] - dt * uX;
+		bisectorNormalRight = [x, y];
+		dt = t * d2;
+		x = coord2[0] - dt * uY;
+		y = coord2[1] + dt * uX;
+		bisectorNormalLeft = [x, y];
+	}
+	else {
+		x = coord2[0] + t * (coord1[0] - coord2[0]);
+		y = coord2[1] + t * (coord1[1] - coord2[1]);
+		bisectorNormalRight = [x, y];
+		x = coord2[0] + t * (coord3[0] - coord2[0]);
+		y = coord2[1] + t * (coord3[1] - coord2[1]);
+		bisectorNormalLeft = [x, y];
+	}
+	return [bisectorNormalRight, bisectorNormalLeft];
+}
+/**
+* 获取默认三点的内切圆
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getNormal(coord1, coord2, coord3) {
+	let dX1 = coord1[0] - coord2[0];
+	let dY1 = coord1[1] - coord2[1];
+	const d1 = Math.hypot(dX1, dY1);
+	dX1 /= d1;
+	dY1 /= d1;
+	let dX2 = coord3[0] - coord2[0];
+	let dY2 = coord3[1] - coord2[1];
+	const d2 = Math.hypot(dX2, dY2);
+	dX2 /= d2;
+	dY2 /= d2;
+	const uX = dX1 + dX2;
+	const uY = dY1 + dY2;
+	return [uX, uY];
+}
+/**
+* 贝塞尔曲线
+* @param points
+*/
+function getBezierCoords(points) {
+	if (points.length <= 2) return points;
+	const bezierCoords = [];
+	const n = points.length - 1;
+	for (let t = 0; t <= 1; t += .01) {
+		let [x, y] = [0, 0];
+		for (let index = 0; index <= n; index++) {
+			const factor = getBinomialFactor(n, index);
+			const a = t ** index;
+			const b = (1 - t) ** (n - index);
+			x += factor * a * b * points[index][0];
+			y += factor * a * b * points[index][1];
+		}
+		bezierCoords.push([x, y]);
+	}
+	bezierCoords.push(points[n]);
+	return bezierCoords;
+}
+/**
+* 获取阶乘数据
+* @param n
+*/
+function getFactorial(n) {
+	let result = 1;
+	switch (true) {
+		case n <= 1:
+			result = 1;
+			break;
+		case n === 2:
+			result = 2;
+			break;
+		case n === 3:
+			result = 6;
+			break;
+		case n === 24:
+			result = 24;
+			break;
+		case n === 5:
+			result = 120;
+			break;
+		default:
+			for (let i = 1; i <= n; i++) result *= i;
+			break;
+	}
+	return result;
+}
+/**
+* 获取二项分布
+* @param n
+* @param index
+*/
+function getBinomialFactor(n, index) {
+	return getFactorial(n) / (getFactorial(index) * getFactorial(n - index));
+}
+/**
+* 插值线性点
+* @param points
+*/
+function getQBSplineCoords(points) {
+	if (points.length <= 2) return points;
+	const [n, bSplineCoords] = [2, []];
+	const m = points.length - n - 1;
+	bSplineCoords.push(points[0]);
+	for (let i = 0; i <= m; i++) for (let t = 0; t <= 1; t += .05) {
+		let [x, y] = [0, 0];
+		for (let k = 0; k <= n; k++) {
+			const factor = getQuadricBSplineFactor(k, t);
+			x += factor * points[i + k][0];
+			y += factor * points[i + k][1];
+		}
+		bSplineCoords.push([x, y]);
+	}
+	bSplineCoords.push(points.at(-1));
+	return bSplineCoords;
+}
+/**
+* 得到二次线性因子
+* @param k
+* @param t
+*/
+function getQuadricBSplineFactor(k, t) {
+	let res = 0;
+	if (k === 0) res = (t - 1) ** 2 / 2;
+	else if (k === 1) res = (-2 * t ** 2 + 2 * t + 1) / 2;
+	else if (k === 2) res = t ** 2 / 2;
+	return res;
+}
+
+//#endregion
+//#region geom/arc.ts
+/**
+* 标绘画弓形算法，继承线要素相关方法和属性
+*/
+function arc(coords) {
+	const coordlength = coords.length;
+	if (coordlength <= 2) throw new Error("coords.length must >= 3");
+	else {
+		let [coord1, coord2, coord3, startAngle, endAngle] = [
+			coords[0],
+			coords[1],
+			coords[2],
+			0,
+			0
+		];
+		const center = getCircleCenterOfThreeCoords(coord1, coord2, coord3);
+		const radius = mathDistance(coord1, center);
+		const angle1 = getAzimuth(coord1, center);
+		const angle2 = getAzimuth(coord2, center);
+		if (isClockWise(coord1, coord2, coord3)) {
+			startAngle = angle2;
+			endAngle = angle1;
+		} else {
+			startAngle = angle1;
+			endAngle = angle2;
+		}
+		return getArcCoords(center, radius, startAngle, endAngle);
+	}
+}
+
+//#endregion
+//#region geom/arrowAttackDirection.ts
+/**
+* 尖曲箭头
+*/
+function arrowAttackDirection(coords, options = {}) {
+	const coordLength = coords.length;
+	if (coordLength < 3) throw new Error("coords.length must >= 3");
+	else {
+		let [tailLeft, tailRight] = [coords[0], coords[1]];
+		if (isClockWise(coords[0], coords[1], coords[2])) {
+			tailLeft = coords[1];
+			tailRight = coords[0];
+		}
+		const midTail = mid(tailLeft, tailRight);
+		const boneCoords = [midTail].concat(coords.slice(2));
+		const headCoords = getArrowHeadCoords(boneCoords, {
+			tailLeft,
+			tailRight,
+			...options
+		});
+		if (headCoords && headCoords.length > 4) {
+			const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
+			const tailWidthFactor = mathDistance(tailLeft, tailRight) / getBaseLength(boneCoords);
+			const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, tailWidthFactor);
+			const coordlength = bodyCoords.length;
+			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
+			leftCoords.push(neckLeft);
+			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
+			rightCoords.push(neckRight);
+			leftCoords = getQBSplineCoords(leftCoords);
+			rightCoords = getQBSplineCoords(rightCoords);
+			return leftCoords.concat(headCoords, rightCoords.reverse());
+		} else return [];
+	}
+}
+/**
+* 插值头部点
+*/
+function getArrowHeadCoords(points, options) {
+	const { tailLeft, tailRight, headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, headTailFactor = .8 } = options;
+	let len = getBaseLength(points);
+	let headHeight = len * headHeightFactor;
+	const headCoord = points.at(-1);
+	len = mathDistance(headCoord, points.at(-2));
+	let tailWidth = 0;
+	if (tailLeft && tailRight) tailWidth = mathDistance(tailLeft, tailRight);
+	if (headHeight > tailWidth * headTailFactor) headHeight = tailWidth * headTailFactor;
+	const headWidth = headHeight * headWidthFactor;
+	const neckWidth = headHeight * neckWidthFactor;
+	headHeight = Math.min(headHeight, len);
+	const neckHeight = headHeight * neckHeightFactor;
+	const headEndCoord = getThirdCoord(points.at(-2), headCoord, 0, headHeight, true);
+	const neckEndCoord = getThirdCoord(points.at(-2), headCoord, 0, neckHeight, true);
+	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
+	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
+	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
+	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
+	return [
+		neckLeft,
+		headLeft,
+		headCoord,
+		headRight,
+		neckRight
+	];
+}
+/**
+* 插值面部分数据
+* @param points
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords(points, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(points);
+	const len = getBaseLength(points);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = mathDistance(neckLeft, neckRight);
+	const widthDif = (tailWidth - neckWidth) / 2;
+	let tempLen = 0;
+	const leftBodyCoords = [];
+	const rightBodyCoords = [];
+	for (let i = 1; i < points.length - 1; i++) {
+		const angle = getAngleOfThreeCoords(points[i - 1], points[i], points[i + 1]) / 2;
+		tempLen += mathDistance(points[i - 1], points[i]);
+		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
+		const left = getThirdCoord(points[i - 1], points[i], Math.PI - angle, w, true);
+		const right = getThirdCoord(points[i - 1], points[i], angle, w, false);
+		leftBodyCoords.push(left);
+		rightBodyCoords.push(right);
+	}
+	return leftBodyCoords.concat(rightBodyCoords);
+}
+
+//#endregion
+//#region geom/arrowAttackDirectionTailed.ts
+/**
+* 燕尾尖曲箭头
+*/
+function arrowAttackDirectionTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	const coordLength = coords.length;
+	if (coordLength < 3) throw new Error("coords.length must >= 3");
+	let [tailLeft, tailRight] = [coords[0], coords[1]];
+	if (isClockWise(coords[0], coords[1], coords[2])) {
+		tailLeft = coords[1];
+		tailRight = coords[0];
+	}
+	const midTail = mid(tailLeft, tailRight);
+	const boneCoords = [midTail].concat(coords.slice(2));
+	const headCoords = getArrowHeadCoords(boneCoords, {
+		tailLeft,
+		tailRight,
+		headHeightFactor,
+		headWidthFactor,
+		neckWidthFactor,
+		neckHeightFactor
+	});
+	if (headCoords && headCoords.length > 4) {
+		const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
+		const tailWidth = mathDistance(tailLeft, tailRight);
+		const allLen = getBaseLength(boneCoords);
+		const len = allLen * tailWidthFactor * swallowTailFactor;
+		const swallowTailCoord = getThirdCoord(boneCoords[1], boneCoords[0], 0, len, true);
+		const factor = tailWidth / allLen;
+		const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, factor);
+		const coordlength = bodyCoords.length;
+		let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
+		leftCoords.push(neckLeft);
+		let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
+		rightCoords.push(neckRight);
+		leftCoords = getQBSplineCoords(leftCoords);
+		rightCoords = getQBSplineCoords(rightCoords);
+		return leftCoords.concat(headCoords, rightCoords.reverse(), [swallowTailCoord, leftCoords[0]]);
+	} else return [];
+}
+
+//#endregion
+//#region geom/arrowClamped.ts
 /**
-* 内置的线段标绘方案
+* 钳击箭头 有效点位长度3,4,5
 */
-const schemePolyline = new PlotScheme({
-	type: "polyline",
+function arrowClamped(coords) {
+	const options = {
+		headHeightFactor: .25,
+		headWidthFactor: .3,
+		neckHeightFactor: .85,
+		neckWidthFactor: .15
+	};
+	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
+	const [coord1, coord2, coord3] = coords;
+	let tempCoord4, connCoord;
+	if (coords.length === 3) {
+		tempCoord4 = getTempCoord4(coord1, coord2, coord3);
+		connCoord = mid(coord1, coord2);
+	} else if (coords.length === 4) {
+		tempCoord4 = coords[3];
+		connCoord = mid(coord1, coord2);
+	} else {
+		tempCoord4 = coords[3];
+		connCoord = coords[4];
+	}
+	let leftArrowCoords;
+	let rightArrowCoords;
+	if (isClockWise(coord1, coord2, coord3)) {
+		leftArrowCoords = getArrowCoords(coord1, connCoord, tempCoord4, false, options);
+		rightArrowCoords = getArrowCoords(connCoord, coord2, coord3, true, options);
+	} else {
+		leftArrowCoords = getArrowCoords(coord2, connCoord, coord3, false, options);
+		rightArrowCoords = getArrowCoords(connCoord, coord1, tempCoord4, true, options);
+	}
+	const m = leftArrowCoords.length;
+	const t = (m - 5) / 2;
+	const llBodyCoords = leftArrowCoords.slice(0, t);
+	const lArrowCoords = leftArrowCoords.slice(t, t + 5);
+	let lrBodyCoords = leftArrowCoords.slice(t + 5, m);
+	let rlBodyCoords = rightArrowCoords.slice(0, t);
+	const rArrowCoords = rightArrowCoords.slice(t, t + 5);
+	const rrBodyCoords = rightArrowCoords.slice(t + 5, m);
+	rlBodyCoords = getBezierCoords(rlBodyCoords);
+	const bodyCoords = getBezierCoords(rrBodyCoords.concat(llBodyCoords.slice(1)));
+	lrBodyCoords = getBezierCoords(lrBodyCoords);
+	return rlBodyCoords.concat(rArrowCoords, bodyCoords, lArrowCoords, lrBodyCoords);
+}
+/**
+* 插值箭形上的点
+* @param coord1  - Wgs84坐标
+* @param coord2 - Wgs84坐标
+* @param coord3 - Wgs84坐标
+* @param clockWise - 是否顺时针
+*/
+function getArrowCoords(coord1, coord2, coord3, clockWise, options) {
+	const midCoord = mid(coord1, coord2);
+	const len = mathDistance(midCoord, coord3);
+	let midCoord1 = getThirdCoord(coord3, midCoord, 0, len * .3, true);
+	let midCoord2 = getThirdCoord(coord3, midCoord, 0, len * .5, true);
+	midCoord1 = getThirdCoord(midCoord, midCoord1, HALF_PI, len / 5, clockWise);
+	midCoord2 = getThirdCoord(midCoord, midCoord2, HALF_PI, len / 4, clockWise);
+	const coords = [
+		midCoord,
+		midCoord1,
+		midCoord2,
+		coord3
+	];
+	const arrowCoords = getArrowHeadCoords$1(coords, options);
+	if (arrowCoords && Array.isArray(arrowCoords) && arrowCoords.length > 0) {
+		const [neckLeftCoord, neckRightCoord] = [arrowCoords[0], arrowCoords[4]];
+		const tailWidthFactor = mathDistance(coord1, coord2) / getBaseLength(coords) / 2;
+		const bodyCoords = getArrowBodyCoords$1(coords, neckLeftCoord, neckRightCoord, tailWidthFactor);
+		const n = bodyCoords.length;
+		let lCoords = bodyCoords.slice(0, n / 2);
+		let rCoords = bodyCoords.slice(n / 2, n);
+		lCoords.push(neckLeftCoord);
+		rCoords.push(neckRightCoord);
+		lCoords = lCoords.reverse();
+		lCoords.push(coord2);
+		rCoords = rCoords.reverse();
+		rCoords.push(coord1);
+		return lCoords.reverse().concat(arrowCoords, rCoords);
+	} else throw new Error("插值出错");
+}
+/**
+* 插值头部点
+* @param coords
+*/
+function getArrowHeadCoords$1(coords, options) {
+	const { headHeightFactor, headWidthFactor, neckWidthFactor, neckHeightFactor } = options;
+	const len = getBaseLength(coords);
+	const headHeight = len * headHeightFactor;
+	const headCoord = coords.at(-1);
+	const headWidth = headHeight * headWidthFactor;
+	const neckWidth = headHeight * neckWidthFactor;
+	const neckHeight = headHeight * neckHeightFactor;
+	const headEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, headHeight, true);
+	const neckEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, neckHeight, true);
+	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
+	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
+	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
+	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
+	return [
+		neckLeft,
+		headLeft,
+		headCoord,
+		headRight,
+		neckRight
+	];
+}
+/**
+* 插值面部分数据
+* @param coords
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords$1(coords, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(coords);
+	const len = getBaseLength(coords);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = mathDistance(neckLeft, neckRight);
+	const widthDif = (tailWidth - neckWidth) / 2;
+	let tempLen = 0;
+	const leftBodyCoords = [];
+	const rightBodyCoords = [];
+	for (let i = 1; i < coords.length - 1; i++) {
+		const angle = getAngleOfThreeCoords(coords[i - 1], coords[i], coords[i + 1]) / 2;
+		tempLen += mathDistance(coords[i - 1], coords[i]);
+		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
+		const left = getThirdCoord(coords[i - 1], coords[i], Math.PI - angle, w, true);
+		const right = getThirdCoord(coords[i - 1], coords[i], angle, w, false);
+		leftBodyCoords.push(left);
+		rightBodyCoords.push(right);
+	}
+	return leftBodyCoords.concat(rightBodyCoords);
+}
+/**
+* 获取对称点
+* @param lineCoord1
+* @param lineCoord2
+* @param coord
+*/
+function getTempCoord4(lineCoord1, lineCoord2, coord) {
+	const midCoord = mid(lineCoord1, lineCoord2);
+	const len = mathDistance(midCoord, coord);
+	const angle = getAngleOfThreeCoords(lineCoord1, midCoord, coord);
+	if (angle < HALF_PI) {
+		const distance1 = len * Math.sin(angle);
+		const distance2 = len * Math.cos(angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
+	} else if (angle >= HALF_PI && angle < Math.PI) {
+		const distance1 = len * Math.sin(Math.PI - angle);
+		const distance2 = len * Math.cos(Math.PI - angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
+	} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
+		const distance1 = len * Math.sin(angle - Math.PI);
+		const distance2 = len * Math.cos(angle - Math.PI);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
+	} else {
+		const distance1 = len * Math.sin(Math.PI * 2 - angle);
+		const distance2 = len * Math.cos(Math.PI * 2 - angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
+	}
+}
+
+//#endregion
+//#region geom/arrowStraightSharp.ts
+/**
+* 尖箭头
+*
+*/
+function arrowStraightSharp(coords, options = {}) {
+	const { tailWidthFactor = .1, neckWidthFactor = .2, headWidthFactor = .25, headAngle = Math.PI / 8.5, neckAngle = Math.PI / 13 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const [coord1, coord2] = [coords[0], coords[1]];
+	const len = getBaseLength(coords);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = len * neckWidthFactor;
+	const headWidth = len * headWidthFactor;
+	const tailLeft = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, true);
+	const tailRight = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, false);
+	const headLeft = getThirdCoord(coord1, coord2, headAngle, headWidth, false);
+	const headRight = getThirdCoord(coord1, coord2, headAngle, headWidth, true);
+	const neckLeft = getThirdCoord(coord1, coord2, neckAngle, neckWidth, false);
+	const neckRight = getThirdCoord(coord1, coord2, neckAngle, neckWidth, true);
+	const pList = [
+		tailLeft,
+		neckLeft,
+		headLeft,
+		coord2,
+		headRight,
+		neckRight,
+		tailRight
+	];
+	return pList;
+}
+
+//#endregion
+//#region geom/arrowStraight.ts
+/**
+* 直箭头
+*/
+function arrowStraight(coords) {
+	const tailWidthFactor = .05;
+	const neckWidthFactor = .1;
+	const headWidthFactor = .15;
+	const headAngle = Math.PI / 4;
+	const neckAngle = Math.PI * .17741;
+	return arrowStraightSharp(coords, {
+		tailWidthFactor,
+		neckWidthFactor,
+		headWidthFactor,
+		headAngle,
+		neckAngle
+	});
+}
+
+//#endregion
+//#region geom/arrowUnitCombatOperation.ts
+/**
+* 分队战斗行动（尖曲箭头）
+*/
+function arrowUnitCombatOperation(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	else {
+		const allLen = getBaseLength(coords);
+		const tailWidth = allLen * tailWidthFactor;
+		const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
+		const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
+		const headCoords = getArrowHeadCoords(coords, {
+			tailLeft,
+			tailRight,
+			headHeightFactor,
+			headWidthFactor,
+			neckWidthFactor,
+			neckHeightFactor
+		});
+		if (headCoords && headCoords.length > 4) {
+			const neckLeft = headCoords[0];
+			const neckRight = headCoords[4];
+			const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
+			const coordlength$1 = bodyCoords.length;
+			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength$1 / 2));
+			leftCoords.push(neckLeft);
+			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
+			rightCoords.push(neckRight);
+			leftCoords = getQBSplineCoords(leftCoords);
+			rightCoords = getQBSplineCoords(rightCoords);
+			return leftCoords.concat(headCoords, rightCoords.reverse());
+		} else return [];
+	}
+}
+
+//#endregion
+//#region geom/arrowUnitCombatOperationTailed.ts
+/**
+* 燕尾尖箭头
+*/
+function arrowUnitCombatOperationTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const allLen = getBaseLength(coords);
+	const tailWidth = allLen * tailWidthFactor;
+	const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
+	const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
+	const len = tailWidth * swallowTailFactor;
+	const swallowTailCoord = getThirdCoord(coords[1], coords[0], 0, len, true);
+	const tailCoords = [
+		tailLeft,
+		swallowTailCoord,
+		tailRight
+	];
+	const headCoords = getArrowHeadCoords(coords, {
+		tailLeft: tailCoords[0],
+		tailRight: tailCoords[2],
+		headHeightFactor,
+		headWidthFactor,
+		neckWidthFactor,
+		neckHeightFactor
+	});
+	if (headCoords && headCoords.length > 4) {
+		const neckLeft = headCoords[0];
+		const neckRight = headCoords[4];
+		const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
+		const coordlength$1 = bodyCoords.length;
+		let leftCoords = [tailCoords[0]].concat(bodyCoords.slice(0, coordlength$1 / 2));
+		leftCoords.push(neckLeft);
+		let rightCoords = [tailCoords[2]].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
+		rightCoords.push(neckRight);
+		leftCoords = getQBSplineCoords(leftCoords);
+		rightCoords = getQBSplineCoords(rightCoords);
+		return leftCoords.concat(headCoords, rightCoords.reverse(), [tailCoords[1], leftCoords[0]]);
+	}
+	return [];
+}
+
+//#endregion
+//#region geom/assemblingPlace.ts
+/**
+* 集结地
+*
+*/
+function assemblingPlace(coords) {
+	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
+	const t = .4;
+	const midCoord = mid(coords[0], coords[2]);
+	coords.push(midCoord, coords[0], coords[1]);
+	let normals = [];
+	const pList = [];
+	for (let i = 0; i < coords.length - 2; i++) {
+		const coord1 = coords[i];
+		const coord2 = coords[i + 1];
+		const coord3 = coords[i + 2];
+		const normalCoords = getBisectorNormals(t, coord1, coord2, coord3);
+		normals = normals.concat(normalCoords);
+	}
+	const count = normals.length;
+	normals = [normals[count - 1]].concat(normals.slice(0, count - 1));
+	for (let i = 0; i < coords.length - 2; i++) {
+		const coord1 = coords[i];
+		const coord2 = coords[i + 1];
+		pList.push(coord1);
+		for (let t$1 = 0; t$1 <= FITTING_COUNT; t$1++) {
+			const coord = getCubicValue(t$1 / FITTING_COUNT, coord1, normals[i * 2], normals[i * 2 + 1], coord2);
+			pList.push(coord);
+		}
+		pList.push(coord2);
+	}
+	return pList;
+}
+
+//#endregion
+//#region geom/flagCurve.ts
+/**
+* 曲线旗标
+*/
+function flagCurve(coords) {
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	return calculatePonits(coords);
+}
+/**
+* 插值点数据
+* @param coords
+*/
+function calculatePonits(coords) {
+	let components = [];
+	if (coords.length > 1) {
+		const startCoord = coords[0];
+		const endCoord = coords.at(-1);
+		const coord1 = startCoord;
+		const coord2 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
+		const coord3 = [(startCoord[0] + endCoord[0]) / 2, startCoord[1]];
+		const coord4 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], -(endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
+		const coord5 = [endCoord[0], startCoord[1]];
+		const coord6 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+		const coord7 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 3 / 8 + startCoord[1]];
+		const coord8 = [(startCoord[0] + endCoord[0]) / 2, (startCoord[1] + endCoord[1]) / 2];
+		const coord9 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 5 / 8 + startCoord[1]];
+		const coord10 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+		const coord11 = [startCoord[0], endCoord[1]];
+		const curve1 = getBezierCoords([
+			coord1,
+			coord2,
+			coord3,
+			coord4,
+			coord5
+		]);
+		const curve2 = getBezierCoords([
+			coord6,
+			coord7,
+			coord8,
+			coord9,
+			coord10
+		]);
+		components = curve1.concat(curve2);
+		components.push(coord11);
+	}
+	return components;
+}
+
+//#endregion
+//#region geom/flagRect.ts
+/**
+* 直角旗标（使用两个控制点直接创建直角旗标）
+*/
+function flagRect(coords) {
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const [startCoord, endCoord] = coords;
+	const coord1 = [endCoord[0], startCoord[1]];
+	const coord2 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord3 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord4 = [startCoord[0], endCoord[1]];
+	return [
+		startCoord,
+		coord1,
+		coord2,
+		coord3,
+		coord4
+	];
+}
+
+//#endregion
+//#region geom/flagTriangle.ts
+/**
+* 三角旗标（使用两个控制点直接创建三角旗标）
+*/
+function flagTriangle(coords) {
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const [startCoord, endCoord] = coords;
+	const coord1 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord2 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord3 = [startCoord[0], endCoord[1]];
+	return [
+		startCoord,
+		coord1,
+		coord2,
+		coord3
+	];
+}
+
+//#endregion
+//#region scheme/PolygonArc.ts
+const PlotSchemePolygonArc = new PlotScheme({
+	type: "PolygonArc",
+	complete: (packable) => packable.positions.length >= 3,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new cesium.Entity({ polygon: {} })] };
+	},
+	render(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 positions = arc(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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
+	],
+	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 positions = arrowAttackDirection(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#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 positions = arrowAttackDirectionTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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 positions = arrowClamped(coords);
+			const hierarchy = new cesium.PolygonHierarchy(positions.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 positions = arrowStraight(coords);
+			const hierarchy = new cesium.PolygonHierarchy(positions.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 positions = arrowStraightSharp(coords);
+			const hierarchy = new cesium.PolygonHierarchy(positions.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,
-		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 < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arrowUnitCombatOperation(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
 		return { entities: [entity] };
 	}
 });
 
 //#endregion
-//#region scheme/rectangle.ts
-/**
-* 内置的多边形标绘方案
-*/
-const schemeRectangle = new PlotScheme({
-	type: "rectangle",
+//#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 positions = arrowUnitCombatOperationTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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;
+		}
+		const positions = assemblingPlace(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagCurve.ts
+const PlotSchemePolygonFlagCurve = new PlotScheme({
+	type: "PolygonFlagCurve",
 	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;
+		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 positions = flagCurve(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagRect.ts
+const PlotSchemePolygonFlagRect = new PlotScheme({
+	type: "PolygonFlagRect",
+	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;
+		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 positions = flagRect(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagTriangle.ts
+const PlotSchemePolygonFlagTriangle = new PlotScheme({
+	type: "PolygonFlagTriangle",
+	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;
+		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 positions = flagTriangle(coords).map((item) => (0, vesium.toCartesian3)(item));
+		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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,
-		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 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 cartesians = features[0].geometry.coordinates[0].map((item) => (0, vesium.toCartesian3)(item)).filter((e) => !!e);
+		const hierarchy = new cesium.PolygonHierarchy(cartesians);
+		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] };
 	}
 });
@@ -1505,6 +3029,29 @@ 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.PlotSchemePolygonFlagCurve = PlotSchemePolygonFlagCurve;
+exports.PlotSchemePolygonFlagRect = PlotSchemePolygonFlagRect;
+exports.PlotSchemePolygonFlagTriangle = PlotSchemePolygonFlagTriangle;
+exports.PlotSchemePolygonSmooth = PlotSchemePolygonSmooth;
+exports.PlotSchemePolyline = PlotSchemePolyline;
+exports.PlotSchemePolylineCurve = PlotSchemePolylineCurve;
+exports.PlotSchemeRectangle = PlotSchemeRectangle;
 exports.PlotSkeletonEntity = PlotSkeletonEntity;
 exports.SampledPlotProperty = SampledPlotProperty;
 exports.SampledPlotStrategy = SampledPlotStrategy;
@@ -1512,12 +3059,8 @@ exports.control = control;
 exports.interval = interval;
 exports.intervalNonclosed = intervalNonclosed;
 exports.moved = moved;
-exports.schemeBillboard = schemeBillboard;
-exports.schemeLabel = schemeLabel;
 exports.schemeMeasureArea = schemeMeasureArea;
-exports.schemePolygon = schemePolygon;
-exports.schemePolyline = schemePolyline;
-exports.schemeRectangle = schemeRectangle;
+exports.schemeMeasureDistance = schemeMeasureDistance;
 exports.usePlot = usePlot;
-})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue);
+})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue, turf);
 //# sourceMappingURL=index.iife.js.map