Le animazioni keyframe definiscono come un valore cambia nel tempo. Ad esempio, è possibile specificare dove dovrebbe trovarsi un oggetto all’inizio di un’animazione e dove dovrebbe muoversi successivamente, quindi calcolare la sua posizione in qualsiasi punto tra quei keyframe. Questo è utile per ispezionare le curve di movimento, verificare la sincronizzazione dell’animazione e esportare i valori campionati per ulteriori analisi. Aspose.3D for Python via .NET consente di campionare una sequenza di keyframe a un timestamp specificato senza renderizzare una scena 3D. In questo tutorial, creerai una semplice animazione di posizione, valuterai i suoi valori interpolati ogni mezzo secondo e salverai i risultati in un file CSV.

Installa Aspose.3D per Python

Installa Aspose.3D for Python via .NET versione 26.10 usando pip:

pip install aspose-3d==26.10.0

Questo esempio utilizza solo il modulo aspose.threed.animation e il modulo csv integrato di Python. Non è necessario un file GLB/GLTF o una scheda grafica compatibile con Vulkan perché il codice esegue calcoli di animazione anziché il rendering delle immagini.

Per informazioni sulla piattaforma e sull’installazione, fare riferimento alla documentazione di Aspose.3D for Python.

Crea e valuta un’animazione a fotogrammi chiave in Python

L’esempio modella la posizione X di un oggetto. La posizione parte da 0, raggiunge 10 unità dopo due secondi e ritorna a 0 dopo cinque secondi.

Tempo (secondi)Posizione XAzione
00Inizio
210Raggiungi posizione massima
50Torna all’inizio

I valori tra questi fotogrammi chiave sono calcolati usando interpolazione lineare. L’esempio crea una curva di animazione numerica autonoma; non collega la sequenza a un oggetto scena reale.

Esempio completo di codice Python

Lo script seguente crea un KeyframeSequence, aggiunge tre fotogrammi chiave, valuta undici timestamp, convalida i valori dei fotogrammi chiave e esporta i risultati in keyframe_animation.csv.

import csv

from aspose.threed.animation import (
    KeyframeSequence,
    Interpolation
)

OUTPUT_FILE = "keyframe_animation.csv"

# Create an animation curve
sequence = KeyframeSequence("PositionX")

# Define keyframes using linear interpolation
sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)

# Display the defined keyframes
print("Keyframes:")

for key in sequence.key_frames:
    print(
        f"Time: {key.time:.2f}s, "
        f"Value: {key.value:.2f}"
    )

# Evaluate the animation every 0.5 seconds
start_time = 0.0
end_time = 5.0
step = 0.5

records = []

print("\nEvaluated animation values:")
print("---------------------------")
print("Time (s) | X Position")

sample_count = int(
    round((end_time - start_time) / step)
) + 1

for i in range(sample_count):
    time = float(start_time + i * step)

# Evaluate the animation at this timestamp
    value = float(sequence.evaluate(time))

records.append([time, value])

print(f"{time:8.2f} | {value:10.3f}")

# Verify values at known timestamps
assert abs(sequence.evaluate(0.0) - 0.0) < 1e-5
assert abs(sequence.evaluate(2.0) - 10.0) < 1e-5
assert abs(sequence.evaluate(5.0) - 0.0) < 1e-5

# Export animation data to CSV
with open(
    OUTPUT_FILE,
    "w",
    newline="",
    encoding="utf-8"
) as file:

writer = csv.writer(file)

writer.writerow([
        "Time (seconds)",
        "X Position"
    ])

writer.writerows(records)

print(f"\nAnimation data saved to {OUTPUT_FILE}")
print("Keyframe validation passed.")

Comprendere come funziona la valutazione dei fotogrammi chiave

Definisci una sequenza di fotogrammi chiave

La classe KeyframeSequence rappresenta una curva numerica con valori definiti in momenti specifici. Questa riga crea una sequenza denominata PositionX:

sequence = KeyframeSequence("PositionX")

Il nome aiuta a identificare la sequenza. Non associa automaticamente la sequenza a una mesh o a una proprietà del nodo. Per ulteriori dettagli, vedere il Riferimento API KeyframeSequence.

Aggiungi fotogrammi chiave con interpolazione lineare

Ogni chiamata a add() fornisce un timestamp, un valore e un tipo di interpolazione:

sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)

