MatPlotLib is a powerful library for data visualization. It provides graphing for scientific computing. It can be used for doing both mathematical calculations and statistics.
Together with additional libraries like NumPy or Numerical Python, it is clear that Python as a programming language and
ecosystem provides a lot of powerful functionality that is
also free to use. MatplotLib has a BSD license, which means it can be ued for personal, academic or commercial purposes without restrictions.
This article will look at using MatplotLib from .NET.
First off an image that displays the demo and example of using MatplotLib.
The source code shown in this article is available on Github here:
https://github.com/toreaurstadboss/SeabornBlazorVisualizer
Using MatPlotLib from .NET
First off, install
Anaconda. Anaconda is a Python distribution that contains a large collection of data visualization libraries. A compatible version with the lastest version of
Python.net Nuget library. The demo displayed here uses
Anaconda version 2023.03.
Anaconda archived versions 2023.03 can be installed from here. Windows users can download the file:
https://repo.anaconda.com/archive/Anaconda3-2023.03-1-Windows-x86_64.exe
https://repo.anaconda.com/archive/
Next up, install also Python 3.10 version. It will be used together with Anaconda. A 64-bit installer can be found here:
Python 3.10 installer (Windows 64-bits)
The correct versions of
NumPy and
MatPlotLib can be checked against this list :
https://github.com/toreaurstadboss/SeabornBlazorVisualizer/blob/main/SeabornBlazorVisualizer/conda_list_loading_matplotlib_working_1st_May_2025.txt
Calculating the determinite integral of a function
The demo in this article show in the link at the top has got an appsettings.json file, you can adjust to your environment.
appsettings.json Application configuration file
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"PythonConfig": {
"PythonDllPath": "C:\\Python310\\Python310.dll",
"PythonHome": "C:\\Programdata\\anaconda3",
"PythonSitePackages": "C:\\Programdata\\anaconda3\\lib\\site-packages",
"PythonVersion": "3.10"
},
"AllowedHosts": "*"
}
Clone the source code and run the application. It is a Blazor server app. You can run it from VS 2022 for example.
The following code shows how Python.net is set up to start using Python. Both Python 3.10 and Anaconda
site libs are used here.
The Python runtime and engine is set up using this helper class.
PythonInitializer.cs
using Microsoft.Extensions.Options;
using Python.Runtime;
namespace SeabornBlazorVisualizer.Data
{
/// <summary>
/// Helper class to initialize the Python runtime
/// </summary>
public static class PythonInitializer
{
private static bool runtime_initialized = false;
/// <summary>
/// Perform one-time initialization of Python runtime
/// </summary>
/// <param name="pythonConfig"></param>
public static void InitializePythonRuntime(IOptions<PythonConfig> pythonConfig)
{
if (runtime_initialized)
return;
var config = pythonConfig.Value;
// Set environment variables
Environment.SetEnvironmentVariable("PYTHONHOME", config.PythonHome, EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("PYTHONPATH", config.PythonSitePackages, EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("PYTHONNET_PYDLL", config.PythonDllPath);
Environment.SetEnvironmentVariable("PYTHONNET_PYVER", config.PythonVersion);
PythonEngine.Initialize();
PythonEngine.PythonHome = config.PythonHome ?? Environment.GetEnvironmentVariable("PYTHONHOME", EnvironmentVariableTarget.Process)!;
PythonEngine.PythonPath = config.PythonDllPath ?? Environment.GetEnvironmentVariable("PYTHONNET_PYDLL", EnvironmentVariableTarget.Process)!;
PythonEngine.BeginAllowThreads();
AddSitePackagesToPythonPath(pythonConfig);
runtime_initialized = true;
}
private static void AddSitePackagesToPythonPath(IOptions<PythonConfig> pythonConfig)
{
if (!runtime_initialized)
{
using (Py.GIL())
{
dynamic sys = Py.Import("sys");
sys.path.append(pythonConfig.Value.PythonSitePackages);
Console.WriteLine(sys.path);
//add folders in solution this too with scripts
sys.path.append(@"Data/");
}
}
}
}
}
The following helper class sets up the site libraries we will use.
PythonHelper.cs
using Python.Runtime;
namespace SeabornBlazorVisualizer.Data
{
/// <summary>
/// Helper class to initialize the Python runtime
/// </summary>
public static class PythonHelper
{
/// <summary>
/// Imports Python modules. Returned are the following modules:
/// <para>np (numpy)</para>
/// <para>os (OS module - standard library)</para>
/// <para>scipy (scipy)</para>
/// <para>mpl (matplotlib)</para>
/// <para>plt (matplotlib.pyplot </para>
/// </summary>
/// <returns>Tuple of Python modules</returns>
public static (dynamic np, dynamic os, dynamic scipy, dynamic mpl, dynamic plt) ImportPythonModules()
{
dynamic np = Py.Import("numpy");
dynamic os = Py.Import("os");
dynamic mpl = Py.Import("matplotlib");
dynamic plt = Py.Import("matplotlib.pyplot");
dynamic scipy = Py.Import("scipy");
mpl.use("Agg");
return (np, os, scipy, mpl, plt);
}
}
}
The demo is a Blazor server app. The following service will generate the plot of a determinite integral using MatPlotLib. The service saves the plot into a PNG file. This PNG file is saved into the folder
wwwroot.
The Blazor server app displays the image that was generated and saved.
MatPlotImageService.cs
using Microsoft.Extensions.Options;
using Python.Runtime;
namespace SeabornBlazorVisualizer.Data
{
public class MatplotPlotImageService
{
private IOptions<PythonConfig>? _pythonConfig;
private static readonly object _lock = new object();
public MatplotPlotImageService(IOptions<PythonConfig> pythonConfig)
{
_pythonConfig = pythonConfig;
PythonInitializer.InitializePythonRuntime(_pythonConfig);
}
public Task<string> GenerateDefiniteIntegral(string functionExpression, int lowerBound, int upperBound)
{
string? result = null;
using (Py.GIL()) // Ensure thread safety for Python calls
{
dynamic np = Py.Import("numpy");
dynamic plt = Py.Import("matplotlib.pyplot");
dynamic patches = Py.Import("matplotlib.patches"); // Import patches module
// Create a Python execution scope
using (var scope = Py.CreateScope())
{
// Define the function inside the scope
scope.Exec($@"
import numpy as np
def func(x):
return {functionExpression}
");
// Retrieve function reference from scope
dynamic func = scope.Get("func");
// Define integration limits
double a = lowerBound, b = upperBound;
// Generate x-values
dynamic x = np.linspace(0, 10, 100); //generate evenly spaced values in range [0, 20], 100 values (per 0.1)
dynamic y = func.Invoke(x);
// Create plot figure
var fig = plt.figure();
var ax = fig.add_subplot(111);
// set title to function expression
plt.title(functionExpression);
ax.plot(x, y, "r", linewidth: 2);
ax.set_ylim(0, null);
// Select range for integral shading
dynamic ix = np.linspace(a, b, 100);
dynamic iy = func.Invoke(ix);
// **Fix: Separate x and y coordinates properly**
List<double> xCoords = new List<double> { a }; // Start at (a, 0)
List<double> yCoords = new List<double> { 0 };
int length = (int)np.size(ix);
for (int i = 0; i < length; i++)
{
xCoords.Add((double)ix[i]);
yCoords.Add((double)iy[i]);
}
xCoords.Add(b); // End at (b, 0)
yCoords.Add(0);
// Convert x and y lists to NumPy arrays
dynamic npVerts = np.column_stack(new object[] { np.array(xCoords), np.array(yCoords) });
// **Correctly Instantiate Polygon Using NumPy Array**
dynamic poly = patches.Polygon(npVerts, facecolor: "0.6", edgecolor: "0.2");
ax.add_patch(poly);
// Compute integral area
double area = np.trapezoid(iy, ix);
ax.text(0.5 * (a + b), 30, "$\\int_a^b f(x)\\mathrm{d}x$", ha: "center", fontsize: 20);
ax.text(0.5 * (a + b), 10, $"Area = {area:F2}", ha: "center", fontsize: 12);
plt.show();
result = SavePlot(plt, dpi: 150);
}
}
return Task.FromResult(result);
}
public Task<string> GenerateHistogram(List<double> values, string title = "Provide Plot title", string xlabel = "Provide xlabel title", string ylabel = "Provide ylabel title")
{
string? result = null;
using (Py.GIL()) //Python Global Interpreter Lock (GIL)
{
var (np, os, scipy, mpl, plt) = PythonHelper.ImportPythonModules();
var distribution = np.array(values.ToArray());
//// Ensure clearing the plot
//plt.clf();
var fig = plt.figure(); //create a new figure
var ax1 = fig.add_subplot(1, 2, 1);
var ax2 = fig.add_subplot(1, 2, 2);
// Add style
plt.style.use("ggplot");
var counts_bins_patches = ax1.hist(distribution, edgecolor: "black");
// Normalize counts to get colors
var counts = counts_bins_patches[0];
var patches = counts_bins_patches[2];
var norm_counts = counts / np.max(counts);
int norm_counts_size = Convert.ToInt32(norm_counts.size.ToString());
// Apply colors to patches based on frequency
for (int i = 0; i < norm_counts_size; i++)
{
plt.setp(patches[i], "facecolor", plt.cm.viridis(norm_counts[i])); //plt.cm is the colormap module in MatPlotlib. viridis creates color maps from normalized value 0 to 1 that is optimized for color-blind people.
}
// **** AX1 Histogram first - frequency counts *****
ax1.set_title(title);
ax1.set_xlabel(xlabel);
ax1.set_ylabel(ylabel);
string cwd = os.getcwd();
// Calculate average and standard deviation
var average = np.mean(distribution);
var std_dev = np.std(distribution);
var total_count = np.size(distribution);
// Format average and standard deviation to two decimal places
var average_formatted = np.round(average, 2);
var std_dev_formatted = np.round(std_dev, 2);
//Add legend with average and standard deviation
ax1.legend(new string[] { $"Total count: {total_count}\n Average: {average_formatted} cm\nStd Dev: {std_dev_formatted} cm" }, framealpha: 0.5, fancybox: true);
//***** AX2 : Set up ax2 = Percentage histogram next *******
ax2.set_title("Percentage distribution");
ax2.set_xlabel(xlabel);
ax2.set_ylabel(ylabel);
// Fix for CS1977: Cast the lambda expression to a delegate type
ax2.yaxis.set_major_formatter((PyObject)plt.FuncFormatter(new Func<double, int, string>((y, _) => $"{y:P0}")));
ax2.hist(distribution, edgecolor: "black", weights: np.ones(distribution.size) / distribution.size);
// Format y-axis to show percentages
ax2.yaxis.set_major_formatter(plt.FuncFormatter(new Func<double, int, string>((y, _) => $"{y:P0}")));
// tight layout to prevent overlap
plt.tight_layout();
// Show the plot with the two subplots at last (render to back buffer 'Agg', see method SavePlot for details)
plt.show();
result = SavePlot(plt, theme: "bmh", dpi: 150);
}
return Task.FromResult(result);
}
public Task<string> GeneratedCumulativeGraphFromValues(List<double> values)
{
string? result = null;
using (Py.GIL()) //Python Global Interpreter Lock (GIL)
{
var (np, os, scipy, mpl, plt) = PythonHelper.ImportPythonModules();
dynamic pythonValues = np.cumsum(np.array(values.ToArray()));
// Ensure clearing the plot
plt.clf();
// Create a figure with increased size
dynamic fig = plt.figure(figsize: new PyTuple(new PyObject[] { new PyFloat(6), new PyFloat(4) }));
// Plot data
plt.plot(values, color: "green");
string cwd = os.getcwd();
result = SavePlot(plt, theme: "ggplot", dpi: 200);
}
return Task.FromResult(result);
}
public Task<string> GenerateRandomizedCumulativeGraph()
{
string? result = null;
using (Py.GIL()) //Python Global Interpreter Lock (GIL)
{
dynamic np = Py.Import("numpy");
//TODO : Remove imports of pandas and scipy and datetime if they are not needed
Py.Import("pandas");
Py.Import("scipy");
Py.Import("datetime");
dynamic os = Py.Import("os");
dynamic mpl = Py.Import("matplotlib");
dynamic plt = Py.Import("matplotlib.pyplot");
// Set dark theme
plt.style.use("ggplot");
mpl.use("Agg");
// Generate data
//dynamic x = np.arange(0, 10, 0.1);
//dynamic y = np.multiply(2, x); // Use NumPy's multiply function
dynamic values = np.cumsum(np.random.randn(1000, 1));
// Ensure clearing the plot
plt.clf();
// Create a figure with increased size
dynamic fig = plt.figure(figsize: new PyTuple(new PyObject[] { new PyFloat(6), new PyFloat(4) }));
// Plot data
plt.plot(values, color: "blue");
string cwd = os.getcwd();
result = SavePlot(plt, theme: "ggplot", dpi: 200);
}
return Task.FromResult(result);
}
/// <summary>
/// Saves the plot to a PNG file with a unique name based on the current date and time
/// </summary>
/// <param name="plot">Plot, must be a PyPlot plot use Python.net Py.Import("matplotlib.pyplot")</param>
/// <param name="theme"></param>
/// <param name="dpi"></param>
/// <returns></returns>
public string? SavePlot(dynamic plt, string theme = "ggplot", int dpi = 200)
{
string? plotSavedImagePath = null;
//using (Py.GIL()) //Python Global Interpreter Lock (GIL)
//{
dynamic os = Py.Import("os");
dynamic mpl = Py.Import("matplotlib");
// Set dark theme
plt.style.use(theme);
mpl.use("Agg"); //set up rendering of plot to back-buffer ('headless' mode)
string cwd = os.getcwd();
// Save plot to PNG file
string imageToCreatePath = $@"GeneratedImages\{DateTime.Now.ToString("yyyyMMddHHmmss")}{Guid.NewGuid().ToString("N")}_plotimg.png";
string imageToCreateWithFolderPath = $@"{cwd}\wwwroot\{imageToCreatePath}";
plt.savefig(imageToCreateWithFolderPath, dpi: dpi); //save the plot to a file (use full path)
plotSavedImagePath = imageToCreatePath;
CleanupOldGeneratedImages(cwd);
//}
return plotSavedImagePath;
}
private static void CleanupOldGeneratedImages(string cwd)
{
lock (_lock)
{
Directory.GetFiles(cwd + @"\wwwroot\GeneratedImages", "*.png")
.OrderByDescending(File.GetLastWriteTime)
.Skip(10)
.ToList()
.ForEach(File.Delete);
}
}
}
The code above shows some additional examples of using MatPlotLib.
- Histogram example
- Line graph using cumulative sum by making use of NumPy or a helper method in .NET
These examples demonstrates also that MatPlotLib can be used for statistics, which today for .NET is mostly crunched with the help of Excel or EP Plus library for example.
Since Python is considered as the home of data visualization with its vast ecosystem of data science libraries, this article and demos shows how you can get started with using this ecosystem from .NET.
Note, using Python.net to create these plots in MatPlotLib is best prepared using
Jupyter Notebook. When the plot displayed looks okay, it is time to integrate that Python script into
.NET and C# using Python.Net library. Make note that there will be some challenges to get the Python code to work in C# of course. When passing in values to a function, sometimes you must use
for example NumPy to create compatible data types. Also note the usage of the
Pystatic class here from Python.net , which offers the GIL Global Interpreter lock and a way to import Python modules.
https://jupyter.org/
A screenshot showing histogram in the demo is shown below. As we can see, MatPlotLib can be used from many different data visualizations and domains.
