schnellerer Zugriff auf Tbitmap

[cumi]

@dizzy:Vielen Dank für deine Info!!
Nun leider durchschau ich das ganze mit der Graphics32 noch nicht ganz. Wie kann ich die einsetzen bzw. welche Files benötige ich wirklich? Ich habe gesehen, dass diese ja aus über 10 Units besteht und sicherlich einiges kann was ich nicht brauche. Ich muss eigentlich fast nichts könnten. Das einzige was ich können muss ist ein Bild in Form eines Bitmaps auf dem RAM anzulegen. Es Pixelweise zu beschreieben und zwar mit TColor Werten. Die TColor-Werte weise ich so zu:
color:=(tmp shl 16)+(tmp shl 8)+tmp //in tmp steht immer eine Zahl zwischen 0 und 255 (normales RGB System) geht das noch schneller? Also die shl und shr sind ja sicherlich was vom schnellsten... RGB kenn ich auch ist aber nicht ganz so schnell so viel ich weiss.
Danach möchte ich das Bild in einer Paintbox anzeigen. Dabei muss es teilweise noch gestrecht werden.
Das wäre eigentlich alles was ich machen muss. Es sollte natürlich so schnell wie möglich werden da dies relativ wichtig ist. Ich möchte die selbe Zuweisung dann noch für Filme benutzen und wenn ich das einige 1000Frames rechne spielt es schon eine Rolle ob ich eine Woche oder ein paar Stunde dran bin EndProjekt: Ein Fraktalprogramm welches einen Film von einem Zoom rechnen kann.

Vielen Dank für eure Hilfe!!!!

[dizzy]

Das was du brauchst ist recht einfach, und der Handhabung von TBitmap recht ähnlich. Du musst die Unit "GR32" einbinden, und ein "TBitmap32" als Offscreenbitmap erzeugen. Davon im Vorfeld auch gleich die größe setzen, ganz wie mit den normalen Bitmaps.

Jetzt kommt die G32 allerdings mit einem eigenen Farbformat her: "TColor32".
Aus der Hilfe zur G32:

Code:

Bits 32...24: Alpha
Bits 23...16: Red
Bits 15...8 : Green
Bits 7...0  : Blue

Also kannst du einzelne Pixel wie folgt bearbeiten:

Delphi-Quellcode:

var
  bmp: TBitmap32;
begin
  bmp := TBitmap32.Create;
  bmp.Width  := 320;
  bmp.Height := 240;

  bmp.Pixels[100, 100] := Color32(RotAnteil, GrünAnteil, BlauAnteil);
  // oder mit Alphakanal
  bmp.Pixels[100, 100] := Color32(RotAnteil, GrünAnteil, BlauAnteil, AlphaWert);
  // oder ohne Umwandlung mit shifting (ist bei der G32 NICHT zwangsläufig schneller!)
  bmp.Pixels[100, 100] := (AlphaWert shl 24) or (RotAnteil shl 16) or (GrünAnteil shl 8) or BlauAnteil;

Um dieses Bitmap irgendwo hin zu zeichnen hat TBitmap32 diverse überladene Versionen von "TBitmap32.DrawTo". Eine Variante kann auf ein beliebiges HDC zeichnen, z.B. ein "TCanvas.Handle". Das dürfte für dich interessant werden.

Zitat:

Ein Fraktalprogramm welches einen Film von einem Zoom rechnen kann.

Klingt interessant, aber was hab ich mir drunter vorzustellen?

Hoffe das hilft!
Fabian

[cumi]

Vielen Dank für deine Hilfe. Ich werds gleich mal ausprobieren. Was du dir darunter vorstellen sollt? Ähh also das Mandelbrotfraktal kennst du oder? jetzt kann man da ja reinzoomen indem man einen Rahmen zieht. Naja also ich möcht jetzt stufenlos ins Fraktal reinfliegen können Mal schauen wies rauskommt Ich komm mit dem schreiben von AVI-Files noch nicht ganz klar. Also ich hab mal den TAVIWriter angesehen. Doch den müste ich relativ stark umschreiben. Das erste Problem ist, dass der unter Delphi6 nicht läuft. Der Compiler bringt dort einenen Fehler so im Stil "Ausdruck gefunden aber then erwartet" mitten in einem Funktionsaufruf und der Courser steht an einem ort wo es sowieso nix hat. Naja ebenn die Rükwärtkompatibilität von Delphi Das zweite und noch viel grösere Problem ist. Dass der in der Orginalversion eigentlich so arbeitet, dass man zuerst alle bilder in eine Tbitmap list reinläut und er sie erst dann anfängt auf die HDD zu schreiben. Ist für mich auch unbrauchbar weil ich keine 10GB Ram habe
Naja mal schauen.... werd ich schon noch irgendwie hinkriegen...

