BMP图片格式解析并显示示例程序

格式原理参考

http://blog.csdn.net/o_sun_o/article/details/8351037

http://blog.csdn.net/lanbing510/article/details/8176231

https://en.wikipedia.org/wiki/BMP_file_format

关于解析以上几个网站，尤其wiki写的很好，我就不赘述了。

几点说明

1.BMP格式众多，在这里我只实现了无压缩格式的BMP解析，因为有压缩的很少用，并且解析只是多几个位运算而已。

2.在这里的解析适用于windows3以后的BMP（估计现在一般没人用windows3之前的了吧），因为这里的调色板被我固定了大小，并且因为不解析压缩的，所以也没有做成调色板与识别压缩像素的RGB掩模共存。

3.关于解析后的存储，biBitCount = 1,4,8。解析后在bitMap中每一个像素占1B，biBitCount=16/24/32，分别占2/3/4B 

4.调色板中每一元素为BGRA(4B),24位图在bitMap中每一元素为BGR值，32位图在bitMap中每一元素为BGRA值。

5.在bitMap中像素存放是从图像左下角开始的，但在getPixelAt(row,col)中我自动作了换算，所以这里的row、col是针对左上角的。

6.测试时用的图片格式有二值bmp,4B bmp,8B bmp,24B bmp,32B bmp。

7.16位图的像素BGR大小是5B+5B+5B，最高位去除。

8.原来这里的bmp像素区对其超级简单，就是一行实际有多少B，我们读时一次读一行，取每行前面的有效数据即可。

9.解析后的数据显示我用了Opencv( 所以我写的解析部分相当于一个残缺版的imread() :-D )。

PS：优化少以及以上问题主要是因为懒，趁着我的研友出去比赛，不想学习，来完成这个之前的烂尾作，做完舒了一口气，笑。

代码

Image_BMP_Class.h

#ifndef _IMAGE_BMP_H_
#define _IMAGE_BMP_H_
#include<iostream>
#include <string>
using namespace std;


typedef unsigned char BYTE;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;

// 24位为主RGB
typedef struct
{
	int biSize;//说明信息头结构所需要的字节数
	int biWidth;//图象的宽度，以象素为单位
	int biHeight;//图象的高度，以象素为单位 
	int biPlanes;//bmp图片的平面属，显然显示器只有一个平面，所以恒等于1
	short biBitCount;//说明比特数/象素，其值为1、4、8、16、24、或32。
	int biCompression;//说明图象数据压缩的类型
	int biSizeImage;//说明图象的大小，以字节为单位
	int biXPelsPerMeter;//水平分辨率
	int biYPelsPerMeter;//水平分辨率
	int biClrUsed;//位图实际使用的彩色表中的颜色索引数
	int biClrImportant;//对图象显示有重要影响的颜色索引的数目
} BitMapInfoHeader; 


class Palette{
	BYTE * ptr;
	uint len;
	//默认四字节 ,所以只适于Windows3.0以上的BMP
public:
	
	Palette() {
		ptr = NULL;
		len = 0;
	}
	~Palette() {
		if(this->ptr!=NULL)
			delete [] ptr;
		ptr = NULL;
	}
	void alloc_mem(uint n) {
		len = n;
		if(len>0)
			ptr = new BYTE[n*4];
	}
	BYTE* getPtr() {
		return ptr;
	}
	BYTE* getPtrAt(uint n) {
		return ptr + n*4;
	}
	void read(BYTE* start_ptr) {
		for(uint i=0;i< len*4;i++){
			ptr[i] = start_ptr[i];
		}
	}
	void show() {
		for(int i=0;i<len;i++) {
			std::cout<<i<<'\t';
			for(int j=0;j<4;j++)
				std::cout<<int(*(ptr+i*4+j))<<' ';
			std::cout<<std::endl;
		}	
	}
};

