ifc_geometry/solid/tessellated/
polygonal.rs1use super::{face_set_slot, int_grid, int_list, to_zero_based, TessellatedFaceSet};
8use crate::error::GeometryResult;
9use crate::slots::Slots;
10use ifc_model::{Entity, EntityId};
11
12pub(crate) mod set_slot {
20 pub const CLOSED: usize = 1;
22 pub const FACES: usize = 2;
24 pub const PN_INDEX: usize = 3;
26}
27
28pub(crate) mod face_slot {
34 pub const COORD_INDEX: usize = 0;
36 pub const INNER_COORD_INDICES: usize = 1;
38}
39
40#[derive(Debug, Clone, Copy)]
49pub struct PolygonalFaceSet<'m> {
50 slots: Slots<'m>,
51}
52
53impl<'m> PolygonalFaceSet<'m> {
54 pub fn new(id: EntityId, entity: &'m Entity) -> Self {
56 Self {
57 slots: Slots::new(id, entity),
58 }
59 }
60
61 pub fn id(&self) -> EntityId {
63 self.slots.id()
64 }
65
66 pub fn base(&self) -> TessellatedFaceSet<'m> {
68 TessellatedFaceSet::from_slots(self.slots)
69 }
70
71 pub fn coordinates(&self) -> GeometryResult<EntityId> {
73 self.slots
74 .req_ref(face_set_slot::COORDINATES, "Coordinates")
75 }
76
77 pub fn closed(&self) -> Option<bool> {
81 self.slots.opt_bool(set_slot::CLOSED)
82 }
83
84 pub fn faces(&self) -> GeometryResult<Vec<EntityId>> {
86 self.slots.req_ref_list(set_slot::FACES, "Faces")
87 }
88
89 pub fn pn_index_1based(&self) -> Option<Vec<i64>> {
91 int_list(self.slots.opt(set_slot::PN_INDEX)?)
92 }
93
94 pub fn pn_index_0based(&self) -> GeometryResult<Option<Vec<usize>>> {
99 let Some(raw) = self.pn_index_1based() else {
100 return Ok(None);
101 };
102 raw.into_iter()
103 .map(|i| to_zero_based(&self.slots, "PnIndex", i))
104 .collect::<GeometryResult<Vec<_>>>()
105 .map(Some)
106 }
107}
108
109#[derive(Debug, Clone, Copy)]
114pub struct IndexedPolygonalFace<'m> {
115 slots: Slots<'m>,
116}
117
118impl<'m> IndexedPolygonalFace<'m> {
119 pub fn new(id: EntityId, entity: &'m Entity) -> Self {
121 Self {
122 slots: Slots::new(id, entity),
123 }
124 }
125
126 pub fn id(&self) -> EntityId {
128 self.slots.id()
129 }
130
131 pub fn type_name(&self) -> &'m str {
133 self.slots.type_name()
134 }
135
136 pub fn has_voids(&self) -> bool {
138 self.type_name()
139 .eq_ignore_ascii_case("IFCINDEXEDPOLYGONALFACEWITHVOIDS")
140 }
141
142 pub fn outer_loop_1based(&self) -> GeometryResult<Vec<i64>> {
144 let value = self.slots.req(face_slot::COORD_INDEX, "CoordIndex")?;
145 int_list(value).ok_or_else(|| {
146 self.slots
147 .degenerate("CoordIndex is not a list of integers")
148 })
149 }
150
151 pub fn outer_loop_0based(&self) -> GeometryResult<Vec<usize>> {
157 self.outer_loop_1based()?
158 .into_iter()
159 .map(|i| to_zero_based(&self.slots, "CoordIndex", i))
160 .collect()
161 }
162}
163
164#[derive(Debug, Clone, Copy)]
174pub struct IndexedPolygonalFaceWithVoids<'m> {
175 slots: Slots<'m>,
176}
177
178impl<'m> IndexedPolygonalFaceWithVoids<'m> {
179 pub fn new(id: EntityId, entity: &'m Entity) -> Self {
181 Self {
182 slots: Slots::new(id, entity),
183 }
184 }
185
186 pub fn id(&self) -> EntityId {
188 self.slots.id()
189 }
190
191 pub fn base(&self) -> IndexedPolygonalFace<'m> {
194 IndexedPolygonalFace { slots: self.slots }
195 }
196
197 pub fn inner_loops_1based(&self) -> GeometryResult<Vec<Vec<i64>>> {
201 let value = self
202 .slots
203 .req(face_slot::INNER_COORD_INDICES, "InnerCoordIndices")?;
204 int_grid(value).ok_or_else(|| {
205 self.slots
206 .degenerate("InnerCoordIndices is not a list of integer lists")
207 })
208 }
209
210 pub fn inner_loops_0based(&self) -> GeometryResult<Vec<Vec<usize>>> {
212 self.inner_loops_1based()?
213 .into_iter()
214 .map(|loop_| {
215 loop_
216 .into_iter()
217 .map(|i| to_zero_based(&self.slots, "InnerCoordIndices", i))
218 .collect()
219 })
220 .collect()
221 }
222
223 pub fn void_count(&self) -> GeometryResult<usize> {
225 Ok(self.inner_loops_1based()?.len())
226 }
227}
228
229#[cfg(test)]
230mod tests {
231 use super::*;
232 use crate::solid::testkit::{entity, int_grid as grid, ints, r, refs};
233 use ifc_model::Value;
234
235 #[test]
238 fn closed_precedes_faces_unlike_the_triangulated_layout() {
239 let e = entity(
240 "IFCPOLYGONALFACESET",
241 vec![r(50), Value::Bool(true), refs(&[10, 11]), Value::Null],
242 );
243 let view = PolygonalFaceSet::new(EntityId(1), &e);
244 assert_eq!(view.coordinates().unwrap(), EntityId(50));
245 assert_eq!(view.closed(), Some(true));
246 assert_eq!(view.faces().unwrap(), vec![EntityId(10), EntityId(11)]);
247 }
248
249 #[test]
250 fn face_set_pn_index_applies_the_same_one_based_rule() {
251 let e = entity(
252 "IFCPOLYGONALFACESET",
253 vec![r(50), Value::Bool(true), refs(&[10]), ints(&[3, 1, 2])],
254 );
255 let view = PolygonalFaceSet::new(EntityId(1), &e);
256 assert_eq!(view.pn_index_1based().unwrap(), vec![3, 1, 2]);
257 assert_eq!(view.pn_index_0based().unwrap().unwrap(), vec![2, 0, 1]);
258 }
259
260 #[test]
261 fn a_face_set_without_pn_index_reports_none() {
262 let e = entity(
263 "IFCPOLYGONALFACESET",
264 vec![r(50), Value::Bool(true), refs(&[10])],
265 );
266 let view = PolygonalFaceSet::new(EntityId(1), &e);
267 assert_eq!(view.pn_index_0based().unwrap(), None);
268 }
269
270 #[test]
271 fn a_face_outer_loop_converts_from_one_based_to_zero_based() {
272 let e = entity("IFCINDEXEDPOLYGONALFACE", vec![ints(&[1, 2, 3, 4])]);
273 let view = IndexedPolygonalFace::new(EntityId(1), &e);
274 assert_eq!(view.outer_loop_1based().unwrap(), vec![1, 2, 3, 4]);
275 assert_eq!(view.outer_loop_0based().unwrap(), vec![0, 1, 2, 3]);
276 assert!(!view.has_voids());
277 }
278
279 #[test]
280 fn a_zero_index_in_a_face_loop_is_rejected() {
281 let e = entity("IFCINDEXEDPOLYGONALFACE", vec![ints(&[0, 1, 2])]);
282 let err = IndexedPolygonalFace::new(EntityId(8), &e)
283 .outer_loop_0based()
284 .unwrap_err();
285 assert_eq!(err.entity(), Some(EntityId(8)));
286 }
287
288 #[test]
291 fn inner_loops_are_never_merged_into_the_outer_loop() {
292 let e = entity(
293 "IFCINDEXEDPOLYGONALFACEWITHVOIDS",
294 vec![
295 ints(&[1, 2, 3, 4]),
296 grid(&[&[5, 6, 7, 8], &[9, 10, 11, 12]]),
297 ],
298 );
299 let view = IndexedPolygonalFaceWithVoids::new(EntityId(1), &e);
300
301 let outer = view.base().outer_loop_0based().unwrap();
302 let inners = view.inner_loops_0based().unwrap();
303
304 assert_eq!(outer, vec![0, 1, 2, 3]);
305 assert_eq!(inners, vec![vec![4, 5, 6, 7], vec![8, 9, 10, 11]]);
306 assert_eq!(view.void_count().unwrap(), 2);
307
308 for inner in &inners {
310 for i in inner {
311 assert!(
312 !outer.contains(i),
313 "hole index {i} leaked into the outer loop"
314 );
315 }
316 }
317 }
318
319 #[test]
320 fn a_face_with_voids_is_distinguishable_from_a_plain_face() {
321 let plain = entity("IFCINDEXEDPOLYGONALFACE", vec![ints(&[1, 2, 3])]);
322 let voided = entity(
323 "IFCINDEXEDPOLYGONALFACEWITHVOIDS",
324 vec![ints(&[1, 2, 3, 4]), grid(&[&[5, 6, 7]])],
325 );
326 assert!(!IndexedPolygonalFace::new(EntityId(1), &plain).has_voids());
327 assert!(IndexedPolygonalFace::new(EntityId(1), &voided).has_voids());
328 }
329
330 #[test]
334 fn missing_inner_coord_indices_is_an_error_not_an_empty_hole_list() {
335 let e = entity("IFCINDEXEDPOLYGONALFACEWITHVOIDS", vec![ints(&[1, 2, 3])]);
336 let view = IndexedPolygonalFaceWithVoids::new(EntityId(2), &e);
337 assert!(view.inner_loops_1based().is_err());
338 assert!(view.base().outer_loop_1based().is_ok());
339 }
340}