rcgal 0.2.2

Rust Computational Geometry Algorithms Library.
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

use std::{cell::RefCell, rc::Rc};

use super::{
    arc_segment_2::ArcSegment2, face_2::Face2, line_segment_2::LineSegment2,
    number_type::NumberType, util_enum::Edge2Type, vertex_2::Vertex2,
};

#[derive(Debug, Clone)]
pub struct Edge2<T: NumberType> {
    source: Rc<RefCell<Vertex2<T>>>,
    target: Rc<RefCell<Vertex2<T>>>,
    twin: Option<Rc<RefCell<Self>>>,
    next: Option<Rc<RefCell<Self>>>,
    prev: Option<Rc<RefCell<Self>>>,
    face: Option<Rc<RefCell<Face2<T>>>>,
    edge_type: Edge2Type,
}

impl<T: NumberType> Edge2<T> {
    pub fn new_segment(source: Rc<RefCell<Vertex2<T>>>, target: Rc<RefCell<Vertex2<T>>>) -> Self {
        Self {
            source,
            target,
            twin: None,
            next: None,
            prev: None,
            face: None,
            edge_type: Edge2Type::Segment,
        }
    }

    pub fn new_arc(source: Rc<RefCell<Vertex2<T>>>, target: Rc<RefCell<Vertex2<T>>>) -> Self {
        Self {
            source,
            target,
            twin: None,
            next: None,
            prev: None,
            face: None,
            edge_type: Edge2Type::Arc,
        }
    }

    pub fn source(&self) -> Rc<RefCell<Vertex2<T>>> {
        self.source.clone()
    }

    pub fn set_source(&mut self, source: Rc<RefCell<Vertex2<T>>>) {
        self.source = source
    }

    pub fn target(&self) -> Rc<RefCell<Vertex2<T>>> {
        self.target.clone()
    }

    pub fn set_target(&mut self, target: Rc<RefCell<Vertex2<T>>>) {
        self.target = target
    }

    pub fn twin(&self) -> Option<Rc<RefCell<Self>>> {
        self.twin.clone()
    }

    pub fn set_twin(&mut self, twin: Rc<RefCell<Self>>) {
        self.twin = Some(twin)
    }

    pub fn next(&self) -> Option<Rc<RefCell<Self>>> {
        self.next.clone()
    }

    pub fn set_next(&mut self, next: Rc<RefCell<Self>>) {
        self.next = Some(next)
    }

    pub fn prev(&self) -> Option<Rc<RefCell<Self>>> {
        self.prev.clone()
    }

    pub fn set_prev(&mut self, prev: Rc<RefCell<Self>>) {
        self.prev = Some(prev)
    }

    pub fn face(&self) -> Option<Rc<RefCell<Face2<T>>>> {
        self.face.clone()
    }

    pub fn set_face(&mut self, face: Rc<RefCell<Face2<T>>>) {
        self.face = Some(face.clone())
    }

    pub fn edge_type(&self) -> Edge2Type {
        self.edge_type
    }

    pub fn to_segment(&self) -> LineSegment2<T> {
        let source = self.source.borrow();
        let target = self.target.borrow();
        LineSegment2::new(source.to_point(), target.to_point())
    }

    pub fn to_arc(&self) -> ArcSegment2<T> {
        todo!()
    }
}

impl<T: NumberType> PartialEq for Edge2<T> {
    fn eq(&self, other: &Self) -> bool {
        if self.edge_type != other.edge_type {
            return false;
        }
        match self.edge_type {
            Edge2Type::Segment => {
                let self_segment = self.to_segment();
                let other_segment = other.to_segment();
                self_segment == other_segment
            }
            Edge2Type::Arc => {
                let self_arc = self.to_arc();
                let other_arc = other.to_arc();
                self_arc == other_arc
            }
        }
    }
}