3. Ich fang mit binär Dateien an!

Ich fang mit binär Dateien an!

  • S

    Meine Fragen:
    1.
    Mit wemm ist Bitmap da verwandt

    class Bitmap : public File

    ? Wer ist File bzw. was ist File?
    2. Wenn bei struct nacher der letzten geschweiften Klammer "}" noch n Name kommt, wie hier z.B. "m_fileheader" ist das dann einfach ein Objekt von dem struct? Also wie wenn ich z.B. "FileHeader m_fileheader" schreibe?

    MfG
    Stromberg

    0
  • *

    1. Noch ist es keine Klasse ... es wäre aber z.B. möglich, dass du dir eine Klasse File anlegst die du abstract machst. Dann machst du z.B. auch für JPEG und PNG usw. eine Klasse die davon erbt usw. Also muss aber nicht, kannst auch einfach ": public File" weglassen 😉
    2. Ja, richtig erkannt 😉

    0
  • S

    So sieht das ganze dann am stück aus, aber die Funktion "load_file" habe ich bissel verändert, ich hab des net ganz verstanden, du wolltest da nur ein "file" zum lesen öffnen, ich wollte doch eine ganz neue .BMP Datei erstellen.

    #include <fstream>
#include <iostream>

class Bitmap
{
    struct FileHeader
    {
        unsigned short type;
        unsigned long size;
        unsigned long reserved;
        unsigned long offset;
        FileHeader()
            : type(0), size(0), reserved(0), offset(0)
        {}
    } m_fileheader;

    struct InfoHeader
    {
        enum Compression {
            RGB = 0,
            RLE8,
            RLE4,
            BITFIELDS
        };
        unsigned long size;
        unsigned long width;
        unsigned long height; // width * height == Anzahl der Pixel!
        unsigned short planes;
        unsigned short bit_count;
        unsigned long compression;
        unsigned long size_data;
        unsigned long x_ppm;
        unsigned long y_ppm;
        unsigned long colors_used;
        unsigned long colors_important;
        InfoHeader()
            : size(0), width(0), height(0), planes(1), bit_count(24), compression(RGB), size_data(0),
            x_ppm(0), y_ppm(0), colors_used(0), colors_important(0)
        {}
    } m_infoheader;

public:
    Bitmap(const char* file_name) { load_file(file_name); }
    Bitmap() {}

public:
    void load_file(const char* file_name)
    {
        std::ofstream file_stream(file_name, std::ios::out | std::ios::binary);
        //if (!file_stream) throw std::invalid_argument("invalid file");
        file_stream.write(reinterpret_cast<char*>(&m_fileheader), sizeof(FileHeader));
        file_stream.write(reinterpret_cast<char*>(&m_infoheader), sizeof(InfoHeader));
    }
};

int main()
{
    class Bitmap test;
    test.load_file("D:/bild.bmp");

    return 0;
}

    Zumindestens gibts jetzt in "D:\" tatsächlich eine BMP Datei namens "bild.bmp". Mit Paint konnte ich sie nicht öffnen, da kam eine Fehlermeldung, dass das Format nicht erkannt werden konnte. Warum nicht?
    Zumindestens konnte ich sie mit so nem Nero Bildprogramm öffnen, des heißt "Nero PhotoSnap Viewer". Warum gehts mit dem, aber nicht mit Paint?
    Hier ist das Ergebnis vom Bild: http://www.pictureupload.de/originals/pictures/231207125824_Unbannt.bmp
    Is aber noch um einiges Verbesserungswillig. Was bei dem Code doch überhaupt fehlt, ist doch der 3te Teil einer BMP-Datei, die Bilddaten oder? Hört sich in Wikipedai aber wieder schrecklich kompliziert an....
    Na ja, ich warte jetzt erst mal auf deine Meinung.
    MfG
    Stromberg

    0
  • *

    hmm ... naja ich hatte in load_file jetzt auch eine Bitmap laden wollen 😛

    Naja guck mal ob sizeof(FileHeader) == 14 ist und sizeof(InfoHeader) == 40. Wenn nicht, musst du padding abstellen.

    Wenn der Header schonmal stimmt, gehst du jetzt hin und füllst die Daten ... müsste eigtl BGR Ausrichtung sein ...

    #include <cstdlib> // std::srand, std::rand
