解析BMP格式图片

已于 2023-08-31 19:02:33 修改
阅读量837 收藏 4
点赞数 2
分类专栏： 图片解析 文章标签： c++ windows
于 2023-07-05 17:18:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46239139/article/details/131533015
版权
本文详细介绍了BMP文件的结构，包括BITMAPFILEHEADER和BITMAPINFOHEADER，以及如何使用C++通过WindowsAPI读取并显示BMP图像。通过创建自定义函数SetImage和ReadBMP，实现了从文件中解析BMP像素数据并显示在窗口上。同时，文章解决了图像反转和颜色反转的问题，确保正确显示图片。
摘要由CSDN通过智能技术生成

介绍

BMP是Bitmap的简称，是一种图像文件的格式格式简单。本篇文章将讲解如何读取bmp格式的文件

BMP结构

我们可以使用软件 010Editor 来帮助我们查看已经文件的结构。如下是我们要解析的bmp图片

(来源于:百度搜索，大小为600x400)

用010Editor打开后是这样子的

 红色框里是该文件的所有结构，蓝色框里是该文件的二进制数据，我们只需要了解这两个地方的内容就行

从中不难看出该BMP由三部分组成:BITMAPFILEHEADER、BITMAPINFOHEADER、BITMAPLINE

BITMAPFILEHEADER:位图文件头，存储着文件文件类型等数据

BITMAPINFOHEADER:位图信息头，存储着图片的宽高，颜色位数等数据

BITMAPLINE:图片像素数据

BITMAPFILEHEADER和BITMAPINFOHEADER结构如下

typedef struct tagBITMAPFILEHEADER {
        WORD    bfType;
        DWORD   bfSize;
        WORD    bfReserved1;
        WORD    bfReserved2;
        DWORD   bfOffBits;
} BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
} BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;

这些结构微软已经帮我们定义好了。我们并不需要了解结构中所有的变量代表什么，只需要知道其中几个就行

BITMAPFILEHEADER:

bfType:文件类型(BMP文件固定为19778，也就是16进制的4D42)

BITMAPINFOHEADER:

biWidth:图像宽度

biHeight:图像高度

biBitCount:图像颜色深度

我们读取bmp只需要如上的数据就行。

BITMAPLINE代表的是图像的像素数据，每个像素一般为一个RGB值，大小由颜色深度决定(一般为24)，存储它可以用COLORREF类型也可以用RGBQUAD类型(COLORREF类型就是RGBQUAD类型)，这里以COLORREF类型为例子。BMP不支持透明度，而COLORREF支持透明度，所以我们可以将图像中的每个像素看成不透明(透明度为255)的像素并填入COLORREF类型，具体示例如下

//假设pixel为图像中的一个像素(红色),只有R,G,B三位数据
//                 R   G  B
BYTE pixel[3] = { 255, 0, 0 };
//一个RGBAURD(COLORREF)类型的数据有R,G,B,A四位数据
//                R   G  B   A
RGBQUAD rgba = { 0, 0, 0, 128 };
//我们可以将pixel看成是透明度(A)为255的RGBQUAD类型的数据,所以如果要将pixle转化为RGBQUAD类型数据,就可以进行以下操作
rgba.rgbRed = pixel[0];
rgba.rgbGreen = pixel[1];
rgba.rgbBlue = pixel[2];
rgba.rgbReserved = 255;    //透明度设为255,也就是不透明

图片显示

在读取图像前我们需要思考一下如何显示我们读取到的像素。我想一些人首先想到的是 SetPixel函数 。雀食，它可以设置一个点的像素。但它是一个一个地设置像素点，效果如下

可以看出它是逐渐显示出图像的，显示速度取决于图片的大小 ，所以比较浪费时间，我们需要一种可以立刻显示图像的方法。因为是读取像素点并显示，所以不使用BitBlt函数(比较麻烦)。因此我编写了一个可直接传入像素值显示图片的函数，代码如下：

