对bmp文件的读写

最新推荐文章于 2022-11-20 19:20:56 发布
最新推荐文章于 2022-11-20 19:20:56 发布
阅读量412 收藏
点赞数
分类专栏： c 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beibei_hao_csdn/article/details/53260010
版权

Read_pic.h文件：

#ifndef _BMP_H_
#define _BMP_H_
#ifdef __cplusplus
extern "C" {
#endif

    typedef enum _BIT_DATA_TYPE_{
        BIT32 = 1,                      //读取或存储成32位
        BIT24 = 2                      //读取或存储成24位
    }BITDATATYPE;

    typedef struct _BMPFILEHEAD_{
        unsigned char   type[2];        //存储 'B' 'M'                    2字节
        unsigned int    size;           //位图文件大小                    4字节
        unsigned short  reserved1;      //保留字                          2字节
        unsigned short  reserved2;      //保留字                          2字节
        unsigned int    offBits;        //位图数据起始位置                4字节
    }BMPHEAD;
    typedef struct _BMPFILEINFOHEAD_{
        unsigned int    selfSize;       //位图信息头的大小                 4字节
        long            bitWidth;       //位图的宽度,以像素为单位          4字节
        long            bitHeight;      //位图的高度,以像素为单位          4字节
        unsigned short  bitPlanes;      //目标设备的级别,必须为1           2字节
        unsigned short  pixelBitCount;  //每个像素所需的位数               2字节
        unsigned int    compression;    //位图压缩类型,0(不压缩)           4字节
        unsigned int    sizeImage;      //位图的大小,以字节为单位          4字节
        long            pixelXPerMeter; //位图的水平分辨率,每米像素数      4字节
        long            pixelYPerMeter; //位图的垂直分辨率,每米像素数      4字节
        unsigned int    colorUsed;      //位图实际使用的颜色表中的颜色数   4字节
        unsigned int    colorImportant; //位图显示过程中重要的颜色数       4字节
    }BMPINFOHEAD;
    typedef struct _IMAGE_{
        int width;
        int height;
        int channels;
        unsigned char * data;
    }IMAGE;

int LoadBMP(const char * file, IMAGE* out_img, BITDATATYPE bit_data_type);
int WriteBMP(const char * file, IMAGE * in_img, BITDATATYPE bit_data_type);
int freeImage(IMAGE * img);
#ifdef __cplusplus
}
#endif

#endif

###########################################################################################

Read_pic.c文件：

#include<stdio.h>
#include"Read_pic.h"

#include <stdlib.h>
#include <memory.h>
#define BMP_SIZE_FILEHEADER 14
#define BMP_SIZE_INFOHEADER 40

#define BMP_COLOR_BITS_24 24
#define BMP_COLOR_BITS_32 32


static unsigned int uInt16Number(unsigned char buf[2]){
    return (buf[1] << 8) | buf[0];
}

static unsigned int uInt32Number(unsigned char buf[4]){
    unsigned numb = buf[3];
    numb = (numb << 8) | buf[2];
    numb = (numb << 8) | buf[1];
    numb = (numb << 8) | buf[0];
    return numb;
}

static void IntTo2Bytes(int val, unsigned char buf[2]){
    buf[0] = (unsigned char)val;
    buf[1] = (unsigned char)(val >> 8);
}

static void IntTo4Bytes(int val, unsigned char buf[4]){
    buf[0] = (unsigned char)val;
    buf[1] = (unsigned char)(val >> 8);
    buf[2] = (unsigned char)(val >> 16);
    buf[3] = (unsigned char)(val >> 24);
}


static int ReadFileHeader(FILE* f, int* bitmap_pos){

    unsigned char header[BMP_SIZE_FILEHEADER];
    BMPHEAD bmp_head;

    int numb = 0;
    int offset = 0;

    if (fseek(f, 0, SEEK_SET))
        return -1;
    //读取bmp head信息
    numb = fread(header, BMP_SIZE_FILEHEADER, 1, f);
    if (numb != 1)
        return -2;
    // 0 - 1
    if (header[0] != 'B' || header[1] != 'M')
        return -3;
    bmp_head.type[0] = header[0];
    bmp_head.type[1] = header[1];

    // 2 - 5
    bmp_head.size = uInt32Number(header + 2);
    // 6 - 7
    // 8 - 9

    // 10 - 13
    offset = uInt32Number(header + 10);
    if(offset != 54)
        return -4;   

    *bitmap_pos  = offset;
    return 0;
}

