rita 0.1.3

Randomized Incremental Triangulation Algorithms
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

use crate::trids::node::VertexNode;

use super::{
    hedge_iterator::HedgeIterator,
    tet_data_structure::{TetDataStructure, TRIANGLE_SUBINDICES},
    tet_iterator::TetIterator,
};

#[derive(Copy, Clone)]
pub struct HalfTriIterator<'a> {
    pub tds: &'a TetDataStructure,
    pub half_tri_idx: usize,
}

impl<'a> HalfTriIterator<'a> {
    pub fn hedges(&self) -> [HedgeIterator<'a>; 3] {
        [
            HedgeIterator {
                tds: self.tds,
                hedge_idx: 0,
                half_tri_idx: self.half_tri_idx,
            },
            HedgeIterator {
                tds: self.tds,
                hedge_idx: 1,
                half_tri_idx: self.half_tri_idx,
            },
            HedgeIterator {
                tds: self.tds,
                hedge_idx: 2,
                half_tri_idx: self.half_tri_idx,
            },
        ]
    }

    pub fn idx(&self) -> usize {
        self.half_tri_idx
    }

    pub fn is_sound(&self) -> bool {
        let [n0, n1, n2] = self.nodes();

        let [n_opposite0, n_opposite1, n_opposite2] = self.opposite().nodes();

        if !((n0 == n_opposite0 && n1 == n_opposite2 && n2 == n_opposite1)
            || (n0 == n_opposite2 && n1 == n_opposite1 && n2 == n_opposite0)
            || (n0 == n_opposite1 && n1 == n_opposite0 && n2 == n_opposite2))
        {
            log::error!("{}: Wrong opposite triangle: {}", self, self.opposite());
            return false;
        }

        true
    }

    /// A triangle is considered conceptual if one of its nodes are conceptual
    pub fn is_conceptual(&self) -> bool {
        self.nodes().iter().any(|n| n.is_conceptual())
    }

    pub fn nodes(&self) -> [VertexNode; 3] {
        let mod4 = self.half_tri_idx % 4;
        let sub_idx = TRIANGLE_SUBINDICES[mod4];

        [
            self.tds.tet_nodes[self.half_tri_idx - mod4 + sub_idx[0]],
            self.tds.tet_nodes[self.half_tri_idx - mod4 + sub_idx[1]],
            self.tds.tet_nodes[self.half_tri_idx - mod4 + sub_idx[2]],
        ]
    }

    /// Get the opposite node on the same tet, i.e the node that is not part of the triangle
    pub fn opposite_node(&self) -> VertexNode {
        self.tds.tet_nodes[self.idx()]
    }

    /// Opposite half triangle on the neighboring tet
    pub fn opposite(&self) -> HalfTriIterator<'a> {
        HalfTriIterator {
            tds: self.tds,
            half_tri_idx: self.tds.half_tri_opposite[self.idx()],
        }
    }

    pub fn tet(&self) -> TetIterator<'a> {
        TetIterator {
            tds: self.tds,
            tet_idx: self.half_tri_idx >> 2, // this is equivalent to self.half_tri_idx / 4 (rounding down to nearest integer), but faster
        }
    }
}

impl std::fmt::Display for HalfTriIterator<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        let [n0, n1, n2] = self.nodes();
        write!(
            f,
            "Triangle {}: {} -> {} -> {}",
            self.half_tri_idx, n0, n1, n2
        )
    }
}