flo_curves 0.8.0

Library for manipulating Bezier curves
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

use super::coordinate::*;
use super::coord2::*;

use std::ops::*;

/// Represents a 2D point
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct Coord3(pub f64, pub f64, pub f64);

impl Coordinate3D for Coord3 {
    ///
    /// X component of this coordinate
    /// 
    #[inline]
    fn x(&self) -> f64 {
        self.0
    }

    ///
    /// Y component of this coordinate
    /// 
    #[inline]
    fn y(&self) -> f64 {
        self.1
    }

    ///
    /// Z component of this coordinate
    /// 
    #[inline]
    fn z(&self) -> f64 {
        self.2
    }
}

impl Add<Coord3> for Coord3 {
    type Output=Coord3;

    #[inline]
    fn add(self, rhs: Coord3) -> Coord3 {
        Coord3(self.0 + rhs.0, self.1 + rhs.1, self.2 + rhs.2)
    }
}

impl Sub<Coord3> for Coord3 {
    type Output=Coord3;

    #[inline]
    fn sub(self, rhs: Coord3) -> Coord3 {
        Coord3(self.0 - rhs.0, self.1 - rhs.1, self.2 - rhs.2)
    }
}

impl Mul<f64> for Coord3 {
    type Output=Coord3;

    #[inline]
    fn mul(self, rhs: f64) -> Coord3 {
        Coord3(self.0 * rhs, self.1 * rhs, self.2 * rhs)
    }
}

impl From<(f64, f64, f64)> for Coord3 {
    fn from((x, y, z): (f64, f64, f64)) -> Coord3 {
        Coord3(x, y, z)
    }
}

impl From<(Coord2, f64)> for Coord3 {
    fn from((pos, z): (Coord2, f64)) -> Coord3 {
        Coord3(pos.0, pos.1, z)
    }
}

impl Into<(f64, f64, f64)> for Coord3 {
    fn into(self) -> (f64, f64, f64) {
        (self.0, self.1, self.2)
    }
}

impl From<(f32, f32, f32)> for Coord3 {
    fn from((x, y, z): (f32, f32, f32)) -> Coord3 {
        Coord3(x as _, y as _, z as _)
    }
}

impl Into<(f32, f32, f32)> for Coord3 {
    fn into(self) -> (f32, f32, f32) {
        (self.0 as _, self.1 as _, self.2 as _)
    }
}

impl Coordinate for Coord3 {
    #[inline]
    fn from_components(components: &[f64]) -> Coord3 {
        Coord3(components[0], components[1], components[2])
    }

    #[inline]
    fn origin() -> Coord3 {
        Coord3(0.0, 0.0, 0.0)
    }

    #[inline]
    fn len() -> usize { 3 }

    #[inline]
    fn get(&self, index: usize) -> f64 { 
        match index {
            0 => self.0,
            1 => self.1,
            2 => self.2,
            _ => panic!("Coord3 only has three components")
        }
    }

    fn from_biggest_components(p1: Coord3, p2: Coord3) -> Coord3 {
        Coord3(f64::from_biggest_components(p1.0, p2.0), f64::from_biggest_components(p1.1, p2.1), f64::from_biggest_components(p1.2, p2.2))
    }

    fn from_smallest_components(p1: Coord3, p2: Coord3) -> Coord3 {
        Coord3(f64::from_smallest_components(p1.0, p2.0), f64::from_smallest_components(p1.1, p2.1), f64::from_smallest_components(p1.2, p2.2))
    }

    #[inline]
    fn distance_to(&self, target: &Coord3) -> f64 {
        let dist_x = target.0-self.0;
        let dist_y = target.1-self.1;
        let dist_z = target.2-self.2;

        f64::sqrt(dist_x*dist_x + dist_y*dist_y + dist_z*dist_z)
    }

    #[inline]
    fn dot(&self, target: &Self) -> f64 {
        self.0*target.0 + self.1*target.1 + self.2*target.2
    }
}