static int ReadFileInfoHead(FILE* f, IMAGE * img){

    unsigned char header[BMP_SIZE_INFOHEADER];
    BMPINFOHEAD bmp_info_head;

    int numb = 0;

    if (fseek(f, BMP_SIZE_FILEHEADER, SEEK_SET))
        return -1;
    //读取bmp info head信息
    numb = fread(header, BMP_SIZE_INFOHEADER, 1, f);
    if (numb != 1)
        return -2;

    // 14 - 17
    bmp_info_head.selfSize = uInt32Number(header);
    if(bmp_info_head.selfSize != 40)
        return -3;

    // 18 - 21
    bmp_info_head.bitWidth = (long)uInt32Number(header + 4);
    // 22 - 25
    bmp_info_head.bitHeight = (long)uInt32Number(header + 8);
    // 26 - 27
    bmp_info_head.bitPlanes = (unsigned short)uInt16Number(header + 12);
    // 28 - 29
    bmp_info_head.pixelBitCount = (unsigned short)uInt16Number(header + 14);
    // 30 - 33
    bmp_info_head.compression = uInt32Number(header + 16);
    // 34 - 37
    bmp_info_head.sizeImage = uInt32Number(header + 20);
    // 38 - 41
    bmp_info_head.pixelXPerMeter = (long)uInt32Number(header + 24);
    // 42 - 45
    bmp_info_head.pixelYPerMeter = (long)uInt32Number(header + 28);
    // 46 - 49
    bmp_info_head.colorUsed = uInt32Number(header + 32);
    // 50 - 53
    bmp_info_head.colorImportant = uInt32Number(header + 36);

    img->width = bmp_info_head.bitWidth;
    img->height = bmp_info_head.bitHeight;

    return (int)(bmp_info_head.pixelBitCount);
}

int LoadBMP(const char* file, IMAGE* out_img, BITDATATYPE bit_data_type){

    FILE* f;
    int bitmap_pos;
    int n_bits;

    int flErr = 0;

    fopen_s(&f, file, "rb");

    if (!f)
        return -11;

    if (out_img == NULL)
        return -12;

    if (0 > (flErr = ReadFileHeader(f, &bitmap_pos))){
        fclose(f);
        return flErr;
    }

    n_bits = ReadFileInfoHead(f, out_img);

    if(n_bits == BMP_COLOR_BITS_24){
        int rgb_size;
        int rgba_size;
        unsigned char* rgb;
        int y;
        unsigned char* line;
        int rest_4;

        if (fseek(f, bitmap_pos, SEEK_SET)){
            fclose(f);
            return -16;
        }

        rgb_size = 3 * out_img->width;
        rgba_size = 4 * out_img->width;

        rest_4 = rgb_size % 4;
        if (rest_4 > 0)
            rgb_size += 4 - rest_4;

        if(bit_data_type == 1)
        {
            out_img->channels = 4;
            out_img->data = (unsigned char*)malloc(out_img->width * out_img->height *4);

            if (out_img->data == NULL)
                return -17;

            rgb = (unsigned char*)malloc(rgb_size);

            if(NULL == rgb)
                return -18;

            for(y = out_img->height - 1; y >= 0; y --){
                int numb = 0;
                int x = 0;

                numb = fread(rgb, rgb_size, 1, f);
                if (numb != 1){
                    fclose(f);
                    free(rgb);
                    return -19;
                }

                numb = 0;
                line = out_img->data + out_img->width * 4 * y;
                for (x = 0; x < out_img->width ; x++){
                    line[3] = 255;
                    line[2] = rgb[numb++];
                    line[1] = rgb[numb++];
                    line[0]= rgb[numb++];
                    line += 4;
                }
            }
        }else if(bit_data_type == 2)
        {
            out_img->channels = 3;
            out_img->data = (unsigned char*)malloc(out_img->width * out_img->height * 3);

            if (out_img->data == NULL)
                return -17;

            rgb = (unsigned char*)malloc(rgb_size);

            if(NULL == rgb)
                return -18;

            for(y = out_img->height - 1; y >= 0; y --){
                int numb = 0;
                int x = 0;

                numb = fread(rgb, rgb_size, 1, f);
                if (numb != 1){
                    fclose(f);
                    free(rgb);
                    return -19;
                }

                numb = 0;
                line = out_img->data + out_img->width * 3 * y;
                for (x = 0; x < out_img->width ; x++){
                    line[2] = rgb[numb++];
                    line[1] = rgb[numb++];
                    line[0]= rgb[numb++];
                    line += 3;
                }
            }
        }
        fclose(f);
        free(rgb);
    }else if(n_bits == BMP_COLOR_BITS_32)
    {
        int rgba_size;
        unsigned char* rgba;
        int y;
        unsigned char* line;

        if (fseek(f, bitmap_pos, SEEK_SET)){
            fclose(f);
            return -16;
        }

        rgba_size = 4 * out_img->width;
        if(bit_data_type == 1)
        {
            out_img->channels = 4;
            out_img->data = (unsigned char*)malloc(out_img->width * out_img->height * 4);

            if (out_img->data == NULL)
                return -17;

            rgba = (unsigned char*)malloc(rgba_size);

            if(NULL == rgba)
                return -18;

            for (y = out_img->height - 1; y >= 0; y --){
                int numb = 0;
                int x = 0;

                numb = fread(rgba, rgba_size, 1, f);
                if (numb != 1){
                    fclose(f);
                    free(rgba);
                    return -19;
                }

                numb = 0;
                line = out_img->data + out_img->width * 4 * y;
                for (x = 0; x < out_img->width ; x++){
                    line[2] = rgba[numb++];//B
                    line[1] = rgba[numb++];//G
                    line[0] = rgba[numb++];//R
                    line[3]= rgba[numb++];//A
                    line += 4;
                }
            }
        }else if(bit_data_type == 2)
        {
            out_img->channels = 3;
            out_img->data = (unsigned char*)malloc(out_img->width * out_img->height * 3);

            if (out_img->data == NULL)
                return -17;

            rgba = (unsigned char*)malloc(rgba_size);

            if(NULL == rgba)
                return -18;

            for (y = out_img->height - 1; y >= 0; y --){
                int numb = 0;
                int x = 0;

                numb = fread(rgba, rgba_size, 1, f);
                if (numb != 1){
                    fclose(f);
                    free(rgba);
                    return -19;
                }

                numb = 0;
                line = out_img->data + out_img->width * 3 * y;
                for (x = 0; x < out_img->width ; x++){
                    line[2] = rgba[numb++];//B
                    line[1] = rgba[numb++];//G
                    line[0] = rgba[numb++];//R
                    line += 3;
                    numb ++;
                }
            }
        }
        fclose(f);
        free(rgba);
    }
    else{
        return -20;
    }
    return 0;
}

