del-msh-cpu 0.1.49

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

//! extract subset of elements as mesh

pub fn extract(
    oldtri2oldvtx: &[[usize; 3]],
    num_oldvtx: usize,
    oldtri2newtri: &[usize],
    num_newtri: usize,
) -> (Vec<[usize; 3]>, usize, Vec<usize>) {
    assert_eq!(oldtri2oldvtx.len(), oldtri2newtri.len());
    let num_tri = oldtri2oldvtx.len();
    let mut oldvtx2newvtx = vec![usize::MAX; num_oldvtx];
    let mut newtri2newvtx = vec![[usize::MAX; 3]; num_newtri];
    let mut num_newvtx = 0;
    for i_tri in 0..num_tri {
        if oldtri2newtri[i_tri] == usize::MAX {
            continue;
        }
        let i_tri_new = oldtri2newtri[i_tri];
        for i_node in 0..3 {
            let i_vtx_xyz = oldtri2oldvtx[i_tri][i_node];
            if oldvtx2newvtx[i_vtx_xyz] == usize::MAX {
                let i_vtx_new = num_newvtx;
                num_newvtx += 1;
                oldvtx2newvtx[i_vtx_xyz] = i_vtx_new;
                newtri2newvtx[i_tri_new][i_node] = i_vtx_new;
            } else {
                let i_vtx_new = oldvtx2newvtx[i_vtx_xyz];
                newtri2newvtx[i_tri_new][i_node] = i_vtx_new;
            }
        }
    }
    (newtri2newvtx, num_newvtx, oldvtx2newvtx)
}

pub fn map_values_old2new<VALUE>(
    old2value: &[VALUE],
    od2new: &[usize],
    num_new: usize,
    num_dim: usize,
) -> Vec<VALUE>
where
    VALUE: num_traits::Zero + Copy,
{
    let mut new2value = vec![VALUE::zero(); num_new * num_dim];
    for i_old in 0..old2value.len() / num_dim {
        let i_new = od2new[i_old];
        if i_new == usize::MAX {
            continue;
        }
        for i_dim in 0..num_dim {
            new2value[i_new * num_dim + i_dim] = old2value[i_old * num_dim + i_dim];
        }
    }
    new2value
}

pub fn from_polygonal_mesh_array(
    elem2idx: &[usize],
    idx2vtx: &[usize],
    elem2flag: &[bool],
) -> (Vec<usize>, Vec<usize>) {
    assert_eq!(elem2idx.len(), elem2flag.len() + 1);
    let mut felem2jdx = vec![0_usize; 1];
    let mut jdx2vtx = vec![0_usize; 0];
    for i_elem in 0..elem2flag.len() {
        if !elem2flag[i_elem] {
            continue;
        }
        let idx0 = elem2idx[i_elem];
        let idx1 = elem2idx[i_elem + 1];
        for &vtx in &idx2vtx[idx0..idx1] {
            jdx2vtx.push(vtx);
        }
        felem2jdx.push(jdx2vtx.len());
    }
    (felem2jdx, jdx2vtx)
}

pub fn from_polygonal_mesh_lambda<F: Fn(usize) -> bool>(
    elem2idx: &[usize],
    idx2vtx: &[usize],
    elem2flag: F,
) -> (Vec<usize>, Vec<usize>) {
    let mut felem2jdx = vec![0_usize; 1];
    let mut jdx2vtx = vec![0_usize; 0];
    let num_elem = elem2idx.len() - 1;
    for i_elem in 0..num_elem {
        if !elem2flag(i_elem) {
            continue;
        }
        let idx0 = elem2idx[i_elem];
        let idx1 = elem2idx[i_elem + 1];
        for &vtx in &idx2vtx[idx0..idx1] {
            jdx2vtx.push(vtx);
        }
        felem2jdx.push(jdx2vtx.len());
    }
    (felem2jdx, jdx2vtx)
}

pub fn from_uniform_mesh_lambda<F: Fn(usize) -> bool>(
    elem2vtx: &[usize],
    num_node: usize,
    elem2flag: F,
) -> Vec<usize> {
    let num_elem = elem2vtx.len() / num_node;
    let mut felem2vtx = vec![0_usize; 0];
    for i_elem in 0..num_elem {
        if !elem2flag(i_elem) {
            continue;
        }
        for i_node in 0..num_node {
            felem2vtx.push(elem2vtx[i_elem * num_node + i_node]);
        }
    }
    felem2vtx
}

pub fn from_uniform_mesh_from_list_of_elements(
    elem2vtx: &[usize],
    num_node: usize,
    elems: &[usize],
) -> Vec<usize> {
    let mut felem2vtx = Vec::<usize>::with_capacity(elems.len() * num_node);
    for i_elem in elems {
        for i_node in 0..num_node {
            felem2vtx.push(elem2vtx[i_elem * num_node + i_node]);
        }
    }
    felem2vtx
}