Att utvärdera animationer i en GLB eller GLTF fil låter dig inspektera hur 3D‑objekt rör sig, roterar och skalas över tid utan att rendera scenen. Du kan använda detta tillvägagångssätt för att analysera animationsdata, verifiera rörelser eller exportera transformationer för vidare bearbetning. I den här handledningen kommer du att ladda en animerad GLB‑modell, inspektera dess klipp, utvärdera fem tidsstämplar och exportera nodtransformationer till CSV.

Ladda och utvärdera GLB‑animationer i Python

Ett animationsklipp innehåller animationsdata som är kopplade till en scen. Dess start- och stopptider definierar den period du kan utvärdera. Arbetsflödet är att ladda en modell, välja ett animationsklipp, tillämpa det vid specifika tidpunkter, inspektera scennoderna och exportera deras transformationer.

Installera Aspose.3D for Python via .NET

Installera Aspose.3D for Python via .NET, som tillhandahåller animationsutvärderings-API:n som används här:

pip install aspose-3d==26.10.0

Se installationsdokumentationen för mer information.

Utvärdera animation och exportera nodtransformationer

Följande kodexempel utvärderar det första animationsklippet vid fem jämnt fördelade tidsstämplar och sparar varje nods lokala translation, rotation och skalning i 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}")

Hur animationsutvärderingen fungerar

Läs in GLB-scenen och hämta dess klipp

Scene.from_file() laddar GLB- eller GLTF-modellen. scene.animation_clips‑samlingen tillhandahåller de tillgängliga klippen:

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

Varje klipp exponerar ett namn och ett tidsintervall i sekunder via name, start och stop. Se AnimationClip API-referens.

Applicera animationen på specifika tidsstämplar

Den centrala operationen är clip.apply_to(time). För det exempelklippet, vars varaktighet är ungefär 3.708 sekunder, är de fem tidsstämplarna:

ExempelTid (sekunder)
10.000
20.927
31.854
42.781
53.708

Du kan ändra FRAME_COUNT för att samla in fler prover. Dessa prover är utvärderade animationstillstånd, inte renderade bildramar.

Läs translation, rotation och skalning

Efter att ha applicerat klippet traverserar skriptet alla scennoder och läser:

  • transform.translation: nodens lokala position.
  • transform.rotation: nodens lokala rotation.
  • transform.scaling: nodens lokala skala.

Det här är lokala transformationer, inte nödvändigtvis världsrumskoordinater. Föräldranodens transformationer påverkar också en nods slutliga position i scenen. Noder utan animation kan behålla samma värden vid varje tidsstämpel.

CSV-utdata från animationen

Skriptet skapar animation_transforms.csv. För det medföljande exemplet börjar konsolen med:

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

Evaluating: Animation_1

CSV-filen innehåller en rad per scennod för varje samplat tidsstämpel och följande kolumner:

KolumnBeskrivning
TidUtvärderingstidstämpel i sekunder
NodindexNodens index i den rekursiva traverseringen
NodnamnNamn på scennod
TranslationLokal position vid tidsstämpeln
RotationLokal rotation vid tidsstämpeln
SkalningLokal skala vid tidsstämpeln

Du kan öppna CSV‑filen i ett kalkylprogram eller analysera den med Python för att jämföra transformationer över klippet.

Vad man bör kontrollera när man utvärderar animationer

Flera klipp. Detta exempel utvärderar clips[0]. För att utvärdera en annan animation, välj ett annat index eller hämta ett klipp efter namn med scene.get_animation_clip(name).

Samplingsupplösning. Fem tidsstämplar ger en grundläggande översikt, men kan missa snabb rörelse. Öka FRAME_COUNT eller välj specifika tider för att undersöka mer detaljer.

Skelett och morph-mål. Inte alla animationseffekter visas som förändringar i en nodes lokala translation, rotation eller skalning. Detta CSV‑arbetsflöde fångar inte varje typ av skelett‑ eller morph‑måldeförändring.

GLTF-beroenden. Textbaserade .gltf-filer kan referera till externa buffertar och texturer. Behåll dessa filer på deras förväntade relativa sökvägar.

Kräver utvärdering av GLB-animationer ett GPU?

Det här exemplet anropar inte Scene.render() eller Vulkan‑renderingsbakänden. Det utvärderar animeringsegenskaper och skriver CSV‑data istället för att generera bilder. Aspose.3D rendering har separata systemkrav, som inte gäller för detta exempts CSV‑endast arbetsflöde.

Få en gratis tillfällig licens

Du kan begära en gratis 30‑dagars tillfällig licens för att utvärdera 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 arbeta med 3D-modeller, animationer och stödjade filformat med Aspose.3D for Python via .NET:

Slutsats

Aspose.3D for Python via .NET 26.10 låter dig utvärdera GLB- och GLTF-animeringsklipp vid valda tidpunkter med AnimationClip.apply_to(). Genom att läsa nodtransformationer efter varje utvärdering kan du inspektera rörelse och exportera strukturerad animationsdata utan att rendera modellen. Anpassa exemplet för att utvärdera ytterligare klipp, öka samplingsfrekvensen eller analysera utvalda noder.

Läs mer