feat(nmr): add interactive 3D phase previews

crates/app/src/shot.rs

@@ -79,6 +79,7 @@ impl Theme {
 /// live in the variant so the scene list stays a plain data table.
 #[derive(Clone, Copy)]
 enum Op {
+    VolumePhase,
     Workspace(bool),
     ImportResults,
     TableDraftConflict,
@@ -306,6 +307,7 @@ fn themes_from_env() -> Vec<Theme> {
 
 fn run_op(op: Op, app: &mut PlotiumApp, ctx: &egui::Context) -> Result<(), String> {
     match op {
+        Op::VolumePhase => volume_phase_shot(app, ctx)?,
         Op::Workspace(content) => workspace_shot::setup(app, content),
         Op::ImportResults => workspace_shot::imports(app),
         Op::TableDraftConflict => table_shot::conflict(app)?,
@@ -343,6 +345,47 @@ fn run_op(op: Op, app: &mut PlotiumApp, ctx: &egui::Context) -> Result<(), Strin
     Ok(())
 }
 
+fn volume_phase_shot(app: &mut PlotiumApp, ctx: &egui::Context) -> Result<(), String> {
+    use plotium_core::state::{NmrVolumePhaseDraft, TaskDockTab};
+    *app = PlotiumApp::new_with_settings(Settings::default());
+    let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("../io/tests/fixtures/nmr/bruker-3d-qf");
+    let loaded = plotium_io::load_path(fixture).map_err(|e| e.to_string())?;
+    let (dataset, _) = plotium_core::workflow::dataset_from_acquisition(loaded.acquisition)
+        .map_err(|e| e.to_string())?;
+    let id = dataset.resource_id();
+    let action = Action::insert_dataset_with_default_canvas(
+        app,
+        dataset,
+        "Phase fixture".into(),
+        DEFAULT_CANVAS_SIZE_MM,
+    );
+    app.execute_action(action);
+    app.focus_single(0);
+    let volume = app.doc.datasets[0]
+        .as_nmr2d()
+        .and_then(|n| n.volume.as_ref())
+        .ok_or("Expected a volume")?;
+    let mut phases = volume.phases;
+    phases[2].p0_degrees = 31.0;
+    phases[2].p1_degrees = -47.0;
+    app.session.ui.nmr_volume_phase_drafts.insert(
+        id,
+        NmrVolumePhaseDraft {
+            source: Arc::downgrade(volume.source.dataset()),
+            baseline: volume.phases,
+            phases,
+            canvas_axis: 2,
+        },
+    );
+    app.session.ui.processing_task_dataset = Some(id);
+    app.session.ui.open_task_tab(TaskDockTab::Processing);
+    app.set_tool(Tool::ManualPhase);
+    app.session.ui.ribbon_tab = WorkflowTab::Process;
+    crate::ui::canvas::request_board_fit(app, ctx, FrameRef::Page(0));
+    Ok(())
+}
+
 fn xps_setup(app: &mut PlotiumApp, ctx: &egui::Context) -> Result<(), String> {
     *app = PlotiumApp::new_with_settings(Settings::default());
     let energy = (0..241)

crates/app/src/shot/scenes.rs

@@ -100,6 +100,8 @@ pub(super) const SCENES: &[Scene] = &[
     act(2, Op::Resize(1440.0, 900.0)),
     act(2, Op::PanelControls(true)),
     shot(8, "panel_controls_expanded"),
+    act(2, Op::VolumePhase),
+    shot(40, "volume_phase_preview"),
     Scene {
         settle: 4,
         op: None,

crates/app/src/ui/canvas/breadcrumb.rs

@@ -40,6 +40,11 @@ pub(crate) fn canvas_breadcrumb(app: &mut PlotiumApp, ci: usize, ui: &mut Ui) {
             ui.small(phase);
         }
     });
+    if app.session.active_canvas == Some(ci)
+        && let Some(feedback) = crate::ui::nmr_phase_preview::canvas_feedback(app, ui.ctx())
+    {
+        ui.small(feedback);
+    }
     ui.add_space(2.0);
     match clicked {
         Some(BreadcrumbTarget::Canvas) => app.exit_panel_scope(),
@@ -63,6 +68,32 @@ fn phase_target(app: &PlotiumApp, ci: usize) -> String {
         return "Phase · Select a plot of the chosen spectrum".into();
     }
     let axis = dataset.active_phase_axis(app.session.ui.phase_axis);
+    if let Some(volume) = dataset.as_nmr2d().and_then(|n| n.volume.as_ref()) {
+        let id = dataset.resource_id();
+        if let Some(draft) = app.session.ui.nmr_volume_phase_drafts.get(&id) {
+            let a = draft.canvas_axis;
+            let nucleus = volume.source.axes()[a]
+                .nucleus
+                .as_deref()
+                .unwrap_or("unknown");
+            return format!(
+                "Phase · {} · F{} · {nucleus} · {} · Apply: entire volume",
+                dataset.display_name(),
+                a + 1,
+                if a == volume.fixed_axis {
+                    "fixed (numeric controls)"
+                } else if axis == PhaseAxis::F1 {
+                    "vertical"
+                } else {
+                    "horizontal"
+                }
+            );
+        }
+        return format!(
+            "Phase · {} · choose an acquisition axis",
+            dataset.display_name()
+        );
+    }
     let (nucleus, scope) = match dataset {
         Dataset::Nmr(nmr) => (nmr.data.axes().first(), "whole spectrum"),
         Dataset::Nmr2D(nmr) if nmr.volume.is_none() => (

crates/app/src/ui/canvas/image_painting.rs

@@ -78,7 +78,29 @@ pub(super) fn paint_document(
     painter: &egui::Painter,
 ) {
     let canvas = &app.doc.canvases[ci];
-    let document = canvas_document(app, ci);
+    let mut document = canvas_document(app, ci);
+    let previews: Vec<_> = canvas
+        .objects
+        .iter()
+        .map(|object| {
+            let plot = object.plot()?;
+            let preview = super::super::nmr_phase_preview::contours(
+                app,
+                painter.ctx(),
+                object.dataset()?,
+                object.id,
+            )?;
+            let mut figure = plot.figure().clone();
+            figure.contours = preview.contours.clone();
+            Some(figure)
+        })
+        .collect();
+    for (item, preview) in document.items.iter_mut().zip(&previews) {
+        if let (plotium_render::DocumentItem::Plot(plot), Some(figure)) = (item, preview) {
+            plot.figure = figure;
+            plot.geometry_generation = None;
+        }
+    }
     let zoom = app.session.board.zoom;
     let bp = canvas.board_pos;
     let detail = workspace_render_detail(painter.ctx(), painter.ctx().input(|input| input.time));

crates/app/src/ui/canvas/mod.rs

@@ -58,7 +58,8 @@ mod panel_notes;
 mod panel_selection;
 mod peaks;
 mod peaks3d;
-mod phase;
+pub(super) mod phase;
+pub(super) use phase::cancel_volume_drag;
 mod plot_annotation_menu;
 mod plot_labels;
 mod plot_marks;
@@ -145,7 +146,10 @@ pub fn render_central(app: &mut PlotiumApp, ui: &mut Ui) {
         return;
     };
     canvas_breadcrumb(app, ci, ui);
+    phase::phase_axis_picker(app, ui);
     super::nmr_volume::navigation(app, ui);
+    super::nmr_phase_preview::update(app, ui.ctx());
+    phase::validate_volume_drag(app, ui.ctx());
     let avail = ui.available_rect_before_wrap();
     let (resp, painter) = ui.allocate_painter(avail.size(), Sense::click_and_drag());
     let geometry = super::workspace_geometry(app, resp.rect, ui.ctx());
@@ -182,6 +186,8 @@ pub fn render_central(app: &mut PlotiumApp, ui: &mut Ui) {
     // `dispatch_frame_gesture` may have switched the active frame.
     let ci = app.session.active_canvas.unwrap_or(ci);
 
+    super::phase_context::reconcile(app, ui.ctx());
+
     // Processing direct manipulation must update the document before its plots
     // are painted, so the changed spectrum is visible in this same frame.
     if pointer_owned && app.session.tool == Tool::ManualPhase {
@@ -342,7 +348,7 @@ pub fn render_central(app: &mut PlotiumApp, ui: &mut Ui) {
                 if super::nmr_volume::phase_target(app)
                     == Some(app.doc.datasets[di].resource_id()) =>
             {
-                let axis = app.doc.datasets[di].active_phase_axis(app.session.ui.phase_axis);
+                let axis = phase::selected_phase_axis(app, di);
                 if let Some(pivot_ppm) = displayed_phase_pivot_ppm(app, di, axis) {
                     let fig = &app.doc.canvases[ci]
                         .object(object_id)