Interpolation.LINEAR indica alla sequenza di calcolare i valori intermedi proporzionalmente tra i fotogrammi chiave. Di conseguenza, il valore aumenta costantemente da 0 a 10 durante i primi due secondi e diminuisce costantemente da 10 a 0 nei successivi tre secondi.

Calcolare un valore a un timestamp

L’operazione chiave è:

value = sequence.evaluate(1.5)

Per questo esempio, il risultato previsto a 1,5 secondi è 7,5. L’interpolazione lineare segue questa formula:

[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]

Qui, t è il timestamp richiesto, t0 e t1 sono i tempi dei fotogrammi chiave circostanti, e v0 e v1 sono i loro rispettivi valori.

Tra i primi due fotogrammi chiave, valutando a 1,5 secondi si ottiene:

[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]

Non è necessario implementare questa formula da solo. KeyframeSequence.evaluate() esegue il calcolo in base alle impostazioni di interpolazione della sequenza.

Verifica i valori valutati

Per i fotogrammi chiave di esempio, l’output è:

Keyframes:
Time: 0.00s, Value: 0.00
Time: 2.00s, Value: 10.00
Time: 5.00s, Value: 0.00

Evaluated animation values:
---------------------------
Time (s) | X Position
    0.00 |      0.000
    0.50 |      2.500
    1.00 |      5.000
    1.50 |      7.500
    2.00 |     10.000
    2.50 |      8.333
    3.00 |      6.667
    3.50 |      5.000
    4.00 |      3.333
    4.50 |      1.667
    5.00 |      0.000

Animation data saved to keyframe_animation.csv
Keyframe validation passed.

Le istruzioni assert verificano i valori nei tre timestamp dei keyframe definiti. Usano una piccola tolleranza invece di un’uguaglianza diretta dei numeri in virgola mobile.

I valori che cambiano tra i fotogrammi chiave confermano che la sequenza viene campionata lungo l’intervallo di tempo.

Esporta i valori dei fotogrammi chiave in CSV

Dopo aver valutato la sequenza, lo script scrive il tempo e la posizione X calcolata in keyframe_animation.csv utilizzando il modulo csv di Python. Il file inizia con:

Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0

Puoi aprire questo CSV in un’applicazione di foglio di calcolo, tracciare la curva di movimento risultante o rileggerlo in Python per l’analisi. Per ottenere risultati più dettagliati, riduci step da 0.5 a un intervallo più piccolo e regola l’intervallo di tempo desiderato.

Considerazioni pratiche

Esempio solo all’interno dell’intervallo di tempo previsto. Questo tutorial valuta i tempi da 0 a 5 secondi. I valori al di fuori dei keyframe definiti sono governati dal comportamento di pre- e post-estrapolazione, che è separato dall’interpolazione tra i keyframe.

Scegli l’interpolazione in modo deliberato. L’interpolazione lineare produce cambiamenti costanti all’interno di ogni segmento. Altri stili di interpolazione possono creare caratteristiche di movimento diverse e potrebbero richiedere impostazioni aggiuntive dei fotogrammi chiave. Consulta il riferimento API di animazione prima di modificare la modalità di interpolazione.

Distinguere la valutazione dell’animazione dall’animazione della scena. Il codice valuta solo una curva numerica. Non aggiorna la posizione X di un nodo della scena né crea un’animazione renderizzata. Per spostare un oggetto 3D, la sequenza deve essere collegata a una proprietà animata appropriata nella scena.

Il rendering GPU non è richiesto. Non viene effettuata alcuna chiamata a Scene.render() né a un backend di rendering. Ciò rende l’esempio adatto a lavorare con valori di animazione su macchine senza una GPU compatibile con Vulkan.

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 prova. Segui la guida di licenza di Aspose.3D per applicare la licenza alla tua applicazione.

Risorse di apprendimento gratuite

Esplora queste risorse per continuare a lavorare con l’animazione 3D e i flussi di lavoro di elaborazione file in Python:

Conclusione

Puoi usare KeyframeSequence.evaluate() in Aspose.3D for Python via .NET per calcolare i valori di animazione in momenti specifici senza renderizzare un modello. In questo esempio, tre fotogrammi chiave definiscono una curva di posizione X, mentre il valutatore calcola le posizioni intermedie e le esporta in CSV. Per adattare l’esempio, modifica i valori dei fotogrammi chiave o l’intervallo di campionamento. Per l’animazione a livello di modello, il passo successivo è collegare le curve di animazione alle proprietà della scena e applicarle agli oggetti.

Leggi di più