Bmp2C.exe Output interpretieren

[doublesobig (Gast)]

Ich habe den Output der Bmp2C.exe vorliegen, jedoch leider nicht mehr 
die .bmp Datei mit welcher der Output generiert wurde. Gibt es eine 
Möglichkeit wie ich den generierten C/C++ Code interpretieren kann?
Hier noch ein Beispielblock aus der C/C++ Datei:

   0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
   0x40,0x40,0x40,0x00,
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   0x02,0x82,0x42,0x22,0xf2,0x0e,0x22,0x42,0x82,0x02,0x00,0x00,
   0x01,0x00,0x00,0x00,
   0x0f,0x00,0x00,0x00,0x00,0x01,0x00,0x00,
   0x00,0x38,0x27,0x24,0x24,0x24,0x24,0x24,0x24,0xe4,0x04,0x00,
   0x01,0x01,0x01,0x01,0x01,0x01,0x09,0x09,0x08,0x07,0x00,0x00,

Ich freue mich über eine Rückmeldung!

[Hmmm (Gast)]

doublesobig schrieb:
> Gibt es eine Möglichkeit wie ich den generierten C/C++ Code
> interpretieren kann?

C-Compiler können gut mit C-Code umgehen.

[Falk B. (falk)]

doublesobig schrieb:
> Ich habe den Output der Bmp2C.exe vorliegen, jedoch leider nicht mehr
> die .bmp Datei mit welcher der Output generiert wurde. Gibt es eine
> Möglichkeit wie ich den generierten C/C++ Code interpretieren kann?

Du willst also aus dem C Code wieder die anschaubare BMP-Datei machen. 
Naja, das geht recht einfach, indem man in einem Mini-C Programm die 
Datei als Binärdaten in eine Datei schreibt.

Lad deine C-Datei hier hoch, vielleicht macht das Einer für dich.

[Gustl B. (-gb-)]

doublesobig schrieb:
> generierten C/C++ Code

Mit welchem Encoding soll das denn C/C++ Code sein? Ich sehe da keinen 
Code.

Guck dir an wie eine BMP aufgebaut ist. Da bringt ein

doublesobig schrieb:
> Beispielblock

ziemlich wenig denn die BMP hat einen Header der steht am Anfang. Oder 
es muss zumindest definiert sein welche Farbtiefe und welche Auflösung 
das Bild hat.

[Dirk B. (dirkb2)]

Code in einem char-Array definieren.
Das Array in eine Datei schreiben (binary mode).

Dann mit Irfan-View ansehen. Das kann auch RAW-Bilder lesen.


Gustl B. schrieb:
> denn die BMP hat einen Header der steht am Anfang.

Muss nicht, denn es ist nicht das Windows Paint Dateiformat gemeint.

[Gustl B. (-gb-)]

Dirk B. schrieb:
> Windows Paint Dateiformat

Wäre mir neu, dass Paint ein eigenes Dateiformat hat.

Zumindest die Auflösung, also Zeilenlänge, muss irgendwo stehen.

[doublesobig (Gast)]

Ein Beispiel mit dem geposteten Code wäre vollkommen ausreichend für 
mich.
const unsigned char Array[] = { 
0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
0x40,0x40,0x40,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x02,0x82,0x42,0x22,0xf2,0x0e,0x22,0x42,0x82,0x02,0x00,0x00,
0x01,0x00,0x00,0x00,
0x0f,0x00,0x00,0x00,0x00,0x01,0x00,0x00,
0x00,0x38,0x27,0x24,0x24,0x24,0x24,0x24,0x24,0xe4,0x04,0x00,
0x01,0x01,0x01,0x01,0x01,0x01,0x09,0x09,0x08,0x07,0x00,0x00};

Die gesamte Datei ist meiner Meinung nach zu lang, sie besteht auch nur 
aus diesem Array was bis zum Rand gefüllt ist.

Informationen bezüglich Header habe ich nicht. So sehen die Elemente in 
diesem Array aus.

Ich verstehe ehrlich gesagt nicht so recht, was du mit Schreiben im 
binary mode meinst. Sollte das Ziel dann eine .bin sein, die ich mit 
IrfanView öffnen kann?

[Εrnst B. (ernst)]

doublesobig schrieb:
> Ich verstehe ehrlich gesagt nicht so recht, was du mit Schreiben im
> binary mode meinst.

Einfach Byte-für-Byte rausschreiben. Dabei keine automagischen 
Konvertierungen "\n"->"\r\n", UTF8,  o.Ä. aktiv haben.

d.H. am Schluss hast du eine Datei bei der im ersten Byte 0x30, im 
zweiten auch 0x30, im dritten 0x00 usw. steht.