class BMPData {
public:
	ushort biBitCount;
	BYTE *ptr;
	uint rows, cols;
	ulong size;
	//其中坐标以图片左下角开始 
public:
	BMPData() {
		biBitCount = 0;
		ptr = NULL;
		rows = cols = 0;
		size = 0;
	};
	~BMPData() {
		if (ptr) delete[] ptr;
	}
	void set_type(ushort biBitCount, uint rows, uint cols) {
		this->biBitCount = biBitCount;
		uint p = 1;
		//计算该数据在内存理论多少字节 
		if (biBitCount>8) {
			//16,24,32
			p = biBitCount / 8;
		}
		size = rows*cols*p;
		ptr = new BYTE[size];

	}

	void read(BYTE *start_ptr) {
		
	}
	BYTE* Ptr() {
		return ptr;
	}
	BYTE* at(int i, int j) {
		return ptr + i*rows + j;
	}
};


class Image_bmp
{
	
private:
	string name;
	string date;
	short bfReserved1, bfReserved2;
	unsigned int bfOffBits;//文件头开始到实际的图象数据之间的字节
	Palette * palette;
	uint size_palette;
	BYTE * bitMap;
	
	
public:	
	string bfType;
	int bfSize;		//位图大小，B
	BitMapInfoHeader BMIHeader;
	
public:
	Image_bmp();
	Image_bmp(const char* name);
	bool open(const char* name);
	//void save(const char* name);
	void getPixelAt(int row, int col, BYTE val[]);
	void showHead();
	void showPalette();
	void show();
	~Image_bmp();
private:
	bool readHead(BYTE *start_ptr, uint offset);
	bool readData(BYTE *start_ptr,uint offset);
};


#endif 
//_IMAGE_BMP_H_

Image_BMP.cpp

#include<iostream>
#include<fstream>
#include<cmath>
#include <string>
#include"Image_BMP_Class.h"
#include<opencv2\opencv.hpp>
#include <assert.h>
using namespace std;

int ToInt(BYTE x,BYTE &it1,BYTE &it2)
{
	//一字节转换为int 
	int b;
	it1 = it2 = 0;
	it1 =(0xF & x);
	it2 = (0xF0 & x) >> 4;
	return int(x);
}
void ToInt(BYTE x,int it1[])
{
	int b;
	//for(int i =0;i<8;++i) it1[i] = 0;
	for(int i=0;i<8;++i)
	{
		b= x&1;
		if(b!=0)
			it1[i] = 1;
		else
			it1[i] = 0;
		x=x>>1;
	}
}

int ToInt2(BYTE item[])
{
	//两字节转换为int 
	BYTE x1,x2,x3,x4;
	ToInt(item[0],x1,x2);
	ToInt(item[1],x3,x4);
	return x1+x2*16+x3*16*16+x4*pow(16,3);
}

int ToInt4(BYTE item[])
{
	//四字节组成一个int 
	BYTE x1,x2,x3,x4,x5,x6,x7,x8;
	ToInt(item[0],x1,x2);
	ToInt(item[1],x3,x4);
	ToInt(item[2],x5,x6);
	ToInt(item[3],x7,x8);
	return  x1+x2*16+x3*16*16+x4*pow(16,3)+
			x5*pow(16,4)+x6*pow(16,5)+
			x7*pow(16,6)+x8*pow(16,7);
}

Image_bmp::Image_bmp()
{
	name = date =bfType ="";
	bfReserved1=bfReserved2=bfSize=0;
	bfOffBits=0;
	bitMap=NULL;
	palette=NULL;
	BMIHeader.biSize=BMIHeader.biWidth=
	BMIHeader.biHeight=BMIHeader.biPlanes=
	BMIHeader.biBitCount=BMIHeader.biCompression=
	BMIHeader.biSizeImage=BMIHeader.biXPelsPerMeter=
	BMIHeader.biYPelsPerMeter=BMIHeader.biClrUsed=
	BMIHeader.biClrImportant=0;
} 

