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

use super::{GraphPath,GraphEdge,GraphEdgeRef};
use crate::bezier::path::ray::*;
use crate::geo::*;
use crate::line::*;

use smallvec::*;

///
/// Represents a collision between a ray and a GraphPath
///
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum GraphRayCollision {
    /// Collision against a single edge
    SingleEdge(GraphEdgeRef),

    /// Collision against an intersection point
    Intersection(GraphEdgeRef)
}

impl<Point: Coordinate+Coordinate2D, Label: Copy> GraphPath<Point, Label> {
    ///
    /// Finds all collisions between a ray and this path
    /// 
    /// The return value is a tuple of (collision, curve_t, line_t, position)
    /// 
    pub fn ray_collisions<L: Line<Point=Point>>(&self, ray: &L) -> Vec<(GraphRayCollision, f64, f64, Point)> {
        ray_collisions(&self, ray)
    }
}

impl GraphRayCollision {
    ///
    /// Returns true if this collision is at an intersection
    ///
    #[inline]
    pub fn is_intersection(&self) -> bool {
        match self {
            GraphRayCollision::SingleEdge(_)        => false,
            GraphRayCollision::Intersection(_edges) => true
        }
    }

    ///
    /// Returns the edge this collision is for
    ///
    #[inline]
    pub fn edge(&self) -> GraphEdgeRef {
        match self {
            GraphRayCollision::SingleEdge(edge)     => *edge,
            GraphRayCollision::Intersection(edge)   => *edge,
        }
    }
}

impl<'a, Point, Label> RayPath for &'a GraphPath<Point, Label> 
where
    Point: Coordinate+Coordinate2D,
    Label: Copy
{
    type Point = Point;
    type Curve = GraphEdge<'a, Point, Label>;

    #[inline] fn num_points(&self) -> usize { self.points.len() }

    #[inline] fn num_edges(&self, point_idx: usize) -> usize { self.points[point_idx].forward_edges.len() }

    #[inline] fn edges_for_point(&self, point_idx: usize) -> SmallVec<[GraphEdgeRef; 8]> {
        let num_edges = self.points[point_idx].forward_edges.len();
        (0..num_edges).into_iter()
            .map(move |edge_idx| GraphEdgeRef { start_idx: point_idx, edge_idx: edge_idx, reverse: false })
            .collect()
    }

    #[inline] fn reverse_edges_for_point(&self, point_idx: usize) -> SmallVec<[GraphEdgeRef; 8]> {
        self.points[point_idx].connected_from.iter()
            .flat_map(|connected_point_idx| {
                let num_edges = self.points[*connected_point_idx].forward_edges.len();

                (0..num_edges).into_iter()
                    .filter(move |edge_idx| self.points[*connected_point_idx].forward_edges[*edge_idx].end_idx == point_idx)
                    .map(move |edge_idx| GraphEdgeRef { start_idx: *connected_point_idx, edge_idx: edge_idx, reverse: true })
            })
            .collect()
    }

    #[inline] fn get_edge(&self, edge: GraphEdgeRef) -> Self::Curve {
        GraphEdge { graph: *self, edge: edge }
    }

    #[inline] fn get_next_edge(&self, edge: GraphEdgeRef) -> (GraphEdgeRef, Self::Curve) {
        let next_point_idx  = self.edge_end_point_idx(edge);
        let next_edge_idx   = self.edge_following_edge_idx(edge);

        let next_edge_ref   = GraphEdgeRef { start_idx: next_point_idx, edge_idx: next_edge_idx, reverse: edge.reverse };

        (next_edge_ref, self.get_edge(next_edge_ref))
    }

    #[inline] fn point_position(&self, point: usize) -> Self::Point {
        self.points[point].position
    }

    #[inline] fn edge_start_point_idx(&self, edge: GraphEdgeRef) -> usize {
        if edge.reverse {
            self.points[edge.start_idx].forward_edges[edge.edge_idx].end_idx
        } else {
            edge.start_idx
        }
    }

    #[inline] fn edge_end_point_idx(&self, edge: GraphEdgeRef) -> usize {
        if edge.reverse {
            edge.start_idx
        } else {
            self.points[edge.start_idx].forward_edges[edge.edge_idx].end_idx
        }
    }

    #[inline] fn edge_following_edge_idx(&self, edge: GraphEdgeRef) -> usize {
        if edge.reverse {
            unimplemented!("Finding the following edge for a reversed reference not implemented yet")
        } else {
            self.points[edge.start_idx].forward_edges[edge.edge_idx].following_edge_idx
        }
    }
}