diff --git a/frontend/.env.development b/frontend/.env.development
index 0eca7e7f..b2b28071 100644
--- a/frontend/.env.development
+++ b/frontend/.env.development
@@ -7,14 +7,14 @@ VITE_APP_TITLE = '水电水利建设项目全过程环境管理信息平台'
 VITE_APP_PORT = 3000
 VITE_APP_BASE_API = '/dev-api'
 # 本地环境
-# VITE_APP_BASE_URL = 'http://10.84.121.127:8093'
+VITE_APP_BASE_URL = 'http://localhost:8093'
 # 测试环境
 # VITE_APP_BASE_URL = 'http://172.16.21.142:8093'
 # VITE_APP_BASE_URL = 'http://172.16.21.142:8096'
 # 汤伟
-# VITE_APP_BASE_URL = 'http://10.84.111.235:8093'
+VITE_APP_BASE_URL = 'http://10.84.111.235:8093'
 # 李林 
-VITE_APP_BASE_URL = 'http://10.84.111.25:8093'
+# VITE_APP_BASE_URL = 'http://10.84.111.25:8093'
 
 # 测试环境线上10.84.121.122:
 VITE_APP_TEST_ONLINE_URL = 'https://211.99.26.225:12122'
diff --git a/frontend/docs/地图模块-3D Cesium实施计划.md b/frontend/docs/地图模块-3D Cesium实施计划.md
index 404e6040..9b22b1b0 100644
--- a/frontend/docs/地图模块-3D Cesium实施计划.md	
+++ b/frontend/docs/地图模块-3D Cesium实施计划.md	
@@ -132,7 +132,7 @@
 
 ## 5. 分步骤实施计划
 
-### Step 1：修正 3D 初始化并默认定位中国
+### Step 1：修正 3D 初始化并默认定位中国 ✅️
 
 目标：
 
@@ -157,7 +157,7 @@
 - 首屏有加载过渡。
 - 进入后稳定落在中国。
 
-### Step 2：展示 3D 基础底图
+### Step 2：展示 3D 基础底图 ✅️
 
 目标：
 
@@ -171,6 +171,10 @@
 - 实现 `addBaseDataLayer(layer, isShow)`：
   - 对 `customBaseLayer` 使用 `url_3d`
   - 对 `BASEMAP-img`、`BASEMAP-white` 预留兼容能力
+  - **必须处理 `wmts` 类型图层**：2D 通过 `WMTS` source 加载，3D 使用 `Cesium.WebMapTileServiceImageryProvider`，从 URL 参数中提取 LAYER/TILEMATRIXSET
+  - **必须提供 `tileMatrixLabels`**：Cesium 默认用纯数字作为 tileMatrix 参数值，但本系统 WMTS 服务器要求 `TileMatrixSet:zoom` 格式（如 `EPSG:3857_hbb_zrbhq_l13:4`）。需构建 `["TileMatrixSet:0", "TileMatrixSet:1", ...]` 传入 `tileMatrixLabels`。
+  - 其他类型：`raster-dem`→XYZ、MapServer→ArcGIS、其余 →WMS
+- **注意**：还存在一个 `key = "powerBaseStation"` 的基地底图图层，该图层**初始化时不加载**（已在 `IGNORED_BASE_LAYER_KEYS` 中忽略），但后续可通过图层树手动勾选显示。
 - 实现 `controlBaseLayerTreeShowAndHidden()`：
   - 让图层树勾选能控制 3D 底图显隐
 - 根据你的要求，UI 层先不开放 `BaseLayerSwitcher` 的 3D 切换行为，只保留默认基础底图加载。
@@ -180,7 +184,7 @@
 - 切到 3D 后可稳定看到基础底图。
 - 图层初始化时 `addBaseDataLayer(this.baseLayerConfig, checked, true)` 的思路在 3D 可落地。
 
-### Step 3：打通 3D 锚点展示
+### Step 3：打通 3D 锚点展示 ✅️
 
 目标：
 
@@ -189,13 +193,14 @@
 
 计划：
 
-- 在 `MapCesium` 内建立点位图层注册结构，建议按 `layerKey -> entity[]` 或 `CustomDataSource` 管理。
+- 在 `MapCesium` 内建立点位图层注册结构，按 `layerKey -> entity[]` 管理。
 - 实现 `addInitDataLayer(pointData, layerType)`：
   - 复用当前点位数据结构
   - 解析 `lgtd/lttd/iconCode/titleName/stnm/anchoPointState/popupHtml`
   - 复用现有图标资源路径
+  - Entity ID 使用 `${layerKey}:${item._id || `${iconType || 'point'}_${stcd}`}`，与 2D 对齐，确保同 stcd 不同 sttpMap 的点不被覆盖
   - 确保 `eng_point` 仍按现有 `mapStore` 过滤后的数据展示，中型站点只在 `7.5` 以上层级出现
-  - 为后续缩放驱动的增量显示预留运行态字段，不把所有点简单一次性硬渲染
+  - 为后续缩放驱动的增量显示预留运行态字段（`_legendVisible`、`_regionVisible`、`_densityVisible`），不把所有点简单一次性硬渲染
 - 实现 `mdLayerTreeShowOrHidden(layerType, checked)`：
   - 图层树控制整个点图层显隐
 - 实现 `removePointLayer()` / `hasLayer()`
@@ -208,7 +213,34 @@
 - 取消勾选图层后，对应锚点消失。
 - `eng_point` 在低于 `7.5` 时不显示中型水电站，高于 `7.5` 时正常显示。
 
-### Step 4：打通 3D popup 与 hover
+### Step 4：打通 3D 基地裁切（jdPanelControlShowAndHidden） ✅️
+
+目标：
+
+- 3D 点击基地面板后，与 2D 行为一致。
+- 加载基地边界 GeoJSON，只显示区域内锚点，隐藏区域外锚点。
+- 取消基地时恢复显示所有锚点。
+
+计划：
+
+- 在 `MapCesium` 中捕获 `hydropBase` 配置，与 2D 一样在 `addBaseDataLayer` 中记录。
+- 实现 `jdPanelControlShowAndHidden(baseid, isAll)`：
+  - `isAll=false`：清除 3D 球面遮罩实体、恢复所有锚点区域可见性、清除裁切状态。
+  - `isAll=true`：先隐藏所有锚点，异步加载基地边界 GeoJSON，执行点在面判断后仅显示区域内锚点，同时在球面绘制裁切边界多边形（`applyRegionMask`），最后飞行到区域视野。
+- 在 `createEntityPropertiesBag` 中新增 `_regionVisible` 属性，初始为 `true`。
+- 在 `applyPointVisibilityRefresh` 中跳过 `_regionVisible !== false` 的实体，确保裁切后碰撞检测不会把区域外锚点重新显示出来。
+- 复用 `extractPolygonCoords` / `isPointInRing` 射线法判断逻辑（与 `region-mask-manager.ts` 一致）。
+- 支持 `AbortController` 取消前一次未完成的请求，避免响应顺序错乱。
+- `applyRegionMask` 将 GeoJSON 多边形转换为 Cesium `PolygonHierarchy`，在球面绘制半透明填充 + 可见边界的区域多边形，模拟 2D 底图 Canvas 裁切遮罩的视觉效果。
+
+验收：
+
+- 点击基地后，3D 只显示该基地区域内的锚点，区域外锚点隐藏。
+- 取消基地后，所有锚点恢复正常显示。
+- 快速切换基地不会出现旧数据覆盖新数据的问题。
+- 多次切换 2D/3D 后基地裁切行为正常。
+
+### Step 5：打通 3D popup 与 hover ✅️
 
 目标：
 
@@ -233,7 +265,7 @@
 - 样式和 2D 保持一致。
 - 移出后 popup 正常消失。
 
-### Step 5：补齐缩放驱动显示与碰撞检测
+### Step 6：补齐缩放驱动显示与碰撞检测
 
 目标：
 
@@ -263,7 +295,7 @@
 - 放大到具体层级后会看到更多锚点逐步出现。
 - 标签和锚点不会大面积重叠到不可读。
 
-### Step 6：打通 3D 锚点点击详情
+### Step 7：打通 3D 锚点点击详情 ✅️
 
 目标：
 
@@ -287,7 +319,7 @@
 - `ylfb` 和普通锚点分支行为一致。
 - 点击空白区域不会误触发弹框。
 
-### Step 7：打通图例联动
+### Step 8：打通图例联动 ✅️
 
 目标：
 
@@ -305,7 +337,7 @@
 - 图例单项勾选/取消时，3D 对应类别锚点同步显隐。
 - 图例分组勾选/取消时，3D 行为与 2D 保持一致。
 
-### Step 8：补足收口与稳定性
+### Step 9：补足收口与稳定性 ✅️
 
 目标：
 
@@ -329,7 +361,7 @@
 
 1. 默认定位到中国 + 启动动画
 2. 展示基础底图
-3. 展示锚点
+3. 展示锚点 3.5. 补基地裁切（jdPanelControlShowAndHidden）
 4. 补 hover popup
 5. 补缩放驱动显示与碰撞检测
 6. 补锚点点击详情
@@ -337,64 +369,6 @@
 8. 补图例联动
 9. 做切换稳定性收口
 
-## 9. 必须补齐的隐藏逻辑清单
-
-下面这些逻辑不是表面接口能直接看出来的，但如果 `3D` 不补，最终效果就会和 `2D` 明显不一致。
-
-### 9.1 图层与菜单切换
-
-- 菜单切换时，只隐藏旧页点图层，不隐藏底图。
-- 图层树勾选前要先经过互斥规则归一化：
-  - `rare_fish_point` 与 `fish_along_point` 互斥
-  - `stinfo/stinfo_video_point` 与 `stinfo_ai_video_point` 互斥
-  - `facilities` 与 `facilities_built` 两个分支互斥
-- 点图层取消勾选时只隐藏，不删除缓存；重新勾选时优先从缓存恢复。
-
-### 9.2 图例与点内显隐
-
-- 图例控制的是图层内部锚点是否可见，不是图层本身是否可见。
-- 图层恢复显示时，图例要先整层全关，再按当前 checked 状态逐项恢复。
-- 环保设施图例组当前是只展示不交互。
-
-### 9.3 缩放驱动显示
-
-- `eng_point` 的中型水电站只在 `ENG_POINT_MEDIUM_VISIBLE_ZOOM = 7.5` 以上显示。
-- 水电开发页缩放跨过 `12` 级时，会自动补开一批动态图层；缩回去时再自动收口。
-- `2D` 存在“缩放越大显示越多”的行为，不是所有锚点在所有层级都等量显示。
-- `2D` 还存在 hover、批量 popup、密度控制等缩放阈值：
-  - hover 低于一定缩放不触发
-  - 高缩放会进入批量 popup 模式
-  - 点位会随着缩放提升逐步放开显示限制
-
-### 9.4 锚点碰撞与控量
-
-- `2D` 中锚点是否可见，不只受图层开关控制，还受以下门闩共同影响：
-  - 图例可见性
-  - 区域裁切可见性
-  - 密度阈值
-  - 图标碰撞结果
-  - 标签碰撞结果
-- 低缩放下，为避免堆叠，部分锚点或标签会被主动隐藏。
-- 高缩放下，会逐步放开图标/标签限制，显示更多内容。
-- 因此 `3D` 不能简单把所有 entity 永久全开，否则视觉密度会明显失控。
-
-### 9.5 Popup 与点击
-
-- hover popup 不是全时开启的，有缩放门槛。
-- 点击和 hover 的命中对象是图标本体，不是任意文字区域。
-- `ylfb` 与普通锚点的点击详情弹框走不同业务分支。
-
-### 9.6 基地与区域裁切
-
-- 基地切换不仅影响搜索候选，还会影响地图上的点位可见范围。
-- 区域裁切会直接把区域外点位隐藏，不是只改底图遮罩。
-
-### 9.7 筛选器特殊逻辑
-
-- 装机容量筛选本质是批量切 `eng_point` 图例状态，不是简单切图层。
-- 鱼类分布模式会接管 `ylfb_point` 的数据、缓存、图例与显隐。
-- 时间筛选当前只重载指定时间相关图层，不是全量重载。
-
 ## 7. 预计修改文件
 
 - `src/components/gis/map.cesium.ts`
@@ -415,3 +389,91 @@
 - 默认飞到中国
 
 这一步最小、最容易验证，也能先把“打开 3D 看起来不对”的核心问题解决掉。
+
+## 9. 必须补齐的隐藏逻辑清单
+
+下面这些逻辑不是表面接口能直接看出来的，但如果 `3D` 不补，最终效果就会和 `2D` 明显不一致。
+
+### 9.1 图层与菜单切换 ✅️
+
+- ✅ 菜单切换时，只隐藏旧页点图层，不隐藏底图。（编排器 `handlePageChange` 控制，Cesium 被动接收数据）
+- ✅ 图层树勾选前要先经过互斥规则归一化：（store 层 `updateLayerData` 处理，Cesium 不感知）
+  - `rare_fish_point` 与 `fish_along_point` 互斥
+  - `stinfo/stinfo_video_point` 与 `stinfo_ai_video_point` 互斥
+  - `facilities` 与 `facilities_built` 两个分支互斥
+- ✅ 点图层取消勾选时只隐藏，不删除缓存；重新勾选时优先从缓存恢复。`mdLayerTreeShowOrHidden` 设置 `_layerVisible` 标志，不删除 `pointLayerRegistry` 条目。
+- ✅ **图层树勾选时按 `type` 字段走不同分支**（见 `updateLayerData`，store 层处理）：
+  - `type === 'pointMap'` → 走 `handlePointMapLayer` → 调用 `mdLayerTreeShowOrHidden`（已实现，L1624）
+  - `type === 'GISMap'` → 走 `controlBaseLayerTreeShowAndHidden`（已实现，L1345）
+  - 3D Cesium 已同时实现这两个方法。
+
+### 9.2 图例与点内显隐 ✅️
+
+- ✅ 图例控制的是图层内部锚点是否可见，不是图层本身是否可见。`setLegendPointVisible` 使用 `_legendVisible` 标志，与 `_layerVisible` 独立。
+- ✅ 图层恢复显示时，图例要先整层全关，再按当前 checked 状态逐项恢复。支持 `anchoPointState=''` 全关 → 逐项 `(state, true)` 恢复两步模式（L1764-1787）。
+- ✅ 环保设施图例组当前是只展示不交互。（编排器层面控制，Cesium 不感知）
+
+### 9.3 缩放驱动显示 ✅️
+
+- ✅ `eng_point` 的中型水电站只在 `ENG_POINT_MEDIUM_VISIBLE_ZOOM = 7.5` 以上显示。（store `filterPointLayerDataForDisplay` 在数据进入 Cesium 前过滤）
+- ✅ 水电开发页缩放跨过 `12` 级时，会自动补开一批动态图层；缩回去时再自动收口。（编排器层面处理）
+- ✅ `2D` 存在"缩放越大显示越多"的行为。碰撞检测中密度门控逐级放开。
+- ✅ `2D` 还存在 hover、批量 popup、密度控制等缩放阈值：
+  - hover 低于 ~zoom 4.5 不触发（`HOVER_POPUP_MAX_HEIGHT = 9_000_000`）
+  - 高缩放进入批量 popup 模式（`BATCH_POPUP_MODE_ZOOM = 14.9`）
+  - 点位随着缩放提升逐步放开密度限制（密度门控 + `DENSITY_ISOLATION_THRESHOLD`）
+- ✅ **图标动态缩放**：`CallbackProperty` 实现 `billboard.scale`，公式 `clamp(0.7 + (zoom - 4.5) * 0.035, 0.4, 1.2)`（L1522）。
+- ✅ **字体动态大小**：`CallbackProperty` 实现 `label.font`，钳位 `[10, 20]`（L1535）。
+- ✅ **文字在图标上方**：`CallbackProperty` 实现 `label.pixelOffset`，负 Y 偏移（L1549）。
+- ✅ **Cesium 中必须使用 `CallbackProperty` 实现动态缩放**：已使用 3 个 `CallbackProperty`（scale/font/offset），`isConstant=false` 每帧重算。
+
+### 9.4 锚点碰撞与控量 ✅️
+
+- ✅ `2D` 中锚点是否可见，不只受图层开关控制，还受以下门闩共同影响：
+  - 图例可见性 `_legendVisible`
+  - 区域裁切可见性 `_regionVisible`
+  - 密度阈值（碰撞循环中 inline 计算，逐级放开）
+  - 图标碰撞结果 `_iconCollisionVisible`
+  - 标签碰撞结果 `_labelCollisionVisible`
+- ✅ 低缩放下，为避免堆叠，部分锚点或标签会被主动隐藏。（`refreshPointLabelVisibility` 碰撞检测，L2117-2455）
+- ✅ 高缩放下，会逐步放开图标/标签限制，显示更多内容。（密度门控 + 碰撞容差随 zoom 调整）
+- ✅ 因此 `3D` 不能简单把所有 entity 永久全开。所有 entity 初始 `_iconCollisionVisible = _labelCollisionVisible = true`，碰撞检测运行后动态调整。
+
+### 9.5 Popup 与点击 ✅️
+
+- ✅ hover popup 不是全时开启的，有缩放门槛。相机高度 > `HOVER_POPUP_MAX_HEIGHT` 时不触发 hover。
+- ✅ 点击和 hover 的命中对象是图标本体，不是任意文字区域。`ScreenSpaceEventHandler` 基于 `scene.pick` 命中 entity。
+- ✅ `ylfb` 与普通锚点的点击详情弹框走不同业务分支。`sttpMap === 'ylfb'` 打开 `ylfbModalVisible`，其他走 `modalVisible`（L366-375）。
+
+### 9.6 基地与区域裁切 ✅️
+
+- ✅ 基地切换不仅影响搜索候选，还会影响地图上的点位可见范围。`jdPanelControlShowAndHidden` 实现（L1684-1748）。
+- ✅ 区域裁切会直接把区域外点位隐藏，不是只改底图遮罩。`filterPointsByRegion` 设置 `_regionVisible = false`（L1824-1848），遮罩多边形 + 裁剪双重处理。
+
+### 9.7 筛选器特殊逻辑 ✅️
+
+- ✅ 装机容量筛选本质是批量切 `eng_point` 图例状态，不是简单切图层。（store 层处理，Cesium 通过 `setLegendPointVisible` 响应）
+- ✅ 鱼类分布模式会接管 `ylfb_point` 的数据、缓存、图例与显隐。（store 层处理）
+- ✅ 时间筛选当前只重载指定时间相关图层，不是全量重载。（store 层处理）
+
+### 9.8 数据进入 addInitDataLayer 前的预处理 ✅️
+
+- ✅ 所有点位数据在进入 `addInitDataLayer` 前会经过 `normalizePointLayerItems()` 过滤：（store 层 `map.ts` 执行，Cesium 接收时已过滤）
+  - 没有 `iconCode` 且 `code !== 'colorLayer'` 的项会被抛弃
+  - `baseId == 'all'` 且 `anchoPointState` 结尾为 `_nbuilt` 的项会被抛弃
+- ✅ `_id` 默认值生成规则：store 层生成 `${sttpMap || iconType || 'point'}_${stcd}`。
+- ✅ **stcd+经纬度重复锚点处理**：Cesium entity ID 使用 `${layerKey}:${item._id}`，与 2D 对齐，同 stcd 不同 sttpMap 的点不会互相覆盖。
+
+### 9.9 图标渐进加载机制
+
+- ❌ 2D 中图标不是一次性全加载完。有 `loading → loaded → error` 三种状态跟踪。
+- ❌ 只有 `loaded` 状态的图标才参与样式渲染，loader 失败的不渲染。
+- ❌ 如果在图标加载过程中就触发了样式刷新，需要通过 `requestAnimationFrame` 回刷。
+- ❌ 3D Cesium 中当前所有 entity 同步创建，billboard `image` URL 直接赋值，无渐进加载。Cesium 内部纹理加载无显式状态跟踪。
+
+### 9.10 密度分档与近邻点元数据 ✅️
+
+- ✅ 每个锚点的 `distance` 字段表示密度分档值（不是物理距离），值越大表示越稀疏。（已使用 `getEntityDensityValue` 从 `_rawData.distance` 读取，L2460）
+- ✅ 不同 density 值对应不同的 `minZoom` 显示门槛。`getEntityDensityMinZoom` 映射 `nearby-point-rules.ts` 的 `densityDisplayRules`（L2491）。
+- ✅ 全量数据加载后，store 会调用 `attachNearbyPointRuntimeMeta()` 给所有点打上 `_nearbyRule`、`_nearbyGroupId`、`_nearbyPriority` 等元数据。（store 层处理，Cesium 碰撞检测中读取）
+- ✅ **孤立点例外规则**：如果一个点在当前视口内 ~56px 范围内没有同 layerKey 的其他可见点，它可以绕过密度门槛直接显示。`DENSITY_ISOLATION_THRESHOLD = 56` + `shouldBypassDensityGateForIsolatedEntity`（L2506-2556）。
diff --git a/frontend/src/api/home/index.ts b/frontend/src/api/home/index.ts
index 1f2ac831..0c450a18 100644
--- a/frontend/src/api/home/index.ts
+++ b/frontend/src/api/home/index.ts
@@ -79,6 +79,16 @@ export function vmsstbprptGetKendoList(data: any) {
     data: data
   });
 }
