C / C++ / MFC

10-Feb-09 20:08

Hi everyone,

I am novelty to Image Processing. Currently, I want to read the data of a monochrome BMP file into an 2D array using VC++ 2005. I read quite a number of articles about BMP file, but there's still a vague explanation concerning the monochrome one.

I know and understand on how to read its header and header information. However, when I read the data of it, the output is 205 for BLACK pixel which makes me very confusing. It should be 0 for Black pixel, right? In short, the followings are my questions:

1. How is data in monochrome BMP file stored?
2. Do I have to read it in RGB order or just one byte a time?
3. Do I have to manage the junk (useless) byte?

Thanks in advance.

Ing LengIeng
Software Developer

Code-o-mat10-Feb-09 21:49

Code-o-mat

10-Feb-09 21:49

I think a monochomre bitmap is stored as 1 bits per pixel, so 1 byte contains 8 pixels, where every 0 is BLACK and every 1 is WHITE (or whatever you schoose to be foreground and background colors). So if you read 205 -> 11001101 -> WHITE PIXEL, BLACK PIXEL, WHITE, WHITE, BLACK, BLACK, WHITE, WHITE. (don't forget, the leftmost bit is the most significant)

> The problem with computers is that they do what you tell them to do and not what you want them to do. <
> Life: great graphics, but the gameplay sux. <

Member 211673610-Feb-09 22:26

10-Feb-09 22:26

Thank you very much! Wink | ;)

Ing LengIeng
Software Developer

Code-o-mat10-Feb-09 23:00

Code-o-mat

10-Feb-09 23:00

You can use bitmasks to gain the pixels out of the bytes, so something like (just to explain and give you a starting point):

SetPixel(x    , y, (bmp_byte &   1)?foreColor:backColor);
SetPixel(x + 1, y, (bmp_byte &   2)?foreColor:backColor);
SetPixel(x + 2, y, (bmp_byte &   4)?foreColor:backColor);
SetPixel(x + 3, y, (bmp_byte &   8)?foreColor:backColor);
SetPixel(x + 4, y, (bmp_byte &  16)?foreColor:backColor);
SetPixel(x + 5, y, (bmp_byte &  32)?foreColor:backColor);
SetPixel(x + 6, y, (bmp_byte &  64)?foreColor:backColor);
SetPixel(x + 7, y, (bmp_byte & 128)?foreColor:backColor);

> The problem with computers is that they do what you tell them to do and not what you want them to do. <
> Life: great graphics, but the gameplay sux. <

Member 211673611-Feb-09 4:33

11-Feb-09 4:33

Thanks very much. I gain much understanding now. Smile | :)

Ing LengIeng
Software Developer

CPallini10-Feb-09 22:04

10-Feb-09 22:04

From BITMAPINFOHEADER documentation [^], about biBitCount member equal to 1:

The bitmap is monochrome, and the bmiColors member of BITMAPINFO contains two entries. Each bit in the bitmap array represents a pixel. If the bit is clear, the pixel is displayed with the color of the first entry in the bmiColors table; if the bit is set, the pixel has the color of the second entry in the table.

Thus one byte of the bitmap array having value 205 represents eight adjacent pixels colors: 11001101 (1-second color of the color table, for instance black, 0-first entry of the color table, for instance white).
Smile | :)

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[My articles]

Member 211673610-Feb-09 22:23

10-Feb-09 22:23

Oh! I see. Thank all of you very much for your useful reply.

One more thing! This might be a stupid question, but how can I convert from a Byte into those 8 bits? Confused | :confused:

Ing LengIeng
Software Developer

CPallini10-Feb-09 22:59

10-Feb-09 22:59

Member 2116736 wrote:
but how can I convert from a Byte into those 8 bits?

A byte is already that set of bits.
If you need to extract single bit info you may:

use the shift and AND operators:

unsigned int getbit(BYTE byte, int bit){ return ( (byte >> bit) & 0x01; ) }

