funimage - Online sa Cloud

PROGRAMA:

NAME

funimage - lumikha ng isang FITS na imahe mula sa isang file ng data ng Funtools

SINOPSIS

funimage [-a] [bitpix=n] funimage [-l]
[bitpix=n] funimage [-px⎪y] [bitpix=n]

Opsyon

-a # idagdag sa umiiral na output file bilang extension ng imahe
-l # input ay isang listahan ng file na naglalaman ng xcol, ycol, halaga
-p [x⎪y] # proyekto kasama ang x o y axis upang lumikha ng 1D na imahe

DESCRIPTION

funimage lumilikha ng pangunahing FITS na imahe mula sa tinukoy na FITS Extension at/o Image
Seksyon ng FITS file, o mula sa Image Section ng non-FITS array, o mula sa isang raw na kaganapan
file.

Ang unang argumento sa programa ay tumutukoy sa FITS input na imahe, array, o raw na file ng kaganapan
para mai-proseso. Kung tinukoy ang "stdin", babasahin ang data mula sa karaniwang input. Gumamit ng Funtools
Bracket Notation upang tukuyin ang mga FITS extension, mga seksyon ng imahe, at mga filter. Ang ikalawa
argument ay ang output FITS file. Kung ang "stdout" ay tinukoy, ang FITS na imahe ay nakasulat sa
ang karaniwang output. Bilang default, ang mga halaga ng output pixel ay kapareho ng uri ng data
ang sa input file (o i-type ang "int" kapag binning ang isang table), ngunit maaari itong ma-override
gamit ang isang opsyonal na ikatlong argumento ng form:

bitpix=n

kung saan ang n ay 8,16,32,-32,-64, para sa unsigned char, short, int, float at double, ayon sa pagkakabanggit.

Kung ang input data ay uri ng imahe, ang naaangkop na seksyon ay kinukuha at hinarangan
(batay sa kung paano tinukoy ang Seksyon ng Larawan), at ang resulta ay nakasulat sa FITS
pangunahing larawan. Kapag ang isang integer na larawan na naglalaman ng mga keyword na BSCALE at BZERO ay
na-convert sa float, ang mga halaga ng pixel ay pina-scale at ang mga scaling na keyword ay tinanggal mula sa
ang output header. Kapag nagko-convert ng integer na naka-scale na data sa integer (maaaring ibang
laki), ang mga pixel ay hindi naka-scale at ang mga scaling na keyword ay pinananatili.

Kung ang input data ay isang binary table o raw na file ng kaganapan, ang mga ito ay naka-bin sa isang imahe,
kung saan kinukuha at bina-block ang isang seksyon, at isinulat sa isang pangunahing FITS na imahe. Sa
sa kasong ito, kinakailangang tukuyin ang dalawang column na gagamitin sa 2D binning.
Magagawa ito sa command line gamit ang bincols=(x,y) keyword:

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

Ang buong anyo ng bincols= specifier ay:

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

kung saan tinutukoy ng mga tlmin, tlmax, at binsiz specifier ang mga sukat ng binning ng larawan:

dim = (tlmax - tlmin)/binsiz (floating point data)
dim = (tlmax - tlmin)/binsiz + 1 (integer data)

Gamit ang syntax na ito, posibleng i-bin ang alinmang dalawang column ng binary table sa anumang bin
laki. Tandaan na ang tlmin, tlmax, at binsiz specifier ay maaaring tanggalin kung TLMIN, TLMAX,
at ang mga parameter ng header ng TDBIN (ayon sa pagkakabanggit) ay nasa FITS binary table header para sa
ang kolum na pinag-uusapan. Tandaan din na kung isang parameter lamang ang tinukoy, ito ay ipinapalagay
upang maging tlmax, at ang tlmin ay nagde-default sa 1. Kung ang dalawang parameter ay tinukoy, sila ay ipinapalagay na
maging tlmin at tlmax. Tingnan ang Binning FITS Binary Tables at Non-FITS Event Files para sa higit pa
impormasyon tungkol sa mga parameter ng binning.

Bilang default, ang isang bagong 2D FITS na file ng imahe ay nilikha at ang imahe ay nakasulat sa pangunahin
HDU. Kung ang -a (idagdag) switch ay tinukoy, ang imahe ay idinagdag sa isang umiiral na FITS
file bilang extension ng IMAGE. (Kung wala ang output file, epektibo ang switch
hindi pinansin at ang imahe ay nakasulat sa pangunahing HDU.) Ito ay maaaring maging kapaki-pakinabang sa isang shell
programming environment kapag nagpoproseso ng maraming FITS na imahe na gusto mong pagsamahin
isang solong panghuling FITS file.

