Ewaluacja animacji w pliku GLB lub GLTF pozwala sprawdzić, jak obiekty 3D poruszają się, obracają i skalują w czasie, bez renderowania sceny. Możesz użyć tego podejścia do analizy danych animacji, weryfikacji ruchów lub eksportu przekształceń do dalszego przetwarzania. W tym samouczku załadujesz animowany model GLB, przejrzysz jego klipy, ocenisz pięć znaczników czasu i wyeksportujesz przekształcenia węzłów do formatu CSV.

Ładowanie i ocena animacji GLB w Pythonie

Klips animacji zawiera dane animacji powiązane ze sceną. Jego czasy rozpoczęcia i zakończenia definiują okres, który można ocenić. Przebieg pracy polega na załadowaniu modelu, wybraniu klipu animacji, zastosowaniu go w określonych momentach, przeglądzie węzłów sceny oraz wyeksportowaniu ich transformacji.

Zainstaluj Aspose.3D for Python via .NET

Zainstaluj Aspose.3D for Python via .NET, które zapewnia używane tutaj API oceny animacji:

pip install aspose-3d==26.10.0

Zobacz dokumentację instalacji aby uzyskać więcej szczegółów.

Ocena animacji i eksport transformacji węzłów

Poniższy przykład kodu ocenia pierwszy klip animacji w pięciu równomiernie rozmieszczonych punktach czasowych i zapisuje lokalne przemieszczenie, rotację oraz skalowanie każdego węzła w pliku animation_transforms.csv.

import csv
import aspose.threed as a3d

INPUT_FILE = "animated_model.glb"
OUTPUT_FILE = "animation_transforms.csv"
FRAME_COUNT = 5

def get_nodes(root):
    """Recursively collect all nodes in the scene."""
    nodes = [root]

for child in root.child_nodes:
        nodes.extend(get_nodes(child))

return nodes

# Load the animated model
scene = a3d.Scene.from_file(INPUT_FILE)

# Retrieve animation clips
clips = list(scene.animation_clips)

if not clips:
    raise RuntimeError("No animation clips found.")

print(f"Found {len(clips)} animation clip(s).")

for i, item in enumerate(clips):
    print(
        f"{i}: {item.name} "
        f"({item.start:.3f} to {item.stop:.3f} seconds)"
    )

# Select the first clip and collect scene nodes
clip = clips[0]
nodes = get_nodes(scene.root_node)

print(f"\nEvaluating: {clip.name}")
print(f"Scene nodes: {len(nodes)}")

records = []

for i in range(FRAME_COUNT):
    time = float(
        clip.start +
        (clip.stop - clip.start) * i / (FRAME_COUNT - 1)
    )

# Apply animation at the requested time
    clip.apply_to(time)

print(f"\nTimestamp: {time:.3f}s")

for index, node in enumerate(nodes):
        transform = node.transform

translation = str(transform.translation)
        rotation = str(transform.rotation)
        scaling = str(transform.scaling)

records.append([
            time,
            index,
            node.name or "(unnamed)",
            translation,
            rotation,
            scaling
        ])

print(
            f"  {node.name or '(unnamed)'}: "
            f"position={translation}, "
            f"rotation={rotation}"
        )

# Write evaluated transformations to CSV
with open(
    OUTPUT_FILE, "w", newline="", encoding="utf-8"
) as file:
    writer = csv.writer(file)

writer.writerow([
        "Time",
        "Node Index",
        "Node Name",
        "Translation",
        "Rotation",
        "Scaling"
    ])

writer.writerows(records)

print(f"\nSaved animation data to {OUTPUT_FILE}")

Jak działa ocena animacji

Załaduj scenę GLB i pobierz jej klipy

Scene.from_file() ładuje model GLB lub GLTF. Kolekcja scene.animation_clips zapewnia dostępne klipy:

scene = a3d.Scene.from_file("animated_model.glb")
clips = list(scene.animation_clips)

Każdy klip udostępnia nazwę oraz zakres czasu w sekundach za pośrednictwem name, start i stop. Zobacz odwołanie do API AnimationClip.

Zastosuj animację w określonych znacznikach czasu

