conspire 0.7.1

The Rust interface to conspire.
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

mod laplace;
mod taubin;

use crate::{
    geometry::mesh::{Mesh, differential::laplace::Weighting},
    math::Scalar,
};

pub enum Smoothing {
    Laplace {
        iterations: usize,
        scale: Scalar,
        weighting: Weighting,
        preserve_boundary: bool,
        preserve_interfaces: bool,
    },
    Taubin {
        iterations: usize,
        pass_band: Scalar,
        scale: Scalar,
        weighting: Weighting,
        preserve_boundary: bool,
        preserve_interfaces: bool,
    },
}

impl<const D: usize> Mesh<D> {
    pub fn smooth(&mut self, smoothing: Smoothing) {
        match smoothing {
            Smoothing::Laplace {
                iterations,
                scale,
                weighting,
                preserve_boundary,
                preserve_interfaces,
            } => self.laplace_smooth(
                iterations,
                scale,
                weighting,
                preserve_boundary,
                preserve_interfaces,
            ),
            Smoothing::Taubin {
                iterations,
                pass_band,
                scale,
                weighting,
                preserve_boundary,
                preserve_interfaces,
            } => self.taubin_smooth(
                iterations,
                pass_band,
                scale,
                weighting,
                preserve_boundary,
                preserve_interfaces,
            ),
        }
    }
    fn constrained_adjacency(
        &self,
        preserve_boundary: bool,
        preserve_interfaces: bool,
    ) -> Vec<Vec<usize>> {
        let mut constrained = vec![false; self.number_of_nodes()];
        if preserve_boundary {
            self.exterior_faces()
                .iter()
                .flatten()
                .for_each(|&node| constrained[node] = true);
        }
        if preserve_interfaces {
            self.mark_interface_nodes(&mut constrained);
        }
        let mut adjacency: Vec<Vec<usize>> = self.node_node_connectivity().to_vec();
        adjacency
            .iter_mut()
            .enumerate()
            .filter(|(node, _)| constrained[*node])
            .for_each(|(_, neighbors)| neighbors.retain(|&other| constrained[other]));
        adjacency
    }
    fn mark_interface_nodes(&self, constrained: &mut [bool]) {
        let mut element_block = Vec::with_capacity(self.number_of_elements());
        for (block, connectivity) in self.connectivities().iter().enumerate() {
            element_block.resize(
                element_block.len() + connectivity.number_of_elements(),
                block,
            );
        }
        self.node_element_connectivity()
            .iter()
            .enumerate()
            .for_each(|(node, elements)| {
                let mut blocks = elements.iter().map(|&element| element_block[element]);
                if let Some(first) = blocks.next()
                    && blocks.any(|block| block != first)
                {
                    constrained[node] = true;
                }
            });
    }
}