spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

/*----------------------------- 
 With some food for thought of 
 www.spieleprogrammierer.de
 www.cplusplus.com/reference
 www.fileformat.info
-------------------------------*/
#ifndef BMP_H
#define BMP_H

#define ID_BMP 0x4D42

#include <windows.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <exception>

using namespace std;

typedef struct tagPixel{
    unsigned char R, G, B;
}Pixel;

typedef struct tagBMPImage{
    BITMAPFILEHEADER fileHeader;
    BITMAPINFOHEADER infoHeader;
    vector<Pixel> pixels;
}BMPImage;

class BMP{
public: 
    BMP();
    BMP(char *fileName);
    virtual ~BMP();

    void loadFile(char* fileName);

    BMPImage* getImage();

private:
    bool isImageValid();
    void loadImage(char *data);
    void extractBIRGB(char *data);

    BMPImage image;
    /*Add your additional functions here.*/
};

#endif

C-/C++-Quelltext

#include "BMP.h"

BMP::BMP(){
}

BMP::BMP(char* fileName){
    loadFile(fileName);
}

BMP::~BMP(){
}

void BMP::loadFile(char* fileName){
    char* buffer;
    size_t size;
    ifstream file;

    file.open(fileName,ios::binary);

    if(!file.is_open()){
        throw exception("File could not be opened.");
        return;
    }
    
    //get file size
    file.seekg(0,ios::end);
    size = (size_t)file.tellg();
    file.seekg(0,ios::beg);

    //read whole file
    buffer = new char [size];
    file.read(buffer, size);
    file.close();

    loadImage(buffer);

    delete[] buffer;
}

void BMP::loadImage(char *data){
    unsigned int index = 0;

    //load file header
    memcpy(&image.fileHeader,&data[index],sizeof(BITMAPFILEHEADER));
    index += sizeof(BITMAPFILEHEADER);

    if(!isImageValid()){
        return;
    }

    //load info header
    memcpy(&image.infoHeader,&data[index],sizeof(BITMAPINFOHEADER));
    index += sizeof(BITMAPINFOHEADER);

    //load image data
    switch(image.infoHeader.biCompression){
        case BI_RGB:
            extractBIRGB(data);
        break;
    /*Add additional compressions here ...*/
    default:
        throw exception("Compression is not supported.");
    }
}

void BMP::extractBIRGB(char *data){
    switch(image.infoHeader.biBitCount){
        case 24:
        {
            int offBit  = image.fileHeader.bfOffBits;
            int width = abs(image.infoHeader.biWidth);
            int heigth = abs(image.infoHeader.biHeight);

            for(int i = 0; i<heigth; i++){
                for(int y=0; y<width; y++){

                    BYTE pixel[3] = {0};
                    memcpy(pixel, &data[offBit], sizeof(BYTE) * 3);

                    Pixel p;
                    p.R = pixel[2];
                    p.G = pixel[1];
                    p.B = pixel[0];

                    image.pixels.push_back(p);

                    offBit+=sizeof(BYTE) * 3;
                }
            }
            break;
        }
        /*Add additional BitCounts 1, 4, 8 here ...*/
    default:
        throw exception(image.infoHeader.biBitCount +"Bit won't be supported.");
    }

}

bool BMP::isImageValid(){
    return image.fileHeader.bfType == ID_BMP ? true : false;
}

BMPImage* BMP::getImage(){
    return &image;
}

C-/C++-Quelltext

#include "BMP.h"
#include <iostream>

using namespace std;

int main(){


    BMP c("./test1.bmp");
    BMPImage *image = c.getImage();

    for(int i = 0; i < image->pixels.size(); i++){
        Pixel p = image->pixels[i];

        printf( "R:%d G:%d B:%d \n", p.R, p.G, p.B );
    }

    cin.get();
}