Animacje klatek kluczowych określają, jak wartość zmienia się w czasie. Na przykład możesz określić, gdzie obiekt powinien znajdować się na początku animacji i dokąd ma się przemieścić, a następnie obliczyć jego pozycję w dowolnym punkcie pomiędzy tymi klatkami kluczowymi. Jest to przydatne do analizowania krzywych ruchu, sprawdzania synchronizacji animacji oraz eksportowania próbkowanych wartości do dalszej analizy. Aspose.3D for Python via .NET umożliwia próbkowanie sekwencji klatek kluczowych w określonym znaczniku czasu bez renderowania sceny 3D. W tym samouczku utworzysz prostą animację pozycji, ocenisz jej interpolowane wartości co pół sekundy i zapiszesz wyniki w pliku CSV.

Zainstaluj Aspose.3D dla Pythona

Zainstaluj Aspose.3D for Python via .NET wersję 26.10 przy użyciu pip:

pip install aspose-3d==26.10.0

Ten przykład używa wyłącznie modułu aspose.threed.animation oraz wbudowanego w Pythona modułu csv. Nie potrzebujesz pliku GLB/GLTF ani karty graficznej kompatybilnej z Vulkanem, ponieważ kod wykonuje obliczenia animacji, a nie renderowanie obrazu.

Aby uzyskać informacje o platformie i instalacji, odwołaj się do dokumentacji Aspose.3D for Python.

Utwórz i oceń animację klatek kluczowych w Pythonie

Przykład modeluje pozycję X obiektu. Pozycja zaczyna się od 0, po dwóch sekundach osiąga 10 jednostek i po pięciu sekundach wraca do 0.

Czas (sekundy)Pozycja XDziałanie
00Start
210Osiągnij maksymalną pozycję
50Powróć do startu

Wartości pomiędzy tymi klatkami kluczowymi są obliczane przy użyciu interpolacji liniowej. Przykład tworzy samodzielną krzywą animacji numerycznej; nie łączy sekwencji z rzeczywistym obiektem sceny.

Kompletny przykład kodu w Pythonie

Poniższy skrypt tworzy KeyframeSequence, dodaje trzy klatki kluczowe, ocenia jedenaście znaczników czasu, weryfikuje wartości klatek kluczowych i eksportuje wyniki do 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.")

Zrozum, jak działa ocena klatek kluczowych

Zdefiniuj sekwencję klatek kluczowych

Klasa KeyframeSequence reprezentuje krzywą numeryczną z wartościami zdefiniowanymi w określonych momentach czasu. Ta linia tworzy sekwencję o nazwie PositionX:

sequence = KeyframeSequence("PositionX")

Nazwa pomaga zidentyfikować sekwencję. Nie wiąże ona automatycznie sekwencji z siatką lub właściwością węzła. Aby uzyskać szczegóły, zobacz odniesienie API KeyframeSequence.

Dodaj klatki kluczowe z interpolacją liniową

Każde wywołanie add() dostarcza znacznik czasu, wartość i typ interpolacji:

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 określa, że sekwencja ma obliczać wartości pośrednie proporcjonalnie między klatkami kluczowymi. W rezultacie wartość rośnie równomiernie od 0 do 10 w ciągu pierwszych dwóch sekund i maleje równomiernie od 10 do 0 w ciągu kolejnych trzech sekund.

Oblicz wartość w znaczniku czasu

Kluczowa operacja to:

value = sequence.evaluate(1.5)

W tym przykładzie oczekiwany wynik po 1.5 sekundy to 7.5. Interpolacja liniowa opiera się na następującym wzorze:

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

Tutaj t jest żądanym znacznikiem czasu, t0 i t1 są otaczającymi czasami klatek kluczowych, a v0 i v1 są ich odpowiednimi wartościami.

Między pierwszymi dwoma klatkami kluczowymi, ocena w 1,5 sekundy daje:

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

Nie musisz samodzielnie implementować tej formuły. KeyframeSequence.evaluate() wykonuje obliczenia zgodnie z ustawieniami interpolacji sekwencji.

Sprawdź wyliczone wartości

Dla przykładowych klatek kluczowych, wynik to:

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.

Instrukcje assert sprawdzają wartości w trzech określonych znacznikach czasu klatek kluczowych. Używają małej tolerancji zamiast bezpośredniej równości zmiennoprzecinkowej.

Zmieniające się wartości pomiędzy klatkami kluczowymi potwierdzają, że sekwencja jest próbkowana w całym swoim przedziale czasowym.

Eksportuj wartości klatek kluczowych do CSV

Po ocenie sekwencji skrypt zapisuje czas i obliczoną pozycję X do keyframe_animation.csv przy użyciu modułu csv języka Python. Plik zaczyna się od:

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

Możesz otworzyć ten plik CSV w aplikacji arkusza kalkulacyjnym, narysować powstałą krzywą ruchu lub wczytać go ponownie do Pythona w celu analizy. Aby uzyskać wyniki o większej szczegółowości, zmniejsz step z 0.5 do mniejszego przedziału i dostosuj żądany zakres czasu.

Praktyczne rozważania

Próbka tylko w zamierzonym przedziale czasowym. Ten samouczek ocenia czasy od 0 do 5 sekund. Wartości spoza zdefiniowanych klatek kluczowych są sterowane zachowaniem przed- i po‑ekstrapolacji, które jest oddzielne od interpolacji pomiędzy klatkami kluczowymi.

Wybieraj interpolację świadomie. Interpolacja liniowa powoduje stałe zmiany w każdym segmencie. Inne style interpolacji mogą tworzyć różne charakterystyki ruchu i mogą wymagać dodatkowych ustawień klatek kluczowych. Odwołaj się do referencji API animacji przed zmianą trybu interpolacji.

Rozróżnij ocenę animacji od animacji sceny. Kod ocenia tylko krzywą numeryczną. Nie aktualizuje on pozycji X węzła sceny ani nie tworzy renderowanej animacji. Aby przemieścić obiekt 3D, sekwencja musi być podłączona do odpowiedniej animowanej właściwości w scenie.

Renderowanie GPU nie jest wymagane. Nie wywołuje się Scene.render() ani nie używa się backendu renderującego. Dzięki temu przykład nadaje się do pracy z wartościami animacji na maszynach bez kompatybilnego z Vulkanem GPU.

Uzyskaj darmową tymczasową licencję

Możesz poprosić o darmową 30‑dniową tymczasową licencję, aby ocenić Aspose.3D for Python via .NET bez ograniczeń wersji próbnej. Postępuj zgodnie z przewodnikiem licencjonowania Aspose.3D, aby zastosować licencję w swojej aplikacji.

Darmowe zasoby edukacyjne

Zapoznaj się z tymi zasobami, aby kontynuować pracę z animacją 3D i przepływami przetwarzania plików w Pythonie:

Podsumowanie

Możesz używać KeyframeSequence.evaluate() w Aspose.3D for Python via .NET, aby obliczyć wartości animacji w określonych momentach czasu bez renderowania modelu. W tym przykładzie trzy klatki kluczowe definiują krzywą położenia X, podczas gdy evaluator oblicza pozycje pośrednie i eksportuje je do CSV. Aby dostosować przykład, zmień wartości klatek kluczowych lub interwał próbkowania. Dla animacji na poziomie modelu kolejnym krokiem jest powiązanie krzywych animacji z właściwościami sceny i zastosowanie ich do obiektów.

Czytaj dalej