Image_bmp::Image_bmp(const char *filename)
{
	name = date =bfType ="";
	bfReserved1=bfReserved2=bfSize=0;
	bfOffBits=0;
	bitMap=NULL;
	palette=NULL; 
	BMIHeader.biSize=BMIHeader.biWidth=
	BMIHeader.biHeight=BMIHeader.biPlanes=
	BMIHeader.biBitCount=BMIHeader.biCompression=
	BMIHeader.biSizeImage=BMIHeader.biXPelsPerMeter=
	BMIHeader.biYPelsPerMeter=BMIHeader.biClrUsed=
	BMIHeader.biClrImportant=0;
	
	
	if (!open(filename)) {
		cout << "read fail!" << endl;
	}
	
}

Image_bmp::~Image_bmp()
{
	if(palette)
		delete palette;
	if(bitMap)
		delete[] bitMap;
}

bool Image_bmp::readHead(BYTE *start_ptr,uint offset =6)
{
	
	
	//已过头部6B 
	
	//保留段
	//in>>item[0]>>item[1]>>item[2]>>item[3];
	bfReserved1= ToInt2(start_ptr+offset);
	offset+=2;
	bfReserved2= ToInt2(start_ptr+offset);
	offset+=2;
	
	//有效数据偏移量 
	bfOffBits = *((int*)(start_ptr+offset)); 
	offset+=4;
	/*位图信息头*/ 
	//位图信息头大小  
	BMIHeader.biSize= *((int*)(start_ptr+offset)); 
	offset+=4;
	//图宽 
	BMIHeader.biWidth = *((int*)(start_ptr+offset)); 
	offset+=4;
	//图高 
	BMIHeader.biHeight = *((int*)(start_ptr+offset)); 
	offset+=4;
	//const 颜色平面数 == 1 
	BMIHeader.biPlanes = ToInt2(start_ptr+offset);
	offset+=2;
	//比特率/像素
	BMIHeader.biBitCount = ToInt2(start_ptr+offset);
	offset+=2;
	//压缩类型 
	BMIHeader.biCompression =  *((int*)(start_ptr+offset)); 
	offset+=4;
	//图像大小
	BMIHeader.biSizeImage =  *((int*)(start_ptr+offset)); 
	offset+=4;
	//水平分辨率
	BMIHeader.biXPelsPerMeter =  *((int*)(start_ptr+offset)); 
	offset+=4;
	//垂直分辨率
	BMIHeader.biYPelsPerMeter =  *((int*)(start_ptr+offset)); 
	offset+=4;
	//用到的颜色索引数，0表示全用 
	BMIHeader.biClrUsed = *((int*)(start_ptr+offset)); 
	offset+=4;
	//重要颜色的索引的数目 
	BMIHeader.biClrImportant =  *((int*)(start_ptr+offset)); 
	offset+=4;
	
	palette = new Palette();
	if(BMIHeader.biBitCount == 1) 
		size_palette = 2;
	else if(BMIHeader.biBitCount == 4) 
		size_palette = 16;
	else if(BMIHeader.biBitCount == 8) 
		size_palette = 256;
	else if((BMIHeader.biBitCount==16|| BMIHeader.biBitCount==32)
			&&BMIHeader.biCompression==3)
		size_palette = 1;
	else if(BMIHeader.biCompression==0)
		size_palette = 1;
		
	palette->alloc_mem(size_palette);
	palette->read(start_ptr+offset);
	offset+=size_palette*4;
	//cout<<"offset"<<offset<<endl;
	//cout<<bfOffBits<<endl;
	//palette->show();
	return true;
}