#include <ctime> // std::time

std::srand(static_cast<unsigned>(std::time(NULL)));

for (unsigned long x(0); x < bm.width; ++x)
    for (unsigned long y(0); y < bm.height; ++y)
    {
        unsigned char color[3] = { std::rand() % 256, std::rand() % 256, std::rand() % 256 };
        file_stream.write(reinterpret_cast<const char*>(&color), sizeof(unsigned char) * 3);
    }

    sollte dir dann alles mit Zufallswerten füllen 😉

    0
  • S

    Äh was is padding? Irgend eine Compiler Option?
    MfG
    Stromberg

    0
  • B

    Stromberg schrieb:

    Äh was is padding? Irgend eine Compiler Option?
    MfG
    Stromberg

    Lies mal diesen Thread durch, da gings auch um Padding 🙂

    0
  • S

    Folgendes, sizeof(m_fileheader) war 16 und sizeof(m_infoheader) war 40. Somit habe ich bei "struct FileHeader" das padding ausgeschalten. Hat auch super geklappt, und sizeof(m_fileheader) war 14. Nur kann ich jetzt die Datei auch nicht mal mehr mit dem "Nero PhotoSnap Viewer" öffnen, und mit Paint wie schon gehabt auch net.
    Hier der Code:

    #include <fstream>
#include <iostream>

class Bitmap
{
    public:
    #pragma pack (1)
    struct FileHeader
    {
        unsigned short type;
        unsigned long size;
        unsigned long reserved;
        unsigned long offset;
        FileHeader()
            : type(0), size(0), reserved(0), offset(0)
        {}
    } m_fileheader;
    #pragma pack (pop)

    struct InfoHeader
    {
        enum Compression {
            RGB = 0,
            RLE8,
            RLE4,
            BITFIELDS
        };
        unsigned long size;
        unsigned long width;
        unsigned long height; // width * height == Anzahl der Pixel!
        unsigned short planes;
        unsigned short bit_count;
        unsigned long compression;
        unsigned long size_data;
        unsigned long x_ppm;
        unsigned long y_ppm;
        unsigned long colors_used;
        unsigned long colors_important;
        InfoHeader()
            : size(0), width(0), height(0), planes(1), bit_count(24), compression(RGB), size_data(0),
            x_ppm(0), y_ppm(0), colors_used(0), colors_important(0)
        {}
    } m_infoheader;

public:
    Bitmap(const char* file_name) { load_file(file_name); }
    Bitmap() {}

public:
    void load_file(const char* file_name)
    {
        std::ofstream file_stream(file_name, std::ios::out | std::ios::binary);
        //if (!file_stream) throw std::invalid_argument("invalid file");
        file_stream.write(reinterpret_cast<char*>(&m_fileheader), sizeof(FileHeader));
        file_stream.write(reinterpret_cast<char*>(&m_infoheader), sizeof(InfoHeader));
    }
};

