leibniz 0.2.0

The package provides a differentiable vector graphics rasterization loss.
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

//! Prediction layout.

use super::Command;

/// Layout for one predicted glyph.
#[derive(Clone, Debug)]
pub struct Layout {
    batch: usize,
    commands: Vec<Command>,
    contours: Vec<Range>,
}

/// Sequence range for one contour.
#[derive(Clone, Debug)]
pub struct Range {
    start: usize,
    end: usize,
}

impl Layout {
    /// Create a layout.
    ///
    /// # Panics
    ///
    /// Panics if any contour range is outside the command sequence.
    pub fn new(batch: usize, commands: Vec<Command>, contours: Vec<Range>) -> Self {
        assert!(
            contours.iter().all(|range| range.end() <= commands.len()),
            "contour ranges must be in bounds for the command sequence"
        );

        Self {
            batch,
            commands,
            contours,
        }
    }

    /// Batch item index.
    pub const fn batch(&self) -> usize {
        self.batch
    }

    /// Commands for a contour range.
    ///
    /// # Panics
    ///
    /// Panics if the range is outside the command sequence.
    pub fn commands(&self, range: &Range) -> &[Command] {
        &self.commands[range.start()..range.end()]
    }

    /// Contour ranges.
    pub fn contours(&self) -> &[Range] {
        &self.contours
    }
}

impl Range {
    /// Create a range.
    ///
    /// # Panics
    ///
    /// Panics if `start` is greater than `end`.
    pub const fn new(start: usize, end: usize) -> Self {
        assert!(start <= end, "range start must not exceed range end");

        Self { start, end }
    }

    /// End index.
    pub const fn end(&self) -> usize {
        self.end
    }

    /// Whether the range is empty.
    pub const fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Number of points in the range.
    pub const fn len(&self) -> usize {
        self.end - self.start
    }

    /// Start index.
    pub const fn start(&self) -> usize {
        self.start
    }
}

#[cfg(test)]
mod tests {
    use super::{Command, Layout, Range};

    #[test]
    #[should_panic]
    fn layout_rejects_out_of_bounds_commands() {
        let _ = Layout::new(0, vec![Command::Quadratic], vec![Range::new(0, 2)]);
    }

    #[test]
    fn layout_returns_contour_commands() {
        let layout = Layout::new(
            0,
            vec![Command::Linear, Command::Quadratic, Command::Linear],
            vec![Range::new(1, 3)],
        );

        assert_eq!(
            layout.commands(&Range::new(1, 3)),
            &[Command::Quadratic, Command::Linear]
        );
    }

    #[test]
    #[should_panic]
    fn range_rejects_reversed_bounds() {
        let _ = Range::new(5, 2);
    }

    #[test]
    fn range_returns_length() {
        assert_eq!(Range::new(2, 5).len(), 3);
    }
}