Fractal-Visualisierung in Delphi

[rawsoul]

Bei dem Youtube-Filmchen steht die Renderzeit: 96 Stündchen.

[everdream]

von mir aus kann das auch gaaaaaaanz langsam gehen. dann kann ich vllt die selben pixeldaten über mehrere frames nutzen...

wie gesagt, bei mir musses ja auch nicht echtzeit sein.

hm, habe da aber grade ne ganz andere idee... wie wärs denn, wenn der user von hand reinzoomt, dann kann mit der mittelpunktkoordinate als "fixpunkt" ein video erstellen,... das müsste doch besser funktionieren, als einen "live zoom" zu berechnen,... das video sollte dann später auch ohne probleme flüssig laufen.
damit kenne ich mich aber leider garniicht aus -.-'

Zitat:

Bei dem Youtube-Filmchen steht die Renderzeit: 96 Stündchen.

macht ja nix ^_^

[everdream]

Also: Wenn ich jezz ne vergleichbare Renderzeit akzeptiere, dann kann ich ja frame für frame berechnen... is ja nur parameterveränderung.

Aber: Wie krieg ich das dann in eine Videodatei?

[everdream]

Okay, ich habe mich jetzt mal ein bischen mit BMP2AVI "eingearbeitet".

Jetzt habe ich noch 2 Aufgaben:

• Die Farben etwas harmonischer zu gestalten und
• dann die Berechnung noch zu optimieren

Zu den Farben hatte ich folgenden Ansatz:
Da man gelegentlich einen "ungünstigen" Pixel erwischt, sticht dieser dann farblich sehr stark hervor.
Ich hatte also überlegt, den Pixel nochmal in 4 Teile zu teilen und für jeden Teilpixel die Anzahl der Iterationen zu berechnen. Der Endgültige Pixelwert wäre dann der Mittelwert dieser 4 Zahlen.
Das bedeutet natürlich, dass ich 4 mal so viel Rechenleistung für den gleichen Bildausschnitt benötige.

Zur konkreten Farbberechnung hatte ich folgenden Ansatz:

Delphi-Quellcode:

var iterationen: integer; //Anzahl der Iterationen für diesen Bildpunkt
    r, g, b: byte; //Farben rot, grün, blau
case iterationen of
  0..255: begin
    r:=0;
    g:=255;
    b:=iterationen;
  end;
  256..512: begin
    r:=0;
    g:=512-iterationen;
    b:=255;
  end;
{...}
end;

So werden alle mehr oder weniger wichtigen Farben durchlaufen, je näher man ranzoomt.

Zur optimierung komme ich, wenn die Farbgebung stimmt. Das Auge programmiert hier schließlich mit ^.^

[everdream]

edit: sry, die datenbank wollte nicht, wie ich wollte...

[Khabarakh]

[OT]

Zitat:

Zitat von Kroko1999

Ob das wirklich live (CPU-Speed) ist :?:

Schaut euch einmal XaoS an, dessen Echtzeit-Zoom ist wirklich unglaublich.
[/OT]

[everdream]

Zitat:

Zitat von Khabarakh

Schaut euch einmal XaoS an, dessen Echtzeit-Zoom ist wirklich unglaublich.

Das ist echt nicht schlecht... Aber ich möchte höhere Auflösung und mehr Details, da nehme ich die Rechenzeiten auch in Kauf...

Das hier ist mein aktueller Code für die Iterationen. Habe das ganze schon um eine Variable und eine Zuweisung erleichtert.
Kann man da noch was mit Assambler rausholen? Jeder Takt zählt ^.^

Delphi-Quellcode:

procedure TMandelbrotSet.DrawSet(var Image: TImage);
var
  Pxl_x, Pxl_y: integer;
  dx, dy: double;
  RealC, ImagC: double;
  x0, x1, y1: double;
  Iterations: integer;
begin
  dx:=Range_X / Image.width;
  dy:=Range_y / Image.height;

  for Pxl_x:=0 to Image.width-1 do
  begin
    for Pxl_y:=0 to Image.width-1 do
    begin
      RealC:=(Center_x - 0.5 * Range_x) + (Pxl_x * dx);
      ImagC:=(Center_y - 0.5 * Range_y) + (Pxl_y * dy);

      Iterations:=0;
      x0:=0;
      y1:=0;

      repeat
        x1:=(x0*x0) - (y1*y1) + RealC;
        y1:=(2*x0*y1) + ImagC;
        x0:=x1;
        Inc(Iterations);
      until ( (iterations >= MaxIterations) or (((x1*x1) + (y1*y1)) >= MaxValue) );

      if (iterations=MaxIterations) then
        Image.Canvas.Pen.Color:=clBlack
      else
        Image.Canvas.Pen.Color:=ChooseColor(Iterations);
      Image.Canvas.MoveTo(Pxl_x,Pxl_y);
      Image.Canvas.LineTo(Pxl_x+1,Pxl_y);
    end;
  end;
end;

[Kroko1999]

(a) statt Image Bitmap nehmen und zum Schluß ins Image kopieren
(b) Scanline verwenden, statt moveto und lineto (pixel[c,y] := color hätte es auch getan)!

[everdream]

Danke für die Tipps!

Die Prozedur ist nur zum Anzeigen auf der Form. Habe nochmal fast die Gleiche, nur, dass die halt das ganze auf na Bitmap macht und die dann speichert, statt sie anzuzeigen.

Momentan geht es mir daraum die reine Berechnung der Iterationen zu optimieren. Werde deine Vorschläge einbringen (d.h. Scanline muss ich nochmal gucken, wie genau die funzt).

[Der Jan]

Hallo,

hab vor paar Jahren auch mal so ein Programm "verbrochen". :) Ich hänge es einfach mal an, anstatt einen eigenen Thread aufzumachen. Vielleicht kannst du dir ja noch ein paar Anregungen holen. Ist eigentlich auch recht schnell, vor allem, wenn man die Effekte ausschaltet.
Falls ich den Sourcecode noch finden sollte, werde ich ihn auch noch posten, müßte eigentlich aug irgendeiner alten CD rumliegen.
Im Archiv sind auch ein paar "Projekte" enthalten, die geladen werden können.