From 2622b9d511a4cec640ef2fbcd18b5cf2604644c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=89=88=E5=85=86=E5=A2=9E?= <你的邮箱@example.com>
Date: Wed, 5 Aug 2026 17:12:38 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=962d=E5=92=8C3d=E7=9A=84?=
 =?UTF-8?q?=E5=9C=B0=E5=9B=BE=E5=B1=95=E7=A4=BA=20=E4=BC=98=E5=8C=96?=
 =?UTF-8?q?=E6=BC=AB=E6=B8=B8=EF=BC=8C=E9=94=9A=E7=82=B9=E6=B7=BB=E5=8A=A0?=
 =?UTF-8?q?=E6=B7=A1=E5=85=A5=E6=B7=A1=E5=87=BA=E6=95=88=E6=9E=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 frontend/src/App.vue                          |   4 -
 frontend/src/components/gis/GisView.vue       |  18 -
 .../src/components/gis/TjCascadeChart.vue     |   4 +-
 frontend/src/components/gis/map.cesium.ts     | 985 ++++++++++++++----
 frontend/src/components/gis/map.class.ts      |   6 +-
 frontend/src/components/gis/map.d.ts          |   7 +
 frontend/src/components/gis/map.leaflet.ts    | 440 --------
 frontend/src/components/gis/map.ol.ts         | 351 ++++++-
 .../src/components/gis/ol/popup-manager.ts    |  92 +-
 .../components/gis/roam/ThreeDRoamManager.ts  |  39 +-
 .../components/gis/roam/ThreeDRoamPanel.vue   |  11 +
 .../src/components/mapController/index.vue    |  10 +-
 12 files changed, 1190 insertions(+), 777 deletions(-)
 delete mode 100644 frontend/src/components/gis/map.leaflet.ts

diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index 36f4ab18..01f126a5 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -7,10 +7,6 @@ const appStore = useAppStore();
 </script>
 
 <template>
-  <!-- 
-  1.地图抽吸
-  2.地图文字和点显示
-   -->
   <el-config-provider :locale="appStore.locale" :size="appStore.size">
     <a-config-provider :theme="usetTheme" :locale="locale">
       <router-view />
diff --git a/frontend/src/components/gis/GisView.vue b/frontend/src/components/gis/GisView.vue
index c52c139b..2baf126b 100644
--- a/frontend/src/components/gis/GisView.vue
+++ b/frontend/src/components/gis/GisView.vue
@@ -160,24 +160,6 @@ onUnmounted(() => {
   cursor: grab;
   z-index: 1;
 }
-/* 消除瓦片之间的缝隙和默认边框 */
-.leaflet-tile {
-  border: none !important;
-  margin: 0 !important;
-  padding: 0 !important;
-  image-rendering: -webkit-optimize-contrast;
-  image-rendering: crisp-edges;
-}
-
-/* 确保地图容器背景色与瓦片一致，避免透出底色 */
-.leaflet-container {
-  background-color: #fff;
-}
-
-/* 如果使用 Canvas 模式，确保 Canvas 没有边框 */
-.leaflet-pane canvas {
-  border: none;
-}
 
 .map-popup-container {
   z-index: 1000;
diff --git a/frontend/src/components/gis/TjCascadeChart.vue b/frontend/src/components/gis/TjCascadeChart.vue
index 1d2d1c33..77cddae7 100644
--- a/frontend/src/components/gis/TjCascadeChart.vue
+++ b/frontend/src/components/gis/TjCascadeChart.vue
@@ -638,7 +638,9 @@ const renderChart = async () => {
           startValue: nextStartValue,
           endValue: nextEndValue
         });
-      } catch (_error: any) {}
+      } catch (error: any) {
+        console.error(error);
+      }
     }, 32);
   };
   zr.on('mousewheel', handleWheel);
diff --git a/frontend/src/components/gis/map.cesium.ts b/frontend/src/components/gis/map.cesium.ts
index fe38f63e..ab81524c 100644
--- a/frontend/src/components/gis/map.cesium.ts
+++ b/frontend/src/components/gis/map.cesium.ts
@@ -38,6 +38,10 @@ export class MapCesium implements MapInterface {
   private popupElement: HTMLElement | null = null;
   private hoveredEntityId: string | null = null;
   private hoverRafId: number | null = null; // requestAnimationFrame 节流
+  /** hover popup 连续脱靶容忍次数：相机微抖/地形遮挡导致瞬时脱靶时不立即隐藏，避免闪烁 */
+  private readonly HOVER_MISS_TOLERANCE = 3;
+  /** 当前连续脱靶计数（命中或隐藏时清零） */
+  private _hoverMissCount = 0;
   /** hover popup 的实际渲染位置缓存（用于 camera.moveEnd 重定位，避免使用 entity.position 的原始椭球面坐标） */
   private _hoverPopupPosition: Cesium.Cartesian3 | null = null;
   private removePostRenderListener: (() => void) | null = null;
@@ -55,15 +59,16 @@ export class MapCesium implements MapInterface {
     worldPosition: Cesium.Cartesian3;
   }> = [];
   private batchPostRenderRemover: (() => void) | null = null;
-  private containerId = '';
   private containerElement: HTMLElement | null = null;
-  private loadingOverlayElement: HTMLDivElement | null = null;
-  private loadingSpinnerAnimation: Animation | null = null;
   private flightFallbackTimer: number | null = null;
   private imageryBaseLayer: Cesium.ImageryLayer | null = null;
   private baseLayerRegistry = new Map<string, Cesium.ImageryLayer>();
   private baseLayerAliasMap = new Map<string, string>();
   private pointLayerRegistry = new Map<string, Cesium.Entity[]>();
+  private wfsLayerRegistry = new Map<string, Cesium.CustomDataSource>();
+  private wfsLoadingKeys = new Set<string>();
+  private wfsPendingVisibility = new Map<string, boolean>();
+  private wfsHoveredEntity: Cesium.Entity | null = null;
   private hydropBaseConfig: any = null;
   private BASEID = '';
   private currentClipGeoJson: any = null;
@@ -71,12 +76,26 @@ export class MapCesium implements MapInterface {
   private maskPolygonEntities: Cesium.Entity[] = [];
   /** 当前相机俯仰模式，用于动态切换深度测试 */
   private _currentPitchMode: 'down' | 'flat' = 'down';
+  /** 漫游模式：强制锚点文字/图标开启深度测试，避免文字遮挡漫游模型 */
+  private _isRoaming = false;
+  /** 漫游已开始但模型尚未就绪（待 activateRoamingPopups 触发批量 popup） */
+  private _pendingRoamingPopups = false;
+  /** 重建批量 popup 时连续空候选次数（防御：避免瞬间过滤导致全屏 Popup 消失） */
+  private _emptyCandidateCount = 0;
+  /** 漫游批量模式空容器被动重建的节流时间戳 */
+  private _lastRoamPassiveRebuild = 0;
   /** 碰撞检测防重入标志，避免级联触发导致重复执行 */
   private _collisionBusy = false;
+  /** 批量初始化锚点图层标志：flushPendingInitLayers 批量加载时合并碰撞检测，避免 O(N²) 全量重算 */
+  private _batchInitLayers = false;
   /** computeAnchorWorldPosition 结果缓存，避免 terrain 加载后重复 globe.getHeight 调用 */
   private _worldPosCache = new Map<string, Cesium.Cartesian3>();
   /** 按经纬度（6 位精度）缓存世界坐标，同位置锚点共享一致的地形高度 */
   private _geoPosCache = new Map<string, Cesium.Cartesian3>();
+  /** 最后已知有效地形高度缓存（按经纬度 6 位精度键控）。
+   *  terrain 瓦片暂缺时 globe.getHeight 返回 undefined，用上次有效高度兜底，
+   *  避免锚点掉回椭球面（高度≈1）导致图标跳屏、drillPick 脱靶、popup 闪烁。 */
+  private _anchorTerrainHeightCache = new Map<string, number>();
   /** 离屏 canvas 文本测量 */
   private _measureCanvas: HTMLCanvasElement | null = null;
   /** 文本像素尺寸缓存 key=`text@roundedFontSize`，zoom 变化 fontSize 改变时自动失效 */
@@ -91,12 +110,6 @@ export class MapCesium implements MapInterface {
     'powerBaseStation',
     's_hydropBase_wfs'
   ]);
-  private readonly PRIMARY_BASE_LAYER_KEYS = new Set([
-    'customBaseLayer',
-    's_province_boundaries',
-    'BASEMAP-white',
-    'BASEMAP-img'
-  ]);
 
   private readonly CHINA_CENTER = { lng: 104.5, lat: 36.5 };
   /** 中国视角默认高度（≈8,000公里，底图边界线清晰可见） */
@@ -112,6 +125,8 @@ export class MapCesium implements MapInterface {
   private readonly CESIUM_ZOOM_FORMULA_D = -40467.74;
   private readonly HOVER_POPUP_MAX_HEIGHT = 12_000_000; // 对应飞入动画中途即开始支持 hover，避免低空地形遮挡导致部分锚点 popup 不显示
   private readonly BATCH_POPUP_MODE_ZOOM = 13; // zoom >= 约 15（UI 层级）进入批量固定模式
+  /** 批量 popup 重建时空候选的容忍次数：连续多次为空才允许清空，避免瞬间过滤导致全屏消失 */
+  private readonly BATCH_POPUP_EMPTY_TOLERANCE = 3;
 
   // ==================== Step 6: 碰撞检测 ====================
   private collisionRefreshFrameId: number | null = null;
@@ -119,6 +134,10 @@ export class MapCesium implements MapInterface {
   private readonly COLLISION_GRID_CELL_SIZE = 96; // 与 2D 一致
   private readonly DENSITY_ISOLATION_THRESHOLD = 56; // 孤立点 pixel 阈值
   private readonly COLLISION_LABEL_PADDING = 4; // 标签碰撞 padding（与 2D checkLabelCollision 对齐）
+  // 锚点/文字碰撞显隐的淡入淡出时长(ms)，与 2D POINT_FADE_DURATION 对齐
+  private readonly FADE_DURATION = 300;
+  private fadeRefreshFrameId: number | null = null;
+  private fadingEntities = new Set<Cesium.Entity>();
 
   // 图标缩放可调参数（只影响 3D Cesium，不参与 2D 计算）
   // scale = base + (zoom - 4.5) * rate，钳位到 [min, max]
@@ -140,7 +159,6 @@ export class MapCesium implements MapInterface {
 
   async init(container: HTMLElement, _rectangle?: any): Promise<any> {
     try {
-      this.containerId = container.id;
       this.containerElement = container;
       const token = 'bearer b734a443-2c8f-4f4a-8698-44828cc5f709';
 
@@ -157,7 +175,7 @@ export class MapCesium implements MapInterface {
         infoBox: false,
         selectionIndicator: false,
         shouldAnimate: true,
-        requestRenderMode: false,
+        requestRenderMode: true, // 开启请求渲染模式，避免卡顿
         targetFrameRate: 30,
         terrainProvider: new Cesium.EllipsoidTerrainProvider() // 默认不使用地形
       });
@@ -206,12 +224,11 @@ export class MapCesium implements MapInterface {
       this._ready = true;
       // 瓦片加载完成后立即加载待处理的倾斜摄影
       this.flushPendingOSGB();
-      // 后台持续监听地形瓦片加载完成（完成后刷新暂缓的锚点数据并关闭 loading）
+      // 后台持续监听地形瓦片加载完成（完成后刷新暂缓的锚点数据）
       this.startTerrainReadyMonitor();
 
       return this.viewer;
     } catch (error) {
-      this.hideLoadingOverlay();
       console.error('Cesium Init Critical Error:', error);
       throw error;
     }
@@ -339,7 +356,6 @@ export class MapCesium implements MapInterface {
             remove();
             this._terrainReady = true;
             this.flushPendingInitLayers();
-            this.hideLoadingOverlay();
           }
         }
       );
@@ -351,7 +367,6 @@ export class MapCesium implements MapInterface {
         remove();
         this._terrainReady = true;
         this.flushPendingInitLayers();
-        this.hideLoadingOverlay();
       }
     }, 20000);
   }
