diverse Fragen zu Bildformat einlesen

[zeropage]

Hallo,

ich möchte damit anfangen, kleine einfache Bilder zu verarbeiten. Als Format habe ich mir Windows Bitmap ausgewählt.

Um da besser durchzusteigen, will ich die Bytes der Datei erst mal nur ausgeben. Beschränke mich zum Anfang aber nur auf den Kopf und die Eigenschaften. Denn dort fangen schon genug Fragen an.

Als Grundlage habe ich den entsprechenden wiki-Artikel genommen.

https://de.wikipedia.org/wiki/Windows_Bitmap#Dateiformat_.28Version_3.29

struct Head
{
    static const int Size = 4;
    std::array <std::string, Size> bName {{ "bfType", "bfSize", "bfReserved", "bfOffbits" }};
    std::array <int, Size> bName_size {{ 2,4,4,4, }};
}head;

struct Info
{
    static const int Size = 11;
    std::array <std::string, Size> bName {{ "biSize", "biWidth", "biHeight", "biPlanes", "biBitCount", "biCompression", "biSizeImage", "biXPelsPerMeter", "biYPelsPerMeter", "biClrUsed", "biClrImportant" }};
    std::array <int, Size> bName_size {{ 4,4,4,2,2, 4,4,4,4,4,4 }};
}info;

struct dummy //nur ein dummy-struct für spätere Inhalte
{
    std::vector <char> dValue;
};

int main()
{

    std::vector <char> picmap;
    char byte;
    size_t offset = 0;

    std::string file_name = "WOLKEN.bmp";
    std::ifstream file (file_name.c_str(), std::ios::binary|std::ios::in);
    while (file.get(byte)) picmap.push_back(byte);

    std::cout << "_Head_" << '\n';
    for (int i=0; i<head.Size; i++)
    {
        std::cout << '#' << std::dec << offset << "  " << head.bName.at(i) << std::setw(11);
        for (int j=0; j<head.bName_size.at(i); j++)
        {
            std::cout << std::hex << int(picmap.at(offset)) << ' ';
            offset ++;
        }
        std::cout << '\n';
    }

    std::cout << '\n' << "_Info_" << '\n';
    for (int i=0; i<info.Size; i++)
    {
        std::cout << '#' << std::dec << offset << "  " << info.bName.at(i) << std::setw(11);
        for (int j=0; j<info.bName_size.at(i); j++)
        {
            std::cout << std::hex << int(picmap.at(offset)) << ' ';
            offset ++;
        }
        std::cout << '\n';
    }

}

Nun meine Fragen:

1 - ist es möglich die structs zu etwas größeren zusammenzufassen? Habe etwas über struct in einem struct nachgeschlagen, wollte aber wissen, ob es etwas besseres gibt.

2 - Ich wollte setw() für einen übersichtlichen Ausdruck nehmen, nur funktioniert das nicht, wie ich mir das vorstelle.
http://abload.de/image.php?img=unbenanntfnou7.png
Wie macht man das korrekt?

3 - Zum Einlesen eines Byte habe ich ein char genommen, nur frage ich mich, ob das korrekt ist, oder was man da besser nimmt?

4 - Wo und wie müsste ich eventuelle Kommentare setzen, damit ein geneigter Helfer schneller den Code überblicken kann? Bei zB Zeile 32 'Bytes der Datei in vector einlesen' stelle ich mir überflüssig vor?

Es würden zu dem Code noch weitere kleine Fragen kommen, würde aber gerne erst die oberen Punkte abhaken.

[dfgdfgd]

Als Byte verwende ich i.d.R. unsigned char.
Ansonsten findet man sich im Code ja ganz gut zurecht.

Kannst ja noch einen Link in den Code reinstellen wo erklärt wird wie das BMP Format definiert ist, damit jemand, der das liest, sofort nachschauen kann welche Information an welcher Stelle steht.

Außerdem könntest du deinen Strukturen Methoden spendieren, welche sich um das Einlesen selbst kümmern. Also z.B. readFromBytes(unsigned char* prt){...}
Das heißt du übergibst den Methoden einfach die Speicheradresse des ersten Bytes und die Strukturen lesen selbstständig alles nötige ein.

Dann schaut deine main Funktion noch übersichtlicher aus.

[sebi707]

lemon03 schrieb:

1 - ist es möglich die structs zu etwas größeren zusammenzufassen? Habe etwas über struct in einem struct nachgeschlagen, wollte aber wissen, ob es etwas besseres gibt.

