BMP影象的讀取和生成

阿新 • • 發佈：2019-01-01

1. BMP.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

2. LoadBMP.c

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#include "BMP.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;
}

3. main.cpp 測試函式

#include <stdio.h>
#include <stdlib.h>
#include "BMP.h"

int main(void)
{
    IMAGE img;    
    LoadBMP("test002.bmp", &img, BIT24);
    WriteBMP("test003.bmp", &img, BIT24);
    freeImage(&img);
    system("pause");
    return 0;
}

如有疑問可留言

BMP影象的讀取和生成

1. BMP.h #ifndef _BMP_H_ #define _BMP_H_ #ifdef __cplusplus extern "C" { #endif typedef enum _BIT_DATA_TYPE_{ B

python讀取和生成excel檔案

1.用python讀取csv檔案： csv是逗號分隔符格式一般我們用的execl生成的格式是xls和xlsx 直接重新命名為csv的話會報錯： Error: line contains NULL byte 解決方案：出錯原因是直接是把字尾為xls的execl檔案重新命名為csv的正常的要

python影象讀取和儲存方案總結

以下程式中用到的timg.jpg原圖為 1、scipy Scipy是一個高階的科學計算庫，其中misc模組很好用，可以將陣列儲存為圖片，也可以對numpy形式影象陣列靈活處理，比如裁剪圖片某一部分等。 from scipy import misc def main(): im

opencv影象讀取和cv::Mat

1、在opencv的C++ API中，所有的類和函式都在名稱空間cv內定義，可以使用 using namespace cv; 或者是加上字首 cv:: 2、imread讀入影象生成的影象由無符號（unsigned char）構成（OpenCV中為C

python的兩種影象讀取和處理方法

1 skimage庫 from skimage import data_dir,io, data img = data.camera() #讀取data中預先儲存的影象camera #Anaconda 版本參

讀取24位 BMP 影象並生成 JPG 縮圖(一)

//對24位BMP進行解析 if(nbitcount==24){ int npad=(nsizeimage/nheight)-nwidth*3; int ndata[]=new int[nheight*nwidth]; byte

使用IPicture介面讀取和顯示BMP,GIF,JPG,ICO,EMF,WMF影象

很久以來，我都被一個問題困擾。關於程式中顯示影象的問題，我在網路上搜索了很長時間，找到了無數的解決方案，比如分析檔案格式,直接讀取檔案的;用控制元件的(ImgEdit);以及不知道內部實現方法的庫（ImageLoad）。而我找到的方法大都不容易使用，特別是那些直接按位讀

【數字影象處理】C++讀取、旋轉和儲存bmp影象檔案程式設計實現

通過我這些天用C++讀寫bmp影象的經歷，摸索再摸索，終於對bmp檔案的結構、操作有了一定的瞭解，下面就大概介紹bmp圖片純C++的讀取、旋轉和儲存的實現過程。有幾點需要注意的是：在讀取bmp圖片的時候，一定要注意記憶體對齊的問題，譬如檔案頭，否則無法讀取出正確結果。

opencv對於bmp影象畫素值的讀取和賦值

#include <stdio.h> #include <cv.h> #include <highgui.h> void main(){ IplImage *img=cvLoadImage("c://fruitfs.bmp",1

利用反射與dom4j讀取javabean生成對應XML和讀取XML得到對應的javabean物件集合

首先實現生成對應的JAVAbean的XML檔案方法 /** * DMO4J寫入XML * @param obj 泛型物件 * @param entityPropertys 泛型物件的List集合 * @param Encode

影象畫素點讀取和賦值

//取IplImage影象畫素值 int main() { IplImage* src = cvLoad("filename",0); //-1預設讀取原通道，0 灰度圖，1彩色圖 if(src!=0) &nb

macOS python3 opencv 讀取和寫入影象

python opencv 影象讀取寫入 1，讀取和寫入影象 1，讀取和寫入影象 #! /usr/local/bin/python3 # coding:utf-8 import cv2 #讀取影象 img = cv2.imread("/U

24位bmp影象的資料讀取&儲存

24位bmp檔案的讀取&儲存我採用的方法是將影象檔案讀取，儲存到一維陣列中，以便後期的操作。 void checkFileExist(FILE * fpbmp) { //開啟圖片檔案按照二進位制讀取

利用Python PIL cPickle讀取和儲存影象資料庫

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

C#不用ArcEngine，生成Shp檔案(五)---------讀取.shx檔案和生成.shx檔案

這一篇來寫一下.shx檔案的讀取跟生成。測試資料下載地址為:http://download.csdn.net/detail/gis0911178/9650967 在第一篇時候有介紹. 索引檔案（.shx）主要包含座標檔案的索引資訊，檔案中每個記錄包含對應的座標檔案記錄距離座標檔案的檔案頭的偏

讀取BMP影象每一畫素點RGB資料

對於24位bmp圖片，每一個畫素點存放著此點的RGB值。首先定義一個結構體，包含紅（red）、綠（green）、藍（blue）這三個欄位，如下： //畫素顏色值 typedef struct tagPOINT{ BYTE b; BYTE g; BYTE

Matlab讀取和顯示影象

Matlab影象讀取： f=imread(‘imgName.extend’) imgName——影象名 extend———影象格式字尾名如何檢視f對應引數： whos f; 影象顯示： imshow(f);——–預設灰度級數256 imshow

opencv 影象讀取顯示和畫素操作

從今天起，開始從頭系統學習下opencv，下面記錄下影象的基本操作： 1. 影象的讀取和顯示 Mat image = imread(imagePath, 1); 第二個引數表示圖片讀入的方式（

使用Excel的VBA來讀取和修改bmp點陣圖畫素資料

很明顯，需要使用VBA程式碼了。選擇一個8位或者24位的bmp點陣圖來開啟。上圖是一個8位點陣圖的畫素資料。上圖是一個24位點陣圖的畫素資料，由於該24位點陣圖會灰色的點陣圖，所以，RGB的值是一樣的。【更多文章】

BMP影象的結構及讀寫和灰度化

1.文件目的本文件主要給出24位真彩BMP影象的結構、讀寫和灰度化方法。 2．一般BMP影象的結構一般的bmp檔案的結結構主要包括檔案頭，BMP資訊頭，調色盤，點陣圖資料內容 (1)BMP檔案頭(14位元組) ,檔案的第0位元組到第13位元組為BMP影象的檔案

BMP影象的讀取和生成

相關推薦