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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
//! Coordinate axis
use std::borrow::Cow;
use std::iter::IntoIterator;
use crate::map;
use crate::traits::{Configure, Data, Set};
use crate::{
grid, Axis, Default, Display, Grid, Label, Range, Scale, ScaleFactor, Script, TicLabels,
};
/// Properties of the coordinate axes
#[derive(Clone)]
pub struct Properties {
grids: map::grid::Map<grid::Properties>,
hidden: bool,
label: Option<Cow<'static, str>>,
logarithmic: bool,
range: Option<(f64, f64)>,
scale_factor: f64,
tics: Option<String>,
}
impl Default for Properties {
fn default() -> Properties {
Properties {
grids: map::grid::Map::new(),
hidden: false,
label: None,
logarithmic: false,
range: None,
scale_factor: 1.,
tics: None,
}
}
}
impl Properties {
/// Hides the axis
///
/// **Note** The `TopX` and `RightY` axes are hidden by default
pub fn hide(&mut self) -> &mut Properties {
self.hidden = true;
self
}
/// Makes the axis visible
///
/// **Note** The `BottomX` and `LeftY` axes are visible by default
pub fn show(&mut self) -> &mut Properties {
self.hidden = false;
self
}
}
impl Configure<Grid> for Properties {
type Properties = grid::Properties;
/// Configures the gridlines
fn configure<F>(&mut self, grid: Grid, configure: F) -> &mut Properties
where
F: FnOnce(&mut grid::Properties) -> &mut grid::Properties,
{
if self.grids.contains_key(grid) {
configure(self.grids.get_mut(grid).unwrap());
} else {
let mut properties = Default::default();
configure(&mut properties);
self.grids.insert(grid, properties);
}
self
}
}
impl Set<Label> for Properties {
/// Attaches a label to the axis
fn set(&mut self, label: Label) -> &mut Properties {
self.label = Some(label.0);
self
}
}
impl Set<Range> for Properties {
/// Changes the range of the axis that will be shown
///
/// **Note** All axes are auto-scaled by default
fn set(&mut self, range: Range) -> &mut Properties {
self.hidden = false;
match range {
Range::Auto => self.range = None,
Range::Limits(low, high) => self.range = Some((low, high)),
}
self
}
}
impl Set<Scale> for Properties {
/// Sets the scale of the axis
///
/// **Note** All axes use a linear scale by default
fn set(&mut self, scale: Scale) -> &mut Properties {
self.hidden = false;
match scale {
Scale::Linear => self.logarithmic = false,
Scale::Logarithmic => self.logarithmic = true,
}
self
}
}
impl Set<ScaleFactor> for Properties {
/// Changes the *scale factor* of the axis.
///
/// All the data plotted against this axis will have its corresponding coordinate scaled with
/// this factor before being plotted.
///
/// **Note** The default scale factor is `1`.
fn set(&mut self, factor: ScaleFactor) -> &mut Properties {
self.scale_factor = factor.0;
self
}
}
impl<P, L> Set<TicLabels<P, L>> for Properties
where
L: IntoIterator,
L::Item: AsRef<str>,
P: IntoIterator,
P::Item: Data,
{
/// Attaches labels to the tics of an axis
fn set(&mut self, tics: TicLabels<P, L>) -> &mut Properties {
let TicLabels { positions, labels } = tics;
let pairs = positions
.into_iter()
.zip(labels.into_iter())
.map(|(pos, label)| format!("'{}' {}", label.as_ref(), pos.f64()))
.collect::<Vec<_>>();
if pairs.is_empty() {
self.tics = None
} else {
self.tics = Some(pairs.join(", "));
}
self
}
}
impl<'a> Script for (Axis, &'a Properties) {
// Allow clippy::format_push_string even with older versions of rust (<1.62) which
// don't have it defined.
#[allow(clippy::all)]
fn script(&self) -> String {
let &(axis, properties) = self;
let axis_ = axis.display();
let mut script = if properties.hidden {
return format!("unset {}tics\n", axis_);
} else {
format!("set {}tics nomirror ", axis_)
};
if let Some(ref tics) = properties.tics {
script.push_str(&format!("({})", tics))
}
script.push('\n');
if let Some(ref label) = properties.label {
script.push_str(&format!("set {}label '{}'\n", axis_, label))
}
if let Some((low, high)) = properties.range {
script.push_str(&format!("set {}range [{}:{}]\n", axis_, low, high))
}
if properties.logarithmic {
script.push_str(&format!("set logscale {}\n", axis_));
}
for (grid, properties) in properties.grids.iter() {
script.push_str(&(axis, grid, properties).script());
}
script
}
}
impl crate::ScaleFactorTrait for Properties {
fn scale_factor(&self) -> f64 {
self.scale_factor
}
}
|
