¿Cómo acceder a una matriz en el campo de una estructura matlab desde una función mex?

Question

Estoy tratando de averiguar cómo acceder a una matriz que está almacenada en un campo en una estructura matlab a partir de una función mex.

Eso es terriblemente largo aliento ... Me explico:

tengo una estructura de MATLAB que se definió como la siguiente:

matrixStruct = struct('matrix', {4, 4, 4; 5, 5, 5; 6, 6 ,6}) 

Tengo una función Mex en el que me gustaría ser capaz de recibir un puntero al primer elemento en la matriz (matriz [0] [0], en términos c), pero no he podido averiguar cómo hacerlo.

He intentado lo siguiente:

/* Pointer to the first element in the matrix (supposedly)... */ 
double *ptr = mxGetPr(mxGetField(prhs[0], 0, "matrix"); 

/* Incrementing the pointer to access all values in the matrix */ 
for(i = 0; i < 3; i++){ 
    printf("%f\n", *(ptr + (i * 3))); 
    printf("%f\n", *(ptr + 1 + (i * 3))); 
    printf("%f\n", *(ptr + 2 + (i * 3))); 
} 

Lo que esto termina la impresión es la siguiente:

variaciones

4.000000 
0.000000 
0.000000 
0.000000 
0.000000 
0.000000 
0.000000 
0.000000 
0.000000 

También he tratado de la siguiente, pensando que tal vez era algo poco firme con llamadas a funciones anidadas, pero fue en vano:

/* Pointer to the first location of the mxArray */ 
mxArray *fieldValuePtr = mxGetField(prhs[0], 0, "matrix"); 

/* Get the double pointer to the first location in the matrix */ 
double *ptr = mxGetPr(fieldValuePtr); 

/* Same for loop code here as written above */ 

¿Alguien tiene una identificación? ¿Cómo puedo lograr lo que intento o lo que potencialmente estoy haciendo mal?

Gracias!

Editar: Según el comentario de yuk, traté de hacer operaciones similares en una estructura que tiene un campo llamado matriz que es una matriz unidimensional de dobles.

La estructura que contiene la matriz se define como sigue:

arrayStruct = struct('array', {4.44, 5.55, 6.66}) 

Probé el siguiente en la arrayStruct desde dentro de la función Mex:

mptr = mxGetPr(mxGetField(prhs[0], 0, "array")); 

printf("%f\n", *(mptr)); 
printf("%f\n", *(mptr + 1)); 
printf("%f\n", *(mptr + 2)); 

... pero la salida siguió lo que era impreso anteriormente:

4.440000 
0.000000 
0.000000 

Answer 1

Está tratando de acceder a la variable que es la matriz de celdas en MATLAB. ¿Estás seguro de que los datos se almacenan en consecuencia? ¿Qué pasa si pones doble matriz en la estructura?

matrixStruct = struct('matrix', [4, 4, 4; 5, 5, 5; 6, 6 ,6]) 

---

creo que el problema es cómo almacena los datos de MATLAB en la matriz celular. Trate de ejecutar este:

double1 = 1; 
double2 = 1:2; 
cellempty = {[]}; 
celldouble1 = {1}; 
celldouble2 = {1:2}; 
cell2doubles = {1,2}; 
whos 

La salida:

Name    Size   Bytes Class  Attributes 
    cell2doubles  1x2    136 cell     
    celldouble1  1x1    68 cell     
    celldouble2  1x1    76 cell     
    cellempty   1x1    60 cell     
    double1   1x1     8 double    
    double2   1x2    16 double    

se puede ver que cada elemento de la matriz celular ocupan 60 bytes adicionales en el tamaño de los números.

Answer 2

struct('field', {a b c}) es una forma especial del constructor struct que crea una struct array que es del mismo tamaño que la serie de células, poniendo cada elemento de la célula en 'campo' campo del elemento correspondiente de la estructura.Es decir, esta:

s = struct('field', {a b c}); 

produce el mismo resultado que esto:

s(1).field = a; 
s(2).field = b; 
s(3).field = c; 

La solución a su problema es utilizar corchetes para formar una matriz (no celular) regular, como esto:

matrixStruct = struct('matrix', [4, 4, 4; 5, 5, 5; 6, 6 ,6]); 

Answer 3

He pasado por esto: Tengo una estructura con un campo que es una matriz. En C++, la estructura correspondiente es double**, por ejemplo. Se produce un error al intentar acceder al campo con engGetVariable(engine,MyStruct.theField). Yo uso una variable temporal para almacenar el MyStruct.theField y luego usar engGetVariable(engine, tempVar), y el código para obtener el campo de la matriz de la estructura parece que

// Fetch struct field using a temp variable 
std::string tempName = std::string(field_name) + "_temp"; 
std::string fetchField = tempName + " = " + std::string(struct_name) 
     + "." + std::string(field_name) + "; "; 
matlabExecute(ep, fetchField); 
mxArray *matlabArray = engGetVariable(ep, tempName.c_str()); 

// Get variable elements 
const int count = mxGetNumberOfElements(matlabArray); 
T *data = (T*) mxGetData(matlabArray); 
for (int i = 0; i < count; i++) 
    vector[i] = _isnan(data[i]) ? (T) (int) -9999 : (T) data[i]; 

// Clear temp variable 
std::string clearTempVar = "clear " + tempName + "; "; 
matlabExecute(ep, clearTempVar); 

// Destroy mx object 
mxDestroyArray(matlabArray); 

muy similar para establecer el campo de la matriz a la estructura lo hice que

// Create temp variable 
mxArray* array = convertVectorToMxArray(mat, nb_rows, nb_cols); 
const std::string temp_name = array_name + "_temp"; 
int ret = engPutVariable(ep, temp_name.c_str(), array); 

// Set variable to struct field 
const std::string cmd = std::string(array_name + " = " + temp_name + "; "); 
matlabExecute(ep, cmd); 

// Delete array 
mxDestroyArray(array);