Update app.py

app.py

@@ -5,10 +5,13 @@
 # (7) Add / Reset legs
 # (8) Stats panel
 # (13) Permanent labeled waypoints
-# (14) BFO analysis
-# (15) Gentle auto-tune (BFO + BTO)
+# (14) BFO analysis chart + MAE/RMSE
+# Gentle auto-tune (BFO + BTO, BTO at satLoc index 5)
 # NEW: Esri Ocean + Satellite basemaps with layer control
+# NEW: Ping ring timestamps (Option A) shown in ring tooltip
+# FIX: robust KML loading + no empty default selection crash
 
+import os
 import re
 import html
 import xml.etree.ElementTree as ET
@@ -51,33 +54,73 @@ RING_TIMES = {
     "Ping Ring 7 (35 kft)": "24:10:00Z",
 }
 
+# Gentle tuning constants
+GENTLE_HEAD_LIMIT_DEG = 20
+GENTLE_SPEED_LIMIT_KT = 40
+HEAD_STEP_DEG = 2
+SPEED_STEP_KT = 5
+LAMBDA_STAY_CLOSE = 0.10
+LAMBDA_SMOOTH = 0.25
+
+# Normalization
+BFO_SCALE_HZ = 5.0
+BTO_SCALE_US = 50.0
+
+# satLoc indices (confirmed by you)
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
 
 # ================= KML =================
