meteorlens 0.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- meteorlens/__init__.py +4 -0
- meteorlens/__main__.py +4 -0
- meteorlens/astrometry.py +398 -0
- meteorlens/calibrate.py +797 -0
- meteorlens/capture.py +225 -0
- meteorlens/cli.py +103 -0
- meteorlens/config.py +504 -0
- meteorlens/control.py +154 -0
- meteorlens/data/config.example.ini +125 -0
- meteorlens/data/mask.example.png +0 -0
- meteorlens/data/showers.csv +112 -0
- meteorlens/data/star_names.csv +36 -0
- meteorlens/data/stars_hip.csv +2817 -0
- meteorlens/detect.py +377 -0
- meteorlens/filters.py +4 -0
- meteorlens/media.py +120 -0
- meteorlens/metrics.py +96 -0
- meteorlens/outputs.py +126 -0
- meteorlens/runner.py +404 -0
- meteorlens/showers.py +129 -0
- meteorlens/store.py +705 -0
- meteorlens/synth.py +87 -0
- meteorlens/thumbs.py +113 -0
- meteorlens/video.py +106 -0
- meteorlens/web/__init__.py +4 -0
- meteorlens/web/app.py +96 -0
- meteorlens/web/formatting.py +91 -0
- meteorlens/web/labels.py +44 -0
- meteorlens/web/live.py +35 -0
- meteorlens/web/routes/__init__.py +7 -0
- meteorlens/web/routes/api.py +155 -0
- meteorlens/web/routes/control.py +22 -0
- meteorlens/web/routes/media.py +65 -0
- meteorlens/web/routes/pages.py +105 -0
- meteorlens/web/setup.py +325 -0
- meteorlens/web/skymap.py +180 -0
- meteorlens/web/static/app.css +171 -0
- meteorlens/web/static/js/dashboard.js +380 -0
- meteorlens/web/static/js/gallery.js +84 -0
- meteorlens/web/static/js/header.js +26 -0
- meteorlens/web/static/js/settings.js +54 -0
- meteorlens/web/static/js/setup.js +519 -0
- meteorlens/web/static/setup.css +114 -0
- meteorlens/web/templates/_macros.html +71 -0
- meteorlens/web/templates/_nav.html +7 -0
- meteorlens/web/templates/base.html +30 -0
- meteorlens/web/templates/dashboard.html +94 -0
- meteorlens/web/templates/gallery.html +33 -0
- meteorlens/web/templates/settings.html +27 -0
- meteorlens/web/templates/setup.html +290 -0
- meteorlens-0.0.0.dist-info/METADATA +283 -0
- meteorlens-0.0.0.dist-info/RECORD +57 -0
- meteorlens-0.0.0.dist-info/WHEEL +5 -0
- meteorlens-0.0.0.dist-info/entry_points.txt +3 -0
- meteorlens-0.0.0.dist-info/licenses/LICENSE +21 -0
- meteorlens-0.0.0.dist-info/licenses/NOTICE +10 -0
- meteorlens-0.0.0.dist-info/top_level.txt +1 -0
meteorlens/__init__.py
ADDED
meteorlens/__main__.py
ADDED
meteorlens/astrometry.py
ADDED
|
@@ -0,0 +1,398 @@
|
|
|
1
|
+
"""Astrometria: model kamery z kalibrácie a prevod pixelov na výšku/azimut.
|
|
2
|
+
|
|
3
|
+
Čisté numpy (bez scipy/pillow) — importuje to produkčná analýza aj samostatný
|
|
4
|
+
`calibrate.py`. Model kamery (fisheye, stred obrazu pevný) aj prevod narovnaného
|
|
5
|
+
obrazu analyzátora späť na pôvodné pixely tu; zvyšok kalibračného nástroja
|
|
6
|
+
(hľadanie riešenia, katalóg) ostáva v `calibrate.py`.
|
|
7
|
+
"""
|
|
8
|
+
import datetime as dt
|
|
9
|
+
import json
|
|
10
|
+
import math
|
|
11
|
+
from pathlib import Path
|
|
12
|
+
|
|
13
|
+
import numpy as np
|
|
14
|
+
|
|
15
|
+
# ───────────────────────────── refrakcia ─────────────────────────────
|
|
16
|
+
|
|
17
|
+
def refract_true_to_app(alt):
|
|
18
|
+
"""Zdanlivá výška (stupne) z pravej – Sæmundsson, štandardná atmosféra."""
|
|
19
|
+
alt = np.asarray(alt, float)
|
|
20
|
+
h = np.clip(alt, -1.0, 90.0)
|
|
21
|
+
r = np.maximum(1.02 / np.tan(np.radians(h + 10.3 / (h + 5.11))) / 60.0, 0.0)
|
|
22
|
+
return np.where(alt < -1.0, alt, alt + r)
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def refract_app_to_true(alt):
|
|
26
|
+
"""Pravá výška z pozorovanej – Bennett."""
|
|
27
|
+
alt = np.asarray(alt, float)
|
|
28
|
+
h = np.clip(alt, -1.0, 90.0)
|
|
29
|
+
r = np.maximum(1.0 / np.tan(np.radians(h + 7.31 / (h + 4.4))) / 60.0, 0.0)
|
|
30
|
+
return np.where(alt < -1.0, alt, alt - r)
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def unit_vectors(alt, az):
|
|
34
|
+
h, a = np.radians(alt), np.radians(az)
|
|
35
|
+
return np.stack([np.cos(h) * np.sin(a), np.cos(h) * np.cos(a), np.sin(h)], axis=-1)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
# ───────────────────────────── model kamery ─────────────────────────────
|
|
39
|
+
|
|
40
|
+
def rot_matrix(az0, alt0, roll):
|
|
41
|
+
"""Riadky = osi kamery (x doprava, y nadol, z dopredu) vyjadrené v ENU (východ, sever, hore)."""
|
|
42
|
+
a, h, r = math.radians(az0), math.radians(alt0), math.radians(roll)
|
|
43
|
+
fwd = np.array([math.cos(h) * math.sin(a), math.cos(h) * math.cos(a), math.sin(h)])
|
|
44
|
+
right = np.array([math.cos(a), -math.sin(a), 0.0])
|
|
45
|
+
down = np.cross(fwd, right)
|
|
46
|
+
x = math.cos(r) * right + math.sin(r) * down
|
|
47
|
+
y = -math.sin(r) * right + math.cos(r) * down
|
|
48
|
+
return np.vstack([x, y, fwd])
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def project_vec(V, M, f, k1, k2, cx, cy):
|
|
52
|
+
c = V @ M.T
|
|
53
|
+
th = np.arccos(np.clip(c[:, 2], -1, 1))
|
|
54
|
+
s = np.hypot(c[:, 0], c[:, 1])
|
|
55
|
+
r = f * th * (1 + k1 * th**2 + k2 * th**4)
|
|
56
|
+
with np.errstate(all="ignore"):
|
|
57
|
+
k = np.where(s > 1e-12, r / s, 0.0)
|
|
58
|
+
return cx + k * c[:, 0], cy + k * c[:, 1], th
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
class CameraModel:
|
|
62
|
+
"""Fisheye: r = f·θ·(1 + k1·θ² + k2·θ⁴) (θ = uhol od optickej osi v rad), stred obrazu pevný."""
|
|
63
|
+
|
|
64
|
+
def __init__(self, az0, alt0, roll, f, k1=0.0, k2=0.0, width=2688, height=1520, cx=None, cy=None):
|
|
65
|
+
self.az0, self.alt0, self.roll = float(az0), float(alt0), float(roll)
|
|
66
|
+
self.f, self.k1, self.k2 = float(f), float(k1), float(k2)
|
|
67
|
+
self.width, self.height = int(width), int(height)
|
|
68
|
+
self.cx = self.width / 2 if cx is None else float(cx)
|
|
69
|
+
self.cy = self.height / 2 if cy is None else float(cy)
|
|
70
|
+
|
|
71
|
+
@property
|
|
72
|
+
def M(self):
|
|
73
|
+
return rot_matrix(self.az0, self.alt0, self.roll)
|
|
74
|
+
|
|
75
|
+
def altaz_to_pix(self, alt_app, az):
|
|
76
|
+
V = unit_vectors(np.atleast_1d(alt_app), np.atleast_1d(az))
|
|
77
|
+
return project_vec(V, self.M, self.f, self.k1, self.k2, self.cx, self.cy)
|
|
78
|
+
|
|
79
|
+
def pix_to_altaz(self, u, v, true_alt=True):
|
|
80
|
+
"""Pixel -> (výška, azimut) v stupňoch. true_alt=True odráta refrakciu."""
|
|
81
|
+
u, v = np.atleast_1d(np.asarray(u, float)), np.atleast_1d(np.asarray(v, float))
|
|
82
|
+
dx, dy = u - self.cx, v - self.cy
|
|
83
|
+
r = np.hypot(dx, dy)
|
|
84
|
+
td = r / self.f
|
|
85
|
+
th = td.copy()
|
|
86
|
+
for _ in range(30):
|
|
87
|
+
g = th * (1 + self.k1 * th**2 + self.k2 * th**4) - td
|
|
88
|
+
dg = 1 + 3 * self.k1 * th**2 + 5 * self.k2 * th**4
|
|
89
|
+
th = th - g / dg
|
|
90
|
+
phi = np.arctan2(dy, dx)
|
|
91
|
+
c = np.stack([np.sin(th) * np.cos(phi), np.sin(th) * np.sin(phi), np.cos(th)], axis=-1)
|
|
92
|
+
enu = c @ self.M
|
|
93
|
+
alt = np.degrees(np.arcsin(np.clip(enu[:, 2], -1, 1)))
|
|
94
|
+
az = np.degrees(np.arctan2(enu[:, 0], enu[:, 1])) % 360.0
|
|
95
|
+
if true_alt:
|
|
96
|
+
alt = refract_app_to_true(alt)
|
|
97
|
+
return alt, az
|
|
98
|
+
|
|
99
|
+
def angular_distance(self, u1, v1, u2, v2):
|
|
100
|
+
"""Uhlová vzdialenosť dvoch pixelov v stupňoch (cez smerové vektory, správne aj pri okraji)."""
|
|
101
|
+
a1, z1 = self.pix_to_altaz(u1, v1, true_alt=False)
|
|
102
|
+
a2, z2 = self.pix_to_altaz(u2, v2, true_alt=False)
|
|
103
|
+
d = np.sum(unit_vectors(a1, z1) * unit_vectors(a2, z2), axis=-1)
|
|
104
|
+
return np.degrees(np.arccos(np.clip(d, -1, 1)))
|
|
105
|
+
|
|
106
|
+
def fov(self):
|
|
107
|
+
w, h, cx, cy = self.width, self.height, self.cx, self.cy
|
|
108
|
+
hor = self.angular_distance(0, cy, w, cy)[0]
|
|
109
|
+
ver = self.angular_distance(cx, 0, cx, h)[0]
|
|
110
|
+
dia = self.angular_distance(0, 0, w, h)[0]
|
|
111
|
+
return float(hor), float(ver), float(dia)
|
|
112
|
+
|
|
113
|
+
def to_dict(self):
|
|
114
|
+
return dict(az0=self.az0, alt0=self.alt0, roll=self.roll, f=self.f, k1=self.k1, k2=self.k2,
|
|
115
|
+
width=self.width, height=self.height, cx=self.cx, cy=self.cy)
|
|
116
|
+
|
|
117
|
+
@classmethod
|
|
118
|
+
def from_dict(cls, d):
|
|
119
|
+
return cls(d["az0"], d["alt0"], d["roll"], d["f"], d.get("k1", 0), d.get("k2", 0),
|
|
120
|
+
d.get("width", 2688), d.get("height", 1520), d.get("cx"), d.get("cy"))
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
def load_calibration(path):
|
|
124
|
+
"""Načíta calibration.json -> (CameraModel, surový slovník)."""
|
|
125
|
+
data = json.loads(Path(path).read_text(encoding="utf-8"))
|
|
126
|
+
return CameraModel.from_dict(data["camera"]), data
|
|
127
|
+
|
|
128
|
+
|
|
129
|
+
def calibration_id(data):
|
|
130
|
+
"""Krátky identifikátor kalibrácie pre riadky v DB (dátum vytvorenia, inak čas merania)."""
|
|
131
|
+
return (data.get("created_utc") or data.get("time_utc") or "").strip()
|
|
132
|
+
|
|
133
|
+
|
|
134
|
+
# ─────────────────── narovnaný obraz analyzátora -> pôvodné pixely ───────────────────
|
|
135
|
+
|
|
136
|
+
def narovnany_na_povodny(xn, yn, map1, map2, W, H, orig_w, orig_h):
|
|
137
|
+
"""Normalizované súradnice (0–1) v narovnanom obraze W×H -> pixely pôvodného obrazu.
|
|
138
|
+
|
|
139
|
+
`map1, map2` sú mapy z `get_undistort_maps(W, H)` (rovnaký tvar ako pri detekcii):
|
|
140
|
+
`dst(x, y) = src(map1(x, y), map2(x, y))`, takže pre pixel narovnaného obrazu je zdroj
|
|
141
|
+
(map1, map2) v danom bode. Hodnoty sú v zmenšenom pôvodnom obraze (šírka W), preto sa
|
|
142
|
+
násobia `orig_w / W`. Bod mimo zdroja -> NaN.
|
|
143
|
+
"""
|
|
144
|
+
x = np.asarray(xn, float) * W
|
|
145
|
+
y = np.asarray(yn, float) * H
|
|
146
|
+
x0 = np.clip(np.floor(x).astype(int), 0, W - 2)
|
|
147
|
+
y0 = np.clip(np.floor(y).astype(int), 0, H - 2)
|
|
148
|
+
fx, fy = x - x0, y - y0
|
|
149
|
+
|
|
150
|
+
def lut(m):
|
|
151
|
+
return (m[y0, x0] * (1 - fx) * (1 - fy) + m[y0, x0 + 1] * fx * (1 - fy)
|
|
152
|
+
+ m[y0 + 1, x0] * (1 - fx) * fy + m[y0 + 1, x0 + 1] * fx * fy)
|
|
153
|
+
|
|
154
|
+
sx, sy = lut(map1), lut(map2) # súradnice v zmenšenom pôvodnom obraze
|
|
155
|
+
sx, sy = np.asarray(sx) * orig_w / W, np.asarray(sy) * orig_h / H
|
|
156
|
+
bad = (sx < 0) | (sx >= orig_w) | (sy < 0) | (sy >= orig_h)
|
|
157
|
+
return np.where(bad, np.nan, sx), np.where(bad, np.nan, sy)
|
|
158
|
+
|
|
159
|
+
|
|
160
|
+
def event_angles(cal, x0, y0, x1, y1, map1, map2, W, H):
|
|
161
|
+
"""Uhly stopy v stupňoch: (az0, alt0, az1, alt1, len_deg, dist_px).
|
|
162
|
+
|
|
163
|
+
`x0/y0/x1/y1` sú normalizované (0–1) v narovnanom obraze W×H (ako v CSV).
|
|
164
|
+
`dist_px` je vzdialenosť koncov v pixeloch narovnaného obrazu (na speed_deg_s).
|
|
165
|
+
Vráti None, ak sa niektorý bod nedá preniesť do pôvodného obrazu (mimo zdroja).
|
|
166
|
+
"""
|
|
167
|
+
u0, v0 = narovnany_na_povodny(x0, y0, map1, map2, W, H, cal.width, cal.height)
|
|
168
|
+
u1, v1 = narovnany_na_povodny(x1, y1, map1, map2, W, H, cal.width, cal.height)
|
|
169
|
+
if np.isnan(u0) or np.isnan(v0) or np.isnan(u1) or np.isnan(v1):
|
|
170
|
+
return None
|
|
171
|
+
alt0, az0 = cal.pix_to_altaz(u0, v0)
|
|
172
|
+
alt1, az1 = cal.pix_to_altaz(u1, v1)
|
|
173
|
+
len_deg = float(cal.angular_distance(u0, v0, u1, v1)[0])
|
|
174
|
+
dist_px = math.hypot((x1 - x0) * W, (y1 - y0) * H)
|
|
175
|
+
return (float(az0[0]), float(alt0[0]), float(az1[0]), float(alt1[0]), len_deg, dist_px)
|
|
176
|
+
|
|
177
|
+
|
|
178
|
+
def path_angles(cal, xs, ys, ts, map1, map2, W, H):
|
|
179
|
+
"""Presná uhlová dĺžka a rýchlosť stopy z jej postupnosti stredov (nie z koncových bodov).
|
|
180
|
+
|
|
181
|
+
`xs, ys` = normalizované (0–1) súradnice stredov v narovnanom obraze W×H (ako `x0/y0` v CSV),
|
|
182
|
+
`ts` = ich časy v sekundách. Body sa prevedú do pôvodného obrazu (rovnako ako `event_angles`),
|
|
183
|
+
na výšku/azimut a spočíta sa súčet uhlových vzdialeností po sebe idúcich bodov (dĺžka oblúka,
|
|
184
|
+
nie tetiva koncov). Rýchlosť je 0,9·dĺžka / čas, kým hlava prejde 90 % dĺžky — rovnaká logika
|
|
185
|
+
ako `speed_px_s`, len v stupňoch. Vráti `(len_deg, speed_deg_s)` alebo `None`, ak je platných
|
|
186
|
+
bodov priveľa málo, padnú mimo zdroja alebo je dĺžka nulová.
|
|
187
|
+
"""
|
|
188
|
+
if xs is None or len(xs) < 2:
|
|
189
|
+
return None
|
|
190
|
+
xs, ys, ts = np.asarray(xs, float), np.asarray(ys, float), np.asarray(ts, float)
|
|
191
|
+
u, v = narovnany_na_povodny(xs, ys, map1, map2, W, H, cal.width, cal.height)
|
|
192
|
+
ok = np.isfinite(u) & np.isfinite(v)
|
|
193
|
+
if int(np.count_nonzero(ok)) < 2:
|
|
194
|
+
return None
|
|
195
|
+
u, v, t = u[ok], v[ok], ts[ok]
|
|
196
|
+
alt, az = cal.pix_to_altaz(u, v)
|
|
197
|
+
vec = unit_vectors(alt, az)
|
|
198
|
+
step = np.degrees(np.arccos(np.clip(np.sum(vec[:-1] * vec[1:], axis=-1), -1, 1)))
|
|
199
|
+
cum = np.cumsum(step)
|
|
200
|
+
if cum[-1] <= 0:
|
|
201
|
+
return None
|
|
202
|
+
i = int(np.searchsorted(cum, 0.9 * cum[-1]))
|
|
203
|
+
grow = float(t[min(i + 1, len(t) - 1)] - t[0])
|
|
204
|
+
return (float(cum[-1]), (0.9 * float(cum[-1]) / grow if grow > 1e-9 else None))
|
|
205
|
+
|
|
206
|
+
|
|
207
|
+
# ─────────────── alt/az -> RA/Dec (G4): inverzia catalog_altaz z calibrate.py ───────────────
|
|
208
|
+
# Rovníková sústava J2000 — rádiant je v nej pevný naprieč nocami (v alt/az sa obloha točí).
|
|
209
|
+
# Model: precesia (bez nutácie a aberrácie, < 0,01°), geometrická výška (bez refrakcie) —
|
|
210
|
+
# rovnaké výšky, aké vracia `CameraModel.pix_to_altaz(true_alt=True)` aj `catalog_altaz`.
|
|
211
|
+
|
|
212
|
+
def julian_date(when):
|
|
213
|
+
"""Gregoriánsky UTC čas -> juliánske dátum (JD)."""
|
|
214
|
+
return when.timestamp() / 86400.0 + 2440587.5
|
|
215
|
+
|
|
216
|
+
|
|
217
|
+
def gmst(when):
|
|
218
|
+
"""Greenwichský stredný hviezdny čas (stupne, 0–360) pre daný UTC okamih."""
|
|
219
|
+
jd = julian_date(when)
|
|
220
|
+
T = (jd - 2451545.0) / 36525.0
|
|
221
|
+
return (280.46061837 + 360.98564736629 * (jd - 2451545.0) + 0.000387933 * T ** 2
|
|
222
|
+
- T ** 3 / 38710000.0) % 360.0
|
|
223
|
+
|
|
224
|
+
|
|
225
|
+
def _precession_angles(jd):
|
|
226
|
+
"""Precesné uhly zeta, z, theta (rad) — rovnaké konštanty ako `calibrate.catalog_altaz`."""
|
|
227
|
+
T = (jd - 2451545.0) / 36525.0
|
|
228
|
+
zeta = math.radians((2306.2181 * T + 0.30188 * T ** 2 + 0.017998 * T ** 3) / 3600.0)
|
|
229
|
+
z = math.radians((2306.2181 * T + 1.09468 * T ** 2 + 0.018203 * T ** 3) / 3600.0)
|
|
230
|
+
th = math.radians((2004.3109 * T - 0.42665 * T ** 2 - 0.041833 * T ** 3) / 3600.0)
|
|
231
|
+
return zeta, z, th
|
|
232
|
+
|
|
233
|
+
|
|
234
|
+
def _rot_z(v, a):
|
|
235
|
+
c, s = math.cos(a), math.sin(a)
|
|
236
|
+
return np.stack([v[..., 0] * c + v[..., 1] * s, v[..., 1] * c - v[..., 0] * s, v[..., 2]], axis=-1)
|
|
237
|
+
|
|
238
|
+
|
|
239
|
+
def _rot_x(v, a):
|
|
240
|
+
c, s = math.cos(a), math.sin(a)
|
|
241
|
+
return np.stack([v[..., 0], v[..., 1] * c - v[..., 2] * s, v[..., 1] * s + v[..., 2] * c], axis=-1)
|
|
242
|
+
|
|
243
|
+
|
|
244
|
+
def unit_vector(ra, dec):
|
|
245
|
+
"""J2000 (stupne) -> jednotkový vektor; z = severný nebeský pól, x = RA 90°, y = RA 0°."""
|
|
246
|
+
ra, dec = np.radians(ra), np.radians(dec)
|
|
247
|
+
return np.stack([np.cos(dec) * np.sin(ra), np.cos(dec) * np.cos(ra), np.sin(dec)], axis=-1)
|
|
248
|
+
|
|
249
|
+
|
|
250
|
+
def altaz_to_radec(alt, az, when, lat, lon):
|
|
251
|
+
"""Výška/azimut (stupne, geometrická výška) + okamih + poloha -> RA/Dec J2000 (stupne).
|
|
252
|
+
|
|
253
|
+
Presná inverzia `calibrate.catalog_altaz` (bez vlastného pohybu — meteory ho nemajú).
|
|
254
|
+
Podporuje polia numpy. Vracia (ra, dec) v stupňoch, ra v [0, 360).
|
|
255
|
+
"""
|
|
256
|
+
alt, az = np.radians(np.asarray(alt, float)), np.radians(np.asarray(az, float))
|
|
257
|
+
phi = math.radians(lat)
|
|
258
|
+
jd = julian_date(when)
|
|
259
|
+
sin_dec = math.sin(phi) * np.sin(alt) + math.cos(phi) * np.cos(alt) * np.cos(az)
|
|
260
|
+
dec_d = np.arcsin(np.clip(sin_dec, -1, 1))
|
|
261
|
+
H = np.arctan2(-np.cos(alt) * np.sin(az),
|
|
262
|
+
(np.sin(alt) - math.sin(phi) * sin_dec) / max(math.cos(phi), 1e-12))
|
|
263
|
+
ra_d = np.radians(gmst(when) + lon) - H
|
|
264
|
+
nd = np.stack([np.cos(dec_d) * np.sin(ra_d), np.cos(dec_d) * np.cos(ra_d), np.sin(dec_d)], axis=-1)
|
|
265
|
+
zeta, z, th = _precession_angles(jd)
|
|
266
|
+
n0 = _rot_z(_rot_x(_rot_z(nd, -z), -th), -zeta) # date -> J2000 (transponované rotácie)
|
|
267
|
+
ra = np.degrees(np.arctan2(n0[..., 0], n0[..., 1])) % 360.0
|
|
268
|
+
dec = np.degrees(np.arcsin(np.clip(n0[..., 2], -1, 1)))
|
|
269
|
+
return ra, dec
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
def radec_to_altaz(ra, dec, when, lat, lon):
|
|
273
|
+
"""RA/Dec J2000 (stupne) + okamih + poloha -> (výška, azimut) v stupňoch, geometrická výška.
|
|
274
|
+
|
|
275
|
+
Presná inverzia `altaz_to_radec` (precesia J2000 -> dátum; bez nutácie/aberácie, < 0,01°).
|
|
276
|
+
Podporuje polia numpy; azimut v [0, 360). Používa Sky Map (W10) a grafy podľa nocí.
|
|
277
|
+
"""
|
|
278
|
+
n0 = unit_vector(ra, dec)
|
|
279
|
+
phi = math.radians(lat)
|
|
280
|
+
zeta, z, th = _precession_angles(julian_date(when))
|
|
281
|
+
nd = _rot_z(_rot_x(_rot_z(n0, zeta), th), z) # J2000 -> dátum (inverzné rotácie)
|
|
282
|
+
ra_d = np.arctan2(nd[..., 0], nd[..., 1])
|
|
283
|
+
dec_d = np.arcsin(np.clip(nd[..., 2], -1, 1))
|
|
284
|
+
ha = np.radians(gmst(when) + lon) - ra_d
|
|
285
|
+
sin_alt = math.sin(phi) * np.sin(dec_d) + math.cos(phi) * np.cos(dec_d) * np.cos(ha)
|
|
286
|
+
alt = np.arcsin(np.clip(sin_alt, -1, 1))
|
|
287
|
+
az = np.arctan2(-np.cos(dec_d) * np.sin(ha),
|
|
288
|
+
(np.sin(dec_d) - np.sin(alt) * math.sin(phi)) / max(math.cos(phi), 1e-12))
|
|
289
|
+
return np.degrees(alt), np.degrees(az) % 360.0
|
|
290
|
+
|
|
291
|
+
|
|
292
|
+
def estimate_radiant(ra0, dec0, ra1, dec1):
|
|
293
|
+
"""Odhad rádiantu: bod najbližší všetkým veľkým kružniciam stôp (J2000, stupne).
|
|
294
|
+
|
|
295
|
+
Každá stopa určuje rovinu (normála n = v0 × v1); spoločný bod minimalizujúci vzdialenosť
|
|
296
|
+
od všetkých rovín je vlastný vektor s najmenším vlastným číslom matice Σ nᵢ nᵢᵀ.
|
|
297
|
+
Vracia (ra, dec) alebo None, ak niet dosť platných stôp.
|
|
298
|
+
"""
|
|
299
|
+
v0, v1 = unit_vector(ra0, dec0), unit_vector(ra1, dec1)
|
|
300
|
+
n = np.cross(v0, v1)
|
|
301
|
+
norm = np.linalg.norm(n, axis=-1)
|
|
302
|
+
keep = norm > 1e-9 # nulová dĺžka stopy neurčuje rovinu
|
|
303
|
+
if int(np.count_nonzero(keep)) < 2:
|
|
304
|
+
return None
|
|
305
|
+
n = n[keep] / norm[keep, None]
|
|
306
|
+
w, vec = np.linalg.eigh(n.T @ n)
|
|
307
|
+
r = vec[:, 0] # najmenšie vlastné číslo
|
|
308
|
+
ra = math.degrees(math.atan2(r[0], r[1])) % 360.0
|
|
309
|
+
dec = math.degrees(math.asin(float(np.clip(r[2], -1, 1))))
|
|
310
|
+
return ra, dec
|
|
311
|
+
|
|
312
|
+
|
|
313
|
+
# ─────────────────── Slnko a hranice noci (W10) ───────────────────
|
|
314
|
+
# Rovnaký vzorec a prah ako `record.py` (geometrická výška, bez refrakcie), aby hranice noci
|
|
315
|
+
# v grafoch sedeli s tým, čo sa reálne nahráva. `record.py` zámerne ostáva len stdlib (bez
|
|
316
|
+
# numpy), preto je vzorec tu zopakovaný — meniť treba obe miesta spolu.
|
|
317
|
+
|
|
318
|
+
def sun_ecliptic_longitude(when):
|
|
319
|
+
"""Ekliptická dĺžka Slnka (stupne, 0–360) pre UTC okamih — rovnaký vzorec ako `sun_altitude`.
|
|
320
|
+
|
|
321
|
+
Používa ju `showers.peak_date` (dátum maxima roja zo slnečnej dĺžky). Vzorec je zhodný s
|
|
322
|
+
`record.sun_altitude` (geometrická, bez refrakcie); meniť treba obe miesta spolu.
|
|
323
|
+
"""
|
|
324
|
+
n = julian_date(when) - 2451545.0
|
|
325
|
+
g = math.radians((357.528 + 0.9856003 * n) % 360)
|
|
326
|
+
return (280.460 + 0.9856474 * n + 1.915 * math.sin(g) + 0.020 * math.sin(2 * g)) % 360.0
|
|
327
|
+
|
|
328
|
+
|
|
329
|
+
def sun_altitude(when, lat, lon):
|
|
330
|
+
"""Výška Slnka (stupne, geometrická) pre UTC okamih a polohu — zhodná s `record.py`."""
|
|
331
|
+
jd = julian_date(when)
|
|
332
|
+
n = jd - 2451545.0
|
|
333
|
+
lam = math.radians(sun_ecliptic_longitude(when))
|
|
334
|
+
eps = math.radians(23.439 - 0.0000004 * n)
|
|
335
|
+
dec = math.asin(math.sin(eps) * math.sin(lam))
|
|
336
|
+
ra = math.atan2(math.cos(eps) * math.sin(lam), math.cos(lam))
|
|
337
|
+
ha = math.radians((280.46061837 + 360.98564736629 * n) % 360 + lon) - ra
|
|
338
|
+
la = math.radians(lat)
|
|
339
|
+
return math.degrees(math.asin(math.sin(la) * math.sin(dec)
|
|
340
|
+
+ math.cos(la) * math.cos(dec) * math.cos(ha)))
|
|
341
|
+
|
|
342
|
+
|
|
343
|
+
def _night_crossing(t0, t1, lat, lon, thr, rising):
|
|
344
|
+
"""Okamih prechodu Slnka prahom `thr` v okne [t0, t1] (rastúci, alebo klesajúci)."""
|
|
345
|
+
step = dt.timedelta(minutes=5)
|
|
346
|
+
f = lambda t: sun_altitude(t, lat, lon) - thr # noqa: E731
|
|
347
|
+
a, fa = t0, f(t0)
|
|
348
|
+
t = t0 + step
|
|
349
|
+
while t <= t1:
|
|
350
|
+
fb = f(t)
|
|
351
|
+
if (rising and fa <= 0.0 < fb) or (not rising and fa >= 0.0 > fb):
|
|
352
|
+
lo, hi = a, t
|
|
353
|
+
for _ in range(50): # bisekcia na ~sekundu
|
|
354
|
+
mid = lo + (hi - lo) / 2
|
|
355
|
+
if (f(mid) <= 0.0) == (f(lo) <= 0.0):
|
|
356
|
+
lo = mid
|
|
357
|
+
else:
|
|
358
|
+
hi = mid
|
|
359
|
+
return hi
|
|
360
|
+
a, fa = t, fb
|
|
361
|
+
t += step
|
|
362
|
+
return None
|
|
363
|
+
|
|
364
|
+
|
|
365
|
+
def night_bounds(night_date, lat, lon, sun_alt=-9.0, tz=None):
|
|
366
|
+
"""Hranice miestnej noci `night_date` (dátum pred polnocou) ako UTC okamihy.
|
|
367
|
+
|
|
368
|
+
Vráti (sunset_utc, sunrise_utc) — kedy Slnko klesne pod a vystúpi nad `sun_alt`. Ak sa
|
|
369
|
+
prechod nenájde (polárny deň/noc), vráti (None, None). `night_date` je `datetime.date`
|
|
370
|
+
alebo ISO reťazec; `tz` je pásmo miestnych hodín (predvolene systémové). Metóda je zhodná
|
|
371
|
+
s `record.sun_altitude` (rovnaký prah), aby grafy sedeli s reálnym nahrávaním.
|
|
372
|
+
"""
|
|
373
|
+
tz = tz or dt.datetime.now().astimezone().tzinfo
|
|
374
|
+
d = night_date if isinstance(night_date, dt.date) else dt.date.fromisoformat(str(night_date))
|
|
375
|
+
d1 = d + dt.timedelta(days=1)
|
|
376
|
+
sunset = _night_crossing(dt.datetime.combine(d, dt.time(12, 0), tzinfo=tz),
|
|
377
|
+
dt.datetime.combine(d1, dt.time(3, 0), tzinfo=tz),
|
|
378
|
+
lat, lon, sun_alt, rising=False)
|
|
379
|
+
sunrise = _night_crossing(dt.datetime.combine(d1, dt.time(0, 0), tzinfo=tz),
|
|
380
|
+
dt.datetime.combine(d1, dt.time(12, 0), tzinfo=tz),
|
|
381
|
+
lat, lon, sun_alt, rising=True)
|
|
382
|
+
to_utc = lambda t: t.astimezone(dt.timezone.utc) if t else None # noqa: E731
|
|
383
|
+
return to_utc(sunset), to_utc(sunrise)
|
|
384
|
+
|
|
385
|
+
|
|
386
|
+
# Canonical Slovak compass abbreviations kept for backwards compatibility.
|
|
387
|
+
COMPASS_SK = ("S", "SV", "V", "JV", "J", "JZ", "Z", "SZ")
|
|
388
|
+
COMPASS_EN = ("N", "NE", "E", "SE", "S", "SW", "W", "NW")
|
|
389
|
+
|
|
390
|
+
|
|
391
|
+
def compass(az):
|
|
392
|
+
"""Slovak compass abbreviation for an azimuth in degrees (legacy API)."""
|
|
393
|
+
return COMPASS_SK[int((float(az) % 360.0) / 45.0 + 0.5) % 8]
|
|
394
|
+
|
|
395
|
+
|
|
396
|
+
def compass_en(az):
|
|
397
|
+
"""English compass abbreviation for an azimuth in degrees (community UI)."""
|
|
398
|
+
return COMPASS_EN[int((float(az) % 360.0) / 45.0 + 0.5) % 8]
|