bool Image_bmp::readData(BYTE *start_ptr, uint offset ) {

	start_ptr += offset;
	//分配内存
	uint size = BMIHeader.biHeight*BMIHeader.biWidth;
	if (BMIHeader.biBitCount == 16)
		size <<=1;//*2
	else if (BMIHeader.biBitCount == 24)
		size *=3;
	else if (BMIHeader.biBitCount == 32)
		size <<=2;//*4
	bitMap = new BYTE[size];


	//一个像素一位 
	//扫描行实际长度（包含填充）
	ulong rows_len = ((BMIHeader.biWidth*BMIHeader.biBitCount + 31) >>5)<<2;
	//1-8位，我们这里默认使用一BYTE表示每个像素点
	if (BMIHeader.biBitCount == 1) {	//Done
		int val[8];
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			uint cnt = 0;
			for (uint j = 0; j<BMIHeader.biWidth; j+=8,cnt++) { 
				ToInt(*(row_ptr + cnt), val);
				for (int k = 0; k < 8 && j + k < BMIHeader.biWidth; k++)
					bitMap[i*BMIHeader.biWidth + j + k] = val[7-k];
			}
		}
	}
	else if (BMIHeader.biBitCount == 4) {	//Done
		BYTE val[2];
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			uint cnt = 0;
			for (uint j = 0; j<BMIHeader.biWidth; j += 2, cnt++) {
				ToInt(*(row_ptr + cnt), val[0],val[1]);
				bitMap[i*BMIHeader.biWidth + j] = val[1];
				if(j+1<BMIHeader.biWidth)
					bitMap[i*BMIHeader.biWidth + j + 1] = val[0];
			}
		}
	}
	else if (BMIHeader.biBitCount == 8) {	//Done
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			for (uint j = 0; j<BMIHeader.biWidth; j++) {
				bitMap[i*BMIHeader.biWidth + j] = row_ptr[j];
			}
		}
	}
	else if (BMIHeader.biBitCount == 16) {	//Done
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			for (uint j = 0; j<BMIHeader.biWidth*2; j++) {
				bitMap[i*BMIHeader.biWidth*2 + j] = row_ptr[j];
			}
		}
	}
	else if (BMIHeader.biBitCount == 24) { //Done
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			for (uint j = 0; j<BMIHeader.biWidth * 3; j++) {
				bitMap[i*BMIHeader.biWidth*3 + j] = row_ptr[j];
			}
		}
	}
	else if (BMIHeader.biBitCount == 32) {	//Done
		for (uint i = 0; i<BMIHeader.biHeight; i++) {
			BYTE *row_ptr = start_ptr + i*(rows_len);
			for (uint j = 0; j<BMIHeader.biWidth * 4; j++) {
				bitMap[i*BMIHeader.biWidth*4 + j] = row_ptr[j];
			}
		}
	}
	return true;
}

void Image_bmp::showHead()
{
	
	cout << "name " << name << endl;
	cout << "bfOffBits " << bfOffBits << endl;
	cout << "BMIHeader.biSize " << BMIHeader.biSize << endl;
	cout << "BMIHeader.biWidth " << BMIHeader.biWidth << endl;
	cout << "BMIHeader.biHeight " << BMIHeader.biHeight << endl;
	cout << "BMIHeader.biPlanes " << BMIHeader.biPlanes << endl;
	cout << "BMIHeader.biBitCount " << BMIHeader.biBitCount << endl;
	cout << "BMIHeader.biCompression " << BMIHeader.biCompression << endl;
	cout << "BMIHeader.biSizeImage " << BMIHeader.biSizeImage << endl;
	cout << "BMIHeader.biXPelsPerMeter " << BMIHeader.biXPelsPerMeter << endl;
	cout << "BMIHeader.biYPelsPerMeter " << BMIHeader.biYPelsPerMeter << endl;
	cout << "BMIHeader.biClrUsed " << BMIHeader.biClrUsed << endl;
	cout << "BMIHeader.biClrImportant " << BMIHeader.biClrImportant << endl;
	cout << "Disp of Bmp's header" << endl;
} 
void Image_bmp::showPalette() {
	if(palette)
		palette->show();
}

