Desingfrage: große Bildermenge in "3D" darstellen

shapoc · Beitrag von **shapoc** » 10. Juni 2009 10:36

Hallo zusammen,

ich möchte an dieser Stelle mal eine design-technische Frage zur Qt-Programmierung stellen ohne zu sehr auf Implementierung einzugehen (dafür hab ich noch nen anderen Thread

).

Es geht um die Darstellung von großen Bildmengen, welche ich möglichst im 3D anzeigen möchte. Dazu gibt es verschiedene Visualisierungsideen, wie z.b. die Anordnung auf einer Kugel oder als eine Art "Star Wars"-Zeitstrahl oder ....

Ich stehe im Moment vor 2 Alternativen, die ich noch nicht so recht überblicken kann.

1. Als QGraphicsScene+View
- Darstellung als "Wand"
- OpenGL ist schon inclusive
-> trotz doku weiß ich noch nicht so richtig, was noch alles im 3d-raum damit möglich wäre

2. komplette OpenGL Eigenimplementierung in QGLWidget
- mehr Freiheit in der 3D-Anordnung
- größerer Aufwand

Ich würde mich freuen, wenn ihr mir hier ein paar Ideen von euch dazu geben könntet, bzw. Vor- und Nachteile der einzelnen Techniken.

upsala · Beitrag von **upsala** » 10. Juni 2009 12:20

QGraphicsScene ist eigentlich 2D also Möglichkeit 2.

shapoc · Beitrag von **shapoc** » 12. Juni 2009 11:30

Würde man dann die Bilder als Texturen auf Polygonen darstellen oder gibt es einen anderen/besseren Weg?

shapoc · Beitrag von **shapoc** » 18. Juni 2009 09:47

Sorry dass ich meinen eigenen Beitrag wieder nach oben hole, möchte aber zum Thema nochmal ne Frage stellen.

Ich habe mit dem Graphics View Framework die letzten Wochen herumexperimentiert und auch ordentliche Ergebnisse erzielt, allerdings bleibt alles wie angesprochen 2D.

Ziel soll es aber sein, die gesamte Bildermenge von einer 2D-Wand auch im 3D Raum darzustellen, weshalb ich jetzt also den Ansatz über ein QGLWidget gehe. Dort habe ich mal ein Polygon-Quad erstellt und eine Textur draufgepappt, was auch ordentlich funktionierte. Ein bischen Mausinteraktion mit hinein und nun denke ich dass ich damit ganz gut weiterkommen würde.

Allerdings stehe ich grad vor der Frage, wie man nun die Gesamtmenge der Bilder in die Szene bringt. Meine Idee wäre, jeweils ein QUAD zu erzeugen mit Textur und diese anzuordnen.

Wie könnte ich diese "Liste" der Objekte am besten speichern, um beim Verschieben der Ansicht z.B. auch auf die Objekte zugreifen zu können.

Wäre für ein paar Tipps und Hinweise sehr dankbar!!

upsala · Beitrag von **upsala** » 18. Juni 2009 15:48

Man kann doch mit OpenGL Gruppen von Anweisungen als Liste ablegen.

Diese GLuint(?) kann man in einem QVector mit Zusätzlichen Infos ablegen.

Ich würde mir aber eher Gedanken machen, ob auch alle Grafiken in den Speicher passen.

shapoc · Beitrag von **shapoc** » 19. Juni 2009 10:19

Jep, das hab ich auch gemacht, als sogenannte Display Lists. Aber bisher konnte ich damit nicht wirklich Performance gewinnen.

Ich habs mal so versucht: Ich gehe in einer Schleife alle Grafiken in einem Verzeichnis durch und erstelle jeweils ne Instanz meiner eigenen Klasse Item. Diese hat eine QPixmap-Pointer auf die Grafik und die Position des Items.
Alle Items speicher ich dann in einer QList in meiner Window-Klasse.

In der Paint Methode meines QGLWidgets rufe ich dann eine methode auf, die die Liste durchgeht, die Grafik als Textur auf ein QUAD packt und dieses entsprechend der Position in die Szene setzt.

Funktioniert eigentlich ganz gut. WEnn ich die Szene verschiebe, hakt es noch ein wenig, weil ich noch mit Pixelverschiebung arbeite, sprich das delta der Mausbewegung auf ein gltranslate draufpacke.

