[原创] 一个简单的windows位图文件类的实现

[原创] 一个简单的windows位图文件类的实现

（一）目的

在图像处理的过程中，我们必然要对位图文件进行像素级的操作。一种办法是使用windows位图操作api或者是MFC中的CBitmap类；另外的办法是调用第三方的图像类，如CxImage类。作者在使用上述这些方案时，发现了如下的问题，首先，他们的功能要么过强（提供了许多一般很少用的功能，例如封装了很多我们不想要的图像格式处理函数），要么过弱（很多常用功能没有提供，比如对像素级的操作接口）。为此，作者根据自己的使用需要，建立了一个针对windows 24位真彩色位图的处理函数。功能目前还不是很完善，但是已经能够满足作者的使用需要。主要功能有：位图的读写、位图的建立和保存、两幅位图的比较、位图中像素颜色的获取和设置、位图中指定区域的获取和设置等等。如果有需要的话，可以进行进一步的的扩充。

（二）位图处理概述

1 位图在windows中以位图文件格式存放（bmp文件）。

文件格式如下：

[ 位图文件头 + 位图信息头 + 颜色表（24位真彩色没有这项） + 位图数据 ]

2 位图文件头：位图文件头主要用于识别位图文件。

以下是位图文件头结构的定义和含义：

typedef struct tagBITMAPFILEHEADER

{

WORD bfType; //必须是“BM”（0x4d42），标志该文件是位图文件

DWORD bfSize; //位图文件的总的大小

WORD bfReserved1; //必须为0

WORD bfReserved2; //必须为0

DWORD bfOffBits; //到位图数据的偏移量（字节数）

} BITMAPFILEHEADER;

3 位图信息头 + 颜色表

以下结构体中定义了位图信息头和颜色表。

typedef struct tagBITMAPINFO {

BITMAPINFOHEADER bmiHeader;//信息头

RGBQUAD bmiColors[1];//颜色表

} BITMAPINFO;

本文中只讨论24位真彩色位图，因此上述结构体不予讨论，只关注信息头就可以了。

信息头定义如下：

typedef struct tagBITMAPINFOHEADER

{

DWORD biSize; //等于sizeof(BITMAPINFOHEADER)

LONG biWidth; //图像的宽度

LONG biHeight; //高度

WORD biPlanes; //必须为1

WORD biBitCount //每个像素的比特数，24位真彩色图应该设成24

DWORD biCompression; //压缩

DWORD biSizeImage; //图像数据的大小

LONG biXPelsPerMeter; //水平方向上的每米的像素个数

LONG biYPelsPerMeter; //垂直方向上的每米的像素个数

DWORD biClrUsed; //调色板中实际使用的颜色数

DWORD biClrImportant; //现实位图时必须的颜色数

} BITMAPINFOHEADER;

4 位图数据

根据不同的位图，位图数据所占据的字节数也是不同的，比如，对于8位位图，每个字节代表了一个像素，对于16位位图，每两个字节代表了一个像素，对于24位位图，每三个字节代表了一个像素，对于32位位图，每四个字节代表了一个像素。本文中的位图采用的是24位位图（3字节）。

这里需要说明的是：位图数据中的数据排列不是按照我们习惯的从左到右，从上到下的顺序。而是采用了从下到上，从左到右的顺序排列每个像素，且，每个像素的RGB颜色值的排列顺序是B,G,R，恰好相反。因此，我们在处理的时候需要特别的注意。

（三）MyColor类定义和实现

MyColor类代表了一个像素点（的颜色），为了方便后续的处理，使用double类型保存RGB值。

struct MyColor

