funimage - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

funimage – Erstellen Sie ein FITS-Bild aus einer Funtools-Datendatei

ZUSAMMENFASSUNG

Spaßbild [-A] [bitpix=n] Spaßbild [-l]
[bitpix=n] Spaßbild [-px⎪y] [bitpix=n]

OPTIONAL

-a # als Bilderweiterung an die vorhandene Ausgabedatei anhängen
-l # Eingabe ist eine Listendatei mit xcol, ycol und Wert
-p [x⎪y] # Projizieren Sie entlang der X- oder Y-Achse, um ein 1D-Bild zu erstellen

BESCHREIBUNG

Spaßbild Erstellt ein primäres FITS-Image aus der angegebenen FITS-Erweiterung und/oder dem angegebenen Image
Abschnitt einer FITS-Datei oder aus einem Bildabschnitt eines Nicht-FITS-Arrays oder aus einem Rohereignis
Datei.

Das erste Argument des Programms gibt das FITS-Eingabebild, das Array oder die Rohereignisdatei an
herstellen. Wenn „stdin“ angegeben ist, werden Daten aus der Standardeingabe gelesen. Verwenden Sie Funtools
Klammernotation zur Angabe von FITS-Erweiterungen, Bildausschnitten und Filtern. Der Zweite
Das Argument ist die ausgegebene FITS-Datei. Wenn „stdout“ angegeben ist, wird auf das FITS-Image geschrieben
die Standardausgabe. Standardmäßig haben die Ausgabepixelwerte denselben Datentyp wie
die der Eingabedatei (oder geben Sie beim Binning einer Tabelle „int“ ein), dies kann jedoch überschrieben werden
mit einem optionalen dritten Argument der Form:

bitpix=n

wobei n 8,16,32,-32,-64 ist, für unsigned char, short, int, float bzw. double.

Wenn die Eingabedaten vom Typ Bild sind, wird der entsprechende Abschnitt extrahiert und blockiert
(basierend auf der Angabe des Bildabschnitts) und das Ergebnis wird in die FITS geschrieben
Primärbild. Wenn es sich um ein ganzzahliges Bild handelt, das die Schlüsselwörter BSCALE und BZERO enthält
in Float konvertiert, die Pixelwerte werden skaliert und die Skalierungsschlüsselwörter werden gelöscht
der Ausgabeheader. Beim Konvertieren von ganzzahlig skalierten Daten in ganzzahlige Daten (möglicherweise von einem anderen Wert).
Größe) werden die Pixel nicht skaliert und die Skalierungsschlüsselwörter bleiben erhalten.

Wenn es sich bei den Eingabedaten um eine Binärtabelle oder eine Rohereignisdatei handelt, werden diese in einem Bild zusammengefasst.
aus dem ein Abschnitt extrahiert und blockiert und in ein primäres FITS-Image geschrieben wird. In
In diesem Fall müssen die beiden Spalten angegeben werden, die beim 2D-Binning verwendet werden.
Dies kann über die Befehlszeile erfolgen bincols=(x,y) Stichwort:

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

Die vollständige Form der bincols= Bezeichner ist:

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

Dabei bestimmen die Spezifizierer tlmin, tlmax und binsiz die Dimensionen der Bildeinteilung:

dim = (tlmax - tlmin)/binsiz (Gleitkommadaten)
dim = (tlmax - tlmin)/binsiz + 1 (ganzzahlige Daten)

Mit dieser Syntax ist es möglich, zwei beliebige Spalten einer Binärtabelle in beliebige Bins zu unterteilen
Größe. Beachten Sie, dass die Spezifizierer tlmin, tlmax und binsiz weggelassen werden können, wenn TLMIN, TLMAX,
und TDBIN-Header-Parameter (jeweils) sind im FITS-Binärtabellen-Header für vorhanden
die betreffende Spalte. Beachten Sie auch, dass, wenn nur ein Parameter angegeben ist, dieser angenommen wird
muss tlmax sein und tlmin ist standardmäßig 1. Wenn zwei Parameter angegeben sind, wird davon ausgegangen, dass dies der Fall ist
sei tlmin und tlmax. Weitere Informationen finden Sie unter „Binning von FITS-Binärtabellen und Nicht-FITS-Ereignisdateien“.
Informationen zu Binning-Parametern.

Standardmäßig wird eine neue 2D-FITS-Bilddatei erstellt und das Bild auf die primäre Datei geschrieben
HDU. Wenn die -a Wenn der Schalter (append) angegeben ist, wird das Bild an ein vorhandenes FITS angehängt
Datei als IMAGE-Erweiterung. (Wenn die Ausgabedatei nicht vorhanden ist, ist der Schalter wirksam
ignoriert und das Image wird auf die primäre HDU geschrieben.) Dies kann in einer Shell nützlich sein
Programmierumgebung bei der Verarbeitung mehrerer FITS-Bilder, die Sie kombinieren möchten
eine einzelne endgültige FITS-Datei.