[dizzy]

Mit Fraktalen hast du bei mir den richtigen Nerv getroffen (Siehe Anhang: Das war mein letztes größeres Projekt -> 3D-Julia Fraktale)

Der eigentliche Flaschenhals ist da allerdings weit weinger die Geschwindigkeit beim Zugriff auf das Bitmap, als viel mehr die Berechnungen selbst. Da kann ich dir meinen CQParser anbieten, bzw. die darin enthaltene Unit "QMath" die einige Methoden zum recht schnellen Rechnen mit komplexen Zahlen enthält.

Das Schreiben eines Videos habe ich bisher immer VirtualDub oder TMPGEnc überlassen, und einfach die Bitmaps auf Platte geschoben. Allerdings könnte dir das DSPack in dieser Richtung weiter helfen.

Viel Erfolg! Und wenn Fragen dazu sind: Ich bin eigentlich immer interessiert

Gruss,
Fabian

PS: Ääääähhh .mpg ist nicht als Anhang erlaubt... dann eben als .zip

[cumi]

das sieht ja (sorry) verdammt gut aus! Mit 3D Fraktalen hab ich mich noch nie beschäftigt. Vielleicht komm ich darauf zurück, wenn ich mit den 2D Fraktalen fertig bin
Zur berechnugn. Also hier mal den Code, welchen ich brauch um die Divergenze von einem Punkt zu berechenn:

Delphi-Quellcode:

  TComplex=record
    r,i:Extended;
  end;
(...)
function TFrmMain.CalcDivMandel(x,y:Extended):Integer;
var
  z1,z2:TComplex;
  h1,h2:Extended;
  i    :Integer;
begin
  z1.r:=0;
  z1.i:=0;
  i   :=0;
  repeat
    h1  :=z1.r*z1.r;
    h2  :=z1.i*z1.i;
    z2.r:=h1-h2      +x;
    z2.i:=2*z1.r*z1.i+y;
    z1:=z2;
    inc(i);
  until (i>=steps) or ((h1+h2)>4);
  result:=i;
end;

Nun also ich hab das ganze mit der GR32 Unit einmal ausprobiert. Und ich muss sagen... kein vergleich viel schneller. Nur leider versteh ich das mit dem Alpha Teil des TColor32 Typs noch nicht ganz. Für was ist der gut? Kann man den auch weglassen? Denn momentan hab ich noch das Problem, das meine Bitmaps vielviel grösser werden als sie vorhin waren. Dies ist relativ verherend da ich ja nicht belibig Ram habe....

Nun nochmals eine kurze Frage. Du sagtest du überlässt das "Filmmachen" an Virtualdub etc. Wie funktioniert das denn bei dir genau? Also Virtualdub kenn ich relativ gut. Ich benutzte es häufig zum umcodieren von Filmen. Jetzt speicherst du einfach alle Frames als Bitmap auf die HDD?

Danke, Greez cumi

[dizzy]

Zitat von cumi:

Also hier mal den Code, welchen ich brauch um die Divergenze von einem Punkt zu berechenn:

Delphi-Quellcode:

  TComplex=record
    r,i:Extended;
  end;
(...)
function TFrmMain.CalcDivMandel(x,y:Extended):Integer;
var
  z1,z2:TComplex;
  h1,h2:Extended;
  i    :Integer;
begin
  z1.r:=0;
  z1.i:=0;
  i   :=0;
  repeat
    h1  :=z1.r*z1.r;
    h2  :=z1.i*z1.i;
    z2.r:=h1-h2      +x;
    z2.i:=2*z1.r*z1.i+y;
    z1:=z2;
    inc(i);
  until (i>=steps) or ((h1+h2)>4);
  result:=i;
end;

Na das sieht doch recht gut aus! Wenn du auf die Genauigkeit verzichten kannst: Double ist deutlich schneller als Extended. Aber grad für einen Zoom kann die Genauigkeit interessant werden (ich selbst hab bei immens starkem Zoom auch schon mal das "Ende von Double" gesehen ).

