האנימציות של keyframe מגדירות כיצד ערך משתנה עם הזמן. לדוגמה, ניתן לציין היכן צריך להיות האובייקט בתחילת האנימציה והיכן עליו לזוז לאחר מכן, ואז לחשב את מיקומו בכל נקודה בין אותם keyframes. זה שימושי לבחינת עקומות תנועה, בדיקת תזמון האנימציה וייצוא ערכים מדגמים לניתוח נוסף. Aspose.3D for Python via .NET מאפשרת לדגום רצף keyframe בזמן מסוים ללא רינדור סצנה תלת‑ממדית. במדריך זה, תיצור אנימציית מיקום פשוטה, תעריך את הערכים הממשיכים כל חצי שנייה, ותשמור את התוצאות בקובץ 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.

יצירת והערכת אנימציית keyframe ב-Python

הדוגמה ממדדת את המיקום בציר X של אובייקט. המיקום מתחיל ב‑0, מגיע ל‑10 יחידות אחרי שתי שניות, וחוזר ל‑0 אחרי חמש שניות.

זמן (שניות)מיקום Xפעולה
00התחלה
210הגעה למיקום המקסימלי
50חזרה להתחלה

הערכים בין מסגרות המפתח האלה מחושבים באמצעות אינטרפולציה לינארית. הדוגמה יוצרת עקומת אנימציה מספרית עצמאית; היא אינה מחברת את הרצף לאובייקט סצנה ממשי.

דוגמת קוד Python מלאה

הסקריפט הבא יוצר KeyframeSequence, מוסיף שלושה keyframes, מעריך אחת עשרה חותמות זמן, מאמת את ערכי ה‑keyframe, ומייצא את התוצאות ל‑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

המחלקה KeyframeSequence מייצגת עקומה מספרית עם ערכים המוגדרים בזמנים ספציפיים. שורה זו יוצרת רצף בשם PositionX:

sequence = KeyframeSequence("PositionX")

השם מסייע בזיהוי הרצף. הוא אינו קשור אוטומטית את הרצף למשטח או למאפיין של צומת. לפרטים, ראה את הפנייה ל‑API של KeyframeSequence.

הוספת keyframes עם אינטרפולציה ליניארית

כל קריאה ל‑add() מספקת חותמת זמן, ערך וסוג אינטרפולציה:

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 הוא חותמת הזמן המבוקשת, t0 ו-t1 הם זמני מסגרות המפתח הסובבות, ו-v0 ו-v1 הם הערכים המתאימים שלהם.

בין שני קי‑פריימים הראשונים, הערכה ב‑1.5 שניות נותנת:

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

אינך צריך לממש נוסחה זו בעצמך. KeyframeSequence.evaluate() מבצע את החישוב בהתאם להגדרות האינטרפולציה של הרצף.

בדוק את הערכים שהוערכו

למסגרות המפתח לדוגמה, הפלט הוא:

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 בודקות את הערכים בשלוש נקודות זמן של keyframe שהוגדרו. הן משתמשות בסובלנות קטנה במקום שוויון ישיר של נקודות צפה.

הערכים המשתנים בין מסגרות המפתח מאשרים שהרצף נמדד לאורך טווח הזמן שלו.

ייצא ערכי keyframe ל-CSV

לאחר הערכת הרצף, הסקריפט כותב את הזמן ואת המיקום X המחושב לקובץ keyframe_animation.csv באמצעות מודול csv של פייתון. הקובץ מתחיל ב:

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 זה באפליקציית גיליון אלקטרוני, לשרטט את עקומת התנועה שהתקבלה, או לקרוא אותו חזרה לפייתון לניתוח. כדי לקבל תוצאות מדויקות יותר, הפחת את step מ-0.5 למרווח קטן יותר והתאם את טווח הזמן הרצוי.

שיקולים מעשיים

דוגמה רק בטווח הזמן המיועד. מדריך זה מעריך זמנים מ‑0 עד 5 שניות. ערכים מחוץ למסגרות המפתח המוגדרות נשלטים על‑ידי התנהגות קדם‑ו‑אחרי‑הרחבה, שהיא נפרדת מהאינטרפולציה בין מסגרות המפתח.

בחר אינטרפולציה בכוונה. אינטרפולציה ליניארית מייצרת שינויים קבועים בתוך כל קטע. סגנונות אינטרפולציה אחרים יכולים ליצור מאפייני תנועה שונים ועלולים לדרוש הגדרות מסגרות מפתח נוספות. עיין ב-הפניה ל‑API של האנימציה לפני שינוי מצב האינטרפולציה.

הבחין בין הערכת אנימציה לאנימציית סצנה. הקוד מעריך רק עקומה מספרית. הוא אינו מעדכן את מיקום ה‑X של צומת סצנה או יוצר אנימציה מרונדרת. כדי להזיז אובייקט תלת‑ממדי, על הרצף להיות מחובר לתכונה מונפשת מתאימה בסצנה.

אין צורך ברינדור GPU. לא מתבצעת קריאה ל-Scene.render() או למנוע רינדור. זה הופך את הדוגמה למתאימה לעבודה עם ערכי אנימציה במחשבים שאין בהם GPU תואם Vulkan.

קבל רישיון זמני חינמי

אתה יכול בקש רישיון זמני חינם ל‑30 יום כדי להעריך את Aspose.3D for Python via .NET ללא מגבלות גרסת ניסיון. עקוב אחרי מדריך הרישוי של Aspose.3D כדי להחיל את הרישיון על היישום שלך.

משאבי למידה חינמיים

חקור את המשאבים האלה כדי להמשיך לעבוד עם אנימציה תלת‑ממדית ותהליכי עיבוד קבצים ב‑Python:

סיכום

אתה יכול להשתמש ב-KeyframeSequence.evaluate() ב‑Aspose.3D for Python via .NET כדי לחשב ערכי אנימציה בזמנים ספציפיים מבלי לבצע רינדור של מודל. בדוגמה זו, שלושה keyframes מגדירים עקומת מיקום בציר X, בעוד שה‑evaluator מחשב מיקומים ביניים ומייצא אותם ל‑CSV. כדי להתאים את הדוגמה, שנה את ערכי ה‑keyframe או את מרווח הדגימה. עבור אנימציה ברמת מודל, הצעד הבא הוא לקשר את עקומות האנימציה למאפייני הסצנה וליישם אותן על האובייקטים.

קרא עוד