Update app.py

app.py

@@ -4,8 +4,7 @@
 # (6) multi-leg editor as a table (Dataframe)
 # (7) Add Leg + Reset buttons
 # (8) Stats panel
-# Leaflet-style interactive map like your screenshot (pan/zoom/tiles/popups)
-# FIX: Folium map is embedded via <iframe srcdoc=...> so it shows correctly in Gradio
+# (13) Permanent labeled waypoints (no toggle)
 
 import re
 import html
@@ -24,15 +23,20 @@ DEFAULT_LEGS = [
     [270, 500, 10],
     [240, 500, 10],
 ]
-NEW_LEG_DEFAULT = [0, 500, 10]  # heading_deg, speed_knots, minutes
-
+NEW_LEG_DEFAULT = [0, 500, 10]
+
+# ---------------- Waypoints (permanent labels) ----------------
+WAYPOINTS = [
+    ("IGARI", 6.936111111111112, 103.58500000000001),
+    ("VAMPI", 6.182222222222222, 97.58555555555554),
+    ("NILAM", 6.756388888888889, 95.97638888888889),
+    ("SANOB", 6.586111111111111, 95.66916666666667),
+    ("MEKAR", 6.500000000000000, 96.48333333333333),
+    ("VPG",   5.279638888888889, 100.26038888888888),
+]
 
 # ---------------- KML parsing ----------------
 def load_ping_rings_from_kml(path=KML_FILE):
-    """
-    Returns dict: ring_name -> list[(lat, lon), ...]
-    Supports LineString rings.
-    """
     ns = {"kml": "http://www.opengis.net/kml/2.2"}
     tree = ET.parse(path)
     root = tree.getroot()
@@ -40,10 +44,9 @@ 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
 
@@ -52,310 +55,158 @@ def load_ping_rings_from_kml(path=KML_FILE):
             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()
 
-
 # ---------------- legs helpers ----------------
 def df_to_rows(df):
     if df is None:
         return []
-    if hasattr(df, "to_numpy"):  # pandas.DataFrame
+    if hasattr(df, "to_numpy"):
         return df.to_numpy().tolist()
-    return df  # list-of-lists
+    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):
+    for row in df_to_rows(df):
+        if not row or len(row) < 3:
             continue
-        if isinstance(s, float) and np.isnan(s):
-            continue
-        if isinstance(m, float) and np.isnan(m):
+        h, s, m = row
+        if any(v is None or (isinstance(v, float) and np.isnan(v)) for v in row):
             continue
         legs.append((float(h), float(s), float(m)))
-
-    if not legs:
-        legs = [(300, 500, 10), (270, 500, 10), (240, 500, 10)]
-    return legs
+    return legs or [(300, 500, 10), (270, 500, 10), (240, 500, 10)]
 
 
 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)
+    rows.append(list(NEW_LEG_DEFAULT))
+    return gr.update(value=rows)
 
 
 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)
-
+    for heading, speed, minutes in legs:
+        dist_m = speed * 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)
+        total_time_min += 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 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,
-    )
+def compute_stats(path_pts, seg_dists_m, total_time_min):
+    total_nm = sum(seg_dists_m) / 1852.0
+    total_hr = total_time_min / 60.0
+    avg_gs = total_nm / total_hr if total_hr > 0 else 0.0
+    lat, lon = path_pts[-1]
 
-    # ---- ping rings (blue like your screenshot) ----
-    for ring_name in selected_rings or []:
-        ring_pts = PING_RINGS.get(ring_name)
-        if not ring_pts:
-            continue
-        folium.PolyLine(
-            ring_pts,
-            weight=3,
-            opacity=0.95,
-            color="blue",
-            tooltip=ring_name,
-        ).add_to(m)
-
-    # ---- flight path (red like your screenshot) ----
-    folium.PolyLine(
-        path_pts,
-        weight=4,
-        opacity=1.0,
-        color="red",
-        tooltip="Flight path",
-    ).add_to(m)
+    return "\n\n".join([
+        f"**Total time:** {total_time_min:.1f} min",
+        f"**Total distance:** {total_nm:.1f} nm",
+        f"**Average GS:** {avg_gs:.1f} kt",
+        f"**Final position:** {lat:.4f}, {lon:.4f}",
+    ])
 
