Planetenbahnen mit Planetenschweif programmieren

Du hast eine Idee für ein Projekt?
Antworten
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hallo liebe Community
Ich möchte das Sonnensystem mit allen Planeten animieren und dabei sollen die Planeten einen verlöschenden Schweif haben.
Grundsätzlich soll eine SQLite- Datenbank zum Einsatz kommen, wo für 150 Jahre die astronomischen X,Y,Z- Positionen der Planeten
für alle 12h gelistet sind. D.h. in der Datenbank sind zwei Datensätzen pro Tag gelistet, Mitternacht und Mittag.

Die Planeten sollen dabei einen Schweif haben, damit man ihre elliptischen Bahnen erkennt.
Es sollen also Punkte in den Raum geplottet werden, die langsam verlöschen.
Bisher sehe ich nur eine Möglichkeit mit einem for- loop zu arbeiten, der in angebbaren Pausezeichen den Plot mit abnehmendem Alphawert
und damit zunehmender Transparenz wiederholt, bis Alpha = 0 ist und nichts mehr von der Bahn zu sehen ist.

Allerdings erscheint es mir ziemlich umständlich für jeden Bahnpunkt einen eigenen Loop laufen zu lassen, zumal
die Pausezeiten bei den äußeren Planeten länger sein sollen, da sie sich ja auch langsamer bewegen.

Dazu bin ich Python- Anfänger. :roll:
Bitte habt ihr einen guten Rat für mich?
VG. Nobby
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Sofern du nicht zu Tricks mit OpenGL oder aehnlichem und einem in der GPU gerechneten Partikelschwarm greifst, wirst du wohl deine 9 * Anzahl-der-Schweifpunkte-viele Objekte haben. So macht man das halt.
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Mir ist noch was eingefallen: http://www.pygame.org/pcr/numpy_flames/

Damit malst du nur die aktuelle Position, und alles andere "verglimmt". Allerdings ist der Wunsch, das fuer verschiedene Planeten unterschiedlich zu machen damit nicht darstellbar.
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hallo Deets & Danke dir.
Leider bin ich ziemlicher Python- Anfänger. Aber in Sachen Sphärenmusik bin ich der Profi, ich habe die alte Kepleridee von den tönenden Planetenbewegungen realisiert.
Und nun will ich sie programmieren. Mir schwebt vor eine SQLite- Datenbank mit den nötigen Daten zu bauen und das über Python an Blender anzuschließen und dort etwas aufzuhübschen.
Ich weiss, alles für einen Anfänger ziemlich anspruchsvoll. Kann man die Planetenschweife in Blender besser darstellen?
Ansonsten befasse ich mich erstmal mit OpenGL und der GPU .
Thanx, N.
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Kann man bestimmt machen - musst du halt die Blender Game Engine begreifen. Ob das nun einfacher ist, als das selbst zu machen - keine Ahnung. Das kommt sehr darauf an, wie komplex die Visualisierung werden soll, und somit ab welchem Moment die Engine von Blender einen Mehrwert bietet. Eine Visualisierung in Blender saehe bezueglich der Schweife auch ganz anders aus - da wuerde man einen Planeten mit einem Schweif bauen, und den dann nur an die Position verschieben, rotiert so dass der Schweif tangential zur Umlaufbahn ist. Oder den Schweif als 3D-Geometrie (zB einen Kegel, mit Bones drin), und den dann animieren anhand der Bahn-Geometrie.

Ich persoenlich wuerde dir ja raten erstmal *sehr* klein anzufangen, und eine einfache, pygame-basierte 2D-Visualisierung zu machen.
Benutzeravatar
__blackjack__
User
Beiträge: 13003
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Ist die Blender Game Engine wieder zum Leben erwacht? Das Projekt schien mir sanft entschlafen zu sein…
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

