funimage - מקוון בענן

תָכְנִית:

שֵׁם

funimage - צור תמונת FITS מקובץ נתונים של Funtools

תַקצִיר

תמונה כיף [-א] [bitpix=n] תמונה כיף [-l]
[bitpix=n] תמונה כיף [-px⎪y] [bitpix=n]

אפשרויות

-הוספה # לקובץ הפלט הקיים בתור סיומת תמונה
-l # קלט הוא קובץ רשימה המכיל xcol, ycol, value
-p [x⎪y] # הקרן לאורך ציר x או y כדי ליצור תמונה 1D

תיאור

תמונה כיף יוצר תמונת FITS ראשית מהרחבה ו/או תמונה של FITS שצוינו
קטע של קובץ FITS, או מקטע תמונה של מערך שאינו FITS, או מאירוע גולמי
קובץ.

הארגומנט הראשון לתוכנית מציין את תמונת הקלט, המערך או קובץ האירוע הגולמי של FITS
לעבד. אם מצוין "stdin", הנתונים נקראים מהקלט הסטנדרטי. השתמש ב- Funtools
סימון סוגריים לציון הרחבות FITS, קטעי תמונה ומסננים. השני
הארגומנט הוא קובץ הפלט FITS. אם מצוין "stdout", תמונת FITS נכתבת
הפלט הסטנדרטי. כברירת מחדל, ערכי פיקסל הפלט הם מאותו סוג נתונים כמו
אלה של קובץ הקלט (או הקלד "int" בעת שילוב טבלה), אך ניתן לעקוף זאת
באמצעות ארגומנט שלישי אופציונלי של הטופס:

bitpix=n

כאשר n הוא 8,16,32,-32,-64, עבור char ללא סימן, קצר, int, float וכפול, בהתאמה.

אם נתוני הקלט הם מסוג תמונה, הקטע המתאים נשלף ונחסם
(בהתבסס על אופן ההגדרה של מדור התמונה), והתוצאה נכתבת ל-FITS
תמונה ראשית. כאשר תמונה שלמה המכילה את מילות המפתח BSCALE ו-BZERO היא
הומר לצוף, ערכי הפיקסלים מותאמים ומילות המפתח לשינוי קנה מידה נמחקים מ
כותרת הפלט. בעת המרת נתונים בקנה מידה של מספר שלם למספר שלם (ייתכן של שונה
גודל), הפיקסלים אינם מותאמים ומילות המפתח לשינוי קנה מידה נשמרות.

אם נתוני הקלט הם טבלה בינארית או קובץ אירוע גולמי, אלה נקלטים בתמונה,
שממנו מחלצים וחוסמים קטע, ונכתב לתמונת FITS ראשית. ב
במקרה זה, יש צורך לציין את שתי העמודות שישמשו ב-2D binning.
ניתן לעשות זאת בשורת הפקודה באמצעות ה- bincols=(x,y) מילת מפתח:

funcnts "foo.ev[EVENTS,bincols=(detx,dety)]"

הצורה המלאה של ה bincols= המפרט הוא:

bincols=([xname[:tlmin[:tlmax:[binsiz]]]],[yname[:tlmin[:tlmax[:binsiz]]]])

כאשר מפרטי tlmin, tlmax ו-binsiz קובעים את ממדי שילוב התמונה:

dim = (tlmax - tlmin)/binsiz (נתוני נקודה צפה)
dim = (tlmax - tlmin)/binsiz + 1 (נתונים שלמים)

באמצעות תחביר זה, ניתן לאחסן כל שתי עמודות של טבלה בינארית בכל סל
גודל. שימו לב שניתן להשמיט את מפרטי tlmin, tlmax ו-binsiz אם TLMIN, TLMAX,
ופרמטרי כותרת TDBIN (בהתאמה) קיימים בכותרת הטבלה הבינארית FITS עבור
העמוד המדובר. שימו לב גם שאם צוין פרמטר אחד בלבד, ההנחה היא
להיות tlmax, ו-tlmin ברירת המחדל היא 1. אם צוינו שני פרמטרים, ההנחה היא שהם
להיות tlmin ו-tlmax. ראה טבלאות בינאריות של FITS Binning וקבצי אירועים שאינם FITS למידע נוסף
מידע על פרמטרי binning.

