Tach,

leute ich bin ziemlich am verzweifeln momentan.
Wie manche vielleicht wissen arbeite meine firma an einem "Führerstand" (Bahn) Simulator.
Mein teil ist der komplette Renderpart.

Wir haben einen Streckenfilm mit ca. 40000 Bilder im JPEG Format.
Diese sind gespeichert in einem Binären file wo vorher noch nen header und ne Index table schlummert.
Dieser wird geladen und ein neues bild in jedem neuem renderschritt geladen, tut einwandfrei
Danke mal an die mir tips gegeben haben !

Was noch dazu kommt: Alle Signale müssen durch eigene ersetzt werden.
Sprich die Lampenstellung muss zur Laufzeit geändert werden können.

Das haben wir folgendermassen gelösst:

Ich hab via opengl, alle Signaltypen nachgezeichnet und die grundform in ne Displayliste verfrachtet.
Beim zeichnen werden dann noch Kreise für die Lampen welche ich über einen einfachen algo erzeuge dazugezeichnet.
So wird die grundform erstellt:



gezeichnet wird es dann so:



ok soweit so gut, nun damit das ganze natürlich realistischer wirkt müssen die signale auch über die originalen Signale im jpeg movie drübergelegt werden.

Damit ich nicht in jedes einzelne bild, die X, Y Koordinate speichern muss hab ich mir nur pro Signal 8 Punkte rausgesucht (Startpunkt, Endpunkt und 6 zwischenpunkte) (Bildnummern) welche ich dann KoEffizienten für ein (8-Faches Polynom berechne) die daten liegen in ner excel tabelle welche ich beim start auslese.

Das wird dazu verwendet um die aktuelle Left, Top Position aus der aktuellen Bildnummer ausrechnen, welches ganz gut klappt, sofern man gute Zwischenpunte gewählt hat, ansonsten kanns passieren das die Signale sonst wo sind :p

Jetzt kommt wo ich probleme habe und das ist der Skalierungspart.
Sprich damit die Original Signale die anderen überdecken müssen die "Kunst" Signale genau drüber gelegt werden und gleich skaliert sein.

Hab dazu also den StartPunkt und den Endpunkt (Bildnummern) genommen und mir daraus zwei skalierungsfaktoren ausgesucht, bsp: 0,04 wenns grad zu erscheint, und 1,2 wenns verschwindet.
Daraufhin hab ich mir ne Geradengleichung gemacht wie aus der Bildposition, BildAnfang und BildEnde den jetzigen Skalierungsfaktor.
Die werte die rauskommen scheinen ok zu sein, allerdings skaliert er ein bischen komisch

Hier sind paar screenshots zur verdeutlichung:

Man beachte die Roten umkreisung
Man beachte den NScale wert Links Unten, welches den aktuellen Skalierungsfaktor enthält

Signal wo es grad sichtbar wird ohne Eigenes drübergelegt


Signal wo es verschwindet ohne Eigenes drübergelegt


Signal wo es grad sichtbar wird mit Eigenem drübergelegt


Signal wo es verschwindet mit Eigenem drübergelegt


Bisher scheint alles ok zu sein, nun kommen 2 Bilder wo dazwischen liegen:






Totale muckenkotze, da passt hinne und vorne nix...
Was ist da faul ?
Hat wer ne idee wie man das geschickter lösen könnte, so das die Skalierung immer stimmt ?


Was später dann noch dazukommt, ist nen Fragment Shader für Unschärfe je nachdem wie nah/weit das signal ist, weil momentan siehts so aus wie nen böser fremdkörper der absolut nicht in den Film passt.
Das kommt aber wirklich erst wenn das Oben alles so passt, vorher nicht.



Danke schonmal fürs lesen,
und freue mich auf antworten



Hätte keine probleme mal den src zu posten da der Videopart eh nix weltbewegendes ist :p
Allerdings ohne Streckenfilm welcher 2,9 GB hat, hat das nicht viel sinn.[/b]