static int WriteFileHeader(FILE* f, IMAGE * in_img, BITDATATYPE bit_data_type)
{
    unsigned char header[BMP_SIZE_FILEHEADER];
    int imgWidth, imgHeight;
    int imageSize;

    int numb = 0;
    int offset = 0;

    if (fseek(f, 0, SEEK_SET))
        return -1;

    header[0] = 'B';
    header[1] = 'M';

    imgWidth = in_img->width;
    imgHeight = in_img->height;

    if(bit_data_type == 1)
    {
        imageSize = imgWidth * 4 * imgHeight + BMP_SIZE_FILEHEADER + BMP_SIZE_INFOHEADER;
    }else if(bit_data_type == 2)
    {
        int rgbSize;
        int rest_4;
        rgbSize = imgWidth * 3;
        rest_4 = rgbSize % 4;
        if (rest_4 > 0)
            rgbSize += 4 - rest_4;
        imageSize = rgbSize * imgHeight + BMP_SIZE_FILEHEADER + BMP_SIZE_INFOHEADER;
    }
    IntTo4Bytes(imageSize, header + 2);
    IntTo4Bytes(0, header + 6);
    IntTo4Bytes((BMP_SIZE_FILEHEADER + BMP_SIZE_INFOHEADER), header + 10);

    //读取bmp head信息
    numb = fwrite(header, BMP_SIZE_FILEHEADER, 1, f);
    if (numb != 1)
        return -2;

    return 0;
}