It may be used as follows:

void main()
  BYTE byte = 205; 
  cout << (int) mb.byte << " decimal is ";
  int i=8;
  while (i--)
  {
    cout << getbit(byte, i);
  }
  cout << " binary " << endl;
}

use the 'union trick', i.e.

struct BitField
{
  unsigned int bit0 : 1;
  unsigned int bit1 : 1;
  unsigned int bit2 : 1;
  unsigned int bit3 : 1;
  unsigned int bit4 : 1;
  unsigned int bit5 : 1;
  unsigned int bit6 : 1;
  unsigned int bit7 : 1;
};
union MyByte
{
  BYTE byte;
  BitField bf;
};

That you may use this way:

bool main()
{
  MyByte mb;
  mb.byte = 205;
  cout << (int) mb.byte << " decimal is ";
  cout <<  mb.bf.bit7 <<  mb.bf.bit6 <<  mb.bf.bit5 <<  mb.bf.bit4 << mb.bf.bit3 << mb.bf.bit2 << mb.bf.bit1 << mb.bf.bit0;
  cout << " binary " << endl;
}

Member 211673611-Feb-09 4:35

11-Feb-09 4:35

Thanks very much, Pallini! Your code is very useful for me.

In case of trouble, I'll come back to you again.

Many thanks,

Ing LengIeng
Software Developer

CPallini11-Feb-09 7:51

11-Feb-09 7:51

You're welcome.
Smile | :)

Member 211673611-Feb-09 14:57

11-Feb-09 14:57

Hi again!

Now I still have problem concerning reading its content. Can you guide me on that? The following is my code:

BITMAPFILEHEADER bmpHeader;
BITMAPINFO bmpInfo;
FILE *fp = fopen("C:\\test.bmp","rb");
fread((char*)&bmpHeader,sizeof(BITMAPFILEHEADER),1,fp);
fread((char*)&bmpInfo,sizeof(BITMAPINFO),1,fp);

WORD bmpWidth = (WORD)bmpInfo.bmiHeader.biWidth;
WORD bmpHeight = (WORD)bmpInfo.bmiHeader.biHeight;

int counter=0;

fseek(fp,bmpHeader.bfOffBits,SEEK_SET);

BYTE *data = new BYTE[bmpWidth*bmpHeight];
// Read the pixels
while(!feof(fp))
{
  for(int i=0; i<bmpwidth;>  {
    if(!feof(fp))
    {
      fread((BYTE*)&data[counter], sizeof(BYTE), 1, fp);
      counter++;
    }
    else
    {
      break;
    }
  }
}
fclose(fp);

Here I got an error message saying that "Array index out of bound". What is the correct way of reading it? Confused | :confused:

Ing LengIeng
Software Developer

CPallini11-Feb-09 22:06

11-Feb-09 22:06

Here again you're doing a mistake on computing the memory required.
For a monochrome bitmap, the size required is bit more elaborate than
(Width * Height), since the file holds 8 pixels in each byte, and the horizontal line is padded (if I remember well) to have a 32-bit multiple length. Hence

int bytesPerLine = Width / 8; // eight pixels per byte
if (Width % 8) bytesPerLine++; // take into account the reminder

// pad the line to make it to a 32-bit multiple
if (bytesPerLine % 4 ) bytesPerLine += 4 - (bytesPerLine % 4);

// finally you get the size
int iSize = bytesPerLine * Height;

I hope the above is correct (I haven't tested it). You may verify it comparing the result with the actual size of the file minus the bfOffBits offset.

Two final notes:

If you allocate memory of a given size don't trust any other counter (you're using EOF) while filling it: check always you're not exceeding the allocated size (in your code try to read until the allocated buffer is filled and not until the end of the file: if the file contains more bytes your application crashes).
If you need to read a block, the read it directly, don't read a byte at time.

Member 211673611-Feb-09 22:13