voronator 0.2.1

Implements the Voronoi diagram construction as a dual of the Delaunay triangulation for a set of points and the construction of a centroidal tesselation of a Delaunay triangulation.
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

extern crate plotters;
extern crate rand;
extern crate voronator;

use plotters::prelude::*;
use rand::prelude::*;
use voronator::delaunator::Point;
#[allow(unused_imports)]
use voronator::{CentroidDiagram, VoronoiDiagram};

const IMG_WIDTH: u32 = 500;
const IMG_HEIGHT: u32 = 500;

fn get_points(n: i32, jitter: f64) -> Vec<Point> {
    let mut rng = rand::thread_rng();
    let mut points: Vec<Point> = vec![];
    for i in 0..n + 1 {
        for j in 0..n + 1 {
            points.push(Point {
                x: (i as f64) + jitter * (rng.gen::<f64>() - rng.gen::<f64>()),
                y: (j as f64) + jitter * (rng.gen::<f64>() - rng.gen::<f64>()),
            });
        }
    }

    points
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let size = 10;
    let points: Vec<Point> = get_points(size, 0.6)
        .into_iter()
        .map(|p| Point {
            x: ((IMG_WIDTH as f64) / 20. + p.x * (IMG_WIDTH as f64)) / (size as f64),
            y: ((IMG_HEIGHT as f64) / 20. + p.y * (IMG_HEIGHT as f64)) / (size as f64),
        })
        .collect();

    let now = std::time::Instant::now();
    let diagram = VoronoiDiagram::new(
        &Point { x: 0., y: 0. },
        &Point {
            x: IMG_WIDTH as f64,
            y: IMG_HEIGHT as f64,
        },
        &points,
    )
    .unwrap();
    // let diagram = CentroidDiagram::new(&points).unwrap();
    println!(
        "time it took to generating a diagram for {} points: {}ms",
        points.len(),
        now.elapsed().as_millis()
    );

    let root = BitMapBackend::new("plot.png", (IMG_WIDTH, IMG_HEIGHT)).into_drawing_area();
    root.fill(&WHITE)?;

    let root = root.apply_coord_spec(RangedCoord::<RangedCoordf32, RangedCoordf32>::new(
        0f32..IMG_WIDTH as f32,
        0f32..IMG_HEIGHT as f32,
        (0..IMG_WIDTH as i32, 0..IMG_HEIGHT as i32),
    ));

    println!("triangles: {}", diagram.delaunay.len());
    println!("cells: {}", diagram.cells().len());

    // for cell in &diagram.cells {
    //     let color = RGBColor{0: rng.gen(), 1: rng.gen(), 2: rng.gen()};
    //     let p: Vec<(f32, f32)> = cell.into_iter().map(|x| (x.x as f32, x.y as f32)).collect();

    //     let poly = Polygon::new(p.clone(), ShapeStyle{color: color.to_rgba(), filled: true, stroke_width: 2});
    //     root.draw(&poly)?;
    // }

    for cell in diagram.cells() {
        let p: Vec<(f32, f32)> = cell.points().into_iter().map(|x| (x.x as f32, x.y as f32)).collect();

        for _ in 0..p.len() {
            let plot = PathElement::new(
                p.clone(),
                ShapeStyle {
                    color: BLACK.to_rgba(),
                    filled: true,
                    stroke_width: 1,
                },
            );
            root.draw(&plot)?;
        }
    }

    Ok(())
}