Return MATLAB structure to C++ and access the elements

Question

I'm trying to run MATLAB from C++ and return the MATLAB output in a structure to C++. The structure could contain any number of things, including arrays of different dimensions and lengths. There's a similar question here , but the answer doesn't give enough detail for me to understand and extrapolate.

I'm running MATLAB using the MatlabEngine.hpp and MatlabDataArray.hpp . I need to return a lot of outputs and have tried other methods which don't quite do what I'm after. Using a structure seems the most logical / readable way to do things. I'll try to explain my case with the following examples, which are hopefully written in a way which will be most useful for anyone else with a similar problems.

MWE 1 - return n by n array

MATLAB code

function output = simple_fun1(a, bc)
% Takes input values of a and an array [a,b]
b = bc(1);
c = bc(2);
sum = a+b+c;
prod = a*b*c;
output = [sum, prod; 3, 4];

This can be run using the C++ code:

C++ code

#include "MatlabEngine.hpp"
#include "MatlabDataArray.hpp"
#include <iostream>

int main()
{
  using namespace matlab::engine;
  matlab::data::ArrayFactory factory; // Create MATLAB data array factory

  std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB(); // Start MATLAB engine

  matlabPtr->eval(u"addpath(genpath('C:/Users/...your path here...'))"); // Add the path to where MATLAB functions are.

  std::vector<double> bc{ 10, 13};
  std::vector<matlab::data::Array> args({
    factory.CreateScalar<double>(7),
    factory.CreateArray({ 1, 2 }, bc.cbegin(), bc.cend())
  });
  
  matlab::data::TypedArray<double> results = matlabPtr->feval(u"simple_fun1",args); // Run simple_fun1
  
  std::cout << "Sum: " << results[0][0] << std::endl;
  std::cout << "Prod: " << results[0][1] << std:endl;
  std::cout << "Three: " << results[1][0] << std::endl;
}

This works for a single return of an n by n array. But if I want to return data separately, ie function [sum, prod] = simple_fun1(a,bc) it doesn't work.

MWE2 - return multiple outputs

I've managed to return multiple outputs using tuples, but then I can only access the first element of the array (if it was an array output) since I've been unable to define a tuple of MATLAB arrays. For example

MATLAB code

function [sum, prod] = simple_fun2(a, bc)
% Takes input values of a and an array [a,b]
b = bc(1);
c = bc(2);
sum = a+b+c;
prod = a*b*c;

C++ code

  std::tuple<double, double> results;
  results = matlabPtr->feval< std::tuple<double, double>>(u"simple_fun2", double(7), std::vector<double>{ 10, 13}); // Just as another example of how to enter inputs in case that's helpful for anyone.
  double s;
  double p;
  std::tie(s, p) = results;
  std::cout << "Sum: " << s << ", Prod: " << p << std::endl;

Return structure

Instead, I would like to write my MATLAB function so that it returns a structure, which should hopefully simplify the code for large amounts of data being passed and allow the data to have different dimensions. However, I've been unable to create a working example.

MATLAB code

function output = simple_fun3(a, bc)
b = bc(1);
c = bc(2);
output.sum = a+b+c;
output.prod = a*b*c;
output.a_sq = a*a;
output.b_sq = b*b;

C++ code

#include "MatlabEngine.hpp"
#include "MatlabDataArray.hpp"
#include <iostream>

int main()
{
  using namespace matlab::engine;
  matlab::data::ArrayFactory factory; // Create MATLAB data array factory

  std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB(); // Start MATLAB engine

  matlabPtr->eval(u"addpath(genpath('C:/Users/...your path here...'))"); // Add the path to where MATLAB functions are.

  std::vector<double> bc{ 10, 13};
  std::vector<matlab::data::Array> args({
    factory.CreateScalar<double>(7),
    factory.CreateArray({ 1, 2 }, bc.cbegin(), bc.cend())
  });
  
  matlab::data::StructArray my_matlab_struct = factory.createStructArray(matlab::data::ArrayDimensions{ 1, 4}, std::vector<std::string>{'sum', 'prod', 'a_sq', 'b_sq'});
  my_matlab_struct = matlabPtr->feval(u"simple_fun3",args);

The above C++ code doesn't work and I don't understand how the structure is being defined; ie what the ArrayDimensions are dimensions of. Any help is appreciated. Thanks

Answer 1

After much searching I managed to solve the problem and pass structures between C++ and MATLAB. The solution is based on this , but the code at the link doesn't work due to missing namespaces. Therefore I've put the solution below. Note: the solution assumes you already have MATLAB and C++ setup to interface with each other, which can be a whole other process depending your MATLAB version and, if you're using Visual Studio, your Visual Studio version too.

Pass a structure to MATLAB from C++

Not part of my original question, but this may be useful to someone.

#include "MatlabEngine.hpp"
#include "MatlabDataArray.hpp"

#include <iostream>
#pragma comment (lib,"libmat.lib")
#pragma comment (lib,"libmx.lib")
#pragma comment (lib,"libmex.lib")
#pragma comment (lib,"libeng.lib")

int main()
{
  using namespace matlab::engine;
  matlab::data::ArrayFactory factory; // Create MATLAB data array factory
  std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB(); // Start MATLAB engine
  
  matlabPtr->eval(u"addpath(genpath('Insert the path of any MATLAB functions you plan to use'))")
  
  matlab::data::StructArray my_structure = factory.createStructArray({1, 1},{"x","y","z"}); // Create a structure with one element and fields x,y,z
  my_structure[0]["x"] = factory.createArray({1, 3},{1., 2., 3.});
  my_structure[0]["y"] = factory.createArray({1, 3},{1., 4., 9.});
  my_structure[0]["z"] = factory.createArray({1, 3},{1., 8., 27.});
  
  matlabPtr->setVariable(u"Mstruct",my_structure); // pass structure to matlab workspace
  matlabPtr->eval(u"Mstruct") // show the structure exists.
  // The array can be passed to a function using feval
}

Get a structure returned from a function

The code below assumes the MATLAB engine is already set up and gets a structure returned from a MATLAB script called matlab_fun which accepts the input(s) args .

  matlab::data::StructArray my_matlab_struct = matlabPtr->feval(u"matlab_fun",args);
  matlab::data::ArrayDimensions dims = my_matlab_struct.getDimensions();
  std::cout << "Structure is: " << dims[0] << " by " << dims[1] << std::endl;
  size_t numFields = my_matlab_struct.getNumberOfFields();
  std::cout << "Structure has " << numFields << " fields." << std::endl;

  matlab::data::Range<matlab::data::ForwardIterator, matlab::data::MATLABFieldIdentifier const> fields = my_matlab_struct.getFieldNames();
  
  for (int i=0; i<numFields; i++){
    matlab::data::TypedArray<double> data = my_matlab_struct[0][fields.begin()[i]]; // [0] for the first element of the structure. Iterates over the fields.
    matlab::data::ArrayDimensions data_dims = data.getDimensions();
    for (int j=0; j<data_dims[0];j++){
      for (int k=0; k<data_dims[1];k++){
        std::cout << data[j][k] << " ";
      }
      std::cout << std::endl;
    }
  }