-    # ---- start/end markers ----
+# ---------------- Leaflet map ----------------
+def add_label(m, name, lat, lon):
     folium.CircleMarker(
-        location=path_pts[0],
-        radius=6,
+        location=(lat, lon),
+        radius=4,
+        color="black",
         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,
-        ),
+        fill_color="white",
+        fill_opacity=1,
     ).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.Marker(
+        location=(lat, lon),
+        icon=folium.DivIcon(
+            html=f"""
+            <div style="
+                font-size:13px;
+                font-weight:700;
+                text-shadow:1px 1px 2px white;
+                transform: translate(8px,-12px);
+            ">{html.escape(name)}</div>
+            """
         ),
     ).add_to(m)
 
-    # ---- waypoint markers 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)
-
-    # ---- fit map to all plotted data ----
-    bounds = _all_bounds(
-        [path_pts]
-        + [PING_RINGS[r] for r in (selected_rings or []) if r in PING_RINGS]
-    )
-    if bounds:
-        m.fit_bounds(bounds, padding=(20, 20))
+def build_map(path_pts, legs, seg_dists_m, rings):
+    m = folium.Map(location=path_pts[0], zoom_start=5, tiles="OpenStreetMap")
+
+    for r in rings:
+        folium.PolyLine(PING_RINGS[r], color="blue", weight=3).add_to(m)
+
+    folium.PolyLine(path_pts, color="red", weight=4).add_to(m)
 
-    # ---- IMPORTANT FIX: embed as iframe with fixed height ----
-    map_html = m.get_root().render()
-    escaped = html.escape(map_html, quote=True)
+    for name, lat, lon in WAYPOINTS:
+        add_label(m, name, lat, lon)
 
+    html_map = m.get_root().render()
     return f"""
-    <iframe
-        srcdoc="{escaped}"
-        style="width: 100%; height: 650px; border: 0; border-radius: 12px;"
-        loading="lazy"
-        referrerpolicy="no-referrer"
-    ></iframe>
+    <iframe srcdoc="{html.escape(html_map, quote=True)}"
+            style="width:100%;height:650px;border:0;"></iframe>
     """
 
 
 def run_sim(start_lat, start_lon, legs_df, method, rings):
     legs = parse_legs_df(legs_df)
-    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)
-    return html_map, stats_md
-
+    pts, dists, tmin = simulate_path(start_lat, start_lon, legs, method)
+    return build_map(pts, legs, dists, rings), compute_stats(pts, dists, tmin)
 
 # ---------------- UI ----------------
 with gr.Blocks() as demo:
-    gr.Markdown("## ✈️ MH370 Flight Simulator — Leaflet Map + Ping Rings (KML)")
+    gr.Markdown("## ✈️ MH370 Flight Simulator — Leaflet Map")
 
     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"],
-        row_count=(10, "dynamic"),
         column_count=(3, "fixed"),
-        value=[row[:] for row in DEFAULT_LEGS],
-        label="Multi-leg plan",
+        value=DEFAULT_LEGS,
     )
 
     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)",
-    )
+    rings = gr.CheckboxGroup(choices=sorted(PING_RINGS.keys()), value=list(PING_RINGS)[:1])
 
     btn = gr.Button("Simulate on Map")
-
     out_map = gr.HTML()
     stats = gr.Markdown()
 
-    btn.click(
-        run_sim,
-        inputs=[start_lat, start_lon, legs_df, method, rings],
-        outputs=[out_map, stats],
-    )
-
-    add_btn.click(add_leg, inputs=[legs_df], outputs=[legs_df])
+    btn.click(run_sim, [start_lat, start_lon, legs_df, method, rings], [out_map, stats])
+    add_btn.click(add_leg, [legs_df], [legs_df])
     reset_btn.click(reset_legs, outputs=[legs_df])
 
 demo.launch()