cesium-xs-sdk 1.0.0

package/src/utils/PlotGeometryUtil.js

@@ -0,0 +1,1134 @@
+/**
+ * 标绘几何算法工具
+ * 移植自 cesium-plot-js 的几何生成能力
+ *
+ * 设计约定：
+ * - 输入控制点：[lon, lat] 或 [lon, lat, height]
+ * - 算法内部在经纬度平面上运算（与插件保持一致）
+ * - 输出：[[lon, lat, height], ...] 或 Cesium.Cartesian3[]
+ *
+ * 注意：标绘算法内部使用平面距离计算，不要替换为 GeoCalcUtil.calcDistance
+ */
+export class PlotGeometryUtil {
+  // ==================== 常量 ====================
+
+  static FITTING_COUNT = 100;
+  static ZERO_TOLERANCE = 0.0001;
+
+  // ==================== 基础平面几何工具 ====================
+
+  /**
+   * 平面距离计算
+   * 将经纬度视为平面坐标计算两点距离
+   */
+  static mathDistance(p1, p2) {
+    return Math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2);
+  }
+
+  /**
+   * 计算点集合的总距离（平面）
+   */
+  static wholeDistance(points) {
+    let distance = 0;
+    if (!points || !Array.isArray(points) || points.length === 0) return distance;
+    for (let i = 0; i < points.length - 1; i++) {
+      distance += this.mathDistance(points[i], points[i + 1]);
+    }
+    return distance;
+  }
+
+  /**
+   * 获取基础长度（插件算法中用于计算箭头尺寸）
+   */
+  static getBaseLength(points) {
+    return this.wholeDistance(points) ** 0.99;
+  }
+
+  /**
+   * 求两个坐标的中点
+   */
+  static mid(p1, p2) {
+    return [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
+  }
+
+  /**
+   * 获取方位角（弧度）
+   * 将经纬度视为平面坐标计算方向
+   */
+  static getAzimuth(startPoint, endPoint) {
+    const distance = this.mathDistance(startPoint, endPoint);
+    if (distance === 0) return 0;
+
+    const angle = Math.asin(Math.abs(endPoint[1] - startPoint[1]) / distance);
+
+    if (endPoint[1] >= startPoint[1] && endPoint[0] >= startPoint[0]) {
+      return angle + Math.PI;
+    }
+    if (endPoint[1] >= startPoint[1] && endPoint[0] < startPoint[0]) {
+      return Math.PI * 2 - angle;
+    }
+    if (endPoint[1] < startPoint[1] && endPoint[0] < startPoint[0]) {
+      return angle;
+    }
+    return Math.PI - angle;
+  }
+
+  /**
+   * 获取三点夹角（∠ABC）
+   */
+  static getAngleOfThreePoints(pntA, pntB, pntC) {
+    const angle = this.getAzimuth(pntB, pntA) - this.getAzimuth(pntB, pntC);
+    return angle < 0 ? angle + Math.PI * 2 : angle;
+  }
+
+  /**
+   * 判断三点是否顺时针
+   */
+  static isClockWise(pnt1, pnt2, pnt3) {
+    return (pnt3[1] - pnt1[1]) * (pnt2[0] - pnt1[0]) > (pnt2[1] - pnt1[1]) * (pnt3[0] - pnt1[0]);
+  }
+
+  /**
+   * 根据起止点和旋转方向求取第三个点
+   * @param {Array} startPnt 起点 [lon, lat]
+   * @param {Array} endPnt 终点 [lon, lat]
+   * @param {number} angle 旋转角（弧度）
+   * @param {number} distance 距离
+   * @param {boolean} clockWise 是否顺时针
+   * @returns {[number, number]}
+   */
+  static getThirdPoint(startPnt, endPnt, angle, distance, clockWise) {
+    const azimuth = this.getAzimuth(startPnt, endPnt);
+    const alpha = clockWise ? azimuth + angle : azimuth - angle;
+    const dx = distance * Math.cos(alpha);
+    const dy = distance * Math.sin(alpha);
+    return [endPnt[0] + dx, endPnt[1] + dy];
+  }
+
+  /**
+   * 插值圆弧点（经纬度平面）
+   * @param {Array} center 圆心 [lon, lat]
+   * @param {number} radius 半径（经纬度平面距离）
+   * @param {number} startAngle 起始角（弧度）
+   * @param {number} endAngle 结束角（弧度）
+   * @param {number} segments 分段数
+   * @returns {Array[]}
+   */
+  static getArcPoints(center, radius, startAngle, endAngle, segments = 100) {
+    let angleDiff = endAngle - startAngle;
+    angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
+
+    const points = [];
+    for (let i = 0; i <= segments; i++) {
+      const angle = startAngle + (angleDiff * i) / segments;
+      const x = center[0] + radius * Math.cos(angle);
+      const y = center[1] + radius * Math.sin(angle);
+      points.push([x, y]);
+    }
+    return points;
+  }
+
+  /**
+   * 计算两点球面距离（米）
+   * 与 _getPointAtBearingAndDistance 使用同一地球半径，保证扇形圆弧闭合一致
+   * @param {Array} p1 [lon, lat]
+   * @param {Array} p2 [lon, lat]
+   * @returns {number}
+   */
+  static _calcSphericalDistance(p1, p2) {
+    const earthRadius = 6371000;
+    const radPerDeg = Math.PI / 180;
+    const [lon1, lat1] = [p1[0] * radPerDeg, p1[1] * radPerDeg];
+    const [lon2, lat2] = [p2[0] * radPerDeg, p2[1] * radPerDeg];
+    const dLat = lat2 - lat1;
+    const dLon = lon2 - lon1;
+    const a = Math.sin(dLat / 2) ** 2 +
+      Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return earthRadius * c;
+  }
+
+  /**
+   * 计算真实地理方位角（弧度）
+   * 采用与 _getPointAtBearingAndDistance 一致的约定：0=正东，逆时针增大
+   * @param {Array} from 起点 [lon, lat]
+   * @param {Array} to 终点 [lon, lat]
+   * @returns {number} 方位角 [0, 2π)
+   */
+  static _getBearing(from, to) {
+    const radPerDeg = Math.PI / 180;
+    const lon1 = from[0] * radPerDeg;
+    const lat1 = from[1] * radPerDeg;
+    const lon2 = to[0] * radPerDeg;
+    const lat2 = to[1] * radPerDeg;
+
+    const dLon = lon2 - lon1;
+    const y = Math.sin(dLon) * Math.cos(lat2);
+    const x = Math.cos(lat1) * Math.sin(lat2) -
+      Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
+
+    // 标准球面前进方位角：0=正北，顺时针增大
+    let standardBearing = Math.atan2(y, x);
+    if (standardBearing < 0) standardBearing += Math.PI * 2;
+
+    // 转换为本 SDK 约定：0=正东，逆时针增大
+    let angle = Math.PI / 2 - standardBearing;
+    if (angle < 0) angle += Math.PI * 2;
+    if (angle > Math.PI * 2 - 1e-12) angle = 0;
+    return angle;
+  }
+
+  /**
+   * 按真实地理方位角和距离求目标点（球面直接解法）
+   * 约定：0=正东，逆时针增大
+   * @param {Array} center 圆心 [lon, lat]
+   * @param {number} distanceMeters 距离（米）
+   * @param {number} angle 方位角（弧度）
+   * @returns {[number, number]}
+   */
+  static _getPointAtBearingAndDistance(center, distanceMeters, angle) {
+    const earthRadius = 6371000;
+    const radPerDeg = Math.PI / 180;
+    const lon1 = center[0] * radPerDeg;
+    const lat1 = center[1] * radPerDeg;
+    const angularDistance = distanceMeters / earthRadius;
+
+    // 转换回标准球面前进方位角：0=正北，顺时针增大
+    const bearing = Math.PI / 2 - angle;
+
+    const lat2 = Math.asin(
+      Math.sin(lat1) * Math.cos(angularDistance) +
+      Math.cos(lat1) * Math.sin(angularDistance) * Math.cos(bearing)
+    );
+    const lon2 = lon1 + Math.atan2(
+      Math.sin(bearing) * Math.sin(angularDistance) * Math.cos(lat1),
+      Math.cos(angularDistance) - Math.sin(lat1) * Math.sin(lat2)
+    );
+
+    return [lon2 / radPerDeg, lat2 / radPerDeg];
+  }
+
+  /**
+   * 在两个端点之间沿真实地理圆弧插值
+   * 精确包含 startPoint 和 endPoint，避免端点漂移
+   * @param {Array} center 圆心 [lon, lat]
+   * @param {Array} startPoint 起点 [lon, lat]
+   * @param {Array} endPoint 终点 [lon, lat]
+   * @param {number} radiusMeters 半径（米）
+   * @param {number} segments 分段数
+   * @returns {Array[]}
+   */
+  static _getGeoArcPointsBetween(center, startPoint, endPoint, radiusMeters, segments = 100) {
+    const startAngle = this._getBearing(center, startPoint);
+    const endAngle = this._getBearing(center, endPoint);
+
+    let angleDiff = endAngle - startAngle;
+    angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
+
+    const points = [startPoint];
+    for (let i = 1; i < segments; i++) {
+      const angle = startAngle + (angleDiff * i) / segments;
+      points.push(this._getPointAtBearingAndDistance(center, radiusMeters, angle));
+    }
+    points.push(endPoint);
+    return points;
+  }
+
+  // ==================== 坐标转换工具 ====================
+
+  /**
+   * 提取经纬度（忽略高度）
+   */
+  static toLonLat(point) {
+    return [point[0], point[1]];
+  }
+
+  /**
+   * 将结果点数组统一转为 [lon, lat, height] 格式
+   */
+  static toPositions(points, height = 0) {
+    return points.map(p => [p[0], p[1], height]);
+  }
+
+  /**
+   * 去除多边形轮廓中的相邻重复点，并显式闭合首尾
+   * 用于修复 Cesium polyline/polygon 因零长度边导致的连线异常
+   * @param {Array[]} points [lon, lat] 或 [lon, lat, height] 数组
+   * @returns {Array[]}
+   */
+  static _closePolygonPoints(points) {
+    if (!points || points.length === 0) return points;
+    const result = [points[0]];
+    for (let i = 1; i < points.length; i++) {
+      const prev = result[result.length - 1];
+      const curr = points[i];
+      if (prev[0] !== curr[0] || prev[1] !== curr[1]) {
+        result.push(curr);
+      }
+    }
+    if (result.length > 1) {
+      const first = result[0];
+      const last = result[result.length - 1];
+      if (first[0] !== last[0] || first[1] !== last[1]) {
+        result.push(first);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 将 [lon, lat, height] 数组转为 Cesium.Cartesian3 数组
+   */
+  static toCartesian3Array(points) {
+    const flat = [];
+    for (const p of points) {
+      flat.push(p[0], p[1], p[2] || 0);
+    }
+    return Cesium.Cartesian3.fromDegreesArrayHeights(flat);
+  }
+
+  // ==================== 曲线/插值工具（复合箭头、曲线标绘需要）====================
+
+  /**
+   * 线性插值
+   */
+  static getPointOnLine(t, startPnt, endPnt) {
+    return [
+      startPnt[0] + t * (endPnt[0] - startPnt[0]),
+      startPnt[1] + t * (endPnt[1] - startPnt[1])
+    ];
+  }
+
+  /**
+   * 三次贝塞尔曲线求值
+   */
+  static getCubicValue(t, startPnt, cPnt1, cPnt2, endPnt) {
+    t = Math.max(Math.min(t, 1), 0);
+    const tp = 1 - t;
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const tp2 = tp * tp;
+    const tp3 = tp2 * tp;
+    return [
+      tp3 * startPnt[0] + 3 * tp2 * t * cPnt1[0] + 3 * tp * t2 * cPnt2[0] + t3 * endPnt[0],
+      tp3 * startPnt[1] + 3 * tp2 * t * cPnt1[1] + 3 * tp * t2 * cPnt2[1] + t3 * endPnt[1]
+    ];
+  }
+
+  /**
+   * 计算三点的法线及角平分线上的两个控制点
+   */
+  static getBisectorNormals(t, pnt1, pnt2, pnt3) {
+    const normal = this.getNormal(pnt1, pnt2, pnt3);
+    const dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
+    const uX = normal[0] / dist;
+    const uY = normal[1] / dist;
+    const d1 = this.mathDistance(pnt1, pnt2);
+    const d2 = this.mathDistance(pnt2, pnt3);
+    let bisectorNormalRight, bisectorNormalLeft;
+
+    if (dist > this.ZERO_TOLERANCE) {
+      if (this.isClockWise(pnt1, pnt2, pnt3)) {
+        let dt = t * d1;
+        let x = pnt2[0] - dt * uY;
+        let y = pnt2[1] + dt * uX;
+        bisectorNormalRight = [x, y];
+        dt = t * d2;
+        x = pnt2[0] + dt * uY;
+        y = pnt2[1] - dt * uX;
+        bisectorNormalLeft = [x, y];
+      } else {
+        let dt = t * d1;
+        let x = pnt2[0] + dt * uY;
+        let y = pnt2[1] - dt * uX;
+        bisectorNormalRight = [x, y];
+        dt = t * d2;
+        x = pnt2[0] - dt * uY;
+        y = pnt2[1] + dt * uX;
+        bisectorNormalLeft = [x, y];
+      }
+    } else {
+      let x = pnt2[0] + t * (pnt1[0] - pnt2[0]);
+      let y = pnt2[1] + t * (pnt1[1] - pnt2[1]);
+      bisectorNormalRight = [x, y];
+      x = pnt2[0] + t * (pnt3[0] - pnt2[0]);
+      y = pnt2[1] + t * (pnt3[1] - pnt2[1]);
+      bisectorNormalLeft = [x, y];
+    }
+    return [bisectorNormalRight, bisectorNormalLeft];
+  }
+
+  /**
+   * 获取三点的内切法线方向
+   */
+  static getNormal(pnt1, pnt2, pnt3) {
+    let dX1 = pnt1[0] - pnt2[0];
+    let dY1 = pnt1[1] - pnt2[1];
+    const d1 = Math.sqrt(dX1 * dX1 + dY1 * dY1);
+    dX1 /= d1;
+    dY1 /= d1;
+    let dX2 = pnt3[0] - pnt2[0];
+    let dY2 = pnt3[1] - pnt2[1];
+    const d2 = Math.sqrt(dX2 * dX2 + dY2 * dY2);
+    dX2 /= d2;
+    dY2 /= d2;
+    return [dX1 + dX2, dY1 + dY2];
+  }
+
+  /**
+   * 获取左侧第一个控制点（用于曲线插值）
+   */
+  static getLeftMostControlPoint(controlPoints, t) {
+    const [pnt1, pnt2, pnt3] = [controlPoints[0], controlPoints[1], controlPoints[2]];
+    const pnts = this.getBisectorNormals(0, pnt1, pnt2, pnt3);
+    const normalRight = pnts[0];
+    const normal = this.getNormal(pnt1, pnt2, pnt3);
+    const dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
+    let controlX, controlY;
+    if (dist > this.ZERO_TOLERANCE) {
+      const mid = this.mid(pnt1, pnt2);
+      const pX = pnt1[0] - mid[0];
+      const pY = pnt1[1] - mid[1];
+      const d1 = this.mathDistance(pnt1, pnt2);
+      const n = 2.0 / d1;
+      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] - mid[0];
+      const dY = normalRight[1] - mid[1];
+      controlX = mid[0] + a11 * dX + a12 * dY;
+      controlY = mid[1] + a12 * dX + a22 * dY;
+    } else {
+      controlX = pnt1[0] + t * (pnt2[0] - pnt1[0]);
+      controlY = pnt1[1] + t * (pnt2[1] - pnt1[1]);
+    }
+    return [controlX, controlY];
+  }
+
+  /**
+   * 获取右侧最后一个控制点（用于曲线插值）
+   */
+  static getRightMostControlPoint(controlPoints, t) {
+    const count = controlPoints.length;
+    const pnt1 = controlPoints[count - 3];
+    const pnt2 = controlPoints[count - 2];
+    const pnt3 = controlPoints[count - 1];
+    const pnts = this.getBisectorNormals(0, pnt1, pnt2, pnt3);
+    const normalLeft = pnts[1];
+    const normal = this.getNormal(pnt1, pnt2, pnt3);
+    const dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
+    let controlX, controlY;
+    if (dist > this.ZERO_TOLERANCE) {
+      const mid = this.mid(pnt2, pnt3);
+      const pX = pnt3[0] - mid[0];
+      const pY = pnt3[1] - mid[1];
+      const d1 = this.mathDistance(pnt2, pnt3);
+      const n = 2.0 / d1;
+      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] - mid[0];
+      const dY = normalLeft[1] - mid[1];
+      controlX = mid[0] + a11 * dX + a12 * dY;
+      controlY = mid[1] + a12 * dX + a22 * dY;
+    } else {
+      controlX = pnt3[0] + t * (pnt2[0] - pnt3[0]);
+      controlY = pnt3[1] + t * (pnt2[1] - pnt3[1]);
+    }
+    return [controlX, controlY];
+  }
+
+  /**
+   * 曲线插值（用于 CurvedArrow / Curve）
+   * @param {number} t 张力系数
+   * @param {Array[]} controlPoints 控制点数组
+   */
+  static getCurvePoints(t, controlPoints) {
+    if (!controlPoints || controlPoints.length < 3) {
+      return controlPoints ? controlPoints.slice() : [];
+    }
+
+    const leftControl = this.getLeftMostControlPoint(controlPoints, t);
+    const normals = [leftControl];
+    let pnt1, pnt2, pnt3;
+    for (let i = 0; i < controlPoints.length - 2; i++) {
+      pnt1 = controlPoints[i];
+      pnt2 = controlPoints[i + 1];
+      pnt3 = controlPoints[i + 2];
+      const normalPoints = this.getBisectorNormals(t, pnt1, pnt2, pnt3);
+      normals.push(...normalPoints);
+    }
+    const rightControl = this.getRightMostControlPoint(controlPoints, t);
+    if (rightControl) {
+      normals.push(rightControl);
+    }
+
+    const points = [];
+    for (let i = 0; i < controlPoints.length - 1; i++) {
+      pnt1 = controlPoints[i];
+      pnt2 = controlPoints[i + 1];
+      points.push(pnt1);
+      for (let j = 0; j < this.FITTING_COUNT; j++) {
+        const pnt = this.getCubicValue(
+          j / this.FITTING_COUNT,
+          pnt1,
+          normals[i * 2],
+          normals[i * 2 + 1],
+          pnt2
+        );
+        points.push(pnt);
+      }
+      points.push(pnt2);
+    }
+    return points;
+  }
+
+  /**
+   * 贝塞尔曲线插值
+   */
+  static getBezierPoints(points) {
+    if (!points || points.length <= 2) return points;
+    const bezierPoints = [];
+    const n = points.length - 1;
+    for (let t = 0; t <= 1; t += 0.01) {
+      let x = 0, y = 0;
+      for (let index = 0; index <= n; index++) {
+        const factor = this.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];
+      }
+      bezierPoints.push([x, y]);
+    }
+    bezierPoints.push(points[n]);
+    return bezierPoints;
+  }
+
+  static getFactorial(n) {
+    let result = 1;
+    for (let i = 1; i <= n; i++) {
+      result *= i;
+    }
+    return result;
+  }
+
+  static getBinomialFactor(n, index) {
+    return this.getFactorial(n) / (this.getFactorial(index) * this.getFactorial(n - index));
+  }
+
+  /**
+   * 二次 B 样条插值
+   */
+  static getQBSplinePoints(points) {
+    if (!points || points.length <= 2) return points;
+    const n = 2;
+    const bSplinePoints = [];
+    const m = points.length - n - 1;
+    bSplinePoints.push(points[0]);
+    for (let i = 0; i <= m; i++) {
+      for (let t = 0; t <= 1; t += 0.05) {
+        let x = 0, y = 0;
+        for (let k = 0; k <= n; k++) {
+          const factor = this.getQuadricBSplineFactor(k, t);
+          x += factor * points[i + k][0];
+          y += factor * points[i + k][1];
+        }
+        bSplinePoints.push([x, y]);
+      }
+    }
+    bSplinePoints.push(points[points.length - 1]);
+    return bSplinePoints;
+  }
+
+  static getQuadricBSplineFactor(k, t) {
+    if (k === 0) return (t - 1) ** 2 / 2;
+    if (k === 1) return (-2 * t ** 2 + 2 * t + 1) / 2;
+    if (k === 2) return t ** 2 / 2;
+    return 0;
+  }
+
+  // ==================== 标绘图元生成 ====================
+
+  /**
+   * 直箭头（FineArrow）
+   * 控制点：2 个 [起点, 终点]
+   */
+  static createFineArrow(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const [p1, p2] = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    const tailWidthFactor = options.tailWidthFactor ?? 0.1;
+    const neckWidthFactor = options.neckWidthFactor ?? 0.2;
+    const headWidthFactor = options.headWidthFactor ?? 0.25;
+    const headAngle = options.headAngle ?? Math.PI / 8.5;
+    const neckAngle = options.neckAngle ?? Math.PI / 13;
+
+    const len = this.getBaseLength([p1, p2]);
+    const tailWidth = len * tailWidthFactor;
+    const neckWidth = len * neckWidthFactor;
+    const headWidth = len * headWidthFactor;
+
+    const tailLeft = this.getThirdPoint(p2, p1, Math.PI / 2, tailWidth, true);
+    const tailRight = this.getThirdPoint(p2, p1, Math.PI / 2, tailWidth, false);
+    const headLeft = this.getThirdPoint(p1, p2, headAngle, headWidth, false);
+    const headRight = this.getThirdPoint(p1, p2, headAngle, headWidth, true);
+    const neckLeft = this.getThirdPoint(p1, p2, neckAngle, neckWidth, false);
+    const neckRight = this.getThirdPoint(p1, p2, neckAngle, neckWidth, true);
+
+    const outlinePoints = [
+      tailLeft, neckLeft, headLeft, p2, headRight, neckRight, tailRight, p1
+    ];
+
+    return this.toPositions(outlinePoints, height);
+  }
+
+  /**
+   * 突击方向（AssaultDirection）
+   * 继承直箭头逻辑，仅系数不同，整体长度拉长 1.5 倍
+   * 控制点：2 个 [起点, 终点]
+   */
+  static createAssaultDirection(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const [p1, p2] = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    const tailWidthFactor = options.tailWidthFactor ?? 0.08;
+    const neckWidthFactor = options.neckWidthFactor ?? 0.1;
+    const headWidthFactor = options.headWidthFactor ?? 0.13;
+    const headAngle = options.headAngle ?? Math.PI / 4;
+    const neckAngle = options.neckAngle ?? Math.PI * 0.17741;
+
+    const len = this.getBaseLength([p1, p2]) * 1.5;
+    const tailWidth = len * tailWidthFactor;
+    const neckWidth = len * neckWidthFactor;
+    const headWidth = len * headWidthFactor;
+
+    const tailLeft = this.getThirdPoint(p2, p1, Math.PI / 2, tailWidth, true);
+    const tailRight = this.getThirdPoint(p2, p1, Math.PI / 2, tailWidth, false);
+    const headLeft = this.getThirdPoint(p1, p2, headAngle, headWidth, false);
+    const headRight = this.getThirdPoint(p1, p2, headAngle, headWidth, true);
+    const neckLeft = this.getThirdPoint(p1, p2, neckAngle, neckWidth, false);
+    const neckRight = this.getThirdPoint(p1, p2, neckAngle, neckWidth, true);
+
+    return this.toPositions([
+      tailLeft, neckLeft, headLeft, p2, headRight, neckRight, tailRight, p1
+    ], height);
+  }
+
+  /**
+   * 细直箭头（StraightArrow）
+   * 控制点：2 个 [起点, 终点]
+   * 输出：线型
+   */
+  static createStraightArrow(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const [p1, p2] = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    const arrowLengthScale = options.arrowLengthScale ?? 5;
+    const maxArrowLength = options.maxArrowLength ?? 3000000;
+
+    const distance = this.mathDistance(p1, p2);
+    let len = distance / arrowLengthScale;
+    len = Math.min(len, maxArrowLength);
+
+    const leftPnt = this.getThirdPoint(p1, p2, Math.PI / 6, len / 2, false);
+    const rightPnt = this.getThirdPoint(p1, p2, Math.PI / 6, len / 2, true);
+
+    return this.toPositions([p1, p2, leftPnt, p2, rightPnt], height);
+  }
+
+  /**
+   * 三角形（Triangle）
+   * 控制点：3 个
+   */
+  static createTriangle(points) {
+    if (!points || points.length < 3) return [];
+    return points.slice(0, 3).map(p => [p[0], p[1], p[2] || 0]);
+  }
+
+  /**
+   * 扇形（Sector）
+   * 控制点：3 个 [圆心, 起始点, 结束点]
+   * 使用球面真实地理圆，保证圆弧经过两个半径控制点
+   */
+  static createSector(points) {
+    if (!points || points.length < 3) return [];
+
+    const [center, pnt2, pnt3] = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    // 使用球面距离作为半径，与圆弧插值函数保持一致
+    const radius = this._calcSphericalDistance(pnt2, center);
+
+    // 弧线精确经过两个控制点，避免端点漂移
+    const arcPoints = this._getGeoArcPointsBetween(center, pnt2, pnt3, radius);
+    arcPoints.push(center);
+
+    return this.toPositions(arcPoints, height);
+  }
+
+  /**
+   * 椭圆（Ellipse）
+   * 控制点：3 个 [center, majorEnd, minorEnd]
+   */
+  static createEllipse(points) {
+    if (!points || points.length < 3) return [];
+
+    const controlPoints = points.slice(0, 3);
+    const [center, majorEnd, minorEnd] = controlPoints.map(p => this.toLonLat(p));
+    const height = controlPoints[0][2] || 0;
+
+    const majorVec = [majorEnd[0] - center[0], majorEnd[1] - center[1]];
+    const minorVec = [minorEnd[0] - center[0], minorEnd[1] - center[1]];
+
+    const ellipsePoints = [];
+    for (let i = 0; i <= 100; i++) {
+      const angle = (Math.PI * 2 * i) / 100;
+      const x = center[0] + majorVec[0] * Math.cos(angle) + minorVec[0] * Math.sin(angle);
+      const y = center[1] + majorVec[1] * Math.cos(angle) + minorVec[1] * Math.sin(angle);
+      ellipsePoints.push([x, y]);
+    }
+
+    return this.toPositions(ellipsePoints, height);
+  }
+
+  // ==================== 复合箭头图元 ====================
+
+  /**
+   * 通用箭头头部点
+   * @param {Array[]} points 控制点数组
+   * @param {object} options 箭头系数
+   * @returns {Array[]} [neckLeft, headLeft, headPnt, headRight, neckRight]
+   */
+  static _getAttackArrowHeadPoints(points, options = {}) {
+    if (!points || points.length < 2) return [];
+    const headHeightFactor = options.headHeightFactor ?? 0.18;
+    const headWidthFactor = options.headWidthFactor ?? 0.3;
+    const neckHeightFactor = options.neckHeightFactor ?? 0.85;
+    const neckWidthFactor = options.neckWidthFactor ?? 0.15;
+    const headTailFactor = options.headTailFactor ?? 0.8;
+
+    const len = this.getBaseLength(points);
+    let headHeight = len * headHeightFactor;
+    const headPnt = points[points.length - 1];
+    const len2 = this.mathDistance(headPnt, points[points.length - 2]);
+    const tailWidth = this.mathDistance(options.tailLeft, options.tailRight);
+    if (headHeight > tailWidth * headTailFactor) {
+      headHeight = tailWidth * headTailFactor;
+    }
+    const headWidth = headHeight * headWidthFactor;
+    const neckWidth = headHeight * neckWidthFactor;
+    headHeight = Math.min(headHeight, len2);
+    const neckHeight = headHeight * neckHeightFactor;
+
+    const headEndPnt = this.getThirdPoint(points[points.length - 2], headPnt, 0, headHeight, true);
+    const neckEndPnt = this.getThirdPoint(points[points.length - 2], headPnt, 0, neckHeight, true);
+    const headLeft = this.getThirdPoint(headPnt, headEndPnt, Math.PI / 2, headWidth, false);
+    const headRight = this.getThirdPoint(headPnt, headEndPnt, Math.PI / 2, headWidth, true);
+    const neckLeft = this.getThirdPoint(headPnt, neckEndPnt, Math.PI / 2, neckWidth, false);
+    const neckRight = this.getThirdPoint(headPnt, neckEndPnt, Math.PI / 2, neckWidth, true);
+    return [neckLeft, headLeft, headPnt, headRight, neckRight];
+  }
+
+  /**
+   * 通用箭头躯干点
+   * @param {Array[]} points 骨骼点
+   * @param {Array} neckLeft
+   * @param {Array} neckRight
+   * @param {number} tailWidthFactor
+   */
+  static _getAttackArrowBodyPoints(points, neckLeft, neckRight, tailWidthFactor) {
+    const allLen = this.wholeDistance(points);
+    const len = this.getBaseLength(points);
+    const tailWidth = len * tailWidthFactor;
+    const neckWidth = this.mathDistance(neckLeft, neckRight);
+    const widthDif = (tailWidth - neckWidth) / 2;
+    let tempLen = 0;
+    const leftBodyPnts = [];
+    const rightBodyPnts = [];
+    for (let i = 1; i < points.length - 1; i++) {
+      const angle = this.getAngleOfThreePoints(points[i - 1], points[i], points[i + 1]) / 2;
+      tempLen += this.mathDistance(points[i - 1], points[i]);
+      const w = (tailWidth / 2 - (tempLen / allLen) * widthDif) / Math.sin(angle);
+      const left = this.getThirdPoint(points[i - 1], points[i], Math.PI - angle, w, true);
+      const right = this.getThirdPoint(points[i - 1], points[i], angle, w, false);
+      leftBodyPnts.push(left);
+      rightBodyPnts.push(right);
+    }
+    return leftBodyPnts.concat(rightBodyPnts);
+  }
+
+  /**
+   * 获取燕尾/集结箭头的尾部点
+   */
+  static _getSquadTailPoints(points, tailWidthFactor, swallowTailFactor = 0) {
+    const allLen = this.getBaseLength(points);
+    const tailWidth = allLen * tailWidthFactor;
+    const tailLeft = this.getThirdPoint(points[1], points[0], Math.PI / 2, tailWidth, false);
+    const tailRight = this.getThirdPoint(points[1], points[0], Math.PI / 2, tailWidth, true);
+    if (swallowTailFactor > 0) {
+      const len = tailWidth * swallowTailFactor;
+      const swallowTailPnt = this.getThirdPoint(points[1], points[0], 0, len, true);
+      return [tailLeft, swallowTailPnt, tailRight];
+    }
+    return [tailLeft, tailRight];
+  }
+
+  /**
+   * 攻击箭头（AttackArrow）
+   * 控制点：≥3 个 [tailLeft, tailRight, bone..., head]
+   */
+  static createAttackArrow(points, options = {}) {
+    if (!points || points.length < 3) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    let [tailLeft, tailRight] = [lnglatPoints[0], lnglatPoints[1]];
+    if (this.isClockWise(lnglatPoints[0], lnglatPoints[1], lnglatPoints[2])) {
+      tailLeft = lnglatPoints[1];
+      tailRight = lnglatPoints[0];
+    }
+
+    const midTail = this.mid(tailLeft, tailRight);
+    const bonePnts = [midTail].concat(lnglatPoints.slice(2));
+    const headPnts = this._getAttackArrowHeadPoints(bonePnts, {
+      ...options,
+      tailLeft,
+      tailRight
+    });
+    if (!headPnts || headPnts.length === 0) return this.toPositions(lnglatPoints, height);
+
+    const [neckLeft, neckRight] = [headPnts[0], headPnts[4]];
+    const tailWidthFactor = this.mathDistance(tailLeft, tailRight) / this.getBaseLength(bonePnts);
+    const bodyPnts = this._getAttackArrowBodyPoints(bonePnts, neckLeft, neckRight, tailWidthFactor);
+    const count = bodyPnts.length;
+    let leftPnts = [tailLeft].concat(bodyPnts.slice(0, count / 2));
+    leftPnts.push(neckLeft);
+    let rightPnts = [tailRight].concat(bodyPnts.slice(count / 2, count));
+    rightPnts.push(neckRight);
+    leftPnts = this.getQBSplinePoints(leftPnts);
+    rightPnts = this.getQBSplinePoints(rightPnts);
+    const result = this._closePolygonPoints(leftPnts.concat(headPnts, rightPnts.reverse()));
+    return this.toPositions(result, height);
+  }
+
+  /**
+   * 燕尾攻击箭头（SwallowtailAttackArrow）
+   * 控制点：≥3 个
+   */
+  static createSwallowtailAttackArrow(points, options = {}) {
+    if (!points || points.length < 3) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    let [tailLeft, tailRight] = [lnglatPoints[0], lnglatPoints[1]];
+    if (this.isClockWise(lnglatPoints[0], lnglatPoints[1], lnglatPoints[2])) {
+      tailLeft = lnglatPoints[1];
+      tailRight = lnglatPoints[0];
+    }
+
+    const midTail = this.mid(tailLeft, tailRight);
+    const bonePnts = [midTail].concat(lnglatPoints.slice(2));
+    const headPnts = this._getAttackArrowHeadPoints(bonePnts, {
+      ...options,
+      tailLeft,
+      tailRight
+    });
+    if (!headPnts || headPnts.length === 0) return this.toPositions(lnglatPoints, height);
+
+    const [neckLeft, neckRight] = [headPnts[0], headPnts[4]];
+    const tailWidthFactor = options.tailWidthFactor ?? 0.1;
+    const swallowTailFactor = options.swallowTailFactor ?? 1;
+    const allLen = this.getBaseLength(bonePnts);
+    const tailWidth = this.mathDistance(tailLeft, tailRight);
+    const len = allLen * tailWidthFactor * swallowTailFactor;
+    const swallowTailPnt = this.getThirdPoint(bonePnts[1], bonePnts[0], 0, len, true);
+    const factor = tailWidth / allLen;
+    const bodyPnts = this._getAttackArrowBodyPoints(bonePnts, neckLeft, neckRight, factor);
+    const count = bodyPnts.length;
+    let leftPnts = [tailLeft].concat(bodyPnts.slice(0, count / 2));
+    leftPnts.push(neckLeft);
+    let rightPnts = [tailRight].concat(bodyPnts.slice(count / 2, count));
+    rightPnts.push(neckRight);
+    leftPnts = this.getQBSplinePoints(leftPnts);
+    rightPnts = this.getQBSplinePoints(rightPnts);
+    const result = this._closePolygonPoints(leftPnts.concat(headPnts, rightPnts.reverse(), [swallowTailPnt, leftPnts[0]]));
+    return this.toPositions(result, height);
+  }
+
+  /**
+   * 集结箭头（SquadCombat）
+   * 控制点：≥2 个 [tailBase, bone..., head]
+   */
+  static createSquadCombat(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    const tailWidthFactor = options.tailWidthFactor ?? 0.1;
+    const tailPnts = this._getSquadTailPoints(lnglatPoints, tailWidthFactor);
+    const headPnts = this._getAttackArrowHeadPoints(lnglatPoints, {
+      ...options,
+      tailLeft: tailPnts[0],
+      tailRight: tailPnts[1]
+    });
+    if (!headPnts || headPnts.length === 0) return this.toPositions(lnglatPoints, height);
+
+    const [neckLeft, neckRight] = [headPnts[0], headPnts[4]];
+    const bodyPnts = this._getAttackArrowBodyPoints(lnglatPoints, neckLeft, neckRight, tailWidthFactor);
+    const count = bodyPnts.length;
+    let leftPnts = [tailPnts[0]].concat(bodyPnts.slice(0, count / 2));
+    leftPnts.push(neckLeft);
+    let rightPnts = [tailPnts[1]].concat(bodyPnts.slice(count / 2, count));
+    rightPnts.push(neckRight);
+    leftPnts = this.getQBSplinePoints(leftPnts);
+    rightPnts = this.getQBSplinePoints(rightPnts);
+    const result = this._closePolygonPoints(leftPnts.concat(headPnts, rightPnts.reverse()));
+    return this.toPositions(result, height);
+  }
+
+  /**
+   * 燕尾集结箭头（SwallowtailSquadCombat）
+   * 控制点：≥2 个
+   */
+  static createSwallowtailSquadCombat(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    const tailWidthFactor = options.tailWidthFactor ?? 0.1;
+    const swallowTailFactor = options.swallowTailFactor ?? 1;
+    const tailPnts = this._getSquadTailPoints(lnglatPoints, tailWidthFactor, swallowTailFactor);
+    const headPnts = this._getAttackArrowHeadPoints(lnglatPoints, {
+      ...options,
+      tailLeft: tailPnts[0],
+      tailRight: tailPnts[2]
+    });
+    if (!headPnts || headPnts.length === 0) return this.toPositions(lnglatPoints, height);
+
+    const [neckLeft, neckRight] = [headPnts[0], headPnts[4]];
+    const bodyPnts = this._getAttackArrowBodyPoints(lnglatPoints, neckLeft, neckRight, tailWidthFactor);
+    const count = bodyPnts.length;
+    let leftPnts = [tailPnts[0]].concat(bodyPnts.slice(0, count / 2));
+    leftPnts.push(neckLeft);
+    let rightPnts = [tailPnts[2]].concat(bodyPnts.slice(count / 2, count));
+    rightPnts.push(neckRight);
+    leftPnts = this.getQBSplinePoints(leftPnts);
+    rightPnts = this.getQBSplinePoints(rightPnts);
+    const result = this._closePolygonPoints(leftPnts.concat(headPnts, rightPnts.reverse(), [tailPnts[1], leftPnts[0]]));
+    return this.toPositions(result, height);
+  }
+
+  /**
+   * 双箭头（DoubleArrow）
+   * 控制点：3~5 个
+   * - 3 点：自动生成临时第四点和对称连接点
+   * - 4 点：第四点作为临时控制点
+   * - 5 点：第四点作为临时控制点，第五点作为连接点
+   */
+  static createDoubleArrow(points, options = {}) {
+    if (!points || points.length < 3) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+    const [pnt1, pnt2, pnt3] = lnglatPoints;
+    const count = lnglatPoints.length;
+
+    let tempPoint4;
+    let connPoint;
+    if (count === 3) {
+      tempPoint4 = this._getDoubleArrowTempPoint4(pnt1, pnt2, pnt3);
+      connPoint = this.mid(pnt1, pnt2);
+    } else if (count === 4) {
+      tempPoint4 = lnglatPoints[3];
+      connPoint = this.mid(pnt1, pnt2);
+    } else {
+      tempPoint4 = lnglatPoints[3];
+      connPoint = lnglatPoints[4];
+    }
+
+    const headHeightFactor = options.headHeightFactor ?? 0.25;
+    const headWidthFactor = options.headWidthFactor ?? 0.3;
+    const neckHeightFactor = options.neckHeightFactor ?? 0.85;
+    const neckWidthFactor = options.neckWidthFactor ?? 0.15;
+
+    const isClockWise = this.isClockWise(pnt1, pnt2, pnt3);
+    let leftArrowPnts, rightArrowPnts;
+    if (isClockWise) {
+      leftArrowPnts = this._getDoubleArrowPoints(pnt1, connPoint, tempPoint4, false, options);
+      rightArrowPnts = this._getDoubleArrowPoints(connPoint, pnt2, pnt3, true, options);
+    } else {
+      leftArrowPnts = this._getDoubleArrowPoints(pnt2, connPoint, pnt3, false, options);
+      rightArrowPnts = this._getDoubleArrowPoints(connPoint, pnt1, tempPoint4, true, options);
+    }
+
+    const m = leftArrowPnts.length;
+    const t = (m - 5) / 2;
+    const llBodyPnts = leftArrowPnts.slice(0, t);
+    const lArrowPnts = leftArrowPnts.slice(t, t + 5);
+    let lrBodyPnts = leftArrowPnts.slice(t + 5, m);
+    let rlBodyPnts = rightArrowPnts.slice(0, t);
+    const rArrowPnts = rightArrowPnts.slice(t, t + 5);
+    const rrBodyPnts = rightArrowPnts.slice(t + 5, m);
+
+    rlBodyPnts = this.getBezierPoints(rlBodyPnts);
+    const bodyPnts = this.getBezierPoints(rrBodyPnts.concat(llBodyPnts.slice(1)));
+    lrBodyPnts = this.getBezierPoints(lrBodyPnts);
+    const result = this._closePolygonPoints(rlBodyPnts.concat(rArrowPnts, bodyPnts, lArrowPnts, lrBodyPnts));
+    return this.toPositions(result, height);
+  }
+
+  static _getDoubleArrowTempPoint4(linePnt1, linePnt2, point) {
+    const midPnt = this.mid(linePnt1, linePnt2);
+    const len = this.mathDistance(midPnt, point);
+    const angle = this.getAngleOfThreePoints(linePnt1, midPnt, point);
+    let symPnt = [0, 0];
+    let distance1, distance2, mid;
+    if (angle < Math.PI / 2) {
+      distance1 = len * Math.sin(angle);
+      distance2 = len * Math.cos(angle);
+      mid = this.getThirdPoint(linePnt1, midPnt, Math.PI / 2, distance1, false);
+      symPnt = this.getThirdPoint(midPnt, mid, Math.PI / 2, distance2, true);
+    } else if (angle < Math.PI) {
+      distance1 = len * Math.sin(Math.PI - angle);
+      distance2 = len * Math.cos(Math.PI - angle);
+      mid = this.getThirdPoint(linePnt1, midPnt, Math.PI / 2, distance1, false);
+      symPnt = this.getThirdPoint(midPnt, mid, Math.PI / 2, distance2, false);
+    } else if (angle < Math.PI * 1.5) {
+      distance1 = len * Math.sin(angle - Math.PI);
+      distance2 = len * Math.cos(angle - Math.PI);
+      mid = this.getThirdPoint(linePnt1, midPnt, Math.PI / 2, distance1, true);
+      symPnt = this.getThirdPoint(midPnt, mid, Math.PI / 2, distance2, true);
+    } else {
+      distance1 = len * Math.sin(Math.PI * 2 - angle);
+      distance2 = len * Math.cos(Math.PI * 2 - angle);
+      mid = this.getThirdPoint(linePnt1, midPnt, Math.PI / 2, distance1, true);
+      symPnt = this.getThirdPoint(midPnt, mid, Math.PI / 2, distance2, false);
+    }
+    return symPnt;
+  }
+
+  static _getDoubleArrowPoints(pnt1, pnt2, pnt3, clockWise, options = {}) {
+    const headHeightFactor = options.headHeightFactor ?? 0.25;
+    const headWidthFactor = options.headWidthFactor ?? 0.3;
+    const neckHeightFactor = options.neckHeightFactor ?? 0.85;
+    const neckWidthFactor = options.neckWidthFactor ?? 0.15;
+
+    const midPnt = this.mid(pnt1, pnt2);
+    const len = this.mathDistance(midPnt, pnt3);
+    let midPnt1 = this.getThirdPoint(pnt3, midPnt, 0, len * 0.3, true);
+    let midPnt2 = this.getThirdPoint(pnt3, midPnt, 0, len * 0.5, true);
+    midPnt1 = this.getThirdPoint(midPnt, midPnt1, Math.PI / 2, len / 5, clockWise);
+    midPnt2 = this.getThirdPoint(midPnt, midPnt2, Math.PI / 2, len / 4, clockWise);
+    const points = [midPnt, midPnt1, midPnt2, pnt3];
+    const arrowPnts = this._getDoubleArrowHeadPoints(points, options);
+    if (!arrowPnts || arrowPnts.length === 0) return [];
+
+    const neckLeftPoint = arrowPnts[0];
+    const neckRightPoint = arrowPnts[4];
+    const tailWidthFactor = this.mathDistance(pnt1, pnt2) / this.getBaseLength(points) / 2;
+    const bodyPnts = this._getAttackArrowBodyPoints(points, neckLeftPoint, neckRightPoint, tailWidthFactor);
+    const n = bodyPnts.length;
+    let lPoints = bodyPnts.slice(0, n / 2);
+    let rPoints = bodyPnts.slice(n / 2, n);
+    lPoints.push(neckLeftPoint);
+    rPoints.push(neckRightPoint);
+    lPoints = lPoints.reverse();
+    lPoints.push(pnt2);
+    rPoints = rPoints.reverse();
+    rPoints.push(pnt1);
+    return lPoints.reverse().concat(arrowPnts, rPoints);
+  }
+
+  static _getDoubleArrowHeadPoints(points, options = {}) {
+    const len = this.getBaseLength(points);
+    const headHeight = len * (options.headHeightFactor ?? 0.25);
+    const headPnt = points[points.length - 1];
+    const headWidth = headHeight * (options.headWidthFactor ?? 0.3);
+    const neckWidth = headHeight * (options.neckWidthFactor ?? 0.15);
+    const neckHeight = headHeight * (options.neckHeightFactor ?? 0.85);
+    const headEndPnt = this.getThirdPoint(points[points.length - 2], headPnt, 0, headHeight, true);
+    const neckEndPnt = this.getThirdPoint(points[points.length - 2], headPnt, 0, neckHeight, true);
+    const headLeft = this.getThirdPoint(headPnt, headEndPnt, Math.PI / 2, headWidth, false);
+    const headRight = this.getThirdPoint(headPnt, headEndPnt, Math.PI / 2, headWidth, true);
+    const neckLeft = this.getThirdPoint(headPnt, neckEndPnt, Math.PI / 2, neckWidth, false);
+    const neckRight = this.getThirdPoint(headPnt, neckEndPnt, Math.PI / 2, neckWidth, true);
+    return [neckLeft, headLeft, headPnt, headRight, neckRight];
+  }
+
+  /**
+   * 曲线箭头（CurvedArrow）
+   * 控制点：≥2 个；2 个点时退化为细直箭头
+   */
+  static createCurvedArrow(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    if (points.length === 2) {
+      return this.createStraightArrow(points, options);
+    }
+
+    const t = options.t ?? 0.3;
+    const arrowLengthScale = options.arrowLengthScale ?? 5;
+    const maxArrowLength = options.maxArrowLength ?? 3000000;
+
+    const curvePoints = this.getCurvePoints(t, lnglatPoints);
+    const pnt1 = lnglatPoints[lnglatPoints.length - 2];
+    const pnt2 = lnglatPoints[lnglatPoints.length - 1];
+    const distance = this.wholeDistance(lnglatPoints);
+    let len = distance / arrowLengthScale;
+    len = Math.min(len, maxArrowLength);
+    const leftPnt = this.getThirdPoint(
+      curvePoints[curvePoints.length - 2],
+      curvePoints[curvePoints.length - 1],
+      Math.PI / 6,
+      len / 2,
+      false
+    );
+    const rightPnt = this.getThirdPoint(
+      curvePoints[curvePoints.length - 2],
+      curvePoints[curvePoints.length - 1],
+      Math.PI / 6,
+      len / 2,
+      true
+    );
+    const result = curvePoints.concat([leftPnt, pnt2, rightPnt]);
+    return this.toPositions(result, height);
+  }
+
+  /**
+   * 曲线（Curve）
+   * 控制点：≥2 个；2 个点时退化为直线
+   */
+  static createCurve(points, options = {}) {
+    if (!points || points.length < 2) return [];
+
+    const lnglatPoints = points.map(p => this.toLonLat(p));
+    const height = points[0][2] || 0;
+
+    // 2 个点时直接连成直线，避免曲线插值算法因点数不足报错
+    if (points.length === 2) {
+      return this.toPositions(lnglatPoints, height);
+    }
+
+    const t = options.t ?? 0.3;
+    const curvePoints = this.getCurvePoints(t, lnglatPoints);
+    return this.toPositions(curvePoints, height);
+  }
+}