HWND SetImage(HWND hWnd, COLORREF* colRGBA, int nWidth, int nHeight, int iPosX, int iPosY)
{
    int nSize = nWidth * nHeight;

    WNDCLASS        wnd;

    HWND            hImage = NULL;
    HBITMAP         hCustomBmp = NULL;
    HDC             hLayeredWindowDC = NULL;
    HDC             hCompatibleDC = NULL;

    BITMAPINFO      bmpInfo = { 0 };
    BLENDFUNCTION   blend = { 0 };
    POINT           pSrc = { 0, 0 };
    POINT           ptDst = { iPosX, iPosY };
    SIZE            sizeWnd = { nWidth, nHeight };

    COLORREF*       colBGRA = new COLORREF[nSize];

    if (!colRGBA)
        return NULL;

    for (int index = 0; index < nSize; index++)
    {
        COLORREF col = colRGBA[index];
        colBGRA[index] = (COLORREF)(((BYTE)(col >> 16) | ((WORD)((BYTE)(col >> 8)) << 8)) | (((DWORD)((BYTE)(col)) << 16)) | (((DWORD)((BYTE)(col >> 24)) << 24)));
    }

    wnd.cbClsExtra = 0;
    wnd.cbWndExtra = 0;
    wnd.hbrBackground = (HBRUSH)(GetStockObject(GRAY_BRUSH));
    wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
    wnd.hIcon = LoadCursor(NULL, IDI_APPLICATION);
    wnd.lpfnWndProc = DefWindowProc;
    wnd.lpszClassName = L"LAYERED";
    wnd.lpszMenuName = NULL;
    wnd.style = CS_HREDRAW;
    wnd.hInstance = GetModuleHandle(NULL);
    RegisterClass(&wnd);

    hImage = CreateWindowEx(WS_EX_LAYERED, L"LAYERED", 0,
        WS_POPUP | WS_BORDER, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);

    SetParent(hImage, hWnd);

    hLayeredWindowDC = GetDC(hImage);
    hCompatibleDC = CreateCompatibleDC(hLayeredWindowDC);
    blend.BlendOp = AC_SRC_OVER;
    blend.SourceConstantAlpha = 255;
    blend.AlphaFormat = AC_SRC_ALPHA;

    hCustomBmp = CreateCompatibleBitmap(hLayeredWindowDC, nWidth, nHeight);
    SelectObject(hCompatibleDC, hCustomBmp);

    bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfo.bmiHeader.biWidth = nWidth;
    bmpInfo.bmiHeader.biHeight = -nHeight;
    bmpInfo.bmiHeader.biPlanes = 1;
    bmpInfo.bmiHeader.biCompression = BI_RGB;
    bmpInfo.bmiHeader.biBitCount = 32;
    SetDIBits(NULL, hCustomBmp, 0, nHeight, colBGRA, &bmpInfo, DIB_RGB_COLORS);

    UpdateLayeredWindow(hImage, hLayeredWindowDC, &ptDst, &sizeWnd, hCompatibleDC, &pSrc, NULL, &blend, ULW_ALPHA);

    DeleteDC(hLayeredWindowDC);

    return hImage;
}

以上代码只需要添加Windows.h头文件，放在任何win32窗口项目里都可以运行。该函数高级在它支持透明度，更加灵活。

hWnd:主窗口的句柄

cPixels:像素点数据

nWidth:图片宽

nHeight:图片高

nPosX:图片(左上角)在窗口中的横坐标

nPosY:图片在窗口中的纵坐标

此函数原理是使用分层窗口通过填充像素显示图片，具体实现原理可以看看我写过的文章 分层窗口的说明与使用。该函数在此处不需要掌握原理，只需会用就行。

至此，我们才正式开始bmp的解析工作

BMP解析

(我是在Windows平台，使用的IDE是vs，其他情况请根据实际进行操作)

我们得先创建一个win32桌面应用程序空项目，创建完之后添加一个main.cpp文件(名字可自己取)，创建完后效果如下：

 接下来我们需要写一个简单的窗口，再把上面显示图片的函数 SetImage 放进去，这里不过多赘述，代码如下

#include<windows.h>

HWND SetImage(HWND hWnd, COLORREF* colRGBA, int nWidth, int nHeight, int iPosX, int iPosY)
{
    int nSize = nWidth * nHeight;

    WNDCLASS        wnd;

    HWND            hImage = NULL;
    HBITMAP         hCustomBmp = NULL;
    HDC             hLayeredWindowDC = NULL;
    HDC             hCompatibleDC = NULL;

    BITMAPINFO      bmpInfo = { 0 };
    BLENDFUNCTION   blend = { 0 };
    POINT           pSrc = { 0, 0 };
    POINT           ptDst = { iPosX, iPosY };
    SIZE            sizeWnd = { nWidth, nHeight };

    COLORREF*       colBGRA = new COLORREF[nSize];

    if (!colRGBA)
        return NULL;

    for (int index = 0; index < nSize; index++)
    {
        COLORREF col = colRGBA[index];
        colBGRA[index] = (COLORREF)(((BYTE)(col >> 16) | ((WORD)((BYTE)(col >> 8)) << 8)) | (((DWORD)((BYTE)(col)) << 16)) | (((DWORD)((BYTE)(col >> 24)) << 24)));
    }

    wnd.cbClsExtra = 0;
    wnd.cbWndExtra = 0;
    wnd.hbrBackground = (HBRUSH)(GetStockObject(GRAY_BRUSH));
    wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
    wnd.hIcon = LoadCursor(NULL, IDI_APPLICATION);
    wnd.lpfnWndProc = DefWindowProc;
    wnd.lpszClassName = L"LAYERED";
    wnd.lpszMenuName = NULL;
    wnd.style = CS_HREDRAW;
    wnd.hInstance = GetModuleHandle(NULL);
    RegisterClass(&wnd);

    hImage = CreateWindowEx(WS_EX_LAYERED, L"LAYERED", 0,
        WS_POPUP | WS_BORDER, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);

    SetParent(hImage, hWnd);

    hLayeredWindowDC = GetDC(hImage);
    hCompatibleDC = CreateCompatibleDC(hLayeredWindowDC);
    blend.BlendOp = AC_SRC_OVER;
    blend.SourceConstantAlpha = 255;
    blend.AlphaFormat = AC_SRC_ALPHA;

    hCustomBmp = CreateCompatibleBitmap(hLayeredWindowDC, nWidth, nHeight);
    SelectObject(hCompatibleDC, hCustomBmp);

    bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfo.bmiHeader.biWidth = nWidth;
    bmpInfo.bmiHeader.biHeight = -nHeight;
    bmpInfo.bmiHeader.biPlanes = 1;
    bmpInfo.bmiHeader.biCompression = BI_RGB;
    bmpInfo.bmiHeader.biBitCount = 32;
    SetDIBits(NULL, hCustomBmp, 0, nHeight, colBGRA, &bmpInfo, DIB_RGB_COLORS);

    UpdateLayeredWindow(hImage, hLayeredWindowDC, &ptDst, &sizeWnd, hCompatibleDC, &pSrc, NULL, &blend, ULW_ALPHA);

    DeleteDC(hLayeredWindowDC);

    return hImage;
}

