Animasi keyframe mendefinisikan bagaimana nilai berubah seiring waktu. Misalnya, Anda dapat menentukan di mana sebuah objek harus berada pada awal animasi dan ke mana objek tersebut harus bergerak selanjutnya, kemudian menghitung posisinya pada titik mana pun di antara keyframe tersebut. Hal ini berguna untuk memeriksa kurva gerakan, memeriksa timing animasi, dan mengekspor nilai yang disampling untuk analisis lebih lanjut. Aspose.3D for Python via .NET memungkinkan Anda untuk menyampling urutan keyframe pada timestamp tertentu tanpa merender adegan 3D. Dalam tutorial ini, Anda akan membuat animasi posisi sederhana, mengevaluasi nilai interpolasinya setiap setengah detik, dan menyimpan hasilnya dalam file CSV.

Instal Aspose.3D untuk Python

Instal Aspose.3D for Python via .NET versi 26.10 menggunakan pip:

pip install aspose-3d==26.10.0

Contoh ini hanya menggunakan modul aspose.threed.animation dan modul bawaan csv milik Python. Anda tidak memerlukan file GLB/GLTF atau kartu grafis yang kompatibel dengan Vulkan karena kode tersebut melakukan perhitungan animasi bukan rendering gambar.

Untuk informasi platform dan instalasi, lihat dokumentasi Aspose.3D for Python.

Membuat dan mengevaluasi animasi keyframe di Python

Contoh ini memodelkan posisi X dari sebuah objek. Posisi dimulai pada 0, mencapai 10 unit setelah dua detik, dan kembali ke 0 setelah lima detik.

Waktu (detik)Posisi XAksi
00Mulai
210Mencapai posisi maksimum
50Kembali ke awal

Nilai di antara keyframe ini dihitung menggunakan interpolasi linier. Contoh ini membuat kurva animasi numerik yang berdiri sendiri; tidak menempelkan urutan ke objek scene yang sebenarnya.

Contoh kode Python lengkap

Script berikut membuat KeyframeSequence, menambahkan tiga keyframe, mengevaluasi sebelas timestamp, memvalidasi nilai keyframe, dan mengekspor hasilnya ke 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.")

Pahami cara kerja evaluasi keyframe

Definisikan urutan keyframe

Kelas KeyframeSequence mewakili kurva numerik dengan nilai yang didefinisikan pada waktu-waktu tertentu. Baris ini membuat urutan yang bernama PositionX:

sequence = KeyframeSequence("PositionX")

Nama membantu mengidentifikasi urutan. Itu tidak secara otomatis mengikat urutan ke properti mesh atau node. Untuk detail, lihat referensi API KeyframeSequence.

Tambahkan keyframe dengan interpolasi linier

Setiap pemanggilan add() menyediakan timestamp, nilai, dan tipe interpolasi:

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 memberi tahu urutan untuk menghitung nilai antara secara proporsional antara keyframe. Akibatnya, nilai meningkat secara stabil dari 0 hingga 10 selama dua detik pertama dan menurun secara stabil dari 10 ke 0 selama tiga detik berikutnya.

Hitung nilai pada timestamp

Operasi kunci adalah:

value = sequence.evaluate(1.5)

Untuk contoh ini, hasil yang diharapkan pada 1,5 detik adalah 7.5. Interpolasi linier mengikuti rumus ini:

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

Di sini, t adalah timestamp yang diminta, t0 dan t1 adalah waktu keyframe di sekitarnya, dan v0 serta v1 adalah nilai masing‑masing.

Antara dua keyframe pertama, evaluasi pada 1.5 detik menghasilkan:

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

Anda tidak perlu mengimplementasikan rumus ini sendiri. KeyframeSequence.evaluate() melakukan perhitungan sesuai dengan pengaturan interpolasi urutan.

Periksa nilai yang dievaluasi

Untuk keyframes contoh, outputnya adalah:

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.

Pernyataan assert memeriksa nilai pada tiga cap waktu keyframe yang didefinisikan. Mereka menggunakan toleransi kecil alih‑alih kesetaraan floating‑point langsung.

Nilai yang berubah di antara keyframe mengonfirmasi bahwa urutan sedang di‑sampling sepanjang rentang waktunya.

Ekspor nilai keyframe ke CSV

Setelah mengevaluasi urutan, skrip menulis waktu dan posisi X yang dihitung ke keyframe_animation.csv menggunakan modul csv Python. File dimulai dengan:

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

Anda dapat membuka CSV ini di aplikasi spreadsheet, memplot kurva gerakan yang dihasilkan, atau membacanya kembali ke Python untuk analisis. Untuk mendapatkan hasil yang lebih halus, kurangi step dari 0.5 ke interval yang lebih kecil dan sesuaikan rentang waktu yang diinginkan.

Pertimbangan praktis

Contoh hanya dalam rentang waktu yang dimaksudkan. Tutorial ini mengevaluasi waktu dari 0 hingga 5 detik. Nilai di luar keyframes yang didefinisikan diatur oleh perilaku pre- dan post-ekstrapolasi, yang terpisah dari interpolasi antar keyframes.

Pilih interpolasi secara sengaja. Interpolasi linier menghasilkan perubahan konstan dalam setiap segmen. Gaya interpolasi lain dapat menciptakan karakteristik gerakan yang berbeda dan mungkin memerlukan pengaturan keyframe tambahan. Lihat referensi API animasi sebelum mengubah mode interpolasi.

Bedakan evaluasi animasi dari animasi scene. Kode hanya mengevaluasi kurva numerik. Itu tidak memperbarui posisi X node scene atau membuat animasi yang dirender. Untuk memindahkan objek 3D, urutan harus terhubung ke properti animasi yang sesuai dalam sebuah scene.

Rendering GPU tidak diperlukan. Tidak ada pemanggilan Scene.render() atau backend rendering yang dilakukan. Hal ini membuat contoh cocok untuk bekerja dengan nilai animasi pada mesin yang tidak memiliki GPU yang kompatibel dengan Vulkan.

Dapatkan Lisensi Sementara Gratis

Anda dapat meminta lisensi sementara gratis selama 30 hari untuk mengevaluasi Aspose.3D for Python via .NET tanpa batasan percobaan. Ikuti panduan lisensi Aspose.3D untuk menerapkan lisensi ke aplikasi Anda.

Sumber Daya Pembelajaran Gratis

Jelajahi sumber daya ini untuk melanjutkan pekerjaan dengan animasi 3D dan alur kerja pemrosesan file di Python:

Kesimpulan

Anda dapat menggunakan KeyframeSequence.evaluate() di Aspose.3D for Python via .NET untuk menghitung nilai animasi pada waktu tertentu tanpa merender model. Dalam contoh ini, tiga keyframe mendefinisikan kurva posisi X, sementara evaluator menghitung posisi antara dan mengekspornya ke CSV. Untuk menyesuaikan contoh, ubah nilai keyframe atau interval sampling. Untuk animasi tingkat model, langkah selanjutnya adalah mengikat kurva animasi ke properti scene dan menerapkannya ke objek.

Baca Selengkapnya