static int WriteFileInfoHead(FILE* f, IMAGE * in_img, BITDATATYPE bit_data_type){

    unsigned char header[BMP_SIZE_INFOHEADER];
    int imageSize = 0;
    int numb = 0;

    if (fseek(f, BMP_SIZE_FILEHEADER, SEEK_SET))
        return -1;
    // 14- 17
    IntTo4Bytes(BMP_SIZE_INFOHEADER, header);
    // 18 - 21
    IntTo4Bytes(in_img->width, header + 4);
    // 22 - 25
    IntTo4Bytes(in_img->height, header + 8);
    // 26 - 27
    IntTo2Bytes(1, header + 12);
    // 28 - 29
    if(bit_data_type == 1)
    {
        IntTo2Bytes(32, header + 14);
    }else if(bit_data_type == 2)
    {
        IntTo2Bytes(24, header + 14);
    }
    // 30 - 33
    IntTo4Bytes(0, header + 16);
    // 34 - 37
     if(bit_data_type == 1)
    {
        imageSize = in_img->width * 4 * in_img->height;
    }else if(bit_data_type == 2)
    {
        int rgbSize;
        int rest_4;
        rgbSize = in_img->width * 3;
        rest_4 = rgbSize % 4;
        if (rest_4 > 0)
            rgbSize += 4 - rest_4;
        imageSize = rgbSize * in_img->height;
    }
    IntTo4Bytes(imageSize, header + 20);
    // 38 - 41
    IntTo4Bytes(0, header + 24);
    // 42 - 45
    IntTo4Bytes(0, header + 28);
    // 46 - 49
    IntTo4Bytes(0, header + 32);
    // 50 - 53
    IntTo4Bytes(0, header + 36);


    numb = fwrite(header, BMP_SIZE_INFOHEADER, 1, f);
    if (numb != 1)
        return -2;

    return 0;
}
int WriteBMP(const char * file, IMAGE * in_img, BITDATATYPE bit_data_type){
    FILE* f;

    int flErr = 0;

    fopen_s(&f, file, "wb");

    if (!f)
        return -1;

    if (in_img == NULL)
        return -2;

    if (0 != WriteFileHeader(f, in_img, bit_data_type)){
        fclose(f);
        return -3;
    }

    if(0 != WriteFileInfoHead(f, in_img, bit_data_type)){
        fclose(f);
        return -4;
    }


    if(bit_data_type == 2){
        int rgb_size;
        unsigned char * rgb;
        int y;
        unsigned char* line;
        int rest_4;

        rgb_size = 3 * in_img->width;

        rest_4 = rgb_size % 4;
        if (rest_4 > 0)
            rgb_size += 4 - rest_4;


        rgb = (unsigned char *)malloc(rgb_size * in_img->height);

        if (rgb == NULL)
            return -6;

        if(in_img->channels == 4)
        {
            for (y = 0; y < in_img->height; y ++){
                int numb = 0;
                int x = 0;

                numb = in_img->width * 4 * y;
                line = rgb + rgb_size * (in_img->height - y - 1);
                for (x = 0; x < in_img->width; x++){
                    line[2] = in_img->data[numb++];
                    line[1] = in_img->data[numb++];
                    line[0]= in_img->data[numb++];
                    line += 3;
                    numb ++;
                }
            }
        }else if(in_img->channels == 3)
        {
            for (y = 0; y < in_img->height; y ++){
                int numb = 0;
                int x = 0;

                numb = in_img->width * 3 * y;
                line = rgb + rgb_size * (in_img->height - y - 1);
                for (x = 0; x < in_img->width; x++){
                    line[2] = in_img->data[numb++];
                    line[1] = in_img->data[numb++];
                    line[0]= in_img->data[numb++];
                    line += 3;
                }
            }
        }
        if (fseek(f, (BMP_SIZE_FILEHEADER + BMP_SIZE_INFOHEADER), SEEK_SET)){
            fclose(f);
            return -5;
        }
        fwrite(rgb, rgb_size * in_img->height, 1, f);
        fclose(f);
        free(rgb);
    }else if(bit_data_type == 1)
    {
        int rgba_size;
        unsigned char * rgba;
        int y;
        unsigned char* line;
        rgba_size = 4 * in_img->width;


        rgba = (unsigned char *)malloc(rgba_size * in_img->height);

        if (rgba == NULL)
            return -6;

        if(in_img->channels == 4)
        {
            for (y = 0; y < in_img->height; y ++){
                int numb = 0;
                int x = 0;

                numb = in_img->width * 4 * y;
                line = rgba + rgba_size * (in_img->height - y - 1);
                for (x = 0; x < in_img->width; x++){
                    line[2] = in_img->data[numb++];//R
                    line[1] = in_img->data[numb++];//G
                    line[0]= in_img->data[numb++];//B
                    line[3]= in_img->data[numb++];//A
                    line += 4;
                }
            }
        }else if(in_img->channels == 3)
        {
            for (y = 0; y < in_img->height; y ++){
                int numb = 0;
                int x = 0;

                numb = in_img->width * 3 * y;
                line = rgba + rgba_size * (in_img->height - y - 1);
                for (x = 0; x < in_img->width; x++){
                    line[2] = in_img->data[numb++];
                    line[1] = in_img->data[numb++];
                    line[0]= in_img->data[numb++];
                    line[3]= 255;
                    line += 4;
                }
            }
        }
        if (fseek(f, (BMP_SIZE_FILEHEADER + BMP_SIZE_INFOHEADER), SEEK_SET)){
            fclose(f);
            return -5;
        }
        fwrite(rgba, rgba_size * in_img->height, 1, f);
        fclose(f);
        free(rgba);
    }
    else{
        return -20;
    }
    return 0;
}
int freeImage(IMAGE * img){
    if(img == NULL)
    {
        return -1;
    }
    if(img->data != NULL)
    {
        free(img->data);
        img->data = NULL;
        img->width = 0;
        img->height = 0;
    }
    return 0;
}

