#![cfg(feature = "ply")]
use crate::geom3::attributes3::Attr3;
use crate::geom3::attributes3::FaceAttrSet3;
use crate::geom3::attributes3::PointAttrSet3;
use crate::geom3::mesh::MeshView3;
use crate::geom3::mesh::data::MeshData3;
use crate::{Point2, Point3, Result, UnitVec3, Vector3};
use ply_rs_bw::parser::{Parser, Reader};
use ply_rs_bw::ply::{
BeginList, ElementDef, Encoding, Header, PropertyAccess, PropertyAccessResult, PropertyDef,
PropertyType, ScalarType,
};
use ply_rs_bw::writer::Writer;
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Write};
use std::path::Path;
pub fn load_ply_mesh_data(path: &Path) -> Result<MeshData3> {
let file = File::open(path)?;
read_ply_mesh_data(BufReader::new(file))
}
pub fn read_ply_mesh_data<R: BufRead>(source: R) -> Result<MeshData3> {
let mut reader = Reader::new(source);
let scalar_parser = Parser::<ScalarRow>::new();
let header = scalar_parser.read_header(&mut reader)?;
let mut points: Option<Vec<Point3>> = None;
let mut point_attrs = PointAttrSet3::empty();
let mut face_attrs = FaceAttrSet3::empty();
let mut faces: Vec<[u32; 3]> = Vec::new();
for (name, def) in header.elements.iter() {
match name.as_str() {
"vertex" => {
let rows = scalar_parser.read_payload_for_element(&mut reader, def, &header)?;
points = Some(read_points(def, &rows, &mut point_attrs)?);
}
"face" => {
let face_parser = Parser::<FaceRow>::new();
let rows = face_parser.read_payload_for_element(&mut reader, def, &header)?;
faces = read_faces(def, &rows, &mut face_attrs)?;
}
_ => {
let skip_parser = Parser::<SkipRow>::new();
skip_parser.read_payload_for_element(&mut reader, def, &header)?;
}
}
}
let points = points.ok_or("PLY file has no 'vertex' element")?;
MeshData3::new_with_attrs(points, faces, point_attrs, face_attrs)
}
pub fn read_ply_points<R: BufRead>(source: R) -> Result<(Vec<Point3>, PointAttrSet3, bool)> {
let mut reader = Reader::new(source);
let scalar_parser = Parser::<ScalarRow>::new();
let header = scalar_parser.read_header(&mut reader)?;
let mut points: Option<Vec<Point3>> = None;
let mut attrs = PointAttrSet3::empty();
let mut has_faces = false;
for (name, def) in header.elements.iter() {
match name.as_str() {
"vertex" => {
let rows = scalar_parser.read_payload_for_element(&mut reader, def, &header)?;
points = Some(read_points(def, &rows, &mut attrs)?);
}
"face" => {
has_faces = def.count > 0;
let face_parser = Parser::<FaceRow>::new();
face_parser.read_payload_for_element(&mut reader, def, &header)?;
}
_ => {
let skip_parser = Parser::<SkipRow>::new();
skip_parser.read_payload_for_element(&mut reader, def, &header)?;
}
}
}
let points = points.ok_or("PLY file has no 'vertex' element")?;
attrs.validate(points.len())?;
Ok((points, attrs, has_faces))
}
pub fn load_ply_points(path: &Path) -> Result<(Vec<Point3>, PointAttrSet3, bool)> {
let file = File::open(path)?;
read_ply_points(BufReader::new(file))
}
#[non_exhaustive]
#[derive(Debug, Clone)]
pub struct PlyWriteOpts {
pub binary: bool,
pub comments: Vec<String>,
pub precision: PlyPrecision,
}
impl Default for PlyWriteOpts {
fn default() -> Self {
Self {
binary: true,
comments: Vec::new(),
precision: PlyPrecision::Double,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PlyPrecision {
Single,
#[default]
Double,
}
impl PlyPrecision {
fn scalar_type(&self) -> ScalarType {
match self {
PlyPrecision::Single => ScalarType::Float,
PlyPrecision::Double => ScalarType::Double,
}
}
}
pub fn write_ply_mesh<'a>(
path: &Path,
mesh: impl Into<MeshView3<'a>>,
opts: &PlyWriteOpts,
) -> Result<()> {
let file = File::create(path)?;
let mut out = BufWriter::new(file);
write_ply_to(&mut out, mesh, opts)?;
out.flush()?;
Ok(())
}
pub fn write_ply_to<'a, W: Write>(
out: &mut W,
mesh: impl Into<MeshView3<'a>>,
opts: &PlyWriteOpts,
) -> Result<()> {
let mesh = mesh.into();
let point_cols = point_columns(mesh.points(), mesh.point_attrs());
let face_cols = face_columns(mesh.face_attrs());
let mut header = new_header(opts);
header.elements.insert(
"vertex".to_string(),
vertex_element(&point_cols, mesh.point_count(), opts),
);
let mut face = ElementDef::new("face".to_string());
face.count = mesh.face_count();
face.properties.insert(
"vertex_indices".to_string(),
PropertyDef::new(
"vertex_indices".to_string(),
PropertyType::List(ScalarType::UChar, ScalarType::Int),
),
);
for (name, col) in face_cols.iter() {
face.properties.insert(
name.clone(),
PropertyDef::new(
name.clone(),
PropertyType::Scalar(col.scalar_type(opts.precision)),
),
);
}
header.elements.insert("face".to_string(), face);
let writer = Writer::<Row>::new();
writer.write_header(out, &header)?;
write_vertex_rows(&writer, out, &header, point_cols, mesh.point_count())?;
let face_def = &header.elements["face"];
let mut row = Row::new();
row.cols = face_cols;
for (i, f) in mesh.faces().iter().enumerate() {
row.index = i;
for (slot, index) in row.face.iter_mut().zip(f.iter()) {
*slot = i32::try_from(*index).map_err(|_| {
format!(
"Point index {index} does not fit the `int` type PLY faces are written with"
)
})?;
}
write_row(&writer, out, &row, face_def, header.encoding)?;
}
Ok(())
}
pub fn write_ply_points(
path: &Path,
points: &[Point3],
attrs: &PointAttrSet3,
opts: &PlyWriteOpts,
) -> Result<()> {
let file = File::create(path)?;
let mut out = BufWriter::new(file);
write_ply_points_to(&mut out, points, attrs, opts)?;
out.flush()?;
Ok(())
}
pub fn write_ply_points_to<W: Write>(
out: &mut W,
points: &[Point3],
attrs: &PointAttrSet3,
opts: &PlyWriteOpts,
) -> Result<()> {
attrs.validate(points.len())?;
let cols = point_columns(points, attrs);
let mut header = new_header(opts);
header.elements.insert(
"vertex".to_string(),
vertex_element(&cols, points.len(), opts),
);
let writer = Writer::<Row>::new();
writer.write_header(out, &header)?;
write_vertex_rows(&writer, out, &header, cols, points.len())
}
fn new_header(opts: &PlyWriteOpts) -> Header {
let mut header = Header::new();
header.encoding = if opts.binary {
Encoding::BinaryLittleEndian
} else {
Encoding::Ascii
};
header.comments = opts.comments.clone();
header
}
fn vertex_element(cols: &[(String, Col<'_>)], count: usize, opts: &PlyWriteOpts) -> ElementDef {
let mut vertex = ElementDef::new("vertex".to_string());
vertex.count = count;
for (name, col) in cols.iter() {
vertex.properties.insert(
name.clone(),
PropertyDef::new(
name.clone(),
PropertyType::Scalar(col.scalar_type(opts.precision)),
),
);
}
vertex
}
fn write_vertex_rows<W: Write>(
writer: &Writer<Row>,
out: &mut W,
header: &Header,
cols: Vec<(String, Col<'_>)>,
count: usize,
) -> Result<()> {
let def = &header.elements["vertex"];
let mut row = Row::new();
row.cols = cols;
for i in 0..count {
row.index = i;
write_row(writer, out, &row, def, header.encoding)?;
}
Ok(())
}
fn write_row<W: Write>(
writer: &Writer<Row>,
out: &mut W,
row: &Row,
def: &ElementDef,
encoding: Encoding,
) -> Result<()> {
match encoding {
Encoding::Ascii => writer.write_ascii_element(out, row, def)?,
Encoding::BinaryLittleEndian => writer.write_little_endian_element(out, row, def)?,
Encoding::BinaryBigEndian => writer.write_big_endian_element(out, row, def)?,
};
Ok(())
}
enum Col<'a> {
Point(&'a [Point3], usize),
Flat(&'a [Point2], usize),
Unit(&'a [UnitVec3], usize),
Scalar(&'a [f64]),
Label(&'a [u32]),
Vector(&'a [Vector3], usize),
Color(&'a [[u8; 3]], usize),
}
impl Col<'_> {
fn scalar_type(&self, precision: PlyPrecision) -> ScalarType {
match self {
Col::Point(..) | Col::Flat(..) | Col::Unit(..) | Col::Scalar(..) | Col::Vector(..) => {
precision.scalar_type()
}
Col::Label(..) => ScalarType::UInt,
Col::Color(..) => ScalarType::UChar,
}
}
fn double(&self, i: usize) -> Option<f64> {
match self {
Col::Point(v, c) => Some(v[i][*c]),
Col::Flat(v, c) => Some(v[i][*c]),
Col::Unit(v, c) => Some(v[i][*c]),
Col::Scalar(v) => Some(v[i]),
Col::Vector(v, c) => Some(v[i][*c]),
_ => None,
}
}
fn uint(&self, i: usize) -> Option<u32> {
match self {
Col::Label(v) => Some(v[i]),
_ => None,
}
}
fn uchar(&self, i: usize) -> Option<u8> {
match self {
Col::Color(v, c) => Some(v[i][*c]),
_ => None,
}
}
}
fn point_columns<'a>(points: &'a [Point3], attrs: &'a PointAttrSet3) -> Vec<(String, Col<'a>)> {
let mut cols = Vec::new();
for (name, c) in [("x", 0), ("y", 1), ("z", 2)] {
cols.push((name.to_string(), Col::Point(points, c)));
}
if let Some(n) = attrs.normals() {
for (name, c) in [("nx", 0), ("ny", 1), ("nz", 2)] {
cols.push((name.to_string(), Col::Unit(n, c)));
}
}
if let Some(colors) = attrs.colors() {
for (name, c) in [("red", 0), ("green", 1), ("blue", 2)] {
cols.push((name.to_string(), Col::Color(colors, c)));
}
}
if let Some(stdev) = attrs.stdev() {
cols.push(("stdev".to_string(), Col::Scalar(stdev)));
}
if let Some(flat) = attrs.flat() {
for (name, c) in [("flat_x", 0), ("flat_y", 1)] {
cols.push((name.to_string(), Col::Flat(flat, c)));
}
}
let mut names: Vec<&str> = attrs.attr_names().collect();
names.sort_unstable();
for name in names {
push_open_attr(&mut cols, name, attrs.attr(name).unwrap());
}
cols
}
fn face_columns(attrs: &FaceAttrSet3) -> Vec<(String, Col<'_>)> {
let mut cols = Vec::new();
if let Some(colors) = attrs.colors() {
for (name, c) in [("red", 0), ("green", 1), ("blue", 2)] {
cols.push((name.to_string(), Col::Color(colors, c)));
}
}
if let Some(labels) = attrs.labels() {
cols.push(("label".to_string(), Col::Label(labels)));
}
let mut names: Vec<&str> = attrs.attr_names().collect();
names.sort_unstable();
for name in names {
push_open_attr(&mut cols, name, attrs.attr(name).unwrap());
}
cols
}
fn push_open_attr<'a>(cols: &mut Vec<(String, Col<'a>)>, name: &str, attr: &'a Attr3) {
match attr {
Attr3::Scalar(v) => cols.push((name.to_string(), Col::Scalar(v))),
Attr3::Label(v) => cols.push((name.to_string(), Col::Label(v))),
Attr3::Vector(v) => {
for (c, suffix) in VECTOR_SUFFIXES.iter().enumerate() {
cols.push((format!("{name}{suffix}"), Col::Vector(v, c)));
}
}
Attr3::Color(v) => {
for (c, suffix) in COLOR_SUFFIXES.iter().enumerate() {
cols.push((format!("{name}{suffix}"), Col::Color(v, c)));
}
}
}
}
#[derive(Default)]
struct Row<'a> {
cols: Vec<(String, Col<'a>)>,
index: usize,
face: [i32; 3],
}
impl Row<'_> {
fn col(&self, name: &str) -> Option<&Col<'_>> {
self.cols.iter().find(|(n, _)| n == name).map(|(_, c)| c)
}
}
impl PropertyAccess for Row<'_> {
fn new() -> Self {
Self::default()
}
fn get_double(&self, name: &str) -> Option<f64> {
self.col(name)?.double(self.index)
}
fn get_float(&self, name: &str) -> Option<f32> {
self.col(name)?.double(self.index).map(|v| v as f32)
}
fn get_uint(&self, name: &str) -> Option<u32> {
self.col(name)?.uint(self.index)
}
fn get_uchar(&self, name: &str) -> Option<u8> {
self.col(name)?.uchar(self.index)
}
fn get_list_int(&self, _name: &str) -> Option<&[i32]> {
Some(&self.face)
}
}
#[derive(Default)]
struct ScalarRow {
values: Vec<f64>,
}
impl ScalarRow {
fn push(&mut self, value: f64) -> PropertyAccessResult {
self.values.push(value);
PropertyAccessResult::Set
}
}
impl PropertyAccess for ScalarRow {
fn new() -> Self {
Self::default()
}
fn set_char(&mut self, _: &str, v: i8) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_uchar(&mut self, _: &str, v: u8) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_short(&mut self, _: &str, v: i16) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_ushort(&mut self, _: &str, v: u16) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_int(&mut self, _: &str, v: i32) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_uint(&mut self, _: &str, v: u32) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_float(&mut self, _: &str, v: f32) -> PropertyAccessResult {
self.push(v as f64)
}
fn set_double(&mut self, _: &str, v: f64) -> PropertyAccessResult {
self.push(v)
}
}
#[derive(Default)]
struct FaceRow {
indices: Vec<i32>,
values: Vec<f64>,
}
impl FaceRow {
fn take_list<T: Copy + Into<i32>>(&mut self, values: Vec<T>) -> PropertyAccessResult {
self.indices = values.into_iter().map(|v| v.into()).collect();
PropertyAccessResult::Set
}
}
impl PropertyAccess for FaceRow {
fn new() -> Self {
Self::default()
}
fn begin_list_int(&mut self, _: &str, _len: usize) -> BeginList<'_, i32> {
BeginList::Fill(&mut self.indices)
}
fn set_list_char(&mut self, _: &str, v: Vec<i8>) -> PropertyAccessResult {
self.take_list(v)
}
fn set_list_uchar(&mut self, _: &str, v: Vec<u8>) -> PropertyAccessResult {
self.take_list(v)
}
fn set_list_short(&mut self, _: &str, v: Vec<i16>) -> PropertyAccessResult {
self.take_list(v)
}
fn set_list_ushort(&mut self, _: &str, v: Vec<u16>) -> PropertyAccessResult {
self.take_list(v)
}
fn set_list_uint(&mut self, _: &str, v: Vec<u32>) -> PropertyAccessResult {
self.indices = v.into_iter().map(|x| x as i32).collect();
PropertyAccessResult::Set
}
fn set_char(&mut self, _: &str, v: i8) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_uchar(&mut self, _: &str, v: u8) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_short(&mut self, _: &str, v: i16) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_ushort(&mut self, _: &str, v: u16) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_int(&mut self, _: &str, v: i32) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_uint(&mut self, _: &str, v: u32) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_float(&mut self, _: &str, v: f32) -> PropertyAccessResult {
self.values.push(v as f64);
PropertyAccessResult::Set
}
fn set_double(&mut self, _: &str, v: f64) -> PropertyAccessResult {
self.values.push(v);
PropertyAccessResult::Set
}
}
struct SkipRow;
impl PropertyAccess for SkipRow {
fn new() -> Self {
SkipRow
}
}
fn read_points(
def: &ElementDef,
rows: &[ScalarRow],
attrs: &mut PointAttrSet3,
) -> Result<Vec<Point3>> {
let scalars = scalar_properties(def);
let columns = transpose(&scalars, rows.iter().map(|r| &r.values), "vertex")?;
let n = rows.len();
let x = take_column(&columns, "x").ok_or("PLY 'vertex' element has no 'x' property")?;
let y = take_column(&columns, "y").ok_or("PLY 'vertex' element has no 'y' property")?;
let z = take_column(&columns, "z").ok_or("PLY 'vertex' element has no 'z' property")?;
let points = (0..n)
.map(|i| Point3::new(x.values[i], y.values[i], z.values[i]))
.collect();
if let (Some(nx), Some(ny), Some(nz)) = (
take_column(&columns, "nx"),
take_column(&columns, "ny"),
take_column(&columns, "nz"),
) {
let mut normals = Vec::with_capacity(n);
for i in 0..n {
let v = Vector3::new(nx.values[i], ny.values[i], nz.values[i]);
let unit = UnitVec3::try_new(v, 1.0e-12).ok_or_else(|| {
format!("PLY vertex {i} has a normal of zero length, which cannot be a direction")
})?;
normals.push(unit);
}
attrs.set_normals(Some(normals), n)?;
}
if let Some(colors) = take_colors(&columns, n) {
attrs.set_colors(Some(colors), n)?;
}
if let Some(stdev) = take_column(&columns, "stdev").or_else(|| take_column(&columns, "std_dev"))
{
attrs.set_stdev(Some(stdev.values.clone()), n)?;
}
match (
take_column(&columns, "flat_x"),
take_column(&columns, "flat_y"),
) {
(Some(fx), Some(fy)) => {
let flat = (0..n)
.map(|i| Point2::new(fx.values[i], fy.values[i]))
.collect();
attrs.set_flat(Some(flat), n)?;
}
(None, None) => {}
_ => {
return Err(
"PLY 'vertex' element has only one of 'flat_x' and 'flat_y', but flat \
coordinates need both"
.into(),
);
}
}
let (composites, taken) = take_composites(&columns);
for (name, attr) in composites {
attrs.insert_attr(&name, attr, n)?;
}
for column in remaining(&columns, POINT_CONSUMED, &taken) {
attrs.insert_attr(&column.name, column.to_attr(), n)?;
}
Ok(points)
}
const POINT_CONSUMED: &[&str] = &[
"x", "y", "z", "nx", "ny", "nz", "red", "green", "blue", "alpha", "stdev", "std_dev", "flat_x",
"flat_y",
];
fn read_faces(
def: &ElementDef,
rows: &[FaceRow],
attrs: &mut FaceAttrSet3,
) -> Result<Vec<[u32; 3]>> {
let mut faces = Vec::with_capacity(rows.len());
let mut source_rows = Vec::with_capacity(rows.len());
for (i, row) in rows.iter().enumerate() {
if row.indices.len() < 3 {
return Err(format!(
"PLY face {i} has {} indices, but a face needs at least 3",
row.indices.len()
)
.into());
}
let mut fan = Vec::with_capacity(row.indices.len());
for index in &row.indices {
let value = u32::try_from(*index)
.map_err(|_| format!("PLY face {i} has a negative point index {index}"))?;
fan.push(value);
}
for k in 1..fan.len() - 1 {
faces.push([fan[0], fan[k], fan[k + 1]]);
source_rows.push(i);
}
}
let scalars = scalar_properties(def);
let columns = transpose(&scalars, rows.iter().map(|r| &r.values), "face")?;
let columns: Vec<Column> = columns
.into_iter()
.map(|c| c.expanded(&source_rows))
.collect();
let n = faces.len();
if let Some(colors) = take_colors(&columns, n) {
attrs.set_colors(Some(colors), n)?;
}
if let Some(labels) = take_column(&columns, "label").or_else(|| take_column(&columns, "labels"))
{
attrs.set_labels(Some(labels.as_labels()?), n)?;
}
let (composites, taken) = take_composites(&columns);
for (name, attr) in composites {
attrs.insert_attr(&name, attr, n)?;
}
for column in remaining(&columns, FACE_CONSUMED, &taken) {
attrs.insert_attr(&column.name, column.to_attr(), n)?;
}
Ok(faces)
}
const FACE_CONSUMED: &[&str] = &[
"vertex_indices",
"vertex_index",
"red",
"green",
"blue",
"alpha",
"label",
"labels",
];
struct Column {
name: String,
declared: ScalarType,
values: Vec<f64>,
}
impl Column {
fn to_attr(&self) -> Attr3 {
match &self.declared {
ScalarType::Float | ScalarType::Double => Attr3::Scalar(self.values.clone()),
_ if self.values.iter().any(|v| *v < 0.0) => Attr3::Scalar(self.values.clone()),
_ => Attr3::Label(self.values.iter().map(|v| *v as u32).collect()),
}
}
fn as_labels(&self) -> Result<Vec<u32>> {
if let Some(v) = self.values.iter().find(|v| **v < 0.0) {
return Err(format!("PLY property '{}' holds a negative label {v}", self.name).into());
}
Ok(self.values.iter().map(|v| *v as u32).collect())
}
fn as_channel(&self) -> Vec<u8> {
self.values
.iter()
.map(|v| v.round().clamp(0.0, 255.0) as u8)
.collect()
}
fn expanded(self, source_rows: &[usize]) -> Self {
if source_rows.len() == self.values.len() {
return self;
}
let values = source_rows.iter().map(|i| self.values[*i]).collect();
Self { values, ..self }
}
}
fn scalar_properties(def: &ElementDef) -> Vec<(String, ScalarType)> {
def.properties
.iter()
.filter_map(|(name, prop)| match &prop.data_type {
PropertyType::Scalar(t) => Some((name.clone(), t.clone())),
PropertyType::List(_, _) => None,
})
.collect()
}
fn transpose<'a>(
scalars: &[(String, ScalarType)],
rows: impl IntoIterator<Item = &'a Vec<f64>>,
element: &str,
) -> Result<Vec<Column>> {
let mut columns: Vec<Column> = scalars
.iter()
.map(|(name, declared)| Column {
name: name.clone(),
declared: declared.clone(),
values: Vec::new(),
})
.collect();
for (i, values) in rows.into_iter().enumerate() {
if values.len() != columns.len() {
return Err(format!(
"PLY '{element}' row {i} produced {} scalar values, but the header declares {}",
values.len(),
columns.len()
)
.into());
}
for (column, value) in columns.iter_mut().zip(values.iter()) {
column.values.push(*value);
}
}
Ok(columns)
}
fn take_column<'a>(columns: &'a [Column], name: &str) -> Option<&'a Column> {
columns.iter().find(|c| c.name == name)
}
fn take_colors(columns: &[Column], n: usize) -> Option<Vec<[u8; 3]>> {
let r = take_column(columns, "red")?.as_channel();
let g = take_column(columns, "green")?.as_channel();
let b = take_column(columns, "blue")?.as_channel();
Some((0..n).map(|i| [r[i], g[i], b[i]]).collect())
}
fn remaining<'a>(columns: &'a [Column], consumed: &[&str], taken: &[String]) -> Vec<&'a Column> {
columns
.iter()
.filter(|c| !consumed.contains(&c.name.as_str()) && !taken.contains(&c.name))
.collect()
}
const VECTOR_SUFFIXES: [&str; 3] = ["_x", "_y", "_z"];
const COLOR_SUFFIXES: [&str; 3] = ["_red", "_green", "_blue"];
fn take_composites(columns: &[Column]) -> (Vec<(String, Attr3)>, Vec<String>) {
let mut composites = Vec::new();
let mut taken = Vec::new();
for column in columns.iter() {
let Some(base) = column.name.strip_suffix(VECTOR_SUFFIXES[0]) else {
continue;
};
let parts: Vec<&Column> = VECTOR_SUFFIXES
.iter()
.filter_map(|s| take_column(columns, &format!("{base}{s}")))
.collect();
if parts.len() != 3 {
continue;
}
let values = (0..column.values.len())
.map(|i| Vector3::new(parts[0].values[i], parts[1].values[i], parts[2].values[i]))
.collect();
composites.push((base.to_string(), Attr3::Vector(values)));
taken.extend(parts.iter().map(|p| p.name.clone()));
}
for column in columns.iter() {
let Some(base) = column.name.strip_suffix(COLOR_SUFFIXES[0]) else {
continue;
};
let parts: Vec<&Column> = COLOR_SUFFIXES
.iter()
.filter_map(|s| take_column(columns, &format!("{base}{s}")))
.collect();
if parts.len() != 3 {
continue;
}
let channels: Vec<Vec<u8>> = parts.iter().map(|p| p.as_channel()).collect();
let values = (0..column.values.len())
.map(|i| [channels[0][i], channels[1][i], channels[2][i]])
.collect();
composites.push((base.to_string(), Attr3::Color(values)));
taken.extend(parts.iter().map(|p| p.name.clone()));
}
(composites, taken)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tests::get_test_file_path;
use approx::assert_relative_eq;
use std::io::Cursor;
#[test]
fn reads_a_binary_file() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("sample-clip.ply"))?;
assert_eq!(mesh.point_count(), 41706);
assert_eq!(mesh.face_count(), 82275);
assert!(!mesh.has_attrs());
Ok(())
}
#[test]
fn reads_an_ascii_file_and_keeps_its_extra_properties() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("bun_zipper_res4.ply"))?;
assert_eq!(mesh.point_count(), 453);
assert_eq!(mesh.face_count(), 948);
let confidence = mesh
.point_attr("confidence")
.expect("the file declares a 'confidence' property")
.as_scalar()
.expect("a float property should become a scalar attribute");
assert_eq!(confidence.len(), 453);
assert_relative_eq!(confidence[0], 0.850855, epsilon = 1.0e-6);
let intensity = mesh
.point_attr("intensity")
.expect("the file declares an 'intensity' property")
.as_scalar()
.expect("a float property should become a scalar attribute");
assert_relative_eq!(intensity[0], 0.5, epsilon = 1.0e-6);
assert_relative_eq!(mesh.points()[0].x, -0.0312216, epsilon = 1.0e-6);
assert_relative_eq!(mesh.points()[0].y, 0.126304, epsilon = 1.0e-6);
assert_relative_eq!(mesh.points()[0].z, 0.00514924, epsilon = 1.0e-6);
Ok(())
}
const REFERENCE_EPS: f64 = 4e-6;
#[test]
fn agrees_with_the_embedded_reference_mesh() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("bun_zipper_res4.ply"))?;
let expected = crate::tests::stanford_bun_4();
assert_eq!(mesh.point_count(), expected.points().len());
assert_eq!(mesh.face_count(), expected.faces().len());
let plan = tol_compress::reorder::optimize(mesh.faces(), mesh.point_count())?;
for (new, &old) in plan.face_order.iter().enumerate() {
for corner in 0..3 {
let a = mesh.points()[mesh.faces()[old as usize][corner] as usize];
let b = expected.points()[expected.faces()[new][corner] as usize];
assert_relative_eq!(a, b, epsilon = REFERENCE_EPS);
}
}
for (new, &old) in plan.vertex_order.iter().enumerate() {
assert_relative_eq!(
mesh.points()[old as usize],
expected.points()[new],
epsilon = REFERENCE_EPS
);
}
Ok(())
}
fn ascii_ply(body: &str) -> Result<MeshData3> {
read_ply_mesh_data(Cursor::new(body.to_string()))
}
#[test]
fn routes_recognized_properties_to_typed_fields() -> Result<()> {
let mesh = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 3\n\
property float x\n\
property float y\n\
property float z\n\
property float nx\n\
property float ny\n\
property float nz\n\
property uchar red\n\
property uchar green\n\
property uchar blue\n\
property float stdev\n\
property float flat_x\n\
property float flat_y\n\
element face 1\n\
property list uchar int vertex_indices\n\
property uchar label\n\
end_header\n\
0 0 0 0 0 2 255 0 0 0.01 0 0\n\
1 0 0 0 0 1 0 255 0 0.02 1.5 0\n\
0 1 0 0 0 1 0 0 255 0.03 0 1.5\n\
3 0 1 2 7\n",
)?;
assert_eq!(mesh.point_count(), 3);
assert_eq!(mesh.face_count(), 1);
let normals = mesh.point_normals().expect("normals should be present");
assert_relative_eq!(normals[0].into_inner(), Vector3::z(), epsilon = 1.0e-12);
assert_eq!(mesh.point_colors().unwrap()[0], [255, 0, 0]);
assert_relative_eq!(mesh.point_stdev().unwrap()[0], 0.01, epsilon = 1.0e-8);
assert_eq!(mesh.point_flat().unwrap()[1], Point2::new(1.5, 0.0));
assert_eq!(mesh.face_labels().unwrap(), &[7]);
assert_eq!(mesh.point_attrs().attr_names().count(), 0);
assert_eq!(mesh.face_attrs().attr_names().count(), 0);
Ok(())
}
#[test]
fn a_lone_flat_column_is_an_error() {
let result = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 1\n\
property float x\n\
property float y\n\
property float z\n\
property float flat_x\n\
end_header\n\
0 0 0 0.5\n",
);
let message = result.expect_err("half a flat coordinate").to_string();
assert!(message.contains("flat_x"), "{message}");
}
#[test]
fn integer_properties_become_labels_unless_they_go_negative() -> Result<()> {
let mesh = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 2\n\
property float x\n\
property float y\n\
property float z\n\
property uint scan_pass\n\
property int offset\n\
property float quality\n\
end_header\n\
0 0 0 4 -1 0.5\n\
1 0 0 9 2 0.25\n",
)?;
assert_eq!(
mesh.point_attr("scan_pass").unwrap().as_label().unwrap(),
&[4, 9]
);
assert_eq!(
mesh.point_attr("offset").unwrap().as_scalar().unwrap(),
&[-1.0, 2.0]
);
assert_eq!(
mesh.point_attr("quality").unwrap().as_scalar().unwrap(),
&[0.5, 0.25]
);
Ok(())
}
#[test]
fn polygons_are_fan_triangulated_and_face_attributes_follow() -> Result<()> {
let mesh = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 5\n\
property float x\n\
property float y\n\
property float z\n\
element face 2\n\
property list uchar int vertex_indices\n\
property float quality\n\
end_header\n\
0 0 0\n\
1 0 0\n\
1 1 0\n\
0 1 0\n\
2 2 0\n\
4 0 1 2 3 0.75\n\
3 0 1 4 0.25\n",
)?;
assert_eq!(mesh.face_count(), 3);
assert_eq!(mesh.faces(), &[[0, 1, 2], [0, 2, 3], [0, 1, 4]]);
assert_eq!(
mesh.face_attr("quality").unwrap().as_scalar().unwrap(),
&[0.75, 0.75, 0.25]
);
Ok(())
}
#[test]
fn a_file_without_faces_loads_as_points_only() -> Result<()> {
let mesh = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 2\n\
property float x\n\
property float y\n\
property float z\n\
end_header\n\
0 0 0\n\
1 2 3\n",
)?;
assert_eq!(mesh.point_count(), 2);
assert_eq!(mesh.face_count(), 0);
assert!(!mesh.is_empty());
Ok(())
}
#[test]
fn unknown_elements_are_skipped_without_desynchronizing() -> Result<()> {
let mesh = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 2\n\
property float x\n\
property float y\n\
property float z\n\
element camera 1\n\
property float view_px\n\
property list uchar int extra\n\
element face 1\n\
property list uchar int vertex_indices\n\
end_header\n\
0 0 0\n\
1 0 0\n\
1.5 2 8 9\n\
3 0 1 1\n",
)?;
assert_eq!(mesh.point_count(), 2);
assert_eq!(mesh.faces(), &[[0, 1, 1]]);
Ok(())
}
#[test]
fn a_missing_vertex_element_is_an_error() {
let result = ascii_ply(
"ply\n\
format ascii 1.0\n\
element face 1\n\
property list uchar int vertex_indices\n\
end_header\n\
3 0 1 2\n",
);
assert!(result.is_err());
}
#[test]
fn an_out_of_range_face_index_is_an_error() {
let result = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 2\n\
property float x\n\
property float y\n\
property float z\n\
element face 1\n\
property list uchar int vertex_indices\n\
end_header\n\
0 0 0\n\
1 0 0\n\
3 0 1 5\n",
);
assert!(result.is_err());
}
fn round_trip(mesh: &MeshData3, binary: bool) -> Result<MeshData3> {
let opts = PlyWriteOpts {
binary,
..Default::default()
};
let mut buffer = Vec::new();
write_ply_to(&mut buffer, mesh, &opts)?;
read_ply_mesh_data(Cursor::new(buffer))
}
fn loaded_mesh() -> MeshData3 {
let mut mesh = MeshData3::new(
vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.0, 1.0, 0.0),
],
vec![[0, 1, 2]],
)
.unwrap();
mesh.set_point_normals(Some(vec![UnitVec3::new_normalize(Vector3::z()); 3]))
.unwrap();
mesh.set_point_colors(Some(vec![[255, 0, 0], [0, 255, 0], [0, 0, 255]]))
.unwrap();
mesh.set_point_stdev(Some(vec![0.001, 0.002, 0.003]))
.unwrap();
mesh.set_point_flat(Some(vec![
Point2::new(0.0, 0.0),
Point2::new(1.5, 0.0),
Point2::new(0.0, 1.5),
]))
.unwrap();
mesh.set_face_colors(Some(vec![[10, 20, 30]])).unwrap();
mesh.set_face_labels(Some(vec![42])).unwrap();
mesh.insert_point_attr("confidence", Attr3::Scalar(vec![0.25, 0.5, 0.75]))
.unwrap();
mesh.insert_point_attr("scan_pass", Attr3::Label(vec![1, 2, 3]))
.unwrap();
mesh.insert_point_attr(
"principal_dir",
Attr3::Vector(vec![Vector3::x(), Vector3::y(), Vector3::z()]),
)
.unwrap();
mesh.insert_point_attr("shade", Attr3::Color(vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
.unwrap();
mesh.insert_face_attr("quality", Attr3::Scalar(vec![0.875]))
.unwrap();
mesh
}
fn assert_same(a: &MeshData3, b: &MeshData3) {
assert_eq!(a.point_count(), b.point_count());
assert_eq!(a.faces(), b.faces());
for (p, q) in a.points().iter().zip(b.points()) {
assert_relative_eq!(p, q, epsilon = 0.0);
}
assert_eq!(a.point_colors(), b.point_colors());
assert_eq!(a.point_stdev(), b.point_stdev());
assert_eq!(a.point_flat(), b.point_flat());
assert_eq!(a.face_colors(), b.face_colors());
assert_eq!(a.face_labels(), b.face_labels());
match (a.point_normals(), b.point_normals()) {
(Some(x), Some(y)) => {
for (p, q) in x.iter().zip(y) {
assert_relative_eq!(p.into_inner(), q.into_inner(), epsilon = 1.0e-15);
}
}
(None, None) => {}
_ => panic!("normals present on only one side"),
}
let mut a_names: Vec<&str> = a.point_attrs().attr_names().collect();
let mut b_names: Vec<&str> = b.point_attrs().attr_names().collect();
a_names.sort_unstable();
b_names.sort_unstable();
assert_eq!(a_names, b_names, "point attribute names differ");
for name in a_names {
assert_eq!(
a.point_attr(name),
b.point_attr(name),
"point attr '{name}'"
);
}
let mut a_names: Vec<&str> = a.face_attrs().attr_names().collect();
let mut b_names: Vec<&str> = b.face_attrs().attr_names().collect();
a_names.sort_unstable();
b_names.sort_unstable();
assert_eq!(a_names, b_names, "face attribute names differ");
for name in a_names {
assert_eq!(a.face_attr(name), b.face_attr(name), "face attr '{name}'");
}
}
#[test]
fn binary_round_trip_preserves_everything() -> Result<()> {
let mesh = loaded_mesh();
assert_same(&mesh, &round_trip(&mesh, true)?);
Ok(())
}
#[test]
fn ascii_round_trip_preserves_everything() -> Result<()> {
let mesh = loaded_mesh();
assert_same(&mesh, &round_trip(&mesh, false)?);
Ok(())
}
#[test]
fn positions_survive_at_full_double_precision() -> Result<()> {
let awkward = 1.0 / 3.0;
let mesh = MeshData3::new(
vec![
Point3::new(awkward, -awkward, 1.0e-9),
Point3::new(1.0e9 + awkward, 0.0, 0.0),
Point3::new(0.0, 1.0, 0.0),
],
vec![[0, 1, 2]],
)?;
for binary in [true, false] {
let back = round_trip(&mesh, binary)?;
for (p, q) in mesh.points().iter().zip(back.points()) {
assert_eq!(p, q, "binary = {binary}");
}
}
Ok(())
}
#[test]
fn a_bare_mesh_round_trips_without_inventing_attributes() -> Result<()> {
let mesh = MeshData3::new(
vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.0, 1.0, 0.0),
],
vec![[0, 1, 2]],
)?;
let back = round_trip(&mesh, true)?;
assert!(!back.has_attrs());
assert_same(&mesh, &back);
Ok(())
}
#[test]
fn a_mesh_with_no_faces_round_trips() -> Result<()> {
let mut mesh = MeshData3::new(
vec![Point3::new(1.0, 2.0, 3.0), Point3::new(4.0, 5.0, 6.0)],
Vec::new(),
)?;
mesh.set_point_stdev(Some(vec![0.1, 0.2]))?;
let back = round_trip(&mesh, true)?;
assert_eq!(back.point_count(), 2);
assert_eq!(back.face_count(), 0);
assert_eq!(back.point_stdev().unwrap(), &[0.1, 0.2]);
Ok(())
}
#[test]
fn multi_component_attributes_are_written_as_suffixed_triples() -> Result<()> {
let mesh = loaded_mesh();
let opts = PlyWriteOpts {
binary: false,
..Default::default()
};
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &mesh, &opts)?;
let text = String::from_utf8(buffer).unwrap();
assert!(text.contains("property double principal_dir_x"), "{text}");
assert!(text.contains("property double principal_dir_y"), "{text}");
assert!(text.contains("property double principal_dir_z"), "{text}");
assert!(text.contains("property uchar shade_red"), "{text}");
assert!(text.contains("property uchar shade_green"), "{text}");
assert!(text.contains("property uchar shade_blue"), "{text}");
Ok(())
}
#[test]
fn single_precision_narrows_and_shrinks_the_output() -> Result<()> {
let mesh = loaded_mesh();
let mut wide = Vec::new();
write_ply_to(&mut wide, &mesh, &PlyWriteOpts::default())?;
let narrow_opts = PlyWriteOpts {
precision: PlyPrecision::Single,
..Default::default()
};
let mut narrow = Vec::new();
write_ply_to(&mut narrow, &mesh, &narrow_opts)?;
assert!(
narrow.len() < wide.len(),
"single precision produced {} bytes against {} for double",
narrow.len(),
wide.len()
);
let back = read_ply_mesh_data(Cursor::new(narrow))?;
for (original, returned) in mesh.points().iter().zip(back.points()) {
for c in 0..3 {
assert_eq!(returned[c], original[c] as f32 as f64);
}
}
assert_eq!(back.point_colors(), mesh.point_colors());
assert_eq!(back.face_labels(), mesh.face_labels());
assert_eq!(
back.point_attr("scan_pass").unwrap(),
mesh.point_attr("scan_pass").unwrap()
);
Ok(())
}
#[test]
fn precision_is_declared_in_the_header() -> Result<()> {
let mesh = loaded_mesh();
for (precision, expected) in [
(PlyPrecision::Double, "property double x"),
(PlyPrecision::Single, "property float x"),
] {
let opts = PlyWriteOpts {
binary: false,
precision,
..Default::default()
};
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &mesh, &opts)?;
let text = String::from_utf8(buffer).unwrap();
assert!(text.contains(expected), "expected `{expected}` in:\n{text}");
}
Ok(())
}
#[test]
fn a_file_that_was_f32_at_source_round_trips_at_single_precision() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("sample-clip.ply"))?;
let opts = PlyWriteOpts {
precision: PlyPrecision::Single,
..Default::default()
};
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &mesh, &opts)?;
let back = read_ply_mesh_data(Cursor::new(buffer))?;
assert_same(&mesh, &back);
Ok(())
}
#[test]
fn the_default_options_are_binary_and_lossless() {
let opts = PlyWriteOpts::default();
assert!(opts.binary);
assert_eq!(opts.precision, PlyPrecision::Double);
}
#[test]
fn comments_are_recorded_in_the_header() -> Result<()> {
let opts = PlyWriteOpts {
binary: false,
comments: vec!["Unit: mm".to_string()],
..Default::default()
};
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &loaded_mesh(), &opts)?;
let text = String::from_utf8(buffer).unwrap();
assert!(text.contains("comment Unit: mm"), "{text}");
Ok(())
}
#[test]
fn a_file_read_from_disk_round_trips_through_the_writer() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("bun_zipper_res4.ply"))?;
assert_same(&mesh, &round_trip(&mesh, true)?);
assert_same(&mesh, &round_trip(&mesh, false)?);
Ok(())
}
#[test]
fn a_large_binary_file_round_trips() -> Result<()> {
let mesh = load_ply_mesh_data(&get_test_file_path("sample-clip.ply"))?;
let back = round_trip(&mesh, true)?;
assert_eq!(back.point_count(), 41706);
assert_eq!(back.face_count(), 82275);
assert_same(&mesh, &back);
Ok(())
}
#[test]
fn a_zero_length_normal_is_an_error() {
let result = ascii_ply(
"ply\n\
format ascii 1.0\n\
element vertex 1\n\
property float x\n\
property float y\n\
property float z\n\
property float nx\n\
property float ny\n\
property float nz\n\
end_header\n\
0 0 0 0 0 0\n",
);
assert!(result.is_err());
}
fn loaded_points() -> (Vec<Point3>, PointAttrSet3) {
let mesh = loaded_mesh();
(mesh.points().to_vec(), mesh.point_attrs().clone())
}
fn round_trip_points(
points: &[Point3],
attrs: &PointAttrSet3,
binary: bool,
) -> Result<(Vec<Point3>, PointAttrSet3, bool)> {
let opts = PlyWriteOpts {
binary,
..Default::default()
};
let mut buffer = Vec::new();
write_ply_points_to(&mut buffer, points, attrs, &opts)?;
read_ply_points(Cursor::new(buffer))
}
#[test]
fn point_round_trip_preserves_every_attribute() -> Result<()> {
let (points, attrs) = loaded_points();
for binary in [true, false] {
let (back_points, back_attrs, has_faces) = round_trip_points(&points, &attrs, binary)?;
assert!(!has_faces, "a point-only file must declare no faces");
assert_eq!(back_points.len(), points.len());
for (p, q) in points.iter().zip(back_points.iter()) {
assert_relative_eq!(p, q, epsilon = 0.0);
}
assert_eq!(back_attrs.colors(), attrs.colors(), "binary = {binary}");
assert_eq!(back_attrs.stdev(), attrs.stdev(), "binary = {binary}");
assert_eq!(back_attrs.flat(), attrs.flat(), "binary = {binary}");
for (a, b) in back_attrs
.normals()
.unwrap()
.iter()
.zip(attrs.normals().unwrap())
{
assert_relative_eq!(a.into_inner(), b.into_inner(), epsilon = 1.0e-15);
}
let mut names: Vec<&str> = back_attrs.attr_names().collect();
let mut expected: Vec<&str> = attrs.attr_names().collect();
names.sort_unstable();
expected.sort_unstable();
assert_eq!(names, expected, "open attribute names differ");
for name in names {
assert_eq!(back_attrs.attr(name), attrs.attr(name), "attr '{name}'");
}
}
Ok(())
}
#[test]
fn the_vertex_section_matches_what_a_mesh_writes() -> Result<()> {
let mesh = loaded_mesh();
let (points, attrs) = loaded_points();
let opts = PlyWriteOpts::default();
let mut mesh_bytes = Vec::new();
write_ply_to(&mut mesh_bytes, &mesh, &opts)?;
let mut point_bytes = Vec::new();
write_ply_points_to(&mut point_bytes, &points, &attrs, &opts)?;
let split = point_bytes
.windows(END_HEADER.len())
.position(|w| w == END_HEADER)
.expect("the point-only file must have a header")
+ END_HEADER.len();
let mesh_split = mesh_bytes
.windows(END_HEADER.len())
.position(|w| w == END_HEADER)
.expect("the mesh file must have a header")
+ END_HEADER.len();
let point_payload = &point_bytes[split..];
let mesh_payload = &mesh_bytes[mesh_split..mesh_split + point_payload.len()];
assert_eq!(point_payload, mesh_payload);
Ok(())
}
const END_HEADER: &[u8] = b"end_header\n";
#[test]
fn reading_points_reports_whether_the_file_had_faces() -> Result<()> {
let mesh = loaded_mesh();
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &mesh, &PlyWriteOpts::default())?;
let (points, attrs, has_faces) = read_ply_points(Cursor::new(buffer))?;
assert!(has_faces);
assert_eq!(points.len(), mesh.point_count());
assert_eq!(attrs.stdev(), mesh.point_stdev());
Ok(())
}
#[test]
fn an_empty_face_element_does_not_count_as_faces() -> Result<()> {
let mesh = MeshData3::new(
vec![Point3::origin(), Point3::new(1.0, 0.0, 0.0)],
Vec::new(),
)?;
let mut buffer = Vec::new();
write_ply_to(&mut buffer, &mesh, &PlyWriteOpts::default())?;
let (points, _, has_faces) = read_ply_points(Cursor::new(buffer))?;
assert!(!has_faces);
assert_eq!(points.len(), 2);
Ok(())
}
#[test]
fn writing_points_rejects_a_mismatched_attribute() {
let (points, _) = loaded_points();
let mut attrs = PointAttrSet3::empty();
attrs.set_stdev(Some(vec![0.1]), 1).unwrap();
let mut buffer = Vec::new();
assert!(
write_ply_points_to(&mut buffer, &points, &attrs, &PlyWriteOpts::default()).is_err()
);
}
#[test]
fn either_container_writes_identical_bytes() -> Result<()> {
let data = loaded_mesh();
let mesh = crate::Mesh3::from_data(data.clone(), false)?;
for binary in [true, false] {
let opts = PlyWriteOpts {
binary,
..Default::default()
};
let mut from_data = Vec::new();
write_ply_to(&mut from_data, &data, &opts)?;
let mut from_mesh = Vec::new();
write_ply_to(&mut from_mesh, &mesh, &opts)?;
assert_eq!(from_data, from_mesh, "binary = {binary}");
}
Ok(())
}
}