Differences

This shows you the differences between two versions of the page.

--- kurse:efcomputergrafik:kw4 [2020/01/23 08:12]
Ivo Blöchliger [Simulation der Bewegung]
+++ kurse:efcomputergrafik:kw4 [2020/02/12 21:06] (current)
Ivo Blöchliger [Beschleunigung bei konstantem Geschwindigkeisbetrag 1]
@@ Line 179: / Line 179: @@
 Diese zweite Ableitung berechnen wir nummerisch durch Ableiten der ersten:
 \[
-a_n(t(\ell)) := \frac{\textrm{d}v_n(\ell)}{\textrm{d}\ell} \approx \frac{v_n(t(\ell)+\Delta t)-v_n(t(\ell)-\Delta t)}{\ell(t+\Delta t)-\ell(t-\Delta t)} \approx \frac{v_n(t(\ell)+\Delta t)-v_n(t(\ell)-\Delta t)}{|p(t+\Delta t)-p(t-\Delta t)|}
+a_n(t(\ell)) := \frac{\mathrm{d}v_n(\ell)}{\mathrm{d}\ell} \approx \frac{v_n(t(\ell)+\Delta t)-v_n(t(\ell)-\Delta t)}{\ell(t+\Delta t)-\ell(t-\Delta t)} \approx \frac{v_n(t(\ell)+\Delta t)-v_n(t(\ell)-\Delta t)}{|p(t+\Delta t)-p(t-\Delta t)|}
 \]
+Algebraisch erhält man folgendes:
+\[
+\frac{\mathrm{d}}{\mathrm{d}\ell} \left(\frac{p'}{|p'|}\right) =
+\frac{p'' - e \cdot \left( e \cdot p''\right)}{|p'|^2}
+\]
+mit $e=\frac{p'}{|p'|}$. Das ist bis auf den Faktor $|p'|^2$ das Gram-Schmidt Verfahren. Sachen gibts...
 ===== Effektive Beschleunigung und Komponente in Bahnnormalebene =====
 Sei $v_{\text{eff}}(t) \in \mathbb{R}$ der Betrag der effektiven Bahngeschwindigkeit im Punkt zum entsprechenden $t$-Parameter.
@@ Line 233: / Line 239: @@
 ===== Blender =====
 Bezier Klasse laden in Blender:
-<code python>
+<code python bahn.py>
+# Nimmt die Bezierkurven aus myspline und erzeugt
+# die Bahn und die Kamera-Animation
 # Import in Blender 2.8 (see https://devtalk.blender.org/t/2-80-using-multiple-internal-scripts-breaking-change/6980 )
 Bezier = bpy.data.texts["bezier.py"].as_module().Bezier
+obj = bpy.data.objects['mySpline']
+# Kurvenpunkte auslesen
+mypoints=[]
+if obj.type == 'CURVE':
+    for subcurve in obj.data.splines:
+        curvetype = subcurve.type
+        if curvetype == 'BEZIER':
+            for bezpoint in subcurve.bezier_points:
+                mypoints.append(bezpoint.handle_left)
+                mypoints.append(bezpoint.co)
+                mypoints.append(bezpoint.handle_right)
+# Sammlung von Bezierkurven erzeugen
+mySplines = []
+numpoints = len(mypoints)
+totalLength = 0
+for i in range(numpoints//3):
+    mySplines.append(Bezier((mypoints[i*3+1],
+        mypoints[i*3+2],
+        mypoints[(i*3+3)%numpoints],
+        mypoints[(i*3+4)%numpoints])))
+    totalLength+=mySplines[-1].length()
+# Bahn erzeugen
+try:
+    bpy.ops.collection.objects_remove(bpy.data.collections['Rails'])
+except:
+    pass
+railsCol = bpy.data.collections.new('Rails')
+linksCol = bpy.data.collections.new('RailLinks')
+railsCol.children.link(linksCol)
+bpy.context.scene.collection.children.link(railsCol)
+abstand = 0.2  # Bahnpunkte
+ldone = 0  # Erledigte Bahnstrecke
+i=0  # Aktuelle Bezierkurve
+t = 0 # Aktuelle t-Parameter
+g = Vector(0,0,-9.81) # Gravitationbeschleunigung
+hmax = 40  # Hoehe fuer v=0
+# Bahnpunkte: Ctrl-Links, Knoten, Ctrl-Rechts
+railspts=[[],[],[]]  # Bahnpunkte, Schiene L, Schiene R, Träger
+while(ldone<totalLength):
+    dl = abstand;
+    tnext = -1
+    while(tnext<0):
+        tnext = mySplines[i].forward(dl, t)
+        if (tnext<0) : # We get the negative remaining length
+            i=(i+1)%numSplines
+            t = 0
+            dl=abs(tnext)
+        else:
+            ldone+=dl
+    t = tnext
+    # Potentielle Energie mgh
+    ekin = (hmax-mySplines[i].x(t).z)*abs(g.z)
+    # Ek = 1/2 * m * v^2
+    v = (2*ekin)**0.5
+    # Koordinatensystem (vorne, oben, rechts)
+    k = mySplines[i].koordsyst(t,v,g)
+    # Bahnpunkte berechnen
+    #
+    #
+    #
+# Blender-Kurven aus den Bahnpunkten erzeugen
+for j in range(3):
+    curvedata = bpy.data.curves.new(name="rail"+str(j), type='CURVE')
+    curvedata.dimensions = '3D'
+    objectdata = bpy.data.objects.new("rail"+str(j), curvedata)
+    objectdata.location = (0,0,0)
+    objectdata.data.bevel_depth = 0.01
+    railsCol.objects.link(objectdata)
+    polyline = curvedata.splines.new('BEZIER')
+    polyline.bezier_points.add(len(railspts[j])-1)
+    for idx, (h1, knot, h2) in enumerate(railspts[j]):
+        point = polyline.bezier_points[idx]
+        point.co = knot
+        point.handle_left = h1
+        point.handle_right = h2
+        point.handle_left_type = 'ALIGNED'
+        point.handle_right_type = 'ALIGNED'
 </code>