del-msh-cpu 0.1.46

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! group elements using the connectivity information

/// mark elements with "idx_group" that is connected to "idx_elem_kernel"
/// * `elem_group` - array of group index for element
/// * `elem_adjelem` - array of adjacent element for element
pub fn mark_connected_elements_for_uniform_mesh(
    elem2group: &mut [usize],
    idx_elem_kernel: usize,
    idx_group: usize,
    elem2adjelem: &[usize],
) {
    let num_elem = elem2group.len();
    assert_eq!(elem2adjelem.len() % num_elem, 0);
    let num_face_par_elem = elem2adjelem.len() / num_elem;
    elem2group[idx_elem_kernel] = idx_group;
    let mut next = vec![idx_elem_kernel];
    while let Some(i_elem0) = next.pop() {
        for ie in 0..num_face_par_elem {
            let ita = elem2adjelem[i_elem0 * num_face_par_elem + ie];
            if ita == usize::MAX {
                continue;
            }
            if elem2group[ita] != idx_group {
                elem2group[ita] = idx_group;
                next.push(ita);
            }
        }
    }
}

/// group uniform mesh
/// * `elem2vtx` - the indices of vertex for each element
/// * `num_node` - number of vertices par element
/// * `elem2elem_adj` - the adjacent element index of an element
pub fn from_uniform_mesh_with_elem2elem(
    elem2vtx: &[usize],
    num_node: usize,
    elem2adjelem: &[usize],
) -> (usize, Vec<usize>) {
    let nelem = elem2vtx.len() / num_node;
    let mut elem2group = vec![usize::MAX; nelem];
    let mut i_group = 0;
    loop {
        let mut itri_ker = usize::MAX;
        for (i_tri, &group) in elem2group.iter().enumerate() {
            if group != usize::MAX {
                continue;
            }
            itri_ker = i_tri;
            break;
        }
        if itri_ker == usize::MAX {
            break;
        }
        mark_connected_elements_for_uniform_mesh(&mut elem2group, itri_ker, i_group, elem2adjelem);
        i_group += 1;
    }
    (i_group, elem2group)
}

pub fn from_triangle_mesh(tri2vtx: &[usize], num_vtx: usize) -> (usize, Vec<usize>) {
    let tri2tri = crate::elem2elem::from_uniform_mesh(
        tri2vtx,
        3,
        &del_geo_core::tri::FACE2IDX,
        &del_geo_core::tri::IDX2NODE,
        num_vtx,
    );
    from_uniform_mesh_with_elem2elem(tri2vtx, 3, &tri2tri)
}

/// mark elements with "idx_group" that is connected to "idx_elem_kernel"
/// * `elem2group` - array of group index for element
/// * `elemface2adjelem` - function takes i_elem and i_face and output index of adjacent element
pub fn mark_connected_elements_for_polygon_mesh<F>(
    elem2group: &mut [usize],
    idx_elem_kernel: usize,
    idx_group: usize,
    elem2idx: &[usize],
    elemface2adjelem: F,
) where
    F: Fn(usize, usize) -> usize,
{
    let num_elem = elem2group.len();
    assert_eq!(num_elem, elem2idx.len() - 1);
    elem2group[idx_elem_kernel] = idx_group;
    let mut next = vec![idx_elem_kernel];
    while let Some(i_elem0) = next.pop() {
        let num_adjelem_for_ielem0 = elem2idx[i_elem0 + 1] - elem2idx[i_elem0];
        for i_face0 in 0..num_adjelem_for_ielem0 {
            let j_elem = elemface2adjelem(i_elem0, i_face0);
            if j_elem == usize::MAX {
                continue;
            }
            if elem2group[j_elem] != idx_group {
                elem2group[j_elem] = idx_group;
                next.push(j_elem);
            }
        }
    }
}

/// group uniform mesh
/// * `elem2vtx` - the indices of vertex for each element
/// * `num_node` - number of vertices par element
/// * `elem2elem_adj` - the adjacent element index of an element
pub fn from_polygon_mesh<F>(elem2idx: &[usize], elemface2adjelem: F) -> (usize, Vec<usize>)
where
    F: Fn(usize, usize) -> usize,
{
    let nelem = elem2idx.len() - 1;
    let mut elem2group = vec![usize::MAX; nelem];
    let mut i_group = 0;
    loop {
        let mut itri_ker = usize::MAX;
        for (i_tri, &group) in elem2group.iter().enumerate() {
            if group != usize::MAX {
                continue;
            }
            itri_ker = i_tri;
            break;
        }
        if itri_ker == usize::MAX {
            break;
        }
        mark_connected_elements_for_polygon_mesh(
            &mut elem2group,
            itri_ker,
            i_group,
            elem2idx,
            &elemface2adjelem,
        );
        i_group += 1;
    }
    (i_group, elem2group)
}