use std::collections::{HashMap, HashSet};
use std::fmt;
use std::iter::FusedIterator;
use super::assembly::context_dependent_shape_representations;
use super::{Graph, Placement, ProductStructure, Usage, UsageKind};
use crate::geometry::{Axis2Placement3d, GeometryError, GeometryErrorKind, Reader, Rigid};
use crate::p21::{Exchange, Param};
use crate::policy::MAX_ASSEMBLY_DEPTH;
use crate::record;
use crate::units::UnitError;
const RRWT: &str = "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION";
const MORE_THAN_ONE_LINK: &str =
"the usage has more than one context_dependent_shape_representation";
const REPEATED: &str = "a partial entity is repeated, so its attributes are stated twice";
const UNDEFINED: &str = "refers to an instance that is not defined";
const RELATIONSHIP_LAYOUT: &str =
"not a representation_relationship with the attributes the schema gives it";
const NOT_A_REFERENCE: &str = "rep_1, rep_2 or transformation_operator is not a reference";
const SIDES: &str = "rep_1 and rep_2 are not one of the component's shape representations and \
one of the assembly's";
const TRANSFORMATION_LAYOUT: &str =
"not an item_defined_transformation with two transform items, as the schema gives it";
const NOT_A_REPRESENTATION: &str = "cannot be read as a representation";
const ITEM_1: &str = "transform_item_1 is not an item of rep_1";
const ITEM_2: &str = "transform_item_2 is not an item of rep_2";
const MAPPED_ITEM_LAYOUT: &str =
"not a mapped_item with a mapping source and target, as the schema gives it";
const NOT_HELD: &str = "no shape representation of the assembly lists the mapped item";
const HELD_TWICE: &str = "more than one shape representation of the assembly lists the mapped \
item, so the context of its target is not certain";
const SHARED_MAPPED_ITEM: &str = "the mapped item places more than one usage, so which one \
it places is not certain";
const MAP_LAYOUT: &str =
"not a representation_map with an origin and a representation, as the schema gives it";
const NOT_THE_COMPONENT: &str = "maps no shape representation of the component";
const CHANGES_REPRESENTATION: &str = "the assembly is placed through one of its shape \
representations and holds this component in another";
const AMBIGUOUS_ROOT: &str =
"the root's usages place its components in different shape representations of it";
#[derive(Debug, Clone)]
pub struct Placements<'s> {
structure: &'s ProductStructure,
usages: Vec<UsageRead>,
}
#[derive(Debug, Clone)]
struct UsageRead {
sides: Option<Sides>,
result: Result<Placed, PlacementError>,
}
#[derive(Debug, Clone, Copy)]
struct Sides {
component: u64,
assembly: u64,
}
#[derive(Debug, Clone)]
struct Placed {
transform: Rigid,
overflow: PlacementError,
}
impl<'s> Placements<'s> {
pub fn new(graph: &Graph<'_>, structure: &'s ProductStructure) -> Self {
let mut frames = Frames {
graph,
readers: HashMap::new(),
items: HashMap::new(),
};
let mut usages: Vec<UsageRead> = structure
.usages()
.iter()
.map(|usage| read_usage(&mut frames, structure, usage))
.collect();
refuse_shared_mapped_items(structure, &mut usages);
Self { structure, usages }
}
pub fn usage(&self, usage: usize) -> Result<Rigid, PlacementError> {
self.usages[usage]
.result
.as_ref()
.map(|placed| placed.transform)
.map_err(Clone::clone)
}
pub fn occurrences(&self, root: usize) -> Occurrences<'_> {
let space = self.root_space(root);
Occurrences {
placements: self,
root: Some(Occurrence {
path: Vec::new(),
definition: root,
representation: space.representation(),
transform: Ok(Rigid::IDENTITY),
}),
stack: vec![Level {
definition: root,
transform: Ok(Rigid::IDENTITY),
space,
next: 0,
}],
path: Vec::new(),
on_path: HashSet::from([root]),
}
}
fn root_space(&self, root: usize) -> Space {
let mut named: Option<u64> = None;
for &index in self.structure.child_usages(root) {
let Some(sides) = self.usages[index].sides else {
continue;
};
match named {
Some(representation) if representation != sides.assembly => {
return Space::Ambiguous;
}
_ => named = Some(sides.assembly),
}
}
match (
named,
self.structure.definitions()[root]
.shape_representations
.as_slice(),
) {
(Some(representation), _) | (None, &[representation]) => Space::Of(representation),
_ => Space::Unknown,
}
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub struct Occurrence {
pub path: Vec<usize>,
pub definition: usize,
pub representation: Option<u64>,
#[cfg_attr(feature = "serde", serde(serialize_with = "outcome"))]
pub transform: Result<Rigid, PlacementError>,
}
#[cfg(feature = "serde")]
fn outcome<S: serde::Serializer>(
result: &Result<Rigid, PlacementError>,
serializer: S,
) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(Some(1))?;
match result {
Ok(transform) => map.serialize_entry("ok", transform)?,
Err(error) => map.serialize_entry("error", error)?,
}
map.end()
}
#[derive(Debug, Clone)]
pub struct Occurrences<'p> {
placements: &'p Placements<'p>,
root: Option<Occurrence>,
stack: Vec<Level>,
path: Vec<usize>,
on_path: HashSet<usize>,
}
#[derive(Debug, Clone)]
struct Level {
definition: usize,
transform: Result<Rigid, PlacementError>,
space: Space,
next: usize,
}
#[derive(Debug, Clone, Copy)]
enum Space {
Of(u64),
Unknown,
Ambiguous,
}
impl Space {
fn representation(self) -> Option<u64> {
match self {
Self::Of(representation) => Some(representation),
Self::Unknown | Self::Ambiguous => None,
}
}
}
impl Iterator for Occurrences<'_> {
type Item = Occurrence;
fn next(&mut self) -> Option<Occurrence> {
if let Some(root) = self.root.take() {
return Some(root);
}
let Self {
placements,
stack,
path,
on_path,
..
} = self;
loop {
let top = stack.last_mut()?;
let Some(&index) = placements
.structure
.child_usages(top.definition)
.get(top.next)
else {
let done = stack.pop()?;
on_path.remove(&done.definition);
if !stack.is_empty() {
path.pop();
}
continue;
};
top.next += 1;
let usage = &placements.structure.usages()[index];
let read = &placements.usages[index];
path.push(index);
let (transform, descend) = if on_path.contains(&usage.child) {
(
Err(PlacementError::Cycle {
usage: usage.instance,
}),
false,
)
} else if path.len() > MAX_ASSEMBLY_DEPTH {
(
Err(PlacementError::TooDeep {
usage: usage.instance,
}),
false,
)
} else {
(compose(&top.transform, top.space, usage, read), true)
};
let representation = read.sides.map(|sides| sides.component);
let occurrence = Occurrence {
path: path.clone(),
definition: usage.child,
representation,
transform: transform.clone(),
};
if descend {
on_path.insert(usage.child);
stack.push(Level {
definition: usage.child,
transform,
space: representation.map_or(Space::Unknown, Space::Of),
next: 0,
});
} else {
path.pop();
}
return Some(occurrence);
}
}
}
impl FusedIterator for Occurrences<'_> {}
fn compose(
parent: &Result<Rigid, PlacementError>,
space: Space,
usage: &Usage,
read: &UsageRead,
) -> Result<Rigid, PlacementError> {
let parent = parent.as_ref().map_err(Clone::clone)?;
let placed = read.result.as_ref().map_err(Clone::clone)?;
if let Some(sides) = read.sides {
let reason = match space {
Space::Of(representation) if representation != sides.assembly => {
Some(CHANGES_REPRESENTATION)
}
Space::Ambiguous => Some(AMBIGUOUS_ROOT),
Space::Of(_) | Space::Unknown => None,
};
if let Some(reason) = reason {
return Err(PlacementError::Inconsistent {
usage: usage.instance,
instance: sides.assembly,
reason,
});
}
}
let transform = *parent * placed.transform;
if is_finite(&transform) {
Ok(transform)
} else {
Err(placed.overflow.clone())
}
}
pub(super) fn is_finite(transform: &Rigid) -> bool {
transform
.rotation
.iter()
.flatten()
.chain(&transform.translation)
.all(|value| value.is_finite())
}
struct Frames<'g, 'a> {
graph: &'g Graph<'a>,
readers: HashMap<u64, Result<Reader<'g, 'a>, UnitError>>,
items: HashMap<u64, Option<HashSet<u64>>>,
}
impl Frames<'_, '_> {
fn items(&mut self, representation: u64) -> Option<&HashSet<u64>> {
let exchange = self.graph.exchange();
self.items
.entry(representation)
.or_insert_with(|| {
record::representation(exchange, representation)
.ok()
.map(|read| read.items.into_iter().collect())
})
.as_ref()
}
fn read(
&mut self,
usage: u64,
item: u64,
representation: u64,
) -> Result<Axis2Placement3d, PlacementError> {
let graph = self.graph;
let exchange = graph.exchange();
if let Some(instance) = exchange.get(item) {
let is_frame = !instance.is_complex()
&& exchange
.records(instance)
.next()
.is_some_and(|record| record.is("AXIS2_PLACEMENT_3D"));
if !is_frame {
return Err(unsupported(exchange, usage, item));
}
}
let reader = self
.readers
.entry(representation)
.or_insert_with(|| Reader::for_representation(graph, representation));
let reader = match reader {
Ok(reader) => reader,
Err(error) => {
return Err(PlacementError::Frame {
usage,
error: GeometryError {
instance: item,
entity: entity(exchange, item),
attribute: None,
kind: GeometryErrorKind::Unit(error.clone()),
},
});
}
};
let frame = reader
.axis2_placement_3d(item)
.map_err(|error| PlacementError::Frame { usage, error })?;
#[expect(
clippy::float_cmp,
reason = "Open CASCADE and the schema build the same x only for an axis of exactly +Z"
)]
let plus_z = frame.z == [0.0, 0.0, 1.0];
if !frame.ref_direction_stated && !plus_z {
return Err(PlacementError::Divergent {
usage,
instance: item,
reason: DivergentReason::DefaultedRefDirection,
});
}
Ok(frame)
}
}
fn read_usage(
frames: &mut Frames<'_, '_>,
structure: &ProductStructure,
usage: &Usage,
) -> UsageRead {
let definitions = structure.definitions();
let mut reading = Reading {
frames,
usage: usage.instance,
component_shapes: &definitions[usage.child].shape_representations,
assembly_shapes: &definitions[usage.parent].shape_representations,
sides: None,
};
let result = match &usage.placement {
None => Err(PlacementError::Unplaced {
usage: usage.instance,
}),
Some(Placement::ShapeRelationship { relationship, .. }) => {
reading.shape_relationship(*relationship)
}
Some(Placement::MappedItem { mapped_item, .. }) => reading.mapped_item(*mapped_item),
};
let sides = reading.sides;
UsageRead {
sides,
result: match quantity_refusal(usage) {
Some(refusal) => Err(refusal),
None => result,
},
}
}
fn refuse_shared_mapped_items(structure: &ProductStructure, usages: &mut [UsageRead]) {
let mapped_item = |usage: &Usage| match usage.placement {
Some(Placement::MappedItem { mapped_item, .. }) => Some(mapped_item),
_ => None,
};
let mut claims: HashMap<u64, usize> = HashMap::new();
for item in structure.usages().iter().filter_map(mapped_item) {
*claims.entry(item).or_default() += 1;
}
for (usage, read) in structure.usages().iter().zip(usages) {
let Some(item) = mapped_item(usage) else {
continue;
};
if claims.get(&item).is_some_and(|&count| count > 1) && read.result.is_ok() {
read.result = Err(PlacementError::Inconsistent {
usage: usage.instance,
instance: item,
reason: SHARED_MAPPED_ITEM,
});
}
}
}
fn quantity_refusal(usage: &Usage) -> Option<PlacementError> {
if usage.kind != UsageKind::QuantifiedAssemblyComponentUsage {
return None;
}
let one = usage.quantity == Some(1.0);
(!one).then_some(PlacementError::Quantified {
usage: usage.instance,
quantity: usage.quantity,
})
}
struct Reading<'r, 'g, 'a> {
frames: &'r mut Frames<'g, 'a>,
usage: u64,
component_shapes: &'r [u64],
assembly_shapes: &'r [u64],
sides: Option<Sides>,
}
struct Relationship {
rep_1: u64,
rep_2: u64,
transformation: Option<u64>,
}
impl<'g, 'a> Reading<'_, 'g, 'a> {
fn exchange(&self) -> &'g Exchange<'a> {
self.frames.graph.exchange()
}
fn inconsistent(&self, instance: u64, reason: &'static str) -> PlacementError {
PlacementError::Inconsistent {
usage: self.usage,
instance,
reason,
}
}
fn shape_relationship(&mut self, relationship: u64) -> Result<Placed, PlacementError> {
let graph = self.frames.graph;
let node = graph
.node(self.usage)
.ok_or_else(|| self.inconsistent(self.usage, UNDEFINED))?;
if let [_, second, ..] = context_dependent_shape_representations(graph, node).as_slice() {
return Err(self.inconsistent(*second, MORE_THAN_ONE_LINK));
}
let Relationship {
rep_1,
rep_2,
transformation,
} = self.relationship(relationship)?;
let normal =
self.component_shapes.contains(&rep_1) && self.assembly_shapes.contains(&rep_2);
let reversed =
self.component_shapes.contains(&rep_2) && self.assembly_shapes.contains(&rep_1);
if normal == reversed {
return Err(self.inconsistent(relationship, SIDES));
}
self.sides = Some(if normal {
Sides {
component: rep_1,
assembly: rep_2,
}
} else {
Sides {
component: rep_2,
assembly: rep_1,
}
});
let transformation = transformation.ok_or(PlacementError::NoTransformation {
usage: self.usage,
relationship,
})?;
let [item_1, item_2] = self.item_defined_transformation(relationship, transformation)?;
self.listed(item_1, rep_1, ITEM_1)?;
self.listed(item_2, rep_2, ITEM_2)?;
let frame_1 = self.frames.read(self.usage, item_1, rep_1)?;
let frame_2 = self.frames.read(self.usage, item_2, rep_2)?;
if !frame_1.to_rigid().is_identity() && !frame_2.to_rigid().is_identity() {
return Err(PlacementError::Divergent {
usage: self.usage,
instance: transformation,
reason: DivergentReason::BothFramesPlaced,
});
}
if normal {
self.placed(&frame_2, &frame_1)
} else {
self.placed(&frame_1, &frame_2)
}
}
fn relationship(&self, id: u64) -> Result<Relationship, PlacementError> {
let exchange = self.exchange();
let instance = exchange
.get(id)
.ok_or_else(|| self.inconsistent(id, UNDEFINED))?;
if record::repeats_partial(exchange, instance) {
return Err(self.inconsistent(id, REPEATED));
}
let layout = || self.inconsistent(id, RELATIONSHIP_LAYOUT);
let (base, transformation): (Vec<Param<'_>>, Option<Param<'_>>) = if instance.is_complex() {
let base = record::partial(exchange, instance, "REPRESENTATION_RELATIONSHIP")
.and_then(|r| record::exact_params(r, 4))
.ok_or_else(layout)?;
let transformation = match record::partial(exchange, instance, RRWT) {
None => None,
Some(r) => Some(
record::exact_params(r, 1)
.and_then(|params| params.into_iter().next())
.ok_or_else(layout)?,
),
};
(base, transformation)
} else {
let record = exchange.records(instance).next().ok_or_else(layout)?;
if record.is(RRWT) {
let mut params = record::exact_params(record, 5).ok_or_else(layout)?;
let transformation = params.pop();
(params, transformation)
} else if record::upper(record.name()).ends_with("REPRESENTATION_RELATIONSHIP") {
(record::exact_params(record, 4).ok_or_else(layout)?, None)
} else {
return Err(unsupported(exchange, self.usage, id));
}
};
let reference = |param: &Param<'_>| {
param
.reference()
.ok_or_else(|| self.inconsistent(id, NOT_A_REFERENCE))
};
Ok(Relationship {
rep_1: reference(&base[2])?,
rep_2: reference(&base[3])?,
transformation: transformation.as_ref().map(reference).transpose()?,
})
}
fn item_defined_transformation(
&self,
relationship: u64,
id: u64,
) -> Result<[u64; 2], PlacementError> {
let exchange = self.exchange();
let instance = exchange
.get(id)
.ok_or_else(|| self.inconsistent(relationship, UNDEFINED))?;
let record = if instance.is_complex() {
None
} else {
exchange
.records(instance)
.next()
.filter(|record| record.is("ITEM_DEFINED_TRANSFORMATION"))
};
let Some(record) = record else {
return Err(unsupported(exchange, self.usage, id));
};
let params = record::exact_params(record, 4)
.ok_or_else(|| self.inconsistent(id, TRANSFORMATION_LAYOUT))?;
let item = |param: &Param<'_>| {
param
.reference()
.ok_or_else(|| self.inconsistent(id, TRANSFORMATION_LAYOUT))
};
Ok([item(¶ms[2])?, item(¶ms[3])?])
}
fn listed(
&mut self,
item: u64,
representation: u64,
reason: &'static str,
) -> Result<(), PlacementError> {
match self.frames.items(representation) {
None => Err(self.inconsistent(representation, NOT_A_REPRESENTATION)),
Some(items) if items.contains(&item) => Ok(()),
Some(_) => Err(self.inconsistent(item, reason)),
}
}
fn mapped_item(&mut self, item: u64) -> Result<Placed, PlacementError> {
let exchange = self.exchange();
let instance = exchange
.get(item)
.ok_or_else(|| self.inconsistent(item, UNDEFINED))?;
if record::repeats_partial(exchange, instance) {
return Err(self.inconsistent(item, REPEATED));
}
let params = if instance.is_complex() {
let other = exchange.records(instance).any(|record| {
![
"MAPPED_ITEM",
"REPRESENTATION_ITEM",
"GEOMETRIC_REPRESENTATION_ITEM",
]
.iter()
.any(|name| record.is(name))
});
if other {
return Err(unsupported(exchange, self.usage, item));
}
record::partial(exchange, instance, "MAPPED_ITEM")
.and_then(|record| record::exact_params(record, 2))
} else {
exchange
.records(instance)
.next()
.filter(|record| record.is("MAPPED_ITEM"))
.and_then(|record| record::exact_params(record, 3))
.map(|params| params[1..].to_vec())
}
.ok_or_else(|| self.inconsistent(item, MAPPED_ITEM_LAYOUT))?;
let (Some(map), Some(target)) = (params[0].reference(), params[1].reference()) else {
return Err(self.inconsistent(item, MAPPED_ITEM_LAYOUT));
};
let mut holders: Vec<u64> = Vec::new();
for &representation in self.assembly_shapes {
if self
.frames
.items(representation)
.is_some_and(|items| items.contains(&item))
{
holders.push(representation);
}
}
holders.sort_unstable();
holders.dedup();
let holder = match holders.as_slice() {
[holder] => *holder,
[] => return Err(self.inconsistent(item, NOT_HELD)),
_ => return Err(self.inconsistent(item, HELD_TWICE)),
};
let map_instance = exchange
.get(map)
.ok_or_else(|| self.inconsistent(item, UNDEFINED))?;
let map_record = if map_instance.is_complex() {
None
} else {
exchange
.records(map_instance)
.next()
.filter(|record| record.is("REPRESENTATION_MAP"))
};
let Some(map_record) = map_record else {
return Err(unsupported(exchange, self.usage, map));
};
let map_params = record::exact_params(map_record, 2)
.ok_or_else(|| self.inconsistent(map, MAP_LAYOUT))?;
let (Some(origin), Some(mapped)) = (map_params[0].reference(), map_params[1].reference())
else {
return Err(self.inconsistent(map, MAP_LAYOUT));
};
if !self.component_shapes.contains(&mapped) {
return Err(self.inconsistent(map, NOT_THE_COMPONENT));
}
self.sides = Some(Sides {
component: mapped,
assembly: holder,
});
let origin = self.frames.read(self.usage, origin, mapped)?;
let target = self.frames.read(self.usage, target, holder)?;
self.placed(&target, &origin)
}
fn placed(
&self,
assembly: &Axis2Placement3d,
component: &Axis2Placement3d,
) -> Result<Placed, PlacementError> {
placed(self.exchange(), self.usage, assembly, component)
}
}
fn placed(
exchange: &Exchange<'_>,
usage: u64,
assembly: &Axis2Placement3d,
component: &Axis2Placement3d,
) -> Result<Placed, PlacementError> {
let inverse = component.to_rigid().inverse();
if !is_finite(&inverse) {
return Err(not_finite(exchange, usage, component.instance));
}
let transform = assembly.to_rigid() * inverse;
if !is_finite(&transform) {
return Err(not_finite(exchange, usage, assembly.instance));
}
Ok(Placed {
transform,
overflow: not_finite(exchange, usage, assembly.instance),
})
}
pub(super) fn not_finite(exchange: &Exchange<'_>, usage: u64, frame: u64) -> PlacementError {
PlacementError::Frame {
usage,
error: GeometryError {
instance: frame,
entity: entity(exchange, frame),
attribute: Some("location"),
kind: GeometryErrorKind::NotFinite,
},
}
}
pub(super) fn mapped_item_transform(
graph: &Graph<'_>,
mapped_item: u64,
(origin, origin_representation): (u64, u64),
(target, target_representation): (u64, u64),
) -> Result<Rigid, PlacementError> {
let mut frames = Frames {
graph,
readers: HashMap::new(),
items: HashMap::new(),
};
let origin = frames.read(mapped_item, origin, origin_representation)?;
let target = frames.read(mapped_item, target, target_representation)?;
placed(graph.exchange(), mapped_item, &target, &origin).map(|placed| placed.transform)
}
fn entity(exchange: &Exchange<'_>, id: u64) -> String {
exchange
.get(id)
.map(|instance| record::entity(exchange, instance))
.unwrap_or_default()
}
fn unsupported(exchange: &Exchange<'_>, usage: u64, instance: u64) -> PlacementError {
PlacementError::Unsupported {
usage,
instance,
entity: entity(exchange, instance),
}
}
#[derive(Debug, Clone, PartialEq, thiserror::Error)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "kind", rename_all = "snake_case"))]
#[non_exhaustive]
pub enum PlacementError {
Unplaced {
usage: u64,
},
Quantified {
usage: u64,
quantity: Option<f64>,
},
NoTransformation {
usage: u64,
relationship: u64,
},
Unsupported {
usage: u64,
instance: u64,
entity: String,
},
Inconsistent {
usage: u64,
instance: u64,
reason: &'static str,
},
Divergent {
usage: u64,
instance: u64,
reason: DivergentReason,
},
Frame {
usage: u64,
error: GeometryError,
},
Cycle {
usage: u64,
},
TooDeep {
usage: u64,
},
}
impl fmt::Display for PlacementError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Unplaced { usage } => write!(
f,
"usage #{usage}: nothing places it (no context_dependent_shape_representation, \
and not as many mapped items as usages)"
),
Self::Quantified {
usage,
quantity: Some(quantity),
} => write!(
f,
"usage #{usage}: a quantity of {quantity}, which one placement cannot place"
),
Self::Quantified {
usage,
quantity: None,
} => write!(
f,
"usage #{usage}: its quantity cannot be read, so it may stand for several \
occurrences"
),
Self::NoTransformation {
usage,
relationship,
} => write!(
f,
"usage #{usage}: relationship #{relationship} states no transformation"
),
Self::Unsupported {
usage,
instance,
entity,
} => write!(
f,
"usage #{usage}: #{instance} ({entity}) is not read as a placement"
),
Self::Inconsistent {
usage,
instance,
reason,
} => write!(f, "usage #{usage}: #{instance}: {reason}"),
Self::Divergent {
usage,
instance,
reason,
} => write!(f, "usage #{usage}: #{instance}: {reason}"),
Self::Frame { usage, error } => write!(f, "usage #{usage}: {error}"),
Self::Cycle { usage } => write!(
f,
"usage #{usage} places a definition already on its path from the root"
),
Self::TooDeep { usage } => write!(
f,
"usage #{usage} lies more than {MAX_ASSEMBLY_DEPTH} levels below the root"
),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
#[non_exhaustive]
pub enum DivergentReason {
BothFramesPlaced,
DefaultedRefDirection,
}
impl fmt::Display for DivergentReason {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::BothFramesPlaced => {
"neither transform item is the identity, and ISO 10303 and Open CASCADE compose \
such a pair differently"
}
Self::DefaultedRefDirection => {
"the frame omits ref_direction and its axis is not +Z, so ISO 10303 and Open \
CASCADE build different x axes"
}
})
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use std::fmt::Write as _;
use super::*;
use crate::p21::parse;
const CONTEXTS: &str = "#1=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
#2=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
#3=DIMENSIONAL_EXPONENTS(1.,0.,0.,0.,0.,0.,0.);
#4=LENGTH_MEASURE_WITH_UNIT(LENGTH_MEASURE(25.4),#1);
#5=(CONVERSION_BASED_UNIT('INCH',#4)LENGTH_UNIT()NAMED_UNIT(#3));
#20=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#1,#2))REPRESENTATION_CONTEXT('',''));
#21=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#5,#2))REPRESENTATION_CONTEXT('',''));
#22=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#2))REPRESENTATION_CONTEXT('',''));
#23=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT((#1,#2))REPRESENTATION_CONTEXT('',''));
";
const MM: u64 = 20;
const INCH: u64 = 21;
const NO_LENGTH: u64 = 22;
const MM_2: u64 = 23;
const X: [f64; 3] = [1.0, 0.0, 0.0];
const Y: [f64; 3] = [0.0, 1.0, 0.0];
const Z: [f64; 3] = [0.0, 0.0, 1.0];
const QUARTER: [[f64; 3]; 3] = [[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]];
struct File {
data: String,
next: u64,
representations: Vec<(u64, String, u64)>,
items: HashMap<u64, Vec<String>>,
}
impl File {
fn new() -> Self {
Self {
data: String::new(),
next: 100,
representations: Vec::new(),
items: HashMap::new(),
}
}
fn add(&mut self, entity: &str) -> u64 {
let id = self.next;
self.next += 1;
writeln!(self.data, "#{id}={entity};").unwrap();
id
}
fn triple(v: [f64; 3]) -> String {
format!("({:?},{:?},{:?})", v[0], v[1], v[2])
}
fn frame(
&mut self,
location: [f64; 3],
axis: Option<[f64; 3]>,
ref_direction: Option<[f64; 3]>,
) -> u64 {
let point = self.add(&format!("CARTESIAN_POINT('',{})", Self::triple(location)));
let mut direction = |v: Option<[f64; 3]>| {
v.map_or("$".to_owned(), |v| {
format!(
"#{}",
self.add(&format!("DIRECTION('',{})", Self::triple(v)))
)
})
};
let axis = direction(axis);
let ref_direction = direction(ref_direction);
self.add(&format!(
"AXIS2_PLACEMENT_3D('',#{point},{axis},{ref_direction})"
))
}
fn identity(&mut self) -> u64 {
self.frame([0.0; 3], Some(Z), Some(X))
}
fn definition_with(&mut self, name: &str, entity: &str, context: u64) -> (u64, u64) {
let definition = self.add(&format!("PRODUCT_DEFINITION('{name}','',$,$)"));
let shape = self.add(&format!("PRODUCT_DEFINITION_SHAPE('','',#{definition})"));
let representation = self.next;
self.next += 1;
self.add(&format!(
"SHAPE_DEFINITION_REPRESENTATION(#{shape},#{representation})"
));
self.representations
.push((representation, entity.to_owned(), context));
(definition, representation)
}
fn definition(&mut self, name: &str, context: u64) -> (u64, u64) {
self.definition_with(name, "SHAPE_REPRESENTATION", context)
}
fn representation(&mut self, definition: u64, context: u64) -> u64 {
let shape = self.add(&format!("PRODUCT_DEFINITION_SHAPE('','',#{definition})"));
let representation = self.next;
self.next += 1;
self.add(&format!(
"SHAPE_DEFINITION_REPRESENTATION(#{shape},#{representation})"
));
self.representations
.push((representation, "SHAPE_REPRESENTATION".to_owned(), context));
representation
}
fn list(&mut self, representation: u64, item: &str) {
self.items
.entry(representation)
.or_default()
.push(item.to_owned());
}
fn list_id(&mut self, representation: u64, item: u64) {
self.list(representation, &format!("#{item}"));
}
fn usage(&mut self, assembly: u64, component: u64) -> u64 {
let name = self.next;
self.add(&format!(
"NEXT_ASSEMBLY_USAGE_OCCURRENCE('{name}','','',#{assembly},#{component},$)"
))
}
fn link(&mut self, usage: u64, relationship: &str) -> u64 {
let id = self.next;
self.add(&relationship.replace("{id}", &id.to_string()));
let shape = self.add(&format!("PRODUCT_DEFINITION_SHAPE('','',#{usage})"));
self.add(&format!(
"CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#{id},#{shape})"
));
id
}
fn relate(&mut self, usage: u64, rep_1: u64, rep_2: u64, transformation: u64) -> u64 {
self.link(
usage,
&format!(
"(REPRESENTATION_RELATIONSHIP('','',#{rep_1},#{rep_2})\
REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#{transformation})\
SHAPE_REPRESENTATION_RELATIONSHIP())"
),
)
}
fn place(
&mut self,
usage: u64,
(rep_1, item_1): (u64, u64),
(rep_2, item_2): (u64, u64),
) -> u64 {
self.list_id(rep_1, item_1);
self.list_id(rep_2, item_2);
let transformation = self.add(&format!(
"ITEM_DEFINED_TRANSFORMATION('','',#{item_1},#{item_2})"
));
self.relate(usage, rep_1, rep_2, transformation);
transformation
}
fn component(
&mut self,
(assembly, assembly_rep): (u64, u64),
(component, component_rep): (u64, u64),
frame: u64,
) -> u64 {
let usage = self.usage(assembly, component);
let origin = self.identity();
self.place(usage, (component_rep, origin), (assembly_rep, frame));
usage
}
fn mapped(
&mut self,
assembly_rep: u64,
component_rep: u64,
origin: u64,
target: u64,
) -> u64 {
let map = self.add(&format!("REPRESENTATION_MAP(#{origin},#{component_rep})"));
let item = self.add(&format!("MAPPED_ITEM('',#{map},#{target})"));
self.list_id(assembly_rep, item);
item
}
fn text(&self) -> String {
let mut text = format!(
"ISO-10303-21;HEADER;FILE_SCHEMA(('AP242'));ENDSEC;DATA;\n{CONTEXTS}{}",
self.data
);
for (id, entity, context) in &self.representations {
let items = self.items.get(id).map_or(String::new(), |i| i.join(","));
writeln!(text, "#{id}={entity}('',({items}),#{context});").unwrap();
}
text + "ENDSEC;END-ISO-10303-21;"
}
}
fn read(src: &str) -> (&'static ProductStructure, Placements<'static>) {
let src: &'static [u8] = Box::leak(src.as_bytes().to_vec().into_boxed_slice());
let graph: &'static Graph<'static> = Box::leak(Box::new(Graph::build(parse(src).unwrap())));
let structure: &'static ProductStructure =
Box::leak(Box::new(ProductStructure::new(graph)));
(structure, Placements::new(graph, structure))
}
fn read_file(file: &File) -> (&'static ProductStructure, Placements<'static>) {
read(&file.text())
}
fn index(structure: &ProductStructure, id: u64) -> usize {
structure
.usages()
.iter()
.position(|u| u.instance == id)
.unwrap()
}
fn definition(structure: &ProductStructure, id: u64) -> usize {
structure
.definitions()
.iter()
.position(|d| d.instance == id)
.unwrap()
}
fn usage_of(file: &File, id: u64) -> Result<Rigid, PlacementError> {
let (structure, placements) = read_file(file);
placements.usage(index(structure, id))
}
fn close(a: &Rigid, b: &Rigid) -> bool {
let rotation = a
.rotation
.iter()
.flatten()
.zip(b.rotation.iter().flatten())
.all(|(x, y)| (x - y).abs() <= 1e-15);
let translation = a
.translation
.iter()
.zip(b.translation)
.all(|(x, y)| (x - y).abs() <= 1e-12 * y.abs().max(1.0));
rotation && translation
}
#[track_caller]
fn assert_close(found: &Result<Rigid, PlacementError>, expected: Rigid) {
let found = found.as_ref().unwrap();
assert!(close(found, &expected), "{found:?} is not {expected:?}");
}
fn rigid(rotation: [[f64; 3]; 3], translation: [f64; 3]) -> Rigid {
Rigid {
rotation,
translation,
}
}
fn moved(translation: [f64; 3]) -> Rigid {
rigid(Rigid::IDENTITY.rotation, translation)
}
#[test]
fn an_item_defined_transformation_carries_the_component_onto_the_assembly() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let frame = file.frame([10.0, 20.0, 30.0], Some(Z), Some(Y));
let usage = file.component(assembly, part, frame);
let (structure, placements) = read_file(&file);
let expected = rigid(QUARTER, [10.0, 20.0, 30.0]);
assert_eq!(placements.usage(index(structure, usage)), Ok(expected));
assert_eq!(expected.apply_point([1.0, 0.0, 0.0]), [10.0, 21.0, 30.0]);
let occurrences: Vec<Occurrence> = placements.occurrences(0).collect();
assert_eq!(
occurrences,
[
Occurrence {
path: vec![],
definition: 0,
representation: Some(assembly.1),
transform: Ok(Rigid::IDENTITY),
},
Occurrence {
path: vec![0],
definition: 1,
representation: Some(part.1),
transform: Ok(expected),
},
]
);
}
#[test]
fn a_reversed_relationship_is_read_by_the_usage() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let frame = file.frame([5.0, 0.0, 0.0], Some(Z), Some(Y));
let origin = file.identity();
file.place(usage, (assembly.1, frame), (part.1, origin));
let (structure, placements) = read_file(&file);
assert_eq!(
structure.usages()[0]
.placement
.as_ref()
.and_then(Placement::reversed),
Some(true)
);
let expected = rigid(QUARTER, [5.0, 0.0, 0.0]);
assert_eq!(placements.usage(0), Ok(expected));
assert_ne!(Ok(expected.inverse()), placements.usage(0));
let part_occurrence = placements.occurrences(0).nth(1).unwrap();
assert_eq!(part_occurrence.representation, Some(part.1));
}
#[test]
fn transform_items_must_be_items_of_their_own_representations() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.list_id(assembly.1, origin);
file.list_id(assembly.1, frame);
let transformation = file.add(&format!(
"ITEM_DEFINED_TRANSFORMATION('','',#{origin},#{frame})"
));
file.relate(usage, part.1, assembly.1, transformation);
assert_eq!(
usage_of(&file, usage),
Err(PlacementError::Inconsistent {
usage,
instance: origin,
reason: ITEM_1,
})
);
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.list_id(assembly.1, origin);
file.place(usage, (part.1, origin), (assembly.1, frame));
assert_eq!(usage_of(&file, usage), Ok(moved([1.0, 0.0, 0.0])));
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.list_id(part.1, origin);
let transformation = file.add(&format!(
"ITEM_DEFINED_TRANSFORMATION('','',#{origin},#{frame})"
));
file.relate(usage, part.1, assembly.1, transformation);
assert_eq!(
usage_of(&file, usage),
Err(PlacementError::Inconsistent {
usage,
instance: frame,
reason: ITEM_2,
})
);
}
#[test]
fn a_mapped_item_maps_its_origin_onto_its_target() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let target = file.frame([0.0, 0.0, 7.0], Some(Z), Some(Y));
file.mapped(assembly.1, part.1, origin, target);
let (structure, placements) = read_file(&file);
assert!(matches!(
structure.usages()[0].placement,
Some(Placement::MappedItem { .. })
));
assert_eq!(
placements.usage(index(structure, usage)),
Ok(rigid(QUARTER, [0.0, 0.0, 7.0]))
);
let part_occurrence = placements.occurrences(0).nth(1).unwrap();
assert_eq!(part_occurrence.representation, Some(part.1));
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.frame([1.0, 0.0, 0.0], None, None);
let target = file.frame([0.0, 0.0, 7.0], Some(Z), Some(Y));
file.mapped(assembly.1, part.1, origin, target);
assert_close(&usage_of(&file, usage), rigid(QUARTER, [0.0, -1.0, 7.0]));
}
#[test]
fn a_mapped_item_places_only_one_usage() {
let shared = |usages: &[u64], item: u64, file: &File| {
for &usage in usages {
assert_eq!(
usage_of(file, usage),
Err(PlacementError::Inconsistent {
usage,
instance: item,
reason: SHARED_MAPPED_ITEM,
})
);
}
};
let mut file = File::new();
let assembly = file.definition("a", MM);
let shape = file.add(&format!("PRODUCT_DEFINITION_SHAPE('','',#{})", assembly.0));
file.add(&format!(
"SHAPE_DEFINITION_REPRESENTATION(#{shape},#{})",
assembly.1
));
let part = file.definition("p", MM);
let first = file.usage(assembly.0, part.0);
let second = file.usage(assembly.0, part.0);
let origin = file.identity();
let target = file.frame([10.0, 0.0, 0.0], None, None);
let item = file.mapped(assembly.1, part.1, origin, target);
shared(&[first, second], item, &file);
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM);
let twin = file.add("PRODUCT_DEFINITION('q','',$,$)");
let shape = file.add(&format!("PRODUCT_DEFINITION_SHAPE('','',#{twin})"));
file.add(&format!(
"SHAPE_DEFINITION_REPRESENTATION(#{shape},#{})",
part.1
));
let first = file.usage(assembly.0, part.0);
let second = file.usage(assembly.0, twin);
let origin = file.identity();
let target = file.frame([10.0, 0.0, 0.0], None, None);
let item = file.mapped(assembly.1, part.1, origin, target);
shared(&[first, second], item, &file);
}
#[test]
fn frames_are_read_in_the_units_of_their_own_representations() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", INCH);
let usage = file.usage(assembly.0, part.0);
let origin = file.frame([1.0, 0.0, 0.0], Some(Z), Some(X));
let frame = file.identity();
file.place(usage, (part.1, origin), (assembly.1, frame));
assert_eq!(usage_of(&file, usage), Ok(moved([-25.4, 0.0, 0.0])));
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", INCH);
let usage = file.usage(assembly.0, part.0);
let origin = file.frame([1.0, 0.0, 0.0], None, None);
let target = file.frame([10.0, 0.0, 0.0], None, None);
file.mapped(assembly.1, part.1, origin, target);
assert_close(&usage_of(&file, usage), moved([10.0 - 25.4, 0.0, 0.0]));
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", NO_LENGTH);
let placed = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([3.0, 0.0, 0.0], None, None);
file.place(placed, (part.1, origin), (assembly.1, frame));
let refused = file.usage(assembly.0, part.0);
let origin = file.frame([3.0, 0.0, 0.0], None, None);
let frame = file.identity();
file.place(refused, (part.1, origin), (assembly.1, frame));
let (structure, placements) = read_file(&file);
assert_eq!(
placements.usage(index(structure, placed)),
Ok(moved([3.0, 0.0, 0.0]))
);
let Err(PlacementError::Frame { usage, error }) =
placements.usage(index(structure, refused))
else {
panic!("a unit is needed");
};
assert_eq!(
(usage, error.instance),
(refused, origin - 1),
"at the point"
);
assert!(matches!(
error.kind,
GeometryErrorKind::Unit(UnitError::Missing { .. })
));
}
#[test]
fn usages_without_a_single_placement_are_refused() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let unplaced = file.usage(assembly.0, part.0);
let plain = file.usage(assembly.0, part.0);
let relationship = file.link(
plain,
&format!(
"SHAPE_REPRESENTATION_RELATIONSHIP('','',#{},#{})",
part.1, assembly.1
),
);
let twice = file.usage(assembly.0, part.0);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
let origin = file.identity();
file.place(twice, (part.1, origin), (assembly.1, frame));
let second = file.place(twice, (part.1, origin), (assembly.1, frame));
let other = file.definition("o", MM);
let elsewhere = file.usage(assembly.0, part.0);
let origin = file.identity();
file.place(elsewhere, (other.1, origin), (assembly.1, frame));
let (structure, placements) = read_file(&file);
let read = |id| placements.usage(index(structure, id));
assert_eq!(
read(unplaced),
Err(PlacementError::Unplaced { usage: unplaced })
);
assert_eq!(
read(plain),
Err(PlacementError::NoTransformation {
usage: plain,
relationship
})
);
let Err(PlacementError::Inconsistent {
usage,
instance,
reason,
}) = read(twice)
else {
panic!("two links");
};
assert_eq!((usage, reason), (twice, MORE_THAN_ONE_LINK));
assert!(instance > second, "{instance}");
assert!(matches!(
read(elsewhere),
Err(PlacementError::Inconsistent { reason: SIDES, .. })
));
}
#[test]
fn quantified_usages_place_only_one() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let quantified = |file: &mut File, quantity: &str| {
let measure = file.add(&format!("MEASURE_WITH_UNIT({quantity},#1)"));
let usage = file.add(&format!(
"(ASSEMBLY_COMPONENT_USAGE($)NEXT_ASSEMBLY_USAGE_OCCURRENCE()\
PRODUCT_DEFINITION_RELATIONSHIP('q','','',#{},#{})PRODUCT_DEFINITION_USAGE()\
QUANTIFIED_ASSEMBLY_COMPONENT_USAGE(#{measure}))",
assembly.0, part.0
));
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.place(usage, (part.1, origin), (assembly.1, frame));
usage
};
let four = quantified(&mut file, "COUNT_MEASURE(4.)");
let one = quantified(&mut file, "COUNT_MEASURE(1.)");
let unreadable = quantified(&mut file, "'four'");
let (structure, placements) = read_file(&file);
let read = |id| placements.usage(index(structure, id));
assert_eq!(
read(four),
Err(PlacementError::Quantified {
usage: four,
quantity: Some(4.0)
})
);
assert_eq!(read(one), Ok(moved([1.0, 0.0, 0.0])));
assert_eq!(
read(unreadable),
Err(PlacementError::Quantified {
usage: unreadable,
quantity: None
})
);
let occurrence = placements.occurrences(0).nth(1).unwrap();
assert_eq!(occurrence.path, [index(structure, four)]);
assert_eq!(occurrence.representation, Some(part.1));
}
#[test]
fn transformations_other_than_two_frames_are_not_read() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let operator_usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let operator = file.add(&format!(
"CARTESIAN_TRANSFORMATION_OPERATOR_3D('','','',$,$,#{origin},$,$)"
));
file.relate(operator_usage, part.1, assembly.1, operator);
let functional_usage = file.usage(assembly.0, part.0);
let functional = file.add("FUNCTIONALLY_DEFINED_TRANSFORMATION('','')");
file.relate(functional_usage, part.1, assembly.1, functional);
let flat_usage = file.usage(assembly.0, part.0);
let point = file.add("CARTESIAN_POINT('',(0.,0.))");
let flat = file.add(&format!("AXIS2_PLACEMENT_2D('',#{point},$)"));
let frame = file.identity();
file.place(flat_usage, (part.1, flat), (assembly.1, frame));
let other = file.definition("o", MM);
let mapped_usage = file.usage(assembly.0, other.0);
let origin = file.identity();
let target = file.add(&format!(
"CARTESIAN_TRANSFORMATION_OPERATOR_3D('','','',$,$,#{origin},2.,$)"
));
file.mapped(assembly.1, other.1, origin, target);
let (structure, placements) = read_file(&file);
let read = |id| placements.usage(index(structure, id));
let unsupported = |usage, instance, entity: &str| {
Err(PlacementError::Unsupported {
usage,
instance,
entity: entity.to_owned(),
})
};
assert_eq!(
read(operator_usage),
unsupported(
operator_usage,
operator,
"CARTESIAN_TRANSFORMATION_OPERATOR_3D"
)
);
assert_eq!(
read(functional_usage),
unsupported(
functional_usage,
functional,
"FUNCTIONALLY_DEFINED_TRANSFORMATION"
)
);
assert_eq!(
read(flat_usage),
unsupported(flat_usage, flat, "AXIS2_PLACEMENT_2D")
);
assert_eq!(
read(mapped_usage),
unsupported(mapped_usage, target, "CARTESIAN_TRANSFORMATION_OPERATOR_3D")
);
}
#[test]
fn divergent_placements_are_refused() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let both = file.usage(assembly.0, part.0);
let origin = file.frame([10.0, 0.0, 0.0], Some(X), Some(Y));
let frame = file.frame([0.0, 0.0, -10.0], None, None);
let both_transformation = file.place(both, (part.1, origin), (assembly.1, frame));
let defaulted = file.usage(assembly.0, part.0);
let origin = file.identity();
let minus_z = file.frame([1.0, 0.0, 0.0], Some([0.0, 0.0, -1.0]), None);
file.place(defaulted, (part.1, origin), (assembly.1, minus_z));
let plus_z = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], Some([0.0, 0.0, 2.5]), None);
file.place(plus_z, (part.1, origin), (assembly.1, frame));
let neither = file.usage(assembly.0, part.0);
let origin = file.frame([0.0; 3], None, None);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.place(neither, (part.1, origin), (assembly.1, frame));
let (structure, placements) = read_file(&file);
let read = |id| placements.usage(index(structure, id));
assert_eq!(
read(both),
Err(PlacementError::Divergent {
usage: both,
instance: both_transformation,
reason: DivergentReason::BothFramesPlaced,
})
);
assert_eq!(
read(defaulted),
Err(PlacementError::Divergent {
usage: defaulted,
instance: minus_z,
reason: DivergentReason::DefaultedRefDirection,
})
);
assert_eq!(read(plus_z), Ok(moved([1.0, 0.0, 0.0])));
assert_eq!(read(neither), Ok(moved([1.0, 0.0, 0.0])));
}
#[test]
fn frames_that_cannot_be_read_refuse_their_usage() {
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let frame = file.frame([1.0, 0.0, 0.0], Some([0.0, 0.0, 0.0]), None);
file.place(usage, (part.1, origin), (assembly.1, frame));
let Err(PlacementError::Frame { error, .. }) = usage_of(&file, usage) else {
panic!("a zero axis");
};
assert_eq!(error.kind, GeometryErrorKind::ZeroDirection);
assert_eq!(error.instance, frame - 1, "reported at the direction");
let mut file = File::new();
let assembly = file.definition("a", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.frame([1.3e308, 1.3e308, 0.0], Some([1.0, 1.0, 0.0]), Some(Z));
let frame = file.identity();
file.place(usage, (part.1, origin), (assembly.1, frame));
let Err(PlacementError::Frame { error, .. }) = usage_of(&file, usage) else {
panic!("not finite");
};
assert_eq!(
(error.instance, error.kind),
(origin, GeometryErrorKind::NotFinite)
);
}
#[test]
fn occurrences_compose_from_the_root_down() {
let mut file = File::new();
let top = file.definition("top", MM);
let pair = file.definition("pair", MM_2);
let bolt = file.definition("bolt", INCH);
let left = file.frame([-100.0, 0.0, 0.0], None, None);
let right = file.frame([100.0, 0.0, 0.0], Some(Z), Some(Y));
let first = file.component(top, pair, left);
let second = file.component(top, pair, right);
let up = file.frame([0.0, 0.0, 1.0], None, None);
let bolt_usage = file.component(pair, bolt, up);
let (structure, placements) = read_file(&file);
let root = definition(structure, top.0);
assert_eq!(structure.roots(), [root]);
let occurrences: Vec<Occurrence> = placements.occurrences(root).collect();
let paths: Vec<Vec<u64>> = occurrences
.iter()
.map(|o| {
o.path
.iter()
.map(|&u| structure.usages()[u].instance)
.collect()
})
.collect();
assert_eq!(
paths,
[
vec![],
vec![first],
vec![first, bolt_usage],
vec![second],
vec![second, bolt_usage]
]
);
let representations: Vec<Option<u64>> =
occurrences.iter().map(|o| o.representation).collect();
assert_eq!(
representations,
[
Some(top.1),
Some(pair.1),
Some(bolt.1),
Some(pair.1),
Some(bolt.1)
]
);
assert_close(&occurrences[2].transform, moved([-100.0, 0.0, 1.0]));
assert_close(&occurrences[4].transform, rigid(QUARTER, [100.0, 0.0, 1.0]));
assert_eq!(
occurrences[4].transform,
Ok(placements.usage(index(structure, second)).unwrap()
* placements.usage(index(structure, bolt_usage)).unwrap())
);
}
#[test]
fn separate_roots_are_unrelated_frames() {
let mut file = File::new();
let first = file.definition("first", MM);
let second = file.definition("second", MM_2);
let part = file.definition("p", INCH);
let lone = file.definition("lone", MM);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.component(first, part, frame);
let frame = file.frame([2.0, 0.0, 0.0], None, None);
file.component(second, part, frame);
let (structure, placements) = read_file(&file);
let roots: Vec<u64> = structure
.roots()
.iter()
.map(|&r| structure.definitions()[r].instance)
.collect();
assert_eq!(roots, [first.0, second.0, lone.0]);
let parts: Vec<Result<Rigid, PlacementError>> = structure.roots()[..2]
.iter()
.map(|&root| placements.occurrences(root).nth(1).unwrap().transform)
.collect();
assert_eq!(
parts,
[Ok(moved([1.0, 0.0, 0.0])), Ok(moved([2.0, 0.0, 0.0]))]
);
let only: Vec<Occurrence> = placements.occurrences(structure.roots()[2]).collect();
assert_eq!(only.len(), 1);
assert_eq!(only[0].representation, Some(lone.1));
}
#[test]
fn a_path_keeps_one_representation_per_definition() {
let mut file = File::new();
let top = file.definition("top", MM);
let sub = file.definition("sub", MM_2);
let other = file.representation(sub.0, MM_2);
let part = file.definition("p", INCH);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.component(top, sub, frame);
let frame = file.frame([2.0, 0.0, 0.0], None, None);
let inner = file.component((sub.0, other), part, frame);
let (structure, placements) = read_file(&file);
assert_eq!(
placements.usage(index(structure, inner)),
Ok(moved([2.0, 0.0, 0.0])),
"the usage itself reads"
);
let occurrences: Vec<Occurrence> = placements.occurrences(0).collect();
assert_eq!(
occurrences[2].transform,
Err(PlacementError::Inconsistent {
usage: inner,
instance: other,
reason: CHANGES_REPRESENTATION,
})
);
assert_eq!(occurrences[2].representation, Some(part.1));
let mut file = File::new();
let top = file.definition("top", MM);
let second = file.representation(top.0, MM);
let part = file.definition("p", INCH);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
let first_usage = file.component(top, part, frame);
let frame = file.frame([2.0, 0.0, 0.0], None, None);
let second_usage = file.component((top.0, second), part, frame);
let (_, placements) = read_file(&file);
let occurrences: Vec<Occurrence> = placements.occurrences(0).collect();
assert_eq!(occurrences[0].representation, None);
assert_eq!(occurrences[0].transform, Ok(Rigid::IDENTITY));
assert_eq!(
occurrences[1..]
.iter()
.map(|o| o.transform.clone())
.collect::<Vec<_>>(),
[
Err(PlacementError::Inconsistent {
usage: first_usage,
instance: top.1,
reason: AMBIGUOUS_ROOT,
}),
Err(PlacementError::Inconsistent {
usage: second_usage,
instance: second,
reason: AMBIGUOUS_ROOT,
}),
]
);
}
#[test]
fn an_occurrence_carries_the_first_refusal_on_its_path() {
let mut file = File::new();
let top = file.definition("top", MM);
let sub = file.definition("sub", MM_2);
let part = file.definition("p", INCH);
let unplaced = file.usage(top.0, sub.0);
let frame = file.frame([2.0, 0.0, 0.0], None, None);
file.component(sub, part, frame);
let (_, placements) = read_file(&file);
let transforms: Vec<Result<Rigid, PlacementError>> =
placements.occurrences(0).map(|o| o.transform).collect();
let refused = Err(PlacementError::Unplaced { usage: unplaced });
assert_eq!(transforms, [Ok(Rigid::IDENTITY), refused.clone(), refused]);
}
#[test]
fn cycles_and_depth_end_a_path() {
let src = "ISO-10303-21;HEADER;FILE_SCHEMA(('X'));ENDSEC;DATA;
#1=PRODUCT_DEFINITION('a','',$,$);
#2=PRODUCT_DEFINITION('b','',$,$);
#3=NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','','',#1,#2,$);
#4=NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','','',#2,#1,$);
ENDSEC;END-ISO-10303-21;";
let (structure, placements) = read(src);
assert_eq!(structure.roots(), [0usize; 0]);
let occurrences: Vec<Occurrence> = placements.occurrences(0).collect();
assert_eq!(
occurrences
.iter()
.map(|o| (o.path.clone(), o.transform.clone()))
.collect::<Vec<_>>(),
[
(vec![], Ok(Rigid::IDENTITY)),
(vec![0], Err(PlacementError::Unplaced { usage: 3 })),
(vec![0, 1], Err(PlacementError::Cycle { usage: 4 })),
]
);
let mut file = File::new();
let mut parent = file.definition("0", MM);
let mut usages = Vec::new();
for level in 1..=1_100 {
let child = file.definition(&level.to_string(), MM);
let frame = file.frame([1.0, 0.0, 0.0], None, None);
usages.push(file.component(parent, child, frame));
parent = child;
}
let (structure, placements) = read_file(&file);
assert_eq!(structure.roots(), [0]);
let occurrences: Vec<Occurrence> = placements.occurrences(0).collect();
assert_eq!(occurrences.len(), 1 + MAX_ASSEMBLY_DEPTH + 1);
let deepest = &occurrences[MAX_ASSEMBLY_DEPTH];
assert_eq!(deepest.path.len(), MAX_ASSEMBLY_DEPTH);
#[expect(clippy::cast_precision_loss, reason = "1024 is exact")]
let depth = MAX_ASSEMBLY_DEPTH as f64;
assert_eq!(deepest.transform, Ok(moved([depth, 0.0, 0.0])));
let beyond = occurrences.last().unwrap();
assert_eq!(beyond.path.len(), MAX_ASSEMBLY_DEPTH + 1);
assert_eq!(
beyond.transform,
Err(PlacementError::TooDeep {
usage: usages[MAX_ASSEMBLY_DEPTH]
})
);
}
#[test]
fn occurrences_are_produced_lazily() {
let mut file = File::new();
let mut parent = file.definition("0", MM);
for level in 1..=40 {
let child = file.definition(&level.to_string(), MM);
for _ in 0..2 {
let frame = file.frame([1.0, 0.0, 0.0], None, None);
file.component(parent, child, frame);
}
parent = child;
}
let (_, placements) = read_file(&file);
let mut occurrences = placements.occurrences(0);
let first: Vec<usize> = occurrences
.by_ref()
.take(42)
.map(|o| o.path.len())
.collect();
assert_eq!(first, (0..=40).chain([40]).collect::<Vec<_>>());
assert_eq!(occurrences.take(1_000).count(), 1_000);
}
#[test]
fn a_complex_mapped_item_places_its_usage() {
let mut file = File::new();
let assembly = file.definition_with("a", "(REPRESENTATION_RELATIONSHIP_PLACEHOLDER)", MM);
let part = file.definition("p", MM_2);
let usage = file.usage(assembly.0, part.0);
let origin = file.identity();
let target = file.frame([0.0, 4.0, 0.0], None, None);
let map = file.add(&format!("REPRESENTATION_MAP(#{origin},#{})", part.1));
let item = file.add(&format!(
"(GEOMETRIC_REPRESENTATION_ITEM()MAPPED_ITEM(#{map},#{target})REPRESENTATION_ITEM(''))"
));
file.list_id(assembly.1, item);
let text = file.text().replace(
&format!(
"#{}=(REPRESENTATION_RELATIONSHIP_PLACEHOLDER)('',(#{item}),#{MM});",
assembly.1
),
&format!(
"#{}=(REPRESENTATION('',(#{item}),#{MM})SHAPE_REPRESENTATION());",
assembly.1
),
);
let (structure, placements) = read(&text);
assert_eq!(
structure.usages()[0].placement,
Some(Placement::MappedItem {
mapped_item: item,
representation_map: map,
origin: Some(origin),
target: Some(target),
})
);
assert_eq!(
placements.usage(index(structure, usage)),
Ok(moved([0.0, 4.0, 0.0]))
);
let camera = text.replace(
"(GEOMETRIC_REPRESENTATION_ITEM()MAPPED_ITEM",
"(CAMERA_IMAGE()CAMERA_IMAGE_3D_WITH_SCALE()GEOMETRIC_REPRESENTATION_ITEM()MAPPED_ITEM",
);
let (structure, placements) = read(&camera);
assert!(matches!(
placements.usage(index(structure, usage)),
Err(PlacementError::Unsupported { instance, .. }) if instance == item
));
}
#[test]
fn errors_format_and_wrap() {
let cases = [
(
PlacementError::Unplaced { usage: 7 },
"usage #7: nothing places it (no context_dependent_shape_representation, and \
not as many mapped items as usages)",
),
(
PlacementError::Quantified {
usage: 7,
quantity: Some(4.0),
},
"usage #7: a quantity of 4, which one placement cannot place",
),
(
PlacementError::Divergent {
usage: 7,
instance: 9,
reason: DivergentReason::BothFramesPlaced,
},
"usage #7: #9: neither transform item is the identity, and ISO 10303 and Open \
CASCADE compose such a pair differently",
),
(
PlacementError::TooDeep { usage: 7 },
"usage #7 lies more than 1024 levels below the root",
),
];
for (error, text) in cases {
assert_eq!(error.to_string(), text);
assert_eq!(crate::Error::from(error).to_string(), text);
}
}
#[cfg(feature = "serde")]
mod serialized {
use super::*;
use crate::testing::unique;
#[test]
fn occurrences_and_errors_have_unique_keys() {
let geometry = GeometryError {
instance: 3,
entity: "DIRECTION".to_owned(),
attribute: Some("direction_ratios"),
kind: GeometryErrorKind::ZeroDirection,
};
let errors = [
PlacementError::Unplaced { usage: 1 },
PlacementError::Quantified {
usage: 1,
quantity: None,
},
PlacementError::NoTransformation {
usage: 1,
relationship: 2,
},
PlacementError::Unsupported {
usage: 1,
instance: 2,
entity: "X".to_owned(),
},
PlacementError::Inconsistent {
usage: 1,
instance: 2,
reason: SIDES,
},
PlacementError::Divergent {
usage: 1,
instance: 2,
reason: DivergentReason::DefaultedRefDirection,
},
PlacementError::Frame {
usage: 1,
error: geometry,
},
PlacementError::Cycle { usage: 1 },
PlacementError::TooDeep { usage: 1 },
];
for error in errors {
let json = unique(&error);
assert!(json.starts_with("{\"kind\":"), "{json}");
unique(&Occurrence {
path: vec![0],
definition: 1,
representation: None,
transform: Err(error),
});
}
assert_eq!(
unique(&PlacementError::Divergent {
usage: 1,
instance: 2,
reason: DivergentReason::BothFramesPlaced,
}),
r#"{"kind":"divergent","usage":1,"instance":2,"reason":"both_frames_placed"}"#
);
let placed = unique(&Occurrence {
path: vec![],
definition: 0,
representation: Some(5),
transform: Ok(Rigid::IDENTITY),
});
assert!(
placed.contains(r#""transform":{"ok":{"rotation""#),
"{placed}"
);
}
}
}