polyhedron 0.1.0

A half edge and radial edge implementation.
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::data_container::StorageBuffer;
use crate::prelude::{half_edge_handle::HalfEdgeHandle, vert_handle::VertHandle};
use crate::EdgeData;
use crate::{ArcId, EdgeId, EndpointList, MeshData, MeshStorage, VertId};

/// Topological handle to an edge (non-manifold only).
pub struct EdgeHandle<C: MeshStorage, const MANIFOLD: bool>
{
    pub(crate) mesh_data: *mut MeshData<C, MANIFOLD>,
    pub(crate) id: EdgeId,
}

impl<C: MeshStorage, const MANIFOLD: bool> EdgeHandle<C, MANIFOLD>
{
    /// Id of the handle.
    pub fn id(&self) -> EdgeId { self.id }

    /// Whether there are any half edges orbitting this eedge.
    pub fn is_thin(&self) -> bool
    {
        unsafe { (*self.mesh_data).edge_ref(self.id).half_edge.is_void() }
    }

    /// Handle to a random half edge orbitting this edge.
    pub fn half_edge(&self) -> HalfEdgeHandle<C, MANIFOLD>
    {
        unsafe {
            let half_edge_id = (*self.mesh_data).edge_ref(self.id).half_edge;

            HalfEdgeHandle {
                mesh_data: self.mesh_data,
                id: half_edge_id,
            }
        }
    }

    /// Ids of both endpoints of the edge in o particular order.
    pub fn endpoints(&self) -> [VertId; 2]
    {
        unsafe { (*self.mesh_data).edge_ref(self.id).endpoints }
    }

    /// Handles to both endpoints of the edge in o particular order.
    pub fn endpoint_handles(&self) -> [VertHandle<C, MANIFOLD>; 2]
    {
        let [v1, v2] = self.endpoints();
        [
            VertHandle::new(self.mesh_data, v1),
            VertHandle::new(self.mesh_data, v2),
        ]
    }

    /// Next edge in the radial cycle of the given endpoint (will crash
    /// if the specified vertex id is not in the edge).
    pub fn next_at(&self, v: VertId) -> Self
    {
        unsafe {
            let next_id = (*self.mesh_data)
                .edge_ref(self.id)
                .cycle_at(v)
                .unwrap()
                .next;

            EdgeHandle {
                mesh_data: self.mesh_data,
                id: next_id,
            }
        }
    }

    /// Previous edge in the radial cycle of the given endpoint (will crash
    /// if the specified vertex id is not in the edge).
    pub fn prev_at(&self, v: VertId) -> Self
    {
        unsafe {
            let prev_id = (*self.mesh_data)
                .edge_ref(self.id)
                .cycle_at(v)
                .unwrap()
                .prev;

            EdgeHandle {
                mesh_data: self.mesh_data,
                id: prev_id,
            }
        }
    }

    /// Make a shallow copy of the handle.
    pub fn replicate(&self) -> Self
    {
        EdgeHandle {
            mesh_data: self.mesh_data,
            id: self.id,
        }
    }

    pub(crate) fn remove_from_cycles(&self)
    {
        assert!(!MANIFOLD);
        let [v1, v2] = self.endpoint_handles();

        if let Some(h) = v1.find_distinct_edge(self.half_edge().id())
        {
            unsafe {
                (*self.mesh_data).vert_mut(v1.id()).arc = ArcId::Edge(h.edge().id())
            };
        }
        else
        {
            unsafe {
                (*self.mesh_data).vert_mut(v1.id()).arc = ArcId::Edge(EdgeId::default());
            };
        };

        if let Some(h) = v2.find_distinct_edge(self.half_edge().id())
        {
            unsafe {
                (*self.mesh_data).vert_mut(v2.id()).arc = ArcId::Edge(h.edge().id());
            };
        }
        else
        {
            unsafe {
                (*self.mesh_data).vert_mut(v2.id()).arc = ArcId::Edge(EdgeId::default());
            };
        };

        unsafe {
            let edges = &mut (*self.mesh_data).topology_data.topo_edges;
            EndpointList::remove_edge(edges, self.id(), v1.id());
            EndpointList::remove_edge(edges, self.id(), v2.id());
        }
    }

    /// Read the stored data for this edge.
    pub fn read_data(&self) -> &EdgeData<C>
    {
        unsafe {
            (*self.mesh_data)
                .geometry_data
                .edge_data
                .read(self.id.to_index() as u64)
        }
    }

    /// Update the stored data for this edge.
    pub fn update_data<F: FnMut(&mut EdgeData<C>)>(&mut self, update: F)
    {
        unsafe {
            (*self.mesh_data)
                .geometry_data
                .edge_data
                .update(self.id.to_index() as u64, update)
        }
    }
}