rasterize 0.6.8

Simple and small 2D rendering library
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

use std::{sync::Arc, time::Instant};

use rasterize::{
    BBox, FillRule, Image, LinColor, Path, Point, RGBA, Scalar, Scene, Size, Transform,
};

type Error = Box<dyn std::error::Error>;

/// Very basic random number generator
#[derive(Default)]
pub struct Rnd {
    state: u32,
}

impl Rnd {
    /// Create new random number generator with seed `0`
    pub fn new() -> Self {
        Self::default()
    }

    /// Create new random number generator with provided `seed` value
    pub fn with_seed(seed: u32) -> Self {
        Self { state: seed }
    }

    fn step(&mut self) -> u32 {
        self.state = self.state.wrapping_mul(214_013).wrapping_add(2_531_011) & 0x7fffffff;
        self.state >> 16
    }

    /// Sample `u32` from uniform distributes
    pub fn uniform_u32(&mut self) -> u32 {
        (self.step() & 0xffff) << 16 | (self.step() & 0xffff)
    }

    /// Sample `u64` from uniform distributes
    pub fn uniform_u64(&mut self) -> u64 {
        ((self.uniform_u32() as u64) << 32) | (self.uniform_u32() as u64)
    }

    /// Sample f64 from `Uniform([0, 1])`
    pub fn uniform(&mut self) -> f64 {
        let bpr_recip: f64 = (2.0f64).powi(-53);
        (self.uniform_u64() >> 10) as f64 * bpr_recip
    }

    /// Sample form normal/gauss distribution with `mu = 0`, `sigma = 1`
    pub fn gauss(&mut self) -> f64 {
        const PI_2: f64 = 2.0 * std::f64::consts::PI;
        let x = self.uniform();
        let y = self.uniform();
        (PI_2 * x).cos() * (-2.0 * (1.0 - y).ln()).sqrt()
    }

    /// Generate random color
    pub fn color(&mut self) -> LinColor {
        RGBA::new(
            (self.uniform_u32() % 256) as u8,
            (self.uniform_u32() % 256) as u8,
            (self.uniform_u32() % 256) as u8,
            255,
        )
        .into()
    }

    /// Generate random `Point(U([0, 1]), U([0, 1]))`
    pub fn point(&mut self) -> Point {
        Point::new(self.uniform(), self.uniform())
    }
}

fn main() -> Result<(), Error> {
    let size = Size {
        height: 1024,
        width: 1024,
    };
    let fsize = Point::new(size.height as Scalar, size.width as Scalar);
    let count = 1024;
    let mut rnd = Rnd::new();

    let mut group = Vec::new();
    for _ in 0..count {
        let circle = Path::builder()
            .move_to(rnd.point() * fsize)
            .circle(rnd.uniform() * 10.0 + 30.0)
            .build();
        group.push(Scene::fill(
            circle.into(),
            Arc::new(rnd.color()),
            FillRule::default(),
        ))
    }
    let scene = Scene::group(group);
    let now = Instant::now();
    // let rasterize = &rasterize::ActiveEdgeRasterizer::default();
    let rasterize = &rasterize::SignedDifferenceRasterizer::default();
    let img = scene.render(
        rasterize,
        Transform::identity(),
        Some(BBox::new((0.0, 0.0), fsize)),
        Some("#ffffff".parse()?),
    );
    eprintln!("{:?}", now.elapsed());
    img.write_bmp(std::io::stdout())?;

    Ok(())
}