Merge branch 'main' of https://github.com/Eskimue/Solve-Field-GUI
This commit is contained in:
Eskimue
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"host": "10.42.42.102",
|
||||
"port": 22,
|
||||
"user": "tm",
|
||||
"password": "heute1234"
|
||||
}
|
||||
@@ -0,0 +1,248 @@
|
||||
# Solve-Field-GUI
|
||||
|
||||
Grafische Windows-Oberfläche für `solve-field` aus Astrometry.net mit Ausführung auf einem Linux-Server per SSH.
|
||||
|
||||
Die Software richtet sich an Anwender, die Astrometrie komfortabel über eine GUI steuern möchten, ohne die `solve-field`-Befehle jedes Mal von Hand zusammenzubauen.
|
||||
|
||||
## Was die Software macht
|
||||
|
||||
Die Anwendung läuft lokal unter Windows und verbindet sich per SSH mit einem entfernten Linux-Server.
|
||||
|
||||
Dort kann sie:
|
||||
|
||||
- Bilddateien auf den Server hochladen
|
||||
- `solve-field` mit vielen Parametern starten
|
||||
- die Ausgabe live im Log anzeigen
|
||||
- Ergebnisdateien im Remote-Verzeichnis anzeigen
|
||||
- einzelne oder mehrere Ergebnisdateien wieder lokal herunterladen
|
||||
- Serverfunktionen wie SExtractor-Prüfung und Diagnose ausführen
|
||||
|
||||
## Hauptfunktionen
|
||||
|
||||
- SSH-Verbindung zu einem Linux-Server mit Benutzername, Passwort und Port
|
||||
- Upload lokaler Bilddateien per SFTP
|
||||
- grafische Konfiguration fast aller wichtigen `solve-field`-Parameter
|
||||
- automatische Befehlsvorschau des erzeugten `solve-field`-Aufrufs
|
||||
- Unterstützung für Maßstab, RA/Dek, Suchradius, Downsampling, CPU-Limit, Tweak-Order und viele weitere Optionen
|
||||
- Unterstützung für Source Extractor per `--use-source-extractor`
|
||||
- automatische Berechnung von `--plot-scale` aus der lokalen Bildgröße
|
||||
- serverseitige Diagnose für `solve-field`, `astrometry.cfg`, Indexdateien, SExtractor und Speicherplatz
|
||||
- Remote-Ergebnis-Tab mit Dateiliste
|
||||
- Mehrfachdownload ausgewählter Ergebnisdateien
|
||||
- Profilspeicherung und Profilladen für komplette GUI-Einstellungen
|
||||
|
||||
## Unterstützte Dateitypen
|
||||
|
||||
Als Eingabedatei lokal:
|
||||
|
||||
- FITS
|
||||
- FIT
|
||||
- FTS
|
||||
- JPG / JPEG
|
||||
- PNG
|
||||
- TIFF / TIF
|
||||
|
||||
Für die automatische Plot-Skalierung kann die Anwendung Bildgrößen direkt aus mehreren Formaten lesen, darunter FITS, PNG, JPG, GIF und BMP.
|
||||
|
||||
## Voraussetzungen
|
||||
|
||||
## Lokal unter Windows
|
||||
|
||||
- Python 3
|
||||
- `asyncssh`
|
||||
- Netzwerkzugriff auf den Linux-Server per SSH
|
||||
|
||||
Installation von `asyncssh`:
|
||||
|
||||
```bash
|
||||
pip install asyncssh
|
||||
```
|
||||
|
||||
## Auf dem Linux-Server
|
||||
|
||||
- Astrometry.net mit `solve-field`
|
||||
- passende Indexdateien
|
||||
- SSH-Zugang
|
||||
|
||||
Optional:
|
||||
|
||||
- `source-extractor`, wenn SExtractor zur Quellenerkennung genutzt werden soll
|
||||
|
||||
## Starten
|
||||
|
||||
Direkt mit Python:
|
||||
|
||||
```bash
|
||||
python astrometry_gui.py
|
||||
```
|
||||
|
||||
Oder unter Windows über:
|
||||
|
||||
```bash
|
||||
astrometry_gui.bat
|
||||
```
|
||||
|
||||
## Bedienung
|
||||
|
||||
## 1. SSH eintragen
|
||||
|
||||
Oben in der GUI:
|
||||
|
||||
- Host
|
||||
- Port
|
||||
- Benutzer
|
||||
- Passwort
|
||||
|
||||
Mit `Verbinden & testen` kann geprüft werden, ob der Server erreichbar ist und `solve-field` vorhanden ist.
|
||||
|
||||
## 2. Bild auswählen und hochladen
|
||||
|
||||
Im Tab `Input / Output`:
|
||||
|
||||
- lokale Datei auswählen
|
||||
- Remote-Verzeichnis festlegen
|
||||
- Datei per `Hochladen` auf den Server übertragen
|
||||
|
||||
Nach dem Upload wird der Remote-Dateipfad automatisch als Eingabedatei gesetzt.
|
||||
|
||||
## 3. Solver-Parameter einstellen
|
||||
|
||||
Je nach Bedarf können unter anderem gesetzt werden:
|
||||
|
||||
- Maßstabsbereich
|
||||
- RA / Dek / Radius
|
||||
- CPU-Limit
|
||||
- Downsampling
|
||||
- Plot-Skalierung
|
||||
- Tweak-Order
|
||||
- Verifikation
|
||||
- Invertierung
|
||||
- SExtractor-Nutzung
|
||||
|
||||
## 4. Befehl prüfen und starten
|
||||
|
||||
Im Tab `Befehlsvorschau` sieht man den tatsächlich erzeugten `solve-field`-Befehl.
|
||||
|
||||
Mit `solve-field starten` wird der Befehl auf dem Server ausgeführt.
|
||||
|
||||
## Tabs im Überblick
|
||||
|
||||
## Input / Output
|
||||
|
||||
- lokale Bilddatei
|
||||
- Remote-Verzeichnis
|
||||
- Upload
|
||||
- Eingabedatei auf dem Server
|
||||
- Ausgabeoptionen wie `--wcs`, `--corr`, `--rdls`, `--match`, `--new-fits`
|
||||
|
||||
## Maßstab & Position
|
||||
|
||||
- `--scale-low`
|
||||
- `--scale-high`
|
||||
- `--scale`
|
||||
- `--scale-err`
|
||||
- `--ra`
|
||||
- `--dec`
|
||||
- `--radius`
|
||||
|
||||
## Solver-Parameter
|
||||
|
||||
- `--depth`
|
||||
- `--cpulimit`
|
||||
- `--plot-scale`
|
||||
- `--downsample`
|
||||
- `--tweak-order`
|
||||
- `--odds-*`
|
||||
- `--objs`
|
||||
- `--pixel-error`
|
||||
- zahlreiche Flags wie `--no-plots`, `--invert`, `--no-verify`
|
||||
|
||||
Zusätzlich gibt es einen Plot-Helfer:
|
||||
|
||||
- automatische Berechnung von `plot-scale`
|
||||
- Zielkantenlänge einstellbar
|
||||
|
||||
## Erweitert
|
||||
|
||||
- manuelle Indexdateien
|
||||
- zusätzliche freie Kommandozeilenargumente
|
||||
|
||||
## Befehlsvorschau
|
||||
|
||||
- zeigt den generierten Befehl
|
||||
- kann aktualisiert werden
|
||||
- kann in die Zwischenablage kopiert werden
|
||||
|
||||
## Server Setup
|
||||
|
||||
- SExtractor prüfen
|
||||
- SExtractor installieren
|
||||
- Server-Diagnose ausführen
|
||||
|
||||
## Remote-Ergebnisse
|
||||
|
||||
- zeigt Dateien im aktuellen Remote-Verzeichnis
|
||||
- lädt den Inhalt beim Öffnen des Tabs automatisch neu
|
||||
- erlaubt Auswahl und Download von einer oder mehreren Dateien
|
||||
|
||||
## Remote-Ergebnisse herunterladen
|
||||
|
||||
Im Tab `Remote-Ergebnisse`:
|
||||
|
||||
- eine oder mehrere Dateien markieren
|
||||
- `Herunterladen` klicken
|
||||
- Zielordner auswählen
|
||||
|
||||
Standardmäßig wird als Zielordner der Ordner der ursprünglich lokal ausgewählten Bilddatei vorgeschlagen.
|
||||
|
||||
## Remote-Verzeichnis leeren
|
||||
|
||||
Im Tab `Input / Output` gibt es die Funktion:
|
||||
|
||||
- `Remote-Inhalt löschen`
|
||||
|
||||
Dabei wird nur der Inhalt des Remote-Verzeichnisses gelöscht, nicht das Verzeichnis selbst.
|
||||
|
||||
## Profile speichern und laden
|
||||
|
||||
Über die Menühleiste:
|
||||
|
||||
- `Profil -> Profil speichern…`
|
||||
- `Profil -> Profil laden…`
|
||||
|
||||
Gespeichert werden:
|
||||
|
||||
- SSH-Daten
|
||||
- Solver-Parameter
|
||||
- Ein-/Ausgabe-Einstellungen
|
||||
- Zusatzargumente
|
||||
- Indexliste
|
||||
|
||||
Das Passwort wird nicht im Klartext gespeichert, sondern mit einer einfachen internen Verschlüsselung abgelegt.
|
||||
|
||||
## Typischer Workflow
|
||||
|
||||
1. Serververbindung eintragen
|
||||
2. Lokales Bild auswählen
|
||||
3. Datei hochladen
|
||||
4. Maßstab und Solver-Parameter setzen
|
||||
5. Optional SExtractor aktivieren
|
||||
6. `solve-field` starten
|
||||
7. Ergebnisse im Tab `Remote-Ergebnisse` prüfen
|
||||
8. Gewünschte Dateien lokal herunterladen
|
||||
|
||||
## Hinweise
|
||||
|
||||
- Die GUI baut nur den Befehl und führt ihn per SSH aus. Die eigentliche Astrometrie läuft vollständig auf dem Server.
|
||||
- Die installierte Astrometry-Version auf dem Server bestimmt, welche Optionen tatsächlich verfügbar sind.
|
||||
- Für SExtractor muss auf dem Server in der Regel `source-extractor` installiert sein.
|
||||
- Für gute Ergebnisse müssen die passenden Indexdateien serverseitig vorhanden und in `astrometry.cfg` korrekt eingebunden sein.
|
||||
|
||||
## Dateien im Projekt
|
||||
|
||||
- [astrometry_gui.py](C:/Users/ich/source/repos/Solve-Field-GUI/astrometry_gui.py)
|
||||
- [astrometry_gui.bat](C:/Users/ich/source/repos/Solve-Field-GUI/astrometry_gui.bat)
|
||||
|
||||
## Lizenz / Nutzung
|
||||
|
||||
Dieses Repository enthält eine GUI zur Bedienung von Astrometry.net. Die Lizenz und Bedingungen von Astrometry.net sowie von eventuell installierten Serverpaketen gelten zusätzlich zu diesem Projekt.
|
||||
Binary file not shown.
+573
-9
@@ -8,13 +8,17 @@ Abhängigkeiten:
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import json
|
||||
import tkinter as tk
|
||||
import tkinter.font as tkfont
|
||||
from tkinter import ttk, filedialog, messagebox, scrolledtext
|
||||
import threading
|
||||
import os
|
||||
import shlex
|
||||
import queue
|
||||
import stat
|
||||
import struct
|
||||
|
||||
try:
|
||||
import asyncssh
|
||||
@@ -23,6 +27,9 @@ except ImportError:
|
||||
HAS_ASYNCSSH = False
|
||||
|
||||
|
||||
SSH_CREDENTIALS_JSON = "ssh_zugangsdaten.json"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tooltip
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -144,6 +151,26 @@ class AsyncSSH:
|
||||
progress_handler=_progress,
|
||||
)
|
||||
|
||||
async def download(self, remote_path: str, local_path: str, progress_cb=None):
|
||||
if self._conn is None:
|
||||
await self.connect()
|
||||
local_path = os.path.normpath(local_path)
|
||||
|
||||
async with self._conn.start_sftp_client() as sftp:
|
||||
attrs = await sftp.stat(remote_path)
|
||||
total = int(getattr(attrs, "size", 0) or 0)
|
||||
done = 0
|
||||
async with sftp.open(remote_path, "rb") as remote_file:
|
||||
with open(local_path, "wb") as local_file:
|
||||
while True:
|
||||
chunk = await remote_file.read(1024 * 1024)
|
||||
if not chunk:
|
||||
break
|
||||
local_file.write(chunk)
|
||||
done += len(chunk)
|
||||
if progress_cb:
|
||||
progress_cb(done, total)
|
||||
|
||||
async def close(self):
|
||||
if self._conn:
|
||||
self._conn.close()
|
||||
@@ -159,7 +186,7 @@ class AstrometryGUI:
|
||||
|
||||
def __init__(self, root: tk.Tk):
|
||||
self.root = root
|
||||
self.root.title("Astrometry.net — solve-field GUI")
|
||||
self.root.title("Astrometry.net — solve-field GUI vom Astronomiemuseum")
|
||||
self.root.geometry("1000x840")
|
||||
self.root.minsize(800, 620)
|
||||
|
||||
@@ -192,8 +219,10 @@ class AstrometryGUI:
|
||||
self.v_port = tk.IntVar(value=22)
|
||||
self.v_user = tk.StringVar(value="eskimue")
|
||||
self.v_pass = tk.StringVar(value="Preside")
|
||||
self._load_startup_credentials()
|
||||
|
||||
self.v_local_file = tk.StringVar()
|
||||
self.v_local_file.trace_add("write", self._on_local_file_changed)
|
||||
self.v_remote_dir = tk.StringVar(value="/tmp/astrometry")
|
||||
self.v_input_file = tk.StringVar()
|
||||
self.v_input_file.trace_add("write", self._on_input_file_changed)
|
||||
@@ -220,6 +249,11 @@ class AstrometryGUI:
|
||||
|
||||
self.v_depth = tk.StringVar()
|
||||
self.v_cpulimit = tk.StringVar(value="300")
|
||||
self.v_plot_scale = tk.StringVar()
|
||||
self.v_plot_scale_auto = tk.BooleanVar(value=True)
|
||||
self.v_plot_target_long_edge = tk.StringVar(value="900")
|
||||
self.v_plot_target_long_edge.trace_add("write", self._on_plot_scale_settings_changed)
|
||||
self.v_plot_scale_auto.trace_add("write", self._on_plot_scale_settings_changed)
|
||||
self.v_downsample = tk.StringVar(value="6")
|
||||
self.v_tweak_order = tk.StringVar(value="2")
|
||||
self.v_odds_solve = tk.StringVar()
|
||||
@@ -244,18 +278,43 @@ class AstrometryGUI:
|
||||
self.v_invert = tk.BooleanVar(value=False)
|
||||
|
||||
self.v_extra = tk.StringVar()
|
||||
self.results_files: dict[str, dict] = {}
|
||||
|
||||
def _load_startup_credentials(self):
|
||||
path = os.path.join(os.getcwd(), SSH_CREDENTIALS_JSON)
|
||||
if not os.path.isfile(path):
|
||||
return
|
||||
try:
|
||||
self._load_credentials_from_file(path)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _load_credentials_from_file(self, path: str):
|
||||
with open(path, "r", encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
if "host" in data:
|
||||
self.v_host.set(str(data["host"]))
|
||||
if "port" in data:
|
||||
self.v_port.set(int(data["port"]))
|
||||
if "user" in data:
|
||||
self.v_user.set(str(data["user"]))
|
||||
if "password" in data:
|
||||
self.v_pass.set(str(data["password"]))
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# UI aufbauen
|
||||
# -----------------------------------------------------------------------
|
||||
|
||||
def _build_ui(self):
|
||||
self._build_menu()
|
||||
|
||||
top = ttk.Frame(self.root, padding=4)
|
||||
top.pack(fill=tk.X)
|
||||
self._build_conn_bar(top)
|
||||
|
||||
nb = ttk.Notebook(self.root)
|
||||
nb.pack(fill=tk.BOTH, expand=True, padx=6, pady=(0, 4))
|
||||
self.nb = ttk.Notebook(self.root)
|
||||
self.nb.pack(fill=tk.BOTH, expand=True, padx=6, pady=(0, 4))
|
||||
self.nb.bind("<<NotebookTabChanged>>", self._on_tab_changed)
|
||||
|
||||
for title, builder in [
|
||||
("Input / Output", self._tab_io),
|
||||
@@ -265,10 +324,14 @@ class AstrometryGUI:
|
||||
("Befehlsvorschau", self._tab_cmd),
|
||||
("⚙ Server Setup", self._tab_setup),
|
||||
]:
|
||||
f = ttk.Frame(nb, padding=6)
|
||||
nb.add(f, text=title)
|
||||
f = ttk.Frame(self.nb, padding=6)
|
||||
self.nb.add(f, text=title)
|
||||
builder(f)
|
||||
|
||||
self.results_tab = ttk.Frame(self.nb, padding=6)
|
||||
self._tab_results(self.results_tab)
|
||||
self.nb.add(self.results_tab, text="Remote-Ergebnisse")
|
||||
|
||||
btn_bar = ttk.Frame(self.root, padding=4)
|
||||
btn_bar.pack(fill=tk.X)
|
||||
|
||||
@@ -304,6 +367,22 @@ class AstrometryGUI:
|
||||
|
||||
self._current_task: asyncio.Future | None = None
|
||||
|
||||
def _build_menu(self):
|
||||
menubar = tk.Menu(self.root)
|
||||
|
||||
profile_menu = tk.Menu(menubar, tearoff=False)
|
||||
profile_menu.add_command(label="Verbindung laden…", command=self._menu_load_credentials)
|
||||
profile_menu.add_separator()
|
||||
profile_menu.add_command(label="Profil speichern…", command=self._save_profile)
|
||||
profile_menu.add_command(label="Profil laden…", command=self._load_profile)
|
||||
menubar.add_cascade(label="Profil", menu=profile_menu)
|
||||
|
||||
self.root.config(menu=menubar)
|
||||
|
||||
def _on_tab_changed(self, _event=None):
|
||||
if self.nb.select() == str(self.results_tab):
|
||||
self._refresh_results_tab()
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Verbindungs-Leiste
|
||||
# -----------------------------------------------------------------------
|
||||
@@ -348,6 +427,9 @@ class AstrometryGUI:
|
||||
"Öffnet einen Datei-Dialog um die lokale Astro-Bild-Datei auszuwählen."
|
||||
).grid(row=0, column=2, padx=4)
|
||||
|
||||
self.local_image_size_label = ttk.Label(uf, text="Größe: —", foreground="gray")
|
||||
self.local_image_size_label.grid(row=0, column=3, sticky=tk.W, padx=4, pady=3)
|
||||
|
||||
ttk.Label(uf, text="Remote-Verzeichnis:").grid(row=1, column=0, sticky=tk.W, padx=4, pady=3)
|
||||
tip(ttk.Entry(uf, textvariable=self.v_remote_dir),
|
||||
"Verzeichnis auf dem Server wohin die Datei hochgeladen wird.\n"
|
||||
@@ -358,9 +440,14 @@ class AstrometryGUI:
|
||||
"Überträgt die lokale Datei asynchron per SFTP auf den Server.\n"
|
||||
"Nach dem Upload wird der Remote-Pfad automatisch eingetragen.")
|
||||
self.upload_btn.grid(row=1, column=2, padx=4)
|
||||
tip(ttk.Button(uf, text="Remote-Inhalt l\u00f6schen", command=self._delete_remote_dir),
|
||||
"L\u00f6scht nur den Inhalt des angegebenen Remote-Verzeichnisses auf dem Server.\n"
|
||||
"Das Verzeichnis selbst bleibt erhalten.\n"
|
||||
"Vorher erscheint eine Sicherheitsabfrage."
|
||||
).grid(row=1, column=3, padx=4)
|
||||
|
||||
self.upload_progress = ttk.Progressbar(uf, mode="determinate", maximum=100)
|
||||
self.upload_progress.grid(row=2, column=0, columnspan=3, sticky=tk.EW, padx=4, pady=4)
|
||||
self.upload_progress.grid(row=2, column=0, columnspan=4, sticky=tk.EW, padx=4, pady=4)
|
||||
tip(self.upload_progress, "Fortschritt des Datei-Uploads in Prozent.")
|
||||
|
||||
rf = ttk.LabelFrame(parent, text="Eingabedatei auf Remote-Rechner", padding=6)
|
||||
@@ -492,6 +579,10 @@ class AstrometryGUI:
|
||||
("CPU-Limit (--cpulimit, s):", self.v_cpulimit,
|
||||
"Maximale Rechenzeit in Sekunden.\n"
|
||||
"300s ist ein guter Kompromiss. 0 = kein Limit."),
|
||||
("Plot-Skalierung (--plot-scale):", self.v_plot_scale,
|
||||
"Skaliert nur die erzeugten Plot-Bilder.\n"
|
||||
"0.25 erzeugt kleinere Plots, 2.0 größere.\n"
|
||||
"Hat keinen Einfluss auf die eigentliche Astrometrie."),
|
||||
("Downsampling (--downsample):", self.v_downsample,
|
||||
"Verkleinert das Bild vor der Verarbeitung.\n"
|
||||
"6 = 1/6 der Auflösung. Beschleunigt die Quellerkennung stark.\n"
|
||||
@@ -521,6 +612,23 @@ class AstrometryGUI:
|
||||
tooltip
|
||||
).grid(row=row, column=col * 2 + 1, sticky=tk.W, padx=(0, 4), pady=2)
|
||||
|
||||
plotf = ttk.LabelFrame(parent, text="Plot-Helfer", padding=6)
|
||||
plotf.pack(fill=tk.X, pady=(0, 8))
|
||||
plotf.columnconfigure(3, weight=1)
|
||||
|
||||
tip(ttk.Checkbutton(plotf, text="Plot-Skalierung automatisch aus lokaler Bildgröße", variable=self.v_plot_scale_auto),
|
||||
"Berechnet --plot-scale aus der langen Bildkante der lokal ausgewählten Datei.\n"
|
||||
"Manuelle Änderungen am Feld sind weiterhin möglich."
|
||||
).grid(row=0, column=0, columnspan=2, sticky=tk.W, padx=4, pady=2)
|
||||
ttk.Label(plotf, text="Zielkantenlänge (px):").grid(row=0, column=2, sticky=tk.W, padx=4, pady=2)
|
||||
tip(ttk.Entry(plotf, textvariable=self.v_plot_target_long_edge, width=10),
|
||||
"Die lange Kante der erzeugten Plots wird grob auf diesen Wert skaliert.\n"
|
||||
"Standard: 900 px."
|
||||
).grid(row=0, column=3, sticky=tk.W, padx=4, pady=2)
|
||||
tip(ttk.Button(plotf, text="Jetzt berechnen", command=self._recalculate_plot_scale),
|
||||
"Liest die Größe der lokalen Datei und setzt --plot-scale neu."
|
||||
).grid(row=0, column=4, sticky=tk.W, padx=4, pady=2)
|
||||
|
||||
ff = ttk.LabelFrame(parent, text="Schalter (Flags)", padding=6)
|
||||
ff.pack(fill=tk.X, pady=(0, 8))
|
||||
|
||||
@@ -547,7 +655,7 @@ class AstrometryGUI:
|
||||
("Weitermachen (--continue)", self.v_continue,
|
||||
"Überspringt bereits gelöste Bilder (prüft ob .solved-Datei existiert).\n"
|
||||
"Ideal für unterbrochene Batch-Verarbeitungen."),
|
||||
("SExtractor nutzen (--use-sextractor)", self.v_sextractor,
|
||||
("SExtractor nutzen (--use-source-extractor)", self.v_sextractor,
|
||||
"Verwendet SExtractor statt des eingebauten Quellenerkennungs-Algorithmus.\n"
|
||||
"Muss auf dem Server installiert sein. Oft besser bei schwierigen Bildern."),
|
||||
("Als FITS-Bild behandeln (--fits-image)", self.v_fits_image,
|
||||
@@ -685,6 +793,37 @@ class AstrometryGUI:
|
||||
" • Freier Speicherplatz"
|
||||
).pack(side=tk.LEFT, padx=4, pady=4)
|
||||
|
||||
def _tab_results(self, parent):
|
||||
head = ttk.Frame(parent)
|
||||
head.pack(fill=tk.X, pady=(0, 4))
|
||||
|
||||
tip(ttk.Label(head, text="Remote-Ergebnisse nach solve-field:"),
|
||||
"Zeigt den Inhalt des Remote-Verzeichnisses nach einem solve-field-Lauf an."
|
||||
).pack(side=tk.LEFT)
|
||||
tip(ttk.Button(head, text="Aktualisieren", command=self._refresh_results_tab),
|
||||
"Liest den Inhalt des aktuell eingestellten Remote-Verzeichnisses erneut vom Server ein."
|
||||
).pack(side=tk.RIGHT, padx=4)
|
||||
tip(ttk.Button(head, text="Remote-Inhalt löschen", command=self._delete_remote_dir),
|
||||
"Löscht den Inhalt des aktuell eingestellten Remote-Verzeichnisses auf dem Server."
|
||||
).pack(side=tk.RIGHT, padx=4)
|
||||
tip(ttk.Button(head, text="Herunterladen", command=self._download_selected_result),
|
||||
"Lädt die ausgewählte Remote-Datei per SFTP herunter."
|
||||
).pack(side=tk.RIGHT, padx=4)
|
||||
|
||||
self.results_info = ttk.Label(parent, text="Noch kein solve-field-Lauf abgeschlossen.", foreground="gray")
|
||||
self.results_info.pack(anchor=tk.W, pady=(0, 4))
|
||||
|
||||
cols = ("name", "size", "remote")
|
||||
self.results_tree = ttk.Treeview(parent, columns=cols, show="headings", height=16, selectmode="extended")
|
||||
self.results_tree.heading("name", text="Datei")
|
||||
self.results_tree.heading("size", text="Größe")
|
||||
self.results_tree.heading("remote", text="Remote-Pfad")
|
||||
self.results_tree.column("name", width=240, anchor=tk.W)
|
||||
self.results_tree.column("size", width=100, anchor=tk.E)
|
||||
self.results_tree.column("remote", width=520, anchor=tk.W)
|
||||
self.results_tree.pack(fill=tk.BOTH, expand=True)
|
||||
self.results_tree.bind("<Double-1>", lambda _e: self._download_selected_result())
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Befehl bauen
|
||||
# -----------------------------------------------------------------------
|
||||
@@ -713,7 +852,7 @@ class AstrometryGUI:
|
||||
flag("--resort", self.v_resort)
|
||||
flag("--continue", self.v_continue)
|
||||
flag("--no-delete-temp", self.v_no_del_temp)
|
||||
flag("--use-sextractor", self.v_sextractor)
|
||||
flag("--use-source-extractor", self.v_sextractor)
|
||||
flag("--fits-image", self.v_fits_image)
|
||||
flag("--no-verify", self.v_no_verify)
|
||||
flag("--just-augment", self.v_just_augment)
|
||||
@@ -754,6 +893,7 @@ class AstrometryGUI:
|
||||
|
||||
add("--depth", self.v_depth)
|
||||
add("--cpulimit", self.v_cpulimit)
|
||||
add("--plot-scale", self.v_plot_scale)
|
||||
add("--downsample", self.v_downsample)
|
||||
add("--odds-to-solve", self.v_odds_solve)
|
||||
add("--odds-to-reject", self.v_odds_reject)
|
||||
@@ -843,6 +983,195 @@ class AstrometryGUI:
|
||||
finally:
|
||||
self.root.after(0, lambda: self.upload_btn.config(state=tk.NORMAL))
|
||||
|
||||
def _delete_remote_dir(self):
|
||||
remote_dir = self.v_remote_dir.get().strip()
|
||||
if not remote_dir:
|
||||
messagebox.showwarning("Remote-Verzeichnis fehlt", "Bitte ein Remote-Verzeichnis angeben.")
|
||||
return
|
||||
if remote_dir == "/":
|
||||
messagebox.showerror("Ung\u00fcltiges Verzeichnis", "Das Root-Verzeichnis '/' darf nicht gel\u00f6scht werden.")
|
||||
return
|
||||
if not messagebox.askyesno(
|
||||
"Remote-Inhalt l\u00f6schen",
|
||||
f"Soll nur der Inhalt dieses Verzeichnisses auf dem Server rekursiv gel\u00f6scht werden?\n\n{remote_dir}"
|
||||
):
|
||||
return
|
||||
self._submit(self._async_delete_remote_dir(remote_dir))
|
||||
|
||||
async def _async_delete_remote_dir(self, remote_dir: str):
|
||||
quoted_dir = shlex.quote(remote_dir)
|
||||
cmd = (
|
||||
f"dir={quoted_dir}; "
|
||||
"if [ -z \"$dir\" ] || [ \"$dir\" = \"/\" ]; then "
|
||||
"echo '[FEHLER] Unsicheres Remote-Verzeichnis.'; exit 1; "
|
||||
"fi; "
|
||||
"if [ ! -e \"$dir\" ]; then "
|
||||
"echo '[INFO] Remote-Verzeichnis existiert nicht.'; exit 0; "
|
||||
"fi; "
|
||||
"find \"$dir\" -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +; "
|
||||
"echo \"[OK] Remote-Inhalt gel\u00f6scht: $dir\""
|
||||
)
|
||||
self._log(f"[INFO] L\u00f6sche Remote-Inhalt: {remote_dir}\n", "info")
|
||||
try:
|
||||
ssh = self._make_ssh()
|
||||
await ssh.connect()
|
||||
await ssh.exec_stream(cmd, self._log)
|
||||
await ssh.close()
|
||||
except Exception as exc:
|
||||
self._log(f"[FEHLER] Remote-Inhalt l\u00f6schen: {exc}\n", "error")
|
||||
|
||||
def _refresh_results_tab(self):
|
||||
remote_dir = self.v_remote_dir.get().strip()
|
||||
self.root.config(cursor="watch")
|
||||
self.nb.config(cursor="watch")
|
||||
self.results_tree.config(cursor="watch")
|
||||
self._submit(self._async_refresh_results_tab(remote_dir))
|
||||
|
||||
async def _async_refresh_results_tab(self, remote_dir: str, returncode: int | None = None):
|
||||
if not remote_dir:
|
||||
self.root.after(0, lambda: self._set_results_info("Kein Remote-Verzeichnis gesetzt."))
|
||||
self.root.after(0, lambda: self._set_results_items([]))
|
||||
return
|
||||
|
||||
quoted_dir = shlex.quote(remote_dir)
|
||||
cmd = (
|
||||
f"dir={quoted_dir}; "
|
||||
"if [ ! -e \"$dir\" ]; then "
|
||||
"echo 'Remote-Verzeichnis existiert nicht.'; exit 0; "
|
||||
"fi; "
|
||||
"find \"$dir\" -maxdepth 2 -type f -printf '%s\t%P\t%p\\n' | sort"
|
||||
)
|
||||
info = f"Remote-Verzeichnis: {remote_dir}"
|
||||
if returncode is not None:
|
||||
info += f" | solve-field Exit-Code: {returncode}"
|
||||
self.root.after(0, lambda: self._set_results_info(info))
|
||||
self.root.after(0, lambda: self._set_results_items([]))
|
||||
|
||||
entries: list[dict[str, str]] = []
|
||||
|
||||
def _capture(line: str):
|
||||
stripped = line.strip()
|
||||
if not stripped or stripped.startswith("[Prozess beendet"):
|
||||
return
|
||||
if "\t" not in stripped:
|
||||
return
|
||||
size, rel_path, full_path = stripped.split("\t", 2)
|
||||
entries.append({
|
||||
"name": rel_path or os.path.basename(full_path),
|
||||
"size": size,
|
||||
"remote": full_path,
|
||||
})
|
||||
|
||||
try:
|
||||
ssh = self._make_ssh()
|
||||
await ssh.connect()
|
||||
await ssh.exec_stream(cmd, _capture)
|
||||
await ssh.close()
|
||||
self.root.after(0, lambda: self._set_results_items(entries))
|
||||
self.root.after(0, self._clear_wait_cursor)
|
||||
except Exception as exc:
|
||||
self.root.after(0, lambda: self._set_results_info(f"[FEHLER] {exc}"))
|
||||
self.root.after(0, lambda: self._set_results_items([]))
|
||||
self.root.after(0, self._clear_wait_cursor)
|
||||
|
||||
def _set_results_info(self, text: str):
|
||||
self.results_info.config(text=text, foreground="gray")
|
||||
|
||||
def _set_results_items(self, entries: list[dict[str, str]]):
|
||||
self.results_files = {}
|
||||
for item in self.results_tree.get_children():
|
||||
self.results_tree.delete(item)
|
||||
for i, entry in enumerate(entries):
|
||||
item_id = f"result_{i}"
|
||||
self.results_files[item_id] = entry
|
||||
self.results_tree.insert(
|
||||
"",
|
||||
tk.END,
|
||||
iid=item_id,
|
||||
values=(
|
||||
entry["name"],
|
||||
self._format_size(entry["size"]),
|
||||
entry["remote"],
|
||||
),
|
||||
)
|
||||
self._autosize_results_columns()
|
||||
|
||||
def _autosize_results_columns(self):
|
||||
body_font = tkfont.nametofont("TkDefaultFont")
|
||||
head_font = tkfont.nametofont("TkHeadingFont")
|
||||
padding = 24
|
||||
|
||||
for col in ("name", "size", "remote"):
|
||||
header = self.results_tree.heading(col, "text") or col
|
||||
width = head_font.measure(header) + padding
|
||||
for item_id in self.results_tree.get_children():
|
||||
value = self.results_tree.set(item_id, col)
|
||||
width = max(width, body_font.measure(str(value)) + padding)
|
||||
self.results_tree.column(col, width=width)
|
||||
|
||||
def _clear_wait_cursor(self):
|
||||
self.root.config(cursor="")
|
||||
self.nb.config(cursor="")
|
||||
self.results_tree.config(cursor="")
|
||||
|
||||
def _format_size(self, size_text: str) -> str:
|
||||
try:
|
||||
size = int(size_text)
|
||||
except Exception:
|
||||
return size_text
|
||||
units = ["B", "KB", "MB", "GB", "TB"]
|
||||
value = float(size)
|
||||
for unit in units:
|
||||
if value < 1024 or unit == units[-1]:
|
||||
if unit == "B":
|
||||
return f"{int(value)} {unit}"
|
||||
return f"{value:.1f} {unit}"
|
||||
value /= 1024
|
||||
return size_text
|
||||
|
||||
def _download_selected_result(self):
|
||||
selection = self.results_tree.selection()
|
||||
if not selection:
|
||||
messagebox.showwarning("Keine Datei ausgewählt", "Bitte zuerst eine oder mehrere Dateien im Ergebnis-Tab auswählen.")
|
||||
return
|
||||
entries = []
|
||||
for item_id in selection:
|
||||
entry = self.results_files.get(item_id)
|
||||
if entry:
|
||||
entries.append(entry)
|
||||
if not entries:
|
||||
messagebox.showwarning("Datei fehlt", "Die ausgewählten Dateien konnten nicht gefunden werden.")
|
||||
return
|
||||
source_dir = os.path.dirname(self.v_local_file.get().strip()) if self.v_local_file.get().strip() else ""
|
||||
initial_dir = source_dir if source_dir and os.path.isdir(source_dir) else os.getcwd()
|
||||
local_dir = filedialog.askdirectory(
|
||||
title="Zielordner für Download auswählen",
|
||||
initialdir=initial_dir,
|
||||
)
|
||||
if not local_dir:
|
||||
return
|
||||
downloads = []
|
||||
for entry in entries:
|
||||
suggested = os.path.basename(entry["remote"])
|
||||
local_path = os.path.normpath(os.path.join(local_dir, suggested))
|
||||
downloads.append((entry["remote"], local_path))
|
||||
self._submit(self._async_download_results(downloads))
|
||||
|
||||
async def _async_download_results(self, downloads: list[tuple[str, str]]):
|
||||
try:
|
||||
ssh = self._make_ssh()
|
||||
await ssh.connect()
|
||||
for remote_path, local_path in downloads:
|
||||
self._log(f"[INFO] Lade Ergebnis herunter: {remote_path} → {local_path}\n", "info")
|
||||
os.makedirs(os.path.dirname(local_path), exist_ok=True)
|
||||
await ssh.download(remote_path, local_path)
|
||||
if not os.path.isfile(local_path):
|
||||
raise FileNotFoundError(f"Datei nach Download nicht gefunden: {local_path}")
|
||||
self._log(f"[OK] Download abgeschlossen: {local_path}\n", "ok")
|
||||
await ssh.close()
|
||||
except Exception as exc:
|
||||
self._log(f"[FEHLER] Download: {exc}\n", "error")
|
||||
|
||||
def _run(self):
|
||||
if not self.v_input_file.get():
|
||||
messagebox.showwarning("Keine Eingabedatei", "Bitte einen Dateipfad angeben.")
|
||||
@@ -855,10 +1184,13 @@ class AstrometryGUI:
|
||||
try:
|
||||
ssh = self._make_ssh()
|
||||
await ssh.connect()
|
||||
await ssh.exec_stream(cmd, self._log)
|
||||
rc = await ssh.exec_stream(cmd, self._log)
|
||||
await ssh.close()
|
||||
self._current_task = None
|
||||
await self._async_refresh_results_tab(self.v_remote_dir.get().strip(), rc)
|
||||
except Exception as exc:
|
||||
self._log(f"[FEHLER] {exc}\n", "error")
|
||||
self._current_task = None
|
||||
|
||||
def _kill(self):
|
||||
if self._current_task:
|
||||
@@ -882,6 +1214,132 @@ class AstrometryGUI:
|
||||
if not current or (current.endswith(".fits") and current.startswith(out_dir)):
|
||||
self.v_new_fits.set(auto_path)
|
||||
|
||||
def _on_local_file_changed(self, *_):
|
||||
path = self.v_local_file.get().strip()
|
||||
if not path or not os.path.isfile(path):
|
||||
self.local_image_size_label.config(text="Größe: —")
|
||||
else:
|
||||
try:
|
||||
width, height = self._read_image_size(path)
|
||||
self.local_image_size_label.config(text=f"Größe: {width} × {height}")
|
||||
except Exception:
|
||||
self.local_image_size_label.config(text="Größe: unbekannt")
|
||||
if self.v_plot_scale_auto.get():
|
||||
self._recalculate_plot_scale()
|
||||
|
||||
def _on_plot_scale_settings_changed(self, *_):
|
||||
if self.v_plot_scale_auto.get():
|
||||
self._recalculate_plot_scale()
|
||||
|
||||
def _recalculate_plot_scale(self):
|
||||
path = self.v_local_file.get().strip()
|
||||
if not path or not os.path.isfile(path):
|
||||
return
|
||||
try:
|
||||
target = float(self.v_plot_target_long_edge.get().replace(",", "."))
|
||||
if target <= 0:
|
||||
return
|
||||
width, height = self._read_image_size(path)
|
||||
long_edge = max(width, height)
|
||||
if long_edge <= 0:
|
||||
return
|
||||
scale = target / long_edge
|
||||
self.v_plot_scale.set(f"{scale:.3f}".rstrip("0").rstrip("."))
|
||||
except Exception:
|
||||
return
|
||||
|
||||
def _read_image_size(self, path: str) -> tuple[int, int]:
|
||||
ext = os.path.splitext(path)[1].lower()
|
||||
if ext in (".fits", ".fit", ".fts"):
|
||||
return self._read_fits_size(path)
|
||||
if ext == ".png":
|
||||
return self._read_png_size(path)
|
||||
if ext in (".jpg", ".jpeg"):
|
||||
return self._read_jpeg_size(path)
|
||||
if ext == ".gif":
|
||||
return self._read_gif_size(path)
|
||||
if ext == ".bmp":
|
||||
return self._read_bmp_size(path)
|
||||
raise ValueError("Nicht unterstütztes Bildformat")
|
||||
|
||||
def _read_fits_size(self, path: str) -> tuple[int, int]:
|
||||
width = height = None
|
||||
with open(path, "rb") as f:
|
||||
while True:
|
||||
block = f.read(2880)
|
||||
if not block:
|
||||
break
|
||||
for i in range(0, len(block), 80):
|
||||
card = block[i:i + 80].decode("ascii", errors="ignore")
|
||||
key = card[:8].strip()
|
||||
if key == "END":
|
||||
if width and height:
|
||||
return width, height
|
||||
break
|
||||
if "=" not in card:
|
||||
continue
|
||||
value = card[10:30].split("/")[0].strip()
|
||||
if key == "NAXIS1":
|
||||
width = int(value)
|
||||
elif key == "NAXIS2":
|
||||
height = int(value)
|
||||
raise ValueError("FITS-Bildgröße nicht lesbar")
|
||||
|
||||
def _read_png_size(self, path: str) -> tuple[int, int]:
|
||||
with open(path, "rb") as f:
|
||||
header = f.read(24)
|
||||
if header[:8] != b"\x89PNG\r\n\x1a\n":
|
||||
raise ValueError("Ungültige PNG-Datei")
|
||||
return struct.unpack(">II", header[16:24])
|
||||
|
||||
def _read_gif_size(self, path: str) -> tuple[int, int]:
|
||||
with open(path, "rb") as f:
|
||||
header = f.read(10)
|
||||
if header[:6] not in (b"GIF87a", b"GIF89a"):
|
||||
raise ValueError("Ungültige GIF-Datei")
|
||||
return struct.unpack("<HH", header[6:10])
|
||||
|
||||
def _read_bmp_size(self, path: str) -> tuple[int, int]:
|
||||
with open(path, "rb") as f:
|
||||
header = f.read(26)
|
||||
if header[:2] != b"BM":
|
||||
raise ValueError("Ungültige BMP-Datei")
|
||||
width, height = struct.unpack("<ii", header[18:26])
|
||||
return abs(width), abs(height)
|
||||
|
||||
def _read_jpeg_size(self, path: str) -> tuple[int, int]:
|
||||
with open(path, "rb") as f:
|
||||
if f.read(2) != b"\xff\xd8":
|
||||
raise ValueError("Ungültige JPEG-Datei")
|
||||
while True:
|
||||
marker_prefix = f.read(1)
|
||||
if not marker_prefix:
|
||||
break
|
||||
if marker_prefix != b"\xff":
|
||||
continue
|
||||
marker = f.read(1)
|
||||
while marker == b"\xff":
|
||||
marker = f.read(1)
|
||||
if marker in (b"\xd8", b"\xd9"):
|
||||
continue
|
||||
size_bytes = f.read(2)
|
||||
if len(size_bytes) != 2:
|
||||
break
|
||||
segment_size = struct.unpack(">H", size_bytes)[0]
|
||||
if marker in (
|
||||
b"\xc0", b"\xc1", b"\xc2", b"\xc3",
|
||||
b"\xc5", b"\xc6", b"\xc7",
|
||||
b"\xc9", b"\xca", b"\xcb",
|
||||
b"\xcd", b"\xce", b"\xcf",
|
||||
):
|
||||
data = f.read(5)
|
||||
if len(data) != 5:
|
||||
break
|
||||
height, width = struct.unpack(">HH", data[1:5])
|
||||
return width, height
|
||||
f.seek(segment_size - 2, os.SEEK_CUR)
|
||||
raise ValueError("JPEG-Bildgröße nicht lesbar")
|
||||
|
||||
def _browse_local(self):
|
||||
path = filedialog.askopenfilename(
|
||||
title="Astro-Bild auswählen",
|
||||
@@ -892,6 +1350,8 @@ class AstrometryGUI:
|
||||
)
|
||||
if path:
|
||||
self.v_local_file.set(path)
|
||||
if messagebox.askyesno("Datei hochladen", "Soll die ausgewählte Datei jetzt direkt auf den Server hochgeladen werden?"):
|
||||
self._upload()
|
||||
|
||||
def _refresh_cmd(self):
|
||||
cmd = self._build_command()
|
||||
@@ -902,6 +1362,110 @@ class AstrometryGUI:
|
||||
self.root.clipboard_clear()
|
||||
self.root.clipboard_append(self.cmd_text.get("1.0", tk.END).strip())
|
||||
|
||||
def _encrypt_text(self, text: str) -> str:
|
||||
if not text:
|
||||
return ""
|
||||
key = b"AstrometryGuiInternalKey-2026"
|
||||
plain = text.encode("utf-8")
|
||||
encrypted = bytes(b ^ key[i % len(key)] for i, b in enumerate(plain))
|
||||
return base64.b64encode(encrypted).decode("ascii")
|
||||
|
||||
def _decrypt_text(self, token: str) -> str:
|
||||
if not token:
|
||||
return ""
|
||||
key = b"AstrometryGuiInternalKey-2026"
|
||||
encrypted = base64.b64decode(token.encode("ascii"))
|
||||
plain = bytes(b ^ key[i % len(key)] for i, b in enumerate(encrypted))
|
||||
return plain.decode("utf-8")
|
||||
|
||||
def _collect_profile_data(self) -> dict:
|
||||
vars_data = {}
|
||||
for name, value in self.__dict__.items():
|
||||
if name.startswith("v_") and hasattr(value, "get"):
|
||||
vars_data[name] = value.get()
|
||||
if "v_pass" in vars_data:
|
||||
vars_data["v_pass"] = ""
|
||||
return {
|
||||
"format": 2,
|
||||
"variables": vars_data,
|
||||
"secrets": {
|
||||
"v_pass_enc": self._encrypt_text(self.v_pass.get()),
|
||||
},
|
||||
"idx_text": self.idx_text.get("1.0", tk.END).strip(),
|
||||
}
|
||||
|
||||
def _apply_profile_data(self, data: dict):
|
||||
vars_data = data.get("variables", {})
|
||||
for name, value in vars_data.items():
|
||||
var = getattr(self, name, None)
|
||||
if var is not None and hasattr(var, "set"):
|
||||
var.set(value)
|
||||
|
||||
secrets = data.get("secrets", {})
|
||||
encrypted_pass = secrets.get("v_pass_enc") or secrets.get("v_pass_dpapi")
|
||||
if encrypted_pass:
|
||||
try:
|
||||
self.v_pass.set(self._decrypt_text(encrypted_pass))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
self.idx_text.delete("1.0", tk.END)
|
||||
idx_text = data.get("idx_text", "")
|
||||
if idx_text:
|
||||
self.idx_text.insert("1.0", idx_text)
|
||||
|
||||
self._refresh_cmd()
|
||||
|
||||
def _save_profile(self):
|
||||
profile_dir = os.path.join(os.getcwd(), "profiles")
|
||||
os.makedirs(profile_dir, exist_ok=True)
|
||||
path = filedialog.asksaveasfilename(
|
||||
title="Profil speichern",
|
||||
initialdir=profile_dir,
|
||||
defaultextension=".json",
|
||||
filetypes=[("JSON-Dateien", "*.json"), ("Alle Dateien", "*.*")],
|
||||
)
|
||||
if not path:
|
||||
return
|
||||
data = self._collect_profile_data()
|
||||
try:
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
json.dump(data, f, ensure_ascii=False, indent=2)
|
||||
self._log(f"[OK] Profil gespeichert: {path}\n", "ok")
|
||||
except Exception as exc:
|
||||
messagebox.showerror("Profil speichern", f"Speichern fehlgeschlagen:\n{exc}")
|
||||
|
||||
def _load_profile(self):
|
||||
profile_dir = os.path.join(os.getcwd(), "profiles")
|
||||
path = filedialog.askopenfilename(
|
||||
title="Profil laden",
|
||||
initialdir=profile_dir if os.path.isdir(profile_dir) else os.getcwd(),
|
||||
filetypes=[("JSON-Dateien", "*.json"), ("Alle Dateien", "*.*")],
|
||||
)
|
||||
if not path:
|
||||
return
|
||||
try:
|
||||
with open(path, "r", encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
self._apply_profile_data(data)
|
||||
self._log(f"[OK] Profil geladen: {path}\n", "ok")
|
||||
except Exception as exc:
|
||||
messagebox.showerror("Profil laden", f"Laden fehlgeschlagen:\n{exc}")
|
||||
|
||||
def _menu_load_credentials(self):
|
||||
path = filedialog.askopenfilename(
|
||||
title="Zugangsdaten laden",
|
||||
initialdir=os.getcwd(),
|
||||
filetypes=[("JSON-Dateien", "*.json"), ("Alle Dateien", "*.*")],
|
||||
)
|
||||
if not path:
|
||||
return
|
||||
try:
|
||||
self._load_credentials_from_file(path)
|
||||
self._log(f"[OK] Zugangsdaten geladen: {path}\n", "ok")
|
||||
except Exception as exc:
|
||||
messagebox.showerror("Zugangsdaten laden", f"Laden fehlgeschlagen:\n{exc}")
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Log (thread-sicher via Queue)
|
||||
# -----------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
{
|
||||
"format": 2,
|
||||
"variables": {
|
||||
"v_host": "10.42.44.25",
|
||||
"v_port": 22,
|
||||
"v_user": "eskimue",
|
||||
"v_pass": "",
|
||||
"v_local_file": "",
|
||||
"v_remote_dir": "/tmp/astrometry",
|
||||
"v_input_file": "",
|
||||
"v_out_prefix": "",
|
||||
"v_out_dir": "/tmp/astrometry",
|
||||
"v_new_fits": "",
|
||||
"v_wcs": "",
|
||||
"v_corr": "",
|
||||
"v_rdls": "",
|
||||
"v_axy": "",
|
||||
"v_solved": "",
|
||||
"v_match": "",
|
||||
"v_scale_units": "degwidth",
|
||||
"v_scale_low": "20",
|
||||
"v_scale_high": "30",
|
||||
"v_scale_est": "",
|
||||
"v_scale_err": "",
|
||||
"v_ra": "",
|
||||
"v_dec": "",
|
||||
"v_radius": "1.0",
|
||||
"v_depth": "",
|
||||
"v_cpulimit": "300",
|
||||
"v_plot_scale": "",
|
||||
"v_plot_scale_auto": true,
|
||||
"v_plot_target_long_edge": "900",
|
||||
"v_downsample": "6",
|
||||
"v_tweak_order": "2",
|
||||
"v_odds_solve": "",
|
||||
"v_odds_reject": "",
|
||||
"v_odds_tune": "",
|
||||
"v_objs": "",
|
||||
"v_pixel_error": "",
|
||||
"v_parity": "both",
|
||||
"v_overwrite": true,
|
||||
"v_no_plots": false,
|
||||
"v_no_tweak": false,
|
||||
"v_resort": false,
|
||||
"v_verbose": false,
|
||||
"v_timestamp": true,
|
||||
"v_no_del_temp": false,
|
||||
"v_continue": false,
|
||||
"v_sextractor": false,
|
||||
"v_fits_image": false,
|
||||
"v_no_verify": false,
|
||||
"v_just_augment": false,
|
||||
"v_invert": true,
|
||||
"v_extra": ""
|
||||
},
|
||||
"secrets": {
|
||||
"v_pass_enc": "EQERAQYJAA=="
|
||||
},
|
||||
"idx_text": ""
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
{
|
||||
"format": 2,
|
||||
"variables": {
|
||||
"v_host": "10.42.44.25",
|
||||
"v_port": 22,
|
||||
"v_user": "eskimue",
|
||||
"v_pass": "",
|
||||
"v_local_file": "C:/Users/ich/Cloud__Museum/Museumsentwicklung/Shop/Faksimile/2026/Heinlein Dieter/IMG_410328-1956_08_30-20000+2000-Te3-26-50.png",
|
||||
"v_remote_dir": "/tmp/astrometry",
|
||||
"v_input_file": "/tmp/astrometry/IMG_410328-1956_08_30-20000+2000-Te3-26-50.png",
|
||||
"v_out_prefix": "",
|
||||
"v_out_dir": "/tmp/astrometry",
|
||||
"v_new_fits": "/tmp/astrometry/IMG_410328-1956_08_30-20000+2000-Te3-26-50.fits",
|
||||
"v_wcs": "",
|
||||
"v_corr": "",
|
||||
"v_rdls": "",
|
||||
"v_axy": "",
|
||||
"v_solved": "",
|
||||
"v_match": "",
|
||||
"v_scale_units": "degwidth",
|
||||
"v_scale_low": "20",
|
||||
"v_scale_high": "30",
|
||||
"v_scale_est": "",
|
||||
"v_scale_err": "",
|
||||
"v_ra": "",
|
||||
"v_dec": "",
|
||||
"v_radius": "1.0",
|
||||
"v_depth": "",
|
||||
"v_cpulimit": "300",
|
||||
"v_plot_scale": "0.15",
|
||||
"v_plot_scale_auto": true,
|
||||
"v_plot_target_long_edge": "900",
|
||||
"v_downsample": "6",
|
||||
"v_tweak_order": "2",
|
||||
"v_odds_solve": "",
|
||||
"v_odds_reject": "",
|
||||
"v_odds_tune": "",
|
||||
"v_objs": "",
|
||||
"v_pixel_error": "",
|
||||
"v_parity": "both",
|
||||
"v_overwrite": true,
|
||||
"v_no_plots": false,
|
||||
"v_no_tweak": false,
|
||||
"v_resort": false,
|
||||
"v_verbose": false,
|
||||
"v_timestamp": true,
|
||||
"v_no_del_temp": false,
|
||||
"v_continue": false,
|
||||
"v_sextractor": false,
|
||||
"v_fits_image": false,
|
||||
"v_no_verify": false,
|
||||
"v_just_augment": false,
|
||||
"v_invert": true,
|
||||
"v_extra": ""
|
||||
},
|
||||
"secrets": {
|
||||
"v_pass_enc": "EQERAQYJAA=="
|
||||
},
|
||||
"idx_text": ""
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"host": "10.42.44.25",
|
||||
"port": 22,
|
||||
"user": "eskimue",
|
||||
"password": "Preside"
|
||||
}
|
||||
Reference in New Issue
Block a user