############################################################

main()：


int main()

{
 IMAGE img;
 IMAGE newImage;
// printf("hello world!");

 unsigned char * des = NULL;

    LoadBMP("hello.bmp", &img, BIT32);

 des = (unsigned char *)malloc(sizeof(char) * img.width * img.height * img.channels);

 //Rotation90Right(img.data, des, img.width,img.height,img.channels);
 //newImage.data = des;
 //newImage.width = img.height;
 //newImage.height = img.width;
 //newImage.channels = img.channels;

 //Rotation180Right(img.data, des, img.width,img.height,img.channels);
 //newImage.data = des;
 //newImage.width = img.width;
 //newImage.height = img.height;
 //newImage.channels = img.channels;

 Rotation270Right(img.data, des, img.width,img.height,img.channels);
 newImage.data = des;
 newImage.width = img.height;
 newImage.height = img.width;
 newImage.channels = img.channels;



 WriteBMP("test-1.bmp",&img,BIT32);
    WriteBMP("translateAfterFormPic.bmp", &newImage, BIT32);
    freeImage(&img);
    system("pause");
 return 0;
}




beibei_hao_csdn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理大作业-BMP文件的读写
weixin_45452278的博客
12-08 4705
数字图像处理-BMP文件的读写一、题目背景二、灰度BMP的读写1.读入lena.bmp文件1.1 编写打印文件头信息与信息头数据的函数2 通过文件内容得到灰度bmp数据信息2.1 打印信息结果3.提取bmp位图数据，另存为 lena.raw, 并通过 photoshop 查看3.1 原理介绍3.2 编写灰度bmp转raw函数3.3 Photoshop查看结果4.读取原始图像左上角1/4 的数据，另存一个 lenas.bmp 图像，在 photoshop 查看4.1 编写裁剪函数4.2 Photoshop查看
BMP格式、读写
马德里小铁匠的铁匠铺
03-17 645
BMP文件数据数据按照从文件头开始的先后顺序分为四个部分： 1、bmp文件头(bmp file header)：提供文件的格式、大小等信息 2、位图信息头(bitmap information)：提供图像数据的尺寸、位平面数、压缩方式、颜色索引等信息 3、调色板(color palette)：可选，如使用索引来表示图像，调色板就是索引与其对应的颜色的映射表 4、位图数据(bitmap data)：就
BMP图像的读写处理
zzjjqq666的博客
03-18 6032
最近一段时间我学习了计算机图像处理这门课程，通过这门课程的学习，我了解到了图片具有灰度和彩色的区别，并且通过具体的代码可以将一些图片数据进行读写与转化。 第一部分：BMP图像的读写 1.BMP图像的读: (1)首先定义BMP文件头和信息头变量BITMAPFILEHEADER bf; //BMP文件头结构体BITMAPINFOHEADER bi; //BMP信息头结构体 (2)创建文件输入流 fp fp=fopen(fileName,“rb”); //fileName为BMP图像文件名 (3)读取信息.
纯C下的读写BMP文件代码
打印/传真嵌入式开发－－张志龙的专栏
10-24 1万+
 纯C代码下读写BMP文件代码，简单易懂。 /**//***************************************************************  Copyright (c) 2007, Shanghai **  **  文件名称：read_write_bmp_with_C.c**  编译:    Visual C++  / ANSI C / I
C/C++读写BMP文件
小裘的博客
10-07 2352
BMP文件格式，C/C++读写BMP文件
BMP文件的读写C代码及文档.rar
09-05
这个压缩包“BMP文件的读写C代码及文档.rar”包含了关于如何使用C语言进行BMP文件读写操作的相关资料，包括一个PDF文档“BMP file format.pdf”和一个名为“readwriteBMP.rar”的源代码压缩包。 BMP文件格式的基础...
bmp文件读写
01-02
bmp文件的读写以及一些基本的操作处理 bool Cex06 3Dlg::readBmp char bmpName { 二进制读方式打开指定的图像文件 FILE fp fopen bmpName "rb" ; if fp 0 return 0; 跳过位图文件头结构...
bmp文件读写操作C代码
09-04
7. **示例代码**：`RWbmpfile.tc`和`RWbmpfile.th`可能是源代码文件和头文件，它们可能包含实现BMP文件读写的函数和相关定义。具体代码细节需要查看这两个文件来获取。 通过理解这些概念并结合提供的源代码，可以...
读写BMP文件
08-26
总结，读写BMP文件涉及对文件结构的理解和数据的转换。理解BMP文件的头部信息和数据组织方式是实现这一功能的关键。无论是否使用调色板，都需要正确处理图像数据的存储和解析，以确保图像的准确显示。在实际应用中，...
C#读写BMP文件测试工程
最新发布
03-23
在本项目"C#读写BMP文件测试工程"中，主要涉及的是使用C#编程语言对位图（BMP）文件进行读取和写入操作。C#是一种面向对象的编程语言，它提供了丰富的类库.NET Framework，其中System.Drawing命名空间下的类可以方便...
BMP文件格式和读写操作
09-01
网上找的关于BMP文件格式的详细描述，以及对BMP文件的读写操作，有VC源代码。
BMP文件读取
08-03
读取.bmp文件源代码，VC++工程
BMP文件的读写和存储
04-15
介绍了如何读BMP文件，可以读出BMP文件的每一部分，并显示出来，此外还实现了BMP文件的反色，并将反色后的文件另存为新图片。
用C语言进行BMP文件的读写
jinkang_zhao的博客
04-09 1260
一个完整的bmp位图文件，可以分为文件信息头，位图信息头和RGB颜色阵列三个部分,文件信息头主要包含“是否是BMP文件”，文件的大小等信息。而位图信息头则主要包含bmp文件的位图宽度，高度，位平面，通道数等信息。而RGB颜色阵列，里面才真正包含我们所需要的bmp位图的像素数据。需要提醒的是，bmp位图的颜色阵列部分，像素数据的存储是以左下角为原点。也就是说，当你打开一个bmp图片并显示在电脑屏幕上
BMP文件格式
04-24 8043
1. 简介位图文件(Bitmap-File，BMP)格式是Windows采用的图像文件存储格式，在Windows环境下运行的所有图像处理软件都支持这种格式。Windows 3.0以前的BMP位图文件格式与显示设备有关，因此把它称为设备相关位图(device-dependent bitmap，DDB)文件格式。Windows 3.0以后的BMP位图文件格式与显示设备无关，因此把这种BMP位图
BMP格式详解
热门推荐
Valineliu
12-12 6万+
BMP（全称Bitmap）是Windows操作系统中的标准图像文件格式，可以分成两类：设备相关位图（DDB）和设备无关位图（DIB），使用非常广。它采用位映射存储格式，除了图像深度可选以外，不采用其他任何压缩，因此，BMP文件所占用的空间很大。BMP文件的图像深度可选lbit、4bit、8bit及24bit。BMP文件存储数据时，图像的扫描方式是按从左到右、从下到上的顺序。由于BMP文件格式是Wi
处理csv、bmp等常用数据分析操作--python
qq_38984928的博客
11-20 849
工作中常用的csv数据分析处理方法，及bmp读写、excel输出数据统计及插图等操作。
BMP文件的读取与写入
zhangyi19930704的专栏
11-12 1926
注：BMP文件格式在这里只做简单介绍，详细介绍可以参看我整理的这个文档点击打开链接 1、BMP文件格式 BMP文件主要包含四个部分：位图文件头，位图信息头，位图调色板，位图数据。 用结构体表示就是： typedef struct tagBITMAP_FILE{ BMPHeader bitmapheader; BMPInfoHeader bitmapin

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值