Hallo,

ich möchte eine kleine Visualisierung für Fractale (bzw. zum Testen erstmal für die Mandelbrotmenge) entwickeln. Die Berechnungen hab ich alle schon. Ich brauche nur noch etwas, um meine Ergebnisse schnellstmöglich darzustellen.

Für alle, die jetzt nicht wissen was ich eigentlich mache:

• entweder kurz bei wiki nachlesen: Link zum Artikel "Mandelbrotmenge"
• oder, wenn euch das zu lang ist, folgende Situation:
  Ich habe für jeden Pixel einen Integerwert, der in eine Farbe umgerechnet und angezeigt werden soll.

Mit Canvas Pixel für Pixel zeichnen ist allerdings recht langsam, vor allem, wenn man bei höheren Auflösungen bildschirmfüllend anzeigen will.

Ich vermute, dass DirectX oder OpenGL meine Ansprechpartner sind. Wenn ich da richtig liege, könnte mir jemand einige Informationen dazu zukommen lassen?

Vielen Dank schonmal im Voraus!

lg, Max!

P.S.: Ich weiß, "gibts schon", aber ich hab halt Spaß dran

Wie malst du bisher "pixelweise"? Nutzt du die Eigenschaft Pixels[] des Canvas oder schon ein OffScreenBitmap und dessen ScanLine[] Eigenschaft? Wenn ersteres, dann suche nach letzterem hier im Forum. Wenn letzteres, dann zeig mal den Code...

Bis jetzt male ich Pixel für Pixel mit Pen.color und canas.moveto/canvas.lineto.
werde mich mal nachder OffScreenBitmap erkundigen.

Habe mir orgestellt am ende einen flüssigen Zoom ins bild zu haben, wäre das damit möglich?


edit: Zu "OffScreenBitmap" find' ich irgendwie nich so viel. Meinst du damit einfach TBitmap?

Ich denke, dass er das meint, ja. Ein OffScreenBitmap wäre meiner Meinung nach ein TBitmap, welches nicht auf dem Bildschirm, sondern nur im Speicher existiert.

Der Zoom damit wäre nicht möglich, zumindest nicht flüssig. Ein Pixel ist ein Pixel.

nja, aber das ganze soll ja angezeigt werden,... im speicher bringts mir nix (ich weiß, bitmaps kann man ja auch anzeigen lassen)

ist das vllt mit DirectX oder OpenGL einfacher? or allem der zoom?

Bei DX bzw. OGL wirst du auch Pixel bemalen müssen, kommt also so ziemlich aufs gleiche raus. Du könntest jedoch eine - sagen wir mal 100px * 100px Darstellungsfläche setzen, jedoch ein gestretchtes (StretchBlt), oder verkleinertes Bitmap mit viel größeren Dimensionen darstellen.

Natürlich kannst du das OffScreenBitmap später darstellen, wenn du es fertig gezeichnet hast (TImage.Picture.Bitmap.Assign(TBitmap), ich glaube sogar, mit TImage.Assign(TBitmap) geht es auch). Oder bestehst du darauf, den Zeichenprozess beobachten zu können?

Nee, ich muss da nicht zugucken können.
Mir wäre auch recht, dass er im Voraus schonmal die Berechnungen für x-frames durchführt, bevor er startet, aber es muss ja möglich sein so einen Zoom hinzubekommen.

Müsste ich dann erstmal x bitmaps erstellen und die dann einfach alle zeigen lassen? das wäre sehr speicheraufwändig!
Das muss doch irgendwie anders gehen!

Wenn das so ist, dann nutze doch das zeichnen im OffScreenBitmap.

Ein verkleinertes Bild ist ja nicht mehr als ein (großes) Bild, bei welchem nicht alle Pixel dargestellt werden. Also berechne ein großes und stelle beim Zoomen den Skalierungsfaktor hoch. Der Benutzer kann dann selbst hineinzoomen.

ich hab ja schon ne lösung, bei der der user selbst zoomt, das ganze passiert halt auch noch mit canvas usw....
screenshots kann man da aber auch schon machen (ein screenshot vom 1600x1600 ist allerdings 10MB groß)

alles noch weit weg von perfektion!

das soll ja selber zoomen, darum gehts ja. sonst bräuchte ich auch nich (viel) schneller zeichnen....

Was machst du hier eigentlich für ein Aufstand? Eine Frage, vieles wird angenommen und alles ist schon wieder zu langsam. Also mal der Reihe nach...

1. OffScreenBitmap ist ein Bitmap welches du anlegst und zum malen nutzt. Dadurch erzeugst du das Bild einmalig nach einer Änderung und kannst dieses dann bei jedem Malen einfach auf die Form malen.
2. Nutzung von TImage ist von Nachteil. Selbst wenn nur ein kleier Teil neugezeichnet werden muss, wird das komplette TImage gemalt. Damit wird das Flackern gefördert und es verlangsamt den Zeichenprozeß.
3. Fülle das TBitmap über die ScanLine Property und du hast eine grundlegend hohe Geschwindigkeit.
4. Male das OffScreenBitmap direkt auf die Form. Nutze dabei die Eigenschaft ClipRect des TCanvas und male nur den markierten Bereich (also das Rechteck welches die Überschneidung zwischen ClipRect und deinem Bitmap darstellt). Dies kannst du einfach lösen mit [mdsn]IntersectRect()[/msdn] und BitBlt()
5. Zoom - wie stellst du dir das vor? Wenn du ein Bild berechnest, dann wirst du die schnellste und grafisch beste Darstellung bekommen, wenn du das Bild passend zu der dargestellten Bildauflösung berechnest. Wenn du nun hinein zoomen willst, dann geschieht das mathematisch mit Änderung deiner Formelparameter. Dadurch werden andere Pixeldaten errechnet und somit entsteht ein neues Bild und dieses zeigt dann einen bidlichen Zoom dar. Ein berechneter Pixel mit einem Farbwert kann nur als Rechteck/Quadrat gezoomt werden und somit wird aus einem roten Pixel gezoomt ein rotes Rechteck - dein zoom ist ein rein mathematisches Problem. verständlich?
6. Ein Screenshot unkomprimiert sind 10 MB an Daten - klar. Wenn du es komprimierst (z.B. PiNG), dann wird es weniger - also nicht immer TBitmap nutzen um was abzuspeichern.
7. Du kannst mit einem Thread im Hintergrund die Daten feiner rechnen. Das Problem beim vorberechnen von Bilddaten für den Zoom: wohin zoomt der Nutzer? man kann ja schliesslich oben links zoomen oder unten rechts ...

Schon allein wegen deinen Fragen und ein paar Dingen bezüglich Zoom, etc. eine Frage von mir: Kennst du fractint? Schonmal mit gearbeitet bzw. Zoom, Formelparameter etc?