@vesium/geometry 1.0.1-beta.54

package/dist/index.cjs

@@ -0,0 +1,1278 @@
+
+//#region src/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 = 0;
+	if (points && Array.isArray(points) && points.length > 0) points.forEach((item, index) => {
+		if (index < points.length - 1) distance += mathDistance(item, points[index + 1]);
+	});
+	return distance;
+}
+/**
+* 获取基础长度
+* @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];
+	return getIntersectCoord(coordA, coordB, coordC, [coordC[0] - coord1[1] + coord3[1], coordC[1] + coord1[0] - coord3[0]]);
+}
+/**
+* 获取交集的点
+* @param coordA
+* @param coordB
+* @param coordC
+* @param coordD
+*/
+function getIntersectCoord(coordA, coordB, coordC, coordD) {
+	if (coordA[1] === coordB[1]) return [(coordD[0] - coordC[0]) / (coordD[1] - coordC[1]) * (coordA[1] - coordC[1]) + coordC[0], coordA[1]];
+	if (coordC[1] === coordD[1]) return [(coordB[0] - coordA[0]) / (coordB[1] - coordA[1]) * (coordC[1] - coordA[1]) + coordA[0], coordC[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);
+	return [e * y - e * coordA[1] + coordA[0], 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]);
+}
+/**
+* 获取线上的点
+* @param t
+* @param startCoord
+* @param endCoord
+*/
+function getCoordOnLine(t, startCoord, endCoord) {
+	return [startCoord[0] + t * (endCoord[0] - startCoord[0]), startCoord[1] + t * (endCoord[1] - startCoord[1])];
+}
+/**
+* 获取立方值
+*/
+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;
+	return [tp3 * startCoord[0] + 3 * tp2 * t * coord1[0] + 3 * tp * t2 * coord2[0] + t3 * endCoord[0], tp3 * startCoord[1] + 3 * tp2 * t * coord1[1] + 3 * tp * t2 * coord2[1] + t3 * endCoord[1]];
+}
+/**
+* 根据起止点和旋转方向求取第三个点
+* @param startCoord
+* @param endCoord
+* @param angle
+* @param distance
+* @param clockWise
+*/
+function getThirdCoord(startCoord, endCoord, angle, distance, clockWise) {
+	const azimuth = getAzimuth(startCoord, endCoord);
+	const alpha = clockWise ? azimuth + angle : azimuth - angle;
+	const dx = distance * Math.cos(alpha);
+	const dy = distance * 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;
+	return [dX1 + dX2, dY1 + dY2];
+}
+/**
+* 获取左边控制点
+* @param controlCoords
+* @param t
+*/
+function getLeftMostControlCoord(controlCoords, t) {
+	let [coord1, coord2, coord3, controlX, controlY] = [
+		controlCoords[0],
+		controlCoords[1],
+		controlCoords[2],
+		0,
+		0
+	];
+	const normalRight = getBisectorNormals(0, coord1, coord2, coord3)[0];
+	const normal = getNormal(coord1, coord2, coord3);
+	if (Math.hypot(normal[0], normal[1]) > ZERO_TOLERANCE) {
+		const midCoord = mid(coord1, coord2);
+		const pX = coord1[0] - midCoord[0];
+		const pY = coord1[1] - midCoord[1];
+		const n = 2 / mathDistance(coord1, coord2);
+		const nX = -n * pY;
+		const nY = n * pX;
+		const a11 = nX * nX - nY * nY;
+		const a12 = 2 * nX * nY;
+		const a22 = nY * nY - nX * nX;
+		const dX = normalRight[0] - midCoord[0];
+		const dY = normalRight[1] - midCoord[1];
+		controlX = midCoord[0] + a11 * dX + a12 * dY;
+		controlY = midCoord[1] + a12 * dX + a22 * dY;
+	} else {
+		controlX = coord1[0] + t * (coord2[0] - coord1[0]);
+		controlY = coord1[1] + t * (coord2[1] - coord1[1]);
+	}
+	return [controlX, controlY];
+}
+/**
+* 获取右边控制点
+* @param controlCoords
+* @param t
+*/
+function getRightMostControlCoord(controlCoords, t) {
+	const coordlength = controlCoords.length;
+	const coord1 = controlCoords[coordlength - 3];
+	const coord2 = controlCoords[coordlength - 2];
+	const coord3 = controlCoords[coordlength - 1];
+	const normalLeft = getBisectorNormals(0, coord1, coord2, coord3)[1];
+	const normal = getNormal(coord1, coord2, coord3);
+	const dist = Math.hypot(normal[0], normal[1]);
+	let [controlX, controlY] = [0, 0];
+	if (dist > ZERO_TOLERANCE) {
+		const midCoord = mid(coord2, coord3);
+		const pX = coord3[0] - midCoord[0];
+		const pY = coord3[1] - midCoord[1];
+		const n = 2 / mathDistance(coord2, coord3);
+		const nX = -n * pY;
+		const nY = n * pX;
+		const a11 = nX * nX - nY * nY;
+		const a12 = 2 * nX * nY;
+		const a22 = nY * nY - nX * nX;
+		const dX = normalLeft[0] - midCoord[0];
+		const dY = normalLeft[1] - midCoord[1];
+		controlX = midCoord[0] + a11 * dX + a12 * dY;
+		controlY = midCoord[1] + a12 * dX + a22 * dY;
+	} else {
+		controlX = coord3[0] + t * (coord2[0] - coord3[0]);
+		controlY = coord3[1] + t * (coord2[1] - coord3[1]);
+	}
+	return [controlX, controlY];
+}
+/**
+* 插值曲线点
+* @param t
+* @param controlCoords
+*/
+function getCurveCoords(t, controlCoords) {
+	let normals = [getLeftMostControlCoord(controlCoords, t)];
+	const coords = [];
+	let coord1, coord2, coord3;
+	for (let i = 0; i < controlCoords.length - 2; i++) {
+		[coord1, coord2, coord3] = [
+			controlCoords[i],
+			controlCoords[i + 1],
+			controlCoords[i + 2]
+		];
+		const normalCoords = getBisectorNormals(t, coord1, coord2, coord3);
+		normals = normals.concat(normalCoords);
+	}
+	const rightControl = getRightMostControlCoord(controlCoords, t);
+	if (rightControl) normals.push(rightControl);
+	for (let i = 0; i < controlCoords.length - 1; i++) {
+		coord1 = controlCoords[i];
+		coord2 = controlCoords[i + 1];
+		coords.push(coord1);
+		for (let j = 0; j < FITTING_COUNT; j++) {
+			const coord = getCubicValue(j / FITTING_COUNT, coord1, normals[i * 2], normals[i * 2 + 1], coord2);
+			coords.push(coord);
+		}
+		coords.push(coord2);
+	}
+	return coords;
+}
+/**
+* 贝塞尔曲线
+* @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 src/arc.ts
+/**
+* 标绘画弓形算法，继承线要素相关方法和属性
+*/
+function arc(coords) {
+	if (coords.length <= 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 src/arrowAttackDirection.ts
+/**
+* 尖曲箭头
+*/
+function arrowAttackDirection(coords, options = {}) {
+	if (coords.length < 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 boneCoords = [mid(tailLeft, tailRight)].concat(coords.slice(2));
+		const headCoords = getArrowHeadCoords(boneCoords, {
+			tailLeft,
+			tailRight,
+			...options
+		});
+		if (headCoords && headCoords.length > 4) {
+			const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
+			const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, mathDistance(tailLeft, tailRight) / getBaseLength(boneCoords));
+			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 [];
+	}
+}
+/**
+* 插值箭形上的点
+* @param coord1
+* @param coord2
+* @param coord3
+* @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 points = [
+		midCoord,
+		midCoord1,
+		midCoord2,
+		coord3
+	];
+	const arrowCoords = getArrowHeadCoords(points, options);
+	if (arrowCoords && Array.isArray(arrowCoords) && arrowCoords.length > 0) {
+		const [neckLeftCoord, neckRightCoord] = [arrowCoords[0], arrowCoords[4]];
+		const bodyCoords = getArrowBodyCoords(points, neckLeftCoord, neckRightCoord, mathDistance(coord1, coord2) / getBaseLength(points) / 2);
+		if (bodyCoords) {
+			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("插值出错");
+}
+/**
+* 插值头部点
+*/
+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);
+	return [
+		getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false),
+		headLeft,
+		headCoord,
+		headRight,
+		getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true)
+	];
+}
+/**
+* 插值面部分数据
+* @param points
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords(points, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(points);
+	const tailWidth = getBaseLength(points) * tailWidthFactor;
+	const widthDif = (tailWidth - mathDistance(neckLeft, neckRight)) / 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);
+}
+/**
+* 获取对称点
+* @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);
+	let symCoord;
+	let distance1 = 0;
+	let distance2 = 0;
+	let midCoord2;
+	if (angle < HALF_PI) {
+		distance1 = len * Math.sin(angle);
+		distance2 = len * Math.cos(angle);
+		midCoord2 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		symCoord = getThirdCoord(midCoord, midCoord2, HALF_PI, distance2, true);
+	} else if (angle >= HALF_PI && angle < Math.PI) {
+		distance1 = len * Math.sin(Math.PI - angle);
+		distance2 = len * Math.cos(Math.PI - angle);
+		midCoord2 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		symCoord = getThirdCoord(midCoord, midCoord2, HALF_PI, distance2, false);
+	} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
+		distance1 = len * Math.sin(angle - Math.PI);
+		distance2 = len * Math.cos(angle - Math.PI);
+		midCoord2 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		symCoord = getThirdCoord(midCoord, midCoord2, HALF_PI, distance2, true);
+	} else {
+		distance1 = len * Math.sin(Math.PI * 2 - angle);
+		distance2 = len * Math.cos(Math.PI * 2 - angle);
+		midCoord2 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		symCoord = getThirdCoord(midCoord, midCoord2, HALF_PI, distance2, false);
+	}
+	return symCoord;
+}
+
+//#endregion
+//#region src/arrowAttackDirectionTailed.ts
+/**
+* 燕尾尖曲箭头
+*/
+function arrowAttackDirectionTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	if (coords.length < 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 boneCoords = [mid(tailLeft, tailRight)].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 bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, tailWidth / allLen);
+		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 src/arrowClamped.ts
+/**
+* 钳击箭头 有效点位长度3,4,5
+*/
+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$1(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$1(coord1, connCoord, tempCoord4, false, options);
+		rightArrowCoords = getArrowCoords$1(connCoord, coord2, coord3, true, options);
+	} else {
+		leftArrowCoords = getArrowCoords$1(coord2, connCoord, coord3, false, options);
+		rightArrowCoords = getArrowCoords$1(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$1(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 bodyCoords = getArrowBodyCoords$1(coords, neckLeftCoord, neckRightCoord, mathDistance(coord1, coord2) / getBaseLength(coords) / 2);
+		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 headHeight = getBaseLength(coords) * 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);
+	return [
+		getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false),
+		headLeft,
+		headCoord,
+		headRight,
+		getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true)
+	];
+}
+/**
+* 插值面部分数据
+* @param coords
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords$1(coords, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(coords);
+	const tailWidth = getBaseLength(coords) * tailWidthFactor;
+	const widthDif = (tailWidth - mathDistance(neckLeft, neckRight)) / 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$1(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);
+		return getThirdCoord(midCoord, getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false), 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);
+		return getThirdCoord(midCoord, getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false), 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);
+		return getThirdCoord(midCoord, getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true), HALF_PI, distance2, true);
+	} else {
+		const distance1 = len * Math.sin(Math.PI * 2 - angle);
+		const distance2 = len * Math.cos(Math.PI * 2 - angle);
+		return getThirdCoord(midCoord, getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true), HALF_PI, distance2, false);
+	}
+}
+
+//#endregion
+//#region src/arrowStraightSharp.ts
+/**
+* 尖箭头
+*
+*/
+function arrowStraightSharp(coords, options = {}) {
+	const { tailWidthFactor = .1, neckWidthFactor = .2, headWidthFactor = .25, headAngle = Math.PI / 8.5, neckAngle = Math.PI / 13 } = options;
+	if (coords.length < 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);
+	return [
+		tailLeft,
+		getThirdCoord(coord1, coord2, neckAngle, neckWidth, false),
+		headLeft,
+		coord2,
+		headRight,
+		getThirdCoord(coord1, coord2, neckAngle, neckWidth, true),
+		tailRight
+	];
+}
+
+//#endregion
+//#region src/arrowStraight.ts
+/**
+* 直箭头
+*/
+function arrowStraight(coords) {
+	return arrowStraightSharp(coords, {
+		tailWidthFactor: .05,
+		neckWidthFactor: .1,
+		headWidthFactor: .15,
+		headAngle: Math.PI / 4,
+		neckAngle: Math.PI * .17741
+	});
+}
+
+//#endregion
+//#region src/arrowStraightFine.ts
+/**
+* 细直箭头
+*/
+function arrowStraightFine(coords) {
+	const maxArrowLength = 3e6;
+	const arrowLengthScale = 5;
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const [coord1, coord2] = [coords[0], coords[1]];
+	let len = mathDistance(coord1, coord2) / arrowLengthScale;
+	len = Math.min(len, maxArrowLength);
+	return [
+		coord1,
+		coord2,
+		getThirdCoord(coord1, coord2, Math.PI / 6, len, false),
+		coord2,
+		getThirdCoord(coord1, coord2, Math.PI / 6, len, true)
+	];
+}
+
+//#endregion
+//#region src/arrowUnitCombatOperation.ts
+/**
+* 分队战斗行动（尖曲箭头）
+*/
+function arrowUnitCombatOperation(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1 } = options;
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	else {
+		const tailWidth = getBaseLength(coords) * 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 = 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 [];
+	}
+}
+
+//#endregion
+//#region src/arrowUnitCombatOperationTailed.ts
+/**
+* 燕尾尖箭头
+*/
+function arrowUnitCombatOperationTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const tailWidth = getBaseLength(coords) * 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 tailCoords = [
+		tailLeft,
+		getThirdCoord(coords[1], coords[0], 0, len, true),
+		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 = bodyCoords.length;
+		let leftCoords = [tailCoords[0]].concat(bodyCoords.slice(0, coordlength / 2));
+		leftCoords.push(neckLeft);
+		let rightCoords = [tailCoords[2]].concat(bodyCoords.slice(coordlength / 2, coordlength));
+		rightCoords.push(neckRight);
+		leftCoords = getQBSplineCoords(leftCoords);
+		rightCoords = getQBSplineCoords(rightCoords);
+		return leftCoords.concat(headCoords, rightCoords.reverse(), [tailCoords[1], leftCoords[0]]);
+	}
+	return [];
+}
+
+//#endregion
+//#region src/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 src/circle.ts
+/**
+* 标绘画圆算法，继承面要素相关方法和属性
+*/
+function circle(coords) {
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const center = coords[0];
+	const radius = mathDistance(center, coords[1]);
+	let [x, y, angle] = [
+		0,
+		0,
+		0
+	];
+	const _coords = [];
+	for (let i = 0; i <= 100; i++) {
+		angle = Math.PI * 2 * i / 100;
+		x = center[0] + radius * Math.cos(angle);
+		y = center[1] + radius * Math.sin(angle);
+		_coords.push([x, y]);
+	}
+	return _coords;
+}
+
+//#endregion
+//#region src/closedCurve.ts
+/**
+* 闭合曲面
+*
+*/
+function closedCurve(coords) {
+	const t = .3;
+	if (coords.length < 3) throw new Error("coords.length must >= 3");
+	else {
+		coords.push(coords[0], coords[1]);
+		let normals = [];
+		const pList = [];
+		for (let i = 0; i < coords.length - 2; i++) {
+			const normalCoords = getBisectorNormals(t, coords[i], coords[i + 1], coords[i + 2]);
+			normals = normals.concat(normalCoords);
+		}
+		const coordlength = normals.length;
+		normals = [normals[coordlength - 1]].concat(normals.slice(0, coordlength - 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 src/curve.ts
+/**
+* 标绘曲线算法
+*/
+function curve(coords) {
+	const t = .3;
+	if (coords.length < 3) throw new Error("coords.length must >= 2");
+	else return getCurveCoords(t, coords);
+}
+
+//#endregion
+//#region src/ellipse.ts
+/**
+* 标绘画椭圆算法，继承面要素相关方法和属性
+*/
+function ellipse(coords) {
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const [coord1, coord2] = [coords[0], coords[1]];
+	const center = mid(coord1, coord2);
+	const majorRadius = Math.abs((coord1[0] - coord2[0]) / 2);
+	const minorRadius = Math.abs((coord1[1] - coord2[1]) / 2);
+	let [x, y, angle] = [
+		0,
+		0,
+		0
+	];
+	const _coords = [];
+	for (let i = 0; i <= FITTING_COUNT; i++) {
+		angle = Math.PI * 2 * i / FITTING_COUNT;
+		x = center[0] + majorRadius * Math.cos(angle);
+		y = center[1] + minorRadius * Math.sin(angle);
+		coords.push([x, y]);
+	}
+	return _coords;
+}
+
+//#endregion
+//#region src/lune.ts
+/**
+* 弓形
+*/
+function lune(coords) {
+	coords = [...coords];
+	const coordLength = coords.length;
+	if (coordLength < 2) throw new Error("coords.length must >= 2");
+	if (coordLength === 2) {
+		const midCoord = mid(coords[0], coords[1]);
+		const d = mathDistance(coords[0], midCoord);
+		const coord = getThirdCoord(coords[0], midCoord, HALF_PI, d);
+		coords.push(coord);
+	}
+	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;
+	}
+	coords = getArcCoords(center, radius, startAngle, endAngle);
+	coords.push(coords[0]);
+	return coords;
+}
+
+//#endregion
+//#region src/rectAngle.ts
+/**
+* 规则矩形
+*
+*/
+function rectAngle(coords) {
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const [startCoord, endCoord] = coords;
+	return [
+		startCoord,
+		[startCoord[0], endCoord[1]],
+		endCoord,
+		[endCoord[0], startCoord[1]],
+		startCoord
+	];
+}
+
+//#endregion
+//#region src/rectinclined1.ts
+/**
+* 斜矩形1
+*
+*/
+function rectinclined1(coords) {
+	if (coords.length < 3) throw new Error("coords.length must >= 3");
+	else {
+		const [coord1, coord2, mouse] = [
+			coords[0],
+			coords[1],
+			coords[2]
+		];
+		const d = calculatePerpendicularDistance(coord1, coord2, mouse);
+		const coord3 = calculatePerpendicularCoord(coord1, coord2, calculatePositionRelativeToLine(coord1, coord2, mouse) * d);
+		const coord4 = calculateFourthCoord(coord1, coord2, coord3);
+		const pList = [];
+		pList.push(coord1, coord2, coord3, coord4, coord1);
+		return pList;
+	}
+}
+/**
+* 已知p1，p2，p3三点，计算p3到p1p2的垂直距离
+* @param {*} p1
+* @param {*} p2
+* @param {*} p3
+*/
+function calculatePerpendicularDistance(p1, p2, p3) {
+	const vx = p2[0] - p1[0];
+	const vy = p2[1] - p1[1];
+	const px = p3[0] - p1[0];
+	const py = p3[1] - p1[1];
+	const vMagnitude = Math.hypot(vx, vy);
+	const projectionLength = (px * vx + py * vy) / vMagnitude;
+	const pMagnitude = Math.hypot(px, py);
+	return Math.sqrt(pMagnitude * pMagnitude - projectionLength * projectionLength);
+}
+/**
+* 已知p1，p2，两点，判断p3点在p1p2的左右，返回-1右侧，0线上，1左侧
+* @param {*} p1
+* @param {*} p2
+* @param {*} p3
+*/
+function calculatePositionRelativeToLine(p1, p2, p3) {
+	const v1 = {
+		x: p2[0] - p1[0],
+		y: p2[1] - p1[1]
+	};
+	const v2 = {
+		x: p3[0] - p1[0],
+		y: p3[1] - p1[1]
+	};
+	const direction = v1.x * v2.y - v1.y * v2.x > 0 ? 1 : -1;
+	if (p1[1] > p2[1]) return direction;
+	return -direction;
+}
+/**
+* 已知p1，p2，p3点求矩形的p4点
+* @param {*} p1
+* @param {*} p2
+* @param {*} p3
+*/
+function calculateFourthCoord(p1, p2, p3) {
+	return [p1[0] + p3[0] - p2[0], p1[1] + p3[1] - p2[1]];
+}
+/**
+* 已知p1，p2两点和距离d，求距离p1p2垂直距离为d的点p3
+* @param {*} p1
+* @param {*} p2
+* @param {*} d
+*/
+function calculatePerpendicularCoord(p1, p2, d) {
+	const m = (p2[1] - p1[1]) / (p2[0] - p1[0]);
+	let x, y;
+	if (m !== 0) {
+		const perpendicularSlope = -1 / m;
+		const c = p2[1] - perpendicularSlope * p2[0];
+		x = d * Math.sqrt(1 / (1 + perpendicularSlope ** 2)) + p2[0];
+		y = perpendicularSlope * x + c;
+	} else {
+		x = p2[0];
+		y = p2[1] - d;
+	}
+	return [x, y];
+}
+
+//#endregion
+exports.FITTING_COUNT = FITTING_COUNT;
+exports.HALF_PI = HALF_PI;
+exports.TWO_PI = TWO_PI;
+exports.ZERO_TOLERANCE = ZERO_TOLERANCE;
+exports.arc = arc;
+exports.arrowAttackDirection = arrowAttackDirection;
+exports.arrowAttackDirectionTailed = arrowAttackDirectionTailed;
+exports.arrowClamped = arrowClamped;
+exports.arrowStraight = arrowStraight;
+exports.arrowStraightFine = arrowStraightFine;
+exports.arrowStraightSharp = arrowStraightSharp;
+exports.arrowUnitCombatOperation = arrowUnitCombatOperation;
+exports.arrowUnitCombatOperationTailed = arrowUnitCombatOperationTailed;
+exports.assemblingPlace = assemblingPlace;
+exports.calculateFourthCoord = calculateFourthCoord;
+exports.calculatePerpendicularCoord = calculatePerpendicularCoord;
+exports.calculatePerpendicularDistance = calculatePerpendicularDistance;
+exports.calculatePositionRelativeToLine = calculatePositionRelativeToLine;
+exports.circle = circle;
+exports.closedCurve = closedCurve;
+exports.curve = curve;
+exports.ellipse = ellipse;
+exports.getAngleOfThreeCoords = getAngleOfThreeCoords;
+exports.getArcCoords = getArcCoords;
+exports.getArrowBodyCoords = getArrowBodyCoords;
+exports.getArrowCoords = getArrowCoords;
+exports.getArrowHeadCoords = getArrowHeadCoords;
+exports.getAzimuth = getAzimuth;
+exports.getBaseLength = getBaseLength;
+exports.getBezierCoords = getBezierCoords;
+exports.getBinomialFactor = getBinomialFactor;
+exports.getBisectorNormals = getBisectorNormals;
+exports.getCircleCenterOfThreeCoords = getCircleCenterOfThreeCoords;
+exports.getCoordOnLine = getCoordOnLine;
+exports.getCubicValue = getCubicValue;
+exports.getCurveCoords = getCurveCoords;
+exports.getFactorial = getFactorial;
+exports.getIntersectCoord = getIntersectCoord;
+exports.getLeftMostControlCoord = getLeftMostControlCoord;
+exports.getNormal = getNormal;
+exports.getQBSplineCoords = getQBSplineCoords;
+exports.getQuadricBSplineFactor = getQuadricBSplineFactor;
+exports.getRightMostControlCoord = getRightMostControlCoord;
+exports.getTempCoord4 = getTempCoord4;
+exports.getThirdCoord = getThirdCoord;
+exports.isClockWise = isClockWise;
+exports.lune = lune;
+exports.mathDistance = mathDistance;
+exports.mid = mid;
+exports.rectAngle = rectAngle;
+exports.rectinclined1 = rectinclined1;
+exports.wholeDistance = wholeDistance;
+//# sourceMappingURL=index.cjs.map