If I have a two dimensional array in C#, how would I plot the contents of this array in Matlab, as a 2-D graph? I'm after an extension method, i.e.
my2DArray.PlotInMatlab();
C and Gnuplot can be used to plot complex functions. One can write the function in C and then write the values of the function at various values in a txt file, which can then be plotted using Gnuplot. The txt file should have numerical values in at least two columns. The first column is for x values.
You can draw lines between points to get a very good "graph" impression, but be careful not to incorrectly represent at definition gaps. E.g. drawing a line from (X=-0.1,Y=1/-0,1) to (X=0.1,Y=1/0,1) would be wrong. line(x1, y1, x2, y2);
I got this working well in the end. Here is a sample graph, generated by a .NET 4.0 C# console app that calls a Matlab .m file:
The nice thing is that we can use all the power of Matlab for drawing graphs, with only a few lines of .NET.
How to do this in .NET:
Create a new .NET console app for C# in Visual Studio 2010, and change it to .NET 4.0 (right click on the project, select "Properties").
.NET Main():
using System;
using System.Diagnostics;
namespace MyPlotGraphUsingMatlabRuntimes
{
/// <summary>
/// Display a graph in Matlab, from a .NET console app.
/// </summary>
class Program
{
static void Main(string[] args)
{
var x = new double[100];
var y = new double[100];
for (int i = 0; i < 100; i++) {
x[i] = i;
y[i] = 2 ^ i;
}
MyHelper.MyMatlab.MyGraph2D(x,y);
Console.Write("[any key to exit]");
Console.ReadKey();
}
}
}
.NET class that provides extension methods to do interop into Matlab (name the file MyMatlab.cs
).
using System;
using System.Collections.Generic;
using MathWorks.MATLAB.NET.Arrays;
namespace MyHelper
{
/// <summary>
/// Collection of chained classes to make Matlab access easier.
/// </summary>
public static class MyMatlab
{
/// <summary>
/// Returns a double in a format that can be passed into Matlab.
/// </summary>
/// <param name="toMatlab">Double to convert into a form we can pass into Matlab.</param>
/// <returns>A double in Matlab format.</returns>
public static MWNumericArray MyToMatlab(this double toMatlab)
{
return new MWNumericArray(toMatlab);
}
/// <summary>
/// Converts an array that contains a single Matlab return parameter back into a .NET double.
/// </summary>
/// <param name="toDouble">MWArray variable, returned from Matlab code.</param>
/// <returns>.NET double.</returns>
public static double MyToDouble(this MWArray toDouble)
{
var matNumericArray = (MWNumericArray)toDouble;
return matNumericArray.ToScalarDouble();
}
/// <summary>
/// Converts an array that contains multiple Matlab return parameters back into a list of .NET doubles.
/// </summary>
/// <param name="toList">MWArray variable, returned from Matlab code.</param>
/// <returns>List of .NET doubles.</returns>
public static List<double> MyToDoubleList(this MWArray toList)
{
var matNumericArray = toList;
var netArray = (MWNumericArray)matNumericArray.ToArray();
var result = new List<double>();
// Console.Write("{0}", netArray[1]);
for (int i = 1; i <= netArray.NumberOfElements; i++) // Matlab arrays are 1-based, thus the odd indexing.
{
result.Add(netArray[i].ToScalarDouble());
}
return result;
}
/// <summary>
/// Converts an array that contains multiple Matlab return parameters back into a list of .NET ints.
/// </summary>
/// <param name="toList">MWArray variable, returned from Matlab code.</param>
/// <returns>List of .NET ints.</returns>
public static List<int> MyToMWNumericArray(this MWArray toList)
{
var matNumericArray = toList;
var netArray = (MWNumericArray)matNumericArray.ToArray();
var result = new List<int>();
// Console.Write("{0}", netArray[1]);
for (int i = 1; i <= netArray.NumberOfElements; i++) // Matlab arrays are 1-based, thus the odd indexing.
{
result.Add(netArray[i].ToScalarInteger());
}
return result;
}
/// <summary>
/// Converts an int[] array into a Matlab parameters.
/// </summary>
/// <param name="intArray">MWArray variable, returned from Matlab code.</param>
/// <returns>List of .NET ints.</returns>
public static MWNumericArray MyToMWNumericArray(this int[] intArray)
{
return new MWNumericArray(1, intArray.Length, intArray); // rows, columns int[] realData
}
/// <summary>
/// Converts an double[] array into parameter for a Matlab call.
/// </summary>
/// <param name="arrayOfDoubles">Array of doubles.</param>
/// <returns>MWNumericArray suitable for passing into a Matlab call.</returns>
public static MWNumericArray MyToMWNumericArray(this double[] arrayOfDoubles)
{
return new MWNumericArray(1, arrayOfDoubles.Length, arrayOfDoubles); // rows, columns int[] realData
}
/// <summary>
/// Converts an List of doubles into a parameter for a Matlab call.
/// </summary>
/// <param name="listOfDoubles">List of doubles.</param>
/// <returns>MWNumericArray suitable for passing into a Matlab call.</returns>
public static MWNumericArray MyToMWNumericArray(this List<double> listOfDoubles)
{
return new MWNumericArray(1, listOfDoubles.Count, listOfDoubles.ToArray()); // rows, columns int[] realData
}
/// <summary>
/// Converts a list of some type into an array of the same type.
/// </summary>
/// <param name="toArray">List of some type.</param>
/// <returns>Array of some type.</returns>
public static T[] MyToArray<T>(this List<T> toArray)
{
var copy = new T[toArray.Count];
for (int i = 0; i < toArray.Count; i++) {
copy[i] = toArray[i];
}
return copy;
}
static private readonly MatlabGraph.Graph MatlabInstance = new MatlabGraph.Graph();
/// <summary>
/// Plot a 2D graph.
/// </summary>
/// <param name="x">Array of doubles, x axis.</param>
/// <param name="y">Array of doubles, y axis.</param>
/// <param name="title">Title of plot.</param>
/// <param name="xaxis">X axis label.</param>
/// <param name="yaxis">Y axis label.</param>
static public void MyGraph2D(List<double> x, List<double> y, string title = "title", string xaxis = "xaxis", string yaxis = "yaxis")
{
MatlabInstance.Graph2D(x.MyToMWNumericArray(), y.MyToMWNumericArray(), title, xaxis, yaxis);
}
/// <summary>
/// Plot a 2D graph.
/// </summary>
/// <param name="x">Array of doubles, x axis.</param>
/// <param name="y">Array of doubles, y axis.</param>
/// <param name="title">Title of plot.</param>
/// <param name="xaxis">X axis label.</param>
/// <param name="yaxis">Y axis label.</param>
static public void MyGraph2D(double[] x, double[] y, string title = "title", string xaxis = "xaxis", string yaxis = "yaxis")
{
MatlabInstance.Graph2D(x.MyToMWNumericArray(), y.MyToMWNumericArray(), title, xaxis, yaxis);
}
/// <summary>
/// Unit test for this class. Displays a graph using Matlab.
/// </summary>
static public void Unit()
{
{
var x = new double[100];
var y = new double[100];
for (int i = 0; i < 100; i++) {
x[i] = i;
y[i] = Math.Sin(i);
}
MyGraph2D(x, y);
}
{
var x = new double[100];
var y = new double[100];
for (int i = 0; i < 100; i++) {
x[i] = i;
y[i] = 2 ^ i;
}
MyGraph2D(x, y);
}
}
}
}
Next, we export a .m file into a .NET assembly. I used Matlab 2010a (this will work for 2010b also). Use Matlab, 32-bit version (32-bit or 64-bit is displayed in the splash screen when Matlab starts up).
The following Matlab code displays a graph. Save it as Graph2D.m
.
function Graph2D (x,y, titleTop, labelX, labelY)
% Create figure
myNewFigure = figure;
plot(x,y)
title({titleTop});
xlabel({labelX});
ylabel({labelY});
Test this within Matlab by typing the following at the console (make sure you change Current Folder
in the Matlab toolbar to the same directory as Graph2D.m
):
x = 0:.2:20;
y = sin(x)./sqrt(x+1);
Graph2D(x,y,'myTitle', 'my x-axis', 'my y-axis')
In the Matlab deployment tool, add a class Graph
, and add the file Graph2D.m
, then package it into MatlabGraph.dll
(change the component name to MatlabGraph
in settings, this determines the name of the generated .dll).
In your .NET project, add a reference to MatlabGraph.dll
(the .NET .dll we have just compiled from Graph2D.m
). This will be 32-bit
if its compiled with the 32-bit
release of Matlab.
MWArray.dll
. You can find this by searching the Matlab install directory. 32-bit
, or consistently 64-bit
.
32-bit
, your .NET app must be compiled for x32
, you must use the 32-bit
version of Matlab (it will show 32-bit
in the splash screen) to export the .NET .dll, and you must import the 32-bit
version of MWArray.dll
into your .NET project.64-bit
, compile your .NET app into All CPU
, you must use the 64-bit
version of Matlab (it will show 64-bit
in the splash screen) to export the .NET .dll, and you must import the 64-bit
version of MWArray.dll
into your .NET project. File..New..Figure
, customize it using Insert
, then generate the .m code using File..Generate M file
. Its fairly obvious what the lines in the newly generated .m file do, you can copy them into your original Graph2D.m
file, then regenerate MatlabGraph.dll
. For example, adding a title to the figure adds a line title({'My new title});
to the auto-generated .m file.If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With