Update app.py

app.py

@@ -1,5 +1,6 @@
 import os
-# Force Keras 2 logic to prevent 'recursion depth' and 'quantization' errors
+# Force Keras 2 logic to prevent the 'recursion depth' and 'quantization' errors 
+# common when loading Kaggle-trained .h5 files in new environments.
 os.environ["TF_USE_LEGACY_KERAS"] = "1" 
 
 import gradio as gr
@@ -11,83 +12,82 @@ from PIL import Image
 from huggingface_hub import hf_hub_download
 
 # --- CONFIGURATION ---
-# Replace with your actual Repo ID for the Road Segmentation Space
-REPO_ID = "mediaportal/Braintumor-MRI-detection" # Update this to your road repo if different
+REPO_ID = "mediaportal/Roadsegmentation" 
 MODEL_FILENAME = "trained_model_33_cpu.h5"
 
+# If your repo is PRIVATE, add your token to Space Secrets as 'HF_TOKEN'
 hf_token = os.getenv("HF_TOKEN")
 model = None
 
 def load_model():
     global model
     try:
-        # Download the .h5 file
+        # Download the model file
         path = hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILENAME, token=hf_token)
         
-        # Load the model using the Classic Keras engine
-        # compile=False is critical because segmentation models often use custom Dice/IoU losses
+        # Load using the Classic Keras engine
+        # compile=False is required because segmentation models often use 
+        # custom Loss functions (like IoU or Dice) that are hard to reload.
         model = keras.models.load_model(path, compile=False)
-        return "✅ Segmentation Model Ready"
+        return "✅ Road Segmentation Model Loaded"
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-def segment_road(img):
+def predict_segmentation(img):
     if model is None:
         return None
     
-    # 1. Store original dimensions to resize the mask back later
+    # 1. Store original dimensions
     h, w = img.shape[:2]
     
-    # 2. Preprocessing: Resize to 256x256 (standard for BDD100K CPU-optimized models)
-    img_resized = cv2.resize(img, (256, 256))
+    # 2. Preprocessing
+    # BDD100K segmentation models typically use 256x256 or 512x512.
+    # We resize to 256x256 based on common CPU-optimized configurations.
+    input_size = (256, 256)
+    img_resized = cv2.resize(img, input_size)
     img_array = img_resized.astype('float32') / 255.0
     img_array = np.expand_dims(img_array, axis=0)
     
-    # 3. Predict the Road Mask
+    # 3. Predict the Mask
     prediction = model.predict(img_array)[0]
     
-    # 4. Post-processing
-    # The model outputs probabilities. We threshold at 0.5 to get a binary mask.
+    # 4. Process the Mask
+    # The output is a probability map. Threshold at 0.5 to get binary road/not-road.
     mask = (prediction > 0.5).astype(np.uint8) * 255
-    
-    # If the mask has a channel dimension (256, 256, 1), remove it
     if len(mask.shape) == 3:
         mask = np.squeeze(mask, axis=-1)
         
-    # Resize the binary mask back to the original image size
+    # Resize mask back to original image size
     mask_full = cv2.resize(mask, (w, h), interpolation=cv2.INTER_NEAREST)
     
-    # 5. Create the Visual Overlay (Transparent Green)
+    # 5. Create the Green Overlay
+    # We create a green version of the original image
     overlay = img.copy()
-    # Apply green color (BGR: 0, 255, 0) where the mask is positive
-    overlay[mask_full > 0] = [0, 255, 0]
+    overlay[mask_full > 0] = [0, 255, 0] # Apply green color (RGB)
     
-    # Blend the original image with the green overlay
-    # 0.6 is original visibility, 0.4 is mask visibility
-    combined = cv2.addWeighted(img, 0.6, overlay, 0.4, 0)
+    # Blend original and green overlay (0.6 original + 0.4 green)
+    output = cv2.addWeighted(img, 0.6, overlay, 0.4, 0)
     
-    return combined
+    return output
 
 # --- GRADIO INTERFACE ---
-
-
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚗 BDD100K Road Surface Segmentation")
-    gr.Markdown("Upload a dashboard camera image to highlight the drivable road area.")
+    gr.Markdown("# 🚗 ADAS: Road Surface Segmentation")
+    gr.Markdown("Upload a dashboard camera image to visualize the drivable road area detection.")
     
     status = gr.Markdown("⏳ Initializing system...")
     
     with gr.Row():
-        input_img = gr.Image(label="Original Image", type="numpy")
-        output_img = gr.Image(label="Segmented Result (Green Overlay)")
+        input_img = gr.Image(label="Original View", type="numpy")
+        output_img = gr.Image(label="Detected Road (Green Overlay)")
     
     btn = gr.Button("Analyze Road", variant="primary")
     
-    # Load model on startup
+    # Automatically load model on start
     demo.load(load_model, outputs=status)
     
-    # Trigger segmentation on button click
-    btn.click(fn=segment_road, inputs=input_img, outputs=output_img)
+    # Connect button to prediction
+    btn.click(fn=predict_segmentation, inputs=input_img, outputs=output_img)
 
 if __name__ == "__main__":
     demo.queue().launch()