diff --git a/frontend/.env.development b/frontend/.env.development
index b560df26..d29767aa 100644
--- a/frontend/.env.development
+++ b/frontend/.env.development
@@ -7,7 +7,7 @@ VITE_APP_TITLE = '水电水利建设项目全过程环境管理信息平台'
 VITE_APP_PORT = 3000
 VITE_APP_BASE_API = '/dev-api'
 # 本地环境
-VITE_APP_BASE_URL = 'http://localhost:8093'
+# VITE_APP_BASE_URL = 'http://localhost:8093'
 # 测试环境
 # VITE_APP_BASE_URL = 'http://172.16.21.142:8093'
 # 汤伟
diff --git a/frontend/public/glb/map-air.glb b/frontend/public/glb/map-air.glb
new file mode 100644
index 00000000..f4b70f77
Binary files /dev/null and b/frontend/public/glb/map-air.glb differ
diff --git a/frontend/src/api/system/disposeManage/index.ts b/frontend/src/api/system/disposeManage/index.ts
index 3b3d9a01..a226e358 100644
--- a/frontend/src/api/system/disposeManage/index.ts
+++ b/frontend/src/api/system/disposeManage/index.ts
@@ -8,6 +8,14 @@ export function threedroambGetKendoListCust(data: any) {
     data: data
   });
 }
+export function getThreedRoamData(data: any) {
+  return request({
+    url: '/threedroamb/getThreedRoamData',
+    method: 'post',
+    data: data
+  });
+}
+
 export function threedroambsave(data: any) {
   return request({
     url: '/threedroamb/save',
@@ -47,4 +55,4 @@ export function threedroambexport(data: any) {
     data: data,
     responseType: 'blob'
   });
-}
\ No newline at end of file
+}
diff --git a/frontend/src/components/gis/GisView.vue b/frontend/src/components/gis/GisView.vue
index 57f2525f..c52c139b 100644
--- a/frontend/src/components/gis/GisView.vue
+++ b/frontend/src/components/gis/GisView.vue
@@ -18,6 +18,9 @@
     <BaseLayerSwitcher :map="mapClass" />
     <!-- 梯级弹框 -->
     <TjLayerModal v-model:open="tjModalVisible" />
+
+    <!-- 三维漫游面板 -->
+    <ThreeDRoamPanel v-if="uiStore.isRoaming" />
   </div>
 </template>
 <script setup lang="ts">
@@ -27,6 +30,7 @@ import MapFilter from '@/components/mapFilter/index.vue';
 import MapController from '@/components/mapController/index.vue';
 import BaseLayerSwitcher from '@/components/BaseLayerSwitcher/index.vue';
 import TjLayerModal from './TjLayerModal.vue';
+import ThreeDRoamPanel from './roam/ThreeDRoamPanel.vue';
 import { useRoute } from 'vue-router';
 import { useMapOrchestrator } from '@/modules/map/application/map-orchestrator';
 import { MapClass } from './map.class';
diff --git a/frontend/src/components/gis/map.cesium.ts b/frontend/src/components/gis/map.cesium.ts
index 73ae8be7..674bb8fc 100644
--- a/frontend/src/components/gis/map.cesium.ts
+++ b/frontend/src/components/gis/map.cesium.ts
@@ -1,12 +1,9 @@
-import * as Cesium from 'cesium';
+import * as Cesium from 'cesium';
+import { ArcGisMapServerImageryProvider } from 'cesium';
 import type { MDOptions } from './map.class';
 import type { MapInterface, layer } from './map.d';
 import { getIconPath } from '@/utils/index';