//自定义窗口过程
LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg,
    WPARAM wParam, LPARAM lParam)
{
    switch (Msg)
    {
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);



        EndPaint(hWnd, &ps);
        break;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, Msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevlnstance,
    LPSTR lpCmdLine, int nShowCmd)
{
    //注册
    WNDCLASS wnd;
    wnd.cbClsExtra = 0;
    wnd.cbWndExtra = 0;
    wnd.hbrBackground = (HBRUSH)(GetStockObject(GRAY_BRUSH));
    wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
    wnd.hIcon = LoadCursor(NULL, IDI_APPLICATION);
    wnd.lpfnWndProc = WndProc;
    wnd.lpszClassName = L"Window";
    wnd.lpszMenuName = NULL;
    wnd.style = CS_HREDRAW;
    wnd.hInstance = hInstance;
    RegisterClass(&wnd);

    //创建
    HWND hWnd = CreateWindow(L"Window", L"BMP",
        WS_OVERLAPPEDWINDOW, 100, 100, 800, 600, NULL, NULL, hInstance, NULL);
    //显示
    ShowWindow(hWnd, nShowCmd);
    //更新
    UpdateWindow(hWnd);

    //循环
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);

    }
}

(PS:若看不懂请先去学习win32基础)

接着我们就要开始解析BMP格式文件了。先梳理一下思路：先读取位图文件头(BITMAPFILEHEADER)，再读取位图信息头(BITMAPINFOHEADER)，最后再读取图片的像素信息，接下来我们创建一个函数 ReadBMP 专门解析BMP格式文件

为了读取文件我们需要再添加头文件<iostream>

要读取BMP数据就需要一张BMP图片，所以函数就需要传入BMP图片的路径。最终我们需要的是图片的像素值，所以函数需要返回或传出图片的像素值，所以函数就可以初步编写成以下形式


#include <windows.h>
#include <iostream>

HWND SetImage(HWND hWnd, COLORREF* colRGBA, int nWidth, int nHeight, int iPosX, int iPosY)
{
    ...
}

//                    传入图片路径         接收图片像素
BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    return TRUE;
}

...

首先我们要打开文件，使用fopen_s函数打开文件

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if(!fp)
        return FALSE;

    return TRUE;
}

当文件打开成功后，我们首先读取的是位图文件头，使用fread函数读取文件

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    BITMAPFILEHEADER bmpFileHeader = {};        //声明存放位图文件头的变量

    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if (!fp)
        return FALSE;
    //读取位图文件头
    fread(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);



    return TRUE;
}

我们还得做一些保护措施，如果传入的图片不是BMP，那么接下来所做的操作都将毫无意义，还会有一大堆错误，所以在这里判断一下文件类型是否为BMP，通过位图文件头里的bfType判断，若其等于19778，则为BMP文件，否则就不是BMP文件

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    BITMAPFILEHEADER bmpFileHeader = {};        //声明存放位图文件头的变量

    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if (!fp)
        return FALSE;
    //读取位图文件头
    fread(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);
    //判断是否为BMP文件
    if (bmpFileHeader.bfType != 19778)
        return FALSE;   //不是就返回FALSE


    return TRUE;
}

当我们确定是BMP文件之后，就可以读取位图信息头了

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    BITMAPFILEHEADER bmpFileHeader = {};        //声明存放位图文件头的变量
    BITMAPINFOHEADER bmpInfoHeader = {};

    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if (!fp)
        return FALSE;
    //读取位图文件头
    fread(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);
    //判断是否为BMP文件
    if (bmpFileHeader.bfType != 19778)
        return FALSE;   //不是就返回FALSE

    //读取位图信息头
    fread(&bmpInfoHeader, 1, sizeof(bmpInfoHeader), fp);

    return TRUE;
}

接下来就可以通过位图信息头获取一些关于图片的重要信息了

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    BITMAPFILEHEADER bmpFileHeader = {};        //声明存放位图文件头的变量
    BITMAPINFOHEADER bmpInfoHeader = {};

    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if (!fp)
        return FALSE;
    //读取位图文件头
    fread(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);
    //判断是否为BMP文件
    if (bmpFileHeader.bfType != 19778)
        return FALSE;   //不是就返回FALSE

    //读取位图信息头
    fread(&bmpInfoHeader, 1, sizeof(bmpInfoHeader), fp);
    //获取图片信息
    LONG picWidth = bmpInfoHeader.biWidth;  //获取图片宽
    LONG picHeight = bmpInfoHeader.biHeight;  //获取图片高
    LONG picSize = picWidth * picHeight;//获取图片大小

    

    return TRUE;
}

然后初始化要传出的变量用于存放读取的图片像素

...
LONG picWidth = bmpInfoHeader.biWidth;  //获取图片宽
LONG picHeight = bmpInfoHeader.biHeight;  //获取图片高
LONG picSize = picWidth * picHeight;//获取图片大小

//初始化要传出的变量
ZeroMemory(colRGBs, sizeof(RGBQUAD) * picSize);



return TRUE;
...

之后我们就要读取图片的内容了，通过循环嵌套一行一行地读取像素值

