A plotting library for Rust powered by Plotly.js.

Information

Category: Rust / Data visualization
Watchers: 15
Star: 870
Fork: 78
Last update: Nov 19, 2023

Resource links

https://github.com/igiagkiozis/plotly

README
Issues 29

Plotly for Rust

A plotting library for Rust powered by Plotly.js.

Usage

Add this to your Cargo.toml:

[dependencies]
plotly = "0.4.1"

For changes since the last version please consult the change log.

Crate Feature Flags

The following feature flags are available:

orca
- Optional, compatible with Rust stable.
- Adds plot save functionality to the following formats: png, jpeg, webp, svg, pdf and eps.
- Requires some additional configuration, see plotly_orca.

Saving to png, jpeg, webp, svg, pdf and eps formats can be made available by enabling the orca feature:

[dependencies]
plotly = { version = "0.4.1", features = ["orca"] }

This feature requires some manual configuration to function. For details and installation instructions please see the plotly_orca.

Plotly in action

Line and Scatter plot

extern crate plotly;
use plotly::common::Mode;
use plotly::{Plot, Scatter};

fn line_and_scatter_plot() {
    let trace1 = Scatter::new(vec![1, 2, 3, 4], vec![10, 15, 13, 17])
        .name("trace1")
        .mode(Mode::Markers);
    let trace2 = Scatter::new(vec![2, 3, 4, 5], vec![16, 5, 11, 9])
        .name("trace2")
        .mode(Mode::Lines);
    let trace3 = Scatter::new(vec![1, 2, 3, 4], vec![12, 9, 15, 12]).name("trace3");

    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.add_trace(trace3);
    plot.show();
}

fn main() -> std::io::Result<()> {
    line_and_scatter_plot();
    Ok(())
}

extern crate plotly;
use plotly::{Plot, Scatter, Layout};
use plotly::common::{Mode, Line, LineShape, Font};
use plotly::layout::Legend;

fn line_shape_options_for_interpolation() {
    let trace1 = Scatter::new(vec![1, 2, 3, 4, 5], vec![1, 3, 2, 3, 1])
        .mode(Mode::LinesMarkers)
        .name("linear")
        .line(Line::new().shape(LineShape::Linear));
    let trace2 = Scatter::new(vec![1, 2, 3, 4, 5], vec![6, 8, 7, 8, 6])
        .mode(Mode::LinesMarkers)
        .name("spline")
        .line(Line::new().shape(LineShape::Spline));
    let trace3 = Scatter::new(vec![1, 2, 3, 4, 5], vec![11, 13, 12, 13, 11])
        .mode(Mode::LinesMarkers)
        .name("vhv")
        .line(Line::new().shape(LineShape::Vhv));
    let trace4 = Scatter::new(vec![1, 2, 3, 4, 5], vec![16, 18, 17, 18, 16])
        .mode(Mode::LinesMarkers)
        .name("hvh")
        .line(Line::new().shape(LineShape::Hvh));
    let trace5 = Scatter::new(vec![1, 2, 3, 4, 5], vec![21, 23, 22, 23, 21])
        .mode(Mode::LinesMarkers)
        .name("vh")
        .line(Line::new().shape(LineShape::Vh));
    let trace6 = Scatter::new(vec![1, 2, 3, 4, 5], vec![26, 28, 27, 28, 26])
        .mode(Mode::LinesMarkers)
        .name("hv")
        .line(Line::new().shape(LineShape::Hv));

    let mut plot = Plot::new();
    let layout = Layout::new()
        .legend(Legend::new().y(0.5).trace_order("reversed")
            .font(Font::new().size(16)));
    plot.set_layout(layout);
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.add_trace(trace3);
    plot.add_trace(trace4);
    plot.add_trace(trace5);
    plot.add_trace(trace6);
    plot.show();
}

fn main() -> std::io::Result<()> {
    line_shape_options_for_interpolation();
    Ok(())
}

extern crate plotly;
use plotly::{Plot, Scatter, Layout};
use plotly::common::{Mode, Line, DashType, Font};
use plotly::layout::{Legend, Axis};

