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
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.
Please note that the Free tier of Azure AI Search is rather slow and seems to only allow queryes at a certain interval, it will suffice to just test it out. To really test it out in for example an Intranet scenario, the standard tier Azure AI search service is recommended, at about 250 USD per month as noted.
Let's look at some code for this DEMO too. You can study the Github repo and clone it to test it out yourself.
The TextToSpeechUtil class handles much of the logic of creating voice from text input and also create the SSML-XML contents and performt the REST api call to create the voice file.
Note that SSML mentioned here, is the Speech Synthesis Markup Language (SSML).
The SSML standard is documented here on MSDN, it is a standard adopted by others too including Google.