SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Point clouds: colour and filter by any property the file carries (#8816) (#8819)
Mario Geiger332f96c26a30
diff --git a/assets/locales/pending/point-cloud-stages.json b/assets/locales/pending/point-cloud-stages.jsonnew file mode 100644index 0000000000..af70cfb6c5--- /dev/null+++ b/assets/locales/pending/point-cloud-stages.json@@ -0,0 +1,58 @@+{+ "en": {+ "ui.point_cloud_add_filter": "Add filter…",+ "ui.point_cloud_filter_by": "Filter by",+ "ui.point_cloud_legend_filter": "Shown and hidden in the legend above",+ "ui.point_cloud_pause": "Pause",+ "ui.point_cloud_play": "Play"+ },+ "fr": {+ "ui.point_cloud_add_filter": "Ajouter un filtre…",+ "ui.point_cloud_filter_by": "Filtrer par",+ "ui.point_cloud_legend_filter": "Affichées et masquées dans la légende ci-dessus",+ "ui.point_cloud_pause": "Pause",+ "ui.point_cloud_play": "Lire"+ },+ "de": {+ "ui.point_cloud_add_filter": "Filter hinzufügen…",+ "ui.point_cloud_filter_by": "Filtern nach",+ "ui.point_cloud_legend_filter": "In der Legende oben ein- und ausgeblendet",+ "ui.point_cloud_pause": "Pause",+ "ui.point_cloud_play": "Abspielen"+ },+ "ja": {+ "ui.point_cloud_add_filter": "フィルターを追加…",+ "ui.point_cloud_filter_by": "フィルター",+ "ui.point_cloud_legend_filter": "上の凡例で表示・非表示を切り替え",+ "ui.point_cloud_pause": "一時停止",+ "ui.point_cloud_play": "再生"+ },+ "zh": {+ "ui.point_cloud_add_filter": "添加筛选…",+ "ui.point_cloud_filter_by": "筛选依据",+ "ui.point_cloud_legend_filter": "在上方图例中显示或隐藏",+ "ui.point_cloud_pause": "暂停",+ "ui.point_cloud_play": "播放"+ },+ "ar": {+ "ui.point_cloud_add_filter": "إضافة مرشح…",+ "ui.point_cloud_filter_by": "التصفية حسب",+ "ui.point_cloud_legend_filter": "تُعرض وتُخفى في وسيلة الإيضاح أعلاه",+ "ui.point_cloud_pause": "إيقاف مؤقت",+ "ui.point_cloud_play": "تشغيل"+ },+ "he": {+ "ui.point_cloud_add_filter": "הוספת מסנן…",+ "ui.point_cloud_filter_by": "סינון לפי",+ "ui.point_cloud_legend_filter": "מוצגים ומוסתרים במקרא שלמעלה",+ "ui.point_cloud_pause": "השהיה",+ "ui.point_cloud_play": "הפעלה"+ },+ "vi": {+ "ui.point_cloud_add_filter": "Thêm bộ lọc…",+ "ui.point_cloud_filter_by": "Lọc theo",+ "ui.point_cloud_legend_filter": "Hiện và ẩn trong chú giải ở trên",+ "ui.point_cloud_pause": "Tạm dừng",+ "ui.point_cloud_play": "Phát"+ }+}diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 3e323724e9..09c91816a6 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -697,38 +697,96 @@ fn fs_line_all(i: LOut) -> @location(0) vec4<f32> {return out_color(i.c);}-// Point clouds: each point is a round dot a few pixels across, facing the screen, depth-tested-// and written like the model's faces, so the model hides the points behind it and they hide it.-// The colour's alpha carries the dot's size (eighths of a pixel).+// Point clouds (`view/clouds.rs`): each point is a round dot a few pixels across, facing the+// screen, depth-tested and written like the model's faces, so the model hides the points behind+// it and they hide it. The cloud's style colours them by their own colour, a ramp or a palette,+// and shows only those whose filtered values lie in its ranges or sets.++struct Cloud {+ style: vec4<f32>, // x: colour (0 own, 1 ramp, 2 palette), y: dot size (px), z, w: ramp range+ filters: array<vec4<f32>, 4>, // x: kind (0 off, 1 range y…z, 2 whole values y + i for the bits i of w)+};+@group(1) @binding(3) var<uniform> cloud: Cloud;-struct POut {+struct CIn {+ @location(0) p: vec3<f32>,+ @location(1) v: f32,+ @location(2) f: vec4<f32>,+ @location(3) rgb: vec4<f32>,+};++struct COut {@builtin(position) pos: vec4<f32>,- @location(0) c: vec4<f32>,- @location(1) wp: vec3<f32>,- @location(2) at: vec2<f32>,+ @location(0) wp: vec3<f32>,+ @location(1) v: f32,+ @location(2) f: vec4<f32>,+ @location(3) rgb: vec3<f32>,+ @location(4) at: vec2<f32>, // the place on its disc+ @location(5) @interpolate(flat) has: u32,};@vertex-fn vs_point(@builtin(vertex_index) vi: u32, @location(0) p: vec3<f32>, @location(1) c: vec4<f32>) -> POut {+fn vs_cloud_dot(@builtin(vertex_index) vi: u32, i: CIn) -> COut {var xs = array<f32, 6>(-1.0, 1.0, 1.0, -1.0, 1.0, -1.0);var ys = array<f32, 6>(-1.0, -1.0, 1.0, -1.0, 1.0, 1.0);let at = vec2<f32>(xs[vi], ys[vi]);- let size = max(c.a * 255.0 / 8.0, 1.0);- let centre = u.vp * vec4<f32>(p, 1.0);- let half = u.screen.xy * 0.5;- var o: POut;- o.pos = vec4<f32>(centre.xy + at * size * 0.5 / half * centre.w, centre.z, centre.w);+ let size = max(cloud.style.y, 1.0);+ let centre = u.vp * vec4<f32>(i.p, 1.0);+ var o: COut;+ o.pos = vec4<f32>(centre.xy + at * size / u.screen.xy * centre.w, centre.z, centre.w);// Behind the eye: nothing.if (near_z(centre) < 0.0) { o.pos = vec4<f32>(0.0, 0.0, 0.0, -1.0); }- o.c = vec4<f32>(c.rgb, 1.0);- o.wp = p;+ o.wp = i.p;+ o.v = i.v;+ o.f = i.f;+ o.rgb = i.rgb.rgb;+ o.has = u32(round(i.rgb.a * 255.0));// Dots under two pixels are squares: a disc that small loses its centre pixel.o.at = at * select(1.0, 0.0, size < 2.0);return o;}+/// Whether filter `f` keeps the value `v`.+fn cloud_keeps(f: vec4<f32>, v: f32) -> bool {+ if (f.x < 0.5) { return true; }+ if (f.x < 1.5) { return v >= f.y && v <= f.z; }+ let k = i32(round(v)) - i32(round(f.y));+ return k >= 0 && k < 32 && ((bitcast<u32>(f.w) >> u32(k)) & 1u) != 0u;+}++fn cloud_ramp(t: f32) -> vec3<f32> {+ var stops = array<vec3<f32>, 5>(+ vec3<f32>(40.0, 70.0, 200.0), vec3<f32>(30.0, 170.0, 230.0), vec3<f32>(60.0, 200.0, 90.0),+ vec3<f32>(240.0, 220.0, 60.0), vec3<f32>(230.0, 70.0, 50.0));+ let k = clamp(t, 0.0, 1.0) * 4.0;+ let j = min(u32(k), 3u);+ return mix(stops[j], stops[j + 1u], k - f32(j)) / 255.0;+}++fn cloud_palette(v: f32) -> vec3<f32> {+ var colours = array<vec3<f32>, 10>(+ vec3<f32>(240.0, 140.0, 40.0), vec3<f32>(245.0, 205.0, 65.0), vec3<f32>(230.0, 65.0, 65.0),+ vec3<f32>(165.0, 75.0, 190.0), vec3<f32>(65.0, 190.0, 115.0), vec3<f32>(75.0, 150.0, 220.0),+ vec3<f32>(240.0, 120.0, 180.0), vec3<f32>(140.0, 105.0, 75.0), vec3<f32>(120.0, 215.0, 215.0),+ vec3<f32>(190.0, 190.0, 80.0));+ if (v < -0.5) { return vec3<f32>(150.0, 160.0, 176.0) / 255.0; }+ return colours[u32(round(v)) % 10u] / 255.0;+}++@fragment-fn fs_point(i: POut) -> @location(0) vec4<f32> {- if (clipped(i.wp) || dot(i.at, i.at) > 1.0) { discard; }- return out_color(i.c);+fn fs_cloud(o: COut) -> @location(0) vec4<f32> {+ var out = clipped(o.wp) || dot(o.at, o.at) > 1.0;+ for (var k = 0u; k < 4u; k++) {+ out = out || (((o.has >> k) & 1u) != 0u && !cloud_keeps(cloud.filters[k], o.f[k]));+ }+ if (out) { discard; }+ var c = o.rgb;+ let mode = cloud.style.x;+ if ((o.has & 16u) != 0u && mode > 1.5) {+ c = cloud_palette(o.v);+ } else if ((o.has & 16u) != 0u && mode > 0.5) {+ c = cloud_ramp((o.v - cloud.style.z) / max(cloud.style.w - cloud.style.z, 1e-12));+ }+ return out_color(vec4<f32>(c, 1.0));}diff --git a/crates/doc/src/format/pending/point-cloud-properties.rs b/crates/doc/src/format/pending/point-cloud-properties.rsnew file mode 100644index 0000000000..ea8097212a--- /dev/null+++ b/crates/doc/src/format/pending/point-cloud-properties.rs@@ -0,0 +1,7 @@+//! A point cloud keeps the other properties its file gives its points (#8816): named numbers per+//! point in `complex` (`columns`, each whole-numbered or not, and the `names` a whole-numbered one's+//! values carry), and it can be coloured by one of them (`color_by: "property"`, with+//! `color_property`, the ramp over `height_range`) and shown only where `filters` keep it (ranges,+//! or sets of named values). Older designs need no transformation: their clouds have no other+//! properties and no filters. The last release refuses a design saved with this (the newer format+//! number) instead of opening its clouds without their properties, colouring and filters.diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 1d2d75dc29..9fd2405d12 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -53,6 +53,8 @@ pub mod physical_material;mod piece_names;pub mod pipe_thread_catalog;pub mod point_cloud;+mod point_cloud_complex;+pub mod point_cloud_distribution;mod points;mod profile_refs;pub mod progress;diff --git a/crates/doc/src/point_cloud.rs b/crates/doc/src/point_cloud.rsindex 25ad4e1768..3e4cb21b61 100644--- a/crates/doc/src/point_cloud.rs+++ b/crates/doc/src/point_cloud.rs@@ -11,6 +11,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};use solidcraft_geom::Vec3;use crate::canvas::{base64_decode, base64_encode};+pub use crate::point_cloud_complex::{Column, Complex, Filter, Floats, Keep, MAX_COLUMNS, MAX_NAMES, Names};use crate::{DocError, IDENTITY, Mat, Result};/// Most points one cloud may hold.@@ -19,6 +20,10 @@ pub const MAX_POINTS: usize = 20_000_000;pub const MAX_COORD: f64 = 1e9;/// Point sizes on screen (pixels).pub const POINT_SIZE: std::ops::RangeInclusive<f64> = 0.5..=16.0;+/// Most filters on one cloud.+pub const MAX_FILTERS: usize = 8;+/// Properties every cloud has besides its file's: the coordinates in the design.+pub const COORDINATES: [&str; 3] = ["x", "y", "z"];/// Length units a point cloud file may be in, and millimetres per unit.pub const UNITS: [(&str, f64); 5] = [("mm", 1.0), ("cm", 10.0), ("m", 1000.0), ("in", 25.4), ("ft", 304.8)];@@ -65,6 +70,24 @@ pub struct PointCloud {pub height_range: Option<[f64; 2]>,#[serde(default = "yes")]pub visible: bool,+ /// The file's other properties of the points.+ #[serde(default, skip_serializing_if = "Complex::is_empty")]+ pub complex: Complex,+ /// The property `color_by: property` colours by.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub color_property: Option<String>,+ /// Only the points every filter keeps are shown.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub filters: Vec<Filter>,+}++/// Where a property's values come from.+#[derive(Clone, Copy, Debug)]+pub enum Source<'a> {+ /// A coordinate of each point in the design.+ Coordinate(usize),+ /// A column of the file: each point's.+ Column(&'a [f32]),}/// How a cloud's points are coloured.@@ -78,6 +101,8 @@ pub enum ColorBy {Single,/// By height in the design: blue low, through cyan, green and yellow, to red high.Height,+ /// By `color_property`: the height ramp over its range or, for whole numbers, a palette.+ Property,}impl ColorBy {@@ -90,6 +115,7 @@ impl ColorBy {"file" => Some(ColorBy::File),"single" => Some(ColorBy::Single),"height" => Some(ColorBy::Height),+ "property" => Some(ColorBy::Property),_ => None,}}@@ -98,6 +124,7 @@ impl ColorBy {ColorBy::File => "file",ColorBy::Single => "single",ColorBy::Height => "height",+ ColorBy::Property => "property",}}}@@ -120,6 +147,27 @@ pub fn height_ramp(t: f64) -> [u8; 3] {std::array::from_fn(|c| (a[c] * (1.0 - f) + b[c] * f).round().clamp(0.0, 255.0) as u8)}+/// Colours of whole-number labels, the label modulo their count; negative labels are grey.+pub const PALETTE: [[u8; 3]; 10] = [+ [240, 140, 40],+ [245, 205, 65],+ [230, 65, 65],+ [165, 75, 190],+ [65, 190, 115],+ [75, 150, 220],+ [240, 120, 180],+ [140, 105, 75],+ [120, 215, 215],+ [190, 190, 80],+];++pub fn label_color(v: f64) -> [u8; 3] {+ if !(v.is_finite() && v >= 0.0) {+ return PLAIN.map(byte);+ }+ PALETTE[(v.round() as usize) % PALETTE.len()]+}+/// A colour channel (0..1) as a byte.pub fn byte(v: f32) -> u8 {(v.clamp(0.0, 1.0) * 255.0).round() as u8@@ -182,15 +230,57 @@ impl PointCloud {let (lo, hi) = (at(HEIGHT_TAIL)?, at(1.0 - HEIGHT_TAIL)?);Some(if hi - lo > 1e-9 { [lo, hi] } else { [lo - 0.5, lo + 0.5] })}+ /// The property colours come from: a column, or a coordinate (`z` for the height ramp).+ pub fn colored_property(&self) -> Option<&str> {+ match self.color_by {+ ColorBy::Height => Some("z"),+ ColorBy::Property => self.color_property.as_deref(),+ ColorBy::File | ColorBy::Single => None,+ }+ }+ /// Where the values of `name` are: a coordinate of each point or a column of the file.+ pub fn source(&self, name: &str) -> Option<Source<'_>> {+ if let Some(k) = COORDINATES.iter().position(|n| *n == name) {+ return Some(Source::Coordinate(k));+ }+ self.complex.column(name).map(|col| Source::Column(&col.values.0))+ }+ /// Every property the cloud can be coloured and filtered by: its coordinates, then its columns.+ pub fn property_names(&self) -> impl Iterator<Item = &str> {+ COORDINATES.into_iter().chain(self.complex.columns.iter().map(|c| c.name.as_str()))+ }+ /// The smallest and largest value of a property, the coordinates in the design.+ pub fn span(&self, property: &str) -> Option<[f64; 2]> {+ if let Some(span) = self.complex.span(property) {+ return Some(span);+ }+ let k = COORDINATES.iter().position(|n| *n == property)?;+ let v = self.world_corners()?.map(|p| [p.x, p.y, p.z][k]);+ Some([v.iter().copied().fold(f64::INFINITY, f64::min), v.iter().copied().fold(f64::NEG_INFINITY, f64::max)])+ }+ /// The ramp's range as far as it can be told without the elements: the one set, or else the+ /// coloured property's span within every range filtering it. The automatic range colouring+ /// by a property is exactly what the filters keep+ /// ([`crate::point_cloud_distribution::color_range`]), which this bounds.+ pub fn color_range(&self) -> Option<[f64; 2]> {+ if self.height_range.is_some() {+ return self.height_range;+ }+ let property = self.colored_property()?;+ let span = if self.color_by == ColorBy::Height { self.auto_height_range() } else { self.span(property) }?;+ let shown =+ self.filters.iter().filter(|f| f.property == property).filter_map(Filter::range).fold(span, |[lo, hi], [a, b]| [lo.max(a), hi.min(b)]);+ Some(if shown[0] <= shown[1] { crate::point_cloud_distribution::ramp_range(shown) } else { span })+ }/// The heights the height ramp runs between now: the cloud's own, else the automatic ones.pub fn height_range_now(&self) -> Option<[f64; 2]> {self.height_range.or_else(|| self.auto_height_range())}- /// The colour of each point (by index) as the cloud is shown.- pub fn shade(&self) -> impl Fn(usize) -> [u8; 3] + '_ {+ /// The colour of each point (by index) as the cloud is shown, the ramp over `range`.+ pub fn shade(&self, range: Option<[f64; 2]>) -> impl Fn(usize) -> [u8; 3] + '_ {let single = self.color.unwrap_or(PLAIN).map(byte);let plain = PLAIN.map(byte);- let range = if self.color_by == ColorBy::Height { self.height_range_now() } else { None };+ let column = self.color_property.as_deref().and_then(|n| self.complex.column(n));move |i| match self.color_by {ColorBy::File => self.colors.get(i).unwrap_or(plain),ColorBy::Single => single,@@ -198,6 +288,14 @@ impl PointCloud {(Some([lo, hi]), Some(p)) => height_ramp((self.world_z(p) - lo) / (hi - lo)),_ => plain,},+ ColorBy::Property => match (column, column.and_then(|c| c.values.0.get(i))) {+ (Some(c), Some(v)) if c.integer => label_color(f64::from(*v)),+ (Some(_), Some(v)) => match range {+ Some([lo, hi]) if hi > lo => height_ramp((f64::from(*v) - lo) / (hi - lo)),+ _ => plain,+ },+ _ => plain,+ },}}/// The corners of the box around the points, placed in the design (mm).@@ -240,6 +338,18 @@ impl PointCloud {if !rigid(&self.transform) {return bad("its placement is not a rigid move");}+ self.complex.check(self.points.len())?;+ if self.filters.len() > MAX_FILTERS+ || self.filters.iter().any(|f| match &f.keep {+ Keep::Range { range: [lo, hi] } => !(lo.is_finite() && hi.is_finite() && lo <= hi),+ Keep::Values { values } => values.len() > MAX_NAMES,+ })+ {+ return bad("its filters are not ranges, lowest first");+ }+ if self.color_by == ColorBy::Property && self.color_property.is_none() {+ return bad("it is coloured by a property without naming it");+ }Ok(())}}@@ -422,6 +532,9 @@ mod tests {color: None,height_range: None,visible: true,+ complex: Complex::default(),+ color_property: None,+ filters: Vec::new(),}}@@ -443,6 +556,20 @@ mod tests {assert_eq!((unit_scale("M"), unit_scale("yd")), (Some(1000.0), None));}+ #[test]+ fn the_ramp_spans_what_is_shown_unless_set() {+ let mut c = cloud(vec![0.0; 9], Vec::new());+ c.complex.columns.push(Column { name: "t".into(), integer: false, values: Floats(vec![0.0, 10.0, 20.0].into()) });+ (c.color_by, c.color_property) = (ColorBy::Property, Some("t".into()));+ assert_eq!(c.color_range(), Some([0.0, 20.0]), "the whole span");+ c.filters = vec![Filter { property: "t".into(), keep: Keep::Range { range: [5.0, 50.0] } }];+ assert_eq!(c.color_range(), Some([5.0, 20.0]), "the span within the filter");+ c.filters.push(Filter { property: "layer".into(), keep: Keep::Range { range: [0.0, 1.0] } });+ assert_eq!(c.color_range(), Some([5.0, 20.0]), "another property's filter changes nothing");+ c.height_range = Some([1.0, 2.0]);+ assert_eq!(c.color_range(), Some([1.0, 2.0]), "a range set is kept");+ }+#[test]fn damaged_clouds_are_refused() {// Not whole points, not finite, not base64.@@ -474,26 +601,26 @@ mod tests {let colors: Vec<u8> = (0..102).flat_map(|i| [i as u8, 7, 9]).collect();let mut c = cloud(values, colors);c.origin = Vec3::ZERO;- assert_eq!(c.shade()(3), [3, 7, 9], "the file's colours");+ assert_eq!(c.shade(c.color_range())(3), [3, 7, 9], "the file's colours");c.colors = Colors::default();- assert_eq!(c.shade()(3), PLAIN.map(byte), "none: plain");+ assert_eq!(c.shade(c.color_range())(3), PLAIN.map(byte), "none: plain");c.color_by = ColorBy::Single;c.color = Some([1.0, 0.5, 0.0]);- assert_eq!(c.shade()(50), [255, 128, 0]);+ assert_eq!(c.shade(c.color_range())(50), [255, 128, 0]);// The stray point doesn't stretch the automatic range.c.color_by = ColorBy::Height;// 102 points: the 2nd and the 99th (of 0…101) once sorted.assert_eq!(c.auto_height_range(), Some([2.0, 99.0]));{- let shade = c.shade();+ let shade = c.shade(c.color_range());assert_eq!((shade(0), shade(100), shade(101)), (height_ramp(0.0), height_ramp(1.0), height_ramp(1.0)));assert_eq!(shade(50), height_ramp(48.0 / 97.0));}// A range of its own; moved up 100 mm, everything is above it.c.height_range = Some([0.0, 50.0]);- assert_eq!(c.shade()(25), height_ramp(0.5));+ assert_eq!(c.shade(c.color_range())(25), height_ramp(0.5));c.transform[3][2] = 100.0;- assert_eq!(c.shade()(0), height_ramp(1.0));+ assert_eq!(c.shade(c.color_range())(0), height_ramp(1.0));assert_eq!((height_ramp(0.0), height_ramp(1.0), height_ramp(f64::NAN)), ([40, 70, 200], [230, 70, 50], [40, 70, 200]));let back: PointCloud = serde_json::from_str(&serde_json::to_string(&c).unwrap()).unwrap();assert_eq!(back, c);diff --git a/crates/doc/src/point_cloud_complex.rs b/crates/doc/src/point_cloud_complex.rsnew file mode 100644index 0000000000..6635996c72--- /dev/null+++ b/crates/doc/src/point_cloud_complex.rs@@ -0,0 +1,215 @@+//! What a point cloud holds besides its points' places and colours: named numbers on its points+//! (a PLY file's other vertex properties), to colour the cloud by and to filter it with. Whole+//! numbers may have names (`role: 0 outer wall, 1 inner wall` in a PLY file's comments): they+//! are labels, filtered by a set of values rather than a range.++use std::sync::Arc;++use serde::{Deserialize, Deserializer, Serialize, Serializer};++use crate::canvas::{base64_decode, base64_encode};+use crate::point_cloud::MAX_POINTS;+use crate::{DocError, Result};++/// Most named numbers per point.+pub const MAX_COLUMNS: usize = 64;++/// One named number on every point.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Column {+ pub name: String,+ /// Whole numbers (labels, counts): coloured by a palette rather than a ramp.+ #[serde(default)]+ pub integer: bool,+ pub values: Floats,+}++impl Column {+ /// The smallest and largest finite value.+ pub fn span(&self) -> Option<[f64; 2]> {+ let mut it = self.values.0.iter().filter(|v| v.is_finite()).map(|v| f64::from(*v));+ let first = it.next()?;+ Some(it.fold([first, first], |[lo, hi], v| [lo.min(v), hi.max(v)]))+ }+}++/// The complex a cloud's points form: named numbers on the points, and the names of+/// whole-numbered ones. Points alone are a complex of dimension 0.+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct Complex {+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub columns: Vec<Column>,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub names: Vec<Names>,+}++/// Most named values of one label.+pub const MAX_NAMES: usize = 256;++/// The names of a label's values.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Names {+ pub property: String,+ pub values: Vec<(i32, String)>,+}++impl Names {+ /// `property: 0 name, 1 another name, -1 none`, or `None` for any other text.+ pub fn parse(text: &str) -> Option<Names> {+ let (property, rest) = text.split_once(':')?;+ let property = property.trim();+ if property.is_empty() || property.contains(char::is_whitespace) {+ return None;+ }+ let values = rest+ .split(',')+ .map(|entry| {+ let (value, name) = entry.trim().split_once(' ')?;+ let name = name.trim();+ (!name.is_empty()).then(|| Some((value.parse::<i32>().ok()?, name.to_string()))).flatten()+ })+ .collect::<Option<Vec<_>>>()?;+ (!values.is_empty() && values.len() <= MAX_NAMES).then(|| Names { property: property.to_string(), values })+ }+ pub fn name(&self, value: i32) -> Option<&str> {+ self.values.iter().find(|(v, _)| *v == value).map(|(_, n)| n.as_str())+ }+}++impl Complex {+ pub fn is_empty(&self) -> bool {+ self.columns.is_empty() && self.names.is_empty()+ }+ /// The column named `name`.+ pub fn column(&self, name: &str) -> Option<&Column> {+ self.columns.iter().find(|c| c.name == name)+ }+ /// The smallest and largest value named `name`.+ pub fn span(&self, name: &str) -> Option<[f64; 2]> {+ self.column(name).and_then(Column::span)+ }+ /// The names of `property`'s values, when it is a label.+ pub fn names(&self, property: &str) -> Option<&Names> {+ self.names.iter().find(|n| n.property == property).filter(|_| self.integer(property))+ }+ /// Whether the values named `name` are whole numbers.+ pub fn integer(&self, name: &str) -> bool {+ self.column(name).is_some_and(|c| c.integer)+ }+ /// Every column has one number per point, the cloud having `points` points.+ pub fn check(&self, points: usize) -> Result<()> {+ let bad = |what: String| Err(DocError::Invalid(format!("point cloud properties: {what}")));+ if self.columns.len() > MAX_COLUMNS {+ return bad("too many properties".into());+ }+ for c in &self.columns {+ if c.values.0.len() != points {+ return bad(format!("property `{}` does not have one number per point", c.name));+ }+ }+ if self.names.len() > MAX_COLUMNS || self.names.iter().any(|n| n.values.is_empty() || n.values.len() > MAX_NAMES) {+ return bad("too many named values".into());+ }+ Ok(())+ }+}++/// Which points are shown: those whose property lies in a range (both ends included), or, for a+/// label, is one of a set of values.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Filter {+ pub property: String,+ #[serde(flatten)]+ pub keep: Keep,+}++/// The values a filter keeps.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(untagged)]+pub enum Keep {+ Range { range: [f64; 2] },+ Values { values: Vec<i32> },+}++impl Filter {+ pub fn range(&self) -> Option<[f64; 2]> {+ match &self.keep {+ Keep::Range { range } => Some(*range),+ Keep::Values { .. } => None,+ }+ }+}++/// Numbers, shared between copies of the design.+#[derive(Clone, Debug, Default)]+pub struct Floats(pub Arc<[f32]>);++impl PartialEq for Floats {+ fn eq(&self, other: &Self) -> bool {+ Arc::ptr_eq(&self.0, &other.0) || self.0.iter().map(|v| v.to_bits()).eq(other.0.iter().map(|v| v.to_bits()))+ }+}++/// The largest base64 text of `n` four-byte words.+fn base64_len(n: usize) -> usize {+ (n * 4).div_ceil(3) * 4 + 16+}++fn words<'de, D: Deserializer<'de>>(d: D, max: usize) -> std::result::Result<Vec<[u8; 4]>, D::Error> {+ let s = String::deserialize(d)?;+ if s.len() > base64_len(max) {+ return Err(serde::de::Error::custom("too many numbers"));+ }+ let b = base64_decode(&s).ok_or_else(|| serde::de::Error::custom("numbers are not base64"))?;+ if !b.len().is_multiple_of(4) {+ return Err(serde::de::Error::custom("numbers are not whole four-byte words"));+ }+ Ok(b.as_chunks::<4>().0.to_vec())+}++impl Serialize for Floats {+ fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {+ s.serialize_str(&base64_encode(&self.0.iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<u8>>()))+ }+}++impl<'de> Deserialize<'de> for Floats {+ fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {+ Ok(Floats(words(d, MAX_POINTS)?.into_iter().map(f32::from_le_bytes).collect()))+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn properties_round_trip_and_are_checked_against_the_points() {+ let complex = Complex {+ columns: vec![+ Column { name: "t".into(), integer: false, values: Floats(vec![0.0, 0.5, 1.0].into()) },+ Column { name: "role".into(), integer: true, values: Floats(vec![0.0, 4.0, 4.0].into()) },+ ],+ names: Vec::new(),+ };+ let back: Complex = serde_json::from_str(&serde_json::to_string(&complex).unwrap()).unwrap();+ assert_eq!(back, complex);+ complex.check(3).unwrap();+ assert!(complex.check(2).is_err(), "three numbers for two points");+ assert_eq!(complex.span("role"), Some([0.0, 4.0]));+ assert!(complex.integer("role") && !complex.integer("t") && !complex.integer("nope"));+ // Named values make a label, and a filter keeps a range or a set of them.+ let names = Names::parse("role: 0 outer wall, 4 bridge, -1 none").unwrap();+ assert_eq!((names.name(4), names.name(-1), names.name(2)), (Some("bridge"), Some("none"), None));+ for text in ["t: seconds since the start", "role 0 wall", ": 0 a", "role: x wall", "role: 0 "] {+ assert!(Names::parse(text).is_none(), "{text}");+ }+ let mut named = complex.clone();+ named.names = vec![names, Names::parse("t: 0 zero").unwrap()];+ assert!(named.names("role").is_some() && named.names("t").is_none(), "only whole numbers are labels");+ let set: Filter = serde_json::from_str(r#"{"property": "role", "values": [0, 4]}"#).unwrap();+ let range: Filter = serde_json::from_str(r#"{"property": "t", "range": [1, 3]}"#).unwrap();+ assert_eq!((set.range(), range.range()), (None, Some([1.0, 3.0])));+ assert_eq!(serde_json::to_value(&set).unwrap(), serde_json::json!({"property": "role", "values": [0, 4]}));+ }+}diff --git a/crates/doc/src/point_cloud_distribution.rs b/crates/doc/src/point_cloud_distribution.rsnew file mode 100644index 0000000000..4d9e052f83--- /dev/null+++ b/crates/doc/src/point_cloud_distribution.rs@@ -0,0 +1,246 @@+//! How much of a point cloud lies at each value of one of its properties, over what its filters+//! keep: the histograms the Edit Point Cloud card draws in its range tracks, split into the+//! colours the view draws, and the values where a label changes along a property, which the+//! tracks snap to.+//!+//! Each point weighs the same, the cloud weighing 1. A range filter keeps the points between its+//! ends, as the view does; a filter by values keeps those whose rounded value it holds; the+//! colour sorts the points kept into the colours they are drawn in. The values the points kept+//! take, from the least to the greatest, are the ramp's automatic range: the colours span exactly+//! what is shown.++use crate::point_cloud::{ColorBy, Filter, Keep, PALETTE, PointCloud, Source};++/// Most bins of one histogram.+pub const MAX_BINS: usize = 8192;++/// What the histograms need of a cloud's geometry, worked out once for its points.+#[derive(Clone, Debug, Default)]+pub struct Geometry {+ /// Each point in the design.+ world: Vec<[f64; 3]>,+}++impl Geometry {+ pub fn of(c: &PointCloud) -> Geometry {+ Geometry { world: (0..c.len()).map(|i| c.world_point(i).map_or([0.0; 3], |p| [p.x, p.y, p.z])).collect() }+ }+}++/// How a histogram is split by colour, into slots; the last slot holds what has no value to be+/// coloured by.+#[derive(Clone, Copy, Debug, PartialEq)]+pub enum Colour<'a> {+ /// One colour.+ One,+ /// The ramp over `range` of `property`, in `bands` equal bands; below and above the range+ /// count with the first and the last.+ Ramp { property: &'a str, range: [f64; 2], bands: usize },+ /// The palette of a whole-numbered `property`: a slot per colour of [`PALETTE`], then one+ /// for negative values.+ Palette { property: &'a str },+}++impl Colour<'_> {+ /// How many slots the histogram has.+ pub fn slots(&self) -> usize {+ match self {+ Colour::One => 1,+ Colour::Ramp { bands, .. } => bands + 1,+ Colour::Palette { .. } => PALETTE.len() + 2,+ }+ }+ fn property(&self) -> Option<&str> {+ match self {+ Colour::One => None,+ Colour::Ramp { property, .. } | Colour::Palette { property } => Some(property),+ }+ }+ /// How a property's values are cut into bands, and the slot of each band.+ fn cut(&self) -> Option<Cut> {+ match *self {+ Colour::One => None,+ Colour::Ramp { range: [lo, hi], bands, .. } => Some(Cut::Grid { start: lo, step: (hi - lo) / bands as f64, count: bands + 1 }),+ Colour::Palette { .. } => Some(INTEGERS),+ }+ }+ fn slot(&self, band: usize) -> usize {+ match *self {+ Colour::One => 0,+ Colour::Ramp { bands, .. } => band.saturating_sub(1).min(bands.saturating_sub(1)),+ Colour::Palette { .. } => match integer(band) {+ Some(v) if v >= 0 => v as usize % PALETTE.len(),+ _ => PALETTE.len(),+ },+ }+ }+}++/// How much lies in each bin, by colour slot.+#[derive(Clone, Debug, PartialEq)]+pub struct Histogram {+ pub bins: usize,+ /// `slots[s][b]`: the measure of slot `s` in bin `b`.+ pub slots: Vec<Vec<f64>>,+ /// The least and the greatest value the points kept take, within the axis or not.+ pub extent: Option<[f64; 2]>,+}++/// Where values are cut into bands, by increasing values.+#[derive(Clone, Copy, Debug)]+enum Cut {+ /// Below (band 0), within (1, both ends included) and above (2) a range.+ Range([f64; 2]),+ /// `count` values `start + k·step`: band 0 lies below the first, band `k` from the `k`th on.+ Grid { start: f64, step: f64, count: usize },+}++/// The bands of whole numbers: band `k` holds the values rounding to `k - 2³¹`.+const INTEGERS: Cut = Cut::Grid { start: 0.5 - 2_147_483_648.0, step: 1.0, count: u32::MAX as usize };++/// The whole number a band of [`INTEGERS`] holds.+fn integer(band: usize) -> Option<i64> {+ i64::try_from(band).ok().map(|k| k - 2_147_483_648)+}++impl Cut {+ fn band(&self, v: f64) -> usize {+ match *self {+ Cut::Range([a, b]) => usize::from(v >= a) + usize::from(v > b),+ Cut::Grid { start, step, count } => {+ if !(v >= start) {+ return 0;+ }+ (((v - start) / step).floor() as usize).saturating_add(1).min(count)+ }+ }+ }+}++/// A filter as a cut and the bands it keeps.+struct Kept<'a> {+ cut: Cut,+ values: Option<&'a [i32]>,+}++impl Kept<'_> {+ fn of(f: &Filter) -> Kept<'_> {+ match &f.keep {+ Keep::Range { range } => Kept { cut: Cut::Range(*range), values: None },+ Keep::Values { values } => Kept { cut: INTEGERS, values: Some(values) },+ }+ }+ fn keeps(&self, v: f64) -> bool {+ let band = self.cut.band(v);+ match self.values {+ None => band == 1,+ Some(values) => integer(band).is_some_and(|v| values.iter().any(|k| i64::from(*k) == v)),+ }+ }+}++/// The value of `s` at point `i`.+fn value(s: Source, i: usize, world: &[[f64; 3]]) -> f64 {+ match s {+ Source::Coordinate(k) => world.get(i).and_then(|p| p.get(k)).copied().unwrap_or(f64::NAN),+ Source::Column(v) => v.get(i).map_or(f64::NAN, |x| f64::from(*x)),+ }+}++/// How much of the cloud lies in each of `bins` bins over `axis` of `property`, by `colour`,+/// within every one of `filters`; `None` for an axis or a number of bins it can't have.+pub fn histogram(+ c: &PointCloud,+ g: &Geometry,+ property: &str,+ axis: [f64; 2],+ bins: usize,+ colour: &Colour,+ filters: &[Filter],+) -> Option<Histogram> {+ if !(axis[0].is_finite() && axis[1].is_finite() && axis[1] > axis[0]) || bins == 0 || bins > MAX_BINS {+ return None;+ }+ if let Colour::Ramp { range: [lo, hi], bands, .. } = *colour+ && !(hi > lo && bands > 0 && bands <= MAX_BINS)+ {+ return None;+ }+ let slots = colour.slots();+ let mut out = vec![vec![0.0; bins]; slots];+ let mut extent = None;+ let Some(p) = c.source(property) else { return Some(Histogram { bins, slots: out, extent }) };+ // A point is not filtered by a property the cloud doesn't have, as in the view.+ let kept: Vec<(Kept, Source)> = filters.iter().filter_map(|f| Some((Kept::of(f), c.source(&f.property)?))).collect();+ let coloured = colour.property().and_then(|n| c.source(n));+ let (colour_cut, plain) = (colour.cut(), slots - 1);+ let m = 1.0 / g.world.len().max(1) as f64;+ let width = (axis[1] - axis[0]) / bins as f64;+ for i in 0..g.world.len() {+ if !kept.iter().all(|(k, s)| k.keeps(value(*s, i, &g.world))) {+ continue;+ }+ let v = value(p, i, &g.world);+ if !v.is_finite() {+ continue;+ }+ extent = Some(extent.map_or([v, v], |[lo, hi]: [f64; 2]| [lo.min(v), hi.max(v)]));+ if !(v >= axis[0] && v <= axis[1]) {+ continue;+ }+ let slot = match (colour_cut, coloured) {+ (Some(cut), Some(s)) => colour.slot(cut.band(value(s, i, &g.world))),+ (Some(_), None) => plain,+ (None, _) => 0,+ };+ // The last bin holds the axis' upper end too.+ let bin = (((v - axis[0]) / width).floor() as usize).min(bins - 1);+ if let Some(b) = out.get_mut(slot).and_then(|s| s.get_mut(bin)) {+ *b += m;+ }+ }+ Some(Histogram { bins, slots: out, extent })+}++/// A range for a ramp from the values it spans: a single value gets one unit around it.+pub fn ramp_range([lo, hi]: [f64; 2]) -> [f64; 2] {+ if hi > lo { [lo, hi] } else { [lo - 0.5, lo + 0.5] }+}++/// The ramp's range: the one set; else, coloured by a property, exactly the values it takes over+/// what `filters` keep (the cloud's own bound, [`PointCloud::color_range`], when nothing is+/// kept); coloured by height, the cloud's own (its points but the highest and lowest few).+pub fn color_range(c: &PointCloud, g: &Geometry, filters: &[Filter]) -> Option<[f64; 2]> {+ color_range_by(c, |property, axis| histogram(c, g, property, axis, 1, &Colour::One, filters).and_then(|h| h.extent))+}++/// [`color_range`], with the values the coloured property takes over what is kept given by+/// `extent` (of the property and an axis over its span): worked out elsewhere, or not yet.+pub fn color_range_by(c: &PointCloud, extent: impl FnOnce(&str, [f64; 2]) -> Option<[f64; 2]>) -> Option<[f64; 2]> {+ let property = c.colored_property()?;+ if c.height_range.is_some() || c.color_by != ColorBy::Property {+ return c.color_range();+ }+ let axis = ramp_range(c.span(property)?);+ extent(property, axis).map(ramp_range).or_else(|| c.color_range())+}++/// The values of `property` where the whole-numbered `label` changes, point after point in order+/// of `property`, lowest first.+pub fn label_changes(c: &PointCloud, g: &Geometry, label: &str, property: &str) -> Vec<f64> {+ let (Some(p), Some(l)) = (c.source(property), c.source(label)) else { return Vec::new() };+ let mut at: Vec<(f64, i64)> = (0..g.world.len())+ .filter_map(|i| {+ let (v, l) = (value(p, i, &g.world), value(l, i, &g.world));+ v.is_finite().then(|| (v, if l.is_finite() { l.round() as i64 } else { i64::MIN }))+ })+ .collect();+ at.sort_by(|a, b| a.0.total_cmp(&b.0));+ let mut out: Vec<f64> = at.windows(2).filter(|w| w[0].1 != w[1].1).map(|w| w[1].0).collect();+ out.dedup();+ out+}++#[cfg(test)]+#[path = "point_cloud_distribution_tests.rs"]+mod tests;diff --git a/crates/doc/src/point_cloud_distribution_tests.rs b/crates/doc/src/point_cloud_distribution_tests.rsnew file mode 100644index 0000000000..52beaa86cd--- /dev/null+++ b/crates/doc/src/point_cloud_distribution_tests.rs@@ -0,0 +1,125 @@+use solidcraft_geom::Vec3;++use super::*;+use crate::IDENTITY;+use crate::point_cloud::{ColorBy, Colors, Column, Complex, Floats, Points};++/// A cloud of `points` with `columns` on them.+fn cloud(points: &[[f32; 3]], columns: Vec<Column>) -> PointCloud {+ PointCloud {+ id: 1,+ name: "c".into(),+ file: String::new(),+ origin: Vec3::new(0.0, 0.0, 0.0),+ points: Points::new(points.iter().flatten().copied().collect::<Vec<f32>>().into()),+ colors: Colors::default(),+ source_points: points.len() as u64,+ units: "mm".into(),+ transform: IDENTITY,+ point_size: 2.0,+ color_by: ColorBy::File,+ color: None,+ height_range: None,+ visible: true,+ complex: Complex { columns, names: Vec::new() },+ color_property: None,+ filters: Vec::new(),+ }+}++fn column(name: &str, integer: bool, values: &[f32]) -> Column {+ Column { name: name.into(), integer, values: Floats(values.to_vec().into()) }+}++fn range(property: &str, range: [f64; 2]) -> Filter {+ Filter { property: property.into(), keep: Keep::Range { range } }+}++fn close(a: &[f64], b: &[f64]) -> bool {+ a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9)+}++/// Ten points along x, `t` the same as x.+fn row() -> PointCloud {+ let points: Vec<[f32; 3]> = (0..10).map(|i| [i as f32 + 0.5, 0.0, 0.0]).collect();+ let t: Vec<f32> = points.iter().map(|p| p[0]).collect();+ cloud(&points, vec![column("t", false, &t)])+}++#[test]+fn each_point_weighs_alike_and_a_range_keeps_those_within_it() {+ let c = row();+ let g = Geometry::of(&c);+ let all = histogram(&c, &g, "t", [0.0, 10.0], 5, &Colour::One, &[]).unwrap();+ assert!(close(&all.slots[0], &[0.2; 5]));+ // Kept from t = 2 to 5: three points, ends included.+ let kept = histogram(&c, &g, "t", [0.0, 10.0], 5, &Colour::One, &[range("t", [2.0, 5.0])]).unwrap();+ assert!(close(&kept.slots[0], &[0.0, 0.2, 0.1, 0.0, 0.0]));+ // Filtered by another property: x from 0 to 4 keeps t from 0 to 4.+ let by_x = histogram(&c, &g, "t", [0.0, 10.0], 5, &Colour::One, &[range("x", [0.0, 4.0])]).unwrap();+ assert!(close(&by_x.slots[0], &[0.2, 0.2, 0.0, 0.0, 0.0]));+ // A filter on a property the cloud doesn't have keeps everything, as in the view.+ assert_eq!(histogram(&c, &g, "t", [0.0, 10.0], 5, &Colour::One, &[range("nope", [0.0, 1.0])]), Some(all));+ // An axis or a number of bins it can't have.+ for (axis, bins) in [([1.0, 1.0], 4), ([0.0, f64::NAN], 4), ([0.0, 1.0], 0), ([0.0, 1.0], MAX_BINS + 1)] {+ assert!(histogram(&c, &g, "t", axis, bins, &Colour::One, &[]).is_none());+ }+}++#[test]+fn colours_split_what_is_kept() {+ // Four points, roles 0, 3, 3 and -1, t from 0 to 3.+ let c = cloud(+ &[[0.0; 3], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0], [3.0, 0.0, 0.0]],+ vec![column("t", false, &[0.0, 1.0, 2.0, 3.0]), column("role", true, &[0.0, 3.0, 3.0, -1.0])],+ );+ let g = Geometry::of(&c);+ let colour = Colour::Palette { property: "role" };+ let h = histogram(&c, &g, "t", [0.0, 4.0], 4, &colour, &[]).unwrap();+ assert_eq!(h.slots.len(), colour.slots());+ assert!(close(&h.slots[0], &[0.25, 0.0, 0.0, 0.0]));+ assert!(close(&h.slots[3], &[0.0, 0.25, 0.25, 0.0]));+ assert!(close(&h.slots[PALETTE.len()], &[0.0, 0.0, 0.0, 0.25]), "a negative label");+ // A filter by values keeps role 3 only.+ let three = Filter { property: "role".into(), keep: Keep::Values { values: vec![3] } };+ let kept = histogram(&c, &g, "t", [0.0, 4.0], 4, &colour, &[three]).unwrap();+ let total: f64 = kept.slots.iter().flatten().sum();+ assert!((total - 0.5).abs() < 1e-9 && close(&kept.slots[3], &h.slots[3]));+ // A ramp over t in two bands, and coloured by a property the cloud doesn't have: plain.+ let ramp = Colour::Ramp { property: "t", range: [0.0, 4.0], bands: 2 };+ let r = histogram(&c, &g, "t", [0.0, 4.0], 4, &ramp, &[]).unwrap();+ assert!(close(&r.slots[0], &[0.25, 0.25, 0.0, 0.0]) && close(&r.slots[1], &[0.0, 0.0, 0.25, 0.25]));+ let none = histogram(&c, &g, "t", [0.0, 4.0], 4, &Colour::Palette { property: "nope" }, &[]).unwrap();+ assert!(close(&none.slots[PALETTE.len() + 1], &[0.25; 4]));+}++#[test]+fn labels_change_where_the_next_point_has_another() {+ // Six points in order of t, layers 0 0 1 1 2 2.+ let points: Vec<[f32; 3]> = (0..6).map(|i| [i as f32, 0.0, 0.0]).collect();+ let c = cloud(&points, vec![column("t", false, &[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]), column("layer", true, &[0.0, 0.0, 1.0, 1.0, 2.0, 2.0])]);+ let g = Geometry::of(&c);+ assert_eq!(label_changes(&c, &g, "layer", "t"), vec![2.0, 4.0]);+ assert!(label_changes(&c, &g, "nope", "t").is_empty());+}++#[test]+fn the_automatic_range_is_what_every_filter_keeps() {+ // Filtered by x from 2 to 4, coloured by t: the range is what is kept of t, though no filter+ // is on t (its span within filters on t would be all of it).+ let mut c = cloud(&[[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [4.0, 0.0, 0.0], [20.0, 0.0, 0.0]], vec![column("t", false, &[0.0, 3.0, 5.0, 7.0])]);+ c.color_by = ColorBy::Property;+ c.color_property = Some("t".into());+ let g = Geometry::of(&c);+ let x = [range("x", [2.0, 4.0])];+ assert_eq!(c.color_range(), Some([0.0, 7.0]));+ assert_eq!(color_range(&c, &g, &x), Some([3.0, 5.0]));+ // The point at x = 20 alone: one value, one unit wide.+ assert_eq!(color_range(&c, &g, &[range("x", [19.0, 21.0])]), Some([6.5, 7.5]));+ // Nothing kept: the cloud's own bound; a range set is kept as it is.+ assert_eq!(color_range(&c, &g, &[range("x", [50.0, 60.0])]), Some([0.0, 7.0]));+ c.height_range = Some([1.0, 2.0]);+ assert_eq!(color_range(&c, &g, &x), Some([1.0, 2.0]));+ let h = histogram(&c, &g, "t", [0.0, 1.0], 4, &Colour::One, &x).unwrap();+ assert_eq!(h.extent, Some([3.0, 5.0]), "the extent reaches past the axis");+}diff --git a/crates/engine/src/cmd/point_cloud.rs b/crates/engine/src/cmd/point_cloud.rsindex 80e0b86185..78bfb0283b 100644--- a/crates/engine/src/cmd/point_cloud.rs+++ b/crates/engine/src/cmd/point_cloud.rs@@ -3,7 +3,9 @@use serde_json::{Value, json};use solidcraft_doc::Mat;-use solidcraft_doc::point_cloud::{ColorBy, Colors, MAX_COORD, MAX_POINTS, POINT_SIZE, PointCloud, Points, UNITS, unit_scale};+use solidcraft_doc::point_cloud::{+ ColorBy, Colors, Filter, Keep, MAX_COORD, MAX_FILTERS, MAX_NAMES, MAX_POINTS, POINT_SIZE, PointCloud, Points, UNITS, unit_scale,+};use super::CommandSpec;use crate::params::{bad, bool_, str_};@@ -13,16 +15,16 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("pointcloud.insert", "Insert Point Cloud", insert).at("SOLID", "INSERT").icon("import")- .params("path: .ply, .xyz or .pts file (its points join the design as a point cloud: drawn as points, never a body; a PLY's red, green and blue are its colours) → cloud, name, points, source_points, bounds, warnings; name?; units?: mm|cm|m|in|ft (the file's length unit, default mm); max_points?: most points kept (default 5000000, at most 20000000; a larger file is thinned evenly); center?: bool (move the cloud so the middle of its base sits at the origin); point_size?: pixels (0.5…16, default 2); color_by?: file|single|height (the file's colours, the default; one colour; or a ramp by height, blue low to red high); color?: [r, g, b] 0…1 (the single colour; given alone it sets color_by single, null sets color_by file); height_range?: [low, high] design Z in mm for the height ramp, or null to work it out from the points (all but the lowest and highest 2 %)"),+ .params("path: .ply, .xyz or .pts file (its points join the design as a point cloud: drawn as points, never a body; a PLY's red, green and blue are its colours, its other vertex properties can colour and filter it) → cloud, name, points, source_points, bounds, warnings; name?; units?: mm|cm|m|in|ft (the file's length unit, default mm); max_points?: most points kept (default 5000000, at most 20000000; a larger file is thinned evenly); center?: bool (move the cloud so the middle of its base sits at the origin); point_size?: pixels (0.5…16, default 2); color_by?: file|single|height or a property's name (the file's colours, the default; one colour; a ramp by height, blue low to red high; or by any property of the file, a ramp over its values or a palette for whole numbers); color?: [r, g, b] 0…1 (the single colour; given alone it sets color_by single, null sets color_by file); color_range?: [low, high] the ramp runs between (design Z in mm by height), or null for the automatic range (by height all but the lowest and highest 2 % of the points; by a property the values it takes over what the filters keep); height_range?: the same as color_range; filters?: [{property, range: [low, high]} or {property, values: [whole numbers]} for a property with named values], or null (only what every filter keeps is shown)"),CommandSpec::new("pointcloud.edit", "Edit Point Cloud", edit).icon("edit")- .params("cloud: id or name; name?; visible?; point_size?: pixels (0.5…16); color_by?: file|single|height (the file's colours, the default; one colour; or a ramp by height, blue low to red high); color?: [r, g, b] 0…1 (the single colour; given alone it sets color_by single, null sets color_by file); height_range?: [low, high] design Z in mm for the height ramp, or null to work it out from the points (all but the lowest and highest 2 %); units?: mm|cm|m|in|ft (the file's length unit: the points are scaled from the unit they came in as); matrix?: [12 or 16 numbers] (where the cloud sits: a rigid row-major 3x4 or 4x4 matrix, as occurrence.move takes it); tolerance? → cloud"),+ .params("cloud: id or name; name?; visible?; point_size?: pixels (0.5…16); color_by?: file|single|height or a property's name (the file's colours, the default; one colour; a ramp by height, blue low to red high; or by any property of the file, a ramp over its values or a palette for whole numbers); color?: [r, g, b] 0…1 (the single colour; given alone it sets color_by single, null sets color_by file); color_range?: [low, high] the ramp runs between (design Z in mm by height), or null for the automatic range (by height all but the lowest and highest 2 % of the points; by a property the values it takes over what the filters keep); height_range?: the same as color_range; units?: mm|cm|m|in|ft (the file's length unit: the points are scaled from the unit they came in as); matrix?: [12 or 16 numbers] (where the cloud sits: a rigid row-major 3x4 or 4x4 matrix, as occurrence.move takes it); tolerance?; filters?: [{property, range: [low, high]} or {property, values: [whole numbers]} for a property with named values], or null (only what every filter keeps is shown) → cloud"),CommandSpec::new("pointcloud.delete", "Delete Point Cloud", delete).icon("delete").params("cloud: id or name → deleted"),CommandSpec::new("pointcloud.list", "Point Clouds", list).icon("list").noundo().doc_only()- .params("→ clouds: [{cloud, name, file, points, source_points, units, visible, point_size, color_by, color, colored, height_range (the ramp's now, its own or worked out), height_auto, bounds: [[x,y,z], [x,y,z]] in the design, matrix}]"),+ .params("→ clouds: [{cloud, name, file, points, source_points, units, visible, point_size, color_by (file, single, height or a property's name), color, colored, properties: [{name, integer, span, names}], filters, color_range (the ramp's now, exact over what the filters keep), height_range (the ramp's own range or the automatic one by height), height_auto, bounds: [[x,y,z], [x,y,z]] in the design, matrix}]"),];fn units_of(p: &Value, cmd: &str) -> Result<Option<(&'static str, f64)>> {@@ -64,18 +66,74 @@ fn color(p: &Value, cmd: &str) -> Result<Option<Option<[f32; 3]>>> {}}-/// `color_by`: absent (`None`), or file, single or height.-fn color_by(p: &Value, cmd: &str) -> Result<Option<ColorBy>> {+/// `color_by`: absent (`None`), file, single or height, or the name of a property.+fn color_by(p: &Value, cmd: &str) -> Result<Option<(ColorBy, Option<String>)>> {match p.get("color_by") {None | Some(Value::Null) => Ok(None),- Some(v) => v.as_str().and_then(ColorBy::parse).map(Some).ok_or_else(|| bad(cmd, "`color_by` must be file, single or height")),+ Some(Value::String(v)) => Ok(Some(match ColorBy::parse(v) {+ Some(b) if b != ColorBy::Property => (b, None),+ _ => (ColorBy::Property, Some(v.clone())),+ })),+ Some(_) => Err(bad(cmd, "`color_by` must be file, single, height or a property's name")),}}+/// `filters`: absent (`None`), null for none, or [{property, range: [low, high]} or+/// {property, values: [whole numbers]}].+fn filters(p: &Value, cmd: &str) -> Result<Option<Vec<Filter>>> {+ let refuse = || {+ bad(+ cmd,+ format!(+ "`filters` must be at most {MAX_FILTERS} {{property, range: [low, high]}} (lowest first) or {{property, values: [whole numbers]}}, or null"+ ),+ )+ };+ match p.get("filters") {+ None => Ok(None),+ Some(Value::Null) => Ok(Some(Vec::new())),+ Some(Value::Array(a)) if a.len() <= MAX_FILTERS => a+ .iter()+ .map(|f| {+ let property = f.get("property").and_then(Value::as_str).ok_or_else(refuse)?.to_string();+ if let Some(values) = f.get("values") {+ let values = values.as_array().ok_or_else(refuse)?;+ let whole = |v: &Value| v.as_i64().and_then(|n| i32::try_from(n).ok());+ let values = values.iter().map(whole).collect::<Option<Vec<i32>>>().filter(|v| v.len() <= MAX_NAMES).ok_or_else(refuse)?;+ return Ok(Filter { property, keep: Keep::Values { values } });+ }+ match f.get("range").and_then(Value::as_array).map(|r| r.iter().map(Value::as_f64).collect::<Option<Vec<f64>>>()) {+ Some(Some(r)) if matches!(r.as_slice(), &[lo, hi] if lo.is_finite() && hi.is_finite() && lo <= hi) => {+ Ok(Filter { property, keep: Keep::Range { range: [r[0], r[1]] } })+ }+ _ => Err(refuse()),+ }+ })+ .collect::<Result<Vec<Filter>>>()+ .map(Some),+ Some(_) => Err(refuse()),+ }+}++/// A cloud colours and filters only by properties it has.+fn check_properties(c: &PointCloud, cmd: &str) -> Result<()> {+ let names: Vec<&str> = c.property_names().collect();+ for n in c.color_property.iter().filter(|_| c.color_by == ColorBy::Property).chain(c.filters.iter().map(|f| &f.property)) {+ if !names.contains(&n.as_str()) {+ return Err(bad(cmd, format!("the point cloud has no property `{n}` (it has {})", names.join(", "))));+ }+ }+ // A set of values filters a label: a property with named whole numbers.+ if let Some(f) = c.filters.iter().find(|f| matches!(f.keep, Keep::Values { .. }) && c.complex.names(&f.property).is_none()) {+ return Err(bad(cmd, format!("`{}` has no named values: filter it with a range", f.property)));+ }+ Ok(())+}+/// `height_range`: absent (`None`), null for the automatic one (`Some(None)`), or [low, high].fn height_range(p: &Value, cmd: &str) -> Result<Option<Option<[f64; 2]>>> {- let refuse = || bad(cmd, "`height_range` must be [low, high] heights in mm, lowest first, or null");- match p.get("height_range") {+ let refuse = || bad(cmd, "`height_range` (or `color_range`) must be [low, high], lowest first, or null");+ match p.get("color_range").or_else(|| p.get("height_range")) {None => Ok(None),Some(Value::Null) => Ok(Some(None)),Some(Value::Array(a)) => match a.iter().map(Value::as_f64).collect::<Option<Vec<f64>>>().as_deref() {@@ -90,13 +148,18 @@ fn height_range(p: &Value, cmd: &str) -> Result<Option<Option<[f64; 2]>>> {/// Apply `color_by`, `color` and `height_range`: a colour given alone means one colour, and/// `color: null` the file's.-fn set_colors(c: &mut PointCloud, by: Option<ColorBy>, color: Option<Option<[f32; 3]>>, range: Option<Option<[f64; 2]>>) {+fn set_colors(c: &mut PointCloud, by: Option<(ColorBy, Option<String>)>, color: Option<Option<[f32; 3]>>, range: Option<Option<[f64; 2]>>) {if let Some(k) = color {c.color = k.or(c.color);c.color_by = if k.is_some() { ColorBy::Single } else { ColorBy::File };}- if let Some(b) = by {+ if let Some((b, property)) = by {+ if property != c.color_property && range.is_none() {+ // Another property's values have another range.+ c.height_range = None;+ }c.color_by = b;+ c.color_property = property.or(c.color_property.take().filter(|_| b == ColorBy::Property));}if let Some(r) = range {c.height_range = r;@@ -172,8 +235,12 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {color: None,height_range: None,visible: true,+ complex: read.complex,+ color_property: None,+ filters: filters(p, cmd)?.unwrap_or_default(),};set_colors(&mut cloud, colors.0, colors.1, colors.2);+ check_properties(&cloud, cmd)?;if center && let Some((lo, hi)) = cloud.local_bounds() {cloud.transform[3] = [-(lo.x + hi.x) / 2.0, -(lo.y + hi.y) / 2.0, -lo.z, 1.0];}@@ -207,6 +274,7 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {let i = find(s, p, cmd)?;let size = point_size(p, cmd)?;let colors = (color_by(p, cmd)?, color(p, cmd)?, height_range(p, cmd)?);+ let filters = filters(p, cmd)?;let units = units_of(p, cmd)?;let placement = match p.get("matrix") {None | Some(Value::Null) => None,@@ -236,6 +304,10 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {c.point_size = v;}set_colors(&mut c, colors.0, colors.1, colors.2);+ if let Some(f) = filters {+ c.filters = f;+ }+ check_properties(&c, cmd)?;if let Some(v) = bool_(p, "visible") {c.visible = v;}@@ -271,7 +343,13 @@ fn list(s: &mut Session, _: &Value) -> Result<Value> {"units": c.units,"visible": c.visible,"point_size": c.point_size,- "color_by": c.color_by.name(),+ "color_by": c.colored_property().filter(|_| c.color_by == ColorBy::Property).unwrap_or(c.color_by.name()),+ "properties": c+ .property_names()+ .map(|n| json!({"name": n, "integer": c.complex.integer(n), "span": c.span(n), "names": c.complex.names(n).map(|m| &m.values)}))+ .collect::<Vec<_>>(),+ "filters": c.filters,+ "color_range": solidcraft_doc::point_cloud_distribution::color_range(c, &solidcraft_doc::point_cloud_distribution::Geometry::of(c), &c.filters),"color": c.color,"colored": !c.colors.is_empty(),"height_range": c.height_range_now(),diff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex c67cfd2992..5dbae9b5c8 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -397,7 +397,7 @@ fn frame(scene: &Scene, cam: &Camera, [width, height]: [u32; 2], key: u64, accesclip: scene.clip.map_or([0.0; 4], |(n, d)| [n.x as f32, n.y as f32, n.z as f32, d as f32]),cap: [f32::from(cap.0) / 255.0, f32::from(cap.1) / 255.0, f32::from(cap.2) / 255.0, if scene.plain_cap { 0.0 } else { 1.0 }],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: analysis_uniform(mode, access.as_ref()),analysis_colors: scene.analysis.map_or([0.0; 36], |a| analysis_colors(&a.colors)),access,diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex edfbf4cdb3..fa1024c05b 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -17,6 +17,8 @@ use crate::pbr;use wgpu::util::DeviceExt;mod ao;+mod clouds;+pub use clouds::{CloudFilter, CloudStyle, ColorMode, DOT_SIZE, Dot, FILTERS, GpuCloud, cloud_dot};#[cfg(not(target_arch = "wasm32"))]mod msaa_check;mod oit;@@ -921,34 +923,6 @@ pub struct GpuImage {/// Image vertex: position (3 × f32), uv (2 × f32), opacity (f32).const IMG_SIZE: usize = 24;-/// A point cloud: round dots of a size on screen, depth-tested and written like the model's-/// faces.-#[derive(Clone)]-pub struct GpuPoints {- pub id: u64,- /// Changes when the points change (they are uploaded again).- pub version: u64,- /// [`CLOUD_POINT_SIZE`] bytes per point: position (3 × f32, in the design), colour (RGBA8,- /// the alpha the dot's size in eighths of a pixel, see [`cloud_point`]).- pub bytes: Arc<Vec<u8>>,-}--/// Bytes per point of a [`GpuPoints`].-pub const CLOUD_POINT_SIZE: usize = 16;--/// A point of a [`GpuPoints`]: where it is, its colour and its size on screen (pixels, up to 31).-pub fn cloud_point(out: &mut Vec<u8>, p: [f32; 3], rgb: [u8; 3], size: f32) {- for v in p {- out.extend_from_slice(&v.to_le_bytes());- }- out.extend_from_slice(&rgb);- out.push((size * 8.0).round().clamp(8.0, 255.0) as u8);-}--fn point_layout() -> wgpu::VertexBufferLayout<'static> {- const A: [wgpu::VertexAttribute; 2] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Unorm8x4];- wgpu::VertexBufferLayout { array_stride: CLOUD_POINT_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }-}/// Ambient occlusion samples per shaded pixel in a still picture (the shader's most).pub const AO_SAMPLES: u32 = 32;@@ -990,7 +964,7 @@ pub struct Frame {/// Canvases and decals.pub images: Vec<GpuImage>,/// Point clouds.- pub points: Vec<GpuPoints>,+ pub clouds: Vec<GpuCloud>,/// Surface analysis: (mode: 0 none, 1 zebra, 2 draft, 3 curvature, 4 environment,/// 5 accessibility; parameter; scale; size) and the pull / access direction.pub analysis: [f32; 8],@@ -2060,10 +2034,8 @@ pub struct Renderer {textures: std::collections::HashMap<u64, (u64, wgpu::BindGroup)>,/// This frame's quads: (image id, vertices).quads: Vec<(u64, Batch)>,- /// Point clouds' dots.- point: wgpu::RenderPipeline,- /// Point clouds by id: (version, points).- clouds: std::collections::HashMap<u64, (u64, Batch)>,+ cloud_pipes: clouds::CloudPipes,+ clouds: clouds::CloudDraws,access_bgl: wgpu::BindGroupLayout,/// The accessibility depth map (a 1 × 1 stand-in when there is none) and its version.access_bind: wgpu::BindGroup,@@ -2875,7 +2847,7 @@ impl Renderer {pipeline("sc_guide_lines", "vs_line", "fs_line_all", line_layout(), depth(wgpu::CompareFunction::LessEqual, false), alpha),)};- let point = || pipeline("sc_points", "vs_point", "fs_point", point_layout(), depth(wgpu::CompareFunction::Less, true), None);+ let cloud_pipes = || clouds::CloudPipes::new(device, &module, &bgl, t, depth(wgpu::CompareFunction::Less, true));let guide_trans = || pipeline("sc_guide_trans", "vs_tri", "fs_tri_all", tri_layout(), depth(wgpu::CompareFunction::LessEqual, false), alpha);// Each job on a thread of its own where the device allows it: D3D12 compiles every shader// as its pipeline is made, which took seconds one after another (#4860).@@ -2892,7 +2864,7 @@ impl Renderer {let lines = jobs.spawn(lines);let lines_all = jobs.spawn(lines_all);let guide_trans = jobs.spawn(guide_trans);- let point = jobs.spawn(point);+ let cloud_pipes = jobs.spawn(cloud_pipes);let image = jobs.spawn(image);let ao = jobs.spawn(ao);let oit = jobs.spawn(oit);@@ -2941,7 +2913,7 @@ impl Renderer {sampler,textures: Default::default(),quads: Vec::new(),- point: point.join(),+ cloud_pipes: cloud_pipes.join(),clouds: Default::default(),tri,tri_cut: cut(tri_marks, tri_cap),@@ -3277,10 +3249,7 @@ fn frame_key(cb: &Frame) -> u64 {img.corners.iter().flatten().for_each(|v| v.to_bits().hash(&mut h));img.opacity.to_bits().hash(&mut h);}- for cloud in &cb.points {- cloud.id.hash(&mut h);- cloud.version.hash(&mut h);- }+ clouds::hash_clouds(&cb.clouds, &mut h);match &cb.access {Some(a) => {true.hash(&mut h);@@ -3430,20 +3399,7 @@ impl Renderer {res.quads.push((img.id, b));}}- // Point clouds: upload new or changed ones, drop removed ones.- res.clouds.retain(|id, _| cb.points.iter().any(|c| c.id == *id));- for c in &cb.points {- if res.clouds.get(&c.id).is_none_or(|(v, _)| *v != c.version) {- match upload(device, "sc_points", &c.bytes, CLOUD_POINT_SIZE) {- Some(b) => {- res.clouds.insert(c.id, (c.version, b));- }- None => {- res.clouds.remove(&c.id);- }- }- }- }+ res.clouds.prepare(device, queue, &res.cloud_pipes, &cb.clouds);res.ss_ready = (cb.ssaa != 1.0 || see_through || res.window_differs()) && res.supersample(device, encoder, cb, see_through);res.ss_key = res.ss_ready.then_some(key);}@@ -3673,14 +3629,7 @@ impl Renderer {pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, &res.pbr, &m.pbr);if !cb.product {- for (_, b) in res.clouds.values() {- pass.set_pipeline(&res.point);- for (buffer, count) in &b.parts {- pass.set_vertex_buffer(0, buffer.slice(..));- pass.draw(0..6, 0..*count);- tally.triangles(6, *count);- }- }+ res.clouds.paint(pass, &res.cloud_pipes, tally);}// Whole-body tints first, so a face or an edge highlighted over the body (in `h.tris`// and `h.lines`) keeps its own colour, as it did when the body's triangles were built@@ -4377,7 +4326,7 @@ mod tests {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: [0.0; 36],access: None,@@ -4764,7 +4713,7 @@ mod glass_tests {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: [0.0; 36],access: None,@@ -4939,7 +4888,7 @@ mod glass_tests {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: [0.0; 36],access: None,@@ -4964,28 +4913,39 @@ mod glass_tests {}#[test]- fn a_cached_point_cloud_picture_updates_after_recoloring_and_hiding() {+ fn a_cached_cloud_picture_follows_its_style_without_uploading_again() {let Some((_, device, queue)) = crate::open_headless().ok() else { return };let depth = crate::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;let mut renderer = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false }, None);let mut frame = test_frame(GpuScene::default(), 2.0);- let mut bytes = Vec::new();- cloud_point(&mut bytes, [0.0; 3], [255, 0, 0], 20.0);- frame.points.push(GpuPoints { id: 1, version: 1, bytes: Arc::new(bytes) });- let red = render_frame(&mut renderer, &device, &queue, &frame, true);- assert!(red.as_chunks::<4>().0.iter().any(|p| p[0] > 200 && p[1] < 30 && p[2] < 30), "the cloud is drawn");- render_frame(&mut renderer, &device, &queue, &frame, true);- assert!(renderer.cached.is_some());- let mut bytes = Vec::new();- cloud_point(&mut bytes, [0.0; 3], [0, 0, 255], 20.0);- frame.points = vec![GpuPoints { id: 1, version: 2, bytes: Arc::new(bytes) }];- let blue = render_frame(&mut renderer, &device, &queue, &frame, true);- assert!(blue.as_chunks::<4>().0.iter().any(|p| p[0] < 30 && p[1] < 30 && p[2] > 200), "the edited cloud replaces the cached picture");- assert_ne!(red, blue);- frame.points.clear();+ // A dot labelled 2 (red in the palette) and a dot filtered by 5 (a range) and the label+ // 2 (a set).+ let mut dots = Vec::new();+ cloud_dot(&mut dots, &Dot { at: [5.0, 5.0, 0.0], rgb: [0, 0, 255], value: 2.0, has: 16, ..Default::default() });+ let filtered = Dot { at: [-3.0, -3.0, 0.0], value: 1.0, filtered: [5.0, 2.0, 0.0, 0.0], rgb: [0, 255, 0], has: 0b10011 };+ cloud_dot(&mut dots, &filtered);+ let style = CloudStyle { mode: ColorMode::Own, range: [0.0, 1.0], filters: Default::default(), point_size: 20.0 };+ frame.clouds.push(GpuCloud { id: 1, version: 1, dots: Arc::new(dots), style });+ let has = |img: &[u8], f: &dyn Fn(&[u8; 4]) -> bool| img.as_chunks::<4>().0.iter().any(f);+ let green = |p: &[u8; 4]| p[1] > 120 && p[0] < 30 && p[2] < 30;+ let own = render_frame(&mut renderer, &device, &queue, &frame, true);+ assert!(has(&own, &|p| p[2] > 200 && p[0] < 30), "a dot in its own colour");+ assert!(has(&own, &green), "the other in its own colour");+ // Values from -1: bit 3 is the label 2, bit 2 the label 1.+ frame.clouds[0].style.filters[1] = CloudFilter::Values { offset: -1, mask: 0b1000 };+ assert!(has(&render_frame(&mut renderer, &device, &queue, &frame, true), &green), "label 2 kept");+ frame.clouds[0].style.filters[1] = CloudFilter::Values { offset: -1, mask: 0b0100 };+ assert!(!has(&render_frame(&mut renderer, &device, &queue, &frame, true), &green), "label 2 left out");+ frame.clouds[0].style.filters[1] = CloudFilter::Off;+ frame.clouds[0].style.filters[0] = CloudFilter::Range([0.0, 4.0]);+ frame.clouds[0].style.mode = ColorMode::Palette;+ let filtered = render_frame(&mut renderer, &device, &queue, &frame, true);+ assert!(!has(&filtered, &green), "its 5 lies outside the range");+ assert!(has(&filtered, &|p| p[0] > 200 && p[1] < 90 && p[2] < 90), "the first, without that value, in the palette's red");+ frame.clouds.clear();let hidden = render_frame(&mut renderer, &device, &queue, &frame, true);- assert!(!hidden.as_chunks::<4>().0.iter().any(|p| p[0] < 30 && p[1] < 30 && p[2] > 200), "hiding the cloud removes its dots");+ assert!(!has(&hidden, &|p| p[0] > 200 && p[1] < 90 && p[2] < 90), "hiding the cloud removes it");}/// A still view shows the picture it drew last: a reused frame (whose filtered picture isdiff --git a/crates/gpu/src/view/clouds.rs b/crates/gpu/src/view/clouds.rsnew file mode 100644index 0000000000..52c0f05a76--- /dev/null+++ b/crates/gpu/src/view/clouds.rs@@ -0,0 +1,227 @@+//! Point clouds: each point a round dot a few pixels across, facing the screen, depth-tested and+//! written like the model's faces. Every point is uploaded once, with the values it is coloured+//! and filtered by; how they are coloured and which are shown is a [`CloudStyle`] of a few+//! numbers the shaders read, so a new colour range or filter range draws again at once without+//! uploading anything.++use std::sync::Arc;++use super::{Batch, Tally, upload};++/// A point cloud as the GPU draws it.+#[derive(Clone)]+pub struct GpuCloud {+ pub id: u64,+ /// Changes when the records change (they are uploaded again).+ pub version: u64,+ /// [`DOT_SIZE`] bytes per point, written by [`cloud_dot`].+ pub dots: Arc<Vec<u8>>,+ pub style: CloudStyle,+}++/// How a cloud is coloured and which of its points are shown.+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub struct CloudStyle {+ pub mode: ColorMode,+ /// The ramp's range of values.+ pub range: [f32; 2],+ /// A point is shown where every filter keeps its filtered value.+ pub filters: [CloudFilter; FILTERS],+ /// A dot's size on screen, in pixels.+ pub point_size: f32,+}++/// Filters the GPU applies at once.+pub const FILTERS: usize = 4;++/// The values a filter keeps.+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub enum CloudFilter {+ /// All of them.+ #[default]+ Off,+ /// Those within a range, ends included.+ Range([f32; 2]),+ /// Whole values `offset + i` for each bit `i` set in `mask`.+ Values { offset: i32, mask: u32 },+}++/// Where a point's colour comes from.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub enum ColorMode {+ /// Its own colour ([`Dot::rgb`]).+ #[default]+ Own,+ /// The ramp over [`CloudStyle::range`] at its value.+ Ramp,+ /// The palette at its whole value.+ Palette,+}++/// One point: where it is, the coloured value and the four filtered values, its own colour, and+/// which of the four filters and the value it has (bits 0 to 3, and 4, of `has`).+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub struct Dot {+ pub at: [f32; 3],+ pub value: f32,+ pub filtered: [f32; FILTERS],+ pub rgb: [u8; 3],+ pub has: u8,+}++/// Bytes per [`Dot`].+pub const DOT_SIZE: usize = 36;++/// Append a dot's record.+pub fn cloud_dot(out: &mut Vec<u8>, d: &Dot) {+ for v in d.at.iter().chain([&d.value]).chain(&d.filtered) {+ out.extend_from_slice(&v.to_le_bytes());+ }+ out.extend_from_slice(&d.rgb);+ out.push(d.has);+}++fn dot_layout() -> wgpu::VertexBufferLayout<'static> {+ const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32, 2 => Float32x4, 3 => Unorm8x4];+ wgpu::VertexBufferLayout { array_stride: DOT_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }+}++/// The uniform a cloud's style is written to, bytes: the colouring, then a `vec4` per filter.+const STYLE_SIZE: u64 = 16 + 16 * FILTERS as u64;++fn style_bytes(s: &CloudStyle) -> [u8; STYLE_SIZE as usize] {+ let mode = match s.mode {+ ColorMode::Own => 0.0f32,+ ColorMode::Ramp => 1.0,+ ColorMode::Palette => 2.0,+ };+ let mut words = vec![mode.to_bits(), s.point_size.to_bits(), s.range[0].to_bits(), s.range[1].to_bits()];+ for f in &s.filters {+ // Kind, then a range's ends, or the first value and the mask of those kept.+ words.extend(match *f {+ CloudFilter::Off => [0.0f32.to_bits(), 0, 0, 0],+ CloudFilter::Range([lo, hi]) => [1.0f32.to_bits(), lo.to_bits(), hi.to_bits(), 0],+ CloudFilter::Values { offset, mask } => [2.0f32.to_bits(), (offset as f32).to_bits(), 0, mask],+ });+ }+ let mut out = [0u8; STYLE_SIZE as usize];+ for (o, w) in out.as_chunks_mut::<4>().0.iter_mut().zip(words) {+ *o = w.to_le_bytes();+ }+ out+}++/// The pipeline that draws clouds' dots, and the layout of their styles.+pub(super) struct CloudPipes {+ layout: wgpu::BindGroupLayout,+ dots: wgpu::RenderPipeline,+}++impl CloudPipes {+ pub(super) fn new(+ device: &wgpu::Device,+ module: &wgpu::ShaderModule,+ viewport: &wgpu::BindGroupLayout,+ target: super::GpuTarget,+ depth: Option<wgpu::DepthStencilState>,+ ) -> CloudPipes {+ let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: Some("sc_cloud"),+ entries: &[wgpu::BindGroupLayoutEntry {+ binding: 3,+ visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,+ ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None },+ count: None,+ }],+ });+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: Some("sc_cloud"),+ bind_group_layouts: &[Some(viewport), Some(&layout)],+ immediate_size: 0,+ });+ let dots = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some("vs_cloud_dot"),+ layout: Some(&pipeline_layout),+ vertex: wgpu::VertexState {+ module,+ entry_point: Some("vs_cloud_dot"),+ buffers: &[Some(dot_layout())],+ compilation_options: Default::default(),+ },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },+ depth_stencil: depth,+ multisample: wgpu::MultisampleState { count: target.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },+ fragment: Some(wgpu::FragmentState {+ module,+ entry_point: Some("fs_cloud"),+ targets: &[Some(wgpu::ColorTargetState { format: target.format, blend: None, write_mask: wgpu::ColorWrites::ALL })],+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ });+ CloudPipes { layout, dots }+ }+}++/// A cloud on the GPU: its dots and its style's uniform.+struct Uploaded {+ version: u64,+ dots: Option<Batch>,+ style: wgpu::Buffer,+ bind: wgpu::BindGroup,+}++/// The clouds on the GPU, by id.+#[derive(Default)]+pub(super) struct CloudDraws(std::collections::HashMap<u64, Uploaded>);++impl CloudDraws {+ /// Upload new or changed clouds, drop removed ones, and write every style.+ pub(super) fn prepare(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pipes: &CloudPipes, clouds: &[GpuCloud]) {+ self.0.retain(|id, _| clouds.iter().any(|c| c.id == *id));+ for c in clouds {+ if self.0.get(&c.id).is_none_or(|u| u.version != c.version) {+ let style = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("sc_cloud_style"),+ size: STYLE_SIZE,+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("sc_cloud_style"),+ layout: &pipes.layout,+ entries: &[wgpu::BindGroupEntry { binding: 3, resource: style.as_entire_binding() }],+ });+ let dots = upload(device, "sc_cloud", &c.dots, DOT_SIZE);+ self.0.insert(c.id, Uploaded { version: c.version, dots, style, bind });+ }+ if let Some(u) = self.0.get(&c.id) {+ queue.write_buffer(&u.style, 0, &style_bytes(&c.style));+ }+ }+ }++ pub(super) fn paint(&self, pass: &mut wgpu::RenderPass<'_>, pipes: &CloudPipes, tally: &Tally) {+ for u in self.0.values() {+ let Some(batch) = &u.dots else { continue };+ pass.set_bind_group(1, &u.bind, &[]);+ pass.set_pipeline(&pipes.dots);+ for (buffer, count) in &batch.parts {+ pass.set_vertex_buffer(0, buffer.slice(..));+ pass.draw(0..6, 0..*count);+ tally.triangles(6, *count);+ }+ }+ }+}++/// What a frame's clouds add to its picture's key.+pub(super) fn hash_clouds(clouds: &[GpuCloud], h: &mut impl std::hash::Hasher) {+ use std::hash::Hash as _;+ for c in clouds {+ c.id.hash(h);+ c.version.hash(h);+ style_bytes(&c.style).hash(h);+ }+}diff --git a/crates/gpu/src/view/msaa_check.rs b/crates/gpu/src/view/msaa_check.rsindex 0afcc6d463..a70e7ab593 100644--- a/crates/gpu/src/view/msaa_check.rs+++ b/crates/gpu/src/view/msaa_check.rs@@ -113,7 +113,7 @@ impl Renderer {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: [0.0; 36],access: None,diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rsindex b172a6467a..4d1811800c 100644--- a/crates/io/src/lib.rs+++ b/crates/io/src/lib.rs@@ -28,6 +28,7 @@ mod native_cad;pub use native_cad::{NATIVE_CAD_EXTS, is_native_cad_path, native_cad_to_step};pub mod paper;mod ply;+mod ply_complex;pub use ply::{ply_counts, read_ply_mesh};mod point_cloud;pub use point_cloud::{CloudFile, DEFAULT_MAX_POINTS, MAX_POINT_CLOUD_BYTES, is_ply_path, is_point_cloud_path, read_point_cloud};diff --git a/crates/io/src/ply.rs b/crates/io/src/ply.rsindex fc6c8fca57..5b702905b0 100644--- a/crates/io/src/ply.rs+++ b/crates/io/src/ply.rs@@ -25,7 +25,7 @@ fn invalid(m: impl std::fmt::Display) -> IoError {}#[derive(Clone, Copy, Debug, PartialEq)]-enum Scalar {+pub(crate) enum Scalar {I8,U8,I16,@@ -50,7 +50,7 @@ impl Scalar {_ => return None,})}- fn size(self) -> usize {+ pub(crate) fn size(self) -> usize {match self {Scalar::I8 | Scalar::U8 => 1,Scalar::I16 | Scalar::U16 => 2,@@ -79,7 +79,7 @@ impl Scalar {})}/// A colour channel of this type as a byte: integers by their range, floats from 0..1.- fn channel(self, v: f64) -> u8 {+ pub(crate) fn channel(self, v: f64) -> u8 {let v = match self {Scalar::F32 | Scalar::F64 => v * 255.0,Scalar::U16 | Scalar::I16 => v / 257.0,@@ -91,23 +91,23 @@ impl Scalar {}#[derive(Clone, Copy, Debug, PartialEq)]-enum Kind {+pub(crate) enum Kind {Scalar(Scalar),/// The count's type and the items' type.List(Scalar, Scalar),}#[derive(Clone, Debug)]-struct Property {- name: String,- kind: Kind,+pub(crate) struct Property {+ pub(crate) name: String,+ pub(crate) kind: Kind,}#[derive(Clone, Debug)]-struct Element {- name: String,- count: u64,- properties: Vec<Property>,+pub(crate) struct Element {+ pub(crate) name: String,+ pub(crate) count: u64,+ pub(crate) properties: Vec<Property>,}impl Element {@@ -124,7 +124,7 @@ impl Element {}#[derive(Clone, Copy, Debug, PartialEq)]-enum Encoding {+pub(crate) enum Encoding {Ascii,Little,Big,@@ -132,10 +132,12 @@ enum Encoding {/// What the header says, and where the rows start.#[derive(Debug)]-struct Header {- encoding: Encoding,- elements: Vec<Element>,- body: usize,+pub(crate) struct Header {+ pub(crate) encoding: Encoding,+ pub(crate) elements: Vec<Element>,+ pub(crate) body: usize,+ /// The text of the `comment` lines.+ pub(crate) comments: Vec<String>,}/// Does `bytes` start like a PLY file?@@ -143,7 +145,7 @@ pub fn is_ply(bytes: &[u8]) -> bool {bytes.starts_with(b"ply") && bytes.get(3).is_some_and(|b| matches!(b, b'\n' | b'\r'))}-fn header(bytes: &[u8]) -> Result<Header> {+pub(crate) fn header(bytes: &[u8]) -> Result<Header> {if !is_ply(bytes) {return Err(invalid("not a PLY file (it must start with `ply`)"));}@@ -163,7 +165,12 @@ fn header(bytes: &[u8]) -> Result<Header> {let text = String::from_utf8_lossy(head.get(..end).unwrap_or_default());let mut encoding = None;let mut elements: Vec<Element> = Vec::new();+ let mut comments = Vec::new();for line in text.split(['\n', '\r']).skip(1) {+ if let Some(c) = line.strip_prefix("comment ") {+ comments.push(c.trim().to_string());+ continue;+ }let mut it = line.split_whitespace();match it.next() {Some("format") => {@@ -206,11 +213,11 @@ fn header(bytes: &[u8]) -> Result<Header> {}}let encoding = encoding.ok_or_else(|| invalid("no `format` line"))?;- Ok(Header { encoding, elements, body })+ Ok(Header { encoding, elements, body, comments })}/// A row's values, read one after another.-enum Rows<'a> {+pub(crate) enum Rows<'a> {Binary { b: &'a [u8], pos: usize, big: bool },Ascii { tokens: std::slice::Split<'a, u8, fn(&u8) -> bool> },}@@ -220,7 +227,7 @@ fn space(b: &u8) -> bool {}impl<'a> Rows<'a> {- fn new(h: &Header, bytes: &'a [u8]) -> Rows<'a> {+ pub(crate) fn new(h: &Header, bytes: &'a [u8]) -> Rows<'a> {let b = bytes.get(h.body..).unwrap_or_default();match h.encoding {Encoding::Ascii => Rows::Ascii { tokens: b.split(space as fn(&u8) -> bool) },@@ -228,7 +235,7 @@ impl<'a> Rows<'a> {Encoding::Big => Rows::Binary { b, pos: 0, big: true },}}- fn value(&mut self, t: Scalar) -> Result<f64> {+ pub(crate) fn value(&mut self, t: Scalar) -> Result<f64> {match self {Rows::Binary { b, pos, big } => {let v = b.get(*pos..).and_then(|r| t.read(r, *big)).ok_or_else(|| invalid("the file ends early"))?;@@ -265,7 +272,7 @@ impl<'a> Rows<'a> {}}}- fn count(&mut self, t: Scalar) -> Result<usize> {+ pub(crate) fn count(&mut self, t: Scalar) -> Result<usize> {let n = self.value(t)?;if !(n >= 0.0 && n <= MAX_FACE as f64 && n.fract() == 0.0) {return Err(invalid("a list is longer than SolidCraft reads"));@@ -316,7 +323,6 @@ pub(crate) type Vertex = ([f64; 3], Option<[u8; 3]>);/// into `faces` (a fan of triangles per face) when given.struct Read {vertices: u64,- colored: bool,bad_faces: usize,}@@ -327,7 +333,7 @@ fn walk(bytes: &[u8], keep: &mut dyn FnMut(u64) -> bool, on_vertex: &mut dyn FnMif w.xyz.is_none() {return Err(invalid("the vertices have no `x`, `y` and `z`"));}- let mut out = Read { vertices: vertex.count, colored: w.rgb.is_some(), bad_faces: 0 };+ let mut out = Read { vertices: vertex.count, bad_faces: 0 };let body = bytes.len().saturating_sub(h.body) as u64;let mut rows = Rows::new(&h, bytes);let mut slots = vec![0.0f64; MAX_PROPERTIES];@@ -447,14 +453,6 @@ fn walk(bytes: &[u8], keep: &mut dyn FnMut(u64) -> bool, on_vertex: &mut dyn FnMOk(out)}-/// The vertices of a PLY file, every `stride`th one (`1`: all), and how many the file has.-/// The colour of each is `Some` when the file has colours.-pub(crate) fn read_vertices(bytes: &[u8], stride: u64, on_vertex: &mut dyn FnMut(Vertex)) -> Result<(u64, bool)> {- let stride = stride.max(1);- let r = walk(bytes, &mut |i| i.is_multiple_of(stride), on_vertex, None)?;- Ok((r.vertices, r.colored))-}-/// How many vertices and faces a PLY file says it has (from its header alone).pub fn ply_counts(bytes: &[u8]) -> Result<(u64, u64)> {let h = header(bytes)?;@@ -501,10 +499,12 @@ pub fn read_ply_mesh(bytes: &[u8], name: &str) -> Result<(Vec<MeshObject>, Vec<Smod tests {use super::*;- fn vertices(bytes: &[u8], stride: u64) -> Result<(Vec<Vertex>, u64, bool)> {- let mut out = Vec::new();- let (n, c) = read_vertices(bytes, stride, &mut |v| out.push(v))?;- Ok((out, n, c))+ /// The vertices kept from at most `max` of them, how many the file has, and whether it has colours.+ fn vertices(bytes: &[u8], max: usize) -> Result<(Vec<Vertex>, u64, bool)> {+ let r = crate::ply_complex::read_ply_cloud(bytes, max)?;+ let colors = r.colors.as_ref();+ let out = r.positions.iter().enumerate().map(|(i, p)| (*p, colors.and_then(|c| c.get(i).copied()))).collect();+ Ok((out, r.vertices, colors.is_some()))}fn binary(big: bool) -> Vec<u8> {@@ -532,7 +532,7 @@ mod tests {#[test]fn binary_little_and_big_endian_with_colours_and_other_elements() {for big in [false, true] {- let (v, n, colored) = vertices(&binary(big), 1).unwrap();+ let (v, n, colored) = vertices(&binary(big), 3).unwrap();assert_eq!((n, colored), (3, true));assert_eq!(v[1], ([1.5, 0.0, 0.0], Some([10, 20, 255])));assert_eq!(v[2].0, [0.0, 2.5, -3.0]);@@ -551,7 +551,7 @@ mod tests {let src = "ply\nformat ascii 1.0\nelement vertex 4\nproperty double x\nproperty double y\nproperty double z\nproperty float red\nproperty float green\nproperty float blue\n\element face 1\nproperty list uchar uint vertex_index\nend_header\n\0 0 0 1 0 0\n1 0 0 0 1 0\n1 1 0 0 0 1\n0 1 0 0.5 0.5 0.5\n4 0 1 2 3\n";- let (v, n, colored) = vertices(src.as_bytes(), 1).unwrap();+ let (v, n, colored) = vertices(src.as_bytes(), 4).unwrap();assert_eq!((n, colored, v.len()), (4, true, 4));assert_eq!(v[0].1, Some([255, 0, 0]));assert_eq!(v[3], ([0.0, 1.0, 0.0], Some([128, 128, 128])));@@ -560,7 +560,7 @@ mod tests {// Only points (as the glim maps are written): no colours, no faces.let points ="ply\nformat ascii 1.0\nelement vertex 2\nproperty float32 x\nproperty float32 y\nproperty float32 z\nend_header\n1 2 3\n4 5 6\n";- let (v, n, colored) = vertices(points.as_bytes(), 1).unwrap();+ let (v, n, colored) = vertices(points.as_bytes(), 2).unwrap();assert_eq!((v.len(), n, colored), (2, 2, false));assert_eq!(v[1], ([4.0, 5.0, 6.0], None));assert!(read_ply_mesh(points.as_bytes(), "x").is_err(), "a point cloud is not a mesh");@@ -589,13 +589,13 @@ mod tests {for c in &cases {let r = std::panic::catch_unwind(|| {let _ = vertices(c, 1);- let _ = vertices(c, 3);+ let _ = vertices(c, 1000);let _ = read_ply_mesh(c, "x");let _ = ply_counts(c);});assert!(r.is_ok(), "{:?}", String::from_utf8_lossy(c));}- assert!(vertices(&good[..good.len() - 30], 1).is_err(), "a cut-off file is refused");+ assert!(vertices(&good[..good.len() - 30], 1000).is_err(), "a cut-off file is refused");// A face naming a vertex that isn't there is left out, with a warning.let tri = "ply\nformat ascii 1.0\nelement vertex 3\nproperty float x\nproperty float y\nproperty float z\nelement face 2\nproperty list uchar int vertex_indices\nend_header\n0 0 0 1 0 0 0 1 0\n3 0 1 2\n3 0 1 99\n";let (mesh, warnings) = read_ply_mesh(tri.as_bytes(), "x").unwrap();diff --git a/crates/io/src/ply_complex.rs b/crates/io/src/ply_complex.rsnew file mode 100644index 0000000000..ff8c4c290d--- /dev/null+++ b/crates/io/src/ply_complex.rs@@ -0,0 +1,147 @@+//! A PLY file read with everything a point cloud can hold: its vertices with all their+//! properties. Positions are `x`, `y`, `z` and colours `red`, `green`, `blue`; every other scalar+//! property becomes a column named as in the file, whole-numbered when its type is an integer. A+//! comment `property: 0 name, 1 name` names the values of a whole-numbered property. Every+//! `stride`th vertex is kept.++use solidcraft_doc::point_cloud::{Column, Complex, Floats, MAX_COLUMNS, Names};++use crate::ply::{Element, Kind, Rows, Scalar, header};+use crate::{IoError, Result};++fn invalid(m: impl std::fmt::Display) -> IoError {+ IoError::Invalid(format!("PLY: {m}"))+}++/// What a PLY file holds, positions in the file's units.+pub(crate) struct PlyCloud {+ pub positions: Vec<[f64; 3]>,+ pub colors: Option<Vec<[u8; 3]>>,+ pub complex: Complex,+ /// Vertices in the file.+ pub vertices: u64,+}++fn integer(s: Scalar) -> bool {+ !matches!(s, Scalar::F32 | Scalar::F64)+}++fn named(e: &Element, names: &[&str]) -> Option<usize> {+ names.iter().find_map(|n| e.properties.iter().position(|p| p.name.eq_ignore_ascii_case(n) && matches!(p.kind, Kind::Scalar(_))))+}++/// The columns an element's scalar properties fill, leaving out those at `taken`.+fn columns_of(e: &Element, taken: &[usize]) -> Vec<(usize, Column)> {+ e.properties+ .iter()+ .enumerate()+ .filter(|(i, _)| !taken.contains(i))+ .filter_map(|(i, p)| match p.kind {+ Kind::Scalar(s) => Some((i, Column { name: p.name.clone(), integer: integer(s), values: Floats::default() })),+ Kind::List(..) => None,+ })+ .collect()+}++/// Read a PLY file's vertices, every `stride`th one of those beyond `max_points`.+pub(crate) fn read_ply_cloud(bytes: &[u8], max_points: usize) -> Result<PlyCloud> {+ let h = header(bytes)?;+ let vertex = h.elements.iter().find(|e| e.name == "vertex").ok_or_else(|| invalid("no `vertex` element"))?;+ let stride = vertex.count.div_ceil(max_points.max(1) as u64).max(1);+ let xyz = [named(vertex, &["x"]), named(vertex, &["y"]), named(vertex, &["z"])];+ let [Some(x), Some(y), Some(z)] = xyz else { return Err(invalid("the vertices have no `x`, `y` and `z`")) };+ let rgb =+ [named(vertex, &["red", "r", "diffuse_red"]), named(vertex, &["green", "g", "diffuse_green"]), named(vertex, &["blue", "b", "diffuse_blue"])];+ let rgb = match rgb {+ [Some(r), Some(g), Some(b)] => Some([r, g, b]),+ _ => None,+ };+ let mut taken = vec![x, y, z];+ taken.extend(rgb.into_iter().flatten());+ let mine = columns_of(vertex, &taken);+ if mine.len() > MAX_COLUMNS {+ return Err(invalid(format!("more than {MAX_COLUMNS} properties")));+ }+ let body = bytes.len().saturating_sub(h.body) as u64;+ let mut rows = Rows::new(&h, bytes);+ let mut out = PlyCloud { positions: Vec::new(), colors: rgb.map(|_| Vec::new()), complex: Complex::default(), vertices: vertex.count };+ let mut columns: Vec<(usize, Vec<f32>, Column)> = mine.into_iter().map(|(i, c)| (i, Vec::new(), c)).collect();+ let mut row = vec![0.0f64; vertex.properties.len()];+ // The elements before the vertices are read past.+ for e in h.elements.iter().take_while(|e| e.name != "vertex").chain([vertex]) {+ if e.count > body {+ return Err(invalid(format!("the file is too short for its {} {}", e.count, e.name)));+ }+ let vertices = std::ptr::eq(e, vertex);+ for r in 0..e.count {+ for (i, p) in e.properties.iter().enumerate() {+ match p.kind {+ Kind::Scalar(t) => {+ let v = rows.value(t)?;+ if let Some(s) = row.get_mut(i).filter(|_| vertices) {+ *s = v;+ }+ }+ Kind::List(c, t) => {+ for _ in 0..rows.count(c)? {+ rows.value(t)?;+ }+ }+ }+ }+ if !vertices || !r.is_multiple_of(stride) {+ continue;+ }+ let v = |i: usize| row.get(i).copied().unwrap_or(0.0);+ out.positions.push([v(x), v(y), v(z)]);+ if let (Some(c), Some(ks)) = (out.colors.as_mut(), rgb) {+ let t = |i: usize| match vertex.properties.get(i).map(|p| p.kind) {+ Some(Kind::Scalar(s)) => s.channel(v(i)),+ _ => 0,+ };+ c.push(ks.map(t));+ }+ for (slot, values, _) in &mut columns {+ values.push(v(*slot) as f32);+ }+ }+ }+ let columns: Vec<Column> = columns.into_iter().map(|(_, values, c)| Column { values: Floats(values.into()), ..c }).collect();+ // Names only for whole-numbered properties the file has, the first comment for each.+ let mut names: Vec<Names> = Vec::new();+ for n in h.comments.iter().filter_map(|c| Names::parse(c)) {+ let label = columns.iter().any(|c| c.name == n.property && c.integer);+ if label && !names.iter().any(|m| m.property == n.property) && names.len() < MAX_COLUMNS {+ names.push(n);+ }+ }+ out.complex = Complex { columns, names };+ Ok(out)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn every_vertex_property_is_kept() {+ let text = "ply\nformat ascii 1.0\ncomment role: 7 wall, -1 none\ncomment t: seconds since the start\ncomment width: 0 thin\n\+ element vertex 4\nproperty float x\nproperty float y\nproperty float z\nproperty double t\nproperty int role\nproperty float width\n\+ element face 1\nproperty list uchar int vertex_indices\nend_header\n\+ 0 0 0 0.5 7 1\n1 0 0 1.5 7 1\n1 1 0 2.5 -1 2\n0 1 0 3.5 -1 2\n4 0 1 2 3\n";+ let r = read_ply_cloud(text.as_bytes(), 10).unwrap();+ assert_eq!(r.positions.len(), 4);+ let col = |n: &str| r.complex.column(n).unwrap();+ assert_eq!(&*col("t").values.0, &[0.5, 1.5, 2.5, 3.5]);+ assert!(col("role").integer && !col("width").integer);+ assert_eq!(&*col("role").values.0, &[7.0, 7.0, -1.0, -1.0]);+ r.complex.check(4).unwrap();+ // Names for the whole-numbered `role` only: `t` is no list and `width` is not whole.+ assert_eq!(r.complex.names.len(), 1);+ assert_eq!(r.complex.names("role").and_then(|n| n.name(-1)), Some("none"));+ // Every second vertex, with its numbers.+ let half = read_ply_cloud(text.as_bytes(), 2).unwrap();+ assert_eq!((half.positions.len(), &*half.complex.column("t").unwrap().values.0), (2, &[0.5f32, 2.5][..]));+ half.complex.check(2).unwrap();+ }+}diff --git a/crates/io/src/point_cloud.rs b/crates/io/src/point_cloud.rsindex 3790fa9b8b..02fb59620b 100644--- a/crates/io/src/point_cloud.rs+++ b/crates/io/src/point_cloud.rs@@ -34,6 +34,8 @@ pub struct CloudFile {pub colors: Vec<u8>,/// Points in the file.pub source_points: u64,+ /// The file's other properties of the points (PLY).+ pub complex: solidcraft_doc::point_cloud::Complex,pub warnings: Vec<String>,}@@ -77,20 +79,19 @@ pub fn read_point_cloud(bytes: &[u8], file: &str, scale: f64, max_points: usize)let ply = crate::ply::is_ply(bytes) || (is_ply_path(file) && !bytes.is_empty());let stride;if ply {- let (count, _) = crate::ply::ply_counts(bytes)?;- stride = count.div_ceil(max as u64).max(1);- keep.out.points.reserve(count.div_ceil(stride).min(max as u64) as usize * 3);- // Colours are known once the header is read: the first vertex says.- let mut first = true;- let (count, colored) = crate::ply::read_vertices(bytes, stride, &mut |(p, rgb)| {- if first {- keep.colored = rgb.is_some();- first = false;- }- keep.push(p, rgb);- })?;- keep.out.source_points = count;- keep.colored &= colored;+ let r = crate::ply_complex::read_ply_cloud(bytes, max)?;+ stride = r.vertices.div_ceil(r.positions.len().max(1) as u64).max(1);+ keep.colored = r.colors.is_some();+ let colors = r.colors.unwrap_or_default();+ for (i, p) in r.positions.iter().enumerate() {+ keep.push(*p, colors.get(i).copied());+ }+ // A point left out would shift every number after it.+ if keep.bad > 0 && !r.complex.is_empty() {+ return Err(IoError::Invalid(format!("{} point(s) are not finite numbers within range", keep.bad)));+ }+ keep.out.source_points = r.vertices;+ keep.out.complex = r.complex;} else {stride = read_xyz(bytes, &mut keep)?;}diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rsindex e363c44b5e..edc15b4b20 100644--- a/crates/ui-egui/src/browser.rs+++ b/crates/ui-egui/src/browser.rs@@ -24,6 +24,7 @@ mod model;mod features;mod point_clouds;pub use point_clouds::CloudPanel;+pub(crate) use point_clouds::point_cloud_tracks;pub(crate) fn reveal_feature(app: &mut SolveApp, id: u64, body: &str) {features::reveal(app, id, body);diff --git a/crates/ui-egui/src/browser/point_cloud_tracks.rs b/crates/ui-egui/src/browser/point_cloud_tracks.rsnew file mode 100644index 0000000000..04e32694ce--- /dev/null+++ b/crates/ui-egui/src/browser/point_cloud_tracks.rs@@ -0,0 +1,219 @@+//! What the Edit Point Cloud card's range tracks draw, worked out off the frame: each track's+//! bars over the whole span and over its loupe, and the values its ends snap to. A track asks+//! every frame; a worker thread answers the newest asks (on the web, where there are no threads,+//! they are answered at once), and until then the track shows its last answer. The view asks too,+//! for the values the coloured property takes over what is kept: the ramp's automatic range.++use std::collections::HashMap;+use std::sync::{Arc, Condvar, Mutex};++use egui::Color32;+use solidcraft_engine::doc::point_cloud::{Filter, PALETTE, PLAIN, PointCloud, byte, height_ramp};+use solidcraft_engine::doc::point_cloud_distribution::{Colour, Geometry, histogram, label_changes};++use super::range_track::Bars;+use crate::theme::model_color;++/// Equal bands a ramp's bars are split into.+const RAMP_BANDS: usize = 32;++/// How a track's bars are coloured.+#[derive(Clone, Debug, PartialEq)]+pub(crate) enum Paint {+ /// One colour.+ One,+ /// The ramp over `range` of `property`; painted at each value when the track is that property.+ Ramp { property: String, range: [f64; 2] },+ /// The palette of a whole-numbered `property`.+ Palette { property: String },+}++/// What a track asks for: its property's bars over the whole span and over the loupe, in `bins`+/// bins each, over what `filters` keep; and the values where `changes_of` changes along it.+#[derive(Clone, Debug, PartialEq)]+pub(crate) struct Ask {+ pub property: String,+ pub span: [f64; 2],+ pub loupe: [f64; 2],+ pub bins: usize,+ pub paint: Paint,+ pub filters: Vec<Filter>,+ pub changes_of: Option<String>,+}++/// A track's answer.+#[derive(Clone, Debug, Default)]+pub(crate) struct Answer {+ pub(super) overview: Bars,+ pub(super) loupe: Bars,+ pub(super) changes: Arc<Vec<f64>>,+ /// The least and the greatest value the property takes over what is kept.+ pub extent: Option<[f64; 2]>,+}++/// The cloud's data as far as the tracks are concerned: its points, columns and placement.+type DataKey = Vec<u64>;++fn data_key(c: &PointCloud) -> DataKey {+ let mut k = vec![Arc::as_ptr(c.points.values()).cast::<f32>() as u64, c.origin.x.to_bits(), c.origin.y.to_bits(), c.origin.z.to_bits()];+ k.extend(c.complex.columns.iter().map(|col| Arc::as_ptr(&col.values.0).cast::<f32>() as u64));+ k.extend(c.transform.iter().flatten().map(|v| v.to_bits()));+ k+}++/// What answers need of a cloud, worked out once for its data.+struct Prepared {+ key: DataKey,+ cloud: Arc<PointCloud>,+ geometry: Option<Arc<Geometry>>,+ changes: HashMap<(String, String), Arc<Vec<f64>>>,+}++impl Prepared {+ fn answer(&mut self, ask: &Ask) -> Answer {+ let c = &self.cloud;+ let geometry = self.geometry.get_or_insert_with(|| Arc::new(Geometry::of(c))).clone();+ let (colour, colours, ramp) = match &ask.paint {+ // Coloured by its own property, each value has its colour: the bars are one slot,+ // painted along the ramp.+ Paint::Ramp { property, range } if *property == ask.property => (Colour::One, vec![plain()], Some(*range)),+ Paint::Ramp { property, range } => (+ Colour::Ramp { property, range: *range, bands: RAMP_BANDS },+ (0..RAMP_BANDS).map(|k| model_color(height_ramp((k as f64 + 0.5) / RAMP_BANDS as f64))).chain([plain()]).collect(),+ None,+ ),+ Paint::Palette { property } => {+ (Colour::Palette { property }, PALETTE.iter().map(|c| model_color(*c)).chain([plain(), plain()]).collect(), None)+ }+ Paint::One => (Colour::One, vec![plain()], None),+ };+ let bars = |axis: [f64; 2]| {+ let h = histogram(c, &geometry, &ask.property, axis, ask.bins, &colour, &ask.filters);+ let extent = h.as_ref().and_then(|h| h.extent);+ (Bars { axis, slots: h.map(|h| h.slots).unwrap_or_default(), colours: colours.clone(), ramp }, extent)+ };+ let (overview, extent) = bars(ask.span);+ let loupe = if ask.loupe == ask.span { overview.clone() } else { bars(ask.loupe).0 };+ let changes = match &ask.changes_of {+ Some(label) => self+ .changes+ .entry((label.clone(), ask.property.clone()))+ .or_insert_with(|| Arc::new(label_changes(c, &geometry, label, &ask.property)))+ .clone(),+ None => Arc::default(),+ };+ Answer { overview, loupe, changes, extent }+ }+}++/// What has no colour of its own: the cloud's plain colour.+fn plain() -> Color32 {+ model_color(PLAIN.map(byte))+}++#[derive(Default)]+struct Inner {+ cloud: Option<(DataKey, Arc<PointCloud>)>,+ asked: HashMap<String, Ask>,+ answers: HashMap<String, (Ask, Arc<Answer>)>,+}++#[derive(Default)]+struct Shared {+ inner: Mutex<Inner>,+ asked: Condvar,+}++/// The answers of one card's tracks; clones share them.+#[derive(Clone, Default)]+pub(crate) struct Tracks {+ shared: Arc<Shared>,+ #[cfg(not(target_arch = "wasm32"))]+ worker: Arc<std::sync::OnceLock<()>>,+}++impl std::fmt::Debug for Tracks {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.write_str("Tracks")+ }+}++impl Tracks {+ /// The last answer to the track `key` (maybe to an older ask), asking `ask` of `cloud` when+ /// that is new.+ pub(crate) fn answer(&self, ctx: &egui::Context, cloud: &PointCloud, key: &str, ask: Ask) -> Option<Arc<Answer>> {+ let Ok(mut inner) = self.shared.inner.lock() else { return None };+ let data = data_key(cloud);+ if inner.cloud.as_ref().is_none_or(|(k, _)| *k != data) {+ inner.cloud = Some((data, Arc::new(cloud.clone())));+ }+ let last = inner.answers.get(key).cloned();+ let answered = last.as_ref().is_some_and(|(a, _)| *a == ask);+ if !answered && inner.asked.get(key) != Some(&ask) {+ inner.asked.insert(key.to_string(), ask);+ drop(inner);+ self.work(ctx);+ }+ last.map(|(_, a)| a)+ }++ /// Whether the track `key` has an answer to its last ask.+ #[cfg(test)]+ pub(super) fn answered(&self, key: &str) -> bool {+ self.shared.inner.lock().is_ok_and(|i| !i.asked.contains_key(key) && i.answers.contains_key(key))+ }++ #[cfg(not(target_arch = "wasm32"))]+ fn work(&self, ctx: &egui::Context) {+ self.shared.asked.notify_one();+ self.worker.get_or_init(|| {+ let shared = Arc::downgrade(&self.shared);+ let ctx = ctx.clone();+ let _ = std::thread::Builder::new().name("point-cloud-tracks".into()).spawn(move || work(&shared, &ctx));+ });+ }++ #[cfg(target_arch = "wasm32")]+ fn work(&self, ctx: &egui::Context) {+ let mut prepared = None;+ while answer_one(&self.shared, &mut prepared) {}+ ctx.request_repaint();+ }+}++/// Answer one ask, if there is one.+fn answer_one(shared: &Shared, prepared: &mut Option<Prepared>) -> bool {+ let (key, ask, data, cloud) = {+ let Ok(mut inner) = shared.inner.lock() else { return false };+ let Some(key) = inner.asked.keys().next().cloned() else { return false };+ let Some(ask) = inner.asked.remove(&key) else { return false };+ let Some((data, cloud)) = inner.cloud.clone() else { return false };+ (key, ask, data, cloud)+ };+ if prepared.as_ref().is_none_or(|p| p.key != data) {+ *prepared = Some(Prepared { key: data, cloud, geometry: None, changes: HashMap::new() });+ }+ let Some(p) = prepared.as_mut() else { return false };+ let answer = Arc::new(p.answer(&ask));+ if let Ok(mut inner) = shared.inner.lock() {+ inner.answers.insert(key, (ask, answer));+ }+ true+}++/// The worker: answers asks as they come, until the card is gone.+#[cfg(not(target_arch = "wasm32"))]+fn work(shared: &std::sync::Weak<Shared>, ctx: &egui::Context) {+ let mut prepared = None;+ loop {+ let Some(s) = shared.upgrade() else { return };+ if answer_one(&s, &mut prepared) {+ ctx.request_repaint();+ continue;+ }+ let Ok(inner) = s.inner.lock() else { return };+ if inner.asked.is_empty() {+ let _ = s.asked.wait_timeout(inner, std::time::Duration::from_millis(500));+ }+ }+}diff --git a/crates/ui-egui/src/browser/point_clouds.rs b/crates/ui-egui/src/browser/point_clouds.rsindex 0e504e1bc0..2c17627f30 100644--- a/crates/ui-egui/src/browser/point_clouds.rs+++ b/crates/ui-egui/src/browser/point_clouds.rs@@ -1,10 +1,13 @@//! The Point Clouds folder of the Browser (#5151): an eye per cloud and for the folder, a menu,-//! and the Edit Point Cloud card (the file's units, the size of the dots, how they are coloured:-//! the file's colours, one colour, or by height between two heights), whose live edits of one-//! opening are one undo step.+//! and the Edit Point Cloud card: the file's units, the size of the dots, how the cloud is+//! coloured (its colours, one colour, a ramp over a property, its range on a track, or the+//! palette of a label, with its legend), and its filters (a range on a track, played with ▶ or+//! Space, or the values of a label picked in its legend). Each track shows how much of the cloud+//! lies at each value, over what the other filters keep. The live edits of one opening are one+//! undo step.use serde_json::{Value, json};-use solidcraft_engine::doc::point_cloud::{ColorBy, PLAIN, PointCloud, UNITS, byte};+use solidcraft_engine::doc::point_cloud::{COORDINATES, ColorBy, Filter, Keep, MAX_FILTERS, Names, PLAIN, PointCloud, UNITS, byte, label_color};use solidcraft_engine::view::POINT_CLOUDS_FOLDER;use super::{Actions, Row, draw_row, is_open, panel_pos, toggle, toggle_folder};@@ -12,18 +15,86 @@ use crate::SolveApp;use crate::context_menu::{Item, Target};use crate::ui_kit;-/// The Edit Point Cloud card: the cloud, the undo depth when it opened, and the automatic-/// height range of the points it was worked out for (it sorts a sample of them).+#[path = "point_cloud_tracks.rs"]+pub(crate) mod point_cloud_tracks;+#[path = "range_track.rs"]+mod range_track;+use point_cloud_tracks::{Ask, Paint, Tracks};+use range_track::{Part, Track, range_track};++/// Filters the GPU applies; the others are kept but not drawn.+pub const DRAWN_FILTERS: usize = solidcraft_gpu::view::FILTERS;++/// The Edit Point Cloud card: the cloud, the undo depth when it opened, what it worked out once+/// for the cloud's data (the automatic height range), its tracks' bars, and a filter playing.#[derive(Clone, Debug)]pub struct CloudPanel {pub cloud: u64,pub(crate) depth: usize,auto: Option<(usize, [u64; 16], Option<[f64; 2]>)>,+ tracks: Tracks,+ pub play: Option<Play>,+}++/// A range filter moving on its own: the part of it touched last moves forward (its upper end+/// unrolls, its band slides, its lower end wipes), across its track's loupe in [`PLAY_SECONDS`].+/// It is written to the design once, when it stops.+#[derive(Clone, Debug)]+pub struct Play {+ pub filter: usize,+ part: Part,+ /// When it last moved, and where it is exactly.+ at: f64,+ exact: [f64; 2],+ /// The range now (a whole-numbered property's ends whole).+ pub now: [f64; 2],+}++/// How long playing a filter across its track's loupe takes, in seconds: zooming in slows it.+const PLAY_SECONDS: f64 = 20.0;++/// The names of a cloud's tracks.+fn filter_key(cloud: u64, k: usize) -> String {+ format!("point_cloud_{cloud}_filter_{k}")+}+fn colour_key(cloud: u64) -> String {+ format!("point_cloud_{cloud}_colour")+}++impl Play {+ /// Start playing `part` of `range` within `span`, from the start again when it is at the end.+ fn new(filter: usize, part: Part, [lo, hi]: [f64; 2], span: [f64; 2], at: f64) -> Play {+ let exact = match part {+ Part::High if hi >= span[1] => [lo, lo],+ Part::Band if hi >= span[1] => [span[0], span[0] + hi - lo],+ Part::Low if lo >= hi => [span[0], hi],+ _ => [lo, hi],+ };+ Play { filter, part, at, exact, now: exact }+ }+ /// Move on to time `now` at `speed` units a second; whether it reached the end.+ fn step(&mut self, now: f64, speed: f64, span: [f64; 2], integer: bool) -> bool {+ let d = speed * (now - self.at).max(0.0);+ self.at = now;+ let [lo, hi] = self.exact;+ let (exact, end) = match self.part {+ Part::High => ([lo, (hi + d).min(span[1])], hi + d >= span[1]),+ Part::Low => ([(lo + d).min(hi), hi], lo + d >= hi),+ Part::Band => {+ let w = hi - lo;+ let start = (lo + d).min(span[1] - w);+ ([start, start + w], lo + d >= span[1] - w)+ }+ };+ self.exact = exact;+ self.now = if integer { exact.map(f64::floor) } else { exact };+ end+ }}impl CloudPanel {pub fn new(app: &SolveApp, cloud: u64) -> Self {- CloudPanel { cloud, depth: app.session.undo.len(), auto: None }+ CloudPanel { cloud, depth: app.session.undo.len(), auto: None, tracks: Tracks::default(), play: None }}/// The cloud's automatic height range, worked out again only when its points or placement/// change.@@ -38,11 +109,80 @@ impl CloudPanel {}}}+ /// The range filter `k` of this card's cloud shows now, while it plays.+ pub fn playing(&self, cloud: u64, k: usize) -> Option<[f64; 2]> {+ self.play.as_ref().filter(|p| self.cloud == cloud && p.filter == k).map(|p| p.now)+ }}/// The ways the card colours the points, as the dropdown lists them.const COLOR_BY: [(ColorBy, &str); 3] = [(ColorBy::File, "File Colors"), (ColorBy::Single, "Single Color"), (ColorBy::Height, "Height")];+/// The names of `property` when it is filtered by a set of values: a label whose values span+/// fewer than the 32 the view's mask holds. Any other property is filtered by a range.+fn label<'a>(c: &'a PointCloud, property: &str) -> Option<&'a Names> {+ let names = c.complex.names(property)?;+ let (lo, hi) = names.values.iter().fold((i32::MAX, i32::MIN), |(lo, hi), (v, _)| (lo.min(*v), hi.max(*v)));+ (i64::from(hi) - i64::from(lo) < 32).then_some(names)+}++/// Bins of a track's bars: about one a point across the card.+fn bins(ui: &egui::Ui) -> usize {+ (ui.available_width().round() as usize).clamp(16, 1024)+}++/// The filters as `pointcloud.edit` takes them.+fn filters_json(filters: &[Filter]) -> Vec<Value> {+ filters.iter().map(|f| serde_json::to_value(f).unwrap_or(Value::Null)).collect()+}++/// The filters with `value` of the label `property` shown or hidden: in its set filter, or in a+/// new one keeping every named value but it.+fn toggled(c: &PointCloud, names: &Names, value: i32) -> Vec<Value> {+ let mut filters = c.filters.clone();+ match filters.iter_mut().find(|f| f.property == names.property && matches!(f.keep, Keep::Values { .. })) {+ Some(Filter { keep: Keep::Values { values }, .. }) => {+ if let Some(k) = values.iter().position(|v| *v == value) {+ values.remove(k);+ } else {+ values.push(value);+ }+ }+ _ => filters.push(Filter {+ property: names.property.clone(),+ keep: Keep::Values { values: names.values.iter().map(|(v, _)| *v).filter(|v| *v != value).collect() },+ }),+ }+ filters_json(&filters)+}++/// A label's legend: a swatch and a name per value, dimmed when a filter hides it. The value+/// clicked, to show or hide.+fn legend(ui: &mut egui::Ui, c: &PointCloud, names: &Names) -> Option<i32> {+ let kept = c.filters.iter().find_map(|f| match &f.keep {+ Keep::Values { values } if f.property == names.property => Some(values.clone()),+ _ => None,+ });+ let mut clicked = None;+ for (v, name) in &names.values {+ let shown = kept.as_ref().is_none_or(|k| k.contains(v));+ let colour = crate::theme::model_color(label_color(f64::from(*v)));+ let swatch = if shown { colour } else { colour.gamma_multiply(0.16) };+ let response = ui+ .horizontal(|ui| {+ let (rect, _) = ui.allocate_exact_size(egui::vec2(14.0, 14.0), egui::Sense::hover());+ ui.painter().rect_filled(rect, 3.0, swatch);+ let text = egui::RichText::new(name.as_str());+ ui.add(egui::Label::new(if shown { text } else { text.weak().strikethrough() }).sense(egui::Sense::click()))+ })+ .inner;+ if response.clicked() {+ clicked = Some(*v);+ }+ }+ clicked+}+pub(super) fn rows(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize, acts: &mut Actions) {let clouds: Vec<(u64, String, bool)> = app.session.doc.point_clouds.iter().map(|c| (c.id, c.name.clone(), c.visible)).collect();if clouds.is_empty() {@@ -104,8 +244,29 @@ pub(crate) fn panel(app: &mut SolveApp, ctx: &egui::Context) {};let mut edit: Option<Value> = None;let title = crate::i18n::format("browser.edit_point_cloud_title", &[("name", &c.name)]);- let (units, decimals) = (app.session.doc.units.clone(), app.preferences.length_decimals);let auto = if c.color_by == ColorBy::Height { m.auto_range(&c) } else { None };+ let now = ctx.input(|i| i.time);+ // A playing filter moves on; at the end of its span it stops, and is written once.+ let mut stop_play = false;+ if let Some(p) = m.play.as_mut()+ && let Some(span) = c.filters.get(p.filter).and_then(|f| c.span(&f.property))+ {+ let integer = c.filters.get(p.filter).is_some_and(|f| c.complex.integer(&f.property));+ let [a, b] = range_track::loupe(ctx, &filter_key(c.id, p.filter), span);+ stop_play = p.step(now, (b - a) / PLAY_SECONDS, span, integer);+ ctx.request_repaint();+ }+ // The cloud as the view draws it now, a playing filter where it is: the filters the tracks+ // apply, how their bars are coloured, as the cloud is, and the values they snap to, where a+ // label changes.+ let live = crate::point_clouds::as_drawn(&c, |k| m.playing(c.id, k)).into_owned();+ let drawn: Vec<Filter> = live.filters.iter().take(DRAWN_FILTERS).cloned().collect();+ let paint = match (c.colored_property(), crate::point_clouds::color_range(ctx, &live)) {+ (Some(n), _) if c.complex.integer(n) => Paint::Palette { property: n.to_string() },+ (Some(n), Some(range)) => Paint::Ramp { property: n.to_string(), range },+ _ => Paint::One,+ };+ let changes_of = c.colored_property().filter(|n| c.complex.integer(n)).map(str::to_string);let at = panel_pos(app);let (closed, action) = ui_kit::Window::new(egui::Id::new("sc_point_cloud_panel"), "point", &title).placed(egui::Align2::LEFT_TOP, at)@@ -113,29 +274,39 @@ pub(crate) fn panel(app: &mut SolveApp, ctx: &egui::Context) {.actions("", crate::i18n::tr("ui.close"), None).show(ctx, true, |ui| {ui_kit::row(ui, crate::i18n::tr_label("Points"), |ui| ui.label(c.len().to_string()));- let names: Vec<&str> = UNITS.iter().map(|(u, _)| *u).collect();- let was = names.iter().position(|u| *u == c.units).unwrap_or(0);+ let mut size = c.point_size;+ if ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_size"), |ui| ui_kit::slider(ui, &mut size, 0.5..=16.0, Default::default())).changed() {+ edit = Some(json!({ "cloud": c.id, "point_size": size }));+ }+ let units: Vec<&str> = UNITS.iter().map(|(u, _)| *u).collect();+ let was = units.iter().position(|u| *u == c.units).unwrap_or(0);let mut unit = was;// A dropdown's response doesn't report the pick: compare the index.- ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_units"), |ui| ui_kit::dropdown(ui, "point_cloud_units", &mut unit, &names));+ ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_units"), |ui| ui_kit::dropdown(ui, "point_cloud_units", &mut unit, &units));if unit != was- && let Some(u) = names.get(unit)+ && let Some(u) = units.get(unit){edit = Some(json!({ "cloud": c.id, "units": u }));}- let mut size = c.point_size;- if ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_size"), |ui| ui_kit::slider(ui, &mut size, 0.5..=16.0, Default::default())).changed() {- edit = Some(json!({ "cloud": c.id, "point_size": size }));- }- let labels: Vec<&str> = COLOR_BY.iter().map(|(_, l)| *l).collect();- let was = COLOR_BY.iter().position(|(b, _)| *b == c.color_by).unwrap_or(0);+ // The ways of colouring, then every property of the file.+ let properties: Vec<&str> = c.property_names().filter(|n| !COORDINATES.contains(n)).collect();+ let labels: Vec<&str> = COLOR_BY.iter().map(|(_, l)| *l).chain(properties.iter().copied()).collect();+ let was = match c.color_by {+ ColorBy::Property => {+ c.color_property.as_deref().and_then(|n| properties.iter().position(|p| *p == n)).map_or(0, |k| COLOR_BY.len() + k)+ }+ by => COLOR_BY.iter().position(|(b, _)| *b == by).unwrap_or(0),+ };let mut by = was;ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_color_by"), |ui| ui_kit::dropdown(ui, "point_cloud_color_by", &mut by, &labels));- if by != was- && let Some((b, _)) = COLOR_BY.get(by)- {- edit = Some(json!({ "cloud": c.id, "color_by": b.name() }));+ if by != was {+ let name = COLOR_BY.get(by).map(|(b, _)| b.name()).or_else(|| properties.get(by - COLOR_BY.len()).copied());+ if let Some(name) = name {+ edit = Some(json!({ "cloud": c.id, "color_by": name }));+ }}+ let colored = c.colored_property();+ let legend_shown = colored.and_then(|n| label(&c, n));match c.color_by {ColorBy::File if c.colors.is_empty() => {ui_kit::row(ui, "", |ui| ui.weak(crate::i18n::tr("ui.point_cloud_no_file_colors")));@@ -147,33 +318,201 @@ pub(crate) fn panel(app: &mut SolveApp, ctx: &egui::Context) {edit = Some(json!({ "cloud": c.id, "color": rgb.map(|v| f64::from(v) / 255.0) }));}}- ColorBy::Height => {- let automatic = c.height_range.is_none();- if ui_kit::checkbox_row(ui, "point_cloud_auto_range", crate::i18n::tr("ui.point_cloud_auto_range"), automatic) {- // Off: start from the range worked out, which the fields then show.- edit = Some(json!({ "cloud": c.id, "height_range": if automatic { json!(auto) } else { Value::Null } }));+ ColorBy::Height | ColorBy::Property => {+ let name = colored.unwrap_or_default();+ if let Some(names) = legend_shown {+ // A label: its legend, which also shows and hides its values.+ if let Some(v) = legend(ui, &c, names) {+ edit = Some(json!({ "cloud": c.id, "filters": toggled(&c, names, v) }));+ }+ } else if !c.complex.integer(name)+ && let Some(span) = if c.color_by == ColorBy::Height { c.span("z").or(auto) } else { c.span(name) }+ {+ // A ramp over what is shown, unless its range is set.+ let automatic = c.height_range.is_none();+ if ui_kit::checkbox_row(ui, "point_cloud_auto_range", crate::i18n::tr("ui.point_cloud_auto_range"), automatic) {+ edit = Some(json!({ "cloud": c.id, "color_range": if automatic { json!(crate::point_clouds::color_range(ui.ctx(), &live)) } else { Value::Null } }));+ }+ // The ramp's range is a range on a track of the property, over what the+ // filters keep; a double click beside it gives it back to the filters.+ let shown = crate::point_clouds::color_range(ui.ctx(), &live).unwrap_or(span);+ let key = colour_key(c.id);+ let ask = Ask {+ property: name.to_string(),+ span,+ loupe: range_track::loupe(ui.ctx(), &key, span),+ bins: bins(ui),+ paint: Paint::Ramp { property: name.to_string(), range: shown },+ filters: drawn.clone(),+ changes_of: None,+ };+ let answer = m.tracks.answer(ui.ctx(), &c, &key, ask);+ let out = range_track(+ ui,+ &Track {+ key: &key,+ range: shown,+ span,+ integer: false,+ overview: answer.as_ref().map(|a| &a.overview),+ loupe: answer.as_ref().map(|a| &a.loupe),+ changes: &[],+ // An automatic range moves with a playing filter: its moving end+ // stays in the loupe.+ follow: m.play.as_ref().filter(|_| automatic).map(|p| if p.part == Part::Low { shown[0] } else { shown[1] }),+ },+ );+ if let Some(range) = out.range {+ edit = Some(json!({ "cloud": c.id, "color_range": range }));+ } else if out.whole {+ edit = Some(json!({ "cloud": c.id, "color_range": Value::Null }));+ }+ }+ }+ }+ // Filters: only what every one of them keeps is shown.+ let mut filters = c.filters.clone();+ let mut changed = false;+ let mut removed = None;+ for (k, f) in c.filters.iter().enumerate() {+ let span = c.span(&f.property);+ let integer = c.complex.integer(&f.property);+ // Play or stop, by ▶ or Space on the track.+ let mut toggle = None;+ ui.horizontal(|ui| {+ ui.label(crate::i18n::tr_dyn(&format!("Filter: {}", f.property)));+ let playing = m.play.as_ref().is_some_and(|p| p.filter == k);+ if let (Some(range), Some(span)) = (f.range(), span)+ && ui_kit::button(+ ui,+ if playing {+ format!("⏸ {}", crate::i18n::tr_label("Pause"))+ } else {+ format!("▶ {}", crate::i18n::tr_label("Play"))+ },+ ui_kit::Button::Small,+ )+ .clicked()+ {+ toggle = Some((m.playing(c.id, k).unwrap_or(range), span));+ }+ if ui_kit::button(ui, "×", ui_kit::Button::Small).clicked() {+ removed = Some(k);+ }+ });+ if k >= DRAWN_FILTERS {+ ui.weak(crate::i18n::tr_dyn(&format!("Not drawn: the view applies {DRAWN_FILTERS} filters at most")));+ }+ match (&f.keep, span) {+ (Keep::Values { .. }, _) => match label(&c, &f.property) {+ Some(names) if legend_shown.is_some_and(|l| l.property == names.property) => {+ ui.weak(crate::i18n::tr_label("Shown and hidden in the legend above"));+ }+ Some(names) => {+ if let Some(v) = legend(ui, &c, names) {+ edit = Some(json!({ "cloud": c.id, "filters": toggled(&c, names, v) }));+ }+ }+ None => {}+ },+ (Keep::Range { range }, Some(span)) => {+ let shown = m.playing(c.id, k).unwrap_or(*range);+ let key = filter_key(c.id, k);+ // The track shows what the other filters keep.+ let others = drawn.iter().enumerate().filter(|(j, _)| *j != k).map(|(_, f)| f.clone()).collect();+ let ask = Ask {+ property: f.property.clone(),+ span,+ loupe: range_track::loupe(ui.ctx(), &key, span),+ bins: bins(ui),+ paint: paint.clone(),+ filters: others,+ changes_of: changes_of.clone(),+ };+ let answer = m.tracks.answer(ui.ctx(), &c, &key, ask);+ let moving = m.play.as_ref().filter(|p| p.filter == k).map(|p| if p.part == Part::Low { shown[0] } else { shown[1] });+ let out = range_track(+ ui,+ &Track {+ key: &key,+ range: shown,+ span,+ integer,+ overview: answer.as_ref().map(|a| &a.overview),+ loupe: answer.as_ref().map(|a| &a.loupe),+ changes: answer.as_ref().map_or(&[][..], |a| &a.changes[..]),+ follow: moving,+ },+ );+ let moved = out.range.or(out.whole.then_some(span));+ if let Some(range) = moved+ && let Some(slot) = filters.get_mut(k)+ {+ slot.keep = Keep::Range { range };+ changed = true;+ // Moving it by hand stops it playing.+ if m.play.as_ref().is_some_and(|p| p.filter == k) {+ m.play = None;+ }+ }+ if out.play {+ toggle = Some((moved.unwrap_or(shown), span));+ }}- if let Some([mut lo, mut hi]) = c.height_range.or(auto) {- let mut changed = false;- ui.add_enabled_ui(!automatic, |ui| {- changed |= ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_height_low"), |ui| {- ui_kit::length_field(ui, &mut lo, &units, decimals)- })- .changed();- changed |= ui_kit::row(ui, crate::i18n::tr("ui.point_cloud_height_high"), |ui| {- ui_kit::length_field(ui, &mut hi, &units, decimals)- })- .changed();- });- // The two heights stay apart, lowest first.- if changed && !automatic {- let hi = hi.max(lo + 1e-3);- edit = Some(json!({ "cloud": c.id, "height_range": [lo, hi] }));+ (Keep::Range { .. }, None) => {}+ }+ if let Some((range, span)) = toggle {+ if m.play.as_ref().is_some_and(|p| p.filter == k) {+ stop_play = true;+ } else {+ // Another filter playing stops where it is.+ if let Some(p) = m.play.take()+ && let Some(slot) = filters.get_mut(p.filter)+ {+ slot.keep = Keep::Range { range: p.now };+ changed = true;}+ let part = range_track::last_part(ui.ctx(), &filter_key(c.id, k));+ m.play = Some(Play::new(k, part, range, span, now));+ }+ }+ }+ if let Some(k) = removed {+ filters.remove(k);+ changed = true;+ m.play = None;+ }+ let all: Vec<&str> = c.property_names().collect();+ if c.filters.len() < MAX_FILTERS {+ let mut add_labels = vec![crate::i18n::tr_label("Add filter…")];+ add_labels.extend(all.iter().copied());+ let mut pick = 0;+ ui_kit::row(ui, crate::i18n::tr_label("Filter by"), |ui| ui_kit::dropdown(ui, "point_cloud_add_filter", &mut pick, &add_labels));+ if let Some(name) = all.get(pick.wrapping_sub(1)) {+ // A label keeps all its values at first, anything else its whole span.+ let keep = match (label(&c, name), c.span(name)) {+ (Some(names), _) => Some(Keep::Values { values: names.values.iter().map(|(v, _)| *v).collect() }),+ (None, Some(span)) => Some(Keep::Range { range: span }),+ (None, None) => None,+ };+ if let Some(keep) = keep {+ filters.push(Filter { property: name.to_string(), keep });+ changed = true;}}}+ if changed {+ edit = Some(json!({ "cloud": c.id, "filters": filters_json(&filters) }));+ }});+ // A filter that stops playing is written where it stopped.+ if stop_play && let Some(p) = m.play.take() {+ let mut filters = c.filters.clone();+ if let Some(f) = filters.get_mut(p.filter) {+ f.keep = Keep::Range { range: p.now };+ edit = Some(json!({ "cloud": c.id, "filters": filters_json(&filters) }));+ }+ }if let Some(p) = edit&& app.run("pointcloud.edit", p).is_ok(){@@ -225,4 +564,96 @@ mod tests {assert_eq!(h.app.session.doc.point_clouds.len(), 1);let _ = std::fs::remove_dir_all(dir);}++ /// A PLY file of points along x, `t` running 0 to 10 by halves, a layer every 2: the layer+ /// changes at t = 2, 4, 6 and 8.+ fn layered_points(dir: &std::path::Path) -> std::path::PathBuf {+ let mut ply = String::from(+ "ply\nformat ascii 1.0\nelement vertex 21\nproperty float x\nproperty float y\nproperty float z\nproperty float t\nproperty int layer\nend_header\n",+ );+ for i in 0..=20 {+ let t = f64::from(i) / 2.0;+ ply += &format!("{t} 0 0 {t} {}\n", (i / 4).min(4));+ }+ let path = dir.join("layers.ply");+ std::fs::write(&path, ply).unwrap();+ path+ }++ #[test]+ fn a_filter_track_draws_snaps_steps_frames_and_plays() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ let dir = std::env::temp_dir().join(format!("solidcraft-browser-track-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = layered_points(&dir);+ let id = h.app.run("pointcloud.insert", json!({"path": path.to_string_lossy()})).unwrap()["cloud"].as_u64().unwrap();+ h.app.run("pointcloud.edit", json!({"cloud": id, "color_by": "layer", "filters": [{"property": "t", "range": [2.0, 5.0]}]})).unwrap();+ h.app.tree.cloud_panel = Some(super::CloudPanel::new(&h.app, id));+ let key = super::filter_key(id, 0);+ let range = |h: &crate::scenario::Harness| h.app.session.doc.point_clouds[0].filters[0].range().unwrap();+ // The bars come from the worker: wait for them, and for the layer changes to snap to.+ let mut bars = None;+ for _ in 0..200 {+ h.frames(1);+ bars = crate::scenario::rect_of(&format!("range_track:{key}:bars"));+ if bars.is_some() && h.app.tree.cloud_panel.as_ref().is_some_and(|m| m.tracks.answered(&key)) {+ break;+ }+ std::thread::sleep(std::time::Duration::from_millis(10));+ }+ h.frames(2);+ let r = bars.expect("the track is drawn");+ let x = |t: f64| f64::from(r.left()) + t / 10.0 * f64::from(r.width());+ let y = f64::from(r.center().y);+ let drag = |h: &mut crate::scenario::Harness, a: f64, b: f64| {+ h.call("ui.drag", json!({"x0": x(a), "y0": y, "x1": x(b), "y1": y, "steps": 8}));+ h.frames(2);+ };+ // Drawn beside the range: a new range, its start snapped to the layer change at 6.+ drag(&mut h, 6.04, 8.9);+ let [lo, hi] = range(&h);+ assert!(lo == 6.0 && (hi - 8.9).abs() < 0.05, "{lo} {hi}");+ // Its end dragged near 8 snaps to it; its start, far from any change, does not.+ drag(&mut h, 8.9, 7.97);+ drag(&mut h, 6.0, 6.5);+ let [lo, hi] = range(&h);+ assert!((lo - 6.5).abs() < 0.05 && hi == 8.0, "{lo} {hi}");+ // ← steps the start, touched last, to the change before it, then the one before that.+ for _ in 0..2 {+ h.call("ui.key", json!({"key": "ArrowLeft"}));+ h.frames(2);+ }+ assert_eq!(range(&h), [4.0, 8.0]);+ // A double click on the range frames the loupe on it; beside it, the whole span.+ h.call("ui.click", json!({"x": x(6.0), "y": y, "double": true}));+ h.frames(2);+ let [a, b] = super::range_track::loupe(&h.ctx, &key, [0.0, 10.0]);+ assert!(a > 3.0 && a < 4.0 && b > 8.0 && b < 9.0, "{a} {b}");+ // A double click on the strip above shows the whole span again; beside the range, the+ // range becomes the whole span.+ // (Past the double click's time, so that it is not a third click.)+ h.frames(30);+ let strip = crate::scenario::rect_of(&format!("range_track:{key}:strip")).unwrap();+ h.call("ui.click", json!({"x": f64::from(strip.center().x), "y": f64::from(strip.center().y), "double": true}));+ h.frames(2);+ assert_eq!(super::range_track::loupe(&h.ctx, &key, [0.0, 10.0]), [0.0, 10.0]);+ h.frames(30);+ h.call("ui.click", json!({"x": x(9.5), "y": y, "double": true}));+ h.frames(2);+ assert_eq!(range(&h), [0.0, 10.0]);+ // Space plays the part touched last (here the end, unrolling), written once when it stops.+ drag(&mut h, 10.0, 7.0);+ assert!((range(&h)[1] - 7.0).abs() < 0.05);+ h.call("ui.key", json!({"key": "Space"}));+ h.frames(2);+ assert!(h.app.tree.cloud_panel.as_ref().unwrap().play.is_some());+ h.frames(20);+ h.call("ui.key", json!({"key": "Space"}));+ h.frames(2);+ assert!(h.app.tree.cloud_panel.as_ref().unwrap().play.is_none());+ let [lo, hi] = range(&h);+ assert!(lo == 0.0 && hi > 7.0 && hi < 10.0, "played on from 7: {hi}");+ let _ = std::fs::remove_dir_all(dir);+ }}diff --git a/crates/ui-egui/src/browser/range_track.rs b/crates/ui-egui/src/browser/range_track.rsnew file mode 100644index 0000000000..e399be4727--- /dev/null+++ b/crates/ui-egui/src/browser/range_track.rs@@ -0,0 +1,580 @@+//! A range on a track, as in an audio editor. The track draws how much of the cloud lies at each+//! value (its bars) under the range. A thin strip above shows the whole span, with the part the+//! track shows (its loupe) framed: the strip is the same range widget, its range being the loupe.+//!+//! Gestures: drag a range's end or its band to move them; drag elsewhere to draw a new range;+//! Shift-click to bring the nearer end to the pointer; double-click the band to frame the loupe on+//! it, elsewhere to ask for the whole (`Outcome::whole`); the wheel or a pinch zooms the loupe+//! around the pointer, a sideways scroll moves it. An end snaps to a value where the colour+//! changes when that value stands alone at this zoom (nothing else within twice the reach), and+//! a whole-numbered property's ends to whole numbers; ⌥ moves ten times slower, without+//! snapping. With the keyboard, once the track is touched: ← and → bring the part touched last to+//! the previous or next change (one pixel with ⌥ or where there is none), Space asks to play it.+//! The ends and the length are fields too; a field's value may be typed relative, as `+30`.++use egui::{Color32, Mesh, Pos2, Rect, Sense, Stroke, Ui, vec2};++use crate::ui_kit;++use crate::theme::Tokens;++/// The part of a range a gesture moves, and that playing moves.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(super) enum Part {+ Low,+ #[default]+ High,+ Band,+}++/// How much lies at each value of an axis: `slots[s][b]`, stacked in slot order, slot `s` in+/// `colours[s]`; or, with `ramp`, one slot painted at each value with the ramp over that range.+#[derive(Clone, Debug, Default, PartialEq)]+pub(super) struct Bars {+ pub axis: [f64; 2],+ pub slots: Vec<Vec<f64>>,+ pub colours: Vec<Color32>,+ pub ramp: Option<[f64; 2]>,+}++/// What a track shows and snaps to.+pub(super) struct Track<'a> {+ /// Names the track among all of them.+ pub key: &'a str,+ pub range: [f64; 2],+ pub span: [f64; 2],+ pub integer: bool,+ pub overview: Option<&'a Bars>,+ pub loupe: Option<&'a Bars>,+ /// Values the ends snap to and the arrows step through, lowest first.+ pub changes: &'a [f64],+ /// A value moving on its own (a range playing), kept in the loupe.+ pub follow: Option<f64>,+}++/// What a frame's input asks for.+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub(super) struct Outcome {+ /// The range moved.+ pub range: Option<[f64; 2]>,+ /// The whole: a double click beside the range.+ pub whole: bool,+ /// Play or stop: Space.+ pub play: bool,+ /// The range was touched by a gesture, a field or a key.+ pub touched: bool,+}++/// What a drag moves: an end, the band, or a new range from where it started.+#[derive(Clone, Copy, Debug, PartialEq)]+enum Grab {+ Low,+ High,+ Band,+ New(f64),+}++#[derive(Clone, Copy, Debug, PartialEq)]+struct Drag {+ /// On the strip (moving the loupe) or the track (moving the range).+ strip: bool,+ grab: Grab,+ /// The range when it started, and the value under the pointer now (slowed by ⌥).+ start: [f64; 2],+ at: f64,+ from: f64,+ last_x: f32,+}++/// What the track keeps between frames.+#[derive(Clone, Copy, Debug, Default)]+struct State {+ loupe: Option<[f64; 2]>,+ drag: Option<Drag>,+ last: Part,+ /// Where an end snapped during the drag.+ snapped: Option<f64>,+}++/// The loupe's narrowest width, as a fraction of the span.+const MIN_LOUPE: f64 = 1e-6;+/// Zoom per point of wheel scroll.+const ZOOM: f64 = 0.004;+/// How close to an end a press grabs it, and an end snaps, in points.+const REACH: f32 = 6.0;+/// ⌥'s slowing.+const FINE: f64 = 0.1;+const STRIP: f32 = 12.0;+const RULER: f32 = 14.0;+const BARS: f32 = 40.0;++fn id(key: &str) -> egui::Id {+ egui::Id::new(("sc_range_track", key))+}++fn state(ctx: &egui::Context, key: &str) -> State {+ ctx.data(|d| d.get_temp(id(key))).unwrap_or_default()+}++fn whole(span: [f64; 2]) -> [f64; 2] {+ [span[0], span[1].max(span[0] + 1e-9)]+}++/// The part of `span` a track shows now.+pub(super) fn loupe(ctx: &egui::Context, key: &str, span: [f64; 2]) -> [f64; 2] {+ state(ctx, key).loupe.map_or(whole(span), |l| fit(l, whole(span)))+}++/// The part of a track's range touched last.+pub(super) fn last_part(ctx: &egui::Context, key: &str) -> Part {+ state(ctx, key).last+}++/// `l` moved and narrowed to lie within `span`, at least its narrowest.+fn fit([a, b]: [f64; 2], span: [f64; 2]) -> [f64; 2] {+ let full = span[1] - span[0];+ let w = (b - a).clamp(full * MIN_LOUPE, full);+ let left = (a + (b - a - w) / 2.0).clamp(span[0], span[1] - w);+ [left, left + w]+}++/// The change nearest `v` within `r`, when no other change is within `2r` of it.+fn lone_change(changes: &[f64], v: f64, r: f64) -> Option<f64> {+ let i = changes.partition_point(|c| *c < v);+ let near = [i.checked_sub(1), Some(i)].into_iter().flatten().filter_map(|k| changes.get(k).map(|c| (k, *c)));+ let (k, c) = near.min_by(|a, b| (a.1 - v).abs().total_cmp(&(b.1 - v).abs()))?;+ let alone = k.checked_sub(1).and_then(|j| changes.get(j)).is_none_or(|p| c - p > 2.0 * r) && changes.get(k + 1).is_none_or(|n| n - c > 2.0 * r);+ ((c - v).abs() <= r && alone).then_some(c)+}++/// The changes standing alone at this zoom within `[a, b]`, at most `n`.+fn lone_changes(changes: &[f64], [a, b]: [f64; 2], r: f64, n: usize) -> Vec<f64> {+ let (i, j) = (changes.partition_point(|c| *c < a), changes.partition_point(|c| *c <= b));+ (i..j)+ .filter(|k| {+ let c = changes.get(*k).copied().unwrap_or(f64::NAN);+ k.checked_sub(1).and_then(|p| changes.get(p)).is_none_or(|p| c - p > 2.0 * r) && changes.get(k + 1).is_none_or(|q| q - c > 2.0 * r)+ })+ .filter_map(|k| changes.get(k).copied())+ .take(n)+ .collect()+}++/// The next change after `v` (`dir` 1) or before it (-1).+fn next_change(changes: &[f64], v: f64, dir: f64) -> Option<f64> {+ let eps = v.abs().max(1.0) * 1e-12;+ if dir > 0.0 {+ changes.get(changes.partition_point(|c| *c <= v + eps)).copied()+ } else {+ changes.partition_point(|c| *c < v - eps).checked_sub(1).and_then(|k| changes.get(k)).copied()+ }+}++/// Bar and tick steps: 1, 2 or 5 times a power of ten, at least `min` apart.+fn nice_step(min: f64) -> f64 {+ let k = 10f64.powf(min.max(1e-300).log10().floor());+ [1.0, 2.0, 5.0, 10.0].into_iter().map(|m| m * k).find(|s| *s >= min).unwrap_or(10.0 * k)+}++/// Paint `bars` within `rect`, showing `axis`; each column scaled to the tallest shown.+fn paint_bars(painter: &egui::Painter, rect: Rect, axis: [f64; 2], bars: &Bars, fill: Color32, ink: Color32) {+ painter.rect_filled(rect, 2.0, fill);+ let n = bars.slots.first().map_or(0, Vec::len);+ if n == 0 || !(bars.axis[1] > bars.axis[0]) {+ return;+ }+ let width = (bars.axis[1] - bars.axis[0]) / n as f64;+ let x_of = |v: f64| rect.left() + ((v - axis[0]) / (axis[1] - axis[0])) as f32 * rect.width();+ let total = |b: usize| bars.slots.iter().filter_map(|s| s.get(b)).sum::<f64>();+ let shown: Vec<usize> = (0..n)+ .filter(|b| {+ let lo = bars.axis[0] + *b as f64 * width;+ lo + width >= axis[0] && lo <= axis[1]+ })+ .collect();+ let peak = shown.iter().map(|b| total(*b)).fold(0.0, f64::max);+ if !(peak > 0.0) {+ return;+ }+ let mut mesh = Mesh::default();+ for b in shown {+ let lo = bars.axis[0] + b as f64 * width;+ let (x0, x1) = (x_of(lo).max(rect.left()), x_of(lo + width).min(rect.right()).max(x_of(lo).max(rect.left()) + 1.0));+ let mut y = rect.bottom();+ for (s, slot) in bars.slots.iter().enumerate() {+ let h = (slot.get(b).copied().unwrap_or(0.0) / peak) as f32 * (rect.height() - 2.0);+ if h <= 0.0 {+ continue;+ }+ let colour = match bars.ramp {+ Some([a, z]) if z > a => {+ crate::theme::model_color(solidcraft_engine::doc::point_cloud::height_ramp((lo + width / 2.0 - a) / (z - a)))+ }+ _ => bars.colours.get(s).copied().unwrap_or(ink),+ };+ mesh.add_colored_rect(Rect::from_min_max(Pos2::new(x0, y - h), Pos2::new(x1, y)), colour);+ y -= h;+ }+ }+ painter.add(mesh);+}++/// The range within `span` after this frame's input, and what else the input asks for.+pub(super) fn range_track(ui: &mut Ui, track: &Track) -> Outcome {+ let t = Tokens::get();+ let ctx = ui.ctx().clone();+ let mut st = state(&ctx, track.key);+ let span = whole(track.span);+ let mut out = Outcome::default();+ let mut range = track.range;+ let mut view = st.loupe.map_or(span, |l| fit(l, span));+ if let Some(f) = track.follow+ && (f < view[0] || f > view[1])+ {+ let w = view[1] - view[0];+ view = fit([f - 0.1 * w, f + 0.9 * w], span);+ st.loupe = Some(view);+ }++ let (rect, response) = ui.allocate_exact_size(vec2(ui.available_width(), STRIP + RULER + BARS + 4.0), Sense::click_and_drag());+ let inner = rect.shrink2(vec2(REACH, 0.0));+ let strip = Rect::from_min_size(inner.min, vec2(inner.width(), STRIP));+ let ruler = Rect::from_min_size(Pos2::new(inner.left(), strip.bottom() + 2.0), vec2(inner.width(), RULER));+ let bars = Rect::from_min_size(Pos2::new(inner.left(), ruler.bottom() + 2.0), vec2(inner.width(), BARS));+ // Named for agents and tests: the strip and the bars.+ crate::scenario::publish_rect(&format!("range_track:{}:strip", track.key), strip);+ crate::scenario::publish_rect(&format!("range_track:{}:bars", track.key), bars);+ let on_strip = |p: Pos2| p.y < strip.bottom() + 1.0;+ let axis_of = |strip: bool, view: [f64; 2]| if strip { span } else { view };+ let x_of = |axis: [f64; 2], v: f64| inner.left() + ((v - axis[0]) / (axis[1] - axis[0])) as f32 * inner.width();+ let v_of = |axis: [f64; 2], x: f32| axis[0] + f64::from((x - inner.left()) / inner.width().max(1.0)) * (axis[1] - axis[0]);+ let per_point = (view[1] - view[0]) / f64::from(inner.width().max(1.0));+ let reach = f64::from(REACH) * per_point;+ let mods = ui.input(|i| i.modifiers);+ let snap = |v: f64, fine: bool, snapped: &mut Option<f64>| {+ let s = if fine { None } else { lone_change(track.changes, v, reach) };+ *snapped = s;+ let v = s.unwrap_or(v);+ if track.integer { v.round() } else { v }+ };+ let grab_at = |strip: bool, x: f32, view: [f64; 2], range: [f64; 2]| {+ let (axis, [a, b]) = (axis_of(strip, view), if strip { view } else { range });+ let (xa, xb) = (x_of(axis, a), x_of(axis, b));+ if (x - xa).abs().min((x - xb).abs()) <= REACH {+ Some(if (x - xa).abs() < (x - xb).abs() { Grab::Low } else { Grab::High })+ } else if x > xa && x < xb {+ Some(Grab::Band)+ } else {+ None+ }+ };++ // Zoom and move the loupe.+ if response.hovered()+ && let Some(p) = response.hover_pos()+ {+ let (zoom, sideways, pinch) = crate::navigation::axis_wheel(&ctx, rect.height());+ if sideways != 0.0 {+ let d = -f64::from(sideways) * per_point;+ view = fit([view[0] + d, view[1] + d], span);+ st.loupe = Some(view);+ }+ if zoom != 0.0 || pinch != 1.0 {+ let k = (-f64::from(zoom) * ZOOM).exp() / f64::from(pinch);+ let at = v_of(axis_of(on_strip(p), view), p.x).clamp(view[0], view[1]);+ view = fit([at - (at - view[0]) * k, at + (view[1] - at) * k], span);+ st.loupe = Some(view);+ }+ }+ if response.drag_started()+ && let Some(p) = ui.input(|i| i.pointer.press_origin())+ {+ response.request_focus();+ let strip = on_strip(p);+ let axis = axis_of(strip, view);+ let v = v_of(axis, p.x);+ let start = if strip { view } else { range };+ let grab = match grab_at(strip, p.x, view, range) {+ Some(g) => g,+ None if mods.shift => {+ if (v - start[0]).abs() < (v - start[1]).abs() {+ Grab::Low+ } else {+ Grab::High+ }+ }+ None => Grab::New(if strip { v } else { snap(v, mods.alt, &mut st.snapped) }),+ };+ if !strip {+ st.last = match grab {+ Grab::Low => Part::Low,+ Grab::Band => Part::Band,+ Grab::High | Grab::New(_) => Part::High,+ };+ out.touched = true;+ }+ st.drag = Some(Drag { strip, grab, start, at: v, from: v, last_x: p.x });+ }+ if response.dragged()+ && let (Some(mut d), Some(p)) = (st.drag, response.interact_pointer_pos())+ {+ let axis = if d.strip { span } else { view };+ let scale = (axis[1] - axis[0]) / f64::from(inner.width().max(1.0));+ d.at += f64::from(p.x - d.last_x) * scale * if mods.alt { FINE } else { 1.0 };+ d.last_x = p.x;+ let mut snapped = None;+ let mut put = |v: f64| if d.strip { v } else { snap(v.clamp(span[0], span[1]), mods.alt, &mut snapped) };+ let [a, b] = d.start;+ let moved = match d.grab {+ Grab::Band => {+ let w = b - a;+ let mut shift = d.at - d.from;+ if !d.strip {+ // The band snaps by whichever end lands on a change.+ let (la, lb) = (put(a + shift) - (a + shift), put(b + shift) - (b + shift));+ shift += if la.abs() > 0.0 && (lb == 0.0 || la.abs() <= lb.abs()) { la } else { lb };+ }+ let lo = (a + shift).clamp(span[0], span[1] - w);+ [lo, lo + w]+ }+ Grab::New(anchor) => {+ let v = put(d.at);+ [anchor.min(v), anchor.max(v)]+ }+ Grab::Low | Grab::High => {+ let v = put(d.at);+ let other = if d.grab == Grab::Low { b } else { a };+ // An end dragged past the other becomes the other.+ let low = v < other;+ if !d.strip {+ st.last = if low { Part::Low } else { Part::High };+ }+ d.grab = if low { Grab::Low } else { Grab::High };+ d.start = if low { [a, other] } else { [other, b] };+ [v.min(other), v.max(other)]+ }+ };+ st.snapped = snapped;+ if d.strip {+ view = fit(moved, span);+ st.loupe = Some(view);+ } else {+ range = moved;+ out.touched = true;+ }+ st.drag = Some(d);+ }+ if response.drag_stopped() {+ st.drag = None;+ st.snapped = None;+ }+ if response.clicked()+ && let Some(p) = response.interact_pointer_pos()+ {+ response.request_focus();+ let strip = on_strip(p);+ let v = v_of(axis_of(strip, view), p.x);+ if strip && grab_at(true, p.x, view, range).is_none() {+ // A click beside the loupe brings it there.+ let w = view[1] - view[0];+ view = fit([v - w / 2.0, v + w / 2.0], span);+ st.loupe = Some(view);+ } else if !strip && mods.shift && grab_at(false, p.x, view, range).is_none() {+ let v = snap(v, mods.alt, &mut st.snapped);+ let low = (v - range[0]).abs() < (v - range[1]).abs();+ range = if low { [v.min(range[1]), range[1]] } else { [range[0], v.max(range[0])] };+ st.last = if low { Part::Low } else { Part::High };+ out.touched = true;+ }+ }+ if response.double_clicked()+ && let Some(p) = response.interact_pointer_pos()+ {+ if on_strip(p) {+ view = span;+ st.loupe = None;+ } else if grab_at(false, p.x, view, range) == Some(Grab::Band) {+ let m = (range[1] - range[0]) * 0.08;+ view = fit([range[0] - m, range[1] + m], span);+ st.loupe = Some(view);+ } else {+ out.whole = true;+ out.touched = true;+ }+ }+ // The keyboard, while the track has it.+ if response.has_focus() {+ ui.memory_mut(|m| m.set_focus_lock_filter(response.id, egui::EventFilter { horizontal_arrows: true, ..Default::default() }));+ let (left, right, space) = ui.input_mut(|i| {+ (+ i.consume_key(egui::Modifiers::NONE, egui::Key::ArrowLeft) || i.consume_key(egui::Modifiers::ALT, egui::Key::ArrowLeft),+ i.consume_key(egui::Modifiers::NONE, egui::Key::ArrowRight) || i.consume_key(egui::Modifiers::ALT, egui::Key::ArrowRight),+ i.consume_key(egui::Modifiers::NONE, egui::Key::Space),+ )+ });+ out.play = space;+ if left || right {+ let dir = if right { 1.0 } else { -1.0 };+ let step = |v: f64| {+ let n = if mods.alt { None } else { next_change(track.changes, v, dir) };+ let v = n.unwrap_or(v + dir * per_point);+ let v = if track.integer && n.is_none() { (v + dir * 0.5).round() } else { v };+ v.clamp(span[0], span[1])+ };+ range = match st.last {+ Part::Low => [step(range[0]).min(range[1]), range[1]],+ Part::High => [range[0], step(range[1]).max(range[0])],+ Part::Band => {+ let lead = if right { range[1] } else { range[0] };+ let w = range[1] - range[0];+ let lo = (range[0] + step(lead) - lead).clamp(span[0], span[1] - w);+ [lo, lo + w]+ }+ };+ let moving = match st.last {+ Part::Low => range[0],+ Part::High => range[1],+ Part::Band => {+ if right {+ range[1]+ } else {+ range[0]+ }+ }+ };+ if moving < view[0] || moving > view[1] {+ let w = view[1] - view[0];+ view = fit([moving - w / 2.0, moving + w / 2.0], span);+ st.loupe = Some(view);+ }+ out.touched = true;+ }+ }++ // The pointer says what a press would take: an end, the band, or a new range beside them.+ if let Some(p) = response.hover_pos().or_else(|| st.drag.and_then(|_| response.interact_pointer_pos())) {+ let icon = match st.drag.map(|d| d.grab) {+ Some(Grab::Band) => egui::CursorIcon::Grabbing,+ Some(_) => egui::CursorIcon::ResizeHorizontal,+ None => match grab_at(on_strip(p), p.x, view, range) {+ Some(Grab::Band) => egui::CursorIcon::Grab,+ Some(_) => egui::CursorIcon::ResizeHorizontal,+ None if on_strip(p) => egui::CursorIcon::PointingHand,+ None => egui::CursorIcon::Crosshair,+ },+ };+ ctx.set_cursor_icon(icon);+ }++ // The strip: the whole span, the range, and the loupe framed.+ let painter = ui.painter_at(rect);+ let empty = Bars::default();+ paint_bars(&painter, strip, span, track.overview.unwrap_or(&empty), t.control_fill, t.text_dim);+ let band = |r: Rect, axis: [f64; 2], [a, b]: [f64; 2]| {+ Rect::from_min_max(Pos2::new(x_of(axis, a).max(r.left()), r.top()), Pos2::new(x_of(axis, b).min(r.right()), r.bottom()))+ };+ painter.rect_filled(band(strip, span, range), 0.0, t.form_primary.gamma_multiply(0.35));+ let frame = band(strip, span, view);+ let shade = t.panel.gamma_multiply(0.7);+ painter.rect_filled(Rect::from_min_max(strip.min, Pos2::new(frame.left(), strip.bottom())), 0.0, shade);+ painter.rect_filled(Rect::from_min_max(Pos2::new(frame.right(), strip.top()), strip.max), 0.0, shade);+ painter.rect_stroke(frame, 1.0, Stroke::new(1.5, t.text), egui::StrokeKind::Inside);++ // The ruler: steps of 1, 2 or 5 times a power of ten, at least 60 points apart.+ let step = nice_step(60.0 * per_point);+ let decimals = (-step.log10().floor()).clamp(0.0, 9.0) as usize;+ let font = egui::FontId::proportional(t.font_micro);+ let mut v = (view[0] / step).ceil() * step;+ for _ in 0..64 {+ if v > view[1] {+ break;+ }+ let x = x_of(view, v);+ painter.line_segment([Pos2::new(x, ruler.bottom() - 5.0), Pos2::new(x, ruler.bottom())], Stroke::new(1.0, t.border));+ painter.text(Pos2::new(x + 2.0, ruler.top()), egui::Align2::LEFT_TOP, format!("{v:.decimals$}"), font.clone(), t.text_dim);+ v += step;+ }+ for c in lone_changes(track.changes, view, reach, 512) {+ let x = x_of(view, c);+ painter.line_segment([Pos2::new(x, ruler.bottom() - 3.0), Pos2::new(x, ruler.bottom() + 1.0)], Stroke::new(1.0, t.warning));+ }++ // The bars, what lies outside the range shaded, and the range's ends.+ paint_bars(&painter, bars, view, track.loupe.unwrap_or(&empty), t.control_fill, t.text_dim);+ let r = band(bars, view, range);+ painter.rect_filled(Rect::from_min_max(bars.min, Pos2::new(r.left(), bars.bottom())), 0.0, shade);+ painter.rect_filled(Rect::from_min_max(Pos2::new(r.right(), bars.top()), bars.max), 0.0, shade);+ painter.rect_filled(r, 0.0, t.form_primary.gamma_multiply(0.18));+ for (v, part) in [(range[0], Part::Low), (range[1], Part::High)] {+ if v < view[0] || v > view[1] {+ continue;+ }+ let x = x_of(view, v);+ let width = if response.has_focus() && st.last == part { 3.0 } else { 2.0 };+ painter.line_segment([Pos2::new(x, bars.top()), Pos2::new(x, bars.bottom())], Stroke::new(width, t.form_primary));+ painter.add(egui::Shape::convex_polygon(+ vec![Pos2::new(x - 5.0, bars.top()), Pos2::new(x + 5.0, bars.top()), Pos2::new(x, bars.top() + 6.0)],+ t.form_primary,+ Stroke::NONE,+ ));+ }+ if let (Some(s), Some(_)) = (st.snapped, st.drag) {+ let x = x_of(view, s);+ painter.line_segment([Pos2::new(x, bars.top()), Pos2::new(x, bars.bottom())], Stroke::new(1.0, t.warning));+ }+ if response.has_focus() && st.last == Part::Band {+ painter.rect_stroke(r, 0.0, Stroke::new(1.0, t.form_primary), egui::StrokeKind::Inside);+ }++ // The ends and the length as numbers.+ let decimals = if track.integer { 0 } else { (-(per_point.max(1e-12)).log10()).ceil().clamp(0.0, 6.0) as usize };+ let speed = if track.integer { 1.0 } else { per_point };+ ui.horizontal(|ui| {+ let field = |ui: &mut Ui, v: &mut f64| ui_kit::track_number(ui, v, speed, decimals).changed();+ let (mut lo, mut hi) = (range[0], range[1]);+ let mut length = hi - lo;+ let changed_lo = field(ui, &mut lo);+ ui.label("…");+ let changed_hi = field(ui, &mut hi);+ ui.weak("↔");+ let changed_length = field(ui, &mut length);+ let round = |v: f64| if track.integer { v.round() } else { v };+ if changed_lo {+ range = [round(lo).min(range[1]), range[1]];+ st.last = Part::Low;+ } else if changed_hi {+ range = [range[0], round(hi).max(range[0])];+ st.last = Part::High;+ } else if changed_length {+ range = [range[0], range[0] + round(length).max(0.0)];+ st.last = Part::High;+ }+ if changed_lo || changed_hi || changed_length {+ out.touched = true;+ }+ });++ ctx.data_mut(|d| d.insert_temp(id(track.key), st));+ out.range = (range != track.range).then_some(range);+ out+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn a_change_snaps_only_when_it_stands_alone_at_this_zoom() {+ let changes = [0.0, 10.0, 11.0, 30.0];+ assert_eq!(lone_change(&changes, 29.0, 2.0), Some(30.0));+ assert_eq!(lone_change(&changes, 10.4, 2.0), None, "10 and 11 are too close to tell apart");+ assert_eq!(lone_change(&changes, 10.4, 0.45), Some(10.0));+ assert_eq!(lone_changes(&changes, [0.0, 40.0], 2.0, 10), vec![0.0, 30.0]);+ assert_eq!(+ (next_change(&changes, 10.0, 1.0), next_change(&changes, 10.0, -1.0), next_change(&changes, 30.0, 1.0)),+ (Some(11.0), Some(0.0), None)+ );+ assert_eq!(nice_step(3.2), 5.0);+ assert_eq!(nice_step(0.07), 0.1);+ }+}diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex 0d2ee73032..2e6ddcfbcb 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -8,10 +8,9 @@ use std::sync::{Arc, Mutex};use egui_wgpu::wgpu;pub use solidcraft_gpu::view::{- AccessMap, BlockBuilder, BlockBytes, BlockTris, CLOUD_POINT_SIZE, DrawStats, DrawStatsHandle, Frame, GpuImage, GpuPoints, GpuScene, GpuTarget,- INSTANCE_SIZE, InstanceLook, InstancedMesh, LINE_SIZE, LOD_PX, MAX_PALETTE, PBR_SIZE, Palette, PaletteIndex, PlannedBody, Renderer, SHARED_SIZE,- SceneBlock, SceneSlot, SharedTris, TRI_SIZE, TriClass, UploadError, cloud_point, extend_runs, level_for, lifted_width, placement_scale,- runs_within, supersampled_size,+ AccessMap, BlockBuilder, BlockBytes, BlockTris, DrawStats, DrawStatsHandle, Frame, GpuImage, GpuScene, GpuTarget, INSTANCE_SIZE, InstanceLook,+ InstancedMesh, LINE_SIZE, LOD_PX, MAX_PALETTE, PBR_SIZE, Palette, PaletteIndex, PlannedBody, Renderer, SHARED_SIZE, SceneBlock, SceneSlot,+ SharedTris, TRI_SIZE, TriClass, UploadError, extend_runs, level_for, lifted_width, placement_scale, runs_within, supersampled_size,};/// A frame of the viewport as an egui paint callback.@@ -454,7 +453,7 @@ fn offscreen(clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis,analysis_colors,access: None,diff --git a/crates/ui-egui/src/navigation.rs b/crates/ui-egui/src/navigation.rsindex ef25cd0f69..fa256558b3 100644--- a/crates/ui-egui/src/navigation.rs+++ b/crates/ui-egui/src/navigation.rs@@ -295,6 +295,39 @@ pub(crate) fn pinch_factor(input: &egui::InputState, options: egui::InputOptionsfactor}+/// The wheel and pinch of this frame for a widget that zooms and moves along one axis itself (a+/// range track), claimed so that nothing under it moves as well: the wheel's vertical points+/// (zoom), its sideways points (the content moves by them) and the pinch factor. Units and+/// modifier routing are egui's, as for the camera.+pub(crate) fn axis_wheel(ctx: &egui::Context, page_height: f32) -> (f32, f32, f32) {+ let options = ctx.options(|o| o.input_options);+ let (zoom, sideways, pinch) = ctx.input(|i| {+ let (mut zoom, mut sideways) = (0.0, 0.0);+ for event in &i.events {+ let egui::Event::MouseWheel { unit, delta, modifiers, phase } = event else { continue };+ if *phase != egui::TouchPhase::Move || modifiers.matches_any(options.zoom_modifier) {+ continue;+ }+ let points = match unit {+ egui::MouseWheelUnit::Point => *delta,+ egui::MouseWheelUnit::Line => *delta * options.line_scroll_speed,+ egui::MouseWheelUnit::Page => *delta * page_height,+ };+ let up = route_wheel_vertical(points, *modifiers, options);+ zoom += up;+ sideways += if up == 0.0 { points.x + points.y } else { points.x };+ }+ // A zoom-modified wheel, skipped above, zooms the track once, as a pinch: no chosen+ // trackpad modifier turns it into anything else here.+ (zoom, sideways, pinch_factor(i, options, page_height, None))+ });+ let (zoom, sideways) = (if zoom.is_finite() { zoom } else { 0.0 }, if sideways.is_finite() { sideways } else { 0.0 });+ if zoom != 0.0 || sideways != 0.0 || pinch != 1.0 {+ claim_wheel(ctx);+ }+ (zoom, sideways, pinch)+}+/// Give this frame's wheel to the widget under the pointer that uses it itself (a value field/// stepping its number, `value_step`): no scroll area or camera under it moves as well.pub(crate) fn claim_wheel(ctx: &egui::Context) {diff --git a/crates/ui-egui/src/point_clouds.rs b/crates/ui-egui/src/point_clouds.rsindex 414c33760c..9519670949 100644--- a/crates/ui-egui/src/point_clouds.rs+++ b/crates/ui-egui/src/point_clouds.rs@@ -1,90 +1,191 @@-//! Point clouds (#5151): with the GPU viewport their points are dots in the 3D pass (depth-tested-//! with the model); the CPU viewport draws some of them over its image.+//! Point clouds (#5151): with the GPU viewport their points are drawn in the 3D pass+//! (depth-tested with the model), coloured and filtered by the shaders; the CPU viewport draws+//! some of them over its image.use std::cell::RefCell;use std::collections::HashMap;use std::sync::Arc;use egui::{Painter, Shape};-use solidcraft_engine::doc::point_cloud::PointCloud;+use solidcraft_engine::doc::point_cloud::Keep;+use solidcraft_engine::doc::point_cloud::{ColorBy, PLAIN, PointCloud, Source, byte};+use solidcraft_engine::doc::point_cloud_distribution::color_range_by;+use solidcraft_gpu::view::{CloudFilter, CloudStyle, ColorMode, Dot, FILTERS, GpuCloud, cloud_dot};use crate::SolveApp;-use crate::gpu::GpuPoints;+use crate::browser::point_cloud_tracks::{Ask, Paint, Tracks};use crate::viewport::Proj;/// Most points the CPU viewport draws of all clouds together.const MAX_CPU_POINTS: usize = 100_000;-/// What a cloud's dots are made from: they are made again only when one of these changes.+/// What a cloud's records are made from: they are made again only when one of these changes.+/// Its colour range, filter ranges and dot size are its style, read by the shaders.#[derive(Clone, PartialEq)]struct Key {- points: usize,- colors: usize,+ data: Vec<usize>,len: usize,origin: [u64; 3],transform: [u64; 16],- size: u64,- color_by: solidcraft_engine::doc::point_cloud::ColorBy,+ color_by: ColorBy,color: Option<[u32; 3]>,- height_range: Option<[u64; 2]>,+ value: Option<String>,+ filtered: [Option<String>; FILTERS],}impl Key {fn of(c: &PointCloud) -> Key {+ let mut data = vec![Arc::as_ptr(c.points.values()).cast::<f32>() as usize, Arc::as_ptr(&c.colors.0).cast::<u8>() as usize];+ data.extend(c.complex.columns.iter().map(|k| Arc::as_ptr(&k.values.0).cast::<f32>() as usize));Key {- points: Arc::as_ptr(c.points.values()).cast::<f32>() as usize,- colors: Arc::as_ptr(&c.colors.0).cast::<u8>() as usize,+ data,len: c.len(),origin: [c.origin.x, c.origin.y, c.origin.z].map(f64::to_bits),transform: std::array::from_fn(|i| c.transform[i / 4][i % 4].to_bits()),- size: c.point_size.to_bits(),color_by: c.color_by,color: c.color.map(|k| k.map(f32::to_bits)),- height_range: c.height_range.map(|r| r.map(f64::to_bits)),+ value: c.colored_property().map(str::to_string),+ filtered: std::array::from_fn(|k| c.filters.get(k).map(|f| f.property.clone())),}}}thread_local! {- /// Dots by cloud id: what they were made from, their version and bytes.- static DOTS: RefCell<HashMap<u64, (Key, u64, Arc<Vec<u8>>)>> = RefCell::new(HashMap::new());+ /// Records by cloud id: what they were made from, their version and bytes.+ static RECORDS: RefCell<HashMap<u64, (Key, u64, Arc<Vec<u8>>)>> = RefCell::new(HashMap::new());static VERSION: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };+ /// By cloud id, the values its coloured property takes over what is kept, worked out off the+ /// frame (one worker a cloud, so that each keeps its own geometry).+ static EXTENTS: RefCell<HashMap<u64, Tracks>> = RefCell::new(HashMap::new());}-fn dots(c: &PointCloud) -> Vec<u8> {- let mut out = Vec::with_capacity(c.len() * crate::gpu::CLOUD_POINT_SIZE);- let size = c.point_size as f32;- let shade = c.shade();- for (i, p) in c.points.iter().enumerate() {+/// The ramp's range of `c` as drawn ([`as_drawn`]): the one set, else, by a property, exactly+/// the values it takes over what the drawn filters keep. Worked out off the frame: until then,+/// the last answer, or the cloud's own bound.+pub(crate) fn color_range(ctx: &egui::Context, c: &PointCloud) -> Option<[f64; 2]> {+ color_range_by(c, |property, axis| {+ let ask = Ask {+ property: property.to_string(),+ span: axis,+ loupe: axis,+ bins: 1,+ paint: Paint::One,+ filters: c.filters.iter().take(FILTERS).cloned().collect(),+ changes_of: None,+ };+ EXTENTS.with(|e| e.borrow_mut().entry(c.id).or_default().answer(ctx, c, "extent", ask)).and_then(|a| a.extent)+ })+}++fn records(c: &PointCloud) -> Arc<Vec<u8>> {+ let plain = PLAIN.map(byte);+ let single = c.color.unwrap_or(PLAIN).map(byte);+ let own = |i: usize| match c.color_by {+ ColorBy::Single => single,+ ColorBy::File => c.colors.get(i).unwrap_or(plain),+ ColorBy::Height | ColorBy::Property => plain,+ };+ // The coloured property, then the filtered ones.+ let sources: [Option<Source>; 1 + FILTERS] = std::array::from_fn(|k| {+ let name = if k == 0 { c.colored_property() } else { c.filters.get(k - 1).map(|f| f.property.as_str()) };+ name.and_then(|n| c.source(n))+ });+ let mut out = Vec::with_capacity(c.len() * solidcraft_gpu::view::DOT_SIZE);+ for i in 0..c.len() {// Placed in double precision: the cloud's origin may be far from the design's.- let local = c.origin + solidcraft_engine::geom::Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]));- let w = solidcraft_engine::doc::apply_point(&c.transform, local);- crate::gpu::cloud_point(&mut out, [w.x as f32, w.y as f32, w.z as f32], shade(i), size);+ let w = c.world_point(i).unwrap_or_default();+ let at = [w.x as f32, w.y as f32, w.z as f32];+ let values = sources.map(|s| {+ s.map(|s| match s {+ Source::Coordinate(k) => at.get(k).copied().unwrap_or(0.0),+ Source::Column(v) => v.get(i).copied().unwrap_or(0.0),+ })+ });+ let mut dot = Dot { at, rgb: own(i), ..Default::default() };+ let [value, filtered @ ..] = values;+ if let Some(v) = value {+ dot.value = v;+ dot.has |= 1 << FILTERS;+ }+ for (k, f) in filtered.into_iter().enumerate() {+ if let (Some(f), Some(slot)) = (f, dot.filtered.get_mut(k)) {+ *slot = f;+ dot.has |= 1 << k;+ }+ }+ cloud_dot(&mut out, &dot);}- out+ Arc::new(out)}-/// The shown point clouds as GPU dots.-pub fn gpu_points(app: &SolveApp) -> Vec<GpuPoints> {+/// The cloud as it is drawn now: a filter `playing` in the Edit Point Cloud card at its range+/// now, so that what follows from the filters (the ramp's automatic range) follows it too.+pub(crate) fn as_drawn(c: &PointCloud, playing: impl Fn(usize) -> Option<[f64; 2]>) -> std::borrow::Cow<'_, PointCloud> {+ let mut c = std::borrow::Cow::Borrowed(c);+ for k in 0..c.filters.len() {+ if let Some(range) = playing(k)+ && let Some(f) = c.to_mut().filters.get_mut(k)+ {+ f.keep = Keep::Range { range };+ }+ }+ c+}++/// How a cloud is coloured and which of its elements are shown, as the shaders read it; a filter+/// playing in the Edit Point Cloud card shows its range now.+fn style(ctx: &egui::Context, c: &PointCloud, playing: impl Fn(usize) -> Option<[f64; 2]>) -> CloudStyle {+ let c = as_drawn(c, playing);+ let property = c.colored_property();+ let mode = match (c.color_by, property) {+ (ColorBy::File | ColorBy::Single, _) | (_, None) => ColorMode::Own,+ (_, Some(name)) if c.complex.integer(name) => ColorMode::Palette,+ _ => ColorMode::Ramp,+ };+ let mut filters = [CloudFilter::Off; FILTERS];+ for (f, slot) in c.filters.iter().zip(filters.iter_mut()) {+ *slot = match &f.keep {+ Keep::Range { range } => CloudFilter::Range(range.map(|v| v as f32)),+ Keep::Values { values } => {+ // Bit `i` is the value `offset + i`, from the label's smallest value.+ let offset = c.complex.names(&f.property).and_then(|n| n.values.iter().map(|(v, _)| *v).min()).unwrap_or(0);+ let mask = values+ .iter()+ .filter_map(|v| u32::try_from(i64::from(*v) - i64::from(offset)).ok())+ .filter(|i| *i < 32)+ .fold(0u32, |m, i| m | 1 << i);+ CloudFilter::Values { offset, mask }+ }+ };+ }+ let range = color_range(ctx, &c).unwrap_or([0.0, 1.0]).map(|v| v as f32);+ CloudStyle { mode, range, filters, point_size: c.point_size as f32 }+}++/// The shown point clouds as the GPU draws them.+pub fn gpu_clouds(app: &SolveApp, ctx: &egui::Context) -> Vec<GpuCloud> {let doc = &app.session.doc;- DOTS.with(|m| {+ EXTENTS.with(|e| e.borrow_mut().retain(|id, _| doc.point_clouds.iter().any(|c| c.id == *id)));+ RECORDS.with(|m| {let mut m = m.borrow_mut();m.retain(|id, _| doc.point_clouds.iter().any(|c| c.id == *id));solidcraft_engine::view::shown_point_clouds(&app.session).map(|c| {let key = Key::of(c);- if let Some((k, version, bytes)) = m.get(&c.id)- && *k == key- {- return GpuPoints { id: c.id, version: *version, bytes: bytes.clone() };- }- let version = VERSION.with(|v| {- v.set(v.get() + 1);- v.get()- });- let bytes = Arc::new(dots(c));- m.insert(c.id, (key, version, bytes.clone()));- GpuPoints { id: c.id, version, bytes }+ let (version, dots) = match m.get(&c.id) {+ Some((k, version, records)) if *k == key => (*version, records.clone()),+ _ => {+ let version = VERSION.with(|v| {+ v.set(v.get() + 1);+ v.get()+ });+ let records = records(c);+ m.insert(c.id, (key, version, records.clone()));+ (version, records)+ }+ };+ let playing = |k: usize| app.tree.cloud_panel.as_ref().and_then(|p| p.playing(c.id, k));+ GpuCloud { id: c.id, version, dots, style: style(ctx, c, playing) }}).collect()})@@ -104,7 +205,7 @@ pub fn show(app: &SolveApp, painter: &Painter, proj: &Proj) {let mut shapes = Vec::new();for c in clouds {let r = (c.point_size as f32 / painter.ctx().pixels_per_point() * 0.5).max(0.5);- let shade = c.shade();+ let shade = c.shade(color_range(painter.ctx(), c));for i in (0..c.len()).step_by(stride) {let Some(p) = c.world_point(i) else { continue };let Some(q) = proj.to_screen(p) else { continue };@@ -119,7 +220,7 @@ mod tests {use super::*;#[test]- fn dots_follow_the_cloud_and_are_made_again_only_when_it_changes() {+ fn records_are_made_again_only_when_the_cloud_changes_and_its_style_follows_it() {let mut h = crate::scenario::Harness::new();let dir = std::env::temp_dir().join(format!("solidcraft-ui-cloud-{}", std::process::id()));std::fs::create_dir_all(&dir).unwrap();@@ -131,32 +232,68 @@ mod tests {assert!(!crate::browser::is_open(&h.app, "point_clouds", true));h.app.run("browser.expand_all", serde_json::json!({})).unwrap();assert!(crate::browser::is_open(&h.app, "point_clouds", true));- let first = gpu_points(&h.app);+ let first = gpu_clouds(&h.app, &h.ctx);assert_eq!(first.len(), 1);- assert_eq!(first[0].bytes.len(), 2 * crate::gpu::CLOUD_POINT_SIZE);- // The second point: at x = 10, green, 3 px (24 eighths).- assert_eq!(&first[0].bytes[16..20], &10f32.to_le_bytes());- assert_eq!(&first[0].bytes[28..32], &[0, 255, 0, 24]);- assert_eq!(gpu_points(&h.app)[0].version, first[0].version, "unchanged: the same dots");+ let size = solidcraft_gpu::view::DOT_SIZE;+ assert_eq!(first[0].dots.len(), 2 * size);+ // The second point: at x = 10, green.+ assert_eq!(&first[0].dots[size..size + 4], &10f32.to_le_bytes());+ assert_eq!(&first[0].dots[2 * size - 4..2 * size - 1], &[0, 255, 0]);+ assert_eq!(first[0].style.point_size, 3.0);+ assert_eq!(gpu_clouds(&h.app, &h.ctx)[0].version, first[0].version, "unchanged: the same records");h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "color": [0, 0, 1]})).unwrap();- let blue = gpu_points(&h.app);+ let blue = gpu_clouds(&h.app, &h.ctx);assert_ne!(blue[0].version, first[0].version);- assert_eq!(&blue[0].bytes[12..15], &[0, 0, 255]);- // By height across x = 0…10 (the cloud turned so x is up): low end blue, high end red.- let up = serde_json::json!([0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0]);- h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "color_by": "height", "matrix": up})).unwrap();- let ramp = gpu_points(&h.app);- let ramp_of = solidcraft_engine::doc::point_cloud::height_ramp;- assert_eq!((&ramp[0].bytes[12..15], &ramp[0].bytes[28..31]), (&ramp_of(0.0)[..], &ramp_of(1.0)[..]));+ assert_eq!(&blue[0].dots[size - 4..size - 1], &[0, 0, 255]);+ // By height: a ramp over the range, the range a style alone.+ h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "color_by": "height", "height_range": [0, 1]})).unwrap();+ let ramp = gpu_clouds(&h.app, &h.ctx);+ assert_eq!((ramp[0].style.mode, ramp[0].style.range), (ColorMode::Ramp, [0.0, 1.0]));+ h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "height_range": [0, 2]})).unwrap();+ let wider = gpu_clouds(&h.app, &h.ctx);+ assert_eq!((wider[0].version, wider[0].style.range), (ramp[0].version, [0.0, 2.0]), "a new range uploads nothing");// Hidden, alone or with its folder: nothing drawn; the view frames it while shown.assert!(!solidcraft_engine::view::bounds(&h.app.session).is_empty());let first_bounds = crate::viewport::model_bounds(&h.app);assert!(!first_bounds.is_empty());assert_eq!(crate::viewport::model_bounds(&h.app), first_bounds, "cached sketch bounds keep the point cloud extent");h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "visible": false})).unwrap();- assert!(gpu_points(&h.app).is_empty());+ assert!(gpu_clouds(&h.app, &h.ctx).is_empty());assert!(solidcraft_engine::view::bounds(&h.app.session).is_empty());assert!(crate::viewport::model_bounds(&h.app).is_empty());let _ = std::fs::remove_dir_all(dir);}++ #[test]+ fn an_automatic_range_is_what_is_kept_and_follows_a_playing_filter() {+ let mut h = crate::scenario::Harness::new();+ let dir = std::env::temp_dir().join(format!("solidcraft-ui-cloud-play-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("t.ply");+ // Eleven points, x and t both running 0 to 10.+ let mut ply = String::from(+ "ply\nformat ascii 1.0\nelement vertex 11\nproperty float x\nproperty float y\nproperty float z\nproperty float t\nend_header\n",+ );+ for i in 0..=10 {+ ply += &format!("{i} 0 0 {i}\n");+ }+ std::fs::write(&path, ply).unwrap();+ let id = h.app.run("pointcloud.insert", serde_json::json!({"path": path.to_string_lossy()})).unwrap()["cloud"].as_u64().unwrap();+ // Filtered by x, not by t: the range is what is kept of t, 2 to 4, once worked out.+ h.app.run("pointcloud.edit", serde_json::json!({"cloud": id, "color_by": "t", "filters": [{"property": "x", "range": [2, 4]}]})).unwrap();+ let range = |h: &crate::scenario::Harness, playing: Option<[f64; 2]>| style(&h.ctx, &h.app.session.doc.point_clouds[0], |_| playing).range;+ let settle = |h: &crate::scenario::Harness, playing: Option<[f64; 2]>, want: [f32; 2]| {+ (0..500).any(|_| {+ let ok = range(h, playing) == want;+ if !ok {+ std::thread::sleep(std::time::Duration::from_millis(5));+ }+ ok+ })+ };+ assert!(settle(&h, None, [2.0, 4.0]), "{:?}", range(&h, None));+ // Played on to 8, the filter is drawn there, and the range follows it.+ assert!(settle(&h, Some([2.0, 8.0]), [2.0, 8.0]), "{:?}", range(&h, Some([2.0, 8.0])));+ let _ = std::fs::remove_dir_all(dir);+ }}diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 511d15bea3..14d56646eb 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -2058,7 +2058,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: [0.0; 36],access: None,diff --git a/crates/ui-egui/src/scale_tests.rs b/crates/ui-egui/src/scale_tests.rsindex b0c28a4ba9..c4afcbc250 100644--- a/crates/ui-egui/src/scale_tests.rs+++ b/crates/ui-egui/src/scale_tests.rs@@ -283,7 +283,7 @@ pub(crate) fn view_frame(clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: crate::gpu::analysis_colors(&t.analysis),access: None,diff --git a/crates/ui-egui/src/ui_kit/fields.rs b/crates/ui-egui/src/ui_kit/fields.rsindex 0ecf16e93a..187ce16bcc 100644--- a/crates/ui-egui/src/ui_kit/fields.rs+++ b/crates/ui-egui/src/ui_kit/fields.rs@@ -923,6 +923,36 @@ pub(crate) fn number_fields<T: egui::emath::Numeric>(.collect()}+/// A number on a range track, without unit: dragged `speed` a point, shown with `decimals`, typed+/// as a sum of numbers (`relative_number`).+/// Tokens: scope control/font tokens. Values are caller data.+pub(crate) fn track_number(ui: &mut Ui, value: &mut f64, speed: f64, decimals: usize) -> Response {+ let now = *value;+ let response = ui.add(egui::DragValue::new(value).speed(speed).fixed_decimals(decimals).custom_parser(move |s| relative_number(s, now)));+ Tokens::get().input_bevel(ui, &response);+ super::layout::publish_geometry(ui, &response);+ response+}++/// A value typed as a sum of numbers (`crate::prefs::parse_number` each), added to `now` when it+/// starts with a sign: "+30" moves the value by 30, "0-5" is −5.+fn relative_number(text: &str, now: f64) -> Option<f64> {+ let text: String = text.chars().filter(|c| !c.is_whitespace()).map(|c| if c == '\u{2212}' { '-' } else { c }).collect();+ let mut total = if text.starts_with(['+', '-']) { now } else { 0.0 };+ let mut term = String::new();+ let mut prev = ' ';+ for c in text.chars() {+ if (c == '+' || c == '-') && !term.is_empty() && !matches!(prev, 'e' | 'E') {+ total += crate::prefs::parse_number(&term)?;+ term.clear();+ }+ term.push(c);+ prev = c;+ }+ total += crate::prefs::parse_number(&term)?;+ total.is_finite().then_some(total)+}+/// Growing plain-text message editor; its parent owns scrolling and Enter routing./// Tokens: control_fill, form_inset, font_label. Use text_area for bounded data input.#[cfg(any(not(target_arch = "wasm32"), test))]diff --git a/crates/ui-egui/src/ui_kit/fields_tests.rs b/crates/ui-egui/src/ui_kit/fields_tests.rsindex 4cc2e3814a..c05710673f 100644--- a/crates/ui-egui/src/ui_kit/fields_tests.rs+++ b/crates/ui-egui/src/ui_kit/fields_tests.rs@@ -665,3 +665,15 @@ fn esc_closes_the_text_menu_alone() {menu_frame(&ctx, key(egui::Key::Escape), &mut draw);assert!(owner_saw_esc.get(), "with the menu closed, Esc reaches the owner again");}++#[test]+fn a_track_number_adds_up_and_a_sign_adds_to_the_value_now() {+ let typed = super::relative_number;+ assert_eq!(typed("1200", 5.0), Some(1200.0));+ assert_eq!(typed("+30", 100.0), Some(130.0));+ assert_eq!(typed(" -30 ", 100.0), Some(70.0));+ assert_eq!(typed("\u{2212}2,5", 10.0), Some(7.5));+ assert_eq!(typed("0-5", 100.0), Some(-5.0));+ assert_eq!(typed("1e-3+1", 0.0), Some(1.001));+ assert_eq!(typed("abc", 1.0), None);+}diff --git a/crates/ui-egui/src/ui_kit/gallery.rs b/crates/ui-egui/src/ui_kit/gallery.rsindex 9d29ec8d2f..4ef81e7a05 100644--- a/crates/ui-egui/src/ui_kit/gallery.rs+++ b/crates/ui-egui/src/ui_kit/gallery.rs@@ -1177,6 +1177,9 @@ const ELEMENTS: &[Element] = &[element!("scalar_field", |ui, _| {scalar_field(ui, &mut 0.5, 0.0..=1.0);}),+ element!("track_number", |ui, _| {+ track_number(ui, &mut 1350.0, 0.5, 1);+ }),element!("length_field", |ui, _| {length_field(ui, &mut 12.7, "in", 2);}),diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 2f8a173979..5104edf1b4 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -4332,7 +4332,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {back: proj.cam.back().to_f32(),size_px,images: crate::ref_images::gpu_images(app),- points: crate::point_clouds::gpu_points(app),+ clouds: crate::point_clouds::gpu_clouds(app, ui.ctx()),analysis: analysis_uniform(app),analysis_colors: crate::gpu::analysis_colors(&t.analysis),access: crate::access::map(app),@@ -7956,7 +7956,7 @@ mod tests {clip: [0.0; 4],cap: [0.0; 4],images: Vec::new(),- points: Vec::new(),+ clouds: Vec::new(),analysis: [0.0; 8],analysis_colors: crate::gpu::analysis_colors(&Tokens::get().analysis),access: None,diff --git a/docs/point-clouds.md b/docs/point-clouds.mdindex 2ba95ce274..7f0600c804 100644--- a/docs/point-clouds.md+++ b/docs/point-clouds.md@@ -9,7 +9,7 @@ depends on it.| Extension | What is read ||-----------|--------------|-| `.ply` | ASCII, binary little-endian and binary big-endian PLY: the `vertex` element's `x`, `y`, `z` (any numeric type) and its `red`, `green`, `blue` when present (bytes, 16-bit or 0…1 floats). Other properties (normals, intensity) and elements are passed over. |+| `.ply` | ASCII, binary little-endian and binary big-endian PLY: the `vertex` element's `x`, `y`, `z` (any numeric type) and its `red`, `green`, `blue` when present (bytes, 16-bit or 0…1 floats). Every other scalar vertex property (intensity, a class, a time…) is kept, by its name in the file, to colour and filter the cloud by; it is whole-numbered when its type is an integer. Other elements are passed over. || `.xyz`, `.pts` | Text, a point per line: `x y z`, optionally followed by `r g b` (six numbers) or by an intensity and `r g b` (seven or more, as PTS files write it). Spaces, tabs, commas or semicolons separate the numbers; `#` and `//` start comments; a PTS file's first line (its count) is skipped. |A PLY file that also has faces can be inserted as a mesh body instead with **Insert Mesh**@@ -27,9 +27,51 @@ or `pointcloud.edit` with `units`): the points are scaled from the unit they cam- `file` (the default): the file's colour of each point, grey when it has none.- `single`: one colour (`color`) for every point.- `height`: a ramp by design Z, blue low through cyan, green and yellow to red high. It runs- between two heights (`height_range`, mm). By default they are worked out from the points: all- but the lowest and highest 2 %, so a few stray points don't flatten the ramp. Turn- **Automatic Range** off in the card to set them.+ between two heights (`color_range`, mm). By default they are worked out from the points: all+ but the lowest and highest 2 %, so a few stray points don't flatten the ramp.+- any property's name (`x`, `y`, `z` or one of the file's): the same ramp over the property's+ values or, for a whole-numbered property, a palette of ten colours (its value modulo ten;+ negative values grey). By default the ramp runs exactly over the values the property takes on+ the points every filter keeps, so filtering re-spreads the colours over what is left.++A ramp's range is a [range track](#range-tracks) in the card; touching it sets the range and+turns **Automatic Range** off, and ticking the box (or a double click beside the range) gives+it back. `color_range: null` does the same from a command.++A whole-numbered property may name its values with a PLY comment, `property: 0 name, 1 other+name, -1 none` (for example `comment role: 0 outer wall, 1 inner wall`). Coloured by it, the+card shows a legend, a swatch and a name per value; clicking a name shows or hides that value.++## Filters++A filter keeps the points whose property lies in a range (both ends included) or, for a+property with named values, is one of a set of values. Only what every filter keeps is shown; a+cloud has at most 8 filters, and the view applies the first 4. **Filter by** in the card adds+one over a property's whole span (or with all its named values); × removes it. Filters change+what is drawn, never the points the design holds.++## Range tracks++Each range filter, and a ramp's range, is edited on a track, as a range is in an audio editor.+The track draws how much of the cloud lies at each value: a histogram of the property over what+the *other* filters keep, stacked by colour, so it is also the colour legend. A thin strip above+it shows the property's whole span, with the part the track shows framed.++- Drag an end or the band between them to move them; drag elsewhere to draw a new range.+ Shift-click brings the nearer end to the pointer.+- Double-click the band to fit the track to it; double-click beside it for the whole span.+ The wheel or a pinch zooms around the pointer, a sideways scroll pans, and dragging in the+ strip moves the framed part.+- An end snaps to a value where the colour changes when no other change is near at this zoom;+ a whole-numbered property's ends snap to whole numbers. ⌥ moves ten times slower, without+ snapping.+- Once the track is touched, ← and → bring the part touched last to the previous or next colour+ change (one pixel with ⌥, or where there is none).+- **Start**, **End** and **Length** are fields too; Length keeps the start. A value typed with a+ sign is relative: `+30` moves it by 30.+- **▶ Play** (or Space) moves the part touched last across the track in 20 seconds: an upper+ end grows the range, the band slides it, a lower end wipes it. The track follows it, and an+ automatic colour range follows it too. Touching the range stops it.## Size@@ -42,12 +84,17 @@ file as a binary part (12 bytes a point, 3 more with colours).## Commands- `pointcloud.insert` — `path`; `name?`, `units?`, `max_points?`, `center?` (move the middle of- its base to the origin), `point_size?` (pixels), `color_by?` (`file`, `single`, `height`),- `color?` (`[r, g, b]` 0…1; alone it means `single`, `null` means `file`), `height_range?`- (`[low, high]` mm, or `null` for the automatic range).+ its base to the origin), `point_size?` (pixels), `color_by?` (`file`, `single`, `height` or a+ property's name), `color?` (`[r, g, b]` 0…1; alone it means `single`, `null` means `file`),+ `color_range?` (`[low, high]`, or `null` for the automatic range; `height_range` is the same),+ `filters?` (`[{"property": …, "range": [low, high]}` or `{"property": …, "values": [whole+ numbers]}]`, or `null` for none).- `pointcloud.edit` — `cloud` (id or name); `name?`, `visible?`, `point_size?`, `color_by?`,- `color?`, `height_range?`, `units?`, `matrix?` (a rigid placement, as `occurrence.move` takes it).-- `pointcloud.delete`, `pointcloud.list`.+ `color?`, `color_range?`, `filters?`, `units?`, `matrix?` (a rigid placement, as+ `occurrence.move` takes it).+- `pointcloud.delete`.+- `pointcloud.list` — each cloud with its properties (name, whole-numbered or not, span, named+ values), its filters and its ramp's range as drawn (`color_range`).- `doc.open` opens a point cloud file as a new design holding it; dropping one on the windowadds it to the open design.@@ -55,4 +102,5 @@ file as a binary part (12 bytes a point, 3 more with colours).```json{"command": "pointcloud.insert", "params": {"path": "glim-points.ply", "units": "m", "color_by": "height"}}+{"command": "pointcloud.edit", "params": {"cloud": "glim-points", "color_by": "intensity", "filters": [{"property": "z", "range": [0, 2500]}]}}```