Hallo,

ich will eine Art 2D-Funktionsplotter bauen. Zum Markieren brauche ich u.a. Rahmen & Text,
die mit der Maus gezogen werden können. Dazu würde ich soetwas wie Overlays nutzen.
Leider sind die nicht überall verfügbar. Pixel invertieren ist auch doof. Kann ich mit den
vorhandenen Puffern soetwas machen? (Bild = Graphpuffer + Markierungspuffer)
Ich möchte nur die Markierung neu zeichnen, nicht die eigentliche Grafik.
Möglicherweise ist OpenGL ja auch schnell genug, um alles komplett neu zu zeichnen?

Viele Grüße,
Stimpy

Ich glaube mit Overlays verfolgst du eine völlig falsche Richtung. Richtig echte Overlays sind in OpenGL zwar vorgesehen werden aber von den Karten so gut wie nicht unterstützt. Aber das wäre auch viel zu kompliziert!

Je nachdem wie viele tausend oder hunderttausend Punkte du hast könnte es sein, dass OpenGL ein bisschen langsamer wird. Wobei dies extrem stark von der vorhandenen Grafikkarte abhängt. Aber nichts desto trotz könntest du deine Punkte auch ein mal generieren und in eine oder mehrere Textur(en) zeichnen und diese bei jedem Rendervorgang benutzen.

Für Texte könntest du Bitmapfonts benutzen. Und zum Invertieren deiner markierung sollte es genügen eine entsprechende Blendfunktion zu bestimmen.

Alles andere richtet sich danach was du damit vor hast.

Hmm, das mit den oft fehlenden Overlays hatte ich schon bemerkt. Es klang nur elegant.

Am schönsten wären getrennte Puffer. In einen zeichne ich die Funktionen.
In den anderen kommt alles was nur temporär existiert (Linien, Markierungen, Text).
Zur Anzeige werden beide wie Folien überblendet. Der Markierungspuffer wird
sehr oft neu gerendert, während der Puffer mit dem Graph unberührt bleibt.
Wenn ich mit OpenGL auch eigene Texturen rendern kann, wäre das sicher eine Möglichkeit.

Könnte ich nicht aber auch den "accumulation buffer" verwenden?

Übrigens skaliere ich das OpenGL-Koordinatensystem so, daß ich eine orthogonale
Projektion habe und ein GL-Punkt genau einem Fenster-Pixel entspricht.
Das gibt dann eine "pixelgenaue" 2D-Darstellung.
Mit der Textausgabe hatte ich mich schon beschfätigt, das sollte funktionieren.

Danke,
Stimpy

Den Accumulation Buffer kannst du nur bedingt gebrauchen, da er nur für Motionblur Effekte etc konzipiert ist. Du könntest deinen Graphen berechnen und den dann in den Buffer packen. Bei jedem Rendern könntest du das Ergebniss dann wieder zurück holen. Aber. der Accumulationbuffer hat eine extrem hohe Auflösung. 64 Bit. Und das wäre reine Verschwendung.

Von daher würde ich schon vorschlagen, dass du das alles über Texturen löst. Da du den Graphen nicht wirklich häufig berechnen musst brauchst du diesen Vorgang nicht sonderlich optimieren. Aus diesem Grund genügt glCopyTexImage2D vollkommen. Sascha Willems hat auf seiner Seite unter OpenGL ganz unten auch ein programm was genau das macht. Allerdings wird der vorgang dort sehr häufig durchgeführt.

Solltest du das häufiger machen müssen solltest du etwas anderes wählen, da CopyTexImage nicht unbedingt das schnellste ist. Diese Möglichkeiten lasse ich gerade mal außen vor, da sie außer imensen Schreibaufwand keinen echten erkennbaren nutzen hätten. Also in deinem speziellen Fall versteht sich.

Hallo,

das hilft mir auf jeden Fall weiter! Damit kann ich das Bild einfrieren und drüber Markierungen malen.
Mit transparenten Texturen könnte ich dann sogar mehrere Ebenen machen. Kann das jede Hardware?

