Keyframe animasyonları bir değerin zaman içinde nasıl değiştiğini tanımlar. Örneğin, bir nesnenin animasyonun başında nerede olması gerektiğini ve sonraki hareketinin nerede olacağını belirtebilir, ardından bu anahtar kareler arasındaki herhangi bir noktada konumunu hesaplayabilirsiniz. Bu, hareket eğrilerini incelemek, animasyon zamanlamasını kontrol etmek ve daha fazla analiz için örneklenmiş değerleri dışa aktarmak için kullanışlıdır. Aspose.3D for Python via .NET belirli bir zaman damgasında bir anahtar kare dizisini, 3D sahne render etmeden örneklemenizi sağlar. Bu öğreticide, basit bir konum animasyonu oluşturacak, ara değerlerini her yarım saniyede bir değerlendirecek ve sonuçları bir CSV dosyasına kaydedeceksiniz.

Kur Aspose.3D for Python

pip kullanarak Aspose.3D for Python via .NET sürüm 26.10’ı kurun:

pip install aspose-3d==26.10.0

Bu örnek yalnızca aspose.threed.animation modülünü ve Python’un yerleşik csv modülünü kullanır. Kod animasyon hesaplamalarını gerçekleştirdiği için görüntü işleme yerine GLB/GLTF dosyasına veya Vulkan uyumlu bir grafik kartına ihtiyacınız yoktur.

Platform ve kurulum bilgileri için, Aspose.3D for Python documentation adresine bakın.

Python’da bir anahtar kare animasyonu oluşturma ve değerlendirme

Örnek, bir nesnenin X konumunu modellemektedir. Konum 0’dan başlar, iki saniye sonra 10 birime ulaşır ve beş saniye sonra 0’a geri döner.

Zaman (saniye)X konumuEylem
00Başlat
210Maksimum konuma ulaş
50Başlangıca dön

Bu anahtar kareler arasındaki değerler doğrusal enterpolasyon kullanılarak hesaplanır. Örnek, bağımsız bir sayısal animasyon eğrisi oluşturur; diziyi gerçek bir sahne nesnesine bağlamaz.

Tam Python kod örneği

Aşağıdaki betik bir KeyframeSequence oluşturur, üç anahtar kare ekler, on bir zaman damgasını değerlendirir, anahtar kare değerlerini doğrular ve sonuçları keyframe_animation.csv dosyasına dışa aktarır.

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.")

Anahtar kare değerlendirmesinin nasıl çalıştığını anlayın

Bir anahtar kare dizisi tanımlayın

KeyframeSequence sınıfı, belirli zamanlarda tanımlanan değerlerle sayısal bir eğriyi temsil eder. Bu satır, PositionX adlı bir dizi oluşturur:

sequence = KeyframeSequence("PositionX")

İsim, diziyi tanımlamaya yardımcı olur. Diziyi otomatik olarak bir mesh veya düğüm özelliğine bağlamaz. Ayrıntılar için, KeyframeSequence API reference adresine bakın.

Doğrusal enterpolasyonla anahtar kareler ekleyin

Her add() çağrısı bir zaman damgası, bir değer ve bir enterpolasyon türü sağlar:

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 dizinin ara değerleri ana kareler arasında orantılı olarak hesaplamasını söyler. Sonuç olarak, değer ilk iki saniye içinde 0’dan 10’a istikrarlı bir şekilde artar ve sonraki üç saniye içinde 10’dan 0’a istikrarlı bir şekilde azalır.

Bir zaman damgasında bir değeri hesaplayın

Ana işlem şudur:

value = sequence.evaluate(1.5)

Bu örnek için, 1.5 saniyedeki beklenen sonuç 7.5’tir. Doğrusal enterpolasyon şu formülü izler:

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

Burada, t is the requested timestamp, t0 ve t1 çevreleyen anahtar kare zamanlarıdır, ve v0 ve v1 bunların ilgili değerleridir.

