Ein animiertes GLB oder GLTF Modell speichert Geometrie‑ und Animationsdaten anstatt eines Ordners mit fertigen Bildern. Um Miniaturansichten oder eine Bildsequenz zu erstellen, müssen Sie die Animation des Modells zu bestimmten Zeitpunkten auswerten und jede resultierende Szene in ein Bild rendern. Dieses Tutorial erklärt, wie man GLB‑Animationsrahmen in Python rendert mithilfe von Aspose.3D for Python via .NET. Sie laden ein animiertes Modell, wählen einen Clip aus, sampeln seine Zeitleiste und speichern jedes Bild als nummeriertes PNG‑Bild. Die resultierenden Bilder können Sie als Modellvorschau oder als Eingabe für einen separaten Bildsequenz‑Workflow verwenden.

Installation von Aspose.3D für Python via .NET

Installieren Sie das Paket mit pip:

pip install aspose-3d

Sie benötigen außerdem:

  • Eine animierte .glb‑Datei oder eine .gltf‑Datei mit den zugehörigen Puffern und Texturen.
  • Eine Rendering‑Umgebung, die den Hardware‑Anforderungen von Aspose.3D entspricht. Siehe die Systemanforderungen.
  • Eine Kameraposition, die das animierte Objekt über den abgetasteten Zeitverlauf im Bild hält.

Rendern eines Animationsclips als PNG‑Frames

Speichern Sie den folgenden Code als render_glb_animation_frames.py und führen Sie ihn aus dem Ordner aus, der animated_model.glb enthält.

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()

Führen Sie es aus mit:

python render_glb_animation_frames.py

Erwartete Ausgabe: ein frames Verzeichnis, das Bilder wie frame_0000.png, frame_0001.png und frame_0002.png enthält. Wenn der Renderer die angewendeten Animationszustände korrekt erfasst, zeigen die Bilder das Modell zu aufeinanderfolgenden Zeitpunkten seiner Animation.

Wie der Frame-Rendering-Code funktioniert

Laden Sie die Szene und wählen Sie einen Animationsclip aus

Die Methode Scene.from_file() öffnet das Modell, während scene.animation_clips Zugriff auf die darin enthaltenen Animationsclips bietet. Das Beispiel verwendet den ersten Clip und liest dessen start‑ und stop‑Eigenschaften, um den Zeitbereich zu bestimmen. Ein Modell ohne Animationsclips kann mit dieser Methode keine animierte Sequenz erzeugen.

Für weitere Details zur Clip‑Auswahl und Knoten‑Transformationen siehe GLB/GLTF‑Animationen in Python laden und auswerten.

Stichprobe der Zeitleiste in regelmäßigen Intervallen

Das Skript verwendet fünf Samples pro Sekunde. Wenn der Clip zwei Sekunden dauert, fordert es zehn Frames bei Zeitstempeln von 0.0 bis 1.8 Sekunden an, wenn der Clip bei Null startet. Das Ausschließen des genauen Endpunkts verhindert die Erzeugung eines redundanten letzten Frames für Animationen, die zur Ausgangsposition zurückkehren.

Die Methode clip.apply_to(timestamp) wendet den ausgewählten Animationsclip bei jedem Zeitstempel an. Im Gegensatz zur Auswertung einer einzelnen Keyframe-Sequenz dient dieser Schritt dazu, die animierte Szene zu aktualisieren, bevor das Bild gerendert wird.

Rendern Sie die aktualisierte Szene aus einer Kamera

Das Beispiel fügt eine Kamera an einer festen Position hinzu und ruft scene.render() für jedes Bild auf. Es legt außerdem eine Bildgröße von 800 × 600 Pixeln und das PNG‑Ausgabeformat fest. Das Festhalten der Kamera erleichtert die Inspektion von Bild‑zu‑Bild‑Unterschieden.

The Aspose.3D Szenen-Rendering-Leitfaden zeigt, wie man eine 3D-Ansicht als Bild speichert. Für Animationssequenzen prüfen Sie, ob jedes Bild den beabsichtigten Zeitstempel widerspiegelt. Wenn aufeinanderfolgende Frames dieselbe Pose zeigen, überprüfen Sie, ob der Rendering-Pfad den aktuellen animierten Zustand verwendet.

Benennen Sie jedes PNG-Frame konsistent

Das Muster frame_0000.png hält die Bilder in der richtigen Reihenfolge, wenn sie nach Dateinamen sortiert werden. Es eignet sich zur Erstellung von Vorschaubildern oder zum Weitergeben der Ausgabe an einen separaten Bildsequenz‑ oder Video‑Workflow. Das Skript erstellt kein Video oder ein animiertes GIF.

Das Skript vergleicht außerdem Dateihashes, um zu warnen, wenn alle Ausgabedateien byteidentisch sind. Unterschiedliche Hashes beweisen nicht per se, dass die Animation korrekt gerendert wurde; prüfen Sie repräsentative Frames nebeneinander.

Kostenlose temporäre Lizenz erhalten

Sie können eine kostenlose 30‑tägige temporäre Lizenz anfordern, um GLB- und GLTF-Animationsrahmen mit Aspose.3D for Python via .NET ohne Evaluationsbeschränkungen zu rendern. Um die Lizenz in Ihrer Python-Anwendung anzuwenden, folgen Sie dem Aspose.3D-Lizenzierungsleitfaden.

Kostenlose Lernressourcen

Entdecken Sie die folgenden Ressourcen, um mehr über das Laden animierter 3D‑Modelle, die Arbeit mit Animationsclips und das Rendern von 3D‑Szenen mit Aspose.3D for Python via .NET zu erfahren:

Fazit

Sie können Frame‑Bilder erzeugen, indem Sie eine Animationszeitachse abtasten und die Szene zu jedem ausgewählten Zeitstempel rendern. Verwenden Sie die nummerierten PNGs, um Thumbnails zu erstellen, Posen zu vergleichen oder eine Bildsequenz für ein anderes Tool vorzubereiten. Wenn Sie numerische Animationswerte statt Bilder benötigen, siehe das Keyframe‑Auswertungstutorial. Bei Rendering‑Problemen besuchen Sie das Aspose.3D support forum.