use std::any::Any;
use std::collections::BTreeSet;
use std::fmt;
use ferrocad_core::property_types;
use ferrocad_core::{ExtensionData, ExtensionValue, Placement, Property, Rotation, Vector3};
use ferrocad_geom::{ElementKind, ElementRef, History, Lineage, MapVersion, Shape};
pub const TYPE_NAME: &str = "Part::PropertyPartShape";
const MAGIC: &[u8; 8] = b"FCSHPROP";
const ENVELOPE_VERSION: u16 = 2;
pub struct ShapeProperty {
shape: Option<Shape>,
placement: Placement,
lineage: Lineage,
}
impl ShapeProperty {
pub fn empty() -> Self {
ShapeProperty {
shape: None,
placement: Placement::identity(),
lineage: Lineage::default(),
}
}
pub fn new(shape: Shape) -> Self {
Self::with_placement(shape, Placement::identity())
}
pub fn with_placement(shape: Shape, placement: Placement) -> Self {
ShapeProperty {
shape: Some(shape),
placement,
lineage: Lineage::default(),
}
}
pub fn with_lineage(shape: Shape, lineage: Lineage) -> Self {
ShapeProperty {
shape: Some(shape),
placement: Placement::identity(),
lineage,
}
}
pub fn with_lineage_and_placement(shape: Shape, placement: Placement, lineage: Lineage) -> Self {
ShapeProperty {
shape: Some(shape),
placement,
lineage,
}
}
pub fn shape(&self) -> Option<Shape> {
self.shape.clone()
}
pub fn placement(&self) -> Placement {
self.placement
}
pub fn set_shape(&mut self, shape: Shape) {
self.shape = Some(shape);
self.placement = Placement::identity();
self.lineage = Lineage::default();
}
pub fn lineage(&self) -> &Lineage {
&self.lineage
}
pub fn set_lineage(&mut self, lineage: Lineage) {
self.lineage = lineage;
}
pub fn clear(&mut self) {
self.shape = None;
self.placement = Placement::identity();
self.lineage = Lineage::default();
}
pub fn resolve_element(&self, name: &str) -> Result<Shape, ResolveElementError> {
let shape = self.shape.as_ref().ok_or(ResolveElementError::NoShape)?;
resolve_element_in(shape, &self.lineage, name)
}
fn brep(&self) -> Vec<u8> {
match self.shape.as_ref() {
Some(shape) => crate::backend().save_shape(shape),
None => Vec::new(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResolveElementError {
NoShape,
Retired,
Missing,
}
impl fmt::Display for ResolveElementError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NoShape => f.write_str("the property holds no shape"),
Self::Retired => f.write_str("the name is not in the shape's lineage"),
Self::Missing => f.write_str("the name does not exist on the shape"),
}
}
}
pub fn resolve_element_in(
shape: &Shape,
lineage: &Lineage,
name: &str,
) -> Result<Shape, ResolveElementError> {
if let Some(mapped) = lineage.map().get(name) {
return Ok(mapped.clone());
}
if !lineage.map().is_empty() {
return Err(ResolveElementError::Retired);
}
crate::backend()
.resolve(shape, name)
.ok_or(ResolveElementError::Missing)
}
pub(crate) fn kind_of_name(name: &str) -> Option<ElementKind> {
ElementKind::ALL.into_iter().find(|kind| {
name.strip_prefix(kind.prefix())
.is_some_and(|ordinal| ordinal.parse::<usize>().is_ok_and(|n| n >= 1))
})
}
pub(crate) fn positional_name(shape: &Shape, name: &str, sub: &Shape) -> Option<String> {
let kind = kind_of_name(name)?;
let backend = crate::backend();
backend
.elements(shape, kind)
.into_iter()
.find(|element| backend.same_shape(&element.shape, sub))
.map(|element| element.name)
}
impl ExtensionData for ShapeProperty {
fn type_name(&self) -> &str {
TYPE_NAME
}
fn clone_box(&self) -> Box<dyn ExtensionData> {
Box::new(ShapeProperty {
shape: self.shape.clone(),
placement: self.placement,
lineage: self.lineage.clone(),
})
}
fn as_any(&self) -> &dyn Any {
self
}
fn eq(&self, other: &dyn ExtensionData) -> bool {
let Some(other) = other.as_any().downcast_ref::<ShapeProperty>() else {
return false;
};
match (&self.shape, &other.shape) {
(None, None) => true,
(Some(x), Some(y)) => x.is_same(y),
_ => false,
}
}
fn save(&self) -> Vec<u8> {
let Some(shape) = self.shape.as_ref() else {
return Vec::new();
};
let backend = crate::backend();
let brep = backend.save_shape(shape);
if brep.is_empty() {
return Vec::new();
}
let mut out = Vec::with_capacity(64);
out.extend_from_slice(MAGIC);
put_u16(&mut out, ENVELOPE_VERSION);
put_bytes(&mut out, &brep);
out.extend_from_slice(&self.placement.base.x.to_le_bytes());
out.extend_from_slice(&self.placement.base.y.to_le_bytes());
out.extend_from_slice(&self.placement.base.z.to_le_bytes());
for component in self.placement.rotation.q {
out.extend_from_slice(&component.to_le_bytes());
}
let version = self.lineage.version();
put_u16(&mut out, version.encoding());
put_str(&mut out, version.policy());
match version.kernel() {
Some(kernel) => {
out.push(1);
put_str(&mut out, kernel);
}
None => out.push(0),
}
put_u64(&mut out, self.lineage.map().len() as u64);
for (name, sub_shape) in self.lineage.map().iter() {
put_str(&mut out, name);
put_bytes(&mut out, &backend.save_shape(sub_shape));
}
put_u64(&mut out, self.lineage.reverse().len() as u64);
for (output, inputs) in self.lineage.reverse().iter() {
put_str(&mut out, output);
put_u64(&mut out, inputs.len() as u64);
for input in inputs {
put_str(&mut out, input);
}
}
out
}
fn fcstd_members(&self) -> Option<Vec<(String, Vec<u8>)>> {
Some(vec![(String::new(), self.brep())])
}
fn fcstd_sidecar(&self) -> Option<(String, Vec<u8>)> {
let has_lineage = !self.lineage.map().is_empty() || !self.lineage.reverse().is_empty();
let has_placement = self.placement != Placement::identity();
if !has_lineage && !has_placement {
return None;
}
let bytes = self.save();
if bytes.is_empty() {
None
} else {
Some(("lineage".to_string(), bytes))
}
}
fn resolve_element_name(&self, name: &str) -> Result<Option<String>, &'static str> {
if kind_of_name(name).is_none() {
return Ok(None);
}
match self.resolve_element(name) {
Ok(_) => Ok(Some(name.to_string())),
Err(ResolveElementError::Retired) => Err("retired"),
Err(ResolveElementError::Missing | ResolveElementError::NoShape) => Err("missing"),
}
}
fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.shape.as_ref() {
Some(shape) => write!(
f,
"ShapeProperty({shape:?}, {} lineage entries)",
self.lineage.map().len()
),
None => f.write_str("ShapeProperty(empty)"),
}
}
}
pub fn make_shape_property(property: ShapeProperty) -> Property {
Property::Extension(ExtensionValue::new(Box::new(property)))
}
pub fn shape_of(property: &Property) -> Option<&ShapeProperty> {
match property {
Property::Extension(value) => value.data().as_any().downcast_ref::<ShapeProperty>(),
_ => None,
}
}
pub fn register() {
property_types::register_extension(
TYPE_NAME,
|| make_shape_property(ShapeProperty::empty()),
restore,
);
}
fn put_u16(out: &mut Vec<u8>, value: u16) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_u32(out: &mut Vec<u8>, value: u32) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_u64(out: &mut Vec<u8>, value: u64) {
out.extend_from_slice(&value.to_le_bytes());
}
fn put_bytes(out: &mut Vec<u8>, bytes: &[u8]) {
put_u64(out, bytes.len() as u64);
out.extend_from_slice(bytes);
}
fn put_str(out: &mut Vec<u8>, value: &str) {
put_u32(out, value.len() as u32);
out.extend_from_slice(value.as_bytes());
}
struct Reader<'a> {
rest: &'a [u8],
}
impl<'a> Reader<'a> {
fn new(rest: &'a [u8]) -> Self {
Reader { rest }
}
fn take(&mut self, count: usize) -> Option<&'a [u8]> {
if self.rest.len() < count {
return None;
}
let (head, tail) = self.rest.split_at(count);
self.rest = tail;
Some(head)
}
fn u8(&mut self) -> Option<u8> {
Some(self.take(1)?[0])
}
fn u16(&mut self) -> Option<u16> {
let bytes: [u8; 2] = self.take(2)?.try_into().ok()?;
Some(u16::from_le_bytes(bytes))
}
fn u32(&mut self) -> Option<u32> {
let bytes: [u8; 4] = self.take(4)?.try_into().ok()?;
Some(u32::from_le_bytes(bytes))
}
fn u64(&mut self) -> Option<u64> {
let bytes: [u8; 8] = self.take(8)?.try_into().ok()?;
Some(u64::from_le_bytes(bytes))
}
fn f64(&mut self) -> Option<f64> {
let bytes: [u8; 8] = self.take(8)?.try_into().ok()?;
Some(f64::from_le_bytes(bytes))
}
fn bytes(&mut self) -> Option<&'a [u8]> {
let len = usize::try_from(self.u64()?).ok()?;
self.take(len)
}
fn string(&mut self) -> Option<String> {
let len = usize::try_from(self.u32()?).ok()?;
String::from_utf8(self.take(len)?.to_vec()).ok()
}
fn is_empty(&self) -> bool {
self.rest.is_empty()
}
}
fn restore(bytes: &[u8]) -> Option<Box<dyn ExtensionData>> {
if bytes.is_empty() {
return Some(Box::new(ShapeProperty::empty()));
}
if bytes.len() >= MAGIC.len() && &bytes[..MAGIC.len()] == MAGIC {
return restore_envelope(bytes).map(|property| Box::new(property) as Box<dyn ExtensionData>);
}
let shape = crate::backend().load_shape(bytes)?;
Some(Box::new(ShapeProperty::new(shape)))
}
const ENVELOPE_VERSION_MIN: u16 = 1;
fn restore_envelope(bytes: &[u8]) -> Option<ShapeProperty> {
let mut reader = Reader::new(&bytes[MAGIC.len()..]);
let version = reader.u16()?;
if !(ENVELOPE_VERSION_MIN..=ENVELOPE_VERSION).contains(&version) {
return None;
}
let backend = crate::backend();
let shape = backend.load_shape(reader.bytes()?)?;
let placement = if version >= 2 {
let base = Vector3::new(reader.f64()?, reader.f64()?, reader.f64()?);
let q = [reader.f64()?, reader.f64()?, reader.f64()?, reader.f64()?];
Placement {
base,
rotation: Rotation { q, raw_axis: None },
}
} else {
Placement::identity()
};
let encoding = reader.u16()?;
let policy = reader.string()?;
let kernel = match reader.u8()? {
0 => None,
1 => Some(reader.string()?),
_ => return None,
};
let forward_count = reader.u64()?;
let mut entries = Vec::new();
for _ in 0..forward_count {
let name = reader.string()?;
let sub_shape = backend.load_shape(reader.bytes()?)?;
entries.push((name, sub_shape));
}
let reverse_count = reader.u64()?;
let mut reverse = Vec::new();
for _ in 0..reverse_count {
let output = reader.string()?;
let input_count = reader.u64()?;
let mut inputs = Vec::new();
for _ in 0..input_count {
inputs.push(reader.string()?);
}
reverse.push((output, inputs));
}
if !reader.is_empty() {
return None;
}
Some(ShapeProperty {
shape: Some(shape),
placement,
lineage: rebuild_lineage(
MapVersion::new(encoding, policy, kernel),
&entries,
&reverse,
),
})
}
fn rebuild_lineage(
version: MapVersion,
entries: &[(String, Shape)],
reverse: &[(String, Vec<String>)],
) -> Lineage {
let mut lineage = Lineage::new(version);
if entries.is_empty() {
return lineage;
}
let mut bind = History::default();
let mut retire = History::default();
for (index, (name, sub_shape)) in entries.iter().enumerate() {
let placeholder = format!("\u{1}ferrocad-lineage-{index}");
bind.modified.push((
ElementRef {
shape: sub_shape.clone(),
name: name.clone(),
},
ElementRef {
shape: sub_shape.clone(),
name: placeholder.clone(),
},
));
retire.deleted.push(ElementRef {
shape: sub_shape.clone(),
name: placeholder,
});
}
lineage.apply(&bind);
lineage.apply(&retire);
let bound: BTreeSet<&str> = entries.iter().map(|(name, _)| name.as_str()).collect();
let anchor = entries[0].1.clone();
let mut replay = History::default();
for (output, inputs) in reverse {
for input in inputs {
if !bound.contains(input.as_str()) {
continue;
}
replay.modified.push((
ElementRef {
shape: anchor.clone(),
name: input.clone(),
},
ElementRef {
shape: anchor.clone(),
name: output.clone(),
},
));
}
}
lineage.apply(&replay);
lineage
}
#[cfg(test)]
mod tests {
use super::*;
use ferrocad_core::{Document, ObjectId, Property};
use ferrocad_occt::OcctBackend;
use std::sync::Arc;
fn setup() {
crate::register(Arc::new(OcctBackend::new()));
}
fn cut_document() -> (Document, ObjectId) {
let mut doc = Document::new();
for name in ["BoxA", "BoxB"] {
let id = doc.add_object(name, crate::BOX_TYPE);
let size = if name == "BoxA" { 2.0 } else { 1.0 };
doc.set_property(id, "Length", Property::Float(size)).unwrap();
doc.set_property(id, "Width", Property::Float(size)).unwrap();
doc.set_property(id, "Height", Property::Float(size)).unwrap();
}
doc.recompute().unwrap();
let cut = doc.add_object("Cut", crate::CUT_TYPE);
doc.set_property(cut, "Base", Property::Link("BoxA".into()))
.unwrap();
doc.set_property(cut, "Tool", Property::Link("BoxB".into()))
.unwrap();
doc.recompute().unwrap();
(doc, cut)
}
fn stored_shape_property(doc: &Document, id: ObjectId) -> &ShapeProperty {
shape_of(doc.object(id).unwrap().properties.get("Shape").unwrap())
.expect("the object owns a Part::PropertyPartShape")
}
fn temp_path(name: &str) -> std::path::PathBuf {
std::env::temp_dir().join(format!(
"ferrocad-part-shape-property-{}-{name}",
std::process::id()
))
}
fn box_and_edges(size: f64) -> (Shape, Vec<ElementRef>) {
let shape = crate::make_box(size, size, size).unwrap();
let edges = crate::backend().elements(&shape, ElementKind::Edge);
(shape, edges)
}
fn lineage_binding(name: &str, target: &ElementRef) -> Lineage {
let mut history = History::default();
history.modified.push((
ElementRef {
shape: target.shape.clone(),
name: name.to_string(),
},
target.clone(),
));
Lineage::from_history(&history, MapVersion::default())
}
#[test]
fn a_mapped_name_resolves_to_the_mapped_edge() {
setup();
let (shape, edges) = box_and_edges(10.0);
let mapped = edges[4].clone();
let property = ShapeProperty::with_lineage(shape, lineage_binding("Edge1", &mapped));
let resolved = property.resolve_element("Edge1").expect("Edge1 resolves");
assert!(
crate::backend().same_shape(&resolved, &mapped.shape),
"the mapped edge is chosen"
);
assert!(
!crate::backend().same_shape(&resolved, &edges[0].shape),
"not the edge its ordinal names"
);
}
#[test]
fn without_a_lineage_a_name_resolves_positionally() {
setup();
let (shape, edges) = box_and_edges(10.0);
let property = ShapeProperty::new(shape);
assert!(property.lineage().map().is_empty());
let resolved = property.resolve_element("Edge1").expect("Edge1 resolves");
assert!(
crate::backend().same_shape(&resolved, &edges[0].shape),
"the first edge is chosen"
);
assert_eq!(
property.resolve_element("Edge99").err(),
Some(ResolveElementError::Missing),
"a name no edge has does not resolve"
);
}
#[test]
fn a_lineage_without_the_name_does_not_retarget() {
setup();
let (shape, edges) = box_and_edges(10.0);
let property = ShapeProperty::with_lineage(shape, lineage_binding("Edge2", &edges[4]));
assert!(!property.lineage().map().is_empty());
assert_eq!(
property.resolve_element("Edge1").err(),
Some(ResolveElementError::Retired),
"a name the map does not justify fails instead of moving"
);
assert_eq!(
property.resolve_element("Edge99").err(),
Some(ResolveElementError::Retired),
"an unknown name fails the same way"
);
let mapped = property.resolve_element("Edge2").expect("Edge2 resolves");
assert!(
crate::backend().same_shape(&mapped, &edges[4].shape),
"the mapped name still works"
);
}
#[test]
fn an_empty_property_resolves_nothing() {
setup();
assert_eq!(
ShapeProperty::empty().resolve_element("Edge1").err(),
Some(ResolveElementError::NoShape)
);
}
#[test]
fn the_extension_hook_answers_only_element_names() {
setup();
let (shape, edges) = box_and_edges(10.0);
let primitive = ShapeProperty::new(shape);
assert_eq!(
primitive.resolve_element_name("Edge1"),
Ok(Some("Edge1".to_string()))
);
assert!(primitive.resolve_element_name("Edge99").is_err());
assert_eq!(primitive.resolve_element_name("N_Axis"), Ok(None));
let property = ShapeProperty::with_lineage(
primitive.shape().unwrap(),
lineage_binding("Edge2", &edges[4]),
);
assert!(property.resolve_element_name("Edge2").is_ok());
assert!(property.resolve_element_name("Edge1").is_err());
}
#[test]
fn fcstd_round_trip_preserves_the_lineage() {
setup();
let (doc, cut) = cut_document();
let original = stored_shape_property(&doc, cut);
assert!(
!original.lineage().map().is_empty(),
"a cut carries forward relations"
);
assert!(
!original.lineage().reverse().is_empty(),
"a cut carries reverse relations"
);
let original_reverse = original.lineage().reverse().clone();
let original_version = original.lineage().version().clone();
let original_names: Vec<String> = original
.lineage()
.map()
.iter()
.map(|(name, _)| name.to_string())
.collect();
let saved = doc.to_saved("LineageRoundTrip");
let path = temp_path("lineage.FCStd");
ferrocad_core::fcstd_write::write_fcstd(&saved, path.to_str().unwrap())
.expect("write .FCStd");
let read = ferrocad_core::fcstd::read_fcstd(path.to_str().unwrap())
.expect("read back .FCStd");
let _ = std::fs::remove_file(&path);
let restored = read
.objects
.iter()
.find(|object| object.name == "Cut")
.and_then(|object| object.properties.get("Shape"))
.and_then(shape_of)
.expect("Cut.Shape is restored");
assert_eq!(restored.lineage().reverse(), &original_reverse);
assert_eq!(restored.lineage().version(), &original_version);
let restored_names: Vec<String> = restored
.lineage()
.map()
.iter()
.map(|(name, _)| name.to_string())
.collect();
assert_eq!(restored_names, original_names);
let properties = |shape: &Shape| {
crate::backend()
.mass_properties(shape)
.expect("a lineage sub-shape has mass properties")
};
for (name, sub_shape) in original.lineage().map().iter() {
let restored_sub = restored
.lineage()
.map()
.get(name)
.unwrap_or_else(|| panic!("'{name}' survives the round trip"));
let before = properties(sub_shape);
let after = properties(restored_sub);
let same = |a: f64, b: f64| (a - b).abs() < 1e-9;
assert!(
same(before.length, after.length)
&& same(before.area, after.area)
&& same(before.volume, after.volume)
&& same(before.center_of_mass.x, after.center_of_mass.x)
&& same(before.center_of_mass.y, after.center_of_mass.y)
&& same(before.center_of_mass.z, after.center_of_mass.z),
"'{name}' maps to the same element"
);
}
}
#[test]
fn an_fcstd_without_a_sidecar_still_loads_the_geometry() {
setup();
let (mut doc, cut) = cut_document();
let shape = stored_shape_property(&doc, cut)
.shape()
.expect("the cut produced a shape");
let volume = crate::backend()
.mass_properties(&shape)
.expect("the cut has mass properties")
.volume;
doc.set_property_raw(
cut,
"Shape",
make_shape_property(ShapeProperty::new(shape)),
);
let saved = doc.to_saved("LegacyRoundTrip");
let path = temp_path("legacy.FCStd");
ferrocad_core::fcstd_write::write_fcstd(&saved, path.to_str().unwrap())
.expect("write .FCStd");
let read = ferrocad_core::fcstd::read_fcstd(path.to_str().unwrap())
.expect("read back .FCStd");
let _ = std::fs::remove_file(&path);
let restored = read
.objects
.iter()
.find(|object| object.name == "Cut")
.and_then(|object| object.properties.get("Shape"))
.and_then(shape_of)
.expect("Cut.Shape is restored");
assert!(restored.lineage().map().is_empty());
assert!(restored.lineage().reverse().is_empty());
let restored_shape = restored.shape().expect("the BREP payload survives");
let restored_volume = crate::backend()
.mass_properties(&restored_shape)
.expect("the restored cut has mass properties")
.volume;
assert!((restored_volume - volume).abs() < 1e-6, "geometry is intact");
}
#[test]
fn the_envelope_round_trips_the_placement() {
setup();
let shape = crate::make_box(2.0, 2.0, 2.0).unwrap();
let placement = Placement::new(
Vector3::new(1.0, 2.0, 3.0),
Rotation::from_axis_angle(&Vector3::new(0.0, 0.0, 1.0), 0.5),
);
let property = ShapeProperty::with_placement(shape, placement);
let bytes = property.save();
let restored = restore(&bytes).expect("the envelope restores");
let restored = restored
.as_any()
.downcast_ref::<ShapeProperty>()
.expect("a ShapeProperty");
assert!(
restored.placement().is_same(&placement, 1e-12),
"the placement is restored"
);
let volume = crate::backend()
.mass_properties(&property.shape().unwrap())
.expect("the original has mass properties")
.volume;
let restored_volume = crate::backend()
.mass_properties(&restored.shape().unwrap())
.expect("the restored shape has mass properties")
.volume;
assert!((volume - restored_volume).abs() < 1e-9, "geometry is intact");
}
#[test]
fn a_version_1_envelope_still_loads() {
setup();
let shape = crate::make_box(3.0, 3.0, 3.0).unwrap();
let mut bytes = Vec::new();
bytes.extend_from_slice(MAGIC);
put_u16(&mut bytes, 1);
put_bytes(&mut bytes, &crate::backend().save_shape(&shape));
put_u16(&mut bytes, MapVersion::default().encoding());
put_str(&mut bytes, MapVersion::default().policy());
bytes.push(0); put_u64(&mut bytes, 0); put_u64(&mut bytes, 0);
let restored = restore(&bytes).expect("v1 restores");
let restored = restored
.as_any()
.downcast_ref::<ShapeProperty>()
.expect("a ShapeProperty");
assert!(restored.shape().is_some(), "geometry survives");
assert_eq!(restored.placement(), Placement::identity());
assert!(restored.lineage().map().is_empty());
}
}