-def load_ping_rings_from_kml(path):
-    ns = {"kml": "http://www.opengis.net/kml/2.2"}
+def load_ping_rings_from_kml(path: str):
+    """
+    Returns dict: ring_name -> list[(lat, lon), ...]
+    Supports LineString rings.
+    Robust against namespace differences.
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"KML file not found: '{path}'. Make sure it exists in the Space root (same folder as app.py)."
+        )
+
     tree = ET.parse(path)
     root = tree.getroot()
 
+    # detect namespace if present
+    m = re.match(r"\{(.*)\}", root.tag)
+    ns_uri = m.group(1) if m else "http://www.opengis.net/kml/2.2"
+    ns = {"kml": ns_uri}
+
     rings = {}
+
     for pm in root.findall(".//kml:Placemark", ns):
         name_el = pm.find("kml:name", ns)
-        if not name_el or not name_el.text:
+        if name_el is None:
+            continue
+        if name_el.text is None:
             continue
         name = name_el.text.strip()
+        if not name:
+            continue
+
         if not name.lower().startswith("ping ring"):
             continue
 
         coords_el = pm.find(".//kml:LineString/kml:coordinates", ns)
-        if not coords_el or not coords_el.text:
+        if coords_el is None or coords_el.text is None:
             continue
 
         pts = []
-        for token in re.split(r"\s+", coords_el.text.strip()):
-            lon, lat, *_ = token.split(",")
-            pts.append((float(lat), float(lon)))
+        text = coords_el.text.strip()
+        for token in re.split(r"\s+", text):
+            if not token:
+                continue
+            parts = token.split(",")
+            if len(parts) < 2:
+                continue
+            lon = float(parts[0])
+            lat = float(parts[1])
+            pts.append((lat, lon))
 
         if pts:
             rings[name] = pts
@@ -85,41 +128,154 @@ def load_ping_rings_from_kml(path):
     return rings
 
 
-PING_RINGS = load_ping_rings_from_kml(KML_FILE)
+try:
+    PING_RINGS = load_ping_rings_from_kml(KML_FILE)
+except Exception as e:
+    # Keep app alive and show a readable UI error instead of crashing on import
+    PING_RINGS = {}
+    KML_LOAD_ERROR = str(e)
+else:
+    KML_LOAD_ERROR = ""
+
+
+# ================= LEGS HELPERS =================
+def df_to_rows(df):
+    if df is None:
+        return []
+    if hasattr(df, "to_numpy"):
+        return df.to_numpy().tolist()
+    return df
+
+
+def parse_legs_df(df):
+    rows = df_to_rows(df)
+    legs = []
+    for row in rows:
+        if row is None or len(row) < 3:
+            continue
+        h, s, m = row[0], row[1], row[2]
+        if h is None or s is None or m is None:
+            continue
+        if isinstance(h, float) and np.isnan(h):
+            continue
+        if isinstance(s, float) and np.isnan(s):
+            continue
+        if isinstance(m, float) and np.isnan(m):
+            continue
+        legs.append((float(h), float(s), float(m)))
+    return legs or [(300, 500, 10), (270, 500, 10), (240, 500, 10)]
+
+
+def legs_to_rows(legs):
+    return [[float(h), float(s), float(m)] for (h, s, m) in legs]
+
+
+def add_leg(df):
+    rows = df_to_rows(df)
+    cleaned = []
+    for r in rows:
+        if r is None or len(r) < 3:
+            continue
+        a, b, c = r[0], r[1], r[2]
+        if (a is None or (isinstance(a, float) and np.isnan(a))) and \
+           (b is None or (isinstance(b, float) and np.isnan(b))) and \
+           (c is None or (isinstance(c, float) and np.isnan(c))):
+            continue
+        cleaned.append([a, b, c])
+    cleaned.append(list(NEW_LEG_DEFAULT))
+    return gr.update(value=cleaned)
+
+
+def reset_legs():
+    return gr.update(value=[row[:] for row in DEFAULT_LEGS])
+
+
+# ================= SIM CORE + STATS =================
+def simulate_path(start_lat, start_lon, legs, method):
+    lat, lon = float(start_lat), float(start_lon)
+    pts = [(lat, lon)]
+    seg_dists_m = []
+    total_time_min = 0.0
+
+    for heading, speed_knots, minutes in legs:
+        dist_m = speed_knots * 1852.0 * (minutes / 60.0)
+        if method == "VINCENTY":
+            (lat, lon), _ = fp.vincenty_direct((lat, lon), heading, dist_m)
+        else:
+            lat, lon = fp.rhumb_direct((lat, lon), heading, dist_m)
+        pts.append((lat, lon))
+        seg_dists_m.append(dist_m)
+        total_time_min += float(minutes)
+
+    return pts, seg_dists_m, total_time_min
+
+
+def compute_stats(path_pts, seg_dists_m, total_time_min, legs):
+    total_dist_m = float(np.sum(seg_dists_m)) if seg_dists_m else 0.0
+    total_dist_km = total_dist_m / 1000.0
+    total_dist_nm = total_dist_m / 1852.0
+
+    total_time_hr = total_time_min / 60.0
+    avg_gs_knots = (total_dist_nm / total_time_hr) if total_time_hr > 0 else 0.0
+
+    end_lat, end_lon = path_pts[-1]
+    return "\n\n".join([
+        f"**Legs:** {len(legs)}",
+        f"**Total time:** {total_time_min:.1f} min ({total_time_hr:.2f} hr)",
+        f"**Total distance:** {total_dist_nm:.1f} nm ({total_dist_km:.1f} km)",
+        f"**Average ground speed:** {avg_gs_knots:.1f} kt",
+        f"**Final position:** lat {end_lat:.4f}, lon {end_lon:.4f}",
+    ])
+
 
+# ================= MAP HELPERS =================
+def _all_bounds(points_list):
+    lats, lons = [], []
+    for pts in points_list:
+        for (la, lo) in pts:
+            if la is None or lo is None:
+                continue
+            lats.append(float(la))
+            lons.append(float(lo))
+    if not lats:
+        return None
+    return [[min(lats), min(lons)], [max(lats), max(lons)]]
 
-# ================= MAP =================
-def add_label(m, name, lat, lon):
+
+def add_permanent_label(m, name, lat, lon):
     folium.CircleMarker(
-        (lat, lon), radius=4, color="black",
-        fill=True, fill_color="white", fill_opacity=1
+        location=(lat, lon),
+        radius=4,
+        color="black",
+        weight=2,
+        fill=True,
+        fill_color="white",
+        fill_opacity=1.0,
+        tooltip=name,
     ).add_to(m)
 
-    folium.Marker(
-        (lat, lon),
-        icon=folium.DivIcon(
-            html=f"""
-            <div style="
-                font-size:13px;
-                font-weight:700;
-                color:black;
-                text-shadow:1px 1px 2px white;
-                transform:translate(8px,-12px);
-                white-space:nowrap;
-            ">{html.escape(name)}</div>
-            """
-        )
-    ).add_to(m)
+    label_html = f"""
+    <div style="
+        font-size: 13px;
+        font-weight: 700;
+        color: black;
+        text-shadow: -1px -1px 0 #fff, 1px -1px 0 #fff, -1px 1px 0 #fff, 1px 1px 0 #fff;
+        white-space: nowrap;
+        transform: translate(8px, -12px);
+    ">{html.escape(name)}</div>
+    """
+    folium.Marker(location=(lat, lon), icon=folium.DivIcon(html=label_html)).add_to(m)
 
 
 def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     start_lat, start_lon = path_pts[0]
 
+    # IMPORTANT: tiles=None so we can add multiple basemaps
     m = folium.Map(
         location=[start_lat, start_lon],
         zoom_start=4,
+        tiles=None,
         control_scale=True,
-        tiles=None,  # IMPORTANT: no default tiles
     )
 
     # ---- BASEMAPS ----
@@ -146,96 +302,497 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
         control=True,
     ).add_to(m)
 
+    # Choose a nicer default basemap: make Ocean "active" by adding it last? (Folium picks first visible)
+    # In practice, Leaflet will show the first base layer; users can switch via LayerControl.
+
     # ---- PING RINGS ----
-    for ring in selected_rings or []:
-        pts = PING_RINGS.get(ring)
-        if not pts:
+    for ring_name in selected_rings or []:
+        ring_pts = PING_RINGS.get(ring_name)
+        if not ring_pts:
             continue
-        label = f"{ring} ({RING_TIMES.get(ring,'')})"
+        ring_time = RING_TIMES.get(ring_name)
+        tooltip = f"{ring_name} ({ring_time})" if ring_time else ring_name
+
         folium.PolyLine(
-            pts, color="blue", weight=2, opacity=0.6, tooltip=label
+            ring_pts,
+            weight=2,
+            opacity=0.6,
+            color="blue",
+            tooltip=tooltip,
         ).add_to(m)
 
     # ---- FLIGHT PATH (glow + main) ----
     folium.PolyLine(path_pts, color="white", weight=8, opacity=0.3).add_to(m)
-    folium.PolyLine(path_pts, color="red", weight=4, opacity=1.0).add_to(m)
+    folium.PolyLine(path_pts, color="red", weight=4, opacity=1.0, tooltip="Flight path").add_to(m)
 
-    # ---- WAYPOINTS ----
-    for name, lat, lon in WAYPOINTS:
-        add_label(m, name, lat, lon)
+    # ---- START/END ----
+    folium.CircleMarker(
+        location=path_pts[0],
+        radius=6,
+        fill=True,
+        color="green",
+        fill_opacity=1.0,
+        popup=folium.Popup(
+            f"<b>Start</b><br>Lat: {path_pts[0][0]:.5f}<br>Lon: {path_pts[0][1]:.5f}",
+            max_width=300,
+        ),
+    ).add_to(m)
 
-    # ---- START / END ----
-    folium.CircleMarker(path_pts[0], radius=6, color="green", fill=True).add_to(m)
-    folium.CircleMarker(path_pts[-1], radius=6, color="purple", fill=True).add_to(m)
+    folium.CircleMarker(
+        location=path_pts[-1],
+        radius=6,
+        fill=True,
+        color="purple",
+        fill_opacity=1.0,
+        popup=folium.Popup(
+            f"<b>End</b><br>Lat: {path_pts[-1][0]:.5f}<br>Lon: {path_pts[-1][1]:.5f}",
+            max_width=300,
+        ),
+    ).add_to(m)
+
+    # ---- SIMULATED WAYPOINTS (white dots with popups) ----
+    total_dist_km = 0.0
+    elapsed_min = 0.0
+    for i, (lat, lon) in enumerate(path_pts):
+        if i == 0:
+            heading = None
+            speed = None
+            minutes = 0.0
+        else:
+            heading, speed, minutes = legs[i - 1]
+            total_dist_km += (seg_dists_m[i - 1] / 1000.0)
+            elapsed_min += minutes
+
+        popup_lines = [
+            f"<b>Waypoint {i}</b>",
+            f"Lat: {lat:.5f}",
+            f"Lon: {lon:.5f}",
+            f"Time elapsed: {elapsed_min:.1f} min",
+        ]
+        if i > 0:
+            popup_lines += [
+                f"Heading: {heading:.1f}°",
+                f"Speed: {speed:.0f} kt",
+                f"Leg: {minutes:.1f} min",
+                f"Distance flown: {total_dist_km:.2f} km",
+            ]
+
+        folium.CircleMarker(
+            location=(lat, lon),
+            radius=5,
+            fill=True,
+            color="white",
+            fill_color="white",
+            fill_opacity=1.0,
+            popup=folium.Popup("<br>".join(popup_lines), max_width=340),
+        ).add_to(m)
+
+    # ---- PERMANENT WAYPOINT LABELS ----
+    for name, lat, lon in WAYPOINTS:
+        add_permanent_label(m, name, float(lat), float(lon))
 
     # ---- LAYER CONTROL ----
     folium.LayerControl(collapsed=False).add_to(m)
 
     # ---- FIT BOUNDS ----
-    all_pts = path_pts[:]
-    for r in selected_rings or []:
-        all_pts += PING_RINGS.get(r, [])
-    if all_pts:
-        lats = [p[0] for p in all_pts]
-        lons = [p[1] for p in all_pts]
-        m.fit_bounds([[min(lats), min(lons)], [max(lats), max(lons)]])
-
-    html_map = html.escape(m.get_root().render(), quote=True)
+    waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS]
+    bounds = _all_bounds(
+        [path_pts]
+        + [PING_RINGS[r] for r in (selected_rings or []) if r in PING_RINGS]
+        + [waypoint_pts]
+    )
+    if bounds:
+        m.fit_bounds(bounds, padding=(20, 20))
+
+    map_html = m.get_root().render()
+    escaped = html.escape(map_html, quote=True)
     return f"""