int main()
{
    class Bitmap test;
    std::cout << sizeof(test.m_fileheader) << std::endl;
    std::cout << sizeof(test.m_infoheader) << std::endl;
    test.load_file("D:/bild.bmp");

    return 0;
}

    MfG
    Stromberg

    0
  • N

    Ich hab vor vielen Jahren mal so eine Klasse geschrieben, nachdem ich herausgefunden hatte, wie man Binärdateien schreibt. Von Dateiformatspezifikationen hatte ich da mangels frei zugänglichem Internet noch keine Ahnung, hab mir das Ganze aus bereits vorhandenen Bitmapdateien erschlossen... die Klasse produziert aber Bitmaps, die man auch in anderen Programmen laden kann (aber die Praxis, für jeden einzelnen Pixel write() aufzurufen, sollte man evtl. nicht nachahmen).
    Also, falls es helfen sollte:

    http://91.34.101.164/TFastBitmap.cpp

    0
  • B

    Warum beschreibst du eigentlich die Datei bei "load_file"?

    Naja, jedenfalls können Bildbearbeitungsprogramme dein Bild wohl nicht öffnen, weil noch nicht einmal der Typ am Anfang stimmt. Du solltest schon gültige Werte in den Strukturen setzen, sonst klappt das nie 😉

    0
  • S

    Irgendwie bring ichs net zu stande, kann mir jemand sagen wie ich es machen kann, das ich im Konstruktor von Bitmap "m_infoheader" und "m_fileheader" initialisieren kann. Wie mach ich das?
    MfG
    Stromberg

    0
  • B

    Stromberg schrieb:

    Irgendwie bring ichs net zu stande, kann mir jemand sagen wie ich es machen kann, das ich im Konstruktor von Bitmap "m_infoheader" und "m_fileheader" initialisieren kann. Wie mach ich das?

    Der Konstruktor wird doch aufgerufen, du initialisierst die Werte aber falsch, FileHeader::type muss ja z.B. 'BM' sein :xmas2:

    0
  • *

    Hmm wie oft noch ^^ Ich hab dir nicht die Klasse zum schreiben sondern zum lesen geschrieben ^^ Aber ok nochmal:

    #if !defined BITMAP_HPP_INCLUDED
#define BITMAP_HPP_INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <fstream>

class Bitmap
{
    #pragma pack (1)
    struct FileHeader
    {
        unsigned char type[2];
        unsigned long size;
        unsigned long reserved;
        unsigned long offset;
        FileHeader()
            : size(0), reserved(0), offset(0)
        { type[0] = 'B'; type[1] = 'M'; }
    } m_fileheader;
    #pragma pack (pop)

	struct InfoHeader
	{
		enum Compression {
            RGB = 0,
            RLE8,
            RLE4,
            BITFIELDS
        };
        unsigned long size;
        unsigned long width;
        unsigned long height; // width * height == Anzahl der Pixel!
        unsigned short planes;
        unsigned short bit_count;
        unsigned long compression;
        unsigned long size_data;
        unsigned long x_ppm;
        unsigned long y_ppm;
        unsigned long colors_used;
        unsigned long colors_important;
        InfoHeader()
            : size(0), width(0), height(0), planes(1), bit_count(24), compression(RGB), size_data(0),
            x_ppm(0), y_ppm(0), colors_used(0), colors_important(0)
        {}
	} m_infoheader;

	std::vector<unsigned char[3]>	m_data;
	std::string						m_filename;

public:
    Bitmap(const char* file_name) 
		: m_filename(file_name)
	{ load(file_name); }
    Bitmap() {}

public:
    void load(const char* file_name)
    {
		std::ifstream file_stream(file_name, std::ios::binary);
		if (!file_stream) throw std::invalid_argument("invalid file");

		m_filename = file_name;

		file_stream.read(reinterpret_cast<char*>(&m_fileheader), sizeof(FileHeader));
		file_stream.read(reinterpret_cast<char*>(&m_infoheader), sizeof(InfoHeader));
		m_data.resize(m_infoheader.width * m_infoheader.height);
		file_stream.seekg(m_fileheader.offset, std::ios_base::beg);
		for (std::size_t i(0); i < m_data.size(); ++i)
		{
			file_stream.read(reinterpret_cast<char*>(m_data[i]), sizeof(unsigned char) * 3);
			std::swap(m_data[i][0], m_data[i][2]);
		}
	}

	void write()
	{
		std::ofstream file_stream(m_filename.c_str(), std::ios::binary);
		if (!file_stream) throw std::invalid_argument("invalid file");

		file_stream.write(reinterpret_cast<const char*>(&m_fileheader), sizeof(FileHeader));
		file_stream.write(reinterpret_cast<char*>(&m_infoheader), sizeof(InfoHeader));
		file_stream.seekp(m_fileheader.offset, std::ios_base::beg);
		for (std::size_t i(0); i < m_data.size(); ++i)
		{
			unsigned char data[3] = { m_data[i][2], m_data[i][1], m_data[i][0] };
			file_stream.write(reinterpret_cast<char*>(data), sizeof(unsigned char) * 3);
		}
	}
};

