funimage - En ligne dans le Cloud

PROGRAMME:

Nom

funimage - crée une image FITS à partir d'un fichier de données Funtools

SYNOPSIS

image amusante [-une] [bitpix=n] image amusante [-l]
[bitpix=n] image amusante [-px⎪y] [bitpix=n]

OPTIONS

-a # ajouter au fichier de sortie existant en tant qu'extension d'image
-l # input est un fichier liste contenant xcol, ycol, value
-p [x⎪y] # projeter le long de l'axe x ou y pour créer une image 1D

DESCRIPTION

image amusante crée une image FITS principale à partir de l'extension et/ou de l'image FITS spécifiée
Section d'un fichier FITS, ou d'une section d'image d'un tableau non-FITS, ou d'un événement brut
fichier.

Le premier argument du programme spécifie l'image d'entrée FITS, le tableau ou le fichier d'événement brut
procéder. Si "stdin" est spécifié, les données sont lues à partir de l'entrée standard. Utiliser Funtools
Bracket Notation pour spécifier les extensions FITS, les sections d'image et les filtres. La deuxième
l'argument est le fichier FITS de sortie. Si "stdout" est spécifié, l'image FITS est écrite dans
la sortie standard. Par défaut, les valeurs de pixels de sortie sont du même type de données que
ceux du fichier d'entrée (ou tapez "int" lors du binning d'une table), mais cela peut être outrepassé
en utilisant un troisième argument facultatif de la forme :

bitpix=n

où n vaut 8,16,32,-32,-64, pour les caractères non signés, short, int, float et double, respectivement.

Si les données d'entrée sont de type image, la section appropriée est extraite et bloquée
(basé sur la façon dont la section Image est spécifiée), et le résultat est écrit dans le FITS
image principale. Lorsqu'une image entière contenant les mots clés BSCALE et BZERO est
converti en flottant, les valeurs de pixel sont mises à l'échelle et les mots-clés de mise à l'échelle sont supprimés de
l'en-tête de sortie. Lors de la conversion de données mises à l'échelle d'entiers en nombres entiers (éventuellement d'un autre
size), les pixels ne sont pas mis à l'échelle et les mots-clés de mise à l'échelle sont conservés.

Si les données d'entrée sont une table binaire ou un fichier d'événement brut, elles sont regroupées dans une image,
à partir de laquelle une section est extraite et bloquée, et écrite dans une image FITS principale. Dans
dans ce cas, il faut préciser les deux colonnes qui seront utilisées dans le binning 2D.
Cela peut être fait sur la ligne de commande en utilisant le bincols=(x,y) mot-clé:

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

La forme complète du bincols= le spécificateur est :

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

où les spécificateurs tlmin, tlmax et binsiz déterminent les dimensions de regroupement de l'image :

dim = (tlmax - tlmin)/binsiz (données à virgule flottante)
dim = (tlmax - tlmin)/binsiz + 1 (données entières)

En utilisant cette syntaxe, il est possible de biner deux colonnes d'une table binaire à n'importe quel bin
Taille. Notez que les spécificateurs tlmin, tlmax et binsiz peuvent être omis si TLMIN, TLMAX,
et les paramètres d'en-tête TDBIN (respectivement) sont présents dans l'en-tête de la table binaire FITS pour
la colonne en question. Notez également que si un seul paramètre est spécifié, il est supposé
être tlmax, et tlmin vaut par défaut 1. Si deux paramètres sont spécifiés, ils sont supposés être
être tlmin et tlmax. Voir Binning FITS Binary Tables et Non-FITS Event Files pour plus d'informations
informations sur les paramètres de binning.

Par défaut, un nouveau fichier image FITS 2D est créé et l'image est écrite sur le
HDU. Si la -a (ajouter) le commutateur est spécifié, l'image est ajoutée à un FITS existant
fichier en tant qu'extension IMAGE. (Si le fichier de sortie n'existe pas, le commutateur est effectivement
ignoré et l'image est écrite sur le HDU principal.) Cela peut être utile dans un shell
environnement de programmation lors du traitement de plusieurs images FITS que vous souhaitez combiner en
un seul fichier FITS final.

