Plotly.NET provides functions for generating and rendering plotly.js charts in .NET programming languages 📈🚀.
Plotly.NET will be available as 2.0.0 version of its predecessor FSharp.Plotly. The feature roadmap can be seen here. Contributions are very welcome!
Old packages up until version 1.2.2 can be accessed via the old package name FSharp.Plotly here
A preview version of Plotly.NET 2.0.0 is available on nuget to plug into your favorite package manager.
You can find all available package versions on the nuget page.
|
|
|
Or add the package reference directly to your .*proj
file:
<PackageReference Include="Plotly.NET" Version="<desired-version-here>" />
You can include the package via an inline package reference:
#r "nuget: Plotly.NET, <desired-version-here>"
You can use the same inline package reference as in script, but as an additional goodie, the interactive extensions for dotnet interactive have you covered for seamless chart rendering:
#r "nuget: Plotly.NET, <desired-version-here>"
#r "nuget: Plotly.NET.Interactive,<desired-version-here>"
The general design philosophy of Plotly.NET implements the following visualization flow:
GenericChart
object from the data you want to visualize by using the respective Chart.*
function, optionally setting some specific style parametersThe Chart
module contains a lot of functions named after the type of chart they will create, e.g.
Chart.Point
will create a point chart, Chart.Scatter3d
wil create a 3D scatter chart, and so on.
The respective functions all contain specific arguments, but they all have in common that the first mandatory arguments are the data to visualize.
Example: The first two arguments of the Chart.Point
function are the x and y data. You can therefore initialize a point chart like this:
open Plotly.NET
let xData = [0. .. 10.]
let yData = [0. .. 10.]
let myFirstChart = Chart.Point(xData,yData)
Styling functions are generally the Chart.with*
naming convention. The following styling example does:
Chart.withTitle
Chart.withX_AxisStyle
Chart.withY_AxisStyle
let myFirstStyledChart =
Chart.Point(xData,yData)
|> Chart.withTitle "Hello world!"
|> Chart.withX_AxisStyle ("xAxis", Showgrid=false)
|> Chart.withY_AxisStyle ("yAxis", Showgrid=false)
Attention: Styling functions mutate 😈 the input chart, therefore possibly affecting bindings to intermediary results. We recommend creating a single chart for each workflow to prevent unexpected results
The Chart.Show
function will open a browser window and render the input chart there. When working in a notebook context, after
referencing Plotly.NET.Interactive, the function is not necessary, just end the cell with the value of the chart.
myFirstChart
|> Chart.Show
Should render this chart in your brower:
myFirstStyledChart
|> Chart.Show
And here is what happened after applying the styles from above:
In a notebook context you usually have (at leat when running on a jupyter server like binder) no access to the browser on the machine where plotly runs on. That's why you can render charts directly in the cell output. Just end the cell with the chart value:
let xData' = [0. .. 10.]
let yData' = [0. .. 10.]
Chart.Point(xData',yData')
Here is the styled chart:
Chart.Point(xData,yData)
|> Chart.withTitle "Hello world!"
|> Chart.withX_AxisStyle ("xAxis", Showgrid=false)
|> Chart.withY_AxisStyle ("yAxis", Showgrid=false)
One of the main design points of Plotly.NET it is to provide support for multiple flavors of chart generation. Here are 2 examples in different styles and languages that create an equivalent chart:
[(1,5);(2,10)]
|> Chart.Point
|> Chart.withTraceName("Hello from F#",Showlegend=true)
|> Chart.withY_AxisStyle("xAxis",Showgrid= false, Showline=true)
|> Chart.withX_AxisStyle("yAxis",Showgrid= false, Showline=true)
static void Main(string[] args)
{
double[] x = new double[] { 1, 2 };
double[] y = new double[] { 5, 10 };
GenericChart.GenericChart chart = Chart.Point(x: x, y: y);
chart
.WithTraceName("Hello from C#", true)
.WithX_AxisStyle(title: "xAxis", Showgrid: false, Showline: true)
.WithY_AxisStyle(title: "yAxis", Showgrid: false, Showline: true)
.Show();
}
DynamicObj
:let xAxis =
let tmp = Axis.LinearAxis()
tmp?title <- "xAxis"
tmp?showgrid <- false
tmp?showline <- true
tmp
let yAxis =
let tmp = Axis.LinearAxis()
tmp?title <- "yAxis"
tmp?showgrid <- false
tmp?showline <- true
tmp
let layout =
let tmp = Layout()
tmp?xaxis <- xAxis
tmp?yaxis <- yAxis
tmp?showlegend <- true
tmp
let trace =
let tmp = Trace("scatter")
tmp?x <- [1;2]
tmp?y <- [5;10]
tmp?mode <- "markers"
tmp?name <- "Hello from F#"
tmp
GenericChart.ofTraceObject(trace)
|> GenericChart.setLayout layout
DynamicObj
:static void Main(string[] args)
{
double[] x = new double[] { 1, 2 };
double[] y = new double[] { 5, 10 };
Axis.LinearAxis xAxis = new Axis.LinearAxis();
xAxis.SetValue("title", "xAxis");
xAxis.SetValue("showgrid", false);
xAxis.SetValue("showline", true);
Axis.LinearAxis yAxis = new Axis.LinearAxis();
yAxis.SetValue("title", "yAxis");
yAxis.SetValue("showgrid", false);
yAxis.SetValue("showline", true);
Layout layout = new Layout();
layout.SetValue("xaxis", xAxis);
layout.SetValue("yaxis", yAxis);
layout.SetValue("showlegend", true);
Trace trace = new Trace("scatter");
trace.SetValue("x", x);
trace.SetValue("y", y);
trace.SetValue("mode", "markers");
trace.SetValue("name", "Hello from C#");
GenericChart
.ofTraceObject(trace)
.WithLayout(layout)
.Show();
}
The project is hosted on GitHub where you can report issues, fork the project and submit pull requests. If you're adding a new public API, please also consider adding samples that can be turned into a documentation. You might also want to read the library design notes to understand how it works.
The library is available under Public Domain license, which allows modification and redistribution for both commercial and non-commercial purposes. For more information see the License file in the GitHub repository.