Animowany model GLB lub GLTF przechowuje dane geometrii i animacji, a nie folder gotowych obrazów. Aby utworzyć miniatury lub sekwencję klatek, należy ocenić animację modelu w określonych znacznikach czasu i wyrenderować każdą powstałą scenę do obrazu. Ten samouczek wyjaśnia, jak renderować klatki animacji GLB w Pythonie przy użyciu Aspose.3D for Python via .NET. Załadujesz animowany model, wybierzesz klip, pobierzesz próbki z jego osi czasu i zapiszesz każdą klatkę jako numerowany obraz PNG. Uzyskane obrazy możesz wykorzystać jako podglądy modelu lub jako wejście do osobnego procesu sekwencji obrazów.

Instalacja Aspose.3D for Python via .NET

Zainstaluj pakiet przy użyciu pip:

pip install aspose-3d

Będziesz także potrzebować:

  • Animowany plik .glb lub plik .gltf z towarzyszącymi buforami i teksturami.
  • Środowisko renderujące zgodne z wymaganiami sprzętowymi Aspose.3D. Zobacz wymagania systemowe.
  • Pozycja kamery, która utrzymuje animowany obiekt w widoku na całej próbkowanej osi czasu.

Renderowanie klipu animacji jako klatki PNG

Zapisz poniższy kod jako render_glb_animation_frames.py i uruchom go z folderu zawierającego 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()

Uruchom go przy użyciu:

python render_glb_animation_frames.py

Oczekiwany wynik: katalog frames zawierający obrazy takie jak frame_0000.png, frame_0001.png i frame_0002.png. Gdy renderer poprawnie przechwytuje zastosowane stany animacji, obrazy pokazują model w kolejnych punktach jego animacji.

Jak działa kod renderowania ramki

Załaduj scenę i wybierz klip animacji

Metoda Scene.from_file() otwiera model, podczas gdy scene.animation_clips zapewnia dostęp do klipów animacji, które zawiera. Przykład używa pierwszego klipu i odczytuje jego właściwości start i stop, aby określić zakres czasu. Model bez klipów animacji nie może wygenerować animowanej sekwencji przy użyciu tej metody.

Aby uzyskać więcej szczegółów na temat wyboru klipów i transformacji węzłów, zobacz Ładowanie i ocena animacji GLB/GLTF w Pythonie.

Próbkuj oś czasu w regularnych odstępach

Skrypt używa pięciu próbek na sekundę. Jeśli klip trwa dwie sekundy, żąda dziesięciu klatek w znacznikach czasu od 0.0 do 1.8 sekundy, gdy klip zaczyna się od zera. Pomijanie dokładnego punktu końcowego zapobiega generowaniu zbędnej ostatniej klatki w animacjach, które wracają do początkowej pozycji.

Metoda clip.apply_to(timestamp) stosuje wybrany klip animacji w każdym znaczniku czasu. W przeciwieństwie do oceny pojedynczej sekwencji klatek kluczowych, ten krok ma na celu zaktualizowanie animowanej sceny przed renderowaniem obrazu.

Renderuj zaktualizowaną scenę z jednej kamery

Przykład dodaje kamerę w stałej pozycji i wywołuje scene.render() dla każdej klatki. Ustawia również rozmiar obrazu 800 × 600 pikseli oraz format wyjściowy PNG. Utrzymanie kamery w stałej pozycji ułatwia analizę różnic pomiędzy kolejnymi klatkami.

The Aspose.3D scene-rendering guide pokazuje, jak zapisać widok 3D jako obraz. Dla sekwencji animacji zweryfikuj, czy każdy obraz odzwierciedla zamierzony znacznik czasu. Jeśli kolejne klatki pokazują tę samą pozycję, sprawdź, czy ścieżka renderowania używa bieżącego stanu animacji.

Nazwij każdą ramkę PNG konsekwentnie

Wzorzec frame_0000.png utrzymuje kolejność obrazów przy sortowaniu według nazwy pliku. Jest odpowiedni do generowania miniatur podglądu lub przekazywania wyniku do osobnego przepływu pracy z sekwencją obrazów lub wideo. Skrypt nie tworzy wideo ani animowanego GIF‑a.

Skrypt porównuje również sumy kontrolne plików, aby ostrzegać, gdy wszystkie pliki wyjściowe są identyczne bajtowo. Różne sumy kontrolne same w sobie nie dowodzą, że animacja została poprawnie wyrenderowana; należy porównać reprezentatywne klatki obok siebie.

Uzyskaj darmową tymczasową licencję

Możesz poprosić o darmową 30‑dniową tymczasową licencję, aby renderować klatki animacji GLB i GLTF przy użyciu Aspose.3D for Python via .NET bez ograniczeń wersji próbnej. Aby zastosować licencję w swojej aplikacji Python, postępuj zgodnie z przewodnikiem licencjonowania Aspose.3D.

Bezpłatne zasoby edukacyjne

Zapoznaj się z poniższymi zasobami, aby dowiedzieć się więcej o ładowaniu animowanych modeli 3D, pracy z klipami animacji oraz renderowaniu scen 3D przy użyciu Aspose.3D for Python via .NET:

Podsumowanie

Możesz generować obrazy klatek, próbkując oś czasu animacji i renderując scenę w każdym wybranym znaczniku czasu. Użyj ponumerowanych plików PNG, aby tworzyć miniatury, porównywać pozy lub przygotować sekwencję obrazów dla innego narzędzia. Jeśli potrzebujesz numerycznych wartości animacji zamiast obrazów, zobacz tutorial oceny klatek kluczowych. W przypadku problemów z renderowaniem odwiedź forum wsparcia Aspose.3D.