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.
Files changed (57) hide show
  1. meteorlens/__init__.py +4 -0
  2. meteorlens/__main__.py +4 -0
  3. meteorlens/astrometry.py +398 -0
  4. meteorlens/calibrate.py +797 -0
  5. meteorlens/capture.py +225 -0
  6. meteorlens/cli.py +103 -0
  7. meteorlens/config.py +504 -0
  8. meteorlens/control.py +154 -0
  9. meteorlens/data/config.example.ini +125 -0
  10. meteorlens/data/mask.example.png +0 -0
  11. meteorlens/data/showers.csv +112 -0
  12. meteorlens/data/star_names.csv +36 -0
  13. meteorlens/data/stars_hip.csv +2817 -0
  14. meteorlens/detect.py +377 -0
  15. meteorlens/filters.py +4 -0
  16. meteorlens/media.py +120 -0
  17. meteorlens/metrics.py +96 -0
  18. meteorlens/outputs.py +126 -0
  19. meteorlens/runner.py +404 -0
  20. meteorlens/showers.py +129 -0
  21. meteorlens/store.py +705 -0
  22. meteorlens/synth.py +87 -0
  23. meteorlens/thumbs.py +113 -0
  24. meteorlens/video.py +106 -0
  25. meteorlens/web/__init__.py +4 -0
  26. meteorlens/web/app.py +96 -0
  27. meteorlens/web/formatting.py +91 -0
  28. meteorlens/web/labels.py +44 -0
  29. meteorlens/web/live.py +35 -0
  30. meteorlens/web/routes/__init__.py +7 -0
  31. meteorlens/web/routes/api.py +155 -0
  32. meteorlens/web/routes/control.py +22 -0
  33. meteorlens/web/routes/media.py +65 -0
  34. meteorlens/web/routes/pages.py +105 -0
  35. meteorlens/web/setup.py +325 -0
  36. meteorlens/web/skymap.py +180 -0
  37. meteorlens/web/static/app.css +171 -0
  38. meteorlens/web/static/js/dashboard.js +380 -0
  39. meteorlens/web/static/js/gallery.js +84 -0
  40. meteorlens/web/static/js/header.js +26 -0
  41. meteorlens/web/static/js/settings.js +54 -0
  42. meteorlens/web/static/js/setup.js +519 -0
  43. meteorlens/web/static/setup.css +114 -0
  44. meteorlens/web/templates/_macros.html +71 -0
  45. meteorlens/web/templates/_nav.html +7 -0
  46. meteorlens/web/templates/base.html +30 -0
  47. meteorlens/web/templates/dashboard.html +94 -0
  48. meteorlens/web/templates/gallery.html +33 -0
  49. meteorlens/web/templates/settings.html +27 -0
  50. meteorlens/web/templates/setup.html +290 -0
  51. meteorlens-0.0.0.dist-info/METADATA +283 -0
  52. meteorlens-0.0.0.dist-info/RECORD +57 -0
  53. meteorlens-0.0.0.dist-info/WHEEL +5 -0
  54. meteorlens-0.0.0.dist-info/entry_points.txt +3 -0
  55. meteorlens-0.0.0.dist-info/licenses/LICENSE +21 -0
  56. meteorlens-0.0.0.dist-info/licenses/NOTICE +10 -0
  57. meteorlens-0.0.0.dist-info/top_level.txt +1 -0
meteorlens/__init__.py ADDED
@@ -0,0 +1,4 @@
1
+ """MeteorLens - local-first meteor detection from IP cameras."""
2
+
3
+ __version__ = "0.1.0"
4
+ VERSION = __version__
meteorlens/__main__.py ADDED
@@ -0,0 +1,4 @@
1
+ from .cli import main
2
+
3
+ if __name__ == "__main__":
4
+ raise SystemExit(main())
@@ -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]