Außer weitere structs gibt es nichts um verschiedene structs zusammenzufassen.

lemon03 schrieb:

2 - Ich wollte setw() für einen übersichtlichen Ausdruck nehmen, nur funktioniert das nicht, wie ich mir das vorstelle.
http://abload.de/image.php?img=unbenanntfnou7.png
Wie macht man das korrekt?

Ich glaube du möchtest setw vor dem Ausgeben des Namens haben. Sonst passt die Ausrichtung aufgrund der unterschiedlichen Länge nicht. Wenn dann die Namen alle links anfangen sollten brauchst du noch left.

lemon03 schrieb:

3 - Zum Einlesen eines Byte habe ich ein char genommen, nur frage ich mich, ob das korrekt ist, oder was man da besser nimmt?

Ich nehme ein uint8_t. Das ist zwar auf den meisten Systemen die einem so begegen einen unsigned char aber kann ja nicht schaden.

[zeropage]

Ah, vielen Dank schonmal. Hilft mir schon weiter
Bin erst mal wieder etwas beschäftigt, bevor dann eventuelle Nachfragen und die angekündigten weiteren kleinen Fragen kommen

Nur mit der formatierten Ausgabe werde ich es noch nicht hinbekommen. Hatte damit schon immer zu kämpfen, ohne das ich auf eine Lösung gekommen wäre. Nun ja, meine war dann immer point(set, x, y).
Gibt es nicht ein setw()-ähnliches, was einfach nur am linken Rand des Konsolenfensters anfängt zu zählen?

[zeropage]

Sorry für die kleine Zwischenfrage, aber ich wurde gerade durch einen anderen Thread abgelenkt, in dem eine std::map vorkam.

Dies scheint mir für meine ersten beiden structs doch auch passend? So in der Form

struct Head
{
     std::map <std::string, int> bType
    {
        {"bfType", 2},
        {"bfSize", 4},
        {"bfReserved", 4},
        {"bfOffbits", 4},
    };
}head;

Ist das in diesem Fall sinnvoll oder eher nicht? Denn mir scheint der Zugriff auf die einzelnen Elemente nicht richtig klar. Wie ich zB von "bfType" auf 2 komme, glaube ich zu kapieren, aber nicht wie ich auf "bfType" zugreifen kann. Lohnt sich, abgesehen vom Lerneffekt, der zusätzliche Aufwand?

[sebi707]

Die Verwendung einer Map macht bei dir wenig Sinn. Mit der Map könntest du etwas wie bType["bfSize"] schreiben, was dir dann 4 liefert. Da du sowas zum einlesen des Headers aber nicht brauchst und die Map zusätzlich alle Elemente nach dem Key (dem ersten Wert) sortiert kriegst auch noch eine völlig falsche Reihenfolge. Du könntest aber vielleicht ein array oder vector von pairs nutzen:

struct Head
{
	static const int Size = 4;
    std::array<std::pair<std::string, int>, Size> bType
    {
        {"bfType", 2},
        {"bfSize", 4},
        {"bfReserved", 4},
        {"bfOffbits", 4},
    };
} head;

Hier kriegst du mit bType[0]->first den "bfType" String und mit bType[0]->second deine 2. Entsprechend mit bType[3] das letzte Paar in deinem Array.

[zeropage]

Ah ... danke schön

Jepp, dann mache ich mal weiter ...

[zeropage]

Puh, ich hänge immer noch an der Ausgabe. Sie ist inzwischen zwar formatiert, hätte aber gerne die Byte-Ausgabe aufgefüllt auf zwei Zeichen, also statt 8 -> 08 etc. Eine Möglichkeit besteht wohl mit std::setfill('0') , nur habe ich absolut keinen Plan, wo und wie ich das einsetzen kann. Es wird alles mögliche ausgefüllt, nur die Byte-Ausgabe nicht. Es ist zwar ärgerlich, das ich mich so lange mit solchen Klein-Klein beschäftigen muss, will es aber gerne endlich erledigt haben.

//std::cout << std::showbase;
    std::cout << std::left;
    std::cout << "_Head_" << '\n';
    for (int i=0; i<head.Size; i++)
    {
        std::cout << '#' << std::dec << std::setw(3) << offset << std::setw(17) << head.bType.at(i).first;
        for (int j=0; j<head.bType.at(i).second; j++)
        {
            std::cout << std::hex << int(picmap.at(offset)) << ' ';
            offset ++;
        }
        std::cout << '\n';
    }