图片的像素数据每个像素占3字节大小，而COLORREF，RGBQUAD等数据类型都占4个字节，为了更方便读取也为了更容易理解这个过程，我们可以创建一个数据类型，使其与图片里的每个像素值类型相符，具体如下

...
#include <iostream>
//创建一个只有3字节大小的数据类型便于读取图像像素值
typedef struct _tagRGBTriplet {
    BYTE rgbRed;        //R
    BYTE rgbGreen;      //G
    BYTE rgbBlue;       //B
}RGBTRIPLET, *LPRGBTRIPLET;

HWND SetImage(HWND hWnd, COLORREF* colRGBA, int nWidth, int nHeight, int iPosX, int iPosY)
...

为了方便赋值，我们需要一个RGBA宏，定义如下：

#define         RGBA(r,g,b,a)                   (COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g)) << 8))|(((DWORD)((BYTE)(b)) << 16))|(((DWORD)((BYTE)(a)) << 24)))

接着回到ReadBMP函数里读取像素值信息

for (int nColumn = 0; nColumn < picHeight; nColumn++)
{
    for (int nRow = 0; nRow < picWidth; nRow++)
    {
        RGBTRIPLET rgb = { 0, 0, 0 };
        //读取单个像素值
        fread(&rgb, sizeof(RGBTRIPLET), 1, fp);
        //                                                                       透明度为255意为不透明
        colRGBs[nColumn * picWidth + nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
        //nColunm * picWidth + nRow 就是位于横坐标为nRow, 纵坐标为nCloumn的像素的索引


    }
}

至此，我们的BMP读取函数完成了！

我们在WM_PAINT消息里读取并显示图片看看是什么样的

已知图片的大小为600x400

...
case WM_PAINT:
{
    PAINTSTRUCT ps;
    HDC hdc = BeginPaint(hWnd, &ps);

    COLORREF* pixels = new COLORREF[600 * 400];
    //读取BMP
    ReadBMP(".\\CSDN-BMP.bmp", pixels);
    //显示图片
    SetImage(hWnd, pixels, 600, 400, 0, 0);

    EndPaint(hWnd, &ps);
    break;
}
...

不出意外的话，图片效果如下

 从中可以看出两个问题：

1.图像反了

2.图像RGB值有问题

我们先解决第一个问题

因为文件中的像素值是从图像左下角第一个像素开始的，所以图片在变量里的样子应该是上下颠倒的

而SetImage函数是从左上角第一个像素开始读取并显示的，所以显示出的图像就是上下颠倒的样子

 

 因此我们只需要将读取出来的像素上下镜像翻转一下，SetImage就可以正常显示图片了就行了

至于怎么翻转，可以先创建一个临时变量用于存放图像一整行的显像素，每读取一行像素后就将它放入存储图像像素值的变量里倒数的指定行数，例如读取了第一行的像素，就将其放入变量的最后一行；读取了第二行的像素，就将其放入变量的倒数第二行······如此循环往复，就能实现垂直镜像翻转

我们先设图片的高度为h，当前读取的像素行数为a，那么第a行的像素值就应该放入变量里的(h-a+1)行,不妨带入一些数据：图片高度为10，当前读取第3行像素，那么该行像素值应该放入变量里的第(10-3+1)=8行，也就是倒数第三行

实际上在代码中我们不直接使用行数，而是使用索引。图像的第一行索引是0，最后一行索引是(图像高度的值-1)，因此我们要对上面的结论做出一些改变：

还是设图片高度为h，若当前读取的像素行数索引为b，那么当前读取的行数为(b+1)；若最后一行的索引是p，那么当前行数就是(p+1)，可得h=p+1。因此索引为b行的像素值应该放入变量中索引为(h-b-1)的一行

有了以上知识就可以编写代码了

...
for (int nColumn = 0; nColumn < picHeight; nColumn++)
{
    for (int nRow = 0; nRow < picWidth; nRow++)
    {
        RGBTRIPLET rgb = { 0, 0, 0 };
        //读取单个像素值
        fread(&rgb, sizeof(RGBTRIPLET), 1, fp);
        //先将一行像素存入临时变量里                      透明度为255意为不透明
        tmpRGBs[nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
        //colRGBs[nColumn * picWidth + nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
        //nColunm * picWidth + nRow 就是位于横坐标为nRow, 纵坐标为nCloumn的像素的索引

    }
    //将索引为nColumn的一行像素复制到指定的位置
    CopyMemory(&colRGBs[(picHeight - nColumn - 1) * picWidth], tmpRGBs, sizeof(COLORREF)*picWidth);
    /*
    因为使用的存储像素值的变量并非二维数组,因此无法直接选择行数
    若将一个一维数组想象成一个m*n的矩阵,若左上角第一个位置为(0,0),那么该矩阵(x,y)位置的索引应为 y*n+x
    若不理解请看下面的示例:
    2   1   3   1
    0   2   8   9
    2   1   5   6
    7   6   4   8
    9   0   0   1
    该矩阵是一个5*4的矩阵,(2,2)的位置值为5,索引为 2 * 4 + 2 = 10
    现在应该就好理解 (picHeight - nColumn - 1) * picWidth 了,如果写完整点就是 (picHeight - nColumn - 1) * picWidth + 0
    */
}
...

我想我的注释已经写得很清楚了

不出意外的话现在运行代码后效果如下

至此我们就解决了第一个问题！

现在我们来解决第二个问题：图像RGB值有问题

如果是一些对win32绘图很熟悉的人，可能一眼就看出这是颜色反转后的图像。没错，图像变成这样子都是因为rgb值反了，也就是像素值中R位置上的数据与B位上的数据反了。

我们可以通过010Editor看看bmp数据。

我们点击左下方框中的BITMAPLINE，在上方数据框中蓝色的就是图像像素值数据，可以看到第一个RGB值为"00 1B 2B"，合起来就是0x2B1B00。我们在打开系统自带的画图软件，看看第一个像素值到底是什么

确实是2B1B00，那为什么颜色会被反转呢？

我们再来看看用来存放读取RGB值的数据类型

typedef struct _tagRGBTriplet {
    BYTE rgbRed;        //R
    BYTE rgbGreen;      //G
    BYTE rgbBlue;       //B
}RGBTRIPLET, *LPRGBTRIPLET;

因为我们用来读取图像RGB值的数据类型是三个BYTE合在一起的，因此它们是按照顺序来读取每个字节，因此它们被拆成00 1B 2B三个数据被错误地放入了R、G、B位，要解决它只需要调换其中R位与B位的位置，因为无论怎么翻转G位始终在中间不变

将此结构改成以下形式就行

typedef struct _tagRGBTriplet {
    BYTE rgbBlue;       //B
    BYTE rgbGreen;      //G
    BYTE rgbRed;        //R
}RGBTRIPLET, *LPRGBTRIPLET;

到目前为止，所以问题都已被解决，不出意外的话运行代码后效果如下

终于可以正常显示图像了！ 

现在我们来换一张图片显示看看效果如何

 (原图：https://www.pixiv.net/artworks/106964347，建议直接使用上面的图像)

上图大小为799x745

现在让我们改一下代码

...
case WM_PAINT:
{
    PAINTSTRUCT ps;
    HDC hdc = BeginPaint(hWnd, &ps);

    COLORREF* pixels = new COLORREF[799 * 745];
    ReadBMP(".\\CSDN-BMP-2.bmp", pixels);
    SetImage(hWnd, pixels, 799, 745, 0, 0);

    EndPaint(hWnd, &ps);
    break;
}
...

不出意外的话，显示的图像会长这样

 为什么我老婆会变成这个样子呢？责任全在系统！！！开个玩笑awa

系统一般以4字节为单位读取数据，因此当图像一行的字节数不是4的倍数时，系统会自动补0使其成为4的倍数，这就是为什么中间会看到一条黑线(黑色的RGB值就为0)，所以我们在读取像素时要检查图像一行的字节数是否为4的倍数，如果是，那么读取完一行后就要使用fseek函数跳过系统自动补全的地方

代码如下

...
//初始化要传出的变量
ZeroMemory(colRGBs, sizeof(RGBQUAD) * picSize);
//计算要跳过的字节数
int DataJump = 4 - ((picWidth * (sizeof(RGBQUAD) - 1)) % 4);
/*
sizeof(RGBQUAD) - 1:就是RGB值的大小,为3字节
picWidth * (sizeof(RGBQUAD) - 1):图像一整行的字节数,之后除以4取余数
用4减去此余数就是系统自动补全的字节数,读取完一行后就需要跳过这些字节
若不理解请好好思考
*/

//创建临时变量
COLORREF* tmpRGBs = new COLORREF[picWidth];
ZeroMemory(tmpRGBs, sizeof(RGBQUAD) * picWidth);
for (int nColumn = 0; nColumn < picHeight; nColumn++)
{
    for (int nRow = 0; nRow < picWidth; nRow++)
    {
        RGBTRIPLET rgb = { 0, 0, 0 };
        //读取单个像素值
        fread(&rgb, sizeof(RGBTRIPLET), 1, fp);
        //先将一行像素存入临时变量里                      透明度为255意为不透明
        tmpRGBs[nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
        //colRGBs[nColumn * picWidth + nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
        //nColunm * picWidth + nRow 就是位于横坐标为nRow, 纵坐标为nCloumn的像素的索引

    }
    //将索引为nColumn的一行像素复制到指定的位置
    CopyMemory(&colRGBs[(picHeight - nColumn - 1) * picWidth], tmpRGBs, sizeof(COLORREF)*picWidth);
    /*
    因为使用的存储像素值的变量并非二维数组,因此无法直接选择行数
    若将一个一维数组想象成一个m*n的矩阵,若左上角第一个位置为(0,0),那么该矩阵(x,y)位置的索引应为 y*n+x
    若不理解请看下面的示例:
    2   1   3   1
    0   2   8   9
    2   1   5   6
    7   6   4   8
    9   0   0   1
    该矩阵是一个5*4的矩阵,(2,2)的位置值为5,索引为 2 * 4 + 2 = 10
    现在应该就好理解 (picHeight - nColumn - 1) * picWidth 了,如果写完整点就是 (picHeight - nColumn - 1) * picWidth + 0
    */

    //读取完一行后,若图像一行的字节数不是4的倍数
    if (picWidth % 4 != 0)
        fseek(fp, DataJump, SEEK_CUR);  //跳过系统补全的地方
}

return TRUE;
...

现在再次运行代码，效果如下

终于可以正常显示我的老婆了！ qwq

至此，我们已经完成了BMP文件的解析工作并成功显示了它，本文也在此画上一个"完美"的句号。

其实本文中的一些代码并不完美，还请读者试着自己改进与完善

最后附上完整代码(都在一个文件里)


#include <windows.h>
#include <iostream>

#define         RGBA(r,g,b,a)                   (COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g)) << 8))|(((DWORD)((BYTE)(b)) << 16))|(((DWORD)((BYTE)(a)) << 24)))

//创建一个只有3字节大小的数据类型便于读取图像像素值
typedef struct _tagRGBTriplet {
    BYTE rgbBlue;       //B
    BYTE rgbGreen;      //G
    BYTE rgbRed;        //R
}RGBTRIPLET, *LPRGBTRIPLET;

HWND SetImage(HWND hWnd, COLORREF* colRGBA, int nWidth, int nHeight, int iPosX, int iPosY)
{
    int nSize = nWidth * nHeight;

    WNDCLASS        wnd;

    HWND            hImage = NULL;
    HBITMAP         hCustomBmp = NULL;
    HDC             hLayeredWindowDC = NULL;
    HDC             hCompatibleDC = NULL;

    BITMAPINFO      bmpInfo = { 0 };
    BLENDFUNCTION   blend = { 0 };
    POINT           pSrc = { 0, 0 };
    POINT           ptDst = { iPosX, iPosY };
    SIZE            sizeWnd = { nWidth, nHeight };

    COLORREF*       colBGRA = new COLORREF[nSize];

    if (!colRGBA)
        return NULL;

    for (int index = 0; index < nSize; index++)
    {
        COLORREF col = colRGBA[index];
        colBGRA[index] = (COLORREF)(((BYTE)(col >> 16) | ((WORD)((BYTE)(col >> 8)) << 8)) | (((DWORD)((BYTE)(col)) << 16)) | (((DWORD)((BYTE)(col >> 24)) << 24)));
    }

    wnd.cbClsExtra = 0;
    wnd.cbWndExtra = 0;
    wnd.hbrBackground = (HBRUSH)(GetStockObject(GRAY_BRUSH));
    wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
    wnd.hIcon = LoadCursor(NULL, IDI_APPLICATION);
    wnd.lpfnWndProc = DefWindowProc;
    wnd.lpszClassName = L"LAYERED";
    wnd.lpszMenuName = NULL;
    wnd.style = CS_HREDRAW;
    wnd.hInstance = GetModuleHandle(NULL);
    RegisterClass(&wnd);

    hImage = CreateWindowEx(WS_EX_LAYERED, L"LAYERED", 0,
        WS_POPUP | WS_BORDER, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);

    SetParent(hImage, hWnd);

    hLayeredWindowDC = GetDC(hImage);
    hCompatibleDC = CreateCompatibleDC(hLayeredWindowDC);
    blend.BlendOp = AC_SRC_OVER;
    blend.SourceConstantAlpha = 255;
    blend.AlphaFormat = AC_SRC_ALPHA;

    hCustomBmp = CreateCompatibleBitmap(hLayeredWindowDC, nWidth, nHeight);
    SelectObject(hCompatibleDC, hCustomBmp);

    bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfo.bmiHeader.biWidth = nWidth;
    bmpInfo.bmiHeader.biHeight = -nHeight;
    bmpInfo.bmiHeader.biPlanes = 1;
    bmpInfo.bmiHeader.biCompression = BI_RGB;
    bmpInfo.bmiHeader.biBitCount = 32;
    SetDIBits(NULL, hCustomBmp, 0, nHeight, colBGRA, &bmpInfo, DIB_RGB_COLORS);

    UpdateLayeredWindow(hImage, hLayeredWindowDC, &ptDst, &sizeWnd, hCompatibleDC, &pSrc, NULL, &blend, ULW_ALPHA);

    DeleteDC(hLayeredWindowDC);

    return hImage;
}

BOOL ReadBMP(const char* chPath, COLORREF* colRGBs)
{
    FILE* fp = NULL;
    BITMAPFILEHEADER bmpFileHeader = {};        //声明存放位图文件头的变量
    BITMAPINFOHEADER bmpInfoHeader = {};

    //打开文件
    fopen_s(&fp, chPath, "rb");
    //打开失败
    if (!fp)
        return FALSE;
    //读取位图文件头
    fread(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);
    //判断是否为BMP文件
    if (bmpFileHeader.bfType != 19778)
        return FALSE;   //不是就返回FALSE

    //读取位图信息头
    fread(&bmpInfoHeader, 1, sizeof(bmpInfoHeader), fp);
    //获取图片信息
    LONG picWidth = bmpInfoHeader.biWidth;  //获取图片宽
    LONG picHeight = bmpInfoHeader.biHeight;  //获取图片高
    LONG picSize = picWidth * picHeight;//获取图片大小

    //初始化要传出的变量
    ZeroMemory(colRGBs, sizeof(RGBQUAD) * picSize);
    //计算要跳过的字节数
    int DataJump = 4 - ((picWidth * (sizeof(RGBQUAD) - 1)) % 4);
    /*
    sizeof(RGBQUAD) - 1:就是RGB值的大小,为3字节
    picWidth * (sizeof(RGBQUAD) - 1):图像一整行的字节数,之后除以4取余数
    用4减去此余数就是系统自动补全的字节数,读取完一行后就需要跳过这些字节
    若不理解请好好思考
    */

    //创建临时变量
    COLORREF* tmpRGBs = new COLORREF[picWidth];
    ZeroMemory(tmpRGBs, sizeof(RGBQUAD) * picWidth);
    for (int nColumn = 0; nColumn < picHeight; nColumn++)
    {
        for (int nRow = 0; nRow < picWidth; nRow++)
        {
            RGBTRIPLET rgb = { 0, 0, 0 };
            //读取单个像素值
            fread(&rgb, sizeof(RGBTRIPLET), 1, fp);
            //先将一行像素存入临时变量里                      透明度为255意为不透明
            tmpRGBs[nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
            //colRGBs[nColumn * picWidth + nRow] = RGBA(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, 255);
            //nColunm * picWidth + nRow 就是位于横坐标为nRow, 纵坐标为nCloumn的像素的索引

        }
        //将索引为nColumn的一行像素复制到指定的位置
        CopyMemory(&colRGBs[(picHeight - nColumn - 1) * picWidth], tmpRGBs, sizeof(COLORREF)*picWidth);
        /*
        因为使用的存储像素值的变量并非二维数组,因此无法直接选择行数
        若将一个一维数组想象成一个m*n的矩阵,若左上角第一个位置为(0,0),那么该矩阵(x,y)位置的索引应为 y*n+x
        若不理解请看下面的示例:
        2   1   3   1
        0   2   8   9
        2   1   5   6
        7   6   4   8
        9   0   0   1
        该矩阵是一个5*4的矩阵,(2,2)的位置值为5,索引为 2 * 4 + 2 = 10
        现在应该就好理解 (picHeight - nColumn - 1) * picWidth 了,如果写完整点就是 (picHeight - nColumn - 1) * picWidth + 0
        */

        //读取完一行后,若图像一行的字节数不是4的倍数
        if (picWidth % 4 != 0)
            fseek(fp, DataJump, SEEK_CUR);  //跳过系统补全的地方
    }
    
    return TRUE;
}

//自定义窗口过程
LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg,
    WPARAM wParam, LPARAM lParam)
{
    switch (Msg)
    {
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);

        COLORREF* pixels = new COLORREF[799 * 745];
        ReadBMP(".\\CSDN-BMP-2.bmp", pixels);
        SetImage(hWnd, pixels, 799, 745, 0, 0);

        EndPaint(hWnd, &ps);
        break;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hWnd, Msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevlnstance,
    LPSTR lpCmdLine, int nShowCmd)
{
    //注册
    WNDCLASS wnd;
    wnd.cbClsExtra = 0;
    wnd.cbWndExtra = 0;
    wnd.hbrBackground = (HBRUSH)(GetStockObject(GRAY_BRUSH));
    wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
    wnd.hIcon = LoadCursor(NULL, IDI_APPLICATION);
    wnd.lpfnWndProc = WndProc;
    wnd.lpszClassName = L"Window";
    wnd.lpszMenuName = NULL;
    wnd.style = CS_HREDRAW;
    wnd.hInstance = hInstance;
    RegisterClass(&wnd);

    //创建
    HWND hWnd = CreateWindow(L"Window", L"BMP",
        WS_OVERLAPPEDWINDOW, 100, 100, 800, 600, NULL, NULL, hInstance, NULL);
    //显示
    ShowWindow(hWnd, nShowCmd);
    //更新
    UpdateWindow(hWnd);

    //循环
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);

    }
}

LanpurZ
关注
专栏目录
010Editor的ELFTemplate 16进制改造
燕十二的BLOG
09-01 4319
010Editor查看elf文件结构非常方便，但是官方提供的模板，很多值都以10进制来显示                          对于二进制内容，还是16进制显示更方便。修改后如下图所示， 这样就直观多了。
刷题回顾（持续更新）
qq_61109509的博客
02-02 1496
misc 图片隐写 PDF转换器（桌面上）将pdf格式转化为word格式 web 1,使用burpsuite进行POST需要二部曲： 在请求头模块输入post=xxx 修改请求方式 2，变量覆盖与MD5 显性覆盖$a=$_GET[xx] 隐性覆盖 parse_str()–字符串 extract()数组 MD5 0e绕过(弱类型比较) md5('QNKCDZO') == md5(240610708)// MD5加密后会变成这个样子 0e830400451993494058024219903
打开并读取BMP图像数据
01-10
在VC++6.0环境下编程利用CDIB类实现对位图的读取和显示操作
BMP格式详解
weixin_34232744的博客
06-27 2498
BMP格式详解 BMP文件格式详解（BMP file format） BMP文件格式，又称为Bitmap（位图）或是DIB(Device-Independent Device，设备无关位图)，是Windows系统中广泛使用的图像文件格式。由于它可以不作任何变换地保存图像像素域的数据，因此成为我们取得RAW数据的重要来源。Windows的图形用户界面（graphical user inter...
怎么读取BMP图片数据
07-24 992
以前看一些类似的文章，现在要具体用了，才知道白看，纸上得来终觉浅，绝知此事须躬行。一些都得从再来。不过，话又说回来。看过才知道是这么一回事了。用UltraEdit打开一张BMP图片，分析了一下。 再结全代码（如下）  for (int y = 0; y          for (int x = 0; x           ULONG C = x + (_BOOT_BMP_YSIZE-1
提取BMP图片的数据
10-13
这个压缩包是一个BMP图片数据提取的C源代码。代码通过读取BMP图片文件，对BMP头信息进行分析，提取图像数据并完整保存到另一个文件，可以直接将图片加载到FB内存显示。 里面有详细的使用说明，同时也提供来部分格式的BMP图片作为验证。
BMP图像读取
hello_dear_you的博客
12-30 5156
0. BMP格式介绍 根据百度百科对BMP的定义，我们知道BMP是Bitmap（位图）的简称，是Windows操作系统中的标准图像文件格式。其特点是由于几乎不进行压缩，所以包含的图像信息较丰富，但同时也到之占用的磁盘空间较大。 1 文件格式 位图文件由4个部分组成： 位图头文件（bitmap-file header) 位图信息头（bitmap-information header) 颜色表（color table)：使用索引来表示图像，此时颜色表就是索引与其对应的颜色之间的映射表（即通过索引值，
PHP处理bmp格式图片的方法分析
12-19
总之，处理BMP格式图片的关键在于理解BMP文件的结构，并编写自定义函数来解析和转换这些数据。尽管PHP的GD库不提供内置的BMP支持，但通过编程手段，我们可以克服这个限制，实现BMP图片在Web开发中的有效利用。
c语言解析bmp图片的实例
08-29
C语言解析BMP图片的实例 本文主要介绍了使用C语言解析BMP图片的实例，涵盖了BMP图片的文件信息头、图片信息头、调色板信息和位图数据四个部分的解析过程。 一、文件信息头（BITMAPFILEHEADER） 文件信息头是BMP...
C语言实现对bmp格式图片打码
09-02
C语言实现对bmp格式图片打码 本文主要介绍了使用C语言实现对bmp格式图片的打码技术，该技术可以将bmp格式图片的指定位置随机置乱，实现图片的加密和保护。 bmp格式图片简介 bmp格式图片是一种无损压缩的位图格式...
bmp图像数据提取工具:bmp2raw
10-19
提取24位bmp图像的数据 linux下编译 基于EasyBmp 代码很简单，没有加注释，没有判断打开文件失败 适用于制作开机画面
010Editor模板（最新）
05-07
包含010Editor最新所有的模板： Dex、ZIP、ELF、EXE等！
解析bmp图片及vc源码
08-31
在VC++环境中，我们可以使用C++语言编写源码来读取和解析BMP文件。基本步骤包括： 1. **打开文件**：使用`fopen`函数打开BMP文件，读取模式。 2. **读取文件头**：跳过DOS头，直接读取Windows头，获取图像的宽、高...
BMP格式介绍
热门推荐
计算机视觉小菜鸟的专栏
03-06 1万+
BMP图片格式；BMP图片，是Bitmap（位图）的简称，它是windows显示图片的基本格式。在windows下，任何格式的图片文件（包括视频播放）都要转化为位图才能显示出来。各种格式的图片文件也都是在位图格式的基础上采用不同的压缩算法生成的。位图文件主要分为如下3个部分：块名称对应Windows结构体定义大小（Byte）文件信息头BITMAPFILEHEADER14位图信息头BITMAPINFOHEADER40RGB颜色阵列BYTE*由图像长宽尺寸决定(1)文件信息头BITMAPFILEHEADER结构
BMP图片文件原始数据分析
guidianhjh的专栏
07-01 1765
按照像素深度分类可以分为：1bit位图(2色)、4bit位图(16色)、8bit位图(256色)、16bit位图(65536色-高彩色)、24bit位图(1670万色-真彩色)、32bit位图(1670万色-增强型真彩色)。用windows自带画图工具，画一张50(宽)x16(高)的BMP图片，填充红绿蓝灰4个颜色，每个颜色4个像素高度，保存成24位位图格式。采用三基色(红R,绿G,蓝B)构成像素的色彩值，通常每个基色占一个字节(十进制 0-255表示，十六进制0x00-0xFF表示)。
编写程序来获取一个bmp图片信息
qq_56683739的博客
10-03 1502
一.基本思路： （1）了解bmp图片的基本格式： （2）打开bmp图片： 对于如何在程序中打开bmp图片，我们可以利用open函数来对bmp图片进行打开操作。 首先我们先了解下open函数的基本参数（我这里只举一个，至于另一个，大家可以通过man对open函数进行查询）。 int open(const char *pathname, int flags); pathname：指定要打开或创建的文件名，带路径（如果不带路径，表示在当前路径）。 flags：打开文件的标志（用位域来实现）。.
BMP图片格式
weixin_30293135的博客
10-10 120
在做基于图像的信息隐藏和提取时， 就要用到BMP图片的相关操作，初学很晕 但是了解了BMP图片的格式之后就可以按照思维来写了 这里记录一篇BMP图片格式详解的博客 链接 （应该没有错误） 转载于:https://www.cnblogs.com/ffgcc/p/10546321.html...
C语言读取bmp图像数据并终端上显示
rdsvdfbfsdfg的博客
10-13 711
1.在写文件头和信息头结构体的时候需要重新设置以字节对齐方式。例如，对于4字节对齐的结构体，在每个成员之间都会有4字节的填充。然而，有些时候我们需要对结构体进行精确的控制，使其占用的内存空间更小或者与其他系统进行交互。对于用到调色版的位图，图像数据就是该像素颜在调色板中的索引值。对于真彩图，图像数据就是实际的R、G、B值。所以采取以下代码进行设置，否则会出现文件头和信息头的总大小为56字节。真彩图像不需要调色版，bitmapInfoHeader后直接是数据。
C++——C++11新语法（中）
最新发布
Wangx_wang的博客
11-06 1025
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
bmp格式图片数据解析
06-13
BMP格式是一种常见的无损位图图像文件格式，以下是BMP格式图片数据解析的步骤： 1. 打开BMP文件，读取文件头信息。BMP文件头包括文件类型、文件大小、保留字1、保留字2、位图数据偏移量等信息。 2. 读取位图信息头...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值