#endif // BITMAP_HPP_INCLUDED

    int main()
{
	Bitmap test("D:\\image_001.bmp");
}

    so in etwa ... jetzt musst du nur mal die randome-daten hinzufügen ...

    0
  • B

    Du musst aber bedenken, dass bei einer Breite des Bilds (in Bytes), die nicht durch 4 teilbar ist, mit Füllbytes aufgestockt wird, die musst du halt überspringen.

    0
  • S

    Ich habs jetzt nochmal alles zur Übung aus meinem Kopf geschrieben. (außer natürlich die Dateinamen vom Info- und Kopfteil) Und jetzt gehts in Nero PhotoSnap Viewer und sogar auch in Paint.

    #include <iostream>
#include <fstream>
using namespace std;

class Bitmap
{
    private:
    #pragma pack (1)
    ////////////////////////////////////////////////////////////////// - Dateikopf
    struct FileHeader
    {
        FileHeader(short type_,int size_,int reserved_,int offBits_);
        short m_type;
        int   m_size;
        int   m_reserved;
        int   m_offBits;
    };
    ////////////////////////////////////////////////////////////////// - Dateiinfo
    struct InfoHeader
    {
        InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                   int sizeImage_,int horizontal_,int vertical_,int used_,int important_);
        int   m_size;
        int   m_width;
        int   m_height;
        short m_planes;
        short m_bitCount;
        int   m_compression;
        int   m_sizeImage;
        int   m_horizontal;
        int   m_vertical;
        int   m_used;
        int   m_important;
    };
    #pragma pack ()
    ////////////////////////////////////////////////////////////////// - Elementvariablen
    ofstream File;
    FileHeader m_fileHeader;
    InfoHeader m_infoHeader;

    public:
    Bitmap(short type_=19778,int size1_=54,int reserved_=0,int offBits_=54, //KOPF
           int size2_=40,int width_=100,int height_=100,int planes_=1,short bitCount_=8,int compression_=0, //INFO
           int sizeImage_=10*10,int horizontal_=0,int vertical_=0,int used_=0,int important_=0); //INFO

    void make_file(char *fileName);
    void write_file();

};

//Konstruktoren
Bitmap::Bitmap(short type_,int size1_,int reserved_,int offBits_, //KOPF
               int size2_,int width_,int height_,int planes_,short bitCount_,int compression_, //INFO
               int sizeImage_,int horizontal_,int vertical_,int used_,int important_) //INFO
:m_fileHeader(type_,size1_,reserved_,offBits_), //KOPF
 m_infoHeader(size2_,width_,height_,planes_,bitCount_,compression_,sizeImage_,horizontal_,vertical_, //INFO
 used_,important_) //INFO
{

}

Bitmap::FileHeader::FileHeader(short type_,int size_,int reserved_,int offBits_)
:m_type(type_),m_size(size_),m_reserved(reserved_),m_offBits(offBits_)
{

}

Bitmap::InfoHeader::InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                               int sizeImage_,int horizontal_,int vertical_,int used_,int important_)
:m_size(size_),m_width(width_),m_height(height_),m_planes(planes_),m_bitCount(bitCount_),m_compression(compression_),
 m_sizeImage(sizeImage_),m_horizontal(horizontal_),m_vertical(vertical_),m_used(used_),m_important(important_)
{

}

//Methoden
void Bitmap::make_file(char *fileName)
{
    File.open(fileName,ios::out | ios::binary);
}

void Bitmap::write_file()
{
    File.write(reinterpret_cast<char*>(&m_fileHeader),sizeof(m_fileHeader));
    File.write(reinterpret_cast<char*>(&m_infoHeader),sizeof(m_infoHeader));
}

