Thread: Reading a bitmap image

Sure, understand the bitmap format and write your code accordingly. Check the http://www.wotsit.org website for formats of many files structures. This way you don't have to rely one someone else's code, you'll have the understanding to "go it alone"

Read the bitmap header, then read the data which is an array of RGB values (assuming 24bit bitmaps). DON'T read it all in one step since:
a) Structure sizes are usually multiples of 4, which 54 isn't.
b) The way variables are stored may or may not match (little big endian).

Code:

const int BmpHeaderSize = 54;
struct BmpHeader
{
	char ID[2];
	long FileSize;
	long RESERVED;
	long BitmapDataOffset;
	long BitmapHeaderSize;
	long Width;
	long Height;
	short NrOfPlanes;
	short BitsPerPixel;
	long Compression;
	long BitmapDataSize;
	long HorizontalResolution;
	long VerticalResolution;
	long Colors;
	long ImportantColors;
};

see the code bove..

i just write this code for a reserch work...
this code work (i hope) =) !

Code:

typedef struct
	{
		unsigned char RGB[3];
	}RGB;

typedef struct
	{
		unsigned int size;
		int width,height;
		unsigned short int planes;
		unsigned short int bpp;
		unsigned int compression;
		unsigned int imagesize;
		int xresolution,yresolution;
		unsigned int colours;
		unsigned int impcolours;
	}INFOHEADER;

// ********** Create Matrix **********
RGB** createMatrix(){
	RGB** Matrix;
	int i;
	Matrix = (RGB **) malloc (sizeof (RGB*) * height);
	if (Matrix == NULL){
		perror("***** No memory available *****");
		exit(0);
	}
	for (i=0;i<height;i++){
		Matrix[i] = (RGB *) malloc (sizeof(RGB) * width);
		if (Matrix[i] == NULL){
		perror("***** No memory available *****");
			exit(0);
		}
	}
	return(Matrix);
}

// ********** Verify if the file is BMP *********
void isBMP(FILE* arq, HEADER head, INFOHEADER info){
	char type[3];
	unsigned short int bpp;
	fseek(arq,0,0);
	fread(type,1,2,arq);
	type[2] = '\0';

	fseek(arq,28,0);
	fread(&bpp,1,2,arq);

	if (strcmp(type,"BM") || (bpp != 24)){
		printf("\nThe file is not BMP format or is not 24 bits\n");
	        exit(0);
	}
}

// ********** Read BMP info from file **********
INFOHEADER readInfo(FILE* arq){
	INFOHEADER info;

	// Image Width in pixels
	fseek(arq,18,0);
	fread(&info.width,1,4,arq);

	// Image Height in pixels
	fseek(arq,22,0);
	fread(&info.height,1,4,arq);

	// Color depth, BPP (bits per pixel)
	fseek(arq,28,0);
	fread(&info.bpp,1,2,arq);

	// Compression type
	// 0 = Normmally
	// 1 = 8 bits per pixel
	// 2 = 4 bits per pixel
	fseek(arq,30,0);
	fread(&info.compression,1,4,arq);

	// Image size in bytes
	fseek(arq,34,0);
	fread(&info.imagesize,1,4,arq);

	// Number of color used (NCL)
	// value = 0 for full color set
	fseek(arq,46,0);
	fread(&info.colours,1,4,arq);

	// Number of important color (NIC)
	// value = 0 means all collors important
	fseek(arq,50,0);
	fread(&info.impcolours,1,4,arq);

	return(info);
}

RGB** loadImage(FILE* arq, RGB** Matrix){
	int i,j;
	RGB tmp;
	long pos = 51;

	fseek(arq,0,0);

	for (i=0; i<height; i++){
		for (j=0; j<width; j++){
			pos+= 3;
			fseek(arq,pos,0);
			fread(&tmp,(sizeof(RGB)),1,arq);
			Matrix[i][j] = tmp;
		}
	}
	return(Matrix);
}


/* Global */
int height, widht;


/* in your main program you just call */
FILE* arq; /* the bitmap file 24 bits */
RGB** Matrix_aux, Matrix;
INFOHEADER info;
info = readInfo(FILE* arq);
height = info.height;
width = info.width;

Matrix_aux = createMatrix();
Matrix = loadImage(arq,Matrix_aux);

Sorry...
Nonsense is our Motif.

i think i got it...

Code:

typedef struct
	{
		char		type[2]; 	// file type
		unsigned int	size; 		// file size in bytes
		unsigned short int reserved1,reserved2;
		unsigned int	offset; 	// offset to image data
	}HEADER;

to load the image just call this function:
RGB** loadImage(FILE* arq, RGB** Matrix);

in main;

Code:

	HEADER head;
	isBMP(arq,head,info);

you acces the color value by this form:
int red, green, blue;

