Files
solidcraft/crates/doc/src/point_cloud.rs
T
e6dc105134 Point clouds: insert PLY, XYZ and PTS scans as a modelling reference (#5151) (#5381)
* Point clouds: insert PLY, XYZ and PTS scans as a modelling reference (#5151)

A point cloud is kept in the design as a reference, drawn as depth-tested
dots and never a body.

- io: a PLY reader (ASCII, binary little/big endian; x, y, z of any numeric
  type, optional colours, other elements skipped; counts checked against the
  file) and XYZ/PTS text, thinned evenly past max_points. PLY meshes with
  faces can also come in through file.insert_mesh.
- doc: Document.point_clouds (shared f32 points relative to an f64 origin,
  colours, units, rigid placement, size and colour), stored as a binary
  container part; format change in pending/point-clouds.rs.
- engine: pointcloud.insert / edit / delete / list; doc.open opens a cloud as
  a new design; selection.delete takes point_clouds; view bounds include them.
- gpu: an instanced point-sprite pipeline (16 bytes a point).
- ui: Browser Point Clouds folder with eyes, menu and an Edit Point Cloud
  card; drop, Open, Insert and file dialogs take .ply/.xyz/.pts; a CPU
  viewport fallback; messages in en, en-GB, ja, zh, de and ko.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Point clouds: colour by the file, one colour or height, from the UI (#5151)

The Edit Point Cloud card gets Color By (File Colors, Single Color,
Height). Height is a blue-to-red ramp over design Z, between the cloud's
own two heights or, by default, a range worked out from the points (all
but the lowest and highest 2 %, from an even sample). pointcloud.insert
and pointcloud.edit take color_by and height_range; pointcloud.list
reports them. The colour of each point is worked out in one place
(PointCloud::shade) for the GPU and CPU viewports.

Also: the card's dropdowns compare the picked index (a dropdown's
response doesn't report the pick, so File Units did not change either).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Point clouds: integrate format registration and viewport caches (#5151)

* Point clouds: satisfy current UI audits and document comparisons (#5151)

Route model RGB data through the theme conversion boundary, provide a compact ribbon label, and include point clouds in the new document comparison. Gate the Unix-only CLI-link helper and test so Windows all-target checks remain buildable after the rebase.

* Point clouds: isolate translations for current main (#5151)

Move the existing 74 messages unchanged into one pending locale file and attribute it through a pending row, following the current repository workflow. Repository checks, 50 tooling tests, final workspace Clippy, wasm and generated-catalog equality checks passed after the rebase.

* Point clouds: fit the rebased code to main's GpuTarget and Frame

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Compare point clouds when reusing placement-independent results

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Point clouds: complete command help and required translations (#5151)

* Point clouds: size the save cap from the raised limit after the rebase

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
2026-10-28 21:17:02 +00:00

502 lines
20 KiB
Rust

//! Point clouds: scanned points (a PLY or XYZ file) kept in the design as a reference to model
//! from (#5151). They are not bodies: nothing is built from them, they are drawn as points.
//! The points travel inside the design file (a binary part of the container, base64 in plain
//! JSON), so it reopens without the original file. They are single precision, relative to the
//! cloud's own `origin` (double precision), so a scan far from the design's origin keeps its
//! detail.
use std::sync::Arc;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use solidcraft_geom::Vec3;
use crate::canvas::{base64_decode, base64_encode};
use crate::{DocError, IDENTITY, Mat, Result};
/// Most points one cloud may hold.
pub const MAX_POINTS: usize = 20_000_000;
/// Largest point coordinate (mm) from the cloud's origin, and largest origin coordinate.
pub const MAX_COORD: f64 = 1e9;
/// Point sizes on screen (pixels).
pub const POINT_SIZE: std::ops::RangeInclusive<f64> = 0.5..=16.0;
/// Length units a point cloud file may be in, and millimetres per unit.
pub const UNITS: [(&str, f64); 5] = [("mm", 1.0), ("cm", 10.0), ("m", 1000.0), ("in", 25.4), ("ft", 304.8)];
/// Millimetres per `unit` (one of [`UNITS`], any case).
pub fn unit_scale(unit: &str) -> Option<f64> {
UNITS.iter().find(|(u, _)| u.eq_ignore_ascii_case(unit)).map(|(_, k)| *k)
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PointCloud {
pub id: u64,
pub name: String,
/// The file it was read from (its name only).
#[serde(default)]
pub file: String,
/// Where the points' own frame sits in the cloud's placement (mm).
pub origin: Vec3,
/// The points from `origin` (mm).
pub points: Points,
/// The file's colour of each point, when it has them.
#[serde(default, skip_serializing_if = "Colors::is_empty")]
pub colors: Colors,
/// Points the file had (more than `points` when the cloud was thinned as it came in).
#[serde(default)]
pub source_points: u64,
/// The file's length unit (one of [`UNITS`]): the points were scaled from it to millimetres.
#[serde(default = "mm")]
pub units: String,
/// Where the cloud sits in the design: a rigid move of its points.
#[serde(default = "identity", skip_serializing_if = "is_identity")]
pub transform: Mat,
/// Size of a point on screen (pixels).
#[serde(default = "two")]
pub point_size: f64,
/// How the points are coloured.
#[serde(default, skip_serializing_if = "ColorBy::is_file")]
pub color_by: ColorBy,
/// The colour of every point with [`ColorBy::Single`] (straight sRGB, 0..1; `None`: [`PLAIN`]).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub color: Option<[f32; 3]>,
/// The heights (design Z, mm) the [`ColorBy::Height`] ramp runs between, lowest first;
/// `None`: worked out from the points ([`PointCloud::auto_height_range`]).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub height_range: Option<[f64; 2]>,
#[serde(default = "yes")]
pub visible: bool,
}
/// How a cloud's points are coloured.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ColorBy {
/// The file's colour of each point ([`PLAIN`] when it has none).
#[default]
File,
/// One colour for every point ([`PointCloud::color`]).
Single,
/// By height in the design: blue low, through cyan, green and yellow, to red high.
Height,
}
impl ColorBy {
fn is_file(&self) -> bool {
*self == ColorBy::File
}
/// From its name (`file`, `single`, `height`).
pub fn parse(s: &str) -> Option<ColorBy> {
match s {
"file" => Some(ColorBy::File),
"single" => Some(ColorBy::Single),
"height" => Some(ColorBy::Height),
_ => None,
}
}
pub fn name(self) -> &'static str {
match self {
ColorBy::File => "file",
ColorBy::Single => "single",
ColorBy::Height => "height",
}
}
}
/// The colour of points that have no other (straight sRGB, 0..1).
pub const PLAIN: [f32; 3] = [0.59, 0.63, 0.69];
/// Points sampled for the automatic height range.
const HEIGHT_SAMPLES: usize = 200_000;
/// The share of points left below and above the automatic height range, so a few stray points
/// don't flatten the ramp.
const HEIGHT_TAIL: f64 = 0.02;
/// A colour of the height ramp at `t` (0: low, 1: high): blue, cyan, green, yellow, red.
pub fn height_ramp(t: f64) -> [u8; 3] {
const STOPS: [[f64; 3]; 5] = [[40.0, 70.0, 200.0], [30.0, 170.0, 230.0], [60.0, 200.0, 90.0], [240.0, 220.0, 60.0], [230.0, 70.0, 50.0]];
let k = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 } * (STOPS.len() - 1) as f64;
let i = (k as usize).min(STOPS.len() - 2);
let f = k - i as f64;
let (a, b) = (STOPS[i], STOPS[i + 1]);
std::array::from_fn(|c| (a[c] * (1.0 - f) + b[c] * f).round().clamp(0.0, 255.0) as u8)
}
/// A colour channel (0..1) as a byte.
pub fn byte(v: f32) -> u8 {
(v.clamp(0.0, 1.0) * 255.0).round() as u8
}
fn identity() -> Mat {
IDENTITY
}
fn is_identity(m: &Mat) -> bool {
*m == IDENTITY
}
fn mm() -> String {
"mm".into()
}
fn two() -> f64 {
2.0
}
fn yes() -> bool {
true
}
impl PointCloud {
pub fn len(&self) -> usize {
self.points.len()
}
pub fn is_empty(&self) -> bool {
self.points.len() == 0
}
/// The `i`th point in the design (mm).
pub fn world_point(&self, i: usize) -> Option<Vec3> {
let p = self.points.get(i)?;
let local = self.origin + Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]));
Some(crate::apply_point(&self.transform, local))
}
/// The corners of the box around the points, in the cloud's placement (mm), or `None` for
/// an empty cloud.
pub fn local_bounds(&self) -> Option<(Vec3, Vec3)> {
let (lo, hi) = self.points.bounds()?;
let v = |p: [f32; 3]| self.origin + Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]));
Some((v(lo), v(hi)))
}
/// The design Z (mm) of a point from the cloud's origin.
fn world_z(&self, p: [f32; 3]) -> f64 {
let m = &self.transform;
let l = [self.origin.x + f64::from(p[0]), self.origin.y + f64::from(p[1]), self.origin.z + f64::from(p[2])];
m[0][2] * l[0] + m[1][2] * l[1] + m[2][2] * l[2] + m[3][2]
}
/// The heights (design Z, mm) holding all but the lowest and highest 2 % of the points (an
/// even sample of them), or `None` for an empty cloud. A flat cloud gets a range 1 mm high.
pub fn auto_height_range(&self) -> Option<[f64; 2]> {
let n = self.points.len();
if n == 0 {
return None;
}
let step = n.div_ceil(HEIGHT_SAMPLES).max(1);
let mut z: Vec<f64> = (0..n).step_by(step).filter_map(|i| self.points.get(i)).map(|p| self.world_z(p)).collect();
z.sort_by(f64::total_cmp);
let last = z.len().checked_sub(1)?;
let at = |q: f64| z.get((last as f64 * q).round() as usize).copied();
let (lo, hi) = (at(HEIGHT_TAIL)?, at(1.0 - HEIGHT_TAIL)?);
Some(if hi - lo > 1e-9 { [lo, hi] } else { [lo - 0.5, lo + 0.5] })
}
/// The heights the height ramp runs between now: the cloud's own, else the automatic ones.
pub fn height_range_now(&self) -> Option<[f64; 2]> {
self.height_range.or_else(|| self.auto_height_range())
}
/// The colour of each point (by index) as the cloud is shown.
pub fn shade(&self) -> impl Fn(usize) -> [u8; 3] + '_ {
let single = self.color.unwrap_or(PLAIN).map(byte);
let plain = PLAIN.map(byte);
let range = if self.color_by == ColorBy::Height { self.height_range_now() } else { None };
move |i| match self.color_by {
ColorBy::File => self.colors.get(i).unwrap_or(plain),
ColorBy::Single => single,
ColorBy::Height => match (range, self.points.get(i)) {
(Some([lo, hi]), Some(p)) => height_ramp((self.world_z(p) - lo) / (hi - lo)),
_ => plain,
},
}
}
/// The corners of the box around the points, placed in the design (mm).
pub fn world_corners(&self) -> Option<[Vec3; 8]> {
let (lo, hi) = self.local_bounds()?;
Some(std::array::from_fn(|i| {
let q = Vec3::new(if i & 1 == 0 { lo.x } else { hi.x }, if i & 2 == 0 { lo.y } else { hi.y }, if i & 4 == 0 { lo.z } else { hi.z });
crate::apply_point(&self.transform, q)
}))
}
/// The cloud is whole: as many colours as points, finite coordinates within range, a size
/// on screen in range and a rigid placement.
pub fn check(&self) -> Result<()> {
let bad = |what: &str| Err(DocError::Invalid(format!("point cloud `{}`: {what}", self.name)));
if self.points.len() > MAX_POINTS {
return bad("too many points");
}
if !self.colors.is_empty() && self.colors.len() != self.points.len() {
return bad("its colours do not match its points");
}
if ![self.origin.x, self.origin.y, self.origin.z].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD) {
return bad("its origin is out of range");
}
if self.points.values().iter().any(|v| !v.is_finite() || f64::from(v.abs()) > MAX_COORD) {
return bad("a point is out of range");
}
if unit_scale(&self.units).is_none() {
return bad("its units are not mm, cm, m, in or ft");
}
if !(self.point_size.is_finite() && POINT_SIZE.contains(&self.point_size)) {
return bad("its point size is out of range");
}
if self.color.is_some_and(|c| c.iter().any(|v| !(0.0..=1.0).contains(v))) {
return bad("its colour is out of range");
}
if self.height_range.is_some_and(|[lo, hi]| !(lo.is_finite() && hi.is_finite() && lo < hi && lo.abs() <= MAX_COORD && hi.abs() <= MAX_COORD))
{
return bad("its height range is not two heights, lowest first");
}
if !rigid(&self.transform) {
return bad("its placement is not a rigid move");
}
Ok(())
}
}
/// A rotation and a translation within range (no scale, shear or mirror).
pub fn rigid(m: &Mat) -> bool {
let column = |i: usize| Vec3::new(m[i][0], m[i][1], m[i][2]);
let (x, y, z) = (column(0), column(1), column(2));
m.iter().flatten().all(|v| v.is_finite())
&& m[3][..3].iter().all(|v| v.abs() <= MAX_COORD)
&& [x, y, z].iter().all(|axis| (axis.dot(*axis) - 1.0).abs() < 1e-6)
&& x.dot(y).abs() < 1e-6
&& x.dot(z).abs() < 1e-6
&& y.dot(z).abs() < 1e-6
&& x.cross(y).dot(z) > 0.0
&& [m[0][3], m[1][3], m[2][3]].iter().all(|v| v.abs() < 1e-9)
&& (m[3][3] - 1.0).abs() < 1e-9
}
/// Corners of the box around some points.
type Corners = Option<([f32; 3], [f32; 3])>;
/// x, y, z per point (single precision, little-endian when stored). Shared, so undo states and
/// copies of the design don't copy the points; the box around them is worked out once.
#[derive(Clone, Debug, Default)]
pub struct Points {
values: Arc<[f32]>,
bounds: Arc<std::sync::OnceLock<Corners>>,
}
impl Points {
pub fn new(values: Arc<[f32]>) -> Points {
Points { values, bounds: Default::default() }
}
/// x, y, z per point.
pub fn values(&self) -> &Arc<[f32]> {
&self.values
}
pub fn len(&self) -> usize {
self.values.len() / 3
}
pub fn is_empty(&self) -> bool {
self.values.len() < 3
}
pub fn get(&self, i: usize) -> Option<[f32; 3]> {
let s = self.values.get(i.checked_mul(3)?..i.checked_mul(3)?.checked_add(3)?)?;
Some([*s.first()?, *s.get(1)?, *s.get(2)?])
}
pub fn iter(&self) -> impl Iterator<Item = [f32; 3]> + '_ {
self.values.as_chunks::<3>().0.iter().copied()
}
/// The lowest and highest x, y and z, or `None` without points.
pub fn bounds(&self) -> Corners {
*self.bounds.get_or_init(|| {
let mut it = self.iter();
let first = it.next()?;
Some(it.fold((first, first), |(mut lo, mut hi), p| {
for k in 0..3 {
lo[k] = lo[k].min(p[k]);
hi[k] = hi[k].max(p[k]);
}
(lo, hi)
}))
})
}
/// The points as stored: little-endian f32, x, y, z per point.
pub fn to_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(self.values.len() * 4);
for v in self.values.iter() {
out.extend_from_slice(&v.to_le_bytes());
}
out
}
/// The points from stored bytes; `None` unless whole points of finite coordinates.
pub fn from_bytes(b: &[u8]) -> Option<Points> {
if !b.len().is_multiple_of(12) || b.len() / 12 > MAX_POINTS {
return None;
}
let v: Vec<f32> = b.as_chunks::<4>().0.iter().map(|c| f32::from_le_bytes(*c)).collect();
v.iter().all(|x| x.is_finite()).then(|| Points::new(v.into()))
}
}
/// The same points: the same shared storage, or equal values.
impl PartialEq for Points {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.values, &other.values) || self.values == other.values
}
}
impl Serialize for Points {
fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
s.serialize_str(&base64_encode(&self.to_bytes()))
}
}
impl<'de> Deserialize<'de> for Points {
fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
let s = String::deserialize(d)?;
if s.len() > (MAX_POINTS * 12).div_ceil(3) * 4 + 16 {
return Err(serde::de::Error::custom("too many points"));
}
let b = base64_decode(&s).ok_or_else(|| serde::de::Error::custom("points are not base64"))?;
Points::from_bytes(&b).ok_or_else(|| serde::de::Error::custom("points are not whole, finite x, y, z"))
}
}
/// r, g, b per point (bytes).
#[derive(Clone, Debug, Default)]
pub struct Colors(pub Arc<[u8]>);
impl Colors {
pub fn len(&self) -> usize {
self.0.len() / 3
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn get(&self, i: usize) -> Option<[u8; 3]> {
let s = self.0.get(i.checked_mul(3)?..i.checked_mul(3)?.checked_add(3)?)?;
Some([*s.first()?, *s.get(1)?, *s.get(2)?])
}
pub fn from_bytes(b: &[u8]) -> Option<Colors> {
(b.len().is_multiple_of(3) && b.len() / 3 <= MAX_POINTS).then(|| Colors(b.into()))
}
}
impl PartialEq for Colors {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0, &other.0) || self.0 == other.0
}
}
impl Serialize for Colors {
fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
s.serialize_str(&base64_encode(&self.0))
}
}
impl<'de> Deserialize<'de> for Colors {
fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
let s = String::deserialize(d)?;
if s.len() > (MAX_POINTS * 3).div_ceil(3) * 4 + 16 {
return Err(serde::de::Error::custom("too many colours"));
}
let b = base64_decode(&s).ok_or_else(|| serde::de::Error::custom("colours are not base64"))?;
Colors::from_bytes(&b).ok_or_else(|| serde::de::Error::custom("colours are not whole r, g, b"))
}
}
/// Every cloud of a design is whole ([`PointCloud::check`]) and has its own id.
pub fn check_all(clouds: &[PointCloud]) -> Result<()> {
let mut ids = std::collections::BTreeSet::new();
for c in clouds {
c.check()?;
if !ids.insert(c.id) {
return Err(DocError::Invalid(format!("two point clouds have the id {}", c.id)));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn cloud(points: Vec<f32>, colors: Vec<u8>) -> PointCloud {
PointCloud {
id: 7,
name: "Scan".into(),
file: "scan.ply".into(),
origin: Vec3::new(1000.0, 0.0, 0.0),
points: Points::new(points.into()),
colors: Colors(colors.into()),
source_points: 2,
units: "m".into(),
transform: IDENTITY,
point_size: 2.0,
color_by: ColorBy::File,
color: None,
height_range: None,
visible: true,
}
}
#[test]
fn points_round_trip_through_json_and_stay_shared() {
let c = cloud(vec![0.0, 1.0, 2.0, -3.5, 4.25, 1e6], vec![255, 0, 10, 1, 2, 3]);
let json = serde_json::to_string(&c).unwrap();
let back: PointCloud = serde_json::from_str(&json).unwrap();
assert_eq!(back, c);
assert_eq!(back.points.get(1), Some([-3.5, 4.25, 1e6]));
assert_eq!(back.colors.get(0), Some([255, 0, 10]));
assert_eq!(back.world_point(0), Some(Vec3::new(1000.0, 1.0, 2.0)));
assert_eq!(back.points.get(2), None);
let copy = c.clone();
assert!(Arc::ptr_eq(copy.points.values(), c.points.values()), "a copy shares the points");
let (lo, hi) = c.local_bounds().unwrap();
assert_eq!((lo, hi), (Vec3::new(996.5, 1.0, 2.0), Vec3::new(1000.0, 4.25, 1e6)));
check_all(&[c]).unwrap();
assert_eq!((unit_scale("M"), unit_scale("yd")), (Some(1000.0), None));
}
#[test]
fn damaged_clouds_are_refused() {
// Not whole points, not finite, not base64.
for points in ["AAAA", "AADAfwAAwH8AAMB/", "!!!!"] {
let json = serde_json::to_string(&cloud(vec![0.0; 3], Vec::new())).unwrap().replace("\"AAAAAAAAAAAAAAAA\"", &format!("\"{points}\""));
assert!(serde_json::from_str::<PointCloud>(&json).is_err(), "{points}");
}
assert!(cloud(vec![0.0; 6], vec![1, 2, 3]).check().is_err(), "one colour for two points");
let mut c = cloud(vec![0.0; 3], Vec::new());
c.point_size = 100.0;
assert!(c.check().is_err());
let mut c = cloud(vec![0.0; 3], Vec::new());
c.transform[0][0] = 2.0;
assert!(c.check().is_err(), "a scale is not a placement");
let c = cloud(vec![0.0; 3], Vec::new());
assert!(check_all(&[c.clone(), c]).is_err(), "two clouds with one id");
for range in [[5.0, 5.0], [9.0, 1.0], [f64::NAN, 1.0], [0.0, 1e12]] {
let mut c = cloud(vec![0.0; 3], Vec::new());
c.height_range = Some(range);
assert!(c.check().is_err(), "{range:?}");
}
}
#[test]
fn points_are_coloured_by_the_file_one_colour_or_their_height() {
// Heights 0..=100 mm, and a stray point far above the rest.
let mut values: Vec<f32> = (0..=100).flat_map(|z| [0.0, 0.0, z as f32]).collect();
values.extend([0.0, 0.0, 1000.0]);
let colors: Vec<u8> = (0..102).flat_map(|i| [i as u8, 7, 9]).collect();
let mut c = cloud(values, colors);
c.origin = Vec3::ZERO;
assert_eq!(c.shade()(3), [3, 7, 9], "the file's colours");
c.colors = Colors::default();
assert_eq!(c.shade()(3), PLAIN.map(byte), "none: plain");
c.color_by = ColorBy::Single;
c.color = Some([1.0, 0.5, 0.0]);
assert_eq!(c.shade()(50), [255, 128, 0]);
// The stray point doesn't stretch the automatic range.
c.color_by = ColorBy::Height;
// 102 points: the 2nd and the 99th (of 0…101) once sorted.
assert_eq!(c.auto_height_range(), Some([2.0, 99.0]));
{
let shade = c.shade();
assert_eq!((shade(0), shade(100), shade(101)), (height_ramp(0.0), height_ramp(1.0), height_ramp(1.0)));
assert_eq!(shade(50), height_ramp(48.0 / 97.0));
}
// A range of its own; moved up 100 mm, everything is above it.
c.height_range = Some([0.0, 50.0]);
assert_eq!(c.shade()(25), height_ramp(0.5));
c.transform[3][2] = 100.0;
assert_eq!(c.shade()(0), height_ramp(1.0));
assert_eq!((height_ramp(0.0), height_ramp(1.0), height_ramp(f64::NAN)), ([40, 70, 200], [230, 70, 50], [40, 70, 200]));
let back: PointCloud = serde_json::from_str(&serde_json::to_string(&c).unwrap()).unwrap();
assert_eq!(back, c);
}
}