Keyframe‑Animationen definieren, wie sich ein Wert im Laufe der Zeit ändert. Zum Beispiel können Sie festlegen, wo ein Objekt zu Beginn einer Animation sein soll und wohin es sich als Nächstes bewegen soll, und dann seine Position zu jedem Zeitpunkt zwischen diesen Keyframes berechnen. Das ist nützlich, um Bewegungskurven zu untersuchen, das Animations‑Timing zu prüfen und abgetastete Werte für weitere Analysen zu exportieren. Aspose.3D for Python via .NET ermöglicht es Ihnen, eine Keyframe‑Sequenz zu einem angegebenen Zeitpunkt zu sampeln, ohne eine 3D‑Szene zu rendern. In diesem Tutorial erstellen Sie eine einfache Positionsanimation, bewerten ihre interpolierten Werte alle halbe Sekunde und speichern die Ergebnisse in einer CSV‑Datei.
Installieren Aspose.3D for Python
Installieren Aspose.3D for Python via .NET Version 26.10 mit pip:
pip install aspose-3d==26.10.0
Dieses Beispiel verwendet nur das aspose.threed.animation‑Modul und das eingebaute csv‑Modul von Python. Sie benötigen keine GLB/GLTF‑Datei oder eine Vulkan‑kompatible Grafikkarte, da der Code Animationsberechnungen statt Bildrendering durchführt.
Für Informationen zu Plattform und Installation siehe die Aspose.3D for Python Dokumentation.
Erstellen und Auswerten einer Keyframe-Animation in Python
Das Beispiel modelliert die X‑Position eines Objekts. Die Position startet bei 0, erreicht nach zwei Sekunden 10 Einheiten und kehrt nach fünf Sekunden zu 0 zurück.
| Zeit (Sekunden) | X-Position | Aktion |
|---|---|---|
| 0 | 0 | Start |
| 2 | 10 | Erreiche maximale Position |
| 5 | 0 | Zurück zum Start |
Die Werte zwischen diesen Schlüsselbildern werden mittels linearer Interpolation berechnet. Das Beispiel erstellt eine eigenständige numerische Animationskurve; sie wird nicht an ein tatsächliches Szenenobjekt angehängt.
Vollständiges Python-Codebeispiel
Das folgende Skript erstellt eine KeyframeSequence, fügt drei Keyframes hinzu, wertet elf Zeitstempel aus, validiert die Keyframe‑Werte und exportiert die Ergebnisse in keyframe_animation.csv.
import csv
from aspose.threed.animation import (
KeyframeSequence,
Interpolation
)
OUTPUT_FILE = "keyframe_animation.csv"
# Create an animation curve
sequence = KeyframeSequence("PositionX")
# Define keyframes using linear interpolation
sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)
# Display the defined keyframes
print("Keyframes:")
for key in sequence.key_frames:
print(
f"Time: {key.time:.2f}s, "
f"Value: {key.value:.2f}"
)
# Evaluate the animation every 0.5 seconds
start_time = 0.0
end_time = 5.0
step = 0.5
records = []
print("\nEvaluated animation values:")
print("---------------------------")
print("Time (s) | X Position")
sample_count = int(
round((end_time - start_time) / step)
) + 1
for i in range(sample_count):
time = float(start_time + i * step)
# Evaluate the animation at this timestamp
value = float(sequence.evaluate(time))
records.append([time, value])
print(f"{time:8.2f} | {value:10.3f}")
# Verify values at known timestamps
assert abs(sequence.evaluate(0.0) - 0.0) < 1e-5
assert abs(sequence.evaluate(2.0) - 10.0) < 1e-5
assert abs(sequence.evaluate(5.0) - 0.0) < 1e-5
# Export animation data to CSV
with open(
OUTPUT_FILE,
"w",
newline="",
encoding="utf-8"
) as file:
writer = csv.writer(file)
writer.writerow([
"Time (seconds)",
"X Position"
])
writer.writerows(records)
print(f"\nAnimation data saved to {OUTPUT_FILE}")
print("Keyframe validation passed.")
Verstehen, wie die Keyframe‑Auswertung funktioniert
Definieren einer Keyframe‑Sequenz
Die Klasse KeyframeSequence repräsentiert eine numerische Kurve mit zu bestimmten Zeitpunkten definierten Werten. Diese Zeile erstellt eine Sequenz namens PositionX:
sequence = KeyframeSequence("PositionX")
Der Name hilft, die Sequenz zu identifizieren. Er bindet die Sequenz nicht automatisch an ein Mesh‑ oder Knoteneigenschaft. Weitere Details finden Sie in der KeyframeSequence API reference.
Keyframes mit linearer Interpolation hinzufügen
Jeder Aufruf von add() liefert einen Zeitstempel, einen Wert und einen Interpolationstyp:
sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)
Interpolation.LINEAR weist die Sequenz an, Zwischenwerte proportional zwischen den Schlüsselbildern zu berechnen. Infolgedessen steigt der Wert gleichmäßig von 0 auf 10 während der ersten zwei Sekunden und fällt gleichmäßig von 10 auf 0 während der nächsten drei Sekunden.
Berechnen Sie einen Wert zu einem Zeitstempel
Der Schlüsselvorgang ist:
value = sequence.evaluate(1.5)
Für dieses Beispiel beträgt das erwartete Ergebnis nach 1,5 Sekunden 7,5. Lineare Interpolation folgt dieser Formel:
[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]
Hier ist t der angeforderte Zeitstempel, t0 und t1 sind die umgebenden Keyframe‑Zeiten, und v0 und v1 sind deren jeweiligen Werte.
Zwischen den ersten beiden Keyframes ergibt die Auswertung bei 1,5 Sekunden:
[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]
Sie müssen diese Formel nicht selbst implementieren. KeyframeSequence.evaluate() führt die Berechnung gemäß den Interpolationseinstellungen der Sequenz durch.
Überprüfen Sie die ausgewerteten Werte
Für die Beispiel‑Keyframes ist die Ausgabe:
Keyframes:
Time: 0.00s, Value: 0.00
Time: 2.00s, Value: 10.00
Time: 5.00s, Value: 0.00
Evaluated animation values:
---------------------------
Time (s) | X Position
0.00 | 0.000
0.50 | 2.500
1.00 | 5.000
1.50 | 7.500
2.00 | 10.000
2.50 | 8.333
3.00 | 6.667
3.50 | 5.000
4.00 | 3.333
4.50 | 1.667
5.00 | 0.000
Animation data saved to keyframe_animation.csv
Keyframe validation passed.
Die assert-Anweisungen prüfen die Werte an den drei definierten Keyframe‑Zeitstempeln. Sie verwenden eine kleine Toleranz anstelle einer direkten Gleitkomma‑Gleichheit.
Die sich ändernden Werte zwischen den Schlüsselbildern bestätigen, dass die Sequenz über ihren Zeitbereich hinweg abgetastet wird.
Exportieren von Keyframe‑Werten in CSV
Nach der Auswertung der Sequenz schreibt das Skript die Zeit und die berechnete X‑Position in keyframe_animation.csv mithilfe des csv‑Moduls von Python. Die Datei beginnt mit:
Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0
Sie können diese CSV in einer Tabellenkalkulationsanwendung öffnen, die resultierende Bewegungskurve plotten oder sie zur Analyse wieder in Python einlesen. Um feinere Ergebnisse zu erhalten, reduzieren Sie step von 0.5 auf ein kleineres Intervall und passen den gewünschten Zeitbereich an.
Praktische Überlegungen
Nur innerhalb des vorgesehenen Zeitbereichs. Dieses Tutorial bewertet Zeiten von 0 bis 5 Sekunden. Werte außerhalb der definierten Schlüsselbilder werden durch das Vor‑ und Nach‑Extrapolationsverhalten gesteuert, das getrennt von der Interpolation zwischen Schlüsselbildern ist.
Wählen Sie die Interpolation bewusst. Lineare Interpolation erzeugt konstante Änderungen innerhalb jedes Segments. Andere Interpolationsstile können unterschiedliche Bewegungseigenschaften erzeugen und erfordern möglicherweise zusätzliche Keyframe‑Einstellungen. Lesen Sie die Animations‑API‑Referenz bevor Sie den Interpolationsmodus ändern.
Unterscheiden Sie die Animationsauswertung von der Szenenanimation. Der Code wertet nur eine numerische Kurve aus. Er aktualisiert nicht die X‑Position eines Szenenknotens und erstellt keine gerenderte Animation. Um ein 3D‑Objekt zu bewegen, muss die Sequenz mit einer geeigneten animierten Eigenschaft in einer Szene verbunden werden.
GPU-Rendering ist nicht erforderlich. Kein Aufruf von Scene.render() oder eines Rendering-Backends wird durchgeführt. Das macht das Beispiel geeignet für die Arbeit mit Animationswerten auf Maschinen ohne eine Vulkan-kompatible GPU.
Kostenlose temporäre Lizenz erhalten
Sie können eine kostenlose 30‑tägige temporäre Lizenz anfordern erhalten, um Aspose.3D for Python via .NET ohne Testbeschränkungen zu evaluieren. Befolgen Sie den Aspose.3D-Lizenzierungsleitfaden, um die Lizenz in Ihrer Anwendung anzuwenden.
Kostenlose Lernressourcen
Entdecken Sie diese Ressourcen, um weiterhin mit 3D‑Animationen und Dateiverarbeitungs‑Workflows in Python zu arbeiten:
- Aspose.3D for Python Developer Guide – Dokumentation zum Laden, Erstellen und Verarbeiten von 3D‑Szenen.
- Aspose.3D Animation API Reference – Klassen für Schlüsselbilder, Interpolation, Animationsclips und Property‑Bindings.
- Free Online 3D Applications – Browserbasierte Werkzeuge für unterstützte 3D‑Datei‑Aufgaben.
- Aspose.3D Tutorials and Articles – Weitere praktische Beispiele für die Arbeit mit 3D‑Formaten.
Fazit
Sie können KeyframeSequence.evaluate() in Aspose.3D for Python via .NET verwenden, um Animationswerte zu bestimmten Zeitpunkten zu berechnen, ohne ein Modell zu rendern. In diesem Beispiel definieren drei Keyframes eine X‑Positionskurve, während der Evaluator Zwischenpositionen berechnet und sie in CSV exportiert. Um das Beispiel anzupassen, ändern Sie die Keyframe‑Werte oder das Abtastintervall. Für Animationen auf Modellebene ist der nächste Schritt, Animationskurven an Szenen‑Eigenschaften zu binden und sie auf Objekte anzuwenden.