Thread: Choice of data structure for storing an image

When I wrote my image class I used a single dimensional array with the r,g,b,r,g,b,r,g,b.. etc format. I then wrote a function that could access a single pixel and return it as a r, g, or b value, or all three. An example is below. My way is probably not the best, or most accepted, but is a suggestion.

Code:

// declaration
class Image;
#define IMAGE_RGB 1
#define IMAGE_R 2
#define IMAGE_G 3
#define IMAGE_B 4
unsigned char* Image::pixel(int x, int y, DWORD pixelType);

// usage

unsigned char rgb[3] = image.pixel(500, 100, IMAGE_RGB); // get all three components of the pixel at (500,100)
unsigned char r = *(image.pixel(500, 100, IMAGE_R)); // get just red component

// etc...

Would any of the algorithms you're using really benefit from a 2D subscript method?

A linear array can always be accessed in a single memory cycle. The array subscripting calculation is small enough that all the interesting values will be in registers.

But a 2D array starting with something like
pixel **data;
always has two memory accesses, one to resolve pixel[row] and then another to get the pixel itself.

Memory is slow by comparison on modern machines.

Ok, I had always been hesitant to use the 2D method... I figured that it would be a bit more readable/easier to understand. Also, I kind of figured that since malloc allocates contiguous memory blocks, splitting up the array would prevent any problems when the images became very large (for example, a raw 10,000x5,000 image is >200 mb).

But from this point forward, I will hide the details of the data structure with accessor functions so that if ever I decided to alter it again, I wont have to refactor all of my code.

Scwizzo,
Out of curiousity, why did you decided to use a single method with a parameter that alters the return value as opposed to separate methods? Also, is the memory footprint of an array containing 3 or 4 values considerably smaller than a struct containing 3 or 4 values?


Thanks a lot for the explanations and the example!

Running the following code gives the following output. Hope it answers your question.

Code:

#include <iostream> 
#include <conio.h>
using namespace std;

struct mystruct
{
    int someinteger[3];
};

int main()
{   
    printf("Size of structure with integer: %i\n", sizeof(mystruct));
    printf("Size of integer: %i\n", sizeof(int[3]));
    while(!_kbhit());
    return 0;	
}

Code:

Size of structure with integer: 12
Size of integer: 12

I chose a 1 dimensional array due to simplicity. I can allocate everything in one large chunk, versus having to run two loops to allocate the memory twice. Also, I would rather deal with pointers, and changing a single memory source than having to copy, delete, copy, move, delete, etc...