huweili-cesium 1.1.13 → 1.1.14

package/index.vue

@@ -205,6 +205,9 @@ const initCesium = async () => {
     // 开启/关闭 动态大气光照从太阳开始
     map.scene.globe.dynamicAtmosphereLightingFromSun = mapOptions.scene.globe.dynamicAtmosphereLightingFromSun;
 
+    // 设置场景模式（2D/3D）
+    const sceneMode = mapOptions.scene.sceneMode || '3D';
+    mapStore.setSceneMode(sceneMode, props.mapId);
     // 设置场景模式（2D/3D）时候的 正交投影（2D）还是透视投影（3D）
     switch(mapOptions.scene.sceneMode){
       case '2D':
@@ -229,10 +232,6 @@ const initCesium = async () => {
       alt: mapOptions.scene.center.alt,
     }, props.mapId)
     mapStore.setMap(map, props.mapId)
-
-    // 设置场景模式（2D/3D）
-    const sceneMode = mapOptions.scene.sceneMode || '3D';
-    mapStore.setSceneMode(sceneMode, props.mapId);
     
     // 初始化半球区域
     const center = mapOptions.scene.center || {}

package/js/basis.js

@@ -10,19 +10,6 @@
  */
 import * as Cesium from 'cesium'
 import { useMapStore } from './stores/mapStore.js'
-import {
-  bindFrustumConstructors,
-  createOrthographicFrustum,
-  createPerspectiveFrustum,
-  ensure3DCompatibleFrustum,
-  detectDuplicateCesium,
-  getCanvasAspectRatio,
-  isOrthographicFrustum,
-  isPerspectiveFrustum,
-  isValid3DFrustum,
-  warnDuplicateCesiumOnce,
-} from './utils/frustumCompat.js'
-import { getCesium } from './utils/cesiumContext.js'
 
 export function basicConfig() {
 
@@ -135,7 +122,7 @@ export function basicConfig() {
     const finalTargetAlt = targetAlt !== undefined ? targetAlt : (centerInfo.targetAlt || 0)
     
     // 检查当前是正交投影（2D）还是透视投影（3D）
-    const isOrthographic = isOrthographicFrustum(map.camera.frustum)
+    const isOrthographic = map.camera.frustum instanceof Cesium.OrthographicFrustum
     
     if (isOrthographic) {
       const orthoWidth = computeOrthoWidthFromHeight(map, finalAltitude)
@@ -201,20 +188,12 @@ export function basicConfig() {
   const restorePerspectiveFrustum = (map) => {
     if (!map) return
 
-    bindFrustumConstructors(map)
     const currentFrustum = map.camera.frustum
-
-    if (isPerspectiveFrustum(currentFrustum)) {
-      currentFrustum.fov = getPerspectiveVerticalFovRadians()
-      currentFrustum.aspectRatio = getCanvasAspectRatio(map)
-      return
-    }
-
-    const perspectiveFrustum = createPerspectiveFrustum(map, currentFrustum)
+    const perspectiveFrustum = new Cesium.PerspectiveFrustum()
     perspectiveFrustum.fov = getPerspectiveVerticalFovRadians()
-    perspectiveFrustum.aspectRatio = getCanvasAspectRatio(map)
-    perspectiveFrustum.near = currentFrustum?.near || 1.0
-    perspectiveFrustum.far = currentFrustum?.far || 10000000.0
+    perspectiveFrustum.aspectRatio = map.canvas.clientWidth / map.canvas.clientHeight
+    perspectiveFrustum.near = currentFrustum.near || 1.0
+    perspectiveFrustum.far = currentFrustum.far || 10000000.0
     map.camera.frustum = perspectiveFrustum
   }
 
@@ -259,36 +238,28 @@ export function basicConfig() {
   const applyOrthographicFrustum = (map, viewHeight, orthoWidth) => {
     if (!map) return
 
-    bindFrustumConstructors(map)
-    warnDuplicateCesiumOnce(map)
-    // 双份 cesium 时勿替换为正交视锥（instanceof 与引擎不一致）；保持透视 + 俯视姿态
-    if (detectDuplicateCesium(map, getCesium())) {
-      return
-    }
-
-    const current = map.camera.frustum
+    const canvas = map.canvas
+    const frustum = new Cesium.OrthographicFrustum()
+    const width = canvas.clientWidth
+    const height = canvas.clientHeight
 
     let widthValue
     if (Number.isFinite(orthoWidth) && orthoWidth > 0) {
       widthValue = orthoWidth
     } else if (Number.isFinite(viewHeight) && viewHeight > 0) {
       widthValue = computeOrthoWidthFromHeight(map, viewHeight)
-    } else if (isPerspectiveFrustum(current)) {
-      const cameraHeight = map.camera.positionCartographic?.height ?? 10000
+    } else if (map.scene.camera.frustum instanceof Cesium.PerspectiveFrustum) {
+      const cameraHeight = map.scene.camera.positionCartographic?.height ?? 10000
       widthValue = computeOrthoWidthFromHeight(map, cameraHeight)
     } else {
-      widthValue = current?.width || 20000
+      widthValue = map.scene.camera.frustum.width || 20000
     }
 
-    const frustum = isOrthographicFrustum(current)
-      ? current
-      : createOrthographicFrustum()
-
     frustum.width = widthValue
-    frustum.aspectRatio = getCanvasAspectRatio(map)
+    frustum.aspectRatio = width / height
     frustum.near = 0.1
     frustum.far = 10000000.0
-    map.camera.frustum = frustum
+    map.scene.camera.frustum = frustum
   }
 
   /**
@@ -421,7 +392,7 @@ export function basicConfig() {
     }
     
     const camera = map.camera
-    const isOrthographic = isOrthographicFrustum(camera.frustum)
+    const isOrthographic = camera.frustum instanceof Cesium.OrthographicFrustum
 
     let currentMode
     if (isOrthographic) {
@@ -448,7 +419,7 @@ export function basicConfig() {
    */
   const getEffective2DOrthoWidth = (map) => {
     const frustum = map?.camera?.frustum
-    if (!isOrthographicFrustum(frustum)) return 0
+    if (!(frustum instanceof Cesium.OrthographicFrustum)) return 0
     if (frustum.width > 0) return frustum.width
 
     const cameraHeight = map?.camera?.positionCartographic?.height
@@ -612,7 +583,7 @@ export function basicConfig() {
     const { distance2D, distance3D } = options
 
     const camera = map.camera
-    const isOrthographic = isOrthographicFrustum(camera.frustum)
+    const isOrthographic = camera.frustum instanceof Cesium.OrthographicFrustum
 
     let currentMode
     if (isOrthographic) {
@@ -626,35 +597,6 @@ export function basicConfig() {
     return { success: true, currentMode }
   }
 
-  /**
-   * 场景模式切换（如 Cesium 自带 sceneModePicker）后修复不兼容的视锥体
-   * @param {import('cesium').Viewer} map
-   * @param {string=} mapId
-   */
-  const setupFrustumGuard = (map, mapId) => {
-    if (!map?.scene?.morphComplete) return
-
-    map.scene.morphComplete.addEventListener(() => {
-      const mode = map.scene.mode
-      if (
-        mode !== Cesium.SceneMode.SCENE3D &&
-        mode !== Cesium.SceneMode.COLUMBUS_VIEW
-      ) {
-        return
-      }
-
-      if (isValid3DFrustum(map.camera.frustum)) return
-
-      const preferOrtho = mapStore.getSceneMode(mapId) === '2D'
-      ensure3DCompatibleFrustum(map, preferOrtho)
-      if (preferOrtho) {
-        applyOrthographicFrustum(map)
-      } else {
-        restorePerspectiveFrustum(map)
-      }
-    })
-  }
-
   return {
     isInChina,
     mouseController,
@@ -675,8 +617,6 @@ export function basicConfig() {
     set2DView,
     set3DView,
     applyOrthographicFrustum,
-    restorePerspectiveFrustum,
-    bindFrustumConstructors,
-    setupFrustumGuard,
+    restorePerspectiveFrustum
   }
 }

package/js/hemisphere.js

@@ -1,360 +1,358 @@
-/**
- * 半球体实体管理模块
- * 
- * 提供在Cesium地图上创建、更新、移动和删除半球体实体的功能
- * 支持自定义半球体的位置、半径、颜色等属性
- * 
- * @author huweili
- * @email czxyhuweili@163.com
- * @version 1.0.0
- */
-import * as Cesium from 'cesium'
-import { BaseConfig } from './config/index.js';
-import { useMapStore } from './stores/mapStore.js'
-import { createViewerColor, getCesium } from './utils/cesiumContext.js'
-
-/**
- * 半球体实体管理配置函数
- * 初始化半球体管理模块，返回半球体操作相关方法
- * 
- * @returns {Object} 半球体操作方法集合
- */
-export function hemisphereConfig() {
-
-  // 获取地图store实例
-  const mapStore = useMapStore()
-
-  // 从配置中心读取 labelEntity 应该处于的角度，并确保在0到90度之间
-  const radians = Cesium.Math.toRadians(BaseConfig.hemisphereLabelAngle);
-  const hemisphereLabelAngle = Math.max(0, Math.min(Math.PI / 2, radians));
-
-  /**
-   * 格式化半球半径标签
-   * 将米为单位的半径值转换为千米，并添加km单位
-   * @param {number|string} radius - 半径值（米）
-   * @returns {string} - 格式化后的半径标签，如 "3km"
-   */
-  const formatHemisphereRadiusLabel = (radius) => {
-    const radiusValue = Number(radius);
-    if (!Number.isFinite(radiusValue)) {
-      return '';
-    }
-    return `${radiusValue / 1000}km`;
-  }
-
-  /**
-   * 获取半球标签文本
-   * 组合标签名称和半径信息，生成完整的半球标签显示文本
-   * @param {string} label - 半球标签名称
-   * @param {number|string} radius - 半径值（米）
-   * @returns {string} - 完整的标签文本，如 "探测区\n半径：3km"
-   */
-  const getHemisphereLabelText = (label, radius) => {
-    const radiusLabel = formatHemisphereRadiusLabel(radius);
-    return radiusLabel ? `${label}\n${radiusLabel}` : label;
-  }
-
-  /**
-   * 【创建并设置半球体实体】
-   * 在指定位置创建一个半球体实体，支持自定义半径和颜色
-   * 半球体默认紧贴地面（高度为0），并设置为半透明效果
-   * 
-   * @param {Object} options 半球体配置参数
-   * @param {string} options.id 半球体唯一标识
-   * @param {number[]} options.center 半球体中心经纬度坐标 [longitude, latitude]
-   * @param {number} options.radius 半球体半径（米）
-   * @param {string} options.sphericalColor 半球体颜色（CSS颜色字符串）
-   * @param {string} options.label 半球体标签文本（可选）
-   * @param {string} options.labelBgColor 半球体标签背景颜色（CSS颜色字符串）
-   * @returns {Cesium.Entity|null} 创建的半球体实体，若创建失败则返回null
-   */
-  const setHemisphere = (options) => {
-    const { mapId } = options
-    const map = mapStore.getMap(mapId)
-    if (!map) {
-      console.error('地图实例不存在')
-      return null
-    }
-
-    if (mapStore.getGraphicMap(`${options.id}`, mapId)) {
-      console.warn(`id: ${options.id} 半球体实体已存在`) 
-      return null
-    }
-
-    // 经纬度转Cesium笛卡尔坐标（球心定位）
-    // 确保球心的高度为0，紧贴地面
-    const Cs = getCesium(mapId)
-    const centerCartesian = Cs.Cartesian3.fromDegrees(options.center[0], options.center[1], 0);
-
-    // 使用Entity方式创建半球体（更稳定可靠）
-    const hemisphereEntity = map.entities.add({
-      position: centerCartesian,
-      ellipsoid: {
-        radii: new Cs.Cartesian3(options.radius, options.radius, options.radius),
-        material: createViewerColor(mapId, options.sphericalColor),
-        // 使用maximumCone和minimumCone创建半球
-        maximumCone: 0, // 上半球（z轴正方向）
-        minimumCone: Math.PI / 2 // 从z轴正方向到水平面（90度）
-      }
-    });
-
-    // 保存原始参数，用于后面计算
-    hemisphereEntity._originalOptions = { ...options };
-
-    // 计算标签位置（半球体表面右侧）
-    // 使用笛卡尔坐标系确保标签始终在半球体外侧
-    // 使用全局变量 hemisphereLabelAngle 控制仰角
-    const localX = options.radius * Math.cos(hemisphereLabelAngle);
-    const localZ = options.radius * Math.sin(hemisphereLabelAngle);
-    
-    // 确保最小高度
-    const safeZ = Math.max(localZ, 50);
-    
-    // 创建局部偏移向量
-    const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
-
-    // 将局部偏移转换到世界坐标系
-    const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(centerCartesian, map.scene.globe.ellipsoid);
-    
-    // 计算最终标签位置：球心 + 偏移向量
-    const labelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
-
-    // 创建独立的文本框Entity
-    let labelEntity = null;
-    if (options.label) {
-      labelEntity = map.entities.add({
-        position: new Cesium.CallbackProperty(() => {
-          return labelPosition;
-        }, false),
-        label: {
-          text: getHemisphereLabelText(options.label, options.radius),
-          font: '10px Microsoft YaHei',
-          fillColor: Cesium.Color.WHITE,
-          // style: Cesium.LabelStyle.FILL_AND_OUTLINE,
-          // 确保背景显示的关键属性
-          showBackground: true,
-          backgroundColor: Cesium.Color.fromCssColorString(options.labelBgColor), // 背景颜色
-          backgroundPadding: new Cesium.Cartesian2(3, 3),
-          // 定位属性 - 标签在右手边
-          verticalOrigin: Cesium.VerticalOrigin.CENTER,
-          horizontalOrigin: Cesium.HorizontalOrigin.LEFT,
-          pixelOffset: new Cesium.Cartesian2(10, 0),
-          // 其他属性
-          eyeOffset: new Cesium.Cartesian3(0, 0, 0),
-          // disableDepthTestDistance: Number.POSITIVE_INFINITY,
-          distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 100000)
-        }
-      });
-      // 将文本框Entity也缓存到store中，使用id+_label作为键
-      mapStore.setGraphicMap(`${options.id}_label`, labelEntity, mapId);
-    }
-
-    // 将半球体缓存到 graphicMap 中，防止重复创建
-    mapStore.setGraphicMap(`${options.id}`, hemisphereEntity, mapId);
-
-    // 返回创建的半球体实体，方便调用者使用
-    return hemisphereEntity;
-  }
-
-  /**
-   * 【移动半球体实体位置】
-   * 更新指定ID的半球体实体到新的经纬度位置
-   * 
-   * @param {Object} options 移动配置参数
-   * @param {string} options.hemisphereId 半球体唯一标识
-   * @param {number[]} options.center 新的中心经纬度坐标 [longitude, latitude]
-   * @returns {null} 无返回值
-   */
-  const moveHemisphere = (options) => {
-    const { mapId } = options
-    const map = mapStore.getMap(mapId)
-    if (!map) {
-      console.error('地图实例不存在')
-      return null
-    }
-
-    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
-    if (!hemisphereEntity) {
-      console.warn(`id: ${options.hemisphereId} 半球体实体不存在`)
-      return null
-    }
-
-    // 更新半球体位置
-    const newPosition = Cesium.Cartesian3.fromDegrees(options.center[0], options.center[1], 0);
-    hemisphereEntity.position = newPosition;
-
-    // 检查是否存在独立的文本框Entity
-    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
-    if (labelEntity) {
-      // 从保存的原始参数中获取半径值
-      let radius = 1000; // 默认半径值
-      if (hemisphereEntity._originalOptions && hemisphereEntity._originalOptions.radius) {
-        radius = hemisphereEntity._originalOptions.radius;
-      }
-      // 计算标签新位置（半球体表面右侧）
-      const localX = radius * Math.cos(hemisphereLabelAngle);
-      const localZ = radius * Math.sin(hemisphereLabelAngle);
-      const safeZ = Math.max(localZ, 50);
-      
-      const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
-      const currentPosition = hemisphereEntity.position.getValue(Cesium.JulianDate.now());
-      
-      const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(currentPosition, map.scene.globe.ellipsoid);
-      const newLabelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
-      
-      // 使用CallbackProperty确保位置平滑更新
-      labelEntity.position = new Cesium.CallbackProperty(() => {
-        return newLabelPosition;
-      }, false);
-    }
-  }
-
-  /**
-   * 【更新半球体实体半径】
-   * 修改指定ID的半球体实体的半径大小
-   * 
-   * @param {Object} options 更新配置参数
-   * @param {string} options.mapId 地图实例ID
-   * @param {string} options.hemisphereId 半球体唯一标识
-   * @param {number} options.radius 新的半球体半径（米）
-   * @returns {null} 无返回值
-   */
-  const updateHemisphere = (options) => {
-    const { mapId } = options
-    const map = mapStore.getMap(mapId)
-    if (!map) {
-      console.error('地图实例不存在')
-      return null
-    }
-
-    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
-    if (!hemisphereEntity) {
-      console.error(`id: ${options.hemisphereId} 半球体实体不存在`)
-      return null
-    }
-
-    // 更新半球体半径
-    hemisphereEntity.ellipsoid.radii = new Cesium.Cartesian3(options.radius, options.radius, options.radius);
-
-    // 更新保存的原始参数中的半径值
-    if (hemisphereEntity._originalOptions) {
-      hemisphereEntity._originalOptions.radius = options.radius;
-    }
-
-    // 检查是否存在独立的文本框Entity
-    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
-    if (labelEntity) {
-      // 更新标签中的半径值
-      const originalLabel = hemisphereEntity._originalOptions?.label;
-      if (originalLabel && labelEntity.label) {
-        labelEntity.label.text = getHemisphereLabelText(originalLabel, options.radius);
-      }
-      
-      // 计算标签新位置（半球体表面右侧）
-      const localX = options.radius * Math.cos(hemisphereLabelAngle);
-      const localZ = options.radius * Math.sin(hemisphereLabelAngle);
-      const safeZ = Math.max(localZ, 50);
-      
-      const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
-      const currentPosition = hemisphereEntity.position.getValue(Cesium.JulianDate.now());
-      
-      const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(currentPosition, map.scene.globe.ellipsoid);
-      const newLabelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
-      
-      // 使用CallbackProperty确保位置平滑更新
-      labelEntity.position = new Cesium.CallbackProperty(() => {
-        return newLabelPosition;
-      }, false);
-    }
-  }
-
-  /**
-   * 解析半球唯一标识（与 setHemisphere 的 id 一致，兼容 hemisphereId）
-   */
-  const resolveHemisphereId = (options) => options.id ?? options.hemisphereId
-
-  /**
-   * 【控制半球体显示/隐藏】
-   * 根据 mapId 与半球唯一标识，同时控制半球体实体及其标签的可见性
-   *
-   * @param {Object} options
-   * @param {string} options.mapId 地图实例ID
-   * @param {string} options.id 半球体唯一标识（与 setHemisphere 的 id 一致）
-   * @param {string} [options.hemisphereId] 同 id，二选一
-   * @param {boolean} [options.visible=true] 是否显示
-   * @returns {{ success: boolean }} 操作结果
-   */
-  const setHemisphereVisible = (options) => {
-    const { mapId, visible = true } = options
-    const hemisphereId = resolveHemisphereId(options)
-
-    if (!hemisphereId) {
-      console.error('缺少半球体唯一标识 id / hemisphereId')
-      return { success: false }
-    }
-
-    const map = mapStore.getMap(mapId)
-    if (!map) {
-      console.error('地图实例不存在')
-      return { success: false }
-    }
-
-    const hemisphereEntity = mapStore.getGraphicMap(hemisphereId, mapId)
-    if (!hemisphereEntity) {
-      console.warn(`id: ${hemisphereId} 半球体实体不存在`)
-      return { success: false }
-    }
-
-    hemisphereEntity.show = visible
-
-    const labelEntity = mapStore.getGraphicMap(`${hemisphereId}_label`, mapId)
-    if (labelEntity) {
-      labelEntity.show = visible
-    }
-
-    return { success: true }
-  }
-
-  /**
-   * 【删除半球体实体】
-   * 移除指定ID的半球体实体，并从缓存中清除记录
-   * 
-   * @param {Object} options 删除配置参数
-   * @param {string} options.hemisphereId 半球体唯一标识
-   * @returns {null} 无返回值
-   */
-  const removeHemisphere = (options) => {
-    const { mapId } = options
-    const map = mapStore.getMap(mapId)
-    if (!map) {
-      console.error('地图实例不存在')
-      return null
-    }
-    
-    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
-    if (!hemisphereEntity) {
-      console.error(`id: ${options.hemisphereId} 半球体实体不存在`)
-      return null
-    }
-
-    // 删除半球体实体
-    map.entities.remove(hemisphereEntity);
-    // 从缓存中移除
-    mapStore.removeGraphicMap(`${options.hemisphereId}`, mapId);
-
-    // 检查并删除独立的文本框Entity
-    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
-    if (labelEntity) {
-      map.entities.remove(labelEntity);
-      mapStore.removeGraphicMap(`${options.hemisphereId}_label`, mapId);
-    }
-  }
-
-  return {
-    setHemisphere,
-    updateHemisphere,
-    removeHemisphere,
-    moveHemisphere,
-    setHemisphereVisible
-  }
+/**
+ * 半球体实体管理模块
+ * 
+ * 提供在Cesium地图上创建、更新、移动和删除半球体实体的功能
+ * 支持自定义半球体的位置、半径、颜色等属性
+ * 
+ * @author huweili
+ * @email czxyhuweili@163.com
+ * @version 1.0.0
+ */
+import * as Cesium from 'cesium'
+import { BaseConfig } from './config/index.js';
+import { useMapStore } from './stores/mapStore.js'
+
+/**
+ * 半球体实体管理配置函数
+ * 初始化半球体管理模块，返回半球体操作相关方法
+ * 
+ * @returns {Object} 半球体操作方法集合
+ */
+export function hemisphereConfig() {
+
+  // 获取地图store实例
+  const mapStore = useMapStore()
+
+  // 从配置中心读取 labelEntity 应该处于的角度，并确保在0到90度之间
+  const radians = Cesium.Math.toRadians(BaseConfig.hemisphereLabelAngle);
+  const hemisphereLabelAngle = Math.max(0, Math.min(Math.PI / 2, radians));
+
+  /**
+   * 格式化半球半径标签
+   * 将米为单位的半径值转换为千米，并添加km单位
+   * @param {number|string} radius - 半径值（米）
+   * @returns {string} - 格式化后的半径标签，如 "3km"
+   */
+  const formatHemisphereRadiusLabel = (radius) => {
+    const radiusValue = Number(radius);
+    if (!Number.isFinite(radiusValue)) {
+      return '';
+    }
+    return `${radiusValue / 1000}km`;
+  }
+
+  /**
+   * 获取半球标签文本
+   * 组合标签名称和半径信息，生成完整的半球标签显示文本
+   * @param {string} label - 半球标签名称
+   * @param {number|string} radius - 半径值（米）
+   * @returns {string} - 完整的标签文本，如 "探测区\n半径：3km"
+   */
+  const getHemisphereLabelText = (label, radius) => {
+    const radiusLabel = formatHemisphereRadiusLabel(radius);
+    return radiusLabel ? `${label}\n${radiusLabel}` : label;
+  }
+
+  /**
+   * 【创建并设置半球体实体】
+   * 在指定位置创建一个半球体实体，支持自定义半径和颜色
+   * 半球体默认紧贴地面（高度为0），并设置为半透明效果
+   * 
+   * @param {Object} options 半球体配置参数
+   * @param {string} options.id 半球体唯一标识
+   * @param {number[]} options.center 半球体中心经纬度坐标 [longitude, latitude]
+   * @param {number} options.radius 半球体半径（米）
+   * @param {string} options.sphericalColor 半球体颜色（CSS颜色字符串）
+   * @param {string} options.label 半球体标签文本（可选）
+   * @param {string} options.labelBgColor 半球体标签背景颜色（CSS颜色字符串）
+   * @returns {Cesium.Entity|null} 创建的半球体实体，若创建失败则返回null
+   */
+  const setHemisphere = (options) => {
+    const { mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return null
+    }
+
+    if (mapStore.getGraphicMap(`${options.id}`, mapId)) {
+      console.warn(`id: ${options.id} 半球体实体已存在`) 
+      return null
+    }
+
+    // 经纬度转Cesium笛卡尔坐标（球心定位）
+    // 确保球心的高度为0，紧贴地面
+    const centerCartesian = Cesium.Cartesian3.fromDegrees(options.center[0], options.center[1], 0);
+
+    // 使用Entity方式创建半球体（更稳定可靠）
+    const hemisphereEntity = map.entities.add({
+      position: centerCartesian,
+      ellipsoid: {
+        radii: new Cesium.Cartesian3(options.radius, options.radius, options.radius),
+        material: Cesium.Color.fromCssColorString(options.sphericalColor), // 设置半透明效果，0.5为透明度值（范围0-1）
+        // 使用maximumCone和minimumCone创建半球
+        maximumCone: 0, // 上半球（z轴正方向）
+        minimumCone: Math.PI / 2 // 从z轴正方向到水平面（90度）
+      }
+    });
+
+    // 保存原始参数，用于后面计算
+    hemisphereEntity._originalOptions = { ...options };
+
+    // 计算标签位置（半球体表面右侧）
+    // 使用笛卡尔坐标系确保标签始终在半球体外侧
+    // 使用全局变量 hemisphereLabelAngle 控制仰角
+    const localX = options.radius * Math.cos(hemisphereLabelAngle);
+    const localZ = options.radius * Math.sin(hemisphereLabelAngle);
+    
+    // 确保最小高度
+    const safeZ = Math.max(localZ, 50);
+    
+    // 创建局部偏移向量
+    const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
+
+    // 将局部偏移转换到世界坐标系
+    const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(centerCartesian, map.scene.globe.ellipsoid);
+    
+    // 计算最终标签位置：球心 + 偏移向量
+    const labelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
+
+    // 创建独立的文本框Entity
+    let labelEntity = null;
+    if (options.label) {
+      labelEntity = map.entities.add({
+        position: new Cesium.CallbackProperty(() => {
+          return labelPosition;
+        }, false),
+        label: {
+          text: getHemisphereLabelText(options.label, options.radius),
+          font: '10px Microsoft YaHei',
+          fillColor: Cesium.Color.WHITE,
+          // style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+          // 确保背景显示的关键属性
+          showBackground: true,
+          backgroundColor: Cesium.Color.fromCssColorString(options.labelBgColor), // 背景颜色
+          backgroundPadding: new Cesium.Cartesian2(3, 3),
+          // 定位属性 - 标签在右手边
+          verticalOrigin: Cesium.VerticalOrigin.CENTER,
+          horizontalOrigin: Cesium.HorizontalOrigin.LEFT,
+          pixelOffset: new Cesium.Cartesian2(10, 0),
+          // 其他属性
+          eyeOffset: new Cesium.Cartesian3(0, 0, 0),
+          // disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 100000)
+        }
+      });
+      // 将文本框Entity也缓存到store中，使用id+_label作为键
+      mapStore.setGraphicMap(`${options.id}_label`, labelEntity, mapId);
+    }
+
+    // 将半球体缓存到 graphicMap 中，防止重复创建
+    mapStore.setGraphicMap(`${options.id}`, hemisphereEntity, mapId);
+
+    // 返回创建的半球体实体，方便调用者使用
+    return hemisphereEntity;
+  }
+
+  /**
+   * 【移动半球体实体位置】
+   * 更新指定ID的半球体实体到新的经纬度位置
+   * 
+   * @param {Object} options 移动配置参数
+   * @param {string} options.hemisphereId 半球体唯一标识
+   * @param {number[]} options.center 新的中心经纬度坐标 [longitude, latitude]
+   * @returns {null} 无返回值
+   */
+  const moveHemisphere = (options) => {
+    const { mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return null
+    }
+
+    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
+    if (!hemisphereEntity) {
+      console.warn(`id: ${options.hemisphereId} 半球体实体不存在`)
+      return null
+    }
+
+    // 更新半球体位置
+    const newPosition = Cesium.Cartesian3.fromDegrees(options.center[0], options.center[1], 0);
+    hemisphereEntity.position = newPosition;
+
+    // 检查是否存在独立的文本框Entity
+    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
+    if (labelEntity) {
+      // 从保存的原始参数中获取半径值
+      let radius = 1000; // 默认半径值
+      if (hemisphereEntity._originalOptions && hemisphereEntity._originalOptions.radius) {
+        radius = hemisphereEntity._originalOptions.radius;
+      }
+      // 计算标签新位置（半球体表面右侧）
+      const localX = radius * Math.cos(hemisphereLabelAngle);
+      const localZ = radius * Math.sin(hemisphereLabelAngle);
+      const safeZ = Math.max(localZ, 50);
+      
+      const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
+      const currentPosition = hemisphereEntity.position.getValue(Cesium.JulianDate.now());
+      
+      const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(currentPosition, map.scene.globe.ellipsoid);
+      const newLabelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
+      
+      // 使用CallbackProperty确保位置平滑更新
+      labelEntity.position = new Cesium.CallbackProperty(() => {
+        return newLabelPosition;
+      }, false);
+    }
+  }
+
+  /**
+   * 【更新半球体实体半径】
+   * 修改指定ID的半球体实体的半径大小
+   * 
+   * @param {Object} options 更新配置参数
+   * @param {string} options.mapId 地图实例ID
+   * @param {string} options.hemisphereId 半球体唯一标识
+   * @param {number} options.radius 新的半球体半径（米）
+   * @returns {null} 无返回值
+   */
+  const updateHemisphere = (options) => {
+    const { mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return null
+    }
+
+    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
+    if (!hemisphereEntity) {
+      console.error(`id: ${options.hemisphereId} 半球体实体不存在`)
+      return null
+    }
+
+    // 更新半球体半径
+    hemisphereEntity.ellipsoid.radii = new Cesium.Cartesian3(options.radius, options.radius, options.radius);
+
+    // 更新保存的原始参数中的半径值
+    if (hemisphereEntity._originalOptions) {
+      hemisphereEntity._originalOptions.radius = options.radius;
+    }
+
+    // 检查是否存在独立的文本框Entity
+    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
+    if (labelEntity) {
+      // 更新标签中的半径值
+      const originalLabel = hemisphereEntity._originalOptions?.label;
+      if (originalLabel && labelEntity.label) {
+        labelEntity.label.text = getHemisphereLabelText(originalLabel, options.radius);
+      }
+      
+      // 计算标签新位置（半球体表面右侧）
+      const localX = options.radius * Math.cos(hemisphereLabelAngle);
+      const localZ = options.radius * Math.sin(hemisphereLabelAngle);
+      const safeZ = Math.max(localZ, 50);
+      
+      const localOffset = new Cesium.Cartesian3(localX, 0, safeZ);
+      const currentPosition = hemisphereEntity.position.getValue(Cesium.JulianDate.now());
+      
+      const enuToFixed = Cesium.Transforms.eastNorthUpToFixedFrame(currentPosition, map.scene.globe.ellipsoid);
+      const newLabelPosition = Cesium.Matrix4.multiplyByPoint(enuToFixed, localOffset, new Cesium.Cartesian3());
+      
+      // 使用CallbackProperty确保位置平滑更新
+      labelEntity.position = new Cesium.CallbackProperty(() => {
+        return newLabelPosition;
+      }, false);
+    }
+  }
+
+  /**
+   * 解析半球唯一标识（与 setHemisphere 的 id 一致，兼容 hemisphereId）
+   */
+  const resolveHemisphereId = (options) => options.id ?? options.hemisphereId
+
+  /**
+   * 【控制半球体显示/隐藏】
+   * 根据 mapId 与半球唯一标识，同时控制半球体实体及其标签的可见性
+   *
+   * @param {Object} options
+   * @param {string} options.mapId 地图实例ID
+   * @param {string} options.id 半球体唯一标识（与 setHemisphere 的 id 一致）
+   * @param {string} [options.hemisphereId] 同 id，二选一
+   * @param {boolean} [options.visible=true] 是否显示
+   * @returns {{ success: boolean }} 操作结果
+   */
+  const setHemisphereVisible = (options) => {
+    const { mapId, visible = true } = options
+    const hemisphereId = resolveHemisphereId(options)
+
+    if (!hemisphereId) {
+      console.error('缺少半球体唯一标识 id / hemisphereId')
+      return { success: false }
+    }
+
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return { success: false }
+    }
+
+    const hemisphereEntity = mapStore.getGraphicMap(hemisphereId, mapId)
+    if (!hemisphereEntity) {
+      console.warn(`id: ${hemisphereId} 半球体实体不存在`)
+      return { success: false }
+    }
+
+    hemisphereEntity.show = visible
+
+    const labelEntity = mapStore.getGraphicMap(`${hemisphereId}_label`, mapId)
+    if (labelEntity) {
+      labelEntity.show = visible
+    }
+
+    return { success: true }
+  }
+
+  /**
+   * 【删除半球体实体】
+   * 移除指定ID的半球体实体，并从缓存中清除记录
+   * 
+   * @param {Object} options 删除配置参数
+   * @param {string} options.hemisphereId 半球体唯一标识
+   * @returns {null} 无返回值
+   */
+  const removeHemisphere = (options) => {
+    const { mapId } = options
+    const map = mapStore.getMap(mapId)
+    if (!map) {
+      console.error('地图实例不存在')
+      return null
+    }
+    
+    const hemisphereEntity = mapStore.getGraphicMap(`${options.hemisphereId}`, mapId)
+    if (!hemisphereEntity) {
+      console.error(`id: ${options.hemisphereId} 半球体实体不存在`)
+      return null
+    }
+
+    // 删除半球体实体
+    map.entities.remove(hemisphereEntity);
+    // 从缓存中移除
+    mapStore.removeGraphicMap(`${options.hemisphereId}`, mapId);
+
+    // 检查并删除独立的文本框Entity
+    const labelEntity = mapStore.getGraphicMap(`${options.hemisphereId}_label`, mapId);
+    if (labelEntity) {
+      map.entities.remove(labelEntity);
+      mapStore.removeGraphicMap(`${options.hemisphereId}_label`, mapId);
+    }
+  }
+
+  return {
+    setHemisphere,
+    updateHemisphere,
+    removeHemisphere,
+    moveHemisphere,
+    setHemisphereVisible
+  }
 }

package/js/stores/mapStore.js

@@ -43,7 +43,6 @@ export const useMapStore = defineStore('map', () => {
         trailTime: 30, // 轨迹时间
         sceneMode: '3D', // 场景模式：'2D' 或 '3D'
         viewOrthoWidth: null, // 2D/3D 切换时保持稳定的正交可视宽度（米）
-        cesiumModule: null, // 与 Viewer 同一份 Cesium（由宿主传入，避免双份 cesium）
         rtkData: {
           latitude: 0, // RTK纬度
           longitude: 0, // RTK经度
@@ -153,13 +152,6 @@ export const useMapStore = defineStore('map', () => {
     getContext(mapId).map.value = mapInstance
   }
 
-  /** @param {typeof import('cesium')} cesiumModule */
-  const setCesiumModule = (cesiumModule, mapId) => {
-    getContext(mapId).cesiumModule = cesiumModule
-  }
-
-  const getCesiumModule = (mapId) => getContext(mapId).cesiumModule
-
   // 获取地图对象
   const getMap = (mapId) => {
     return getContext(mapId).map.value
@@ -377,8 +369,6 @@ export const useMapStore = defineStore('map', () => {
     clearAllGroundLinks,
     setMap,
     getMap,
-    setCesiumModule,
-    getCesiumModule,
     clearLayer,
     resetLayer,
     setTrailTime,

package/js/toolbar/zoomController.js

@@ -9,7 +9,6 @@
  */
 import * as Cesium from 'cesium'
 import { useMapStore } from '../stores/mapStore.js'
-import { isOrthographicFrustum } from '../utils/frustumCompat.js'
 
 /**
  * 创建缩放控制器
@@ -38,7 +37,7 @@ export function createZoomController() {
     if (!mapId) return
     if (isOrthographic) {
       const frustum = camera.frustum
-      if (isOrthographicFrustum(frustum) && frustum.width > 0) {
+      if (frustum instanceof Cesium.OrthographicFrustum && frustum.width > 0) {
         mapStore.setViewOrthoWidth(frustum.width, mapId)
       }
       return
@@ -76,7 +75,7 @@ export function createZoomController() {
     if (!map) return
 
     const camera = map.camera
-    const isOrthographic = isOrthographicFrustum(camera.frustum)
+    const isOrthographic = camera.frustum instanceof Cesium.OrthographicFrustum
     
     if (isOrthographic) {
       const position = camera.positionCartographic
@@ -86,7 +85,7 @@ export function createZoomController() {
         const newHeight = Math.max(100, currentHeight * factor)
         const heightRatio = currentHeight > 0 ? newHeight / currentHeight : factor
 
-        if (isOrthographicFrustum(frustum) && frustum.width > 0) {
+        if (frustum instanceof Cesium.OrthographicFrustum && frustum.width > 0) {
           frustum.width = Math.max(100, frustum.width * heightRatio)
         }
 
@@ -139,7 +138,7 @@ export function createZoomController() {
     if (!map) return
 
     const camera = map.camera
-    const isOrthographic = isOrthographicFrustum(camera.frustum)
+    const isOrthographic = camera.frustum instanceof Cesium.OrthographicFrustum
     
     if (isOrthographic) {
       const position = camera.positionCartographic
@@ -149,7 +148,7 @@ export function createZoomController() {
         const newHeight = Math.min(1000000, currentHeight * factor)
         const heightRatio = currentHeight > 0 ? newHeight / currentHeight : factor
 
-        if (isOrthographicFrustum(frustum) && frustum.width > 0) {
+        if (frustum instanceof Cesium.OrthographicFrustum && frustum.width > 0) {
           frustum.width = Math.min(10000000, frustum.width * heightRatio)
         }
 

package/package.json

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

package/js/utils/cesiumContext.js

@@ -1,36 +0,0 @@
-/**
- * 按 mapId 使用与 Viewer 同一份 Cesium 命名空间，避免 Vite 双份 cesium 导致 Color / Frustum instanceof 失败
- */
-import * as defaultCesium from 'cesium'
-import { useMapStore } from '../stores/mapStore.js'
-
-export function getCesium(mapId) {
-  return useMapStore().getCesiumModule(mapId) || defaultCesium
-}
-
-/** @param {typeof import('cesium')} cesiumModule */
-export function toCssColorString(color) {
-  if (color == null) return 'rgba(0,191,255,0.85)'
-  if (typeof color === 'string') return color
-  if (typeof color.toCssColorString === 'function') return color.toCssColorString()
-  if (typeof color.toCssHexString === 'function') {
-    const hex = color.toCssHexString()
-    const a = color.alpha ?? 1
-    return a < 1 ? `rgba(${Math.round(color.red * 255)},${Math.round(color.green * 255)},${Math.round(color.blue * 255)},${a})` : hex
-  }
-  if (color.red !== undefined) {
-    const { red, green, blue, alpha = 1 } = color
-    return `rgba(${Math.round(red * 255)},${Math.round(green * 255)},${Math.round(blue * 255)},${alpha})`
-  }
-  return String(color)
-}
-
-/**
- * 创建与当前 Viewer 同模块的 Color（用于 entity material / point.color）
- * @param {string=} mapId
- * @param {import('cesium').Color | string | object} value
- */
-export function createViewerColor(mapId, value) {
-  const Cs = getCesium(mapId)
-  return Cs.Color.fromCssColorString(toCssColorString(value))
-}

package/js/utils/frustumCompat.js

@@ -1,97 +0,0 @@
-/**
- * 与 Viewer 使用同一套 Cesium 构造视锥体，避免 Vite 双份 cesium 导致 Camera.update 报错
- */
-import * as Cesium from 'cesium'
-
-let PerspectiveFrustumCtor = Cesium.PerspectiveFrustum
-let OrthographicFrustumCtor = Cesium.OrthographicFrustum
-
-export function getFrustumTypeName(frustum) {
-  return frustum?.constructor?.name ?? ''
-}
-
-export function isPerspectiveFrustum(frustum) {
-  return getFrustumTypeName(frustum) === 'PerspectiveFrustum'
-}
-
-export function isOrthographicFrustum(frustum) {
-  return getFrustumTypeName(frustum) === 'OrthographicFrustum'
-}
-
-export function isValid3DFrustum(frustum) {
-  const name = getFrustumTypeName(frustum)
-  return name === 'PerspectiveFrustum' || name === 'OrthographicFrustum'
-}
-
-export function getCanvasAspectRatio(map) {
-  const canvas = map?.canvas
-  if (!canvas) return 1
-  const w = canvas.clientWidth || 1
-  const h = canvas.clientHeight || 1
-  return w / h
-}
-
-/**
- * 从已创建的 Viewer 上绑定与引擎一致的 Frustum 构造函数
- * @param {import('cesium').Viewer} map
- */
-export function bindFrustumConstructors(map) {
-  const frustum = map?.camera?.frustum
-  if (!frustum?.constructor) return
-
-  const name = getFrustumTypeName(frustum)
-  if (name === 'PerspectiveFrustum') {
-    PerspectiveFrustumCtor = frustum.constructor
-  } else if (name === 'OrthographicFrustum') {
-    OrthographicFrustumCtor = frustum.constructor
-  }
-}
-
-export function createPerspectiveFrustum(map, sourceFrustum) {
-  if (isPerspectiveFrustum(sourceFrustum)) {
-    return sourceFrustum
-  }
-  const frustum = new PerspectiveFrustumCtor()
-  frustum.near = sourceFrustum?.near ?? 1.0
-  frustum.far = sourceFrustum?.far ?? 10000000.0
-  return frustum
-}
-
-export function createOrthographicFrustum() {
-  return new OrthographicFrustumCtor()
-}
-
-export function ensure3DCompatibleFrustum(map, preferOrthographic = false) {
-  if (!map?.camera) return
-  const current = map.camera.frustum
-  if (isValid3DFrustum(current)) return
-
-  if (preferOrthographic && detectDuplicateCesium(map)) {
-    preferOrthographic = false
-  }
-
-  map.camera.frustum = preferOrthographic
-    ? createOrthographicFrustum()
-    : createPerspectiveFrustum(map, current)
-}
-
-let duplicateCesiumWarned = false
-
-/** Vite 未 dedupe cesium 时，库内 new 的 Frustum 与 Viewer 不是同一类 */
-export function detectDuplicateCesium(map, cesiumModule) {
-  const Cs = cesiumModule || Cesium
-  const frustum = map?.camera?.frustum
-  if (!frustum) return false
-  return (
-    getFrustumTypeName(frustum) === 'PerspectiveFrustum' &&
-    !(frustum instanceof Cs.PerspectiveFrustum)
-  )
-}
-
-export function warnDuplicateCesiumOnce(map) {
-  if (duplicateCesiumWarned || !detectDuplicateCesium(map)) return
-  duplicateCesiumWarned = true
-  console.warn(
-    '[huweili-cesium] 检测到两份 cesium 副本，正交视锥可能触发 Camera.update 报错。请在 vite.config 设置 resolve.dedupe: ["cesium"]，并将 cesium、huweili-cesium 加入 optimizeDeps.include。'
-  )
-}

package/postinstall.mjs

@@ -1,79 +0,0 @@
-/**
- * 依赖安装完成后在终端打印欢迎信息（npm / pnpm / yarn 均会触发 postinstall）
- * 放在包根目录，避免 .npmignore 的 scripts/ 导致发布包缺失
- */
-import { readFileSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const pkgRoot = resolve(__dirname)
-
-if (
-  process.env.CI === 'true' ||
-  process.env.CI === '1' ||
-  process.env.SKIP_POSTINSTALL_WELCOME === '1'
-) {
-  process.exit(0)
-}
-
-const initCwd = process.env.INIT_CWD ? resolve(process.env.INIT_CWD) : ''
-if (initCwd && initCwd === pkgRoot) {
-  process.exit(0)
-}
-
-const pkg = JSON.parse(readFileSync(resolve(pkgRoot, 'package.json'), 'utf8'))
-const { version = '?', name = 'huweili-cesium' } = pkg
-
-const npmUrl = `https://www.npmjs.com/package/${name}`
-
-function normalizeRepoUrl(repo) {
-  if (!repo) return ''
-  const raw = typeof repo === 'string' ? repo : repo.url
-  if (!raw) return ''
-  return raw
-    .replace(/^git\+/, '')
-    .replace(/^git:\/\//, 'https://')
-    .replace(/^git@github\.com:/, 'https://github.com/')
-    .replace(/\.git$/, '')
-}
-
-const repoUrl = normalizeRepoUrl(pkg.homepage || pkg.repository)
-
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  cyan: '\x1b[36m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  magenta: '\x1b[35m',
-  blue: '\x1b[34m',
-}
-
-const banner = `
-${c.cyan}${c.bold}  ╔══════════════════════════════════════════════════════════╗
-  ║                                                          ║
-  ║   🌍  huweili-cesium  ${c.green}v${version}${c.cyan}${c.bold}  —  Cesium 三维地图工具库已就绪   ║
-  ║                                                          ║
-  ╚══════════════════════════════════════════════════════════╝${c.reset}
-
-${c.yellow}${c.bold}  快速开始${c.reset}
-${c.dim}  ─────────────────────────────────────────────────────────${c.reset}
-  ${c.green}组件${c.reset}  import CesiumMap from ${c.cyan}'huweili-cesium'${c.reset}
-  ${c.green}工具${c.reset}  import { basicConfig } from ${c.cyan}'huweili-cesium'${c.reset}
-  ${c.green}按钮${c.reset}  import { createCustomToolbarButtons } from ${c.cyan}'huweili-cesium/customToolbarButtons'${c.reset}
-
-${c.yellow}${c.bold}  使用前请确认${c.reset}
-  ${c.dim}·${c.reset} 已安装 peer：${c.magenta}cesium · vue · pinia · mitt · qrcode${c.reset}
-  ${c.dim}·${c.reset} 已加载 ${c.cyan}constants.js${c.reset}（MapConfig / DroneConfig 等）
-  ${c.dim}·${c.reset} Vite：${c.cyan}resolve.dedupe: ['cesium']${c.reset} 或组件传 ${c.cyan}:cesium="Cesium"${c.reset}
-
-${c.yellow}${c.bold}  链接${c.reset}
-  ${c.dim}·${c.reset} npm  ${c.blue}${npmUrl}${c.reset}${repoUrl ? `\n  ${c.dim}·${c.reset} 仓库 ${c.blue}${repoUrl}${c.reset}` : ''}
-
-${c.dim}  文档见包内 README · 祝绘制愉快 🚁${c.reset}
-${c.dim}  关闭欢迎: set SKIP_POSTINSTALL_WELCOME=1${c.reset}
-`
-
-console.log(banner)