funimage - Online nel cloud

PROGRAMMA:

NOME

funimage - crea un'immagine FITS da un file di dati Funtools

SINOSSI

immagine divertente [-un] [bitpix=n] immagine divertente [-l]
[bitpix=n] immagine divertente [-px⎪y] [bitpix=n]

VERSIONI

-a # aggiunge al file di output esistente come estensione dell'immagine
-l # input è un file di elenco contenente xcol, ycol, value
-p [x⎪y] # proietta lungo l'asse x o y per creare un'immagine 1D

DESCRIZIONE

immagine divertente crea un'immagine FITS primaria dall'estensione FITS e/o dall'immagine specificata
Sezione di un file FITS, o da una sezione immagine di un array non FITS, o da un evento raw
file.

Il primo argomento del programma specifica l'immagine di input FITS, l'array o il file evento non elaborato
processare. Se viene specificato "stdin", i dati vengono letti dallo standard input. Usa Funtools
Notazione tra parentesi per specificare estensioni FITS, sezioni di immagini e filtri. Il secondo
l'argomento è il file FITS di output. Se viene specificato "stdout", l'immagine FITS viene scritta in
l'uscita standard. Per impostazione predefinita, i valori dei pixel di output sono dello stesso tipo di dati di
quelli del file di input (o digita "int" quando raccogli una tabella), ma questo può essere sovrascritto
utilizzando un terzo argomento facoltativo della forma:

bitpix = n

dove n è 8,16,32,-32,-64, rispettivamente per unsigned char, short, int, float e double.

Se i dati di input sono di tipo immagine, la sezione appropriata viene estratta e bloccata
(in base a come viene specificata la sezione dell'immagine) e il risultato viene scritto nel FITS
immagine primaria. Quando un'immagine intera contenente le parole chiave BSCALE e BZERO è
convertito in float, i valori dei pixel vengono ridimensionati e le parole chiave di ridimensionamento vengono eliminate da
l'intestazione di uscita. Quando si convertono dati interi scalati in interi (possibilmente di un diverso
dimensione), i pixel non vengono ridimensionati e le parole chiave di ridimensionamento vengono mantenute.

Se i dati di input sono una tabella binaria o un file di eventi non elaborato, questi vengono raccolti in un'immagine,
da cui viene estratta e bloccata una sezione e scritta in un'immagine FITS primaria. In
in questo caso è necessario specificare le due colonne che verranno utilizzate nel binning 2D.
Questo può essere fatto sulla riga di comando usando il bincol=(x,y) parola chiave:

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

La forma completa di bincoli= specificatore è:

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

dove gli specificatori tlmin, tlmax e binsiz determinano le dimensioni di raggruppamento dell'immagine:

dim = (tlmax - tlmin)/binsiz (dati in virgola mobile)
dim = (tlmax - tlmin)/binsiz + 1 (dati interi)

Usando questa sintassi, è possibile bin di due colonne qualsiasi di una tabella binaria in qualsiasi bin
dimensione. Si noti che gli specificatori tlmin, tlmax e binsiz possono essere omessi se TLMIN, TLMAX,
e i parametri dell'intestazione TDBIN (rispettivamente) sono presenti nell'intestazione della tabella binaria FITS per
la colonna in questione. Si noti inoltre che se viene specificato un solo parametro, si presume
per essere tlmax e tlmin per impostazione predefinita è 1. Se vengono specificati due parametri, si presume che siano
essere tlmin e tlmax. Per ulteriori informazioni, vedere la raccolta di tabelle binarie FITS e file di eventi non FITS
informazioni sui parametri di raggruppamento.

Per impostazione predefinita, viene creato un nuovo file di immagine FITS 2D e l'immagine viene scritta nel primario
HDU. Se la -a (append) è specificato, l'immagine viene aggiunta a un FITS esistente
file come estensione IMAGE. (Se il file di output non esiste, l'interruttore è effettivamente
ignorato e l'immagine viene scritta sull'HDU primario.) Questo può essere utile in una shell
ambiente di programmazione durante l'elaborazione di più immagini FITS in cui si desidera combinare
un unico file FITS finale.

