Renderizar fotogramas de animación desde GLB/GLTF en Python

Un modelo animado GLB o GLTF almacena geometría y datos de animación en lugar de una carpeta de imágenes listas. Para crear miniaturas o una secuencia de fotogramas, necesita evaluar la animación del modelo en marcas de tiempo específicas y renderizar cada escena resultante en una imagen. Este tutorial explica cómo renderizar fotogramas de animación GLB en Python usando Aspose.3D for Python via .NET. Cargará un modelo animado, seleccionará un clip, muestreará su línea de tiempo y guardará cada fotograma como una imagen PNG numerada. Puede usar las imágenes resultantes como vistas previas del modelo o como entrada para un flujo de trabajo de secuencia de imágenes separado.

Instalar Aspose.3D para Python a través de .NET

Instale el paquete usando pip:

pip install aspose-3d

También necesitarás:

• Un archivo .glb animado o un archivo .gltf con sus buffers y texturas adjuntos.
• Un entorno de renderizado compatible con los requisitos de hardware de Aspose.3D. Consulte los requisitos del sistema.
• Una posición de cámara que mantenga el objeto animado visible a lo largo de la línea de tiempo muestreada.

Renderizar un clip de animación como fotogramas PNG

Guarde el siguiente código como render_glb_animation_frames.py y ejecútelo desde la carpeta que contiene animated_model.glb.

import hashlib
import math
from pathlib import Path

import aspose.threed as a3d
from aspose.pydrawing import Color, Size
from aspose.pydrawing.imaging import ImageFormat
from aspose.threed.entities import Camera
from aspose.threed.utilities import Vector3

INPUT_FILE = Path("animated_model.glb")
OUTPUT_DIR = Path("frames")
FRAMES_PER_SECOND = 5
IMAGE_WIDTH = 800
IMAGE_HEIGHT = 600

def main():
    if not INPUT_FILE.is_file():
        raise FileNotFoundError(f"Input model not found: {INPUT_FILE}")

scene = a3d.Scene.from_file(str(INPUT_FILE))
    clips = list(scene.animation_clips)
    if not clips:
        raise RuntimeError("The input model has no animation clips.")

clip = clips[0]
    duration = float(clip.stop - clip.start)
    if duration <= 0:
        raise ValueError("The selected animation has no positive time range.")

# Use the same camera position for every frame.
    camera = Camera()
    camera_node = scene.root_node.create_child_node("PreviewCamera", camera)
    camera_node.transform.translation = Vector3(3, 2, 6)
    camera.look_at = Vector3.ORIGIN

options = a3d.ImageRenderOptions()
    options.background_color = Color.white
    options.asset_directories.append(str(INPUT_FILE.resolve().parent))

OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    frame_count = max(1, math.ceil(duration * FRAMES_PER_SECOND))
    hashes = set()

for frame_index in range(frame_count):
        timestamp = float(clip.start) + frame_index / FRAMES_PER_SECOND
        clip.apply_to(timestamp)

frame_path = OUTPUT_DIR / f"frame_{frame_index:04d}.png"
        scene.render(
            camera,
            str(frame_path),
            Size(IMAGE_WIDTH, IMAGE_HEIGHT),
            ImageFormat.png,
            options,
        )

if not frame_path.is_file() or frame_path.stat().st_size == 0:
            raise RuntimeError(f"Rendering did not create a usable PNG: {frame_path}")

hashes.add(hashlib.sha256(frame_path.read_bytes()).digest())
        print(f"Frame {frame_index + 1}/{frame_count}: {frame_path} at {timestamp:.3f}s")

if frame_count > 1 and len(hashes) == 1:
        print("WARNING: All PNG files are byte-identical. Check animation state and camera view.")

print(f"Created {frame_count} PNG file(s) in {OUTPUT_DIR}/")

if __name__ == "__main__":
    main()

Ejecutar con:

python render_glb_animation_frames.py

