Creating a graph or a plot from a C# console app, using Matlab?

Question

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();

Answer 1

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:

6. 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").

   11. .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();
               }
           }
       }
       

   12. .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);
                   }
               }
           }
       }
       

7. 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).

   2. 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});
      

   3. 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')
      

   4. 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).

   5. 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.

   6. In your .NET project, add a reference to the 32-bit version of MWArray.dll. You can find this by searching the Matlab install directory.
   7. Again, make sure that everything is either consistently 32-bit, or consistently 64-bit.
      9. If you choose 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.
      10. If you choose 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.
   8. Run the .NET app, and it will display the graph above, by calling the Matlab runtimes.
8. If you want to deploy this to a new PC, you will have to install the .NET runtimes on this PC (these are royalty free).
9. The nice thing about this is that you can customize the graphs in Matlab to your hearts content, using all the power of Matlab. You could do 3-D graphs: create a new figure in Matlab using 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.
10. If there is any interest, I can provide the complete C# sample project in .NET.