fn line_dash() {
    let trace1 = Scatter::new(vec![1, 2, 3, 4, 5], vec![1, 3, 2, 3, 1])
        .mode(Mode::LinesMarkers)
        .name("solid")
        .line(Line::new().dash(DashType::Solid));
    let trace2 = Scatter::new(vec![1, 2, 3, 4, 5], vec![6, 8, 7, 8, 6])
        .mode(Mode::LinesMarkers)
        .name("dashdot")
        .line(Line::new().dash(DashType::DashDot));
    let trace3 = Scatter::new(vec![1, 2, 3, 4, 5], vec![11, 13, 12, 13, 11])
        .mode(Mode::LinesMarkers)
        .name("dash")
        .line(Line::new().dash(DashType::Dash));
    let trace4 = Scatter::new(vec![1, 2, 3, 4, 5], vec![16, 18, 17, 18, 16])
        .mode(Mode::LinesMarkers)
        .name("dot")
        .line(Line::new().dash(DashType::Dot));
    let trace5 = Scatter::new(vec![1, 2, 3, 4, 5], vec![21, 23, 22, 23, 21])
        .mode(Mode::LinesMarkers)
        .name("longdash")
        .line(Line::new().dash(DashType::LongDash));
    let trace6 = Scatter::new(vec![1, 2, 3, 4, 5], vec![26, 28, 27, 28, 26])
        .mode(Mode::LinesMarkers)
        .name("longdashdot")
        .line(Line::new().dash(DashType::LongDashDot));

    let mut plot = Plot::new();
    let layout = Layout::new()
        .legend(Legend::new().y(0.5).trace_order("reversed")
            .font(Font::new().size(16)))
        .xaxis(Axis::new().range(vec![0.95, 5.05]).auto_range(false))
        .yaxis(Axis::new().range(vec![0.0, 28.5]).auto_range(false));
    plot.set_layout(layout);
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.add_trace(trace3);
    plot.add_trace(trace4);
    plot.add_trace(trace5);
    plot.add_trace(trace6);
    plot.show();
}

fn main() -> std::io::Result<()> {
    line_dash();
    Ok(())
}

extern crate plotly;
use plotly::{Plot, Scatter, Rgb, NamedColor, Layout};
use plotly::common::{Mode, Marker, Line, Title};
use plotly::layout::Axis;

fn colored_and_styled_scatter_plot() {
    let trace1 = Scatter::new(vec![52698, 43117], vec![53, 31])
        .mode(Mode::Markers)
        .name("North America")
        .text_array(vec!["United States", "Canada"])
        .marker(
            Marker::new()
                .color(Rgb::new(164, 194, 244))
                .size(12)
                .line(Line::new().color(NamedColor::White).width(0.5)),
        );
    let trace2 = Scatter::new(
        vec![
            39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, 18007,
        ],
        vec![33, 20, 13, 19, 27, 19, 49, 44, 38],
    )
        .mode(Mode::Markers)
        .name("Europe")
        .text_array(vec![
            "Germany",
            "Britain",
            "France",
            "Spain",
            "Italy",
            "Czech Rep.",
            "Greece",
            "Poland",
        ])
        .marker(Marker::new().color(Rgb::new(255, 217, 102)).size(12));
    let trace3 = Scatter::new(
        vec![42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899],
        vec![23, 42, 54, 89, 14, 99, 93, 70],
    )
        .mode(Mode::Markers)
        .name("Asia/Pacific")
        .text_array(vec![
            "Australia",
            "Japan",
            "South Korea",
            "Malaysia",
            "China",
            "Indonesia",
            "Philippines",
            "India",
        ])
        .marker(Marker::new().color(Rgb::new(234, 153, 153)).size(12));
    let trace4 = Scatter::new(
        vec![19097, 18601, 15595, 13546, 12026, 7434, 5419],
        vec![43, 47, 56, 80, 86, 93, 80],
    )
        .mode(Mode::Markers)
        .name("Latin America")
        .text_array(vec![
            "Chile",
            "Argentina",
            "Mexico",
            "Venezuela",
            "Venezuela",
            "El Salvador",
            "Bolivia",
        ])
        .marker(Marker::new().color(Rgb::new(142, 124, 195)).size(12));

    let layout = Layout::new()
        .title(Title::new("Quarter 1 Growth"))
        .xaxis(
            Axis::new()
                .title(Title::new("GDP per Capita"))
                .show_grid(false)
                .zero_line(false),
        )
        .yaxis(Axis::new().title(Title::new("Percent")).show_line(false));
    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.add_trace(trace3);
    plot.add_trace(trace4);
    plot.set_layout(layout);
    plot.show_png(1024, 680);
    plot.show();
}

