C++实现24位真彩BMP图平移，镜像，旋转90、180度

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/SakuraMashiro/article/details/78392807

一、BMP文件格式解析
BMP文件格式，又称为Bitmap（位图）或是DIB(Device-Independent Device，设备无关位图)，是Window系统中广泛使用的图像文件格式。由于它可以不作任何变换地保存图像像素域的数据，因此成为我们取得RAW数据的重要来源。Windows的图形用户界面（graphical user interfaces）也在它的内建图像子系统GDI中对BMP格式提供了支持。
BMP文件总体上由4部分组成，分别是位图文件头、位图信息头、调色板和图像数据，如表5-1所示。
表5-1 BMP文件的组成结构
位图文件头（bitmap-file header） 大小： 14个字节
位图信息头（bitmap-information header） 大小： 40个字节
彩色表/调色板（color table） 大小： 由颜色索引数决定
位图数据（bitmap-data） 大小： 由图像尺寸决定
下面来详细看一下每个组成部分的细节。
1．位图文件头（bitmap-file header）
位图文件头（bitmap-file header）包含了图像类型、图像大小、图像数据存放地址和两个保留未使用的字段。
打开WINGDI.h文件，搜索”BITMAPFILEHEADER”就可以定位到BMP文件的位图文件头的数据结构定义。
typedef struct tagBITMAPFILEHEADER {
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits;
} BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;
表5-2列出了tagBITMAPFILEHEADER中各字段的含义。
表5-2 tagBITMAPFILEHEADER结构
字 段 名 大小（单位：字节） 描 述
bfType 2 位图类别，根据不同的操作
系统而不同，在Windows
中，此字段的值总为‘BM’
bfSize 4 BMP图像文件的大小
bfReserved1 2 总为0
bfReserved2 2 总为0
bfOffBits 4 BMP图像数据的地址

