cartan-remesh 0.5.1

Adaptive remeshing primitives for triangle meshes on Riemannian manifolds
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// ~/cartan/cartan-remesh/tests/split_collapse.rs

use approx::assert_relative_eq;
use cartan_dec::Mesh;
use cartan_manifolds::euclidean::Euclidean;
use cartan_remesh::{RemeshError, collapse_edge, split_edge};
use nalgebra::SVector;

/// Build a diamond mesh: 4 vertices, 2 triangles sharing edge (1,2).
///
///     0
///    / \
///   1---2
///    \ /
///     3
fn diamond_mesh() -> Mesh<Euclidean<2>, 3, 2> {
    let manifold = Euclidean::<2>;
    let vertices = vec![
        SVector::from([0.0, 1.0]),
        SVector::from([-1.0, 0.0]),
        SVector::from([1.0, 0.0]),
        SVector::from([0.0, -1.0]),
    ];
    let triangles = vec![[1, 2, 0], [2, 1, 3]];
    Mesh::from_simplices(&manifold, vertices, triangles)
}

fn total_area(mesh: &Mesh<Euclidean<2>, 3, 2>, manifold: &Euclidean<2>) -> f64 {
    (0..mesh.n_simplices())
        .map(|t| mesh.triangle_area(manifold, t))
        .sum()
}

fn find_edge(mesh: &Mesh<Euclidean<2>, 3, 2>, a: usize, b: usize) -> Option<usize> {
    let (lo, hi) = if a < b { (a, b) } else { (b, a) };
    mesh.boundaries
        .iter()
        .position(|&[i, j]| i == lo && j == hi)
}

#[test]
fn split_edge_adds_one_vertex() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let nv_before = mesh.n_vertices();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let log = split_edge(&mut mesh, &manifold, edge);

    assert_eq!(mesh.n_vertices(), nv_before + 1);
    assert_eq!(log.splits.len(), 1);
    assert_eq!(log.splits[0].new_vertex, nv_before);
}

#[test]
fn split_edge_replaces_two_faces_with_four() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let nf_before = mesh.n_simplices();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let _ = split_edge(&mut mesh, &manifold, edge);

    assert_eq!(mesh.n_simplices(), nf_before + 2);
}

#[test]
fn split_edge_preserves_total_area() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let area_before = total_area(&mesh, &manifold);
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let _ = split_edge(&mut mesh, &manifold, edge);

    let area_after = total_area(&mesh, &manifold);
    assert_relative_eq!(area_before, area_after, epsilon = 1e-12);
}

#[test]
fn split_edge_new_vertex_at_midpoint() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let log = split_edge(&mut mesh, &manifold, edge);

    let new_v = log.splits[0].new_vertex;
    let pos = &mesh.vertices[new_v];
    assert_relative_eq!(pos[0], 0.0, epsilon = 1e-12);
    assert_relative_eq!(pos[1], 0.0, epsilon = 1e-12);
}

#[test]
fn split_edge_preserves_euler() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let euler_before = mesh.euler_characteristic();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let _ = split_edge(&mut mesh, &manifold, edge);

    assert_eq!(euler_before, mesh.euler_characteristic());
}

#[test]
fn collapse_edge_removes_one_vertex_and_two_faces() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let nv_before = mesh.n_vertices();
    let nf_before = mesh.n_simplices();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let log = collapse_edge(&mut mesh, &manifold, edge, 0.5)
        .expect("collapse should succeed on diamond mesh");

    assert_eq!(mesh.n_vertices(), nv_before - 1);
    assert_eq!(mesh.n_simplices(), nf_before - 2);
    assert_eq!(log.collapses.len(), 1);
    assert_eq!(log.collapses[0].removed_faces.len(), 2);
}

#[test]
fn collapse_edge_surviving_vertex_at_midpoint() {
    let manifold = Euclidean::<2>;
    let mut mesh = diamond_mesh();
    let edge = find_edge(&mesh, 1, 2).expect("edge (1,2) must exist");

    let log = collapse_edge(&mut mesh, &manifold, edge, 0.5).expect("collapse should succeed");

    let survivor = log.collapses[0].surviving_vertex;
    let pos = &mesh.vertices[survivor];
    assert_relative_eq!(pos[0], 0.0, epsilon = 1e-12);
    assert_relative_eq!(pos[1], 0.0, epsilon = 1e-12);
}

#[test]
fn collapse_edge_rejects_foldover() {
    // Vertex 4 at (-0.6, 0.1) makes triangle [1,4,0] barely CCW.
    // Collapsing edge (1,3) moves vertex 1 from (-1,0) to the midpoint (-0.5,-0.5),
    // which flips [1,4,0] from CCW (area=+0.35) to CW (area=-0.275).
    let manifold = Euclidean::<2>;
    let vertices = vec![
        SVector::from([0.0, 2.0]),  // 0
        SVector::from([-1.0, 0.0]), // 1
        SVector::from([1.0, 0.0]),  // 2
        SVector::from([0.0, -1.0]), // 3
        SVector::from([-0.6, 0.1]), // 4
    ];
    let triangles = vec![[1, 2, 0], [2, 1, 3], [1, 3, 4], [1, 4, 0]];
    let mut mesh = Mesh::from_simplices(&manifold, vertices, triangles);
    let edge13 = find_edge(&mesh, 1, 3).expect("edge (1,3) must exist");

    let result = collapse_edge(&mut mesh, &manifold, edge13, 0.0);
    assert!(
        matches!(result, Err(RemeshError::Foldover { .. })),
        "collapse should be rejected: triangle [1,4,0] flips when 1 moves to midpoint"
    );
}