contourable 0.8.0

A library for differentiable functions
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

use nalgebra::{self as na, ComplexField};
use num_dual::{DualNum, DualNumFloat};

/// Computes the cumulative distance around a set of vertices in a circular manner.
///
/// # Arguments
///
/// * `vertices` - A slice of points representing the vertices.
///
/// # Returns
///
/// A vector of cumulative distances.
///
/// # Example
///
/// ```rust
/// use nalgebra::Point2;
/// use contourable::closed::polygon::utils::circular_cumulative_distance;
/// let vertices = vec![Point2::new(0.0, 0.0), Point2::new(1.0, 0.0)];
/// let distances = circular_cumulative_distance(&vertices);
/// assert_eq!(distances, vec![0.0, 1.0, 2.0]);
/// ```
pub fn circular_cumulative_distance<D, F>(vertices: &[na::Point2<D>]) -> Vec<D>
where
    D: DualNum<F> + ComplexField<RealField = D>,
    F: DualNumFloat,
{
    vertices
        .iter()
        .zip(vertices.iter().skip(1).chain(vertices.iter().take(1)))
        .fold(vec![D::zero()], |mut acc, (p1, p2)| {
            acc.push(acc.last().cloned().unwrap_or(D::zero()) + (p2 - p1).norm());
            acc
        })
}

#[cfg(test)]
mod tests {

    use super::*;
    use approx::assert_relative_eq;
    use nalgebra::{Isometry2, Point2, Vector2};

    fn assert_vec_rel_eq<T: na::RealField>(a: &[T], b: &[T]) {
        a.iter().zip(b.iter()).for_each(|(a, b)| {
            assert_relative_eq!(a, b);
        });
    }

    #[test]
    fn test_compute_distance_square() {
        let iso = Isometry2::new(Vector2::new(1.1, -2.2), 1.23);
        let vertices = vec![
            iso * Point2::new(0.0, 0.0),
            iso * Point2::new(1.0, 0.0),
            iso * Point2::new(1.0, 1.0),
            iso * Point2::new(0.0, 1.0),
        ];
        let distances = circular_cumulative_distance(&vertices);
        let expected_distances = vec![0.0, 1.0, 2.0, 3.0, 4.0];
        assert_vec_rel_eq(&distances, &expected_distances);
    }

    #[test]
    fn test_compute_distance_triangle() {
        let vertices = vec![
            Point2::new(0.0, 0.0),
            Point2::new(3.0, 0.0),
            Point2::new(3.0, 4.0),
        ];
        let distances = circular_cumulative_distance(&vertices);
        let expected_distances = vec![0.0, 3.0, 7.0, 12.0];
        assert_vec_rel_eq(&distances, &expected_distances);
    }

    #[test]
    fn test_compute_distance_line() {
        let vertices = vec![Point2::new(0.0, 0.0), Point2::new(1.0, 0.0)];
        let distances = circular_cumulative_distance(&vertices);
        let expected_distances = vec![0.0, 1.0, 2.0];
        assert_vec_rel_eq(&distances, &expected_distances);
    }
}