Un modèle animé GLB ou GLTF stocke la géométrie et les données d’animation plutôt qu’un dossier d’images prêtes à l’emploi. Pour créer des miniatures ou une séquence d’images, vous devez évaluer l’animation du modèle à des instants précis et rendre chaque scène résultante en une image. Ce tutoriel explique comment rendre les images d’animation GLB en Python en utilisant Aspose.3D for Python via .NET. Vous chargerez un modèle animé, sélectionnerez un clip, échantillonnerez sa chronologie et enregistrerez chaque image sous forme de fichier PNG numéroté. Vous pouvez utiliser les images générées comme aperçus du modèle ou comme entrée d’un flux de travail séparé de séquence d’images.

Installer Aspose.3D for Python via .NET

Installez le package en utilisant pip :

pip install aspose-3d

Vous aurez également besoin de :

  • Un fichier .glb animé ou un fichier .gltf avec ses tampons et textures associés.
  • Un environnement de rendu compatible avec les exigences matérielles d’Aspose.3D. Voir les exigences du système.
  • Une position de caméra qui maintient l’objet animé dans le champ de vision tout au long de la chronologie échantillonnée.

Rendu d’un clip d’animation en images PNG

Enregistrez le code suivant sous le nom render_glb_animation_frames.py et exécutez‑le depuis le dossier contenant 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()

Exécutez‑le avec :

python render_glb_animation_frames.py

Sortie attendue : un répertoire frames contenant des images telles que frame_0000.png, frame_0001.png et frame_0002.png. Lorsque le rendu capture correctement les états d’animation appliqués, les images montrent le modèle à des points successifs de son animation.

Comment fonctionne le code de rendu de trame

Chargez la scène et sélectionnez un clip d’animation

La méthode Scene.from_file() ouvre le modèle, tandis que scene.animation_clips donne accès aux clips d’animation qu’il contient. L’exemple utilise le premier clip et lit ses propriétés start et stop pour déterminer la plage temporelle. Un modèle sans clips d’animation ne peut pas générer une séquence animée avec cette méthode.

Pour plus de détails sur la sélection de clips et les transformations de nœuds, consultez Load and Evaluate GLB/GLTF Animations in Python.

Échantillonner la chronologie à intervalles réguliers

Le script utilise cinq échantillons par seconde. Si le clip dure deux secondes, il demande dix images aux horodatages de 0.0 à 1.8 secondes lorsque le clip commence à zéro. Exclure le point final exact évite de générer une image finale redondante pour les animations qui reviennent à la pose de départ.

La méthode clip.apply_to(timestamp) applique le clip d’animation sélectionné à chaque horodatage. Contrairement à l’évaluation d’une séquence de trame clé unique, cette étape vise à mettre à jour la scène animée avant que l’image ne soit rendue.

Rendre la scène mise à jour depuis une caméra

L’exemple ajoute une caméra à une position fixe et appelle scene.render() pour chaque image. Il définit également une taille d’image de 800 × 600 pixels et un format de sortie PNG. Garder la caméra fixe facilite l’inspection des différences d’une image à l’autre.

Le guide de rendu de scène Aspose.3D montre comment enregistrer une vue 3D sous forme d’image. Pour les séquences d’animation, vérifiez que chaque image reflète l’horodatage prévu. Si les images successives affichent la même pose, vérifiez si le chemin de rendu utilise l’état animé actuel.

Nommez chaque cadre PNG de manière cohérente

Le motif frame_0000.png maintient les images dans l’ordre lorsqu’elles sont triées par nom de fichier. Il convient pour générer des miniatures d’aperçu ou transmettre la sortie à un flux de travail séparé d’image‑séquence ou vidéo. Le script ne crée pas de vidéo ni de GIF animé.

Le script compare également les hachages de fichiers pour avertir lorsque tous les fichiers de sortie sont identiques au niveau des octets. Des hachages différents ne prouvent pas en eux-mêmes que l’animation est rendue correctement ; inspectez les images représentatives côte à côte.

Obtenez une licence temporaire gratuite

Vous pouvez demander une licence temporaire gratuite de 30 jours pour rendre les images d’animation GLB et GLTF en utilisant 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 chargement de modèles 3D animés, le travail avec des clips d’animation et le rendu de scènes 3D en utilisant Aspose.3D for Python via .NET :

Conclusion

Vous pouvez générer des images d’images clés en échantillonnant une chronologie d’animation et en rendant la scène à chaque horodatage sélectionné. Utilisez les PNGs numérotés pour créer des vignettes, comparer les poses ou préparer une séquence d’images pour un autre outil. Si vous avez besoin de valeurs d’animation numériques plutôt que d’images, consultez le tutoriel d’évaluation des images clés. Pour les problèmes de rendu, visitez le forum de support Aspose.3D.