Evaluar animaciones en un archivo GLB o GLTF permite inspeccionar cómo los objetos 3D se mueven, rotan y escalan a lo largo del tiempo sin renderizar la escena. Puedes usar este enfoque para analizar datos de animación, verificar movimientos o exportar transformaciones para un procesamiento posterior. En este tutorial, cargarás un modelo GLB animado, inspeccionarás sus clips, evaluarás cinco marcas de tiempo y exportarás las transformaciones de los nodos a CSV.

Cargar y evaluar animaciones GLB en Python

Un clip de animación contiene datos de animación asociados a una escena. Sus tiempos de inicio y final definen el período que puedes evaluar. El flujo de trabajo consiste en cargar un modelo, seleccionar un clip de animación, aplicarlo en momentos específicos, inspeccionar los nodos de la escena y exportar sus transformaciones.

Instalar Aspose.3D for Python via .NET

Instale Aspose.3D for Python via .NET, que proporciona la API de evaluación de animación utilizada aquí:

pip install aspose-3d==26.10.0

Consulte la documentación de instalación para obtener más detalles.

Evaluar animación y exportar transformaciones de nodo

El siguiente ejemplo de código evalúa el primer clip de animación en cinco marcas de tiempo espaciadas uniformemente y guarda la traducción, rotación y escala locales de cada nodo en 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}")

Cómo funciona la evaluación de la animación

Cargar la escena GLB y recuperar sus clips

Scene.from_file() carga el modelo GLB o GLTF. La colección scene.animation_clips proporciona los clips disponibles:`

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

Cada clip expone un nombre y un rango de tiempo en segundos a través de name, start y stop. Consulte la referencia de la API de AnimationClip.

Aplicar la animación en marcas de tiempo específicas

La operación central es clip.apply_to(time). Para el clip de ejemplo, cuya duración es aproximadamente 3.708 segundos, las cinco marcas de tiempo son:

MuestraTiempo (segundos)
10.000
20.927
31.854
42.781
53.708

Puedes cambiar FRAME_COUNT para recopilar más muestras. Estas muestras son estados de animación evaluados, no fotogramas de imagen renderizados.

Leer traducción, rotación y escalado

Después de aplicar el recorte, el script recorre todos los nodos de la escena y lee:

  • transform.translation: la posición local del nodo.
  • transform.rotation: la rotación local del nodo.
  • transform.scaling: la escala local del nodo.

Estas son transformaciones locales, no necesariamente coordenadas en el espacio mundial. Las transformaciones del nodo padre también afectan la posición final de un nodo en la escena. Los nodos sin animación pueden conservar los mismos valores en cada marca de tiempo.

Salida CSV de la animación

El script crea animation_transforms.csv. Para el ejemplo proporcionado, la consola comienza con:

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

Evaluating: Animation_1

El CSV contiene una fila por nodo de escena en cada marca de tiempo muestreada y estas columnas:

ColumnaDescripción
TiempoMarca de tiempo de evaluación en segundos
Índice del nodoÍndice del nodo en el recorrido recursivo
Nombre del nodoNombre del nodo de la escena
TraslaciónPosición local en la marca de tiempo
RotaciónRotación local en la marca de tiempo
EscalaEscala local en la marca de tiempo

Puedes abrir el CSV en una aplicación de hoja de cálculo o analizarlo con Python para comparar transformaciones a lo largo del clip.

Qué comprobar al evaluar animaciones

Múltiples clips. Este ejemplo evalúa clips[0]. Para evaluar otra animación, elija un índice diferente o recupere un clip por nombre usando scene.get_animation_clip(name).

Resolución de muestreo. Cinco marcas de tiempo proporcionan una visión básica, pero pueden pasar por alto movimientos rápidos. Aumente FRAME_COUNT o elija momentos específicos para inspeccionar más detalle.

Esqueletos y objetivos de morph. No todos los efectos de animación aparecen como cambios en la traslación, rotación o escala local de un nodo. Este flujo de trabajo CSV no captura todo tipo de deformación esquelética o de morph-target.

Dependencias de GLTF. Los archivos .gltf basados en texto pueden hacer referencia a buffers y texturas externos. Mantenga esos archivos en sus rutas relativas esperadas.

¿Evaluar animaciones GLB requiere una GPU?

Este ejemplo no invoca Scene.render() ni el backend de renderizado Vulkan. Evalúa las propiedades de animación y escribe datos CSV en lugar de generar imágenes. El renderizado de Aspose.3D tiene requisitos de hardware separados requisitos de hardware, que no se aplican al flujo de trabajo solo CSV de este ejemplo.

Obtenga 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 evaluación. Para aplicar la licencia en su aplicación Python, siga la guía de licenciamiento de Aspose.3D.

Recursos de aprendizaje gratuitos

Explore los siguientes recursos para aprender más sobre el trabajo con modelos 3D, animaciones y formatos de archivo compatibles usando Aspose.3D for Python via .NET:

Conclusión

Aspose.3D for Python via .NET 26.10 le permite evaluar clips de animación GLB y GLTF en momentos seleccionados con AnimationClip.apply_to(). Al leer las transformaciones de los nodos después de cada evaluación, puede inspeccionar el movimiento y exportar datos de animación estructurados sin renderizar el modelo. Adapte el ejemplo para evaluar clips adicionales, aumentar la frecuencia de muestreo o analizar nodos seleccionados.

Leer más