funimage - Online en la nube

PROGRAMA:

NOMBRE

funimage: crea una imagen FITS a partir de un archivo de datos de Funtools

SINOPSIS

imagen divertida [-a] [bitpix = n] imagen divertida [-l]
[bitpix = n] imagen divertida [-px⎪y] [bitpix = n]

CAMPUS

-a # agregar al archivo de salida existente como una extensión de imagen
-l # input es un archivo de lista que contiene xcol, ycol, value
-p [x⎪y] # proyecto a lo largo del eje xoy para crear una imagen 1D

DESCRIPCIÓN

imagen divertida crea una imagen FITS primaria a partir de la Extensión y / o Imagen FITS especificada
Sección de un archivo FITS, o de una sección de imagen de una matriz que no es FITS, o de un evento sin procesar
archivo.

El primer argumento del programa especifica la imagen de entrada, la matriz o el archivo de eventos sin formato FITS
para procesar. Si se especifica "stdin", los datos se leen desde la entrada estándar. Utilice Funtools
Notación entre corchetes para especificar extensiones FITS, secciones de imagen y filtros. El segundo
El argumento es el archivo FITS de salida. Si se especifica "stdout", la imagen FITS se escribe en
la salida estándar. De forma predeterminada, los valores de los píxeles de salida son del mismo tipo de datos que
los del archivo de entrada (o escriba "int" al agrupar una tabla), pero esto se puede anular
usando un tercer argumento opcional del formulario:

bitpix = n

donde n es 8,16,32, -32, -64, para unsigned char, short, int, float y double, respectivamente.

Si los datos de entrada son de tipo imagen, se extrae y bloquea la sección correspondiente
(basado en cómo se especifica la Sección de imagen), y el resultado se escribe en FITS
imagen primaria. Cuando se muestra una imagen entera que contiene las palabras clave BSCALE y BZERO
convertido a flotante, los valores de los píxeles se escalan y las palabras clave de escala se eliminan de
el encabezado de salida. Al convertir datos escalados enteros a enteros (posiblemente de una
tamaño), los píxeles no se escalan y se conservan las palabras clave de escala.

Si los datos de entrada son una tabla binaria o un archivo de eventos sin procesar, estos se agrupan en una imagen,
del cual se extrae y bloquea una sección y se escribe en una imagen FITS principal. En
En este caso, es necesario especificar las dos columnas que se utilizarán en el binning 2D.
Esto se puede hacer en la línea de comando usando el bincols = (x, y) palabra clave:

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

La forma completa del bincols = especificador es:

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

donde los especificadores tlmin, tlmax y binsiz determinan las dimensiones de agrupación de imágenes:

dim = (tlmax - tlmin) / binsiz (datos de coma flotante)
dim = (tlmax - tlmin) / binsiz + 1 (datos enteros)

Usando esta sintaxis, es posible agrupar dos columnas cualesquiera de una tabla binaria en cualquier bin
Talla. Tenga en cuenta que los especificadores tlmin, tlmax y binsiz se pueden omitir si TLMIN, TLMAX,
y los parámetros de encabezado TDBIN (respectivamente) están presentes en el encabezado de la tabla binaria FITS para
la columna en cuestión. Tenga en cuenta también que si solo se especifica un parámetro, se asume
tlmax, y tlmin por defecto es 1. Si se especifican dos parámetros, se supone que
sea ​​tlmin y tlmax. Consulte Agrupación de tablas binarias de FITS y archivos de eventos que no son de FITS para obtener más información.
información sobre los parámetros de agrupación.

De forma predeterminada, se crea un nuevo archivo de imagen 2D FITS y la imagen se escribe en el
HDU. Si el -a (agregar) se especifica el interruptor, la imagen se agrega a un FITS existente
archivo como una extensión de IMAGEN. (Si el archivo de salida no existe, el conmutador se
ignorado y la imagen se escribe en la HDU principal.) Esto puede ser útil en un shell
entorno de programación al procesar múltiples imágenes FITS que desea combinar en
un único archivo FITS final.

