Update app.py

app.py

@@ -1,14 +1,13 @@
 # app.py
 # MH370 Flight Simulator — Leaflet map (Folium) + Ping Rings (KML)
-# Includes:
-# (6) multi-leg editor (Dataframe)
-# (7) Add Leg + Reset buttons
+# Features:
+# (6) Multi-leg editor
+# (7) Add / Reset legs
 # (8) Stats panel
 # (13) Permanent labeled waypoints
-# (14) BFO analysis chart + MAE/RMSE
-# NEW: Gentle auto-tune can fit BOTH BFO + BTO (BTO at satLoc index 5)
-# NEW: Two simulate buttons: Manual vs Gentle Auto-tune
-# NEW: Ping ring timestamps (Option A) shown in ring tooltip
+# (14) BFO analysis
+# (15) Gentle auto-tune (BFO + BTO)
+# NEW: Esri Ocean + Satellite basemaps with layer control
 
 import re
 import html
@@ -22,6 +21,8 @@ import plotly.graph_objects as go
 
 import flight_plotter_v32 as fp
 
+
+# ================= CONFIG =================
 KML_FILE = "MH370 - 13 nov (3).kml"
 
 DEFAULT_LEGS = [
@@ -31,39 +32,31 @@ DEFAULT_LEGS = [
 ]
 NEW_LEG_DEFAULT = [0, 500, 10]
 
-# ---------------- #13 Waypoints (PERMANENT LABELS) ----------------
 WAYPOINTS = [
-    ("IGARI", 6.936111111111112, 103.58500000000001),
-    ("VAMPI", 6.182222222222222, 97.58555555555554),
-    ("NILAM", 6.756388888888889, 95.97638888888889),
-    ("SANOB", 6.586111111111111, 95.66916666666667),
-    ("VPG",   5.279638888888889, 100.26038888888888),
-    ("MEKAR", 6.500000000000000, 96.48333333333333),
+    ("IGARI", 6.93611111, 103.585),
+    ("VAMPI", 6.18222222, 97.58555556),
+    ("NILAM", 6.75638889, 95.97638889),
+    ("SANOB", 6.58611111, 95.66916667),
+    ("VPG",   5.27963889, 100.26038889),
+    ("MEKAR", 6.5, 96.48333333),
 ]
 
-# -------- Gentle tuning constants --------
-GENTLE_HEAD_LIMIT_DEG = 20   # ±20°
-GENTLE_SPEED_LIMIT_KT = 40   # ±40 kt
-HEAD_STEP_DEG = 2            # grid step
-SPEED_STEP_KT = 5            # grid step
-LAMBDA_STAY_CLOSE = 0.10     # penalty vs your original input
-LAMBDA_SMOOTH = 0.25         # penalty vs previous tuned leg
-
-# Normalization scales so Hz and microseconds are comparable
-BFO_SCALE_HZ = 5.0
-BTO_SCALE_US = 50.0
+RING_TIMES = {
+    "Ping Ring 1": "18:25:00Z",
+    "Ping Ring 2": "18:40:00Z",
+    "Ping Ring 3": "19:40:00Z",
+    "Ping Ring 4": "20:40:00Z",
+    "Ping Ring 5": "21:40:00Z",
+    "Ping Ring 6": "22:40:00Z",
+    "Ping Ring 7 (35 kft)": "24:10:00Z",
+}
 
-# satLoc indices (confirmed by you)
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
 
-# ---------------- KML parsing ----------------
-def load_ping_rings_from_kml(path=KML_FILE):
-    """
-    Returns dict: ring_name -> list[(lat, lon), ...]
-    Supports LineString rings.
-    """
+# ================= KML =================
+def load_ping_rings_from_kml(path):
     ns = {"kml": "http://www.opengis.net/kml/2.2"}
     tree = ET.parse(path)
     root = tree.getroot()
@@ -71,730 +64,178 @@ def load_ping_rings_from_kml(path=KML_FILE):
     rings = {}
     for pm in root.findall(".//kml:Placemark", ns):
         name_el = pm.find("kml:name", ns)
-        if name_el is None or not name_el.text:
+        if not name_el or not name_el.text:
             continue
         name = name_el.text.strip()
-
         if not name.lower().startswith("ping ring"):
             continue
 
         coords_el = pm.find(".//kml:LineString/kml:coordinates", ns)
-        if coords_el is None or not coords_el.text:
+        if not coords_el or not coords_el.text:
             continue
 
         pts = []
-        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))
+        for token in re.split(r"\s+", coords_el.text.strip()):
+            lon, lat, *_ = token.split(",")
+            pts.append((float(lat), float(lon)))
 
         if pts:
             rings[name] = pts
 
-    if not rings:
-        raise RuntimeError(
-            f"No ping rings found in KML. Check file name/path: {path} and Placemark names."
-        )
     return rings
 
 