Spaßbild Kann auch Eingaben aus einer Tabelle entgegennehmen, die Spalten mit x, y und Werten enthält (z. B. die
Ausgabe von Fundisp -l Hier werden jedes Bild x und y sowie die Anzahl der Zählungen angezeigt
Position.) Wenn die -l Wenn der Schalter (list) verwendet wird, wird die Eingabedatei als FITS oder angenommen
ASCII-Tabelle mit (mindestens) drei Spalten, die die x- und y-Bildkoordinaten angeben
und der Wert dieses Bildpixels. In diesem Fall, Spaßbild erfordert vier zusätzliche Argumente:
xcolumn:xdims, ycolumn:ydims, vcolumn und bitpix=n. Die x- und y-col:dim-Informationen werden benötigt
die Form:

name:dim # Werte reichen von 1 bis dim
name:min:max # Werte reichen von min bis max
name:min:max:binsiz # Dimensionen skaliert nach Binsize

Insbesondere sollte der Min-Wert immer dann verwendet werden, wenn der minimale Koordinatenwert vorliegt
etwas anderes als eins. Zum Beispiel:

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

Die Listenfunktion kann auch zum Lesen unbenannter Spalten aus der Standardeingabe verwendet werden: einfach
Ersetzen Sie den Spaltennamen durch eine Nullzeichenfolge. Beachten Sie, dass die Dimensionsinformationen noch vorhanden sind
erforderlich:

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

Die Listenfunktion bietet eine einfache Möglichkeit, ein leeres Bild zu erstellen. Wenn Sie eine Spalte übergeben,
basierte Textdatei zu funimage, in der der Textkopf das erforderliche Bild enthält
Informationen, dann erstellt funimage korrekt ein leeres Bild. Betrachten Sie zum Beispiel die
folgende Textdatei (genannt foo.txt):

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

Diese Textdatei definiert zwei Spalten, x und y, jeweils vom Datentyp 32-Bit-int und image
Dimension 10. Der Befehl:

funimage foo.txt foo.fits bitpix=8

erstellt ein leeres FITS-Bild namens foo.fits, das ein 10x10-Bild mit vorzeichenlosem Zeichen enthält:

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

Beachten Sie, dass die Textdatei mindestens eine Datenzeile enthalten muss. Allerdings in der Gegenwart
Beispielsweise liegt die Ereignisposition 0,0 außerhalb der Bildgrenzen und wird ignoriert. (Du
kann natürlich echte x- und y-Werte verwenden, um das Bild mit Daten zu füllen.)

Darüber hinaus können Sie die TEXT-Filterspezifikation verwenden, um die Notwendigkeit einer Eingabe zu vermeiden
Textdatei insgesamt. Der folgende Befehl erstellt das gleiche 10x10-Zeichen-Bild ohne
eine tatsächliche Eingabedatei:

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

Sie können auch eine dieser Methoden verwenden, um eine Regionsmaske zu generieren, indem Sie einfach eine anhängen
Region innerhalb der Filterklammern und Spezifizierung Maske=alle zusammen mit dem Bitpix. Für
Der folgende Befehl generiert beispielsweise eine 10x10-Zeichenmaske mit 3 Regionen:

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

Die resultierende Maske sieht folgendermaßen aus:

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

Sie können verwenden Spaßbild um mit dem 1D-Bildprojektionen entlang der x- oder y-Achse zu erstellen -p
[x⎪y] schalten. Diese Funktion funktioniert sowohl für Bilder als auch für Tabellen. Betrachten Sie zum Beispiel a
FITS-Tabelle mit dem Namen ev.fits, die die folgenden Zeilen enthält:

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

Ein entsprechendes 5x5-Bild namens dim2.fits würde daher Folgendes enthalten:

+1 2 3 4
---------- ---------- ---------- ---------- ---------- ----------
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

Eine Projektion entlang der y-Achse kann entweder auf der Tabelle oder im Bild durchgeführt werden:

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

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

Darüber hinaus können Sie mithilfe von eine 1D-Bildprojektion entlang einer beliebigen Spalte einer Tabelle erstellen
bincols=[Spalte] Filterspezifikation und Angabe einer einzelnen Spalte. Zum Beispiel die
Der folgende Befehl projiziert dasselbe 1D-Bild entlang der y-Achse einer Tabelle wie bei Verwendung von -p
y Schalter:

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

Beispiele:

Erstellen Sie ein FITS-Image aus einer FITS-Binärtabelle:

[sh] funimage test.ev test.fits

Zeigen Sie das FITS-Bild an, das aus einem blockierten Abschnitt der FITS-Binärtabelle generiert wurde:

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

Nutzen Sie funimage online über die Dienste von onworks.net