fn main() -> std::io::Result<()> {
    colored_and_styled_scatter_plot();
    Ok(())
}

For more examples see scatter_and_line_plot_examples.rs.

Bar plot

extern crate plotly;
use plotly::{Plot, Bar, Layout};
use plotly::common::{ErrorData, ErrorType};

fn bar_chart_with_error_bars() {
    let trace1 = Bar::new(
        vec!["Trial 1", "Trial 2", "Trial 3"],
        vec![3, 6, 4],
    )
        .name("Control")
        .error_y(ErrorData::new(ErrorType::Data).array(vec![1.0, 0.5, 1.5]));

    let trace2 = Bar::new(
        vec!["Trial 1", "Trial 2", "Trial 3"],
        vec![4, 7, 3],
    )
        .name("LA Zoo")
        .error_y(ErrorData::new(ErrorType::Data).array(vec![0.5, 1.0, 2.0]));

    let layout = Layout::new();
    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.set_layout(layout);
    plot.show();
}

fn main() -> std::io::Result<()> {
    bar_chart_with_error_bars();
    Ok(())
}

For more examples see bar_plot_examples.rs.

Histogram plot

extern crate plotly;
use plotly::{Plot, Histogram, NamedColor, Layout};
use plotly::common::Marker;
use plotly::layout::BarMode;
use rand_distr::{Distribution, Normal};

fn sample_normal_distribution(n: usize, mean: f64, std_dev: f64) -> Vec<f64> {
    let mut rng = rand::thread_rng();
    let dist = Normal::new(mean, std_dev).unwrap();
    let mut v = Vec::<f64>::with_capacity(n);
    for _idx in 1..n {
        v.push(dist.sample(&mut rng));
    }
    v
}

fn overlaid_histogram() {
    let samples1 = sample_normal_distribution(500, 0.0, 1.0);
    let trace1 = Histogram::new(samples1)
        .name("trace 1")
        .opacity(0.5)
        .marker(Marker::new().color(NamedColor::Green));

    let samples2 = sample_normal_distribution(500, 0.0, 1.0);
    let trace2 = Histogram::new(samples2)
        .name("trace 2")
        .opacity(0.6)
        .marker(Marker::new().color(NamedColor::Red));

    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.add_trace(trace2);

    let layout = Layout::new().bar_mode(BarMode::Overlay);
    plot.set_layout(layout);
    plot.show();
}

fn main() -> std::io::Result<()> {
    overlaid_histogram();
    Ok(())
}

For more examples see histogram_plot_examples.rs.

Candlestick plot

extern crate plotly;
use plotly::{Plot, Candlestick};