🤷🏼‍♂️ Mag sein. Selbst wenn nicht ist das IMHO deutlich zu komplex für einen Anfänger. Aber er will ja partout.
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hallo Leute!
Ich bin jetzt soweit die Planetenbahnen in 3D mit Matplotlib darzustellen und die Planetenbewegungen zu animieren. Das ist soweit sehr beglückend : )
Jedoch sollen die Planeten ja Sounds haben. Dabei ist die Lautstärke eines Planeten objektiv von seiner Gravitationskraft zur Sonne abhängig - diese Daten sind in der Datenbank gelistet.
Subjektiv ist die Lautstärke eines Planeten aber von der Entfernung zu mir abhängig, da ich ja der Lauschende bin. Diese Pegel liessen sich aus den x,y,z- Koordinaten leicht berechnen.
Das Problem was ich jetzt seit Tagen habe ist: Wie erhalte ich meine Position? Das Matplotlib- Backend- Window ist ja sozusagen das Fenster meines Raumschiffes. Ich brauche die Koordinaten meines Raumschiffes im solaren Koordinatensytem (Sonne im Nullpunkt), also in dem Koordinatensystem, in dem ich auch die Planetenpositionen plotte. Das Backend zeigt unten x,y,z- Koordinaten an, zwar die des Mauszeigers / des Cursors, aber damit könnte ich auch arbeiten. Gibt es sowas wie einen Befehl get_viewpoint_coordinates im 3D- Plot / Animation? Ich konnte bislang nichts Passendes finden...
Bitte bitte bitte hat jemand einen Tipp? Liebe Grüße, Norbert
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Viel spannender ist doch die Frage, wie sich dieser Sound im Vakuum ausbreiten soll.
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hi Sirius. Diese Frage ist wirklich sehr spannend.
Denn Druckwelle geht nicht (Alfvénwellen sind Druckwellen im Plasma, sie kommen aber nicht in Frage). Elektromagnetische Wellen kommen auch nicht in Frage.
Es handelt sich um Schwingungen der Raumzeitmetrik, also um Gravitationswellen. Mein Modell stellt eine erste Näherung dar, nach der die Schwingungen bei der Annäherung an ein schweres Objekt wie einen Planeten mit der Gravitationskraft zunehmen. Der Planet fungiert als Sender. D.h. die Schwingungen werden bei Annäherung mit 1/ r² stärker bzw. lauter.