Wow. Das ist ja auch mal ein nicht leichtes Problem. Ich bin zwar nicht so der Freak was Gleichungen angeht aber ich denke mal nicht, dass du mit einer linearen Gleichung dort so sonderlich gut hinkommen wirst. Zum ersten weil die Strecke nun mal meist in Kurven liegt und weil je nach Entfernung des Signals dessen Geschwindigkeit und Größe stetig zu nimmt. Also am Ende wird es am schnellsten bewegt und am schnellsten skaliert. Ich weiß nicht ob die Auflösung die du da hast ausreicht. Weil du auch ungleichmäßige abstände bräuchtest und somit unterschiedliche zeitabstände hättest.

Zusätzlich käme auch noch eine perspektive Verzerrung wenn sich der Winkel dazu ändert. Aber das kann man wohl außer acht lassen.

Ich persönlich würde diese Informationen wahrscheinlich pro Bild abspeichern. Und zwar so, dass man das vorherige abgespeicherte dann mit in das einfließen lassen kann. Sprich ich habe bei Bild 20 die Elemente gesetzt und bei Bild 21 sehe ich die Position von 20 noch und kann diese entsprechend an die des Bildes 21 anpassen. So kann man ein wenig vermeiden, dass da 1 oder 2 Bilder dabei sind die von der Position echt weit vom Rest entfernt sind. Das ist zwar mehr arbeit aber so dürfte das Ergebniss am genauesten sein. Allerdings könnte es sein, dass die dennoch unruhig wirken. Evtl könnte man das per Algo noch ein wenig beruhigen.


Da hast du recht. Die wirken ein wenig Fremd. Aber das mit dem Shader halte ich für eine ziemlich schlechten Idee, wenn ich ehrlich bin. Verstehe das nicht falsch aber das ist wirklich wirklich wirklich ein mega Bombe auf die auf ne super kleine Mücke geschossen wird. Schon mal daran gedacht für so etwas eine Textur zu nehmen. Die kannst du doch mittels Alphakanal am Rand weich machen. Kombiniert mit Blending sollte das dein Probleme mit der Unschärfe lösen. Außerdem kannst du dann so auch noch eine echte Lampe nehmen und der Realismuseffekt dürfte wesentlich höher sein als mit jedem Shader. Der im übrigen mehr an Rechenleistung fressen dürfte als ein Quad mit ner Textur.

Bedeutet das, dass der skalierungsfaktor linear mit der Zeit (und demnach auch etwa Z-Wert) zusammen hängt? Dem ist nämlich nicht so. Die Größe eines Objektes ist indirekt Proportional zu seiner Entfernung, also
Größe = Wirkliche_Größe / Entfernung
Also wenn es in 10 Einheiten Entfernung 20 Pixel groß ist, dann ist es in 100 Einheiten Entfernung 2 Pixel groß.

Und wie Lossy eX schon erwähnt hat wundert es mich auch etwas, dass du bei den ~ 40-100 KB die du je Bild brauchst nicht nocht genug Platz für die ~10 Byte eines Lichtleins hast. Und selbst wenns zum editieren durch das Angeben von nur 8 Positionen etwas einfacher geht so stellt sich mir doch die Frage wieso du nicht beliebig viele Positionen angeben kannst, vor allem wenn das Lichtlein dann öfter als 6 mal auftaucht und wieder verschwindet weil es von irgendwas verdeckt wird. Du brauchst ja dann auch kein x-beliebig Gradiges Polynom wenn du die Abschnitte unterteilst wie mans halt bei Splines und so macht.

Also,

das mit ner Linearen Geraden gleichung nicht geht war mir klar aber der Prof meint das wäre so korrekt -.-
Sein lautsatz war "Das liegt 100pro an OpenGL, das skaliert nicht richtig, mit ner Geraden Gleichung muss es gehen".

Es muss doch irgendwie möglich sein ne gescheite Skalierungsroutine zu bauen, welche aus dem 8 Punkten die ich eh immer habe den Skalierungsfaktor berechnet ohne dieses beschissene Polynom zu nehmen.



Ich rechne nicht mit Zeit, sondern nur mit der aktuellen-, start- und endbildnummer.
Es läuft nen sehr komplexes steuersystem auf nem anderen rechner welche mir daten via TCP/IP schickt welche ich daraus nen Faktor ausrechne um zu wissen welche Bildnummer alle 40 ms kommen muss.

Z Achse gibts nicht, da ich von Anfang an alles auf glOrtho also 2D ausgerichtet habe.

