Charger et évaluer les animations GLB/GLTF en Python

Évaluer les animations dans un fichier GLB ou GLTF vous permet d’inspecter comment les objets 3D se déplacent, tournent et changent d’échelle au fil du temps sans rendre la scène. Vous pouvez utiliser cette approche pour analyser les données d’animation, vérifier les mouvements ou exporter les transformations pour un traitement ultérieur. Dans ce tutoriel, vous chargerez un modèle GLB animé, inspecterez ses clips, évaluerez cinq repères temporels et exporterez les transformations des nœuds vers le format CSV.

Charger et évaluer les animations GLB en Python

Un clip d’animation contient des données d’animation associées à une scène. Ses temps de début et de fin définissent la période que vous pouvez évaluer. Le flux de travail consiste à charger un modèle, sélectionner un clip d’animation, l’appliquer à des moments spécifiques, inspecter les nœuds de la scène et exporter leurs transformations.

Installer Aspose.3D for Python via .NET

Installez Aspose.3D for Python via .NET, qui fournit l’API d’évaluation d’animation utilisée ici :

pip install aspose-3d==26.10.0

Voir la documentation d’installation pour plus de détails.

Évaluer l’animation et exporter les transformations de nœuds

L’exemple de code suivant évalue le premier clip d’animation à cinq intervalles de temps uniformément espacés et enregistre la translation, la rotation et l’échelle locales de chaque nœud dans 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.writerows(records)

print(f"\nSaved animation data to {OUTPUT_FILE}")

Comment fonctionne l’évaluation de l’animation

Charger la scène GLB et récupérer ses clips

Scene.from_file() charge le modèle GLB ou GLTF. La collection scene.animation_clips fournit les clips disponibles :

scene = a3d.Scene.from_file("animated_model.glb")
clips = list(scene.animation_clips)

Chaque clip expose un nom et une plage de temps en secondes via name, start et stop. Voir la référence API AnimationClip.

Appliquer l’animation à des horodatages spécifiques

L’opération centrale est clip.apply_to(time). Pour le clip d’exemple, dont la durée est d’environ 3,708 secondes, les cinq horodatages sont :

Vous pouvez modifier FRAME_COUNT pour collecter davantage d’échantillons. Ces échantillons sont des états d’animation évalués, pas des images rendues.

Lire la translation, la rotation et le redimensionnement

Après avoir appliqué le clip, le script parcourt tous les nœuds de la scène et lit :

• transform.translation : la position locale du nœud.
• transform.rotation : la rotation locale du nœud.
• transform.scaling : l’échelle locale du nœud.

Ce sont des transformations locales, pas nécessairement des coordonnées en espace mondial. Les transformations du nœud parent affectent également la position finale d’un nœud dans la scène. Les nœuds sans animation peuvent conserver les mêmes valeurs à chaque horodatage.

Sortie CSV de l’animation

Le script crée animation_transforms.csv. Pour l’exemple fourni, la console commence par :

Found 1 animation clip(s).
0: Animation_1 (0.000 to 3.708 seconds)

Evaluating: Animation_1

Le CSV contient une ligne par nœud de scène à chaque horodatage échantillonné et ces colonnes :

Vous pouvez ouvrir le CSV dans une application de tableur ou l’analyser avec Python pour comparer les transformations tout au long du clip.

Que vérifier lors de l’évaluation des animations

Plusieurs clips. Cet exemple évalue clips[0]. Pour évaluer une autre animation, choisissez un indice différent ou récupérez un clip par son nom en utilisant scene.get_animation_clip(name).

Résolution d’échantillonnage. Cinq horodatages offrent un aperçu de base, mais peuvent manquer les mouvements rapides. Augmentez FRAME_COUNT ou choisissez des moments spécifiques pour examiner plus de détails.

Squelettes et cibles de morphing. Tous les effets d’animation n’apparaissent pas comme des changements de translation, rotation ou mise à l’échelle locale d’un nœud. Ce flux de travail CSV ne capture pas tous les types de déformation squelettique ou de cible de morphing.

Dépendances GLTF. Les fichiers .gltf basés sur du texte peuvent référencer des tampons et des textures externes. Conservez ces fichiers à leurs chemins relatifs attendus.

L’évaluation des animations GLB nécessite-t-elle un GPU ?

Cet exemple n’appelle pas Scene.render() ni le backend de rendu Vulkan. Il évalue les propriétés d’animation et écrit des données CSV au lieu de générer des images. Le rendu Aspose.3D possède des exigences matérielles distinctes, qui ne s’appliquent pas au flux de travail uniquement CSV de cet exemple.

Obtenez une licence temporaire gratuite

Vous pouvez demander une licence temporaire gratuite de 30 jours pour évaluer Aspose.3D for Python via .NET sans limitations d’évaluation. Pour appliquer la licence dans votre application Python, suivez le guide de licence Aspose.3D.

Ressources d’apprentissage gratuites

Explorez les ressources suivantes pour en savoir plus sur le travail avec des modèles 3D, des animations et les formats de fichiers pris en charge à l’aide d’Aspose.3D for Python via .NET :

• Aspose.3D for Python Developer Guide – Apprenez à créer, charger, modifier et traiter des fichiers 3D.
• Free Online 3D Applications – Visualisez, convertissez et traitez des modèles 3D directement dans votre navigateur.
• Aspose.3D Python API Reference – Explorez les classes, méthodes et propriétés disponibles.
• Aspose.3D Tutorials and Articles – Trouvez des exemples pratiques et des guides pour travailler avec les formats de fichiers 3D.

Conclusion

Aspose.3D for Python via .NET 26.10 vous permet d’évaluer les clips d’animation GLB et GLTF à des moments sélectionnés avec AnimationClip.apply_to(). En lisant les transformations des nœuds après chaque évaluation, vous pouvez inspecter le mouvement et exporter des données d’animation structurées sans rendre le modèle. Adaptez l’exemple pour évaluer des clips supplémentaires, augmenter la fréquence d’échantillonnage ou analyser les nœuds sélectionnés.

En savoir plus

• Convertir GLB en FBX en Python
• Convertir GLB en OBJ en Python
• Convertir OBJ en FBX en Python