int main()
{
    Bitmap Trial;
    Trial.make_file("D:/Weihnachten.bmp");
    Trial.write_file();
    return 0;
}

    Jetzt schau ich mir mal den Code von (D)Evil an, der is glaub bissel professioneller als meiner. Mal ein großes Dankeschön an dich (D)Evil was du dir hier für eine Mühe gibst!!!!
    MfG
    Stromberg

    0
  • S

    Mh, bei meinem Code, hab ich jetzt noch versucht, die Bilddaten hinzuzufügen, aber irgendwie funktionierts nicht. Also es gibt keinen Error oder sowas, aber das Bild ist halt trotzdem einfach nur scharz. Wie gehts richtig? Was mache ich da falsch? Ich hab gedacht, ich muss einfach die RGB Werte für jedes Pixel einlesen. Und es gibt width*height Pixel oder? Kann mich da mal jemand aufklären? Meine bisherige Version:

    #include <iostream>
#include <fstream>
using namespace std;

class Bitmap
{
    private:
    #pragma pack (1)
    ////////////////////////////////////////////////////////////////// - Dateikopf
    struct FileHeader
    {
        FileHeader(short type_,int size_,int reserved_,int offBits_);
        short m_type;
        int   m_size;
        int   m_reserved;
        int   m_offBits;
    };
    ////////////////////////////////////////////////////////////////// - Dateiinfo
    struct InfoHeader
    {
        InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                   int sizeImage_,int horizontal_,int vertical_,int used_,int important_);
        int   m_size;
        int   m_width;
        int   m_height;
        short m_planes;
        short m_bitCount;
        int   m_compression;
        int   m_sizeImage;
        int   m_horizontal;
        int   m_vertical;
        int   m_used;
        int   m_important;
    };
    #pragma pack ()
    ////////////////////////////////////////////////////////////////// - Elementvariablen
    ofstream File;
    FileHeader m_fileHeader;
    InfoHeader m_infoHeader;

    public:
    Bitmap(short type_=19778,int size1_=54,int reserved_=0,int offBits_=54, //KOPF
           int size2_=40,int width_=100,int height_=100,int planes_=1,short bitCount_=32,int compression_=0, //INFO
           int sizeImage_=100*100*4,int horizontal_=0,int vertical_=0,int used_=0,int important_=0); //INFO

    void make_file(char *fileName);
    void write_file();
    void write_colour(bool a,bool b,bool c); // !!! UM DAS HIER GEHTS !!!

};

//Konstruktoren
Bitmap::Bitmap(short type_,int size1_,int reserved_,int offBits_, //KOPF
               int size2_,int width_,int height_,int planes_,short bitCount_,int compression_, //INFO
               int sizeImage_,int horizontal_,int vertical_,int used_,int important_) //INFO
:m_fileHeader(type_,size1_,reserved_,offBits_), //KOPF
 m_infoHeader(size2_,width_,height_,planes_,bitCount_,compression_,sizeImage_,horizontal_,vertical_, //INFO
 used_,important_) //INFO
{

}

Bitmap::FileHeader::FileHeader(short type_,int size_,int reserved_,int offBits_)
:m_type(type_),m_size(size_),m_reserved(reserved_),m_offBits(offBits_)
{

}

Bitmap::InfoHeader::InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                               int sizeImage_,int horizontal_,int vertical_,int used_,int important_)
:m_size(size_),m_width(width_),m_height(height_),m_planes(planes_),m_bitCount(bitCount_),m_compression(compression_),
 m_sizeImage(sizeImage_),m_horizontal(horizontal_),m_vertical(vertical_),m_used(used_),m_important(important_)
{

}

//Methoden
void Bitmap::make_file(char *fileName)
{
    File.open(fileName,ios::out | ios::binary);
}

void Bitmap::write_file()
{
    File.write(reinterpret_cast<char*>(&m_fileHeader),sizeof(m_fileHeader));
    File.write(reinterpret_cast<char*>(&m_infoHeader),sizeof(m_infoHeader));
}