-import {
-  generatePopupHtml,
-  shouldPreferEng2Popup,
-  getNormalizedPopupSttpMap
-} from '@/utils/popupHtmlGenerator';
+import { generatePopupHtml } from '@/utils/popupHtmlGenerator';
 import { useModelStore } from '@/store/modules/model';
 import { getNearbyPointDensityDisplayRules } from '@/modules/map/domain/nearby-point-rules';
 import {
@@ -20,20 +17,42 @@ import {
 export class MapCesium implements MapInterface {
   private viewer: Cesium.Viewer | null = null;
   private _ready = false;
+  /** 地形瓦片是否已完全加载（CLAMP_TO_GROUND 可正确计算位置） */
+  private _terrainReady = false;
+  /** 因地形未就绪而暂缓加载的锚点数据（按 layerKey 去重，保留最新） */
+  private _pendingInitLayers: Array<{
+    data: any;
+    key: string;
+    options?: MDOptions;
+  }> = [];
+  /** 锚点数据暂缓期间缓存的显隐状态 */
+  private _pendingLayerVisibility = new Map<string, boolean>();
+  /** 锚点数据暂缓期间缓存的图例显隐调用 */
+  private _pendingLegendCalls: Array<{
+    layerKey: string;
+    anchoPointState: string;
+    checked: boolean;
+  }> = [];
   private _pendingOSGBItems: OSGBItem[] = [];
   private clickEventHandler: Cesium.ScreenSpaceEventHandler | null = null;
   private popupElement: HTMLElement | null = null;
   private hoveredEntityId: string | null = null;
   private hoverRafId: number | null = null; // requestAnimationFrame 节流
+  /** hover popup 的实际渲染位置缓存（用于 camera.moveEnd 重定位，避免使用 entity.position 的原始椭球面坐标） */
+  private _hoverPopupPosition: Cesium.Cartesian3 | null = null;
   private removePostRenderListener: (() => void) | null = null;
   private removeCameraChangedListener: (() => void) | null = null;
   private isBatchPopupMode = false;
+  /** 上次 rebuild 时的 zoom 级别，拖拽时 zoom 未变则跳过 rebuild，避免无意义闪烁 */
+  private _lastBatchRebuildZoom = -1;
   private batchPopupContainer: HTMLDivElement | null = null;
   private batchPopupItems: Array<{
     entity: Cesium.Entity;
     element: HTMLDivElement;
     popupWidth: number;
     popupHeight: number;
+    /** 首次构建时缓存的地形高度修正世界坐标，每帧投影时用，避免依赖 terrain 加载状态 */
+    worldPosition: Cesium.Cartesian3;
   }> = [];
   private batchPostRenderRemover: (() => void) | null = null;
   private containerId = '';
@@ -50,6 +69,21 @@ export class MapCesium implements MapInterface {
   private currentClipGeoJson: any = null;
   private clipRequestController: AbortController | null = null;
   private maskPolygonEntities: Cesium.Entity[] = [];
+  /** 当前相机俯仰模式，用于动态切换深度测试 */
+  private _currentPitchMode: 'down' | 'flat' = 'down';
+  /** 碰撞检测防重入标志，避免级联触发导致重复执行 */
+  private _collisionBusy = false;
+  /** computeAnchorWorldPosition 结果缓存，避免 terrain 加载后重复 globe.getHeight 调用 */
+  private _worldPosCache = new Map<string, Cesium.Cartesian3>();
+  /** 按经纬度（6 位精度）缓存世界坐标，同位置锚点共享一致的地形高度 */
+  private _geoPosCache = new Map<string, Cesium.Cartesian3>();
+  /** 离屏 canvas 文本测量 */
+  private _measureCanvas: HTMLCanvasElement | null = null;
+  /** 文本像素尺寸缓存 key=`text@roundedFontSize`，zoom 变化 fontSize 改变时自动失效 */
+  private _measureTextCache = new Map<
+    string,
+    { width: number; height: number }
+  >();
   private originalBgColor: Cesium.Color | null = null;
   private skyBoxShown = true;
   private skyAtmosphereShown = true;
@@ -65,10 +99,10 @@ export class MapCesium implements MapInterface {
   ]);
 
   private readonly CHINA_CENTER = { lng: 104.5, lat: 36.5 };
-  private readonly CHINA_BOOT_HEIGHT = 20000000;
-  private readonly CHINA_DEFAULT_HEIGHT = 9000000;
+  /** 中国视角默认高度（≈8,000公里，底图边界线清晰可见） */
+  private readonly CHINA_DEFAULT_HEIGHT = 8000000;
   private readonly CHINA_VIEW_ORIENTATION = {
-    heading: Cesium.Math.toRadians(-6),
+    heading: Cesium.Math.toRadians(-7),
     pitch: Cesium.Math.toRadians(-90),
     roll: 0
   };
@@ -76,31 +110,31 @@ export class MapCesium implements MapInterface {
   private readonly CESIUM_ZOOM_FORMULA_B = 0.00007096758;
   private readonly CESIUM_ZOOM_FORMULA_C = 91610.74;
   private readonly CESIUM_ZOOM_FORMULA_D = -40467.74;
-  private readonly HOVER_POPUP_MAX_HEIGHT = 9_000_000; // ~zoom 4.5，中国视角以上不触发 hover
-  private readonly BATCH_POPUP_MODE_ZOOM = 14.9; // zoom >= 14.9 进入批量固定模式（float 容差避免 15 刚好踩边界）
+  private readonly HOVER_POPUP_MAX_HEIGHT = 12_000_000; // 对应飞入动画中途即开始支持 hover，避免低空地形遮挡导致部分锚点 popup 不显示
+  private readonly BATCH_POPUP_MODE_ZOOM = 13; // zoom >= 约 15（UI 层级）进入批量固定模式
 
   // ==================== Step 6: 碰撞检测 ====================
   private collisionRefreshFrameId: number | null = null;
   private labelVisibilityDebounceTimerId: number | null = null;
   private readonly COLLISION_GRID_CELL_SIZE = 96; // 与 2D 一致
   private readonly DENSITY_ISOLATION_THRESHOLD = 56; // 孤立点 pixel 阈值
-  private readonly COLLISION_LABEL_PADDING = 4; // 标签碰撞 padding
+  private readonly COLLISION_LABEL_PADDING = 4; // 标签碰撞 padding（与 2D checkLabelCollision 对齐）
 
   // 图标缩放可调参数（只影响 3D Cesium，不参与 2D 计算）
   // scale = base + (zoom - 4.5) * rate，钳位到 [min, max]
   // zoom≈4.5 是中国全国视角，zoom≈15 是最大放大级别
   private readonly ICON_MIN_SCALE = 0.4; // 最小缩放
-  private readonly ICON_MAX_SCALE = 1.2; // 最大缩放（限制放大后图标不超过 1.2x 基础值）
-  private readonly ICON_BASE_SCALE = 0.7; // zoom≈4.5 基准（中国视角图标 ≈ 原始尺寸）
-  private readonly ICON_SCALE_RATE = 0.035; // 每级 zoom 增长（放大 10 级才增加 ~0.35）
+  private readonly ICON_MAX_SCALE = 0.8; // 最大缩放（限制放大后图标不超过 1.2x 基础值）
+  private readonly ICON_BASE_SCALE = 0.66; // zoom≈4.5 基准（中国视角图标 ≈ 原始尺寸）
+  private readonly ICON_SCALE_RATE = 0.01; // 每级 zoom 增长（放大 10 级才增加 ~0.35）
 
   // 标签文字可调参数
   // fontSize = clamp(base * scale, min, max)，scale = 0.7 + (zoom-4.5)*0.08
   private readonly LABEL_FONT_MIN = 10; // 最小字号(px)，改大 → 小缩放时文字更清晰
-  private readonly LABEL_FONT_MAX = 20; // 最大字号(px)
-  private readonly LABEL_FONT_BASE = 16; // 基准乘数，改大 → 所有缩放级别文字都变大
-  private readonly LABEL_OFFSET_SINGLE = 14; // 单行偏移系数，改大 → 文字离图标更远
-  private readonly LABEL_OFFSET_MULTI = 30; // 多行偏移系数
+  private readonly LABEL_FONT_MAX = 16; // 最大字号(px)（与 2D 对齐）
+  private readonly LABEL_FONT_BASE = 12; // 基准乘数（与 2D 对齐，2D: 12）
+  private readonly LABEL_OFFSET_SINGLE = 16; // 单行偏移系数（与 2D 对齐，2D: -22 * scale）
+  private readonly LABEL_OFFSET_MULTI = 16; // 多行偏移系数
 
   // ==================== Step 1: 初始化 + 飞中国 ====================
 
@@ -108,7 +142,6 @@ export class MapCesium implements MapInterface {
     try {
       this.containerId = container.id;
       this.containerElement = container;
-      this.showLoadingOverlay(container);
       const token = 'bearer fa8aa37c-1e52-4631-a699-625b4147ace8';
 
       this.viewer = new Cesium.Viewer(container, {
@@ -131,12 +164,18 @@ export class MapCesium implements MapInterface {
       this.viewer.cesiumWidget.creditContainer.style.display = 'none';
       const layers = this.viewer.imageryLayers;
       layers.removeAll();
-      const provider = new Cesium.UrlTemplateImageryProvider({
-        url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
-        maximumLevel: 19,
-        credit:
-          'Esri, DigitalGlobe, GeoEye, i-cubed, USDA FSA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'
-      });
+      // const provider = new Cesium.UrlTemplateImageryProvider({
+      //   url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+      //   maximumLevel: 18,
+      //   credit:
+      //     'Esri, DigitalGlobe, GeoEye, i-cubed, USDA FSA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'
+      // });
+      const provider = await ArcGisMapServerImageryProvider.fromUrl(
+        'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
+        {
+          maximumLevel: 19 // 可选，Provider 内部会自动限制到服务实际支持的级别
+        }
+      );
       const customTerrain = await Cesium.CesiumTerrainProvider.fromUrl(
         import.meta.env.VITE_APP_MAP_URL + '/Terrain?token=' + token, // 指向包含 layer.json 的目录
         {
@@ -158,16 +197,17 @@ export class MapCesium implements MapInterface {
 
       await this.flyToChina();
 
+      // 等待地图底图瓦片首轮加载完成（不再同时等待地形，loading 延迟到地形就绪）
+      await this.waitForTilesLoaded();
+
       this.setupClickHandler();
       this.setupCameraPopupReset();
 
       this._ready = true;
-      console.log('[Cesium] init complete, viewer ready');
-
-      // 初始化完成后等 5 秒再加载倾斜摄影，确保渲染管线稳定
-      setTimeout(() => {
-        this.flushPendingOSGB();
-      }, 5000);
+      // 瓦片加载完成后立即加载待处理的倾斜摄影
+      this.flushPendingOSGB();
+      // 后台持续监听地形瓦片加载完成（完成后刷新暂缓的锚点数据并关闭 loading）
+      this.startTerrainReadyMonitor();
 
       return this.viewer;
     } catch (error) {
@@ -177,54 +217,216 @@ export class MapCesium implements MapInterface {
     }
   }
 
+  /**
+   * 初始化相机到中国上空的全球全景视图（~25,000,000m），展示以中国为中心的完整地球球体。
+   * 不执行飞入动画，由外部在边界线等图层加载完成后调用 flyToDefaultView()。
+   */
   private flyToChina(): Promise<void> {
     return new Promise(resolve => {
       if (!this.viewer) {
-        this.hideLoadingOverlay();
         resolve();
         return;
       }
-
-      // Step 1: 瞬跳至高空俯视中国
       this.viewer.camera.cancelFlight();
       this.viewer.camera.setView({
         destination: Cesium.Cartesian3.fromDegrees(
           this.CHINA_CENTER.lng,
           this.CHINA_CENTER.lat,
-          this.CHINA_BOOT_HEIGHT
+          25_000_000
         ),
-        orientation: this.CHINA_VIEW_ORIENTATION
+        orientation: {
+          heading: Cesium.Math.toRadians(0),
+          pitch: Cesium.Math.toRadians(-90),
+          roll: 0
+        }
       });
       this.viewer.scene.requestRender();
-
-      // Step 2: 等一帧让 setView 生效后，飞入到默认视角
       requestAnimationFrame(() => {
-        const finish = () => {
-          this.clearFlightFallbackTimer();
-          this.hideLoadingOverlay();
-          resolve();
-        };
-
-        this.clearFlightFallbackTimer();
-        this.flightFallbackTimer = window.setTimeout(() => {
-          finish();
-        }, 2600);
-
-        this.viewer!.camera.flyTo({
-          destination: Cesium.Cartesian3.fromDegrees(
-            this.CHINA_CENTER.lng,
-            this.CHINA_CENTER.lat,
-            this.CHINA_DEFAULT_HEIGHT
-          ),
-          orientation: this.CHINA_VIEW_ORIENTATION,
-          duration: 1.8,
-          complete: finish,
-          cancel: finish
-        });
+        resolve();
       });
     });
   }
 
+  /**
+   * 从默认地球全景视图飞入到中国视角（~8,000,000m）。
+   * 先停留 2s 让边界线等图层加载渲染，再平滑飞入。
+   */
+  async flyToDefaultView(): Promise<void> {
+    if (!this.viewer) return;
+
+    // Step 1: 在默认全景视图停留 2s（此时边界线图层已加载，等待瓦片渲染）
+    await new Promise<void>(resolve => {
+      setTimeout(resolve, 1000);
+    });
+
+    // Step 2: 平滑飞入中国具体视角
+    return new Promise(resolve => {
+      const FLY_DURATION = 3.0; // 飞入动画时长
+      const FALLBACK_BUFFER = 1500; // 逃逸保护 buffer
+
+      const finish = () => {
+        this.clearFlightFallbackTimer();
+        resolve();
+      };
+
+      this.clearFlightFallbackTimer();
+      this.flightFallbackTimer = window.setTimeout(() => {
+        finish();
+      }, FLY_DURATION * 1000 + FALLBACK_BUFFER);
+
+      this.viewer!.camera.flyTo({
+        destination: Cesium.Cartesian3.fromDegrees(
+          this.CHINA_CENTER.lng,
+          this.CHINA_CENTER.lat,
+          this.CHINA_DEFAULT_HEIGHT
+        ),
+        orientation: this.CHINA_VIEW_ORIENTATION,
+        duration: FLY_DURATION,
+        complete: finish,
+        cancel: finish
+      });
+    });
+  }
+
+  /**
+   * 等待地图瓦片加载到底图可见即可（不阻塞等待地形瓦片全部加载完）。
+   * - 快速路径：tileLoadProgressEvent 降至 0（瓦片全加载完成）→ 立即返回
+   * - 超时路径：最多等 3 秒 → 底图已可见，地形继续后台加载
+   */
+  private waitForTilesLoaded(): Promise<void> {
+    return new Promise(resolve => {
+      if (!this.viewer) {
+        resolve();
+        return;
+      }
+
+      let resolved = false;
+      const remove =
+        this.viewer.scene.globe.tileLoadProgressEvent.addEventListener(
+          (remaining: number) => {
+            if (!resolved && remaining === 0) {
+              resolved = true;
+              remove();
+              resolve();
+            }
+          }
+        );
+
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          remove();
+          resolve();
+        }
+      }, 1000);
+    });
+  }
+
+  /**
+   * 后台监听地形瓦片最终加载完成。
+   * tileLoadProgressEvent 降至 0 时认为地形已就绪，
+   * 刷新因地形未就绪而暂缓的锚点数据。
+   */
+  private startTerrainReadyMonitor() {
+    if (!this.viewer || this._terrainReady) return;
+
+    let resolved = false;
+    const remove =
+      this.viewer.scene.globe.tileLoadProgressEvent.addEventListener(
+        (remaining: number) => {
+          if (!resolved && remaining === 0) {
+            resolved = true;
+            remove();
+            this._terrainReady = true;
+            this.flushPendingInitLayers();
+            this.hideLoadingOverlay();
+          }
+        }
+      );
+
+    // 超时保护：最多等 20 秒后强行使之为就绪
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        remove();
+        this._terrainReady = true;
+        this.flushPendingInitLayers();
+        this.hideLoadingOverlay();
+      }
+    }, 20000);
+  }
+
+  /** 刷新所有因地形未就绪而暂缓的锚点数据 */
+  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
+        );
+      }
+      // 应用暂缓期间缓存的显隐状态
+      if (this._pendingLayerVisibility.has(layer.key)) {
+        const visible = this._pendingLayerVisibility.get(layer.key)!;
+        this._pendingLayerVisibility.delete(layer.key);
+        this.mdLayerTreeShowOrHidden(layer.key, visible);
+      }
+    }
+    // 地形就绪后，将所有锚点位置刷新为地形修正后的绝对值，
+    // 避免初始化时 terrain 未加载导致的锚点悬浮问题
+    this.refreshEntityPositionsWithTerrain();
+  }
+
+  /**
+   * 用当前地形高度刷新所有锚点位置为绝对值（替换 RELATIVE_TO_GROUND），
+   * 确保放大地图后高 LOD 地形瓦片加载时锚点能正确贴地。
+   */
+  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() {
     if (this.flightFallbackTimer !== null) {
       window.clearTimeout(this.flightFallbackTimer);
@@ -328,37 +530,77 @@ export class MapCesium implements MapInterface {
             return;
           }
 
-          const picked = scene.pick(evt.endPosition);
-          const entity =
-            Cesium.defined(picked) && picked.id instanceof Cesium.Entity
-              ? (picked.id as Cesium.Entity)
-              : null;
+          // 使用 drillPick 获取该像素所有对象：OSGB 模型可能挡在锚点和相机之间，
+          // scene.pick 只返回最前的 Cesium3DTileFeature 而丢失锚点 entity
+          const pickResults = scene.drillPick(evt.endPosition);
+          let entity: Cesium.Entity | null = null;
+          /** 该像素上是否命中了 BillBoard（图标），而非 Label（文字标签） */
+          let isBillboardHit = false;
+          for (const p of pickResults) {
+            if (Cesium.defined(p)) {
+              // 检查原始 pick 类型：Billboard = 图标，Label = 文字标签
+              // 对于模型上的锚点，用 terrain 高度反算屏幕坐标会偏移，无法通过 isPixelInsideIconArea 检测
+              // 直接用 Cesium 内部的 pick 原型判断更可靠
+              if (p.primitive instanceof Cesium.Billboard) {
+                isBillboardHit = true;
+              }
+              if (p.id instanceof Cesium.Entity) {
+                entity = p.id as Cesium.Entity;
+              }
+              // 找到 entity 且当前 pick 就是图标 → 已确定是图标命中，提前结束
+              if (entity && isBillboardHit) break;
+            }
+          }
 
           // 检测是否命中可交互的锚点
           if (entity && this.isEntityInteractive(entity)) {
-            canvas.style.cursor = 'pointer';
+            // 模型上的锚点：使用 drillPick 原始类型（Billboard vs Label）判断是否为图标命中
+            // 非模型锚点：继续使用位置校验的 isPixelInsideIconArea（与 2D 对齐）
+            const isOnModel = entity ? this.isEntityOnModel(entity) : false;
+            const isIconHit = isOnModel
+              ? isBillboardHit
+              : this.isPixelInsideIconArea(entity, evt.endPosition);
 
-            // 批量模式下单点 hover 不触发 popup
-            if (this.isBatchPopupMode) return;
-
-            // 同一个实体不重复刷新
-            if (this.hoveredEntityId === entity.id) {
-              const position = entity.position?.getValue(
-                this.viewer!.clock.currentTime
-              );
-              if (position) {
-                this.updatePopupPosition(position);
+            if (!isIconHit) {
+              canvas.style.cursor = 'default';
+              if (!this.isBatchPopupMode) {
+                this.hidePopup();
               }
               return;
             }
 
-            this.showPopupForEntity(entity);
+            canvas.style.cursor = 'pointer';
+
+            // 批量模式下：模型之上的锚点允许 hover，普通锚点由批量 popup 处理
+            if (this.isBatchPopupMode && !isOnModel) return;
+
+            // 获取锚点的实际渲染世界坐标（固定位置，不跟随鼠标）
+            // computeAnchorWorldPosition 取 terrain 高度修正后的位置，与 billboard CLAMP_TO_GROUND 渲染位置一致
+            const anchorWorldPos = this.computeAnchorWorldPosition(entity);
+
+            // 同一个实体不重复刷新
+            if (this.hoveredEntityId === entity.id) {
+              if (anchorWorldPos) {
+                this._hoverPopupPosition = anchorWorldPos;
+                this.updatePopupPosition(anchorWorldPos);
+              }
+              return;
+            }
+
+            // 使用锚点固定位置显示 popup，而非鼠标光标位置
+            this.showPopupForEntity(entity, anchorWorldPos ?? undefined);
+            // 延迟一帧重试：首次 hover 时 terrain 可能未加载，椭球面高度导致位置偏移
+            requestAnimationFrame(() => {
+              if (this.hoveredEntityId === entity.id) {
+                this.repositionHoverPopup();
+              }
+            });
             return;
           }
 
           canvas.style.cursor = 'default';
-          // 批量模式下不隐藏批量 popup
-          if (!this.isBatchPopupMode) {
+          // 批量模式下仅隐藏 hover popup（模型之上的锚点），保留批量 popup
+          if (!this.isBatchPopupMode || this.hoveredEntityId) {
             this.hidePopup();
           }
         });
@@ -412,6 +654,12 @@ export class MapCesium implements MapInterface {
     this.removeCameraChangedListener =
       this.viewer.camera.changed.addEventListener(() => {
         this.requestRefreshPointLabelVisibility(false, 150);
+        // 根据俯仰角动态切换深度测试，避免平行视角时锚点穿透地形
+        this.updateDepthTestForPitch();
+        // 拖拽时隐藏 hover popup，避免 popup 留在旧屏幕坐标跟随地图漂移
+        if (this.hoveredEntityId) {
+          this.hidePopup();
+        }
       });
 
     this.removePostRenderListener = this.viewer.camera.moveEnd.addEventListener(
@@ -420,14 +668,21 @@ export class MapCesium implements MapInterface {
           this.getCurrentCameraHeight()
         );
 
+        // 相机停止后刷新生效的地形 LOD，将锚点位置更新为地形修正绝对值
+        this.refreshEntityPositionsWithTerrain();
+
         if (zoom >= this.BATCH_POPUP_MODE_ZOOM) {
           if (!this.isBatchPopupMode) {
             this.enableBatchPopupMode();
           } else {
-            // 已处于批量模式：重建 popup（与 2D moveend 行为对齐）
-            // 拖拽/平移后视口内可能出现新的可见锚点，仅 postRender 重定位无法创建新 popup
-            // 同时修复 zoom 进出循环后 popup 消失的问题
-            this.rebuildBatchPopupsIfNeeded();
+            // 已处于批量模式：仅 zoom 变化时重建（拖拽平移不重建，postRender 已处理位置更新）
+            if (Math.abs(zoom - this._lastBatchRebuildZoom) > 0.3) {
+              this.rebuildBatchPopupsIfNeeded();
+            }
+          }
+          // 批量模式下，模型之上的锚点 hover popup 也需要在拖拽后重定位
+          if (this.hoveredEntityId) {
+            this.repositionHoverPopup();
           }
         } else {
           if (this.isBatchPopupMode) {
@@ -440,25 +695,57 @@ export class MapCesium implements MapInterface {
         }
 
         // Step 6: 碰撞检测 — 相机停止移动后重新计算图标/标签可见性
-        this.requestRefreshPointLabelVisibility();
+        // 加 60ms debounce 避免与 camera.changed(150ms) 级联重复触发
+        this.requestRefreshPointLabelVisibility(false, 60);
       }
     );
   }
 
+  /** 根据相机俯仰角动态切换深度测试，平行视角时启用深度测试以避免穿透地形 */
+  private updateDepthTestForPitch(): void {
+    if (!this.viewer) return;
+    const pitchDeg = Cesium.Math.toDegrees(this.viewer.camera.pitch);
+    const newMode = pitchDeg < -65 ? 'down' : 'flat';
+    if (newMode === this._currentPitchMode) return;
+    this._currentPitchMode = newMode;
+
+    const depthValue =
+      newMode === 'flat' ? undefined : Number.POSITIVE_INFINITY;
+    this.pointLayerRegistry.forEach(entities => {
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        if (entity.billboard) {
+          (entity.billboard as any).disableDepthTestDistance = depthValue;
+        }
+        if (entity.label) {
+          (entity.label as any).disableDepthTestDistance = depthValue;
+        }
+      }
+    });
+  }
+
   /** 根据 hoveredEntityId 重定位 popup（相机移动后调用，不重建内容） */
   private repositionHoverPopup(): void {
     if (!this.viewer || !this.popupElement || !this.hoveredEntityId) return;
+
+    // 实时从实体计算世界坐标（跳过 _worldPosCache，使用最新地形 LOD 高度）
     const entity = this.viewer.entities.getById(this.hoveredEntityId);
-    if (!entity || !entity.position) {
-      this.hidePopup();
+    if (entity) {
+      const worldPos = this.computeAnchorWorldPosition(entity, true);
+      if (worldPos) {
+        this._hoverPopupPosition = worldPos;
+        this.updatePopupPosition(worldPos);
+        return;
+      }
+    }
+
+    // 回退：使用缓存
+    if (this._hoverPopupPosition) {
+      this.updatePopupPosition(this._hoverPopupPosition);
       return;
     }
-    const position = entity.position.getValue(this.viewer.clock.currentTime);
-    if (!position) {
-      this.hidePopup();
-      return;
-    }
-    this.updatePopupPosition(position);
+
+    this.hidePopup();
   }
 
   /** 批量模式下每帧更新 popup 位置，实现流畅跟随拖拽 */
@@ -504,19 +791,6 @@ export class MapCesium implements MapInterface {
     return zoom > -1 ? zoom : 0;
   }
 
-  /** 判断实体是否属于 ENG 类型（用于 popup 碰撞优先保留，与 isEntityEng 对齐） */
-  private isEngEntity(entity: Cesium.Entity): boolean {
-    const e = entity as any;
-    // 优先从实体 properties._sttpMap 直接检查（与 Entity 创建时设置的 _sttpMap 一致）
-    const sttpFromProps = String(e._sttpMap || '').toUpperCase();
-    if (sttpFromProps.startsWith('ENG')) return true;
-    // 其次从 _rawData 检查
-    const rawData = e._rawData as Record<string, any> | undefined;
-    if (!rawData) return false;
-    const sttpMap = getNormalizedPopupSttpMap(rawData).toUpperCase();
-    return sttpMap.startsWith('ENG');
-  }
-
   /** 判断实体当前是否可交互（图层可见 + 图例可见 + 区域可见） */
   private isEntityInteractive(entity: Cesium.Entity): boolean {
     const e = entity as any;
@@ -527,6 +801,130 @@ export class MapCesium implements MapInterface {
     return true;
   }
 
+  /**
+   * 判断锚点是否位于 3D 模型（倾斜摄影/OSGB）之上
+   * 用 computeAnchorWorldPosition 取 terrain 修正后的位置与 Cesium3DTileset 包围球求交，
+   * 确保模型表面锚点正确识别。注意：computeAnchorWorldPosition 不再调用 isEntityOnModel，
+   * 不会产生循环调用。
+   */
+  private isEntityOnModel(entity: Cesium.Entity): boolean {
+    if (!this.viewer || !entity.position) return false;
+    const worldPos = this.computeAnchorWorldPosition(entity);
+    if (!worldPos) return false;
+
+    const primitives = this.viewer.scene.primitives;
+    for (let i = 0; i < primitives.length; i++) {
+      const p = primitives.get(i);
+      if (p instanceof Cesium.Cesium3DTileset) {
+        const tileset = p as Cesium.Cesium3DTileset;
+        if (!tileset.show) continue;
+        const bs = tileset.boundingSphere;
+        if (bs) {
+          const dist = Cesium.Cartesian3.distance(worldPos, bs.center);
+          if (dist <= bs.radius) return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 计算锚点的实际渲染世界坐标（固定位置，不跟随鼠标）
+   * 取 entity.position 的经纬度 + 地形高度，构造 CLAMP_TO_GROUND 后的世界坐标
+   * 注意：模型上的锚点由调用方决定是否使用 terrain 修正（MOUSE_MOVE 中已区分处理）
+   */
+  private computeAnchorWorldPosition(
+    entity: Cesium.Entity,
+    skipCache = false
+  ): Cesium.Cartesian3 | undefined {
+    if (!this.viewer || !entity.position) return undefined;
+
+    const entityId = entity.id;
+    // 持久缓存：实体位置不变，terrain 加载后 globe.getHeight 结果也不会变
+    if (!skipCache && entityId && this._worldPosCache.has(entityId)) {
+      return this._worldPosCache.get(entityId)!;
+    }
+
+    const rawPos = entity.position.getValue(this.viewer.clock.currentTime);
+    if (!rawPos) return undefined;
+
+    const carto = Cesium.Cartographic.fromCartesian(rawPos);
+    // 地理坐标键（6 位精度），相同经纬度的锚点共享同一缓存
+    const posKey = `${carto.longitude.toFixed(6)},${carto.latitude.toFixed(6)}`;
+    if (!skipCache && this._geoPosCache.has(posKey)) {
+      const cached = this._geoPosCache.get(posKey)!;
+      // 仅当调用方走的是 entityId 缓存时也用 geo 缓存回填 entityId cache
+      if (entityId && !this._worldPosCache.has(entityId)) {
+        this._worldPosCache.set(entityId, cached);
+      }
+      return cached;
+    }
+
+    // 尝试取地形高度；无数据时回退到原始椭球面高度
+    const terrainHeight = this.viewer.scene.globe.getHeight(carto);
+    const height =
+      terrainHeight !== undefined && terrainHeight > 0
+        ? terrainHeight
+        : carto.height;
+    // +1 与 entity position 的 1m 偏移对齐（RELATIVE_TO_GROUND），避免锚点穿模
+    const worldPos = Cesium.Cartesian3.fromRadians(
+      carto.longitude,
+      carto.latitude,
+      height + 1
+    );
+
+    // 仅在 terrain 有实际高度数据时缓存（避免缓存未加载时的 0 高度占位值）
+    if (terrainHeight !== undefined && terrainHeight > 0) {
+      if (entityId) {
+        this._worldPosCache.set(entityId, worldPos);
+      }
+      this._geoPosCache.set(posKey, worldPos);
+    }
+    return worldPos;
+  }
+
+  /**
+   * 判断鼠标像素是否位于锚点图标的命中区域内（对齐 2D isPixelInsideIconArea）
+   * 排除文字标签区域，只允许图标像素范围触发 hover
+   */
+  private isPixelInsideIconArea(
+    entity: Cesium.Entity,
+    screenPos: Cesium.Cartesian2
+  ): boolean {
+    if (!this.viewer || !entity.position) return false;
+    const zoom = this.getCurrentCesiumZoom();
+    if (zoom === undefined || zoom === null) return false;
+
+    // 用地形高度修正后的锚点世界坐标投影到屏幕 → 图标中心像素
+    // 不能用 rawPos (lon,lat,0)，放大后椭球面与地形高度的偏差在屏幕空间会被放大导致 dx/dy 超出命中区域
+    const anchorWorldPos = this.computeAnchorWorldPosition(entity);
+    if (!anchorWorldPos) return false;
+
+    const iconPixel = Cesium.SceneTransforms.worldToWindowCoordinates(
+      this.viewer.scene,
+      anchorWorldPos
+    );
+    if (!iconPixel) return false;
+
+    const dx = screenPos.x - iconPixel.x;
+    const dy = screenPos.y - iconPixel.y;
+
+    // 动态缩放（与 2D 完全一致）
+    let dynamicScale = 0.7 + (zoom - 4.5) * 0.08;
+    dynamicScale = Math.max(0.5, Math.min(3.0, dynamicScale));
+
+    const halfWidth = 12 * dynamicScale;
+    const topReach = 8 * dynamicScale;
+    const bottomReach = 12 * dynamicScale;
+
+    return (
+      dx >= -halfWidth &&
+      dx <= halfWidth &&
+      dy >= -topReach &&
+      dy <= bottomReach
+    );
+  }
+
   /** 根据实体属性生成 popup HTML，复用 generatePopupHtml */
   private getPopupHtml(rawData: Record<string, any>): string {
     return rawData.popupHtml || generatePopupHtml(rawData) || '';
@@ -535,6 +933,7 @@ export class MapCesium implements MapInterface {
   /** 关闭单个 hover popup */
   private hidePopup(): void {
     this.hoveredEntityId = null;
+    this._hoverPopupPosition = null;
     if (!this.popupElement) return;
     this.popupElement.style.display = 'none';
     this.popupElement.innerHTML = '';
@@ -568,12 +967,6 @@ export class MapCesium implements MapInterface {
   private updatePopupPosition(position: Cesium.Cartesian3): void {
     if (!this.viewer || !this.popupElement) return;
 
-    // 被地形遮挡时隐藏 popup
-    if (this.isPositionBehindTerrain(position)) {
-      this.hidePopup();
-      return;
-    }
-
     const canvasPosition = Cesium.SceneTransforms.worldToWindowCoordinates(
       this.viewer.scene,
       position
@@ -590,8 +983,11 @@ export class MapCesium implements MapInterface {
   }
 
   /** 读取实体原始数据并渲染 hover popup */
-  private showPopupForEntity(entity: Cesium.Entity): void {
-    if (!this.viewer || !this.popupElement || !entity.position) return;
+  private showPopupForEntity(
+    entity: Cesium.Entity,
+    worldPosition?: Cesium.Cartesian3
+  ): void {
+    if (!this.viewer || !this.popupElement) return;
 
     const rawData: Record<string, any> = {
       ...((entity as any)._rawData || {})
@@ -600,7 +996,13 @@ export class MapCesium implements MapInterface {
       rawData.sttpMap = rawData._sttpMap || rawData.popupSttpMap || '';
     }
     const popupHtml = this.getPopupHtml(rawData);
-    const position = entity.position.getValue(this.viewer.clock.currentTime);
+
+    // 优先使用传入的锚点世界坐标（已修正为地形高度），其次回退到 entity.position
+    const position =
+      worldPosition ||
+      (entity.position
+        ? entity.position.getValue(this.viewer.clock.currentTime)
+        : undefined);
 
     if (!popupHtml || !position) {
       this.hidePopup();
@@ -609,6 +1011,7 @@ export class MapCesium implements MapInterface {
 
     this.popupElement.innerHTML = popupHtml;
     this.hoveredEntityId = entity.id;
+    this._hoverPopupPosition = position;
     this.updatePopupPosition(position);
   }
 
@@ -616,25 +1019,30 @@ export class MapCesium implements MapInterface {
 
   /** 启用批量 popup：所有可见锚点固定显示 popup */
   private enableBatchPopupMode() {
-    console.log('[Cesium] enableBatchPopupMode');
+    const zoom = this.getZoomLevelFromCameraHeight(
+      this.getCurrentCameraHeight()
+    );
+    // 二次校验 zoom 门槛，防止初始化时 camera.moveEnd 以错误高度触发
+    if (zoom < this.BATCH_POPUP_MODE_ZOOM) return;
+
     this.isBatchPopupMode = true;
+    this._lastBatchRebuildZoom = zoom;
     this.clearBatchPopups();
     this.hidePopup(); // 清除可能残留的 hover popup
-    // 先同步执行碰撞检测，确保 _iconCollisionVisible 已正确计算，
-    // 避免重叠锚点的 popup 在 showBatchPopups 中被短暂创建
-    this.refreshPointLabelVisibility();
-    // 等所有 chunk 处理完再注册 postRender，避免用不完整列表做碰撞
-    this.showBatchPopups().then(() => {
-      if (this.isBatchPopupMode) {
-        this.setupBatchPopupPostRenderSync();
-      }
-    });
+    // 先注册 postRender（内含 zoom 兜底检测），再构建 popup，确保缩放/拖拽时始终有同步线程
+    this.setupBatchPopupPostRenderSync();
+    // 碰撞检测改为 rAF 异步执行，不再同步阻塞主线程，避免进入批量模式时卡顿 1-2s。
+    // 上一帧的 _iconCollisionVisible 会在下一帧 postRender 的 updateBatchPopupPositions 中使用，
+    // 且 camera.changed/moveEnd 也会触发碰撞检测刷新，不会导致视觉闪烁。
+    this.requestRefreshPointLabelVisibility(false, 0);
+    // 等所有 chunk 处理完再更新 batchPopupItems, postRender 中 updateBatchPopupPositions 会用
+    this.showBatchPopups();
   }
 
   /** 退出批量 popup */
   private disableBatchPopupMode() {
-    console.log('[Cesium] disableBatchPopupMode');
     this.isBatchPopupMode = false;
+    this._lastBatchRebuildZoom = -1;
     this.clearBatchPopupPostRenderSync();
     this.clearBatchPopups();
     this.hidePopup();
@@ -659,21 +1067,22 @@ export class MapCesium implements MapInterface {
       x: number;
       y: number;
       popupHtml: string;
+      engPriority: number;
     }> = [];
 
     this.pointLayerRegistry.forEach(entities => {
       entities.forEach(entity => {
         if (!this.isEntityInteractive(entity)) return;
-        // 图标被碰撞/密度隐藏的锚点不展示 popup（没有可见图标，popup 无意义且干扰碰撞）
-        if ((entity as any)._iconCollisionVisible === false) return;
-        const position = entity.position?.getValue(
-          this.viewer!.clock.currentTime
-        );
-        if (!position) return;
+        // 注：不在此处过滤 _iconCollisionVisible / _labelCollisionVisible，
+        // 由 updateBatchPopupPositions 每帧动态判断，避免一次性过滤导致锚点永远无法出现
+
+        // 用 terrain 高度修正后的坐标投影屏幕位置，与 updateBatchPopupPositions 缓存的 worldPosition 一致
+        const worldPos = this.computeAnchorWorldPosition(entity);
+        if (!worldPos) return;
 
         const cp = Cesium.SceneTransforms.worldToWindowCoordinates(
           this.viewer!.scene,
-          position
+          worldPos
         );
         if (!cp) return;
 
@@ -686,7 +1095,9 @@ export class MapCesium implements MapInterface {
           return;
 
         // 被地形遮挡的不展示 popup
-        if (this.isPositionBehindTerrain(position)) return;
+        if (this.isPositionBehindTerrain(worldPos)) return;
+        // 模型之上的锚点不固定展示 popup，仅通过 hover 触发
+        if (this.isEntityOnModel(entity)) return;
 
         const rawData: Record<string, any> = {
           ...((entity as any)._rawData || {})
@@ -695,11 +1106,7 @@ export class MapCesium implements MapInterface {
           rawData.sttpMap = rawData._sttpMap || rawData.popupSttpMap || '';
         }
 
-        let popupHtml = shouldPreferEng2Popup(rawData)
-          ? generatePopupHtml(rawData, { forceEng2: true }) ||
-            rawData.popupHtml ||
-            generatePopupHtml(rawData)
-          : this.getPopupHtml(rawData);
+        let popupHtml = this.getPopupHtml(rawData);
 
         if (!popupHtml) {
           const title = rawData.titleName || rawData.stnm || rawData.ennm || '';
@@ -707,18 +1114,22 @@ export class MapCesium implements MapInterface {
           popupHtml = `<div class="map-popup-item"><div class="iconDivTitle">${title}</div></div>`;
         }
 
-        candidates.push({ entity, x: cp.x, y: cp.y, popupHtml });
+        candidates.push({
+          entity,
+          x: cp.x,
+          y: cp.y,
+          popupHtml,
+          engPriority: this.getEntityEngRenderPriority(entity)
+        });
       });
     });
 
-    // 按 X 坐标排序，X 接近时（5px 容差，3D 投影浮点误差）ENG 优先
+    // 按 engPriority 降序排列（ENG 优先），高优先级先放置，低优先级碰撞后隐藏
     candidates.sort((a, b) => {
-      const dx = a.x - b.x;
-      if (Math.abs(dx) > 5) return dx;
-      const aEng = this.isEngEntity(a.entity) ? 0 : 1;
-      const bEng = this.isEngEntity(b.entity) ? 0 : 1;
-      if (aEng !== bEng) return aEng - bEng;
-      return dx;
+      if (a.engPriority !== b.engPriority) {
+        return b.engPriority - a.engPriority;
+      }
+      return a.x - b.x;
     });
 
     return candidates;
@@ -761,8 +1172,10 @@ export class MapCesium implements MapInterface {
           popupEl.style.display = 'block';
           popupEl.style.transform = 'translate(-50%, calc(-100% - 10px))';
           popupEl.style.pointerEvents = 'none';
+          popupEl.style.transition = 'opacity 0.15s ease-in';
 
-          // 先隐藏测量尺寸
+          // 先隐藏（opacity 0 + visibility hidden），测量尺寸后再淡入
+          popupEl.style.opacity = '0';
           popupEl.style.visibility = 'hidden';
           popupEl.style.left = `${x}px`;
           popupEl.style.top = `${y}px`;
@@ -779,59 +1192,35 @@ export class MapCesium implements MapInterface {
             bottom: y - 10
           };
 
-          const isCurrentEng = this.isEngEntity(entity);
-          let collidedIdx = -1;
-
+          let hasCollision = false;
           for (let k = 0; k < placedPopups.length; k++) {
             if (this.checkPopupCollision(popupRect, placedPopups[k])) {
-              collidedIdx = k;
+              hasCollision = true;
               break;
             }
           }
 
-          if (collidedIdx === -1) {
-            // 无碰撞：正常放置
+          if (!hasCollision) {
+            // 无碰撞：正常放置 + 淡入
             popupEl.style.visibility = 'visible';
+            popupEl.style.opacity = '1';
             popupEl.style.left = `${x}px`;
             popupEl.style.top = `${y}px`;
+            // 缓存地形高度修正后的世界坐标，每帧用于稳定投影
+            const worldPos =
+              this.computeAnchorWorldPosition(entity) ||
+              entity.position?.getValue(this.viewer.clock.currentTime);
             this.batchPopupItems.push({
               entity,
               element: popupEl,
               popupWidth: pw,
-              popupHeight: ph
+              popupHeight: ph,
+              worldPosition: worldPos
             });
             placedPopups.push({ ...popupRect, entity, element: popupEl });
           } else {
-            const collided = placedPopups[collidedIdx];
-            const isCollidedEng = this.isEngEntity(collided.entity);
-
-            if (isCurrentEng && !isCollidedEng) {
-              // ENG 碰撞普通 popup：移除普通，展示 ENG
-              collided.element.remove();
-              this.batchPopupItems = this.batchPopupItems.filter(
-                item => item.element !== collided.element
-              );
-              popupEl.style.visibility = 'visible';
-              popupEl.style.left = `${x}px`;
-              popupEl.style.top = `${y}px`;
-              this.batchPopupItems.push({
-                entity,
-                element: popupEl,
-                popupWidth: pw,
-                popupHeight: ph
-              });
-              placedPopups[collidedIdx] = {
-                ...popupRect,
-                entity,
-                element: popupEl
-              };
-            } else if (!isCurrentEng && isCollidedEng) {
-              // 普通碰撞 ENG：隐藏当前普通 popup，保留 ENG
-              container.removeChild(popupEl);
-            } else {
-              // 同类型碰撞：后来的让路
-              container.removeChild(popupEl);
-            }
+            // 碰撞：后来的让路
+            container.removeChild(popupEl);
           }
         }
 
@@ -876,6 +1265,16 @@ export class MapCesium implements MapInterface {
   /** 每帧更新批量 popup 屏幕位置 + 碰撞检测（拖拽/缩放时流畅跟随） */
   private updateBatchPopupPositions() {
     if (!this.viewer || !this.batchPopupContainer) return;
+
+    // 每帧主动检测 zoom：缩放时 camera.moveEnd 可能不触发，postRender 在这里兜底退出批量模式
+    const zoom = this.getZoomLevelFromCameraHeight(
+      this.getCurrentCameraHeight()
+    );
+    if (zoom < this.BATCH_POPUP_MODE_ZOOM) {
+      this.disableBatchPopupMode();
+      return;
+    }
+
     if (this.batchPopupItems.length === 0) return;
 
     const canvas = this.viewer.scene.canvas;
@@ -896,11 +1295,9 @@ export class MapCesium implements MapInterface {
 
     for (let i = 0; i < this.batchPopupItems.length; i++) {
       const item = this.batchPopupItems[i];
-      const { entity, element, popupWidth, popupHeight } = item;
-
-      // 先恢复为 block，碰撞检测再做最终决定
-      element.style.display = 'block';
+      const { entity, element, popupWidth, popupHeight, worldPosition } = item;
 
+      // 不提前设为 block：只有通过所有检查才设为可见，避免碰撞检测状态交替时全部闪一下
       if (!this.isEntityInteractive(entity)) {
         element.style.display = 'none';
         continue;
@@ -912,17 +1309,27 @@ export class MapCesium implements MapInterface {
         continue;
       }
 
-      const position = entity.position?.getValue(
-        this.viewer!.clock.currentTime
-      );
-      if (!position) {
-        element.style.display = 'none';
-        continue;
+      // 每帧实时从 terrain 查询当前位置（绕过 computeAnchorWorldPosition 的 _worldPosCache），
+      // 确保 popup 始终跟随 billboard CLAMP_TO_GROUND 的实际渲染位置。
+      // 拖拽时 camera 角度变化可能放大缓存位置与实际位置之间的投影偏差，
+      // 只有 eng 图层出现此问题是因为 eng 锚点主要分布在西部山区（地形起伏大）。
+      const rawPos = entity.position?.getValue(this.viewer.clock.currentTime);
+      if (rawPos) {
+        const rawCarto = Cesium.Cartographic.fromCartesian(rawPos);
+        const terrainHeight = this.viewer.scene.globe.getHeight(rawCarto);
+        if (terrainHeight !== undefined && terrainHeight > 0) {
+          const terrainPos = Cesium.Cartesian3.fromRadians(
+            rawCarto.longitude,
+            rawCarto.latitude,
+            terrainHeight
+          );
+          item.worldPosition = terrainPos;
+        }
       }
 
       const cp = Cesium.SceneTransforms.worldToWindowCoordinates(
         this.viewer!.scene,
-        position
+        item.worldPosition
       );
       if (!cp) {
         element.style.display = 'none';
@@ -941,6 +1348,8 @@ export class MapCesium implements MapInterface {
 
       const x = cp.x;
       const y = cp.y;
+      // 通过所有检查后才设为可见（与开头的惰性策略配合，避免全量闪一下）
+      element.style.display = 'block';
       element.style.left = `${x}px`;
       element.style.top = `${y}px`;
 
@@ -955,18 +1364,12 @@ export class MapCesium implements MapInterface {
       });
     }
 
-    // 第二遍：碰撞检测 — 按 X 排序后右让左，X 接近时（5px 容差）ENG 优先
+    // 第二遍：碰撞检测 — 按 X 排序后右让左（不区分 ENG 类型）
     visibleRects.sort((a, b) => {
-      const dx = a.x - b.x;
-      if (Math.abs(dx) > 5) return dx;
-      const aEng = this.isEngEntity(a.item.entity) ? 0 : 1;
-      const bEng = this.isEngEntity(b.item.entity) ? 0 : 1;
-      if (aEng !== bEng) return aEng - bEng;
-      return dx;
+      return a.x - b.x;
     });
 
     const collisionFlags = new Array(visibleRects.length).fill(false);
-    const instantFlags = new Array(visibleRects.length).fill(false); // ENG 碰撞立即隐藏
     for (let i = 1; i < visibleRects.length; i++) {
       const a = visibleRects[i];
       for (let j = 0; j < i; j++) {
@@ -975,71 +1378,50 @@ export class MapCesium implements MapInterface {
 
         if (!this.checkPopupCollision(a, b)) continue;
 
-        const aEng = this.isEngEntity(a.item.entity);
-        const bEng = this.isEngEntity(b.item.entity);
-
-        if (aEng && !bEng) {
-          // ENG (a) 碰撞普通 (b)：立即隐藏普通，ENG 继续检查是否碰撞其他已放置项
-          collisionFlags[j] = true;
-          instantFlags[j] = true;
-        } else if (!aEng && bEng) {
-          // 普通 (a) 碰撞 ENG (b)：立即隐藏普通
-          collisionFlags[i] = true;
-          instantFlags[i] = true;
-          break;
-        } else {
-          // 同类型碰撞：后来的让路（经 2 帧滞后防闪烁）
-          collisionFlags[i] = true;
-          break;
-        }
+        // 后来的让路（经 2 帧滞后防闪烁）
+        collisionFlags[i] = true;
+        break;
       }
     }
 
-    // 第三遍：应用显示状态，ENG 碰撞立即隐藏，同类型 2 帧滞后防闪烁
+    // 第三遍：应用显示状态
+    // 隐藏立即生效（count >= 1 即隐藏），显示延迟 2 帧防闪烁（count <= -2 才显示）
+    // 缩小过程中新出现的碰撞需要立即响应，否则 popup 重叠可见。2 帧延迟仅用于显示方向，
+    // 避免 zoom 抖动/快速平移时 popup 频繁闪烁。
     for (let i = 0; i < visibleRects.length; i++) {
       const { element } = visibleRects[i].item;
       const hidden = collisionFlags[i];
 
-      if (hidden && instantFlags[i]) {
-        // ENG 碰撞：立即隐藏，不经过滞后
-        element.style.display = 'none';
-        this.popupCollisionFrames.delete(element);
-        continue;
-      }
-
       const prevFrames = this.popupCollisionFrames.get(element) || 0;
       if (hidden) {
         const count = prevFrames > 0 ? prevFrames + 1 : 1;
         this.popupCollisionFrames.set(element, count);
-        if (count >= 2) {
-          element.style.display = 'none';
-        }
+        // 隐藏立即生效（>=1），无需等 2 帧
+        element.style.display = 'none';
       } else {
         const count = prevFrames < 0 ? prevFrames - 1 : -1;
         this.popupCollisionFrames.set(element, count);
+        // 显示延迟 2 帧防闪烁
         if (count <= -2) {
           element.style.display = 'block';
+        } else {
+          element.style.display = 'none';
         }
       }
     }
   }
 
   /** 批量模式下双缓冲重建 popup（图层/图例变化、拖拽/缩放 moveEnd 时调用）。
-   * 在新隐藏容器中构建 popup，构建完成后替换旧容器，避免 clear→rebuild 空白帧闪烁。 */
+   * 旧 popup 保持可见且 postRender 持续更新位置，新 popup 构建完成后无缝替换，消除闪烁。 */
   private _rebuildGeneration = 0;
 
   private rebuildBatchPopupsIfNeeded() {
     if (!this.isBatchPopupMode || !this.containerElement) return;
 
-    console.log(
-      '[Cesium] rebuildBatchPopups gen=%d',
-      this._rebuildGeneration + 1
-    );
-
-    // 停止旧容器的 postRender 同步（旧 popup 在新容器就绪前保持显示）
-    this.clearBatchPopupPostRenderSync();
-
+    // 不停止 postRender，不清空 batchPopupItems：旧 popup 持续更新位置，避免闪一下
     const oldContainer = this.batchPopupContainer;
+    const oldItems = this.batchPopupItems;
+    const oldItemsSet = new Set(oldItems);
     const generation = ++this._rebuildGeneration;
 
     // 在隐藏容器中构建新 popup（尚未插入 DOM）
@@ -1049,13 +1431,10 @@ export class MapCesium implements MapInterface {
       'position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:1000;';
     newContainer.id = 'batch-popup-container';
 
-    this.batchPopupContainer = newContainer;
-    this.batchPopupItems = [];
-    this.popupCollisionFrames = new WeakMap();
-
+    // buildBatchPopupsInContainer 会往 this.batchPopupItems push 新 item，
+    // 旧 item 仍在数组中，postRender 继续更新其位置
     const candidates = this.collectBatchPopupCandidates();
     this.buildBatchPopupsInContainer(newContainer, candidates).then(() => {
-      // 如果期间触发了新的重建，丢弃本次结果
       if (generation !== this._rebuildGeneration) {
         newContainer.remove();
         return;
@@ -1064,10 +1443,20 @@ export class MapCesium implements MapInterface {
         newContainer.remove();
         return;
       }
-      // 双缓冲替换：移除旧容器 → 插入新容器 → 注册 postRender
+      // 过滤掉旧 items，仅保留本次构建的新 items
+      this.batchPopupItems = this.batchPopupItems.filter(
+        item => !oldItemsSet.has(item)
+      );
+      this.popupCollisionFrames = new WeakMap();
+      // 无缝替换容器
       if (oldContainer) oldContainer.remove();
+      this.batchPopupContainer = newContainer;
       this.containerElement!.appendChild(newContainer);
-      this.setupBatchPopupPostRenderSync();
+      // 记录本次 rebuild 的 zoom 级别
+      this._lastBatchRebuildZoom = this.getZoomLevelFromCameraHeight(
+        this.getCurrentCameraHeight()
+      );
+      // postRender 已在 enableBatchPopupMode 中注册，此处无需重复
     });
   }
 
@@ -1111,6 +1500,7 @@ export class MapCesium implements MapInterface {
 
     // 批量 popup 和 hover popup
     this.isBatchPopupMode = false;
+    this._lastBatchRebuildZoom = -1;
     this.clearBatchPopupPostRenderSync();
     this.clearBatchPopups();
     this.hidePopup();
@@ -1187,8 +1577,7 @@ export class MapCesium implements MapInterface {
     this.hydropBaseConfig = null;
     this.BASEID = '';
     this.hoveredEntityId = null;
-
-    console.log('[Cesium] destroyed');
+    this._hoverPopupPosition = null;
   }
 
   private requestRender() {
@@ -1433,7 +1822,7 @@ export class MapCesium implements MapInterface {
         lat,
         height > 100 ? height : 1000
       ),
-      duration: 1.5
+      duration: 2
     });
   }
 
@@ -1517,6 +1906,19 @@ export class MapCesium implements MapInterface {
   ): void {
     if (!this.viewer) return;
 
+    // 地形未就绪时暂缓加载，等 terrainReady 后统一刷新
+    if (!this._terrainReady) {
+      this._pendingInitLayers = this._pendingInitLayers.filter(
+        l => l.key !== layerType
+      );
+      this._pendingInitLayers.push({
+        data: pointData,
+        key: layerType,
+        options: _mdoptions
+      });
+      return;
+    }
+
     let dataArray: any[] = [];
     let targetLayerKey = layerType;
 
@@ -1608,27 +2010,29 @@ export class MapCesium implements MapInterface {
 
       const entity = new Cesium.Entity({
         id: entityId,
-        position: Cesium.Cartesian3.fromDegrees(lon, lat, 0),
+        position: Cesium.Cartesian3.fromDegrees(lon, lat, 1),
         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.CLAMP_TO_GROUND
+          heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
         } as any,
         label: {
           text: labelText || undefined,
           font: dynamicLabelFont as any,
           fillColor: Cesium.Color.WHITE,
-          outlineColor: Cesium.Color.BLACK,
-          outlineWidth: 2,
+          outlineColor: new Cesium.Color(0, 0, 0, 0.9), // 与 2D stroke rgba(0,0,0,0.9) 对齐
+          outlineWidth: 3, // 比 2D 略宽以补偿 Cesium SDF 渲染偏细的问题
           style: Cesium.LabelStyle.FILL_AND_OUTLINE,
           verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
           pixelOffset: dynamicLabelOffset as any,
           horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
           scaleByDistance: new Cesium.NearFarScalar(1.0e3, 1.2, 2.0e7, 0.8),
-          heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+          heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
         } as any,
         properties: {
           ...item,
@@ -1673,7 +2077,13 @@ export class MapCesium implements MapInterface {
 
   mdLayerTreeShowOrHidden(layerType: string, checked?: boolean): void {
     const entities = this.pointLayerRegistry.get(layerType);
-    if (!entities) return;
+    if (!entities) {
+      // 锚点数据暂缓期间，缓存显隐状态等到实体创建后应用
+      if (this._pendingInitLayers.some(l => l.key === layerType)) {
+        this._pendingLayerVisibility.set(layerType, checked !== false);
+      }
+      return;
+    }
 
     const visible = checked !== false;
     entities.forEach(entity => {
@@ -1694,6 +2104,7 @@ export class MapCesium implements MapInterface {
     if (!entities) return;
 
     entities.forEach(entity => {
+      if (entity.id) this._worldPosCache.delete(entity.id);
       if (this.viewer && !this.viewer.isDestroyed()) {
         this.viewer.entities.remove(entity);
       }
@@ -1708,12 +2119,14 @@ export class MapCesium implements MapInterface {
   private destroyAllPointLayers(): void {
     this.pointLayerRegistry.forEach((entities, layerKey) => {
       entities.forEach(entity => {
+        if (entity.id) this._worldPosCache.delete(entity.id);
         if (this.viewer && !this.viewer.isDestroyed()) {
           this.viewer.entities.remove(entity);
         }
       });
     });
     this.pointLayerRegistry.clear();
+    this._worldPosCache.clear();
   }
 
   // ==================== Stubs（后续步骤补齐） ====================
@@ -1809,7 +2222,13 @@ export class MapCesium implements MapInterface {
     checked: boolean
   ): void {
     const entities = this.pointLayerRegistry.get(layerKey);
-    if (!entities) return;
+    if (!entities) {
+      // 锚点数据暂缓期间，缓存图例显隐调用等到实体创建后回放
+      if (this._pendingInitLayers.some(l => l.key === layerKey)) {
+        this._pendingLegendCalls.push({ layerKey, anchoPointState, checked });
+      }
+      return;
+    }
 
     if (!anchoPointState) {
       // 第一步：全部隐藏（配合 restoreLayerLegendVisibility 两步走：先全隐藏再按图例逐项恢复）
@@ -2100,21 +2519,23 @@ export class MapCesium implements MapInterface {
 
   /**
    * 组合计算可见性（3D 解耦模型）：
-   * - entity.show = 基础可见（layer && legend && region），保持 entity 始终"在作用域内"
-   * - entity.billboard.show = 基础可见 && 图标碰撞通过
-   * - entity.label.show = 基础可见 && 标签碰撞通过（图标碰撞不影响标签）
+   * - entity.show = 图层可见 && 区域可见（不含图例），legend 切换时 CLAMP_TO_GROUND 数据不丢失
+   * - entity.billboard.show = 全部基础可见 && 图标碰撞通过
+   * - entity.label.show = 全部基础可见 && 标签碰撞通过（图标碰撞不影响标签）
    */
   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 整体始终基于 layer/legend/region（不受碰撞影响，保证 popup/click 等交互不受碰撞干扰）
-    entity.show = baseVisible;
+    entity.show = entityVisible;
     // 图标单独受碰撞控制
     if (entity.billboard) {
       (entity.billboard as any).show =
         baseVisible && e._iconCollisionVisible !== false;
     }
-    // 标签单独受碰撞控制（不与图标碰撞联动）
+    // 标签受碰撞控制（图标隐藏时标签联动隐藏）
     if (entity.label) {
       (entity.label as any).show =
         baseVisible && e._labelCollisionVisible !== false;
@@ -2167,14 +2588,38 @@ export class MapCesium implements MapInterface {
   private refreshPointLabelVisibility(): void {
     if (!this.viewer) return;
 
-    const currentZoom = this.getCurrentCesiumZoom();
-    if (currentZoom === undefined || currentZoom === null) return;
+    // 防重入：避免 camera.changed + moveEnd 级联触发导致的重复执行
+    if (this._collisionBusy) return;
 
-    console.log(
-      `[Cesium Collision] zoom=${currentZoom?.toFixed(2)} layers=${
-        this.pointLayerRegistry.size
-      }`
-    );
+    // terrain 可用性检测：初始化时 globe.getHeight 可能因瓦片未加载返回 undefined，
+    // 导致所有锚点回退到椭球面高度（0），屏幕位置与实际 CLAMP_TO_GROUND 渲染位置偏差
+    // 极大，碰撞检测失效。此时跳过本轮，通过 rAF 自旋重试直到 terrain 就绪。
+    // 仅当 _worldPosCache 为空时做此检测（已有缓存说明 terrain 数据已可用过）。
+    if (this._worldPosCache.size === 0) {
+      const testCarto = Cesium.Cartographic.fromDegrees(
+        this.CHINA_CENTER.lng,
+        this.CHINA_CENTER.lat
+      );
+      const testHeight = this.viewer.scene.globe.getHeight(testCarto);
+      if (testHeight === undefined || testHeight <= 0) {
+        // terrain 数据尚未就绪，推迟到下一帧重试
+        if (this.collisionRefreshFrameId === null) {
+          this.collisionRefreshFrameId = window.requestAnimationFrame(() => {
+            this.collisionRefreshFrameId = null;
+            this.refreshPointLabelVisibility();
+          });
+        }
+        return;
+      }
+    }
+
+    this._collisionBusy = true;
+
+    const currentZoom = this.getCurrentCesiumZoom();
+    if (currentZoom === undefined || currentZoom === null) {
+      this._collisionBusy = false;
+      return;
+    }
 
     // ===== 阶段0：收集视口内所有基础可见实体 =====
     type CollisionCandidate = {
@@ -2194,6 +2639,7 @@ export class MapCesium implements MapInterface {
       pixelX: number;
       pixelY: number;
       id: string;
+      layerKey: string;
     };
 
     const candidates: CollisionCandidate[] = [];
@@ -2217,6 +2663,25 @@ export class MapCesium implements MapInterface {
     );
     const fontSize = Math.max(10, Math.min(24, 12 * dynamicScale));
 
+    // ===== 阶段0.5：地理边界预过滤（避免对全国所有实体执行昂贵的 globe.getHeight） =====
+    const viewRect = this.viewer.camera.computeViewRectangle();
+    let geoMinLon = -Infinity,
+      geoMaxLon = Infinity,
+      geoMinLat = -Infinity,
+      geoMaxLat = Infinity;
+    if (viewRect) {
+      geoMinLon = Cesium.Math.toDegrees(viewRect.west);
+      geoMaxLon = Cesium.Math.toDegrees(viewRect.east);
+      geoMinLat = Cesium.Math.toDegrees(viewRect.south);
+      geoMaxLat = Cesium.Math.toDegrees(viewRect.north);
+      // 添加缓冲范围（约 1 度，避免边缘实体被误剔除）
+      const geoPad = 1.0;
+      geoMinLon -= geoPad;
+      geoMaxLon += geoPad;
+      geoMinLat -= geoPad;
+      geoMaxLat += geoPad;
+    }
+
     // 第一遍：密度门控 + 构建候选
     this.pointLayerRegistry.forEach((entities, layerKey) => {
       entities.forEach(entity => {
@@ -2234,10 +2699,51 @@ export class MapCesium implements MapInterface {
           return;
         }
 
-        const position = entity.position?.getValue(
-          this.viewer!.clock.currentTime
-        );
-        if (!position) {
+        // 地理边界预过滤：用原始经纬度快速剔除视口外实体，避免昂贵的 globe.getHeight 调用
+        if (viewRect) {
+          const rawLon = Number(e._rawData?.lgtd);
+          const rawLat = Number(e._rawData?.lttd);
+          if (isFinite(rawLon) && isFinite(rawLat)) {
+            if (
+              rawLon < geoMinLon ||
+              rawLon > geoMaxLon ||
+              rawLat < geoMinLat ||
+              rawLat > geoMaxLat
+            ) {
+              return; // 视口外实体，跳过（保留当前碰撞状态不变）
+            }
+          }
+        }
+
+        // 原始椭球面坐标屏幕预过滤：用 entity.position 的椭球面高度（无 terrain 查询）快速投影到屏幕，
+        // 剔除地理边界通过但实际渲染位置偏移较大的边缘实体，进一步减少 globe.getHeight 调用
+        if (entity.position) {
+          const rawPos = entity.position.getValue(
+            this.viewer.clock.currentTime
+          );
+          if (rawPos) {
+            const roughScreenPos =
+              Cesium.SceneTransforms.worldToWindowCoordinates(
+                this.viewer!.scene,
+                rawPos
+              );
+            if (roughScreenPos) {
+              const roughPadding = 200; // 比 viewPadding 更大（120→200），因椭球面偏移可能比实际渲染位置偏下
+              if (
+                roughScreenPos.x < -roughPadding ||
+                roughScreenPos.y < -roughPadding ||
+                roughScreenPos.x > canvas.clientWidth + roughPadding ||
+                roughScreenPos.y > canvas.clientHeight + roughPadding
+              ) {
+                return; // 原始椭球面坐标也在视口外，跳过地形查询
+              }
+            }
+          }
+        }
+
+        // 使用 terrain 高度修正后的世界坐标，与图标实际渲染位置（CLAMP_TO_GROUND）对齐
+        const worldPos = this.computeAnchorWorldPosition(entity);
+        if (!worldPos) {
           e._iconCollisionVisible = false;
           e._labelCollisionVisible = false;
           this.applyEntityVisibility(entity);
@@ -2246,7 +2752,7 @@ export class MapCesium implements MapInterface {
 
         const screenPos = Cesium.SceneTransforms.worldToWindowCoordinates(
           this.viewer!.scene,
-          position
+          worldPos
         );
         if (!screenPos) {
           e._iconCollisionVisible = false;
@@ -2280,6 +2786,7 @@ export class MapCesium implements MapInterface {
             densityPixelGrid
           );
         const densityVisible = currentZoom >= densityMinZoom || bypassDensity;
+        e._densityVisible = densityVisible;
 
         if (!densityVisible) {
           e._iconCollisionVisible = false;
@@ -2288,8 +2795,25 @@ export class MapCesium implements MapInterface {
           return;
         }
 
-        // 构建图标碰撞盒（与 2D 一致：Math.max(14, 24 * dynamicScale)）
-        const iconCollisionSize = Math.max(14, 24 * dynamicScale);
+        // 构建图标碰撞盒：使用图标实际视觉尺寸（与 billboard scale 公式一致）
+        // 3D 图标有独立缩放体系，碰撞盒需与视觉大小对齐，否则碰撞过于激进
+        const iconPixelSize = 24; // 图标图片像素宽度
+        const iconScaleFactor = Math.max(
+          this.ICON_MIN_SCALE,
+          Math.min(
+            this.ICON_MAX_SCALE,
+            this.ICON_BASE_SCALE + (currentZoom - 4.5) * this.ICON_SCALE_RATE
+          )
+        );
+        // scaleByDistance: NearFarScalar(1e3, 1.5, 2e7, 0.8)，线性插值
+        const camHeight = this.viewer!.camera.positionCartographic.height;
+        const sbdT = Math.max(
+          0,
+          Math.min(1, (camHeight - 1000) / (20000000 - 1000))
+        );
+        const scaleByDist = 1.5 + sbdT * (0.8 - 1.5);
+        const visualIconSize = iconPixelSize * iconScaleFactor * scaleByDist;
+        const iconCollisionSize = Math.max(14, visualIconSize);
         const iconLeft = pixelX - iconCollisionSize / 2;
         const iconRight = pixelX + iconCollisionSize / 2;
         const iconTop = pixelY - iconCollisionSize / 2;
@@ -2304,22 +2828,29 @@ export class MapCesium implements MapInterface {
         let labelBottom = 0;
 
         if (hasLabel) {
-          const lines = labelText.split('\n');
-          const maxLineLength = Math.max(
-            ...lines.map((l: string) => l.length),
-            1
-          );
-          const labelLineCount = lines.length;
-          // 标签碰撞偏移与 2D getPointLabelCollisionOffsetY 对齐
+          // 用 Canvas 2D measureText 精确测量像素尺寸，替代公式估算
+          const measured = this.measureLabelPixelSize(labelText, fontSize);
+          const labelLineCount = labelText.split('\n').length;
+          // Cesium 标签 verticalOrigin = BOTTOM，文字底部对齐 pixelY+labelOffsetY，
+          // 文字从底部向上延伸 measured.height。碰撞盒中心应在 pixelY+labelOffsetY - measured.height/2 处。
           const labelOffsetY =
-            labelLineCount > 1 ? -36 * dynamicScale : -28 * dynamicScale;
-          const estimatedWidth = maxLineLength * fontSize * 0.6 + 16;
-          const estimatedHeight = labelLineCount * (fontSize + 4) + 8;
-          const centerY = pixelY + labelOffsetY;
-          labelLeft = pixelX - estimatedWidth / 2;
-          labelRight = pixelX + estimatedWidth / 2;
-          labelTop = centerY - estimatedHeight / 2;
-          labelBottom = centerY + estimatedHeight / 2;
+            labelLineCount > 1
+              ? -this.LABEL_OFFSET_MULTI * dynamicScale
+              : -this.LABEL_OFFSET_SINGLE * dynamicScale;
+          // 标签 scaleByDistance: NearFarScalar(1.0e3, 1.2, 2.0e7, 0.8)，
+          // 与图标逻辑一致，碰撞盒需乘以该因子以匹配实际渲染大小
+          const labelSbdT = Math.max(
+            0,
+            Math.min(1, (camHeight - 1000) / (20000000 - 1000))
+          );
+          const labelScaleByDist = 1.2 + labelSbdT * (0.8 - 1.2);
+          const measuredWidth = measured.width * labelScaleByDist;
+          const measuredHeight = measured.height * labelScaleByDist;
+          const centerY = pixelY + labelOffsetY - measuredHeight / 2;
+          labelLeft = pixelX - measuredWidth / 2;
+          labelRight = pixelX + measuredWidth / 2;
+          labelTop = centerY - measuredHeight / 2;
+          labelBottom = centerY + measuredHeight / 2;
         }
 
         const entityId = String(entity.id || '');
@@ -2341,12 +2872,16 @@ export class MapCesium implements MapInterface {
           densityPriority: this.getEntityDensityPriority(entity),
           pixelX,
           pixelY,
-          id: entityId
+          id: entityId,
+          layerKey: layerKey
         });
       });
     });
 
-    if (candidates.length === 0) return;
+    if (candidates.length === 0) {
+      this._collisionBusy = false;
+      return;
+    }
 
     // ===== 阶段1：排序（eng优先级 > 近邻点优先级 > 密度优先级 > Y轴 > ID） =====
     candidates.sort((left, right) => {
@@ -2365,7 +2900,7 @@ export class MapCesium implements MapInterface {
       return left.id.localeCompare(right.id);
     });
 
-    // ===== 阶段2：图标碰撞（AABB + 空间网格加速） =====
+    // ===== 阶段2：图标碰撞（AABB + 空间网格加速，与 2D 对齐） =====
     const iconPlacedGrid = new Map<
       string,
       Array<{
@@ -2373,6 +2908,12 @@ export class MapCesium implements MapInterface {
         right: number;
         top: number;
         bottom: number;
+        entityId: string;
+        layerKey: string;
+        engPriority: number;
+        nearbyPriority: number;
+        px: number;
+        py: number;
       }>
     >();
 
@@ -2384,36 +2925,34 @@ export class MapCesium implements MapInterface {
         bottom: candidate.iconBottom
       };
 
-      const hasCollision = this.findCollidingRectInGrid(
+      const collidingIcon = this.findCollidingRectInGrid(
         iconRect,
         iconPlacedGrid,
         this.COLLISION_GRID_CELL_SIZE,
         placed => this.checkIconsAabbCollision(placed, iconRect)
       );
 
-      const iconVisible = !hasCollision;
+      const iconVisible = !collidingIcon;
       (candidate.entity as any)._iconCollisionVisible = iconVisible;
 
       if (iconVisible) {
         this.addRectToCollisionGrid(
-          iconRect,
+          {
+            ...iconRect,
+            entityId: candidate.id,
+            layerKey: candidate.layerKey,
+            engPriority: candidate.engPriority,
+            nearbyPriority: candidate.nearbyPriority
+          },
           iconPlacedGrid,
           this.COLLISION_GRID_CELL_SIZE
         );
       }
     });
 
-    // ===== 阶段3：标签碰撞（先避让图标，再避让标签） =====
-    const labelCandidates = [...candidates].sort((left, right) => {
-      if (left.engPriority !== right.engPriority)
-        return right.engPriority - left.engPriority;
-      if (left.nearbyPriority !== right.nearbyPriority)
-        return left.nearbyPriority - right.nearbyPriority;
-      if (left.pixelY !== right.pixelY) return left.pixelY - right.pixelY;
-      if (left.pixelX !== right.pixelX) return left.pixelX - right.pixelX;
-      return left.id.localeCompare(right.id);
-    });
-
+    // ===== 阶段3：标签碰撞（标签 vs 所有图标 + 标签间碰撞） =====
+    // 标签 vs 所有已放置图标：跨图层/跨优先级均检测，仅排除自己的图标
+    // 标签间碰撞：按优先级顺序放置，后放置的标签若与已放置的标签重叠则隐藏
     const labelPlacedGrid = new Map<
       string,
       Array<{
@@ -2424,7 +2963,7 @@ export class MapCesium implements MapInterface {
       }>
     >();
 
-    labelCandidates.forEach(candidate => {
+    candidates.forEach(candidate => {
       const e = candidate.entity as any;
 
       if (!candidate.hasLabel) {
@@ -2432,8 +2971,11 @@ export class MapCesium implements MapInterface {
         return;
       }
 
-      // 3D 解耦：图标被碰撞隐藏不影响标签显示
-      // 标签仍会避让已放置的图标（见下方 iconPlacedGrid 检查）
+      // 图标被隐藏（不论同图层还是跨图层），标签也隐藏
+      if (e._iconCollisionVisible === false) {
+        e._labelCollisionVisible = false;
+        return;
+      }
 
       const labelRect = {
         left: candidate.labelLeft,
@@ -2442,25 +2984,31 @@ export class MapCesium implements MapInterface {
         bottom: candidate.labelBottom
       };
 
-      // 先避让已放置的图标（缩小保护区4px，允许边缘擦过）
+      // 标签避让所有图层的已放置图标（仅排除自己的图标）
       const hasIconCollision = this.findCollidingRectInGrid(
         labelRect,
         iconPlacedGrid,
         this.COLLISION_GRID_CELL_SIZE,
         iconRect => {
-          const inset = 4;
+          // 排除自己的图标
+          if ((iconRect as any).entityId === candidate.id) return false;
+          // 检查 AABB 碰撞（与 2D checkLabelCollisionWithIcon 对齐）
+          // inset 根据图标实际尺寸动态计算：图标越小 inset 越小，避免小图标下碰撞区域过度缩小
+          const iconW = (iconRect as any).right - (iconRect as any).left;
+          const inset = Math.max(2, iconW * 0.1);
           const narrowed = {
             left: iconRect.left + inset,
             right: iconRect.right - inset,
             top: iconRect.top + inset,
             bottom: iconRect.bottom - inset
           };
-          return !(
-            narrowed.right <= labelRect.left ||
-            narrowed.left >= labelRect.right ||
-            narrowed.bottom <= labelRect.top ||
-            narrowed.top >= labelRect.bottom
+          const isCollision = !(
+            narrowed.right < labelRect.left ||
+            narrowed.left > labelRect.right ||
+            narrowed.bottom < labelRect.top ||
+            narrowed.top > labelRect.bottom
           );
+          return isCollision;
         }
       );
 
@@ -2474,7 +3022,9 @@ export class MapCesium implements MapInterface {
         labelRect,
         labelPlacedGrid,
         this.COLLISION_GRID_CELL_SIZE,
-        placed => this.checkLabelAabbCollision(placed, labelRect)
+        placed => {
+          return this.checkLabelAabbCollision(placed, labelRect);
+        }
       );
 
       const labelVisible = !hasLabelCollision;
@@ -2490,18 +3040,16 @@ export class MapCesium implements MapInterface {
     });
 
     // ===== 阶段4：统一应用可见性变化 =====
-    let iconVisibleCount = 0;
-    let labelVisibleCount = 0;
+
     candidates.forEach(candidate => {
-      const e = candidate.entity as any;
-      if (e._iconCollisionVisible) iconVisibleCount++;
-      if (e._labelCollisionVisible) labelVisibleCount++;
       this.applyEntityVisibility(candidate.entity);
     });
 
-    console.log(
-      `[Cesium Collision] 候选=${candidates.length} 图标可见=${iconVisibleCount} 标签可见=${labelVisibleCount}`
-    );
+    // 强制触发渲染，确保 Cesium 在下一帧应用 label.show / billboard.show 变更
+    this.viewer.scene.requestRender();
+
+    // 释放防重入锁
+    this._collisionBusy = false;
   }
 
   // ==================== 碰撞检测辅助：密度门控 ====================
@@ -2651,6 +3199,72 @@ export class MapCesium implements MapInterface {
     return this.isEntityEng(entity) ? 200 : 100;
   }
 
+  // ==================== 文本像素级精确测量 ====================
+
+  /** 复用离屏 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 精确测量文字在屏幕上的像素宽度和高度，
+   * 替代公式估算，消除字体映射差异和 outlineWidth 等不确定因素。
+   * 结果按 `text@roundedFontSize` 缓存，fontSize 随 zoom 变化时自动失效。
+   * @param text 标签文字（支持多行 \n 分隔）
+   * @param fontSize Cesium label font 实际使用的像素字号
+   * @returns { width, height } 像素尺寸（已包含 outlineWidth 补偿和少量内边距）
+   */
+  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: number; height: number } = {
+        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 m = ctx.measureText(line);
+      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，无额外边距）
+    const height = lines.length * roundedFs;
+
+    const result = { width, height };
+    this._measureTextCache.set(cacheKey, result);
+    return result;
+  }
+
   // ==================== 碰撞检测辅助：空间网格与 AABB ====================
 
   /** 计算矩形覆盖的碰撞网格 cell keys */
@@ -2777,7 +3391,6 @@ export class MapCesium implements MapInterface {
   private flushPendingOSGB(): void {
     if (!this.viewer || this.viewer.isDestroyed()) return;
     const items = this._pendingOSGBItems.splice(0);
-    console.log(`[Cesium] 开始加载 ${items.length} 个待加载的倾斜摄影模型`);
     items.forEach(item => LoadOSGB(this.viewer!, item));
   }
 
diff --git a/frontend/src/components/gis/map.class.ts b/frontend/src/components/gis/map.class.ts
index ea1e450d..d514f8fe 100644
--- a/frontend/src/components/gis/map.class.ts
+++ b/frontend/src/components/gis/map.class.ts
@@ -273,6 +273,11 @@ export class MapClass implements MapClassInterface {
     this.service.flyTopanto(position, zoom);
   }
 
+  /** 飞入默认视角（仅 3D 生效）：初始地球视图后，图层加载完再飞入中国 */
+  async flyToDefaultView(): Promise<void> {
+    await this.service.flyToDefaultView();
+  }
+
   getCurrentZoom(): number | undefined {
     return this.service.getCurrentZoom();
   }
diff --git a/frontend/src/components/gis/map.d.ts b/frontend/src/components/gis/map.d.ts
index 9d04a2dd..300ad6b1 100644
--- a/frontend/src/components/gis/map.d.ts
+++ b/frontend/src/components/gis/map.d.ts
@@ -78,6 +78,11 @@ export interface MapInterface {
    */
   initPopupOverlay(popupContainer: HTMLDivElement): void;
 
+  /**
+   * 飞入默认视角（仅 3D 有效），在图层加载完成后调用
+   */
+  flyToDefaultView(): Promise<void>;
+
   /**
    * 初始化加载基础图层
    * @param layer
diff --git a/frontend/src/components/gis/map.ol.ts b/frontend/src/components/gis/map.ol.ts
index 61b66db6..21c8a5b0 100644
--- a/frontend/src/components/gis/map.ol.ts
+++ b/frontend/src/components/gis/map.ol.ts
@@ -2499,6 +2499,11 @@ export class MapOl implements MapInterface {
     return this.view?.getZoom();
   }
 
+  /** 3D 专用飞入默认视角，2D 下无需操作 */
+  async flyToDefaultView(): Promise<void> {
+    // 2D 无动画，空实现
+  }
+
   /**
    * 生成带完整圆边框的上半圆 Canvas
    * @param radius 半径（像素）
diff --git a/frontend/src/components/gis/roam/ThreeDRoamManager.ts b/frontend/src/components/gis/roam/ThreeDRoamManager.ts
new file mode 100644
index 00000000..99f44d32
--- /dev/null
+++ b/frontend/src/components/gis/roam/ThreeDRoamManager.ts
@@ -0,0 +1,363 @@
+/**
+ * 三维漫游管理器
+ * 负责加载 CZML 飞行路径、控制动画、第一人称相机跟随
+ */
+import { czml_huanghe } from './data/riverline';
+import * as Cesium from 'cesium';
+
+export class ThreeDRoamManager {
+  private viewer: any;
+  private dataSource: any = null;
+  private roamingEntity: any = null;
+  private startTime: any = null;
+  private callbackEvent: (() => void) | null = null;
+  private tickCallback: ((clock: any) => void) | null = null;
+  private totalDuration = 0;
+  private onProgress: ((seconds: number) => void) | null = null;
+  private positionList: number[] = [];
+
+  // 开关状态
+  private _flightPathVisible = true;
+  private _flightModelVisible = true;
+
+  // 相机平滑跟随插值状态
+  private _smoothCenter: Cesium.Cartesian3 | null = null;
+  private _smoothOrientation: Cesium.Quaternion | null = null;
+
+  constructor(viewer: any) {
+    this.viewer = viewer;
+  }
+
+  /**
+   * 初始化漫游（加载 CZML 并定位到第0帧）
+   * @param positionList API 返回的坐标点位数组
+   * @param totalTime 总时长（秒）
+   * @param milestoneList 里程碑列表 [[name, time], ...]
+   * @param onProgress 进度回调
+   */
+  async init(
+    positionList: number[],
+    totalTime: number,
+    milestoneList?: [string, string][],
+    onProgress?: (seconds: number) => void
+  ): Promise<void> {
+    this.onProgress = onProgress || null;
+    this.totalDuration = Math.ceil(totalTime || 0);
+
+    // 0. 清除旧数据源（避免堆积）
+    if (this.dataSource) {
+      this.viewer.dataSources.remove(this.dataSource);
+      this.dataSource = null;
+    }
+    this.roamingEntity = null;
+
+    // 1. 处理点位数据（每4个点 +600 形成站点停留）
+    const processedList = [...positionList];
+    for (let i = 0; i < processedList.length; i++) {
+      if ((i + 1) % 4 === 0) {
+        processedList[i] = processedList[i] + 600;
+      }
+    }
+    this.positionList = processedList;
+
+    // 2. 基于模板生成 CZML，替换坐标
+    const c_czml = JSON.parse(JSON.stringify(czml_huanghe));
+    c_czml[1].position.cartographicDegrees = processedList;
+
+    // 动态更新时间区间（总时长秒 → ISO 时间）
+    const totalSec = Math.ceil(totalTime || 0);
+    const endDate = new Date('2021-03-16T10:00:01Z');
+    endDate.setSeconds(endDate.getSeconds() + totalSec);
+    const endStr = endDate.toISOString().replace(/\.\d+Z$/, 'Z');
+    c_czml[0].clock.interval = `2021-03-16T10:00:01Z/${endStr}`;
+    c_czml[0].clock.currentTime = '2021-03-16T10:00:01Z';
+    c_czml[1].availability = `2021-03-16T10:00:01Z/${endStr}`;
+
+    // 3. 加载 CZML
+    try {
+      const dataSourcePromise = await this.viewer.dataSources.add(
+        Cesium.CzmlDataSource.load(c_czml)
+      );
+      this.dataSource = dataSourcePromise;
+      this.roamingEntity = this.dataSource.entities.getById(c_czml[1].id);
+      if (this.roamingEntity) {
+        this.roamingEntity.path.show = this._flightPathVisible;
+        this.roamingEntity.model.show = this._flightModelVisible;
+      }
+
+      // 4. 锁定相机到飞机模型后方（第0帧视角）
+      this.viewer.trackedEntity = this.roamingEntity;
+      this._smoothCenter = null;
+      this._smoothOrientation = null;
+      this.firstPersonModel();
+
+      this.startTime = this.viewer.clock.currentTime.clone();
+      this.viewer.clock.clockRange = Cesium.ClockRange.CLAMPED;
+      this.viewer.clock.multiplier = 1;
+    } catch (error) {
+      console.error('CZML 加载失败:', error);
+    }
+  }
+
+  /** 开始飞行 */
+  start(): void {
+    if (!this.roamingEntity) {
+      console.warn('请先初始化漫游数据');
+      return;
+    }
+    this.viewer.trackedEntity = this.roamingEntity;
+    this.viewer.clock.shouldAnimate = true;
+    this.entitiesVisible(false);
+    this.registerTickCallback();
+  }
+
+  /** 暂停飞行（相机仍锁定在模型位置） */
+  pause(): void {
+    this.viewer.clock.shouldAnimate = false;
+    this.entitiesVisible(true);
+    this.removeTickCallback();
+  }
+
+  /** 重置飞行（回到起点/第0帧） */
+  reset(): void {
+    this.unLockViewAndEntity();
+    this.clearResult();
+    this.viewer.clock.shouldAnimate = false;
+    this._smoothCenter = null;
+    this._smoothOrientation = null;
+    if (this.onProgress) this.onProgress(0);
+  }
+
+  /** 清除飞行路径和模型（保留相机视角完全不变） */
+  clear(): void {
+    // 隐藏模型和路径（不删数据源，不动 trackedEntity 和 lookAtTransform）
+    if (this.roamingEntity) {
+      this.roamingEntity.path.show = false;
+      this.roamingEntity.model.show = false;
+    }
+    // 停止时钟（不动相机，视角完全不变）
+    this.viewer.clock.shouldAnimate = false;
+    // 清理引用
+    this.roamingEntity = null;
+    this.removeTickCallback();
+    this._smoothCenter = null;
+    this._smoothOrientation = null;
+    if (this.onProgress) this.onProgress(0);
+  }
+
+  /** 设置飞行倍率 */
+  setSpeed(multiplier: number): void {
+    this.viewer.clock.multiplier = multiplier;
+  }
+
+  /** 切换飞行路径显隐 */
+  setFlightPathVisible(visible: boolean): void {
+    this._flightPathVisible = visible;
+    if (this.roamingEntity) {
+      this.roamingEntity.path.show = visible;
+    }
+  }
+
+  /** 切换飞行模型显隐 */
+  setFlightModelVisible(visible: boolean): void {
+    this._flightModelVisible = visible;
+    if (this.roamingEntity) {
+      this.roamingEntity.model.show = visible;
+    }
+  }
+
+  /** 跳转到指定时间点（秒） */
+  jumpToTime(seconds: number): void {
+    if (this.startTime) {
+      this.viewer.clock.currentTime = Cesium.JulianDate.addSeconds(
+        this.startTime,
+        seconds,
+        new Cesium.JulianDate()
+      );
+    }
+  }
+
+  /** 视角定位到指定时间点的位置 */
+  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
+      });
+    }
+  }
+
+  /** 是否已加载漫游实体 */
+  get hasEntity(): boolean {
+    return this.roamingEntity !== null && this.roamingEntity !== undefined;
+  }
+
+  /** 销毁清理（完全释放） */
+  destroy(skipCesiumCleanup = false): void {
+    if (skipCesiumCleanup) {
+      // dim 切换：只清引用，Cesium 数据由地图切换自行销毁
+      this.removeTickCallback();
+      this.roamingEntity = null;
+      this.dataSource = null;
+      this.viewer = null;
+      return;
+    }
+    this.clear();
+    if (this.dataSource) {
+      this.viewer.dataSources.remove(this.dataSource);
+      this.dataSource = null;
+    }
+    this.removeFirstPersonModel();
+    this.viewer = null;
+  }
+
+  // ==================== Private ====================
+
+  /** 隐藏/显示地图实体 */
+  private entitiesVisible(visible: boolean): void {
+    const entities = this.viewer.entities?.values;
+    if (entities?.length > 0) {
+      entities.forEach((it: any) => {
+        const name = it?.myname;
+        if (
+          (name === 'tempMarketImg' ||
+            name === 'tempMarkets' ||
+            name === 'tempMarket') &&
+          it.show !== visible
+        ) {
+          it.show = visible;
+        }
+      });
+    }
+  }
+
+  /** 第一人称相机跟随（preRender）—— 平滑插值版 */
+  private firstPersonModel(): void {
+    if (this.viewer.scene) {
+      this.removeFirstPersonModel();
+      this.callbackEvent = this.viewer.scene.preRender.addEventListener(() => {
+        this.setCameraLookAt();
+      });
+    }
+  }
+
+  /** 移除第一人称 */
+  private removeFirstPersonModel(): void {
+    if (this.callbackEvent && typeof this.callbackEvent === 'function') {
+      this.callbackEvent();
+      this.callbackEvent = null;
+    }
+  }
+
+  /** 每帧平滑插值相机到模型后方（解决转向时突然跳动） */
+  private setCameraLookAt(): void {
+    try {
+      const entity = this.viewer.trackedEntity;
+      if (!entity) return;
+
+      const time = this.viewer.clock.currentTime;
+      const targetCenter = entity.position?.getValue(time);
+      const targetOrientation = entity.orientation?.getValue(time);
+      if (!targetCenter || !targetOrientation) return;
+
+      // 插值系数：越小越平滑（跟随延迟越大）
+      const lerpFactor = 0.06;
+
+      // 对位置做 lerp
+      let center: Cesium.Cartesian3;
+      if (this._smoothCenter) {
+        center = Cesium.Cartesian3.lerp(
+          this._smoothCenter,
+          targetCenter,
+          lerpFactor,
+          new Cesium.Cartesian3()
+        );
+      } else {
+        center = targetCenter.clone();
+      }
+
+      // 对朝向做 slerp（球面线性插值，保证旋转平滑）
+      let orientation: Cesium.Quaternion;
+      if (this._smoothOrientation) {
+        orientation = Cesium.Quaternion.slerp(
+          this._smoothOrientation,
+          targetOrientation,
+          lerpFactor,
+          new Cesium.Quaternion()
+        );
+      } else {
+        orientation = targetOrientation.clone();
+      }
+
+      this._smoothCenter = center;
+      this._smoothOrientation = orientation;
+
+      const transform = Cesium.Matrix4.fromRotationTranslation(
+        Cesium.Matrix3.fromQuaternion(orientation),
+        center
+      );
+      this.viewer.camera.lookAtTransform(
+        transform,
+        new Cesium.Cartesian3(-1200, 0, 500)
+      );
+    } catch (e) {
+      // ignore render error
+    }
+  }
+
+  /** 注册 onTick 进度回调 */
+  private registerTickCallback(): void {
+    this.removeTickCallback();
+    const render = (clock: any) => {
+      if (!this.viewer.clock.shouldAnimate) return;
+      if (!this.startTime) return;
+      const timeOffset = Math.floor(
+        Cesium.JulianDate.secondsDifference(clock.currentTime, this.startTime)
+      );
+      if (this.onProgress) {
+        this.onProgress(timeOffset);
+      }
+      // 播放结束自动停止
+      if (this.totalDuration > 0 && timeOffset >= this.totalDuration) {
+        this.clear();
+      }
+    };
+    this.viewer.clock.onTick.addEventListener(render);
+    this.tickCallback = render;
+  }
+
+  /** 移除 onTick 回调 */
+  private removeTickCallback(): void {
+    if (this.tickCallback) {
+      this.viewer.clock.onTick.removeEventListener(this.tickCallback);
+      this.tickCallback = null;
+    }
+  }
+
+  /** 解除实体和视角锁定 */
+  private unLockViewAndEntity(): void {
+    this.viewer.trackedEntity = undefined;
+    if (this.viewer.camera) {
+      this.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+    }
+    this.removeFirstPersonModel();
+  }
+
+  /** 清除数据源 */
+  private clearResult(): void {
+    this.viewer.clock.shouldAnimate = false;
+    this.viewer.trackedEntity = undefined;
+    if (this.dataSource) {
+      this.viewer.dataSources.remove(this.dataSource);
+      this.dataSource = null;
+    }
+    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
new file mode 100644
index 00000000..43b56b57
--- /dev/null
+++ b/frontend/src/components/gis/roam/ThreeDRoamPanel.vue
@@ -0,0 +1,544 @@
+<template>
+  <div class="three-d-roam-panel">
+    <div class="container-roam">
+      <!-- 漫游路径 -->
+      <div v-if="!isLCJ" class="row">
+        <span>漫游路径：</span>
+        <a-tooltip
+          placement="topLeft"
+          :title="tooltipTitle"
+          :open="tooltipVisible"
+          color="#fff"
+          overlayClassName="ThreeDRoamController_tooltip"
+        >
+          <a-select
+            v-model:value="selectedPath"
+            :options="pathOptions"
+            style="width: 120px"
+            @change="handlePathChange"
+          />
+        </a-tooltip>
+        <span class="divider" />
+      </div>
+
+      <!-- 漫游操作 -->
+      <div class="row">
+        <span style="margin-left: 12px">漫游操作：</span>
+        <div
+          class="tool-btn"
+          :style="{ pointerEvents: selectedPath ? 'auto' : 'none' }"
+          @click="handlePlayToggle"
+        >
+          <span
+            v-if="isPlaying"
+            class="icon iconfont icon-pause-circle"
+            style="font-size: 20px"
+            title="暂停"
+          />
+          <span
+            v-else
+            class="icon iconfont icon-play-circle"
+            style="font-size: 20px"
+            title="播放"
+          />
+        </div>
+        <div class="tool-btn" @click="handleReset">
+          <span
+            class="icon iconfont icon-reset"
+            style="font-size: 20px"
+            title="重置"
+          />
+        </div>
+        <div class="tool-btn" @click="handleClear">
+          <span
+            class="icon iconfont icon-clearMap"
+            style="font-size: 20px"
+            title="清除"
+          />
+        </div>
+      </div>
+
+      <!-- 倍率 -->
+      <div class="row">
+        <span class="divider" />
+        <span>倍率：</span>
+        <a-slider
+          style="width: 180px"
+          :min="1"
+          :max="10"
+          :step="0.2"
+          v-model:value="speedMultiplier"
+          class="slider"
+          @change="handleSpeedChange"
+        />
+        <div class="value-display">
+          <span>{{ speedMultiplier }}</span>
+        </div>
+      </div>
+
+      <!-- 显示开关 -->
+      <div class="row">
+        <span class="divider" />
+        <span>飞行路径：</span>
+        <a-switch
+          v-model:checked="showFlightPath"
+          checkedChildren="开启"
+          unCheckedChildren="隐藏"
+          @change="handleFlightPathChange"
+        />
+        <span>飞行模型：</span>
+        <a-switch
+          v-model:checked="showFlightModel"
+          checkedChildren="开启"
+          unCheckedChildren="隐藏"
+          @change="handleFlightModelChange"
+        />
+      </div>
+
+      <!-- 进度条 -->
+      <div class="row" style="flex: 1">
+        <span class="divider" />
+        <a-slider
+          class="slider-roam"
+          style="width: 100%"
+          v-model:value="currentProgress"
+          :max="totalDuration"
+          :marks="milestoneMarks"
+          :tipFormatter="tipFormatter"
+          @afterChange="handleProgressChange"
+        />
+        <div class="value-display">
+          <span>{{ displayTime }}</span>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {
+  ref,
+  computed,
+  onMounted,
+  onUnmounted,
+  watch,
+  defineOptions
+} from 'vue';
+import type { SelectProps } from 'ant-design-vue';
+import {
+  threedroambGetKendoListCust,
+  getThreedRoamData
+} from '@/api/system/disposeManage';
+import { stcdNameList } from '@/utils/GisUrlList';
+import { ThreeDRoamManager } from './ThreeDRoamManager';
+import { MapClass } from '@/components/gis/map.class';
+import { useUiStore } from '@/store/modules/ui';
+
+defineOptions({ name: 'ThreeDRoamPanel' });
+
+// ==================== Props ====================
+const props = defineProps<{
+  /** 是否LCJ项目（黄河基地） */
+  isLCJ?: boolean;
+}>();
+
+// ==================== State ====================
+const selectedPath = ref<string>('');
+const pathOptions = ref<SelectProps['options']>([]);
+const isPlaying = ref(false);
+
+// 倍率
+const speedMultiplier = ref(1);
+
+// 显示开关
+const showFlightPath = ref(true);
+const showFlightModel = ref(true);
+
+// 进度条
+const currentProgress = ref(0);
+const totalDuration = ref(0);
+const milestoneMarks = ref<Record<number, any>>({});
+
+// 提示
+const tooltipVisible = ref(false);
+const tooltipTitle = ref('');
+
+const uiStore = useUiStore();
+
+// 当前漫游数据
+const roamData = ref<any>(null);
+
+// 退出漫游时恢复的相机状态
+let savedCamera: any = null;
+
+let roamManager: ThreeDRoamManager | null = null;
+
+const displayTime = computed(() => formatTime(currentProgress.value));
+
+// ==================== Manager ====================
+
+function getViewer(): any {
+  const mapClass = MapClass.getInstance();
+  return mapClass?.view || null;
+}
+
+async function initRoamManager(): Promise<void> {
+  const viewer = getViewer();
+  if (!viewer) {
+    console.warn('Cesium viewer 未就绪');
+    return;
+  }
+  // 进入漫游：保存当前相机状态用于退出时恢复
+  savedCamera = {
+    position: viewer.camera.position.clone(),
+    direction: viewer.camera.direction.clone(),
+    up: viewer.camera.up.clone()
+  };
+  if (!roamManager) {
+    roamManager = new ThreeDRoamManager(viewer);
+  }
+  // 清除旧数据后重新初始化
+  roamManager.clear();
+  if (!roamData.value?.list) return;
+  await roamManager.init(
+    roamData.value.list,
+    roamData.value.totalTime || 0,
+    roamData.value.milestoneList,
+    (seconds: number) => {
+      currentProgress.value = seconds;
+    }
+  );
+}
+
+// ==================== API Calls ====================
+
+/** 获取飞行路径列表 */
+async function fetchFlightPathList() {
+  try {
+    const params = {
+      logic: 'and',
+      filters: [
+        {
+          field: 'isDeleted',
+          operator: 'eq',
+          dataType: 'string',
+          value: '0'
+        }
+      ],
+      sort: [{ field: 'recordTime', dir: 'asc' }]
+    };
+    const res = await threedroambGetKendoListCust(params);
+    const list = res?.data?.data || [];
+    if (list.length > 0) {
+      pathOptions.value = list.map((item: any) => ({
+        label: item.name,
+        value: item.code,
+        bscd: item.bscd
+      }));
+      // 默认选中第一个
+      if (!selectedPath.value) {
+        selectedPath.value = list[0].code;
+      }
+    }
+  } catch (error) {
+    console.error('获取飞行路径列表失败:', error);
+  }
+}
+
+/** 根据选中的路径code获取漫游数据 */
+async function fetchRoamData(code: string) {
+  if (!code) return;
+  try {
+    const params = {
+      filter: {
+        logic: 'and',
+        filters: [
+          {
+            field: 'code',
+            operator: 'eq',
+            dataType: 'string',
+            value: code
+          }
+        ]
+      }
+    };
+    const res = await getThreedRoamData(params);
+    const data = res || {};
+    roamData.value = data;
+
+    // 设置总时长
+    totalDuration.value = Math.ceil(data.totalTime || 0);
+
+    // 设置里程碑标记
+    if (data.milestoneList?.length > 0) {
+      const marks: Record<number, any> = {};
+      data.milestoneList.forEach(
+        ([name, timeStr]: [string, string], i: number) => {
+          const num = Number(timeStr);
+          const matchedItem = stcdNameList.find(
+            (item: any) => item.value === name
+          );
+          const labelName = matchedItem ? matchedItem.key : name;
+          marks[num] = {
+            style: {
+              color: '#FFFFFF',
+              position: 'absolute',
+              top: i % 2 === 0 ? '-30px' : '-2px'
+            },
+            label: labelName
+          };
+        }
+      );
+      milestoneMarks.value = marks;
+    } else {
+      milestoneMarks.value = {};
+    }
+
+    // 数据就绪后初始化漫游管理器
+    initRoamManager();
+  } catch (error) {
+    console.error('获取漫游数据失败:', error);
+  }
+}
+
+// ==================== Methods ====================
+function formatTime(seconds: number): string {
+  const s = Math.floor(seconds);
+  const m = Math.floor(s / 60);
+  const sec = s % 60;
+  return `${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+}
+
+// 进度条tooltip显示时间
+const tipFormatter = (value: number) => formatTime(value);
+
+function handlePathChange(value: string) {
+  selectedPath.value = value;
+  // 切换路径：先清除旧数据（不用等接口返回）
+  if (roamManager) {
+    roamManager.clear();
+  }
+  isPlaying.value = false;
+  currentProgress.value = 0;
+}
+
+async function handlePlayToggle() {
+  if (!roamManager) return;
+  if (isPlaying.value) {
+    roamManager.pause();
+  } else {
+    // 如果数据被清除（clear后），重新初始化再开始
+    if (!roamManager.hasEntity) {
+      await initRoamManager();
+    }
+    roamManager.start();
+  }
+  isPlaying.value = !isPlaying.value;
+}
+
+function handleReset() {
+  if (!roamManager) return;
+  roamManager.reset();
+  isPlaying.value = false;
+  currentProgress.value = 0;
+  // 重新初始化
+  initRoamManager();
+}
+
+function handleClear() {
+  if (!roamManager) return;
+  roamManager.clear();
+  isPlaying.value = false;
+}
+
+function handleSpeedChange(value: number) {
+  if (roamManager) {
+    roamManager.setSpeed(value);
+  }
+}
+
+function handleFlightPathChange(value: boolean) {
+  if (roamManager) {
+    roamManager.setFlightPathVisible(value);
+  }
+}
+
+function handleFlightModelChange(value: boolean) {
+  if (roamManager) {
+    roamManager.setFlightModelVisible(value);
+  }
+}
+
+function handleProgressChange(value: number) {
+  if (roamManager) {
+    roamManager.jumpToTime(value);
+    roamManager.flyToPositionAtTime(value);
+  }
+}
+
+// ==================== Lifecycle ====================
+onMounted(() => {
+  fetchFlightPathList();
+});
+
+onUnmounted(() => {
+  // dim 切换时跳过 Cesium 清理（由地图切换自行处理），避免影响 2D 地图初始化
+  const skipCesiumCleanup = !!uiStore.skipRoamCameraRestore;
+  roamManager?.destroy(skipCesiumCleanup);
+  roamManager = null;
+  // 恢复相机到进入漫游前的位置（dim 切换时跳过，由地图模式切换自行处理）
+  if (savedCamera && !uiStore.skipRoamCameraRestore) {
+    const viewer = getViewer();
+    if (viewer) {
+      viewer.camera.flyTo({
+        destination: savedCamera.position,
+        orientation: {
+          direction: savedCamera.direction,
+          up: savedCamera.up
+        },
+        duration: 1.5
+      });
+    }
+  }
+  savedCamera = null;
+  uiStore.skipRoamCameraRestore = false;
+});
+
+// 选中路径变化时加载数据
+watch(
+  selectedPath,
+  newVal => {
+    if (newVal) {
+      fetchRoamData(newVal);
+    }
+  },
+  { immediate: true }
+);
+
+// ==================== Expose ====================
+defineExpose({
+  selectedPath,
+  pathOptions,
+  isPlaying,
+  speedMultiplier,
+  currentProgress,
+  totalDuration,
+  milestoneMarks,
+  displayTime,
+  roamData
+});
+</script>
+
+<style scoped lang="scss">
+.three-d-roam-panel {
+  width: 100%;
+  pointer-events: auto;
+}
+
+.container-roam {
+  width: 95%;
+  height: 55px;
+  position: absolute;
+  z-index: 999;
+  bottom: 20px;
+  right: 40px;
+  left: 25px;
+  border: 2px solid #007fcc;
+  background: rgba(12, 51, 88, 0.65);
+  display: flex;
+  padding: 8px 24px;
+  color: white;
+  :deep(.ant-select-selector) {
+    color: white;
+    background: transparent !important;
+    border-color: rgba(0, 127, 204, 0.65);
+  }
+  .slider {
+    :deep(.ant-slider-rail) {
+      background: rgba(255, 255, 255, 0.15);
+    }
+    :deep(.ant-slider-handle::after) {
+      background: rgb(0, 230, 252);
+    }
+  }
+
+  .slider-roam {
+    margin-bottom: 10px !important;
+
+    &:hover {
+      :deep(.ant-slider-rail) {
+        background-color: rgba(255, 255, 255, 0.15) !important;
+      }
+      /* 刻度点 */
+      :deep(.ant-slider-dot) {
+        border-color: #e9e9e9;
+      }
+    }
+    :deep(.ant-slider-mark-text) {
+      margin-left: 4px;
+    }
+    :deep(.ant-slider-handle-click-focused) {
+      border-color: #1890ff !important;
+      box-shadow: none !important;
+      // transform: scale(1) !important;
+      outline: none !important;
+    }
+    :deep(.ant-slider-handle:focus),
+    :deep(.ant-slider-handle:focus-visible),
+    :deep(.ant-slider-handle:focus-within) {
+      outline: none !important;
+      box-shadow: none !important;
+    }
+    :deep(.ant-slider-track) {
+      background-color: rgb(6, 230, 252) !important;
+    }
+    :deep(.ant-slider-with-marks) {
+      margin-bottom: 10px !important;
+    }
+    :deep(.ant-slider-rail) {
+      background: rgba(255, 255, 255, 0.15);
+    }
+    :deep(.ant-slider-handle::after) {
+      background: rgb(0, 230, 252);
+    }
+    :deep(.ant-slider-dot) {
+      background: rgba(255, 255, 255, 0.3);
+    }
+    :deep(.ant-slider-dot-active) {
+      border-color: #ffffff;
+    }
+  }
+}
+
+.row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.divider {
+  height: 44px;
+  width: 1px;
+  background: rgba(0, 127, 204, 0.4);
+  margin: 0 12px;
+}
+
+.tool-btn {
+  background: #2f6b98;
+  border-radius: 50%;
+  height: 32px;
+  width: 32px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  cursor: pointer;
+}
+
+.value-display {
+  width: 90px;
+  padding: 4px 8px;
+  background-color: rgba(12, 51, 88, 0.45);
+  border: 1px solid rgba(0, 127, 204, 0.65);
+  color: rgba(255, 255, 255, 0.35);
+}
+</style>
diff --git a/frontend/src/components/gis/roam/data/riverline.ts b/frontend/src/components/gis/roam/data/riverline.ts
new file mode 100644
index 00000000..b9f4dbbd
--- /dev/null
+++ b/frontend/src/components/gis/roam/data/riverline.ts
@@ -0,0 +1,50 @@
+/**
+ * CZML 飞行路径模板
+ * 运行时由 ThreeDRoamManager 动态替换 position.cartographicDegrees 和 clock.interval
+ */
+export const czml_huanghe = [
+  {
+    id: 'document',
+    name: '黄河八电站漫游',
+    version: '1.0',
+    clock: {
+      interval: '2021-03-16T10:00:01Z/2021-03-16T11:12:18Z',
+      currentTime: '2021-03-16T10:00:01Z',
+      multiplier: 1
+    }
+  },
+  {
+    id: 'hhriverRoamingModel',
+    name: '黄河八电站漫游飞机',
+    description: '从上游电站开始往下游电站漫游飞行模型',
+    availability: '2021-03-16T10:00:01Z/2021-03-16T11:12:18Z',
+    model: {
+      gltf: '/glb/map-air.glb',
+      scale: 10
+    },
+    orientation: {
+      velocityReference: '#position'
+    },
+    viewFrom: {
+      cartesian: [-1480, -1315, 1079]
+    },
+    path: {
+      resolution: 1,
+      material: {
+        polylineGlow: {
+          color: {
+            rgba: [0, 0, 200, 255]
+          },
+          glowPower: 0.4
+        }
+      },
+      width: 3
+    },
+    position: {
+      interpolationAlgorithm: 'HERMITE',
+      interpolationDegree: 7,
+      epoch: '2021-03-16T10:00:01Z',
+      cartographicDegrees: []
+    }
+  }
+]
diff --git a/frontend/src/components/mapController/index.vue b/frontend/src/components/mapController/index.vue
index 28f2fd3d..4c0b1b1d 100644
--- a/frontend/src/components/mapController/index.vue
+++ b/frontend/src/components/mapController/index.vue
@@ -43,7 +43,7 @@
             <i
               class="icon iconfont"
               :class="
-                child.key === 'threedRoam' && activeKey === 'threedRoam'
+                child.key === 'threedRoam' && uiStore.isRoaming
                   ? 'icon-closeCircle'
                   : 'icon-' + child.icon
               "
@@ -396,6 +396,11 @@ const handleControllerClick = (item: any) => {
     case 'dim': // 切换3D/2D
       {
         const switchingTo3D = uiStore.mapType === '2D';
+        // 先关闭漫游（如果有），标记跳过相机还原（由地图切换自行处理）
+        if (uiStore.isRoaming) {
+          uiStore.skipRoamCameraRestore = true;
+          uiStore.isRoaming = false;
+        }
         uiStore.mapType = switchingTo3D ? '3D' : '2D';
         if (switchingTo3D) {
           // 2D→3D：关闭抽屉，请求倾斜摄影数据，开始过渡
@@ -405,7 +410,6 @@ const handleControllerClick = (item: any) => {
         } else {
           // 3D→2D：打开抽屉，清理过渡，卸载所有倾斜摄影模型
           uiStore.drawerOpen = true;
-          uiStore.isRoaming = false;
           cleanup3DTransition();
           activeKey.value = null;
           // 卸载所有倾斜摄影
diff --git a/frontend/src/components/mapFilter/index.vue b/frontend/src/components/mapFilter/index.vue
index 9e495377..93af03ad 100644
--- a/frontend/src/components/mapFilter/index.vue
+++ b/frontend/src/components/mapFilter/index.vue
@@ -647,7 +647,7 @@ const focusSelectedAnchorPoint = () => {
 
   mapOrchestrator.focusPoint(
     selectedValue,
-    uiStore.mapType === '3D' ? 9 : 14,
+    uiStore.mapType === '3D' ? 8 : 14,
     isFishSurveyMode.value ? anchorPointOptions.value : undefined
   );
 };
diff --git a/frontend/src/modules/map/application/map-orchestrator.ts b/frontend/src/modules/map/application/map-orchestrator.ts
index 4c0ff19e..93785339 100644
--- a/frontend/src/modules/map/application/map-orchestrator.ts
+++ b/frontend/src/modules/map/application/map-orchestrator.ts
@@ -227,20 +227,18 @@ export const useMapOrchestrator = () => {
         );
         await mapStore.updateLayerData(checkedKeys, true);
         mapStore.setSelectedLegendData();
-        const backgroundLoadPromise = isInitialLoad
-          ? mapStore.loadAllLayerData(layerConfig, checkedKeys, {
-              pageToken: activePageToken,
-              skipSessionCheck: true,
-              pageKey
-            })
-          : mapStore.loadCurrentPageLayerData(layerConfig, checkedKeys, {
-              pageToken: activePageToken,
-              skipSessionCheck: true
-            });
-
-        void backgroundLoadPromise.catch(error => {
-          console.error(`页面锚点后台加载失败 [${pageKey}]`, error);
-        });
+        if (isInitialLoad) {
+          mapStore.loadAllLayerData(layerConfig, checkedKeys, {
+            pageToken: activePageToken,
+            skipSessionCheck: true,
+            pageKey
+          });
+        } else {
+          mapStore.loadCurrentPageLayerData(layerConfig, checkedKeys, {
+            pageToken: activePageToken,
+            skipSessionCheck: true
+          });
+        }
         backgroundLoadStarted = true;
       }
     } finally {
@@ -297,6 +295,10 @@ export const useMapOrchestrator = () => {
     const checkedKeys = mapViewStore.getCheckedLayerKeys();
     await mapStore.updateLayerData(checkedKeys, true);
     mapStore.setSelectedLegendData();
+    // 切换到 3D 时：先恢复图层，再停留 + 飞入中国视角（与 mountView 一致）
+    if (mapClass.flyToDefaultView) {
+      await mapClass.flyToDefaultView();
+    }
     await syncZoomSensitiveState({
       isHydroMenu: options.getIsHydroMenu(),
       refreshEngPoint: true
@@ -419,6 +421,10 @@ export const useMapOrchestrator = () => {
     bindBaseSelection();
     bindZoomListener(options.getIsHydroMenu);
     await loadPage({ pageKey: options.pageKey, isInitialLoad: true });
+    // 加载完边界线等动态图层后，再从地球视图飞入中国视角
+    if (mapClass.flyToDefaultView) {
+      await mapClass.flyToDefaultView();
+    }
     await syncZoomSensitiveState({
       isHydroMenu: options.getIsHydroMenu(),
       refreshEngPoint: true
@@ -622,6 +628,8 @@ export const useMapOrchestrator = () => {
 
     const previousPageKey = mapConfigStore.lastLoadOptions?.pageKey || '';
     if (previousPageKey && previousPageKey !== pageKey) {
+      // 取消旧页面正在请求的图层数据，释放 HTTP 连接
+      mapStore.abortAllInFlightRequests();
       hideCurrentVisibleLayers();
       mapViewStore.setCheckedLayerKeys([]);
       mapStore.setSelectedLegendData();
diff --git a/frontend/src/store/modules/map.ts b/frontend/src/store/modules/map.ts
index 99cbd6c0..7a99a910 100644
--- a/frontend/src/store/modules/map.ts
+++ b/frontend/src/store/modules/map.ts
@@ -808,7 +808,7 @@ export const useMapStore = defineStore('map', () => {
    * @param items 图层数据
    * @param checkedKeys 选中的图层 keys（用于优先加载）
    */
-  const loadAllLayerData = async (
+  const loadAllLayerData = (
     items: any[],
     checkedKeys: string[] = [],
     options: {
@@ -824,7 +824,6 @@ export const useMapStore = defineStore('map', () => {
     const checkedTasks: Array<() => Promise<any>> = [];
     const uncheckedTasks: Array<() => Promise<any>> = [];
     const processedKeys = new Set<string>();
-    const debugStart = Date.now();
 
     const processItems = (itemList: any[]) => {
       itemList.forEach(item => {
@@ -857,97 +856,101 @@ export const useMapStore = defineStore('map', () => {
 
     processItems(items);
 
-    try {
-      // 首页初始化：所有图层接口一次性并发下发，避免分批串行等待。
-      const loadResults = await Promise.allSettled(
-        [...checkedTasks, ...uncheckedTasks].map(task => task())
-      );
-      const failedResults = loadResults.filter(
-        result => result.status === 'rejected'
-      );
+    const allTasks = [...checkedTasks, ...uncheckedTasks];
 
-      if (failedResults.length > 0) {
-        console.warn(
-          '部分图层数据加载失败，但不会阻断其他图层:',
-          failedResults
+    // 方案三：逐个处理 —— 内部不 await 批量完成，每个请求独立释放 HTTP 连接
+    void (async () => {
+      try {
+        const loadResults = await Promise.allSettled(
+          allTasks.map(task => task())
+        );
+        const failedResults = loadResults.filter(
+          result => result.status === 'rejected'
         );
-      }
 
-      if (
-        (typeof currentSessionId === 'number' &&
-          !isCurrentLoadSession(currentSessionId)) ||
-        !isActivePageToken(options.pageToken)
-      ) {
-        return;
-      }
-
-      if (
-        options.pageKey &&
-        hasPendingPageNavigationAwayFrom(options.pageKey)
-      ) {
-        return;
-      }
-
-      // 确保所有图层的数据都已经缓存到 pointDataCache 和 layer.data
-      const allLayerKeys = getAllLayerKeys(items);
-      for (const key of allLayerKeys) {
-        const layer = findLayerByKey(items, key);
-        if (layer && getEffectivePointLayerData(key).length > 0) {
-          syncBackgroundCacheToReactiveStore(key);
-          layer.data = getEffectivePointLayerData(key);
-        }
-      }
-
-      const allPointData = mapDataStore.rebuildPointDataFromCache(allLayerKeys);
-      attachNearbyPointRuntimeMeta(allPointData);
-      const runtimeCheckedKeys = getRuntimeCheckedLayerKeys();
-      const treeCheckedKeys = mapConfigStore.extractCheckedLayerKeys(
-        layerData.value.length > 0 ? layerData.value : items
-      );
-      const finalCheckedKeys =
-        runtimeCheckedKeys.length > 0 ? runtimeCheckedKeys : treeCheckedKeys;
-
-      // 备注：近邻点元数据需要基于全量点位统一识别，识别完成后同步刷新各图层 Feature。
-      for (const key of allLayerKeys) {
-        const layer = findLayerByKey(items, key);
-        if (!layer || !hasPointLayerData(key)) {
-          continue;
+        if (failedResults.length > 0) {
+          console.warn(
+            '部分图层数据加载失败，但不会阻断其他图层:',
+            failedResults
+          );
         }
 
-        const layerPoints = getPointLayerData(key);
-        const displayData = filterPointLayerDataForDisplay(key, layerPoints);
-        const cacheChecked = mapDataStore.getPointLayerCache(key)?.checked;
-        const shouldRestoreVisible =
-          typeof cacheChecked === 'boolean'
-            ? cacheChecked
-            : layer.checked === 1 || finalCheckedKeys.includes(key);
-        layer.data = layerPoints;
-        mapClass.addInitDataLayer(displayData, key);
-        if (shouldRestoreVisible) {
-          restoreLayerLegendVisibility(key);
+        if (
+          (typeof currentSessionId === 'number' &&
+            !isCurrentLoadSession(currentSessionId)) ||
+          !isActivePageToken(options.pageToken)
+        ) {
+          return;
         }
-        mapClass.mdLayerTreeShowOrHidden(key, shouldRestoreVisible);
-      }
 
-      // 设置选中的图例数据（确保图例在所有锚点加载完成后才显示）
-      setSelectedLegendData();
+        if (
+          options.pageKey &&
+          hasPendingPageNavigationAwayFrom(options.pageKey)
+        ) {
+          return;
+        }
 
-      // 备注：初始化 loading 期间用户可能已经手动改过图层勾选，这里必须以最新运行态收尾，
-      // 不能再回放 load 启动瞬间的默认 checked 快照。
-      await updateLayerData(finalCheckedKeys, true);
-    } finally {
-      const shouldFinishLoading =
-        (typeof currentSessionId !== 'number' ||
-          isCurrentLoadSession(currentSessionId)) &&
-        (options.pageToken === undefined ||
-          activePageRenderToken === options.pageToken);
-      if (shouldFinishLoading) {
-        finishPageLoading(options.pageToken);
+        // 确保所有图层的数据都已经缓存到 pointDataCache 和 layer.data
+        const allLayerKeys = getAllLayerKeys(items);
+        for (const key of allLayerKeys) {
+          const layer = findLayerByKey(items, key);
+          if (layer && getEffectivePointLayerData(key).length > 0) {
+            syncBackgroundCacheToReactiveStore(key);
+            layer.data = getEffectivePointLayerData(key);
+          }
+        }
+
+        const allPointData = mapDataStore.rebuildPointDataFromCache(allLayerKeys);
+        attachNearbyPointRuntimeMeta(allPointData);
+        const runtimeCheckedKeys = getRuntimeCheckedLayerKeys();
+        const treeCheckedKeys = mapConfigStore.extractCheckedLayerKeys(
+          layerData.value.length > 0 ? layerData.value : items
+        );
+        const finalCheckedKeys =
+          runtimeCheckedKeys.length > 0 ? runtimeCheckedKeys : treeCheckedKeys;
+
+        // 备注：近邻点元数据需要基于全量点位统一识别，识别完成后同步刷新各图层 Feature。
+        for (const key of allLayerKeys) {
+          const layer = findLayerByKey(items, key);
+          if (!layer || !hasPointLayerData(key)) {
+            continue;
+          }
+
+          const layerPoints = getPointLayerData(key);
+          const displayData = filterPointLayerDataForDisplay(key, layerPoints);
+          const cacheChecked = mapDataStore.getPointLayerCache(key)?.checked;
+          const shouldRestoreVisible =
+            typeof cacheChecked === 'boolean'
+              ? cacheChecked
+              : layer.checked === 1 || finalCheckedKeys.includes(key);
+          layer.data = layerPoints;
+          mapClass.addInitDataLayer(displayData, key);
+          if (shouldRestoreVisible) {
+            restoreLayerLegendVisibility(key);
+          }
+          mapClass.mdLayerTreeShowOrHidden(key, shouldRestoreVisible);
+        }
+
+        // 设置选中的图例数据（确保图例在所有锚点加载完成后才显示）
+        setSelectedLegendData();
+
+        // 备注：初始化 loading 期间用户可能已经手动改过图层勾选，这里必须以最新运行态收尾，
+        // 不能再回放 load 启动瞬间的默认 checked 快照。
+        await updateLayerData(finalCheckedKeys, true);
+      } finally {
+        const shouldFinishLoading =
+          (typeof currentSessionId !== 'number' ||
+            isCurrentLoadSession(currentSessionId)) &&
+          (options.pageToken === undefined ||
+            activePageRenderToken === options.pageToken);
+        if (shouldFinishLoading) {
+          finishPageLoading(options.pageToken);
+        }
       }
-    }
+    })();
   };
 
-  const loadCurrentPageLayerData = async (
+  const loadCurrentPageLayerData = (
     items: any[],
     checkedKeys: string[] = [],
     options: {
@@ -993,14 +996,12 @@ export const useMapStore = defineStore('map', () => {
 
     beginPageLoading(options.pageToken);
 
-    try {
-      // 菜单切换：仅当前页的勾选图层一次性并发下发，旧请求在后台继续运行。
-      await Promise.allSettled(tasks.map(task => task()));
-    } finally {
+    // 方案三：逐个处理 —— 不 await 批量完成，每个请求独立释放 HTTP 连接
+    void Promise.allSettled(tasks.map(task => task())).then(() => {
       if (isActivePageToken(options.pageToken)) {
         finishPageLoading(options.pageToken);
       }
-    }
+    });
   };
 
   /**
@@ -1446,6 +1447,18 @@ export const useMapStore = defineStore('map', () => {
     }
   };
 
+  /**
+   * 取消所有正在请求的图层数据，释放 HTTP 连接
+   */
+  const abortAllInFlightRequests = () => {
+    for (const [identifier, entry] of inFlightRequestMap.entries()) {
+      entry.controller.abort();
+      inFlightRequestMap.delete(identifier);
+      activeLayerRequestKeyMap.delete(entry.layerKey);
+    }
+    backgroundPointLayerCache.clear();
+  };
+
   /**
    * 更新搜索时间范围并重新加载描点数据
    */
@@ -1461,6 +1474,7 @@ export const useMapStore = defineStore('map', () => {
     loadCurrentPageLayerData,
     loadLayerData,
     setSelectedLegendData,
+    abortAllInFlightRequests,
     legendData,
     setLegendData,
     legendDataSelected,
diff --git a/frontend/src/store/modules/ui.ts b/frontend/src/store/modules/ui.ts
index d629759e..31992ca2 100644
--- a/frontend/src/store/modules/ui.ts
+++ b/frontend/src/store/modules/ui.ts
@@ -8,6 +8,8 @@ export const useUiStore = defineStore('ui', () => {
   const mapSwitchCompletedTick = ref(0);
   // 3d 流域三维漫游
   const isRoaming = ref(false);
+  // dim 切换时跳过漫游相机还原（由地图模式切换自行处理）
+  const skipRoamCameraRestore = ref(false);
 
   // 切换抽屉状态
   const toggleDrawer = () => {
@@ -26,6 +28,7 @@ export const useUiStore = defineStore('ui', () => {
   return {
     drawerOpen,
     isRoaming,
+    skipRoamCameraRestore,
     toggleDrawer,
     setDrawerOpen,
     mapType,
diff --git a/frontend/src/utils/request.ts b/frontend/src/utils/request.ts
index c8e1b177..91849a70 100644
--- a/frontend/src/utils/request.ts
+++ b/frontend/src/utils/request.ts
@@ -56,10 +56,9 @@ service.interceptors.response.use(
     if (status === 200) {
       if (response.data.code == 401) {
         message.error(response.data.msg || '请求失败');
-        setTimeout(() => {
-          localStorage.clear();
-          window.location.href = '/login';
-        }, 1000);
+        localStorage.clear();
+        useUserStoreHook().resetToken();
+        router.push('/login');
         return;
       } else if (response.data.code == 1) {
         message.error(response.data.msg);
diff --git a/frontend/src/views/system/TiltPhotoManagement/index.vue b/frontend/src/views/system/TiltPhotoManagement/index.vue
index 98aa474e..d40ecce4 100644
--- a/frontend/src/views/system/TiltPhotoManagement/index.vue
+++ b/frontend/src/views/system/TiltPhotoManagement/index.vue
@@ -148,7 +148,7 @@ const handleDelete = (record: any) => {
     zIndex: 2002,
     onOk: async () => {
       try {
-        let res = await deleteTiltPhoto({ id: record.id });
+        let res = await deleteTiltPhoto({ stcd: record.stcd });
         message.success('删除成功');
         basicTable.value.refresh();
       } catch (error) {