@@ -359,72 +374,53 @@ export class MapCesium implements MapInterface {
   /** 刷新所有因地形未就绪而暂缓的锚点数据 */
   private flushPendingInitLayers() {
     const layers = this._pendingInitLayers.splice(0);
-    for (const layer of layers) {
-      this.addInitDataLayer(layer.data, layer.key, layer.options);
-      // 回放暂缓期间缓存的图例显隐调用（在实体创建后按序执行）
-      const legendCalls = this._pendingLegendCalls.filter(
-        c => c.layerKey === layer.key
-      );
-      this._pendingLegendCalls = this._pendingLegendCalls.filter(
-        c => c.layerKey !== layer.key
-      );
-      for (const call of legendCalls) {
-        this.setLegendPointVisible(
-          call.layerKey,
-          call.anchoPointState,
-          call.checked
+    // 批量添加：内部各方法（addInitDataLayer / setLegendPointVisible /
+    // mdLayerTreeShowOrHidden）不再各自触发全量碰撞检测，末尾统一执行一次
+    this._batchInitLayers = true;
+    try {
+      for (const layer of layers) {
+        this.addInitDataLayer(layer.data, layer.key, layer.options);
+        // 回放暂缓期间缓存的图例显隐调用（在实体创建后按序执行）
+        const legendCalls = this._pendingLegendCalls.filter(
+          c => c.layerKey === layer.key
         );
+        this._pendingLegendCalls = this._pendingLegendCalls.filter(
+          c => c.layerKey !== layer.key
+        );
+        for (const call of legendCalls) {
+          this.setLegendPointVisible(
+            call.layerKey,
+            call.anchoPointState,
+            call.checked
+          );
+        }
+        // 应用暂缓期间缓存的显隐状态
+        if (this._pendingLayerVisibility.has(layer.key)) {
+          const visible = this._pendingLayerVisibility.get(layer.key)!;
+          this._pendingLayerVisibility.delete(layer.key);
+          this.mdLayerTreeShowOrHidden(layer.key, visible);
+        }
       }
-      // 应用暂缓期间缓存的显隐状态
-      if (this._pendingLayerVisibility.has(layer.key)) {
-        const visible = this._pendingLayerVisibility.get(layer.key)!;
-        this._pendingLayerVisibility.delete(layer.key);
-        this.mdLayerTreeShowOrHidden(layer.key, visible);
-      }
+    } finally {
+      this._batchInitLayers = false;
     }
     // 地形就绪后，将所有锚点位置刷新为地形修正后的绝对值，
     // 避免初始化时 terrain 未加载导致的锚点悬浮问题
     this.refreshEntityPositionsWithTerrain();
+    // 批量添加完成后统一触发一次碰撞检测与批量 popup 重建（位置刷新后再计算）
+    this.requestRefreshPointLabelVisibility(true);
+    this.rebuildBatchPopupsIfNeeded();
   }
 
   /**
-   * 用当前地形高度刷新所有锚点位置为绝对值（替换 RELATIVE_TO_GROUND），
-   * 确保放大地图后高 LOD 地形瓦片加载时锚点能正确贴地。
+   * 锚点位置已改为动态地形采样（CallbackProperty 每帧取 globe.getHeight），
+   * 此处只需失效位置缓存，保证 popup/点击投影使用最新的地形 LOD 高度。
+   * 不再写死 entity.position，避免覆盖动态采样。
    */
   private refreshEntityPositionsWithTerrain() {
     if (!this.viewer) return;
-
     this._worldPosCache.clear();
     this._geoPosCache.clear();
-
-    const scene = this.viewer.scene;
-    this.pointLayerRegistry.forEach(entities => {
-      for (const entity of entities) {
-        const rawData = (entity as any)._rawData;
-        if (!rawData) continue;
-
-        const lon = Number(rawData.lgtd);
-        const lat = Number(rawData.lttd);
-        if (!isFinite(lon) || !isFinite(lat)) continue;
-
-        const carto = Cesium.Cartographic.fromDegrees(lon, lat);
-        const terrainHeight = scene.globe.getHeight(carto);
-        const height =
-          terrainHeight !== undefined && terrainHeight > 0 ? terrainHeight : 0;
-
-        // 更新为绝对值：地形高度 + 1m 偏移（与原有 RELATIVE_TO_GROUND 行为对齐）
-        entity.position = Cesium.Cartesian3.fromDegrees(lon, lat, height + 1);
-
-        // 位置已为绝对值，改为 NONE 避免 RELATIVE_TO_GROUND 再次叠加地形高度
-        if (entity.billboard) {
-          (entity.billboard as any).heightReference =
-            Cesium.HeightReference.NONE;
-        }
-        if (entity.label) {
-          (entity.label as any).heightReference = Cesium.HeightReference.NONE;
-        }
-      }
-    });
   }
 
   private clearFlightFallbackTimer() {
@@ -434,62 +430,6 @@ export class MapCesium implements MapInterface {
     }
   }
 
-  private showLoadingOverlay(container: HTMLElement) {
-    this.hideLoadingOverlay();
-
-    const overlay = document.createElement('div');
-    overlay.setAttribute('data-map-cesium-loading', 'true');
-    overlay.style.position = 'absolute';
-    overlay.style.inset = '0';
-    overlay.style.display = 'flex';
-    overlay.style.flexDirection = 'column';
-    overlay.style.alignItems = 'center';
-    overlay.style.justifyContent = 'center';
-    overlay.style.gap = '12px';
-    overlay.style.background =
-      'linear-gradient(180deg, rgba(7, 20, 36, 0.72) 0%, rgba(7, 20, 36, 0.46) 100%)';
-    overlay.style.zIndex = '30';
-    overlay.style.backdropFilter = 'blur(2px)';
-    overlay.style.pointerEvents = 'auto';
-
-    const spinner = document.createElement('div');
-    spinner.style.width = '36px';
-    spinner.style.height = '36px';
-    spinner.style.borderRadius = '50%';
-    spinner.style.border = '3px solid rgba(255, 255, 255, 0.25)';
-    spinner.style.borderTopColor = '#ffffff';
-    this.loadingSpinnerAnimation = spinner.animate(
-      [{ transform: 'rotate(0deg)' }, { transform: 'rotate(360deg)' }],
-      { duration: 900, iterations: Infinity, easing: 'linear' }
-    );
-
-    const label = document.createElement('div');
-    label.textContent = '3D场景加载中...';
-    label.style.color = '#ffffff';
-    label.style.fontSize = '14px';
-    label.style.lineHeight = '20px';
-    label.style.letterSpacing = '0.5px';
-    label.style.textShadow = '0 1px 2px rgba(0, 0, 0, 0.35)';
-
-    overlay.appendChild(spinner);
-    overlay.appendChild(label);
-    container.appendChild(overlay);
-    this.loadingOverlayElement = overlay;
-  }
-
-  private hideLoadingOverlay() {
-    if (this.loadingSpinnerAnimation) {
-      this.loadingSpinnerAnimation.cancel();
-      this.loadingSpinnerAnimation = null;
-    }
-    if (this.loadingOverlayElement?.parentNode) {
-      this.loadingOverlayElement.parentNode.removeChild(
-        this.loadingOverlayElement
-      );
-    }
-    this.loadingOverlayElement = null;
-  }
-
   // ==================== Step 7: 点击锚点打开详情弹框 ====================
 
   private setupClickHandler() {
@@ -522,6 +462,13 @@ export class MapCesium implements MapInterface {
           const scene = this.viewer?.scene;
           if (!scene) return;
 
+          // 漫游批量模式下完全禁用 hover：所有锚点由批量 popup 固定展示，避免与漫游/模型交互冲突
+          if (this.isBatchPopupMode && this._isRoaming) {
+            canvas.style.cursor = 'default';
+            this.hidePopup();
+            return;
+          }
+
           const cameraHeight = this.getCurrentCameraHeight();
           // 缩放门槛：中国视角以上不触发 hover
           if (cameraHeight > this.HOVER_POPUP_MAX_HEIGHT) {
@@ -563,16 +510,16 @@ export class MapCesium implements MapInterface {
 
             if (!isIconHit) {
               canvas.style.cursor = 'default';
-              if (!this.isBatchPopupMode) {
-                this.hidePopup();
-              }
+              this.hidePopupWithTolerance();
               return;
             }
 
             canvas.style.cursor = 'pointer';
+            this._hoverMissCount = 0;
 
-            // 批量模式下：模型之上的锚点允许 hover，普通锚点由批量 popup 处理
-            if (this.isBatchPopupMode && !isOnModel) return;
+            // 已固定展示（批量 popup）的锚点跳过 hover popup，避免同一内容出现双份；
+            // 未被固定展示的锚点（如碰撞被隐藏）仍可通过 hover 查看
+            if ((entity as any)._fixedPopupShown) return;
 
             // 获取锚点的实际渲染世界坐标（固定位置，不跟随鼠标）
             // computeAnchorWorldPosition 取 terrain 高度修正后的位置，与 billboard CLAMP_TO_GROUND 渲染位置一致
@@ -598,11 +545,11 @@ export class MapCesium implements MapInterface {
             return;
           }
 
-          canvas.style.cursor = 'default';
-          // 批量模式下仅隐藏 hover popup（模型之上的锚点），保留批量 popup
-          if (!this.isBatchPopupMode || this.hoveredEntityId) {
-            this.hidePopup();
-          }
+          // WFS 河段悬停高亮（锚点未命中时检查）
+          const wfsHighlighted = this.handleWfsHover(pickResults);
+          canvas.style.cursor = wfsHighlighted ? 'pointer' : 'default';
+          // 用脱靶容忍隐藏 hover popup，避免漫游静止态相机微抖导致锚点瞬时脱靶时 popup 闪烁
+          this.hidePopupWithTolerance();
         });
       },
       Cesium.ScreenSpaceEventType.MOUSE_MOVE
@@ -658,7 +605,14 @@ export class MapCesium implements MapInterface {
         this.updateDepthTestForPitch();
         // 拖拽时隐藏 hover popup，避免 popup 留在旧屏幕坐标跟随地图漂移
         if (this.hoveredEntityId) {
-          this.hidePopup();
+          if (this._isRoaming) {
+            // 漫游中相机每帧持续运动（第一人称跟随模型）：直接隐藏会导致
+            // popup 闪烁、鼠标不动后消失。改为跟随锚点世界坐标重定位，
+            // 让 popup 稳定跟随锚点显示。
+            this.repositionHoverPopup();
+          } else {
+            this.hidePopup();
+          }
         }
       });
 
@@ -671,7 +625,17 @@ export class MapCesium implements MapInterface {
         // 相机停止后刷新生效的地形 LOD，将锚点位置更新为地形修正绝对值
         this.refreshEntityPositionsWithTerrain();
 
-        if (zoom >= this.BATCH_POPUP_MODE_ZOOM) {
+        if (this._isRoaming) {
+          if (this._pendingRoamingPopups) {
+            // 漫游模型尚未就绪（activateRoamingPopups 未触发），跳过提前开启批量 Popup
+          } else if (!this.isBatchPopupMode) {
+            // 漫游中：批量 popup 无条件开启（不受缩放阈值限制）
+            this.enableBatchPopupMode(true);
+          } else {
+            // 漫游中：无条件重建
+            this.rebuildBatchPopupsIfNeeded();
+          }
+        } else if (zoom >= this.BATCH_POPUP_MODE_ZOOM) {
           if (!this.isBatchPopupMode) {
             this.enableBatchPopupMode();
           } else {
@@ -680,18 +644,13 @@ export class MapCesium implements MapInterface {
               this.rebuildBatchPopupsIfNeeded();
             }
           }
-          // 批量模式下，模型之上的锚点 hover popup 也需要在拖拽后重定位
-          if (this.hoveredEntityId) {
-            this.repositionHoverPopup();
-          }
-        } else {
-          if (this.isBatchPopupMode) {
-            this.disableBatchPopupMode();
-          }
-          // hover popup 重定位而非隐藏，避免缩放结束后闪烁
-          if (this.hoveredEntityId) {
-            this.repositionHoverPopup();
-          }
+        } else if (this.isBatchPopupMode) {
+          this.disableBatchPopupMode();
+        }
+
+        // 批量模式下，模型之上的锚点 hover popup 也需要在拖拽后重定位
+        if (this.hoveredEntityId) {
+          this.repositionHoverPopup();
         }
 
         // Step 6: 碰撞检测 — 相机停止移动后重新计算图标/标签可见性
@@ -709,8 +668,43 @@ export class MapCesium implements MapInterface {
     if (newMode === this._currentPitchMode) return;
     this._currentPitchMode = newMode;
 
-    const depthValue =
-      newMode === 'flat' ? undefined : Number.POSITIVE_INFINITY;
+    // 漫游中不按俯仰角覆盖（保持深度测试开启，让模型遮挡锚点文字）
+    if (this._isRoaming) return;
+    this.applyPointDepthTest(this.getDepthTestValue());
+  }
+
+  /**
+   * 漫游开关：漫游时强制所有锚点文字/图标开启深度测试（被模型正确遮挡），
+   * 漫游结束恢复按俯仰角的动态策略。模型文件(glb)在漫游时加载，
+   * 若锚点 disableDepthTestDistance 仍为 POSITIVE_INFINITY，文字会始终绘制在模型之上。
+   */
+  setRoamDepthTest(enabled: boolean): void {
+    this._isRoaming = enabled;
+    this.applyPointDepthTest(this.getDepthTestValue());
+    // 漫游开始时仅记录“待开启”标志，不在模型加载/相机飞到位前直接开启批量 popup
+    //（避免旧视角锚点 Popup 提前全部出现）。由 activateRoamingPopups() 在模型渲染就绪后真正开启；
+    // 退出漫游时清除标志，批量模式恢复由 moveEnd/postRender 的缩放逻辑接管。
+    this._pendingRoamingPopups = enabled;
+  }
+
+  /**
+   * 漫游模型加载完成并渲染后，由外部（ThreeDRoamManager/面板）调用，
+   * 执行 enableBatchPopupMode(true)，确保 Popup 与漫游模型同时出现。
+   */
+  activateRoamingPopups(): void {
+    if (!this._isRoaming || !this._pendingRoamingPopups) return;
+    this._pendingRoamingPopups = false;
+    this.enableBatchPopupMode(true);
+  }
+
+  /** 当前应使用的深度测试值：flat（平视/漫游）→ 0 启用深度测试让模型可遮挡；down（俯视）→ 禁用避免地形遮挡文字 */
+  private getDepthTestValue(): number {
+    if (this._isRoaming) return 0;
+    return this._currentPitchMode === 'down' ? Number.POSITIVE_INFINITY : 0;
+  }
+
+  /** 对所有锚点图层统一应用 disableDepthTestDistance */
+  private applyPointDepthTest(depthValue: number): void {
     this.pointLayerRegistry.forEach(entities => {
       for (let i = 0; i < entities.length; i++) {
         const entity = entities[i];
@@ -794,6 +788,7 @@ export class MapCesium implements MapInterface {
   /** 判断实体当前是否可交互（图层可见 + 图例可见 + 区域可见） */
   private isEntityInteractive(entity: Cesium.Entity): boolean {
     const e = entity as any;
+    if (e._isWfs) return false; // WFS 河段实体走独立高亮逻辑，不参与锚点交互
     if (e._layerVisible === false) return false;
     if (e._legendVisible === false) return false;
     if (e._regionVisible === false) return false;
@@ -801,6 +796,49 @@ export class MapCesium implements MapInterface {
     return true;
   }
 
+  /**
+   * 处理 WFS 河段悬停高亮：命中要素改为加深色，未命中恢复原色
+   * @param pickResults drillPick 结果
+   * @returns 是否命中 WFS 河段
+   */
+  private handleWfsHover(pickResults: any[]): boolean {
+    let hitEntity: Cesium.Entity | null = null;
+    for (const p of pickResults) {
+      if (Cesium.defined(p) && p.id instanceof Cesium.Entity) {
+        const e = p.id as any;
+        if (e._isWfs) {
+          hitEntity = p.id as Cesium.Entity;
+          break;
+        }
+      }
+    }
+
+    // 高亮对象变化时恢复上一个并切换高亮叠加实体（show 切换不重建几何，无卡顿）
+    if (this.wfsHoveredEntity !== hitEntity) {
+      this.restoreWfsHoverStyle();
+      this.wfsHoveredEntity = hitEntity;
+      if (hitEntity) {
+        const hoverEntity = (hitEntity as any)._wfsHoverEntity ?? hitEntity;
+        const baseEntity = (hoverEntity as any)._wfsBaseEntity ?? hoverEntity;
+        baseEntity.show = false;
+        hoverEntity.show = true;
+        this.wfsHoveredEntity = hoverEntity;
+      }
+    }
+    return !!hitEntity;
+  }
+
+  /** 恢复上一个 WFS 高亮：隐藏叠加实体，显示基座实体 */
+  private restoreWfsHoverStyle(): void {
+    if (!this.wfsHoveredEntity) return;
+    const e = this.wfsHoveredEntity as any;
+    if (e._wfsBaseEntity) {
+      e.show = false;
+      e._wfsBaseEntity.show = true;
+    }
+    this.wfsHoveredEntity = null;
+  }
+
   /**
    * 判断锚点是否位于 3D 模型（倾斜摄影/OSGB）之上
    * 用 computeAnchorWorldPosition 取 terrain 修正后的位置与 Cesium3DTileset 包围球求交，
@@ -862,15 +900,22 @@ export class MapCesium implements MapInterface {
 
     // 尝试取地形高度；无数据时回退到原始椭球面高度
     const terrainHeight = this.viewer.scene.globe.getHeight(carto);
-    const height =
-      terrainHeight !== undefined && terrainHeight > 0
-        ? terrainHeight
-        : carto.height;
-    // +1 与 entity position 的 1m 偏移对齐（RELATIVE_TO_GROUND），避免锚点穿模
+    let height: number;
+    if (terrainHeight !== undefined && terrainHeight > 0) {
+      height = terrainHeight;
+      this._anchorTerrainHeightCache.set(posKey, terrainHeight);
+    } else if (this._anchorTerrainHeightCache.has(posKey)) {
+      // terrain 瓦片暂缺（getHeight 返回 undefined）时，用最后已知有效高度兜底，
+      // 避免回退到椭球面高度导致图标跳屏
+      height = this._anchorTerrainHeightCache.get(posKey)!;
+    } else {
+      height = carto.height;
+    }
+    // +1 与 entity position 的动态地形采样高度（terrain + 1）对齐，避免锚点穿模
     const worldPos = Cesium.Cartesian3.fromRadians(
       carto.longitude,
       carto.latitude,
-      height + 1
+      height + 3
     );
 
     // 仅在 terrain 有实际高度数据时缓存（避免缓存未加载时的 0 高度占位值）
@@ -932,11 +977,30 @@ export class MapCesium implements MapInterface {
 
   /** 关闭单个 hover popup */
   private hidePopup(): void {
+    this._hoverMissCount = 0;
     this.hoveredEntityId = null;
     this._hoverPopupPosition = null;
     if (!this.popupElement) return;
     this.popupElement.style.display = 'none';
     this.popupElement.innerHTML = '';
+    // 恢复 hover popup 层级
+    this.popupElement.style.removeProperty('zIndex');
+  }
+
+  /**
+   * 容忍瞬时脱靶的隐藏：连续 HOVER_MISS_TOLERANCE 次脱靶才真正隐藏。
+   * 漫游静止态相机 preRender 每帧微抖（lerp/slerp 跟随），平视视角下锚点近视锥底边缘，
+   * 投影在屏内/屏外间交替导致 drillPick 瞬时脱靶；直接隐藏会表现为 popup 持续闪烁。
+   */
+  private hidePopupWithTolerance(): void {
+    if (
+      this.hoveredEntityId &&
+      this._hoverMissCount < this.HOVER_MISS_TOLERANCE
+    ) {
+      this._hoverMissCount++;
+      return;
+    }
+    this.hidePopup();
   }
 
   /** 判断 3D 位置是否被地形遮挡（基于射线与 terrain 求交） */
@@ -973,7 +1037,20 @@ export class MapCesium implements MapInterface {
     );
 
     if (!canvasPosition) {
-      this.hidePopup();
+      // 投影失败（锚点在相机后方/视锥外）：保留上次位置不隐藏，避免相机微抖时闪烁
+      return;
+    }
+    // 投影落在视口外（锚点近视锥底边缘，相机微抖使其短暂滑出）：保留上次位置，避免 popup 跳到屏幕外
+    const canvas = this.viewer.scene.canvas;
+    const cw = canvas.clientWidth || canvas.width;
+    const ch = canvas.clientHeight || canvas.height;
+    const MARGIN = 100;
+    if (
+      canvasPosition.x < -MARGIN ||
+      canvasPosition.y < -MARGIN ||
+      canvasPosition.x > cw + MARGIN ||
+      canvasPosition.y > ch + MARGIN
+    ) {
       return;
     }
 
@@ -1013,20 +1090,24 @@ export class MapCesium implements MapInterface {
     this.hoveredEntityId = entity.id;
     this._hoverPopupPosition = position;
     this.updatePopupPosition(position);
+    // 临时提升层级，避免被批量固定 popup 容器（z-index: 1000）遮挡
+    this.popupElement.style.zIndex = '1100';
   }
 
   // ==================== 批量 popup ====================
 
-  /** 启用批量 popup：所有可见锚点固定显示 popup */
-  private enableBatchPopupMode() {
+  /** 启用批量 popup：所有可见锚点固定显示 popup。
+   *  @param force 为 true 时跳过缩放阈值直接开启（漫游强制批量模式使用） */
+  private enableBatchPopupMode(force = false) {
     const zoom = this.getZoomLevelFromCameraHeight(
       this.getCurrentCameraHeight()
     );
-    // 二次校验 zoom 门槛，防止初始化时 camera.moveEnd 以错误高度触发
-    if (zoom < this.BATCH_POPUP_MODE_ZOOM) return;
+    // 二次校验 zoom 门槛，防止初始化时 camera.moveEnd 以错误高度触发（force 时跳过）
+    if (!force && zoom < this.BATCH_POPUP_MODE_ZOOM) return;
 
     this.isBatchPopupMode = true;
     this._lastBatchRebuildZoom = zoom;
+    this._emptyCandidateCount = 0;
     this.clearBatchPopups();
     this.hidePopup(); // 清除可能残留的 hover popup
     // 先注册 postRender（内含 zoom 兜底检测），再构建 popup，确保缩放/拖拽时始终有同步线程
@@ -1094,10 +1175,10 @@ export class MapCesium implements MapInterface {
         )
           return;
 
-        // 被地形遮挡的不展示 popup
-        if (this.isPositionBehindTerrain(worldPos)) return;
-        // 模型之上的锚点不固定展示 popup，仅通过 hover 触发
-        if (this.isEntityOnModel(entity)) return;
+        // 被地形遮挡的不展示 popup（漫游时跳过：模型上方锚点易被新加载的高精度地形误判为遮挡）
+        if (!this._isRoaming && this.isPositionBehindTerrain(worldPos)) return;
+        // 模型之上的锚点不固定展示 popup，仅通过 hover 触发（漫游强制批量模式下不过滤，需固定展示）
+        if (!this._isRoaming && this.isEntityOnModel(entity)) return;
 
         const rawData: Record<string, any> = {
           ...((entity as any)._rawData || {})
@@ -1206,6 +1287,8 @@ export class MapCesium implements MapInterface {
             popupEl.style.opacity = '1';
             popupEl.style.left = `${x}px`;
             popupEl.style.top = `${y}px`;
+            // 标记该锚点已有固定展示的 popup，hover 时跳过 hover popup
+            (entity as any)._fixedPopupShown = true;
             // 缓存地形高度修正后的世界坐标，每帧用于稳定投影
             const worldPos =
               this.computeAnchorWorldPosition(entity) ||
@@ -1220,6 +1303,7 @@ export class MapCesium implements MapInterface {
             placedPopups.push({ ...popupRect, entity, element: popupEl });
           } else {
             // 碰撞：后来的让路
+            (entity as any)._fixedPopupShown = false;
             container.removeChild(popupEl);
           }
         }
@@ -1270,12 +1354,24 @@ export class MapCesium implements MapInterface {
     const zoom = this.getZoomLevelFromCameraHeight(
       this.getCurrentCameraHeight()
     );
-    if (zoom < this.BATCH_POPUP_MODE_ZOOM) {
+    // 漫游中强制批量模式，跳过 zoom 兜底退出检测
+    if (!this._isRoaming && zoom < this.BATCH_POPUP_MODE_ZOOM) {
       this.disableBatchPopupMode();
       return;
     }
 
-    if (this.batchPopupItems.length === 0) return;
+    if (this.batchPopupItems.length === 0) {
+      // 漫游强制批量模式下容器为空：节流触发一次被动重建，
+      // 防止相机/模型就位后仍无 Popup（配合 rebuild 的空候选容忍，不会造成清空闪烁）
+      if (this._isRoaming) {
+        const now = performance.now();
+        if (now - this._lastRoamPassiveRebuild > 1500) {
+          this._lastRoamPassiveRebuild = now;
+          this.rebuildBatchPopupsIfNeeded();
+        }
+      }
+      return;
+    }
 
     const canvas = this.viewer.scene.canvas;
     const viewW = canvas.clientWidth;
@@ -1409,6 +1505,13 @@ export class MapCesium implements MapInterface {
         }
       }
     }
+
+    // 同步固定展示标记：当前实际可见（display != none）的批量 popup 对应锚点，hover 时跳过 hover popup
+    for (let i = 0; i < this.batchPopupItems.length; i++) {
+      const item = this.batchPopupItems[i];
+      (item.entity as any)._fixedPopupShown =
+        item.element.style.display !== 'none';
+    }
   }
 
   /** 批量模式下双缓冲重建 popup（图层/图例变化、拖拽/缩放 moveEnd 时调用）。
@@ -1434,6 +1537,19 @@ export class MapCesium implements MapInterface {
     // buildBatchPopupsInContainer 会往 this.batchPopupItems push 新 item，
     // 旧 item 仍在数组中，postRender 继续更新其位置
     const candidates = this.collectBatchPopupCandidates();
+
+    // 防御性重建：候选为空时不替换旧容器，避免瞬间过滤（高精度地形/模型遮挡判定波动）
+    // 导致全屏 Popup 消失。连续多次（空窗期容忍）为空才允许清空，防止残留过期 Popup。
+    if (candidates.length === 0) {
+      this._emptyCandidateCount++;
+      if (this._emptyCandidateCount < this.BATCH_POPUP_EMPTY_TOLERANCE) {
+        newContainer.remove();
+        return;
+      }
+    } else {
+      this._emptyCandidateCount = 0;
+    }
+
     this.buildBatchPopupsInContainer(newContainer, candidates).then(() => {
       if (generation !== this._rebuildGeneration) {
         newContainer.remove();
@@ -1444,9 +1560,17 @@ export class MapCesium implements MapInterface {
         return;
       }
       // 过滤掉旧 items，仅保留本次构建的新 items
-      this.batchPopupItems = this.batchPopupItems.filter(
+      const newItems = this.batchPopupItems.filter(
         item => !oldItemsSet.has(item)
       );
+      // 被移除的旧 item 对应的锚点复位固定展示标记，
+      // 避免其已不在 batchPopupItems 中、每帧同步无法覆盖，导致 hover 被永久跳过
+      this.batchPopupItems.forEach(item => {
+        if (oldItemsSet.has(item)) {
+          (item.entity as any)._fixedPopupShown = false;
+        }
+      });
+      this.batchPopupItems = newItems;
       this.popupCollisionFrames = new WeakMap();
       // 无缝替换容器
       if (oldContainer) oldContainer.remove();
@@ -1462,6 +1586,10 @@ export class MapCesium implements MapInterface {
 
   /** 清除所有批量 popup */
   private clearBatchPopups() {
+    // 清除前复位所有锚点的固定展示标记
+    this.batchPopupItems.forEach(item => {
+      (item.entity as any)._fixedPopupShown = false;
+    });
     this.batchPopupItems = [];
     this.popupCollisionFrames = new WeakMap<HTMLDivElement, number>();
     if (this.batchPopupContainer) {
@@ -1492,9 +1620,8 @@ export class MapCesium implements MapInterface {
   // ==================== destroy ====================
 
   destroy(): void {
-    // 取消飞行超时和加载动画
+    // 取消飞行超时
     this.clearFlightFallbackTimer();
-    this.hideLoadingOverlay();
     this._ready = false;
     this._pendingOSGBItems = [];
 
@@ -1530,6 +1657,12 @@ export class MapCesium implements MapInterface {
       window.clearTimeout(this.labelVisibilityDebounceTimerId);
       this.labelVisibilityDebounceTimerId = null;
     }
+    // 淡入淡出 rAF 循环
+    if (this.fadeRefreshFrameId !== null) {
+      cancelAnimationFrame(this.fadeRefreshFrameId);
+      this.fadeRefreshFrameId = null;
+    }
+    this.fadingEntities.clear();
 
     // 中止进行中的基地裁切请求
     if (this.clipRequestController) {
@@ -1548,6 +1681,10 @@ export class MapCesium implements MapInterface {
     // 清理锚点图层和底图注册表
     this.destroyAllPointLayers();
     this.pointLayerRegistry.clear();
+    this.wfsLayerRegistry.clear();
+    this.wfsLoadingKeys.clear();
+    this.wfsPendingVisibility.clear();
+    this.wfsHoveredEntity = null;
     this.baseLayerRegistry.clear();
     this.baseLayerAliasMap.clear();
     this.imageryBaseLayer = null;
@@ -1742,6 +1879,8 @@ export class MapCesium implements MapInterface {
 
     if (!imageryLayer) return null;
 
+    // 记录请求 URL，供 addBaseDataLayer 复用判断（URL 变化才需要重建）
+    (imageryLayer as any)._baseLayerUrl = url;
     imageryLayer.show = visible;
     if (typeof layerConfig?.rasteropacity === 'number') {
       imageryLayer.alpha = layerConfig.rasteropacity;
@@ -1749,6 +1888,111 @@ export class MapCesium implements MapInterface {
     return imageryLayer;
   }
 
+  /**
+   * 加载 WFS 矢量图层（与 2D map.ol.ts 对齐）：fetch 原始 GeoJSON，
+   * 在原始数据层过滤坐标异常的要素，再生成 polyline 实体
+   */
+  private loadWfsLayer(layerConfig: any, isShow: boolean): void {
+    if (!this.viewer || !layerConfig?.key) return;
+
+    // 已有请求在途时跳过，避免重复 fetch 产生多份实体；显隐由待定机制接管
+    if (this.wfsLoadingKeys.has(layerConfig.key)) return;
+
+    // 同 key 重复添加前先移除旧数据源（连同内部实体一并销毁）
+    const existingDs = this.wfsLayerRegistry.get(layerConfig.key);
+    if (existingDs) {
+      this.viewer.dataSources.remove(existingDs, true);
+      this.wfsLayerRegistry.delete(layerConfig.key);
+    }
+    this.restoreWfsHoverStyle();
+    this.wfsLoadingKeys.add(layerConfig.key);
+
+    // 在原始 GeoJSON 层面对坐标做 4326 有效性筛选，删除混入的异常投影数据
+    const isCoordIn4326Range = (lon: number, lat: number) =>
+      lon >= -180 && lon <= 180 && lat >= -90 && lat <= 90;
+    const isValidGeoJsonFeature = (feature: any): boolean => {
+      const geom = feature?.geometry;
+      if (!geom) return false;
+      const flat = geom.coordinates.flat(Infinity) as number[];
+      for (let i = 0; i < flat.length; i += 2) {
+        if (!isCoordIn4326Range(flat[i], flat[i + 1])) return false;
+      }
+      return true;
+    };
+
+    const url = layerConfig.url;
+
+    fetch(url)
+      .then(res => res.json())
+      .then(data => {
+        if (!this.viewer) return; // 地图可能已被销毁
+        this.wfsLoadingKeys.delete(layerConfig.key);
+        data.features = (data.features || []).filter(isValidGeoJsonFeature);
+
+        const baseColor = Cesium.Color.fromCssColorString(
+          layerConfig.color || '#038303'
+        );
+        const highlightColor = Cesium.Color.fromCssColorString('#37ff00ff');
+
+        // 每个 WFS 图层一个 CustomDataSource，通过 dataSource.show 可靠控制整组显隐
+        const dataSource = new Cesium.CustomDataSource(layerConfig.key);
+        this.viewer.dataSources.add(dataSource);
+
+        data.features.forEach((feature: any) => {
+          const coords = feature?.geometry?.coordinates;
+          if (!Array.isArray(coords)) return;
+          const flat = coords.flat(Infinity) as number[];
+          if (flat.length < 2) return;
+
+          const props = feature?.properties || {};
+          const positions = Cesium.Cartesian3.fromDegreesArray(flat);
+          const createEntity = (
+            width: number,
+            color: Cesium.Color,
+            show: boolean
+          ) => {
+            const entity = new Cesium.Entity({
+              name: feature?.properties?.Id ?? layerConfig.key,
+              polyline: {
+                positions,
+                width,
+                material: new Cesium.ColorMaterialProperty(color),
+                clampToGround: true
+              },
+              show
+            });
+            (entity as any)._isWfs = true;
+            (entity as any)._rawData = props;
+            return entity;
+          };
+
+          // 基座实体（宽 3）+ 高亮叠加实体（宽 4）：
+          // hover 用 show 切换代替修改 width，避免贴地线几何重建导致的卡顿
+          const baseEntity = createEntity(3, baseColor, true);
+          const hoverEntity = createEntity(4, highlightColor, false);
+          (baseEntity as any)._wfsHoverEntity = hoverEntity;
+          (hoverEntity as any)._wfsBaseEntity = baseEntity;
+          dataSource.entities.add(baseEntity);
+          dataSource.entities.add(hoverEntity);
+        });
+
+        this.wfsLayerRegistry.set(layerConfig.key, dataSource);
+
+        // 应用加载期间用户已操作的显隐状态（如加载中取消勾选）
+        if (this.wfsPendingVisibility.has(layerConfig.key)) {
+          dataSource.show = this.wfsPendingVisibility.get(layerConfig.key)!;
+          this.wfsPendingVisibility.delete(layerConfig.key);
+        } else {
+          dataSource.show = isShow;
+        }
+        this.requestRender();
+      })
+      .catch(err => {
+        this.wfsLoadingKeys.delete(layerConfig.key);
+        console.error(`3D WFS 图层加载失败 [${layerConfig.key}]:`, err);
+      });
+  }
+
   addBaseDataLayer(layerConfig: any, isShow = true): void {
     if (!this.viewer || !layerConfig?.key) return;
 
@@ -1758,6 +2002,11 @@ export class MapCesium implements MapInterface {
       return;
     }
 
+    if (layerConfig.type === 'wfs') {
+      this.loadWfsLayer(layerConfig, !!isShow);
+      return;
+    }
+
     if (
       this.IGNORED_BASE_LAYER_KEYS.has(layerConfig.key) ||
       this.IGNORED_BASE_LAYER_KEYS.has(layerConfig.id)
@@ -1773,6 +2022,27 @@ export class MapCesium implements MapInterface {
       return;
     }
 
+    // 复用已注册的同一底图：避免重复创建 provider 导致重复请求瓦片与白屏闪烁。
+    // 仅当请求 URL 发生变化时才走重建流程（如 customBaseLayer 更换底图地址）
+    const registryPrimaryKey =
+      this.resolvePrimaryBaseLayerKey(layerConfig?.key) ||
+      this.resolvePrimaryBaseLayerKey(layerConfig?.id);
+    const newRequestUrl = this.getLayerRequestUrl(layerConfig);
+    if (registryPrimaryKey) {
+      const existingLayer = this.baseLayerRegistry.get(registryPrimaryKey);
+      if (
+        existingLayer &&
+        (existingLayer as any)._baseLayerUrl === newRequestUrl
+      ) {
+        existingLayer.show = !!isShow;
+        if (typeof layerConfig?.rasteropacity === 'number') {
+          existingLayer.alpha = layerConfig.rasteropacity;
+        }
+        this.requestRender();
+        return;
+      }
+    }
+
     const imageryLayer = this.createImageryLayer(layerConfig, !!isShow);
     if (!imageryLayer) return;
 
@@ -1794,6 +2064,19 @@ export class MapCesium implements MapInterface {
       return;
     }
 
+    // WFS 矢量图层：切换整个 CustomDataSource 显隐
+    const wfsDataSource = this.wfsLayerRegistry.get(targetKey);
+    if (wfsDataSource) {
+      wfsDataSource.show = checked;
+      this.requestRender();
+      return;
+    }
+    // WFS 图层仍在加载中：记录待应用的显隐状态，加载完成后生效
+    if (this.wfsLoadingKeys.has(targetKey)) {
+      this.wfsPendingVisibility.set(targetKey, checked);
+      return;
+    }
+
     const primaryKey = this.resolvePrimaryBaseLayerKey(targetKey);
     if (!primaryKey) return;
 
@@ -1806,6 +2089,9 @@ export class MapCesium implements MapInterface {
 
   hasBaseLayer(layerKey: string): boolean {
     if (layerKey === 'BASEMAP-img') return !!this.imageryBaseLayer;
+    const hasWfs = this.wfsLayerRegistry.has(layerKey);
+    console.log('[WFS 3D] hasBaseLayer key:', layerKey, '→', hasWfs);
+    if (hasWfs) return true;
     return !!this.resolvePrimaryBaseLayerKey(layerKey);
   }
 
@@ -2008,17 +2294,40 @@ export class MapCesium implements MapInterface {
         return new Cesium.Cartesian2(0, offsetY);
       }, false);
 
+      // 动态地形采样位置：每帧取当前地形 LOD 高度，保证锚点绝对高度贴地。
+      // 使用 HeightReference.NONE + 真实 3D 坐标，深度测试才能让模型正确遮挡文字/图标
+      //（RELATIVE_TO_GROUND 走地面渲染路径，disableDepthTestDistance 对模型遮挡不可靠）
+      const anchorCarto = Cesium.Cartographic.fromDegrees(lon, lat);
+      const posKey = `${lon.toFixed(6)},${lat.toFixed(6)}`;
+      const dynamicPosition = new Cesium.CallbackProperty(() => {
+        const terrainHeight = this.viewer?.scene.globe.getHeight(anchorCarto);
+        let height: number;
+        if (terrainHeight !== undefined && terrainHeight > 0) {
+          this._anchorTerrainHeightCache.set(posKey, terrainHeight);
+          height = terrainHeight + 1;
+        } else if (this._anchorTerrainHeightCache.has(posKey)) {
+          // terrain 瓦片暂缺（getHeight 返回 undefined）时，用最后已知有效高度兜底，
+          // 避免图标掉回椭球面（高度≈1）导致屏幕位置跳变、drillPick 脱靶
+          height = this._anchorTerrainHeightCache.get(posKey)! + 1;
+        } else {
+          height = 1;
+        }
+        return Cesium.Cartesian3.fromDegrees(lon, lat, height);
+      }, false);
+
       const entity = new Cesium.Entity({
         id: entityId,
-        position: Cesium.Cartesian3.fromDegrees(lon, lat, 1),
+        position: dynamicPosition,
         billboard: {
           image: iconUrl || undefined,
           scale: dynamicIconScale as any,
           verticalOrigin: Cesium.VerticalOrigin.CENTER,
           horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
           scaleByDistance: new Cesium.NearFarScalar(1.0e3, 1.5, 2.0e7, 0.8),
-          heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND,
-          disableDepthTestDistance: Number.POSITIVE_INFINITY
+          heightReference: Cesium.HeightReference.NONE,
+          disableDepthTestDistance: this._isRoaming
+            ? 0
+            : Number.POSITIVE_INFINITY
         } as any,
         label: {
           text: labelText || undefined,
@@ -2031,8 +2340,10 @@ export class MapCesium implements MapInterface {
           pixelOffset: dynamicLabelOffset as any,
           horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
           scaleByDistance: new Cesium.NearFarScalar(1.0e3, 1.2, 2.0e7, 0.8),
-          heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND,
-          disableDepthTestDistance: Number.POSITIVE_INFINITY
+          heightReference: Cesium.HeightReference.NONE,
+          disableDepthTestDistance: this._isRoaming
+            ? 0
+            : Number.POSITIVE_INFINITY
         } as any,
         properties: {
           ...item,
@@ -2071,8 +2382,11 @@ export class MapCesium implements MapInterface {
       );
     }
 
-    // 数据加载完成后触发首次碰撞检测（同步执行，避免异步 rAF 导致的首帧闪烁）
-    this.requestRefreshPointLabelVisibility(true);
+    // 数据加载完成后触发首次碰撞检测（同步执行，避免异步 rAF 导致的首帧闪烁）；
+    // 批量初始化（flushPendingInitLayers）时由末尾统一触发一次，避免 O(N²) 全量重算
+    if (!this._batchInitLayers) {
+      this.requestRefreshPointLabelVisibility(true);
+    }
   }
 
   mdLayerTreeShowOrHidden(layerType: string, checked?: boolean): void {
@@ -2091,10 +2405,13 @@ export class MapCesium implements MapInterface {
       this.applyEntityVisibility(entity);
     });
 
-    // 图层切换后立即重算碰撞（同步执行，避免闪烁）
-    this.requestRefreshPointLabelVisibility(true);
-    // 批量模式下同步重建 popup
-    this.rebuildBatchPopupsIfNeeded();
+    // 批量初始化时由 flushPendingInitLayers 末尾统一触发
+    if (!this._batchInitLayers) {
+      // 图层切换后立即重算碰撞（同步执行，避免闪烁）
+      this.requestRefreshPointLabelVisibility(true);
+      // 批量模式下同步重建 popup
+      this.rebuildBatchPopupsIfNeeded();
+    }
   }
 
   removePointLayer(layerKey: string): void {
@@ -2127,6 +2444,7 @@ export class MapCesium implements MapInterface {
     });
     this.pointLayerRegistry.clear();
     this._worldPosCache.clear();
+    this._anchorTerrainHeightCache.clear();
   }
 
   // ==================== Stubs（后续步骤补齐） ====================
@@ -2236,8 +2554,11 @@ export class MapCesium implements MapInterface {
         (entity as any)._legendVisible = false;
         this.applyEntityVisibility(entity);
       });
-      this.requestRefreshPointLabelVisibility(true);
-      this.rebuildBatchPopupsIfNeeded();
+      // 批量初始化时由 flushPendingInitLayers 末尾统一触发
+      if (!this._batchInitLayers) {
+        this.requestRefreshPointLabelVisibility(true);
+        this.rebuildBatchPopupsIfNeeded();
+      }
       return;
     }
 
@@ -2250,9 +2571,12 @@ export class MapCesium implements MapInterface {
       }
     });
 
-    // 图例切换后立即重算碰撞（同步执行，避免闪烁）
-    this.requestRefreshPointLabelVisibility(true);
-    this.rebuildBatchPopupsIfNeeded();
+    // 批量初始化时由 flushPendingInitLayers 末尾统一触发
+    if (!this._batchInitLayers) {
+      // 图例切换后立即重算碰撞（同步执行，避免闪烁）
+      this.requestRefreshPointLabelVisibility(true);
+      this.rebuildBatchPopupsIfNeeded();
+    }
   }
 
   // ==================== 基地裁切辅助方法 ====================
@@ -2522,26 +2846,284 @@ export class MapCesium implements MapInterface {
    * - entity.show = 图层可见 && 区域可见（不含图例），legend 切换时 CLAMP_TO_GROUND 数据不丢失
    * - entity.billboard.show = 全部基础可见 && 图标碰撞通过
    * - entity.label.show = 全部基础可见 && 标签碰撞通过（图标碰撞不影响标签）
+   * 碰撞标志切换时不再直接 show，而是走淡入淡出（与 2D 对齐）。
    */
   private applyEntityVisibility(entity: Cesium.Entity): void {
     const e = entity as any;
     // entity 整体不依赖图例，避免 legend 切换时 CLAMP_TO_GROUND 数据丢失
     const entityVisible = e._layerVisible && e._regionVisible;
-    // billboard/label 的基础可见性包含图例
-    const baseVisible = e._layerVisible && e._legendVisible && e._regionVisible;
     entity.show = entityVisible;
+
     // 图标单独受碰撞控制
     if (entity.billboard) {
-      (entity.billboard as any).show =
-        baseVisible && e._iconCollisionVisible !== false;
+      this.syncTargetVisibility(entity, 'icon');
     }
     // 标签受碰撞控制（图标隐藏时标签联动隐藏）
     if (entity.label) {
-      (entity.label as any).show =
-        baseVisible && e._labelCollisionVisible !== false;
+      this.syncTargetVisibility(entity, 'label');
     }
   }
 
+  /**
+   * 同步单个目标（icon/label）的显隐：
+   * - 密度门控 / 图层 / 图例 / 区域变化：直接显隐，不做淡入淡出（与 2D 一致）
+   * - 碰撞标志切换：启动淡入/淡出动画
+   */
+  private syncTargetVisibility(
+    entity: Cesium.Entity,
+    target: 'icon' | 'label'
+  ) {
+    const e = entity as any;
+    const baseVisible = e._layerVisible && e._legendVisible && e._regionVisible;
+    const collisionVisible =
+      target === 'icon'
+        ? e._iconCollisionVisible !== false
+        : e._labelCollisionVisible !== false;
+    const desired = baseVisible && collisionVisible;
+
+    // 密度门控：直接显隐，不做淡入淡出
+    if (e._densityVisible === false) {
+      this.cancelFade(entity, target);
+      this.applyGraphicsState(entity, target, desired);
+      return;
+    }
+
+    // 图层/图例/区域导致的隐藏：直接显隐
+    if (!baseVisible) {
+      this.cancelFade(entity, target);
+      this.applyGraphicsState(entity, target, false);
+      return;
+    }
+
+    // 仅碰撞标志变化触发淡入淡出（记录上一次碰撞标志用于判断切换）
+    const prevFlagKey =
+      target === 'icon' ? '_prevIconCollision' : '_prevLabelCollision';
+    const prevFlag = e[prevFlagKey];
+    e[prevFlagKey] = collisionVisible;
+
+    if (prevFlag === undefined) {
+      // 初始状态：不做动画，直接应用
+      this.applyGraphicsState(entity, target, desired);
+      return;
+    }
+    if (prevFlag !== collisionVisible) {
+      this.startFade(entity, collisionVisible ? 'in' : 'out', target);
+    }
+    this.applyGraphicsState(entity, target, desired);
+  }
+
+  /**
+   * 应用图标/文字当前帧的 show 与 alpha。
+   * 淡出/淡入中 show 保持 true、颜色带 alpha；动画结束（getFadeAlpha 已清理标记）后按目标显隐应用，
+   * 并恢复默认颜色（等价于"动画结束可安全置 show=false"）。
+   */
+  private applyGraphicsState(
+    entity: Cesium.Entity,
+    target: 'icon' | 'label',
+    desired: boolean
+  ): void {
+    const e = entity as any;
+    const alpha = this.getFadeAlpha(entity, target);
+    if (target === 'icon') {
+      const b = entity.billboard as any;
+      if (!b) return;
+      if (alpha !== null) {
+        b.show = true;
+        b.color = Cesium.Color.WHITE.withAlpha(alpha);
+        e._iconColorFaded = true;
+      } else {
+        b.show = desired;
+        if (e._iconColorFaded) {
+          b.color = Cesium.Color.WHITE.withAlpha(1); // 恢复默认
+          e._iconColorFaded = false;
+        }
+      }
+    } else {
+      const l = entity.label as any;
+      if (!l) return;
+      if (alpha !== null) {
+        l.show = true;
+        l.fillColor = Cesium.Color.WHITE.withAlpha(alpha);
+        l.outlineColor = new Cesium.Color(0, 0, 0, 0.9 * alpha);
+        e._labelColorFaded = true;
+      } else {
+        l.show = desired;
+        if (e._labelColorFaded) {
+          l.fillColor = Cesium.Color.WHITE; // 恢复默认
+          l.outlineColor = new Cesium.Color(0, 0, 0, 0.9);
+          e._labelColorFaded = false;
+        }
+      }
+    }
+  }
+
+  /**
+   * 启动图标/文字的淡入/淡出动画。
+   * 对应需求：碰撞隐藏时不直接 show=false，而是打上淡出标记 + 起始时间，
+   * 由 tickFadeRefresh 每帧计算 alpha 驱动，动画结束自动清理。
+   */
+  private startFade(
+    entity: Cesium.Entity,
+    dir: 'in' | 'out',
+    target: 'icon' | 'label'
+  ) {
+    const e = entity as any;
+    const outFlag = target === 'icon' ? '_isFadingOut' : '_labelFadingOut';
+    const outStart =
+      target === 'icon' ? '_fadeStartTime' : '_labelFadeStartTime';
+    const inFlag = target === 'icon' ? '_isFadingIn' : '_labelFadingIn';
+    const inStart =
+      target === 'icon' ? '_fadeInStartTime' : '_labelFadeInStartTime';
+
+    if (dir === 'out') {
+      if (e[outFlag]) return;
+      e[outFlag] = true;
+      e[outStart] = performance.now();
+      // 若正在淡入则中断，改向淡出
+      e[inFlag] = false;
+      e[inStart] = 0;
+    } else {
+      if (e[inFlag]) return;
+      e[inFlag] = true;
+      e[inStart] = performance.now();
+      // 若正在淡出则中断，改向淡入
+      e[outFlag] = false;
+      e[outStart] = 0;
+    }
+
+    this.fadingEntities.add(entity);
+    this.requestFadeRefresh();
+  }
+
+  /**
+   * 计算图标/文字的当前 alpha。
+   * 淡出 alpha 1.0→0.0，淡入 0.0→1.0；未在淡变中返回 null。
+   * 动画结束分支：清除淡变标记（自动清理）并返回 null。
+   */
+  private getFadeAlpha(
+    entity: Cesium.Entity,
+    target: 'icon' | 'label'
+  ): number | null {
+    const e = entity as any;
+    const outFlag = target === 'icon' ? '_isFadingOut' : '_labelFadingOut';
+    const outStart =
+      target === 'icon' ? '_fadeStartTime' : '_labelFadeStartTime';
+    const inFlag = target === 'icon' ? '_isFadingIn' : '_labelFadingIn';
+    const inStart =
+      target === 'icon' ? '_fadeInStartTime' : '_labelFadeInStartTime';
+
+    if (e[outFlag]) {
+      const alpha = this.computeFadeAlpha(e[outStart], false);
+      if (alpha === null) {
+        // 淡出结束：自动清理标记
+        e[outFlag] = false;
+        e[outStart] = 0;
+      }
+      return alpha;
+    }
+    if (e[inFlag]) {
+      const alpha = this.computeFadeAlpha(e[inStart], true);
+      if (alpha === null) {
+        // 淡入结束：自动清理标记
+        e[inFlag] = false;
+        e[inStart] = 0;
+      }
+      return alpha;
+    }
+    return null;
+  }
+
+  /** 根据起始时间与当前时间计算 alpha；动画已结束返回 null */
+  private computeFadeAlpha(
+    startTime: unknown,
+    fadingIn: boolean
+  ): number | null {
+    const start = Number(startTime) || 0;
+    const elapsed = performance.now() - start;
+    if (elapsed >= this.FADE_DURATION) {
+      return null;
+    }
+    const progress = Math.max(0, elapsed / this.FADE_DURATION);
+    return fadingIn ? progress : 1 - progress;
+  }
+
+  /** 取消目标的淡变（密度/图层等非碰撞显隐切换时使用） */
+  private cancelFade(entity: Cesium.Entity, target: 'icon' | 'label') {
+    const e = entity as any;
+    if (target === 'icon') {
+      e._isFadingOut = false;
+      e._fadeStartTime = 0;
+      e._isFadingIn = false;
+      e._fadeInStartTime = 0;
+    } else {
+      e._labelFadingOut = false;
+      e._labelFadeStartTime = 0;
+      e._labelFadingIn = false;
+      e._labelFadeInStartTime = 0;
+    }
+  }
+
+  /** 请求一次淡变重绘；已有循环在跑则忽略 */
+  private requestFadeRefresh() {
+    if (this.fadeRefreshFrameId !== null) return;
+    this.fadeRefreshFrameId = requestAnimationFrame(() =>
+      this.tickFadeRefresh()
+    );
+  }
+
+  /**
+   * 淡变驱动循环：requestRenderMode 下每帧主动 requestRender 并应用最新 alpha，
+   * 直到没有任何 entity 处于淡变中（此时已由 getFadeAlpha 清理标记并应用最终显隐）。
+   */
+  private tickFadeRefresh() {
+    this.fadeRefreshFrameId = null;
+    const stillFading: Cesium.Entity[] = [];
+    this.fadingEntities.forEach(entity => {
+      const e = entity as any;
+      let fading = false;
+      if (entity.billboard && this.getFadeAlpha(entity, 'icon') !== null) {
+        fading = true;
+      }
+      if (entity.label && this.getFadeAlpha(entity, 'label') !== null) {
+        fading = true;
+      }
+      if (fading) {
+        stillFading.push(entity);
+      }
+      // 应用当前帧 alpha / 最终显隐
+      if (entity.billboard) {
+        this.applyGraphicsState(
+          entity,
+          'icon',
+          this.collisionDesired(e, 'icon')
+        );
+      }
+      if (entity.label) {
+        this.applyGraphicsState(
+          entity,
+          'label',
+          this.collisionDesired(e, 'label')
+        );
+      }
+    });
+    this.fadingEntities = new Set(stillFading);
+    this.requestRender();
+    if (this.fadingEntities.size > 0) {
+      this.fadeRefreshFrameId = requestAnimationFrame(() =>
+        this.tickFadeRefresh()
+      );
+    }
+  }
+
+  /** 当前图标/标签的目标显隐（基础可见 && 碰撞通过），供淡变循环使用 */
+  private collisionDesired(e: any, target: 'icon' | 'label'): boolean {
+    const baseVisible = e._layerVisible && e._legendVisible && e._regionVisible;
+    if (target === 'icon') {
+      return baseVisible && e._iconCollisionVisible !== false;
+    }
+    return baseVisible && e._labelCollisionVisible !== false;
+  }
+
   // ==================== Step 6: 碰撞检测 ====================
 
   /**
@@ -2614,10 +3196,19 @@ export class MapCesium implements MapInterface {
     }
 
     this._collisionBusy = true;
+    try {
+      // 碰撞检测主体抽到 inner，finally 确保中途异常时也释放防重入锁
+      this.refreshPointLabelVisibilityInner();
+    } finally {
+      // 释放防重入锁（异常也必须释放，否则 _collisionBusy 永久为 true，碰撞检测静默瘫痪）
+      this._collisionBusy = false;
+    }
+  }
 
+  /** 碰撞检测主体（由 refreshPointLabelVisibility 的 try/finally 保护执行） */
+  private refreshPointLabelVisibilityInner(): void {
     const currentZoom = this.getCurrentCesiumZoom();
     if (currentZoom === undefined || currentZoom === null) {
-      this._collisionBusy = false;
       return;
     }
 
@@ -2879,7 +3470,6 @@ export class MapCesium implements MapInterface {
     });
 
     if (candidates.length === 0) {
-      this._collisionBusy = false;
       return;
     }
 
@@ -3047,9 +3637,7 @@ export class MapCesium implements MapInterface {
 
     // 强制触发渲染，确保 Cesium 在下一帧应用 label.show / billboard.show 变更
     this.viewer.scene.requestRender();
-
-    // 释放防重入锁
-    this._collisionBusy = false;
+    // 防重入锁由 refreshPointLabelVisibility 的 finally 统一释放
   }
 
   // ==================== 碰撞检测辅助：密度门控 ====================
@@ -3250,11 +3838,6 @@ export class MapCesium implements MapInterface {
       maxWidth = Math.max(maxWidth, m.width);
     }
 
-    // 用中文字符 '中' 测量实际行高（ascent + descent），兼容 CJK 字体
-    const sample = ctx.measureText('中');
-    const ascent = sample.actualBoundingBoxAscent || roundedFs * 0.8;
-    const descent = sample.actualBoundingBoxDescent || roundedFs * 0.2;
-
     // 宽度 = 文字像素宽度（取多行中最宽的一行，无额外边距）
     const width = maxWidth;
     // 高度 = 字符高度 × 行数（字符高度 ≈ fontSize，无额外边距）
diff --git a/frontend/src/components/gis/map.class.ts b/frontend/src/components/gis/map.class.ts
index d514f8fe..8d8f5b2a 100644
--- a/frontend/src/components/gis/map.class.ts
+++ b/frontend/src/components/gis/map.class.ts
@@ -1,5 +1,4 @@
 import type { layer, MapInterface } from './map.d';
-// import { MapLeaflet } from "./map.leaflet";
 import { MapOl } from './map.ol';
 import { MapCesium } from './map.cesium';
 
@@ -29,7 +28,6 @@ export class MapClass implements MapClassInterface {
   constructor() {
     this.layers = new Map();
     this.view = null;
-    // this.service = new MapLeaflet();
     this.service = new MapOl();
   }
   static getInstance(): MapClass {
@@ -143,6 +141,10 @@ export class MapClass implements MapClassInterface {
   removePointLayer(layerKey: string): void {
     this.service.removePointLayer?.(layerKey);
   }
+  // 漫游模式锚点深度测试开关（仅 3D 有效，2D 无此能力直接忽略）
+  setRoamDepthTest(enabled: boolean): void {
+    this.service.setRoamDepthTest?.(enabled);
+  }
   // 销毁地图
   destroy(): void {
     this.service.destroy();
diff --git a/frontend/src/components/gis/map.d.ts b/frontend/src/components/gis/map.d.ts
index 300ad6b1..e874834c 100644
--- a/frontend/src/components/gis/map.d.ts
+++ b/frontend/src/components/gis/map.d.ts
@@ -213,6 +213,13 @@ export interface MapInterface {
     checked: boolean
   ): void;
 
+  /**
+   * 漫游模式锚点深度测试开关（仅 3D 有效）
+   * 漫游时启用后，锚点文字/图标开启深度测试，被漫游模型正确遮挡
+   * @param enabled 是否处于漫游状态
+   */
+  setRoamDepthTest?(enabled: boolean): void;
+
   /**
    * 长度量算
    */
diff --git a/frontend/src/components/gis/map.leaflet.ts b/frontend/src/components/gis/map.leaflet.ts
deleted file mode 100644
index e7da68d0..00000000
--- a/frontend/src/components/gis/map.leaflet.ts
+++ /dev/null
@@ -1,440 +0,0 @@
-// import { MapInterface } from './map';
-// import * as L from 'leaflet';
-// import * as esriLeaflet from 'esri-leaflet';
-// import '@/utils/leaflet/leaflet-tilelayer-wmts-src.js';
-// import { mapServerBaseUrl } from './map.class';
-// import '@/utils/leaflet/leaflet.inflatable-markers-group.js';
-// import {MDOptions} from './map.class';
-// import { getIconPath } from "@/utils/index";
-// // @ts-ignore
-// import axios from 'axios';
-// // import "@/components/thematicMap/leaflet/leaflet.inflatable-markers-group.js"
-
-// const tiledMapGroup = L.layerGroup();
-// const chartMapGroup = L.layerGroup();
-// const overlayGroup = L.layerGroup();
-// const CENTER_positionCN: any = [38, 114.17112499999996]; //中心纬经度 中国
-// const basinCenter = {
-//   DA_HHGLSX: [103.343357, 35.931812],
-//   FA_CJGLSX: [111.001911, 30.821327]
-// };
-// let boundCavansLayer: any = null;
-// let ganliulist: any = [];
-// export class MapLeaflet implements MapInterface {
-//   map: any = null;
-//   htmlMakerLayer: any = [];
-//   defaultScale = 10;
-//   minimumZoom = 7;
-//   setDrawPlug: any = null;
-//   layermarkers: any = [];
-//   rainlayerslist: any = [];
-//   private layerRegistry: Map<string, any> = new Map(); // ✅ 新增：存储 key -> layer 实例
-
-//   private currentBaseLayerKey: string | null = null; // ✅ 新增：记录当前激活的底图 Key
-
-//   temperatureMapObj: any = [];
-//   //地图初始化
-//   init(container: HTMLElement, rectangle?: any): Promise<any> {
-//     try {
-//       console.log('init初始化container', container);
-//       var corner1 = L.latLng(55.35715491537772, 140.7821677051657);
-//       var corner2 = L.latLng(0.975580441812298, 67.56008229483018);
-//       var bounds = L.latLngBounds(corner2, corner1);
-//       const map = L.map(container as any, {
-//         preferCanvas: true,
-//         zoom: 4.5,
-//         minZoom: 4.23,
-//         maxZoom: 22, // 【修改点1】增大最大缩放级别，允许用户继续滚轮放大
-//         maxNativeZoom: 12,
-//         zoomSnap: 0.1, // 【修改点2】让缩放更平滑，不强制对齐整数
-//         zoomDelta: 0.5,
-//         center: CENTER_positionCN,
-//         attributionControl: false,
-//         zoomControl: false,
-//         trackResize: true,
-//         maxBounds: bounds,
-//         maxBoundsViscosity: 1.0,
-//         wheelPxPerZoomLevel: 180,
-//       });
-//       // ✅ 新增：可视化显示 maxBounds 范围
-//       // L.rectangle(bounds, {color: "#ff7800", weight: 3, opacity: 0.8, fillOpacity: 0.1})
-//       //  .addTo(map)
-//       //  .bindPopup("这是 maxBounds 的范围");
-//       this.map = map;
-//       this.map.on('zoomend', (e: any) => {
-//         console.log('当前缩放级别', e.target.getZoom());
-//       });
-//       return Promise.resolve(map);
-//     } catch (e) {
-//       console.log('测试', e);
-//       return Promise.reject({});
-//     }
-//   }
-//   addBaseDataLayer(layer: any): any {
-//     // The WMTS URL
-//     console.log(layer);
-//     switch (layer.type) {
-//       case 'wmts':
-//         if (layer.url) {
-//           console.log('https://211.99.26.225:18085' + layer.url);
-//           if (layer) {
-//             var ignLayer = L.tileLayer
-//               .wmts('https://211.99.26.225:18085/geoserver/gwc/service/wmts', {
-//                 tileMatrixSet: 'EPSG:3857_qgc_qsj_arcgistiles_l13',
-//                 tileSize: 256, //切片大小
-//                 maxZoom: 13,
-//                 noWrap: true,
-//                 opacity: 0.99,
-//                 minZoom: 4,
-//                 styles:{
-//                   abc:123
-//                 },
-//                 layer: 'qgc_qsj_arcgistiles_l13'
-//               })
-//               .addTo(this.map)
-//               .bringToBack();
-//               const registryKey = layer.key || layer.title;
-//           if (registryKey) {
-//               this.layerRegistry.set(registryKey, ignLayer);
-//           }
-//             layer._layer = ignLayer;
-//             layer._layer.layerGroup = overlayGroup;
-//           }
-//         }
-//         return layer;
-
-//       case 'markers':
-//         this.getRain(layer);
-//         break;
-//       default: {
-//         return;
-//       }
-//     }
-//   }
-
-//    baseLayerSwitcher(key: string) {
-//     if (!this.map) return;
-
-//     console.log('切换底图 key:', key);
-
-//     // 1. 如果当前已有底图且不是同一个，先移除
-//     if (this.currentBaseLayerKey && this.currentBaseLayerKey !== key) {
-//       const oldLayer = this.layerRegistry.get(this.currentBaseLayerKey);
-//       if (oldLayer && this.map.hasLayer(oldLayer)) {
-//         this.map.removeLayer(oldLayer);
-//         console.log(`已移除旧底图: ${this.currentBaseLayerKey}`);
-//       }
-//     }
-
-//     // 2. 检查新底图是否已存在 registry 中
-//     let newLayer = this.layerRegistry.get(key);
-
-//     // 3. 如果不存在，则创建并添加到地图和 registry
-//     if (!newLayer) {
-//       newLayer = this.createBaseLayerByKey(key);
-//       if (newLayer) {
-//         this.layerRegistry.set(key, newLayer);
-//         newLayer.addTo(this.map);
-//         // 确保底图在最底层
-//         newLayer.bringToBack();
-//       }
-//     } else {
-//       // 4. 如果已存在，直接添加（如果未添加）
-//       if (!this.map.hasLayer(newLayer)) {
-//         newLayer.addTo(this.map);
-//         newLayer.bringToBack();
-//       }
-//     }
-
-//     // 5. 更新当前激活的 Key
-//     if (newLayer) {
-//       this.currentBaseLayerKey = key;
-//     }
-//   }
-
-//   /**
-//    * 根据 Key 创建具体的 Leaflet 图层实例
-//    */
-//    createBaseLayerByKey(key: string): L.Layer | null {
-//     console.log(key)
-//     const tdtToken = 'e90d56e5a09d1767899ad45846b0cefd' //企业版密钥，勿换e650f138c4481cca888cd13094bb9026
-//     const mapType = 'w' //c:天地图经纬度底图;w:天地图墨卡托底图
-//     const URL_TerTDT = `https://t0.tianditu.gov.cn/ter_${mapType}/wmts?tk=${tdtToken}` //terMap
-//     switch (key) {
-//       case 's_province_boundaries':
-//         // 假设这是之前的 WMTS 矢量图层
-//         // 注意：原代码中硬编码了 URL 和 layer 名称，这里需要确保与实际服务对应
-//         return L.tileLayer.wmts('https://211.99.26.225:18085/geoserver/gwc/service/wmts', {
-//           tileMatrixSet: 'EPSG:3857_qgc_qsj_arcgistiles_l13',
-//           tileSize: 256,
-//           // maxZoom: 13,
-//           noWrap: true,
-//           opacity: 1,
-//           minZoom: 4,
-//                 zIndex: 1,
-//           layer: 'qgc_qsj_arcgistiles_l13', // 请确认此 layer 名称是否对应“矢量”
-//           format: 'image/png'
-//         });
-
-//       case 'BASEMAP-white':
-//         // 地形图示例 (使用 OpenStreetMap 或其他地形服务作为占位，请替换为实际地址)
-//         return L.tileLayer(`${URL_TerTDT}&SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=ter&STYLE=default&TILEMATRIXSET=${mapType}&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&FORMAT=tiles`, {
-//           // maxZoom: 17,
-//                 format: "image/png",
-//                 zIndex: 12,
-//           attribution: 'Map data: &copy; OpenStreetMap contributors, SRTM | Map style: &copy; OpenTopoMap (CC-BY-SA)'
-//         });
-
-//       case 'BASEMAP-img':
-//         // 影像图示例 (使用 Esri World Imagery 作为占位，请替换为实际地址)
-//         return L.tileLayer('https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', {
-//           attribution: 'Tiles &copy; Esri &mdash; Source: Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community'
-//         });
-
-//       default:
-//         console.warn(`未知的底图 Key: ${key}`);
-//         return null;
-//     }
-//   }
-
-//   controlBaseLayerTreeShowAndHidden(layerType: String, key: String, checked: boolean) {
-//           // 优先使用 key 查找，如果没有 key 则尝试用 layerType
-//           // console.log(this.getAllLayers())
-//           console.log(key)
-//           console.log(this.layerRegistry)
-//     const registryKey:any = key || layerType;
-//     const layerInstance = this.layerRegistry.get(registryKey);
-//     if (layerInstance) {
-//       if (checked) {
-//         // 显示：如果不在地图上，则添加
-//         if (!this.map.hasLayer(layerInstance)) {
-//           layerInstance.addTo(this.map);
-//         }
-//       } else {
-//         // 隐藏：如果在地图上，则移除
-//         if (this.map.hasLayer(layerInstance)) {
-//           this.map.removeLayer(layerInstance);
-//         }
-//       }
-//     } else {
-//       console.warn(`未找到标识为 ${registryKey} 的图层实例`);
-//     }
-//   }
-
-//       /**
-//    * 添加初始化数据图层
-//    * @param pointLayerObj 图层配置对象 (包含 data, key, checked 等属性)
-//    * @param layerType 图层类型/Key (如果 pointLayerObj 中有 key，则优先使用 obj.key)
-//    * @param mdoptions 描点选项配置
-//    * @param legendArray 图例映射数据 (用于根据 anchoPointState 匹配图标)
-//    */
-//   addInitDataLayer = (pointLayerObj: any, layerType?: any, mdoptions?: MDOptions, legendArray?: any) => {
-//     // 1. 参数校验与数据提取
-//     if (!this.map || !pointLayerObj) {
-//       return;
-//     }
-
-//     let dataArray: any[] = [];
-//     let targetLayerKey: string = layerType;
-
-//     if (Array.isArray(pointLayerObj)) {
-//       dataArray = pointLayerObj;
-//     } else {
-//       dataArray = pointLayerObj.data || [];
-//       targetLayerKey = pointLayerObj.key || layerType;
-//     }
-
-//     if (!targetLayerKey) {
-//       console.warn('缺少图层 Key，无法加载描点');
-//       return;
-//     }
-
-//     if (dataArray.length === 0) {
-//       const existingGroup = this.layerRegistry.get(targetLayerKey);
-//       if (existingGroup && existingGroup instanceof L.LayerGroup) {
-//         existingGroup.clearLayers();
-//       }
-//       return;
-//     }
-
-//     console.log(`开始加载图层 [${targetLayerKey}] 的描点，数量: ${dataArray.length}`);
-
-//     // 2. 获取或创建该图层的 LayerGroup
-//     let layerGroup = this.layerRegistry.get(targetLayerKey);
-
-//     const shouldClear = mdoptions?.isRemove !== false;
-
-//     if (!layerGroup || !(layerGroup instanceof L.LayerGroup)) {
-//       if (layerGroup && this.map.hasLayer(layerGroup)) {
-//         this.map.removeLayer(layerGroup);
-//       }
-//       layerGroup = L.layerGroup();
-//       this.layerRegistry.set(targetLayerKey, layerGroup);
-//       layerGroup.addTo(this.map);
-//     } else {
-//       if (shouldClear) {
-//         layerGroup.clearLayers();
-//       }
-//     }
-
-//     // 3. 遍历数据生成 Marker
-//     dataArray.forEach((item: any) => {
-//       const { lgtd, lttd, stcd, stnm, iconCode, anchoPointState, _id, titleName, ennm } = item;
-
-//       if (lgtd == null || lttd == null) {
-//         return;
-//       }
-
-//       // 4. 确定图标样式和文字
-//       let iconUrl = '';
-//       let iconSize = [15, 15];
-
-//       // 获取图标 URL
-//       if (iconCode) {
-//         iconUrl = getIconPath(iconCode);
-//       } else if (anchoPointState && legendArray) {
-//         const legendItem = legendArray[anchoPointState];
-//         if (legendItem && legendItem.icon) {
-//           iconUrl = getIconPath(legendItem.icon);
-//           if (legendItem.width && legendItem.height) {
-//              iconSize = [legendItem.width, legendItem.height];
-//           }
-//         }
-//       }
-
-//       // 如果没有找到图标，使用默认或跳过
-//       if (!iconUrl) {
-//          // 可以选择使用默认图标或者继续
-//          iconUrl = getIconPath('default'); // 假设有一个默认图标
-//          if(!iconUrl) return;
-//       }
-
-//       // 5. 创建带文字的 DivIcon
-//       // 显示的文字优先使用 titleName，其次 ennm，最后 stnm
-//       const labelText = titleName || ennm || stnm || '';
-
-//       // 构建 HTML 结构：一个容器包含图片和文字
-//       // 注意：这里使用内联样式简单演示，建议在实际项目中提取到 CSS 类中
-//       const iconHtml = `
-//         <div style="position: relative; display: flex; flex-direction: column; align-items: center; width: max-content;">
-//           <div style="
-//             font: 10px sans-serif;
-//             font-weight: bold;
-//             color: #fff;
-//             white-space: nowrap;
-//             margin-bottom: 2px;
-//             -webkit-text-stroke: 2px #2e2d2d;
-//             paint-order: stroke fill; /* 确保描边在填充外部，防止文字变细 */
-
-//           ">
-//             ${labelText}
-//           </div>
-//           <img src="${iconUrl}" style="width: ${iconSize[0]}px; height: ${iconSize[1]}px; display: block;" />
-//         </div>`;
-
-//       const customIcon = L.divIcon({
-//         html: iconHtml,
-//         className: '', // 重要：设置为空字符串以避免 Leaflet 默认样式干扰
-//         iconSize: [iconSize[0], iconSize[1] + 20], // 高度增加以容纳文字 (假设文字高约20px)
-//         iconAnchor: [iconSize[0] / 2, iconSize[1] + 10], // 锚点设在图片底部中心
-//         popupAnchor: [0, -(iconSize[1] + 20)] // 弹窗锚点设在整体顶部
-//       });
-
-//       // 6. 创建 Marker
-//  const marker = L.marker([lttd, lgtd], {
-//         icon: customIcon,
-//         // @ts-ignore
-//         options: {
-//           ...item,
-//           layerKey: targetLayerKey,
-//           originalEvent: item
-//         }
-//       });
-
-//       // 7. 绑定点击事件 (如果需要)
-//       marker.on('click', (e: any) => {
-//         // 触发全局事件，例如：
-//         // GlobalEvents.get('map_dataLayer_click').set(item);
-//         console.log('Marker clicked:', item);
-//       });
-
-//       // 8. 将 Marker 添加到 LayerGroup
-//       layerGroup.addLayer(marker);
-//     });
-
-//     console.log(`图层 [${targetLayerKey}] 描点加载完成`);
-//   }
-//   getRain(data: any) {
-//     if (data?.geojson) {
-//       this.removeRainLayer();
-//       this.removeLayermarkers();
-//       const renderColor = (item: any, colRules: any) => {
-//         let color = 'rgba(0,0,0,0)';
-//         colRules.map((rule: any, index: number) => {
-//           if (
-//             item.properties.hvalue >= rule?.sv &&
-//             item.properties.hvalue < rule?.ev
-//           ) {
-//             color = rule.colors;
-//           }
-//           if (index === colRules.length - 1) {
-//             if (item.properties.hvalue >= rule?.ev) {
-//               color = rule.colors;
-//             }
-//           }
-//         });
-//         return color;
-//       };
-
-//       data.geojson.features.map((item: any, index: number) => {
-//         let pushlist = L.geoJSON(item, {
-//           style: {
-//             color: renderColor(item, data.colRules),
-//             weight: 2,
-//             opacity: 0.8,
-//             fillOpacity: 0.7
-//             // fillColor: "#1D91C0",
-//           }
-//         }).addTo(this.map);
-//         this.layermarkers.push(pushlist);
-//       });
-//     }
-//   }
-//   removeLayermarkers = () => {
-//     // console.log('layermarkers',layermarkers);
-
-//     try {
-//       if (this.layermarkers.length > 0) {
-//         if (this.map.hasLayer(this.layermarkers)) {
-//           this.map.removeLayer(this.layermarkers);
-//         } else {
-//           console.log('移除图层失败，应已经移除');
-//         }
-//       }
-//       // removeAllGeojson(map);
-//     } catch (e) {
-//       // message.info('移除图层失败')
-//       console.log('移除图层失败，是否应移除');
-//     }
-//   };
-
-//   removeRainLayer(): void {
-//     console.log('test!删除Layer');
-//     const _this = this;
-//     if (this.rainlayerslist.length > 0) {
-//       this.rainlayerslist.map((item: any) => {
-//         _this.map.removeLayer(item);
-//       });
-//       this.rainlayerslist = [];
-//     }
-//   } // 缩放
-//   zoomToggle(type: 'out' | 'in') {
-//     if (this.map) {
-//       if (type === 'out') {
-//         this.map && this.map.zoomOut();
-//       } else {
-//         this.map && this.map.zoomIn();
-//       }
-//     }
-//   }
-// }
diff --git a/frontend/src/components/gis/map.ol.ts b/frontend/src/components/gis/map.ol.ts
index 55ad7d39..31048ba0 100644
--- a/frontend/src/components/gis/map.ol.ts
+++ b/frontend/src/components/gis/map.ol.ts
@@ -50,6 +50,9 @@ const MAX_ZOOM = 22;
 const INITIAL_ZOOM = 4.5;
 const BATCH_POPUP_MODE_ZOOM = 15;
 const FULL_DISPLAY_NO_COLLISION_ZOOM = Number.POSITIVE_INFINITY;
+const POINT_FADE_DURATION = 300; // 锚点/文字碰撞显隐的淡入淡出时长(ms)
+// 标签文字上方的避让边距(px)：防止下方锚点文字紧贴上方锚点图标底部，看着像重叠
+const LABEL_ICON_TOP_CLEARANCE = 6;
 
 // 定义边界 [minX, minY, maxX, maxY] (Web Mercator 坐标)
 const BOUNDS_SW = [26.5, -9.99999999999929];
@@ -61,6 +64,13 @@ export class MapOl implements MapInterface {
   private layerRegistry: Map<string, any> = new Map();
   private iconLoadState = new Map<string, 'loading' | 'loaded' | 'error'>();
   private pointStyleCache = new Map<string, Style[]>();
+  private measureCanvas: HTMLCanvasElement | null = null;
+  private measureTextCache = new Map<
+    string,
+    { width: number; height: number }
+  >();
+  private fadeRefreshFrameId: number | null = null;
+  private fadingFeatures = new Set<Feature>();
   private baseLayerConfig: any | null = null;
   private hydropBaseConfig: any | null = null;
   private REGISTRY_KEY = 'customBaseLayer';
@@ -75,7 +85,6 @@ export class MapOl implements MapInterface {
   private BASEID = '';
   private currentClipGeoJson: any | null = null;
   private clipRequestController: AbortController | null = null;
-  private hoveredFeatureId: string | number | null = null;
   private wfsHighlightLayer: VectorLayer | null = null;
   private popupManager: PopupManager;
   private regionMaskManager: RegionMaskManager;
@@ -256,25 +265,30 @@ export class MapOl implements MapInterface {
           }
         }
 
-        // 命中河段时直接切换鼠标样式（与 demo 一致，popup 是节流回调不能依赖它）
+        // 命中河段或锚点时直接切换鼠标样式（与 demo 一致，popup 是节流回调不能依赖它）
         const targetElement = this.map?.getTargetElement() as HTMLElement;
+        let isHitAnchor = false;
         if (targetElement) {
-          targetElement.style.cursor = hitFeature ? 'pointer' : '';
+          isHitAnchor = this.detectFeatureAtPixel(evt.pixel).isHitIcon;
+          targetElement.style.cursor =
+            isHitAnchor || hitFeature ? 'pointer' : '';
         }
 
         this.popupManager.handlePointerMove(evt.pixel, payload => {
-          this.hoveredFeatureId = payload.hoveredId;
-
           if (targetElement) {
             // 命中河段或 hover popup 命中锚点时显示 pointer 光标
             targetElement.style.cursor =
-              payload.hoveredId || hitFeature ? 'pointer' : '';
+              isHitAnchor || payload.hoveredId || hitFeature ? 'pointer' : '';
           }
 
-          // 批量 popup 模式下不触发 hover popup
-          if (!this.isBatchPopupMode) {
-            this.showPopup(payload.detectedFeature, payload.coordinate);
-          }
+          // 该锚点已有固定展示（批量 popup）的 popup，跳过 hover popup，避免同一内容出现双份；
+          // 未被固定展示的锚点（如碰撞被隐藏）仍可通过 hover 查看，且 hover popup 展示时会临时提升层级，不被固定展示遮挡
+          const fixedShown =
+            payload.detectedFeature?.get('_fixedPopupShown') === true;
+          this.showPopup(
+            fixedShown ? undefined : payload.detectedFeature,
+            fixedShown ? undefined : payload.coordinate
+          );
         });
       });
 
@@ -475,25 +489,48 @@ export class MapOl implements MapInterface {
     const iconCollisionVisible = feature.get('_iconCollisionVisible') !== false;
     const labelCollisionVisible =
       feature.get('_labelCollisionVisible') === true;
-    const finalIconVisible = iconTargetVisible && iconCollisionVisible;
-    const labelTargetVisible =
-      !this.isBatchPopupMode &&
-      finalIconVisible &&
-      !!formattedLabelText &&
-      labelCollisionVisible;
 
-    if (!finalIconVisible) {
+    // 淡入淡出 alpha（null = 未在淡变中）
+    const iconAlpha = this.getFadeAlpha(feature, 'icon');
+    const labelAlpha = this.getFadeAlpha(feature, 'label');
+    const isIconFading = iconAlpha !== null;
+    const isLabelFading = labelAlpha !== null;
+
+    const finalIconVisible = iconTargetVisible && iconCollisionVisible;
+    // 碰撞隐藏时仍在淡出中则继续渲染，动画结束（alpha 归 0）后才会真正隐藏
+    const iconRendered = finalIconVisible || isIconFading;
+
+    // 图例/区域/密度隐藏：不做淡出，直接隐藏
+    if (!iconTargetVisible) {
       return null;
     }
 
+    // 碰撞隐藏且不在淡出中：直接隐藏
+    if (!iconRendered) {
+      return null;
+    }
+
+    const labelRenderVisible =
+      !this.isBatchPopupMode &&
+      iconRendered &&
+      !!formattedLabelText &&
+      (labelCollisionVisible || isLabelFading);
+
+    const iconRenderAlpha = iconAlpha ?? 1;
+    const labelRenderAlpha = labelAlpha ?? 1;
+    // 文字淡变跟随整锚点：取锚点与文字各自 alpha 的最小值
+    const effectiveLabelAlpha = Math.min(iconRenderAlpha, labelRenderAlpha);
+    const fading = isIconFading || isLabelFading;
+
     const styleCacheKey = [
       iconUrl,
       dynamicScale.toFixed(2),
       fontSize,
       engPriority,
       labelOffsetY,
-      labelTargetVisible ? formattedLabelText : '',
-      labelTargetVisible ? 1 : 0
+      labelRenderVisible ? formattedLabelText : '',
+      labelRenderVisible ? 1 : 0,
+      fading ? 1 : 0
     ].join('|');
     const cachedStyles = this.pointStyleCache.get(styleCacheKey);
     if (cachedStyles) {
@@ -508,12 +545,13 @@ export class MapOl implements MapInterface {
           scale: dynamicScale,
           anchor: [0.5, 0.5],
           crossOrigin: 'anonymous',
-          declutterMode: 'none'
+          declutterMode: 'none',
+          opacity: iconRenderAlpha
         })
       })
     ];
 
-    if (formattedLabelText && labelTargetVisible) {
+    if (formattedLabelText && labelRenderVisible) {
       styles.push(
         new Style({
           zIndex: engPriority + 1,
@@ -521,9 +559,11 @@ export class MapOl implements MapInterface {
             text: formattedLabelText,
             offsetY: labelOffsetY,
             font: `${fontSize}px sans-serif`,
-            fill: new Fill({ color: '#fff' }),
+            fill: new Fill({
+              color: `rgba(255, 255, 255, ${effectiveLabelAlpha})`
+            }),
             stroke: new Stroke({
-              color: 'rgba(0, 0, 0, 0.9)',
+              color: `rgba(0, 0, 0, ${0.9 * effectiveLabelAlpha})`,
               width: 2
             }),
             textAlign: 'center',
@@ -533,7 +573,9 @@ export class MapOl implements MapInterface {
       );
     }
 
-    this.pointStyleCache.set(styleCacheKey, styles);
+    if (!fading) {
+      this.pointStyleCache.set(styleCacheKey, styles);
+    }
     return styles;
   }
 
@@ -543,7 +585,8 @@ export class MapOl implements MapInterface {
     visible: boolean,
     dirtyLayerKeys?: Set<string>
   ) {
-    if (feature.get(key) === visible) {
+    const prev = feature.get(key);
+    if (prev === visible) {
       return;
     }
 
@@ -552,6 +595,21 @@ export class MapOl implements MapInterface {
     if (dirtyLayerKeys && layerKey) {
       dirtyLayerKeys.add(String(layerKey));
     }
+
+    // 碰撞显隐切换时启动淡入淡出（初始状态 prev 为 undefined 时不做动画）
+    if (key === '_iconCollisionVisible') {
+      if (prev === true && !visible) {
+        this.startFade(feature, 'out', 'icon');
+      } else if (prev === false && visible) {
+        this.startFade(feature, 'in', 'icon');
+      }
+    } else if (key === '_labelCollisionVisible') {
+      if (prev === true && !visible) {
+        this.startFade(feature, 'out', 'label');
+      } else if (prev === false && visible) {
+        this.startFade(feature, 'in', 'label');
+      }
+    }
   }
 
   private flushDirtyPointLayers(dirtyLayerKeys: Set<string>) {
@@ -561,6 +619,127 @@ export class MapOl implements MapInterface {
     });
   }
 
+  /**
+   * 启动锚点（icon）或文字（label）的淡入/淡出动画。
+   * 对应需求：碰撞隐藏时不直接 show=false，而是打上淡出标记 + 起始时间，
+   * 由 createPointStyle（等价于 Cesium 的 alpha 回调）每帧计算 alpha 驱动淡出。
+   */
+  private startFade(
+    feature: Feature,
+    dir: 'in' | 'out',
+    target: 'icon' | 'label'
+  ) {
+    const outFlag = target === 'icon' ? '_isFadingOut' : '_labelFadingOut';
+    const outStart =
+      target === 'icon' ? '_fadeStartTime' : '_labelFadeStartTime';
+    const inFlag = target === 'icon' ? '_isFadingIn' : '_labelFadingIn';
+    const inStart =
+      target === 'icon' ? '_fadeInStartTime' : '_labelFadeInStartTime';
+
+    if (dir === 'out') {
+      if (feature.get(outFlag)) return;
+      feature.set(outFlag, true, true);
+      feature.set(outStart, performance.now(), true);
+      // 若正在淡入则中断，改向淡出
+      feature.set(inFlag, false, true);
+      feature.set(inStart, 0, true);
+    } else {
+      if (feature.get(inFlag)) return;
+      feature.set(inFlag, true, true);
+      feature.set(inStart, performance.now(), true);
+      // 若正在淡出则中断，改向淡入
+      feature.set(outFlag, false, true);
+      feature.set(outStart, 0, true);
+    }
+
+    this.fadingFeatures.add(feature);
+    this.requestFadeRefresh();
+  }
+
+  /**
+   * 计算锚点/文字的当前 alpha。
+   * 淡出 alpha 1.0→0.0，淡入 0.0→1.0；未在淡变中返回 null。
+   * 动画结束分支：清除淡变标记（自动清理），并返回 null，
+   * 由调用方按碰撞标志决定最终显隐（等价于"结束时可安全置 show=false"）。
+   */
+  private getFadeAlpha(
+    feature: Feature,
+    target: 'icon' | 'label'
+  ): number | null {
+    const outFlag = target === 'icon' ? '_isFadingOut' : '_labelFadingOut';
+    const outStart =
+      target === 'icon' ? '_fadeStartTime' : '_labelFadeStartTime';
+    const inFlag = target === 'icon' ? '_isFadingIn' : '_labelFadingIn';
+    const inStart =
+      target === 'icon' ? '_fadeInStartTime' : '_labelFadeInStartTime';
+
+    if (feature.get(outFlag)) {
+      const alpha = this.computeFadeAlpha(feature.get(outStart), false);
+      if (alpha === null) {
+        // 淡出结束：自动清理标记
+        feature.set(outFlag, false, true);
+        feature.set(outStart, 0, true);
+      }
+      return alpha;
+    }
+    if (feature.get(inFlag)) {
+      const alpha = this.computeFadeAlpha(feature.get(inStart), true);
+      if (alpha === null) {
+        // 淡入结束：自动清理标记
+        feature.set(inFlag, false, true);
+        feature.set(inStart, 0, true);
+      }
+      return alpha;
+    }
+    return null;
+  }
+
+  /** 根据起始时间与当前时间计算 alpha；动画已结束返回 null */
+  private computeFadeAlpha(
+    startTime: unknown,
+    fadingIn: boolean
+  ): number | null {
+    const start = Number(startTime) || 0;
+    const elapsed = performance.now() - start;
+    if (elapsed >= POINT_FADE_DURATION) {
+      return null;
+    }
+    const progress = Math.max(0, elapsed / POINT_FADE_DURATION);
+    return fadingIn ? progress : 1 - progress;
+  }
+
+  /** 请求一次淡变重绘；已有循环在跑则忽略 */
+  private requestFadeRefresh() {
+    if (this.fadeRefreshFrameId !== null) return;
+    this.fadeRefreshFrameId = requestAnimationFrame(() =>
+      this.tickFadeRefresh()
+    );
+  }
+
+  /**
+   * 淡变驱动循环：每帧让所有点图层重绘一次（createPointStyle 会读取最新 alpha），
+   * 直到没有任何 feature 处于淡变中（此时已由 getFadeAlpha 清理标记，样式函数返回最终显隐）。
+   */
+  private tickFadeRefresh() {
+    this.fadeRefreshFrameId = null;
+    const stillFading: Feature[] = [];
+    this.fadingFeatures.forEach(feature => {
+      if (
+        this.getFadeAlpha(feature, 'icon') !== null ||
+        this.getFadeAlpha(feature, 'label') !== null
+      ) {
+        stillFading.push(feature);
+      }
+    });
+    this.fadingFeatures = new Set(stillFading);
+    this.pointLayerManager.forEachLayer(layer => layer.changed());
+    if (this.fadingFeatures.size > 0) {
+      this.fadeRefreshFrameId = requestAnimationFrame(() =>
+        this.tickFadeRefresh()
+      );
+    }
+  }
+
   private syncFeatureDensityVisible(
     feature: Feature,
     visible: boolean,
@@ -937,15 +1116,18 @@ export class MapOl implements MapInterface {
       const iconBottom = entry.pixelY + iconCollisionSize / 2 + iconPadding;
       const labelText = entry.labelText;
       const fontSize = this.getPointFontSize(dynamicScale);
-      const lines = labelText ? labelText.split('\n') : [''];
-      const maxLineLength = Math.max(...lines.map(line => line.length), 1);
-      const labelLineCount = lines.length;
-      const labelOffsetY = this.getPointLabelCollisionOffsetY(
+      const labelLineCount = labelText ? labelText.split('\n').length : 1;
+      // 碰撞偏移与渲染偏移统一，保证碰撞块与实际渲染文字完全重合
+      const labelOffsetY = this.getPointLabelRenderOffsetY(
         dynamicScale,
         labelLineCount
       );
-      const estimatedWidth = maxLineLength * fontSize * 0.6 + 16;
-      const estimatedHeight = labelLineCount * (fontSize + 4) + 8;
+      // 碰撞块大小 = 文字实测像素大小（Canvas 2D measureText 精确测量，与 3D 对齐）
+      const measured = labelText
+        ? this.measureLabelPixelSize(labelText, fontSize)
+        : { width: 0, height: 0 };
+      const labelWidth = measured.width;
+      const labelHeight = measured.height;
       const centerX = entry.pixelX;
       const centerY = entry.pixelY + labelOffsetY;
       const candidateId = String(
@@ -967,10 +1149,10 @@ export class MapOl implements MapInterface {
         iconTop,
         iconBottom,
         hasLabel: !!labelText,
-        left: centerX - estimatedWidth / 2,
-        right: centerX + estimatedWidth / 2,
-        top: centerY - estimatedHeight / 2,
-        bottom: centerY + estimatedHeight / 2,
+        left: centerX - labelWidth / 2,
+        right: centerX + labelWidth / 2,
+        top: centerY - labelHeight / 2,
+        bottom: centerY + labelHeight / 2,
         priority: Number(entry.feature.get('_nearbyPriority') || 9999),
         engPriority: this.getFeatureEngRenderPriority(entry.feature),
         densityPriority: entry.densityPriority,
@@ -1307,6 +1489,71 @@ export class MapOl implements MapInterface {
     });
   }
 
+  /** 复用离屏 canvas 获取 2d context */
+  private getMeasureCtx(): CanvasRenderingContext2D | null {
+    if (!this.measureCanvas) {
+      this.measureCanvas = document.createElement('canvas');
+      this.measureCanvas.width = 1;
+      this.measureCanvas.height = 1;
+    }
+    return this.measureCanvas.getContext('2d');
+  }
+
+  /**
+   * 用 Canvas 2D measureText 精确测量文字在屏幕上的像素宽度和高度（与 3D 实现对齐），
+   * 碰撞块的大小 = 文字实际大小。结果按 `text@roundedFontSize` 缓存，fontSize 随 zoom 变化时自动失效。
+   * 宽度优先取墨迹实测（actualBoundingBoxLeft/Right），避免 CJK 字体右留白导致块比文字宽。
+   * @param text 标签文字（支持多行 \n 分隔）
+   * @param fontSize 标签实际使用的像素字号
+   * @returns { width, height } 像素尺寸
+   */
+  private measureLabelPixelSize(
+    text: string,
+    fontSize: number
+  ): { width: number; height: number } {
+    const roundedFs = Math.round(fontSize);
+    const cacheKey = `${text}@${roundedFs}`;
+    const cached = this.measureTextCache.get(cacheKey);
+    if (cached) return cached;
+
+    const ctx = this.getMeasureCtx();
+    // fallback：canvas 不可用时用简单估算（极少发生）
+    if (!ctx) {
+      const lines = text.split('\n');
+      const maxLen = Math.max(...lines.map(l => l.length), 1);
+      const fallback = {
+        width: maxLen * roundedFs + 20,
+        height: lines.length * (roundedFs + 4) + 8
+      };
+      this.measureTextCache.set(cacheKey, fallback);
+      return fallback;
+    }
+
+    ctx.font = `${roundedFs}px sans-serif`;
+    const lines = text.split('\n');
+
+    let maxWidth = 0;
+    for (const line of lines) {
+      const metrics = ctx.measureText(line);
+      // 墨迹宽 = 左右墨迹边界之和；浏览器不支持 actualBoundingBox 时退回排版宽
+      const inkWidth =
+        metrics.actualBoundingBoxLeft !== undefined &&
+        metrics.actualBoundingBoxRight !== undefined
+          ? metrics.actualBoundingBoxLeft + metrics.actualBoundingBoxRight
+          : metrics.width;
+      maxWidth = Math.max(maxWidth, inkWidth);
+    }
+
+    // 宽度 = 文字墨迹像素宽度（取多行中最宽的一行，无额外边距）
+    const width = maxWidth;
+    // 高度 = 行数 × 字号（与 3D 对齐，作为文字块的像素高度）
+    const height = lines.length * roundedFs;
+
+    const result = { width, height };
+    this.measureTextCache.set(cacheKey, result);
+    return result;
+  }
+
   private checkLabelCollision(
     left: { left: number; right: number; top: number; bottom: number },
     right: { left: number; right: number; top: number; bottom: number }
@@ -1334,12 +1581,20 @@ export class MapOl implements MapInterface {
       top: iconRect.top + inset,
       bottom: iconRect.bottom - inset
     };
+    // 标签块向上扩展避让边距（等价于给文字加"上边距"），
+    // 让下方锚点文字不再紧贴上方锚点图标底部（含文字描边/图标视觉边缘）看着像重叠
+    const extendedLabelRect = {
+      left: labelRect.left,
+      right: labelRect.right,
+      top: labelRect.top - LABEL_ICON_TOP_CLEARANCE,
+      bottom: labelRect.bottom
+    };
 
     return !(
-      narrowedIconRect.right + padding <= labelRect.left ||
-      narrowedIconRect.left - padding >= labelRect.right ||
-      narrowedIconRect.bottom + padding <= labelRect.top ||
-      narrowedIconRect.top - padding >= labelRect.bottom
+      narrowedIconRect.right + padding <= extendedLabelRect.left ||
+      narrowedIconRect.left - padding >= extendedLabelRect.right ||
+      narrowedIconRect.bottom + padding <= extendedLabelRect.top ||
+      narrowedIconRect.top - padding >= extendedLabelRect.bottom
     );
   }
 
@@ -1397,17 +1652,6 @@ export class MapOl implements MapInterface {
     return labelLineCount > 1 ? -30 * dynamicScale : -22 * dynamicScale;
   }
 
-  /**
-   * 统一计算标签碰撞时的纵向偏移。
-   * 这里允许比视觉位置略高一点，避免相邻点图标过早压掉主标签。
-   */
-  private getPointLabelCollisionOffsetY(
-    dynamicScale: number,
-    labelLineCount: number
-  ): number {
-    return labelLineCount > 1 ? -36 * dynamicScale : -28 * dynamicScale;
-  }
-
   /**
    * distance 字段表示点位密度分档，不是物理距离。
    * 这里仅用它决定点位从哪个缩放级别开始参与显示候选。
@@ -2684,6 +2928,13 @@ export class MapOl implements MapInterface {
     this.clearBatchPopupPostRenderSync();
     this.removeQueryLayer();
     this.regionMaskManager.destroy();
+    this.measureTextCache.clear();
+    this.measureCanvas = null;
+    if (this.fadeRefreshFrameId !== null) {
+      cancelAnimationFrame(this.fadeRefreshFrameId);
+      this.fadeRefreshFrameId = null;
+    }
+    this.fadingFeatures.clear();
 
     const clearLayer = (layer: any) => {
       if (layer && layer.getSource) {
diff --git a/frontend/src/components/gis/ol/popup-manager.ts b/frontend/src/components/gis/ol/popup-manager.ts
index 929d8dfb..a52fc1c4 100644
--- a/frontend/src/components/gis/ol/popup-manager.ts
+++ b/frontend/src/components/gis/ol/popup-manager.ts
@@ -38,8 +38,6 @@ export class PopupManager {
   private lastHoveredId: string | number | null = null;
   private animationFrameId: number | null = null;
   private getPointLayers: () => VectorLayer<VectorSource>[];
-  private popupMouseEnterHandler: (() => void) | null = null;
-  private popupMouseMoveHandler: (() => void) | null = null;
   private hoverChangeHandler:
     | ((payload: PointerMoveChangePayload) => void)
     | undefined;
@@ -63,17 +61,6 @@ export class PopupManager {
     this.popupElement.style.removeProperty('left');
     this.popupElement.style.removeProperty('top');
     this.popupElement.style.setProperty('pointer-events', 'none', 'important');
-    this.popupMouseEnterHandler = () => {
-      this.forceHidePopup();
-    };
-    this.popupMouseMoveHandler = () => {
-      this.forceHidePopup();
-    };
-    this.popupElement.addEventListener(
-      'mouseenter',
-      this.popupMouseEnterHandler
-    );
-    this.popupElement.addEventListener('mousemove', this.popupMouseMoveHandler);
     this.popupOverlay = new Overlay({
       element: this.popupElement,
       positioning: 'bottom-center',
@@ -209,12 +196,43 @@ export class PopupManager {
         this.popupElement.innerHTML = popupHtml;
         this.popupOverlay.setPosition(coordinate);
         this.popupElement.style.display = 'block';
+        this.raisePopupLayer();
         return;
       }
     }
 
     this.popupOverlay.setPosition(undefined);
     this.popupElement.style.display = 'none';
+    this.restorePopupLayer();
+  }
+
+  // 备注：hover popup 展示时临时提升层级，避免被批量固定 popup 容器（z-index: 1000）遮挡。
+  // OL Overlay 会把元素包在 .ol-overlay-container 包装层里，该层又挂在 z-index: 0 的
+  // .ol-overlaycontainer 下，单独抬升 popup 元素或其包装层都无法越过顶层容器的层叠上下文，
+  // 因此必须同时抬升 map.getOverlayContainer()（.ol-overlaycontainer）才能盖过批量容器。
+  private raisePopupLayer() {
+    if (!this.popupElement) return;
+    this.popupElement.style.zIndex = '1100';
+    if (this.popupElement.parentElement) {
+      this.popupElement.parentElement.style.zIndex = '1100';
+    }
+    const container = this.map?.getOverlayContainer();
+    if (container) {
+      container.style.zIndex = '1001';
+    }
+  }
+
+  // 备注：隐藏 hover popup 时恢复层级，避免长期抬高影响其它 Overlay。
+  private restorePopupLayer() {
+    if (!this.popupElement) return;
+    this.popupElement.style.removeProperty('zIndex');
+    if (this.popupElement.parentElement) {
+      this.popupElement.parentElement.style.removeProperty('zIndex');
+    }
+    const container = this.map?.getOverlayContainer();
+    if (container) {
+      container.style.zIndex = '0';
+    }
   }
 
   private getPopupHtml(props: Record<string, any>) {
@@ -340,6 +358,8 @@ export class PopupManager {
         popupEl.style.visibility = 'visible';
         popupEl.style.left = `${popupX}px`;
         popupEl.style.top = `${popupY}px`;
+        // 标记该锚点已有固定展示的 popup，hover 时跳过 hover popup
+        feature.set('_fixedPopupShown', true);
         this.batchPopupItems.push({
           feature,
           element: popupEl
@@ -353,6 +373,7 @@ export class PopupManager {
         });
       } else {
         // 有碰撞，移除该 popup
+        feature.set('_fixedPopupShown', false);
         batchContainer.removeChild(popupEl);
       }
     });
@@ -373,26 +394,32 @@ export class PopupManager {
     const viewportPadding = 48;
 
     this.batchPopupItems.forEach(({ feature, element }) => {
+      // 统一维护固定展示标记：显示时置 true、隐藏时置 false
+      const setVisible = (visible: boolean) => {
+        element.style.display = visible ? 'block' : 'none';
+        feature.set('_fixedPopupShown', visible);
+      };
+
       if (feature.get('_legendVisible') === false) {
-        element.style.display = 'none';
+        setVisible(false);
         return;
       }
 
       if (styleChecker && !styleChecker(feature)) {
-        element.style.display = 'none';
+        setVisible(false);
         return;
       }
 
       const geom = feature.getGeometry();
       if (!geom || geom.getType() !== 'Point') {
-        element.style.display = 'none';
+        setVisible(false);
         return;
       }
 
       const coords = (geom as Point).getCoordinates();
       const pixel = this.map?.getPixelFromCoordinate(coords);
       if (!pixel) {
-        element.style.display = 'none';
+        setVisible(false);
         return;
       }
 
@@ -404,18 +431,22 @@ export class PopupManager {
         popupX > viewportWidth + viewportPadding ||
         popupY > viewportHeight + viewportPadding
       ) {
-        element.style.display = 'none';
+        setVisible(false);
         return;
       }
 
       element.style.left = `${popupX}px`;
       element.style.top = `${popupY}px`;
-      element.style.display = 'block';
+      setVisible(true);
     });
   }
 
   // 备注：清除批量显示的 popups。
   clearBatchPopups() {
+    // 清除前复位所有要素的固定展示标记
+    this.batchPopupItems.forEach(({ feature }) => {
+      feature.set('_fixedPopupShown', false);
+    });
     this.batchPopupItems = [];
     if (this.batchPopupContainer) {
       this.batchPopupContainer.remove();
@@ -456,15 +487,6 @@ export class PopupManager {
     });
   }
 
-  // 备注：在弹窗层意外接管鼠标时，通过统一 hover 回调链路立即清空当前悬停状态。
-  private forceHidePopup() {
-    this.emitHoverChange({
-      hoveredId: null,
-      detectedFeature: undefined,
-      coordinate: undefined
-    });
-  }
-
   // 备注：统一派发 hover 变化，确保地图侧的 cursor、Popup 和图层刷新走同一条处理链路。
   private emitHoverChange(payload: PointerMoveChangePayload) {
     this.lastHoveredId = payload.hoveredId;
@@ -505,23 +527,9 @@ export class PopupManager {
   destroy() {
     this.clearBatchPopups();
     this.reset();
-    if (this.popupElement && this.popupMouseEnterHandler) {
-      this.popupElement.removeEventListener(
-        'mouseenter',
-        this.popupMouseEnterHandler
-      );
-    }
-    if (this.popupElement && this.popupMouseMoveHandler) {
-      this.popupElement.removeEventListener(
-        'mousemove',
-        this.popupMouseMoveHandler
-      );
-    }
     if (this.map && this.popupOverlay) {
       this.map.removeOverlay(this.popupOverlay);
     }
-    this.popupMouseEnterHandler = null;
-    this.popupMouseMoveHandler = null;
     this.hoverChangeHandler = undefined;
     this.popupOverlay = null;
     this.popupElement = null;
diff --git a/frontend/src/components/gis/roam/ThreeDRoamManager.ts b/frontend/src/components/gis/roam/ThreeDRoamManager.ts
index 99f44d32..29100086 100644
--- a/frontend/src/components/gis/roam/ThreeDRoamManager.ts
+++ b/frontend/src/components/gis/roam/ThreeDRoamManager.ts
@@ -23,6 +23,9 @@ export class ThreeDRoamManager {
   // 相机平滑跟随插值状态
   private _smoothCenter: Cesium.Cartesian3 | null = null;
   private _smoothOrientation: Cesium.Quaternion | null = null;
+  // 点击跳转后的过渡截止时间（performance.now() 时间戳）：
+  // 过渡期内 setCameraLookAt 使用更大的插值系数，让相机平滑“飞”向目标而非瞬移
+  private _transitionEnd = 0;
 
   constructor(viewer: any) {
     this.viewer = viewer;
@@ -116,6 +119,8 @@ export class ThreeDRoamManager {
     this.viewer.clock.shouldAnimate = false;
     this.entitiesVisible(true);
     this.removeTickCallback();
+    // 不清除平滑插值状态：暂停后相机仍会平滑收敛到模型位置再停下（保留缓冲，
+    // 避免“立刻暂停”的突兀感）；此时时钟已冻结，目标固定，不会产生抖动
   }
 
   /** 重置飞行（回到起点/第0帧） */
@@ -177,21 +182,17 @@ export class ThreeDRoamManager {
     }
   }
 
-  /** 视角定位到指定时间点的位置 */
+  /**
+   * 视角定位到指定时间点的位置
+   * 说明：不再使用 camera.flyTo —— 漫游中第一人称跟随（setCameraLookAt）每帧执行
+   * lookAtTransform，camera.flyTo 会与其争抢相机控制，导致相机高度/zoom 振荡，
+   * 锚点文字随之“先缩小后重新放大”。改为开启一段过渡窗口，
+   * setCameraLookAt 在窗口内用更大的插值系数平滑“飞”向目标时间点的跟随视角。
+   * 位置/朝向仍由 setCameraLookAt 每帧从模型实时取值，因此无需在此读取坐标。
+   */
   flyToPositionAtTime(seconds: number): void {
     if (!this.roamingEntity || !this.startTime) return;
-    const time = Cesium.JulianDate.addSeconds(
-      this.startTime,
-      seconds,
-      new Cesium.JulianDate()
-    );
-    const position = this.roamingEntity.position?.getValue(time);
-    if (position) {
-      this.viewer.camera.flyTo({
-        destination: position,
-        duration: 0.5
-      });
-    }
+    this._transitionEnd = performance.now() + 500;
   }
 
   /** 是否已加载漫游实体 */
@@ -267,8 +268,14 @@ export class ThreeDRoamManager {
       const targetOrientation = entity.orientation?.getValue(time);
       if (!targetCenter || !targetOrientation) return;
 
-      // 插值系数：越小越平滑（跟随延迟越大）
-      const lerpFactor = 0.06;
+      // 插值系数：常规跟随 0.1（越小越平滑，跟随延迟越大）；
+      // 点击跳转后的过渡期内 0.15 → 0.1 线性衰减，让相机快速且平滑地“飞”向目标位置
+      const now = performance.now();
+      let lerpFactor = 0.1;
+      if (now < this._transitionEnd) {
+        const t = 1 - (this._transitionEnd - now) / 500; // 0 → 1
+        lerpFactor = 0.15 + (0.1 - 0.15) * t;
+      }
 
       // 对位置做 lerp
       let center: Cesium.Cartesian3;
@@ -360,4 +367,4 @@ export class ThreeDRoamManager {
     }
     this.removeTickCallback();
   }
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/gis/roam/ThreeDRoamPanel.vue b/frontend/src/components/gis/roam/ThreeDRoamPanel.vue
index 43b56b57..a1328898 100644
--- a/frontend/src/components/gis/roam/ThreeDRoamPanel.vue
+++ b/frontend/src/components/gis/roam/ThreeDRoamPanel.vue
@@ -105,6 +105,7 @@
           :max="totalDuration"
           :marks="milestoneMarks"
           :tipFormatter="tipFormatter"
+          @change="handleProgressChange"
           @afterChange="handleProgressChange"
         />
         <div class="value-display">
@@ -188,6 +189,8 @@ async function initRoamManager(): Promise<void> {
     console.warn('Cesium viewer 未就绪');
     return;
   }
+  // 进入漫游：锚点文字/图标开启深度测试，避免文字遮挡漫游模型(glb)
+  MapClass.getInstance().setRoamDepthTest(true);
   // 进入漫游：保存当前相机状态用于退出时恢复
   savedCamera = {
     position: viewer.camera.position.clone(),
@@ -369,6 +372,12 @@ function handleFlightModelChange(value: boolean) {
   }
 }
 
+/**
+ * 进度条拖动/点击时同步 Cesium 时钟并开启相机过渡
+ * - jumpToTime：拖动/点击瞬间即同步时钟，避免播放中 onTick 进度回调按旧时钟位置
+ *   把滑块值覆盖回去（问题1：10→20 先到 20 再回退到 10）；
+ * - flyToPositionAtTime：开启过渡窗口，让第一人称跟随平滑“飞”向目标位置（保留缓冲）。
+ */
 function handleProgressChange(value: number) {
   if (roamManager) {
     roamManager.jumpToTime(value);
@@ -382,6 +391,8 @@ onMounted(() => {
 });
 
 onUnmounted(() => {
+  // 退出漫游：恢复锚点深度测试策略（按俯仰角动态切换）
+  MapClass.getInstance().setRoamDepthTest(false);
   // dim 切换时跳过 Cesium 清理（由地图切换自行处理），避免影响 2D 地图初始化
   const skipCesiumCleanup = !!uiStore.skipRoamCameraRestore;
   roamManager?.destroy(skipCesiumCleanup);
diff --git a/frontend/src/components/mapController/index.vue b/frontend/src/components/mapController/index.vue
index 07b6b9eb..43822a04 100644
--- a/frontend/src/components/mapController/index.vue
+++ b/frontend/src/components/mapController/index.vue
@@ -1,5 +1,9 @@
 <template>
-  <div id="map-controller" class="map-controller" :style="{ right: drawerOpen ? '480px' : '12px' }">
+  <div
+    id="map-controller"
+    class="map-controller"
+    :style="{ right: drawerOpen ? '480px' : '12px' }"
+  >
     <div
       class="map-controller-group"
       v-for="(item, index) in controllers"
@@ -424,10 +428,10 @@ const handleControllerClick = (item: any) => {
       }
       break;
     case 'threedRoam': // 流域三维漫游
-      if (is3DTransition.value) break;
-      // 互斥：选中threedRoam时取消其他选中
       activeKey.value = activeKey.value === 'threedRoam' ? null : 'threedRoam';
       uiStore.isRoaming = !uiStore.isRoaming;
+      // 进入/退出漫游立即同步深度测试与强制批量 popup，不依赖漫游面板的数据异步加载链路
+      map.value.setRoamDepthTest?.(uiStore.isRoaming);
       break;
     // 可以在这里添加其他控制器的处理逻辑
     case 'screenShot':