gaozheng
/
geopro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: gaozheng:main
Branches Tags
gaozheng:main
gaozheng:feat/vtk-3d-view
..
compare: gaozheng:feat/vtk-3d-view
Branches Tags
gaozheng:main
gaozheng:feat/vtk-3d-view

No commits in common. "main" and "feat/vtk-3d-view" have entirely different histories.
main ... feat/vtk-3

108 changed files with 504 additions and 5461 deletions
Show Stats Expand all files Collapse all files

19
docs/OPTIMIZATION-BACKLOG.md
View File

@ -55,22 +55,3 @@
落在光标下那张切片 → 选对（`onPick` 仅命中时触发，未命中不误选）。重叠切片仍按最前优先（合理）。
逻辑闭合但**未 live 点击验证**（工具无法交互点击 3D 切片）；若仍有偏差需 live 复核（重叠循环切换等）。
- **更新**：2026-06-25 issue2+③+反向²(`69e8790`)+④(`63cda56`) 全部实现。
---
## OPT-003 · 二维分析 C 期：dd_raster 栅格地理配准渲染（阻塞·待后端端点）
- **状态**：🔴 Open（**阻塞**：后端无栅格数据端点）
- **记录日期**：2026-06-26
- **背景/现状**：二维分析改造分期 A→B→C（spec `docs/superpowers/specs/2026-06-26-2d-analysis-topdown-elevation.md`）。
A（一场景两相机）、B（足迹高程 Z 拖动）已实现（commit `6a10975`、`bdebe54`）。**C 期=dd_raster 栅格**
（DD0623 新增 ddCode，展示模式 2D，形态=栅格/遥感影像）尚未做。
- **期望**：`dd_raster` 纳入 2D 维度过滤（`dimOf`/`dimensionOf` 加 `dd_raster`→Dim2D）；col2D 勾选渲染按
ddCode 分派（轨迹走 `loadMapLine`，栅格走**栅格加载**，不可串）；栅格取**像素 + 四至/仿射 + 投影 CRS**
作地理配准纹理平面贴到地形上（带高程，可被 B 期 Z 拖动），类似底图瓦片按经纬定位。
- **阻塞点（为何不做）**：实测后端 API 文档 `docs/apis/business_OpenAPI.json` **无任何 dd_raster / 栅格影像
端点**（仅有 grid 行/反演 grid、GPR 通道图，均非带四至+投影的栅格）。无端点 → 无像素/地理范围可加载 →
C 期无数据可渲染。**须后端提供返回「像素 + 四至/仿射 + 投影」的端点后方可落地。**
- **难点**：栅格加载路径（新）、按 ddCode 的渲染分派、地理配准纹理平面（参考 `TileBasemap` 的 `buildFlat`/
`buildWarped` 按经纬贴地形 + DEM 位移）。
- **关联**：spec §6/§9/§10/§11；handoff `docs/superpowers/HANDOFF-2026-06-26-vtk-anomaly-2d-analysis.md` §0。
- **更新**：—

100
docs/superpowers/HANDOFF-2026-06-26-vtk-anomaly-2d-analysis.md
View File

@ -1,100 +0,0 @@
# HANDOFF — VTK 3D 视图：创建异常打磨 + 切片/异常交互 + 二维分析改造（2026-06-26）
> 分支 `feat/vtk-3d-view`。桌面端 Qt6 + VTK 9.6。本会话围绕「创建异常」全链路打磨、切片/异常交互修复、全局中文化，最后转入「二维分析改造」的需求厘清 + 写 spec。**下一步＝按 spec 实现二维分析 A 期。**
---
## 0. 立刻要做的事（下个会话从这里开始）
**二维分析改造 A 期已实现**（未提交，下个会话需用户实跑反馈手感/角度）。spec：`docs/superpowers/specs/2026-06-26-2d-analysis-topdown-elevation.md`（commit `227ee8f`）。分期 A→B→C：
- **A（已实现 ✅，build+439测试全绿，未提交）**：一场景两相机。切「二维分析」tab → 近俯视(下压12°≈78°俯角)+禁旋转(左键改平移、仅平移/缩放)；按维度翻 actor `SetVisibility`（轨迹↔体/帘面/异常，**不清空**）；切片 `SetEnabled` 显隐（不销毁）；地形+底图常驻；切回三维还原相机快照。**待用户实跑**：①近俯视角度是否合适②切换是否瞬时③左键平移手感④切回三维视角还原是否自然。
- 改动文件：`CameraPreset.{hpp,cpp}`(applyNearTop2D)、`PickInteractorStyle.{hpp,cpp}`(setLock2D)、`SliceTool.{hpp,cpp}`(setVisible)、`InteractionManager.{hpp,cpp}`(setMode2D)、`VtkSceneView.{hpp,cpp}`(setAnalysisMode2D+mapLineDs_+相机快照)、`ColumnDrawer.{hpp,cpp}`(analysisModeChanged 信号)、`main.cpp`(接信号)。
- 已知小风险：2D 取景 `computeDataBounds` 含隐藏的 3D 体包围盒（地形主导，影响小）；切片 `SetEnabled` 显隐属 GUI 不可自测项。
- **B（已实现 ✅，build+441测试全绿，未提交，待实跑）**：二维里选中足迹（单/Ctrl 多选）→ 竖向拖动只改**高程 Z**、锁 XY、顶部实时高程读数浮层；Z 偏移按 dsId 持久（切走再回/全量重建保留）。手势：单击足迹=选中、Ctrl+单击=多选切换、点空白=取消+平移、（多）选后竖向拖动=整体改 Z。
- 实现：`VtkSceneView` 加 `pickMapLineAt/nudgeSelectedMapLinesZ/selectedMapLineZ/clearMapLineSelection`（vtkCellPicker+PickFromList 只拾可见足迹、选中高亮黄加粗、`mapLineZOffset_` 持久）；`PickInteractorStyle` lock2D 下命中足迹→Z 拖动(`onPick2D/onDrag2D/onDrag2DEnd`+`worldPerPixelZ` 像素→世界Z)、否则平移；`InteractionManager::pickStyle()` 暴露样式；`main.cpp` 接回调 + 高程读数浮层(复用提示样式)。
- **待用户实跑**：①拾取灵敏度(tol 0.012)②拖动 Z 灵敏度/方向(上移=抬高)③多选拖动④读数是否合理(现为 actor 包围盒中心世界 Z，含 placement+偏移，未除 VE)。
- **C（下一步）**：dd_raster 纳入 2D 过滤 + 按 ddCode 分派渲染 + 栅格地理配准贴地形。**阻塞：dd_raster 数据端点未确认**（需后端给「像素 + 四至/投影」端点）。
---
## 1. 环境 / 命令 / 铁律（必读）
- **构建**：用 PowerShell 工具跑 `cmd /c "D:\Git\lanbingtech\geopro\build.bat app"`（Claude 的 Bash 跑 build 会被环境劫持，用 PowerShell）。测试 `build.bat test`（ctest，**439 用例**）。`vswhere.exe not recognized` 噪声无害。LNK1104=exe 被运行中的 app 锁，需用户关 app 才能链接。
- **回复用中文**（用户要求）。
- **CLAUDE.md 两条绑定规则**：①发现技术债当场修，不以"非本轮引入"搪塞；②**能自己做的绝不让用户做**——日志(`%LOCALAPPDATA%/Geomative/Geopro3/logs/geopro_*.log`)/数据/构建/诊断都自己来，只在 LNK1104 关 app、或真正产品决策才找用户。
- **git**：精确 `git add <files>`（仓库有并行 GPR 会话的脏文件 `.superpowers/sdd/*`、`docs/.../poc-lod-shots/*.png`，**勿误提交**）。提交无 Co-Authored-By（全局禁）。
- **后端 token（可访问真实接口，用户给的）**：`geomativeauthorization: Geomative e6c1259748644c8da0954d864bb82604`；base URL `http://tenant.geomative.cn/pop-api`；样例 projectId `1439735554211840`。可用 curl 查接口。
---
## 2. 本会话已完成（提交清单，新→旧）
**创建异常全链路（核心工作量）**
- `227ee8f` 二维分析 spec（doc）。
- `c1a824e` 二维维度分类对齐数据字典 DD0623（去 3 个已删除轨迹类型，dimensionOf/dimOf/测试）。
- `e8bb2f8`/`1648ccb`/`f230ca8` 异常绘制提示：vtkTextActor 渲染不出中文 → 改 **app 层 QLabel 浮层**（右上角、深底方角、不挡鼠标）；列表切到别对象清切片选中（`deselectSlice`）。
- `9782a2b` 删除切片/异常加确认框 + **弹框按钮全局中文化**（Qt zh_CN 翻译器 + `formkit::addDialogButtons` 默认「确定/取消」+ 打包补 qtbase_zh_CN.qm）。
- `306d7bc` 提示移右上角 + **线双击结束含双击位置**（去回滚）。
- `d7ab770` **切片保存后定稿锁定**（`SetInteraction(0)` 不可移动/旋转）+ VTK/列表菜单去「保存·另存」。
- `91a7106` **结束手势**：点=单击即完成、线=双击、面=**点回起点闭合**（近起点 12px 吸附+橡皮筋指向起点）。
- `1a70ca0` 异常对话框加**样式预览**（选中类型 legend 可视化：点球/线/面）。
- `4ae8286` **异常截图配色与切面一致**：取 widget 自身 `GetColorMap()` 输出（非另建 LUT）→ 逐像素一致 + RGBA 外区透明消蓝边。
- `d470dc8` 双击/单击隔离（后被 `306d7bc` 改回"含双击位置"）+ 异常类型下拉误显「暂无数据」（`EmptyAwareComboBox::realItemCount` 用错 flags 角色→改 `model()->flags()`）。
- `04af569` 返工（点交互/点渲染小球/截图/类型空态）。
- `75c1327`→`3ed1ea7`→`58544ff`→`c6756aa` 截图相机方案A(已废)、**异常类型接平台真实类型**(`listExceptionTypes` 按形态)、**点/线/面三态**子菜单、**样式接平台 legend**(`getExceptionTypeDetail`)。
- 截图最终方案：**只从切片 2D 剖面图、按异常几何 buffer 裁剪**（`captureAnomalyShotFromSlice`，GIS buffer+掩膜，点圆/线胶囊/面外扩多边形）。
**其它**
- `56e4b3a` 登录验证码容器白底。
- `8563693` 分段折叠向上收起（stretch 动态：展开=1/折叠=0+尾弹簧）。
- `d6e52cb` 三维分析分段面板视觉打磨（chevron 段头/描边新增按钮/顶部留白）。
- `fb911a9` 坐标轴面板硬编码色 token 化。
- `cdd7613` vtk-3d-openapi 文档对齐实测（DsPage 行在 `data.list`、DsRow 全字段、装置不在 data/page）。
- `2f6ec7d`→`1742b75`→`31ad7a4` **装置筛选**：data/page 行不带 properties→改按行自带 `typeName/dsTypeCode` 筛选；parseDsRows 兼容对象形态。
- 期间生成了一次安装包：`installer/dist/Geopro_Setup_3.0.0-20260625.exe`（脚本 `installer/build_installer.ps1`，含 windeployqt+样本+PROJ+vc_redist）。
---
## 3. 创建异常功能现状（已落地，端到端可用，mock 保存）
入口：VTK 切片右键 →「创建异常 → 点/线/面」。流程：圈定(AnomalyDrawTool)→草稿渲染→**从切片2D图buffer裁剪截图**→对话框(名称/异常类型[接平台]/样式预览/备注/截图)→保存(mock)→刷新树+渲染异常 actor。
- **关键文件**：`src/render/interact/AnomalyDrawTool.{hpp,cpp}`（三态绘制：点单击完成/线双击/面点起点闭合，Esc取消/Backspace撤点）；`src/app/AnomalySaveDialog.{hpp,cpp}`（接 `cmdRepo.listExceptionTypes`/`getExceptionTypeDetail`，样式预览）；`src/app/SliceExport.{hpp,cpp}`（`captureAnomalyShotFromSlice`）；`src/render/actors/AnomalyActor.cpp`（点=球/线=折线/面=闭合多边形）；`src/app/main.cpp`（onSliceContextMenuRequested ~509 起：菜单+绘制+对话框+保存接线，QLabel 提示浮层）。
- **样式来源**：选中平台异常类型 → `getExceptionTypeDetail` 取 legend（polylineColor/Width/Shape, pointColor…）→ 套到异常 lineColor/lineWidth/dashed。
- **截图**：只裁切片那张 2D 剖面图（`InteractionManager::selectedSliceColorImage` 现取 `SliceTool::coloredResliceImage()`=widget ColorMap 输出，与屏幕同源）。
### 仍卡在后端（P3，非客户端问题）
- **异常真保存 `newException`** 卡：异常 `remarkSourceId` 须指向真实 dsObjectId（三维体/切片），但真后端**无任何登记三维体/切片为 dsObject 的端点**（实测 `voxel/generate`、`slice/generate`、通用 `dsObject create` 全无）。当前 `saveAnomaly` 是内存 mock。后端补登记端点后整链可接真。
- 平台「点」类异常类型该项目为空（线/面有）→ 画点时类型下拉空属正常。
---
## 4. 二维分析改造——已确认的设计决策（与用户逐条敲定）
1. **不分两个场景**：一个 3D 地形场景（带高程）+ 底图贴地形，两栏只是相机不同。"二维分析只是 3D 的固定视角"。
2. **二维相机**：锁定**近俯视(75–80°，非绝对正俯视)**，禁旋转，仅平移+缩放。（绝对正俯视看不出高程→留倾斜）
3. **切 tab 显隐**：翻另一方数据集 `SetVisibility`（**不显示，非清空**）→ 性能零代价（VTK 跳过不可见 actor）、切换瞬时、只占内存。地形+底图常驻。**绝不清空**（重体素重建会卡）。
4. **高程拖动(C1)**：二维里选中 2D 内容（单/多选）→ 竖向拖动只改**高程 Z**、锁 XY、实时读数。用途=分离叠在一起的 2D 层。
5. **维度过滤**：2D = `dd_trajectory_data`（+ C 期 `dd_raster`）；`dd_radar_2d/3d` 是 3D（不进 2D）。已对齐 DD0623（`c1a824e`）。
6. **雷达客户反馈**：只影响数据模型 + **3D 视图**渲染（二维雷达=线、三维雷达=切面、带打标）+ 详情页校准——**均属另立任务，不在本次 2D 改造**。2D 只显示轨迹线、打标暂不做（与本设计一致）。
---
## 5. 关键代码锚点（二维分析改造用）
- 切 2D 视图模式钩子：`Column2DDataset::view2DModeChanged` → `main.cpp` 接 `sceneCtrl`（搜 `view2DModeChanged`）。
- 维度分类：`src/app/DatasetDimension.cpp::dimOf`（col2D 用）；`src/data/api/Api3dRepository.cpp` + `src/data/repo/LocalSample3dRepository.cpp::dimensionOf`。
- 2D 内容注入：`main.cpp` ~502 `col2D->setDatasets(splitByDimension(...).dim2D)`；勾选渲染 `Column2DDataset::checkedDatasetsChanged` → `loadMapLine`/`MapLineActor`。
- 场景/相机/可见：`VtkSceneView`（actor 管理）、`VtkSceneController`、`InteractionManager`（拾取/选中，新增 `deselectSlice`）。
- 地形+底图：`buildTerrain`（带高程，VE 垂直夸张相关）、`TileBasemap`（天地图按经纬贴）。
- 数据字典：`D:\Projects\GEOPRO\DD0623.xlsx`（46 个 ddCode，列：序号/ddCode/领域/含义/状态/**展示模式(2D/3D)**/**展示形态**/备注…）。解析：openpyxl 可用，中文 GBK 终端会乱码→导 UTF-8 文件再 Read。
---
## 6. 待确认/风险
- **dd_raster 数据端点**（像素+四至/投影）未确认 → C 期阻塞。
- 近俯视角度需实机调；高程是否落库暂定会话内（不落库）。
- §3 翻可见标志需可靠区分每个 actor 的维度归属。
- 切相机/可见与现有 view2DModeChanged、底图、地形 VE 逻辑勿打架。
- **GUI 无法登录自测**：相机/截图/交互类改动我只能保证编译+逻辑，视觉/手感需用户实跑反馈。
---
## 7. 相关记忆/文档
- 记忆库 `MEMORY.md`（如 login-chain-truth、vtk-3d-persistence-structure、build-vs2026-vcpkg-gotchas、deploy-hardcoded-dev-paths 等）。
- vtk-3d API 设计草案：`docs/api/vtk-3d-openapi.json`（已对齐实测，0.6.1）。
- 真后端 API：`docs/apis/business_OpenAPI.json`。
- 二维分析 spec：`docs/superpowers/specs/2026-06-26-2d-analysis-topdown-elevation.md`。

101
docs/superpowers/specs/2026-06-26-2d-analysis-topdown-elevation.md
View File

@ -1,101 +0,0 @@
# 二维分析：锁定俯视相机 + 内容显隐 + 高程拖动 — Spec（2026-06-26）
## 0. 一句话目标
把「二维分析」从"另一套平面地图"改为**同一个 3D 地形场景的一个锁定近俯视视角**：切 tab 只切相机+翻另一方数据集的可见标志（不清空），二维内容（轨迹/栅格）落在带高程的地形上，且可选中后沿高程上下拖动分离。
---
## 1. 背景与现状
- 三维分析栏（`CategoryAnalysisTab`）与二维分析栏（`Column2DDataset` / `col2D`）**共用同一个 `VtkSceneView` / `InteractionManager` / `renderWindow`**。现状：两栏勾选的 actor 叠在同一场景，切 tab 不切相机、不区分内容。
- 二维内容现状：`col2D` 勾选 → `loadMapLine`（`dd/ert/trajectory/line`）→ `MapLineActor`（lat/lon 折线）；有 `view2DModeChanged` 信号已接到 `sceneCtrl`（2D 视图模式钩子，本 spec 在其上扩展）。
- 地形 + 底图：场景已有地形（`buildTerrain`，带高程）+ 天地图底图（`TileBasemap`，按经纬贴）。
- 维度分类：`DatasetDimension::dimOf` + `Api3dRepository/LocalSample3dRepository::dimensionOf`，已对齐数据字典 DD0623（2D = `dd_trajectory_data`，commit c1a824e）。
**用户确认的认知**：二维分析"只是 3D 的固定视角"，底图不是平面图、是**带高程的地形图**；内容沿用不清空。
---
## 2. 核心设计：一个场景 + 两种相机
- **不分两个场景**，只有一个 3D 地形场景（地形 + 底图 + 全部已勾选数据），两栏区别仅在**相机**与**哪类数据集可见**。
| | 三维分析 | 二维分析 |
|---|---|---|
| 相机 | 自由透视（可旋转/倾斜/平移/缩放） | **锁定近俯视**（不可旋转，仅平移+缩放）|
| 可见数据集 | 3D 数据集（体/切片/剖面…）可见；2D 数据集隐藏 | 2D 数据集（轨迹/栅格）可见；3D 数据集隐藏 |
| 地形 + 底图 | 常驻可见 | 常驻可见（同一地形，俯视看即"地形图"）|
---
## 3. 二维分析的相机：锁定近俯视
- 切到二维分析 → 相机切到**近俯视固定角（约 75–80°，非绝对正俯视）**：理由——绝对正俯视在正交/小透视下高程变化不可见，留一点倾斜以便看出高低（§5 拖动反馈需要）。
- 锁定：**禁用旋转**（interactor style 不响应旋转/倾斜），仅保留**平移 + 缩放**。
- 切回三维分析 → 恢复自由透视相机（恢复切走前的视角或合理默认）。
- 实现锚点：扩展 `view2DModeChanged` 钩子 → `VtkSceneController` 切相机模式 + 切 interactor style（或在 style 内按模式禁旋转）。
---
## 4. 内容显隐：切 tab 翻可见标志（**不清空**）
- 切 tab 时，对"另一方"的数据集 actor 用 `SetVisibility(false)`，切回 `SetVisibility(true)`。**不移除 actor、不重建**。
- 性能：VTK 渲染跳过不可见 actor → 隐藏内容**不参与绘制、不耗 FPS**；切换瞬时（无重插值/重传 GPU）；唯一代价是内存/显存驻留（数据本已加载，无新增加载）。
- **禁止用清空**：重体素（GPR/ERT）每次切回要重插值+重传 GPU，必卡。
- 地形 + 底图两边都不隐藏。
- 实现锚点：`VtkSceneView` 按数据集维度（`dimensionOf`/记录每 actor 的维度）批量翻可见标志；切 tab 时调用。
---
## 5. 高程拖动（C1）：选中 2D 内容沿 Z 上下移
- 二维分析里，**拾取选中已渲染的 2D 内容**（轨迹/栅格），支持**单选 / 多选**。
- 选中后**竖向拖动 → 仅改其高程 Z（离地高度）**，**锁死 X/Y**（不动地理位置）。用于把叠在一起的 2D 层分离、看清。
- 拖动时**实时显示当前高程数值**（屏幕浮层读数）。
- 近俯视固定角（§3）使高低可见。
- 实现锚点：新增/复用一个 2D 拾取-拖动交互（类似切片 widget 但只允许 Z 平移 + 多选）；actor 的 Z 偏移持久（切走再回保留）。
- 待定：高程是否需要随数据保存（暂定仅会话内 actor 变换，不落库；接真实端点再议）。
---
## 6. dd_raster：二维栅格过滤 + 渲染（本期新增）
- 数据字典 DD0623：`dd_raster`（栅格/遥感影像，**本次新增**，展示模式 2D，形态=栅格）。
- 纳入 2D 过滤：`dimOf`/`dimensionOf` 增 `dd_raster` → `Dim2D`；但 col2D 勾选渲染须**按 ddCode 分派**——轨迹走 `loadMapLine`，栅格走**栅格加载**（不可让栅格走轨迹端点）。
- 渲染：取栅格的**地理范围（四至/仿射）+ 像素**，作为**地理配准的纹理平面贴到地形上**（带高程，可被 §5 高程拖动），类似底图瓦片按经纬度定位。
- 依赖：dd_raster 的**数据端点**（返回像素 + 四至/投影）——**待确认**，未明确前 §6 不落地（先做 §3–§5）。
---
## 7. 维度过滤口径（对齐数据字典 DD0623，已部分落地）
- 2D（足迹/栅格）：`dd_trajectory_data`（统一通用轨迹，"保留"，已并入 dd_radar_rtk_trajectory）+ `dd_raster`（本期新增，随 §6）。
- 已删除、不再单列：`dd_radar_rtk_trajectory` / `dd_transient_electromagnetic_trajectory_data` / `dd_radar_channel_trajectory`（字典均"删除"）。已清理：commit c1a824e。
- `dd_radar_2d` / `dd_radar_3d`：字典为 `展示模式=3D`（通道剖面 / 三维插值模型）→ **属三维分析，不进 2D 过滤**。
---
## 8. 与雷达客户反馈的边界（本 spec **不含**）
- 雷达 TM 模型（单/双/多频，每频一个 `dd_radar_2d`/`dd_radar_3d`，共用一个 `dd_trajectory_data` 轨迹）→ 数据模型，与本 spec 无冲突。
- 雷达**数据在 3D 视图的渲染**（二维雷达=线/curtain、三维雷达=切面，按 trace 坐标，带打标 hover tip）→ **三维分析的另立任务**。
- 详情页用 trace 坐标校准异常 + 剖面打标 → 详情页另立任务。
- **2D 视图只显示轨迹线、打标暂不在 2D 展示**（客户 #6 修正）→ 与本 spec 的"2D 显示轨迹足迹"一致，无新增 2D 工作。
- 雷达轨迹就是 `dd_trajectory_data`，本 spec 的 2D 分析按统一轨迹处理，无需特判。
---
## 9. 实现分期
- **A. 一场景两相机**：切 tab → 锁定近俯视/恢复自由相机 + 翻另一方数据集可见标志（§3、§4）。基础，先做。
- **B. 高程拖动**：2D 拾取单/多选 + 仅 Z 拖动 + 锁 XY + 实时读数（§5）。
- **C. dd_raster**：过滤纳入 + 按 ddCode 分派渲染 + 栅格地理配准贴地形（§6）。依赖栅格数据端点确认。
---
## 10. 风险 / 待定
- 近俯视角度（75–80°）需实机调；用户若坚持绝对正俯视，则 §5 高程反馈改为纯数值（不直观）。
- §4 翻可见标志需可靠区分每个 actor 的维度归属（按数据集 ddCode 记录维度 → actor）。
- §5 高程是否持久化/落库待定（暂会话内）。
- §6 dd_raster 数据端点（像素 + 四至/投影）未确认 → C 期阻塞点。
- 切相机/可见标志切换需与现有 `view2DModeChanged`、底图、地形 VE（垂直夸张）逻辑兼容，勿互相打架。
---
## 11. 验收
- 切到二维分析：相机变近俯视、**不能旋转**，只能平移+缩放；3D 数据集（体/切片/剖面）不可见，轨迹+地形+底图可见。
- 切回三维分析：恢复自由相机；3D 数据集重新可见，2D 轨迹隐藏。切换**瞬时无卡顿**（无重建）。
- 二维分析里选中一条/多条轨迹，竖向拖动→只改高程、地理位置不动、实时显示高程；叠在一起的层能被拉开。
- （C 期）勾选 dd_raster → 栅格按地理范围贴在地形上、可被高程拖动；轨迹与栅格各走各的加载路径、互不串。
- 维度过滤与数据字典 DD0623 一致（2D=trajectory_data+raster；radar_2d/3d 归 3D）。

210
docs/superpowers/specs/2026-06-26-gpr-3d-render-perf-ANALYSIS-for-review.md
View File

@ -1,210 +0,0 @@
# GPR 多通道三维体渲染性能问题 — 分析文档（供外部专家评审）
> 自包含技术文档。读者无需了解本代码库内部，只需具备 GPU 体绘制 / VTK 基础。
> 目的：把"探地雷达(GPR)多通道阵列数据渲成可交互三维体"遇到的性能问题、已试方案、实测数据、
> 待定关键点完整呈现，供外部专家判断方向。
---
## 1. 背景与系统
- 桌面端 C++ 应用（Qt6 + **VTK 9.6.2**），渲染探地雷达(GPR)采集的地下三维数据，要求**可交互**（旋转/缩放）。
- 渲染用 VTK 的 `vtkGPUVolumeRayCastMapper`（OpenGL GPU 光线投射体绘制）。
- 当前测试机 GPU：32 个着色器纹理单元（典型独显/中端）。
## 2. 数据特征（关键，决定一切）
多通道阵列 GPR，一次采集一条"测线(line)"：
- **道(trace)**：一个位置一根天线的垂直回波，深度方向 **821 采样**。
- **通道(channel)**：阵列横向并排的多对天线，本数据 **14 通道**；**相邻通道横向间距 ≈ 10.5cm**（来自 `.ord` 文件真实偏移 -0.686…+0.686m，跨度 1.37m）。
- **沿测线道间距 ≈ 4.9cm**（比横向通道间距细 ~2 倍）。
- 一条测线：沿路 **~45305 道**，覆盖 **~2.2km**（一条南北向道路）。
- **共 20 条测线 = 同一条路来回扫 20 趟**（车载，每趟阵列覆盖约 1.4m 宽，多趟铺横向）。
**单条线 = 一个三维体**：X=沿测线(~45305)、Y=通道(14)、Z=深度(821)。
**关键业务约束（来自现场专家）**：
- 通道太稀（10.5cm）→ 需**线内通道间插值**加密（相邻真实天线之间插，物理成立）；
- **绝不做"测线之间"的插值**（车与车之间是真实物理空隙，插出来"信号全是假的"，工程上不可接受）；
- 多条测线"分开各自插值，渲染可以合到一起"。
GPR 数据的统计特征（实测，见 §6）：**~91% 体素近零（反射层之间是空的），但反射层横贯整个深度分布**（不是集中一坨）。
## 3. 已建成并验证可用的功能（不是问题所在）
1. **线内通道插值**：读 `.ord` 真实横向偏移，规则化到 2.5cm 网格、相邻通道线性插值（不跨线）。
实测 Y 由 14 加密到 **56**。有单元测试。
2. **多体单遍合成**：20 条独立体（各自插值）作为一个 `vtkGPUVolumeRayCastMapper` 的多个端口注册进
`vtkMultiVolume`，**单遍 ray-cast 合成**（而非每条体一遍）。已验证。
3. **纹理单元上限自动退避**：单个 multi-volume 同时挂的体数受 GPU 每着色器纹理单元上限制约
（每体约吃 4 个单元 → 32 单元机上**一个包最多 7 体**，第 8 体报错并丢体）。已实现"渲一帧→报错则
每包减 1 重建重渲"的自动退避（强制 K=12 → 自动退避到 7，无丢体）。
4. **运行时换贴图边界**（确定性测试结论）：给某端口**就地换贴图**——若**保持包围盒不变**（同范围、
只改 Y 密度）则 multi-volume 算得对；若**改包围盒**（任意子区域、origin/范围/spacing 变）则破坏
其缓存 `TexToBBox` → 体断开/消失。
5. 通道维 LOD、统一传函、色标图例等。
## 4. 核心问题：性能
- **20 条密体（Y=56）总览，交互极卡**：静止 ~1.7 fps，旋转/缩放掉到 < 1 fps（GPU 100%）。
- 渲染**视觉正确**（雷达剖面纹理清晰、横向连续、合成无误），纯属性能。
- 现有提速手段都是**"交互时降质"**方向（降屏幕分辨率、加粗采样步长）——**损可见质量**，治标。
用户明确要求："有没有不损可见质量的根本性提速（业界最佳实践）？"
## 5. 已分析/已试的所有方案（含理由与状态）
| # | 方案 | 理由 | 状态 / 结论 |
|---|---|---|---|
| A | multi-volume 单遍合成 | 把"N 体=N 遍 ray-cast"降到分包遍数 | ✅ 已实现。但单遍内每步仍要在重叠体里逐个采样 |
| B | 纹理单元自动退避分包 | 绕开 GPU 纹理单元上限、不丢体 | ✅ 已实现（K=7/包，20 条=3 包）。代价：**跨包重叠合成不正确（接缝）** |
| C | 交互降屏幕采样(ImageSampleDistance) | VTK AutoAdjust 标准手段 | ✅ 已做。**损质量**；且 AutoAdjust 只降屏幕、不降沿光线步长 |
| D | 交互手动加粗沿光线步长(SampleDistance) | 通道插值后 Y 密→自动步长极细→巨卡；这才是大头 | ✅ 已实现（`--sampleDist`/`--dragSampleMul`）。**损质量；且用户尚未实测**（见 §7 待定） |
| E | 通道维 LOD（远疏近密换 Y 平面子集）| 保包围盒换贴图（#4 验证安全） | ✅ 已实现。但**只减纹理内存、不减每步重叠体采样次数 → 对此瓶颈几乎无效** |
| F | **装箱单体(binning)**：各线先逐线插值，再把**真实道**摆进一个总览网格体（空隙透明、不跨线插值）| 一个体一遍、每步采 1 次 → ~20×；真实数据无假信号 | ⚠️ 技术可行、合规，但**用户否决**：装箱合并后**总览里分不出各线**，而用户要"一起渲染时仍能逐线区分/查看"→ 合并即失去意义 |
| G | **空体素跳过 ESS（换 OSPRay/ANARI 后端）**：跳过透明背景块 | 业界对稀疏体的头号提速、不损质量 | ❌ **实测对本数据收益有限**（见 §6）：保质量阈值下仅 ~2×，且**ESS 跳的是空区、不解决"重叠"**。VTK 库存 mapper 无自动 ESS；OSPRay 本环境未编、vcpkg 无包 |
| H | 减少同屏体数（只渲选中 ≤7 条）| 真实工作流本就是选几条，1 包 1 遍 | ✅ 免费、永远有效（使用方式，非技术） |
## 6. 关键实测数据
### 6.1 ESS（空体素跳过）潜力——零依赖实测，决定要不要上 OSPRay
对一条真实测线密体（5702×56×789），按块算 min/max，统计"整块落在近零透明带"的占比（=ESS 可跳块）：
| 透明带半宽(相对半值域) | 8³ 块可跳占比 | 理论提速上限 1/(1−占比) | 说明 |
|---|---|---|---|
| 5% | 8% | 1.1× | 极保守 |
| **10%（保质量，不丢弱反射）** | **52%** | **~2.1×** | — |
| 20% | 80% | ~4.9× | 开始把弱反射当背景丢 |
| 30%（激进）| 90% | ~10× | 明显损质量 |
- 体素层面 **91% 近零**，但块层面（ESS 实际粒度）保质量阈值下**只能跳 ~52% → 理论 ~2×**。
- 原因：**反射层横贯整个深度分布**，多数块里总混着信号、跳不掉。要 10× 须用激进阈值（损质量）。
- **更关键**：ESS 跳"空区"，**不减少"重叠"**——在有信号的块里仍要逐个采样所有重叠体。
### 6.2 其它实测
- multi-volume 纹理单元上限：本机 7 体/包（32 单元），第 8 体报 "Hardware does not support the number of textures"。
- 体维度示例：coarse 4 → ~11000×56×793/线；coarse 32 → ~1400×56×780/线。
- 全 20 条 dense（coarse 32）：底图 level 0、Y=56、分 3 包，**渲染正确**；交互 ~1.7fps（**未加 D 方案的旧构建**）。
## 7. 关键点——已实测，结论修正（原假设两条都被推翻）
### 7.1 "重叠几层"——实测：**平均 ~8.7 层、最大 15 层（不是 ~2–3，也不是 20）**
纯几何测（各线世界 AABB 投到 X-Y 俯视 footprint、细网格统计每格覆盖层数，`--overlapStat`）：
- footprint：横向 X≈37m、沿路 Y≈2.2km；
- **有体覆盖处平均重叠 8.74 层，最大 15 层**；穿 12–14 个体的格子占 ~42%。
- **结论修正**：原"~2–3 层"假设**错**（开发团队和外部专家都猜偏了）；**重叠是真实的大瓶颈**。
- **且这 9 层是冗余**：20 趟是同一条路反复扫，同一地下点被测了 ~9 次 → 这 9 个重叠体在该处**都非空**
（同一地下结构）→ **ESS 在重叠区一个都跳不掉**（再次印证 ESS 不解决重叠）。
### 7.2 "采样 vs 重叠谁是大头"——实测：**采样瓶颈，fps 线性正比于步长**
20 条密体、静止近景、离屏（步长越大越快越糙）：
| sampleDist | fps | 相对 |
|---|---|---|
| 0.2（≈自动细）| 1.3 | 1× |
| 0.5 | 3.2 | 2.5× |
| 1.0 | 5.9 | 4.5× |
| 2.0 | 11.3 | 8.7× |
| 4.0 | 20.9 | 16× |
- **步长翻倍→fps 翻倍 → GPU 是采样瓶颈**。总开销 ≈ 光线数 × (光线长/步长) × ~9 个重叠体。
- D 方案（手动步长）**确实直接、强力提速**；但**保质量的步长（≈ Nyquist，0.5×体素）下仍只 ~2 fps**
——因为 **9× 冗余重叠**把它乘了回去。要到交互级(10+fps) 得把步长粗到 ~2.0（欠采样、损 Z 薄层）。
### 7.3 合并诊断（两测合起来）
**慢 = 采样密度 × ~9 倍冗余重叠，两者都真实。**
- D 方案(粗化采样)：提速强，但保质量步长下被 9× 重叠压回 ~2fps；要交互须损质量。
- **唯一"保质量又快"的，是去掉那 9× 冗余重叠**（同路重扫的同一地下点）：合并/装箱（取真实道、不跨线
插值）→ 一个体一遍 → ~9× 提速、且 Nyquist 步长下也能交互、**零质量损失**（冗余测量本就该合并降噪）。
- **但这与用户"保持 20 条可区分"直接冲突**——而这 9 层在物理上是**冗余测量**（同一地下结构扫了 9 遍），
保持它们"可区分"的工程价值存疑。
### 7.4 CPU OSPRay vs GPU（仍未测）
ESS 对本数据 ~2× 且不解决 9× 重叠；OSPRay 主要 CPU、对手是 GPU 数千核。**很可能换 OSPRay 比现状还慢**，
且为 ~2× 重编整个 VTK 投入产出极差。不建议在去掉冗余重叠之前考虑。
### 7.5 "多线为何卡"的根因确诊（passcost，决定架构）——结论：**不是固定开销，是没用 LOD**
> 背景：最初 P11/P12 是"各线独立 mapper + 视野 LOD"，实测仍 0.5fps。需确诊卡在三个嫌疑哪个：
> ①LOD 选区没削小 ②N 遍固定开销 ③重叠没摊掉。`passcost` 命令：N 个独立 GPU mapper 各渲一个 64³ 小体
> （模拟 LOD 削过的小区），分"铺开/不重叠"与"叠在一起/重叠"，测离屏稳态 fps vs N。
| N | 铺开(不重叠) fps | 叠加(重叠) fps |
|---|---|---|
| 1 | 177 | 204 |
| 5 | 162 | 43 |
| 10 | 144 | 22 |
| **20** | **78** | **11** |
**判读（决定性）：**
- **嫌疑 ②（N 遍固定开销）排除**：20 个独立 mapper 铺开仍 **78fps**（177→78，远非线性）。
→ **各线独立 mapper 架构上完全可行，固定开销温和。"multi-volume 单遍 ⊥ 视野 LOD"这个不可兼得不致命**——
放弃单遍、回独立 mapper 并不慢。
- **嫌疑 ③（重叠）真实但小体下可控**：叠加随 N ~1/N（每条光线乘 N），但 **20 层 64³ 叠加仍 11fps**（可用），
再叠屏幕降采样更快。
- **嫌疑 ①（选区没削小）= 真凶**：passcost 小体 20 层叠加=11fps，而真实 view-all 只 1.7fps——差距全在
**贴图大小**：当前渲的是**整卷底图**（~11000×56×200 ≈ 上亿体素/条），**根本没用视野 LOD 把它削成小区**。
这是**最好结局：可修，不动地基，只需真正用上 LOD**。
**对架构的直接含义**：本会话引入的 **multi-volume 单遍是错误取舍**——为"单遍"关掉了 LOD、改固定整卷贴图，
导致大贴图 × 9 层重叠 = 1.7fps。而 passcost 证明独立 mapper 够快，**根本不必为单遍牺牲 LOD**。
## 8. 部署约束（硬件不确定，跨厂商）
客户机配置未知（可能无独显，或 N卡/A卡/Intel）。**没有任何单一渲染器能在 N 卡和 A 卡上都做"GPU+ESS"**——
GPU 体光追渲染器全厂商锁定（N 卡→NVIDIA VisRTX/OptiX/IndeX；Intel→OSPRay-GPU；A 卡→基本无成熟方案）。
跨厂商唯一通用的是 **OSPRay-CPU（免显卡、任意 x86）** 或 **OpenGL（任意 GPU、但无 ESS=现状）**。
若上多后端，需"OSPRay-CPU 保底 + 探测到 N卡/Intel独显时升对应 GPU 后端 + OpenGL 终极兜底"。
## 9. 关键问题——大多已被实测回答
1. ~~有没有不损质量的根本性提速法~~ **有，且是通用解：LOD（视野自适应多分辨率）**——让 GPU 单帧实际
ray-cast 的体素量**与数据总量解耦、只与"屏幕能看清的量"挂钩**（Task 12c 单体已验证 752/380fps）。
§7.5 passcost 证明它**对多线也成立**（独立 mapper 开销温和，20 条铺开 78fps）。
2. ~~"卡"的主因~~ **已确诊（§7.5）：不是 N 遍固定开销（排除），是【当前根本没用 LOD、渲整卷大贴图】（嫌疑①）。**
本会话引入的 multi-volume 单遍为"单遍"关掉了 LOD → 大贴图 × 9 层重叠 → 1.7fps。
3. **9 层重叠的正确定位**（外部专家纠偏 + passcost 印证）：它只是**这批数据（同路重扫 20 趟）的特例倍数**，
**不是渲染本质问题**。本质是"单帧采样量 > GPU 吞吐"，通用解是 LOD（扛任意大数据：无重叠但更大也能扛）。
9 层重叠在 LOD 之上降级为"一个被摊薄的常数因子"（passcost：20 层小体叠加仍 11fps）。
**不要让渲染架构围绕这个特例设计。**
4. ESS/OSPRay/多后端：**继续埋掉**——ESS 对本数据 ~2× 且不解决重叠、CPU 对手是 GPU，且**它解决的是 LOD
已经解决的通用问题**，投入产出差。
## 10. 最终结论（passcost 确诊后，架构清晰）
- **渲染架构 = LOD 中心（视野自适应、单帧量与总量解耦）。** 这是扛"任意大数据"的通用根本解，
Task 12c 单体已验证、§7.5 passcost 多线也成立。
- **本会话的 multi-volume 单遍是错误取舍**：为"单遍合成"牺牲了 LOD、改固定整卷大贴图，正是当前 1.7fps 的
直接原因。passcost 证明独立 mapper 开销温和（20 条 78fps）→ **根本不必为单遍弃 LOD**。
- **正解 = 各线独立 mapper + 视野 LOD（逐线用 Task 12c 引擎）+ 停手才重建**（不每帧重建，避免 P11/P12
那种"20 条每帧重建上传"的 thrash——那才是 0.5fps 的另一半原因，与稳态 ray-cast 无关，已被 P13 思路解决）。
让每条线只渲视野内小区 → 即使 9 层叠加也可用。
- **9 层重叠 = LOD 之上的可选应用层优化**（对同路重扫冗余可"合并/降噪"，顺带省 9×），**不进渲染地基**。
用户要逐条区分就不合并（靠 LOD 摊薄），要纯总览就合并。
- **采样步长（D 方案）= LOD 框架内的质量旋钮**，非独立根本解。
- **ESS/OSPRay/多后端：不做**（不解决 LOD 已解决的通用问题，对本数据收益差）。
→ **下一步（确诊已完成，可开工）**：把多线总览从"multi-volume 单遍固定整卷"改回"各线独立 mapper +
视野 LOD + 停手重建"，让单帧渲染量随视野走、与 20 条总量解耦；实测多线总览是否达交互级。
这是顺着通用 LOD 框架、被 passcost 数据支撑的明确方向——不再围着 9 层重叠这个特例转。
---
### 附：相关已落地代码 / 诊断工具（如专家要复现）
- 通道插值：`src/io/gpr/GprGeometry.cpp::planChannelInterpolation` + `Gpr3dvVolumeBridge.cpp`
- 多体合成/退避/质量控制/通道 LOD：`tools/gpr_poc/main.cpp::cmdViewAll`
- **诊断命令**（`tools/gpr_poc/main.cpp`，可直接跑复现 §6/§7 的数）：
- `gpr_poc ess-stat <dir> <line>`：ESS 空块潜力（§6.1）
- `gpr_poc view-all <dir> <gps> --overlapStat`：实测重叠层数（§7.1）
- `gpr_poc view-all <dir> <gps> --sampleDist D`：步长↔fps（§7.2）
- `gpr_poc passcost --size 64 --overlap 0|1`：N 遍开销 vs 重叠 隔离测（§7.5）
- 数据/插值口径 spec：`docs/superpowers/specs/2026-06-25-gpr-line-channel-interpolation-and-multivolume.md`
- 多后端 ESS 架构 spec（**结论：不做，见本文 §10**）：`docs/superpowers/specs/2026-06-26-gpr-multibackend-ess-rendering.md`
---
## 摘要（一页结论，供决策）
1. **现象**：20 条通道插值密体总览，~1.7fps、交互更卡。视觉正确，纯性能。
2. **确诊**（passcost 隔离测）：**不是 N 遍固定开销**（20 独立 mapper 铺开 78fps，排除）；
是**当前根本没用视野 LOD、在渲整卷大贴图**（× 9 层重叠）。本会话的 multi-volume 单遍为"单遍"
牺牲了 LOD，是直接原因。
3. **通用根本解 = LOD**（单帧渲染量与数据总量解耦），扛任意大数据；Task 12c 单体 752fps、passcost 多线
也成立。9 层重叠只是**本批数据的特例倍数**，是 LOD 之上一个可摊薄/可选合并的因子，**不是架构核心**。
4. **正解**：各线独立 mapper + 视野 LOD + 停手才重建（弃 multi-volume 单遍）。
5. **明确否定**：ESS/OSPRay/多后端（对本数据 ~2×、不解决重叠、解决的是 LOD 已解决的通用问题）。

132
docs/superpowers/specs/2026-06-26-gpr-multibackend-ess-rendering.md
View File

@ -1,132 +0,0 @@
# ⚠️ 本 spec 已被实测推翻，勿照此实现
> **结论（见 `2026-06-26-gpr-3d-render-perf-ANALYSIS-for-review.md` §10）：ESS/OSPRay/多后端【不做】。**
> 实测：ESS 对本数据 ~2× 且不解决重叠；passcost 确诊"多线卡"的真因是【没用视野 LOD、渲整卷大贴图】，
> 不是固定开销。**正解 = LOD 中心（各线独立 mapper + 视野 LOD + 停手重建），见下方实现计划。**
> 本文余下"多后端/ESS"内容仅作历史记录。
---
## 实现计划（LOD 中心多线总览 — 已确诊、可执行）
**目标**：把 `cmdViewAll` 从"multi-volume 单遍 + 固定整卷大贴图"改为"各线独立 mapper + 视野 LOD +
停手才重建"，使单帧渲染量随视野走、与 20 条总量解耦。
**改动步骤（`tools/gpr_poc/main.cpp::cmdViewAll`）**：
1. `PlacedSource` 加回**每线自己的 `vtkSmartVolumeMapper`**（GPU 模式）；删 multi-volume 用法
（multiMapper/multiVol/port 不再需要，但可暂留不碍）。
2. **装配**：删 `buildBundles` + 退避（无 multi-volume 即无纹理单元上限）；改为逐线
`mapper->SetInputData(baseImage)` → `volume->SetMapper(mapper)` → `ren->AddVolume(volume)`，
各线 mapper 收进 `mappers` 向量（供质量控制）。
3. **开 LOD**：`gViewAllBaseOnly = false`（启用引擎选区换图）；引擎换的是"改包围盒的子区域"，
各线独立 mapper 下**安全**（无 multi-volume 可破坏）。
4. **关 channel LOD**：`gChanLod = false`——引擎金字塔已逐级降 Y，无需单独抽 Y 平面。
5. `viewAllPickOneLine`：`ps.mapper->SetInputData(ps.currentImg); ps.mapper->Update();`（非 multiMapper 端口）。
6. **停手才重建（已有，确认接线）**：拖动中(`viewAllOnInteracting`)只降质+重置裁剪、**不提交引擎目标**；
松手(`viewAllOnInteract`)/定时器 idle 才 `viewAllSubmitTargets`（提交 LOD 目标）+ `viewAllPickOneLine`
（拉就绪区域换上）。避免 P11/P12"每帧 20 条重建上传"thrash。
7. **质量旋钮保留**：`--sampleDist`/`--maxImgSample`/`--dragSampleMul` 作 LOD 框架内的交互降质兜底。
8. **总览级别**：引擎 `selectLod` 按屏幕像素选层——拉远时全路映射到少量像素 → 自动选粗层（小贴图）→
20 条小贴图即可用；拉近 → 小区域细层。**确认 selectLod 多线下确实选到粗层**（若没有，调
selectLod 的屏幕像素阈值——这是 §7.5 嫌疑①的修复点）。
**验收**：离屏看各线底图 level 随相机距离变（远→粗/小、近→细/小区）；真窗口测 20 条总览交互级 fps、
拖动跟手、松手清晰、过档位无明显卡顿（外部专家提示重点盯"停手重建过渡手感"）。
---
# GPR 三维体渲染：多后端 + 空体素跳过(ESS) 加速架构 — Spec（2026-06-26，已废）
> 解决"20 个重叠密体在 VTK 库存 OpenGL mapper 上又卡又只能降质"的根本性方案。
> 关联：`docs/superpowers/specs/2026-06-25-gpr-line-channel-interpolation-and-multivolume.md`（数据/插值口径）。
---
## 0. 一句话目标
用**空体素跳过(ESS)** 这一不损可见质量的业界技术，把"逐线分开的多个密体合并渲染"做到**不卡**；
并以**多渲染后端 + 自动适配**覆盖客户侧未知/多厂商硬件（含无显卡）。
---
## 1. 问题与根因
- 现状渲染 = VTK `vtkGPUVolumeRayCastMapper`（OpenGL）。**任意 GPU 可跑（最通用），但无 ESS**。
- 20 个重叠半透明密体：每条光线每步在 20 体各采一次、光线又长 → 几十亿次纹理查找/帧 → 1.7fps、交互更卡。
- 通道插值后 Y 加密到 2.5cm，使自动沿光线步长更细 → 更卡。
- **已尝试的"交互降质"（屏幕降采样 + 沿光线步长加粗）是治标**，损可见质量。
## 2. 根本方案：ESS（不损质量）
GPR 体 ~90% 是近零背景（反射层之间空）。ESS 用 min/max 加速结构**跳过"在传函里全透明"的块**，
对稀疏数据常 5–50× 提速、**零质量损失**。但 **VTK 库存 GPU mapper 不做自动 ESS**（仅有受限的
`UseDepthPass` 等高线跳过）。→ 真 ESS 必须**换专业体渲染后端**（其底层自带 ESS + 正确合成多重叠体）。
## 3. 关键事实：跨厂商 GPU 加速不存在单一方案
GPU 体光追渲染器全是**厂商锁定**：
| 后端 | 硬件 | ESS | 跨厂商 | 角色 |
|---|---|---|---|---|
| OpenGL（vtkGPUVolumeRayCastMapper，现状）| 任意 GPU(N/A/Intel) | ❌ | ✅ | **终极兜底** |
| OSPRay（CPU，Embree/ISPC）| 任意 x86 CPU（免显卡）| ✅ | ✅ | **通用基线** |
| OSPRay-GPU（SYCL/oneAPI）| 仅 Intel Arc/数据中心卡 | ✅ | ❌ | Intel 独显 |
| ANARI + VisRTX（OptiX）| 仅 NVIDIA | ✅ | ❌ | N 卡 |
| AMD GPU 体渲染+ESS | — | — | ❌ 无成熟方案 | — |
**结论**：没有"同时 N/A 卡的 GPU-ESS"。**面向未知客户机，OSPRay-CPU 是最稳通用选择**（免显卡、ESS、质量不降）。
## 4. 渲染后端架构（多后端 + 自动适配 + 手动覆盖 + 兼容灰掉）
### 4.1 用户可见选项（按硬件/结果命名，不暴露库名）
| 用户看到 | 背后实现 | 适配硬件 |
|---|---|---|
| **自动（推荐）** | 探测后选下面之一 | — |
| GPU 加速（N卡）| ANARI + VisRTX | NVIDIA 独显 |
| GPU 加速（Intel）| OSPRay-GPU | Intel Arc 独显 |
| CPU（通用，免显卡）| OSPRay-CPU | 任意 CPU |
| 通用 GPU（兼容）| OpenGL（现状 mapper）| 任意 GPU（兜底）|
### 4.2 自动探测逻辑
```
if NVIDIA 独显: → VisRTX(GPU)
elif Intel Arc 独显: → OSPRay-GPU
elif AMD(独显/核显) 或 Intel 核显 或 无显卡 或 探测失败:
→ OSPRay-CPU（默认） // 核显一律走 CPU：弱+共享内存+多不被GPU后端支持
// 强力 A 卡可手动选"通用 OpenGL"用其 GPU(无 ESS)，但不作默认
```
- **手动覆盖**：用户可自选，但**只列出与当前硬件兼容的项**（不兼容灰掉，如 A 卡上禁 VisRTX）。
- **集显建议**：一律 OSPRay-CPU（CPU+ESS 比让弱核显硬渲更稳更快）。
### 4.3 部署策略（一句话）
**OSPRay-CPU 保底通用；探测到 N卡/Intel Arc 时升对应 GPU 后端；A 卡/核显吃 CPU 基线；OpenGL 终极兜底。**
## 5. 上 ESS 后端后，废弃哪些
- ❌ **装箱单体(binning)**：当初为绕 OpenGL 无 ESS 才提（代价=丢"逐线分开"）。ESS 后端让**逐线分开
的多体也快** → 不需要装箱。**逐线分开 + 不造假 + 不卡，三者兼得。**
- ❌ **交互降质权宜**（屏幕/沿光线步长加粗）：ESS 后端有自带的自适应/渐进式细化，基本不用；保留作任何后端的兜底。
- ❌ 自写 ESS shader / 预积分 / UseDepthPass：后端自带，无需自行实现。
- ✅ **保留**："选几条 ds(≤7)" 是使用方式（非技术），永远有效。
## 6. 实现要点（工程）
- VTK 需**重编**带：`RenderingRayTracing`(OSPRay)、`RenderingAnari`(ANARI/VisRTX) 模块 + 依赖
（OSPRay/Embree/ISPC/OpenVKL；ANARI-SDK/VisRTX）。用户已确认工程量无所谓。
- 渲染层抽象一个 `IVolumeRenderBackend`，运行时按 §4 选具体 mapper：
`vtkGPUVolumeRayCastMapper`(OpenGL) / `vtkOSPRayPass`+volume / `vtkAnariPass`+volume。
- **数据不变**：逐线密体（含通道插值，spec 前一份）原样喂各后端；多体合成由后端负责（无 K=7 分包）。
- 硬件探测：GL_VENDOR / 平台 API（DXGI 枚举适配器）判 N/A/Intel + 独显/核显。
## 7. POC 计划（先验"CPU+ESS 够不够快"——最通用、风险最低）
1. **POC-1（先做）**：最小程序，用 **OSPRay-CPU** 渲一个 GPR 密体（tmp/lines_all_dense 里一条/几条），
**实测普通 CPU 上对多体/密体的 fps + ESS 提速比**，对照现状 OpenGL。先确认 OSPRay 在本环境
可编可跑、CPU+ESS 实际够快——这是整套方案值不值得上的关键闸门。
2. **POC-2**：若有 N 卡，ANARI+VisRTX 渲同一体，对照 GPU 提速。
3. POC 通过 → 才动手重编 VTK + 接后端抽象层。
## 8. 风险 / 待定
- OSPRay-GPU（Intel）较新、不如 CPU 路成熟；ANARI/VisRTX 需 NVIDIA 驱动 + VisRTX 库。
- 各后端传函/外观与 OpenGL 有差异，需重新调一致。
- 本环境能否编出带光追/ANARI 的 VTK（vcpkg/手动依赖）待 POC-1 验证。
- CPU+ESS 在低核机上的实际帧率待实测。
## 9. 验收
1. 客户机无论有无显卡/何种显卡，自动选到可跑的后端并出图（OSPRay-CPU 永远兜底）。
2. 20 条密体总览：逐线分开、不造假、**ESS 后端下不卡**（目标交互 ≥ 可用帧率，质量不降）。
3. 手动选项只列兼容项；集显默认 CPU。
4. 数据层（通道插值密体）零改动复用。

144
docs/superpowers/specs/2026-06-27-inversion-3d-volume-surfer-method-and-gaps.md
View File

@ -1,144 +0,0 @@
# 反演剖面三维体：客户目标方法（Surfer）对照与客户端差距 — 2026-06-27
> 来源：客户提供的演示视频 `ScreenShot/9f67e80cb823170bb9374d779ec4c0cb.mp4`（Golden Software Surfer，13min）
> 与参考成果图 `ScreenShot/Weixin Image_20260627080012_429_2117.png`。
> 结论一句话：**客户用的就是"合并点云 + 3D 反距离加权(IDW) + 边界裁剪(Blanking) + 体绘制/等值面"。**
> 客户端插值内核已与之一致，差距只在「搜索半径 / 边界裁剪 / 等值面」三点。
---
## 0. 背景与一次认知纠偏
用户反馈："选多个 dd_inversion_data（江西理工四条井字相交测线）做三维体，得到的是四个剖面各自左右
拉伸的薄板，不连成完整体。"
排查中曾推荐"逐深度层各向异性插值"——看了客户演示视频后**确认是过度设计**。客户没有逐层做，
就是**朴素的三维 IDW**（对合并后的整团散点云一次性 3D 网格化）。本文以视频实证为准。
---
## 1. 客户目标方法（Surfer 实测，逐帧为证）
| 步骤 | 操作 | 视频帧（时间戳）证据 |
|---|---|---|
| 1. 合并点云 | 所有测线/剖面反演单元合并成**一个 XYZC 文件** `combine-e_m_m.xyz`，列= **X, Y, Elevation, Resistivity, Conductivity, Sensitivity** | t48.7：Grid Data 导入对话框，Data Type=**XYZC** |
| 2. 三维网格化 | Grid Data → 方法 **Inverse Distance to a Power（IDW，幂次）** → XYZC 直接生成 **3D 网格体**；注脚明示"does not extrapolate beyond the range of data" | t48.7：Gridding Method 选中 IDW；t97.5：Gridding 进度；t195：`.grd has been created` |
| 3. 边界裁剪 | 数字化**测区边界多边形**（Base vector / Polyline）→ **Blanking** 把体裁到测区真实足迹 | t292.5：Polygon 工具数字化边界 |
| 4. 三维渲染 | 3D View → 3D Grid Volume（`out-BAIHUA.vtk`）：**Volume render**(Sliced / Slice count 500 / Tri-linear / Alpha blending / Opacity 80%) + **Isosurface**(阈值 isovalue) + **Image slice**(YZ/Z) | t585：Volume render 属性；t682：Isosurface(isovalue=1794.39)；t633：Image slice(YZ) |
要点：
- **真三维 IDW**，对合并点云一次成体（非逐层 2D）。
- IDW **不外推到数据范围外**；测区足迹靠 **Blanking 多边形**裁出（参考图那个不规则边界即来源于此）。
- 红色异常体 = **等值面抽取**（Isosurface 按阈值）。
- 坐标为真实投影坐标 + 高程，可叠地形/影像底图。
---
## 2. 客户端现状（已实现部分）
生产路径：`Api3dRepository::createVolume`（`src/data/api/Api3dRepository.cpp`）
→ 把所有选中 ds 的反演单元按测线真实几何配准合并成 `PointSet`
→ `buildVolume(pts, cellXY, cellZ, power, maxDist)`（`src/core/algo/VolumeBuilder.cpp`）
→ **三维 IDW**（`src/core/algo/IdwInterpolator.cpp`）：`maxDist` 外置 NaN 留空。
即：**「合并点云 + 3D IDW」内核与 Surfer 一致**。参数见 `src/data/repo/VolumeBuildParams.hpp`：
`cellXY=1.0, cellZ=0.5, power=2.0, maxDist=4.0`。
渲染：`VoxelActor`（`src/render/actors/VoxelActor.hpp`）仅 GPU 体绘制（NaN→透明），**无等值面**
（`GridContourActor`/`ContourBands` 是 2D 网格等值线，非 3D 等值面）。地形/影像/坐标轴/电极点已有
（`TerrainActor`/`TileBasemap`/`AxesActor`/`ElectrodeActor`）。
---
## 3. 差距与修复（共 3 点）
> 不需改插值算法（内核已对）；改的是搜索域、裁剪、与等值面。
### G1. 搜索半径 maxDist 太小 → "四块板"
`maxDist=4m` 远小于井字测线间距 → IDW 只填测线 ±4m 管套，线间留空 → 四块薄板。
**修复**：把搜索半径放大到覆盖测区（或提供"覆盖全域"选项），对齐 Surfer 默认搜索域行为。
### G2. 缺边界裁剪(Blanking) → 单纯放大半径只会"变粗"
**这是用户观察到"调大 maxDist 只是让体看起来更粗"的真正原因**：没有足迹裁剪，放大半径会把体
鼓满整个外接盒 → 粗大臃肿。Surfer 不粗，是因为 Blanking 把体裁到了测区真实多边形足迹。
**修复**：加**足迹掩膜**——
- 自动：散点平面**凸包 / alpha-shape**（或沿测线 buffer 并集）；
- 或手动：支持用户数字化/导入边界多边形（对齐 Surfer Blanking）。
掩膜外体素整列置空（NaN/透明）。
### G3. 缺 3D 等值面 → 出不来红色异常体
`VoxelActor` 只有体绘制。
**修复**：在体上加 **`vtkFlyingEdges3D` / `vtkContourFilter`** 抽等值面，阈值可调（对齐 Surfer Isosurface）。
---
## 4. 修复落地顺序
1. **G1+G2 一起做**（插值搜索域放大 + 足迹掩膜）→ 出满铺、裁到测区足迹的体。这是核心，先做。
2. **G3 等值面**（阈值可调）→ 出红色异常体。参考图第二主角，紧接着做。
3. 影像底图/坐标轴/电极点复用现有。
---
## 5. 必须先和客户对齐的预期（避免"又看起来不对"）
参考图是**密集测网**（顶面可见很多条测线点阵）；江西项目只有**四条井字线**。
- **形态可复刻**（满铺体 + 等值面 + 影像底图）；
- 但**框内细节出不来**——参考图的细碎红异常源于密集采样，四条线之间只能给出平滑趋势，
等值面会是几个光滑大团。要那种精度需加密测线。
---
## 6. 非目标 / 说明
- 不改 IDW 内核算法本身（已与 Surfer 一致），不引入逐层各向异性（客户未用）。
- 各向异性搜索椭球可作为后续可选增强（Surfer 亦为可选项，非默认），本期不做。
- Kriging 仍为占位（`VolumeBuildParams::Model::Kriging`，core 未实现），本期不依赖。
---
## 7. 续：白化方式之争 + 体绘制边界「梯田」（2026-06-28，branch `fix/3d-volume-blanking-mask`）
> 本节记录 §1–6 之后这一轮的来龙去脉、技术取舍与权威佐证，供后续决策不再反复。
### 7.1 前因后果（时间线）
客户原话："**我们这个白化确实有问题，填色了，填了蓝色**"——无数据区被填成蓝色，而非 Surfer 那种透明白化。排查分三层、逐个修：
1. **切片填蓝**：`vtkImagePlaneWidget` 会按【输入标量范围】(含哨兵)自动 window/level，把哨兵顶到 LUT 最低色格(蓝)且不透明。
修复：`SliceTool` 钉死 `SetWindowLevel([vmin,vmax])` + `ColorLutBuilder` 预留 0 号"白化槽"(全透明)，哨兵(<vmin)钳到该槽即透明。实测证据：`tests/spike/slice_alpha_probe.cpp`（真 widget 离屏渲染 + 回读像素：背板透出=透明成功）。**这条同时纠正了切片颜色映射**（之前 colorbar 被错误拉伸到切片局部范围）。
2. **早期"满屏蓝"是误判**：实为 `maxDist=0`（自动覆盖测区，`kDefMaxDist=0.0`）把整个凸包**填实**=真实低值数据(蓝)，**不是空值**（见 §3 G1）。日志实证请求体 `"maxDist":0`。
3. **三维体渗蓝**：无数据格设哨兵 `vmin-1`、不透明度 0；三线性插值在"哨兵↔真值"交界处插出低值(蓝)且不透明度非零 → 渗一圈蓝。为消除，给体绘制加**二值 mask**（`VoxelActor::makeMaskLike` + `assembleVolume` 用 `vtkGPUVolumeRayCastMapper`+`SetMaskInput`+`SetMaskTypeToBinary`，mask=0 体素被光线投射**硬跳过**）。
**mask 的副作用 = 用户 2026-06-28 截图的「竖条/梳齿/底边锯齿」**：硬跳过=边界不再三线性插值/羽化。`maxDist=0` 下体填满**凸包足迹**（带斜边多边形），斜边在 1m 规则网格上离散成**体素阶梯(staircase)**。以前(SmartVolumeMapper+哨兵→不透明度0 软消隐)斜边被羽化抹圆、看不出；加 mask 后变成逐体素硬台阶。**即使色阶不透明度=100% 也可见**——因 mask 在不透明度传函【之前】就把体素从光线上删了（两个并行子代理：渲染侧 + 数据/建体侧共同确诊）。
### 7.2 取舍的本质
| 方案 | 边界观感 | 数据诚实度 | 误判风险 |
|---|---|---|---|
| **二值 mask（当前）** | 体素梯田（难看） | ✅ 只画真数据、零假值 | 低（梯田明显是网格对齐的足迹边界，不像地质体） |
| 软消隐（哨兵→不透明度0，无 mask） | 平滑 | ❌ 边界是插值出的假值 | **高** |
### 7.3 「细蓝边」是什么 + 为何【不能】回退软消隐（权威佐证）
软消隐回退后的"细蓝边" = 真数据格与哨兵格(`vmin-1`)三线性插值出的、**数据里根本不存在的假低阻值**。低阻在物探通常指含水/导电体，这圈蓝出现在测区最外缘会被**误读成"边界存在真实低阻(导电)异常带"**——真有数据分析歧义。
多个权威来源一致认定"插值进 NoData 产生边缘伪影"是错误做法、应 mask 排除：
- **ESRI 官方**：双线性/三次插值 "**interpolate incorrectly into the NoData** and background areas... producing **artifacts or black ridges**" —— 我们的"蓝脊"与之同源（哨兵钳到最低色=蓝）。<https://support.esri.com/en-us/knowledge-base/faq-why-do-bilinear-interpolation-and-cubic-convolution-000003271>
- **GDAL 官方**：正确做法是把 masked NoData 的 "**weights of contributing source pixels are set to zero to ignore them**" / "will not be used in interpolation"。<https://gdal.org/en/stable/programs/gdalwarp.html>
- **rasterio**：bilinear 重采样在 NoData 边界产生 invalid 值（已知 issue #1721）。<https://github.com/rasterio/rasterio/issues/1721>
- **Golden Software Surfer**（客户参照工具）：NoData "**removed from the neighborhood**"，不跨它插值。<https://surferhelp.goldensoftware.com/gridmisc/Blanked_Nodes_Grid_Filter.htm>（定义 <https://surferhelp.goldensoftware.com/glossary/def_blanking.htm>）
- **凸包外 = 外推**："**Extrapolated data is usually meaningless and misleading.**" <https://github.com/fatiando/fatiando/pull/44>、<https://www.spatialanalysisonline.com/HTML/gridding_and_interpolation_met.htm>
**结论：二值 mask = 业界标准的"把 NoData 排除出插值"做法，是对的**；梯田只是 mask 在斜足迹边界上的网格离散观感（诚实、不误导）。**不应回退软消隐**（=让哨兵参与插值=以上权威明确反对的造假值做法）。
### 7.4 决策与待办（截至 2026-06-28，本分支未提交）
- ✅ **保留二值 mask**（数据诚实/合规，符合 ESRI/GDAL/Surfer 标准）。
- 梯田若要压平，走**不造假值**的路（二选一，**待用户/客户拍板**）：
- (a) **细化 XY 网格**：`cellXY` 1m→0.5m，阶梯缩到亚像素；代价：体素×4、耗时 ~3.5s→~14s、内存×4。
- (b) **接受梯田**：它诚实、且明显是足迹边界，不会被当成地质体。
- 渲染侧本轮其它已落地修复（排查"分层/稠密"时做、确认非主因但保留）：GPU 探测+CPU 回退(`setVolumeGpuSupported`)、细采样距离+`UseJittering`、`ScalarOpacityUnitDistance=对角/10`、去 `kMaxOpacity`(改由色阶「不透明度」单一控制、100%=实心)、移除工具条「透」滑块。
- **附带缺陷（待修）**：`VoxelGenerateRequest::maxDist` 结构体默认 `4.0`（`src/data/dto/Vtk3dRequests.hpp:18`）与对话框 `kDefMaxDist=0.0`（`VolumeParamsDialog.cpp:34`）不一致——绕过对话框直建会拿到 4m → 退回"四块板/线间空隙"老问题，应统一为 0。
- 抽稀空间哈希 `(ix*p1)^(iy*p2)^(iz*p3)`（`VolumeBuilder.cpp` ~146-151）为 XOR 非单射、有碰撞风险（与本症无关，但宜换 `(iz*ny+iy)*nx+ix` 线性键）。

231
docs/superpowers/specs/2026-06-28-dataset-detail-view-architecture-and-extension-guide.md
View File

@ -1,231 +0,0 @@
# 数据集详情视图：架构详解 + 「新增一种 ds 类型详情页」扩展指南 — 2026-06-28
> 读者：将为**一种新数据集类型**开发详情页的同事。读完本文你应能**独立按现有架构扩展，无需口头交接**。
> 所有引用均为 `文件:行号`（可点击）。代码以 2026-06-28 `fix/3d-volume-blanking-mask` 分支为准。
---
## 0. 一句话架构
**详情页 = 数据驱动的"策略 + 页签引擎"**：每种 ds 类型（由 **`ddCode`** 标识）有一个**策略**声明它有哪些页签（每页签 = 一种视图 + 一个加载键）；控制器按 `ddCode` 找策略 → 建页签 → 按加载键**异步**拉数据 → 解析成**类型擦除的 payload(`QVariant`)** → **工厂**按视图种类造视图 → 视图 `setPayload` 自解包渲染。**新增类型 = 加一个策略 + 一条加载键分发 + （必要时）一个视图**，**不动**列表/控制器/壳层。
---
## 1. 端到端数据流（双击一个数据集会发生什么）
```
[列表 QTreeWidget] 双击 item
main.cpp:1501 itemDoubleClicked → 读 item 的 data role：
kDsIdRole / kDsDdCodeRole / kDsNameRole / kDsTmObjectIdRole
main.cpp:1509 detailCtrl.openDataset(dsId, ddCode, dsName, tmObjectId)
│
▼
[编排层 DatasetDetailController]
DatasetDetailController.cpp:21 openDataset()
registry_.find(ddCode) → 找策略（找不到 → emit loadFailed "暂不支持该数据类型的预览"，优雅降级）
strategy->tabs() → std::vector<TabSpec>
emit datasetOpened(dsId, ddCode, dsName, tmObjectId, tabs) ──┐ 建页
对每个【非 lazy】页签 loadTab(dsId, ddCode, i) │
│ │
▼ DatasetDetailController.cpp:46 loadTabImpl() │
repo_.loadAsync(spec.loaderKey, dsId, pageNo, pageSize) │ 按【loaderKey】异步加载
→ DetailLoad*（在飞句柄，存 inflight_[tabIndex]，abort-and-replace）
emit tabLoadStarted(dsId, i) → 页上盖「加载中」遮罩 │
│ DetailLoad::done(QVariant payload) │
▼ │
emit tabReady(dsId, i, payload) │
│ │
▼ ▼
[壳层 DatasetDetailPanel(QTabWidget，每个 ds 一页) / DatasetDetailPage(单 ds，多页签)]
Panel.onDatasetOpened (DatasetDetailPanel.cpp:38) ← datasetOpened
new DatasetDetailPage → 注入(repo/viewState/tmObjectId) → page.build(tabs)
Page.build (DatasetDetailPage.cpp:33)
对每个 TabSpec：makeDetailView(spec.kind, ...) 造视图 → 组装页签
Panel.onTabReady (DatasetDetailPanel.cpp:61) ← tabReady
page.setTabPayload(i, payload) (DatasetDetailPage.cpp:92)
→ views_[i]->setPayload(payload) ← 视图自解包 payload 渲染
```
懒加载 / 分页是**反向**信号（页 → 面板 → 控制器）：
- **lazy 页签**首次点开 → `Page::tabNeeded` → `Panel::tabNeeded` → `detailCtrl.loadTab`（main.cpp:1522）。
- **paginated 页签**翻页 → `DataTableView::pageRequested` → `Page::tabPageNeeded` → `Panel::tabPageNeeded` → `detailCtrl.loadTabPaged`（main.cpp:1525）。
---
## 2. 五个核心抽象（必须先理解）
| 抽象 | 定义处 | 作用 |
|---|---|---|
| **`ViewKind`**（枚举） | `src/controller/DatasetDetailTab.hpp:10` | 视图渲染种类全集：`Scatter / FilledContour / Bar / LineProfile / PolylineMap / Table / WebMap` |
| **`TabSpec`** | `src/controller/DatasetDetailTab.hpp:13` | 页签描述符 `{QString title; ViewKind kind; QString loaderKey; bool lazy; bool paginated;}` |
| **`IDatasetChartStrategy`** + **`ChartStrategyRegistry`** | `src/controller/IDatasetChartStrategy.hpp` | 策略：`ddCode()` + `tabs()`；注册表按 `ddCode` 索引策略 |
| **`IDetailView`** | `src/app/panels/chart/IDetailView.hpp` | 视图统一接口：`QWidget* widget()` + `void setPayload(const QVariant&)` |
| **Payload 结构体**（6 种）+ **`DetailLoad`/`ApiDetailLoad`** | `src/core/model/detail/DetailPayloads.hpp`、`src/data/api/DatasetLoadHandles.hpp` | 纯数据载荷（`QVariant` 类型擦除）+ 异步加载句柄 |
**关键契约**：
- **`ddCode`** = 分发主键（后端给每个 ds 带的类型码，如 `dd_inversion_data`）。列表把它存进 item 的 `kDsDdCodeRole`，双击时透传给 `openDataset`。
- **`loaderKey`** = 控制器与仓储之间的字符串契约（如 `"inversion.scatter"`）。控制器只认 `TabSpec.loaderKey`，仓储 `loadAsync` 按它分发到具体加载函数。
- **payload** 必须 `Q_DECLARE_METATYPE` + 用 `QVariant::fromValue(...)` 装、`qvariant_cast<T>(...)`（或 `.value<T>()`）解。
---
## 3. 现有 5 种 ds 类型对照表（照抄即模板）
| ddCode | 策略（`src/app/panels/chart/*Strategy.hpp`） | 页签：title / ViewKind / loaderKey / lazy / paginated | payload | 视图 |
|---|---|---|---|---|
| `dd_inversion_data` | `ErtInversionStrategy.hpp` | 原数据 / Scatter / `inversion.scatter` / 否 / 否；<br>网格数据 / FilledContour / `inversion.grid` / **lazy** / 否 | `ScatterPayload` / `ContourPayload` | RawDataChartView / GridDataChartView |
| `dd_ert_measurement_data` | `MeasurementStrategy.hpp` | 散点 / Scatter / `ert_measurement.scatter`；列表 / Table / `ert_measurement.rows` | `ScatterPayload` / `TablePayload` | RawDataChartView / DataTableView |
| `dd_ert_measurement_gr_data` | `GrMeasurementStrategy.hpp` | 柱状 / Bar / `gr.bar`；列表 / Table / `gr.rows` | `BarPayload` / `TablePayload` | BarChartView / DataTableView |
| `dd_trajectory_data` | `TrajectoryStrategy.hpp` | 列表 / Table / `traj.rows`；高程 / LineProfile / `traj.elev`；地图 / WebMap / `traj.map` | `TablePayload` / `LinePayload` / `MapPayload` | DataTableView / LineChartView / TrajectoryMapView |
| `dd_grid` | `GridStrategy.hpp` | 列表 / Table / `grid.rows` / 否 / **paginated** | `TablePayload`（分页） | DataTableView |
注册处（**唯一**集中点）：`src/app/main.cpp:2378-2383`
```cpp
geopro::controller::ChartStrategyRegistry chartRegistry;
chartRegistry.add(std::make_unique<geopro::app::ErtInversionStrategy>());
chartRegistry.add(std::make_unique<geopro::app::MeasurementStrategy>());
// ... 共 5 个
geopro::controller::DatasetDetailController detailCtrl(datasetRepo, chartRegistry); // main.cpp:2384
```
---
## 4. 分层职责与关键文件（按数据流顺序）
1. **列表层** —— `QTreeWidget`（`DatasetListPanel::populateDatasetList`，`src/app/panels/DatasetListPanel.cpp:33`）。**通用、与类型无关**：从后端 ds 列表（`std::vector<data::DsRow>`）填树，每行把 `ddCode` 等写进 data role。role 常量定义在 `src/app/panels/DatasetListPanel.hpp:16-26`：
`kDsIdRole=0x0100` / `kDsDdCodeRole=0x0104` / `kDsNameRole=0x0105` / `kDsTmObjectIdRole=0x0108`。
**两个详情入口**（都按 `kDsDdCodeRole` 路由）：
- 左下数据列表双击 → `main.cpp:1501-1510` 直接 `detailCtrl.openDataset(dsId, ddCode, dsName, tmObjectId)`；
- 数据列分类区双击 → `CategorySection::detailRequested(dsId, ddCode, name)`（`src/app/panels/columns/CategorySection.cpp:124`）→ `CategoryAnalysisTab`（`columns/CategoryAnalysisTab.cpp:50`）→ `buildWorkbench` 接 `openDataset`（`main.cpp:1967`）。⚠️ 此入口只带 dsId/ddCode/name、**不带 tmObjectId**（白化模板列表可能为空——新类型若依赖 tmObjectId 需留意）。
→ **新增类型通常【不用动列表】**：只要后端把新 ds 带它的 `ddCode` 返回，它就会出现在树里、双击即按 `ddCode` 路由到你的策略。
2. **编排层** —— `DatasetDetailController`（`src/controller/DatasetDetailController.cpp`）：`openDataset:21` / `loadTab:37` / `loadTabPaged:41` / `loadTabImpl:46`。只依赖 `IAsyncDatasetRepository` + `ChartStrategyRegistry`，**不认识任何具体类型**。
3. **策略层** —— `src/app/panels/chart/*Strategy.hpp`（每个 ~15 行）。**新增类型主要在这里加一个文件**。
4. **数据层** —— `src/data/api/ApiDatasetRepository.cpp`：
- 分发 `loadAsync:160`（`if (loaderKey == "...") return makeXxx(dsId);`，未知 key 抛 `runtime_error`→ 控制器兜成 `loadFailed`）。
- 加载函数 `makeXxx:175-247`：`new ApiDetailLoad(xxxBatch(api_, dsId), [](r){ return QVariant::fromValue(payload); })`。
- 批次 `xxxBatch:52-154`（匿名命名空间）：`new net::ApiBatch({api.getAsync(端点), api.postJsonAsync(端点, body)...}, &isFailure)`——**唯一端点定义处**。
- 解析器 `parseXxxParts`（本文件匿名 ns）或 `dto::parseXxx`（`src/data/dto/*Dto.cpp`）：`QList<ApiResponse>` → payload。
5. **视图层** —— 工厂 `src/app/panels/chart/DetailViewFactory.cpp:15`（`ViewKind` → `IDetailView`，并注入 cmdRepo/colorTplRepo/viewState/getter）；各视图 `RawDataChartView/GridDataChartView/DataTableView/BarChartView/LineChartView/TrajectoryMapView`。
6. **壳层** —— `DatasetDetailPage`（单 ds 多页签：`build:33`、`setTabPayload:92`、lazy 遮罩、分页冒泡）；`DatasetDetailPanel`（QTabWidget，每 ds 一页，路由控制器信号：`onDatasetOpened:38` / `onTabReady:61`）。
7. **接线** —— `main.cpp`：面板创建+注入 `1390-1395`；控制器↔面板信号 `1513-1531`；策略注册+控制器 `2378-2384`。
---
## 5. 扩展配方：新增一种 ds 类型的详情页
### 前置：先判断走 5A 还是 5B
- 你的页签能否**复用现有 `ViewKind`**（散点 / 等值面 / 表格 / 柱状 / 折线 / 地图）？
- **能** → 走 **5A**（最常见，多数"又一种表格/散点"属于此）。
- **不能**（要全新的图） → 走 **5B**（5A + 新视图）。
### 5A. 复用现有视图（4 步，全在已有文件里加）
**① 写策略** —— 新建 `src/app/panels/chart/FooStrategy.hpp`（照抄 `GridStrategy.hpp`）：
```cpp
#pragma once
#include <vector>
#include "IDatasetChartStrategy.hpp"
namespace geopro::app {
struct FooStrategy : controller::IDatasetChartStrategy {
std::string ddCode() const override { return "dd_foo"; } // ← 后端给的类型码
std::vector<controller::TabSpec> tabs() const override {
return {
{QStringLiteral("列表"), controller::ViewKind::Table,
QStringLiteral("foo.rows"), /*lazy*/ false, /*paginated*/ false},
// 慢的页签设 lazy=true；服务端分页设 paginated=true（视图须是 DataTableView）
};
}
};
} // namespace geopro::app
```
**② 注册策略** —— `src/app/main.cpp:2383` 后加一行：
```cpp
chartRegistry.add(std::make_unique<geopro::app::FooStrategy>());
```
并在 main.cpp 顶部 include `panels/chart/FooStrategy.hpp`。
**③ 加 loaderKey 分发 + 加载函数** —— `src/data/api/ApiDatasetRepository.cpp`：
- 分发表 `loadAsync`（:171 后）：`if (loaderKey == "foo.rows") return makeFooRows(dsId);`
- 批次（匿名 ns，:154 附近）：
```cpp
net::ApiBatch* fooRowsBatch(net::ApiClient& api, const std::string& dsId) {
QList<net::IApiCall*> calls{
api.getAsync(QStringLiteral("/business/dd/foo/rows?dsObjectId=%1").arg(enc(dsId))),
};
return new net::ApiBatch(calls, &isFailure);
}
```
- 加载函数（:247 附近）：
```cpp
DetailLoad* ApiDatasetRepository::makeFooRows(const std::string& dsId) {
return new ApiDetailLoad(fooRowsBatch(api_, dsId), [](const QList<net::ApiResponse>& r) {
return QVariant::fromValue(dto::parseFooTable(r[0].data)); // → 复用的 payload（如 TablePayload）
});
}
```
- 在 `src/data/api/ApiDatasetRepository.hpp` 声明 `makeFooRows`。
**④ 写解析器** —— `src/data/dto/FooDto.{hpp,cpp}`（照抄 `MeasurementDto`/`GridDto`）：`parseFooTable(const QJsonObject&) → core::TablePayload`。新增 .cpp 记得加进 `src/data/CMakeLists.txt`（或对应子目录的 CMakeLists）。
> 复用视图时**视图层、工厂、壳层、控制器、列表全不动**。
### 5B. 需要全新视图（在 5A 之上多 5 步）
**① 加 ViewKind** —— `src/controller/DatasetDetailTab.hpp:10` 枚举追加 `Foo`。
**② 加 payload** —— `src/core/model/detail/DetailPayloads.hpp`：定义 `struct FooPayload {...};`，文件末尾加 `Q_DECLARE_METATYPE(geopro::core::FooPayload)`。
**③ 写视图** —— `src/app/panels/chart/FooChartView.{hpp,cpp}`，实现 `IDetailView`：
```cpp
class FooChartView : public QWidget, public IDetailView {
public:
QWidget* widget() override { return this; }
void setPayload(const QVariant& v) override {
const auto p = v.value<geopro::core::FooPayload>(); // 解包
/* 用 p 渲染（QwtPlot / ECharts-via-QWebEngine / 自绘） */
}
};
```
**④ 加工厂分支** —— `src/app/panels/chart/DetailViewFactory.cpp:22` 的 `switch` 里加 `case controller::ViewKind::Foo: return std::unique_ptr<IDetailView>(new FooChartView(parent));`（需注入仓储就照 Scatter/Table 分支注入）。
**⑤ 注册 .cpp** —— `src/app/CMakeLists.txt` 加 `FooChartView.cpp`。
然后照 **5A 的 ①②③④** 接策略/loaderKey/加载/解析。
---
## 6. 关键约定与坑（务必知道）
- **优雅降级**：`ddCode` 未注册策略 → 控制器 `emit loadFailed "暂不支持该数据类型的预览"`（`DatasetDetailController.cpp:26`）。所以"详情打不开"先查**策略是否注册**。
- **未知 loaderKey** → 仓储 `loadAsync` 抛 `std::runtime_error`，控制器 `loadTabImpl` 就地兜成 `loadFailed`（`:59-63`），**不会**让遮罩永久悬挂。策略 loaderKey 必须与仓储分发表**字符串完全一致**。
- **payload 类型擦除**：忘了 `Q_DECLARE_METATYPE` 或 `QVariant::fromValue`/`.value<T>()` 不匹配 → 视图拿到空 payload、静默不渲染。
- **lazy**：数据慢的页签设 `lazy=true`——开页**不**加载，首次点开才发 `tabNeeded`（`DatasetDetailPage.cpp:80`），其间盖 `LoadingOverlay`。
- **paginated**：服务端分页**只支持 `DataTableView`**（`Page::build:61` 用 `qobject_cast<DataTableView*>` 接 `pageRequested`）；`makeXxxRows` 要透传 `pageNo/pageSize`（见 `makeGridRows:238`）。
- **注入链**：视图所需仓储/getter（`cmdRepo`/`colorTplRepo`/`projectIdGetter`/`tmObjectId`/`viewState`）由工厂在造视图时注入（`DetailViewFactory.cpp:15-65`），而面板/页**必须在 `build()` 之前**完成注入（`DatasetDetailPanel.cpp:45-48`）。新视图若要新仓储，沿 `makeDetailView` 形参 → `Page::build` → `Panel::onDatasetOpened` → `main.cpp` 注入这条链透传。
- **跨视图色阶联动（可选）**：若新视图涉及色阶且要和 2D/3D 联动，注入 `DatasetViewState* viewState`（单一真源，按 dsId）；不涉及就忽略，传 nullptr 无副作用。详见 `src/controller/DatasetViewState.hpp`。
- **并发正确性**：同一页签重复加载用 **abort-and-replace** + **句柄身份比对丢弃迟到信号**（`DatasetDetailController.cpp:66,72`）；退出时 abort 全部在飞句柄（`~DatasetDetailController:17`）。你写 `makeXxx` 不用操心，沿用 `ApiDetailLoad` 即可。
---
## 7. 你需要触碰的文件清单（速查）
| 场景 | 必改文件 |
|---|---|
| **5A 复用视图** | ① `FooStrategy.hpp`(新) ② `main.cpp`(注册+include) ③ `ApiDatasetRepository.{cpp,hpp}`(分发+批次+make) ④ `FooDto.{hpp,cpp}`(新解析) + 对应 `CMakeLists.txt` |
| **5B 全新视图** | 5A 全部 + `DatasetDetailTab.hpp`(ViewKind) + `DetailPayloads.hpp`(payload) + `FooChartView.{hpp,cpp}`(新) + `DetailViewFactory.cpp`(分支) + `src/app/CMakeLists.txt` |
| **永远不用动** | `DatasetDetailController`、`DatasetDetailPanel/Page`、列表 `QTreeWidget`、`IDetailView`、`DetailLoad` |
---
## 8. 自测建议
- **策略层单测**：`FooStrategy{}.ddCode()` / `.tabs()` 返回符合预期（纯函数，易测）。
- **分发单测**：`ApiDatasetRepository::loadAsync("foo.rows", ...)` 不抛、返回非空 `DetailLoad`。
- **解析器单测**：喂一份真实后端 JSON 给 `dto::parseFooTable`，断言 payload 字段（参考现有 `tests/` 下 DTO 测试）。
- **联调**：构建 `build.bat app`，登录后在数据集树双击该类型 ds，看页签/数据/遮罩是否正常；打不开先看桌面日志 `%LOCALAPPDATA%/Geomative/Geopro3/logs/geopro_*.log` 里 `[detail] openDataset ...` 与 `[detail] 未注册策略/loadAsync 失败`。
---
_本文覆盖详情视图全链路；列表视图为通用容器（按后端 ds 列表 + ddCode 驱动），新增类型一般无需改它。如新类型在树中的归类/图标有特殊需求，再看列表填充处（`kDsDdCodeRole` 等 role 的写入点）。_

10
installer/build_installer.ps1
View File

@ -124,16 +124,6 @@ if (-not $SkipDeploy) {
} finally {
if (-not $adsPreexisted) { Remove-Item $adsTmp -Force -ErrorAction SilentlyContinue }
}
# 中文化：windeployqt --no-translations 不带翻译，单独拷 Qt 自带 zh_CN（QMessageBox/QFileDialog
# 等标准按钮中文化；app 启动按 exe 旁 translations\ 加载）。
$qtZh = Join-Path $QtBin '..\translations\qtbase_zh_CN.qm'
if (Test-Path $qtZh) {
$stageTr = Join-Path $StageDir 'translations'
New-Item -ItemType Directory -Force $stageTr | Out-Null
Copy-Item $qtZh $stageTr -Force
} else {
Warn "未找到 qtbase_zh_CN.qm（$qtZh）—部署版标准按钮可能仍为英文"
}
}
# --- 5.5 随包数据：本地样本演示数据 + PROJ 数据（exe 旁布局，运行时相对定位）-------

105
src/app/AnomalySaveDialog.cpp
View File

@ -4,28 +4,30 @@
#include "EmptyAwareComboBox.hpp"
#include <QFormLayout>
#include <QJsonArray>
#include <QJsonObject>
#include <QLabel>
#include <QLineEdit>
#include <QPainter>
#include <QPen>
#include <QPixmap>
#include <QPlainTextEdit>
#include <QPointer>
#include <algorithm>
#include "FormKit.hpp"
#include "Theme.hpp"
#include "repo/IDatasetCommandRepository.hpp"
namespace geopro::app {
namespace {
// 异常类型 mock 列表（label, id）。真实 exceptionType 端点只读、后续接。
struct TypeItem { const char* label; const char* id; };
const TypeItem kMockTypes[] = {
{"断层", "mock-fault"},
{"破碎带", "mock-fracture"},
{"含水构造", "mock-water"},
{"其它", "mock-other"},
};
} // namespace
AnomalySaveDialog::AnomalySaveDialog(const QString& screenshotPath, int shotW, int shotH,
geopro::data::IDatasetCommandRepository* cmdRepo,
const QString& projectId, int remarkSourceType,
QWidget* parent)
: QDialog(parent), cmdRepo_(cmdRepo), remarkSourceType_(remarkSourceType) {
: QDialog(parent) {
setWindowTitle(QStringLiteral("保存异常"));
setModal(true);
@ -40,17 +42,10 @@ AnomalySaveDialog::AnomalySaveDialog(const QString& screenshotPath, int shotW, i
form->addRow(formkit::editLabel(QStringLiteral("名称")), name_);
type_ = new EmptyAwareComboBox();
type_->setPlaceholderText(QStringLiteral("请选择异常类型")); // 空(如该形态平台无类型)时显灰占位+「暂无数据」
for (const auto& t : kMockTypes)
type_->addItem(QString::fromUtf8(t.label), QString::fromUtf8(t.id));
formkit::capField(type_);
form->addRow(formkit::editLabel(QStringLiteral("异常类型")), type_);
// 样式预览：选中类型的 legend 派生样式可视化(点=色球/线=线型/面=描边矩形)。
stylePreview_ = new QLabel(QStringLiteral("—"));
stylePreview_->setMinimumWidth(geopro::app::scaledPx(92));
form->addRow(formkit::editLabel(QStringLiteral("样式")), stylePreview_);
// 选中类型变化 → 拉其平台样式(legend)，使保存的异常按平台类型样式渲染 + 刷新预览。
connect(type_, qOverload<int>(&QComboBox::currentIndexChanged), this,
[this](int) { loadStyleForCurrent(); });
loadTypes(cmdRepo, projectId, remarkSourceType); // 异步拉平台异常类型填充（与平台一致）
remark_ = new QPlainTextEdit();
remark_->setFixedHeight(geopro::app::scaledPx(60));
@ -74,78 +69,6 @@ AnomalySaveDialog::AnomalySaveDialog(const QString& screenshotPath, int shotW, i
formkit::addDialogButtons(root, this);
}
void AnomalySaveDialog::loadTypes(geopro::data::IDatasetCommandRepository* cmdRepo,
const QString& projectId, int remarkSourceType) {
if (cmdRepo == nullptr || projectId.isEmpty()) return; // 无仓储/项目 → 下拉留空(空态提示)
QPointer<AnomalySaveDialog> self(this);
cmdRepo->listExceptionTypes(
projectId, QString::number(remarkSourceType),
[self](bool ok, QJsonArray list, const QString&) {
if (!self || !ok) return; // 对话框已关 / 失败 → 留空
for (const QJsonValue& v : list) {
const QJsonObject o = v.toObject();
// 平台响应项：{label:类型名, value:类型id}（实测扁平 data 数组，net 层已归一 value）。
self->type_->addItem(o.value(QStringLiteral("label")).toString(),
o.value(QStringLiteral("value")).toString());
}
self->loadStyleForCurrent(); // 首项自动选中 → 预取其样式
});
}
void AnomalySaveDialog::loadStyleForCurrent() {
if (cmdRepo_ == nullptr) return;
const QString typeId = type_->currentData().toString();
if (typeId.isEmpty()) return;
QPointer<AnomalySaveDialog> self(this);
cmdRepo_->getExceptionTypeDetail(typeId, [self](bool ok, QJsonObject detail, const QString&) {
if (!self || !ok) return;
const QJsonObject lg = detail.value(QStringLiteral("legend")).toObject();
// 按形态(1点/2线/3面)从 legend 派生样式：点用 pointColor；线/面用 polyline*。
if (self->remarkSourceType_ == 1) {
self->styleColor_ = lg.value(QStringLiteral("pointColor")).toString();
} else {
self->styleColor_ = lg.value(QStringLiteral("polylineColor")).toString();
self->styleWidth_ = lg.value(QStringLiteral("polylineWidth")).toDouble();
self->styleDashed_ =
lg.value(QStringLiteral("polylineShape")).toString().contains(QStringLiteral("dash"));
}
self->updateStylePreview();
});
}
void AnomalySaveDialog::updateStylePreview() {
if (stylePreview_ == nullptr) return;
const QColor col(styleColor_);
if (!col.isValid()) { // 未取到样式 → 占位
stylePreview_->setPixmap(QPixmap());
stylePreview_->setText(QStringLiteral("—"));
return;
}
const int w = geopro::app::scaledPx(92), h = geopro::app::scaledPx(22);
QPixmap pm(w, h);
pm.fill(Qt::transparent);
QPainter p(&pm);
p.setRenderHint(QPainter::Antialiasing, true);
QPen pen(col);
pen.setWidthF(std::clamp(styleWidth_ > 0.0 ? styleWidth_ : 2.0, 1.0, 4.0));
if (styleDashed_) pen.setStyle(Qt::DashLine);
if (remarkSourceType_ == 1) { // 点：实心色球
p.setPen(Qt::NoPen);
p.setBrush(col);
p.drawEllipse(QPointF(w / 2.0, h / 2.0), h * 0.3, h * 0.3);
} else if (remarkSourceType_ == 2) { // 线：按线宽/虚实画线
p.setPen(pen);
p.drawLine(QPointF(w * 0.1, h / 2.0), QPointF(w * 0.9, h / 2.0));
} else { // 面：描边矩形 + 淡填充
p.setPen(pen);
p.setBrush(QColor(col.red(), col.green(), col.blue(), 40));
p.drawRect(QRectF(w * 0.12, h * 0.22, w * 0.76, h * 0.56));
}
p.end();
stylePreview_->setText(QString());
stylePreview_->setPixmap(pm);
}
QString AnomalySaveDialog::anomalyName() const {
const QString n = name_->text().trimmed();
return n.isEmpty() ? QStringLiteral("异常") : n;

32
src/app/AnomalySaveDialog.hpp
View File

@ -7,52 +7,24 @@ class QComboBox;
class QPlainTextEdit;
class QLabel;
namespace geopro::data {
class IDatasetCommandRepository;
}
namespace geopro::app {
// 异常保存对话框（#4b，需求 R50）：名称 + 异常类型 + 备注 + 截图预览/大小。
// 异常类型从平台按标注形态(remarkSourceType)异步拉取，与平台保持一致。accept 后取 name/typeName/typeId/remark。
// 异常类型本期 mock 列表（真实 exceptionType 端点只读、后续可接）。accept 后取 name/typeName/typeId/remark。
class AnomalySaveDialog : public QDialog {
Q_OBJECT
public:
// screenshotPath：圈定结束截图的本地路径（为空则不显示预览）；w/h：截图像素尺寸（R50「确定截图大小」）。
// cmdRepo/projectId：异步拉取平台异常类型填充下拉（与平台一致）；remarkSourceType：标注形态 1点/2线/3面，
// 决定查询哪一类平台异常类型。cmdRepo 为空则下拉留空（空态由 EmptyAwareComboBox 提示）。
AnomalySaveDialog(const QString& screenshotPath, int shotW, int shotH,
geopro::data::IDatasetCommandRepository* cmdRepo, const QString& projectId,
int remarkSourceType, QWidget* parent = nullptr);
AnomalySaveDialog(const QString& screenshotPath, int shotW, int shotH, QWidget* parent = nullptr);
QString anomalyName() const;
QString typeName() const;
QString typeId() const;
QString remark() const;
// 选中类型的平台样式（从 legend 按形态派生，与平台一致）。styleColor 空 = 未取到，调用方用默认样式。
QString styleColor() const { return styleColor_; }
double styleWidth() const { return styleWidth_; }
bool styleDashed() const { return styleDashed_; }
private:
// 异步拉平台异常类型(label→显示, value→id)填充下拉；空/失败时下拉留空（EmptyAwareComboBox 提示）。
void loadTypes(geopro::data::IDatasetCommandRepository* cmdRepo, const QString& projectId,
int remarkSourceType);
// 拉当前选中类型的详情 legend → 按形态(点/线/面)派生 styleColor/Width/Dashed。
void loadStyleForCurrent();
// 据当前样式按形态画预览(点=色球/线=线型/面=描边矩形)，画到 stylePreview_。
void updateStylePreview();
geopro::data::IDatasetCommandRepository* cmdRepo_ = nullptr;
int remarkSourceType_ = 3;
QString styleColor_; // legend 派生线/点色（空=未取到）
double styleWidth_ = 0.0; // legend.polylineWidth
bool styleDashed_ = false; // legend.polylineShape 含 "dash"
QLineEdit* name_ = nullptr;
QComboBox* type_ = nullptr;
QLabel* stylePreview_ = nullptr; // 选中类型样式预览(色块/线型)
QPlainTextEdit* remark_ = nullptr;
};

22
src/app/AxesSettingsPanel.cpp
View File

@ -48,7 +48,7 @@ AxesSettingsPanel::AxesSettingsPanel(QWidget* parent) : QFrame(parent) {
setFrameShape(QFrame::StyledPanel);
applyTokenizedStyleSheet(
this, QStringLiteral("QFrame{background:{{bg/panel}};border:1px solid {{border/default}};"
"border-radius:8px;}")); // radius/lg=8（规范§3.2 画布浮窗）
"border-radius:10px;}"));
setFixedWidth(320);
auto* v = new QVBoxLayout(this);
@ -63,12 +63,9 @@ AxesSettingsPanel::AxesSettingsPanel(QWidget* parent) : QFrame(parent) {
close->setFixedSize(24, 24);
close->setCursor(Qt::PointingHandCursor);
// 显式覆盖全局 QPushButton 的 padding(6px 14px)/border——否则 24×24 容不下 padding，× 被挤出不可见。
// 颜色走 token（避免深色模式失效）。
applyTokenizedStyleSheet(
close, QStringLiteral(
"QPushButton{border:none;background:transparent;padding:0;margin:0;font-size:16px;"
"color:{{text/secondary}};}"
"QPushButton:hover{color:{{accent/primary}};}"));
close->setStyleSheet(QStringLiteral(
"QPushButton{border:none;background:transparent;padding:0;margin:0;font-size:16px;color:#888;}"
"QPushButton:hover{color:#2f6fed;}"));
connect(close, &QPushButton::clicked, this, &AxesSettingsPanel::closed);
titleRow->addWidget(title);
titleRow->addStretch(1);
@ -103,8 +100,7 @@ AxesSettingsPanel::AxesSettingsPanel(QWidget* parent) : QFrame(parent) {
scaleSlider_->setSingleStep(1);
scaleSlider_->setPageStep(1); // 点击轨道按 1 步移动（默认 pageStep=10 → 点一下直接跳到 10 的 bug）
scaleLabel_ = new QLabel(QStringLiteral("1.0×"), this);
applyTokenizedStyleSheet(scaleLabel_,
QStringLiteral("border:none;color:{{text/secondary}};min-width:36px;"));
scaleLabel_->setStyleSheet(QStringLiteral("border:none;color:#888;min-width:36px;"));
connect(scaleSlider_, &QSlider::valueChanged, this,
[this](int v) { scaleLabel_->setText(QStringLiteral("%1.0×").arg(v)); });
scaleRow->addWidget(scaleSlider_, 1);
@ -115,7 +111,9 @@ AxesSettingsPanel::AxesSettingsPanel(QWidget* parent) : QFrame(parent) {
auto* btns = new QHBoxLayout();
auto* cancel = new QPushButton(QStringLiteral("取消"), this);
auto* apply = new QPushButton(QStringLiteral("应用"), this);
apply->setDefault(true); // 主按钮：走全局 QPushButton:default 样式(accent/primary,随主题)，不再硬编码蓝
apply->setStyleSheet(QStringLiteral(
"QPushButton{background:#2f6fed;color:white;border:none;border-radius:6px;padding:6px 18px;}"
"QPushButton:hover{background:#2a63d4;}"));
connect(cancel, &QPushButton::clicked, this, &AxesSettingsPanel::closed);
connect(apply, &QPushButton::clicked, this, [this] {
auto rd = [](const Row& r) {
@ -149,7 +147,7 @@ AxesSettingsPanel::Row AxesSettingsPanel::addAxisRow(QVBoxLayout* col, const QSt
auto* range = new QHBoxLayout();
auto* loCol = new QVBoxLayout();
auto* loLbl = new QLabel(QStringLiteral("最小值"), this);
applyTokenizedStyleSheet(loLbl, QStringLiteral("border:none;color:{{text/tertiary}};"));
loLbl->setStyleSheet(QStringLiteral("border:none;color:#888;"));
loCol->addWidget(loLbl);
r.lo = new QDoubleSpinBox(this);
r.lo->setRange(-1e6, 1e6);
@ -158,7 +156,7 @@ AxesSettingsPanel::Row AxesSettingsPanel::addAxisRow(QVBoxLayout* col, const QSt
range->addLayout(loCol);
auto* hiCol = new QVBoxLayout();
auto* hiLbl = new QLabel(QStringLiteral("最大值"), this);
applyTokenizedStyleSheet(hiLbl, QStringLiteral("border:none;color:{{text/tertiary}};"));
hiLbl->setStyleSheet(QStringLiteral("border:none;color:#888;"));
hiCol->addWidget(hiLbl);
r.hi = new QDoubleSpinBox(this);
r.hi->setRange(-1e6, 1e6);

2
src/app/CMakeLists.txt
View File

@ -41,7 +41,6 @@ add_executable(geopro_desktop WIN32
panels/DescriptionPanel.cpp
panels/QuillDelta.cpp
panels/chart/RawDataChartView.cpp
panels/chart/ColorScaleProperties.cpp
panels/chart/InversionFormDialog.cpp
panels/chart/ScatterDataOps.cpp
panels/chart/SaveAsDialog.cpp
@ -65,7 +64,6 @@ add_executable(geopro_desktop WIN32
panels/chart/BarChartView.cpp
panels/chart/LineChartView.cpp
panels/chart/TrajectoryMapView.cpp
panels/web/ProjectWebView.cpp
panels/chart/DetailViewFactory.cpp
resources/map/map.qrc
resources/keys.qrc

6
src/app/ColorGradientDialog.cpp
View File

@ -205,11 +205,11 @@ ColorGradientDialog::ColorGradientDialog(const std::vector<Stop>& init, double m
// ── 整体透明度滑块（0~1, step 0.01） ───────────────────────────────────
{
auto* opRow = new QHBoxLayout();
opRow->addWidget(new QLabel(QStringLiteral("不透明度：")));
opRow->addWidget(new QLabel(QStringLiteral("整体透明度：")));
opacitySlider_ = new QSlider(Qt::Horizontal, this);
opacitySlider_->setRange(0, 100);
opacitySlider_->setValue(static_cast<int>(opacity_ * 100 + 0.5));
opacityLabel_ = new QLabel(QString::number(opacity_ * 100, 'f', 0), this); // 0~100 显示
opacityLabel_ = new QLabel(QString::number(opacity_, 'f', 2), this);
opRow->addWidget(opacitySlider_, 1);
opRow->addWidget(opacityLabel_);
root->addLayout(opRow);
@ -247,7 +247,7 @@ ColorGradientDialog::ColorGradientDialog(const std::vector<Stop>& init, double m
[this](double) { onMinMaxChanged(); });
connect(opacitySlider_, &QSlider::valueChanged, this, [this](int v) {
opacity_ = v / 100.0;
opacityLabel_->setText(QString::number(v)); // 0~100 显示（内部仍存 0~1）
opacityLabel_->setText(QString::number(opacity_, 'f', 2));
});
// 配色方案：内置预设打底，再异步拉取后端 .clr 列表（若有 api）。

17
src/app/ColorScaleConfigDialog.cpp
View File

@ -112,7 +112,6 @@ ColorScaleConfigDialog::ColorScaleConfigDialog(const geopro::core::ColorScale& i
resize(560, 420);
// 用初始色阶的升序断点填模型；空色阶兜底成 vmin/vmax 两端蓝红。
globalOpacity_ = init.globalOpacity(); // 回显真实整体透明度（两级第二级），不再硬编码 1
for (const auto& [value, color] : init.stops()) rows_.push_back({value, color});
if (rows_.empty()) {
rows_.push_back({vmin_, geopro::core::Rgba{0, 0, 255, 255}});
@ -355,15 +354,15 @@ void ColorScaleConfigDialog::onColorScheme() {
std::vector<GradientEditWidget::Stop> seed;
for (const auto& r : rows_) seed.push_back({(r.value - lo) / span, r.color});
ColorGradientDialog dlg(seed, lo, hi, vmin_, vmax_, samples_, globalOpacity_, tplRepo_, projectId_,
this);
ColorGradientDialog dlg(seed, lo, hi, vmin_, vmax_, samples_, 1.0, tplRepo_, projectId_, this);
if (dlg.exec() != QDialog::Accepted) return;
const auto grad = dlg.stops();
if (grad.size() < 2) return;
globalOpacity_ = dlg.opacity(); // 两级第二级：整体透明度单独存，不烘焙进每色 alpha
const double opacity = dlg.opacity();
const unsigned char alpha = static_cast<unsigned char>(opacity * 255.0 + 0.5);
// 在新渐变上按各层级位置连续采样回填颜色（复刻 mapColors，含每色自有 alpha）。
// 在新渐变上按各层级位置连续采样回填颜色（复刻 mapColors + addAlphaToColor 整体透明度）。
auto sampleGrad = [&](double pos) -> geopro::core::Rgba {
if (pos <= grad.front().pos) return grad.front().color;
if (pos >= grad.back().pos) return grad.back().color;
@ -373,8 +372,11 @@ void ColorScaleConfigDialog::onColorScheme() {
const double t = (x1 > x0) ? (pos - x0) / (x1 - x0) : 0.0;
return lerp(grad[i].color, grad[i + 1].color, t);
};
// 只回填颜色（含每色自有 alpha），整体透明度单独存于 globalOpacity_、渲染时才相乘（两级）。
for (auto& r : rows_) r.color = sampleGrad((r.value - lo) / span);
for (auto& r : rows_) {
geopro::core::Rgba c = sampleGrad((r.value - lo) / span);
if (opacity < 1.0) c.a = alpha; // 整体透明度覆盖 alpha
r.color = c;
}
rebuildTable();
}
@ -557,7 +559,6 @@ void ColorScaleConfigDialog::onOpen() {
geopro::core::ColorScale ColorScaleConfigDialog::colorScale() const {
geopro::core::ColorScale cs;
for (const auto& row : rows_) cs.addStop(row.value, row.color); // 内部按 value 升序
cs.setGlobalOpacity(globalOpacity_); // 整体透明度独立带出（渲染时与每色 alpha 相乘）
return cs;
}

6
src/app/ColorScaleConfigDialog.hpp
View File

@ -44,11 +44,6 @@ public:
// 线形/标注配置（线形⚙ 编辑后；2D 消费，3D 忽略）。
ContourLineConfig lineConfig() const { return lineCfg_; }
// 层级方案透传字段（复刻原版 properties：保存色阶时一并写回，避免覆盖清空 web 设过的值）。
QString lvlSchemeType() const { return lvlSchemeType_; }
int logLinesCount() const { return logLinesCount_; }
int equalAreaLayerCount() const { return equalAreaLayerCount_; }
private:
struct Row {
double value;
@ -75,7 +70,6 @@ private:
QTableWidget* table_ = nullptr;
std::vector<Row> rows_; // 始终按 value 升序维护
double globalOpacity_ = 1.0; // 整体透明度（两级第二级，独立存储，不烘焙进 rows_ 的 alpha）
double vmin_ = 0.0;
double vmax_ = 0.0;
std::vector<double> samples_; // 数据原始标量（等积分层 + 直方图）

8
src/app/EmptyAwareComboBox.cpp
View File

@ -23,14 +23,12 @@ EmptyAwareComboBox::EmptyAwareComboBox(QWidget* parent) : QComboBox(parent) {
int EmptyAwareComboBox::realItemCount() const {
int n = 0;
auto* m = model();
for (int i = 0; i < count(); ++i) {
// 排除临时「暂无数据」占位项。
if (itemData(i, kEmptyHintRole).toBool()) continue;
// 排除不可选项（禁用 / NoItemFlags）。用 model()->flags() 正确取项标志——
// 原 itemData(i, UserRole-1) 不是 Qt 的 flags 角色，对正常项恒返回不可选 →
// realItemCount 恒 0 → 有真实项也误插「暂无数据」(用户实测:异常区下方多一条暂无数据)。
if (m && !(m->flags(m->index(i, modelColumn())) & Qt::ItemIsSelectable)) continue;
// 排除不可选项（禁用 / NoItemFlags），它们不构成「真实可选数据」。
if (!(itemData(i, Qt::UserRole - 1).value<Qt::ItemFlags>() & Qt::ItemIsSelectable))
continue;
++n;
}
return n;

8
src/app/FormKit.hpp
View File

@ -55,11 +55,9 @@ QVBoxLayout* dialogRoot(QDialog* dlg);
// 与「数据详情 / 属性面板」同款的卡片面。返回 QFrame；其 layout() 即 QVBoxLayout，向内 addSection/addLayout。
QFrame* formCard(QWidget* parent);
QVBoxLayout* cardBody(QFrame* card); // 取 formCard 的内层 QVBoxLayout（便捷器）
// 标准底部按钮栏：QDialogButtonBox(Ok|Cancel)，已接 accept/reject。
// 默认中文「确定/取消」(不依赖 Qt 翻译是否就位)；调用方可覆盖(如「生成/取消」)。
QDialogButtonBox* addDialogButtons(QVBoxLayout* root, QDialog* dlg,
const QString& okText = QStringLiteral("确定"),
const QString& cancelText = QStringLiteral("取消"));
// 标准底部按钮栏：QDialogButtonBox(Ok|Cancel)，已接 accept/reject；okText/cancelText 可定制文案。
QDialogButtonBox* addDialogButtons(QVBoxLayout* root, QDialog* dlg, const QString& okText = QString(),
const QString& cancelText = QString());
// ── 可编辑表单：§7.0 统一度量（DynamicFormEditor 与各参数对话框共用，单一真相）──────
QFormLayout* makeEditForm(); // 右对齐标签 + 标准行距/列距

186
src/app/SliceExport.cpp
View File

@ -1,27 +1,13 @@
#include "SliceExport.hpp"
#include <algorithm>
#include <cmath>
#include <fstream>
#include <QColor>
#include <QImage>
#include <QPainter>
#include <QPainterPath>
#include <QPainterPathStroker>
#include <QPointF>
#include <QPolygonF>
#include <QRect>
#include <vtkCamera.h>
#include <vtkDataArray.h>
#include <vtkImageData.h>
#include <vtkNew.h>
#include <vtkPNGWriter.h>
#include <vtkPointData.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkWindowToImageFilter.h>
namespace geopro::app {
@ -55,178 +41,6 @@ bool captureRenderWindowPng(vtkRenderWindow* win, const std::string& path, int&
return writer->GetErrorCode() == 0;
}
bool captureFramedRegionPng(vtkRenderWindow* win, const double regionBounds[6], double padFactor,
double minExtent, const std::string& path, int& outW, int& outH) {
outW = outH = 0;
if (win == nullptr || path.empty()) return false;
vtkRenderer* ren =
win->GetRenderers() ? win->GetRenderers()->GetFirstRenderer() : nullptr;
vtkCamera* cam = ren ? ren->GetActiveCamera() : nullptr;
if (ren == nullptr || cam == nullptr)
return captureRenderWindowPng(win, path, outW, outH); // 无渲染器 → 退回整窗
// 1) 区域包围盒：minExtent 兜底(点零体积/共面零厚度) → padFactor 以中心外扩留边距。
double b[6];
for (int i = 0; i < 3; ++i) {
const double lo = regionBounds[2 * i], hi = regionBounds[2 * i + 1];
const double c = 0.5 * (lo + hi);
double half = 0.5 * (hi - lo);
if (2.0 * half < minExtent) half = 0.5 * minExtent; // 退化轴兜底
half *= padFactor; // 外扩边距
b[2 * i] = c - half;
b[2 * i + 1] = c + half;
}
// 2) 存相机现场（ResetCamera 改 position/focalPoint/clipping/parallelScale）。
double pos[3], fp[3], up[3], clip[2];
cam->GetPosition(pos);
cam->GetFocalPoint(fp);
cam->GetViewUp(up);
cam->GetClippingRange(clip);
const double va = cam->GetViewAngle();
const double ps = cam->GetParallelScale();
// 3) 重构图：保持视角方向，仅推近/缩放框住外扩区域。
ren->ResetCamera(b);
// 4) 截图（后台缓冲 + 关交换 → 屏幕不闪）。
vtkNew<vtkWindowToImageFilter> w2i;
w2i->SetInput(win);
w2i->ReadFrontBufferOff();
w2i->Update();
if (auto* img = w2i->GetOutput()) {
int dims[3];
img->GetDimensions(dims);
outW = dims[0];
outH = dims[1];
}
vtkNew<vtkPNGWriter> writer;
writer->SetFileName(path.c_str());
writer->SetInputConnection(w2i->GetOutputPort());
writer->Write();
const bool ok = writer->GetErrorCode() == 0;
// 5) 还原相机 + 重绘回原视图。
cam->SetPosition(pos);
cam->SetFocalPoint(fp);
cam->SetViewUp(up);
cam->SetViewAngle(va);
cam->SetParallelScale(ps);
cam->SetClippingRange(clip);
win->Render();
return ok;
}
bool captureAnomalyShotFromSlice(vtkImageData* colorImg, const double o[3], const double p1[3],
const double p2[3],
const std::vector<std::array<double, 3>>& worldPts, int markType,
const std::string& outlineHex, const std::string& path, int& outW,
int& outH) {
outW = outH = 0;
if (colorImg == nullptr || worldPts.empty() || path.empty()) return false;
int dims[3];
colorImg->GetDimensions(dims);
const int nx = dims[0], ny = dims[1];
if (nx < 2 || ny < 2) return false;
// 平面两轴(image i↔e1=p1-o, j↔e2=p2-o)；世界点 → 归一(u,v) → 像素(QImage 顶左原点,需翻 j)。
const double e1[3] = {p1[0] - o[0], p1[1] - o[1], p1[2] - o[2]};
const double e2[3] = {p2[0] - o[0], p2[1] - o[1], p2[2] - o[2]};
const double L1 = e1[0] * e1[0] + e1[1] * e1[1] + e1[2] * e1[2];
const double L2 = e2[0] * e2[0] + e2[1] * e2[1] + e2[2] * e2[2];
if (L1 < 1e-12 || L2 < 1e-12) return false;
QPolygonF poly;
poly.reserve(static_cast<int>(worldPts.size()));
for (const auto& P : worldPts) {
const double d[3] = {P[0] - o[0], P[1] - o[1], P[2] - o[2]};
const double u = (d[0] * e1[0] + d[1] * e1[1] + d[2] * e1[2]) / L1;
const double v = (d[0] * e2[0] + d[1] * e2[1] + d[2] * e2[2]) / L2;
poly << QPointF(u * (nx - 1), (ny - 1) - v * (ny - 1)); // 翻 j 到 QImage 坐标
}
// 缓冲半径：异常包围盒对角的 15%，最小取图长边 4%（点/小异常也有可见外扩）。
const QRectF pb = poly.boundingRect();
const double diag = std::hypot(pb.width(), pb.height());
const double buffer = std::max(0.04 * std::max(nx, ny), 0.15 * diag);
// 按形态构 buffer 后的裁剪形状：点→圆、线→胶囊带、面→外扩多边形(填充 ∪ 描边)。
QPainterPath shape;
if (markType == 1 || poly.size() == 1) {
shape.addEllipse(poly.first(), buffer, buffer);
} else if (markType == 2) {
QPainterPath line;
line.moveTo(poly.first());
for (int i = 1; i < poly.size(); ++i) line.lineTo(poly[i]);
QPainterPathStroker st;
st.setWidth(2.0 * buffer);
st.setCapStyle(Qt::RoundCap);
st.setJoinStyle(Qt::RoundJoin);
shape = st.createStroke(line);
} else {
QPainterPath fill;
fill.addPolygon(poly);
fill.closeSubpath();
QPainterPath outline = fill;
QPainterPathStroker st;
st.setWidth(2.0 * buffer);
st.setJoinStyle(Qt::RoundJoin);
shape = fill.united(st.createStroke(outline)); // 向外扩 buffer
}
// 裁剪区 = 形状包围盒(夹到图内)。
const QRect crop = shape.boundingRect().toAlignedRect().intersected(QRect(0, 0, nx, ny));
if (crop.width() < 1 || crop.height() < 1) return false;
// 切片着色图(vtk, j=0 在底) → QImage(顶左原点，翻行)。RGBA 保留外区透明(消除血缘外蓝边)。
const int comps = colorImg->GetNumberOfScalarComponents();
const bool rgba = comps >= 4;
QImage src(nx, ny, rgba ? QImage::Format_RGBA8888 : QImage::Format_RGB888);
for (int j = 0; j < ny; ++j) {
uchar* row = src.scanLine(ny - 1 - j);
for (int i = 0; i < nx; ++i) {
const auto* px = static_cast<unsigned char*>(colorImg->GetScalarPointer(i, j, 0));
if (rgba) {
row[i * 4] = px[0];
row[i * 4 + 1] = px[1];
row[i * 4 + 2] = px[2];
row[i * 4 + 3] = px[3];
} else {
row[i * 3] = px[0];
row[i * 3 + 1] = px[1];
row[i * 3 + 2] = px[2];
}
}
}
// 输出：buffer 形状内贴剖面像素(外透明)，再描异常轮廓。
QImage out(crop.size(), QImage::Format_ARGB32);
out.fill(Qt::transparent);
QPainter pr(&out);
pr.setRenderHint(QPainter::Antialiasing, true);
pr.translate(-crop.topLeft());
pr.setClipPath(shape);
pr.drawImage(0, 0, src);
pr.setClipping(false);
QColor oc(QString::fromStdString(outlineHex));
if (!oc.isValid()) oc = QColor(255, 48, 48);
QPen pen(oc);
pen.setWidthF(2.0);
pr.setPen(pen);
pr.setBrush(Qt::NoBrush);
if (markType == 1 || poly.size() == 1)
pr.drawEllipse(poly.first(), 4.0, 4.0); // 点：小标记
else if (markType == 2)
pr.drawPolyline(poly);
else
pr.drawPolygon(poly);
pr.end();
if (!out.save(QString::fromStdString(path), "PNG")) return false;
outW = out.width();
outH = out.height();
return true;
}
bool exportSliceDat(vtkImageData* slice, const std::string& path) {
if (slice == nullptr || path.empty()) return false;
vtkDataArray* arr = slice->GetPointData() ? slice->GetPointData()->GetScalars() : nullptr;

22
src/app/SliceExport.hpp
View File

@ -1,7 +1,5 @@
#pragma once
#include <array>
#include <string>
#include <vector>
class vtkImageData;
class vtkRenderWindow;
@ -14,26 +12,6 @@ bool exportSliceImagePng(vtkImageData* colorImage, const std::string& path);
// 截整个渲染窗口为 PNG（异常标识截图，需求 R88）；成功返回 true，并填回截图像素宽高。
bool captureRenderWindowPng(vtkRenderWindow* win, const std::string& path, int& outW, int& outH);
// 「相机重构图」截图（方案A）：把相机临时重新取景到 regionBounds（圈定范围）外扩后的区域，
// 使异常框在画面中央带周边语境，再截图、还原相机。业界 frame/zoom-to-fit selection 范式。
// regionBounds: {xmin,xmax,ymin,ymax,zmin,zmax} 世界系圈定包围盒；
// padFactor: 以盒中心外扩的倍数（1.4≈异常占画面~70%）；
// minExtent: 退化兜底（点=零体积、线/面共面=某轴零厚度）时各轴的最小世界尺寸。
// 视角方向不变（仅推近/缩放）；屏幕无闪（后台缓冲+关交换）。失败回退整窗截图。
bool captureFramedRegionPng(vtkRenderWindow* win, const double regionBounds[6], double padFactor,
double minExtent, const std::string& path, int& outW, int& outH);
// 异常截图（正确做法）：**只从切片那张 2D 剖面彩图**上，按异常几何**向外缓冲(buffer)一圈后裁剪**输出。
// 业界范式 = GIS「几何缓冲 + 按掩膜裁剪栅格」：点→圆、线→胶囊带、面→外扩多边形；缓冲外透明。
// colorImg：selectedSliceColorImage() 的剖面 RGB 图；o/p1/p2：该切片平面三点(image i↔p1-o, j↔p2-o)；
// worldPts：异常顶点(世界系,落在该平面)；markType：1点/2线/3面；outlineHex：在裁图上描异常轮廓的颜色。
// 成功返回 true，填回输出像素宽高。失败(无图/几何退化)返回 false，调用方可回退。
bool captureAnomalyShotFromSlice(vtkImageData* colorImg, const double o[3], const double p1[3],
const double p2[3],
const std::vector<std::array<double, 3>>& worldPts, int markType,
const std::string& outlineHex, const std::string& path, int& outW,
int& outH);
// 把切片重采样 2D 标量影像写为 .dat 文本网格（行=j、列=i，空格分隔，每格取标量首分量）；成功返回 true。
bool exportSliceDat(vtkImageData* slice, const std::string& path);

16
src/app/TileBasemap.cpp
View File

@ -232,11 +232,9 @@ void TileBasemap::refineTile(int z, int x, int y, std::set<long long>& out, int&
const double cx = (sw.x + ne.x) * 0.5, cy = (sw.y + ne.y) * 0.5; // 瓦片中心(局部米)
const double g = std::max(std::abs(ne.x - sw.x), std::abs(ne.y - sw.y)); // 瓦片地面尺寸(米)
// 距离上限(按剖面范围动态)：以覆盖中心(相机焦点 cenX_,cenY_)为心，瓦片离它太远则不加载——
// 远裁剪面有界(剖面不被近裁剪面切)，也避免拉远无限铺。叶块本身可大于此距离(近端仍在范围内即保留)。
// 心改用焦点而非原点(0,0)：否则 frame 锚在别处数据(如深圳)时，看台湾数据全被剔除→底图空。
const double rx = cx - cenX_, ry = cy - cenY_;
if (std::sqrt(rx * rx + ry * ry) - g * 0.5 > maxTileDist_) return;
// 距离上限(按剖面范围动态)：数据中心在局部原点(0,0)；瓦片离它太远则不加载——远裁剪面有界
// (剖面不被近裁剪面切)，也避免拉远无限铺。叶块本身可大于此距离(其近端仍在范围内即保留)。
if (std::sqrt(cx * cx + cy * cy) - g * 0.5 > maxTileDist_) return;
// 该瓦片投影到屏幕的近似像素尺寸 > 阈值且未到最大层级 → 细分为 4 子块(近处更细)。
double screenPx;
@ -288,10 +286,6 @@ void TileBasemap::refresh() {
if (pl[0] * fp[0] + pl[1] * fp[1] + pl[2] * fp[2] + pl[3] < 0.0)
for (int k = 0; k < 4; ++k) pl[k] = -pl[k];
}
// 底图覆盖中心 = 相机焦点(用户正看处)的局部 XY，而非世界原点：frame 锚在首个数据集，看远处别处
// 数据时原点离视野很远会把全部瓦片距离剔除→底图空。焦点为心则底图随视野走(同 frame 仍与数据对齐)。
cenX_ = fp[0];
cenY_ = fp[1];
// 底图最大距离按当前剖面合并范围动态定(随勾选增删自动伸缩)；无数据用下限。
maxTileDist_ = kRangeFloor;
@ -300,10 +294,10 @@ void TileBasemap::refresh() {
if (r > 0.0) maxTileDist_ = std::clamp(r * kRangeFactor, kRangeFloor, kRangeCeil);
}
// 四叉树：从覆盖中心(相机焦点经纬)一圈粗根块出发，按屏幕误差细分 → 近细远粗、铺满视野，无盲区。
// 四叉树：从数据中心一圈粗根块出发，按屏幕误差细分 → 近细远粗、铺满视野，无单层级盲区。
desired_.clear();
int count = 0;
const auto c = frame_->toLatLon(cenX_, cenY_); // 覆盖中心 = 相机焦点(非世界原点)
const auto c = frame_->toLatLon(0.0, 0.0); // 数据中心
const geopro::render::TileXY root = geopro::render::lonLatToTile(c.lon, c.lat, kRootZoom);
for (int dy = -1; dy <= 1; ++dy)
for (int dx = -1; dx <= 1; ++dx)

4
src/app/TileBasemap.hpp
View File

@ -84,10 +84,6 @@ private:
int satMaxZoom_ = 18;
// 四叉树当前帧相机参数(refresh 写, refineTile 读)：相机位置 + 投影系数 + 视锥 6 面。
double camX_ = 0, camY_ = 0, camZ_ = 0;
// 底图覆盖中心(相机焦点的局部 XY)：四叉树根块取此处经纬、距离剔除以此为心。
// 关键——不能用世界原点(0,0)：frame 锚在首个数据集(如深圳)，看远处别处数据(如台湾,相距数百公里)时
// 原点离视野数百公里→全部瓦片被距离剔除→底图空。改用焦点→底图随视野走(瓦片与数据同 frame 仍对齐)。
double cenX_ = 0, cenY_ = 0;
double projK_ = 1.0;
bool projParallel_ = false;
double frustum_[24] = {0}; // 6 个视锥平面(内法向)，AABB 全在某面外则剔除

89
src/app/TopBar.cpp
View File

@ -119,6 +119,48 @@ QPixmap renderAvatar(const QString& initials, int px, const QColor& bg, const QC
}
// ── 四个菜单（结构对齐需求；叶子项当前为静态占位，后续接真实页面）──
QMenu* buildViewMenu(QWidget* p)
{
auto* m = new QMenu(QStringLiteral("视图"), p);
m->addAction(QStringLiteral("分析视图"));
m->addAction(QStringLiteral("大屏视图"));
return m;
}
QMenu* buildProjectMenu(QWidget* p)
{
auto* m = new QMenu(QStringLiteral("项目管理"), p);
m->addAction(QStringLiteral("数据视图"));
auto* cfg = m->addMenu(QStringLiteral("项目配置"));
cfg->addAction(QStringLiteral("基本信息"));
cfg->addAction(QStringLiteral("项目结构"));
cfg->addAction(QStringLiteral("视图配置"));
m->addAction(QStringLiteral("数据管理"));
auto* biz = m->addMenu(QStringLiteral("业务管理"));
biz->addAction(QStringLiteral("异常管理"));
biz->addAction(QStringLiteral("异常体管理"));
auto* mon = m->addMenu(QStringLiteral("在线监测"));
mon->addAction(QStringLiteral("项目设备"));
mon->addAction(QStringLiteral("在线任务管理"));
auto* doc = m->addMenu(QStringLiteral("项目资料管理"));
doc->addAction(QStringLiteral("项目资料管理"));
doc->addAction(QStringLiteral("报告列表"));
auto* tools = m->addMenu(QStringLiteral("工具组件"));
tools->addAction(QStringLiteral("装置与脚本"));
tools->addAction(QStringLiteral("色阶配置"));
tools->addAction(QStringLiteral("异常类型管理"));
tools->addAction(QStringLiteral("模型管理"));
auto* exp = m->addMenu(QStringLiteral("批量导出"));
exp->addAction(QStringLiteral("文件导出"));
exp->addAction(QStringLiteral("报告导出"));
auto* alarm = m->addMenu(QStringLiteral("告警管理"));
alarm->addAction(QStringLiteral("设备告警"));
alarm->addAction(QStringLiteral("告警查询"));
m->addAction(QStringLiteral("自动任务"));
m->addAction(QStringLiteral("模板管理"));
return m;
}
QMenu* buildToolsMenu(QWidget* p)
{
auto* m = new QMenu(QStringLiteral("业务工具"), p);
@ -217,8 +259,8 @@ TopBar::TopBar(QWidget* parent) : QWidget(parent) {
// 一级菜单 → 工具条按钮（视图/项目管理/业务工具/设备），纯文字 + 下拉箭头。
// 复用原菜单构造器；菜单作为 popup 挂到按钮（按钮文字取菜单标题）。
lay->addWidget(makeMenuButton(this, buildViewMenu()));
lay->addWidget(makeMenuButton(this, buildProjectMenu()));
lay->addWidget(makeMenuButton(this, buildViewMenu(this)));
lay->addWidget(makeMenuButton(this, buildProjectMenu(this)));
lay->addWidget(makeMenuButton(this, buildToolsMenu(this)));
lay->addWidget(makeMenuButton(this, buildDeviceMenu(this)));
@ -290,49 +332,6 @@ TopBar::TopBar(QWidget* parent) : QWidget(parent) {
lay->addWidget(userRow_);
}
// 视图菜单。「分析视图」=默认工作台（emit analysisViewRequested，中央区从 web 整窗切回工作台）；
// 「大屏视图」当前为占位。
QMenu* TopBar::buildViewMenu() {
auto* m = new QMenu(QStringLiteral("视图"), this);
QObject::connect(m->addAction(QStringLiteral("分析视图")), &QAction::triggered, this,
[this] { emit analysisViewRequested(); });
m->addAction(QStringLiteral("大屏视图"));
return m;
}
// 项目管理菜单。仅保留需「直接嵌入」的 web 页（Excel「单个项目」页签第 10~21 行带嵌入地址者）：
// 在线监测 / 工具组件 / 批量导出 / 告警管理，点击 emit webPageRequested，由 main 独立整窗加载。
// 其余全部隐藏（数据视图、项目配置、数据管理、业务管理、项目资料管理、自动任务、模板管理 …）。
QMenu* TopBar::buildProjectMenu() {
auto* m = new QMenu(QStringLiteral("项目管理"), this);
// web 叶子项：携带 target 路径，点击发信号。
auto addWeb = [this](QMenu* parent, const QString& title, const QString& target) {
auto* a = parent->addAction(title);
QObject::connect(a, &QAction::triggered, this,
[this, title, target] { emit webPageRequested(title, target); });
};
auto* mon = m->addMenu(QStringLiteral("在线监测"));
addWeb(mon, QStringLiteral("项目设备"), QStringLiteral("/projectSpace/onlineMonitor/projectDevice"));
addWeb(mon, QStringLiteral("在线任务管理"), QStringLiteral("/projectSpace/onlineMonitor/onlineTask"));
auto* tools = m->addMenu(QStringLiteral("工具组件"));
addWeb(tools, QStringLiteral("装置与脚本"), QStringLiteral("/projectSpace/toolComponent/deviceScript"));
addWeb(tools, QStringLiteral("色阶配置"), QStringLiteral("/projectSpace/toolComponent/levelConfigure"));
addWeb(tools, QStringLiteral("异常类型管理"), QStringLiteral("/projectSpace/toolComponent/exceptionType"));
addWeb(tools, QStringLiteral("模型管理"), QStringLiteral("/projectSpace/toolComponent/modelManage"));
auto* exp = m->addMenu(QStringLiteral("批量导出"));
addWeb(exp, QStringLiteral("文件导出"), QStringLiteral("/projectSpace/bulkExport/fileExport"));
addWeb(exp, QStringLiteral("报告导出"), QStringLiteral("/projectSpace/bulkExport/templateExport"));
auto* alarm = m->addMenu(QStringLiteral("告警管理"));
addWeb(alarm, QStringLiteral("设备告警"), QStringLiteral("/projectSpace/alarmManage/deviceAlarm"));
addWeb(alarm, QStringLiteral("告警查询"), QStringLiteral("/projectSpace/alarmManage/alarmQuery"));
return m;
}
bool TopBar::eventFilter(QObject* obj, QEvent* event) {
if (obj == userRow_ && event->type() == QEvent::MouseButtonRelease) {
if (userMenu_)

6
src/app/TopBar.hpp
View File

@ -29,14 +29,8 @@ signals:
void allProjectsRequested(); // 点击"全部项目…"
void logoutRequested(); // 头像菜单「退出登录」
void settingsRequested(); // 点击齿轮图标 → 打开设置
// 项目管理菜单中「直接嵌入」的 web 页被点击：title=窗口标题，target=嵌入页 target 路径。
void webPageRequested(const QString& title, const QString& target);
void analysisViewRequested(); // 视图菜单「分析视图」→ 中央区切回默认工作台
private:
QMenu* buildViewMenu(); // 视图菜单（成员：「分析视图」需 emit 信号）
QMenu* buildProjectMenu(); // 项目管理菜单（成员：webview 叶子项需 emit 信号）
QToolButton* wsBtn_ = nullptr;
QToolButton* projBtn_ = nullptr;
QWidget* userRow_ = nullptr; // 用户区整块（头像+姓名/职务+箭头）

9
src/app/VolumeParamsDialog.cpp
View File

@ -31,7 +31,7 @@ namespace {
constexpr double kDefCellXY = 1.0;
constexpr double kDefCellZ = 0.5;
constexpr double kDefPower = 2.0;
constexpr double kDefMaxDist = 0.0; // 0=自动「覆盖测区」(全数据 IDW + 凸包足迹裁剪，对齐 Surfer)
constexpr double kDefMaxDist = 4.0;
constexpr int kRoleDsId = Qt::UserRole + 1; // 源树项存 dsId
constexpr int kRoleMountId = Qt::UserRole + 1; // 生成位置树项存 id
constexpr int kRoleMountConfType = Qt::UserRole + 2; // 生成位置树项存 confType
@ -187,14 +187,11 @@ VolumeParamsDialog::VolumeParamsDialog(const QVector<VolumeSourceItem>& sources,
cellXY_ = makeSpin(kDefCellXY, 0.01, 1000.0, 0.5, 2);
cellZ_ = makeSpin(kDefCellZ, 0.01, 1000.0, 0.5, 2);
power_ = makeSpin(kDefPower, 0.5, 6.0, 0.5, 1);
maxDist_ = makeSpin(kDefMaxDist, 0.0, 10000.0, 1.0, 2);
// maxDist=0（=最小值）→ 显示「自动」：全数据 IDW + 凸包足迹裁剪填满测区（对齐客户 Surfer）；
// >0 → 局部 IDW 半径（剖面附近清晰、跨大空隙可能填不满）。
maxDist_->setSpecialValueText(QStringLiteral("自动 (覆盖测区)"));
maxDist_ = makeSpin(kDefMaxDist, 0.1, 10000.0, 1.0, 2);
form2->addRow(formkit::editLabel(QStringLiteral("水平间距 (米)")), cellXY_);
form2->addRow(formkit::editLabel(QStringLiteral("竖向间距 (米)")), cellZ_);
form2->addRow(formkit::editLabel(QStringLiteral("IDW 幂次")), power_);
form2->addRow(formkit::editLabel(QStringLiteral("最大影响距离 (米, 0=自动)")), maxDist_);
form2->addRow(formkit::editLabel(QStringLiteral("最大影响距离 (米)")), maxDist_);
cardLay->addLayout(form2);
cols->addWidget(card, 1);

4
src/app/VolumePropertiesDialog.cpp
View File

@ -40,9 +40,7 @@ VolumePropertiesDialog::VolumePropertiesDialog(const QString& name, const Volume
.row(QStringLiteral("网格间距"), QStringLiteral("XY=%1 m Z=%2 m")
.arg(info.params.cellXY, 0, 'f', 2)
.arg(info.params.cellZ, 0, 'f', 2))
.row(QStringLiteral("超距"), info.params.maxDist > 0.0
? QStringLiteral("%1 m").arg(info.params.maxDist, 0, 'f', 2)
: QStringLiteral("自动 (覆盖测区)"))
.row(QStringLiteral("超距"), QStringLiteral("%1 m").arg(info.params.maxDist, 0, 'f', 2))
.row(QStringLiteral("色阶来源"),
info.params.colorScaleId.empty() ? QStringLiteral("首个源数据集")
: QString::fromStdString(info.params.colorScaleId));

221
src/app/VtkSceneView.cpp
View File

@ -11,17 +11,11 @@
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkBoundingBox.h>
#include <vtkCellPicker.h>
#include <vtkCubeAxesActor.h>
#include <vtkNew.h>
#include <vtkProp.h>
#include <vtkPiecewiseFunction.h>
#include <vtkColorTransferFunction.h>
#include <vtkGPUVolumeRayCastMapper.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include "CameraPreset.hpp"
#include "Scene.hpp"
@ -86,14 +80,12 @@ void VtkSceneView::removeProps(std::vector<vtkSmartPointer<vtkProp>>& props) {
}
bool VtkSceneView::computeDataBounds(double out[6]) const {
// 仅计「可见」prop：二维分析下 3D 体/帘面已隐藏，取景/坐标轴/底图范围都应只围当前可见维度，
// 否则二维取景被隐藏的远处 3D 体撑歪、坐标轴框错维度。
vtkBoundingBox bb;
for (const auto& kv : dsProps_)
for (const auto& p : kv.second)
if (p && p->GetVisibility()) { if (double* b = p->GetBounds()) bb.AddBounds(b); }
if (p) { if (double* b = p->GetBounds()) bb.AddBounds(b); }
for (const auto& p : miscProps_)
if (p && p->GetVisibility()) { if (double* b = p->GetBounds()) bb.AddBounds(b); }
if (p) { if (double* b = p->GetBounds()) bb.AddBounds(b); }
if (!bb.IsValid()) return false;
bb.GetBounds(out);
return true;
@ -110,8 +102,6 @@ void VtkSceneView::clear() {
// 只移除数据 prop（按 ds 跟踪）+ 杂项(地形/测线)+ 坐标轴；不动底图(TileBasemap 自管)→ 重建不丢图。
for (auto& kv : dsProps_) removeProps(kv.second);
dsProps_.clear();
mapLineDs_.clear(); // 2D 足迹维度记录随数据图元一并清(模式标志保留)
selectedMapLines_.clear(); // 选中态随图元清(actor 已销毁)；Z 偏移 mapLineZOffset_ 保留→重建后复位高度
removeProps(miscProps_);
clearAnomalies(); // 异常 actor 随清场一并移除
if (currentAxes_) {
@ -128,11 +118,6 @@ void VtkSceneView::clear() {
void VtkSceneView::setVerticalExaggeration(double ve) { verticalExaggeration_ = ve; }
void VtkSceneView::setVolumeOpacity(double /*maxOpacity*/) {
// 已退役：体不透明度统一由【色阶「不透明度」】控制（每单位 = 单色alpha × 色阶不透明度，100%=实心）。
// 旧工具条「透明度」滑块移除；保留空实现仅为满足接口（无调用方）。
}
void VtkSceneView::addSurveyLine(const geopro::core::Grid& grid) {
auto line = geopro::render::buildSurveyLine(grid, *frame_);
if (line) {
@ -164,7 +149,6 @@ void VtkSceneView::addCurtain(const std::string& dsId, const geopro::core::Grid&
auto curtain = geopro::render::buildCurtain(grid, cs, *frame_);
if (curtain) {
curtain->SetScale(1.0, 1.0, verticalExaggeration_); // 纵向夸张成墙
curtain->SetVisibility(analysisMode2D_ ? 0 : 1); // 帘面=3D内容：二维分析下隐藏
scene_.addActor(curtain);
dsProps_[dsId].push_back(curtain);
}
@ -172,29 +156,6 @@ void VtkSceneView::addCurtain(const std::string& dsId, const geopro::core::Grid&
void VtkSceneView::addVolume(const std::string& dsId, const geopro::data::VolumeGrid& vol,
const geopro::core::ColorScale& cs) {
// 首次建体时一次性探测 GPU 体绘制支持（此刻 widget 已显示、GL 上下文就绪）：不支持则全局回退
// SmartVolumeMapper(CPU)，避免无独显/软件 GL/远程桌面上整个体渲不出（空值仍靠传函透明）。
static bool gpuProbed = false;
if (!gpuProbed && renderWindow_) {
gpuProbed = true;
// 关键：addVolume 在普通 Qt 槽里跑，GL 上下文未必 current → 先 MakeCurrent，否则 IsRenderSupported
// 误判为不支持、把有独显的机器错误回退到 CPU（体变稠密/分层）。再给真实传函属性供其判定。
renderWindow_->MakeCurrent();
vtkNew<vtkGPUVolumeRayCastMapper> probe;
vtkNew<vtkVolumeProperty> prop;
vtkNew<vtkColorTransferFunction> ctf;
ctf->AddRGBPoint(0.0, 1, 1, 1);
ctf->AddRGBPoint(1.0, 1, 1, 1);
vtkNew<vtkPiecewiseFunction> otf;
otf->AddPoint(0.0, 0.0);
otf->AddPoint(1.0, 1.0);
prop->SetColor(ctf);
prop->SetScalarOpacity(otf);
const bool ok = probe->IsRenderSupported(renderWindow_, prop) != 0;
geopro::render::setVolumeGpuSupported(ok);
qInfo().noquote() << "[volrender] GPU volume ray cast supported=" << ok
<< (ok ? "(GPU+mask 干净白化)" : "(回退 CPU SmartVolumeMapper，边缘有细渗色)");
}
// 纵向夸张烤进 image 的 z 原点/间距（与帘面 SetScale 同倍，保证纵向一致）。
// 用暴露 image 的 buildVoxel 重载：保留 currentVolumeImage_ 供 P3 切片附着（几何含 VE）。
vtkSmartPointer<vtkImageData> image;
@ -206,7 +167,6 @@ void VtkSceneView::addVolume(const std::string& dsId, const geopro::data::Volume
// 体 actor 不参与拾取：切片选中靠点中切片平面（widget 交互/拾取）。否则点击落到体内部时
// picker 命中体、worldPoint 落体内 → nearestSlice 按平面距离选错切片（用户 ④ 串选）。
volume->PickableOff();
volume->SetVisibility(analysisMode2D_ ? 0 : 1); // 体=3D内容：二维分析下隐藏
scene_.addViewProp(volume);
dsProps_[dsId].push_back(volume);
currentVolumeImage_ = image;
@ -214,36 +174,11 @@ void VtkSceneView::addVolume(const std::string& dsId, const geopro::data::Volume
currentVmin_ = vol.vmin;
currentVmax_ = vol.vmax;
volumeOwnerDs_ = dsId;
volumes_[dsId] = VolumeRec{image, cs, vol.vmin, vol.vmax, volume}; // 多体并发：登记本体 image+actor
// G3 等值面：在值域高段(0.7)抽不透明实心异常体(参考图红块)。挂同一 dsProps_ → 随体一并移除。
const double isoVal = vol.vmin + 0.7 * (vol.vmax - vol.vmin);
auto iso = geopro::render::buildIsosurface(image, cs, vol.vmin, vol.vmax, isoVal);
if (iso) {
iso->PickableOff(); // 不参与拾取（同体 actor，避免串选）
iso->SetVisibility(analysisMode2D_ ? 0 : 1); // 3D 内容：二维分析下隐藏
scene_.addActor(iso);
dsProps_[dsId].push_back(iso);
}
volumes_[dsId] = VolumeRec{image, cs, vol.vmin, vol.vmax}; // 多体并发：登记本体 image
if (onVolumeChanged) onVolumeChanged();
}
}
bool VtkSceneView::updateVolumeColorInPlace(const std::string& dsId,
const geopro::core::ColorScale& cs) {
auto it = volumes_.find(dsId);
if (it == volumes_.end() || !it->second.volume) return false; // 未渲染 → 调用方回退 remove+add
// 仅换传函（image 不变）→ 切片基底保持有效、不被关闭。等值面随阈值色变化较小，暂不重抽。
geopro::render::updateVolumeColors(it->second.volume, cs, it->second.vmin, it->second.vmax);
it->second.cs = cs;
currentColorScale_ = cs;
// onVolumeChanged → InteractionManager.setVolumeImage(同 image, 新 cs)：检测 image 未变 → 不关切片，
// 仅更新体色阶并让该体下未保存切片跟随改色（见 InteractionManager::setVolumeImage）。
if (onVolumeChanged) onVolumeChanged();
if (renderWindow_) renderWindow_->Render();
return true;
}
void VtkSceneView::addMapLine(const std::string& dsId, const geopro::data::MapLine& line,
double worldZ) {
// 2D 足迹：经共享 frame 投影到世界 XY、Z=worldZ。按 dsId 跟踪（与帘面同 dsProps_ → removeDataset 复用）。
@ -252,12 +187,8 @@ void VtkSceneView::addMapLine(const std::string& dsId, const geopro::data::MapLi
anchorFrameIfNeeded(line.lat, line.lon, static_cast<int>(line.lat.size()));
auto actor = geopro::render::buildMapLine(line.lat, line.lon, worldZ, *frame_);
if (actor) {
actor->SetVisibility(analysisMode2D_ ? 1 : 0); // 足迹=2D内容：仅二维分析下显示
auto off = mapLineZOffset_.find(dsId); // B 期：复用持久 Z 偏移(全量重建后仍在该高度)
if (off != mapLineZOffset_.end()) actor->AddPosition(0.0, 0.0, off->second);
scene_.addActor(actor);
dsProps_[dsId].push_back(actor);
mapLineDs_.insert(dsId); // 记录此 ds 为 2D 足迹(切 tab 按维度翻可见)
}
}
@ -275,10 +206,6 @@ void VtkSceneView::removeDataset(const std::string& dsId) {
if (it == dsProps_.end()) return;
removeProps(it->second);
dsProps_.erase(it);
mapLineDs_.erase(dsId); // 若是 2D 足迹则同步去除维度记录
// 场景已无任何数据图元 → 复位重锚标志：下个数据(可能在别处)重新把 frame 锚到它，底图随之归位。
// 否则删到空再加远处新数据时，新数据按旧锚点投到偏远世界坐标、底图仍贴在旧位置 → 底图"消失"。
if (dsProps_.empty()) frameAnchoredToData_ = false;
const bool wasVolume = volumes_.erase(dsId) > 0;
if (volumeOwnerDs_ == dsId) { // 移除的是"当前体" → currentImage 回退到剩余某体，无则置空
if (!volumes_.empty()) {
@ -376,137 +303,6 @@ void VtkSceneView::fitView() {
if (onCameraChanged) onCameraChanged(); // 取景后 → 底图按新视锥重算覆盖(治首帧部分瓦片不出)
}
void VtkSceneView::setAnalysisMode2D(bool is2D) {
if (is2D == analysisMode2D_) return; // 幂等：同模式重复切不做事
analysisMode2D_ = is2D;
if (!is2D) clearMapLineSelection(); // 离开二维分析：清足迹选中(三维下不可拖 Z)；Z 偏移仍持久
// ① 按维度翻可见标志(不清空、不重建→切换瞬时)：2D 足迹↔3D 帘面/体；异常属 3D。
// 地形/测线(miscProps_)与底图(TileBasemap 自管)两边常驻、不动。
for (auto& kv : dsProps_) {
const bool is2dContent = mapLineDs_.count(kv.first) > 0;
const bool vis = is2D ? is2dContent : !is2dContent;
for (auto& p : kv.second)
if (p) p->SetVisibility(vis ? 1 : 0);
}
for (auto& kv : anomalyProps_)
if (kv.second) kv.second->SetVisibility(is2D ? 0 : 1); // 异常=3D内容
// ② 取景 + 坐标轴 + 渲染统一走 render()：朝向按 analysisMode2D_(已设)选近俯视/自由透视；
// ResetCamera 到"可见"数据包围盒(computeDataBounds 只计可见 prop)；rebuildAxes 在二维下自移除；
// 末尾 Render + onCameraChanged(底图按新视锥重算)。不再用相机快照(陈旧易错)，每次按可见内容取景。
render(/*is2D ViewMode=*/false, /*resetCamera=*/true);
}
// ── 二维分析改造 B 期：选中 2D 足迹沿高程 Z 拖动 ───────────────────────────────────
void VtkSceneView::applyMapLineSelectionVisual() {
for (auto& kv : dsProps_) {
if (!mapLineDs_.count(kv.first)) continue;
const bool sel = selectedMapLines_.count(kv.first) > 0;
for (auto& p : kv.second) {
auto* a = vtkActor::SafeDownCast(p);
if (!a) continue;
if (sel) { // 选中：黄高亮 + 加粗
a->GetProperty()->SetColor(1.0, 0.85, 0.2);
a->GetProperty()->SetLineWidth(6.0);
} else { // 未选：复原 buildMapLine 默认(橙 3.0)
a->GetProperty()->SetColor(0.95, 0.55, 0.10);
a->GetProperty()->SetLineWidth(3.0);
}
}
}
}
void VtkSceneView::clearMapLineSelection() {
if (selectedMapLines_.empty()) return;
selectedMapLines_.clear();
applyMapLineSelectionVisual();
if (renderWindow_) renderWindow_->Render();
if (onMapLineSelectionChanged) onMapLineSelectionChanged(); // VTK→列表：同步清空
}
std::vector<std::string> VtkSceneView::selectedMapLines() const {
return std::vector<std::string>(selectedMapLines_.begin(), selectedMapLines_.end());
}
void VtkSceneView::setSelectedMapLines(const std::vector<std::string>& dsIds) {
// 列表→VTK：按 dsId 设选中(仅已渲染足迹)，高亮+渲染；不回调 onMapLineSelectionChanged(防回环)。
selectedMapLines_.clear();
for (const auto& id : dsIds)
if (mapLineDs_.count(id)) selectedMapLines_.insert(id);
applyMapLineSelectionVisual();
if (renderWindow_) renderWindow_->Render();
}
bool VtkSceneView::pickMapLineAt(int screenX, int screenY, bool additive) {
auto* ren = scene_.renderer();
if (!ren) return false;
// 只在"可见足迹"中拾取(PickFromList)：避免地形/底图/隐藏的 3D 体抢命中。
vtkNew<vtkCellPicker> picker;
picker->SetTolerance(0.012);
picker->PickFromListOn();
bool any = false;
for (auto& kv : dsProps_) {
if (!mapLineDs_.count(kv.first)) continue;
for (auto& p : kv.second)
if (p && p->GetVisibility()) { picker->AddPickList(p); any = true; }
}
if (!any) return false; // 无可见足迹 → 不拦截(交由平移)
if (!picker->Pick(screenX, screenY, 0.0, ren)) {
if (!additive) clearMapLineSelection(); // 点空白(非多选)→ 取消选中
return false;
}
vtkProp* hit = picker->GetViewProp();
std::string hitDs;
for (auto& kv : dsProps_) {
if (!mapLineDs_.count(kv.first)) continue;
for (auto& p : kv.second)
if (p.Get() == hit) { hitDs = kv.first; break; }
if (!hitDs.empty()) break;
}
if (hitDs.empty()) {
if (!additive) clearMapLineSelection();
return false;
}
if (additive) { // Ctrl 多选：切换该足迹
if (selectedMapLines_.count(hitDs)) selectedMapLines_.erase(hitDs);
else selectedMapLines_.insert(hitDs);
} else if (!selectedMapLines_.count(hitDs)) { // 单击未选中的线 → 替换为它
selectedMapLines_.clear();
selectedMapLines_.insert(hitDs);
}
// 单击已选中的线(可能为多选之一)：保持当前选中集 → 起手即可整体拖动，不塌缩为单选。
applyMapLineSelectionVisual();
if (renderWindow_) renderWindow_->Render();
if (onMapLineSelectionChanged) onMapLineSelectionChanged(); // VTK→列表：同步选中
return !selectedMapLines_.empty(); // 有选中 → 交互样式进入 Z 拖动
}
void VtkSceneView::nudgeSelectedMapLinesZ(double worldDz) {
if (selectedMapLines_.empty() || worldDz == 0.0) return;
for (const auto& dsId : selectedMapLines_) {
mapLineZOffset_[dsId] += worldDz; // 持久累计(全量重建后 addMapLine 复用)
auto it = dsProps_.find(dsId);
if (it == dsProps_.end()) continue;
for (auto& p : it->second) {
auto* a = vtkActor::SafeDownCast(p);
if (a) a->AddPosition(0.0, 0.0, worldDz); // 仅改 Z，锁 XY
}
}
if (scene_.renderer()) scene_.renderer()->ResetCameraClippingRange(); // Z 抬升后防被裁剪面切
if (renderWindow_) renderWindow_->Render();
}
double VtkSceneView::selectedMapLineZ() const {
if (selectedMapLines_.empty()) return 0.0;
// 代表性 Z = 任一选中足迹 actor 的包围盒中心 Z(含 placement worldZ + 已累计偏移)。
auto it = dsProps_.find(*selectedMapLines_.begin());
if (it == dsProps_.end()) return 0.0;
for (const auto& p : it->second)
if (p) { if (double* b = p->GetBounds()) return 0.5 * (b[4] + b[5]); }
return 0.0;
}
void VtkSceneView::rebuildAxes() {
// 先移除上一次的坐标轴 prop：render 可能在一次 rebuild 内多次调用（末尾统一 render +
// 异步回灌 render），不先移除会叠加坐标轴（评审 HIGH）。移除后再算 bounds（仅数据图元）。
@ -514,9 +310,6 @@ void VtkSceneView::rebuildAxes() {
scene_.renderer()->RemoveViewProp(currentAxes_);
currentAxes_ = nullptr;
}
// 二维分析无立体坐标轴：任何渲染路径(全量/增量/切模式)走到此都不重建坐标轴，
// 保证切到二维分析后坐标轴消失、且后续增量渲染不把它带回来。
if (analysisMode2D_) return;
// 坐标轴随数据包围盒重建：仅按数据图元算 bounds(不含底图，否则被~公里级底图撑大)，
// 再造 vtkCubeAxesActor 入场。None 模式或无数据 → buildAxes 返回 nullptr，场景无坐标轴。
double bounds[6];
@ -547,18 +340,14 @@ void VtkSceneView::render(bool is2D, bool resetCamera) {
// 坐标轴仅三维视图显示（2D 俯视测线不需要立体坐标轴）。
if (!is2D) rebuildAxes();
// 相机预设（朝向）只在取景时应用——保留相机的重建(改放大系数)不重设朝向，否则也会跳视角。
// 朝向优先看二维分析模式(本期 A)：处二维分析→近俯视；否则按 ViewMode(旧 Map2D 正俯视/三维自由)。
// 这样 VE 改/项目切等全量重建在二维分析下仍保持近俯视，不跳回三维自由视角。
if (resetCamera) {
if (analysisMode2D_)
geopro::render::applyNearTop2D(scene_.renderer());
else if (is2D)
if (is2D)
geopro::render::applyTop2D(scene_.renderer());
else
geopro::render::applyFree3D(scene_.renderer());
double bounds[6];
if (computeDataBounds(bounds))
scene_.renderer()->ResetCamera(bounds); // 取景到"可见"数据(不含底图，否则数据缩成小点)
scene_.renderer()->ResetCamera(bounds); // 取景到数据(不含底图，否则数据缩成小点)
else
scene_.renderer()->ResetCamera();
}

39
src/app/VtkSceneView.hpp
View File

@ -2,7 +2,6 @@
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
@ -19,7 +18,6 @@ class vtkRenderer;
class vtkRenderWindow;
class vtkProp;
class vtkActor;
class vtkVolume;
namespace geopro::app {
@ -35,15 +33,12 @@ public:
void clear() override;
void setVerticalExaggeration(double ve) override;
void setVolumeOpacity(double maxOpacity) override; // 运行时调已渲染体 + 后续新体的最大不透明度
double zRefElev() const override { return zRefElev_; }
void addSurveyLine(const geopro::core::Grid& grid) override;
void addCurtain(const std::string& dsId, const geopro::core::Grid& grid,
const geopro::core::ColorScale& cs) override;
void addVolume(const std::string& dsId, const geopro::data::VolumeGrid& vol,
const geopro::core::ColorScale& cs) override;
bool updateVolumeColorInPlace(const std::string& dsId,
const geopro::core::ColorScale& cs) override;
void addMapLine(const std::string& dsId, const geopro::data::MapLine& line,
double worldZ) override;
void addTerrain(const geopro::data::TerrainPaths& paths) override;
@ -87,29 +82,6 @@ public:
// 相机程序化变化(取景/预设/缩放)后回调，供底图按新视锥重算覆盖(否则首帧部分瓦片要手动微动才出)。
std::function<void()> onCameraChanged;
// ── 二维分析改造 A 期：一场景两相机 ──────────────────────────────────────────
// 切「二维分析」(is2D=true)：相机锁近俯视、显 2D 足迹/隐 3D(体/帘面/异常)；切回反之。
// 只翻 actor 可见标志(不清空、不重建)→ 切换瞬时、零重插值。地形/底图常驻不动。
// 切片显隐 + 交互锁由 InteractionManager::setMode2D 配合(上层在同一处调两者)。
void setAnalysisMode2D(bool is2D);
bool isAnalysisMode2D() const { return analysisMode2D_; }
// ── 二维分析改造 B 期：选中 2D 足迹沿高程 Z 拖动 ───────────────────────────────
// 仅二维分析下用。pickMapLineAt：在屏幕(x,y)拾取足迹(只考虑可见足迹，不被地形/底图干扰)；命中则
// 选中(additive=Ctrl 多选切换，否则单选替换)并高亮，返回是否有选中(交互样式据此决定 Z 拖动/平移)。
// nudgeSelectedMapLinesZ：选中足迹世界 Z += worldDz(锁 XY)；偏移按 dsId 持久(切走再回/全量重建保留)。
// selectedMapLineZ：代表性当前世界 Z(高程读数浮层用)；无选中返回 0。
bool pickMapLineAt(int screenX, int screenY, bool additive);
void clearMapLineSelection();
bool hasMapLineSelection() const { return !selectedMapLines_.empty(); }
void nudgeSelectedMapLinesZ(double worldDz);
double selectedMapLineZ() const;
// 双向选择联动：列表↔VTK。selectedMapLines 取当前选中 dsId；setSelectedMapLines 由列表设置选中
// (高亮，不回调，避免环)。VTK 内拾取改变选中时触发 onMapLineSelectionChanged → 上层同步列表。
std::vector<std::string> selectedMapLines() const;
void setSelectedMapLines(const std::vector<std::string>& dsIds);
std::function<void()> onMapLineSelectionChanged;
private:
// 首个带经纬数据(剖面/足迹)到达时把共享 frame 重锚到其 lat/lon 包围盒中心：使数据落在世界原点近旁
// (否则样本默认原点可能离真实数据数百公里→图元在视锥外、移动视角也找不到)。已锚或无经纬则跳过。
@ -155,7 +127,6 @@ private:
vtkSmartPointer<vtkImageData> image;
geopro::core::ColorScale cs;
double vmin = 0.0, vmax = 0.0;
vtkSmartPointer<vtkVolume> volume; // 体 actor（运行时调不透明度：改其 property 的不透明度传递函数）
};
std::map<std::string, VolumeRec> volumes_;
@ -175,16 +146,6 @@ private:
std::vector<vtkSmartPointer<vtkProp>> miscProps_;
std::string volumeOwnerDs_; // 当前 currentVolumeImage_ 归属的 ds（其被移除时置空切片源）
std::map<std::string, vtkSmartPointer<vtkActor>> anomalyProps_; // 异常 id → 3D actor
// ── 二维分析改造 A 期 ──
// 哪些 dsProps_ 条目是 2D 足迹(addMapLine)：切 tab 按此区分维度翻可见(其余 dsProps_=帘面/体=3D)。
std::set<std::string> mapLineDs_;
bool analysisMode2D_ = false; // 当前是否处二维分析(默认三维：启动在「三维分析」tab)
// B 期：选中的足迹 dsId(Z 拖动目标) + 各足迹累计 Z 偏移(持久，全量重建后 addMapLine 复用)。
std::set<std::string> selectedMapLines_;
std::map<std::string, double> mapLineZOffset_;
void applyMapLineSelectionVisual(); // 选中足迹加粗变亮、其余复原(橙 3.0)
};
} // namespace geopro::app

19
src/app/VtkViewToolbar.cpp
View File

@ -1,11 +1,7 @@
#include "VtkViewToolbar.hpp"
#include <QFrame>
#include <QHBoxLayout>
#include <QLabel>
#include <QPoint>
#include <QSize>
#include <QSlider>
#include <QToolButton>
#include <QVBoxLayout>
@ -65,12 +61,11 @@ VtkViewToolbar::VtkViewToolbar(QWidget* parent) : QWidget(parent) {
{"下", ViewDir::Bottom}, {"左", ViewDir::Left}, {"右", ViewDir::Right}};
for (const V& v : views) {
const ViewDir d = v.d;
auto* b = textBtn(QString::fromUtf8(v.t));
connect(b, &QToolButton::clicked, this, [this, d] { emit viewRequested(d); });
viewDirButtons_.push_back(b); // 二维分析下禁用(会改朝向、破坏近俯视锁定)
connect(textBtn(QString::fromUtf8(v.t)), &QToolButton::clicked, this,
[this, d] { emit viewRequested(d); });
}
sep();
// ── 段3：缩放 / 复位 ──（三维体不透明度已移交色阶「不透明度」，旧「透」滑块退役移除）
// ── 段3：缩放 / 复位 ──
connect(iconBtn(Glyph::Plus, QStringLiteral("放大")), &QToolButton::clicked, this,
&VtkViewToolbar::zoomInRequested);
connect(iconBtn(Glyph::Minus, QStringLiteral("缩小")), &QToolButton::clicked, this,
@ -89,12 +84,4 @@ VtkViewToolbar::VtkViewToolbar(QWidget* parent) : QWidget(parent) {
adjustSize();
}
void VtkViewToolbar::setAnalysisMode2D(bool is2D) {
for (auto* b : viewDirButtons_) {
if (!b) continue;
b->setEnabled(!is2D);
b->setToolTip(is2D ? QStringLiteral("二维分析下不可用（已锁定近俯视）") : QString());
}
}
} // namespace geopro::app

13
src/app/VtkViewToolbar.hpp
View File

@ -1,12 +1,7 @@
#pragma once
#include <QWidget>
#include <vector>
#include "I3dSceneView.hpp" // geopro::controller::ViewDir
class QToolButton;
class QSlider;
class QLabel;
namespace geopro::app {
// VTK 画布竖排工具条（spec §9）：全局视图控制——设置(坐标轴)/前后上下左右/放大缩小复位。
@ -16,20 +11,12 @@ class VtkViewToolbar : public QWidget {
public:
explicit VtkViewToolbar(QWidget* parent = nullptr);
public slots:
// 二维分析激活时禁用不适用的工具：6 向快捷视图会改相机朝向→破坏二维近俯视锁定，故二维下禁用；
// 缩放/适配/坐标轴设置(含 VE)仍可用。切回三维恢复。
void setAnalysisMode2D(bool is2D);
signals:
void axesSettingsRequested(); // 设置 → 弹 AxesSettingsDialog
void viewRequested(geopro::controller::ViewDir dir); // 前/后/上/下/左/右
void zoomInRequested();
void zoomOutRequested();
void fitRequested(); // 复位=适配
private:
std::vector<QToolButton*> viewDirButtons_; // 6 向快捷视图按钮：二维分析下禁用
};
} // namespace geopro::app

3
src/app/login/LoginWindow.cpp
View File

@ -100,8 +100,7 @@ LoginWindow::LoginWindow(geopro::net::AuthService& auth, QWidget* parent)
"#brandSubtitle { color: rgba(255,255,255,0.82); font-size: %3px; }"
"#fieldLabel { color: {{text/secondary}}; font-size: %4px; font-weight: %5; }"
// 输入框已 Ela 化(ElaLineEdit 自绘 Fluent + 自动明暗)，不再写 QLineEdit QSS。
// 验证码容器固定白底：后端验证码图是浅底，白底贴合图边(两种主题皆然，故用白字面值)。
"#captchaImg { border: 1px solid {{border/strong}}; border-radius: 8px; background: #FFFFFF; }")
"#captchaImg { border: 1px solid {{border/strong}}; border-radius: 8px; background: {{bg/hover}}; }")
.arg(scaledPx(type::kDisplay))
.arg(type::kWeightBold)
.arg(scaledPx(type::kCaption))

432
src/app/main.cpp
View File

@ -50,12 +50,10 @@
#include <QListWidget>
#include <QListWidgetItem>
#include <QJsonObject>
#include <QLibraryInfo>
#include <QMenu>
#include <QMessageBox>
#include <QPoint>
#include <QSet>
#include <QTranslator>
#include <QToolButton>
#include <QKeySequence>
#include <QProcess>
@ -66,7 +64,6 @@
#include <QStringList>
#include <QTabWidget>
#include <QMainWindow>
#include <QStackedWidget>
#include <QStatusBar>
#include <QStyle>
#include <QSurfaceFormat>
@ -107,7 +104,6 @@
#include "SlicePropertiesDialog.hpp"
#include "SliceExport.hpp"
#include "ToastOverlay.hpp"
#include "panels/LoadingOverlay.hpp"
#include "TopBar.hpp"
#include "VolumeParamsDialog.hpp"
#include "VolumePropertiesDialog.hpp"
@ -115,9 +111,7 @@
#include "ProjectListDialog.hpp"
#include "ObjectFormDialog.hpp"
#include "ImportDatasetDialog.hpp"
#include "panels/web/ProjectWebView.hpp"
#include "WorkbenchNavController.hpp"
#include "DatasetViewState.hpp"
#include "VtkSceneController.hpp"
#include "VtkSceneView.hpp"
#include "api/NavRequest.hpp"
@ -156,7 +150,6 @@
#include "Scene.hpp"
#include "VoxelFromScatters.hpp"
#include "interact/InteractionManager.hpp"
#include "interact/PickInteractorStyle.hpp"
#include "interact/SlicePlaneMath.hpp"
#include "actors/AnomalyActor.hpp"
#include "actors/CurtainActor.hpp"
@ -181,8 +174,6 @@
#include <vtkCameraInterpolator.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkLookupTable.h>
#include <vtkObjectFactory.h>
#include <vtkOutputWindow.h>
#include <vtkProperty.h>
#include <vtkImageData.h>
#include <vtkDataArray.h>
@ -203,8 +194,6 @@ public:
{
host_->installEventFilter(this);
}
// overlay 定位/置顶后，再把这些控件 raise 到 overlay 之上（如工具条/提示常驻最上层）。
void setRaiseAfter(std::vector<QWidget*> w) { raiseAfter_ = std::move(w); }
void reposition()
{
overlay_->adjustSize();
@ -217,19 +206,9 @@ public:
// 偏移取非负：保证浮层矩形始终 ⊆ host 矩形（不跑到 host 外）。
const int dx = std::max(0, (h.width() - o.width()) / 2);
const int dy = std::max(0, (h.height() - o.height()) / 2);
if (overlay_->parentWidget() == host_) {
// overlay 是 host 的子级：本地坐标居中。须 raise 到 GL 之上才可见（QVTKOpenGLStereoWidget
// 的子控件 lower 会落到 GL 之下→不可见），再把工具条/提示 raise 回它之上→工具条永在最上层。
overlay_->move(dx, dy);
overlay_->raise();
for (QWidget* w : raiseAfter_)
if (w) w->raise();
} else {
// overlay 与 host 同级：换算到共同父坐标系并置顶。
overlay_->move(host_->x() + dx, host_->y() + dy);
overlay_->raise();
}
}
protected:
bool eventFilter(QObject* obj, QEvent* e) override
@ -242,7 +221,6 @@ protected:
private:
QWidget* overlay_;
QWidget* host_;
std::vector<QWidget*> raiseAfter_; // 定位后再 raise 到 overlay 之上的常驻控件（工具条/提示）
};
// 取 vector 中位数（用于由测线 lat/lon 推世界系原点）。空则返回 0。
@ -271,8 +249,7 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
geopro::data::IColorTemplateRepository& colorTplRepo,
geopro::data::IDatasetCommandRepository& cmdRepo,
geopro::controller::WorkbenchNavController& nav,
geopro::controller::DatasetDetailController& detailCtrl,
const QString& sessionToken)
geopro::controller::DatasetDetailController& detailCtrl)
{
// ── 世界系：启动取一次 grid1 的 lat/lon，用中位数作 GeoLocalFrame 原点 ──
// 全项目共享（shared_ptr 持有）：所有帘面用同一 frame 投影，保证多条测线空间配准。
@ -302,10 +279,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
auto* sceneCtrl = new geopro::controller::VtkSceneController(repo, *scene3dRepo, *sceneView,
vtkWidget);
sceneCtrl->setVerticalExaggeration(kVerticalExaggeration);
// 跨视图色阶真源（统一同步机制）：2D 详情/3D 帘面/体 共用一份按 dsId 的色阶；编辑→真源→各视图跟随。
// parent=vtkWidget → 随窗口销毁清理；须早于详情面板创建以便注入。
auto* viewState = new geopro::controller::DatasetViewState(vtkWidget);
sceneCtrl->setViewState(viewState);
// ── P3 切片交互编排（InteractionManager）─────────────────────────────────
// interactor 由 QVTK 在 setRenderWindow 后提供（renderWindow->GetInteractor()）。
@ -349,11 +322,7 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
ads::CDockManager::setAutoHideConfigFlags(ads::CDockManager::AutoHideFlags()); // 禁用自动隐藏
auto* dockManager = new ads::CDockManager(&window);
// 中央区用 QStackedWidget 承载：page0=工作台(dockManager，默认「分析视图」)，
// page1=项目管理 web 页（点项目管理菜单整窗加载，视图菜单「分析视图」切回 page0）。
auto* centralStack = new QStackedWidget(&window);
centralStack->addWidget(dockManager); // index 0：工作台
window.setCentralWidget(centralStack);
window.setCentralWidget(dockManager);
// 覆盖 ADS 自带分隔条样式：其 default.css 用 palette(dark) 把面板间分隔画成深灰粗线，
// 且设在管理器自身、选择器更具体（优先级高于全局主题）。在其后追加同选择器、按主题着色的极淡分隔覆盖。
@ -420,13 +389,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
split->addWidget(vtkWidget);
split->setStretchFactor(0, 0);
split->setStretchFactor(1, 1);
// 折叠/展开抽屉 → 同步 QSplitter 尺寸：收起时把抽屉栏压到按钮宽(18)、余量全给画布（否则残留空白区）；
// 展开恢复约 280。setSizes 为相对比例，splitter 按 min/max 钳制后铺满。
QObject::connect(drawer, &geopro::app::ColumnDrawer::collapsedChanged, split,
[split](bool collapsed) {
split->setSizes(collapsed ? QList<int>{18, 100000}
: QList<int>{280, 100000});
});
centerLayout->addWidget(viewHeader);
centerLayout->addWidget(split, 1);
// 工具条悬浮于画布左上角（overlay；左上固定，画布 resize 无需重定位）。
@ -434,78 +396,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
viewToolbar->move(12, 12);
viewToolbar->raise();
viewToolbar->show();
// 异常绘制操作提示：右上角 QLabel 浮层（VTK 内置字体不含中文字形，故用 Qt 渲染中文 + QSS 美化）。
// 深底 + accent 描边；不挡画布鼠标事件；绘制开始显示、结束/取消隐藏（见 onSliceContextMenuRequested）。
auto* anomalyHint = new QLabel(vtkWidget);
anomalyHint->setObjectName(QStringLiteral("anomalyHint"));
anomalyHint->setAttribute(Qt::WA_TransparentForMouseEvents);
// 方角 + 不透明深底：避免「圆角外三角区露白底」与「半透明在 GL 子控件上渲染成灰」两个坑。
geopro::app::applyTokenizedStyleSheet(
anomalyHint,
QStringLiteral("QLabel#anomalyHint{background:#0E1A2D;color:#E6ECF5;"
"border:1px solid {{accent/primary}};padding:8px 12px;}"));
anomalyHint->hide();
// 保存三维体等待蒙版（公共组件 LoadingOverlay）：挂 centerWidget → showOver 铺满整个「VTK视图」
// 子视图(表头+左树+画布)并 raise 到顶层；保存阶段显示，完成即撤。复用于其他需要整窗等待的场景。
auto* vtkLoading = new geopro::app::LoadingOverlay(centerWidget);
// ── 二维分析 B 期：高程 Z 拖动读数浮层（顶部居中）+ 足迹拾取/拖动回调注入交互样式 ──────────
// 拖动选中足迹时显示其当前世界 Z，松开隐藏；不挡画布鼠标。深底方角（同异常提示坑规避）。
auto* elevHint = new QLabel(vtkWidget);
elevHint->setObjectName(QStringLiteral("elevHint"));
elevHint->setAttribute(Qt::WA_TransparentForMouseEvents);
geopro::app::applyTokenizedStyleSheet(
elevHint, QStringLiteral("QLabel#elevHint{background:#0E1A2D;color:#E6ECF5;"
"border:1px solid {{accent/primary}};padding:6px 12px;}"));
elevHint->hide();
// 滚轮升降时读数浮层 1.2s 后自动隐藏（拖动则在松开时隐藏）。
auto* zHideTimer = new QTimer(vtkWidget);
zHideTimer->setSingleShot(true);
QObject::connect(zHideTimer, &QTimer::timeout, elevHint, [elevHint]() { elevHint->hide(); });
auto showZReadout = std::make_shared<std::function<void()>>([sceneView, elevHint, vtkWidget]() {
elevHint->setText(
QStringLiteral("高程 Z：%1 m").arg(sceneView->selectedMapLineZ(), 0, 'f', 1));
elevHint->adjustSize();
elevHint->move((vtkWidget->width() - elevHint->width()) / 2, 12); // 顶部居中
elevHint->show();
elevHint->raise();
});
if (auto* style = interactionMgr->pickStyle()) {
// 命中可见足迹→选中(Ctrl 多选)并返回是否进入 Z 拖动；未命中(返回 false)→交互样式回退平移。
style->onPick2D = [sceneView](int x, int y, bool additive) {
return sceneView->pickMapLineAt(x, y, additive);
};
// 拖动中：施加世界 Z 增量(仅改 Z)，并把选中足迹当前高程显示在顶部读数浮层。
style->onDrag2D = [sceneView, showZReadout](double worldDz) {
sceneView->nudgeSelectedMapLinesZ(worldDz);
(*showZReadout)();
};
style->onDrag2DEnd = [elevHint]() { elevHint->hide(); };
// 滚轮升降：有选中足迹则施加 Z 增量并显示读数(1.2s 后自动隐藏)，返回 true 消费滚轮；否则缩放。
style->onWheel2D = [sceneView, showZReadout, zHideTimer](double worldDz) {
if (!sceneView->hasMapLineSelection()) return false;
sceneView->nudgeSelectedMapLinesZ(worldDz);
(*showZReadout)();
zHideTimer->start(1200);
return true;
};
}
// 双向选择联动：列表行选中 ↔ VTK 足迹高亮。两向各自屏蔽回环(setSelectedMapLines 不回调、
// setSelectedDsIds 屏蔽信号)，故无需额外守卫。
QObject::connect(drawer->col2D(), &geopro::app::Column2DDataset::selectedDatasetsChanged, &window,
[sceneView](const QStringList& ids) {
std::vector<std::string> v;
for (const QString& s : ids) v.push_back(s.toStdString());
sceneView->setSelectedMapLines(v);
});
sceneView->onMapLineSelectionChanged = [sceneView, drawer]() {
QStringList ids;
for (const std::string& s : sceneView->selectedMapLines())
ids << QString::fromStdString(s);
drawer->col2D()->setSelectedDsIds(ids);
};
// 坐标轴设置抽屉面板：叠加 vtkWidget、工具条右侧滑出，默认隐藏（点设置 toggle）。
auto* axesPanel = new geopro::app::AxesSettingsPanel(vtkWidget);
axesPanel->hide();
@ -530,14 +420,9 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
}
for (const std::string& id : *checkedSliceIds) {
geopro::data::I3dSceneRepository::SliceSpec sp;
if (scene3dRepo->sliceSpec(id, sp) && interactionMgr->isVolumeRendered(sp.volumeDsId)) {
if (scene3dRepo->sliceSpec(id, sp) && interactionMgr->isVolumeRendered(sp.volumeDsId))
interactionMgr->showSavedSlice(id, sp.axis, sp.origin, sp.point1, sp.point2,
sp.volumeDsId);
// 已保存切片用自己的色阶（颜色+不透明度）；无则跟随三维体（兜底，showSavedSlice 已用体色阶）。
geopro::core::ColorScale scs;
if (scene3dRepo->sliceColorScale(id, scs))
interactionMgr->setSliceColorScaleByDsId(id, scs);
}
}
};
@ -618,30 +503,15 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
// 保存=按"未保存/已保存"分派(新建+链接+自动勾选 / 覆盖位姿)；导出统一为「导出▸图片·dat」；
// 正视/翻转/关闭=接现有交互(关闭已保存切片→onSliceClosed 取消列表勾选)；创建异常=占位(#4)。
interactionMgr->onSliceContextMenuRequested =
[&window, &cmdRepo, &nav, interactionMgr, sceneView, scene3dRepo, refreshAnalysis,
refreshAnomalies, drawer, anomalyDrawTool, renderWindowPtr, anomalyHint, vtkWidget]() {
[&window, interactionMgr, sceneView, scene3dRepo, refreshAnalysis, refreshAnomalies, drawer,
anomalyDrawTool, renderWindowPtr]() {
QMenu menu(&window);
QMenu* anomMenu = menu.addMenu(QStringLiteral("创建异常")); // → 点/线/面 子菜单
QAction* aAnoPoint = anomMenu->addAction(QStringLiteral("点"));
QAction* aAnoLine = anomMenu->addAction(QStringLiteral("线"));
QAction* aAnoFace = anomMenu->addAction(QStringLiteral("面"));
// 「保存」仅对未保存(临时)切片显示——已保存切片定稿锁定、不可再改/再存(用户要求)。
QAction* aSave = interactionMgr->selectedSliceDsId().empty()
? menu.addAction(QStringLiteral("保存"))
: nullptr;
QAction* aAnomaly = menu.addAction(QStringLiteral("创建异常"));
QAction* aSave = menu.addAction(QStringLiteral("保存"));
QMenu* expMenu = menu.addMenu(QStringLiteral("导出"));
QAction* aImg = expMenu->addAction(QStringLiteral("图片"));
QAction* aDat = expMenu->addAction(QStringLiteral("dat"));
menu.addSeparator();
// 「不透明度」放入视觉分组（正视图上方），仅对未保存切片显示（已保存切片改不透明度走列表右键
// 「色阶」）。颜色映射始终跟随三维体；这里只设总不透明度。
QAction *aOp100 = nullptr, *aOpPlus50 = nullptr, *aOpFollow = nullptr;
if (interactionMgr->selectedSliceDsId().empty()) {
QMenu* opMenu = menu.addMenu(QStringLiteral("不透明度"));
aOp100 = opMenu->addAction(QStringLiteral("100%"));
aOpPlus50 = opMenu->addAction(QStringLiteral("三维体+50%"));
aOpFollow = opMenu->addAction(QStringLiteral("跟随三维体"));
}
QAction* aFace = menu.addAction(QStringLiteral("正视图"));
QAction* aFlip = menu.addAction(QStringLiteral("视图翻转"));
QAction* aClose = menu.addAction(QStringLiteral("关闭"));
@ -651,61 +521,27 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
if (chosen == aFace) { interactionMgr->faceSelected(); return; }
if (chosen == aFlip) { interactionMgr->flipView(); return; }
if (chosen == aClose) { interactionMgr->closeSelected(); return; } // →onSliceClosed→取消列表勾选
if (aOp100 && chosen == aOp100) {
interactionMgr->setSelectedSliceOpacity(geopro::render::interact::SliceOpacityMode::Full);
vtkWidget->update();
return;
}
if (aOpPlus50 && chosen == aOpPlus50) {
interactionMgr->setSelectedSliceOpacity(
geopro::render::interact::SliceOpacityMode::VolumePlus50);
vtkWidget->update();
return;
}
if (aOpFollow && chosen == aOpFollow) {
interactionMgr->setSelectedSliceOpacity(
geopro::render::interact::SliceOpacityMode::FollowVolume);
vtkWidget->update();
return;
}
if (chosen == aAnoPoint || chosen == aAnoLine || chosen == aAnoFace) {
// 形态(1点/2线/3面)：同时决定绘制工具 mode、a.markType、对话框查平台类型的 remarkSourceType。
// core::AnomalyMarkType 与 remarkSourceType 同值(Point=1/Polyline=2/Polygon=3)，用一个 shape 贯通。
if (chosen == aAnomaly) {
// 在选中切片平面上启动圈定（左键逐点、右键/回车闭合、Esc 取消）。
namespace ri = geopro::render::interact;
using DM = ri::AnomalyDrawTool::DrawMode;
const int shape = (chosen == aAnoPoint) ? 1 : (chosen == aAnoLine) ? 2 : 3;
const DM mode =
(chosen == aAnoPoint) ? DM::Point : (chosen == aAnoLine) ? DM::Line : DM::Face;
int axis = 3;
ri::Vec3 o{}, p1{}, p2{};
if (!interactionMgr->selectedSlicePlane(axis, o, p1, p2)) return;
const ri::Vec3 e1{{p1[0] - o[0], p1[1] - o[1], p1[2] - o[2]}};
const ri::Vec3 e2{{p2[0] - o[0], p2[1] - o[1], p2[2] - o[2]}};
const ri::Vec3 normal = ri::normalize(ri::cross(e1, e2));
// 操作提示浮层（右上角）：按形态显示结束方式；绘制结束/取消隐藏。
anomalyHint->setText(
shape == 1 ? QStringLiteral("标注点\n左键单击落点即完成\nEsc 取消")
: shape == 2
? QStringLiteral("标注线\n左键逐点 · 双击结束\nBackspace 撤点 · Esc 取消")
: QStringLiteral("标注面\n左键逐点 · 点回起点闭合\nBackspace 撤点 · Esc 取消"));
anomalyHint->adjustSize();
anomalyHint->move(vtkWidget->width() - anomalyHint->width() - 12, 12); // 右上角
anomalyHint->show();
anomalyHint->raise();
// 多体并发：异常挂到"选中切片所属体"（非 currentVolume），无选中切片回退当前体。
std::string volId = interactionMgr->selectedSliceVolumeDsId();
if (volId.empty()) volId = sceneView->currentVolumeDsId();
// 异常归属（spec §8）：当前选中切片已保存（selectedSliceDsId 非空）→挂该切片；临时切片→挂体。
const std::string savedSliceId = interactionMgr->selectedSliceDsId();
anomalyDrawTool->start(
mode, o, normal,
[&window, &cmdRepo, &nav, interactionMgr, sceneView, scene3dRepo, renderWindowPtr,
refreshAnomalies, refreshAnalysis, volId, savedSliceId, normal, o, p1, p2, shape,
anomalyHint](const std::vector<ri::Vec3>& worldPts) {
anomalyHint->hide(); // 绘制结束 → 隐藏操作提示
o, normal,
[&window, sceneView, scene3dRepo, renderWindowPtr, refreshAnomalies, refreshAnalysis,
volId, savedSliceId, normal, o](const std::vector<ri::Vec3>& worldPts) {
// 草稿异常：先临时渲染（让用户在对话框前看到所画，且截图含异常）。
geopro::core::Anomaly a;
a.markType = static_cast<geopro::core::AnomalyMarkType>(shape);
a.markType = geopro::core::AnomalyMarkType::Polygon;
a.remarkSourceId =
geopro::core::resolveAnomalyMount(!savedSliceId.empty(), savedSliceId, volId);
a.lineColor = "#ff3030";
@ -718,40 +554,12 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
a.id = draftId;
sceneView->addAnomaly(a);
renderWindowPtr->Render();
// 截图（含异常）→ 临时文件。
const QString shot =
QDir(QDir::tempPath()).filePath(QStringLiteral("geopro_anomaly_shot.png"));
int sw = 0, sh = 0;
// 截图(正确做法)：只从切片那张 2D 剖面彩图、按异常几何向外缓冲一圈裁剪(GIS buffer+掩膜)。
std::vector<std::array<double, 3>> wpts;
wpts.reserve(worldPts.size());
for (const auto& p : worldPts) wpts.push_back({p[0], p[1], p[2]});
vtkSmartPointer<vtkImageData> sliceColor = interactionMgr->selectedSliceColorImage();
const double oo[3] = {o[0], o[1], o[2]};
const double pp1[3] = {p1[0], p1[1], p1[2]};
const double pp2[3] = {p2[0], p2[1], p2[2]};
bool shotOk = sliceColor && geopro::app::captureAnomalyShotFromSlice(
sliceColor, oo, pp1, pp2, wpts, shape,
a.lineColor, shot.toStdString(), sw, sh);
if (!shotOk) { // 回退：无切片图时退回相机框景(整窗外扩)，至少有图。
double rb[6] = {worldPts[0][0], worldPts[0][0], worldPts[0][1],
worldPts[0][1], worldPts[0][2], worldPts[0][2]};
for (const auto& p : worldPts) {
rb[0] = std::min(rb[0], p[0]); rb[1] = std::max(rb[1], p[0]);
rb[2] = std::min(rb[2], p[1]); rb[3] = std::max(rb[3], p[1]);
rb[4] = std::min(rb[4], p[2]); rb[5] = std::max(rb[5], p[2]);
}
auto vlen = [](double x, double y, double z) {
return std::sqrt(x * x + y * y + z * z);
};
const double e1 = vlen(p1[0] - o[0], p1[1] - o[1], p1[2] - o[2]);
const double e2 = vlen(p2[0] - o[0], p2[1] - o[1], p2[2] - o[2]);
const double minExt = 0.25 * std::min(e1, e2);
geopro::app::captureFramedRegionPng(renderWindowPtr, rb, 1.4, minExt,
shot.toStdString(), sw, sh);
}
// 异常类型按标注形态(shape=1点/2线/3面)拉对应平台类型，与平台一致。
geopro::app::AnomalySaveDialog dlg(shot, sw, sh, &cmdRepo,
nav.currentProjectId(), shape, &window);
geopro::app::captureRenderWindowPng(renderWindowPtr, shot.toStdString(), sw, sh);
geopro::app::AnomalySaveDialog dlg(shot, sw, sh, &window);
if (dlg.exec() != QDialog::Accepted) {
sceneView->removeAnomaly(draftId);
renderWindowPtr->Render();
@ -762,12 +570,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
a.typeName = dlg.typeName().toStdString();
a.exceptionTypeId = dlg.typeId().toStdString();
a.remark = dlg.remark().toStdString();
// 平台样式：选中异常类型的 legend 派生（与平台一致）；未取到则保留上面的默认样式。
if (!dlg.styleColor().isEmpty()) {
a.lineColor = dlg.styleColor().toStdString();
if (dlg.styleWidth() > 0.0) a.lineWidth = dlg.styleWidth();
a.dashed = dlg.styleDashed();
}
scene3dRepo->saveAnomaly(
a, shot.toStdString(),
[sceneView, renderWindowPtr, refreshAnomalies, refreshAnalysis,
@ -782,10 +584,10 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
QString::fromStdString(m));
});
},
[anomalyHint]() { anomalyHint->hide(); }); // 取消(Esc)→隐藏提示
[]() { /* onCancel：放弃，无需处理 */ });
return;
}
if (aSave != nullptr && chosen == aSave) {
if (chosen == aSave) {
int axis = 3;
geopro::render::interact::Vec3 o{}, p1{}, p2{};
if (!interactionMgr->selectedSlicePlane(axis, o, p1, p2)) return;
@ -819,14 +621,10 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
QLineEdit::Normal,
QStringLiteral("切片"), &ok);
if (!ok) return;
// 保存时快照切片自己的色阶对象：颜色继承当时三维体 + 不透明度取当前具体值（并入 globalOpacity）。
const geopro::core::ColorScale sliceCs =
interactionMgr->selectedSliceColorScaleSnapshot();
scene3dRepo->createSlice(
spec, name.isEmpty() ? std::string("切片") : name.toStdString(),
[interactionMgr, refreshAnalysis, drawer, scene3dRepo, sliceCs](std::string newId) {
[interactionMgr, refreshAnalysis, drawer](std::string newId) {
interactionMgr->tagSelectedSlice(newId); // 链接当前切片 → 新数据集（不重绘）
scene3dRepo->setSliceColorScale(newId, sliceCs); // 存切片独立色阶（mock）
refreshAnalysis(); // 新行进列表
// 新切片自动勾选 → 列表打勾 + 保持渲染（refreshAnalysis 已重建列表，故在其后勾选）。
if (auto* sec = drawer->analysisTab()->section("voxel"))
@ -878,7 +676,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
&geopro::controller::VtkSceneController::zoomOut);
QObject::connect(viewToolbar, &geopro::app::VtkViewToolbar::fitRequested, sceneCtrl,
&geopro::controller::VtkSceneController::fit);
// （三维体不透明度已移交色阶「不透明度」；旧工具条「透」滑块退役。）
// 设置（⚙）→ 工具条右侧 toggle 抽屉面板（非模态弹窗）。
QObject::connect(viewToolbar, &geopro::app::VtkViewToolbar::axesSettingsRequested, &window,
[axesPanel, viewToolbar]() {
@ -920,8 +717,8 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
});
// 段头「+新增三维体」：弹参数对话框 → 组装真实 VoxelGenerateRequest → createVolume(mock) → 刷新。
QObject::connect(analysisTab, &geopro::app::CategoryAnalysisTab::generateVolumeRequested, &window,
[&window, &nav, scene3dRepo, refreshAnalysis, lastSourceRows, lastStructNodes,
analysisTab, vtkLoading](const QString& /*dsTypeCode*/, const QStringList& sourceIds) {
[&window, &nav, scene3dRepo, refreshAnalysis, lastSourceRows,
lastStructNodes](const QString& /*dsTypeCode*/, const QStringList& sourceIds) {
if (sourceIds.isEmpty()) return;
// 源 ds（id,名称,结构归属）：名称/structParentId 从最近拉取的行查（缺则用 id）。
QVector<geopro::app::VolumeSourceItem> sources;
@ -957,47 +754,8 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
req.power = p.power;
req.maxDist = p.maxDist;
req.colorScaleId = p.colorScaleId;
// 保存(目前 mock，瞬时同步)：直接建体+入树，不弹等待蒙版——mock 没有耗时，蒙版
// 会 showOver 后立刻 hide 在渲染区一闪而过。等待蒙版只在「真有耗时的后端保存」
// 才有意义：接真实异步保存端点后，在那个调用外用 LoadingOverlay 包蒙版即可。
// 保存阶段：VTK 整体加等待蒙版(挂 centerWidget→盖整个 VTK 子视图)。singleShot 让
// 蒙版先绘出再干活，避免 mock 即时完成时蒙版根本没画出来。
vtkLoading->showOver(QStringLiteral("正在保存三维体…"));
QTimer::singleShot(0, &window, [=]() {
const std::string newId = scene3dRepo->createVolume(req); // 保存 + 注册(mock)
{
// refreshAnalysis 重建列表会让各段重发"勾选变化"→ 触发场景重算 → 已渲染
// 剖面被删了又加。保存时屏蔽 analysisTab 渲染信号 → 渲染区一动不动。
const QSignalBlocker block(analysisTab);
refreshAnalysis(); // 入三维体树（仅刷列表，不触发渲染）
}
vtkLoading->hide(); // 保存阶段结束 → 撤蒙版
const QString qid = QString::fromStdString(newId);
// 渲染阶段无蒙版：自动勾选新体 → 增量加体(剖面不动) + 标题前等待 spinner；
// 渲染完成由 volumeRendered 撤 spinner、失败由 loadFailed 兜底。
analysisTab->setItemChecked(qid, true);
analysisTab->setItemBusy(qid, true);
analysisTab->scrollItemToTop(qid); // 新三维体行尽量滚到分析栏顶部
});
});
// 任一数据集（剖面/体）异步加载开始 → 列表项复选框转等待 spinner；渲染完成 → 复原复选框。
// 覆盖非三维体：勾选剖面首次渲染较慢时也有等待反馈（用户反馈）。
QObject::connect(sceneCtrl, &geopro::controller::VtkSceneController::datasetLoading, analysisTab,
[analysisTab](const QString& dsId) { analysisTab->setItemBusy(dsId, true); });
QObject::connect(sceneCtrl, &geopro::controller::VtkSceneController::datasetRendered, analysisTab,
[analysisTab](const QString& dsId) { analysisTab->setItemBusy(dsId, false); });
// 根因修复：异步建体的渲染发生在后台线程触发的投递事件里，renderWindow->Render() 渲到离屏 FBO，
// 但 QVTKOpenGLStereoWidget 把 FBO「呈现到屏」绑定 Qt 的 paint；建体完成后 app 空闲、无后续 paint，
// FBO 渲好却没贴到屏 → 体偶发不可见(动鼠标产生 paint 才出来)。显式请求一次 Qt 重绘补上呈现步骤。
QObject::connect(sceneCtrl, &geopro::controller::VtkSceneController::volumeRendered, vtkWidget,
[vtkWidget](const QString&) { vtkWidget->update(); });
// 加载失败 → 兜底撤回所有 spinner（避免标题卡在等待态）。
QObject::connect(sceneCtrl, &geopro::controller::VtkSceneController::loadFailed, analysisTab,
[analysisTab, &window](const QString& msg) {
analysisTab->clearAllBusy();
// 明确提示而非静默：源数据加载失败(如后端 502)时用户能区分"后端没给数据"与"渲染问题"。
geopro::app::showToast(
&window, QStringLiteral("数据加载失败，未生成三维体：%1").arg(msg));
scene3dRepo->createVolume(req);
refreshAnalysis();
});
// 双击数据详情：dd_slice→切片属性；dd_voxel→三维体属性（同 colAnalysis 详情口径）。
QObject::connect(analysisTab, &geopro::app::CategoryAnalysisTab::detailRequested, &window,
@ -1025,20 +783,9 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
// 三维体段右键删除：切片→deleteSlice / 异常→deleteAnomaly，删后刷新树。
// 异常删除须同时 refreshAnomalies（重载异常 actor）——否则列表行没了但场景里异常仍渲染（技术债，已修）。
QObject::connect(analysisTab, &geopro::app::CategoryAnalysisTab::deleteDatasetRequested, &window,
[scene3dRepo, refreshAnalysis, refreshAnomalies, &window](const QString& dsId,
[scene3dRepo, refreshAnalysis, refreshAnomalies](const QString& dsId,
const QString& ddCode) {
const std::string id = dsId.toStdString();
// 删除前确认(不可撤销)：明确中文「删除/取消」按钮。
const QString what =
ddCode == QStringLiteral("dd_slice") ? QStringLiteral("切片")
: QStringLiteral("异常");
QMessageBox box(QMessageBox::Warning, QStringLiteral("删除%1").arg(what),
QStringLiteral("确定删除该%1吗？此操作不可撤销。").arg(what),
QMessageBox::NoButton, &window);
QPushButton* del = box.addButton(QStringLiteral("删除"), QMessageBox::AcceptRole);
box.addButton(QStringLiteral("取消"), QMessageBox::RejectRole);
box.exec();
if (box.clickedButton() != del) return; // 取消 → 不删
if (ddCode == QStringLiteral("dd_slice")) {
scene3dRepo->deleteSlice(
id, [refreshAnalysis]() { refreshAnalysis(); },
@ -1136,30 +883,8 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
// 色阶（三维体/切片）：复刻原版「色阶配置」对话框，确定后体素 + 其切片随新色阶重渲染。
// 仅对当前已渲染的三维体生效（切片色阶继承体色阶，经 InteractionManager 重建）。
QObject::connect(analysisTab, &geopro::app::CategoryAnalysisTab::colorScaleRequested, &window,
[&window, &colorTplRepo, &nav, sceneCtrl, sceneView, scene3dRepo,
interactionMgr](const QString& qid) {
[&window, &colorTplRepo, &nav, sceneCtrl, sceneView](const QString& qid) {
const std::string dsId = qid.toStdString();
// 已保存切片（dd_slice）→ 编辑切片自己的色阶（颜色+不透明度），不走三维体路径。
if (scene3dRepo->isSliceDataset(dsId)) {
geopro::core::ColorScale scs;
if (!scene3dRepo->sliceColorScale(dsId, scs)) {
QMessageBox::information(&window, QStringLiteral("色阶"),
QStringLiteral("该切片暂无独立色阶。"));
return;
}
const auto stops = scs.stopValues();
const double vmin = stops.empty() ? 0.0 : stops.front();
const double vmax = stops.empty() ? 1.0 : stops.back();
geopro::app::ColorScaleConfigDialog dlg(scs, vmin, vmax, {}, {},
&colorTplRepo,
nav.currentProjectId(), QString(),
&window);
if (dlg.exec() != QDialog::Accepted) return;
const auto newCs = dlg.colorScale();
scene3dRepo->setSliceColorScale(dsId, newCs); // 存切片独立色阶（mock）
interactionMgr->setSliceColorScaleByDsId(dsId, newCs); // 若在渲染则即时改色
return;
}
// 多体并发：编辑"该体"（任一已渲染体，不限当前体）的色阶。
const auto* vol = sceneView->volume(dsId);
if (!vol) {
@ -1207,35 +932,19 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
[sceneView, interactionMgr, renderWindowPtr](const QString& dsId,
const QString& ddCode) {
const std::string id = dsId.toStdString();
// 选中项决定高亮：异常↔切片互斥，选其它对象两者都清(否则切到别的对象后切片/异常仍高亮)。
if (ddCode == QStringLiteral("dd_anomaly")) {
if (ddCode == QStringLiteral("dd_anomaly"))
sceneView->setSelectedAnomaly(id);
interactionMgr->deselectSlice();
} else if (ddCode == QStringLiteral("dd_slice")) {
sceneView->setSelectedAnomaly(std::string{});
else if (ddCode == QStringLiteral("dd_slice"))
interactionMgr->selectSavedSlice(id); // 选中已渲染的该切片(高亮)
} else {
sceneView->setSelectedAnomaly(std::string{});
interactionMgr->deselectSlice();
}
renderWindowPtr->Render();
});
// 反向 VTK→list：在 VTK 里点中/选中一张切片 → 在三维体段树里同步选中该切片行（②反向）。
// 点空白/清选(dsId 空) → 一并清 VTK 异常高亮(否则取消选中后异常图形仍高亮，用户反馈)。
interactionMgr->onSliceSelectionChanged = [drawer, sceneView, renderWindowPtr](
const std::string& dsId) {
interactionMgr->onSliceSelectionChanged = [drawer](const std::string& dsId) {
if (auto* sec = drawer->analysisTab()->section("voxel"))
sec->selectItem(QString::fromStdString(dsId));
if (dsId.empty()) {
sceneView->setSelectedAnomaly(std::string{});
renderWindowPtr->Render();
}
};
// 已保存切片经 VTK 右键「关闭」→ 取消数据列表对应切片项的勾选(否则列表仍勾选，用户反馈)。
interactionMgr->onSliceClosed = [drawer](const std::string& dsId) {
if (auto* sec = drawer->analysisTab()->section("voxel"))
sec->setChecked(QString::fromStdString(dsId), false);
};
// 异常双击属性(R83)/右键删除已并入 analysisTab 的 detailRequested(dd_anomaly) /
// deleteDatasetRequested(dd_anomaly)；列表选中→VTK高亮(R84)随旧栏退役暂缺，待新段补 anomalySelected。
// ── 二维数据集栏：天地图底图开关（③，复用轨迹图 token，经同一共享 GeoLocalFrame 配准）──
auto* basemap = new geopro::app::TileBasemap(*scene, renderWindowPtr, frame, &window);
@ -1271,19 +980,6 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
if (*view2dMode == 4) sceneCtrl->set2DPlacement(4, z);
});
// ── 二维分析改造 A 期：切「三维分析/二维分析」tab → 一场景两相机 ──────────────────
// 三处协作：①切片隐藏+交互锁(仅平移+缩放) [InteractionManager]；②按目标维度重置取景基线
// [VtkSceneController]——使切换后该维度首条数据自动取景；③维度显隐+近俯视/自由相机+取景+坐标轴+
// 渲染 [VtkSceneView]。顺序：先 ①②(都不渲染)，最后 ③ 收尾统一渲染。只翻可见标志、不清空/重建 →
// 切换瞬时；地形+底图常驻。
QObject::connect(drawer, &geopro::app::ColumnDrawer::analysisModeChanged, &window,
[interactionMgr, sceneCtrl, sceneView, viewToolbar](bool is2D) {
interactionMgr->setMode2D(is2D);
sceneCtrl->onAnalysisModeChanged(is2D);
sceneView->setAnalysisMode2D(is2D);
viewToolbar->setAnalysisMode2D(is2D); // 二维下禁用 6 向快捷视图
});
// 首个真实剖面到达 → frame 重锚到数据 lat/lon 后，把选中的底图加载到数据所在位置
// （默认天地图即在此刻出现，避免启动时在样本原点拉无关瓦片）。
sceneView->onFrameReanchored = [basemap, basemapKind]() {
@ -1326,10 +1022,7 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
// ── 中央“空状态”引导浮层：未接入真实 sections 时，引导首次使用者从左侧入手。──
// 透明背景 + 鼠标穿透（不挡 QVTK 交互）；CenterOverlay 随视口尺寸保持居中；
// 接入真实中央数据后改成依 sections 是否为空调 setVisible 即可。
// 挂在 vtkWidget 下（而非 centerWidget）：使其与工具条/提示同属 vtkWidget 子级，CenterOverlay 会把它
// 压到子级最底（在 GL 之上、工具条/提示之下）→ 工具条永远在最上层、引导层在最下层（修视图缩小时
// 引导层挡住工具条）。
auto* emptyState = new QFrame(vtkWidget);
auto* emptyState = new QFrame(centerWidget);
emptyState->setObjectName(QStringLiteral("centralEmpty"));
emptyState->setAttribute(Qt::WA_TransparentForMouseEvents);
// 背景取 canvas/bg(#0B1320)——与画布同色：在原生 GL 上覆盖透明无法生效（会回退成不透明浅底），
@ -1372,24 +1065,16 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
esLay->addWidget(esHint);
auto* emptyCentering = new CenterOverlay(emptyState, vtkWidget);
// 引导层定位后，把工具条与提示浮层 raise 到其上 → 工具条永在最上层（修：缩小渲染区时引导层挡工具条）。
emptyCentering->setRaiseAfter({viewToolbar, anomalyHint, elevHint});
emptyCentering->reposition();
auto* vtkDock = new ads::CDockWidget(QStringLiteral("VTK视图"));
vtkDock->setWidget(centerWidget);
auto* centerDockArea = dockManager->addDockWidget(ads::CenterDockWidgetArea, vtkDock);
// 项目管理「直接嵌入」web 页：作为中央 QStackedWidget 的第二页，整窗加载（覆盖整个工作台）。
// 单实例复用——点不同菜单项时重新 load；token 已注入页面 localStorage。
auto* projectWebView = new geopro::app::ProjectWebView(sessionToken);
centralStack->addWidget(projectWebView); // index 1：项目管理 web 整窗
// ── 下方「数据详情」dock：平面图表多 Tab 面板（QGraphicsView，VTK 仅算几何）──
// 单击数据集 → 聚焦已开页；双击 → 新建/聚焦页（真实反演剖面/散点/异常/色阶）。
auto* detailPanel = new geopro::app::DatasetDetailPanel();
// 注入色阶模板仓储 + 当前 projectId 取值回调（网格剖面「色阶配置」编辑器的另存/打开/新建色阶）。
detailPanel->setViewState(viewState); // 跨视图色阶真源（2D↔3D 同步）
detailPanel->setColorTemplateRepo(&colorTplRepo, [&nav] { return nav.currentProjectId(); });
// 注入反演命令仓储（measurement 反演运算/生成视电阻率）。projectId 取值仍由页内 projectIdGetter 提供。
detailPanel->setCommandRepo(&cmdRepo);
@ -1635,32 +1320,12 @@ void buildWorkbench(QMainWindow& window, geopro::data::LocalSampleRepository& re
QObject::connect(topBar, &geopro::app::TopBar::workspaceSwitchRequested, &nav,
&geopro::controller::WorkbenchNavController::switchWorkspace);
// 项目管理「直接嵌入」web 页：拼当前项目的嵌入 URL，在中央区整窗加载（切到 web 页）。
// space=3 为「项目空间(projectSpace)」固定常量——Excel 所有 projectSpace 页均 space=3，
// 与租户/工作空间 id 无关（误用工作空间 snowflake 会被后端拒：space 参数无效）。
QObject::connect(
topBar, &geopro::app::TopBar::webPageRequested, &window,
[projectWebView, centralStack, &nav](const QString& /*title*/, const QString& target) {
const QString url =
QStringLiteral("http://tenant.geomative.cn/#/embed?space=3&projectId=%1&target=%2")
.arg(nav.currentProjectId(), target);
projectWebView->load(url);
centralStack->setCurrentWidget(projectWebView); // 整窗切到 web 页
});
// 视图菜单「分析视图」：中央区切回工作台（默认视图）。
QObject::connect(topBar, &geopro::app::TopBar::analysisViewRequested, &window,
[centralStack, dockManager]() {
centralStack->setCurrentWidget(dockManager);
});
// 切换到「不同项目」时先清空中央区，避免新项目残留旧项目的三栏数据与 VTK 渲染。
// 仅真正换项目用（delete-refresh 等 switchProject(currentProjectId) 不走此处，避免误清）。
auto clearCentral = [sceneCtrl, emptyState, checkedProfiles, checkedAnalysis,
pushChecked, lastSourceRows, refreshAnalysis, checkedSliceIds,
syncSlices, basemap, sceneView, scene3dRepo]() {
// 切项目：先清内存态三维体/切片/异常（否则上个项目的产物残留进新项目列表），再 refreshAnalysis。
scene3dRepo->clearMockData();
// 数据源清空 → 5 段 + col2D 清空（refreshAnalysis 内 setBuckets/dim2D）。
syncSlices, basemap, sceneView]() {
// 数据源清空 → 5 段 + col2D 清空（refreshAnalysis 内 setBuckets/dim2D；客户端三维体仍驻留）。
*lastSourceRows = {};
refreshAnalysis();
// 勾选集清空并下发空到 VTK（帘面/体素/切片/2D 足迹全部撤场）。
@ -2232,17 +1897,6 @@ public:
return false;
}
};
// VTK 警告/错误输出窗口：转 Qt 日志（qWarning），不弹独立窗口；并把 VTK 报错落进 geopro 日志便于排查。
class QtVtkOutputWindow : public vtkOutputWindow {
public:
static QtVtkOutputWindow* New();
vtkTypeMacro(QtVtkOutputWindow, vtkOutputWindow);
void DisplayText(const char* txt) override {
if (txt && *txt) qWarning().noquote() << "[vtk]" << QString::fromUtf8(txt).trimmed();
}
};
vtkStandardNewMacro(QtVtkOutputWindow);
} // namespace
int main(int argc, char* argv[])
@ -2262,28 +1916,10 @@ int main(int argc, char* argv[])
QSurfaceFormat::setDefaultFormat(QVTKOpenGLStereoWidget::defaultFormat());
GuardedApplication app(argc, argv); // 顶层异常护栏：slot/事件里的异常不致客户端崩溃
// VTK 警告/错误转 Qt 日志（qWarning → geopro 日志），彻底不弹独立 vtkOutputWindow 窗口
// （Windows 默认 vtkWin32OutputWindow 不认 DisplayMode，仍会弹空窗；故直接替换实例）。
// 同时把 VTK 报错落进日志，便于排查（如体绘制偶发不渲染的真因）。
{
auto* vtkOut = QtVtkOutputWindow::New();
vtkOutputWindow::SetInstance(vtkOut);
vtkOut->Delete(); // SetInstance 已持引用
}
// 异步 ApiCall::finished 等信号携带 ApiResponse；注册元类型以支持跨 QueuedConnection 传递
// （当前详情链路为同线程 DirectConnection，非严格必需，但作防御性注册，见 spec §5.1）。
qRegisterMetaType<geopro::net::ApiResponse>();
// Qt 标准控件文案中文化：安装 Qt 自带 zh_CN 翻译 → QMessageBox/QDialogButtonBox/QFileDialog/
// QColorDialog 等的 OK/Cancel/Yes/No/Save… 全局显示中文。translator 须存活至程序结束(放 main 栈)。
QTranslator qtZhTranslator;
const QString appTr = QCoreApplication::applicationDirPath() + QStringLiteral("/translations");
if (qtZhTranslator.load(QStringLiteral("qtbase_zh_CN"), appTr) || // 部署版(exe 旁)
qtZhTranslator.load(QStringLiteral("qtbase_zh_CN"),
QLibraryInfo::path(QLibraryInfo::TranslationsPath))) // dev(Qt 安装)
app.installTranslator(&qtZhTranslator);
// 组织/应用名：QSettings 持久化（dock 布局、登录记忆等）按此定位存储位置。
QCoreApplication::setOrganizationName(QStringLiteral("Geomative"));
QCoreApplication::setApplicationName(QStringLiteral("Geopro3"));
@ -2394,7 +2030,7 @@ int main(int argc, char* argv[])
// 而是给出可见错误提示。否则登录后窗口未显示、进程消失，用户无从排查。
try {
buildWorkbench(*window, repo, projectRepo, datasetRepo, colorTplRepo, cmdRepo, nav,
detailCtrl, token);
detailCtrl);
} catch (const std::exception& e) {
QMessageBox::critical(
nullptr, QStringLiteral("启动失败"),

3
src/app/panels/DatasetDetailPage.cpp
View File

@ -51,8 +51,7 @@ void DatasetDetailPage::build(const QString& dsId, const QString& ddCode, const
// dsIdGetter 用本页 dsId_（此处已赋值），随项目/数据集稳定。
auto view = makeDetailView(spec.kind, this, colorTplRepo_, projectIdGetter_, cmdRepo_,
[this] { return dsId_; },
[this] { return tmObjectId_; },
viewState_); // 抛出由调用栈兜底（GuardedApplication）
[this] { return tmObjectId_; }); // 抛出由调用栈兜底（GuardedApplication）
IDetailView* raw = view.release(); // QWidget 由 this/QwtPlot 父子树接管生命周期
views_[i] = raw;
// lazy 页签：建覆盖该视图的加载遮罩（父为视图 widget，随其尺寸覆盖图区）。

9
src/app/panels/DatasetDetailPage.hpp
View File

@ -12,10 +12,6 @@ class IColorTemplateRepository;
class IDatasetCommandRepository;
}
namespace geopro::controller {
class DatasetViewState; // 跨视图色阶真源（统一同步）
}
namespace geopro::app {
class IDetailView;
@ -39,9 +35,6 @@ public:
// 所属 TM 对象 id（=白化 structParentId）注入（须在 build 前设置 → tmObjectIdGetter 透传给视图）。
void setTmObjectId(const QString& tmObjectId) { tmObjectId_ = tmObjectId; }
// 跨视图色阶真源注入（须在 build 前设置 → 透传给网格视图，实现 2D↔3D 色阶同步）。
void setViewState(geopro::controller::DatasetViewState* state) { viewState_ = state; }
// 按页签集构建页签（首次打开调一次）。dsId/ddCode/dsName 用于 tabNeeded。
void build(const QString& dsId, const QString& ddCode, const QString& dsName,
const std::vector<geopro::controller::TabSpec>& tabs);
@ -82,8 +75,6 @@ private:
// 反演命令仓储注入（透传给 makeDetailView → measurement 散点视图反演按钮）。
geopro::data::IDatasetCommandRepository* cmdRepo_ = nullptr;
geopro::controller::DatasetViewState* viewState_ = nullptr; // 跨视图色阶真源（透传给网格视图）
};
} // namespace geopro::app

5
src/app/panels/DatasetDetailPanel.cpp
View File

@ -15,10 +15,6 @@ void DatasetDetailPanel::setCommandRepo(geopro::data::IDatasetCommandRepository*
cmdRepo_ = repo;
}
void DatasetDetailPanel::setViewState(geopro::controller::DatasetViewState* state) {
viewState_ = state;
}
DatasetDetailPanel::DatasetDetailPanel(QWidget* parent) : QTabWidget(parent) {
setTabsClosable(true);
connect(this, &QTabWidget::tabCloseRequested, this, [this](int i) { widget(i)->deleteLater(); });
@ -44,7 +40,6 @@ void DatasetDetailPanel::onDatasetOpened(const QString& dsId, const QString& ddC
// 注入须在 build 前（build 内造视图时即透传给工厂）。
p->setColorTemplateRepo(colorTplRepo_, projectIdGetter_);
p->setCommandRepo(cmdRepo_);
p->setViewState(viewState_); // 跨视图色阶真源（build 前设置 → 透传给网格视图）
p->setTmObjectId(tmObjectId); // 白化 structParentId（build 前设置 → 透传给视图）
p->build(dsId, ddCode, dsName, tabs); // ddCode 透传 → 页内 tabNeeded 携带
const QString title = dsName.isEmpty() ? dsId : dsName; // 页签标题用数据名（空则回退 id）

8
src/app/panels/DatasetDetailPanel.hpp
View File

@ -9,9 +9,6 @@ namespace geopro::data {
class IColorTemplateRepository;
class IDatasetCommandRepository;
}
namespace geopro::controller {
class DatasetViewState; // 跨视图色阶真源（统一同步）
}
namespace geopro::app {
class DatasetDetailPage;
@ -28,9 +25,6 @@ public:
// 反演命令仓储：透传给每个新建的详情页（measurement 反演运算/生成视电阻率用）。
void setCommandRepo(geopro::data::IDatasetCommandRepository* repo);
// 跨视图色阶真源：透传给每个新建的详情页 → 网格视图（2D↔3D 色阶同步）。
void setViewState(geopro::controller::DatasetViewState* state);
// 数据集打开：find-or-create 页 → build(tabs) → 加/抬该面板页签。
// tmObjectId：所属 TM 对象 id（白化 structParentId），build 前交给页 → 视图。
void onDatasetOpened(const QString& dsId, const QString& ddCode, const QString& dsName,
@ -57,7 +51,5 @@ private:
// 反演命令仓储注入（新页 build 前 setCommandRepo 透传）。
geopro::data::IDatasetCommandRepository* cmdRepo_ = nullptr;
geopro::controller::DatasetViewState* viewState_ = nullptr; // 跨视图色阶真源（透传给详情页）
};
} // namespace geopro::app

15
src/app/panels/DatasetListPanel.cpp
View File

@ -90,17 +90,6 @@ public:
const bool isContainer = idx.data(kDsDdCodeRole).toString() == QStringLiteral("container");
if (checkable) {
QRect checkRect(r.left() + 12, r.top() + (r.height() - box) / 2, box, box);
if (idx.data(kDsBusyRole).toBool()) {
// 渲染中：复选框位置画旋转 spinner（等待动画，角度由 kDsSpinAngleRole 驱动）。
const int angle = idx.data(kDsSpinAngleRole).toInt();
p->save();
p->setRenderHint(QPainter::Antialiasing, true);
QPen pen(geopro::app::tokenColor("accent/primary"), 2.0);
pen.setCapStyle(Qt::RoundCap);
p->setPen(pen);
p->drawArc(QRectF(checkRect).adjusted(2, 2, -2, -2), -angle * 16, 270 * 16);
p->restore();
} else {
const auto cs = static_cast<Qt::CheckState>(idx.data(Qt::CheckStateRole).toInt());
QStyleOptionViewItem o(opt);
o.rect = checkRect;
@ -109,7 +98,6 @@ public:
const QWidget* w = opt.widget;
QStyle* st = w ? w->style() : QApplication::style();
st->drawPrimitive(QStyle::PE_IndicatorItemViewItemCheck, &o, p, w);
}
textLeftPad = 12 + box + 8; // 复选框右侧留白后再放文本
} else if (isContainer) {
// 容器文本左缘对齐子级复选框的左缘(r.left()+12)——使「容器→带框子级」的视觉缩进 = 一个树级
@ -155,7 +143,6 @@ public:
const QModelIndex& idx) override {
if (!(idx.flags() & Qt::ItemIsUserCheckable))
return QStyledItemDelegate::editorEvent(ev, model, opt, idx);
const bool busy = idx.data(kDsBusyRole).toBool(); // 渲染中 → 吞掉勾选交互
const QRect r = opt.rect.adjusted(4, 2, -4, -2);
const int box = 16;
// 命中区放宽到复选框左侧整段(含一点文本起始),便于点击。
@ -167,14 +154,12 @@ public:
if (ev->type() == QEvent::MouseButtonRelease) {
auto* me = static_cast<QMouseEvent*>(ev);
if (me->button() == Qt::LeftButton && hit.contains(me->pos())) {
if (busy) return true; // 渲染中：不切换，仅消费
toggle();
return true;
}
} else if (ev->type() == QEvent::KeyPress) {
auto* ke = static_cast<QKeyEvent*>(ev);
if (ke->key() == Qt::Key_Space || ke->key() == Qt::Key_Select) {
if (busy) return true;
toggle();
return true;
}

2
src/app/panels/DatasetListPanel.hpp
View File

@ -23,8 +23,6 @@ constexpr int kDsNameRole = 0x0105; // Qt::UserRole + 5（dsName，详情页
constexpr int kDsTypeNameRole = 0x0106; // Qt::UserRole + 6（类型名，快速筛选用）
constexpr int kDsCreateTimeRole = 0x0107; // Qt::UserRole + 7（创建时间，按日期筛选用）
constexpr int kDsTmObjectIdRole = 0x0108; // Qt::UserRole + 8（所属 TM 对象 id=白化 structParentId）
constexpr int kDsBusyRole = 0x0109; // Qt::UserRole + 9（true=该行渲染中，复选框位置画等待 spinner）
constexpr int kDsSpinAngleRole = 0x010A; // Qt::UserRole + 10（spinner 角度，定时器驱动，delegate 据此旋转）
// 数据页签：树形（按 DsRow.parentId 嵌套，源数据为根、派生数据挂其下，对齐原版 el-table 树）。
// 每项列0：文本 = dsName +「创建时间 · 类型名」；data(0,角色) 存 dsId/ddCode/dsName。

5
src/app/panels/LoadingOverlay.cpp
View File

@ -30,10 +30,7 @@ LoadingOverlay::LoadingOverlay(QWidget* parent) : QWidget(parent), label_(new QL
hide();
}
void LoadingOverlay::showOver() { showOver(QStringLiteral("加载中…")); }
void LoadingOverlay::showOver(const QString& message) {
label_->setText(message);
void LoadingOverlay::showOver() {
if (parentWidget()) setGeometry(parentWidget()->rect());
raise();
show();

6
src/app/panels/LoadingOverlay.hpp
View File

@ -3,14 +3,12 @@
class QLabel;
namespace geopro::app {
// 半透明「等待」遮罩（公共组件）。贴在任意目标视图上层（含 VTK QVTKOpenGLStereoWidget），
// showOver()/hide() 切换，几何随父 resize 跟随。可传自定义文案在不同场景复用。
// 半透明「加载中…」遮罩。贴在目标视图上层，showOver()/hide() 切换，几何随父 resize 跟随。
class LoadingOverlay : public QWidget {
Q_OBJECT
public:
explicit LoadingOverlay(QWidget* parent);
void showOver(); // 铺满父尺寸、置顶、显示（默认「加载中…」）
void showOver(const QString& message); // 同上，自定义提示文案（如「正在保存三维体…」）
void showOver(); // 铺满父尺寸、置顶、显示
protected:
bool eventFilter(QObject* obj, QEvent* ev) override; // 跟随父 resize
private:

22
src/app/panels/chart/ColorMapService.cpp
View File

@ -11,11 +11,6 @@ inline double clamp01(double v) {
inline unsigned char lerpByte(unsigned char a, unsigned char b, double t) {
return static_cast<unsigned char>(a + (b - a) * t + 0.5);
}
// 两级透明度：每色 alpha × 整体透明度（渲染时相乘，不烘焙）。
inline core::Rgba applyGlobalAlpha(core::Rgba c, double g) {
c.a = static_cast<unsigned char>(c.a * g + 0.5);
return c;
}
} // namespace
ColorMapService::ColorMapService(const core::ColorScale& scale)
@ -52,18 +47,17 @@ double ColorMapService::normalized(double v) const {
}
core::Rgba ColorMapService::colorAtContinuous(double v) const {
const double g = scale_.globalOpacity(); // 两级第二级：整体透明度
if (normStops_.empty()) return applyGlobalAlpha(core::Rgba{0, 0, 0, 255}, g);
if (normStops_.size() == 1) return applyGlobalAlpha(normStops_.front().color, g);
if (normStops_.empty()) return core::Rgba{0, 0, 0, 255};
if (normStops_.size() == 1) return normStops_.front().color;
double t = normalized(v);
// 非有限值（NaN/Inf，可能来自降级后端的脏数据或退化数据范围）：回退首断点色，
// 避免下方 upper_bound 用 NaN 比较返回 end() 后解引用越界（崩溃）。
if (!std::isfinite(t)) return applyGlobalAlpha(normStops_.front().color, g);
if (!std::isfinite(t)) return normStops_.front().color;
// 找到 t 落在哪两个 normStop 之间
if (t <= normStops_.front().pos) return applyGlobalAlpha(normStops_.front().color, g);
if (t >= normStops_.back().pos) return applyGlobalAlpha(normStops_.back().color, g);
if (t <= normStops_.front().pos) return normStops_.front().color;
if (t >= normStops_.back().pos) return normStops_.back().color;
// 二分查找第一个 pos > t
auto it = std::upper_bound(normStops_.begin(), normStops_.end(), t,
@ -74,16 +68,16 @@ core::Rgba ColorMapService::colorAtContinuous(double v) const {
double segLen = hi.pos - lo.pos;
double frac = (segLen > 0.0) ? (t - lo.pos) / segLen : 0.0;
return applyGlobalAlpha(core::Rgba{
return core::Rgba{
lerpByte(lo.color.r, hi.color.r, frac),
lerpByte(lo.color.g, hi.color.g, frac),
lerpByte(lo.color.b, hi.color.b, frac),
lerpByte(lo.color.a, hi.color.a, frac)
}, g);
};
}
core::Rgba ColorMapService::colorAtDiscrete(double v) const {
return applyGlobalAlpha(scale_.colorAt(v), scale_.globalOpacity());
return scale_.colorAt(v);
}
} // namespace geopro::app

57
src/app/panels/chart/ColorScaleProperties.cpp
View File

@ -1,57 +0,0 @@
#include "panels/chart/ColorScaleProperties.hpp"
#include <QJsonArray>
namespace geopro::app {
QString rgbaToColorBarCss(const geopro::core::Rgba& c) {
if (c.a >= 255)
return QStringLiteral("#%1%2%3")
.arg(c.r, 2, 16, QLatin1Char('0'))
.arg(c.g, 2, 16, QLatin1Char('0'))
.arg(c.b, 2, 16, QLatin1Char('0'))
.toUpper();
return QStringLiteral("rgba(%1, %2, %3, %4)")
.arg(c.r)
.arg(c.g)
.arg(c.b)
.arg(QString::number(c.a / 255.0, 'g', 3));
}
QJsonObject buildColorScaleProperties(const geopro::core::ColorScale& scale,
const ContourLineConfig& lineCfg, const QString& lvlSchemeType,
int logLinesCount, int equalAreaLayerCount,
bool includeLvlScheme) {
QJsonArray colorBar;
for (const auto& [value, color] : scale.stops())
colorBar.append(QJsonArray{QString::number(value, 'f', 2), rgbaToColorBarCss(color)});
QJsonObject lineConfig{
{QStringLiteral("showLines"), lineCfg.lineShow},
{QStringLiteral("color"), rgbaToColorBarCss(lineCfg.lineColor)},
{QStringLiteral("lineType"),
lineCfg.dashed ? QStringLiteral("dashed") : QStringLiteral("solid")}};
QJsonObject labelConfig{{QStringLiteral("showLabels"), lineCfg.labelShow},
{QStringLiteral("color"), rgbaToColorBarCss(lineCfg.labelColor)}};
QJsonObject props{{QStringLiteral("colorBar"), colorBar},
{QStringLiteral("opacity"), scale.globalOpacity()}, // 两级第二级：整体透明度
{QStringLiteral("lineConfig"), lineConfig},
{QStringLiteral("labelConfig"), labelConfig}};
if (includeLvlScheme) { // 等值面(网格/反演)路径：层级方案透传字段（复刻原版，整条覆盖写须带）
props[QStringLiteral("lvlSchemeType")] = lvlSchemeType;
props[QStringLiteral("logLinesCount")] = logLinesCount;
props[QStringLiteral("equalAreaLayerCount")] = equalAreaLayerCount;
}
return props;
}
QJsonObject withColorBarAndOpacity(const QJsonObject& base, const geopro::core::ColorScale& scale) {
QJsonObject props = base; // 保留 lineConfig/labelConfig/层级方案 等加载到的原值
QJsonArray colorBar;
for (const auto& [value, color] : scale.stops())
colorBar.append(QJsonArray{QString::number(value, 'f', 2), rgbaToColorBarCss(color)});
props[QStringLiteral("colorBar")] = colorBar; // 仅覆盖本次编辑的颜色
props[QStringLiteral("opacity")] = scale.globalOpacity(); // 与整体不透明度
return props;
}
} // namespace geopro::app

29
src/app/panels/chart/ColorScaleProperties.hpp
View File

@ -1,29 +0,0 @@
#pragma once
#include <QJsonObject>
#include <QString>
#include "ContourLineDialog.hpp" // ContourLineConfig
#include "model/ColorScale.hpp"
namespace geopro::app {
// core::Rgba → colorBar 颜色串（不透明 #RRGGBB，半透明 rgba(r,g,b,a∈0..1)），与后端 colorBar 互通。
QString rgbaToColorBarCss(const geopro::core::Rgba& c);
// 组装色阶持久化 properties（colorBar[每色含 alpha] + opacity[整体透明度] + lineConfig + labelConfig
// + lvlSchemeType/logLinesCount/equalAreaLayerCount[层级方案，复刻原版透传字段]）。
// 散点/网格共用同一格式（同一条后端记录 businessCode=""）。整条 properties 覆盖写，故层级字段必须带，
// 否则会清空 web 设过的值。opacity 为两级透明度的第二级。
// includeLvlScheme=false：measurement 散点(type3) 路径，不写等值面专属的层级方案字段（对齐原版
// scatters「仅发 colorBar/lineConfig/labelConfig」+ 桌面两级 opacity），避免向 R0 记录注入无关字段。
QJsonObject buildColorScaleProperties(const geopro::core::ColorScale& scale,
const ContourLineConfig& lineCfg,
const QString& lvlSchemeType = QStringLiteral("normal"),
int logLinesCount = 8, int equalAreaLayerCount = 10,
bool includeLvlScheme = true);
// load-then-save 回写（对齐原版 originPage）：在加载到的原始 properties 上【只覆盖 colorBar+opacity】，
// 其余字段（lineConfig/labelConfig/层级方案）原样保留，避免散点保存清掉网格(共用同一条记录)的值。
QJsonObject withColorBarAndOpacity(const QJsonObject& base, const geopro::core::ColorScale& scale);
} // namespace geopro::app

2
src/app/panels/chart/ContourPlotItem.cpp
View File

@ -195,7 +195,7 @@ void ContourPlotItem::buildFillImage(const core::Grid& g, ColorMapService* svc)
double v = (v00 * (1 - ti) + v10 * ti) * (1 - tj) +
(v01 * (1 - ti) + v11 * ti) * tj;
auto c = svc->colorAtDiscrete(v); // 离散色带 → 平滑填充带边界
scan[px] = qRgba(c.r, c.g, c.b, c.a); // 听色阶 alpha：alpha=0 真透明（无 alpha 色阶默认 255 不受影响）
scan[px] = qRgba(c.r, c.g, c.b, c.a ? c.a : 255);
}
}
fillImage_ = std::move(img);

7
src/app/panels/chart/DetailViewFactory.cpp
View File

@ -17,8 +17,7 @@ std::unique_ptr<IDetailView> makeDetailView(controller::ViewKind kind, QWidget*
std::function<QString()> projectIdGetter,
geopro::data::IDatasetCommandRepository* cmdRepo,
std::function<QString()> dsIdGetter,
std::function<QString()> tmObjectIdGetter,
geopro::controller::DatasetViewState* viewState) {
std::function<QString()> tmObjectIdGetter) {
switch (kind) {
case controller::ViewKind::Scatter: {
auto* raw = new RawDataChartView(parent);
@ -26,8 +25,6 @@ std::unique_ptr<IDetailView> makeDetailView(controller::ViewKind kind, QWidget*
raw->setCommandRepo(cmdRepo, dsIdGetter, projectIdGetter);
// 注入色阶模板仓储（散点「色阶配置」编辑器另存为/打开/覆盖用；projectId 复用上面的 getter）。
raw->setColorTemplateRepo(colorTplRepo);
// 注入跨视图色阶真源（反演原数据 type1 与网格/3D 共用色阶 → 实时联动；measurement 不路由）。
raw->setViewState(viewState);
return std::unique_ptr<IDetailView>(raw);
}
case controller::ViewKind::FilledContour: {
@ -38,8 +35,6 @@ std::unique_ptr<IDetailView> makeDetailView(controller::ViewKind kind, QWidget*
grid->setCommandRepo(cmdRepo, std::move(dsIdGetter), std::move(projectIdGetter));
// 注入 tmObjectId 取值回调（白化对话框模板列表用，= 数据集 structParentId）。
grid->setTmObjectIdGetter(std::move(tmObjectIdGetter));
// 注入跨视图色阶真源（编辑→真源→3D 帘面/体等跟随；本视图也跟随他视图改色）。
grid->setViewState(viewState);
return std::unique_ptr<IDetailView>(grid);
}
case controller::ViewKind::Table: {

7
src/app/panels/chart/DetailViewFactory.hpp
View File

@ -13,10 +13,6 @@ class IColorTemplateRepository;
class IDatasetCommandRepository;
}
namespace geopro::controller {
class DatasetViewState; // 跨视图色阶真源（统一同步）
}
namespace geopro::app {
class IDetailView;
@ -33,7 +29,6 @@ std::unique_ptr<IDetailView> makeDetailView(
std::function<QString()> projectIdGetter = {},
geopro::data::IDatasetCommandRepository* cmdRepo = nullptr,
std::function<QString()> dsIdGetter = {},
std::function<QString()> tmObjectIdGetter = {},
geopro::controller::DatasetViewState* viewState = nullptr);
std::function<QString()> tmObjectIdGetter = {});
} // namespace geopro::app

59
src/app/panels/chart/GridDataChartView.cpp
View File

@ -36,8 +36,6 @@
#include "panels/chart/AutoAnnotationDialog.hpp"
#include "panels/chart/ColorBarWidget.hpp"
#include "panels/chart/ColorMapService.hpp"
#include "panels/chart/ColorScaleProperties.hpp"
#include "DatasetViewState.hpp"
#include "panels/chart/ContourDrawTool.hpp"
#include "panels/chart/ContourHoverTip.hpp"
#include "panels/chart/ContourPlotItem.hpp"
@ -326,7 +324,7 @@ void GridDataChartView::openColorScaleEditor() {
tplRepo_, projectId, lvlTemplateId_, this);
if (dlg.exec() != QDialog::Accepted) return;
const auto cs = dlg.colorScale();
gridScale_ = dlg.colorScale();
lineCfg_ = dlg.lineConfig();
showLabels_ = lineCfg_.labelShow; // 标注显隐同步 + 回写工具条复选框（避免 UI 与状态脱钩）
if (chkShowLabels_) {
@ -334,63 +332,10 @@ void GridDataChartView::openColorScaleEditor() {
chkShowLabels_->setChecked(showLabels_);
}
const QString dsId = dsIdGetter_ ? dsIdGetter_() : QString();
// 统一同步：写入色阶真源 → 经 colorScaleChanged 触发本视图(及 3D 帘面/体等)重渲染。
// 无状态层（理论不至）才本地兜底重绘。
if (state_ && !dsId.isEmpty()) {
state_->setColorScale(dsId, cs);
} else {
gridScale_ = cs;
applyColorScaleRender();
}
persistColorScale(dsId, cs, dlg.lvlSchemeType(), dlg.logLinesCount(),
dlg.equalAreaLayerCount()); // 持久化到后端（businessCode=""，与散点同一条记录）
}
void GridDataChartView::applyColorScaleRender() {
delete colorSvc_;
colorSvc_ = new ColorMapService(gridScale_);
rebuildContour();
if (colorBar_) colorBar_->setColorScale(gridScale_);
}
void GridDataChartView::setViewState(geopro::controller::DatasetViewState* state) {
state_ = state;
if (!state_) return;
connect(state_, &geopro::controller::DatasetViewState::colorScaleChanged, this,
&GridDataChartView::onColorScaleChanged);
}
void GridDataChartView::onColorScaleChanged(const QString& dsId) {
if (!state_ || !hasGrid_) return;
if (!dsIdGetter_ || dsIdGetter_() != dsId) return; // 只跟随本视图所示数据集
const auto* cs = state_->colorScale(dsId);
if (!cs) return;
gridScale_ = *cs;
applyColorScaleRender();
}
void GridDataChartView::persistColorScale(const QString& dsId, const geopro::core::ColorScale& cs,
const QString& lvlSchemeType, int logLinesCount,
int equalAreaLayerCount) {
if (!cmdRepo_ || dsId.isEmpty()) return; // 无仓储/无 dsId → 仅本地生效（不阻塞）
const QString projectId = projectIdGetter_ ? projectIdGetter_() : QString();
// 网格(getDetail type2) 与 反演散点(type1) 共用 businessCode=""（后端按 (dsObjectId,businessCode)
// 存唯一记录，save 无 type 字段）。properties 含每色 alpha + 整体透明度 + 层级方案透传字段。
QJsonObject body{
{QStringLiteral("dsObjectId"), dsId},
{QStringLiteral("templateId"), lvlTemplateId_},
{QStringLiteral("businessCode"), QString()},
{QStringLiteral("projectId"), projectId},
{QStringLiteral("properties"),
buildColorScaleProperties(cs, lineCfg_, lvlSchemeType, logLinesCount, equalAreaLayerCount)},
};
QPointer<GridDataChartView> self(this);
cmdRepo_->saveColorGradation(body, [self](bool ok, QString msg) {
if (!self || ok) return;
QMessageBox::warning(self, QStringLiteral("色阶配置"),
msg.isEmpty() ? QStringLiteral("色阶保存失败") : msg);
});
colorBar_->setColorScale(gridScale_);
}
void GridDataChartView::setCommandRepo(geopro::data::IDatasetCommandRepository* repo,

15
src/app/panels/chart/GridDataChartView.hpp
View File

@ -4,7 +4,6 @@
#include <vector>
#include <QJsonObject> // submitDrawnException 默认参数 const QJsonObject& = {} 需完整类型
#include <QPointer>
#include <QString>
#include <QWidget>
@ -29,10 +28,6 @@ class IColorTemplateRepository;
class IDatasetCommandRepository;
}
namespace geopro::controller {
class DatasetViewState; // 跨视图色阶真源（统一同步机制）
}
namespace geopro::app {
class AnomalyTablePanel;
@ -76,17 +71,9 @@ public:
tmObjectIdGetter_ = std::move(tmObjectIdGetter);
}
// 注入跨视图色阶真源（统一同步）：编辑写入它、并连 colorScaleChanged 跟随他视图（如 3D）改色。
void setViewState(geopro::controller::DatasetViewState* state);
private:
void rebuildContour(); // 按当前显隐开关重建并重绘 ContourPlotItem
void openColorScaleEditor(); // 「色阶配置」→ 共享色阶编辑器（色阶 + 层级⚙ + 线形⚙）
void applyColorScaleRender(); // 用当前 gridScale_ 重建色彩服务/等值面/色阶条
void onColorScaleChanged(const QString& dsId); // 色阶真源变更(本视图或他视图编辑)→ 跟随重渲染
void persistColorScale(const QString& dsId, const geopro::core::ColorScale& cs,
const QString& lvlSchemeType, int logLinesCount,
int equalAreaLayerCount); // 存后端（含层级方案透传字段）
void openGridWizard(); // I1「网格」→ 网格化向导
void openWhitening(); // I3「白化」→ 白化弹窗
void openFilter(); // I4「滤波处理」→ 滤波弹窗
@ -144,8 +131,6 @@ private:
// tmObjectId 取值回调（= 数据集 structParentId）。白化对话框模板列表用；空 → 模板列表为空。
std::function<QString()> tmObjectIdGetter_;
QPointer<geopro::controller::DatasetViewState> state_; // 跨视图色阶真源（注入；QPointer 自动判空防悬挂）
};
} // namespace geopro::app

81
src/app/panels/chart/RawDataChartView.cpp
View File

@ -2,8 +2,6 @@
#include "ColorScaleConfigDialog.hpp"
#include "panels/chart/ChartTheme.hpp"
#include "panels/chart/ColorBarWidget.hpp"
#include "panels/chart/ColorScaleProperties.hpp"
#include "DatasetViewState.hpp"
#include "panels/chart/GridWizardDialog.hpp"
#include "panels/chart/InversionFormDialog.hpp"
#include "panels/chart/SaveAsDialog.hpp"
@ -304,6 +302,41 @@ void styleToolIconButton(QToolButton* btn, const QIcon& icon) {
btn->setCursor(Qt::PointingHandCursor);
}
// core::Rgba → colorBar 颜色串（与 ColorScaleConfigDialog::rgbaToCss 同格式：不透明 #RRGGBB，
// 半透明 rgba(r,g,b,a∈0..1)），与后端 colorBar 互通。
QString rgbaToColorBarCss(const geopro::core::Rgba& c) {
if (c.a >= 255)
return QStringLiteral("#%1%2%3")
.arg(c.r, 2, 16, QLatin1Char('0'))
.arg(c.g, 2, 16, QLatin1Char('0'))
.arg(c.b, 2, 16, QLatin1Char('0'))
.toUpper();
return QStringLiteral("rgba(%1, %2, %3, %4)")
.arg(c.r)
.arg(c.g)
.arg(c.b)
.arg(QString::number(c.a / 255.0, 'g', 3));
}
// 组装色阶 properties（colorBar + lineConfig + labelConfig），与原版散点路径
// newLvlColorLevel 一致（battery/scatters 仅发这三块，不含 lvlSchemeType 等等值面专属字段）。
QJsonObject buildColorScaleProperties(const geopro::core::ColorScale& scale,
const ContourLineConfig& lineCfg) {
QJsonArray colorBar;
for (const auto& [value, color] : scale.stops())
colorBar.append(QJsonArray{QString::number(value, 'f', 2), rgbaToColorBarCss(color)});
QJsonObject lineConfig{
{QStringLiteral("showLines"), lineCfg.lineShow},
{QStringLiteral("color"), rgbaToColorBarCss(lineCfg.lineColor)},
{QStringLiteral("lineType"),
lineCfg.dashed ? QStringLiteral("dashed") : QStringLiteral("solid")}};
QJsonObject labelConfig{{QStringLiteral("showLabels"), lineCfg.labelShow},
{QStringLiteral("color"), rgbaToColorBarCss(lineCfg.labelColor)}};
return QJsonObject{{QStringLiteral("colorBar"), colorBar},
{QStringLiteral("lineConfig"), lineConfig},
{QStringLiteral("labelConfig"), labelConfig}};
}
} // namespace
void RawDataChartView::showNotImplemented(QWidget* anchor) {
@ -367,21 +400,16 @@ void RawDataChartView::openInversionColorScale(QWidget* anchor) {
this);
if (dlg.exec() != QDialog::Accepted) return;
const auto cs = dlg.colorScale();
const QString dsId = dsIdGetter_ ? dsIdGetter_() : QString();
// 统一同步：反演原数据(type1,"")与网格/3D 共用 → 写真源，经 colorScaleChanged 各视图(含自身)重绘。
if (state_ && !dsId.isEmpty()) {
state_->setColorScale(dsId, cs);
} else {
data_.scale = cs;
// 本地重建上色重绘。
data_.scale = dlg.colorScale();
delete colorSvc_;
colorSvc_ = new ColorMapService(data_.scale);
redrawScatter();
colorBar_->setColorScale(data_.scale);
}
showToast(this, QStringLiteral("色阶应用成功")); // M8 成功提示（对照原版 Message.success）
// 持久化（businessCode 空，对照原版 originPage newLvlColorLevel businessCode:''）。
const QString dsId = dsIdGetter_ ? dsIdGetter_() : QString();
const QString projectId = projectIdGetter_ ? projectIdGetter_() : QString();
if (!cmdRepo_ || dsId.isEmpty()) return;
QJsonObject body{
@ -389,13 +417,7 @@ void RawDataChartView::openInversionColorScale(QWidget* anchor) {
{QStringLiteral("templateId"), data_.templateId}, // 读取到的色阶模板 id（对照原版，可空）
{QStringLiteral("businessCode"), QString()},
{QStringLiteral("projectId"), projectId},
// load-then-save：在加载到的原始 properties 上只覆盖 colorBar+opacity，保留网格设过的
// lineConfig/层级（共用同一条 businessCode="" 记录）；无原始记录(首次)才整条新建。
{QStringLiteral("properties"),
data_.properties.isEmpty()
? buildColorScaleProperties(cs, dlg.lineConfig(), dlg.lvlSchemeType(),
dlg.logLinesCount(), dlg.equalAreaLayerCount())
: withColorBarAndOpacity(data_.properties, cs)},
{QStringLiteral("properties"), buildColorScaleProperties(data_.scale, dlg.lineConfig())},
};
QPointer<RawDataChartView> self(this);
cmdRepo_->saveColorGradation(body, [self](bool ok, QString msg) {
@ -405,26 +427,6 @@ void RawDataChartView::openInversionColorScale(QWidget* anchor) {
});
}
void RawDataChartView::setViewState(geopro::controller::DatasetViewState* state) {
state_ = state;
if (!state_) return;
connect(state_, &geopro::controller::DatasetViewState::colorScaleChanged, this,
&RawDataChartView::onColorScaleChanged);
}
void RawDataChartView::onColorScaleChanged(const QString& dsId) {
if (!state_) return;
if (!dsIdGetter_ || dsIdGetter_() != dsId) return; // 只跟随本视图所示数据集
const auto* cs = state_->colorScale(dsId);
if (!cs) return;
data_.scale = *cs;
delete colorSvc_;
colorSvc_ = new ColorMapService(data_.scale);
redrawScatter();
if (data_.verticalLegend) colorBarV_->setColorScale(data_.scale);
else colorBar_->setColorScale(data_.scale);
}
void RawDataChartView::openInversionSaveAs(QWidget* anchor) {
// O3：另存为（复用 SaveAsDialog::Inversion → saveInversionAsData）。
const QString dsId = dsIdGetter_ ? dsIdGetter_() : QString();
@ -597,10 +599,7 @@ void RawDataChartView::openScatterColorScale(QWidget* anchor) {
{QStringLiteral("templateId"), data_.templateId}, // 读取到的色阶模板 id（对照原版，可空）
{QStringLiteral("businessCode"), currentVFieldCode()},
{QStringLiteral("projectId"), projectId},
// measurement(type3,"R0") 独立记录：不写等值面层级方案字段（includeLvlScheme=false）。
{QStringLiteral("properties"),
buildColorScaleProperties(data_.scale, dlg.lineConfig(), QStringLiteral("normal"), 8, 10,
/*includeLvlScheme=*/false)},
{QStringLiteral("properties"), buildColorScaleProperties(data_.scale, dlg.lineConfig())},
};
QPointer<RawDataChartView> self(this);
cmdRepo_->saveColorGradation(body, [self](bool ok, QString msg) {

12
src/app/panels/chart/RawDataChartView.hpp
View File

@ -1,7 +1,6 @@
#pragma once
#include <functional>
#include <QPointer>
#include <QString>
#include <QWidget>
#include "model/detail/DetailPayloads.hpp"
@ -19,10 +18,6 @@ class IDatasetCommandRepository;
class IColorTemplateRepository;
}
namespace geopro::controller {
class DatasetViewState; // 跨视图色阶真源（统一同步）
}
namespace geopro::app {
class ColorBarWidget;
@ -57,10 +52,6 @@ public:
// setCommandRepo 注入的 projectIdGetter_）。可传空 → 编辑器后端按钮禁用。
void setColorTemplateRepo(geopro::data::IColorTemplateRepository* repo);
// 注入跨视图色阶真源：反演原数据散点(type1, businessCode="")与网格/3D 共用色阶 → 实时联动。
// measurement(type3,"R0") 单视图、不路由真源（openScatterColorScale 不经此）。
void setViewState(geopro::controller::DatasetViewState* state);
protected:
// 信息模式（M13）下捕获画布点击：找最近散点显示属性。其余事件不消费。
bool eventFilter(QObject* obj, QEvent* ev) override;
@ -79,7 +70,6 @@ private:
// 反演原数据默认工具条交互（O1/O2/O3）：
void openGridWizard(QWidget* anchor); // O1 网格化向导（复用 GridWizardDialog）
void openInversionColorScale(QWidget* anchor); // O2 原数据散点色阶（type1，businessCode=''）
void onColorScaleChanged(const QString& dsId); // 色阶真源变更(本视图或网格/3D)→ type1 散点跟随重绘
void openInversionSaveAs(QWidget* anchor); // O3 另存为（复用 SaveAsDialog::Inversion）
// measurement 交互：
@ -140,8 +130,6 @@ private:
std::function<QString()> projectIdGetter_;
// 色阶模板仓储（注入；空则编辑器「另存为/打开」禁用）。
geopro::data::IColorTemplateRepository* colorTplRepo_ = nullptr;
QPointer<geopro::controller::DatasetViewState> state_; // 跨视图色阶真源（注入；仅 type1 路由；QPointer 防悬挂）
};
} // namespace geopro::app

70
src/app/panels/columns/CategoryAnalysisTab.cpp
View File

@ -1,11 +1,6 @@
#include "panels/columns/CategoryAnalysisTab.hpp"
#include <QAbstractItemView>
#include <QPointer>
#include <QScrollArea>
#include <QScrollBar>
#include <QTimer>
#include <QTreeWidget>
#include <QVBoxLayout>
#include "Theme.hpp"
@ -20,25 +15,19 @@ CategoryAnalysisTab::CategoryAnalysisTab(geopro::data::DatasetFieldDictionary* d
outer->setSpacing(0);
auto* scroll = new QScrollArea(this);
scroll_ = scroll;
scroll->setWidgetResizable(true);
scroll->setFrameShape(QFrame::NoFrame);
scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // 内容随面板宽自适应，不出横向滚动条
outer->addWidget(scroll, 1);
auto* content = new QWidget(scroll);
content_ = content;
auto* col = new QVBoxLayout(content);
col_ = col;
col->setContentsMargins(0, space::kSm, 0, space::kSm); // 顶部留白：首段段头不贴顶
col->setContentsMargins(0, 0, 0, 0);
col->setSpacing(space::kSm);
for (const CategorySpec& spec : categoryConfigs()) {
auto* sec = new CategorySection(spec, dict, content);
sections_[spec.id] = sec;
ordered_.push_back(sec);
connect(sec, &CategorySection::collapsedChanged, this,
&CategoryAnalysisTab::relayoutSections); // 折叠/展开 → 重排 stretch（向上收）
const std::string segId = spec.id;
connect(sec, &CategorySection::checkedDatasetsChanged, this,
[this, segId](const QStringList& ids) {
@ -65,22 +54,9 @@ CategoryAnalysisTab::CategoryAnalysisTab(geopro::data::DatasetFieldDictionary* d
// 某段内容增多时其最小高度(=内容总高)撑大，超出视口则由外层 QScrollArea 统一出纵向滚动条。
col->addWidget(sec, 1);
}
// 尾部弹簧（末项）：默认 0；全部段折叠时由 relayoutSections 置 1，吸收余量把段头顶到顶部。
col->addStretch(0);
scroll->setWidget(content);
}
void CategoryAnalysisTab::relayoutSections() {
if (!col_) return;
int expanded = 0;
for (auto* sec : ordered_)
if (sec->isExpanded()) ++expanded;
// 展开段 stretch=1（吸收余量、铺满）；折叠段 stretch=0（只占段头高，下方不再留空）。
for (auto* sec : ordered_) col_->setStretchFactor(sec, sec->isExpanded() ? 1 : 0);
// 尾部弹簧：仅当全部折叠时=1（把所有段头顶到顶部）；有任一展开段时=0（由展开段吸收余量）。
col_->setStretch(col_->count() - 1, expanded == 0 ? 1 : 0);
}
void CategoryAnalysisTab::setBuckets(const CategoryBuckets& b) {
const auto& cfg = categoryConfigs();
for (std::size_t i = 0; i < cfg.size() && i < b.segments.size(); ++i) {
@ -105,50 +81,6 @@ CategorySection* CategoryAnalysisTab::section(const std::string& id) const {
return it != sections_.end() ? it->second : nullptr;
}
// ds 归属唯一段未知 → 广播到各段，仅含该 ds 的段会命中生效（其余 no-op）。
void CategoryAnalysisTab::setItemChecked(const QString& dsId, bool on) {
for (auto* sec : ordered_) sec->setChecked(dsId, on);
}
void CategoryAnalysisTab::setItemBusy(const QString& dsId, bool busy) {
for (auto* sec : ordered_) sec->setBusy(dsId, busy);
}
void CategoryAnalysisTab::clearAllBusy() {
for (auto* sec : ordered_) sec->clearAllBusy();
}
void CategoryAnalysisTab::scrollItemToTop(const QString& dsId) {
// 先就地展开所在段（同步），再进入多拍重试定位（等布局/滚动条范围结算）。
for (auto* sec : ordered_)
if (sec->itemFor(dsId)) { sec->ensureExpanded(); break; }
scrollItemToTopRetry(dsId, /*attemptsLeft=*/5);
}
void CategoryAnalysisTab::scrollItemToTopRetry(const QString& dsId, int attemptsLeft) {
if (!scroll_ || !content_) return;
CategorySection* sec = nullptr;
QTreeWidgetItem* item = nullptr;
for (auto* s : ordered_)
if ((item = s->itemFor(dsId)) != nullptr) { sec = s; break; }
if (sec && item) {
sec->ensureExpanded();
for (QTreeWidgetItem* p = item->parent(); p; p = p->parent())
p->setExpanded(true); // 展开树内父节点，使目标行有有效几何
QTreeWidget* tree = sec->listWidget();
tree->scrollToItem(item, QAbstractItemView::PositionAtTop); // 内层树（若有内滚动）
// 行顶映射到滚动内容坐标 → 设外层滚动条把该行顶到面板最上方。
const int y = tree->viewport()->mapTo(content_, tree->visualItemRect(item).topLeft()).y();
scroll_->verticalScrollBar()->setValue(y);
}
// 多拍重试：每拍布局更趋稳定（滚动条 range 长够、行几何更新），末拍稳定到位 → 根治"有时滚不到位"。
if (attemptsLeft > 0) {
QPointer<CategoryAnalysisTab> self(this);
const QString id = dsId;
QTimer::singleShot(16, this, [self, id, attemptsLeft]() {
if (self) self->scrollItemToTopRetry(id, attemptsLeft - 1);
});
}
}
void CategoryAnalysisTab::recomputeCheckedUnion() {
QStringList all; // ds 归属唯一段，跨段不重复，直接拼接
for (const auto& [id, ids] : checkedBySeg_) all += ids;

18
src/app/panels/columns/CategoryAnalysisTab.hpp
View File

@ -4,9 +4,6 @@
#include <map>
#include <string>
#include <vector>
class QVBoxLayout;
class QScrollArea;
#include "DatasetCategory.hpp" // CategoryBuckets
#include "interact/SlicePlaneMath.hpp" // geopro::render::interact::SliceAxis
#include "repo/RepoTypes.hpp"
@ -30,11 +27,6 @@ public:
void setStructure(const std::vector<geopro::data::StructNode>& nodes); // 转发各段
void refreshArrayFilters(); // 装置枚举异步加载后，重填各段装置筛选下拉
CategorySection* section(const std::string& id) const; // 按 CategorySpec.id 取段
// ── 三维体生成后：自动勾选触发渲染 + 标题前等待动画(spinner)反馈（转发到含该 ds 的段）──
void setItemChecked(const QString& dsId, bool on); // 自动勾选（触发渲染）
void setItemBusy(const QString& dsId, bool busy); // 复选框↔等待 spinner 切换
void clearAllBusy(); // 撤回所有 spinner（失败兜底）
void scrollItemToTop(const QString& dsId); // 把某行尽量滚到面板顶部（新建三维体后定位）
signals:
void checkedDatasetsChanged(const QStringList& dsIds); // 5 段勾选并集
@ -53,18 +45,8 @@ signals:
private:
void recomputeCheckedUnion();
// scrollItemToTop 的多拍重试实现：展开段/新增行后布局与滚动条范围需多次结算，单拍常滚不到位。
// 每拍重算行位置并设滚动条，剩余拍数耗尽前持续校正 → 末拍几何稳定后行稳定到顶。
void scrollItemToTopRetry(const QString& dsId, int attemptsLeft);
// 据各段折叠态重排 stretch：折叠段=0(仅段头高)、展开段=1(吸收余量)；全折叠时尾部弹簧吸收→段头顶到顶部。
// 仅在面板不产生滚动条(内容short于视口)时有可见效果——正是用户反馈的"折叠后停在原位中间"场景。
void relayoutSections();
std::map<std::string, CategorySection*> sections_;
std::vector<CategorySection*> ordered_; // 按 categoryConfigs 顺序（relayout 遍历用）
QScrollArea* scroll_ = nullptr; // 外层滚动区（scrollItemToTop 定位用）
QWidget* content_ = nullptr; // 滚动内容容器（坐标映射用）
QVBoxLayout* col_ = nullptr; // 段堆叠布局（末项=尾部弹簧）
std::map<std::string, QStringList> checkedBySeg_; // 各段当前勾选（合并成并集）
};

113
src/app/panels/columns/CategorySection.cpp
View File

@ -12,7 +12,6 @@
#include <QPushButton>
#include <QSet>
#include <QSignalBlocker>
#include <QTimer>
#include <QToolButton>
#include <QTreeWidget>
#include <QTreeWidgetItemIterator>
@ -34,50 +33,24 @@ CategorySection::CategorySection(const CategorySpec& spec, geopro::data::Dataset
root->setContentsMargins(0, 0, 0, 0);
root->setSpacing(0);
// 数据类型段头（可折叠，规范§4.3/§6）：chevron + 标题(title 字号·半粗) ｜「+ 新增三维体」(右,仅反演类)。
// 段头加浅底 + 底分隔线作视觉分段；去原生小三角(难看)→chevron 文本前缀，随主题/hover 变色。
// 数据类型标题行（spec §7）：折叠箭头+标题（左） | 「+新增三维体」（右，仅反演类，在标题行而非筛选行）。
auto* headerRow = new QWidget(this);
headerRow->setObjectName(QStringLiteral("secHeader"));
applyTokenizedStyleSheet(headerRow,
QStringLiteral("QWidget#secHeader{background:{{bg/panel-subtle}};"
"border-bottom:1px solid {{divider}};}"));
auto* hl = new QHBoxLayout(headerRow);
hl->setContentsMargins(space::kMd, space::kSm, space::kSm, space::kSm);
hl->setContentsMargins(space::kSm, 0, space::kSm, 0);
hl->setSpacing(space::kSm);
header_ = new QToolButton(headerRow);
header_->setText(QString::fromStdString(spec_.title));
header_->setCheckable(true);
header_->setChecked(true);
header_->setArrowType(Qt::NoArrow);
header_->setToolButtonStyle(Qt::ToolButtonTextOnly);
header_->setCursor(Qt::PointingHandCursor);
applyTokenizedStyleSheet(
header_, QStringLiteral("QToolButton{border:none;background:transparent;padding:0;"
"font-size:%1px;font-weight:%2;color:{{text/primary}};}"
"QToolButton:hover{color:{{accent/primary}};}")
.arg(scaledPx(type::kTitle))
.arg(type::kWeightSemibold));
auto syncHeader = [this] {
header_->setText((header_->isChecked() ? QStringLiteral("▾ ") : QStringLiteral("▸ "))
+ QString::fromStdString(spec_.title));
};
syncHeader();
header_->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
header_->setArrowType(Qt::DownArrow);
header_->setAutoRaise(true);
hl->addWidget(header_);
hl->addStretch(1);
if (spec_.canGenerateVolume) {
auto* gen = new QToolButton(headerRow);
gen->setText(QStringLiteral("+ 新增三维体"));
gen->setCursor(Qt::PointingHandCursor);
// 次级强调按钮(规范§6.7)：描边 accent + accent 文字，hover 浅强调底；非裸文字。
applyTokenizedStyleSheet(
gen, QStringLiteral(
"QToolButton{border:1px solid {{accent/primary}};border-radius:%1px;"
"color:{{accent/primary}};background:transparent;padding:%2px %3px;font-size:%4px;}"
"QToolButton:hover{background:{{bg/selected}};}"
"QToolButton:pressed{background:{{bg/hover}};}")
.arg(radius::kSm)
.arg(scaledPx(space::kXxs))
.arg(scaledPx(space::kMd))
.arg(scaledPx(type::kCaption)));
gen->setAutoRaise(true);
connect(gen, &QToolButton::clicked, this, [this] {
emit generateVolumeRequested(QString::fromStdString(spec_.dsTypeCode), checkedDsIds());
});
@ -92,7 +65,6 @@ CategorySection::CategorySection(const CategorySpec& spec, geopro::data::Dataset
// 筛选行：采集时间范围（在前）+ 装置类型（在后，仅 ERT 类）。
auto* filterRow = new QHBoxLayout();
filterRow->setSpacing(space::kSm);
dateRange_ = new DateRangeEdit(body_);
connect(dateRange_, &DateRangeEdit::rangeChanged, this, [this] { rebuildList(); });
filterRow->addWidget(dateRange_, 1);
@ -143,26 +115,12 @@ CategorySection::CategorySection(const CategorySpec& spec, geopro::data::Dataset
root->addWidget(body_, 1);
connect(header_, &QToolButton::toggled, this, [this, syncHeader](bool on) {
connect(header_, &QToolButton::toggled, this, [this](bool on) {
body_->setVisible(on);
syncHeader(); // ▾(展开)/▸(折叠) 切换
emit collapsedChanged(); // 外层据此把折叠段 stretch 归 0、展开段吸收余量 → 折叠向上收
header_->setArrowType(on ? Qt::DownArrow : Qt::RightArrow);
});
}
bool CategorySection::isExpanded() const { return header_ && header_->isChecked(); }
void CategorySection::ensureExpanded() {
if (header_ && !header_->isChecked()) header_->setChecked(true); // toggled→展开段体
}
QTreeWidgetItem* CategorySection::itemFor(const QString& dsId) const {
if (!list_ || dsId.isEmpty()) return nullptr;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->data(0, kDsIdRole).toString() == dsId) return *it;
return nullptr;
}
void CategorySection::setStructure(const std::vector<geopro::data::StructNode>& nodes) {
structure_ = nodes; // 容器分层（项目根/GS/TM→ds）在 Task 12 接入真实结构后据此构建。
}
@ -192,51 +150,6 @@ void CategorySection::setChecked(const QString& dsId, bool on) {
}
}
void CategorySection::setBusy(const QString& dsId, bool on) {
QTreeWidgetItem* target = nullptr;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->data(0, kDsIdRole).toString() == dsId) { target = *it; break; }
if (!target) return;
{
// 改 busy/角度角色用 SignalBlocker：不触发 itemChanged→emitChecked→重渲染；viewport 仍重绘。
const QSignalBlocker block(list_);
target->setData(0, kDsBusyRole, on);
if (on) target->setData(0, Qt::CheckStateRole, Qt::Checked); // 渲染中保持勾选(仍属渲染集)
}
bool anyBusy = false;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->data(0, kDsBusyRole).toBool()) { anyBusy = true; break; }
if (anyBusy) {
if (!spinTimer_) {
spinTimer_ = new QTimer(this);
spinTimer_->setInterval(80);
connect(spinTimer_, &QTimer::timeout, this, [this]() {
spinAngle_ = (spinAngle_ + 30) % 360;
const QSignalBlocker block(list_);
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->data(0, kDsBusyRole).toBool())
(*it)->setData(0, kDsSpinAngleRole, spinAngle_);
});
}
if (!spinTimer_->isActive()) spinTimer_->start();
} else if (spinTimer_) {
spinTimer_->stop();
}
if (list_->viewport()) list_->viewport()->update();
}
void CategorySection::clearAllBusy() {
const QSignalBlocker block(list_);
bool any = false;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->data(0, kDsBusyRole).toBool()) {
(*it)->setData(0, kDsBusyRole, false);
any = true;
}
if (spinTimer_) spinTimer_->stop();
if (any && list_->viewport()) list_->viewport()->update();
}
void CategorySection::refreshArrayCombo() {
if (!spec_.hasArrayTypeFilter || !arrayCombo_) return;
const QString prev = arrayCombo_->currentData().toString();
@ -400,12 +313,14 @@ void CategorySection::showContextMenu(const QPoint& pos) {
sl->addAction(QStringLiteral("前后"), this, [this, id] { emit sliceRequested(SliceAxis::FrontBack, id); });
sl->addAction(QStringLiteral("左右"), this, [this, id] { emit sliceRequested(SliceAxis::LeftRight, id); });
sl->addAction(QStringLiteral("任意"), this, [this, id] { emit sliceRequested(SliceAxis::Oblique, id); });
menu.addAction(QStringLiteral("色阶"), this, [this, id] { emit colorScaleRequested(id); });
} else if (ddCode == QStringLiteral("dd_slice")) { // 切片(列表中均为已保存=定稿锁定，无保存/另存)
menu.addAction(QStringLiteral("色阶…"), this, [this, id] { emit colorScaleRequested(id); });
} else if (ddCode == QStringLiteral("dd_slice")) { // 切片
menu.addAction(QStringLiteral("保存位姿"), this, [this, id] { emit sliceSaveRequested(id); });
menu.addAction(QStringLiteral("另存为…"), this, [this, id] { emit sliceSaveAsRequested(id); });
QMenu* ex = menu.addMenu(QStringLiteral("导出"));
ex->addAction(QStringLiteral("图片"), this, [this, id] { emit sliceExportImageRequested(id); });
ex->addAction(QStringLiteral("dat"), this, [this, id] { emit sliceExportDatRequested(id); });
menu.addAction(QStringLiteral("色阶"), this, [this, id] { emit colorScaleRequested(id); });
menu.addAction(QStringLiteral("色阶…"), this, [this, id] { emit colorScaleRequested(id); });
menu.addSeparator();
menu.addAction(QStringLiteral("删除"), this, [this, id, ddCode] { emit deleteDatasetRequested(id, ddCode); });
} else if (ddCode == QStringLiteral("dd_anomaly")) { // 异常

12
src/app/panels/columns/CategorySection.hpp
View File

@ -7,12 +7,10 @@
#include "repo/RepoTypes.hpp"
class QTreeWidget;
class QTreeWidgetItem;
class QComboBox;
class QDateEdit;
class QLabel;
class QToolButton;
class QTimer;
class QWidget;
namespace geopro::data {
@ -35,21 +33,13 @@ public:
void setStructure(const std::vector<geopro::data::StructNode>& nodes);
void setDatasets(const std::vector<geopro::data::DsRow>& rows);
void setChecked(const QString& dsId, bool on); // 按 dsId 勾选/取消(新建切片自动勾选等场景)
// 渲染中：该行复选框替换为等待 spinner（busy=true）/复原（false）。busy 期间保持勾选、动画由定时器驱动。
void setBusy(const QString& dsId, bool busy);
void clearAllBusy(); // 撤回本段所有 spinner（失败兜底）
void selectItem(const QString& dsId); // 程序化选中某行(VTK→list 反向联动)；空/未找到=清选中
QStringList checkedIds() const { return checkedDsIds(); } // 当前勾选 ds（异常显隐同步用）
void refreshArrayFilter() { refreshArrayCombo(); } // 装置枚举异步加载后重填下拉
const CategorySpec& spec() const { return spec_; }
bool isExpanded() const; // 段头展开态（供外层按折叠状态重分配 stretch，实现"折叠向上收"）
void ensureExpanded(); // 展开本段（折叠则展开）：滚动定位前确保目标行可见
QTreeWidget* listWidget() const { return list_; } // 段体树（外层滚动定位用）
QTreeWidgetItem* itemFor(const QString& dsId) const; // 按 dsId 取行（无则 nullptr）
signals:
void checkedDatasetsChanged(const QStringList& dsIds); // 数据行勾选=渲染
void collapsedChanged(); // 折叠/展开切换 → 外层 CategoryAnalysisTab 重排各段 stretch
void generateVolumeRequested(const QString& dsTypeCode, const QStringList& sourceDsIds); // 段头「+新增三维体」
void detailRequested(const QString& dsId, const QString& ddCode, const QString& name); // 双击/右键=详情
void deleteDatasetRequested(const QString& dsId, const QString& ddCode); // 右键删除（切片/异常）
@ -81,8 +71,6 @@ private:
QComboBox* arrayCombo_ = nullptr; // 装置类型筛选（仅 hasArrayTypeFilter）
DateRangeEdit* dateRange_ = nullptr; // 采集时间范围筛选（起止双日历，可清空）
QTreeWidget* list_ = nullptr;
QTimer* spinTimer_ = nullptr; // 驱动 busy 行 spinner 旋转（有 busy 行时运行）
int spinAngle_ = 0; // 当前 spinner 角度（度）
};
} // namespace geopro::app

32
src/app/panels/columns/Column2DDataset.cpp
View File

@ -1,8 +1,5 @@
#include "panels/columns/Column2DDataset.hpp"
#include <set>
#include <string>
#include <QComboBox>
#include "EmptyAwareComboBox.hpp"
@ -72,7 +69,6 @@ Column2DDataset::Column2DDataset(QWidget* parent) : QWidget(parent) {
list_ = new QTreeWidget();
list_->setHeaderHidden(true);
list_->setRootIsDecorated(true);
list_->setSelectionMode(QAbstractItemView::ExtendedSelection); // 多选行(与 VTK 多选拖动联动)
applyDatasetCardDelegate(list_);
connect(list_, &QTreeWidget::itemChanged, this, [this](QTreeWidgetItem*, int) {
QStringList ids;
@ -82,36 +78,19 @@ Column2DDataset::Column2DDataset(QWidget* parent) : QWidget(parent) {
}
emit checkedDatasetsChanged(ids);
});
// 行选中变化 → 上抛选中 dsId(高亮联动 VTK；与勾选/渲染独立)。
connect(list_, &QTreeWidget::itemSelectionChanged, this, [this]() {
QStringList ids;
for (QTreeWidgetItem* it : list_->selectedItems())
ids << it->data(0, kDsIdRole).toString();
emit selectedDatasetsChanged(ids);
});
root->addWidget(list_, 1);
}
void Column2DDataset::setDatasets(const std::vector<geopro::data::DsRow>& rows) {
// 增量保留：记住当前已勾选的足迹 ds，重建后复原（仍存在的项保持勾选）。否则对象树每次增删勾选都触发
// 本刷新 → 清空全部勾选 + 上抛空集 → 已渲染足迹被移除、列表选中丢失（用户反馈：必须增量更新，
// 与三维分析段 CategorySection::rebuildList 同一处理）。
std::set<std::string> wasChecked;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->checkState(0) == Qt::Checked)
wasChecked.insert((*it)->data(0, kDsIdRole).toString().toStdString());
{
QSignalBlocker blocker(list_);
populateDatasetList(list_, rows, /*append=*/false);
for (QTreeWidgetItemIterator it(list_); *it; ++it) {
(*it)->setFlags((*it)->flags() | Qt::ItemIsUserCheckable);
const std::string id = (*it)->data(0, kDsIdRole).toString().toStdString();
// 复原勾选：仍存在的曾勾选项保持勾选；新项默认不勾。
(*it)->setCheckState(0, wasChecked.count(id) ? Qt::Checked : Qt::Unchecked);
(*it)->setCheckState(0, Qt::Unchecked);
}
} // blocker released here
// 上抛复原后的勾选集（保持渲染，不再清空 → 控制器据 diff 增量保留已渲染足迹，集合不变则不增删）。
// 填充后统一发一次(新载入必为空选):清掉上一次的渲染勾选
QStringList ids;
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if ((*it)->checkState(0) == Qt::Checked)
@ -119,11 +98,4 @@ void Column2DDataset::setDatasets(const std::vector<geopro::data::DsRow>& rows)
emit checkedDatasetsChanged(ids);
}
void Column2DDataset::setSelectedDsIds(const QStringList& dsIds) {
QSignalBlocker blocker(list_); // 防回环：VTK→列表 设置选中不再上抛 selectedDatasetsChanged
list_->clearSelection();
for (QTreeWidgetItemIterator it(list_); *it; ++it)
if (dsIds.contains((*it)->data(0, kDsIdRole).toString())) (*it)->setSelected(true);
}
} // namespace geopro::app

5
src/app/panels/columns/Column2DDataset.hpp
View File

@ -14,15 +14,12 @@ class Column2DDataset : public QWidget {
public:
explicit Column2DDataset(QWidget* parent = nullptr);
void setDatasets(const std::vector<geopro::data::DsRow>& rows);
// VTK→列表 选择联动：按 dsId 选中对应行(高亮)，内部屏蔽信号避免回环。
void setSelectedDsIds(const QStringList& dsIds);
signals:
void basemapChanged(int index); // 0 天地图 / 1 Google / 2 隐藏
void view2DModeChanged(int index); // 0 关闭 /1 Z=0 /2 顶部 /3 底部 /4 自定义
void customZChanged(double z); // 世界绝对高程(米),向上为正
void checkedDatasetsChanged(const QStringList& dsIds); // 勾选(渲染开关)变化
void selectedDatasetsChanged(const QStringList& dsIds); // 行选中(高亮联动)变化，非勾选
void checkedDatasetsChanged(const QStringList& dsIds);
private:
QTreeWidget* list_ = nullptr;

5
src/app/panels/columns/ColumnDrawer.cpp
View File

@ -25,10 +25,6 @@ ColumnDrawer::ColumnDrawer(QWidget* parent, geopro::data::DatasetFieldDictionary
tabs->addTab(analysisTab_, QStringLiteral("三维分析"));
tabs->addTab(col2D_, QStringLiteral("二维分析"));
tabs->tabBar()->setUsesScrollButtons(false); // 永不出左右滚动箭头（两 tab 必能平铺）
// 切 tab → 发 analysisModeChanged(is2D)：以"当前 widget 是否 col2D"判定，不写死索引。
connect(tabs, &QTabWidget::currentChanged, this, [this, tabs](int idx) {
emit analysisModeChanged(tabs->widget(idx) == col2D_);
});
// 折叠按钮：固定宽 18px，垂直拉伸。
// 用 SVG 图标(makeGlyph)而非 ◀/▶ 文字——三角符(U+25C0/25B6)不在 YaHei，作按钮文字会触发
@ -83,7 +79,6 @@ void ColumnDrawer::toggleCollapsed()
// 折叠后只保留按钮宽度；展开恢复可调范围
setMinimumWidth(collapsed_ ? 0 : 180);
setMaximumWidth(collapsed_ ? 18 : 560);
emit collapsedChanged(collapsed_); // 通知上层调 QSplitter 尺寸，回收/恢复栏宽（防残留空白）
}
void ColumnDrawer::expand()

6
src/app/panels/columns/ColumnDrawer.hpp
View File

@ -23,12 +23,6 @@ public:
Column2DDataset* col2D() const { return col2D_; }
CategoryAnalysisTab* analysisTab() const { return analysisTab_; }
signals:
// 切换「三维分析 / 二维分析」tab：is2D=true 进入二维分析。上层据此切相机+翻维度可见标志。
void analysisModeChanged(bool is2D);
// 折叠/展开切换：上层据此调整 QSplitter 尺寸，回收/恢复抽屉栏宽（否则收起残留空白区）。
void collapsedChanged(bool collapsed);
public slots:
void toggleCollapsed();
void expand(); // 强制展开（进入全屏时确保三栏可见）

63
src/app/panels/web/ProjectWebView.cpp
View File

@ -1,63 +0,0 @@
#include "panels/web/ProjectWebView.hpp"
#include <QUrl>
#include <QVBoxLayout>
#include <QWebEnginePage>
#include <QWebEngineScript>
#include <QWebEngineScriptCollection>
#include <QWebEngineView>
namespace geopro::app {
namespace {
// 把字符串转成安全的 JS 字面量（带引号、转义），用于拼进注入脚本。
QString jsStringLiteral(const QString& s) {
// QJsonValue::toJson 不直接给单值字符串；手工转义足够（token 仅含 base64/空格）。
QString out;
out.reserve(s.size() + 2);
out += QLatin1Char('"');
for (const QChar c : s) {
switch (c.unicode()) {
case '\\': out += QStringLiteral("\\\\"); break;
case '"': out += QStringLiteral("\\\""); break;
case '\n': out += QStringLiteral("\\n"); break;
case '\r': out += QStringLiteral("\\r"); break;
case '\t': out += QStringLiteral("\\t"); break;
default: out += c; break;
}
}
out += QLatin1Char('"');
return out;
}
} // namespace
ProjectWebView::ProjectWebView(const QString& token, QWidget* parent) : QWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(0);
view_ = new QWebEngineView(this);
lay->addWidget(view_, 1);
// token 注入：DocumentCreation 阶段把登录 token 写入 localStorage["token"]，
// 早于嵌入页 SPA 启动脚本，保证其读取鉴权时已就绪。每次 load 都会重新执行。
if (!token.isEmpty()) {
QWebEngineScript script;
script.setName(QStringLiteral("inject-geopro-token"));
script.setInjectionPoint(QWebEngineScript::DocumentCreation);
script.setWorldId(QWebEngineScript::MainWorld);
script.setRunsOnSubFrames(true);
script.setSourceCode(
QStringLiteral("try{localStorage.setItem('token', %1);}catch(e){}")
.arg(jsStringLiteral(token)));
view_->page()->scripts().insert(script);
}
}
void ProjectWebView::load(const QString& url) {
view_->load(QUrl(url));
}
} // namespace geopro::app

25
src/app/panels/web/ProjectWebView.hpp
View File

@ -1,25 +0,0 @@
#pragma once
#include <QString>
#include <QWidget>
class QWebEngineView;
namespace geopro::app {
// 项目管理 webview 宿主：内嵌 QWebEngineView，承载需「直接嵌入」的 web 管理页
// （在线监测 / 工具组件 / 批量导出 / 告警管理）。
// 构造期注入 DocumentCreation 脚本，把登录 token 写入页面 localStorage["token"]，
// 早于页面自身脚本执行，确保 web 端读取鉴权时已就绪。
class ProjectWebView : public QWidget {
Q_OBJECT
public:
explicit ProjectWebView(const QString& token, QWidget* parent = nullptr);
// 加载嵌入页（完整 URL，含 #/embed?space=..&projectId=..&target=..）。
void load(const QString& url);
private:
QWebEngineView* view_ = nullptr;
};
} // namespace geopro::app

1
src/controller/CMakeLists.txt
View File

@ -2,7 +2,6 @@ find_package(Qt6 COMPONENTS Core REQUIRED)
add_library(geopro_controller STATIC
WorkbenchNavController.cpp
DatasetDetailController.cpp
DatasetViewState.cpp
VtkSceneController.cpp)
target_include_directories(geopro_controller PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(geopro_controller PUBLIC geopro_data Qt6::Core)

2
src/controller/DatasetViewState.cpp
View File

@ -1,2 +0,0 @@
#include "DatasetViewState.hpp"
// 实现全部内联于头；此 .cpp 仅为让 AUTOMOC 为带 Q_OBJECT 的头生成并链接 moc。

49
src/controller/DatasetViewState.hpp
View File

@ -1,49 +0,0 @@
#pragma once
#include <QHash>
#include <QObject>
#include <QString>
#include "model/ColorScale.hpp"
namespace geopro::controller {
// 跨视图共享的「单一真源」会话状态，按 dsId 维护。统一所有视图间同步，取代两两接线：
// - 改色阶：任何编辑入口只调 setColorScale(dsId, cs)，不再各改各的拷贝；
// - 观察：各视图连一次 colorScaleChanged(dsId)，槽里【只重渲染】、【绝不回写】→ 无信号回环；
// - 加载：视图取色阶时先问 hub（colorScale 非空则用之），否则把后端值 seed 进来当真源。
// 新增同步项（可见性/选中/值域…）= 加一个字段 + 一个 xxxChanged(dsId) 信号，沿用同一套机制。
//
// 作用域：数据集的「默认/共享色阶」(后端 businessCode="")，被 反演散点/网格/帘面/体 共用（同一条后端
// 记录）。measurement(businessCode="R0") 为单视图、无跨视图伙伴，暂不入此层（清晰边界，非欠债）。
class DatasetViewState : public QObject {
Q_OBJECT
public:
explicit DatasetViewState(QObject* parent = nullptr) : QObject(parent) {}
bool hasColorScale(const QString& dsId) const { return scales_.contains(dsId); }
// 无记录返回 nullptr（调用方据此兜底为自带值）。
const geopro::core::ColorScale* colorScale(const QString& dsId) const {
auto it = scales_.constFind(dsId);
return it == scales_.constEnd() ? nullptr : &it.value();
}
// 用户编辑应用：写入真源并广播。观察者据此重渲染。
void setColorScale(const QString& dsId, const geopro::core::ColorScale& cs) {
scales_.insert(dsId, cs);
emit colorScaleChanged(dsId);
}
// 首次从后端加载得到色阶时播种：已有则不覆盖、不广播（避免加载即触发重建/存盘）。
void seedColorScale(const QString& dsId, const geopro::core::ColorScale& cs) {
if (!scales_.contains(dsId)) scales_.insert(dsId, cs);
}
signals:
void colorScaleChanged(const QString& dsId);
private:
QHash<QString, geopro::core::ColorScale> scales_;
};
} // namespace geopro::controller

6
src/controller/I3dSceneView.hpp
View File

@ -31,8 +31,6 @@ public:
virtual void clear() = 0;
virtual void setVerticalExaggeration(double ve) = 0;
// 三维体体绘制最大不透明度（0~1）：运行时调节已渲染体 + 后续新体（默认 0.30）。默认空实现，测试 mock 无需覆盖。
virtual void setVolumeOpacity(double maxOpacity) { (void)maxOpacity; }
// 地表高程基准（测线地表高程）：2D 足迹「顶部/底部」摆放锚定真实地表。
virtual double zRefElev() const = 0;
@ -44,10 +42,6 @@ public:
// 3D：体绘制（IDW 体素 + colorScale）；按 dsId 跟踪。
virtual void addVolume(const std::string& dsId, const geopro::data::VolumeGrid& vol,
const geopro::core::ColorScale& cs) = 0;
// 原地更新已渲染体颜色/不透明度（仅换传函、不重建 image）：色阶改动用，避免换 image 连带关闭未保存切片。
// 返回 true=已原地更新；false=该体未渲染/不支持 → 调用方回退 remove+add。默认 false。
virtual bool updateVolumeColorInPlace(const std::string& /*dsId*/,
const geopro::core::ColorScale& /*cs*/) { return false; }
// 2D 足迹：把测线/轨迹经纬折线平铺进 3D 地图（worldZ=摆放高程）；按 dsId 跟踪以支持增量移除。
virtual void addMapLine(const std::string& dsId, const geopro::data::MapLine& line,
double worldZ) = 0;

103
src/controller/VtkSceneController.cpp
View File

@ -4,10 +4,8 @@
#include <set>
#include <utility>
#include <QDebug>
#include <QPointer>
#include "DatasetViewState.hpp"
#include "I3dSceneView.hpp"
#include "repo/IDatasetRepository.hpp"
@ -25,39 +23,6 @@ VtkSceneController::VtkSceneController(data::IDatasetRepository& dsRepo,
QObject* parent)
: QObject(parent), dsRepo_(dsRepo), sceneRepo_(sceneRepo), view_(view) {}
void VtkSceneController::setViewState(DatasetViewState* state) {
state_ = state;
if (state_)
connect(state_, &DatasetViewState::colorScaleChanged, this,
&VtkSceneController::recolorDataset);
}
void VtkSceneController::recolorDataset(const QString& qid) {
if (!state_) return;
const geopro::core::ColorScale* cs = state_->colorScale(qid);
if (!cs) return;
const std::string dsId = qid.toStdString();
volumeScaleCache_[dsId] = *cs; // 体色阶随真源更新（未渲染时下次勾选命中）
if (!isChecked(dsId)) return; // 未渲染 → 仅更缓存
// 就地重建：体 → 用新色阶重 addVolume（addVolume 内部触发体下切片随新色阶重建）；
// 帘面 → 用缓存源网格重 addCurtain。一个 dsId 只会是其一。
bool changed = false;
if (auto vit = volumeCache_.find(dsId); vit != volumeCache_.end()) {
// 优先原地改色（仅换传函、不重建 image）→ 该体下未保存切片不被关闭、跟随改色。
// 原地失败（理论不至）才回退 remove+add（会关未保存切片）。
if (!view_.updateVolumeColorInPlace(dsId, *cs)) {
view_.removeDataset(dsId);
view_.addVolume(dsId, vit->second, *cs);
}
changed = true;
} else if (auto sit = sectionGridCache_.find(dsId); sit != sectionGridCache_.end()) {
view_.removeDataset(dsId);
view_.addCurtain(dsId, sit->second, *cs);
changed = true;
}
if (changed) view_.renderIncremental();
}
void VtkSceneController::setCheckedDatasets(const QStringList& dsIds) {
std::vector<std::string> newDs;
newDs.reserve(static_cast<std::size_t>(dsIds.size()));
@ -81,8 +46,7 @@ void VtkSceneController::setCheckedDatasets(const QStringList& dsIds) {
// 取景意图按「场景是否已有数据到场过」判定，而非 checkedDs_ 是否空——否则连续快速勾选第二个
// ds 时 checkedDs_ 已非空但首批尚未到场，会被误清取景意图，相机不对准数据 → 看似不渲染。
fitOnArrival_ = !hadArrivedData_;
// 仅当 3D 与 2D 都空才复位取景基线：否则取消全部 3D 但仍有 2D 足迹时，下个 3D 勾选会误跳取景。
if (checkedDs_.empty() && checked2dDs_.empty()) hadArrivedData_ = false;
if (checkedDs_.empty()) hadArrivedData_ = false; // 全取消 → 下批到场重新取景
const unsigned long long gen = rebuildGeneration_; // 不自增：并发增量互不作废
for (const auto& id : checkedDs_)
@ -99,16 +63,14 @@ void VtkSceneController::setChecked2DDatasets(const QStringList& dsIds) {
// 二维足迹始终画进 View3D 场景，且按 dsId 跟踪 → 一律增量 diff（不全量重建，不打断 3D 帘面/体）。
const std::set<std::string> oldSet(checked2dDs_.begin(), checked2dDs_.end());
const std::set<std::string> newSet(newDs.begin(), newDs.end());
// 此前空场景(无 3D 数据且无 2D 足迹) → 首批足迹到场自动取景；否则增量追加保持相机不跳。
const bool wasEmpty = checkedDs_.empty() && checked2dDs_.empty();
for (const auto& id : checked2dDs_)
if (!newSet.count(id)) view_.removeDataset(id); // 取消勾选 → 移除该足迹图元
checked2dDs_ = std::move(newDs);
// 取景基线与 3D 路径统一用 hadArrivedData_（而非"两栏皆空"）：否则二维分析下若已有隐藏的 3D 数据，
// 勾选首条足迹会因 wasEmpty=false 而不取景 → 足迹落在视野外。切 tab 时 onAnalysisModeChanged 已按
// 目标维度是否有数据重置该基线，故此处首条可见维度数据能正确取景。
fitOnArrival_ = !hadArrivedData_;
if (checkedDs_.empty() && checked2dDs_.empty()) hadArrivedData_ = false;
fitOnArrival_ = wasEmpty; // 首批足迹(空场景)取景；否则保持当前相机不跳
// 足迹画进 View3D 场景；mode=0 关闭 → 仅记录勾选不渲染（见 set2DPlacement 切回时补画）。
if (placement2dMode_ != 0 && mode_ == ViewMode::View3D) {
@ -183,17 +145,11 @@ void VtkSceneController::addDatasetAsync(const std::string& dsId, unsigned long
auto cachedGrid = volumeCache_.find(dsId);
auto cachedScale = volumeScaleCache_.find(dsId);
if (cachedGrid != volumeCache_.end() && cachedScale != volumeScaleCache_.end()) {
const QString qid = QString::fromStdString(dsId); // 优先用色阶真源（含已编辑值）
const geopro::core::ColorScale& useCs =
(state_ && state_->colorScale(qid)) ? *state_->colorScale(qid) : cachedScale->second;
view_.addVolume(dsId, cachedGrid->second, useCs); // 缓存命中（色阶随体缓存）
view_.addVolume(dsId, cachedGrid->second, cachedScale->second); // 缓存命中（色阶随体缓存）
onDatasetArrived();
emit volumeRendered(QString::fromStdString(dsId)); // 缓存命中即时完成 → 撤 spinner
emit datasetRendered(QString::fromStdString(dsId));
return;
}
loadingDs_.insert(dsId);
emit datasetLoading(QString::fromStdString(dsId)); // 异步建体开始 → 列表项转 spinner
sceneRepo_.loadVolume(
dsId,
[self, gen, dsId](data::VolumeGrid g, core::ColorScale cs) {
@ -201,19 +157,9 @@ void VtkSceneController::addDatasetAsync(const std::string& dsId, unsigned long
self->loadingDs_.erase(dsId);
if (gen != self->rebuildGeneration_ || !self->isChecked(dsId)) return;
self->volumeScaleCache_[dsId] = cs; // 色阶随体一起缓存（mock 体在 dsRepo_ 无条目）
const QString qid = QString::fromStdString(dsId);
if (self->state_) self->state_->seedColorScale(qid, cs); // 播种真源
auto it = self->volumeCache_.emplace(dsId, std::move(g)).first;
qInfo().noquote() << "[volrender] addVolume dsId=" << qid
<< "nx=" << it->second.vol.nx() << "ny=" << it->second.vol.ny()
<< "nz=" << it->second.vol.nz();
const geopro::core::ColorScale& useCs =
(self->state_ && self->state_->colorScale(qid)) ? *self->state_->colorScale(qid)
: self->volumeScaleCache_[dsId];
self->view_.addVolume(dsId, it->second, useCs);
self->view_.addVolume(dsId, it->second, self->volumeScaleCache_[dsId]);
self->onDatasetArrived();
emit self->volumeRendered(QString::fromStdString(dsId)); // 落地完成 → 撤 spinner
emit self->datasetRendered(QString::fromStdString(dsId));
},
[self, gen, dsId](const std::string& m) {
if (!self) return;
@ -226,22 +172,14 @@ void VtkSceneController::addDatasetAsync(const std::string& dsId, unsigned long
// 剖面 → 帘面（着色用 loadSection 返回的 s.scale，与体的源色阶同源）。
loadingDs_.insert(dsId);
emit datasetLoading(QString::fromStdString(dsId)); // 剖面首次加载较慢 → 列表项转 spinner
sceneRepo_.loadSection(
dsId,
[self, gen, dsId](data::SectionData s) {
if (!self) return;
self->loadingDs_.erase(dsId);
if (gen != self->rebuildGeneration_ || !self->isChecked(dsId)) return; // 作废/已取消
self->sectionGridCache_.insert_or_assign(dsId, s.grid); // 留存源网格供帘面重着色（Grid 无默认构造）
const QString qid = QString::fromStdString(dsId);
if (self->state_) self->state_->seedColorScale(qid, s.scale); // 播种真源
const geopro::core::ColorScale& useCs =
(self->state_ && self->state_->colorScale(qid)) ? *self->state_->colorScale(qid)
: s.scale;
self->view_.addCurtain(dsId, s.grid, useCs);
self->view_.addCurtain(dsId, s.grid, s.scale);
self->onDatasetArrived();
emit self->datasetRendered(QString::fromStdString(dsId)); // 帘面落地 → 复原复选框
},
[self, gen, dsId](const std::string& m) {
if (!self) return;
@ -272,14 +210,6 @@ void VtkSceneController::setViewMode(ViewMode mode) {
rebuildInternal();
}
void VtkSceneController::onAnalysisModeChanged(bool is2D) {
// 切「三维分析/二维分析」tab：按目标维度是否已有数据重置取景基线。
// 目标维度空 → hadArrivedData_=false：切换后该维度第一条数据自动取景(治"3D 数据不知生成到哪")。
// 目标维度非空 → hadArrivedData_=true：视图切换时已 fit 到该维度，后续勾选不再跳(与三维一致)。
// 显隐/相机/坐标轴由 VtkSceneView::setAnalysisMode2D 处理(上层在同一处调用)；此处只管取景基线。
hadArrivedData_ = is2D ? !checked2dDs_.empty() : !checkedDs_.empty();
}
void VtkSceneController::setLayer(SceneLayer layer, bool on) {
switch (layer) {
case SceneLayer::Curtain: showCurtain_ = on; break;
@ -299,25 +229,16 @@ void VtkSceneController::setVerticalExaggeration(double ve) {
preserveCameraOnRebuild_ = false;
}
void VtkSceneController::setVolumeOpacity(double maxOpacity) {
// 运行时更新已渲染体的不透明度传递函数（不重建体，实时跟手）+ 记为后续新体默认（见 VtkSceneView）。
view_.setVolumeOpacity(maxOpacity);
}
void VtkSceneController::rebuild() { rebuildInternal(); }
void VtkSceneController::setVolumeColorScale(const std::string& dsId,
const geopro::core::ColorScale& cs) {
// 统一走色阶真源：写入即广播 colorScaleChanged → recolorDataset 就地重着色（体/帘面+切片），
// 同时 2D 详情等其它视图一并跟随。无 state_（理论不至）才退化为直连重建。
if (state_) {
state_->setColorScale(QString::fromStdString(dsId), cs);
return;
}
volumeScaleCache_[dsId] = cs;
if (!isChecked(dsId)) return;
volumeScaleCache_[dsId] = cs; // 会话级 mock 持久（再勾选命中缓存，见 addDatasetAsync）
if (!isChecked(dsId)) return; // 未渲染 → 仅更缓存，下次勾选生效
auto git = volumeCache_.find(dsId);
if (git == volumeCache_.end()) return;
if (git == volumeCache_.end()) return; // 体网格尚未到场 → 同上
// 移除旧体素 → 以新色阶重建：addVolume 内部置 currentColorScale_ 并触发 onVolumeChanged，
// InteractionManager 据此以新色阶重建该体下已勾选切片。
view_.removeDataset(dsId);
view_.addVolume(dsId, git->second, cs);
view_.renderIncremental();

28
src/controller/VtkSceneController.hpp
View File

@ -1,6 +1,5 @@
#pragma once
#include <QObject>
#include <QPointer>
#include <QString>
#include <QStringList>
#include <map>
@ -19,8 +18,6 @@ class IDatasetRepository;
namespace geopro::controller {
class DatasetViewState; // 跨视图共享色阶真源（统一同步机制）
// 中央视图模式：二维地图（俯视测线）/ 三维视图（帘面/体素/地形）。
enum class ViewMode { Map2D, View3D };
@ -38,10 +35,6 @@ public:
VtkSceneController(data::IDatasetRepository& dsRepo, data::I3dSceneRepository& sceneRepo,
I3dSceneView& view, QObject* parent = nullptr);
// 注入跨视图色阶真源（统一同步）：连 colorScaleChanged → 就地按 dsId 重着色帘面/体。
// 构造后由 main.cpp 注入一次。
void setViewState(DatasetViewState* state);
public slots:
void setCheckedDatasets(const QStringList& dsIds);
// 二维数据集栏勾选（足迹型测线/轨迹）→ 平铺进 View3D 地图。与 3D 勾选集独立，按 dsId 增量。
@ -49,17 +42,12 @@ public slots:
// 二维足迹摆放高度（mode：0关闭 /1 Z=0 /2 顶部 /3 底部 /4 自定义；customZ 仅 mode=4 用）。
void set2DPlacement(int mode, double customZ);
void setViewMode(ViewMode mode);
// 切「三维分析/二维分析」tab（A 期）：按目标维度是否已有数据重置取景基线，使切换后该维度第一条
// 数据自动取景。显隐/相机/坐标轴由 VtkSceneView::setAnalysisMode2D 负责（上层在同一处一并调用）。
void onAnalysisModeChanged(bool is2D);
void setLayer(SceneLayer layer, bool on);
void setVerticalExaggeration(double ve);
// 三维体透明度调节（工具条滑块）：运行时更新已渲染体的不透明度，并作为后续新体默认（0~1）。
void setVolumeOpacity(double maxOpacity);
void rebuild(); // 主题切换等外部触发的重渲染
// 色阶编辑器「确定」：写入色阶真源(state_)，经 colorScaleChanged 统一就地重着色（体/帘面 + 切片）。
// 兼容旧调用点；真正的重着色在 recolorDataset()。无 state_ 时退化为直连重建。
// 色阶编辑器「确定」：更新某三维体色阶并就地重渲染（体素 + 其切片随新色阶重建）。
// 后端 3D 色阶保存未就绪 → 缓存即会话级 mock 持久（再勾选命中 volumeScaleCache_）。
void setVolumeColorScale(const std::string& dsId, const geopro::core::ColorScale& cs);
// ── P2 三维数据集栏 ──
@ -75,17 +63,9 @@ public slots:
signals:
void loadFailed(const QString& message);
// 三维体异步建体+落地渲染完成（dsId）。供 UI 撤回该体列表项的等待 spinner、复原复选框。
void volumeRendered(const QString& dsId);
// 任一数据集（剖面/体）异步加载开始 / 渲染完成：上层据此把该列表项复选框↔等待 spinner 切换。
// 仅异步路径发（缓存命中即时完成只发 rendered）；覆盖非三维体（剖面首次渲染也较慢，用户反馈）。
void datasetLoading(const QString& dsId);
void datasetRendered(const QString& dsId);
private:
void rebuildInternal();
// colorScaleChanged(dsId) 槽：从 state_ 取新色阶，就地重建该 dsId 的帘面/体（及体下切片）。只渲染，不回写。
void recolorDataset(const QString& dsId);
// 增量加入单个 ds（帘面/体素，按图层开关）；回调按 gen + 仍勾选 守护，落地后增量渲染。
void addDatasetAsync(const std::string& dsId, unsigned long long gen);
// 增量加入单个 2D 足迹（异步 loadMapLine → addMapLine at 当前摆放 Z）；回调按 gen + 仍勾选 守护。
@ -122,13 +102,9 @@ private:
AxisRangeCfg axisX_, axisY_, axisZ_; // 坐标轴设置面板的 per-axis 可见性 + 自定义范围
static constexpr int kAxesFontSize = 12;
QPointer<DatasetViewState> state_; // 跨视图色阶真源（注入；编辑/加载/重着色都经它；QPointer 防悬挂）
// 缓存（按 dsId）：避免重复读盘/插值。
std::map<std::string, geopro::core::Grid> gridCache_;
std::map<std::string, geopro::core::ColorScale> colorScaleCache_;
// 帘面源网格缓存：帘面重着色需 grid 重建 addCurtain（loadSection 的 s.grid 不在 gridCache_）。
std::map<std::string, geopro::core::Grid> sectionGridCache_;
std::map<std::string, data::VolumeGrid> volumeCache_;
// 三维体色阶缓存：mock 体在 dsRepo_ 无条目，色阶随 loadVolume 一起交付并缓存于此。
std::map<std::string, geopro::core::ColorScale> volumeScaleCache_;

170
src/core/algo/VolumeBuilder.cpp
View File

@ -3,12 +3,10 @@
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <numeric>
#include <stdexcept>
#include <unordered_map>
#include <vector>
#include "algo/IdwInterpolator.hpp"
namespace geopro::core {
@ -26,64 +24,10 @@ void fitAxis(double ext, double cell, double& outCell, int& outN) {
outN = kMaxVolumeDim;
outCell = ext / static_cast<double>(kMaxVolumeDim - 1); // maxDim 格覆盖全 ext
}
// 平面凸包（Andrew monotone chain，返回 CCW 顶点；末点=首点已去重）。点 <3 / 共线退化 → 空。
struct Hull2D { std::vector<double> x, y; };
// (A-O) × (B-O)：>0 表示 B 在有向边 O→A 左侧。
double cross2(double ox, double oy, double ax, double ay, double bx, double by) {
return (ax - ox) * (by - oy) - (ay - oy) * (bx - ox);
}
Hull2D convexHull2D(const std::vector<double>& xs, const std::vector<double>& ys) {
Hull2D hull;
const std::size_t n = xs.size();
if (n < 3) return hull;
std::vector<std::size_t> idx(n);
for (std::size_t i = 0; i < n; ++i) idx[i] = i;
std::sort(idx.begin(), idx.end(), [&](std::size_t a, std::size_t b) {
return xs[a] < xs[b] || (xs[a] == xs[b] && ys[a] < ys[b]);
});
std::vector<std::size_t> h(2 * n);
int k = 0;
for (std::size_t ii = 0; ii < n; ++ii) { // 下凸包
const std::size_t i = idx[ii];
while (k >= 2 &&
cross2(xs[h[k - 2]], ys[h[k - 2]], xs[h[k - 1]], ys[h[k - 1]], xs[i], ys[i]) <= 0)
--k;
h[k++] = i;
}
const int lower = k + 1;
for (std::size_t ii = n; ii-- > 0;) { // 上凸包
const std::size_t i = idx[ii];
while (k >= lower &&
cross2(xs[h[k - 2]], ys[h[k - 2]], xs[h[k - 1]], ys[h[k - 1]], xs[i], ys[i]) <= 0)
--k;
h[k++] = i;
}
if (k - 1 < 3) return hull; // 去末点后仍 <3 → 退化
hull.x.reserve(k - 1); hull.y.reserve(k - 1);
for (int t = 0; t < k - 1; ++t) { hull.x.push_back(xs[h[t]]); hull.y.push_back(ys[h[t]]); }
return hull;
}
// 点是否在 CCW 凸多边形内（含边界），buf=向外缓冲（米，保边界整列不被误裁）。
bool inHull(const Hull2D& hull, double px, double py, double buf) {
const std::size_t m = hull.x.size();
for (std::size_t i = 0; i < m; ++i) {
const std::size_t j = (i + 1) % m;
const double ex = hull.x[j] - hull.x[i], ey = hull.y[j] - hull.y[i];
const double len = std::sqrt(ex * ex + ey * ey);
const double c = cross2(hull.x[i], hull.y[i], hull.x[j], hull.y[j], px, py);
// c/len = 点到该边的有符号垂距(内侧为正)；< -buf 即在多边形外超过缓冲 → 排除。
if (len > 0.0 && c < -buf * len) return false;
}
return true;
}
} // namespace
BuiltVolume buildVolume(const PointSet& pts, double cellXY, double cellZ,
double power, double maxDist, bool clipToFootprint) {
double power, double maxDist) {
if (pts.v.empty()) {
throw std::invalid_argument("buildVolume: empty point set");
}
@ -106,111 +50,11 @@ BuiltVolume buildVolume(const PointSet& pts, double cellXY, double cellZ,
fitAxis(maxy - miny, cellXY, spec.dy, spec.ny);
fitAxis(maxz - minz, cellZ, spec.dz, spec.nz);
spec.power = power;
spec.maxDist = maxDist;
// 节点封顶：真实数据(大测区/小 cell)易逼近 kMaxVolumeDim³ → IDW 卡死。超 kMaxNodes 等比放大三轴 cell。
{
constexpr long long kMaxNodes = 4'000'000;
const long long tot = 1LL * spec.nx * spec.ny * spec.nz;
if (tot > kMaxNodes) {
const double s = std::cbrt(static_cast<double>(tot) / static_cast<double>(kMaxNodes));
spec.dx *= s; spec.dy *= s; spec.dz *= s;
auto rc = [](double ext, double cell) { int n = static_cast<int>(ext / cell) + 1; return n < 1 ? 1 : n; };
spec.nx = rc(maxx - minx, spec.dx);
spec.ny = rc(maxy - miny, spec.dy);
spec.nz = rc(maxz - minz, spec.dz);
}
}
// 退化维补一层：若某横/竖向范围 < 一个 cell（如共面/共线剖面 → 该向仅 1 层），vtkGPUVolumeRayCastMapper
// 无法对「1 层厚的体」(本质 2D)体绘制 → 报 vtkExecutive 错误、什么都渲染不出来。补到 2 层 → 成薄板可渲。
spec.nx = std::max(spec.nx, 2);
spec.ny = std::max(spec.ny, 2);
spec.nz = std::max(spec.nz, 2);
// 各向异性搜索半径（实测：对角线全域 IDW 对真实井字数据=每节点求和全部点→卡死；井字线间最大空隙
// 仅 ~20m，故水平半径 auto=0.2×XY 对角线[限 12~60m] 足以跨格填满而非全域；垂直限带→剖面深向密
// 采、带内必有点，既不混深度又把候选点经「按 z 排序+二分定带」剪到深度邻域，避免卡死）。
const double exX = maxx - minx, exY = maxy - miny;
const double xydiag = std::sqrt(exX * exX + exY * exY);
// 水平半径 auto = XY 对角线 → 填满整个凸包足迹（对齐 Surfer Blanking 后的实心体）。实测因抽稀
// + z-带垂直剪枝，大半径与小半径耗时几乎一致（~2.8s/真实赣州 4 线），故取满填。
const double maxDistH = (maxDist > 0.0) ? maxDist : (xydiag > 0.0 ? xydiag : 1.0);
const double maxDistV = std::max(6.0 * spec.dz, 2.0);
spec.maxDist = maxDistH; // 记录（属性页/诊断）
// 点抽稀到网格分辨率：剖面 ~0.4m 采样远密于网格 → 按 (dx,dy,dz) 体素聚合(质心+均值)，
// 大幅减候选点、不损可视化分辨率。
struct ThinAcc { double sx = 0, sy = 0, sz = 0, sv = 0; int c = 0; };
std::unordered_map<long long, ThinAcc> tmap;
tmap.reserve(pts.v.size());
auto keyOf = [&](double x, double y, double z) -> long long {
const long long ix = static_cast<long long>(std::floor((x - minx) / spec.dx));
const long long iy = static_cast<long long>(std::floor((y - miny) / spec.dy));
const long long iz = static_cast<long long>(std::floor((z - minz) / spec.dz));
return (ix * 73856093LL) ^ (iy * 19349663LL) ^ (iz * 83492791LL);
};
for (std::size_t i = 0; i < pts.v.size(); ++i) {
ThinAcc& a = tmap[keyOf(pts.x[i], pts.y[i], pts.z[i])];
a.sx += pts.x[i]; a.sy += pts.y[i]; a.sz += pts.z[i]; a.sv += pts.v[i]; ++a.c;
}
std::vector<double> tx, ty, tz, tv;
tx.reserve(tmap.size()); ty.reserve(tmap.size()); tz.reserve(tmap.size()); tv.reserve(tmap.size());
for (const auto& kv : tmap) {
const ThinAcc& a = kv.second;
tx.push_back(a.sx / a.c); ty.push_back(a.sy / a.c);
tz.push_back(a.sz / a.c); tv.push_back(a.sv / a.c);
}
const std::size_t nt = tv.size();
// 抽稀点按 z 升序 → 每深度切片二分定 [gz-V, gz+V] 带，仅遍历带内点。
std::vector<std::size_t> order(nt);
std::iota(order.begin(), order.end(), std::size_t{0});
std::sort(order.begin(), order.end(), [&](std::size_t a, std::size_t b) { return tz[a] < tz[b]; });
std::vector<double> zs(nt);
for (std::size_t t = 0; t < nt; ++t) zs[t] = tz[order[t]];
// 足迹凸包（用原始点；退化 <3/共线 → 空 → 跳过裁剪）。
const Hull2D hull = clipToFootprint ? convexHull2D(pts.x, pts.y) : Hull2D{};
const bool useClip = hull.x.size() >= 3;
const double buf = 0.5 * std::max(spec.dx, spec.dy);
// 3) 各向异性 z-带 IDW（凸包外/带内无点 → NaN 留空）。
ScalarVolume vol(spec.nx, spec.ny, spec.nz);
const double nan = std::numeric_limits<double>::quiet_NaN();
const double maxH2 = maxDistH * maxDistH;
const bool fastPow2 = (power == 2.0);
const double halfPow = power * 0.5;
for (int k = 0; k < spec.nz; ++k) {
const double gz = spec.oz + k * spec.dz;
const std::size_t lo = static_cast<std::size_t>(
std::lower_bound(zs.begin(), zs.end(), gz - maxDistV) - zs.begin());
const std::size_t hi = static_cast<std::size_t>(
std::upper_bound(zs.begin(), zs.end(), gz + maxDistV) - zs.begin());
for (int j = 0; j < spec.ny; ++j) {
const double gy = spec.oy + j * spec.dy;
for (int i = 0; i < spec.nx; ++i) {
const double gx = spec.ox + i * spec.dx;
if (useClip && !inHull(hull, gx, gy, buf)) { vol.at(i, j, k) = nan; continue; }
double wsum = 0.0, vsum = 0.0;
bool any = false, hit = false; double hitVal = 0.0;
for (std::size_t t = lo; t < hi; ++t) {
const std::size_t p = order[t];
const double ddx = gx - tx[p], ddy = gy - ty[p];
const double h2 = ddx * ddx + ddy * ddy;
if (h2 > maxH2) continue; // 超水平半径
const double ddz = gz - tz[p];
const double d2 = h2 + ddz * ddz;
any = true;
if (d2 < 1e-12) { hit = true; hitVal = tv[p]; break; }
const double w = fastPow2 ? (1.0 / d2) : std::pow(d2, -halfPow);
wsum += w; vsum += w * tv[p];
}
if (hit) vol.at(i, j, k) = hitVal;
else if (!any || wsum == 0.0) vol.at(i, j, k) = nan;
else vol.at(i, j, k) = vsum / wsum;
}
}
}
// 3) IDW（maxDist 外 NaN 留空）。
const IdwInterpolator idw;
ScalarVolume vol = idw.interpolate(pts, spec);
// 4) 数据实测值域（仅有限值）。无有限值 → 退化 {0,1}。
double vmin = std::numeric_limits<double>::infinity();

10
src/core/algo/VolumeBuilder.hpp
View File

@ -20,15 +20,7 @@ struct BuiltVolume {
// 前置：pts 须含 ≥1 点（空集抛 std::invalid_argument）。
// 确定性：同点集同参数 → 同 GridSpec 同体（不冻结 spec，见计划 §1 决策）。
// 提取自 LocalSample3dRepository::loadVolume，供本地样本 / 真实 Api 共享，消除调参漂移。
//
// maxDist 语义（对齐客户 Surfer：XYZC + IDW + 边界 Blanking，见
// docs/superpowers/specs/2026-06-27-inversion-3d-volume-surfer-method-and-gaps.md）：
// - maxDist > 0：局部 IDW 半径（超距 blank），偏快、剖面附近清晰，但跨大空隙可能填不满。
// - maxDist <= 0：自动「覆盖测区」——半径取包络对角线，域内每点取到全部散点（≈Surfer 用全数据）。
// clipToFootprint=true（默认）：用散点平面**凸包**做足迹裁剪，凸包外网格列整列置空（≈Surfer 用
// 边界多边形 Blanking）。避免单纯放大半径把体鼓满外接盒（"变粗"的根因）。
// 退化（散点 <3 / 平面近共线，如单条剖面）→ 自动跳过裁剪。
BuiltVolume buildVolume(const PointSet& pts, double cellXY, double cellZ,
double power, double maxDist, bool clipToFootprint = true);
double power, double maxDist);
} // namespace geopro::core

6
src/core/model/ColorScale.hpp
View File

@ -23,16 +23,10 @@ public:
void setOver(Rgba c) { over_ = c; }
void setNan(Rgba c) { nan_ = c; }
bool empty() const { return stops_.empty(); }
// 整体透明度（两级透明度的第二级）：与每色 alpha 相乘，渲染时才叠加，绝不烘焙进 stop。
// [0,1]，默认 1（不透明）。独立存储 → 色阶编辑可回显真实值、单色 alpha 保持独立。
void setGlobalOpacity(double o) { globalOpacity_ = o; }
double globalOpacity() const { return globalOpacity_; }
private:
struct Stop { double value; Rgba color; };
std::vector<Stop> stops_;
std::optional<Rgba> under_, over_, nan_;
double globalOpacity_ = 1.0;
};
} // namespace geopro::core

4
src/core/model/detail/DetailPayloads.hpp
View File

@ -1,6 +1,5 @@
#pragma once
#include <vector>
#include <QJsonObject>
#include <QMetaType>
#include <QString>
#include "model/Field.hpp"
@ -42,9 +41,6 @@ struct ScatterPayload {
// 色阶模板 id（来自 lvl/colorGradation/getDetail 的 templateId）：保存色阶时回带
// （对照原版 newLvlColorLevel 带读取到的 templateId；可空）。
QString templateId;
// type1 原始 properties（lineConfig/labelConfig/层级方案）：保存色阶时只覆盖 colorBar+opacity、
// 其余原样回写，避免清掉网格(共用同一条 businessCode="" 记录)设过的等值线/层级值（对齐原版 load-then-save）。
QJsonObject properties;
};
// 等值面载荷：grid(rows) + 色阶 + 异常（≈ data::GridParts）。

8
src/data/GprVolumeRepository.cpp
View File

@ -36,14 +36,12 @@ VolumeGrid builtI16ToVolumeGrid(const geopro::core::BuiltI16& built) {
}
VolumeGrid createGprVolumeGrid(const std::string& lineDir,
const std::string& linePrefix, int coarse,
double targetDy) {
const std::string& linePrefix, int coarse) {
// 走 P1/P2 链(io::gpr)得处理后 int16 量化体 → 反量化为 app 的 float 体。
// metricsOut 传 nullptr：repository 只产数据，度量留给 gpr_poc CLI。
// targetDy 透传 → 默认走线内通道插值(2.5cm 网格)，app 渲染链即得密 Y 体。
const geopro::core::BuiltI16 built =
geopro::io::gpr::buildLineVolumeFromGpr3dv(
lineDir, linePrefix, /*metricsOut=*/nullptr, coarse, targetDy);
geopro::io::gpr::buildLineVolumeFromGpr3dv(lineDir, linePrefix,
/*metricsOut=*/nullptr, coarse);
return builtI16ToVolumeGrid(built);
}

5
src/data/GprVolumeRepository.hpp
View File

@ -26,12 +26,9 @@ VolumeGrid builtI16ToVolumeGrid(const geopro::core::BuiltI16& built);
// lineDir/linePrefix 同 gpr3dv-smoke / build-line(如 "D:/Downloads/明星路", "明星路_001")。
// coarse(下采样因子，≥1)：沿测线(道/X 轴)每 coarse 道取 1，省内存；横向/深度保全分辨率。
// 稠密 VolumeGrid 全内存，长线需较大 coarse 控内存(默认 4 = build-line POC 档)。
// targetDy(米，>0 启用)：线内【通道间插值】目标横向间距(读真实道偏移规则化，不跨线)。
// 默认 0.025(2.5cm)；0=不插值(Y=原通道数)。详见 io::gpr::buildLineVolumeFromGpr3dv。
// 失败(加载失败/立方体为空)→ 抛 std::runtime_error(由 io::gpr 链抛出，原样透传)。
VolumeGrid createGprVolumeGrid(const std::string& lineDir,
const std::string& linePrefix, int coarse = 4,
double targetDy = 0.025);
const std::string& linePrefix, int coarse = 4);
} // namespace geopro::data

166
src/data/api/Api3dRepository.cpp
View File

@ -1,6 +1,5 @@
#include "api/Api3dRepository.hpp"
#include <QCoreApplication>
#include <QDateTime>
#include <QDebug>
#include <QJsonDocument>
@ -8,19 +7,14 @@
#include <QString>
#include <QVariant>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <exception>
#include <memory>
#include <thread>
#include <tuple>
#include <utility>
#include "algo/VolumeBuilder.hpp" // core::PointSet / BuiltVolume / buildVolume（含 Field.hpp）
#include "api/DatasetLoadHandles.hpp"
#include "GprVolumeRepository.hpp" // createGprVolumeGrid（§6 接入：GPR 体直产）
#include "model/ColorScale.hpp"
#include "model/detail/DetailPayloads.hpp"
#include "repo/IAsyncDatasetRepository.hpp"
@ -44,9 +38,11 @@ DsDimension Api3dRepository::dimensionOf(const DsRow& ds) const {
return DsDimension::Dim3D;
}
if (c == "dd_slice") return DsDimension::Analysis3D;
// 足迹型 → 二维数据集：地面 lat/lon 序列，平铺进地图。dd_trajectory_data = 统一通用轨迹
// (数据字典 DD0623「保留」，已并入 dd_radar_rtk_trajectory)；瞬变电磁/雷达通道/RTK 轨迹字典均「删除」。
if (c == "dd_trajectory_data") return DsDimension::Dim2D;
// 足迹型(测线/各类轨迹) → 二维数据集：地面 lat/lon 序列，平铺进地图（spec §4.1/§4.2）。
if (c == "dd_trajectory_data" || c == "dd_transient_electromagnetic_trajectory_data" ||
c == "dd_radar_channel_trajectory" || c == "dd_radar_rtk_trajectory") {
return DsDimension::Dim2D;
}
return DsDimension::Other;
}
@ -125,41 +121,11 @@ std::string Api3dRepository::createVolume(const VoxelGenerateRequest& req) {
return id;
}
std::string Api3dRepository::createGprVolume(const std::string& lineDir,
const std::string& linePrefix,
const std::string& name, int coarse) {
// 走 io::gpr 逐线管线（含线内通道插值）直接产体（抛异常透传给调用方）。
VolumeGrid grid = geopro::data::createGprVolumeGrid(lineDir, linePrefix, coarse);
// 简易灰度色阶（负→暗、零→灰、正→亮）覆盖体值域，使体素渲染可见。
core::ColorScale scale;
const double mid = 0.5 * (grid.vmin + grid.vmax);
scale.addStop(grid.vmin, core::Rgba{20, 24, 40, 255});
scale.addStop(mid, core::Rgba{140, 140, 150, 255});
scale.addStop(grid.vmax, core::Rgba{235, 232, 220, 255});
const std::string id = "vol-" + std::to_string(++volumeCounter_);
StoredVolume sv;
sv.name = name;
sv.createTime =
QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd HH:mm")).toStdString();
sv.cachedGrid = std::move(grid); // 预填 → loadVolume 直接命中渲染（不走 mock IDW）
sv.cachedScale = scale;
volumes_[id] = std::move(sv);
return id;
}
const VoxelGenerateRequest* Api3dRepository::lastVoxelRequest(const std::string& dsId) const {
const auto it = volumes_.find(dsId);
return (it != volumes_.end() && it->second.request) ? &*it->second.request : nullptr;
}
void Api3dRepository::clearMockData() {
// 切换项目：清空内存态三维体/切片/异常，避免上个项目的产物残留进新项目列表。
volumes_.clear();
slices_.clear();
anomalies_.clear();
}
std::vector<DsRow> Api3dRepository::volumeRows() const {
std::vector<DsRow> rows;
rows.reserve(volumes_.size());
@ -242,19 +208,6 @@ void Api3dRepository::appendGridPoints(const core::Grid& g, core::PointSet& pts)
}
}
void Api3dRepository::loadSectionWithRetry(const std::string& dsId, int attemptsLeft,
std::function<void(SectionData)> onOk, OnError onErr) {
loadSection(dsId, onOk, [this, dsId, attemptsLeft, onOk, onErr](const std::string& m) {
if (attemptsLeft > 0) { // 瞬时失败（502 等）→ 重试，不立刻判整体失败
qInfo().noquote() << "[volbuild] source" << QString::fromStdString(dsId)
<< "加载失败，重试(剩" << attemptsLeft << "次):" << QString::fromStdString(m);
loadSectionWithRetry(dsId, attemptsLeft - 1, onOk, onErr);
return;
}
onErr(m);
});
}
void Api3dRepository::finalizeVolume(const std::string& dsId, const core::PointSet& pts,
const core::ColorScale& scale,
const VolumeBuildParams& params,
@ -264,75 +217,34 @@ void Api3dRepository::finalizeVolume(const std::string& dsId, const core::PointS
onErr("Api3dRepository::loadVolume: 配准后无有效散点（源数据为空或全无数据）");
return;
}
// 重 IDW 建体放后台线程，避免阻塞 UI（用户要求：渲染必须异步）。纯计算（无 Qt/VTK），算完
// 经事件循环回主线程做缓存 + 交付（缓存写 volumes_ / onOk 触碰 VTK 必须在主线程）。
// 兜底：无 QCoreApplication（headless/单测）时退化为同步，保证可测/可离屏。
auto deliver = [this, dsId, scale, onOk, onErr](std::shared_ptr<geopro::core::BuiltVolume> bv,
std::string err, std::size_t nPts) {
if (!bv) {
onErr(std::string("Api3dRepository::loadVolume: ") + err);
return;
}
double vmin = bv->vmin, vmax = bv->vmax;
try {
geopro::core::BuiltVolume bv =
geopro::core::buildVolume(pts, params.cellXY, params.cellZ, params.power, params.maxDist);
// 值域：优先色阶分段值，否则 buildVolume 的数据实测范围。
double vmin = bv.vmin, vmax = bv.vmax;
const std::vector<double> stops = scale.stopValues();
if (stops.size() >= 2) {
vmin = stops.front();
vmax = stops.back();
}
qInfo().noquote() << "[volbuild] finalize pts=" << nPts << "grid" << bv->spec.nx << "x"
<< bv->spec.ny << "x" << bv->spec.nz << "origin" << bv->spec.ox
<< bv->spec.oy << bv->spec.oz << "spacing" << bv->spec.dx << bv->spec.dy
<< bv->spec.dz;
VolumeGrid out{std::move(bv->vol),
{{bv->spec.ox, bv->spec.oy, bv->spec.oz}},
{{bv->spec.dx, bv->spec.dy, bv->spec.dz}},
qInfo().noquote() << "[volbuild] finalize pts=" << pts.v.size() << "grid"
<< bv.spec.nx << "x" << bv.spec.ny << "x" << bv.spec.nz
<< "origin" << bv.spec.ox << bv.spec.oy << bv.spec.oz << "spacing"
<< bv.spec.dx << bv.spec.dy << bv.spec.dz;
VolumeGrid out{std::move(bv.vol),
{{bv.spec.ox, bv.spec.oy, bv.spec.oz}},
{{bv.spec.dx, bv.spec.dy, bv.spec.dz}},
vmin, vmax};
auto it = volumes_.find(dsId);
if (it != volumes_.end()) { // 缓存明细 + 色阶（下次命中即跳重算）
it->second.cachedGrid = out;
it->second.cachedScale = scale;
it->second.pointCount = nPts; // 持久化聚合散点数（详情统计用）
it->second.pointCount = pts.v.size(); // 持久化聚合散点数（详情统计用）
}
onOk(std::move(out), scale);
};
// 纯计算闭包：返回 (built|nullptr, err, nPts)。
auto compute = [pts, params]() {
std::shared_ptr<geopro::core::BuiltVolume> bv;
std::string err;
try {
bv = std::make_shared<geopro::core::BuiltVolume>(geopro::core::buildVolume(
pts, params.cellXY, params.cellZ, params.power, params.maxDist));
} catch (const std::exception& e) {
err = e.what();
onErr(std::string("Api3dRepository::loadVolume: ") + e.what());
}
return std::make_tuple(bv, err, pts.v.size());
};
qInfo().noquote() << "[volbuild] start dsId=" << QString::fromStdString(dsId)
<< "pts=" << pts.v.size() << "async=" << (QCoreApplication::instance() != nullptr);
if (!QCoreApplication::instance()) { // 无事件循环（headless/单测）→ 同步
auto res = compute();
deliver(std::get<0>(res), std::get<1>(res), std::get<2>(res));
return;
}
std::thread([compute, deliver, dsId]() mutable {
const auto t0 = std::chrono::steady_clock::now();
auto res = compute();
auto bv = std::get<0>(res); // 具名变量（非结构化绑定）→ C++17 可被 lambda 捕获
auto err = std::get<1>(res);
auto nPts = std::get<2>(res);
const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - t0).count();
qInfo().noquote() << "[volbuild] computed dsId=" << QString::fromStdString(dsId)
<< "ms=" << ms << "ok=" << (bv != nullptr);
// 回主线程交付（QueuedConnection；qApp 为主线程对象，存活于整个会话）。
QMetaObject::invokeMethod(
qApp,
[deliver, bv, err, nPts]() mutable { deliver(std::move(bv), std::move(err), nPts); },
Qt::QueuedConnection);
}).detach();
}
void Api3dRepository::loadVolume(const std::string& dsId,
@ -360,14 +272,15 @@ void Api3dRepository::loadVolume(const std::string& dsId,
int pending;
bool failed = false;
core::PointSet pts;
std::vector<core::ColorScale> scales; // 收集所有源色阶 → 取 vmax 中位者定值域（不依赖到达顺序）
core::ColorScale scale; // 取首个到达源的色阶定值域
bool haveScale = false;
};
auto agg = std::make_shared<Agg>();
agg->pending = static_cast<int>(params.sourceDatasetIds.size());
for (const std::string& srcId : params.sourceDatasetIds) {
loadSectionWithRetry(
srcId, /*attemptsLeft=*/2,
loadSection(
srcId,
[this, dsId, srcId, params, agg, onOk, onErr](SectionData s) {
if (agg->failed) return;
const std::size_t before = agg->pts.v.size();
@ -376,20 +289,12 @@ void Api3dRepository::loadVolume(const std::string& dsId,
<< "grid" << s.grid.nx() << "x" << s.grid.ny() << "-> +"
<< (agg->pts.v.size() - before) << "pts (total"
<< agg->pts.v.size() << ")";
agg->scales.push_back(s.scale);
if (!agg->haveScale) {
agg->scale = s.scale;
agg->haveScale = true;
}
if (--agg->pending > 0) return; // 还有源未到齐
// 值域定法（修偶发"淡蓝/几乎不可见"根因）：旧逻辑取「首个到达源」的色阶 → 多条线值域
// 不一(如多条 2168、一条 24550)时随异步到达顺序抖动；取到大值域那条会把数据全压到
// 色阶低端→全蓝近透明。改为取所有源色阶按 vmax 排序的中位者：确定性(去到达顺序依赖)
// + 抗单条线值域离群 → 多数线的正常值域稳定胜出。
auto& ss = agg->scales;
std::sort(ss.begin(), ss.end(),
[](const core::ColorScale& a, const core::ColorScale& b) {
const auto av = a.stopValues(), bv = b.stopValues();
return (av.empty() ? 0.0 : av.back()) < (bv.empty() ? 0.0 : bv.back());
});
const core::ColorScale chosen = ss.empty() ? core::ColorScale{} : ss[ss.size() / 2];
finalizeVolume(dsId, agg->pts, chosen, params, onOk, onErr);
finalizeVolume(dsId, agg->pts, agg->scale, params, onOk, onErr);
},
[agg, onErr](const std::string& m) {
if (agg->failed) return;
@ -477,21 +382,6 @@ void Api3dRepository::deleteSlice(const std::string& dsId, std::function<void()>
onOk();
}
void Api3dRepository::setSliceColorScale(const std::string& dsId,
const geopro::core::ColorScale& cs) {
auto it = slices_.find(dsId);
if (it == slices_.end()) return;
it->second.colorScale = cs; // 切片独立色阶（mock；真实后端走该切片 dsId 的 colorGradation）
it->second.hasColorScale = true;
}
bool Api3dRepository::sliceColorScale(const std::string& dsId, geopro::core::ColorScale& out) const {
auto it = slices_.find(dsId);
if (it == slices_.end() || !it->second.hasColorScale) return false;
out = it->second.colorScale;
return true;
}
// ── 异常 / 异常体（后端真实端点存在，但异常挂三维体、三维体仍 mock → 异常暂内存 mock；
// 挂载结构按"异常→三维体"，整链端点就绪后切真实，见记忆 vtk-3d-persistence-structure）──

16
src/data/api/Api3dRepository.hpp
View File

@ -42,16 +42,8 @@ public:
std::string createVolume(VolumeBuildParams params, const std::string& name);
// 请求体形态创建：组装真实 VoxelGenerateRequest → 派生 params 存储 + 打印请求体 JSON（供后端联调）。
std::string createVolume(const VoxelGenerateRequest& req);
// GPR 三维体：走 io::gpr 逐线管线（含线内通道插值，§1）直接产体并【预填 cachedGrid】，
// 注册为 dd_voxel 体 → 自动进 volumeRows/三级树，loadVolume 直接命中渲染（不走 mock IDW）。
// lineDir/linePrefix 同 build-line（如 "D:/Downloads/明星路","明星路_010"）；coarse 控内存。
// 返回新 dsId；失败抛 std::runtime_error（加载/立方体空，由 io::gpr 链透传）。
std::string createGprVolume(const std::string& lineDir, const std::string& linePrefix,
const std::string& name, int coarse = 8);
// 取回某三维体组装的请求体（测试/联调）；非本 repo 创建或无 request 时返回 nullptr。
const VoxelGenerateRequest* lastVoxelRequest(const std::string& dsId) const;
// 清空内存态三维体/切片/异常（切换项目时调；否则上个项目的体/切片/异常残留在新项目列表）。
void clearMockData();
// 已创建三维体的列表行（ddCode="dd_voxel"），供三维分析栏合并注入（每次 setDatasets 追加）。
std::vector<DsRow> volumeRows() const;
@ -98,8 +90,6 @@ public:
std::function<void()> onOk, OnError onErr) override;
void deleteSlice(const std::string& dsId,
std::function<void()> onOk, OnError onErr) override;
void setSliceColorScale(const std::string& dsId, const geopro::core::ColorScale& cs) override;
bool sliceColorScale(const std::string& dsId, geopro::core::ColorScale& out) const override;
// 异常 / 异常体（后端未就绪 → load 回空树，变更走 onErr）
void loadAnomalyTree(const std::string& objectId,
@ -123,10 +113,6 @@ private:
// 把一条剖面 section grid 的有限值节点按 CurtainActor 同口径定位（lat/lon→frame.toLocal，
// 世界 Z=grid.y 高程）追加为 IDW 散点 → 保证体与帘面同系对齐。
void appendGridPoints(const core::Grid& g, core::PointSet& pts) const;
// 源剖面带重试加载：瞬时失败（如后端 502 Bad Gateway）重试 attemptsLeft 次，避免一条源抖动
// 就让整个三维体建不出来（表现为"连坐标轴都没有"的无声不渲染）。重试用尽才 onErr。
void loadSectionWithRetry(const std::string& dsId, int attemptsLeft,
std::function<void(SectionData)> onOk, OnError onErr);
// 多源散点聚合完成 → buildVolume + 值域 + 缓存明细/色阶 → onOk(体, 色阶)。
void finalizeVolume(const std::string& dsId, const core::PointSet& pts,
const core::ColorScale& scale, const VolumeBuildParams& params,
@ -153,8 +139,6 @@ private:
SliceSpec spec;
std::string name;
std::string createTime; // 创建时刻
geopro::core::ColorScale colorScale; // 切片自己的色阶（颜色快照 + 不透明度并入 globalOpacity）
bool hasColorScale = false; // 是否已设过独立色阶（否则还原时跟随三维体）
};
std::map<std::string, StoredSlice> slices_; // dsId → 切片
int sliceCounter_ = 0;

7
src/data/api/ApiDatasetCommandRepository.cpp
View File

@ -387,13 +387,6 @@ void ApiDatasetCommandRepository::listExceptionTypes(
std::move(cb));
}
void ApiDatasetCommandRepository::getExceptionTypeDetail(
const QString& exceptionTypeId, std::function<void(bool, QJsonObject, QString)> cb) {
wireObject(api_.getAsync(QStringLiteral("/business/exceptionType/getDetail/%1")
.arg(enc(exceptionTypeId))),
std::move(cb));
}
void ApiDatasetCommandRepository::listArrayTypes(
std::function<void(bool, QJsonArray, QString)> cb) {
wireArray(api_.getAsync(QStringLiteral("/business/script/arrayTypeList")), std::move(cb));

3
src/data/api/ApiDatasetCommandRepository.hpp
View File

@ -81,9 +81,6 @@ public:
void listExceptionTypes(
const QString& projectId, const QString& remarkSourceType,
std::function<void(bool ok, QJsonArray list, QString msg)> cb) override;
void getExceptionTypeDetail(
const QString& exceptionTypeId,
std::function<void(bool ok, QJsonObject data, QString msg)> cb) override;
void listArrayTypes(std::function<void(bool ok, QJsonArray list, QString msg)> cb) override;
void getExceptionName(
const QString& exceptionTypeId, const QString& remarkSourceId,

4
src/data/api/ApiDatasetRepository.cpp
View File

@ -28,7 +28,6 @@ struct ChartParts {
geopro::core::ScatterField scatter;
geopro::core::ColorScale scatterScale;
QString templateId; // 散点色阶模板 id（保存色阶回带，对照原版 lvlTemplateId）
QJsonObject scatterProperties; // type1 记录原始 properties（保存时回写 lineConfig/层级，不覆盖网格的值）
};
// 网格数据加载结果：grid(rows) + 网格色阶(type2) + 异常。
struct GridParts {
@ -62,8 +61,6 @@ ChartParts parseScatterParts(const QList<net::ApiResponse>& r) {
p.scatter = dto::parseScatterGraph(r[0].data);
p.scatterScale = dto::parseColorBar(r[1].data);
p.templateId = r[1].data.value(QStringLiteral("templateId")).toVariant().toString();
// 原始 properties（含 lineConfig/labelConfig/层级方案）：保存色阶时原样回写，避免清掉网格(共用同条记录)的值。
p.scatterProperties = r[1].data.value(QStringLiteral("properties")).toObject();
return p;
}
@ -178,7 +175,6 @@ DetailLoad* ApiDatasetRepository::makeInversionScatter(const std::string& dsId)
ChartParts p = parseScatterParts(r);
core::ScatterPayload payload{p.scatter, p.scatterScale};
payload.templateId = p.templateId; // 色阶保存回带（对照原版 lvlTemplateId）
payload.properties = p.scatterProperties; // 原始 properties → 保存时回写非 colorBar 字段
return QVariant::fromValue(payload);
});
}

5
src/data/dto/DatasetChartDto.cpp
View File

@ -47,10 +47,7 @@ ScatterField parseScatterGraph(const QJsonObject& data) {
ColorScale parseColorBar(const QJsonObject& data) {
ColorScale cs;
const QJsonObject props = data.value("properties").toObject();
// 整体透明度（两级第二级）：properties.opacity，缺省 1（不透明）。
if (props.contains("opacity")) cs.setGlobalOpacity(props.value("opacity").toDouble(1.0));
const QJsonArray bar = props.value("colorBar").toArray();
const QJsonArray bar = data.value("properties").toObject().value("colorBar").toArray();
for (auto e : bar) {
const QJsonArray pair = e.toArray();
if (pair.size() < 2) continue;

7
src/data/repo/I3dSceneRepository.hpp
View File

@ -113,13 +113,6 @@ public:
virtual void deleteSlice(const std::string& dsId,
std::function<void()> onOk, OnError onErr) = 0;
// 已保存切片的独立色阶（颜色快照 + 不透明度并入 globalOpacity）。mock 仓储内存存；
// 默认空实现（无色阶存储的仓储）。set 在保存切片后调用，get 在还原/编辑切片色阶时用。
virtual void setSliceColorScale(const std::string& /*dsId*/,
const geopro::core::ColorScale& /*cs*/) {}
virtual bool sliceColorScale(const std::string& /*dsId*/,
geopro::core::ColorScale& /*out*/) const { return false; }
// ── 异常 / 异常体（spec §6.4）────────────────────────────────────────────
// 异常体（树中间层）：含该体下的多个 Anomaly。
struct AnomalyBody {

7
src/data/repo/IDatasetCommandRepository.hpp
View File

@ -167,13 +167,6 @@ public:
const QString& projectId, const QString& remarkSourceType,
std::function<void(bool ok, QJsonArray list, QString msg)> cb) = 0;
// 异常类型详情：GET /business/exceptionType/getDetail/{id} → data{...legend...}。
// data.legend = {polylineColor/Width/Shape, pointColor/Size/Shape, polygonFillColor,...}，
// 供创建异常时按平台类型样式渲染（与平台一致）。回调 data = 整个 data 对象。
virtual void getExceptionTypeDetail(
const QString& exceptionTypeId,
std::function<void(bool ok, QJsonObject data, QString msg)> cb) = 0;
// 装置类型枚举：GET /business/script/arrayTypeList → [{itemValue,name}]（电阻率/视电阻率段装置筛选用）。
virtual void listArrayTypes(std::function<void(bool ok, QJsonArray list, QString msg)> cb) = 0;

8
src/data/repo/LocalSample3dRepository.cpp
View File

@ -49,9 +49,11 @@ DsDimension LocalSample3dRepository::dimensionOf(const DsRow& ds) const {
}
// 切片：三维分析栏。
if (c == "dd_slice") return DsDimension::Analysis3D;
// 足迹型 → 二维数据集。dd_trajectory_data = 统一通用轨迹(数据字典 DD0623「保留」，已并入
// dd_radar_rtk_trajectory)；瞬变电磁/雷达通道/RTK 等轨迹型字典均标「删除」，不再单列。
if (c == "dd_trajectory_data") return DsDimension::Dim2D;
// 足迹型(测线/各类轨迹)：二维数据集（与 Api3dRepository 同口径）。
if (c == "dd_trajectory_data" || c == "dd_transient_electromagnetic_trajectory_data" ||
c == "dd_radar_channel_trajectory" || c == "dd_radar_rtk_trajectory") {
return DsDimension::Dim2D;
}
return DsDimension::Other;
}

47
src/io/gpr/Gpr3dvVolumeBridge.cpp
View File

@ -4,7 +4,6 @@
#include <cmath>
#include <limits>
#include <stdexcept>
#include <vector>
#include <QString>
@ -13,7 +12,6 @@
#include "RadarProcessor.h"
#include "core/model/ScalarVolumeI16.hpp"
#include "io/gpr/GprGeometry.hpp" // planChannelInterpolation
namespace geopro::io::gpr {
@ -70,7 +68,7 @@ double nowMs(std::chrono::steady_clock::time_point t0) {
geopro::core::BuiltI16 buildLineVolumeFromGpr3dv(const std::string& lineDir,
const std::string& linePrefix,
BridgeMetrics* metricsOut,
int coarse, double targetDy) {
int coarse) {
const int stride = coarse > 1 ? coarse : 1; // 沿测线下采样步长(≥1)
const QString dir = QString::fromLocal8Bit(lineDir.c_str());
const QString base = QString::fromLocal8Bit(linePrefix.c_str());
@ -110,25 +108,9 @@ geopro::core::BuiltI16 buildLineVolumeFromGpr3dv(const std::string& lineDir,
// 下采样后输出道数(向上取整保留末道附近)：nxOut = ceil(traces/stride)。
const int nxOut = (traces + stride - 1) / stride;
const int nx = nxOut; // X=道(沿测线，已按 stride 下采样)
const int ny = channels; // Y=通道(横向)
const int nz = samples; // Z=样本(深度)
// §1 线内通道插值：读各通道真实横向偏移(header.chXOffsets) → 规则网格化 Y 到 targetDy。
// 绝不跨线；间距/通道数从数据来，不假设。退路(无偏移/未启用)= 逐通道 identity。
std::vector<double> latOff;
const auto& chx = processed.header.chXOffsets;
if (chx.size() == channels)
for (int c = 0; c < channels; ++c)
latOff.push_back(static_cast<double>(chx[c]));
std::vector<geopro::io::gpr::ChannelInterpRow> rows;
bool interpolated = false;
if (static_cast<int>(latOff.size()) == channels && targetDy > 0.0) {
rows = planChannelInterpolation(latOff, targetDy);
interpolated = (static_cast<int>(rows.size()) != channels);
}
if (rows.empty())
for (int c = 0; c < channels; ++c) rows.push_back({c, c, 0.0});
const int ny = static_cast<int>(rows.size()); // Y=通道(横向，可能已插值加密)
// 3) 扫处理后值域 → Quant(offset=中点，防溢出)。
const auto tFill = std::chrono::steady_clock::now();
short rawMin = std::numeric_limits<short>::max();
@ -156,26 +138,20 @@ geopro::core::BuiltI16 buildLineVolumeFromGpr3dv(const std::string& lineDir,
quant.scale = (vmax > vmin) ? (vmax - vmin) / 64000.0 : 1.0;
quant.offset = 0.5 * (vmin + vmax); // 中点 → 防溢出
// 4) 逐 (输出行 j, trace, sample) 填体。每个输出行 = 两侧最近真实通道线性插值
// (a==b 时即原通道)。GPR 立方体稠密(每体素有值)，无空洞 → 不置 kBlank。
// 4) 逐 (ch,trace,sample) 填体。GPR 立方体为稠密体(每体素有值)，无空洞 → 不置 kBlank。
// 沿测线按 stride 下采样：输出道 to → 源道 t = to*stride。
geopro::core::BuiltI16 built;
built.vol = geopro::core::ScalarVolumeI16(nx, ny, nz);
for (int j = 0; j < ny; ++j) {
const auto& chA = processed.volumeData[rows[j].a];
const auto& chB = processed.volumeData[rows[j].b];
const double wb = rows[j].wb, wa = 1.0 - wb;
for (int c = 0; c < channels; ++c) {
const auto& chData = processed.volumeData[c];
for (int to = 0; to < nxOut; ++to) {
const int t = to * stride;
const bool hasA = t < static_cast<int>(chA.size());
const bool hasB = t < static_cast<int>(chB.size());
const bool hasTrace = t < static_cast<int>(chData.size());
for (int s = 0; s < samples; ++s) {
const double va =
(hasA && s < static_cast<int>(chA[t].size())) ? chA[t][s] : 0.0;
const double vb =
(hasB && s < static_cast<int>(chB[t].size())) ? chB[t][s] : 0.0;
// X=输出道 to、Y=输出行 j、Z=样本 s。
built.vol.at(to, j, s) = quant.toQ(wa * va + wb * vb);
short v = 0;
if (hasTrace && s < static_cast<int>(chData[t].size())) v = chData[t][s];
// X=输出道 to、Y=通道 c、Z=样本 s。
built.vol.at(to, c, s) = quant.toQ(static_cast<double>(v));
}
}
}
@ -186,8 +162,7 @@ geopro::core::BuiltI16 buildLineVolumeFromGpr3dv(const std::string& lineDir,
// 下采样后相邻输出道在世界中跨 stride 个原始道距 → dx ×stride 保持真实尺度。
const double dxBase = h.distanceInc > 1e-9 ? h.distanceInc : 1.0;
const double dx = dxBase * stride;
// 插值后 Y 已规则化到 targetDy 网格；否则用原通道横距。
const double dy = interpolated ? targetDy : channelSpacingY(h, channels);
const double dy = channelSpacingY(h, channels);
const double dz = depthSpacingZ(h);
built.quant = quant;

6
src/io/gpr/Gpr3dvVolumeBridge.hpp
View File

@ -40,15 +40,11 @@ struct BridgeMetrics {
// metricsOut 非空时回填维度/量化/spacing/耗时(供 CLI 报告，不编造)。
// coarse(下采样因子，≥1)：沿测线(道/X 轴)每 coarse 道取 1，spacing.x ×coarse 保形；
// 通道/样本(横向/深度)保留全分辨率。coarse≤1 即全分辨率。磁盘紧张时省空间用。
// targetDy(米，>0 启用)：线内【通道间插值】目标横向间距。读各通道真实横向偏移
// (header.chXOffsets) 规则网格化 Y 到 targetDy：ny=round(跨度/targetDy)+1，逐行线性
// 插值（不跨线、不假设道间距）。<=0 或无偏移 → 不插值，Y=原通道数。默认 0.025(2.5cm)。
// 失败(加载失败/立方体为空) → 抛 std::runtime_error。
geopro::core::BuiltI16 buildLineVolumeFromGpr3dv(const std::string& lineDir,
const std::string& linePrefix,
BridgeMetrics* metricsOut,
int coarse = 1,
double targetDy = 0.025);
int coarse = 1);
} // namespace geopro::io::gpr

43
src/io/gpr/GprGeometry.cpp
View File

@ -1,8 +1,5 @@
#include "io/gpr/GprGeometry.hpp"
#include <algorithm>
#include <cmath>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
@ -25,46 +22,6 @@ std::vector<double> parseChannelXOffsets(const std::string& ordText) {
return offsets;
}
std::vector<ChannelInterpRow> planChannelInterpolation(
const std::vector<double>& offsets, double targetDy) {
const int n = static_cast<int>(offsets.size());
std::vector<ChannelInterpRow> rows;
// 退化：通道<2 或 targetDy 非法 → 逐通道 identity。
if (n < 2 || targetDy <= 0.0) {
for (int i = 0; i < n; ++i) rows.push_back({i, i, 0.0});
return rows;
}
// 按偏移排序的通道索引（端点 / 区间定位用；通道本身可能非有序）。
std::vector<int> ord(n);
std::iota(ord.begin(), ord.end(), 0);
std::sort(ord.begin(), ord.end(),
[&](int x, int y) { return offsets[x] < offsets[y]; });
const double mn = offsets[ord.front()];
const double mx = offsets[ord.back()];
const double span = mx - mn;
// 跨度已比 targetDy 还密 → 不加密，逐通道 identity（保原通道序）。
if (span <= targetDy * 0.5) {
for (int i = 0; i < n; ++i) rows.push_back({i, i, 0.0});
return rows;
}
const int ny = static_cast<int>(std::lround(span / targetDy)) + 1;
int k = 0; // ord 内区间左指针：offsets[ord[k]] <= p
for (int j = 0; j < ny; ++j) {
const double p = mn + static_cast<double>(j) * targetDy;
while (k + 1 < n && offsets[ord[k + 1]] < p) ++k;
if (k + 1 >= n) { // p 在最右通道之外 → 取最右通道
rows.push_back({ord[n - 1], ord[n - 1], 0.0});
continue;
}
const int a = ord[k], b = ord[k + 1];
const double oa = offsets[a], ob = offsets[b];
double wb = (ob > oa) ? (p - oa) / (ob - oa) : 0.0;
wb = std::clamp(wb, 0.0, 1.0);
rows.push_back({a, b, wb});
}
return rows;
}
double depthOfSample(int s, const IprHeader& h) {
if (h.samples <= 1) return 0.0; // 防除零
const double timeNs = static_cast<double>(s) * h.timeWindowNs /

16
src/io/gpr/GprGeometry.hpp
View File

@ -11,22 +11,6 @@ namespace geopro::io::gpr {
// 解析 .ord 文本，返回末列==1 的有效通道的横向偏移(第 2 列)，按文件顺序。
std::vector<double> parseChannelXOffsets(const std::string& ordText);
// 通道间插值方案：一个输出网格行 = (1-wb)*通道[a] + wb*通道[b]（线性）。
// a==b 时即原样取该通道（无插值）。
struct ChannelInterpRow {
int a = 0;
int b = 0;
double wb = 0.0;
};
// 按真实横向偏移 offsets(米，逐通道) + 目标横向间距 targetDy(米) 规则网格化通道维(Y)：
// 返回每个输出网格行的线性插值方案。网格在 [min(off), max(off)] 上以 targetDy 等距取
// ny = round(span/targetDy)+1 行；每行找两侧最近真实通道线性插值（端点外用端点）。
// 退化(通道<2 / targetDy<=0 / 跨度已比 targetDy 还密) → 逐通道 identity（每通道一行）。
// 纯函数，便于单测：不依赖任何文件/模型。
std::vector<ChannelInterpRow> planChannelInterpolation(
const std::vector<double>& offsets, double targetDy);
// 采样序号 s → 深度(米)。depth = soilVelocity[m/s] * (s * timeWindowNs/(samples-1) * 1e-9) / 2。
// samples<=1 时返回 0 防除零。
double depthOfSample(int s, const IprHeader& h);

16
src/render/CameraPreset.cpp
View File

@ -8,8 +8,6 @@ namespace {
// 三维斜视方位角 / 仰角。
constexpr double kAzimuth = 30.0;
constexpr double kElevation = 25.0;
// 二维分析近俯视：自正俯视下压的角度(12°→俯角约78°)。留一点倾斜使高程差可辨。
constexpr double kNearTopTilt = 12.0;
} // namespace
void applyTop2D(vtkRenderer* r)
@ -39,20 +37,6 @@ void applyFree3D(vtkRenderer* r)
r->ResetCamera();
}
void applyNearTop2D(vtkRenderer* r)
{
if (!r) return;
auto* c = r->GetActiveCamera();
c->ParallelProjectionOff(); // 透视：配合一点倾斜，使高程差可见(正交/正俯视下不可辨)
// 自正俯视(+Z 向下看、北朝上)起，下压 kNearTopTilt → 俯角约 78°；方位不偏(正北俯视)。
c->SetFocalPoint(0, 0, 0);
c->SetPosition(0, 0, 1);
c->SetViewUp(0, 1, 0);
c->Elevation(kNearTopTilt);
c->OrthogonalizeViewUp();
r->ResetCamera();
}
void applyView(vtkRenderer* r, ViewDir dir)
{
if (!r) return;

4
src/render/CameraPreset.hpp
View File

@ -8,10 +8,6 @@ void applyTop2D(vtkRenderer* r);
// 自由三维：透视投影，斜视方位看到剖面立体。
void applyFree3D(vtkRenderer* r);
// 二维分析近俯视：透视投影，自正俯视下压一点(约12°→约78°俯角)。留一点倾斜使高程差可见
// (绝对正俯视下高程不可辨)，仅平移+缩放(旋转由 interactor style 锁定)。
void applyNearTop2D(vtkRenderer* r);
// 快捷视图方向（世界系 x=East,y=North,z=-depth）。
// Top 俯视 (相机在 +Z 向下看)
// Bottom 仰视 (相机在 -Z 向上看)

27
src/render/ColorLutBuilder.cpp
View File

@ -2,34 +2,19 @@
namespace geopro::render {
vtkSmartPointer<vtkLookupTable> buildLut(const geopro::core::ColorScale& cs, double vmin, double vmax,
int n, bool transparentBelowRange)
vtkSmartPointer<vtkLookupTable> buildLut(const geopro::core::ColorScale& cs, double vmin, double vmax, int n)
{
if (n < 2) n = 2; // 至少两级，避免 (n-1) 退化
auto lut = vtkSmartPointer<vtkLookupTable>::New();
lut->SetNumberOfTableValues(n);
// 白化（无数据）真透明：体把留空格设为哨兵 vmin-1.0（< vmin），切片 reslice 后据此识别。
// ⚠ 实测(tests/spike/slice_alpha_probe)：vtkImagePlaneWidget 纹理【认】区间内 texel alpha
// （alpha=0 的格→透明，背后透出），但【不认】UseBelowRangeColor（下溢被钳到 0 号最低色格、
// 填蓝，根本不走 below-range 色）。故不能用 UseBelowRangeColor，改为：把下限下移一格、
// 预留 0 号格为全透明"白化槽"——下溢哨兵被钳到 0 号格即透明；真实 [vmin,vmax] 数据落
// 1..n-1 格（不透明），不受影响。
const double lo = transparentBelowRange ? vmin - (vmax - vmin) / (n - 1) : vmin;
lut->SetTableRange(lo, vmax);
lut->SetTableRange(vmin, vmax);
for (int t = 0; t < n; ++t) {
if (transparentBelowRange && t == 0) {
lut->SetTableValue(0, 0.0, 0.0, 0.0, 0.0); // 白化槽：全透明（下溢钳到此）
continue;
}
const double val = lo + (vmax - lo) * t / (n - 1);
const double val = vmin + (vmax - vmin) * t / (n - 1);
const auto c = cs.colorAt(val);
// 两级透明度（渲染时相乘，不烘焙）：有效 alpha = 每色 alpha × 整体透明度。
// #RRGGBB 无 alpha 默认 a=255、整体默认 1 → 旧纯色阶不受影响；alpha=0 真透明。
lut->SetTableValue(t, c.r / 255.0, c.g / 255.0, c.b / 255.0,
c.a / 255.0 * cs.globalOpacity());
// 复刻原版 three 渲染（parseColor 只取 rgb、MeshBasicMaterial opacity=1）：
// 忽略 colorBar 的 alpha，画满不透明 RGB。
lut->SetTableValue(t, c.r / 255.0, c.g / 255.0, c.b / 255.0, 1.0);
}
if (transparentBelowRange) lut->SetNanColor(0.0, 0.0, 0.0, 0.0); // NaN 也透明（双保险）
lut->Build();
return lut;
}

6
src/render/ColorLutBuilder.hpp
View File

@ -5,10 +5,6 @@
namespace geopro::render {
// 由 core 阶梯色阶构建 N 级 vtkLookupTable，区间 [vmin, vmax]。
// transparentBelowRange=true：把 < vmin 的标量（=三维体无数据格的留空哨兵 vmin-1.0）映射为
// 全透明（而非默认钳到最低档色不透明）。切片复用体的标量 image，据此让白化区真透明、不填蓝。
// 仅切片需要；散点/等值线传 false（保留"低于值域钳最低色"的原行为，避免误隐真实欠量数据）。
vtkSmartPointer<vtkLookupTable> buildLut(const geopro::core::ColorScale& cs, double vmin, double vmax,
int n = 256, bool transparentBelowRange = false);
vtkSmartPointer<vtkLookupTable> buildLut(const geopro::core::ColorScale& cs, double vmin, double vmax, int n = 256);
} // namespace geopro::render

5
src/render/actors/AnomalyActor.cpp
View File

@ -19,8 +19,8 @@ namespace {
// 虚线点画图案(16 位)与重复因子；dashed 异常用。
constexpr int kDashPattern = 0xF0F0;
constexpr int kDashRepeat = 1;
// Point 型异常的小球像素直径（RenderPointsAsSpheres 下为球径）。
constexpr float kPointSize = 13.0F;
// Point 型异常的方块点像素边长。
constexpr float kPointSize = 8.0F;
// 把一个异常的 localPts 灌入 points（x, -y, 0：深度取负，与 #18 同坐标系）。
void fillPoints2D(vtkPoints* points, const geopro::core::Anomaly& a)
@ -82,7 +82,6 @@ vtkSmartPointer<vtkActor> buildActor(vtkPoints* points, std::size_t n,
actor->GetProperty()->SetColor(c.r / 255.0, c.g / 255.0, c.b / 255.0);
if (asPoints) {
actor->GetProperty()->SetPointSize(kPointSize);
actor->GetProperty()->SetRenderPointsAsSpheres(true); // 点异常渲染为小球(非扁平方点)
} else {
actor->GetProperty()->SetLineWidth(a.lineWidth > 0.0 ? a.lineWidth : 1.0);
if (a.dashed) {

200
src/render/actors/VoxelActor.cpp
View File

@ -1,25 +1,15 @@
#include "actors/VoxelActor.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
#include <vtkActor.h>
#include <vtkColorTransferFunction.h>
#include <vtkDoubleArray.h>
#include <vtkFloatArray.h>
#include <vtkFlyingEdges3D.h>
#include <vtkGPUVolumeRayCastMapper.h>
#include <vtkNew.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkShortArray.h>
#include <vtkSmartVolumeMapper.h>
#include <vtkPiecewiseFunction.h>
#include <vtkPointData.h>
#include <vtkUnsignedCharArray.h>
#include <vtkVolumeMapper.h>
#include <vtkVolumeProperty.h>
namespace geopro::render {
@ -28,88 +18,29 @@ namespace {
// 颜色/不透明度传递函数采样级数。
constexpr int kTransferSamples = 64;
// 是否支持 GPU 体绘制（光线投射）。默认 true（有独显的常态）；无 GPU 机器由 setVolumeGpuSupported(false)
// 设回退。影响：mask 真白化只有 GPU mapper 支持 → 无 GPU 时不建 mask、改用 SmartVolumeMapper(自动 CPU 回退)，
// 空值仍靠不透明度传函(哨兵→0)透明，仅交界处少了 mask 的干净边（重现一圈细渗色）。
bool g_gpuVolumeSupported = true;
// 体绘制最大不透明度（[vmin,vmax] 线性 0→kMaxOpacity）。
constexpr double kMaxOpacity = 0.15;
// NaN/留空格的哨兵：落在 [vmin,vmax] 之外，传递函数把它映射为完全透明。
double sentinel(double vmin) { return vmin - 1.0; }
// 二值 mask 体（UCHAR，255=有效、0=空值）。与标量同维同 origin/spacing、同点序
// （id=(k*ny+j)*nx+i）。空值格 mask=0 → 喂给 GPU ray cast 后被完全跳过：不着色、不参与
// 三线性插值，对齐 Surfer Blanking 的真白化语义（消除"空白处沿数据边界渗蓝")。
// 调用方在填标量的同一循环里写 m->SetValue(id, valid?255:0)。
vtkSmartPointer<vtkImageData> makeMaskLike(int nx, int ny, int nz,
double ox, double oy, double oz,
double dx, double dy, double dz,
vtkUnsignedCharArray*& outArr)
{
auto mask = vtkSmartPointer<vtkImageData>::New();
mask->SetDimensions(nx, ny, nz);
mask->SetOrigin(ox, oy, oz);
mask->SetSpacing(dx, dy, dz);
vtkNew<vtkUnsignedCharArray> m;
m->SetName("mask");
m->SetNumberOfTuples(static_cast<vtkIdType>(nx) * ny * nz);
mask->GetPointData()->SetScalars(m);
outArr = m; // image 持有引用，循环结束前有效
return mask;
}
// double/int16 两版公用的 mapper+property+volume 组装。mask 非空 → 用 GPU ray cast + 二值 mask
// 做真白化（SmartVolumeMapper 不转发 mask，故走 GPU mapper；桌面端恒有 GL 上下文）；
// mask 为空 → 保留 SmartVolumeMapper（GPU/CPU 自适应）。
// double/int16 两版公用的 mapper+property+volume 组装（行为与原 double 版一致）。
vtkSmartPointer<vtkVolume> assembleVolume(vtkImageData* img,
vtkColorTransferFunction* color,
vtkPiecewiseFunction* opacity,
vtkImageData* mask)
vtkPiecewiseFunction* opacity)
{
// 采样距离 + 不透明度单位距离用到几何尺度。
double sp[3];
img->GetSpacing(sp);
const double minSp =
std::min({std::abs(sp[0]), std::abs(sp[1]), std::abs(sp[2])}); // 最细体素维度
double bnd[6];
img->GetBounds(bnd);
const double diag = std::sqrt((bnd[1] - bnd[0]) * (bnd[1] - bnd[0]) +
(bnd[3] - bnd[2]) * (bnd[3] - bnd[2]) +
(bnd[5] - bnd[4]) * (bnd[5] - bnd[4])); // 包围盒对角(最长穿越路径)
vtkSmartPointer<vtkVolumeMapper> mapper;
if (mask && g_gpuVolumeSupported) {
// 真白化：mask=0 体素被光线投射完全跳过，杜绝空值格沿边界渗蓝。需 GPU 光线投射支持。
vtkNew<vtkGPUVolumeRayCastMapper> gpu;
gpu->SetInputData(img);
gpu->SetMaskInput(mask);
gpu->SetMaskTypeToBinary();
gpu->SetAutoAdjustSampleDistances(0); // 全程全质量（GPU 直接 mapper 无交互降采样开关）
// 关了自适应必须显式给【细】采样距离，否则用粗默认值 → 看到一层层体素(分层伪影)。
if (minSp > 0) gpu->SetSampleDistance(static_cast<float>(0.3 * minSp));
// 抖动：用噪声纹理微扰每条光线的采样起点，消除规则采样面造成的「木纹/分层」伪影（VTK 官方此用途）。
gpu->SetUseJittering(1);
mapper = gpu;
} else {
// SmartVolumeMapper：有 GPU 走 GPU ray cast，否则自动回退 CPU，避免无 GPU 时卡死/失败。
vtkNew<vtkSmartVolumeMapper> sm;
sm->SetInputData(img);
vtkNew<vtkSmartVolumeMapper> mapper;
mapper->SetInputData(img);
// 全程统一全质量(GPU 足够快, 实测 ~7ms/帧)：关掉交互降采样, 避免"停手补高清"那一帧突跳停顿。
sm->SetAutoAdjustSampleDistances(0);
sm->SetInteractiveAdjustSampleDistances(0);
mapper = sm;
}
mapper->SetAutoAdjustSampleDistances(0);
mapper->SetInteractiveAdjustSampleDistances(0);
vtkNew<vtkVolumeProperty> prop;
prop->SetColor(color);
prop->SetScalarOpacity(opacity);
prop->SetInterpolationTypeToLinear();
prop->ShadeOff();
// 不透明度单位距离 = 包围盒对角 × kOpacityUnitFraction：控制沿深度的累积速度，使色阶「不透明度」滑块
// 有层次。取对角/10：100%(每单位=1.0)→沿体累积到≈实心、10% 很淡。太大(=整条对角)→100% 也偏透；
// 太小(=体素)→ 低不透明度也累积到全不透明。
constexpr double kOpacityUnitFraction = 0.1;
if (diag > 0) prop->SetScalarOpacityUnitDistance(kOpacityUnitFraction * diag);
auto volume = vtkSmartPointer<vtkVolume>::New();
volume->SetMapper(mapper);
@ -143,52 +74,14 @@ vtkSmartPointer<vtkVolume> assembleVolumeI16(vtkImageData* img,
vtkNew<vtkPiecewiseFunction> opacity;
opacity->AddPoint(static_cast<double>(geopro::core::ScalarVolumeI16::kBlank), 0.0);
for (int t = 0; t < kTransferSamples; ++t) {
const double qd = qminD + (qmaxD - qminD) * t / (kTransferSamples - 1);
const auto qvLevel = static_cast<std::int16_t>(std::lround(qd));
const double phys = q.toPhys(qvLevel);
opacity->AddPoint(qd, cs.colorAt(phys).a / 255.0 * cs.globalOpacity());
}
opacity->AddPoint(qminD, 0.0);
opacity->AddPoint(qmaxD, kMaxOpacity);
// 由预建 short 体扫出二值 mask（kBlank→0 跳过）。稠密体（无 kBlank）→ 全 255，等价无 mask。
int dims[3];
img->GetDimensions(dims);
vtkUnsignedCharArray* mArr = nullptr;
auto mask = makeMaskLike(dims[0], dims[1], dims[2], img->GetOrigin()[0], img->GetOrigin()[1],
img->GetOrigin()[2], img->GetSpacing()[0], img->GetSpacing()[1],
img->GetSpacing()[2], mArr);
if (auto* sc = vtkShortArray::SafeDownCast(img->GetPointData()->GetScalars())) {
const vtkIdType n = sc->GetNumberOfTuples();
for (vtkIdType id = 0; id < n; ++id)
mArr->SetValue(id, sc->GetValue(id) == geopro::core::ScalarVolumeI16::kBlank ? 0 : 255);
}
return assembleVolume(img, color, opacity, mask);
return assembleVolume(img, color, opacity);
}
} // namespace
void setVolumeGpuSupported(bool ok) { g_gpuVolumeSupported = ok; }
void updateVolumeColors(vtkVolume* volume, const geopro::core::ColorScale& cs, double vmin,
double vmax) {
if (!volume || !volume->GetProperty()) return;
if (vmin >= vmax) vmax = vmin + 1.0;
const double blank = sentinel(vmin);
// 与 buildVoxel(float 路径) 同口径重建颜色/不透明度传函，原地换到已有 actor 上（不重建 image →
// 切片基底不变、不被关闭）。
vtkNew<vtkColorTransferFunction> color;
vtkNew<vtkPiecewiseFunction> opacity;
opacity->AddPoint(blank, 0.0);
for (int t = 0; t < kTransferSamples; ++t) {
const double val = vmin + (vmax - vmin) * t / (kTransferSamples - 1);
const auto c = cs.colorAt(val);
color->AddRGBPoint(val, c.r / 255.0, c.g / 255.0, c.b / 255.0);
opacity->AddPoint(val, c.a / 255.0 * cs.globalOpacity());
}
volume->GetProperty()->SetColor(color);
volume->GetProperty()->SetScalarOpacity(opacity);
}
vtkSmartPointer<vtkVolume> buildVoxel(const geopro::core::ScalarVolume& vol,
const geopro::core::ColorScale& cs,
double ox, double oy, double oz,
@ -207,13 +100,7 @@ vtkSmartPointer<vtkVolume> buildVoxel(const geopro::core::ScalarVolume& vol,
img->SetOrigin(ox, oy, oz);
img->SetSpacing(dx, dy, dz);
// 标量用 float（非 double）：OpenGL 无原生 double 体纹理，GPU 体绘制对 double 处理不稳/部分驱动间歇
// 出空（偶发不渲染根因之一），且省一半显存。float 精度对可视化足够。
// 二值 mask：NaN 空格→0（光线投射跳过，真白化），有值→255。与标量同循环填，免二次扫描。
vtkUnsignedCharArray* mArr = nullptr;
auto mask = makeMaskLike(nx, ny, nz, ox, oy, oz, dx, dy, dz, mArr);
vtkNew<vtkFloatArray> sc;
vtkNew<vtkDoubleArray> sc;
sc->SetName("v");
sc->SetNumberOfTuples(static_cast<vtkIdType>(nx) * ny * nz);
// 点序 i 最快、j 次之、k 最慢（匹配 vtkImageData 与 ScalarVolume::idx）。
@ -222,9 +109,7 @@ vtkSmartPointer<vtkVolume> buildVoxel(const geopro::core::ScalarVolume& vol,
for (int i = 0; i < nx; ++i) {
const double v = vol.at(i, j, k);
const vtkIdType id = (static_cast<vtkIdType>(k) * ny + j) * nx + i;
const bool isBlank = std::isnan(v);
sc->SetValue(id, static_cast<float>(isBlank ? blank : v)); // NaN → 哨兵
mArr->SetValue(id, isBlank ? 0 : 255);
sc->SetValue(id, std::isnan(v) ? blank : v); // NaN → 哨兵
}
img->GetPointData()->SetScalars(sc);
outImage = img;
@ -237,17 +122,13 @@ vtkSmartPointer<vtkVolume> buildVoxel(const geopro::core::ScalarVolume& vol,
color->AddRGBPoint(val, c.r / 255.0, c.g / 255.0, c.b / 255.0);
}
// 不透明度传递函数：哨兵 → 0（透明）；区间内由色阶 alpha 驱动，再乘体密度主控 kMaxOpacity。
// 体素不透明度 = (色阶 alpha/255) × kMaxOpacity（整体透明度已在配置时乘进 alpha）。
// alpha=0 → 真透明；alpha=255（无 alpha 色阶默认）→ 维持 kMaxOpacity 的通透手感，不回归。
// 不透明度传递函数：哨兵 → 0（透明）；[vmin,vmax] 线性递增到 kMaxOpacity。
vtkNew<vtkPiecewiseFunction> opacity;
opacity->AddPoint(blank, 0.0);
for (int t = 0; t < kTransferSamples; ++t) {
const double val = vmin + (vmax - vmin) * t / (kTransferSamples - 1);
opacity->AddPoint(val, cs.colorAt(val).a / 255.0 * cs.globalOpacity());
}
opacity->AddPoint(vmin, 0.0);
opacity->AddPoint(vmax, kMaxOpacity);
return assembleVolume(img, color, opacity, mask);
return assembleVolume(img, color, opacity);
}
vtkSmartPointer<vtkVolume> buildVoxelI16(const geopro::core::ScalarVolumeI16& vol,
@ -268,10 +149,6 @@ vtkSmartPointer<vtkVolume> buildVoxelI16(const geopro::core::ScalarVolumeI16& vo
img->SetOrigin(ox, oy, oz);
img->SetSpacing(dx, dy, dz);
// 二值 mask：kBlank 空格→0（真白化跳过），有值→255。与标量同循环填。
vtkUnsignedCharArray* mArr = nullptr;
auto mask = makeMaskLike(nx, ny, nz, ox, oy, oz, dx, dy, dz, mArr);
vtkNew<vtkShortArray> sc;
sc->SetName("v");
sc->SetNumberOfTuples(static_cast<vtkIdType>(nx) * ny * nz);
@ -283,7 +160,6 @@ vtkSmartPointer<vtkVolume> buildVoxelI16(const geopro::core::ScalarVolumeI16& vo
const std::int16_t qv = vol.at(i, j, k);
const vtkIdType id = (static_cast<vtkIdType>(k) * ny + j) * nx + i;
sc->SetValue(id, qv);
mArr->SetValue(id, qv == geopro::core::ScalarVolumeI16::kBlank ? 0 : 255);
}
img->GetPointData()->SetScalars(sc);
outImage = img;
@ -304,17 +180,13 @@ vtkSmartPointer<vtkVolume> buildVoxelI16(const geopro::core::ScalarVolumeI16& vo
color->AddRGBPoint(qd, c.r / 255.0, c.g / 255.0, c.b / 255.0);
}
// 不透明度传递函数（量化域）：kBlank → 0（透明）；区间内由色阶 alpha 驱动 × 体密度主控 kMaxOpacity。
// 不透明度传递函数（量化域）：kBlank → 0（透明）；[qmin,qmax] 线性递增到 kMaxOpacity。
vtkNew<vtkPiecewiseFunction> opacity;
opacity->AddPoint(static_cast<double>(geopro::core::ScalarVolumeI16::kBlank), 0.0);
for (int t = 0; t < kTransferSamples; ++t) {
const double qd = qminD + (qmaxD - qminD) * t / (kTransferSamples - 1);
const auto qvLevel = static_cast<std::int16_t>(std::lround(qd));
const double phys = q.toPhys(qvLevel);
opacity->AddPoint(qd, cs.colorAt(phys).a / 255.0 * cs.globalOpacity());
}
opacity->AddPoint(qminD, 0.0);
opacity->AddPoint(qmaxD, kMaxOpacity);
return assembleVolume(img, color, opacity, mask);
return assembleVolume(img, color, opacity);
}
vtkSmartPointer<vtkVolume> buildVoxel(const geopro::core::ScalarVolume& vol,
@ -336,34 +208,4 @@ vtkSmartPointer<vtkVolume> buildVoxelI16FromImage(vtkImageData* shortImg,
return assembleVolumeI16(shortImg, q, cs, vminPhys, vmaxPhys);
}
vtkSmartPointer<vtkActor> buildIsosurface(vtkImageData* img, const geopro::core::ColorScale& cs,
double vmin, double vmax, double isoValue)
{
if (!img) return nullptr;
if (vmin >= vmax) vmax = vmin + 1.0;
// 阈值钳进 (vmin,vmax)：=vmin 会沿留空哨兵边界成面、=vmax 抽不出。
const double eps = 1e-6 * (vmax - vmin);
isoValue = std::max(vmin + eps, std::min(vmax - eps, isoValue));
vtkNew<vtkFlyingEdges3D> fe;
fe->SetInputData(img);
fe->SetValue(0, isoValue);
fe->ComputeNormalsOn();
fe->ComputeGradientsOff();
fe->ComputeScalarsOff();
fe->Update();
if (!fe->GetOutput() || fe->GetOutput()->GetNumberOfPoints() == 0) return nullptr; // 无超阈区
vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputConnection(fe->GetOutputPort());
mapper->ScalarVisibilityOff(); // 用 actor 实色，不按标量着色
auto actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
const auto c = cs.colorAt(isoValue); // 阈值处的色（高值多为暖红，复刻参考图红块）
actor->GetProperty()->SetColor(c.r / 255.0, c.g / 255.0, c.b / 255.0);
actor->GetProperty()->SetOpacity(1.0); // 不透明实心
return actor;
}
} // namespace geopro::render

16
src/render/actors/VoxelActor.hpp
View File

@ -1,5 +1,4 @@
#pragma once
#include <vtkActor.h>
#include <vtkSmartPointer.h>
#include <vtkVolume.h>
#include <vtkImageData.h>
@ -8,21 +7,6 @@
#include "model/ScalarVolumeI16.hpp"
namespace geopro::render {
// 设置是否支持 GPU 体绘制（启动探测后调一次）。false → 体绘制回退 SmartVolumeMapper(CPU 自适应)、
// 不建 mask（空值仍透明，仅边缘少了 mask 的干净度）。默认 true。
void setVolumeGpuSupported(bool ok);
// 原地更新已渲染体的颜色/不透明度（仅换传函，不重建 image）：色阶改动时用，避免重建 image 把切片基底
// 换掉、连带关闭未保存切片。float 体路径口径（标准 addVolume 产物）。
void updateVolumeColors(vtkVolume* volume, const geopro::core::ColorScale& cs, double vmin,
double vmax);
// 体上抽等值面（marching cubes/FlyingEdges）→ 不透明实心 actor，凸显超阈异常体（参考图红块）。
// img 为 buildVoxel 暴露的 vtkImageData（标量=物理值，留空=哨兵 vmin-1，低于任意 isoValue 不成面）。
// isoValue 在 [vmin,vmax] 内；颜色取 ColorScale 在 isoValue 处的实色、不透明。无超阈区 → 返回 nullptr。
vtkSmartPointer<vtkActor> buildIsosurface(vtkImageData* img, const geopro::core::ColorScale& cs,
double vmin, double vmax, double isoValue);
// 把 core 规则标量体（IDW 输出，含 NaN 留空）转 vtkImageData，再建 GPU 光线投射体绘制。
// 颜色按 ColorScale 在 [vmin,vmax] 采样；NaN/留空格 → 不透明度 0（透明）。
// 返回 vtkVolume（由调用方加入 renderer）。

87
src/render/interact/AnomalyDrawTool.cpp
View File

@ -17,6 +17,8 @@
#include <vtkProperty.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkTextActor.h>
#include <vtkTextProperty.h>
namespace geopro::render::interact {
@ -25,7 +27,6 @@ constexpr double kEps = 1e-9;
constexpr double kObserverPriority = 5.0; // 高于切片 widget 与右键菜单(1.0)，绘制期独占
constexpr double kDoubleClickMs = 350.0; // 左键双击闭合阈值
constexpr int kClickSlopPx = 6; // 双击位置相近阈值(px)
constexpr int kCloseSnapPx = 12; // 面：光标/点击邻近起点的吸附阈值(px)
double nowMs() {
return std::chrono::duration<double, std::milli>(
@ -39,11 +40,10 @@ AnomalyDrawTool::AnomalyDrawTool(vtkRenderWindowInteractor* interactor, vtkRende
AnomalyDrawTool::~AnomalyDrawTool() { removeObservers(); }
void AnomalyDrawTool::start(DrawMode mode, const Vec3& planeOrigin, const Vec3& planeNormal,
void AnomalyDrawTool::start(const Vec3& planeOrigin, const Vec3& planeNormal,
std::function<void(const std::vector<Vec3>&)> onFinish,
std::function<void()> onCancel) {
if (active_) cancel();
mode_ = mode;
origin_ = planeOrigin;
normal_ = normalize(planeNormal);
onFinish_ = std::move(onFinish);
@ -53,9 +53,19 @@ void AnomalyDrawTool::start(DrawMode mode, const Vec3& planeOrigin, const Vec3&
hasCursor_ = false;
active_ = true;
installObservers();
// 操作提示由 app 层 QLabel 浮层承担(VTK 内置字体不含中文字形 → vtkTextActor 渲染不出中文)。
// 屏幕操作提示（左上角），解决"不知如何闭合"。
if (renderer_) {
hint_ = vtkSmartPointer<vtkTextActor>::New();
hint_->SetInput("圈定异常：左键逐点 · 双击或右键完成 · Esc 取消");
hint_->GetTextProperty()->SetFontSize(16);
hint_->GetTextProperty()->SetColor(1.0, 0.9, 0.0);
hint_->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport();
hint_->GetPositionCoordinate()->SetValue(0.02, 0.94);
renderer_->AddViewProp(hint_);
if (interactor_) interactor_->Render();
}
}
void AnomalyDrawTool::cancel() {
if (!active_) return;
@ -70,9 +80,11 @@ void AnomalyDrawTool::teardownActive() {
if (renderer_) {
if (preview_) renderer_->RemoveViewProp(preview_);
if (rubber_) renderer_->RemoveViewProp(rubber_);
if (hint_) renderer_->RemoveViewProp(hint_);
}
preview_ = nullptr;
rubber_ = nullptr;
hint_ = nullptr;
active_ = false;
hasCursor_ = false;
pts_.clear();
@ -103,20 +115,7 @@ Vec3 AnomalyDrawTool::pickOnPlane() const {
return Vec3{{nearP[0] + t * dir[0], nearP[1] + t * dir[1], nearP[2] + t * dir[2]}};
}
bool AnomalyDrawTool::nearFirstVertex(int sx, int sy) const {
if (pts_.empty() || !renderer_) return false;
renderer_->SetWorldPoint(pts_.front()[0], pts_.front()[1], pts_.front()[2], 1.0);
renderer_->WorldToDisplay();
double d[3];
renderer_->GetDisplayPoint(d);
return std::abs(d[0] - sx) <= kCloseSnapPx && std::abs(d[1] - sy) <= kCloseSnapPx;
}
void AnomalyDrawTool::addVertex() {
// 点模式：单点，再次左键 = 重定位(微调)，不累积；线/面模式：累积顶点。
if (mode_ == DrawMode::Point && !pts_.empty())
pts_[0] = pickOnPlane();
else
pts_.push_back(pickOnPlane());
updatePreview();
}
@ -159,8 +158,7 @@ void AnomalyDrawTool::updatePreview() {
preview_->SetMapper(mapper);
preview_->GetProperty()->SetColor(1.0, 0.9, 0.0); // 亮黄
preview_->GetProperty()->SetLineWidth(2.0);
preview_->GetProperty()->SetPointSize(mode_ == DrawMode::Point ? 16.0 : 9.0); // 点模式更醒目
preview_->GetProperty()->SetRenderPointsAsSpheres(true); // 顶点渲染为小球(图钉感)
preview_->GetProperty()->SetPointSize(9.0); // 醒目圆点
renderer_->AddActor(preview_);
interactor_->Render();
}
@ -169,18 +167,16 @@ void AnomalyDrawTool::updateRubber() {
if (!renderer_) return;
if (rubber_) renderer_->RemoveViewProp(rubber_);
rubber_ = nullptr;
// 点模式：单点标注，不拉末点→光标的橡皮筋线（否则点完还甩出一条线，用户反馈）。
if (mode_ == DrawMode::Point || pts_.empty() || !hasCursor_) {
if (pts_.empty() || !hasCursor_) {
if (interactor_) interactor_->Render();
return;
}
// 末点 → 光标 的虚线橡皮筋（跟手反馈）；面模式光标邻近起点 → 指向起点，预览闭合。
// 末点 → 当前光标投影点 的虚线橡皮筋（跟手反馈）。
const Vec3& a = pts_.back();
const Vec3 endP = cursorNearStart_ ? pts_.front() : cursorPt_;
vtkNew<vtkPoints> points;
points->SetNumberOfPoints(2);
points->SetPoint(0, a[0], a[1], a[2]);
points->SetPoint(1, endP[0], endP[1], endP[2]);
points->SetPoint(1, cursorPt_[0], cursorPt_[1], cursorPt_[2]);
vtkNew<vtkPolyData> poly;
poly->SetPoints(points);
vtkNew<vtkPolyLine> line;
@ -204,9 +200,7 @@ void AnomalyDrawTool::updateRubber() {
}
void AnomalyDrawTool::finish() {
const std::size_t minPts =
mode_ == DrawMode::Point ? 1 : (mode_ == DrawMode::Line ? 2 : 3); // 点1/线2/面3
if (pts_.size() < minPts) { // 不足以成形 → 取消
if (pts_.size() < 3) { // 不足以成面 → 取消
cancel();
return;
}
@ -227,9 +221,6 @@ void AnomalyDrawTool::installObservers() {
// 鼠标移动：更新末点→光标的虚线橡皮筋（跟手反馈）。不 abort，不干扰其它悬停。
self->cursorPt_ = self->pickOnPlane();
self->hasCursor_ = true;
const int* mp = self->interactor_->GetEventPosition();
self->cursorNearStart_ = self->mode_ == DrawMode::Face && self->pts_.size() >= 3 &&
self->nearFirstVertex(mp[0], mp[1]);
self->updateRubber();
return;
}
@ -238,21 +229,9 @@ void AnomalyDrawTool::installObservers() {
if (self->cmd_) self->cmd_->SetAbortFlag(1);
switch (eid) {
case vtkCommand::LeftButtonPressEvent: {
// 点：单击即落点并完成（业界通用，无需双击/回车）。
if (self->mode_ == DrawMode::Point) {
self->addVertex();
self->finish();
break;
}
// 左键双连击 = 闭合（标准多边形交互）；否则加顶点。
const double now = nowMs();
const int* p = self->interactor_->GetEventPosition();
// 面：点回起点(屏幕邻近)闭合(≥3点)，不加点。
if (self->mode_ == DrawMode::Face && self->pts_.size() >= 3 &&
self->nearFirstVertex(p[0], p[1])) {
self->finish();
break;
}
// 线：左键双连击 = 完成；否则加顶点。
const bool dbl = self->lastClickMs_ >= 0.0 &&
(now - self->lastClickMs_) < kDoubleClickMs &&
std::abs(p[0] - self->lastClickX_) <= kClickSlopPx &&
@ -260,29 +239,17 @@ void AnomalyDrawTool::installObservers() {
self->lastClickMs_ = now;
self->lastClickX_ = p[0];
self->lastClickY_ = p[1];
if (dbl) {
// 双击结束：第一下已落点(=双击位置)，保留为末顶点直接完成(含双击位置，同地图工具)。
if (dbl)
self->finish();
} else {
else
self->addVertex();
}
break;
}
case vtkCommand::RightButtonPressEvent:
// 绘制中右键不提交（保留给「创建异常」菜单语义）；已 abort 消费，不打开菜单。
break;
case vtkCommand::RightButtonPressEvent: self->finish(); break;
case vtkCommand::KeyPressEvent: {
const char* key = self->interactor_->GetKeySym();
const std::string k = key ? std::string(key) : std::string();
if (k == "Escape")
self->cancel();
else if (k == "Return" || k == "KP_Enter")
self->finish();
else if ((k == "BackSpace" || k == "Delete") && !self->pts_.empty()) {
self->pts_.pop_back(); // 撤上一点
self->updatePreview();
self->updateRubber();
}
if (key && (std::string(key) == "Escape")) self->cancel();
else if (key && (std::string(key) == "Return")) self->finish();
break;
}
default: break;

22
src/render/interact/AnomalyDrawTool.hpp
View File

@ -9,28 +9,26 @@
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkActor;
class vtkTextActor;
class vtkCallbackCommand;
namespace geopro::render::interact {
// 异常圈定工具（#4b）：在给定切片平面上交互式画 点 / 线 / 面。
// 左键逐点加顶点（屏幕射线与平面求交，落在平面上）；**双击 / 回车 提交** → onFinish(worldPts)；
// Esc 取消；Backspace 撤上一点；点模式再次左键=重定位单点(微调)。右键绘制中不响应(保留给菜单语义)。
// 点≥1 / 线≥2(开放) / 面≥3(闭合)；闭合与否由上层据 markType 渲染，本工具只产顶点。
// 高优先级(5.0)交互器观察者抢输入：先于切片 widget 与 InteractionManager 右键菜单，绘制期独占左右键。
// 异常圈定工具（#4b）：在给定切片平面上交互式画多边形。
// 左键逐点加顶点（屏幕射线与平面求交，落在平面上）；右键 / 双击 / 回车 闭合 → onFinish(worldPts)；
// Esc / 不足 3 点闭合 → onCancel。绘制中实时预览折线。
// 高优先级(2.0)交互器观察者抢输入：先于切片 widget 与 InteractionManager 右键菜单，绘制期独占左右键。
// render 层：只碰 VTK，不认业务；产物(平面上的世界点)经回调交上层组装 core::Anomaly。
class AnomalyDrawTool {
public:
enum class DrawMode { Point, Line, Face }; // 点(1)/线(2,开放)/面(3,闭合)
AnomalyDrawTool(vtkRenderWindowInteractor* interactor, vtkRenderer* renderer);
~AnomalyDrawTool();
AnomalyDrawTool(const AnomalyDrawTool&) = delete;
AnomalyDrawTool& operator=(const AnomalyDrawTool&) = delete;
// 开始在平面(origin/normal)上按 mode 圈定。onFinish 收顶点(世界系)；onCancel 取消。
void start(DrawMode mode, const Vec3& planeOrigin, const Vec3& planeNormal,
// 开始在平面(origin/normal)上圈定。onFinish 收闭合多边形顶点(世界系)；onCancel 取消。
void start(const Vec3& planeOrigin, const Vec3& planeNormal,
std::function<void(const std::vector<Vec3>&)> onFinish,
std::function<void()> onCancel);
bool active() const { return active_; }
@ -40,9 +38,8 @@ private:
void addVertex(); // 左键：加顶点
void updatePreview(); // 重建已点几何（顶点圆点 + 实线折线；单点也可见）
void updateRubber(); // 鼠标移动：末点→光标的虚线橡皮筋
void finish(); // 双击/回车/(面)点起点：完成
void finish(); // 右键/双击/回车：闭合
Vec3 pickOnPlane() const; // 当前鼠标屏幕点 → 射线与平面交点
bool nearFirstVertex(int sx, int sy) const; // 屏幕点是否邻近起点(面闭合判定/提示)
void installObservers();
void removeObservers();
@ -52,7 +49,6 @@ private:
vtkRenderer* renderer_;
bool active_ = false;
DrawMode mode_ = DrawMode::Face;
Vec3 origin_{{0, 0, 0}}, normal_{{0, 0, 1}};
std::vector<Vec3> pts_;
std::function<void(const std::vector<Vec3>&)> onFinish_;
@ -60,9 +56,9 @@ private:
vtkSmartPointer<vtkActor> preview_; // 已点几何（顶点圆点 + 实线折线）
vtkSmartPointer<vtkActor> rubber_; // 末点→光标 虚线橡皮筋
vtkSmartPointer<vtkTextActor> hint_; // 屏幕操作提示
Vec3 cursorPt_{{0, 0, 0}}; // 当前鼠标在切面上的投影点
bool hasCursor_ = false;
bool cursorNearStart_ = false; // 面模式光标邻近起点 → 橡皮筋指向起点预览闭合
vtkSmartPointer<vtkCallbackCommand> cmd_;
unsigned long tagLeft_ = 0, tagMove_ = 0, tagRight_ = 0, tagKey_ = 0, tagDbl_ = 0;
// 双击闭合检测（左键两连击）：记上次左键时刻 + 屏幕位置。

131
src/render/interact/InteractionManager.cpp
View File

@ -29,15 +29,6 @@ std::array<double, 6> imageBounds(vtkImageData* img) {
if (img) img->GetBounds(b.data());
return b;
}
// 据三维体总不透明度(0~1)把切片不透明度模式解析为具体总不透明度(0~1)。
double resolveSliceOpacity(SliceOpacityMode mode, double volumeOpacity01) {
switch (mode) {
case SliceOpacityMode::Full: return 1.0; // 100% 不透明
case SliceOpacityMode::VolumePlus50: return std::min(1.0, volumeOpacity01 + 0.5);
case SliceOpacityMode::FollowVolume: return volumeOpacity01;
}
return 1.0;
}
} // namespace
InteractionManager::InteractionManager(vtkRenderWindowInteractor* interactor,
@ -119,19 +110,8 @@ void InteractionManager::setVolumeImage(const std::string& volumeDsId, vtkImageD
const geopro::core::ColorScale& cs, double vmin, double vmax) {
if (volumeDsId.empty()) return;
auto it = volumes_.find(volumeDsId);
if (it != volumes_.end() && it->second.image != image) {
// image 变（体重建）：旧 image 即将失效 → 关该体切片（上层 syncSlices 用新 image 重现已保存切片）。
closeSlicesOfVolume(volumeDsId);
} else if (it != volumes_.end()) {
// image 不变、仅色阶变（原地改色）：该体下【未保存】切片跟随改色（颜色 + 按模式重解析总不透明度）；
// 已保存切片用自己的色阶、不动。切片不被关闭，解决"改体色阶刷掉未保存切片"。
for (const auto& s : slices_) {
if (s->volumeDsId() != volumeDsId || !s->dsId().empty()) continue;
s->setColorScale(cs);
s->setOpacity(s->opacityMode(), resolveSliceOpacity(s->opacityMode(), cs.globalOpacity()));
}
safeRender();
}
// 同体 image 变更（重建/改色阶）：旧 image 即将失效 → 先关该体已显示切片（上层 syncSlices 用新 image 重现）。
if (it != volumes_.end() && it->second.image != image) closeSlicesOfVolume(volumeDsId);
volumes_[volumeDsId] = VolumeImg{image, cs, vmin, vmax};
}
@ -188,7 +168,6 @@ void InteractionManager::showSavedSlice(const std::string& dsId, int axis, const
tool->setVolumeDsId(volumeDsId);
SliceTool* tp = tool.get();
tool->onInteract = [this, tp]() { selectByTool(tp); };
tool->setInteractive(false); // 已保存切片定稿锁定：不可移动/旋转(用户要求)；仍可拾取选中/右键
slices_.push_back(std::move(tool));
selected_ = static_cast<int>(slices_.size()) - 1;
updateSelectionVisual(); // 程序化显示(syncSlices)：不发 onSliceSelectionChanged，避免列表选中被刷
@ -226,13 +205,6 @@ bool InteractionManager::selectSavedSlice(const std::string& dsId) {
return false;
}
void InteractionManager::deselectSlice() {
if (selected_ < 0) return;
selected_ = -1;
updateSelectionVisual(); // 清高亮(无选中切片)
safeRender();
}
void InteractionManager::selectByTool(const SliceTool* tool) {
int idx = -1;
for (std::size_t i = 0; i < slices_.size(); ++i)
@ -280,27 +252,6 @@ void InteractionManager::closeAll() {
safeRender();
}
PickInteractorStyle* InteractionManager::pickStyle() const { return style_; }
void InteractionManager::setMode2D(bool is2D) {
// 进入二维分析：主动取消「三维前视图」的所有选中。否则残留的选中切片会让 onWheel 持续消费滚轮
// （二维下无法缩放），且切回三维仍残留高亮。清 selected_ + 切片高亮；再经 onSliceSelectionChanged("")
// 联动清三维分析列表选中行与异常高亮（app 层接线）。与 VtkSceneView::setAnalysisMode2D 离开二维时
// clearMapLineSelection 清足迹选中相对称。
if (is2D) {
if (selected_ >= 0) {
selected_ = -1;
updateSelectionVisual(); // 清切片高亮（切回三维不残留选中）
}
if (onSliceSelectionChanged) onSliceSelectionChanged(std::string{});
}
// 切片属三维内容：二维分析隐藏(不销毁→切回零重建)、三维分析显示。
for (auto& s : slices_)
if (s) s->setVisible(!is2D);
if (style_) style_->setLock2D(is2D); // 二维=禁旋转、左键平移(仅平移+缩放)
// 不在此渲染：相机/地形/底图/维度显隐及统一 Render 由 VtkSceneView::setAnalysisMode2D 收尾。
}
void InteractionManager::flipView() {
if (!renderer_) return;
auto* cam = renderer_->GetActiveCamera();
@ -338,54 +289,6 @@ std::string InteractionManager::selectedSliceVolumeDsId() const {
void InteractionManager::tagSelectedSlice(const std::string& dsId) {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return;
slices_[static_cast<std::size_t>(selected_)]->setDsId(dsId);
slices_[static_cast<std::size_t>(selected_)]->setInteractive(false); // 保存即定稿锁定(不可改)
}
void InteractionManager::setSelectedSliceOpacity(SliceOpacityMode mode) {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return;
SliceTool* s = slices_[static_cast<std::size_t>(selected_)].get();
const VolumeImg* v = volumeOf(s->volumeDsId());
const double volOp = v ? v->cs.globalOpacity() : 1.0; // 三维体的总不透明度（参照量）
s->setOpacity(mode, resolveSliceOpacity(mode, volOp));
safeRender();
}
SliceOpacityMode InteractionManager::selectedSliceOpacityMode() const {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return SliceOpacityMode::Full;
return slices_[static_cast<std::size_t>(selected_)]->opacityMode();
}
double InteractionManager::selectedSliceOpacity() const {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return 1.0;
return slices_[static_cast<std::size_t>(selected_)]->opacity();
}
geopro::core::ColorScale InteractionManager::selectedSliceColorScaleSnapshot() const {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return {};
const SliceTool* s = slices_[static_cast<std::size_t>(selected_)].get();
geopro::core::ColorScale cs = s->colorScale(); // 颜色快照（来自三维体）
cs.setGlobalOpacity(s->opacity()); // 当前总不透明度并入 → 切片自己的色阶对象
return cs;
}
void InteractionManager::setSelectedSliceColorScale(const geopro::core::ColorScale& cs) {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return;
SliceTool* s = slices_[static_cast<std::size_t>(selected_)].get();
s->setColorScale(cs);
s->setOpacity(SliceOpacityMode::Full, cs.globalOpacity()); // 已保存切片：不透明度取自其色阶
safeRender();
}
bool InteractionManager::setSliceColorScaleByDsId(const std::string& dsId,
const geopro::core::ColorScale& cs) {
for (const auto& s : slices_) {
if (s->dsId() != dsId) continue;
s->setColorScale(cs);
s->setOpacity(SliceOpacityMode::Full, cs.globalOpacity()); // 不透明度并入其色阶 globalOpacity
safeRender();
return true;
}
return false;
}
vtkImageData* InteractionManager::selectedSliceImage() const {
@ -394,29 +297,37 @@ vtkImageData* InteractionManager::selectedSliceImage() const {
}
vtkSmartPointer<vtkImageData> InteractionManager::selectedSliceColorImage() const {
if (selected_ < 0 || selected_ >= static_cast<int>(slices_.size())) return nullptr;
// 与屏幕切片**同源**的着色输出(widget 自己的 ColorMap 输出, 逐像素一致, RGBA 外区透明)。
// 原先另建 LUT 上色, 与屏幕配色可能不一致(用户实测异常截图与切面差异大) → 改取 widget 着色结果。
auto colored = slices_[static_cast<std::size_t>(selected_)]->coloredResliceImage();
if (colored == nullptr) return nullptr;
vtkImageData* scalar = selectedSliceImage();
if (scalar == nullptr) return nullptr;
// 高清化：切片重采样像素维度受体素分辨率限制(常仅几十px) → 上采样到目标分辨率(双线性, 与屏幕
// TextureInterpolateOn 同口径), 得清晰大图。对 RGBA 直接插值(色已定, 不再过 LUT)。
// 高清导出：切片重采样像素维度受体素网格分辨率限制（常仅几十px）→ 先上采样到目标分辨率
// （最长边 kExportLongSide，保持长宽比、插值），再上色，得到清晰大图。
constexpr int kExportLongSide = 2048;
int dims[3];
colored->GetDimensions(dims);
scalar->GetDimensions(dims);
const int nx = dims[0], ny = dims[1];
const int longest = std::max(nx, ny);
double f = (longest > 0) ? static_cast<double>(kExportLongSide) / longest : 1.0;
if (f < 1.0) f = 1.0; // 不缩小
if (f < 1.0) f = 1.0; // 不缩小（已够大则原样）
vtkNew<vtkImageResize> resize;
resize->SetInputData(colored);
resize->SetInputData(scalar);
resize->SetResizeMethodToOutputDimensions();
resize->SetOutputDimensions(std::max(1, static_cast<int>(nx * f)),
std::max(1, static_cast<int>(ny * f)), 1);
resize->Update();
// 用与切片显示同一色阶 LUT 上色：取选中切片所属体的色阶（多体并发各体色阶不同）。
const VolumeImg* v = (selected_ >= 0 && selected_ < static_cast<int>(slices_.size()))
? volumeOf(slices_[static_cast<std::size_t>(selected_)]->volumeDsId())
: nullptr;
auto lut = v ? buildLut(v->cs, v->vmin, v->vmax) : buildLut(geopro::core::ColorScale{}, 0.0, 1.0);
vtkNew<vtkImageMapToColors> map;
map->SetInputConnection(resize->GetOutputPort());
map->SetLookupTable(lut);
map->SetOutputFormatToRGB();
map->Update();
auto out = vtkSmartPointer<vtkImageData>::New();
out->DeepCopy(resize->GetOutput()); // 脱离 filter 生命周期
out->DeepCopy(map->GetOutput()); // 深拷贝脱离 filter 生命周期
return out;
}

24
src/render/interact/InteractionManager.hpp
View File

@ -60,17 +60,11 @@ public:
std::vector<std::string> shownSavedSliceIds() const; // 当前已显示的已保存切片 dsId 列表
// 选中已显示的某 dsId 切片（列表操作定位到对应渲染切片）；找到返回 true。
bool selectSavedSlice(const std::string& dsId);
// 清除切片选中（列表选中切到别的对象/异常时调用，否则 VTK 切片仍高亮，用户反馈）。
void deselectSlice();
// 关闭选中切片（E56）。无选中则忽略。
void closeSelected();
// 关闭并释放所有切片（切到二维 / 清场 / 体素重建前调）。
void closeAll();
// 切二维分析(is2D=true)/三维分析(false)：翻所有切片显隐(不销毁，切回零重建) + 锁/解锁交互样式
// (二维=仅平移+缩放、禁旋转)。地形/底图/相机由 VtkSceneView::setAnalysisMode2D 处理，此处不渲染。
void setMode2D(bool is2D);
// 关闭并释放某体下的所有切片（该体移除/重建时；不动其它体的切片）。
void closeSlicesOfVolume(const std::string& volumeDsId);
@ -92,20 +86,6 @@ public:
std::string selectedSliceVolumeDsId() const;
// 给当前选中(未保存)切片打 dsId 标签：保存=把当前切片链接到新数据集（不重绘、不重复）。
void tagSelectedSlice(const std::string& dsId);
// ── 切片不透明度（与三维体解耦；总不透明度据所属体不透明度解析）──────────────
// 设置选中切片不透明度模式。无选中则忽略。
void setSelectedSliceOpacity(SliceOpacityMode mode);
// 选中切片当前不透明度模式（菜单勾选当前项用）。无选中返回 Full。
SliceOpacityMode selectedSliceOpacityMode() const;
// 选中切片当前解析后的总不透明度(0~1)（保存切片取具体值用）。无选中返回 1。
double selectedSliceOpacity() const;
// 选中切片色阶快照(颜色 + 当前总不透明度并入 globalOpacity)：保存切片建自己色阶对象用。
geopro::core::ColorScale selectedSliceColorScaleSnapshot() const;
// 用给定色阶覆盖选中切片（已保存切片编辑自己色阶时用；不透明度取该色阶 globalOpacity）。
void setSelectedSliceColorScale(const geopro::core::ColorScale& cs);
// 用给定色阶覆盖指定 dsId 的已显示切片（还原/编辑已保存切片色阶时用，不依赖选中）。找到返回 true。
bool setSliceColorScaleByDsId(const std::string& dsId, const geopro::core::ColorScale& cs);
// 选中切片的重采样 2D 标量影像（导出 dat 用）；无选中返回 nullptr。
vtkImageData* selectedSliceImage() const;
// 选中切片"上色后"的 2D 影像（导出图片用）：重采样标量经切片色阶 LUT → RGB 图；无选中返回 nullptr。
@ -126,10 +106,6 @@ public:
void installStyle();
void uninstallStyle();
// 暴露交互样式：供 app 层注入二维分析 B 期的足迹拾取/Z 拖动回调（onPick2D/onDrag2D/onDrag2DEnd）。
// 定义在 .cpp（此处 PickInteractorStyle 仅前置声明，vtkSmartPointer→裸指针下转需完整类型）。
PickInteractorStyle* pickStyle() const;
private:
// 拾取回调实现（PickInteractorStyle 注入）。
void onPicked(const Vec3& worldPoint); // 选中所在切片 + 焦点

69
src/render/interact/PickInteractorStyle.cpp
View File

@ -1,9 +1,7 @@
#include "interact/PickInteractorStyle.hpp"
#include <chrono>
#include <cmath>
#include <vtkCallbackCommand.h>
#include <vtkCamera.h>
#include <vtkCellPicker.h>
#include <vtkMath.h>
@ -49,22 +47,6 @@ bool PickInteractorStyle::pickWorld(Vec3& out) {
void PickInteractorStyle::OnLeftButtonDown() {
auto* iren = this->GetInteractor();
// 二维分析：左键命中足迹→进入高程 Z 拖动(B 期)；否则=平移(等同中键)，禁旋转。抬键由 OnLeftButtonUp 收尾。
if (lock2D_) {
const int* p = iren ? iren->GetEventPosition() : nullptr;
if (p) this->FindPokedRenderer(p[0], p[1]);
if (!this->CurrentRenderer) return;
const bool additive = iren && iren->GetControlKey(); // Ctrl=多选
if (onPick2D && p && onPick2D(p[0], p[1], additive)) { // 命中足迹 → Z 拖动
dragging2D_ = true;
lastDragY_ = p[1];
this->GrabFocus(this->EventCallbackCommand);
return;
}
this->GrabFocus(this->EventCallbackCommand); // 未命中 → 平移
this->StartPan();
return;
}
Vec3 world;
const bool hit = pickWorld(world);
@ -100,7 +82,6 @@ void PickInteractorStyle::OnLeftButtonDown() {
}
void PickInteractorStyle::Rotate() {
if (lock2D_) return; // 二维分析禁旋转(仅平移+缩放)
Vec3 c;
if (!this->CurrentRenderer || !getRotateCenter || !getRotateCenter(c)) {
Superclass::Rotate(); // 无选中物 → 默认绕焦点旋转
@ -145,62 +126,12 @@ void PickInteractorStyle::Rotate() {
rwi->Render();
}
double PickInteractorStyle::worldPerPixelZ() const {
if (!this->CurrentRenderer) return 1.0;
auto* cam = this->CurrentRenderer->GetActiveCamera();
auto* rw = this->CurrentRenderer->GetRenderWindow();
if (!cam || !rw) return 1.0;
const int* sz = rw->GetSize();
const double h = (sz && sz[1] > 0) ? static_cast<double>(sz[1]) : 800.0;
if (cam->GetParallelProjection())
return 2.0 * cam->GetParallelScale() / h; // 平行投影：可见世界高度=2*parallelScale
// 透视：可见世界高度 = 2*d*tan(viewAngle/2)，d=相机到焦点距离。
double pos[3], fp[3];
cam->GetPosition(pos);
cam->GetFocalPoint(fp);
const double dx = pos[0] - fp[0], dy = pos[1] - fp[1], dz = pos[2] - fp[2];
const double d = std::sqrt(dx * dx + dy * dy + dz * dz);
const double va = vtkMath::RadiansFromDegrees(cam->GetViewAngle());
return 2.0 * d * std::tan(va * 0.5) / h;
}
void PickInteractorStyle::OnMouseMove() {
if (dragging2D_) { // B 期：竖向拖动 → 选中足迹 Z 增量(仅改 Z)。鼠标上移(y 增)→ 抬高。
auto* rwi = this->Interactor;
if (rwi) {
const int y = rwi->GetEventPosition()[1];
const int dyPix = y - lastDragY_;
lastDragY_ = y;
if (dyPix != 0 && onDrag2D) onDrag2D(worldPerPixelZ() * dyPix);
}
return; // 不走基类(不平移/不旋转)
}
Superclass::OnMouseMove();
}
void PickInteractorStyle::OnLeftButtonUp() {
if (dragging2D_) { // 结束 Z 拖动
dragging2D_ = false;
if (this->Interactor) this->ReleaseFocus();
if (onDrag2DEnd) onDrag2DEnd();
return;
}
Superclass::OnLeftButtonUp(); // 平移/旋转/缩放等由基类按 State 收尾
}
namespace {
constexpr double kWheelStepPx = 24.0; // 滚轮一格升降 ≈ 拖动 24 像素的世界 Z 量(与拖动手感一致)
}
void PickInteractorStyle::OnMouseWheelForward() {
// 二维分析有选中足迹 → 滚轮抬升其高程(消费滚轮)；否则按切片推进 / 默认缩放。
if (lock2D_ && onWheel2D && onWheel2D(worldPerPixelZ() * kWheelStepPx)) return;
if (onWheelStep && onWheelStep(+1)) return; // 有选中切片 → 推进，消费滚轮
Superclass::OnMouseWheelForward(); // 否则默认缩放
}
void PickInteractorStyle::OnMouseWheelBackward() {
if (lock2D_ && onWheel2D && onWheel2D(-worldPerPixelZ() * kWheelStepPx)) return;
if (onWheelStep && onWheelStep(-1)) return;
Superclass::OnMouseWheelBackward();
}

26
src/render/interact/PickInteractorStyle.hpp
View File

@ -31,23 +31,6 @@ public:
// 在"按下开始拖动"时调用一次，把焦点设到该中心(位置同步补偿,画面不变)→ 之后绕它旋转、不跳。
std::function<bool(Vec3& center)> getRotateCenter;
// 二维分析锁：开 → 左键拖动改为平移、禁旋转(仅平移+缩放)；关 → 恢复三维拾取/旋转交互。
void setLock2D(bool on) { lock2D_ = on; }
bool isLock2D() const { return lock2D_; }
// ── 二维分析 B 期：选中足迹沿高程 Z 拖动 ──（仅 lock2D 下生效；回调由 app 层注入）
// onPick2D：左键按下时在(x,y)拾取足迹(additive=Ctrl 多选)，返回是否有选中→有则进入 Z 拖动、否则平移。
// onDrag2D：拖动中把竖向像素换算成的世界 Z 增量(本类按相机算)交给 app 施加到选中足迹(仅改 Z)。
// onDrag2DEnd：松开结束拖动(供 app 收起高程读数浮层)。
std::function<bool(int x, int y, bool additive)> onPick2D;
std::function<void(double worldDz)> onDrag2D;
std::function<void()> onDrag2DEnd;
// 滚轮升降：有选中足迹时滚轮改其高程 Z(本类按相机算 worldDz)；app 施加并返回是否消费(无选中→false→默认缩放)。
std::function<bool(double worldDz)> onWheel2D;
void OnMouseMove() override;
void OnLeftButtonUp() override;
void OnLeftButtonDown() override;
void OnMouseWheelForward() override;
void OnMouseWheelBackward() override;
@ -61,20 +44,11 @@ protected:
private:
// 在当前鼠标位置拾取世界点；命中返回 true 并填 out。
bool pickWorld(Vec3& out);
// 当前相机下：竖向一屏幕像素对应的世界 Z（米/像素），用于把拖动像素换算成 Z 增量。
double worldPerPixelZ() const;
// 手动双击判定：QVTK+Windows 下 vtkRenderWindowInteractor::GetRepeatCount() 不可靠（评审 M5）。
// 记上次左键按下时刻+屏幕位置，两次按下间隔 < kDoubleClickMs 且位置相近视为双击。
double lastDownTime_ = -1.0; // 单调时钟(毫秒)，-1=无
int lastDownPos_[2] = {0, 0};
// 二维分析模式：左键=平移、禁旋转(仅平移+缩放)。由 InteractionManager 在切 tab 时设。
bool lock2D_ = false;
// B 期足迹 Z 拖动状态：左键命中足迹时进入，记上次鼠标 y 以算增量。
bool dragging2D_ = false;
int lastDragY_ = 0;
};
} // namespace geopro::render::interact

54
src/render/interact/SliceTool.cpp
View File

@ -6,7 +6,6 @@
#include <vtkCallbackCommand.h>
#include <vtkCommand.h>
#include <vtkImageData.h>
#include <vtkImageMapToColors.h>
#include <vtkImagePlaneWidget.h>
#include <vtkLookupTable.h>
#include <vtkProperty.h>
@ -34,37 +33,9 @@ void SliceTool::initWidget(const geopro::core::ColorScale& cs, double vmin, doub
widget_->TextureInterpolateOn();
widget_->DisplayTextOff();
// 色阶/区间存为单一真源；总不透明度(opacity_)默认 100%。LUT 由 rebuildLut 统一建。
cs_ = cs;
vmin_ = vmin;
vmax_ = vmax;
rebuildLut();
}
void SliceTool::rebuildLut() {
if (!widget_) return;
double vmin = vmin_, vmax = vmax_;
if (vmin >= vmax) vmax = vmin + 1.0;
// 切片渲染单一真源：颜色/单色 alpha 取自 cs_，总不透明度由 opacity_ 覆盖（与三维体解耦）。
geopro::core::ColorScale c = cs_;
c.setGlobalOpacity(opacity_);
// transparentBelowRange=true：体的留空哨兵(vmin-1.0)在切片上映射为透明，白化区不再填蓝。
auto lut = buildLut(c, vmin, vmax, 256, /*transparentBelowRange=*/true);
// 色阶 LUT 套用：用户自管 LUT（不让 widget 用默认灰度窗位）。
auto lut = buildLut(cs, vmin, vmax);
widget_->SetLookupTable(lut);
// 关键：钉死 window/level 到 [vmin,vmax]。否则 vtkImagePlaneWidget 会按【输入标量范围】
// (含哨兵)自动拉伸映射，把哨兵顶到最低色格填蓝（实测 tests/spike/slice_alpha_probe 确诊）。
widget_->SetWindowLevel(vmax - vmin, 0.5 * (vmin + vmax));
}
void SliceTool::setOpacity(SliceOpacityMode mode, double resolved01) {
opacityMode_ = mode;
opacity_ = resolved01 < 0.0 ? 0.0 : (resolved01 > 1.0 ? 1.0 : resolved01);
rebuildLut();
}
void SliceTool::setColorScale(const geopro::core::ColorScale& cs) {
cs_ = cs;
rebuildLut();
}
void SliceTool::applyMarginsAndActivate() {
@ -199,27 +170,6 @@ vtkImageData* SliceTool::reslicedOutput() const {
return widget_ ? widget_->GetResliceOutput() : nullptr;
}
void SliceTool::setInteractive(bool on) {
interactive_ = on; // 记录锁定态：setVisible 重显时复原
if (widget_) widget_->SetInteraction(on ? 1 : 0); // 关=锁移动/旋转/光标，纹理仍显示
}
void SliceTool::setVisible(bool on) {
if (!widget_) return;
widget_->SetEnabled(on ? 1 : 0); // 翻显隐(不销毁)：几何/纹理保留、切回零重建
if (on) widget_->SetInteraction(interactive_ ? 1 : 0); // SetEnabled 可能重置交互→复原锁定态
}
vtkSmartPointer<vtkImageData> SliceTool::coloredResliceImage() const {
if (!widget_) return nullptr;
vtkImageMapToColors* cm = widget_->GetColorMap(); // widget 内部把 reslice 经 LUT 上色 → 纹理
if (cm == nullptr) return nullptr;
cm->Update();
auto out = vtkSmartPointer<vtkImageData>::New();
out->DeepCopy(cm->GetOutput()); // 即屏幕切片所贴像素(RGBA, 外区 alpha=0)
return out;
}
double SliceTool::distanceToPlane(const Vec3& p) const {
const Vec3 c = center();
const Vec3 n = normal();

34
src/render/interact/SliceTool.hpp
View File

@ -16,10 +16,6 @@ class vtkTrivialProducer;
namespace geopro::render::interact {
// 切片不透明度模式（用户右键设置）：满（100%）/ 三维体+50% / 跟随三维体。
// 实际渲染用的"总不透明度"= 据所属三维体的不透明度解析（见 InteractionManager::resolveSliceOpacity）。
enum class SliceOpacityMode { Full, VolumePlus50, FollowVolume };
// 单个切片工具：封装 vtkImagePlaneWidget。
// 内部对体素 vtkImageData 做 reslice + 纹理着色（spec §9.1 钉死 reslice 路线，非 cutter）。
// 轴向(UpDown/FrontBack/LeftRight)：SetPlaneOrientationToX/Y/Z，角度固定。
@ -81,34 +77,12 @@ public:
// 当前切面重采样得到的 2D 标量影像（导出 dat 用）；widget 已释放则 nullptr。
vtkImageData* reslicedOutput() const;
// 与屏幕切片纹理同源的着色输出(widget 自己的 ColorMap 输出, RGBA, 逐像素一致, 外区透明)。
// 异常截图/导出用它而非另建 LUT，避免与屏幕配色不一致(用户实测差异大)。
vtkSmartPointer<vtkImageData> coloredResliceImage() const;
// 开/关 widget 鼠标交互(移动/旋转/光标)。关=锁定但仍显示(已保存切片定稿不可改)；
// 拾取选中/右键菜单由 PickInteractorStyle 独立处理，不受此影响。
void setInteractive(bool on);
// 显/隐切片(切到二维分析时隐藏，切回再显)：SetEnabled 翻显隐而非销毁，几何/位置保留、
// 切回零重建。重显时复原锁定态(SetEnabled 可能把交互重置为开)。
void setVisible(bool on);
// ── 不透明度（切片独立，与三维体解耦）──────────────────────────────────
// 设置不透明度模式 + 已解析的总不透明度(0~1)。颜色映射/单色 alpha 仍由色阶(cs_)给，
// 这里只决定整条切片的"总不透明度"（= cs_.globalOpacity 在切片渲染时被它覆盖）。
void setOpacity(SliceOpacityMode mode, double resolved01);
SliceOpacityMode opacityMode() const { return opacityMode_; }
double opacity() const { return opacity_; } // 已解析的总不透明度(0~1)
// 切换本切片色阶(颜色)：未保存切片跟随三维体改色、已保存切片用自己的色阶。重建 LUT。
void setColorScale(const geopro::core::ColorScale& cs);
const geopro::core::ColorScale& colorScale() const { return cs_; }
// 关闭：Off() 并解除 interactor 绑定（幂等）。
void close();
private:
SliceAxis axis_;
bool interactive_ = true; // 当前是否允许交互(setInteractive 记录)：重显(setVisible)时复原锁定态
std::string dsId_; // 已保存切片归属标签（空=临时交互切片）
std::string volumeDsId_; // 所属三维体 dsId（多体并发用）
vtkImageData* image_; // 非拥有；生命周期由调用方(VtkSceneView 的 currentVolumeImage_)保证
@ -119,15 +93,7 @@ private:
void initWidget(const geopro::core::ColorScale& cs, double vmin, double vmax); // 共享 widget 配置
void applyMarginsAndActivate(); // 按 axis 设旋转锁 + On() + 装交互观察者
void rebuildLut(); // 据 cs_ + opacity_ 重建 LUT 并钉死 window/level
std::array<double, 6> imageBounds() const;
// 色阶(颜色) + 区间 + 总不透明度：切片渲染单一真源（cs_ 提供颜色/单色 alpha，opacity_ 覆盖总不透明度）。
geopro::core::ColorScale cs_;
double vmin_ = 0.0;
double vmax_ = 1.0;
double opacity_ = 1.0; // 已解析的总不透明度(0~1)，默认 100%
SliceOpacityMode opacityMode_ = SliceOpacityMode::Full;
};
} // namespace geopro::render::interact

2
tests/CMakeLists.txt
View File

@ -29,8 +29,6 @@ target_sources(geopro_tests PRIVATE core/test_local_frame.cpp)
target_sources(geopro_tests PRIVATE core/test_model.cpp)
target_sources(geopro_tests PRIVATE core/test_color_scale.cpp)
target_sources(geopro_tests PRIVATE core/test_idw.cpp)
# buildVolume：凸包足迹裁剪 + maxDist=0 自动覆盖测区（对齐客户 Surfer Blanking）。
target_sources(geopro_tests PRIVATE core/test_volume_builder.cpp)
target_sources(geopro_tests PRIVATE core/test_crs_transform.cpp)
target_sources(geopro_tests PRIVATE core/test_model_data.cpp)
target_sources(geopro_tests PRIVATE core/test_geo_frame.cpp)

Some files were not shown because too many files have changed in this diff Show More