ifc_geometry/lower/
context.rs1use axiolid_model::NodeId;
19use ifc_model::EntityId;
20
21use crate::error::{GeometryError, GeometryResult};
22use crate::input::context::representation_frame_resolved;
25pub use crate::input::product::geometric_products;
28use crate::input::representation::{
29 select_product_representation, Representation, RepresentationPurpose,
30};
31use crate::lower::dispatch::lower_representation_item;
32use crate::lower::session::LoweringSession;
33use crate::transform::Transform;
34
35pub use crate::constraint::product_world_transform;
36pub use crate::input::representation::select_shape_representation;
37
38pub fn lower_product_items(
44 session: &mut LoweringSession<'_>,
45 product: EntityId,
46) -> GeometryResult<Option<NodeId>> {
47 lower_product_representation(session, product, RepresentationPurpose::Body)
48}
49
50pub fn lower_product_representation(
52 session: &mut LoweringSession<'_>,
53 product: EntityId,
54 purpose: RepresentationPurpose,
55) -> GeometryResult<Option<NodeId>> {
56 let Some(world) = representation_frame_resolved(
59 session.model(),
60 session.units(),
61 product,
62 purpose,
63 session.linear_resolution(),
64 )?
65 else {
66 return Ok(None);
67 };
68 lower_product_representation_in(session, product, purpose, world)
69}
70
71pub(crate) fn lower_product_representation_in(
78 session: &mut LoweringSession<'_>,
79 product: EntityId,
80 purpose: RepresentationPurpose,
81 frame: Transform,
82) -> GeometryResult<Option<NodeId>> {
83 let Some(representation) = select_product_representation(session.model(), product, purpose)?
84 else {
85 return Ok(None);
86 };
87
88 let entity = session
89 .model()
90 .get(representation)
91 .ok_or(GeometryError::MissingEntity {
92 referrer: product,
93 missing: representation,
94 })?;
95 let items = Representation::new(representation, entity).items()?;
96 let mut roots = Vec::with_capacity(items.len());
97 for item in items {
98 roots.push(lower_representation_item(session, item, frame)?);
99 }
100 collect_roots(session, product, roots)
101}
102
103#[cfg(feature = "compile")]
115pub(crate) fn lower_product_representation_leaving_out(
116 session: &mut LoweringSession<'_>,
117 product: EntityId,
118 purpose: RepresentationPurpose,
119 leave_out: impl Fn(&str) -> bool,
120) -> GeometryResult<Option<(Option<NodeId>, Vec<EntityId>)>> {
121 let Some(frame) = representation_frame_resolved(
122 session.model(),
123 session.units(),
124 product,
125 purpose,
126 session.linear_resolution(),
127 )?
128 else {
129 return Ok(None);
130 };
131 let Some(representation) = select_product_representation(session.model(), product, purpose)?
132 else {
133 return Ok(None);
134 };
135 let entity = session
136 .model()
137 .get(representation)
138 .ok_or(GeometryError::MissingEntity {
139 referrer: product,
140 missing: representation,
141 })?;
142 let items = Representation::new(representation, entity).items()?;
143 let (mut roots, mut left_out) = (Vec::with_capacity(items.len()), Vec::new());
144 for item in items {
145 match session.model().get(item) {
147 Some(entity) if leave_out(&entity.type_name) => left_out.push(item),
148 _ => roots.push(lower_representation_item(session, item, frame)?),
149 }
150 }
151 Ok(Some((collect_roots(session, product, roots)?, left_out)))
152}
153
154fn collect_roots(
156 session: &mut LoweringSession<'_>,
157 product: EntityId,
158 roots: Vec<NodeId>,
159) -> GeometryResult<Option<NodeId>> {
160 match roots.len() {
161 0 => Ok(None),
162 1 => Ok(Some(roots[0])),
163 _ => Ok(Some(session.node_for(
164 product,
165 axiolid_model::GeometryNode::Collection(roots),
166 )?)),
167 }
168}