funimage - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

funimage - ഒരു Funtools ഡാറ്റ ഫയലിൽ നിന്ന് ഒരു FITS ഇമേജ് സൃഷ്ടിക്കുക

സിനോപ്സിസ്

രസകരമായ ചിത്രം [-എ] [bitpix=n] രസകരമായ ചിത്രം [-എൽ]
[bitpix=n] രസകരമായ ചിത്രം [-px⎪y] [bitpix=n]

ഓപ്ഷനുകൾ

-a # നിലവിലുള്ള ഔട്ട്‌പുട്ട് ഫയലിലേക്ക് ഒരു ഇമേജ് എക്സ്റ്റൻഷനായി കൂട്ടിച്ചേർക്കുക
-l # ഇൻപുട്ട് എന്നത് xcol, ycol, value എന്നിവ അടങ്ങുന്ന ഒരു ലിസ്റ്റ് ഫയലാണ്
-p [x⎪y] 1D ഇമേജ് സൃഷ്‌ടിക്കുന്നതിന് x അല്ലെങ്കിൽ y അക്ഷത്തിൽ # പ്രൊജക്റ്റ് ചെയ്യുക

വിവരണം

രസകരമായ ചിത്രം നിർദ്ദിഷ്ട FITS വിപുലീകരണത്തിൽ നിന്നും കൂടാതെ/അല്ലെങ്കിൽ ഇമേജിൽ നിന്നും ഒരു പ്രാഥമിക FITS ഇമേജ് സൃഷ്ടിക്കുന്നു
ഒരു FITS ഫയലിന്റെ വിഭാഗം, അല്ലെങ്കിൽ FITS അല്ലാത്ത അറേയുടെ ഇമേജ് വിഭാഗത്തിൽ നിന്നോ അല്ലെങ്കിൽ ഒരു അസംസ്‌കൃത ഇവന്റിൽ നിന്നോ
ഫയൽ.

പ്രോഗ്രാമിലേക്കുള്ള ആദ്യ ആർഗ്യുമെന്റ് FITS ഇൻപുട്ട് ഇമേജ്, അറേ അല്ലെങ്കിൽ റോ ഇവന്റ് ഫയൽ വ്യക്തമാക്കുന്നു.
പ്രോസസ്സ് ചെയ്യാൻ. "stdin" വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് ഡാറ്റ റീഡ് ചെയ്യും. Funtools ഉപയോഗിക്കുക
FITS വിപുലീകരണങ്ങൾ, ഇമേജ് വിഭാഗങ്ങൾ, ഫിൽട്ടറുകൾ എന്നിവ വ്യക്തമാക്കുന്നതിനുള്ള ബ്രാക്കറ്റ് നോട്ടേഷൻ. രണ്ടാമത്തെ
ആർഗ്യുമെന്റ് ഔട്ട്പുട്ട് FITS ഫയൽ ആണ്. "stdout" വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, FITS ചിത്രം എഴുതപ്പെടും
സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്. ഡിഫോൾട്ടായി, ഔട്ട്പുട്ട് പിക്സൽ മൂല്യങ്ങൾ അതേ ഡാറ്റാ തരത്തിലുള്ളതാണ്
ഇൻപുട്ട് ഫയലിന്റെ (അല്ലെങ്കിൽ ഒരു ടേബിൾ ബിൻ ചെയ്യുമ്പോൾ "int" എന്ന് ടൈപ്പ് ചെയ്യുക), എന്നാൽ ഇത് അസാധുവാക്കാവുന്നതാണ്
ഫോമിന്റെ ഒരു ഓപ്ഷണൽ മൂന്നാം ആർഗ്യുമെന്റ് ഉപയോഗിക്കുന്നു:

ബിറ്റ്പിക്സ്=എൻ

ഇവിടെ n എന്നത് 8,16,32,-32,-64 ആണ്, ഒപ്പിടാത്ത char, short, int, float, double എന്നിവയ്ക്ക് യഥാക്രമം.