2．位图信息头（bitmap-information header）
位图信息头（bitmap-information header）包含了位图信息头的大小、图像的宽高、图像的色深、压缩说明图像数据的大小和其他一些参数。
打开WINGDI.h文件，搜索”tagBITMAPINFOHEADER”就可以定位到BMP文件的位图信息头的数据结构定义。
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;
表5-3列出了tagBITMAPFILEHEADER中各字段的含义。
表5-3 tagBITMAPFILEHEADER结构
字 段 名 大小
（单位：
字节） 描 述
biSize 4 本结构的大小，根据不同的操作系统而不同，在Windows中，此字段的值总为28h字节=40字节
biWidth 4 BMP图像的宽度，单位像素
biHeight 4 总为0
biPlanes 2 总为0
biBitCount 2 BMP图像的色深，即一个像素用多少位表示，常见有1、4、8、16、24和32，分别对应单色、16色、256色、16位高彩色、24位真彩色和32位增强型真彩色
biCompression 4 压缩方式，0表示不压缩，1表示RLE8压缩，2表示RLE4压缩，3表示每个像素值由指定的掩码决定
biSizeImage 4 BMP图像数据大小，必须是4的倍数，图像数据大小不是4的倍数时用0填充补足
biXPelsPerMeter 4 水平分辨率，单位像素/m
biYPelsPerMeter 4 垂直分辨率，单位像素/m
biClrUsed 4 BMP图像使用的颜色，0表示使用全部颜色，对于256色位图来说，此值为100h=256
biClrImportant 4 重要的颜色数，此值为0时所有颜色都重要，对于使用调色板的BMP图像来说，当显卡不能够显示所有颜色时，此值将辅助驱动程序显示颜色
3．彩色表/调色板（color table）
彩色表/调色板（color table）是单色、16色和256色图像文件所特有的，相对应的调色板大小是2、16和256，调色板以4字节为单位，每4个字节存放一个颜色值，图像 的数据是指向调色板的索引。
可以将调色板想象成一个数组，每个数组元素的大小为4字节，假设有一256色的BMP图像的调色板数据为：
调色板[0]=黑、调色板[1]=白、调色板[2]=红、调色板[3]=蓝…调色板[255]=黄
图像数据01 00 02 FF表示调用调色板[1]、调色板[0]、调色板[2]和调色板[255]中的数据来显示图像颜色。
在早期的计算机中，显卡相对比较落后，不一定能保证显示所有颜色，所以在调色板中的颜色数据应尽可能将图像中主要的颜色按顺序排列在前面，位图信息 头的biClrImportant字段指出了有多少种颜色是重要的。
每个调色板的大小为4字节，按蓝、绿、红存储一个颜色值。
打开WINGDI.h文件，搜索”tagRGBTRIPLE”就可以定位到BMP文件的调色板的数据结构定义。
typedef struct tagRGBQUAD {
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
表5-4列出了tagRGBTRIPLE中各字段的含义。
表5-4 tagRGBTRIPLE结构
字 段 名 大小（单位：字节） 描 述
rgbBlue 1 蓝色值
rgbGreen 1 绿色值
rgbRed 1 红色值
rgbReserved 1 保留，总为0
4．位图数据（bitmap-data）
如果图像是单色、16色和256色，则紧跟着调色板的是位图数据，位图数据是指向调色板的索引序号。
如果位图是16位、24位和32位色，则图像文件中不保留调色板，即不存在调色板，图像的颜色直接在位图数据中给出。
16位图像使用2字节保存颜色值，常见有两种格式：5位红5位绿5位蓝和5位红6位绿5位蓝，即555格式和565格式。555格式只使用了15 位，最后一位保留，设为0。
24位图像使用3字节保存颜色值，每一个字节代表一种颜色，按红、绿、蓝排列。
32位图像使用4字节保存颜色值，每一个字节代表一种颜色，除了原来的红、绿、蓝，还有Alpha通道，即透明色。
如果图像带有调色板，则位图数据可以根据需要选择压缩与不压缩，如果选择压缩，则根据BMP图像是16色或256色，采用RLE4或RLE8压缩算 法压缩。
RLE4是压缩16色图像数据的，RLE4采用表5-5所示方式压缩数据。

二、C++实现
1.在CodeBlocks中新建项目
新建Bitmap类和头文件

头文件中的声明

#ifndef BMPFILE_H
#define BMPFILE_H

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<cstring>
using namespace std;

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int DWORD;

//位图文件头定义
typedef struct tagBITMAPFILEHEADER {
//  WORD bfType;//单独读取，结构体中就不定义了
    DWORD bfSize;//文件大小
    WORD bfReserved1;//保留字
    WORD bfReserved2;//保留字
    DWORD bfOffBits;//从文件头到实际位图数据的偏移字节数
} BITMAPFILEHEADER;

//位图信息头定义
typedef struct tagBITMAPINFOHEADER {
    DWORD biSize;//信息头大小
    DWORD biWidth;//图像宽度
    DWORD biHeight;//图像高度
    WORD biPlanes;//位平面数
    WORD biBitCount;//每像素位数
    DWORD biCompression;//压缩类型
    DWORD biSizeImage;//压缩图像大小字节数
    DWORD biXPelsPerMeter;//水平分辨率
    DWORD biYPelsPerMeter;//垂直分辨率
    DWORD biClrUsed;//位图实际用到的色彩数
    DWORD biClrImportant;//本位图中重要的色彩数
} BITMAPINFOHEADER;

//像素信息
typedef struct tagIMAGEDATA
{
    BYTE blue;
    BYTE green;
    BYTE red;
} DATA;

class BmpFile
{
    public:
        BmpFile();
        virtual ~BmpFile();
        void translation(int x, int y);
        void mirror(char axis);
        void clone(char* filePath);
        void rotate90();
        void rotate180();
        void readfile(char* filePath);
        int getPSize();
    protected:
    private:
        BITMAPFILEHEADER strHead;
        BITMAPINFOHEADER strInfo;
        int h, w, pSize;
        int mW, mSize;

        WORD bfType;
        DATA* src;

};

#endif // BMPFILE_H

对BMP位图镜像，平移，旋转等操作，实际是就是对位图数据那部分的像素矩阵进行操作，可以使用两个二维数组，保存变换前后的状态，观察总的像素值是否变化，24位真彩图的像素数 = 总的字节数/3 ， 因为每个像素需要用24位二进制来表示，也就是3个字节。计算变换后的宽和高，以及像素的变化规律。

BmpFile.cpp中方法的实现

#include "BmpFile.h"

int BmpFile::getPSize(){
    return pSize;

}

//从指定路径读取BMP位图
void BmpFile::readfile(char* filePath){
    FILE *fpi;
    fpi = fopen(filePath, "rb");
    if (fpi != NULL) {
        //先读取文件类型
        fread(&bfType, 1, sizeof(WORD), fpi);
        if (0x4d42 != bfType) {
            cout << "Error:The file is not a bmp image" << endl;

        }
        //读取bmp文件的文件头和信息头
        fread(&strHead, 1, sizeof(tagBITMAPFILEHEADER), fpi);
        fread(&strInfo, 1, sizeof(tagBITMAPINFOHEADER), fpi);
        //获取图像的宽度，以像素为单位
        h = strInfo.biHeight;
        //获取图像的高度，以像素为单位
        w = strInfo.biWidth;
        //每一行像素的字节数必须是4的整数倍，不足用0补齐
        if (w % 4 == 0) {
            mW = w;
        }
        else {
            mW = (w / 4 + 1) * 4;
        }
        //判断图片是否损坏
        if (h*mW * 3 != strInfo.biSizeImage) {
            cout<<"Error: image broken!"<<endl;

        }
        //获得图片的像素数
        pSize = strInfo.biSizeImage / 3;

        //初始化原始图片的像素数组
        src = new DATA[pSize];
        //读取bmp数据信息
        fread(src, 1, sizeof(DATA)*pSize, fpi);
        fclose(fpi);
}
}

//平移
void BmpFile::translation(int x, int y){
    int moveX, moveY;
    if (x % 4 == 0)
        moveX = x;
    else
        moveX = x / 4 * 4;
    moveY = y;
    int newH = h + moveY;
    int newW = mW + moveX;
    int newSize = newH * newW;
    DATA* target = new DATA[newSize];
    memset(target, 0, sizeof(DATA)*newSize);
    for (int i = 0; i < newH; i++) {
        for (int j = 0; j < newW; j++) {
            if (i < moveY) {
                target[i*newW + j].red = 255;
                target[i*newW + j].blue = 255;
                target[i*newW + j].green = 255;
                continue;
            }
            if (j < moveX) {
                target[i*newW + j].red = 255;
                target[i*newW + j].blue = 255;
                target[i*newW + j].green = 255;
            }
            else {
                target[i*newW + j] = src[(i - moveY)*mW + (j - moveX)];
            }
        }
    }
    FILE *fpo1;
    fpo1 = fopen("C:\\Users\\Administrator\\Desktop\\translation.bmp", "wb");
    BITMAPFILEHEADER newHead = strHead;
    BITMAPINFOHEADER newInfo = strInfo;
    newHead.bfSize = (DWORD)(newHead.bfSize - pSize * 3 + newSize * 3);
    newInfo.biHeight = (DWORD)newH;
    newInfo.biWidth = (DWORD)newW;
    newInfo.biSizeImage = (DWORD)(newSize * 3);
    fwrite(&bfType, 1, sizeof(WORD), fpo1);
    fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
    fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
    fwrite(target, 1, sizeof(DATA)*(newSize), fpo1);
    fclose(fpo1);
    delete[] target;


}

//镜像
void BmpFile::mirror(char axis){

    DATA* target = new DATA[pSize];
    memset(target, 0, sizeof(DATA) * pSize);

    if (axis == 'y') {
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < mW; j++) {
                target[i*mW + j] = src[i*mW + mW - 1 - j];
            }
        }
    }
    else {
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < mW; j++) {
                target[i*mW + j] = src[(h - 1 - i)*mW + j];
            }
        }
    }
    FILE *fpo1;
    fpo1 = fopen("C:\\Users\\Administrator\\Desktop\\mirror.bmp", "wb");
    fwrite(&bfType, 1, sizeof(WORD), fpo1);
    fwrite(&strHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
    fwrite(&strInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
    fwrite(target, 1, sizeof(DATA)*(pSize), fpo1);
    fclose(fpo1);
    delete[] target;

}


//复制
void BmpFile::clone(char* filePath){

    DATA* target = new DATA[pSize];
    memset(target, 0, sizeof(DATA)*pSize);
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < mW; j++) {

          target[i*mW + j] = src[i*mW + j];

        }
    }
    FILE *fpo1;
    fpo1 = fopen(filePath, "wb");
    BITMAPFILEHEADER newHead = strHead;
    BITMAPINFOHEADER newInfo = strInfo;
    newHead.bfSize = (DWORD)(newHead.bfSize);
    newInfo.biHeight = (DWORD)h;
    newInfo.biWidth = (DWORD)mW;
    newInfo.biSizeImage = (DWORD)(pSize * 3);
    fwrite(&bfType, 1, sizeof(WORD), fpo1);
    fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
    fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
    fwrite(target, 1, sizeof(DATA)*(pSize), fpo1);
    fclose(fpo1);
    cout<<" success"<<endl;
    delete[] target;

}