temp = Matrix[i][j].RGB;
red = (int)Matrix[i][j].RGB[0].
green = (int)Matrix[i][j].RGB[1].
blue = (int)Matrix[i][j].RGB[2].

i write again the code. is in attach.

gcc -o example example.c

open a bitmap 24 bits file to a matrix, and save again to out.bmp the same file.

hmmm, just reboot your machine. Or create a swap partition.

This is a fairly robust validation routine. One improvement might be to verify the bit offset by calculating together the height, width, and boundary padding (if any).

Code:

/*
  Validate, then read data into the supplied buffers.
  If successful, a pointer to the actual bits is returned. 
  Otherwise, the function returns NULL.  
*/
void * GetBitmapInfo(
 BITMAPFILEHEADER * bfhBuf, 
 BITMAPINFOHEADER * bihBuf, 
 const void * base, 
 unsigned length)
{
 void * bits = 0;
 
 char * ptr = (char*)base;
 
     if(length > sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER))
    {
     BITMAPFILEHEADER * bfh = (BITMAPFILEHEADER *)ptr;
 
     BITMAPINFOHEADER * bih = (BITMAPINFOHEADER *)(ptr + sizeof(BITMAPFILEHEADER)); 
  
         if(((char*)&(bfh->bfType))[0] == 'B' 
            &&
           ((char*)&(bfh->bfType))[1] == 'M'
            &&
           bfh->bfReserved1 == 0
            &&
           bfh->bfReserved2 == 0 
            &&
           bfh->bfSize == length
            &&
           bih->biSize == 40
            &&
             (bih->biBitCount == 1 
               ||
              bih->biBitCount == 4 
               ||
              bih->biBitCount == 8 
               ||
              bih->biBitCount == 24)
            &&
         /* this doesn't really validate anything, 
            but it does prevent access violations */   
           bfh->bfOffBits < length) 
        {
         bfhBuf->bfType = bfh->bfType;
         bfhBuf->bfSize = bfh->bfSize;
         bfhBuf->bfReserved1 = bfh->bfReserved1;
         bfhBuf->bfReserved2 = bfh->bfReserved2;
         bfhBuf->bfOffBits = bfh->bfOffBits;
         bihBuf->biSize = bih->biSize;
         bihBuf->biWidth = bih->biWidth;
         bihBuf->biHeight = bih->biHeight;
         bihBuf->biPlanes = bih->biPlanes;
         bihBuf->biBitCount = bih->biBitCount;
         bihBuf->biCompression = bih->biCompression;
         bihBuf->biSizeImage = bih->biSizeImage;
         bihBuf->biXPelsPerMeter = bih->biXPelsPerMeter;
         bihBuf->biYPelsPerMeter = bih->biYPelsPerMeter;
         bihBuf->biClrUsed = bih->biClrUsed;
         bihBuf->biClrImportant = bih->biClrImportant;
         bits = &ptr[bfh->bfOffBits];    
        }
    }   

 return bits;
}

That's an interesting approach! Is there any way to add these directories to the executable (in some resource form)?

Well you could do it by simply retrieving the size of the EXE, setting the file pointer to one BYTE past that and writing in the binary data from there. Your loader would then have to retrieve the size of the EXE and start loading from there.

Here are my structs:

Code:

typedef struct CMPHeader
{
   DWORD NumImages;
   WORD BitsPerPixel;
   WORD Compressed;
   BYTE DateOfFile[8];
   BYTE Author[20];
};

typedef struct NCHeader
{
  DWORD bmpwidth;
  DWORD bmpheight;
  DWORD chunksize;
  DWORD id;
};

I have a program that will take a text file as input and will output a .CMP file with all the relevant info in it. The text file simply lists the bmps that will be compiled into the cmp.

The CMPHeader is at the start of the file and each NCHeader precedes a chunk of raw bitmap data. My current format allows for different size bitmaps to be compiled in the same file, however, this might cause problems later, but the chunksize field will tell you how much data to read for the next chunk. After that another chunk will appear - there will be CMPHeader.NumImages chunks in the file.


Here is the structure of my cmp file:

---------------------------
CMPHeader
---------------------------
NCHeader -> new chunk header
---------------------------
Raw bitmap data -> RLE compressed if CMPHeader->compressed is 1
---------------------------
NCHeader
---------------------------
Raw bitmap data
---------------------------
...
...
...
...
----------------------------
Palette data in order RGB - 768 bytes - 4th element is stripped from palette data in the bmp files. Palette is taken from first image in the compilation process since all images share the same palette.
------------------EOF




Future revisions will allow a PAL file to be specified as the palette data but will still be placed in the last 768 bytes of the file.

I thought it was easier to place the palette at the end of the file rather than after the CMPHeader. This way the palette is always guaranteed to start at lengthoffile-768.

It's just something I cooked up so that I don't have a million bmps sitting out there on the drive just waiting for someone to alter.