vsvg 0.5.0

Core library for pen-plotter graphics.
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

use kurbo::Affine;

#[allow(dead_code)]
fn skew_affine(kx: f64, ky: f64) -> Affine {
    // this is missing from kurbo, so we implement it here
    // | a c e |
    // | b d f |
    // | 0 0 1 |

    Affine::new([1.0, ky.tan(), kx.tan(), 1.0, 0.0, 0.0])
}

pub trait Transforms: Sized {
    /// Apply a 2D affine transform
    fn transform(&mut self, affine: &Affine) -> &mut Self;

    /// Translate the geometry by `dx` and `dy`.
    #[inline]
    fn translate(&mut self, dx: impl Into<f64>, dy: impl Into<f64>) -> &mut Self {
        self.transform(&Affine::translate((dx.into(), dy.into())));
        self
    }

    /// Scale the geometry by `s` around the origin.
    #[inline]
    fn scale(&mut self, s: impl Into<f64>) -> &mut Self {
        self.transform(&Affine::scale(s.into()));
        self
    }

    /// Scale the geometry by `sx` and `sy` around the origin.
    #[inline]
    fn scale_non_uniform(&mut self, sx: impl Into<f64>, sy: impl Into<f64>) -> &mut Self {
        self.transform(&Affine::scale_non_uniform(sx.into(), sy.into()));
        self
    }

    /// Scale the geometry by `sx` and `sy` around the point `(cx, cy)`.
    #[inline]
    fn scale_around(
        &mut self,
        sx: impl Into<f64>,
        sy: impl Into<f64>,
        cx: impl Into<f64>,
        cy: impl Into<f64>,
    ) -> &mut Self {
        let (cx, cy) = (cx.into(), cy.into());
        let transform = Affine::translate((cx, cy))
            * Affine::scale_non_uniform(sx.into(), sy.into())
            * Affine::translate((-cx, -cy));
        self.transform(&transform);
        self
    }

    /// Rotate the geometry by `theta` radians around the origin.
    #[inline]
    fn rotate(&mut self, theta: impl Into<f64>) -> &mut Self {
        self.transform(&Affine::rotate(theta.into()));
        self
    }

    /// Rotate the geometry by `theta` radians around the point `(cx, cy)`.
    #[inline]
    fn rotate_around(
        &mut self,
        theta: impl Into<f64>,
        cx: impl Into<f64>,
        cy: impl Into<f64>,
    ) -> &mut Self {
        let (cx, cy) = (cx.into(), cy.into());
        let transform = Affine::translate((cx, cy))
            * Affine::rotate(theta.into())
            * Affine::translate((-cx, -cy));
        self.transform(&transform);
        self
    }

    /// Skew the geometry by `kx` and `ky` radians around the origin.
    #[inline]
    fn skew(&mut self, kx: impl Into<f64>, ky: impl Into<f64>) -> &mut Self {
        self.transform(&skew_affine(kx.into(), ky.into()));
        self
    }

    /// Skew the geometry by `kx` and `ky` radians around the point `(cx, cy)`.
    #[inline]
    fn skew_around(
        &mut self,
        kx: impl Into<f64>,
        ky: impl Into<f64>,
        cx: impl Into<f64>,
        cy: impl Into<f64>,
    ) -> &mut Self {
        let (cx, cy) = (cx.into(), cy.into());
        let transform = Affine::translate((cx, cy))
            * skew_affine(kx.into(), ky.into())
            * Affine::translate((-cx, -cy));
        self.transform(&transform);
        self
    }
}

// TODO: tests