ഇൻപുട്ട് ഡാറ്റ ടൈപ്പ് ഇമേജ് ആണെങ്കിൽ, ഉചിതമായ വിഭാഗം എക്‌സ്‌ട്രാക്റ്റ് ചെയ്യുകയും ബ്ലോക്ക് ചെയ്യുകയും ചെയ്യും
(ചിത്ര വിഭാഗം എങ്ങനെയാണ് വ്യക്തമാക്കിയിരിക്കുന്നത് എന്നതിനെ അടിസ്ഥാനമാക്കി), ഫലം FITS-ലേക്ക് എഴുതുന്നു
പ്രാഥമിക ചിത്രം. BSCALE, BZERO കീവേഡുകൾ അടങ്ങിയ ഒരു പൂർണ്ണസംഖ്യ ചിത്രം ആയിരിക്കുമ്പോൾ
ഫ്ലോട്ടിലേക്ക് പരിവർത്തനം ചെയ്തു, പിക്സൽ മൂല്യങ്ങൾ സ്കെയിൽ ചെയ്യപ്പെടുകയും സ്കെയിലിംഗ് കീവേഡുകൾ ഇല്ലാതാക്കുകയും ചെയ്യുന്നു
ഔട്ട്പുട്ട് തലക്കെട്ട്. പൂർണ്ണസംഖ്യ സ്കെയിൽ ചെയ്ത ഡാറ്റ പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ (ഒരുപക്ഷേ വ്യത്യസ്തമായത്
വലിപ്പം), പിക്സലുകൾ സ്കെയിൽ ചെയ്തിട്ടില്ല കൂടാതെ സ്കെയിലിംഗ് കീവേഡുകൾ നിലനിർത്തുന്നു.

ഇൻപുട്ട് ഡാറ്റ ഒരു ബൈനറി ടേബിളോ റോ ഇവന്റ് ഫയലോ ആണെങ്കിൽ, ഇവ ഒരു ഇമേജിലേക്ക് ബിൻ ചെയ്യുന്നു,
അതിൽ നിന്ന് ഒരു ഭാഗം എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത് ബ്ലോക്ക് ചെയ്‌ത് ഒരു പ്രാഥമിക FITS ഇമേജിലേക്ക് എഴുതുന്നു. ഇൻ
ഈ സാഹചര്യത്തിൽ, 2D ബിന്നിംഗിൽ ഉപയോഗിക്കുന്ന രണ്ട് നിരകൾ വ്യക്തമാക്കേണ്ടത് ആവശ്യമാണ്.
ഇത് ഉപയോഗിച്ച് കമാൻഡ് ലൈനിൽ ചെയ്യാം ബിങ്കോളുകൾ=(x,y) കീവേഡ്:

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

എന്നതിന്റെ പൂർണ്ണ രൂപം ബിങ്കോളുകൾ= സ്പെസിഫയർ ഇതാണ്:

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

ഇവിടെ tlmin, tlmax, binsiz സ്പെസിഫയറുകൾ ഇമേജ് ബിന്നിംഗ് അളവുകൾ നിർണ്ണയിക്കുന്നു:

dim = (tlmax - tlmin)/binsiz (ഫ്ലോട്ടിംഗ് പോയിന്റ് ഡാറ്റ)
dim = (tlmax - tlmin)/binsiz + 1 (പൂർണ്ണസംഖ്യ ഡാറ്റ)

ഈ വാക്യഘടന ഉപയോഗിച്ച്, ഒരു ബൈനറി ടേബിളിന്റെ ഏതെങ്കിലും രണ്ട് നിരകൾ ഏത് ബിന്നിലും ബിൻ ചെയ്യാൻ സാധിക്കും.
വലിപ്പം. TLMIN, TLMAX, എങ്കിൽ tlmin, tlmax, binsiz സ്പെസിഫയറുകൾ ഒഴിവാക്കാനാകുമെന്നത് ശ്രദ്ധിക്കുക.
കൂടാതെ TDBIN ഹെഡർ പാരാമീറ്ററുകൾ (യഥാക്രമം) FITS ബൈനറി പട്ടിക തലക്കെട്ടിൽ ഉണ്ട്
ചോദ്യം ചെയ്യപ്പെടുന്ന കോളം. ഒരു പരാമീറ്റർ മാത്രമേ വ്യക്തമാക്കിയിട്ടുള്ളൂവെങ്കിൽ, അത് അനുമാനിക്കപ്പെടുന്നു എന്നതും ശ്രദ്ധിക്കുക
tlmax ആയിരിക്കുകയും tlmin സ്ഥിരസ്ഥിതിയായി 1 ആയി മാറുകയും ചെയ്യുന്നു. രണ്ട് പരാമീറ്ററുകൾ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അവ അനുമാനിക്കപ്പെടുന്നു
tlmin ഉം tlmax ഉം ആകുക. കൂടുതൽ വിവരങ്ങൾക്ക് Binning FITS ബൈനറി ടേബിളുകളും നോൺ-ഫിറ്റ്സ് ഇവന്റ് ഫയലുകളും കാണുക
ബിന്നിംഗ് പാരാമീറ്ററുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

