Diskussion für die Grafik



  • Hi!
    Ich muss ein großes wissenschaftliches Projekt in C++ schreiben. Es handelt sich um 2d graphische Darstellung von Netzen. Geschwindigkeit wird bevorzugt vor Qualität. Ich habe erstens an win32 + OpenGl gedacht. Jetzt aber habe ich von win32 + Gdi+ gelesen. Ist es sinnvoll?



  • 2D Darstellung... das ist nicht präzise genug. Kann ja alles heißen. Soll es interaktiv sein? Kann es statisch sein? Was soll dargestellt werden? Netze... toll. Es gibt von AT&T ein Tool das nennt sich Graphviz, damit kann man Graphen als SVG oder PNG erstellen lassen. Ist natürlich nur statisch, aber je nach Anforderung, wäre das ganze schon eine fertig nutzbare Komponente.

    GDI+ ist sehr einfach zu benutzen, da es umfangreiche Zeichenoperationen von Haus aus anbietet. Ist aber weniger geeignet, um spektakuläre Animationen darzustellen. OpenGL ist für Animationen besser (schnellere Grafik), aber dafür etwas umständlicher zu handhaben, da es nur primitive Zeichenoperationen anbietet.

    Man kann es also nicht pauschal sagen.



  • Meine Netzen bestehen aus 10, 50, 100 bis 1000 - 2000 Knoten, sogar kann es mehr geben. Zusätzlich kommunizieren die Knoten wireless miteinander. Die Knoten sind als schwarze Quadrate oder Kreisen und der Datenaustasch ist als Gerade repräsentiert. Es kann auch sein, dass sich die Knoten bewegen. Nach jedem Simullationsschritt muss auf dem Bildschirm den aktuellsten Netzzustand gezeichnet werden.
    Animationen brauche ich nicht. Aber die einzelnen Simullationsschritte entsprechen eigentlich eigene Frames. Wenn diese schön und schnell gezeichnet werden, soll man das als eine Art Animation verstehen.



  • Wenn sich die Knoten weich bewegen sollen, z.B. 25 mal pro Sekunde, handelt es sich um eine Animation.
    Wenn du sagst, jede Sekunde (oder alle paar Sekunden) gibt es eine Aktualisierung eines Zustandes, ist es schon weniger eine Animation... sondern mehr eine Aktualisierung. Kommt auf die Ansprüche an, die man hier stellt.

    Gehen wir von der GDI+ aus:

    2000 Knoten sind viel, aber die müsste GDI+ auf einem aktuellen Prozessor locker schaffen. Vorallem, wenn es nur ein kleines Rechteck ist, und die Rechtecke durch einfache Linien verbunden sind, ist es ein leichtes. Umd wenn dann keine Animation nötig ist (weil nur alle paar Sekunden eine Aktualisierung), kannst du mit der GDI+ gut auskommen. Weiterhin ist die Frage: sind 2000 Knoten auf einmal zu sehen? Meistens sieht man nur einen Ausschnitt. Und dann zeichnet man am besten auch nur den Ausschnitt. Das kann man intelligent programmieren, um GDI+ bei eventuellen Performance-Problemen zu entlasten. Weiterhin sollte man einen Backbuffer zum Zeichnen benutzen, damit kann man auch viel Speed rausholen.
    Für eine endgültige Aussage, ist aber ein Benchmarktest nötig. Da mich das jetzt auch irgendwie interessiert, werde ich das vielleicht mal machen. 🙂

    Im Forumsmagazin habe ich ein GDI+-Tutorial geschrieben. Schau da mal rein.

    Wenn aber die Knoten sich weich und sanft von A nach B bewegen sollen (halt eine echte Animation), dann solltest du OpenGL oder DirectX nehmen. Die sind dafür ausgelegt. Macht aber nur Sinn, wenn der Grafikchip in dem PC ein 3D-Chip ist. Aber davon gehe ich mal aus. 😉



  • Artchi, wir sprechen von verschiedenen Sachen.

    Wenn du sagst, jede Sekunde (oder alle paar Sekunden) gibt es eine Aktualisierung eines Zustandes, ist es schon weniger eine Animation... sondern mehr eine Aktualisierung. Kommt auf die Ansprüche an, die man hier stellt.

    Ein Simulationsschritt bei mir beträgt etwa 5-10 Nanosekunden. Für diese Zeit ist es unmöglich den neuen Zustand zu berechnen und alles auf dem Bildschirm auszugeben. Deshalb hab ich mich für eine irreale Simulationszeitaufteilung entschieden. D.h. die Simulationszeit wird virtuell emuliert. Es kann sein, dass der Vorgang, den ich simuliere, 100 oder 200 Millisekunden dauert. Aber die PC-s sind nicht so mächtig und können nicht die Realität so präzis verfolgen. Deshalb wird das ganze Simulation viel länger dauern, etwa 1 Minute oder so. Das ist aber nicht wichtig, denn die GENAUE ZEIT WIRD GEMESSEN UND GEZEIGT - z.B. 123 Millisekunden, 452 Nanosekunden usw.
    Also ich will die zum Ausführen der Simulation Zeit so nah wie möglich mit dem reellen Vorgang machen. Ist es schon klar geworden?



  • Hem, also was du mir jetzt damit sagen willst, weiß ich nicht. Das du deine realen Bedingungen nicht 1:1 auf den Bildschirm wiedergeben kannst, leuchtet bei den Nanosekunden ein. Schon allein deshalb, weil ein LCD-Monitor meistens eh nur 60 Bilder pro Sekunde anzeigt. Über mehr braucht man für das menschliche Auge auch nicht zu reden. 😉

    Nichts desto trotz, willst du ja trotzdem etwas anzeigen? Oder?

    Ich habe mal einen kleinen Test mit der GDI+ gemacht, und einfach mal 2000 lange Linien zeichnen lassen. Wenn man einen Backbuffer zum Zeichnen benutzt, wird es erwartungsgemäß recht schnell. Hier mal die Log-Ausgabe der Zeiten in 100-nanosecond für 2000 Linien:

    Zeit (Start, Ende, Dif): 128220921895000000, 128220921895930000, 930000
    Zeit (Start, Ende, Dif): 128220921897810000, 128220921898750000, 940000
    Zeit (Start, Ende, Dif): 128220921930000000, 128220921931560000, 1560000
    Zeit (Start, Ende, Dif): 128220921940310000, 128220921942030000, 1720000
    Zeit (Start, Ende, Dif): 128220921963590000, 128220921965310000, 1720000
    Zeit (Start, Ende, Dif): 128220921967650000, 128220921968590000, 940000
    

    Die Unterschiedlichen Differenzen (Dif) entstehen durch die Multitasking-Umgebung, zeigen aber eine Tendenz auf. Wenn ich mich nicht täusche, sind das also ca. 0,094 bis 0,172 Sekunden, für 2000 Linien. Mein System:
    AMD64 X2 3800+ und ATI X300 GraKa.

    Du mußt noch die eigentliche Logik und die ganzen Objekte die deine Knoten repräsentieren, in die Berechnung einplanen, da die auch Performance schlucken.

    Wenn du deine Grafikausgabe schön kapselst und in eine eigene Schicht packst, kannst du notfalls ganz einfach die API austauschen (z.B. von GDI+ auf OpenGL), wenn du nicht gleich OpenGL benutzen willst. Für Prototyping ist GDI+ dann auch nicht schlecht. Allerdings kann sich natürlich OpenGL von Anfang an schon lohnen. So schwer ist OpenGL auch nicht, wenn man sich einarbeitet.



  • Ich probiere es mal mit GDI+. Wenn es mir nicht passt, dann mache ich eine zweite Version mit OpenGl. Wo kann ich irgendwelche Tutorials dazu finden?



  • Im Forumsmagazin gibts ein Tutorial von mir, oder du schaust auf meine Homepage.



  • @Artchi:
    Wieso eigentlich GDI+ und nicht einfach GDI?
    2000 Linien in 100-200ms sind IMHO lächerlich, das wären gerademal 20k Linien pro Sekunde. Pf. Da muss irgendwas faul sein.
    Und GetSystemTimeAsFileTime ist sicher nicht geeignet um so kurze Zeiten zu messen, was der Hauptgrund für die so grob unterschiedlichen Messungen sein dürfte, nicht "die Multitasking Umgebung".

    @Zdravko:
    Mach einfach eigene Tests wenn du wissen willst was am schnellsten ist. Ich würde auf GDI oder OpenGL tippen, GDI+ ... brauchst du IMHO nicht und macht IMHO auch keinen Sinn.



  • Ok, dann fange ich mit GDI an. Natürlich wird nur 1 Teil des ganzen Netzwerks auf dem Bildschirm gezeichnet! Ich brauche also zusätzlich eine Klasse zoom, die mir ein Rechteck der zu sehende Partition zeigt.


Log in to reply