funimage maaari ring kumuha ng input mula sa isang talahanayan na naglalaman ng mga column ng x, y, at value (hal, ang
output mula sa fundisp -l na nagpapakita ng bawat larawang x at y at ang bilang ng mga bilang doon
posisyon.) Kapag ang -l (listahan) switch ay ginagamit, ang input file ay kinuha upang maging isang FITS o
ASCII table na naglalaman ng (hindi bababa sa) tatlong column na tumutukoy sa x at y image coordinates
at ang halaga ng pixel ng larawang iyon. Sa kasong ito, funimage nangangailangan ng apat na karagdagang argumento:
xcolumn:xdims, ycolumn:ydims, vcolumn at bitpix=n. Ang x at y col:dim na impormasyon ay tumatagal
ang form:

name:dim # na mga value ay mula 1 hanggang dim
name:min:max # values ​​ay mula min hanggang max
name:min:max:binsiz # na dimensyon na na-scale ayon sa binsize

Sa partikular, ang min value ay dapat gamitin sa tuwing ang minimum na coordinate value ay
isang bagay maliban sa isa. Halimbawa:

funimage -l foo.lst foo.fits xcol:0:512 ycol:0:512 value bitpix=-32

Magagamit din ang feature na listahan para basahin ang mga hindi pinangalanang column mula sa karaniwang input: simple lang
palitan ang pangalan ng column ng null string. Tandaan na ang impormasyon ng dimensyon ay pa rin
kailangan:

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

Ang tampok na listahan ay nagbibigay ng isang simpleng paraan upang makabuo ng isang blangkong larawan. Kung pumasa ka sa isang Column-
based Text File to funimage kung saan ang text header ay naglalaman ng kinakailangang larawan
impormasyon, pagkatapos ay tama ang funimage na gagawa ng isang blangkong larawan. Halimbawa, isaalang-alang ang
sumusunod na text file (tinatawag na foo.txt):

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

Tinutukoy ng text file na ito ang dalawang column, x at y, bawat isa ay may uri ng data na 32-bit int at larawan
sukat 10. Ang utos:

funimage foo.txt foo.fits bitpix=8

ay gagawa ng walang laman na FITS na imahe na tinatawag na foo.fits na naglalaman ng 10x10 na larawan ng unsigned char:

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

Tandaan na ang text file ay dapat maglaman ng kahit isang hilera ng data. Gayunpaman, sa kasalukuyan
halimbawa, ang posisyon ng kaganapan 0,0 ay nasa labas ng mga limitasyon ng larawan at hindi papansinin. (Ikaw
maaari, siyempre, gumamit ng tunay na x,y na mga halaga upang i-seed ang larawan gamit ang data.)

Higit pa rito, maaari mong gamitin ang detalye ng filter ng TEXT upang maiwasan ang pangangailangan para sa isang input
kabuuan ng text file. Ang sumusunod na command ay lilikha ng parehong 10x10 char na imahe nang wala
isang aktwal na input file:

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

Maaari mo ring gamitin ang alinman sa mga pamamaraang ito upang makabuo ng mask ng rehiyon sa pamamagitan lamang ng pagdaragdag ng a
rehiyon sa loob ng mga bracket ng filter at pagtukoy maskara=lahat kasama ang bitpix. Para sa
halimbawa, ang sumusunod na command ay bubuo ng 10x10 char mask gamit ang 3 rehiyon:

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

Ang resultang mask ay ganito ang hitsura:

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

Maaari mong gamitin ang funimage upang lumikha ng 1D na mga projection ng imahe sa kahabaan ng x o y axis gamit ang -p
[x⎪y] lumipat. Gumagana ang kakayahang ito para sa parehong mga imahe at talahanayan. Halimbawa isaalang-alang ang a
FITS table na pinangalanang ev.fits na naglalaman ng mga sumusunod na row:

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

Ang katumbas na 5x5 na larawan, na tinatawag na dim2.fits, ay naglalaman ng:

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

Ang isang projection sa kahabaan ng y axis ay maaaring isagawa sa alinman sa talahanayan o sa imahe:

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

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

Higit pa rito, maaari kang lumikha ng isang 1D image projection kasama ang anumang column ng isang table sa pamamagitan ng paggamit ng
bincols=[column] detalye ng filter at pagtukoy ng isang column. Halimbawa, ang
sumusunod na mga proyekto ng command ang parehong 1D na imahe sa kahabaan ng y axis ng isang talahanayan bilang paggamit ng -p
y lumipat:

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

Halimbawa:

Gumawa ng FITS na imahe mula sa FITS binary table:

[sh] funimage test.ev test.fits

Ipakita ang FITS na imaheng nabuo mula sa isang naka-block na seksyon ng FITS binary table:

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

Gumamit ng funimage online gamit ang mga serbisyo ng onworks.net