Zitat von cumi:

Nun also ich hab das ganze mit der GR32 Unit einmal ausprobiert. Und ich muss sagen... kein vergleich viel schneller. Nur leider versteh ich das mit dem Alpha Teil des TColor32 Typs noch nicht ganz. Für was ist der gut? Kann man den auch weglassen? Denn momentan hab ich noch das Problem, das meine Bitmaps vielviel grösser werden als sie vorhin waren. Dies ist relativ verherend da ich ja nicht belibig Ram habe....

Den Alphateil kanst du ganz weg lassen, ja. Der sollte dann imho auf 255 gesetzt werden. Der wird erst interessant wenn du mehrere Bitmaps halbtransparent überlagern möchtest. Allerdings kann man ihn nicht ganz weg lassen, d.h. ein Pixel wird immer volle 32 Bit beanspruchen. Deshalb ja auch Graphics32 .
Die gesamte Sequenz im RAM zu halten ist imho ohnehin nicht so glücklich. Über Chunks von so 10 bis 20 Bitmaps im Speicher kann man reden, die dann in einem Schwupps geschrieben werden, aber ich hab jedes Bitmap direkt nach Fertigstellung weggeschrieben und fertig.

Zitat von cumi:

Nun nochmals eine kurze Frage. Du sagtest du überlässt das "Filmmachen" an Virtualdub etc. Wie funktioniert das denn bei dir genau? Also Virtualdub kenn ich relativ gut. Ich benutzte es häufig zum umcodieren von Filmen. Jetzt speicherst du einfach alle Frames als Bitmap auf die HDD?

Japp, genau so
Einfach mit aufsteigender Nummereierung benennen (z.B. frac0001.bmp; frac0002.bmp; ...; fracXXXX.bmp), und VirtualDub (und auch TMPGEnc) erkennen mit Öffnen des ersten Bildes der Sequenz dass es auch eine Sequenz ist, und behandelt es wie ein Video.
Ist zunächst mal die einfachere Variante während man sich noch mit den "wichtigen" Dingen rumplagen muss 8).

Gruss,
Fabian

[cumi]

Zitat von dizzy:

Na das sieht doch recht gut aus! Wenn du auf die Genauigkeit verzichten kannst: Double ist deutlich schneller als Extended. Aber grad für einen Zoom kann die Genauigkeit interessant werden (ich selbst hab bei immens starkem Zoom auch schon mal das "Ende von Double" gesehen ).

Jo wenn du mal so richtig reinzoomen willst kommst du mit den Double wirklich an den Anschlag... Und viel langsamer wirds ja mit Extended wahrscheinlich auch nicht sein, oder?

Zitat von dizzy:

Den Alphateil kanst du ganz weg lassen, ja. Der sollte dann imho auf 255 gesetzt werden. Der wird erst interessant wenn du mehrere Bitmaps halbtransparent überlagern möchtest. Allerdings kann man ihn nicht ganz weg lassen, d.h. ein Pixel wird immer volle 32 Bit beanspruchen. Deshalb ja auch Graphics32 .
Die gesamte Sequenz im RAM zu halten ist imho ohnehin nicht so glücklich. Über Chunks von so 10 bis 20 Bitmaps im Speicher kann man reden, die dann in einem Schwupps geschrieben werden, aber ich hab jedes Bitmap direkt nach Fertigstellung weggeschrieben und fertig.

Äh also bis jetzt hab ich ihn einfach immer gar nicht berücksichtigt. Daher wird er höchstwahrscheinlich auf 0 stehen... Funktioniert aber trotzdem. Kann aber auch sein das die Funktion Color32 den Alphawert automatisch auf 255 setz.
Nun du sagtest dieser werde für die Transparenz benutz. Wie funktioniert das? Mir ist gleich die Idee gekommen, dass ich eigentlcih übergänge von einer in die andere Farbe so rechnen könnte. Äh also mal eine Idee wie ich mir vorstellen könnte wies gehen könnte Kann man einfach zuerst was zeichen, sprich einen Pixel einfärben mit dem Alphawert 255 und danach den selben Pixel nochmals überschreiben allerdings mit einem Alphawert von zb. 128 und dann er der Pixel schlussentlich den Mittelwert? Naja war nur so eine Idee

Zitat von dizzzy:

Zitat von cumi:

Nun nochmals eine kurze Frage. Du sagtest du überlässt das "Filmmachen" an Virtualdub etc. Wie funktioniert das denn bei dir genau? Also Virtualdub kenn ich relativ gut. Ich benutzte es häufig zum umcodieren von Filmen. Jetzt speicherst du einfach alle Frames als Bitmap auf die HDD?

Japp, genau so
Einfach mit aufsteigender Nummereierung benennen (z.B. frac0001.bmp; frac0002.bmp; ...; fracXXXX.bmp), und VirtualDub (und auch TMPGEnc) erkennen mit Öffnen des ersten Bildes der Sequenz dass es auch eine Sequenz ist, und behandelt es wie ein Video.
Ist zunächst mal die einfachere Variante während man sich noch mit den "wichtigen" Dingen rumplagen muss 8).

Ah supi, wusste nicht das dies so einfach geht Naja wie soll man schno auf die Ideekommen eine *.bmp Datei mit VirtualDub zu laden....

------------------
Nun hab ich aber trotzdem nochmals eine Frage. Also irgendwas mach ich da noch nicht ganz richtig habe ich bemerkt. Es sind nicht einfach TBitMap32 die mehr Stack brauchen, nein ich brauche wenn ich das selbe nochmals rechne und eigentlich nicht weitere TBitMaps erzeuge (mach ich dann auch teilweise in einer doppeltverlinkten Liste. Seit ich dieses System kenne brauch ich es wo es nur irgendwie einbisschen Sinn macht weil mich die Geschwindigkeit und die Bedienung fast vom Stuhl gehauen hat ).
Ich überschreibe dabei allerdings ein vorhandenes TBitMap immer wieder. Nun der fehler muss wohl dabei liegen.
Ich mache dies so:

Delphi-Quellcode:

  img:=TBitmap32.Create;   //img ist vom Typ TBitMap32
  img.Width:=sRef.dx;
  img.Height:=sRef.dy;

Ich hab dann mal zum probieren immernoch vor dem TBitmap32.Create img.free aufgerufen, was allerdings keine Abhilfe schuf.
Iregdnwer eine Idee was da sonst noch schieflaufen könnte??

Ah ja und gibts kei Tool von Delphi her welches einem anzeigt wo wieviel Speicher gebraucht wird? Ich benutze bis jetzt (ich weiss, dass es nichts dümmeres gibt ) den Taskmanager von WinXP. Ich zweifle jedoch an dessen Richtigkeit.....

Vielen Dank für eure Hilfe! Greez cumi

[dizzy]

Zitat von cumi:

Jo wenn du mal so richtig reinzoomen willst kommst du mit den Double wirklich an den Anschlag... Und viel langsamer wirds ja mit Extended wahrscheinlich auch nicht sein, oder?

Immerhin ca. Faktor 3 (bei einfacher Addition). Hab hier mal einen Test mit so ziemlich allen Typen gemacht.

Zitat von cumi:

Äh also bis jetzt hab ich ihn einfach immer gar nicht berücksichtigt. Daher wird er höchstwahrscheinlich auf 0 stehen... Funktioniert aber trotzdem. Kann aber auch sein das die Funktion Color32 den Alphawert automatisch auf 255 setz.

Wenn du bei Color32() nur 3 Parameter übergibst, dann ist Alpha per default auf 255 (= voll Deckend)

Zitat von cumi:

Nun du sagtest dieser werde für die Transparenz benutz. Wie funktioniert das? Mir ist gleich die Idee gekommen, dass ich eigentlcih übergänge von einer in die andere Farbe so rechnen könnte. Äh also mal eine Idee wie ich mir vorstellen könnte wies gehen könnte Kann man einfach zuerst was zeichen, sprich einen Pixel einfärben mit dem Alphawert 255 und danach den selben Pixel nochmals überschreiben allerdings mit einem Alphawert von zb. 128 und dann er der Pixel schlussentlich den Mittelwert? Naja war nur so eine Idee

Das geht, allerdings nicht via TBitmap32.Pixels[], da du damit den Pixel incl. Alphawert ganz neu setzt. Du müsstest dir ein zweites TBitmap32 machen, und dort dein zu überblendendes Bitmap mit Transparenzen rein schreiben. (TBitmap32.BlendMode muss dann auf dmBlend gesetzt werden.) Dann kannst du das mit DrawTo() auf das erste drauf malen, mit Berücksichtigung der Alphawerte.

