huweili-cesium 1.2.70 → 1.2.71

package/js/geometry.js

@@ -15,6 +15,205 @@ export function geometryConfig() {
   // 获取地图store实例
   const mapStore = useMapStore()
 
+  /**
+   * 创建锥形波效果
+   * @param {Object} options - 锥形波配置选项
+   * @param {string} options.id - 效果唯一标识符
+   * @param {number[]} options.positions - 位置数组 [lng, lat, height]
+   * @param {number} options.heading - 指向方向（度）
+   * @param {number} options.pitch - 俯仰角度（度）
+   * @param {number} options.length - 圆锥高
+   * @param {number} options.bottomRadius - 底部半径
+   * @param {number} options.thickness - 厚度
+   * @param {string} options.color - 颜色（默认 '#00FFFF'）
+   * @param {string} options.mapId - 地图实例ID
+   * @returns {Cesium.Primitive|null} 创建的锥形波实体，若创建失败则返回null
+   */
+  const conicalWave = (options) => {
+    const map = mapStore.getMap(options.mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return null
+    }
+
+    if (mapStore.getGraphicMap(options.id, options.mapId)) {
+      console.warn(`id: ${options.id} 效果已存在`)
+      return null
+    }
+
+    const [lng, lat, height = 0] = options.positions
+    const vertexPosition = Cesium.Cartesian3.fromDegrees(lng, lat, height)
+    const heading = Cesium.Math.toRadians(options.heading || 0)
+    const pitch = Cesium.Math.toRadians(options.pitch || 0)
+    const hpr = new Cesium.HeadingPitchRoll(heading, pitch, 0)
+    const modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(vertexPosition, hpr)
+    const translationMatrix = Cesium.Matrix4.fromTranslation(new Cesium.Cartesian3(0, 0, -(options.length || 0) / 2))
+    Cesium.Matrix4.multiply(modelMatrix, translationMatrix, modelMatrix)
+
+    const primitive = new Cesium.Primitive({
+      geometryInstances: new Cesium.GeometryInstance({
+        geometry: new Cesium.CylinderGeometry({
+          length: options.length,
+          topRadius: 0,
+          bottomRadius: options.bottomRadius
+        })
+      }),
+      appearance: new Cesium.MaterialAppearance({
+        material: new Cesium.Material({
+          fabric: {
+            uniforms: {
+              color: Cesium.Color.fromCssColorString(options.color || '#00FFFF').withAlpha(0.7),
+              duration: 6000,
+              repeat: 30,
+              offset: 0,
+              thickness: options.thickness || 0.3
+            },
+            source: `
+              uniform vec4 color;
+              uniform float duration;
+              uniform float repeat;
+              uniform float offset;
+              uniform float thickness;
+
+              czm_material czm_getMaterial(czm_materialInput materialInput) {
+                czm_material material = czm_getDefaultMaterial(materialInput);
+                float sp = 1.0/repeat;
+                vec2 st = materialInput.st;
+                float dis = distance(st, vec2(0.5));
+                float time = mod((czm_frameNumber / 60.0) / (duration / 1000.0), 1.0);
+                float m = mod(dis + offset - time, sp);
+                float a = step(sp*(1.0-thickness), m);
+                material.diffuse = color.rgb;
+                material.alpha = a * color.a;
+                return material;
+              }
+            `
+          },
+          translucent: true
+        }),
+        translucent: true
+      }),
+      modelMatrix,
+      asynchronous: false
+    })
+
+    primitive._originalOptions = { ...options }
+    mapStore.setGraphicMap(options.id, primitive, options.mapId)
+    map.scene.primitives.add(primitive)
+    return primitive
+  }
+
+  /**
+   * 更新圆锥体高度 / 位置
+   * @param options
+   *        id        圆锥体唯一标识
+   *        length    新的高度（米）（可选）
+   *        positions 新的 [lng, lat, height]（可选）
+   *        mapId     地图实例ID
+   * @returns boolean  成功 true / 失败 false
+   */
+  const updateConeLengthOrPosition = (options) => {
+    const { id, length, positions, mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return false
+    }
+
+    if (length === undefined && positions === undefined) {
+      console.error('更新圆锥体高度 / 位置：必须提供高度或位置')
+      return false
+    }
+
+    const oldPrimitive = mapStore.getGraphicMap(id, mapId)
+    if (!oldPrimitive) {
+      console.error(`id: ${id} 圆锥体不存在`)
+      return false
+    }
+
+    try {
+      const opts = { ...oldPrimitive._originalOptions }
+      if (length !== undefined) opts.length = length
+      if (positions !== undefined) opts.positions = positions
+
+      const [lng, lat, height = 0] = opts.positions
+      const vertexPos = Cesium.Cartesian3.fromDegrees(lng, lat, height)
+      const hpr = new Cesium.HeadingPitchRoll(
+        Cesium.Math.toRadians(opts.heading || 0),
+        Cesium.Math.toRadians(opts.pitch || 0),
+        0
+      )
+      const modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(vertexPos, hpr)
+      const trans = Cesium.Matrix4.fromTranslation(new Cesium.Cartesian3(0, 0, -(opts.length || 0) / 2))
+      Cesium.Matrix4.multiply(modelMatrix, trans, modelMatrix)
+
+      const newPrimitive = new Cesium.Primitive({
+        geometryInstances: new Cesium.GeometryInstance({
+          geometry: new Cesium.CylinderGeometry({
+            length: opts.length,
+            topRadius: 0,
+            bottomRadius: opts.bottomRadius
+          })
+        }),
+        appearance: oldPrimitive.appearance,
+        modelMatrix,
+        asynchronous: false
+      })
+
+      newPrimitive._originalOptions = opts
+      map.scene.primitives.remove(oldPrimitive)
+      map.scene.primitives.add(newPrimitive)
+      mapStore.setGraphicMap(id, newPrimitive, mapId)
+      return true
+    } catch (e) {
+      console.error('更新圆锥体失败:', e)
+      return false
+    }
+  }
+
+  /**
+   * 更新圆锥体姿态
+   * @param {Object} options 更新配置参数
+   * @param {string} options.id - 圆锥体ID
+   * @param {number} options.heading - 新的指向方向（度）
+   * @param {number} options.pitch - 新的俯仰角度（度）
+   * @param {string} options.mapId - 地图实例ID
+   * @returns {boolean} 更新成功返回true，否则返回false
+   */
+  const updateConePose = (options) => {
+    const { id, heading = 0, pitch = 0, mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return false
+    }
+
+    const primitive = mapStore.getGraphicMap(id, mapId)
+    if (!primitive) {
+      console.error(`id: ${id} 圆锥体不存在`)
+      return false
+    }
+
+    try {
+      const opts = primitive._originalOptions || {}
+      const [lng, lat, height = 0] = opts.positions || [0, 0, 0]
+      const vertexPos = Cesium.Cartesian3.fromDegrees(lng, lat, height)
+      const hpr = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(heading), Cesium.Math.toRadians(pitch), 0)
+      const modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(vertexPos, hpr)
+      const trans = Cesium.Matrix4.fromTranslation(new Cesium.Cartesian3(0, 0, -(opts.length || 0) / 2))
+      Cesium.Matrix4.multiply(modelMatrix, trans, modelMatrix)
+
+      primitive.modelMatrix = modelMatrix
+      opts.heading = heading
+      opts.pitch = pitch
+      mapStore.setGraphicMap(id, primitive, mapId)
+      return true
+    } catch (error) {
+      console.error(`更新圆锥体姿态失败:`, error)
+      return false
+    }
+  }
+
   /**
    * 创建四棱锥波效果
    * @param {string} options.id - 效果唯一标识符
@@ -293,6 +492,9 @@ export function geometryConfig() {
   };
 
   return {
+    conicalWave,
+    updateConeLengthOrPosition,
+    updateConePose,
     rectangularPyramidWave,
     updateRectangularPyramidWavePose,
     updateRectangularPyramidPoseFast,

package/js/movePath.js

@@ -10,6 +10,7 @@
  */
 import * as Cesium from 'cesium'
 import { useMapStore } from './stores/mapStore.js'
