maps 1.10.0

Inspect, compare and align multiple grid maps in an intuitive & fast GUI
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

use std::collections::VecDeque;
use std::time;

use eframe::egui;
use egui_plot::{Line, Plot, PlotPoints};

/// Monotonic clock timestamp for native builds.
#[cfg(not(target_arch = "wasm32"))]
type TimeInstant = time::Instant;

/// Monotonic web_sys millisecond timestamp, with up to microsecond resolution.
/// https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
#[cfg(target_arch = "wasm32")]
type TimeInstant = f64;

fn now() -> TimeInstant {
    #[cfg(not(target_arch = "wasm32"))]
    return time::Instant::now();

    #[cfg(target_arch = "wasm32")]
    web_sys::window()
        .expect("no window")
        .performance()
        .expect("no performance")
        .now()
}

/// Tracing tool for measuring durations, buffering them, plotting etc.
/// wasm compatible, not thread-safe.
#[derive(Default)]
pub struct Tracing {
    pub name: String,
    current: Option<TimeInstant>,
    max_buffer_size: usize,
    buffer: VecDeque<time::Duration>,
}

impl Tracing {
    pub fn new(name: &str, max_buffer_size: usize) -> Tracing {
        Tracing {
            name: name.into(),
            current: None,
            max_buffer_size,
            buffer: VecDeque::with_capacity(max_buffer_size),
        }
    }

    pub fn buffer_size(&self) -> usize {
        self.buffer.len()
    }

    /// Start a new measurement.
    pub fn start(&mut self) {
        self.current = Some(now());
    }

    /// Measures and stores the duration since the last start() in the buffer.
    /// Requires start() before.
    pub fn measure(&mut self) {
        if self.buffer.len() == self.max_buffer_size {
            self.buffer.pop_front();
        }
        let current = self.current.expect("missing start()");

        #[cfg(not(target_arch = "wasm32"))]
        self.buffer.push_back(current.elapsed());

        #[cfg(target_arch = "wasm32")]
        self.buffer.push_back(time::Duration::from_micros(
            ((now() - current) * 1e3) as u64,
        ));
    }

    /// Plots the buffered measurements as f64 seconds.
    pub fn plot(&self, ui: &mut egui::Ui) {
        let points: PlotPoints = (0..self.buffer_size())
            .map(|i| {
                [
                    i as f64,
                    self.buffer.get(i).expect("missing duration").as_secs_f64(),
                ]
            })
            .collect();
        Plot::new(self.name.as_str())
            .view_aspect(2.0)
            .show(ui, |plot_ui| plot_ui.line(Line::new("duration", points)));
    }
}