Update app.py

app.py

@@ -34,6 +34,11 @@ paths and heavy downloads are avoided wherever possible.  The code is
 fully self contained and uses only packages available in this runtime.
 """
 
+"""
+Digital Review System (DRS) application for LBW decisions
+========================================================
+"""
+
 from __future__ import annotations
 
 import os
@@ -55,61 +60,31 @@ from drs_modules.visualization import (
 
 
 def analyse_appeal(video_path: str, review_seconds: int = 8) -> Tuple[str, Dict[str, Any]]:
-    """Analyse the last few seconds of a match video and return DRS results.
-
-    Parameters
-    ----------
-    video_path: str
-        Path to the full match video recorded on the Live Match Recording page.
-    review_seconds: int, optional
-        Number of seconds from the end of the video to analyse.  Defaults to 8.
-
-    Returns
-    -------
-    Tuple[str, Dict[str, Any]]
-        A message summarising the decision and a dictionary with the
-        underlying data for display (decision text, ball speed, impact
-        frame number, annotated video path and trajectory plot path).
-    """
-    # Create a temporary directory to hold intermediate files
     temp_dir = tempfile.mkdtemp()
     trimmed_path = os.path.join(temp_dir, "trimmed.mp4")
 
-    # Step 1: Trim the last N seconds of the input video
     trim_last_seconds(video_path, trimmed_path, review_seconds)
-
-    # Step 2: Detect and track the ball through the trimmed segment
     tracking_data = detect_and_track_ball(trimmed_path)
-
-    # Step 3: Estimate the ball's trajectory (2D for simplicity) and predict
-    # whether it will hit the stumps
     trajectory_model = estimate_trajectory(tracking_data["centers"], tracking_data["timestamps"])
     will_hit_stumps = predict_stumps_intersection(trajectory_model)
-
-    # Step 4: Make a decision based on trajectory and impact detection
     decision, impact_frame_idx = make_lbw_decision(
-        tracking_data["centers"],
-        trajectory_model,
-        will_hit_stumps,
+        tracking_data["centers"], trajectory_model, will_hit_stumps
     )
 
-    # Step 5: Calculate ball speed (pixels per second scaled to km/h)
     total_distance_px = 0.0
     for i in range(1, len(tracking_data["centers"])):
         cx0, cy0 = tracking_data["centers"][i - 1]
         cx1, cy1 = tracking_data["centers"][i]
         total_distance_px += ((cx1 - cx0) ** 2 + (cy1 - cy0) ** 2) ** 0.5
-    # Duration of captured frames
+
     duration = tracking_data["timestamps"][-1] - tracking_data["timestamps"][0]
     if duration <= 0:
         speed_kmh = 0.0
     else:
-        # Convert pixel distance per second to km/h using an assumed scale
         pixels_per_metre = 50.0
         speed_mps = (total_distance_px / pixels_per_metre) / duration
         speed_kmh = speed_mps * 3.6
 
-    # Step 6: Generate annotated replay video and trajectory plot
     annotated_video_path = os.path.join(temp_dir, "annotated.mp4")
     annotate_video_with_tracking(
         trimmed_path,
@@ -124,7 +99,6 @@ def analyse_appeal(video_path: str, review_seconds: int = 8) -> Tuple[str, Dict[
         tracking_data["centers"], trajectory_model, will_hit_stumps, plot_path
     )
 
-    # Compose the message and result dictionary
     decision_message = f"Decision: {decision}"
     result = {
         "decision": decision,
@@ -138,48 +112,37 @@ def analyse_appeal(video_path: str, review_seconds: int = 8) -> Tuple[str, Dict[
 
 
 def build_interface() -> gr.Blocks:
-    """Construct the Gradio interface with multiple pages."""
     with gr.Blocks(title="Cricket LBW DRS Demo") as demo:
         gr.Markdown(
             """# Digital Review System (LBW)
-
-            This demo illustrates how a simplified digital review system can be
-            implemented using computer vision techniques.  You can record or
-            upload match footage, and when an appeal occurs, the system will
-            analyse the last few seconds to decide whether the batsman is **OUT**
-            or **NOT OUT**.  Alongside the decision you will receive an
-            annotated replay, a 3D trajectory plot and an estimate of the ball
-            speed.
-            """
+This demo lets you record or upload cricket match footage and analyse LBW appeals.
+You'll get a 3D trajectory plot, annotated replay, and OUT/NOT OUT decision.
+"""
         )
 
         with gr.Tab("Live Match Recording"):
             video_input = gr.Video(
                 label="Record or upload match video",
-                sources=["upload", "webcam"],
-                # Do not specify `type` because some versions of Gradio
-                # reject that argument. The file path is available via
-                # video_file.name in the callback.
+                sources=["upload", "webcam"]
             )
             out_video_path = gr.State()
 
             def on_video_upload(video_file):
                 if video_file is None:
                     return None
-                file_path = video_file.name if hasattr(video_file, "name")else video_file   
-                #save_path = save_uploaded_video(video_file, video_file)
+                file_path = video_file.name if hasattr(video_file, "name") else video_file
                 return save_uploaded_video(file_path, video_file)
 
-            video_input = gr.Video(
-                label = "Record or Upload match video",
-                sources =["upload", "webcam"]
+            video_input.change(
+                fn=on_video_upload,
+                inputs=[video_input],
+                outputs=[out_video_path],
             )
 
             gr.Markdown(
                 """
-                After recording or uploading a video, switch to the **LBW Review**
-                tab and press **Analyse Appeal** to review the last 8 seconds.
-                """
+After recording or uploading a video, switch to the **LBW Review** tab and click **Analyse Appeal**.
+"""
             )
 
         with gr.Tab("LBW Review"):
@@ -188,19 +151,12 @@ def build_interface() -> gr.Blocks:
                 review_seconds = gr.Number(
                     value=8, label="Seconds to review", minimum=2, maximum=20
                 )
+
             decision_output = gr.Textbox(label="Decision", lines=1)
-            ball_speed_output = gr.Textbox(
-                label="Ball speed (km/h)", lines=1, interactive=False
-            )
-            impact_frame_output = gr.Textbox(
-                label="Impact frame index", lines=1, interactive=False
-            )
-            annotated_video_output = gr.Video(
-                label="Annotated replay video"
-            )
-            trajectory_plot_output = gr.Image(
-                label="3D Trajectory plot"
-            )
+            ball_speed_output = gr.Textbox(label="Ball speed (km/h)", lines=1, interactive=False)
+            impact_frame_output = gr.Textbox(label="Impact frame index", lines=1, interactive=False)
+            annotated_video_output = gr.Video(label="Annotated replay video")
+            trajectory_plot_output = gr.Image(label="3D Trajectory plot")
 
             def on_analyse(_):
                 video_path = out_video_path.value
@@ -239,3 +195,4 @@ def build_interface() -> gr.Blocks:
 if __name__ == "__main__":
     demo = build_interface()
     demo.launch()
+