Das Evaluieren von Animationen in einer GLB oder GLTF Datei ermöglicht es Ihnen, zu untersuchen, wie sich 3D‑Objekte im Laufe der Zeit bewegen, rotieren und skalieren, ohne die Szene zu rendern. Sie können diesen Ansatz nutzen, um Animationsdaten zu analysieren, Bewegungen zu überprüfen oder Transformationen für die weitere Verarbeitung zu exportieren. In diesem Tutorial laden Sie ein animiertes GLB‑Modell, inspizieren seine Clips, evaluieren fünf Zeitstempel und exportieren Knoten‑Transformationen nach CSV.
GLB-Animationen in Python laden und auswerten
Ein Animationsclip enthält Animationsdaten, die mit einer Szene verknüpft sind. Seine Start‑ und Stoppzeiten definieren den Zeitraum, den Sie auswerten können. Der Arbeitsablauf besteht darin, ein Modell zu laden, einen Animationsclip auszuwählen, ihn zu bestimmten Zeitpunkten anzuwenden, die Szenenknoten zu inspizieren und deren Transformationen zu exportieren.
Installieren Aspose.3D for Python via .NET
Installieren Sie Aspose.3D for Python via .NET, das die hier verwendete Animationsauswertungs-API bereitstellt:
pip install aspose-3d==26.10.0
Siehe die Installationsdokumentation für weitere Details.
Animation bewerten und Knoten‑Transformationen exportieren
Das folgende Codebeispiel wertet den ersten Animationsclip an fünf gleichmäßig verteilten Zeitstempeln aus und speichert die lokale Translation, Rotation und Skalierung jedes Knotens in animation_transforms.csv.
import csv
import aspose.threed as a3d
INPUT_FILE = "animated_model.glb"
OUTPUT_FILE = "animation_transforms.csv"
FRAME_COUNT = 5
def get_nodes(root):
"""Recursively collect all nodes in the scene."""
nodes = [root]
for child in root.child_nodes:
nodes.extend(get_nodes(child))
return nodes
# Load the animated model
scene = a3d.Scene.from_file(INPUT_FILE)
# Retrieve animation clips
clips = list(scene.animation_clips)
if not clips:
raise RuntimeError("No animation clips found.")
print(f"Found {len(clips)} animation clip(s).")
for i, item in enumerate(clips):
print(
f"{i}: {item.name} "
f"({item.start:.3f} to {item.stop:.3f} seconds)"
)
# Select the first clip and collect scene nodes
clip = clips[0]
nodes = get_nodes(scene.root_node)
print(f"\nEvaluating: {clip.name}")
print(f"Scene nodes: {len(nodes)}")
records = []
for i in range(FRAME_COUNT):
time = float(
clip.start +
(clip.stop - clip.start) * i / (FRAME_COUNT - 1)
)
# Apply animation at the requested time
clip.apply_to(time)
print(f"\nTimestamp: {time:.3f}s")
for index, node in enumerate(nodes):
transform = node.transform
translation = str(transform.translation)
rotation = str(transform.rotation)
scaling = str(transform.scaling)
records.append([
time,
index,
node.name or "(unnamed)",
translation,
rotation,
scaling
])
print(
f" {node.name or '(unnamed)'}: "
f"position={translation}, "
f"rotation={rotation}"
)
# Write evaluated transformations to CSV
with open(
OUTPUT_FILE, "w", newline="", encoding="utf-8"
) as file:
writer = csv.writer(file)
writer.writerow([
"Time",
"Node Index",
"Node Name",
"Translation",
"Rotation",
"Scaling"
])
writer.writeres(records)
print(f"\nSaved animation data to {OUTPUT_FILE}")
Wie die Animationsauswertung funktioniert
Laden Sie die GLB‑Szene und rufen Sie deren Clips ab
Scene.from_file() lädt das GLB- oder GLTF‑Modell. Die scene.animation_clips‑Sammlung liefert die verfügbaren Clips:
scene = a3d.Scene.from_file("animated_model.glb")
clips = list(scene.animation_clips)
Jeder Clip stellt einen Namen und einen Zeitbereich in Sekunden über name, start und stop bereit. Siehe die AnimationClip API-Referenz.
Animation zu bestimmten Zeitstempeln anwenden
Die zentrale Operation ist clip.apply_to(time). Für den Beispiel‑Clip, dessen Dauer ungefähr 3.708 Sekunden beträgt, sind die fünf Zeitstempel:
| Beispiel | Zeit (Sekunden) |
|---|---|
| 1 | 0.000 |
| 2 | 0.927 |
| 3 | 1.854 |
| 4 | 2.781 |
| 5 | 3.708 |
Sie können FRAME_COUNT ändern, um mehr Stichproben zu sammeln. Diese Stichproben sind ausgewertete Animationszustände, nicht gerenderte Bildrahmen.
Lesen von Translation, Rotation und Skalierung
Nachdem das Clip angewendet wurde, durchläuft das Skript alle Szenenknoten und liest:
transform.translation: die lokale Position des Knotens.transform.rotation: die lokale Rotation des Knotens.transform.scaling: die lokale Skalierung des Knotens.
Dies sind lokale Transformationen, nicht unbedingt Weltkoordinaten. Elternknoten-Transformationen beeinflussen ebenfalls die endgültige Position eines Knotens in der Szene. Knoten ohne Animation können bei jedem Zeitstempel dieselben Werte beibehalten.
CSV-Ausgabe aus der Animation
Das Skript erstellt animation_transforms.csv. Für das bereitgestellte Beispiel beginnt die Konsole mit:
Found 1 animation clip(s).
0: Animation_1 (0.000 to 3.708 seconds)
Evaluating: Animation_1
Die CSV enthält für jeden Szenenknoten zu jedem abgetasteten Zeitstempel eine Zeile und diese Spalten:
| Spalte | Beschreibung |
|---|---|
| Zeit | Evaluierungszeitstempel in Sekunden |
| Knotenindex | Index des Knotens in der rekursiven Traversierung |
| Knotenname | Name des Szenenknotens |
| Translation | Lokale Position zum Zeitpunkt |
| Rotation | Lokale Rotation zum Zeitpunkt |
| Skalierung | Lokale Skalierung zum Zeitpunkt |
Sie können die CSV-Datei in einer Tabellenkalkulationsanwendung öffnen oder sie mit Python analysieren, um die Transformationen im Clip zu vergleichen.
Was zu prüfen ist, wenn man Animationen bewertet
Mehrere Clips. Dieses Beispiel bewertet clips[0]. Um eine andere Animation zu bewerten, wählen Sie einen anderen Index oder rufen Sie einen Clip anhand seines Namens mit scene.get_animation_clip(name) ab.
Abtastauflösung. Fünf Zeitstempel bieten einen grundlegenden Überblick, können jedoch schnelle Bewegungen übersehen. Erhöhen Sie FRAME_COUNT oder wählen Sie bestimmte Zeitpunkte, um mehr Details zu untersuchen.
Skelette und Morph-Targets. Nicht alle Animationseffekte erscheinen als Änderungen in der lokalen Translation, Rotation oder Skalierung eines Knotens. Dieser CSV-Workflow erfasst nicht jede Art von skeletaler oder Morph-Target-Verformung.
GLTF-Abhängigkeiten. Textbasierte .gltf-Dateien können externe Puffer und Texturen referenzieren. Bewahren Sie diese Dateien an ihren erwarteten relativen Pfaden auf.
Erfordert die Auswertung von GLB-Animationen eine GPU?
Dieses Beispiel ruft Scene.render() oder das Vulkan‑Rendering‑Backend nicht auf. Es bewertet Animations‑Eigenschaften und schreibt CSV‑Daten, anstatt Bilder zu erzeugen. Aspose.3D‑Rendering hat separate Hardwareanforderungen, die für den rein CSV‑Workflow dieses Beispiels nicht gelten.
Kostenlose temporäre Lizenz erhalten
Sie können eine kostenlose 30‑tägige temporäre Lizenz anfordern, um Aspose.3D for Python via .NET ohne Evaluierungsbeschränkungen zu evaluieren. Um die Lizenz in Ihrer Python‑Anwendung anzuwenden, folgen Sie dem Aspose.3D‑Lizenzierungsleitfaden.
Kostenlose Lernressourcen
Entdecken Sie die folgenden Ressourcen, um mehr darüber zu erfahren, wie Sie mit 3D‑Modellen, Animationen und unterstützten Dateiformaten mit Aspose.3D for Python via .NET arbeiten:
- Aspose.3D for Python Developer Guide – Erfahren Sie, wie Sie 3D-Dateien erstellen, laden, ändern und verarbeiten.
- Free Online 3D Applications – Betrachten, konvertieren und verarbeiten Sie 3D-Modelle direkt in Ihrem Browser.
- Aspose.3D Python API Reference – Entdecken Sie verfügbare Klassen, Methoden und Eigenschaften.
- Aspose.3D Tutorials and Articles – Finden Sie praktische Beispiele und Anleitungen zur Arbeit mit 3D-Dateiformaten.
Fazit
Aspose.3D for Python via .NET 26.10 ermöglicht es Ihnen, GLB- und GLTF-Animationsclips zu ausgewählten Zeitpunkten mit AnimationClip.apply_to() auszuwerten. Durch das Lesen der Knoten‑Transformationen nach jeder Auswertung können Sie die Bewegung untersuchen und strukturierte Animationsdaten exportieren, ohne das Modell zu rendern. Passen Sie das Beispiel an, um zusätzliche Clips auszuwerten, die Abtastfrequenz zu erhöhen oder ausgewählte Knoten zu analysieren.