image amusante peut également prendre l'entrée d'une table contenant des colonnes de x, y et valeur (par exemple, le
sortie de fonds -l qui affiche chaque image x et y et le nombre de comptes à ce
position.) Lorsque le -l (liste) est utilisé, le fichier d'entrée est considéré comme un FITS ou
Table ASCII contenant (au moins) trois colonnes qui spécifient les coordonnées x et y de l'image
et la valeur de ce pixel d'image. Dans ce cas, image amusante nécessite quatre arguments supplémentaires :
xcolumn:xdims, ycolumn:ydims, vcolumn et bitpix=n. Les informations x et y col:dim prennent
la forme:

name:dim # les valeurs vont de 1 à dim
name:min:max # les valeurs vont de min à max
name:min:max:binsiz # dimensions mises à l'échelle par binsize

En particulier, la valeur min doit être utilisée chaque fois que la valeur de coordonnée minimale est
autre chose qu'un. Par exemple:

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

La fonctionnalité de liste peut également être utilisée pour lire des colonnes sans nom à partir d'une entrée standard : simplement
remplacez le nom de la colonne par une chaîne nulle. Notez que les informations de dimension sont toujours
Champs obligatoires:

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

^D

La fonction de liste fournit un moyen simple de générer une image vierge. Si vous passez une colonne-
Fichier texte basé sur funimage dans lequel l'en-tête de texte contient l'image requise
informations, alors funimage créera correctement une image vierge. Par exemple, considérons le
fichier texte suivant (appelé foo.txt) :

x:I:1:10 y:I:1:10
------ ------
+0 (0)XNUMX XNUMX

Ce fichier texte définit deux colonnes, x et y, chacune de type de données 32 bits int et image
dimension 10. La commande :

funimage foo.txt foo.fits bitpix=8

va créer une image FITS vide appelée foo.fits contenant une image 10x10 de caractère non signé :

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

Notez que le fichier texte doit contenir au moins une ligne de données. Cependant, dans le présent
Par exemple, la position de l'événement 0,0 est en dehors des limites de l'image et sera ignorée. (Tu
peut, bien sûr, utiliser de vraies valeurs x,y pour ensemencer l'image avec des données.)

De plus, vous pouvez utiliser la spécification de filtre TEXT pour éviter le besoin d'une entrée
fichier texte au total. La commande suivante créera la même image de caractère 10x10 sans
un fichier d'entrée réel :

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

Vous pouvez également utiliser l'une de ces méthodes pour générer un masque de région simplement en ajoutant un
région à l'intérieur des supports de filtre et en spécifiant masque=tous avec le bitpix. Pour
exemple, la commande suivante va générer un masque de caractères 10x10 en utilisant 3 régions :

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

Le masque résultant ressemble à ceci :

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

Vous pouvez utiliser image amusante pour créer des projections d'images 1D le long de l'axe x ou y en utilisant le -p
[x⎪y] changer. Cette capacité fonctionne à la fois pour les images et les tableaux. Par exemple, considérons un
Table FITS nommée ev.fits contenant les lignes suivantes :

XY
-------- --------
+1 (1)XNUMX XNUMX
+1 (2)XNUMX XNUMX
+1 (3)XNUMX XNUMX
+1 (4)XNUMX XNUMX
+1 (5)XNUMX XNUMX
+2 (2)XNUMX XNUMX
+2 (3)XNUMX XNUMX
+2 (4)XNUMX XNUMX
+2 (5)XNUMX XNUMX
+3 (3)XNUMX XNUMX
+3 (4)XNUMX XNUMX
+3 (5)XNUMX XNUMX
+4 (4)XNUMX XNUMX
+4 (5)XNUMX XNUMX
+5 (5)XNUMX XNUMX

Une image 5x5 correspondante, appelée dim2.fits, contiendrait donc :

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

Une projection selon l'axe des y peut être effectuée soit sur le tableau soit sur l'image :

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

De plus, vous pouvez créer une projection d'image 1D le long de n'importe quelle colonne d'un tableau en utilisant le
bincols=[colonne] spécification de filtre et spécification d'une seule colonne. Par exemple, le
la commande suivante projette la même image 1D le long de l'axe y d'une table en utilisant le -p
y passer:

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

Exemples :

Créez une image FITS à partir d'une table binaire FITS :

[sh] funimage test.ev test.fits

Affichez l'image FITS générée à partir d'une section bloquée de la table binaire FITS :

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

Utilisez funimage en ligne en utilisant les services onworks.net