plottery_server 0.7.0

pen-plotter server executable of Plottery, a creative coding framework for generative vector graphics and pen plotting.
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

#[cfg(test)]
mod tests {
    use plottery_lib::{FloatInterpolation, Path, Plottable, Rect, SampleSettings, V2};

    use crate::accelleration::accelleration_path::AccellerationPath;

    #[test]
    fn full_speed_all_segments() {
        let path = Rect::new(V2::new(0.0, 0.0), V2::new(1.0, 1.0));

        let accell_dist = 0.2;
        let edge_slow_down_power = 0.5;

        let points = path.get_points(SampleSettings::default());
        let acc_path = AccellerationPath::new(&points, accell_dist, edge_slow_down_power);

        assert_eq!(acc_path.points.len(), 13);
        // start and end points didn't change
        assert_eq!(
            acc_path.points.first().unwrap().point,
            points.first().unwrap()
        );
        assert_eq!(
            acc_path.points.last().unwrap().point,
            points.last().unwrap()
        );

        for (i, point_speed) in acc_path.points.iter().enumerate() {
            if i == 0 || i == acc_path.points.len() - 1 {
                // first and last point
                assert_eq!(point_speed.speed, 0.0);
            } else {
                // other points
                assert!(point_speed.speed >= 0.1);
                assert!(point_speed.speed <= 1.0);
            }
        }
    }

    #[test]
    fn long_short() {
        let path = Path::new_from(vec![
            V2::new(0.0, 0.0),
            V2::new(1.0, 0.0),
            V2::new(1.0, 0.1),
        ]);

        let accell_dist = 0.3;
        let edge_slow_down_power = 0.5;

        let points = path.get_points(SampleSettings::default());
        let acc_path = AccellerationPath::new(&points, accell_dist, edge_slow_down_power);

        assert_eq!(acc_path.points.len(), 5);

        // start and end points didn't change
        assert_eq!(
            acc_path.points.first().unwrap().point,
            points.first().unwrap()
        );
        assert_eq!(
            acc_path.points.last().unwrap().point,
            points.last().unwrap()
        );

        // start and end speed 0.0
        assert_eq!(acc_path.points.first().unwrap().speed, 0.0);
        assert_eq!(acc_path.points.last().unwrap().speed, 0.0);

        // long segment
        assert_eq!(acc_path.points[1].speed, 1.0);
        assert_eq!(acc_path.points[2].speed, 1.0);
        // right before end
        assert!(acc_path.points[3].speed <= 0.5);
        assert!(acc_path.points[3].speed >= 0.01);
    }

    #[test]
    fn short_long() {
        let path = Path::new_from(vec![
            V2::new(0.0, 0.0),
            V2::new(0.1, 0.0),
            V2::new(0.1, 1.0),
        ]);

        let accell_dist = 0.3;
        let edge_slow_down_power = 0.5;

        let points = path.get_points(SampleSettings::default());
        let acc_path = AccellerationPath::new(&points, accell_dist, edge_slow_down_power);

        assert_eq!(acc_path.points.len(), 5);

        // start and end points didn't change
        assert_eq!(
            acc_path.points.first().unwrap().point,
            points.first().unwrap()
        );
        assert_eq!(
            acc_path.points.last().unwrap().point,
            points.last().unwrap()
        );

        // start and end speed 0.0
        assert_eq!(acc_path.points.first().unwrap().speed, 0.0);
        assert_eq!(acc_path.points.last().unwrap().speed, 0.0);

        // right after start
        assert!(acc_path.points[1].speed <= 0.5);
        assert!(acc_path.points[1].speed >= 0.01);
        // long segment
        assert_eq!(acc_path.points[2].speed, 1.0);
        assert_eq!(acc_path.points[3].speed, 1.0);
    }

    #[test]
    fn very_short_segments() {
        let points: Vec<V2> = 0.0.lerp_iter(1.0, 0.01).map(|x| V2::new(x, 0.0)).collect();

        let accell_dist = 0.3;
        let edge_slow_down_power = 0.5;
        let acc_path = AccellerationPath::new(&points, accell_dist, edge_slow_down_power);

        for point in acc_path.points.iter() {
            println!("point: {:?}", point);
        }

        assert!(points.len() + 10 >= acc_path.points.len());
    }
}