İlk iki anahtar kare arasında, 1.5 saniyede değerlendirme şu sonucu verir:

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

Bu formülü kendiniz uygulamanıza gerek yok. KeyframeSequence.evaluate() sıralamanın interpolasyon ayarlarına göre hesaplamayı gerçekleştirir.

Değerlendirilen değerleri kontrol edin

Örnek anahtar kareler için çıktı şu şekildedir:

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 ifadeleri, tanımlı üç anahtar kare zaman damgasındaki değerleri kontrol eder. Doğrudan kayan nokta eşitliği yerine küçük bir tolerans kullanırlar.

Kare anahtarları arasındaki değişen değerler, dizinin zaman aralığı boyunca örneklenmekte olduğunu doğrular.

Anahtar kare değerlerini CSV’ye dışa aktar

Sequenci değerlendirdikten sonra, script Python’un csv modülünü kullanarak zamanı ve hesaplanan X konumunu keyframe_animation.csv dosyasına yazar. Dosya şu şekilde başlar:

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

Bu CSV’yi bir elektronik tablo uygulamasında açabilir, ortaya çıkan hareket eğrisini çizebilir veya analiz için tekrar Python’a okuyabilirsiniz. Daha ayrıntılı sonuçlar elde etmek için step değerini 0.5‘ten daha küçük bir aralığa düşürün ve istenen zaman aralığını ayarlayın.

Pratik hususlar

Örnek yalnızca amaçlanan zaman aralığında. Bu öğreticide 0 ile 5 saniye arasındaki zamanlar değerlendirilir. Tanımlı anahtar karelerin dışındaki değerler, anahtar kareler arasındaki enterpolasyondan ayrı olan ön ve son ekstrapolasyon davranışıyla yönetilir.

İnterpolasyonu bilinçli seçin. Doğrusal interpolasyon, her segment içinde sabit değişimler üretir. Diğer interpolasyon stilleri farklı hareket özellikleri oluşturabilir ve ek anahtar kare ayarları gerektirebilir. İnterpolasyon modunu değiştirmeden önce animasyon API referansı inceleyin.

Animasyon değerlendirmesini sahne animasyonundan ayırın. Kod yalnızca sayısal bir eğriyi değerlendirir. Bir sahne düğümünün X konumunu güncellemez veya işlenmiş bir animasyon oluşturmaz. 3D bir nesneyi hareket ettirmek için, dizi bir sahnedeki uygun bir animasyonlu özelliğe bağlanmalıdır.

GPU renderleme gerekli değildir. Scene.render() çağrısı veya bir renderleme arka ucu yapılmaz. Bu, örneği Vulkan uyumlu bir GPU’su olmayan makinelerde animasyon değerleriyle çalışmak için uygun hale getirir.

Ücretsiz Geçici Lisans Al

Aspose.3D for Python via .NET’ı değerlendirmek için 30 günlük ücretsiz geçici lisans isteyin. Deneme sınırlamaları olmadan. Lisansı uygulamak için Aspose.3D lisanslama kılavuzunu izleyin.

Ücretsiz Öğrenme Kaynakları

Python’da 3D animasyon ve dosya işleme iş akışlarıyla çalışmaya devam etmek için bu kaynakları keşfedin:

Sonuç

KeyframeSequence.evaluate() metodunu Aspose.3D for Python via .NET içinde kullanarak bir modeli render etmeden belirli zamanlarda animasyon değerlerini hesaplayabilirsiniz. Bu örnekte, üç anahtar kare X‑konumu eğrisini tanımlar, değerlendirici ara konumları hesaplar ve CSV’ye dışa aktarır. Örneği uyarlamak için anahtar kare değerlerini veya örnekleme aralığını değiştirin. Model düzeyinde animasyon için bir sonraki adım, animasyon eğrilerini sahne özelliklerine bağlamak ve nesnelere uygulamaktır.

Devamını Oku