Carica e valuta le animazioni GLB/GLTF in Python

Valutare le animazioni in un file GLB o GLTF consente di ispezionare come gli oggetti 3D si muovono, ruotano e scalano nel tempo senza renderizzare la scena. È possibile utilizzare questo approccio per analizzare i dati di animazione, verificare i movimenti o esportare le trasformazioni per ulteriori elaborazioni. In questo tutorial, caricherai un modello GLB animato, ispezionerai i suoi clip, valuterai cinque timestamp e esporterai le trasformazioni dei nodi in CSV.

Carica e valuta le animazioni GLB in Python

Una clip di animazione contiene dati di animazione associati a una scena. I suoi tempi di inizio e fine definiscono il periodo che è possibile valutare. Il flusso di lavoro consiste nel caricare un modello, selezionare una clip di animazione, applicarla a tempi specifici, ispezionare i nodi della scena e esportare le loro trasformazioni.

Installa Aspose.3D for Python via .NET

Installa Aspose.3D for Python via .NET, che fornisce l’API di valutazione dell’animazione utilizzata qui:

pip install aspose-3d==26.10.0

Vedi la documentazione di installazione per ulteriori dettagli.

Valuta l’animazione e l’esportazione delle trasformazioni dei nodi

Il seguente esempio di codice valuta la prima clip di animazione in cinque timestamp equidistanti e salva la traduzione locale, la rotazione e la scala di ciascun nodo in 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}")

Come funziona la valutazione dell’animazione

Carica la scena GLB e recupera i suoi clip

Scene.from_file() carica il modello GLB o GLTF. La collezione scene.animation_clips fornisce le clip disponibili:

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

Ogni clip espone un nome e un intervallo di tempo in secondi tramite name, start e stop. Vedi il riferimento API di AnimationClip.

Applica l’animazione a timestamp specifici

L’operazione centrale è clip.apply_to(time). Per il clip di esempio, la cui durata è di circa 3,708 secondi, i cinque timestamp sono:

Puoi modificare FRAME_COUNT per raccogliere più campioni. Questi campioni sono stati di animazione valutati, non fotogrammi immagine renderizzati.

Leggi traslazione, rotazione e scaling

Dopo aver applicato il ritaglio, lo script attraversa tutti i nodi della scena e legge:

• transform.translation: la posizione locale del nodo.
• transform.rotation: la rotazione locale del nodo.
• transform.scaling: la scala locale del nodo.

Queste sono trasformazioni locali, non necessariamente coordinate nello spazio globale. Le trasformazioni del nodo genitore influenzano anche la posizione finale di un nodo nella scena. I nodi senza animazione possono mantenere gli stessi valori a ogni timestamp.

Output CSV dall’animazione

Lo script crea animation_transforms.csv. Per il campione fornito, la console inizia con:

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

Evaluating: Animation_1

Il CSV contiene una riga per nodo di scena a ogni timestamp campionato e queste colonne:

Puoi aprire il CSV in un’applicazione di foglio di calcolo o analizzarlo con Python per confrontare le trasformazioni nella clip.

Cosa controllare quando si valutano le animazioni

Clip multiple. Questo esempio valuta clips[0]. Per valutare un’altra animazione, scegli un indice diverso o recupera una clip per nome usando scene.get_animation_clip(name).

Risoluzione di campionamento. Cinque timestamp forniscono una panoramica di base, ma potrebbero perdere movimenti rapidi. Aumenta FRAME_COUNT o scegli momenti specifici per ispezionare più dettagli.

Scheletri e target di morph. Non tutti gli effetti di animazione appaiono come modifiche nella traduzione, rotazione o scala locale di un nodo. Questo flusso di lavoro CSV non cattura tutti i tipi di deformazione scheletrica o di morph-target.

Dipendenze GLTF. I file .gltf basati su testo possono fare riferimento a buffer e texture esterni. Mantieni quei file nei percorsi relativi previsti.

La valutazione delle animazioni GLB richiede una GPU?

Questo esempio non invoca Scene.render() né il backend di rendering Vulkan. Valuta le proprietà di animazione e scrive dati CSV invece di generare immagini. Il rendering di Aspose.3D ha requisiti hardware separati requisiti hardware, i quali non si applicano al flusso di lavoro solo CSV di questo esempio.

Ottieni una Licenza Temporanea Gratuita

Puoi richiedere una licenza temporanea gratuita di 30 giorni per valutare Aspose.3D for Python via .NET senza limitazioni di valutazione. Per applicare la licenza nella tua applicazione Python, segui la guida di licenza di Aspose.3D.

Risorse di apprendimento gratuite

Esplora le seguenti risorse per saperne di più su come lavorare con modelli 3D, animazioni e formati di file supportati utilizzando Aspose.3D for Python via .NET:

• Aspose.3D for Python Developer Guide – Scopri come creare, caricare, modificare e elaborare file 3D.
• Free Online 3D Applications – Visualizza, converti ed elabora modelli 3D direttamente nel tuo browser.
• Aspose.3D Python API Reference – Esplora le classi, i metodi e le proprietà disponibili.
• Aspose.3D Tutorials and Articles – Trova esempi pratici e guide per lavorare con i formati di file 3D.

Conclusione

Aspose.3D for Python via .NET 26.10 ti consente di valutare i clip di animazione GLB e GLTF in momenti selezionati con AnimationClip.apply_to(). Leggendo le trasformazioni dei nodi dopo ogni valutazione, puoi ispezionare il movimento ed esportare dati di animazione strutturati senza renderizzare il modello. Adatta l’esempio per valutare clip aggiuntivi, aumentare la frequenza di campionamento o analizzare i nodi selezionati.

Leggi di più

• Converti GLB in FBX in Python
• Converti GLB in OBJ in Python
• Converti OBJ in FBX in Python