כברירת מחדל, נוצר קובץ תמונה חדש 2D FITS והתמונה נכתבת לראשי
HDU. אם ה -a (הוספה) צוין מתג, התמונה מצורפת ל-FITS קיים
הקובץ בתור סיומת IMAGE. (אם קובץ הפלט אינו קיים, המתג הוא למעשה
התעלמו והתמונה נכתבת ל-HDU הראשי.) זה יכול להיות שימושי במעטפת
סביבת תכנות בעת עיבוד תמונות FITS מרובות שברצונך לשלב אליהן
קובץ FITS סופי בודד.

תמונה כיף יכול גם לקבל קלט מטבלה המכילה עמודות של x, y וערך (למשל, ה
פלט מ fundisp -l שמציגה כל תמונה x ו-y ואת מספר הספירות
עמדה.) כאשר -l נעשה שימוש במתג (רשימה), קובץ הקלט נחשב כ-FITS או
טבלת ASCII המכילה (לפחות) שלוש עמודות המציינות את קואורדינטות התמונה x ו-y
והערך של אותו פיקסל תמונה. במקרה הזה, תמונה כיף דורש ארבעה טיעונים נוספים:
xcolumn:xdims, ycolumn:ydims, vcolumn ו-bitpix=n. המידע x ו-y col:dim לוקח
הצורה:

name:dim # ערכים נעים בין 1 לעמעום
name:min:max # ערכים נעים בין המינימום למקסימום
name:min:max:binsiz # מידות בקנה מידה לפי binsize

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

funimage -l foo.lst foo.fits xcol:0:512 ycol:0:512 ערך bitpix=-32

ניתן להשתמש בתכונת הרשימה גם לקריאת עמודות ללא שם מקלט רגיל: פשוט
החלף את שם העמודה במחרוזת null. שים לב שמידע הממדים עדיין עדיין
נדרש:

funimage -l stdin foo.fits "":0:512 "":0:512 "" bitpix=-32
240 250 1
255 256 2
...
^D

תכונת הרשימה מספקת דרך פשוטה ליצור תמונה ריקה. אם אתה עובר טור-
קובץ טקסט מבוסס ל-funimage שבו כותרת הטקסט מכילה את התמונה הנדרשת
מידע, אז funimage ייצור בצורה נכונה תמונה ריקה. לדוגמה, שקול את
קובץ הטקסט הבא (נקרא foo.txt):

x:I:1:10 y:I:1:10
------ ------
0 0

קובץ טקסט זה מגדיר שתי עמודות, x ו-y, כל אחת מסוג נתונים 32-bit int ותמונה
ממד 10. הפקודה:

funimage foo.txt foo.fits bitpix=8

תיצור תמונת FITS ריקה בשם foo.fits המכילה תמונה בגודל 10x10 של char unsigned:

fundisp foo.fits
1 2 3 4 5 6 7 8 9 10
------ ------ ------ ------ ------ ------ ------ ------ -- ---- ------
10: 0 0 0 0 0 0 0 0 0 0
9: 0 0 0 0 0 0 0 0 0 0
8: 0 0 0 0 0 0 0 0 0 0
7: 0 0 0 0 0 0 0 0 0 0
6: 0 0 0 0 0 0 0 0 0 0
5: 0 0 0 0 0 0 0 0 0 0
4: 0 0 0 0 0 0 0 0 0 0
3: 0 0 0 0 0 0 0 0 0 0
2: 0 0 0 0 0 0 0 0 0 0
1: 1 0 0 0 0 0 0 0 0 0

שימו לב שקובץ הטקסט חייב להכיל לפחות שורה אחת של נתונים. עם זאת, בהווה
לדוגמה, מיקום האירוע 0,0 הוא מחוץ לגבולות התמונה ויתעלם ממנו. (אתה
יכול, כמובן, להשתמש בערכי x, y אמיתיים כדי לראות את התמונה עם נתונים.)

