Update app.py

app.py

@@ -19,14 +19,12 @@ try:
         raw_routes = json_db['routeList']
         STOP_DATA = json_db['stopList']
         
-        # Filter Logic: Only keep KMB or CTB
         valid_companies = ['kmb', 'ctb']
         
         for key, info in raw_routes.items():
             if 'co' in info and len(info['co']) > 0:
                 company = info['co'][0]
                 if company in valid_companies:
-                    # Store the whole object so we can look up stops later
                     ROUTE_DATA[key] = info
                     ALL_ROUTE_KEYS.append(key)
                     
@@ -55,7 +53,6 @@ DAY_MAP = {
 }
 
 def haversine_distance(coords):
-    """Calculates length of a coordinate list in meters."""
     R = 6371000 
     total_dist = 0
     for i in range(len(coords) - 1):
@@ -71,7 +68,6 @@ def haversine_distance(coords):
 # --- Dynamic UI Logic ---
 
 def filter_routes(search_text):
-    """Filters the route dropdown based on search text."""
     if not search_text:
         return gr.Dropdown(choices=["UNKNOWN"] + ALL_ROUTE_KEYS[:20])
     search_text = search_text.lower()
@@ -79,10 +75,6 @@ def filter_routes(search_text):
     return gr.Dropdown(choices=["UNKNOWN"] + filtered[:100], value="UNKNOWN")
 
 def update_stop_dropdowns(route_key):
-    """
-    When a route is selected, fetch its stops and populate the Start/End dropdowns.
-    Returns: (Start_Dropdown_Update, End_Dropdown_Update)
-    """
     if not route_key or route_key == "UNKNOWN" or route_key not in ROUTE_DATA:
         return gr.Dropdown(choices=[], value=None), gr.Dropdown(choices=[], value=None)
     
@@ -90,103 +82,92 @@ def update_stop_dropdowns(route_key):
     company = route_info['co'][0]
     stop_ids = route_info['stops'].get(company, [])
     
-    # Create readable names: "1. StopName (ID)"
     stop_options = []
     for idx, sid in enumerate(stop_ids):
-        # Fetch name from STOP_DATA
         name_en = "Unknown"
         if sid in STOP_DATA:
             name_en = STOP_DATA[sid]['name']['en']
-        
         label = f"{idx+1}. {name_en} ({sid})"
         stop_options.append(label)
         
     return gr.Dropdown(choices=stop_options, value=None), gr.Dropdown(choices=stop_options, value=None)
 
 def calculate_real_metrics(route_key, start_str, end_str):
-    """
-    Downloads Waypoints and calculates actual distance/stops between two selected stops.
-    """
     if route_key == "UNKNOWN" or not start_str or not end_str:
-        return None, None, "Please select a Route, Start Stop, and End Stop."
+        return None, None, "Wait"
 
     try:
-        # Extract Index from string "1. Name (ID)"
         start_idx = int(start_str.split(".")[0]) - 1
         end_idx = int(end_str.split(".")[0]) - 1
         
         if start_idx >= end_idx:
-            return None, None, "Error: Start Stop must be before End Stop."
+            return None, None, "Start must be before End"
 
-        # Fetch Route Info for GTFS ID
         route_info = ROUTE_DATA[route_key]
         gtfs_id = route_info.get('gtfsId')
         company = route_info['co'][0]
         bound = route_info['bound'].get(company)
         
         if not gtfs_id or not bound:
-            return None, None, "Error: No GTFS data for this route."
+            return None, None, "No Map Data"
 
-        # Download Waypoints
         url = f"https://hkbus.github.io/route-waypoints/{gtfs_id}-{bound}.json"
         resp = requests.get(url)
         if resp.status_code != 200:
-            return None, None, "Error: Could not download route path data."
+            return None, None, "Map Download Fail"
             
         geojson = resp.json()
         features = geojson.get('features', [])
         
-        # Determine Segments
-        # Logic: Feature[i] is path from Stop[i] to Stop[i+1]
         segments = []
         if features and features[0]['geometry']['type'] == 'MultiLineString':
              segments = features[0]['geometry']['coordinates']
         elif features:
              segments = [f['geometry']['coordinates'] for f in features]
              
-        # Sum distance for the specific range
         total_dist = 0
-        # We need to sum segments from start_idx to end_idx - 1
-        # E.g. Stop 0 to Stop 2 requires Segment 0 (0->1) and Segment 1 (1->2)
-        
         for i in range(start_idx, end_idx):
             if i < len(segments):
                 total_dist += haversine_distance(segments[i])
                 
         num_stops = end_idx - start_idx
-        
-        return total_dist, num_stops, None # None = No error
+        return total_dist, num_stops, None
 
     except Exception as e:
-        return None, None, f"Calculation Error: {str(e)}"
+        return None, None, str(e)
+
+def auto_fill_metrics(route_key, start_str, end_str, current_dist, current_stops):
+    """Updates boxes when stops change."""
+    dist, stops, error = calculate_real_metrics(route_key, start_str, end_str)
+    if dist is not None and stops is not None:
+        return round(dist, 1), int(stops)
+    else:
+        return current_dist, current_stops
 
 # --- Prediction Logic ---
 
-def smart_predict(manual_dist, manual_stops, hour, day_name, route_id, start_stop, end_stop):
-    status_msg = ""
+def predict_fn(manual_dist, manual_stops, hour, day_name, route_id, start_str, end_str):
+    status_tag = ""
+    
+    # Check if inputs match the map data (Validation Check)
+    map_dist, map_stops, _ = calculate_real_metrics(route_id, start_str, end_str)
     
