精华内容
下载资源
问答
  • c语言读取bmp文件

    2016-05-05 15:19:31
    c语言读取bmp文件、vs2010工程
  • C语言读取BMP文件

    2015-02-03 14:09:04
    C语言读取BMP图片并存入工程文件夹中,适用于初学者理解BMP文件的结构和格式。开发环境:VS2010
  • C语言读写BMP文件

    千次阅读 2014-05-14 13:40:57
    参考的是:用C语言进行BMP文件读写 - 计算机视觉小菜鸟的专栏 - 博客频道 - CSDN.NET

    参考的是:用C语言进行BMP文件的读写,以及:BMP格式介绍


    首先是头文件bmp.h:

    #ifndef BMP_H  
    #define BMP_H  
    
    #include <stdio.h>  
    #include <stdlib.h>  
    typedef struct  
    {  
    	//unsigned short    bfType;  
    	unsigned long    bfSize;  
    	unsigned short    bfReserved1;  
    	unsigned short    bfReserved2;  
    	unsigned long    bfOffBits;  
    } ClBitMapFileHeader;  
    
    typedef struct  
    {  
    	unsigned long  biSize;   
    	long   biWidth;   
    	long   biHeight;   
    	unsigned short   biPlanes;   
    	unsigned short   biBitCount;  
    	unsigned long  biCompression;   
    	unsigned long  biSizeImage;   
    	long   biXPelsPerMeter;   
    	long   biYPelsPerMeter;   
    	unsigned long   biClrUsed;   
    	unsigned long   biClrImportant;   
    } ClBitMapInfoHeader;  
    
    typedef struct   
    {  
    	unsigned char rgbBlue; //该颜色的蓝色分量 
    	unsigned char rgbGreen; //该颜色的绿色分量 
    	unsigned char rgbRed; //该颜色的红色分量 
    	unsigned char rgbReserved; //保留值 
    } ClRgbQuad;  
    
    typedef struct  
    {  
    	int width;  
    	int height;  
    	int channels;  
    	unsigned char* imageData;  
    }ClImage;  
    
    ClImage* clLoadImage(const char* path);  
    bool clSaveImage(const char* path, ClImage* bmpImg);  
    
    #endif
    


    其次是各个函数的实现bmp.cpp,主要是clLoadImage(载入)和clSaveImage(保存)这两个函数:
    #include "bmp.h"  
      
    ClImage* clLoadImage(const char* path)  
    {  
        ClImage* bmpImg;  
        FILE* pFile;  
        unsigned short fileType;  
        ClBitMapFileHeader bmpFileHeader;  
        ClBitMapInfoHeader bmpInfoHeader;  
        int channels = 1;  
        int width = 0;  
        int height = 0;  
        int step = 0;  
        int offset = 0;  
        unsigned char pixVal;  
        ClRgbQuad* quad;  
        int i, j, k;  
      
        bmpImg = (ClImage*)malloc(sizeof(ClImage));  
        pFile = fopen(path, "rb");  
        if (!pFile)  
        {  
            free(bmpImg);  
            return NULL;  
        }  
      
        fread(&fileType, sizeof(unsigned short), 1, pFile);  
        if (fileType == 0x4D42)  
        {  
            //printf("bmp file! \n");  
      
            fread(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);  
            /*printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n"); 
            printf("bmp文件头信息:\n"); 
            printf("文件大小:%d \n", bmpFileHeader.bfSize); 
            printf("保留字:%d \n", bmpFileHeader.bfReserved1); 
            printf("保留字:%d \n", bmpFileHeader.bfReserved2); 
            printf("位图数据偏移字节数:%d \n", bmpFileHeader.bfOffBits);*/  
      
            fread(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);  
            /*printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n"); 
            printf("bmp文件信息头\n"); 
            printf("结构体长度:%d \n", bmpInfoHeader.biSize); 
            printf("位图宽度:%d \n", bmpInfoHeader.biWidth); 
            printf("位图高度:%d \n", bmpInfoHeader.biHeight); 
            printf("位图平面数:%d \n", bmpInfoHeader.biPlanes); 
            printf("颜色位数:%d \n", bmpInfoHeader.biBitCount); 
            printf("压缩方式:%d \n", bmpInfoHeader.biCompression); 
            printf("实际位图数据占用的字节数:%d \n", bmpInfoHeader.biSizeImage); 
            printf("X方向分辨率:%d \n", bmpInfoHeader.biXPelsPerMeter); 
            printf("Y方向分辨率:%d \n", bmpInfoHeader.biYPelsPerMeter); 
            printf("使用的颜色数:%d \n", bmpInfoHeader.biClrUsed); 
            printf("重要颜色数:%d \n", bmpInfoHeader.biClrImportant); 
            printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");*/  
      
            if (bmpInfoHeader.biBitCount == 8)  
            {  
                //printf("该文件有调色板,即该位图为非真彩色\n\n");  
                channels = 1;  
                width = bmpInfoHeader.biWidth;  
                height = bmpInfoHeader.biHeight;  
                offset = (channels*width)%4;  
                if (offset != 0)  
                {  
                    offset = 4 - offset;  
                }  
                //bmpImg->mat = kzCreateMat(height, width, 1, 0);  
                bmpImg->width = width;  
                bmpImg->height = height;  
                bmpImg->channels = 1;  
                bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);  
                step = channels*width;  
      
                quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad)*256);  
                fread(quad, sizeof(ClRgbQuad), 256, pFile);  
                free(quad);  
      
                for (i=0; i<height; i++)  
                {  
                    for (j=0; j<width; j++)  
                    {  
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);  
                        bmpImg->imageData[(height-1-i)*step+j] = pixVal;  
                    }  
                    if (offset != 0)  
                    {  
                        for (j=0; j<offset; j++)  
                        {  
                            fread(&pixVal, sizeof(unsigned char), 1, pFile);  
                        }  
                    }  
                }             
            }  
            else if (bmpInfoHeader.biBitCount == 24)  
            {  
                //printf("该位图为位真彩色\n\n");  
                channels = 3;  
                width = bmpInfoHeader.biWidth;  
                height = bmpInfoHeader.biHeight;  
      
                bmpImg->width = width;  
                bmpImg->height = height;  
                bmpImg->channels = 3;  
                bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*3*height);  
                step = channels*width;  
      
                offset = (channels*width)%4;  
                if (offset != 0)  
                {  
                    offset = 4 - offset;  
                }  
      
                for (i=0; i<height; i++)  
                {  
                    for (j=0; j<width; j++)  
                    {  
                        for (k=0; k<3; k++)  
                        {  
                            fread(&pixVal, sizeof(unsigned char), 1, pFile);  
                            bmpImg->imageData[(height-1-i)*step+j*3+k] = pixVal;  
                        }  
                        //kzSetMat(bmpImg->mat, height-1-i, j, kzScalar(pixVal[0], pixVal[1], pixVal[2]));  
                    }  
                    if (offset != 0)  
                    {  
                        for (j=0; j<offset; j++)  
                        {  
                            fread(&pixVal, sizeof(unsigned char), 1, pFile);  
                        }  
                    }  
                }  
            }  
        }  
      
        return bmpImg;  
    }  
      
    bool clSaveImage(const char* path, ClImage* bmpImg)  
    {  
        FILE *pFile;  
        unsigned short fileType;  
        ClBitMapFileHeader bmpFileHeader;  
        ClBitMapInfoHeader bmpInfoHeader;  
        int step;  
        int offset;  
        unsigned char pixVal = '\0';  
        int i, j;  
        ClRgbQuad* quad;  
      
        pFile = fopen(path, "wb");  
        if (!pFile)  
        {  
            return false;  
        }  
      
        fileType = 0x4D42;  
        fwrite(&fileType, sizeof(unsigned short), 1, pFile);  
      
        if (bmpImg->channels == 3)//24位,通道,彩图 
        {  
            step = bmpImg->channels*bmpImg->width;  
            offset = step%4;  
            if (offset != 4)  
            {  
                step += 4-offset;  
            }  
      
            bmpFileHeader.bfSize = bmpImg->height*step + 54;  
            bmpFileHeader.bfReserved1 = 0;  
            bmpFileHeader.bfReserved2 = 0;  
            bmpFileHeader.bfOffBits = 54;  
            fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);  
      
            bmpInfoHeader.biSize = 40;  
            bmpInfoHeader.biWidth = bmpImg->width;  
            bmpInfoHeader.biHeight = bmpImg->height;  
            bmpInfoHeader.biPlanes = 1;  
            bmpInfoHeader.biBitCount = 24;  
            bmpInfoHeader.biCompression = 0;  
            bmpInfoHeader.biSizeImage = bmpImg->height*step;  
            bmpInfoHeader.biXPelsPerMeter = 0;  
            bmpInfoHeader.biYPelsPerMeter = 0;  
            bmpInfoHeader.biClrUsed = 0;  
            bmpInfoHeader.biClrImportant = 0;  
            fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);  
      
            for (i=bmpImg->height-1; i>-1; i--)  
            {  
                for (j=0; j<bmpImg->width; j++)  
                {  
                    pixVal = bmpImg->imageData[i*bmpImg->width*3+j*3];  
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                    pixVal = bmpImg->imageData[i*bmpImg->width*3+j*3+1];  
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                    pixVal = bmpImg->imageData[i*bmpImg->width*3+j*3+2];  
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                }  
                if (offset!=0)  
                {  
                    for (j=0; j<4-offset; j++)  
                    {  
                        pixVal = 0;  
                        fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                    }  
                }  
            }  
        }  
        else if (bmpImg->channels == 1)//8位,单通道,灰度图 
        {  
            step = bmpImg->width;  
            offset = step%4;  
            if (offset != 4)  
            {  
                step += 4-offset;  
            }  
      
            bmpFileHeader.bfSize = 54 + 256*4 + bmpImg->width;  
            bmpFileHeader.bfReserved1 = 0;  
            bmpFileHeader.bfReserved2 = 0;  
            bmpFileHeader.bfOffBits = 54 + 256*4;  
            fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);  
      
            bmpInfoHeader.biSize = 40;  
            bmpInfoHeader.biWidth = bmpImg->width;  
            bmpInfoHeader.biHeight = bmpImg->height;  
            bmpInfoHeader.biPlanes = 1;  
            bmpInfoHeader.biBitCount = 8;  
            bmpInfoHeader.biCompression = 0;  
            bmpInfoHeader.biSizeImage = bmpImg->height*step;  
            bmpInfoHeader.biXPelsPerMeter = 0;  
            bmpInfoHeader.biYPelsPerMeter = 0;  
            bmpInfoHeader.biClrUsed = 256;  
            bmpInfoHeader.biClrImportant = 256;  
            fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);  
      
            quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad)*256);  
            for (i=0; i<256; i++)  
            {  
                quad[i].rgbBlue = i;  
                quad[i].rgbGreen = i;  
                quad[i].rgbRed = i;  
                quad[i].rgbReserved = 0;  
            }  
            fwrite(quad, sizeof(ClRgbQuad), 256, pFile);  
            free(quad);  
      
            for (i=bmpImg->height-1; i>-1; i--)  
            {  
                for (j=0; j<bmpImg->width; j++)  
                {  
                    pixVal = bmpImg->imageData[i*bmpImg->width+j];  
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                }  
                if (offset!=0)  
                {  
                    for (j=0; j<4-offset; j++)  
                    {  
                        pixVal = 0;  
                        fwrite(&pixVal, sizeof(unsigned char), 1, pFile);  
                    }  
                }  
            }  
        }  
        fclose(pFile);  
      
        return true;  
    }
    

    最后测试一下:

    #include "bmp.h"  
    
    const char* fileName1 = "D:\\opencv_pic\\Lena.bmp";
    const char* fileName2 = "D:\\opencv_pic\\Lena - 副本.bmp";
    
    int main(int argc, char* argv[])  
    {  
    	ClImage* img = clLoadImage(fileName1);  
    	bool flag = clSaveImage(fileName2, img);  
    	if(flag)  
    	{
    		printf("save ok...\n");  
    	}
    	else
    	{
    		printf("save failure...\n");
    	}
    	return 0;  
    }  
    
    执行完毕无问题,对比一下两张图片,结果是相同的:



    展开全文
  • //BMP 头typedef struct{char id[2]; //bmp 文件标志 "BM"unsigned long fileSize; //文件大小unsigned long reserved0;unsigned long bitmapDataOffset;unsigned long...

    //BMP 头

    typedef struct

    {

    char id[2];                                   //bmp 文件标志 "BM"

    unsigned long fileSize;                    //文件大小

    unsigned long reserved0;

    unsigned long bitmapDataOffset;

    unsigned long bitmapHeaderSize;

    unsigned long width;                    //图像宽度

    unsigned long height;                   //图像高度

    unsigned short planes;

    unsigned short bitsPerPixel;            //每个像素站多少位

    unsigned long compression;            //是否压缩

    unsigned long bitmapDataSize;

    unsigned long hRes;

    unsigned long vRes;

    unsigned long colors;

    unsigned long importantColors;

    unsigned char palette[256][4];      //调色板数据,24位及以上像素没有该数据

    } BMPHeader_t;

    long GetFileSize(FILE* f)

    {

    long pos = ftell(f);

    fseek(f,0,SEEK_END);

    long len = ftell(f);

    fseek(f,pos,SEEK_SET);

    return len;

    }

    void __stdcall Com_Error(const char *fmt, ... )

    {

    char    com_errorMessage[4096];

    va_list        argptr;

    va_start (argptr,fmt);

    vsprintf (com_errorMessage,fmt,argptr);

    va_end (argptr);

    MessageBox(NULL,com_errorMessage,"错误提示",MB_ICONERROR);

    }

    //*pic 返回 RGBA 类型像素数据,width 返回修正后的宽度,height返回高度

    // name 输入的文件名称

    bool LoadBMP( const char *name, byte **pic, int *width, int *height )

    {

    int        columns, rows, numPixels;

    byte    *pixbuf;

    int        row, column;

    byte    *buf_p;

    byte    *buffer;

    int        length;

    BMPHeader_t bmpHeader;

    byte        *bmpRGBA;

    *pic = NULL;

    // load the file

    FILE* pfile = fopen(name,"rb");

    if(pfile == NULL)

    {

    Com_Error( "LoadBMP: Load BMP files failed (%s)/n", name );

    return false;

    }

    length = GetFileSize(pfile);

    buffer = (byte*) malloc(length*sizeof(byte));

    fread(buffer,1,length,pfile);

    if (!buffer)

    {

    Com_Error( "LoadBMP: Memory alloc failed (%s)/n", name );

    return false;

    }

    buf_p = buffer;

    bmpHeader.id[0] = *buf_p++;

    bmpHeader.id[1] = *buf_p++;

    bmpHeader.fileSize = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.reserved0 = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.bitmapDataOffset = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.bitmapHeaderSize = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.width = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.height = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.planes = ( * ( short * ) buf_p );

    buf_p += 2;

    bmpHeader.bitsPerPixel = ( * ( short * ) buf_p );

    buf_p += 2;

    bmpHeader.compression = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.bitmapDataSize = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.hRes = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.vRes = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.colors = ( * ( long * ) buf_p );

    buf_p += 4;

    bmpHeader.importantColors = ( * ( long * ) buf_p );

    buf_p += 4;

    memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) );

    if ( bmpHeader.bitsPerPixel == 8 )

    buf_p += 1024;

    if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' )

    {

    Com_Error( "LoadBMP: only Windows-style BMP files supported (%s)/n", name );

    return false;

    }

    if ( bmpHeader.fileSize != length )

    {

    Com_Error("LoadBMP: header size does not match file size (%d vs. %d) (%s)/n", bmpHeader.fileSize, length, name );

    return false;

    }

    if ( bmpHeader.compression != 0 )

    {

    Com_Error("LoadBMP: only uncompressed BMP files supported (%s)/n", name );

    return false;

    }

    if ( bmpHeader.bitsPerPixel < 8 )

    {

    Com_Error("LoadBMP: monochrome and 4-bit BMP files not supported (%s)/n", name );

    return false;

    }

    columns = bmpHeader.width;

    rows = bmpHeader.height;

    if(bmpHeader.bitsPerPixel == 24 )

    {

    if( (columns & 3) != 0)                    //检查宽度是否为4倍数           columns = (columns & ~3) + 4;    //修正位图宽度值,对齐到4的倍数,不然图像会变形

    }

    if ( rows < 0 )

    rows = -rows;

    numPixels = columns * rows;

    if ( width )

    *width = columns;

    if ( height )

    *height = rows;

    bmpRGBA = (byte*)malloc( numPixels * 4 );

    *pic = bmpRGBA;

    buf_p = buffer+54;

    for ( row = rows-1; row >= 0; row--)

    {

    pixbuf = bmpRGBA + row*columns*4;

    for ( column = 0; column < columns; column++ )

    {

    unsigned char red, green, blue, alpha;

    int palIndex;

    unsigned short shortPixel;

    switch ( bmpHeader.bitsPerPixel )

    {

    case 8:

    palIndex = *buf_p++;

    *pixbuf++ = bmpHeader.palette[palIndex][2];

    *pixbuf++ = bmpHeader.palette[palIndex][1];

    *pixbuf++ = bmpHeader.palette[palIndex][0];

    *pixbuf++ = 0xff;

    break;

    case 16:

    shortPixel = * ( unsigned short * ) pixbuf;

    pixbuf += 2;

    *pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7;

    *pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2;

    *pixbuf++ = ( shortPixel & ( 31 ) ) << 3;

    *pixbuf++ = 0xff;

    break;

    case 24:

    blue = *buf_p++;

    green = *buf_p++;

    red = *buf_p++;

    *pixbuf++ = red;

    *pixbuf++ = green;

    *pixbuf++ = blue;

    *pixbuf++ = 255;

    break;

    case 32:

    blue = *buf_p++;

    green = *buf_p++;

    red = *buf_p++;

    alpha = *buf_p++;

    *pixbuf++ = red;

    *pixbuf++ = green;

    *pixbuf++ = blue;

    *pixbuf++ = alpha;

    break;

    default:

    Com_Error("LoadBMP: illegal pixel_size '%d' in file '%s'/n", bmpHeader.bitsPerPixel, name );

    return false;

    }

    }

    }

    free(buffer);

    fclose(pfile);

    return true;

    }

    //注意bmp文件是由左到右, 由下到上的循序存储的像素.每个像素颜色顺序为B G R (A) //BMP的行象素是4字节对齐的,不足的补0,比如有个图像每行宽度是63象素,//BMP文件存储时会每行存储64个字节,最后一个字节用0补齐void CDlg::OnPaint()   //测试图像{CPaintDC dc(this);static byte* pic = NULL;static int w,h;if(pic == NULL){    char spath[MAX_PATH];    _getcwd(spath, 200);    strcat(spath,"//res//b0000.bmp");    LoadBMP(spath,&pic,&w,&h);}int i,j;for(j=0;j

    展开全文
  • 关于C语言读取BMP文件

    2019-03-01 19:40:52
    关于图像分割和hough变换(19_03_01学习进度) 之前MATLAB部分遇到一个问题,我在Hough变换完成之后得到的图像需要进一步的...C语言读取BMP文件 以下为按照BMP格式相搭配的读取头文件 /* 位图文件头 (位图头的...

    之前MATLAB部分遇到一个问题,我在Hough变换完成之后得到的图像需要进一步的处理,但是我是通过在之前的图像上用循环遍历添加上点,这样的到的图片使用句柄保存只能得到循环运算之前的原图,暂时没有找到解决方法,就先开始准别C语言的读取BMP文件的方法

    C语言读取BMP文件

    以下为按照BMP格式相搭配的读取头文件

    /* 位图文件头 (位图头的字节数 = 位图文件字节数 - 位图图像数据字节数)*/

    偏移量 域名称 大小 内容
    0000H 文件标识 2 识别位图的类型
    0002H File Size 4 表示文件的大小,单位是B
    0006H Reserved 4 保留信息,用处目前不明只知道必须为0
    000AH Bitmao Data Offset 4 从文件开始到位图数据之间的偏移量

    typedef struct BMP_FILE_HEADER
    {
    WORD bType; // 文件标识符
    DWORD bSize; // 文件的大小
    WORD bReserved1; // 保留值,必须设置为0
    WORD bReserved2; // 保留值,必须设置为0
    DWORD bOffset; // 文件头的最后到图像数据位开始的偏移量
    } BMPFILEHEADER; // 14 字节

    /* 位图信息头 */

    偏移量 域名称 大小 内容
    000EH Bitmap Header Size 4 位图的信息头的长度,一般是28H
    0012H Width 4 位图的宽度,单位是像素
    0016H Height 4 位图的高度,单位是像素
    001AH Planes 4 位图的位面数,肯定是1
    001CH Bit per pixel 2 每个像素的位数,1\4\8\16\24\32,分别表示2的N次方的色位,单色图像默认为1,即只有黑白
    001EH Comression 4 压缩说明,0:不压缩;1:使用8位RLE压缩方式;2:使用4位RLE压缩方式;3:Bitfields-位域存放方式
    0022H Bitmap Data SIze 4 用字节数字表示的位图数据的大小,必须是4的倍数
    0026H HResolution 4 用像素表示水平分辨率
    002AH VResolution 4 用像素表示垂直分辨率
    002EH Colors 4 位图使用的颜色数
    0032H Important Colors 4 指定的重要的颜色数,当数值等于Colors的数值的时候表示所有颜色一样重要

    typedef struct BMP_INFO
    {
    DWORD bInfoSize; // 信息头的大小
    DWORD bWidth; // 图像的宽度
    DWORD bHeight; // 图像的高度
    WORD bPlanes; // 图像的位面数
    WORD bBitCount; // 每个像素的位数
    DWORD bCompression; // 压缩类型
    DWORD bmpImageSize; // 图像的大小,以字节为单位
    DWORD bXPelsPerMeter; // 水平分辨率
    DWORD bYPelsPerMeter; // 垂直分辨率
    DWORD bClrUsed; // 使用的色彩数
    DWORD bClrImportant; // 重要的颜色数
    } BMPINF; // 40 字节

    /* 彩色表:调色板 */

    偏移量 域名称 大小 内容
    ____H Palette N*4 调色板规范,四个字节分别用来描述蓝色、绿色、红色和填充符的数值,在彩色图像的处理中就是各个通道的作用

    typedef struct RGB_QUAD
    {
    WORD rgbBlue; // 蓝色强度
    WORD rgbGreen; // 绿色强度
    WORD rgbRed; // 红色强度
    WORD rgbReversed; // 保留值
    }

    之后就是图像信息数据:

    偏移量 域名称 大小 内容
    ____H Bitmap Data 包含扫描的信息,扫描顺序是从右向左,从上到下
    展开全文
  • c语言读取bmp文件完整版

    万次阅读 多人点赞 2016-06-24 15:43:55
    #include #include /* 定义WORD为两个字节的类型 */ typedef unsigned short WORD;.../* 位图文件头主要是对位图文件的一些描述 位图信息头主要是对位图图像方面信息的描述 */ /*************************** 位图
    #include <stdio.h>
    #include <stdlib.h>
    
    /* 定义WORD为两个字节的类型 */
    typedef unsigned short WORD;
    /* 定义DWORD为四个字节的类型 */
    typedef unsigned long DWORD;
    
    /* 位图文件头主要是对位图文件的一些描述 位图信息头主要是对位图图像方面信息的描述 */
    /*************************** 位图标准信息(54字节) ******************************************/
    /* 位图文件头 (位图头的字节数 = 位图文件字节数 - 位图图像数据字节数)*/
    typedef struct BMP_FILE_HEADER
    {
    	WORD bType;      // 文件标识符 
    	DWORD bSize;     // 文件的大小 
    	WORD bReserved1; // 保留值,必须设置为0  
    	WORD bReserved2; // 保留值,必须设置为0 
    	DWORD bOffset;   // 文件头的最后到图像数据位开始的偏移量 
    } BMPFILEHEADER;     // 14 字节
    
    /* 位图信息头 */
    typedef struct BMP_INFO
    {
    	DWORD bInfoSize;            // 信息头的大小   
    	DWORD bWidth;               // 图像的宽度     
    	DWORD bHeight;              // 图像的高度     
    	WORD bPlanes;               // 图像的位面数   
    	WORD bBitCount;             // 每个像素的位数 
    	DWORD bCompression;         // 压缩类型 
    	DWORD bmpImageSize;         // 图像的大小,以字节为单位 
    	DWORD bXPelsPerMeter;       // 水平分辨率 
    	DWORD bYPelsPerMeter;       // 垂直分辨率 
    	DWORD bClrUsed;             // 使用的色彩数 
    	DWORD bClrImportant;        // 重要的颜色数 
    } BMPINF;            // 40 字节
    
    /* 彩色表:调色板 */
    typedef struct RGB_QUAD 
    {
    	WORD rgbBlue;     // 蓝色强度 
    	WORD rgbGreen;    // 绿色强度 
    	WORD rgbRed;      // 红色强度 
    	WORD rgbReversed; // 保留值 
    } RGBQUAD;
    
    
    int main()
    {
    	int i = sizeof(BMPFILEHEADER);
    	int j = sizeof(long);
    	FILE *fp;                     // 定义一个文件指针
    	BMPFILEHEADER bmpFileHeader;  // 定义一个 BMP 文件头的结构体
    	BMPINF bmpInfo;               // 定义一个 BMP 文件信息结构体 
    
    
    	// "rb" 只读打开一个二进制文件,只允许读数据。'b'指的是让这个库函数以二进制形式打开此文件。
    	// 读取失败会返回空指针,读取成功后,fp 会指向一块具有 bmp 属性的内存,我们可以对这块内存开始操作
    	if((fp = fopen("kilyc.bmp", "rb")) == NULL) // fp = 0x00426aa0
    	{
    		printf("Cann't open the file!\n");
    		return 0;
    	}
    
    	// 让 fp 指向 bmp 文件的开始 
    	// 第 2 个参数是偏移量 第三个参数是文件起始地址 所以此函数执行成功后文件指针会指向文件的开始
    	fseek(fp, 0, SEEK_SET);                            // fp = 0x00426aa0
    
    	// 读取文件信息
    	/*
    		参数1: 读出数据的存放缓冲区
    		参数2: 读取多少个字节的数据
    		参数3: 读取几包这样的数据
    		参数4: 文件指针(源数据)
    	*/
    	fread(&bmpFileHeader, sizeof(BMPFILEHEADER), 1, fp); 
    	
    	fread(&bmpInfo, sizeof(bmpInfo), 1, fp);
    
    
    	// 输出BMP文件的位图文件头的所有信息
    	printf("位图文件头主要是对位图文件的一些描述:BMPFileHeader\n\n");
    	printf("文件标识符 = 0X%X\n", bmpFileHeader.bType);
    	printf("BMP 文件大小 = %d 字节\n", bmpFileHeader.bSize);
    	printf("保留值1 = %d \n", bmpFileHeader.bReserved1);
    	printf("保留值2 = %d \n", bmpFileHeader.bReserved2);
    	printf("文件头的最后到图像数据位开始的偏移量 = %d 字节\n", bmpFileHeader.bOffset);
    
    	// 输出BMP文件的位图信息头的所有信息
    	printf("\n\n位图信息头主要是对位图图像方面信息的描述:BMPInfo\n\n");
    	printf("信息头的大小 = %d 字节\n", bmpInfo.bInfoSize);
    	printf("位图的高度 = %d \n", bmpInfo.bHeight);
    	printf("位图的宽度 = %d \n", bmpInfo.bWidth);
    	printf("图像的位面数(位面数是调色板的数量,默认为1个调色板) = %d \n", bmpInfo.bPlanes); 
    	printf("每个像素的位数 = %d 位\n", bmpInfo.bBitCount);
    	printf("压缩类型 = %d \n", bmpInfo.bCompression);
    	printf("图像的大小 = %d 字节\n", bmpInfo.bmpImageSize);
    	printf("水平分辨率 = %d \n", bmpInfo.bXPelsPerMeter);
    	printf("垂直分辨率 = %d \n", bmpInfo.bYPelsPerMeter);
    	printf("使用的色彩数 = %d \n", bmpInfo.bClrUsed);
    	printf("重要的色彩数 = %d \n", bmpInfo.bClrImportant);
    
    	printf("\n\n\n压缩说明:有0(不压缩),1(RLE 8,8位RLE压缩),2(RLE 4,4位RLE压缩,3(Bitfields,位域存放)");
    
    	fclose(fp);
    
    	while(1);
    
    	return 0;
    
    }
    

    1.本文部分素材来源网络,版权归原作者所有,如涉及作品版权问题,请与我联系删除。

    2.未经原作者允许不得转载本文内容,否则将视为侵权;

    3.转载或者引用本文内容请注明来源及原作者;

    4.对于不遵守此声明或者其他违法使用本文内容者,本人依法保留追究权等。

    下面是我的个人微信公众号,关注【一个早起的程序员】精彩系列文章每天不断。

    展开全文
  • 利用C语言读取BMP文件

    千次阅读 多人点赞 2020-03-09 14:15:24
    文章目录什么是bmp文件1.文件头信息块2.图像描述信息块3.颜色表4.图像数据区编写代码C文件h头文件存储算法 什么是bmp文件 BMP是bitmap的缩写形式,bitmap顾名思义,就是位图也即Windows位图。它一般由4部分组成:...
  • C语言读取BITMAP文件,此源码默认读取当前目录下的1.bmp。可以改成处理其他BMP文件
  • C语言读取BMP文件最关键的是要理解结构体对齐。一般情况下,C语言的结构体在内存中会按照4字节(32位)或者8字节(64位)对齐。BMP文件的数据头结构体按照字节排列,而且不能对齐,所以需要用预编译宏设置不能对齐。...
  • *读取bmp图片信息.cpp *author:王炳华 *运行此文件,在同目录下存放一个名为dog.bmp的图片,格式必须为bmp */ #include #include #define BMPTYPE 19778 bool isBMP(FILE *F); int multiply_2(int i); void ...
  • c语言读取bmp图像c语言读取bmp图像

    热门讨论 2009-04-28 14:07:57
    c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像c语言读取bmp图像
  • BMP文件信息读取并在CMD窗口显示图片 位图的基本格式可以参考其它博客,这里不进行详细说明。 原始图片及文件信息 原始图片可以在网上下载24位颜色的位图,然后用画图工具进行裁剪编辑,为简单起见,我们限定只...
  • 最近尝试了验证BMP文件读取的正确 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /* 定义WORD为两个字节的类型 / typedef unsigned short WORD; / 定义DWORD为四个字节的类型 / typedef ...
  • 匿名用户1级2014-05-16 回答BMP是一种与...由于历史的原因,存在Windows和OS/2两种类型的BMP,目前Windows类型的BMP基本上可是说是事实上的标准,下面均以此类型BMP文件为例,其文件主要由以下3部分组成: (1)文件头...
  • linux C语言读取bmp文件写屏

    千次阅读 2016-05-04 17:45:55
    直接上代码11 int read_bmp(char* name, unsigned char* buff) 12 { 13 Image* image; 14 Rgbquad* quad; 15 Bitmapfileheader* fileheader; 16
  • 本学期的实验之一,看网上许多文章关于读取像素的处理并不是很完整,就放上来一个。 /***************************************************** * usage: *****************************************************/...
  • c语言读取bmp文件格式(转载)

    千次阅读 2007-10-26 14:48:00
    转自http://topameng.spaces.live.com/blog/cns!F962D4854A8233D!325.entryc语言读取bmp文件格式//BMP 头typedef struct{ char id[2]; //bmp 文件标志 "BM" unsigned long fileSize;
  • C语言读取BMP位图文件

    2010-10-14 10:35:08
    C语言读取BMP位图文件 , 用C写的 , 可以读取 BMP 文件的位置 , 方便对图档作修正
  • C语言读取bmp位图文件

    2019-04-10 18:04:19
    bmp位图文件分为文件信息区与数据区两部分,文件信息区又分为文件头,信息头,颜色表三部分。 文件C语言中用结构体BITMAPFILEHEADER表示,其定义如下: typedef struct tagBITMAPFILEHEADER { WORD bfType; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,689
精华内容 2,275
关键字:

c语言读取bmp文件

c语言 订阅