CODEWITHSUNDEEP
c++iphoneimageimage-processing
Brett
Brett

Reputation: 12007

C++ - Convert uint8_t* image data to double** image data

I am working on a C++ function (inside my iOS app) where I have image data in the form uint8_t*.

I obtained the image data using the code using the CVPixelBufferGetBaseAddress() method of the iOS SDK:

uint8_t *bPixels = (uint8_t *)CVPixelBufferGetBaseAddress(imageBuffer);

I have another function (from a third part source) that does some of the image processing functions I would like to use on my image data, but the input for the image data for these functions is double**.

Does anyone have any idea how to go about converting this? What other information can I provide?

The constructor prototype for the class that use double** look like:

Image(double **iPixels, unsigned int iWidth, unsigned int iHeight);

Upvotes: 0

Views: 1665

Answers (2)

waTeim
waTeim

Reputation: 9225

I'm going to take a giant bunch of guesses here in hopes that this will lead you towards getting at the documentation and answering back. If there's no further documentation, well, here's a starting point.

Guess 1) The Image constructor requires a doubly dimensioned array where each component is an R,G,B,Alpha channel in that order. So iPixels[0] is the red data, iPixels[1] is the green data, etc.

Guess 2) Because it's not integer data, the values range from 0 to 1.

Guess 3) All of this must be pre-allocated.

Guess 4) Image data is row-major

Guess 5) Source data is BRGA

So with that in mind, starting with bPixels

double *redData = new double[width*height];
double *greenData = new double[width*height];
double *blueData = new double[width*height];
double *alphaData = new double[width*height];
double **iPixels = new double*[4];

iPixels[0] = redData;
iPixels[1] = greenData;
iPixels[2] = blueData;
iPixels[3] = alphaData;

for(int y = 0;y < height;y++)
{  
   for(int x = 0;x < width;x++)
   {
      int alpha = bPixels[(y*width + x)*4 + 3];
      int red = bPixels[(y*width +x)*4 + 2];
      int green = bPixels[(y*width + x)*4 + 1];
      int blue = bPixels[(y*width + x)*4];

      redData[y*width + x] = red/255.0;
      greenData[y*width + x] = green/255.0;
      blueData[y*width + x] = blue/255.0;
      alphaData[y*width + x] = alpha/255.0;
   }
 }

 Image newImage(iPixels,width,height);

some of the things that can go wrong.

Source is not BGRA but RGBA, which will make the colors all wrong. Not row major or destination is not in slices which will make things look all screwed up and/or seg-fault

Upvotes: 0

mb84
mb84

Reputation: 693

Your uint8_t *bPixels seems to hold image data as 1-dimensional continuous array of height*width lenght. So to access pixel in the x-th row and y-th column you have to write bPixels[x*width+y].

Image() seems to work on 2-dimensional arrays. To access pixel like above you would have to write iPixels[x][y].

So you need to copy your existing 1-dimensional array to a 2-dimensional:

double **mypixels = new double* [height];
for (int x=0; x<height; x++)
{
    mypixels[x] = new double [width];
    for (int y=0; y<width; y++)
        mypixels[x][y] = bPixels[x*width+y]; // attention here, maybe normalization is necessary
                                             // e.g. mypixels[x][y] = bPixels[x*width+y] / 255.0
}

Because your 1-dimensional array has pixel of type uint8_t and the 2-dimensional one pixel of type double, you must allocate new memory. Otherwise, if both would have same pixel type, the more elegant solution (a simple map) would be:

uint8_t **mypixels = new uint8_t* [height];
for (int x=0; x<height; x++)
    mypixels[x] = bPixels+x*width;

Attention: beside the problem of eventually necessary normalization, there is also a problem with the indices-compatibility! My examples assume that the 1-dimensional array is stored row-by-row and that the functions working on 2-dimensional index with [x][y] (that means first-row-then-column). The declaration of Image() however, could lead to the conclusion that it needs its arrays to be indexed with [y][x] maybe.

Upvotes: 1

Related Questions