-    <iframe srcdoc="{html_map}"
-            style="width:100%;height:650px;border:0;border-radius:12px;">
-    </iframe>
+    <iframe
+        srcdoc="{escaped}"
+        style="width: 100%; height: 650px; border: 0; border-radius: 12px;"
+        loading="lazy"
+        referrerpolicy="no-referrer"
+    ></iframe>
     """
 
 
-# ================= SIM CORE =================
-def simulate_path(start_lat, start_lon, legs, method):
-    lat, lon = start_lat, start_lon
-    pts = [(lat, lon)]
-    dists = []
+# ================= BFO ANALYSIS =================
+def _parse_start_time(s: str) -> datetime:
+    s = (s or "").strip()
+    if not s:
+        return datetime(2014, 3, 7, 18, 22, 0, tzinfo=timezone.utc)
+
+    if re.fullmatch(r"\d{2}:\d{2}:\d{2}", s):
+        hh, mm, ss = map(int, s.split(":"))
+        return datetime(2014, 3, 7, hh, mm, ss, tzinfo=timezone.utc)
+
+    s = s.replace("T", " ").replace("Z", "")
+    dt = datetime.fromisoformat(s)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+def _ping_points_after(start_dt: datetime):
+    pts = []
+    for row in fp.satLoc:
+        label = fp._extract_time_string(row[0])
+
+        meas_bfo = row[SATLOC_IDX_MEAS_BFO]
+        meas_bto = row[SATLOC_IDX_MEAS_BTO]
+
+        if meas_bfo is None:
+            continue
+
+        try:
+            dt_ping = fp._time_label_to_dt(label, fp.SAT_EPOCH_UTC)
+        except Exception:
+            continue
+
+        if dt_ping < start_dt:
+            continue
+
+        pts.append((label, dt_ping, float(meas_bfo), None if meas_bto is None else float(meas_bto)))
+    return pts
 
-    for hdg, spd, minutes in legs:
-        dist_m = spd * 1852 * (minutes / 60)
+
+def _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg_deg, spd_knots, t_inside_leg_sec):
+    dist_m = float(spd_knots) * 1852.0 * (float(t_inside_leg_sec) / 3600.0)
+    if method == "VINCENTY":
+        (lat, lon), _ = fp.vincenty_direct((leg_start_lat, leg_start_lon), float(hdg_deg), dist_m)
+    else:
+        lat, lon = fp.rhumb_direct((leg_start_lat, leg_start_lon), float(hdg_deg), dist_m)
+    return float(lat), float(lon)
+
+
+def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm):
+    start_dt = _parse_start_time(start_time_str)
+    pts = _ping_points_after(start_dt)
+
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = boundaries[-1]
+
+    # leg start positions
+    cur_lat = float(start_lat)
+    cur_lon = float(start_lon)
+    leg_start_positions = [(cur_lat, cur_lon)]
+    for (hdg, spd, minutes) in legs[:-1]:
+        dist_m = float(spd) * 1852.0 * (float(minutes) / 60.0)
         if method == "VINCENTY":
-            (lat, lon), _ = fp.vincenty_direct((lat, lon), hdg, dist_m)
+            (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(hdg), dist_m)
         else:
-            lat, lon = fp.rhumb_direct((lat, lon), hdg, dist_m)
-        pts.append((lat, lon))
-        dists.append(dist_m)
+            cur_lat, cur_lon = fp.rhumb_direct((cur_lat, cur_lon), float(hdg), dist_m)
+        leg_start_positions.append((cur_lat, cur_lon))
+
+    x_labels, measured, calculated = [], [], []
+    for label, dt_ping, meas_bfo, _meas_bto in pts:
+        t_sec = (dt_ping - start_dt).total_seconds()
+        if t_sec < 0 or t_sec > total_end:
+            continue
+        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
+        i = max(0, min(i, len(legs) - 1))
+        t_inside = t_sec - boundaries[i]
+
+        leg_start_lat, leg_start_lon = leg_start_positions[i]
+        hdg, spd, _ = legs[i]
+
+        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
+
+        alt_m = float(alt_ft) * 0.3048
+        vs_mps = float(vs_fpm) * 0.00508
+        spd_mps = float(spd) * 1852.0 / 3600.0
+        pred_bfo = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
+
+        x_labels.append(label)
+        measured.append(float(meas_bfo))
+        calculated.append(float(pred_bfo))
+
+    if not x_labels:
+        fig = go.Figure()
+        fig.update_layout(title="BFO Analysis", xaxis_title="Time", yaxis_title="Hz", height=520)
+        return fig, "**BFO scoring:** no valid ping points inside your simulated time."
+
+    m_arr = np.array(measured, dtype=float)
+    c_arr = np.array(calculated, dtype=float)
+    err = c_arr - m_arr
+    mae = float(np.mean(np.abs(err)))
+    rmse = float(np.sqrt(np.mean(err * err)))
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x_labels, y=measured, mode="markers", name="Measured BFO",
+                             marker=dict(size=11, symbol="circle")))
+    fig.add_trace(go.Scatter(x=x_labels, y=calculated, mode="lines+markers", name="Calculated BFO",
+                             line=dict(width=3), marker=dict(size=10, symbol="diamond")))
+    fig.update_layout(
+        title="BFO Analysis",
+        xaxis_title="Time",
+        yaxis_title="Hz",
+        legend=dict(x=1.02, y=1.0),
+        margin=dict(l=60, r=160, t=80, b=60),
+        height=520,
+    )
+
+    score_md = (
+        f"**BFO scoring (Hz)**\n\n"
+        f"- Points: **{len(m_arr)}**\n"
+        f"- MAE: **{mae:.2f} Hz**\n"
+        f"- RMSE: **{rmse:.2f} Hz**"
+    )
+    return fig, score_md
+
+
+# ================= AUTOTUNE (BFO + BTO) =================
+def _wrap_heading(deg):
+    return float(deg) % 360.0
+
+
+def _heading_diff(a, b):
+    return (float(a) - float(b) + 180.0) % 360.0 - 180.0
+
+
+def gentle_autotune_all_legs(start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm):
+    start_dt = _parse_start_time(start_time_str)
+    pts = _ping_points_after(start_dt)
+    if not pts:
+        return legs, "Auto-tune: no BFO points after start time."
+
+    n = len(legs)
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = boundaries[-1]
+
+    pts2 = []
+    for label, dt_ping, meas_bfo, meas_bto in pts:
+        t_sec = (dt_ping - start_dt).total_seconds()
+        if 0 <= t_sec <= total_end:
+            pts2.append((label, dt_ping, meas_bfo, meas_bto, float(t_sec)))
+
+    if len(pts2) < 2:
+        return legs, "Auto-tune: not enough pings inside your simulated time."
+
+    tuned = list(legs)
+    cur_lat = float(start_lat)
+    cur_lon = float(start_lon)
+
+    prev_h, prev_s, _ = tuned[0]
+    report = ["**Gentle auto-tune (BFO + BTO, bounded + smooth):**"]
+    tuned_count = 0
+
+    for i in range(n):
+        leg_start = boundaries[i]
+        leg_end = boundaries[i + 1]
+        minutes_i = float(tuned[i][2])
+
+        leg_pings = [(dt, bfo, bto, (t - leg_start)) for (_, dt, bfo, bto, t) in pts2 if leg_start <= t <= leg_end]
+        orig_h, orig_s, _ = legs[i]
+
+        if len(leg_pings) < 2:
+            report.append(f"- Leg {i+1}: skipped (not enough pings in window)")
+            h0, s0, _ = tuned[i]
+            dist_m = float(s0) * 1852.0 * (minutes_i / 60.0)
+            if method == "VINCENTY":
+                (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(h0), dist_m)
+            else:
+                cur_lat, cur_lon = fp.rhumb_direct((cur_lat, cur_lon), float(h0), dist_m)
+            prev_h, prev_s = h0, s0
+            continue
+
+        leg_start_lat, leg_start_lon = cur_lat, cur_lon
+
+        h_center = _wrap_heading(orig_h)
+        s_center = float(orig_s)
+
+        h_low = h_center - GENTLE_HEAD_LIMIT_DEG
+        h_high = h_center + GENTLE_HEAD_LIMIT_DEG
+
+        h_candidates = []
+        h = h_low
+        while h <= h_high + 1e-9:
+            h_candidates.append(_wrap_heading(h))
+            h += HEAD_STEP_DEG
+        h_candidates = sorted(set(round(x, 6) for x in h_candidates))
+
+        s_low = max(150.0, s_center - GENTLE_SPEED_LIMIT_KT)
+        s_high = min(650.0, s_center + GENTLE_SPEED_LIMIT_KT)
+        s_candidates = np.arange(s_low, s_high + 0.0001, SPEED_STEP_KT).tolist()
+
+        def objective(hdg, spd):
+            bfo_preds, bfo_meas = [], []
+            bto_preds, bto_meas = [], []
+
+            alt_m = float(alt_ft) * 0.3048
+            vs_mps = float(vs_fpm) * 0.00508
+            spd_mps = float(spd) * 1852.0 / 3600.0
+
+            for dt_ping, meas_bfo, meas_bto, t_inside in leg_pings:
+                lat, lon = _predict_state_from_leg_start(
+                    method, leg_start_lat, leg_start_lon, hdg, spd, t_inside
+                )
+
+                pred_bfo = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
+                bfo_preds.append(pred_bfo)
+                bfo_meas.append(float(meas_bfo))
+
+                if meas_bto is not None:
+                    pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
+                    bto_preds.append(pred_bto)
+                    bto_meas.append(float(meas_bto))
+
+            e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
+            rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
 
-    return pts, dists
+            rmse_bto = 0.0
+            if len(bto_preds) >= 2:
+                e_bto = np.array(bto_preds) - np.array(bto_meas)
+                rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
+
+            fit_score = (rmse_bfo / BFO_SCALE_HZ) + (rmse_bto / BTO_SCALE_US)
+
+            stay_close = (abs(_heading_diff(hdg, orig_h)) / GENTLE_HEAD_LIMIT_DEG) ** 2 + ((float(spd) - float(orig_s)) / GENTLE_SPEED_LIMIT_KT) ** 2
+            smooth = (abs(_heading_diff(hdg, prev_h)) / 45.0) ** 2 + ((float(spd) - float(prev_s)) / 80.0) ** 2
+
+            loss = fit_score + LAMBDA_STAY_CLOSE * stay_close + LAMBDA_SMOOTH * smooth
+            return loss, rmse_bfo, rmse_bto
+
+        best_h, best_s = None, None
+        best_loss = float("inf")
+        best_rbfo = float("inf")
+        best_rbto = float("inf")
+
+        for hdg in h_candidates:
+            for spd in s_candidates:
+                loss, rbfo, rbto = objective(hdg, spd)
+                if loss < best_loss:
+                    best_loss = loss
+                    best_h, best_s = float(hdg), float(spd)
+                    best_rbfo, best_rbto = rbfo, rbto
+
+        tuned[i] = (float(best_h), float(best_s), minutes_i)
+        tuned_count += 1
+
+        if best_rbto > 0:
+            report.append(
+                f"- Leg {i+1}: {orig_h:.0f}°→**{best_h:.0f}°**, {orig_s:.0f}→**{best_s:.0f} kt** | "
+                f"RMSE_BFO **{best_rbfo:.2f} Hz** | RMSE_BTO **{best_rbto:.1f} µs**"
+            )
+        else:
+            report.append(
+                f"- Leg {i+1}: {orig_h:.0f}°→**{best_h:.0f}°**, {orig_s:.0f}→**{best_s:.0f} kt** | "
+                f"RMSE_BFO **{best_rbfo:.2f} Hz** | RMSE_BTO (n/a)"
+            )
+
+        dist_m = float(best_s) * 1852.0 * (minutes_i / 60.0)
+        if method == "VINCENTY":
+            (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(best_h), dist_m)
+        else:
+            cur_lat, cur_lon = fp.rhumb_direct((cur_lat, cur_lon), float(best_h), dist_m)
+
+        prev_h, prev_s = best_h, best_s
+
+    report.append(f"\nTuned legs: **{tuned_count}/{n}** (skipped legs had <2 pings in that time window)")
+    return tuned, "\n".join(report)
+
+
+# ================= RUNNERS =================
+def _run_common(start_lat, start_lon, legs, method, rings, start_time_str, alt_ft, vs_fpm):
+    path_pts, seg_dists_m, total_time_min = simulate_path(start_lat, start_lon, legs, method)
+    html_map = build_leaflet_map(path_pts, legs, seg_dists_m, rings)
+    stats_md = compute_stats(path_pts, seg_dists_m, total_time_min, legs)
+    bfo_fig, bfo_md = bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm)
+    return html_map, stats_md, bfo_fig, bfo_md
+
+
+def run_sim_manual(start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm):
+    legs = parse_legs_df(legs_df)
+    html_map, stats_md, bfo_fig, bfo_md = _run_common(
+        start_lat, start_lon, legs, method, rings, start_time_str, alt_ft, vs_fpm
+    )
+    return gr.update(), "", html_map, stats_md, bfo_fig, bfo_md
+
+
+def run_sim_autotune(start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm):
+    legs = parse_legs_df(legs_df)
+    tuned_legs, tune_md = gentle_autotune_all_legs(
+        start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm
+    )
+    html_map, stats_md, bfo_fig, bfo_md = _run_common(
+        start_lat, start_lon, tuned_legs, method, rings, start_time_str, alt_ft, vs_fpm
+    )
+    return gr.update(value=legs_to_rows(tuned_legs)), tune_md, html_map, stats_md, bfo_fig, bfo_md
 
 
 # ================= UI =================
+# Safe default selected ring(s)
+RING_CHOICES = sorted(PING_RINGS.keys())
+DEFAULT_SELECTED_RINGS = [RING_CHOICES[0]] if len(RING_CHOICES) > 0 else []
+
 with gr.Blocks() as demo:
-    gr.Markdown("## ✈️ MH370 Flight Simulator — Oceanic Basemap")
+    gr.Markdown("## ✈️ MH370 Flight Simulator — Leaflet + Esri Ocean/Satellite")
+
+    if KML_LOAD_ERROR:
+        gr.Markdown(
+            "### ⚠️ KML not loaded\n"
+            f"**Error:** {KML_LOAD_ERROR}\n\n"
+            "Make sure your KML file is uploaded into the Space and the filename in `KML_FILE` matches exactly."
+        )
 
     with gr.Row():
         start_lat = gr.Slider(-10, 10, value=6.3, label="Start Latitude")
         start_lon = gr.Slider(90, 110, value=96.3, label="Start Longitude")
-        method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY")
+        method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY", label="Method")
 
     legs_df = gr.Dataframe(
         headers=["heading_deg", "speed_knots", "minutes"],
-        value=DEFAULT_LEGS,
+        datatype=["number", "number", "number"],
         row_count=(10, "dynamic"),
         column_count=(3, "fixed"),
+        value=[row[:] for row in DEFAULT_LEGS],
+        label="Multi-leg plan",
     )
 
+    with gr.Row():
+        add_btn = gr.Button("➕ Add leg")
+        reset_btn = gr.Button("♻️ Reset legs")
+
     rings = gr.CheckboxGroup(
-        choices=sorted(PING_RINGS.keys()),
-        value=[sorted(PING_RINGS.keys())[0]],
-        label="Ping rings",
+        choices=RING_CHOICES,
+        value=DEFAULT_SELECTED_RINGS,
+        label="Ping rings (from your KML)",
     )
 
-    btn = gr.Button("Simulate on Map")
-    out = gr.HTML()
+    gr.Markdown("### #14 BFO/BTO Settings")
+    with gr.Row():
+        start_time_str = gr.Textbox(value="2014-03-07 18:22:00Z", label="Simulation start time (UTC)")
+        alt_ft = gr.Number(value=35000, label="Altitude (ft)")
+        vs_fpm = gr.Number(value=0, label="Vertical speed (ft/min)")
+
+    with gr.Row():
+        manual_btn = gr.Button("Simulate on Map + BFO (Manual)")
+        tune_btn = gr.Button("Simulate on Map + BFO/BTO (Gentle auto-tune)")
+
+    tune_status = gr.Markdown()
+
+    out_map = gr.HTML()
+    stats = gr.Markdown()
 
-    def run(lat, lon, df, method, rings):
-        legs = [(float(r[0]), float(r[1]), float(r[2])) for r in df]
-        pts, dists = simulate_path(lat, lon, legs, method)
-        return build_leaflet_map(pts, legs, dists, rings)
+    gr.Markdown("### BFO Analysis")
+    bfo_plot = gr.Plot()
+    bfo_score = gr.Markdown()
+
+    manual_btn.click(
+        run_sim_manual,
+        inputs=[start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm],
+        outputs=[legs_df, tune_status, out_map, stats, bfo_plot, bfo_score],
+    )
+
+    tune_btn.click(
+        run_sim_autotune,
+        inputs=[start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm],
+        outputs=[legs_df, tune_status, out_map, stats, bfo_plot, bfo_score],
+    )
 
-    btn.click(run, [start_lat, start_lon, legs_df, method, rings], out)
+    add_btn.click(add_leg, inputs=[legs_df], outputs=[legs_df])
+    reset_btn.click(reset_legs, outputs=[legs_df])
 
 demo.launch()