{

public:

// default constructor

MyColor()

{

}

// double initialization constructor

MyColor(double x, double y, double z)

{

X = x;

Y = y;

Z = z;

}

// int initialization constructor

MyColor(int x, int y, int z)

{

X = x;

Y = y;

Z = z;

}

// Equal operator

bool operator==(MyColor& c)

{

return ( (X == c.X) && (Y == c.Y) && (Z == c.Z));

}

// Assignment operator

MyColor& operator=(MyColor& c)

{

X = c.X;

Y = c.Y;

Z = c.Z;

return (*this);

}

// operator /

MyColor operator/(int i)

{

return MyColor(this->X / i, this->Y / i, this->Z / i);

}

MyColor operator/(double d)

{

return MyColor(this->X / d, this->Y / d, this->Z / d);

}

// operator *

MyColor operator*(int i)

{

return MyColor(this->X * i, this->Y * i, this->Z * i);

}

MyColor operator*(double d)

{

return MyColor(this->X * d, this->Y * d, this->Z * d);

}

// operator +

MyColor operator+(MyColor& c)

{

return MyColor(this->X + c.X, this->Y + c.Y, this->Z + c.Z);

}

// operator -

double operator-(MyColor& c)

{

return _Euclidean3D(c);

}

// 3-D 欧式距离（squared）

double _Euclidean3D(MyColor& c)

{

static double tmp;

tmp = (this->X - c.X) * (this->X - c.X) +

(this->Y - c.Y) * (this->Y - c.Y) +

(this->Z - c.Z) * (this->Z - c.Z);

return tmp;

}

public:

// 3-dimension data, eg. R, G, B

double X;

double Y;

double Z;

};

上面的“减号”操作符是求两个颜色值的距离，它直接调用 _Euclidean3D计算欧式距离；也可以替换成别的距离函数（如海明距离）。

X，Y，Z中保存的是颜色值，double类型。

还有一些别的操作，如*,/等等，主要是对颜色值进行线性运算。

（四）MyBitmap类的定义

MyBitmap类实现了基本的常用的位图操作。

一些成员变量：

LPBITMAPFILEHEADER m_lpFileHeader;//文件头的指针

LPBITMAPINFOHEADER m_lpInfoHead;//信息头指针

MyColor * m_Image;//位图数据指针

一些成员函数：

void Open(char* Filename);//打开文件（24位真彩色）

void Close();//关闭文件，释放所有资源

void Write2File(char* Filename);//写回bmp文件

void Create(int width, int height, MyColor c = MyColor(0,0,0));//建立指定大小和颜色的位图对象

MyBitmap& operator=(MyBitmap& bitmap);//复制本对象

bool operator==(MyBitmap& bitmap);//比较两个位图是否相同

void GetAt(int x, int y, MyColor& c);//获取坐标x,y的颜色值（左上角为0，0）

void SetAt(int x, int y, MyColor& c);//设置颜色

MyColor& GetRef(int x, int y);//获取某个像素对象的引用

void GetImageSection(int x, int y, int width, int height, MyBitmap& bitmap);//获取指定区域

void SetImageSection(int x, int y, int width, int height, MyColor& c);//设置指定区域

void SetImageSection(int x, int y, int width, int height, MyBitmap& bitmap);//设置指定区域

long GetWidth();//获取宽度

long GetHeight();//获取高度

bool IsBitmapValid();//测试对象是否有效

// 24-bit bitmap class

class MyBitmap

{

public:

// default constructor

MyBitmap();

// initialization constructor

MyBitmap(int width, int height, MyColor c = MyColor(0,0,0));

// default deconstructor

~MyBitmap();

public:

// open a 24-bit bitmap file

void Open(char* Filename);

// close a bitmap object and release all resource it used

void Close();

// write this object to a bitmap file

void Write2File(char* Filename);

// create a new bitmap object with prefixed width and height and color

void Create(int width, int height, MyColor c = MyColor(0,0,0));

// assignment operator

MyBitmap& operator=(MyBitmap& bitmap);

// equal operator

bool operator==(MyBitmap& bitmap);

// get color element at pos(x,y) x: width y: height (0,0) at left-top

void GetAt(int x, int y, MyColor& c);

// set color element at pos(x,y)

void SetAt(int x, int y, MyColor& c);

// get reference of the m_Image

MyColor& GetRef(int x, int y);

// get section of an image

void GetImageSection(int x, int y, int width, int height, MyBitmap& bitmap);

// set section of an image to color

void SetImageSection(int x, int y, int width, int height, MyColor& c);

// set section of an image to another image

void SetImageSection(int x, int y, int width, int height, MyBitmap& bitmap);

// get bitmap width

long GetWidth();

// get bitmap height

long GetHeight();

// test if a valid bitmap is read in memory

bool IsBitmapValid();

private:

// get bytes used per line in the bitmap

int GetBytesPerLine();

private:

// true if an object is valid

bool m_bValid;

// store the image file head

LPBITMAPFILEHEADER m_lpFileHeader;

// store the image info head

LPBITMAPINFOHEADER m_lpInfoHead;

// store the image data

MyColor * m_Image;

};

