cdt 0.1.0

Fast, robust constrained 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

use std::iter::repeat_with;
use rand::{Rng, SeedableRng};

use clap::{Arg, App};
use itertools::Itertools;

const N: usize = 1_000_000;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let matches = App::new("triangulate")
        .author("Matt Keeter <matt.j.keeter@gmail.com>")
        .about("Triangulates random points")
        .arg(Arg::with_name("num")
            .short("n")
            .long("num")
            .help("number of points")
            .takes_value(true))
        .arg(Arg::with_name("output")
            .short("o")
            .long("out")
            .help("svg file to target")
            .takes_value(true))
        .arg(Arg::with_name("check")
            .short("c")
            .long("check")
            .help("check invariants after each step (slow)"))
        .arg(Arg::with_name("seed")
            .short("s")
            .long("seed")
            .help("seed for RNG")
            .takes_value(true))
        .get_matches();

    let num = matches.value_of("num")
        .map(|s| s.parse())
        .unwrap_or(Ok(N))?;
    let seed: u64 = matches.value_of("seed")
        .map(|s| s.parse())
        .unwrap_or_else(|| Ok(rand::thread_rng().gen()))?;

    // Use a ChaCha RNG to be reproducible across platforms
    let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);

    // Sample as f32 to match the behavior in fuzz.rs
    // (to increase likelihood of collisions)
    let points: Vec<_> = repeat_with(|| rng.gen_range(0.0..1.0))
        .tuple_windows()
        .map(|(a, b): (f32, f32)| (a as f64, b as f64))
        .take(num)
        .collect();

    eprintln!("Running with seed {}", seed);
    let now = std::time::Instant::now();
    let mut t = cdt::Triangulation::new(&points)?;
    while !t.done() {
        t.step()?;
        if matches.is_present("check") {
            t.check();
        }
    }
    let result = t.triangles().collect::<Vec<_>>();
    let elapsed = now.elapsed();

    eprintln!(
        "    Triangulated {} points in {}.{}s.\n    Generated {} triangles.",
        num,
        elapsed.as_secs(),
        elapsed.subsec_millis(),
        result.len(),
    );

    if let Some(out) = matches.value_of("output") {
        eprintln!("    Saving {}", out);
        t.save_debug_svg(out).expect("Could not save SVG");
    }
    Ok(())
}