2 releases
Uses old Rust 2015
0.1.3 | Nov 19, 2017 |
---|---|
0.1.2 | Nov 19, 2017 |
#1582 in Algorithms
32KB
559 lines
A Rust library for generating Flot documents
Flot is a JavaScript library for generating attractive data plots. Although usually used to enhance interactive websites, flot-rs is a nice way for command-line programs to create standalone HTML documents with plots. By default these refer to online sources, so they can be handed over to anybody else for display.
extern crate flot;
fn main() {
let line_data = vec![(0.0,1.0),(1.0,4.5)];
let points_data = vec![(0.5,1.2),(0.8,4.0)];
let page = flot::Page::new("");
let p = page.plot("Lines and Points");
p.lines("lines",line_data).fill(0.3).line_width(0);
p.points("points",points_data).symbol("circle");
page.render("simple.html").expect("i/o error");
}
A Page
may contain multiple plots; plots may contain multiple
series with chart types (lines
,points
,bars
).
The result of running this program is to create 'simple.html', which can be opened in your browser.
Page
can be given a title, which if non-empty will both set the title
of the document and create a H1 heading. Likewise, the plot
method is
given a title which if non-empty will provide a centered H2 heading for
the plot.
Ways of specifying Data
By default, the series constructors take anything that converts to an
iterator of (f64,f64)
x-y pairs.
Note that the vectors line_data
and points_data
are consumed
by these calls.
If you have a source of tuples that isn't (f64,f64)
, then
flot::to_f64
will convert that into a form that flot-rs accepts, provided
that those types convert cleanly into f64
.
Alternatively, you can map a iterator of references with a function - flot::mapr
produces the desired points iterator, which here we collect into a vector.
extern crate flot;
fn make_gaussian(xvalues: &[f64], m: f64, s: f64) -> Vec<(f64,f64)> {
use std::f64::consts::PI;
let s2 = 2.0*s*s;
let norm = 1.0/(s2*PI).sqrt();
flot::mapr (
xvalues,
move |x| norm*(-(x-m).powi(2)/s2).exp()
).collect()
}
fn main() {
let page = flot::Page::new("");
let p = page.plot("Normal distribution").size(500,300);
let xvalues: Vec<_> = flot::range(0.0,10.0,0.1).collect();
p.lines("norm σ=1.0",make_gaussian(&xvalues,5.0,1.0));
p.lines("norm σ=0.7",make_gaussian(&xvalues,6.0,0.5));
page.render("normal.html").unwrap();
}
range
is a little convenience iterator for making ranges of floating-point
values (subsequently I've discovered that the itertools-num
crate provides something similar - see linspace
).
flot::mapv
is similar, except it takes an iterator of values. Here are the
squares of all integers from 0 to 9:
page.plot().legend_pos(Corner::TopLeft)
.bars("squares",mapv(0..10,|x| x*x))
.width(0.75);
(The iterator given to mapr
and mapv
can provide any values which can be
converted into a f64
, so the integer range works.)
Finally, flot::zip
can take two iterators of references, which are zipped
together into point tuples. This is useful if you have separate x and y data
as slices or vectors.
Using flot-rs as a Personal Display Engine
By default, flot-rs uses the Cloudflare CDN for jQuery (3.2.1) and Flot (0.8.3),
which means that these HTML documents are portable and can be viewed with anyone
with an internet connenction. Browsers cache these dependencies, so that generally
these documents render quickly. However, if you download Flot directly, then
you can set the environment variable FLOT
to its location. E.g. I have
export FLOT=/home/steve/Downloads/flot
.
Being a command-line person, I tend to open generated HTML documents using
the appropriate command, start
for Windows, open
for MacOS, gnome-open
for Linux. There are browser-specific options for opening documents without
toolbars and such like in their own window, e.g. google-chrome --app=doc.html
and firefox --chrome doc.html
for Firefox.
Dependencies
~180KB