Les animations d’images clés définissent comment une valeur évolue dans le temps. Par exemple, vous pouvez spécifier où un objet doit se trouver au début d’une animation et où il doit se déplacer ensuite, puis calculer sa position à n’importe quel moment entre ces images clés. Cela est utile pour examiner les courbes de mouvement, vérifier le timing de l’animation et exporter les valeurs échantillonnées pour une analyse plus approfondie. Aspose.3D for Python via .NET vous permet d’échantillonner une séquence d’images clés à un horodatage spécifié sans rendre une scène 3D. Dans ce tutoriel, vous créerez une animation de position simple, évaluerez ses valeurs interpolées toutes les demi‑secondes et enregistrerez les résultats dans un fichier CSV.
Installer Aspose.3D pour Python
Installez Aspose.3D for Python via .NET version 26.10 en utilisant pip:
pip install aspose-3d==26.10.0
Cet exemple n’utilise que le module aspose.threed.animation et le module intégré csv de Python. Vous n’avez pas besoin d’un fichier GLB/GLTF ou d’une carte graphique compatible Vulkan, car le code effectue des calculs d’animation plutôt que le rendu d’images.
Pour les informations sur la plateforme et l’installation, reportez‑vous à la Aspose.3D for Python documentation.
Créer et évaluer une animation d’images clés en Python
L’exemple modélise la position X d’un objet. La position commence à 0, atteint 10 unités après deux secondes, et revient à 0 après cinq secondes.
| Temps (secondes) | Position X | Action |
|---|---|---|
| 0 | 0 | Démarrer |
| 2 | 10 | Atteindre la position maximale |
| 5 | 0 | Retour au point de départ |
Les valeurs entre ces images clés sont calculées à l’aide de l’interpolation linéaire. L’exemple crée une courbe d’animation numérique autonome ; il n’attache pas la séquence à un objet de scène réel.
Exemple complet de code Python
Le script suivant crée une KeyframeSequence, ajoute trois images clés, évalue onze horodatages, valide les valeurs des images clés et exporte les résultats vers 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.")
Comprendre le fonctionnement de l’évaluation des images clés
Définir une séquence d’images clés
La classe KeyframeSequence représente une courbe numérique avec des valeurs définies à des moments spécifiques. Cette ligne crée une séquence nommée PositionX :
sequence = KeyframeSequence("PositionX")
Le nom aide à identifier la séquence. Il ne lie pas automatiquement la séquence à un maillage ou à une propriété de nœud. Pour plus de détails, consultez la référence de l’API KeyframeSequence.
Ajouter des images clés avec interpolation linéaire
Chaque appel à add() fournit un horodatage, une valeur et un type d’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)
Interpolation.LINEAR indique à la séquence de calculer les valeurs intermédiaires proportionnellement entre les images clés. En conséquence, la valeur augmente régulièrement de 0 à 10 pendant les deux premières secondes et diminue régulièrement de 10 à 0 pendant les trois secondes suivantes.
Calculer une valeur à un horodatage
L’opération clé est :
value = sequence.evaluate(1.5)
Pour cet exemple, le résultat attendu à 1,5 seconde est 7,5. L’interpolation linéaire suit cette formule :
[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]
Ici, t est le timestamp demandé, t0 et t1 sont les temps des images‑clés environnantes, et v0 et v1 sont leurs valeurs respectives.
Entre les deux premières images clés, l’évaluation à 1,5 seconde donne :
[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]
Vous n’avez pas besoin d’implémenter cette formule vous-même. KeyframeSequence.evaluate() effectue le calcul selon les paramètres d’interpolation de la séquence.
Vérifier les valeurs évaluées
Pour les keyframes d’exemple, la sortie est :
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.
Les instructions assert vérifient les valeurs aux trois horodatages de trame clé définis. Elles utilisent une petite tolérance plutôt qu’une égalité directe en virgule flottante.
Les valeurs changeantes entre les images clés confirment que la séquence est échantillonnée sur toute sa plage temporelle.
Exporter les valeurs des images clés vers CSV
Après avoir évalué la séquence, le script écrit le temps et la position X calculée dans keyframe_animation.csv en utilisant le module csv de Python. Le fichier commence par :
Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0
Vous pouvez ouvrir ce CSV dans une application de feuille de calcul, tracer la courbe de mouvement résultante, ou le relire dans Python pour l’analyse. Pour obtenir des résultats plus détaillés, réduisez step de 0.5 à un intervalle plus petit et ajustez la plage de temps souhaitée.
Considérations pratiques
Échantillon uniquement dans la plage de temps prévue. Ce tutoriel évalue les temps de 0 à 5 secondes. Les valeurs en dehors des images clés définies sont régies par le comportement d’extrapolation pré et post, qui est distinct de l’interpolation entre les images clés.
Choisissez l’interpolation délibérément. L’interpolation linéaire produit des changements constants au sein de chaque segment. D’autres styles d’interpolation peuvent créer différentes caractéristiques de mouvement et peuvent nécessiter des réglages de trame clé supplémentaires. Consultez la référence de l’API d’animation avant de changer le mode d’interpolation.
Distinguer l’évaluation de l’animation de l’animation de scène. Le code n’évalue qu’une courbe numérique. Il ne met pas à jour la position X d’un nœud de scène ni ne crée une animation rendue. Pour déplacer un objet 3D, la séquence doit être connectée à une propriété animée appropriée dans une scène.
Le rendu GPU n’est pas requis. Aucun appel à Scene.render() ou à un backend de rendu n’est effectué. Cela rend l’exemple adapté à travailler avec des valeurs d’animation sur des machines sans GPU compatible Vulkan.
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’essai. Consultez le guide de licence Aspose.3D pour appliquer la licence à votre application.
Ressources d’apprentissage gratuites
Explorez ces ressources pour continuer à travailler avec l’animation 3D et les flux de travail de traitement de fichiers en Python :
- Aspose.3D for Python Developer Guide – Documentation pour le chargement, la création et le traitement des scènes 3D.
- Aspose.3D Animation API Reference – Classes pour les images clés, l’interpolation, les clips d’animation et les liaisons de propriétés.
- Free Online 3D Applications – Outils basés sur le navigateur pour les tâches prises en charge sur les fichiers 3D.
- Aspose.3D Tutorials and Articles – Plus d’exemples pratiques pour travailler avec les formats 3D.
Conclusion
Vous pouvez utiliser KeyframeSequence.evaluate() dans Aspose.3D for Python via .NET pour calculer les valeurs d’animation à des moments spécifiques sans rendre un modèle. Dans cet exemple, trois images clés définissent une courbe de position X, tandis que l’évaluateur calcule les positions intermédiaires et les exporte au format CSV. Pour adapter l’exemple, modifiez les valeurs des images clés ou l’intervalle d’échantillonnage. Pour l’animation au niveau du modèle, l’étape suivante consiste à lier les courbes d’animation aux propriétés de la scène et à les appliquer aux objets.