การทำแอนิเมชันแบบคีย์เฟรมกำหนดว่าค่าหนึ่งเปลี่ยนแปลงอย่างไรตามเวลา ตัวอย่างเช่น คุณสามารถระบุตำแหน่งที่วัตถุควรอยู่ในจุดเริ่มต้นของแอนิเมชันและตำแหน่งที่มันควรเคลื่อนต่อไป แล้วคำนวณตำแหน่งของมันในจุดใดก็ได้ระหว่างคีย์เฟรมเหล่านั้น สิ่งนี้มีประโยชน์สำหรับการตรวจสอบโค้งการเคลื่อนที่ การตรวจสอบเวลาแอนิเมชัน และการส่งออกค่าที่สุ่มตัวอย่างเพื่อการวิเคราะห์ต่อไป Aspose.3D for Python via .NET ทำให้คุณสามารถสุ่มตัวอย่างลำดับคีย์เฟรมในช่วงเวลาที่กำหนดโดยไม่ต้องเรนเดอร์ฉาก 3D ในบทเรียนนี้ คุณจะสร้างแอนิเมชันตำแหน่งแบบง่าย ประเมินค่าที่ผ่านการอินเตอร์โพเลตทุกครึ่งวินาที และบันทึกผลลัพธ์ลงในไฟล์ CSV.
ติดตั้ง Aspose.3D for Python
ติดตั้ง Aspose.3D for Python via .NET เวอร์ชัน 26.10 โดยใช้ pip:
pip install aspose-3d==26.10.0
ตัวอย่างนี้ใช้เฉพาะโมดูล aspose.threed.animation และโมดูล csv ที่มาพร้อมกับ Python เท่านั้น คุณไม่จำเป็นต้องมีไฟล์ GLB/GLTF หรือกราฟิกการ์ดที่รองรับ Vulkan เนื่องจากโค้ดทำการคำนวณแอนิเมชันแทนการเรนเดอร์ภาพ.
สำหรับข้อมูลแพลตฟอร์มและการติดตั้ง ให้ดูเอกสาร Aspose.3D for Python documentation.
สร้างและประเมินการเคลื่อนไหวแบบคีย์เฟรมใน Python
ตัวอย่างนี้จำลองตำแหน่ง X ของวัตถุ ตำแหน่งเริ่มที่ 0, เพิ่มขึ้นเป็น 10 หน่วยหลังจากสองวินาที, และกลับไปที่ 0 หลังจากห้าวินาที.
| เวลา (วินาที) | ตำแหน่ง X | การกระทำ |
|---|---|---|
| 0 | 0 | เริ่มต้น |
| 2 | 10 | ถึงตำแหน่งสูงสุด |
| 5 | 0 | กลับสู่จุดเริ่มต้น |
ค่าระหว่างคีย์เฟรมเหล่านี้ถูกคำนวณโดยใช้ การอินเทอร์โพเลชันเชิงเส้น. ตัวอย่างสร้างโค้งแอนิเมชันเชิงตัวเลขแบบสแตนด์อโลน; ไม่ได้แนบลำดับนี้กับอ็อบเจกต์ฉากจริง.
ตัวอย่างโค้ด Python แบบสมบูรณ์
สคริปต์ต่อไปนี้สร้าง KeyframeSequence เพิ่มคีย์เฟรมสามคีย์เฟรม ประเมินเวลา timestamp สิบหนึ่งค่า ตรวจสอบค่าคีย์เฟรม และส่งออกผลลัพธ์ไปยัง 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.")
ทำความเข้าใจวิธีการประเมินค่า keyframe
กำหนดลำดับของ keyframe
คลาส KeyframeSequence แสดงถึงโค้งเชิงตัวเลขที่มีค่าที่กำหนดในช่วงเวลาที่เฉพาะเจาะจง บรรทัดนี้สร้างลำดับที่ชื่อ PositionX:
sequence = KeyframeSequence("PositionX")
ชื่อช่วยระบุลำดับ ไม่ได้ทำการผูกลำดับกับเมชหรือคุณสมบัติโหนดโดยอัตโนมัติ สำหรับรายละเอียดเพิ่มเติม ดูที่ KeyframeSequence API reference.
เพิ่มคีย์เฟรมด้วยการแทรกเชิงเส้น
แต่ละครั้งที่เรียก add() จะระบุ timestamp, ค่า value, และประเภทของการอินเทอร์โพเลชัน:
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 บอกให้ลำดับคำนวณค่ากลางอย่างสัดส่วนระหว่างคีย์เฟรม ผลลัพธ์คือค่าจะเพิ่มอย่างต่อเนื่องจาก 0 ถึง 10 ในช่วงสองวินาทีแรกและลดลงอย่างต่อเนื่องจาก 10 ถึง 0 ในช่วงสามวินาทีถัดไป.
คำนวณค่าที่เวลาประทับ
การดำเนินการหลักคือ:
value = sequence.evaluate(1.5)
สำหรับตัวอย่างนี้ ผลลัพธ์ที่คาดหวังที่ 1.5 วินาทีคือ 7.5. การประมาณค่าเชิงเส้นตามสูตรต่อไปนี้:
[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]
ที่นี่, t คือ timestamp ที่ร้องขอ, t0 และ t1 คือเวลาของ keyframe ที่ล้อมรอบ, และ v0 และ v1 คือค่าที่สอดคล้องกันของพวกมัน.
ระหว่างสองคีย์เฟรมแรก การประเมินค่าในเวลา 1.5 วินาทีให้ผลลัพธ์เป็น:
[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]
คุณไม่จำเป็นต้องทำสูตรนี้ด้วยตนเอง KeyframeSequence.evaluate() ทำการคำนวณตามการตั้งค่าการอินเทอร์โพเลชันของลำดับ
ตรวจสอบค่าที่ประเมิน
สำหรับ keyframes ตัวอย่าง ผลลัพธ์คือ:
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 ตรวจสอบค่าที่ timestamp ของ keyframe ที่กำหนดไว้สามค่า. พวกเขาใช้ความคลาดเคลื่อนเล็กน้อยแทนการเปรียบเทียบ floating-point อย่างตรงไปตรงมา.
ค่าที่เปลี่ยนแปลงระหว่างคีย์เฟรมยืนยันว่าลำดับกำลังถูกสุ่มตัวอย่างตลอดช่วงเวลาของมัน.
ส่งออกค่าคีย์เฟรมเป็น CSV
หลังจากประเมินลำดับแล้ว สคริปต์จะเขียนเวลาและตำแหน่ง X ที่คำนวณได้ลงใน keyframe_animation.csv โดยใช้โมดูล csv ของ Python ไฟล์จะเริ่มต้นด้วย:
Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0
คุณสามารถเปิดไฟล์ CSV นี้ในแอปพลิเคชันสเปรดชีต, วาดกราฟเคลื่อนที่ที่ได้, หรืออ่านกลับเข้า Python เพื่อวิเคราะห์ได้. เพื่อให้ได้ผลลัพธ์ที่ละเอียดมากขึ้น, ลด step จาก 0.5 เป็นช่วงเวลาที่เล็กลงและปรับช่วงเวลาที่ต้องการ.
ข้อควรพิจารณาเชิงปฏิบัติ
ตัวอย่างเฉพาะในช่วงเวลาที่ตั้งใจ บทแนะนำนี้ประเมินเวลา ตั้งแต่ 0 ถึง 5 วินาที. ค่าที่อยู่นอกกรอบคีย์ที่กำหนดจะถูกควบคุมโดยพฤติกรรมการขยายล่วงหน้าและหลัง ซึ่งแยกจากการแทรกค่าระหว่างกรอบคีย์.
เลือกการแทรกค่าตามความตั้งใจ การแทรกค่าตามเส้นตรงทำให้เกิดการเปลี่ยนแปลงคงที่ในแต่ละส่วน การแทรกค่าแบบอื่นอาจสร้างลักษณะการเคลื่อนที่ที่แตกต่างและอาจต้องการการตั้งค่า keyframe เพิ่มเติม ดูที่ อ้างอิง API การเคลื่อนไหว ก่อนเปลี่ยนโหมดการแทรกค่า
แยกการประเมินค่าแอนิเมชันจากแอนิเมชันของฉาก. โค้ดจะประเมินเส้นโค้งเชิงตัวเลขเท่านั้น. มันไม่ได้อัปเดตตำแหน่ง X ของโหนดในฉากหรือสร้างแอนิเมชันที่เรนเดอร์. เพื่อย้ายวัตถุ 3 มิติ ลำดับต้องเชื่อมต่อกับคุณสมบัติที่ทำแอนิเมชันที่เหมาะสมในฉาก.
ไม่จำเป็นต้องเรนเดอร์ด้วย GPU ไม่มีการเรียก Scene.render() หรือ backend การเรนเดอร์ใด ๆ นี้ทำให้ตัวอย่างนี้เหมาะสำหรับการทำงานกับค่าการเคลื่อนไหวบนเครื่องที่ไม่มี GPU ที่รองรับ Vulkan.
รับใบอนุญาตชั่วคราวฟรี
คุณสามารถ ขอรับใบอนุญาตชั่วคราวฟรี 30 วัน เพื่อประเมิน Aspose.3D for Python via .NET โดยไม่มีข้อจำกัดของรุ่นทดลอง. ทำตาม คู่มือการให้ใบอนุญาต Aspose.3D เพื่อใช้ใบอนุญาตในแอปพลิเคชันของคุณ.
แหล่งเรียนรู้ฟรี
สำรวจแหล่งข้อมูลเหล่านี้เพื่อดำเนินการทำงานกับการสร้างแอนิเมชัน 3D และกระบวนการประมวลผลไฟล์ใน Python:
- Aspose.3D for Python Developer Guide – เอกสารสำหรับการโหลด, การสร้างและการประมวลผลฉาก 3D.
- Aspose.3D Animation API Reference – คลาสสำหรับคีย์เฟรม, การแทรกค่า, คลิปแอนิเมชัน, และการผูกคุณสมบัติ.
- Free Online 3D Applications – เครื่องมือแบบเบราว์เซอร์สำหรับงานไฟล์ 3D ที่รองรับ.
- Aspose.3D Tutorials and Articles – ตัวอย่างเชิงปฏิบัติเพิ่มเติมสำหรับการทำงานกับรูปแบบ 3D.
สรุป
คุณสามารถใช้ KeyframeSequence.evaluate() ใน Aspose.3D for Python via .NET เพื่อคำนวณค่าการเคลื่อนไหวในช่วงเวลาที่กำหนดโดยไม่ต้องเรนเดอร์โมเดล ในตัวอย่างนี้ กรอบคีย์สามกรอบกำหนดโค้งตำแหน่ง X ในขณะที่ตัวประเมินคำนวณตำแหน่งกลางและส่งออกเป็น CSV เพื่อปรับตัวอย่าง ให้เปลี่ยนค่ากรอบคีย์หรือช่วงการสุ่มตัวอย่าง สำหรับการเคลื่อนไหวระดับโมเดล ขั้นตอนต่อไปคือผูกโค้งการเคลื่อนไหวกับคุณสมบัติของฉากและนำไปใช้กับวัตถุ