//旋转90度
void BmpFile::rotate90(){
    DATA* target = new DATA[pSize];
    memset(target, 0, sizeof(DATA)*pSize);
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < mW; j++) {

            target[j*h + (h-1-i)] = src[i*mW + j];

        }
    }
    FILE *fpo1;
    fpo1 = fopen("C:\\Users\\Administrator\\Desktop\\rotate90.bmp", "wb");
    BITMAPFILEHEADER newHead = strHead;
    BITMAPINFOHEADER newInfo = strInfo;
    newHead.bfSize = (DWORD)(newHead.bfSize);
    newInfo.biHeight = (DWORD)mW;
    newInfo.biWidth = (DWORD)h;
    newInfo.biSizeImage = (DWORD)(pSize * 3);
    fwrite(&bfType, 1, sizeof(WORD), fpo1);
    fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
    fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
    fwrite(target, 1, sizeof(DATA)*(pSize), fpo1);
    fclose(fpo1);
    cout<<"success"<<endl;
    delete[] target;

};

//旋转180度
void BmpFile::rotate180(){
    DATA* target = new DATA[pSize];
    memset(target, 0, sizeof(DATA)*pSize);
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < mW; j++) {

            target[(h-1-i)*mW + (mW-j-1)] = src[i*mW + j];

        }
    }
    FILE *fpo1;
    fpo1 = fopen("C:\\Users\\Administrator\\Desktop\\rotate180.bmp", "wb");
    BITMAPFILEHEADER newHead = strHead;
    BITMAPINFOHEADER newInfo = strInfo;
    newHead.bfSize = (DWORD)(newHead.bfSize);
    newInfo.biHeight = (DWORD)h;
    newInfo.biWidth = (DWORD)mW;
    newInfo.biSizeImage = (DWORD)(pSize * 3);
    fwrite(&bfType, 1, sizeof(WORD), fpo1);
    fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
    fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
    fwrite(target, 1, sizeof(DATA)*(pSize), fpo1);
    fclose(fpo1);
    cout<<"success"<<endl;
    delete[] target;

};

main.cpp中测试

#include"BmpFile.h"
using namespace std;


int main() {

        //初始化BMP文件类
        BmpFile *bmp = new BmpFile();

        //指定图片路径
        char filePath[] = "C:\\Users\\Administrator\\Desktop\\input.bmp";

        //从指定路径读取图片
        bmp->readfile(filePath);

        cout << "clone the bmp" << endl;

        //复制一张图片至指定路径
        bmp->clone(filePath);

        cout<<"rotate90"<<endl;

        //旋转90度
        bmp->rotate90();

        cout<<"rotate180"<<endl;
        //旋转180度
        bmp->rotate180();

        //向右上方平移
        int x, y;
        cout << "Translation, input the X(0<X<400): ";
        cin >> x;
        cout << "Translation, input the Y(0<Y<400): ";
        cin >> y;
        bmp->translation(x, y);

        //镜像
        char axis;
        cout << "Mirror, according to X axis or Y axis? (x or y): ";
        cin >> axis;
        bmp->mirror(axis);



    return 0;
}

如果缩放的话，可以借助双线性插值方法计算缩放后非整数位置部分像素的值，这里就不多说了。