MATLAB: Embedded coder: How to specify array function input parameter as constant (read only)

constEmbedded Codermatlab coderparameter

A certain MatLab function has an array as an input parameter. The function only reads from that array, it never changes its size or writes to it.

When this function is put through the embedded coder, I get:

extern void stepMeasProcessScan(const emxArray_uint8_T *img, ……

which is good: MatLab recognised that my code never changes the input parameter "img".

But: emxArray_uint8_T is generated as follows:

typedef struct emxArray_uint8_T {

    uint8_T *data;
    int32_T *size;
    int32_T allocatedSize;
    int32_T numDimensions;
    boolean_T canFreeData;
} emxArray_uint8_T;

So the generated code cannot change any of the members of this struct, because of the "const". But the generated code could change the data pointed to by the "data" and "size" members, because they lack a "const" in their definition.

As a result, copying a "const uint8_T *" into "data" results in a compiler error.

What I need, is something like:

typedef struct emxArray_const_uint8_T {

    const uint8_T *data;
    const int32_T *size;
    int32_T allocatedSize;
    int32_T numDimensions;
    boolean_T canFreeData;
} emxArray_uint8_T;

Can anybody tell me how to achieve this ?

Best Answer

This is an oversight in the design. I've created a bug report.

In the mean time, you can work around the problem by using a const cast. Just cast your pointer so that it is not const any more. This is ugly but will allow you to make forward progress.

HTH,

Fred

Related Solutions

MATLAB: Question about using C library created by codegen in C program

Hi Jeff,

I added the product MATLAB Coder to your question since this makes searching easier.

The following is a duplication of my answer at StackOverflow:

http://stackoverflow.com/a/24271438/3297440

If you look in the directory where you generated code you should find a file named functionName_emxAPI.h. This file declares some utility functions which make constructing and destroying emxArray values simpler. Using them to create emxArray values ensures that all of the fields are properly initialized and insulates your code from any possible changes to the emxArray type.

In an example I made which takes an array of uint32 values and also returns such an array I see the following functions:

extern emxArray_uint32_T *emxCreateWrapperND_uint32_T(unsigned int *data,
                                                      int numDimensions,
                                                      int *size);
extern emxArray_uint32_T *emxCreateWrapper_uint32_T(unsigned int *data, int rows,
                                                    int cols);
extern emxArray_uint32_T *emxCreateND_uint32_T(int numDimensions, int *size);
extern emxArray_uint32_T *emxCreate_uint32_T(int rows, int cols);
extern void emxDestroyArray_uint32_T(emxArray_uint32_T *emxArray);

The first four functions can be used to create emxArray values in different situations.

The first pair, i.e. emxCreateWrapper_uint32_T, emxCreateWrapperND_uint32_T, can be used to create a uint32 emxArray with the specified number of dimensions and sizes from existing data. So if you already have the input data allocated in some memory, these functions wrap that data up into an emxArray of the specified size without allocating any extra memory.

/* Create a 10-by-10 C array of uint32 values and wrap an emxArray around it */
uint32_T x[100];
emxArray *pEmx = NULL;
int k = 0;
for (k = 0; k < 100; k++) {
    x[k] = (uint32_T) k;
}
pEmx = emxCreateWrapper_uint32_T(x, 10, 10);
/* Use pEmx here*/
/* Deallocate any memory allocated in pEmx. */
/* This DOES NOT free pEmx->data because the "wrapper" function was used */
emxDestroyArray_uint32_T(pEmx);

The second pair, i.e. emxCreate_uint32_T, emxCreateND_uint32_T, also create emxArray values. However, they also heap allocate storage for the data field of the emxArray. This memory will be large enough to hold the number of elements specified in their respective size arguments After calling these, you will need to populate the data stored in the data field of the returned emxArray struct:

/* Allocate a 10-by-10 uint32 emxArray and fill the values */
int k = 0;
emxArray *pEmx = emxCreate_uint32_T(10, 10);
for (k = 0; k < 100; ++k) {
    pEmx->data[k] = (uint32_T) k;
}
/* Use pEmx here*/
/* Deallocate any memory allocated in pEmx. */
/* This DOES free pEmx->data */
emxDestroyArray_uint32_T(pEmx);

The last, emxDestroyArray_uint32_T, will be used to destroy the array and deallocate any memory allocated by the previous methods.

Finally, to capture your output, you could use emxCreate_struct_T or emxCreateND_struct_T to create an empty emxArray of struct_T values with the proper number of dimensions by passing 0 for one or more sizes where appropriate. The generated code will allocate enough memory to hold the resulting data in your output emxArray at runtime. You can then check the size field of this output emxArray to view the sizes of the dimensions of the data field and extract the data as you wish.

The documentation for using emxArray arguments is available here:

http://www.mathworks.com/help/fixedpoint/ug/c-code-interface-for-unbounded-arrays-and-structure-fields.html#bsp2zlh

MATLAB: How Matlab coder convert the image to unsinged char

so i found out how to fill this emxArray_uint8_T with unsinged char, in c++ there is the code

    emxArray_uint8_T *I; 
    emxInit_uint8_T(&I, 3);
    string imageName("F:/********amr.jpg");   
    Mat image;
    image = imread(imageName.c_str(), IMREAD_COLOR); // Read the file
      Vec3b intensity;
      int sizeimage, counter;
      int rows = image.rows;
      int cols = image.cols;
      sizeimage = rows*cols;
      I->size[0] = rows;
      I->size[1] = cols;
      I->size[2] = 3;
    emxEnsureCapacity((emxArray__common *)I, 0, (int)sizeof(unsigned char));
          counter = 0;
 for (int i = 0;i < cols;i++)
    {
      for (int j = 0;j < rows;j++)
      {
        intensity = image.at<Vec3b>(j, i);
        uchar blue = intensity.val[0];
        uchar green = intensity.val[1];
        uchar red = intensity.val[2];
        I->data[counter] = red;
        I->data[counter + sizeimage] = green;
        I->data[counter + 2* sizeimage] = blue;
        counter++;
      }
    }

now the data is transfered from the image into the emxArray_uint8_T which u can use in your c++ code i had the same results of my function in Matlab and my c++ program.

Best Answer

Related Solutions

MATLAB: Question about using C library created by codegen in C program

MATLAB: How Matlab coder convert the image to unsinged char

Related Question