（五）MyBitmap类的定义

以下是实现代码：

MyBitmap::MyBitmap()

{

m_bValid = false;

m_lpFileHeader = NULL;

m_lpInfoHead = NULL;

m_Image = NULL;

}

MyBitmap::MyBitmap(int width, int height, MyColor c /* = MyColor */)

{

if(!(width > 0 && height > 0))

throw "MyBitmap::MyBitmap - width / height non-positive";

m_bValid = false;

m_lpFileHeader = NULL;

m_lpInfoHead = NULL;

m_Image = NULL;

Create(width, height, c);

}

MyBitmap::~MyBitmap()

{

delete m_lpFileHeader;

delete m_lpInfoHead;

delete []m_Image;

m_bValid = false;

m_lpFileHeader = NULL;

m_lpInfoHead = NULL;

m_Image = NULL;

}

bool MyBitmap::IsBitmapValid()

{

return m_bValid;

}

void MyBitmap::Open(char* Filename)

{

if(IsBitmapValid())

Close();

FILE *fp = fopen(Filename, "rb");

if(!fp)

throw "MyBitmap::Open - file open error";

m_lpFileHeader = new BITMAPFILEHEADER;

if(m_lpFileHeader == NULL)

throw "MyBitmap::Open - out of memory";

m_lpInfoHead = new BITMAPINFOHEADER;

if(m_lpInfoHead == NULL)

throw "MyBitmap::Open - out of memory";

fread(m_lpFileHeader, sizeof(BITMAPFILEHEADER), 1, fp);

fread(m_lpInfoHead, sizeof(BITMAPINFOHEADER), 1, fp);

byte *image = new byte[m_lpInfoHead->biSizeImage];

if(image == NULL)

throw "MyBitmap::Open - out of memory";

fread(image, 1, m_lpInfoHead->biSizeImage, fp);

m_Image = new MyColor[m_lpInfoHead->biWidth * m_lpInfoHead->biHeight];

if(m_Image == NULL)

throw "MyBitmap::Open - out of memory";

double thex, they, thez;

long addr;

long bytePerline = m_lpInfoHead->biSizeImage / m_lpInfoHead->biHeight;

for(int x = 0 ; x < m_lpInfoHead->biWidth ; x++)

{

for(int y = 0 ; y < m_lpInfoHead->biHeight ; y++)

{

addr = x * 3 + (m_lpInfoHead->biHeight - y - 1) * bytePerline;

thez = image[addr];

they = image[addr+1];

thex = image[addr+2];

m_Image[y * m_lpInfoHead->biWidth + x].X = thex;

m_Image[y * m_lpInfoHead->biWidth + x].Y = they;

m_Image[y * m_lpInfoHead->biWidth + x].Z = thez;

}

}

delete []image;

m_bValid = true;

}

void MyBitmap::Close()

{

if(m_bValid)

{

delete m_lpFileHeader;

m_lpFileHeader = NULL;

delete m_lpInfoHead;

m_lpInfoHead = NULL;

delete []m_Image;

m_Image = NULL;

m_bValid = false;

}

}

int MyBitmap::GetBytesPerLine()

{

if(!IsBitmapValid())

throw "MyBitmap::GetBytesPerLine - open first";

int bytePerline = m_lpInfoHead->biSizeImage / m_lpInfoHead->biHeight;

return bytePerline;

}

long MyBitmap::GetWidth()

{

if(!IsBitmapValid())

throw "MyBitmap::GetWidth - open first";

return m_lpInfoHead->biWidth;

}

long MyBitmap::GetHeight()

{

if(!IsBitmapValid())

throw "MyBitmap::GetHeight - open first";

return m_lpInfoHead->biHeight;

}

void MyBitmap::Write2File(char* Filename)

