procedural_modelling 0.4.2

A framework-agnostic Procedural Modelling crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::collections::HashMap;

use crate::{
    halfedge::HalfEdgeImplMeshType,
    math::IndexType,
    mesh::{EdgeBasics, HalfEdge, MeshBasics},
};

use super::HalfEdgeMeshImpl;

/// A pseudo-winged edge representation of an edge for debugging purposes
#[derive(Clone)]
pub(crate) struct PseudoWingedEdge<E, V, F>
where
    E: IndexType,
    V: IndexType,
    F: IndexType,
{
    id: E,
    twin: E,
    origin: V,
    target: V,
    prev: E,
    face: F,
    next: E,
    twin_prev: E,
    twin_face: F,
    twin_next: E,
}

impl<E: IndexType, V: IndexType, F: IndexType> std::fmt::Debug for PseudoWingedEdge<E, V, F> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{: >w$} -{:->w$}--><--{:-<w$}- {: <w$}  |  face: {: >w$} / {: <w$} [{: <w$}]/[{: <w$}] {: >w$} / {: <w$}",
            self.origin,
            self.id,
            self.twin,
            self.target,
            self.prev,
            self.twin_next,
            if self.face == IndexType::max() {
                "na".to_string()
            } else {
                self.face.index().to_string()
            },
            if self.twin_face == IndexType::max() {
                "na".to_string()
            } else {
                self.twin_face.index().to_string()
            },
            self.next,
            self.twin_prev,
            w = 2,
        )
    }
}

impl<T: HalfEdgeImplMeshType> HalfEdgeMeshImpl<T> {
    /// Returns all edges as pseudo-winged edges
    pub(crate) fn pair_edges(&self) -> Vec<PseudoWingedEdge<T::E, T::V, T::F>> {
        let mut edges: HashMap<T::E, PseudoWingedEdge<T::E, T::V, T::F>> = HashMap::new();
        self.edges().for_each(|edge| {
            let twin = edge.twin(self);
            if edges.contains_key(&twin.id()) {
                return;
            }
            edges.insert(
                edge.id(),
                PseudoWingedEdge {
                    id: edge.id(),
                    twin: twin.id(),
                    origin: edge.origin_id(),
                    target: twin.origin_id(),
                    prev: edge.prev_id(),
                    face: edge.face_id(),
                    next: edge.next_id(),
                    twin_prev: twin.prev_id(),
                    twin_face: twin.face_id(),
                    twin_next: twin.next_id(),
                },
            );
        });

        let mut vec: Vec<PseudoWingedEdge<T::E, T::V, T::F>> = edges.values().cloned().collect();
        vec.sort_by(|a, b| a.id.cmp(&b.id));
        vec
    }
}