+- Blenderforum (https://blender-forum.de/forum)
+-- Forum: Blender Hilfe (https://blender-forum.de/forum/forumdisplay.php?fid=4)
+--- Forum: Support (https://blender-forum.de/forum/forumdisplay.php?fid=5)
+--- Thema: Frage Launchingexperimente in Blender/Phyton (/showthread.php?tid=898)
Launchingexperimente in Blender/Phyton - Maurice - 24.03.2025
Moin!
Ich schreibe gerade meine Bachelorarbeit in Psychologie und versuche für mein Experiment Stimuli in Blender zu erstellen. Es geht um ein Launching experiment also naives Physikverständniss. Bei den Stimuli werden in verschiedenen Geschwindigkeiten Billiardkugeln aufeinander geschossen, und mit eyetracking beobachten wir dann, wie gut die Teilnehmer bei welcher Geschwindigkeit Folgen können.
Hier mein Problem:
Ich habe bereits einige Stimuli mit dem Rigid body-system erstellt. Für mein Vorexperiment würde ich allerdings auch gerne mit dem Phyton package Pooltool Blends erstellen, um den Realismus zu vergleichen. Leider schaffe ich es nicht, meinen Code in Blender zum Laufen zu bringen. Das Problem ist die Geschwindigkeit V0. Für mein Experiment muss ich V0 verändern können, leider passiert allerdings nichts, wenn ich V0 veränder.
Vielen Dank das ihr euch mein Problem angehört habt, ich hoffe irgendjemand kann mir weiterhelfen.
Das ist die Blender datei:
setup_for_pooltool-original_dimensions.blend (Größe: 3.79 MB / Downloads: 14)
Und hier ist mein Code:
import bpy
import math
import numpy as np
# --- Minimaldefinitionen für Konstanten und Hilfsfunktionen ---
class const:
stationary = 0
rolling = 1
spinning = 2
pocketed = 3
nontranslating = [stationary, pocketed]
tol = 1e-6
english_fraction = 0.5
numba_cache = False # Platzhalter
# Minimal umgesetzte Utility-Funktionen (stark vereinfacht):
def unit_vector_fast(v):
norm = np.linalg.norm(v)
return v if norm < const.tol else v / norm
def coordinate_rotation_fast(v, angle):
# Dreht den Vektor (oder alle Zeilen eines 2D-Arrays) um 'angle' im xy-Plan.
c, s = np.cos(angle), np.sin(angle)
if v.ndim == 1:
x, y, z = v
return np.array([x * c - y * s, x * s + y * c, z])
else:
R = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
return np.dot(v, R.T)
def angle_fast(v):
# Gibt den Winkel (im Bogenmaß) des Vektors im xy-Plan zurück.
return np.arctan2(v[1], v[0]) if np.linalg.norm(v[:2]) > const.tol else 0
def get_rel_velocity_fast(rvw, R):
# Für diese Simulation nehmen wir an, dass die relative Geschwindigkeit
# einfach der linearen Geschwindigkeit entspricht.
return rvw[1]
def cross_fast(a, b):
return np.cross(a, b)
def quadratic_fast(A, B, C):
# Löst die quadratische Gleichung: A*t^2 + B*t + C = 0
disc = B**2 - 4 * A * C
if disc < 0 or abs(A) < const.tol:
return np.inf, np.inf
t1 = (-B + math.sqrt(disc)) / (2 * A)
t2 = (-B - math.sqrt(disc)) / (2 * A)
return t1, t2
# --- Funktionen aus deinem Code (vereinfacht) ---
def resolve_ball_ball_collision(rvw1, rvw2):
"""Berechnet eine ideale elastische Kollision zweier Kugeln gleicher Masse."""
r1, r2 = rvw1[0], rvw2[0]
v1, v2 = rvw1[1], rvw2[1]
v_rel = v1 - v2
v_mag = np.linalg.norm(v_rel)
n = unit_vector_fast(r2 - r1)
t = coordinate_rotation_fast(n, np.pi / 2)
beta = abs(angle_fast(v_rel) - angle_fast(n))
# Konvertiere ggf. zu float64 (wichtig auf Windows)
rvw1 = rvw1.astype(np.float64)
rvw2 = rvw2.astype(np.float64)
rvw1[1] = t * v_mag * np.sin(beta) + v2
rvw2[1] = n * v_mag * np.cos(beta) + v2
return rvw1, rvw2
def get_ball_ball_collision_coeffs(rvw1, rvw2, s1, s2, mu1, mu2, m1, m2, g1, g2, R):
# Vereinfachter Ansatz: Differenzen der Positionen und Geschwindigkeiten
c1x, c1y = rvw1[0, 0], rvw1[0, 1]
c2x, c2y = rvw2[0, 0], rvw2[0, 1]
if s1 in const.nontranslating:
b1x, b1y = 0, 0
else:
phi1 = angle_fast(rvw1[1])
v1 = np.linalg.norm(rvw1[1])
b1x, b1y = v1 * np.cos(phi1), v1 * np.sin(phi1)
if s2 in const.nontranslating:
b2x, b2y = 0, 0
else:
phi2 = angle_fast(rvw2[1])
v2 = np.linalg.norm(rvw2[1])
b2x, b2y = v2 * np.cos(phi2), v2 * np.sin(phi2)
Bx, By = b2x - b1x, b2y - b1y
Cx, Cy = c2x - c1x, c2y - c1y
# Quadratisches Modell: (B*t + C)^2 = (2R)^2
A = Bx**2 + By**2
B = 2 * (Bx * Cx + By * Cy)
C = Cx**2 + Cy**2 - (2 * R) ** 2
return A, B, C, 0, 0 # d und e nicht benötigt
def get_ball_ball_collision_time(rvw1, rvw2, s1, s2, mu1, mu2, m1, m2, g1, g2, R):
A, B, C, _, _ = get_ball_ball_collision_coeffs(
rvw1, rvw2, s1, s2, mu1, mu2, m1, m2, g1, g2, R
)
if abs(A) < const.tol:
return np.inf
disc = B**2 - 4 * A * C
if disc < 0:
return np.inf
t1 = (-B + math.sqrt(disc)) / (2 * A)
t2 = (-B - math.sqrt(disc)) / (2 * A)
roots = [t for t in [t1, t2] if t > const.tol]
return min(roots) if roots else np.inf
def evolve_state_motion(state, rvw, R, m, u_s, u_sp, u_r, g, t):
"""Einfache Zustandsentwicklung: Wir gehen hier von einer gleichförmigen Bewegung aus."""
new_r = rvw[0] + rvw[1] * t
# Geschwindigkeit und Spin bleiben gleich.
new_rvw = np.array([new_r, rvw[1], rvw[2]])
return new_rvw, state
def cue_strike(m, M, R, V0, phi, theta, a, b):
"""
Simuliert einen Queue-Stoß.
Bei theta=0 und a=b=0 erhält man einen Stoß, der den Ball in
Richtung (F/m)*[sin(phi+pi/2), -cos(phi+pi/2)] schickt.
"""
# Skaliere english-Effekt (hier ohne Einfluss, da a=b=0)
a *= R * const.english_fraction
b *= R * const.english_fraction
# Umrechnung in Bogenmaß
phi = phi * np.pi / 180
theta = theta * np.pi / 180
I = 2 / 5 * m * R**2
# Berechne einen fiktiven Impuls F
F = 2 * M * V0 / (1 + m / M)
# Ballgeschwindigkeit im Ball (nur im y-Anteil, da theta=0)
v_B = -F / m * np.array([0, np.cos(theta), 0])
# Rotation ins Tischkoordinatensystem
rot_angle = phi + np.pi / 2
v_T = coordinate_rotation_fast(v_B, rot_angle)
# Für den Spin (ohne English-Effekte bleibt er hier 0)
w_T = np.zeros(3)
return v_T, w_T
"""TODO: Apply states to initial, intermediate and final positions in blender
=> Init parameters are set in scene
Collision @ frame 40
Number of frames: Time of collision * 24 (+ delay after stimuli has been presented ~4 frames ± 0.1 sec)
Key-Frames:
- initial state is given
- pre-collision state has to be computed with `evolve_state_motion` (Frame: Collision-1)
- final state computed via `resolve_collision` (Frame: Collision-cont)
Remarks:
- blue ball is hit by cue
"""
blue = bpy.data.objects["blueball"]
red = bpy.data.objects["redball"]
ground = bpy.data.objects["Ground"]
cue = bpy.data.objects["cue"]
pos_blue = np.array([-0.211807, 0, 0.0285])
pos_red = np.array([0, 0, 0.0285])
directional_vector = pos_red - pos_blue
distance = np.linalg.norm(directional_vector)
phi = np.degrees(np.arctan2(directional_vector[1], directional_vector[0]))
theta = 0 # Elevationswinkel (Grad)
a = 0 # Seiteneffekt (English)
b = 0 # Vertikaler English
g = 9.81 # Erdbeschleunigung (m/s²)
u_s = 0.2 # Gleitreibungskoeffizient => friction ground
u_sp = 0.01 # Spin-Reibungskoeffizient
u_r = 0.02 # Rollreibungskoeffizient
# Ball2 ist stationär:
vel2 = np.array([0.0, 0.0, 0.0])
spin2 = np.array([0.0, 0.0, 0.0])
rvw2 = np.array([pos_red, vel2, spin2])
# cue_strength = 2 * distance
v0 = distance
m = red.rigid_body.mass # Kugelmasse (kg)
M = cue.rigid_body.mass # Masse des Queues (kg)
radius = 0.0285 # Kugelradius (m)
# Ball1 wird vom Queue getroffen:
v_T, w_T = cue_strike(m, M, radius, v0, phi, theta, a, b)
vel1 = v_T
spin1 = w_T
rvw1 = np.array([pos_blue, vel1, spin1])
# Zustände (hier: Ball1 rollt, Ball2 ist stationär)
s1 = const.rolling
s2 = const.stationary
# Berechne Kollisionszeitpunkt
collision_time = get_ball_ball_collision_time(
rvw1, rvw2, s1, s2, u_r, u_r, m, m, g, g, radius
)
if collision_time == np.inf:
print("\nKeine Kollision vorhergesagt.")
else:
print("\nVorhergesagte Kollisionszeit: {:.4f} s".format(collision_time))
print("Number of frames: ", round(FPS * collision_time * SCALING))
collision_frame = round(
FPS * collision_time * SCALING
) # TODO: this factor needs to be removed
MAX_FRAMES = 2 * collision_frame + 4 # allow short adjustment
# Zustandsentwicklung bis zur Kollision (hier bewegt sich vorwiegend Ball1)
rvw1_collision, _ = evolve_state_motion(
s1, rvw1, radius, m, u_s, u_sp, u_r, g, collision_time
)
# Kollisionsauflösung
rvw1_post, rvw2_post = resolve_ball_ball_collision(
rvw1_collision, rvw2
) # r=position, w=rotation, v=velocity
# Init
# cube.hide_set(False)
# TODO: set visibility
# cube.hide_viewport = True
# cube.hide_render = True
blue.lock_rotation[0] = False
blue.lock_rotation[1] = True
blue.lock_rotation[2] = True
red.lock_rotation[0] = False
red.lock_rotation[1] = True
red.lock_rotation[2] = True
bpy.app.handlers.frame_change_pre.clear()
# INFO: Init ball location
blue.location = [-0.211807, 0, 0.0285]
blue.keyframe_insert("location", frame=0)
# blue.rigid_body.kinematic = False
# blue.keyframe_insert("rigid_body.kinematic", frame=0)
red.location = [0, 0, 0.0285]
red.keyframe_insert("location", frame=0)
# red.rigid_body.kinematic = False
# red.keyframe_insert("rigid_body.kinematic", frame=0)
# INFO: SETUP
cue.location = blue.location
cue.location[0] -= radius * 2 + v0
cue.rigid_body.kinematic = True
cue.keyframe_insert("rigid_body.kinematic", frame=0)
cue.keyframe_insert("location", frame=0)
# INFO: COLLISION CUE & BALL
cue.location = blue.location
# cue.location[0] -= radius
cue.keyframe_insert("location", frame=1)
# cue.rigid_body.kinematic = False
# cue.keyframe_insert("rigid_body.kinematic", frame=1)
# Pre-collision
blue.location = rvw1_collision[0]
blue.keyframe_insert("location", frame=collision_frame)
# Resolved
blue.location = rvw1_post[0]
blue.keyframe_insert("location", frame=MAX_FRAMES)
bpy.context.scene.rigidbody_world.enabled = True
bpy.context.scene.frame_start = 1
bpy.context.scene.frame_end = MAX_FRAMES
bpy.ops.screen.animation_play()
RE: Launchingexperimente in Blender/Phyton - Hobbyblenderer - 25.03.2025
Hallo Maurice,
V0 klingt nach Ausgangsgeschwindigkeit... Dachte ich mir und weiter unten schreibst es ja selbst - egal.
Wenn man den Code einmal hat, ist es natürlich einfach, die Eingangsparameter zu ändern und den Code noch einmal auszuführen.
Wenn du sagst, es ändert sich nichts, dann wird entweder die V0-Variable ignoriert/nicht verwendet, oder irgend etwas anderes ist mit dem Code im Argen. Vorausgesetzt du hast die Variable geändert und den Code noch einmal ausgeführt. Funktioniert by the way auch via Tastencombo "Alt + p"
Mit "bpy" hatte ich auch schon so meinen "Spaß".
So, nachdem ich mir dann doch mal Deine Datei angeguckt habe (weil FPS nicht definiert ist und mir natürlich die Objekte fehlen) komme ich zu dem Schluss:
Da wird genau gar nichts ausgeführt, sondern nur definiert. Also Musst du als aller erstes ganz ans Ende - wenn alles was benötigt wird, definiert ist - in eine separate Zeile ganz links (ohne Einschübe/Tabs) schreiben:
Code:
# --- Hauptsimulation ---
def hello_world():
(GEKÜRZT / HIERUM GEHTS GERADE NICHT)
print("\n=== Zustand nach der Kollision ===")
print(
"Ball1 - Position:",
rvw1_post[0],
"Geschwindigkeit:",
rvw1_post[1],
"Rotation:",
rvw1_post[2],
)
print(
"Ball2 - Position:",
rvw2_post[0],
"Geschwindigkeit:",
rvw2_post[1],
"Rotation:",
rvw2_post[2],
)
import os
os.system("cls")
hello_world()hello_world() macht es aus. Import os und die "cls" Zeile löschen den Text in der Systemconsole - bekommt man nicht direkt eine "Halsschlagader wie Henning May" beim Debuggen.
Die drei Zeilen kannst du 1:1 hier kopieren und bei dir ans Ende einfügen!
Dazu mache ich mir immer die Systemkonsole in einem separaten Fenster auf: ganz oben auf "Window" -> "Toggle System Console" (Menüpunkt ganz unten)
Ich glaube da hast du noch straff zu tun. Sag bescheid, wenn du wieder nicht weiter kommst.
Gruß Hobbyblenderer
Edit: Blender Version 4.4.0 - siehe Blender ganz rechts unten (kurz vorm Displayende, relativ klein)
RE: Launchingexperimente in Blender/Phyton - Hobbyblenderer - 26.03.2025
Für absolute Sicherheit kommt bei mir am Anfang noch ein Zeitstempel:
Code:
import os
import datetime
os.system("cls")
dtGesBeginn = datetime.datetime.now()
print("###############################################")
print("# Beginn:", dtGesBeginn)
print("# Stand:", "15.01.2021")
print("###############################################")naja und unter Stand der Code-Stand - habe ich direkt unterschlagen/vergessen^^
LG und viel Erfolg!
Edit: die "low performer" Binsenweisheit darf nicht fehlen: "Kein Backup, kein Mitleid!"