void Image_bmp::getPixelAt(int row, int col, BYTE val[]) {
	//返回（row,col）处的存放于val中的B-G-R-A值
	
	row = BMIHeader.biHeight - row-1;				//存储的信息从图片左下角开始，这里转换相对于左上角
	if (BMIHeader.biBitCount == 32) {
		if (BMIHeader.biCompression == 0) {			//32位无压缩
			uint n = (row*BMIHeader.biWidth + col) * 4;
			for(int k=0;k<4;k++)
				val[k] = bitMap[n+k];
		}
		else {										//32位压缩（带掩模）

		}
	}
	else if (BMIHeader.biBitCount == 24) {		
		uint n = (row*BMIHeader.biWidth + col) * 3;
		for (int k = 0; k<3; k++)
			val[k] = bitMap[n + k];
	}
	else if (BMIHeader.biBitCount == 16) {
		if (BMIHeader.biCompression == 0) {			//16位无压缩B5+G5+R5
			uint n = (row*BMIHeader.biWidth + col) * 2;
			val[0] = (0x7C & bitMap[n]) >> 2;		//01111100
			val[1] &= 0x00;
			val[1] |= ((0x3 & bitMap[n]) << 3);		//0000 0011
			val[1] |= ((0xE0 & bitMap[n + 1]) >> 5);//1110 0000
			val[2] |= (0x1F & bitMap[n + 1]);		//0001 1111
		}
		else {										//16位压缩（带掩模）

		}
	}
	else if (BMIHeader.biBitCount <= 8) {			// 1 4 8 位，必用调色板
		uint n = (row*BMIHeader.biWidth + col);
		BYTE * ptr = this->palette->getPtrAt(int(bitMap[n]));
		for (int i = 0; i < 4; i++)
			val[i] = ptr[i];
	}
}

void Image_bmp::show() {
	if (!bitMap) return;
	using namespace cv;
	Mat mat(BMIHeader.biHeight, BMIHeader.biWidth, CV_8UC3); //BGRA
	BYTE val[4];
	//cout << "mat.rows" << mat.rows << endl;
	{
		for (int i = 0; i < mat.rows; ++i) {
			for (int j = 0; j < mat.cols; j++) {
				cv::Vec3b &rgba = mat.at<cv::Vec3b>(i, j);
				getPixelAt(i, j, val);
				for(int k=0;k<3;k++)
					rgba[k] = val[k];
			}
		}
	}

	
	imshow("2333333333 494D4C",mat);
	//waitKey(0);
}
bool Image_bmp::open(const char* file_name) {
	char item[4];
	ifstream fcin(file_name, ios::in | ios::binary);
	if (fcin.fail()) {
		return false;
	}
	fcin.seekg(0, ios::beg);
	//读入文件格式 
	fcin >> item[0] >> item[1];
	if (item[0] != 'B' || item[1] != 'M') {
		fcin.close();
		return false;
	}
	this->name = string(file_name);
	bfType = "BM";
	fcin.read(item, 4);
	//读入位图大小
	bfSize = ToInt4((BYTE*)item);
	//cout << "bfSize " << bfSize << endl;

	//加载所有数据
	BYTE *start_ptr = new BYTE[bfSize + 1];
	if (!start_ptr) {
		cout << "bad malloc" << endl;
		return false;
	}
	fcin.seekg(0, ios::beg);
	fcin.read((char*)start_ptr, bfSize);
	fcin.close();
	
	readHead(start_ptr, 6);
	readData(start_ptr, bfOffBits);
	if(start_ptr)
		delete[] start_ptr;
	return true;
}

main.cpp

#include <iostream>
#include <opencv2\opencv.hpp>
#include"Image_BMP_Class.h"

int main(int argc, char** argv) {
	
	char *file_name = NULL;
	if (argc == 2)
		file_name = argv[1];
	else
		return 0;
	Image_bmp pic(file_name);
	pic.showHead();
	pic.show();
	cout << "Creat by YWF CSDN_Blog:http://blog.csdn.net/hffhjh111?viewmode=contents" << endl;
	//Image_bmp pic("8.bmp");
	//pic.showHead();
	//p.showPalette();
	//pic.show();
	cv::waitKey(0);
	return 0;
}