void Bitmap::write_colour(bool a,bool b,bool c) //<--- !!! UMD DAS HIER GEHTS !!!
{
    int product=m_infoHeader.m_width*m_infoHeader.m_height*m_infoHeader.m_bitCount/8;
    for (int i=0;i<product;++i)
    {
        File.write(reinterpret_cast<char*>(&a),sizeof(a));   //Blau
        File.write(reinterpret_cast<char*>(&b),sizeof(b));  //Grün
        File.write(reinterpret_cast<char*>(&c),sizeof(c));  //Rot
    }
}

int main()
{
    Bitmap Trial;
    Trial.make_file("D:/Weihnachten.bmp");
    Trial.write_file();
    Trial.write_colour(133,220,34); //<-- !!! UM DAS HIER GEHTS !!!
    return 0;
}

    MfG
    Stromberg

    0
  • B

    Badestrand schrieb:

    Du musst aber bedenken, dass bei einer Breite des Bilds (in Bytes), die nicht durch 4 teilbar ist, mit Füllbytes aufgestockt wird, die musst du halt überspringen.

    ⚠

    void Bitmap::write_colour(char a, char b, char c)
{
    for ( int y=0; y<m_infoHeader.m_height; y++ )
    {
        // Farben für diese Zeile schreiben
        for ( int x=0; x<m_infoHeader.m_width; x++ )
        {
            File.write( &a, sizeof(a) );
            File.write( &b, sizeof(b) );
            File.write( &c, sizeof(c) );
        }

        // Füllbytes, maximal 3
        int bpp = m_infoHeader.m_bitCount / 8; // BytesPerPixel
        int bpl = bpp * m_infoHeader.m_width;  // BytesPerLine
        int fill_byte_count = (bpl%4==0)? (0) : (4 - (bpl%4));
        char fill[] = { 0, 0, 0 };
        File.write( fill, fill_byte_count );
    }
}

    Außerdem, du weißt schon, dass 'bool' eigentlich ungeeignet ist, andere Farbwerte als 0 oder 1 aufzunehmen?

    0
  • S

    Mit deiner Methode, kam folgendes Ergebnis raus:
    http://www.pictureupload.de/showpic.php?src=pictures/241207143537_Fo.bmp
    Aber das Ergebnis bleibt immer gleich, egal ob ich die Funktionsparamter von "coulor" verändere....
    Also irgendwas stimmt an dem code noch nicht. Ich glaube das hat was mit den Einträgen vom "InfoHeader" und "FileHEader" zu tun. Da hab ich glaub vll. falsche Sachen reingeschrieben, aber ich weiß au net so genau was ich da reinschreiben soll. Hab mir des halt einfach im Wiki angeschaut. Also wenn ich da jemand von euch auskennt, dann könnt der des ja nochmal "überprüfen" ob da meine Angaben korrekt sind:

    Bitmap(short type_=19778,int size1_=54,int reserved_=0,int offBits_=54, //KOPF
           int size2_=40,int width_=100,int height_=100,int planes_=1,short bitCount_=32,int compression_=0, //INFO
           int sizeImage_=100*100,int horizontal_=0,int vertical_=0,int used_=0,int important_=0); //INFO

    Und hier der ganze Code:

    #include <iostream>
#include <fstream>
using namespace std;

class Bitmap
{
    private:
    #pragma pack (1)
    ////////////////////////////////////////////////////////////////// - Dateikopf
    struct FileHeader
    {
        FileHeader(short type_,int size_,int reserved_,int offBits_);
        short m_type;
        int   m_size;
        int   m_reserved;
        int   m_offBits;
    };
    ////////////////////////////////////////////////////////////////// - Dateiinfo
    struct InfoHeader
    {
        InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                   int sizeImage_,int horizontal_,int vertical_,int used_,int important_);
        int   m_size;
        int   m_width;
        int   m_height;
        short m_planes;
        short m_bitCount;
        int   m_compression;
        int   m_sizeImage;
        int   m_horizontal;
        int   m_vertical;
        int   m_used;
        int   m_important;
    };
    #pragma pack ()
    ////////////////////////////////////////////////////////////////// - Elementvariablen
    ofstream File;
    FileHeader m_fileHeader;
    InfoHeader m_infoHeader;

    public:
    Bitmap(short type_=19778,int size1_=54,int reserved_=0,int offBits_=54, //KOPF
           int size2_=40,int width_=100,int height_=100,int planes_=1,short bitCount_=32,int compression_=0, //INFO
           int sizeImage_=100*100,int horizontal_=0,int vertical_=0,int used_=0,int important_=0); //INFO

    void make_file(char *fileName);
    void write_file();
    void write_colour(char blue, char green, char red); // !!! UM DAS HIER GEHTS !!!

};

