funimage - Online na nuvem

PROGRAMA:

NOME

funimage - cria uma imagem FITS a partir de um arquivo de dados Funtools

SINOPSE

imagem divertida [-uma] [bitpix = n] imagem divertida [-eu]
[bitpix = n] imagem divertida [-px⎪y] [bitpix = n]

OPÇÕES

-a # anexa ao arquivo de saída existente como uma extensão de imagem
-l # input é um arquivo de lista contendo xcol, ycol, value
-p [x⎪y] # projeto ao longo do eixo x ou y para criar uma imagem 1D

DESCRIÇÃO

imagem divertida cria uma imagem FITS primária a partir da extensão e / ou imagem FITS especificada
Seção de um arquivo FITS ou de uma Seção de imagem de um array não FITS ou de um evento bruto
arquivo.

O primeiro argumento para o programa especifica a imagem de entrada FITS, matriz ou arquivo de evento bruto
para processar. Se "stdin" for especificado, os dados serão lidos da entrada padrão. Use Funtools
Notação de colchetes para especificar extensões FITS, seções de imagem e filtros. O segundo
argumento é o arquivo FITS de saída. Se "stdout" for especificado, a imagem FITS será gravada
a saída padrão. Por padrão, os valores de pixel de saída são do mesmo tipo de dados que
aqueles do arquivo de entrada (ou digite "int" ao binning uma tabela), mas isso pode ser sobrescrito
usando um terceiro argumento opcional do formulário:

bitpix = n

onde n é 8,16,32, -32, -64, para unsigned char, short, int, float e double, respectivamente.

Se os dados de entrada são do tipo imagem, a seção apropriada é extraída e bloqueada
(com base em como a seção de imagem é especificada), e o resultado é gravado no FITS
imagem primária. Quando uma imagem inteira contendo as palavras-chave BSCALE e BZERO é
convertido em flutuante, os valores de pixel são dimensionados e as palavras-chave de dimensionamento são excluídas do
o cabeçalho de saída. Ao converter dados em escala de inteiros em inteiros (possivelmente de um diferente
tamanho), os pixels não são dimensionados e as palavras-chave de dimensionamento são mantidas.

Se os dados de entrada forem uma tabela binária ou arquivo de evento bruto, eles serão armazenados em uma imagem,
do qual uma seção é extraída e bloqueada e gravada em uma imagem FITS primária. No
neste caso, é necessário especificar as duas colunas que serão utilizadas na categorização 2D.
Isso pode ser feito na linha de comando usando o bincols = (x, y) palavra-chave:

funções "foo.ev [EVENTOS, bincols = (detx, dety)]"

A forma completa do bincols = especificador é:

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

onde os especificadores tlmin, tlmax e binsiz determinam as dimensões de binning da imagem:

dim = (tlmax - tlmin) / binsiz (dados de ponto flutuante)
dim = (tlmax - tlmin) / binsiz + 1 (dados inteiros)

Usando esta sintaxe, é possível agrupar quaisquer duas colunas de uma tabela binária em qualquer compartimento
Tamanho. Observe que os especificadores tlmin, tlmax e binsiz podem ser omitidos se TLMIN, TLMAX,
e parâmetros de cabeçalho TDBIN (respectivamente) estão presentes no cabeçalho da tabela binária FITS para
a coluna em questão. Observe também que se apenas um parâmetro for especificado, ele é assumido
para ser tlmax, e tlmin é padronizado para 1. Se dois parâmetros são especificados, eles são assumidos como
seja tlmin e tlmax. Consulte Binning FITS Binary Tables e Non-FITS Event Files para mais
informações sobre parâmetros de categorização.

Por padrão, um novo arquivo de imagem 2D FITS é criado e a imagem é gravada no primário
HDU. Se o -a (append) switch é especificado, a imagem é anexada a um FITS existente
arquivo como uma extensão IMAGE. (Se o arquivo de saída não existir, a mudança é efetivamente
ignorado e a imagem é gravada na HDU primária.) Isso pode ser útil em um shell
ambiente de programação ao processar várias imagens FITS que você deseja combinar em
um único arquivo FITS final.

