Creating BMP in pure C++

Question

Thank you for help. This is the final version. Working version

BMPHead.znak1='B';
BMPHead.znak2='M';
BMPHead.bfSize=40;
BMPHead.bfReserved1 = 0;
BMPHead.bfReserved1 = 0;
BMPHead.bfOffBits=54;
BMPHead.biSize=40;
BMPHead.biWidth=CSVHead.depth_pxsize ;
BMPHead.biHeight=CSVHead.lateral_pxsize;
BMPHead.biPlanes=1;
BMPHead.biBitCount=32;
BMPHead.biCompression = 0;
BMPHead.biSizeImage = ((CSVHead.lateral_pxsize * CSVHead.depth_pxsize)*4);
BMPHead.biXPelsPerMeter = 0;
BMPHead.biYPelsPerMeter = 0;
BMPHead.biClrUsed = 0;
BMPHead.biClrImportant =0;



void zamiana_danych(int &EndOfHead, float line[], csvh &CSVHead, bmph BMPHead, float &max, float &min)
{   unsigned char bit_empty=0;
    float tmp[500];
    ifstream obraz;
    fstream bitmapa("POP_OCT.bmp");
    obraz.open("POP_OCT.csv", ios::binary);
    obraz.seekg(EndOfHead, ios_base::beg);
    bitmapa.seekg(BMPHead.bfOffBits, ios_base::beg); // this part was missing
    for( int numb=0; numb < CSVHead.depth_pxsize; numb++ )
        {
        //wczytanie jednego wiersza dancyh
        for(int i=0; i<CSVHead.lateral_pxsize; i++)
            { //wczytanie komorki danych
                obraz>>line[i];
                obraz.seekg(+1, ios_base::cur);
                tmp[i]=((max-min) / 255) * line[i] - min;
                unsigned char pixel[4]={tmp[i],tmp[i],tmp[i],0};
                bitmapa.write((char*)&pixel, sizeof(pixel));
            }
        }
      bitmapa.close();
      obraz.close();

Question I need to create BMP in C++ without using nonstandard libraries, but I still have some errors. I know there are some similiar topics, but it's still not clear for me how to make this thing working.

File is created, but when I try to open it, photo browser says:

"Windows Image Viewer can not open the image, because the file is too big or broken".

I'm not sure if the problem is in header or in pixel writing.

That's the code:

#include<iostream>
#include<fstream>
#include<cstring>
#include <stdlib.h>
using namespace std;


struct bmph{
unsigned short int bfType; // instead of this I use znak1 and znak2
unsigned long int bfSize;
unsigned short int bfReserved1;
unsigned short int bfReserved2;
unsigned long int bfOffBits;
unsigned long int biSize;
unsigned long int biWidth;
unsigned long int biHeight;
unsigned short int biPlanes;
unsigned short int biBitCount;
unsigned long int biCompression;
unsigned long int biSizeImage;
unsigned long int biXPelsPerMeter;
unsigned long int biYPelsPerMeter;
unsigned long int biClrUsed;
unsigned long int biClrImportant;
};


int main()
{
unsigned char pixel[4]={255,255,255,0};
char znak1='B';
char znak2='M';
bmph bmpheader;

ofstream moje_bmp("tworzBMP.bmp");

bmpheader.bfSize=40 + (500*999)*4;
bmpheader.bfReserved1 = 0;
bmpheader.bfReserved1 = 0;
bmpheader.bfOffBits=54;
bmpheader.biSize=40;
bmpheader.biWidth=500;
bmpheader.biHeight=999;
bmpheader.biPlanes=1;
bmpheader.biBitCount=4;
bmpheader.biCompression = 0;
bmpheader.biSizeImage = (500*999)*4;
bmpheader.biXPelsPerMeter = 0;
bmpheader.biYPelsPerMeter = 0;
bmpheader.biClrUsed = 0;
bmpheader.biClrImportant =0;


moje_bmp << znak1 <<znak2;
moje_bmp.write((char*)&bmpheader.bfSize, sizeof(bmpheader.bfSize));
moje_bmp.write((char*)&bmpheader.bfReserved1, sizeof(bmpheader.bfReserved1));
moje_bmp.write((char*)&bmpheader.bfReserved1, sizeof(bmpheader.bfReserved1));
moje_bmp.write((char*)&bmpheader.bfOffBits, sizeof(bmpheader.bfOffBits));
moje_bmp.write((char*)&bmpheader.bfSize, sizeof(bmpheader.bfSize));
moje_bmp.write((char*)&bmpheader.biWidth, sizeof(bmpheader.biWidth));
moje_bmp.write((char*)&bmpheader.biHeight, sizeof(bmpheader.biHeight));
moje_bmp.write((char*)&bmpheader.biPlanes, sizeof(bmpheader.biPlanes));
moje_bmp.write((char*)&bmpheader.biBitCount, sizeof(bmpheader.biBitCount));
moje_bmp.write((char*)&bmpheader.biCompression, sizeof(bmpheader.biCompression));
moje_bmp.write((char*)&bmpheader.biSizeImage, sizeof(bmpheader.biSizeImage));
moje_bmp.write((char*)&bmpheader.biXPelsPerMeter, sizeof(bmpheader.biXPelsPerMeter));
moje_bmp.write((char*)&bmpheader.biYPelsPerMeter, sizeof(bmpheader.biYPelsPerMeter));
moje_bmp.write((char*)&bmpheader.biClrUsed, sizeof(bmpheader.biClrUsed));
moje_bmp.write((char*)&bmpheader.biClrImportant, sizeof(bmpheader.biClrImportant));

   for(int tx=0; tx<500;tx++)
        {
                for(int ty=0; ty<999;ty++)
                {
                   moje_bmp.write((char*)&pixel, sizeof(pixel));
                }
        }
moje_bmp.close();
return 0;
}

As all of it worked in the example above, in my main project it does not. Here are the functions from main project and the same result: "Windows Image Viewer can not open the image, because the file is too big or broken".

void glowa_bmp(bmph &BMPHead, csvh &CSVHead)
{
ofstream bitmapa("bitmapa.bmp", ios::binary);

//przypisanie wartosci naglowka
BMPHead.znak1='B';
BMPHead.znak2='M';
BMPHead.bfSize=54;
BMPHead.bfReserved1 = 0;
BMPHead.bfReserved1 = 0;
BMPHead.bfOffBits=54;
BMPHead.biSize=40;
BMPHead.biWidth=CSVHead.depth_pxsize ;
BMPHead.biHeight=CSVHead.lateral_pxsize;
BMPHead.biPlanes=1;
BMPHead.biBitCount=32;
BMPHead.biCompression = 0;
BMPHead.biSizeImage = ((CSVHead.lateral_pxsize * CSVHead.depth_pxsize)*4);
BMPHead.biXPelsPerMeter = 0;
BMPHead.biYPelsPerMeter = 0;
BMPHead.biClrUsed = 0;
BMPHead.biClrImportant =0;

//zapisanie naglowka w pliku
bitmapa << BMPHead.znak1 << BMPHead.znak2;
bitmapa.write((char*)&BMPHead.bfSize, sizeof(BMPHead.bfSize));
bitmapa.write((char*)&BMPHead.bfReserved1, sizeof(BMPHead.bfReserved1));
bitmapa.write((char*)&BMPHead.bfReserved1, sizeof(BMPHead.bfReserved1));
bitmapa.write((char*)&BMPHead.bfOffBits, sizeof(BMPHead.bfOffBits));
bitmapa.write((char*)&BMPHead.bfSize, sizeof(BMPHead.bfSize));
bitmapa.write((char*)&BMPHead.biWidth, sizeof(BMPHead.biWidth));
bitmapa.write((char*)&BMPHead.biHeight, sizeof(BMPHead.biHeight));
bitmapa.write((char*)&BMPHead.biPlanes, sizeof(BMPHead.biPlanes));
bitmapa.write((char*)&BMPHead.biBitCount, sizeof(BMPHead.biBitCount));
bitmapa.write((char*)&BMPHead.biCompression, sizeof(BMPHead.biCompression));
bitmapa.write((char*)&BMPHead.biSizeImage, sizeof(BMPHead.biSizeImage));
bitmapa.write((char*)&BMPHead.biXPelsPerMeter,      sizeof(BMPHead.biXPelsPerMeter));
bitmapa.write((char*)&BMPHead.biYPelsPerMeter, sizeof(BMPHead.biYPelsPerMeter));
bitmapa.write((char*)&BMPHead.biClrUsed, sizeof(BMPHead.biClrUsed));
bitmapa.write((char*)&BMPHead.biClrImportant, sizeof(BMPHead.biClrImportant));

bitmapa.close();
}




void zamiana_danych(int &EndOfHead, float line[], csvh &CSVHead, float &max, float &min)
{   unsigned char bit_empty=0;
    float tmp[500];
    ifstream obraz;
    ofstream bitmapa("bitmapa.bmp", ios::binary);
    obraz.open("POP_OCT.csv", ios::binary);
    obraz.seekg(EndOfHead, ios_base::beg);
    for( int numb=0; numb < CSVHead.depth_pxsize; numb++ )
        {
        //wczytanie jednego wiersza dancyh
        for(int i=0; i<CSVHead.lateral_pxsize; i++)
            { //wczytanie komorki danych
                obraz>>line[i];
                obraz.seekg(+1, ios_base::cur);
                tmp[i]=((max-min) / 255) * line[i] - min;
                unsigned char pixel[4]={tmp[i],tmp[i],tmp[i],0};
                bitmapa.write((char*)&pixel, sizeof(pixel));
            }
        }
      bitmapa.close();
      obraz.close();
}

Answer 1

bmpheader.bfSize=40 + (500*999)*4;

You need to add 54 instead of 40:

• BITMAPFILEHEADER: 14
• BITMAPINFOHEADER: 40

Which you both combined in struct bmph.

Thus: 54 + (500*999)*4;, being the total size of the resulting file.

bmpheader.biBitCount=4;

bmpheader.biBitCount should be 32 (24 for RGB and 32 for RGBA).

---

Also, if you can make sure the padding of struct bmph is ok (i.e. no padding - not sure about the setting for Linux, it's #pragma pack in Windows for example), then you could write the whole struct in one go.

And as @fleebness already suggested, make sure to use fixed types in your struct, so they won't change depending on the system you are compiling for.

Answer 2

Have you tried this correction:

ofstream moje_bmp("tworzBMP.bmp", std::ios::binary | std::ios::out);

I believe std::ofstream expects text output instead of binary, so you have to override it.

Also, you might refer to this:

https://web.archive.org/web/20080912171714/http://www.fortunecity.com/skyscraper/windows/364/bmpffrmt.html

and instead of using 'unsigned short int' and such, try things like std::uint16_t for 2 byte values, or std::uint32_t for four byte values, etc.