//Konstruktoren
Bitmap::Bitmap(short type_,int size1_,int reserved_,int offBits_, //KOPF
               int size2_,int width_,int height_,int planes_,short bitCount_,int compression_, //INFO
               int sizeImage_,int horizontal_,int vertical_,int used_,int important_) //INFO
:m_fileHeader(type_,size1_,reserved_,offBits_), //KOPF
 m_infoHeader(size2_,width_,height_,planes_,bitCount_,compression_,sizeImage_,horizontal_,vertical_, //INFO
 used_,important_) //INFO
{

}

Bitmap::FileHeader::FileHeader(short type_,int size_,int reserved_,int offBits_)
:m_type(type_),m_size(size_),m_reserved(reserved_),m_offBits(offBits_)
{

}

Bitmap::InfoHeader::InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                               int sizeImage_,int horizontal_,int vertical_,int used_,int important_)
:m_size(size_),m_width(width_),m_height(height_),m_planes(planes_),m_bitCount(bitCount_),m_compression(compression_),
 m_sizeImage(sizeImage_),m_horizontal(horizontal_),m_vertical(vertical_),m_used(used_),m_important(important_)
{

}

//Methoden
void Bitmap::make_file(char *fileName)
{
    File.open(fileName,ios::out | ios::binary);
}

void Bitmap::write_file()
{
    File.write(reinterpret_cast<char*>(&m_fileHeader),sizeof(m_fileHeader));
    File.write(reinterpret_cast<char*>(&m_infoHeader),sizeof(m_infoHeader));
}

void Bitmap::write_colour(char blue, char green, char red)
{
    for ( int y=0; y<m_infoHeader.m_height; y++ )
    {
        // Farben für diese Zeile schreiben
        for ( int x=0; x<m_infoHeader.m_width; x++ )
        {
            File.write( &blue, sizeof(blue) );
            File.write( &green, sizeof(green) );
            File.write( &red, sizeof(red) );
        }

        // Füllbytes, maximal 3
        int bpp = m_infoHeader.m_bitCount / 8; // BytesPerPixel
        int bpl = bpp * m_infoHeader.m_width;  // BytesPerLine
        int fill_byte_count = (bpl%4==0)? (0) : (4 - (bpl%4));
        char fill[] = { 0, 0, 0 };
        File.write( fill, fill_byte_count );
    }
}

int main()
{
    Bitmap Trial;
    Trial.make_file("D:/Fotze.bmp");
    Trial.write_file();
    Trial.write_colour(133,220,34); //<-- !!! UM DAS HIER GEHTS !!!
    return 0;
}

    MfG
    Stromberg

    0
  • S

    Also, mit dem Code für "write_colour" von dir gings irgendwie net, das geht viel einfacher, ich hab des jetzt einfach so gemacht (und es funktioniert blendend):

    #include <iostream>
#include <fstream>
using namespace std;