Główną operacją jest clip.apply_to(time). Dla przykładowego klipu, którego czas trwania wynosi około 3.708 sekundy, pięć znaczników czasu to:

PróbkaCzas (sekundy)
10.000
20.927
31.854
42.781
53.708

Możesz zmienić FRAME_COUNT, aby zebrać więcej próbek. Te próbki są ocenianymi stanami animacji, a nie renderowanymi klatkami obrazu.

Odczyt translacji, rotacji i skalowania

Po zastosowaniu przycięcia skrypt przegląda wszystkie węzły sceny i odczytuje:

  • transform.translation: lokalna pozycja węzła.
  • transform.rotation: lokalna rotacja węzła.
  • transform.scaling: lokalna skala węzła.

Są to lokalne przekształcenia, niekoniecznie współrzędne w przestrzeni światowej. Przekształcenia węzła nadrzędnego również wpływają na ostateczną pozycję węzła w scenie. Węzły bez animacji mogą zachować te same wartości przy każdym znaczniku czasu.

Wyjście CSV z animacji

Skrypt tworzy animation_transforms.csv. Dla dostarczonego przykładu konsola zaczyna się od:

Found 1 animation clip(s).
0: Animation_1 (0.000 to 3.708 seconds)

Evaluating: Animation_1

Plik CSV zawiera po jednym wierszu dla każdego węzła sceny przy każdym próbkowanym znaczniku czasu oraz następujące kolumny:

KolumnaOpis
CzasZnacznik czasu oceny w sekundach
Indeks węzłaIndeks węzła w rekurencyjnym przeglądzie
Nazwa węzłaNazwa węzła sceny
TranslacjaLokalna pozycja w danym znaczniku czasu
RotacjaLokalna rotacja w danym znaczniku czasu
SkalowanieLokalna skala w danym znaczniku czasu

Możesz otworzyć plik CSV w aplikacji arkusza kalkulacyjnego lub przeanalizować go w Pythonie, aby porównać transformacje w całym klipie.

Co sprawdzić przy ocenie animacji

Wiele klipów. Ten przykład ocenia clips[0]. Aby ocenić inną animację, wybierz inny indeks lub pobierz klip po nazwie, używając scene.get_animation_clip(name).

Rozdzielczość próbkowania. Pięć znaczników czasu zapewnia podstawowy przegląd, ale może przegapić szybki ruch. Zwiększ FRAME_COUNT lub wybierz konkretne momenty, aby zbadać więcej szczegółów.

Szkielety i cele morph‑target. Nie wszystkie efekty animacji pojawiają się jako zmiany w lokalnym przemieszczeniu, rotacji lub skalowaniu węzła. Ten przepływ pracy CSV nie obejmuje każdego rodzaju deformacji szkieletowej lub morph‑target.

Zależności GLTF. Pliki tekstowe .gltf mogą odwoływać się do zewnętrznych buforów i tekstur. Zachowaj te pliki w ich oczekiwanych względnych ścieżkach.

Czy ocena animacji GLB wymaga GPU?

Ten przykład nie wywołuje Scene.render() ani backendu renderowania Vulkan. Oceni właściwości animacji i zapisuje dane CSV zamiast generować obrazy. Renderowanie Aspose.3D ma oddzielne wymagania sprzętowe, które nie mają zastosowania do tego przepływu pracy opartego wyłącznie na CSV.

Uzyskaj darmową tymczasową licencję

Możesz poprosić o darmową 30‑dniową tymczasową licencję, aby ocenić Aspose.3D for Python via .NET bez ograniczeń oceny. 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 pracy z modelami 3D, animacjami i obsługiwanymi formatami plików przy użyciu Aspose.3D for Python via .NET:

Podsumowanie

Aspose.3D for Python via .NET 26.10 umożliwia ocenę klipów animacji GLB i GLTF w wybranych momentach za pomocą AnimationClip.apply_to(). Czytając przekształcenia węzłów po każdej ocenie, możesz analizować ruch i eksportować ustrukturyzowane dane animacji bez renderowania modelu. Dostosuj przykład, aby ocenić dodatkowe klipy, zwiększyć częstotliwość próbkowania lub analizować wybrane węzły.

Czytaj więcej