imagem divertida também pode receber entrada de uma tabela contendo colunas de x, y e valor (por exemplo, o
Saída de fundo -l que exibe cada imagem xey e o número de contagens naquele
posição.) Quando o -l (lista) for usado, o arquivo de entrada é considerado um FITS ou
Tabela ASCII contendo (pelo menos) três colunas que especificam as coordenadas da imagem xey
e o valor desse pixel da imagem. Nesse caso, imagem divertida requer quatro argumentos extras:
xcolumn: xdims, ycolumn: ydims, vcolumn e bitpix = n. The xey col: dim informação leva
a forma:

nome: dim # os valores variam de 1 a dim
nome: min: max # valores variam de min a max
nome: min: max: binsiz # dimensões dimensionadas por binsize

Em particular, o valor mínimo deve ser usado sempre que o valor mínimo da coordenada é
algo diferente de um. Por exemplo:

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

O recurso de lista também pode ser usado para ler colunas sem nome da entrada padrão: simplesmente
substitua o nome da coluna por uma string nula. Observe que as informações de dimensão ainda são
requeridos:

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

O recurso de lista fornece uma maneira simples de gerar uma imagem em branco. Se você passar por uma coluna
Arquivo de texto baseado em funimage em que o cabeçalho do texto contém a imagem necessária
informações, então funimage fará corretamente uma imagem em branco. Por exemplo, considere o
seguinte arquivo de texto (denominado foo.txt):

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

Este arquivo de texto define duas colunas, x e y, cada um dos tipos de dados int de 32 bits e imagem
dimensão 10. O comando:

funimage foo.txt foo.fits bitpix = 8

irá criar uma imagem FITS vazia chamada foo.fits contendo uma imagem 10x10 de 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 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

Observe que o arquivo de texto deve conter pelo menos uma linha de dados. No entanto, no presente
exemplo, a posição do evento 0,0 está fora dos limites da imagem e será ignorada. (Vocês
pode, é claro, usar valores reais x, y para alimentar a imagem com dados.)

Além disso, você pode usar a especificação do filtro TEXT para evitar a necessidade de uma entrada
arquivo de texto completamente. O seguinte comando irá criar a mesma imagem 10x10 char sem
um arquivo de entrada real:

funimage stdin '[TEXT (x: I: 10, y: I: 10)]' foo.fits bitpix = 8 </ dev / null
or
funimage / dev / null '[TEXTO (x: I: 10, y: I: 10)]' foo.fits bitpix = 8

Você também pode usar qualquer um desses métodos para gerar uma máscara de região simplesmente anexando um
região dentro dos colchetes do filtro e especificando máscara = tudo junto com o bitpix. Para
exemplo, o seguinte comando irá gerar uma máscara 10x10 char usando 3 regiões:

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

A máscara resultante tem a seguinte aparência:

fundisp 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

Você pode usar imagem divertida para criar projeções de imagem 1D ao longo do eixo x ou y usando o -p
[x⎪y] trocar. Esse recurso funciona para imagens e tabelas. Por exemplo, considere um
Tabela FITS chamada ev.fits contendo as seguintes linhas:

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

Uma imagem 5x5 correspondente, chamada dim2.fits, conteria, portanto:

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

Uma projeção ao longo do eixo y pode ser realizada na mesa ou na imagem:

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

Além disso, você pode criar uma projeção de imagem 1D ao longo de qualquer coluna de uma tabela usando o
bincols = [coluna] especificação de filtro e especificando uma única coluna. Por exemplo, o
o seguinte comando projeta a mesma imagem 1D ao longo do eixo y de uma tabela como o uso do -p
y Switch:

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

Exemplos:

Crie uma imagem FITS a partir de uma tabela binária FITS:

[sh] funimage test.ev test.fits

Exibir a imagem FITS gerada a partir de uma seção bloqueada da tabela binária FITS:

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

Use funimage online usando serviços onworks.net