Mein Plotter muß schon recht flink und universell sein, da er auch wie ein Oszilloskop aktuelle Werte darstellt.
(Daher auch der Schritt zu OpenGL. Plattformübergreifend gibt's wohl nichts besseres.)

Kannst Du mir noch einen Link/Stichwort geben, womit das Textur erstellen doch noch schneller geht?

Also wenn dein Colorbuffer Transparente Werte hat, dann kannst du auch Transparenzen mit kopieren. Da gab es vor kurzem aber ein Thema bei dem das nicht ganz so ging. Deswegen wäre das dann eher mit Vorsicht zu genießen.


Hmmmm. Jetzt soll es auf einmal doch variabel sein?

Von was für einer Anzahl an Punkten reden wir jetzt gerade??? Ich frage das dewegen, da es bis zu einem gewissen Grade noch ohne Probleme machbar ist ohne, dass man da irgendetwas zwischenspeichern muss. VU Meter in OpenGL. Wenn du es immer zeichnest, dann wird es irgendwo natürlich langsamer aber das hängt wieder extrem stark von der Punkteanzahl ab.

Evtl solltest du da auch zwischen zwei Modis unterscheiden. Also einen bei dem du eine Funktion darstellst und einen mit dem sehr dynamische Daten darstellst. Und dann ist das entsprechend auf den jeweiligen Fall optimiert. Weil ich würde dir den Weg über die CopyTexImage oder andere Möglichkeiten nur empfehlen wenn du deine Daten zwingend in einem Bild speichern musst. Wenn sich diese von Bild zu Bild unterscheiden macht es keinen Sinn diese erst zwischen zu speichern und dann auf den Bildschirm zu bringen. Zu mindest in deinem Falle.

Bitte mache dir erst einmal genau Gedanken darüber was du von deinem Programm alles erwartest bzw was für Probleme alles auftretten könnten als der ersten Lösung hinterher zu laufen! Das ist nicht böse gemeint. Aber es kann sein, dass eine Techniken mehr Aufwand darstellen als überhaupt nötig ist und in einigen anderen Fällen gar nichts wirklich bringen. Und das ist dann Aufwand den du betreiben musst weil eine kleine Hintergrundinfo gefehlt hat.

Ich hatte ja nicht geahnt, daß ich hier so umfangreiche Hilfestellungen bekomme. Danke!
Die Darstellung war daher etwas verkürzt. Der Oszi-Plotter muß sehr flexibel werden.


1. Objektiste anlegen -> komprimieren -> Listenelemente zeichnen

Meine Idee ist ein QT-Widget, welches die OpenGL-Funkionalität kapselt. Diesem Widget
übergebe ich selbstgeschraubte Grafikobjekte (Polygone, Kreise, Text...). Diese werden
in einer Liste verwaltet. Dem Widget kann man von außen sagen "neu zeichnen" - und
schon werden die Objekte aus der Liste an OpenGL weitergereicht zum Zeichnen.
Die interne Behandlung der Grafikobjekte sorgt dafür, daß möglichst wenig Punkte
gezeichnet werden (Graphen werden auf Widgetbreite*2 Punkte reduziert -> max. 800-2000 Punkte).

2. Interaktion

Es können Rahmen gezogen werden (zoomen). Mann kann Meßpunkte mit dem Mauszeiger
anfahren und als Zahl ablesen. Vielleicht will man auch Bedienelemente einblenden...
Dazu darf die Echtzeitgrafik (Oszi) anhalten (wenns zu langsam wird?). Daher wollte ich für alles,
was temporär eingeblendet wird eine extra Ebene drüberlegen. Mit dem Texturvorschlag ergäbe sich:
- Mausklick -> Grafik stoppt & wird in Textur kopiert und eingeblendet
- OpenGL rendert jetzt temporäre Objekte über der Textur mit dem Graphen
- Maus loslassen -> OpenGL rendert wieder den Graphen

Wäre OpenGL schnell genug, so könnte man die temporären Objekte einfach in die Liste einhängen
und Frame für Frame mit allen Graphen mitrendern lassen.

3. Unwägbarkeit

Es kann sein, daß es Fälle gibt, in denen die Grafik nicht animiert ist dafür aber 20..50 Graphen übereinander
angezeigt werden müssen + Interaktion.
Was tun, wenn das Fenster vergrößert wird? Dann wird die Auflösung der komprimierten Graphen zu gering.
Da kann alles mögliche noch nötig werden...
Das mit den Texturen kann ich z.B. auch verwenden, um die Skala nebst Text unter den Osziplot zu zaubern.
Der Plotter selbst ist übrigens noch eine extra Schicht über dem obengennanten Widget.

Mein Problem ist weniger, der Entwurf des Plotters selbst. Ich überblicke bloß nicht, was OpenGL mir da schon
entgegenbringt. Daher bin ich auf der Suche nach Techniken und Möglichkeiten...

Wieviele Polygonpunkte kann ich denn OpenGL pro Sekunde abverlangen?

Das schaut doch schon mal sehr gut. Mit solchen Infos kann man dir auch genau helfen. Das Problem ist leider das, dass es immer wieder sehr spezielle Lösungen für ein problem gibt und man deswegen ziemlich genau wissen muss worum es eigentlich geht.

Also ich denke mal für dich wären Vertex Buffer Objects (VBO) ganz interessant. Damit kannst du dir einen Speicherbereich auf der Grafikkarte Reservieren lassen und kannst deine Vertexdaten dort ablegen und diese dann am Stück zeichnen lassen. Das ist sehr schnell und speziell für dynamische Zwecke konzipiert. Diese würde ich zwingend vorraussetzen und dann brauchst du auch keinen Akt mehr betreiben in dem du die Sachen irgendwie in ein Bild verpackst.

Die Skala und Beschriftung etc. würde ich in eine DisplayList rendern. Das muss ja nur ein Mal gemacht werden, wenn es sich ändert und sollte auch ein wenig beschleunigt werden.

Zu der Polygonanzahl kann man nicht so viel sagen. Je nachdem wie lange du das alles Lockst zum Uploaden der Daten und wie du renderst. Aber im Idealfall bist du damit in der Lage auf einer Radeon 9500 knappe 75 Mio Dreiecke in der Sekunde zu rendern. Wohl gemerkt. Im Idealfall!! Den erreicht man in der Praxis leider nie wirklich.

Damit habe ich jetzt ein paar Techniken, mit denen ich da noch etwas rauskitzeln kann.
Ich werde mich noch ein wenig in die OpenGL-Thematik einlesen müssen.

Momentan überlege ich mir nocheinmal die Gesamtstruktur. Die Grafikschicht kennt nur
die Liste mit Grundformen (Polygone, Text, Farben...). Diese allgemein beschriebenen
Grafikobjekte werden mit OpenGL dargestellt oder aber auch gedruckt oder exportiert(!).

Der Plotter kommt dann da oben als weitere Schicht drauf. Evtl. werde ich da noch einige
Spezialbefehle einbauen, die dem OpenGL erklären, was wie zu puffern ist. Der Drucker
darf das dann ignorieren. Animationen sind eh' nicht sein Ding (höchstens als Daumenkino ).

Mal sehen, was als nächstes gewünscht wird...

Vielen Dank!