Also wenn ich für jedes Signal zu jedem einzelnen Bild die Positionen und Skalierung speichern würde, wäre das sehr zeit aufwendig. Bei 40000 bilder, also effektiv mit signalen 30000 bilder gehts noch... aber wir wollen ja später grössere Filme machen, die dann auch mal 1-2 std fahrt sind anstatt 5 min :p und das sind dann halt mal nen paar x-mio bildern.



Jop, da wir aber hier ne GF 6800 GT mit nem schnellem P4 haben kann ich da ruhig auf PixelShader setzten.
Werd aber beides mal ausprobieren.

Wie wäre es, wenn du für die Skalierung ausser Start und Endwehrt auch noch zwischenpunkte machst und nen Polynom draus, wie bei den Positionen??? (Vielleicht genügen da ja weniger zwischenpunkte um Aufwand zu sparen)

P.s. Ich hoffe das hat noch niemand gesagt, habe gerade wenig Zeit

_________________
Nothing, oh sweet nothing,
today we are doing nothing at all...
http://www.geo-progs.de

Jop, hab grad das mit dem Polynom gemacht, geht einwandfrei
Hätte ich gleich drauf kommen können. :p

Das gleiche mach ich ja auch für Left und Top Position vom Signal

Jetzt kommt dann wirklich nur noch das mit der Unschärfe/Verwischung dazu.

Aber erst muss der Chefs absegnen.

Ne frage noch:

Hat wer ne ahnung von Polynomen ?
Ich hab nicht wirklich viel ahnung davon, weil der Prof das ja gemacht hat in Excel
Daraus werden 8 Koeffezienten berechnet, welche ich dann über diese Formel die Richtige Left, Top und jetzt auch
Skalierungswert berechne:



Muss ich mal erklären wie das bei uns abläuft bis überhaupt mal nen Signal erscheinen kann auf dem Bildschirm:

Startbild und Endbild wird gewählt für ein Signal, wos erscheint und verschwindet.
Danach werden 6 zwischenpunkte genommen davon, factor ist da (EndBild - StartBild) / 7.
Für alle 8 Punkte nun, wird der Signaltyp, Left, Top und Skalierungswert gesetzt und in eine eindeutige Binärdatei gespeichert. Pro Signal eine Datei.

Dann werden diese Binärdateien über ein Seperates tool in ne Excel Tabelle konvertiert.

Über nen Makro werden dann diese Excel Daten in ne andere Excel Tabelle kopiert und die Polynome für die 8 Koeffzieten pro signal ausrechnet und in ne weitere tabelle gespeichert welche noch andere infos stehen.

Dann kommt nen weiteres tool, welches dann wiederrum diese Excel Daten in 1 Binärdatei konvertiert.
Das ist dann die Signaltabelle:



Am liebsten wäre wenn das alles über Delphi laufen würde, und kein einziger weg mehr über Excel und so.

Thx bisher für antworten

Es ist ein lineares Gleichungssystem welches es zu lösen gilt. Du hast 8 Gleichungen der Form
Xi = P7*(Ti^7) + P6*(Ti^6) + P5*(Ti^5) + ... + P1*(Ti) + P0
Wobei Xi der X-Wert zum Zeitpunkt (Frame) Ti ist, gleiches gilt für Y-Werte.
P0-7 sind die Polynomfaktoren.

Man könnte das auch in Matrixschreibweise machen indem du dir mal ne Matrix auf stellst mit
M =
T0^7 | T0^6 | ... | T0 | 1
T1^7 | T1^6 | ... | T1 | 1
...
T7^7 | T7^6 | ... | T7 | 1

Und die Ergebniswerte als Vektor anschreibst
V = ( X0, X1, X2, ... X7 )

Das Gleichungssystem kannst du jetzt sehen als
V = M * P
wobei P die Polynomfaktoren sind, also
P = (P7, P6, P5, ..., P1, P0)
du willst P wissen also musst du M invertieren um mit
(M^-1) * V = P zu erhalten

Ein kleines Rechenbeispiel:

Also die 4 "Zeit-"punkte wo du die Punkte gegeben hast. Die Punkte sind nun beispielsweise:
V = (1, 3, 0, 5)


und
P = M * V = (77.106, -117.657, 42.5513, 1)

Nun weißt du das dein Polynom so ausschaut:
x = 77,106 * t^3 - 117,657 * t^2 + 42,5513 * t + 1