immagine divertente può anche prendere input da una tabella contenente colonne di x, y e value (ad es
uscita da fondi -l che mostra ogni immagine x e y e il numero di conteggi in quel punto
posizione.) Quando il -l (elenco) viene utilizzato l'interruttore, il file di input viene considerato un FITS o
Tabella ASCII contenente (almeno) tre colonne che specificano le coordinate x e y dell'immagine
e il valore di quel pixel dell'immagine. In questo caso, immagine divertente richiede quattro argomenti aggiuntivi:
xcolumn:xdims, ycolumn:ydims, vcolumn e bitpix=n. Le informazioni xey col:dim prendono
il modulo:

nome:dim # i valori vanno da 1 a dim
nome:min:max # i valori vanno da min a max
nome:min:max:binsiz # dimensioni ridimensionate per binsize

In particolare, il valore minimo dovrebbe essere utilizzato ogni volta che il valore minimo della coordinata è
qualcosa di diverso da uno. Per esempio:

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

La funzione elenco può essere utilizzata anche per leggere colonne senza nome dall'input standard: semplicemente
sostituire il nome della colonna con una stringa nulla. Nota che le informazioni sulla dimensione sono ancora
necessario:

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

La funzione elenco fornisce un modo semplice per generare un'immagine vuota. Se passi una Colonna-
file di testo basato su funimage in cui l'intestazione di testo contiene l'immagine richiesta
informazioni, quindi funimage creerà correttamente un'immagine vuota. Ad esempio, si consideri il
seguente file di testo (chiamato foo.txt):

X: I: 1: 10 Y: I: 1: 10
------ ------
0/0

Questo file di testo definisce due colonne, x e y, ciascuna con tipo di dati int a 32 bit e image
dimensione 10. Il comando:

FunIMage foo.txt foo.fits bitpix = 8

creerà un'immagine FITS vuota chiamata foo.fits contenente un'immagine 10x10 di caratteri senza segno:

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

Tieni presente che il file di testo deve contenere almeno una riga di dati. Tuttavia, nel presente
Ad esempio, la posizione dell'evento 0,0 è al di fuori dei limiti dell'immagine e verrà ignorata. (Voi
può, ovviamente, utilizzare valori x,y reali per seminare l'immagine con i dati.)

Inoltre, è possibile utilizzare la specifica del filtro TEXT per ovviare alla necessità di un input
file di testo del tutto. Il seguente comando creerà la stessa immagine 10x10 caratteri senza
un file di input effettivo:

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

Puoi anche usare uno di questi metodi per generare una maschera di regione semplicemente aggiungendo a
regione all'interno delle parentesi del filtro e specificando maschera=tutto insieme al bitpix. Per
esempio, il seguente comando genererà una maschera di caratteri 10x10 utilizzando 3 regioni:

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

La maschera risultante si presenta così:

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

Puoi usare immagine divertente per creare proiezioni di immagini 1D lungo l'asse x o y utilizzando il -p
[x⎪y] interruttore. Questa funzionalità funziona sia per le immagini che per le tabelle. Consideriamo ad esempio a
Tabella FITS denominata ev.fits contenente le seguenti righe:

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

Una corrispondente immagine 5x5, denominata dim2.fits, conterrebbe quindi:

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

Una proiezione lungo l'asse y può essere eseguita sia sul tavolo che sull'immagine:

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

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

Inoltre, puoi creare una proiezione di immagini 1D lungo qualsiasi colonna di una tabella utilizzando il pulsante
bincols=[colonna] specifica del filtro e specificando una singola colonna. Ad esempio, il
il comando seguente proietta la stessa immagine 1D lungo l'asse y di una tabella come utilizzo del -p
y passare:

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

Consigli d'uso:

Crea un'immagine FITS da una tabella binaria FITS:

[sh] funimage test.ev test.fits

Visualizza l'immagine FITS generata da una sezione bloccata della tabella binaria FITS:

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

Usa funimage online utilizzando i servizi onworks.net