honeycomb_kernels/remeshing/cut.rs
1use honeycomb_core::{
2 cmap::{CMap2, DartIdType, EdgeIdType, SewError},
3 geometry::{CoordsFloat, Vertex2},
4 stm::{Transaction, TransactionClosureResult, retry, try_or_coerce},
5};
6
7/// Cut an edge in half and build triangles from the new vertex.
8///
9/// This function takes an edge of the map's boundary as argument, cut it in half, and build two
10/// triangles from the new vertex.
11///
12/// ```text
13///
14/// + +
15/// / \ /|\
16/// / \ / | \
17/// / \ --> / | \
18/// / \ / | \
19/// / \ / | \
20/// +-----------+ +-----+-----+
21/// e
22///
23/// ```
24///
25/// This function expects to operate on a triangular mesh. At the moment, calling it on another type
26/// of mesh may result in non-explicit errors (e.g. an internal sew operation will consistently fail
27/// due to a dart being non-free) as there is no check on the face's degree.
28///
29/// # Arguments
30///
31/// - `t: &mut Transaction` -- Associated transaction.
32/// - `map: &mut CMap2` -- Edited map.
33/// - `e: EdgeIdType` -- Edge to cut.
34/// - `[nd1, nd2, nd3]: [DartIdType; 3]` -- Free darts used to create the new edges.
35///
36/// # Errors
37///
38/// This function will abort and raise an error if:
39/// - the transaction cannot be completed,
40/// - one of the edge's vertex has no associated coordinates value,
41/// - one internal sew operation fails.
42///
43/// The returned error can be used in conjunction with transaction control to avoid any
44/// modifications in case of failure at attribute level. The user can then choose to retry or
45/// abort as he wishes using `Transaction::with_control_and_err`.
46#[inline]
47pub fn cut_outer_edge<T: CoordsFloat>(
48 t: &mut Transaction,
49 map: &CMap2<T>,
50 e: EdgeIdType,
51 [nd1, nd2, nd3]: [DartIdType; 3],
52) -> TransactionClosureResult<(), SewError> {
53 // unfallible
54 try_or_coerce!(map.link::<2>(t, nd1, nd2), SewError);
55 try_or_coerce!(map.link::<1>(t, nd2, nd3), SewError);
56
57 let ld = e as DartIdType;
58 let (b0ld, b1ld) = (map.beta_transac::<0>(t, ld)?, map.beta_transac::<1>(t, ld)?);
59
60 let (vid1, vid2) = (
61 map.vertex_id_transac(t, ld)?,
62 map.vertex_id_transac(t, b1ld)?,
63 );
64 let new_v = match (map.read_vertex(t, vid1)?, map.read_vertex(t, vid2)?) {
65 (Some(v1), Some(v2)) => Vertex2::average(&v1, &v2),
66 _ => retry()?,
67 };
68 map.write_vertex(t, nd1, new_v)?;
69
70 map.unsew::<1>(t, ld)?;
71 map.unsew::<1>(t, b1ld)?;
72
73 map.sew::<1>(t, ld, nd1)?;
74 map.sew::<1>(t, nd1, b0ld)?;
75 map.sew::<1>(t, nd3, b1ld)?;
76 map.sew::<1>(t, b1ld, nd2)?;
77
78 Ok(())
79}
80
81/// Cut an edge in half and build triangles from the new vertex.
82///
83/// This function takes an edge of the map's as argument, cut it in half, and build four triangles
84/// from the new vertex.
85///
86/// ```text
87///
88/// + +
89/// / \ /|\
90/// / \ / | \
91/// / \ / | \
92/// / \ / | \
93/// / \ / | \
94/// +-----------+ --> +-----+-----+
95/// \ e / \ | /
96/// \ / \ | /
97/// \ / \ | /
98/// \ / \ | /
99/// \ / \|/
100/// + +
101///
102/// ```
103///
104/// This function expects to operate on a triangular mesh. At the moment, calling it on another type
105/// of mesh may result in non-explicit errors (e.g. an internal sew operation will consistently fail
106/// due to a dart being non-free) as there is no check on each faces' degree.
107///
108/// # Arguments
109///
110/// - `t: &mut Transaction` -- Associated transaction.
111/// - `map: &mut CMap2` -- Edited map.
112/// - `e: EdgeIdType` -- Edge to cut.
113/// - `[nd1, nd2, nd3, nd4, nd5, nd6]: [DartIdType; 6]` -- Free darts used to create the new edges.
114///
115/// # Errors
116///
117/// This function will abort and raise an error if:
118/// - the transaction cannot be completed,
119/// - one of the edge's vertex has no associated coordinates value,
120/// - one internal sew operation fails.
121///
122/// The returned error can be used in conjunction with transaction control to avoid any
123/// modifications in case of failure at attribute level. The user can then choose to retry or
124/// abort as he wishes using `Transaction::with_control_and_err`.
125#[inline]
126pub fn cut_inner_edge<T: CoordsFloat>(
127 t: &mut Transaction,
128 map: &CMap2<T>,
129 e: EdgeIdType,
130 [nd1, nd2, nd3, nd4, nd5, nd6]: [DartIdType; 6],
131) -> TransactionClosureResult<(), SewError> {
132 // unfallible
133 try_or_coerce!(map.link::<2>(t, nd1, nd2), SewError);
134 try_or_coerce!(map.link::<1>(t, nd2, nd3), SewError);
135 try_or_coerce!(map.link::<2>(t, nd4, nd5), SewError);
136 try_or_coerce!(map.link::<1>(t, nd5, nd6), SewError);
137
138 let (ld, rd) = (e as DartIdType, map.beta_transac::<2>(t, e as DartIdType)?);
139 let (b0ld, b1ld) = (map.beta_transac::<0>(t, ld)?, map.beta_transac::<1>(t, ld)?);
140 let (b0rd, b1rd) = (map.beta_transac::<0>(t, rd)?, map.beta_transac::<1>(t, rd)?);
141
142 let (vid1, vid2) = (
143 map.vertex_id_transac(t, ld)?,
144 map.vertex_id_transac(t, b1ld)?,
145 );
146 let new_v = match (map.read_vertex(t, vid1)?, map.read_vertex(t, vid2)?) {
147 (Some(v1), Some(v2)) => Vertex2::average(&v1, &v2),
148 _ => retry()?,
149 };
150 map.write_vertex(t, nd1, new_v)?;
151
152 map.unsew::<2>(t, ld)?;
153 map.unsew::<1>(t, ld)?;
154 map.unsew::<1>(t, b1ld)?;
155 map.unsew::<1>(t, rd)?;
156 map.unsew::<1>(t, b1rd)?;
157
158 map.sew::<2>(t, ld, nd6)?;
159 map.sew::<2>(t, rd, nd3)?;
160
161 map.sew::<1>(t, ld, nd1)?;
162 map.sew::<1>(t, nd1, b0ld)?;
163 map.sew::<1>(t, nd3, b1ld)?;
164 map.sew::<1>(t, b1ld, nd2)?;
165
166 map.sew::<1>(t, rd, nd4)?;
167 map.sew::<1>(t, nd4, b0rd)?;
168 map.sew::<1>(t, nd6, b1rd)?;
169 map.sew::<1>(t, b1rd, nd5)?;
170
171 Ok(())
172}