Zitat von cumi:

Ah supi, wusste nicht das dies so einfach geht Naja wie soll man schno auf die Ideekommen eine *.bmp Datei mit VirtualDub zu laden....

Ich habs einfach ausprobiert, da es in der Filterliste des Open-Dialogs steht

Zitat von cumi:

Nun hab ich aber trotzdem nochmals eine Frage. Also irgendwas mach ich da noch nicht ganz richtig habe ich bemerkt. Es sind nicht einfach TBitMap32 die mehr Stack brauchen, nein ich brauche wenn ich das selbe nochmals rechne und eigentlich nicht weitere TBitMaps erzeuge (mach ich dann auch teilweise in einer doppeltverlinkten Liste. Seit ich dieses System kenne brauch ich es wo es nur irgendwie einbisschen Sinn macht weil mich die Geschwindigkeit und die Bedienung fast vom Stuhl gehauen hat ).
Ich überschreibe dabei allerdings ein vorhandenes TBitMap immer wieder. Nun der fehler muss wohl dabei liegen.
Ich mache dies so:

Delphi-Quellcode:

  img:=TBitmap32.Create;   //img ist vom Typ TBitMap32
  img.Width:=sRef.dx;
  img.Height:=sRef.dy;

Ich hab dann mal zum probieren immernoch vor dem TBitmap32.Create img.free aufgerufen, was allerdings keine Abhilfe schuf.
Iregdnwer eine Idee was da sonst noch schieflaufen könnte??

Das ständige Freigeben und Neuerstellen ist imho sehr unsauber, zumal der Speichermanager von Delphi dazu neigt einmal alloziierten Speicher nicht umgehend an Windows zurück zu geben (zur Geschwindigkeitsoptimierung). Nimm besser eine einzige Variable vom Typ TBitmap32 und mache vor dem Neuzeichnen ein Clear(Color32(0,0,0));
btw: Du schreibst "Stack". Objekte werden doch aber auf dem Heap angelegt, oder?

Zitat von cumi:

Ah ja und gibts kei Tool von Delphi her welches einem anzeigt wo wieviel Speicher gebraucht wird? Ich benutze bis jetzt (ich weiss, dass es nichts dümmeres gibt ) den Taskmanager von WinXP. Ich zweifle jedoch an dessen Richtigkeit.....

Ich habe hier schon öfters memproof gelesen. Benutzt hab ich es allerdings noch nicht.

Arrividetschi
Fabian

[cumi]

Zitat von dizzy:

Immerhin ca. Faktor 3 (bei einfacher Addition). Hab hier mal einen Test mit so ziemlich allen Typen gemacht.

Hmm, hab jetzt mal alles in Double umgewandelt und ich hol ca. einen Faktor 2 an Zeit raus. Daher denke ich werd ich von jetzt an Double benutzen. Und wenn ichs dann doch mal noch genauer haben will ist es ja ein kleines das Programm nochmals schnell mit Extended zu compilieren.
Mal noch eine Frage. Was machst du eigentlich beruflich? Informatik ist nicht nur dein Hobby, oder? Ich bin immerwieder aufs neue erstaunt wie genau, dass du über all diese Dinge bescheid weisst.... Und hier gleich noch der absolut passende Test

Zitat von dizzy:

Das geht, allerdings nicht via TBitmap32.Pixels[], da du damit den Pixel incl. Alphawert ganz neu setzt. Du müsstest dir ein zweites TBitmap32 machen, und dort dein zu überblendendes Bitmap mit Transparenzen rein schreiben. (TBitmap32.BlendMode muss dann auf dmBlend gesetzt werden.) Dann kannst du das mit DrawTo() auf das erste drauf malen, mit Berücksichtigung der Alphawerte.

Kann ich mal ausprobieren, ja.
Jetzt bin ich gleich an einem Problem angelangt das eigentlich auch hierhinein gehört und zwar:
Ich habe zwei Farben (TColor32). Nun möchte ich einen Übergang von der einen in die andere berechnen. Ich nehme an, dass es hierfür von der GR32 auch Möglichkeiten gibt. Ich hab sie leider nur noch nicht gefunden

Zitat von dizzy:

Das ständige Freigeben und Neuerstellen ist imho sehr unsauber, zumal der Speichermanager von Delphi dazu neigt einmal alloziierten Speicher nicht umgehend an Windows zurück zu geben (zur Geschwindigkeitsoptimierung). Nimm besser eine einzige Variable vom Typ TBitmap32 und mache vor dem Neuzeichnen ein Clear(Color32(0,0,0));