സ്ഥിരസ്ഥിതിയായി, ഒരു പുതിയ 2D FITS ഇമേജ് ഫയൽ സൃഷ്‌ടിക്കുകയും ചിത്രം പ്രൈമറിയിലേക്ക് എഴുതുകയും ചെയ്യുന്നു
എച്ച്.ഡി.യു. എങ്കിൽ -a (അനുയോജിപ്പിക്കുക) സ്വിച്ച് വ്യക്തമാക്കിയിരിക്കുന്നു, ചിത്രം നിലവിലുള്ള ഒരു FITS-ലേക്ക് ചേർത്തിരിക്കുന്നു
ഒരു IMAGE വിപുലീകരണമായി ഫയൽ ചെയ്യുക. (ഔട്ട്പുട്ട് ഫയൽ നിലവിലില്ലെങ്കിൽ, സ്വിച്ച് ഫലപ്രദമാണ്
അവഗണിച്ചു, ചിത്രം പ്രാഥമിക HDU-ലേക്ക് എഴുതുന്നു.) ഇത് ഒരു ഷെല്ലിൽ ഉപയോഗപ്രദമാകും
നിങ്ങൾ സംയോജിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന ഒന്നിലധികം FITS ഇമേജുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ പ്രോഗ്രാമിംഗ് പരിതസ്ഥിതി
ഒരൊറ്റ അന്തിമ FITS ഫയൽ.

രസകരമായ ചിത്രം x, y, മൂല്യം എന്നിവയുടെ നിരകൾ അടങ്ങിയ പട്ടികയിൽ നിന്നും ഇൻപുട്ട് എടുക്കാം (ഉദാ
നിന്ന് ഔട്ട്പുട്ട് ഫണ്ടിസ്പി -l ഇത് ഓരോ ചിത്രവും x, y എന്നിവയും അതിലെ എണ്ണങ്ങളുടെ എണ്ണവും പ്രദർശിപ്പിക്കുന്നു
സ്ഥാനം.) എപ്പോൾ -l (ലിസ്റ്റ്) സ്വിച്ച് ഉപയോഗിക്കുന്നു, ഇൻപുട്ട് ഫയൽ ഒരു FITS ആയി എടുക്കുന്നു അല്ലെങ്കിൽ
x, y ഇമേജ് കോർഡിനേറ്റുകൾ വ്യക്തമാക്കുന്ന (കുറഞ്ഞത്) മൂന്ന് നിരകൾ അടങ്ങുന്ന ASCII പട്ടിക
ആ ഇമേജ് പിക്സലിന്റെ മൂല്യവും. ഈ സാഹചര്യത്തിൽ, രസകരമായ ചിത്രം നാല് അധിക ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ്:
xcolumn:xdims, ycolumn:ydims, vcolumn, bitpix=n. x, y col:dim വിവരങ്ങൾ എടുക്കുന്നു
രൂപം:

പേര്:ഡിം # മൂല്യങ്ങൾ 1 മുതൽ മങ്ങൽ വരെയാണ്
name:min:max # മൂല്യങ്ങൾ മിനിറ്റ് മുതൽ പരമാവധി വരെയാണ്
name:min:max:binsiz # അളവുകൾ binsize കൊണ്ട് സ്കെയിൽ ചെയ്യുന്നു

പ്രത്യേകിച്ചും, ഏറ്റവും കുറഞ്ഞ കോർഡിനേറ്റ് മൂല്യം ആയിരിക്കുമ്പോൾ മിനിമം മൂല്യം ഉപയോഗിക്കണം
ഒന്നല്ലാതെ മറ്റെന്തെങ്കിലും. ഉദാഹരണത്തിന്:

funimage -l foo.lst foo.fits xcol:0:512 ycol:0:512 മൂല്യം bitpix=-32

സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് പേരില്ലാത്ത കോളങ്ങൾ വായിക്കാനും ലിസ്റ്റ് ഫീച്ചർ ഉപയോഗിക്കാം: ലളിതമായി
നിരയുടെ പേര് ഒരു നൾ സ്ട്രിംഗ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. അളവ് വിവരങ്ങൾ ഇപ്പോഴും ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക
ആവശ്യമാണ്:

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

ലിസ്റ്റ് ഫീച്ചർ ഒരു ശൂന്യമായ ഇമേജ് സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ലളിതമായ മാർഗം നൽകുന്നു. നിങ്ങൾ ഒരു കോളം കടന്നാൽ-
ടെക്‌സ്‌റ്റ് ഹെഡറിൽ ആവശ്യമായ ചിത്രം അടങ്ങിയിരിക്കുന്ന ഫ്യൂമേജിലേക്കുള്ള ടെക്‌സ്‌റ്റ് ഫയൽ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
വിവരങ്ങൾ, അപ്പോൾ ഫ്യൂണിമേജ് ശരിയായി ഒരു ശൂന്യ ചിത്രം ഉണ്ടാക്കും. ഉദാഹരണത്തിന്, പരിഗണിക്കുക
ഇനിപ്പറയുന്ന ടെക്സ്റ്റ് ഫയൽ (foo.txt എന്ന് വിളിക്കുന്നു):

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