-PING_RINGS = load_ping_rings_from_kml()
-
-# ---------------- Ping ring timestamps (Option A) ----------------
-# These keys must match your KML Placemark names exactly.
-RING_TIMES = {
-    "Ping Ring 1": "18:25:00Z",
-    "Ping Ring 2": "18:40:00Z",
-    "Ping Ring 3": "19:40:00Z",
-    "Ping Ring 4": "20:40:00Z",
-    "Ping Ring 5": "21:40:00Z",
-    "Ping Ring 6": "22:40:00Z",
-    "Ping Ring 7 (35 kft)": "24:10:00Z",
-}
-
-
-# ---------------- legs helpers ----------------
-def df_to_rows(df):
-    if df is None:
-        return []
-    if hasattr(df, "to_numpy"):  # pandas.DataFrame
-        return df.to_numpy().tolist()
-    return df  # list-of-lists
-
-
-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)))
-
-    if not legs:
-        legs = [(300, 500, 10), (270, 500, 10), (240, 500, 10)]
-    return legs
-
+PING_RINGS = load_ping_rings_from_kml(KML_FILE)
 
-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):
-    """
-    Returns:
-      pts: [(lat,lon), ...] including start and end of each leg
-      seg_dists_m: [distance_m for each leg]
-      total_time_min: float
-    """
-    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]
-
-    lines = [
-        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}",
-    ]
-    return "\n\n".join(lines)
-
-
-# ---------------- Leaflet map (Folium) ----------------
-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)]]
-
-
-def add_permanent_label(m, name, lat, lon):
-    """
-    Adds a small dot + a permanent text label using DivIcon.
-    """
+# ================= MAP =================
+def add_label(m, name, lat, lon):
     folium.CircleMarker(
-        location=(lat, lon),
-        radius=4,
-        color="black",
-        weight=2,
-        fill=True,
-        fill_color="white",
-        fill_opacity=1.0,
-        tooltip=name,
+        (lat, lon), radius=4, color="black",
+        fill=True, fill_color="white", fill_opacity=1
     ).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),
+        (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)
 
 
 def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     start_lat, start_lon = path_pts[0]
+
     m = folium.Map(
         location=[start_lat, start_lon],
         zoom_start=4,
-        tiles="OpenStreetMap",
         control_scale=True,
+        tiles=None,  # IMPORTANT: no default tiles
     )
 
-    # Ping rings (blue) + timestamp tooltip
-    for ring_name in selected_rings or []:
-        ring_pts = PING_RINGS.get(ring_name)
-        if not ring_pts:
-            continue
-
-        ring_time = RING_TIMES.get(ring_name)
-        tooltip = f"{ring_name} ({ring_time})" if ring_time else ring_name
-
-        folium.PolyLine(
-            ring_pts,
-            weight=3,
-            opacity=0.95,
-            color="blue",
-            tooltip=tooltip,
-        ).add_to(m)
-
-    # Flight path (red)
-    folium.PolyLine(
-        path_pts,
-        weight=4,
-        opacity=1.0,
-        color="red",
-        tooltip="Flight path",
+    # ---- BASEMAPS ----
+    folium.TileLayer(
+        "OpenStreetMap",
+        name="OpenStreetMap",
+        overlay=False,
+        control=True,
     ).add_to(m)
 
-    # Start/End markers
-    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,
-        ),
+    folium.TileLayer(
+        tiles="https://server.arcgisonline.com/ArcGIS/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",
+        attr="Esri",
+        name="Esri Ocean",
+        overlay=False,
+        control=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,
-        ),
+    folium.TileLayer(
+        tiles="https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
+        attr="Esri",
+        name="Esri Satellite",
+        overlay=False,
+        control=True,
     ).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),
+    # ---- PING RINGS ----
+    for ring in selected_rings or []:
+        pts = PING_RINGS.get(ring)
+        if not pts:
+            continue
+        label = f"{ring} ({RING_TIMES.get(ring,'')})"
+        folium.PolyLine(
+            pts, color="blue", weight=2, opacity=0.6, tooltip=label
         ).add_to(m)
 
-    # Permanent labeled real-world waypoints (#13)
-    for name, lat, lon in WAYPOINTS:
-        add_permanent_label(m, name, float(lat), float(lon))
-
-    # Fit bounds to include everything
-    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))
-
-    # Embed as iframe with fixed height (Gradio-safe)
-    map_html = m.get_root().render()
-    escaped = html.escape(map_html, quote=True)
-
-    return f"""
-    <iframe
-        srcdoc="{escaped}"
-        style="width: 100%; height: 650px; border: 0; border-radius: 12px;"
-        loading="lazy"
-        referrerpolicy="no-referrer"
-    ></iframe>
-    """
+    # ---- 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)
 
