6.3. יצירת מערכים

כל דוגמה בשאר העמודים האלה מתחילה עם ndarray שכבר נמצא בידינו. עמוד זה הוא הקטלוג של איך מערך זה נוצר. יש ארבע משפחות של בנאים:

  • מתוך איטרבל של Python – הצורה הרגילה של ליטרל / רשימה / tuple.

  • מלא מראש בצורה נתונה – אפסים, אחדים, ערך קבוע, מטריצת יחידה.

  • מיוצר כסדרה – ערכים בטווח או במרווח אחיד.

  • עטיפת חוצץ שכבר נמצא ב-RAM – מקרה ההתקן ההיקפי.

כל בנאי מקבל מילת מפתח dtype= ובברירת מחדל הוא float. נתוני חיישן כמעט תמיד רוצים dtype קטן יותר מברירת המחדל.

כל דוגמה למטה מתחילה ב:

from ulab import numpy as np

6.3.1. מתוך איטרבל של Python

array() בונה ndarray מכל איטרבל של מספרים:

a = np.array([1, 2, 3, 4])
print(a)

פלט:

array([1.0, 2.0, 3.0, 4.0], dtype=float)

איטרבלים מקוננים מפיקים מערכים רב-ממדיים. כל האיטרבלים הפנימיים חייבים להיות באותו אורך, אחרת מורמת ValueError

m = np.array([[1, 2, 3],
              [4, 5, 6]], dtype=np.uint8)

גם ndarray קיים הוא קלט תקף; array() תמיד מעתיק. כדי להימנע מההעתקה כאשר אין בה צורך, השתמש ב-asarray()

b = np.asarray(a, dtype=np.float)   # same dtype -> no copy

6.3.2. מלא מראש בצורה נתונה

כאשר הצורה הסופית ידועה אך התוכן עדיין לא, הקצה את החוצץ מראש וכתוב לתוכו מאוחר יותר:

  • zeros() – מלא באפסים.

  • ones() – מלא באחדים.

  • full() – מלא בערך נתון.

  • empty() – כינוי ל-zeros() (ulab אינו משאיר את החוצץ לא מאותחל).

  • eye() – מטריצת N-על-M דמוית יחידה עם אחדים באלכסון ה-k.

  • diag() – מטריצה אלכסונית מתוך וקטור, או האלכסון של מטריצה.

np.zeros((3, 3))                   # 3x3 of zeros
np.ones(5, dtype=np.uint8)         # length-5 vector of ones
np.full((2, 3), 7, dtype=np.int8)  # 2x3, all 7
np.eye(4)                          # 4x4 identity
np.diag([1, 2, 3])                 # 3x3, [1, 2, 3] on the diagonal

הארגומנט shape הוא מספר שלם בודד (עבור מערך חד-ממדי) או tuple.

6.3.3. מיוצר כסדרה

  • arange() – ערכים במרווח אחיד כמו range() המובנה, אך תמיד מחזיר ndarray

    np.arange(0, 10, 2)            # array([0, 2, 4, 6, 8])

  • linspace() – num נקודות במרווח אחיד בין שני גבולות, כשהגבול העליון נכלל כאשר endpoint=True

    np.linspace(0, 1, num=11)      # 0.0, 0.1, ..., 1.0

  • logspace() – נקודות במרווח גאומטרי. start ו-stop הם מעריכים, לא נקודות קצה; התוצאה נמתחת מ-base ** start עד base ** stop

    np.logspace(0, 3, num=4)       # 1.0, 10.0, 100.0, 1000.0

  • meshgrid() – בונה שתי מטריצות קואורדינטות משני מערכים חד-ממדיים כך שפונקציה לכל פיקסל f(x, y) ניתנת להערכה על פני רשת שלמה בקריאה ווקטורית אחת. בהינתן וקטור x באורך W ווקטור y באורך H, meshgrid מחזיר שתי מטריצות H-על-W: X הוא וקטור ה-x החוזר בכל שורה כלפי מטה, Y הוא וקטור ה-y החוזר על פני כל עמודה, כך ש-X[i, j] הוא קואורדינטת ה-x ו-Y[i, j] הוא קואורדינטת ה-y של התא בשורה i ובעמודה j

    x = np.arange(4)            # [0, 1, 2, 3]
y = np.arange(3)            # [0, 1, 2]
X, Y = np.meshgrid(x, y)
# X = [[0, 1, 2, 3],
#      [0, 1, 2, 3],
#      [0, 1, 2, 3]]
# Y = [[0, 0, 0, 0],
#      [1, 1, 1, 1],
#      [2, 2, 2, 2]]

    f(X, Y) אז מעריך את הפונקציה בכל תא של הרשת בביטוי אחד. מפת מרחק-מהמרכז על פני פריים (H, W), למשל, היא np.sqrt((X - cx)**2 + (Y - cy)**2) כנגד המטריצות ש-meshgrid() החזיר.

6.3.4. חיבור

concatenate() מחבר tuple של מערכים לאורך ציר קיים:

a = np.array([[1, 2], [3, 4]], dtype=np.uint8)
b = np.array([[5, 6]],         dtype=np.uint8)
np.concatenate((a, b), axis=0)
# array([[1, 2], [3, 4], [5, 6]], dtype=uint8)

כל הקלטים חייבים לחלוק את אותו dtype ו-ndim, ולהתאים בכל ציר מלבד זה של החיבור. concatenate() מקצה מערך חדש גדול דיו להכיל את כל הקלטים ומעתיק את הנתונים פנימה, ולכן הוא הכלי הנכון לחיבור חד-פעמי של מערכים שכבר קיימים; הוא הכלי הלא נכון בתוך לולאת זרימה, שבה הקצאת היעד מראש פעם אחת וכתיבה לתוכו דרך השמה לפי פרוסה הם הדפוס.

6.3.5. עטיפת חוצץ קיים

הבנאי השימושי ביותר על מצלמה הוא frombuffer(). הוא מפרש מחדש חוצץ קיים מסוג בתים בתור ndarray חד-ממדי ללא העתקת בית אחד:

buf = bytearray(8)
audio = np.frombuffer(buf, dtype=np.int16)
# 4 int16 samples, sharing memory with buf

כתיבות דרך audio נראות ב-buf ולהפך. ה-dtype הנבחר חייב לחלק את אורך החוצץ בשלמות.

offset= מדלג על כותרת בתחילת החוצץ; count= מגביל כמה איברים נקראים:

np.frombuffer(buf, dtype=np.uint8, offset=2, count=4)

זהו הבנאי הנכון בכל פעם שהתקן היקפי מוסר ליישום חוצץ גולמי – דגימות ADC ב-bytearray, מטען נתונים שנמשך מ-SPI. הבתים שההתקן ההיקפי כתב הם המערך.

כאשר התקן היקפי כותב ערכים רבי-בתים בסדר בתים שה-CPU של המצלמה אינו קורא באופן טבעי, byteswap() הופך את סדר הבתים של כל איבר כך שהערכים נקראים נכון. הוא מחזיר מערך חדש כברירת מחדל; העברת inplace=True משנה את המקור במקום.

frombuffer() מטפל רק ב-dtypes ש-numpy עצמו מגדיר. עבור התקנים היקפיים המפיקים דגימות שלמים בנות 32 סיביות, from_int32_buffer() וחבריו ממירים ל-float במעבר אחד.