Speicherverwaltung:
@upsala: Dein Einwand ist berechtigt. Bisher benutze ich Grafiken die recht klein sind, 150x150 Pixel. Ziel soll sein, beim heranzoomen ab einem bestimmten Zoomlevel die hochaufgelöste Variante anzuzeigen und beim rauszoomen entsprechend die kleinere.
Das könnte dann vielleicht etwas schwerer werden.

Folgende Fragen:
1. Ist mein bisheriger Ansatz überhaupt "gut" oder hab ich irgendwas nich beachtet?
2. Macht es Sinn, pro Move zu gucken welche Items sichtbar sind(das macht doch OpenGL eigentlich schon durch den Viewport) und dann nur den Items ne Textur verpassen, die auch angezeigt werden?
3. Die Texturen/Grafiken sind für eine Szene erstmal "fest". Macht es sind, aus allen eine einzige große Textur zu erzeugen (dynamisch) und aus dieser entsprechend jeweils einen Teil pro Item zuzuweisen?

Es geht mir hier neben der praktischen Funktionalität vor allem auch ums Konzept. Ich denke hier kann mit der richtigen Programmierung auch ordentlich Performance herausgeholt werden.

Danke schonmal für weitere Hinweise und Tipps.

upsala · Beitrag von **upsala** » 19. Juni 2009 12:17

In den Trolltech-Labs gibt es doch eine Demo wo Bilder umgeklappt werden, oder so. Hast du dir das schon mal genauer angeschaut?

shapoc · Beitrag von **shapoc** » 19. Juni 2009 12:29

Nö

Hab grad mal 10 verschiedene Suchen auf die labs angestoßen, aber noch nix passendes gefunden. Kannst du vielleicht etwas genauer beschreiben, was du mit "umklappen" meinst?

Hab nur diese Seite zu Bildmanipulation gefunden: http://labs.trolltech.com/page/Graphics ... /Examples1 . Meinst du die?!

Edit: Seh grad, dass dort dieses "Folding" beschrieben ist. Denke du meinst das, oder?
Sieht zwar schick aus, aber ich seh grad nich, wo das für mein Problem helfen könnte?

upsala · Beitrag von **upsala** » 19. Juni 2009 17:50

Der Cover-Browser ist das was ich meinte:
Examples 2

Ich habe mittlerweile gesehen, daß dort OpenGL auch nicht direkt verwendet wird, aber vielleicht bringt es dich trotzdem weiter.

shapoc · Beitrag von **shapoc** » 28. Juni 2009 12:17

So, nach einigen Tagen sitz ich wieder an meinem QGLWidget und grübel mal wieder...

Die Anzeige meiner Items+Texturen funktioniert soweit ganz gut, Performance ist ok.

Ich möchte nun ähnlich wie ich es für eine QGraphicsview (http://www.qtforum.de/forum/viewtopic.php?t=9297) gemacht habe, die aktuellen Koordinaten meines viewports ermitteln und entsprechend der Verschiebung die Items, die aus dem Bild auf einer Seite verschwinden, auf der gegenüberliegenden Seite wieder neuzeichnen, um eine Art "unendliche" Scene darstellen zu können.
Beim QGraphicsview konnte ich über die Scene die aktuellen Koordinaten ermitteln, wie kann ich sowas in meinem QGLWidget realisieren?

Meinen Ausschnitt habe ich im Moment auf die Größe der Scene gesetzt, welche ich mir vorher beim Erstellen der Items berechne:

Code: Alles auswählen

glOrtho(-this->sceneWidth/2, this->sceneWidth/2, this->sceneHeight/2, -this->sceneHeight/2, 0.1, 100.0);

so dass alle Items standardmäßig angezeigt werden. Diese sind alle um den Weltkoordinatenursprung gezeichnet, d.h. der befindet sich genau in der Mitte meiner Items.

Meine Idee wäre, die Anfangsausmaße der Scene, die ich ja habe, zu speichern und dann bei jedem Move in eine Richtung zu gucken, wie weit die Translation von der Ursprungsposition entfernt ist und anhand dessen zu berechnen, ob auf der anderen Seite die Items noch sichtbar sind oder schon auf der neuen Seite gezeichnet werden müssen.

Sollte ich das so versuchen oder habt ihr noch andere/bessere Ideen?