ഈ ടെക്‌സ്‌റ്റ് ഫയൽ 32-ബിറ്റ് ഇന്റെയും ഇമേജിന്റെയും ഓരോ ഡാറ്റാ ടൈപ്പും x, y എന്നീ രണ്ട് കോളങ്ങളെ നിർവചിക്കുന്നു.
അളവ് 10. കമാൻഡ്:

funimage foo.txt foo.fits bitpix=8

ഒപ്പിടാത്ത ചാറിന്റെ 10x10 ചിത്രം അടങ്ങിയ foo.fits എന്ന ശൂന്യമായ FITS ഇമേജ് സൃഷ്ടിക്കും:

ഫണ്ടിസ്പ് ഫൂ.ഫിറ്റ്സ്
1 2 3 4 5 6 7 8 9
------------------------------------------------------- ----------
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

ഒരു റീജിയൻ മാസ്‌ക് സൃഷ്‌ടിക്കുന്നതിന് നിങ്ങൾക്ക് ഈ രീതികളിലൊന്ന് ഉപയോഗിക്കാനും കഴിയും
ഫിൽട്ടർ ബ്രാക്കറ്റുകൾക്കുള്ളിലെ പ്രദേശവും വ്യക്തമാക്കലും മുഖംമൂടി=എല്ലാം ബിറ്റ്പിക്സിനൊപ്പം. വേണ്ടി
ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കമാൻഡ് 10 മേഖലകൾ ഉപയോഗിച്ച് 10x3 ചാർ മാസ്ക് സൃഷ്ടിക്കും:

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=എല്ലാം < /dev/null

തത്ഫലമായുണ്ടാകുന്ന മാസ്ക് ഇതുപോലെ കാണപ്പെടുന്നു:

ഫണ്ടിസ്പ് ഫൂ.ഫിറ്റ്സ്
1 2 3 4 5 6 7 8 9
------------------------------------------------------- ----------
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

നിങ്ങൾക്ക് ഉപയോഗിക്കാം രസകരമായ ചിത്രം ഉപയോഗിച്ച് x അല്ലെങ്കിൽ y അക്ഷത്തിൽ 1D ഇമേജ് പ്രൊജക്ഷനുകൾ സൃഷ്ടിക്കാൻ -p
[x⎪y] സ്വിച്ച്. ഈ കഴിവ് ചിത്രങ്ങൾക്കും പട്ടികകൾക്കും വേണ്ടി പ്രവർത്തിക്കുന്നു. ഉദാഹരണത്തിന് എ പരിഗണിക്കുക
ev.fits എന്ന് പേരുള്ള 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

അതിനാൽ, dim5.fits എന്ന് വിളിക്കപ്പെടുന്ന ഒരു 5x2 ഇമേജിൽ ഇവ അടങ്ങിയിരിക്കും:

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

y അക്ഷത്തിൽ ഒരു പ്രൊജക്ഷൻ പട്ടികയിലോ ചിത്രത്തിലോ നടത്താം:

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

കൂടാതെ, ഒരു പട്ടികയുടെ ഏത് കോളത്തിലും നിങ്ങൾക്ക് ഒരു 1D ഇമേജ് പ്രൊജക്ഷൻ സൃഷ്ടിക്കാൻ കഴിയും
ബിങ്കോളുകൾ=[നിര] ഫിൽട്ടർ സ്പെസിഫിക്കേഷനും ഒരൊറ്റ കോളം വ്യക്തമാക്കുന്നതും. ഉദാഹരണത്തിന്, ദി
ഇനിപ്പറയുന്ന കമാൻഡ് ഒരു ടേബിളിന്റെ y അക്ഷത്തിൽ അതേ 1D ഇമേജ് പ്രൊജക്റ്റ് ചെയ്യുന്നു -p
y സ്വിച്ചുചെയ്യുക:

രസകരമായ ചിത്രം ev.fits'[bincols=y]' stdout ⎪ fundisp stdin
1 2 3 4 5
---------- ---------- -------------------------------
1: 1 2 3 4 5

ഉദാഹരണങ്ങൾ:

ഒരു FITS ബൈനറി പട്ടികയിൽ നിന്ന് ഒരു FITS ഇമേജ് സൃഷ്‌ടിക്കുക:

[sh] funimage test.ev test.fits

FITS ബൈനറി പട്ടികയുടെ ബ്ലോക്ക് ചെയ്‌ത വിഭാഗത്തിൽ നിന്ന് സൃഷ്‌ടിച്ച FITS ചിത്രം പ്രദർശിപ്പിക്കുക:

[sh] ഫ്യൂണിമേജ് "test.ev[2:8,3:7,2]" stdout ⎪ fundisp stdin
1 2 3
-------------------------
1: 20
2: 28

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഓൺലൈനിൽ ഫ്യൂണിമേജ് ഉപയോഗിക്കുക