imagen divertida también puede tomar la entrada de una tabla que contiene columnas de x, y y valor (por ejemplo, el
salida de fundir -l que muestra cada imagen xey y el número de recuentos en ese
posición.) Cuando el -l (lista) se utiliza el interruptor, el archivo de entrada se toma como FITS o
Tabla ASCII que contiene (al menos) tres columnas que especifican las coordenadas de la imagen xey
y el valor de ese píxel de imagen. En este caso, imagen divertida requiere cuatro argumentos adicionales:
xcolumn: xdims, ycolumn: ydims, vcolumn y bitpix = n. La columna xey: la información tenue toma
la forma:

nombre: dim # los valores van de 1 a dim
name: min: max # los valores varían de mínimo a máximo
name: min: max: binsiz # dimensiones escaladas por binsize

En particular, el valor mínimo debe usarse siempre que el valor mínimo de la coordenada sea
algo diferente a uno. Por ejemplo:

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

La función de lista también se puede utilizar para leer columnas sin nombre de la entrada estándar: simplemente
reemplace el nombre de la columna con una cadena nula. Tenga en cuenta que la información de la dimensión todavía es
necesario:

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

La función de lista proporciona una forma sencilla de generar una imagen en blanco. Si pasa una columna-
Archivo de texto basado en una imagen de fondo en la que el encabezado de texto contiene la imagen requerida.
información, funimage hará correctamente una imagen en blanco. Por ejemplo, considere el
siguiente archivo de texto (llamado foo.txt):

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

Este archivo de texto define dos columnas, xey, cada una de tipo de datos de 32 bits int e image
dimensión 10. El comando:

funimage foo.txt foo.fits bitpix = 8

creará una imagen FITS vacía llamada foo.fits que contiene una imagen de 10x10 de caracteres sin firmar:

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

Tenga en cuenta que el archivo de texto debe contener al menos una fila de datos. Sin embargo, en el presente
Por ejemplo, la posición del evento 0,0 está fuera de los límites de la imagen y se ignorará. (Usted
puede, por supuesto, usar valores reales de x, y para sembrar la imagen con datos).

Además, puede utilizar la especificación del filtro TEXT para obviar la necesidad de una entrada
archivo de texto en conjunto. El siguiente comando creará la misma imagen de 10x10 caracteres sin
un archivo de entrada real:

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

También puede utilizar cualquiera de estos métodos para generar una máscara de región simplemente agregando un
región dentro de los soportes de filtro y especificando máscara = todo junto con bitpix. Para
Por ejemplo, el siguiente comando generará una máscara de 10x10 caracteres usando 3 regiones:

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 máscara resultante se ve así:

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

Puedes usar imagen divertida para crear proyecciones de imágenes 1D a lo largo del eje xoy utilizando el -p
[x⎪y] cambiar. Esta capacidad funciona tanto para imágenes como para tablas. Por ejemplo, considere un
FITS tabla denominada ev.fits que contiene las siguientes filas:

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

Por tanto, una imagen de 5x5 correspondiente, denominada dim2.fits, contendría:

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

Se puede realizar una proyección a lo largo del eje y en la tabla o en la imagen:

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

Además, puede crear una proyección de imagen 1D a lo largo de cualquier columna de una tabla utilizando el
bincols = [columna] especificación de filtro y especificando una sola columna. Por ejemplo, el
siguiente comando proyecta la misma imagen 1D a lo largo del eje y de una tabla como el uso de la -p
y cambiar:

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

Ejemplos:

Cree una imagen FITS a partir de una tabla binaria FITS:

[sh] funimage prueba.ev prueba.encaja

Muestre la imagen FITS generada a partir de una sección bloqueada de la tabla binaria FITS:

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

Utilice funimage en línea utilizando los servicios de onworks.net