MATLAB: How Matlab coder convert the image to unsinged char

ccodecdigital image processingimage processingImage Processing ToolboxMATLABmatlab coder

good day

I am working with matlab Coder which convert a image function to c++ code. the function looks something like this array=findsomething(I); where I is an image has been read with the function Imread. the result code in c++ code which has emxArray_uint8_T which looks like this struct emxArray_uint8_T { unsigned char *data; int *size; int allocatedSize; int numDimensions; boolean_T canFreeData; }; the data from the image should be a stream in unsigned char *data,i can read an image from OpenCV but i need to convert the image type from Mat to unsighed char, i have already read http://www.mathworks.com/help/matlab/matlab_external/matlab-data.html#f22019 but i dont know which comes first red blue or green,and if red should i start with coloms or rows? can someone help

Best Answer

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.

Related Solutions

MATLAB: Unbounded Sized Variables Code Genaration

 I had a friend that figured it out.
 // Initialize Cov Matrix
 emxArray_real_T *Cov = emxCreate_real_T(cols, cols);
 // Initialize Lambda matrix
 emxArray_creal_T *Lambda = emxCreate_creal_T(cols, 1);
 // Initialize V matrix
 emxArray_creal_T *V = emxCreate_creal_T(cols, cols);
   int c = 0;
   // Copy values from input to Cov matrix
   for (int i = 0; i < cols; i++)
   {
    for (int j = 0; j < cols; j++)
    {
     Cov->data[c] = input[i][j];
     c++;
    }
   }
   // Call My_Eig function to retrieve Lambda and V matrices
   My_Eig(Cov, Lambda, V);
   // Copy values from Lambda and V to out_Lambda and out_V
   for (int i = 0; i < cols; i++)
   {
    out_Lambda[i,0] = Lambda->data[i].re;
    out_Lambda[i,1] = Lambda->data[i].im;
   }
   for (int i = 0; i < (cols * cols); i++)
   {
    out_V[i, 0] = V->data[i].re;
    out_V[i, 1] = V->data[i].im;
   }
 // Before quit the function, release allocated memory
 emxDestroyArray_real_T(Cov);
 emxDestroyArray_creal_T(Lambda);
 emxDestroyArray_creal_T(V);
 My_Eig_terminate();
   return;
}

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

Best Answer

Related Solutions

MATLAB: Unbounded Sized Variables Code Genaration

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

Related Question