Keyframe‑animationer definierar hur ett värde förändras över tid. Till exempel kan du ange var ett objekt ska vara i början av en animation och var det ska röra sig härnäst, och sedan beräkna dess position vid någon punkt mellan dessa nyckelramar. Detta är användbart för att inspektera rörelskurvor, kontrollera animationstiming och exportera samplade värden för vidare analys. Aspose.3D for Python via .NET gör det möjligt att sampla en nyckelramsekvens vid en angiven tidsstämpel utan att rendera en 3D‑scen. I den här handledningen kommer du att skapa en enkel positionsanimation, utvärdera dess interpolerade värden varannan halvsekund och spara resultaten i en CSV‑fil.
Installera Aspose.3D for Python
Installera Aspose.3D for Python via .NET version 26.10 med pip:
pip install aspose-3d==26.10.0
Det här exemplet använder endast aspose.threed.animation‑modulen och Pythons inbyggda csv‑modul. Du behöver inte en GLB/GLTF‑fil eller ett Vulkan‑kompatibelt grafikkort eftersom koden utför animationsberäkningar snarare än bildrendering.
För plattforms- och installationsinformation, se Aspose.3D for Python-dokumentation.
Skapa och utvärdera en nyckelbildsanimation i Python
Exemplet modellerar X‑positionen för ett objekt. Positionen startar vid 0, når 10 enheter efter två sekunder och återgår till 0 efter fem sekunder.
| Tid (sekunder) | X-position | Åtgärd |
|---|---|---|
| 0 | 0 | Start |
| 2 | 10 | Nå maximal position |
| 5 | 0 | Återgå till start |
Värdena mellan dessa nyckelbilder beräknas med linjär interpolation. Exemplet skapar en fristående numerisk animationskurva; den fäster inte sekvensen till ett faktiskt scenobjekt.
Komplett Python‑kodexempel
Följande skript skapar en KeyframeSequence, lägger till tre nyckelramar, utvärderar elva tidsstämplar, validerar nyckelramvärdena och exporterar resultaten till 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.")
Förstå hur nyckelbildsutvärderingen fungerar
Definiera en keyframe‑sekvens
Klassen KeyframeSequence representerar en numerisk kurva med värden definierade vid specifika tidpunkter. Denna rad skapar en sekvens med namnet PositionX:
sequence = KeyframeSequence("PositionX")
Namnet hjälper till att identifiera sekvensen. Det binder inte automatiskt sekvensen till ett mesh eller en nod‑egenskap. För detaljer, se KeyframeSequence API reference.
Lägg till nyckelramar med linjär interpolation
Varje anrop till add() tillhandahåller en tidsstämpel, ett värde och en interpoleringstyp:
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 talar om för sekvensen att beräkna mellanliggande värden proportionellt mellan nyckelbilder. Som ett resultat ökar värdet stadigt från 0 till 10 under de första två sekunderna och minskar stadigt från 10 till 0 under de följande tre sekunderna.
Beräkna ett värde vid en tidsstämpel
Den viktigaste operationen är:
value = sequence.evaluate(1.5)
För detta exempel är det förväntade resultatet vid 1.5 sekunder 7.5. Linjär interpolation följer denna formel:
[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]
Här är t den begärda tidsstämpeln, t0 och t1 är de omgivande nyckelramstiderna, och v0 och v1 är deras respektive värden.
Mellan de två första nyckelramarna, ger en utvärdering vid 1,5 sekunder:
[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]
Du behöver inte implementera den här formeln själv. KeyframeSequence.evaluate() utför beräkningen enligt sekvensens interpolationsinställningar.
Kontrollera de utvärderade värdena
För de exempelkeyframes är utskriften:
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.
assert-satserna kontrollerar värdena vid de tre definierade nyckelramstidsstämplarna. De använder en liten tolerans istället för direkt flyttalsjämförelse.
De förändrade värdena mellan nyckelbilder bekräftar att sekvensen samplas över hela dess tidsintervall.
Exportera nyckelbildsvärden till CSV
Efter att sekvensen har utvärderats skriver skriptet tiden och den beräknade X‑positionen till keyframe_animation.csv med Python:s csv‑modul. Filen börjar med:
Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0
Du kan öppna den här CSV-filen i ett kalkylprogram, plotta den resulterande rörelskurvan eller läsa in den igen i Python för analys. För att få finare resultat, minska step från 0.5 till ett mindre intervall och justera det önskade tidsintervallet.
Praktiska överväganden
Endast prov inom avsett tidsintervall. Denna handledning utvärderar tider från 0 till 5 sekunder. Värden utanför de definierade nyckelramarna styrs av för- och efterextrapoleringsbeteende, vilket är separat från interpolation mellan nyckelramar.
Välj interpolering medvetet. Linjär interpolering ger konstanta förändringar inom varje segment. Andra interpolationsstilar kan skapa olika rörelseskaraktäristika och kan kräva ytterligare nyckelraminställningar. Se animation API-referensen innan du ändrar interpolationsläget.
Skilj på animeringsevaluering och scenanimation. Koden utvärderar endast en numerisk kurva. Den uppdaterar inte en scennods X‑position eller skapar en renderad animation. För att flytta ett 3D‑objekt måste sekvensen kopplas till en lämplig animerad egenskap i en scen.
GPU-rendering krävs inte. Inget anrop till Scene.render() eller en renderingsbackend görs. Detta gör exemplet lämpligt för att arbeta med animationsvärden på maskiner utan ett Vulkan‑kompatibelt GPU.
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 begränsningar i provperioden. Följ Aspose.3D licensguide för att tillämpa licensen i din applikation.
Gratis lärresurser
Utforska dessa resurser för att fortsätta arbeta med 3D‑animation och filbearbetningsarbetsflöden i Python:
- Aspose.3D for Python Developer Guide – Dokumentation för inläsning, skapande och bearbetning av 3D‑scener.
- Aspose.3D Animation API Reference – Klasser för nyckelramar, interpolering, animationsklipp och egenskapsbindningar.
- Free Online 3D Applications – Webbläsarbaserade verktyg för stödjade 3D‑filuppgifter.
- Aspose.3D Tutorials and Articles – Fler praktiska exempel för arbete med 3D‑format.
Slutsats
Du kan använda KeyframeSequence.evaluate() i Aspose.3D for Python via .NET för att beräkna animationsvärden vid specifika tidpunkter utan att rendera en modell. I det här exemplet definierar tre nyckelramar en X‑positionskurva, medan evaluatorn beräknar mellanstegens positioner och exporterar dem till CSV. För att anpassa exemplet, ändra nyckelramarnas värden eller samplingsintervallet. För animation på modellnivå är nästa steg att binda animationskurvor till scenegenskaper och tillämpa dem på objekt.