In Matplotlib gibt es die Funktion ax.get_proj(), mit der man wohl Elevation, Azimut (und Abstand?) erhalten kann. Daraus könnte man natürlich die x,y,z- Koordinaten meines Blickpunktes berechnen.
Aber ich denke es müsste noch einfacher gehen, da im Grafikwindow unten die Mauskoordinaten zu sehen sind, die ich nur irgendwie extrahieren müsste...
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Ist hier der richtige Ort für diese Frage? : Wie bekomme ich in Matplotlib die 3D Koordinaten meines Blickpunktes?
Die Frage scheint wirklich selten und sehr knifflig zu sein. Ich fand bisher 3D Axes ax.view_init(elev, azim) oder get_proj(), aber ich komme nicht weiter,
die Dokumentation ist sehr dürftig und offenbar hatten nur Wenige Leute bedarf den eigenen Viewpoint zu bestimmen.
Obwohl unten im Backend- Window die Koordinaten mitlaufen (Elevation, Azimuth bzw, x,y,z.
Hat jemand bitte einen Rat???
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hier befindet sich die Dokumentation von Matplotlib
https://matplotlib.org/3.2.1/api/_as_ge ... xes3D.html
von
get_proj(self)
Create the projection matrix from the current viewing position.
elev stores the elevation angle in the z plane azim stores the azimuth angle in the (x, y) plane
dist is the distance of the eye viewing point from the object point.

Daraus könnte ich x,y,z meines Blickpunktes berechnen, aber ich komme nicht weiter : (
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Klick mal auf deinen eignen Link, und dann auf den Link “Source” und such den raus für die Methode. Da steht dann geschrieben, wie das Objekt Elevation und Azimuth vorhält.
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Danke dir deets, wir kommen der Sache näher.
Der Text dort lautet:

def get_proj(self):
"""
Create the projection matrix from the current viewing position.

elev stores the elevation angle in the z plane
azim stores the azimuth angle in the (x, y) plane

dist is the distance of the eye viewing point from the object point.
"""
relev, razim = np.pi * self.elev/180, np.pi * self.azim/180

xmin, xmax = self.get_xlim3d()
ymin, ymax = self.get_ylim3d()
zmin, zmax = self.get_zlim3d()

# transform to uniform world coordinates 0-1, 0-1, 0-1
worldM = proj3d.world_transformation(xmin, xmax, ymin, ymax, zmin, zmax)

# look into the middle of the new coordinates
R = np.array([0.5, 0.5, 0.5])

xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist
yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist
zp = R[2] + np.sin(relev) * self.dist
E = np.array((xp, yp, zp))

self.eye = E
self.vvec = R - E
self.vvec = self.vvec / np.linalg.norm(self.vvec)

if abs(relev) > np.pi/2:
# upside down
V = np.array((0, 0, -1))
else:
V = np.array((0, 0, 1))
zfront, zback = -self.dist, self.dist

viewM = proj3d.view_transformation(E, R, V)
projM = self._projection(zfront, zback)
M0 = np.dot(viewM, worldM)
M = np.dot(projM, M0)
return M

Aber daraus werde ich nicht schlau!
Zumal der Text Ungenauigkeiten und Fehler enthält hinsichtlich Reihenfolge und Ebene der Winkel, es müsste heissen:
(1.) azim stores the azimuth angle in the (x, y) plane
(2.) elev stores the elevation angle in the (y, z) plane (was soll denn sonst eine y-plane sein???)
(3.) dist is the distance of the eye viewing point from the object point.
Das verunsichert mich natürlich noch mehr. Dazu ist die Distanz immer = 10, also kann es nicht die Distanz in Datacoordinates sein...
Ich denke man sieht daran, und an den wenigen Beiträgen zum Thema im Web, dass das Problem nur wenigen Programmierern begegnet.
Eigentlich sollte der eigene Viewpoint bei Gameengines ständig gebraucht werden, aber in Matplotlib?

Also bitte helft mir etwas weiter, ich brauche letztlich die x, y, z- Koordinaten meines Blickpunktes in Datacoordinates, der Umweg über azim & elev ist ja nicht unbedingt nötig.
Dann kann ich die Lautstärken der Planetensounds in Abhängigkeit von meiner Position im Raum berechnen :P :P :P

Beste Grüße, Norbert
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Hallo __deets__
Ok., Elevation ist die Höhe (y) über dem Azimut (in der x,y- Ebene), man kann das verstehen.

Ich mache jetzt event- handling! Beim event- drawing kann ich meine Position mit der Maus einstellen und die Winkel elev und azim beziehen.
Das ist ein großer Fortschritt, denn ich kann nun durch den Raum gleiten und die Winkel in fließenden Zahlen beziehen - genau was ich brauche um die Lautstärken fließend zu regeln.
Aber meine Distanz zum Ursprung 0,0,0 müsste ich aus den World- coordinates irgendwie berechnen.
Das geht sicher, aber es ist so unsauber...

Dein Tipp auf die SOURCE ist sicher sinnvoll, leider verstehe ich es nicht.
Ich vermute aber, dass meine gesuchten x,y,z- Koordinaten intern dazu benutzt werden, um elev & azim zu berechnen, sodass ich es wieder zurückrechne...
Dann wäre der ganze Rechenaufwand überflüssig und macht mein Sonnensystem unnötig langsamer...

Kannst Du den Code verstehen?
Kann man daraus x,y,z meines Viewpoints beziehen?

Bitte gib mir diesen Rat.
Nobby
User
Beiträge: 11
Registriert: Sonntag 2. Februar 2020, 18:16

Gibt es eine Möglichkeit MIDI- Daten mit einem Python- Modul in Töne zu verwandeln?
Kann man mit Python Musik machen?
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Jein. Es gibt MIDI Bibliotheken, mit denen du midi-Ereignisse bekommst. Und du kannst dann auch darauf basierend zb mit pygame oder pyaudio Töne abspielen.

Nur musst du dann alles, wirklich alles, selbst machen. Da gib es keine Effekte, Aussteuerung, Mischung. Nix.

Ich würde also eine DAW wie Ableton Live, Fruity Loops, Reason nehmen.
Antworten