SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Point clouds: draw a PLY file's edges and faces (#8817) (#8820)
Mario Geigerc1760d4857c4
diff --git a/assets/locales/pending/point-cloud-edges-and-faces.json b/assets/locales/pending/point-cloud-edges-and-faces.jsonnew file mode 100644index 0000000000..bfca9e3d67--- /dev/null+++ b/assets/locales/pending/point-cloud-edges-and-faces.json@@ -0,0 +1,26 @@+{+ "en": {+ "ui.point_cloud_dots": "Dots"+ },+ "fr": {+ "ui.point_cloud_dots": "Points isolés"+ },+ "de": {+ "ui.point_cloud_dots": "Einzelpunkte"+ },+ "ja": {+ "ui.point_cloud_dots": "単独の点"+ },+ "zh": {+ "ui.point_cloud_dots": "独立点"+ },+ "ar": {+ "ui.point_cloud_dots": "نقاط منفردة"+ },+ "he": {+ "ui.point_cloud_dots": "נקודות בודדות"+ },+ "vi": {+ "ui.point_cloud_dots": "Điểm đơn lẻ"+ }+}diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 6f52b8de38..d3172ece8e 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -883,10 +883,10 @@ fn fs_line_all(i: LOut) -> @location(0) vec4<f32> {return out_color(i.c);}-// 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.+// Point clouds and their cells (`view/clouds.rs`): dots, segments as beads (or lines when they+// have no size) and triangles, from one record per element. 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; values vary across an element, so a range cuts it where its value crosses an end.struct Cloud {style: vec4<f32>, // x: colour (0 own, 1 ramp, 2 palette), y: dot size (px), z, w: ramp range@@ -895,43 +895,88 @@ struct Cloud {@group(1) @binding(3) var<uniform> cloud: Cloud;struct CIn {- @location(0) p: vec3<f32>,- @location(1) v: f32,- @location(2) f: vec4<f32>,- @location(3) rgb: vec4<f32>,+ @location(0) a: vec3<f32>,+ @location(1) b: vec3<f32>,+ @location(2) c: vec3<f32>,+ @location(8) before: vec3<f32>,+ @location(9) after: vec3<f32>,+ @location(3) v: vec3<f32>,+ @location(4) f0: vec3<f32>,+ @location(5) f1: vec3<f32>,+ @location(10) f2: vec3<f32>,+ @location(11) f3: vec3<f32>,+ @location(6) size: vec2<f32>,+ @location(7) rgb: vec4<f32>,};struct COut {@builtin(position) pos: vec4<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,+ @location(1) n: vec3<f32>, // zero: not lit+ @location(2) v: f32,+ @location(3) f: vec4<f32>,+ @location(4) rgb: vec3<f32>,+ @location(5) at: vec2<f32>, // a dot's place on its disc+ @location(6) @interpolate(flat) has: u32,};+fn cloud_out(i: CIn, w: vec3<f32>, wp: vec3<f32>, pos: vec4<f32>, n: vec3<f32>) -> COut {+ var o: COut;+ o.pos = pos;+ o.wp = wp;+ o.n = n;+ o.v = dot(w, i.v);+ o.f = vec4<f32>(dot(w, i.f0), dot(w, i.f1), dot(w, i.f2), dot(w, i.f3));+ o.rgb = i.rgb.rgb;+ o.at = vec2<f32>(0.0);+ o.has = u32(round(i.rgb.a * 255.0));+ return o;+}++fn behind(c: vec4<f32>) -> bool {+ return near_z(c) < 0.0;+}+@vertexfn 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(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.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));+ let centre = u.vp * vec4<f32>(i.a, 1.0);+ var pos = vec4<f32>(centre.xy + at * size / u.screen.xy * centre.w, centre.z, centre.w);+ if (behind(centre)) { pos = vec4<f32>(0.0, 0.0, 0.0, -1.0); }+ var o = cloud_out(i, vec3<f32>(1.0, 0.0, 0.0), i.a, pos, vec3<f32>(0.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;}+/// The least half-width of a segment on screen, in pixels.+const MIN_HALF_PX: f32 = 0.75;++/// The frame of a bead along `d`: along it, across it level, and up, its height axis.+fn bead_frame(d: vec3<f32>) -> mat3x3<f32> {+ var t = vec3<f32>(1.0, 0.0, 0.0);+ if (length(d) > 1e-9) { t = d / length(d); }+ var side = cross(vec3<f32>(0.0, 0.0, 1.0), t);+ if (length(side) < 1e-6) { side = vec3<f32>(1.0, 0.0, 0.0); }+ side = normalize(side);+ return mat3x3<f32>(t, side, cross(t, side));+}++/// Corner `j` (0…9) of a bead's cross-section, a stadium: its place across and up, and its+/// normal. Corners 0…4 go up the right half-disc, 5…9 down the left one, so 4–5 is the flat top+/// and 9–0 the flat bottom.+fn stadium(j: u32, size: vec2<f32>) -> vec4<f32> {+ let k = j % 10u;+ let right = k < 5u;+ let a = -1.5707963 + 0.7853982 * f32(k % 5u) + select(3.1415927, 0.0, right);+ let r = 0.5 * size.y;+ let flat_half = 0.5 * max(size.x - size.y, 0.0);+ return vec4<f32>(select(-flat_half, flat_half, right) + r * cos(a), r * sin(a), cos(a), sin(a));+}+/// Whether filter `f` keeps the value `v`.fn cloud_keeps(f: vec4<f32>, v: f32) -> bool {if (f.x < 0.5) { return true; }@@ -940,6 +985,101 @@ fn cloud_keeps(f: vec4<f32>, v: f32) -> bool {return k >= 0 && k < 32 && ((bitcast<u32>(f.w) >> u32(k)) & 1u) != 0u;}+/// Whether filter `f` leaves out a whole element with values `v` at its corners: all on one+/// side of a range, or one value at every corner, not kept. A set of values with corners that+/// differ may keep part of the element: its fragments decide.+fn cloud_drops(f: vec4<f32>, v: vec3<f32>) -> bool {+ if (f.x > 1.5) { return all(v == vec3<f32>(v.x)) && !cloud_keeps(f, v.x); }+ return f.x > 0.5 && (all(v < vec3<f32>(f.y)) || all(v > vec3<f32>(f.z)));+}++/// Whether a filter leaves out the whole element.+fn filtered_out(i: CIn) -> bool {+ let has = u32(round(i.rgb.a * 255.0));+ let values = array<vec3<f32>, 4>(i.f0, i.f1, i.f2, i.f3);+ for (var k = 0u; k < 4u; k++) {+ if (((has >> k) & 1u) != 0u && cloud_drops(cloud.filters[k], values[k])) { return true; }+ }+ return false;+}++/// The part in front of the near plane of the segment between clip-space `a` and `b`, as+/// fractions of it from `a`; empty (first above second) when all of it is behind. Clip-space+/// coordinates are affine along a line, so the crossing is exact.+fn in_front(a: vec4<f32>, b: vec4<f32>) -> vec2<f32> {+ let za = near_z(a);+ let zb = near_z(b);+ if (za < 0.0 && zb < 0.0) { return vec2<f32>(1.0, 0.0); }+ let t = za / (za - zb);+ return vec2<f32>(select(0.0, t, za < 0.0), select(1.0, t, zb < 0.0));+}++@vertex+fn vs_cloud_segment(@builtin(vertex_index) vi: u32, i: CIn) -> COut {+ // Corner `vi % 10` of the cross-section at the start (`vi < 10`) or the end; the index+ // buffer joins them into the bead's sides.+ let pa = u.vp * vec4<f32>(i.a, 1.0);+ let pb = u.vp * vec4<f32>(i.b, 1.0);+ let part = in_front(pa, pb);+ if (filtered_out(i) || part.x > part.y) {+ return cloud_out(i, vec3<f32>(1.0, 0.0, 0.0), i.a, vec4<f32>(0.0, 0.0, 0.0, -1.0), vec3<f32>(0.0));+ }+ // Where the near plane cuts it, the bead ends there, square; its numbers are exact at `e`.+ let at_end = vi >= 10u;+ let e = select(part.x, part.y, at_end);+ let cut = e != select(0.0, 1.0, at_end);+ let f = bead_frame(i.b - i.a);+ let c = stadium(vi % 10u, i.size);+ let axis = mix(i.a, i.b, e);+ // Where it meets the next or the previous bead, the cross-section lies in the plane halfway+ // between their directions, stretched across to keep its width: both beads end on the same+ // section. A turn sharper than 120° ends square instead.+ let other = select(i.a - i.before, i.after - i.b, at_end);+ var across_dir = f[1];+ var stretch = 1.0;+ if (!cut && length(other) > 1e-9) {+ let g = bead_frame(other);+ let mid = f[1] + g[1];+ if (length(mid) > 1e-6 && dot(normalize(mid), f[1]) > 0.5) {+ across_dir = normalize(mid);+ stretch = 1.0 / dot(across_dir, f[1]);+ }+ }+ let wp = axis + across_dir * (c.x * stretch) + f[2] * c.y;+ let ca = u.vp * vec4<f32>(axis, 1.0);+ let cw = u.vp * vec4<f32>(wp, 1.0);+ let half = u.screen.xy * 0.5;+ var pos = cw;+ // At least a pixel and a half across: a bead seen from afar, or a line without size. A corner+ // behind the eye has no place on the screen and needs no widening: the rasteriser clips it.+ if (cw.w > 0.0) {+ let c0 = mix(pa, pb, part.x);+ let c1 = mix(pa, pb, part.y);+ let along = (c1.xy / c1.w - c0.xy / c0.w) * half;+ var across = vec2<f32>(-along.y, along.x);+ if (length(across) < 1e-6) { across = vec2<f32>(1.0, 0.0); }+ across = normalize(across);+ var px = (cw.xy / cw.w - ca.xy / ca.w) * half;+ if (length(px) < MIN_HALF_PX * abs(c.z)) {+ px = across * c.z * MIN_HALF_PX;+ pos = vec4<f32>((ca.xy / ca.w + px / half) * cw.w, cw.z, cw.w);+ }+ }+ let n = select(f[1] * c.z + f[2] * c.w, vec3<f32>(0.0), i.size.y <= 0.0);+ return cloud_out(i, vec3<f32>(1.0 - e, e, 0.0), wp, pos, n);+}++@vertex+fn vs_cloud_triangle(@builtin(vertex_index) vi: u32, i: CIn) -> COut {+ // Not `w[vi] = 1.0`: the Windows D3D12 shader compiler cannot write through a dynamic vector index.+ let w = vec3<f32>(f32(vi == 0u), f32(vi == 1u), f32(vi == 2u));+ let wp = i.a * w.x + i.b * w.y + i.c * w.z;+ var n = cross(i.b - i.a, i.c - i.a);+ if (length(n) > 0.0) { n = normalize(n); }+ // The true clip-space corner, even behind the eye: the rasteriser clips a triangle exactly.+ return cloud_out(i, w, wp, u.vp * vec4<f32>(wp, 1.0), n);+}+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),@@ -974,5 +1114,8 @@ fn fs_cloud(o: COut) -> @location(0) vec4<f32> {} 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));}+ if (length(o.n) > 0.5) {+ c = c * (0.45 + 0.55 * abs(dot(normalize(o.n), normalize(u.back.xyz))));+ }return out_color(vec4<f32>(c, 1.0));}diff --git a/crates/doc/src/format/pending/point-cloud-segments-and-triangles.rs b/crates/doc/src/format/pending/point-cloud-segments-and-triangles.rsnew file mode 100644index 0000000000..219f4df9af--- /dev/null+++ b/crates/doc/src/format/pending/point-cloud-segments-and-triangles.rs@@ -0,0 +1,6 @@+//! A point cloud keeps the segments and triangles its file draws over its points (#8817):+//! `segments` and `triangles` in its `complex`, the indices of their points, and a column of named+//! numbers may lie on them (`on`: `segment` or `triangle`; a column that does not say is on the+//! points, as every design saved before this has it). Older designs need no transformation: their+//! clouds are points alone. The last release refuses a design saved with this (the newer format+//! number) instead of opening its clouds as loose points without their edges and faces.diff --git a/crates/doc/src/point_cloud.rs b/crates/doc/src/point_cloud.rsindex ab174333de..a1ad8d959a 100644--- a/crates/doc/src/point_cloud.rs+++ b/crates/doc/src/point_cloud.rs@@ -12,7 +12,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};use solidcore_record::Vec3;use crate::canvas::{base64_decode, base64_encode};-pub use crate::point_cloud_complex::{Column, Complex, Filter, Floats, Keep, MAX_COLUMNS, MAX_NAMES, Names};+pub use crate::point_cloud_complex::{Column, Complex, Filter, Floats, Indices, Keep, MAX_CELLS, MAX_COLUMNS, MAX_NAMES, Names, On};use crate::{DocError, IDENTITY, Mat, Result};/// Most points one cloud may hold.@@ -71,24 +71,26 @@ pub struct PointCloud {pub height_range: Option<[f64; 2]>,#[serde(default = "yes")]pub visible: bool,- /// The file's other properties of the points.+ /// Segments and triangles over the points, and the file's other properties.#[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.+ /// Only the elements within every filter's range are shown.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub filters: Vec<Filter>,}-/// Where a property's values come from.+/// Where a property's values come from on one kind of element.#[derive(Clone, Copy, Debug)]pub enum Source<'a> {- /// A coordinate of each point in the design.+ /// A coordinate of each corner in the design.Coordinate(usize),- /// A column of the file: each point's.- Column(&'a [f32]),+ /// A column on the points: each corner's.+ Corners(&'a [f32]),+ /// A column on the element itself.+ Element(&'a [f32]),}/// How a cloud's points are coloured.@@ -239,16 +241,21 @@ impl PointCloud {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<'_>> {+ /// Where the values of `name` are on elements of kind `on`: a coordinate of each corner, a+ /// column on the points (each corner's, varying across the element) or one on the element.+ pub fn source(&self, name: &str, on: On) -> 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))+ if let Some(col) = self.complex.column(name, on) {+ return Some(Source::Element(&col.values.0));+ }+ self.complex.column(name, On::Point).map(|col| Source::Corners(&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()))+ let mut seen = std::collections::BTreeSet::new();+ COORDINATES.into_iter().chain(self.complex.columns.iter().map(|c| c.name.as_str())).filter(move |n| seen.insert(*n))}/// The smallest and largest value of a property, the coordinates in the design.pub fn span(&self, property: &str) -> Option<[f64; 2]> {@@ -273,6 +280,19 @@ impl PointCloud {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 })}+ /// Points no segment or triangle ends on: those drawn as dots.+ pub fn isolated_points(&self) -> usize {+ if self.complex.segments.is_empty() && self.complex.triangles.is_empty() {+ return self.len();+ }+ let mut used = vec![false; self.len()];+ for i in self.complex.segments.0.iter().chain(self.complex.triangles.0.iter()) {+ if let Some(u) = used.get_mut(*i as usize) {+ *u = true;+ }+ }+ used.iter().filter(|u| !**u).count()+ }/// 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())@@ -281,7 +301,7 @@ impl PointCloud {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 column = self.color_property.as_deref().and_then(|n| self.complex.column(n));+ let column = self.color_property.as_deref().and_then(|n| self.complex.column(n, On::Point));move |i| match self.color_by {ColorBy::File => self.colors.get(i).unwrap_or(plain),ColorBy::Single => single,@@ -558,9 +578,10 @@ mod tests {}#[test]- fn the_ramp_spans_what_is_shown_unless_set() {+ fn the_ramp_spans_what_is_shown_unless_set_and_isolated_points_are_counted() {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.complex.segments = Indices(vec![0, 1].into());+ c.complex.columns.push(Column { name: "t".into(), on: On::Point, 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] } }];@@ -569,6 +590,7 @@ mod tests {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");+ assert_eq!(c.isolated_points(), 1, "point 2 ends no segment");}#[test]diff --git a/crates/doc/src/point_cloud_complex.rs b/crates/doc/src/point_cloud_complex.rsindex 6635996c72..fe26dc12dc 100644--- a/crates/doc/src/point_cloud_complex.rs+++ b/crates/doc/src/point_cloud_complex.rs@@ -1,5 +1,8 @@-//! 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+//! What a point cloud holds besides its points: segments and triangles between them, and named+//! numbers on its points, segments and triangles (a PLY file's properties), to colour the cloud+//! by and to filter it with. A point's numbers vary along the segments and across the triangles+//! that meet there; a segment's or a triangle's are constant on it. A segment with `width` and+//! `height` numbers is drawn as a bead of that cross-section; without them, as a line. 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.@@ -11,13 +14,41 @@ use crate::canvas::{base64_decode, base64_encode};use crate::point_cloud::MAX_POINTS;use crate::{DocError, Result};-/// Most named numbers per point.+/// Most segments or triangles in one cloud.+pub const MAX_CELLS: usize = 20_000_000;+/// Most named numbers per point, segment and triangle together.pub const MAX_COLUMNS: usize = 64;-/// One named number on every point.+/// The elements a column of numbers is on.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "lowercase")]+pub enum On {+ #[default]+ Point,+ Segment,+ Triangle,+}++impl On {+ fn is_point(&self) -> bool {+ *self == On::Point+ }+ pub fn name(self) -> &'static str {+ match self {+ On::Point => "point",+ On::Segment => "segment",+ On::Triangle => "triangle",+ }+ }+}++/// One named number on every element of a kind.#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct Column {pub name: String,+ /// Points unless said: a design saved with numbers on points alone says nothing.+ #[serde(default, skip_serializing_if = "On::is_point")]+ pub on: On,/// Whole numbers (labels, counts): coloured by a palette rather than a ramp.#[serde(default)]pub integer: bool,@@ -33,10 +64,16 @@ impl Column {}}-/// 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.+/// The complex a cloud's points span: segments and triangles over them, and named numbers on+/// all three. Without segments or triangles, the points alone are a complex of dimension 0.#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]pub struct Complex {+ /// Point indices, two per segment.+ #[serde(default, skip_serializing_if = "Indices::is_empty")]+ pub segments: Indices,+ /// Point indices, three per triangle, counter-clockwise seen from its front.+ #[serde(default, skip_serializing_if = "Indices::is_empty")]+ pub triangles: Indices,#[serde(default, skip_serializing_if = "Vec::is_empty")]pub columns: Vec<Column>,#[serde(default, skip_serializing_if = "Vec::is_empty")]@@ -78,33 +115,95 @@ impl Names {impl Complex {pub fn is_empty(&self) -> bool {- self.columns.is_empty() && self.names.is_empty()+ self.segments.is_empty() && self.triangles.is_empty() && 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 subcomplex spanned by the points `kept` marks: those points, numbered in order, with+ /// their numbers, and the segments and triangles all of whose corners are among them, with+ /// theirs. Also how many segments and triangles it leaves out.+ pub fn induced(&self, kept: &[bool]) -> (Complex, u64) {+ let mut next = 0u32;+ let renumbered: Vec<Option<u32>> = kept+ .iter()+ .map(|k| {+ k.then(|| {+ next += 1;+ next - 1+ })+ })+ .collect();+ let restrict = |indices: &Indices, n: usize| {+ let (mut ids, mut whole) = (Vec::new(), Vec::new());+ for corners in indices.0.chunks_exact(n) {+ let new: Option<Vec<u32>> = corners.iter().map(|i| renumbered.get(*i as usize).copied().flatten()).collect();+ whole.push(new.is_some());+ ids.extend(new.unwrap_or_default());+ }+ (Indices(ids.into()), whole)+ };+ let (segments, on_segments) = restrict(&self.segments, 2);+ let (triangles, on_triangles) = restrict(&self.triangles, 3);+ let left_out = on_segments.iter().chain(&on_triangles).filter(|whole| !**whole).count() as u64;+ let columns = self+ .columns+ .iter()+ .map(|c| {+ let mask = match c.on {+ On::Point => kept,+ On::Segment => &on_segments,+ On::Triangle => &on_triangles,+ };+ let values: Vec<f32> = c.values.0.iter().zip(mask).filter(|(_, k)| **k).map(|(v, _)| *v).collect();+ Column { values: Floats(values.into()), ..c.clone() }+ })+ .collect();+ (Complex { segments, triangles, columns, names: self.names.clone() }, left_out)+ }+ pub fn segment_count(&self) -> usize {+ self.segments.0.len() / 2+ }+ pub fn triangle_count(&self) -> usize {+ self.triangles.0.len() / 3}- /// The smallest and largest value named `name`.+ /// The column named `name` on elements of kind `on`: a name may be on several kinds.+ pub fn column(&self, name: &str, on: On) -> Option<&Column> {+ self.columns.iter().find(|c| c.name == name && c.on == on)+ }+ /// The smallest and largest value named `name`, on whichever elements carry it.pub fn span(&self, name: &str) -> Option<[f64; 2]> {- self.column(name).and_then(Column::span)+ self.columns.iter().filter(|c| c.name == name).filter_map(Column::span).reduce(|[a, b], [c, d]| [a.min(c), b.max(d)])}/// 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.+ /// Whether the values named `name` are whole numbers wherever they are.pub fn integer(&self, name: &str) -> bool {- self.column(name).is_some_and(|c| c.integer)+ let mut named = self.columns.iter().filter(|c| c.name == name).peekable();+ named.peek().is_some() && named.all(|c| c.integer)}- /// Every column has one number per point, the cloud having `points` points.+ /// How many elements of a kind there are, the cloud having `points` points.+ pub fn count(&self, on: On, points: usize) -> usize {+ match on {+ On::Point => points,+ On::Segment => self.segment_count(),+ On::Triangle => self.triangle_count(),+ }+ }+ /// Every index names a point, and every column has one number per element.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());+ let bad = |what: String| Err(DocError::Invalid(format!("point cloud complex: {what}")));+ if !self.segments.0.len().is_multiple_of(2) || !self.triangles.0.len().is_multiple_of(3) {+ return bad("segments are not pairs or triangles not triples".into());+ }+ if self.segment_count() > MAX_CELLS || self.triangle_count() > MAX_CELLS || self.columns.len() > MAX_COLUMNS {+ return bad("too many segments, triangles or properties".into());+ }+ if self.segments.0.iter().chain(self.triangles.0.iter()).any(|i| *i as usize >= points) {+ return bad("an index names a missing point".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 c.values.0.len() != self.count(c.on, points) {+ return bad(format!("property `{}` does not have one number per {}", c.name, c.on.name()));}}if self.names.len() > MAX_COLUMNS || self.names.iter().any(|n| n.values.is_empty() || n.values.len() > MAX_NAMES) {@@ -114,8 +213,8 @@ impl Complex {}}-/// 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.+/// Which elements 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,@@ -140,10 +239,26 @@ impl Filter {}}+/// Indices into a cloud's points, shared between copies of the design.+#[derive(Clone, Debug, Default)]+pub struct Indices(pub Arc<[u32]>);++impl Indices {+ pub fn is_empty(&self) -> bool {+ self.0.is_empty()+ }+}+/// Numbers, shared between copies of the design.#[derive(Clone, Debug, Default)]pub struct Floats(pub Arc<[f32]>);+impl PartialEq for Indices {+ fn eq(&self, other: &Self) -> bool {+ Arc::ptr_eq(&self.0, &other.0) || self.0 == other.0+ }+}+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()))@@ -167,6 +282,18 @@ fn words<'de, D: Deserializer<'de>>(d: D, max: usize) -> std::result::Result<VecOk(b.as_chunks::<4>().0.to_vec())}+impl Serialize for Indices {+ 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 Indices {+ fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {+ Ok(Indices(words(d, 3 * MAX_CELLS)?.into_iter().map(u32::from_le_bytes).collect()))+ }+}+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>>()))@@ -175,7 +302,7 @@ impl Serialize for Floats {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()))+ Ok(Floats(words(d, MAX_POINTS.max(MAX_CELLS))?.into_iter().map(f32::from_le_bytes).collect()))}}@@ -184,20 +311,26 @@ mod tests {use super::*;#[test]- fn properties_round_trip_and_are_checked_against_the_points() {+ fn a_complex_round_trips_and_is_checked_against_its_points() {let complex = Complex {+ segments: Indices(vec![0, 1, 1, 2].into()),+ triangles: Indices(vec![0, 1, 2].into()),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()) },+ Column { name: "t".into(), on: On::Point, integer: false, values: Floats(vec![0.0, 0.5, 1.0].into()) },+ Column { name: "role".into(), on: On::Segment, integer: true, values: Floats(vec![0.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);+ let points: Column = serde_json::from_str(r#"{"name": "t", "values": ""}"#).unwrap();+ assert!(!serde_json::to_string(&points).unwrap().contains("\"on\""), "a column on the points does not say so");+ assert_eq!(points.on, On::Point, "a column without `on` is on the points");complex.check(3).unwrap();- assert!(complex.check(2).is_err(), "three numbers for two points");+ assert!(complex.check(2).is_err(), "index 2 names a missing point");assert_eq!(complex.span("role"), Some([0.0, 4.0]));assert!(complex.integer("role") && !complex.integer("t") && !complex.integer("nope"));+ assert!(complex.column("role", On::Segment).is_some() && complex.column("role", On::Point).is_none());// 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));@@ -211,5 +344,8 @@ mod tests {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]}));+ let mut short = complex.clone();+ short.columns[1].values = Floats(vec![0.0].into());+ assert!(short.check(3).is_err(), "one role for two segments");}}diff --git a/crates/doc/src/point_cloud_distribution.rs b/crates/doc/src/point_cloud_distribution.rsindex 4d9e052f83..ce44b63314 100644--- a/crates/doc/src/point_cloud_distribution.rs+++ b/crates/doc/src/point_cloud_distribution.rs@@ -3,28 +3,77 @@//! 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.+//! Each element weighs its measure: a dot 1, a segment its length, a triangle its area, each kind+//! divided by its own total so that kinds of different dimension weigh alike. On an element every+//! property is linear (the same everywhere, or its corners' values interpolated), so filters,+//! colours and the histogram all cut it the same way, where a linear function crosses a value. A+//! range filter keeps the part between its ends, as the view does; a filter by values keeps the+//! parts whose rounded value it holds; the colour sorts the parts into the colours they are drawn+//! in. Each part spreads its measure exactly over the values it covers of the histogram's+//! property: a dot's at one value, a segment's evenly, a triangle's as the tent its corners'+//! values make. The values the parts 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};+use crate::point_cloud::{ColorBy, Filter, Keep, On, PALETTE, PointCloud, Source};/// Most bins of one histogram.pub const MAX_BINS: usize = 8192;+/// How far past its first band one part of an element is split by one cut. A ramp of [`MAX_BINS`]+/// bands, with the one below it and the one above it, has no more than this to cross, so its+/// measure is whole; only the whole numbers have more (a hostile file's values may cross billions).+const MAX_BANDS: usize = MAX_BINS + 1;+/// Most corners of a part of a triangle: each cut adds at most one to its three.+const MAX_CORNERS: usize = 24;-/// What the histograms need of a cloud's geometry, worked out once for its points.+/// What the histograms need of a cloud's geometry, worked out once for its points and cells.#[derive(Clone, Debug, Default)]pub struct Geometry {/// Each point in the design.world: Vec<[f64; 3]>,+ /// The points drawn as dots: those no segment or triangle ends on.+ dots: Vec<u32>,+ /// Each segment's share of all segments' length, and each triangle's of their area.+ segments: Vec<f64>,+ triangles: Vec<f64>,}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() }+ let world: Vec<[f64; 3]> = (0..c.len()).map(|i| c.world_point(i).map_or([0.0; 3], |p| [p.x, p.y, p.z])).collect();+ let mut used = vec![false; world.len()];+ for i in c.complex.segments.0.iter().chain(c.complex.triangles.0.iter()) {+ if let Some(u) = used.get_mut(*i as usize) {+ *u = true;+ }+ }+ let dots = (0..world.len() as u32).filter(|i| !used.get(*i as usize).copied().unwrap_or(true)).collect();+ let at = |i: u32| world.get(i as usize).copied().unwrap_or_default();+ let sub = |a: [f64; 3], b: [f64; 3]| [b[0] - a[0], b[1] - a[1], b[2] - a[2]];+ let norm = |v: [f64; 3]| (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();+ let segments = c.complex.segments.0.as_chunks::<2>().0.iter().map(|[a, b]| norm(sub(at(*a), at(*b)))).collect();+ let triangles = c+ .complex+ .triangles+ .0+ .as_chunks::<3>()+ .0+ .iter()+ .map(|[a, b, d]| {+ let (u, v) = (sub(at(*a), at(*b)), sub(at(*a), at(*d)));+ 0.5 * norm([u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]])+ })+ .collect();+ Geometry { world, dots, segments: shares(segments), triangles: shares(triangles) }+ }+}++/// Each measure over their total (none for a total that is not a positive number).+fn shares(mut m: Vec<f64>) -> Vec<f64> {+ let total: f64 = m.iter().filter(|v| v.is_finite()).sum();+ for v in &mut m {+ *v = if total > 0.0 && v.is_finite() { *v / total } else { 0.0 };}+ m}/// How a histogram is split by colour, into slots; the last slot holds what has no value to be@@ -82,11 +131,11 @@ 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.+ /// The least and the greatest value the parts kept take, within the axis or not.pub extent: Option<[f64; 2]>,}-/// Where values are cut into bands, by increasing values.+/// Where a linear function is 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.@@ -115,6 +164,123 @@ impl Cut {}}}+ /// The values band `k` holds, from and to (`None`: without end).+ fn bounds(&self, k: usize) -> (Option<f64>, Option<f64>) {+ match *self {+ Cut::Range([a, b]) => match k {+ 0 => (None, Some(a)),+ 1 => (Some(a), Some(b)),+ _ => (Some(b), None),+ },+ Cut::Grid { start, step, count } => {+ ((k > 0).then_some(start + k.saturating_sub(1) as f64 * step), (k < count).then_some(start + k as f64 * step))+ }+ }+ }+}++/// A part of an element in its own coordinates: a dot, a stretch `[s₀, s₁]` of a segment (0 at+/// its first point), or a convex polygon in a triangle (each corner the weights of the+/// triangle's second and third points).+// Parts live in two buffers reused element after element: boxing a polygon would allocate per+// triangle.+#[allow(clippy::large_enum_variant)]+#[derive(Clone, Copy, Debug)]+enum Part {+ Dot,+ Stretch([f64; 2]),+ Polygon(Polygon),+}++#[derive(Clone, Copy, Debug)]+struct Polygon {+ at: [[f64; 2]; MAX_CORNERS],+ len: usize,+}++impl Polygon {+ fn triangle() -> Polygon {+ let mut at = [[0.0; 2]; MAX_CORNERS];+ at[1] = [1.0, 0.0];+ at[2] = [0.0, 1.0];+ Polygon { at, len: 3 }+ }+ fn corners(&self) -> &[[f64; 2]] {+ self.at.get(..self.len).unwrap_or(&[])+ }+ /// The part where `g ≥ 0`.+ fn clip(&self, g: impl Fn([f64; 2]) -> f64) -> Polygon {+ let mut out = Polygon { at: [[0.0; 2]; MAX_CORNERS], len: 0 };+ let mut push = |p: [f64; 2]| {+ if let Some(slot) = out.at.get_mut(out.len) {+ *slot = p;+ out.len += 1;+ }+ };+ let c = self.corners();+ for (k, p) in c.iter().enumerate() {+ let q = c.get((k + 1) % c.len()).copied().unwrap_or(*p);+ let (gp, gq) = (g(*p), g(q));+ if gp >= 0.0 {+ push(*p);+ }+ if (gp >= 0.0) != (gq >= 0.0) {+ let f = gp / (gp - gq);+ push([p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f]);+ }+ }+ out+ }+}++/// A linear function on an element: its values at the corners.+fn at(f: [f64; 3], p: [f64; 2]) -> f64 {+ f[0] + (f[1] - f[0]) * p[0] + (f[2] - f[0]) * p[1]+}++/// The bands of `cut` that `part` meets where `f` takes its values, each with the part in it.+fn split(part: &Part, f: [f64; 3], cut: Cut, mut visit: impl FnMut(usize, Part)) {+ match part {+ Part::Dot => visit(cut.band(f[0]), Part::Dot),+ Part::Stretch([s0, s1]) => {+ let (a, b) = (at(f, [*s0, 0.0]), at(f, [*s1, 0.0]));+ let (lo, hi) = (a.min(b), a.max(b));+ let (k0, k1) = (cut.band(lo), cut.band(hi));+ if k0 == k1 || !(hi > lo) {+ return visit(k0, *part);+ }+ let s = |x: f64| s0 + (x - a) / (b - a) * (s1 - s0);+ for k in k0..=k1.min(k0 + MAX_BANDS) {+ let (from, to) = cut.bounds(k);+ let (x0, x1) = (from.map_or(lo, |v| v.max(lo)), to.map_or(hi, |v| v.min(hi)));+ if x1 > x0 {+ let (t0, t1) = (s(x0), s(x1));+ visit(k, Part::Stretch([t0.min(t1), t0.max(t1)]));+ }+ }+ }+ Part::Polygon(p) => {+ let values = p.corners().iter().map(|c| at(f, *c));+ let (lo, hi) = values.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v)));+ let (k0, k1) = (cut.band(lo), cut.band(hi));+ if k0 == k1 || !(hi > lo) {+ return visit(k0, *part);+ }+ for k in k0..=k1.min(k0 + MAX_BANDS) {+ let (from, to) = cut.bounds(k);+ let mut q = *p;+ if let Some(v) = from {+ q = q.clip(|c| at(f, c) - v);+ }+ if let Some(v) = to {+ q = q.clip(|c| v - at(f, c));+ }+ if q.len >= 3 {+ visit(k, Part::Polygon(q));+ }+ }+ }+ }}/// A filter as a cut and the bands it keeps.@@ -130,8 +296,7 @@ impl Kept<'_> {Keep::Values { values } => Kept { cut: INTEGERS, values: Some(values) },}}- fn keeps(&self, v: f64) -> bool {- let band = self.cut.band(v);+ fn keeps(&self, band: usize) -> bool {match self.values {None => band == 1,Some(values) => integer(band).is_some_and(|v| values.iter().any(|k| i64::from(*k) == v)),@@ -139,14 +304,133 @@ impl Kept<'_> {}}-/// The value of `s` at point `i`.-fn value(s: Source, i: usize, world: &[[f64; 3]]) -> f64 {+/// The values of `s` at an element's corners: element `e` of a kind, on points `ids`.+fn corners(s: Source, e: usize, ids: [u32; 3], world: &[[f64; 3]]) -> [f64; 3] {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)),+ Source::Coordinate(k) => ids.map(|i| world.get(i as usize).and_then(|p| p.get(k)).copied().unwrap_or(f64::NAN)),+ Source::Corners(v) => ids.map(|i| v.get(i as usize).map_or(f64::NAN, |x| f64::from(*x))),+ Source::Element(v) => [v.get(e).map_or(f64::NAN, |x| f64::from(*x)); 3],}}+/// Measure spread over bins: what falls in a bin directly, and evenly spread measure as ramps+/// (`k·max(0, x − c)` summed into its distribution function at each bin edge).+struct Bins {+ lo: f64,+ hi: f64,+ width: f64,+ n: usize,+ direct: Vec<f64>,+ slope: Vec<f64>,+ offset: Vec<f64>,+}++impl Bins {+ fn new([lo, hi]: [f64; 2], n: usize, slots: usize) -> Bins {+ Bins {+ lo,+ hi,+ width: (hi - lo) / n as f64,+ n,+ direct: vec![0.0; slots * n],+ slope: vec![0.0; slots * (n + 2)],+ offset: vec![0.0; slots * (n + 2)],+ }+ }+ fn edge(&self, j: usize) -> f64 {+ if j >= self.n { self.hi } else { self.lo + j as f64 * self.width }+ }+ /// The bin holding `x`, the last bin holding its upper end too.+ fn bin(&self, x: f64) -> Option<usize> {+ if !(x >= self.lo && x <= self.hi) {+ return None;+ }+ Some((((x - self.lo) / self.width).floor() as usize).min(self.n - 1))+ }+ fn add(&mut self, slot: usize, j: usize, m: f64) {+ if let Some(d) = self.direct.get_mut(slot * self.n + j) {+ *d += m;+ }+ }+ fn point(&mut self, slot: usize, x: f64, m: f64) {+ if let Some(j) = self.bin(x) {+ self.add(slot, j, m);+ }+ }+ /// A ramp of slope `k` from `c`: it reaches the first edge at or after `c`.+ fn ramp(&mut self, slot: usize, c: f64, k: f64) {+ let j = ((c - self.lo) / self.width).ceil().clamp(0.0, (self.n + 1) as f64) as usize;+ let at = slot * (self.n + 2) + j;+ if let (Some(s), Some(o)) = (self.slope.get_mut(at), self.offset.get_mut(at)) {+ *s += k;+ *o += k * c;+ }+ }+ /// `m` spread evenly over `[a, b]`.+ fn even(&mut self, slot: usize, a: f64, b: f64, m: f64) {+ if !(b > a) {+ return self.point(slot, a, m);+ }+ let k = m / (b - a);+ self.ramp(slot, a, k);+ self.ramp(slot, b, -k);+ }+ /// `m` spread as a triangle's measure over its corners' values `q₀ ≤ q₁ ≤ q₂`: rising to+ /// `q₁` and falling to `q₂`.+ fn tent(&mut self, slot: usize, [q0, q1, q2]: [f64; 3], m: f64) {+ if !(q2 > q0) {+ return self.point(slot, q0, m);+ }+ let below = |x: f64| {+ if x <= q0 {+ 0.0+ } else if x >= q2 {+ m+ } else if x <= q1 {+ m * (x - q0) * (x - q0) / ((q2 - q0) * (q1 - q0))+ } else {+ m * (1.0 - (q2 - x) * (q2 - x) / ((q2 - q0) * (q2 - q1)))+ }+ };+ let (Some(j0), Some(j1)) = (self.bin(q0.max(self.lo)), self.bin(q2.min(self.hi))) else { return };+ for j in j0..=j1 {+ let (a, b) = (self.edge(j).max(q0), self.edge(j + 1).min(q2));+ self.add(slot, j, below(b) - below(a));+ }+ }+ fn finish(self, slots: usize) -> Vec<Vec<f64>> {+ (0..slots)+ .map(|s| {+ let (mut slope, mut offset, mut before) = (0.0, 0.0, 0.0);+ (0..=self.n)+ .filter_map(|j| {+ let at = s * (self.n + 2) + j;+ slope += self.slope.get(at).copied().unwrap_or(0.0);+ offset += self.offset.get(at).copied().unwrap_or(0.0);+ let f = slope * self.edge(j) - offset;+ let spread = (j > 0).then_some(f - before);+ before = f;+ spread.map(|d| d + self.direct.get(s * self.n + j - 1).copied().unwrap_or(0.0))+ })+ .collect()+ })+ .collect()+ }+}++/// The kinds of element, each with its elements' points and shares of measure.+fn kinds<'a>(c: &'a PointCloud, g: &'a Geometry) -> [(On, Box<dyn Iterator<Item = (usize, [u32; 3], f64)> + 'a>); 3] {+ let dot = if g.dots.is_empty() { 0.0 } else { 1.0 / g.dots.len() as f64 };+ [+ (On::Point, Box::new(g.dots.iter().map(move |i| (*i as usize, [*i; 3], dot)))),+ (+ On::Segment,+ Box::new(c.complex.segments.0.as_chunks::<2>().0.iter().zip(&g.segments).enumerate().map(|(e, ([a, b], m))| (e, [*a, *b, *b], *m))),+ ),+ (On::Triangle, Box::new(c.complex.triangles.0.as_chunks::<3>().0.iter().zip(&g.triangles).enumerate().map(|(e, (ids, m))| (e, *ids, *m)))),+ ]+}+/// 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(@@ -167,39 +451,68 @@ pub fn histogram(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 mut out = Bins::new(axis, bins, slots);+ let kept: Vec<Kept> = filters.iter().map(Kept::of).collect();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,+ let (mut parts, mut next) = (Vec::new(), Vec::new());+ let mut extent = None;+ for (on, elements) in kinds(c, g) {+ let Some(p) = c.source(property, on) else { continue };+ let filtered: Vec<Option<Source>> = filters.iter().map(|f| c.source(&f.property, on)).collect();+ let coloured = colour.property().and_then(|n| c.source(n, on));+ let start = match on {+ On::Point => Part::Dot,+ On::Segment => Part::Stretch([0.0, 1.0]),+ On::Triangle => Part::Polygon(Polygon::triangle()),};- // 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;+ for (e, ids, m) in elements {+ if m <= 0.0 {+ continue;+ }+ parts.clear();+ parts.push(start);+ for (k, s) in kept.iter().zip(&filtered) {+ // An element without the filtered property is not filtered by it, as in the view.+ let Some(s) = s else { continue };+ let f = corners(*s, e, ids, &g.world);+ next.clear();+ for part in &parts {+ split(part, f, k.cut, |band, q| {+ if k.keeps(band) {+ next.push(q);+ }+ });+ }+ std::mem::swap(&mut parts, &mut next);+ }+ let pv = corners(p, e, ids, &g.world);+ let colour_values = coloured.map(|s| corners(s, e, ids, &g.world));+ for part in &parts {+ // A linear function is least and greatest at a part's corners.+ for v in part_values(part, pv) {+ if v.is_finite() {+ extent = Some(extent.map_or([v, v], |[lo, hi]: [f64; 2]| [lo.min(v), hi.max(v)]));+ }+ }+ match (colour_cut, colour_values) {+ (Some(cut), Some(f)) => split(part, f, cut, |band, q| spread(&mut out, colour.slot(band), &q, pv, m)),+ (Some(_), None) => spread(&mut out, plain, part, pv, m),+ (None, _) => spread(&mut out, 0, part, pv, m),+ }+ }}}- Some(Histogram { bins, slots: out, extent })+ Some(Histogram { bins, slots: out.finish(slots), extent })+}++/// The values a linear function `f` takes at a part's corners.+fn part_values(part: &Part, f: [f64; 3]) -> impl Iterator<Item = f64> + '_ {+ let (ends, corners): (Option<[f64; 2]>, &[[f64; 2]]) = match part {+ Part::Dot => (Some([f[0], f[0]]), &[]),+ Part::Stretch([s0, s1]) => (Some([at(f, [*s0, 0.0]), at(f, [*s1, 0.0])]), &[]),+ Part::Polygon(p) => (None, p.corners()),+ };+ ends.into_iter().flatten().chain(corners.iter().map(move |c| at(f, *c)))}/// A range for a ramp from the values it spans: a single value gets one unit around it.@@ -225,16 +538,50 @@ pub fn color_range_by(c: &PointCloud, extent: impl FnOnce(&str, [f64; 2]) -> Optextent(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.+/// Spread a part's measure (`m`, the whole element's share) over the values `f` takes on it.+fn spread(out: &mut Bins, slot: usize, part: &Part, f: [f64; 3], m: f64) {+ match part {+ Part::Dot => out.point(slot, f[0], m),+ Part::Stretch([s0, s1]) => {+ let (a, b) = (at(f, [*s0, 0.0]), at(f, [*s1, 0.0]));+ out.even(slot, a.min(b), a.max(b), m * (s1 - s0));+ }+ Part::Polygon(p) => {+ let c = p.corners();+ let Some(first) = c.first() else { return };+ for w in c.get(1..).unwrap_or(&[]).windows(2) {+ let [b, d] = [w[0], w[1]];+ // The share of the triangle's area: twice the area in its own coordinates.+ let area = ((b[0] - first[0]) * (d[1] - first[1]) - (b[1] - first[1]) * (d[0] - first[0])).abs();+ let mut q = [at(f, *first), at(f, b), at(f, d)];+ q.sort_by(f64::total_cmp);+ out.tent(slot, q, m * area);+ }+ }+ }+}++/// The values of `property` where the whole-numbered `label` changes, element after element in+/// order of `property` (each element at its smallest value, with its label there), 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();+ let mut at: Vec<(f64, i64)> = Vec::new();+ for (on, elements) in kinds(c, g) {+ let (Some(p), Some(l)) = (c.source(property, on), c.source(label, on)) else { continue };+ let n = match on {+ On::Point => 1,+ On::Segment => 2,+ On::Triangle => 3,+ };+ for (e, ids, _) in elements {+ let (pv, lv) = (corners(p, e, ids, &g.world), corners(l, e, ids, &g.world));+ let lowest = (0..n).min_by(|i, j| pv[*i].total_cmp(&pv[*j])).unwrap_or(0);+ let v = pv[lowest];+ if v.is_finite() {+ let l = lv[lowest];+ at.push((v, if l.is_finite() { l.round() as i64 } else { i64::MIN }));+ }+ }+ }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();diff --git a/crates/doc/src/point_cloud_distribution_tests.rs b/crates/doc/src/point_cloud_distribution_tests.rsindex cee5d00448..522475947c 100644--- a/crates/doc/src/point_cloud_distribution_tests.rs+++ b/crates/doc/src/point_cloud_distribution_tests.rs@@ -2,10 +2,10 @@ use solidcore_record::Vec3;use super::*;use crate::IDENTITY;-use crate::point_cloud::{ColorBy, Colors, Column, Complex, Floats, Points};+use crate::point_cloud::{ColorBy, Colors, Column, Complex, Floats, Indices, Points};-/// A cloud of `points` with `columns` on them.-fn cloud(points: &[[f32; 3]], columns: Vec<Column>) -> PointCloud {+/// A cloud of `points`, with `segments` and `triangles` between them and `columns` on them.+fn cloud(points: &[[f32; 3]], segments: &[u32], triangles: &[u32], columns: Vec<Column>) -> PointCloud {PointCloud {id: 1,name: "c".into(),@@ -21,14 +21,14 @@ fn cloud(points: &[[f32; 3]], columns: Vec<Column>) -> PointCloud {color: None,height_range: None,visible: true,- complex: Complex { columns, names: Vec::new() },+ complex: Complex { segments: Indices(segments.to_vec().into()), triangles: Indices(triangles.to_vec().into()), 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 column(name: &str, on: On, integer: bool, values: &[f32]) -> Column {+ Column { name: name.into(), on, integer, values: Floats(values.to_vec().into()) }}fn range(property: &str, range: [f64; 2]) -> Filter {@@ -39,27 +39,19 @@ 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();+fn a_segment_spreads_its_length_evenly_over_what_a_range_keeps() {+ // t runs 0 to 10 along a segment 10 long.+ let c = cloud(&[[0.0, 0.0, 0.0], [10.0, 0.0, 0.0]], &[0, 1], &[], vec![column("t", On::Point, false, &[0.0, 10.0])]);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 all = histogram(&c, &g, "t", [0.0, 10.0], 10, &Colour::One, &[]).unwrap();+ assert!(close(&all.slots[0], &[0.1; 10]));+ // Kept from t = 2.5 to 5: the part is cut at the iso-values, as the view cuts it.+ let kept = histogram(&c, &g, "t", [0.0, 10.0], 10, &Colour::One, &[range("t", [2.5, 5.0])]).unwrap();+ assert!(close(&kept.slots[0], &[0.0, 0.0, 0.05, 0.1, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0]));+ // Filtered by another property along the same segment: 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());@@ -67,37 +59,82 @@ fn each_point_weighs_alike_and_a_range_keeps_those_within_it() {}#[test]-fn colours_split_what_is_kept() {- // Four points, roles 0, 3, 3 and -1, t from 0 to 3.+fn a_triangle_spreads_its_area_as_a_tent_over_its_corners_values() {+ // t is 0, 1 and 2 at the corners: the measure rises to t = 1 and falls to 2.+ let c = cloud(&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], &[], &[0, 1, 2], vec![column("t", On::Point, false, &[0.0, 1.0, 2.0])]);+ let g = Geometry::of(&c);+ let h = histogram(&c, &g, "t", [0.0, 2.0], 4, &Colour::One, &[]).unwrap();+ // The distribution function: x²/2 up to 1, then 1 − (2 − x)²/2.+ assert!(close(&h.slots[0], &[0.125, 0.375, 0.375, 0.125]));+ // Cut at t ≤ 1: half the area is left, all below 1.+ let half = histogram(&c, &g, "t", [0.0, 2.0], 4, &Colour::One, &[range("t", [0.0, 1.0])]).unwrap();+ assert!(close(&half.slots[0], &[0.125, 0.375, 0.0, 0.0]));+ // Cut by x across t: the part where x ≤ 0.5, its area 3/4 of the triangle's.+ let x = histogram(&c, &g, "t", [0.0, 2.0], 1, &Colour::One, &[range("x", [0.0, 0.5])]).unwrap();+ assert!(close(&x.slots[0], &[0.75]));+}++#[test]+fn kinds_weigh_alike_and_colours_split_what_is_kept() {+ // Two segments, roles 0 and 3, and a dot; t along each segment, the dot at t = 5.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])],+ &[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [4.0, 0.0, 0.0], [9.0, 9.0, 9.0]],+ &[0, 1, 2, 3],+ &[],+ vec![+ column("t", On::Point, false, &[0.0, 1.0, 1.0, 4.0, 5.0]),+ column("role", On::Segment, true, &[0.0, 3.0]),+ column("role", On::Point, true, &[0.0, 0.0, 0.0, 0.0, 2.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();+ let h = histogram(&c, &g, "t", [0.0, 5.0], 5, &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.+ // The segments share their kind's 1 by length (1 and 3), the dot has its kind's 1.+ assert!(close(&h.slots[0], &[0.25, 0.0, 0.0, 0.0, 0.0]));+ assert!(close(&h.slots[3], &[0.0, 0.25, 0.25, 0.25, 0.0]));+ assert!(close(&h.slots[2], &[0.0, 0.0, 0.0, 0.0, 1.0]));+ // A filter by values keeps role 3 only; the dot has a role too and is left out.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 kept = histogram(&c, &g, "t", [0.0, 5.0], 5, &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]));+ assert!((total - 0.75).abs() < 1e-9 && close(&kept.slots[3], &h.slots[3]));+ // A ramp over t in two bands splits the long segment where t crosses 2.5.+ let ramp = Colour::Ramp { property: "t", range: [0.0, 5.0], bands: 2 };+ let r = histogram(&c, &g, "t", [0.0, 5.0], 5, &ramp, &[]).unwrap();+ assert!(close(&r.slots[0], &[0.25, 0.25, 0.125, 0.0, 0.0]) && close(&r.slots[1], &[0.0, 0.0, 0.125, 0.25, 1.0]));}#[test]-fn labels_change_where_the_next_point_has_another() {- // Six points in order of t, layers 0 0 1 1 2 2.+fn a_ramp_of_the_most_bands_keeps_all_of_an_element() {+ // Across every band of the finest ramp the API accepts, nothing is lost: a segment and a+ // triangle, within the ramp and running past both its ends.+ let t = |values: &[f32]| vec![column("t", On::Point, false, values)];+ let ramp = Colour::Ramp { property: "t", range: [0.0, 1.0], bands: MAX_BINS };+ for c in [+ cloud(&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], &[0, 1], &[], t(&[0.0, 1.0])),+ cloud(&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], &[], &[0, 1, 2], t(&[0.0, 1.0, 0.5])),+ cloud(&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], &[0, 1], &[], t(&[-0.5, 1.5])),+ cloud(&[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], &[], &[0, 1, 2], t(&[-0.5, 1.5, 0.5])),+ ] {+ let g = Geometry::of(&c);+ let h = histogram(&c, &g, "t", [-1.0, 2.0], 4, &ramp, &[]).unwrap();+ let total: f64 = h.slots.iter().flatten().sum();+ assert!((total - 1.0).abs() < 1e-9, "{total}");+ }+}++#[test]+fn labels_change_where_the_next_element_has_another() {+ // Five segments in order of t, layers 0 0 1 1 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 c = cloud(+ &points,+ &[0, 1, 1, 2, 2, 3, 3, 4, 4, 5],+ &[],+ vec![column("t", On::Point, false, &[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]), column("layer", On::Segment, true, &[0.0, 0.0, 1.0, 1.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());@@ -105,21 +142,21 @@ fn labels_change_where_the_next_point_has_another() {#[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])]);+ // t runs 0 to 10 along x; filtered by x from 2 to 4, coloured by t: the range is 2 to 4,+ // though no filter is on t (its span within filters on t would be 0 to 10).+ let mut c = cloud(&[[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [20.0, 0.0, 0.0]], &[0, 1], &[], vec![column("t", On::Point, false, &[0.0, 10.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!(c.color_range(), Some([0.0, 10.0]));+ assert_eq!(color_range(&c, &g, &x), Some([2.0, 4.0]));+ // The dot at x = 20 is kept by nothing; by itself it would be 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]));+ assert_eq!(color_range(&c, &g, &[range("x", [50.0, 60.0])]), Some([0.0, 10.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");+ assert_eq!(h.extent, Some([2.0, 4.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 78bfb0283b..9bb560bceb 100644--- a/crates/engine/src/cmd/point_cloud.rs+++ b/crates/engine/src/cmd/point_cloud.rs@@ -15,7 +15,7 @@ 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, 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)"),+ .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 properties can colour and filter it; its edge and face elements become segments and triangles, a segment with width and height properties drawn as a bead) → cloud, name, points, segments, triangles, 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 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"),@@ -24,7 +24,7 @@ pub static COMMANDS: &[CommandSpec] = &[.icon("list").noundo().doc_only()- .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}]"),+ .params("→ clouds: [{cloud, name, file, points, segments, triangles, 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)>> {@@ -205,13 +205,7 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {let center = bool_(p, "center").unwrap_or(false);let bytes = solidcraft_io::vfs::read(path, solidcraft_io::MAX_POINT_CLOUD_BYTES).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;let read = solidcraft_io::read_point_cloud(&bytes, path, scale, max_points).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- let mut warnings = read.warnings;- if solidcraft_io::is_ply_path(path)- && let Ok((_, faces)) = solidcraft_io::ply_counts(&bytes)- && faces > 0- {- warnings.push(format!("the file also has {faces} faces: Insert Mesh (file.insert_mesh) reads it as a mesh"));- }+ let warnings = read.warnings;drop(bytes);let file = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());let stem = std::path::Path::new(path).file_stem().map(|n| n.to_string_lossy().trim().to_string()).filter(|n| !n.is_empty());@@ -252,6 +246,8 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {"cloud": id,"name": name,"points": cloud.len(),+ "segments": cloud.complex.segment_count(),+ "triangles": cloud.complex.triangle_count(),"source_points": cloud.source_points,"bounds": bounds(&cloud),"warnings": warnings,@@ -344,6 +340,8 @@ fn list(s: &mut Session, _: &Value) -> Result<Value> {"visible": c.visible,"point_size": c.point_size,"color_by": c.colored_property().filter(|_| c.color_by == ColorBy::Property).unwrap_or(c.color_by.name()),+ "segments": c.complex.segment_count(),+ "triangles": c.complex.triangle_count(),"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)}))diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex 07ff5a798b..e8883b9c8e 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -20,7 +20,7 @@ use wgpu::util::DeviceExt;mod ao;pub use ao::GroundAo;mod clouds;-pub use clouds::{CloudFilter, CloudStyle, ColorMode, DOT_SIZE, Dot, FILTERS, GpuCloud, cloud_dot};+pub use clouds::{CELL_SIZE, Cell, CloudFilter, CloudStyle, ColorMode, FILTERS, GpuCloud, cloud_cell};#[cfg(not(target_arch = "wasm32"))]mod msaa_check;mod oit;@@ -1035,7 +1035,7 @@ pub struct Frame {pub cap: [f32; 4],/// Canvases and decals.pub images: Vec<GpuImage>,- /// Point clouds.+ /// Point clouds and their cells.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.@@ -5265,19 +5265,30 @@ mod glass_tests {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);- // A dot labelled 2 (red in the palette) and a dot filtered by 5 (a range) and the label- // 2 (a set).+ // A dot (labelled 2, red in the palette) and a bead across the view, 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);+ cloud_cell(&mut dots, &Cell { corners: [[5.0, 5.0, 0.0]; 3], rgb: [0, 0, 255], value: [2.0; 3], has: 16, ..Default::default() });+ let mut segments = Vec::new();+ let ends = [[-3.0, -3.0, 0.0], [3.0, -3.0, 0.0], [3.0, -3.0, 0.0]];+ let bead = Cell {+ corners: ends,+ value: [1.0; 3],+ filtered: [[5.0; 3], [2.0; 3], [0.0; 3], [0.0; 3]],+ size: [0.2, 0.2],+ rgb: [0, 255, 0],+ has: 0b10011,+ ..Default::default()+ };+ cloud_cell(&mut segments, &bead);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 empty = Arc::new(Vec::new());+ frame.clouds.push(GpuCloud { id: 1, version: 1, dots: Arc::new(dots), segments: Arc::new(segments), triangles: empty, 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");+ assert!(has(&own, &|p| p[2] > 200 && p[0] < 30), "the dot in its own colour");+ assert!(has(&own, &green), "the bead 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");@@ -5287,13 +5298,102 @@ mod glass_tests {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");+ assert!(!has(&filtered, &green), "the bead's 5 lies outside the range");+ assert!(has(&filtered, &|p| p[0] > 200 && p[1] < 90 && p[2] < 90), "the dot, without that value, in the palette's red");frame.clouds.clear();let hidden = render_frame(&mut renderer, &device, &queue, &frame, true);assert!(!has(&hidden, &|p| p[0] > 200 && p[1] < 90 && p[2] < 90), "hiding the cloud removes it");}+ /// A set of values keeps the part of a bead where its rounded value is kept, as the range+ /// tracks measure it, whichever end holds the kept value: the first end's value alone does+ /// not decide for the whole bead.+ #[test]+ fn a_set_filter_keeps_the_part_of_a_bead_whose_ends_differ() {+ let Some((_, device, queue)) = crate::open_headless().ok() else { return };+ let depth = crate::depth_format(&device, true);+ let format = wgpu::TextureFormat::Rgba8Unorm;+ let target = GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false };+ let mut renderer = Renderer::new(&device, target, None);+ let mut draw = |version: u64, at_start: f32, at_end: f32, mask: u32| {+ let mut frame = test_frame(GpuScene::default(), 1.0);+ let ends = [[-3.0, -3.0, 0.0], [3.0, -3.0, 0.0], [3.0, -3.0, 0.0]];+ let bead = Cell {+ corners: ends,+ neighbours: [ends[0], ends[1]],+ filtered: [[at_start, at_end, at_end], [0.0; 3], [0.0; 3], [0.0; 3]],+ size: [0.5, 0.5],+ rgb: [0, 255, 0],+ has: 1,+ ..Default::default()+ };+ let mut segments = Vec::new();+ cloud_cell(&mut segments, &bead);+ let mut filters: [CloudFilter; 4] = Default::default();+ filters[0] = CloudFilter::Values { offset: 0, mask };+ let style = CloudStyle { mode: ColorMode::Own, range: [0.0, 1.0], filters, point_size: 1.0 };+ let empty = Arc::new(Vec::new());+ frame.clouds.push(GpuCloud { id: 1, version, dots: empty.clone(), segments: Arc::new(segments), triangles: empty, style });+ let img = render_frame(&mut renderer, &device, &queue, &frame, true);+ // The 64 by 64 picture, split down the middle.+ let side =+ |left: bool| img.as_chunks::<4>().0.iter().enumerate().any(|(i, p)| (i % 64 < 32) == left && p[1] > 60 && p[0] < 30 && p[2] < 30);+ (side(true), side(false))+ };+ assert_eq!(draw(1, 0.0, 1.0, 0b10), (false, true), "1 is kept at the end only: the half towards the end");+ assert_eq!(draw(2, 1.0, 0.0, 0b10), (true, false), "1 is kept at the start only: the half towards the start");+ assert_eq!(draw(3, 0.0, 1.0, 0b11), (true, true), "both kept: the whole bead");+ assert_eq!(draw(4, 0.0, 1.0, 0b100), (false, false), "neither kept: nothing");+ assert_eq!(draw(5, 1.0, 1.0, 0b01), (false, false), "the same value at both ends, not kept: nothing");+ }++ /// A floor and a bead on it, one end far off to the side behind the eye: each is cut exactly at+ /// the near plane. So what lies ahead shows where the perspective puts it, and nothing is+ /// drawn straight below the eye, where an end moved to a made-up place would pull a wedge.+ #[test]+ fn a_cloud_element_crossing_the_near_plane_is_cut_there() {+ let Some((_, device, queue)) = crate::open_headless().ok() else { return };+ let depth = crate::depth_format(&device, true);+ let format = wgpu::TextureFormat::Rgba8Unorm;+ let target = GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false };+ let mut renderer = Renderer::new(&device, target, None);+ // Looking along -z from the origin: a point shows at x/d, y/d at distance d = -z.+ let (near, far) = (0.1f32, 1000.0f32);+ let (a, b) = (-far / (far - near), -far * near / (far - near));+ let view_proj = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, a, -1.0], [0.0, 0.0, b, 0.0]];+ let mut draw = |version: u64, segments: Vec<u8>, triangles: Vec<u8>| {+ let mut frame = test_frame(GpuScene::default(), 1.0);+ frame.view_proj = view_proj;+ let style = CloudStyle { mode: ColorMode::Own, range: [0.0, 1.0], filters: Default::default(), point_size: 1.0 };+ let dots = Arc::new(Vec::new());+ frame.clouds.push(GpuCloud { id: 1, version, dots, segments: Arc::new(segments), triangles: Arc::new(triangles), style });+ render_frame(&mut renderer, &device, &queue, &frame, true)+ };+ // Green at pixel `x` of row `y`, counted from the top of the 64 by 64 picture.+ let green =+ |img: &[u8], x: usize, y: usize| img.get((y * 64 + x) * 4..(y * 64 + x) * 4 + 3).is_some_and(|p| p[1] > 60 && p[0] < 30 && p[2] < 30);+ // Pixel 47 of row 43 is (0.48, -0.36). On y = -1 that is 2.78 away, where the path from+ // (0, -1, -3) to (40, -1, 3) has come to x = 1.47: x/d = 0.53, within the floor (0.18 to+ // 0.87 there) and the bead. Pixel 32 of row 56 is (0.0, -0.77): by that distance both have+ // gone far off to the right.+ let (ahead, below) = ((47, 43), (32, 56));++ let mut triangles = Vec::new();+ let floor = [[-1.0, -1.0, -3.0], [1.0, -1.0, -3.0], [40.0, -1.0, 3.0]];+ cloud_cell(&mut triangles, &Cell { corners: floor, rgb: [0, 255, 0], ..Default::default() });+ let img = draw(1, Vec::new(), triangles);+ assert!(green(&img, ahead.0, ahead.1), "the floor ahead");+ assert!(!green(&img, below.0, below.1), "no wedge of floor below the eye");++ let (start, end) = ([40.0, -1.0, 3.0], [0.0, -1.0, -3.0]);+ let mut segments = Vec::new();+ let bead = Cell { corners: [start, end, end], neighbours: [start, end], size: [0.5, 0.5], rgb: [0, 255, 0], ..Default::default() };+ cloud_cell(&mut segments, &bead);+ let img = draw(2, segments, Vec::new());+ assert!(green(&img, ahead.0, ahead.1), "the bead ahead");+ assert!(!green(&img, below.0, below.1), "no wedge of bead below the eye");+ }+/// A still view shows the picture it drew last: a reused frame (whose filtered picture is/// cached once) draws the same pixels as the frame before it, and changing the camera draws/// again rather than keeping the cached picture.diff --git a/crates/gpu/src/view/clouds.rs b/crates/gpu/src/view/clouds.rsindex 52c0f05a76..e7dd5d8176 100644--- a/crates/gpu/src/view/clouds.rs+++ b/crates/gpu/src/view/clouds.rs@@ -1,8 +1,8 @@-//! 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.+//! Point clouds and the cells between their points: dots, segments drawn as beads (or lines when+//! they have no size), and triangles. Every element is uploaded once, as one record of a single+//! layout whatever its kind; 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;@@ -14,18 +14,21 @@ 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`].+ /// [`CELL_SIZE`] bytes per element, written by [`cloud_cell`]: the points drawn as dots,+ /// the segments and the triangles.pub dots: Arc<Vec<u8>>,+ pub segments: Arc<Vec<u8>>,+ pub triangles: Arc<Vec<u8>>,pub style: CloudStyle,}-/// How a cloud is coloured and which of its points are shown.+/// How a cloud is coloured and which of its elements 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.+ /// An element 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,@@ -46,10 +49,10 @@ pub enum CloudFilter {Values { offset: i32, mask: u32 },}-/// Where a point's colour comes from.+/// Where an element's colour comes from.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]pub enum ColorMode {- /// Its own colour ([`Dot::rgb`]).+ /// Its own colour ([`Cell::rgb`]).#[default]Own,/// The ramp over [`CloudStyle::range`] at its value.@@ -58,32 +61,64 @@ pub enum ColorMode {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`).+/// One element: its corners (a point repeats its own, a segment its second), the coloured value+/// and the four filtered values at each corner, a bead's width and height (zero: a line), its own+/// colour, and which of the four filters and the value it has (bits 0 to 3, and 4, of `has`). A+/// segment also has the points before and after it on its bead (its own ends where it has none),+/// so that two beads meet in the plane halfway between their directions.#[derive(Clone, Copy, Debug, Default, PartialEq)]-pub struct Dot {- pub at: [f32; 3],- pub value: f32,- pub filtered: [f32; FILTERS],+pub struct Cell {+ pub corners: [[f32; 3]; 3],+ pub neighbours: [[f32; 3]; 2],+ pub value: [f32; 3],+ pub filtered: [[f32; 3]; FILTERS],+ pub size: [f32; 2],pub rgb: [u8; 3],pub has: u8,}-/// Bytes per [`Dot`].-pub const DOT_SIZE: usize = 36;+/// Bytes per [`Cell`].+pub const CELL_SIZE: usize = 132;-/// 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) {+/// Append a cell's record.+pub fn cloud_cell(out: &mut Vec<u8>, c: &Cell) {+ let floats = c.corners.iter().flatten().chain(c.neighbours.iter().flatten()).chain(&c.value).chain(c.filtered.iter().flatten()).chain(&c.size);+ for v in floats {out.extend_from_slice(&v.to_le_bytes());}- out.extend_from_slice(&d.rgb);- out.push(d.has);+ out.extend_from_slice(&c.rgb);+ out.push(c.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 }+fn cell_layout() -> wgpu::VertexBufferLayout<'static> {+ const A: [wgpu::VertexAttribute; 12] = wgpu::vertex_attr_array![+ 0 => Float32x3, 1 => Float32x3, 2 => Float32x3, 8 => Float32x3, 9 => Float32x3,+ 3 => Float32x3, 4 => Float32x3, 5 => Float32x3, 10 => Float32x3, 11 => Float32x3,+ 6 => Float32x2, 7 => Unorm8x4+ ];+ wgpu::VertexBufferLayout { array_stride: CELL_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }+}++/// Corners of a bead's cross-section: a stadium, each half-disc in four chords.+const SIDES: u32 = 10;+/// What each pipeline draws: the records of which kind, and vertices per record. A bead's are+/// indexed into its [`SIDES`] corners at each end, so each is worked out once: its sides, then+/// its two ends closed by fans of triangles.+const DRAWS: [(usize, u32); 3] = [(0, 6), (1, SIDES * 6 + 2 * (SIDES - 2) * 3), (2, 3)];++/// The bead as indices into its corners: corner `j` at its start is `j`, at its end `SIDES + j`.+/// Side `q` is the quad between corners `q` and `q + 1` at both ends. The corners turn+/// counter-clockwise seen from ahead, so every triangle turns counter-clockwise seen from+/// outside: the inside faces away and is not drawn.+fn bead_indices() -> Vec<u16> {+ let n = SIDES as u16;+ let sides = (0..n).flat_map(|q| {+ let r = (q + 1) % n;+ [q, r, n + r, q, n + r, n + q]+ });+ let start = (1..n - 1).flat_map(|j| [0, j + 1, j]);+ let end = (1..n - 1).flat_map(move |j| [n, n + j, n + j + 1]);+ sides.chain(start).chain(end).collect()}/// The uniform a cloud's style is written to, bytes: the colouring, then a `vec4` per filter.@@ -111,10 +146,11 @@ fn style_bytes(s: &CloudStyle) -> [u8; STYLE_SIZE as usize] {out}-/// The pipeline that draws clouds' dots, and the layout of their styles.+/// The pipelines that draw clouds: dots, segments and triangles.pub(super) struct CloudPipes {layout: wgpu::BindGroupLayout,- dots: wgpu::RenderPipeline,+ pipes: [wgpu::RenderPipeline; 3],+ bead: wgpu::Buffer,}impl CloudPipes {@@ -139,35 +175,41 @@ impl CloudPipes {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 }+ let pipe = |vs: &str, cull: Option<wgpu::Face>| {+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some(vs),+ layout: Some(&pipeline_layout),+ vertex: wgpu::VertexState { module, entry_point: Some(vs), buffers: &[Some(cell_layout())], compilation_options: Default::default() },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, cull_mode: cull, ..Default::default() },+ depth_stencil: depth.clone(),+ 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,+ })+ };+ let indices: Vec<u8> = bead_indices().iter().flat_map(|i| i.to_le_bytes()).collect();+ let bead = wgpu::util::DeviceExt::create_buffer_init(+ device,+ &wgpu::util::BufferInitDescriptor { label: Some("sc_cloud_bead"), contents: &indices, usage: wgpu::BufferUsages::INDEX },+ );+ CloudPipes {+ pipes: [pipe("vs_cloud_dot", None), pipe("vs_cloud_segment", Some(wgpu::Face::Back)), pipe("vs_cloud_triangle", None)],+ layout,+ bead,+ }}}-/// A cloud on the GPU: its dots and its style's uniform.+/// A cloud on the GPU: its records by kind and its style's uniform.struct Uploaded {version: u64,- dots: Option<Batch>,+ kinds: [Option<Batch>; 3],style: wgpu::Buffer,bind: wgpu::BindGroup,}@@ -193,8 +235,8 @@ impl CloudDraws {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 });+ let kinds = [&c.dots, &c.segments, &c.triangles].map(|bytes| upload(device, "sc_cloud", bytes, CELL_SIZE));+ self.0.insert(c.id, Uploaded { version: c.version, kinds, style, bind });}if let Some(u) = self.0.get(&c.id) {queue.write_buffer(&u.style, 0, &style_bytes(&c.style));@@ -204,13 +246,20 @@ impl CloudDraws {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);+ for (pipe, (kind, vertices)) in pipes.pipes.iter().zip(DRAWS) {+ let Some(Some(batch)) = u.kinds.get(kind) else { continue };+ pass.set_pipeline(pipe);+ for (buffer, count) in &batch.parts {+ pass.set_vertex_buffer(0, buffer.slice(..));+ if kind == 1 {+ pass.set_index_buffer(pipes.bead.slice(..), wgpu::IndexFormat::Uint16);+ pass.draw_indexed(0..vertices, 0, 0..*count);+ } else {+ pass.draw(0..vertices, 0..*count);+ }+ tally.triangles(vertices, *count);+ }}}}diff --git a/crates/io/src/ply.rs b/crates/io/src/ply.rsindex 83990961d6..ca0f55afcb 100644--- a/crates/io/src/ply.rs+++ b/crates/io/src/ply.rs@@ -536,9 +536,9 @@ mod tests {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]);- // Every second vertex.- let (v, _, _) = vertices(&binary(big), 2).unwrap();- assert_eq!(v.iter().map(|v| v.0[1]).collect::<Vec<_>>(), [0.0, 2.5]);+ // A thinned file leaves its face out: it would lose a corner.+ let thin = crate::ply_complex::read_ply_cloud(&binary(big), 2).unwrap();+ assert_eq!((thin.positions.len(), thin.complex.triangle_count(), thin.cells_left_out), (2, 0, 1));let (mesh, warnings) = read_ply_mesh(&binary(big), "Tri").unwrap();assert!(warnings.is_empty());assert_eq!(mesh[0].triangles, [[0, 1, 2]]);@@ -563,6 +563,9 @@ mod tests {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));+ // Points alone are thinned: every second one.+ let (v, _, _) = vertices(points.as_bytes(), 1).unwrap();+ assert_eq!(v, [([1.0, 2.0, 3.0], None)]);assert!(read_ply_mesh(points.as_bytes(), "x").is_err(), "a point cloud is not a mesh");}diff --git a/crates/io/src/ply_complex.rs b/crates/io/src/ply_complex.rsindex ff8c4c290d..6367806481 100644--- a/crates/io/src/ply_complex.rs+++ b/crates/io/src/ply_complex.rs@@ -1,10 +1,12 @@-//! 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.+//! A PLY file read with everything a point cloud can hold: the vertices with all their+//! properties, and the `edge` and `face` elements as segments and triangles (a face as a fan)+//! with theirs. 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.+//! A file whose vertices fit keeps them all, with its edges and faces. One with more keeps every+//! `stride`th vertex and leaves its edges and faces out, since thinning would cut them.-use solidcraft_doc::point_cloud::{Column, Complex, Floats, MAX_COLUMNS, Names};+use solidcraft_doc::point_cloud::{Column, Complex, Floats, Indices, MAX_CELLS, MAX_COLUMNS, Names, On};use crate::ply::{Element, Kind, Rows, Scalar, header};use crate::{IoError, Result};@@ -20,6 +22,10 @@ pub(crate) struct PlyCloud {pub complex: Complex,/// Vertices in the file.pub vertices: u64,+ /// Faces whose indices could not be read.+ pub bad_faces: usize,+ /// Edges and faces in the file, left out because its vertices were thinned.+ pub cells_left_out: u64,}fn integer(s: Scalar) -> bool {@@ -31,78 +37,149 @@ fn named(e: &Element, names: &[&str]) -> Option<usize> {}/// The columns an element's scalar properties fill, leaving out those at `taken`.-fn columns_of(e: &Element, taken: &[usize]) -> Vec<(usize, Column)> {+fn columns_of(e: &Element, on: On, 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::Scalar(s) => Some((i, Column { name: p.name.clone(), on, 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`.+/// An index into `n` vertices, or `None` for anything else.+fn index(v: f64, n: usize) -> Option<u32> {+ (v >= 0.0 && v < n as f64 && v.fract() == 0.0).then(|| u32::try_from(v as u64).ok()).flatten()+}++/// Read a PLY file: every vertex with the edges and faces when they fit in `max_points`, else+/// every `stride`th vertex alone.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 whole = stride == 1;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]) {+ let mut out =+ PlyCloud { positions: Vec::new(), colors: None, complex: Complex::default(), vertices: vertex.count, bad_faces: 0, cells_left_out: 0 };+ let mut columns: Vec<(On, Vec<f32>, Column)> = Vec::new();+ let (mut segments, mut triangles) = (Vec::new(), Vec::new());+ let mut row = vec![0.0f64; e_max(&h.elements)];+ let mut list: Vec<f64> = Vec::new();+ for e in &h.elements {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);+ if !whole && (e.name == "edge" || e.name == "face") {+ out.cells_left_out = out.cells_left_out.saturating_add(e.count);+ }+ let (on, taken, xyz, rgb, ends, face) = match e.name.as_str() {+ "vertex" => {+ let xyz = [named(e, &["x"]), named(e, &["y"]), named(e, &["z"])];+ let [Some(x), Some(y), Some(z)] = xyz else { return Err(invalid("the vertices have no `x`, `y` and `z`")) };+ let rgb =+ [named(e, &["red", "r", "diffuse_red"]), named(e, &["green", "g", "diffuse_green"]), named(e, &["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());+ (Some(On::Point), taken, Some([x, y, z]), rgb, None, None)+ }+ "edge" if whole => {+ let (Some(a), Some(b)) = (named(e, &["vertex1"]), named(e, &["vertex2"])) else {+ return Err(invalid("the edges have no `vertex1` and `vertex2`"));+ };+ (Some(On::Segment), vec![a, b], None, None, Some([a, b]), None)+ }+ "face" if whole => {+ let face = e+ .properties+ .iter()+ .position(|p| matches!(p.name.as_str(), "vertex_indices" | "vertex_index") && matches!(p.kind, Kind::List(..)));+ (face.map(|_| On::Triangle), Vec::new(), None, None, None, face)+ }+ _ => (None, Vec::new(), None, None, None, None),+ };+ let mine: Vec<(usize, Column)> = on.map(|on| columns_of(e, on, &taken)).unwrap_or_default();+ if columns.len() + mine.len() > MAX_COLUMNS {+ return Err(invalid(format!("more than {MAX_COLUMNS} properties")));+ }+ let first = columns.len();+ let slots: Vec<usize> = mine.iter().map(|(i, _)| *i).collect();+ columns.extend(mine.into_iter().map(|(_, c)| (c.on, Vec::new(), c)));+ if rgb.is_some() {+ out.colors = Some(Vec::new());+ }for r in 0..e.count {+ list.clear();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) {+ if let Some(s) = row.get_mut(i) {*s = v;}}Kind::List(c, t) => {- for _ in 0..rows.count(c)? {- rows.value(t)?;+ let n = rows.count(c)?;+ for _ in 0..n {+ let v = rows.value(t)?;+ if face == Some(i) {+ list.push(v);+ }}}}}- 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));+ // How many elements this row stands for: a vertex kept, a segment, a fan's triangles.+ let copies = if let Some([x, y, z]) = xyz {+ if !r.is_multiple_of(stride) {+ continue;+ }+ 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 e.properties.get(i).map(|p| p.kind) {+ Some(Kind::Scalar(s)) => s.channel(v(i)),+ _ => 0,+ };+ c.push(ks.map(t));+ }+ 1+ } else if let Some([a, b]) = ends {+ let n = vertex.count as usize;+ let (Some(a), Some(b)) = (index(v(a), n), index(v(b), n)) else { return Err(invalid("an edge names a missing vertex")) };+ segments.extend([a, b]);+ 1+ } else if face.is_some() {+ let n = vertex.count as usize;+ match list.iter().map(|x| index(*x, n)).collect::<Option<Vec<u32>>>() {+ Some(p) if p.len() >= 3 => {+ for k in 1..p.len() - 1 {+ triangles.extend([p[0], p[k], p[k + 1]]);+ }+ p.len() - 2+ }+ _ => {+ out.bad_faces += 1;+ 0+ }+ }+ } else {+ 0+ };+ for (k, slot) in slots.iter().enumerate() {+ if let Some((_, values, _)) = columns.get_mut(first + k) {+ values.extend(std::iter::repeat_n(v(*slot) as f32, copies));+ }}- for (slot, values, _) in &mut columns {- values.push(v(*slot) as f32);+ if segments.len() / 2 > MAX_CELLS || triangles.len() / 3 > MAX_CELLS {+ return Err(invalid(format!("more than {MAX_CELLS} edges or triangles")));}}}@@ -110,38 +187,51 @@ pub(crate) fn read_ply_cloud(bytes: &[u8], max_points: usize) -> Result<PlyCloud// 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);+ let label = columns.iter().any(|c| c.name == n.property) && columns.iter().filter(|c| c.name == n.property).all(|c| c.integer);if label && !names.iter().any(|m| m.property == n.property) && names.len() < MAX_COLUMNS {names.push(n);}}- out.complex = Complex { columns, names };+ out.complex = Complex { segments: Indices(segments.into()), triangles: Indices(triangles.into()), columns, names };Ok(out)}+/// The most properties of any element: the row buffer's length.+fn e_max(elements: &[Element]) -> usize {+ elements.iter().map(|e| e.properties.len()).max().unwrap_or(0)+}+#[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";+ fn edges_faces_and_every_property_are_kept() {+ let text = "ply\nformat ascii 1.0\ncomment role: 7 wall, -1 none\ncomment t: seconds since the start\ncomment width: 0 thin\nelement vertex 4\nproperty float x\nproperty float y\nproperty float z\nproperty double t\n\+ element edge 2\nproperty int vertex1\nproperty int vertex2\nproperty int role\nproperty double width\n\+ element face 1\nproperty list uchar int vertex_indices\nproperty int layer\nend_header\n\+ 0 0 0 0.5\n1 0 0 1.5\n1 1 0 2.5\n0 1 0 3.5\n0 1 7 0.42\n1 2 -1 0\n4 0 1 2 3 9\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]);+ assert_eq!(&*r.complex.segments.0, &[0, 1, 1, 2]);+ assert_eq!(&*r.complex.triangles.0, &[0, 1, 2, 0, 2, 3], "a quad is a fan of two");+ let col = |n: &str, on| r.complex.column(n, on).unwrap();+ assert_eq!(&*col("t", On::Point).values.0, &[0.5, 1.5, 2.5, 3.5]);+ assert!(col("role", On::Segment).integer && !col("width", On::Segment).integer);+ assert_eq!(&*col("role", On::Segment).values.0, &[7.0, -1.0]);+ assert_eq!(&*col("layer", On::Triangle).values.0, &[9.0, 9.0], "each triangle of the fan has the face's");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();+ // Too many vertices: thinned, with the edges and faces that thinning would cut left out.+ let thin = read_ply_cloud(text.as_bytes(), 3).unwrap();+ assert_eq!((thin.positions.len(), thin.cells_left_out), (2, 3));+ assert!(thin.complex.segments.0.is_empty() && thin.complex.triangles.0.is_empty());+ assert_eq!(&*thin.complex.column("t", On::Point).unwrap().values.0, &[0.5, 2.5]);+ assert!(thin.complex.column("role", On::Segment).is_none());+ thin.complex.check(2).unwrap();+ let bad = text.replace("1 2 -1 0", "1 9 -1 0");+ assert!(read_ply_cloud(bad.as_bytes(), 10).is_err(), "an edge to a missing vertex");}}diff --git a/crates/io/src/point_cloud.rs b/crates/io/src/point_cloud.rsindex 0e6e922c4e..b03db8df81 100644--- a/crates/io/src/point_cloud.rs+++ b/crates/io/src/point_cloud.rs@@ -34,7 +34,7 @@ pub struct CloudFile {pub colors: Vec<u8>,/// Points in the file.pub source_points: u64,- /// The file's other properties of the points (PLY).+ /// Segments, triangles and the file's other properties (PLY).pub complex: solidcraft_doc::point_cloud::Complex,pub warnings: Vec<String>,}@@ -91,15 +91,25 @@ pub fn read_point_cloud(bytes: &[u8], file: &str, scale: f64, max_points: usize)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();+ let mut read = Vec::with_capacity(r.positions.len());for (i, p) in r.positions.iter().enumerate() {+ let bad = keep.bad;keep.push(*p, colors.get(i).copied());+ read.push(keep.bad == bad);}- // 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)));+ // A point left out takes with it its numbers and whatever ends on it.+ let (complex, cut) = if keep.bad > 0 { r.complex.induced(&read) } else { (r.complex, 0) };+ if cut > 0 {+ keep.out.warnings.push(format!("{cut} segment(s) and triangle(s) left out, since a point they end on could not be read"));+ }+ if r.bad_faces > 0 {+ keep.out.warnings.push(format!("{} face(s) could not be read and were left out", r.bad_faces));+ }+ if r.cells_left_out > 0 {+ keep.out.warnings.push(format!("{} edge(s) and face(s) left out, since thinning the points would cut them", r.cells_left_out));}keep.out.source_points = r.vertices;- keep.out.complex = r.complex;+ keep.out.complex = complex;} else {stride = read_xyz(bytes, &mut keep)?;}@@ -191,6 +201,8 @@ fn read_xyz(bytes: &[u8], keep: &mut Keep) -> Result<u64> {#[cfg(test)]mod tests {+ use solidcraft_doc::point_cloud::On;+use super::*;fn ply_points(n: usize) -> Vec<u8> {@@ -215,11 +227,43 @@ mod tests {assert_eq!(&c.points[3..6], &[2000.0, 0.0, 0.0]);assert!(c.colors.is_empty());assert_eq!(c.warnings.len(), 1, "{:?}", c.warnings);+ // A thinned file leaves out the edges thinning would cut, and says so.+ let edged = "ply\nformat ascii 1.0\nelement vertex 4\nproperty float x\nproperty float y\nproperty float z\n\+ element edge 2\nproperty int vertex1\nproperty int vertex2\nend_header\n0 0 0\n1 0 0\n2 0 0\n3 0 0\n0 1\n2 3\n";+ let e = read_point_cloud(edged.as_bytes(), "path.ply", 1.0, 2).unwrap();+ assert_eq!((e.points.len(), e.complex.segment_count()), (6, 0));+ assert!(e.warnings.iter().any(|w| w.starts_with("2 edge(s) and face(s) left out")), "{:?}", e.warnings);let all = read_point_cloud(&ply_points(10), "scan.PLY", 1.0, DEFAULT_MAX_POINTS).unwrap();assert_eq!((all.points.len(), all.warnings.len()), (30, 0));assert!(read_point_cloud(&ply_points(10), "scan.ply", 0.0, 5).is_err());}+ #[test]+ fn a_point_that_cannot_be_read_takes_only_what_ends_on_it() {+ let text = "ply\nformat ascii 1.0\ncomment role: 7 wall\nelement vertex 5\nproperty float x\nproperty float y\nproperty float z\nproperty float t\n\+ element edge 3\nproperty int vertex1\nproperty int vertex2\nproperty int role\n\+ element face 2\nproperty list uchar int vertex_indices\nproperty int layer\nend_header\n\+ 0 0 0 10\nnan 0 0 11\n2 0 0 12\n3 0 0 13\n4 0 0 14\n0 1 7\n2 3 8\n3 4 9\n3 0 2 3 5\n3 1 2 3 6\n";+ let c = read_point_cloud(text.as_bytes(), "path.ply", 1.0, DEFAULT_MAX_POINTS).unwrap();+ assert_eq!(c.points, [0., 0., 0., 2., 0., 0., 3., 0., 0., 4., 0., 0.]);+ assert_eq!(&*c.complex.segments.0, &[1, 2, 2, 3], "numbered among the points that are left");+ assert_eq!(&*c.complex.triangles.0, &[0, 1, 2]);+ assert_eq!(&*c.complex.column("t", On::Point).unwrap().values.0, &[10., 12., 13., 14.]);+ assert_eq!(&*c.complex.column("role", On::Segment).unwrap().values.0, &[8., 9.]);+ assert_eq!(&*c.complex.column("layer", On::Triangle).unwrap().values.0, &[5.]);+ assert_eq!(c.complex.names("role").and_then(|n| n.name(7)), Some("wall"));+ c.complex.check(4).unwrap();+ assert_eq!(+ c.warnings,+ ["2 segment(s) and triangle(s) left out, since a point they end on could not be read", "1 point(s) could not be read and were left out"]+ );+ // Edges alone, no numbers on the points: the same, not a refused file.+ let edged = "ply\nformat ascii 1.0\nelement vertex 3\nproperty float x\nproperty float y\nproperty float z\n\+ element edge 2\nproperty int vertex1\nproperty int vertex2\nend_header\nnan 0 0\n1 0 0\n2 0 0\n0 1\n1 2\n";+ let e = read_point_cloud(edged.as_bytes(), "path.ply", 1.0, DEFAULT_MAX_POINTS).unwrap();+ assert_eq!((e.points.len(), &*e.complex.segments.0), (6, &[0u32, 1][..]));+ }+#[test]fn xyz_and_pts_text() {let xyz = "# x y z r g b\n1 2 3 255 0 0\n4,5,6,0,255,0\n\n7\t8\t9\t0\t0\t255\nnot a point\n";diff --git a/crates/ui-egui/src/browser/point_cloud_tracks.rs b/crates/ui-egui/src/browser/point_cloud_tracks.rsindex 04e32694ce..d9bb5aab6b 100644--- a/crates/ui-egui/src/browser/point_cloud_tracks.rs+++ b/crates/ui-egui/src/browser/point_cloud_tracks.rs@@ -51,11 +51,18 @@ pub(crate) struct Answer {pub extent: Option<[f64; 2]>,}-/// The cloud's data as far as the tracks are concerned: its points, columns and placement.+/// The cloud's data as far as the tracks are concerned: its points, cells, 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()];+ let mut k = vec![+ Arc::as_ptr(c.points.values()).cast::<f32>() as u64,+ Arc::as_ptr(&c.complex.segments.0).cast::<u32>() as u64,+ Arc::as_ptr(&c.complex.triangles.0).cast::<u32>() 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()));kdiff --git a/crates/ui-egui/src/browser/point_clouds.rs b/crates/ui-egui/src/browser/point_clouds.rsindex 294798e403..19e80a2116 100644--- a/crates/ui-egui/src/browser/point_clouds.rs+++ b/crates/ui-egui/src/browser/point_clouds.rs@@ -1,10 +1,10 @@//! 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 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.+//! and the Edit Point Cloud card: the file's units, the size of the dots (when some points are+//! 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::{COORDINATES, ColorBy, Filter, Keep, MAX_FILTERS, Names, PLAIN, PointCloud, UNITS, byte, label_color};@@ -26,12 +26,14 @@ use range_track::{Part, Track, range_track};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.+/// for the cloud's data (the automatic height range, the number of dots), 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]>)>,+ dots: Option<([usize; 3], usize)>,tracks: Tracks,pub play: Option<Play>,}@@ -94,7 +96,7 @@ impl Play {impl CloudPanel {pub fn new(app: &SolveApp, cloud: u64) -> Self {- CloudPanel { cloud, depth: app.session.undo.len(), auto: None, tracks: Tracks::default(), play: None }+ CloudPanel { cloud, depth: app.session.undo.len(), auto: None, dots: None, tracks: Tracks::default(), play: None }}/// The cloud's automatic height range, worked out again only when its points or placement/// change.@@ -109,6 +111,22 @@ impl CloudPanel {}}}+ /// How many points are drawn as dots, worked out again only when the cloud's data change.+ fn dots(&mut self, c: &PointCloud) -> usize {+ let key = [+ std::sync::Arc::as_ptr(c.points.values()).cast::<f32>() as usize,+ std::sync::Arc::as_ptr(&c.complex.segments.0).cast::<u32>() as usize,+ std::sync::Arc::as_ptr(&c.complex.triangles.0).cast::<u32>() as usize,+ ];+ match self.dots {+ Some((k, n)) if k == key => n,+ _ => {+ let n = c.isolated_points();+ self.dots = Some((key, n));+ n+ }+ }+ }/// 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)@@ -247,6 +265,7 @@ 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 auto = if c.color_by == ColorBy::Height { m.auto_range(&c) } else { None };+ let dots = m.dots(&c);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;@@ -276,9 +295,17 @@ 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 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 }));+ // The dots' size, where some points are dots: those no segment or triangle ends on.+ if dots > 0 {+ if dots < c.len() {+ ui_kit::row(ui, crate::i18n::tr_label("Dots"), |ui| ui.label(dots.to_string()));+ }+ 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);@@ -567,15 +594,18 @@ mod tests {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 {+ /// A PLY file of ten segments along x, `t` running 0 to 10 along them and two segments to a+ /// layer: the layer changes at t = 2, 4, 6 and 8.+ fn layered_segments(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",+ "ply\nformat ascii 1.0\nelement vertex 11\nproperty float x\nproperty float y\nproperty float z\nproperty float t\n\+ element edge 10\nproperty int vertex1\nproperty int vertex2\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));+ for i in 0..=10 {+ ply += &format!("{i} 0 0 {i}\n");+ }+ for i in 0..10 {+ ply += &format!("{i} {} {}\n", i + 1, i / 2);}let path = dir.join("layers.ply");std::fs::write(&path, ply).unwrap();@@ -588,7 +618,7 @@ mod tests {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 path = layered_segments(&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));diff --git a/crates/ui-egui/src/point_clouds.rs b/crates/ui-egui/src/point_clouds.rsindex 0b6f21a0ad..b13c162ed0 100644--- a/crates/ui-egui/src/point_clouds.rs+++ b/crates/ui-egui/src/point_clouds.rs@@ -1,6 +1,6 @@-//! 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.+//! Point clouds (#5151): with the GPU viewport their points, segments and triangles are drawn in+//! the 3D pass (depth-tested with the model), coloured and filtered by the shaders; the CPU+//! viewport draws some of their points over its image.use std::cell::RefCell;use std::collections::HashMap;@@ -8,9 +8,9 @@ use std::sync::Arc;use egui::{Painter, Shape};use solidcraft_engine::doc::point_cloud::Keep;-use solidcraft_engine::doc::point_cloud::{ColorBy, PLAIN, PointCloud, Source, byte};+use solidcraft_engine::doc::point_cloud::{ColorBy, On, 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 solidcraft_gpu::view::{Cell, CloudFilter, CloudStyle, ColorMode, FILTERS, GpuCloud, cloud_cell};use crate::SolveApp;use crate::browser::point_cloud_tracks::{Ask, Paint, Tracks};@@ -35,7 +35,12 @@ struct Key {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];+ let mut data = vec![+ Arc::as_ptr(c.points.values()).cast::<f32>() as usize,+ Arc::as_ptr(&c.colors.0).cast::<u8>() as usize,+ Arc::as_ptr(&c.complex.segments.0).cast::<u32>() as usize,+ Arc::as_ptr(&c.complex.triangles.0).cast::<u32>() as usize,+ ];data.extend(c.complex.columns.iter().map(|k| Arc::as_ptr(&k.values.0).cast::<f32>() as usize));Key {data,@@ -50,9 +55,12 @@ impl Key {}}+/// Records of a cloud's dots, segments and triangles.+type Records = [Arc<Vec<u8>>; 3];+thread_local! {/// 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 RECORDS: RefCell<HashMap<u64, (Key, u64, Records)>> = 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).@@ -77,45 +85,107 @@ pub(crate) fn color_range(ctx: &egui::Context, c: &PointCloud) -> Option<[f64; 2})}-fn records(c: &PointCloud) -> Arc<Vec<u8>> {+fn records(c: &PointCloud) -> Records {+ let world: Vec<[f32; 3]> = (0..c.len())+ .map(|i| {+ // Placed in double precision: the cloud's origin may be far from the design's.+ let w = c.world_point(i).unwrap_or_default();+ [w.x as f32, w.y as f32, w.z as f32]+ })+ .collect();let plain = PLAIN.map(byte);let single = c.color.unwrap_or(PLAIN).map(byte);- let own = |i: usize| match c.color_by {+ let own = |i: u32| match c.color_by {ColorBy::Single => single,- ColorBy::File => c.colors.get(i).unwrap_or(plain),+ ColorBy::File => c.colors.get(i as usize).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 w = c.world_point(i).unwrap_or_default();- let at = [w.x as f32, w.y as f32, w.z as f32];+ let names: [Option<&str>; 1 + FILTERS] =+ std::array::from_fn(|k| if k == 0 { c.colored_property() } else { c.filters.get(k - 1).map(|f| f.property.as_str()) });+ let complex = &c.complex;+ let width = complex.column("width", On::Segment).map(|k| &k.values.0[..]);+ let height = complex.column("height", On::Segment).map(|k| &k.values.0[..]);+ let mut out: [Vec<u8>; 3] = Default::default();+ let mut used = vec![false; c.len()];+ // Each point's one segment in and one segment out, when it has exactly one of each: a bead+ // runs through it, and its two segments meet there mitred.+ let (mut into, mut out_of) = (vec![None; c.len()], vec![None; c.len()]);+ for ends in complex.segments.0.as_chunks::<2>().0 {+ let [a, b] = ends.map(|i| i as usize);+ if let Some(slot) = out_of.get_mut(a) {+ *slot = if slot.is_none() { Some(Some(b)) } else { Some(None) };+ }+ if let Some(slot) = into.get_mut(b) {+ *slot = if slot.is_none() { Some(Some(a)) } else { Some(None) };+ }+ }+ let through = |links: &[Option<Option<usize>>], at: u32| links.get(at as usize).copied().flatten().flatten().and_then(|k| world.get(k).copied());+ for (kind, on, n) in [(1usize, On::Segment, 2usize), (2, On::Triangle, 3)] {+ let indices = if n == 2 { &complex.segments.0 } else { &complex.triangles.0 };+ let sources = names.map(|name| name.and_then(|n| c.source(n, on)));+ for (e, ids) in indices.chunks_exact(n).enumerate() {+ let at = |k: usize| ids.get(k.min(n - 1)).copied().unwrap_or(0);+ let corners = [at(0), at(1), at(2)];+ for i in corners {+ if let Some(u) = used.get_mut(i as usize) {+ *u = true;+ }+ }+ let mut cell =+ Cell { corners: corners.map(|i| world.get(i as usize).copied().unwrap_or_default()), rgb: own(corners[0]), ..Default::default() };+ let values = sources.map(|s| {+ s.map(|s| match s {+ Source::Coordinate(k) => cell.corners.map(|p| p[k]),+ Source::Corners(v) => corners.map(|i| v.get(i as usize).copied().unwrap_or(0.0)),+ Source::Element(v) => [v.get(e).copied().unwrap_or(0.0); 3],+ })+ });+ if on == On::Segment {+ let [a, b] = [corners[0], corners[1]];+ // The point before `a` only when `a` is passed through, not where beads branch.+ let joined = |at: u32| matches!((into.get(at as usize), out_of.get(at as usize)), (Some(Some(Some(_))), Some(Some(Some(_)))));+ let before = through(&into, a).filter(|_| joined(a));+ let after = through(&out_of, b).filter(|_| joined(b));+ cell.neighbours = [before.unwrap_or(cell.corners[0]), after.unwrap_or(cell.corners[1])];+ cell.size = [width.and_then(|w| w.get(e)).copied().unwrap_or(0.0), height.and_then(|h| h.get(e)).copied().unwrap_or(0.0)];+ }+ fill(&mut cell, values);+ cloud_cell(&mut out[kind], &cell);+ }+ }+ // The points drawn as dots: those no segment or triangle ends on.+ let sources = names.map(|name| name.and_then(|n| c.source(n, On::Point)));+ for (i, p) in world.iter().enumerate() {+ if used.get(i).copied().unwrap_or(false) {+ continue;+ }+ let mut cell = Cell { corners: [*p; 3], rgb: own(i as u32), ..Default::default() };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),+ Source::Coordinate(k) => [p[k]; 3],+ Source::Corners(v) | Source::Element(v) => [v.get(i).copied().unwrap_or(0.0); 3],})});- 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;- }+ fill(&mut cell, values);+ cloud_cell(&mut out[0], &cell);+ }+ out.map(Arc::new)+}++/// The coloured value and the filtered values of a cell, where it has them.+fn fill(cell: &mut Cell, values: [Option<[f32; 3]>; 1 + FILTERS]) {+ let [value, filtered @ ..] = values;+ if let Some(v) = value {+ cell.value = v;+ cell.has |= 1 << FILTERS;+ }+ for (k, f) in filtered.into_iter().enumerate() {+ if let Some(f) = f {+ cell.filtered[k] = f;+ cell.has |= 1 << k;}- cloud_dot(&mut out, &dot);}- Arc::new(out)}/// The cloud as it is drawn now: a filter `playing` in the Edit Point Cloud card at its range@@ -172,7 +242,7 @@ pub fn gpu_clouds(app: &SolveApp, ctx: &egui::Context) -> Vec<GpuCloud> {solidcraft_engine::view::shown_point_clouds(&app.session).map(|c| {let key = Key::of(c);- let (version, dots) = match m.get(&c.id) {+ let (version, [dots, segments, triangles]) = match m.get(&c.id) {Some((k, version, records)) if *k == key => (*version, records.clone()),_ => {let version = VERSION.with(|v| {@@ -185,7 +255,7 @@ pub fn gpu_clouds(app: &SolveApp, ctx: &egui::Context) -> Vec<GpuCloud> {}};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) }+ GpuCloud { id: c.id, version, dots, segments, triangles, style: style(ctx, c, playing) }}).collect()})@@ -234,8 +304,8 @@ mod tests {assert!(crate::browser::is_open(&h.app, "point_clouds", true));let first = gpu_clouds(&h.app, &h.ctx);assert_eq!(first.len(), 1);- let size = solidcraft_gpu::view::DOT_SIZE;- assert_eq!(first[0].dots.len(), 2 * size);+ let size = solidcraft_gpu::view::CELL_SIZE;+ assert_eq!((first[0].dots.len(), first[0].segments.len()), (2 * size, 0));// 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]);@@ -270,13 +340,9 @@ mod tests {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");- }+ // One segment, x and t both running 0 to 10 along it.+ let ply = "ply\nformat ascii 1.0\nelement vertex 2\nproperty float x\nproperty float y\nproperty float z\nproperty float t\n\+ element edge 1\nproperty int vertex1\nproperty int vertex2\nend_header\n0 0 0 0\n10 0 0 10\n0 1\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.diff --git a/docs/point-clouds.md b/docs/point-clouds.mdindex 7f0600c804..42768d86c6 100644--- a/docs/point-clouds.md+++ b/docs/point-clouds.md@@ -9,11 +9,11 @@ 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). 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. |+| `.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. The `edge` element (`vertex1`, `vertex2`) and the `face` element (`vertex_indices`, a face as a fan of triangles) become segments and triangles between the points, with their own properties. 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**-(`file.insert_mesh`); **Insert Point Cloud** then mentions it in its warnings.+A PLY file with faces can also be inserted as a mesh body with **Insert Mesh**+(`file.insert_mesh`), which makes it solid geometry rather than a reference.Point cloud files say nothing about their length unit. `units` (`mm`, `cm`, `m`, `in`, `ft`)says what it is; the default is millimetres, as for every other import. Lidar and SLAM maps are@@ -42,6 +42,21 @@ A whole-numbered property may name its values with a PLY comment, `property: 0 nname, -1 none` (for example `comment role: 0 outer wall, 1 inner wall`). Coloured by it, thecard shows a legend, a swatch and a name per value; clicking a name shows or hides that value.+## Edges and faces++A cloud read from a PLY file with edges or faces draws them between its points: triangles+filled, segments as lines or, when they have `width` and `height` properties, as beads of that+stadium cross-section (a tube when the two are equal), meeting mitred where one runs into the+next. Points no segment or triangle ends on stay dots, of the cloud's point size. A point that+can't be read (not a finite number, or out of range) is left out with a warning, and so are the+segments and triangles that end on it.++A property on the points varies along the segments and across the triangles that meet there;+one on the segments or triangles is constant on each. Colours follow the same rule, and a range+filter cuts an element exactly where its value crosses an end of the range, so a filter on a+time property replays a path as it was drawn. A range track weighs each element by its measure,+each kind over its own total: a dot counts 1, a segment its length, a triangle its area.+## FiltersA filter keeps the points whose property lies in a range (both ends included) or, for a@@ -76,7 +91,9 @@ it shows the property's whole span, with the part the track shows framed.## SizeA cloud keeps at most `max_points` points (5,000,000 unless asked, at most 20,000,000); a larger-file is thinned evenly, one point in *n*, and the result says how many were kept. Files up to+file is thinned evenly, one point in *n*, and the result says how many were kept. Thinning would+cut a file's edges and faces, so a thinned file leaves them out, with a warning; raise `max_points`+to keep them. A cloud holds at most 20,000,000 segments and as many triangles. Files up to1 GiB are read. The points are stored single precision relative to the cloud's first point (keptdouble precision), so a scan far from the origin keeps its detail; they travel inside the designfile as a binary part (12 bytes a point, 3 more with colours).@@ -93,7 +110,7 @@ file as a binary part (12 bytes a point, 3 more with colours).`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+- `pointcloud.list` — each cloud with its segment and triangle counts, its properties (name, whole-numbered or not, span, namedvalues), 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.diff --git a/xtask/src/mesh_decisions.rs b/xtask/src/mesh_decisions.rsindex 123e7334bc..ee45c6729a 100644--- a/xtask/src/mesh_decisions.rs+++ b/xtask/src/mesh_decisions.rs@@ -32,10 +32,14 @@ pub const CRATES: &[&str] = &["crates/doc", "crates/engine", "crates/kernel"];const MODEL_BODY_CRATES: &[&str] = &["crates/doc", "crates/engine"];/// Modules (a file, or a directory with everything below it) whose job is display, export,-/// previews or mesh bodies: their mesh use is what a mesh is for.+/// previews or mesh bodies: their mesh use is what a mesh is for. Or that hold no mesh at all,+/// only a field the check's syntactic pattern takes for one.pub const SKIPPED_MODULES: &[(&str, &str)] = &[("crates/doc/src/display_quality.rs", "the viewport's display quality levels"),("crates/doc/src/placed_mesh.rs", "the display meshes and plans of bodies and placed parts"),+ ("crates/doc/src/point_cloud.rs", "no mesh: the triangles of a point cloud's own complex"),+ ("crates/doc/src/point_cloud_complex.rs", "no mesh: the triangles of a point cloud's own complex"),+ ("crates/doc/src/point_cloud_distribution.rs", "no mesh: the triangles of a point cloud's own complex"),("crates/engine/src/cmd/file_thumbnail.rs", "a design's thumbnail picture"),("crates/engine/src/cmd/mesh.rs", "mesh bodies: repair, decimate and inspect imported meshes"),("crates/engine/src/cmd/render", "rendered pictures"),