Extract RGB values from Bitmap Image

See more:

C++

Bitmap

read

RGB

Hello. I am currently trying to extract R, G, B values from a 256 colour bitmap image (using for testing purposes a fixed width of 152 and height 150). I have checked using BITMAPINFOHEADER and BITMAPFILEHEADER that the offset is 1078 and bytes per pixel is 1.

The image data is initially placed in a 2 dimensional array before being placed into a 1 dimensional array. Three 2 dimensional arrays were allocated to hold the R, G, B values from each pixel.

When I run the program, the following Debug Assertion Failed! message appears:
Expression: _BLOCK_TYPE_IS_VALID (pHead->nBlockUse)

Below is the code and I would value your expert feedback and how to fix this error.

unsigned char** Allocate2DArray(unsigned char** buffer, int w, int h)
{
    buffer = new unsigned char*[h];
    if(buffer == NULL) return 0; // return if memory not allocated
    // For each of these pointers, allocate memory of size ‘w’
    for(int j=0; j<h; j++)
    {   buffer[j] = new unsigned char[w];
        if(buffer[j] == NULL) return 0;// return if not allocated
    }
    return buffer;
}

void DeAllocate2DArray(unsigned char** buffer, int h)
{
    // After complete usage, delete the memory dynamically allocated
    for(int j=h-1; j>= 0; j--)
        delete[] buffer[j]; //delete rows
    delete[] buffer; //delete the pointer to pointer
}



using namespace std;

int main()
{
    ifstream image;
    image.open("image.bmp",std::ios_base::binary);

    if (image.is_open())
    {
        cout<< "function success\n";
    }
    else
    {
        cout<< "unable to open file";
    }


    const int width = 152;
    const int height = 150;

    unsigned char m_cHeaderData[1078];
    unsigned char** m_cImageData = new unsigned char* [height];

    for( int i = 0; i <height; i++)
    {
        m_cImageData[i] = new unsigned char [width];
    }

    ifstream* m_pInFile;
    m_pInFile = new ifstream;
    m_pInFile->open("image.bmp", ios::in | ios::binary);
    m_pInFile->seekg(0, ios::beg);
    m_pInFile->read(reinterpret_cast<char*>(m_cHeaderData), 1078); 
    //bitmap bits start at offset 1078

    for(int i = 0; i <height; i++)
    {
       m_pInFile->read(reinterpret_cast<char*>(m_cImageData[i]), width);
    }

    m_pInFile->close();


    // Declare a pointer of the type you want.
    // This will point to the 1D array
    unsigned char* array_1D;

    // Now allocate memory for array_1D
    array_1D = new unsigned char[height*width];
    if(array_1D == NULL) return 0;  // return if memory not allocated

    // Copy contents from the existing 2D array
    int offset = 0;

    for(int j=0; j<height; j++)  // traverse height (or rows)
    {
        offset = width * j;
        for(int i=0; i<width; i++) // traverse width
        {
            array_1D[offset + i] = m_cImageData[j][i]; // update value at current (i, j)
        }
    }

    // Declare three 2D arrays to store R,G, and B planes of image.
    unsigned char**arrayR_2D, **arrayG_2D, **arrayB_2D;
    arrayR_2D = Allocate2DArray(arrayR_2D, width, height);
    arrayG_2D = Allocate2DArray(arrayG_2D, width, height);
    arrayB_2D = Allocate2DArray(arrayB_2D, width, height);

    // return if memory not allocated
    if(arrayR_2D == NULL || arrayG_2D == NULL || arrayB_2D == NULL) return 0;

    // Extract R,G,B planes from the existing composite 1D array
    int offsetx = 0;
    int counter = 0;
    int bytesPerPixel = 1;

    for(int j=0; j<height; j++)  // traverse height (or rows)
    {
        offset = width * j;
        for(int i=0; i<width*bytesPerPixel; i+=bytesPerPixel) // width
        {
            arrayB_2D[j][counter++] = array_1D[offsetx + i+0];
            arrayG_2D[j][counter++] = array_1D[offsetx + i+1];
            arrayR_2D[j][counter++] = array_1D[offsetx + i+2];
        }
        counter = 0;
    }


    // After complete usage, delete the memory dynamically allocated
    DeAllocate2DArray(arrayR_2D, height);
    DeAllocate2DArray(arrayG_2D, height);
    DeAllocate2DArray(arrayB_2D, height);

    // After complete usage, delete the memory dynamically allocated
    delete[] array_1D; //delete the pointer to pointer

    //deallocate memory:
    delete m_pInFile;
    delete m_pOutFile;
    for(int i = 0; i <height; i++)
    {
        delete[] m_cImageData[i];
    }
    delete[] m_cImageData;


    system("pause");

    return 0;
}