honeycomb_core/cmap/builder/
io.rs

1use std::collections::{BTreeMap, HashMap};
2
3use itertools::multizip;
4use num_traits::Zero;
5use vtkio::model::{CellType, DataSet, VertexNumbers};
6use vtkio::{IOBuffer, Vtk};
7
8use crate::attributes::AttrStorageManager;
9use crate::cmap::{BuilderError, CMap2, DartIdType, VertexIdType};
10use crate::geometry::{CoordsFloat, Vertex2};
11
12// --- Custom
13
14pub(crate) struct CMapFile {
15    pub meta: (String, usize, usize),
16    pub betas: String,
17    pub unused: Option<String>,
18    pub vertices: Option<String>,
19}
20
21pub(crate) fn parse_meta(meta_line: &str) -> Result<(String, usize, usize), BuilderError> {
22    let parts: Vec<&str> = meta_line.split_whitespace().collect();
23    if parts.len() != 3 {
24        return Err(BuilderError::BadMetaData("incorrect format"));
25    }
26
27    Ok((
28        parts[0].to_string(),
29        parts[1]
30            .parse()
31            .map_err(|_| BuilderError::BadMetaData("could not parse dimension"))?,
32        parts[2]
33            .parse()
34            .map_err(|_| BuilderError::BadMetaData("could not parse dart number"))?,
35    ))
36}
37
38impl TryFrom<String> for CMapFile {
39    type Error = BuilderError;
40
41    fn try_from(value: String) -> Result<Self, Self::Error> {
42        let mut sections = HashMap::new();
43        let mut current_section = String::new();
44
45        for line in value.trim().lines() {
46            let trimmed = line.trim();
47            if trimmed.is_empty() || trimmed.starts_with('#') {
48                // ignore empty & comment lines
49                continue;
50            }
51            if trimmed.starts_with('[') && trimmed.contains(']') {
52                // process section header
53                let section_name = trimmed.trim_matches(['[', ']']).to_lowercase();
54
55                if section_name != "meta"
56                    && section_name != "betas"
57                    && section_name != "unused"
58                    && section_name != "vertices"
59                {
60                    return Err(BuilderError::UnknownHeader(section_name));
61                }
62
63                if sections
64                    .insert(section_name.clone(), String::new())
65                    .is_some()
66                {
67                    return Err(BuilderError::DuplicatedSection(section_name));
68                }
69                current_section = section_name;
70
71                continue;
72            }
73            if !current_section.is_empty() {
74                // regular line
75                let line_without_comment = trimmed.split('#').next().unwrap().trim();
76                if !line_without_comment.is_empty() {
77                    let current_content = sections.get_mut(&current_section).unwrap();
78                    if !current_content.is_empty() {
79                        current_content.push('\n');
80                    }
81                    current_content.push_str(line_without_comment);
82                }
83            }
84        }
85
86        if !sections.contains_key("meta") {
87            // missing required section
88            return Err(BuilderError::MissingSection("meta"));
89        }
90        if !sections.contains_key("betas") {
91            // missing required section
92            return Err(BuilderError::MissingSection("betas"));
93        }
94
95        Ok(Self {
96            meta: parse_meta(sections["meta"].as_str())?,
97            betas: sections["betas"].clone(),
98            unused: sections.get("unused").cloned(),
99            vertices: sections.get("vertices").cloned(),
100        })
101    }
102}
103
104// ------ building routines
105
106pub fn build_2d_from_cmap_file<T: CoordsFloat>(
107    f: CMapFile,
108    manager: AttrStorageManager, // FIXME: find a cleaner solution to populate the manager
109) -> Result<CMap2<T>, BuilderError> {
110    if f.meta.1 != 2 {
111        // mismatched dim
112        return Err(BuilderError::BadMetaData(
113            "mismatch between requested dimension and header",
114        ));
115    }
116    let mut map = CMap2::new_with_undefined_attributes(f.meta.2, manager);
117
118    // putting it in a scope to drop the data
119    let betas = f.betas.lines().collect::<Vec<_>>();
120    if betas.len() != 3 {
121        // mismatched dim
122        return Err(BuilderError::InconsistentData(
123            "wrong number of beta functions",
124        ));
125    }
126    let b0 = betas[0]
127        .split_whitespace()
128        .map(str::parse)
129        .collect::<Vec<_>>();
130    let b1 = betas[1]
131        .split_whitespace()
132        .map(str::parse)
133        .collect::<Vec<_>>();
134    let b2 = betas[2]
135        .split_whitespace()
136        .map(str::parse)
137        .collect::<Vec<_>>();
138
139    // mismatched dart number
140    if b0.len() != f.meta.2 + 1 {
141        return Err(BuilderError::InconsistentData(
142            "wrong number of values for the beta 0 function",
143        ));
144    }
145    if b1.len() != f.meta.2 + 1 {
146        return Err(BuilderError::InconsistentData(
147            "wrong number of values for the beta 1 function",
148        ));
149    }
150    if b2.len() != f.meta.2 + 1 {
151        return Err(BuilderError::InconsistentData(
152            "wrong number of values for the beta 2 function",
153        ));
154    }
155
156    for (d, b0d, b1d, b2d) in multizip((
157        (1..=f.meta.2),
158        b0.into_iter().skip(1),
159        b1.into_iter().skip(1),
160        b2.into_iter().skip(1),
161    )) {
162        let b0d = b0d.map_err(|_| BuilderError::BadValue("could not parse a b0 value"))?;
163        let b1d = b1d.map_err(|_| BuilderError::BadValue("could not parse a b1 value"))?;
164        let b2d = b2d.map_err(|_| BuilderError::BadValue("could not parse a b2 value"))?;
165        map.set_betas(d as DartIdType, [b0d, b1d, b2d]);
166    }
167
168    if let Some(unused) = f.unused {
169        for u in unused.split_whitespace() {
170            let d = u
171                .parse()
172                .map_err(|_| BuilderError::BadValue("could not parse an unused ID"))?;
173            map.remove_free_dart(d);
174        }
175    }
176
177    if let Some(vertices) = f.vertices {
178        for l in vertices.trim().lines() {
179            let mut it = l.split_whitespace();
180            let id: VertexIdType = it
181                .next()
182                .ok_or(BuilderError::BadValue("incorrect vertex line format"))?
183                .parse()
184                .map_err(|_| BuilderError::BadValue("could not parse vertex ID"))?;
185            let x: f64 = it
186                .next()
187                .ok_or(BuilderError::BadValue("incorrect vertex line format"))?
188                .parse()
189                .map_err(|_| BuilderError::BadValue("could not parse vertex x coordinate"))?;
190            let y: f64 = it
191                .next()
192                .ok_or(BuilderError::BadValue("incorrect vertex line format"))?
193                .parse()
194                .map_err(|_| BuilderError::BadValue("could not parse vertex y coordinate"))?;
195            if it.next().is_some() {
196                return Err(BuilderError::BadValue("incorrect vertex line format"));
197            }
198            map.force_write_vertex(id, (T::from(x).unwrap(), T::from(y).unwrap()));
199        }
200    }
201
202    Ok(map)
203}
204
205// --- VTK
206
207macro_rules! if_predicate_return_err {
208    ($pr: expr, $er: expr) => {
209        if $pr {
210            return Err($er);
211        }
212    };
213}
214
215macro_rules! build_vertices {
216    ($v: ident) => {{
217        if_predicate_return_err!(
218            !($v.len() % 3).is_zero(),
219            BuilderError::BadVtkData("vertex list contains an incomplete tuple")
220        );
221        $v.chunks_exact(3)
222            .map(|slice| {
223                // WE IGNORE Z values
224                let &[x, y, _] = slice else { unreachable!() };
225                Vertex2(T::from(x).unwrap(), T::from(y).unwrap())
226            })
227            .collect()
228    }};
229}
230
231// ------ building routine
232
233#[allow(clippy::too_many_lines)]
234/// Internal building routine for [`CMap2::from_vtk_file`].
235///
236/// # Result / Errors
237///
238/// This implementation support only a very specific subset of VTK files. This result in many
239/// possibilities for failure. This function may return:
240///
241/// - `Ok(CMap2)` -- The file was successfully parsed and its content made into a 2-map.
242/// - `Err(BuilderError)` -- The function failed for one of the following reasons (sorted
243///   by [`BuilderError`] variants):
244///     - `UnsupportedVtkData`: The file contains unsupported data, i.e.:
245///         - file format isn't Legacy,
246///         - data set is something other than `UnstructuredGrid`,
247///         - coordinate representation type isn't `float` or `double`
248///         - mesh contains unsupported cell types (`PolyVertex`, `PolyLine`, `TriangleStrip`,
249///           `Pixel` or anything 3D)
250///     - `InvalidVtkFile`: The file contains inconsistencies, i.e.:
251///         - the number of coordinates cannot be divided by `3`, meaning a tuple is incomplete
252///         - the number of `Cells` and `CellTypes` isn't equal
253///         - a given cell has an inconsistent number of vertices with its specified cell type
254pub fn build_2d_from_vtk<T: CoordsFloat>(
255    value: Vtk,
256    mut _manager: AttrStorageManager, // FIXME: find a cleaner solution to populate the manager
257) -> Result<CMap2<T>, BuilderError> {
258    let mut cmap: CMap2<T> = CMap2::new(0);
259    let mut sew_buffer: BTreeMap<(usize, usize), DartIdType> = BTreeMap::new();
260    match value.data {
261        DataSet::ImageData { .. }
262        | DataSet::StructuredGrid { .. }
263        | DataSet::RectilinearGrid { .. }
264        | DataSet::PolyData { .. }
265        | DataSet::Field { .. } => {
266            return Err(BuilderError::UnsupportedVtkData("dataset not supported"));
267        }
268        DataSet::UnstructuredGrid { pieces, .. } => {
269            let mut tmp = pieces.iter().map(|piece| {
270                // assume inline data
271                let Ok(tmp) = piece.load_piece_data(None) else {
272                    return Err(BuilderError::UnsupportedVtkData("not inlined data piece"));
273                };
274
275                // build vertex list
276                // since we're expecting coordinates, we'll assume floating type
277                // we're also converting directly to our vertex type since we're building a 2-map
278                let vertices: Vec<Vertex2<T>> = match tmp.points {
279                    IOBuffer::F64(v) => build_vertices!(v),
280                    IOBuffer::F32(v) => build_vertices!(v),
281                    _ => {
282                        return Err(BuilderError::UnsupportedVtkData(
283                            "unsupported coordinate type",
284                        ));
285                    }
286                };
287
288                let vtkio::model::Cells { cell_verts, types } = tmp.cells;
289                match cell_verts {
290                    VertexNumbers::Legacy {
291                        num_cells,
292                        vertices: verts,
293                    } => {
294                        // check basic stuff
295                        if_predicate_return_err!(
296                            num_cells as usize != types.len(),
297                            BuilderError::BadVtkData("different # of cell in CELLS and CELL_TYPES")
298                        );
299
300                        // build a collection of vertex lists corresponding of each cell
301                        let mut cell_components: Vec<Vec<usize>> = Vec::new();
302                        let mut take_next = 0;
303                        for vertex_id in &verts {
304                            if take_next.is_zero() {
305                                // making it usize since it's a counter
306                                take_next = *vertex_id as usize;
307                                cell_components.push(Vec::with_capacity(take_next));
308                            } else {
309                                cell_components
310                                    .last_mut()
311                                    .expect("E: unreachable")
312                                    .push(*vertex_id as usize);
313                                take_next -= 1;
314                            }
315                        }
316                        assert_eq!(num_cells as usize, cell_components.len());
317
318                        let mut errs =
319                            types
320                                .iter()
321                                .zip(cell_components.iter())
322                                .map(|(cell_type, vids)| match cell_type {
323                                    CellType::Vertex => {
324                                        if_predicate_return_err!(
325                                            vids.len() != 1,
326                                            BuilderError::BadVtkData(
327                                                "`Vertex` with incorrect # of vertices (!=1)"
328                                            )
329                                        );
330                                        // silent ignore
331                                        Ok(())
332                                    }
333                                    CellType::PolyVertex => Err(BuilderError::UnsupportedVtkData(
334                                        "`PolyVertex` cell type",
335                                    )),
336                                    CellType::Line => {
337                                        if_predicate_return_err!(
338                                            vids.len() != 2,
339                                            BuilderError::BadVtkData(
340                                                "`Line` with incorrect # of vertices (!=2)"
341                                            )
342                                        );
343                                        // silent ignore
344                                        Ok(())
345                                    }
346                                    CellType::PolyLine => Err(BuilderError::UnsupportedVtkData(
347                                        "`PolyLine` cell type",
348                                    )),
349                                    CellType::Triangle => {
350                                        // check validity
351                                        if_predicate_return_err!(
352                                            vids.len() != 3,
353                                            BuilderError::BadVtkData(
354                                                "`Triangle` with incorrect # of vertices (!=3)"
355                                            )
356                                        );
357                                        // build the triangle
358                                        let d0 = cmap.add_free_darts(3);
359                                        let (d1, d2) = (d0 + 1, d0 + 2);
360                                        cmap.force_write_vertex(
361                                            d0 as VertexIdType,
362                                            vertices[vids[0]],
363                                        );
364                                        cmap.force_write_vertex(
365                                            d1 as VertexIdType,
366                                            vertices[vids[1]],
367                                        );
368                                        cmap.force_write_vertex(
369                                            d2 as VertexIdType,
370                                            vertices[vids[2]],
371                                        );
372                                        cmap.force_link::<1>(d0, d1).unwrap(); // edge d0 links vertices vids[0] & vids[1]
373                                        cmap.force_link::<1>(d1, d2).unwrap(); // edge d1 links vertices vids[1] & vids[2]
374                                        cmap.force_link::<1>(d2, d0).unwrap(); // edge d2 links vertices vids[2] & vids[0]
375                                        // record a trace of the built cell for future 2-sew
376                                        sew_buffer.insert((vids[0], vids[1]), d0);
377                                        sew_buffer.insert((vids[1], vids[2]), d1);
378                                        sew_buffer.insert((vids[2], vids[0]), d2);
379                                        Ok(())
380                                    }
381                                    CellType::TriangleStrip => {
382                                        Err(BuilderError::UnsupportedVtkData(
383                                            "`TriangleStrip` cell type",
384                                        ))
385                                    }
386                                    CellType::Polygon => {
387                                        let n_vertices = vids.len();
388                                        let d0 = cmap.add_free_darts(n_vertices);
389                                        (0..n_vertices).for_each(|i| {
390                                            let di = d0 + i as DartIdType;
391                                            let dip1 =
392                                                if i == n_vertices - 1 { d0 } else { di + 1 };
393                                            cmap.force_write_vertex(
394                                                di as VertexIdType,
395                                                vertices[vids[i]],
396                                            );
397                                            cmap.force_link::<1>(di, dip1).unwrap();
398                                            sew_buffer
399                                                .insert((vids[i], vids[(i + 1) % n_vertices]), di);
400                                        });
401                                        Ok(())
402                                    }
403                                    CellType::Pixel => {
404                                        Err(BuilderError::UnsupportedVtkData("`Pixel` cell type"))
405                                    }
406                                    CellType::Quad => {
407                                        if_predicate_return_err!(
408                                            vids.len() != 4,
409                                            BuilderError::BadVtkData(
410                                                "`Quad` with incorrect # of vertices (!=4)"
411                                            )
412                                        );
413                                        // build the quad
414                                        let d0 = cmap.add_free_darts(4);
415                                        let (d1, d2, d3) = (d0 + 1, d0 + 2, d0 + 3);
416                                        cmap.force_write_vertex(
417                                            d0 as VertexIdType,
418                                            vertices[vids[0]],
419                                        );
420                                        cmap.force_write_vertex(
421                                            d1 as VertexIdType,
422                                            vertices[vids[1]],
423                                        );
424                                        cmap.force_write_vertex(
425                                            d2 as VertexIdType,
426                                            vertices[vids[2]],
427                                        );
428                                        cmap.force_write_vertex(
429                                            d3 as VertexIdType,
430                                            vertices[vids[3]],
431                                        );
432                                        cmap.force_link::<1>(d0, d1).unwrap(); // edge d0 links vertices vids[0] & vids[1]
433                                        cmap.force_link::<1>(d1, d2).unwrap(); // edge d1 links vertices vids[1] & vids[2]
434                                        cmap.force_link::<1>(d2, d3).unwrap(); // edge d2 links vertices vids[2] & vids[3]
435                                        cmap.force_link::<1>(d3, d0).unwrap(); // edge d3 links vertices vids[3] & vids[0]
436                                        // record a trace of the built cell for future 2-sew
437                                        sew_buffer.insert((vids[0], vids[1]), d0);
438                                        sew_buffer.insert((vids[1], vids[2]), d1);
439                                        sew_buffer.insert((vids[2], vids[3]), d2);
440                                        sew_buffer.insert((vids[3], vids[0]), d3);
441                                        Ok(())
442                                    }
443                                    _ => Err(BuilderError::UnsupportedVtkData(
444                                        "CellType not supported in 2-maps",
445                                    )),
446                                });
447                        if let Some(is_err) = errs.find(Result::is_err) {
448                            return Err(is_err.unwrap_err()); // unwrap & wrap because type inference is clunky
449                        }
450                    }
451                    VertexNumbers::XML { .. } => {
452                        return Err(BuilderError::UnsupportedVtkData("XML format"));
453                    }
454                }
455                Ok(())
456            });
457            // return the first error if there is one
458            if let Some(is_err) = tmp.find(Result::is_err) {
459                return Err(is_err.unwrap_err()); // unwrap & wrap because type inference is clunky
460            }
461        }
462    }
463    while let Some(((id0, id1), dart_id0)) = sew_buffer.pop_first() {
464        if let Some(dart_id1) = sew_buffer.remove(&(id1, id0)) {
465            cmap.force_sew::<2>(dart_id0, dart_id1).unwrap();
466        }
467    }
468    Ok(cmap)
469}
honeycomb_core/cmap/builder/io.rs

honeycomb_core/cmap/builder/
io.rs
