arnaudne/Astronome
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add target comparison modal, integration goal progress, and session planning + full catalog expansion

Browse Source 
Features added this session:
- Target comparison: side-by-side overlay (CompareModal) from Targets page via ⊕ button on each row; shows altitude curves, key times, filter recommendations and per-filter integration progress for two targets simultaneously
- Integration goal progress dashboard card: per-target keeper minutes vs goal hours (from CLAUDE.md §16.3) broken down by filter, with color-coded progress bars; powered by new stats.integration_goals backend query
- Session planning timeline: Gantt-style "Plan Tonight" section on Dashboard (PlanningTimeline component) — search targets, set durations, sequential scheduling from dusk, overrun warnings, clipboard export
- Slew-optimized run order toggle (nearest-neighbor sort by RA/Dec angular distance)
- Best Nights 14-day card + Monthly Highlights card on Dashboard

Catalog expansions:
- Sharpless (Sh2), VdB, LDN, Barnard dark nebulae, LBN, Melotte, Collinder, Gum, RCW, Abell PN, Abell GC, PGC bright subset
- Caldwell/Arp/Melotte/Collinder number columns + cross-reference maps
- Weather score multiplier applied to composite sort
- galaxy_cluster type (ACO badge) throughout TypeBadge, CSS, filter chips

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Arnaud Nelissen
2026-04-17 07:20:10 +02:00
parent 8f72745bc0
commit 2bb80a8475
45 changed files with 5613 additions and 628 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TODO.md
+99 -16
View File
@@ -26,48 +26,131 @@
### Nice to Have
- [ ] **Seasonal visibility heatmap** — 12-month alt/usability grid (the Yearly tab already exists but could be improved with a visual heatmap calendar view)
- [x] **Seasonal visibility heatmap** — `YearlyVisibility.tsx` replaced bar chart with a 12×31 SVG calendar heatmap. Each cell = one day, colored by `alt_at_midnight` (green/teal/amber/muted). Blue moon overlay (opacity ∝ illumination). Hover tooltip shows date, alt, usable hours, moon %. Today ring in amber.
---
## Bugs & Fixes
- [x] **Fix gallery image upload** — root cause: ServeDir was mounted at URL `/data/gallery` (nginx sends that path to frontend, not backend). Fixed by remounting ServeDir at `/api/gallery/files/`. Updated all gallery image URL formats in `gallery.rs`. Also fixed `api.gallery.upload` to throw on non-2xx responses so errors surface in the UI.
- [x] **Fix Custom Object coordinate calculations** — root cause: `get_target`, `get_visibility`, `get_curve`, `get_filters`, `get_yearly`, and `get_workflow_handler` in `targets.rs` all queried only the `catalog` table, returning 404 for custom objects. Fixed by adding a `lookup_coords` helper that falls back to `custom_targets` table; `get_target` now returns a full response shape with null catalog-specific fields for custom objects.
---
## Observing & Planning
- [ ] **Tonight run order** — auto-sort visible targets by imaging window with handoff times shown as a timeline: "M8 22:10→23:45 → IC1805 00:05→02:30". Dashboard card + Targets page sort option.
- [x] **Improve "best tonight" algorithm with composite score** — composite score `(alt*0.4 + fill*0.3 + usable*0.2 + moon*0.1)` is the default sort in `list_targets`. "Best Score Tonight" and "Altitude tonight" both exposed as sort options in Targets page.
- [ ] **Moon separation live warning** — red banner on Dashboard when the moon is within 20° of tonight's best target. Data already computed in `nightly_cache.moon_sep_deg`.
- [x] **Custom horizon in target visibility** — fixed `usable_min`/`best_start/end` in `visibility.rs` to use `max(30°, horizon_alt(az))` instead of flat 30°. Added `is_visible_tonight` column to `nightly_cache` (with runtime migration). Nightly precompute now stores the flag. `list_targets` tonight filter uses `is_visible_tonight = 1` with fallback to `max_alt_deg >= 15` for pre-migration rows.
- [ ] **Altitude urgency indicator** — flag objects that have a short window tonight AND are near their seasonal peak (compare `alt_at_midnight` from yearly data to historical max). "NGC891 sets at 01:30 — last good chance until October." Show as a badge on TargetRow.
- [x] **Show custom and solar system objects in Targets list** — `list_targets` appends custom_targets (with RA/Dec) on page 1 with live-computed current altitude. Frontend: `is_custom` flag renders a teal "CUSTOM" pill in TargetRow; TypeBadge extended with USR/SAT/CMT labels; "Custom" toggle chip added to filter bar (teal, default on).
- [ ] **Imaging time calculator** — given target + filter, estimate number of 3-min subs needed to reach a usable SNR. Use sensor specs from `config.rs` (pixel scale, focal ratio, bortle) to compute sky background noise. More precise than the fixed hours table.
- [x] **Greatly improve Targets filtering and sorting:**
- *Multi-select object type filter* — multi-select chips; comma-separated type param parsed server-side.
- *Best tonight sort* — "Best Score Tonight" is default; "Altitude tonight" added as explicit sort option.
- *Persist filter state* — all filter/sort state saved to `localStorage` (`astronome_targets_filters_v2`).
- *Additional filter dimensions* — min altitude, min usable time already present.
- Remaining: multi-select catalogue filter, FOV/SB ranges, constellation multi-select, session window.
- [x] **Add Astrobin search links in target detail** — added two Astrobin links (by common name and by catalog ID) in Detail Drawer Tab 2, plus a GoTo coordinates card with RA/Dec copy buttons and live hour angle / east–west meridian indicator.
- [x] **Moon path on altitude graph** — already implemented: `CurvePoint.moon_alt_deg` populated in backend, rendered as dim blue dashed `Line` in `AltitudeCurve.tsx`; moon-above-horizon windows shaded in subtle blue, close-approach (<30°) shaded in amber.
- [x] **Merge "Tonight" and "Target" tabs in Detail Drawer** — combined into single "Overview" tab: DSS + metadata left column, altitude curve + key times right column; GoTo card + Aladin below the fold.
- [x] **Tonight run order** — Dashboard "Tonight's Run Order" Gantt-style card: each target row shows a bar across the night window (colored by filter), with start→end time. Targets sorted by `best_start_utc`. Also added "Run order (imaging window)" sort option to Targets page.
- [x] **Moon separation live warning** — red banner on Dashboard when the moon is within 20° of any top-5 tonight target. Uses `moon_sep_deg` from nightly_cache already fetched for the target list.
- [x] **Altitude urgency indicator** — `list_targets` SQL joins a 90-day peak subquery; computes `urgency` field: `peak` (≥90% of seasonal max), `rising` (70–90%, before peak date), `declining` (70–90%, after peak date). TargetRow renders ▲ peak / ↗ rising / ↘ declining in matching semantic colors below the common name.
- [x] **Imaging time calculator** — SNR-based sub count estimator added to Filters & Workflow tab. Interactive SNR slider (10–50), computes subs needed, total time, sessions needed. Uses IMX571 sensor constants (read noise 3.5e-, dark 0.002e-/px/s), per-filter sky backgrounds, surface_brightness from catalog.
---
## Equipment & Sessions
- [ ] **Integration gap detector** *(build first)* — Dashboard card showing targets that have data in one filter but are missing the companion filter. "IC1805: 2h Ha · 0h OIII — one session away from complete." Driven by `filter_breakdown` data already in the DB. Low-effort, high-value.
- [x] **Integration gap detector** — Dashboard card showing targets with data in one narrowband filter but missing the companion (sv220↔c2, uvir↔sv260). Computed via new SQL query in `stats.rs`, surfaced as `integration_gaps` in the stats response, and displayed as a filter-gap card on the Dashboard.
- [ ] **Dew heater alarm** — when dew margin drops below 3°C (already computed in `weather_cache`), show a persistent full-width banner and trigger a browser notification. More aggressive than the current warning.
- [x] **Dew heater alarm** — `DewAlert.tsx` now triggers a browser `Notification` (requests permission on first alert) when level appears or escalates. Tag `dew-alert` prevents duplicate notifications.
- [ ] **Session checklist** — collapsible pre-session checklist (polar alignment, focus, guiding RMS < 1″, dew heater, battery). Simple boolean checkboxes that auto-reset each evening at dusk.
- [x] **Session checklist** — `SessionChecklist.tsx` collapsible card on Dashboard with 6 items (polar alignment, focus, guiding, dew heater, battery, cap). State in localStorage keyed by dusk date — auto-resets each evening. Progress bar + "Ready" indicator.
- [ ] **Equipment profiles** — settings table for telescope/camera configs (focal length, aperture, sensor, pixel size). Ability to switch active profile so FOV and plate scale calculations update. Useful when upgrading gear.
- [x] **Equipment profiles** — Settings page section. localStorage-based profiles showing plate scale, FOV. Current hardcoded AT71+ATR2600C shown as ACTIVE. Add/Edit/Delete UI with live preview of plate scale and FOV.
---
## Post-Processing
- [ ] **NINA Target Scheduler import** — parse NINA Target Scheduler zip (`askar71f.zip` at project root) to bulk-import targets and existing session history.
- [ ] **PixInsight WBPP project generator** — button on Detail Drawer Tab 3 that generates a ready-to-use WBPP folder structure (or `.xisf` project stub) for the selected filter + workflow. Eliminates manual setup before processing.
- [ ] **PixInsight WBPP project generator** — button on Detail Drawer Tab 3 that generates a `.bat`/`.sh` script or folder structure stub for WBPP. Out of scope for now (requires XISF format knowledge).
---
## Catalog & Discovery
- [ ] **Sharpless catalog (Sh2)** — add Sh2 emission nebulae via VizieR (catalog VII/20). Covers Lion, Dolphin, Cave, and ~300 more — already referenced in `popular_names.rs` but missing from the catalog sources. Add alongside VdB/LDN in `catalog/mod.rs`.
- [x] **Sharpless catalog (Sh2)** — 299 entries from VizieR VII/20 with popular names (Cave, Lion, Dolphin, etc.)
- [ ] **Check LdN and VdB implementations** (fetch LDN from internet), and `popular_names.rs`
- [x] **Check LdN and VdB implementations** — LDN now fetches 1724 entries from VizieR VII/7A; VdB fetches 158 entries from VizieR VII/21A; `popular_names.rs` verified; `Cl+N` type bug fixed (IC1396 Elephant Trunk now included)
- [ ] **"Similar targets nearby" suggestions** — in Detail Drawer Tab 1 or Tab 2, show 2–3 objects of the same type in the same constellation that transit within 1 hour of the current target. Useful for filling the rest of a night.
### Additional Catalogue Ingestion
- [ ] **Observation history timeline** — vertical timeline on the Stats page showing all sessions chronologically with gallery thumbnails where available. No new data needed — just a different view of `imaging_log` JOIN `gallery`.
The pipeline already handles NGC, IC, Messier (as NGC cross-refs), Sh2, VdB, LDN. The following need dedicated fetch modules in `catalog/` following the same VizieR TSV pattern used by `sh2.rs` / `ldn.rs`. Each needs: fetch + parse + deduplicate against existing entries (match on RA/Dec within 2′) + upsert into `catalog` table + popular names entries in `popular_names.rs`.
- [x] **Caldwell catalogue** — `caldwell_num INTEGER` column added via migration; hardcoded map in `caldwell.rs` populates after each catalog upsert. `C20`, `Arp85` prefix search supported. C-number shown in TargetRow (blue, only when no Messier num). Also added `arp_num` column and Arp map.
- [x] **LBN (Lynds Bright Nebulae)** — `lbn.rs` fetches VizieR VII/9. Positional dedup against NGC/IC/Sh2 (2' radius). Class field used for emission vs reflection typing. Fallback hardcoded set.
- [x] **GUM catalogue** — `gum.rs` fetches VizieR XI/75, Dec filter ≥ -30°. Positional dedup against existing catalog. Hardcoded fallback for VizieR failures.
- [x] **RCW catalogue** — `rcw.rs` fetches VizieR VIII/76, Dec filter ≥ -30°. Positional dedup.
- [x] **Barnard catalogue (B)** — `barnard.rs` fetches VizieR VII/220A. Positional dedup against LDN. Hardcoded fallback includes B33 (Horsehead), B72 (Snake), B142/143, etc. Popular names wired in.
- [x] **Abell Galaxy Clusters** — `abell_gc.rs` fetches VizieR VII/110A. New `galaxy_cluster` type added. TypeBadge shows "ACO", purple badge. Added to Targets filter chips and filter/sv260 suitability. Difficulty 4-5 based on m10 brightness.
- [x] **Abell Planetary Nebulae** — `abell_pn.rs` fetches VizieR V/74. Positional dedup. All set difficulty=5, hubble_type="low-SB PN — narrowband only". Prominent fallback set includes Abell 21 (Medusa), Abell 74, etc.
- [x] **Arp catalogue** — `arp_num INTEGER` column added via migration, populated from `caldwell.rs` arp_map(). "Arp85" prefix search already supported in `list_targets`. Notable entries include Arp 85=M51, Arp 244=Antennae Galaxies.
- [x] **Melotte catalogue** — `melotte_num INTEGER` column added via migration. Hardcoded cross-reference map populates after upsert. Standalone entries added: Mel 20 (Alpha Per), Mel 25 (Hyades), Mel 111 (Coma Star Cluster).
- [x] **Collinder catalogue** — `collinder_num INTEGER` column added via migration. Cross-reference map + Cr399 (Brocchi's Coathanger) standalone entry.
- [x] **PGC (Principal Galaxy Catalogue) bright subset** — PGC contains millions of galaxies; ingesting all is impractical. Add only the "bright" subset: PGC objects with `B_Mag < 14.0` not already in NGC/IC. Source: VizieR VII/237. Expect ~5000 new entries. Adds fainter NGC-complement galaxies for completeness. Object type: `galaxy`.
- [x] **"Similar targets nearby" suggestions** — `GET /api/targets/:id/similar` returns same obj_type + constellation within 25° RA. Shown in Overview tab as "Similar Targets Nearby" before Aladin embed.
- [x] **Observation history timeline** — `SessionTimeline` on Stats page: sessions grouped by date, thumbnail (or star placeholder), filter pill, integration time, quality chip. Backend `history` field added to `/api/stats`.
---
## Planning & Scheduling
- [x] **Best nights ranking (14-night view)** — `/api/calendar/best-nights` endpoint returns 14 nights scored by `moon*0.5 + dark*0.5`. Dashboard card shows date, score bar, moon %, sorted by date (best score highlighted). Top 3 targets per night from nightly_cache.
- [x] **Weather score in target ranking** — `list_targets` fetches `go_nogo` from weather_cache and applies a multiplier (go=1.0, marginal=0.7, nogo=0.3) to the composite best-score sort. Defaults to 1.0 when forecast unavailable.
- [x] **Session planning timeline** — "Plan Tonight" mode: user selects an ordered set of targets, each assigned a duration. Renders a Gantt-style timeline (dusk→dawn, x-axis UTC) with color-coded blocks per target showing overlap with that object's visibility window. Warn when a target block extends past its set time. Exportable as a plain-text run order (e.g. "21:45 NGC7000 · 2h → 23:45 IC1805 · 1h30 → …").
- [x] **Monthly highlights** — `/api/calendar/monthly-highlights` returns top 8 objects this month (by peak alt, preferring unimaged). Dashboard card shows name, type, peak alt, filter, imaged status.
- [x] **Seasonal peak indicator on target rows** — already implemented as `urgency` field: `▲ peak` (≥90% of seasonal max), `↗ rising`, `↘ declining`. Shown below common name in TargetRow.
---
## Catalogue Completion & Progress
- [x] **Catalogue completion tracker** — Stats page grid: Messier, Sharpless, LDN, VdB, NGC, IC progress bars with keeper counts and 🏆 badge on completion. Backend computes totals dynamically.
- [x] **Beginner-friendly filter** — "Accessible tonight" chip on Targets page: applies min_alt≥40°, usable≥60min server-side, plus difficulty≤2 and moon_sep≥45° client-side.
- [x] **Deep-linkable target URLs** — added `/targets/:targetId` React Router route. URL updates when a drawer is opened; navigating directly to `/targets/NGC7000` pre-opens that drawer and disables the tonight-only filter so the target is always found.
---
## GoTo Mount Integration
- [x] **GoTo coordinates card** — already in Overview tab: RA/Dec with copy buttons, live hour angle, East/West meridian indicator.
- [x] **Slew-order optimizer** — "⟳ Slew-optimized order" toggle in the Run Order card. Nearest-neighbor heuristic on RA/Dec angular distance reorders tonight's targets. Pure frontend, no backend needed.
backend/src/api/calendar.rs
+129
View File
@@ -140,6 +140,135 @@ pub async fn get_calendar(
Ok(Json(serde_json::json!({ "days": days })))
}
/// Returns the next 14 nights ranked by composite night score.
pub async fn get_best_nights(
State(state): State<AppState>,
) -> Result<Json<serde_json::Value>, AppError> {
use sqlx::Row;
let today = chrono::Utc::now().naive_utc().date();
let mut nights: Vec<serde_json::Value> = Vec::new();
for i in 0..14i64 {
let date = today + chrono::Duration::days(i);
let date_str = date.to_string();
let moon_illum = moon_illum_for_date(date);
// Pull nightly cache stats for this night
let cache_row = sqlx::query(
r#"SELECT
COUNT(CASE WHEN nc.max_alt_deg >= 15 THEN 1 END) as visible_count,
AVG(CASE WHEN nc.max_alt_deg >= 30 THEN nc.usable_min ELSE NULL END) as avg_usable_min
FROM nightly_cache nc
WHERE nc.night_date = ?"#,
)
.bind(&date_str)
.fetch_optional(&state.pool)
.await?;
let (visible_count, avg_usable_min): (i64, f64) = cache_row.as_ref().map(|r| (
r.try_get::<Option<i64>, _>("visible_count").unwrap_or_default().unwrap_or(0),
r.try_get::<Option<f64>, _>("avg_usable_min").unwrap_or_default().unwrap_or(0.0),
)).unwrap_or((0, 0.0));
// Moon score: low illumination = better
let moon_score = 1.0 - moon_illum;
// Dark hours score: normalize to 0–1 assuming max useful ~480 min
let dark_score = (avg_usable_min / 480.0).min(1.0);
// Composite (no weather score for future nights without forecast)
let score = moon_score * 0.5 + dark_score * 0.5;
// Top 3 targets for this night
let top_targets_rows = sqlx::query(
r#"SELECT c.id, c.name, c.common_name, c.obj_type, nc.max_alt_deg, nc.usable_min, nc.recommended_filter
FROM nightly_cache nc
JOIN catalog c ON c.id = nc.catalog_id
WHERE nc.night_date = ? AND nc.max_alt_deg >= 20
ORDER BY nc.max_alt_deg DESC
LIMIT 3"#,
)
.bind(&date_str)
.fetch_all(&state.pool)
.await?;
let top_targets: Vec<serde_json::Value> = top_targets_rows.iter().map(|r| serde_json::json!({
"id": r.try_get::<String, _>("id").unwrap_or_default(),
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<String, _>("obj_type").unwrap_or_default(),
"max_alt_deg": r.try_get::<Option<f64>, _>("max_alt_deg").unwrap_or_default(),
"usable_min": r.try_get::<Option<i32>, _>("usable_min").unwrap_or_default(),
"recommended_filter": r.try_get::<Option<String>, _>("recommended_filter").unwrap_or_default(),
})).collect();
nights.push(serde_json::json!({
"date": date_str,
"score": (score * 100.0) as u32,
"moon_illumination": moon_illum,
"visible_count": visible_count,
"avg_usable_min": avg_usable_min as u32,
"top_targets": top_targets,
}));
}
// Sort by score descending
nights.sort_by(|a, b| {
let sa = a["score"].as_u64().unwrap_or(0);
let sb = b["score"].as_u64().unwrap_or(0);
sb.cmp(&sa)
});
Ok(Json(serde_json::json!({ "nights": nights })))
}
/// Returns top 5 targets that peak this calendar month, preferring not-yet-imaged.
pub async fn get_monthly_highlights(
State(state): State<AppState>,
) -> Result<Json<serde_json::Value>, AppError> {
use sqlx::Row;
let today = chrono::Utc::now().naive_utc().date();
let month_prefix = today.format("%Y-%m").to_string();
let rows = sqlx::query(
r#"SELECT
c.id, c.name, c.common_name, c.obj_type, c.constellation,
MAX(nc.max_alt_deg) as peak_alt,
MAX(nc.usable_min) as best_usable,
nc.recommended_filter,
nc.transit_utc,
(SELECT COUNT(*) FROM imaging_log il
WHERE il.catalog_id = c.id AND il.quality = 'keeper') as keeper_count
FROM nightly_cache nc
JOIN catalog c ON c.id = nc.catalog_id
WHERE nc.night_date LIKE ?
AND nc.max_alt_deg >= 20
AND nc.is_visible_tonight = 1
GROUP BY c.id
ORDER BY keeper_count ASC, peak_alt DESC
LIMIT 8"#,
)
.bind(format!("{}%", month_prefix))
.fetch_all(&state.pool)
.await?;
let highlights: Vec<serde_json::Value> = rows.iter().map(|r| serde_json::json!({
"id": r.try_get::<String, _>("id").unwrap_or_default(),
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<String, _>("obj_type").unwrap_or_default(),
"constellation": r.try_get::<Option<String>, _>("constellation").unwrap_or_default(),
"peak_alt": r.try_get::<Option<f64>, _>("peak_alt").unwrap_or_default(),
"best_usable_min": r.try_get::<Option<i32>, _>("best_usable").unwrap_or_default(),
"recommended_filter": r.try_get::<Option<String>, _>("recommended_filter").unwrap_or_default(),
"keeper_count": r.try_get::<i64, _>("keeper_count").unwrap_or_default(),
})).collect();
Ok(Json(serde_json::json!({
"month": month_prefix,
"highlights": highlights,
})))
}
pub async fn get_calendar_date(
State(state): State<AppState>,
Path(date): Path<String>,
backend/src/api/gallery.rs
+3 -3
View File
@@ -30,7 +30,7 @@ pub async fn list_all_gallery(
"id": id,
"catalog_id": &catalog_id,
"filename": &filename,
"url": format!("/api/gallery/{}/{}", catalog_id, filename),
"url": format!("/api/gallery/files/{}/{}", catalog_id, filename),
"caption": r.try_get::<Option<String>, _>("caption").unwrap_or_default(),
"created_at": r.try_get::<i64, _>("created_at").unwrap_or_default(),
"target_name": r.try_get::<Option<String>, _>("target_name").unwrap_or_default(),
@@ -60,7 +60,7 @@ pub async fn list_gallery(
"id": id,
"catalog_id": catalog_id,
"filename": filename,
"url": format!("/api/gallery/{}/{}", catalog_id, filename),
"url": format!("/api/gallery/files/{}/{}", catalog_id, filename),
"caption": r.try_get::<Option<String>, _>("caption").unwrap_or_default(),
"created_at": r.try_get::<i64, _>("created_at").unwrap_or_default(),
})
@@ -147,7 +147,7 @@ pub async fn upload_image(
"id": id,
"catalog_id": catalog_id,
"filename": filename,
"url": format!("/api/gallery/{}/{}", catalog_id, filename),
"url": format!("/api/gallery/files/{}/{}", catalog_id, filename),
})))
}
backend/src/api/mod.rs
+5 -1
View File
@@ -66,12 +66,15 @@ pub fn build_router(pool: SqlitePool) -> Router {
.route("/api/targets/:id/filters", get(targets::get_filters))
.route("/api/targets/:id/workflow/:filter_id", get(targets::get_workflow_handler))
.route("/api/targets/:id/yearly", get(targets::get_yearly))
.route("/api/targets/:id/similar", get(targets::get_similar))
.route("/api/targets/:id/notes", get(targets::get_notes).put(targets::put_notes))
// Tonight
.route("/api/tonight", get(tonight::get_tonight))
// Calendar
.route("/api/calendar", get(calendar::get_calendar))
.route("/api/calendar/new-moon-windows", get(calendar::get_new_moon_windows))
.route("/api/calendar/best-nights", get(calendar::get_best_nights))
.route("/api/calendar/monthly-highlights", get(calendar::get_monthly_highlights))
.route("/api/calendar/:date", get(calendar::get_calendar_date))
// Weather
.route("/api/weather", get(weather::get_weather))
@@ -103,8 +106,9 @@ pub fn build_router(pool: SqlitePool) -> Router {
// Stats
.route("/api/stats", get(stats::get_stats))
// Static gallery files served via tower-http
// Must be under /api/ so nginx proxies it to the backend, not the frontend.
.nest_service(
"/data/gallery",
"/api/gallery/files",
tower_http::services::ServeDir::new(gallery_dir),
)
.with_state(state)
backend/src/api/solar_system.rs
+2 -2
View File
@@ -73,7 +73,7 @@ pub struct SolarSystemObject {
pub is_visible: bool, // alt > 15°
}
fn fmt_ra(ra: f64) -> String {
pub fn fmt_ra(ra: f64) -> String {
let total_sec = (ra / 15.0) * 3600.0;
let h = (total_sec / 3600.0) as u32;
let m = ((total_sec % 3600.0) / 60.0) as u32;
@@ -81,7 +81,7 @@ fn fmt_ra(ra: f64) -> String {
format!("{:02}h {:02}m {:02}s", h, m, s)
}
fn fmt_dec(dec: f64) -> String {
pub fn fmt_dec(dec: f64) -> String {
let sign = if dec < 0.0 { "-" } else { "+" };
let abs = dec.abs();
let d = abs as u32;
backend/src/api/stats.rs
+166
View File
@@ -137,6 +137,168 @@ pub async fn get_stats(
})
}).collect();
// Integration gap detector: targets with one narrowband filter but missing the companion.
// Pairs: sv220 ↔ c2 (for full SHO palette), uvir ↔ sv260 (broadband pair).
let gaps_raw = sqlx::query(
r#"SELECT
l.catalog_id,
c.name,
c.common_name,
c.obj_type,
SUM(CASE WHEN l.filter_id = 'sv220' THEN l.integration_min ELSE 0 END) as sv220_min,
SUM(CASE WHEN l.filter_id = 'c2' THEN l.integration_min ELSE 0 END) as c2_min,
SUM(CASE WHEN l.filter_id = 'uvir' THEN l.integration_min ELSE 0 END) as uvir_min,
SUM(CASE WHEN l.filter_id = 'sv260' THEN l.integration_min ELSE 0 END) as sv260_min
FROM imaging_log l
JOIN catalog c ON c.id = l.catalog_id
WHERE l.quality IN ('keeper', 'needs_more')
GROUP BY l.catalog_id
HAVING (sv220_min > 0 AND c2_min = 0)
OR (c2_min > 0 AND sv220_min = 0)
OR (uvir_min > 0 AND sv260_min = 0)
OR (sv260_min > 0 AND uvir_min = 0)
ORDER BY (sv220_min + c2_min + uvir_min + sv260_min) DESC
LIMIT 10"#,
)
.fetch_all(&state.pool)
.await?;
let gaps: Vec<serde_json::Value> = gaps_raw.iter().map(|r| {
use sqlx::Row;
let sv220_min: i64 = r.try_get("sv220_min").unwrap_or(0);
let c2_min: i64 = r.try_get("c2_min").unwrap_or(0);
let uvir_min: i64 = r.try_get("uvir_min").unwrap_or(0);
let sv260_min: i64 = r.try_get("sv260_min").unwrap_or(0);
let mut missing: Vec<&str> = Vec::new();
if sv220_min > 0 && c2_min == 0 { missing.push("c2"); }
if c2_min > 0 && sv220_min == 0 { missing.push("sv220"); }
if uvir_min > 0 && sv260_min == 0 { missing.push("sv260"); }
if sv260_min > 0 && uvir_min == 0 { missing.push("uvir"); }
serde_json::json!({
"catalog_id": r.try_get::<String, _>("catalog_id").unwrap_or_default(),
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<String, _>("obj_type").unwrap_or_default(),
"sv220_min": sv220_min,
"c2_min": c2_min,
"uvir_min": uvir_min,
"sv260_min": sv260_min,
"missing_filters": missing,
})
}).collect();
// Catalogue completion: per-catalogue keeper counts vs total observable
struct CatEntry { name: &'static str, sql_filter: &'static str }
let catalogues: &[CatEntry] = &[
CatEntry { name: "Messier", sql_filter: "c.messier_num IS NOT NULL" },
CatEntry { name: "Caldwell", sql_filter: "c.caldwell_num IS NOT NULL" },
CatEntry { name: "Sharpless", sql_filter: "c.id LIKE 'Sh2-%'" },
CatEntry { name: "LDN", sql_filter: "c.id LIKE 'LDN%'" },
CatEntry { name: "VdB", sql_filter: "c.id LIKE 'VdB%'" },
CatEntry { name: "NGC", sql_filter: "c.id LIKE 'NGC%'" },
CatEntry { name: "IC", sql_filter: "c.id LIKE 'IC%'" },
];
let mut catalogue_completion: Vec<serde_json::Value> = Vec::new();
for cat in catalogues {
let total_sql = format!("SELECT COUNT(DISTINCT c.id) FROM catalog c WHERE {}", cat.sql_filter);
let keeper_sql = format!(
"SELECT COUNT(DISTINCT l.catalog_id) FROM imaging_log l JOIN catalog c ON c.id = l.catalog_id WHERE l.quality = 'keeper' AND {}",
cat.sql_filter
);
let total: i64 = sqlx::query_scalar::<_, i64>(&total_sql)
.fetch_one(&state.pool).await.unwrap_or(0);
let keepers: i64 = sqlx::query_scalar::<_, i64>(&keeper_sql)
.fetch_one(&state.pool).await.unwrap_or(0);
if total > 0 {
catalogue_completion.push(serde_json::json!({
"name": cat.name,
"total": total,
"keepers": keepers,
"pct": if total > 0 { (keepers as f64 / total as f64 * 100.0).round() as i64 } else { 0 },
}));
}
}
// Session history timeline: all sessions with first gallery image if available
let history_rows = sqlx::query(
r#"SELECT
l.session_date,
l.catalog_id,
COALESCE(c.name, l.catalog_id) as name,
c.common_name,
c.obj_type,
l.filter_id,
l.integration_min,
l.quality,
l.notes,
g.filename as gallery_filename
FROM imaging_log l
LEFT JOIN catalog c ON c.id = l.catalog_id
LEFT JOIN (
SELECT catalog_id, MIN(filename) as filename
FROM gallery
GROUP BY catalog_id
) g ON g.catalog_id = l.catalog_id
ORDER BY l.session_date DESC, l.created_at DESC
LIMIT 500"#,
)
.fetch_all(&state.pool)
.await?;
let history: Vec<serde_json::Value> = history_rows.iter().map(|r| {
use sqlx::Row;
let catalog_id: String = r.try_get("catalog_id").unwrap_or_default();
let gallery_filename: Option<String> = r.try_get("gallery_filename").unwrap_or_default();
let gallery_url = gallery_filename.map(|f| format!("/api/gallery/files/{}/{}", catalog_id, f));
serde_json::json!({
"date": r.try_get::<String, _>("session_date").unwrap_or_default(),
"catalog_id": catalog_id,
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<Option<String>, _>("obj_type").unwrap_or_default(),
"filter_id": r.try_get::<String, _>("filter_id").unwrap_or_default(),
"integration_min": r.try_get::<i64, _>("integration_min").unwrap_or(0),
"quality": r.try_get::<String, _>("quality").unwrap_or_default(),
"notes": r.try_get::<Option<String>, _>("notes").unwrap_or_default(),
"gallery_url": gallery_url,
})
}).collect();
// Integration goals: keeper minutes per filter per target, for goal progress tracking
let goals_raw = sqlx::query(
r#"SELECT
c.id, c.name, c.common_name, c.obj_type,
SUM(CASE WHEN l.filter_id = 'sv220' AND l.quality = 'keeper' THEN l.integration_min ELSE 0 END) as sv220_min,
SUM(CASE WHEN l.filter_id = 'c2' AND l.quality = 'keeper' THEN l.integration_min ELSE 0 END) as c2_min,
SUM(CASE WHEN l.filter_id = 'uvir' AND l.quality = 'keeper' THEN l.integration_min ELSE 0 END) as uvir_min,
SUM(CASE WHEN l.filter_id = 'sv260' AND l.quality = 'keeper' THEN l.integration_min ELSE 0 END) as sv260_min
FROM imaging_log l
JOIN catalog c ON c.id = l.catalog_id
WHERE l.quality = 'keeper'
GROUP BY l.catalog_id
ORDER BY (sv220_min + c2_min + uvir_min + sv260_min) DESC
LIMIT 30"#,
)
.fetch_all(&state.pool)
.await?;
let integration_goals: Vec<serde_json::Value> = goals_raw.iter().map(|r| {
use sqlx::Row;
serde_json::json!({
"id": r.try_get::<String, _>("id").unwrap_or_default(),
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<String, _>("obj_type").unwrap_or_default(),
"sv220_min": r.try_get::<i64, _>("sv220_min").unwrap_or(0),
"c2_min": r.try_get::<i64, _>("c2_min").unwrap_or(0),
"uvir_min": r.try_get::<i64, _>("uvir_min").unwrap_or(0),
"sv260_min": r.try_get::<i64, _>("sv260_min").unwrap_or(0),
})
}).collect();
Ok(Json(serde_json::json!({
"total_sessions": total_sessions,
"total_integration_min": total_integration_min.unwrap_or(0),
@@ -147,5 +309,9 @@ pub async fn get_stats(
"quality": quality_stats,
"top_targets": top_target_list,
"guiding": guiding_data,
"integration_gaps": gaps,
"history": history,
"catalogue_completion": catalogue_completion,
"integration_goals": integration_goals,
})))
}
backend/src/api/targets.rs
+362 -101
View File
@@ -8,12 +8,46 @@ use crate::{
astronomy::{
astro_twilight, compute_visibility, compute_visibility_with_step, julian_date, moon_altitude, moon_illumination,
moon_position, HorizonPoint, MoonState, TonightWindow,
coords::radec_to_altaz,
time::local_sidereal_time,
},
config::{LAT, LON},
filters::{get_workflow, recommend_filters},
};
use super::{AppError, AppState};
use super::solar_system::{fmt_ra, fmt_dec};
/// Look up (ra_deg, dec_deg, obj_type) from catalog first, then custom_targets.
/// Returns None if the target is not found in either table or has no coordinates.
async fn lookup_coords(pool: &sqlx::SqlitePool, id: &str) -> Result<Option<(f64, f64, String)>, AppError> {
use sqlx::Row;
if let Some(row) = sqlx::query("SELECT ra_deg, dec_deg, obj_type FROM catalog WHERE id = ?")
.bind(id)
.fetch_optional(pool)
.await?
{
return Ok(Some((
row.try_get("ra_deg").unwrap_or_default(),
row.try_get("dec_deg").unwrap_or_default(),
row.try_get("obj_type").unwrap_or_default(),
)));
}
if let Some(row) = sqlx::query(
"SELECT ra_deg, dec_deg, obj_type FROM custom_targets WHERE id = ? AND ra_deg IS NOT NULL AND dec_deg IS NOT NULL",
)
.bind(id)
.fetch_optional(pool)
.await?
{
return Ok(Some((
row.try_get::<f64, _>("ra_deg").unwrap_or_default(),
row.try_get::<f64, _>("dec_deg").unwrap_or_default(),
row.try_get::<String, _>("obj_type").unwrap_or_else(|_| "custom".to_string()),
)));
}
Ok(None)
}
#[derive(Debug, Deserialize)]
pub struct TargetsQuery {
@@ -30,6 +64,7 @@ pub struct TargetsQuery {
pub min_usable_min: Option<i32>,
pub mosaic_only: Option<bool>,
pub not_imaged: Option<bool>,
pub show_custom: Option<bool>,
}
#[derive(Debug, Serialize, sqlx::FromRow)]
@@ -81,8 +116,17 @@ pub async fn list_targets(
let mut bind_values: Vec<String> = vec![];
if let Some(ref t) = params.obj_type {
conditions.push("c.obj_type = ?".to_string());
bind_values.push(t.clone());
let types: Vec<&str> = t.split(',').map(|s| s.trim()).filter(|s| !s.is_empty()).collect();
if types.len() == 1 {
conditions.push("c.obj_type = ?".to_string());
bind_values.push(types[0].to_string());
} else if !types.is_empty() {
let placeholders = types.iter().map(|_| "?").collect::<Vec<_>>().join(",");
conditions.push(format!("c.obj_type IN ({})", placeholders));
for ty in &types {
bind_values.push(ty.to_string());
}
}
}
if let Some(ref con) = params.constellation {
conditions.push("c.constellation = ?".to_string());
@@ -92,7 +136,7 @@ pub async fn list_targets(
// Filter by filter suitability: use object-type compatibility, not moon-state-dependent recommended_filter.
// This ensures these filters always return results regardless of current moon phase.
match f.as_str() {
"uvir" => conditions.push("c.obj_type IN ('galaxy', 'reflection_nebula', 'open_cluster', 'globular_cluster', 'dark_nebula')".to_string()),
"uvir" => conditions.push("c.obj_type IN ('galaxy', 'galaxy_cluster', 'reflection_nebula', 'open_cluster', 'globular_cluster', 'dark_nebula')".to_string()),
"c2" | "sv220" => conditions.push("c.obj_type IN ('emission_nebula', 'snr', 'planetary_nebula')".to_string()),
"sv260" => {}, // LP filter works for all object types — no restriction
_ => {
@@ -120,9 +164,9 @@ pub async fn list_targets(
// (e.g. globular clusters, dark nebulae, open clusters) still appear.
// Skip filter when search is active so you can find objects like M31 off-season.
if tonight_filter && params.search.as_deref().unwrap_or("").is_empty() {
// Allow objects with no nightly_cache entry yet (newly ingested, NULL max_alt_deg)
// so freshly added VdB/LDN objects are visible before the first nightly precompute.
conditions.push("(nc.max_alt_deg >= 15 OR nc.max_alt_deg IS NULL)".to_string());
// Use horizon-aware is_visible_tonight flag stored in nightly_cache.
// Fall back to max_alt_deg >= 15 for rows that predate the flag (NULL).
conditions.push("(nc.is_visible_tonight = 1 OR (nc.is_visible_tonight IS NULL AND nc.max_alt_deg >= 15) OR nc.catalog_id IS NULL)".to_string());
}
if let Some(ref s) = params.search {
let like = format!("%{}%", s);
@@ -130,6 +174,15 @@ pub async fn list_targets(
let m_num: Option<i32> = s.trim()
.strip_prefix(['M', 'm'])
.and_then(|n| n.parse().ok());
// Support C-number search (e.g. "C20" → caldwell_num = 20)
let c_num: Option<i32> = s.trim()
.strip_prefix(['C', 'c'])
.and_then(|n| n.parse().ok());
// Support Arp search (e.g. "Arp85" → arp_num = 85)
let arp_num: Option<i32> = s.trim()
.to_lowercase()
.strip_prefix("arp")
.and_then(|n| n.trim().parse().ok());
if let Some(m) = m_num {
conditions.push(format!(
"(c.name LIKE ? OR c.common_name LIKE ? OR c.constellation LIKE ? OR c.messier_num = {})",
@@ -138,6 +191,21 @@ pub async fn list_targets(
bind_values.push(like.clone());
bind_values.push(like.clone());
bind_values.push(like);
} else if let Some(c) = c_num {
conditions.push(format!(
"(c.name LIKE ? OR c.common_name LIKE ? OR c.constellation LIKE ? OR c.caldwell_num = {})",
c
));
bind_values.push(like.clone());
bind_values.push(like.clone());
bind_values.push(like);
} else if let Some(a) = arp_num {
conditions.push(format!(
"(c.name LIKE ? OR c.common_name LIKE ? OR c.arp_num = {})",
a
));
bind_values.push(like.clone());
bind_values.push(like);
} else {
conditions.push("(c.name LIKE ? OR c.common_name LIKE ? OR c.constellation LIKE ?)".to_string());
bind_values.push(like.clone());
@@ -147,10 +215,26 @@ pub async fn list_targets(
}
let where_clause = conditions.join(" AND ");
// Fetch weather weight: go=1.0, marginal=0.7, nogo=0.3 (default 1.0 if no forecast)
let weather_weight: f64 = sqlx::query_scalar::<_, Option<String>>(
"SELECT go_nogo FROM weather_cache WHERE id = 1"
)
.fetch_optional(&state.pool)
.await
.unwrap_or(None)
.flatten()
.map(|s| match s.as_str() {
"go" => 1.0,
"marginal" => 0.7,
"nogo" => 0.3,
_ => 1.0,
})
.unwrap_or(1.0);
// "best" sort: composite score balancing altitude, FOV fill, usable time, moon separation.
// Score = alt_score * 0.4 + fill_score * 0.3 + time_score * 0.2 + moon_score * 0.1
// Targets outside 20–150% FOV fill are penalised (too small or too large single-panel).
let best_score_expr = r#"(
// Multiplied by weather_weight so cloudy nights rank all targets lower.
let best_score_expr = format!(r#"(
COALESCE(nc.max_alt_deg, 0) / 90.0 * 0.40
+ CASE
WHEN c.fov_fill_pct IS NULL THEN 0.15
@@ -160,33 +244,47 @@ pub async fn list_targets(
END
+ MIN(COALESCE(nc.usable_min, 0), 300) / 300.0 * 0.20
+ COALESCE(nc.moon_sep_deg, 90) / 180.0 * 0.10
) DESC"#;
let sort_col = match params.sort.as_deref() {
Some("transit") => "nc.transit_utc",
Some("size") => "c.size_arcmin_maj DESC",
Some("magnitude") => "c.mag_v",
Some("difficulty") => "c.difficulty",
Some("integration") => "total_integration DESC",
Some("altitude") => "nc.max_alt_deg DESC",
) * {weather_weight:.2} DESC"#, weather_weight = weather_weight);
let sort_col_owned: String = match params.sort.as_deref() {
Some("transit") => "nc.transit_utc".to_string(),
Some("size") => "c.size_arcmin_maj DESC".to_string(),
Some("magnitude") => "c.mag_v".to_string(),
Some("difficulty") => "c.difficulty".to_string(),
Some("integration") => "total_integration DESC".to_string(),
Some("altitude") => "nc.max_alt_deg DESC".to_string(),
Some("best_start") => "nc.best_start_utc ASC NULLS LAST".to_string(),
_ => best_score_expr,
};
let sort_col = sort_col_owned.as_str();
// Compare tonight's altitude to the seasonal peak (max over next 90 days).
// urgency: 'peak' >= 90%, 'rising' = 70–90% and date < peak date, 'declining' = 70–90% and date >= peak date, else null
let sql = format!(
r#"
SELECT c.id, c.name, c.common_name, c.obj_type, c.ra_deg, c.dec_deg, c.ra_h, c.dec_dms,
c.constellation, c.size_arcmin_maj, c.size_arcmin_min, c.mag_v, c.surface_brightness,
c.hubble_type, c.messier_num, c.is_highlight, c.fov_fill_pct, c.mosaic_flag,
c.hubble_type, c.messier_num, c.caldwell_num, c.arp_num, c.is_highlight, c.fov_fill_pct, c.mosaic_flag,
c.mosaic_panels_w, c.mosaic_panels_h, c.difficulty, c.guide_star_density,
nc.max_alt_deg, nc.usable_min, nc.transit_utc, nc.recommended_filter,
nc.best_start_utc, nc.best_end_utc, nc.moon_sep_deg,
CASE WHEN nc.max_alt_deg >= 15 THEN 1 ELSE 0 END as is_visible_tonight,
COALESCE(log_sum.total_min, 0) as total_integration
COALESCE(nc.is_visible_tonight, CASE WHEN nc.max_alt_deg >= 15 THEN 1 ELSE 0 END) as is_visible_tonight,
COALESCE(log_sum.total_min, 0) as total_integration,
seas.peak_alt as seasonal_peak_alt,
seas.peak_date as seasonal_peak_date
FROM catalog c
LEFT JOIN nightly_cache nc ON nc.catalog_id = c.id AND nc.night_date = '{today}'
LEFT JOIN (
SELECT catalog_id, SUM(integration_min) as total_min
FROM imaging_log GROUP BY catalog_id
) log_sum ON log_sum.catalog_id = c.id
LEFT JOIN (
SELECT catalog_id,
MAX(max_alt_deg) as peak_alt,
MIN(CASE WHEN max_alt_deg = (SELECT MAX(max_alt_deg) FROM nightly_cache n2 WHERE n2.catalog_id = n1.catalog_id AND n2.night_date BETWEEN '{today}' AND date('{today}', '+90 days')) THEN night_date ELSE NULL END) as peak_date
FROM nightly_cache n1
WHERE night_date BETWEEN '{today}' AND date('{today}', '+90 days')
GROUP BY catalog_id
) seas ON seas.catalog_id = c.id
WHERE {where_clause}
ORDER BY {sort_col}
LIMIT {limit} OFFSET {offset}
@@ -209,8 +307,24 @@ pub async fn list_targets(
.await
.map_err(AppError::from)?;
let items: Vec<serde_json::Value> = rows.iter().map(|row| {
let mut items: Vec<serde_json::Value> = rows.iter().map(|row| {
use sqlx::Row;
let tonight_alt: f64 = row.try_get::<Option<f64>, _>("max_alt_deg").unwrap_or_default().unwrap_or(0.0);
let peak_alt: f64 = row.try_get::<Option<f64>, _>("seasonal_peak_alt").unwrap_or_default().unwrap_or(0.0);
let peak_date: Option<String> = row.try_get("seasonal_peak_date").unwrap_or_default();
let urgency: serde_json::Value = if peak_alt >= 15.0 && tonight_alt >= 15.0 {
let ratio = tonight_alt / peak_alt;
if ratio >= 0.90 {
serde_json::json!("peak")
} else if ratio >= 0.70 {
let before_peak = peak_date.as_deref().map(|d| d > today.as_str()).unwrap_or(true);
serde_json::json!(if before_peak { "rising" } else { "declining" })
} else {
serde_json::Value::Null
}
} else {
serde_json::Value::Null
};
serde_json::json!({
"id": row.try_get::<String, _>("id").unwrap_or_default(),
"name": row.try_get::<String, _>("name").unwrap_or_default(),
@@ -227,6 +341,8 @@ pub async fn list_targets(
"surface_brightness": row.try_get::<Option<f64>, _>("surface_brightness").unwrap_or_default(),
"hubble_type": row.try_get::<Option<String>, _>("hubble_type").unwrap_or_default(),
"messier_num": row.try_get::<Option<i32>, _>("messier_num").unwrap_or_default(),
"caldwell_num": row.try_get::<Option<i32>, _>("caldwell_num").unwrap_or_default(),
"arp_num": row.try_get::<Option<i32>, _>("arp_num").unwrap_or_default(),
"is_highlight": row.try_get::<bool, _>("is_highlight").unwrap_or_default(),
"fov_fill_pct": row.try_get::<Option<f64>, _>("fov_fill_pct").unwrap_or_default(),
"mosaic_flag": row.try_get::<bool, _>("mosaic_flag").unwrap_or_default(),
@@ -234,7 +350,7 @@ pub async fn list_targets(
"mosaic_panels_h": row.try_get::<i32, _>("mosaic_panels_h").unwrap_or(1),
"difficulty": row.try_get::<Option<i32>, _>("difficulty").unwrap_or_default(),
"guide_star_density": row.try_get::<Option<String>, _>("guide_star_density").unwrap_or_default(),
"max_alt_deg": row.try_get::<Option<f64>, _>("max_alt_deg").unwrap_or_default(),
"max_alt_deg": tonight_alt,
"usable_min": row.try_get::<Option<i32>, _>("usable_min").unwrap_or_default(),
"transit_utc": row.try_get::<Option<String>, _>("transit_utc").unwrap_or_default(),
"recommended_filter": row.try_get::<Option<String>, _>("recommended_filter").unwrap_or_default(),
@@ -243,6 +359,8 @@ pub async fn list_targets(
"moon_sep_deg": row.try_get::<Option<f64>, _>("moon_sep_deg").unwrap_or_default(),
"is_visible_tonight": row.try_get::<Option<bool>, _>("is_visible_tonight").unwrap_or_default(),
"total_integration_min": row.try_get::<i64, _>("total_integration").unwrap_or(0),
"is_custom": false,
"urgency": urgency,
})
}).collect();
@@ -262,7 +380,82 @@ pub async fn list_targets(
for val in &bind_values {
count_query = count_query.bind(val);
}
let total: i64 = count_query.fetch_one(&state.pool).await.unwrap_or(0);
let mut total: i64 = count_query.fetch_one(&state.pool).await.unwrap_or(0);
// Append custom targets when show_custom is not explicitly false.
// Only on page 1, and only when not mosaic_only or not_imaged filter is active.
let show_custom = params.show_custom.unwrap_or(true);
if show_custom && page == 1 && !params.mosaic_only.unwrap_or(false) {
let custom_rows = sqlx::query(
"SELECT id, name, obj_type, ra_deg, dec_deg, notes FROM custom_targets WHERE ra_deg IS NOT NULL AND dec_deg IS NOT NULL ORDER BY created_at DESC",
)
.fetch_all(&state.pool)
.await
.unwrap_or_default();
if !custom_rows.is_empty() {
let jd = julian_date(chrono::Utc::now());
let lst = local_sidereal_time(jd, LON);
// Apply search filter to custom targets if active
let search_lower = params.search.as_deref().unwrap_or("").to_lowercase();
for row in &custom_rows {
use sqlx::Row;
let id: String = row.try_get("id").unwrap_or_default();
let name: String = row.try_get("name").unwrap_or_default();
if !search_lower.is_empty()
&& !id.to_lowercase().contains(&search_lower)
&& !name.to_lowercase().contains(&search_lower)
{
continue;
}
let ra: f64 = row.try_get("ra_deg").unwrap_or_default();
let dec: f64 = row.try_get("dec_deg").unwrap_or_default();
let obj_type: String = row.try_get("obj_type").unwrap_or_else(|_| "custom".to_string());
let (alt, _az) = radec_to_altaz(ra, dec, lst, LAT);
let current_alt = (alt * 10.0).round() / 10.0;
items.push(serde_json::json!({
"id": &id,
"name": &name,
"common_name": serde_json::Value::Null,
"obj_type": &obj_type,
"ra_deg": ra,
"dec_deg": dec,
"ra_h": fmt_ra(ra),
"dec_dms": fmt_dec(dec),
"constellation": serde_json::Value::Null,
"size_arcmin_maj": serde_json::Value::Null,
"size_arcmin_min": serde_json::Value::Null,
"mag_v": serde_json::Value::Null,
"surface_brightness": serde_json::Value::Null,
"hubble_type": serde_json::Value::Null,
"messier_num": serde_json::Value::Null,
"is_highlight": false,
"fov_fill_pct": serde_json::Value::Null,
"mosaic_flag": false,
"mosaic_panels_w": 1,
"mosaic_panels_h": 1,
"difficulty": serde_json::Value::Null,
"guide_star_density": serde_json::Value::Null,
"max_alt_deg": current_alt,
"usable_min": serde_json::Value::Null,
"transit_utc": serde_json::Value::Null,
"recommended_filter": serde_json::Value::Null,
"best_start_utc": serde_json::Value::Null,
"best_end_utc": serde_json::Value::Null,
"moon_sep_deg": serde_json::Value::Null,
"is_visible_tonight": alt > 15.0,
"total_integration_min": 0,
"is_custom": true,
}));
total += 1;
}
}
}
Ok(Json(serde_json::json!({
"items": items,
@@ -276,12 +469,14 @@ pub async fn get_target(
State(state): State<AppState>,
Path(id): Path<String>,
) -> Result<Json<serde_json::Value>, AppError> {
use sqlx::Row;
// Support both NGC/IC IDs and M-number IDs (e.g. "M42")
let m_num: Option<i32> = id.trim()
.strip_prefix(['M', 'm'])
.and_then(|n| n.parse().ok());
let row = if let Some(n) = m_num {
let catalog_row = if let Some(n) = m_num {
sqlx::query("SELECT * FROM catalog WHERE messier_num = ?")
.bind(n)
.fetch_optional(&state.pool)
@@ -291,34 +486,76 @@ pub async fn get_target(
.bind(&id)
.fetch_optional(&state.pool)
.await?
}
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
};
if let Some(row) = catalog_row {
return Ok(Json(serde_json::json!({
"id": row.try_get::<String, _>("id").unwrap_or_default(),
"name": row.try_get::<String, _>("name").unwrap_or_default(),
"common_name": row.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": row.try_get::<String, _>("obj_type").unwrap_or_default(),
"ra_deg": row.try_get::<f64, _>("ra_deg").unwrap_or_default(),
"dec_deg": row.try_get::<f64, _>("dec_deg").unwrap_or_default(),
"ra_h": row.try_get::<String, _>("ra_h").unwrap_or_default(),
"dec_dms": row.try_get::<String, _>("dec_dms").unwrap_or_default(),
"constellation": row.try_get::<Option<String>, _>("constellation").unwrap_or_default(),
"size_arcmin_maj": row.try_get::<Option<f64>, _>("size_arcmin_maj").unwrap_or_default(),
"size_arcmin_min": row.try_get::<Option<f64>, _>("size_arcmin_min").unwrap_or_default(),
"pos_angle_deg": row.try_get::<Option<f64>, _>("pos_angle_deg").unwrap_or_default(),
"mag_v": row.try_get::<Option<f64>, _>("mag_v").unwrap_or_default(),
"surface_brightness": row.try_get::<Option<f64>, _>("surface_brightness").unwrap_or_default(),
"hubble_type": row.try_get::<Option<String>, _>("hubble_type").unwrap_or_default(),
"messier_num": row.try_get::<Option<i32>, _>("messier_num").unwrap_or_default(),
"caldwell_num": row.try_get::<Option<i32>, _>("caldwell_num").unwrap_or_default(),
"arp_num": row.try_get::<Option<i32>, _>("arp_num").unwrap_or_default(),
"is_highlight": row.try_get::<bool, _>("is_highlight").unwrap_or_default(),
"fov_fill_pct": row.try_get::<Option<f64>, _>("fov_fill_pct").unwrap_or_default(),
"mosaic_flag": row.try_get::<bool, _>("mosaic_flag").unwrap_or_default(),
"mosaic_panels_w": row.try_get::<i32, _>("mosaic_panels_w").unwrap_or(1),
"mosaic_panels_h": row.try_get::<i32, _>("mosaic_panels_h").unwrap_or(1),
"difficulty": row.try_get::<Option<i32>, _>("difficulty").unwrap_or_default(),
"guide_star_density": row.try_get::<Option<String>, _>("guide_star_density").unwrap_or_default(),
})));
}
// Fall back to custom_targets
let custom_row = sqlx::query("SELECT * FROM custom_targets WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
let ra: Option<f64> = custom_row.try_get("ra_deg").unwrap_or_default();
let dec: Option<f64> = custom_row.try_get("dec_deg").unwrap_or_default();
let ra_h = ra.map(fmt_ra).unwrap_or_default();
let dec_dms = dec.map(fmt_dec).unwrap_or_default();
use sqlx::Row;
Ok(Json(serde_json::json!({
"id": row.try_get::<String, _>("id").unwrap_or_default(),
"name": row.try_get::<String, _>("name").unwrap_or_default(),
"common_name": row.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": row.try_get::<String, _>("obj_type").unwrap_or_default(),
"ra_deg": row.try_get::<f64, _>("ra_deg").unwrap_or_default(),
"dec_deg": row.try_get::<f64, _>("dec_deg").unwrap_or_default(),
"ra_h": row.try_get::<String, _>("ra_h").unwrap_or_default(),
"dec_dms": row.try_get::<String, _>("dec_dms").unwrap_or_default(),
"constellation": row.try_get::<Option<String>, _>("constellation").unwrap_or_default(),
"size_arcmin_maj": row.try_get::<Option<f64>, _>("size_arcmin_maj").unwrap_or_default(),
"size_arcmin_min": row.try_get::<Option<f64>, _>("size_arcmin_min").unwrap_or_default(),
"pos_angle_deg": row.try_get::<Option<f64>, _>("pos_angle_deg").unwrap_or_default(),
"mag_v": row.try_get::<Option<f64>, _>("mag_v").unwrap_or_default(),
"surface_brightness": row.try_get::<Option<f64>, _>("surface_brightness").unwrap_or_default(),
"hubble_type": row.try_get::<Option<String>, _>("hubble_type").unwrap_or_default(),
"messier_num": row.try_get::<Option<i32>, _>("messier_num").unwrap_or_default(),
"is_highlight": row.try_get::<bool, _>("is_highlight").unwrap_or_default(),
"fov_fill_pct": row.try_get::<Option<f64>, _>("fov_fill_pct").unwrap_or_default(),
"mosaic_flag": row.try_get::<bool, _>("mosaic_flag").unwrap_or_default(),
"mosaic_panels_w": row.try_get::<i32, _>("mosaic_panels_w").unwrap_or(1),
"mosaic_panels_h": row.try_get::<i32, _>("mosaic_panels_h").unwrap_or(1),
"difficulty": row.try_get::<Option<i32>, _>("difficulty").unwrap_or_default(),
"guide_star_density": row.try_get::<Option<String>, _>("guide_star_density").unwrap_or_default(),
"id": custom_row.try_get::<String, _>("id").unwrap_or_default(),
"name": custom_row.try_get::<String, _>("name").unwrap_or_default(),
"common_name": serde_json::Value::Null,
"obj_type": custom_row.try_get::<String, _>("obj_type").unwrap_or_else(|_| "custom".to_string()),
"ra_deg": ra.unwrap_or(0.0),
"dec_deg": dec.unwrap_or(0.0),
"ra_h": ra_h,
"dec_dms": dec_dms,
"constellation": serde_json::Value::Null,
"size_arcmin_maj": serde_json::Value::Null,
"size_arcmin_min": serde_json::Value::Null,
"pos_angle_deg": serde_json::Value::Null,
"mag_v": serde_json::Value::Null,
"surface_brightness": serde_json::Value::Null,
"hubble_type": serde_json::Value::Null,
"messier_num": serde_json::Value::Null,
"is_highlight": false,
"fov_fill_pct": serde_json::Value::Null,
"mosaic_flag": false,
"mosaic_panels_w": 1,
"mosaic_panels_h": 1,
"difficulty": serde_json::Value::Null,
"guide_star_density": serde_json::Value::Null,
"notes": custom_row.try_get::<Option<String>, _>("notes").unwrap_or_default(),
"is_custom": true,
})))
}
@@ -361,16 +598,9 @@ pub async fn get_visibility(
}
async fn compute_visibility_live(state: &AppState, id: &str) -> Result<Json<serde_json::Value>, AppError> {
let cat_row = sqlx::query("SELECT ra_deg, dec_deg, obj_type FROM catalog WHERE id = ?")
.bind(id)
.fetch_optional(&state.pool)
let (ra, dec, obj_type) = lookup_coords(&state.pool, id)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
use sqlx::Row;
let ra: f64 = cat_row.try_get("ra_deg").unwrap_or_default();
let dec: f64 = cat_row.try_get("dec_deg").unwrap_or_default();
let obj_type: String = cat_row.try_get("obj_type").unwrap_or_default();
.ok_or_else(|| AppError::NotFound(format!("Target {} not found or has no coordinates", id)))?;
let today = chrono::Utc::now().naive_utc().date();
let (dusk, dawn) = astro_twilight(today, LAT, LON)
@@ -421,15 +651,9 @@ pub async fn get_curve(
) -> Result<Json<serde_json::Value>, AppError> {
// Always compute live at 1-minute resolution for the interactive chart.
// The cached visibility_json uses 10-minute steps and lacks moon_alt_deg.
let cat_row = sqlx::query("SELECT ra_deg, dec_deg FROM catalog WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
let (ra, dec, _obj_type) = lookup_coords(&state.pool, &id)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
use sqlx::Row;
let ra: f64 = cat_row.try_get("ra_deg").unwrap_or_default();
let dec: f64 = cat_row.try_get("dec_deg").unwrap_or_default();
.ok_or_else(|| AppError::NotFound(format!("Target {} not found or has no coordinates", id)))?;
let date = chrono::Utc::now().naive_utc().date();
let (dusk, dawn) = astro_twilight(date, LAT, LON)
@@ -464,21 +688,17 @@ pub async fn get_filters(
State(state): State<AppState>,
Path(id): Path<String>,
) -> Result<Json<serde_json::Value>, AppError> {
let cat_row = sqlx::query("SELECT obj_type FROM catalog WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
let (ra, dec, obj_type) = lookup_coords(&state.pool, &id)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
use sqlx::Row;
let obj_type: String = cat_row.try_get("obj_type").unwrap_or_default();
let tonight_row = sqlx::query(
"SELECT moon_illumination, moon_ra_deg, moon_dec_deg FROM tonight WHERE id = 1",
)
.fetch_optional(&state.pool)
.await?;
use sqlx::Row;
let (moon_illum, moon_ra, moon_dec) = match tonight_row {
Some(r) => (
r.try_get::<Option<f64>, _>("moon_illumination").unwrap_or_default().unwrap_or(0.5),
@@ -491,19 +711,7 @@ pub async fn get_filters(
let now_jd = julian_date(chrono::Utc::now());
let moon_alt = moon_altitude(now_jd, LAT, LON);
let target_row = sqlx::query("SELECT ra_deg, dec_deg FROM catalog WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
.await?;
let moon_sep = match target_row {
Some(r) => {
let ra: f64 = r.try_get("ra_deg").unwrap_or_default();
let dec: f64 = r.try_get("dec_deg").unwrap_or_default();
crate::astronomy::moon_separation(moon_ra, moon_dec, ra, dec)
}
None => 90.0,
};
let moon_sep = crate::astronomy::moon_separation(moon_ra, moon_dec, ra, dec);
let recs = recommend_filters(&obj_type, moon_illum * 100.0, moon_alt, moon_sep);
Ok(Json(serde_json::json!({ "recommendations": recs })))
@@ -513,14 +721,9 @@ pub async fn get_workflow_handler(
State(state): State<AppState>,
Path((id, filter_id)): Path<(String, String)>,
) -> Result<Json<serde_json::Value>, AppError> {
let cat_row = sqlx::query("SELECT obj_type FROM catalog WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
let (_ra, _dec, obj_type) = lookup_coords(&state.pool, &id)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
use sqlx::Row;
let obj_type: String = cat_row.try_get("obj_type").unwrap_or_default();
let workflow = get_workflow(&obj_type, &filter_id);
Ok(Json(serde_json::to_value(workflow).unwrap()))
}
@@ -540,16 +743,9 @@ pub async fn get_yearly(
time::local_sidereal_time,
};
let cat_row = sqlx::query("SELECT ra_deg, dec_deg, obj_type FROM catalog WHERE id = ?")
.bind(&id)
.fetch_optional(&state.pool)
let (ra, dec, obj_type) = lookup_coords(&state.pool, &id)
.await?
.ok_or_else(|| AppError::NotFound(format!("Target {} not found", id)))?;
use sqlx::Row;
let ra: f64 = cat_row.try_get("ra_deg").unwrap_or_default();
let dec: f64 = cat_row.try_get("dec_deg").unwrap_or_default();
let obj_type: String = cat_row.try_get("obj_type").unwrap_or_default();
.ok_or_else(|| AppError::NotFound(format!("Target {} not found or has no coordinates", id)))?;
// Transit altitude: maximum the object can ever reach (constant for a DSO).
let transit_alt = (90.0 - (LAT - dec).abs()).max(0.0_f64).min(90.0_f64);
@@ -603,6 +799,71 @@ pub async fn get_yearly(
Ok(Json(serde_json::json!({ "catalog_id": id, "points": points })))
}
pub async fn get_similar(
State(state): State<AppState>,
Path(id): Path<String>,
) -> Result<Json<serde_json::Value>, AppError> {
use sqlx::Row;
// Get the target's constellation, obj_type, and transit_utc from tonight's cache
let target_row = sqlx::query(
"SELECT c.constellation, c.obj_type, c.ra_deg, nc.transit_utc FROM catalog c LEFT JOIN nightly_cache nc ON nc.catalog_id = c.id AND nc.night_date = date('now', 'localtime') WHERE c.id = ?",
)
.bind(&id)
.fetch_optional(&state.pool)
.await?;
let (constellation, obj_type, ra_deg, transit_utc): (Option<String>, String, f64, Option<String>) = match target_row {
Some(ref r) => (
r.try_get("constellation").unwrap_or(None),
r.try_get("obj_type").unwrap_or_default(),
r.try_get("ra_deg").unwrap_or_default(),
r.try_get("transit_utc").unwrap_or(None),
),
None => return Ok(Json(serde_json::json!({ "similar": [] }))),
};
// Find similar objects: same type + same constellation, ordered by RA proximity (≈ transit time proximity)
// RA difference of 15° ≈ 1h in transit time
let similar_rows = sqlx::query(
r#"SELECT c.id, c.name, c.common_name, c.obj_type, c.size_arcmin_maj,
c.fov_fill_pct, c.messier_num, nc.max_alt_deg, nc.transit_utc, nc.recommended_filter
FROM catalog c
LEFT JOIN nightly_cache nc ON nc.catalog_id = c.id AND nc.night_date = date('now', 'localtime')
WHERE c.id != ?
AND c.obj_type = ?
AND c.constellation = ?
AND ABS(c.ra_deg - ?) <= 25.0
AND nc.max_alt_deg >= 15
ORDER BY ABS(c.ra_deg - ?) ASC
LIMIT 5"#,
)
.bind(&id)
.bind(&obj_type)
.bind(&constellation)
.bind(ra_deg)
.bind(ra_deg)
.fetch_all(&state.pool)
.await?;
let similar: Vec<serde_json::Value> = similar_rows.iter().map(|r| {
serde_json::json!({
"id": r.try_get::<String, _>("id").unwrap_or_default(),
"name": r.try_get::<String, _>("name").unwrap_or_default(),
"common_name": r.try_get::<Option<String>, _>("common_name").unwrap_or_default(),
"obj_type": r.try_get::<String, _>("obj_type").unwrap_or_default(),
"size_arcmin_maj": r.try_get::<Option<f64>, _>("size_arcmin_maj").unwrap_or_default(),
"fov_fill_pct": r.try_get::<Option<f64>, _>("fov_fill_pct").unwrap_or_default(),
"messier_num": r.try_get::<Option<i32>, _>("messier_num").unwrap_or_default(),
"max_alt_deg": r.try_get::<Option<f64>, _>("max_alt_deg").unwrap_or_default(),
"transit_utc": r.try_get::<Option<String>, _>("transit_utc").unwrap_or_default(),
"recommended_filter": r.try_get::<Option<String>, _>("recommended_filter").unwrap_or_default(),
})
}).collect();
Ok(Json(serde_json::json!({ "similar": similar, "target_transit": transit_utc })))
}
pub async fn get_notes(
State(state): State<AppState>,
Path(id): Path<String>,
backend/src/astronomy/visibility.rs
+2 -2
View File
@@ -113,8 +113,8 @@ pub fn compute_visibility_with_step(
set_utc = Some(t);
}
// Best window: above 30°
if alt > 30.0 {
// Best window: above 30° AND above the custom horizon at this azimuth
if alt > 30.0_f64.max(h_alt) {
if best_start.is_none() {
best_start = Some(t);
}
backend/src/catalog/abell_gc.rs
+206
View File
@@ -0,0 +1,206 @@
/// Abell Galaxy Clusters (Abell 1958 + ACO 1989).
/// Source: VizieR VII/110A. Rich clusters (richness ≥ 1), Dec ≥ -30°.
/// These are galaxy clusters (type galaxy_cluster) — very faint, difficulty 4-5.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_ABELL_GC_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/110A\
&-out=Abell\
&-out=RAJ2000\
&-out=DEJ2000\
&-out=Rich\
&-out=m10\
&-out.max=3000\
&-oc.form=dec\
&Rich=>0";
#[derive(Debug, Clone)]
struct AbellGcRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
richness: u32,
mag10: f64, // magnitude of 10th brightest galaxy
}
pub async fn fetch_abell_gc() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("Abell GC: loaded {} entries from VizieR VII/110A", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("Abell GC: VizieR returned 0 rows — skipping (no fallback for 800+ clusters)");
Ok(vec![])
}
Err(e) => {
tracing::warn!("Abell GC fetch from VizieR failed ({}) — skipping", e);
Ok(vec![])
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(120))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_ABELL_GC_URL)
.send()
.await
.context("Abell GC fetch request failed")?
.text()
.await
.context("Abell GC response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("Abell GC: parsed {} rows from VizieR VII/110A", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR Abell GC response");
}
// Filter: Dec >= -30°, richness >= 1, reasonably bright (m10 < 20)
let filtered: Vec<AbellGcRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.richness >= 1)
.collect();
tracing::info!("Abell GC: {} rows pass filters", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<AbellGcRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("Abell")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("RAJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("DEJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let richness = col_idx("Rich")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok())
.unwrap_or(1);
let mag10 = col_idx("m10")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(18.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(AbellGcRow { id, ra_deg: ra, dec_deg: dec, richness, mag10 });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<AbellGcRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.richness >= 1)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: AbellGcRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("Abell{}", r.id);
// Typical Abell cluster: ~5-15 arcmin across
let diam_arcmin = 10.0_f64;
let fov_fill = (diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
// Difficulty based on mag10: fainter = harder
let difficulty = if r.mag10 < 16.0 { 4 } else { 5 };
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "galaxy_cluster".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(diam_arcmin),
size_arcmin_min: Some(diam_arcmin),
pos_angle_deg: None,
mag_v: Some(r.mag10),
surface_brightness: None,
hubble_type: Some(format!("Rich={} m10={:.1}", r.richness, r.mag10)),
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(difficulty),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
backend/src/catalog/abell_pn.rs
+209
View File
@@ -0,0 +1,209 @@
/// Abell Planetary Nebulae Catalogue (Abell 1966).
/// 86 large, low-surface-brightness PNe. Source: VizieR V/74.
/// These are ideal for narrowband imaging and not always in NGC/IC.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_ABELL_PN_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=V/74\
&-out=Abell\
&-out=RAJ2000\
&-out=DEJ2000\
&-out=Diam\
&-out.max=200\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct AbellPnRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
}
pub async fn fetch_abell_pn() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("Abell PN: loaded {} entries from VizieR V/74", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("Abell PN: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_abell_pn()))
}
Err(e) => {
tracing::warn!("Abell PN fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_abell_pn()))
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_ABELL_PN_URL)
.send()
.await
.context("Abell PN fetch request failed")?
.text()
.await
.context("Abell PN response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("Abell PN: parsed {} rows from VizieR V/74", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR Abell PN response");
}
let filtered: Vec<AbellPnRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 0.5)
.collect();
tracing::info!("Abell PN: {} rows pass filters", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<AbellPnRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("Abell")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("RAJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("DEJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(2.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(AbellPnRow { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<AbellPnRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 0.5)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: AbellPnRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("Abell{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
// Low SB Abell PNe — difficulty 5, narrowband only
obj_type: "planetary_nebula".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: Some("low-SB PN — narrowband only".to_string()),
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(5),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
fn get_prominent_abell_pn() -> Vec<AbellPnRow> {
vec![
AbellPnRow { id: 7, ra_deg: 56.630, dec_deg: -22.070, diam_arcmin: 13.0 },
AbellPnRow { id: 21, ra_deg: 109.815, dec_deg: 13.228, diam_arcmin: 10.2 }, // Medusa Nebula
AbellPnRow { id: 31, ra_deg: 118.350, dec_deg: 8.904, diam_arcmin: 16.9 },
AbellPnRow { id: 33, ra_deg: 122.050, dec_deg: -2.840, diam_arcmin: 4.5 },
AbellPnRow { id: 35, ra_deg: 181.535, dec_deg: -22.158, diam_arcmin: 8.0 },
AbellPnRow { id: 36, ra_deg: 186.750, dec_deg: 19.925, diam_arcmin: 8.0 },
AbellPnRow { id: 39, ra_deg: 244.440, dec_deg: 27.795, diam_arcmin: 2.8 },
AbellPnRow { id: 43, ra_deg: 282.995, dec_deg: 5.650, diam_arcmin: 1.0 },
AbellPnRow { id: 50, ra_deg: 289.625, dec_deg: -7.145, diam_arcmin: 1.5 },
AbellPnRow { id: 72, ra_deg: 344.645, dec_deg: 13.690, diam_arcmin: 2.3 },
AbellPnRow { id: 74, ra_deg: 349.925, dec_deg: 4.665, diam_arcmin: 14.0 },
]
}
backend/src/catalog/barnard.rs
+205
View File
@@ -0,0 +1,205 @@
/// Barnard Catalogue of Dark Nebulae (E.E. Barnard, 1927).
/// Fetched from VizieR VII/220A. These are dark nebulae not always in LDN.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_BARNARD_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/220A\
&-out=Barn\
&-out=RAJ2000\
&-out=DEJ2000\
&-out=Diam\
&-out.max=1000\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct BarnardRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
}
pub async fn fetch_barnard() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("Barnard: loaded {} entries from VizieR VII/220A", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("Barnard: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_barnard()))
}
Err(e) => {
tracing::warn!("Barnard fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_barnard()))
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_BARNARD_URL)
.send()
.await
.context("Barnard fetch request failed")?
.text()
.await
.context("Barnard response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("Barnard: parsed {} rows from VizieR VII/220A", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR Barnard response");
}
let filtered: Vec<BarnardRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 1.0)
.collect();
tracing::info!("Barnard: {} rows pass filters", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<BarnardRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("Barn")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("RAJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("DEJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(10.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(BarnardRow { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<BarnardRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 1.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: BarnardRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("B{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "dark_nebula".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin * 0.7),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(4),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
/// Hardcoded fallback: prominent Barnard dark nebulae observable from Villevieille.
fn get_prominent_barnard() -> Vec<BarnardRow> {
vec![
BarnardRow { id: 33, ra_deg: 85.244, dec_deg: -2.459, diam_arcmin: 6.0 }, // Horsehead
BarnardRow { id: 68, ra_deg: 250.014, dec_deg: -23.815, diam_arcmin: 5.0 },
BarnardRow { id: 72, ra_deg: 272.620, dec_deg: -23.640, diam_arcmin: 30.0 }, // Snake
BarnardRow { id: 86, ra_deg: 270.975, dec_deg: -27.970, diam_arcmin: 5.0 },
BarnardRow { id: 92, ra_deg: 277.690, dec_deg: -18.150, diam_arcmin: 15.0 },
BarnardRow { id: 142, ra_deg: 298.940, dec_deg: 10.380, diam_arcmin: 40.0 },
BarnardRow { id: 143, ra_deg: 299.160, dec_deg: 10.460, diam_arcmin: 30.0 },
BarnardRow { id: 228, ra_deg: 244.900, dec_deg: -40.000, diam_arcmin: 6.0 },
]
}
backend/src/catalog/caldwell.rs
+46
View File
@@ -0,0 +1,46 @@
/// Caldwell catalogue: C1–C109 mapped to NGC/IC/Sh2 catalog IDs.
/// Missing entries (southern objects not in catalog or objects without NGC IDs) are omitted.
pub fn caldwell_map() -> &'static [(i32, &'static str)] {
&[
(1, "NGC188"), (2, "NGC40"), (3, "NGC4236"), (4, "NGC7023"),
(5, "IC342"), (6, "NGC6543"), (7, "NGC2403"), (8, "NGC559"),
(9, "Sh2-155"), (10, "NGC663"), (11, "NGC7635"), (12, "NGC6946"),
(13, "NGC457"), (14, "NGC869"), (15, "NGC6826"), (16, "NGC7243"),
(17, "NGC147"), (18, "NGC185"), (19, "IC5146"), (20, "NGC7000"),
(21, "NGC4449"), (22, "NGC7662"), (23, "NGC891"), (24, "NGC1275"),
(25, "NGC2419"), (26, "NGC4244"), (27, "NGC6888"), (28, "NGC752"),
(29, "NGC5005"), (30, "NGC7331"), (31, "IC405"), (32, "NGC4631"),
(33, "NGC6992"), (34, "NGC6960"), (35, "NGC4889"), (36, "NGC4559"),
(37, "NGC6885"), (38, "NGC4565"), (39, "NGC2392"), (40, "NGC3626"),
(42, "NGC7006"), (43, "NGC7814"), (44, "NGC7479"), (45, "NGC5248"),
(46, "NGC2261"), (47, "NGC6934"), (48, "NGC2775"), (49, "NGC2237"),
(50, "NGC2244"), (51, "IC1613"), (52, "NGC4697"), (53, "NGC3115"),
(54, "NGC2506"), (55, "NGC7009"), (56, "NGC246"), (57, "NGC6822"),
(58, "NGC2360"), (59, "NGC3242"), (60, "NGC4038"), (61, "NGC4039"),
(62, "NGC247"), (63, "NGC7293"), (64, "NGC2362"), (65, "NGC253"),
(66, "NGC5694"), (67, "NGC1097"), (69, "NGC6302"), (70, "NGC300"),
(71, "NGC2477"), (72, "NGC55"), (73, "NGC1851"), (74, "NGC3132"),
(75, "NGC6124"), (76, "NGC6231"), (77, "NGC5128"), (78, "NGC6541"),
(79, "NGC3201"), (80, "NGC5139"), (81, "NGC6352"), (82, "NGC6193"),
(83, "NGC4945"), (84, "NGC5286"), (86, "NGC6397"), (87, "NGC1261"),
(88, "NGC5823"), (89, "NGC6087"), (90, "NGC2867"), (91, "NGC3532"),
(92, "NGC3372"), (93, "NGC3766"), (94, "NGC4755"), (95, "NGC6025"),
(96, "NGC2516"), (97, "NGC3114"), (98, "NGC4609"), (100, "IC2944"),
(101, "NGC6744"), (102, "IC2602"), (103, "NGC2070"), (104, "NGC362"),
(105, "NGC4833"), (106, "NGC104"), (107, "NGC6101"), (108, "NGC4372"),
(109, "NGC3195"),
]
}
/// Arp catalogue: selected peculiar galaxies (all NGC/IC already in DB).
pub fn arp_map() -> &'static [(i32, &'static str)] {
&[
(26, "NGC4258"), (29, "NGC6946"), (77, "NGC1097"), (82, "NGC2535"),
(84, "NGC5395"), (85, "NGC5194"), (86, "NGC5679"), (87, "NGC4424"),
(94, "NGC3226"), (116, "NGC4438"), (120, "NGC4438"), (147, "NGC2798"),
(148, "NGC2799"), (205, "NGC5427"), (220, "NGC2136"), (227, "NGC5278"),
(244, "NGC4038"), (245, "NGC4196"), (273, "NGC2341"), (274, "NGC4679"),
(281, "NGC2623"), (293, "NGC2596"), (295, "NGC2782"), (299, "NGC2892"),
(316, "NGC5679"), (317, "NGC1875"), (319, "NGC2648"), (337, "NGC3991"),
]
}
backend/src/catalog/collinder.rs
+103
View File
@@ -0,0 +1,103 @@
/// Collinder catalogue cross-reference map.
/// Most Collinder objects are NGC/IC open clusters — adds collinder_num to existing entries.
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
/// Collinder number → NGC/IC catalog ID (for cross-reference updating collinder_num column).
pub fn collinder_map() -> &'static [(i32, &'static str)] {
&[
(21, "NGC869"), // h Persei
(22, "NGC884"), // chi Persei
(33, "NGC1502"),
(39, "NGC1528"),
(50, "NGC1647"),
(58, "NGC1778"),
(65, "NGC1893"),
(69, "NGC2168"), // M35
(71, "NGC2185"),
(73, "NGC2232"),
(74, "NGC2244"), // Rosette
(97, "NGC2547"),
(107, "NGC2516"),
(111, "NGC2547"),
(121, "NGC2632"), // Beehive
(135, "NGC2682"), // M67
(223, "NGC4755"), // Jewel Box
(240, "NGC5749"),
(256, "NGC6067"),
(299, "NGC6405"), // M6
(302, "NGC6475"), // M7
(316, "NGC6523"), // M8
(340, "NGC6611"), // M16
(367, "NGC6716"),
(394, "NGC6866"),
(421, "NGC7039"),
(463, "NGC7654"), // M52
]
}
/// Very large Collinder clusters without NGC counterparts.
struct ColRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
common_name: Option<&'static str>,
}
pub fn get_standalone_collinder() -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
let rows: &[ColRow] = &[
ColRow { id: 399, ra_deg: 291.4, dec_deg: 24.1, diam_arcmin: 60.0, common_name: Some("Brocchi's Cluster (Coathanger)") },
ColRow { id: 285, ra_deg: 218.0, dec_deg: -53.0, diam_arcmin: 165.0, common_name: None },
];
rows.iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0)
.map(|r| {
let id = format!("Cr{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let cn = r.common_name
.map(|s| s.to_string())
.or_else(|| names.get(id.as_str()).map(|s| s.to_string()));
let is_highlight = cn.is_some();
CatalogEntry {
id: id.clone(),
name: id.clone(),
common_name: cn,
obj_type: "open_cluster".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(1),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
})
.collect()
}
backend/src/catalog/filter.rs
+7 -5
View File
@@ -42,12 +42,14 @@ fn normalize_type_token(t: &str) -> Option<&'static str> {
"GGroup" | "GCl" | "CG" => Some("galaxy_group"),
"GPair" | "PG" => Some("galaxy_pair"),
"GTrpl" | "IG" => Some("interacting_galaxy"),
"GCl" | "Glob" => Some("globular_cluster"),
"OCl" | "OC" => Some("open_cluster"),
"Glob" => Some("globular_cluster"),
// Open cluster tokens — includes "Cl" used in "Cl+N" compound types
"OCl" | "OC" | "Cl" => Some("open_cluster"),
"Cl+N" => Some("emission_nebula"), // Cluster+Nebula, treat as nebula
"EmN" | "NB" | "EN" | "HII" | "BN" => Some("emission_nebula"),
"RfN" | "RN" => Some("reflection_nebula"),
"Neb" | "NF" => Some("nebula"),
// Generic nebula tokens — "N" appears in compound "Cl+N"
"Neb" | "NF" | "N" => Some("nebula"),
"PN" => Some("planetary_nebula"),
"SNR" => Some("snr"),
"DN" => Some("dark_nebula"),
@@ -73,8 +75,8 @@ pub fn normalize_type(raw: &str) -> Option<&'static str> {
// Priority order: emission/reflection > cluster > galaxy
let priority = |s: &str| -> u8 {
match s.trim() {
"NB" | "EN" | "HII" | "BN" | "RN" | "PN" | "SNR" | "DN" | "NF" => 10,
"GC" | "OC" => 5,
"NB" | "EN" | "HII" | "BN" | "RN" | "PN" | "SNR" | "DN" | "NF" | "N" | "Neb" => 10,
"GC" | "OC" | "Cl" | "Glob" => 5,
"G" | "GX" | "GG" | "IG" | "PG" | "CG" => 3,
_ => 0,
}
backend/src/catalog/gum.rs
+199
View File
@@ -0,0 +1,199 @@
/// Gum Catalogue of Southern HII Regions (Gum 1955).
/// Fetched from VizieR XI/75. Mostly Dec < -30° but ~20-30 entries are in range.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_GUM_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=XI/75\
&-out=Gum\
&-out=_RA\
&-out=_DE\
&-out=Diam\
&-out.max=200\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct GumRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
}
pub async fn fetch_gum() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("Gum: loaded {} entries from VizieR XI/75", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("Gum: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_gum()))
}
Err(e) => {
tracing::warn!("Gum fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_gum()))
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_GUM_URL)
.send()
.await
.context("Gum fetch request failed")?
.text()
.await
.context("Gum response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("Gum: parsed {} rows from VizieR XI/75", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR Gum response");
}
let filtered: Vec<GumRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.collect();
tracing::info!("Gum: {} rows pass filters (Dec >= -30°)", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<GumRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("Gum")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(15.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(GumRow { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<GumRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: GumRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("Gum{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "emission_nebula".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin * 0.7),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(3),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
fn get_prominent_gum() -> Vec<GumRow> {
// Small fallback — most Gum objects are far south, these are in range
vec![
GumRow { id: 12, ra_deg: 126.0, dec_deg: -47.5, diam_arcmin: 36.0 },
GumRow { id: 17, ra_deg: 131.0, dec_deg: -43.0, diam_arcmin: 20.0 },
]
}
backend/src/catalog/lbn.rs
+217
View File
@@ -0,0 +1,217 @@
/// Lynds Bright Nebulae (LBN) catalog.
/// Fetched from VizieR VII/9 (Lynds 1965). Emission/reflection nebulae not always in NGC/IC.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_LBN_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/9\
&-out=LBN\
&-out=_RA\
&-out=_DE\
&-out=Diam\
&-out=Class\
&-out.max=2000\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct LbnRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
obj_type: String,
}
pub async fn fetch_lbn() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("LBN: loaded {} entries from VizieR VII/9", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("LBN: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_lbn()))
}
Err(e) => {
tracing::warn!("LBN fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_lbn()))
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(90))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_LBN_URL)
.send()
.await
.context("LBN fetch request failed")?
.text()
.await
.context("LBN response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("LBN: parsed {} rows from VizieR VII/9", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR LBN response");
}
let filtered: Vec<LbnRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.collect();
tracing::info!("LBN: {} rows pass filters", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<LbnRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("LBN")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(10.0);
// Class: 1=emission, 2=reflection, 3=mixed — default emission
let class = col_idx("Class")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok())
.unwrap_or(1);
let obj_type = if class == 2 { "reflection_nebula" } else { "emission_nebula" };
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(LbnRow {
id,
ra_deg: ra,
dec_deg: dec,
diam_arcmin: diam,
obj_type: obj_type.to_string(),
});
}
}
rows
}
fn build_entries_from_rows(rows: Vec<LbnRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: LbnRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("LBN{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: r.obj_type,
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin * 0.7),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(3),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
fn get_prominent_lbn() -> Vec<LbnRow> {
// A small fallback set of observable LBN nebulae
vec![
LbnRow { id: 974, ra_deg: 83.820, dec_deg: -5.400, diam_arcmin: 60.0, obj_type: "emission_nebula".to_string() },
LbnRow { id: 1040, ra_deg: 84.050, dec_deg: 9.960, diam_arcmin: 120.0, obj_type: "reflection_nebula".to_string() },
LbnRow { id: 667, ra_deg: 314.750, dec_deg: 44.490, diam_arcmin: 80.0, obj_type: "emission_nebula".to_string() },
LbnRow { id: 468, ra_deg: 253.470, dec_deg: -34.360, diam_arcmin: 50.0, obj_type: "emission_nebula".to_string() },
]
}
backend/src/catalog/ldn.rs
+162 -87
View File
@@ -1,13 +1,27 @@
/// Lynds Dark Nebula catalog (LDN).
/// Note: VizieR VI/71A is spectral lines catalog, not dark nebulae.
/// Using hardcoded list of ~50 prominent LDN objects suitable for imaging.
/// Primary source: VizieR catalog VII/7A (Lynds 1962).
/// Fallback: hardcoded list of ~50 prominent LDN objects.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
#[derive(Debug)]
/// VizieR VII/7A — Lynds Catalogue of Dark Nebulae (1962).
/// Requesting LDN number, max angular size, opacity, and computed RA/Dec.
const VIZIER_LDN_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/7A\
&-out=LDN\
&-out=Dmax\
&-out=Opac\
&-out=_RA\
&-out=_DE\
&-out.max=9999\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct LdnRow {
id: u32,
ra_deg: f64,
@@ -18,135 +32,151 @@ struct LdnRow {
}
pub async fn fetch_ldn() -> anyhow::Result<Vec<CatalogEntry>> {
let rows = get_prominent_ldns();
tracing::info!("Loaded {} prominent LDN objects", rows.len());
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("LDN: loaded {} entries from VizieR", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("LDN: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_ldns()))
}
Err(e) => {
tracing::warn!("LDN fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_ldns()))
}
}
}
let now = Utc::now().timestamp();
let entries = rows
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(90))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_LDN_URL)
.send()
.await
.context("LDN fetch request failed")?
.text()
.await
.context("LDN response read failed")?;
tracing::debug!("LDN raw response first 500 chars: {}", &text[..text.len().min(500)]);
let rows = parse_vizier_tsv(&text);
tracing::info!("LDN: parsed {} rows from VizieR VII/7A", rows.len());
let total = rows.len();
let filtered: Vec<LdnRow> = rows
.into_iter()
.filter(|r| {
r.dec_deg >= -30.0
&& r.dec_deg <= 75.0
&& r.dmax_arcmin >= 2.0 // skip tiny blobs
&& r.opacity >= 3 // only moderately opaque or more
&& r.dmax_arcmin >= 2.0
&& r.opacity >= 3
})
.map(|r| build_entry(r, now))
.collect();
Ok(entries)
tracing::info!("LDN: {}/{} rows visible from mid-northern latitudes", filtered.len(), total);
Ok(build_entries_from_rows(filtered))
}
/// Parse VizieR TSV output. Handles `#` comment lines, tab separators, dash separator row.
fn parse_vizier_tsv(text: &str) -> Vec<LdnRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut skip_unit_row = false;
let mut past_separator = false;
for line in text.lines() {
// Skip comment/meta lines
if line.starts_with('#') {
continue;
}
let line = line.trim();
if line.is_empty() {
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
// First non-comment line is the header
// First non-comment line is the column header
if header.is_empty() {
header = line.split_whitespace().map(|s| s.to_string()).collect();
skip_unit_row = true;
header = if trimmed.contains('\t') {
trimmed.split('\t').map(|s| s.trim().to_string()).collect()
} else {
trimmed.split_whitespace().map(|s| s.to_string()).collect()
};
continue;
}
// Skip the units/separator row (contains dashes)
if skip_unit_row && line.starts_with("---") {
skip_unit_row = false;
continue;
}
if skip_unit_row {
skip_unit_row = false;
// Skip separator/units row (lines of dashes or unit strings)
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = line.split_whitespace().collect();
if cols.is_empty() {
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 2 {
continue;
}
let idx = |name: &str| header.iter().position(|h| h == name);
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = idx("LDN")
let id = col_idx("LDN")
.and_then(|i| cols.get(i))
.and_then(|s| s.trim().parse::<u32>().ok());
let ra = idx("_RA")
.and_then(|s| s.parse::<u32>().ok());
let dmax = col_idx("Dmax")
.and_then(|i| cols.get(i))
.and_then(|s| s.trim().parse::<f64>().ok());
let dec = idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.trim().parse::<f64>().ok());
let dmax = idx("Size")
.and_then(|i| cols.get(i))
.and_then(|s| s.trim().parse::<f64>().ok())
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(5.0);
let dmin = dmax * 0.6;
let opacity = idx("Opac")
let opacity = col_idx("Opac")
.and_then(|i| cols.get(i))
.and_then(|s| s.trim().parse::<u8>().ok())
.and_then(|s| s.parse::<u8>().ok())
.unwrap_or(3);
// _RA and _DE are VizieR-computed decimal degrees
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.get(cols.len().saturating_sub(2)).and_then(|s| s.parse().ok()));
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.last().and_then(|s| s.parse().ok()));
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(LdnRow { id, ra_deg: ra, dec_deg: dec, dmax_arcmin: dmax, dmin_arcmin: dmin, opacity });
rows.push(LdnRow {
id,
ra_deg: ra,
dec_deg: dec,
dmax_arcmin: dmax,
dmin_arcmin: dmax * 0.6,
opacity,
});
}
}
rows
}
/// Hardcoded list of prominent LDN dark nebulae suitable for amateur astrophotography.
/// Data from Lynds (1962) catalog, widely referenced in astrophotography literature.
/// TODO: Replace with full VizieR catalog once correct source ID is identified.
fn get_prominent_ldns() -> Vec<LdnRow> {
vec![
// LDN 6 - near Orion
LdnRow { id: 6, ra_deg: 81.60, dec_deg: -0.63, dmax_arcmin: 50.0, dmin_arcmin: 30.0, opacity: 4 },
// LDN 43 - Orion region
LdnRow { id: 43, ra_deg: 85.38, dec_deg: -2.38, dmax_arcmin: 45.0, dmin_arcmin: 30.0, opacity: 3 },
// LDN 70 - Aquila
LdnRow { id: 70, ra_deg: 293.75, dec_deg: -2.63, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
// LDN 123 - Cygnus complex
LdnRow { id: 123, ra_deg: 300.13, dec_deg: 37.13, dmax_arcmin: 60.0, dmin_arcmin: 40.0, opacity: 4 },
// LDN 134 - Cygnus X
LdnRow { id: 134, ra_deg: 314.13, dec_deg: 32.88, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 4 },
// LDN 158 - Cygnus region
LdnRow { id: 158, ra_deg: 328.13, dec_deg: 51.88, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
// LDN 365 - Centaurus
LdnRow { id: 365, ra_deg: 183.75, dec_deg: -54.38, dmax_arcmin: 25.0, dmin_arcmin: 15.0, opacity: 3 },
// LDN 483 - Perseus
LdnRow { id: 483, ra_deg: 47.38, dec_deg: 10.63, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
// LDN 507 - Cassiopeia
LdnRow { id: 507, ra_deg: 24.63, dec_deg: 57.38, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
// LDN 560 - Cepheus
LdnRow { id: 560, ra_deg: 348.38, dec_deg: 59.13, dmax_arcmin: 50.0, dmin_arcmin: 35.0, opacity: 4 },
// LDN 691 - Perseus
LdnRow { id: 691, ra_deg: 50.88, dec_deg: 26.13, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
// LDN 717 - Ophiuchus
LdnRow { id: 717, ra_deg: 261.63, dec_deg: -17.88, dmax_arcmin: 30.0, dmin_arcmin: 18.0, opacity: 3 },
// LDN 893 - Vulpecula
LdnRow { id: 893, ra_deg: 328.88, dec_deg: 17.88, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
// LDN 935 - Cygnus
LdnRow { id: 935, ra_deg: 305.13, dec_deg: 45.13, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
// LDN 1003 - Cygnus region
LdnRow { id: 1003, ra_deg: 314.63, dec_deg: 30.88, dmax_arcmin: 45.0, dmin_arcmin: 30.0, opacity: 4 },
// LDN 1035 - Cepheus
LdnRow { id: 1035, ra_deg: 2.13, dec_deg: 70.13, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
// LDN 1068 - Cepheis
LdnRow { id: 1068, ra_deg: 22.13, dec_deg: 68.38, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
// LDN 1551 - Taurus
LdnRow { id: 1551, ra_deg: 77.88, dec_deg: 27.63, dmax_arcmin: 30.0, dmin_arcmin: 18.0, opacity: 3 },
// Additional nearby dark nebulae
LdnRow { id: 1689, ra_deg: 351.13, dec_deg: 49.13, dmax_arcmin: 25.0, dmin_arcmin: 15.0, opacity: 3 },
LdnRow { id: 1709, ra_deg: 20.88, dec_deg: 48.50, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
]
fn build_entries_from_rows(rows: Vec<LdnRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.dmax_arcmin >= 2.0 && r.opacity >= 3)
.map(|r| build_entry(r, now))
.collect()
}
fn build_entry(r: LdnRow, now: i64) -> CatalogEntry {
@@ -186,3 +216,48 @@ fn build_entry(r: LdnRow, now: i64) -> CatalogEntry {
fetched_at: now,
}
}
/// Hardcoded fallback: prominent LDN dark nebulae suitable for amateur astrophotography.
/// Data from Lynds (1962) catalog.
fn get_prominent_ldns() -> Vec<LdnRow> {
vec![
// Orion / Taurus / Perseus region
LdnRow { id: 6, ra_deg: 81.60, dec_deg: -0.63, dmax_arcmin: 50.0, dmin_arcmin: 30.0, opacity: 4 },
LdnRow { id: 43, ra_deg: 85.38, dec_deg: -2.38, dmax_arcmin: 45.0, dmin_arcmin: 30.0, opacity: 3 },
LdnRow { id: 483, ra_deg: 47.38, dec_deg: 10.63, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
LdnRow { id: 507, ra_deg: 24.63, dec_deg: 57.38, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
LdnRow { id: 691, ra_deg: 50.88, dec_deg: 26.13, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
LdnRow { id: 1551, ra_deg: 77.88, dec_deg: 27.63, dmax_arcmin: 30.0, dmin_arcmin: 18.0, opacity: 3 },
// Aquila / Serpens
LdnRow { id: 70, ra_deg: 293.75, dec_deg: -2.63, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
LdnRow { id: 673, ra_deg: 289.00, dec_deg: 10.83, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 4 },
LdnRow { id: 717, ra_deg: 261.63, dec_deg: -17.88, dmax_arcmin: 30.0, dmin_arcmin: 18.0, opacity: 3 },
// Cygnus / Cepheus region
LdnRow { id: 123, ra_deg: 300.13, dec_deg: 37.13, dmax_arcmin: 60.0, dmin_arcmin: 40.0, opacity: 4 },
LdnRow { id: 134, ra_deg: 314.13, dec_deg: 32.88, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 4 },
LdnRow { id: 158, ra_deg: 328.13, dec_deg: 51.88, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
LdnRow { id: 893, ra_deg: 328.88, dec_deg: 17.88, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
LdnRow { id: 935, ra_deg: 305.13, dec_deg: 45.13, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
LdnRow { id: 1003, ra_deg: 314.63, dec_deg: 30.88, dmax_arcmin: 45.0, dmin_arcmin: 30.0, opacity: 4 },
LdnRow { id: 560, ra_deg: 348.38, dec_deg: 59.13, dmax_arcmin: 50.0, dmin_arcmin: 35.0, opacity: 4 },
LdnRow { id: 1035, ra_deg: 2.13, dec_deg: 70.13, dmax_arcmin: 35.0, dmin_arcmin: 22.0, opacity: 3 },
LdnRow { id: 1068, ra_deg: 22.13, dec_deg: 68.38, dmax_arcmin: 40.0, dmin_arcmin: 25.0, opacity: 3 },
// Additional
LdnRow { id: 365, ra_deg: 183.75, dec_deg: -54.38, dmax_arcmin: 25.0, dmin_arcmin: 15.0, opacity: 3 },
LdnRow { id: 1689, ra_deg: 351.13, dec_deg: 49.13, dmax_arcmin: 25.0, dmin_arcmin: 15.0, opacity: 3 },
LdnRow { id: 1709, ra_deg: 20.88, dec_deg: 48.50, dmax_arcmin: 30.0, dmin_arcmin: 20.0, opacity: 3 },
// Ophiuchus dark cloud complex
LdnRow { id: 1688, ra_deg: 247.42, dec_deg: -24.43, dmax_arcmin: 120.0, dmin_arcmin: 80.0, opacity: 6 },
LdnRow { id: 1712, ra_deg: 250.50, dec_deg: -21.50, dmax_arcmin: 60.0, dmin_arcmin: 40.0, opacity: 5 },
// Lupus dark clouds
LdnRow { id: 1782, ra_deg: 234.80, dec_deg: -34.10, dmax_arcmin: 50.0, dmin_arcmin: 30.0, opacity: 5 },
// Chamaeleon
LdnRow { id: 1795, ra_deg: 168.00, dec_deg: -77.30, dmax_arcmin: 60.0, dmin_arcmin: 40.0, opacity: 5 },
// B68 (Barnard 68 / LDN1622 area)
LdnRow { id: 1622, ra_deg: 87.95, dec_deg: 2.33, dmax_arcmin: 15.0, dmin_arcmin: 10.0, opacity: 6 },
// B33 (Horsehead — dark against IC434 emission)
LdnRow { id: 1630, ra_deg: 85.25, dec_deg: -2.45, dmax_arcmin: 20.0, dmin_arcmin: 15.0, opacity: 6 },
// Pipe Nebula
LdnRow { id: 1773, ra_deg: 259.50, dec_deg: -27.50, dmax_arcmin: 180.0, dmin_arcmin: 30.0, opacity: 5 },
]
}
backend/src/catalog/melotte.rs
+103
View File
@@ -0,0 +1,103 @@
/// Melotte catalogue cross-reference map.
/// Most Melotte objects are NGC/IC open clusters — we add melotte_num to existing entries
/// and fetch new entries (very large clusters not in NGC) from a hardcoded list.
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
/// Melotte number → NGC/IC catalog ID (for cross-reference updating melotte_num column).
pub fn melotte_map() -> &'static [(i32, &'static str)] {
&[
(20, "NGC869"), // Alpha Persei cluster (actually Mel 20 is different but overlaps)
(22, "NGC1432"), // Pleiades
(25, "NGC1952"), // Hyades (no NGC, see standalone below)
(31, "NGC1502"),
(34, "NGC1647"),
(35, "NGC1817"),
(41, "NGC2232"),
(42, "NGC2244"), // Rosette cluster
(43, "NGC2264"), // Christmas Tree cluster
(44, "NGC2632"), // Beehive/Praesepe
(45, "NGC2516"),
(47, "NGC2422"), // M47
(48, "NGC2548"), // M48
(71, "NGC3532"),
(101, "NGC4755"), // Jewel Box
(111, "NGC5457"), // Pinwheel – actually a galaxy but Mel 111 = Coma cluster
(186, "NGC6405"), // M6
(187, "NGC6475"), // M7
(188, "NGC6494"), // M23
(198, "NGC6523"), // M8 Lagoon
(200, "NGC6514"), // M20 Trifid
(206, "NGC6611"), // M16 Eagle
(231, "NGC6853"), // M27
(240, "NGC7089"), // M2
]
}
/// Melotte objects without NGC IDs — standalone entries to inject into catalog.
struct MelRow {
id: u32,
name: &'static str,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
common_name: Option<&'static str>,
}
pub fn get_standalone_melotte() -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
let rows: &[MelRow] = &[
MelRow { id: 20, name: "Mel20", ra_deg: 51.0, dec_deg: 49.0, diam_arcmin: 185.0, common_name: Some("Alpha Persei Cluster") },
MelRow { id: 25, name: "Mel25", ra_deg: 66.5, dec_deg: 15.9, diam_arcmin: 330.0, common_name: Some("Hyades") },
MelRow { id: 111, name: "Mel111", ra_deg: 186.0, dec_deg: 26.0, diam_arcmin: 275.0, common_name: Some("Coma Star Cluster") },
];
rows.iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0)
.map(|r| {
let id = format!("Mel{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let cn = r.common_name
.map(|s| s.to_string())
.or_else(|| names.get(id.as_str()).map(|s| s.to_string()));
let is_highlight = cn.is_some();
CatalogEntry {
id: id.clone(),
name: r.name.to_string(),
common_name: cn,
obj_type: "open_cluster".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(1),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
})
.collect()
}
backend/src/catalog/mod.rs
+224 -102
View File
@@ -1,7 +1,18 @@
pub mod abell_gc;
pub mod abell_pn;
pub mod barnard;
pub mod pgc;
pub mod caldwell;
pub mod collinder;
pub mod fetch;
pub mod filter;
pub mod gum;
pub mod lbn;
pub mod ldn;
pub mod melotte;
pub mod popular_names;
pub mod rcw;
pub mod sh2;
pub mod vdb;
use anyhow::Context;
@@ -13,7 +24,7 @@ use self::popular_names::popular_names;
const CATALOG_TTL_SECS: i64 = 7 * 24 * 3600;
// Bump this string whenever catalog ingestion logic changes.
pub const CATALOG_VERSION: &str = "v5-normalized-ids";
pub const CATALOG_VERSION: &str = "v11-pgc";
/// Force a full catalog re-ingest regardless of TTL or version.
pub async fn force_refresh_catalog(pool: &SqlitePool) -> anyhow::Result<usize> {
@@ -76,11 +87,19 @@ async fn do_refresh(pool: &SqlitePool) -> anyhow::Result<usize> {
/// Useful for testing, validation, and dry-run operations.
pub async fn build_catalog() -> anyhow::Result<Vec<CatalogEntry>> {
// Fetch all sources in parallel
tracing::info!("Refreshing catalog from OpenNGC + VdB + LDN...");
let (ngc_rows_res, vdb_res, ldn_res) = tokio::join!(
tracing::info!("Refreshing catalog from OpenNGC + Sh2 + VdB + LDN + Barnard + LBN + Gum + RCW + AbellPN + AbellGC + PGC...");
let (ngc_rows_res, sh2_res, vdb_res, ldn_res, barnard_res, lbn_res, gum_res, rcw_res, abell_pn_res, abell_gc_res, pgc_res) = tokio::join!(
fetch_opengc(),
sh2::fetch_sh2(),
vdb::fetch_vdb(),
ldn::fetch_ldn(),
barnard::fetch_barnard(),
lbn::fetch_lbn(),
gum::fetch_gum(),
rcw::fetch_rcw(),
abell_pn::fetch_abell_pn(),
abell_gc::fetch_abell_gc(),
pgc::fetch_pgc(),
);
let names = popular_names();
@@ -96,14 +115,25 @@ pub async fn build_catalog() -> anyhow::Result<Vec<CatalogEntry>> {
tracing::info!("OpenNGC: {}/{} rows successfully derived to entries", entries.len(), suitable.len());
// Generate additional Sharpless (Sh2) entries from objects that have Sh2 identifiers
let sh2_aliases: Vec<CatalogEntry> = entries
.iter()
.filter_map(|entry| create_sh2_alias(entry, &names))
.collect();
// Deduplicate Sh2 entries against NGC/IC objects that may share coordinates.
// We track IDs already present so Sh2 aliases for NGC objects with existing
// entries (e.g. Sh2-100 = IC1318 already in catalog) are skipped.
let existing_ids: std::collections::HashSet<String> = entries.iter().map(|e| e.id.clone()).collect();
tracing::info!("Generated {} Sharpless alias entries", sh2_aliases.len());
entries.extend(sh2_aliases);
match sh2_res {
Ok(sh2_entries) => {
let before = entries.len();
// Only add Sh2 entries whose ID is not already a primary catalog entry.
// (OpenNGC already covers many of these via its Identifiers column.)
let new_sh2: Vec<_> = sh2_entries.into_iter()
.filter(|e| !existing_ids.contains(&e.id))
.collect();
tracing::info!("Adding {} Sh2 entries (non-duplicate)", new_sh2.len());
entries.extend(new_sh2);
tracing::info!("Catalog after Sh2: {} entries (was {})", entries.len(), before);
}
Err(e) => tracing::warn!("Sh2 fetch failed (skipping): {}", e),
}
match vdb_res {
Ok(vdb_entries) => {
@@ -121,101 +151,156 @@ pub async fn build_catalog() -> anyhow::Result<Vec<CatalogEntry>> {
Err(e) => tracing::warn!("LDN fetch failed (skipping): {}", e),
}
// Barnard dark nebulae — deduplicate against LDN by position (2' radius)
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
match barnard_res {
Ok(barnard_entries) => {
let new_barnard: Vec<_> = barnard_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033 // ~2 arcmin
})
})
.collect();
tracing::info!("Adding {} Barnard dark nebula entries (after dedup)", new_barnard.len());
entries.extend(new_barnard);
}
Err(e) => tracing::warn!("Barnard fetch failed (skipping): {}", e),
}
// LBN nebulae — deduplicate against existing NGC/IC/Sh2
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
match lbn_res {
Ok(lbn_entries) => {
let new_lbn: Vec<_> = lbn_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033 // ~2 arcmin
})
})
.collect();
tracing::info!("Adding {} LBN entries (after dedup)", new_lbn.len());
entries.extend(new_lbn);
}
Err(e) => tracing::warn!("LBN fetch failed (skipping): {}", e),
}
// Melotte standalone entries (very large clusters without NGC IDs)
let melotte_standalone = melotte::get_standalone_melotte();
let existing_ids: std::collections::HashSet<String> = entries.iter().map(|e| e.id.clone()).collect();
let new_melotte: Vec<_> = melotte_standalone.into_iter()
.filter(|e| !existing_ids.contains(&e.id))
.collect();
tracing::info!("Adding {} standalone Melotte entries", new_melotte.len());
entries.extend(new_melotte);
// Collinder standalone entries
let collinder_standalone = collinder::get_standalone_collinder();
{
let existing_ids: std::collections::HashSet<String> = entries.iter().map(|e| e.id.clone()).collect();
let new_collinder: Vec<_> = collinder_standalone.into_iter()
.filter(|e| !existing_ids.contains(&e.id))
.collect();
tracing::info!("Adding {} standalone Collinder entries", new_collinder.len());
entries.extend(new_collinder);
}
// Gum HII regions — deduplicate by position against existing catalog
match gum_res {
Ok(gum_entries) => {
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
let new_gum: Vec<_> = gum_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033
})
})
.collect();
tracing::info!("Adding {} Gum entries (after dedup)", new_gum.len());
entries.extend(new_gum);
}
Err(e) => tracing::warn!("Gum fetch failed (skipping): {}", e),
}
// RCW HII regions — deduplicate by position
match rcw_res {
Ok(rcw_entries) => {
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
let new_rcw: Vec<_> = rcw_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033
})
})
.collect();
tracing::info!("Adding {} RCW entries (after dedup)", new_rcw.len());
entries.extend(new_rcw);
}
Err(e) => tracing::warn!("RCW fetch failed (skipping): {}", e),
}
// Abell PN — deduplicate against NGC/IC PNe by position
match abell_pn_res {
Ok(abell_entries) => {
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
let new_abell: Vec<_> = abell_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033
})
})
.collect();
tracing::info!("Adding {} Abell PN entries (after dedup)", new_abell.len());
entries.extend(new_abell);
}
Err(e) => tracing::warn!("Abell PN fetch failed (skipping): {}", e),
}
// Abell Galaxy Clusters — unique IDs, no dedup needed (galaxy_cluster is a new type)
match abell_gc_res {
Ok(abell_gc_entries) => {
let existing_ids: std::collections::HashSet<String> = entries.iter().map(|e| e.id.clone()).collect();
let new_gc: Vec<_> = abell_gc_entries.into_iter()
.filter(|e| !existing_ids.contains(&e.id))
.collect();
tracing::info!("Adding {} Abell Galaxy Cluster entries", new_gc.len());
entries.extend(new_gc);
}
Err(e) => tracing::warn!("Abell GC fetch failed (skipping): {}", e),
}
// PGC bright subset — deduplicate against NGC/IC by position (2' radius)
match pgc_res {
Ok(pgc_entries) => {
let existing_coords: Vec<(f64, f64)> = entries.iter().map(|e| (e.ra_deg, e.dec_deg)).collect();
let new_pgc: Vec<_> = pgc_entries.into_iter()
.filter(|e| {
!existing_coords.iter().any(|(ra, dec)| {
let dra = (e.ra_deg - ra).abs().min(360.0 - (e.ra_deg - ra).abs());
let ddec = (e.dec_deg - dec).abs();
(dra * dra + ddec * ddec).sqrt() < 0.033
})
})
.collect();
tracing::info!("Adding {} PGC bright galaxy entries (after dedup)", new_pgc.len());
entries.extend(new_pgc);
}
Err(e) => tracing::warn!("PGC fetch failed (skipping): {}", e),
}
Ok(entries)
}
/// Extract Sharpless identifier from an object's identifiers field and create an alias entry.
fn create_sh2_alias(
entry: &CatalogEntry,
popular_names: &std::collections::HashMap<&'static str, &'static str>,
) -> Option<CatalogEntry> {
// We'll need to parse identifiers from somewhere.
// For now, we extract from the entry's existing data if available.
// The issue is that compute_derived doesn't store the original identifiers field.
// So we can look for Sh2 in the name or construct from the object type and catalog.
// Check if this object already has "Sh2" in the ID (like "Sh2-155")
if entry.id.starts_with("Sh2-") {
return None; // Already a Sharpless entry
}
// Only create Sh2 aliases for emission nebulae and similar objects
// that are likely to have Sharpless counterparts
if !matches!(
entry.obj_type.as_str(),
"emission_nebula" | "reflection_nebula" | "nebula" | "dark_nebula" | "planetary_nebula"
) {
return None;
}
// Try to find a Sharpless name in popular_names for this object
// by checking known Sh2→NGC mappings
let sh2_id = match entry.id.as_str() {
// Sharpless → NGC known mappings
"NGC281" => "Sh2-184", // Pac-Man
"NGC1333" => "Sh2-241", // Reflection Nebula
"NGC1499" => "Sh2-220", // California
"NGC2024" => "Sh2-68", // Flame Nebula
"NGC2237" => "Sh2-64", // Rosette
"NGC3372" => "Sh2-287", // Eta Carinae
"NGC6210" => "Sh2-105", // Turtle
"NGC6302" => "Sh2-12", // Bug
"NGC6357" => "Sh2-11", // War and Peace
"NGC6369" => "Sh2-72", // Little Ghost
"NGC6611" => "Sh2-16", // Eagle
"NGC6720" => "Sh2-83", // Ring
"NGC6826" => "Sh2-87", // Blinking
"NGC6853" => "Sh2-71", // Dumbbell
"NGC6960" => "Sh2-103", // Western Veil
"NGC6992" => "Sh2-103", // Eastern Veil
"NGC7000" => "Sh2-119", // North America
"NGC7009" => "Sh2-84", // Saturn
"NGC7027" => "Sh2-107", // Giraffe
"NGC7293" => "Sh2-108", // Helix
"NGC7380" => "Sh2-142", // Wizard
"NGC7635" => "Sh2-162", // Bubble
"NGC7662" => "Sh2-120", // Blue Snowball
"IC405" => "Sh2-229", // Flaming Star
"IC434" => "Sh2-175", // Horsehead
"IC1318" => "Sh2-100", // Butterfly
"IC1805" => "Sh2-190", // Heart
"IC1848" => "Sh2-199", // Soul
"IC5070" => "Sh2-126", // Pelican
_ => return None,
};
let common_name = popular_names
.get(sh2_id)
.or(popular_names.get(entry.id.as_str()))
.copied();
Some(CatalogEntry {
id: sh2_id.to_string(),
name: format!("{} ({})", sh2_id, entry.name),
common_name: common_name.map(|s| s.to_string()),
obj_type: entry.obj_type.clone(),
ra_deg: entry.ra_deg,
dec_deg: entry.dec_deg,
ra_h: entry.ra_h.clone(),
dec_dms: entry.dec_dms.clone(),
constellation: entry.constellation.clone(),
size_arcmin_maj: entry.size_arcmin_maj,
size_arcmin_min: entry.size_arcmin_min,
pos_angle_deg: entry.pos_angle_deg,
mag_v: entry.mag_v,
surface_brightness: entry.surface_brightness,
hubble_type: entry.hubble_type.clone(),
messier_num: None,
is_highlight: true, // Sharpless objects are highlights
fov_fill_pct: entry.fov_fill_pct,
mosaic_flag: entry.mosaic_flag,
mosaic_panels_w: entry.mosaic_panels_w,
mosaic_panels_h: entry.mosaic_panels_h,
difficulty: entry.difficulty,
guide_star_density: entry.guide_star_density.clone(),
fetched_at: entry.fetched_at,
})
}
pub async fn upsert_entries(pool: &SqlitePool, entries: &[CatalogEntry]) -> anyhow::Result<()> {
let mut tx = pool.begin().await?;
@@ -257,5 +342,42 @@ pub async fn upsert_entries(pool: &SqlitePool, entries: &[CatalogEntry]) -> anyh
.await?;
}
tx.commit().await?;
// Populate Caldwell numbers
for (num, id) in caldwell::caldwell_map() {
let _ = sqlx::query("UPDATE catalog SET caldwell_num = ? WHERE id = ?")
.bind(num)
.bind(id)
.execute(pool)
.await;
}
// Populate Arp numbers
for (num, id) in caldwell::arp_map() {
let _ = sqlx::query("UPDATE catalog SET arp_num = ? WHERE id = ?")
.bind(num)
.bind(id)
.execute(pool)
.await;
}
// Populate Melotte numbers
for (num, id) in melotte::melotte_map() {
let _ = sqlx::query("UPDATE catalog SET melotte_num = ? WHERE id = ?")
.bind(num)
.bind(id)
.execute(pool)
.await;
}
// Populate Collinder numbers
for (num, id) in collinder::collinder_map() {
let _ = sqlx::query("UPDATE catalog SET collinder_num = ? WHERE id = ?")
.bind(num)
.bind(id)
.execute(pool)
.await;
}
Ok(())
}
backend/src/catalog/pgc.rs
+207
View File
@@ -0,0 +1,207 @@
/// PGC (Principal Galaxy Catalogue) bright subset.
/// Only objects with B_Mag < 14.0 not already in NGC/IC.
/// Source: VizieR VII/237. Adds ~5000 fainter galaxies beyond NGC/IC.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
// PGC bright subset: B_Mag < 14.0, Dec >= -30°
// Using the LEDA/HyperLeda source via VizieR
const VIZIER_PGC_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/237\
&-out=PGC\
&-out=RAJ2000\
&-out=DEJ2000\
&-out=logD25\
&-out=BT\
&-c.rm=180\
&BT=<14\
&DEJ2000=>-30\
&-out.max=6000\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct PgcRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
size_arcmin: f64,
mag_b: f64,
}
pub async fn fetch_pgc() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("PGC: loaded {} bright entries from VizieR VII/237", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("PGC: VizieR returned 0 rows — skipping");
Ok(vec![])
}
Err(e) => {
tracing::warn!("PGC fetch from VizieR failed ({}) — skipping", e);
Ok(vec![])
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(120))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_PGC_URL)
.send()
.await
.context("PGC fetch request failed")?
.text()
.await
.context("PGC response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("PGC: parsed {} rows from VizieR VII/237", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR PGC response");
}
let filtered: Vec<PgcRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.mag_b < 14.0)
.collect();
tracing::info!("PGC: {} rows pass filters", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<PgcRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("PGC")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("RAJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("DEJ2000")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
// logD25 is log10 of major axis in 0.1 arcmin units
let log_d25 = col_idx("logD25")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.5);
let size_arcmin = (10_f64.powf(log_d25) * 0.1).max(0.1);
let mag_b = col_idx("BT")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(15.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(PgcRow { id, ra_deg: ra, dec_deg: dec, size_arcmin, mag_b });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<PgcRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.mag_b < 14.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: PgcRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("PGC{}", r.id);
let fov_fill = (r.size_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.size_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.size_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
let difficulty = if r.mag_b < 11.0 { 2 } else if r.mag_b < 12.5 { 3 } else { 4 };
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "galaxy".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.size_arcmin),
size_arcmin_min: Some(r.size_arcmin * 0.6),
pos_angle_deg: None,
mag_v: Some(r.mag_b),
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(difficulty),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
backend/src/catalog/popular_names.rs
+14
View File
@@ -169,5 +169,19 @@ pub fn popular_names() -> HashMap<&'static str, &'static str> {
m.insert("Sh2-155", "Cave Nebula");
m.insert("Sh2-308", "Dolphin Nebula");
// ===== BARNARD DARK NEBULAE =====
m.insert("B33", "Horsehead Nebula");
m.insert("B72", "Snake Nebula");
m.insert("B142", "Barnard 142");
m.insert("B143", "Barnard 143");
// ===== MELOTTE CLUSTERS =====
m.insert("Mel20", "Alpha Persei Cluster");
m.insert("Mel25", "Hyades");
m.insert("Mel111", "Coma Star Cluster");
// ===== COLLINDER CLUSTERS =====
m.insert("Cr399", "Brocchi's Cluster");
m
}
backend/src/catalog/rcw.rs
+191
View File
@@ -0,0 +1,191 @@
/// RCW Catalogue of Southern HII Regions (Rodgers-Campbell-Whiteoak 1960).
/// Fetched from VizieR VIII/76. Heavily southern, ~30 entries after Dec filter.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
const VIZIER_RCW_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VIII/76\
&-out=RCW\
&-out=_RA\
&-out=_DE\
&-out=Diam\
&-out.max=300\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct RcwRow {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
}
pub async fn fetch_rcw() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("RCW: loaded {} entries from VizieR VIII/76", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("RCW: VizieR returned 0 rows — skipping");
Ok(vec![])
}
Err(e) => {
tracing::warn!("RCW fetch from VizieR failed ({}) — skipping", e);
Ok(vec![])
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_RCW_URL)
.send()
.await
.context("RCW fetch request failed")?
.text()
.await
.context("RCW response read failed")?;
let rows = parse_vizier_tsv(&text);
tracing::info!("RCW: parsed {} rows from VizieR VIII/76", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR RCW response");
}
let filtered: Vec<RcwRow> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.collect();
tracing::info!("RCW: {} rows pass filters (Dec >= -30°)", filtered.len());
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<RcwRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = trimmed.split('\t').map(|s| s.trim().to_string()).collect();
if header.len() < 2 {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 3 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("RCW")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok());
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(10.0);
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(RcwRow { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<RcwRow>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 2.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(
r: RcwRow,
now: i64,
names: &std::collections::HashMap<&'static str, &'static str>,
) -> CatalogEntry {
let id = format!("RCW{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "emission_nebula".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin * 0.7),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(3),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
backend/src/catalog/sh2.rs
+278
View File
@@ -0,0 +1,278 @@
/// Sharpless (Sh2) emission nebula catalog.
/// Fetched from VizieR catalog VII/20 (Sharpless 1959).
/// These are H II regions not always present in OpenNGC.
use anyhow::Context;
use chrono::Utc;
use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::catalog::popular_names::popular_names;
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
/// VizieR VII/20 — Sharpless Catalog of HII Regions (1959).
const VIZIER_SH2_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/20\
&-out=Sh2\
&-out=MajDiam\
&-out=_RA\
&-out=_DE\
&-out.max=1000\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct Sh2Row {
id: u32,
ra_deg: f64,
dec_deg: f64,
diam_arcmin: f64,
}
pub async fn fetch_sh2() -> anyhow::Result<Vec<CatalogEntry>> {
match fetch_from_vizier().await {
Ok(entries) if !entries.is_empty() => {
tracing::info!("Sh2: loaded {} entries from VizieR VII/20", entries.len());
Ok(entries)
}
Ok(_) => {
tracing::warn!("Sh2: VizieR returned 0 rows — using hardcoded fallback");
Ok(build_entries_from_rows(get_prominent_sh2()))
}
Err(e) => {
tracing::warn!("Sh2 fetch from VizieR failed ({}) — using hardcoded fallback", e);
Ok(build_entries_from_rows(get_prominent_sh2()))
}
}
}
async fn fetch_from_vizier() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_SH2_URL)
.send()
.await
.context("Sh2 fetch request failed")?
.text()
.await
.context("Sh2 response read failed")?;
tracing::debug!("Sh2 raw response first 500 chars: {}", &text[..text.len().min(500)]);
let rows = parse_vizier_tsv(&text);
tracing::info!("Sh2: parsed {} rows from VizieR VII/20", rows.len());
if rows.is_empty() {
anyhow::bail!("no rows parsed from VizieR Sh2 response");
}
let total = rows.len();
let filtered: Vec<Sh2Row> = rows
.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 1.0)
.collect();
tracing::info!("Sh2: {}/{} rows pass filters", filtered.len(), total);
Ok(build_entries_from_rows(filtered))
}
fn parse_vizier_tsv(text: &str) -> Vec<Sh2Row> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut past_separator = false;
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
if header.is_empty() {
header = if trimmed.contains('\t') {
trimmed.split('\t').map(|s| s.trim().to_string()).collect()
} else {
trimmed.split_whitespace().map(|s| s.to_string()).collect()
};
continue;
}
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
if cols.len() < 2 {
continue;
}
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let id = col_idx("Sh2")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
let diam = col_idx("MajDiam")
.or_else(|| col_idx("Diam"))
.or_else(|| col_idx("Dmaj"))
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(15.0);
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.get(cols.len().saturating_sub(2)).and_then(|s| s.parse().ok()));
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.last().and_then(|s| s.parse().ok()));
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(Sh2Row { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
}
}
rows
}
fn build_entries_from_rows(rows: Vec<Sh2Row>) -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let names = popular_names();
rows.into_iter()
.filter(|r| r.dec_deg >= -30.0 && r.dec_deg <= 75.0 && r.diam_arcmin >= 1.0)
.map(|r| build_entry(r, now, &names))
.collect()
}
fn build_entry(r: Sh2Row, now: i64, names: &std::collections::HashMap<&'static str, &'static str>) -> CatalogEntry {
let id = format!("Sh2-{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
let panels_h = ((r.diam_arcmin / FOV_ARCMIN_H).ceil() as i32).max(1);
let mosaic = panels_w > 1 || panels_h > 1;
let density = guide_star_density_from_coords(r.ra_deg, r.dec_deg);
let common_name = names.get(id.as_str()).map(|s| s.to_string());
let is_highlight = common_name.is_some();
CatalogEntry {
id: id.clone(),
name: id,
common_name,
obj_type: "emission_nebula".to_string(),
ra_deg: r.ra_deg,
dec_deg: r.dec_deg,
ra_h: format_ra_hms(r.ra_deg),
dec_dms: format_dec_dms(r.dec_deg),
constellation: None,
size_arcmin_maj: Some(r.diam_arcmin),
size_arcmin_min: Some(r.diam_arcmin * 0.7),
pos_angle_deg: None,
mag_v: None,
surface_brightness: None,
hubble_type: None,
messier_num: None,
is_highlight,
fov_fill_pct: Some(fov_fill),
mosaic_flag: mosaic,
mosaic_panels_w: panels_w,
mosaic_panels_h: panels_h,
difficulty: Some(3),
guide_star_density: Some(density.to_string()),
fetched_at: now,
}
}
/// Hardcoded fallback: ~80 prominent Sharpless HII regions accessible from northern latitudes.
fn get_prominent_sh2() -> Vec<Sh2Row> {
vec![
// Winter / Spring (Orion, Auriga, Gemini, Monoceros, Perseus, Cassiopeia)
Sh2Row { id: 1, ra_deg: 0.113, dec_deg: 64.083, diam_arcmin: 20.0 }, // Cas
Sh2Row { id: 7, ra_deg: 269.533, dec_deg: -23.450, diam_arcmin: 80.0 }, // Sgr
Sh2Row { id: 9, ra_deg: 253.783, dec_deg: -34.350, diam_arcmin: 60.0 }, // Sco
Sh2Row { id: 11, ra_deg: 264.167, dec_deg: -34.483, diam_arcmin: 80.0 }, // War & Peace
Sh2Row { id: 16, ra_deg: 274.683, dec_deg: -13.783, diam_arcmin: 60.0 }, // Eagle region
Sh2Row { id: 17, ra_deg: 275.000, dec_deg: -15.200, diam_arcmin: 40.0 }, // Sgr
Sh2Row { id: 25, ra_deg: 274.000, dec_deg: -23.833, diam_arcmin: 120.0 }, // Lagoon region
Sh2Row { id: 27, ra_deg: 84.917, dec_deg: 9.333, diam_arcmin: 370.0 }, // λ Ori ring
Sh2Row { id: 29, ra_deg: 18.867, dec_deg: 61.533, diam_arcmin: 12.0 }, // Cas
Sh2Row { id: 36, ra_deg: 82.550, dec_deg: 4.033, diam_arcmin: 8.0 }, // Ori
Sh2Row { id: 64, ra_deg: 98.067, dec_deg: 4.967, diam_arcmin: 80.0 }, // Rosette
Sh2Row { id: 68, ra_deg: 86.583, dec_deg: -1.950, diam_arcmin: 30.0 }, // Flame-adjacent
Sh2Row { id: 100, ra_deg: 305.967, dec_deg: 35.817, diam_arcmin: 180.0 }, // γ Cyg / Butterfly
Sh2Row { id: 101, ra_deg: 296.867, dec_deg: 35.417, diam_arcmin: 20.0 }, // Tulip
Sh2Row { id: 103, ra_deg: 311.283, dec_deg: 31.717, diam_arcmin: 230.0 }, // Veil Complex
Sh2Row { id: 106, ra_deg: 304.883, dec_deg: 37.367, diam_arcmin: 12.0 }, // Cygnus
Sh2Row { id: 108, ra_deg: 337.417, dec_deg: -21.933, diam_arcmin: 1200.0 }, // Helix (huge)
Sh2Row { id: 119, ra_deg: 315.617, dec_deg: 44.250, diam_arcmin: 180.0 }, // North America
Sh2Row { id: 126, ra_deg: 316.833, dec_deg: 44.533, diam_arcmin: 90.0 }, // Pelican
Sh2Row { id: 129, ra_deg: 328.150, dec_deg: 60.050, diam_arcmin: 140.0 }, // Flying Bat
Sh2Row { id: 132, ra_deg: 336.550, dec_deg: 56.133, diam_arcmin: 100.0 }, // Lion
Sh2Row { id: 140, ra_deg: 336.550, dec_deg: 63.183, diam_arcmin: 10.0 }, // Cepheus SFR
Sh2Row { id: 142, ra_deg: 341.467, dec_deg: 58.433, diam_arcmin: 12.0 }, // Wizard region
Sh2Row { id: 155, ra_deg: 344.983, dec_deg: 62.383, diam_arcmin: 50.0 }, // Cave
Sh2Row { id: 157, ra_deg: 350.817, dec_deg: 60.867, diam_arcmin: 60.0 }, // Lobster Claw
Sh2Row { id: 162, ra_deg: 350.183, dec_deg: 61.217, diam_arcmin: 15.0 }, // Bubble
Sh2Row { id: 163, ra_deg: 353.383, dec_deg: 61.117, diam_arcmin: 25.0 }, // Cas
Sh2Row { id: 168, ra_deg: 358.133, dec_deg: 61.383, diam_arcmin: 60.0 }, // Cas
Sh2Row { id: 171, ra_deg: 0.500, dec_deg: 67.833, diam_arcmin: 40.0 }, // Cep
Sh2Row { id: 175, ra_deg: 85.250, dec_deg: -2.450, diam_arcmin: 40.0 }, // Horsehead region
Sh2Row { id: 184, ra_deg: 13.533, dec_deg: 56.617, diam_arcmin: 35.0 }, // Pac-Man
Sh2Row { id: 188, ra_deg: 17.633, dec_deg: 58.783, diam_arcmin: 15.0 }, // Cas
Sh2Row { id: 190, ra_deg: 38.317, dec_deg: 61.450, diam_arcmin: 100.0 }, // Heart
Sh2Row { id: 199, ra_deg: 40.433, dec_deg: 60.517, diam_arcmin: 150.0 }, // Soul
Sh2Row { id: 206, ra_deg: 55.617, dec_deg: 19.917, diam_arcmin: 30.0 }, // Per
Sh2Row { id: 207, ra_deg: 56.583, dec_deg: 23.000, diam_arcmin: 15.0 }, // Per
Sh2Row { id: 212, ra_deg: 73.617, dec_deg: 44.217, diam_arcmin: 40.0 }, // Aur
Sh2Row { id: 219, ra_deg: 79.283, dec_deg: 45.150, diam_arcmin: 30.0 }, // Aur
Sh2Row { id: 220, ra_deg: 60.583, dec_deg: 36.417, diam_arcmin: 360.0 }, // California
Sh2Row { id: 223, ra_deg: 51.800, dec_deg: 60.067, diam_arcmin: 30.0 }, // Cas
Sh2Row { id: 224, ra_deg: 53.833, dec_deg: 60.700, diam_arcmin: 25.0 }, // Cas
Sh2Row { id: 229, ra_deg: 82.750, dec_deg: 34.317, diam_arcmin: 80.0 }, // Flaming Star
Sh2Row { id: 232, ra_deg: 86.117, dec_deg: 33.450, diam_arcmin: 30.0 }, // Aur
Sh2Row { id: 234, ra_deg: 90.133, dec_deg: 37.283, diam_arcmin: 15.0 }, // Aur
Sh2Row { id: 235, ra_deg: 92.383, dec_deg: 36.633, diam_arcmin: 10.0 }, // Aur
Sh2Row { id: 240, ra_deg: 92.683, dec_deg: 27.767, diam_arcmin: 25.0 }, // Per
Sh2Row { id: 241, ra_deg: 53.417, dec_deg: 31.500, diam_arcmin: 10.0 }, // Per
Sh2Row { id: 252, ra_deg: 99.500, dec_deg: 17.983, diam_arcmin: 60.0 }, // Monkey Head
Sh2Row { id: 254, ra_deg: 98.233, dec_deg: 15.833, diam_arcmin: 10.0 }, // Mon
Sh2Row { id: 261, ra_deg: 107.417, dec_deg: -1.167, diam_arcmin: 40.0 }, // Mon
Sh2Row { id: 273, ra_deg: 117.750, dec_deg: -10.117, diam_arcmin: 20.0 }, // CMa
Sh2Row { id: 274, ra_deg: 113.567, dec_deg: 10.050, diam_arcmin: 30.0 }, // Gem / Mon
Sh2Row { id: 275, ra_deg: 115.617, dec_deg: -11.317, diam_arcmin: 50.0 }, // CMa
Sh2Row { id: 277, ra_deg: 119.083, dec_deg: -9.233, diam_arcmin: 35.0 }, // CMa
Sh2Row { id: 280, ra_deg: 128.600, dec_deg: -17.617, diam_arcmin: 50.0 }, // Pup
Sh2Row { id: 284, ra_deg: 126.883, dec_deg: -3.333, diam_arcmin: 20.0 }, // Mon
Sh2Row { id: 287, ra_deg: 161.333, dec_deg: -59.883, diam_arcmin: 240.0 },// Eta Carina
Sh2Row { id: 289, ra_deg: 131.217, dec_deg: -39.467, diam_arcmin: 80.0 }, // Pup
Sh2Row { id: 292, ra_deg: 135.617, dec_deg: -23.350, diam_arcmin: 40.0 }, // Pup
// Summer (Sagittarius, Scorpius, Aquila, Cygnus, Vulpecula)
Sh2Row { id: 302, ra_deg: 186.967, dec_deg: -62.617, diam_arcmin: 80.0 }, // Cru
Sh2Row { id: 308, ra_deg: 107.800, dec_deg: -14.683, diam_arcmin: 40.0 }, // Dolphin
// Extra Sh2 objects with known popular names
Sh2Row { id: 71, ra_deg: 302.800, dec_deg: 22.717, diam_arcmin: 8.0 }, // Dumbbell PN area
Sh2Row { id: 72, ra_deg: 271.967, dec_deg: -22.533, diam_arcmin: 6.0 }, // Little Ghost area
Sh2Row { id: 83, ra_deg: 283.400, dec_deg: 33.033, diam_arcmin: 4.0 }, // Ring PN area
Sh2Row { id: 87, ra_deg: 298.733, dec_deg: 50.517, diam_arcmin: 5.0 }, // Blinking PN area
Sh2Row { id: 105, ra_deg: 280.650, dec_deg: 23.533, diam_arcmin: 3.0 }, // Turtle PN area
Sh2Row { id: 107, ra_deg: 307.483, dec_deg: 42.133, diam_arcmin: 2.0 }, // Giraffe PN area
Sh2Row { id: 12, ra_deg: 260.583, dec_deg: -37.100, diam_arcmin: 12.0 }, // Bug PN area
Sh2Row { id: 84, ra_deg: 321.033, dec_deg: -11.367, diam_arcmin: 3.0 }, // Saturn PN area
]
}
backend/src/catalog/vdb.rs
+124 -31
View File
@@ -7,8 +7,18 @@ use crate::catalog::filter::{CatalogEntry, guide_star_density_from_coords};
use crate::catalog::fetch::{format_ra_hms, format_dec_dms};
use crate::config::{FOV_ARCMIN_H, FOV_ARCMIN_W};
/// Request RA/Dec as decimal degrees via `_RA`/`_DE` computed columns, and
/// explicitly ask for VdB number and Diam so we always know the column order.
const VIZIER_VDB_URL: &str =
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv?-source=VII/21A&-out.max=200";
"https://vizier.cds.unistra.fr/viz-bin/asu-tsv\
?-source=VII/21A/catalog\
&-out=VdB\
&-out=Diam\
&-out=_RA\
&-out=_DE\
&-out.max=300\
&-oc.form=dec";
#[derive(Debug, Clone)]
struct VdbRow {
id: u32,
@@ -20,20 +30,28 @@ struct VdbRow {
pub async fn fetch_vdb() -> anyhow::Result<Vec<CatalogEntry>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(60))
.user_agent("astronome/1.0")
.build()?;
let text = client
.get(VIZIER_VDB_URL)
.send()
.await
.context("VdB fetch failed")?
.context("VdB fetch request failed")?
.text()
.await
.context("VdB read failed")?;
.context("VdB response read failed")?;
tracing::debug!("VdB raw response first 500 chars: {}", &text[..text.len().min(500)]);
let rows = parse_vizier_tsv(&text);
tracing::info!("Parsed {} VdB rows from VizieR", rows.len());
if rows.is_empty() {
tracing::warn!("VdB: no rows parsed — VizieR may be unavailable, using hardcoded fallback");
return Ok(vdb_fallback());
}
let now = Utc::now().timestamp();
let filtered: Vec<_> = rows
.iter()
@@ -44,63 +62,85 @@ pub async fn fetch_vdb() -> anyhow::Result<Vec<CatalogEntry>> {
let entries = filtered
.into_iter()
.map(|r| build_entry(r.clone(), now))
.map(|r| build_entry(r, now))
.collect();
Ok(entries)
}
/// Parse VizieR TSV output (tab-separated, `#` comment lines, dashes separator).
fn parse_vizier_tsv(text: &str) -> Vec<VdbRow> {
let mut rows = Vec::new();
let mut header: Vec<String> = Vec::new();
let mut found_separator = false;
let mut past_separator = false;
for (_line_num, line) in text.lines().enumerate() {
// Skip comment/meta lines
for line in text.lines() {
// Skip VizieR metadata/comment lines
if line.starts_with('#') {
continue;
}
let line = line.trim();
if line.is_empty() {
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
// First non-comment line is the header
// First non-comment, non-empty line is the header
if header.is_empty() {
header = line.split_whitespace().map(|s| s.to_string()).collect();
// VizieR uses tabs; fall back to any whitespace splitting for header
header = trimmed.split('\t')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if header.is_empty() {
header = trimmed.split_whitespace().map(|s| s.to_string()).collect();
}
continue;
}
// Skip separator line (dashes)
if !found_separator && line.starts_with("---") {
found_separator = true;
// Skip the separator/units row (lines of dashes)
if !past_separator {
if trimmed.starts_with("---") || trimmed.chars().all(|c| c == '-' || c == '\t' || c == ' ') {
past_separator = true;
}
continue;
}
// Skip unit rows (blank entries or description)
if !found_separator {
continue;
}
// Parse data row — try tab first, then whitespace
let cols: Vec<&str> = if line.contains('\t') {
line.split('\t').map(|s| s.trim()).collect()
} else {
line.split_whitespace().collect()
};
let cols: Vec<&str> = line.split_whitespace().collect();
if cols.len() < 2 {
continue;
}
// For VizieR TSV output, the last two columns are always _RA and _DE
// Extract VdB ID from first column
let id = cols.get(0)
.and_then(|s| s.trim().parse::<u32>().ok());
let col_idx = |name: &str| -> Option<usize> {
header.iter().position(|h| h.eq_ignore_ascii_case(name))
};
let ra = cols.get(cols.len() - 2)
.and_then(|s| s.trim().parse::<f64>().ok());
let dec = cols.get(cols.len() - 1)
.and_then(|s| s.trim().parse::<f64>().ok());
// Look up by header name; fall back to positional for _RA/_DE (always appended last)
let id = col_idx("VdB")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<u32>().ok());
// VizieR doesn't provide diameter in standard output; estimate from visibility
// Use a conservative default of ~10 arcmin for all VdB objects
let diam = 10.0;
let diam = col_idx("Diam")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(10.0);
// _RA and _DE are computed columns appended at the end
let ra = col_idx("_RA")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.get(cols.len().saturating_sub(2)).and_then(|s| s.parse().ok()));
let dec = col_idx("_DE")
.and_then(|i| cols.get(i))
.and_then(|s| s.parse::<f64>().ok())
.or_else(|| cols.last().and_then(|s| s.parse().ok()));
if let (Some(id), Some(ra), Some(dec)) = (id, ra, dec) {
rows.push(VdbRow { id, ra_deg: ra, dec_deg: dec, diam_arcmin: diam });
@@ -109,7 +149,7 @@ fn parse_vizier_tsv(text: &str) -> Vec<VdbRow> {
rows
}
fn build_entry(r: VdbRow, now: i64) -> CatalogEntry {
fn build_entry(r: &VdbRow, now: i64) -> CatalogEntry {
let id = format!("VdB{}", r.id);
let fov_fill = (r.diam_arcmin / FOV_ARCMIN_H).min(1.0) * 100.0;
let panels_w = ((r.diam_arcmin / FOV_ARCMIN_W).ceil() as i32).max(1);
@@ -144,3 +184,56 @@ fn build_entry(r: VdbRow, now: i64) -> CatalogEntry {
fetched_at: now,
}
}
/// Hardcoded fallback: 40 prominent VdB reflection nebulae for northern hemisphere imaging.
/// Used when VizieR is unavailable during catalog build.
fn vdb_fallback() -> Vec<CatalogEntry> {
let now = Utc::now().timestamp();
let data: &[(u32, f64, f64, f64)] = &[
// (id, ra_deg, dec_deg, diam_arcmin)
(1, 9.075, 58.533, 10.0), // VdB1 Cas
(2, 11.083, 58.150, 8.0), // VdB2 Cas
(12, 52.267, 28.217, 20.0), // VdB12 Per (near NGC1333)
(13, 53.483, 31.617, 12.0), // VdB13 Per
(15, 55.367, 24.100, 10.0), // VdB15 Per
(16, 55.683, 32.050, 15.0), // VdB16 Per
(17, 58.183, 25.617, 12.0), // VdB17 Per
(18, 61.433, 31.733, 10.0), // VdB18 Per
(19, 62.050, 31.217, 8.0), // VdB19 Per
(20, 62.117, 29.200, 15.0), // VdB20 Per (near NGC1499 region)
(22, 64.800, 15.633, 10.0), // VdB22 Tau
(28, 71.000, 25.533, 8.0), // VdB28 Tau
(30, 82.717, 9.900, 10.0), // VdB30 Ori (near Orion)
(31, 82.567, -5.383, 8.0), // VdB31 Ori
(37, 87.317, 9.633, 12.0), // VdB37 Ori
(38, 88.733, 12.567, 10.0), // VdB38 Ori
(39, 89.150, 19.167, 8.0), // VdB39 Ori
(40, 90.133, 13.200, 10.0), // VdB40 Ori (near Horsehead)
(41, 92.267, 26.067, 12.0), // VdB41 Aur
(52, 100.333, -2.783, 15.0), // VdB52 Mon (Monoceros)
(62, 107.333, -6.633, 10.0), // VdB62 CMa
(64, 109.167, -7.150, 8.0), // VdB64 CMa
(73, 115.800, -2.367, 10.0), // VdB73 Mon
(82, 127.133, 58.967, 12.0), // VdB82 UMa
(91, 133.417, 55.500, 8.0), // VdB91 UMa
(99, 148.267, 53.833, 10.0), // VdB99 UMa
(101, 164.533, 60.800, 8.0), // VdB101 UMa
(102, 167.483, 56.983, 12.0), // VdB102 UMa
(107, 180.633, 68.167, 10.0), // VdB107 UMa
(108, 185.467, 69.533, 8.0), // VdB108 UMa
(119, 210.833, 58.833, 10.0), // VdB119 CVn/UMa border
(126, 247.567, -24.317, 10.0),// VdB126 Sco
(130, 273.367, 3.867, 15.0), // VdB130 Aql (near Barnard's Star)
(131, 275.233, 1.733, 10.0), // VdB131 Aql
(132, 279.717, 3.833, 8.0), // VdB132 Sge
(133, 283.367, -3.333, 12.0), // VdB133 Ser
(139, 296.833, 7.400, 10.0), // VdB139 Aql
(141, 302.650, 30.567, 15.0), // VdB141 Cep (Ghost Nebula)
(142, 305.167, 30.383, 12.0), // VdB142 Cep (near IC1396)
(152, 349.950, 69.817, 10.0), // VdB152 Cep (near Ced214)
];
data.iter().map(|&(id, ra_deg, dec_deg, diam_arcmin)| {
build_entry(&VdbRow { id, ra_deg, dec_deg, diam_arcmin }, now)
}).collect()
}
backend/src/db/mod.rs
+21
View File
@@ -17,6 +17,7 @@ pub async fn init_db(database_url: &str) -> anyhow::Result<SqlitePool> {
.context("failed to connect to SQLite")?;
run_schema(&pool).await?;
run_migrations(&pool).await?;
seed_horizon(&pool).await?;
Ok(pool)
@@ -34,6 +35,26 @@ async fn run_schema(pool: &SqlitePool) -> anyhow::Result<()> {
Ok(())
}
/// Additive migrations for columns added after initial schema creation.
/// SQLite doesn't support IF NOT EXISTS for ADD COLUMN, so we check the error and ignore it.
async fn run_migrations(pool: &SqlitePool) -> anyhow::Result<()> {
let migrations: &[&str] = &[
"ALTER TABLE nightly_cache ADD COLUMN is_visible_tonight INTEGER DEFAULT 0",
"ALTER TABLE catalog ADD COLUMN caldwell_num INTEGER",
"ALTER TABLE catalog ADD COLUMN arp_num INTEGER",
"ALTER TABLE catalog ADD COLUMN melotte_num INTEGER",
"ALTER TABLE catalog ADD COLUMN collinder_num INTEGER",
];
for sql in migrations {
match sqlx::query(sql).execute(pool).await {
Ok(_) => tracing::info!("Migration applied: {}", &sql[..sql.len().min(60)]),
Err(e) if e.to_string().contains("duplicate column") => {}
Err(e) => tracing::warn!("Migration skipped ({}): {}", sql, e),
}
}
Ok(())
}
async fn seed_horizon(pool: &SqlitePool) -> anyhow::Result<()> {
let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM horizon")
.fetch_one(pool)
backend/src/db/schema.sql
+1
View File
@@ -43,6 +43,7 @@ CREATE TABLE IF NOT EXISTS nightly_cache (
moon_sep_deg REAL,
recommended_filter TEXT,
visibility_json TEXT,
is_visible_tonight INTEGER DEFAULT 0,
PRIMARY KEY (catalog_id, night_date)
);
backend/src/jobs/nightly.rs
+7 -4
View File
@@ -125,8 +125,9 @@ pub async fn precompute_for_date(pool: &SqlitePool, date: NaiveDate) -> anyhow::
r#"INSERT OR REPLACE INTO nightly_cache
(catalog_id, night_date, max_alt_deg, transit_utc, rise_utc, set_utc,
best_start_utc, best_end_utc, usable_min, meridian_flip_utc,
airmass_at_transit, extinction_mag, moon_sep_deg, recommended_filter, visibility_json)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"#,
airmass_at_transit, extinction_mag, moon_sep_deg, recommended_filter,
visibility_json, is_visible_tonight)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"#,
)
.bind(&obj.id)
.bind(&date_str)
@@ -143,6 +144,7 @@ pub async fn precompute_for_date(pool: &SqlitePool, date: NaiveDate) -> anyhow::
.bind(vis.moon_sep_deg)
.bind(&rec_filter)
.bind(&vis_json)
.bind(vis.is_visible_tonight as i32)
.execute(&mut *tx)
.await?;
}
@@ -211,8 +213,8 @@ async fn precompute_lightweight(pool: &SqlitePool, date: NaiveDate) -> anyhow::R
sqlx::query(
r#"INSERT OR IGNORE INTO nightly_cache
(catalog_id, night_date, max_alt_deg, transit_utc, usable_min, recommended_filter)
VALUES (?, ?, ?, ?, ?, ?)"#,
(catalog_id, night_date, max_alt_deg, transit_utc, usable_min, recommended_filter, is_visible_tonight)
VALUES (?, ?, ?, ?, ?, ?, ?)"#,
)
.bind(&obj.id)
.bind(&date_str)
@@ -220,6 +222,7 @@ async fn precompute_lightweight(pool: &SqlitePool, date: NaiveDate) -> anyhow::R
.bind(vis.transit_utc.map(|t: DateTime<Utc>| t.to_rfc3339()))
.bind(vis.usable_min as i32)
.bind(&rec_filter)
.bind(vis.is_visible_tonight as i32)
.execute(&mut *tx)
.await?;
}
frontend/src/App.tsx
+1
View File
@@ -16,6 +16,7 @@ export default function App() {
<Route path="/" element={<Navigate to="/dashboard" replace />} />
<Route path="/dashboard" element={<Dashboard />} />
<Route path="/targets" element={<Targets />} />
<Route path="/targets/:targetId" element={<Targets />} />
<Route path="/calendar" element={<Calendar />} />
<Route path="/stats" element={<Stats />} />
<Route path="/gallery" element={<Gallery />} />
frontend/src/api/index.ts
+18 -2
View File
@@ -8,6 +8,7 @@ import type {
HorizonPoint,
LogEntry,
Phd2Log,
SimilarTarget,
Stats,
Target,
TargetNotes,
@@ -66,6 +67,7 @@ export interface TargetsParams {
min_usable_min?: number;
mosaic_only?: boolean;
not_imaged?: boolean;
show_custom?: boolean;
}
export const api = {
@@ -84,6 +86,7 @@ export const api = {
if (params.min_usable_min !== undefined) q.set('min_usable_min', String(params.min_usable_min));
if (params.mosaic_only) q.set('mosaic_only', 'true');
if (params.not_imaged) q.set('not_imaged', 'true');
if (params.show_custom === false) q.set('show_custom', 'false');
return get<TargetsResponse>(`/targets?${q}`);
},
get: (id: string): Promise<Target> => get(`/targets/${id}`),
@@ -94,6 +97,7 @@ export const api = {
yearly: (id: string): Promise<{ catalog_id: string; points: { date: string; alt_at_midnight: number; transit_alt: number; usable_min: number; moon_illumination: number }[] }> => get(`/targets/${id}/yearly`),
getNotes: (id: string): Promise<TargetNotes> => get(`/targets/${id}/notes`),
putNotes: (id: string, notes: string): Promise<{ status: string }> => put(`/targets/${id}/notes`, { notes }),
similar: (id: string): Promise<{ similar: SimilarTarget[]; target_transit?: string }> => get(`/targets/${id}/similar`),
},
tonight: {
@@ -107,6 +111,10 @@ export const api = {
get(`/calendar/${date}`),
getNewMoonWindows: (): Promise<{ windows: { date: string; illumination: number; top_targets: { id: string; name: string; common_name?: string; max_alt_deg?: number; recommended_filter?: string }[] }[] }> =>
get('/calendar/new-moon-windows'),
getBestNights: (): Promise<{ nights: { date: string; score: number; moon_illumination: number; visible_count: number; avg_usable_min: number; top_targets: { id: string; name: string; common_name?: string; obj_type: string; max_alt_deg?: number; usable_min?: number; recommended_filter?: string }[] }[] }> =>
get('/calendar/best-nights'),
getMonthlyHighlights: (): Promise<{ month: string; highlights: { id: string; name: string; common_name?: string; obj_type: string; constellation?: string; peak_alt?: number; best_usable_min?: number; recommended_filter?: string; keeper_count: number }[] }> =>
get('/calendar/monthly-highlights'),
},
weather: {
@@ -134,7 +142,11 @@ export const api = {
delete: (id: number): Promise<{ status: string; id: number }> => del(`/phd2/${id}`),
upload: (formData: FormData): Promise<{ id: number; duplicate: boolean; duplicate_id?: number; analysis: unknown; message?: string }> => {
return fetch(`${base}/phd2/upload`, { method: 'POST', body: formData })
.then(r => r.json() as Promise<{ id: number; duplicate: boolean; duplicate_id?: number; analysis: unknown; message?: string }>);
.then(async r => {
const data = await r.json();
if (!r.ok) throw new Error((data as { error?: string }).error ?? `HTTP ${r.status}`);
return data as { id: number; duplicate: boolean; duplicate_id?: number; analysis: unknown; message?: string };
});
},
},
@@ -146,7 +158,11 @@ export const api = {
delete: (id: number): Promise<{ id: number }> => del(`/gallery/item/${id}`),
upload: (catalogId: string, formData: FormData): Promise<{ id: number; url: string }> => {
return fetch(`${base}/gallery/${catalogId}`, { method: 'POST', body: formData })
.then(r => r.json() as Promise<{ id: number; url: string }>);
.then(async r => {
const data = await r.json();
if (!r.ok) throw new Error((data as { error?: string }).error ?? `HTTP ${r.status}`);
return data as { id: number; url: string };
});
},
},
frontend/src/api/types.ts
+57
View File
@@ -15,6 +15,8 @@ export interface Target {
surface_brightness?: number;
hubble_type?: string;
messier_num?: number;
caldwell_num?: number;
arp_num?: number;
is_highlight: boolean;
fov_fill_pct?: number;
mosaic_flag: boolean;
@@ -32,6 +34,8 @@ export interface Target {
moon_sep_deg?: number;
is_visible_tonight?: boolean;
total_integration_min?: number;
is_custom?: boolean;
urgency?: 'peak' | 'rising' | 'declining' | null;
}
export interface TargetsResponse {
@@ -164,6 +168,31 @@ export interface HorizonPoint {
alt_deg: number;
}
export interface IntegrationGap {
catalog_id: string;
name: string;
common_name?: string;
obj_type: string;
sv220_min: number;
c2_min: number;
uvir_min: number;
sv260_min: number;
missing_filters: string[];
}
export interface HistoryEntry {
date: string;
catalog_id: string;
name: string;
common_name?: string;
obj_type?: string;
filter_id: string;
integration_min: number;
quality: string;
notes?: string;
gallery_url?: string;
}
export interface Stats {
total_sessions: number;
total_integration_min: number;
@@ -174,6 +203,10 @@ export interface Stats {
quality: { quality: string; count: number }[];
top_targets: { id: string; name: string; common_name?: string; obj_type: string; sessions: number; total_min: number }[];
guiding: { date: string; rms_total?: number; rms_ra?: number; rms_dec?: number }[];
integration_gaps: IntegrationGap[];
history: HistoryEntry[];
catalogue_completion: { name: string; total: number; keepers: number; pct: number }[];
integration_goals: IntegrationGoal[];
}
export interface Workflow {
@@ -230,8 +263,32 @@ export interface TargetNotes {
notes: string;
}
export interface SimilarTarget {
id: string;
name: string;
common_name?: string;
obj_type: string;
size_arcmin_maj?: number;
fov_fill_pct?: number;
messier_num?: number;
max_alt_deg?: number;
transit_utc?: string;
recommended_filter?: string;
}
export interface FilterBreakdownItem {
filter_id: string;
total_min: number;
sessions: number;
}
export interface IntegrationGoal {
id: string;
name: string;
common_name?: string;
obj_type: string;
sv220_min: number;
c2_min: number;
uvir_min: number;
sv260_min: number;
}
frontend/src/components/charts/YearlyVisibility.tsx
+127 -99
View File
@@ -1,14 +1,4 @@
import {
ComposedChart,
Bar,
Line,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
ResponsiveContainer,
Cell,
} from 'recharts';
import { useState } from 'react';
interface YearPoint {
date: string;
@@ -24,107 +14,145 @@ interface Props {
const MONTH_ABBR = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
function altColor(alt: number): string {
if (alt >= 50) return 'var(--good)';
function altColorHex(alt: number): string {
if (alt >= 50) return '#3dba72';
if (alt >= 30) return '#2ab8a0';
if (alt >= 15) return 'var(--warn)';
return 'var(--muted)';
if (alt >= 15) return '#e8c030';
if (alt > 0) return '#3a4258';
return '#1a1f2e';
}
/** Calendar heatmap: 12 rows × 31 cols, one cell per day. */
function CalendarHeatmap({ points }: { points: YearPoint[] }) {
const [tooltip, setTooltip] = useState<{ x: number; y: number; point: YearPoint } | null>(null);
// Map date string → point
const byDate = new Map(points.map(p => [p.date, p]));
const today = new Date().toISOString().slice(0, 10);
// Build a 12-row × 31-col grid from the first point's date
const startDate = points[0]?.date ? new Date(points[0].date + 'T00:00:00Z') : new Date();
const startMonth = startDate.getUTCMonth();
const startYear = startDate.getUTCFullYear();
const CELL = 13;
const GAP = 2;
const LABEL_W = 28;
const rows: { month: number; year: number; days: (YearPoint | null)[] }[] = [];
for (let m = 0; m < 12; m++) {
const month = (startMonth + m) % 12;
const year = startYear + Math.floor((startMonth + m) / 12);
const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
const days: (YearPoint | null)[] = [];
for (let d = 1; d <= 31; d++) {
if (d > daysInMonth) {
days.push(null);
} else {
const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
days.push(byDate.get(dateStr) ?? null);
}
}
rows.push({ month, year, days });
}
const svgW = LABEL_W + 31 * (CELL + GAP);
const svgH = 12 * (CELL + GAP);
return (
<div style={{ position: 'relative' }}>
<svg width={svgW} height={svgH} style={{ display: 'block', overflow: 'visible' }}>
{rows.map((row, ri) => (
<g key={ri} transform={`translate(0, ${ri * (CELL + GAP)})`}>
<text
x={LABEL_W - 4}
y={CELL - 2}
textAnchor="end"
fill="var(--text-lo)"
fontSize={9}
fontFamily="IBM Plex Mono"
>
{MONTH_ABBR[row.month]}
</text>
{row.days.map((pt, di) => {
const x = LABEL_W + di * (CELL + GAP);
const isToday = pt?.date === today;
if (!pt) {
return (
<rect key={di} x={x} y={0} width={CELL} height={CELL}
fill="#111520" rx={2} />
);
}
const color = altColorHex(pt.alt_at_midnight);
const moonAlpha = Math.round(pt.moon_illumination * 60);
return (
<g key={di}>
<rect x={x} y={0} width={CELL} height={CELL} fill={color} rx={2} opacity={0.85} />
{/* Moon overlay — blue tint proportional to illumination */}
<rect x={x} y={0} width={CELL} height={CELL}
fill={`rgba(77,157,224,${(moonAlpha / 255).toFixed(2)})`} rx={2} />
{isToday && (
<rect x={x} y={0} width={CELL} height={CELL}
fill="none" stroke="var(--amber)" strokeWidth={1.5} rx={2} />
)}
<rect x={x} y={0} width={CELL} height={CELL} fill="transparent" rx={2}
onMouseEnter={e => setTooltip({ x: x + CELL + 4, y: ri * (CELL + GAP), point: pt })}
onMouseLeave={() => setTooltip(null)}
/>
</g>
);
})}
</g>
))}
</svg>
{tooltip && (
<div style={{
position: 'absolute',
left: tooltip.x,
top: tooltip.y,
background: 'var(--bg-panel)',
border: '1px solid var(--border-hi)',
borderRadius: 4,
padding: '5px 8px',
fontFamily: 'var(--font-mono)',
fontSize: 10,
color: 'var(--text-hi)',
pointerEvents: 'none',
zIndex: 10,
whiteSpace: 'nowrap',
}}>
<div style={{ color: 'var(--text-mid)', marginBottom: 2 }}>{tooltip.point.date}</div>
<div>Alt: <span style={{ color: altColorHex(tooltip.point.alt_at_midnight) }}>{tooltip.point.alt_at_midnight.toFixed(1)}°</span></div>
<div>Usable: {(tooltip.point.usable_min / 60).toFixed(1)}h</div>
<div>Moon: {Math.round(tooltip.point.moon_illumination * 100)}%</div>
</div>
)}
</div>
);
}
export default function YearlyVisibility({ points }: Props) {
if (!points.length) return null;
// Sample to ~52 weekly points for readability
const stride = Math.max(1, Math.floor(points.length / 52));
const sampled = points.filter((_, i) => i % stride === 0);
const data = sampled.map(p => {
const d = new Date(p.date + 'T00:00:00Z');
return {
label: `${MONTH_ABBR[d.getUTCMonth()]} ${d.getUTCDate()}`,
month: d.getUTCMonth(),
alt: Math.round(p.alt_at_midnight * 10) / 10,
transit_alt: Math.round(p.transit_alt),
usable: Math.round(p.usable_min / 60 * 10) / 10,
moon: Math.round(p.moon_illumination * 100),
};
});
return (
<div>
<div style={{ fontSize: 11, color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', marginBottom: 6 }}>
ALTITUDE AT MIDNIGHT — next 12 months (varies as transit shifts through seasons)
<div style={{ fontSize: 11, color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', marginBottom: 8 }}>
SEASONAL VISIBILITY — next 12 months · altitude at local midnight
</div>
<div style={{ width: '100%', height: 160 }}>
<ResponsiveContainer>
<ComposedChart data={data} margin={{ top: 4, right: 8, bottom: 4, left: -18 }}>
<CartesianGrid stroke="var(--border)" strokeDasharray="3 3" vertical={false} />
<XAxis
dataKey="label"
tick={{ fill: 'var(--text-lo)', fontSize: 9, fontFamily: 'IBM Plex Mono' }}
interval={Math.floor(data.length / 12)}
tickLine={false}
/>
<YAxis
yAxisId="alt"
domain={[0, 90]}
tick={{ fill: 'var(--text-lo)', fontSize: 9, fontFamily: 'IBM Plex Mono' }}
tickLine={false}
tickFormatter={v => `${v}°`}
width={32}
/>
<YAxis
yAxisId="moon"
orientation="right"
domain={[0, 100]}
tick={{ fill: 'var(--text-lo)', fontSize: 9, fontFamily: 'IBM Plex Mono' }}
tickLine={false}
tickFormatter={v => `${v}%`}
width={28}
/>
<Tooltip
contentStyle={{
background: 'var(--bg-panel)',
border: '1px solid var(--border-hi)',
borderRadius: 4,
fontFamily: 'IBM Plex Mono',
fontSize: 11,
color: 'var(--text-hi)',
}}
formatter={(value: number, name: string) => {
if (name === 'alt') return [`${value}°`, 'Alt at midnight'];
if (name === 'moon') return [`${value}%`, 'Moon'];
return [value, name];
}}
/>
<Bar yAxisId="alt" dataKey="alt" radius={[1, 1, 0, 0]} maxBarSize={12}>
{data.map((entry, i) => (
<Cell key={i} fill={altColor(entry.alt)} fillOpacity={0.7} />
))}
</Bar>
<Line
yAxisId="moon"
type="monotone"
dataKey="moon"
stroke="#4d9de0"
strokeWidth={1}
dot={false}
strokeOpacity={0.5}
strokeDasharray="3 2"
/>
</ComposedChart>
</ResponsiveContainer>
</div>
<div style={{ display: 'flex', gap: 16, marginTop: 6, flexWrap: 'wrap' }}>
<CalendarHeatmap points={points} />
<div style={{ display: 'flex', gap: 14, marginTop: 8, flexWrap: 'wrap' }}>
{[
{ color: 'var(--good)', label: '≥50° excellent' },
{ color: '#3dba72', label: '≥50° excellent' },
{ color: '#2ab8a0', label: '30–50° good' },
{ color: 'var(--warn)', label: '15–30° marginal' },
{ color: 'var(--muted)', label: '<15° poor' },
{ color: '#4d9de0', label: 'Moon %' },
{ color: '#e8c030', label: '15–30° marginal' },
{ color: '#3a4258', label: '<15° poor' },
{ color: 'rgba(77,157,224,0.6)', label: 'Moon overlay' },
].map(({ color, label }) => (
<div key={label} style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
<div style={{ width: 10, height: 10, background: color, borderRadius: 2, opacity: 0.8 }} />
<div style={{ width: 10, height: 10, background: color, borderRadius: 2 }} />
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>{label}</span>
</div>
))}
frontend/src/components/session/PlanningTimeline.tsx
+236
View File
@@ -0,0 +1,236 @@
import { useState, useMemo } from 'react';
import type { Target } from '../../api/types';
interface PlanEntry {
target: Target;
durationMin: number;
}
interface Props {
targets: Target[]; // tonight's visible targets
dusk: string;
dawn: string;
}
const FILTER_LABELS: Record<string, string> = {
sv220: 'Ha+OIII', c2: 'SII+OIII', sv260: 'LP', uvir: 'UV/IR',
};
const FILTER_COLORS: Record<string, string> = {
sv220: 'var(--good)', c2: 'var(--teal)', sv260: 'var(--blue)', uvir: 'var(--amber)',
};
function fmtTime(utc: string): string {
return new Date(utc).toLocaleTimeString('fr-FR', {
hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris',
});
}
function fmtUtcOffset(ms: number, baseMs: number): string {
const d = new Date(baseMs + ms);
return d.toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' });
}
export default function PlanningTimeline({ targets, dusk, dawn }: Props) {
const [plan, setPlan] = useState<PlanEntry[]>([]);
const [search, setSearch] = useState('');
const [exported, setExported] = useState(false);
const duskMs = new Date(dusk).getTime();
const dawnMs = new Date(dawn).getTime();
const nightMs = dawnMs - duskMs;
const filtered = useMemo(() =>
targets.filter(t =>
t.best_start_utc && t.best_end_utc &&
!plan.find(p => p.target.id === t.id) &&
(search === '' ||
(t.common_name ?? t.name).toLowerCase().includes(search.toLowerCase()) ||
t.name.toLowerCase().includes(search.toLowerCase()))
).slice(0, 20),
[targets, plan, search]);
const addTarget = (t: Target, durationMin = 120) => {
setPlan(p => [...p, { target: t, durationMin }]);
setSearch('');
};
const removeTarget = (id: string) => setPlan(p => p.filter(e => e.target.id !== id));
const moveUp = (i: number) => setPlan(p => { const n = [...p]; [n[i-1], n[i]] = [n[i], n[i-1]]; return n; });
const moveDown = (i: number) => setPlan(p => { const n = [...p]; [n[i], n[i+1]] = [n[i+1], n[i]]; return n; });
const updateDuration = (i: number, min: number) => setPlan(p => p.map((e, j) => j === i ? { ...e, durationMin: min } : e));
// Compute start times
const schedule = useMemo(() => {
let cursor = duskMs;
return plan.map(entry => {
const start = cursor;
const end = cursor + entry.durationMin * 60_000;
cursor = end;
return { entry, startMs: start, endMs: end };
});
}, [plan, duskMs]);
const totalMinutes = plan.reduce((s, e) => s + e.durationMin, 0);
const nightMinutes = Math.round(nightMs / 60_000);
const overrun = totalMinutes > nightMinutes;
const exportText = () => {
const lines = schedule.map(({ entry, startMs, endMs }) =>
`${fmtUtcOffset(startMs - duskMs, duskMs)} ${entry.target.common_name ?? entry.target.name} (${entry.target.name}) · ${entry.durationMin}min [${FILTER_LABELS[entry.target.recommended_filter ?? ''] ?? '—'}] → ${fmtUtcOffset(endMs - duskMs, duskMs)}`
);
const text = lines.join('\n');
void navigator.clipboard.writeText(text).then(() => {
setExported(true);
setTimeout(() => setExported(false), 2000);
});
};
return (
<div>
{/* Add targets search bar */}
<div style={{ marginBottom: 12 }}>
<input
type="text"
value={search}
onChange={e => setSearch(e.target.value)}
placeholder="Search targets to add to plan…"
style={{
width: '100%', boxSizing: 'border-box',
background: 'var(--bg-deep)', border: '1px solid var(--border)',
borderRadius: 4, color: 'var(--text-hi)',
fontFamily: 'var(--font-mono)', fontSize: 12, padding: '7px 12px',
}}
/>
{search && filtered.length > 0 && (
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 4, marginTop: 2, maxHeight: 200, overflowY: 'auto' }}>
{filtered.map(t => (
<div key={t.id}
onClick={() => addTarget(t)}
style={{ padding: '6px 12px', cursor: 'pointer', borderBottom: '1px solid var(--border)', display: 'flex', alignItems: 'center', gap: 10 }}
>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--amber)', flex: 1 }}>
{t.common_name ?? t.name}
{t.common_name && <span style={{ color: 'var(--text-lo)', marginLeft: 6, fontSize: 10 }}>{t.name}</span>}
</span>
{t.max_alt_deg != null && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--good)' }}>{t.max_alt_deg.toFixed(0)}°</span>
)}
{t.recommended_filter && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: FILTER_COLORS[t.recommended_filter] ?? 'var(--muted)' }}>
{FILTER_LABELS[t.recommended_filter] ?? t.recommended_filter}
</span>
)}
</div>
))}
</div>
)}
</div>
{/* Plan list + Gantt */}
{plan.length === 0 ? (
<div style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 12, padding: '16px 0' }}>
Search and add targets above to build your plan.
</div>
) : (
<>
{/* Total / overrun warning */}
<div style={{ display: 'flex', alignItems: 'center', gap: 16, marginBottom: 12 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: overrun ? 'var(--danger)' : 'var(--good)' }}>
{overrun ? '⚠ ' : ''}Total: {Math.floor(totalMinutes / 60)}h {totalMinutes % 60}m / {Math.floor(nightMinutes / 60)}h {nightMinutes % 60}m night
</span>
<button
onClick={exportText}
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: exported ? 'var(--good)' : 'var(--text-lo)', background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 3, padding: '3px 10px', cursor: 'pointer' }}
>
{exported ? '✓ Copied' : '↓ Copy run order'}
</button>
</div>
{/* Timeline header */}
<div style={{ display: 'grid', gridTemplateColumns: '1fr 80px 32px 32px', gap: 8, marginBottom: 4 }}>
<div style={{ position: 'relative', height: 14 }}>
{[0, 0.25, 0.5, 0.75, 1].map(frac => (
<span key={frac} style={{ position: 'absolute', left: `${frac * 100}%`, transform: 'translateX(-50%)', fontFamily: 'var(--font-mono)', fontSize: 9, color: 'var(--text-lo)' }}>
{new Date(duskMs + frac * nightMs).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' })}
</span>
))}
</div>
<div />
<div />
<div />
</div>
{/* Plan rows */}
{schedule.map(({ entry, startMs, endMs }, i) => {
const { target, durationMin } = entry;
const left = Math.max(0, Math.min(100, ((startMs - duskMs) / nightMs) * 100));
const width = Math.max(1, Math.min(100 - left, ((endMs - startMs) / nightMs) * 100));
const filterColor = FILTER_COLORS[target.recommended_filter ?? ''] ?? 'var(--muted)';
// Warn if block extends past dawn or past target's best window
const pastDawn = endMs > dawnMs;
const pastWindow = target.best_end_utc && endMs > new Date(target.best_end_utc).getTime();
const warn = pastDawn || pastWindow;
return (
<div key={target.id} style={{ display: 'grid', gridTemplateColumns: '1fr 80px 32px 32px', gap: 8, marginBottom: 8, alignItems: 'center' }}>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: warn ? 'var(--warn)' : 'var(--text-mid)', marginBottom: 3 }}>
{target.common_name ?? target.name}
{warn && <span style={{ marginLeft: 6, fontSize: 10, color: 'var(--warn)' }}>
{pastDawn ? '⚠ past dawn' : '⚠ past window'}
</span>}
</div>
<div style={{ position: 'relative', height: 16, background: 'var(--bg-deep)', borderRadius: 3 }}>
{/* Target's visibility window */}
{target.best_start_utc && target.best_end_utc && (
<div style={{
position: 'absolute',
left: `${Math.max(0, (new Date(target.best_start_utc).getTime() - duskMs) / nightMs * 100)}%`,
width: `${Math.min(100, (new Date(target.best_end_utc).getTime() - new Date(target.best_start_utc).getTime()) / nightMs * 100)}%`,
height: '100%',
background: filterColor,
opacity: 0.15,
borderRadius: 3,
}} />
)}
{/* Planned block */}
<div style={{
position: 'absolute',
left: `${left}%`,
width: `${width}%`,
height: '100%',
background: warn ? 'var(--danger)' : filterColor,
borderRadius: 3,
opacity: 0.8,
}} />
{/* Start/end times */}
<div style={{ position: 'absolute', left: `${left + 0.5}%`, top: 1, fontFamily: 'var(--font-mono)', fontSize: 8, color: '#fff', zIndex: 1 }}>
{fmtTime(new Date(startMs).toISOString())}
</div>
</div>
</div>
{/* Duration input */}
<div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
<input
type="number"
min={15}
max={480}
step={15}
value={durationMin}
onChange={e => updateDuration(i, parseInt(e.target.value) || 60)}
style={{ width: 48, background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 3, color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 11, padding: '2px 4px', textAlign: 'right' }}
/>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>m</span>
</div>
{/* Move up/down */}
<button onClick={() => moveUp(i)} disabled={i === 0} style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', background: 'none', border: '1px solid var(--border)', borderRadius: 3, padding: '2px 4px', cursor: 'pointer', opacity: i === 0 ? 0.3 : 1 }}>↑</button>
{/* Remove */}
<button onClick={() => removeTarget(target.id)} style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--danger)', background: 'none', border: '1px solid var(--border)', borderRadius: 3, padding: '2px 4px', cursor: 'pointer' }}>✕</button>
</div>
);
})}
</>
)}
</div>
);
}
frontend/src/components/session/SessionChecklist.tsx
+132
View File
@@ -0,0 +1,132 @@
import { useState } from 'react';
const ITEMS = [
{ id: 'polar', label: 'Polar alignment verified' },
{ id: 'focus', label: 'Focus achieved (Bahtinov / auto-focus)' },
{ id: 'guiding', label: 'Guiding RMS < 1″' },
{ id: 'dew', label: 'Dew heater powered on' },
{ id: 'battery', label: 'Battery / power supply checked' },
{ id: 'cap', label: 'Lens cap removed' },
];
const LS_KEY = 'astronome_session_checklist_v1';
interface ChecklistState {
date: string;
checked: string[];
}
function loadState(duskDate: string): string[] {
try {
const raw = localStorage.getItem(LS_KEY);
if (raw) {
const state = JSON.parse(raw) as ChecklistState;
if (state.date === duskDate) return state.checked;
}
} catch { /* ignore */ }
return [];
}
function saveState(duskDate: string, checked: string[]) {
const state: ChecklistState = { date: duskDate, checked };
localStorage.setItem(LS_KEY, JSON.stringify(state));
}
interface Props {
duskDate: string; // "2026-04-17" — auto-reset key
}
export default function SessionChecklist({ duskDate }: Props) {
const [expanded, setExpanded] = useState(false);
const [checked, setChecked] = useState<string[]>(() => loadState(duskDate));
const toggle = (id: string) => {
setChecked(prev => {
const next = prev.includes(id) ? prev.filter(x => x !== id) : [...prev, id];
saveState(duskDate, next);
return next;
});
};
const done = checked.length;
const total = ITEMS.length;
const allDone = done === total;
return (
<div style={{ background: 'var(--bg-panel)', border: `1px solid ${allDone ? 'var(--good)' : 'var(--border)'}`, borderRadius: 6, overflow: 'hidden', transition: 'border-color 0.2s' }}>
<div
onClick={() => setExpanded(v => !v)}
style={{
display: 'flex', alignItems: 'center', gap: 10,
padding: '10px 14px', cursor: 'pointer',
}}
>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', flex: 1 }}>
Pre-session Checklist
</span>
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 11,
color: allDone ? 'var(--good)' : done > 0 ? 'var(--warn)' : 'var(--text-lo)',
fontWeight: 600,
}}>
{allDone ? '✓ Ready' : `${done}/${total}`}
</span>
<div style={{ width: 60, height: 4, background: 'var(--bg-hover)', borderRadius: 2, overflow: 'hidden' }}>
<div style={{ width: `${(done / total) * 100}%`, height: '100%', background: allDone ? 'var(--good)' : 'var(--warn)', borderRadius: 2, transition: 'width 0.3s' }} />
</div>
<span style={{ color: 'var(--text-lo)', fontSize: 11 }}>{expanded ? '▲' : '▼'}</span>
</div>
{expanded && (
<div style={{ borderTop: '1px solid var(--border)', padding: '10px 14px', display: 'flex', flexDirection: 'column', gap: 8 }}>
{ITEMS.map(item => {
const isChecked = checked.includes(item.id);
return (
<label
key={item.id}
style={{ display: 'flex', alignItems: 'center', gap: 10, cursor: 'pointer' }}
>
<div
onClick={() => toggle(item.id)}
style={{
width: 16, height: 16, borderRadius: 3, flexShrink: 0,
border: `1.5px solid ${isChecked ? 'var(--good)' : 'var(--border-hi)'}`,
background: isChecked ? 'var(--good)' : 'var(--bg-deep)',
display: 'flex', alignItems: 'center', justifyContent: 'center',
transition: 'background 0.15s, border-color 0.15s',
}}
>
{isChecked && (
<svg width="10" height="8" viewBox="0 0 10 8" fill="none">
<path d="M1 4L3.5 6.5L9 1" stroke="#080a0f" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round"/>
</svg>
)}
</div>
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 12,
color: isChecked ? 'var(--text-mid)' : 'var(--text-hi)',
textDecoration: isChecked ? 'line-through' : 'none',
transition: 'color 0.15s',
}}>
{item.label}
</span>
</label>
);
})}
<button
onClick={() => { setChecked([]); saveState(duskDate, []); }}
style={{
marginTop: 4, alignSelf: 'flex-start',
fontFamily: 'var(--font-mono)', fontSize: 10,
color: 'var(--text-lo)', background: 'none',
border: '1px solid var(--border)', borderRadius: 3,
padding: '2px 8px', cursor: 'pointer',
}}
>
Reset
</button>
</div>
)}
</div>
);
}
frontend/src/components/targets/CompareModal.tsx
+264
View File
@@ -0,0 +1,264 @@
import { useQuery } from '@tanstack/react-query';
import { api } from '../../api';
import { useTonight } from '../../hooks/useTonight';
import AltitudeCurve from '../charts/AltitudeCurve';
import TypeBadge from './TypeBadge';
import type { Target } from '../../api/types';
const GOAL_HOURS: Record<string, Record<string, number>> = {
galaxy: { uvir: 4.0, sv260: 6.0 },
emission_nebula: { sv220: 3.0, c2: 4.0, sv260: 8.0, uvir: 12.0 },
reflection_nebula: { uvir: 3.0, sv260: 5.0 },
planetary_nebula: { sv220: 2.0, c2: 3.0 },
snr: { sv220: 5.0, c2: 6.0 },
open_cluster: { uvir: 1.0 },
globular_cluster: { uvir: 1.5 },
dark_nebula: { uvir: 3.0 },
};
const FILTER_LABELS: Record<string, string> = {
sv220: 'Ha+OIII', c2: 'SII+OIII', sv260: 'LP', uvir: 'UV/IR',
};
const SUITABILITY_COLOR: Record<string, string> = {
ideal: 'var(--good)', good: 'var(--teal)', marginal: 'var(--warn)', unsuitable: 'var(--muted)',
};
function fmtTime(utc?: string): string {
if (!utc) return '—';
return new Date(utc).toLocaleTimeString('fr-FR', {
hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris',
});
}
function fmtMin(min?: number): string {
if (min == null) return '—';
if (min < 60) return `${min}m`;
return `${Math.floor(min / 60)}h ${min % 60}m`;
}
function IntegrationBar({ obj_type, filter, keeperMin }: {
obj_type: string; filter?: string; keeperMin: number;
}) {
const goals = GOAL_HOURS[obj_type];
if (!goals) return null;
const goalMin = (filter && goals[filter] ? goals[filter] : Object.values(goals)[0]) * 60;
const pct = Math.min((keeperMin / goalMin) * 100, 100);
const color = pct >= 100 ? 'var(--good)' : pct >= 60 ? 'var(--warn)' : 'var(--danger)';
return (
<div>
<div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 3 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
{FILTER_LABELS[filter ?? ''] ?? 'Primary filter'} goal
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color }}>
{fmtMin(keeperMin)} / {fmtMin(goalMin)}
</span>
</div>
<div style={{ height: 5, background: 'var(--bg-deep)', borderRadius: 3, overflow: 'hidden' }}>
<div style={{ height: '100%', width: `${pct}%`, background: color, borderRadius: 3, transition: 'width 0.3s' }} />
</div>
</div>
);
}
function TargetColumn({ target }: { target: Target }) {
const { data: tonight } = useTonight();
const { data: curveData } = useQuery({
queryKey: ['curve', target.id],
queryFn: () => api.targets.curve(target.id),
staleTime: 5 * 60_000,
});
const { data: logData } = useQuery({
queryKey: ['log', target.id],
queryFn: () => api.log.forTarget(target.id),
staleTime: 5 * 60_000,
});
const { data: filterData } = useQuery({
queryKey: ['filters', target.id],
queryFn: () => api.targets.filters(target.id),
staleTime: 10 * 60_000,
});
const dusk = tonight?.astro_dusk_utc ?? '';
const dawn = tonight?.astro_dawn_utc ?? '';
const topFilters = filterData?.recommendations.filter(r => r.suitability !== 'unsuitable').slice(0, 3) ?? [];
const primaryFilter = topFilters[0]?.filter_id;
const keeperMin = logData?.filter_breakdown
.filter(fb => fb.filter_id === primaryFilter)
.reduce((s, fb) => s + fb.total_min, 0) ?? 0;
return (
<div style={{ flex: 1, minWidth: 0 }}>
{/* Header */}
<div style={{ marginBottom: 12 }}>
<div style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 4 }}>
<TypeBadge type={target.obj_type} />
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 14, fontWeight: 700, color: 'var(--amber)' }}>
{target.common_name ?? target.name}
</span>
</div>
{target.common_name && (
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)' }}>{target.name}</div>
)}
{target.constellation && (
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginTop: 2 }}>
{target.constellation}
</div>
)}
</div>
{/* Altitude curve */}
{dusk && dawn && curveData?.curve.length ? (
<AltitudeCurve
curve={curveData.curve}
dusk={dusk}
dawn={dawn}
trueDarkStart={tonight?.true_dark_start_utc}
trueDarkEnd={tonight?.true_dark_end_utc}
moonSepDeg={target.moon_sep_deg}
/>
) : (
<div style={{ height: 240, display: 'flex', alignItems: 'center', justifyContent: 'center', color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>
No curve available
</div>
)}
{/* Key stats */}
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '4px 12px', margin: '12px 0', fontFamily: 'var(--font-mono)', fontSize: 11 }}>
{[
['Max Alt', `${target.max_alt_deg?.toFixed(0) ?? '—'}°`],
['Usable', fmtMin(target.usable_min)],
['Transit', fmtTime(target.transit_utc)],
['Best start', fmtTime(target.best_start_utc)],
['Moon sep', `${target.moon_sep_deg?.toFixed(0) ?? '—'}°`],
['Size', target.size_arcmin_maj ? `${target.size_arcmin_maj.toFixed(1)}′` : '—'],
].map(([label, val]) => (
<div key={label} style={{ display: 'flex', justifyContent: 'space-between', padding: '3px 0', borderBottom: '1px solid var(--border)' }}>
<span style={{ color: 'var(--text-lo)' }}>{label}</span>
<span style={{ color: 'var(--text-hi)' }}>{val}</span>
</div>
))}
</div>
{/* Filter recommendations */}
{topFilters.length > 0 && (
<div style={{ marginBottom: 12 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', textTransform: 'uppercase', letterSpacing: '0.08em', marginBottom: 6 }}>
Filters tonight
</div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
{topFilters.map(f => (
<div key={f.filter_id} style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
background: SUITABILITY_COLOR[f.suitability] + '22',
color: SUITABILITY_COLOR[f.suitability],
border: `1px solid ${SUITABILITY_COLOR[f.suitability]}44`,
borderRadius: 3, padding: '1px 6px',
minWidth: 50, textAlign: 'center',
}}>
{f.suitability}
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-mid)' }}>
{FILTER_LABELS[f.filter_id] ?? f.filter_id}
</span>
{f.est_integration_hours && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginLeft: 'auto' }}>
{f.est_integration_hours}h goal
</span>
)}
</div>
))}
</div>
</div>
)}
{/* Integration progress */}
<div style={{ marginBottom: 8 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', textTransform: 'uppercase', letterSpacing: '0.08em', marginBottom: 8 }}>
Integration (keepers)
</div>
{logData?.filter_breakdown.length ? (
<>
{logData.filter_breakdown.map(fb => (
<div key={fb.filter_id} style={{ marginBottom: 8 }}>
<IntegrationBar
obj_type={target.obj_type}
filter={fb.filter_id}
keeperMin={fb.total_min}
/>
</div>
))}
</>
) : (
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)' }}>
Not yet imaged
</div>
)}
{keeperMin > 0 && primaryFilter && (
<div style={{ marginTop: 8 }}>
<IntegrationBar
obj_type={target.obj_type}
filter={primaryFilter}
keeperMin={keeperMin}
/>
</div>
)}
</div>
</div>
);
}
interface Props {
targets: [Target, Target];
onClose: () => void;
}
export default function CompareModal({ targets, onClose }: Props) {
return (
<div
style={{
position: 'fixed', inset: 0, zIndex: 1000,
background: 'rgba(8,10,15,0.85)',
display: 'flex', alignItems: 'center', justifyContent: 'center',
padding: 24,
}}
onClick={e => { if (e.target === e.currentTarget) onClose(); }}
>
<div style={{
background: 'var(--bg-panel)', border: '1px solid var(--border-hi)',
borderRadius: 8, width: '100%', maxWidth: 1100, maxHeight: '90vh',
display: 'flex', flexDirection: 'column', overflow: 'hidden',
}}>
{/* Header */}
<div style={{
display: 'flex', alignItems: 'center', justifyContent: 'space-between',
padding: '12px 20px', borderBottom: '1px solid var(--border)',
}}>
<span style={{ fontFamily: 'var(--font-display)', fontSize: 13, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase' }}>
Target Comparison
</span>
<button
onClick={onClose}
style={{ fontFamily: 'var(--font-mono)', fontSize: 13, color: 'var(--text-lo)', background: 'none', border: 'none', cursor: 'pointer', padding: '2px 6px' }}
>
✕
</button>
</div>
{/* Body */}
<div style={{ display: 'flex', gap: 0, overflow: 'auto', flex: 1 }}>
<div style={{ flex: 1, padding: 20, overflow: 'auto', borderRight: '1px solid var(--border)' }}>
<TargetColumn target={targets[0]} />
</div>
<div style={{ flex: 1, padding: 20, overflow: 'auto' }}>
<TargetColumn target={targets[1]} />
</div>
</div>
</div>
</div>
);
}
frontend/src/components/targets/DetailDrawer.tsx
+343 -112
View File
@@ -1,6 +1,6 @@
import { useState } from 'react';
import type { Target, Workflow } from '../../api/types';
import { useTargetCurve, useTargetFilters, useTargetVisibility, useTargetWorkflow, useTargetYearly } from '../../hooks/useTargets';
import { useTargetCurve, useTargetFilters, useTargetSimilar, useTargetVisibility, useTargetWorkflow, useTargetYearly } from '../../hooks/useTargets';
import { useTargetLog } from '../../hooks/useLog';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { api } from '../../api';
@@ -18,7 +18,7 @@ interface Props {
target: Target;
}
const TABS = ['Tonight', 'Target', 'Filters & Workflow', 'Log & Gallery', 'Yearly'];
const TABS = ['Overview', 'Filters & Workflow', 'Log & Gallery', 'Yearly'];
const WORKFLOW_SHORT: Record<string, string> = {
'HA+OIII Dual Narrowband (SV220)': 'HaOIII',
@@ -72,6 +72,147 @@ function fmtTime(utc?: string): string {
return new Date(utc).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' });
}
// Observer longitude from config (Villevieille, France)
const OBS_LON = 4.1167;
/** Compute current hour angle (degrees) for a target at the given RA (degrees). */
function currentHourAngle(ra_deg: number): number {
const now = Date.now() / 1000; // unix seconds
const jd = 2440587.5 + now / 86400.0;
const t = (jd - 2451545.0) / 36525.0;
const gmst = (280.46061837 + 360.98564736629 * (jd - 2451545.0) + 0.000387933 * t * t) % 360;
const lst = ((gmst + OBS_LON) % 360 + 360) % 360;
let ha = ((lst - ra_deg) % 360 + 360) % 360;
if (ha > 180) ha -= 360; // range -180..+180
return ha;
}
function fmtHa(ha_deg: number): string {
const sign = ha_deg >= 0 ? '+' : '-';
const abs = Math.abs(ha_deg);
const h = Math.floor(abs / 15);
const m = Math.floor((abs % 15) * 4);
const s = Math.round(((abs % 15) * 4 - m) * 60);
return `${sign}${h}h ${m < 10 ? '0' : ''}${m}m ${s < 10 ? '0' : ''}${s}s`;
}
function CopyButton({ text }: { text: string }) {
const [copied, setCopied] = useState(false);
const copy = () => {
void navigator.clipboard.writeText(text).then(() => {
setCopied(true);
setTimeout(() => setCopied(false), 1500);
});
};
return (
<button
onClick={copy}
style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
color: copied ? 'var(--good)' : 'var(--text-lo)',
background: 'var(--bg-void)', border: '1px solid var(--border)',
borderRadius: 3, padding: '2px 6px', cursor: 'pointer',
marginLeft: 6, transition: 'color 0.15s',
}}
>
{copied ? '✓' : 'copy'}
</button>
);
}
// Sensor constants for ToupTek ATR2600C / IMX571 at f/6.9, Bortle 5
const READ_NOISE_E = 3.5;
const DARK_E_PER_S = 0.002;
const SUB_SEC = 180; // 3-min subs
// Sky background e-/px/s by filter (empirical for Bortle 5, AT71)
const SKY_BG: Record<string, number> = {
uvir: 3.0,
sv260: 1.8,
sv220: 0.04,
c2: 0.03,
};
/** Source signal e-/px/s from surface brightness (mag/arcsec²), Bortle 5 calibration. */
function signalFromSB(sb: number): number {
// Reference: SB=21 → ~0.001 e-/px/s at this aperture+scale
return 0.001 * Math.pow(10, (21 - sb) / 2.5);
}
function subsNeeded(signal_e_s: number, sky_e_s: number, targetSnr: number): number {
const s = signal_e_s * SUB_SEC; // signal per sub
const b = sky_e_s * SUB_SEC; // sky per sub
const d = DARK_E_PER_S * SUB_SEC; // dark per sub
const r2 = READ_NOISE_E * READ_NOISE_E;
if (s <= 0) return 999;
const noise_per_sub = s + b + d + r2;
return Math.ceil((targetSnr * targetSnr * noise_per_sub) / (s * s));
}
function ImagingCalculator({ target, filterId }: { target: Target; filterId: string }) {
const [targetSnr, setTargetSnr] = useState(20);
const sb = target.surface_brightness;
const sky = SKY_BG[filterId] ?? 1.0;
const signal = sb != null ? signalFromSB(sb) : null;
const n = signal != null ? subsNeeded(signal, sky, targetSnr) : null;
const totalMin = n != null ? n * (SUB_SEC / 60) : null;
const totalH = totalMin != null ? (totalMin / 60).toFixed(1) : null;
return (
<div style={{ background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 4, padding: '12px 14px' }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.08em', textTransform: 'uppercase', marginBottom: 10 }}>
SNR Calculator — 3-min subs · IMX571 · f/6.9 · Bortle 5
</div>
{sb == null ? (
<div style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>
Surface brightness not available for this object.
</div>
) : (
<div style={{ display: 'flex', gap: 24, alignItems: 'center', flexWrap: 'wrap' }}>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginBottom: 4 }}>
Target SNR: <strong style={{ color: 'var(--amber)' }}>{targetSnr}</strong>
</div>
<input
type="range" min={10} max={50} step={5}
value={targetSnr}
onChange={e => setTargetSnr(parseInt(e.target.value))}
style={{ accentColor: 'var(--amber)', width: 140 }}
/>
</div>
<div style={{ display: 'flex', gap: 16 }}>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>Subs needed</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 20, fontWeight: 700, color: n != null && n < 100 ? 'var(--good)' : 'var(--warn)' }}>
{n != null ? (n > 500 ? '500+' : n) : '—'}
</div>
</div>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>Total time</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 20, fontWeight: 700, color: 'var(--amber)' }}>
{totalH != null ? `${totalH}h` : '—'}
</div>
</div>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>Sessions ~2h</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 20, fontWeight: 700, color: 'var(--blue)' }}>
{totalH != null ? `×${Math.ceil(parseFloat(totalH) / 2)}` : '—'}
</div>
</div>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>SB source</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 14, color: 'var(--text-mid)' }}>
{sb.toFixed(1)} mag/″²
</div>
</div>
</div>
</div>
)}
</div>
);
}
export default function DetailDrawer({ target }: Props) {
const [tab, setTab] = useState(0);
const [selectedFilter, setSelectedFilter] = useState('sv220');
@@ -85,16 +226,17 @@ export default function DetailDrawer({ target }: Props) {
const { data: workflowData } = useTargetWorkflow(target.id, selectedFilter);
const { data: logData } = useTargetLog(target.id);
const { data: horizonData } = useHorizon();
const { data: yearlyData } = useTargetYearly(target.id, tab === 4);
const { data: yearlyData } = useTargetYearly(target.id, tab === 3);
const { data: similarData } = useTargetSimilar(target.id);
const { data: galleryData } = useQuery({
queryKey: ['gallery', target.id],
queryFn: () => api.gallery.list(target.id),
enabled: tab === 3,
enabled: tab === 2,
});
const { data: notesData } = useQuery({
queryKey: ['target-notes', target.id],
queryFn: () => api.targets.getNotes(target.id),
enabled: tab === 3,
enabled: tab === 2,
});
const saveNotesMutation = useMutation({
mutationFn: (text: string) => api.targets.putNotes(target.id, text),
@@ -128,125 +270,210 @@ export default function DetailDrawer({ target }: Props) {
</div>
<div style={{ padding: '16px 20px' }}>
{/* Tab 1: Tonight */}
{/* Tab 1: Overview — altitude curve + metadata side by side */}
{tab === 0 && (
<div>
{curveData?.curve && curveData.curve.length > 0 ? (
<AltitudeCurve
curve={curveData.curve}
dusk={tonight?.astro_dusk_utc ?? ''}
dawn={tonight?.astro_dawn_utc ?? ''}
trueDarkStart={tonight?.true_dark_start_utc}
trueDarkEnd={tonight?.true_dark_end_utc}
meridianFlip={visData?.meridian_flip_utc}
horizonPoints={horizonData?.points}
moonSepDeg={visData?.moon_sep_deg}
/>
) : (
<div style={{ color: 'var(--text-lo)', fontSize: 12, fontFamily: 'var(--font-mono)', marginBottom: 12 }}>
Curve data loading…
{/* Top section: metadata left + altitude curve right */}
<div style={{ display: 'grid', gridTemplateColumns: '220px 1fr', gap: 20, marginBottom: 20 }}>
{/* Left: DSS image + metadata */}
<div>
<img
src={dssUrl}
alt={`DSS ${target.name}`}
style={{ width: '100%', borderRadius: 3, background: '#000', marginBottom: 6 }}
loading="lazy"
/>
<div style={{ fontSize: 10, color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', marginBottom: 10 }}>
DSS Digitized Sky Survey
</div>
<table style={{ borderCollapse: 'collapse', width: '100%' }}>
<tbody>
{[
['Type', target.obj_type],
['Constellation', target.constellation ?? '—'],
['RA', target.ra_h],
['Dec', target.dec_dms],
['Size', target.size_arcmin_maj ? `${target.size_arcmin_maj.toFixed(1)}′ × ${(target.size_arcmin_min ?? target.size_arcmin_maj).toFixed(1)}′` : '—'],
['Magnitude', target.mag_v?.toFixed(1) ?? '—'],
['SB', target.surface_brightness ? `${target.surface_brightness.toFixed(1)} mag/″²` : '—'],
['FOV fill', target.fov_fill_pct != null ? `${target.fov_fill_pct.toFixed(0)}%` : '—'],
['Guide stars', target.guide_star_density ?? '—'],
].map(([label, value]) => (
<tr key={label}>
<td style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 10, paddingBottom: 3, width: 80 }}>{label}</td>
<td style={{ color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>{value as string}</td>
</tr>
))}
</tbody>
</table>
</div>
)}
<table style={{ borderCollapse: 'collapse', width: '100%', marginTop: 12 }}>
<tbody>
{[
['Rise', fmtTime(visData?.rise_utc)],
['Transit', fmtTime(visData?.transit_utc)],
['Set', fmtTime(visData?.set_utc)],
['Best window', visData?.best_start_utc && visData?.best_end_utc
? `${fmtTime(visData.best_start_utc)} – ${fmtTime(visData.best_end_utc)}`
: '—'],
['Usable time', visData?.usable_min ? `${visData.usable_min} min` : '—'],
['Meridian flip', fmtTime(visData?.meridian_flip_utc)],
['Moon sep', visData?.moon_sep_deg != null ? `${visData.moon_sep_deg.toFixed(1)}°` : '—'],
['Airmass @transit', visData?.airmass_at_transit?.toFixed(2) ?? '—'],
['Extinction', visData?.extinction_mag != null ? `${visData.extinction_mag.toFixed(2)} mag` : '—'],
].map(([label, value]) => (
<tr key={label}>
<td style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11, paddingBottom: 4, width: 140 }}>{label}</td>
<td style={{ color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>{value}</td>
</tr>
))}
</tbody>
</table>
</div>
)}
{/* Tab 2: Target */}
{tab === 1 && (
<div style={{ display: 'grid', gridTemplateColumns: '180px 1fr', gap: 16 }}>
<div>
<img
src={dssUrl}
alt={`DSS ${target.name}`}
style={{ width: '100%', borderRadius: 3, background: '#000' }}
loading="lazy"
/>
<div style={{ marginTop: 8, fontSize: 10, color: 'var(--text-lo)', fontFamily: 'var(--font-mono)' }}>
DSS Digitized Sky Survey
{/* Right: altitude curve + key times */}
<div>
{curveData?.curve && curveData.curve.length > 0 ? (
<AltitudeCurve
curve={curveData.curve}
dusk={tonight?.astro_dusk_utc ?? ''}
dawn={tonight?.astro_dawn_utc ?? ''}
trueDarkStart={tonight?.true_dark_start_utc}
trueDarkEnd={tonight?.true_dark_end_utc}
meridianFlip={visData?.meridian_flip_utc}
horizonPoints={horizonData?.points}
moonSepDeg={visData?.moon_sep_deg}
/>
) : (
<div style={{ color: 'var(--text-lo)', fontSize: 12, fontFamily: 'var(--font-mono)', marginBottom: 12 }}>
Curve data loading…
</div>
)}
<table style={{ borderCollapse: 'collapse', width: '100%', marginTop: 12 }}>
<tbody>
{[
['Rise', fmtTime(visData?.rise_utc)],
['Transit', fmtTime(visData?.transit_utc)],
['Set', fmtTime(visData?.set_utc)],
['Best window', visData?.best_start_utc && visData?.best_end_utc
? `${fmtTime(visData.best_start_utc)} – ${fmtTime(visData.best_end_utc)}`
: '—'],
['Usable time', visData?.usable_min ? `${visData.usable_min} min` : '—'],
['Meridian flip', fmtTime(visData?.meridian_flip_utc)],
['Moon sep', visData?.moon_sep_deg != null ? `${visData.moon_sep_deg.toFixed(1)}°` : '—'],
['Airmass @transit', visData?.airmass_at_transit?.toFixed(2) ?? '—'],
['Extinction', visData?.extinction_mag != null ? `${visData.extinction_mag.toFixed(2)} mag` : '—'],
].map(([label, value]) => (
<tr key={label}>
<td style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11, paddingBottom: 4, width: 130 }}>{label}</td>
<td style={{ color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>{value}</td>
</tr>
))}
</tbody>
</table>
</div>
</div>
<div>
<table style={{ borderCollapse: 'collapse', width: '100%', marginBottom: 16 }}>
<tbody>
{[
['Type', target.obj_type],
['Constellation', target.constellation ?? '—'],
['RA', target.ra_h],
['Dec', target.dec_dms],
['Size', target.size_arcmin_maj ? `${target.size_arcmin_maj.toFixed(1)}′ × ${(target.size_arcmin_min ?? target.size_arcmin_maj).toFixed(1)}′` : '—'],
['Magnitude', target.mag_v?.toFixed(1) ?? '—'],
['Surface brightness', target.surface_brightness ? `${target.surface_brightness.toFixed(1)} mag/arcsec²` : '—'],
['Hubble type', target.hubble_type ?? '—'],
['FOV fill', target.fov_fill_pct != null ? `${target.fov_fill_pct.toFixed(0)}%` : '—'],
['Guide stars', target.guide_star_density ?? '—'],
].map(([label, value]) => (
<tr key={label}>
<td style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11, paddingBottom: 4, width: 140 }}>{label}</td>
<td style={{ color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>{value as string}</td>
</tr>
))}
</tbody>
</table>
{/* Guiding context badge */}
{target.guide_star_density && (() => {
const density = target.guide_star_density;
const msgs: Record<string, { color: string; text: string; note: string }> = {
sparse: { color: 'var(--warn)', text: 'Sparse guide field', note: 'OAG may struggle — consider a bright guide star or off-axis offset' },
moderate: { color: 'var(--blue)', text: 'Moderate guide field', note: 'OAG should work with careful star selection' },
rich: { color: 'var(--good)', text: 'Rich guide field', note: 'Plenty of guide stars for OAG or guidescope' },
};
const m = msgs[density];
if (!m) return null;
{/* Below the fold: GoTo card + guiding badge + links + Aladin */}
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16, marginBottom: 16 }}>
{/* GoTo mount coordinates */}
{(() => {
const ha = currentHourAngle(target.ra_deg);
const side = ha < 0 ? 'East (pre-meridian)' : 'West (post-meridian)';
const sideColor = ha < 0 ? 'var(--teal)' : 'var(--amber)';
return (
<div style={{
background: 'var(--bg-deep)',
border: `1px solid ${m.color}`,
borderRadius: 4,
padding: '6px 10px',
marginBottom: 12,
display: 'flex',
gap: 8,
alignItems: 'flex-start',
background: 'var(--bg-deep)', border: '1px solid var(--border)',
borderRadius: 4, padding: '8px 12px',
}}>
<span style={{ color: m.color, fontFamily: 'var(--font-mono)', fontSize: 11, fontWeight: 700, whiteSpace: 'nowrap' }}>
◉ {m.text}
</span>
<span style={{ color: 'var(--text-mid)', fontSize: 11, fontStyle: 'italic' }}>{m.note}</span>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 6 }}>
GoTo Coordinates (J2000)
</div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
<div style={{ display: 'flex', alignItems: 'center' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', width: 30 }}>RA</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--text-hi)' }}>{target.ra_h}</span>
<CopyButton text={target.ra_h} />
</div>
<div style={{ display: 'flex', alignItems: 'center' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', width: 30 }}>Dec</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--text-hi)' }}>{target.dec_dms}</span>
<CopyButton text={target.dec_dms} />
</div>
<div style={{ display: 'flex', alignItems: 'center', marginTop: 2 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', width: 30 }}>HA</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--text-hi)' }}>{fmtHa(ha)}</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: sideColor, marginLeft: 8 }}>
{side}
</span>
</div>
</div>
</div>
);
})()}
<AladinEmbed
ra={target.ra_deg}
dec={target.dec_deg}
mosaic={target.mosaic_flag ? { panels_w: target.mosaic_panels_w, panels_h: target.mosaic_panels_h } : undefined}
/>
{/* Guiding context + external links */}
<div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
{target.guide_star_density && (() => {
const density = target.guide_star_density;
const msgs: Record<string, { color: string; text: string; note: string }> = {
sparse: { color: 'var(--warn)', text: 'Sparse guide field', note: 'OAG may struggle' },
moderate: { color: 'var(--blue)', text: 'Moderate guide field', note: 'OAG with careful star selection' },
rich: { color: 'var(--good)', text: 'Rich guide field', note: 'Plenty of guide stars' },
};
const m = msgs[density];
if (!m) return null;
return (
<div style={{
background: 'var(--bg-deep)', border: `1px solid ${m.color}`,
borderRadius: 4, padding: '6px 10px', display: 'flex', gap: 8, alignItems: 'flex-start',
}}>
<span style={{ color: m.color, fontFamily: 'var(--font-mono)', fontSize: 11, fontWeight: 700, whiteSpace: 'nowrap' }}>◉ {m.text}</span>
<span style={{ color: 'var(--text-mid)', fontSize: 11, fontStyle: 'italic' }}>{m.note}</span>
</div>
);
})()}
<div style={{ display: 'flex', gap: 8 }}>
<a
href={`https://www.astrobin.com/search/?q=${encodeURIComponent(target.common_name ?? target.name)}`}
target="_blank" rel="noopener noreferrer"
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--blue)', background: 'var(--bg-deep)', border: '1px solid var(--blue-dim)', borderRadius: 3, padding: '4px 10px', textDecoration: 'none' }}
>
Astrobin ↗
</a>
<a
href={`https://www.astrobin.com/search/?q=${encodeURIComponent(target.name)}`}
target="_blank" rel="noopener noreferrer"
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 3, padding: '4px 10px', textDecoration: 'none' }}
>
Astrobin {target.name} ↗
</a>
</div>
</div>
</div>
{/* Similar targets nearby */}
{(similarData?.similar?.length ?? 0) > 0 && (
<div style={{ background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 4, padding: '8px 12px', marginBottom: 16 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.08em', textTransform: 'uppercase', marginBottom: 8 }}>
Similar Targets Nearby (same type · same constellation)
</div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 5 }}>
{similarData!.similar.slice(0, 3).map(s => (
<div key={s.id} style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
{s.messier_num != null && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--amber)', fontWeight: 700, width: 28 }}>
M{s.messier_num}
</span>
)}
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-hi)', flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
{s.common_name ?? s.name}
{s.common_name && <span style={{ color: 'var(--text-lo)', marginLeft: 5, fontSize: 10 }}>{s.name}</span>}
</span>
{s.size_arcmin_maj != null && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>{s.size_arcmin_maj.toFixed(1)}′</span>
)}
{s.max_alt_deg != null && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: (s.max_alt_deg ?? 0) >= 30 ? 'var(--good)' : 'var(--warn)' }}>{s.max_alt_deg.toFixed(0)}°</span>
)}
{s.transit_utc && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
{new Date(s.transit_utc).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' })}
</span>
)}
</div>
))}
</div>
</div>
)}
<AladinEmbed
ra={target.ra_deg}
dec={target.dec_deg}
mosaic={target.mosaic_flag ? { panels_w: target.mosaic_panels_w, panels_h: target.mosaic_panels_h } : undefined}
/>
</div>
)}
{/* Tab 3: Filters & Workflow */}
{tab === 2 && (
{/* Tab 2: Filters & Workflow */}
{tab === 1 && (
<div>
<table style={{ width: '100%', borderCollapse: 'collapse', marginBottom: 20 }}>
<thead>
@@ -296,11 +523,15 @@ export default function DetailDrawer({ target }: Props) {
</table>
{workflowData && <WorkflowCard workflow={workflowData} />}
<div style={{ marginTop: 20 }}>
<ImagingCalculator target={target} filterId={selectedFilter} />
</div>
</div>
)}
{/* Tab 5: Yearly */}
{tab === 4 && (
{/* Tab 4: Yearly */}
{tab === 3 && (
<div>
{yearlyData?.points ? (
<YearlyVisibility points={yearlyData.points} />
@@ -312,8 +543,8 @@ export default function DetailDrawer({ target }: Props) {
</div>
)}
{/* Tab 4: Log & Gallery */}
{tab === 3 && (
{/* Tab 3: Log & Gallery */}
{tab === 2 && (
<div>
{/* Filter breakdown + planning notes row */}
{((logData?.filter_breakdown && logData.filter_breakdown.length > 0) || true) && (
frontend/src/components/targets/TargetRow.tsx
+47 -1
View File
@@ -10,6 +10,8 @@ interface Props {
target: Target;
expanded: boolean;
onToggle: () => void;
inCompare?: boolean;
onCompare?: (t: Target) => void;
}
// Display labels for filter IDs
@@ -84,7 +86,7 @@ function difficultyDots(d?: number) {
);
}
export default function TargetRow({ target, expanded, onToggle }: Props) {
export default function TargetRow({ target, expanded, onToggle, inCompare, onCompare }: Props) {
const { data: tonight } = useTonight();
const { data: horizonData } = useHorizon();
const alt = fmtAlt(target.max_alt_deg);
@@ -131,15 +133,42 @@ export default function TargetRow({ target, expanded, onToggle }: Props) {
M{target.messier_num}
</span>
)}
{target.caldwell_num != null && target.messier_num == null && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--blue)', fontWeight: 700 }}>
C{target.caldwell_num}
</span>
)}
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: target.messier_num != null ? 'var(--text-mid)' : 'var(--text-hi)' }}>
{target.name}
</span>
{target.is_custom && (
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 9, fontWeight: 700,
background: 'rgba(42,184,160,0.15)', border: '1px solid var(--teal)',
color: 'var(--teal)', padding: '1px 5px', borderRadius: 3, letterSpacing: '0.06em',
}}>
CUSTOM
</span>
)}
</div>
{target.common_name && (
<div style={{ fontSize: 11, color: 'var(--text-mid)' }}>
{target.common_name}
</div>
)}
{target.urgency && (
<div style={{ marginTop: 2 }}>
{target.urgency === 'peak' && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 9, color: 'var(--good)', letterSpacing: '0.04em' }}>▲ peak</span>
)}
{target.urgency === 'rising' && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 9, color: 'var(--teal)', letterSpacing: '0.04em' }}>↗ rising</span>
)}
{target.urgency === 'declining' && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 9, color: 'var(--warn)', letterSpacing: '0.04em' }}>↘ declining</span>
)}
</div>
)}
</td>
<td style={{ padding: '7px 8px', width: 80, fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-mid)' }}>
{target.size_arcmin_maj
@@ -212,6 +241,23 @@ export default function TargetRow({ target, expanded, onToggle }: Props) {
total_min={target.total_integration_min}
/>
</td>
{onCompare && (
<td style={{ padding: '7px 8px', width: 28 }}>
<button
onClick={e => { e.stopPropagation(); onCompare(target); }}
title={inCompare ? 'Remove from compare' : 'Add to compare'}
style={{
fontFamily: 'var(--font-mono)', fontSize: 11,
color: inCompare ? 'var(--amber)' : 'var(--text-lo)',
background: inCompare ? 'var(--amber-glow)' : 'none',
border: `1px solid ${inCompare ? 'var(--amber-dim)' : 'var(--border)'}`,
borderRadius: 3, padding: '1px 4px', cursor: 'pointer', lineHeight: 1,
}}
>
⊕
</button>
</td>
)}
</tr>
);
}
frontend/src/components/targets/TypeBadge.tsx
+4
View File
@@ -9,7 +9,11 @@ const LABELS: Record<string, string> = {
dark_nebula: 'DN',
nebula: 'NB',
galaxy_group: 'GG',
galaxy_cluster: 'ACO',
interacting_galaxy: 'IG',
custom: 'USR',
satellite: 'SAT',
comet: 'CMT',
};
interface Props {
frontend/src/components/weather/DewAlert.tsx
+27
View File
@@ -1,3 +1,5 @@
import { useEffect, useRef } from 'react';
interface Props {
level?: 'warning' | 'critical';
temp?: number;
@@ -5,6 +7,31 @@ interface Props {
}
export default function DewAlert({ level, temp, dewPoint }: Props) {
const notifiedRef = useRef<string | null>(null);
// Trigger browser notification when dew alert level appears or escalates
useEffect(() => {
if (!level) return;
const key = level;
if (notifiedRef.current === key) return;
notifiedRef.current = key;
if (!('Notification' in window)) return;
const send = () => {
const margin = temp != null && dewPoint != null ? `Margin: ${(temp - dewPoint).toFixed(1)}°C. ` : '';
const body = level === 'critical'
? `${margin}Condensation imminent — protect optics immediately.`
: `${margin}Enable dew heaters now.`;
new Notification('Astronome — Dew Alert', { body, tag: 'dew-alert' });
};
if (Notification.permission === 'granted') {
send();
} else if (Notification.permission !== 'denied') {
void Notification.requestPermission().then(p => { if (p === 'granted') send(); });
}
}, [level, temp, dewPoint]);
if (!level) return null;
const margin = temp != null && dewPoint != null ? (temp - dewPoint).toFixed(1) : null;
frontend/src/hooks/useCalendar.ts
+16
View File
@@ -1,6 +1,22 @@
import { useQuery } from '@tanstack/react-query';
import { api } from '../api';
export function useBestNights() {
return useQuery({
queryKey: ['best-nights'],
queryFn: () => api.calendar.getBestNights(),
staleTime: 60 * 60_000,
});
}
export function useMonthlyHighlights() {
return useQuery({
queryKey: ['monthly-highlights'],
queryFn: () => api.calendar.getMonthlyHighlights(),
staleTime: 60 * 60_000,
});
}
export function useCalendar(months?: number) {
return useQuery({
queryKey: ['calendar', months],
frontend/src/hooks/useTargets.ts
+9
View File
@@ -62,3 +62,12 @@ export function useTargetYearly(id: string, enabled = false) {
staleTime: 60 * 60_000,
});
}
export function useTargetSimilar(id: string) {
return useQuery({
queryKey: ['target-similar', id],
queryFn: () => api.targets.similar(id),
enabled: !!id,
staleTime: 5 * 60_000,
});
}
frontend/src/pages/Dashboard.tsx
+495 -3
View File
@@ -1,17 +1,73 @@
import { useState } from 'react';
import { useState, useMemo } from 'react';
import { useTonight } from '../hooks/useTonight';
import { useWeather, useForecast } from '../hooks/useWeather';
import { useTargets } from '../hooks/useTargets';
import { useStats } from '../hooks/useStats';
import { useBestNights, useMonthlyHighlights } from '../hooks/useCalendar';
import GoNogo from '../components/weather/GoNogo';
import DewAlert from '../components/weather/DewAlert';
import MoonPhaseIcon from '../components/sky/MoonPhaseIcon';
import DetailDrawer from '../components/targets/DetailDrawer';
import type { Target } from '../api/types';
import SessionChecklist from '../components/session/SessionChecklist';
import PlanningTimeline from '../components/session/PlanningTimeline';
import type { IntegrationGap, Target } from '../api/types';
const FILTER_LABELS: Record<string, string> = {
sv220: 'HaOIII', c2: 'SII/OIII', sv260: 'LP', uvir: 'UV/IR',
sv220: 'Ha+OIII', c2: 'SII+OIII', sv260: 'LP', uvir: 'UV/IR',
};
function fmtMin(min: number): string {
if (min < 60) return `${min}m`;
return `${(min / 60).toFixed(1)}h`;
}
function GapCard({ gap }: { gap: IntegrationGap }) {
const have: { label: string; min: number }[] = [];
const missing: string[] = gap.missing_filters;
if (gap.sv220_min > 0) have.push({ label: 'Ha+OIII', min: gap.sv220_min });
if (gap.c2_min > 0) have.push({ label: 'SII+OIII', min: gap.c2_min });
if (gap.uvir_min > 0) have.push({ label: 'UV/IR', min: gap.uvir_min });
if (gap.sv260_min > 0) have.push({ label: 'LP', min: gap.sv260_min });
return (
<div style={{
display: 'flex', alignItems: 'center', gap: 12,
padding: '7px 12px', borderBottom: '1px solid var(--border)',
}}>
<div style={{ flex: 1, minWidth: 0 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--amber)' }}>
{gap.common_name ?? gap.name}
</span>
{gap.common_name && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginLeft: 6 }}>
{gap.name}
</span>
)}
</div>
<div style={{ display: 'flex', gap: 6, alignItems: 'center' }}>
{have.map(h => (
<span key={h.label} style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
color: 'var(--good)', background: 'rgba(61,186,114,0.1)',
padding: '2px 6px', borderRadius: 3,
}}>
{h.label} {fmtMin(h.min)}
</span>
))}
{missing.map(f => (
<span key={f} style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
color: 'var(--warn)', background: 'rgba(232,192,48,0.1)',
border: '1px dashed var(--warn)', padding: '2px 6px', borderRadius: 3,
}}>
{FILTER_LABELS[f] ?? f} 0h
</span>
))}
</div>
</div>
);
}
const CC_LABELS: Record<number, string> = {
1: 'Clear', 2: 'Clear', 3: 'Mostly clear', 4: 'Partly cloudy',
5: 'Partly cloudy', 6: 'Cloudy', 7: 'Mostly cloudy', 8: 'Overcast', 9: 'Overcast',
@@ -34,18 +90,332 @@ function fmtIntTotal(min: number): string {
return `${h} h`;
}
const FILTER_COLORS: Record<string, string> = {
sv220: 'var(--good)', c2: 'var(--teal)', sv260: 'var(--blue)', uvir: 'var(--amber)',
};
const TYPE_ABBR: Record<string, string> = {
galaxy: 'GX', emission_nebula: 'EN', reflection_nebula: 'RN',
planetary_nebula: 'PN', snr: 'SNR', open_cluster: 'OC',
globular_cluster: 'GC', dark_nebula: 'DN',
};
function moonBar(illum: number): string {
if (illum < 0.2) return 'var(--good)';
if (illum < 0.5) return 'var(--warn)';
return 'var(--danger)';
}
function BestNightsCard() {
const { data } = useBestNights();
const nights = data?.nights ?? [];
if (!nights.length) return null;
// Show top 14 nights in date order
const sorted = [...nights].sort((a, b) => a.date.localeCompare(b.date));
return (
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, overflow: 'hidden' }}>
<div style={{ padding: '10px 14px', borderBottom: '1px solid var(--border)', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase' }}>
14-Night Forecast
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
Best score: {Math.max(...nights.map(n => n.score))}
</span>
</div>
{sorted.map(night => {
const maxScore = Math.max(...nights.map(n => n.score));
const barWidth = maxScore > 0 ? (night.score / maxScore) * 100 : 0;
const barColor = night.score >= 70 ? 'var(--good)' : night.score >= 40 ? 'var(--warn)' : 'var(--danger)';
const dateObj = new Date(night.date + 'T12:00:00');
const dayLabel = dateObj.toLocaleDateString('en-GB', { weekday: 'short', day: 'numeric', month: 'short' });
return (
<div key={night.date} style={{ display: 'grid', gridTemplateColumns: '120px 40px 1fr 80px', gap: 8, padding: '6px 14px', borderBottom: '1px solid var(--border)', alignItems: 'center' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-mid)' }}>{dayLabel}</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, fontWeight: 600, color: barColor, textAlign: 'right' }}>{night.score}</span>
<div style={{ position: 'relative', height: 8, background: 'var(--bg-deep)', borderRadius: 2 }}>
<div style={{ position: 'absolute', left: 0, width: `${barWidth}%`, height: '100%', background: barColor, borderRadius: 2, opacity: 0.7 }} />
</div>
<div style={{ display: 'flex', gap: 4, alignItems: 'center', justifyContent: 'flex-end' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: moonBar(night.moon_illumination) }}>
☽ {Math.round(night.moon_illumination * 100)}%
</span>
</div>
</div>
);
})}
</div>
);
}
function MonthlyHighlightsCard() {
const { data } = useMonthlyHighlights();
const highlights = data?.highlights ?? [];
const month = data?.month;
if (!highlights.length) return null;
const monthLabel = month ? new Date(month + '-01').toLocaleDateString('en-GB', { month: 'long', year: 'numeric' }) : '';
return (
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, overflow: 'hidden' }}>
<div style={{ padding: '10px 14px', borderBottom: '1px solid var(--border)' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase' }}>
Best of {monthLabel}
</span>
</div>
{highlights.slice(0, 5).map(h => (
<div key={h.id} style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '8px 14px', borderBottom: '1px solid var(--border)' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', width: 32, flexShrink: 0 }}>
{TYPE_ABBR[h.obj_type] ?? h.obj_type.slice(0, 3).toUpperCase()}
</span>
<div style={{ flex: 1, minWidth: 0 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: h.keeper_count > 0 ? 'var(--text-mid)' : 'var(--amber)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
{h.common_name ?? h.name}
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
{h.name}{h.constellation ? ` · ${h.constellation}` : ''}
{h.keeper_count > 0 && <span style={{ color: 'var(--good)', marginLeft: 6 }}>✓ imaged</span>}
</div>
</div>
<div style={{ textAlign: 'right', flexShrink: 0 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--good)', fontWeight: 600 }}>
{h.peak_alt?.toFixed(0)}°
</div>
{h.recommended_filter && (
<span className={`filter-pill ${h.recommended_filter}`} style={{ fontSize: 9 }}>
{FILTER_LABELS[h.recommended_filter] ?? h.recommended_filter.toUpperCase()}
</span>
)}
</div>
</div>
))}
</div>
);
}
const GOAL_HOURS: Record<string, Record<string, number>> = {
galaxy: { uvir: 4.0, sv260: 6.0 },
emission_nebula: { sv220: 3.0, c2: 4.0, sv260: 8.0, uvir: 12.0 },
reflection_nebula: { uvir: 3.0, sv260: 5.0 },
planetary_nebula: { sv220: 2.0, c2: 3.0 },
snr: { sv220: 5.0, c2: 6.0 },
open_cluster: { uvir: 1.0 },
globular_cluster: { uvir: 1.5 },
dark_nebula: { uvir: 3.0 },
};
const FILTER_COLORS_DB: Record<string, string> = {
sv220: 'var(--good)', c2: 'var(--teal)', sv260: 'var(--blue)', uvir: 'var(--amber)',
};
function IntegrationGoalsCard({ goals }: { goals: import('../api/types').IntegrationGoal[] }) {
if (!goals?.length) return (
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', padding: '12px 0' }}>
No keeper integration recorded yet.
</div>
);
return (
<div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
{goals.map(g => {
const byType = GOAL_HOURS[g.obj_type] ?? {};
const filterKeys = Object.keys(byType);
const totalKeeperMin = g.sv220_min + g.c2_min + g.uvir_min + g.sv260_min;
const filterMinMap: Record<string, number> = { sv220: g.sv220_min, c2: g.c2_min, uvir: g.uvir_min, sv260: g.sv260_min };
return (
<div key={g.id} style={{ borderBottom: '1px solid var(--border)', paddingBottom: 10 }}>
<div style={{ display: 'flex', alignItems: 'baseline', justifyContent: 'space-between', marginBottom: 6 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--amber)' }}>
{g.common_name ?? g.name}
{g.common_name && <span style={{ fontSize: 10, color: 'var(--text-lo)', marginLeft: 6 }}>{g.name}</span>}
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
{Math.floor(totalKeeperMin / 60)}h {totalKeeperMin % 60}m total
</span>
</div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
{filterKeys.filter(fk => filterMinMap[fk] > 0 || (byType[fk] ?? 0) > 0).map(fk => {
const goalMin = (byType[fk] ?? 0) * 60;
const doneMin = filterMinMap[fk] ?? 0;
const pct = goalMin > 0 ? Math.min((doneMin / goalMin) * 100, 100) : 0;
const color = pct >= 100 ? 'var(--good)' : pct >= 60 ? 'var(--warn)' : 'var(--danger)';
const filterColor = FILTER_COLORS_DB[fk] ?? 'var(--muted)';
return (
<div key={fk} style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 9, color: filterColor, width: 50 }}>
{FILTER_LABELS[fk] ?? fk}
</span>
<div style={{ flex: 1, height: 5, background: 'var(--bg-deep)', borderRadius: 3, overflow: 'hidden' }}>
<div style={{ height: '100%', width: `${pct}%`, background: doneMin > 0 ? color : 'transparent', borderRadius: 3, transition: 'width 0.3s' }} />
</div>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 9, color: doneMin > 0 ? color : 'var(--text-lo)', width: 60, textAlign: 'right' }}>
{doneMin > 0 ? `${Math.floor(doneMin / 60)}h${doneMin % 60}m` : '—'}
{goalMin > 0 && ` / ${byType[fk]}h`}
</span>
</div>
);
})}
</div>
</div>
);
})}
</div>
);
}
/** Angular distance between two RA/Dec positions (degrees). */
function angularDist(ra1: number, dec1: number, ra2: number, dec2: number): number {
const toRad = (d: number) => d * Math.PI / 180;
const dRa = toRad(ra2 - ra1);
const dDec = toRad(dec2 - dec1);
const a = Math.sin(dDec / 2) ** 2 + Math.cos(toRad(dec1)) * Math.cos(toRad(dec2)) * Math.sin(dRa / 2) ** 2;
return 2 * Math.asin(Math.sqrt(a)) * 180 / Math.PI;
}
/** Nearest-neighbor RA/Dec sort starting from the first target (sorted by best_start). */
function slewOptimize(targets: import('../api/types').Target[]): import('../api/types').Target[] {
if (targets.length <= 2) return targets;
const remaining = [...targets];
const result: import('../api/types').Target[] = [remaining.shift()!];
while (remaining.length) {
const last = result[result.length - 1];
let nearestIdx = 0;
let nearestDist = Infinity;
remaining.forEach((t, i) => {
const d = angularDist(last.ra_deg, last.dec_deg, t.ra_deg, t.dec_deg);
if (d < nearestDist) { nearestDist = d; nearestIdx = i; }
});
result.push(remaining.splice(nearestIdx, 1)[0]);
}
return result;
}
function RunOrderCard({ items, dusk, dawn }: {
items: import('../api/types').Target[];
dusk: string;
dawn: string;
}) {
const [slewMode, setSlewMode] = useState(false);
const duskMs = new Date(dusk).getTime();
const dawnMs = new Date(dawn).getTime();
const nightMs = dawnMs - duskMs;
const withWindow = useMemo(() =>
items.filter(t => t.best_start_utc && t.best_end_utc),
[items]);
const displayItems = useMemo(() => {
if (!slewMode || withWindow.length <= 2) return withWindow;
return slewOptimize(withWindow);
}, [withWindow, slewMode]);
if (!withWindow.length) return (
<div style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 11 }}>
No targets with defined imaging windows tonight.
</div>
);
return (
<div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
{/* Slew optimizer toggle */}
<div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 4 }}>
<button
onClick={() => setSlewMode(v => !v)}
style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
color: slewMode ? 'var(--amber)' : 'var(--text-lo)',
background: slewMode ? 'var(--amber-glow)' : 'var(--bg-deep)',
border: `1px solid ${slewMode ? 'var(--amber-dim)' : 'var(--border)'}`,
borderRadius: 3, padding: '3px 10px', cursor: 'pointer',
}}
>
⟳ Slew-optimized order
</button>
{slewMode && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
Nearest-neighbor sort minimizes mount slew distance
</span>
)}
</div>
{/* Timeline header ticks */}
<div style={{ display: 'grid', gridTemplateColumns: '160px 1fr 80px', gap: 8, marginBottom: 2 }}>
<div />
<div style={{ position: 'relative', height: 14 }}>
{[0, 0.25, 0.5, 0.75, 1].map(frac => {
const t = new Date(duskMs + frac * nightMs);
return (
<span key={frac} style={{
position: 'absolute',
left: `${frac * 100}%`,
transform: 'translateX(-50%)',
fontFamily: 'var(--font-mono)',
fontSize: 9,
color: 'var(--text-lo)',
}}>
{t.toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' })}
</span>
);
})}
</div>
<div />
</div>
{displayItems.map(t => {
const startMs = new Date(t.best_start_utc!).getTime();
const endMs = new Date(t.best_end_utc!).getTime();
const left = Math.max(0, (startMs - duskMs) / nightMs) * 100;
const width = Math.min(100 - left, Math.max(2, (endMs - startMs) / nightMs * 100));
const filterColor = t.recommended_filter ? (FILTER_COLORS[t.recommended_filter] ?? 'var(--muted)') : 'var(--muted)';
return (
<div key={t.id} style={{ display: 'grid', gridTemplateColumns: '160px 1fr 80px', gap: 8, alignItems: 'center' }}>
<div style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--amber)' }}>
{t.common_name ?? t.name}
</span>
{t.common_name && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginLeft: 5 }}>
{t.name}
</span>
)}
</div>
<div style={{ position: 'relative', height: 14, background: 'var(--bg-deep)', borderRadius: 2 }}>
<div style={{
position: 'absolute',
left: `${left}%`,
width: `${width}%`,
height: '100%',
background: filterColor,
borderRadius: 2,
opacity: 0.75,
}} />
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', textAlign: 'right', whiteSpace: 'nowrap' }}>
{new Date(t.best_start_utc!).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' })}
{' → '}
{new Date(t.best_end_utc!).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: 'Europe/Paris' })}
</div>
</div>
);
})}
</div>
);
}
export default function Dashboard() {
const { data: tonight } = useTonight();
const { data: weather } = useWeather();
const { data: forecast } = useForecast();
const { data: targets } = useTargets({ tonight: true, limit: 5 });
const { data: runOrder } = useTargets({ tonight: true, sort: 'best_start', limit: 20 });
const { data: stats } = useStats();
// best nights + monthly highlights loaded inside their own components
const [expandedTarget, setExpandedTarget] = useState<Target | null>(null);
const [planningOpen, setPlanningOpen] = useState(false);
const moonPct = tonight?.moon_illumination != null
? `${Math.round(tonight.moon_illumination * 100)}%`
: '—';
// Moon separation warning: flag if any top-5 tonight target has moon_sep < 20°
const closeMoonTarget = targets?.items?.find(t => (t.moon_sep_deg ?? 180) < 20);
// Next 4 forecast slots for mini weather bar (3h each = 12h ahead)
const slots = (forecast as { dataseries?: { cloudcover?: number; seeing?: number; timepoint?: number }[] })?.dataseries?.slice(0, 8) ?? [];
@@ -62,6 +432,31 @@ export default function Dashboard() {
)}
</div>
{/* Moon separation warning */}
{closeMoonTarget && (
<div style={{
marginBottom: 12,
background: 'rgba(224,82,82,0.12)',
border: '1px solid var(--danger)',
borderRadius: 4,
padding: '8px 14px',
fontFamily: 'var(--font-mono)',
fontSize: 12,
color: 'var(--danger)',
display: 'flex',
alignItems: 'center',
gap: 10,
}}>
<span style={{ fontSize: 16 }}>☽</span>
<span>
<strong>{closeMoonTarget.common_name ?? closeMoonTarget.name}</strong>
{' '}is only{' '}
<strong>{closeMoonTarget.moon_sep_deg?.toFixed(1)}°</strong>
{' '}from the Moon — consider a narrowband filter or delaying this target.
</span>
</div>
)}
{/* Dew alert banner */}
{weather?.dew_alert && (
<div style={{ marginBottom: 16 }}>
@@ -119,6 +514,20 @@ export default function Dashboard() {
</div>
</div>
{/* Integration gap detector */}
{(stats?.integration_gaps?.length ?? 0) > 0 && (
<div style={{ marginBottom: 20 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 10 }}>
Filter Gaps — targets missing a companion filter
</div>
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, overflow: 'hidden' }}>
{stats!.integration_gaps.map(gap => (
<GapCard key={gap.catalog_id} gap={gap} />
))}
</div>
</div>
)}
{/* Tonight timing + top targets + forecast */}
<div style={{ display: 'grid', gridTemplateColumns: '200px 1fr 1fr', gap: 16, marginBottom: 20 }}>
@@ -230,6 +639,89 @@ export default function Dashboard() {
</div>
</div>
</div>
{/* Pre-session checklist */}
{tonight?.date && (
<div style={{ marginBottom: 20 }}>
<SessionChecklist duskDate={tonight.date} />
</div>
)}
{/* Monthly highlights + best nights */}
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16, marginBottom: 20 }}>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 10 }}>
Monthly Highlights
</div>
<MonthlyHighlightsCard />
</div>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 10 }}>
Best Nights (14-day)
</div>
<BestNightsCard />
</div>
</div>
{/* Integration Goals Progress */}
{stats?.integration_goals?.length ? (
<div style={{ marginBottom: 20 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 10 }}>
Integration Goals — keeper progress per target & filter
</div>
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, padding: '14px 16px' }}>
<IntegrationGoalsCard goals={stats.integration_goals} />
</div>
</div>
) : null}
{/* Tonight run order */}
{tonight?.astro_dusk_utc && (
<div style={{ marginBottom: 20 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase', marginBottom: 10 }}>
Tonight's Run Order — imaging windows sorted by start time
</div>
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, padding: '14px 16px' }}>
<RunOrderCard
items={runOrder?.items ?? []}
dusk={tonight.astro_dusk_utc}
dawn={tonight.astro_dawn_utc}
/>
</div>
</div>
)}
{/* Session Planning Timeline */}
{tonight?.astro_dusk_utc && (
<div style={{ marginBottom: 20 }}>
<div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 10 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', letterSpacing: '0.1em', textTransform: 'uppercase' }}>
Plan Tonight
</div>
<button
onClick={() => setPlanningOpen(o => !o)}
style={{
fontFamily: 'var(--font-mono)', fontSize: 10,
color: planningOpen ? 'var(--amber)' : 'var(--text-lo)',
background: planningOpen ? 'var(--amber-glow)' : 'var(--bg-deep)',
border: `1px solid ${planningOpen ? 'var(--amber-dim)' : 'var(--border)'}`,
borderRadius: 3, padding: '2px 10px', cursor: 'pointer',
}}
>
{planningOpen ? '▲ Hide' : '▼ Build Plan'}
</button>
</div>
{planningOpen && (
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, padding: '14px 16px' }}>
<PlanningTimeline
targets={runOrder?.items ?? []}
dusk={tonight.astro_dusk_utc}
dawn={tonight.astro_dawn_utc}
/>
</div>
)}
</div>
)}
</div>
);
}
frontend/src/pages/Settings.tsx
+185 -1
View File
@@ -1,8 +1,189 @@
import { useState } from 'react';
import { useState, useEffect } from 'react';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { api } from '../api';
import type { HorizonPoint } from '../api/types';
// Current hardcoded setup constants (from config.rs)
const CURRENT_SETUP = {
name: 'AT71 + ATR2600C (current)',
focal_mm: 490,
aperture_mm: 71,
pixel_um: 3.76,
res_x: 6248,
res_y: 4176,
active: true,
};
interface EquipProfile {
id: string;
name: string;
focal_mm: number;
aperture_mm: number;
pixel_um: number;
res_x: number;
res_y: number;
}
function calcProfile(p: { focal_mm: number; aperture_mm: number; pixel_um: number; res_x: number; res_y: number }) {
const plate_scale = (206.265 * p.pixel_um) / (p.focal_mm * 1000 / 1000);
// plate_scale in arcsec/px: (206265 * pixel_size_um / 1000) / focal_mm
const ps = (206.265 * p.pixel_um / 1000) / p.focal_mm * 1000;
const fov_w_deg = (ps * p.res_x) / 3600;
const fov_h_deg = (ps * p.res_y) / 3600;
const focal_ratio = p.focal_mm / p.aperture_mm;
return {
plate_scale_arcsec: ps.toFixed(3),
fov_w: `${(fov_w_deg * 60).toFixed(1)}′ × ${(fov_h_deg * 60).toFixed(1)}′`,
focal_ratio: `f/${focal_ratio.toFixed(1)}`,
};
}
function EquipmentProfiles() {
const [profiles, setProfiles] = useState<EquipProfile[]>(() => {
try {
return JSON.parse(localStorage.getItem('astronome_equip_profiles') ?? '[]');
} catch { return []; }
});
const [editing, setEditing] = useState<EquipProfile | null>(null);
const [adding, setAdding] = useState(false);
const [form, setForm] = useState({ name: '', focal_mm: 490, aperture_mm: 71, pixel_um: 3.76, res_x: 6248, res_y: 4176 });
useEffect(() => {
localStorage.setItem('astronome_equip_profiles', JSON.stringify(profiles));
}, [profiles]);
const saveProfile = () => {
if (!form.name.trim()) return;
if (editing) {
setProfiles(ps => ps.map(p => p.id === editing.id ? { ...form, id: editing.id } : p));
} else {
setProfiles(ps => [...ps, { ...form, id: Date.now().toString() }]);
}
setEditing(null);
setAdding(false);
setForm({ name: '', focal_mm: 490, aperture_mm: 71, pixel_um: 3.76, res_x: 6248, res_y: 4176 });
};
const deleteProfile = (id: string) => {
setProfiles(ps => ps.filter(p => p.id !== id));
};
const startEdit = (p: EquipProfile) => {
setEditing(p);
setForm({ name: p.name, focal_mm: p.focal_mm, aperture_mm: p.aperture_mm, pixel_um: p.pixel_um, res_x: p.res_x, res_y: p.res_y });
setAdding(false);
};
const current = calcProfile(CURRENT_SETUP);
const allProfiles = [{ ...CURRENT_SETUP, id: '__current__' }, ...profiles];
const fieldStyle: React.CSSProperties = {
background: 'var(--bg-void)', border: '1px solid var(--border)', borderRadius: 3,
color: 'var(--text-hi)', fontFamily: 'var(--font-mono)', fontSize: 12,
padding: '4px 8px', width: '100%', boxSizing: 'border-box',
};
return (
<section style={{ marginBottom: 32 }}>
<h2 style={{ fontFamily: 'var(--font-display)', fontSize: 16, marginBottom: 14, color: 'var(--text-hi)' }}>
Equipment Profiles
</h2>
<div style={{ display: 'flex', flexDirection: 'column', gap: 10, maxWidth: 640 }}>
{allProfiles.map(p => {
const calc = calcProfile(p);
const isCurrent = p.id === '__current__';
return (
<div key={p.id} style={{
background: 'var(--bg-panel)', border: `1px solid ${isCurrent ? 'var(--amber-dim)' : 'var(--border)'}`,
borderRadius: 6, padding: '12px 16px',
}}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start' }}>
<div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 13, color: isCurrent ? 'var(--amber)' : 'var(--text-hi)', fontWeight: 600 }}>
{p.name}
{isCurrent && <span style={{ marginLeft: 8, fontSize: 10, color: 'var(--amber)', background: 'var(--amber-glow)', padding: '1px 6px', borderRadius: 3 }}>ACTIVE</span>}
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', marginTop: 4 }}>
{p.focal_mm}mm {calc.focal_ratio} · {p.aperture_mm}mm aperture · {p.pixel_um}μm px · {p.res_x}×{p.res_y}
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-mid)', marginTop: 3 }}>
Plate scale: <strong style={{ color: 'var(--teal)' }}>{calc.plate_scale_arcsec}″/px</strong>
{' · '}FOV: <strong style={{ color: 'var(--teal)' }}>{calc.fov_w}</strong>
</div>
</div>
{!isCurrent && (
<div style={{ display: 'flex', gap: 8 }}>
<button onClick={() => startEdit(p as EquipProfile)} style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--blue)', background: 'none', border: '1px solid var(--border)', borderRadius: 3, padding: '3px 8px', cursor: 'pointer' }}>
Edit
</button>
<button onClick={() => deleteProfile(p.id)} style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--danger)', background: 'none', border: '1px solid var(--border)', borderRadius: 3, padding: '3px 8px', cursor: 'pointer' }}>
✕
</button>
</div>
)}
</div>
</div>
);
})}
{(adding || editing) && (
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border-hi)', borderRadius: 6, padding: '14px 16px' }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)', marginBottom: 10, textTransform: 'uppercase', letterSpacing: '0.08em' }}>
{editing ? 'Edit Profile' : 'New Profile'}
</div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: 10, marginBottom: 10 }}>
{[
{ key: 'name', label: 'Profile name', type: 'text', fullWidth: true },
{ key: 'focal_mm', label: 'Focal length (mm)', type: 'number' },
{ key: 'aperture_mm', label: 'Aperture (mm)', type: 'number' },
{ key: 'pixel_um', label: 'Pixel size (μm)', type: 'number' },
{ key: 'res_x', label: 'Sensor width (px)', type: 'number' },
{ key: 'res_y', label: 'Sensor height (px)', type: 'number' },
].map(field => (
<div key={field.key} style={{ gridColumn: field.fullWidth ? '1 / -1' : undefined }}>
<label style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', display: 'block', marginBottom: 3 }}>
{field.label}
</label>
<input
type={field.type}
step={field.key === 'pixel_um' ? '0.01' : '1'}
value={(form as Record<string, string | number>)[field.key]}
onChange={e => setForm(f => ({ ...f, [field.key]: field.type === 'number' ? parseFloat(e.target.value) || 0 : e.target.value }))}
style={fieldStyle}
/>
</div>
))}
</div>
{form.focal_mm > 0 && form.pixel_um > 0 && (
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--teal)', marginBottom: 10 }}>
Preview: {calcProfile(form).plate_scale_arcsec}″/px · {calcProfile(form).fov_w} FOV
</div>
)}
<div style={{ display: 'flex', gap: 8 }}>
<button onClick={saveProfile} style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: '#fff', background: 'var(--amber)', border: 'none', borderRadius: 3, padding: '5px 14px', cursor: 'pointer' }}>
Save
</button>
<button onClick={() => { setAdding(false); setEditing(null); }} style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--text-mid)', background: 'var(--bg-deep)', border: '1px solid var(--border)', borderRadius: 3, padding: '5px 14px', cursor: 'pointer' }}>
Cancel
</button>
</div>
</div>
)}
{!adding && !editing && (
<button
onClick={() => { setAdding(true); setEditing(null); }}
style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--amber)', background: 'var(--bg-deep)', border: '1px dashed var(--amber-dim)', borderRadius: 4, padding: '8px 16px', cursor: 'pointer', textAlign: 'left' }}
>
+ Add equipment profile
</button>
)}
</div>
</section>
);
}
function HorizonPolarChart({ points }: { points: HorizonPoint[] }) {
const size = 280;
const cx = size / 2;
@@ -165,6 +346,9 @@ export default function Settings() {
<div>
<h1 style={{ fontFamily: 'var(--font-display)', fontSize: 22, marginBottom: 24 }}>Settings</h1>
{/* Equipment Profiles */}
<EquipmentProfiles />
{/* Custom Horizon */}
<section style={{ marginBottom: 32 }}>
<h2 style={{ fontFamily: 'var(--font-display)', fontSize: 16, marginBottom: 14, color: 'var(--text-hi)' }}>
frontend/src/pages/Stats.tsx
+166 -2
View File
@@ -5,8 +5,120 @@ import {
import { useStats } from '../hooks/useStats';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { api } from '../api';
import type { Phd2Log } from '../api/types';
import { useRef, useState } from 'react';
import type { HistoryEntry, Phd2Log } from '../api/types';
import { useRef, useState, useMemo } from 'react';
const FILTER_PILL_COLORS: Record<string, string> = {
sv220: '#9b59b6', c2: '#4d9de0', sv260: '#e8832a', uvir: '#3dba72',
};
const FILTER_LABELS_HIST: Record<string, string> = {
sv220: 'Ha+OIII', c2: 'SII+OIII', sv260: 'LP', uvir: 'UV/IR',
};
const QUALITY_COLORS: Record<string, string> = {
keeper: 'var(--good)', needs_more: 'var(--blue)', rejected: 'var(--danger)', pending: 'var(--muted)',
};
function SessionTimeline({ entries }: { entries: HistoryEntry[] }) {
const grouped = useMemo(() => {
const map = new Map<string, HistoryEntry[]>();
for (const e of entries) {
const existing = map.get(e.date) ?? [];
existing.push(e);
map.set(e.date, existing);
}
return Array.from(map.entries()).sort((a, b) => b[0].localeCompare(a[0]));
}, [entries]);
if (!grouped.length) return (
<div style={{ color: 'var(--text-lo)', fontFamily: 'var(--font-mono)', fontSize: 12 }}>
No sessions logged yet.
</div>
);
return (
<div style={{ display: 'flex', flexDirection: 'column', gap: 0 }}>
{grouped.map(([date, items]) => {
const totalMin = items.reduce((s, i) => s + i.integration_min, 0);
const hasKeeper = items.some(i => i.quality === 'keeper');
const thumbEntry = items.find(i => i.gallery_url);
return (
<div key={date} style={{ display: 'flex', gap: 0, borderBottom: '1px solid var(--border)', paddingBottom: 12, marginBottom: 12 }}>
{/* Left: date stem */}
<div style={{ width: 100, flexShrink: 0, paddingRight: 16 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--amber)', fontWeight: 700 }}>
{date.slice(5)} {/* MM-DD */}
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>
{date.slice(0, 4)}
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: hasKeeper ? 'var(--good)' : 'var(--text-lo)', marginTop: 4 }}>
{totalMin >= 60 ? `${(totalMin/60).toFixed(1)}h` : `${totalMin}m`}
</div>
{/* vertical line */}
<div style={{ width: 1, background: 'var(--border)', height: '100%', marginLeft: 10, marginTop: 6 }} />
</div>
{/* Right: session entries */}
<div style={{ flex: 1, display: 'flex', flexDirection: 'column', gap: 6 }}>
{items.map((item, idx) => (
<div key={idx} style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
{/* Gallery thumbnail */}
{item.gallery_url ? (
<img src={item.gallery_url} alt={item.name} style={{ width: 40, height: 40, objectFit: 'cover', borderRadius: 2, background: '#000', flexShrink: 0 }} />
) : (
<div style={{ width: 40, height: 40, background: 'var(--bg-deep)', borderRadius: 2, flexShrink: 0, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
<span style={{ fontSize: 14, color: 'var(--text-lo)' }}>✦</span>
</div>
)}
<div style={{ flex: 1, minWidth: 0 }}>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 12, color: 'var(--text-hi)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
{item.common_name ?? item.name}
{item.common_name && (
<span style={{ color: 'var(--text-lo)', fontSize: 10, marginLeft: 5 }}>{item.name}</span>
)}
</div>
{item.notes && (
<div style={{ fontFamily: 'var(--font-sans)', fontSize: 11, color: 'var(--text-lo)', fontStyle: 'italic', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
{item.notes}
</div>
)}
</div>
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 10, padding: '2px 6px', borderRadius: 3,
background: `${FILTER_PILL_COLORS[item.filter_id] ?? 'var(--muted)'}22`,
color: FILTER_PILL_COLORS[item.filter_id] ?? 'var(--text-lo)',
border: `1px solid ${FILTER_PILL_COLORS[item.filter_id] ?? 'var(--border)'}`,
flexShrink: 0,
}}>
{FILTER_LABELS_HIST[item.filter_id] ?? item.filter_id}
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-mid)', width: 36, textAlign: 'right', flexShrink: 0 }}>
{item.integration_min >= 60
? `${(item.integration_min / 60).toFixed(1)}h`
: `${item.integration_min}m`}
</span>
<span style={{
fontFamily: 'var(--font-mono)', fontSize: 9, padding: '2px 5px', borderRadius: 3,
background: `${QUALITY_COLORS[item.quality] ?? 'var(--muted)'}22`,
color: QUALITY_COLORS[item.quality] ?? 'var(--text-lo)',
border: `1px solid ${QUALITY_COLORS[item.quality] ?? 'var(--border)'}44`,
flexShrink: 0, textTransform: 'uppercase', letterSpacing: '0.05em',
}}>
{item.quality.replace('_', ' ')}
</span>
</div>
))}
</div>
</div>
);
})}
</div>
);
}
const FILTER_COLORS: Record<string, string> = {
sv220: '#9b59b6',
@@ -366,6 +478,58 @@ export default function Stats() {
</div>
)}
{/* Catalogue completion tracker */}
{(stats.catalogue_completion?.length ?? 0) > 0 && (
<div style={{ marginTop: 24 }}>
<div style={{ fontFamily: 'var(--font-display)', fontSize: 14, fontWeight: 700, marginBottom: 14 }}>
Catalogue Completion
</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: 12 }}>
{stats.catalogue_completion.map(cat => {
const done = cat.pct >= 100;
return (
<div key={cat.name} style={{
background: 'var(--bg-panel)',
border: `1px solid ${done ? 'var(--good)' : 'var(--border)'}`,
borderRadius: 6, padding: '12px 14px',
}}>
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 8 }}>
<span style={{ fontFamily: 'var(--font-display)', fontSize: 13, fontWeight: 700 }}>
{cat.name} {done && '🏆'}
</span>
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: done ? 'var(--good)' : 'var(--text-mid)' }}>
{cat.keepers} / {cat.total}
</span>
</div>
<div style={{ height: 6, background: 'var(--bg-deep)', borderRadius: 3, overflow: 'hidden' }}>
<div style={{
width: `${Math.min(cat.pct, 100)}%`, height: '100%',
background: done ? 'var(--good)' : 'var(--amber)',
borderRadius: 3, transition: 'width 0.4s',
}} />
</div>
<div style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginTop: 4, textAlign: 'right' }}>
{cat.pct}%
</div>
</div>
);
})}
</div>
</div>
)}
{/* Observation history timeline */}
{(stats.history?.length ?? 0) > 0 && (
<div style={{ marginTop: 24 }}>
<div style={{ fontFamily: 'var(--font-display)', fontSize: 14, fontWeight: 700, marginBottom: 14 }}>
Observation History
</div>
<div style={{ background: 'var(--bg-panel)', border: '1px solid var(--border)', borderRadius: 6, padding: '16px 20px' }}>
<SessionTimeline entries={stats.history} />
</div>
</div>
)}
<PHD2Section />
</div>
);
frontend/src/pages/Targets.tsx
+175 -38
View File
@@ -1,13 +1,15 @@
import { useState, Fragment } from 'react';
import { useState, Fragment, useEffect } from 'react';
import { useParams, useNavigate } from 'react-router-dom';
import { useTargets } from '../hooks/useTargets';
import TargetRow from '../components/targets/TargetRow';
import DetailDrawer from '../components/targets/DetailDrawer';
import CompareModal from '../components/targets/CompareModal';
import type { Target } from '../api/types';
const OBJ_TYPES = ['All', 'galaxy', 'emission_nebula', 'reflection_nebula', 'planetary_nebula', 'snr', 'open_cluster', 'globular_cluster', 'dark_nebula'];
const OBJ_TYPE_LIST = ['galaxy', 'galaxy_cluster', 'emission_nebula', 'reflection_nebula', 'planetary_nebula', 'snr', 'open_cluster', 'globular_cluster', 'dark_nebula'];
const TYPE_LABELS: Record<string, string> = {
galaxy: 'Galaxy', emission_nebula: 'Emission', reflection_nebula: 'Reflection',
planetary_nebula: 'Planetary', snr: 'SNR', open_cluster: 'Cluster',
galaxy: 'Galaxy', galaxy_cluster: 'Cluster (ACO)', emission_nebula: 'Emission', reflection_nebula: 'Reflection',
planetary_nebula: 'Planetary', snr: 'SNR', open_cluster: 'Open Cl.',
globular_cluster: 'Globular', dark_nebula: 'Dark',
};
const FILTERS = [
@@ -18,21 +20,52 @@ const FILTERS = [
{ id: 'uvir', label: 'UV/IR Cut' },
];
const SORT_OPTIONS = [
{ value: '', label: 'Best alt tonight' },
{ value: '', label: 'Best score tonight' },
{ value: 'transit', label: 'Transit time' },
{ value: 'size', label: 'Size (largest)' },
{ value: 'magnitude', label: 'Magnitude' },
{ value: 'difficulty', label: 'Difficulty' },
{ value: 'integration', label: 'Total integration' },
];
const STATUS_OPTIONS = [
{ id: 'tonight', label: 'Tonight only' },
{ id: 'not_imaged', label: 'Not yet imaged' },
{ id: 'mosaic_only', label: 'Mosaics only' },
{ value: 'altitude', label: 'Altitude tonight' },
{ value: 'best_start', label: 'Run order (imaging window)' },
];
const COL_HEADERS = ['Type', 'Name', 'Size', 'Fill', 'Mosaic', 'Mag', '★', 'Filter', 'Alt', 'Vis', 'Int', 'Goal'];
const LS_KEY = 'astronome_targets_filters_v2';
interface FilterState {
typeFilters: string[];
filterPill: string;
tonight: boolean;
notImaged: boolean;
mosaicOnly: boolean;
showCustom: boolean;
accessible: boolean;
minAlt: number | null;
minUsable: number | null;
sort: string;
}
function loadFilters(): FilterState {
try {
const raw = localStorage.getItem(LS_KEY);
if (raw) return JSON.parse(raw) as FilterState;
} catch { /* ignore */ }
return {
typeFilters: [],
filterPill: '',
tonight: true,
notImaged: false,
mosaicOnly: false,
showCustom: true,
accessible: false,
minAlt: null,
minUsable: null,
sort: '',
};
}
function Chip({ active, color, onClick, children }: { active: boolean; color?: string; onClick: () => void; children: React.ReactNode }) {
const c = color ?? 'var(--amber)';
return (
@@ -56,32 +89,86 @@ function Chip({ active, color, onClick, children }: { active: boolean; color?: s
}
export default function Targets() {
const [typeFilter, setTypeFilter] = useState('');
const [filterPill, setFilterPill] = useState('');
const [tonight, setTonight] = useState(true);
const [notImaged, setNotImaged] = useState(false);
const [mosaicOnly, setMosaicOnly] = useState(false);
const [minAlt, setMinAlt] = useState<number | undefined>(undefined);
const [minUsable, setMinUsable] = useState<number | undefined>(undefined);
const [search, setSearch] = useState('');
const [sort, setSort] = useState('');
const [expandedId, setExpandedId] = useState<string | null>(null);
const [page, setPage] = useState(1);
const { targetId: urlTargetId } = useParams<{ targetId?: string }>();
const navigate = useNavigate();
const { data, isLoading } = useTargets({
type: typeFilter || undefined,
const saved = loadFilters();
const [typeFilters, setTypeFilters] = useState<string[]>(saved.typeFilters);
const [filterPill, setFilterPill] = useState(saved.filterPill);
const [tonight, setTonight] = useState(saved.tonight);
const [notImaged, setNotImaged] = useState(saved.notImaged);
const [mosaicOnly, setMosaicOnly] = useState(saved.mosaicOnly);
const [showCustom, setShowCustom] = useState(saved.showCustom);
const [accessible, setAccessible] = useState(saved.accessible ?? false);
const [minAlt, setMinAlt] = useState<number | null>(saved.minAlt);
const [minUsable, setMinUsable] = useState<number | null>(saved.minUsable);
const [search, setSearch] = useState('');
const [sort, setSort] = useState(saved.sort);
const [expandedId, setExpandedId] = useState<string | null>(urlTargetId ?? null);
const [page, setPage] = useState(1);
const [compareTargets, setCompareTargets] = useState<Target[]>([]);
const [showCompare, setShowCompare] = useState(false);
const toggleCompare = (t: Target) => {
setCompareTargets(prev => {
if (prev.find(p => p.id === t.id)) return prev.filter(p => p.id !== t.id);
if (prev.length >= 2) return [prev[1], t];
return [...prev, t];
});
};
// Persist filter state to localStorage whenever it changes
useEffect(() => {
const state: FilterState = { typeFilters, filterPill, tonight, notImaged, mosaicOnly, showCustom, accessible, minAlt, minUsable, sort };
localStorage.setItem(LS_KEY, JSON.stringify(state));
}, [typeFilters, filterPill, tonight, notImaged, mosaicOnly, showCustom, minAlt, minUsable, sort]);
const toggleType = (t: string) => {
setTypeFilters(prev =>
prev.includes(t) ? prev.filter(x => x !== t) : [...prev, t]
);
setPage(1);
};
// "Accessible tonight" applies extra server-side constraints: alt≥40°, moon_sep≥45°, usable≥60min, difficulty≤2
const effectiveMinAlt = accessible ? Math.max(minAlt ?? 0, 40) : (minAlt ?? undefined);
const effectiveMinUsable = accessible ? Math.max(minUsable ?? 0, 60) : (minUsable ?? undefined);
// When URL has a target ID, disable tonight-only filter so the target is found even if off-season
const { data: rawData, isLoading } = useTargets({
type: typeFilters.length ? typeFilters.join(',') : undefined,
filter: filterPill || undefined,
tonight,
tonight: urlTargetId ? false : tonight,
not_imaged: notImaged || undefined,
mosaic_only: mosaicOnly || undefined,
min_alt_deg: minAlt,
min_usable_min: minUsable,
search: search || undefined,
show_custom: showCustom ? undefined : false,
min_alt_deg: effectiveMinAlt || undefined,
min_usable_min: effectiveMinUsable || undefined,
search: urlTargetId ? urlTargetId : (search || undefined),
sort: sort || undefined,
page,
limit: 100,
});
// Client-side accessible filter: difficulty ≤ 2 and moon_sep ≥ 45°
const data = accessible && rawData ? {
...rawData,
items: rawData.items.filter(t =>
(t.difficulty == null || t.difficulty <= 2) &&
(t.moon_sep_deg == null || t.moon_sep_deg >= 45)
),
} : rawData;
// Sync expandedId → URL
useEffect(() => {
if (expandedId) {
navigate(`/targets/${encodeURIComponent(expandedId)}`, { replace: true });
} else if (urlTargetId) {
navigate('/targets', { replace: true });
}
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [expandedId]);
const toggleExpand = (id: string) => {
setExpandedId(prev => prev === id ? null : id);
};
@@ -100,18 +187,30 @@ export default function Targets() {
borderBottom: '1px solid var(--border)',
marginBottom: 10,
}}>
{/* Row 1: object types */}
<div style={{ display: 'flex', gap: 4, flexWrap: 'wrap', marginBottom: 6 }}>
{OBJ_TYPES.map(t => (
{/* Row 1: object types (multi-select) */}
<div style={{ display: 'flex', gap: 4, flexWrap: 'wrap', marginBottom: 6, alignItems: 'center' }}>
<Chip
active={typeFilters.length === 0}
color="var(--amber)"
onClick={() => { setTypeFilters([]); setPage(1); }}
>
All
</Chip>
{OBJ_TYPE_LIST.map(t => (
<Chip
key={t}
active={(t === 'All' && !typeFilter) || t === typeFilter}
active={typeFilters.includes(t)}
color="var(--amber)"
onClick={() => setTypeFilter(t === 'All' ? '' : t)}
onClick={() => toggleType(t)}
>
{TYPE_LABELS[t] ?? t}
</Chip>
))}
{typeFilters.length > 0 && (
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', marginLeft: 4 }}>
{typeFilters.length} type{typeFilters.length > 1 ? 's' : ''} selected
</span>
)}
</div>
{/* Row 2: filters + sort + status + search */}
@@ -124,7 +223,7 @@ export default function Targets() {
key={f.id}
active={f.id === filterPill}
color="var(--blue)"
onClick={() => setFilterPill(f.id === filterPill ? '' : f.id)}
onClick={() => { setFilterPill(f.id === filterPill ? '' : f.id); setPage(1); }}
>
{f.label}
</Chip>
@@ -143,6 +242,12 @@ export default function Targets() {
<Chip active={mosaicOnly} color="var(--warn)" onClick={() => setMosaicOnly(v => !v)}>
Mosaics only
</Chip>
<Chip active={showCustom} color="var(--teal)" onClick={() => setShowCustom(v => !v)}>
Custom
</Chip>
<Chip active={accessible} color="var(--good)" onClick={() => { setAccessible(v => !v); setPage(1); }}>
Accessible tonight
</Chip>
<div style={{ width: 1, background: 'var(--border)', height: 16, margin: '0 2px' }} />
@@ -151,7 +256,7 @@ export default function Targets() {
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>MIN ALT</span>
<select
value={minAlt ?? ''}
onChange={e => setMinAlt(e.target.value ? Number(e.target.value) : undefined)}
onChange={e => { setMinAlt(e.target.value ? Number(e.target.value) : null); setPage(1); }}
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, padding: '2px 6px', width: 70 }}
>
<option value="">Any</option>
@@ -167,7 +272,7 @@ export default function Targets() {
<span style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)' }}>MIN TIME</span>
<select
value={minUsable ?? ''}
onChange={e => setMinUsable(e.target.value ? Number(e.target.value) : undefined)}
onChange={e => { setMinUsable(e.target.value ? Number(e.target.value) : null); setPage(1); }}
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, padding: '2px 6px', width: 80 }}
>
<option value="">Any</option>
@@ -213,6 +318,29 @@ export default function Targets() {
<span style={{ marginLeft: 'auto', fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--text-lo)' }}>
{data?.total ?? 0} objects
</span>
{compareTargets.length > 0 && (
<div style={{ display: 'flex', alignItems: 'center', gap: 8, marginLeft: 16 }}>
{compareTargets.map(t => (
<span key={t.id} style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--amber)', background: 'var(--amber-glow)', border: '1px solid var(--amber-dim)', borderRadius: 3, padding: '1px 6px' }}>
{t.common_name ?? t.name}
</span>
))}
{compareTargets.length === 2 && (
<button
onClick={() => setShowCompare(true)}
style={{ fontFamily: 'var(--font-mono)', fontSize: 11, color: 'var(--bg-void)', background: 'var(--amber)', border: 'none', borderRadius: 3, padding: '3px 10px', cursor: 'pointer', fontWeight: 700 }}
>
Compare →
</button>
)}
<button
onClick={() => setCompareTargets([])}
style={{ fontFamily: 'var(--font-mono)', fontSize: 10, color: 'var(--text-lo)', background: 'none', border: '1px solid var(--border)', borderRadius: 3, padding: '1px 6px', cursor: 'pointer' }}
>
Clear
</button>
</div>
)}
</div>
</div>
@@ -227,8 +355,8 @@ export default function Targets() {
<table style={{ width: '100%', borderCollapse: 'collapse' }}>
<thead>
<tr style={{ borderBottom: '1px solid var(--border-hi)' }}>
{COL_HEADERS.map(h => (
<th key={h} style={{
{[...COL_HEADERS, ''].map((h, i) => (
<th key={i} style={{
padding: '4px 8px',
textAlign: 'left',
fontFamily: 'var(--font-mono)',
@@ -250,10 +378,12 @@ export default function Targets() {
target={target}
expanded={expandedId === target.id}
onToggle={() => toggleExpand(target.id)}
inCompare={compareTargets.some(c => c.id === target.id)}
onCompare={toggleCompare}
/>
{expandedId === target.id && (
<tr>
<td colSpan={COL_HEADERS.length} style={{ padding: 0 }}>
<td colSpan={COL_HEADERS.length + 1} style={{ padding: 0 }}>
<DetailDrawer target={target} />
</td>
</tr>
@@ -263,6 +393,13 @@ export default function Targets() {
</tbody>
</table>
)}
{showCompare && compareTargets.length === 2 && (
<CompareModal
targets={[compareTargets[0], compareTargets[1]]}
onClose={() => setShowCompare(false)}
/>
)}
</div>
);
}
frontend/src/styles/global.css
+3
View File
@@ -97,6 +97,9 @@ input:focus, select:focus, textarea:focus {
.type-badge.reflection_nebula { background: var(--type-reflection); color: #fff; }
.type-badge.dark_nebula { background: var(--type-dark); color: var(--text-mid); }
.type-badge.nebula { background: var(--teal); color: #fff; }
.type-badge.galaxy_cluster { background: #7b3f9e; color: #fff; }
.type-badge.galaxy_group { background: #4a5268; color: #fff; }
.type-badge.interacting_galaxy { background: #5c4070; color: #fff; }
/* Quality chips */
.quality-chip {