+import { DroneConfig } from './config/index.js'
 
 const scratchCutoffTime = new Cesium.JulianDate()
 
@@ -47,18 +48,25 @@ export function movePathConfig() {
 
     const positions = trailData.positions
     const renderPositions = trailData.renderPositions || (trailData.renderPositions = positions.map(point => point.position).filter(Boolean))
+    const lastPoint = positions[positions.length - 1]
+    const lastPosition = lastPoint?.position
+    const minTrailDistanceSquared = trailData.minTrailDistanceSquared || (trailData.minTrailDistanceSquared = DroneConfig.minTrailDistance * DroneConfig.minTrailDistance)
 
-    // 轨迹必须和无人机完全同步：每次直接复用同一个点，避免出现一帧延迟的间隙。
+    // 降低轨迹追加频率：距离小于5米且距离上次追加不足300ms时，不追加新轨迹点。
+    if (lastPoint && lastPosition) {
+      const distanceSquared = Cesium.Cartesian3.distanceSquared(lastPosition, newPosition)
+      const elapsedSeconds = Cesium.JulianDate.secondsDifference(currentTime, lastPoint.timestamp)
+      if (distanceSquared < minTrailDistanceSquared || elapsedSeconds < DroneConfig.minTrailIntervalSeconds) {
+        return trailData
+      }
+    }
+
+    // 添加新的轨迹点，包含位置和时间戳
     const clonedPosition = Cesium.Cartesian3.clone(newPosition)
     positions.push({ position: clonedPosition, timestamp: Cesium.JulianDate.clone(currentTime) })
     renderPositions.push(clonedPosition)
     trailData.lastUpdateTime = currentTime
 
-    // 立刻通知 Cesium 重新取轨迹数组，避免 CallbackProperty 在下一帧才刷新。
-    if (trailData.entity?.polyline) {
-      trailData.entity.polyline.positions = renderPositions
-    }
-
     // 清理旧轨迹点，只保留最近指定时间的轨迹
     const trailTime = mapStore.getTrailTime(mapId)
     if (trailTime === -1 || positions.length <= 1) return trailData

package/js/movePoint.js

@@ -240,6 +240,12 @@ export function movePointConfig(baseUrl) {
       return modelEntity
     }
 
+    // 初始化复用对象，避免上百个无人机高频移动时反复创建临时对象
+    modelEntity.scratchPosition ||= new Cesium.Cartesian3()
+    modelEntity.scratchTargetPosition ||= new Cesium.Cartesian3()
+    modelEntity.scratchFlightEndTime ||= new Cesium.JulianDate()
+    modelEntity.scratchFarFutureTime ||= new Cesium.JulianDate()
+
     // 如果存在实体，确保实体属性实时同步
     const info = modelEntity.info || (modelEntity.info = {})
     info.pointId = pointId
@@ -254,46 +260,112 @@ export function movePointConfig(baseUrl) {
     info.distance = options.distance || ''
     info.receiveTime = options.receiveTime || ''
 
-    // 约定：收到一次无人机数据，就立刻把无人机定位到这个点，同时拖尾追加同一个点。
-    // 不再做平滑插值，避免无人机和轨迹之间出现滞后。
-    const targetPosition = Cesium.Cartesian3.fromDegrees(lng, lat, height)
+    // ========== 实时位置获取开始 ==========
+    const positionProperty = modelEntity.positionProperty || modelEntity.entity?.position
+    let currentRealPosition = positionProperty?.getValue?.(currentTime, modelEntity.scratchPosition)
+
+    if (!currentRealPosition && modelEntity.currentPosition) {
+      // 插值属性取不到值时，回退到上一次缓存的真实位置。
+      currentRealPosition = Cesium.Cartesian3.clone(modelEntity.currentPosition, modelEntity.scratchPosition)
+    }
+
+    if (!currentRealPosition) {
+      // 仍没有当前位置时，使用本次传入坐标作为起点。
+      currentRealPosition = Cesium.Cartesian3.fromDegrees(lng, lat, height, modelEntity.scratchPosition)
+    }
+
+    // getValue 复用 scratchPosition，后续 targetPosition 也会复用其它 scratch，先把当前位置固定到独立对象，避免被后续计算覆盖。
+    currentRealPosition = Cesium.Cartesian3.clone(currentRealPosition, modelEntity.currentPosition || new Cesium.Cartesian3())
+    modelEntity.currentPosition = currentRealPosition
+    // ========== 实时位置获取结束 ==========
+
+    // ========== 保留轨迹 ==========
+    // 在飞行开始前，先记录当前点，保证轨迹不会从新目标点突兀开始。
+    moveDroneTrail({
+      pointId,
+      newPosition: currentRealPosition,
+      mapId
+    })
 
-    // 终止旧飞行监听，避免历史插值逻辑继续影响当前定位。
+    // ========== 终止当前所有飞行状态 ==========
+    // 终止旧飞行监听；飞行插值和轨迹更新都在同一个 onTick 中处理。
     if (modelEntity.flightEndListener) {
       map.clock.onTick.removeEventListener(modelEntity.flightEndListener)
       modelEntity.flightEndListener = null
     }
 
     modelEntity.isFlying = false
-    modelEntity.currentPosition = Cesium.Cartesian3.clone(targetPosition, modelEntity.currentPosition || new Cesium.Cartesian3())
-    modelEntity.positionProperty = {
-      getValue: () => modelEntity.currentPosition
+    // 每次移动都重建采样属性，只保留“当前位置 -> 新目标点”的最新飞行段。
+    modelEntity.positionProperty = new Cesium.SampledPositionProperty()
+    modelEntity.positionProperty.forwardExtrapolationType = Cesium.ExtrapolationType.HOLD
+    modelEntity.positionProperty.backwardExtrapolationType = Cesium.ExtrapolationType.HOLD
+    modelEntity.positionProperty.forwardExtrapolationDuration = Number.POSITIVE_INFINITY
+    modelEntity.positionProperty.backwardExtrapolationDuration = Number.POSITIVE_INFINITY
+    modelEntity.positionProperty.addSample(currentTime, currentRealPosition)
+    modelEntity.entity.position = modelEntity.positionProperty
+
+    // ========== 计算新的飞行路径 ==========
+    const targetPosition = Cesium.Cartesian3.fromDegrees(lng, lat, height)
+    const distanceSquared = Cesium.Cartesian3.distanceSquared(currentRealPosition, targetPosition)
+
+    // 距离过近则直接定位
+    if (distanceSquared < MIN_DRONE_MOVE_DISTANCE_SQUARED) {
+      modelEntity.currentPosition = Cesium.Cartesian3.clone(targetPosition, modelEntity.currentPosition)
+      modelEntity.positionProperty.addSample(currentTime, modelEntity.currentPosition)
+
+      moveDroneTrail({
+        pointId,
+        newPosition: modelEntity.currentPosition,
+        mapId
+      })
+      return modelEntity
     }
-    modelEntity.info = modelEntity.info || {}
-    modelEntity.info.pointId = pointId
-    modelEntity.info.lng = lng
-    modelEntity.info.lat = lat
-    modelEntity.info.height = height
-    modelEntity.info.speed = speed
-    modelEntity.info.flyingHandName = options.flyingHandName || ''
-    modelEntity.info.flyingHandPhone = options.flyingHandPhone || ''
-    modelEntity.info.flyingHandPosition = options.flyingHandPosition || ''
-    modelEntity.info.frequencyBand = options.frequencyBand || ''
-    modelEntity.info.distance = options.distance || ''
-    modelEntity.info.receiveTime = options.receiveTime || ''
-
-    // 直接使用当前点覆盖实体位置，不再依赖 SampledPositionProperty 做插值。
-    if (modelEntity.entity) {
-      modelEntity.entity.position = targetPosition
+
+    // 按距离和速度计算本段飞行时长，由 SampledPositionProperty 自动插值位置。
+    const flightDuration = Math.sqrt(distanceSquared) / speed
+    const flightEndTime = Cesium.JulianDate.addSeconds(currentTime, flightDuration, new Cesium.JulianDate())
+
+    if (!map.clock.shouldAnimate) {
+      map.clock.shouldAnimate = true
     }
-    modelEntity.positionProperty = null
 
-    // 拖尾直接追加同一个点。
-    moveDroneTrail({
-      pointId,
-      newPosition: modelEntity.currentPosition,
-      mapId
-    })
+    // 不再为每个无人机改全局 clock.startTime/stopTime，避免多无人机互相抢时钟范围。
+    modelEntity.positionProperty.addSample(flightEndTime, targetPosition)
+    modelEntity.isFlying = true
+
+    const flightTickListener = (clock) => {
+      if (!modelEntity.isFlying) return
+
+      const isFinished = Cesium.JulianDate.compare(clock.currentTime, flightEndTime) >= 0
+      const tickPosition = isFinished
+        ? targetPosition
+        : modelEntity.positionProperty.getValue(clock.currentTime, modelEntity.scratchPosition)
+
+      if (tickPosition) {
+        // 每帧缓存插值后的真实位置，并同步追加轨迹点。
+        modelEntity.currentPosition = Cesium.Cartesian3.clone(tickPosition, modelEntity.currentPosition)
+        moveDroneTrail({
+          pointId,
+          newPosition: modelEntity.currentPosition,
+          mapId
+        })
+      }
+
+      if (!isFinished) return
+
+      modelEntity.currentPosition = Cesium.Cartesian3.clone(targetPosition, modelEntity.currentPosition)
+      modelEntity.isFlying = false
+
+      // 到达目标后追加远期采样点，让实体在终点保持不动。
+      const farFutureTime = Cesium.JulianDate.addSeconds(flightEndTime, DEFAULT_FAR_FUTURE_SECONDS, new Cesium.JulianDate())
+      modelEntity.positionProperty.addSample(farFutureTime, modelEntity.currentPosition)
+
+      clock.onTick.removeEventListener(flightTickListener)
+      modelEntity.flightEndListener = null
+    }
+
+    modelEntity.flightEndListener = flightTickListener
+    map.clock.onTick.addEventListener(flightTickListener)
 
     return modelEntity
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huweili-cesium",
-  "version": "1.2.70",
+  "version": "1.2.71",
   "description": "基于 Cesium 的地图工具库（无人机态势、轨迹、围栏、工具栏等）",
   "type": "module",
   "main": "./index.js",