Salida esperada: un directorio frames que contiene imágenes como frame_0000.png, frame_0001.png y frame_0002.png. Cuando el renderizador captura correctamente los estados de animación aplicados, las imágenes muestran el modelo en puntos sucesivos de su animación.

Cómo funciona el código de renderizado de fotogramas

Cargar la escena y seleccionar un clip de animación

El método Scene.from_file() abre el modelo, mientras que scene.animation_clips brinda acceso a los clips de animación que contiene. El ejemplo usa el primer clip y lee sus propiedades start y stop para determinar el rango de tiempo. Un modelo sin clips de animación no puede generar una secuencia animada mediante este método.

Para obtener más detalles sobre la selección de clips y las transformaciones de nodos, consulte Cargar y evaluar animaciones GLB/GLTF en Python.

Muestre la línea de tiempo a intervalos regulares

El script utiliza cinco muestras por segundo. Si el clip dura dos segundos, solicita diez fotogramas en marcas de tiempo de 0.0 a 1.8 segundos cuando el clip comienza en cero. Excluir el punto final exacto evita generar un fotograma final redundante para animaciones que vuelven a la pose inicial.

El método clip.apply_to(timestamp) aplica el clip de animación seleccionado en cada marca de tiempo. A diferencia de evaluar una secuencia de un solo fotograma clave, este paso está destinado a actualizar la escena animada antes de que se renderice la imagen.

Renderizar la escena actualizada desde una cámara

El ejemplo agrega una cámara en una posición fija y llama a scene.render() para cada fotograma. También establece un tamaño de imagen de 800 × 600 píxeles y un formato de salida PNG. Mantener la cámara fija facilita la inspección de las diferencias entre fotogramas.

La guía de renderizado de escenas de Aspose.3D muestra cómo guardar una vista 3D como una imagen. Para secuencias de animación, verifique que cada imagen refleje la marca de tiempo prevista. Si los fotogramas sucesivos muestran la misma pose, compruebe si la ruta de renderizado está utilizando el estado animado actual.

Nombra cada fotograma PNG de forma consistente

El patrón frame_0000.png mantiene las imágenes en orden cuando se ordenan por nombre de archivo. Es adecuado para generar miniaturas de vista previa o pasar la salida a una secuencia de imágenes o flujo de trabajo de video separado. El script no crea un video ni un GIF animado.

El script también compara los hashes de los archivos para advertir cuando todos los archivos de salida son idénticos a nivel de bytes. Los hashes diferentes no prueban por sí mismos que la animación se haya renderizado correctamente; inspecciona los fotogramas representativos lado a lado.

Obtén una licencia temporal gratuita

Puede solicitar una licencia temporal gratuita de 30 días para renderizar fotogramas de animación GLB y GLTF usando 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 la carga de modelos 3D animados, el trabajo con clips de animación y la renderización de escenas 3D usando Aspose.3D for Python via .NET:

• Aspose.3D for Python Developer Guide – Aprenda cómo cargar, modificar, animar y renderizar modelos 3D en Python.
• Render 3D Scenes to Images – Aprenda cómo configurar una cámara y renderizar escenas 3D como archivos de imagen.
• Aspose.3D Python API Reference – Explore clases y métodos para clips de animación, renderizado de escenas, cámaras y procesamiento de archivos 3D.
• Free Online 3D Applications – Vea, convierta y procese modelos 3D compatibles directamente en su navegador.
• Aspose.3D Tutorials and Articles – Encuentre tutoriales prácticos de Python que cubren animaciones GLB/GLTF, evaluación de fotogramas clave y otras tareas de procesamiento 3D.

Conclusión

Puedes generar imágenes de fotogramas muestreando una línea de tiempo de animación y renderizando la escena en cada marca de tiempo seleccionada. Usa los PNG numerados para crear miniaturas, comparar poses o preparar una secuencia de imágenes para otra herramienta. Si necesitas valores numéricos de animación en lugar de imágenes, consulta el tutorial de evaluación de fotogramas clave. Para problemas de renderizado, visita el foro de soporte de Aspose.3D.