rcgal 0.1.0

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
126
127
128
129
130

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

use super::{
    arc_2::Arc2, face_2::Face2, number_type::NumberType, segment_2::Segment2, vertex_2::Vertex2,
};

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Edge2Type {
    Segment,
    Arc,
}

#[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) -> Segment2<T> {
        let source = self.source.borrow();
        let target = self.target.borrow();
        Segment2::new(source.to_point(), target.to_point())
    }

    pub fn to_arc(&self) -> Arc2<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
            }
        }
    }
}