fn simple_candlestick_chart() {
    let x = vec![
        "2017-01-04","2017-01-05","2017-01-06","2017-01-09","2017-01-10","2017-01-11","2017-01-12",
        "2017-01-13","2017-01-17","2017-01-18","2017-01-19","2017-01-20","2017-01-23","2017-01-24",
        "2017-01-25","2017-01-26","2017-01-27","2017-01-30","2017-01-31","2017-02-01","2017-02-02",
        "2017-02-03","2017-02-06","2017-02-07","2017-02-08","2017-02-09","2017-02-10","2017-02-13",
        "2017-02-14","2017-02-15",];
    let open = vec![
        115.849998, 115.919998, 116.779999, 117.949997, 118.769997, 118.739998, 118.900002,
        119.110001, 118.339996, 120.0, 119.400002, 120.449997, 120.0, 119.550003, 120.419998,
        121.669998, 122.139999, 120.93, 121.150002, 127.029999, 127.980003, 128.309998, 129.130005,
        130.539993, 131.350006, 131.649994, 132.460007, 133.080002, 133.470001, 135.520004,
    ];
    let high = vec![
        116.510002, 116.860001, 118.160004, 119.43, 119.379997, 119.93, 119.300003, 119.620003,
        120.239998, 120.5, 120.089996, 120.449997, 120.809998, 120.099998, 122.099998, 122.440002,
        122.349998, 121.629997, 121.389999, 130.490005, 129.389999, 129.190002, 130.5, 132.089996,
        132.220001, 132.449997, 132.940002, 133.820007, 135.089996, 136.270004,
    ];
    let low = vec![
        115.75, 115.809998, 116.470001, 117.940002, 118.300003, 118.599998, 118.209999, 118.809998,
        118.220001, 119.709999, 119.370003, 119.730003, 119.769997, 119.5, 120.279999, 121.599998,
        121.599998, 120.660004, 120.620003, 127.010002, 127.779999, 128.160004, 128.899994,
        130.449997, 131.220001, 131.119995, 132.050003, 132.75, 133.25, 134.619995,
    ];
    let close = vec![
        116.019997, 116.610001, 117.910004, 118.989998, 119.110001, 119.75, 119.25, 119.040001,
        120.0, 119.989998, 119.779999, 120.0, 120.080002, 119.970001, 121.879997, 121.940002,
        121.949997, 121.629997, 121.349998, 128.75, 128.529999, 129.080002, 130.289993, 131.529999,
        132.039993, 132.419998, 132.119995, 133.289993, 135.020004, 135.509995,
    ];

    let trace1 = Candlestick::new(x, open, high, low, close);

    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.show();
}

fn main() -> std::io::Result<()> {
    simple_candlestick_chart();
    Ok(())
}

For more examples see candlestick_plot_examples.rs.

OHLC plot

extern crate plotly;
use plotly::{Plot, Ohlc};

fn simple_ohlc_chart() {
    let x = vec![
        "2017-01-04","2017-01-05","2017-01-06","2017-01-09","2017-01-10","2017-01-11","2017-01-12",
        "2017-01-13","2017-01-17","2017-01-18","2017-01-19","2017-01-20","2017-01-23","2017-01-24",
        "2017-01-25","2017-01-26","2017-01-27","2017-01-30","2017-01-31","2017-02-01","2017-02-02",
        "2017-02-03","2017-02-06","2017-02-07","2017-02-08","2017-02-09","2017-02-10","2017-02-13",
        "2017-02-14","2017-02-15",];
    let open = vec![
        115.849998, 115.919998, 116.779999, 117.949997, 118.769997, 118.739998, 118.900002,
        119.110001, 118.339996, 120.0, 119.400002, 120.449997, 120.0, 119.550003, 120.419998,
        121.669998, 122.139999, 120.93, 121.150002, 127.029999, 127.980003, 128.309998, 129.130005,
        130.539993, 131.350006, 131.649994, 132.460007, 133.080002, 133.470001, 135.520004,
    ];
    let high = vec![
        116.510002, 116.860001, 118.160004, 119.43, 119.379997, 119.93, 119.300003, 119.620003,
        120.239998, 120.5, 120.089996, 120.449997, 120.809998, 120.099998, 122.099998, 122.440002,
        122.349998, 121.629997, 121.389999, 130.490005, 129.389999, 129.190002, 130.5, 132.089996,
        132.220001, 132.449997, 132.940002, 133.820007, 135.089996, 136.270004,
    ];
    let low = vec![
        115.75, 115.809998, 116.470001, 117.940002, 118.300003, 118.599998, 118.209999, 118.809998,
        118.220001, 119.709999, 119.370003, 119.730003, 119.769997, 119.5, 120.279999, 121.599998,
        121.599998, 120.660004, 120.620003, 127.010002, 127.779999, 128.160004, 128.899994,
        130.449997, 131.220001, 131.119995, 132.050003, 132.75, 133.25, 134.619995,
    ];
    let close = vec![
        116.019997, 116.610001, 117.910004, 118.989998, 119.110001, 119.75, 119.25, 119.040001,
        120.0, 119.989998, 119.779999, 120.0, 120.080002, 119.970001, 121.879997, 121.940002,
        121.949997, 121.629997, 121.349998, 128.75, 128.529999, 129.080002, 130.289993, 131.529999,
        132.039993, 132.419998, 132.119995, 133.289993, 135.020004, 135.509995,
    ];

    let trace1 = Ohlc::new(x, open, high, low, close);

    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.show();
}