{

if(!IsBitmapValid())

throw "MyBitmap::Write2File - no image exists";

FILE *fp = fopen(Filename, "w+b");

if(!fp)

throw "MyBitmap::Write2File - file open error";

fwrite(m_lpFileHeader, sizeof(BITMAPFILEHEADER), 1, fp);

fwrite(m_lpInfoHead, sizeof(BITMAPINFOHEADER), 1, fp);

byte *image = new byte[m_lpInfoHead->biSizeImage];

if(image == NULL)

throw "MyBitmap::Write2File - out of memory";

memset(image, 0, m_lpInfoHead->biSizeImage);

double thex, they, thez;

long addr;

long bytePerline = this->GetBytesPerLine();

for(int x = 0 ; x < m_lpInfoHead->biWidth ; x++)

{

for(int y = 0 ; y < m_lpInfoHead->biHeight ; y++)

{

addr = x * 3 + (m_lpInfoHead->biHeight - y - 1) * bytePerline;

thex = m_Image[y * m_lpInfoHead->biWidth + x].X;

they = m_Image[y * m_lpInfoHead->biWidth + x].Y;

thez = m_Image[y * m_lpInfoHead->biWidth + x].Z;

image[addr] = thez;

image[addr+1] = they;

image[addr+2] = thex;

}

}

fwrite(image, 1, m_lpInfoHead->biSizeImage, fp);

delete []image;

fclose(fp);

}

void MyBitmap::Create(int width, int height, MyColor c)

{

if(!(width > 0 && height > 0))

throw "MyBitmap::Create - width / height non-positive";

if(this->IsBitmapValid())

Close();

m_lpFileHeader = new BITMAPFILEHEADER;

if(m_lpFileHeader == NULL)

throw "MyBitmap::Create - out of memory";

memset(m_lpFileHeader, 0, sizeof(BITMAPFILEHEADER));

m_lpInfoHead = new BITMAPINFOHEADER;

if(m_lpInfoHead == NULL)

throw "MyBitmap::Create - out of memory";

memset(m_lpInfoHead, 0, sizeof(BITMAPINFOHEADER));

m_Image = new MyColor[width * height];

if(m_Image == NULL)

throw "MyBitmap::Create - out of memory";

int linebytes = width * 3;

while(linebytes % 4)

linebytes ++;

//位图文件大小

int ImageSize = linebytes * height +

sizeof(BITMAPFILEHEADER) +

sizeof(BITMAPINFOHEADER);

m_lpFileHeader->bfType = (WORD)0x4d42;

m_lpFileHeader->bfSize = ImageSize;

m_lpFileHeader->bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

m_lpInfoHead->biBitCount = 24;

m_lpInfoHead->biWidth = width;

m_lpInfoHead->biHeight = height;

m_lpInfoHead->biPlanes = 1;

m_lpInfoHead->biCompression = BI_RGB;

m_lpInfoHead->biSize = sizeof(BITMAPINFOHEADER);

m_lpInfoHead->biSizeImage = linebytes * height;

for(int x = 0 ; x < width ; x ++)

{

for(int y = 0 ; y < height ; y ++)

{

m_Image[width * y + x] = c;

}

}

m_bValid = true;

}

MyBitmap& MyBitmap::operator=(MyBitmap& bitmap)

{

if(bitmap.IsBitmapValid()) //valid

{

this->Close();

m_lpFileHeader = new BITMAPFILEHEADER;

if(m_lpFileHeader == NULL)

throw "MyBitmap::operator= - out of memory";

memcpy(m_lpFileHeader, bitmap.m_lpFileHeader, sizeof(BITMAPFILEHEADER));

m_lpInfoHead = new BITMAPINFOHEADER;

if(m_lpInfoHead == NULL)

throw "MyBitmap::operator= - out of memory";

memcpy(m_lpInfoHead, bitmap.m_lpInfoHead, sizeof(BITMAPINFOHEADER));

m_Image = new MyColor[bitmap.GetWidth() * bitmap.GetHeight()];

if(m_Image == NULL)

throw "MyBitmap::operator= - out of memory";

memcpy(m_Image, bitmap.m_Image, bitmap.GetWidth() * bitmap.GetHeight() * sizeof(MyColor));

m_bValid = true;

}

else //not valid

{

this->Close();

}

return (*this);

}

bool MyBitmap::operator==(MyBitmap& bitmap)