Äh also das geht leider nicht weil ich immerwieder die Gröse ändere, also .Width und .Height neu setze (resize des Forms)...

Zitat von dizzy:

btw: Du schreibst "Stack". Objekte werden doch aber auf dem Heap angelegt, oder?

äh jo stimmt, so genau hab ichs nicht genommen Sagen wir einfach mal im Speicher

Zitat von dizzy:

Zitat von cumi:

Ah ja und gibts kei Tool von Delphi her welches einem anzeigt wo wieviel Speicher gebraucht wird? Ich benutze bis jetzt (ich weiss, dass es nichts dümmeres gibt ) den Taskmanager von WinXP. Ich zweifle jedoch an dessen Richtigkeit.....

Ich habe hier schon öfters memproof gelesen. Benutzt hab ich es allerdings noch nicht.

Werd ich auch mal ausprobieren... Wäre schon noch schön ein genaueres Abbild des Speichers zu sehen.


Zum Schluss möcht ich dir, Fabian, nochmals ganz herzlich danken für deine Geduld mir alle Fragen zu beantworten. Bin ich echt mega super froh Denn wenn ich das alles in Büchern oder im Netz zusammensuchen müsste würd ichs glaub ich gar nicht finden oder dann hätte ich ein halbes Jahr

Greez cumi

[dizzy]

Zitat von cumi:

Mal noch eine Frage. Was machst du eigentlich beruflich? Informatik ist nicht nur dein Hobby, oder? Ich bin immerwieder aufs neue erstaunt wie genau, dass du über all diese Dinge bescheid weisst.... Und hier gleich noch der absolut passende Test

Ich bin "beruflich" Student der Informatik. Allerdings hat dieses mit dem Thema hier nicht sehr viel zu tun - das ist eigentlich 100% privates Interesse und jahrelang aufkummuliertes (Halb-)Wissen

Zitat von cumi:

Jetzt bin ich gleich an einem Problem angelangt das eigentlich auch hierhinein gehört und zwar:
Ich habe zwei Farben (TColor32). Nun möchte ich einen Übergang von der einen in die andere berechnen. Ich nehme an, dass es hierfür von der GR32 auch Möglichkeiten gibt. Ich hab sie leider nur noch nicht gefunden

Das macht dir die G32 nicht ganz so einfach wie du es gerne hättest . Das Zauberwort heisst hier lineare Interpolation, und zum Mischen zweier Farben dürftest du hier in der DP auch einiges finden.
Allerdings bringt die G32 eine nette Routine mit, die das Mischen recht effizient (weil mit MMX) umsetzt: "Combine(X, Y, W: TColor32): TColor32"
Auszug aus der Hilfe:

Zitat:

Returns the color with components calculated as linear interpolation between X and Y colors. The W parameter, which sholuld be in [0..255] range, specifies the weight of the first color (X). The alpha channel is interpolated as well.

Wichtig ist dabei, dass du nachher die Prozedur "EMMS;" aufrufst bevor du wieder mit normalen Fließkommarechnungen anfängst, da sonst die CPU auf MMX geschaltet bleibt, und keine normalen FLOPs mehr berechnet.

Zitat von cumi:

Äh also das geht leider nicht weil ich immerwieder die Gröse ändere, also .Width und .Height neu setze (resize des Forms)...

Na dan ändere doch einfach die Größe . Dazu musst du das Bitmap ja nicht neu erstellen! (btw: TBitmap32.SetSize(X, Y) ist etwas effizienter als das einzelne Zuweisen an Width und Height.)

Zitat von cumi:

äh jo stimmt, so genau hab ichs nicht genommen Sagen wir einfach mal im Speicher

Oki

Zitat von cumi:

Zum Schluss möcht ich dir, Fabian, nochmals ganz herzlich danken für deine Geduld mir alle Fragen zu beantworten. Bin ich echt mega super froh Denn wenn ich das alles in Büchern oder im Netz zusammensuchen müsste würd ichs glaub ich gar nicht finden oder dann hätte ich ein halbes Jahr

Keine Ursache. Was meinst du wie viel Wissen ich diesem Forum schon zu verdanken hab .
Macht ja Spaß!

Cu,
Fabian