fn main() -> std::io::Result<()> {
    simple_ohlc_chart();
    Ok(())
}

For more examples see ohlc_plot_examples.rs.

Contour plot

extern crate plotly;
use plotly::{Plot, Contour, Layout};
use std::f64::consts::PI;
use plotly::common::{Title, ColorScale, ColorScalePalette, Mode};
use plotly::contour::Contours;

fn simple_contour_plot() {
    let n = 200;
    let mut x = Vec::<f64>::new();
    let mut y = Vec::<f64>::new();
    let mut z: Vec<Vec<f64>> = Vec::new();

    for index in 0..n {
        let value = -2.0 * PI + 4.0 * PI * (index as f64) / (n as f64);
        x.push(value);
        y.push(value);
    }

    for xi in 0..n {
        let mut row = Vec::<f64>::new();
        for yi in 0..n {
            let radius_squared = x[xi].powf(2.0) + y[yi].powf(2.0);
            let zv = x[xi].sin() * y[yi].cos() * radius_squared.sin() / (radius_squared + 1.0).log10();
            row.push(zv);
        }
        z.push(row);
    }

    let trace = Contour::new(x, y,z);
    let mut plot = Plot::new();

    plot.add_trace(trace);
    plot.show();
}


fn main() -> std::io::Result<()> {
    simple_contour_plot();
    Ok(())
}

For more examples see contour_examples.rs.

Heat-map Plot

extern crate plotly;
use plotly::{Plot, HeatMap};

fn basic_heat_map() {
    let z = vec![vec![1, 20, 30], vec![20, 1, 60], vec![30, 60, 1]];
    let trace = HeatMap::new_z(z);
    let mut plot = Plot::new();
    plot.add_trace(trace);
    plot.show();
}

fn main() -> std::io::Result<()> {
    basic_heat_map();
    Ok(())
}

For more examples see heat_map_examples.rs.

Surface plot

extern crate plotly;
use plotly::{Plot, Surface, Layout};
use plotly::surface::{Lighting, PlaneContours, PlaneProject, SurfaceContours};

fn spectral_surface_plot() {
    let mut x: Vec<f64> = Vec::new();
    let mut y: Vec<f64> = Vec::new();
    let mut z: Vec<Vec<f64>> = Vec::new();
    let N = 100;

    for i in 0..N {
        x.push(i as f64 / N as f64);
        y.push(i as f64 / N as f64);
    }

    for xi in 0..N {
        let mut iz: Vec<f64> = Vec::new();
        for yi in 0..N {
            let xf = (xi as f64) / N as f64;
            let yf = (yi as f64) / N as f64;

            let cz = (2.0 * xf * std::f64::consts::PI).sin() * (4.0 * yf * std::f64::consts::PI).cos();
            iz.push(cz);
        }
        z.push(iz);
    }

    let trace = Surface::new(z).x(x).y(y).visible(true)
        .hide_surface(false).lighting(Lighting::new())
        .contours(SurfaceContours::new().z(PlaneContours::new()
            .show(true).use_colormap(true).project(PlaneProject::new().z(true))));
    let mut plot = Plot::new();
    plot.set_layout(Layout::new());
    plot.add_trace(trace);
    plot.show();
}

fn main() -> std::io::Result<()> {
    spectral_surface_plot();
    Ok(())
}

For more examples see surface_plot_examples.rs.

Save plots

At present it is only possible to save plots in PNG, JPEG and HTML format with the help of the browser. For example the following code:

extern crate plotly;
use plotly::common::Mode;
use plotly::{Plot, Scatter};

fn line_and_scatter_plot() {
    let trace1 = Scatter::new(vec![1, 2, 3, 4], vec![10, 15, 13, 17])
        .name("trace1")
        .mode(Mode::Markers);
    let trace2 = Scatter::new(vec![2, 3, 4, 5], vec![16, 5, 11, 9])
        .name("trace2")
        .mode(Mode::Lines);
    let trace3 = Scatter::new(vec![1, 2, 3, 4], vec![12, 9, 15, 12]).name("trace3");

    let mut plot = Plot::new();
    plot.add_trace(trace1);
    plot.add_trace(trace2);
    plot.add_trace(trace3);
    // The following will generate the plot in PNG format (width: 1024, height: 680) and display it in the browser.
    plot.show_png(1024, 680);
    // Similarly to the above line but with a JPEG format output.
    plot.show_jpeg(1024, 680);
    // Save the resulting plot in `filename.html`
    plot.to_html("filename.html");
    plot.show();
}

fn main() -> std::io::Result<()> {
    line_and_scatter_plot();
    Ok(())
}

will open 3 tabs in the browser with the first two containing the PNG and JPEG outputs respectively. Then these must be saved manually by right clicking and selecting Save As... in the context menu of the browser. This is somewhat cumbersome. An alternative is to use the orca feature which draws on the Orca package to directly convert plot data to several formats. The orca feature enables to_* methods where* is one of the supported formats: png, jpeg, webp, svg, pdf and eps. The caveat is that there is a manual installation step required for this to work. For instructions please see: plotly_orca.

License

Plotly for Rust is distributed under the terms of the MIT license.

See LICENSE-MIT, and COPYRIGHT for details.

29 Open More issues

Closed

AWS Ubuntu - Fails to display image

When running a Rust executable on a AWS Ubuntu Spot instance, the run fails with the following message:

thread 'main' panicked at 'called Result::unwrap() on an Err value: Os { code: 2, kind: NotFound, message: "No such file or directory" }', /home/ubuntu/.cargo/registry/src/github.com-1ecc6299db9ec823/plotly-0.4.0/src/plot.rs:314:9 Otherwise runs fine in my local machine, opening the browser and displaying the image automatically

bug

opened Mar 25, 2020 by ceikit 2

Closed

License text isn't clear

Plotly for Rust is distributed under the terms of both the MIT license.

MIT and Apache-2.0, or something else?

opened Feb 26, 2020 by Phrohdoh 1

Closed

Margin right

https://github.com/igiagkiozis/plotly/blob/71111ae26a506f734626a16d2e9b9cded1c43e9b/src/charts/mod.rs#L1987

With the above we are able to adjust the left, top, and bottom largins. Can we add the right margin too? If you're happy to accept pull requests, I could take a look in future

opened Feb 26, 2020 by shahinrostami 1

Closed

Saving on windows is buggy

I'm having some strange outputs from the .to_pdf and .to_png methods..

So in rust I am calling these

        dam_density_plot.to_pdf("figures/dam_offspring_rate.pdf", 1600, 1000);
        dam_density_plot.to_png("figures/dam_offspring_rate.png", 1600, 1000);

and the results are strange.. (Before and after .show() does not change anything).

dam_offspring_rate.pdf

Maybe we need a unit converter to make these usizes make sense pixel wise or something?

opened Mar 13, 2020 by CGMossa 1

Open

Extract the render-to-string portion of to_html() into its own public method

Add a .to_inline_html() method to Plot which can then be sent elsewhere for rendering.

For example, when using in Evcxr this turns this construction:

let plotly_file = "/tmp/plot.html";
plot.to_html(plotly_file);
let plotly_contents = fs::read_to_string(plotly_file).unwrap();
println!("EVCXR_BEGIN_CONTENT text/html\n{}\nEVCXR_END_CONTENT", plotly_contents);
fs::remove_file(plotly_file)?;

into this one-liner:

println!("EVCXR_BEGIN_CONTENT text/html\n{}\nEVCXR_END_CONTENT", plot.to_inline_html());

I debated adding a helper method for that wrapping - I'm happy to do so but I feel it would be presumptive without an OK from @igiagkiozis since they might not wish to officially support such usage, and interested parties probably are using DARN anyway which is a better place for it.

Closes #12 as long as people are happy to do their own root div or Evcxr content wrapping.

opened Jun 4, 2020 by Xymist 0

Open

Subplot support

Would it be possible to get subplot support? At a minimum, it looks like methods would be needed to label and xaxis and a yaxis for traces such as Scatter, as well as the ability to define multiple axes in the layout, each with an anchor (see the examples at https://plotly.com/javascript/subplots/). It would also be nice to have an API similar to the python library (see https://plotly.com/python/subplots/).

opened May 19, 2020 by nwoodbury 0

Open

Expose inline html as a String

Exposing the html/javascript generated could help build dashboards with some rust web stack

let trace1 = Scatter::new(vec![1, 2, 3, 4], vec![10, 15, 13, 17])
       .name("trace1")
       .mode(Mode::Markers);
let mut plot = Plot::new();
plot.add_trace(trace1);
println!("{}", plot.to_inline_html());

Could have a result like

<div id="SomePlotlyID" />
<script>
//Javascript generated
</script>

opened May 11, 2020 by ykafia 0

Open

Adds From<&str> for Title

This enables one to write code like

let layout = plotly::layout::Layout::new().title("Overview plot".into());

Which could be nice to have.

opened Apr 30, 2020 by CGMossa 0

Open

data refs

I've only done it for the scatter plot so far. If you agree with my changes, I'll do the rest and add these changes to this PR.

opened Apr 25, 2020 by M1cha 0

Open

Typo in AxisType

Category corrected. This is not affecting anything within crate.

opened Apr 24, 2020 by CGMossa 0

vue-plotly plotly.jsvue-plotly - Wrapper for plotly.js declarative charting library that ships with 20 chart types, including 3D charts, statistical graphs, and SVG maps.

Plotly Express - Simple syntax for complex charts. Now integrated into plotly.py!

Productivity Tools for Plotly + Pandas

The interactive graphing library for Python (includes Plotly Express) :sparkles:

Open-source JavaScript charting library behind Plotly and Dash

A script [js + plotly.js] that guesses your next input no matter how random you try to be

Visualize large time-series data in plotly

XChart is a light-weight Java library for plotting data.

A plotting library in Ruby built on top of Vega and D3.

An interactive graphing library for R

Easy to use Python API wrapper to plot charts with matplotlib, plotly, bokeh and more

Blazing fast hexapod robot simulator with React and Plotly.

Plotters - A Rust drawing library focus on data plotting for both WASM and native applications 🦀 📈 🚀

plotlib is a generic data visualisation and plotting library for Rust

textplots - Terminal plotting library

Kotlin API for Lets-Plot - an open-source plotting library for statistical data.

atom-ide-rust — Rust IDE support for Atom, powered by the Rust Language Server (RLS)

Glot is a plotting library for Golang built on top of gnuplot.

Lets-Plot is an open-source plotting library for statistical data

termplotlib is a Python library for all your terminal plotting needs

ScottPlot is a free and open-source plotting library for .NET that makes it easy to interactively display large datasets.

Share this repo

Related Repos

Data visualization

1.1k

Realtime ticker data in your terminal 📈 Built with Rust. Data sourced from Yahoo! Finance...

Realtime ticker data in your terminal 📈 Built with Rust. Data sourced from Yahoo! Finance.

Data visualization

158

Inline diagrams for rustdoc with mermade.js

Aquamarine is a procedural macro extension for rustdoc, that aims to improve the visual component of Rust documentation through use of the mermaid.js diagrams.

Data visualization

9.7k

gping 🚀Ping, but with a graph

Data visualization

code-minimap🛰 A high performance code minimap render.

This tool is for generating text minimaps at 🚀 speed. You can use it to implement IDE-like minimap plugin for the terminal text editor, minimap.vim for example