geom3d 0.2.0

Data structures and algorithms for 3D geometric modeling.
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

use super::Curve;
use crate::{utils, Float, Point3};

#[derive(Debug)]
pub struct Polyline {
    pub vertices: Vec<Point3>,
    pub segment_lengths: Vec<Float>,
    pub length: Float,
}

impl Polyline {
    pub fn new(vertices: Vec<Point3>) -> Self {
        assert!(vertices.len() >= 2);
        let segment_lengths = vertices
            .windows(2)
            .map(|pair| pair[1].distance(pair[0]))
            .collect::<Vec<_>>();
        let length = segment_lengths.iter().sum();
        Polyline {
            vertices,
            segment_lengths,
            length,
        }
    }

    pub fn start(&self) -> Point3 {
        self.vertices[0]
    }

    pub fn end(&self) -> Point3 {
        self.vertices[self.vertices.len() - 1]
    }

    /// Get index of nearest vertex
    pub fn nearest_vertex(&self, point: Point3) -> usize {
        utils::find_nearest_point(&self.vertices, point)
    }
}

impl Curve for Polyline {
    fn get_point(&self, t: Float) -> Point3 {
        if t <= 0.0 {
            self.start()
        } else if t >= 1.0 {
            self.end()
        } else {
            let mut length = t * self.length;
            for (index, &segment_length) in self.segment_lengths.iter().enumerate() {
                if length > segment_length {
                    length -= segment_length;
                } else {
                    return self.vertices[index]
                        .lerp(self.vertices[index + 1], length / segment_length);
                }
            }
            unreachable!()
        }
    }

    fn project(&self, point: Point3) -> Float {
        let mut min = Float::MAX;
        let mut min_index = 0;

        for (index, pair) in self.vertices.windows(2).enumerate() {
            let distance = utils::distance_to_line_segment(pair[0], pair[1], point);
            if distance < min {
                min = distance;
                min_index = index;
            }
        }

        let length = self.segment_lengths.iter().take(min_index).sum::<Float>()
            + (point - self.vertices[min_index])
                .dot((self.vertices[min_index + 1] - self.vertices[min_index]).normalize());
        (length / self.length).clamp(0.0, 1.0)
    }
}