del-msh-cpu 0.1.52

mesh utility library for computer graphics research and prototyping
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

//! methods related to triangle mesh topology

/// split polygons of polygonal mesh into triangles
pub fn from_polygon_mesh(elem2idx: &[usize], idx2vtx: &[usize]) -> (Vec<[usize; 3]>, Vec<usize>) {
    let mut num_tri = 0_usize;
    for i_elem in 0..elem2idx.len() - 1 {
        assert!(elem2idx[i_elem + 1] >= elem2idx[i_elem]);
        let num_node = elem2idx[i_elem + 1] - elem2idx[i_elem];
        num_tri += num_node - 2;
    }
    let mut tri2vtx = Vec::<[usize; 3]>::with_capacity(num_tri);
    let mut new2old = Vec::<usize>::with_capacity(num_tri);
    for i_elem in 0..elem2idx.len() - 1 {
        let num_node = elem2idx[i_elem + 1] - elem2idx[i_elem];
        let idx0 = elem2idx[i_elem];
        for i_node in 0..num_node - 2 {
            tri2vtx.push([
                idx2vtx[idx0],
                idx2vtx[idx0 + 1 + i_node],
                idx2vtx[idx0 + 2 + i_node],
            ]);
            new2old.push(i_elem);
        }
    }
    (tri2vtx, new2old)
}

/// split quad element to triangle element
pub fn from_quad_mesh(quad2vtx: &[[usize; 4]]) -> Vec<[usize; 3]> {
    let mut tri2vtx = Vec::with_capacity(quad2vtx.len() * 2);
    for q in quad2vtx {
        tri2vtx.push([q[0], q[1], q[2]]);
        tri2vtx.push([q[0], q[2], q[3]]);
    }
    tri2vtx
}

pub fn from_grid(nx: usize, ny: usize) -> Vec<[usize; 3]> {
    let mx = nx - 1;
    let my = ny - 1;
    let ncell = mx * my;
    let mut tri2vtx = Vec::<[usize; 3]>::with_capacity(ncell * 2);
    for imy in 0..my {
        for imx in 0..mx {
            let ivx0 = imx + imy * nx;
            let ivx1 = imx + 1 + imy * nx;
            let ivx2 = imx + 1 + (imy + 1) * nx;
            let ivx3 = imx + (imy + 1) * nx;
            tri2vtx.push([ivx0, ivx1, ivx2]);
            tri2vtx.push([ivx0, ivx2, ivx3]);
        }
    }
    assert_eq!(tri2vtx.len(), ncell * 2);
    tri2vtx
}

// above: from methods
// ---------------------------------

/// find node index of a triangle from the vertex index
pub fn find_node_tri(tri2vtx: &[usize; 3], i_vtx: usize) -> usize {
    if tri2vtx[0] == i_vtx {
        return 0;
    }
    if tri2vtx[1] == i_vtx {
        return 1;
    }
    if tri2vtx[2] == i_vtx {
        return 2;
    }
    panic!("vertex {} not found in triangle", i_vtx);
}

/// triangle surrounding triangle
pub fn elem2elem(
    elem2vtx: &[usize],
    num_node: usize,
    num_vtx: usize,
    is_simplex_indexing: bool,
) -> Vec<usize> {
    let (face2idx, idx2node) = if is_simplex_indexing {
        (
            del_geo_core::tri::FACE2IDX.to_vec(),
            del_geo_core::tri::IDX2NODE.to_vec(),
        )
    } else {
        crate::elem2elem::face2node_of_polygon_element(num_node)
    };
    match num_node {
        2 => crate::elem2elem::from_uniform_mesh::<_, 2, 2>(
            elem2vtx.as_chunks::<2>().0,
            &face2idx,
            &idx2node,
            num_vtx,
        )
        .into_flattened(),
        3 => crate::elem2elem::from_uniform_mesh::<_, 3, 3>(
            elem2vtx.as_chunks::<3>().0,
            &face2idx,
            &idx2node,
            num_vtx,
        )
        .into_flattened(),
        4 => crate::elem2elem::from_uniform_mesh::<_, 4, 4>(
            elem2vtx.as_chunks::<4>().0,
            &face2idx,
            &idx2node,
            num_vtx,
        )
        .into_flattened(),
        _ => panic!("unsupported num_node: {num_node}"),
    }
}