Las animaciones de fotogramas clave definen cómo cambia un valor a lo largo del tiempo. Por ejemplo, puedes especificar dónde debe estar un objeto al inicio de una animación y a dónde debe moverse a continuación, y luego calcular su posición en cualquier punto entre esos fotogramas clave. Esto es útil para inspeccionar curvas de movimiento, verificar la sincronización de la animación y exportar valores muestreados para un análisis posterior. Aspose.3D for Python via .NET te permite muestrear una secuencia de fotogramas clave en una marca de tiempo especificada sin renderizar una escena 3D. En este tutorial, crearás una animación de posición simple, evaluarás sus valores interpolados cada medio segundo y guardarás los resultados en un archivo CSV.
Instalar Aspose.3D for Python
Instale Aspose.3D for Python via .NET versión 26.10 usando pip:
pip install aspose-3d==26.10.0
Este ejemplo usa solo el módulo aspose.threed.animation y el módulo csv incorporado de Python. No necesita un archivo GLB/GLTF ni una tarjeta gráfica compatible con Vulkan porque el código realiza cálculos de animación en lugar de renderizar imágenes.
Para obtener información sobre la plataforma e instalación, consulte la documentación de Aspose.3D for Python.
Crear y evaluar una animación de fotogramas clave en Python
El ejemplo modela la posición X de un objeto. La posición comienza en 0, alcanza 10 unidades después de dos segundos y vuelve a 0 después de cinco segundos.
| Tiempo (segundos) | Posición X | Acción |
|---|---|---|
| 0 | 0 | Iniciar |
| 2 | 10 | Alcanzar posición máxima |
| 5 | 0 | Volver al inicio |
Los valores entre estos fotogramas clave se calculan mediante interpolación lineal. El ejemplo crea una curva de animación numérica independiente; no adjunta la secuencia a un objeto de escena real.
Ejemplo completo de código Python
El siguiente script crea una KeyframeSequence, agrega tres fotogramas clave, evalúa once marcas de tiempo, valida los valores de los fotogramas clave y exporta los resultados a 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.")
Entender cómo funciona la evaluación de fotogramas clave
Definir una secuencia de fotogramas clave
La clase KeyframeSequence representa una curva numérica con valores definidos en momentos específicos. Esta línea crea una secuencia llamada PositionX:
sequence = KeyframeSequence("PositionX")
El nombre ayuda a identificar la secuencia. No vincula automáticamente la secuencia a una malla o propiedad de nodo. Para más detalles, consulte la Referencia de la API KeyframeSequence.
Agregar fotogramas clave con interpolación lineal
Cada llamada a add() proporciona una marca de tiempo, un valor y un tipo de interpolación:
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 indica a la secuencia que calcule los valores intermedios de forma proporcional entre los fotogramas clave. Como resultado, el valor aumenta de manera constante de 0 a 10 durante los primeros dos segundos y disminuye de manera constante de 10 a 0 durante los siguientes tres segundos.
Calcular un valor en una marca de tiempo
La operación clave es:
value = sequence.evaluate(1.5)
Para este ejemplo, el resultado esperado a los 1.5 segundos es 7.5. La interpolación lineal sigue esta fórmula:
[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]
Aquí, t es la marca de tiempo solicitada, t0 y t1 son los tiempos de fotogramas clave circundantes, y v0 y v1 son sus respectivos valores.
Entre los dos primeros fotogramas clave, al evaluar a 1.5 segundos se obtiene:
[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]
No es necesario que implemente esta fórmula usted mismo. KeyframeSequence.evaluate() realiza el cálculo de acuerdo con la configuración de interpolación de la secuencia.
Verificar los valores evaluados
Para los fotogramas clave de ejemplo, la salida es:
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.
Las sentencias assert verifican los valores en los tres timestamps de keyframe definidos. Utilizan una pequeña tolerancia en lugar de una igualdad directa de punto flotante.
Los valores cambiantes entre fotogramas clave confirman que la secuencia se está muestreando a lo largo de su rango de tiempo.
Exportar valores de fotogramas clave a CSV
Después de evaluar la secuencia, el script escribe el tiempo y la posición X calculada en keyframe_animation.csv usando el módulo csv de Python. El archivo comienza con:
Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0
Puedes abrir este CSV en una aplicación de hoja de cálculo, trazar la curva de movimiento resultante o leerlo de nuevo en Python para su análisis. Para obtener resultados más detallados, reduce step de 0.5 a un intervalo más pequeño y ajusta el rango de tiempo deseado.
Consideraciones prácticas
Muestra solo dentro del rango de tiempo previsto. Este tutorial evalúa los tiempos de 0 a 5 segundos. Los valores fuera de los fotogramas clave definidos están regidos por el comportamiento de extrapolación previa y posterior, que es independiente de la interpolación entre fotogramas clave.
Elija la interpolación deliberadamente. La interpolación lineal produce cambios constantes dentro de cada segmento. Otros estilos de interpolación pueden crear diferentes características de movimiento y pueden requerir configuraciones adicionales de fotogramas clave. Consulte la referencia de la API de animación antes de cambiar el modo de interpolación.
Distinguir la evaluación de animación de la animación de escena. El código evalúa solo una curva numérica. No actualiza la posición X de un nodo de escena ni crea una animación renderizada. Para mover un objeto 3D, la secuencia debe estar conectada a una propiedad animada apropiada en una escena.
No se requiere renderizado GPU. No se llama a Scene.render() ni se utiliza un backend de renderizado. Esto hace que el ejemplo sea adecuado para trabajar con valores de animación en máquinas sin una GPU compatible con Vulkan.
Obtén una licencia temporal gratuita
Puede solicitar una licencia temporal gratuita de 30 días para evaluar Aspose.3D for Python via .NET sin limitaciones de prueba. Siga la guía de licenciamiento de Aspose.3D para aplicar la licencia a su aplicación.
Recursos de aprendizaje gratuitos
Explore estos recursos para continuar trabajando con animación 3D y flujos de trabajo de procesamiento de archivos en Python:
- Aspose.3D for Python Developer Guide – Documentación para cargar, crear y procesar escenas 3D.
- Aspose.3D Animation API Reference – Clases para fotogramas clave, interpolación, clips de animación y enlaces de propiedades.
- Free Online 3D Applications – Herramientas basadas en navegador para tareas compatibles con archivos 3D.
- Aspose.3D Tutorials and Articles – Más ejemplos prácticos para trabajar con formatos 3D.
Conclusión
Puede usar KeyframeSequence.evaluate() en Aspose.3D for Python via .NET para calcular valores de animación en momentos específicos sin renderizar un modelo. En este ejemplo, tres fotogramas clave definen una curva de posición X, mientras que el evaluador calcula posiciones intermedias y las exporta a CSV. Para adaptar el ejemplo, cambie los valores de los fotogramas clave o el intervalo de muestreo. Para animación a nivel de modelo, el siguiente paso es vincular las curvas de animación a las propiedades de la escena y aplicarlas a los objetos.