+// 环保自动监测工作开展情弹窗
+export function overviewvmsstbprptGetKendoList(data: any) {
+  return request({
+    url: '/overview/vmsstbprpt/GetKendoList',
+    method: 'post',
+    data: data
+  });
+}
+
+
 
 // 获取基本信息
 export function baseMsstbprptGetKendoList(data: any) {
diff --git a/frontend/src/api/system/map/TiltPhotoManagement/index.ts b/frontend/src/api/system/map/TiltPhotoManagement/index.ts
index b6ee61fc..5b041a97 100644
--- a/frontend/src/api/system/map/TiltPhotoManagement/index.ts
+++ b/frontend/src/api/system/map/TiltPhotoManagement/index.ts
@@ -1,9 +1,9 @@
 import request from '@/utils/request';
-
+ 
 // 获取所有倾斜摄影
 export function getAllTiltPhotoTree(data: any) {
   return request({
-    url: '/api/wmp-sys-server/sys/oblique/GetKendoListCust',
+    url: '/sys/oblique/GetKendoListCust',
     method: 'post',
     data: data
   });
@@ -11,7 +11,7 @@ export function getAllTiltPhotoTree(data: any) {
 // 保存倾斜摄影
 export function saveTiltPhoto(data: any) {
   return request({
-    url: '/api/wmp-sys-server/sys/oblique/addOrUpdate',
+    url: '/sys/oblique/addOrUpdate',
     method: 'post',
     data: data
   });
@@ -19,7 +19,7 @@ export function saveTiltPhoto(data: any) {
 // 删除倾斜摄影
 export function deleteTiltPhoto(data: any) {
   return request({
-    url: '/api/wmp-sys-server/sys/oblique/delete',
+    url: '/sys/oblique/delete',
     method: 'get',
     params: data
   });
diff --git a/frontend/src/components/BasicSearch/index.vue b/frontend/src/components/BasicSearch/index.vue
index 1a500565..1df4f7c2 100644
--- a/frontend/src/components/BasicSearch/index.vue
+++ b/frontend/src/components/BasicSearch/index.vue
@@ -468,7 +468,7 @@ const triggerManualValuesChange = (changedKey: string, newValue: any) => {
   emit('valuesChange', changedValues, { ...formData });
 };
 
-const dataDimensionDataChange = (value: any, fieldName: string = 'baseId') => {
+const dataDimensionDataChange = (value: any, fieldName = 'baseId') => {
   formData[fieldName] = value;
   formData.rstcd = "";
   shuJuTianBaoStore.getEngOption(value,'baseId');
diff --git a/frontend/src/components/BasicTable/index.vue b/frontend/src/components/BasicTable/index.vue
index 5f5d7990..716cc092 100644
--- a/frontend/src/components/BasicTable/index.vue
+++ b/frontend/src/components/BasicTable/index.vue
@@ -192,6 +192,7 @@ const getList = async (filter?: Record<string, any>) => {
   total.value = 0;
   if (filter !== undefined) {
     lastFilter.value = filter;
+    page.value = 1;
   }
   try {
     // 合并排序参数：优先使用用户手动排序，否则使用 searchParams 中的默认排序
diff --git a/frontend/src/components/carouselIntroduce/ArtsDetail.vue b/frontend/src/components/carouselIntroduce/ArtsDetail.vue
index b0d95b82..e2e1de19 100644
--- a/frontend/src/components/carouselIntroduce/ArtsDetail.vue
+++ b/frontend/src/components/carouselIntroduce/ArtsDetail.vue
@@ -5,7 +5,7 @@
             <div class="card_left">
                 <div class="card_img">
                     <div class="carousel-wrapper">
-                        <div class="carousel-inner">
+                        <div class="carousel-inner" ref="carouselInnerRef">
                             <div class="carousel-track" :style="trackStyle">
                                 <div v-for="(item, index) in originalMediaData" :key="index" class="carousel-item">
                                     <a-image :src="item.url" />
@@ -43,7 +43,7 @@
 </template>
 
 <script lang="ts" setup>
-import { ref, computed, onMounted, watch } from 'vue';
+import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
 import { LeftOutlined, RightOutlined } from '@ant-design/icons-vue';
 
 defineOptions({
@@ -67,6 +67,15 @@ interface MediaItem {
 
 const originalMediaData = ref<MediaItem[]>([]);
 const currentIndex = ref(0);
+const carouselInnerRef = ref<HTMLElement | null>(null);
+const itemWidth = ref(0);
+let resizeObserver: ResizeObserver | null = null;
+
+const updateItemWidth = () => {
+    if (carouselInnerRef.value) {
+        itemWidth.value = carouselInnerRef.value.clientWidth;
+    }
+};
 
 // 初始化数据
 const initOriginalData = () => {
@@ -89,10 +98,9 @@ const setCurrentIndexFromProps = () => {
     }
 };
 
-// 计算轨道样式 - 完全按照 React 版本的逻辑
 const trackStyle = computed(() => {
     return {
-        transform: `translateX(calc((68.8px - 48vw) * ${currentIndex.value}))`
+        transform: `translateX(-${itemWidth.value * currentIndex.value}px)`
     };
 });
 
@@ -122,12 +130,23 @@ const currentDescription = computed(() => {
 const currentTitle = computed(() => {
     return originalMediaData.value[currentIndex.value]?.title || '';
 });
-// 页面加载时执行
 onMounted(() => {
-    console.log('ArtsDetail mounted - props.index:', props.index, 'props.dataSource.length:', props.dataSource?.length);
     initOriginalData();
     setCurrentIndexFromProps();
-    console.log('After setCurrentIndexFromProps - currentIndex.value:', currentIndex.value);
+    updateItemWidth();
+    if (carouselInnerRef.value) {
+        resizeObserver = new ResizeObserver(() => {
+            updateItemWidth();
+        });
+        resizeObserver.observe(carouselInnerRef.value);
+    }
+});
+
+onUnmounted(() => {
+    if (resizeObserver) {
+        resizeObserver.disconnect();
+        resizeObserver = null;
+    }
 });
 
 // 只监听 dataSource 变化，不监听 index 变化
@@ -196,10 +215,9 @@ watch(
                 transition: transform 0.3s ease-in-out;
 
                 .carousel-item {
-                    width: calc(48vw - 80.8px);
-                    flex: 0 0 calc(48vw - 80.8px);
+                    width: 100%;
+                    flex: 0 0 100%;
                     height: 100%;
-                    margin-right: 12px;
                     display: flex;
                     justify-content: center;
                     align-items: center;
diff --git a/frontend/src/components/gis/GisView.vue b/frontend/src/components/gis/GisView.vue
index 60ea9a73..57f2525f 100644
--- a/frontend/src/components/gis/GisView.vue
+++ b/frontend/src/components/gis/GisView.vue
@@ -32,8 +32,10 @@ import { useMapOrchestrator } from '@/modules/map/application/map-orchestrator';
 import { MapClass } from './map.class';
 import { getQgcRvcd } from '@/api/map';
 import { servers } from './mapurlManage';
+import { useUiStore } from '@/store/modules/ui';
 
 const mapOrchestrator = useMapOrchestrator();
+const uiStore = useUiStore();
 
 const route = useRoute();
 const mapClass = MapClass.getInstance();
@@ -82,7 +84,11 @@ const init = async () => {
 const handleMapController = async (e: any, mapType: any) => {
   switch (e) {
     case 'dim':
-      await mapClass.switchView(mapType);
+      await mapOrchestrator.switchMapType(mapType, {
+        popupContainer: popupRef.value,
+        getIsHydroMenu: () => isShuiDianKaiFaMenu.value
+      });
+      uiStore.markMapSwitchCompleted();
       break;
     case 4: // 梯级流域显示
       tlyLayerVisible.value = !tlyLayerVisible.value;
diff --git a/frontend/src/components/gis/gisUtils.ts b/frontend/src/components/gis/gisUtils.ts
index 1776cc85..2466a5fd 100644
--- a/frontend/src/components/gis/gisUtils.ts
+++ b/frontend/src/components/gis/gisUtils.ts
@@ -42,9 +42,6 @@ export const legendData2Obj = (data: any[]) => {
       if (item?.childrenList && item.childrenList?.length > 0) {
         f(item.childrenList);
       } else {
-        if (item.nameEn.includes('_测试')) {
-          item.nameEn = item.nameEn.split('_测试')[0];
-        }
         _tempData[item.nameEn] = item;
       }
     });
diff --git a/frontend/src/components/gis/map.cesium.ts b/frontend/src/components/gis/map.cesium.ts
index 684b4b85..afcf34a7 100644
--- a/frontend/src/components/gis/map.cesium.ts
+++ b/frontend/src/components/gis/map.cesium.ts
@@ -1,30 +1,99 @@
-// src/components/gis/map.cesium.ts
-import * as Cesium from 'cesium';
+import * as Cesium from 'cesium';
+import type { MDOptions } from './map.class';
 import type { MapInterface, layer } from './map.d';
-
-// ✅ 1. 全局配置 Cesium 静态资源路径 (vite-plugin-cesium 通常会自动处理，但显式指定更保险)
-// 注意：如果你使用了 vite-plugin-cesium，这一步通常不需要，但如果报错，可以尝试取消注释下面这行
-// Cesium.buildModuleUrl.setBaseUrl('/node_modules/cesium/Build/Cesium/');
+import { getIconPath } from '@/utils/index';
+import {
+  generatePopupHtml,
+  shouldPreferEng2Popup,
+  getNormalizedPopupSttpMap
+} from '@/utils/popupHtmlGenerator';
+import { useModelStore } from '@/store/modules/model';
+import { getNearbyPointDensityDisplayRules } from '@/modules/map/domain/nearby-point-rules';
 
 export class MapCesium implements MapInterface {
   private viewer: Cesium.Viewer | null = null;
+  private clickEventHandler: Cesium.ScreenSpaceEventHandler | null = null;
+  private popupElement: HTMLElement | null = null;
+  private hoveredEntityId: string | null = null;
+  private hoverRafId: number | null = null; // requestAnimationFrame 节流
+  private removePostRenderListener: (() => void) | null = null;
+  private removeCameraChangedListener: (() => void) | null = null;
+  private isBatchPopupMode = false;
+  private batchPopupContainer: HTMLDivElement | null = null;
+  private batchPopupItems: Array<{
+    entity: Cesium.Entity;
+    element: HTMLDivElement;
+    popupWidth: number;
+    popupHeight: number;
+  }> = [];
+  private batchPostRenderRemover: (() => void) | null = null;
   private containerId = '';
   private containerElement: HTMLElement | null = null;
   private loadingOverlayElement: HTMLDivElement | null = null;
   private loadingSpinnerAnimation: Animation | null = null;
   private flightFallbackTimer: number | null = null;
+  private imageryBaseLayer: Cesium.ImageryLayer | null = null;
+  private baseLayerRegistry = new Map<string, Cesium.ImageryLayer>();
+  private baseLayerAliasMap = new Map<string, string>();
+  private pointLayerRegistry = new Map<string, Cesium.Entity[]>();
+  private hydropBaseConfig: any = null;
+  private BASEID = '';
+  private currentClipGeoJson: any = null;
+  private clipRequestController: AbortController | null = null;
+  private maskPolygonEntities: Cesium.Entity[] = [];
+  private originalBgColor: Cesium.Color | null = null;
+  private skyBoxShown = true;
+  private skyAtmosphereShown = true;
+  private readonly IGNORED_BASE_LAYER_KEYS = new Set([
+    'powerBaseStation',
+    's_hydropBase_wfs'
+  ]);
+  private readonly PRIMARY_BASE_LAYER_KEYS = new Set([
+    'customBaseLayer',
+    's_province_boundaries',
+    'BASEMAP-white',
+    'BASEMAP-img'
+  ]);
 
-  private readonly CHINA_CENTER = {
-    lng: 114.5,
-    lat: 36.5
-  };
+  private readonly CHINA_CENTER = { lng: 104.5, lat: 36.5 };
   private readonly CHINA_BOOT_HEIGHT = 20000000;
-  private readonly CHINA_DEFAULT_HEIGHT = 12000000;
+  private readonly CHINA_DEFAULT_HEIGHT = 9000000;
   private readonly CHINA_VIEW_ORIENTATION = {
-    heading: Cesium.Math.toRadians(0),
+    heading: Cesium.Math.toRadians(-6),
     pitch: Cesium.Math.toRadians(-90),
     roll: 0
   };
+  private readonly CESIUM_ZOOM_FORMULA_A = 40487.57;
+  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 刚好踩边界）
+
+  // ==================== 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
+
+  // 图标缩放可调参数（只影响 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）
+
+  // 标签文字可调参数
+  // 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; // 多行偏移系数
+
+  // ==================== Step 1: 初始化 + 飞中国 ====================
 
   async init(container: HTMLElement, _rectangle?: any): Promise<any> {
     try {
@@ -44,31 +113,47 @@ export class MapCesium implements MapInterface {
         navigationHelpButton: false,
         infoBox: false,
         selectionIndicator: false,
-        shouldAnimate: true
+        shouldAnimate: true,
+        requestRenderMode: true,
+        targetFrameRate: 30,
+        terrainProvider: new Cesium.EllipsoidTerrainProvider()
       });
 
+      this.viewer.cesiumWidget.creditContainer.style.display = 'none';
       const layers = this.viewer.imageryLayers;
       layers.removeAll();
       const arcgisUrl =
         'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/';
 
-      const provider = await Cesium.ArcGisMapServerImageryProvider.fromUrl(
-        arcgisUrl,
-        {
-          enablePickFeatures: false,
-          maximumLevel: 19
-        }
-      );
-      layers.addImageryProvider(provider);
+      // const provider = await Cesium.ArcGisMapServerImageryProvider.fromUrl(
+      //   arcgisUrl,
+      //   {
+      //     enablePickFeatures: false,
+      //     maximumLevel: 19
+      //   }
+      // );
+      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'
+      });
+
+      this.imageryBaseLayer = layers.addImageryProvider(provider);
+      this.imageryBaseLayer.show = true;
 
       this.viewer.scene.globe.depthTestAgainstTerrain = false;
+      this.viewer.scene.globe.show = true;
+      this.viewer.scene.fog.enabled = false;
+      this.viewer.scene.fxaa = false;
       this.viewer.useBrowserRecommendedResolution = true;
 
-      // 先把相机直接摆到中国上空，避免初始化阶段短暂闪到美国默认视角。
-      this.setBootChinaView();
-      await this.waitForViewerReady();
       await this.flyToChina();
 
+      this.setupClickHandler();
+      this.setupCameraPopupReset();
+
+      console.log('[Cesium] init complete, viewer ready');
       return this.viewer;
     } catch (error) {
       this.hideLoadingOverlay();
@@ -77,31 +162,6 @@ export class MapCesium implements MapInterface {
     }
   }
 
-  private setBootChinaView() {
-    if (!this.viewer) return;
-
-    this.viewer.camera.cancelFlight();
-    this.viewer.camera.setView({
-      destination: Cesium.Cartesian3.fromDegrees(
-        this.CHINA_CENTER.lng,
-        this.CHINA_CENTER.lat,
-        this.CHINA_BOOT_HEIGHT
-      ),
-      orientation: this.CHINA_VIEW_ORIENTATION
-    });
-  }
-
-  private waitForViewerReady(): Promise<void> {
-    return new Promise(resolve => {
-      requestAnimationFrame(() => {
-        requestAnimationFrame(() => {
-          this.viewer?.scene.requestRender();
-          resolve();
-        });
-      });
-    });
-  }
-
   private flyToChina(): Promise<void> {
     return new Promise(resolve => {
       if (!this.viewer) {
@@ -110,34 +170,53 @@ export class MapCesium implements MapInterface {
         return;
       }
 
-      const finish = () => {
-        if (this.flightFallbackTimer !== null) {
-          window.clearTimeout(this.flightFallbackTimer);
-          this.flightFallbackTimer = null;
-        }
-        this.hideLoadingOverlay();
-        resolve();
-      };
-
+      // Step 1: 瞬跳至高空俯视中国
       this.viewer.camera.cancelFlight();
-      this.flightFallbackTimer = window.setTimeout(() => {
-        finish();
-      }, 2600);
-
-      this.viewer.camera.flyTo({
+      this.viewer.camera.setView({
         destination: Cesium.Cartesian3.fromDegrees(
           this.CHINA_CENTER.lng,
           this.CHINA_CENTER.lat,
-          this.CHINA_DEFAULT_HEIGHT
+          this.CHINA_BOOT_HEIGHT
         ),
-        orientation: this.CHINA_VIEW_ORIENTATION,
-        duration: 1.8,
-        complete: finish,
-        cancel: finish
+        orientation: this.CHINA_VIEW_ORIENTATION
+      });
+      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
+        });
       });
     });
   }
 
+  private clearFlightFallbackTimer() {
+    if (this.flightFallbackTimer !== null) {
+      window.clearTimeout(this.flightFallbackTimer);
+      this.flightFallbackTimer = null;
+    }
+  }
+
   private showLoadingOverlay(container: HTMLElement) {
     this.hideLoadingOverlay();
 
@@ -152,8 +231,8 @@ export class MapCesium implements MapInterface {
     overlay.style.gap = '12px';
     overlay.style.background =
       'linear-gradient(180deg, rgba(7, 20, 36, 0.72) 0%, rgba(7, 20, 36, 0.46) 100%)';
-    overlay.style.backdropFilter = 'blur(2px)';
     overlay.style.zIndex = '30';
+    overlay.style.backdropFilter = 'blur(2px)';
     overlay.style.pointerEvents = 'auto';
 
     const spinner = document.createElement('div');
@@ -164,11 +243,7 @@ export class MapCesium implements MapInterface {
     spinner.style.borderTopColor = '#ffffff';
     this.loadingSpinnerAnimation = spinner.animate(
       [{ transform: 'rotate(0deg)' }, { transform: 'rotate(360deg)' }],
-      {
-        duration: 900,
-        iterations: Infinity,
-        easing: 'linear'
-      }
+      { duration: 900, iterations: Infinity, easing: 'linear' }
     );
 
     const label = document.createElement('div');
@@ -198,25 +273,1109 @@ export class MapCesium implements MapInterface {
     this.loadingOverlayElement = null;
   }
 
-  destroy(): void {
-    if (this.flightFallbackTimer !== null) {
-      window.clearTimeout(this.flightFallbackTimer);
-      this.flightFallbackTimer = null;
+  // ==================== Step 7: 点击锚点打开详情弹框 ====================
+
+  private setupClickHandler() {
+    if (!this.viewer) return;
+    if (this.clickEventHandler) {
+      this.clickEventHandler.destroy();
     }
+
+    const modelStore = useModelStore();
+    const canvas = this.viewer.scene.canvas;
+    this.clickEventHandler = new Cesium.ScreenSpaceEventHandler(canvas);
+
+    // 默认箭头光标，与 2D 一致（不显示拖拽小手）
+    canvas.style.cursor = 'default';
+
+    // 鼠标移动：光标样式 + hover popup（rAF 节流，批量模式下只改光标）
+    let pendingMoveEvent: { endPosition: Cesium.Cartesian2 } | null = null;
+
+    this.clickEventHandler.setInputAction(
+      (move: { endPosition: Cesium.Cartesian2 }) => {
+        pendingMoveEvent = move;
+
+        if (this.hoverRafId !== null) return; // 已有待处理的帧，跳过
+        this.hoverRafId = requestAnimationFrame(() => {
+          this.hoverRafId = null;
+          const evt = pendingMoveEvent;
+          pendingMoveEvent = null;
+          if (!evt) return;
+
+          const scene = this.viewer?.scene;
+          if (!scene) return;
+
+          const cameraHeight = this.getCurrentCameraHeight();
+          // 缩放门槛：中国视角以上不触发 hover
+          if (cameraHeight > this.HOVER_POPUP_MAX_HEIGHT) {
+            canvas.style.cursor = 'default';
+            this.hidePopup();
+            return;
+          }
+
+          const picked = scene.pick(evt.endPosition);
+          const entity =
+            Cesium.defined(picked) && picked.id instanceof Cesium.Entity
+              ? (picked.id as Cesium.Entity)
+              : null;
+
+          // 检测是否命中可交互的锚点
+          if (entity && this.isEntityInteractive(entity)) {
+            canvas.style.cursor = 'pointer';
+
+            // 批量模式下单点 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);
+              }
+              return;
+            }
+
+            this.showPopupForEntity(entity);
+            return;
+          }
+
+          canvas.style.cursor = 'default';
+          // 批量模式下不隐藏批量 popup
+          if (!this.isBatchPopupMode) {
+            this.hidePopup();
+          }
+        });
+      },
+      Cesium.ScreenSpaceEventType.MOUSE_MOVE
+    );
+
+    // 点击：打开详情弹框
+    this.clickEventHandler.setInputAction(
+      (click: { position: Cesium.Cartesian2 }) => {
+        const scene = this.viewer?.scene;
+        if (!scene) return;
+
+        const picked = scene.pick(click.position);
+        if (!Cesium.defined(picked) || !picked.id) return;
+
+        const entity = picked.id as Cesium.Entity;
+        if (!this.isEntityInteractive(entity)) return;
+
+        const rawData: Record<string, any> = (entity as any)._rawData || {};
+
+        if (rawData.sttpMap === 'ylfb') {
+          modelStore.ylfbModalVisible = true;
+          modelStore.params = rawData;
+        } else {
+          modelStore.modalVisible = true;
+          modelStore.params = rawData;
+          modelStore.title = rawData.titleName || rawData.stnm;
+        }
+      },
+      Cesium.ScreenSpaceEventType.LEFT_CLICK
+    );
+  }
+
+  // ==================== Step 5: hover popup + 批量 popup ====================
+
+  /** 监听相机移动结束：检测缩放阈值切换批量模式 */
+  private setupCameraPopupReset() {
+    if (!this.viewer) return;
+
+    if (this.removePostRenderListener) {
+      this.removePostRenderListener();
+      this.removePostRenderListener = null;
+    }
+    if (this.removeCameraChangedListener) {
+      this.removeCameraChangedListener();
+      this.removeCameraChangedListener = null;
+    }
+
+    // camera.changed：相机运动中实时刷新碰撞检测（debounce 150ms）
+    this.removeCameraChangedListener =
+      this.viewer.camera.changed.addEventListener(() => {
+        this.requestRefreshPointLabelVisibility(false, 150);
+      });
+
+    this.removePostRenderListener = this.viewer.camera.moveEnd.addEventListener(
+      () => {
+        const zoom = this.getZoomLevelFromCameraHeight(
+          this.getCurrentCameraHeight()
+        );
+
+        if (zoom >= this.BATCH_POPUP_MODE_ZOOM) {
+          if (!this.isBatchPopupMode) {
+            this.enableBatchPopupMode();
+          } else {
+            // 已处于批量模式：重建 popup（与 2D moveend 行为对齐）
+            // 拖拽/平移后视口内可能出现新的可见锚点，仅 postRender 重定位无法创建新 popup
+            // 同时修复 zoom 进出循环后 popup 消失的问题
+            this.rebuildBatchPopupsIfNeeded();
+          }
+        } else {
+          if (this.isBatchPopupMode) {
+            this.disableBatchPopupMode();
+          }
+          // hover popup 重定位而非隐藏，避免缩放结束后闪烁
+          if (this.hoveredEntityId) {
+            this.repositionHoverPopup();
+          }
+        }
+
+        // Step 6: 碰撞检测 — 相机停止移动后重新计算图标/标签可见性
+        this.requestRefreshPointLabelVisibility();
+      }
+    );
+  }
+
+  /** 根据 hoveredEntityId 重定位 popup（相机移动后调用，不重建内容） */
+  private repositionHoverPopup(): void {
+    if (!this.viewer || !this.popupElement || !this.hoveredEntityId) return;
+    const entity = this.viewer.entities.getById(this.hoveredEntityId);
+    if (!entity || !entity.position) {
+      this.hidePopup();
+      return;
+    }
+    const position = entity.position.getValue(this.viewer.clock.currentTime);
+    if (!position) {
+      this.hidePopup();
+      return;
+    }
+    this.updatePopupPosition(position);
+  }
+
+  /** 批量模式下每帧更新 popup 位置，实现流畅跟随拖拽 */
+  private setupBatchPopupPostRenderSync() {
+    if (!this.viewer || this.batchPostRenderRemover) return;
+    this.batchPostRenderRemover = this.viewer.scene.postRender.addEventListener(
+      () => {
+        if (!this.isBatchPopupMode) return;
+        this.updateBatchPopupPositions();
+      }
+    );
+  }
+
+  /** 停止每帧同步 */
+  private clearBatchPopupPostRenderSync() {
+    if (this.batchPostRenderRemover) {
+      this.batchPostRenderRemover();
+      this.batchPostRenderRemover = null;
+    }
+  }
+
+  /** 获取当前相机高度（米） */
+  private getCurrentCameraHeight(): number {
+    if (!this.viewer) return Number.POSITIVE_INFINITY;
+    const height = this.viewer.camera.positionCartographic.height;
+    if (!height || !isFinite(height) || height <= 0) {
+      return Number.POSITIVE_INFINITY;
+    }
+    return height;
+  }
+
+  /** 将相机高度映射为近似 2D zoom 级别（与 getCurrentCesiumZoom 同公式） */
+  private getZoomLevelFromCameraHeight(height: number): number {
+    const zoom =
+      this.CESIUM_ZOOM_FORMULA_D +
+      (this.CESIUM_ZOOM_FORMULA_A - this.CESIUM_ZOOM_FORMULA_D) /
+        (1 +
+          Math.pow(
+            height / this.CESIUM_ZOOM_FORMULA_C,
+            this.CESIUM_ZOOM_FORMULA_B
+          )) +
+      1;
+    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;
+    if (e._layerVisible === false) return false;
+    if (e._legendVisible === false) return false;
+    if (e._regionVisible === false) return false;
+    if (entity.show === false) return false;
+    return true;
+  }
+
+  /** 根据实体属性生成 popup HTML，复用 generatePopupHtml */
+  private getPopupHtml(rawData: Record<string, any>): string {
+    return rawData.popupHtml || generatePopupHtml(rawData) || '';
+  }
+
+  /** 关闭单个 hover popup */
+  private hidePopup(): void {
+    this.hoveredEntityId = null;
+    if (!this.popupElement) return;
+    this.popupElement.style.display = 'none';
+    this.popupElement.innerHTML = '';
+  }
+
+  /** 根据实体世界坐标把 popup 定位到屏幕坐标 */
+  private updatePopupPosition(position: Cesium.Cartesian3): void {
+    if (!this.viewer || !this.popupElement) return;
+
+    const canvasPosition = Cesium.SceneTransforms.worldToWindowCoordinates(
+      this.viewer.scene,
+      position
+    );
+
+    if (!canvasPosition) {
+      this.hidePopup();
+      return;
+    }
+
+    this.popupElement.style.left = `${canvasPosition.x}px`;
+    this.popupElement.style.top = `${canvasPosition.y}px`;
+    this.popupElement.style.display = 'block';
+  }
+
+  /** 读取实体原始数据并渲染 hover popup */
+  private showPopupForEntity(entity: Cesium.Entity): void {
+    if (!this.viewer || !this.popupElement || !entity.position) return;
+
+    const rawData: Record<string, any> = {
+      ...((entity as any)._rawData || {})
+    };
+    if (!rawData.sttpMap) {
+      rawData.sttpMap = rawData._sttpMap || rawData.popupSttpMap || '';
+    }
+    const popupHtml = this.getPopupHtml(rawData);
+    const position = entity.position.getValue(this.viewer.clock.currentTime);
+
+    if (!popupHtml || !position) {
+      this.hidePopup();
+      return;
+    }
+
+    this.popupElement.innerHTML = popupHtml;
+    this.hoveredEntityId = entity.id;
+    this.updatePopupPosition(position);
+  }
+
+  // ==================== 批量 popup ====================
+
+  /** 启用批量 popup：所有可见锚点固定显示 popup */
+  private enableBatchPopupMode() {
+    console.log('[Cesium] enableBatchPopupMode');
+    this.isBatchPopupMode = true;
+    this.clearBatchPopups();
+    this.hidePopup(); // 清除可能残留的 hover popup
+    // 先同步执行碰撞检测，确保 _iconCollisionVisible 已正确计算，
+    // 避免重叠锚点的 popup 在 showBatchPopups 中被短暂创建
+    this.refreshPointLabelVisibility();
+    // 等所有 chunk 处理完再注册 postRender，避免用不完整列表做碰撞
+    this.showBatchPopups().then(() => {
+      if (this.isBatchPopupMode) {
+        this.setupBatchPopupPostRenderSync();
+      }
+    });
+  }
+
+  /** 退出批量 popup */
+  private disableBatchPopupMode() {
+    console.log('[Cesium] disableBatchPopupMode');
+    this.isBatchPopupMode = false;
+    this.clearBatchPopupPostRenderSync();
+    this.clearBatchPopups();
+    this.hidePopup();
+  }
+
+  /** 收集视口内可交互实体并按 X 坐标排序（ENG 优先） */
+  private collectBatchPopupCandidates(): Array<{
+    entity: Cesium.Entity;
+    x: number;
+    y: number;
+    popupHtml: string;
+  }> {
+    if (!this.viewer) return [];
+
+    const canvas = this.viewer.scene.canvas;
+    const viewW = canvas.clientWidth;
+    const viewH = canvas.clientHeight;
+    const padding = 60;
+
+    const candidates: Array<{
+      entity: Cesium.Entity;
+      x: number;
+      y: number;
+      popupHtml: string;
+    }> = [];
+
+    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;
+
+        const cp = Cesium.SceneTransforms.worldToWindowCoordinates(
+          this.viewer!.scene,
+          position
+        );
+        if (!cp) return;
+
+        if (
+          cp.x < -padding ||
+          cp.y < -padding ||
+          cp.x > viewW + padding ||
+          cp.y > viewH + padding
+        )
+          return;
+
+        const rawData: Record<string, any> = {
+          ...((entity as any)._rawData || {})
+        };
+        if (!rawData.sttpMap) {
+          rawData.sttpMap = rawData._sttpMap || rawData.popupSttpMap || '';
+        }
+
+        let popupHtml = shouldPreferEng2Popup(rawData)
+          ? generatePopupHtml(rawData, { forceEng2: true }) ||
+            rawData.popupHtml ||
+            generatePopupHtml(rawData)
+          : this.getPopupHtml(rawData);
+
+        if (!popupHtml) {
+          const title = rawData.titleName || rawData.stnm || rawData.ennm || '';
+          if (!title) return;
+          popupHtml = `<div class="map-popup-item"><div class="iconDivTitle">${title}</div></div>`;
+        }
+
+        candidates.push({ entity, x: cp.x, y: cp.y, popupHtml });
+      });
+    });
+
+    // 按 X 坐标排序，X 接近时（5px 容差，3D 投影浮点误差）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;
+    });
+
+    return candidates;
+  }
+
+  /** 在指定容器中分帧构建 popup DOM（避免卡顿），完成后 resolve */
+  private buildBatchPopupsInContainer(
+    container: HTMLDivElement,
+    candidates: Array<{
+      entity: Cesium.Entity;
+      x: number;
+      y: number;
+      popupHtml: string;
+    }>
+  ): Promise<void> {
+    return new Promise(resolve => {
+      let index = 0;
+      const CHUNK_SIZE = 80;
+      const placedPopups: Array<{
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        entity: Cesium.Entity;
+        element: HTMLDivElement;
+      }> = [];
+
+      const processChunk = () => {
+        if (!this.isBatchPopupMode) return;
+
+        const end = Math.min(index + CHUNK_SIZE, candidates.length);
+        for (let i = index; i < end; i++) {
+          const { entity, x, y, popupHtml } = candidates[i];
+
+          const popupEl = document.createElement('div');
+          popupEl.className =
+            this.popupElement?.className || 'map-popup-container';
+          popupEl.innerHTML = popupHtml;
+          popupEl.style.position = 'absolute';
+          popupEl.style.display = 'block';
+          popupEl.style.transform = 'translate(-50%, calc(-100% - 10px))';
+          popupEl.style.pointerEvents = 'none';
+
+          // 先隐藏测量尺寸
+          popupEl.style.visibility = 'hidden';
+          popupEl.style.left = `${x}px`;
+          popupEl.style.top = `${y}px`;
+          container.appendChild(popupEl);
+
+          const rect = popupEl.getBoundingClientRect();
+          const pw = rect.width || 120;
+          const ph = rect.height || 40;
+
+          const popupRect = {
+            left: x - pw / 2,
+            right: x + pw / 2,
+            top: y - 10 - ph,
+            bottom: y - 10
+          };
+
+          const isCurrentEng = this.isEngEntity(entity);
+          let collidedIdx = -1;
+
+          for (let k = 0; k < placedPopups.length; k++) {
+            if (this.checkPopupCollision(popupRect, placedPopups[k])) {
+              collidedIdx = k;
+              break;
+            }
+          }
+
+          if (collidedIdx === -1) {
+            // 无碰撞：正常放置
+            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.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);
+            }
+          }
+        }
+
+        index = end;
+        if (index < candidates.length && this.isBatchPopupMode) {
+          requestAnimationFrame(processChunk);
+        } else {
+          resolve();
+        }
+      };
+
+      requestAnimationFrame(processChunk);
+    });
+  }
+
+  /** 创建批量 popup 容器并构建所有可见 popup */
+  private showBatchPopups(): Promise<void> {
+    if (!this.viewer || !this.containerElement) return Promise.resolve();
+
+    const batchContainer = document.createElement('div');
+    batchContainer.className = 'batch-popup-container';
+    batchContainer.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 1000;
+    `;
+    batchContainer.id = 'batch-popup-container';
+    this.batchPopupContainer = batchContainer;
+    this.containerElement.appendChild(batchContainer);
+
+    const candidates = this.collectBatchPopupCandidates();
+    return this.buildBatchPopupsInContainer(batchContainer, candidates);
+  }
+
+  /** 每一帧都在更新，不需要持久化，但清理时一并重置 */
+  private popupCollisionFrames = new WeakMap<HTMLDivElement, number>();
+
+  /** 每帧更新批量 popup 屏幕位置 + 碰撞检测（拖拽/缩放时流畅跟随） */
+  private updateBatchPopupPositions() {
+    if (!this.viewer || !this.batchPopupContainer) return;
+    if (this.batchPopupItems.length === 0) return;
+
+    const canvas = this.viewer.scene.canvas;
+    const viewW = canvas.clientWidth;
+    const viewH = canvas.clientHeight;
+    const padding = 48;
+
+    // 第一遍：更新位置、收集可见项的屏幕矩形（用缓存宽高，不依赖 DOM 测量）
+    const visibleRects: {
+      item: (typeof this.batchPopupItems)[number];
+      x: number;
+      y: number;
+      left: number;
+      right: number;
+      top: number;
+      bottom: number;
+    }[] = [];
+
+    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';
+
+      if (!this.isEntityInteractive(entity)) {
+        element.style.display = 'none';
+        continue;
+      }
+
+      // 图标被碰撞隐藏的锚点不展示 popup
+      if ((entity as any)._iconCollisionVisible === false) {
+        element.style.display = 'none';
+        continue;
+      }
+
+      const position = entity.position?.getValue(
+        this.viewer!.clock.currentTime
+      );
+      if (!position) {
+        element.style.display = 'none';
+        continue;
+      }
+
+      const cp = Cesium.SceneTransforms.worldToWindowCoordinates(
+        this.viewer!.scene,
+        position
+      );
+      if (!cp) {
+        element.style.display = 'none';
+        continue;
+      }
+
+      if (
+        cp.x < -padding ||
+        cp.y < -padding ||
+        cp.x > viewW + padding ||
+        cp.y > viewH + padding
+      ) {
+        element.style.display = 'none';
+        continue;
+      }
+
+      const x = cp.x;
+      const y = cp.y;
+      element.style.left = `${x}px`;
+      element.style.top = `${y}px`;
+
+      visibleRects.push({
+        item,
+        x,
+        y,
+        left: x - popupWidth / 2,
+        right: x + popupWidth / 2,
+        top: y - 10 - popupHeight,
+        bottom: y - 10
+      });
+    }
+
+    // 第二遍：碰撞检测 — 按 X 排序后右让左，X 接近时（5px 容差）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;
+    });
+
+    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++) {
+        if (collisionFlags[j]) continue;
+        const b = visibleRects[j];
+
+        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;
+        }
+      }
+    }
+
+    // 第三遍：应用显示状态，ENG 碰撞立即隐藏，同类型 2 帧滞后防闪烁
+    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';
+        }
+      } else {
+        const count = prevFrames < 0 ? prevFrames - 1 : -1;
+        this.popupCollisionFrames.set(element, count);
+        if (count <= -2) {
+          element.style.display = 'block';
+        }
+      }
+    }
+  }
+
+  /** 批量模式下双缓冲重建 popup（图层/图例变化、拖拽/缩放 moveEnd 时调用）。
+   * 在新隐藏容器中构建 popup，构建完成后替换旧容器，避免 clear→rebuild 空白帧闪烁。 */
+  private _rebuildGeneration = 0;
+
+  private rebuildBatchPopupsIfNeeded() {
+    if (!this.isBatchPopupMode || !this.containerElement) return;
+
+    console.log(
+      '[Cesium] rebuildBatchPopups gen=%d',
+      this._rebuildGeneration + 1
+    );
+
+    // 停止旧容器的 postRender 同步（旧 popup 在新容器就绪前保持显示）
+    this.clearBatchPopupPostRenderSync();
+
+    const oldContainer = this.batchPopupContainer;
+    const generation = ++this._rebuildGeneration;
+
+    // 在隐藏容器中构建新 popup（尚未插入 DOM）
+    const newContainer = document.createElement('div');
+    newContainer.className = 'batch-popup-container';
+    newContainer.style.cssText =
+      '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();
+
+    const candidates = this.collectBatchPopupCandidates();
+    this.buildBatchPopupsInContainer(newContainer, candidates).then(() => {
+      // 如果期间触发了新的重建，丢弃本次结果
+      if (generation !== this._rebuildGeneration) {
+        newContainer.remove();
+        return;
+      }
+      if (!this.isBatchPopupMode) {
+        newContainer.remove();
+        return;
+      }
+      // 双缓冲替换：移除旧容器 → 插入新容器 → 注册 postRender
+      if (oldContainer) oldContainer.remove();
+      this.containerElement!.appendChild(newContainer);
+      this.setupBatchPopupPostRenderSync();
+    });
+  }
+
+  /** 清除所有批量 popup */
+  private clearBatchPopups() {
+    this.batchPopupItems = [];
+    this.popupCollisionFrames = new WeakMap<HTMLDivElement, number>();
+    if (this.batchPopupContainer) {
+      this.batchPopupContainer.remove();
+      this.batchPopupContainer = null;
+      return;
+    }
+    const existing = document.getElementById('batch-popup-container');
+    if (existing) {
+      existing.remove();
+    }
+  }
+
+  /** 简单碰撞检测（AABB + padding） */
+  private checkPopupCollision(
+    a: { left: number; right: number; top: number; bottom: number },
+    b: { left: number; right: number; top: number; bottom: number }
+  ): boolean {
+    const padding = 4;
+    return !(
+      a.right + padding < b.left ||
+      a.left - padding > b.right ||
+      a.bottom + padding < b.top ||
+      a.top - padding > b.bottom
+    );
+  }
+
+  // ==================== destroy ====================
+
+  destroy(): void {
+    // 取消飞行超时和加载动画
+    this.clearFlightFallbackTimer();
     this.hideLoadingOverlay();
+
+    // 批量 popup 和 hover popup
+    this.isBatchPopupMode = false;
+    this.clearBatchPopupPostRenderSync();
+    this.clearBatchPopups();
+    this.hidePopup();
+
+    // hover 节流 requestAnimationFrame
+    if (this.hoverRafId !== null) {
+      cancelAnimationFrame(this.hoverRafId);
+      this.hoverRafId = null;
+    }
+
+    // 相机事件监听
+    if (this.removePostRenderListener) {
+      this.removePostRenderListener();
+      this.removePostRenderListener = null;
+    }
+    if (this.removeCameraChangedListener) {
+      this.removeCameraChangedListener();
+      this.removeCameraChangedListener = null;
+    }
+
+    // 碰撞检测 rAF / 定时器
+    if (this.collisionRefreshFrameId !== null) {
+      cancelAnimationFrame(this.collisionRefreshFrameId);
+      this.collisionRefreshFrameId = null;
+    }
+    if (this.labelVisibilityDebounceTimerId !== null) {
+      window.clearTimeout(this.labelVisibilityDebounceTimerId);
+      this.labelVisibilityDebounceTimerId = null;
+    }
+
+    // 中止进行中的基地裁切请求
+    if (this.clipRequestController) {
+      this.clipRequestController.abort();
+      this.clipRequestController = null;
+    }
+
+    // 清理遮罩多边形 Entity（需在 viewer.destroy 前清除）
+    if (this.viewer && !this.viewer.isDestroyed()) {
+      this.maskPolygonEntities.forEach(entity => {
+        this.viewer!.entities.remove(entity);
+      });
+    }
+    this.maskPolygonEntities = [];
+
+    // 清理锚点图层和底图注册表
+    this.destroyAllPointLayers();
+    this.pointLayerRegistry.clear();
+    this.baseLayerRegistry.clear();
+    this.baseLayerAliasMap.clear();
+    this.imageryBaseLayer = null;
+
+    // 清理 Cesium 事件处理器
+    if (this.clickEventHandler) {
+      this.clickEventHandler.destroy();
+      this.clickEventHandler = null;
+    }
+    this.popupElement = null;
+
+    // 销毁 Cesium Viewer
     if (this.viewer) {
+      this._rebuildGeneration++; // 中止进行中的双缓冲重建
       this.viewer.camera.cancelFlight();
       this.viewer.destroy();
       this.viewer = null;
     }
     this.containerElement = null;
+
+    // 重置所有状态变量（确保下次 init 时是干净状态）
+    this.popupCollisionFrames = new WeakMap();
+    this.currentClipGeoJson = null;
+    this.originalBgColor = null;
+    this.skyBoxShown = true;
+    this.skyAtmosphereShown = true;
+    this.hydropBaseConfig = null;
+    this.BASEID = '';
+    this.hoveredEntityId = null;
+
+    console.log('[Cesium] destroyed');
   }
 
+  private requestRender() {
+    this.viewer?.scene.requestRender();
+  }
+
+  /**
+   * 标签文本格式化：与 2D formatPointLabelText 完全对齐
+   * - 去除括号 ()（）
+   * - 每行最多 12 个字符
+   * - 13~24 字符 → 拆成两行
+   * - 超过 24 字符 → 第二行末尾用 "..." 截断
+   */
+  private formatPointLabelText(text: string): string {
+    const normalizedText = String(text || '')
+      .replace(/[()（）]/g, '')
+      .trim();
+    if (!normalizedText) {
+      return '';
+    }
+
+    const maxLineLength = 12;
+    if (normalizedText.length <= maxLineLength) {
+      return normalizedText;
+    }
+
+    const firstLine = normalizedText.slice(0, maxLineLength);
+    if (normalizedText.length <= maxLineLength * 2) {
+      return `${firstLine}\n${normalizedText.slice(maxLineLength)}`;
+    }
+
+    const secondLine = `${normalizedText.slice(
+      maxLineLength,
+      maxLineLength + 9
+    )}...`;
+    return `${firstLine}\n${secondLine}`;
+  }
+
+  // ==================== Step 2: 基础底图 ====================
+
+  private getRegistryKeys(layerConfig: any): string[] {
+    const keys = [layerConfig?.key, layerConfig?.id].filter(
+      (key): key is string => typeof key === 'string' && key.length > 0
+    );
+    return Array.from(new Set(keys));
+  }
+
+  private resolvePrimaryBaseLayerKey(layerKey: string): string | undefined {
+    if (!layerKey) return undefined;
+    if (this.baseLayerRegistry.has(layerKey)) return layerKey;
+    return this.baseLayerAliasMap.get(layerKey);
+  }
+
+  private unregisterBaseLayer(layerConfig: any) {
+    if (!this.viewer) return;
+    const registryKeys = this.getRegistryKeys(layerConfig);
+    const uniquePrimaryKeys = new Set<string>();
+
+    registryKeys.forEach(key => {
+      const primaryKey = this.resolvePrimaryBaseLayerKey(key) || key;
+      uniquePrimaryKeys.add(primaryKey);
+      this.baseLayerAliasMap.delete(key);
+    });
+
+    uniquePrimaryKeys.forEach(primaryKey => {
+      const existingLayer = this.baseLayerRegistry.get(primaryKey);
+      if (existingLayer) {
+        this.viewer?.imageryLayers.remove(existingLayer, true);
+        this.baseLayerRegistry.delete(primaryKey);
+      }
+    });
+  }
+
+  private registerBaseLayer(
+    layerConfig: any,
+    imageryLayer: Cesium.ImageryLayer
+  ) {
+    const registryKeys = this.getRegistryKeys(layerConfig);
+    const primaryKey = layerConfig?.key || layerConfig?.id;
+    if (!primaryKey) return;
+
+    this.baseLayerRegistry.set(primaryKey, imageryLayer);
+    registryKeys.forEach(key => {
+      this.baseLayerAliasMap.set(key, primaryKey);
+    });
+  }
+
+  private getLayerRequestUrl(layerConfig: any): string {
+    if (layerConfig?.key === 'customBaseLayer') {
+      return layerConfig?.url_3d;
+    }
+    return layerConfig?.url || layerConfig?.url_3d || '';
+  }
+
+  private createImageryLayer(layerConfig: any, visible: boolean) {
+    if (layerConfig?.key === 'hydropBase') return null;
+    if (!this.viewer) return null;
+
+    const url = this.getLayerRequestUrl(layerConfig);
+    if (!url) return null;
+
+    let imageryLayer: Cesium.ImageryLayer | null = null;
+
+    // WMTS：与 2D addBaseDataLayer 对齐，从 URL 参数中提取 LAYER / TILEMATRIXSET
+    // 必须提供 tileMatrixLabels，否则 Cesium 默认用纯数字 tileMatrix 值，
+    // 而服务器期望的是 "TileMatrixSet:zoom" 格式（如 EPSG:3857_hbb_zrbhq_l13:4）
+    if (layerConfig?.type === 'wmts') {
+      const urlParts = url.split('?');
+      const baseUrl = urlParts[0];
+      const urlParams = new URLSearchParams(urlParts[1] || '');
+      const wmtsLayer = urlParams.get('LAYER') || urlParams.get('layer') || '';
+      const tileMatrixSetID =
+        urlParams.get('TILEMATRIXSET') || urlParams.get('TileMatrixSet') || '';
+      const maxLevel = 19;
+      const tileMatrixLabels = Array.from(
+        { length: maxLevel + 1 },
+        (_, i) => `${tileMatrixSetID}:${i}`
+      );
+
+      imageryLayer = this.viewer.imageryLayers.addImageryProvider(
+        new Cesium.WebMapTileServiceImageryProvider({
+          url: baseUrl,
+          layer: wmtsLayer,
+          style: 'raster',
+          format: 'image/png',
+          tileMatrixSetID: tileMatrixSetID,
+          tileMatrixLabels: tileMatrixLabels,
+          maximumLevel: maxLevel
+        })
+      );
+    } else if (
+      layerConfig?.type === 'raster-dem' ||
+      /\{x\}|\{y\}|\{z\}/.test(url)
+    ) {
+      imageryLayer = this.viewer.imageryLayers.addImageryProvider(
+        new Cesium.UrlTemplateImageryProvider({ url })
+      );
+    } else if (url.includes('MapServer')) {
+      imageryLayer = this.viewer.imageryLayers.add(
+        Cesium.ImageryLayer.fromProviderAsync(
+          Cesium.ArcGisMapServerImageryProvider.fromUrl(url, {
+            enablePickFeatures: false,
+            maximumLevel: 19
+          })
+        )
+      );
+    } else {
+      const cleanUrl = url.split('?')[0];
+      const wmsLayers = layerConfig?.layers || '';
+      imageryLayer = this.viewer.imageryLayers.addImageryProvider(
+        new Cesium.WebMapServiceImageryProvider({
+          url: cleanUrl,
+          layers: wmsLayers,
+          parameters: {
+            service: 'WMS',
+            transparent: 'true',
+            format: 'image/png'
+          }
+        })
+      );
+    }
+
+    if (!imageryLayer) return null;
+
+    imageryLayer.show = visible;
+    if (typeof layerConfig?.rasteropacity === 'number') {
+      imageryLayer.alpha = layerConfig.rasteropacity;
+    }
+    return imageryLayer;
+  }
+
+  addBaseDataLayer(layerConfig: any, isShow = true): void {
+    if (!this.viewer || !layerConfig?.key) return;
+
+    // 基地裁切配置存储（与 2D 对齐：layer.type === 'vector' && layer.key === 'hydropBase'）
+    if (layerConfig.type === 'vector' && layerConfig.key === 'hydropBase') {
+      this.hydropBaseConfig = layerConfig;
+      return;
+    }
+
+    if (
+      this.IGNORED_BASE_LAYER_KEYS.has(layerConfig.key) ||
+      this.IGNORED_BASE_LAYER_KEYS.has(layerConfig.id)
+    ) {
+      return;
+    }
+
+    if (layerConfig.key === 'BASEMAP-img') {
+      if (this.imageryBaseLayer) {
+        this.imageryBaseLayer.show = !!isShow;
+      }
+      this.requestRender();
+      return;
+    }
+
+    const imageryLayer = this.createImageryLayer(layerConfig, !!isShow);
+    if (!imageryLayer) return;
+
+    this.unregisterBaseLayer(layerConfig);
+    this.registerBaseLayer(layerConfig, imageryLayer);
+    this.requestRender();
+  }
+
+  controlBaseLayerTreeShowAndHidden(
+    layerType: string,
+    key: string,
+    checked: boolean
+  ): void {
+    const targetKey = key || layerType;
+    if (targetKey === 'BASEMAP-img') {
+      if (this.imageryBaseLayer) {
+        this.imageryBaseLayer.show = checked;
+      }
+      return;
+    }
+
+    const primaryKey = this.resolvePrimaryBaseLayerKey(targetKey);
+    if (!primaryKey) return;
+
+    const imageryLayer = this.baseLayerRegistry.get(primaryKey);
+    if (!imageryLayer) return;
+
+    imageryLayer.show = checked;
+    this.requestRender();
+  }
+
+  hasBaseLayer(layerKey: string): boolean {
+    if (layerKey === 'BASEMAP-img') return !!this.imageryBaseLayer;
+    return !!this.resolvePrimaryBaseLayerKey(layerKey);
+  }
+
+  // ==================== 其他公共方法 ====================
+
   flyTopanto(position: number[], zoom: number): void {
     if (!this.viewer || !position) return;
     const [lng, lat] = position;
     const height = 20000000 / Math.pow(2, zoom);
-
     this.viewer.camera.cancelFlight();
     this.viewer.camera.flyTo({
       destination: Cesium.Cartesian3.fromDegrees(
@@ -228,35 +1387,293 @@ export class MapCesium implements MapInterface {
     });
   }
 
-  // ... 其他空实现方法保持不变 ...
-  jdPanelControlShowAndHidden(_baseid: string, _isAll: boolean): void {}
-  mdLayerShowOrHidden(): void {}
-  addBaseDataLayer(_layer: any): void {}
-  controlBaseLayerTreeShowAndHidden(
-    _layerType: string,
-    _key: string,
-    _checked: boolean
-  ): void {}
-  mdLayerTreeShowOrHidden(_layerType: string, _checked?: boolean): void {}
-  hasLayer(_layerKey: string): boolean {
-    return false;
+  getCurrentZoom(): number | undefined {
+    return this.getCurrentCesiumZoom();
   }
-  hasBaseLayer(_layerKey: string): boolean {
-    return false;
+
+  private getCurrentCesiumZoom() {
+    if (!this.viewer) return undefined;
+    const height = this.viewer.camera.positionCartographic.height;
+    if (!height || !isFinite(height) || height <= 0) return undefined;
+    const zoom =
+      this.CESIUM_ZOOM_FORMULA_D +
+      (this.CESIUM_ZOOM_FORMULA_A - this.CESIUM_ZOOM_FORMULA_D) /
+        (1 +
+          Math.pow(
+            Number(height) / this.CESIUM_ZOOM_FORMULA_C,
+            this.CESIUM_ZOOM_FORMULA_B
+          )) +
+      1;
+    return zoom > -1 ? zoom : 0;
   }
-  setLegendPointVisible(
-    _layerKey: string,
-    _anchoPointState: string,
-    _checked: boolean
-  ): void {}
+
+  zoomToggle(type: 'out' | 'in'): void {
+    if (!this.viewer) return;
+    const factor = 1.5;
+    if (type === 'in') this.viewer.camera.zoomIn(factor);
+    else this.viewer.camera.zoomOut(factor);
+  }
+
+  mapOutPut(fileName = '3D_截图.png'): void {
+    if (!this.viewer) {
+      console.warn('Viewer is not initialized.');
+      return;
+    }
+    try {
+      const canvas = this.viewer.canvas;
+      this.viewer.render();
+      const dataURL = canvas.toDataURL('image/png');
+      if (dataURL.length < 100) {
+        console.warn(
+          'Canvas data is too small, likely black or empty. Check CORS settings.'
+        );
+      }
+      const link = document.createElement('a');
+      link.href = dataURL;
+      link.download = fileName;
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+    } catch (error) {
+      console.error('Failed to export map image:', error);
+    }
+  }
+
+  initPopupOverlay(popupContainer: HTMLDivElement): void {
+    this.popupElement = popupContainer;
+    if (this.popupElement) {
+      // 清除可能残留的旧样式
+      this.popupElement.style.removeProperty('position');
+      this.popupElement.style.removeProperty('transform');
+      this.popupElement.style.removeProperty('left');
+      this.popupElement.style.removeProperty('top');
+      this.popupElement.style.display = 'none';
+      this.popupElement.style.position = 'absolute';
+      this.popupElement.style.transform = 'translate(-50%, calc(-100% - 10px))';
+      this.popupElement.style.setProperty(
+        'pointer-events',
+        'none',
+        'important'
+      );
+    }
+  }
+
+  // ==================== Step 3: 锚点展示 ====================
+
   addInitDataLayer(
-    _pointData: any[],
-    _layerType: any,
-    _mdoptions?: any
-  ): void {}
-  switchView(_type: any): void {}
-  fitBounds(_bounds: any): void {}
+    pointData: any,
+    layerType: any,
+    _mdoptions?: MDOptions
+  ): void {
+    if (!this.viewer) return;
+
+    let dataArray: any[] = [];
+    let targetLayerKey = layerType;
+
+    // 与 2D PointLayerManager.addDataLayer 对齐的输入归一化
+    if (Array.isArray(pointData)) {
+      dataArray = pointData;
+    } else {
+      dataArray = pointData?.data || [];
+      targetLayerKey = pointData?.key || layerType;
+    }
+
+    if (!targetLayerKey) {
+      console.warn('[Cesium] 缺少图层 Key，无法加载锚点');
+      return;
+    }
+
+    // 先移除旧图层数据
+    this.removePointLayer(targetLayerKey);
+
+    const entities: Cesium.Entity[] = [];
+
+    dataArray.forEach((item: any) => {
+      const { lgtd, lttd, stnm, iconCode, titleName, ennm } = item;
+
+      if (lgtd == null || lttd == null) return;
+
+      const lon = Number(lgtd);
+      const lat = Number(lttd);
+      if (isNaN(lon) || isNaN(lat) || !isFinite(lon) || !isFinite(lat)) return;
+      if (Math.abs(lon) > 180 || Math.abs(lat) > 90) return;
+
+      // 图标：复用现有图标资源路径，与 2D 一致
+      const iconUrl = iconCode
+        ? getIconPath(iconCode)
+        : getIconPath('default') || '';
+
+      // 标签文本：格式化（换行截断）+ ylfb 用 ftp，其他用 titleName > stnm > ennm
+      const rawLabelText =
+        item.sttpMap === 'ylfb'
+          ? item.ftp || ''
+          : titleName || stnm || ennm || '';
+      const labelText = this.formatPointLabelText(rawLabelText);
+      // 行数决定纵向偏移量，与 2D getPointLabelRenderOffsetY 对齐
+      const labelLineCount = labelText.includes('\n') ? 2 : labelText ? 1 : 0;
+
+      // Entity ID：与 2D 对齐，使用 _id 优先（_id = sttpMap_stcd），确保同 stcd 不同 sttpMap 的点不互相覆盖
+      const rawId =
+        item._id || item.stcd || `${lon.toFixed(6)},${lat.toFixed(6)}`;
+      const entityId = `${targetLayerKey}:${rawId}`;
+
+      // 图标缩放：使用 CallbackProperty 动态响应相机缩放变化
+      // 调参见顶部 ICON_ 常量
+      const dynamicIconScale = new Cesium.CallbackProperty(() => {
+        const zoom = this.getCurrentCesiumZoom() || 4.5;
+        return Math.max(
+          this.ICON_MIN_SCALE,
+          Math.min(
+            this.ICON_MAX_SCALE,
+            this.ICON_BASE_SCALE + (zoom - 4.5) * this.ICON_SCALE_RATE
+          )
+        );
+      }, false);
+
+      // 字体大小：与 2D getPointFontSize 对齐 → fontSize = clamp(base * scale, min, max)
+      // 调参见顶部 LABEL_FONT_ 常量
+      const dynamicLabelFont = new Cesium.CallbackProperty(() => {
+        const zoom = this.getCurrentCesiumZoom() || 4.5;
+        const scale = Math.max(0.5, Math.min(3.0, 0.7 + (zoom - 4.5) * 0.08));
+        const fontSize = Math.round(
+          Math.max(
+            this.LABEL_FONT_MIN,
+            Math.min(this.LABEL_FONT_MAX, this.LABEL_FONT_BASE * scale)
+          )
+        );
+        return `${fontSize}px sans-serif`;
+      }, false);
+
+      // 标签纵向偏移：与 2D getPointLabelRenderOffsetY 对齐
+      // 调参见顶部 LABEL_OFFSET_ 常量
+      const dynamicLabelOffset = new Cesium.CallbackProperty(() => {
+        const zoom = this.getCurrentCesiumZoom() || 4.5;
+        const scale = Math.max(0.5, Math.min(3.0, 0.7 + (zoom - 4.5) * 0.08));
+        const offsetY =
+          labelLineCount > 1
+            ? -this.LABEL_OFFSET_MULTI * scale
+            : -this.LABEL_OFFSET_SINGLE * scale;
+        return new Cesium.Cartesian2(0, offsetY);
+      }, false);
+
+      const entity = new Cesium.Entity({
+        id: entityId,
+        position: Cesium.Cartesian3.fromDegrees(lon, lat, 0),
+        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),
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        } as any,
+        label: {
+          text: labelText || undefined,
+          font: dynamicLabelFont as any,
+          fillColor: Cesium.Color.WHITE,
+          outlineColor: Cesium.Color.BLACK,
+          outlineWidth: 2,
+          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),
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        } as any,
+        properties: {
+          ...item,
+          _layerKey: targetLayerKey,
+          _iconUrl: iconUrl,
+          _labelText: labelText,
+          _legendVisible: true,
+          _regionVisible: true,
+          _sttpMap: item.sttpMap
+        } as any
+      });
+
+      this.viewer!.entities.add(entity);
+      // 存储原始业务数据引用，避免点击时遍历 Cesium Property
+      (entity as any)._rawData = item;
+      (entity as any)._labelText = labelText;
+      // 可见性控制标志（组合计算 entity.show）
+      (entity as any)._layerVisible = true;
+      (entity as any)._legendVisible = true;
+      (entity as any)._regionVisible = true;
+      // 碰撞检测可见性标志（初始均为可见，碰撞检测会按需更新）
+      (entity as any)._iconCollisionVisible = true;
+      (entity as any)._labelCollisionVisible = true;
+      // 初始应用可见性（确保 entity.show / entity.label.show 被显式设置）
+      this.applyEntityVisibility(entity);
+      entities.push(entity);
+    });
+
+    this.pointLayerRegistry.set(targetLayerKey, entities);
+
+    // 如果当前有活跃的基地裁切，新图层也需要过滤
+    if (this.currentClipGeoJson) {
+      this.filterPointsByRegionForLayer(
+        targetLayerKey,
+        this.extractPolygonCoords(this.currentClipGeoJson)
+      );
+    }
+
+    // 数据加载完成后触发首次碰撞检测（同步执行，避免异步 rAF 导致的首帧闪烁）
+    this.requestRefreshPointLabelVisibility(true);
+  }
+
+  mdLayerTreeShowOrHidden(layerType: string, checked?: boolean): void {
+    const entities = this.pointLayerRegistry.get(layerType);
+    if (!entities) return;
+
+    const visible = checked !== false;
+    entities.forEach(entity => {
+      (entity as any)._layerVisible = visible;
+      this.applyEntityVisibility(entity);
+    });
+
+    // 图层切换后立即重算碰撞（同步执行，避免闪烁）
+    this.requestRefreshPointLabelVisibility(true);
+    // 批量模式下同步重建 popup
+    this.rebuildBatchPopupsIfNeeded();
+  }
+
+  removePointLayer(layerKey: string): void {
+    if (!layerKey) return;
+
+    const entities = this.pointLayerRegistry.get(layerKey);
+    if (!entities) return;
+
+    entities.forEach(entity => {
+      if (this.viewer && !this.viewer.isDestroyed()) {
+        this.viewer.entities.remove(entity);
+      }
+    });
+    this.pointLayerRegistry.delete(layerKey);
+  }
+
+  hasLayer(layerKey: string): boolean {
+    return this.pointLayerRegistry.has(layerKey);
+  }
+
+  private destroyAllPointLayers(): void {
+    this.pointLayerRegistry.forEach((entities, layerKey) => {
+      entities.forEach(entity => {
+        if (this.viewer && !this.viewer.isDestroyed()) {
+          this.viewer.entities.remove(entity);
+        }
+      });
+    });
+    this.pointLayerRegistry.clear();
+  }
+
+  // ==================== Stubs（后续步骤补齐） ====================
+
   baseLayerSwitcher(_key: string): void {}
+  switchView(_type: '2D' | '3D'): void {}
+  fitBounds(_bounds: any): void {}
+  lengthCalculate(): void {}
+  areCalculate(): void {}
+  removeQueryLayer(): void {}
   addTertiarybasinLayer(
     _layer: layer,
     _fillcolor: any,
@@ -264,67 +1681,1026 @@ export class MapCesium implements MapInterface {
     _datas: any
   ): void {}
   hideTertiarybasinLayer(_layer: layer): void {}
-  zoomToggle(type: 'out' | 'in'): void {
-    if (!this.viewer) return;
-    const factor = 1.5;
-    if (type === 'in') this.viewer.camera.zoomIn(factor);
-    else this.viewer.camera.zoomOut(factor);
-  }
-  lengthCalculate(): void {}
-  areCalculate(): void {}
-  removeQueryLayer(): void {}
-  // src/components/gis/map.cesium.ts
-
-  /**
-   * 地图截图下载
-   * @param fileName 可选，下载的文件名，默认为 'cesium_map.png'
-   */
-  mapOutPut(fileName = 'cesium_map.png'): void {
-    if (!this.viewer) {
-      console.warn('Viewer is not initialized.');
+  async jdPanelControlShowAndHidden(
+    _regionId: string,
+    isAll: boolean
+  ): Promise<void> {
+    if (!this.viewer || !this.hydropBaseConfig) {
+      console.warn('地图未初始化或 hydropBaseConfig 未配置');
       return;
     }
 
+    // 取消正在进行的裁切请求
+    if (this.clipRequestController) {
+      this.clipRequestController.abort();
+      this.clipRequestController = null;
+    }
+
+    this.BASEID = _regionId;
+
+    if (!isAll) {
+      // 取消裁切：清除遮罩多边形，恢复全部锚点可见，平滑飞回全国视图
+      this.currentClipGeoJson = null;
+      this.clearMaskPolygon();
+      this.setAllPointsRegionVisible(true);
+      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.0
+      });
+      return;
+    }
+
+    // 用户从"全部"进入，锚点本来就全可见，无需 API 前先隐藏（避免全量遍历卡顿）
+    this.clipRequestController = new AbortController();
+    const signal = this.clipRequestController.signal;
+
     try {
-      const canvas = this.viewer.canvas;
+      const url =
+        this.hydropBaseConfig.geojson_url +
+        `&cql_filter=BASEID='${this.BASEID}'`;
 
-      // ✅ 关键步骤 1: 强制渲染一帧，确保画布内容是最新的
-      // 这有助于解决因缓冲区清除导致的黑屏问题
-      this.viewer.render();
+      const geoJsonData = await this.fetchGeoJson(url, signal);
 
-      // ✅ 关键步骤 2: 尝试获取数据
-      // 注意：如果存在跨域污染，这里可能会抛出 SecurityError
-      const dataURL = canvas.toDataURL('image/png');
+      if (signal.aborted) return;
+      if (this.BASEID !== _regionId) return;
 
-      // 检查是否获取到了有效数据（简单的长度检查）
-      if (dataURL.length < 100) {
-        console.warn(
-          'Canvas data is too small, likely black or empty. Check CORS settings.'
-        );
-        // 可以尝试 fallback 到 blob 方式，但通常 CORS 问题两者都会失败
-      }
-
-      // 创建临时链接元素
-      const link = document.createElement('a');
-      link.href = dataURL;
-      link.download = fileName;
-
-      // 触发点击事件进行下载
-      document.body.appendChild(link);
-      link.click();
-
-      // 清理临时元素
-      document.body.removeChild(link);
-    } catch (error) {
-      console.error('Failed to export map image:', error);
-      if (error instanceof DOMException && error.name === 'SecurityError') {
-        console.error(
-          'Security Error: The canvas has been tainted by cross-origin data. Ensure all imagery providers support CORS.'
-        );
+      this.currentClipGeoJson = geoJsonData;
+      const regionCoords = this.extractPolygonCoords(geoJsonData);
+      this.filterPointsByRegion(regionCoords);
+      this.fitViewToGeoJson(regionCoords);
+      this.createMaskPolygon(regionCoords);
+    } catch (error: any) {
+      if (error.name === 'AbortError') return;
+      this.currentClipGeoJson = null;
+      console.error('加载裁切数据失败:', error);
+      this.clearMaskPolygon();
+      this.setAllPointsRegionVisible(true);
+    } finally {
+      if (this.clipRequestController?.signal === signal) {
+        this.clipRequestController = null;
       }
     }
   }
+  mdLayerShowOrHidden(
+    _layerType: string,
+    _key?: string,
+    _baseid?: string,
+    _checked?: boolean,
+    _isAll?: boolean
+  ): void {}
+  setLegendPointVisible(
+    layerKey: string,
+    anchoPointState: string,
+    checked: boolean
+  ): void {
+    const entities = this.pointLayerRegistry.get(layerKey);
+    if (!entities) return;
 
-  // ... 其他代码 ...
-  initPopupOverlay(_popupContainer: HTMLDivElement): void {}
+    if (!anchoPointState) {
+      // 第一步：全部隐藏（配合 restoreLayerLegendVisibility 两步走：先全隐藏再按图例逐项恢复）
+      entities.forEach(entity => {
+        (entity as any)._legendVisible = false;
+        this.applyEntityVisibility(entity);
+      });
+      this.requestRefreshPointLabelVisibility(true);
+      this.rebuildBatchPopupsIfNeeded();
+      return;
+    }
+
+    // 按 anchoPointState 字段匹配并设置可见性
+    entities.forEach(entity => {
+      const rawData = (entity as any)._rawData;
+      if (rawData && rawData.anchoPointState === anchoPointState) {
+        (entity as any)._legendVisible = checked;
+        this.applyEntityVisibility(entity);
+      }
+    });
+
+    // 图例切换后立即重算碰撞（同步执行，避免闪烁）
+    this.requestRefreshPointLabelVisibility(true);
+    this.rebuildBatchPopupsIfNeeded();
+  }
+
+  // ==================== 基地裁切辅助方法 ====================
+
+  /** 获取 GeoJSON 数据 */
+  private async fetchGeoJson(url: string, signal?: AbortSignal): Promise<any> {
+    const response = await fetch(url, { signal });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return response.json();
+  }
+
+  /** 批量设置全部锚点的 _regionVisible 标志 */
+  private setAllPointsRegionVisible(visible: boolean): void {
+    this.pointLayerRegistry.forEach(entities => {
+      entities.forEach(entity => {
+        (entity as any)._regionVisible = visible;
+        this.applyEntityVisibility(entity);
+      });
+    });
+  }
+
+  /** 根据 GeoJSON 边界批量更新锚点的区域显隐状态（射线法） */
+  private filterPointsByRegion(regionCoords: number[][][]): void {
+    if (!regionCoords.length) {
+      console.warn('无法解析区域边界，显示所有锚点');
+      this.setAllPointsRegionVisible(true);
+      return;
+    }
+
+    this.pointLayerRegistry.forEach((_entities, layerKey) => {
+      this.filterPointsByRegionForLayer(layerKey, regionCoords);
+    });
+  }
+
+  /** 对单个图层应用基地裁切过滤 */
+  private filterPointsByRegionForLayer(
+    layerKey: string,
+    regionCoords: number[][][]
+  ): void {
+    const entities = this.pointLayerRegistry.get(layerKey);
+    if (!entities || !regionCoords.length) return;
+
+    entities.forEach(entity => {
+      const rawData = (entity as any)._rawData;
+      if (!rawData) {
+        (entity as any)._regionVisible = false;
+        this.applyEntityVisibility(entity);
+        return;
+      }
+
+      const lon = Number(rawData.lgtd);
+      const lat = Number(rawData.lttd);
+
+      if (!isFinite(lon) || !isFinite(lat)) {
+        (entity as any)._regionVisible = false;
+        this.applyEntityVisibility(entity);
+        return;
+      }
+
+      (entity as any)._regionVisible = this.isPointInPolygon(
+        lon,
+        lat,
+        regionCoords
+      );
+      this.applyEntityVisibility(entity);
+    });
+  }
+
+  /** 根据多边形坐标飞行相机到基地边界 */
+  private fitViewToGeoJson(regionCoords: number[][][]): void {
+    if (!this.viewer) return;
+
+    try {
+      if (!regionCoords.length) return;
+
+      // 计算所有坐标的经纬度范围
+      let minLon = Infinity;
+      let maxLon = -Infinity;
+      let minLat = Infinity;
+      let maxLat = -Infinity;
+
+      regionCoords.forEach(ring => {
+        ring.forEach(([lon, lat]) => {
+          if (lon < minLon) minLon = lon;
+          if (lon > maxLon) maxLon = lon;
+          if (lat < minLat) minLat = lat;
+          if (lat > maxLat) maxLat = lat;
+        });
+      });
+
+      if (!isFinite(minLon)) return;
+
+      const rectangle = Cesium.Rectangle.fromDegrees(
+        minLon,
+        minLat,
+        maxLon,
+        maxLat
+      );
+
+      this.viewer.camera.flyTo({
+        destination: rectangle,
+        duration: 1.0,
+        complete: () => this.requestRender()
+      });
+    } catch (error) {
+      console.error('调整3D视野失败:', error);
+    }
+  }
+
+  /** 应用基地裁切：globe.clippingPolygons 直接裁切地球渲染 */
+  private createMaskPolygon(regionCoords: number[][][]): void {
+    if (!this.viewer) return;
+
+    // 仅清理旧边框（不重置 clipping/背景色/skyBox，避免 GPU 状态反复重建）
+    this.maskPolygonEntities.forEach(entity => {
+      if (!this.viewer!.isDestroyed()) {
+        this.viewer!.entities.remove(entity);
+      }
+    });
+    this.maskPolygonEntities = [];
+
+    if (!regionCoords.length) return;
+
+    const cartesianRings = regionCoords.map(ring =>
+      Cesium.Cartesian3.fromDegreesArray(
+        ring.flatMap(([lon, lat]) => [lon, lat])
+      )
+    );
+
+    // 首次进入裁切时保存原始状态
+    if (!this.originalBgColor) {
+      this.originalBgColor = this.viewer.scene.backgroundColor.clone();
+      this.skyBoxShown = this.viewer.scene.skyBox?.show ?? true;
+      this.skyAtmosphereShown = this.viewer.scene.skyAtmosphere?.show ?? true;
+    }
+    // 边界外设为白色
+    if (this.viewer.scene.skyBox) this.viewer.scene.skyBox.show = false;
+    if (this.viewer.scene.skyAtmosphere)
+      this.viewer.scene.skyAtmosphere.show = false;
+    this.viewer.scene.backgroundColor = Cesium.Color.WHITE;
+
+    // 直接设新裁切（不经过空集合，避免 GPU shader 重复编译）
+    this.viewer.scene.globe.clippingPolygons =
+      new Cesium.ClippingPolygonCollection({
+        polygons: cartesianRings.map(
+          positions => new Cesium.ClippingPolygon({ positions })
+        ),
+        inverse: true,
+        enabled: true
+      });
+
+    // 绘制基地边界线（双线视觉效果：紫色 + 浅紫色）
+    const borderStyles = [
+      { width: 3, color: '#6D64DF' },
+      { width: 1.5, color: '#CCC9F4' }
+    ];
+    borderStyles.forEach(({ width, color }) => {
+      cartesianRings.forEach(positions => {
+        this.maskPolygonEntities.push(
+          this.viewer!.entities.add({
+            polyline: {
+              positions,
+              width,
+              material: Cesium.Color.fromCssColorString(color),
+              clampToGround: true
+            }
+          })
+        );
+      });
+    });
+
+    this.requestRender();
+    this.viewer.scene.screenSpaceCameraController.maximumZoomDistance = 6_400_000;
+  }
+
+  /** 清除遮罩多边形 */
+  private clearMaskPolygon(): void {
+    if (!this.viewer) return;
+
+    // 解除 globe 裁切
+    this.viewer.scene.globe.clippingPolygons =
+      new Cesium.ClippingPolygonCollection();
+
+    // 恢复背景色、星空、大气层
+    if (this.originalBgColor) {
+      this.viewer.scene.backgroundColor = this.originalBgColor;
+      this.originalBgColor = null;
+    }
+    if (this.viewer.scene.skyBox) {
+      this.viewer.scene.skyBox.show = this.skyBoxShown;
+    }
+    if (this.viewer.scene.skyAtmosphere) {
+      this.viewer.scene.skyAtmosphere.show = this.skyAtmosphereShown;
+    }
+
+    this.viewer.scene.screenSpaceCameraController.maximumZoomDistance =
+      Infinity;
+
+    this.maskPolygonEntities.forEach(entity => {
+      if (!this.viewer!.isDestroyed()) {
+        this.viewer!.entities.remove(entity);
+      }
+    });
+    this.maskPolygonEntities = [];
+  }
+
+  /** 从 GeoJSON 中提取多边形环坐标 */
+  private extractPolygonCoords(geoJson: any): number[][][] {
+    if (!geoJson?.features?.length) return [];
+
+    const coords: number[][][] = [];
+    geoJson.features.forEach((feature: any) => {
+      const geometry = feature.geometry;
+      if (!geometry) return;
+
+      if (geometry.type === 'Polygon') {
+        coords.push(...geometry.coordinates);
+      } else if (geometry.type === 'MultiPolygon') {
+        geometry.coordinates.forEach((polygon: number[][][]) => {
+          coords.push(...polygon);
+        });
+      }
+    });
+
+    return coords;
+  }
+
+  /** 射线法判断点是否在任意一个多边形环内 */
+  private isPointInPolygon(
+    lon: number,
+    lat: number,
+    polygons: number[][][]
+  ): boolean {
+    for (const polygon of polygons) {
+      if (this.isPointInRing(lon, lat, polygon)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** 射线法判断点是否在单个闭合环内 */
+  private isPointInRing(lon: number, lat: number, ring: number[][]): boolean {
+    let inside = false;
+    const n = ring.length;
+
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+      const xi = ring[i][0];
+      const yi = ring[i][1];
+      const xj = ring[j][0];
+      const yj = ring[j][1];
+
+      const intersect =
+        yi > lat !== yj > lat &&
+        lon < ((xj - xi) * (lat - yi)) / (yj - yi) + xi;
+
+      if (intersect) inside = !inside;
+    }
+
+    return inside;
+  }
+
+  /**
+   * 组合计算可见性（3D 解耦模型）：
+   * - entity.show = 基础可见（layer && legend && region），保持 entity 始终"在作用域内"
+   * - entity.billboard.show = 基础可见 && 图标碰撞通过
+   * - entity.label.show = 基础可见 && 标签碰撞通过（图标碰撞不影响标签）
+   */
+  private applyEntityVisibility(entity: Cesium.Entity): void {
+    const e = entity as any;
+    const baseVisible = e._layerVisible && e._legendVisible && e._regionVisible;
+    // entity 整体始终基于 layer/legend/region（不受碰撞影响，保证 popup/click 等交互不受碰撞干扰）
+    entity.show = baseVisible;
+    // 图标单独受碰撞控制
+    if (entity.billboard) {
+      (entity.billboard as any).show =
+        baseVisible && e._iconCollisionVisible !== false;
+    }
+    // 标签单独受碰撞控制（不与图标碰撞联动）
+    if (entity.label) {
+      (entity.label as any).show =
+        baseVisible && e._labelCollisionVisible !== false;
+    }
+  }
+
+  // ==================== Step 6: 碰撞检测 ====================
+
+  /**
+   * 触发碰撞检测刷新（带 rAF 节流，与 2D requestRefreshPointLabelVisibility 对齐）
+   */
+  private requestRefreshPointLabelVisibility(
+    immediate = false,
+    debounceMs = 0
+  ) {
+    if (this.labelVisibilityDebounceTimerId !== null) {
+      window.clearTimeout(this.labelVisibilityDebounceTimerId);
+      this.labelVisibilityDebounceTimerId = null;
+    }
+
+    if (immediate) {
+      if (this.collisionRefreshFrameId !== null) {
+        cancelAnimationFrame(this.collisionRefreshFrameId);
+        this.collisionRefreshFrameId = null;
+      }
+      this.refreshPointLabelVisibility();
+      return;
+    }
+
+    if (debounceMs > 0) {
+      this.labelVisibilityDebounceTimerId = window.setTimeout(() => {
+        this.labelVisibilityDebounceTimerId = null;
+        this.requestRefreshPointLabelVisibility();
+      }, debounceMs);
+      return;
+    }
+
+    if (this.collisionRefreshFrameId !== null) return;
+
+    this.collisionRefreshFrameId = window.requestAnimationFrame(() => {
+      this.collisionRefreshFrameId = null;
+      this.refreshPointLabelVisibility();
+    });
+  }
+
+  /**
+   * 主碰撞检测：密度门控 → 图标碰撞 → 标签碰撞
+   * 与 2D refreshPointLabelVisibility 核心算法完全对齐
+   */
+  private refreshPointLabelVisibility(): void {
+    if (!this.viewer) return;
+
+    const currentZoom = this.getCurrentCesiumZoom();
+    if (currentZoom === undefined || currentZoom === null) return;
+
+    console.log(
+      `[Cesium Collision] zoom=${currentZoom?.toFixed(2)} layers=${
+        this.pointLayerRegistry.size
+      }`
+    );
+
+    // ===== 阶段0：收集视口内所有基础可见实体 =====
+    type CollisionCandidate = {
+      entity: Cesium.Entity;
+      iconLeft: number;
+      iconRight: number;
+      iconTop: number;
+      iconBottom: number;
+      hasLabel: boolean;
+      labelLeft: number;
+      labelRight: number;
+      labelTop: number;
+      labelBottom: number;
+      engPriority: number;
+      nearbyPriority: number;
+      densityPriority: number;
+      pixelX: number;
+      pixelY: number;
+      id: string;
+    };
+
+    const candidates: CollisionCandidate[] = [];
+    const canvas = this.viewer.scene.canvas;
+    const viewPadding = 120; // 视口外的宽容范围
+
+    // 孤立点密度网格：用于 shouldBypassDensityGate
+    const densityPixelGrid = new Map<
+      string,
+      Array<{
+        entity: Cesium.Entity;
+        layerKey: string;
+        pixelX: number;
+        pixelY: number;
+      }>
+    >();
+
+    const dynamicScale = Math.max(
+      0.5,
+      Math.min(3.0, 0.7 + (currentZoom - 4.5) * 0.08)
+    );
+    const fontSize = Math.max(10, Math.min(24, 12 * dynamicScale));
+
+    // 第一遍：密度门控 + 构建候选
+    this.pointLayerRegistry.forEach((entities, layerKey) => {
+      entities.forEach(entity => {
+        const e = entity as any;
+
+        // 基础可见性检查（layer/legend/region）
+        if (
+          e._layerVisible === false ||
+          e._legendVisible === false ||
+          e._regionVisible === false
+        ) {
+          e._iconCollisionVisible = false;
+          e._labelCollisionVisible = false;
+          this.applyEntityVisibility(entity);
+          return;
+        }
+
+        const position = entity.position?.getValue(
+          this.viewer!.clock.currentTime
+        );
+        if (!position) {
+          e._iconCollisionVisible = false;
+          e._labelCollisionVisible = false;
+          this.applyEntityVisibility(entity);
+          return;
+        }
+
+        const screenPos = Cesium.SceneTransforms.worldToWindowCoordinates(
+          this.viewer!.scene,
+          position
+        );
+        if (!screenPos) {
+          e._iconCollisionVisible = false;
+          e._labelCollisionVisible = false;
+          this.applyEntityVisibility(entity);
+          return;
+        }
+
+        const pixelX = screenPos.x;
+        const pixelY = screenPos.y;
+
+        // 视口裁剪：太远的实体不参与碰撞，但保留其当前碰撞状态（不重置）
+        if (
+          pixelX < -viewPadding ||
+          pixelY < -viewPadding ||
+          pixelX > canvas.clientWidth + viewPadding ||
+          pixelY > canvas.clientHeight + viewPadding
+        ) {
+          return;
+        }
+
+        // 密度 gating（与 2D getFeatureDensityMinZoom / shouldRenderFeatureByDensity 对齐）
+        const densityMinZoom = this.getEntityDensityMinZoom(entity);
+        const bypassDensity =
+          currentZoom < densityMinZoom &&
+          this.shouldBypassDensityGateForIsolatedEntity(
+            entity,
+            pixelX,
+            pixelY,
+            layerKey,
+            densityPixelGrid
+          );
+        const densityVisible = currentZoom >= densityMinZoom || bypassDensity;
+
+        if (!densityVisible) {
+          e._iconCollisionVisible = false;
+          e._labelCollisionVisible = false;
+          this.applyEntityVisibility(entity);
+          return;
+        }
+
+        // 构建图标碰撞盒（与 2D 一致：Math.max(14, 24 * dynamicScale)）
+        const iconCollisionSize = Math.max(14, 24 * dynamicScale);
+        const iconLeft = pixelX - iconCollisionSize / 2;
+        const iconRight = pixelX + iconCollisionSize / 2;
+        const iconTop = pixelY - iconCollisionSize / 2;
+        const iconBottom = pixelY + iconCollisionSize / 2;
+
+        // 构建标签碰撞盒
+        const labelText: string = e._labelText || '';
+        const hasLabel = !!labelText;
+        let labelLeft = 0;
+        let labelRight = 0;
+        let labelTop = 0;
+        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 对齐
+          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;
+        }
+
+        const entityId = String(entity.id || '');
+        const rawData: Record<string, any> = e._rawData || {};
+
+        candidates.push({
+          entity,
+          iconLeft,
+          iconRight,
+          iconTop,
+          iconBottom,
+          hasLabel,
+          labelLeft,
+          labelRight,
+          labelTop,
+          labelBottom,
+          engPriority: this.getEntityEngRenderPriority(entity),
+          nearbyPriority: Number(rawData._nearbyPriority || 9999),
+          densityPriority: this.getEntityDensityPriority(entity),
+          pixelX,
+          pixelY,
+          id: entityId
+        });
+      });
+    });
+
+    if (candidates.length === 0) return;
+
+    // ===== 阶段1：排序（eng优先级 > 近邻点优先级 > 密度优先级 > Y轴 > ID） =====
+    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.densityPriority !== right.densityPriority) {
+        return left.densityPriority - right.densityPriority;
+      }
+      if (left.pixelY !== right.pixelY) {
+        return left.pixelY - right.pixelY;
+      }
+      return left.id.localeCompare(right.id);
+    });
+
+    // ===== 阶段2：图标碰撞（AABB + 空间网格加速） =====
+    const iconPlacedGrid = new Map<
+      string,
+      Array<{
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+      }>
+    >();
+
+    candidates.forEach(candidate => {
+      const iconRect = {
+        left: candidate.iconLeft,
+        right: candidate.iconRight,
+        top: candidate.iconTop,
+        bottom: candidate.iconBottom
+      };
+
+      const hasCollision = this.findCollidingRectInGrid(
+        iconRect,
+        iconPlacedGrid,
+        this.COLLISION_GRID_CELL_SIZE,
+        placed => this.checkIconsAabbCollision(placed, iconRect)
+      );
+
+      const iconVisible = !hasCollision;
+      (candidate.entity as any)._iconCollisionVisible = iconVisible;
+
+      if (iconVisible) {
+        this.addRectToCollisionGrid(
+          iconRect,
+          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);
+    });
+
+    const labelPlacedGrid = new Map<
+      string,
+      Array<{
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+      }>
+    >();
+
+    labelCandidates.forEach(candidate => {
+      const e = candidate.entity as any;
+
+      if (!candidate.hasLabel) {
+        e._labelCollisionVisible = false;
+        return;
+      }
+
+      // 3D 解耦：图标被碰撞隐藏不影响标签显示
+      // 标签仍会避让已放置的图标（见下方 iconPlacedGrid 检查）
+
+      const labelRect = {
+        left: candidate.labelLeft,
+        right: candidate.labelRight,
+        top: candidate.labelTop,
+        bottom: candidate.labelBottom
+      };
+
+      // 先避让已放置的图标（缩小保护区4px，允许边缘擦过）
+      const hasIconCollision = this.findCollidingRectInGrid(
+        labelRect,
+        iconPlacedGrid,
+        this.COLLISION_GRID_CELL_SIZE,
+        iconRect => {
+          const inset = 4;
+          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
+          );
+        }
+      );
+
+      if (hasIconCollision) {
+        e._labelCollisionVisible = false;
+        return;
+      }
+
+      // 再避让已放置的标签
+      const hasLabelCollision = this.findCollidingRectInGrid(
+        labelRect,
+        labelPlacedGrid,
+        this.COLLISION_GRID_CELL_SIZE,
+        placed => this.checkLabelAabbCollision(placed, labelRect)
+      );
+
+      const labelVisible = !hasLabelCollision;
+      e._labelCollisionVisible = labelVisible;
+
+      if (labelVisible) {
+        this.addRectToCollisionGrid(
+          labelRect,
+          labelPlacedGrid,
+          this.COLLISION_GRID_CELL_SIZE
+        );
+      }
+    });
+
+    // ===== 阶段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}`
+    );
+  }
+
+  // ==================== 碰撞检测辅助：密度门控 ====================
+
+  /** 从实体原始数据中提取 density 字段（密度分档值，非物理距离） */
+  private getEntityDensityValue(entity: Cesium.Entity): number | null {
+    const rawData = (entity as any)._rawData;
+    if (!rawData) return null;
+    const rawDistance = rawData.distance;
+    if (
+      rawDistance === undefined ||
+      rawDistance === null ||
+      rawDistance === ''
+    ) {
+      return null;
+    }
+    const densityValue = Number(rawDistance);
+    return Number.isFinite(densityValue) ? densityValue : null;
+  }
+
+  /** 密度优先级（档位越低越优先，与 2D getFeatureDensityPriority 对齐） */
+  private getEntityDensityPriority(entity: Cesium.Entity): number {
+    const densityValue = this.getEntityDensityValue(entity);
+    const densityDisplayRules = getNearbyPointDensityDisplayRules();
+    if (densityValue === null) {
+      return densityDisplayRules.length;
+    }
+    const matchedRuleIndex = densityDisplayRules.findIndex(rule => {
+      return densityValue >= rule.minDensityValue;
+    });
+    return matchedRuleIndex >= 0
+      ? matchedRuleIndex
+      : densityDisplayRules.length;
+  }
+
+  /** 根据密度值获取最低显示缩放级别（与 2D getFeatureDensityMinZoom 对齐） */
+  private getEntityDensityMinZoom(entity: Cesium.Entity): number {
+    const densityValue = this.getEntityDensityValue(entity);
+    if (densityValue === null) return 0;
+    const densityDisplayRules = getNearbyPointDensityDisplayRules();
+    const matchedRule = densityDisplayRules.find(rule => {
+      return densityValue >= rule.minDensityValue;
+    });
+    if (matchedRule) return matchedRule.minZoom;
+    return densityDisplayRules.at(-1)?.minZoom ?? 0;
+  }
+
+  /**
+   * 孤立点密度豁免：如果当前视口内 56px 范围内没有其他同图层可见点，
+   * 则跳过密度门控直接显示（与 2D shouldBypassDensityGateForIsolatedFeature 对齐）
+   */
+  private shouldBypassDensityGateForIsolatedEntity(
+    entity: Cesium.Entity,
+    pixelX: number,
+    pixelY: number,
+    layerKey: string,
+    densityPixelGrid: Map<
+      string,
+      Array<{
+        entity: Cesium.Entity;
+        layerKey: string;
+        pixelX: number;
+        pixelY: number;
+      }>
+    >
+  ): boolean {
+    // 先登记当前实体到密度网格
+    const gridKey = `${layerKey}:${Math.floor(
+      pixelX / this.DENSITY_ISOLATION_THRESHOLD
+    )}:${Math.floor(pixelY / this.DENSITY_ISOLATION_THRESHOLD)}`;
+    const bucket = densityPixelGrid.get(gridKey) || [];
+    bucket.push({ entity, layerKey, pixelX, pixelY });
+    densityPixelGrid.set(gridKey, bucket);
+
+    // 检查周围 3x3 网格单元
+    const checkedKeys = new Set<string>();
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const neighborKey = `${layerKey}:${
+          Math.floor(pixelX / this.DENSITY_ISOLATION_THRESHOLD) + dx
+        }:${Math.floor(pixelY / this.DENSITY_ISOLATION_THRESHOLD) + dy}`;
+        if (checkedKeys.has(neighborKey)) continue;
+        checkedKeys.add(neighborKey);
+
+        const neighborBucket = densityPixelGrid.get(neighborKey);
+        if (!neighborBucket?.length) continue;
+
+        for (const neighbor of neighborBucket) {
+          if (neighbor.entity === entity) continue;
+          const dist = Math.hypot(
+            neighbor.pixelX - pixelX,
+            neighbor.pixelY - pixelY
+          );
+          if (dist <= this.DENSITY_ISOLATION_THRESHOLD) {
+            return false; // 有近邻点，不豁免
+          }
+        }
+      }
+    }
+
+    return true; // 孤立点，豁免密度门控
+  }
+
+  // ==================== 碰撞检测辅助：eng 优先级 ====================
+
+  /** 判断是否为 eng 点（与 2D isFeatureEng 对齐） */
+  private isEntityEng(entity: Cesium.Entity): boolean {
+    const e = entity as any;
+    const rawData: Record<string, any> = e._rawData || {};
+    const layerKey = String(e._layerKey || '').toLowerCase();
+    const sttpMap = String(
+      rawData.sttpMap || rawData._sttpMap || ''
+    ).toUpperCase();
+    const sttpCode = String(
+      rawData.sttpCode || rawData.sttp || ''
+    ).toUpperCase();
+
+    return (
+      layerKey.includes('eng_point') ||
+      sttpMap === 'ENG' ||
+      sttpMap === 'ENG2' ||
+      sttpCode === 'ENG'
+    );
+  }
+
+  /** 判断是否为 eng 告警点（与 2D isFeatureEngAlarm 对齐） */
+  private isEntityEngAlarm(entity: Cesium.Entity): boolean {
+    const e = entity as any;
+    const rawData: Record<string, any> = e._rawData || {};
+    const layerKey = String(e._layerKey || '').toLowerCase();
+    const legendState = String(rawData.anchoPointState || '')
+      .trim()
+      .toLowerCase();
+
+    return (
+      layerKey.includes('eng_alarm_point') ||
+      layerKey.includes('alarm_range') ||
+      legendState.startsWith('alarm_range_') ||
+      legendState.startsWith('large_eng_built_alarm_range_') ||
+      legendState.startsWith('mid_eng_built_alarm_range_')
+    );
+  }
+
+  /** 获取 eng 渲染优先级：告警=300, eng=200, 普通=100（与 2D 完全一致） */
+  private getEntityEngRenderPriority(entity: Cesium.Entity): number {
+    if (this.isEntityEngAlarm(entity)) return 300;
+    return this.isEntityEng(entity) ? 200 : 100;
+  }
+
+  // ==================== 碰撞检测辅助：空间网格与 AABB ====================
+
+  /** 计算矩形覆盖的碰撞网格 cell keys */
+  private getCollisionGridKeys(
+    rect: {
+      left: number;
+      right: number;
+      top: number;
+      bottom: number;
+    },
+    cellSize: number
+  ): string[] {
+    const startX = Math.floor(rect.left / cellSize);
+    const endX = Math.floor(rect.right / cellSize);
+    const startY = Math.floor(rect.top / cellSize);
+    const endY = Math.floor(rect.bottom / cellSize);
+    const keys: string[] = [];
+
+    for (let x = startX; x <= endX; x += 1) {
+      for (let y = startY; y <= endY; y += 1) {
+        keys.push(`${x}:${y}`);
+      }
+    }
+
+    return keys;
+  }
+
+  /** 将矩形注册到碰撞网格 */
+  private addRectToCollisionGrid<
+    T extends {
+      left: number;
+      right: number;
+      top: number;
+      bottom: number;
+    }
+  >(rect: T, grid: Map<string, T[]>, cellSize: number) {
+    this.getCollisionGridKeys(rect, cellSize).forEach(key => {
+      const bucket = grid.get(key) || [];
+      bucket.push(rect);
+      grid.set(key, bucket);
+    });
+  }
+
+  /** 在碰撞网格中查找与给定矩形碰撞的矩形 */
+  private findCollidingRectInGrid<
+    T extends {
+      left: number;
+      right: number;
+      top: number;
+      bottom: number;
+    }
+  >(
+    rect: {
+      left: number;
+      right: number;
+      top: number;
+      bottom: number;
+    },
+    grid: Map<string, T[]>,
+    cellSize: number,
+    isCollision: (candidate: T) => boolean
+  ): T | undefined {
+    for (const key of this.getCollisionGridKeys(rect, cellSize)) {
+      const bucket = grid.get(key);
+      if (!bucket?.length) continue;
+
+      for (const candidate of bucket) {
+        if (isCollision(candidate)) {
+          return candidate;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /** 图标碰撞检测：AABB 重叠判定（padding=0，与 2D 图标碰撞一致） */
+  private checkIconsAabbCollision(
+    left: { left: number; right: number; top: number; bottom: number },
+    right: { left: number; right: number; top: number; bottom: number }
+  ): boolean {
+    return !(
+      left.right < right.left ||
+      left.left > right.right ||
+      left.bottom < right.top ||
+      left.top > right.bottom
+    );
+  }
+
+  /** 标签碰撞检测：AABB 重叠 + padding=4（与 2D checkLabelCollision 对齐） */
+  private checkLabelAabbCollision(
+    left: { left: number; right: number; top: number; bottom: number },
+    right: { left: number; right: number; top: number; bottom: number }
+  ): boolean {
+    const padding = this.COLLISION_LABEL_PADDING;
+    return !(
+      left.right + padding < right.left ||
+      left.left - padding > right.right ||
+      left.bottom + padding < right.top ||
+      left.top - padding > right.bottom
+    );
+  }
 }
diff --git a/frontend/src/components/gis/map.class.ts b/frontend/src/components/gis/map.class.ts
index c0eada73..5758848c 100644
--- a/frontend/src/components/gis/map.class.ts
+++ b/frontend/src/components/gis/map.class.ts
@@ -272,4 +272,8 @@ export class MapClass implements MapClassInterface {
   flyTopanto(position: number[], zoom: number): void {
     this.service.flyTopanto(position, zoom);
   }
+
+  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 e18e481f..24cb929b 100644
--- a/frontend/src/components/gis/map.d.ts
+++ b/frontend/src/components/gis/map.d.ts
@@ -124,6 +124,12 @@ export interface MapInterface {
   fitBounds(bbox, bearing): void;
 
   flyTopanto(positon, zoom): void;
+
+  /**
+   * 获取当前地图缩放级别语义
+   * 2D 直接返回原生 zoom，3D 由相机高度换算后返回
+   */
+  getCurrentZoom(): number | undefined;
   // /**
   //  * 加载倾斜摄影数据
   //  * @param HH3DUrlArray
diff --git a/frontend/src/components/gis/map.ol.ts b/frontend/src/components/gis/map.ol.ts
index c5aa5d7b..209f6ff0 100644
--- a/frontend/src/components/gis/map.ol.ts
+++ b/frontend/src/components/gis/map.ol.ts
@@ -39,6 +39,7 @@ import { PointLayerManager } from './ol/point-layer-manager';
 import { PopupManager } from './ol/popup-manager';
 import { RegionMaskManager } from './ol/region-mask-manager';
 import { getNearbyPointDensityDisplayRules } from '@/modules/map/domain/nearby-point-rules';
+import router from '@/router';
 
 const modelStore = useModelStore();
 const VITE_APP_MAP_URL = import.meta.env.VITE_APP_MAP_URL;
@@ -49,7 +50,7 @@ const MIN_ZOOM = 4.23;
 const MAX_ZOOM = 22;
 const INITIAL_ZOOM = 4.5;
 const BATCH_POPUP_MODE_ZOOM = 15;
-const FULL_DISPLAY_NO_COLLISION_ZOOM = 15;
+const FULL_DISPLAY_NO_COLLISION_ZOOM = Number.POSITIVE_INFINITY;
 
 // 定义边界 [minX, minY, maxX, maxY] (Web Mercator 坐标)
 const BOUNDS_SW = [26.5, -9.99999999999929];
@@ -80,6 +81,8 @@ export class MapOl implements MapInterface {
   private regionMaskManager: RegionMaskManager;
   private isBatchPopupMode = false;
   private batchPopupRefreshFrameId: number | null = null;
+  private batchPopupPendingRebuild = false;
+  private batchPopupPostRenderListenerKey: any = null;
   private pointLayerStyleRefreshFrameId: number | null = null;
   private labelVisibilityRefreshFrameId: number | null = null;
   private labelVisibilityDebounceTimerId: number | null = null;
@@ -167,6 +170,13 @@ export class MapOl implements MapInterface {
         this.handleZoomChange();
       });
       this.map.on('click', evt => {
+        if (
+          router.currentRoute.value.path.includes(
+            'shengTaiLiuLiangManZuQingKuangJiangJu'
+          )
+        ) {
+          return;
+        }
         this.popupManager.showPopup(undefined, undefined);
         this.popupManager.handleMapClick(evt.pixel, detectedFeature => {
           if (detectedFeature.values_.sttpMap == 'ylfb') {
@@ -200,13 +210,14 @@ export class MapOl implements MapInterface {
 
       this.map.on('pointerdrag', () => {
         if (this.isBatchPopupMode) {
-          this.requestUpdateBatchPopups();
+          this.ensureBatchPopupPostRenderSync();
         }
       });
       this.map.on('moveend', () => {
+        this.clearBatchPopupPostRenderSync();
         this.requestRefreshPointLabelVisibility(false, 60);
         if (this.isBatchPopupMode) {
-          this.requestUpdateBatchPopups();
+          this.requestUpdateBatchPopups(false, true);
         }
       });
 
@@ -291,8 +302,9 @@ export class MapOl implements MapInterface {
    */
   private enableBatchPopupMode() {
     this.isBatchPopupMode = true;
+    this.clearBatchPopupPostRenderSync();
     this.popupManager.clearBatchPopups();
-    this.requestUpdateBatchPopups(true);
+    this.requestUpdateBatchPopups(true, true);
   }
 
   /**
@@ -300,6 +312,8 @@ export class MapOl implements MapInterface {
    */
   private disableBatchPopupMode() {
     this.isBatchPopupMode = false;
+    this.batchPopupPendingRebuild = false;
+    this.clearBatchPopupPostRenderSync();
     if (this.batchPopupRefreshFrameId !== null) {
       cancelAnimationFrame(this.batchPopupRefreshFrameId);
       this.batchPopupRefreshFrameId = null;
@@ -314,11 +328,40 @@ export class MapOl implements MapInterface {
   private updateBatchPopups() {
     const features = this.pointLayerManager.getFeaturesInViewport();
     // 传入样式检查器，过滤掉 declutter/距离过滤等隐藏的锚点
-    this.popupManager.showPopupsForFeatures(features, feature => {
-      const style = this.createPointStyle(feature);
-      return style !== null;
+    this.popupManager.showPopupsForFeatures(
+      features,
+      feature => {
+        const style = this.createPointStyle(feature);
+        return style !== null;
+      },
+      {
+        rebuild: this.batchPopupPendingRebuild
+      }
+    );
+  }
+
+  private ensureBatchPopupPostRenderSync() {
+    if (!this.map || this.batchPopupPostRenderListenerKey) {
+      return;
+    }
+
+    this.batchPopupPostRenderListenerKey = this.map.on('postrender', () => {
+      if (!this.isBatchPopupMode) {
+        return;
+      }
+      this.popupManager.updateBatchPopupPositions(feature => {
+        const style = this.createPointStyle(feature);
+        return style !== null;
+      });
     });
   }
+
+  private clearBatchPopupPostRenderSync() {
+    if (this.batchPopupPostRenderListenerKey) {
+      unByKey(this.batchPopupPostRenderListenerKey);
+      this.batchPopupPostRenderListenerKey = null;
+    }
+  }
   /**
    * 创建点样式 (模拟 Leaflet 的 DivIcon 效果，支持随缩放动态调整大小)
    */
@@ -346,10 +389,11 @@ export class MapOl implements MapInterface {
       legendVisible !== false &&
       regionVisible !== false &&
       densityVisible &&
-      this.shouldRenderNearbyFeature(feature, currentZoom);
+      this.shouldRenderNearbyFeature();
 
     const dynamicScale = this.getDynamicPointScale(currentZoom);
     const fontSize = this.getPointFontSize(dynamicScale);
+    const engPriority = this.getFeatureEngRenderPriority(feature);
     const formattedLabelText = this.formatPointLabelText(labelText);
     const labelLineCount = formattedLabelText
       ? formattedLabelText.split('\n').length
@@ -363,7 +407,10 @@ export class MapOl implements MapInterface {
       feature.get('_labelCollisionVisible') === true;
     const finalIconVisible = iconTargetVisible && iconCollisionVisible;
     const labelTargetVisible =
-      finalIconVisible && !!formattedLabelText && labelCollisionVisible;
+      !this.isBatchPopupMode &&
+      finalIconVisible &&
+      !!formattedLabelText &&
+      labelCollisionVisible;
 
     if (!finalIconVisible) {
       return null;
@@ -373,6 +420,7 @@ export class MapOl implements MapInterface {
       iconUrl,
       dynamicScale.toFixed(2),
       fontSize,
+      engPriority,
       labelOffsetY,
       labelTargetVisible ? formattedLabelText : '',
       labelTargetVisible ? 1 : 0
@@ -384,6 +432,7 @@ export class MapOl implements MapInterface {
 
     const styles: Style[] = [
       new Style({
+        zIndex: engPriority,
         image: new Icon({
           src: iconUrl,
           scale: dynamicScale,
@@ -397,7 +446,7 @@ export class MapOl implements MapInterface {
     if (formattedLabelText && labelTargetVisible) {
       styles.push(
         new Style({
-          zIndex: 101,
+          zIndex: engPriority + 1,
           text: new Text({
             text: formattedLabelText,
             offsetY: labelOffsetY,
@@ -598,6 +647,7 @@ export class MapOl implements MapInterface {
         top: number;
         bottom: number;
         priority: number;
+        engPriority: number;
         densityPriority: number;
         id: string;
         pixelX: number;
@@ -616,6 +666,7 @@ export class MapOl implements MapInterface {
       top: number;
       bottom: number;
       priority: number;
+      engPriority: number;
       densityPriority: number;
       id: string;
       pixelX: number;
@@ -663,7 +714,7 @@ export class MapOl implements MapInterface {
         legendVisible: feature.get('_legendVisible') !== false,
         regionVisible: feature.get('_regionVisible') !== false,
         densityPriority: this.getFeatureDensityPriority(feature),
-        nearbyVisible: this.shouldRenderNearbyFeature(feature, currentZoom),
+        nearbyVisible: this.shouldRenderNearbyFeature(),
         labelText: this.formatPointLabelText(
           feature.get('_labelText') as string
         ),
@@ -808,7 +859,7 @@ export class MapOl implements MapInterface {
       const dynamicScale = this.getDynamicPointScale(currentZoom);
       // 备注：图标碰撞盒适当小于视觉图标尺寸，允许相邻站点轻微贴近显示，
       // 避免像“小浪底/三门峡”这类近点被过早裁掉成只剩一个点。
-      const iconCollisionSize = Math.max(12, 16 * dynamicScale);
+      const iconCollisionSize = Math.max(14, 24 * dynamicScale);
       const iconPadding = 0;
       const iconLeft = entry.pixelX - iconCollisionSize / 2 - iconPadding;
       const iconRight = entry.pixelX + iconCollisionSize / 2 + iconPadding;
@@ -851,6 +902,7 @@ export class MapOl implements MapInterface {
         top: centerY - estimatedHeight / 2,
         bottom: centerY + estimatedHeight / 2,
         priority: Number(entry.feature.get('_nearbyPriority') || 9999),
+        engPriority: this.getFeatureEngRenderPriority(entry.feature),
         densityPriority: entry.densityPriority,
         id: candidateId,
         pixelX: entry.pixelX,
@@ -863,6 +915,9 @@ export class MapOl implements MapInterface {
     });
 
     candidates.sort((left, right) => {
+      if (left.engPriority !== right.engPriority) {
+        return right.engPriority - left.engPriority;
+      }
       if (left.priority !== right.priority) {
         return left.priority - right.priority;
       }
@@ -951,6 +1006,9 @@ export class MapOl implements MapInterface {
     });
 
     const labelCandidates = [...candidates].sort((left, right) => {
+      if (left.engPriority !== right.engPriority) {
+        return right.engPriority - left.engPriority;
+      }
       if (left.priority !== right.priority) {
         return left.priority - right.priority;
       }
@@ -1149,10 +1207,11 @@ export class MapOl implements MapInterface {
     }
   }
 
-  private requestUpdateBatchPopups(immediate = false) {
+  private requestUpdateBatchPopups(immediate = false, rebuild = true) {
     if (!this.isBatchPopupMode) {
       return;
     }
+    this.batchPopupPendingRebuild = this.batchPopupPendingRebuild || rebuild;
 
     if (immediate) {
       if (this.batchPopupRefreshFrameId !== null) {
@@ -1160,6 +1219,7 @@ export class MapOl implements MapInterface {
         this.batchPopupRefreshFrameId = null;
       }
       this.updateBatchPopups();
+      this.batchPopupPendingRebuild = false;
       return;
     }
 
@@ -1173,6 +1233,7 @@ export class MapOl implements MapInterface {
         return;
       }
       this.updateBatchPopups();
+      this.batchPopupPendingRebuild = false;
     });
   }
 
@@ -1326,6 +1387,47 @@ export class MapOl implements MapInterface {
     return densityDisplayRules.at(-1)?.minZoom ?? 0;
   }
 
+  private isFeatureEng(feature: Feature): boolean {
+    const layerKey = String(feature.get('_layerKey') || '').toLowerCase();
+    const sttpMap = String(
+      feature.get('_sttpMap') || feature.get('sttpMap') || ''
+    ).toUpperCase();
+    const sttpCode = String(
+      feature.get('sttpCode') || feature.get('sttp') || ''
+    ).toUpperCase();
+
+    return (
+      layerKey.includes('eng_point') ||
+      sttpMap === 'ENG' ||
+      sttpMap === 'ENG2' ||
+      sttpCode === 'ENG'
+    );
+  }
+
+  private isFeatureEngAlarm(feature: Feature): boolean {
+    const layerKey = String(
+      feature.get('_layerKey') || feature.get('type') || ''
+    ).toLowerCase();
+    const legendState = String(feature.get('anchoPointState') || '')
+      .trim()
+      .toLowerCase();
+
+    return (
+      layerKey.includes('eng_alarm_point') ||
+      layerKey.includes('alarm_range') ||
+      legendState.startsWith('alarm_range_') ||
+      legendState.startsWith('large_eng_built_alarm_range_') ||
+      legendState.startsWith('mid_eng_built_alarm_range_')
+    );
+  }
+
+  private getFeatureEngRenderPriority(feature: Feature): number {
+    if (this.isFeatureEngAlarm(feature)) {
+      return 300;
+    }
+    return this.isFeatureEng(feature) ? 200 : 100;
+  }
+
   /**
    * 如果点位在当前视图中没有近邻点，则允许跳过静态密度门槛直接参与显示。
    * 这样像“戈兰滩”这类 distance 档位偏密、但当前周围实际很空的点也能出现。
@@ -1398,53 +1500,10 @@ export class MapOl implements MapInterface {
   }
 
   /**
-   * 统一根据近邻点分组和缩放阶段判断当前要素是否应该参与渲染。
+   * 近邻点统一参与原位堆叠，具体谁显示在顶层交给碰撞排序和图层优先级控制。
    */
-  private shouldRenderNearbyFeature(
-    feature: Feature,
-    currentZoom: number
-  ): boolean {
-    const nearbyGroupId = feature.get('_nearbyGroupId');
-    const groupSize = Number(feature.get('_nearbyGroupSize'));
-    const priority = Number(feature.get('_nearbyPriority'));
-    const replaceAtZoom = Number(feature.get('_nearbyReplaceAtZoom'));
-    const expandAtZoom = Number(feature.get('_nearbyExpandAtZoom'));
-    const showZoomMin = feature.get('_nearbyShowZoomMin');
-    const showZoomMax = feature.get('_nearbyShowZoomMax');
-
-    if (!nearbyGroupId || !Number.isFinite(groupSize) || groupSize < 2) {
-      return true;
-    }
-
-    if (!Number.isFinite(priority) || priority <= 0) {
-      return true;
-    }
-
-    if (
-      showZoomMin !== null &&
-      showZoomMin !== undefined &&
-      currentZoom < Number(showZoomMin)
-    ) {
-      return false;
-    }
-
-    if (
-      showZoomMax !== null &&
-      showZoomMax !== undefined &&
-      currentZoom > Number(showZoomMax)
-    ) {
-      return false;
-    }
-
-    if (Number.isFinite(expandAtZoom) && currentZoom >= expandAtZoom) {
-      return true;
-    }
-
-    if (Number.isFinite(replaceAtZoom) && currentZoom >= replaceAtZoom) {
-      return priority <= Math.min(2, groupSize);
-    }
-
-    return priority === 1;
+  private shouldRenderNearbyFeature(): boolean {
+    return true;
   }
   /**
    * 初始化加载基础图层
@@ -2436,6 +2495,10 @@ export class MapOl implements MapInterface {
     );
   }
 
+  getCurrentZoom(): number | undefined {
+    return this.view?.getZoom();
+  }
+
   /**
    * 生成带完整圆边框的上半圆 Canvas
    * @param radius 半径（像素）
@@ -2496,6 +2559,7 @@ export class MapOl implements MapInterface {
       window.clearTimeout(this.labelVisibilityDebounceTimerId);
       this.labelVisibilityDebounceTimerId = null;
     }
+    this.clearBatchPopupPostRenderSync();
     this.removeQueryLayer();
     this.regionMaskManager.destroy();
 
diff --git a/frontend/src/components/gis/ol/point-layer-manager.ts b/frontend/src/components/gis/ol/point-layer-manager.ts
index 95489733..87e29dd7 100644
--- a/frontend/src/components/gis/ol/point-layer-manager.ts
+++ b/frontend/src/components/gis/ol/point-layer-manager.ts
@@ -5,8 +5,6 @@ import VectorLayer from 'ol/layer/Vector';
 import VectorSource from 'ol/source/Vector';
 import { fromLonLat } from 'ol/proj';
 import { getIconPath } from '@/utils/index';
-import { getNearbyPointConfig } from '@/modules/map/domain/nearby-point-rules';
-
 type PointLayerStyleFactory = (feature: Feature) => any;
 
 type PointLayerManagerOptions = {
@@ -80,103 +78,12 @@ export class PointLayerManager {
   updateNearbyFeatureLayout(currentZoom?: number): void {
     if (!this.map) return;
 
-    const resolution = this.map.getView().getResolution();
-    if (
-      currentZoom === undefined ||
-      !Number.isFinite(currentZoom) ||
-      !resolution
-    ) {
+    if (currentZoom === undefined || !Number.isFinite(currentZoom)) {
       return;
     }
-    const nearbyPointConfig = getNearbyPointConfig();
-    const { autoRule, layoutRule } = nearbyPointConfig;
-
-    const groupMap = new Map<string, Feature[]>();
 
     this.forEachFeature(feature => {
       this.resetFeatureToBaseCoordinate(feature);
-
-      const groupId = feature.get('_nearbyGroupId');
-      const groupSize = Number(feature.get('_nearbyGroupSize'));
-      if (!groupId || !Number.isFinite(groupSize) || groupSize < 2) {
-        return;
-      }
-
-      const groupFeatures = groupMap.get(groupId) || [];
-      groupFeatures.push(feature);
-      groupMap.set(groupId, groupFeatures);
-    });
-
-    groupMap.forEach(features => {
-      const expandAtZoom = Number(features[0]?.get('_nearbyExpandAtZoom'));
-      if (!Number.isFinite(expandAtZoom) || currentZoom < expandAtZoom) {
-        return;
-      }
-      const sortedFeatures = [...features].sort((left, right) => {
-        return (
-          Number(left.get('_nearbyPriority') || 0) -
-          Number(right.get('_nearbyPriority') || 0)
-        );
-      });
-      const secondaryFeatures = sortedFeatures.filter(feature => {
-        const priority = Number(feature.get('_nearbyPriority'));
-        return Number.isFinite(priority) && priority > 1;
-      });
-
-      secondaryFeatures.forEach((feature, index) => {
-        const baseCoordinates = feature.get('_baseCoordinates') as
-          | number[]
-          | undefined;
-        const geometry = feature.getGeometry();
-        if (
-          !baseCoordinates ||
-          baseCoordinates.length < 2 ||
-          !geometry ||
-          geometry.getType() !== 'Point'
-        ) {
-          return;
-        }
-
-        const groupSecondaryCount = secondaryFeatures.length;
-        const baseOffsetPx =
-          Number(feature.get('_nearbyExpandOffsetPx')) ||
-          autoRule.expandOffsetPx;
-        const ringSize = Math.max(1, layoutRule.ringSize);
-        const ringIndex = Math.floor(index / ringSize);
-        const ringOffsetIndex = index % ringSize;
-        const currentRingCount = Math.min(
-          ringSize,
-          groupSecondaryCount - ringIndex * ringSize
-        );
-        const fanAngleDeg =
-          currentRingCount <= 1
-            ? 0
-            : currentRingCount <= 2
-            ? layoutRule.fanAngleForTwoDeg
-            : currentRingCount <= 4
-            ? layoutRule.fanAngleForFourDeg
-            : layoutRule.fanAngleForManyDeg;
-        const angleStepDeg =
-          currentRingCount <= 1 ? 0 : fanAngleDeg / (currentRingCount - 1);
-        const startAngleDeg = -90 - fanAngleDeg / 2;
-        const expandAngleDeg = startAngleDeg + ringOffsetIndex * angleStepDeg;
-        const expandAngleRad = (expandAngleDeg * Math.PI) / 180;
-        const expandOffsetPx =
-          baseOffsetPx +
-          ringIndex *
-            Math.max(
-              layoutRule.ringGapPx,
-              baseOffsetPx * layoutRule.ringGapFactor
-            );
-        const offsetX = Math.cos(expandAngleRad) * expandOffsetPx * resolution;
-        const offsetY = Math.sin(expandAngleRad) * expandOffsetPx * resolution;
-
-        feature.set('_nearbyExpandAngleDeg', expandAngleDeg, true);
-        (geometry as Point).setCoordinates([
-          baseCoordinates[0] + offsetX,
-          baseCoordinates[1] - offsetY
-        ]);
-      });
     });
   }
 
@@ -318,7 +225,7 @@ export class PointLayerManager {
     layerKey: string,
     matchValue: string,
     checked: boolean,
-    fieldKey: string = 'anchoPointState'
+    fieldKey = 'anchoPointState'
   ): void {
     const vectorLayer = this.layerRegistry.get(layerKey);
     if (!vectorLayer) return;
@@ -392,7 +299,6 @@ export class PointLayerManager {
     if (!isFinite(coord[0]) || !isFinite(coord[1])) {
       return null;
     }
-
     let iconUrl = iconCode ? getIconPath(iconCode) : '';
     if (!iconUrl) {
       iconUrl = getIconPath('default') || '';
@@ -403,7 +309,9 @@ export class PointLayerManager {
       ...item,
       _layerKey: targetLayerKey
     });
-    feature.setId(item.stcd || item._id);
+    const rawFeatureId =
+      item.stcd || item._id || `${lon.toFixed(6)},${lat.toFixed(6)}`;
+    feature.setId(`${targetLayerKey}:${rawFeatureId}`);
     feature.set('_iconUrl', iconUrl);
     feature.set(
       '_labelText',
@@ -457,7 +365,6 @@ export class PointLayerManager {
 
     const valueMap = fieldIndexMap.get(fieldKey);
     if (!valueMap) return [];
-
     return valueMap.get(String(matchValue)) || [];
   }
 
diff --git a/frontend/src/components/gis/ol/popup-manager.ts b/frontend/src/components/gis/ol/popup-manager.ts
index dd21e450..929d8dfb 100644
--- a/frontend/src/components/gis/ol/popup-manager.ts
+++ b/frontend/src/components/gis/ol/popup-manager.ts
@@ -4,7 +4,10 @@ import OlMap from 'ol/Map';
 import Overlay from 'ol/Overlay';
 import VectorLayer from 'ol/layer/Vector';
 import VectorSource from 'ol/source/Vector';
-import { generatePopupHtml } from '@/utils/popupHtmlGenerator';
+import {
+  generatePopupHtml,
+  shouldPreferEng2Popup
+} from '@/utils/popupHtmlGenerator';
 
 type PopupManagerOptions = {
   map: OlMap | null;
@@ -27,6 +30,11 @@ export class PopupManager {
   private map: OlMap | null;
   private popupOverlay: Overlay | null = null;
   private popupElement: HTMLElement | null = null;
+  private batchPopupContainer: HTMLDivElement | null = null;
+  private batchPopupItems: Array<{
+    feature: Feature;
+    element: HTMLDivElement;
+  }> = [];
   private lastHoveredId: string | number | null = null;
   private animationFrameId: number | null = null;
   private getPointLayers: () => VectorLayer<VectorSource>[];
@@ -49,6 +57,11 @@ export class PopupManager {
   // 备注：初始化 Popup Overlay 并挂载到地图实例。
   initPopupOverlay(container: HTMLElement) {
     this.popupElement = container;
+    this.popupElement.style.display = 'none';
+    this.popupElement.style.removeProperty('position');
+    this.popupElement.style.removeProperty('transform');
+    this.popupElement.style.removeProperty('left');
+    this.popupElement.style.removeProperty('top');
     this.popupElement.style.setProperty('pointer-events', 'none', 'important');
     this.popupMouseEnterHandler = () => {
       this.forceHidePopup();
@@ -190,7 +203,7 @@ export class PopupManager {
 
     if (feature && coordinate) {
       const props = feature.getProperties();
-      const popupHtml = props.popupHtml || generatePopupHtml(props);
+      const popupHtml = this.getPopupHtml(props);
 
       if (popupHtml) {
         this.popupElement.innerHTML = popupHtml;
@@ -204,22 +217,37 @@ export class PopupManager {
     this.popupElement.style.display = 'none';
   }
 
+  private getPopupHtml(props: Record<string, any>) {
+    return props.popupHtml || generatePopupHtml(props);
+  }
+
   // 备注：批量显示多个要素的 Popup，使用绝对定位的 div 而非 Overlay。
   showPopupsForFeatures(
     features: Feature[],
-    styleChecker?: (feature: Feature) => boolean
+    styleChecker?: (feature: Feature) => boolean,
+    options?: {
+      rebuild?: boolean;
+    }
   ) {
     if (!this.map || !this.popupElement) return;
-
-    // 清除之前批量显示的 popups
-    this.clearBatchPopups();
+    const shouldRebuild = options?.rebuild !== false;
 
     // 过滤：只显示图例可见的要素
     const visibleFeatures = features.filter(
       f => f.get('_legendVisible') !== false
     );
 
-    if (visibleFeatures.length === 0) return;
+    if (visibleFeatures.length === 0) {
+      this.clearBatchPopups();
+      return;
+    }
+
+    if (!shouldRebuild && this.batchPopupItems.length > 0) {
+      this.updateBatchPopupPositions(styleChecker);
+      return;
+    }
+
+    this.clearBatchPopups();
 
     const mapElement = this.map.getTargetElement();
     const batchContainer = document.createElement('div');
@@ -234,6 +262,7 @@ export class PopupManager {
       z-index: 1000;
     `;
     batchContainer.id = 'batch-popup-container';
+    this.batchPopupContainer = batchContainer;
 
     // 先添加容器到 DOM，以便后续元素能正确测量尺寸
     mapElement.appendChild(batchContainer);
@@ -245,12 +274,6 @@ export class PopupManager {
       top: number;
       bottom: number;
     }> = [];
-    let styleHiddenCount = 0;
-    let blockedCount = 0;
-    let renderedCount = 0;
-    const renderedIds: Array<string | number | null> = [];
-    const blockedIds: Array<string | number | null> = [];
-
     visibleFeatures.forEach(feature => {
       const geom = feature.getGeometry();
       if (!geom || geom.getType() !== 'Point') return;
@@ -261,12 +284,15 @@ export class PopupManager {
 
       // 检查样式是否隐藏（declutter、距离过滤等）
       if (styleChecker && !styleChecker(feature)) {
-        styleHiddenCount += 1;
         return;
       }
 
       const props = feature.getProperties();
-      const popupHtml = props.popupHtml || generatePopupHtml(props);
+      const popupHtml = shouldPreferEng2Popup(props)
+        ? generatePopupHtml(props, { forceEng2: true }) ||
+          props.popupHtml ||
+          generatePopupHtml(props)
+        : this.getPopupHtml(props);
       if (!popupHtml) return;
 
       // 创建与原始 popupElement 完全相同的样式
@@ -314,8 +340,10 @@ export class PopupManager {
         popupEl.style.visibility = 'visible';
         popupEl.style.left = `${popupX}px`;
         popupEl.style.top = `${popupY}px`;
-        renderedCount += 1;
-        renderedIds.push((feature.getId?.() as string | number | null) ?? null);
+        this.batchPopupItems.push({
+          feature,
+          element: popupEl
+        });
 
         placedPopups.push({
           left: popupRect.left,
@@ -325,15 +353,76 @@ export class PopupManager {
         });
       } else {
         // 有碰撞，移除该 popup
-        blockedCount += 1;
-        blockedIds.push((feature.getId?.() as string | number | null) ?? null);
         batchContainer.removeChild(popupEl);
       }
     });
   }
 
+  updateBatchPopupPositions(styleChecker?: (feature: Feature) => boolean) {
+    if (
+      !this.map ||
+      !this.batchPopupContainer ||
+      this.batchPopupItems.length === 0
+    ) {
+      return;
+    }
+
+    const mapSize = this.map.getSize();
+    const viewportWidth = mapSize?.[0] ?? 0;
+    const viewportHeight = mapSize?.[1] ?? 0;
+    const viewportPadding = 48;
+
+    this.batchPopupItems.forEach(({ feature, element }) => {
+      if (feature.get('_legendVisible') === false) {
+        element.style.display = 'none';
+        return;
+      }
+
+      if (styleChecker && !styleChecker(feature)) {
+        element.style.display = 'none';
+        return;
+      }
+
+      const geom = feature.getGeometry();
+      if (!geom || geom.getType() !== 'Point') {
+        element.style.display = 'none';
+        return;
+      }
+
+      const coords = (geom as Point).getCoordinates();
+      const pixel = this.map?.getPixelFromCoordinate(coords);
+      if (!pixel) {
+        element.style.display = 'none';
+        return;
+      }
+
+      const popupX = pixel[0];
+      const popupY = pixel[1] - 10;
+      if (
+        popupX < -viewportPadding ||
+        popupY < -viewportPadding ||
+        popupX > viewportWidth + viewportPadding ||
+        popupY > viewportHeight + viewportPadding
+      ) {
+        element.style.display = 'none';
+        return;
+      }
+
+      element.style.left = `${popupX}px`;
+      element.style.top = `${popupY}px`;
+      element.style.display = 'block';
+    });
+  }
+
   // 备注：清除批量显示的 popups。
   clearBatchPopups() {
+    this.batchPopupItems = [];
+    if (this.batchPopupContainer) {
+      this.batchPopupContainer.remove();
+      this.batchPopupContainer = null;
+      return;
+    }
+
     const existing = document.getElementById('batch-popup-container');
     if (existing) {
       existing.remove();
diff --git a/frontend/src/components/gis/ol/region-mask-manager.ts b/frontend/src/components/gis/ol/region-mask-manager.ts
index 5ca3de85..10989037 100644
--- a/frontend/src/components/gis/ol/region-mask-manager.ts
+++ b/frontend/src/components/gis/ol/region-mask-manager.ts
@@ -209,7 +209,7 @@ export class RegionMaskManager {
   }
 
   // 备注：清除当前底图遮罩并按需恢复默认视野，供切换基地和异常兜底复用。
-  clearMapMask(resetView: boolean = true): void {
+  clearMapMask(resetView = true): void {
     const maskedLayers = this.maskBindings.map(binding => binding.layer);
     this.clearMaskEvents();
 
diff --git a/frontend/src/components/mapFilter/index.vue b/frontend/src/components/mapFilter/index.vue
index 626038af..410568de 100644
--- a/frontend/src/components/mapFilter/index.vue
+++ b/frontend/src/components/mapFilter/index.vue
@@ -110,7 +110,7 @@
   </div>
 </template>
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue';
+import { ref, computed, watch, nextTick } from 'vue';
 import dayjs from 'dayjs';
 import { useRoute } from 'vue-router';
 import { MapClass } from '@/components/gis/map.class';
@@ -118,6 +118,7 @@ import { useMapOrchestrator } from '@/modules/map/application/map-orchestrator';
 import { useMapDataStore } from '@/modules/map/stores/map-data.store';
 import { useMapViewStore } from '@/modules/map/stores/map-view.store';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
+import { useUiStore } from '@/store/modules/ui';
 import { useMapStore } from '@/store/modules/map';
 import { DateSetting } from '@/utils/enumeration';
 import { getFishList, getFishPointList } from '@/api/map';
@@ -126,6 +127,7 @@ const route = useRoute();
 const mapOrchestrator = useMapOrchestrator();
 const mapDataStore = useMapDataStore();
 const mapViewStore = useMapViewStore();
+const uiStore = useUiStore();
 const jidiSelectEventStore = useJidiSelectEventStore();
 const mapStore = useMapStore();
 const mapClass = MapClass.getInstance();
@@ -156,6 +158,7 @@ const fishPointOptions = ref<any[]>([]);
 const fishSpeciesOptions = ref<{ label: string; value: string }[]>([]);
 const fishSpeciesLoading = ref(false);
 const fishPointLoading = ref(false);
+const refocusTimer = ref<ReturnType<typeof setTimeout> | null>(null);
 
 const searchTimeRange = ref([
   dayjs(mapViewStore.searchTimeRange[0]).format('YYYY-MM-DD HH:mm:ss'),
@@ -623,15 +626,48 @@ const handleCapacityChange = (value: string) => {
   mapOrchestrator.changeEngPointCapacity(value);
 };
 
-// 备注：搜索定位只分发定位命令，不在筛选组件里直接操作地图实例。
-const handleAnchorPointChange = (value: string) => {
-  if (!value) return;
+const clearRefocusTimer = () => {
+  if (!refocusTimer.value) {
+    return;
+  }
+  clearTimeout(refocusTimer.value);
+  refocusTimer.value = null;
+};
+
+const focusSelectedAnchorPoint = () => {
+  const selectedValue = anchorPointSelectValue.value;
+  if (!selectedValue) {
+    return;
+  }
+
   mapOrchestrator.focusPoint(
-    value,
+    selectedValue,
     14,
     isFishSurveyMode.value ? anchorPointOptions.value : undefined
   );
 };
+
+// 备注：搜索定位只分发定位命令，不在筛选组件里直接操作地图实例。
+const handleAnchorPointChange = (value: string) => {
+  if (!value) return;
+  focusSelectedAnchorPoint();
+};
+
+watch(
+  () => uiStore.mapSwitchCompletedTick,
+  async (newVal, oldVal) => {
+    if (newVal === oldVal || !anchorPointSelectValue.value) {
+      return;
+    }
+
+    await nextTick();
+    clearRefocusTimer();
+    refocusTimer.value = setTimeout(() => {
+      refocusTimer.value = null;
+      focusSelectedAnchorPoint();
+    }, 120);
+  }
+);
 </script>
 
 <style lang="scss" scoped>
diff --git a/frontend/src/components/mapLegend/index.vue b/frontend/src/components/mapLegend/index.vue
index 64cc3e4d..cb38a655 100644
--- a/frontend/src/components/mapLegend/index.vue
+++ b/frontend/src/components/mapLegend/index.vue
@@ -88,9 +88,7 @@ const hasEnvFac = computed(() =>
 
 const legendItemClick = (item: any) => {
   if (item.parentName == '环保设施') return;
-  if (item.canBeChecked == 0) {
-    return;
-  }
+  if (item.canBeChecked == 0) return;
   if (item.nameEn) {
     mapOrchestrator.toggleLegend(item.nameEn, item.checked == 0 ? 1 : 0);
   }
diff --git a/frontend/src/modules/EnvironmentalQuality/TwoLayers/EnvironmentalQualityTwoLayers.vue b/frontend/src/modules/EnvironmentalQuality/TwoLayers/EnvironmentalQualityTwoLayers.vue
index 912ca453..86ee6a7e 100644
--- a/frontend/src/modules/EnvironmentalQuality/TwoLayers/EnvironmentalQualityTwoLayers.vue
+++ b/frontend/src/modules/EnvironmentalQuality/TwoLayers/EnvironmentalQualityTwoLayers.vue
@@ -4,7 +4,7 @@
         <a-form ref="formRef" :model="formState" layout="inline" class="search-form">
             <a-space wrap>
                 <a-form-item label="所属基地" name="dataDimensionVal">
-                    <a-select v-model:value="formState.dataDimensionVal" placeholder="请选择" style="width: 120px"
+                    <a-select v-model:value="formState.dataDimensionVal" placeholder="请选择" style="width: 140px"
                         show-search :filter-option="filterBaseOption" option-filter-prop="label"
                         @change="handleBaseChange">
                         <a-select-option v-for="item in baseList" :key="item.wbsCode" :value="item.wbsCode"
@@ -32,7 +32,7 @@
                 </a-form-item>
 
                 <a-form-item label="达标状态" name="sfdb">
-                    <a-select v-model:value="formState.sfdb" placeholder="请选择" style="width: 100px" show-search
+                    <a-select v-model:value="formState.sfdb" placeholder="请选择" style="width: 160px" show-search
                         :filter-option="filterOption" option-filter-prop="label">
                         <a-select-option value="" label="全部">全部</a-select-option>
                         <a-select-option value="0" label="不达标">不达标</a-select-option>
@@ -44,12 +44,12 @@
                 <a-form-item label="时间" name="dateValues">
                     <a-date-picker v-model:value="formState.dateValues"
                         :format="formState.types === 'month' ? 'YYYY-MM' : 'YYYY'" :picker="formState.types"
-                        placeholder="请选择月份" style="width: 140px" :disabled-date="disabledMonthDate" />
+                        placeholder="请选择月份" style="width: 100px" :disabled-date="disabledMonthDate" />
 
                 </a-form-item>
 
                 <a-form-item label="断面名称" name="stnm">
-                    <a-input v-model:value="formState.stnm" placeholder="请输入断面名称" style="width: 200px" allow-clear />
+                    <a-input v-model:value="formState.stnm" placeholder="请输入断面名称" style="width: 180px" allow-clear />
                 </a-form-item>
 
                 <a-form-item>
@@ -90,7 +90,7 @@
         <!-- 详情弹窗 -->
         <a-modal v-model:open="detailModalVisible" :title="`${detailData.stnm || ''} 详细信息`" width="1536px" :footer="null"
             @cancel="handleDetailModalClose">
-            <HJMZDTwoLays :tc="{
+            <HJMZDTwoLays v-if="detailModalVisible" :tc="{
                 stcd: detailData.stcd || '',
                 startTime: detailData.tm,
                 endTime: (typeof detailData.tm === 'string' ? detailData.tm.split(' ')[0] : dayjs(detailData.tm).format('YYYY-MM-DD')) + ' 23:59:59',
@@ -231,7 +231,7 @@ const columns = [
         title: '断面名称',
         dataIndex: 'stnm',
         key: 'stnm',
-        width: 180,
+        width: 200,
         ellipsis: true,
         customCell: (record: any, rowIndex: number) => {
             const tableData = tableRef.value?.tableData || []
@@ -243,13 +243,13 @@ const columns = [
         title: '测站类型',
         dataIndex: 'sttypeName',
         key: 'sttypeName',
-        width: 120
+        width: 80
     },
     {
         title: '达标状态',
         dataIndex: 'sfdbName',
         key: 'sfdbName',
-        width: 120,
+        width: 80,
         customRender: ({ record }: any) => {
             const sfdb = record.sfdbName
             let color = '#000000'
@@ -267,19 +267,19 @@ const columns = [
         title: '水质要求',
         dataIndex: 'wwqtgName',
         key: 'wwqtgName',
-        width: 120
+        width: 80
     },
     {
         title: '当前水质',
         dataIndex: 'wqGrdName',
         key: 'wqGrdName',
-        width: 120
+        width: 80
     },
     {
         title: '去年同期水质',
         dataIndex: 'beforeWqGrdName',
         key: 'beforeWqGrdName',
-        width: 150
+        width: 140
     },
     {
         title: '操作',
@@ -674,7 +674,7 @@ const handleReset = () => {
     formState.dtinType = ''
     formState.types = props.type || 'month'
     formState.sfdb = ''
-    formState.dateValues = dayjs()
+    formState.dateValues =props.dateValue ? (typeof props.dateValue === 'string' ? dayjs(props.dateValue, props.type === 'month' ? 'YYYY-MM' : 'YYYY') : props.dateValue) : dayjs(),
     formState.stnm = ''
     pieCode.value = []
 
diff --git a/frontend/src/modules/EnvironmentalQuality/TwoLayers/HJMZDTwoLays.vue b/frontend/src/modules/EnvironmentalQuality/TwoLayers/HJMZDTwoLays.vue
index d89fd1b2..33d3ab2a 100644
--- a/frontend/src/modules/EnvironmentalQuality/TwoLayers/HJMZDTwoLays.vue
+++ b/frontend/src/modules/EnvironmentalQuality/TwoLayers/HJMZDTwoLays.vue
@@ -13,7 +13,7 @@
           v-model:value="formState.sfdb"
           placeholder="请选择"
           allow-clear
-          style="width: 150px"
+          style="width: 160px"
         >
           <a-select-option value="">全部</a-select-option>
           <a-select-option :value="'0'">不达标</a-select-option>
@@ -114,7 +114,8 @@ const columnList = [
     elementCode: '',
     disabledDate: true,
     sorter: true,
-    multiLink: false
+    multiLink: false,
+    width: 160
   },
   {
     dataIndexRaw: '',
@@ -558,18 +559,18 @@ const transUnit = (value: any, tbCode: string, ys: string) => {
 // ==================== 监听器 ====================
 
 // 监听 tc 和 formState.sfdb 变化，重新获取列配置
-watch(
-  () => [props.tc.stcd, props.tc.startTime, props.tc.endTime, formState.sfdb],
-  ([stcd, startTime, endTime]) => {
-    if (!stcd) {
-      return;
-    }
-    // 
-    tableRef.value.tableData = [];
-    getCol({ stcd, startTime, endTime });
-  },
-  { immediate: false } // 不在初始化时立即执行，由 onMounted 处理
-);
+// watch(
+//   () => [props.tc.stcd, props.tc.startTime, props.tc.endTime, formState.sfdb],
+//   ([stcd, startTime, endTime]) => {
+//     if (!stcd) {
+//       return;
+//     }
+//     // 
+//     tableRef.value.tableData = [];
+//     getCol({ stcd, startTime, endTime });
+//   },
+//   { immediate: false } // 不在初始化时立即执行，由 onMounted 处理
+// );
 
 // 初始化
 onMounted(() => {
diff --git a/frontend/src/modules/diwenshuijianhuansheshileixingzuchengjijieruqingkuang/TwoLayers/diwenshuijianhuansheshileixingzuchengjijieruqingkuangTwoLayers.vue b/frontend/src/modules/diwenshuijianhuansheshileixingzuchengjijieruqingkuang/TwoLayers/diwenshuijianhuansheshileixingzuchengjijieruqingkuangTwoLayers.vue
index b3cc5aa9..eb6b93a0 100644
--- a/frontend/src/modules/diwenshuijianhuansheshileixingzuchengjijieruqingkuang/TwoLayers/diwenshuijianhuansheshileixingzuchengjijieruqingkuangTwoLayers.vue
+++ b/frontend/src/modules/diwenshuijianhuansheshileixingzuchengjijieruqingkuang/TwoLayers/diwenshuijianhuansheshileixingzuchengjijieruqingkuangTwoLayers.vue
@@ -167,6 +167,7 @@ const columns = [
         dataIndex: 'dtinTm',
         key: 'dtinTm',
         width: 120,
+         sort: true, // 启用排序
         customRender: ({ record }: any) => {
             const date = record.dtinTm
             if (!date) return '-'
@@ -192,6 +193,7 @@ const columns = [
         dataIndex: 'ststdt',
         key: 'ststdt',
         width: 120,
+         sort: true, // 启用排序
         customRender: ({ record }: any) => {
             const date = record.ststdt
             if (!date) return '-'
@@ -211,6 +213,7 @@ const columns = [
         dataIndex: 'jcdt',
         key: 'jcdt',
         width: 120,
+         sort: true, // 启用排序
         customRender: ({ record }: any) => {
             const date = record.jcdt
             if (!date) return '-'
diff --git a/frontend/src/modules/huanbaozdjcgzkzQK/huanbaozidongjianceEJ/index.vue b/frontend/src/modules/huanbaozdjcgzkzQK/huanbaozidongjianceEJ/index.vue
index d48f56b8..02cc7d52 100644
--- a/frontend/src/modules/huanbaozdjcgzkzQK/huanbaozidongjianceEJ/index.vue
+++ b/frontend/src/modules/huanbaozdjcgzkzQK/huanbaozidongjianceEJ/index.vue
@@ -48,7 +48,7 @@
       ref="tableRef"
       :scrollY="400"
       :columns="columns"
-      :list-url="vmsstbprptGetKendoList"
+      :list-url="overviewvmsstbprptGetKendoList"
       :search-params="searchParams"
       :transform-data="customTransform"
     >
@@ -73,8 +73,10 @@
 </template>
 
 <script lang="ts" setup>
-import { ref, computed, onMounted } from 'vue';
-import { vmsstbprptGetKendoList } from '@/api/home';
+import { ref, computed, onMounted, h } from 'vue';
+import { Tooltip } from 'ant-design-vue';
+import { QuestionCircleOutlined } from '@ant-design/icons-vue';
+import { vmsstbprptGetKendoList,overviewvmsstbprptGetKendoList } from '@/api/home';
 import BasicTable from '@/components/BasicTable/index.vue';
 import { useModelStore } from '@/store/modules/model';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
@@ -144,10 +146,9 @@ const columns = computed(() => {
       },
       {
         key: 'coenvwState',
-        title: '监测状态',
+        title: h(Tooltip, { title: '最近1天有监测数据为在线，否则为离线' }, { default: () => h('span', null, ['监测状态', h(QuestionCircleOutlined, { style: { marginLeft: '4px', color: '#000' } })]) }),
         dataIndex: 'coenvwState',
         width: '120px',
-
         slots: { customRender: 'coenvwState' }
       },
       {
@@ -203,7 +204,7 @@ const columns = computed(() => {
   if (tabIndex.value !== '4') {
     baseColumns.push({
       key: 'coenvwState',
-      title: '监测状态',
+      title: h(Tooltip, { title: '最近1天有监测数据为在线，否则为离线' }, { default: () => h('span', null, ['监测状态', h(QuestionCircleOutlined, { style: { marginLeft: '4px', color: '#999' } })]) }),
       dataIndex: 'coenvwState',
       width: '120px',
       slots: { customRender: 'coenvwState' }
@@ -313,7 +314,7 @@ const getRstcdData = async () => {
     ],
     select: ['stcd', 'stnm']
   };
-  const res = await vmsstbprptGetKendoList(parmas);
+  const res = await overviewvmsstbprptGetKendoList(parmas);
   rstcdOptions.value = res.data.data.map((item) => {
     return {
       value: item.stcd,
diff --git a/frontend/src/modules/jidiSelectorMod.vue b/frontend/src/modules/jidiSelectorMod.vue
index d0d19ebe..2c9ae4fc 100644
--- a/frontend/src/modules/jidiSelectorMod.vue
+++ b/frontend/src/modules/jidiSelectorMod.vue
@@ -1,7 +1,6 @@
 <script setup lang="ts">
 import { onMounted, ref } from 'vue';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
-const loading = ref(false);
 const isOpen = ref(true);
 const JidiSelectEventStore = useJidiSelectEventStore();
 
diff --git a/frontend/src/modules/liuyu/ai/spdzwaijc/AISPTK.vue b/frontend/src/modules/liuyu/ai/spdzwaijc/AISPTK.vue
index 306ae0fe..05db5b8a 100644
--- a/frontend/src/modules/liuyu/ai/spdzwaijc/AISPTK.vue
+++ b/frontend/src/modules/liuyu/ai/spdzwaijc/AISPTK.vue
@@ -317,7 +317,7 @@ import dayjs from 'dayjs';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
 import videoCover from '@/assets/images/videFm.jpg';
 import { useDraggable } from '@/utils/drag';
-;
+
 const baseUrl = import.meta.env.VITE_APP_ATTACHMENT_URL;
 
 // ==================== Props ====================
diff --git a/frontend/src/modules/liuyu/yichangyujing/shengtailiuliangxianzhigaojing/ModeGaoJing.vue b/frontend/src/modules/liuyu/yichangyujing/shengtailiuliangxianzhigaojing/ModeGaoJing.vue
index fbc2a9a9..6bc70aaa 100644
--- a/frontend/src/modules/liuyu/yichangyujing/shengtailiuliangxianzhigaojing/ModeGaoJing.vue
+++ b/frontend/src/modules/liuyu/yichangyujing/shengtailiuliangxianzhigaojing/ModeGaoJing.vue
@@ -33,9 +33,12 @@
       <a-form-item>
         <a-button type="primary" @click="handleSearch">查询</a-button>
         <!-- <a-button style="margin-left: 8px" @click="handleReset">重置</a-button> -->
-        <a-tooltip title="导出（暂未实现）">
-          <a-button style="margin-left: 8px">导出</a-button>
-        </a-tooltip>
+          <a-button
+            style="margin-left: 8px"
+            @click="handleExport"
+            :loading="exportLoading"
+            >导出</a-button
+          >
       </a-form-item>
     </a-form>
 
@@ -66,11 +69,12 @@
 </template>
 
 <script lang="ts" setup>
-import { ref, computed, reactive, watch,onMounted } from 'vue';
+import { ref, computed, reactive, watch, onMounted } from 'vue';
 import BasicTable from '@/components/BasicTable/index.vue';
 import { getStllGaojingDetail } from '@/api/zngj';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
 import { useModelStore } from '@/store/modules/model';
+import dayjs, { Dayjs } from 'dayjs';
 defineOptions({
   name: 'ModeGaoJing'
 });
@@ -262,11 +266,24 @@ const opentan = (record: any) => {
   modelStore.title = record.ennm;
   modelStore.params.stcd = record.rstcd;
 };
+/* 导出逻辑 */
+const exportLoading = ref(false);
+const handleExport = () => {
+  exportLoading.value = true;
+
+  tableRef.value
+    .exportTable({
+      fileName: `生态流量低于限值告警统计_${dayjs().format('YYYY-MM-DD HH-mm-ss')}`
+    })
+    .finally(() => {
+      exportLoading.value = false;
+    });
+};
 // 初始化加载数据
 // handleSearch();
 onMounted(() => {
   handleSearch();
-}); 
+});
 </script>
 
 <style lang="scss" scoped>
@@ -283,7 +300,6 @@ onMounted(() => {
 
   .table-wrapper {
     flex: 1;
-
   }
 }
 </style>
diff --git a/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/ModeGaoJing.vue b/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/ModeGaoJing.vue
index 091f12c0..7f10a256 100644
--- a/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/ModeGaoJing.vue
+++ b/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/ModeGaoJing.vue
@@ -32,6 +32,12 @@
       </a-form-item>
       <a-form-item>
         <a-button type="primary" @click="handleSearch">查询</a-button>
+        <a-button
+            style="margin-left: 8px"
+            @click="handleExport"
+            :loading="exportLoading"
+            >导出</a-button
+          >
       </a-form-item>
     </a-form>
 
@@ -67,7 +73,7 @@ import BasicTable from '@/components/BasicTable/index.vue';
 import { getStllGaojingDetail } from '@/api/zngj';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
 import { useModelStore } from '@/store/modules/model';
-
+import dayjs, { Dayjs } from 'dayjs';
 defineOptions({
   name: 'ModeGaoJing'
 });
@@ -266,6 +272,19 @@ const opentan = (record: any) => {
   modelStore.title = record.ennm;
   modelStore.params.stcd = record.rstcd;
 };
+/* 导出逻辑 */
+const exportLoading = ref(false);
+const handleExport = () => {
+  exportLoading.value = true;
+
+  tableRef.value
+    .exportTable({
+      fileName: `生态流量低于限值告警统计_${dayjs().format('YYYY-MM-DD HH-mm-ss')}`
+    })
+    .finally(() => {
+      exportLoading.value = false;
+    });
+};
 onMounted(() => {
   handleSearch();
 });
diff --git a/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/shuizhijianceshuju.vue b/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/shuizhijianceshuju.vue
index 62fbf3f2..75027bcd 100644
--- a/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/shuizhijianceshuju.vue
+++ b/frontend/src/modules/liuyu/yichangyujing/shuizhijiancegaojing/shuizhijianceshuju.vue
@@ -1,47 +1,63 @@
 <!-- SidePanelItem.vue -->
 <template>
-    <div>
-        <SidePanelItem title="水质监测数据告警情况" :select="select" @update-values="handlePanelChange">
-            <a-spin :spinning="dataLoading" tip="加载中...">
-                <div class="body_box">
-                    <div class="box" v-for="(item, index) in data" :key="index" @click="handleCardClick(item.warnState)" style="cursor: pointer;">
-                        <div>
-                            <div :class="item.icon" :style="{background:item.background}"></div>
-                            <div class="title_text">{{ item.name }}</div>
-                        </div>
-                        <div><span class="text_num">{{ item.num }}</span><span>座</span></div>
-                    </div>
-                </div>
-            </a-spin>
-        </SidePanelItem>
+  <div>
+    <SidePanelItem
+      title="水质监测数据告警情况"
+      :select="select"
+      @update-values="handlePanelChange"
+    >
+      <a-spin :spinning="dataLoading" tip="加载中...">
+        <div class="body_box">
+          <div
+            class="box"
+            v-for="(item, index) in data"
+            :key="index"
+            @click="handleCardClick(item.warnState)"
+            style="cursor: pointer"
+          >
+            <div>
+              <div
+                :class="item.icon"
+                :style="{ background: item.background }"
+              ></div>
+              <div class="title_text">{{ item.name }}</div>
+            </div>
+            <div>
+              <span class="text_num">{{ item.num }}</span
+              ><span>座</span>
+            </div>
+          </div>
+        </div>
+      </a-spin>
+    </SidePanelItem>
 
-        <a-modal
-            v-model:open="modalVisible"
-            title="水质监测告警统计"
-            width="1536px"
-            :footer="null"
-            @cancel="handleModalClose"
-        >
-            <ModeGaoJing
-                v-if="modalVisible"
-                :baseId="baseid"
-                :warnState="currentWarnState"
-                :dtinType="defaultValue"
-            />
-        </a-modal>
-    </div>
+    <a-modal
+      v-model:open="modalVisible"
+      title="水质监测告警统计"
+      width="1536px"
+      :footer="null"
+      @cancel="handleModalClose"
+    >
+      <ModeGaoJing
+        v-if="modalVisible"
+        :baseId="baseid"
+        :warnState="currentWarnState"
+        :dtinType="defaultValue"
+      />
+    </a-modal>
+  </div>
 </template>
 
 <script lang="ts" setup>
-import { ref, watch } from "vue";
+import { ref, watch } from 'vue';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
-import SidePanelItem from "@/components/SidePanelItem/index.vue";
+import SidePanelItem from '@/components/SidePanelItem/index.vue';
 import { getShuizhiGaojingList } from '@/api/zngj';
 import ModeGaoJing from './ModeGaoJing.vue';
 import { useDraggable } from '@/utils/drag';
 
 defineOptions({
-    name: "shuizhijianceshuju",
+  name: 'shuizhijianceshuju'
 });
 
 const JidiSelectEventStore = useJidiSelectEventStore();
@@ -54,222 +70,224 @@ const modalVisible = ref(false);
 const currentWarnState = ref('');
 useDraggable(modalVisible, { boundary: true, resetOnOpen: true });
 const handleCardClick = (warnState: string) => {
-    currentWarnState.value = warnState;
-    modalVisible.value = true;
+  currentWarnState.value = warnState;
+  modalVisible.value = true;
 };
 
 const handleModalClose = () => {
-    modalVisible.value = false;
+  modalVisible.value = false;
 };
 
 const select = ref({
-    show: true,
-    value: '0',
-    options: [
-        { label: '全部', value: '' },
-        { label: '国家站', value: '1' },
-        { label: '自建站', value: '0' },
-    ],
-    width: '140px',
-    minWidth: '140px',
+  show: true,
+  value: '0',
+  options: [
+    { label: '全部', value: '' },
+    { label: '国家站', value: '1' },
+    { label: '自建站', value: '0' }
+  ],
+  width: '140px',
+  minWidth: '140px'
 });
 
 const data = ref([
-    {
+  {
+    name: '正常',
+    num: '0',
+    warnState: '1',
+    icon: 'iconfont icon-map-rgszzDabiao zhuangji',
+    background: '#78c300'
+  },
+  {
+    name: '告警',
+    num: '0',
+    warnState: '2',
+    icon: 'iconfont icon-map-rgszzDabiao shebeiZhengchang',
+    background: '#e55555'
+  },
+  {
+    name: '无数据',
+    num: '0',
+    warnState: '0',
+    icon: 'iconfont icon-map-rgszzDabiao shebeiLixian',
+    background: '#8d8d8d'
+  }
+]);
+
+const handlePanelChange = (payload: any) => {
+  if (payload.select !== undefined) {
+    defaultValue.value = payload.select;
+    select.value.value = payload.select;
+  }
+  getCardData();
+};
+
+const getCardData = async () => {
+  if (!baseid.value) return;
+
+  dataLoading.value = true;
+
+  try {
+    const filters: any[] = [
+      {
+        field: 'sttpCode',
+        operator: 'in',
+        dataType: 'string',
+        value: ['WQ']
+      },
+      {
+        field: 'mway',
+        operator: 'eq',
+        dataType: 'number',
+        value: 2
+      },
+      {
+        field: 'usfl',
+        operator: 'eq',
+        dataType: 'string',
+        value: '1'
+      },
+      baseid.value != 'all'
+        ? {
+            field: 'baseId',
+            operator: 'eq',
+            dataType: 'string',
+            value: baseid.value
+          }
+        : null
+    ].filter(Boolean);
+
+    if (defaultValue.value === '') {
+      filters.push({
+        field: 'dtinType',
+        operator: 'in',
+        dataType: 'number',
+        value: [0, 1]
+      });
+    } else {
+      filters.push({
+        field: 'dtinType',
+        operator: 'eq',
+        dataType: 'number',
+        value: Number(defaultValue.value)
+      });
+    }
+
+    const params = {
+      filter: {
+        logic: 'and',
+        filters
+      },
+      group: [
+        {
+          dir: 'desc',
+          field: 'warnState',
+          aggregates: [
+            {
+              field: 'stcd',
+              aggregate: 'count'
+            }
+          ]
+        }
+      ],
+      select: []
+    };
+
+    const res = await getShuizhiGaojingList(params);
+    const list = res?.data?.data || [];
+    // debugger
+    const result = {
+      normal: 0,
+      abnormal: 0,
+      noData: 0
+    };
+
+    list.forEach((item: any) => {
+      const warnState = item.items?.[0]?.WARNSTATE;
+      const count = item.items?.[0]?.COUNT_STCD ?? 0;
+      if (warnState == 0) result.noData = count;
+      else if (warnState == 1) result.normal = count;
+      else if (warnState == 2) result.abnormal = count;
+    });
+
+    data.value = [
+      {
         name: '正常',
         num: '0',
         warnState: '1',
         icon: 'iconfont icon-map-rgszzDabiao zhuangji',
-        background: '#78c300',
-    },
-    {
+        background: '#78c300'
+      },
+      {
         name: '告警',
         num: '0',
         warnState: '2',
         icon: 'iconfont icon-map-rgszzDabiao shebeiZhengchang',
-        background: '#e55555',
-    },
-    {
+        background: '#e55555'
+      },
+      {
         name: '无数据',
         num: '0',
         warnState: '0',
         icon: 'iconfont icon-map-rgszzDabiao shebeiLixian',
-        background: '#8d8d8d',
-    },
-]);
-
-const handlePanelChange = (payload: any) => {
-    if (payload.select !== undefined) {
-        defaultValue.value = payload.select;
-        select.value.value = payload.select;
-    }
-    getCardData();
-};
-
-const getCardData = async () => {
-    if (!baseid.value) return;
-
-    dataLoading.value = true;
-
-    try {
-        const filters: any[] = [
-            {
-                field: 'sttpCode',
-                operator: 'in',
-                dataType: 'string',
-                value: ['WQ'],
-            },
-            {
-                field: 'mway',
-                operator: 'eq',
-                dataType: 'number',
-                value: 2,
-            },
-            {
-                field: 'usfl',
-                operator: 'eq',
-                dataType: 'string',
-                value: '1',
-            },
-           baseid.value !='all'? {
-                field: 'baseId',
-                operator: 'eq',
-                dataType: 'string',
-                value: baseid.value,
-            }: null,
-        ].filter(Boolean);
-
-        if (defaultValue.value === '') {
-            filters.push({
-                field: 'dtinType',
-                operator: 'in',
-                dataType: 'number',
-                value: [0, 1],
-            });
-        } else {
-            filters.push({
-                field: 'dtinType',
-                operator: 'eq',
-                dataType: 'number',
-                value: Number(defaultValue.value),
-            });
-        }
-
-        const params = {
-            filter: {
-                logic: 'and',
-                filters,
-            },
-            group: [
-                {
-                    dir: 'desc',
-                    field: 'warnState',
-                    aggregates: [
-                        {
-                            field: 'stcd',
-                            aggregate: 'count',
-                        },
-                    ],
-                },
-            ],
-            select: [],
-        };
-
-        const res = await getShuizhiGaojingList(params);
-        const list = res?.data?.data || [];
-        // debugger
-        const result = {
-            normal: 0,
-            abnormal: 0,
-            noData: 0,
-        };
-
-        list.forEach((item: any) => {
-            const warnState = item.items?.[0]?.WARNSTATE;
-            const count = item.items?.[0]?.COUNT_STCD ?? 0;
-            if (warnState == 0) result.noData = count;
-            else if (warnState == 1) result.normal = count;
-            else if (warnState == 2) result.abnormal = count;
-        });
-
-        data.value = [
-            {
-                name: '正常',
-                num: result.normal.toString(),
-                warnState: '1',
-                icon: 'iconfont icon-shuidianzhan1 zhuangji',
-                background: '#78c300',
-            },
-            {
-                name: '告警',
-                num: result.abnormal.toString(),
-                warnState: '2',
-                icon: 'iconfont icon-shuidianzhanGaojing shebeiZhengchang',
-                background: '#e55555',
-            },
-            {
-                name: '无数据',
-                num: result.noData.toString(),
-                warnState: '0',
-                icon: 'iconfont icon-shuidianzhanWushujv shebeiLixian',
-                background: '#8d8d8d',
-            },
-        ];
-    } catch (error) {
-        console.error('获取水质监测告警数据失败:', error);
-    } finally {
-        dataLoading.value = false;
-    }
+        background: '#8d8d8d'
+      }
+    ];
+  } catch (error) {
+    console.error('获取水质监测告警数据失败:', error);
+  } finally {
+    dataLoading.value = false;
+  }
 };
 
 watch(
-    () => JidiSelectEventStore.selectedItem,
-    async newVal => {
-        if (newVal && newVal.wbsCode) {
-            baseid.value = newVal.wbsCode;
-            getCardData();
-        }
-    },
-    { deep: true, immediate: true }
+  () => JidiSelectEventStore.selectedItem,
+  async newVal => {
+    if (newVal && newVal.wbsCode) {
+      baseid.value = newVal.wbsCode;
+      getCardData();
+    }
+  },
+  { deep: true, immediate: true }
 );
 </script>
 
 <style lang="scss">
 .body_box {
-    width: 100%;
-    height: 132px;
+  width: 100%;
+  height: 132px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+
+  .box {
+    width: 126px;
+    height: 116px;
+    border: 1px solid rgba(108, 164, 247, 0.35);
     display: flex;
+    justify-content: center;
+    flex-direction: column;
     align-items: center;
-    justify-content: space-between;
 
-    .box {
-        width: 126px;
-        height: 116px;
-        border: 1px solid rgba(108, 164, 247, 0.35);
-        display: flex;
-        justify-content: center;
-        flex-direction: column;
-        align-items: center;
-
-        .iconfont {
-            width: 40px;
-            height: 40px;
-            background: #78c300;
-            border-radius: 50%;
-            text-align: center;
-            line-height: 40px;
-            font-size: 24px;
-            color: #fff;
-        }
-        .title_text{
-            width: 100%;
-            text-align: center;
-        }
-        .text_num{
-            width: 100%;
-            text-align: center;
-            font-size: 24px;
-        }
+    .iconfont {
+      width: 40px;
+      height: 40px;
+      background: #78c300;
+      border-radius: 50%;
+      text-align: center;
+      line-height: 40px;
+      font-size: 24px;
+      color: #fff;
     }
+    .title_text {
+      width: 100%;
+      text-align: center;
+    }
+    .text_num {
+      width: 100%;
+      text-align: center;
+      font-size: 24px;
+    }
+  }
 }
 </style>
diff --git a/frontend/src/modules/lushengshengtaijiance/index.vue b/frontend/src/modules/lushengshengtaijiance/index.vue
index a83c03fa..abc52cf1 100644
--- a/frontend/src/modules/lushengshengtaijiance/index.vue
+++ b/frontend/src/modules/lushengshengtaijiance/index.vue
@@ -63,7 +63,7 @@
 
 <script lang="ts" setup>
 import { ref, onMounted, onUnmounted, nextTick,watch } from 'vue';
-import { ref, watch } from 'vue';
+// import { ref, watch } from 'vue';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
 import SidePanelItem from '@/components/SidePanelItem/index.vue';
 import LsstjkTk from './LsstjkTk.vue';
diff --git a/frontend/src/modules/map/application/map-orchestrator.ts b/frontend/src/modules/map/application/map-orchestrator.ts
index 3e0d783d..4c0ff19e 100644
--- a/frontend/src/modules/map/application/map-orchestrator.ts
+++ b/frontend/src/modules/map/application/map-orchestrator.ts
@@ -43,6 +43,7 @@ const HYDRO_DYNAMIC_LAYER_KEYS = [
 ];
 const ENG_POINT_LAYER_KEY = 'eng_point';
 const ENG_POINT_MEDIUM_VISIBLE_ZOOM = 7.5;
+const CESIUM_ZOOM_SYNC_DEBOUNCE_MS = 80;
 const LARGE_ENG_LEGEND_PREFIX = 'large_eng_';
 const MID_ENG_LEGEND_PREFIX = 'mid_eng_';
 
@@ -55,12 +56,20 @@ export const useMapOrchestrator = () => {
   const mapViewStore = useMapViewStore();
   const jidiSelectEventStore = useJidiSelectEventStore();
   let activePageLoadRequestId = 0;
-  let zoomListenerKey: any = null;
+  let removeZoomListener: (() => void) | null = null;
   let stopBaseSelectionWatch: WatchStopHandle | null = null;
   const initializedBaseLayerKeys = new Set<string>();
   const baseSelectionDebounceTimer = ref<ReturnType<typeof setTimeout> | null>(
     null
   );
+  const zoomSyncDebounceTimer = ref<ReturnType<typeof setTimeout> | null>(null);
+  let latestHydroMenuGetter: (() => boolean) | null = null;
+  let currentMapType: '2D' | '3D' = '2D';
+  let hydroMenuDefaultCheckedKeys = new Set<string>();
+  let hydroDynamicLayerSyncTask: {
+    visible: boolean;
+    promise: Promise<string[] | void>;
+  } | null = null;
 
   // 备注：统一获取当前地图视图对象，避免在多个组件里重复兼容 2D/3D view 访问方式。
   const getCurrentView = () => {
@@ -69,7 +78,14 @@ export const useMapOrchestrator = () => {
 
   // 备注：统一获取当前地图缩放级别，供页面切换和缩放监听复用。
   const getCurrentZoom = (): number | undefined => {
-    return getCurrentView()?.getZoom?.();
+    return mapClass.getCurrentZoom();
+  };
+
+  const clearZoomSyncDebounceTimer = () => {
+    if (zoomSyncDebounceTimer.value) {
+      clearTimeout(zoomSyncDebounceTimer.value);
+      zoomSyncDebounceTimer.value = null;
+    }
   };
 
   // 备注：统一把当前页面中的 GIS 基础图层初始化到地图实例，避免在图层树组件里做配置解析和加层编排。
@@ -95,7 +111,20 @@ export const useMapOrchestrator = () => {
       }
 
       if (item.key === 'customBaseLayer') {
-        sessionStorage.setItem('customBaseLayer', JSON.stringify(item.config));
+        const serializableBaseLayerConfig = {
+          key: item.config?.key,
+          id: item.config?.id,
+          name: item.config?.name,
+          type: item.config?.type,
+          url: item.config?.url,
+          url_3d: item.config?.url_3d,
+          layers: item.config?.layers,
+          rasteropacity: item.config?.rasteropacity
+        };
+        sessionStorage.setItem(
+          'customBaseLayer',
+          JSON.stringify(serializableBaseLayerConfig)
+        );
       }
 
       if (!initializedBaseLayerKeys.has(item.key)) {
@@ -154,6 +183,9 @@ export const useMapOrchestrator = () => {
 
       // 先设置图层数据（更新 checkedLayerKeys），再设置图例数据
       if (layerConfig.length > 0) {
+        hydroMenuDefaultCheckedKeys = new Set(
+          mapConfigStore.extractCheckedLayerKeys(layerConfig)
+        );
         mapStore.setLayerData(layerConfig);
         ensureBaseLayersInitialized(layerConfig);
 
@@ -229,10 +261,56 @@ export const useMapOrchestrator = () => {
     await mapClass.init(container);
 
     if (popupContainer) {
+      const popupHost = container.parentElement;
+      if (popupHost && popupContainer.parentElement !== popupHost) {
+        popupHost.appendChild(popupContainer);
+      }
+      popupContainer.style.display = 'none';
       mapClass.initPopupOverlay(popupContainer);
     }
   };
 
+  const replayCurrentMapState = async (
+    options: Pick<InitializeOptions, 'popupContainer'> & {
+      getIsHydroMenu: () => boolean;
+    }
+  ) => {
+    initializedBaseLayerKeys.clear();
+
+    const currentZoom = getCurrentZoom();
+    if (currentZoom !== undefined) {
+      mapViewStore.setCurrentZoomLevel(currentZoom);
+    }
+
+    if (options.popupContainer) {
+      const container = document.getElementById('mapContainer');
+      const popupHost = container?.parentElement || null;
+      if (popupHost && options.popupContainer.parentElement !== popupHost) {
+        popupHost.appendChild(options.popupContainer);
+      }
+      options.popupContainer.style.display = 'none';
+      mapClass.initPopupOverlay(options.popupContainer);
+    }
+
+    ensureBaseLayersInitialized(mapStore.layerData || []);
+
+    const checkedKeys = mapViewStore.getCheckedLayerKeys();
+    await mapStore.updateLayerData(checkedKeys, true);
+    mapStore.setSelectedLegendData();
+    await syncZoomSensitiveState({
+      isHydroMenu: options.getIsHydroMenu(),
+      refreshEngPoint: true
+    });
+
+    const selectedBaseId = mapViewStore.selectedBaseId;
+    mapClass.jdPanelControlShowAndHidden(
+      selectedBaseId || 'all',
+      !!selectedBaseId
+    );
+
+    bindZoomListener(options.getIsHydroMenu);
+  };
+
   // 备注：统一完成首屏页面配置加载，供挂载阶段和后续页面重载复用。
   const initialize = async ({
     container,
@@ -249,20 +327,18 @@ export const useMapOrchestrator = () => {
 
   // 备注：统一绑定地图缩放监听，让页面组件只负责触发初始化，不再直接处理缩放联动细节。
   const bindZoomListener = (getIsHydroMenu: () => boolean) => {
-    if (zoomListenerKey) {
-      unByKey(zoomListenerKey);
-      zoomListenerKey = null;
+    if (removeZoomListener) {
+      removeZoomListener();
+      removeZoomListener = null;
     }
-
-    const view = getCurrentView();
-    if (!view?.on) return;
+    clearZoomSyncDebounceTimer();
 
     const currentZoom = getCurrentZoom();
     if (currentZoom !== undefined) {
       mapViewStore.setCurrentZoomLevel(currentZoom);
     }
 
-    zoomListenerKey = view.on('change:resolution', async () => {
+    const emitZoomChange = async () => {
       const zoom = getCurrentZoom();
       if (zoom === undefined) return;
 
@@ -271,7 +347,36 @@ export const useMapOrchestrator = () => {
         zoom,
         getIsHydroMenu()
       );
+    };
+
+    if (currentMapType === '3D') {
+      const removeCesiumListener =
+        mapClass.view?.camera?.changed?.addEventListener(() => {
+          clearZoomSyncDebounceTimer();
+          zoomSyncDebounceTimer.value = setTimeout(() => {
+            zoomSyncDebounceTimer.value = null;
+            void emitZoomChange();
+          }, CESIUM_ZOOM_SYNC_DEBOUNCE_MS);
+        });
+
+      if (typeof removeCesiumListener === 'function') {
+        removeZoomListener = () => {
+          clearZoomSyncDebounceTimer();
+          removeCesiumListener();
+        };
+      }
+      return;
+    }
+
+    const view = getCurrentView();
+    if (!view?.on) return;
+
+    const zoomListenerKey = view.on('change:resolution', () => {
+      void emitZoomChange();
     });
+    removeZoomListener = () => {
+      unByKey(zoomListenerKey);
+    };
   };
 
   // 备注：统一绑定基地切换事件，让页面组件不再直接 watch 外部基地选择源。
@@ -308,10 +413,34 @@ export const useMapOrchestrator = () => {
       getIsHydroMenu: () => boolean;
     }
   ) => {
+    currentMapType = '2D';
+    latestHydroMenuGetter = options.getIsHydroMenu;
     await initializeMapShell(options);
     bindBaseSelection();
     bindZoomListener(options.getIsHydroMenu);
     await loadPage({ pageKey: options.pageKey, isInitialLoad: true });
+    await syncZoomSensitiveState({
+      isHydroMenu: options.getIsHydroMenu(),
+      refreshEngPoint: true
+    });
+  };
+
+  const switchMapType = async (
+    type: '2D' | '3D',
+    options: Pick<InitializeOptions, 'popupContainer'> & {
+      getIsHydroMenu?: () => boolean;
+    } = {}
+  ) => {
+    const hydroMenuGetter =
+      options.getIsHydroMenu || latestHydroMenuGetter || (() => false);
+    latestHydroMenuGetter = hydroMenuGetter;
+    currentMapType = type;
+
+    await mapClass.switchView(type);
+    await replayCurrentMapState({
+      popupContainer: options.popupContainer,
+      getIsHydroMenu: hydroMenuGetter
+    });
   };
 
   // 备注：统一处理菜单切换后的页面配置重载，供页面 watch 直接复用。
@@ -361,47 +490,91 @@ export const useMapOrchestrator = () => {
         (layer: any) => layer?.url && !mapDataStore.hasPointLayerData(layer.key)
       );
 
-    for (const layer of layersToLoad) {
-      await mapStore.loadLayerData(layer);
+    if (layersToLoad.length === 0) {
+      return;
     }
+
+    await Promise.all(layersToLoad.map(layer => mapStore.loadLayerData(layer)));
   };
 
   // 备注：统一控制水电开发菜单下的动态图层增删，避免页面组件直接操作加载和勾选细节。
   const syncHydroDynamicLayers = async (visible: boolean) => {
-    const currentCheckedKeys = mapViewStore.getCheckedLayerKeys();
-    const pageDefaultCheckedKeys = new Set(
-      mapConfigStore.extractCheckedLayerKeys(mapStore.layerData || [])
-    );
+    if (
+      hydroDynamicLayerSyncTask &&
+      hydroDynamicLayerSyncTask.visible === visible
+    ) {
+      return hydroDynamicLayerSyncTask.promise;
+    }
 
-    if (visible) {
-      const layersToAdd = HYDRO_DYNAMIC_LAYER_KEYS.filter(
-        key => !currentCheckedKeys.includes(key)
-      );
+    const task = (async () => {
+      const currentCheckedKeys = mapViewStore.getCheckedLayerKeys();
 
-      if (layersToAdd.length === 0) {
+      if (visible) {
+        const layersToAdd = HYDRO_DYNAMIC_LAYER_KEYS.filter(
+          key => !currentCheckedKeys.includes(key)
+        );
+
+        if (layersToAdd.length === 0) {
+          return currentCheckedKeys;
+        }
+
+        await ensureDynamicLayersLoaded(layersToAdd);
+        return applyLayerSelection({
+          checkedKeys: [...currentCheckedKeys, ...layersToAdd]
+        });
+      }
+
+      const nextCheckedKeys = currentCheckedKeys.filter(key => {
+        if (!HYDRO_DYNAMIC_LAYER_KEYS.includes(key)) {
+          return true;
+        }
+        return hydroMenuDefaultCheckedKeys.has(key);
+      });
+
+      if (nextCheckedKeys.length === currentCheckedKeys.length) {
         return currentCheckedKeys;
       }
 
-      await ensureDynamicLayersLoaded(layersToAdd);
       return applyLayerSelection({
-        checkedKeys: [...currentCheckedKeys, ...layersToAdd]
+        checkedKeys: nextCheckedKeys
       });
-    }
-
-    const nextCheckedKeys = currentCheckedKeys.filter(key => {
-      if (!HYDRO_DYNAMIC_LAYER_KEYS.includes(key)) {
-        return true;
+    })().finally(() => {
+      if (hydroDynamicLayerSyncTask?.promise === task) {
+        hydroDynamicLayerSyncTask = null;
       }
-      return pageDefaultCheckedKeys.has(key);
     });
 
-    if (nextCheckedKeys.length === currentCheckedKeys.length) {
-      return currentCheckedKeys;
+    hydroDynamicLayerSyncTask = {
+      visible,
+      promise: task
+    };
+    return task;
+  };
+
+  // 备注：统一按当前缩放对齐首页菜单的中型站过滤和 12 级动态图层状态。
+  const syncZoomSensitiveState = async ({
+    isHydroMenu,
+    refreshEngPoint = false
+  }: {
+    isHydroMenu: boolean;
+    refreshEngPoint?: boolean;
+  }) => {
+    const currentZoom = getCurrentZoom();
+    if (currentZoom !== undefined) {
+      mapViewStore.setCurrentZoomLevel(currentZoom);
     }
 
-    return applyLayerSelection({
-      checkedKeys: nextCheckedKeys
-    });
+    if (
+      isHydroMenu &&
+      refreshEngPoint &&
+      mapViewStore.getCheckedLayerKeys().includes(ENG_POINT_LAYER_KEY)
+    ) {
+      mapStore.refreshPointLayerDisplayData(ENG_POINT_LAYER_KEY);
+    }
+
+    await syncHydroDynamicLayers(
+      !!isHydroMenu && currentZoom !== undefined && currentZoom >= 12
+    );
   };
 
   // 备注：统一处理地图缩放联动，收口水电开发菜单下的动态图层阈值切换逻辑。
@@ -419,6 +592,7 @@ export const useMapOrchestrator = () => {
         currentZoom <= ENG_POINT_MEDIUM_VISIBLE_ZOOM);
 
     if (
+      isHydroMenu &&
       crossedEngPointMediumThreshold &&
       mapViewStore.getCheckedLayerKeys().includes(ENG_POINT_LAYER_KEY)
     ) {
@@ -454,13 +628,10 @@ export const useMapOrchestrator = () => {
     }
 
     return reloadPage(pageKey).then(async () => {
-      const currentZoom = getCurrentZoom();
-      if (isHydroMenu && currentZoom !== undefined && currentZoom >= 12) {
-        await syncHydroDynamicLayers(true);
-        return;
-      }
-
-      await syncHydroDynamicLayers(false);
+      await syncZoomSensitiveState({
+        isHydroMenu,
+        refreshEngPoint: true
+      });
     });
   };
 
@@ -487,12 +658,15 @@ export const useMapOrchestrator = () => {
   // 备注：统一处理单个图例切换命令，供图例组件复用。
   const toggleLegend = (nameEn: string, checked?: number) => {
     if (!nameEn) return;
+    console.log('toggleLegend', nameEn, checked);
+    console.log(mapViewStore.getLegendChecked(nameEn));
     const nextChecked =
       checked === undefined
         ? mapViewStore.getLegendChecked(nameEn) === 1
           ? 0
           : 1
         : checked;
+    console.log(nextChecked);
     mapStore.updateLegendChecked(nameEn, nextChecked);
   };
 
@@ -570,30 +744,47 @@ export const useMapOrchestrator = () => {
       mapDataStore.pointData.find(pointMatcher) ||
       fallbackPoints.find(pointMatcher);
     if (!targetPoint?.lgtd || !targetPoint?.lttd) return;
+
+    const legendState = String(targetPoint?.anchoPointState || '');
+    if (legendState && mapViewStore.getLegendChecked(legendState) !== 1) {
+      mapStore.updateLegendChecked(legendState, 1);
+    }
+
+    const layerKey = String(targetPoint?.layerKey || '');
+    if (layerKey && mapClass.hasLayer(layerKey)) {
+      mapClass.mdLayerTreeShowOrHidden(layerKey, true);
+    }
+
     mapClass.flyTopanto([targetPoint.lgtd, targetPoint.lttd], zoom);
   };
 
   // 备注：统一释放地图页面生命周期里注册的监听，避免页面卸载后残留联动。
   const unmountView = () => {
-    if (zoomListenerKey) {
-      unByKey(zoomListenerKey);
-      zoomListenerKey = null;
+    if (removeZoomListener) {
+      removeZoomListener();
+      removeZoomListener = null;
     }
+    clearZoomSyncDebounceTimer();
 
     if (stopBaseSelectionWatch) {
       stopBaseSelectionWatch();
-      stopBaseSelectionWatch = null;
     }
 
     if (baseSelectionDebounceTimer.value) {
       clearTimeout(baseSelectionDebounceTimer.value);
       baseSelectionDebounceTimer.value = null;
     }
+
+    latestHydroMenuGetter = null;
+    currentMapType = '2D';
+    initializedBaseLayerKeys.clear();
+    hydroMenuDefaultCheckedKeys.clear();
   };
 
   return {
     initialize,
     mountView,
+    switchMapType,
     unmountView,
     loadPage,
     reloadPage,
diff --git a/frontend/src/modules/map/domain/nearby-point-rules.ts b/frontend/src/modules/map/domain/nearby-point-rules.ts
index d9c758be..77d99e51 100644
--- a/frontend/src/modules/map/domain/nearby-point-rules.ts
+++ b/frontend/src/modules/map/domain/nearby-point-rules.ts
@@ -74,19 +74,19 @@ export const DEFAULT_NEARBY_POINT_DENSITY_DISPLAY_RULES: NearbyPointDensityDispl
     },
     {
       minDensityValue: 800000,
-      minZoom: 6.1
+      minZoom: 0
     },
     {
       minDensityValue: 400000,
-      minZoom: 8.1
+      minZoom: 0
     },
     {
       minDensityValue: 50000,
-      minZoom: 10.6
+      minZoom: 2.0
     },
     {
       minDensityValue: 0,
-      minZoom: 12.2
+      minZoom: 4.0
     }
   ];
 
@@ -121,6 +121,37 @@ type GroupCandidate = {
   layerKey: string;
 };
 
+const isAlarmRangeLegendState = (legendState: string): boolean => {
+  return (
+    legendState.startsWith('alarm_range_') ||
+    legendState.startsWith('large_eng_built_alarm_range_') ||
+    legendState.startsWith('mid_eng_built_alarm_range_')
+  );
+};
+
+const getPointRenderPriority = (point: Record<string, any>): number => {
+  const layerKey = String(point.layerKey || point.type || '').toLowerCase();
+  const legendState = String(point.anchoPointState || '').trim().toLowerCase();
+
+  if (
+    layerKey.includes('eng_alarm_point') ||
+    layerKey.includes('alarm_range') ||
+    isAlarmRangeLegendState(legendState)
+  ) {
+    return 300;
+  }
+
+  if (
+    layerKey.includes('eng_point') ||
+    legendState.startsWith('large_eng_') ||
+    legendState.startsWith('mid_eng_')
+  ) {
+    return 200;
+  }
+
+  return 100;
+};
+
 const normalizeText = (value: unknown): string => {
   return String(value ?? '')
     .trim()
@@ -207,6 +238,12 @@ const compareGroupCandidates = (
   left: GroupCandidate,
   right: GroupCandidate
 ): number => {
+  const leftRenderPriority = getPointRenderPriority(left.point);
+  const rightRenderPriority = getPointRenderPriority(right.point);
+  if (leftRenderPriority !== rightRenderPriority) {
+    return rightRenderPriority - leftRenderPriority;
+  }
+
   const leftDensityValue = toFiniteNumber(left.point.distance);
   const rightDensityValue = toFiniteNumber(right.point.distance);
 
@@ -232,21 +269,18 @@ const buildRuntimeMeta = (
   displayName: string,
   rule: NearbyPointAutoRule
 ): NearbyPointRuntimeMeta => {
-  const displayMode: NearbyPointDisplayMode =
-    priority === 1 ? 'default' : priority === 2 ? 'replace' : 'expand';
-
   return {
     groupId,
     displayName,
     groupSize,
     priority,
-    showZoomMin: priority === 1 ? null : rule.replaceAtZoom,
+    showZoomMin: null,
     showZoomMax: null,
     replaceAtZoom: rule.replaceAtZoom,
     expandAtZoom: rule.expandAtZoom,
     expandOffsetPx: rule.expandOffsetPx,
-    expandAngleDeg: priority === 1 ? 0 : (priority - 2) * rule.angleStepDeg,
-    displayMode
+    expandAngleDeg: 0,
+    displayMode: 'default'
   };
 };
 
@@ -279,61 +313,49 @@ const buildGroupCandidates = (
   return candidates;
 };
 
-const buildLayerScopedNearbyGroups = (
+const buildNearbyGroups = (
   candidates: GroupCandidate[],
   rule: NearbyPointAutoRule
 ): GroupCandidate[][] => {
-  const layerScopedCandidates = new Map<string, GroupCandidate[]>();
-
-  candidates.forEach(candidate => {
-    const layerKey = candidate.layerKey || '__empty_layer__';
-    const layerItems = layerScopedCandidates.get(layerKey) || [];
-    layerItems.push(candidate);
-    layerScopedCandidates.set(layerKey, layerItems);
-  });
-
   const result: GroupCandidate[][] = [];
+  const sortedCandidates = [...candidates].sort(compareGroupCandidates);
+  const consumedIndexes = new Set<number>();
 
-  layerScopedCandidates.forEach(layerItems => {
-    const sortedCandidates = [...layerItems].sort(compareGroupCandidates);
-    const consumedIndexes = new Set<number>();
+  sortedCandidates.forEach((seedCandidate, seedIndex) => {
+    if (consumedIndexes.has(seedIndex)) {
+      return;
+    }
 
-    sortedCandidates.forEach((seedCandidate, seedIndex) => {
-      if (consumedIndexes.has(seedIndex)) {
-        return;
+    const groupItems: GroupCandidate[] = [seedCandidate];
+    const groupIndexes = [seedIndex];
+
+    for (
+      let candidateIndex = seedIndex + 1;
+      candidateIndex < sortedCandidates.length;
+      candidateIndex += 1
+    ) {
+      if (consumedIndexes.has(candidateIndex)) {
+        continue;
       }
 
-      const groupItems: GroupCandidate[] = [seedCandidate];
-      const groupIndexes = [seedIndex];
+      const currentCandidate = sortedCandidates[candidateIndex];
+      const distanceMeters = haversineDistanceMeters(
+        seedCandidate.lon,
+        seedCandidate.lat,
+        currentCandidate.lon,
+        currentCandidate.lat
+      );
 
-      for (
-        let candidateIndex = seedIndex + 1;
-        candidateIndex < sortedCandidates.length;
-        candidateIndex += 1
-      ) {
-        if (consumedIndexes.has(candidateIndex)) {
-          continue;
-        }
-
-        const currentCandidate = sortedCandidates[candidateIndex];
-        const distanceMeters = haversineDistanceMeters(
-          seedCandidate.lon,
-          seedCandidate.lat,
-          currentCandidate.lon,
-          currentCandidate.lat
-        );
-
-        if (distanceMeters <= rule.distanceThresholdMeters) {
-          groupItems.push(currentCandidate);
-          groupIndexes.push(candidateIndex);
-        }
+      if (distanceMeters <= rule.distanceThresholdMeters) {
+        groupItems.push(currentCandidate);
+        groupIndexes.push(candidateIndex);
       }
+    }
 
-      if (groupItems.length >= rule.minGroupSize) {
-        groupIndexes.forEach(index => consumedIndexes.add(index));
-        result.push(groupItems);
-      }
-    });
+    if (groupItems.length >= rule.minGroupSize) {
+      groupIndexes.forEach(index => consumedIndexes.add(index));
+      result.push(groupItems);
+    }
   });
 
   return result;
@@ -354,7 +376,7 @@ export const attachNearbyPointRuntimeMeta = (
   if (candidates.length < rule.minGroupSize) {
     return points;
   }
-  const groupedCandidates = buildLayerScopedNearbyGroups(candidates, rule);
+  const groupedCandidates = buildNearbyGroups(candidates, rule);
 
   let groupSeed = 0;
   groupedCandidates.forEach(groupItems => {
diff --git a/frontend/src/modules/map/stores/map-config.store.ts b/frontend/src/modules/map/stores/map-config.store.ts
index 843a6281..248d5a00 100644
--- a/frontend/src/modules/map/stores/map-config.store.ts
+++ b/frontend/src/modules/map/stores/map-config.store.ts
@@ -28,10 +28,9 @@ export const useMapConfigStore = defineStore('map-config', () => {
   const legendLoading = ref(false);
   const lastLoadOptions = ref<MapConfigLoadOptions | null>(null);
 
-  // 备注：统一规范图例 nameEn，避免 `_测试` 后缀影响索引命中。
   const normalizeLegendNameEn = (nameEn?: string): string => {
     if (!nameEn) return '';
-    return nameEn.includes('_测试') ? nameEn.split('_测试')[0] : nameEn;
+    return nameEn;
   };
 
   // 备注：重建图层配置索引，后续按 key 读取图层配置时不再全量递归。
diff --git a/frontend/src/modules/qixidijchuXx/index.vue b/frontend/src/modules/qixidijchuXx/index.vue
index 5a51e304..28ed7542 100644
--- a/frontend/src/modules/qixidijchuXx/index.vue
+++ b/frontend/src/modules/qixidijchuXx/index.vue
@@ -55,7 +55,9 @@ const select = ref({
   value: 'all',
   options: jiDiList.value,
   picker: undefined,
-  format: undefined
+  format: undefined,
+  width: '160px',
+  minWidth:'160px'
 });
 const baseid = ref('');
 // 加载状态
diff --git a/frontend/src/modules/qixidiliuliangbianhua/index.vue b/frontend/src/modules/qixidiliuliangbianhua/index.vue
index 8fff3e8e..3f866f51 100644
--- a/frontend/src/modules/qixidiliuliangbianhua/index.vue
+++ b/frontend/src/modules/qixidiliuliangbianhua/index.vue
@@ -39,7 +39,7 @@ const baseid = ref('');
 const modelStore = useModelStore();
 
 // Loading 状态和数据状态
-const loading = ref(false);
+const loading = ref(true);
 const hasData = ref(true); // 初始化为 true，因为 initChart 时会渲染
 const select = ref({
   show: true,
@@ -844,4 +844,7 @@ watch(
     z-index: 10;
   }
 }
+:deep(.ant-spin-nested-loading >div>.ant-spin){
+  background: rgba(255, 255, 255) !important;
+}
 </style>
diff --git a/frontend/src/modules/qixidishuiwenbianhua/index.vue b/frontend/src/modules/qixidishuiwenbianhua/index.vue
index 08100bb2..d7d2b6b0 100644
--- a/frontend/src/modules/qixidishuiwenbianhua/index.vue
+++ b/frontend/src/modules/qixidishuiwenbianhua/index.vue
@@ -9,7 +9,7 @@
     <div class="chart-wrapper">
       <a-spin :spinning="loading">
         <!-- 始终渲染图表容器，确保有固定宽高 -->
-        <div ref="chartRef" class="water-temp-chart"></div>
+        <div  ref="chartRef" class="water-temp-chart"></div>
         <!-- 无数据时显示Empty，但不影响容器尺寸 -->
         <div v-if="!loading && !hasData" class="empty-overlay">
           <a-empty description="暂无数据" />
@@ -41,7 +41,7 @@ let chartInstance: echarts.ECharts | null = null;
 const baseid = ref('');
 
 // Loading 状态和数据状态
-const loading = ref(false);
+const loading = ref(true);
 const hasData = ref(true); // 初始化为 true，因为 initChart 时会渲染
 
 // 选择器配置
@@ -732,4 +732,7 @@ onUnmounted(() => {
     z-index: 10;
   }
 }
+:deep(.ant-spin-nested-loading >div>.ant-spin){
+  background: rgba(255, 255, 255) !important;
+}
 </style>
diff --git a/frontend/src/modules/shengTaiLiuLiangXieFangSheShiMod/xieFangFenBu/TwoLayer/FenBuQingKuangTwoLayer.vue b/frontend/src/modules/shengTaiLiuLiangXieFangSheShiMod/xieFangFenBu/TwoLayer/FenBuQingKuangTwoLayer.vue
index f96e5c10..37b03077 100644
--- a/frontend/src/modules/shengTaiLiuLiangXieFangSheShiMod/xieFangFenBu/TwoLayer/FenBuQingKuangTwoLayer.vue
+++ b/frontend/src/modules/shengTaiLiuLiangXieFangSheShiMod/xieFangFenBu/TwoLayer/FenBuQingKuangTwoLayer.vue
@@ -587,12 +587,12 @@ const fetchTableData = async () => {
             {
               field: 'stnm',
               operator: 'contains',
-              value: '12'
+              value: params.value.stnm
             },
             {
               field: 'ennm',
               operator: 'contains',
-              value: '12'
+              value:  params.value.stnm
             }
           ]
         }
diff --git a/frontend/src/modules/shengtaidabiaoMod/TwoLayer/ShengTaiLiuLiangDaBQKTwoLayer.vue b/frontend/src/modules/shengtaidabiaoMod/TwoLayer/ShengTaiLiuLiangDaBQKTwoLayer.vue
index dcce21bf..f2f2a82b 100644
--- a/frontend/src/modules/shengtaidabiaoMod/TwoLayer/ShengTaiLiuLiangDaBQKTwoLayer.vue
+++ b/frontend/src/modules/shengtaidabiaoMod/TwoLayer/ShengTaiLiuLiangDaBQKTwoLayer.vue
@@ -501,7 +501,7 @@ const updateChart = () => {
         center: ['35%', '50%'],
         avoidLabelOverlap: false,
         itemStyle: {
-          borderRadius: 10,
+          borderRadius: 5,
           borderColor: '#fff',
           borderWidth: 2
         },
diff --git a/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/HuanJingSJJRQK.vue b/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/HuanJingSJJRQK.vue
index 44eb39da..0b66c896 100644
--- a/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/HuanJingSJJRQK.vue
+++ b/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/HuanJingSJJRQK.vue
@@ -14,7 +14,7 @@ import {
   getMsstbprptKendoList
 } from '@/api/home';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
-
+import dayjs from 'dayjs';
 const props = defineProps<{
   dataDimensionVal?: string;
   name?: string;
@@ -337,17 +337,27 @@ const customTransform = (res: any) => ({
   total: res?.data?.total || 0
 });
 
+const exportLoading = ref(false);
 function handleExport() {
+  if (exportLoading.value) return;
+
+  exportLoading.value = true;
+
   const currentTab = tabKey.value;
   if (
     tableRefs.value[currentTab] &&
     typeof tableRefs.value[currentTab].exportTable === 'function'
   ) {
-    tableRefs.value[currentTab].exportTable({
-      fileName: '环境监测数据接入情况'
-    });
+    tableRefs.value[currentTab]
+      .exportTable({
+        fileName: `水电开发情况_${dayjs().format('YYYY-MM-DD HH-mm-ss')}`
+      })
+      .finally(() => {
+        exportLoading.value = false;
+      });
   } else {
-    message.info('导出功能待实现');
+    message.info('当前Tab暂无导出数据');
+    exportLoading.value = false;
   }
 }
 
@@ -640,6 +650,7 @@ const searchList = computed(() => [
     type: 'Input',
     name: 'stnm',
     label: '',
+    placeholder:'请输入电站名称',
     fieldProps: {
       allowClear: true,
       placeholder: '请输入电站名称'
@@ -866,7 +877,7 @@ onUnmounted(() => {
       @reset="handleReset"
     >
       <template #actions>
-        <a-button @click="handleExport">
+       <a-button @click="handleExport"  :loading ="exportLoading" >
           <template #icon><DownloadOutlined /></template>
           导出
         </a-button>
diff --git a/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/ShuiDianKaiFQKTwoLayer.vue b/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/ShuiDianKaiFQKTwoLayer.vue
index 153e36bd..27e605a1 100644
--- a/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/ShuiDianKaiFQKTwoLayer.vue
+++ b/frontend/src/modules/shuidianhuangjingjieruMod/TwoLayer/ShuiDianKaiFQKTwoLayer.vue
@@ -15,7 +15,7 @@ import {
   getBaseWbsb
 } from '@/api/home';
 import { useJidiSelectEventStore } from '@/store/modules/jidiSelectEvent';
-
+import dayjs from 'dayjs';
 const props = defineProps<{
   defaultJidiInfo?: Record<string, string | number | boolean>;
   seriesName?: string;
@@ -300,12 +300,27 @@ const customTransform = (res: any) => ({
   records: res?.data?.data || res?.data?.items || [],
   total: res?.data?.total || 0
 });
-
+const exportLoading = ref(false);
 function handleExport() {
-  if (tableRef.value && typeof tableRef.value.export === 'function') {
-    tableRef.value.export();
+  if (exportLoading.value) return;
+
+  exportLoading.value = true;
+
+  const currentTab = tabKey.value;
+  if (
+    tableRefs.value[currentTab] &&
+    typeof tableRefs.value[currentTab].exportTable === 'function'
+  ) {
+    tableRefs.value[currentTab]
+      .exportTable({
+        fileName: `水电开发情况_${dayjs().format('YYYY-MM-DD HH-mm-ss')}`
+      })
+      .finally(() => {
+        exportLoading.value = false;
+      });
   } else {
-    message.info('导出功能待实现');
+    message.info('当前Tab暂无导出数据');
+    exportLoading.value = false;
   }
 }
 
@@ -575,6 +590,7 @@ const searchList = computed(() => [
     type: 'Input',
     name: 'stnm',
     label: '',
+     placeholder: '请输入电站名称',
     fieldProps: {
       allowClear: true,
       placeholder: '请输入电站名称'
@@ -946,7 +962,7 @@ onUnmounted(() => {
       @reset="handleReset"
     >
       <template #actions>
-        <a-button @click="handleExport">
+        <a-button @click="handleExport"  :loading ="exportLoading" >
           <template #icon><DownloadOutlined /></template>
           导出
         </a-button>
diff --git a/frontend/src/modules/shuiwenjiancegongzuokaizhangqingkuang/shuiwenjiancegongzuoEJ.vue b/frontend/src/modules/shuiwenjiancegongzuokaizhangqingkuang/shuiwenjiancegongzuoEJ.vue
index b1dc99f9..b3d56e07 100644
--- a/frontend/src/modules/shuiwenjiancegongzuokaizhangqingkuang/shuiwenjiancegongzuoEJ.vue
+++ b/frontend/src/modules/shuiwenjiancegongzuokaizhangqingkuang/shuiwenjiancegongzuoEJ.vue
@@ -404,7 +404,7 @@ const getselectTwo = async (code: any) => {
             "filters": [
                 code != 'all' ? {
                     "field": "baseId",
-                    "operator": "contains",
+                    "operator": "eq",
                     "dataType": "string",
                     "value": code
                 } : null,
diff --git a/frontend/src/modules/yanchengshuiwenChangeMod/index.vue b/frontend/src/modules/yanchengshuiwenChangeMod/index.vue
index ed01ba7f..a43b2945 100644
--- a/frontend/src/modules/yanchengshuiwenChangeMod/index.vue
+++ b/frontend/src/modules/yanchengshuiwenChangeMod/index.vue
@@ -56,11 +56,28 @@ const paramsOne = {
   tm: []
 };
 const dataOne = ref('');
-// 使用 computed 使 prompts 响应 dataOne.value 的变化
-const prompts = computed(() => ({
-  show: true,
-  value: `注:最新数据时间为${dataOne.value || getCurrentHourTime()}`
-}));
+// 保存原始表格数据，用于提取 minTm
+const rawTableData = ref<any[]>([]);
+// 使用 computed 使 prompts 基于原始数据的 minTm 字段
+const prompts = computed(() => {
+  // 如果没有数据或数据为空，不显示提示
+  if (!rawTableData.value || rawTableData.value.length === 0) {
+    return { show: true, value: '' };
+  }
+
+  // 获取第一条数据的 minTm 字段
+  const minTm = rawTableData.value[0]?.minTm;
+
+  // 如果 minTm 为空，也不显示提示
+  if (!minTm) {
+    return { show: true, value: '' };
+  }
+
+  return {
+    show: true,
+    value: `注:最新数据时间为${minTm}`
+  };
+});
 const showemit = ref(false);
 const loading = ref(false);
 // const selectOptions: any = ref([])
@@ -308,6 +325,9 @@ const init = async () => {
     let res = await getKendoListCust(params);
     let data = res.data.data || res.data;
 
+    // 保存原始数据，用于提取 minTm
+    rawTableData.value = data;
+
     if (data.length > 0) {
       showemit.value = true;
     } else {
diff --git a/frontend/src/store/modules/jidiSelectEvent.ts b/frontend/src/store/modules/jidiSelectEvent.ts
index c52646ef..72f7734d 100644
--- a/frontend/src/store/modules/jidiSelectEvent.ts
+++ b/frontend/src/store/modules/jidiSelectEvent.ts
@@ -23,7 +23,7 @@ export const useJidiSelectEventStore = defineStore('jidiSelectEvent', () => {
   };
   const getJidiData = async () => {
     loading.value = true;
-    let params = {
+    const params = {
       filter: {
         logic: 'and',
         filters: [
@@ -50,7 +50,7 @@ export const useJidiSelectEventStore = defineStore('jidiSelectEvent', () => {
       select: ['wbsCode', 'wbsName']
     };
     const res = await wbsbGetKendoList(params);
-    let data = res?.data?.data || [
+    const data = res?.data?.data || [
       {
         wbsCode: 'all',
         wbsName: '当前全部',
diff --git a/frontend/src/store/modules/map.ts b/frontend/src/store/modules/map.ts
index 19719ef4..99cbd6c0 100644
--- a/frontend/src/store/modules/map.ts
+++ b/frontend/src/store/modules/map.ts
@@ -16,6 +16,7 @@ import { useMapViewStore } from '@/modules/map/stores/map-view.store';
 import request from '@/utils/request';
 const mapClass = MapClass.getInstance();
 const ENG_POINT_LAYER_KEY = 'eng_point';
+const ENG_ALARM_POINT_LAYER_KEY = 'eng_alarm_point';
 const YLFB_POINT_LAYER_KEY = 'ylfb_point';
 const ENG_POINT_MEDIUM_VISIBLE_ZOOM = 7.5;
 const ENG_POINT_LARGE_STATES = [
@@ -29,6 +30,22 @@ const ENG_POINT_MEDIUM_STATES = [
   'mid_eng_nbuilt'
 ];
 
+const isEngPointRuntimeItem = (item: any): boolean => {
+  const runtimeLayerKey = String(
+    item?.layerKey || item?.type || item?._layerKey || ''
+  ).toLowerCase();
+  const sttpMap = String(
+    item?._sttpMap || item?.sttpMap || item?.popupSttpMap || ''
+  ).toUpperCase();
+  const sttpCode = String(item?.sttpCode || item?.sttp || '').toUpperCase();
+
+  if (runtimeLayerKey) {
+    return runtimeLayerKey.includes(ENG_POINT_LAYER_KEY);
+  }
+
+  return sttpMap === 'ENG' || sttpMap === 'ENG2' || sttpCode === 'ENG';
+};
+
 const normalizeCachePayload = (value: any): any => {
   if (Array.isArray(value)) {
     return value.map(item => normalizeCachePayload(item));
@@ -105,19 +122,48 @@ const normalizeRequestParams = (rawParams: any) => {
   };
 };
 
-const parseAnchorParamFilters = (anchorParamJson?: string) => {
-  if (!anchorParamJson) return [];
+const parseAnchorParamJson = (anchorParamJson?: string) => {
+  const result: { filters: any[]; orders: any[] | null } = {
+    filters: [],
+    orders: null
+  };
+
+  if (!anchorParamJson) return result;
 
   try {
-    const parsedParams = JSON.parse(anchorParamJson);
-    if (!parsedParams || typeof parsedParams !== 'object') {
-      return [];
+    const parsed = JSON.parse(anchorParamJson);
+    if (!parsed || typeof parsed !== 'object') return result;
+
+    // 解析 params -> filters（兼容旧格式：如果没有 params 字段，整个对象即为 params）
+    const paramsObj = parsed.params || parsed;
+    if (
+      paramsObj &&
+      typeof paramsObj === 'object' &&
+      !Array.isArray(paramsObj)
+    ) {
+      result.filters = buildFiltersFromParamsObject(paramsObj);
     }
 
-    return buildFiltersFromParamsObject(parsedParams);
+    // 解析 orders -> sort 数组
+    if (parsed.orders) {
+      let ordersObj: Record<string, any> = {};
+      if (typeof parsed.orders === 'string') {
+        ordersObj = JSON.parse(parsed.orders);
+      } else if (typeof parsed.orders === 'object') {
+        ordersObj = parsed.orders;
+      }
+      if (ordersObj && typeof ordersObj === 'object') {
+        result.orders = Object.entries(ordersObj).map(([field, dir]) => ({
+          field,
+          dir
+        }));
+      }
+    }
+
+    return result;
   } catch (error) {
     console.error('解析 anchorParamJson 失败:', error);
-    return [];
+    return result;
   }
 };
 
@@ -183,6 +229,10 @@ export const useMapStore = defineStore('map', () => {
 
     const allowMedium = currentZoom > ENG_POINT_MEDIUM_VISIBLE_ZOOM;
     return sourceData.filter((item: any) => {
+      if (!isEngPointRuntimeItem(item)) {
+        return true;
+      }
+
       const state = String(item?.anchoPointState || '');
       if (ENG_POINT_LARGE_STATES.includes(state)) {
         return true;
@@ -985,14 +1035,21 @@ export const useMapStore = defineStore('map', () => {
     layerKey: string,
     nameEn: string
   ): string[] => {
-    void layerKey;
     const normalizedNameEn = normalizeLegendNameEn(nameEn);
     if (!normalizedNameEn) {
       return [];
     }
 
     if (normalizedNameEn.includes('alarm_range_')) {
-      return [`large_eng_built_${normalizedNameEn}`];
+      const candidates: string[] = [];
+      if (layerKey === ENG_ALARM_POINT_LAYER_KEY) {
+        candidates.push(`mid_eng_built_${normalizedNameEn}`);
+        candidates.push(`large_eng_built_${normalizedNameEn}`);
+      } else {
+        candidates.push(`large_eng_built_${normalizedNameEn}`);
+        candidates.push(`mid_eng_built_${normalizedNameEn}`);
+      }
+      return candidates;
     }
 
     return [normalizedNameEn];
@@ -1130,9 +1187,12 @@ export const useMapStore = defineStore('map', () => {
 
     requestParams = normalizeRequestParams(requestParams);
 
-    const anchorParamFilters = parseAnchorParamFilters(anchorParamJson);
-    if (anchorParamFilters.length) {
-      requestParams.filters.push(...anchorParamFilters);
+    const anchorParamResult = parseAnchorParamJson(anchorParamJson);
+    if (anchorParamResult.filters.length) {
+      requestParams.filters.push(...anchorParamResult.filters);
+    }
+    if (anchorParamResult.orders) {
+      requestOrders = anchorParamResult.orders;
     }
 
     if (timeRangeLayerKeys.includes(layerKey)) {
@@ -1166,7 +1226,7 @@ export const useMapStore = defineStore('map', () => {
       }
     }
 
-    if (layer?.orders) {
+    if (!requestOrders && layer?.orders) {
       try {
         const ordersObj = JSON.parse(layer.orders);
         const ordersArray = Object.entries(ordersObj).map(([field, dir]) => ({
diff --git a/frontend/src/store/modules/shuJuTianBao.ts b/frontend/src/store/modules/shuJuTianBao.ts
index 7e29e00a..b1cec9a7 100644
--- a/frontend/src/store/modules/shuJuTianBao.ts
+++ b/frontend/src/store/modules/shuJuTianBao.ts
@@ -66,7 +66,7 @@ export const useShuJuTianBaoStore = defineStore('shuJuTianBao', () => {
       if (type == 'baseId') {
         param = rvcd === 'all' ? {} : { baseId: rvcd };
       } else {
-        param = rvcd === 'all' ? {} : { reachcd: rvcd };
+        param = rvcd === 'all' ? {} : { rvcd: rvcd };
       }
       const res = await getEngInfoDropdown(param);
       if (res.data && Array.isArray(res.data)) {
diff --git a/frontend/src/store/modules/ui.ts b/frontend/src/store/modules/ui.ts
index 190b9213..b4ba2d27 100644
--- a/frontend/src/store/modules/ui.ts
+++ b/frontend/src/store/modules/ui.ts
@@ -5,6 +5,7 @@ export const useUiStore = defineStore('ui', () => {
   // 右侧抽屉状态
   const drawerOpen = ref(true);
   const mapType = ref('2D');
+  const mapSwitchCompletedTick = ref(0);
 
   // 切换抽屉状态
   const toggleDrawer = () => {
@@ -16,10 +17,16 @@ export const useUiStore = defineStore('ui', () => {
     drawerOpen.value = open;
   };
 
+  const markMapSwitchCompleted = () => {
+    mapSwitchCompletedTick.value += 1;
+  };
+
   return {
     drawerOpen,
     toggleDrawer,
     setDrawerOpen,
-    mapType
+    mapType,
+    mapSwitchCompletedTick,
+    markMapSwitchCompleted
   };
 });
diff --git a/frontend/src/utils/popupHtmlGenerator.ts b/frontend/src/utils/popupHtmlGenerator.ts
index 46205a43..a85bfc8b 100644
--- a/frontend/src/utils/popupHtmlGenerator.ts
+++ b/frontend/src/utils/popupHtmlGenerator.ts
@@ -2451,10 +2451,10 @@ const themecc_list = [
   }
 ];
 const getThemee = (fieldName?: string) => {
-  let themeecList = themecc_list;
+  const themeecList = themecc_list;
   let getitem: any = {};
   if (fieldName && themeecList.length > 0) {
-    let getitemList = themeecList.filter(
+    const getitemList = themeecList.filter(
       (i: any) => i.fieldName.toUpperCase() == fieldName.toUpperCase()
     );
     if (getitemList.length > 0) {
@@ -2642,16 +2642,19 @@ const timegj = [
  * @param props - 锚点数据对象
  * @returns HTML 字符串
  */
-export function generatePopupHtml(props: any): string {
+export function generatePopupHtml(
+  props: any,
+  options?: {
+    forceEng2?: boolean;
+  }
+): string {
   const p = props;
   const dzFdl = getUnitConfigByCode('Other', 'FDLYKW')?.unit;
   const dzZjrl = getUnitConfigByCode('Other', 'ZJRL')?.unit;
   const title = p?.ennm || p?.stnm;
   const titleClass = getTitleClass(title);
-
   let newsttpMap = p.sttpMap;
-  console.log('newsttpMap', newsttpMap);
-  if (p.qecInterval) {
+  if (options?.forceEng2) {
     newsttpMap = 'eng2';
   }
   let html = '';
@@ -2714,7 +2717,7 @@ export function generatePopupHtml(props: any): string {
       } else {
         lastTmEngEqDataVo = p.lastTmEngEqDataVo;
       }
-      if (!lastTmEngEqDataVo?.qo && !lastTmEngEqDataVo?.qi) return '';
+      // if (!lastTmEngEqDataVo?.qo && !lastTmEngEqDataVo?.qi) return '';
 
       const qecLimitVal = lastTmEngEqDataVo?.qecLimit;
       let qecLimitDisplay = '-';
@@ -3587,3 +3590,29 @@ export function generatePopupHtml(props: any): string {
 
   return html ? `<div>${html}</div>` : '';
 }
+
+export function getNormalizedPopupSttpMap(props: any): string {
+  return String(props?._sttpMap || props?.sttpMap || props?.popupSttpMap || '')
+    .trim()
+    .toUpperCase();
+}
+
+export function isEngPopupFamily(props: any): boolean {
+  return getNormalizedPopupSttpMap(props).startsWith('ENG');
+}
+
+export function shouldPreferEng2Popup(
+  props: any,
+  options?: {
+    forceEng2?: boolean;
+  }
+): boolean {
+  if (options?.forceEng2) {
+    return true;
+  }
+
+  return (
+    isEngPopupFamily(props) &&
+    (!!props?.lastTmEngEqDataVo || !!props?.qecInterval)
+  );
+}
diff --git a/frontend/src/utils/request.ts b/frontend/src/utils/request.ts
index 9e40980b..4bddc19e 100644
--- a/frontend/src/utils/request.ts
+++ b/frontend/src/utils/request.ts
@@ -58,7 +58,6 @@ service.interceptors.response.use(
         message.error(response.data.msg || '请求失败');
         setTimeout(() => {
           localStorage.clear();
-          router.push('/login');
           window.location.href = '/';
         }, 1000);
         return;
diff --git a/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/Approval/index.vue b/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/Approval/index.vue
index 2e2f0907..af734c4f 100644
--- a/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/Approval/index.vue
+++ b/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/Approval/index.vue
@@ -246,6 +246,23 @@ const buildSearchParams = (values: any) => {
   return {
     logic: 'and',
     filters: [
+       values.rvcd && values.rvcd !== 'all'
+        ? {
+            field: 'rvcd',
+            operator: 'contains',
+            dataType: 'string',
+            value: values.rvcd
+          }
+        : null,
+
+      values.rstcd
+        ? {
+            field: 'stcd',
+            operator: 'eq',
+            dataType: 'string',
+            value: values.rstcd
+          }
+        : null,
       values.basin
         ? {
             field: 'basin',
diff --git a/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/FishResource/index.vue b/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/FishResource/index.vue
index f421a160..3f7b1256 100644
--- a/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/FishResource/index.vue
+++ b/frontend/src/views/DataQueryMenuModule/components/conventionalHydropower/FishResource/index.vue
@@ -510,6 +510,23 @@ const buildSearchParams = (values: any) => {
   return {
     logic: 'and',
     filters: [
+       values.rvcd && values.rvcd !== 'all'
+        ? {
+            field: 'rvcd',
+            operator: 'contains',
+            dataType: 'string',
+            value: values.rvcd
+          }
+        : null,
+
+      values.rstcd
+        ? {
+            field: 'stcd',
+            operator: 'eq',
+            dataType: 'string',
+            value: values.rstcd
+          }
+        : null,
       values.ptype && values.ptype !== 'all'
         ? {
             field: 'ptype',
diff --git a/frontend/src/views/fish-survey/fishSurveyZhuanZhi.vue b/frontend/src/views/fish-survey/fishSurveyZhuanZhi.vue
index 3c72c1e2..7243c02d 100644
--- a/frontend/src/views/fish-survey/fishSurveyZhuanZhi.vue
+++ b/frontend/src/views/fish-survey/fishSurveyZhuanZhi.vue
@@ -22,7 +22,7 @@ let initialLeft = 0;
 let initialTop = 0;
 
 const onMouseDown = (e: MouseEvent) => {
-  ;
+  
   isDragging = true;
   startX = e.clientX;
   startY = e.clientY;
diff --git a/frontend/src/views/shiPinJianKong/shiPinJianKongZhuanTi.vue b/frontend/src/views/shiPinJianKong/shiPinJianKongZhuanTi.vue
index 08a57328..781f661c 100644
--- a/frontend/src/views/shiPinJianKong/shiPinJianKongZhuanTi.vue
+++ b/frontend/src/views/shiPinJianKong/shiPinJianKongZhuanTi.vue
@@ -238,6 +238,9 @@ const statusFilter = ref<"online" | "offline">("online");
 // 视频列表
 const videoList = ref<any[]>(Array(9).fill(null));
 
+// 等待队列（存放超出布局限制的视频）
+const pendingVideoQueue = ref<any[]>([]);
+
 // 移除视频
 const removeVideo = (index: number, nodeKey?: string) => {
   const videoData = videoList.value[index];
@@ -255,6 +258,19 @@ const removeVideo = (index: number, nodeKey?: string) => {
   }
   // 移除视频
   videoList.value[index] = null;
+
+  // 尝试从队列补位
+  fillEmptySlot(index);
+};
+
+// 填充空位（从队列中取第一个视频）
+const fillEmptySlot = (emptyIndex: number) => {
+  if (pendingVideoQueue.value.length > 0) {
+    const nextVideo = pendingVideoQueue.value.shift();
+    if (nextVideo) {
+      videoList.value[emptyIndex] = nextVideo;
+    }
+  }
 };
 
 // 添加视频到列表
@@ -269,18 +285,49 @@ const addVideo = (videoData: any) => {
   } else if (videoList.value.filter((v, i) => i < maxCount).length < maxCount) {
     videoList.value.push(videoData);
   } else {
-    // 如果满了，替换第一个
-    videoList.value[0] = videoData;
+    // 如果满了，加入等待队列
+    if (!pendingVideoQueue.value.find((v) => v.key === videoData.key)) {
+      pendingVideoQueue.value.push(videoData);
+    }
   }
 };
 
 // 监听布局变化，调整视频列表长度
-watch(viewLayout, (newLayout) => {
-  const maxCount = parseInt(newLayout);
+watch(viewLayout, (newLayout, oldLayout) => {
+  const newMaxCount = parseInt(newLayout);
+  const oldMaxCount = oldLayout ? parseInt(oldLayout) : newMaxCount;
+
+  // 布局减小时，超出部分移入队列
+  if (newMaxCount < oldMaxCount) {
+    for (let i = newMaxCount; i < oldMaxCount && i < videoList.value.length; i++) {
+      const video = videoList.value[i];
+      if (video && !pendingVideoQueue.value.find((v) => v.key === video.key)) {
+        pendingVideoQueue.value.push(video);
+      }
+      videoList.value[i] = null;
+    }
+  }
+
   // 确保数组长度足够
-  while (videoList.value.length < maxCount) {
+  while (videoList.value.length < newMaxCount) {
     videoList.value.push(null);
   }
+
+  // 布局增大时，从队列填充新空位
+  if (newMaxCount > oldMaxCount) {
+    const availableSlots = newMaxCount - oldMaxCount;
+    for (let i = 0; i < availableSlots && pendingVideoQueue.value.length > 0; i++) {
+      const emptyIndex = videoList.value.findIndex(
+        (v, i) => i < newMaxCount && (v === null || v === undefined)
+      );
+      if (emptyIndex !== -1) {
+        const nextVideo = pendingVideoQueue.value.shift();
+        if (nextVideo) {
+          videoList.value[emptyIndex] = nextVideo;
+        }
+      }
+    }
+  }
 });
 
 // 树形数据
@@ -408,8 +455,8 @@ const handlePlayRecord = (record: any) => {
   if (videoPath) {
     const maxCount = parseInt(viewLayout.value);
 
-    // 检查是否已经添加过该录像
-    const existingIndex = videoList.value.findIndex((v) => v && v.flnm === record.flnm);
+    // 检查是否已经添加过该录像（通过视频路径判断）
+    const existingIndex = videoList.value.findIndex((v) => v && v.url === videoPath);
 
     if (existingIndex !== -1) {
       return;
@@ -560,10 +607,11 @@ const initTree = async () => {
     },
   };
 
-  // 清空视频列表和勾选状态
+  // 清空视频列表、勾选状态和等待队列
   videoList.value = Array(9).fill(null);
   checkedKeys.value = [];
   expandedKeys.value = [];
+  pendingVideoQueue.value = [];
 
   treeLoading.value = true;
   try {
@@ -679,6 +727,7 @@ const handleMonitorTypeChange = () => {
     // 清空中间视频
     videoList.value = Array(9).fill(null);
     checkedKeys.value = [];
+    pendingVideoQueue.value = [];
   }
 
   // 切换到实时视频时，恢复在线默认状态
@@ -729,11 +778,15 @@ const handleTreeSelect = (checkedKeysValue: any[], info: any) => {
           // 自动添加所有父节点到 checkedKeys
           addParentKeys(nodeData.key);
         } else {
-          // 超出限制，使用 setTimeout 延迟取消勾选，避免与 Tree 组件的自动勾选冲突
-          setTimeout(() => {
-            // 使用 filter 创建新数组以触发响应式更新
-            checkedKeys.value = checkedKeys.value.filter((key) => key !== nodeData.key);
-          }, 50);
+          // 超出限制，加入等待队列（保持勾选状态）
+          if (!pendingVideoQueue.value.find((v) => v.key === nodeData.key)) {
+            pendingVideoQueue.value.push({
+              flnm: nodeData.name,
+              stnm: nodeData.stnm,
+              url: videoUrl,
+              ...nodeData,
+            });
+          }
         }
       } else {
       }
@@ -744,6 +797,17 @@ const handleTreeSelect = (checkedKeysValue: any[], info: any) => {
   } else {
     // 取消勾选：移除视频
     if (!nodeData.children || nodeData.children.length === 0) {
+      // 先检查是否在队列中
+      const queueIndex = pendingVideoQueue.value.findIndex(
+        (v) => v.key === nodeData.key
+      );
+      if (queueIndex !== -1) {
+        // 从队列中移除
+        pendingVideoQueue.value.splice(queueIndex, 1);
+        removeUnnecessaryParentKeys(nodeData.key);
+        return;
+      }
+
       // 叶子节点：直接移除
       removeVideoByNodeKey(nodeData.key);
 
@@ -912,16 +976,23 @@ const addVideosFromNodeWithLimit = (node: any) => {
   const remainingSlots = maxCount - currentCount;
 
   if (remainingSlots <= 0) {
-    // 没有剩余位置，延迟取消所有相关节点的勾选
-    setTimeout(() => {
-      cancelNodeCheck(node);
-    }, 100);
+    // 没有剩余位置，全部加入队列
+    allLeafNodes.forEach((leafNode: any) => {
+      if (!pendingVideoQueue.value.find((v) => v.key === leafNode.key)) {
+        pendingVideoQueue.value.push({
+          flnm: leafNode.name,
+          stnm: leafNode.stnm,
+          url: leafNode.url || leafNode.videoUrl || leafNode.playUrl,
+          ...leafNode,
+        });
+      }
+    });
     return;
   }
 
   // 只添加前 remainingSlots 个叶子节点
   const nodesToAdd = allLeafNodes.slice(0, remainingSlots);
-  const nodesToCancel = allLeafNodes.slice(remainingSlots);
+  const nodesToQueue = allLeafNodes.slice(remainingSlots);
 
   // 添加允许的视频并勾选对应节点
   nodesToAdd.forEach((leafNode: any) => {
@@ -938,37 +1009,26 @@ const addVideosFromNodeWithLimit = (node: any) => {
     }
   });
 
-  // 先取消超出限制的节点的勾选
-  if (nodesToCancel.length > 0) {
-    setTimeout(() => {
-      cancelNodesCheck(nodesToCancel);
-
-      // 取消后再为所有添加的子节点添加父节点
-      nodesToAdd.forEach((leafNode: any) => {
-        addParentKeys(leafNode.key);
-      });
-    }, 50);
-  } else {
-    // 没有超出限制，直接添加父节点
-    setTimeout(() => {
-      nodesToAdd.forEach((leafNode: any) => {
-        addParentKeys(leafNode.key);
-      });
-    }, 50);
+  // 超出限制的节点加入队列（保持勾选状态）
+  if (nodesToQueue.length > 0) {
+    nodesToQueue.forEach((leafNode: any) => {
+      if (!pendingVideoQueue.value.find((v) => v.key === leafNode.key)) {
+        pendingVideoQueue.value.push({
+          flnm: leafNode.name,
+          stnm: leafNode.stnm,
+          url: leafNode.url || leafNode.videoUrl || leafNode.playUrl,
+          ...leafNode,
+        });
+      }
+    });
   }
-};
 
-// 取消单个节点的勾选
-const cancelNodeCheck = (node: any) => {
-  // 使用 filter 创建新数组以触发响应式更新
-  checkedKeys.value = checkedKeys.value.filter((key) => key !== node.key);
-};
-
-// 取消多个节点的勾选
-const cancelNodesCheck = (nodes: any[]) => {
-  nodes.forEach((node: any) => {
-    cancelNodeCheck(node);
-  });
+  // 添加父节点
+  setTimeout(() => {
+    nodesToAdd.forEach((leafNode: any) => {
+      addParentKeys(leafNode.key);
+    });
+  }, 50);
 };
 
 // 递归移除节点及其所有子节点的视频
@@ -986,9 +1046,20 @@ const removeVideosFromNode = (node: any) => {
 
 // 根据节点key移除视频
 const removeVideoByNodeKey = (nodeKey: string) => {
+  // 先检查是否在队列中
+  const queueIndex = pendingVideoQueue.value.findIndex(
+    (v) => v.key === nodeKey
+  );
+  if (queueIndex !== -1) {
+    pendingVideoQueue.value.splice(queueIndex, 1);
+    return;
+  }
+
   const index = videoList.value.findIndex((video) => video && video.key === nodeKey);
   if (index !== -1) {
     videoList.value[index] = null;
+    // 尝试从队列补位
+    fillEmptySlot(index);
   }
 };
 
diff --git a/frontend/src/views/shuJuFenXi/components/utils.ts b/frontend/src/views/shuJuFenXi/components/utils.ts
index 477fd985..bfa12b68 100644
--- a/frontend/src/views/shuJuFenXi/components/utils.ts
+++ b/frontend/src/views/shuJuFenXi/components/utils.ts
@@ -354,8 +354,8 @@ export const handleCellEdit = (params: any, fWorksheet: any, year: string) => {
     );
 
     // 重建该组的所有单元格引用
-    let groupCells = [];
-    let currentDayCount = groupStartDayOfYear;
+    const groupCells = [];
+    const currentDayCount = groupStartDayOfYear;
     let currentMonth = 1;
     let cumulativeDays = 0;
 
@@ -389,7 +389,7 @@ export const handleCellEdit = (params: any, fWorksheet: any, year: string) => {
     console.log('组中单元格:', groupCells);
 
     // 构建公式
-    let formula = `=ROUND(AVERAGE(${groupCells.join(',')}), 1)`;
+    const formula = `=ROUND(AVERAGE(${groupCells.join(',')}), 1)`;
 
     // 找到该组的结束位置用于显示公式
     let endMonth = 1;
@@ -446,7 +446,7 @@ export const getParams = (searchData: any, Psort?: any, Rstcd?: boolean) => {
     return result.slice(1, -1);
   };
   // if (searchData) {
-  let params: any = [];
+  const params: any = [];
   // if (sttpCode) {
   //     params.push(
   //         {
@@ -783,7 +783,7 @@ export const getParams = (searchData: any, Psort?: any, Rstcd?: boolean) => {
     ].filter((el: any) => el != null);
   }
 
-  let filter = {
+  const filter = {
     logic: 'and',
     filters: params
   };
@@ -917,7 +917,7 @@ export const calculateCrossMonthAverages = async (
   let groupValues: string[] = []; // 存储单元格引用
   let groupPositions: { month: number; day: number }[] = []; // 记录每个值的位置
   let validDataCount = 0; // 记录当前组中有效数据的数量
-  let protectedRanges: any[] = [];
+  const protectedRanges: any[] = [];
   for (let month = 1; month <= 12; month++) {
     const dataRow = month * 2 + 1; // 当前月份的数据行
     const daysInMonth = getDaysInMonth(year, month); // 根据年份获取该月天数
@@ -958,7 +958,7 @@ export const calculateCrossMonthAverages = async (
         if (validDataCount > 0) {
           // 构建平均值公式
           const range = groupValues.join(',');
-          let formula = `=ROUND(AVERAGE(${range}), 1)`;
+          const formula = `=ROUND(AVERAGE(${range}), 1)`;
 
           // 在组的最后一天显示平均值
           const lastPosition = groupPositions[groupValues.length - 1];
@@ -989,7 +989,7 @@ export const calculateCrossMonthAverages = async (
   if (groupValues.length > 0 && groupValues.length < 5 && validDataCount > 0) {
     // 构建平均值公式
     const range = groupValues.join(',');
-    let formula = `=ROUND(AVERAGE(${range}), 1)`;
+    const formula = `=ROUND(AVERAGE(${range}), 1)`;
 
     // 在组的最后一天显示平均值
     const lastPosition = groupPositions[groupValues.length - 1];
diff --git a/frontend/src/views/system/ConfigManagement/ConfigManagementForm.vue b/frontend/src/views/system/ConfigManagement/ConfigManagementForm.vue
new file mode 100644
index 00000000..96f6a7eb
--- /dev/null
+++ b/frontend/src/views/system/ConfigManagement/ConfigManagementForm.vue
@@ -0,0 +1,828 @@
+<template>
+  <a-modal
+    :title="isEdit ? '编辑沿程配置' : '新增沿程配置'"
+    v-model:open="modalVisible"
+    :confirm-loading="localLoading"
+    width="1200px"
+    :destroy-on-close="true"
+    ok-text="保存"
+    @cancel="handleCancel"
+    @ok="handleOk"
+  >
+    <a-form
+      ref="formRef"
+      :model="formData"
+      :rules="rules"
+      name="edit_form"
+      :labelCol="{ span: 5 }"
+    >
+      <a-row>
+        <a-col :span="12">
+          <a-form-item label="沿程配置名称" name="name">
+            <a-input
+              v-model:value="formData.name"
+              style="width: 100%"
+              placeholder="请输入沿程配置名称"
+            /> </a-form-item
+        ></a-col>
+        <a-col :span="12">
+          <a-form-item label="沿程配置编码" name="code">
+            <a-input
+              v-model:value="formData.code"
+              style="width: 100%"
+              placeholder="请输入沿程配置编码"
+            />
+          </a-form-item>
+        </a-col>
+      </a-row>
+      <a-row>
+        <a-col :span="12">
+          <a-form-item label="所在河段" name="rvcd">
+            <a-select
+              v-model:value="formData.rvcd"
+              show-search
+              style="width: 100%"
+              placeholder="请选择所在河段"
+              :options="riverOptions"
+              :filter-option="filterOption"
+              @change="handleRiverSelect"
+              :disabled="isEdit"
+            />
+          </a-form-item>
+        </a-col>
+        <a-col :span="12">
+          <a-form-item label="备注" name="remark">
+            <a-textarea
+              :rows="4"
+              v-model:value="formData.remark"
+              style="width: 100%"
+              placeholder="请输入备注"
+            />
+          </a-form-item>
+        </a-col>
+      </a-row>
+    </a-form>
+    <div class="config-tree-container">
+      <!-- 新增一级节点区域 -->
+      <div v-if="addingNewNode" class="add-node-row">
+        <a-select
+          v-model:value="newNodeData.stcd"
+          show-search
+          placeholder="请选择站点"
+          style="width: 300px"
+          :filter-option="filterOption"
+          @change="handleNodeSelect"
+        >
+          <a-select-option
+            v-for="item in stationList"
+            :key="item.stcd"
+            :value="item.stcd"
+          >
+            {{ item.stnm }}
+          </a-select-option>
+        </a-select>
+        <a-button
+          type="primary"
+          @click="handleSaveNewNode"
+          style="margin-left: 8px"
+        >
+          保存
+        </a-button>
+        <a-button @click="handleCancelAdd" style="margin-left: 8px">
+          <MinusOutlined />
+        </a-button>
+      </div>
+      <a-button v-else class="mb-4" type="primary" @click="handleAdd">
+        <PlusOutlined /> 新增一级节点
+      </a-button>
+
+      <!-- 树形结构 -->
+      <a-tree
+        v-if="treeData.length > 0"
+        :tree-data="treeData"
+        :default-expand-all="false"
+        :selectable="false"
+        block-node
+        style="width: 400px"
+      >
+        <template #title="{ dataRef }">
+          <!-- 编辑状态：只显示编辑区域 -->
+          <div
+            v-if="editingNode && editingNodeKey === dataRef.key"
+            class="add-child-node-row w-[300px]"
+          >
+            <a-select
+              v-model:value="editNodeData.stcd"
+              show-search
+              placeholder="请选择站点"
+              style="width: 300px"
+              :filter-option="filterOption"
+              @change="() => handleEditNodeSelect(dataRef)"
+            >
+              <a-select-option
+                v-for="item in dataRef.parentId
+                  ? childStationList
+                  : stationList"
+                :key="item.stcd"
+                :value="item.stcd"
+              >
+                {{ dataRef.parentId ? item.stnm : item.ennm }}
+              </a-select-option>
+            </a-select>
+            <a-button
+              type="primary"
+              @click.stop="handleSaveEditNode"
+              style="margin-left: 8px"
+            >
+              保存
+            </a-button>
+            <a-button
+              @click.stop="handleCancelEditNode"
+              style="margin-left: 8px"
+            >
+              <MinusOutlined />
+            </a-button>
+          </div>
+          <!-- 非编辑状态：显示正常节点内容 -->
+          <template v-else>
+            <div class="tree-node-wrapper">
+              <span class="tree-node-title"> {{ getNodeTitle(dataRef) }} </span>
+              <div class="tree-node-actions">
+                <!-- 一级节点：支持新增子节点、编辑、排序、删除 -->
+                <template v-if="!dataRef.parentId">
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleAddChild(dataRef)"
+                    :title="
+                      dataRef.sttpName
+                        ? `子级添加-${dataRef.sttpName}`
+                        : '子级添加'
+                    "
+                  >
+                    <PlusOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleEditNode(dataRef)"
+                    title="编辑"
+                  >
+                    <EditOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleMoveUp(dataRef)"
+                    title="上移"
+                    :disabled="isFirstNode(dataRef)"
+                  >
+                    <ArrowUpOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleMoveDown(dataRef)"
+                    title="下移"
+                    :disabled="isLastNode(dataRef)"
+                  >
+                    <ArrowDownOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    danger
+                    @click.stop="handleDeleteNode(dataRef)"
+                    title="删除"
+                  >
+                    <DeleteOutlined />
+                  </a-button>
+                </template>
+                <!-- 二级节点：只支持编辑、排序、删除 -->
+                <template v-else>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleEditNode(dataRef)"
+                    title="编辑"
+                  >
+                    <EditOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleMoveUp(dataRef)"
+                    title="上移"
+                    :disabled="isFirstNode(dataRef)"
+                  >
+                    <ArrowUpOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    @click.stop="handleMoveDown(dataRef)"
+                    title="下移"
+                    :disabled="isLastNode(dataRef)"
+                  >
+                    <ArrowDownOutlined />
+                  </a-button>
+                  <a-button
+                    type="link"
+                    size="small"
+                    danger
+                    @click.stop="handleDeleteNode(dataRef)"
+                    title="删除"
+                  >
+                    <DeleteOutlined />
+                  </a-button>
+                </template>
+              </div>
+            </div>
+            <!-- 子节点添加区域 -->
+            <div
+              v-if="addingChildNode && currentParentKey === dataRef.key"
+              class="add-child-node-row"
+            >
+              <a-select
+                v-model:value="childNodeData.stcd"
+                show-search
+                placeholder="请选择站点"
+                style="width: 300px"
+                :filter-option="filterOption"
+                @change="handleChildNodeSelect"
+              >
+                <a-select-option
+                  v-for="item in childStationList"
+                  :key="item.stcd"
+                  :value="item.stcd"
+                >
+                  {{ item.stnm }}-{{ item.sttpName }}
+                </a-select-option>
+              </a-select>
+              <a-button
+                type="primary"
+                @click.stop="handleSaveChildNode"
+                style="margin-left: 8px"
+              >
+                保存
+              </a-button>
+              <a-button
+                @click.stop="handleCancelAddChild"
+                style="margin-left: 8px"
+              >
+                <MinusOutlined />
+              </a-button>
+            </div>
+          </template>
+        </template>
+      </a-tree>
+      <a-empty v-else description="暂无数据" style="margin-top: 20px" />
+    </div>
+  </a-modal>
+</template>
+
+<script lang="ts" setup>
+import { ref, reactive, computed, watch } from 'vue';
+import { message, Modal } from 'ant-design-vue';
+import type { Rule } from 'ant-design-vue/es/form';
+import dayjs from 'dayjs';
+import {
+  PlusOutlined,
+  MinusOutlined,
+  EditOutlined,
+  DeleteOutlined,
+  ArrowUpOutlined,
+  ArrowDownOutlined
+} from '@ant-design/icons-vue';
+import { getEngInfoDropdown, getAddvcdDropdownByRvcd } from '@/api/select';
+
+interface Props {
+  visible: boolean;
+  initialValues?: any | null;
+  loading?: boolean;
+  riverOptions?: any[];
+}
+
+const localLoading = ref(false);
+const props = withDefaults(defineProps<Props>(), {
+  visible: false,
+  initialValues: null,
+  loading: false,
+  riverOptions: () => []
+});
+
+const modalVisible = computed({
+  get: () => props.visible,
+  set: val => emit('update:visible', val)
+});
+
+const emit = defineEmits<{
+  (e: 'update:visible', value: boolean): void;
+  (e: 'cancel'): void;
+  (e: 'ok', values: any): void;
+}>();
+
+const formRef = ref();
+
+const defaultFormData = reactive({
+  id: undefined,
+  name: undefined,
+  code: undefined,
+  rvcd: undefined,
+  remark: undefined
+});
+const formData: any = reactive({ ...defaultFormData });
+
+const rules: Record<string, Rule[]> = {
+  name: [{ required: true, message: '请输入沿程配置名称', trigger: 'blur' }],
+  code: [{ required: true, message: '请输入配置编码', trigger: 'blur' }],
+  rvcd: [{ required: true, message: '请选择所在河段', trigger: 'change' }]
+};
+
+const handleRiverSelect = async (value: string) => {
+  const res = await getEngInfoDropdown({ rvcd: value });
+  stationList.value = (res.data || []).map((item: any) => ({
+    ...item,
+    stnm: item.ennm
+  }));
+};
+
+const isEdit = computed(() => !!props.initialValues);
+
+// 树形数据
+const treeData = ref<any[]>([]);
+
+// 新增节点相关
+const addingNewNode = ref(false);
+const newNodeData = ref({
+  stcd: undefined,
+  ennm: '',
+  sttpName: ''
+});
+
+// 添加子节点相关
+const addingChildNode = ref(false);
+const currentParentKey = ref<string | null>(null);
+const childNodeData = ref({
+  stcd: undefined,
+  ennm: '',
+  sttpName: ''
+});
+
+// 编辑节点相关
+const editingNode = ref(false);
+const editingNodeKey = ref<string | null>(null);
+const editNodeData = ref({
+  stcd: undefined,
+  ennm: '',
+  sttpName: '',
+  originalData: null as any
+});
+
+const stationList = ref([]);
+const childStationList = ref([]);
+
+// 生成唯一ID
+let nodeIdCounter = 0;
+const generateNodeId = () => `node_${Date.now()}_${++nodeIdCounter}`;
+
+// 获取节点标题
+const getNodeTitle = (dataRef: any) => {
+  if (!dataRef.parentId) {
+    return dataRef.ennm || '';
+  } else {
+    return `${dataRef.ennm || ''} ${dataRef.sttpName || ''}`;
+  }
+};
+
+// 搜索过滤
+const filterOption = (inputValue: string, option: any) => {
+  const label = option.label || option.name || '';
+  const reachcdName = option.reachcdName || '';
+  const keyword = inputValue || '';
+
+  return label.indexOf(keyword) !== -1 || reachcdName.indexOf(keyword) !== -1;
+};
+
+// 判断是否为第一个节点
+const isFirstNode = (dataRef: any) => {
+  const siblings = getSiblings(dataRef);
+  return siblings.length > 0 && siblings[0].key === dataRef.key;
+};
+
+// 判断是否为最后一个节点
+const isLastNode = (dataRef: any) => {
+  const siblings = getSiblings(dataRef);
+  return (
+    siblings.length > 0 && siblings[siblings.length - 1].key === dataRef.key
+  );
+};
+
+// 获取兄弟节点
+const getSiblings = (dataRef: any) => {
+  if (!dataRef.parentId) {
+    // 一级节点
+    return treeData.value;
+  } else {
+    // 二级节点，找到父节点的 children
+    const parent = findNodeByKey(treeData.value, dataRef.parentId);
+    return parent?.children || [];
+  }
+};
+
+// 根据 key 查找节点
+const findNodeByKey = (nodes: any[], key: string): any => {
+  for (const node of nodes) {
+    if (node.key === key) {
+      return node;
+    }
+    if (node.children && node.children.length > 0) {
+      const found = findNodeByKey(node.children, key);
+      if (found) return found;
+    }
+  }
+  return null;
+};
+
+// 新增一级节点
+const handleAdd = () => {
+  if (!formData.rvcd) {
+    message.warning('请先选择所在河段');
+    return;
+  }
+  addingNewNode.value = true;
+  newNodeData.value = {
+    stcd: undefined,
+    ennm: '',
+    sttpName: ''
+  };
+};
+
+// 选择节点
+const handleNodeSelect = (value: string) => {
+  const station = stationList.value.find(item => item.stcd === value);
+  if (station) {
+    newNodeData.value.ennm = station.stnm;
+    newNodeData.value.sttpName = station.sttpName;
+  }
+};
+
+// 保存新增节点
+const handleSaveNewNode = () => {
+  if (!newNodeData.value.stcd) {
+    message.error('请选择站点');
+    return;
+  }
+
+  const newNode = {
+    key: generateNodeId(),
+    stcd: newNodeData.value.stcd,
+    ennm: newNodeData.value.ennm,
+    sttpName: newNodeData.value.sttpName,
+    parentId: null,
+    children: []
+  };
+
+  treeData.value.push(newNode);
+  addingNewNode.value = false;
+  message.success('添加成功');
+};
+
+// 取消新增
+const handleCancelAdd = () => {
+  addingNewNode.value = false;
+  newNodeData.value = {
+    stcd: undefined,
+    ennm: '',
+    sttpName: ''
+  };
+};
+
+// 添加子节点（二级节点）
+const handleAddChild = async (parentData: any) => {
+  addingChildNode.value = true;
+  currentParentKey.value = parentData.key;
+  childNodeData.value = {
+    stcd: undefined,
+    ennm: '',
+    sttpName: ''
+  };
+  const res = await getAddvcdDropdownByRvcd({ stcd: parentData.stcd });
+  childStationList.value = res.data || [];
+};
+
+// 选择子节点
+const handleChildNodeSelect = (value: string) => {
+  const station = childStationList.value.find(item => item.stcd === value);
+  if (station) {
+    childNodeData.value.ennm = station.stnm;
+    childNodeData.value.sttpName = station.sttpName;
+  }
+};
+
+// 保存新增子节点
+const handleSaveChildNode = () => {
+  if (!childNodeData.value.stcd) {
+    message.error('请选择站点');
+    return;
+  }
+
+  const parent = findNodeByKey(treeData.value, currentParentKey.value!);
+  if (!parent) {
+    message.error('父节点不存在');
+    return;
+  }
+
+  const newChild = {
+    key: generateNodeId(),
+    stcd: childNodeData.value.stcd,
+    ennm: childNodeData.value.ennm,
+    sttpName: childNodeData.value.sttpName,
+    parentId: parent.key,
+    children: []
+  };
+
+  if (!parent.children) {
+    parent.children = [];
+  }
+  // 在子节点列表顶部添加
+  parent.children.unshift(newChild);
+
+  addingChildNode.value = false;
+  currentParentKey.value = null;
+  message.success('添加子节点成功');
+};
+
+// 取消添加子节点
+const handleCancelAddChild = () => {
+  addingChildNode.value = false;
+  currentParentKey.value = null;
+  childNodeData.value = {
+    stcd: undefined,
+    ennm: '',
+    sttpName: ''
+  };
+};
+
+// 编辑节点
+const handleEditNode = async (dataRef: any) => {
+  editingNode.value = true;
+  editingNodeKey.value = dataRef.key;
+  // 保存原始数据
+  editNodeData.value = {
+    stcd: dataRef.stcd,
+    ennm: dataRef.ennm,
+    sttpName: dataRef.sttpName,
+    originalData: { ...dataRef }
+  };
+  if (dataRef.parentId) {
+    const parent = findNodeByKey(treeData.value, dataRef.parentId);
+    if (parent) {
+      const res = await getAddvcdDropdownByRvcd({ stcd: parent.stcd });
+      childStationList.value = res.data || [];
+    }
+  }
+};
+
+// 选择编辑节点
+const handleEditNodeSelect = (dataRef: any) => {
+  const value = editNodeData.value.stcd;
+  const list = dataRef.parentId ? childStationList.value : stationList.value;
+  const station = list.find(item => item.stcd === value);
+  if (station) {
+    editNodeData.value.ennm = station.stnm;
+    editNodeData.value.sttpName = station.sttpName;
+    editNodeData.value.stcd = station.stcd;
+  }
+};
+
+// 保存编辑节点
+const handleSaveEditNode = () => {
+  if (!editNodeData.value.stcd) {
+    message.error('请选择站点');
+    return;
+  }
+
+  // 找到要编辑的节点
+  const node = findNodeByKey(treeData.value, editingNodeKey.value!);
+  if (!node) {
+    message.error('节点不存在');
+    return;
+  }
+
+  // 更新节点数据
+  node.stcd = editNodeData.value.stcd;
+  node.ennm = editNodeData.value.ennm;
+  node.sttpName = editNodeData.value.sttpName;
+
+  editingNode.value = false;
+  editingNodeKey.value = null;
+  message.success('编辑成功');
+};
+
+// 取消编辑节点
+const handleCancelEditNode = () => {
+  editingNode.value = false;
+  editingNodeKey.value = null;
+  editNodeData.value = {
+    stcd: undefined,
+    ennm: '',
+    sttpName: '',
+    originalData: null
+  };
+};
+
+// 上移
+const handleMoveUp = (dataRef: any) => {
+  const siblings = getSiblings(dataRef);
+  const index = siblings.findIndex(item => item.key === dataRef.key);
+
+  if (index > 0) {
+    // 交换位置
+    [siblings[index - 1], siblings[index]] = [
+      siblings[index],
+      siblings[index - 1]
+    ];
+    message.success('上移成功');
+  }
+};
+
+// 下移
+const handleMoveDown = (dataRef: any) => {
+  const siblings = getSiblings(dataRef);
+  const index = siblings.findIndex(item => item.key === dataRef.key);
+
+  if (index < siblings.length - 1) {
+    // 交换位置
+    [siblings[index], siblings[index + 1]] = [
+      siblings[index + 1],
+      siblings[index]
+    ];
+    message.success('下移成功');
+  }
+};
+
+// 删除节点
+const handleDeleteNode = (dataRef: any) => {
+  Modal.confirm({
+    title: '确认删除',
+    content: `确定要删除节点"${dataRef.ennm}"吗？`,
+    okText: '确定',
+    cancelText: '取消',
+    onOk: () => {
+      if (!dataRef.parentId) {
+        // 删除一级节点
+        const index = treeData.value.findIndex(
+          item => item.key === dataRef.key
+        );
+        if (index > -1) {
+          treeData.value.splice(index, 1);
+        }
+      } else {
+        // 删除二级节点
+        const parent = findNodeByKey(treeData.value, dataRef.parentId);
+        if (parent && parent.children) {
+          const index = parent.children.findIndex(
+            item => item.key === dataRef.key
+          );
+          if (index > -1) {
+            parent.children.splice(index, 1);
+          }
+        }
+      }
+      message.success('删除成功');
+    }
+  });
+};
+
+const handleOk = async () => {
+  try {
+    await formRef.value.validate();
+    const submitValues = {
+      ...formData,
+      captureDate: formData.captureDate
+        ? dayjs(formData.captureDate).format('YYYY-MM-DD')
+        : undefined,
+      configNodes: treeData.value // 提交树形数据
+    };
+    emit('ok', submitValues);
+  } catch (error) {
+    console.error('Validate Failed:', error);
+    message.error('请检查表单填写是否正确');
+  }
+};
+
+const initForm = async () => {
+  if (props.initialValues) {
+    const values = props.initialValues;
+    Object.keys(formData).forEach(key => {
+      if (values.hasOwnProperty(key)) {
+        if (key === 'captureDate' && values[key]) {
+          formData[key] = dayjs(values[key]);
+        } else {
+          formData[key] = values[key];
+        }
+      }
+    });
+
+    // 初始化树形数据
+    if (values.configNodes && Array.isArray(values.configNodes)) {
+      treeData.value = values.configNodes.map((node: any) => ({
+        ...node,
+        children:
+          node.children?.map((child: any) => ({
+            ...child
+          })) || []
+      }));
+    } else {
+      treeData.value = [];
+    }
+
+    // 编辑时调用接口获取一级站点列表
+    if (formData.rvcd) {
+      const res = await getEngInfoDropdown({ rvcd: formData.rvcd });
+      stationList.value = (res.data || []).map((item: any) => ({
+        ...item,
+        stnm: item.ennm
+      }));
+    }
+  } else {
+    resetForm();
+  }
+};
+
+const resetForm = () => {
+  if (formRef.value) {
+    formRef.value.resetFields();
+  }
+  Object.assign(formData, defaultFormData);
+  treeData.value = [];
+  addingNewNode.value = false;
+};
+
+const handleCancel = () => {
+  emit('update:visible', false);
+  emit('cancel');
+  resetForm();
+};
+
+watch(
+  () => props.visible,
+  newVisible => {
+    if (newVisible) {
+      initForm();
+    }
+  },
+  { immediate: false }
+);
+
+defineExpose({
+  localLoading
+});
+</script>
+
+<style scoped lang="scss">
+.config-tree-container {
+  margin-top: 16px;
+
+  .add-node-row {
+    display: flex;
+    align-items: center;
+    margin-bottom: 16px;
+  }
+}
+
+.tree-node-wrapper {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  width: 100%;
+  padding-right: 8px;
+
+  .tree-node-title {
+    flex: 1;
+  }
+
+  .tree-node-actions {
+    opacity: 0;
+    transition: opacity 0.2s;
+  }
+}
+
+// 确保鼠标悬停时显示操作按钮
+.tree-node-wrapper:hover {
+  .tree-node-actions {
+    opacity: 1;
+  }
+}
+
+// 子节点添加区域样式
+.add-child-node-row {
+  display: flex;
+  align-items: center;
+  padding: 8px 0 8px 24px;
+  margin-top: 4px;
+  background-color: #f5f5f5;
+  border-radius: 4px;
+}
+</style>
diff --git a/frontend/src/views/system/ConfigManagement/ConfigManagementSearch.vue b/frontend/src/views/system/ConfigManagement/ConfigManagementSearch.vue
new file mode 100644
index 00000000..91cd9b3b
--- /dev/null
+++ b/frontend/src/views/system/ConfigManagement/ConfigManagementSearch.vue
@@ -0,0 +1,83 @@
+<template>
+  <div class="content-search">
+    <BasicSearch
+      ref="basicSearchRef"
+      :searchList="searchList"
+      :initial-values="initSearchData"
+      @reset="handleReset"
+      @finish="onSearchFinish"
+      @values-change="onValuesChange"
+    >
+      <template #actions>
+        <a-tooltip title="新增配置">
+          <a-button @click="props.handleAdd" type="primary">
+            新增沿程配置
+          </a-button>
+        </a-tooltip>
+      </template>
+    </BasicSearch>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { ref, computed, onMounted } from 'vue';
+import BasicSearch from '@/components/BasicSearch/index.vue';
+
+interface Props {
+  handleAdd: () => void;
+  riverOptions: any[];
+  riverOptionsLoad: boolean;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits<{
+  (e: 'reset', values: any): void;
+  (e: 'searchFinish', values: any): void;
+}>();
+
+const initSearchData = {
+  name: null,
+  rvcd: null
+};
+
+const searchData = ref<any>({ ...initSearchData });
+const searchList: any = computed(() => [
+  {
+    type: 'Input',
+    name: 'name',
+    label: '沿程配置名称',
+    fieldProps: {
+      allowClear: true
+    }
+  },
+  {
+    type: 'Select',
+    name: 'rvcd',
+    label: '所在河段',
+    width: 300,
+    fieldProps: {
+      allowClear: true
+    },
+    options: props.riverOptions,
+    loading: props.riverOptionsLoad
+  }
+]);
+
+const onSearchFinish = (values: any) => {
+  emit('searchFinish', values);
+};
+
+const onValuesChange = (changedValues: any, allValues: any) => {
+  searchData.value = { ...searchData.value, ...allValues };
+};
+
+const handleReset = () => {
+  emit('reset', initSearchData);
+};
+
+onMounted(() => {
+  emit('searchFinish', initSearchData);
+});
+</script>
+<style lang="scss"></style>
diff --git a/frontend/src/views/system/ConfigManagement/index.vue b/frontend/src/views/system/ConfigManagement/index.vue
new file mode 100644
index 00000000..2e3570c1
--- /dev/null
+++ b/frontend/src/views/system/ConfigManagement/index.vue
@@ -0,0 +1,379 @@
+<!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\components\ConfigManagement\index.vue -->
+<template>
+  <div class="content">
+    <ConfigManagementSearch
+      ref="configManagementSearch"
+      :handle-add="handleAdd"
+      :river-options="riverOptions"
+      :river-options-load="riverOptionsLoad"
+      @reset="handleReset"
+      @search-finish="onSearchFinish"
+    />
+    <BasicTable
+      ref="basicTable"
+      :columns="columns"
+      :list-url="getAllConfigTree"
+      :search-params="searchParams"
+    >
+      <template #action="{ record }">
+        <div class="flex gap-[6px]">
+          <a-button
+            class="!p-0"
+            type="link"
+            size="small"
+            @click="handleEdit(record)"
+            >编辑</a-button
+          >
+          <a-button
+            class="!p-0"
+            type="link"
+            size="small"
+            danger
+            @click="handleDelete(record)"
+            >删除</a-button
+          >
+        </div>
+      </template>
+    </BasicTable>
+    <ConfigManagementForm
+      ref="configManagementForm"
+      v-model:visible="editModalVisible"
+      :initial-values="currentRecord"
+      :river-options="riverOptions"
+      :river-options-load="riverOptionsLoad"
+      @cancel="editModalCancel"
+      @ok="handleEditSubmit"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, nextTick, onMounted } from 'vue';
+import BasicTable from '@/components/BasicTable/index.vue';
+import ConfigManagementSearch from './ConfigManagementSearch.vue';
+import ConfigManagementForm from './ConfigManagementForm.vue';
+import { message, Modal } from 'ant-design-vue';
+import {
+  getAllConfigTree,
+  deleteBaseWbsb,
+  saveBaseWbsbChild,
+  saveBaseWbsbChildDetail,
+  getChildConfigTree
+} from '@/api/system/map/ConfigManagement';
+import { getRvcdDropdown } from '@/api/select';
+import dayjs from 'dayjs';
+
+// 表格实例
+const basicTable = ref<any>(null);
+// 表格列配置
+const columns = [
+  {
+    title: '序号',
+    dataIndex: 'index',
+    key: 'index',
+    width: 60,
+    align: 'center',
+    customRender: ({ index }) => index + 1
+  },
+  {
+    title: '沿程配置名称',
+    dataIndex: 'name',
+    key: 'name',
+    width: 150
+  },
+  {
+    title: '配置编码',
+    key: 'code',
+    dataIndex: 'code',
+    width: 120
+  },
+  {
+    title: '所在河段',
+    dataIndex: 'rvnm',
+    key: 'rvnm',
+    width: 300,
+    ellipsis: true
+  },
+  {
+    title: '创建人',
+    key: 'recordUser',
+    width: 120,
+    dataIndex: 'recordUser'
+  },
+  {
+    title: '创建时间',
+    key: 'recordTime',
+    dataIndex: 'recordTime',
+    width: 150
+  },
+  {
+    title: '更新时间',
+    key: 'modifyTime',
+    dataIndex: 'modifyTime',
+    width: 150
+  },
+  {
+    title: '备注',
+    dataIndex: 'remark',
+    key: 'remark',
+    width: 360
+  },
+  {
+    title: '操作',
+    key: 'action',
+    width: 120,
+    fixed: 'right',
+    slots: { customRender: 'action' }
+  }
+];
+
+// 搜索参数
+const searchParams = ref({
+  "sort": [
+        {
+            "field": "recordTime",
+            "dir": "desc"
+        }
+    ],
+});
+// 编辑弹窗数据
+const currentRecord = ref<any | null>(null);
+const editModalVisible = ref(false);
+
+// 新增处理
+const handleAdd = () => {
+  currentRecord.value = null;
+  editModalVisible.value = true;
+};
+
+// 过滤掉值为 '-' 的字段
+const filterRecord = (record: any) => {
+  const filtered: any = {};
+  Object.keys(record).forEach(key => {
+    if (record[key] !== '-') {
+      filtered[key] = record[key];
+    }
+  });
+  return filtered;
+};
+
+// 编辑处理
+const handleEdit = async (record: any) => {
+  currentRecord.value = filterRecord(record);
+  const params = {
+    filter: {
+      logic: 'and',
+      filters: [
+        {
+          field: 'alongId',
+          operator: 'eq',
+          value: record.id
+        }
+      ]
+    },
+    sort: [
+      {
+        field: 'sort',
+        dir: 'asc'
+      }
+    ]
+  };
+  const res = await getChildConfigTree(params);
+  if (res.code == 0) {
+    const data = res.data.data || [];
+    const firstLevelNodes = data.filter((item: any) => !item.rstcd);
+    const secondLevelNodes = data.filter((item: any) => item.rstcd);
+
+    const configNodes = firstLevelNodes.map((node: any, index: number) => {
+      const children = secondLevelNodes.filter(
+        (child: any) => child.rstcd === node.stcd
+      );
+
+      return {
+        key: `parent-${index}`,
+        stcd: node.stcd,
+        ennm: node.stnm,
+        sttpName: node.sttpName,
+        parentId: null,
+        children: children.map((child: any, childIndex: number) => ({
+          key: `child-${index}-${childIndex}`,
+          stcd: child.stcd,
+          ennm: child.stnm,
+          sttpName: child.sttpName,
+          parentId: `parent-${index}`,
+          children: []
+        }))
+      };
+    });
+
+    currentRecord.value.configNodes = configNodes;
+  }
+  editModalVisible.value = true;
+};
+
+// 删除处理
+const handleDelete = (record: any) => {
+  Modal.confirm({
+    title: '确认删除',
+    content: '确定要删除选中的记录吗？',
+    zIndex: 2002,
+    onOk: async () => {
+      try {
+        let res = await deleteBaseWbsb([record.id]);
+        if (res.code == 0) {
+          message.success('删除成功');
+          basicTable.value.refresh();
+        } else {
+          message.error('删除失败');
+        }
+      } catch (error) {
+        message.error('删除失败');
+        return;
+      }
+    }
+  });
+};
+
+// 搜索完成处理
+const onSearchFinish = (values: any) => {
+  const params = {
+    logic: 'and',
+    filters: [
+      values.rvcd
+        ? {
+            field: 'rvcd',
+            operator: 'eq',
+            dataType: 'string',
+            value: values.rvcd
+          }
+        : null,
+      values.name
+        ? {
+            field: 'name',
+            operator: 'contains',
+            dataType: 'string',
+            value: values.name
+          }
+        : null
+    ].filter(Boolean)
+  };
+  basicTable.value.getList(params);
+};
+
+// 重置
+const handleReset = () => {
+  basicTable.value.getList({
+    logic: 'and',
+    filters: []
+  });
+};
+
+// 表单取消
+const editModalCancel = () => {
+  currentRecord.value = null;
+  editModalVisible.value = false;
+};
+
+// 表单提交
+const handleEditSubmit = async (values: any) => {
+  try {
+    const formData = {
+      ...currentRecord.value,
+      ...values,
+      modifyTime: dayjs().format('YYYY-MM-DD HH:mm:ss')
+    };
+    delete formData.configNodes;
+
+    Object.keys(formData).forEach(key => {
+      if (key.includes('-')) {
+        delete formData[key];
+      }
+    });
+
+    let res = await saveBaseWbsbChild(formData);
+    if (res.code == 0) {
+      const alongId = res.data;
+      const treeData = values.configNodes || [];
+
+      if (treeData.length > 0) {
+        const formatTreeData = (
+          nodes: any[],
+          parentId: string | null = null,
+          parentStcd: string | null = null
+        ) => {
+          return nodes.map(node => ({
+            alongId,
+            stcd: node.stcd,
+            stnm: node.ennm || node.stnm,
+            sttpName: node.sttpName,
+            parentId: parentId ? parentId : null,
+            rstcd: parentStcd || null,
+            children:
+              node.children && node.children.length > 0
+                ? formatTreeData(node.children, node.key, node.stcd)
+                : []
+          }));
+        };
+
+        const detailData = formatTreeData(treeData);
+
+        const detailRes = await saveBaseWbsbChildDetail(detailData);
+        if (detailRes.code == 0) {
+          message.success(`保存成功`);
+          editModalVisible.value = false;
+          basicTable.value.refresh();
+        } else {
+          message.error(`保存子节点失败`);
+        }
+      } else {
+        message.success(`保存成功`);
+        editModalVisible.value = false;
+        basicTable.value.refresh();
+      }
+    } else {
+      message.error(`保存失败`);
+    }
+  } catch (error) {
+    message.error(`保存失败`);
+    editModalVisible.value = false;
+    return;
+  }
+};
+const riverOptions = ref<any>([]);
+const riverOptionsLoad = ref(false);
+const initOption = () => {
+  const params = {};
+  riverOptionsLoad.value = true;
+  getRvcdDropdown(params).then((res: any) => {
+    res.data.forEach((item: any) => {
+      item.value = item.rvcd;
+      item.label = item.rvnm;
+    });
+    riverOptions.value = res.data || [];
+    riverOptionsLoad.value = false;
+  });
+};
+onMounted(() => {
+  initOption();
+});
+</script>
+
+<style scoped lang="scss">
+.content {
+  position: relative;
+  z-index: 900;
+  pointer-events: all;
+  width: 100%;
+  height: 100%;
+  background-color: #ffffff;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  box-sizing: border-box;
+  overflow: hidden;
+}
+.config-management {
+  height: 100%;
+  padding: 16px;
+}
+</style>
diff --git a/frontend/src/views/system/StationManagement/StationManagementForm.vue b/frontend/src/views/system/StationManagement/StationManagementForm.vue
new file mode 100644
index 00000000..f64ef6db
--- /dev/null
+++ b/frontend/src/views/system/StationManagement/StationManagementForm.vue
@@ -0,0 +1,160 @@
+<template>
+  <a-modal
+    :title="isEdit ? '编辑电站' : '新增电站'"
+    v-model:open="modalVisible"
+    :confirm-loading="localLoading"
+    width="600px"
+    :destroy-on-close="true"
+    @cancel="handleCancel"
+    @ok="handleOk"
+  >
+    <a-form
+      ref="formRef"
+      :model="formData"
+      :rules="rules"
+      name="edit_form"
+      :labelCol="{ span: 5 }"
+    >
+      <a-form-item label="电站名称" name="stationName">
+        <a-input
+          v-model:value="formData.stationName"
+          style="width: 100%"
+          placeholder="请输入电站名称"
+        />
+      </a-form-item>
+      <a-form-item label="所属流域" name="basin">
+        <a-input
+          v-model:value="formData.basin"
+          style="width: 100%"
+          placeholder="请输入所属流域"
+        />
+      </a-form-item>
+      <a-form-item label="装机容量(MW)" name="capacity">
+        <a-input-number
+          v-model:value="formData.capacity"
+          style="width: 100%"
+          placeholder="请输入装机容量"
+          :min="0"
+        />
+      </a-form-item>
+      <a-form-item label="状态" name="status">
+        <a-select v-model:value="formData.status" style="width: 100%">
+          <a-select-option value="running">运行中</a-select-option>
+          <a-select-option value="stopped">停运</a-select-option>
+        </a-select>
+      </a-form-item>
+      <a-form-item label="位置坐标" name="coordinates">
+        <a-input
+          v-model:value="formData.coordinates"
+          style="width: 100%"
+          placeholder="请输入位置坐标"
+        />
+      </a-form-item>
+    </a-form>
+  </a-modal>
+</template>
+
+<script lang="ts" setup>
+import { ref, reactive, computed, watch } from 'vue';
+import { message } from 'ant-design-vue';
+import type { Rule } from 'ant-design-vue/es/form';
+
+interface Props {
+  visible: boolean;
+  initialValues?: any | null;
+  loading?: boolean;
+}
+
+const localLoading = ref(false);
+const props = withDefaults(defineProps<Props>(), {
+  visible: false,
+  initialValues: null,
+  loading: false
+});
+
+const modalVisible = computed({
+  get: () => props.visible,
+  set: val => emit('update:visible', val)
+});
+
+const emit = defineEmits<{
+  (e: 'update:visible', value: boolean): void;
+  (e: 'cancel'): void;
+  (e: 'ok', values: any): void;
+}>();
+
+const formRef = ref();
+
+const defaultFormData = reactive({
+  id: undefined,
+  stationName: undefined,
+  basin: undefined,
+  capacity: undefined,
+  status: undefined,
+  coordinates: undefined
+});
+const formData: any = reactive({ ...defaultFormData });
+
+const rules: Record<string, Rule[]> = {
+  stationName: [{ required: true, message: '请输入电站名称', trigger: 'blur' }],
+  basin: [{ required: true, message: '请输入所属流域', trigger: 'blur' }],
+  capacity: [{ required: true, message: '请输入装机容量', trigger: 'blur' }]
+};
+
+const isEdit = computed(() => !!props.initialValues);
+
+const handleOk = async () => {
+  try {
+    await formRef.value.validate();
+    const submitValues = {
+      ...formData
+    };
+    emit('ok', submitValues);
+  } catch (error) {
+    console.error('Validate Failed:', error);
+    message.error('请检查表单填写是否正确');
+  }
+};
+
+const initForm = () => {
+  if (props.initialValues) {
+    const values = props.initialValues;
+    Object.keys(formData).forEach(key => {
+      if (values.hasOwnProperty(key)) {
+        formData[key] = values[key];
+      }
+    });
+  } else {
+    resetForm();
+  }
+};
+
+const resetForm = () => {
+  if (formRef.value) {
+    formRef.value.resetFields();
+  }
+  Object.assign(formData, defaultFormData);
+};
+
+const handleCancel = () => {
+  emit('update:visible', false);
+  emit('cancel');
+  resetForm();
+};
+
+watch(
+  () => props.visible,
+  newVisible => {
+    if (newVisible) {
+      initForm();
+    }
+  },
+  { immediate: false }
+);
+
+defineExpose({
+  localLoading
+});
+</script>
+
+<style scoped lang="scss"></style>
diff --git a/frontend/src/views/system/StationManagement/StationManagementSearch.vue b/frontend/src/views/system/StationManagement/StationManagementSearch.vue
new file mode 100644
index 00000000..662624b7
--- /dev/null
+++ b/frontend/src/views/system/StationManagement/StationManagementSearch.vue
@@ -0,0 +1,67 @@
+<template>
+  <div class="content-search">
+    <BasicSearch
+      ref="basicSearchRef"
+      :searchList="searchList"
+      :initial-values="initSearchData"
+      @reset="handleReset"
+      @finish="onSearchFinish"
+      @values-change="onValuesChange"
+    >
+      <template #actions>
+        <a-tooltip title="新增电站">
+          <a-button @click="props.handleAdd" type="primary"> 新增电站 </a-button>
+        </a-tooltip>
+      </template>
+    </BasicSearch>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { ref, computed, onMounted } from "vue";
+import BasicSearch from "@/components/BasicSearch/index.vue";
+
+interface Props {
+  handleAdd: () => void;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits<{
+  (e: "reset", values: any): void;
+  (e: "searchFinish", values: any): void;
+}>();
+
+const initSearchData = {
+  stationName: "",
+};
+
+const searchData = ref<any>({ ...initSearchData });
+const searchList: any = computed(() => [
+  {
+    type: "Input",
+    name: "stationName",
+    label: "电站名称",
+    fieldProps: {
+      allowClear: true,
+    },
+  },
+]);
+
+const onSearchFinish = (values: any) => {
+  emit("searchFinish", values);
+};
+
+const onValuesChange = (changedValues: any, allValues: any) => {
+  searchData.value = { ...searchData.value, ...allValues };
+};
+
+const handleReset = () => {
+  emit("reset", initSearchData);
+};
+
+onMounted(() => {
+  emit("searchFinish", initSearchData);
+});
+</script>
+<style lang="scss"></style>
diff --git a/frontend/src/views/system/StationManagement/index.vue b/frontend/src/views/system/StationManagement/index.vue
new file mode 100644
index 00000000..b74d178f
--- /dev/null
+++ b/frontend/src/views/system/StationManagement/index.vue
@@ -0,0 +1,203 @@
+<!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\components\StationManagement\index.vue -->
+<template>
+  <div class="content">
+    <StationManagementSearch
+      ref="stationManagementSearch"
+      :handle-add="handleAdd"
+      @reset="handleReset"
+      @search-finish="onSearchFinish"
+    />
+    <BasicTable
+      :columns="columns"
+      :data="dataSource"
+      :list-url="fetchStationData"
+      :search-params="searchParams"
+      :enable-row-selection="true"
+      @selection-change="handleSelectionChange"
+    >
+      <template #action="{ column, record }">
+        <a-space>
+          <a-button type="link" size="small" @click="handleEdit(record)"
+            >编辑</a-button
+          >
+          <a-button
+            type="link"
+            size="small"
+            danger
+            @click="handleDelete(record)"
+            >删除</a-button
+          >
+        </a-space>
+      </template>
+      <template #status="{ column, record }">
+        <a-tag :color="record.status === 'running' ? 'green' : 'red'">
+          {{ record.status === 'running' ? '运行中' : '停运' }}
+        </a-tag>
+      </template>
+    </BasicTable>
+    <StationManagementForm
+      ref="stationManagementForm"
+      v-model:visible="editModalVisible"
+      :initial-values="currentRecord"
+      @cancel="editModalCancel"
+      @ok="handleEditSubmit"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue';
+import BasicTable from '@/components/BasicTable/index.vue';
+import StationManagementSearch from './StationManagementSearch.vue';
+import StationManagementForm from './StationManagementForm.vue';
+import { message } from 'ant-design-vue';
+
+// 表格列配置
+const columns = [
+  {
+    title: '电站名称',
+    dataIndex: 'stationName',
+    key: 'stationName',
+    width: 150
+  },
+  {
+    title: '所属流域',
+    dataIndex: 'basin',
+    key: 'basin',
+    width: 120
+  },
+  {
+    title: '装机容量(MW)',
+    dataIndex: 'capacity',
+    key: 'capacity',
+    width: 120
+  },
+  {
+    title: '状态',
+    key: 'status',
+    dataIndex: 'status',
+    width: 100,
+    slots: { customRender: 'status' }
+  },
+  {
+    title: '位置坐标',
+    dataIndex: 'coordinates',
+    key: 'coordinates',
+    ellipsis: true
+  },
+  {
+    title: '操作',
+    key: 'action',
+    width: 150,
+    fixed: 'right',
+    slots: { customRender: 'action' }
+  }
+];
+
+// 搜索参数
+const searchParams = ref({});
+// 编辑弹窗数据
+const currentRecord = ref<any | null>(null);
+const editModalVisible = ref(false);
+
+// 数据源
+const dataSource = ref([]);
+
+// 模拟数据获取函数
+const fetchStationData = (params: any) => {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve({
+        data: {
+          records: [
+            {
+              id: 1,
+              stationName: '三峡电站',
+              basin: '长江流域',
+              capacity: 22500,
+              status: 'running',
+              coordinates: '111.29,30.83'
+            },
+            {
+              id: 2,
+              stationName: '葛洲坝电站',
+              basin: '长江流域',
+              capacity: 2715,
+              status: 'running',
+              coordinates: '111.28,30.75'
+            },
+            {
+              id: 3,
+              stationName: '溪洛渡电站',
+              basin: '金沙江流域',
+              capacity: 13860,
+              status: 'stopped',
+              coordinates: '103.65,28.25'
+            }
+          ],
+          total: 3
+        }
+      });
+    }, 500);
+  });
+};
+
+const handleAdd = () => {
+  currentRecord.value = null;
+  editModalVisible.value = true;
+};
+
+// 编辑处理
+const handleEdit = (record: any) => {
+  currentRecord.value = { ...record };
+  editModalVisible.value = true;
+};
+
+// 删除处理
+const handleDelete = (record: any) => {
+  message.warning(`删除电站: ${record.stationName}`);
+};
+
+// 搜索完成处理
+const onSearchFinish = (values: any) => {
+  console.log(values);
+};
+
+// 重置
+const handleReset = (params: any) => {};
+
+// 选择变化处理
+const handleSelectionChange = (selectedRows: any[]) => {
+  console.log('选中的行:', selectedRows);
+};
+
+// 表单取消
+const editModalCancel = () => {
+  editModalVisible.value = false;
+};
+
+// 表单提交
+const handleEditSubmit = (values: any) => {
+  console.log(values);
+};
+</script>
+
+<style scoped lang="scss">
+.content {
+  position: relative;
+  z-index: 900;
+  pointer-events: all;
+  width: 100%;
+  height: 100%;
+  background-color: #ffffff;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  box-sizing: border-box;
+  overflow: hidden;
+}
+.station-management {
+  height: 100%;
+  padding: 16px;
+}
+</style>
diff --git a/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementForm.vue b/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementForm.vue
new file mode 100644
index 00000000..165aa7f6
--- /dev/null
+++ b/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementForm.vue
@@ -0,0 +1,249 @@
+<template>
+  <a-modal
+    :title="isEdit ? '编辑倾斜摄影' : '新增倾斜摄影'"
+    v-model:open="modalVisible"
+    :confirm-loading="localLoading"
+    width="600px"
+    :destroy-on-close="true"
+    ok-text="保存"
+    @cancel="handleCancel"
+    @ok="handleOk"
+  >
+    <a-form
+      ref="formRef"
+      :model="formData"
+      :rules="rules"
+      name="edit_form"
+      :labelCol="{ span: 5 }"
+    >
+      <a-form-item label="倾斜影像名称" name="stnm">
+        <a-input
+          v-model:value="formData.stnm"
+          style="width: 100%"
+          placeholder="请输入倾斜影像名称"
+        />
+      </a-form-item>
+      <a-form-item label="所在河段" name="hbrvcd">
+        <a-select
+          v-model:value="formData.hbrvcd"
+          show-search
+          style="width: 100%"
+          placeholder="请选择所在河段"
+          :options="riverOptions"
+          :filter-option="filterOption"
+          :disabled="isEdit"
+          @change="handleRiverSelect"
+        />
+      </a-form-item>
+      <a-form-item label="所属电站" name="rstcd">
+        <a-select
+          v-model:value="formData.rstcd"
+          show-search
+          style="width: 100%"
+          placeholder="请选择所属电站"
+          :options="ennmOptions"
+          :filter-option="filterOption"
+          :disabled="isEdit"
+        />
+        <!-- <a-input
+          v-model:value="formData.ennm"
+          style="width: 100%"
+          placeholder="请输入所属电站"
+        /> -->
+      </a-form-item>
+      <a-form-item label="倾斜影像URL" name="url">
+        <a-input
+          v-model:value="formData.url"
+          style="width: 100%"
+          placeholder="请输入倾斜影像URL"
+        />
+      </a-form-item>
+      <a-form-item label="模型坐标" name="location">
+        <a-textarea
+          v-model:value="formData.location"
+          :rows="4"
+          style="width: 100%"
+          placeholder="请输入模型坐标"
+        />
+      </a-form-item>
+      <a-form-item label="模型精度" name="accuracy">
+        <a-input-number
+          v-model:value="formData.accuracy"
+          style="width: 100%"
+          placeholder="请输入模型精度"
+          :min="0"
+        />
+      </a-form-item>
+      <a-form-item label="边界范围" name="boundary">
+        <a-textarea
+          v-model:value="formData.boundary"
+          :rows="4"
+          style="width: 100%"
+          placeholder="请输入边界范围"
+        />
+      </a-form-item>
+      <a-form-item label="模型高度" name="height">
+        <a-input-number
+          v-model:value="formData.height"
+          style="width: 100%"
+          placeholder="请输入模型高度"
+          :min="0"
+        />
+      </a-form-item>
+      <a-form-item label="备注" name="comments">
+        <a-textarea
+          v-model:value="formData.comments"
+          :rows="4"
+          style="width: 100%"
+          placeholder="请输入备注"
+        />
+      </a-form-item>
+    </a-form>
+  </a-modal>
+</template>
+
+<script lang="ts" setup>
+import { ref, reactive, computed, watch } from 'vue';
+import { message } from 'ant-design-vue';
+import type { Rule } from 'ant-design-vue/es/form';
+import dayjs from 'dayjs';
+import { getEngInfoDropdown } from '@/api/select';
+interface Props {
+  visible: boolean;
+  initialValues?: any | null;
+  loading?: boolean;
+  riverOptions?: any[];
+}
+const localLoading = ref(false);
+const props = withDefaults(defineProps<Props>(), {
+  visible: false,
+  initialValues: null,
+  loading: false,
+  riverOptions: () => []
+});
+
+const modalVisible = computed({
+  get: () => props.visible,
+  set: val => emit('update:visible', val)
+});
+
+const emit = defineEmits<{
+  (e: 'update:visible', value: boolean): void;
+  (e: 'cancel'): void;
+  (e: 'ok', values: any): void;
+}>();
+
+const formRef = ref();
+
+const defaultFormData = reactive({
+  id: undefined,
+  stnm: undefined,
+  hbrvcd: undefined,
+  rstcd: undefined,
+  url: undefined,
+  location: undefined,
+  accuracy: undefined,
+  boundary: undefined,
+  height: undefined,
+  comments: undefined
+});
+const formData: any = reactive({ ...defaultFormData });
+
+const rules: Record<string, Rule[]> = {
+  stnm: [{ required: true, message: '请输入倾斜影像名称', trigger: 'blur' }],
+  hbrvcd: [{ required: true, message: '请输入所在河段', trigger: 'blur' }],
+  rstcd: [{ required: true, message: '请输入所属电站', trigger: 'blur' }],
+  url: [{ required: true, message: '请输入倾斜影像URL', trigger: 'blur' }],
+  location: [{ required: true, message: '请输入模型坐标', trigger: 'blur' }]
+};
+
+const isEdit = computed(() => !!props.initialValues);
+
+const handleOk = async () => {
+  try {
+    await formRef.value.validate();
+    const ennmItem = ennmOptions.value.find(item => item.value == formData.rstcd);
+    const riverItem = props.riverOptions.find(item => item.value == formData.hbrvcd);
+    const submitValues = {
+      ...formData,
+      ennm: ennmItem?.ennm || '',
+      hbrvcdName: riverItem?.label || '',
+      captureDate: formData.captureDate
+        ? dayjs(formData.captureDate).format('YYYY-MM-DD')
+        : undefined,
+    };
+
+    emit('ok', submitValues);
+  } catch (error) {
+    console.error('Validate Failed:', error);
+    message.error('请检查表单填写是否正确');
+  }
+};
+
+const initForm = () => {
+  if (props.initialValues) {
+    const values = props.initialValues;
+    Object.keys(formData).forEach(key => {
+      if (values.hasOwnProperty(key)) {
+        if (key === 'captureDate' && values[key]) {
+          formData[key] = dayjs(values[key]);
+        } else {
+          formData[key] = values[key];
+        }
+      }
+    });
+  } else {
+    resetForm();
+  }
+};
+
+const resetForm = () => {
+  if (formRef.value) {
+    formRef.value.resetFields();
+  }
+  Object.assign(formData, defaultFormData);
+};
+
+const handleCancel = () => {
+  emit('update:visible', false);
+  emit('cancel');
+  resetForm();
+};
+// 搜索过滤
+const filterOption = (inputValue: string, option: any) => {
+  const label = option.label || option.name || '';
+  const reachcdName = option.reachcdName || '';
+  const keyword = inputValue || '';
+
+  return label.indexOf(keyword) !== -1 || reachcdName.indexOf(keyword) !== -1;
+};
+const ennmOptions = ref([]);
+const handleRiverSelect = async (value: any) => {
+  let res: any = await getEngInfoDropdown({ reachcd: value });
+  if (res?.data?.length > 0) {
+    res.data.forEach((item: any) => {
+      item.value = item.stcd;
+      item.label = item.ennm;
+    });
+    ennmOptions.value = res.data;
+  } else {
+    ennmOptions.value = [];
+  }
+};
+watch(
+  () => props.visible,
+  newVisible => {
+    if (newVisible) {
+      initForm();
+      handleRiverSelect('');
+    }
+  },
+  { immediate: false }
+);
+
+defineExpose({
+  localLoading
+});
+</script>
+
+<style scoped lang="scss"></style>
diff --git a/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementSearch.vue b/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementSearch.vue
new file mode 100644
index 00000000..e518bcb7
--- /dev/null
+++ b/frontend/src/views/system/TiltPhotoManagement/TiltPhotoManagementSearch.vue
@@ -0,0 +1,81 @@
+<template>
+  <div class="content-search">
+    <BasicSearch
+      ref="basicSearchRef"
+      :searchList="searchList"
+      :initial-values="initSearchData"
+      @reset="handleReset"
+      @finish="onSearchFinish"
+      @values-change="onValuesChange"
+    >
+      <template #actions>
+        <a-tooltip title="新增倾斜摄影">
+          <a-button @click="props.handleAdd" type="primary"> 新增倾斜摄影 </a-button>
+        </a-tooltip>
+      </template>
+    </BasicSearch>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { ref, computed, onMounted } from "vue";
+import BasicSearch from "@/components/BasicSearch/index.vue";
+
+interface Props {
+  handleAdd: () => void;
+  riverOptions: any[];
+  riverOptionsLoad: boolean;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits<{
+  (e: "reset", values: any): void;
+  (e: "searchFinish", values: any): void;
+}>();
+
+const initSearchData = {
+  stnm: "",
+  rvcd:""
+};
+
+const searchData = ref<any>({ ...initSearchData });
+const searchList: any = computed(() => [
+  {
+    type: "Input",
+    name: "stnm",
+    label: "倾斜影像名称",
+    fieldProps: {
+      allowClear: true,
+    },
+  },
+  {
+    type: 'Select',
+    name: 'rvcd',
+    label: '所在河段',
+    width: 300,
+    fieldProps: {
+      allowClear: true
+    },
+    options: props.riverOptions,
+    loading: props.riverOptionsLoad
+  }
+]);
+
+const onSearchFinish = (values: any) => {
+  emit("searchFinish", values);
+};
+
+const onValuesChange = (changedValues: any, allValues: any) => {
+  searchData.value = { ...searchData.value, ...allValues };
+};
+
+const handleReset = () => {
+  emit("reset", initSearchData);
+};
+
+onMounted(() => {
+  emit("searchFinish", initSearchData);
+});
+</script>
+<style scoped lang="scss"></style>
diff --git a/frontend/src/views/system/TiltPhotoManagement/index.vue b/frontend/src/views/system/TiltPhotoManagement/index.vue
new file mode 100644
index 00000000..45c76096
--- /dev/null
+++ b/frontend/src/views/system/TiltPhotoManagement/index.vue
@@ -0,0 +1,269 @@
+<!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\components\TiltPhotoManagement\index.vue -->
+<template>
+  <div class="content">
+    <TiltPhotoManagementSearch
+      ref="tiltPhotoManagementSearch"
+      :river-options="riverOptions"
+      :river-options-load="riverOptionsLoad"
+      :handle-add="handleAdd"
+      @reset="handleReset"
+      @search-finish="onSearchFinish"
+    />
+    <BasicTable
+      ref="basicTable"
+      :columns="columns"
+      :list-url="getAllTiltPhotoTree"
+      :search-params="searchParams"
+    >
+      <template #action="{ column, record }">
+        <div class="flex gap-[6px]">
+          <a-button
+            class="!p-0"
+            type="link"
+            size="small"
+            @click="handleEdit(record)"
+            >编辑</a-button
+          >
+          <a-button
+            class="!p-0"
+            type="link"
+            size="small"
+            danger
+            @click="handleDelete(record)"
+            >删除</a-button
+          >
+        </div>
+      </template>
+    </BasicTable>
+    <TiltPhotoManagementForm
+      ref="tiltPhotoManagementForm"
+      v-model:visible="editModalVisible"
+      :river-options="riverOptions"
+      :river-options-load="riverOptionsLoad"
+      :initial-values="currentRecord"
+      @cancel="editModalCancel"
+      @ok="handleEditSubmit"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, nextTick, onMounted } from 'vue';
+import BasicTable from '@/components/BasicTable/index.vue';
+import TiltPhotoManagementSearch from './TiltPhotoManagementSearch.vue';
+import TiltPhotoManagementForm from './TiltPhotoManagementForm.vue';
+import { message, Modal } from 'ant-design-vue';
+import {
+  getAllTiltPhotoTree,
+  saveTiltPhoto,
+  deleteTiltPhoto
+} from '@/api/system/map/TiltPhotoManagement';
+import { getRvcdDropdown } from '@/api/select';
+// 表格列配置
+const columns = [
+  {
+    title: '序号',
+    dataIndex: 'index',
+    key: 'index',
+    width: 60,
+    align: 'center',
+    customRender: ({ text, record, index }) => index + 1
+  },
+  {
+    title: '倾斜影像名称',
+    dataIndex: 'stnm',
+    key: 'stnm',
+    width: 150
+  },
+  {
+    title: 'URL',
+    dataIndex: 'url',
+    key: 'url'
+    // width: 360
+  },
+  {
+    title: '所在河段',
+    dataIndex: 'hbrvcdName',
+    key: 'hbrvcdName',
+    width: 280
+  },
+  {
+    title: '所属电站',
+    key: 'ennm',
+    dataIndex: 'ennm',
+    width: 140
+  },
+  {
+    title: '创建人',
+    key: 'recordUser',
+    dataIndex: 'recordUser',
+    width: 150
+  },
+  {
+    title: '创建时间',
+    key: 'recordTime',
+    dataIndex: 'recordTime',
+    width: 150
+  },
+  {
+    title: '更新时间',
+    key: 'modifyTime',
+    dataIndex: 'modifyTime',
+    width: 150
+  },
+  {
+    title: '操作',
+    key: 'action',
+    width: 120,
+    fixed: 'right',
+    slots: { customRender: 'action' }
+  }
+];
+
+// 表格实例
+const basicTable = ref<any>(null);
+// 搜索参数
+const searchParams = ref({});
+// 编辑弹窗数据
+const currentRecord = ref<any | null>(null);
+const editModalVisible = ref(false);
+
+// 添加处理
+const handleAdd = () => {
+  currentRecord.value = null;
+  editModalVisible.value = true;
+};
+
+// 编辑处理
+const handleEdit = (record: any) => {
+  currentRecord.value = { ...record };
+  editModalVisible.value = true;
+};
+
+// 删除处理
+const handleDelete = (record: any) => {
+  Modal.confirm({
+    title: '确认删除',
+    content: '确定要删除选中的记录吗？',
+    zIndex: 2002,
+    onOk: async () => {
+      try {
+        let res = await deleteTiltPhoto({ id: record.id });
+        message.success('删除成功');
+        basicTable.value.refresh();
+      } catch (error) {
+        message.error('删除失败');
+        return;
+      }
+    }
+  });
+};
+
+// 搜索完成处理
+const onSearchFinish = (values: any) => {
+  const params = {
+    logic: 'and',
+    filters: [
+      values.parentId
+        ? {
+            field: 'parentId',
+            operator: 'eq',
+            dataType: 'string',
+            value: values.parentId
+          }
+        : null,
+      values.stnm
+        ? {
+            field: 'stnm',
+            operator: 'contains',
+            dataType: 'string',
+            value: values.stnm
+          }
+        : null,
+      values.rvcd
+        ? {
+            field: 'hbrvcd',
+            operator: 'contains',
+            dataType: 'string',
+            value: values.rvcd
+          }
+        : null
+    ].filter(Boolean)
+  };
+  basicTable.value.getList(params);
+};
+
+// 重置
+const handleReset = () => {
+  nextTick(() => {
+    basicTable.value.getList({
+      logic: 'and',
+      filters: []
+    });
+  });
+};
+
+// 表单取消
+const editModalCancel = () => {
+  currentRecord.value = null;
+  editModalVisible.value = false;
+};
+
+// 表单提交
+const handleEditSubmit = async (values: any) => {
+  try {
+    let res = await saveTiltPhoto({
+      ...currentRecord.value,
+      ...values,
+      recordTime:currentRecord.value.recordTime != '-' ? currentRecord.value.recordTime : null
+    });
+    message.success(`保存成功`);
+
+    editModalVisible.value = false;
+    basicTable.value.refresh();
+  } catch (error) {
+    message.error(`保存失败`);
+
+    editModalVisible.value = false;
+    return;
+  }
+};
+const riverOptions = ref<any>([]);
+const riverOptionsLoad = ref(false);
+const initOption = () => {
+  const params = {};
+  riverOptionsLoad.value = true;
+  getRvcdDropdown(params).then((res: any) => {
+    res.data.forEach((item: any) => {
+      item.value = item.rvcd;
+      item.label = item.rvnm;
+    });
+    riverOptions.value = res.data || [];
+    riverOptionsLoad.value = false;
+  });
+};
+onMounted(() => {
+  initOption();
+});
+</script>
+
+<style scoped lang="scss">
+.tilt-photo-management {
+  height: 100%;
+  padding: 16px;
+}
+.content {
+  position: relative;
+  z-index: 900;
+  pointer-events: all;
+  width: 100%;
+  height: 100%;
+  background-color: #ffffff;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  box-sizing: border-box;
+  overflow: hidden;
+  padding: 16px;
+}
+</style>
diff --git a/frontend/src/views/system/map/components/LayerManagement/LayerManagementForm.vue b/frontend/src/views/system/map/components/LayerManagement/LayerManagementForm.vue
index caa405e3..ffe7d157 100644
--- a/frontend/src/views/system/map/components/LayerManagement/LayerManagementForm.vue
+++ b/frontend/src/views/system/map/components/LayerManagement/LayerManagementForm.vue
@@ -20,6 +20,7 @@
           v-model:value="formData.title"
           style="width: 100%"
           placeholder="请输入图层名称"
+          :maxlength="50"
         />
       </a-form-item>
       <a-form-item label="图层编码" name="code">
diff --git a/frontend/src/views/system/map/components/LayerManagement/index.vue b/frontend/src/views/system/map/components/LayerManagement/index.vue
index 90c923ea..8829853e 100644
--- a/frontend/src/views/system/map/components/LayerManagement/index.vue
+++ b/frontend/src/views/system/map/components/LayerManagement/index.vue
@@ -265,7 +265,10 @@ const handleDelete = async (record: any) => {
     onOk: async () => {
       try {
         let res = await deleteMapLayer([record.id]);
-        message.success('删除成功');
+        if(res.code == 0){
+           message.success('删除成功');
+        }
+       
         basicTable.value.refresh();
       } catch (error) {
         message.error('删除失败');
diff --git a/frontend/src/views/system/map/components/LegendData/index.vue b/frontend/src/views/system/map/components/LegendData/index.vue
index 9738c1a6..f7c8192e 100644
--- a/frontend/src/views/system/map/components/LegendData/index.vue
+++ b/frontend/src/views/system/map/components/LegendData/index.vue
@@ -1,4 +1,4 @@
-<!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\components\LegendData\index.vue -->
+<!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\componentsData\index.vue -->
 <template>
   <div class="content">
     <LegendDataSearch
diff --git a/frontend/src/views/system/map/components/LegendStructure/index.vue b/frontend/src/views/system/map/components/LegendStructure/index.vue
index ed0e04f1..3024ae99 100644
--- a/frontend/src/views/system/map/components/LegendStructure/index.vue
+++ b/frontend/src/views/system/map/components/LegendStructure/index.vue
@@ -250,7 +250,9 @@ const handleDelete = (record: any) => {
     onOk: async () => {
       try {
         let res = await deleteMapLegend([record.id]);
-        message.success('删除成功');
+        if (res.code == 0) {
+          message.success('删除成功');
+        }
         basicTable.value.refresh();
       } catch (error) {
         message.error('删除失败');
@@ -375,10 +377,12 @@ const handleEditSubmit = async (values: any, type: string) => {
       ...values,
       parentId: parentId.value
     });
-    if (type === 'switch') {
-      message.success('修改状态成功');
-    } else {
-      message.success(`保存成功`);
+    if (res.code == 0) {
+      if (type === 'switch') {
+        message.success('修改状态成功');
+      } else {
+        message.success(`保存成功`);
+      }
     }
     editModalVisible.value = false;
     basicTable.value.refresh();
diff --git a/frontend/src/views/system/map/index.vue b/frontend/src/views/system/map/index.vue
index fda27e60..44f7e80d 100644
--- a/frontend/src/views/system/map/index.vue
+++ b/frontend/src/views/system/map/index.vue
@@ -27,18 +27,18 @@ const tabs = [
     name: "图例数据管理",
     value: "legendData",
   },
-  {
-    name: "电站专题管理",
-    value: "station",
-  },
-  {
-    name: "沿程配置管理",
-    value: "config",
-  },
-  {
-    name: "倾斜摄影管理",
-    value: "tilt",
-  },
+  // {
+  //   name: "电站专题管理",
+  //   value: "station",
+  // },
+  // {
+  //   name: "沿程配置管理",
+  //   value: "config",
+  // },
+  // {
+  //   name: "倾斜摄影管理",
+  //   value: "tilt",
+  // },
 ];
 
 // 当前激活的 tab
diff --git a/frontend/src/views/system/pushManagement/components/ConfigManagement/index.vue b/frontend/src/views/system/pushManagement/components/ConfigManagement/index.vue
index 46b833db..239cf3db 100644
--- a/frontend/src/views/system/pushManagement/components/ConfigManagement/index.vue
+++ b/frontend/src/views/system/pushManagement/components/ConfigManagement/index.vue
@@ -1,7 +1,7 @@
 <!-- d:\wordpack\WholeProcessPlatform\frontend\src\views\system\map\components\ConfigManagement\index.vue -->
 <template>
   <div class="content">
-    推送配置
+    <!-- 推送配置 -->
     <!-- <ConfigManagementSearch
       ref="configManagementSearch"
       :handle-add="handleAdd"