class Bitmap
{
    private:
    #pragma pack (1)
    ////////////////////////////////////////////////////////////////// - Dateikopf
    struct FileHeader
    {
        FileHeader(short type_,int size_,int reserved_,int offBits_);
        short m_type;
        int   m_size;
        int   m_reserved;
        int   m_offBits;
    };
    ////////////////////////////////////////////////////////////////// - Dateiinfo
    struct InfoHeader
    {
        InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                   int sizeImage_,int horizontal_,int vertical_,int used_,int important_);
        int   m_size;
        int   m_width;
        int   m_height;
        short m_planes;
        short m_bitCount;
        int   m_compression;
        int   m_sizeImage;
        int   m_horizontal;
        int   m_vertical;
        int   m_used;
        int   m_important;
    };
    #pragma pack ()
    ////////////////////////////////////////////////////////////////// - Elementvariablen
    ofstream File;
    FileHeader m_fileHeader;
    InfoHeader m_infoHeader;

    public:
    Bitmap(short type_=19778,int size1_=54,int reserved_=0,int offBits_=54, //KOPF
           int size2_=40,int width_=100,int height_=100,int planes_=1,short bitCount_=32,int compression_=0, //INFO
           int sizeImage_=100*100,int horizontal_=0,int vertical_=0,int used_=0,int important_=0); //INFO

    void make_file(char *fileName);
    void write_file();
    void write_colour(char blue, char green, char red); // !!! UM DAS HIER GEHTS !!!

};

//Konstruktoren
Bitmap::Bitmap(short type_,int size1_,int reserved_,int offBits_, //KOPF
               int size2_,int width_,int height_,int planes_,short bitCount_,int compression_, //INFO
               int sizeImage_,int horizontal_,int vertical_,int used_,int important_) //INFO
:m_fileHeader(type_,size1_,reserved_,offBits_), //KOPF
 m_infoHeader(size2_,width_,height_,planes_,bitCount_,compression_,sizeImage_,horizontal_,vertical_, //INFO
 used_,important_) //INFO
{

}

Bitmap::FileHeader::FileHeader(short type_,int size_,int reserved_,int offBits_)
:m_type(type_),m_size(size_),m_reserved(reserved_),m_offBits(offBits_)
{

}

Bitmap::InfoHeader::InfoHeader(int size_,int width_,int height_,int planes_,short bitCount_,int compression_,
                               int sizeImage_,int horizontal_,int vertical_,int used_,int important_)
:m_size(size_),m_width(width_),m_height(height_),m_planes(planes_),m_bitCount(bitCount_),m_compression(compression_),
 m_sizeImage(sizeImage_),m_horizontal(horizontal_),m_vertical(vertical_),m_used(used_),m_important(important_)
{

}

//Methoden
void Bitmap::make_file(char *fileName)
{
    File.open(fileName,ios::out | ios::binary);
}

void Bitmap::write_file()
{
    File.write(reinterpret_cast<char*>(&m_fileHeader),sizeof(m_fileHeader));
    File.write(reinterpret_cast<char*>(&m_infoHeader),sizeof(m_infoHeader));
}

void Bitmap::write_colour(char blue, char green, char red)
{
    for (int i=0;i<100*100;++i)
    {
        File.write(reinterpret_cast<char*>(&blue),sizeof(blue));
        File.write(reinterpret_cast<char*>(&green),sizeof(green));
        File.write(reinterpret_cast<char*>(&red),sizeof(red));
        File.write("0",sizeof(char));
    }
}

int main()
{
    Bitmap Trial;
    Trial.make_file("D:/Bild.bmp");
    Trial.write_file();
    Trial.write_colour(133,20,34); //<-- !!! UM DAS HIER GEHTS !!!
    return 0;
}

    Muss ich noch auf was spezielles bei den ".bmp" Dateien achten? Was sagt ihr dazu, was kann ich noch besser machen? (Am Code Stil gibts doch sicherlich was auszusetzen oder?)

    MfG
    Stromberg

    0
  • B

    Die reinterpret-casts in write_color sind jetzt ziemlich nutzlos.
    Im Konstruktor von FileHeader und InfoHeader würde ich nur die Variablen in die Parameterliste aufnehmen, die wirklich von außen festgelegt werden müssen. In FileHeader sind z.B. type, size und reserved immer gleich, die kannst du initialisieren, ohne dass sie übergeben werden müssen.
    Dann natürlich einbauen, dass man die Größe selber spezifizieren und die Bildpunkte selber bestimmen kann.
    Kompression unterstützen..
    🙂

    0
Anmelden zum Antworten