lognplot 0.1.0

Log and plot data
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::geometry::Point;
use crate::style::{Color, Stroke};
use crate::time::{TimeSpan, TimeStamp};
use crate::tsdb::{Aggregation, Observation, Sample, SampleMetrics};
use crate::tsdb::{Query, RangeQueryResult, TsDbHandle};
use std::str::FromStr;

/// A single curve with some stroke styling.
#[derive(Debug, Clone)]
pub struct Curve {
    pub data: CurveData,
    stroke: Stroke,
    legend: Option<String>,
}

/// A dataset. Can be either a trace, or a vector of points!
#[derive(Debug, Clone)]
pub enum CurveData {
    /// A tsdb signal with some name.
    Trace {
        name: String,
        db: TsDbHandle,
        // TODO: cache database queries in some data structure?
    },

    /// Raw points.
    Points(Vec<Point>),
}

impl CurveData {
    pub fn points(x: Vec<f64>, y: Vec<f64>) -> Self {
        let points = x
            .iter()
            .zip(y.iter())
            .map(|p| Point::new(*p.0, *p.1))
            .collect();
        CurveData::Points(points)
    }

    pub fn trace(name: &str, db: TsDbHandle) -> Self {
        CurveData::Trace {
            name: name.to_string(),
            db,
        }
    }
}

impl CurveData {
    /// Pull data in for drawing the graph.
    pub fn query(
        &self,
        timespan: &TimeSpan,
        amount: usize,
    ) -> RangeQueryResult<Sample, SampleMetrics> {
        match self {
            // In case of raw data, just return them all.
            CurveData::Points(points) => {
                let observations = points
                    .iter()
                    .map(|p| Observation::new(TimeStamp::new(p.x()), Sample::new(p.y())))
                    .collect();
                RangeQueryResult::Observations(observations)
            }

            // In case of a trace, query database for points.
            CurveData::Trace { name, db } => {
                // Time for time series database benefit
                // TODO: cache results?
                let query = Query::create().amount(amount).span(&timespan).build();
                let result = db.query(name, query);
                result.inner
            }
        }
    }

    fn summary(&self) -> Option<Aggregation<Sample, SampleMetrics>> {
        match &self {
            CurveData::Points(points) => point_summary(points),
            CurveData::Trace { name, db } => db.summary(name),
        }
    }
}

/// Calculate aggregate information about points.
fn point_summary(points: &[Point]) -> Option<Aggregation<Sample, SampleMetrics>> {
    if points.is_empty() {
        None
    } else {
        let count = points.len();
        let (first, rest) = points.split_first().unwrap();
        let mut xmin = first.x();
        let mut xmax = xmin;
        let mut ymin = first.y();
        let mut ymax = ymin;
        let mut ysum = ymin;
        let mut ysum_squared = ymin * ymin;
        for p in rest {
            if p.x() > xmax {
                xmax = p.x();
            }

            if p.x() < xmin {
                xmin = p.x();
            }

            if p.y() > ymax {
                ymax = p.y();
            }

            if p.y() < ymin {
                ymin = p.y();
            }

            ysum += p.y();
            ysum_squared += p.y() * p.y();
        }

        let timespan = TimeSpan::new(TimeStamp::new(xmin), TimeStamp::new(xmax));
        let metrics = SampleMetrics::new(ymin, ymax, ysum, ysum_squared, count);
        let aggregation = Aggregation::new(timespan, metrics, count);
        Some(aggregation)
    }
}

impl Curve {
    pub fn new(data: CurveData) -> Self {
        let stroke = Stroke::from_str("blue").unwrap();
        let legend = None;

        Self {
            data,
            stroke,
            legend,
        }
    }

    pub fn color(&self) -> Color {
        self.stroke.color.clone()
    }

    /// Retrieve a data summary of this curve.
    pub fn summary(&self) -> Option<Aggregation<Sample, SampleMetrics>> {
        self.data.summary()
    }

    /// Pull data in for drawing the graph.
    pub fn query(
        &self,
        timespan: &TimeSpan,
        amount: usize,
    ) -> RangeQueryResult<Sample, SampleMetrics> {
        self.data.query(timespan, amount)
    }
}