diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..ac2b23f
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,2 @@
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f9b7f7b..6bc49e0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,14 +28,6 @@ jobs:
path: dicom-viewer
persist-credentials: false
- - name: Checkout wsi-dicom-annotations
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- with:
- repository: frames-sg/wsi-dicom-annotations
- ref: a623e84405d9be6779e7065a71031228b20849a5
- path: wsi-dicom-annotations
- persist-credentials: false
-
- name: Install Linux GUI dependencies
if: runner.os == 'Linux'
run: |
@@ -108,14 +100,6 @@ jobs:
path: dicom-viewer
persist-credentials: false
- - name: Checkout wsi-dicom-annotations
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- with:
- repository: frames-sg/wsi-dicom-annotations
- ref: a623e84405d9be6779e7065a71031228b20849a5
- path: wsi-dicom-annotations
- persist-credentials: false
-
- name: Install Rust
uses: dtolnay/rust-toolchain@a75363d06101555fc97c6c7e1e65670b99104d98 # 1.96.1
diff --git a/.gitignore b/.gitignore
index d79565e..78f2998 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,55 @@
/.DS_Store
*.profraw
*.profdata
+
+# Local tools, credentials, and editor state
+.DS_Store
+.codex/
+.claude/
+.local-docs/
+.local-tools/
+.codex-security-*/
+reasonix.toml
+.env
+.env.*
+!.env.example
+!.env.sample
+*.key
+*.pem
+*.p12
+*.pfx
+.vscode/
+.idea/
+*.swp
+
+# Local dependencies, build outputs, and caches
+node_modules/
+.venv*/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+/dist/
+/coverage/
+lcov*.info
+*.log
+
+# Private writing and execution plans; maintained outside the software repos
+/manuscript/
+/grant/
+/paper/
+/papers/
+/uscap/
+/docs/manuscript/
+/docs/USCAP*
+/docs/papers/
+/docs/benchmarks/paper/
+/docs/plans/
+/docs/workplans/
+/docs/refactor/
+/docs/superpowers/
+/MIGRATION.md
+/migration.md
+*.docx
+*.pptx
+*.pdf
diff --git a/Cargo.lock b/Cargo.lock
index 6794130..7f722b5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -995,7 +995,6 @@ dependencies = [
"j2k-metal-support",
"j2k-native",
"metal-wgpu-interop",
- "peak_alloc",
"pollster",
"rfd",
"rstar",
@@ -1004,20 +1003,19 @@ dependencies = [
"sha2",
"tempfile",
"thiserror 2.0.20",
+ "tiff",
"uuid",
+ "winresource",
"wsi-dicom-annotations",
]
[[package]]
name = "dicom-viewer-core"
-version = "0.1.0"
+version = "0.1.1"
dependencies = [
"dicom-core",
"dicom-dictionary-std",
- "dicom-encoding",
"dicom-object",
- "dicom-parser",
- "dicom-transfer-syntax-registry",
"geo",
"j2k-metal-support",
"j2k-native",
@@ -1107,6 +1105,18 @@ version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+[[package]]
+name = "dwrote"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b35532432acc8b19ceed096e35dfa088d3ea037fe4f3c085f1f97f33b4d02"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "winapi",
+ "wio",
+]
+
[[package]]
name = "ecolor"
version = "0.34.3"
@@ -1358,11 +1368,10 @@ dependencies = [
[[package]]
name = "epaint"
version = "0.34.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6675898a291ec212fc3df04f537d177fce8496120244590e6359dcaa4c25da79"
dependencies = [
"ahash",
"bytemuck",
+ "dwrote",
"ecolor",
"emath",
"epaint_default_fonts",
@@ -1376,6 +1385,8 @@ dependencies = [
"skrifa",
"smallvec",
"vello_cpu",
+ "winapi",
+ "wio",
]
[[package]]
@@ -1397,7 +1408,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -3334,12 +3345,6 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
-[[package]]
-name = "peak_alloc"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccc90935a8dd139fdf341762773687a1e361d3f54b396a55d9dd1f7001e484bb"
-
[[package]]
name = "peniko"
version = "0.6.1"
@@ -3934,7 +3939,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -4311,7 +4316,7 @@ dependencies = [
"getrandom 0.4.2",
"once_cell",
"rustix 1.1.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -4515,7 +4520,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
dependencies = [
"memoffset",
"tempfile",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -5108,7 +5113,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
]
[[package]]
@@ -5452,6 +5457,24 @@ dependencies = [
"memchr",
]
+[[package]]
+name = "winresource"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "wio"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
+dependencies = [
+ "winapi",
+]
+
[[package]]
name = "wit-bindgen"
version = "0.51.0"
@@ -5554,7 +5577,8 @@ checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
[[package]]
name = "wsi-dicom-annotations"
-version = "0.1.1"
+version = "0.1.2"
+source = "git+https://github.com/frames-sg/wsi-dicom-annotations.git?rev=71851b4a0c286fa9b57326e426962bf1a63a781e#71851b4a0c286fa9b57326e426962bf1a63a781e"
dependencies = [
"chrono",
"dicom-core",
diff --git a/Cargo.toml b/Cargo.toml
index 1dc9b8c..18ea948 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ members = [
"crates/dicom-viewer-core",
"crates/metal-wgpu-interop",
]
-exclude = ["vendor/lru", "vendor/wayland-scanner"]
+exclude = ["vendor/epaint", "vendor/lru", "vendor/wayland-scanner"]
[workspace.package]
edition = "2021"
@@ -16,10 +16,7 @@ repository = "https://github.com/frames-sg/dicom-viewer"
[workspace.dependencies]
dicom-core = "0.9"
dicom-dictionary-std = "0.9"
-dicom-encoding = "0.9"
dicom-object = "0.9"
-dicom-parser = "0.9"
-dicom-transfer-syntax-registry = { version = "0.9", default-features = false }
eframe = { version = "0.34.2", default-features = false, features = [
"accesskit",
"default_fonts",
@@ -43,17 +40,18 @@ serde = { version = "1", features = ["derive", "rc"] }
wsi-rs = { version = "0.6.0", git = "https://github.com/frames-sg/wsi-rs.git", rev = "b940ea94f3290e54ca2c5f87823109538709c59d" }
tempfile = "3"
thiserror = "2"
+tiff = "0.11.3"
lcms2 = { version = "6.1.1", features = ["static"] }
sha2 = "0.10"
uuid = { version = "1", features = ["serde", "v4"] }
geo = { version = "0.33.1", default-features = false }
rstar = "0.12.2"
-peak_alloc = "0.3"
-wsi-dicom-annotations = { version = "=0.1.1", path = "../wsi-dicom-annotations" }
+wsi-dicom-annotations = { version = "=0.1.2", git = "https://github.com/frames-sg/wsi-dicom-annotations.git", rev = "71851b4a0c286fa9b57326e426962bf1a63a781e" }
-# Temporary security patches for advisories without compatible upstream
-# releases. See each vendored crate's SECURITY-PATCH.md for removal criteria.
+# Dependency patches and the Windows font backend; see SUPPLY_CHAIN.md.
+# Security-patched crates retain their SECURITY-PATCH.md removal criteria.
[patch.crates-io]
+epaint = { path = "vendor/epaint" }
lru = { path = "vendor/lru" }
wayland-scanner = { path = "vendor/wayland-scanner" }
diff --git a/README.md b/README.md
index 950cb7f..b6dd003 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,6 @@
Lightweight desktop viewer for local whole-slide image files through `wsi-rs`.
-This application is for research use only. It is not a medical device and is
-not intended for diagnosis, treatment decisions, or other clinical use. Use
-only research inputs that contain no patient data; the viewer does not perform
-de-identification or validate that an input is free of identifying metadata.
-
The app is intended for checking `wsi-dicom` output locally and for verifying
other wsi-rs-supported WSI inputs. It does not upload files or use DICOMweb.
Its facts panel reads only the technical WSI tags documented below; local file
@@ -14,7 +9,7 @@ paths can still be visible in the UI and in screenshots.
See [Architecture](docs/ARCHITECTURE.md) for ownership, scheduling, cache, and
Metal interoperability invariants, the [pathology annotation
-workflow](docs/ANNOTATION_WORKFLOW.md), and the [research release
+workflow](docs/ANNOTATION_WORKFLOW.md), and the [release
checklist](docs/RELEASE.md) for distribution gates.
## Build
@@ -27,6 +22,15 @@ complete revisions, so no sibling codec checkout is required.
cargo run -p dicom-viewer
```
+Build the standalone Windows GUI executable on an x86-64 Windows host with:
+
+```powershell
+cargo build -p dicom-viewer --bin dicom-viewer --release --locked
+```
+
+The Windows build statically links the MSVC runtime, so the resulting
+`target\release\dicom-viewer.exe` requires no application-specific sidecar DLLs.
+
wgpu is the only presentation backend on every platform. On macOS, ordinary
builds automatically enable `wsi-rs` Metal decoding and use the renderer's
exact Metal device; resident RGB tiles are converted to RGBA by a wgpu compute
@@ -81,7 +85,7 @@ space, wsi-rs source caches, or GPU driver overhead.
DICOM inspection rejects metadata beyond explicit resource limits before the
eager object parser runs: 1 MiB of file-meta data, 16 MiB per primitive value,
128 MiB of cumulative primitive values, two million metadata tokens, and 64
-nested sequences. These are research-viewer safety limits rather than DICOM
+nested sequences. These are viewer safety limits rather than DICOM
conformance claims.
## Pathology annotation workspace
@@ -129,10 +133,20 @@ contract](docs/FRAMES_PATHOLOGY_GEOJSON_V1.md), [tumor-mask compatibility
adapter](docs/TUMOR_MASK_COMPATIBILITY.md), and [workspace storage/privacy
notes](docs/WORKSPACE_STORAGE.md).
+### Annotation dependency source
+
+Annotations 0.1.2 is pinned to immutable Git revision
+`71851b4a0c286fa9b57326e426962bf1a63a781e` in `frames-sg/wsi-dicom-annotations`.
+That revision owns the shared metadata reader and headless CLI. CI checks out only
+the viewer; Cargo resolves the owner without a sibling directory or local overlay.
+The dependency remains versioned and locked. A later registry migration requires
+publication of the matching API and a reviewed lockfile refresh.
+
### Headless annotation interoperability probe
-`annotation_probe` is a thin CLI over the separately versioned
-`wsi-dicom-annotations` library. It exposes ANN/SEG parsing and rewriting plus
+`annotation_probe` is maintained in the `wsi-dicom-annotations` repository as the
+`wsi-annotation-probe` package. Build it there with
+`cargo build -p wsi-annotation-probe --bin annotation_probe --locked`. It exposes ANN/SEG parsing and rewriting plus
Rust-owned GeoJSON and raster conversion without the GUI. It writes one
schema-versioned JSON object to stdout; warnings and human-readable failures go
to stderr.
@@ -207,8 +221,6 @@ Dual-licensed under either [MIT](LICENSE-MIT) or
## Current Scope
-- Research-use-only operation with non-patient inputs; no clinical claims or
- de-identification workflow.
- Desktop-only `egui/eframe` app with a unified wgpu renderer.
- Open one wsi-rs-supported WSI file or a folder of DICOM instances.
- View WSI levels as tiled RGB/RGBA pixels through `wsi-rs`.
diff --git a/SUPPLY_CHAIN.md b/SUPPLY_CHAIN.md
index 92bba98..a7d26fc 100644
--- a/SUPPLY_CHAIN.md
+++ b/SUPPLY_CHAIN.md
@@ -15,7 +15,7 @@ The production raster boundary adds only these direct crates:
- `npyz = 0.9.1` (MIT): no optional features are enabled. The crate publishes
no `rust-version`, so compatibility is established by the locked workspace
build on Rust 1.96 rather than an upstream MSRV declaration.
-- `zarrs = 0.23.13` (MIT OR Apache-2.0, declared Rust 1.91): defaults are
+- `zarrs = 0.23.14` (MIT OR Apache-2.0, declared Rust 1.91): defaults are
disabled; only `filesystem`, `blosc`, `crc32c`, `gzip`, `sharding`, and
`zstd` are enabled. The application exposes only a local filesystem array
path and does not compile the `ndarray`, async, remote-store, or optional
@@ -31,10 +31,16 @@ input surface.
## Temporary security patch
+The local `vendor/epaint` 0.34.3 integration also supplies the Windows DirectWrite
+font backend. It adds `dwrote` 0.11.5 on Windows. The license policy permits
+MPL-2.0 only for that exact crate version, with source and distribution notices
+in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). This font integration is
+separate from the security patches below.
+
`vendor/lru` is the crates.io `lru 0.16.4` source with the upstream
panic-safety fix and regression test from commit
`f9a7f00fcf2d33e00adb03758cb350aaaa52cddb`. This addresses
-RUSTSEC-2026-0253 while `zarrs 0.23.13` still requires `lru 0.16.x`. See
+RUSTSEC-2026-0253 while `zarrs 0.23.14` still requires `lru 0.16.x`. See
`vendor/lru/SECURITY-PATCH.md` for source, checksum, and removal criteria.
`vendor/wayland-scanner` is the crates.io `wayland-scanner 0.31.10` source with
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
new file mode 100644
index 0000000..8f26633
--- /dev/null
+++ b/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,15 @@
+# Third-party notices
+
+## dwrote 0.11.5 — Windows DirectWrite binding
+
+Windows builds use the unmodified `dwrote` crate through the local epaint font
+backend. Its authors are the Servo Project Developers and Vladimir Vukicevic.
+The crate is licensed under the [Mozilla Public License 2.0](https://www.mozilla.org/en-US/MPL/2.0/).
+
+The corresponding source is available in the
+[0.11.5 registry package](https://crates.io/crates/dwrote/0.11.5) and at its
+[recorded upstream revision](https://github.com/servo/dwrote-rs/tree/5bbe910f7156213cdbaca4e1addfe85ea8b421ef).
+
+Include this notice and the MPL 2.0 license text in Windows release packages.
+If this dependency is modified, provide the corresponding modified covered source
+and retain its license notices. See [Mozilla's distribution guidance](https://www.mozilla.org/en-US/MPL/2.0/FAQ/).
diff --git a/apps/dicom-viewer/Cargo.toml b/apps/dicom-viewer/Cargo.toml
index 0d6669e..bc8f5e5 100644
--- a/apps/dicom-viewer/Cargo.toml
+++ b/apps/dicom-viewer/Cargo.toml
@@ -1,6 +1,7 @@
[package]
name = "dicom-viewer"
version = "0.1.0"
+build = "build.rs"
edition.workspace = true
rust-version.workspace = true
license.workspace = true
@@ -11,19 +12,22 @@ default = []
cuda = ["dicom-viewer-core/cuda"]
[dependencies]
-dicom-viewer-core = { version = "=0.1.0", path = "../../crates/dicom-viewer-core" }
+dicom-viewer-core = { version = "=0.1.1", path = "../../crates/dicom-viewer-core" }
wsi-dicom-annotations = { workspace = true }
eframe = { workspace = true }
rfd = { workspace = true }
serde_json = { workspace = true }
serde = { workspace = true }
-peak_alloc = { workspace = true }
sha2 = { workspace = true }
tempfile = { workspace = true }
thiserror = { workspace = true }
+tiff = { workspace = true }
uuid = { workspace = true }
rstar = { workspace = true }
+[build-dependencies]
+winresource = { version = "0.1.31", default-features = false }
+
[target.'cfg(target_os = "macos")'.dependencies]
j2k-metal-support = { workspace = true }
metal-wgpu-interop = { version = "=0.1.0", path = "../../crates/metal-wgpu-interop" }
diff --git a/apps/dicom-viewer/assets/app-icon.ico b/apps/dicom-viewer/assets/app-icon.ico
new file mode 100644
index 0000000..298d13e
Binary files /dev/null and b/apps/dicom-viewer/assets/app-icon.ico differ
diff --git a/apps/dicom-viewer/assets/app-icon.png b/apps/dicom-viewer/assets/app-icon.png
new file mode 100644
index 0000000..4da3a7a
Binary files /dev/null and b/apps/dicom-viewer/assets/app-icon.png differ
diff --git a/apps/dicom-viewer/assets/app-icon.svg b/apps/dicom-viewer/assets/app-icon.svg
new file mode 100644
index 0000000..0732583
--- /dev/null
+++ b/apps/dicom-viewer/assets/app-icon.svg
@@ -0,0 +1,7 @@
+
+
diff --git a/apps/dicom-viewer/build.rs b/apps/dicom-viewer/build.rs
new file mode 100644
index 0000000..2ce0d0b
--- /dev/null
+++ b/apps/dicom-viewer/build.rs
@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+fn main() {
+ println!("cargo:rerun-if-changed=assets/app-icon.ico");
+ if std::env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
+ return;
+ }
+
+ let icon = PathBuf::from(
+ std::env::var_os("CARGO_MANIFEST_DIR")
+ .expect("Cargo must provide the package manifest directory"),
+ )
+ .join("assets")
+ .join("app-icon.ico");
+ let icon = icon
+ .to_str()
+ .expect("the embedded icon path must be valid UTF-8");
+
+ let mut resource = winresource::WindowsResource::new();
+ resource
+ .set_icon(icon)
+ .set("FileDescription", "Slide Viewer")
+ .set("ProductName", "Slide Viewer")
+ .set("OriginalFilename", "Slide-Viewer.exe")
+ .compile()
+ .expect("failed to embed the Slide Viewer Windows resources");
+}
diff --git a/apps/dicom-viewer/src/app.rs b/apps/dicom-viewer/src/app.rs
index 8460817..5c42153 100644
--- a/apps/dicom-viewer/src/app.rs
+++ b/apps/dicom-viewer/src/app.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
use std::time::{Duration, Instant};
use dicom_viewer_core::{TileDecodeBackend, ViewerStudy};
-use eframe::egui::{self, Frame, Sense};
+use eframe::egui;
mod annotation_actions;
mod annotation_job;
@@ -11,6 +11,7 @@ mod background_worker;
mod bounded_input;
mod camera;
mod canvas;
+mod canvas_frame;
mod export_job;
mod format;
mod level_warmer;
@@ -25,6 +26,7 @@ mod theme;
mod tile;
mod ui;
mod viewport;
+mod viewport_export;
mod workspace;
mod workspace_actions;
mod workspace_dialogs;
@@ -32,9 +34,11 @@ mod workspace_interaction;
use annotation_job::AnnotationLoadResult;
use background_worker::BackgroundWorker;
-use camera::{wheel_zoom_factor, CameraState};
+#[cfg(test)]
+use camera::{raw_wheel_delta_y, wheel_zoom_factor};
#[cfg(test)]
use camera::{CameraMotion, CameraView, MAX_ZOOM, MIN_ZOOM};
+use camera::{CameraState, WheelZoomSettings};
use canvas::SlideCanvas;
use export_job::WorkspaceExportJob;
use open_job::{OpenPoll, OpenQueue};
@@ -43,16 +47,16 @@ use raster::RasterState;
use report::ReportState;
use ui::chrome::{show_status_bar, show_toolbar, ToolbarState};
use ui::facts::show_facts_sidebar;
-use ui::overlay::{
- draw_canvas_overlays, paint_canvas_background, paint_empty_state, FrameStats, OverlayInfo,
-};
-use ui::pathology_workspace::{show_pathology_workspace_panel, show_tool_rail};
+use ui::overlay::FrameStats;
+use ui::pathology_workspace::{show_populated_pathology_workspace_panel, show_tool_rail};
+#[cfg(test)]
use viewport::screen_to_base;
#[cfg(test)]
use viewport::{choose_render_level, visible_tiles};
+use viewport_export::PendingViewportExport;
use workspace::{
- draw_external_layer_overlays, draw_workspace_overlay, AutosaveStatus, RestoredWorkspace,
- RevisionStore, SchemeLibrary, WorkspaceAutosave, WorkspaceRuntime, WorkspaceSaveRequest,
+ AutosaveStatus, RestoredWorkspace, RevisionStore, SchemeLibrary, WorkspaceAutosave,
+ WorkspaceRuntime, WorkspaceSaveRequest,
};
#[cfg(test)]
@@ -69,6 +73,7 @@ const VISIBLE_UPLOAD_BUDGET: Duration = Duration::from_millis(6);
const MAX_TRANSITION_UPLOADS_PER_FRAME: usize = 2;
const MAX_PREFETCH_UPLOADS_PER_FRAME: usize = 4;
const PREFETCH_UPLOAD_BUDGET: Duration = Duration::from_millis(1);
+const WHEEL_ZOOM_STORAGE_KEY: &str = "dicom-viewer-wheel-zoom-v1";
pub struct DicomViewerApp {
study: Option>,
@@ -80,11 +85,15 @@ pub struct DicomViewerApp {
frame_stats: FrameStats,
camera: CameraState,
show_facts_panel: bool,
+ show_pathology_workspace: bool,
+ wheel_zoom: WheelZoomSettings,
pathology: PathologyState,
report: ReportState,
raster: RasterState,
annotation_load_job: Option>,
workspace_export_job: Option,
+ pending_viewport_export: Option,
+ last_canvas_rect: Option,
active_path: Option,
reported_cpu_fallbacks: usize,
workspace: Option,
@@ -249,6 +258,13 @@ impl DicomViewerApp {
pub fn new(cc: &eframe::CreationContext<'_>, initial_path: Option) -> Self {
theme::install_visuals(&cc.egui_ctx);
+ let wheel_zoom = cc
+ .storage
+ .and_then(|storage| {
+ eframe::get_value::(storage, WHEEL_ZOOM_STORAGE_KEY)
+ })
+ .unwrap_or_default()
+ .sanitized();
let render_state = cc
.wgpu_render_state
.clone()
@@ -283,11 +299,15 @@ impl DicomViewerApp {
frame_stats: FrameStats::default(),
camera: CameraState::default(),
show_facts_panel: false,
+ show_pathology_workspace: false,
+ wheel_zoom,
pathology: PathologyState::default(),
report: ReportState::default(),
raster: RasterState::default(),
annotation_load_job: None,
workspace_export_job: None,
+ pending_viewport_export: None,
+ last_canvas_rect: None,
active_path: None,
reported_cpu_fallbacks: 0,
workspace: None,
@@ -377,12 +397,15 @@ impl DicomViewerApp {
job.cancel();
}
self.workspace_export_job = None;
+ self.pending_viewport_export = None;
+ self.last_canvas_rect = None;
self.active_path = None;
self.reported_cpu_fallbacks = 0;
self.workspace = None;
self.autosave = None;
self.pending_restore = None;
self.pending_scheme_migration = None;
+ self.show_pathology_workspace = false;
self.show_import_wizard = false;
self.show_export_wizard = false;
self.last_queued_workspace_revision = None;
@@ -507,7 +530,71 @@ fn reconcile_discovered_sidecar_stubs(
Ok(())
}
+impl DicomViewerApp {
+ fn show_app_toolbar(&mut self, ui: &mut egui::Ui) -> ui::chrome::ToolbarActions {
+ let has_study = self.study.is_some();
+
+ let autosave_label = self.autosave_label();
+ let (can_undo, can_redo) = self.workspace.as_ref().map_or((false, false), |runtime| {
+ (runtime.can_undo(), runtime.can_redo())
+ });
+ show_toolbar(
+ ui,
+ ToolbarState {
+ has_study,
+ show_facts: &mut self.show_facts_panel,
+ show_pathology: &mut self.show_pathology_workspace,
+ can_undo,
+ can_redo,
+ autosave_status: &autosave_label,
+ export_running: self.workspace_export_job.is_some()
+ || self.pending_viewport_export.is_some(),
+ export_cancel_requested: self
+ .workspace_export_job
+ .as_ref()
+ .is_some_and(WorkspaceExportJob::cancellation_requested),
+ smooth_camera: self.camera.smoothing_enabled_mut(),
+ wheel_zoom: &mut self.wheel_zoom,
+ },
+ )
+ }
+
+ fn apply_toolbar_actions(&mut self, ctx: &egui::Context, actions: &ui::chrome::ToolbarActions) {
+ if actions.open_file {
+ self.pick_file(ctx);
+ }
+ if actions.open_folder {
+ self.pick_folder(ctx);
+ }
+ if actions.undo && self.workspace.as_mut().is_some_and(WorkspaceRuntime::undo) {
+ self.status = "Undid the last pathology command.".into();
+ }
+ if actions.redo && self.workspace.as_mut().is_some_and(WorkspaceRuntime::redo) {
+ self.status = "Redid the pathology command.".into();
+ }
+ if actions.import {
+ self.show_pathology_workspace = true;
+ self.show_import_wizard = true;
+ }
+ if actions.export {
+ self.show_export_wizard = true;
+ }
+ if actions.cancel_export {
+ if let Some(job) = &self.workspace_export_job {
+ job.cancel();
+ self.status = "Cancelling export; the destination will remain unchanged…".into();
+ } else if self.pending_viewport_export.take().is_some() {
+ self.status = "Cancelled current view capture.".into();
+ }
+ }
+ }
+}
+
impl eframe::App for DicomViewerApp {
+ fn save(&mut self, storage: &mut dyn eframe::Storage) {
+ eframe::set_value(storage, WHEEL_ZOOM_STORAGE_KEY, &self.wheel_zoom);
+ }
+
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.poll_workspace_autosave();
if ctx.input(|input| input.viewport().close_requested()) {
@@ -545,6 +632,7 @@ impl eframe::App for DicomViewerApp {
self.handle_dropped_files(ctx);
self.poll_open_job(ctx);
self.poll_annotation_jobs(ctx);
+ self.poll_current_view_tiff_export(ctx);
self.poll_workspace_export_job(ctx);
self.poll_pathology_job();
self.poll_report_job();
@@ -556,57 +644,13 @@ impl eframe::App for DicomViewerApp {
let (stable_dt, predicted_dt) = ui.input(|input| (input.stable_dt, input.predicted_dt));
self.frame_stats.record(stable_dt, predicted_dt);
- let has_study = self.study.is_some();
-
- let autosave_label = self.autosave_label();
- let (can_undo, can_redo) = self.workspace.as_ref().map_or((false, false), |runtime| {
- (runtime.can_undo(), runtime.can_redo())
- });
- let actions = show_toolbar(
- ui,
- ToolbarState {
- has_study,
- show_facts: &mut self.show_facts_panel,
- can_undo,
- can_redo,
- autosave_status: &autosave_label,
- export_running: self.workspace_export_job.is_some(),
- export_cancel_requested: self
- .workspace_export_job
- .as_ref()
- .is_some_and(WorkspaceExportJob::cancellation_requested),
- smooth_camera: self.camera.smoothing_enabled_mut(),
- },
- );
- if actions.open_file {
- self.pick_file(ui.ctx());
- }
- if actions.open_folder {
- self.pick_folder(ui.ctx());
- }
+ let actions = self.show_app_toolbar(ui);
+ self.apply_toolbar_actions(ui.ctx(), &actions);
// Opening replaces the active study and generation. Refresh the frame
// snapshot after the modal picker returns so this frame cannot submit
// work for the previous study under the replacement generation.
let study = self.study.clone();
let opening = self.open_queue.is_opening();
- if actions.undo && self.workspace.as_mut().is_some_and(WorkspaceRuntime::undo) {
- self.status = "Undid the last pathology command.".into();
- }
- if actions.redo && self.workspace.as_mut().is_some_and(WorkspaceRuntime::redo) {
- self.status = "Redid the pathology command.".into();
- }
- if actions.import {
- self.show_import_wizard = true;
- }
- if actions.export {
- self.show_export_wizard = true;
- }
- if actions.cancel_export {
- if let Some(job) = &self.workspace_export_job {
- job.cancel();
- }
- self.status = "Cancelling export; the destination will remain unchanged…".into();
- }
show_status_bar(
ui,
&self.status,
@@ -619,176 +663,21 @@ impl eframe::App for DicomViewerApp {
self.active_generation,
study.as_ref().map(|study| study.summary()),
);
- if let Some(runtime) = &mut self.workspace {
- if let Some(error) = show_tool_rail(ui, runtime) {
- self.status = error;
- }
- let panel_actions = show_pathology_workspace_panel(ui, runtime);
- self.handle_pathology_workspace_actions(panel_actions, ui.ctx());
- }
- self.show_workspace_dialogs(ui.ctx());
- // ── Central canvas ─────────────────────────────────────────
- egui::CentralPanel::default_margins()
- .frame(Frame::NONE.fill(theme::CANVAS))
- .show_inside(ui, |ui| {
- let rect = ui.available_rect_before_wrap();
- let response = ui.allocate_rect(rect, Sense::click_and_drag());
- if response.clicked() || response.drag_started() {
- response.request_focus();
- } else if ui.input(|input| input.pointer.any_pressed()) && !response.hovered() {
- response.surrender_focus();
+ if self.show_pathology_workspace {
+ if let Some(runtime) = &mut self.workspace {
+ if let Some(error) = show_tool_rail(ui, runtime) {
+ self.status = error;
}
- let painter = ui.painter_at(rect);
- paint_canvas_background(&painter, rect);
-
- let Some(study) = study.clone() else {
- paint_empty_state(&painter, rect, opening);
- return;
- };
-
- if actions.fit {
- self.canvas.record_zoom_input();
- self.camera.request_fit();
- }
- self.camera.prepare_canvas(rect, study.summary());
- if actions.zoom_out {
- self.canvas.record_zoom_input();
- self.camera.zoom_about_center(rect, 0.8);
- }
- if actions.zoom_in {
- self.canvas.record_zoom_input();
- self.camera.zoom_about_center(rect, 1.25);
- }
-
- let accepts_keys =
- (response.hovered() || response.has_focus()) && !ui.ctx().text_edit_focused();
- let zoom_before_keys = self.camera.target_view().zoom;
- if self.camera.handle_keys(ui, rect, accepts_keys) {
- if (self.camera.target_view().zoom - zoom_before_keys).abs() > f32::EPSILON {
- self.canvas.record_zoom_input();
+ if let Some(panel_actions) = show_populated_pathology_workspace_panel(ui, runtime) {
+ if panel_actions.close_panel {
+ self.show_pathology_workspace = false;
}
- ui.ctx().request_repaint();
- }
-
- let camera_frame = self.camera.frame(rect, study.summary(), stable_dt);
- if camera_frame.animating {
- ui.ctx().request_repaint();
+ self.handle_pathology_workspace_actions(panel_actions, ui.ctx());
}
- let workspace_interaction = self.handle_workspace_interaction(
- ui,
- &response,
- rect,
- study.summary(),
- camera_frame.rendered,
- accepts_keys,
- );
-
- if workspace_interaction.pan_requested {
- self.camera
- .pan_by_rendered(response.drag_delta(), camera_frame.rendered);
- ui.ctx().request_repaint();
- }
- if response.double_clicked() && !workspace_interaction.click_consumed {
- let pointer = response.interact_pointer_pos().unwrap_or(rect.center());
- self.canvas.record_zoom_input();
- self.camera
- .zoom_around_rendered(rect, pointer, 2.0, camera_frame.rendered);
- ui.ctx().request_repaint();
- }
-
- if response.hovered() {
- let scroll_y = ui.input(|input| input.smooth_scroll_delta.y);
- if scroll_y.abs() > 0.0 {
- let pointer = ui
- .input(|input| input.pointer.hover_pos())
- .unwrap_or(rect.center());
- self.canvas.record_zoom_input();
- self.camera.zoom_around_rendered(
- rect,
- pointer,
- wheel_zoom_factor(scroll_y),
- camera_frame.rendered,
- );
- ui.ctx().request_repaint();
- }
- let pinch = ui.input(|input| input.zoom_delta());
- if (pinch - 1.0).abs() > 0.001 {
- let pointer = ui
- .input(|input| input.pointer.hover_pos())
- .unwrap_or(rect.center());
- self.canvas.record_zoom_input();
- self.camera.zoom_around_rendered(
- rect,
- pointer,
- pinch,
- camera_frame.rendered,
- );
- ui.ctx().request_repaint();
- }
- if ui.input(|input| input.pointer.any_down()) {
- ui.ctx().request_repaint();
- }
- }
-
- self.canvas.paint(
- ui.ctx(),
- &painter,
- rect,
- &study,
- self.active_generation,
- camera_frame,
- );
- if let Some(runtime) = &mut self.workspace {
- if let Err(error) = runtime.refresh_spatial_index() {
- self.status =
- format!("Could not update annotation viewport index: {error}");
- }
- }
- if let Some((count, reason)) = self.canvas.cpu_fallback() {
- if count > self.reported_cpu_fallbacks {
- self.reported_cpu_fallbacks = count;
- self.status = format!(
- "{} preferred → wgpu; CPU fallback used for {count} tile(s): {reason}",
- study.summary().tile_decode_backend
- );
- }
- }
-
- let hover_base = response.hover_pos().map(|p| {
- screen_to_base(
- rect,
- p,
- camera_frame.rendered.center_base,
- camera_frame.rendered.zoom,
- )
- });
- let tile_failure = self.canvas.tile_failure();
- let debug_stats = self.canvas.debug_stats_text();
- draw_canvas_overlays(
- &painter,
- rect,
- OverlayInfo {
- summary: study.summary(),
- zoom: camera_frame.rendered.zoom,
- frame_rate: self.frame_stats.info(),
- hover_base,
- tile_failure,
- debug_stats: debug_stats.as_deref(),
- },
- );
- if let Some(runtime) = &self.workspace {
- if let Some(context) = study.annotation_context() {
- draw_external_layer_overlays(
- &painter,
- rect,
- runtime,
- context,
- camera_frame.rendered,
- );
- }
- draw_workspace_overlay(&painter, rect, runtime, camera_frame.rendered);
- }
- });
+ }
+ }
+ self.show_workspace_dialogs(ui.ctx());
+ self.show_canvas(ui, study.as_ref(), opening, &actions, stable_dt);
self.queue_workspace_autosave();
if self
.autosave
diff --git a/apps/dicom-viewer/src/app/camera.rs b/apps/dicom-viewer/src/app/camera.rs
index 806d586..0c9a3a8 100644
--- a/apps/dicom-viewer/src/app/camera.rs
+++ b/apps/dicom-viewer/src/app/camera.rs
@@ -10,6 +10,60 @@ const CAMERA_SMOOTHING_RESPONSE: f32 = 22.0;
const CAMERA_SMOOTHING_SNAP_PX: f32 = 0.25;
const CAMERA_SMOOTHING_SNAP_ZOOM: f32 = 0.0005;
const WHEEL_ZOOM_SENSITIVITY: f32 = 0.0015;
+const MIN_WHEEL_ZOOM_SPEED: f32 = 0.25;
+const MAX_WHEEL_ZOOM_SPEED: f32 = 4.0;
+const MAX_WHEEL_ZOOM_EXPONENT: f32 = 1.5;
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(default)]
+pub(super) struct WheelZoomSettings {
+ speed: f32,
+ inverted: bool,
+}
+
+impl WheelZoomSettings {
+ pub(super) fn for_os(os: &str) -> Self {
+ if os == "windows" {
+ Self::new(2.0, false)
+ } else {
+ Self::new(1.0, true)
+ }
+ }
+
+ pub(super) fn new(speed: f32, inverted: bool) -> Self {
+ Self { speed, inverted }.sanitized()
+ }
+
+ pub(super) fn speed(self) -> f32 {
+ self.speed
+ }
+
+ pub(super) fn speed_mut(&mut self) -> &mut f32 {
+ &mut self.speed
+ }
+
+ pub(super) fn inverted(self) -> bool {
+ self.inverted
+ }
+
+ pub(super) fn inverted_mut(&mut self) -> &mut bool {
+ &mut self.inverted
+ }
+
+ pub(super) fn sanitized(mut self) -> Self {
+ if !self.speed.is_finite() {
+ self.speed = 1.0;
+ }
+ self.speed = self.speed.clamp(MIN_WHEEL_ZOOM_SPEED, MAX_WHEEL_ZOOM_SPEED);
+ self
+ }
+}
+
+impl Default for WheelZoomSettings {
+ fn default() -> Self {
+ Self::for_os(std::env::consts::OS)
+ }
+}
fn clamp_camera_view_to_min(view: &mut CameraView, summary: &StudySummary, minimum_zoom: f32) {
view.zoom = view.zoom.clamp(minimum_zoom, MAX_ZOOM);
@@ -196,6 +250,28 @@ impl CameraState {
}
}
+ pub(super) fn retarget_frame(
+ &mut self,
+ rendered: CameraView,
+ summary: &StudySummary,
+ ) -> CameraFrame {
+ clamp_camera_view_to_min(&mut self.target, summary, self.minimum_zoom);
+ if !self.motion.enabled || camera_is_settled(rendered, self.target) {
+ self.motion.reset(self.target);
+ return CameraFrame {
+ rendered: self.target,
+ target: self.target,
+ animating: false,
+ };
+ }
+
+ CameraFrame {
+ rendered,
+ target: self.target,
+ animating: true,
+ }
+ }
+
pub(super) fn pan_by(&mut self, delta_screen: Vec2) {
if delta_screen == Vec2::ZERO {
return;
@@ -353,8 +429,32 @@ fn smooth_zoom(current: f32, target: f32, alpha: f32) -> f32 {
.clamp(MIN_ZOOM, MAX_ZOOM)
}
-pub(super) fn wheel_zoom_factor(scroll_y: f32) -> f32 {
- (-scroll_y * WHEEL_ZOOM_SENSITIVITY).exp()
+pub(super) fn wheel_zoom_factor(scroll_y: f32, settings: WheelZoomSettings) -> f32 {
+ let direction = if settings.inverted() { -1.0 } else { 1.0 };
+ (scroll_y * WHEEL_ZOOM_SENSITIVITY * settings.speed() * direction)
+ .clamp(-MAX_WHEEL_ZOOM_EXPONENT, MAX_WHEEL_ZOOM_EXPONENT)
+ .exp()
+}
+
+pub(super) fn raw_wheel_delta_y(input: &egui::InputState) -> f32 {
+ let line_scroll_speed = egui::InputOptions::default().line_scroll_speed;
+ input
+ .events
+ .iter()
+ .filter_map(|event| match event {
+ egui::Event::MouseWheel {
+ unit,
+ delta,
+ modifiers,
+ ..
+ } if !modifiers.command => Some(match unit {
+ egui::MouseWheelUnit::Point => delta.y,
+ egui::MouseWheelUnit::Line => delta.y * line_scroll_speed,
+ egui::MouseWheelUnit::Page => delta.y * input.viewport_rect().height(),
+ }),
+ _ => None,
+ })
+ .sum()
}
fn camera_is_settled(rendered: CameraView, target: CameraView) -> bool {
diff --git a/apps/dicom-viewer/src/app/canvas.rs b/apps/dicom-viewer/src/app/canvas.rs
index c42fe00..1a5ccda 100644
--- a/apps/dicom-viewer/src/app/canvas.rs
+++ b/apps/dicom-viewer/src/app/canvas.rs
@@ -300,6 +300,21 @@ impl SlideCanvas {
);
}
}
+ if let Some(level) =
+ sharpening_transition_level(summary, plan.render_level, plan.prefetch_level)
+ .and_then(|level| level_by_index(summary, level))
+ {
+ for tile in &plan.prefetch {
+ self.tiles.draw_ready_tile(
+ painter,
+ rect,
+ level,
+ tile,
+ camera.rendered.center_base,
+ camera.rendered.zoom,
+ );
+ }
+ }
painter.rect_stroke(
slide_rect,
@@ -384,6 +399,19 @@ fn interaction_measurement_target(
}
}
+fn sharpening_transition_level(
+ summary: &StudySummary,
+ rendered_level: LevelIndex,
+ target_level: LevelIndex,
+) -> Option {
+ if rendered_level == target_level {
+ return None;
+ }
+ let rendered = level_by_index(summary, rendered_level)?;
+ let target = level_by_index(summary, target_level)?;
+ (target.downsample < rendered.downsample).then_some(target_level)
+}
+
fn level_preparation_observation(event: &LevelWarmerEvent) -> (Duration, LevelPreparationStatus) {
match event {
LevelWarmerEvent::Prepared { elapsed, .. } => (*elapsed, LevelPreparationStatus::Prepared),
@@ -1091,6 +1119,20 @@ mod tests {
.all(|tile| tile.key.level == plan.prefetch_level));
}
+ #[test]
+ fn zoom_in_target_tiles_sharpen_progressively_but_zoom_out_targets_do_not() {
+ let summary = summary();
+ let fine = LevelIndex::from_u32(0);
+ let coarse = LevelIndex::from_u32(1);
+
+ assert_eq!(
+ sharpening_transition_level(&summary, coarse, fine),
+ Some(fine)
+ );
+ assert_eq!(sharpening_transition_level(&summary, fine, coarse), None);
+ assert_eq!(sharpening_transition_level(&summary, fine, fine), None);
+ }
+
#[test]
fn hysteresis_holds_current_level_while_preloading_adjacent_target() {
let summary = summary();
diff --git a/apps/dicom-viewer/src/app/canvas_frame.rs b/apps/dicom-viewer/src/app/canvas_frame.rs
new file mode 100644
index 0000000..4a512f1
--- /dev/null
+++ b/apps/dicom-viewer/src/app/canvas_frame.rs
@@ -0,0 +1,235 @@
+use dicom_viewer_core::ViewerStudy;
+use eframe::egui::{self, Frame, Rect, Sense};
+use std::sync::Arc;
+
+use super::camera::{raw_wheel_delta_y, wheel_zoom_factor, CameraFrame, CameraView};
+use super::ui::chrome::ToolbarActions;
+use super::ui::overlay::{
+ draw_canvas_overlays, paint_canvas_background, paint_empty_state, OverlayInfo,
+};
+use super::viewport::screen_to_base;
+use super::viewport_export::should_draw_canvas_hud;
+use super::workspace::{draw_external_layer_overlays, draw_workspace_overlay};
+use super::workspace_interaction::WorkspaceCanvasInteraction;
+use super::{theme, DicomViewerApp};
+
+impl DicomViewerApp {
+ pub(super) fn show_canvas(
+ &mut self,
+ ui: &mut egui::Ui,
+ study: Option<&Arc>,
+ opening: bool,
+ actions: &ToolbarActions,
+ stable_dt: f32,
+ ) {
+ egui::CentralPanel::default_margins()
+ .frame(Frame::NONE.fill(theme::CANVAS))
+ .show_inside(ui, |ui| {
+ let rect = ui.available_rect_before_wrap();
+ self.last_canvas_rect = Some(rect);
+ if let Some(pending) = &mut self.pending_viewport_export {
+ pending.update_canvas(rect, ui.ctx().viewport_rect());
+ }
+ let response = ui.allocate_rect(rect, Sense::click_and_drag());
+ if response.clicked() || response.drag_started() {
+ response.request_focus();
+ } else if ui.input(|input| input.pointer.any_pressed()) && !response.hovered() {
+ response.surrender_focus();
+ }
+ let painter = ui.painter_at(rect);
+ paint_canvas_background(&painter, rect);
+
+ let Some(study) = study else {
+ paint_empty_state(&painter, rect, opening);
+ return;
+ };
+
+ let camera_frame =
+ self.prepare_canvas_camera(ui, &response, rect, study, actions, stable_dt);
+ self.canvas.paint(
+ ui.ctx(),
+ &painter,
+ rect,
+ study,
+ self.active_generation,
+ camera_frame,
+ );
+ if let Some(runtime) = &mut self.workspace {
+ if let Err(error) = runtime.refresh_spatial_index() {
+ self.status =
+ format!("Could not update annotation viewport index: {error}");
+ }
+ }
+ if let Some((count, reason)) = self.canvas.cpu_fallback() {
+ if count > self.reported_cpu_fallbacks {
+ self.reported_cpu_fallbacks = count;
+ self.status = format!(
+ "{} preferred → wgpu; CPU fallback used for {count} tile(s): {reason}",
+ study.summary().tile_decode_backend
+ );
+ }
+ }
+
+ self.paint_annotation_overlays(
+ &painter,
+ rect,
+ study,
+ &response,
+ camera_frame.rendered,
+ );
+ });
+ }
+
+ fn prepare_canvas_camera(
+ &mut self,
+ ui: &egui::Ui,
+ response: &egui::Response,
+ rect: Rect,
+ study: &ViewerStudy,
+ actions: &ToolbarActions,
+ stable_dt: f32,
+ ) -> CameraFrame {
+ if actions.fit {
+ self.canvas.record_zoom_input();
+ self.camera.request_fit();
+ }
+ self.camera.prepare_canvas(rect, study.summary());
+ if actions.zoom_out {
+ self.canvas.record_zoom_input();
+ self.camera.zoom_about_center(rect, 0.8);
+ }
+ if actions.zoom_in {
+ self.canvas.record_zoom_input();
+ self.camera.zoom_about_center(rect, 1.25);
+ }
+
+ let accepts_keys =
+ (response.hovered() || response.has_focus()) && !ui.ctx().text_edit_focused();
+ let zoom_before_keys = self.camera.target_view().zoom;
+ if self.camera.handle_keys(ui, rect, accepts_keys) {
+ if (self.camera.target_view().zoom - zoom_before_keys).abs() > f32::EPSILON {
+ self.canvas.record_zoom_input();
+ }
+ ui.ctx().request_repaint();
+ }
+
+ let camera_frame = self.camera.frame(rect, study.summary(), stable_dt);
+ if camera_frame.animating {
+ ui.ctx().request_repaint();
+ }
+ let workspace_interaction = self.handle_workspace_interaction(
+ ui,
+ response,
+ rect,
+ study.summary(),
+ camera_frame.rendered,
+ accepts_keys,
+ );
+
+ self.apply_canvas_gestures(
+ ui,
+ response,
+ rect,
+ camera_frame.rendered,
+ workspace_interaction,
+ );
+
+ // Pointer input can change the target after this frame's rendered view was
+ // advanced. Publish that new target immediately so tile lookahead starts during
+ // the gesture instead of waiting for the next animation frame.
+ let camera_frame = self
+ .camera
+ .retarget_frame(camera_frame.rendered, study.summary());
+ if camera_frame.animating {
+ ui.ctx().request_repaint();
+ }
+
+ camera_frame
+ }
+
+ fn apply_canvas_gestures(
+ &mut self,
+ ui: &egui::Ui,
+ response: &egui::Response,
+ rect: Rect,
+ rendered: CameraView,
+ workspace_interaction: WorkspaceCanvasInteraction,
+ ) {
+ if workspace_interaction.pan_requested {
+ self.camera.pan_by_rendered(response.drag_delta(), rendered);
+ ui.ctx().request_repaint();
+ }
+ if response.double_clicked() && !workspace_interaction.click_consumed {
+ let pointer = response.interact_pointer_pos().unwrap_or(rect.center());
+ self.canvas.record_zoom_input();
+ self.camera
+ .zoom_around_rendered(rect, pointer, 2.0, rendered);
+ ui.ctx().request_repaint();
+ }
+
+ if response.hovered() {
+ let scroll_y = ui.input(raw_wheel_delta_y);
+ if scroll_y.abs() > 0.0 {
+ let pointer = ui
+ .input(|input| input.pointer.hover_pos())
+ .unwrap_or(rect.center());
+ self.canvas.record_zoom_input();
+ self.camera.zoom_around_rendered(
+ rect,
+ pointer,
+ wheel_zoom_factor(scroll_y, self.wheel_zoom),
+ rendered,
+ );
+ ui.ctx().request_repaint();
+ }
+ let pinch = ui.input(|input| input.zoom_delta());
+ if (pinch - 1.0).abs() > 0.001 {
+ let pointer = ui
+ .input(|input| input.pointer.hover_pos())
+ .unwrap_or(rect.center());
+ self.canvas.record_zoom_input();
+ self.camera
+ .zoom_around_rendered(rect, pointer, pinch, rendered);
+ ui.ctx().request_repaint();
+ }
+ if ui.input(|input| input.pointer.any_down()) {
+ ui.ctx().request_repaint();
+ }
+ }
+ }
+
+ fn paint_annotation_overlays(
+ &self,
+ painter: &egui::Painter,
+ rect: Rect,
+ study: &ViewerStudy,
+ response: &egui::Response,
+ rendered: CameraView,
+ ) {
+ let hover_base = response
+ .hover_pos()
+ .map(|p| screen_to_base(rect, p, rendered.center_base, rendered.zoom));
+ let tile_failure = self.canvas.tile_failure();
+ let debug_stats = self.canvas.debug_stats_text();
+ if should_draw_canvas_hud(self.pending_viewport_export.is_some()) {
+ draw_canvas_overlays(
+ painter,
+ rect,
+ OverlayInfo {
+ summary: study.summary(),
+ zoom: rendered.zoom,
+ frame_rate: self.frame_stats.info(),
+ hover_base,
+ tile_failure,
+ debug_stats: debug_stats.as_deref(),
+ },
+ );
+ }
+ if let Some(runtime) = &self.workspace {
+ if let Some(context) = study.annotation_context() {
+ draw_external_layer_overlays(painter, rect, runtime, context, rendered);
+ }
+ draw_workspace_overlay(painter, rect, runtime, rendered);
+ }
+ }
+}
diff --git a/apps/dicom-viewer/src/app/export_job.rs b/apps/dicom-viewer/src/app/export_job.rs
index e4978cd..c697168 100644
--- a/apps/dicom-viewer/src/app/export_job.rs
+++ b/apps/dicom-viewer/src/app/export_job.rs
@@ -9,6 +9,7 @@ use super::background_worker::{BackgroundWorker, WorkerPoll};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum WorkspaceExportKind {
+ CurrentViewTiff,
PortableWorkspace,
SchemeGeoJson,
CompatibilityGeoJson,
@@ -22,6 +23,7 @@ pub(super) enum WorkspaceExportKind {
impl WorkspaceExportKind {
pub(super) const fn label(self) -> &'static str {
match self {
+ Self::CurrentViewTiff => "current view TIFF",
Self::PortableWorkspace => "portable workspace",
Self::SchemeGeoJson => "scheme-aware GeoJSON",
Self::CompatibilityGeoJson => "CellViT compatibility GeoJSON",
diff --git a/apps/dicom-viewer/src/app/tests.rs b/apps/dicom-viewer/src/app/tests.rs
index 3f797b1..8c87d5f 100644
--- a/apps/dicom-viewer/src/app/tests.rs
+++ b/apps/dicom-viewer/src/app/tests.rs
@@ -61,6 +61,13 @@ pub(super) fn wait_for_background(label: &str, mut poll: impl FnMut() -> Opti
}
pub(super) fn write_source_wsi(path: &std::path::Path) {
+ write_source_wsi_with_optical_paths(path, &[]);
+}
+
+pub(super) fn write_source_wsi_with_optical_paths(
+ path: &std::path::Path,
+ optical_path_identifiers: &[&str],
+) {
use dicom_core::value::{DataSetSequence, PrimitiveValue, Value};
use dicom_core::{DataElement, Length, VR};
use dicom_dictionary_std::{tags, uids};
@@ -89,7 +96,7 @@ pub(super) fn write_source_wsi(path: &std::path::Path) {
DataElement::new(tags::STUDY_INSTANCE_UID, VR::UI, "2.25.9902"),
DataElement::new(tags::SERIES_INSTANCE_UID, VR::UI, "2.25.9903"),
DataElement::new(tags::FRAME_OF_REFERENCE_UID, VR::UI, "2.25.9904"),
- DataElement::new(tags::PATIENT_NAME, VR::PN, "Research^Slide"),
+ DataElement::new(tags::PATIENT_NAME, VR::PN, "Example^Slide"),
DataElement::new(tags::PATIENT_ID, VR::LO, "R-1"),
DataElement::new(tags::STUDY_DATE, VR::DA, "20260814"),
DataElement::new(tags::STUDY_TIME, VR::TM, "120000"),
@@ -118,6 +125,30 @@ pub(super) fn write_source_wsi(path: &std::path::Path) {
VR::SQ,
Value::from(DataSetSequence::new(vec![origin], Length::UNDEFINED)),
));
+ if !optical_path_identifiers.is_empty() {
+ let optical_paths = optical_path_identifiers
+ .iter()
+ .map(|identifier| {
+ let mut item = InMemDicomObject::new_empty();
+ item.put(DataElement::new(
+ tags::OPTICAL_PATH_IDENTIFIER,
+ VR::SH,
+ *identifier,
+ ));
+ item
+ })
+ .collect::>();
+ object.put(DataElement::new(
+ tags::NUMBER_OF_OPTICAL_PATHS,
+ VR::UL,
+ PrimitiveValue::from(u32::try_from(optical_paths.len()).unwrap()),
+ ));
+ object.put(DataElement::new(
+ tags::OPTICAL_PATH_SEQUENCE,
+ VR::SQ,
+ Value::from(DataSetSequence::new(optical_paths, Length::UNDEFINED)),
+ ));
+ }
object.put(DataElement::new(
tags::PIXEL_DATA,
VR::OB,
@@ -157,6 +188,7 @@ fn headless_app_runs_empty_logic_and_ui_with_real_renderer_state() {
assert!(!output.shapes.is_empty());
assert!(app.study.is_none());
assert_eq!(app.active_generation, 0);
+ assert!(!app.show_pathology_workspace);
app.show_facts_panel = true;
let output = context.run_ui(egui::RawInput::default(), |ui| {
@@ -681,10 +713,65 @@ fn pointer_zoom_preserves_the_base_point_in_the_rendered_frame() {
}
#[test]
-fn wheel_zoom_direction_is_inverted_for_natural_scroll() {
- assert!(wheel_zoom_factor(120.0) < 1.0);
- assert!(wheel_zoom_factor(-120.0) > 1.0);
- assert_eq!(wheel_zoom_factor(0.0), 1.0);
+fn same_frame_wheel_zoom_retargets_tile_planning_before_animation_advances() {
+ let summary = summary();
+ let rect = Rect::from_min_size(pos2(0.0, 0.0), vec2(512.0, 512.0));
+ let pointer = pos2(400.0, 180.0);
+ let mut camera = CameraState::default();
+ camera.reset_for_study(&summary);
+ camera.prepare_canvas(rect, &summary);
+ let frame_before_input = camera.frame(rect, &summary, 1.0 / 60.0);
+
+ camera.zoom_around_rendered(rect, pointer, 2.0, frame_before_input.rendered);
+ let frame_for_tiles = camera.retarget_frame(frame_before_input.rendered, &summary);
+
+ assert_eq!(
+ frame_for_tiles.rendered.zoom,
+ frame_before_input.rendered.zoom
+ );
+ assert_eq!(frame_for_tiles.target.zoom, camera.target_view().zoom);
+ assert!(frame_for_tiles.target.zoom > frame_for_tiles.rendered.zoom);
+ assert!(frame_for_tiles.animating);
+}
+
+#[test]
+fn windows_wheel_zoom_defaults_to_native_direction_and_faster_steps() {
+ let settings = WheelZoomSettings::for_os("windows");
+
+ assert!(!settings.inverted());
+ assert_eq!(settings.speed(), 2.0);
+ assert!(wheel_zoom_factor(120.0, settings) > 1.0);
+ assert!(wheel_zoom_factor(-120.0, settings) < 1.0);
+ assert_eq!(wheel_zoom_factor(0.0, settings), 1.0);
+}
+
+#[test]
+fn wheel_zoom_direction_and_speed_are_explicitly_configurable() {
+ let normal = WheelZoomSettings::new(1.0, false);
+ let faster = WheelZoomSettings::new(2.0, false);
+ let inverted = WheelZoomSettings::new(1.0, true);
+
+ assert!(wheel_zoom_factor(60.0, faster) > wheel_zoom_factor(60.0, normal));
+ assert!(wheel_zoom_factor(60.0, inverted) < 1.0);
+}
+
+#[test]
+fn wheel_zoom_consumes_the_immediate_native_wheel_step() {
+ let context = egui::Context::default();
+ let input = egui::RawInput {
+ events: vec![egui::Event::MouseWheel {
+ unit: egui::MouseWheelUnit::Line,
+ delta: vec2(0.0, 1.0),
+ phase: egui::TouchPhase::Move,
+ modifiers: egui::Modifiers::NONE,
+ }],
+ ..Default::default()
+ };
+ let mut observed = 0.0;
+
+ let _ = context.run_ui(input, |ui| observed = ui.input(raw_wheel_delta_y));
+
+ assert_eq!(observed, egui::InputOptions::default().line_scroll_speed);
}
#[test]
diff --git a/apps/dicom-viewer/src/app/theme.rs b/apps/dicom-viewer/src/app/theme.rs
index b084e86..f13ff17 100644
--- a/apps/dicom-viewer/src/app/theme.rs
+++ b/apps/dicom-viewer/src/app/theme.rs
@@ -21,6 +21,7 @@ pub(super) const CYAN: Color32 = Color32::from_rgb(112, 192, 206);
pub(super) const GREEN: Color32 = Color32::from_rgb(112, 192, 116);
pub(super) const WARN: Color32 = Color32::from_rgb(206, 142, 60);
pub(super) fn install_visuals(ctx: &egui::Context) {
+ install_platform_font(ctx);
let mut style = (*ctx.global_style()).clone();
style.text_styles = [
@@ -84,12 +85,39 @@ pub(super) fn install_visuals(ctx: &egui::Context) {
ctx.set_global_style(style);
}
+#[cfg(target_os = "windows")]
+fn install_platform_font(ctx: &egui::Context) {
+ let windows_directory = std::env::var_os("WINDIR").unwrap_or_else(|| "C:\\Windows".into());
+ let path = std::path::PathBuf::from(windows_directory)
+ .join("Fonts")
+ .join("segoeui.ttf");
+ let Ok(bytes) = std::fs::read(path) else {
+ return;
+ };
+
+ let name = "Segoe UI".to_owned();
+ let mut fonts = egui::FontDefinitions::default();
+ fonts.font_data.insert(
+ name.clone(),
+ std::sync::Arc::new(egui::FontData::from_owned(bytes)),
+ );
+ fonts
+ .families
+ .entry(egui::FontFamily::Proportional)
+ .or_default()
+ .insert(0, name);
+ ctx.set_fonts(fonts);
+}
+
+#[cfg(not(target_os = "windows"))]
+fn install_platform_font(_ctx: &egui::Context) {}
+
#[cfg(test)]
mod tests {
use super::*;
#[test]
- fn installed_visuals_keep_the_research_viewer_palette_and_spacing() {
+ fn installed_visuals_keep_the_viewer_palette_and_spacing() {
let context = egui::Context::default();
install_visuals(&context);
@@ -101,4 +129,15 @@ mod tests {
assert_eq!(style.spacing.item_spacing, vec2(8.0, 7.0));
assert_eq!(style.spacing.interact_size.y, 26.0);
}
+
+ #[test]
+ fn text_rasterizer_is_native_only_on_windows() {
+ let expected = if cfg!(target_os = "windows") {
+ "DirectWrite grayscale"
+ } else {
+ "skrifa/vello"
+ };
+
+ assert_eq!(egui::epaint::text::font_rasterizer_name(), expected);
+ }
}
diff --git a/apps/dicom-viewer/src/app/ui/chrome.rs b/apps/dicom-viewer/src/app/ui/chrome.rs
index 554587d..a6efef5 100644
--- a/apps/dicom-viewer/src/app/ui/chrome.rs
+++ b/apps/dicom-viewer/src/app/ui/chrome.rs
@@ -6,6 +6,7 @@ use eframe::egui::{
use dicom_viewer_core::StudySummary;
use super::super::theme;
+use super::super::WheelZoomSettings;
#[derive(Debug, Default)]
pub(in crate::app) struct ToolbarActions {
@@ -24,12 +25,14 @@ pub(in crate::app) struct ToolbarActions {
pub(in crate::app) struct ToolbarState<'a> {
pub(in crate::app) has_study: bool,
pub(in crate::app) show_facts: &'a mut bool,
+ pub(in crate::app) show_pathology: &'a mut bool,
pub(in crate::app) can_undo: bool,
pub(in crate::app) can_redo: bool,
pub(in crate::app) autosave_status: &'a str,
pub(in crate::app) export_running: bool,
pub(in crate::app) export_cancel_requested: bool,
pub(in crate::app) smooth_camera: &'a mut bool,
+ pub(in crate::app) wheel_zoom: &'a mut WheelZoomSettings,
}
pub(in crate::app) fn show_toolbar(ui: &mut egui::Ui, state: ToolbarState<'_>) -> ToolbarActions {
@@ -55,6 +58,10 @@ pub(in crate::app) fn show_toolbar(ui: &mut egui::Ui, state: ToolbarState<'_>) -
ui.toggle_value(state.show_facts, RichText::new("Info").size(13.0));
if state.has_study {
rule(ui);
+ ui.toggle_value(
+ state.show_pathology,
+ RichText::new("Annotations").size(13.0),
+ );
actions.import = ui.button(RichText::new("Import").size(13.0)).clicked();
if state.export_running {
actions.cancel_export = ui
@@ -83,6 +90,16 @@ pub(in crate::app) fn show_toolbar(ui: &mut egui::Ui, state: ToolbarState<'_>) -
actions.zoom_in = ui.button(RichText::new("+").size(13.0)).clicked();
ui.menu_button("View", |ui| {
ui.checkbox(state.smooth_camera, "Smooth navigation");
+ ui.checkbox(
+ state.wheel_zoom.inverted_mut(),
+ "Invert wheel zoom direction",
+ );
+ ui.add(
+ egui::Slider::new(state.wheel_zoom.speed_mut(), 0.25..=4.0)
+ .logarithmic(true)
+ .custom_formatter(|value, _| format!("{value:.2}×"))
+ .text("Wheel zoom speed"),
+ );
});
}
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
@@ -184,11 +201,7 @@ pub(in crate::app) fn privacy_badge(ui: &mut egui::Ui) {
.show(ui, |ui| {
ui.spacing_mut().item_spacing.x = 6.0;
ui.label(RichText::new("\u{25CF}").color(theme::GREEN).size(9.0));
- ui.label(
- RichText::new("RESEARCH · LOCAL")
- .color(theme::TEXT_MUTED)
- .size(11.0),
- );
+ ui.label(RichText::new("LOCAL").color(theme::TEXT_MUTED).size(11.0));
});
}
@@ -211,19 +224,23 @@ mod tests {
#[test]
fn toolbar_and_status_bar_render_each_availability_state_without_actions() {
let mut show_facts = false;
+ let mut show_pathology = false;
let mut smooth_camera = true;
+ let mut wheel_zoom = WheelZoomSettings::for_os("windows");
let output = run_ui(|ui| {
let actions = show_toolbar(
ui,
ToolbarState {
has_study: false,
show_facts: &mut show_facts,
+ show_pathology: &mut show_pathology,
can_undo: false,
can_redo: false,
autosave_status: "Not saved",
export_running: false,
export_cancel_requested: false,
smooth_camera: &mut smooth_camera,
+ wheel_zoom: &mut wheel_zoom,
},
);
assert!(!actions.open_file);
@@ -239,12 +256,14 @@ mod tests {
ToolbarState {
has_study: true,
show_facts: &mut show_facts,
+ show_pathology: &mut show_pathology,
can_undo: true,
can_redo: true,
autosave_status: "Saved",
export_running: false,
export_cancel_requested: false,
smooth_camera: &mut smooth_camera,
+ wheel_zoom: &mut wheel_zoom,
},
);
assert!(!actions.undo);
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace.rs
index ca8b90b..4d073c9 100644
--- a/apps/dicom-viewer/src/app/ui/pathology_workspace.rs
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace.rs
@@ -1,6 +1,12 @@
+mod findings;
+mod inspector;
+mod layers;
+mod palette;
+mod tool_rail;
+
use std::path::PathBuf;
-use dicom_viewer_core::{AnnotationClassGeometry, SegmentOperation, VectorFindingGeometry};
+use dicom_viewer_core::{AnnotationClassGeometry, SegmentOperation, WorkspaceObjectGeometryKind};
use eframe::egui::{self, Color32, Margin, Panel, RichText, ScrollArea, Stroke};
use uuid::Uuid;
@@ -11,11 +17,21 @@ use super::super::workspace::{
use super::chrome::chrome_frame;
use super::section_heading;
+use findings::{finding_rows, show_findings};
+use inspector::show_inspector;
+use layers::show_layers;
+use palette::show_scheme_and_palette;
+#[cfg(test)]
+use palette::visible_palette;
+pub(in crate::app) use tool_rail::show_tool_rail;
+
const TOOL_RAIL_WIDTH: f32 = 58.0;
const FINDING_ROW_HEIGHT: f32 = 25.0;
#[derive(Debug, Default)]
pub(in crate::app) struct PathologyWorkspaceActions {
+ pub(in crate::app) close_panel: bool,
+ pub(in crate::app) export_current_view_tiff: bool,
pub(in crate::app) import_dicom: bool,
pub(in crate::app) import_profiled_geojson: bool,
pub(in crate::app) import_sr: bool,
@@ -38,57 +54,11 @@ pub(in crate::app) struct PathologyWorkspaceActions {
pub(in crate::app) status: Option,
}
-pub(in crate::app) fn show_tool_rail(
+pub(in crate::app) fn show_populated_pathology_workspace_panel(
ui: &mut egui::Ui,
runtime: &mut WorkspaceRuntime,
-) -> Option {
- let mut error = None;
- Panel::left("pathology-tool-rail")
- .exact_size(TOOL_RAIL_WIDTH)
- .frame(chrome_frame(theme::CHROME, Margin::symmetric(6, 8)))
- .show_inside(ui, |ui| {
- ui.vertical_centered(|ui| {
- ui.label(
- RichText::new("TOOLS")
- .size(9.0)
- .color(theme::TEXT_DIM)
- .strong(),
- );
- ui.add_space(3.0);
- for tool in ActiveTool::ALL {
- let selected = runtime.active_tool() == tool;
- let response = ui
- .selectable_label(
- selected,
- RichText::new(tool_glyph(tool)).size(17.0).strong(),
- )
- .on_hover_text(format!("{} ({})", tool.label(), tool.shortcut()));
- if response.clicked() {
- if tool == ActiveTool::Brush {
- if let Err(err) = runtime.ensure_segmentation_layer() {
- error = Some(err.to_string());
- continue;
- }
- }
- if runtime.request_tool(tool) == ToolTransitionOutcome::BlockedByDraft {
- error = Some(
- "Unfinished polygon: choose Resume, Finish, or Discard.".into(),
- );
- }
- }
- }
- ui.add_space(5.0);
- ui.separator();
- if ui
- .button(RichText::new("N").monospace().strong())
- .on_hover_text("New independent finding / segment (N)")
- .clicked()
- {
- runtime.begin_new_segment();
- }
- });
- });
- error
+) -> Option {
+ (runtime.document().object_count() > 0).then(|| show_pathology_workspace_panel(ui, runtime))
}
pub(in crate::app) fn show_pathology_workspace_panel(
@@ -105,6 +75,10 @@ pub(in crate::app) fn show_pathology_workspace_panel(
ui.horizontal(|ui| {
ui.heading(RichText::new("Pathology").color(theme::TEXT));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+ actions.close_panel = ui
+ .small_button("X")
+ .on_hover_text("Close annotations")
+ .clicked();
let count = runtime.document().object_count();
ui.label(
RichText::new(format!("{count} tracked"))
@@ -181,714 +155,6 @@ fn show_draft_guard(
});
}
-fn show_scheme_and_palette(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
-) {
- section_heading(ui, "Annotation scheme");
- let scheme = runtime.document().scheme();
- ui.horizontal(|ui| {
- ui.label(RichText::new(scheme.display_name()).strong());
- ui.label(
- RichText::new(format!("v{}", scheme.version()))
- .small()
- .color(theme::TEXT_DIM),
- );
- });
- ui.label(
- RichText::new(format!(
- "{} · {}…",
- scheme.id(),
- &scheme.content_digest()[..12]
- ))
- .monospace()
- .small()
- .color(theme::TEXT_DIM),
- );
- let palette = visible_palette(runtime);
- ui.add_space(4.0);
- ui.horizontal_wrapped(|ui| {
- for (id, label, color, selected) in palette {
- let color = Color32::from_rgb(color[0], color[1], color[2]);
- let response = ui
- .horizontal(|ui| {
- let (swatch, _) =
- ui.allocate_exact_size(egui::vec2(8.0, 16.0), egui::Sense::hover());
- ui.painter().rect_filled(swatch, 1.0, color);
- ui.selectable_label(selected, RichText::new(label).size(12.0))
- })
- .inner;
- if response.clicked() {
- if let Err(error) = runtime.set_active_class(id) {
- actions.error = Some(error.to_string());
- }
- }
- }
- });
-
- if runtime.editing_representation() == EditingRepresentation::Segmentation
- && matches!(
- runtime.active_tool(),
- ActiveTool::Polygon | ActiveTool::Brush
- )
- {
- ui.horizontal(|ui| {
- ui.label(RichText::new("Operation").small().color(theme::TEXT_MUTED));
- for (operation, label) in [
- (SegmentOperation::Add, "Add"),
- (SegmentOperation::Erase, "Erase"),
- ] {
- let enabled = operation == SegmentOperation::Add
- || runtime
- .selection()
- .iter()
- .any(|id| runtime.document().segment(*id).is_some());
- if ui
- .add_enabled(
- enabled,
- egui::Button::selectable(runtime.segment_operation() == operation, label),
- )
- .clicked()
- {
- runtime.set_segment_operation(operation);
- }
- }
- ui.label(RichText::new("Alt reverses").small().color(theme::TEXT_DIM));
- });
- if runtime.active_tool() == ActiveTool::Brush {
- ui.label(
- RichText::new(format!("Brush Ø {:.0} px", runtime.brush_diameter()))
- .small()
- .color(theme::TEXT_MUTED),
- );
- }
- }
-}
-
-fn show_findings(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
-) {
- section_heading(ui, "Findings");
- let rows = finding_rows(runtime);
- if rows.is_empty() {
- ui.label(
- RichText::new("No tracked findings yet.")
- .small()
- .color(theme::TEXT_DIM),
- );
- return;
- }
- ScrollArea::vertical()
- .id_salt("tracked-findings")
- .max_height(210.0)
- .auto_shrink([false, true])
- .show_rows(ui, FINDING_ROW_HEIGHT, rows.len(), |ui, range| {
- for row in &rows[range] {
- let selected = runtime.selection().contains(&row.id);
- ui.horizontal(|ui| {
- let visible = runtime.document().presentation().object_visible(row.id);
- let eye = if visible { "●" } else { "○" };
- if ui
- .small_button(eye)
- .on_hover_text("Toggle visibility")
- .clicked()
- {
- if let Err(error) =
- runtime.set_object_visibility_without_history(row.id, !visible)
- {
- actions.error = Some(error.to_string());
- }
- }
- let response = ui.selectable_label(
- selected,
- RichText::new(format!("#{:04} {}", row.ordinal, row.label)).size(12.0),
- );
- if response.clicked() {
- let shift = ui.input(|input| input.modifiers.shift);
- if shift {
- runtime.toggle_selection(row.id);
- } else {
- runtime.select_only(row.id);
- }
- }
- if response.double_clicked() {
- actions.jump_to = Some(row.id);
- }
- ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
- if ui
- .small_button("⌖")
- .on_hover_text("Jump to finding")
- .clicked()
- {
- actions.jump_to = Some(row.id);
- }
- ui.label(
- RichText::new(&row.metric)
- .monospace()
- .small()
- .color(theme::TEXT_DIM),
- );
- });
- });
- }
- });
-}
-
-fn show_layers(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
-) {
- section_heading(ui, "Layers");
- let vectors = runtime
- .document()
- .vector_layers()
- .iter()
- .map(|layer| (layer.id(), layer.name().to_owned(), layer.findings().len()))
- .collect::>();
- let segments = runtime
- .document()
- .segmentation_layers()
- .iter()
- .map(|layer| (layer.id(), layer.name().to_owned(), layer.segments().len()))
- .collect::>();
- for (id, name, count) in vectors {
- layer_row(
- ui,
- runtime,
- actions,
- id,
- &name,
- count,
- EditingRepresentation::Vector,
- );
- }
- for (id, name, count) in segments {
- layer_row(
- ui,
- runtime,
- actions,
- id,
- &name,
- count,
- EditingRepresentation::Segmentation,
- );
- }
- let external = runtime
- .document()
- .external_layers()
- .iter()
- .map(|layer| {
- (
- layer.id(),
- layer.name().to_owned(),
- layer.kind().clone(),
- layer.source_path().map(std::path::Path::to_path_buf),
- layer.source_object_count(),
- layer.class_mappings().clone(),
- )
- })
- .collect::>();
- for (id, name, kind, source_path, count, mappings) in external {
- let presentation = runtime.document().presentation().layer(id);
- let mut remove_layer = false;
- let mut load_layer = false;
- let payload_loaded = runtime.external_payload(id).is_some();
- ui.horizontal(|ui| {
- let eye = if presentation.visible { "●" } else { "○" };
- if ui.small_button(eye).clicked() {
- if let Err(error) = runtime.set_layer_visibility(id, !presentation.visible) {
- actions.error = Some(error.to_string());
- }
- }
- ui.label(RichText::new("◇").color(theme::TEXT_DIM));
- ui.label(format!("{name} · {count}"));
- ui.label(RichText::new("LOCKED").small().color(theme::TEXT_DIM));
- if !payload_loaded
- && source_path.is_some()
- && sidecar_kind_for_external(&kind).is_some()
- && ui.small_button("Load").clicked()
- {
- load_layer = true;
- }
- if ui.small_button("Remove").clicked() {
- remove_layer = true;
- }
- });
- ui.horizontal(|ui| {
- edit_layer_opacity(ui, runtime, actions, id, presentation);
- let status = source_path.as_deref().map_or("embedded reference", |path| {
- if path.exists() {
- "linked source"
- } else {
- "missing linked source"
- }
- });
- ui.label(RichText::new(format!("{kind:?} · {status}")).small().color(
- if status.starts_with("missing") {
- theme::AMBER
- } else {
- theme::TEXT_DIM
- },
- ));
- });
- if remove_layer {
- match runtime.remove_external_layer(id) {
- Ok(true) => {
- actions.status =
- Some(format!("Removed source layer {name}; Undo restores it."));
- }
- Ok(false) => {}
- Err(error) => actions.error = Some(error.to_string()),
- }
- continue;
- }
- if load_layer {
- actions.load_sidecar = source_path.clone().zip(sidecar_kind_for_external(&kind));
- }
- let classes = runtime.external_classes(id);
- ui.indent(("external-controls", id), |ui| match classes {
- Err(error) => {
- ui.label(RichText::new(error.to_string()).small().color(theme::AMBER));
- }
- Ok(classes) if classes.is_empty() => {
- let message = if kind == dicom_viewer_core::ExternalLayerKind::Heatmap
- && payload_loaded
- {
- "Heatmap source result; export it through DICOM PM."
- } else {
- "Source payload is unloaded or has no lossless editable objects."
- };
- ui.label(
- RichText::new(message)
- .small()
- .color(theme::TEXT_DIM),
- );
- }
- Ok(classes) => {
- ui.collapsing("Class mapping & promotion", |ui| {
- let scheme_options = runtime
- .document()
- .scheme()
- .classes()
- .iter()
- .map(|class| {
- (
- class.id().to_owned(),
- class.label().to_owned(),
- class.geometry(),
- )
- })
- .collect::>();
- for class in &classes {
- ui.horizontal_wrapped(|ui| {
- ui.label(format!(
- "{} · {} {}",
- class.label,
- class.object_count,
- class.geometry.label().to_lowercase()
- ));
- if !class.editable {
- ui.label(RichText::new("read-only geometry").small().color(theme::AMBER));
- }
- });
- let current = mappings.get(&class.key).cloned();
- let selected_text = current
- .as_deref()
- .and_then(|id| {
- scheme_options
- .iter()
- .find(|(candidate, _, _)| candidate == id)
- .map(|(_, label, _)| label.as_str())
- })
- .unwrap_or("Unmapped");
- ui.horizontal(|ui| {
- egui::ComboBox::from_id_salt(("external-class-map", id, &class.key))
- .selected_text(selected_text)
- .show_ui(ui, |ui| {
- for (target_id, label, geometry) in &scheme_options {
- if *geometry != class.geometry {
- continue;
- }
- if ui
- .selectable_label(
- current.as_deref() == Some(target_id.as_str()),
- label,
- )
- .clicked()
- {
- if let Err(error) = runtime.set_external_class_mapping(
- id,
- &class.key,
- target_id,
- ) {
- actions.error = Some(error.to_string());
- }
- }
- }
- });
- if current.is_none() {
- if let Some(suggested) = class.exact_scheme_class_id.as_deref() {
- let label = scheme_options
- .iter()
- .find(|(id, _, _)| id == suggested)
- .map_or(suggested, |(_, label, _)| label.as_str());
- if ui
- .small_button(format!("Use exact: {label}"))
- .clicked()
- {
- if let Err(error) = runtime.set_external_class_mapping(
- id,
- &class.key,
- suggested,
- ) {
- actions.error = Some(error.to_string());
- }
- }
- }
- }
- });
- }
-
- let complete = classes.iter().all(|class| {
- class.editable && mappings.contains_key(&class.key)
- });
- if ui
- .add_enabled(complete, egui::Button::new("Make editable"))
- .on_hover_text(
- "Convert every source object only after every source class is mapped",
- )
- .clicked()
- {
- match runtime.make_external_layer_editable(id) {
- Ok(ids) => {
- actions.status = Some(format!(
- "Converted {} source object(s) as independently tracked findings.",
- ids.len()
- ));
- }
- Err(error) => actions.error = Some(error.to_string()),
- }
- }
-
- ui.collapsing("Source objects", |ui| match runtime.external_objects(id) {
- Err(error) => {
- ui.label(RichText::new(error.to_string()).small().color(theme::AMBER));
- }
- Ok(objects) => {
- ScrollArea::vertical()
- .id_salt(("external-objects", id))
- .max_height(180.0)
- .show_rows(ui, 24.0, objects.len(), |ui, range| {
- for object in &objects[range] {
- ui.horizontal(|ui| {
- ui.label(
- RichText::new(&object.label)
- .small()
- .color(theme::TEXT_MUTED),
- );
- let mapped = mappings.contains_key(&object.class_key);
- let enabled = object.promotable
- && mapped
- && !object.promoted;
- if ui
- .add_enabled(
- enabled,
- egui::Button::new(if object.promoted {
- "Tracked"
- } else {
- "Promote"
- }),
- )
- .clicked()
- {
- match runtime.promote_external_object(
- id,
- &object.source_object_id,
- ) {
- Ok(_) => {
- actions.status = Some(
- "Promoted one source object as a tracked finding."
- .into(),
- );
- }
- Err(error) => {
- actions.error = Some(error.to_string());
- }
- }
- }
- });
- }
- });
- }
- });
- });
- }
- });
- }
-}
-
-fn sidecar_kind_for_external(
- kind: &dicom_viewer_core::ExternalLayerKind,
-) -> Option {
- match kind {
- dicom_viewer_core::ExternalLayerKind::DicomAnn => {
- Some(dicom_viewer_core::SidecarKind::Annotation)
- }
- dicom_viewer_core::ExternalLayerKind::DicomSeg => {
- Some(dicom_viewer_core::SidecarKind::BinarySegmentation)
- }
- dicom_viewer_core::ExternalLayerKind::DicomSr => {
- Some(dicom_viewer_core::SidecarKind::StructuredReport)
- }
- dicom_viewer_core::ExternalLayerKind::ProfiledGeoJson
- | dicom_viewer_core::ExternalLayerKind::Heatmap => None,
- }
-}
-
-fn edit_layer_opacity(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
- id: Uuid,
- presentation: dicom_viewer_core::LayerPresentation,
-) {
- let mut opacity = presentation.opacity;
- if ui
- .add(egui::Slider::new(&mut opacity, 0.05..=1.0).text("opacity"))
- .changed()
- {
- let mut updated = presentation;
- updated.opacity = opacity;
- if let Err(error) = runtime.set_layer_presentation_without_history(id, updated) {
- actions.error = Some(error.to_string());
- }
- }
-}
-
-fn layer_row(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
- id: Uuid,
- name: &str,
- count: usize,
- representation: EditingRepresentation,
-) {
- let presentation = runtime.document().presentation().layer(id);
- ui.horizontal(|ui| {
- let eye = if presentation.visible { "●" } else { "○" };
- if ui.small_button(eye).clicked() {
- if let Err(error) = runtime.set_layer_visibility(id, !presentation.visible) {
- actions.error = Some(error.to_string());
- }
- }
- let active = runtime.editing_representation() == representation;
- if ui
- .selectable_label(active, format!("{name} {count}"))
- .clicked()
- {
- let result = match representation {
- EditingRepresentation::Vector => runtime.use_vector_layer(id),
- EditingRepresentation::Segmentation => runtime.use_segmentation_layer(id),
- };
- if let Err(error) = result {
- actions.error = Some(error.to_string());
- }
- }
- ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
- ui.label(
- RichText::new(if presentation.locked {
- "locked"
- } else {
- "editable"
- })
- .small()
- .color(theme::TEXT_DIM),
- );
- });
- });
- ui.horizontal(|ui| {
- edit_layer_opacity(ui, runtime, actions, id, presentation);
- let mut locked = presentation.locked;
- if ui.checkbox(&mut locked, "Lock").changed() {
- let mut updated = presentation;
- updated.locked = locked;
- if let Err(error) = runtime.set_layer_presentation_without_history(id, updated) {
- actions.error = Some(error.to_string());
- }
- }
- });
-}
-
-fn show_inspector(
- ui: &mut egui::Ui,
- runtime: &mut WorkspaceRuntime,
- actions: &mut PathologyWorkspaceActions,
-) {
- section_heading(ui, "Selection inspector");
- match runtime.selection().len() {
- 0 => {
- ui.label(
- RichText::new("Select a finding or segment to inspect it.")
- .small()
- .color(theme::TEXT_DIM),
- );
- }
- count @ 2.. => {
- ui.label(format!("{count} objects selected"));
- actions.delete_selection = ui.button("Delete selected").clicked();
- }
- 1 => {
- let id = *runtime
- .selection()
- .iter()
- .next()
- .expect("one selection exists");
- if let Some(row) = finding_rows(runtime).into_iter().find(|row| row.id == id) {
- let details = selected_details(runtime, id);
- ui.label(RichText::new(format!("#{:04} {}", row.ordinal, row.label)).strong());
- ui.label(
- RichText::new(row.metric)
- .monospace()
- .color(theme::TEXT_MUTED),
- );
- if let Some(details) = details {
- let compatible_classes = runtime
- .document()
- .scheme()
- .classes()
- .iter()
- .filter(|class| class.geometry() == details.geometry)
- .map(|class| (class.id().to_owned(), class.label().to_owned()))
- .collect::>();
- egui::ComboBox::from_id_salt(("inspector-class", id))
- .selected_text(
- runtime
- .document()
- .scheme()
- .class(&details.class_id)
- .map_or(details.class_id.as_str(), |class| class.label()),
- )
- .show_ui(ui, |ui| {
- for (class_id, label) in compatible_classes {
- if ui
- .selectable_label(class_id == details.class_id, label)
- .clicked()
- {
- if let Err(error) = runtime.reclassify_selection(&class_id) {
- actions.error = Some(error.to_string());
- }
- }
- }
- });
-
- let finding_sites = runtime.document().scheme().finding_sites().to_vec();
- if !finding_sites.is_empty() {
- let selected_site = details.finding_site.as_ref().and_then(|selected| {
- finding_sites.iter().find(|site| selected.matches(site))
- });
- egui::ComboBox::from_id_salt(("inspector-finding-site", id))
- .selected_text(
- selected_site.map_or("No finding site", |site| site.meaning()),
- )
- .show_ui(ui, |ui| {
- if ui
- .selectable_label(
- details.finding_site.is_none(),
- "No finding site",
- )
- .clicked()
- {
- if let Err(error) = runtime.set_selected_finding_site(None) {
- actions.error = Some(error.to_string());
- }
- }
- for site in &finding_sites {
- let selected = details
- .finding_site
- .as_ref()
- .is_some_and(|current| current.matches(site));
- if ui.selectable_label(selected, site.meaning()).clicked() {
- if let Err(error) =
- runtime.set_selected_finding_site(Some(site))
- {
- actions.error = Some(error.to_string());
- }
- }
- }
- });
- }
-
- let name_id = egui::Id::new(("finding-name", id));
- let mut name = ui.ctx().data_mut(|data| {
- data.get_temp::(name_id)
- .unwrap_or_else(|| details.name.clone().unwrap_or_default())
- });
- let name_response = ui.add(
- egui::TextEdit::singleline(&mut name)
- .id(name_id)
- .hint_text("Optional finding name"),
- );
- ui.ctx()
- .data_mut(|data| data.insert_temp(name_id, name.clone()));
- if name_response.lost_focus() {
- let value = (!name.trim().is_empty()).then_some(name.trim());
- if let Err(error) = runtime.set_selected_name(value) {
- actions.error = Some(error.to_string());
- }
- }
-
- let comment_id = egui::Id::new(("finding-comment", id));
- let mut comment = ui.ctx().data_mut(|data| {
- data.get_temp::(comment_id)
- .unwrap_or_else(|| details.comment.clone().unwrap_or_default())
- });
- let comment_response = ui.add(
- egui::TextEdit::multiline(&mut comment)
- .id(comment_id)
- .desired_rows(2)
- .hint_text("Optional comment"),
- );
- ui.ctx()
- .data_mut(|data| data.insert_temp(comment_id, comment.clone()));
- if comment_response.lost_focus() {
- let value = (!comment.trim().is_empty()).then_some(comment.trim());
- if let Err(error) = runtime.set_selected_comment(value) {
- actions.error = Some(error.to_string());
- }
- }
-
- ui.label(
- RichText::new(format!("{} · {}", details.kind, details.source_status))
- .small()
- .color(theme::TEXT_MUTED),
- );
- ui.label(
- RichText::new(format!(
- "Tracking ID {}\nTracking UID {}",
- details.tracking_id, details.tracking_uid
- ))
- .monospace()
- .small()
- .color(theme::TEXT_DIM),
- );
- }
- ui.label(
- RichText::new(format!("Object {id}"))
- .monospace()
- .small()
- .color(theme::TEXT_DIM),
- );
- actions.delete_selection = ui.button("Delete finding").clicked();
- }
- }
- }
-}
-
fn show_expert(
ui: &mut egui::Ui,
runtime: &WorkspaceRuntime,
@@ -920,227 +186,5 @@ fn show_expert(
});
}
-struct FindingRow {
- id: Uuid,
- ordinal: u64,
- label: String,
- metric: String,
-}
-
-struct SelectedDetails {
- class_id: String,
- geometry: AnnotationClassGeometry,
- name: Option,
- comment: Option,
- tracking_id: String,
- tracking_uid: String,
- kind: &'static str,
- source_status: &'static str,
- finding_site: Option,
-}
-
-fn selected_details(runtime: &WorkspaceRuntime, id: Uuid) -> Option {
- let document = runtime.document();
- if let Some(finding) = document.finding(id) {
- return Some(SelectedDetails {
- class_id: finding.class_id().to_owned(),
- geometry: match finding.geometry() {
- VectorFindingGeometry::Point(_) => AnnotationClassGeometry::Point,
- VectorFindingGeometry::Regions(_) => AnnotationClassGeometry::Region,
- },
- name: finding.name().map(str::to_owned),
- comment: finding.comment().map(str::to_owned),
- tracking_id: finding.tracking().id().to_owned(),
- tracking_uid: finding.tracking().uid().to_owned(),
- kind: "Vector finding",
- source_status: provenance_label(finding.provenance()),
- finding_site: finding.finding_site().cloned(),
- });
- }
- if let Some(segment) = document.segment(id) {
- return Some(SelectedDetails {
- class_id: segment.class_id().to_owned(),
- geometry: AnnotationClassGeometry::Region,
- name: segment.name().map(str::to_owned),
- comment: segment.comment().map(str::to_owned),
- tracking_id: segment.tracking().id().to_owned(),
- tracking_uid: segment.tracking().uid().to_owned(),
- kind: "Segmentation segment",
- source_status: provenance_label(segment.provenance()),
- finding_site: segment.finding_site().cloned(),
- });
- }
- let measurement = document.measurement(id)?;
- Some(SelectedDetails {
- class_id: measurement.class_id().to_owned(),
- geometry: AnnotationClassGeometry::Region,
- name: measurement.name().map(str::to_owned),
- comment: measurement.comment().map(str::to_owned),
- tracking_id: measurement.tracking().id().to_owned(),
- tracking_uid: measurement.tracking().uid().to_owned(),
- kind: "Linear measurement",
- source_status: provenance_label(measurement.provenance()),
- finding_site: measurement.finding_site().cloned(),
- })
-}
-
-fn provenance_label(provenance: &dicom_viewer_core::WorkspaceObjectProvenance) -> &'static str {
- match provenance {
- dicom_viewer_core::WorkspaceObjectProvenance::Manual => "manual",
- dicom_viewer_core::WorkspaceObjectProvenance::Promoted { .. } => "promoted",
- }
-}
-
-fn finding_rows(runtime: &WorkspaceRuntime) -> Vec {
- let document = runtime.document();
- let mut rows = document
- .vector_findings()
- .map(|finding| FindingRow {
- id: finding.object_id(),
- ordinal: finding.ordinal(),
- label: document.scheme().class(finding.class_id()).map_or_else(
- || finding.class_id().to_owned(),
- |class| class.label().to_owned(),
- ),
- metric: match finding.geometry() {
- VectorFindingGeometry::Point(_) => "point".into(),
- VectorFindingGeometry::Regions(components) => {
- format!(
- "{} region{}",
- components.len(),
- if components.len() == 1 { "" } else { "s" }
- )
- }
- },
- })
- .chain(document.segments().map(|segment| {
- let geometry = document.composite_segment(segment.object_id()).ok();
- FindingRow {
- id: segment.object_id(),
- ordinal: segment.ordinal(),
- label: document.scheme().class(segment.class_id()).map_or_else(
- || segment.class_id().to_owned(),
- |class| class.label().to_owned(),
- ),
- metric: format!(
- "{} component{}",
- geometry
- .as_ref()
- .map_or(0, |geometry| geometry.components().len()),
- if geometry
- .as_ref()
- .is_some_and(|geometry| geometry.components().len() == 1)
- {
- ""
- } else {
- "s"
- }
- ),
- }
- }))
- .chain(
- document
- .measurements()
- .iter()
- .map(|measurement| FindingRow {
- id: measurement.object_id(),
- ordinal: measurement.ordinal(),
- label: document.scheme().class(measurement.class_id()).map_or_else(
- || "Ruler".into(),
- |class| format!("{} length", class.label()),
- ),
- metric: measurement.physical_length_mm().map_or_else(
- || "unscaled".into(),
- |length| {
- if length >= 1.0 {
- format!("{length:.3} mm")
- } else {
- format!("{:.1} µm", length * 1_000.0)
- }
- },
- ),
- }),
- )
- .collect::>();
- rows.sort_by_key(|row| row.ordinal);
- rows
-}
-
-fn visible_palette(runtime: &WorkspaceRuntime) -> Vec<(String, String, [u8; 3], bool)> {
- let expected_geometry = match runtime.active_tool() {
- ActiveTool::Point => Some(AnnotationClassGeometry::Point),
- ActiveTool::Polygon | ActiveTool::Brush | ActiveTool::Ruler => {
- Some(AnnotationClassGeometry::Region)
- }
- ActiveTool::Pan | ActiveTool::Select => None,
- };
- runtime
- .document()
- .scheme()
- .classes()
- .iter()
- .filter(|class| expected_geometry.is_none_or(|geometry| class.geometry() == geometry))
- .map(|class| {
- (
- class.id().to_owned(),
- class.label().to_owned(),
- class.display_color(),
- runtime.active_class_id() == class.id(),
- )
- })
- .collect()
-}
-
-fn tool_glyph(tool: ActiveTool) -> &'static str {
- match tool {
- ActiveTool::Pan => "✥",
- ActiveTool::Select => "⌁",
- ActiveTool::Polygon => "△",
- ActiveTool::Brush => "●",
- ActiveTool::Point => "+",
- ActiveTool::Ruler => "╱",
- }
-}
-
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::app::tests::run_ui;
- use dicom_viewer_core::{AnnotationScheme, ViewerSourceIdentity};
-
- fn runtime() -> WorkspaceRuntime {
- WorkspaceRuntime::new(
- ViewerSourceIdentity::new(1, 0, 0, 0, 0, 0, (1_000, 1_000)),
- AnnotationScheme::general_pathology_v1(),
- )
- .unwrap()
- }
-
- #[test]
- fn pathology_workspace_renders_as_one_dense_panel_and_tool_rail() {
- let mut runtime = runtime();
- let output = run_ui(|ui| {
- let _ = show_tool_rail(ui, &mut runtime);
- show_pathology_workspace_panel(ui, &mut runtime);
- });
- assert!(!output.shapes.is_empty());
- }
-
- #[test]
- fn common_palette_filters_classes_by_tool_geometry() {
- let mut runtime = runtime();
- runtime.set_active_tool(ActiveTool::Point).unwrap();
- let point_classes = visible_palette(&runtime);
- assert_eq!(
- point_classes
- .iter()
- .map(|class| class.0.as_str())
- .collect::>(),
- vec!["cell", "nucleus"]
- );
- runtime.set_active_tool(ActiveTool::Polygon).unwrap();
- assert!(visible_palette(&runtime)
- .iter()
- .all(|class| !matches!(class.0.as_str(), "cell" | "nucleus")));
- }
-}
+mod tests;
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/findings.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/findings.rs
new file mode 100644
index 0000000..6304b58
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/findings.rs
@@ -0,0 +1,155 @@
+use super::*;
+use dicom_viewer_core::VectorFindingGeometry;
+
+pub(super) fn show_findings(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+) {
+ section_heading(ui, "Findings");
+ let rows = finding_rows(runtime);
+ if rows.is_empty() {
+ ui.label(
+ RichText::new("No tracked findings yet.")
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ return;
+ }
+ ScrollArea::vertical()
+ .id_salt("tracked-findings")
+ .max_height(210.0)
+ .auto_shrink([false, true])
+ .show_rows(ui, FINDING_ROW_HEIGHT, rows.len(), |ui, range| {
+ for row in &rows[range] {
+ let selected = runtime.selection().contains(&row.id);
+ ui.horizontal(|ui| {
+ let visible = runtime.document().presentation().object_visible(row.id);
+ let eye = if visible { "●" } else { "○" };
+ if ui
+ .small_button(eye)
+ .on_hover_text("Toggle visibility")
+ .clicked()
+ {
+ if let Err(error) =
+ runtime.set_object_visibility_without_history(row.id, !visible)
+ {
+ actions.error = Some(error.to_string());
+ }
+ }
+ let response = ui.selectable_label(
+ selected,
+ RichText::new(format!("#{:04} {}", row.ordinal, row.label)).size(12.0),
+ );
+ if response.clicked() {
+ let shift = ui.input(|input| input.modifiers.shift);
+ if shift {
+ runtime.toggle_selection(row.id);
+ } else {
+ runtime.select_only(row.id);
+ }
+ }
+ if response.double_clicked() {
+ actions.jump_to = Some(row.id);
+ }
+ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+ if ui
+ .small_button("⌖")
+ .on_hover_text("Jump to finding")
+ .clicked()
+ {
+ actions.jump_to = Some(row.id);
+ }
+ ui.label(
+ RichText::new(&row.metric)
+ .monospace()
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ });
+ });
+ }
+ });
+}
+
+pub(super) struct FindingRow {
+ pub(super) id: Uuid,
+ pub(super) ordinal: u64,
+ pub(super) label: String,
+ pub(super) metric: String,
+}
+
+pub(super) fn finding_rows(runtime: &WorkspaceRuntime) -> Vec {
+ let document = runtime.document();
+ let mut rows = document
+ .vector_findings()
+ .map(|finding| FindingRow {
+ id: finding.object_id(),
+ ordinal: finding.ordinal(),
+ label: document.scheme().class(finding.class_id()).map_or_else(
+ || finding.class_id().to_owned(),
+ |class| class.label().to_owned(),
+ ),
+ metric: match finding.geometry() {
+ VectorFindingGeometry::Point(_) => "point".into(),
+ VectorFindingGeometry::Regions(components) => {
+ format!(
+ "{} region{}",
+ components.len(),
+ if components.len() == 1 { "" } else { "s" }
+ )
+ }
+ },
+ })
+ .chain(document.segments().map(|segment| {
+ let geometry = document.composite_segment(segment.object_id()).ok();
+ FindingRow {
+ id: segment.object_id(),
+ ordinal: segment.ordinal(),
+ label: document.scheme().class(segment.class_id()).map_or_else(
+ || segment.class_id().to_owned(),
+ |class| class.label().to_owned(),
+ ),
+ metric: format!(
+ "{} component{}",
+ geometry
+ .as_ref()
+ .map_or(0, |geometry| geometry.components().len()),
+ if geometry
+ .as_ref()
+ .is_some_and(|geometry| geometry.components().len() == 1)
+ {
+ ""
+ } else {
+ "s"
+ }
+ ),
+ }
+ }))
+ .chain(
+ document
+ .measurements()
+ .iter()
+ .map(|measurement| FindingRow {
+ id: measurement.object_id(),
+ ordinal: measurement.ordinal(),
+ label: document.scheme().class(measurement.class_id()).map_or_else(
+ || "Ruler".into(),
+ |class| format!("{} length", class.label()),
+ ),
+ metric: measurement.physical_length_mm().map_or_else(
+ || "unscaled".into(),
+ |length| {
+ if length >= 1.0 {
+ format!("{length:.3} mm")
+ } else {
+ format!("{:.1} µm", length * 1_000.0)
+ }
+ },
+ ),
+ }),
+ )
+ .collect::>();
+ rows.sort_by_key(|row| row.ordinal);
+ rows
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/inspector.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/inspector.rs
new file mode 100644
index 0000000..034b7cc
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/inspector.rs
@@ -0,0 +1,210 @@
+use super::*;
+
+pub(super) fn show_inspector(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+) {
+ section_heading(ui, "Selection inspector");
+ match runtime.selection().len() {
+ 0 => {
+ ui.label(
+ RichText::new("Select a finding or segment to inspect it.")
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ }
+ count @ 2.. => {
+ ui.label(format!("{count} objects selected"));
+ actions.delete_selection = ui.button("Delete selected").clicked();
+ }
+ 1 => {
+ let id = *runtime
+ .selection()
+ .iter()
+ .next()
+ .expect("one selection exists");
+ if let Some(row) = finding_rows(runtime).into_iter().find(|row| row.id == id) {
+ let details = selected_details(runtime, id);
+ ui.label(RichText::new(format!("#{:04} {}", row.ordinal, row.label)).strong());
+ ui.label(
+ RichText::new(row.metric)
+ .monospace()
+ .color(theme::TEXT_MUTED),
+ );
+ if let Some(details) = details {
+ let compatible_classes = runtime
+ .document()
+ .scheme()
+ .classes()
+ .iter()
+ .filter(|class| class.geometry() == details.geometry)
+ .map(|class| (class.id().to_owned(), class.label().to_owned()))
+ .collect::>();
+ egui::ComboBox::from_id_salt(("inspector-class", id))
+ .selected_text(
+ runtime
+ .document()
+ .scheme()
+ .class(&details.class_id)
+ .map_or(details.class_id.as_str(), |class| class.label()),
+ )
+ .show_ui(ui, |ui| {
+ for (class_id, label) in compatible_classes {
+ if ui
+ .selectable_label(class_id == details.class_id, label)
+ .clicked()
+ {
+ if let Err(error) = runtime.reclassify_selection(&class_id) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ });
+
+ let finding_sites = runtime.document().scheme().finding_sites().to_vec();
+ if !finding_sites.is_empty() {
+ let selected_site = details.finding_site.as_ref().and_then(|selected| {
+ finding_sites.iter().find(|site| selected.matches(site))
+ });
+ egui::ComboBox::from_id_salt(("inspector-finding-site", id))
+ .selected_text(
+ selected_site.map_or("No finding site", |site| site.meaning()),
+ )
+ .show_ui(ui, |ui| {
+ if ui
+ .selectable_label(
+ details.finding_site.is_none(),
+ "No finding site",
+ )
+ .clicked()
+ {
+ if let Err(error) = runtime.set_selected_finding_site(None) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ for site in &finding_sites {
+ let selected = details
+ .finding_site
+ .as_ref()
+ .is_some_and(|current| current.matches(site));
+ if ui.selectable_label(selected, site.meaning()).clicked() {
+ if let Err(error) =
+ runtime.set_selected_finding_site(Some(site))
+ {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ });
+ }
+
+ let name_id = egui::Id::new(("finding-name", id));
+ let mut name = ui.ctx().data_mut(|data| {
+ data.get_temp::(name_id)
+ .unwrap_or_else(|| details.name.clone().unwrap_or_default())
+ });
+ let name_response = ui.add(
+ egui::TextEdit::singleline(&mut name)
+ .id(name_id)
+ .hint_text("Optional finding name"),
+ );
+ ui.ctx()
+ .data_mut(|data| data.insert_temp(name_id, name.clone()));
+ if name_response.lost_focus() {
+ let value = (!name.trim().is_empty()).then_some(name.trim());
+ if let Err(error) = runtime.set_selected_name(value) {
+ actions.error = Some(error.to_string());
+ }
+ }
+
+ let comment_id = egui::Id::new(("finding-comment", id));
+ let mut comment = ui.ctx().data_mut(|data| {
+ data.get_temp::(comment_id)
+ .unwrap_or_else(|| details.comment.clone().unwrap_or_default())
+ });
+ let comment_response = ui.add(
+ egui::TextEdit::multiline(&mut comment)
+ .id(comment_id)
+ .desired_rows(2)
+ .hint_text("Optional comment"),
+ );
+ ui.ctx()
+ .data_mut(|data| data.insert_temp(comment_id, comment.clone()));
+ if comment_response.lost_focus() {
+ let value = (!comment.trim().is_empty()).then_some(comment.trim());
+ if let Err(error) = runtime.set_selected_comment(value) {
+ actions.error = Some(error.to_string());
+ }
+ }
+
+ ui.label(
+ RichText::new(format!("{} · {}", details.kind, details.source_status))
+ .small()
+ .color(theme::TEXT_MUTED),
+ );
+ ui.label(
+ RichText::new(format!(
+ "Tracking ID {}\nTracking UID {}",
+ details.tracking_id, details.tracking_uid
+ ))
+ .monospace()
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ }
+ ui.label(
+ RichText::new(format!("Object {id}"))
+ .monospace()
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ actions.delete_selection = ui.button("Delete finding").clicked();
+ }
+ }
+ }
+}
+
+struct SelectedDetails {
+ class_id: String,
+ geometry: AnnotationClassGeometry,
+ name: Option,
+ comment: Option,
+ tracking_id: String,
+ tracking_uid: String,
+ kind: &'static str,
+ source_status: &'static str,
+ finding_site: Option,
+}
+
+fn selected_details(runtime: &WorkspaceRuntime, id: Uuid) -> Option {
+ let object = runtime.document().object(id)?;
+ let (geometry, kind) = match object.geometry_kind() {
+ WorkspaceObjectGeometryKind::Point => (AnnotationClassGeometry::Point, "Vector finding"),
+ WorkspaceObjectGeometryKind::Region => (AnnotationClassGeometry::Region, "Vector finding"),
+ WorkspaceObjectGeometryKind::Segmentation => {
+ (AnnotationClassGeometry::Region, "Segmentation segment")
+ }
+ WorkspaceObjectGeometryKind::Measurement => {
+ (AnnotationClassGeometry::Region, "Linear measurement")
+ }
+ };
+ Some(SelectedDetails {
+ class_id: object.class_id().to_owned(),
+ geometry,
+ name: object.name().map(str::to_owned),
+ comment: object.comment().map(str::to_owned),
+ tracking_id: object.tracking().id().to_owned(),
+ tracking_uid: object.tracking().uid().to_owned(),
+ kind,
+ source_status: provenance_label(object.provenance()),
+ finding_site: object.finding_site().cloned(),
+ })
+}
+
+fn provenance_label(provenance: &dicom_viewer_core::WorkspaceObjectProvenance) -> &'static str {
+ match provenance {
+ dicom_viewer_core::WorkspaceObjectProvenance::Manual => "manual",
+ dicom_viewer_core::WorkspaceObjectProvenance::Promoted { .. } => "promoted",
+ }
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/layers.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/layers.rs
new file mode 100644
index 0000000..dace7b8
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/layers.rs
@@ -0,0 +1,128 @@
+mod external;
+
+use super::PathologyWorkspaceActions;
+use crate::app::ui::section_heading;
+use crate::app::{
+ theme,
+ workspace::{EditingRepresentation, WorkspaceRuntime},
+};
+use eframe::egui::{self, RichText};
+use uuid::Uuid;
+
+pub(super) fn show_layers(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+) {
+ section_heading(ui, "Layers");
+ let vectors = runtime
+ .document()
+ .vector_layers()
+ .iter()
+ .map(|layer| (layer.id(), layer.name().to_owned(), layer.findings().len()))
+ .collect::>();
+ let segments = runtime
+ .document()
+ .segmentation_layers()
+ .iter()
+ .map(|layer| (layer.id(), layer.name().to_owned(), layer.segments().len()))
+ .collect::>();
+ for (id, name, count) in vectors {
+ layer_row(
+ ui,
+ runtime,
+ actions,
+ id,
+ &name,
+ count,
+ EditingRepresentation::Vector,
+ );
+ }
+ for (id, name, count) in segments {
+ layer_row(
+ ui,
+ runtime,
+ actions,
+ id,
+ &name,
+ count,
+ EditingRepresentation::Segmentation,
+ );
+ }
+ external::show_external_layers(ui, runtime, actions);
+}
+
+fn edit_layer_opacity(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ id: Uuid,
+ presentation: dicom_viewer_core::LayerPresentation,
+) {
+ let mut opacity = presentation.opacity;
+ if ui
+ .add(egui::Slider::new(&mut opacity, 0.05..=1.0).text("opacity"))
+ .changed()
+ {
+ let mut updated = presentation;
+ updated.opacity = opacity;
+ if let Err(error) = runtime.set_layer_presentation_without_history(id, updated) {
+ actions.error = Some(error.to_string());
+ }
+ }
+}
+
+fn layer_row(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ id: Uuid,
+ name: &str,
+ count: usize,
+ representation: EditingRepresentation,
+) {
+ let presentation = runtime.document().presentation().layer(id);
+ ui.horizontal(|ui| {
+ let eye = if presentation.visible { "●" } else { "○" };
+ if ui.small_button(eye).clicked() {
+ if let Err(error) = runtime.set_layer_visibility(id, !presentation.visible) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ let active = runtime.editing_representation() == representation;
+ if ui
+ .selectable_label(active, format!("{name} {count}"))
+ .clicked()
+ {
+ let result = match representation {
+ EditingRepresentation::Vector => runtime.use_vector_layer(id),
+ EditingRepresentation::Segmentation => runtime.use_segmentation_layer(id),
+ };
+ if let Err(error) = result {
+ actions.error = Some(error.to_string());
+ }
+ }
+ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+ ui.label(
+ RichText::new(if presentation.locked {
+ "locked"
+ } else {
+ "editable"
+ })
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ });
+ });
+ ui.horizontal(|ui| {
+ edit_layer_opacity(ui, runtime, actions, id, presentation);
+ let mut locked = presentation.locked;
+ if ui.checkbox(&mut locked, "Lock").changed() {
+ let mut updated = presentation;
+ updated.locked = locked;
+ if let Err(error) = runtime.set_layer_presentation_without_history(id, updated) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ });
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/layers/external.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/layers/external.rs
new file mode 100644
index 0000000..0328776
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/layers/external.rs
@@ -0,0 +1,311 @@
+use super::{edit_layer_opacity, PathologyWorkspaceActions};
+use crate::app::{
+ theme,
+ workspace::{ExternalClassDescriptor, WorkspaceRuntime},
+};
+use dicom_viewer_core::{AnnotationClassGeometry, ExternalLayerReference};
+use eframe::egui::{self, RichText, ScrollArea};
+
+pub(super) fn show_external_layers(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+) {
+ let layers = runtime.document().external_layers().to_vec();
+ for layer in &layers {
+ show_external_layer(ui, runtime, actions, layer);
+ }
+}
+
+fn show_external_layer(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ layer: &ExternalLayerReference,
+) {
+ let id = layer.id();
+ let name = layer.name();
+ let kind = layer.kind();
+ let source_path = layer.source_path();
+ let count = layer.source_object_count();
+ let presentation = runtime.document().presentation().layer(id);
+ let mut remove_layer = false;
+ let mut load_layer = false;
+ let payload_loaded = runtime.external_payload(id).is_some();
+ ui.horizontal(|ui| {
+ let eye = if presentation.visible { "●" } else { "○" };
+ if ui.small_button(eye).clicked() {
+ if let Err(error) = runtime.set_layer_visibility(id, !presentation.visible) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ ui.label(RichText::new("◇").color(theme::TEXT_DIM));
+ ui.label(format!("{name} · {count}"));
+ ui.label(RichText::new("LOCKED").small().color(theme::TEXT_DIM));
+ if !payload_loaded
+ && source_path.is_some()
+ && sidecar_kind_for_external(kind).is_some()
+ && ui.small_button("Load").clicked()
+ {
+ load_layer = true;
+ }
+ if ui.small_button("Remove").clicked() {
+ remove_layer = true;
+ }
+ });
+ ui.horizontal(|ui| {
+ edit_layer_opacity(ui, runtime, actions, id, presentation);
+ let status = source_path.map_or("embedded reference", |path| {
+ if path.exists() {
+ "linked source"
+ } else {
+ "missing linked source"
+ }
+ });
+ ui.label(RichText::new(format!("{kind:?} · {status}")).small().color(
+ if status.starts_with("missing") {
+ theme::AMBER
+ } else {
+ theme::TEXT_DIM
+ },
+ ));
+ });
+ if remove_layer {
+ match runtime.remove_external_layer(id) {
+ Ok(true) => {
+ actions.status = Some(format!("Removed source layer {name}; Undo restores it."));
+ }
+ Ok(false) => {}
+ Err(error) => actions.error = Some(error.to_string()),
+ }
+ return;
+ }
+ if load_layer {
+ actions.load_sidecar = source_path
+ .map(std::path::Path::to_path_buf)
+ .zip(sidecar_kind_for_external(kind));
+ }
+ let classes = runtime.external_classes(id);
+ ui.indent(("external-controls", id), |ui| match classes {
+ Err(error) => {
+ ui.label(RichText::new(error.to_string()).small().color(theme::AMBER));
+ }
+ Ok(classes) if classes.is_empty() => {
+ let message =
+ if *kind == dicom_viewer_core::ExternalLayerKind::Heatmap && payload_loaded {
+ "Heatmap source result; export it through DICOM PM."
+ } else {
+ "Source payload is unloaded or has no lossless editable objects."
+ };
+ ui.label(RichText::new(message).small().color(theme::TEXT_DIM));
+ }
+ Ok(classes) => {
+ ui.collapsing("Class mapping & promotion", |ui| {
+ show_promotion(ui, runtime, actions, layer, &classes);
+ });
+ }
+ });
+}
+
+fn sidecar_kind_for_external(
+ kind: &dicom_viewer_core::ExternalLayerKind,
+) -> Option {
+ match kind {
+ dicom_viewer_core::ExternalLayerKind::DicomAnn => {
+ Some(dicom_viewer_core::SidecarKind::Annotation)
+ }
+ dicom_viewer_core::ExternalLayerKind::DicomSeg => {
+ Some(dicom_viewer_core::SidecarKind::BinarySegmentation)
+ }
+ dicom_viewer_core::ExternalLayerKind::DicomSr => {
+ Some(dicom_viewer_core::SidecarKind::StructuredReport)
+ }
+ dicom_viewer_core::ExternalLayerKind::ProfiledGeoJson
+ | dicom_viewer_core::ExternalLayerKind::Heatmap => None,
+ }
+}
+
+fn show_promotion(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ layer: &ExternalLayerReference,
+ classes: &[ExternalClassDescriptor],
+) {
+ let id = layer.id();
+ let mappings = layer.class_mappings();
+ let scheme_options = runtime
+ .document()
+ .scheme()
+ .classes()
+ .iter()
+ .map(|class| {
+ (
+ class.id().to_owned(),
+ class.label().to_owned(),
+ class.geometry(),
+ )
+ })
+ .collect::>();
+ for class in classes {
+ show_class_mapping(ui, runtime, actions, layer, class, &scheme_options);
+ }
+
+ let complete = classes
+ .iter()
+ .all(|class| class.editable && mappings.contains_key(&class.key));
+ if ui
+ .add_enabled(complete, egui::Button::new("Make editable"))
+ .on_hover_text("Convert every source object only after every source class is mapped")
+ .clicked()
+ {
+ match runtime.make_external_layer_editable(id) {
+ Ok(ids) => {
+ actions.status = Some(format!(
+ "Converted {} source object(s) as independently tracked findings.",
+ ids.len()
+ ));
+ }
+ Err(error) => actions.error = Some(error.to_string()),
+ }
+ }
+
+ ui.collapsing("Source objects", |ui| {
+ show_source_objects(ui, runtime, actions, layer)
+ });
+}
+
+fn show_class_mapping(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ layer: &ExternalLayerReference,
+ class: &ExternalClassDescriptor,
+ scheme_options: &[(String, String, AnnotationClassGeometry)],
+) {
+ let id = layer.id();
+ let mappings = layer.class_mappings();
+
+ ui.horizontal_wrapped(|ui| {
+ ui.label(format!(
+ "{} · {} {}",
+ class.label,
+ class.object_count,
+ class.geometry.label().to_lowercase()
+ ));
+ if !class.editable {
+ ui.label(
+ RichText::new("read-only geometry")
+ .small()
+ .color(theme::AMBER),
+ );
+ }
+ });
+ let current = mappings.get(&class.key).cloned();
+ let selected_text = current
+ .as_deref()
+ .and_then(|id| {
+ scheme_options
+ .iter()
+ .find(|(candidate, _, _)| candidate == id)
+ .map(|(_, label, _)| label.as_str())
+ })
+ .unwrap_or("Unmapped");
+ ui.horizontal(|ui| {
+ egui::ComboBox::from_id_salt(("external-class-map", id, &class.key))
+ .selected_text(selected_text)
+ .show_ui(ui, |ui| {
+ for (target_id, label, geometry) in scheme_options {
+ if *geometry != class.geometry {
+ continue;
+ }
+ if ui
+ .selectable_label(current.as_deref() == Some(target_id.as_str()), label)
+ .clicked()
+ {
+ if let Err(error) =
+ runtime.set_external_class_mapping(id, &class.key, target_id)
+ {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ });
+ if current.is_none() {
+ if let Some(suggested) = class.exact_scheme_class_id.as_deref() {
+ let label = scheme_options
+ .iter()
+ .find(|(id, _, _)| id == suggested)
+ .map_or(suggested, |(_, label, _)| label.as_str());
+ if ui.small_button(format!("Use exact: {label}")).clicked() {
+ if let Err(error) =
+ runtime.set_external_class_mapping(id, &class.key, suggested)
+ {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ }
+ });
+}
+
+fn show_source_objects(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+ layer: &ExternalLayerReference,
+) {
+ let id = layer.id();
+ let mappings = layer.class_mappings();
+ match runtime.external_objects(id) {
+ Err(error) => {
+ ui.label(RichText::new(error.to_string()).small().color(theme::AMBER));
+ }
+ Ok(objects) => {
+ ScrollArea::vertical()
+ .id_salt(("external-objects", id))
+ .max_height(180.0)
+ .show_rows(ui, 24.0, objects.len(), |ui, range| {
+ for object in &objects[range] {
+ ui.horizontal(|ui| {
+ ui.label(
+ RichText::new(&object.label)
+ .small()
+ .color(theme::TEXT_MUTED),
+ );
+ let mapped = mappings.contains_key(&object.class_key);
+ let enabled = object.promotable && mapped && !object.promoted;
+ let response = ui.add_enabled(
+ enabled,
+ egui::Button::new(if object.promoted {
+ "Tracked"
+ } else {
+ "Promote"
+ }),
+ );
+ let response =
+ if let Some(reason) = object.promotion_block_reason.as_deref() {
+ response.on_disabled_hover_text(reason)
+ } else {
+ response
+ };
+ if response.clicked() {
+ match runtime.promote_external_object(id, &object.source_object_id)
+ {
+ Ok(_) => {
+ actions.status = Some(
+ "Promoted one source object as a tracked finding."
+ .into(),
+ );
+ }
+ Err(error) => {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ });
+ }
+ });
+ }
+ }
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/palette.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/palette.rs
new file mode 100644
index 0000000..8195da0
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/palette.rs
@@ -0,0 +1,111 @@
+use super::*;
+
+pub(super) fn show_scheme_and_palette(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+ actions: &mut PathologyWorkspaceActions,
+) {
+ section_heading(ui, "Annotation scheme");
+ let scheme = runtime.document().scheme();
+ ui.horizontal(|ui| {
+ ui.label(RichText::new(scheme.display_name()).strong());
+ ui.label(
+ RichText::new(format!("v{}", scheme.version()))
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ });
+ ui.label(
+ RichText::new(format!(
+ "{} · {}…",
+ scheme.id(),
+ &scheme.content_digest()[..12]
+ ))
+ .monospace()
+ .small()
+ .color(theme::TEXT_DIM),
+ );
+ let palette = visible_palette(runtime);
+ ui.add_space(4.0);
+ ui.horizontal_wrapped(|ui| {
+ for (id, label, color, selected) in palette {
+ let color = Color32::from_rgb(color[0], color[1], color[2]);
+ let response = ui
+ .horizontal(|ui| {
+ let (swatch, _) =
+ ui.allocate_exact_size(egui::vec2(8.0, 16.0), egui::Sense::hover());
+ ui.painter().rect_filled(swatch, 1.0, color);
+ ui.selectable_label(selected, RichText::new(label).size(12.0))
+ })
+ .inner;
+ if response.clicked() {
+ if let Err(error) = runtime.set_active_class(id) {
+ actions.error = Some(error.to_string());
+ }
+ }
+ }
+ });
+
+ if runtime.editing_representation() == EditingRepresentation::Segmentation
+ && matches!(
+ runtime.active_tool(),
+ ActiveTool::Polygon | ActiveTool::Brush
+ )
+ {
+ ui.horizontal(|ui| {
+ ui.label(RichText::new("Operation").small().color(theme::TEXT_MUTED));
+ for (operation, label) in [
+ (SegmentOperation::Add, "Add"),
+ (SegmentOperation::Erase, "Erase"),
+ ] {
+ let enabled = operation == SegmentOperation::Add
+ || runtime
+ .selection()
+ .iter()
+ .any(|id| runtime.document().segment(*id).is_some());
+ if ui
+ .add_enabled(
+ enabled,
+ egui::Button::selectable(runtime.segment_operation() == operation, label),
+ )
+ .clicked()
+ {
+ runtime.set_segment_operation(operation);
+ }
+ }
+ ui.label(RichText::new("Alt reverses").small().color(theme::TEXT_DIM));
+ });
+ if runtime.active_tool() == ActiveTool::Brush {
+ ui.label(
+ RichText::new(format!("Brush Ø {:.0} px", runtime.brush_diameter()))
+ .small()
+ .color(theme::TEXT_MUTED),
+ );
+ }
+ }
+}
+
+pub(super) fn visible_palette(runtime: &WorkspaceRuntime) -> Vec<(String, String, [u8; 3], bool)> {
+ let expected_geometry = match runtime.active_tool() {
+ ActiveTool::Point => Some(AnnotationClassGeometry::Point),
+ ActiveTool::Polygon | ActiveTool::Brush | ActiveTool::Ruler => {
+ Some(AnnotationClassGeometry::Region)
+ }
+ ActiveTool::Pan | ActiveTool::Select => None,
+ };
+ runtime
+ .document()
+ .scheme()
+ .classes()
+ .iter()
+ .filter(|class| expected_geometry.is_none_or(|geometry| class.geometry() == geometry))
+ .map(|class| {
+ (
+ class.id().to_owned(),
+ class.label().to_owned(),
+ class.display_color(),
+ runtime.active_class_id() == class.id(),
+ )
+ })
+ .collect()
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/tests.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/tests.rs
new file mode 100644
index 0000000..fde4610
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/tests.rs
@@ -0,0 +1,58 @@
+use super::*;
+use crate::app::tests::run_ui;
+use dicom_viewer_core::{AnnotationScheme, ViewerSourceIdentity};
+
+fn runtime() -> WorkspaceRuntime {
+ WorkspaceRuntime::new(
+ ViewerSourceIdentity::new(1, 0, 0, 0, 0, 0, (1_000, 1_000)),
+ AnnotationScheme::general_pathology_v1(),
+ )
+ .unwrap()
+}
+
+#[test]
+fn pathology_workspace_renders_as_one_dense_panel_and_tool_rail() {
+ let mut runtime = runtime();
+ let output = run_ui(|ui| {
+ let _ = show_tool_rail(ui, &mut runtime);
+ show_pathology_workspace_panel(ui, &mut runtime);
+ });
+ assert!(!output.shapes.is_empty());
+}
+
+#[test]
+fn pathology_panel_stays_closed_until_the_document_has_a_tracked_object() {
+ let mut runtime = runtime();
+ let mut panel_rendered = true;
+ let _ = run_ui(|ui| {
+ panel_rendered = show_populated_pathology_workspace_panel(ui, &mut runtime).is_some();
+ });
+ assert!(!panel_rendered);
+
+ runtime.set_active_tool(ActiveTool::Point).unwrap();
+ runtime
+ .add_point_finding(dicom_viewer_core::Point2::new(10.0, 20.0))
+ .unwrap();
+ let _ = run_ui(|ui| {
+ panel_rendered = show_populated_pathology_workspace_panel(ui, &mut runtime).is_some();
+ });
+ assert!(panel_rendered);
+}
+
+#[test]
+fn common_palette_filters_classes_by_tool_geometry() {
+ let mut runtime = runtime();
+ runtime.set_active_tool(ActiveTool::Point).unwrap();
+ let point_classes = visible_palette(&runtime);
+ assert_eq!(
+ point_classes
+ .iter()
+ .map(|class| class.0.as_str())
+ .collect::>(),
+ vec!["cell", "nucleus"]
+ );
+ runtime.set_active_tool(ActiveTool::Polygon).unwrap();
+ assert!(visible_palette(&runtime)
+ .iter()
+ .all(|class| !matches!(class.0.as_str(), "cell" | "nucleus")));
+}
diff --git a/apps/dicom-viewer/src/app/ui/pathology_workspace/tool_rail.rs b/apps/dicom-viewer/src/app/ui/pathology_workspace/tool_rail.rs
new file mode 100644
index 0000000..2546ec9
--- /dev/null
+++ b/apps/dicom-viewer/src/app/ui/pathology_workspace/tool_rail.rs
@@ -0,0 +1,130 @@
+use super::*;
+
+pub(in crate::app) fn show_tool_rail(
+ ui: &mut egui::Ui,
+ runtime: &mut WorkspaceRuntime,
+) -> Option {
+ let mut error = None;
+ Panel::left("pathology-tool-rail")
+ .exact_size(TOOL_RAIL_WIDTH)
+ .frame(chrome_frame(theme::CHROME, Margin::symmetric(6, 8)))
+ .show_inside(ui, |ui| {
+ ui.vertical_centered(|ui| {
+ ui.label(
+ RichText::new("TOOLS")
+ .size(9.0)
+ .color(theme::TEXT_DIM)
+ .strong(),
+ );
+ ui.add_space(3.0);
+ for tool in ActiveTool::ALL {
+ let selected = runtime.active_tool() == tool;
+ let response = ui
+ .add_sized([40.0, 34.0], egui::Button::selectable(selected, ""))
+ .on_hover_text(format!("{} ({})", tool.label(), tool.shortcut()));
+ let icon_color = if selected {
+ theme::CANVAS_EDGE
+ } else if response.hovered() {
+ theme::AMBER_BRIGHT
+ } else {
+ theme::TEXT
+ };
+ ui.painter().extend(tool_icon_shapes(
+ tool,
+ response.rect.shrink(7.0),
+ icon_color,
+ ));
+ if response.clicked() {
+ if tool == ActiveTool::Brush {
+ if let Err(err) = runtime.ensure_segmentation_layer() {
+ error = Some(err.to_string());
+ continue;
+ }
+ }
+ if runtime.request_tool(tool) == ToolTransitionOutcome::BlockedByDraft {
+ error = Some(
+ "Unfinished polygon: choose Resume, Finish, or Discard.".into(),
+ );
+ }
+ }
+ }
+ ui.add_space(5.0);
+ ui.separator();
+ if ui
+ .button(RichText::new("N").monospace().strong())
+ .on_hover_text("New independent finding / segment (N)")
+ .clicked()
+ {
+ runtime.begin_new_segment();
+ }
+ });
+ });
+ error
+}
+
+fn tool_icon_shapes(tool: ActiveTool, rect: egui::Rect, color: Color32) -> Vec {
+ let center = rect.center();
+ let radius = rect.width().min(rect.height()) * 0.42;
+ let stroke = Stroke::new(1.8, color);
+ let point = |x: f32, y: f32| center + egui::vec2(x * radius, y * radius);
+
+ match tool {
+ ActiveTool::Pan => vec![
+ egui::Shape::line_segment([point(-1.0, 0.0), point(1.0, 0.0)], stroke),
+ egui::Shape::line_segment([point(0.0, -1.0), point(0.0, 1.0)], stroke),
+ egui::Shape::line_segment([point(-1.0, 0.0), point(-0.65, -0.28)], stroke),
+ egui::Shape::line_segment([point(-1.0, 0.0), point(-0.65, 0.28)], stroke),
+ egui::Shape::line_segment([point(1.0, 0.0), point(0.65, -0.28)], stroke),
+ egui::Shape::line_segment([point(1.0, 0.0), point(0.65, 0.28)], stroke),
+ egui::Shape::line_segment([point(0.0, -1.0), point(-0.28, -0.65)], stroke),
+ egui::Shape::line_segment([point(0.0, -1.0), point(0.28, -0.65)], stroke),
+ egui::Shape::line_segment([point(0.0, 1.0), point(-0.28, 0.65)], stroke),
+ egui::Shape::line_segment([point(0.0, 1.0), point(0.28, 0.65)], stroke),
+ ],
+ ActiveTool::Select => vec![egui::Shape::closed_line(
+ vec![
+ point(-0.78, -0.92),
+ point(-0.66, 0.78),
+ point(-0.18, 0.31),
+ point(0.29, 0.95),
+ point(0.65, 0.69),
+ point(0.19, 0.08),
+ point(0.83, -0.02),
+ ],
+ stroke,
+ )],
+ ActiveTool::Polygon => vec![egui::Shape::closed_line(
+ vec![point(0.0, -0.9), point(0.9, 0.75), point(-0.9, 0.75)],
+ stroke,
+ )],
+ ActiveTool::Brush => vec![egui::Shape::circle_filled(center, radius * 0.66, color)],
+ ActiveTool::Point => vec![
+ egui::Shape::line_segment([point(-0.9, 0.0), point(0.9, 0.0)], stroke),
+ egui::Shape::line_segment([point(0.0, -0.9), point(0.0, 0.9)], stroke),
+ egui::Shape::circle_filled(center, radius * 0.16, color),
+ ],
+ ActiveTool::Ruler => vec![
+ egui::Shape::line_segment([point(-0.75, 0.75), point(0.75, -0.75)], stroke),
+ egui::Shape::line_segment([point(-0.98, 0.5), point(-0.5, 0.98)], stroke),
+ egui::Shape::line_segment([point(0.5, -0.98), point(0.98, -0.5)], stroke),
+ ],
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn every_tool_icon_is_vector_geometry_not_font_text() {
+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(24.0, 24.0));
+
+ for tool in ActiveTool::ALL {
+ let shapes = tool_icon_shapes(tool, rect, theme::TEXT);
+ assert!(!shapes.is_empty(), "{} needs a visible icon", tool.label());
+ assert!(shapes
+ .iter()
+ .all(|shape| !matches!(shape, egui::Shape::Text(_))));
+ }
+ }
+}
diff --git a/apps/dicom-viewer/src/app/viewport_export.rs b/apps/dicom-viewer/src/app/viewport_export.rs
new file mode 100644
index 0000000..557d9ab
--- /dev/null
+++ b/apps/dicom-viewer/src/app/viewport_export.rs
@@ -0,0 +1,305 @@
+use std::fs::File;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use eframe::egui;
+
+use super::export_job::WorkspaceExportKind;
+use super::workspace_actions::ensure_export_not_cancelled;
+use super::DicomViewerApp;
+
+#[derive(Debug)]
+struct ScreenshotRequest;
+
+pub(super) struct PendingViewportExport {
+ destination: PathBuf,
+ canvas_rect: egui::Rect,
+ viewport_rect: egui::Rect,
+ screenshot_request: egui::UserData,
+ request_sent: bool,
+}
+
+impl PendingViewportExport {
+ fn new(destination: PathBuf, canvas_rect: egui::Rect, viewport_rect: egui::Rect) -> Self {
+ Self {
+ destination,
+ canvas_rect,
+ viewport_rect,
+ screenshot_request: egui::UserData::new(ScreenshotRequest),
+ request_sent: false,
+ }
+ }
+
+ pub(super) fn update_canvas(&mut self, canvas_rect: egui::Rect, viewport_rect: egui::Rect) {
+ self.canvas_rect = canvas_rect;
+ self.viewport_rect = viewport_rect;
+ }
+
+ fn request_if_needed(&mut self, ctx: &egui::Context) {
+ if self.request_sent {
+ return;
+ }
+ ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(
+ self.screenshot_request.clone(),
+ ));
+ self.request_sent = true;
+ }
+
+ fn matching_image(&self, ctx: &egui::Context) -> Option> {
+ ctx.input(|input| {
+ input.events.iter().find_map(|event| match event {
+ egui::Event::Screenshot {
+ viewport_id,
+ user_data,
+ image,
+ } if *viewport_id == egui::ViewportId::ROOT
+ && user_data == &self.screenshot_request =>
+ {
+ Some(Arc::clone(image))
+ }
+ _ => None,
+ })
+ })
+ }
+}
+
+pub(super) fn should_draw_canvas_hud(capture_pending: bool) -> bool {
+ !capture_pending
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct CapturedView {
+ width: u32,
+ height: u32,
+ rgb: Vec,
+}
+
+impl DicomViewerApp {
+ pub(super) fn begin_current_view_tiff_export(&mut self, ctx: &egui::Context) {
+ if self.workspace_export_job.is_some() || self.pending_viewport_export.is_some() {
+ self.status = "Another export is already running.".into();
+ return;
+ }
+ let Some(canvas_rect) = self.last_canvas_rect else {
+ self.status = "The current slide view is not ready to capture.".into();
+ return;
+ };
+ let default_name = self
+ .active_path
+ .as_deref()
+ .and_then(Path::file_stem)
+ .and_then(|stem| stem.to_str())
+ .map_or_else(
+ || "current-view.tiff".to_owned(),
+ |stem| format!("{stem}-current-view.tiff"),
+ );
+ let Some(destination) =
+ self.choose_export_path("TIFF image", &["tif", "tiff"], &default_name)
+ else {
+ return;
+ };
+ self.pending_viewport_export = Some(PendingViewportExport::new(
+ destination,
+ canvas_rect,
+ ctx.viewport_rect(),
+ ));
+ self.status = "Preparing the current slide view for TIFF export…".into();
+ ctx.request_repaint();
+ }
+
+ pub(super) fn poll_current_view_tiff_export(&mut self, ctx: &egui::Context) {
+ let image = self.pending_viewport_export.as_mut().and_then(|pending| {
+ let image = pending.matching_image(ctx);
+ pending.request_if_needed(ctx);
+ image
+ });
+ let Some(image) = image else {
+ return;
+ };
+ let pending = self
+ .pending_viewport_export
+ .take()
+ .expect("a matching screenshot requires a pending export");
+ let view = match crop_screenshot(image.as_ref(), pending.viewport_rect, pending.canvas_rect)
+ {
+ Ok(view) => view,
+ Err(error) => {
+ self.status = format!("Could not capture the current slide view: {error}");
+ return;
+ }
+ };
+ self.start_workspace_export(
+ pending.destination,
+ WorkspaceExportKind::CurrentViewTiff,
+ ctx,
+ move |temporary, cancellation| {
+ ensure_export_not_cancelled(cancellation)?;
+ write_tiff(temporary, &view)?;
+ ensure_export_not_cancelled(cancellation)
+ },
+ );
+ }
+}
+
+fn crop_screenshot(
+ screenshot: &egui::ColorImage,
+ viewport_rect: egui::Rect,
+ canvas_rect: egui::Rect,
+) -> Result {
+ if screenshot.size[0].checked_mul(screenshot.size[1]) != Some(screenshot.pixels.len()) {
+ return Err("the screenshot pixel count does not match its dimensions".into());
+ }
+ if [
+ viewport_rect.min.x,
+ viewport_rect.min.y,
+ viewport_rect.max.x,
+ viewport_rect.max.y,
+ canvas_rect.min.x,
+ canvas_rect.min.y,
+ canvas_rect.max.x,
+ canvas_rect.max.y,
+ ]
+ .iter()
+ .any(|value| !value.is_finite())
+ {
+ return Err("the viewport or canvas bounds are invalid".into());
+ }
+ if viewport_rect.width() <= 0.0 || viewport_rect.height() <= 0.0 {
+ return Err("the viewport dimensions are invalid".into());
+ }
+
+ let image_width = screenshot.size[0];
+ let image_height = screenshot.size[1];
+ let scale_x = image_width as f32 / viewport_rect.width();
+ let scale_y = image_height as f32 / viewport_rect.height();
+ let min_x = ((canvas_rect.min.x - viewport_rect.min.x) * scale_x)
+ .floor()
+ .clamp(0.0, image_width as f32) as usize;
+ let min_y = ((canvas_rect.min.y - viewport_rect.min.y) * scale_y)
+ .floor()
+ .clamp(0.0, image_height as f32) as usize;
+ let max_x = ((canvas_rect.max.x - viewport_rect.min.x) * scale_x)
+ .ceil()
+ .clamp(0.0, image_width as f32) as usize;
+ let max_y = ((canvas_rect.max.y - viewport_rect.min.y) * scale_y)
+ .ceil()
+ .clamp(0.0, image_height as f32) as usize;
+ if max_x <= min_x || max_y <= min_y {
+ return Err("the slide canvas is outside the captured window".into());
+ }
+
+ let width = max_x - min_x;
+ let height = max_y - min_y;
+ let rgb_capacity = width
+ .checked_mul(height)
+ .and_then(|pixels| pixels.checked_mul(3))
+ .ok_or_else(|| "the TIFF dimensions overflow memory limits".to_owned())?;
+ let mut rgb = Vec::with_capacity(rgb_capacity);
+ for y in min_y..max_y {
+ let row_start = y * image_width + min_x;
+ for pixel in &screenshot.pixels[row_start..row_start + width] {
+ let [red, green, blue, _] = pixel.to_array();
+ rgb.extend_from_slice(&[red, green, blue]);
+ }
+ }
+ Ok(CapturedView {
+ width: u32::try_from(width)
+ .map_err(|_| "the TIFF width exceeds the supported range".to_owned())?,
+ height: u32::try_from(height)
+ .map_err(|_| "the TIFF height exceeds the supported range".to_owned())?,
+ rgb,
+ })
+}
+
+fn write_tiff(path: &Path, view: &CapturedView) -> Result<(), String> {
+ let expected = usize::try_from(view.width)
+ .ok()
+ .and_then(|width| {
+ usize::try_from(view.height)
+ .ok()
+ .and_then(|height| width.checked_mul(height))
+ })
+ .and_then(|pixels| pixels.checked_mul(3))
+ .ok_or_else(|| "the TIFF dimensions overflow memory limits".to_owned())?;
+ if view.rgb.len() != expected {
+ return Err("the TIFF pixel count does not match its dimensions".into());
+ }
+ let mut file = File::create(path)
+ .map_err(|error| format!("Could not create TIFF temporary file: {error}"))?;
+ {
+ let mut encoder = tiff::encoder::TiffEncoder::new(&mut file)
+ .map_err(|error| format!("Could not initialize TIFF encoder: {error}"))?;
+ encoder
+ .write_image::(view.width, view.height, &view.rgb)
+ .map_err(|error| format!("Could not encode TIFF pixels: {error}"))?;
+ }
+ file.sync_all()
+ .map_err(|error| format!("Could not flush TIFF output: {error}"))
+}
+
+#[cfg(test)]
+mod tests {
+ use eframe::egui::{self, Color32};
+
+ use super::*;
+
+ #[test]
+ fn screenshot_crop_uses_physical_pixels_and_excludes_surrounding_ui() {
+ let pixels = (0_u8..48)
+ .map(|value| Color32::from_rgb(value, value.saturating_add(1), value.saturating_add(2)))
+ .collect();
+ let screenshot = egui::ColorImage::new([8, 6], pixels);
+ let viewport = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(4.0, 3.0));
+ let canvas = egui::Rect::from_min_max(egui::pos2(1.0, 1.0), egui::pos2(3.0, 2.0));
+
+ let cropped = crop_screenshot(&screenshot, viewport, canvas).unwrap();
+
+ assert_eq!((cropped.width, cropped.height), (4, 2));
+ assert_eq!(cropped.rgb.len(), 4 * 2 * 3);
+ assert_eq!(cropped.rgb[0..3], [18, 19, 20]);
+ assert_eq!(cropped.rgb[cropped.rgb.len() - 3..], [29, 30, 31]);
+ }
+
+ #[test]
+ fn screenshot_crop_is_relative_to_the_native_viewport_origin() {
+ let pixels = (0_u8..48)
+ .map(|value| Color32::from_rgb(value, value, value))
+ .collect();
+ let screenshot = egui::ColorImage::new([8, 6], pixels);
+ let viewport = egui::Rect::from_min_size(egui::pos2(100.0, 50.0), egui::vec2(4.0, 3.0));
+ let canvas = egui::Rect::from_min_max(egui::pos2(101.0, 51.0), egui::pos2(103.0, 52.0));
+
+ let cropped = crop_screenshot(&screenshot, viewport, canvas).unwrap();
+
+ assert_eq!((cropped.width, cropped.height), (4, 2));
+ assert_eq!(cropped.rgb[0..3], [18, 18, 18]);
+ assert_eq!(cropped.rgb[cropped.rgb.len() - 3..], [29, 29, 29]);
+ }
+
+ #[test]
+ fn current_view_capture_hides_the_diagnostic_canvas_hud() {
+ assert!(should_draw_canvas_hud(false));
+ assert!(!should_draw_canvas_hud(true));
+ }
+
+ #[test]
+ fn current_view_writer_emits_a_readable_rgb_tiff() {
+ let directory = tempfile::tempdir().unwrap();
+ let path = directory.path().join("view.tiff");
+ let view = CapturedView {
+ width: 2,
+ height: 1,
+ rgb: vec![255, 0, 0, 0, 127, 255],
+ };
+
+ write_tiff(&path, &view).unwrap();
+
+ let mut decoder = tiff::decoder::Decoder::new(std::fs::File::open(path).unwrap()).unwrap();
+ assert_eq!(decoder.dimensions().unwrap(), (2, 1));
+ assert_eq!(decoder.colortype().unwrap(), tiff::ColorType::RGB(8));
+ let tiff::decoder::DecodingResult::U8(decoded) = decoder.read_image().unwrap() else {
+ panic!("RGB8 TIFF should decode to eight-bit samples");
+ };
+ assert_eq!(decoded, view.rgb);
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace.rs b/apps/dicom-viewer/src/app/workspace.rs
index 0970487..5e4ce71 100644
--- a/apps/dicom-viewer/src/app/workspace.rs
+++ b/apps/dicom-viewer/src/app/workspace.rs
@@ -1,9 +1,14 @@
+mod external;
mod external_overlay;
+mod geometry;
mod history;
mod overlay;
mod persistence;
mod scheme_library;
+mod selection;
mod spatial;
+mod tools;
+mod transaction;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::{Path, PathBuf};
@@ -83,6 +88,7 @@ pub(super) struct ExternalObjectDescriptor {
pub(in crate::app) class_key: String,
pub(in crate::app) promoted: bool,
pub(in crate::app) promotable: bool,
+ pub(in crate::app) promotion_block_reason: Option,
}
#[derive(Debug, Clone)]
@@ -163,6 +169,7 @@ struct PreparedExternalObject {
class_key: String,
geometry: Option,
promotion: Option,
+ promotion_block_reason: Option,
}
impl ActiveTool {
@@ -337,455 +344,6 @@ pub(super) struct WorkspaceRuntime {
}
impl WorkspaceRuntime {
- pub(super) fn new(
- source_identity: ViewerSourceIdentity,
- scheme: AnnotationScheme,
- ) -> ViewerResult {
- Self::from_document(WorkspaceDocument::new(source_identity, scheme)?)
- }
-
- #[cfg(test)]
- pub(super) fn with_history_limits(
- source_identity: ViewerSourceIdentity,
- scheme: AnnotationScheme,
- max_commands: usize,
- max_retained_bytes: usize,
- ) -> ViewerResult {
- let mut runtime = Self::new(source_identity, scheme)?;
- runtime.history = WorkspaceHistory::with_limits(max_commands, max_retained_bytes);
- Ok(runtime)
- }
-
- pub(super) fn from_document(document: WorkspaceDocument) -> ViewerResult {
- document.validate()?;
- let active_vector_layer = document.vector_layers()[0].id();
- let document = Arc::new(document);
- let spatial_index = WorkspaceSpatialIndex::build(&document)?;
- let spatial_revision = document.revision();
- let region_class_id = document
- .scheme()
- .classes()
- .iter()
- .find(|class| class.geometry() == dicom_viewer_core::AnnotationClassGeometry::Region)
- .map(|class| class.id().to_owned())
- .ok_or_else(|| ViewerError::InvalidInput("scheme has no region class".into()))?;
- let point_class_id = document
- .scheme()
- .classes()
- .iter()
- .find(|class| class.geometry() == dicom_viewer_core::AnnotationClassGeometry::Point)
- .map(|class| class.id().to_owned())
- .unwrap_or_else(|| region_class_id.clone());
- Ok(Self {
- document,
- history: WorkspaceHistory::default(),
- active_tool: ActiveTool::Select,
- region_class_id,
- point_class_id,
- active_vector_layer,
- active_segmentation_layer: None,
- editing_representation: EditingRepresentation::Vector,
- segment_operation: SegmentOperation::Add,
- brush_diameter: 40.0,
- selection: HashSet::new(),
- draft: None,
- draft_undo: Vec::new(),
- pending_tool: None,
- brush_stroke: None,
- brush_operation: None,
- ruler_start: None,
- spatial_index,
- spatial_revision,
- external_payloads: HashMap::new(),
- handle_drag: None,
- })
- }
-
- #[must_use]
- pub(super) fn document(&self) -> &WorkspaceDocument {
- &self.document
- }
-
- #[must_use]
- pub(super) fn document_snapshot(&self) -> Arc {
- Arc::clone(&self.document)
- }
-
- pub(super) fn edit(
- &mut self,
- label: impl Into,
- edit: impl FnOnce(&mut WorkspaceDocument) -> ViewerResult,
- ) -> ViewerResult {
- let before = Arc::clone(&self.document);
- let mut candidate = (*before).clone();
- let result = edit(&mut candidate)?;
- candidate.validate()?;
- if candidate.revision() != before.revision() {
- let after = Arc::new(candidate);
- self.history
- .record(label, Arc::clone(&before), Arc::clone(&after));
- self.document = after;
- self.draft_undo.clear();
- self.invalidate_spatial_index();
- }
- Ok(result)
- }
-
- pub(super) fn undo(&mut self) -> bool {
- let Some(document) = self.history.undo() else {
- return false;
- };
- self.document = document;
- self.selection.retain(|id| {
- self.document.finding(*id).is_some()
- || self.document.segment(*id).is_some()
- || self.document.measurement(*id).is_some()
- });
- self.invalidate_spatial_index();
- true
- }
-
- pub(super) fn redo(&mut self) -> bool {
- let Some(document) = self.history.redo() else {
- return false;
- };
- self.document = document;
- self.invalidate_spatial_index();
- true
- }
-
- #[must_use]
- pub(super) fn can_undo(&self) -> bool {
- self.history.can_undo()
- }
-
- #[must_use]
- pub(super) fn can_redo(&self) -> bool {
- self.history.can_redo()
- }
-
- #[must_use]
- pub(super) fn history_truncated(&self) -> bool {
- self.history.truncated()
- }
-
- #[must_use]
- pub(super) fn undo_label(&self) -> Option<&str> {
- self.history.undo_label()
- }
-
- #[must_use]
- pub(super) fn redo_label(&self) -> Option<&str> {
- self.history.redo_label()
- }
-
- #[must_use]
- pub(super) const fn active_tool(&self) -> ActiveTool {
- self.active_tool
- }
-
- #[cfg(test)]
- pub(super) fn set_active_tool(&mut self, tool: ActiveTool) -> ViewerResult<()> {
- match self.request_tool(tool) {
- ToolTransitionOutcome::Applied => Ok(()),
- ToolTransitionOutcome::BlockedByDraft => Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before switching tools".into(),
- )),
- }
- }
-
- pub(super) fn request_tool(&mut self, tool: ActiveTool) -> ToolTransitionOutcome {
- if self.active_tool == tool {
- return ToolTransitionOutcome::Applied;
- }
- if self.draft.is_some() {
- self.pending_tool = Some(tool);
- return ToolTransitionOutcome::BlockedByDraft;
- }
- self.active_tool = tool;
- self.draft_undo.clear();
- if matches!(tool, ActiveTool::Point | ActiveTool::Ruler) {
- self.editing_representation = EditingRepresentation::Vector;
- }
- self.pending_tool = None;
- ToolTransitionOutcome::Applied
- }
-
- pub(super) fn resolve_draft_transition(
- &mut self,
- resolution: DraftResolution,
- ) -> ViewerResult<()> {
- match resolution {
- DraftResolution::Resume => {
- self.pending_tool = None;
- }
- DraftResolution::Finish => {
- self.finish_draft()?;
- if let Some(tool) = self.pending_tool.take() {
- self.active_tool = tool;
- }
- }
- DraftResolution::Discard => {
- self.draft = None;
- self.draft_undo.clear();
- if let Some(tool) = self.pending_tool.take() {
- self.active_tool = tool;
- }
- }
- }
- Ok(())
- }
-
- pub(super) fn finish_draft(&mut self) -> ViewerResult {
- let draft = self
- .draft
- .clone()
- .ok_or_else(|| ViewerError::InvalidInput("there is no polygon draft".into()))?;
- let target_layer = match draft.target {
- DraftTarget::Vector { layer_id } | DraftTarget::Segment { layer_id, .. } => layer_id,
- };
- self.ensure_layer_editable(target_layer)?;
- let result = match draft.target {
- DraftTarget::Vector { layer_id } => self.edit("Add polygon finding", |document| {
- document.add_vector_finding(
- layer_id,
- &draft.class_id,
- dicom_viewer_core::VectorFindingGeometry::regions(vec![draft.points]),
- )
- })?,
- DraftTarget::Segment {
- layer_id,
- segment_id,
- operation,
- } => {
- let primitive = SegmentationPrimitive::polygon(operation, draft.points);
- if let Some(segment_id) = segment_id {
- self.edit("Edit segment", |document| {
- document.apply_segment_primitive(segment_id, primitive)?;
- Ok(segment_id)
- })?
- } else {
- self.edit("Add segment", |document| {
- document.add_segment(layer_id, &draft.class_id, primitive)
- })?
- }
- }
- };
- self.draft = None;
- self.select_only(result);
- Ok(result)
- }
-
- #[must_use]
- pub(super) fn draft(&self) -> Option<&DraftInteraction> {
- self.draft.as_ref()
- }
-
- pub(super) fn set_draft(&mut self, draft: DraftInteraction) {
- self.draft = Some(draft);
- self.draft_undo.clear();
- }
-
- pub(super) fn add_polygon_point(&mut self, point: Point2) -> ViewerResult<()> {
- self.draft_undo.clear();
- if let Some(draft) = &mut self.draft {
- draft.push_point(point);
- return Ok(());
- }
- let draft = match self.editing_representation {
- EditingRepresentation::Vector => {
- self.ensure_layer_editable(self.active_vector_layer)?;
- DraftInteraction::vector_polygon(
- self.active_vector_layer,
- self.region_class_id.clone(),
- vec![point],
- )
- }
- EditingRepresentation::Segmentation => {
- let layer_id = self.ensure_segmentation_layer()?;
- self.ensure_layer_editable(layer_id)?;
- let segment_id = self.selected_segment();
- if self.segment_operation == SegmentOperation::Erase && segment_id.is_none() {
- return Err(ViewerError::InvalidInput(
- "select a segment before using Erase".into(),
- ));
- }
- DraftInteraction::segment_polygon(
- layer_id,
- segment_id,
- self.segment_operation,
- self.region_class_id.clone(),
- vec![point],
- )
- }
- };
- self.draft = Some(draft);
- Ok(())
- }
-
- pub(super) fn add_point_finding(&mut self, point: Point2) -> ViewerResult {
- let layer = self.active_vector_layer;
- self.ensure_layer_editable(layer)?;
- let class_id = self.point_class_id.clone();
- let id = self.edit("Add point finding", |document| {
- document.add_vector_finding(
- layer,
- &class_id,
- dicom_viewer_core::VectorFindingGeometry::Point(point),
- )
- })?;
- self.select_only(id);
- Ok(id)
- }
-
- pub(super) fn begin_brush_stroke_with_operation(
- &mut self,
- point: Point2,
- operation: SegmentOperation,
- ) -> ViewerResult<()> {
- let layer = self.ensure_segmentation_layer()?;
- self.ensure_layer_editable(layer)?;
- if operation == SegmentOperation::Erase && self.selected_segment().is_none() {
- return Err(ViewerError::InvalidInput(
- "select a segment before using Erase".into(),
- ));
- }
- self.brush_stroke = Some(vec![point]);
- self.brush_operation = Some(operation);
- Ok(())
- }
-
- pub(super) fn extend_brush_stroke(&mut self, point: Point2) {
- if let Some(stroke) = &mut self.brush_stroke {
- let minimum_step = (self.brush_diameter * 0.08).max(0.5);
- if stroke.last().is_none_or(|last| {
- let dx = point.x - last.x;
- let dy = point.y - last.y;
- dx.hypot(dy) >= minimum_step
- }) {
- stroke.push(point);
- }
- }
- }
-
- pub(super) fn finish_brush_stroke(&mut self) -> ViewerResult> {
- let Some(centerline) = self.brush_stroke.take() else {
- return Ok(None);
- };
- let layer_id = self.ensure_segmentation_layer()?;
- self.ensure_layer_editable(layer_id)?;
- let operation = self
- .brush_operation
- .take()
- .unwrap_or(self.segment_operation);
- let segment_id = self.selected_segment();
- let primitive = SegmentationPrimitive::brush(operation, centerline, self.brush_diameter);
- let id = if let Some(segment_id) = segment_id {
- let outcome = self.edit("Brush stroke", |document| {
- document.apply_segment_primitive(segment_id, primitive)
- })?;
- if outcome == dicom_viewer_core::SegmentEditOutcome::NoIntersection {
- return Ok(None);
- }
- segment_id
- } else {
- let class_id = self.region_class_id.clone();
- self.edit("Add segment", |document| {
- document.add_segment(layer_id, &class_id, primitive)
- })?
- };
- self.select_only(id);
- Ok(Some(id))
- }
-
- pub(super) fn cancel_pointer_interaction(&mut self) {
- self.brush_stroke = None;
- self.brush_operation = None;
- }
-
- #[must_use]
- pub(super) fn brush_stroke(&self) -> Option<&[Point2]> {
- self.brush_stroke.as_deref()
- }
-
- pub(super) fn place_ruler_point(
- &mut self,
- point: Point2,
- physical_length_mm: impl FnOnce(Point2, Point2) -> Option,
- ) -> ViewerResult> {
- let Some(start) = self.ruler_start.take() else {
- self.ruler_start = Some(point);
- return Ok(None);
- };
- let class_id = self.region_class_id.clone();
- let length = physical_length_mm(start, point);
- let id = self.edit("Add ruler", |document| {
- document.add_linear_measurement(&class_id, [start, point], length)
- })?;
- self.select_only(id);
- Ok(Some(id))
- }
-
- #[must_use]
- pub(super) const fn ruler_start(&self) -> Option {
- self.ruler_start
- }
-
- pub(super) fn cancel_ruler(&mut self) -> bool {
- self.ruler_start.take().is_some()
- }
-
- pub(super) fn cancel_draft_step(&mut self) -> bool {
- let Some(before) = self.draft.as_ref().cloned() else {
- return false;
- };
- if before.points().is_empty() {
- self.draft = None;
- return true;
- }
- if before.points().len() == 1 {
- self.draft = None;
- self.draft_undo.push(DraftUndoStep::RestoreDraft(before));
- return true;
- }
- let point = self
- .draft
- .as_mut()
- .and_then(DraftInteraction::pop_point)
- .expect("the non-empty polygon draft was checked");
- self.draft_undo.push(DraftUndoStep::AppendPoint(point));
- true
- }
-
- pub(super) fn undo_draft_cancel(&mut self) -> bool {
- let Some(step) = self.draft_undo.pop() else {
- return false;
- };
- match step {
- DraftUndoStep::AppendPoint(point) => {
- let Some(draft) = &mut self.draft else {
- self.draft_undo.push(DraftUndoStep::AppendPoint(point));
- return false;
- };
- draft.push_point(point);
- }
- DraftUndoStep::RestoreDraft(draft) => {
- if self.draft.is_some() {
- self.draft_undo.push(DraftUndoStep::RestoreDraft(draft));
- return false;
- }
- self.draft = Some(draft);
- }
- }
- true
- }
-
- pub(super) fn discard_draft(&mut self) {
- self.draft = None;
- self.draft_undo.clear();
- self.pending_tool = None;
- }
-
pub(super) fn set_layer_visibility(
&mut self,
layer_id: Uuid,
@@ -821,1271 +379,6 @@ impl WorkspaceRuntime {
self.invalidate_spatial_index();
Ok(())
}
-
- #[must_use]
- pub(super) fn selection(&self) -> &HashSet {
- &self.selection
- }
-
- pub(super) fn select_only(&mut self, object_id: Uuid) {
- self.selection.clear();
- self.selection.insert(object_id);
- }
-
- pub(super) fn toggle_selection(&mut self, object_id: Uuid) {
- if !self.selection.remove(&object_id) {
- self.selection.insert(object_id);
- }
- }
-
- pub(super) fn clear_selection(&mut self) {
- self.selection.clear();
- }
-
- fn selected_segment(&self) -> Option {
- self.selection
- .iter()
- .copied()
- .find(|id| self.document.segment(*id).is_some())
- }
-
- pub(super) fn delete_selection(&mut self) -> ViewerResult {
- let ids = self.selection.iter().copied().collect::>();
- if ids.is_empty() {
- return Ok(0);
- }
- self.ensure_objects_editable(&ids)?;
- let deleted = self.edit("Delete selection", |document| {
- let mut count = 0;
- for id in &ids {
- count += usize::from(document.delete_object(*id)?);
- }
- Ok(count)
- })?;
- self.clear_selection();
- Ok(deleted)
- }
-
- pub(super) fn begin_handle_drag(&mut self, point: Point2, tolerance: f64) -> bool {
- let tolerance_squared = tolerance * tolerance;
- let mut closest: Option<(f64, Uuid, EditableHandle)> = None;
- for id in self.selection.iter().copied() {
- if self.object_locked(id) {
- continue;
- }
- if let Some(finding) = self.document.finding(id) {
- match finding.geometry() {
- VectorFindingGeometry::Point(candidate) => update_handle_candidate(
- &mut closest,
- point,
- *candidate,
- tolerance_squared,
- id,
- EditableHandle::PointFinding,
- ),
- VectorFindingGeometry::Regions(components) => {
- for (component_index, component) in components.iter().enumerate() {
- for (vertex_index, candidate) in component.iter().copied().enumerate() {
- update_handle_candidate(
- &mut closest,
- point,
- candidate,
- tolerance_squared,
- id,
- EditableHandle::PolygonVertex {
- component_index,
- vertex_index,
- },
- );
- }
- }
- }
- }
- } else if let Some(segment) = self.document.segment(id) {
- for (primitive_index, primitive) in segment.primitives().iter().enumerate() {
- let points = match primitive.geometry() {
- SegmentationPrimitiveGeometry::Polygon { points } => points.as_ref(),
- SegmentationPrimitiveGeometry::Brush { centerline, .. } => {
- centerline.as_ref()
- }
- };
- for (point_index, candidate) in points.iter().copied().enumerate() {
- update_handle_candidate(
- &mut closest,
- point,
- candidate,
- tolerance_squared,
- id,
- EditableHandle::SegmentPrimitivePoint {
- primitive_index,
- point_index,
- },
- );
- }
- }
- } else if let Some(measurement) = self.document.measurement(id) {
- for (endpoint_index, candidate) in measurement.endpoints().into_iter().enumerate() {
- update_handle_candidate(
- &mut closest,
- point,
- candidate,
- tolerance_squared,
- id,
- EditableHandle::MeasurementEndpoint { endpoint_index },
- );
- }
- }
- }
- let Some((_, object_id, handle)) = closest else {
- return false;
- };
- self.handle_drag = Some(HandleDrag {
- object_id,
- handle,
- before: Arc::clone(&self.document),
- });
- true
- }
-
- pub(super) fn update_handle_drag(
- &mut self,
- point: Point2,
- physical_length_mm: impl FnOnce(Point2, Point2) -> Option,
- ) -> ViewerResult<()> {
- let Some(drag) = &self.handle_drag else {
- return Ok(());
- };
- let object_id = drag.object_id;
- let handle = drag.handle;
- let mut candidate = (*self.document).clone();
- match handle {
- EditableHandle::PointFinding => {
- candidate
- .replace_vector_geometry(object_id, VectorFindingGeometry::Point(point))?;
- }
- EditableHandle::PolygonVertex {
- component_index,
- vertex_index,
- } => {
- candidate.move_vector_vertex(object_id, component_index, vertex_index, point)?;
- }
- EditableHandle::MeasurementEndpoint { endpoint_index } => {
- let mut endpoints = candidate
- .measurement(object_id)
- .ok_or_else(|| {
- ViewerError::InvalidInput("the dragged measurement no longer exists".into())
- })?
- .endpoints();
- endpoints[endpoint_index] = point;
- let length = physical_length_mm(endpoints[0], endpoints[1]);
- candidate.set_measurement_endpoints(object_id, endpoints, length)?;
- }
- EditableHandle::SegmentPrimitivePoint {
- primitive_index,
- point_index,
- } => {
- candidate.move_segment_primitive_point(
- object_id,
- primitive_index,
- point_index,
- point,
- )?;
- }
- }
- candidate.validate()?;
- self.document = Arc::new(candidate);
- self.invalidate_spatial_index();
- Ok(())
- }
-
- pub(super) fn finish_handle_drag(&mut self) -> bool {
- let Some(drag) = self.handle_drag.take() else {
- return false;
- };
- if drag.before.revision() == self.document.revision() {
- return false;
- }
- self.history.record(
- "Move geometry handle",
- drag.before,
- Arc::clone(&self.document),
- );
- true
- }
-
- pub(super) fn cancel_handle_drag(&mut self) -> bool {
- let Some(drag) = self.handle_drag.take() else {
- return false;
- };
- self.document = drag.before;
- self.invalidate_spatial_index();
- true
- }
-
- #[must_use]
- pub(super) const fn handle_drag_active(&self) -> bool {
- self.handle_drag.is_some()
- }
-
- pub(super) fn reclassify_selection(&mut self, class_id: &str) -> ViewerResult {
- let ids = self.selection.iter().copied().collect::>();
- if ids.is_empty() {
- return Ok(0);
- }
- self.ensure_objects_editable(&ids)?;
- self.edit("Reclassify selection", |document| {
- for id in &ids {
- document.reclassify_object(*id, class_id)?;
- }
- Ok(ids.len())
- })
- }
-
- pub(super) fn set_selected_name(&mut self, name: Option<&str>) -> ViewerResult<()> {
- let id = self.single_selection()?;
- self.ensure_objects_editable(&[id])?;
- self.edit("Rename finding", |document| {
- document.set_object_name(id, name)
- })
- }
-
- pub(super) fn set_selected_comment(&mut self, comment: Option<&str>) -> ViewerResult<()> {
- let id = self.single_selection()?;
- self.ensure_objects_editable(&[id])?;
- self.edit("Edit finding comment", |document| {
- document.set_object_comment(id, comment)
- })
- }
-
- pub(super) fn set_selected_finding_site(
- &mut self,
- site: Option<&dicom_viewer_core::DicomCode>,
- ) -> ViewerResult<()> {
- let id = self.single_selection()?;
- self.ensure_objects_editable(&[id])?;
- self.edit("Set finding site", |document| {
- document.set_object_finding_site(id, site)
- })
- }
-
- #[must_use]
- pub(super) fn active_class_id(&self) -> &str {
- match self.active_tool {
- ActiveTool::Point => &self.point_class_id,
- _ => &self.region_class_id,
- }
- }
-
- pub(super) fn set_active_class(&mut self, class_id: impl Into) -> ViewerResult<()> {
- if self.draft.is_some() {
- return Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before changing class".into(),
- ));
- }
- let class_id = class_id.into();
- let class = self.document.scheme().class(&class_id).ok_or_else(|| {
- ViewerError::InvalidInput("selected annotation class does not exist".into())
- })?;
- match class.geometry() {
- dicom_viewer_core::AnnotationClassGeometry::Region => self.region_class_id = class_id,
- dicom_viewer_core::AnnotationClassGeometry::Point => self.point_class_id = class_id,
- }
- self.draft_undo.clear();
- Ok(())
- }
-
- pub(super) fn migrate_scheme(
- &mut self,
- target: AnnotationScheme,
- mappings: &BTreeMap,
- ) -> ViewerResult<()> {
- if self.draft.is_some() {
- return Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before changing annotation scheme"
- .into(),
- ));
- }
- self.edit("Migrate annotation scheme", |document| {
- document.migrate_scheme(target, mappings)
- })
- }
-
- #[must_use]
- pub(super) const fn segment_operation(&self) -> SegmentOperation {
- self.segment_operation
- }
-
- pub(super) fn set_segment_operation(&mut self, operation: SegmentOperation) {
- self.segment_operation = operation;
- }
-
- #[must_use]
- pub(super) const fn brush_diameter(&self) -> f64 {
- self.brush_diameter
- }
-
- pub(super) fn adjust_brush_diameter(&mut self, scale: f64) {
- self.brush_diameter = (self.brush_diameter * scale).clamp(1.0, 20_000.0);
- }
-
- #[must_use]
- #[cfg(test)]
- pub(super) const fn active_vector_layer(&self) -> Uuid {
- self.active_vector_layer
- }
-
- pub(super) fn ensure_segmentation_layer(&mut self) -> ViewerResult {
- if self.draft.is_some() {
- return Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before activating Brush".into(),
- ));
- }
- if let Some(id) = self.active_segmentation_layer {
- self.editing_representation = EditingRepresentation::Segmentation;
- self.draft_undo.clear();
- return Ok(id);
- }
- let id = self.edit("Create segmentation layer", |document| {
- Ok(document.ensure_manual_segmentation_layer())
- })?;
- self.active_segmentation_layer = Some(id);
- self.editing_representation = EditingRepresentation::Segmentation;
- self.draft_undo.clear();
- Ok(id)
- }
-
- #[must_use]
- pub(super) const fn editing_representation(&self) -> EditingRepresentation {
- self.editing_representation
- }
-
- pub(super) fn use_vector_layer(&mut self, layer_id: Uuid) -> ViewerResult<()> {
- if self.draft.is_some() {
- return Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before changing layers".into(),
- ));
- }
- if !self
- .document
- .vector_layers()
- .iter()
- .any(|layer| layer.id() == layer_id)
- {
- return Err(ViewerError::InvalidInput(
- "the selected vector layer does not exist".into(),
- ));
- }
- self.active_vector_layer = layer_id;
- self.editing_representation = EditingRepresentation::Vector;
- self.draft_undo.clear();
- Ok(())
- }
-
- pub(super) fn use_segmentation_layer(&mut self, layer_id: Uuid) -> ViewerResult<()> {
- if self.draft.is_some() {
- return Err(ViewerError::InvalidInput(
- "finish, resume, or discard the current polygon before changing layers".into(),
- ));
- }
- if !self
- .document
- .segmentation_layers()
- .iter()
- .any(|layer| layer.id() == layer_id)
- {
- return Err(ViewerError::InvalidInput(
- "the selected segmentation layer does not exist".into(),
- ));
- }
- self.active_segmentation_layer = Some(layer_id);
- self.editing_representation = EditingRepresentation::Segmentation;
- self.draft_undo.clear();
- Ok(())
- }
-
- pub(super) fn begin_new_segment(&mut self) {
- self.draft_undo.clear();
- self.clear_selection();
- }
-
- pub(super) fn add_external_annotation(
- &mut self,
- name: impl Into,
- source_path: Option,
- document: AnnotationDocument,
- ) -> ViewerResult {
- let count = document.groups().len() as u64;
- let id = self.upsert_external_layer(
- name.into(),
- ExternalLayerKind::DicomAnn,
- source_path,
- None,
- count,
- )?;
- self.external_payloads
- .insert(id, ExternalLayerPayload::Annotation(Arc::new(document)));
- Ok(id)
- }
-
- pub(super) fn add_external_pathology(
- &mut self,
- name: impl Into,
- session: PathologySession,
- ) -> ViewerResult {
- let source_path = Some(session.geojson_path().to_path_buf());
- let source_digest = Some(session.semantic_digest().to_owned());
- let count = session.preview().features().len() as u64;
- let id = self.upsert_external_layer(
- name.into(),
- ExternalLayerKind::ProfiledGeoJson,
- source_path,
- source_digest,
- count,
- )?;
- self.external_payloads
- .insert(id, ExternalLayerPayload::ProfiledGeoJson(Arc::new(session)));
- Ok(id)
- }
-
- pub(super) fn add_external_segmentation(
- &mut self,
- name: impl Into,
- source_path: Option,
- document: SegmentationDocument,
- ) -> ViewerResult<(Uuid, Vec)> {
- let count = document.segments().len() as u64;
- let id = self.upsert_external_layer(
- name.into(),
- ExternalLayerKind::DicomSeg,
- source_path,
- None,
- count,
- )?;
- let (vector_groups, diagnostics) =
- if document.kind() == dicom_viewer_core::SegmentationKind::Fractional {
- (None, Vec::new())
- } else {
- let projection =
- document.vectorized_annotations(SegToAnnConversionPolicy::AllowLoss)?;
- let diagnostics = projection.diagnostics().to_vec();
- (Some(Arc::from(projection.into_groups())), diagnostics)
- };
- self.external_payloads.insert(
- id,
- ExternalLayerPayload::Segmentation {
- document: Arc::new(document),
- vector_groups,
- },
- );
- Ok((id, diagnostics))
- }
-
- pub(super) fn add_external_report(
- &mut self,
- name: impl Into,
- source_path: Option,
- session: ReportSession,
- ) -> ViewerResult {
- let count = session.document().groups().len() as u64;
- let id = self.upsert_external_layer(
- name.into(),
- ExternalLayerKind::DicomSr,
- source_path,
- None,
- count,
- )?;
- self.external_payloads
- .insert(id, ExternalLayerPayload::Report(Arc::new(session)));
- Ok(id)
- }
-
- pub(super) fn add_external_heatmap(
- &mut self,
- name: impl Into,
- session: RasterSession,
- context: &eframe::egui::Context,
- ) -> ViewerResult {
- let source_path = Some(session.raster_path().to_path_buf());
- let source_digest = Some(session.semantic_digest().to_owned());
- let count = u64::from(session.frame_count())
- .saturating_mul(u64::try_from(session.selected_channel_count()).unwrap_or(u64::MAX));
- let id = self.upsert_external_layer(
- name.into(),
- ExternalLayerKind::Heatmap,
- source_path,
- source_digest,
- count,
- )?;
- let texture = session.load_texture(context);
- self.external_payloads.insert(
- id,
- ExternalLayerPayload::Heatmap {
- session: Arc::new(session),
- texture,
- },
- );
- Ok(id)
- }
-
- fn upsert_external_layer(
- &mut self,
- name: String,
- kind: ExternalLayerKind,
- source_path: Option,
- source_digest: Option,
- source_object_count: u64,
- ) -> ViewerResult {
- if let Some(id) = self.matching_external_layer(&kind, source_path.as_deref()) {
- self.edit("Load source layer", |workspace| {
- workspace.hydrate_external_layer(id, source_object_count, source_digest)
- })?;
- return Ok(id);
- }
- let reference = ExternalLayerReference::new(
- name,
- kind,
- source_path,
- source_digest,
- source_object_count,
- );
- let id = reference.id();
- self.edit("Import source layer", |document| {
- document.add_external_layer(reference)
- })?;
- Ok(id)
- }
-
- pub(super) fn ensure_discovered_external_stub(
- &mut self,
- name: impl Into,
- kind: ExternalLayerKind,
- source_path: PathBuf,
- ) -> ViewerResult {
- if let Some(id) = self.matching_external_layer(&kind, Some(&source_path)) {
- return Ok(id);
- }
- let reference = ExternalLayerReference::new(name, kind, Some(source_path), None, 0);
- let id = reference.id();
- let mut candidate = (*self.document).clone();
- candidate.add_external_layer(reference)?;
- candidate.validate()?;
- self.document = Arc::new(candidate);
- self.invalidate_spatial_index();
- Ok(id)
- }
-
- pub(super) fn remove_external_layer(&mut self, layer_id: Uuid) -> ViewerResult {
- self.edit("Remove source layer", |document| {
- document.remove_external_layer(layer_id)
- })
- }
-
- #[must_use]
- pub(super) fn external_payload(&self, layer_id: Uuid) -> Option<&ExternalLayerPayload> {
- self.external_payloads.get(&layer_id)
- }
-
- fn matching_external_layer(
- &self,
- kind: &ExternalLayerKind,
- source_path: Option<&Path>,
- ) -> Option {
- let source_path = source_path?;
- self.document
- .external_layers()
- .iter()
- .find(|layer| layer.kind() == kind && layer.source_path() == Some(source_path))
- .map(ExternalLayerReference::id)
- }
-
- pub(super) fn external_classes(
- &self,
- layer_id: Uuid,
- ) -> ViewerResult> {
- let objects = self.prepare_external_objects(layer_id)?;
- let mut classes = BTreeMap::::new();
- for object in objects {
- let Some(geometry) = object.geometry else {
- continue;
- };
- let editable = object.promotion.is_some();
- let entry = classes.entry(object.class_key.clone()).or_insert_with(|| {
- let exact_scheme_class_id = self
- .document
- .scheme()
- .classes()
- .iter()
- .find(|class| class.concept_key().as_str() == object.class_key)
- .map(|class| class.id().to_owned());
- ExternalClassDescriptor {
- key: object.class_key,
- label: object.label,
- geometry,
- object_count: 0,
- exact_scheme_class_id,
- editable,
- }
- });
- entry.object_count = entry.object_count.saturating_add(1);
- entry.editable &= editable;
- }
- Ok(classes.into_values().collect())
- }
-
- pub(super) fn external_objects(
- &self,
- layer_id: Uuid,
- ) -> ViewerResult> {
- self.prepare_external_objects(layer_id).map(|objects| {
- objects
- .into_iter()
- .map(|object| ExternalObjectDescriptor {
- promoted: self.source_object_was_promoted(layer_id, &object.source_object_id),
- promotable: object.promotion.is_some(),
- source_object_id: object.source_object_id,
- label: object.label,
- class_key: object.class_key,
- })
- .collect()
- })
- }
-
- pub(super) fn set_external_class_mapping(
- &mut self,
- layer_id: Uuid,
- source_class_key: &str,
- target_class_id: &str,
- ) -> ViewerResult<()> {
- let source = self
- .external_classes(layer_id)?
- .into_iter()
- .find(|class| class.key == source_class_key)
- .ok_or_else(|| {
- ViewerError::InvalidInput("the external source class does not exist".into())
- })?;
- let target = self
- .document
- .scheme()
- .class(target_class_id)
- .ok_or_else(|| {
- ViewerError::InvalidInput(
- "the mapping target is not in the pinned annotation scheme".into(),
- )
- })?;
- if source.geometry != target.geometry() {
- return Err(ViewerError::InvalidInput(
- "external class mappings cannot change point/region geometry".into(),
- ));
- }
- let source_class_key = source_class_key.to_owned();
- let target_class_id = target_class_id.to_owned();
- self.edit("Map external class", move |document| {
- document.set_external_class_mapping(layer_id, &source_class_key, &target_class_id)
- })
- }
-
- pub(super) fn promote_external_object(
- &mut self,
- layer_id: Uuid,
- source_object_id: &str,
- ) -> ViewerResult {
- if self.source_object_was_promoted(layer_id, source_object_id) {
- return Err(ViewerError::InvalidInput(
- "the selected source object is already a tracked finding".into(),
- ));
- }
- let object = self
- .prepare_external_objects(layer_id)?
- .into_iter()
- .find(|object| object.source_object_id == source_object_id)
- .ok_or_else(|| {
- ViewerError::InvalidInput("the external source object does not exist".into())
- })?;
- let class_id = self.external_mapping_target(layer_id, &object.class_key)?;
- let promotion = object.promotion.ok_or_else(|| {
- ViewerError::Unsupported(
- "the selected external object cannot be represented by an editable workspace geometry".into(),
- )
- })?;
- let vector_layer = self.active_vector_layer;
- let source_object_id = object.source_object_id;
- let id = self.edit("Promote source object", move |document| {
- apply_external_promotion(
- document,
- vector_layer,
- layer_id,
- source_object_id,
- &class_id,
- promotion,
- )
- })?;
- if self.document.segment(id).is_some() {
- self.active_segmentation_layer = self
- .document
- .segmentation_layers()
- .iter()
- .find(|layer| {
- layer
- .segments()
- .iter()
- .any(|segment| segment.object_id() == id)
- })
- .map(|layer| layer.id());
- }
- self.select_only(id);
- Ok(id)
- }
-
- pub(super) fn make_external_layer_editable(
- &mut self,
- layer_id: Uuid,
- ) -> ViewerResult> {
- let objects = self.prepare_external_objects(layer_id)?;
- if objects.is_empty() {
- return Err(ViewerError::InvalidInput(
- "the external layer contains no convertible objects".into(),
- ));
- }
- if objects
- .iter()
- .any(|object| self.source_object_was_promoted(layer_id, &object.source_object_id))
- {
- return Err(ViewerError::InvalidInput(
- "the external layer already contains promoted objects; promote the remaining objects individually".into(),
- ));
- }
- let prepared = objects
- .into_iter()
- .map(|object| {
- let class_id = self.external_mapping_target(layer_id, &object.class_key)?;
- let promotion = object.promotion.ok_or_else(|| {
- ViewerError::Unsupported(format!(
- "source object {} cannot be converted losslessly",
- object.source_object_id
- ))
- })?;
- Ok((object.source_object_id, class_id, promotion))
- })
- .collect::>>()?;
- let vector_layer = self.active_vector_layer;
- let ids = self.edit("Make external layer editable", move |document| {
- prepared
- .into_iter()
- .map(|(source_object_id, class_id, promotion)| {
- apply_external_promotion(
- document,
- vector_layer,
- layer_id,
- source_object_id,
- &class_id,
- promotion,
- )
- })
- .collect::>>()
- })?;
- self.selection = ids.iter().copied().collect();
- if ids.iter().any(|id| self.document.segment(*id).is_some()) {
- self.active_segmentation_layer = self
- .document
- .segmentation_layers()
- .iter()
- .find(|layer| {
- layer
- .segments()
- .iter()
- .any(|segment| ids.contains(&segment.object_id()))
- })
- .map(|layer| layer.id());
- }
- Ok(ids)
- }
-
- fn external_mapping_target(
- &self,
- layer_id: Uuid,
- source_class_key: &str,
- ) -> ViewerResult {
- self.document
- .external_layers()
- .iter()
- .find(|layer| layer.id() == layer_id)
- .and_then(|layer| layer.class_mappings().get(source_class_key))
- .cloned()
- .ok_or_else(|| {
- ViewerError::InvalidInput(
- "every source class needs an explicit mapping before promotion".into(),
- )
- })
- }
-
- fn prepare_external_objects(
- &self,
- layer_id: Uuid,
- ) -> ViewerResult> {
- if !self
- .document
- .external_layers()
- .iter()
- .any(|layer| layer.id() == layer_id)
- {
- return Err(ViewerError::InvalidInput(
- "the external source layer does not exist".into(),
- ));
- }
- match self.external_payloads.get(&layer_id) {
- Some(ExternalLayerPayload::Annotation(document)) => {
- prepare_annotation_objects(document)
- }
- Some(ExternalLayerPayload::ProfiledGeoJson(session)) => session
- .editable_ann()
- .map_or_else(|| Ok(Vec::new()), prepare_annotation_objects),
- Some(ExternalLayerPayload::Segmentation { document, .. }) => {
- prepare_segmentation_objects(document)
- }
- Some(ExternalLayerPayload::Report(session)) => {
- prepare_report_objects(session.document())
- }
- Some(ExternalLayerPayload::Heatmap { .. }) => Ok(Vec::new()),
- None => Ok(Vec::new()),
- }
- }
-
- fn source_object_was_promoted(&self, layer_id: Uuid, source_object_id: &str) -> bool {
- self.document
- .vector_findings()
- .map(|finding| finding.provenance())
- .chain(self.document.segments().map(|segment| segment.provenance()))
- .chain(
- self.document
- .measurements()
- .iter()
- .map(|measurement| measurement.provenance()),
- )
- .any(|provenance| {
- matches!(
- provenance,
- WorkspaceObjectProvenance::Promoted {
- source_layer_id,
- source_object_id: promoted_id,
- } if *source_layer_id == layer_id && promoted_id == source_object_id
- )
- })
- }
-
- pub(super) fn refresh_spatial_index(&mut self) -> ViewerResult<()> {
- if self.spatial_revision != self.document.revision() {
- self.spatial_index = WorkspaceSpatialIndex::build(&self.document)?;
- self.spatial_revision = self.document.revision();
- }
- Ok(())
- }
-
- #[must_use]
- pub(super) fn spatial_index(&self) -> &WorkspaceSpatialIndex {
- &self.spatial_index
- }
-
- #[must_use]
- pub(super) fn hit_test(&self, point: Point2, tolerance: f64) -> Option {
- let query = [
- point.x - tolerance,
- point.y - tolerance,
- point.x + tolerance,
- point.y + tolerance,
- ];
- self.spatial_index
- .query(query, 256)
- .into_iter()
- .filter_map(|id| {
- object_distance(self.document(), id, point).map(|distance| (id, distance))
- })
- .filter(|(_, distance)| *distance <= tolerance)
- .min_by(|left, right| left.1.total_cmp(&right.1))
- .map(|(id, _)| id)
- }
-
- #[must_use]
- pub(super) fn object_bounds(&self, id: Uuid) -> Option<[f64; 4]> {
- self.spatial_index.bounds(id)
- }
-
- fn invalidate_spatial_index(&mut self) {
- self.spatial_revision = u64::MAX;
- }
-
- fn single_selection(&self) -> ViewerResult {
- if self.selection.len() != 1 {
- return Err(ViewerError::InvalidInput(
- "select exactly one tracked object".into(),
- ));
- }
- Ok(*self
- .selection
- .iter()
- .next()
- .expect("one selected object exists"))
- }
-
- fn ensure_layer_editable(&self, layer_id: Uuid) -> ViewerResult<()> {
- if self.document.presentation().layer(layer_id).locked {
- return Err(ViewerError::InvalidInput(
- "the active annotation layer is locked".into(),
- ));
- }
- Ok(())
- }
-
- fn ensure_objects_editable(&self, object_ids: &[Uuid]) -> ViewerResult<()> {
- if object_ids.iter().copied().any(|id| self.object_locked(id)) {
- return Err(ViewerError::InvalidInput(
- "the selection contains an object on a locked layer".into(),
- ));
- }
- Ok(())
- }
-
- fn object_locked(&self, object_id: Uuid) -> bool {
- self.document.vector_layers().iter().any(|layer| {
- layer
- .findings()
- .iter()
- .any(|finding| finding.object_id() == object_id)
- && self.document.presentation().layer(layer.id()).locked
- }) || self.document.segmentation_layers().iter().any(|layer| {
- layer
- .segments()
- .iter()
- .any(|segment| segment.object_id() == object_id)
- && self.document.presentation().layer(layer.id()).locked
- })
- }
-}
-
-fn annotation_group_geometry(
- group: &dicom_viewer_core::AnnotationGroup,
-) -> Option {
- match group.geometry() {
- AnnotationGeometry::Points(_) => Some(AnnotationClassGeometry::Point),
- AnnotationGeometry::Polygons(_) => Some(AnnotationClassGeometry::Region),
- AnnotationGeometry::ReadOnly { graphic_type, .. } => match graphic_type {
- dicom_viewer_core::AnnotationGraphicType::Point => Some(AnnotationClassGeometry::Point),
- dicom_viewer_core::AnnotationGraphicType::Polygon => {
- Some(AnnotationClassGeometry::Region)
- }
- dicom_viewer_core::AnnotationGraphicType::Polyline
- | dicom_viewer_core::AnnotationGraphicType::Ellipse
- | dicom_viewer_core::AnnotationGraphicType::Rectangle => None,
- },
- }
-}
-
-fn prepare_annotation_objects(
- document: &AnnotationDocument,
-) -> ViewerResult> {
- let mut objects = Vec::new();
- for group in document.groups() {
- let Some(geometry) = annotation_group_geometry(group) else {
- continue;
- };
- let class_key = annotation_class_concept_key(
- geometry,
- group.category(),
- group.property_type(),
- group.property_type_modifiers(),
- )
- .to_string();
- let source_frame = SourceFrameContext::new(
- (group.referenced_optical_paths().len() == 1)
- .then(|| group.referenced_optical_paths()[0].clone()),
- None,
- None,
- None,
- );
- match group.geometry() {
- AnnotationGeometry::Points(points) => {
- for (index, point) in points.iter().copied().enumerate() {
- let point = document.canonical_level0_pixel(
- document.source(),
- point.x,
- point.y,
- None,
- )?;
- objects.push(PreparedExternalObject {
- source_object_id: format!("{}:{}", group.uid(), index + 1),
- label: group.label().to_owned(),
- class_key: class_key.clone(),
- geometry: Some(geometry),
- promotion: Some(PreparedExternalPromotion::Vector {
- geometry: VectorFindingGeometry::Point(point),
- tracking: None,
- source_frame: source_frame.clone(),
- }),
- });
- }
- }
- AnnotationGeometry::Polygons(polygons) => {
- for (index, polygon) in polygons.iter().enumerate() {
- let polygon = polygon
- .iter()
- .map(|point| {
- document
- .canonical_level0_pixel(document.source(), point.x, point.y, None)
- .map_err(dicom_viewer_core::ViewerError::from)
- })
- .collect::>>()?;
- objects.push(PreparedExternalObject {
- source_object_id: format!("{}:{}", group.uid(), index + 1),
- label: group.label().to_owned(),
- class_key: class_key.clone(),
- geometry: Some(geometry),
- promotion: Some(PreparedExternalPromotion::Vector {
- geometry: VectorFindingGeometry::regions(vec![polygon]),
- tracking: None,
- source_frame: source_frame.clone(),
- }),
- });
- }
- }
- AnnotationGeometry::ReadOnly { .. } => {
- for index in 0..group.annotation_count() {
- objects.push(PreparedExternalObject {
- source_object_id: format!("{}:{}", group.uid(), index + 1),
- label: group.label().to_owned(),
- class_key: class_key.clone(),
- geometry: Some(geometry),
- promotion: None,
- });
- }
- }
- }
- }
- Ok(objects)
-}
-
-fn prepare_segmentation_objects(
- document: &SegmentationDocument,
-) -> ViewerResult> {
- let mut polygons = BTreeMap::>>::new();
- if document.editable() {
- for run in document.binary_runs()? {
- let x0 = f64::from(run.column_start());
- let x1 = f64::from(run.column_start().saturating_add(run.length()));
- let y0 = f64::from(run.row());
- let y1 = y0 + 1.0;
- polygons.entry(run.segment_number()).or_default().push(vec![
- Point2::new(x0, y0),
- Point2::new(x1, y0),
- Point2::new(x1, y1),
- Point2::new(x0, y1),
- ]);
- }
- }
- Ok(document
- .segments()
- .iter()
- .enumerate()
- .map(|(index, segment)| {
- let number = segment
- .source_segment_number()
- .unwrap_or_else(|| u16::try_from(index + 1).unwrap_or(u16::MAX));
- let class_key = annotation_class_concept_key(
- AnnotationClassGeometry::Region,
- segment.category(),
- segment.property_type(),
- segment.property_type_modifiers(),
- )
- .to_string();
- let tracking = segment
- .tracking_id()
- .zip(segment.tracking_uid())
- .and_then(|(id, uid)| TrackingIdentity::new(id, uid).ok());
- let primitives = polygons.remove(&number).map(|polygons| {
- polygons
- .into_iter()
- .map(|polygon| SegmentationPrimitive::polygon(SegmentOperation::Add, polygon))
- .collect::>()
- });
- PreparedExternalObject {
- source_object_id: format!("segment:{number}"),
- label: segment.label().to_owned(),
- class_key,
- geometry: Some(AnnotationClassGeometry::Region),
- promotion: primitives.filter(|primitives| !primitives.is_empty()).map(
- |primitives| PreparedExternalPromotion::Segment {
- primitives,
- tracking,
- source_frame: SourceFrameContext::default(),
- },
- ),
- }
- })
- .collect())
-}
-
-fn prepare_report_objects(
- document: &StructuredReportDocument,
-) -> ViewerResult> {
- let mut objects = Vec::new();
- for group in document.groups() {
- let class_key = annotation_class_concept_key(
- AnnotationClassGeometry::Region,
- group.finding_category(),
- group.finding_type(),
- &[],
- )
- .to_string();
- let source_tracking = TrackingIdentity::new(group.tracking_id(), group.tracking_uid()).ok();
- for (measurement_index, measurement) in group.measurements().iter().enumerate() {
- for (coordinate_index, coordinates) in measurement.coordinates().iter().enumerate() {
- if coordinates.graphic() != dicom_viewer_core::CoordinateGraphic::Polyline
- || coordinates.points().len() != 2
- {
- continue;
- }
- let source_object_id = format!(
- "{}:{}:{}",
- group.tracking_uid(),
- measurement_index + 1,
- coordinate_index + 1
- );
- let physical_length_mm = measurement_length_mm(measurement);
- let endpoints = coordinates
- .points()
- .iter()
- .map(|point| {
- document
- .source()
- .slide_coordinate_to_pixel3(point.x, point.y, point.z)
- .map_err(dicom_viewer_core::ViewerError::from)
- })
- .collect::>>()?;
- let promotion = physical_length_mm.map(|physical_length_mm| {
- PreparedExternalPromotion::Measurement {
- endpoints: [endpoints[0], endpoints[1]],
- physical_length_mm,
- tracking: source_tracking.clone(),
- source_frame: SourceFrameContext::default(),
- }
- });
- objects.push(PreparedExternalObject {
- source_object_id,
- label: group.finding_type().meaning().to_owned(),
- class_key: class_key.clone(),
- geometry: Some(AnnotationClassGeometry::Region),
- promotion,
- });
- }
- }
- }
- Ok(objects)
-}
-
-fn measurement_length_mm(
- measurement: &dicom_viewer_core::StructuredReportMeasurement,
-) -> Option {
- if measurement.concept().scheme() != "SCT"
- || measurement.concept().value() != "410668003"
- || measurement.unit().scheme() != "UCUM"
- || !measurement.value().is_finite()
- || measurement.value() <= 0.0
- {
- return None;
- }
- match measurement.unit().value() {
- "mm" => Some(measurement.value()),
- "um" | "µm" => Some(measurement.value() / 1_000.0),
- _ => None,
- }
-}
-
-fn object_distance(document: &WorkspaceDocument, id: Uuid, point: Point2) -> Option {
- if let Some(finding) = document.finding(id) {
- return Some(match finding.geometry() {
- dicom_viewer_core::VectorFindingGeometry::Point(candidate) => {
- (candidate.x - point.x).hypot(candidate.y - point.y)
- }
- dicom_viewer_core::VectorFindingGeometry::Regions(components) => components
- .iter()
- .map(|component| polygon_distance(component, point))
- .fold(f64::INFINITY, f64::min),
- });
- }
- if let Some(segment) = document.segment(id) {
- let geometry = document.composite_segment(segment.object_id()).ok()?;
- return geometry
- .components()
- .iter()
- .map(|component| {
- let inside = dicom_viewer_core::polygon_contains_point(component.exterior(), point)
- && !component
- .holes()
- .iter()
- .any(|hole| dicom_viewer_core::polygon_contains_point(hole, point));
- if inside {
- 0.0
- } else {
- std::iter::once(component.exterior())
- .chain(component.holes().iter().map(Vec::as_slice))
- .map(|ring| ring_edge_distance(ring, point))
- .fold(f64::INFINITY, f64::min)
- }
- })
- .min_by(f64::total_cmp);
- }
- let measurement = document.measurement(id)?;
- let endpoints = measurement.endpoints();
- Some(segment_distance(endpoints[0], endpoints[1], point))
-}
-
-fn update_handle_candidate(
- closest: &mut Option<(f64, Uuid, EditableHandle)>,
- target: Point2,
- candidate: Point2,
- tolerance_squared: f64,
- object_id: Uuid,
- handle: EditableHandle,
-) {
- let dx = candidate.x - target.x;
- let dy = candidate.y - target.y;
- let distance_squared = dx * dx + dy * dy;
- if distance_squared > tolerance_squared
- || closest
- .as_ref()
- .is_some_and(|(best, _, _)| *best <= distance_squared)
- {
- return;
- }
- *closest = Some((distance_squared, object_id, handle));
-}
-
-fn polygon_distance(polygon: &[Point2], point: Point2) -> f64 {
- if dicom_viewer_core::polygon_contains_point(polygon, point) {
- 0.0
- } else {
- ring_edge_distance(polygon, point)
- }
-}
-
-fn ring_edge_distance(points: &[Point2], point: Point2) -> f64 {
- points
- .iter()
- .zip(points.iter().cycle().skip(1))
- .take(points.len())
- .map(|(start, end)| segment_distance(*start, *end, point))
- .fold(f64::INFINITY, f64::min)
-}
-
-fn segment_distance(start: Point2, end: Point2, point: Point2) -> f64 {
- let dx = end.x - start.x;
- let dy = end.y - start.y;
- let length_squared = dx * dx + dy * dy;
- if length_squared <= f64::EPSILON {
- return (point.x - start.x).hypot(point.y - start.y);
- }
- let fraction =
- (((point.x - start.x) * dx + (point.y - start.y) * dy) / length_squared).clamp(0.0, 1.0);
- let closest = Point2::new(start.x + fraction * dx, start.y + fraction * dy);
- (point.x - closest.x).hypot(point.y - closest.y)
}
#[cfg(test)]
diff --git a/apps/dicom-viewer/src/app/workspace/external.rs b/apps/dicom-viewer/src/app/workspace/external.rs
new file mode 100644
index 0000000..9a5dd17
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace/external.rs
@@ -0,0 +1,724 @@
+use super::*;
+
+impl WorkspaceRuntime {
+ pub(in crate::app) fn add_external_annotation(
+ &mut self,
+ name: impl Into,
+ source_path: Option,
+ document: AnnotationDocument,
+ ) -> ViewerResult {
+ let count = document.groups().len() as u64;
+ let id = self.upsert_external_layer(
+ name.into(),
+ ExternalLayerKind::DicomAnn,
+ source_path,
+ None,
+ count,
+ )?;
+ self.external_payloads
+ .insert(id, ExternalLayerPayload::Annotation(Arc::new(document)));
+ Ok(id)
+ }
+
+ pub(in crate::app) fn add_external_pathology(
+ &mut self,
+ name: impl Into,
+ session: PathologySession,
+ ) -> ViewerResult {
+ let source_path = Some(session.geojson_path().to_path_buf());
+ let source_digest = Some(session.semantic_digest().to_owned());
+ let count = session.preview().features().len() as u64;
+ let id = self.upsert_external_layer(
+ name.into(),
+ ExternalLayerKind::ProfiledGeoJson,
+ source_path,
+ source_digest,
+ count,
+ )?;
+ self.external_payloads
+ .insert(id, ExternalLayerPayload::ProfiledGeoJson(Arc::new(session)));
+ Ok(id)
+ }
+
+ pub(in crate::app) fn add_external_segmentation(
+ &mut self,
+ name: impl Into,
+ source_path: Option,
+ document: SegmentationDocument,
+ ) -> ViewerResult<(Uuid, Vec)> {
+ let count = document.segments().len() as u64;
+ let id = self.upsert_external_layer(
+ name.into(),
+ ExternalLayerKind::DicomSeg,
+ source_path,
+ None,
+ count,
+ )?;
+ let (vector_groups, diagnostics) =
+ if document.kind() == dicom_viewer_core::SegmentationKind::Fractional {
+ (None, Vec::new())
+ } else {
+ let projection =
+ document.vectorized_annotations(SegToAnnConversionPolicy::AllowLoss)?;
+ let diagnostics = projection.diagnostics().to_vec();
+ (Some(Arc::from(projection.into_groups())), diagnostics)
+ };
+ self.external_payloads.insert(
+ id,
+ ExternalLayerPayload::Segmentation {
+ document: Arc::new(document),
+ vector_groups,
+ },
+ );
+ Ok((id, diagnostics))
+ }
+
+ pub(in crate::app) fn add_external_report(
+ &mut self,
+ name: impl Into,
+ source_path: Option,
+ session: ReportSession,
+ ) -> ViewerResult {
+ let count = session.document().groups().len() as u64;
+ let id = self.upsert_external_layer(
+ name.into(),
+ ExternalLayerKind::DicomSr,
+ source_path,
+ None,
+ count,
+ )?;
+ self.external_payloads
+ .insert(id, ExternalLayerPayload::Report(Arc::new(session)));
+ Ok(id)
+ }
+
+ pub(in crate::app) fn add_external_heatmap(
+ &mut self,
+ name: impl Into,
+ session: RasterSession,
+ context: &eframe::egui::Context,
+ ) -> ViewerResult {
+ let source_path = Some(session.raster_path().to_path_buf());
+ let source_digest = Some(session.semantic_digest().to_owned());
+ let count = u64::from(session.frame_count())
+ .saturating_mul(u64::try_from(session.selected_channel_count()).unwrap_or(u64::MAX));
+ let id = self.upsert_external_layer(
+ name.into(),
+ ExternalLayerKind::Heatmap,
+ source_path,
+ source_digest,
+ count,
+ )?;
+ let texture = session.load_texture(context);
+ self.external_payloads.insert(
+ id,
+ ExternalLayerPayload::Heatmap {
+ session: Arc::new(session),
+ texture,
+ },
+ );
+ Ok(id)
+ }
+
+ fn upsert_external_layer(
+ &mut self,
+ name: String,
+ kind: ExternalLayerKind,
+ source_path: Option,
+ source_digest: Option,
+ source_object_count: u64,
+ ) -> ViewerResult {
+ if let Some(id) = self.matching_external_layer(&kind, source_path.as_deref()) {
+ self.edit("Load source layer", |workspace| {
+ workspace.hydrate_external_layer(id, source_object_count, source_digest)
+ })?;
+ return Ok(id);
+ }
+ let reference = ExternalLayerReference::new(
+ name,
+ kind,
+ source_path,
+ source_digest,
+ source_object_count,
+ );
+ let id = reference.id();
+ self.edit("Import source layer", |document| {
+ document.add_external_layer(reference)
+ })?;
+ Ok(id)
+ }
+
+ pub(in crate::app) fn ensure_discovered_external_stub(
+ &mut self,
+ name: impl Into,
+ kind: ExternalLayerKind,
+ source_path: PathBuf,
+ ) -> ViewerResult {
+ if let Some(id) = self.matching_external_layer(&kind, Some(&source_path)) {
+ return Ok(id);
+ }
+ let reference = ExternalLayerReference::new(name, kind, Some(source_path), None, 0);
+ let id = reference.id();
+ let mut candidate = (*self.document).clone();
+ candidate.add_external_layer(reference)?;
+ candidate.validate()?;
+ self.document = Arc::new(candidate);
+ self.invalidate_spatial_index();
+ Ok(id)
+ }
+
+ pub(in crate::app) fn remove_external_layer(&mut self, layer_id: Uuid) -> ViewerResult {
+ self.edit("Remove source layer", |document| {
+ document.remove_external_layer(layer_id)
+ })
+ }
+
+ #[must_use]
+ pub(in crate::app) fn external_payload(&self, layer_id: Uuid) -> Option<&ExternalLayerPayload> {
+ self.external_payloads.get(&layer_id)
+ }
+
+ fn matching_external_layer(
+ &self,
+ kind: &ExternalLayerKind,
+ source_path: Option<&Path>,
+ ) -> Option {
+ let source_path = source_path?;
+ self.document
+ .external_layers()
+ .iter()
+ .find(|layer| layer.kind() == kind && layer.source_path() == Some(source_path))
+ .map(ExternalLayerReference::id)
+ }
+
+ pub(in crate::app) fn external_classes(
+ &self,
+ layer_id: Uuid,
+ ) -> ViewerResult> {
+ let objects = self.prepare_external_objects(layer_id)?;
+ let mut classes = BTreeMap::::new();
+ for object in objects {
+ let Some(geometry) = object.geometry else {
+ continue;
+ };
+ let editable = object.promotion.is_some();
+ let entry = classes.entry(object.class_key.clone()).or_insert_with(|| {
+ let exact_scheme_class_id = self
+ .document
+ .scheme()
+ .classes()
+ .iter()
+ .find(|class| class.concept_key().as_str() == object.class_key)
+ .map(|class| class.id().to_owned());
+ ExternalClassDescriptor {
+ key: object.class_key,
+ label: object.label,
+ geometry,
+ object_count: 0,
+ exact_scheme_class_id,
+ editable,
+ }
+ });
+ entry.object_count = entry.object_count.saturating_add(1);
+ entry.editable &= editable;
+ }
+ Ok(classes.into_values().collect())
+ }
+
+ pub(in crate::app) fn external_objects(
+ &self,
+ layer_id: Uuid,
+ ) -> ViewerResult> {
+ self.prepare_external_objects(layer_id).map(|objects| {
+ objects
+ .into_iter()
+ .map(|object| ExternalObjectDescriptor {
+ promoted: self.source_object_was_promoted(layer_id, &object.source_object_id),
+ promotable: object.promotion.is_some(),
+ promotion_block_reason: object.promotion_block_reason,
+ source_object_id: object.source_object_id,
+ label: object.label,
+ class_key: object.class_key,
+ })
+ .collect()
+ })
+ }
+
+ pub(in crate::app) fn set_external_class_mapping(
+ &mut self,
+ layer_id: Uuid,
+ source_class_key: &str,
+ target_class_id: &str,
+ ) -> ViewerResult<()> {
+ let source = self
+ .external_classes(layer_id)?
+ .into_iter()
+ .find(|class| class.key == source_class_key)
+ .ok_or_else(|| {
+ ViewerError::InvalidInput("the external source class does not exist".into())
+ })?;
+ let target = self
+ .document
+ .scheme()
+ .class(target_class_id)
+ .ok_or_else(|| {
+ ViewerError::InvalidInput(
+ "the mapping target is not in the pinned annotation scheme".into(),
+ )
+ })?;
+ if source.geometry != target.geometry() {
+ return Err(ViewerError::InvalidInput(
+ "external class mappings cannot change point/region geometry".into(),
+ ));
+ }
+ let source_class_key = source_class_key.to_owned();
+ let target_class_id = target_class_id.to_owned();
+ self.edit("Map external class", move |document| {
+ document.set_external_class_mapping(layer_id, &source_class_key, &target_class_id)
+ })
+ }
+
+ pub(in crate::app) fn promote_external_object(
+ &mut self,
+ layer_id: Uuid,
+ source_object_id: &str,
+ ) -> ViewerResult {
+ if self.source_object_was_promoted(layer_id, source_object_id) {
+ return Err(ViewerError::InvalidInput(
+ "the selected source object is already a tracked finding".into(),
+ ));
+ }
+ let object = self
+ .prepare_external_objects(layer_id)?
+ .into_iter()
+ .find(|object| object.source_object_id == source_object_id)
+ .ok_or_else(|| {
+ ViewerError::InvalidInput("the external source object does not exist".into())
+ })?;
+ let class_id = self.external_mapping_target(layer_id, &object.class_key)?;
+ let promotion = object.promotion.ok_or_else(|| {
+ ViewerError::Unsupported(object.promotion_block_reason.unwrap_or_else(|| {
+ "the selected external object cannot be represented by an editable workspace geometry"
+ .into()
+ }))
+ })?;
+ let vector_layer = self.active_vector_layer;
+ let source_object_id = object.source_object_id;
+ let id = self.edit("Promote source object", move |document| {
+ apply_external_promotion(
+ document,
+ vector_layer,
+ layer_id,
+ source_object_id,
+ &class_id,
+ promotion,
+ )
+ })?;
+ if self.document.segment(id).is_some() {
+ self.active_segmentation_layer = self
+ .document
+ .segmentation_layers()
+ .iter()
+ .find(|layer| {
+ layer
+ .segments()
+ .iter()
+ .any(|segment| segment.object_id() == id)
+ })
+ .map(|layer| layer.id());
+ }
+ self.select_only(id);
+ Ok(id)
+ }
+
+ pub(in crate::app) fn make_external_layer_editable(
+ &mut self,
+ layer_id: Uuid,
+ ) -> ViewerResult> {
+ let objects = self.prepare_external_objects(layer_id)?;
+ if objects.is_empty() {
+ return Err(ViewerError::InvalidInput(
+ "the external layer contains no convertible objects".into(),
+ ));
+ }
+ if objects
+ .iter()
+ .any(|object| self.source_object_was_promoted(layer_id, &object.source_object_id))
+ {
+ return Err(ViewerError::InvalidInput(
+ "the external layer already contains promoted objects; promote the remaining objects individually".into(),
+ ));
+ }
+ let prepared = objects
+ .into_iter()
+ .map(|object| {
+ let class_id = self.external_mapping_target(layer_id, &object.class_key)?;
+ let promotion = object.promotion.ok_or_else(|| {
+ ViewerError::Unsupported(object.promotion_block_reason.unwrap_or_else(|| {
+ format!(
+ "source object {} cannot be converted losslessly",
+ object.source_object_id
+ )
+ }))
+ })?;
+ Ok((object.source_object_id, class_id, promotion))
+ })
+ .collect::>>()?;
+ let vector_layer = self.active_vector_layer;
+ let ids = self.edit("Make external layer editable", move |document| {
+ prepared
+ .into_iter()
+ .map(|(source_object_id, class_id, promotion)| {
+ apply_external_promotion(
+ document,
+ vector_layer,
+ layer_id,
+ source_object_id,
+ &class_id,
+ promotion,
+ )
+ })
+ .collect::>>()
+ })?;
+ self.selection = ids.iter().copied().collect();
+ if ids.iter().any(|id| self.document.segment(*id).is_some()) {
+ self.active_segmentation_layer = self
+ .document
+ .segmentation_layers()
+ .iter()
+ .find(|layer| {
+ layer
+ .segments()
+ .iter()
+ .any(|segment| ids.contains(&segment.object_id()))
+ })
+ .map(|layer| layer.id());
+ }
+ Ok(ids)
+ }
+
+ fn external_mapping_target(
+ &self,
+ layer_id: Uuid,
+ source_class_key: &str,
+ ) -> ViewerResult {
+ self.document
+ .external_layers()
+ .iter()
+ .find(|layer| layer.id() == layer_id)
+ .and_then(|layer| layer.class_mappings().get(source_class_key))
+ .cloned()
+ .ok_or_else(|| {
+ ViewerError::InvalidInput(
+ "every source class needs an explicit mapping before promotion".into(),
+ )
+ })
+ }
+
+ fn prepare_external_objects(
+ &self,
+ layer_id: Uuid,
+ ) -> ViewerResult> {
+ if !self
+ .document
+ .external_layers()
+ .iter()
+ .any(|layer| layer.id() == layer_id)
+ {
+ return Err(ViewerError::InvalidInput(
+ "the external source layer does not exist".into(),
+ ));
+ }
+ match self.external_payloads.get(&layer_id) {
+ Some(ExternalLayerPayload::Annotation(document)) => {
+ prepare_annotation_objects(document)
+ }
+ Some(ExternalLayerPayload::ProfiledGeoJson(session)) => session
+ .editable_ann()
+ .map_or_else(|| Ok(Vec::new()), prepare_annotation_objects),
+ Some(ExternalLayerPayload::Segmentation { document, .. }) => {
+ prepare_segmentation_objects(document)
+ }
+ Some(ExternalLayerPayload::Report(session)) => {
+ prepare_report_objects(session.document())
+ }
+ Some(ExternalLayerPayload::Heatmap { .. }) => Ok(Vec::new()),
+ None => Ok(Vec::new()),
+ }
+ }
+
+ fn source_object_was_promoted(&self, layer_id: Uuid, source_object_id: &str) -> bool {
+ self.document
+ .vector_findings()
+ .map(|finding| finding.provenance())
+ .chain(self.document.segments().map(|segment| segment.provenance()))
+ .chain(
+ self.document
+ .measurements()
+ .iter()
+ .map(|measurement| measurement.provenance()),
+ )
+ .any(|provenance| {
+ matches!(
+ provenance,
+ WorkspaceObjectProvenance::Promoted {
+ source_layer_id,
+ source_object_id: promoted_id,
+ } if *source_layer_id == layer_id && promoted_id == source_object_id
+ )
+ })
+ }
+}
+
+fn annotation_group_geometry(
+ group: &dicom_viewer_core::AnnotationGroup,
+) -> Option {
+ match group.geometry() {
+ AnnotationGeometry::Points(_) => Some(AnnotationClassGeometry::Point),
+ AnnotationGeometry::Polygons(_) => Some(AnnotationClassGeometry::Region),
+ AnnotationGeometry::ReadOnly { graphic_type, .. } => match graphic_type {
+ dicom_viewer_core::AnnotationGraphicType::Point => Some(AnnotationClassGeometry::Point),
+ dicom_viewer_core::AnnotationGraphicType::Polygon => {
+ Some(AnnotationClassGeometry::Region)
+ }
+ dicom_viewer_core::AnnotationGraphicType::Polyline
+ | dicom_viewer_core::AnnotationGraphicType::Ellipse
+ | dicom_viewer_core::AnnotationGraphicType::Rectangle => None,
+ },
+ }
+}
+
+fn prepare_annotation_objects(
+ document: &AnnotationDocument,
+) -> ViewerResult> {
+ let mut objects = Vec::new();
+ for group in document.groups() {
+ let Some(geometry) = annotation_group_geometry(group) else {
+ continue;
+ };
+ let class_key = annotation_class_concept_key(
+ geometry,
+ group.category(),
+ group.property_type(),
+ group.property_type_modifiers(),
+ )
+ .to_string();
+ let (source_frame, promotion_block_reason) = match SourceFrameContext::from_ann_group(group)
+ {
+ Ok(source_frame) => (Some(source_frame), None),
+ Err(ViewerError::Unsupported(reason) | ViewerError::InvalidInput(reason)) => {
+ (None, Some(reason))
+ }
+ Err(error) => (None, Some(error.to_string())),
+ };
+ match group.geometry() {
+ AnnotationGeometry::Points(points) => {
+ for (index, point) in points.iter().copied().enumerate() {
+ let point = document.canonical_level0_pixel(
+ document.source(),
+ point.x,
+ point.y,
+ None,
+ )?;
+ objects.push(PreparedExternalObject {
+ source_object_id: format!("{}:{}", group.uid(), index + 1),
+ label: group.label().to_owned(),
+ class_key: class_key.clone(),
+ geometry: Some(geometry),
+ promotion: source_frame.clone().map(|source_frame| {
+ PreparedExternalPromotion::Vector {
+ geometry: VectorFindingGeometry::Point(point),
+ tracking: None,
+ source_frame,
+ }
+ }),
+ promotion_block_reason: promotion_block_reason.clone(),
+ });
+ }
+ }
+ AnnotationGeometry::Polygons(polygons) => {
+ for (index, polygon) in polygons.iter().enumerate() {
+ let polygon = polygon
+ .iter()
+ .map(|point| {
+ document
+ .canonical_level0_pixel(document.source(), point.x, point.y, None)
+ .map_err(dicom_viewer_core::ViewerError::from)
+ })
+ .collect::>>()?;
+ objects.push(PreparedExternalObject {
+ source_object_id: format!("{}:{}", group.uid(), index + 1),
+ label: group.label().to_owned(),
+ class_key: class_key.clone(),
+ geometry: Some(geometry),
+ promotion: source_frame.clone().map(|source_frame| {
+ PreparedExternalPromotion::Vector {
+ geometry: VectorFindingGeometry::regions(vec![polygon]),
+ tracking: None,
+ source_frame,
+ }
+ }),
+ promotion_block_reason: promotion_block_reason.clone(),
+ });
+ }
+ }
+ AnnotationGeometry::ReadOnly { .. } => {
+ for index in 0..group.annotation_count() {
+ objects.push(PreparedExternalObject {
+ source_object_id: format!("{}:{}", group.uid(), index + 1),
+ label: group.label().to_owned(),
+ class_key: class_key.clone(),
+ geometry: Some(geometry),
+ promotion: None,
+ promotion_block_reason: Some(
+ "the ANN graphic type is viewable but has no editable workspace geometry"
+ .into(),
+ ),
+ });
+ }
+ }
+ }
+ }
+ Ok(objects)
+}
+
+fn prepare_segmentation_objects(
+ document: &SegmentationDocument,
+) -> ViewerResult> {
+ let mut polygons = BTreeMap::>>::new();
+ if document.editable() {
+ for run in document.binary_runs()? {
+ let x0 = f64::from(run.column_start());
+ let x1 = f64::from(run.column_start().saturating_add(run.length()));
+ let y0 = f64::from(run.row());
+ let y1 = y0 + 1.0;
+ polygons.entry(run.segment_number()).or_default().push(vec![
+ Point2::new(x0, y0),
+ Point2::new(x1, y0),
+ Point2::new(x1, y1),
+ Point2::new(x0, y1),
+ ]);
+ }
+ }
+ Ok(document
+ .segments()
+ .iter()
+ .enumerate()
+ .map(|(index, segment)| {
+ let number = segment
+ .source_segment_number()
+ .unwrap_or_else(|| u16::try_from(index + 1).unwrap_or(u16::MAX));
+ let class_key = annotation_class_concept_key(
+ AnnotationClassGeometry::Region,
+ segment.category(),
+ segment.property_type(),
+ segment.property_type_modifiers(),
+ )
+ .to_string();
+ let tracking = segment
+ .tracking_id()
+ .zip(segment.tracking_uid())
+ .and_then(|(id, uid)| TrackingIdentity::new(id, uid).ok());
+ let primitives = polygons.remove(&number).map(|polygons| {
+ polygons
+ .into_iter()
+ .map(|polygon| SegmentationPrimitive::polygon(SegmentOperation::Add, polygon))
+ .collect::>()
+ });
+ PreparedExternalObject {
+ source_object_id: format!("segment:{number}"),
+ label: segment.label().to_owned(),
+ class_key,
+ geometry: Some(AnnotationClassGeometry::Region),
+ promotion: primitives.filter(|primitives| !primitives.is_empty()).map(
+ |primitives| PreparedExternalPromotion::Segment {
+ primitives,
+ tracking,
+ source_frame: SourceFrameContext::default(),
+ },
+ ),
+ promotion_block_reason: (!document.editable())
+ .then(|| "the SEG object is viewable but is not losslessly editable".into()),
+ }
+ })
+ .collect())
+}
+
+fn prepare_report_objects(
+ document: &StructuredReportDocument,
+) -> ViewerResult> {
+ let mut objects = Vec::new();
+ for group in document.groups() {
+ let class_key = annotation_class_concept_key(
+ AnnotationClassGeometry::Region,
+ group.finding_category(),
+ group.finding_type(),
+ &[],
+ )
+ .to_string();
+ let source_tracking = TrackingIdentity::new(group.tracking_id(), group.tracking_uid()).ok();
+ for (measurement_index, measurement) in group.measurements().iter().enumerate() {
+ for (coordinate_index, coordinates) in measurement.coordinates().iter().enumerate() {
+ if coordinates.graphic() != dicom_viewer_core::CoordinateGraphic::Polyline
+ || coordinates.points().len() != 2
+ {
+ continue;
+ }
+ let source_object_id = format!(
+ "{}:{}:{}",
+ group.tracking_uid(),
+ measurement_index + 1,
+ coordinate_index + 1
+ );
+ let physical_length_mm = measurement_length_mm(measurement);
+ let endpoints = coordinates
+ .points()
+ .iter()
+ .map(|point| {
+ document
+ .source()
+ .slide_coordinate_to_pixel3(point.x, point.y, point.z)
+ .map_err(dicom_viewer_core::ViewerError::from)
+ })
+ .collect::>>()?;
+ let promotion = physical_length_mm.map(|physical_length_mm| {
+ PreparedExternalPromotion::Measurement {
+ endpoints: [endpoints[0], endpoints[1]],
+ physical_length_mm,
+ tracking: source_tracking.clone(),
+ source_frame: SourceFrameContext::default(),
+ }
+ });
+ objects.push(PreparedExternalObject {
+ source_object_id,
+ label: group.finding_type().meaning().to_owned(),
+ class_key: class_key.clone(),
+ geometry: Some(AnnotationClassGeometry::Region),
+ promotion,
+ promotion_block_reason: physical_length_mm
+ .is_none()
+ .then(|| "the SR measurement has no supported physical length".into()),
+ });
+ }
+ }
+ }
+ Ok(objects)
+}
+
+fn measurement_length_mm(
+ measurement: &dicom_viewer_core::StructuredReportMeasurement,
+) -> Option {
+ if measurement.concept().scheme() != "SCT"
+ || measurement.concept().value() != "410668003"
+ || measurement.unit().scheme() != "UCUM"
+ || !measurement.value().is_finite()
+ || measurement.value() <= 0.0
+ {
+ return None;
+ }
+ match measurement.unit().value() {
+ "mm" => Some(measurement.value()),
+ "um" | "µm" => Some(measurement.value() / 1_000.0),
+ _ => None,
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace/geometry.rs b/apps/dicom-viewer/src/app/workspace/geometry.rs
new file mode 100644
index 0000000..01ba93b
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace/geometry.rs
@@ -0,0 +1,295 @@
+use super::*;
+
+impl WorkspaceRuntime {
+ pub(in crate::app) fn begin_handle_drag(&mut self, point: Point2, tolerance: f64) -> bool {
+ let tolerance_squared = tolerance * tolerance;
+ let mut closest: Option<(f64, Uuid, EditableHandle)> = None;
+ for id in self.selection.iter().copied() {
+ if self.object_locked(id) {
+ continue;
+ }
+ if let Some(finding) = self.document.finding(id) {
+ match finding.geometry() {
+ VectorFindingGeometry::Point(candidate) => update_handle_candidate(
+ &mut closest,
+ point,
+ *candidate,
+ tolerance_squared,
+ id,
+ EditableHandle::PointFinding,
+ ),
+ VectorFindingGeometry::Regions(components) => {
+ for (component_index, component) in components.iter().enumerate() {
+ for (vertex_index, candidate) in component.iter().copied().enumerate() {
+ update_handle_candidate(
+ &mut closest,
+ point,
+ candidate,
+ tolerance_squared,
+ id,
+ EditableHandle::PolygonVertex {
+ component_index,
+ vertex_index,
+ },
+ );
+ }
+ }
+ }
+ }
+ } else if let Some(segment) = self.document.segment(id) {
+ for (primitive_index, primitive) in segment.primitives().iter().enumerate() {
+ let points = match primitive.geometry() {
+ SegmentationPrimitiveGeometry::Polygon { points } => points.as_ref(),
+ SegmentationPrimitiveGeometry::Brush { centerline, .. } => {
+ centerline.as_ref()
+ }
+ };
+ for (point_index, candidate) in points.iter().copied().enumerate() {
+ update_handle_candidate(
+ &mut closest,
+ point,
+ candidate,
+ tolerance_squared,
+ id,
+ EditableHandle::SegmentPrimitivePoint {
+ primitive_index,
+ point_index,
+ },
+ );
+ }
+ }
+ } else if let Some(measurement) = self.document.measurement(id) {
+ for (endpoint_index, candidate) in measurement.endpoints().into_iter().enumerate() {
+ update_handle_candidate(
+ &mut closest,
+ point,
+ candidate,
+ tolerance_squared,
+ id,
+ EditableHandle::MeasurementEndpoint { endpoint_index },
+ );
+ }
+ }
+ }
+ let Some((_, object_id, handle)) = closest else {
+ return false;
+ };
+ self.handle_drag = Some(HandleDrag {
+ object_id,
+ handle,
+ before: Arc::clone(&self.document),
+ });
+ true
+ }
+
+ pub(in crate::app) fn update_handle_drag(
+ &mut self,
+ point: Point2,
+ physical_length_mm: impl FnOnce(Point2, Point2) -> Option,
+ ) -> ViewerResult<()> {
+ let Some(drag) = &self.handle_drag else {
+ return Ok(());
+ };
+ let object_id = drag.object_id;
+ let handle = drag.handle;
+ let mut candidate = (*self.document).clone();
+ match handle {
+ EditableHandle::PointFinding => {
+ candidate
+ .replace_vector_geometry(object_id, VectorFindingGeometry::Point(point))?;
+ }
+ EditableHandle::PolygonVertex {
+ component_index,
+ vertex_index,
+ } => {
+ candidate.move_vector_vertex(object_id, component_index, vertex_index, point)?;
+ }
+ EditableHandle::MeasurementEndpoint { endpoint_index } => {
+ let mut endpoints = candidate
+ .measurement(object_id)
+ .ok_or_else(|| {
+ ViewerError::InvalidInput("the dragged measurement no longer exists".into())
+ })?
+ .endpoints();
+ endpoints[endpoint_index] = point;
+ let length = physical_length_mm(endpoints[0], endpoints[1]);
+ candidate.set_measurement_endpoints(object_id, endpoints, length)?;
+ }
+ EditableHandle::SegmentPrimitivePoint {
+ primitive_index,
+ point_index,
+ } => {
+ candidate.move_segment_primitive_point(
+ object_id,
+ primitive_index,
+ point_index,
+ point,
+ )?;
+ }
+ }
+ candidate.validate()?;
+ self.document = Arc::new(candidate);
+ self.invalidate_spatial_index();
+ Ok(())
+ }
+
+ pub(in crate::app) fn finish_handle_drag(&mut self) -> bool {
+ let Some(drag) = self.handle_drag.take() else {
+ return false;
+ };
+ if drag.before.revision() == self.document.revision() {
+ return false;
+ }
+ self.history.record(
+ "Move geometry handle",
+ drag.before,
+ Arc::clone(&self.document),
+ );
+ true
+ }
+
+ pub(in crate::app) fn cancel_handle_drag(&mut self) -> bool {
+ let Some(drag) = self.handle_drag.take() else {
+ return false;
+ };
+ self.document = drag.before;
+ self.invalidate_spatial_index();
+ true
+ }
+
+ #[must_use]
+ pub(in crate::app) const fn handle_drag_active(&self) -> bool {
+ self.handle_drag.is_some()
+ }
+
+ pub(in crate::app) fn refresh_spatial_index(&mut self) -> ViewerResult<()> {
+ if self.spatial_revision != self.document.revision() {
+ self.spatial_index = WorkspaceSpatialIndex::build(&self.document)?;
+ self.spatial_revision = self.document.revision();
+ }
+ Ok(())
+ }
+
+ #[must_use]
+ pub(in crate::app) fn spatial_index(&self) -> &WorkspaceSpatialIndex {
+ &self.spatial_index
+ }
+
+ #[must_use]
+ pub(in crate::app) fn hit_test(&self, point: Point2, tolerance: f64) -> Option {
+ let query = [
+ point.x - tolerance,
+ point.y - tolerance,
+ point.x + tolerance,
+ point.y + tolerance,
+ ];
+ self.spatial_index
+ .query(query, 256)
+ .into_iter()
+ .filter_map(|id| {
+ object_distance(self.document(), id, point).map(|distance| (id, distance))
+ })
+ .filter(|(_, distance)| *distance <= tolerance)
+ .min_by(|left, right| left.1.total_cmp(&right.1))
+ .map(|(id, _)| id)
+ }
+
+ #[must_use]
+ pub(in crate::app) fn object_bounds(&self, id: Uuid) -> Option<[f64; 4]> {
+ self.spatial_index.bounds(id)
+ }
+
+ pub(in crate::app) fn invalidate_spatial_index(&mut self) {
+ self.spatial_revision = u64::MAX;
+ }
+}
+
+fn object_distance(document: &WorkspaceDocument, id: Uuid, point: Point2) -> Option {
+ if let Some(finding) = document.finding(id) {
+ return Some(match finding.geometry() {
+ dicom_viewer_core::VectorFindingGeometry::Point(candidate) => {
+ (candidate.x - point.x).hypot(candidate.y - point.y)
+ }
+ dicom_viewer_core::VectorFindingGeometry::Regions(components) => components
+ .iter()
+ .map(|component| polygon_distance(component, point))
+ .fold(f64::INFINITY, f64::min),
+ });
+ }
+ if let Some(segment) = document.segment(id) {
+ let geometry = document.composite_segment(segment.object_id()).ok()?;
+ return geometry
+ .components()
+ .iter()
+ .map(|component| {
+ let inside = dicom_viewer_core::polygon_contains_point(component.exterior(), point)
+ && !component
+ .holes()
+ .iter()
+ .any(|hole| dicom_viewer_core::polygon_contains_point(hole, point));
+ if inside {
+ 0.0
+ } else {
+ std::iter::once(component.exterior())
+ .chain(component.holes().iter().map(Vec::as_slice))
+ .map(|ring| ring_edge_distance(ring, point))
+ .fold(f64::INFINITY, f64::min)
+ }
+ })
+ .min_by(f64::total_cmp);
+ }
+ let measurement = document.measurement(id)?;
+ let endpoints = measurement.endpoints();
+ Some(segment_distance(endpoints[0], endpoints[1], point))
+}
+
+fn update_handle_candidate(
+ closest: &mut Option<(f64, Uuid, EditableHandle)>,
+ target: Point2,
+ candidate: Point2,
+ tolerance_squared: f64,
+ object_id: Uuid,
+ handle: EditableHandle,
+) {
+ let dx = candidate.x - target.x;
+ let dy = candidate.y - target.y;
+ let distance_squared = dx * dx + dy * dy;
+ if distance_squared > tolerance_squared
+ || closest
+ .as_ref()
+ .is_some_and(|(best, _, _)| *best <= distance_squared)
+ {
+ return;
+ }
+ *closest = Some((distance_squared, object_id, handle));
+}
+
+fn polygon_distance(polygon: &[Point2], point: Point2) -> f64 {
+ if dicom_viewer_core::polygon_contains_point(polygon, point) {
+ 0.0
+ } else {
+ ring_edge_distance(polygon, point)
+ }
+}
+
+fn ring_edge_distance(points: &[Point2], point: Point2) -> f64 {
+ points
+ .iter()
+ .zip(points.iter().cycle().skip(1))
+ .take(points.len())
+ .map(|(start, end)| segment_distance(*start, *end, point))
+ .fold(f64::INFINITY, f64::min)
+}
+
+fn segment_distance(start: Point2, end: Point2, point: Point2) -> f64 {
+ let dx = end.x - start.x;
+ let dy = end.y - start.y;
+ let length_squared = dx * dx + dy * dy;
+ if length_squared <= f64::EPSILON {
+ return (point.x - start.x).hypot(point.y - start.y);
+ }
+ let fraction =
+ (((point.x - start.x) * dx + (point.y - start.y) * dy) / length_squared).clamp(0.0, 1.0);
+ let closest = Point2::new(start.x + fraction * dx, start.y + fraction * dy);
+ (point.x - closest.x).hypot(point.y - closest.y)
+}
diff --git a/apps/dicom-viewer/src/app/workspace/selection.rs b/apps/dicom-viewer/src/app/workspace/selection.rs
new file mode 100644
index 0000000..8ea21fa
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace/selection.rs
@@ -0,0 +1,132 @@
+use super::*;
+
+impl WorkspaceRuntime {
+ #[must_use]
+ pub(in crate::app) fn selection(&self) -> &HashSet {
+ &self.selection
+ }
+
+ pub(in crate::app) fn select_only(&mut self, object_id: Uuid) {
+ self.selection.clear();
+ self.selection.insert(object_id);
+ }
+
+ pub(in crate::app) fn toggle_selection(&mut self, object_id: Uuid) {
+ if !self.selection.remove(&object_id) {
+ self.selection.insert(object_id);
+ }
+ }
+
+ pub(in crate::app) fn clear_selection(&mut self) {
+ self.selection.clear();
+ }
+
+ pub(in crate::app) fn selected_segment(&self) -> Option {
+ self.selection.iter().copied().find(|id| {
+ self.document.object(*id).is_some_and(|object| {
+ object.geometry_kind()
+ == dicom_viewer_core::WorkspaceObjectGeometryKind::Segmentation
+ })
+ })
+ }
+
+ pub(in crate::app) fn delete_selection(&mut self) -> ViewerResult {
+ let ids = self.selection.iter().copied().collect::>();
+ if ids.is_empty() {
+ return Ok(0);
+ }
+ self.ensure_objects_editable(&ids)?;
+ let deleted = self.edit("Delete selection", |document| {
+ let mut count = 0;
+ for id in &ids {
+ count += usize::from(document.delete_object(*id)?);
+ }
+ Ok(count)
+ })?;
+ self.clear_selection();
+ Ok(deleted)
+ }
+
+ pub(in crate::app) fn reclassify_selection(&mut self, class_id: &str) -> ViewerResult {
+ let ids = self.selection.iter().copied().collect::>();
+ if ids.is_empty() {
+ return Ok(0);
+ }
+ self.ensure_objects_editable(&ids)?;
+ self.edit("Reclassify selection", |document| {
+ for id in &ids {
+ document.reclassify_object(*id, class_id)?;
+ }
+ Ok(ids.len())
+ })
+ }
+
+ pub(in crate::app) fn set_selected_name(&mut self, name: Option<&str>) -> ViewerResult<()> {
+ let id = self.single_selection()?;
+ self.ensure_objects_editable(&[id])?;
+ self.edit("Rename finding", |document| {
+ document.set_object_name(id, name)
+ })
+ }
+
+ pub(in crate::app) fn set_selected_comment(
+ &mut self,
+ comment: Option<&str>,
+ ) -> ViewerResult<()> {
+ let id = self.single_selection()?;
+ self.ensure_objects_editable(&[id])?;
+ self.edit("Edit finding comment", |document| {
+ document.set_object_comment(id, comment)
+ })
+ }
+
+ pub(in crate::app) fn set_selected_finding_site(
+ &mut self,
+ site: Option<&dicom_viewer_core::DicomCode>,
+ ) -> ViewerResult<()> {
+ let id = self.single_selection()?;
+ self.ensure_objects_editable(&[id])?;
+ self.edit("Set finding site", |document| {
+ document.set_object_finding_site(id, site)
+ })
+ }
+
+ pub(in crate::app) fn single_selection(&self) -> ViewerResult {
+ if self.selection.len() != 1 {
+ return Err(ViewerError::InvalidInput(
+ "select exactly one tracked object".into(),
+ ));
+ }
+ Ok(*self
+ .selection
+ .iter()
+ .next()
+ .expect("one selected object exists"))
+ }
+
+ pub(in crate::app) fn ensure_layer_editable(&self, layer_id: Uuid) -> ViewerResult<()> {
+ if self.document.presentation().layer(layer_id).locked {
+ return Err(ViewerError::InvalidInput(
+ "the active annotation layer is locked".into(),
+ ));
+ }
+ Ok(())
+ }
+
+ pub(in crate::app) fn ensure_objects_editable(&self, object_ids: &[Uuid]) -> ViewerResult<()> {
+ if object_ids.iter().copied().any(|id| self.object_locked(id)) {
+ return Err(ViewerError::InvalidInput(
+ "the selection contains an object on a locked layer".into(),
+ ));
+ }
+ Ok(())
+ }
+
+ pub(in crate::app) fn object_locked(&self, object_id: Uuid) -> bool {
+ self.document
+ .object_layer_id(object_id)
+ .ok()
+ .flatten()
+ .is_some_and(|layer_id| self.document.presentation().layer(layer_id).locked)
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace/tests.rs b/apps/dicom-viewer/src/app/workspace/tests.rs
index f38b643..8251e7a 100644
--- a/apps/dicom-viewer/src/app/workspace/tests.rs
+++ b/apps/dicom-viewer/src/app/workspace/tests.rs
@@ -28,6 +28,14 @@ fn square(x: f64) -> VectorFindingGeometry {
]])
}
+#[test]
+fn a_new_workspace_starts_in_pan_mode() {
+ let runtime =
+ WorkspaceRuntime::new(source(), AnnotationScheme::general_pathology_v1()).unwrap();
+
+ assert_eq!(runtime.active_tool(), ActiveTool::Pan);
+}
+
#[test]
fn history_undoes_and_redoes_whole_commands_and_new_edits_invalidate_redo() {
let mut runtime = WorkspaceRuntime::with_history_limits(
@@ -508,6 +516,58 @@ fn imported_ann_requires_explicit_complete_mapping_before_atomic_conversion() {
.is_err());
}
+#[test]
+fn imported_multi_optical_ann_remains_viewable_with_precise_promotion_block_reason() {
+ let directory = tempfile::tempdir().unwrap();
+ let source_path = directory.path().join("source.dcm");
+ crate::app::tests::write_source_wsi_with_optical_paths(&source_path, &["A", "B"]);
+ let context = DicomAnnotationContext::from_source(&source_path).unwrap();
+ let scheme = AnnotationScheme::general_pathology_v1();
+ let neoplasm = scheme.class("neoplasm").unwrap();
+ let group = AnnotationGroup::polygons(
+ "Multi-path finding",
+ neoplasm.category().clone(),
+ neoplasm.property_type().clone(),
+ neoplasm.recommended_display_cielab(),
+ vec![vec![
+ Point2::new(1.0, 1.0),
+ Point2::new(6.0, 1.0),
+ Point2::new(6.0, 6.0),
+ Point2::new(1.0, 6.0),
+ ]],
+ )
+ .unwrap()
+ .with_referenced_optical_paths(vec!["A".into(), "B".into()])
+ .unwrap();
+ let source_object_id = format!("{}:1", group.uid());
+ let ann = AnnotationDocument::new(context, vec![group]).unwrap();
+ let mut runtime = WorkspaceRuntime::new(
+ ViewerSourceIdentity::new(9, 0, 0, 0, 0, 0, (16, 16)),
+ scheme,
+ )
+ .unwrap();
+ let external = runtime
+ .add_external_annotation("Imported ANN", Some(source_path), ann)
+ .unwrap();
+ let class = runtime.external_classes(external).unwrap().remove(0);
+ runtime
+ .set_external_class_mapping(external, &class.key, "neoplasm")
+ .unwrap();
+
+ let object = runtime.external_objects(external).unwrap().remove(0);
+ assert_eq!(object.source_object_id, source_object_id);
+ assert!(!object.promotable);
+ assert!(!object.promoted);
+ let error = runtime
+ .promote_external_object(external, &source_object_id)
+ .unwrap_err();
+ assert_eq!(
+ error.to_string(),
+ "unsupported input: ANN group references 2 optical paths and remains read-only because promotion would lose applicability"
+ );
+ assert_eq!(runtime.document().object_count(), 0);
+}
+
#[test]
fn external_layer_removal_is_undoable_and_retains_the_shared_payload() {
let directory = tempfile::tempdir().unwrap();
diff --git a/apps/dicom-viewer/src/app/workspace/tools.rs b/apps/dicom-viewer/src/app/workspace/tools.rs
new file mode 100644
index 0000000..a6c56b6
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace/tools.rs
@@ -0,0 +1,453 @@
+use super::*;
+
+impl WorkspaceRuntime {
+ #[must_use]
+ pub(in crate::app) const fn active_tool(&self) -> ActiveTool {
+ self.active_tool
+ }
+
+ #[cfg(test)]
+ pub(in crate::app) fn set_active_tool(&mut self, tool: ActiveTool) -> ViewerResult<()> {
+ match self.request_tool(tool) {
+ ToolTransitionOutcome::Applied => Ok(()),
+ ToolTransitionOutcome::BlockedByDraft => Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before switching tools".into(),
+ )),
+ }
+ }
+
+ pub(in crate::app) fn request_tool(&mut self, tool: ActiveTool) -> ToolTransitionOutcome {
+ if self.active_tool == tool {
+ return ToolTransitionOutcome::Applied;
+ }
+ if self.draft.is_some() {
+ self.pending_tool = Some(tool);
+ return ToolTransitionOutcome::BlockedByDraft;
+ }
+ self.active_tool = tool;
+ self.draft_undo.clear();
+ if matches!(tool, ActiveTool::Point | ActiveTool::Ruler) {
+ self.editing_representation = EditingRepresentation::Vector;
+ }
+ self.pending_tool = None;
+ ToolTransitionOutcome::Applied
+ }
+
+ pub(in crate::app) fn resolve_draft_transition(
+ &mut self,
+ resolution: DraftResolution,
+ ) -> ViewerResult<()> {
+ match resolution {
+ DraftResolution::Resume => {
+ self.pending_tool = None;
+ }
+ DraftResolution::Finish => {
+ self.finish_draft()?;
+ if let Some(tool) = self.pending_tool.take() {
+ self.active_tool = tool;
+ }
+ }
+ DraftResolution::Discard => {
+ self.draft = None;
+ self.draft_undo.clear();
+ if let Some(tool) = self.pending_tool.take() {
+ self.active_tool = tool;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ pub(in crate::app) fn finish_draft(&mut self) -> ViewerResult {
+ let draft = self
+ .draft
+ .clone()
+ .ok_or_else(|| ViewerError::InvalidInput("there is no polygon draft".into()))?;
+ let target_layer = match draft.target {
+ DraftTarget::Vector { layer_id } | DraftTarget::Segment { layer_id, .. } => layer_id,
+ };
+ self.ensure_layer_editable(target_layer)?;
+ let result = match draft.target {
+ DraftTarget::Vector { layer_id } => self.edit("Add polygon finding", |document| {
+ document.add_vector_finding(
+ layer_id,
+ &draft.class_id,
+ dicom_viewer_core::VectorFindingGeometry::regions(vec![draft.points]),
+ )
+ })?,
+ DraftTarget::Segment {
+ layer_id,
+ segment_id,
+ operation,
+ } => {
+ let primitive = SegmentationPrimitive::polygon(operation, draft.points);
+ if let Some(segment_id) = segment_id {
+ self.edit("Edit segment", |document| {
+ document.apply_segment_primitive(segment_id, primitive)?;
+ Ok(segment_id)
+ })?
+ } else {
+ self.edit("Add segment", |document| {
+ document.add_segment(layer_id, &draft.class_id, primitive)
+ })?
+ }
+ }
+ };
+ self.draft = None;
+ self.select_only(result);
+ Ok(result)
+ }
+
+ #[must_use]
+ pub(in crate::app) fn draft(&self) -> Option<&DraftInteraction> {
+ self.draft.as_ref()
+ }
+
+ pub(in crate::app) fn set_draft(&mut self, draft: DraftInteraction) {
+ self.draft = Some(draft);
+ self.draft_undo.clear();
+ }
+
+ pub(in crate::app) fn add_polygon_point(&mut self, point: Point2) -> ViewerResult<()> {
+ self.draft_undo.clear();
+ if let Some(draft) = &mut self.draft {
+ draft.push_point(point);
+ return Ok(());
+ }
+ let draft = match self.editing_representation {
+ EditingRepresentation::Vector => {
+ self.ensure_layer_editable(self.active_vector_layer)?;
+ DraftInteraction::vector_polygon(
+ self.active_vector_layer,
+ self.region_class_id.clone(),
+ vec![point],
+ )
+ }
+ EditingRepresentation::Segmentation => {
+ let layer_id = self.ensure_segmentation_layer()?;
+ self.ensure_layer_editable(layer_id)?;
+ let segment_id = self.selected_segment();
+ if self.segment_operation == SegmentOperation::Erase && segment_id.is_none() {
+ return Err(ViewerError::InvalidInput(
+ "select a segment before using Erase".into(),
+ ));
+ }
+ DraftInteraction::segment_polygon(
+ layer_id,
+ segment_id,
+ self.segment_operation,
+ self.region_class_id.clone(),
+ vec![point],
+ )
+ }
+ };
+ self.draft = Some(draft);
+ Ok(())
+ }
+
+ pub(in crate::app) fn add_point_finding(&mut self, point: Point2) -> ViewerResult {
+ let layer = self.active_vector_layer;
+ self.ensure_layer_editable(layer)?;
+ let class_id = self.point_class_id.clone();
+ let id = self.edit("Add point finding", |document| {
+ document.add_vector_finding(
+ layer,
+ &class_id,
+ dicom_viewer_core::VectorFindingGeometry::Point(point),
+ )
+ })?;
+ self.select_only(id);
+ Ok(id)
+ }
+
+ pub(in crate::app) fn begin_brush_stroke_with_operation(
+ &mut self,
+ point: Point2,
+ operation: SegmentOperation,
+ ) -> ViewerResult<()> {
+ let layer = self.ensure_segmentation_layer()?;
+ self.ensure_layer_editable(layer)?;
+ if operation == SegmentOperation::Erase && self.selected_segment().is_none() {
+ return Err(ViewerError::InvalidInput(
+ "select a segment before using Erase".into(),
+ ));
+ }
+ self.brush_stroke = Some(vec![point]);
+ self.brush_operation = Some(operation);
+ Ok(())
+ }
+
+ pub(in crate::app) fn extend_brush_stroke(&mut self, point: Point2) {
+ if let Some(stroke) = &mut self.brush_stroke {
+ let minimum_step = (self.brush_diameter * 0.08).max(0.5);
+ if stroke.last().is_none_or(|last| {
+ let dx = point.x - last.x;
+ let dy = point.y - last.y;
+ dx.hypot(dy) >= minimum_step
+ }) {
+ stroke.push(point);
+ }
+ }
+ }
+
+ pub(in crate::app) fn finish_brush_stroke(&mut self) -> ViewerResult> {
+ let Some(centerline) = self.brush_stroke.take() else {
+ return Ok(None);
+ };
+ let layer_id = self.ensure_segmentation_layer()?;
+ self.ensure_layer_editable(layer_id)?;
+ let operation = self
+ .brush_operation
+ .take()
+ .unwrap_or(self.segment_operation);
+ let segment_id = self.selected_segment();
+ let primitive = SegmentationPrimitive::brush(operation, centerline, self.brush_diameter);
+ let id = if let Some(segment_id) = segment_id {
+ let outcome = self.edit("Brush stroke", |document| {
+ document.apply_segment_primitive(segment_id, primitive)
+ })?;
+ if outcome == dicom_viewer_core::SegmentEditOutcome::NoIntersection {
+ return Ok(None);
+ }
+ segment_id
+ } else {
+ let class_id = self.region_class_id.clone();
+ self.edit("Add segment", |document| {
+ document.add_segment(layer_id, &class_id, primitive)
+ })?
+ };
+ self.select_only(id);
+ Ok(Some(id))
+ }
+
+ pub(in crate::app) fn cancel_pointer_interaction(&mut self) {
+ self.brush_stroke = None;
+ self.brush_operation = None;
+ }
+
+ #[must_use]
+ pub(in crate::app) fn brush_stroke(&self) -> Option<&[Point2]> {
+ self.brush_stroke.as_deref()
+ }
+
+ pub(in crate::app) fn place_ruler_point(
+ &mut self,
+ point: Point2,
+ physical_length_mm: impl FnOnce(Point2, Point2) -> Option,
+ ) -> ViewerResult> {
+ let Some(start) = self.ruler_start.take() else {
+ self.ruler_start = Some(point);
+ return Ok(None);
+ };
+ let class_id = self.region_class_id.clone();
+ let length = physical_length_mm(start, point);
+ let id = self.edit("Add ruler", |document| {
+ document.add_linear_measurement(&class_id, [start, point], length)
+ })?;
+ self.select_only(id);
+ Ok(Some(id))
+ }
+
+ #[must_use]
+ pub(in crate::app) const fn ruler_start(&self) -> Option {
+ self.ruler_start
+ }
+
+ pub(in crate::app) fn cancel_ruler(&mut self) -> bool {
+ self.ruler_start.take().is_some()
+ }
+
+ pub(in crate::app) fn cancel_draft_step(&mut self) -> bool {
+ let Some(before) = self.draft.as_ref().cloned() else {
+ return false;
+ };
+ if before.points().is_empty() {
+ self.draft = None;
+ return true;
+ }
+ if before.points().len() == 1 {
+ self.draft = None;
+ self.draft_undo.push(DraftUndoStep::RestoreDraft(before));
+ return true;
+ }
+ let point = self
+ .draft
+ .as_mut()
+ .and_then(DraftInteraction::pop_point)
+ .expect("the non-empty polygon draft was checked");
+ self.draft_undo.push(DraftUndoStep::AppendPoint(point));
+ true
+ }
+
+ pub(in crate::app) fn undo_draft_cancel(&mut self) -> bool {
+ let Some(step) = self.draft_undo.pop() else {
+ return false;
+ };
+ match step {
+ DraftUndoStep::AppendPoint(point) => {
+ let Some(draft) = &mut self.draft else {
+ self.draft_undo.push(DraftUndoStep::AppendPoint(point));
+ return false;
+ };
+ draft.push_point(point);
+ }
+ DraftUndoStep::RestoreDraft(draft) => {
+ if self.draft.is_some() {
+ self.draft_undo.push(DraftUndoStep::RestoreDraft(draft));
+ return false;
+ }
+ self.draft = Some(draft);
+ }
+ }
+ true
+ }
+
+ pub(in crate::app) fn discard_draft(&mut self) {
+ self.draft = None;
+ self.draft_undo.clear();
+ self.pending_tool = None;
+ }
+
+ #[must_use]
+ pub(in crate::app) fn active_class_id(&self) -> &str {
+ match self.active_tool {
+ ActiveTool::Point => &self.point_class_id,
+ _ => &self.region_class_id,
+ }
+ }
+
+ pub(in crate::app) fn set_active_class(
+ &mut self,
+ class_id: impl Into,
+ ) -> ViewerResult<()> {
+ if self.draft.is_some() {
+ return Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before changing class".into(),
+ ));
+ }
+ let class_id = class_id.into();
+ let class = self.document.scheme().class(&class_id).ok_or_else(|| {
+ ViewerError::InvalidInput("selected annotation class does not exist".into())
+ })?;
+ match class.geometry() {
+ dicom_viewer_core::AnnotationClassGeometry::Region => self.region_class_id = class_id,
+ dicom_viewer_core::AnnotationClassGeometry::Point => self.point_class_id = class_id,
+ }
+ self.draft_undo.clear();
+ Ok(())
+ }
+
+ pub(in crate::app) fn migrate_scheme(
+ &mut self,
+ target: AnnotationScheme,
+ mappings: &BTreeMap,
+ ) -> ViewerResult<()> {
+ if self.draft.is_some() {
+ return Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before changing annotation scheme"
+ .into(),
+ ));
+ }
+ self.edit("Migrate annotation scheme", |document| {
+ document.migrate_scheme(target, mappings)
+ })
+ }
+
+ #[must_use]
+ pub(in crate::app) const fn segment_operation(&self) -> SegmentOperation {
+ self.segment_operation
+ }
+
+ pub(in crate::app) fn set_segment_operation(&mut self, operation: SegmentOperation) {
+ self.segment_operation = operation;
+ }
+
+ #[must_use]
+ pub(in crate::app) const fn brush_diameter(&self) -> f64 {
+ self.brush_diameter
+ }
+
+ pub(in crate::app) fn adjust_brush_diameter(&mut self, scale: f64) {
+ self.brush_diameter = (self.brush_diameter * scale).clamp(1.0, 20_000.0);
+ }
+
+ #[must_use]
+ #[cfg(test)]
+ pub(in crate::app) const fn active_vector_layer(&self) -> Uuid {
+ self.active_vector_layer
+ }
+
+ pub(in crate::app) fn ensure_segmentation_layer(&mut self) -> ViewerResult {
+ if self.draft.is_some() {
+ return Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before activating Brush".into(),
+ ));
+ }
+ if let Some(id) = self.active_segmentation_layer {
+ self.editing_representation = EditingRepresentation::Segmentation;
+ self.draft_undo.clear();
+ return Ok(id);
+ }
+ let id = self.edit("Create segmentation layer", |document| {
+ Ok(document.ensure_manual_segmentation_layer())
+ })?;
+ self.active_segmentation_layer = Some(id);
+ self.editing_representation = EditingRepresentation::Segmentation;
+ self.draft_undo.clear();
+ Ok(id)
+ }
+
+ #[must_use]
+ pub(in crate::app) const fn editing_representation(&self) -> EditingRepresentation {
+ self.editing_representation
+ }
+
+ pub(in crate::app) fn use_vector_layer(&mut self, layer_id: Uuid) -> ViewerResult<()> {
+ if self.draft.is_some() {
+ return Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before changing layers".into(),
+ ));
+ }
+ if !self
+ .document
+ .vector_layers()
+ .iter()
+ .any(|layer| layer.id() == layer_id)
+ {
+ return Err(ViewerError::InvalidInput(
+ "the selected vector layer does not exist".into(),
+ ));
+ }
+ self.active_vector_layer = layer_id;
+ self.editing_representation = EditingRepresentation::Vector;
+ self.draft_undo.clear();
+ Ok(())
+ }
+
+ pub(in crate::app) fn use_segmentation_layer(&mut self, layer_id: Uuid) -> ViewerResult<()> {
+ if self.draft.is_some() {
+ return Err(ViewerError::InvalidInput(
+ "finish, resume, or discard the current polygon before changing layers".into(),
+ ));
+ }
+ if !self
+ .document
+ .segmentation_layers()
+ .iter()
+ .any(|layer| layer.id() == layer_id)
+ {
+ return Err(ViewerError::InvalidInput(
+ "the selected segmentation layer does not exist".into(),
+ ));
+ }
+ self.active_segmentation_layer = Some(layer_id);
+ self.editing_representation = EditingRepresentation::Segmentation;
+ self.draft_undo.clear();
+ Ok(())
+ }
+
+ pub(in crate::app) fn begin_new_segment(&mut self) {
+ self.draft_undo.clear();
+ self.clear_selection();
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace/transaction.rs b/apps/dicom-viewer/src/app/workspace/transaction.rs
new file mode 100644
index 0000000..7d0ea60
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace/transaction.rs
@@ -0,0 +1,142 @@
+use super::*;
+
+impl WorkspaceRuntime {
+ pub(in crate::app) fn new(
+ source_identity: ViewerSourceIdentity,
+ scheme: AnnotationScheme,
+ ) -> ViewerResult {
+ Self::from_document(WorkspaceDocument::new(source_identity, scheme)?)
+ }
+
+ #[cfg(test)]
+ pub(in crate::app) fn with_history_limits(
+ source_identity: ViewerSourceIdentity,
+ scheme: AnnotationScheme,
+ max_commands: usize,
+ max_retained_bytes: usize,
+ ) -> ViewerResult {
+ let mut runtime = Self::new(source_identity, scheme)?;
+ runtime.history = WorkspaceHistory::with_limits(max_commands, max_retained_bytes);
+ Ok(runtime)
+ }
+
+ pub(in crate::app) fn from_document(document: WorkspaceDocument) -> ViewerResult {
+ document.validate()?;
+ let active_vector_layer = document.vector_layers()[0].id();
+ let document = Arc::new(document);
+ let spatial_index = WorkspaceSpatialIndex::build(&document)?;
+ let spatial_revision = document.revision();
+ let region_class_id = document
+ .scheme()
+ .classes()
+ .iter()
+ .find(|class| class.geometry() == dicom_viewer_core::AnnotationClassGeometry::Region)
+ .map(|class| class.id().to_owned())
+ .ok_or_else(|| ViewerError::InvalidInput("scheme has no region class".into()))?;
+ let point_class_id = document
+ .scheme()
+ .classes()
+ .iter()
+ .find(|class| class.geometry() == dicom_viewer_core::AnnotationClassGeometry::Point)
+ .map(|class| class.id().to_owned())
+ .unwrap_or_else(|| region_class_id.clone());
+ Ok(Self {
+ document,
+ history: WorkspaceHistory::default(),
+ active_tool: ActiveTool::Pan,
+ region_class_id,
+ point_class_id,
+ active_vector_layer,
+ active_segmentation_layer: None,
+ editing_representation: EditingRepresentation::Vector,
+ segment_operation: SegmentOperation::Add,
+ brush_diameter: 40.0,
+ selection: HashSet::new(),
+ draft: None,
+ draft_undo: Vec::new(),
+ pending_tool: None,
+ brush_stroke: None,
+ brush_operation: None,
+ ruler_start: None,
+ spatial_index,
+ spatial_revision,
+ external_payloads: HashMap::new(),
+ handle_drag: None,
+ })
+ }
+
+ #[must_use]
+ pub(in crate::app) fn document(&self) -> &WorkspaceDocument {
+ &self.document
+ }
+
+ #[must_use]
+ pub(in crate::app) fn document_snapshot(&self) -> Arc {
+ Arc::clone(&self.document)
+ }
+
+ pub(in crate::app) fn edit(
+ &mut self,
+ label: impl Into,
+ edit: impl FnOnce(&mut WorkspaceDocument) -> ViewerResult,
+ ) -> ViewerResult {
+ let before = Arc::clone(&self.document);
+ let mut candidate = (*before).clone();
+ let result = edit(&mut candidate)?;
+ candidate.validate()?;
+ if candidate.revision() != before.revision() {
+ let after = Arc::new(candidate);
+ self.history
+ .record(label, Arc::clone(&before), Arc::clone(&after));
+ self.document = after;
+ self.draft_undo.clear();
+ self.invalidate_spatial_index();
+ }
+ Ok(result)
+ }
+
+ pub(in crate::app) fn undo(&mut self) -> bool {
+ let Some(document) = self.history.undo() else {
+ return false;
+ };
+ self.document = document;
+ self.selection
+ .retain(|id| self.document.object(*id).is_some());
+ self.invalidate_spatial_index();
+ true
+ }
+
+ pub(in crate::app) fn redo(&mut self) -> bool {
+ let Some(document) = self.history.redo() else {
+ return false;
+ };
+ self.document = document;
+ self.invalidate_spatial_index();
+ true
+ }
+
+ #[must_use]
+ pub(in crate::app) fn can_undo(&self) -> bool {
+ self.history.can_undo()
+ }
+
+ #[must_use]
+ pub(in crate::app) fn can_redo(&self) -> bool {
+ self.history.can_redo()
+ }
+
+ #[must_use]
+ pub(in crate::app) fn history_truncated(&self) -> bool {
+ self.history.truncated()
+ }
+
+ #[must_use]
+ pub(in crate::app) fn undo_label(&self) -> Option<&str> {
+ self.history.undo_label()
+ }
+
+ #[must_use]
+ pub(in crate::app) fn redo_label(&self) -> Option<&str> {
+ self.history.redo_label()
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace_actions.rs b/apps/dicom-viewer/src/app/workspace_actions.rs
index ab82d13..4e3bfa7 100644
--- a/apps/dicom-viewer/src/app/workspace_actions.rs
+++ b/apps/dicom-viewer/src/app/workspace_actions.rs
@@ -71,6 +71,9 @@ impl DicomViewerApp {
}
}
+ if actions.export_current_view_tiff {
+ self.begin_current_view_tiff_export(ctx);
+ }
if actions.export_portable_workspace {
self.export_portable_workspace(ctx);
}
diff --git a/apps/dicom-viewer/src/app/workspace_dialogs.rs b/apps/dicom-viewer/src/app/workspace_dialogs.rs
index 815ba6f..fe984c4 100644
--- a/apps/dicom-viewer/src/app/workspace_dialogs.rs
+++ b/apps/dicom-viewer/src/app/workspace_dialogs.rs
@@ -172,11 +172,21 @@ impl DicomViewerApp {
== AnnotationScheme::tumor_mask_compatibility_v1().content_digest();
let mut open = true;
let mut action = PathologyWorkspaceActions::default();
- egui::Window::new("Export Pathology")
+ egui::Window::new("Export")
.id(egui::Id::new("pathology-export-wizard"))
.open(&mut open)
.default_width(430.0)
.show(ctx, |ui| {
+ action.export_current_view_tiff =
+ ui.button("Current screen view (TIFF)…").clicked();
+ ui.label(
+ RichText::new(
+ "Captures the visible slide canvas at the current pan and zoom, including pathology overlays but excluding the viewer HUD.",
+ )
+ .small()
+ .weak(),
+ );
+ ui.separator();
ui.label(format!(
"Preflight: {vectors} vector finding(s), {segments} segment(s), {rulers} ruler(s)."
));
@@ -229,7 +239,8 @@ impl DicomViewerApp {
ui.label(RichText::new("GeoJSON excludes rulers only after explicit eligible-items confirmation.").small().weak());
}
});
- let acted = action.export_portable_workspace
+ let acted = action.export_current_view_tiff
+ || action.export_portable_workspace
|| action.export_scheme_geojson
|| action.export_compatibility_geojson
|| action.export_ann
diff --git a/apps/dicom-viewer/src/app/workspace_interaction.rs b/apps/dicom-viewer/src/app/workspace_interaction.rs
index f0cbaf6..10fd1b4 100644
--- a/apps/dicom-viewer/src/app/workspace_interaction.rs
+++ b/apps/dicom-viewer/src/app/workspace_interaction.rs
@@ -1,9 +1,15 @@
+mod keyboard;
+mod pointer;
+
+#[cfg(test)]
+mod tests;
+
use dicom_viewer_core::{Point2, StudySummary};
use eframe::egui::{self, Rect};
use super::camera::CameraView;
use super::viewport::{base_contains_point, screen_to_base};
-use super::workspace::{ActiveTool, ToolTransitionOutcome};
+use super::workspace::ActiveTool;
use super::DicomViewerApp;
#[derive(Debug, Default)]
@@ -29,107 +35,7 @@ impl DicomViewerApp {
};
if accepts_keys {
- let (modifiers, pressed) = ui.input(|input| {
- let pressed = |key| input.key_pressed(key);
- (
- input.modifiers,
- [
- pressed(egui::Key::V),
- pressed(egui::Key::P),
- pressed(egui::Key::B),
- pressed(egui::Key::K),
- pressed(egui::Key::R),
- pressed(egui::Key::N),
- pressed(egui::Key::Enter),
- pressed(egui::Key::Escape),
- pressed(egui::Key::Delete),
- pressed(egui::Key::Z),
- pressed(egui::Key::Y),
- pressed(egui::Key::OpenBracket),
- pressed(egui::Key::CloseBracket),
- ],
- )
- });
- let command_handled = if modifiers.command && pressed[9] {
- if modifiers.shift {
- if runtime.redo() {
- self.status = "Redid the last pathology command.".into();
- }
- } else if runtime.undo_draft_cancel() {
- self.status = "Restored the last cancelled draft step.".into();
- } else if runtime.undo() {
- self.status = "Undid the last pathology command.".into();
- }
- true
- } else if modifiers.ctrl && pressed[10] {
- if runtime.redo() {
- self.status = "Redid the last pathology command.".into();
- }
- true
- } else {
- false
- };
- if !command_handled && !modifiers.command && !modifiers.ctrl && !modifiers.alt {
- let requested_tool = if pressed[0] {
- Some(ActiveTool::Select)
- } else if pressed[1] {
- Some(ActiveTool::Polygon)
- } else if pressed[2] {
- Some(ActiveTool::Brush)
- } else if pressed[3] {
- Some(ActiveTool::Point)
- } else if pressed[4] {
- Some(ActiveTool::Ruler)
- } else {
- None
- };
- if let Some(tool) = requested_tool {
- if tool == ActiveTool::Brush {
- if let Err(error) = runtime.ensure_segmentation_layer() {
- self.status = error.to_string();
- }
- }
- if runtime.request_tool(tool) == ToolTransitionOutcome::BlockedByDraft {
- self.status =
- "Unfinished polygon: choose Resume, Finish, or Discard.".into();
- }
- }
- if pressed[5] {
- runtime.begin_new_segment();
- self.status = "The next edit will create an independent tracked object.".into();
- }
- if pressed[6] && runtime.draft().is_some() {
- match runtime.finish_draft() {
- Ok(_) => self.status = "Finished polygon.".into(),
- Err(error) => self.status = error.to_string(),
- }
- }
- if pressed[7] {
- if runtime.brush_stroke().is_some() {
- runtime.cancel_pointer_interaction();
- self.status = "Cancelled the current brush stroke.".into();
- } else if runtime.cancel_draft_step() {
- self.status = "Removed the latest draft vertex; Escape again to continue undoing the draft.".into();
- } else if runtime.cancel_ruler() {
- self.status = "Cancelled the unfinished ruler.".into();
- }
- }
- if pressed[8] {
- match runtime.delete_selection() {
- Ok(count) if count > 0 => {
- self.status = format!("Deleted {count} tracked object(s).")
- }
- Ok(_) => {}
- Err(error) => self.status = error.to_string(),
- }
- }
- if pressed[11] {
- runtime.adjust_brush_diameter(0.8);
- }
- if pressed[12] {
- runtime.adjust_brush_diameter(1.25);
- }
- }
+ ui.input(|input| keyboard::handle_keyboard(runtime, &mut self.status, input));
}
let space_pan = accepts_keys && ui.input(|input| input.key_down(egui::Key::Space));
@@ -144,182 +50,20 @@ impl DicomViewerApp {
.map(|pointer| screen_to_base(rect, pointer, view.center_base, view.zoom))
.filter(|point| base_contains_point(summary, *point))
.map(|point| Point2::new(f64::from(point.x), f64::from(point.y)));
- let alt = ui.input(|input| input.modifiers.alt);
-
- match runtime.active_tool() {
- ActiveTool::Pan => unreachable!(),
- ActiveTool::Select => {
- if response.drag_started() {
- if let Some(point) = point {
- let tolerance = 11.0 / f64::from(view.zoom.max(f32::EPSILON));
- interaction.drag_consumed = runtime.begin_handle_drag(point, tolerance);
- }
- }
- if runtime.handle_drag_active() && response.dragged() {
- interaction.drag_consumed = true;
- if let Some(point) = point {
- let mpp = valid_mpp(summary);
- if let Err(error) = runtime.update_handle_drag(point, |start, end| {
- mpp.map(|(mpp_x, mpp_y)| {
- ((end.x - start.x) * mpp_x).hypot((end.y - start.y) * mpp_y)
- / 1_000.0
- })
- }) {
- self.status = format!("Geometry handle cannot move there: {error}");
- }
- }
- }
- if runtime.handle_drag_active() && response.drag_stopped() {
- interaction.drag_consumed = true;
- if runtime.finish_handle_drag() {
- self.status = "Committed one geometry-move command.".into();
- }
- } else if runtime.handle_drag_active()
- && (!ui.input(|input| input.pointer.primary_down())
- || ui.input(|input| input.viewport().focused == Some(false)))
- {
- runtime.cancel_handle_drag();
- self.status =
- "Pointer capture was lost; the geometry move was cancelled.".into();
- }
- if response.clicked() && !interaction.drag_consumed {
- interaction.click_consumed = true;
- if let Some(point) = point {
- let tolerance = 9.0 / f64::from(view.zoom.max(f32::EPSILON));
- if let Some(id) = runtime.hit_test(point, tolerance) {
- if ui.input(|input| input.modifiers.shift) {
- runtime.toggle_selection(id);
- } else {
- runtime.select_only(id);
- }
- } else if !ui.input(|input| input.modifiers.shift) {
- runtime.clear_selection();
- }
- }
- }
- }
- ActiveTool::Polygon => {
- if response.double_clicked() {
- interaction.click_consumed = true;
- if let Some(point) = point {
- let original = runtime.segment_operation();
- if alt {
- runtime.set_segment_operation(original.reversed());
- }
- let add = runtime.add_polygon_point(point);
- runtime.set_segment_operation(original);
- match add.and_then(|()| runtime.finish_draft().map(|_| ())) {
- Ok(()) => self.status = "Finished polygon.".into(),
- Err(error) => self.status = error.to_string(),
- }
- }
- } else if response.clicked() {
- interaction.click_consumed = true;
- if let Some(point) = point {
- let original = runtime.segment_operation();
- if alt {
- runtime.set_segment_operation(original.reversed());
- }
- let result = runtime.add_polygon_point(point);
- runtime.set_segment_operation(original);
- self.status = match result {
- Ok(()) => {
- "Polygon vertex added; Enter or double-click to finish.".into()
- }
- Err(error) => error.to_string(),
- };
- }
- }
- }
- ActiveTool::Brush => {
- if response.drag_started() {
- interaction.drag_consumed = true;
- if let Some(point) = point {
- let operation = if alt {
- runtime.segment_operation().reversed()
- } else {
- runtime.segment_operation()
- };
- if let Err(error) =
- runtime.begin_brush_stroke_with_operation(point, operation)
- {
- self.status = error.to_string();
- }
- }
- }
- if response.dragged() {
- interaction.drag_consumed = true;
- if let Some(point) = point {
- runtime.extend_brush_stroke(point);
- }
- }
- if response.drag_stopped() {
- interaction.drag_consumed = true;
- match runtime.finish_brush_stroke() {
- Ok(Some(_)) => self.status = "Committed one brush-stroke command.".into(),
- Ok(None) => {
- self.status =
- "Erase did not intersect the selected segment; nothing changed."
- .into()
- }
- Err(error) => self.status = error.to_string(),
- }
- } else if runtime.brush_stroke().is_some()
- && (!ui.input(|input| input.pointer.primary_down())
- || ui.input(|input| input.viewport().focused == Some(false)))
- {
- runtime.cancel_pointer_interaction();
- self.status =
- "Pointer capture was lost; the brush stroke was cancelled.".into();
- }
- }
- ActiveTool::Point => {
- if response.clicked() {
- interaction.click_consumed = true;
- if let Some(point) = point {
- match runtime.add_point_finding(point) {
- Ok(_) => self.status = "Added an independent tracked point.".into(),
- Err(error) => self.status = error.to_string(),
- }
- }
- }
- }
- ActiveTool::Ruler => {
- if response.clicked() {
- interaction.click_consumed = true;
- if let Some(point) = point {
- let mpp = valid_mpp(summary);
- match runtime.place_ruler_point(point, |start, end| {
- mpp.map(|(mpp_x, mpp_y)| {
- ((end.x - start.x) * mpp_x).hypot((end.y - start.y) * mpp_y)
- / 1_000.0
- })
- }) {
- Ok(Some(id)) => {
- let label = runtime
- .document()
- .measurement(id)
- .and_then(|measurement| measurement.physical_length_mm())
- .map_or_else(
- || "unscaled pixels".into(),
- |millimeters| {
- if millimeters >= 1.0 {
- format!("{millimeters:.3} mm")
- } else {
- format!("{:.1} µm", millimeters * 1_000.0)
- }
- },
- );
- self.status = format!("Added tracked ruler: {label}.");
- }
- Ok(None) => self.status = "Ruler start set.".into(),
- Err(error) => self.status = error.to_string(),
- }
- }
- }
- }
- }
- interaction
+ let input = ui.input(|input| pointer::PointerInput {
+ point,
+ clicked: response.clicked(),
+ double_clicked: response.double_clicked(),
+ drag_started: response.drag_started(),
+ dragged: response.dragged(),
+ drag_stopped: response.drag_stopped(),
+ capture_lost: !input.pointer.primary_down() || input.viewport().focused == Some(false),
+ shift: input.modifiers.shift,
+ alt: input.modifiers.alt,
+ zoom: view.zoom,
+ mpp: valid_mpp(summary),
+ });
+ pointer::handle_pointer(runtime, &mut self.status, &input)
}
}
diff --git a/apps/dicom-viewer/src/app/workspace_interaction/keyboard.rs b/apps/dicom-viewer/src/app/workspace_interaction/keyboard.rs
new file mode 100644
index 0000000..2f01ecc
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace_interaction/keyboard.rs
@@ -0,0 +1,109 @@
+use eframe::egui;
+
+use crate::app::workspace::{ActiveTool, ToolTransitionOutcome, WorkspaceRuntime};
+
+pub(super) fn handle_keyboard(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &egui::InputState,
+) {
+ let modifiers = input.modifiers;
+ if !handle_history_key(runtime, status, input)
+ && !modifiers.command
+ && !modifiers.ctrl
+ && !modifiers.alt
+ {
+ handle_edit_keys(runtime, status, input);
+ }
+}
+
+fn handle_history_key(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &egui::InputState,
+) -> bool {
+ let modifiers = input.modifiers;
+ if modifiers.command && input.key_pressed(egui::Key::Z) {
+ if modifiers.shift {
+ if runtime.redo() {
+ *status = "Redid the last pathology command.".into();
+ }
+ } else if runtime.undo_draft_cancel() {
+ *status = "Restored the last cancelled draft step.".into();
+ } else if runtime.undo() {
+ *status = "Undid the last pathology command.".into();
+ }
+ true
+ } else if modifiers.ctrl && input.key_pressed(egui::Key::Y) {
+ if runtime.redo() {
+ *status = "Redid the last pathology command.".into();
+ }
+ true
+ } else {
+ false
+ }
+}
+
+fn requested_tool(input: &egui::InputState) -> Option {
+ if input.key_pressed(egui::Key::V) {
+ Some(ActiveTool::Select)
+ } else if input.key_pressed(egui::Key::P) {
+ Some(ActiveTool::Polygon)
+ } else if input.key_pressed(egui::Key::B) {
+ Some(ActiveTool::Brush)
+ } else if input.key_pressed(egui::Key::K) {
+ Some(ActiveTool::Point)
+ } else if input.key_pressed(egui::Key::R) {
+ Some(ActiveTool::Ruler)
+ } else {
+ None
+ }
+}
+
+fn handle_edit_keys(runtime: &mut WorkspaceRuntime, status: &mut String, input: &egui::InputState) {
+ if let Some(tool) = requested_tool(input) {
+ if tool == ActiveTool::Brush {
+ if let Err(error) = runtime.ensure_segmentation_layer() {
+ *status = error.to_string();
+ }
+ }
+ if runtime.request_tool(tool) == ToolTransitionOutcome::BlockedByDraft {
+ *status = "Unfinished polygon: choose Resume, Finish, or Discard.".into();
+ }
+ }
+ if input.key_pressed(egui::Key::N) {
+ runtime.begin_new_segment();
+ *status = "The next edit will create an independent tracked object.".into();
+ }
+ if input.key_pressed(egui::Key::Enter) && runtime.draft().is_some() {
+ match runtime.finish_draft() {
+ Ok(_) => *status = "Finished polygon.".into(),
+ Err(error) => *status = error.to_string(),
+ }
+ }
+ if input.key_pressed(egui::Key::Escape) {
+ if runtime.brush_stroke().is_some() {
+ runtime.cancel_pointer_interaction();
+ *status = "Cancelled the current brush stroke.".into();
+ } else if runtime.cancel_draft_step() {
+ *status =
+ "Removed the latest draft vertex; Escape again to continue undoing the draft."
+ .into();
+ } else if runtime.cancel_ruler() {
+ *status = "Cancelled the unfinished ruler.".into();
+ }
+ }
+ if input.key_pressed(egui::Key::Delete) {
+ match runtime.delete_selection() {
+ Ok(count) if count > 0 => *status = format!("Deleted {count} tracked object(s)."),
+ Ok(_) => {}
+ Err(error) => *status = error.to_string(),
+ }
+ }
+ if input.key_pressed(egui::Key::OpenBracket) {
+ runtime.adjust_brush_diameter(0.8);
+ }
+ if input.key_pressed(egui::Key::CloseBracket) {
+ runtime.adjust_brush_diameter(1.25);
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace_interaction/pointer.rs b/apps/dicom-viewer/src/app/workspace_interaction/pointer.rs
new file mode 100644
index 0000000..f512a79
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace_interaction/pointer.rs
@@ -0,0 +1,227 @@
+use super::WorkspaceCanvasInteraction;
+use crate::app::workspace::{ActiveTool, WorkspaceRuntime};
+use dicom_viewer_core::Point2;
+
+/// One pointer observation, translated from egui before issuing domain commands.
+#[derive(Debug, Default)]
+pub(super) struct PointerInput {
+ pub(super) point: Option,
+ pub(super) clicked: bool,
+ pub(super) double_clicked: bool,
+ pub(super) drag_started: bool,
+ pub(super) dragged: bool,
+ pub(super) drag_stopped: bool,
+ pub(super) capture_lost: bool,
+ pub(super) shift: bool,
+ pub(super) alt: bool,
+ pub(super) zoom: f32,
+ pub(super) mpp: Option<(f64, f64)>,
+}
+
+pub(super) fn handle_pointer(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+) -> WorkspaceCanvasInteraction {
+ let mut interaction = WorkspaceCanvasInteraction::default();
+ match runtime.active_tool() {
+ ActiveTool::Pan => {}
+ ActiveTool::Select => handle_select(runtime, status, input, &mut interaction),
+ ActiveTool::Polygon => handle_polygon(runtime, status, input, &mut interaction),
+ ActiveTool::Brush => handle_brush(runtime, status, input, &mut interaction),
+ ActiveTool::Point => handle_point(runtime, status, input, &mut interaction),
+ ActiveTool::Ruler => handle_ruler(runtime, status, input, &mut interaction),
+ }
+ interaction
+}
+
+fn handle_select(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+ interaction: &mut WorkspaceCanvasInteraction,
+) {
+ let point = input.point;
+ if input.drag_started {
+ if let Some(point) = point {
+ let tolerance = 11.0 / f64::from(input.zoom.max(f32::EPSILON));
+ interaction.drag_consumed = runtime.begin_handle_drag(point, tolerance);
+ }
+ }
+ if runtime.handle_drag_active() && input.dragged {
+ interaction.drag_consumed = true;
+ if let Some(point) = point {
+ let mpp = input.mpp;
+ if let Err(error) = runtime.update_handle_drag(point, |start, end| {
+ mpp.map(|(mpp_x, mpp_y)| {
+ ((end.x - start.x) * mpp_x).hypot((end.y - start.y) * mpp_y) / 1_000.0
+ })
+ }) {
+ *status = format!("Geometry handle cannot move there: {error}");
+ }
+ }
+ }
+ if runtime.handle_drag_active() && input.drag_stopped {
+ interaction.drag_consumed = true;
+ if runtime.finish_handle_drag() {
+ *status = "Committed one geometry-move command.".into();
+ }
+ } else if runtime.handle_drag_active() && input.capture_lost {
+ runtime.cancel_handle_drag();
+ *status = "Pointer capture was lost; the geometry move was cancelled.".into();
+ }
+ if input.clicked && !interaction.drag_consumed {
+ interaction.click_consumed = true;
+ if let Some(point) = point {
+ let tolerance = 9.0 / f64::from(input.zoom.max(f32::EPSILON));
+ if let Some(id) = runtime.hit_test(point, tolerance) {
+ if input.shift {
+ runtime.toggle_selection(id);
+ } else {
+ runtime.select_only(id);
+ }
+ } else if !input.shift {
+ runtime.clear_selection();
+ }
+ }
+ }
+}
+
+fn handle_polygon(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+ interaction: &mut WorkspaceCanvasInteraction,
+) {
+ let point = input.point;
+ let alt = input.alt;
+ if input.double_clicked {
+ interaction.click_consumed = true;
+ if let Some(point) = point {
+ let original = runtime.segment_operation();
+ if alt {
+ runtime.set_segment_operation(original.reversed());
+ }
+ let add = runtime.add_polygon_point(point);
+ runtime.set_segment_operation(original);
+ match add.and_then(|()| runtime.finish_draft().map(|_| ())) {
+ Ok(()) => *status = "Finished polygon.".into(),
+ Err(error) => *status = error.to_string(),
+ }
+ }
+ } else if input.clicked {
+ interaction.click_consumed = true;
+ if let Some(point) = point {
+ let original = runtime.segment_operation();
+ if alt {
+ runtime.set_segment_operation(original.reversed());
+ }
+ let result = runtime.add_polygon_point(point);
+ runtime.set_segment_operation(original);
+ *status = match result {
+ Ok(()) => "Polygon vertex added; Enter or double-click to finish.".into(),
+ Err(error) => error.to_string(),
+ };
+ }
+ }
+}
+
+fn handle_brush(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+ interaction: &mut WorkspaceCanvasInteraction,
+) {
+ let point = input.point;
+ let alt = input.alt;
+ if input.drag_started {
+ interaction.drag_consumed = true;
+ if let Some(point) = point {
+ let operation = if alt {
+ runtime.segment_operation().reversed()
+ } else {
+ runtime.segment_operation()
+ };
+ if let Err(error) = runtime.begin_brush_stroke_with_operation(point, operation) {
+ *status = error.to_string();
+ }
+ }
+ }
+ if input.dragged {
+ interaction.drag_consumed = true;
+ if let Some(point) = point {
+ runtime.extend_brush_stroke(point);
+ }
+ }
+ if input.drag_stopped {
+ interaction.drag_consumed = true;
+ match runtime.finish_brush_stroke() {
+ Ok(Some(_)) => *status = "Committed one brush-stroke command.".into(),
+ Ok(None) => {
+ *status = "Erase did not intersect the selected segment; nothing changed.".into()
+ }
+ Err(error) => *status = error.to_string(),
+ }
+ } else if runtime.brush_stroke().is_some() && input.capture_lost {
+ runtime.cancel_pointer_interaction();
+ *status = "Pointer capture was lost; the brush stroke was cancelled.".into();
+ }
+}
+
+fn handle_point(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+ interaction: &mut WorkspaceCanvasInteraction,
+) {
+ let point = input.point;
+ if input.clicked {
+ interaction.click_consumed = true;
+ if let Some(point) = point {
+ match runtime.add_point_finding(point) {
+ Ok(_) => *status = "Added an independent tracked point.".into(),
+ Err(error) => *status = error.to_string(),
+ }
+ }
+ }
+}
+
+fn handle_ruler(
+ runtime: &mut WorkspaceRuntime,
+ status: &mut String,
+ input: &PointerInput,
+ interaction: &mut WorkspaceCanvasInteraction,
+) {
+ let point = input.point;
+ if input.clicked {
+ interaction.click_consumed = true;
+ if let Some(point) = point {
+ let mpp = input.mpp;
+ match runtime.place_ruler_point(point, |start, end| {
+ mpp.map(|(mpp_x, mpp_y)| {
+ ((end.x - start.x) * mpp_x).hypot((end.y - start.y) * mpp_y) / 1_000.0
+ })
+ }) {
+ Ok(Some(id)) => {
+ let label = runtime
+ .document()
+ .measurement(id)
+ .and_then(|measurement| measurement.physical_length_mm())
+ .map_or_else(
+ || "unscaled pixels".into(),
+ |millimeters| {
+ if millimeters >= 1.0 {
+ format!("{millimeters:.3} mm")
+ } else {
+ format!("{:.1} µm", millimeters * 1_000.0)
+ }
+ },
+ );
+ *status = format!("Added tracked ruler: {label}.");
+ }
+ Ok(None) => *status = "Ruler start set.".into(),
+ Err(error) => *status = error.to_string(),
+ }
+ }
+ }
+}
diff --git a/apps/dicom-viewer/src/app/workspace_interaction/tests.rs b/apps/dicom-viewer/src/app/workspace_interaction/tests.rs
new file mode 100644
index 0000000..a2628d9
--- /dev/null
+++ b/apps/dicom-viewer/src/app/workspace_interaction/tests.rs
@@ -0,0 +1,100 @@
+use dicom_viewer_core::{AnnotationScheme, Point2, ViewerSourceIdentity};
+use eframe::egui;
+
+use super::{keyboard, pointer};
+use crate::app::workspace::{ActiveTool, WorkspaceRuntime};
+
+fn workspace() -> WorkspaceRuntime {
+ WorkspaceRuntime::new(
+ ViewerSourceIdentity::new(9, 0, 0, 0, 0, 0, (5_000, 4_000)),
+ AnnotationScheme::general_pathology_v1(),
+ )
+ .unwrap()
+}
+
+fn press(runtime: &mut WorkspaceRuntime, keys: &[egui::Key], modifiers: egui::Modifiers) {
+ let context = egui::Context::default();
+ let input = egui::RawInput {
+ modifiers,
+ events: keys
+ .iter()
+ .map(|&key| egui::Event::Key {
+ key,
+ physical_key: None,
+ pressed: true,
+ repeat: false,
+ modifiers,
+ })
+ .collect(),
+ ..Default::default()
+ };
+ let _ = context.run_ui(input, |ui| {
+ ui.input(|input| keyboard::handle_keyboard(runtime, &mut String::new(), input));
+ });
+}
+
+#[test]
+fn keyboard_history_precedes_tool_selection_and_restores_cancelled_drafts() {
+ let mut runtime = workspace();
+ runtime.request_tool(ActiveTool::Polygon);
+ runtime.add_polygon_point(Point2::new(10.0, 10.0)).unwrap();
+ runtime.add_polygon_point(Point2::new(20.0, 10.0)).unwrap();
+ press(&mut runtime, &[egui::Key::Escape], egui::Modifiers::NONE);
+ assert_eq!(runtime.draft().unwrap().points().len(), 1);
+ press(
+ &mut runtime,
+ &[egui::Key::Z, egui::Key::V],
+ egui::Modifiers {
+ command: true,
+ ..Default::default()
+ },
+ );
+ assert_eq!(runtime.draft().unwrap().points().len(), 2);
+ assert_eq!(runtime.active_tool(), ActiveTool::Polygon);
+ let layer_count = runtime.document().segmentation_layers().len();
+ press(&mut runtime, &[egui::Key::B], egui::Modifiers::NONE);
+ assert_eq!(runtime.active_tool(), ActiveTool::Polygon);
+ assert_eq!(runtime.document().segmentation_layers().len(), layer_count);
+}
+
+#[test]
+fn pointer_capture_loss_cancels_stroke_and_release_commits_one_undoable_edit() {
+ let mut runtime = workspace();
+ runtime.ensure_segmentation_layer().unwrap();
+ runtime.request_tool(ActiveTool::Brush);
+ let mut status = String::new();
+ let start = pointer::PointerInput {
+ point: Some(Point2::new(50.0, 50.0)),
+ drag_started: true,
+ dragged: true,
+ zoom: 1.0,
+ ..Default::default()
+ };
+ assert!(pointer::handle_pointer(&mut runtime, &mut status, &start).drag_consumed);
+ assert!(runtime.brush_stroke().is_some());
+ pointer::handle_pointer(
+ &mut runtime,
+ &mut status,
+ &pointer::PointerInput {
+ capture_lost: true,
+ ..Default::default()
+ },
+ );
+ assert!(runtime.brush_stroke().is_none());
+ assert_eq!(runtime.document().object_count(), 0);
+ assert!(status.contains("cancelled"));
+
+ pointer::handle_pointer(&mut runtime, &mut status, &start);
+ let release = pointer::PointerInput {
+ drag_stopped: true,
+ capture_lost: true,
+ ..Default::default()
+ };
+ assert!(pointer::handle_pointer(&mut runtime, &mut status, &release).drag_consumed);
+ assert_eq!(runtime.document().object_count(), 1);
+ assert!(runtime.brush_stroke().is_none());
+ assert!(runtime.undo());
+ assert_eq!(runtime.document().object_count(), 0);
+ assert!(runtime.redo());
+ assert_eq!(runtime.document().object_count(), 1);
+}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe.rs b/apps/dicom-viewer/src/bin/annotation_probe.rs
deleted file mode 100644
index e5880cd..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![forbid(unsafe_code)]
-
-use peak_alloc::PeakAlloc;
-
-#[path = "annotation_probe/command.rs"]
-mod command;
-#[path = "annotation_probe/conversion_report.rs"]
-mod conversion_report;
-#[path = "annotation_probe/convert_geojson.rs"]
-mod convert_geojson;
-#[path = "annotation_probe/convert_raster.rs"]
-mod convert_raster;
-#[path = "annotation_probe/legacy/mod.rs"]
-mod legacy;
-#[path = "annotation_probe/publication.rs"]
-mod publication;
-
-#[global_allocator]
-pub(crate) static PEAK_ALLOC: PeakAlloc = PeakAlloc;
-
-fn main() {
- let exit_code = command::execute(
- std::env::args_os().skip(1),
- std::io::stdout().lock(),
- std::io::stderr().lock(),
- );
- if exit_code != 0 {
- std::process::exit(exit_code);
- }
-}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe/command.rs b/apps/dicom-viewer/src/bin/annotation_probe/command.rs
deleted file mode 100644
index e532c90..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe/command.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use std::ffi::OsString;
-use std::io::Write;
-use std::path::PathBuf;
-
-use crate::{convert_geojson, convert_raster, legacy};
-
-pub(crate) const USAGE: &str = "usage:\n annotation_probe inspect --source [--canonical-source ] [--payload full|digest] \n annotation_probe roundtrip --source [--canonical-source ] --output [--allow-lossy] [--payload full|digest] \n annotation_probe convert-geojson --source [--canonical-source ] --mapping --coordinate-space level0-pixels|source-pixels|slide-mm --target ann [--target seg] [--target sr] (--output | --output-dir ) [--allow-lossy] \n annotation_probe convert-raster --source [--canonical-source ] --profile [--channel | --all-channels] (--output | --output-dir ) [--max-instance-bytes ] ";
-
-pub(crate) fn next_path(
- arguments: &mut impl Iterator- ,
- option: &str,
-) -> Result {
- arguments
- .next()
- .map(PathBuf::from)
- .ok_or_else(|| format!("{option} requires a path"))
-}
-
-pub(crate) fn next_utf8(
- arguments: &mut impl Iterator
- ,
- option: &str,
-) -> Result {
- let value = arguments
- .next()
- .ok_or_else(|| format!("{option} requires a value"))?;
- value
- .into_string()
- .map_err(|_| format!("{option} requires UTF-8 text"))
-}
-
-pub(crate) fn set_once(slot: &mut Option, value: T, option: &str) -> Result<(), String> {
- if slot.is_some() {
- return Err(format!("{option} may be supplied only once"));
- }
- *slot = Some(value);
- Ok(())
-}
-
-pub(crate) fn execute(
- arguments: impl IntoIterator
- ,
- stdout: impl Write,
- mut stderr: impl Write,
-) -> i32 {
- let arguments: Vec<_> = arguments.into_iter().collect();
- match arguments.first().and_then(|argument| argument.to_str()) {
- Some("inspect" | "roundtrip") => legacy::execute(arguments, stdout, stderr),
- Some("convert-geojson") => {
- convert_geojson::execute(arguments.into_iter().skip(1), stdout, stderr)
- }
- Some("convert-raster") => {
- convert_raster::execute(arguments.into_iter().skip(1), stdout, stderr)
- }
- _ => {
- let _ = writeln!(
- stderr,
- "the first argument must name a supported command\n{USAGE}"
- );
- 2
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn conversion_commands_have_owned_grammars() {
- for (command, expected_error) in [
- ("convert-geojson", "--source is required"),
- ("convert-raster", "--source is required"),
- ] {
- let mut stdout = Vec::new();
- let mut stderr = Vec::new();
-
- let exit = execute([OsString::from(command)], &mut stdout, &mut stderr);
-
- assert_eq!(exit, 2);
- let report: serde_json::Value = serde_json::from_slice(&stdout).unwrap();
- assert_eq!(report["schema"], "conversion-report-v1");
- assert_eq!(report["status"], "error");
- assert_eq!(report["operation"], command);
- assert_eq!(report["error"]["code"], "USAGE_ERROR");
- let stderr = String::from_utf8(stderr).unwrap();
- assert!(stderr.contains(expected_error), "{stderr}");
- assert!(stderr.contains("annotation_probe convert-geojson"));
- assert!(stderr.contains("annotation_probe convert-raster"));
- }
- }
-
- #[test]
- fn conversion_failures_emit_conversion_report_v1() {
- for (command, profile_option, profile_path, input) in [
- (
- "convert-geojson",
- "--mapping",
- "missing-mapping.json",
- "missing.geojson",
- ),
- (
- "convert-raster",
- "--profile",
- "missing-profile.json",
- "missing.npy",
- ),
- ] {
- let mut stdout = Vec::new();
- let mut stderr = Vec::new();
- let mut arguments = vec![
- OsString::from(command),
- OsString::from("--source"),
- OsString::from("missing-source.dcm"),
- OsString::from(profile_option),
- OsString::from(profile_path),
- ];
- if command == "convert-geojson" {
- arguments.extend([
- OsString::from("--coordinate-space"),
- OsString::from("level0-pixels"),
- OsString::from("--target"),
- OsString::from("ann"),
- ]);
- }
- arguments.extend([
- OsString::from("--output"),
- OsString::from("missing-output.dcm"),
- OsString::from(input),
- ]);
-
- let exit = execute(arguments, &mut stdout, &mut stderr);
-
- assert_eq!(exit, 1, "{}", String::from_utf8_lossy(&stderr));
- let report: serde_json::Value = serde_json::from_slice(&stdout).unwrap();
- assert_eq!(report["schema"], "conversion-report-v1");
- assert_eq!(report["schema_version"], 1);
- assert_eq!(report["status"], "error");
- assert_eq!(report["operation"], command);
- assert_eq!(report["error"]["code"], "SOURCE_READ_FAILED");
- assert!(!stderr.is_empty());
- }
- }
-}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe/conversion_report.rs b/apps/dicom-viewer/src/bin/annotation_probe/conversion_report.rs
deleted file mode 100644
index b97b836..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe/conversion_report.rs
+++ /dev/null
@@ -1,583 +0,0 @@
-use std::collections::BTreeMap;
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-use std::time::Instant;
-
-use serde::Serialize;
-use wsi_dicom_annotations::{
- DiagnosticDisposition, DiagnosticSeverity, InteroperabilityDiagnostic,
-};
-
-#[path = "conversion_report/checksum.rs"]
-mod checksum;
-
-use checksum::{sha256_bytes, sha256_directory, sha256_file};
-
-pub(crate) const SCHEMA: &str = "conversion-report-v1";
-pub(crate) const SCHEMA_VERSION: u32 = 1;
-
-#[derive(Debug)]
-pub(crate) struct ConversionError {
- pub(crate) code: &'static str,
- pub(crate) message: String,
-}
-
-impl ConversionError {
- pub(crate) fn new(code: &'static str, message: impl Into) -> Self {
- Self {
- code,
- message: message.into(),
- }
- }
-
- pub(crate) fn io(operation: &'static str, path: &Path, error: impl std::fmt::Display) -> Self {
- Self::new(operation, format!("{}: {error}", path.to_string_lossy()))
- }
-
- pub(crate) fn conversion(error: impl std::fmt::Display) -> Self {
- Self::new("CONVERSION_FAILED", error.to_string())
- }
-
- pub(crate) fn output_write(error: impl std::fmt::Display) -> Self {
- Self::new("OUTPUT_WRITE_FAILED", error.to_string())
- }
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ImplementationReport {
- name: &'static str,
- version: &'static str,
-}
-
-impl Default for ImplementationReport {
- fn default() -> Self {
- Self {
- name: "dicom-viewer-rust",
- version: env!("CARGO_PKG_VERSION"),
- }
- }
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct InputReport {
- role: &'static str,
- path: String,
- bytes: u64,
- sha256: String,
-}
-
-impl InputReport {
- pub(crate) fn from_bytes(
- role: &'static str,
- path: &Path,
- bytes: &[u8],
- ) -> Result {
- let bytes_len = u64::try_from(bytes.len()).map_err(|_| {
- ConversionError::new("INPUT_TOO_LARGE", "input byte length does not fit u64")
- })?;
- Ok(Self {
- role,
- path: path.to_string_lossy().into_owned(),
- bytes: bytes_len,
- sha256: sha256_bytes(bytes),
- })
- }
-
- pub(crate) fn from_file(role: &'static str, path: &Path) -> Result {
- let (bytes, sha256) = sha256_file(path)?;
- Ok(Self {
- role,
- path: path.to_string_lossy().into_owned(),
- bytes,
- sha256,
- })
- }
-
- pub(crate) fn from_path(role: &'static str, path: &Path) -> Result {
- let metadata = std::fs::symlink_metadata(path)
- .map_err(|error| ConversionError::io("INPUT_READ_FAILED", path, error))?;
- let (bytes, sha256) = if metadata.is_file() {
- sha256_file(path)?
- } else if metadata.is_dir() {
- sha256_directory(path)?
- } else {
- return Err(ConversionError::new(
- "INPUT_PATH_INVALID",
- format!(
- "input is neither a regular file nor a directory: {}",
- path.display()
- ),
- ));
- };
- Ok(Self {
- role,
- path: path.to_string_lossy().into_owned(),
- bytes,
- sha256,
- })
- }
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct OutputReport {
- pub(crate) target: &'static str,
- pub(crate) path: String,
- pub(crate) sop_class_uid: &'static str,
- pub(crate) sop_instance_uid: String,
- pub(crate) series_instance_uid: String,
- pub(crate) bytes: u64,
- pub(crate) sha256: String,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) concatenation_uid: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) concatenation_source_sop_instance_uid: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) in_concatenation_number: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) in_concatenation_total_number: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) frame_offset: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) frame_count: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) pixel_value_bytes: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) pixel_sha256: Option,
-}
-
-impl OutputReport {
- pub(crate) fn for_file(
- target: &'static str,
- path: &Path,
- report_path: &Path,
- sop_class_uid: &'static str,
- sop_instance_uid: &str,
- series_instance_uid: &str,
- ) -> Result {
- let (bytes, sha256) = sha256_file(path)?;
- Ok(Self {
- target,
- path: report_path.to_string_lossy().into_owned(),
- sop_class_uid,
- sop_instance_uid: sop_instance_uid.to_string(),
- series_instance_uid: series_instance_uid.to_string(),
- bytes,
- sha256,
- concatenation_uid: None,
- concatenation_source_sop_instance_uid: None,
- in_concatenation_number: None,
- in_concatenation_total_number: None,
- frame_offset: None,
- frame_count: None,
- pixel_value_bytes: None,
- pixel_sha256: None,
- })
- }
-
- pub(crate) fn with_parametric_map_part(
- mut self,
- plan: &wsi_dicom_annotations::ParametricMapPlan,
- part: &wsi_dicom_annotations::ParametricMapPartPlan,
- part_index: usize,
- ) -> Result {
- let concatenated = plan.parts().len() > 1;
- self.concatenation_uid = plan.concatenation_uid().map(str::to_string);
- self.concatenation_source_sop_instance_uid = plan
- .concatenation_source_sop_instance_uid()
- .map(str::to_string);
- if concatenated {
- self.in_concatenation_number = Some(u16::try_from(part_index + 1).map_err(|_| {
- ConversionError::new(
- "OUTPUT_REPORT_FAILED",
- "PM concatenation part number exceeds DICOM US",
- )
- })?);
- self.in_concatenation_total_number =
- Some(u16::try_from(plan.parts().len()).map_err(|_| {
- ConversionError::new(
- "OUTPUT_REPORT_FAILED",
- "PM concatenation total exceeds DICOM US",
- )
- })?);
- }
- self.frame_offset = Some(part.frame_offset());
- self.frame_count = Some(part.frame_count());
- self.pixel_value_bytes = Some(part.pixel_value_length());
- self.pixel_sha256 = Some(part.pixel_sha256().to_string());
- Ok(self)
- }
-}
-
-#[derive(Debug, Serialize)]
-#[serde(untagged)]
-pub(crate) enum CoverageReport {
- Features {
- target: &'static str,
- feature_count: usize,
- },
- Raster {
- target: &'static str,
- frame_count: u32,
- channel_count: usize,
- },
-}
-
-impl CoverageReport {
- pub(crate) const fn features(target: &'static str, feature_count: usize) -> Self {
- Self::Features {
- target,
- feature_count,
- }
- }
-
- pub(crate) const fn raster(frame_count: u32, channel_count: usize) -> Self {
- Self::Raster {
- target: "pm",
- frame_count,
- channel_count,
- }
- }
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct DiagnosticReport {
- code: String,
- severity: &'static str,
- path: String,
- disposition: &'static str,
- message: String,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct SuccessReport {
- schema: &'static str,
- schema_version: u32,
- status: &'static str,
- operation: &'static str,
- implementation: ImplementationReport,
- pub(crate) inputs: Vec,
- pub(crate) outputs: Vec,
- pub(crate) target_coverage: Vec,
- pub(crate) normalizations: Vec,
- pub(crate) losses: Vec,
- pub(crate) semantic_digest: String,
- pub(crate) timing_ms: BTreeMap<&'static str, f64>,
- pub(crate) peak_tracked_heap_bytes: usize,
-}
-
-impl SuccessReport {
- pub(crate) fn new(operation: &'static str) -> Self {
- Self {
- schema: SCHEMA,
- schema_version: SCHEMA_VERSION,
- status: "ok",
- operation,
- implementation: ImplementationReport::default(),
- inputs: Vec::new(),
- outputs: Vec::new(),
- target_coverage: Vec::new(),
- normalizations: Vec::new(),
- losses: Vec::new(),
- semantic_digest: String::new(),
- timing_ms: BTreeMap::new(),
- peak_tracked_heap_bytes: 0,
- }
- }
-
- pub(crate) fn add_diagnostics(&mut self, diagnostics: &[InteroperabilityDiagnostic]) {
- for diagnostic in diagnostics {
- let report = DiagnosticReport::from(diagnostic);
- match diagnostic.disposition() {
- DiagnosticDisposition::Normalized => self.normalizations.push(report),
- DiagnosticDisposition::WouldDrop => self.losses.push(report),
- DiagnosticDisposition::Unsupported => self.losses.push(report),
- }
- }
- }
-
- pub(crate) fn record_verification_completion(&mut self, started: Instant, peak_heap: usize) {
- self.peak_tracked_heap_bytes = peak_heap;
- self.timing_ms.insert(
- "through_verification",
- started.elapsed().as_secs_f64() * 1_000.0,
- );
- }
-}
-
-impl From<&InteroperabilityDiagnostic> for DiagnosticReport {
- fn from(diagnostic: &InteroperabilityDiagnostic) -> Self {
- Self {
- code: diagnostic.code().to_string(),
- severity: match diagnostic.severity() {
- DiagnosticSeverity::Info => "info",
- DiagnosticSeverity::Warning => "warning",
- DiagnosticSeverity::Error => "error",
- },
- path: diagnostic.path().to_string(),
- disposition: match diagnostic.disposition() {
- DiagnosticDisposition::Normalized => "normalized",
- DiagnosticDisposition::WouldDrop => "would_drop",
- DiagnosticDisposition::Unsupported => "unsupported",
- },
- message: diagnostic.message().to_string(),
- }
- }
-}
-
-#[derive(Serialize)]
-struct ErrorBody<'a> {
- code: &'static str,
- message: &'a str,
-}
-
-#[derive(Serialize)]
-struct ErrorReport<'a> {
- schema: &'static str,
- schema_version: u32,
- status: &'static str,
- operation: &'static str,
- implementation: ImplementationReport,
- error: ErrorBody<'a>,
-}
-
-pub(crate) fn emit_success(report: &SuccessReport, mut stdout: impl Write) -> i32 {
- match write_json_line(&mut stdout, report) {
- Ok(()) => 0,
- Err(_) => 1,
- }
-}
-
-pub(crate) fn emit_error(
- operation: &'static str,
- error: &ConversionError,
- mut stdout: impl Write,
- mut stderr: impl Write,
-) -> i32 {
- if write_error_report(operation, error, &mut stdout).is_err() {
- let _ = writeln!(stderr, "failed to serialize conversion report");
- return 1;
- }
- let _ = writeln!(stderr, "{operation} failed: {}", error.message);
- 1
-}
-
-pub(crate) fn emit_usage_error(
- operation: &'static str,
- message: &str,
- usage: &str,
- mut stdout: impl Write,
- mut stderr: impl Write,
-) -> i32 {
- let error = ConversionError::new("USAGE_ERROR", message);
- if write_error_report(operation, &error, &mut stdout).is_err() {
- let _ = writeln!(stderr, "failed to serialize conversion report");
- return 1;
- }
- let _ = writeln!(stderr, "{message}\n{usage}");
- 2
-}
-
-fn write_error_report(
- operation: &'static str,
- error: &ConversionError,
- output: &mut impl Write,
-) -> std::io::Result<()> {
- let report = ErrorReport {
- schema: SCHEMA,
- schema_version: SCHEMA_VERSION,
- status: "error",
- operation,
- implementation: ImplementationReport::default(),
- error: ErrorBody {
- code: error.code,
- message: &error.message,
- },
- };
- write_json_line(output, &report)
-}
-
-pub(crate) fn write_manifest(path: &Path, report: &SuccessReport) -> Result<(), ConversionError> {
- let file = File::create(path)
- .map_err(|error| ConversionError::io("MANIFEST_WRITE_FAILED", path, error))?;
- serde_json::to_writer_pretty(file, report).map_err(|error| {
- ConversionError::new(
- "MANIFEST_WRITE_FAILED",
- format!("{}: {error}", path.display()),
- )
- })
-}
-
-pub(crate) fn write_json_line(
- output: &mut impl Write,
- value: &impl Serialize,
-) -> std::io::Result<()> {
- serde_json::to_writer(&mut *output, value).map_err(std::io::Error::other)?;
- writeln!(output)
-}
-
-#[cfg(test)]
-mod tests {
- use std::io;
-
- use sha2::{Digest, Sha256};
-
- use super::*;
-
- #[test]
- fn input_report_hashes_the_exact_consumed_bytes() {
- let bytes = b"profile bytes already read by the converter";
-
- let report = InputReport::from_bytes("mapping", Path::new("mapping.json"), bytes).unwrap();
- let value = serde_json::to_value(report).unwrap();
-
- assert_eq!(value["bytes"], bytes.len());
- assert_eq!(value["sha256"], format!("{:x}", Sha256::digest(bytes)));
- }
-
- #[test]
- fn file_and_directory_input_reports_hash_stable_consumed_content() {
- let temporary = tempfile::tempdir().expect("temporary directory should be created");
- let root = temporary.path().join("array.zarr");
- std::fs::create_dir(&root).expect("input directory should be created");
- std::fs::write(root.join("z.json"), b"metadata").expect("metadata should be written");
- std::fs::create_dir(root.join("chunks")).expect("chunk directory should be created");
- std::fs::write(root.join("chunks/0"), b"pixels").expect("chunk should be written");
-
- let file = InputReport::from_file("profile", &root.join("z.json"))
- .expect("regular file should hash");
- assert_eq!(file.bytes, 8);
- let directory =
- InputReport::from_path("raster", &root).expect("directory should hash recursively");
- assert_eq!(directory.bytes, 14);
- let repeated = InputReport::from_path("raster", &root)
- .expect("unchanged directory should hash identically");
- assert_eq!(directory.sha256, repeated.sha256);
- assert_eq!(sha256_bytes(b"metadata"), file.sha256);
-
- let missing = InputReport::from_path("raster", &root.join("missing"))
- .expect_err("missing input should fail");
- assert_eq!(missing.code, "INPUT_READ_FAILED");
- }
-
- #[cfg(unix)]
- #[test]
- fn directory_input_rejects_symbolic_links() {
- use std::os::unix::fs::symlink;
-
- let temporary = tempfile::tempdir().expect("temporary directory should be created");
- let root = temporary.path().join("array.zarr");
- std::fs::create_dir(&root).expect("input directory should be created");
- std::fs::write(temporary.path().join("outside"), b"pixels")
- .expect("target should be written");
- symlink(temporary.path().join("outside"), root.join("chunk"))
- .expect("test symlink should be created");
-
- let error = InputReport::from_path("raster", &root)
- .expect_err("symlinked input should fail closed");
- assert_eq!(error.code, "INPUT_PATH_INVALID");
- assert!(error.message.contains("symbolic link"));
- }
-
- #[test]
- fn report_writers_emit_one_json_object_and_surface_sink_failures() {
- let temporary = tempfile::tempdir().expect("temporary directory should be created");
- let object_path = temporary.path().join("ann.dcm");
- std::fs::write(&object_path, b"dicom bytes").expect("output fixture should be written");
- let output = OutputReport::for_file(
- "ann",
- &object_path,
- Path::new("ann.dcm"),
- "1.2.840.10008.5.1.4.1.1.91.1",
- "2.25.1",
- "2.25.2",
- )
- .expect("output report should hash the written object");
- assert_eq!(output.bytes, 11);
-
- let mut report = SuccessReport::new("convert-geojson");
- report
- .inputs
- .push(InputReport::from_bytes("mapping", Path::new("mapping.json"), b"{}").unwrap());
- report.outputs.push(output);
- report
- .target_coverage
- .push(CoverageReport::features("ann", 1));
- report.target_coverage.push(CoverageReport::raster(2, 1));
- report.semantic_digest = "abc".into();
- report.record_verification_completion(Instant::now(), 4096);
-
- let mut stdout = Vec::new();
- assert_eq!(emit_success(&report, &mut stdout), 0);
- assert_eq!(stdout.iter().filter(|byte| **byte == b'\n').count(), 1);
- let value: serde_json::Value = serde_json::from_slice(&stdout).unwrap();
- assert_eq!(value["status"], "ok");
- assert_eq!(value["peak_tracked_heap_bytes"], 4096);
-
- let manifest = temporary.path().join("manifest.json");
- write_manifest(&manifest, &report).expect("manifest should serialize");
- assert_eq!(
- serde_json::from_slice::(&std::fs::read(manifest).unwrap()).unwrap()
- ["semantic_digest"],
- "abc"
- );
-
- let error = ConversionError::new("BAD_INPUT", "broken input");
- let mut error_stdout = Vec::new();
- let mut error_stderr = Vec::new();
- assert_eq!(
- emit_error(
- "convert-geojson",
- &error,
- &mut error_stdout,
- &mut error_stderr
- ),
- 1
- );
- assert!(String::from_utf8(error_stderr)
- .unwrap()
- .contains("broken input"));
-
- let mut usage_stdout = Vec::new();
- let mut usage_stderr = Vec::new();
- assert_eq!(
- emit_usage_error(
- "convert-raster",
- "missing profile",
- "usage text",
- &mut usage_stdout,
- &mut usage_stderr,
- ),
- 2
- );
- assert!(String::from_utf8(usage_stderr)
- .unwrap()
- .contains("usage text"));
-
- struct BrokenWriter;
- impl Write for BrokenWriter {
- fn write(&mut self, _: &[u8]) -> io::Result {
- Err(io::Error::other("sink failed"))
- }
-
- fn flush(&mut self) -> io::Result<()> {
- Ok(())
- }
- }
- assert_eq!(emit_success(&report, BrokenWriter), 1);
- assert_eq!(
- emit_error("convert-geojson", &error, BrokenWriter, io::sink()),
- 1
- );
- assert_eq!(
- emit_usage_error(
- "convert-raster",
- "missing profile",
- "usage text",
- BrokenWriter,
- io::sink(),
- ),
- 1
- );
- }
-}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe/conversion_report/checksum.rs b/apps/dicom-viewer/src/bin/annotation_probe/conversion_report/checksum.rs
deleted file mode 100644
index 34cb55e..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe/conversion_report/checksum.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use std::fs::File;
-use std::io::Read;
-use std::path::Path;
-
-use sha2::{Digest, Sha256};
-
-use super::ConversionError;
-
-pub(super) fn sha256_bytes(bytes: &[u8]) -> String {
- format!("{:x}", Sha256::digest(bytes))
-}
-
-pub(super) fn sha256_file(path: &Path) -> Result<(u64, String), ConversionError> {
- let mut file =
- File::open(path).map_err(|error| ConversionError::io("INPUT_READ_FAILED", path, error))?;
- let mut digest = Sha256::new();
- let mut buffer = [0_u8; 128 * 1024];
- let mut bytes = 0_u64;
- loop {
- let count = file
- .read(&mut buffer)
- .map_err(|error| ConversionError::io("INPUT_READ_FAILED", path, error))?;
- if count == 0 {
- break;
- }
- digest.update(&buffer[..count]);
- bytes = bytes
- .checked_add(u64::try_from(count).map_err(|_| {
- ConversionError::new("INPUT_TOO_LARGE", "input read length does not fit u64")
- })?)
- .ok_or_else(|| ConversionError::new("INPUT_TOO_LARGE", "input size overflow"))?;
- }
- Ok((bytes, format!("{:x}", digest.finalize())))
-}
-
-pub(super) fn sha256_directory(path: &Path) -> Result<(u64, String), ConversionError> {
- let mut digest = Sha256::new();
- digest.update(b"conversion-input-directory-v1\0");
- let mut bytes = 0_u64;
- let mut entry_count = 0_u64;
- hash_directory(path, path, 0, &mut entry_count, &mut bytes, &mut digest)?;
- Ok((bytes, format!("{:x}", digest.finalize())))
-}
-
-fn hash_directory(
- root: &Path,
- directory: &Path,
- depth: u16,
- entry_count: &mut u64,
- bytes: &mut u64,
- digest: &mut Sha256,
-) -> Result<(), ConversionError> {
- if depth > 128 {
- return Err(ConversionError::new(
- "INPUT_PATH_INVALID",
- format!(
- "input directory nesting exceeds 128 levels: {}",
- root.display()
- ),
- ));
- }
- let mut entries = std::fs::read_dir(directory)
- .map_err(|error| ConversionError::io("INPUT_READ_FAILED", directory, error))?
- .collect::>>()
- .map_err(|error| ConversionError::io("INPUT_READ_FAILED", directory, error))?;
- entries.sort_by_key(std::fs::DirEntry::file_name);
- for entry in entries {
- *entry_count = entry_count.checked_add(1).ok_or_else(|| {
- ConversionError::new("INPUT_TOO_LARGE", "input directory entry count overflow")
- })?;
- if *entry_count > 1_000_000 {
- return Err(ConversionError::new(
- "INPUT_TOO_LARGE",
- "input directory contains more than 1,000,000 entries",
- ));
- }
- let path = entry.path();
- let metadata = std::fs::symlink_metadata(&path)
- .map_err(|error| ConversionError::io("INPUT_READ_FAILED", &path, error))?;
- let relative = path.strip_prefix(root).map_err(|_| {
- ConversionError::new(
- "INPUT_PATH_INVALID",
- format!("input entry escaped its root: {}", path.display()),
- )
- })?;
- let relative = relative.to_str().ok_or_else(|| {
- ConversionError::new(
- "INPUT_PATH_INVALID",
- format!(
- "input directory contains a non-UTF-8 path: {}",
- path.display()
- ),
- )
- })?;
- if metadata.file_type().is_symlink() {
- return Err(ConversionError::new(
- "INPUT_PATH_INVALID",
- format!(
- "input directory contains a symbolic link: {}",
- path.display()
- ),
- ));
- }
- hash_component(
- digest,
- if metadata.is_dir() { b'D' } else { b'F' },
- relative,
- )?;
- if metadata.is_dir() {
- hash_directory(root, &path, depth + 1, entry_count, bytes, digest)?;
- } else if metadata.is_file() {
- let (length, file_digest) = sha256_file(&path)?;
- *bytes = bytes.checked_add(length).ok_or_else(|| {
- ConversionError::new("INPUT_TOO_LARGE", "input directory byte count overflow")
- })?;
- digest.update(length.to_le_bytes());
- digest.update(file_digest.as_bytes());
- } else {
- return Err(ConversionError::new(
- "INPUT_PATH_INVALID",
- format!(
- "input directory contains a special file: {}",
- path.display()
- ),
- ));
- }
- }
- Ok(())
-}
-
-fn hash_component(digest: &mut Sha256, kind: u8, relative: &str) -> Result<(), ConversionError> {
- let length = u64::try_from(relative.len()).map_err(|_| {
- ConversionError::new("INPUT_TOO_LARGE", "input path length does not fit u64")
- })?;
- digest.update([kind]);
- digest.update(length.to_le_bytes());
- digest.update(relative.as_bytes());
- Ok(())
-}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe/convert_geojson.rs b/apps/dicom-viewer/src/bin/annotation_probe/convert_geojson.rs
deleted file mode 100644
index 65cbbb5..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe/convert_geojson.rs
+++ /dev/null
@@ -1,586 +0,0 @@
-use std::ffi::OsString;
-use std::io::Write;
-use std::path::PathBuf;
-use std::time::Instant;
-
-use dicom_viewer_core::frames_viewer_producer;
-use wsi_dicom_annotations::{
- DicomAnnotationContext, DicomBundlePublication, DicomSinglePublication, PathologyAnnotationSet,
- PathologyCoordinateSpace, PathologyDicomDocuments, PathologyDicomTarget as Target,
- PathologyDocumentWriteError,
-};
-
-use crate::command::{next_path, next_utf8, set_once, USAGE};
-use crate::conversion_report::{
- emit_error, emit_success, emit_usage_error, write_manifest, ConversionError, CoverageReport,
- InputReport, OutputReport, SuccessReport,
-};
-use crate::publication::{publication_error, read_bounded_file};
-use crate::PEAK_ALLOC;
-
-const MAX_GEOJSON_BYTES: u64 = 64 * 1024 * 1024;
-const MAX_MAPPING_BYTES: u64 = 4 * 1024 * 1024;
-const ANN_STORAGE_UID: &str = "1.2.840.10008.5.1.4.1.1.91.1";
-const SEG_STORAGE_UID: &str = "1.2.840.10008.5.1.4.1.1.66.4";
-const COMPREHENSIVE_3D_SR_STORAGE_UID: &str = "1.2.840.10008.5.1.4.1.1.88.34";
-
-#[derive(Debug)]
-pub(crate) struct Arguments {
- pub(crate) source: PathBuf,
- pub(crate) canonical_source: PathBuf,
- pub(crate) mapping: PathBuf,
- pub(crate) coordinate_space: PathologyCoordinateSpace,
- pub(crate) targets: Vec,
- pub(crate) output: Option,
- pub(crate) output_dir: Option,
- pub(crate) allow_lossy: bool,
- pub(crate) input: PathBuf,
-}
-
-pub(crate) fn execute(
- arguments: impl IntoIterator
- ,
- stdout: impl Write,
- stderr: impl Write,
-) -> i32 {
- let arguments = match parse(arguments) {
- Ok(arguments) => arguments,
- Err(error) => {
- return emit_usage_error("convert-geojson", &error, USAGE, stdout, stderr);
- }
- };
- match run(&arguments) {
- Ok(report) => emit_success(&report, stdout),
- Err(error) => emit_error("convert-geojson", &error, stdout, stderr),
- }
-}
-
-pub(crate) fn parse(arguments: impl IntoIterator
- ) -> Result {
- let mut arguments = arguments.into_iter();
- let mut source = None;
- let mut canonical_source = None;
- let mut mapping = None;
- let mut coordinate_space = None;
- let mut targets = Vec::new();
- let mut output = None;
- let mut output_dir = None;
- let mut allow_lossy = false;
- let mut input = None;
- while let Some(argument) = arguments.next() {
- match argument.to_str() {
- Some("--source") => {
- let value = next_path(&mut arguments, "--source")?;
- set_once(&mut source, value, "--source")?;
- }
- Some("--canonical-source") => {
- let value = next_path(&mut arguments, "--canonical-source")?;
- set_once(&mut canonical_source, value, "--canonical-source")?;
- }
- Some("--mapping") => {
- let value = next_path(&mut arguments, "--mapping")?;
- set_once(&mut mapping, value, "--mapping")?;
- }
- Some("--coordinate-space") => {
- let value = next_utf8(&mut arguments, "--coordinate-space")?;
- let parsed = match value.as_str() {
- "level0-pixels" => PathologyCoordinateSpace::Level0Pixels,
- "source-pixels" => PathologyCoordinateSpace::SourcePixels,
- "slide-mm" => PathologyCoordinateSpace::SlideMillimeters,
- _ => {
- return Err(
- "--coordinate-space requires level0-pixels, source-pixels, or slide-mm"
- .into(),
- );
- }
- };
- set_once(&mut coordinate_space, parsed, "--coordinate-space")?;
- }
- Some("--target") => {
- let value = next_utf8(&mut arguments, "--target")?;
- let target = match value.as_str() {
- "ann" => Target::Ann,
- "seg" => Target::Seg,
- "sr" => Target::Sr,
- _ => return Err("--target requires ann, seg, or sr".into()),
- };
- if targets.contains(&target) {
- return Err(format!("duplicate --target {value}"));
- }
- targets.push(target);
- }
- Some("--output") => {
- let value = next_path(&mut arguments, "--output")?;
- set_once(&mut output, value, "--output")?;
- }
- Some("--output-dir") => {
- let value = next_path(&mut arguments, "--output-dir")?;
- set_once(&mut output_dir, value, "--output-dir")?;
- }
- Some("--allow-lossy") => allow_lossy = true,
- Some(value) if value.starts_with('-') => {
- return Err(format!("unknown option {value}"));
- }
- _ if input.is_none() => input = Some(PathBuf::from(argument)),
- _ => return Err("only one GeoJSON input path may be supplied".into()),
- }
- }
- let source = source.ok_or_else(|| "--source is required".to_string())?;
- let mapping = mapping.ok_or_else(|| "--mapping is required".to_string())?;
- let coordinate_space =
- coordinate_space.ok_or_else(|| "--coordinate-space is required".to_string())?;
- if targets.is_empty() {
- return Err("at least one --target is required".into());
- }
- validate_destination(targets.len(), output.as_ref(), output_dir.as_ref())?;
- let input = input.ok_or_else(|| "a GeoJSON input path is required".to_string())?;
- Ok(Arguments {
- canonical_source: canonical_source.unwrap_or_else(|| source.clone()),
- source,
- mapping,
- coordinate_space,
- targets,
- output,
- output_dir,
- allow_lossy,
- input,
- })
-}
-
-fn validate_destination(
- target_count: usize,
- output: Option<&PathBuf>,
- output_dir: Option<&PathBuf>,
-) -> Result<(), String> {
- match (target_count, output, output_dir) {
- (1, Some(_), None) | (2.., None, Some(_)) => Ok(()),
- (1, None, None) => Err("one target requires --output".into()),
- (2.., None, None) => Err("multiple targets require --output-dir".into()),
- (1, None, Some(_)) => Err("one target requires --output, not --output-dir".into()),
- (2.., Some(_), None) => Err("multiple targets require --output-dir, not --output".into()),
- (_, Some(_), Some(_)) => Err("--output and --output-dir are mutually exclusive".into()),
- (0, _, _) => unreachable!("target count was validated"),
- }
-}
-
-fn run(arguments: &Arguments) -> Result {
- PEAK_ALLOC.reset_peak_usage();
- let started = Instant::now();
- let source = DicomAnnotationContext::from_source(&arguments.source).map_err(|error| {
- ConversionError::new(
- "SOURCE_READ_FAILED",
- format!("source WSI could not be read: {error}"),
- )
- })?;
- let canonical_source = DicomAnnotationContext::from_source(&arguments.canonical_source)
- .map_err(|error| {
- ConversionError::new(
- "CANONICAL_SOURCE_READ_FAILED",
- format!("canonical source WSI could not be read: {error}"),
- )
- })?;
- let geojson = read_bounded_file(&arguments.input, MAX_GEOJSON_BYTES, "GeoJSON input")?;
- let mapping = read_bounded_file(&arguments.mapping, MAX_MAPPING_BYTES, "mapping profile")?;
- let annotations = PathologyAnnotationSet::from_json(
- &geojson,
- &mapping,
- &source,
- &canonical_source,
- arguments.coordinate_space,
- arguments.allow_lossy,
- )
- .map_err(ConversionError::conversion)?;
- let documents = PathologyDicomDocuments::build(&annotations, &arguments.targets)
- .map_err(ConversionError::conversion)?
- .with_producers(
- frames_viewer_producer(9101, "WSI annotations").map_err(ConversionError::conversion)?,
- frames_viewer_producer(9201, "WSI segmentations")
- .map_err(ConversionError::conversion)?,
- frames_viewer_producer(9301, "WSI measurement reports")
- .map_err(ConversionError::conversion)?,
- );
- let mut report = base_report(arguments, &annotations, &mapping, &geojson, started)?;
- let protected = [
- arguments.source.as_path(),
- arguments.canonical_source.as_path(),
- arguments.mapping.as_path(),
- arguments.input.as_path(),
- ];
- if let Some(output) = &arguments.output {
- let target = arguments.targets[0];
- let publication = DicomSinglePublication::new(output, target.file_name(), &protected)
- .map_err(publication_error)?;
- documents
- .write_and_verify(target, publication.staged_file(), &source)
- .map_err(pathology_write_error)?;
- report.outputs.push(output_report(
- &documents,
- target,
- publication.staged_file(),
- publication.destination(),
- )?);
- report.record_verification_completion(started, PEAK_ALLOC.peak_usage());
- publication.publish().map_err(publication_error)?;
- } else if let Some(output_dir) = &arguments.output_dir {
- let publication =
- DicomBundlePublication::new(output_dir, &protected).map_err(publication_error)?;
- for &target in &arguments.targets {
- let staged = publication.staging_path().join(target.file_name());
- documents
- .write_and_verify(target, &staged, &source)
- .map_err(pathology_write_error)?;
- report.outputs.push(output_report(
- &documents,
- target,
- &staged,
- &publication.destination().join(target.file_name()),
- )?);
- }
- report.record_verification_completion(started, PEAK_ALLOC.peak_usage());
- let manifest = publication.staging_path().join("manifest.json");
- write_manifest(&manifest, &report)?;
- publication
- .sync_staged_file(&manifest)
- .map_err(publication_error)?;
- publication.publish().map_err(publication_error)?;
- } else {
- return Err(ConversionError::new(
- "INVALID_DESTINATION",
- "conversion has no destination",
- ));
- }
- Ok(report)
-}
-
-fn output_report(
- documents: &PathologyDicomDocuments,
- target: Target,
- staged_path: &std::path::Path,
- report_path: &std::path::Path,
-) -> Result {
- let (sop_class_uid, sop_instance_uid, series_instance_uid) = match target {
- Target::Ann => {
- let document = documents.ann().ok_or_else(missing_document)?;
- (
- ANN_STORAGE_UID,
- document.sop_instance_uid(),
- document.series_instance_uid(),
- )
- }
- Target::Seg => {
- let document = documents.seg().ok_or_else(missing_document)?;
- (
- SEG_STORAGE_UID,
- document.sop_instance_uid(),
- document.series_instance_uid(),
- )
- }
- Target::Sr => {
- let document = documents.sr().ok_or_else(missing_document)?;
- (
- COMPREHENSIVE_3D_SR_STORAGE_UID,
- document.sop_instance_uid(),
- document.series_instance_uid(),
- )
- }
- };
- OutputReport::for_file(
- target.label(),
- staged_path,
- report_path,
- sop_class_uid,
- sop_instance_uid,
- series_instance_uid,
- )
-}
-
-fn pathology_write_error(error: PathologyDocumentWriteError) -> ConversionError {
- match error {
- PathologyDocumentWriteError::Write { source, .. } => ConversionError::output_write(source),
- PathologyDocumentWriteError::Verification { source, .. } => {
- ConversionError::new("OUTPUT_VERIFICATION_FAILED", source.to_string())
- }
- PathologyDocumentWriteError::Mismatch(_) => {
- ConversionError::new("OUTPUT_VERIFICATION_FAILED", error.to_string())
- }
- PathologyDocumentWriteError::MissingTarget => ConversionError::new(
- "INTERNAL_TARGET_MISMATCH",
- "selected target document is missing",
- ),
- }
-}
-
-fn base_report(
- arguments: &Arguments,
- annotations: &PathologyAnnotationSet,
- mapping: &[u8],
- geojson: &[u8],
- started: Instant,
-) -> Result {
- let mut report = SuccessReport::new("convert-geojson");
- report.inputs = vec![
- InputReport::from_file("source", &arguments.source)?,
- InputReport::from_file("canonical_source", &arguments.canonical_source)?,
- InputReport::from_bytes("mapping", &arguments.mapping, mapping)?,
- InputReport::from_bytes("geojson", &arguments.input, geojson)?,
- ];
- report.target_coverage = arguments
- .targets
- .iter()
- .map(|target| CoverageReport::features(target.label(), annotations.feature_count()))
- .collect();
- report.add_diagnostics(annotations.diagnostics());
- report.semantic_digest = annotations.semantic_sha256();
- report
- .timing_ms
- .insert("conversion", started.elapsed().as_secs_f64() * 1_000.0);
- Ok(report)
-}
-
-fn missing_document() -> ConversionError {
- ConversionError::new(
- "INTERNAL_TARGET_MISMATCH",
- "selected target document is missing",
- )
-}
-
-#[cfg(test)]
-mod tests {
- use dicom_dictionary_std::tags;
-
- use super::*;
- use crate::legacy::tests::write_source_wsi;
-
- #[test]
- fn output_shape_tracks_target_count() {
- let single = parse(
- [
- "--source",
- "source.dcm",
- "--mapping",
- "mapping.json",
- "--coordinate-space",
- "level0-pixels",
- "--target",
- "ann",
- "--output",
- "ann.dcm",
- "annotations.geojson",
- ]
- .map(OsString::from),
- )
- .unwrap();
- assert_eq!(single.targets, vec![Target::Ann]);
- assert_eq!(single.output, Some(PathBuf::from("ann.dcm")));
-
- let error = parse(
- [
- "--source",
- "source.dcm",
- "--mapping",
- "mapping.json",
- "--coordinate-space",
- "level0-pixels",
- "--target",
- "ann",
- "--target",
- "seg",
- "--output",
- "one.dcm",
- "annotations.geojson",
- ]
- .map(OsString::from),
- )
- .unwrap_err();
- assert_eq!(error, "multiple targets require --output-dir, not --output");
- }
-
- #[test]
- fn rejects_repeated_valued_options() {
- let error = parse(
- [
- "--source",
- "source-a.dcm",
- "--source",
- "source-b.dcm",
- "--mapping",
- "mapping.json",
- "--coordinate-space",
- "level0-pixels",
- "--target",
- "ann",
- "--output",
- "ann.dcm",
- "annotations.geojson",
- ]
- .map(OsString::from),
- )
- .unwrap_err();
-
- assert_eq!(error, "--source may be supplied only once");
- }
-
- #[test]
- fn publishes_verified_three_object_bundle_and_matching_manifest() {
- let directory = tempfile::tempdir().unwrap();
- let source = directory.path().join("source.dcm");
- let mapping = directory.path().join("mapping.json");
- let geojson = directory.path().join("annotations.geojson");
- let output = directory.path().join("bundle");
- write_source_wsi(&source);
- std::fs::write(&mapping, MAPPING).unwrap();
- std::fs::write(&geojson, GEOJSON).unwrap();
- let mut stdout = Vec::new();
- let mut stderr = Vec::new();
-
- let exit = execute(
- [
- "--source",
- source.to_str().unwrap(),
- "--mapping",
- mapping.to_str().unwrap(),
- "--coordinate-space",
- "level0-pixels",
- "--target",
- "ann",
- "--target",
- "seg",
- "--target",
- "sr",
- "--output-dir",
- output.to_str().unwrap(),
- geojson.to_str().unwrap(),
- ]
- .map(OsString::from),
- &mut stdout,
- &mut stderr,
- );
-
- assert_eq!(exit, 0, "{}", String::from_utf8_lossy(&stderr));
- assert!(stderr.is_empty());
- for name in ["ann.dcm", "seg.dcm", "sr.dcm", "manifest.json"] {
- assert!(output.join(name).is_file(), "missing {name}");
- }
- for (name, series_number) in [("ann.dcm", "9101"), ("seg.dcm", "9201"), ("sr.dcm", "9301")]
- {
- let object = dicom_object::open_file(output.join(name)).unwrap();
- assert_eq!(
- object
- .element(tags::MANUFACTURER)
- .unwrap()
- .to_str()
- .unwrap(),
- "Frames"
- );
- assert_eq!(
- object
- .element(tags::MANUFACTURER_MODEL_NAME)
- .unwrap()
- .to_str()
- .unwrap(),
- "DICOM Viewer"
- );
- assert_eq!(
- object
- .element(tags::SERIES_NUMBER)
- .unwrap()
- .to_str()
- .unwrap(),
- series_number
- );
- }
- let report: serde_json::Value = serde_json::from_slice(&stdout).unwrap();
- let manifest: serde_json::Value =
- serde_json::from_slice(&std::fs::read(output.join("manifest.json")).unwrap()).unwrap();
- assert_eq!(report, manifest);
- assert_eq!(report["status"], "ok");
- assert_eq!(report["semantic_digest"].as_str().unwrap().len(), 64);
- assert_eq!(
- report["outputs"]
- .as_array()
- .unwrap()
- .iter()
- .map(|output| output["target"].as_str().unwrap())
- .collect::>(),
- ["ann", "seg", "sr"]
- );
- }
-
- #[test]
- fn conversion_failure_does_not_publish_a_partial_bundle() {
- let directory = tempfile::tempdir().unwrap();
- let source = directory.path().join("source.dcm");
- let mapping = directory.path().join("mapping.json");
- let geojson = directory.path().join("point.geojson");
- let output = directory.path().join("bundle");
- write_source_wsi(&source);
- std::fs::write(&mapping, MAPPING).unwrap();
- std::fs::write(
- &geojson,
- br#"{"type":"FeatureCollection","features":[{"type":"Feature","id":"2.25.70","geometry":{"type":"Point","coordinates":[1,1]},"properties":{"classification":{"name":"tumor"}}}]}"#,
- )
- .unwrap();
- let mut stdout = Vec::new();
- let mut stderr = Vec::new();
-
- let exit = execute(
- [
- "--source",
- source.to_str().unwrap(),
- "--mapping",
- mapping.to_str().unwrap(),
- "--coordinate-space",
- "level0-pixels",
- "--target",
- "ann",
- "--target",
- "seg",
- "--output-dir",
- output.to_str().unwrap(),
- geojson.to_str().unwrap(),
- ]
- .map(OsString::from),
- &mut stdout,
- &mut stderr,
- );
-
- assert_eq!(exit, 1);
- assert!(!output.exists());
- assert_eq!(
- serde_json::from_slice::(&stdout).unwrap()["error"]["code"],
- "CONVERSION_FAILED"
- );
- }
-
- const MAPPING: &[u8] = br#"
- {
- "schema_version":1,
- "labels":{
- "tumor":{
- "category":{"code_value":"M-01000","coding_scheme_designator":"SRT","code_meaning":"Morphologically Altered Structure"},
- "property_type":{"code_value":"108369006","coding_scheme_designator":"SCT","code_meaning":"Neoplasm"},
- "generation_type":"MANUAL",
- "recommended_display_cielab":[40000,30000,20000],
- "segment_label":"Tumor"
- }
- },
- "measurements":{
- "Area":{
- "concept":{"code_value":"AREA","coding_scheme_designator":"99WSI","code_meaning":"Area"},
- "unit":{"code_value":"mm2","coding_scheme_designator":"UCUM","code_meaning":"square millimeter"}
- }
- },
- "sr":{
- "report_title":{"code_value":"126000","coding_scheme_designator":"DCM","code_meaning":"Imaging Measurement Report"},
- "procedures_reported":[{"code_value":"P5-09051","coding_scheme_designator":"SRT","code_meaning":"Histopathology procedure"}]
- }
- }
- "#;
-
- const GEOJSON: &[u8] = br#"
- {"type":"FeatureCollection","features":[{
- "type":"Feature",
- "id":"2.25.71",
- "geometry":{"type":"Polygon","coordinates":[[[1,1],[6,1],[6,6],[1,6],[1,1]]]},
- "properties":{"classification":{"name":"tumor"},"measurements":{"Area":25.0}}
- }]}
- "#;
-}
diff --git a/apps/dicom-viewer/src/bin/annotation_probe/convert_raster.rs b/apps/dicom-viewer/src/bin/annotation_probe/convert_raster.rs
deleted file mode 100644
index 00c1dc5..0000000
--- a/apps/dicom-viewer/src/bin/annotation_probe/convert_raster.rs
+++ /dev/null
@@ -1,598 +0,0 @@
-use std::ffi::OsString;
-use std::io::Write;
-use std::path::PathBuf;
-use std::time::Instant;
-
-use dicom_viewer_core::frames_viewer_producer;
-use wsi_dicom_annotations::{
- DicomAnnotationContext, DicomBundlePublication, DicomSinglePublication, ParametricMapDocument,
- ParametricMapInstance, ParametricMapPlan, RasterChannelSelection, RasterProfile,
-};
-
-use crate::command::{next_path, next_utf8, set_once, USAGE};
-use crate::conversion_report::{
- emit_error, emit_success, emit_usage_error, write_manifest, ConversionError, CoverageReport,
- InputReport, OutputReport, SuccessReport,
-};
-use crate::publication::{publication_error, read_bounded_file};
-use crate::PEAK_ALLOC;
-
-pub(crate) const DEFAULT_MAX_INSTANCE_BYTES: u64 = 2_000_000_000;
-const MAX_PROFILE_BYTES: u64 = 4 * 1024 * 1024;
-const PARAMETRIC_MAP_STORAGE_UID: &str = "1.2.840.10008.5.1.4.1.1.30";
-
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) enum ChannelSelection {
- One(String),
- All,
-}
-
-#[derive(Debug)]
-pub(crate) struct Arguments {
- pub(crate) source: PathBuf,
- pub(crate) canonical_source: PathBuf,
- pub(crate) profile: PathBuf,
- pub(crate) channel: Option,
- pub(crate) output: Option,
- pub(crate) output_dir: Option,
- pub(crate) max_instance_bytes: u64,
- pub(crate) input: PathBuf,
-}
-
-pub(crate) fn execute(
- arguments: impl IntoIterator
- ,
- stdout: impl Write,
- stderr: impl Write,
-) -> i32 {
- let arguments = match parse(arguments) {
- Ok(arguments) => arguments,
- Err(error) => {
- return emit_usage_error("convert-raster", &error, USAGE, stdout, stderr);
- }
- };
- match run(&arguments) {
- Ok(report) => emit_success(&report, stdout),
- Err(error) => emit_error("convert-raster", &error, stdout, stderr),
- }
-}
-
-pub(crate) fn parse(arguments: impl IntoIterator
- ) -> Result