diff --git a/crates/core/src/anatomy/layer.rs b/crates/core/src/anatomy/layer.rs new file mode 100644 index 00000000..c3f29b2a --- /dev/null +++ b/crates/core/src/anatomy/layer.rs @@ -0,0 +1,270 @@ +//! The annotation layer of one view (`packages/anatomy/src/render/layer.ts`, contract +//! `docs/ANNOTATION-RENDERING.md`): markers drawn from the document, in document order, with +//! the TypeScript attribute order (the review drawings are byte goldens of it until R5). + +use std::collections::{HashMap, HashSet}; + +use super::svg::{Element, Node}; +use crate::domain::sheet::{AnatomicalSheetDocument, Annotation, Geometry, Laterality, SheetView}; +use crate::json::js_number; + +pub const FALLBACK_COLOR: &str = "#888888"; + +/// Why a layer cannot be drawn. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LayerError { + UnknownView, +} + +/// The view of that id (first match, as `Array.find`). +pub fn find_view<'a>( + document: &'a AnatomicalSheetDocument, + view_id: &str, +) -> Option<&'a SheetView> { + document.views.iter().find(|v| v.id() == view_id) +} + +/// `renderAnnotationLayer({ document, viewId, states })`: `states` holds the ids marked +/// `data-state="current"`. +pub fn render_layer( + document: &AnatomicalSheetDocument, + view_id: &str, + states: &HashSet<&str>, +) -> Result { + let view = find_view(document, view_id).ok_or(LayerError::UnknownView)?; + let context = Context { + twin_opacity: if view.is_main() { "0.65" } else { "0.5" }, + categories: document + .categories + .iter() + .map(|c| (c.id.as_str(), c.color.as_deref())) + .collect(), + view_names: document + .views + .iter() + .map(|v| (v.id(), v.name().fr.as_str())) + .collect(), + states, + }; + let children = document + .annotations + .iter() + .filter(|a| a.view_id() == view_id) + .flat_map(|a| context.elements(a)) + .map(Node::Element) + .collect(); + let attrs = vec![ + ("data-layer", "annotations".to_owned()), + ("data-view-id", view_id.to_owned()), + ]; + Ok(Element::svg("g", attrs, children)) +} + +struct Context<'a> { + twin_opacity: &'static str, + /// Last duplicate wins, as a JavaScript `Map` built from the list. + categories: HashMap<&'a str, Option<&'a str>>, + view_names: HashMap<&'a str, &'a str>, + states: &'a HashSet<&'a str>, +} + +type Attrs = Vec<(&'static str, String)>; + +impl Context<'_> { + fn elements(&self, annotation: &Annotation) -> Vec { + let (geometry, color) = match annotation { + Annotation::Observable(a) => (a.geometry.as_ref(), a.color.as_deref()), + Annotation::DetailTrigger(a) => (a.geometry.as_ref(), a.color.as_deref()), + }; + let Some(geometry) = geometry else { + return Vec::new(); + }; + let color = color + .or_else(|| { + self.categories + .get(annotation.category_id()) + .copied() + .flatten() + }) + .unwrap_or(FALLBACK_COLOR) + .to_owned(); + let data = self.data_attrs(annotation); + let label = format!( + "{} / {}", + value_of(&data, "data-anno-name-fr"), + value_of(&data, "data-anno-name-en") + ); + if annotation.trigger().is_some() { + return vec![shape(geometry, &color, trigger_visual(), &data, &label)]; + } + match geometry { + Geometry::Circle(c) => self.point(c.cx, c.cy, c.r, &color, &data, &label), + _ => vec![shape(geometry, &color, zone_visual(), &data, &label)], + } + } + + fn data_attrs(&self, annotation: &Annotation) -> Attrs { + let mut data: Attrs = vec![("data-anno-id", annotation.id().to_owned())]; + match annotation { + Annotation::DetailTrigger(t) => { + let opened = self + .view_names + .get(t.opens_view_id.as_str()) + .copied() + .unwrap_or(""); + data.push(("data-anno-kind", "detail_trigger".to_owned())); + data.push(("data-anno-lateral", laterality(t.laterality).to_owned())); + data.push(("data-anno-opens-view", t.opens_view_id.clone())); + let names = t + .name + .as_ref() + .map_or((opened, opened), |n| (n.fr.as_str(), n.en.as_str())); + data.push(("data-anno-name-fr", names.0.to_owned())); + data.push(("data-anno-name-en", names.1.to_owned())); + } + Annotation::Observable(o) => { + let kind = match o.kind { + crate::domain::sheet::ObservableKind::Point => "point", + crate::domain::sheet::ObservableKind::Zone => "zone", + }; + data.push(("data-anno-kind", kind.to_owned())); + data.push(("data-anno-lateral", laterality(o.laterality).to_owned())); + data.push(("data-anno-name-fr", o.name.fr.clone())); + data.push(("data-anno-name-en", o.name.en.clone())); + if let Some(zone) = o.finding_zone_id.as_deref().filter(|z| !z.is_empty()) { + data.push(("data-anno-zone", zone.to_owned())); + } + if let Some(region) = o.vertebral_region_code.as_deref().filter(|r| !r.is_empty()) { + data.push(("data-anno-region", region.to_owned())); + } + } + } + if self.states.contains(annotation.id()) { + data.push(("data-state", "current".to_owned())); + } + data + } + + /// A transparent hitbox, then the visible twin on top. + fn point( + &self, + cx: f64, + cy: f64, + r: f64, + color: &str, + data: &Attrs, + label: &str, + ) -> Vec { + let mut hitbox: Attrs = vec![ + ("cx", js_number(cx)), + ("cy", js_number(cy)), + ("r", js_number(r)), + ("fill", "transparent".to_owned()), + ("pointer-events", "all".to_owned()), + ("style", "cursor:pointer".to_owned()), + ]; + hitbox.extend(data.iter().cloned()); + let mut visible: Attrs = vec![ + ("cx", js_number(cx)), + ("cy", js_number(cy)), + ("r", js_number(2.0_f64.max(r - 12.0))), + ("fill", color.to_owned()), + ("fill-opacity", self.twin_opacity.to_owned()), + ("stroke", "#000".to_owned()), + ("stroke-width", "1.5".to_owned()), + ("pointer-events", "none".to_owned()), + ]; + visible.extend(data.iter().cloned()); + vec![ + titled("circle", hitbox, label), + titled("circle", visible, label), + ] + } +} + +fn value_of<'a>(attrs: &'a Attrs, name: &str) -> &'a str { + attrs + .iter() + .find(|(k, _)| *k == name) + .map_or("", |(_, v)| v.as_str()) +} + +fn laterality(value: Laterality) -> &'static str { + match value { + Laterality::Unpaired => "unpaired", + Laterality::Bilateral => "bilateral", + Laterality::Left => "left", + Laterality::Right => "right", + } +} + +fn zone_visual() -> Attrs { + vec![ + ("fill-opacity", "0.3".to_owned()), + ("stroke-width", "2".to_owned()), + ("pointer-events", "all".to_owned()), + ("style", "cursor:pointer".to_owned()), + ] +} + +fn trigger_visual() -> Attrs { + vec![ + ("fill-opacity", "0.06".to_owned()), + ("stroke-width", "2".to_owned()), + ("stroke-dasharray", "8,4".to_owned()), + ("pointer-events", "all".to_owned()), + ("style", "cursor:pointer".to_owned()), + ("class", "detail-zone".to_owned()), + ] +} + +/// The tag and geometry attributes of a shape. +fn geometry_attrs(geometry: &Geometry) -> (&'static str, Attrs) { + match geometry { + Geometry::Circle(c) => ( + "circle", + vec![ + ("cx", js_number(c.cx)), + ("cy", js_number(c.cy)), + ("r", js_number(c.r)), + ], + ), + Geometry::Polygon(p) => { + let points: Vec = p + .points + .iter() + .map(|pt| format!("{},{}", js_number(pt.0), js_number(pt.1))) + .collect(); + ("polygon", vec![("points", points.join(" "))]) + } + Geometry::Path(path) => ("path", vec![("d", path.d.clone())]), + } +} + +/// `{ ...geometry, fill, stroke, ...visual, ...data }` with the title child. +fn shape(geometry: &Geometry, color: &str, visual: Attrs, data: &Attrs, label: &str) -> Element { + let (tag, mut attrs) = geometry_attrs(geometry); + attrs.push(("fill", color.to_owned())); + attrs.push(("stroke", color.to_owned())); + attrs.extend(visual); + attrs.extend(data.iter().cloned()); + titled(tag, attrs, label) +} + +fn titled(tag: &str, attrs: Attrs, label: &str) -> Element { + let title = Element::svg("title", Vec::new(), vec![Node::Text(label.to_owned())]); + Element::svg(tag, attrs, vec![Node::Element(title)]) +} + +/// `viewBoxOf(view)`: the view box as the four numbers, JavaScript printing. +pub fn view_box_of(view: &SheetView) -> Option { + view.view_box().map(|b| { + format!( + "{} {} {} {}", + js_number(b.min_x), + js_number(b.min_y), + js_number(b.width), + js_number(b.height) + ) + }) +} diff --git a/crates/core/src/anatomy/mod.rs b/crates/core/src/anatomy/mod.rs index 8adc87ba..2684c5c5 100644 --- a/crates/core/src/anatomy/mod.rs +++ b/crates/core/src/anatomy/mod.rs @@ -1,4 +1,5 @@ //! The anatomy core (R3): SVG reading and sanitising, the annotation layer drawn from the //! sheet document, and the composition of a view (canvas and highlight). +pub mod layer; pub mod svg; diff --git a/crates/core/tests/anatomy_layer.rs b/crates/core/tests/anatomy_layer.rs new file mode 100644 index 00000000..35b341b9 --- /dev/null +++ b/crates/core/tests/anatomy_layer.rs @@ -0,0 +1,89 @@ +//! R3 O2: the Rust annotation layer equals the TypeScript layer tree frozen by +//! `packages/anatomy/tests/r3.layer-oracles.test.ts`, attribute order included (the review +//! drawings are byte goldens of that order until R5). +#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] + +mod common; + +use std::collections::HashSet; + +use faunosteo_core::anatomy::layer::render_layer; +use faunosteo_core::anatomy::svg::{Element, Node}; +use faunosteo_core::domain::sheet::AnatomicalSheetDocument; +use serde::Deserialize; +use serde_json::{Map, Value, json}; + +/// `LayerElement` as the TypeScript writes it: tag, ordered attributes, children, text. +fn layer_value(element: &Element) -> Value { + let attrs: Map = element + .attrs + .iter() + .map(|a| (a.qname.clone(), Value::String(a.value.clone()))) + .collect(); + let mut text = None; + let mut children = Vec::new(); + for child in &element.children { + match child { + Node::Element(e) => children.push(layer_value(e)), + Node::Text(t) => text = Some(t.clone()), + } + } + let mut out = json!({ "tag": element.qname, "attrs": attrs, "children": children }); + if let Some(t) = text { + out["text"] = Value::String(t); + } + out +} + +/// Attribute names in order, at every level: what `==` on maps would not check. +fn orders(value: &Value, out: &mut Vec>) { + out.push( + value["attrs"] + .as_object() + .unwrap() + .keys() + .cloned() + .collect(), + ); + for child in value["children"].as_array().unwrap() { + orders(child, out); + } +} + +#[test] +fn every_frozen_layer_is_reproduced_with_its_attribute_order() { + let (_, oracle) = common::oracle_file("r3/layer.json"); + let (_, draft) = common::oracle_file("sheet.draft.json"); + let draft = AnatomicalSheetDocument::deserialize(&draft["output"]).unwrap(); + let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap(); + let cases = oracle["cases"].as_array().unwrap(); + assert_eq!(cases.len(), 8); + for case in cases { + let document = if case["doc"] == "draft" { + &draft + } else { + &edge + }; + let view = case["viewId"].as_str().unwrap(); + let states: HashSet<&str> = case["states"] + .as_array() + .unwrap() + .iter() + .map(|s| s.as_str().unwrap()) + .collect(); + let layer = layer_value(&render_layer(document, view, &states).unwrap()); + let label = format!("{} {} {:?}", case["doc"], view, states.len()); + assert_eq!(layer, case["layer"], "{label}"); + let (mut ours, mut theirs) = (Vec::new(), Vec::new()); + orders(&layer, &mut ours); + orders(&case["layer"], &mut theirs); + assert_eq!(ours, theirs, "{label}: attribute order"); + } +} + +#[test] +fn an_unknown_view_is_refused() { + let (_, oracle) = common::oracle_file("r3/layer.json"); + let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap(); + assert!(render_layer(&edge, "nope", &HashSet::new()).is_err()); +}