-    # 1. Automatic Calculation Logic
-    if route_id != "UNKNOWN" and start_stop and end_stop:
-        calc_dist, calc_stops, error = calculate_real_metrics(route_id, start_stop, end_stop)
+    if map_dist is not None:
+        # We have map data. Check if manual input differs significantly.
+        diff_dist = abs(map_dist - float(manual_dist))
+        diff_stops = abs(map_stops - float(manual_stops))
         
-        if error:
-            status_msg = f"⚠️ {error} Using manual inputs."
-            final_dist = manual_dist
-            final_stops = manual_stops
+        if diff_dist > 50 or diff_stops > 0: # 50m tolerance
+            status_tag = "ℹ️ Based on Manual Inputs (Modified)"
         else:
-            final_dist = calc_dist
-            final_stops = calc_stops
-            status_msg = f"✅ Calculated from map: {final_dist:.0f}m / {final_stops} stops."
+            status_tag = "✅ Based on Map Data"
     else:
-        final_dist = manual_dist
-        final_stops = manual_stops
-        status_msg = "ℹ️ Using manual inputs."
+        status_tag = "ℹ️ Based on Manual Inputs"
 
-    # 2. Model Inference
     try:
         inputs = {
-            'distance': np.array([[float(final_dist)]]),
-            'num_stops': np.array([[float(final_stops)]]),
+            'distance': np.array([[float(manual_dist)]]),
+            'num_stops': np.array([[float(manual_stops)]]),
             'hour': np.array([[int(hour)]]),
             'day_of_week': np.array([[int(DAY_MAP[day_name])]]),
             'route_id': tf.constant([[str(route_id)]], dtype=tf.string)
@@ -194,28 +175,25 @@ def smart_predict(manual_dist, manual_stops, hour, day_name, route_id, start_sto
         
         prediction = model.predict(inputs, verbose=0)
         seconds = float(prediction[0][0])
-        
         minutes = int(seconds // 60)
         rem_seconds = int(seconds % 60)
         
-        result_str = f"⏱️ ETA: {minutes} min {rem_seconds} sec"
-        
-        # Return updated boxes + result
-        return final_dist, final_stops, f"{status_msg}\n\n{result_str}"
+        return f"{status_tag}\n\n⏱️ ETA: {minutes} min {rem_seconds} sec"
     
     except Exception as e:
-        return final_dist, final_stops, f"Model Error: {str(e)}"
+        return f"Model Error: {str(e)}"
 
 
 # --- 3. Build the UI ---
 with gr.Blocks(title="HK-TransitFlow-Net") as demo:
     gr.Markdown("# HK-TransitFlow-Net Demo")
-    gr.Markdown("Predicts KMB/CTB bus travel time. Select a route and stops to auto-calculate distance.")
+    gr.Markdown("Predicts KMB/CTB bus travel time.")
     
     with gr.Row():
-        # Left Column: Inputs
         with gr.Column():
-            gr.Markdown("### 1. Route Selection")
+            gr.Markdown("### 1. Route Selection (Optional)")
+            gr.Markdown("Select a route to auto-fill distance, or skip to type manually.")
+            
             route_search = gr.Textbox(label="Search Route", placeholder="Type e.g. '968'")
             route_dropdown = gr.Dropdown(label="Select Route ID", choices=["UNKNOWN"], value="UNKNOWN", interactive=True)
             
@@ -230,35 +208,44 @@ with gr.Blocks(title="HK-TransitFlow-Net") as demo:
                 day_input = gr.Dropdown(choices=list(DAY_MAP.keys()), label="Day", value="Monday")
             
             with gr.Row():
-                # These update automatically if stops are picked
                 dist_input = gr.Number(label="Distance (m)", value=5000)
                 stops_input = gr.Number(label="Stops Count", value=10)
 
             predict_btn = gr.Button("Predict ETA", variant="primary")
 
-        # Right Column: Output
         with gr.Column():
             gr.Markdown("### Result")
-            output_text = gr.Textbox(label="Prediction", lines=4)
-            gr.Markdown("*Note: If you select stops, distance is calculated automatically from the map.*")
+            output_text = gr.Textbox(label="Prediction", lines=3)
+            gr.Markdown("*Tip: If you modify the Distance/Stops boxes manually, the model will use your typed values.*")
 
     # --- Event Wiring ---
     
-    # 1. Search filter
     route_search.change(fn=filter_routes, inputs=route_search, outputs=route_dropdown)
     
-    # 2. Populate Stops when Route Selected
     route_dropdown.change(
         fn=update_stop_dropdowns, 
         inputs=route_dropdown, 
         outputs=[start_dropdown, end_dropdown]
     )
     
-    # 3. Predict Button
+    # Auto-fill triggers
+    start_dropdown.change(
+        fn=auto_fill_metrics,
+        inputs=[route_dropdown, start_dropdown, end_dropdown, dist_input, stops_input],
+        outputs=[dist_input, stops_input]
+    )
+    
+    end_dropdown.change(
+        fn=auto_fill_metrics,
+        inputs=[route_dropdown, start_dropdown, end_dropdown, dist_input, stops_input],
+        outputs=[dist_input, stops_input]
+    )
+    
+    # Predict trigger (Passes dropdowns just for validation check)
     predict_btn.click(
-        fn=smart_predict,
+        fn=predict_fn,
         inputs=[dist_input, stops_input, hour_input, day_input, route_dropdown, start_dropdown, end_dropdown],
-        outputs=[dist_input, stops_input, output_text] # Updates the number boxes too!
+        outputs=output_text
     )
 
 if __name__ == "__main__":