En animerad GLB eller GLTF modell lagrar geometri och animationsdata snarare än en mapp med färdiga bilder. För att skapa miniatyrbilder eller en bildsekvens måste du utvärdera modellens animation vid specifika tidsstämplar och rendera varje resulterande scen till en bild. Den här handledningen förklarar hur du renderar GLB‑animationsramar i Python med hjälp av Aspose.3D for Python via .NET. Du kommer att ladda en animerad modell, välja ett klipp, sampla dess tidslinje och spara varje ram som en numrerad PNG‑bild. Du kan använda de resulterande bilderna som modell‑förhandsvisningar eller som indata till ett separat bildsekvens‑arbetsflöde.

Installera Aspose.3D för Python via .NET

Installera paket med pip:

pip install aspose-3d

Du kommer också att behöva:

  • En animerad .glb‑fil eller en .gltf‑fil med tillhörande buffertar och texturer.
  • En renderingsmiljö som är kompatibel med Aspose.3D:s hårdvarukrav. Se systemkrav.
  • En kameraposition som håller det animerade objektet i bild under den provade tidslinjen.

Rendera ett animationsklipp som PNG-ramar

Spara följande kod som render_glb_animation_frames.py och kör den från mappen som innehåller 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()

Kör det med:

python render_glb_animation_frames.py

Förväntad utdata: en frames-katalog som innehåller bilder såsom frame_0000.png, frame_0001.png och frame_0002.png. När renderaren fångar de tillämpade animationsstaterna korrekt, visar bilderna modellen vid på varandra följande punkter i dess animation.

Hur koden för ramrendering fungerar

Läs in scenen och välj ett animationsklipp

Scene.from_file()‑metoden öppnar modellen, medan scene.animation_clips ger åtkomst till de animationsklipp den innehåller. Exemplet använder det första klippet och läser dess start‑ och stop‑egenskaper för att bestämma tidsintervallet. En modell utan animationsklipp kan inte generera en animerad sekvens med denna metod.

För mer detaljer om klippval och nodtransformationer, se Load and Evaluate GLB/GLTF Animations in Python.

Sampla tidslinjen med regelbundna intervaller

Skriptet använder fem prover per sekund. Om klippet varar i två sekunder begär det tio bildrutor vid tidsstämplar från 0.0 till 1.8 sekunder när klippet startar vid noll. Att utesluta den exakta slutpunkten undviker att generera en överflödig sista bildruta för animationer som loopar tillbaka till startpositionen.

Metoden clip.apply_to(timestamp) tillämpar det valda animationsklippet vid varje tidsstämpel. Till skillnad från att utvärdera en enskild nyckelramsekvens är detta steg avsett att uppdatera den animerade scenen innan bilden renderas.

Rendera den uppdaterade scenen från en kamera

Exemplet lägger till en kamera på en fast position och anropar scene.render() för varje bildruta. Det ställer också in en bildstorlek på 800 × 600 pixlar och ett PNG‑utdataformat. Att hålla kameran fast gör det enklare att inspektera skillnader mellan bildrutor.

The Aspose.3D scene-rendering guide visar hur man sparar en 3D‑vy som en bild. För animationssekvenser, verifiera att varje bild återspeglar den avsedda tidsstämpeln. Om på varandra följande bildrutor visar samma pose, kontrollera om renderingsvägen använder det aktuella animerade tillståndet.

Namna varje PNG-ram konsekvent

frame_0000.png-mönstret håller bilder i ordning när de sorteras efter filnamn. Det är lämpligt för att generera förhandsminiatyrer eller skicka utdata till ett separat bildsekvens- eller videoflöde. Skriptet skapar inte en video eller en animerad GIF.

Skriptet jämför också filhashar för att varna när alla utdatafiler är byte‑identiska. Olika hashvärden bevisar i sig själva inte att animationen har renderats korrekt; inspektera representativa bildrutor sida vid sida.

Få en gratis tillfällig licens

Du kan begära en gratis 30‑dagars tillfällig licens för att rendera GLB‑ och GLTF‑animeringsramar med Aspose.3D for Python via .NET utan utvärderingsbegränsningar. För att tillämpa licensen i din Python‑applikation, följ Aspose.3D licensguide.

Gratis lärresurser

Utforska följande resurser för att lära dig mer om att ladda animerade 3D-modeller, arbeta med animationsklipp och rendera 3D‑scener med Aspose.3D for Python via .NET:

Slutsats

Du kan generera bildrutor genom att sampla en animations‑tidslinje och rendera scenen vid varje valt tidsstämpling. Använd de numrerade PNG‑filerna för att skapa miniatyrbilder, jämföra poser eller förbereda en bildsekvens för ett annat verktyg. Om du behöver numeriska animationsvärden istället för bilder, se tutorial för nyckelbildsevaluering. För renderingsproblem, besök Aspose.3D supportforum.