Das sind deine Pixel-Infos. Dann musst du rausknobeln, wieviele Pixel es 
in der Breite Sind, und wieviele Bytes pro Pixel gespeichert sind.
Das konfigurierst du in einer Bild-Konverter-Software, und schreibst 
wieder ein BMP oder PNG oder TIFF oder wasauchimmer daraus.

[Gustl B. (-gb-)]

doublesobig schrieb:
> Ein Beispiel mit dem geposteten Code wäre vollkommen ausreichend für
> mich.

Gut, wenn du meinst:
Welche Farbtiefe? Mit Welcher Farbe beginnt der Ausschnitt? Mit welcher 
Pixel und Zeilennummer beginnt der Ausschnitt? Wie lange ist eine Zeile?

[doublesobig (Gast)]

Gustl B. schrieb:
> Welche Farbtiefe? Mit Welcher Farbe beginnt der Ausschnitt? Mit welcher
> Pixel und Zeilennummer beginnt der Ausschnitt? Wie lange ist eine Zeile?

Eben deshalb stelle ich ja die Frage hier. Ich erkenne selber nicht den 
typischen Aufbau einer Bitmap die ja hoffentlich Output der Bmp2C.exe 
sein sollte.(aus einer Bitmap ist es ja trivial diese Informationen zu 
entnehmen) Ich weiß eben nicht, wie das alles zu interpretieren ist und 
wie ich aus den Informationen ein Bild extrahieren kann.

[Εrnst B. (ernst)]

doublesobig schrieb:
> Ein Beispiel mit dem geposteten Code wäre vollkommen ausreichend für
> mich.

bitteschön.

test.c kompilieren, ausführen.

dann mit imagemagick:

  convert -depth 8 -size 8x4 rgb:test.raw result.png

Dein Quell-Bild war nicht RGB? Hatte keine 24 Bit/Pixel? War nicht 8×4 
Pixel groß?
Dann stimmt das result.png nicht.

[Gustl B. (-gb-)]

doublesobig schrieb:
> Ich weiß eben nicht, wie das alles zu interpretieren ist und
> wie ich aus den Informationen ein Bild extrahieren kann.

Dann wären ein paar mehr Informationen hilfreich, z. B. wie viele Bytes 
sind das insgesamt? Daraus könnte man schonmal recht gut die Auflösung 
erraten wenn das z. B. 921600 oder 2359296 oder ... sind.

[doublesobig (Gast)]

Εrnst B. schrieb:
> Dein Quell-Bild war nicht RGB? Hatte keine 24 Bit/Pixel? War nicht 8×4
> Pixel groß?
> Dann stimmt das result.png nicht.

Danke dir für deine Mühe. Ehrlich gesagt habe ich das Ergebnis nicht 
erwartet, werde es aber erstmal in ein paar weiteren Fällen betrachten.

[doublesobig (Gast)]

Hast du die Bildparameter aus dem Array gewonnen oder war es eine 
Annahme deiner Seite?

[S. R. (svenska)]

doublesobig schrieb:
> Hast du die Bildparameter aus dem Array gewonnen
> oder war es eine Annahme deiner Seite?

Das war eine Annahme, denn die Chancen stehen gut, dass die 
Bildparameter in dem Array nicht drinstehen.

[Εrnst B. (ernst)]

doublesobig schrieb:
> Annahme deiner Seite?

Geraten. 96 Bytes lässt sich ohne Rest durch 3 Teilen, deshalb Annahme 
RGB, ==> 32 Pixel.
32 Pixel auf ein Rechteck verteilen?

1×32, 2×16  => sind mir zu unförmig
deshalb versuch mit 8×4.

Schaut aber nicht richtig aus.

Also: von vorne, Parameter ändern...


Das meine ich mit:

Εrnst B. schrieb:
> Dann musst du rausknobeln, wieviele Pixel es
> in der Breite Sind, und wieviele Bytes pro Pixel gespeichert sind

Wenn das BMP2C das nicht irgendwo in einem Kommentar im C-File abgelegt 
hat.

[doublesobig (Gast)]

Ich habe einen Kommentar gefunden, in dem folgende Anmerkungen stehen:

// Memorysize:  5376 bytes (12 bytes per Line)
// Bitmapsize   X:12 Y:3584
// Bits per Pixel:1

[Gustl B. (-gb-)]

Sehr gut! Ohne diesen Kommentar hätte man lange probieren können bis da 
diese seltsame Auflösung rauskommt.

Also ist das Schwarz/Weiß. Aber um aus deinem Ausschnitt ein Bild zu 
rechnen bräuchte man trotzdem die Position des ersten Bytes, also welche 
8 Pixel sind das in einer Zeile?

Edit:

[[0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 1.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1.]
 [0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 0. 0.]
 [0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]
 [0. 0. 1. 0. 0. 0. 1. 0. 1. 1. 1. 1.]
 [0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0.]
 [0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0.]
 [0. 0. 1. 0. 1. 0. 0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [1. 1. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1.]
 [1. 0. 0. 0. 0. 0. 1. 0. 0. 1. 1. 1.]
 [0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]
 [0. 1. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0.]
 [0. 0. 1. 0. 0. 1. 0. 0. 0. 0. 1. 0.]
 [0. 1. 0. 0. 0. 0. 1. 0. 0. 1. 0. 0.]
 [1. 1. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 0.]
 [1. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 0. 0. 1. 1. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

Allerdings ist bei deinem Ausschnitt an Bytes unklar ob der an einem 
Zeilenanfang oder irgendwo sonst beginnt.

[doublesobig (Gast)]

Kann man da nicht eine ähnliche Aussage wie Ernst B. treffen? Bei einem 
Bit pro Pixel und insgesamt 96 Byte könnten es ja z.B. 12 x 8 Byte sein.
Es sollte auf jeden Fall ein chinesisches Schriftzeichen ergeben. Bei 
deinem Ergebnis sieht es fast so aus, als könnte man ein chinesisches 
Schriftzeichen erlangen, wenn man es in der Länge teilt und die 8 12x8 
Blöcke übereinander legt.

[Gustl B. (gustl_b)]

Bei 12 Pixeln Breite ist das Bild 1,5 Bytes breit.

Man kann viel vermuten. Unklar ist und bleibt wo das erste Byte steht. 
Ist das im Bild ganz oben links?
Dann ist unklar ob das little oder big endian ist.
Schön wäre die ganze Bilddaten und nicht nur dieser Ausschnitt. Aber da 
ja jetzt sowohl Auflösung als auch Farbtiefe bekannt sind kannst du das 
selber schnell zu einem Bildchen bauen und ausprobieren wenn es auf 
Anhieb nicht korrekt aussieht.

[A. S. (Gast)]

doublesobig schrieb:
> Ich habe einen Kommentar gefunden, in dem folgende Anmerkungen stehen:

doublesobig schrieb:
> Es sollte auf jeden Fall ein chinesisches Schriftzeichen ergeben.

Das ist aber alles schon arg Salami.

Gibt es weitere Infos, die Du hast? Z.b. welches Zeichen?

Ein Puzzle ohne Randteile ist einfacher, wenn man Infos zum Motiv hat.

[Mark B. (markbrandis)]

Gustl B. schrieb:
> Bei 12 Pixeln Breite ist das Bild 1,5 Bytes breit.
>
> Man kann viel vermuten. Unklar ist und bleibt wo das erste Byte steht.
> Ist das im Bild ganz oben links?

Laut dem Standard ist das Pixel mit den Koordinaten (0,0) unten links:

https://en.wikipedia.org/wiki/BMP_file_format#File_structure

[Gustl B. (gustl_b)]

Dann ist das Bild eben punktgespiegelt. Aber egal solange hier nur 
Fragmente gepostet werden kann man nicht sinnvoll helfen.

Bei dem Seitenverhältnis tippe ich auch nicht auf ein Schriftzeichen 
sondern einen ganzen Zeichensatz.

[doublesobig (Gast)]

Ich kann wie gesagt keine weiteren Infos geben und das Array besteht nur 
aus vielen weiteren solcher Konstrukte. Deshalb hätte das vollständige 
Array auch nur wenig Sinn (hat auch ca. 6000 Zeilen). Die Header 
Informationen scheinen irgendwann verloren gegangen zu sein.Ich habe 
leider auch keinen Ansprechpartner.

Informationen über die Zeichen habe ich nicht. Wird wohl alles der 
vereinfachte chinesische Zeichensatz sein. Da nicht mit sonderlich viel 
Weitblick programmiert wurde, ist es eben auch möglich, dass in einem 
"Block" mehrere Zeichen stehen.

[A. S. (Gast)]

doublesobig schrieb:
> ch kann wie gesagt keine weiteren Infos geben und das Array besteht nur
> aus vielen weiteren solcher Konstrukte. Deshalb hätte das vollständige
> Array auch nur wenig Sinn (hat auch ca. 6000 Zeilen)

Wenn es "komisch" formatiert ist, ist es kaum so aus dem Konverter 
gefallen. Du kannst uns weiter raten lassen oder das File posten. Das 
sind doch bloß ein paar kB

doublesobig schrieb:
> Informationen über die Zeichen habe ich nicht.

Unwahrscheinlich, dass Dir jemand ein Projekt übergibt und dann sagt, 
hier ist ein File mit Schriftzeichen. Woher die stammen, wie sie 
verwendet werden, wo sie angezeigt werden, auf welcher HW das eingesetzt 
wird, ist unbekannt.

doublesobig schrieb:
> Da nicht mit sonderlich viel Weitblick programmiert wurde, ist es eben
> auch möglich, dass in einem "Block" mehrere Zeichen stehen.

Es gibt also auch noch SW drumherum, deren Qualität Du beurteilen 
kannst? Die vielleicht sogar vorliegt?

[A. S. (Gast)]

Gustl B. schrieb:
> Allerdings ist bei deinem Ausschnitt an Bytes unklar ob der an einem
> Zeilenanfang oder irgendwo sonst beginnt.


Das Muster scheint so aufgebaut, dass die 8Bit jedes Bytes "quer" zu den 
einzelnen Bytes sind. Als Beispiel, wenn ein Zeichen 12 Spalten a 16 
Zeilen ist:

Byte 0:
Bit0 = Reihe 0, Spalte 0
Bit1 = Reihe 1, Spalte 0
...
Bit7 = Reihe 7, Spalte 0

Byte 1:
Bit0 = Reihe 0, Spalte 1
Bit1 = Reihe 1, Spalte 1
...
Bit7 = Reihe 7, Spalte 1

Byte 12:
Bit0 = Reihe 0, Spalte 12
ODER = Reihe 8, Spalte 0

Bit1 = Reihe 0, Spalte 12
ODER = Reihe 9, Spalte 0

[Gustl B. (-gb-)]

Pics or it didn't happen (-:

Edit:
Bildchen angefügt, gute Idee, danke! Jetzt hat der TO aber wirklich 
genug Hinweise wie er seine Aufgabe lösen kann.

[Mark B. (markbrandis)]

doublesobig schrieb:
> Ich freue mich über eine Rückmeldung!

Wir übrigens auch.

[doublesobig (Gast)]

Vielen Dank für eure Mühe.
Ich werde versuchen die Idee zu implementieren und kann dann eine finale 
Rückmeldung geben.
Sieht mir aber schon sehr nach chinesischen Schriftzeichen aus :)

[Philipp K. (philipp_k59)]

Wenn man schon programmiert, wieso nicht ein kleines Tool selbst 
schreiben das in einem Fenster mögliche Zusammenhänge anzeigt und man 
nur noch zuschauen muss. Nur mal so als Pseudobeispiel...

int x=0; int y=0; int maxheight=100; int maxWidth=100; int offset=0; int bytewidth=3;

const unsigned char Array[] = { 
0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40};

for(int b=1;b<bytewidth;b++)
for(int i=0;i<offset;i++)
for(int h=0;h<=maxheight;h++){
y++; x=0;    
for(int w=0;w<maxWidth*bytewidth;w=w+bytewidth)
     { 
x++;
if(bytewidth==1)
setPixel(x,y,Array[offset+i*h*bytewidth]);
else if(bytewidth==2){
setPixel(x,y,Array[offset+i*h*bytewidth]);
setPixel(x,y,Array[offset+i*h*(bytewidth+1)]);
}
else if(bytewidth==3){
setPixel(x,y,Array[offset+i*h*bytewidth]);
setPixel(x,y,Array[offset+i*h*bytewidth+1]);
setPixel(x,y,Array[offset+i*h*bytewidth+2]);
}
       delay(100);
       
     }
}
}

[doublesobig (Gast)]

Ich habe mich jetzt dazu entschieden, eine vollständige Bitmap aus den 
gegebenen Werten zu erstellen. Die Größe passe ich nachträglich mittels 
magnify von imagemagick an. Die Hinweise die ich dankenswerterweise von 
euch bekommen habe, waren bei der Erstellung der Bitmap sehr hilfreich.

[W.S. (Gast)]

doublesobig schrieb:
> Ich habe mich jetzt dazu entschieden, eine vollständige Bitmap aus den
> gegebenen Werten zu erstellen. Die Größe passe ich nachträglich mittels
> magnify von imagemagick an.

Und was soll dann dabei herauskommen? Wen du bei solch einfachen kleinen 
Grafiken etwas skalierst, dann kommt immer Matsch dabei heraus, es sei 
denn, du skalierst integer, also mal 2 oder mal 3 oder so, dann werden 
die Klötzchen eben nur größer.

Aber wozu?
Wenn du kleine scharfe Icons brauchst, dann ist es allemal besser, diese 
selber zu malen - z.B. mit MSPaint, das kann mit passender Vergrößerung 
pixelweise.

Abgesehen davon scheint mir dieses Bmp2C ein ziemlich lausiges Programm 
zu sein. Einfach nur einen Sack voll Zahlen auszuspeien, ohne irgend 
einen Kommentar, ohne irgend eine Formatangabe - igitt.

W.S.