runmat-meshing-surface 0.6.0

Surface meshing stage for RunMat meshing
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct SurfaceRecoveryOptions {
    pub require_closed: bool,
    pub max_area_relative_error: f64,
    pub min_normal_alignment: f64,
}

impl Default for SurfaceRecoveryOptions {
    fn default() -> Self {
        Self {
            require_closed: true,
            max_area_relative_error: 1.0e-8,
            min_normal_alignment: 1.0 - 1.0e-8,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SurfaceRecoveryReport {
    pub surface_element_count: usize,
    pub recovered_edge_count: usize,
    pub open_edge_count: usize,
    pub nonmanifold_edge_count: usize,
    pub max_area_relative_error: f64,
    pub min_normal_alignment: f64,
    pub source_face_coverage_ratio: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub enum SurfaceRecoveryError {
    EmptySurface,
    InvalidOptions,
    MissingSurfaceNode {
        element_id: u32,
        node_id: u32,
    },
    NonFiniteSurfaceNode {
        node_id: u32,
    },
    DegenerateElement {
        element_id: u32,
    },
    AreaMismatch {
        element_id: u32,
        relative_error: f64,
        max_relative_error: f64,
    },
    SourceFaceAreaMismatch {
        source_face_id: u32,
        relative_error: f64,
        max_relative_error: f64,
    },
    NormalMismatch {
        element_id: u32,
        alignment: f64,
        min_alignment: f64,
    },
    MissingSourceFace {
        source_face_id: u32,
    },
    UncoveredSourceFace {
        source_face_id: u32,
    },
    OpenEdge {
        edge: [u32; 2],
        count: usize,
    },
    NonManifoldEdge {
        edge: [u32; 2],
        count: usize,
    },
}

impl std::fmt::Display for SurfaceRecoveryError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::EmptySurface => write!(formatter, "surface recovery input has no elements"),
            Self::InvalidOptions => write!(
                formatter,
                "surface recovery options must use finite area and normal thresholds"
            ),
            Self::MissingSurfaceNode {
                element_id,
                node_id,
            } => write!(
                formatter,
                "surface element {element_id} references missing node {node_id}"
            ),
            Self::NonFiniteSurfaceNode { node_id } => {
                write!(formatter, "surface node {node_id} has non-finite coordinates")
            }
            Self::DegenerateElement { element_id } => {
                write!(formatter, "surface element {element_id} is degenerate")
            }
            Self::AreaMismatch {
                element_id,
                relative_error,
                max_relative_error,
            } => write!(
                formatter,
                "surface element {element_id} area relative error {relative_error:.6e} exceeds {max_relative_error:.6e}"
            ),
            Self::SourceFaceAreaMismatch {
                source_face_id,
                relative_error,
                max_relative_error,
            } => write!(
                formatter,
                "source face {source_face_id} recovered area relative error {relative_error:.6e} exceeds {max_relative_error:.6e}"
            ),
            Self::NormalMismatch {
                element_id,
                alignment,
                min_alignment,
            } => write!(
                formatter,
                "surface element {element_id} normal alignment {alignment:.6e} is below {min_alignment:.6e}"
            ),
            Self::MissingSourceFace { source_face_id } => {
                write!(formatter, "source face {source_face_id} is not present in topology")
            }
            Self::UncoveredSourceFace { source_face_id } => {
                write!(formatter, "source face {source_face_id} is not covered by surface mesh")
            }
            Self::OpenEdge { edge, count } => write!(
                formatter,
                "surface edge {}-{} has incidence {count}, expected 2",
                edge[0], edge[1]
            ),
            Self::NonManifoldEdge { edge, count } => write!(
                formatter,
                "surface edge {}-{} has non-manifold incidence {count}, expected 2",
                edge[0], edge[1]
            ),
        }
    }
}

impl std::error::Error for SurfaceRecoveryError {}