[zeropage]

Ich habe dann noch eine zweite Sache, die mir aufgefallen ist. Schreiber lieber einen neuen Beitrag dafür, das man dies besser auseinander halten kann.

Habe ich hier eine Diskrepanz zwischen dem Wiki-Artikel und meiner Ausgabe?

Im Artikel steht bei biHeight

Der Betrag gibt die Höhe der Bitmap in Pixel an.

Ist der Wert positiv, so ist die Bitmap eine sogenannte "bottom-up"-Bitmap (die Bilddaten beginnen mit der untersten und enden mit der obersten Bildzeile). Dies ist die gebräuchlichste Variante.
Ist der Wert negativ, so ist die Bitmap eine "top-down"-Bitmap (die Bilddaten beginnen mit der obersten und enden mit der untersten Bildzeile).

Bei mir scheint aber biWidth negativ? Denn ffffff bdeutet doch negativ?
http://abload.de/image.php?img=unbenannt282q3n.png

[sebi707]

lemon03 schrieb:

Sie ist inzwischen zwar formatiert, hätte aber gerne die Byte-Ausgabe aufgefüllt auf zwei Zeichen, also statt 8 -> 08 etc. Eine Möglichkeit besteht wohl mit std::setfill('0') , nur habe ich absolut keinen Plan, wo und wie ich das einsetzen kann.

Du hast setw ja jetzt schon richtig benutzt. Mit setfill kannst du festlegen mit welchem Zeichen aufgefüllt werden soll. Standardmäßig wird mit Leerzeichen aufgefüllt. Vor der Ausgabe der Bytes stellst du also auf '0' um, außerdem wieder ausrichtung nach rechts und dann vor jedem Byte ein setw(2) . Aber ich muss zugeben, dass die iomanip geschichten ziemlich nervig sind.

lemon03 schrieb:

Bei mir scheint aber biWidth negativ? Denn ffffff bdeutet doch negativ?

Benutze mal unsigned char statt char für Bytes überall. Oder testweise noch einen zusätzichen Cast:

int(unsigned char(picmap.at(offset)))

Ich bin mir ziemlich sicher, dass dies nur ein Fehler bei der Ausgabe ist und die ffffff am Anfang da gar nicht stehen sollten.

[dirkski]

lemon03 schrieb:

1 - ist es möglich die structs zu etwas größeren zusammenzufassen? Habe etwas über struct in einem struct nachgeschlagen, wollte aber wissen, ob es etwas besseres gibt.

Hallo lemon03, zu was größeren nicht. Aber was spricht dagegen die structs Head und Info eins zu eins wie im Wikipedia-Artikel aufzubauen.
Also ohne array, maps oder vector. Ich hab den Artikel nur überflogen aber die Felder von 'Dateikopf' und 'Informationsblock' sind doch statisch, oder?
Dann könntest du evtl. den operator>> zum einlesen überladen.

struct Head {
  uint16_t bfType; // ASCII-Zeichenkette "BM" (Hex: 0x42 0x4D Dez: 19778).
  uint32_t bfSize; // Größe der BMP-Datei in Byte. (unzuverlässig)
  uint32_t bfReserved; // Reserviert, von der Software abhängig, standardmäßig 0
[...]
}

Edit: Zu was größerem schon, später alles in eine class BMP oder so...
... und Head und Info kann man evtl. zusammenlegen... Die 'struct BITMAPINFOHEADER' fängt ja bei Offset 14 an.

[dirkski]

dirkski schrieb:

Hallo lemon03, zu was größeren nicht. Aber was spricht dagegen die structs Head und Info eins zu eins wie im Wikipedia-Artikel aufzubauen.
Also ohne array, maps oder vector. Ich hab den Artikel nur überflogen aber die Felder von 'Dateikopf' und 'Informationsblock' sind doch statisch, oder?
Dann könntest du evtl. den operator>> zum einlesen überladen.

struct Head {
  uint16_t bfType; // ASCII-Zeichenkette "BM" (Hex: 0x42 0x4D Dez: 19778).
  uint32_t bfSize; // Größe der BMP-Datei in Byte. (unzuverlässig)
  uint32_t bfReserved; // Reserviert, von der Software abhängig, standardmäßig 0
[...]
}

Tja, hab ich jetzt zu einfach gedacht. Wollte ich das jetzt einfach mit
istream.read(struct_nach_char_cast, 14) den Dateikopf einlesen, aber nix:

Das zweite Feld (bfSize) in meiner struct oben wird auf 4 Bytes ausgerichtet, meh! Alle nachfolgende Werte falsch

Mal abgesehen von der endian-Problematik...

[zeropage]

[quote="sebi707"]

lemon03 schrieb:

lemon03 schrieb:

Bei mir scheint aber biWidth negativ? Denn ffffff bdeutet doch negativ?

Benutze mal unsigned char statt char für Bytes überall. Oder testweise noch einen zusätzichen Cast:

int(unsigned char(picmap.at(offset)))

Ich bin mir ziemlich sicher, dass dies nur ein Fehler bei der Ausgabe ist und die ffffff am Anfang da gar nicht stehen sollten.

Mmh, aber alle Indizien deuten eher doch auf ein negatives Vorzeichen? Im Artikel selbst kann ein Wert negativ sein, je nach Bitmap.
Ich müsste tatsächlich diesen Cast nehmen, denn bei unsigned char oder uint8_t bekomme ich dort einen Fehler, weil ein Wert größer ist als genau ein Byte.
Und wenn ich einfach ohne Formatierung nur alle Bytes untereinander ausgebe, bekomme ich auch bei i=18 ein ffffffa0 .

std::string file_name = "WOLKEN.bmp";
    std::ifstream file (file_name.c_str(), std::ios::binary|std::ios::in);
    int i = 0;
    while (i < 32+4)
    {
        file.get (byte);
        std::cout << std::dec << i << "  " << std::hex << int(byte) << '\n';
        i ++;
    }

[zeropage]

sebi707 schrieb:

lemon03 schrieb:

Bei mir scheint aber biWidth negativ? Denn ffffff bdeutet doch negativ?

Benutze mal unsigned char statt char für Bytes überall. Oder testweise noch einen zusätzichen Cast:

int(unsigned char(picmap.at(offset)))

Ich bin mir ziemlich sicher, dass dies nur ein Fehler bei der Ausgabe ist und die ffffff am Anfang da gar nicht stehen sollten.

Mmh, aber alle Indizien deuten eher doch auf ein negatives Vorzeichen? Im Artikel selbst kann ein Wert negativ sein, je nach Bitmap.
Ich müsste tatsächlich diesen Cast nehmen, denn bei unsigned char oder uint8_t bekomme ich dort einen Fehler, weil ein Wert größer ist als genau ein Byte.
Und wenn ich einfach ohne Formatierung nur alle Bytes untereinander ausgebe, bekomme ich auch bei i=18 ein ffffffa0 .

std::string file_name = "WOLKEN.bmp";
    std::ifstream file (file_name.c_str(), std::ios::binary|std::ios::in);
    int i = 0;
    while (i < 32+4)
    {
        file.get (byte);
        std::cout << std::dec << i << "  " << std::hex << int(byte) << '\n';
        i ++;
    }

[DirkB]

ffffffa0 passt nicht in ein Byte.
a0 schon eher. Wenn der Wert² signed ist und du expandierst ihn zu einem (32-Bit) int, kommen die ff dazu.

²der Variablentyp, in der der Wert gespeichert ist.

[zeropage]

@ dirkski

Danke für die Anregungen, aber die momentane Ausgabe soll nur dazu dienen, überhaupt in eine solche Bitmap-Struktur durchzusteigen, also erst mal alle Werte laut Tabelle nachvollziehbar auszugeben.

Später interessieren mich nur die Farbwerte.

[zeropage]

Ups, da haben wir uns jetzt überschnitten.

DirkB schrieb:

ffffffa0 passt nicht in ein Byte.
a0 schon eher. Wenn der Wert² signed ist und du expandierst ihn zu einem (32-Bit) int, kommen die ff dazu.

²der Variablentyp, in der der Wert gespeichert ist.

Bin noch beim Überlegen ...

[DirkB]

lemon03 schrieb:

Bin noch beim Überlegen ...

Du hast doch vier Bytes ausgegeben, die zu biWidth gehören.
Wo soll denn da der lange Wert her kommen?

Ich habe die Ausgabe nur ganz kurz gesehen, da sich bei abload.de gleich wieder ein Fenster/Popup davor gesetzt hat. Und auf solchen Seite klicke ich nichts an.
Copy&Paste der Konsole mit Code-Tags geht auch.

Das sieht dann so aus:

Microsoft Windows [Version 10.0.10586]
(c) 2015 Microsoft Corporation. Alle Rechte vorbehalten.

C:\>

Und jeder kann es lesen.

[dirkski]

lemon03 schrieb:

@ dirkski

Danke für die Anregungen, aber die momentane Ausgabe soll nur dazu dienen, überhaupt in eine solche Bitmap-Struktur durchzusteigen, also erst mal alle Werte laut Tabelle nachvollziehbar auszugeben.

Später interessieren mich nur die Farbwerte.

Ok, würde aber evtl. einfacher gehen auf die Member zuzugreifen...

Hier als Vorschlag (ist nicht perfekt):

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <exception>

struct BMPFileHeader {
  uint16_t bfType;      // ASCII-Zeichenkette "BM" (Hex: 0x42 0x4D Dez: 19778).
  uint32_t bfSize;      // Größe der BMP-Datei in Byte. (unzuverlässig)
  uint32_t bfReserved;  // Reserviert, von der Software abhängig, standardmäßig 0
  uint32_t bfOffBits;   // Offset der Bilddaten in Byte vom Beginn der Datei an, bei Echtfarben fast immer 54 (manche Software ignoriert diese Angabe daher fehlerhafterweise).
};

struct BMPInfoHeader {
  uint32_t biSize;          // 40 (Größe der BITMAPINFOHEADER-Struktur in Byte)
  int32_t  biWidth;         // Breite der Bitmap in Pixel.
  int32_t  biHeight;        // Der Betrag gibt die Höhe der Bitmap in Pixel an.
                            // Ist der Wert positiv, so ist die Bitmap eine sogenannte "bottom-up"-Bitmap
                            //   (die Bilddaten beginnen mit der untersten und enden mit der obersten Bildzeile).
                            //   Dies ist die gebräuchlichste Variante.
                            // Ist der Wert negativ, so ist die Bitmap eine "top-down"-Bitmap
                            //   (die Bilddaten beginnen mit der obersten und enden mit der untersten Bildzeile).
  uint16_t biPlanes;        // 1 (Stand in einigen älteren Formaten wie PCX für die Anzahl der Farbebenen,
                            //   wird aber für BMP nicht verwendet)
  uint16_t biBitCount;      // Gibt die Farbtiefe der Bitmap in bpp an; muss einer der folgenden Werte sein:
                            //   1, 4, 8, 16, 24 oder 32. Bei 1, 4 und 8 bpp sind die Farben indiziert.
  uint32_t biCompression;   // Einer der folgenden Werte:
                            //   0 (BI_RGB): Bilddaten sind unkomprimiert.
                            //   1 (BI_RLE8): Bilddaten sind lauflängenkodiert für 8 bpp. Nur erlaubt wenn biBitCount=8 und biHeight positiv.
                            //   2 (BI_RLE4): Bilddaten sind lauflängenkodiert für 4 bpp. Nur erlaubt wenn biBitCount=4 und biHeight positiv.
                            //   3 (BI_BITFIELDS): Bilddaten sind unkomprimiert und benutzerdefiniert (mittels Farbmasken) kodiert. Nur erlaubt wenn biBitCount=16 oder 32.
  uint32_t biSizeImage;     // Wenn biCompression=BI_RGB: Entweder 0 oder die Größe der Bilddaten in Byte.
                            //  Ansonsten: Größe der Bilddaten in Byte.
  int32_t  biXPelsPerMeter; // Horizontale Auflösung des Zielausgabegerätes in Pixel pro Meter; wird aber für BMP-Dateien meistens auf 0 gesetzt.
  int32_t  biYPelsPerMeter; // Vertikale Auflösung des Zielausgabegerätes in Pixel pro Meter; wird aber für BMP-Dateien meistens auf 0 gesetzt.
  uint32_t biClrUsed;       // Wenn biBitCount=1: 0.
                            //  Wenn biBitCount=4 oder 8: die Anzahl der Einträge der Farbtabelle; 0 bedeutet die maximale Anzahl (2, 16 oder 256).
                            //  Ansonsten: Die Anzahl der Einträge der Farbtabelle (0=keine Farbtabelle). Auch wenn sie in diesem Fall nicht notwendig ist, kann dennoch eine für die Farbquantisierung empfohlene Farbtabelle angegeben werden.
  uint32_t biClrImportant;  // Wenn biBitCount=1, 4 oder 8: Die Anzahl sämtlicher im Bild verwendeten Farben; 0 bedeutet alle Farben der Farbtabelle.
                            //  Ansonsten:
                            //  Wenn eine Farbtabelle vorhanden ist und diese sämtliche im Bild verwendeten Farben enthält: deren Anzahl.
                            //  Ansonsten: 0.
};