{

if(this->m_bValid == false && bitmap.m_bValid == false)

return true;

if( (this->m_bValid == true && bitmap.m_bValid == false) ||

(this->m_bValid == false && bitmap.m_bValid == true) )

return false;

//all valid

int ret;

ret = memcmp(this->m_lpFileHeader, bitmap.m_lpFileHeader, sizeof(BITMAPFILEHEADER));

if(ret != 0)

return false;

ret = memcmp(this->m_lpInfoHead, bitmap.m_lpInfoHead, sizeof(BITMAPINFOHEADER));

if(ret != 0)

return false;

ret = memcmp(this->m_Image,

bitmap.m_Image, sizeof(MyColor) * bitmap.GetWidth() * bitmap.GetHeight());

if(ret != 0)

return false;

return true;

}

void MyBitmap::GetAt(int x, int y, MyColor& c)

{

if( ! (x >= 0 && y >= 0 && x < this->GetWidth() && y < this->GetHeight()) )

throw "MyBitmap::GetAt - x / y beyond the bound";

if(!IsBitmapValid())

throw "MyBitmap::GetAt - no image exists";

c = m_Image[this->GetWidth() * y + x];

}

void MyBitmap::SetAt(int x, int y, MyColor& c)

{

if( ! (x >= 0 && y >= 0 && x < this->GetWidth() && y < this->GetHeight()) )

throw "MyBitmap::SetAt - x / y beyond the bound";

if(!IsBitmapValid())

throw "MyBitmap::SetAt - no image exists";

m_Image[this->GetWidth() * y + x] = c;

}

MyColor& MyBitmap::GetRef(int x, int y)

{

if( ! (x >= 0 && y >= 0 && x < this->GetWidth() && y < this->GetHeight()) )

throw "MyBitmap::GetRef - x / y beyond the bound";

if(!IsBitmapValid())

throw "MyBitmap::GetRef - no image exists";

return m_Image[this->GetWidth() * y + x];

}

void MyBitmap::GetImageSection(int x, int y, int width, int height, MyBitmap& bitmap)

{

if( ! (x >= 0 && y >= 0 && x+width-1 < this->GetWidth() && y+height-1 < this->GetHeight() &&

width > 0 && height > 0) )

throw "MyBitmap::GetImageSection - x / y / widht / height beyond the bound";

bitmap.Create(width, height);

MyColor c;

for(int i = 0 ; i < width ; i ++)

{

for(int j = 0 ; j < height ; j ++)

{

this->GetAt(i + x, j + y, c);

bitmap.SetAt(i, j, c);

}

}

}

void MyBitmap::SetImageSection(int x, int y, int width, int height, MyColor& c)

{

if( ! (x >= 0 && y >= 0 && x+width-1 < this->GetWidth() && y+height-1 < this->GetHeight() &&

width > 0 && height > 0) )

throw "MyBitmap::SetImageSection - x / y / widht / height beyond the bound";

for(int i = 0 ; i < width ; i ++)

{

for(int j = 0 ; j < height ; j ++)

{

this->GetRef(i + x, j + y) = c;

}

}

}

void MyBitmap::SetImageSection(int x, int y, int width, int height, MyBitmap& bitmap)

{

if( ! (x >= 0 && y >= 0 && x+width-1 < this->GetWidth() && y+height-1 < this->GetHeight() &&

width > 0 && height > 0 && width <= bitmap.GetWidth() && height <= bitmap.GetHeight()) )

throw "MyBitmap::SetImageSection - x / y / widht / height beyond the bound";

MyColor c;

for(int j = 0 ; j < height ; j ++)

{

for(int i = 0 ; i < width ; i ++)

{

bitmap.GetAt(i, j, c);

this->GetRef(i + x, j + y) = c;

}

}

}

（六）测试

主函数：

void main(void)

{

MyBitmap b;

b.Open("a.bmp");

b.Write2File("b.bmp");

b.Close();

}

（七）说明

本文实现了一个简单易用的24位真彩色位图类，避免了过多的接口和不必要的功能。通过对这个类进行扩充，还可以满足未来更多的需要。

• ·Tomcat的RemoteAddrValve的
• ·在IBM WebSphere MQ本地队列中存
• ·[原创] 简单实用的c++快速排序模板类
• ·C++程序员在学习C#时需要注意的一些问题（一
• ·biosdisk的用法
• ·[原创] 一个简单的使用wininet的htt
• ·井字棋程序的设计与算法
• ·计算机随机数的产生
• ·用C#下的Raw Socket编程实现网络封包
• ·使用JavaScript写的操作系统和输入法程