+    # ---- WAYPOINTS ----
+    for name, lat, lon in WAYPOINTS:
+        add_label(m, name, lat, lon)
 
-# ---------------- BFO/BTO analysis helpers ----------------
-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)
+    # ---- 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)
 
-    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)
+    # ---- 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)]])
 
-def _ping_points_after(start_dt: datetime):
-    """
-    Returns list of tuples:
-      (label, dt_ping, meas_bfo, meas_bto)
-    where meas_bto may be None.
+    html_map = html.escape(m.get_root().render(), quote=True)
+    return f"""
+    <iframe srcdoc="{html_map}"
+            style="width:100%;height:650px;border:0;border-radius:12px;">
+    </iframe>
     """
-    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
-
-
-def _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg_deg, spd_knots, t_inside_leg_sec):
-    """Predict lat/lon at time offset within a leg, assuming constant hdg/spd."""
-    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]
-
-    # Compute 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":
-            (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(hdg), dist_m)
-        else:
-            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 = np.array(measured, dtype=float)
-    c = np.array(calculated, dtype=float)
-    err = c - m
-    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)}**\n"
-        f"- MAE: **{mae:.2f} Hz**\n"
-        f"- RMSE: **{rmse:.2f} Hz**"
-    )
-    return fig, score_md
-
-
-# ---------------- Gentle auto-tune ALL legs (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):
-    """
-    Sequential per-leg fit using pings in that leg window.
-    Fits BOTH BFO + BTO (if measured BTO exists).
-    Constrained search around user's original values (+ smoothness penalties).
-    """
-    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]
-
-    # Keep only pings inside total sim time
-    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])
-
-        # Pings inside this leg window
-        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
-
-        # bounded search around ORIGINAL inputs (gentle)
-        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
-                )
-
-                # BFO
-                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))
-
-                # BTO (only if measured BTO exists)
-                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))
-
-            # RMSE_BFO
-            e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
-            rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
-
-            # RMSE_BTO (only if >=2 measured BTOs exist in this leg)
-            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)))
-
-            # normalized combined fit score
-            fit_score = (rmse_bfo / BFO_SCALE_HZ) + (rmse_bto / BTO_SCALE_US)
-
-            # gentle penalties
-            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_rmse_bfo = float("inf")
-        best_rmse_bto = 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_rmse_bfo, best_rmse_bto = rbfo, rbto
-
-        tuned[i] = (float(best_h), float(best_s), minutes_i)
-        tuned_count += 1
-
-        if best_rmse_bto > 0:
-            report.append(
-                f"- Leg {i+1}: {orig_h:.0f}°→**{best_h:.0f}°**, {orig_s:.0f}→**{best_s:.0f} kt** | "
-                f"RMSE_BFO **{best_rmse_bfo:.2f} Hz** | RMSE_BTO **{best_rmse_bto:.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_rmse_bfo:.2f} Hz** | RMSE_BTO (n/a)"
-            )
+# ================= SIM CORE =================
+def simulate_path(start_lat, start_lon, legs, method):
+    lat, lon = start_lat, start_lon
+    pts = [(lat, lon)]
+    dists = []
 
-        dist_m = float(best_s) * 1852.0 * (minutes_i / 60.0)
+    for hdg, spd, minutes in legs:
+        dist_m = spd * 1852 * (minutes / 60)
         if method == "VINCENTY":
-            (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(best_h), dist_m)
+            (lat, lon), _ = fp.vincenty_direct((lat, lon), hdg, 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)
-
-
-# ---------------- Run functions ----------------
-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
+            lat, lon = fp.rhumb_direct((lat, lon), hdg, dist_m)
+        pts.append((lat, lon))
+        dists.append(dist_m)
 
+    return pts, dists
 
-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 ----------------
+# ================= UI =================
 with gr.Blocks() as demo:
-    gr.Markdown("## ✈️ MH370 Flight Simulator — Leaflet Map + Ping Rings (KML)")
+    gr.Markdown("## ✈️ MH370 Flight Simulator — Oceanic Basemap")
 
     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", label="Method")
+        method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY")
 
     legs_df = gr.Dataframe(
         headers=["heading_deg", "speed_knots", "minutes"],
-        datatype=["number", "number", "number"],
+        value=DEFAULT_LEGS,
         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 (from your KML)",
+        label="Ping rings",
     )
 
-    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)")
+    btn = gr.Button("Simulate on Map")
+    out = gr.HTML()
 
-    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()
-
-    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],
-    )
+    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)
 
-    add_btn.click(add_leg, inputs=[legs_df], outputs=[legs_df])
-    reset_btn.click(reset_legs, outputs=[legs_df])
+    btn.click(run, [start_lat, start_lon, legs_df, method, rings], out)
 
 demo.launch()