struct BMP {
  BMPFileHeader head;
  BMPInfoHeader info;
};

std::istream & operator>>(std::istream & is, BMPFileHeader & head) {
  std::cerr << __func__ << " (BMPFileHeader): ";

  if(is.good())
    is.read(reinterpret_cast<char*>(&head.bfType), sizeof(uint16_t) );

  if(is.good())
    is.read(reinterpret_cast<char*>(&head.bfSize), sizeof(uint32_t)*3 ); // bfSize ... bfOffBits = 3*

  if(!is.good()) {
    std::cerr << "read error (BMPFileHeader)!\n";
    return is;
  }

  std::cerr << " bfType = " << head.bfType
            << ", bfSize = " << head.bfSize
            << ", bfReserved = " << head.bfReserved
            << ", bfOffBits = " << head.bfOffBits
            << " (is.tellg() = " << is.tellg() << ")\n";

  return is;
}

std::istream & operator>>(std::istream & is, BMPInfoHeader & info) noexcept {
  std::cerr << __func__ << " (BMPInfoHeader): ";

  if( is.good())
    is.read(reinterpret_cast<char*>(&info), sizeof(uint32_t)*3 );
  if( is.good())
    is.read(reinterpret_cast<char*>(&info.biPlanes), sizeof(uint16_t)*2 );
  if( is.good())
    is.read(reinterpret_cast<char*>(&info.biCompression), sizeof(uint32_t)*6 );

  if(!is.good()) {
    std::cerr << "read error (BMPInfoHeader)!\n";
    return is;
  }

  std::cerr << " biSize: " << info.biSize
            << ", biWidth: " << info.biWidth
            << ", biHeight: " << info.biHeight
            << ", biPlanes: " << info.biPlanes
            << ", biBitCount: " << info.biBitCount
            << ", biCompression: " << info.biCompression
            << " (is.tellg() = " << is.tellg() << ")\n";

  return is;
}

std::istream & operator>>(std::istream & is, BMP & bmp) {
  std::cerr << __func__ << " (BMP): ";

  is >> bmp.head >> bmp.info;
  if(!is.good()) {
    std::cerr << "read error (BMP)!\n";
    return is;
  }

  return is;
}

int main(int argc, char *argv[])
{
  std::string filename;
  if( argv[1])
    filename = argv[1];
  else
    filename = "/usr/share/xml/docbook/stylesheet/nwalsh/1.78.1/slides/slidy/graphics/unfold.bmp";

  std::ifstream file (filename.c_str(), std::ios::binary|std::ios::in);

//  BMPFileHeader head;

//  if (file.good())
//    file >> head;

//  BMPInfoHeader info;
//  if (file.good())
//    file >> info;

  BMP bmp;
  if (file.good())
    file >> bmp;

//  while (file.get(byte)) picmap.push_back(byte);

  return EXIT_SUCCESS;
}

Die structs habe ich einfach aus wp kopiert und alles überflüssige gelöscht bzw. Kommentare eingefügt.

Ob die Lese-Routine mit den vielen reads jetz gut ist weiß ich nicht (auf die Performance bezogen)...

cu

[zeropage]

biHeight als Höhe der Bitmap wird ja korrekt in Pixel ausgegeben.

Nur wenn bei mir irgendwo ein mir nicht nachvollziehbarer Fehler auftaucht, klappt gleich gar nichts mehr. Wollte jetzt casten, um zu schauen, ob ohne Vorzeichen bei biWidth der Wert auch korrekt ist, aber bekomme wieder irgendwelche Fehlermeldungen wegen fehlenden Semikolon und son Kram ... nerv

[zeropage]

@ nochmal dirkski

Uh, danke für die Mühe Auf den ersten Blick sieht das in etwa so aus, wie ich es auch mal vor Augen hatte, nur wie das ausgeschrieben wird, war mir unklar. Aber ich müsste mich in das Beispiel etwas einarbeiten, denn einiges ist mir nicht sofort bekannt.

Aber im Moment habe ich ja noch Schwierigkeiten mit meinem eigenen Code, dessen Fehler ich erst mal verstehen muss, bevor ich mich an komplexere wage.