יתר על כן, אתה יכול להשתמש במפרט מסנן TEXT כדי למנוע את הצורך בקלט
קובץ טקסט לגמרי. הפקודה הבאה תיצור את אותה תמונת תווים בגודל 10x10 ללא
קובץ קלט בפועל:

funimage stdin'[TEXT(x:I:10,y:I:10)]' foo.fits bitpix=8 < /dev/null
or
funimage /dev/null'[TEXT(x:I:10,y:I:10)]' foo.fits bitpix=8

אתה גם יכול להשתמש באחת מהשיטות הללו כדי ליצור מסכת אזור פשוט על ידי הוספת א
אזור בתוך סוגריים של המסנן וציון מסכה = הכל יחד עם הביטפיקס. ל
לדוגמה, הפקודה הבאה תיצור מסכת תווים בגודל 10x10 באמצעות 3 אזורים:

funimage stdin'[TEXT(x:I:10,y:I:10),cir(5,5,4),point(10,1),-cir(5,5,2)]' \
foo.fits bitpix=8,mask=all < /dev/null

המסכה שהתקבלה נראית כך:

fundisp foo.fits
1 2 3 4 5 6 7 8 9 10
------ ------ ------ ------ ------ ------ ------ ------ -- ---- ------
10: 0 0 0 0 0 0 0 0 0 0
9: 0 0 0 0 0 0 0 0 0 0
8: 0 0 1 1 1 1 1 0 0 0
7: 0 1 1 1 1 1 1 1 0 0
6: 0 1 1 0 0 0 1 1 0 0
5: 0 1 1 0 0 0 1 1 0 0
4: 0 1 1 0 0 0 1 1 0 0
3: 0 1 1 1 1 1 1 1 0 0
2: 0 0 1 1 1 1 1 0 0 0
1: 0 0 0 0 0 0 0 0 0 2

אתה יכול להשתמש תמונה כיף כדי ליצור הקרנות תמונה 1D לאורך ציר x או y באמצעות -p
[x⎪y] החלף. יכולת זו פועלת הן עבור תמונות והן עבור טבלאות. למשל קחו בחשבון את א
טבלת FITS בשם ev.fits המכילה את השורות הבאות:

XY
------------------------
1 1
1 2
1 3
1 4
1 5
2 2
2 3
2 4
2 5
3 3
3 4
3 5
4 4
4 5
5 5

תמונה מתאימה בגודל 5x5, הנקראת dim2.fits, תכיל אפוא:

1 2 3 4 5
---------- ---------- ---------- ---------- ----------
5: 1 1 1 1
4: 1 1 1 1
3: 1 1 1 0
2: 1 1 0 0
1: 1 0 0 0

ניתן לבצע הקרנה לאורך ציר y על הטבלה או על התמונה:

funimage -py ev.fits stdout ⎪ fundisp stdin
1 2 3 4 5
---------- ---------- ---------- ---------- ----------
1: 1 2 3 4

funimage -py dim2.fits stdout ⎪ fundisp stdin
1 2 3 4 5
---------- ---------- ---------- ---------- ----------
1: 1 2 3 4

יתרה מזאת, אתה יכול ליצור הקרנת תמונה 1D לאורך כל עמודה בטבלה באמצעות ה
bincols=[עמודה] מפרט מסנן וציון עמודה בודדת. לדוגמה, ה
הפקודה הבאה מקרינה את אותה תמונה 1D לאורך ציר ה-y של טבלה כמו שימוש ב- -p
y לעבור:

funimage ev.fits'[bincols=y]' stdout ⎪ fundisp stdin
1 2 3 4 5
---------- ---------- ---------- ---------- ----------
1: 1 2 3 4

דוגמאות:

צור תמונת FITS מטבלה בינארית FITS:

[ש] funimage test.ev test.fits

הצג את תמונת FITS שנוצרה מקטע חסום בטבלה בינארית FITS:

[sh] funimage "test.ev[2:8,3:7,2]" stdout ⎪ fundisp stdin
1 2 3
---------- ---------- ----------
1: 20 28 36
2: 28 36 44

השתמש ב-funimage באינטרנט באמצעות שירותי onworks.net