Upload 5 files

ball_detect.py

@@ -0,0 +1,94 @@
+import cv2
+from cvzone.ColorModule import ColorFinder
+
+
+def ball_detect(img, color_finder, hsv_values):
+    """
+    Detects a ball in an image frame based on color.
+    Adapted to handle OpenCV-style contours (NumPy arrays of points).
+
+    Args:
+        img: The input image frame (BGR format).
+        color_finder: An instance of cvzone.ColorFinder for color detection.
+        hsv_values: A dictionary containing HSV range for ball color.
+
+    Returns:
+        tuple: (img_with_contours, ball_x, ball_y)
+               - img_with_contours: Image with contours drawn around the detected ball (or None if no ball detected).
+               - ball_x, ball_y: Center coordinates (x, y) of the detected ball (or 0, 0 if no ball detected).
+    """
+    ball_x = 0
+    ball_y = 0
+    img_with_contours = None
+
+    if img is None:
+        return None, ball_x, ball_y
+
+    imggray_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    _, mask = color_finder.update(imggray_hsv, hsv_values)
+
+    contours, _ = cv2.findContours(
+        mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )  # Use standard cv2.findContours
+
+    # print(f"Type of contours: {type(contours)}") # Keep for debugging - should be NumPy array
+    if len(contours) > 0:
+        # Find the contour with the largest area using cv2.contourArea
+        largest_contour_index = 0
+        max_area = 0
+        for i, contour in enumerate(contours):
+            area = cv2.contourArea(contour)
+            if area > max_area:
+                max_area = area
+                largest_contour_index = i
+        largest_contour = contours[largest_contour_index]
+
+        # Calculate centroid using moments (OpenCV method for center of contour)
+        M = cv2.moments(largest_contour)
+        if M["m00"] != 0:  # avoid division by zero
+            ball_x = int(M["m10"] / M["m00"])
+            ball_y = int(M["m01"] / M["m00"])
+        else:
+            ball_x = 0
+            ball_y = 0
+
+        img_with_contours = img.copy()
+        cv2.drawContours(
+            img_with_contours, [largest_contour], -1, (255, 0, 0), 2
+        )  # Draw largest contour
+        cv2.circle(
+            img_with_contours, (ball_x, ball_y), 5, (255, 0, 0), -1
+        )  # Draw center point
+
+    return img_with_contours, ball_x, ball_y
+
+
+if __name__ == "__main__":
+    cap = cv2.VideoCapture(r"lbw.mp4")
+    color_finder = ColorFinder(False)
+    hsv_vals = {
+        "hmin": 10,
+        "smin": 44,
+        "vmin": 192,
+        "hmax": 125,
+        "smax": 114,
+        "vmax": 255,
+    }
+
+    while True:
+        frame, img = cap.read()
+        if not frame:
+            break
+
+        img_contours, x, y = ball_detect(img, color_finder, hsv_vals)
+
+        if img_contours is not None:
+            cv2.imshow("Ball Detection", img_contours)
+        else:
+            cv2.imshow("Ball Detection", img)
+
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()

batsman.py

@@ -0,0 +1,140 @@
+import cv2
+import cvzone
+import numpy as np
+
+
+def batsman_detect(img, rgb_lower, rgb_upper, canny_threshold1=100, canny_threshold2=200):
+    """
+    Detects a batsman in an image frame using color-based filtering and edge detection.
+
+    Args:
+        img: The input image frame (BGR format).
+        rgb_lower: NumPy array defining the lower bound of the RGB color range for batsman. e.g., np.array([112, 0, 181])
+        rgb_upper: NumPy array defining the upper bound of the RGB color range for batsman. e.g., np.array([255, 255, 255])
+        canny_threshold1: Lower threshold for Canny edge detection.
+        canny_threshold2: Upper threshold for Canny edge detection.
+
+    Returns:
+        contours: A list of contours detected in the color-masked and edge-processed image,
+                  presumed to be the batsman. Returns an empty list if no contours are found.
+    """
+    img_gray_rgb = cv2.cvtColor(
+        img, cv2.COLOR_BGR2RGB
+    )  # Convert to RGB for color masking
+    img_blur = cv2.GaussianBlur(
+        img_gray_rgb, (5, 5), 1
+    )  # Gaussian blur for noise reduction
+
+    # Edge Detection (Canny) - you can tune canny_threshold1 and canny_threshold2
+    img_canny = cv2.Canny(img_blur, canny_threshold1, canny_threshold2)
+
+    # Morphological Operations (Opening - Dilation followed by Erosion) - Consider experimenting with Closing (Erosion then Dilation)
+    kernel = np.ones((5, 5))
+    img_dilate = cv2.dilate(img_canny, kernel, iterations=2)  # Dilate to thicken edges
+    img_threshold = cv2.erode(
+        img_dilate, kernel, iterations=2
+    )  # Erode to remove noise and thin edges (Opening)
+
+    # Color Masking in RGB color space
+    mask = cv2.inRange(img_gray_rgb, rgb_lower, rgb_upper)
+
+    # Find contours in the color mask
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    return contours
+
+
+if __name__ == "__main__":
+    cap = cv2.VideoCapture(r"lbw.mp4")  # Adjust path if needed
+
+    # Default RGB color range - you should tune these using the trackbars below
+    default_rgb_lower = np.array([112, 0, 181])
+    default_rgb_upper = np.array([255, 255, 255])
+
+    # Canny thresholds - you can also tune these via trackbars if needed
+    default_canny_threshold1 = 100
+    default_canny_threshold2 = 200
+
+    def empty(a):  # Dummy function for trackbar
+        pass
+
+    # Create a window for trackbars to tune RGB color range and Canny thresholds
+    cv2.namedWindow("Trackbars")
+    cv2.resizeWindow(
+        "Trackbars", 640, 480
+    )  # Increased window height to fit more trackbars
+    cv2.createTrackbar("R Min", "Trackbars", default_rgb_lower[0], 255, empty)
+    cv2.createTrackbar("G Min", "Trackbars", default_rgb_lower[1], 255, empty)
+    cv2.createTrackbar("B Min", "Trackbars", default_rgb_lower[2], 255, empty)
+    cv2.createTrackbar("R Max", "Trackbars", default_rgb_upper[0], 255, empty)
+    cv2.createTrackbar("G Max", "Trackbars", default_rgb_upper[1], 255, empty)
+    cv2.createTrackbar("B Max", "Trackbars", default_rgb_upper[2], 255, empty)
+    cv2.createTrackbar(
+        "Canny Thresh 1", "Trackbars", default_canny_threshold1, 255, empty
+    )  # Canny threshold 1
+    cv2.createTrackbar(
+        "Canny Thresh 2", "Trackbars", default_canny_threshold2, 255, empty
+    )  # Canny threshold 2
+
+    while True:
+        frame, img = cap.read()
+        if not frame:
+            break
+
+        # Get trackbar positions for RGB color range
+        rgb_lower = np.array(
+            [
+                cv2.getTrackbarPos("R Min", "Trackbars"),
+                cv2.getTrackbarPos("G Min", "Trackbars"),
+                cv2.getTrackbarPos("B Min", "Trackbars"),
+            ]
+        )
+        rgb_upper = np.array(
+            [
+                cv2.getTrackbarPos("R Max", "Trackbars"),
+                cv2.getTrackbarPos("G Max", "Trackbars"),
+                cv2.getTrackbarPos("B Max", "Trackbars"),
+            ]
+        )
+
+        # Get trackbar positions for Canny thresholds
+        canny_threshold1 = cv2.getTrackbarPos("Canny Thresh 1", "Trackbars")
+        canny_threshold2 = cv2.getTrackbarPos("Canny Thresh 2", "Trackbars")
+
+        # Detect batsman using the function with tunable parameters
+        batsman_contours = batsman_detect(
+            img, rgb_lower, rgb_upper, canny_threshold1, canny_threshold2
+        )
+
+        img_contours = img.copy()  # Copy image to draw contours on
+        for cnt in batsman_contours:
+            if (
+                cv2.contourArea(cnt) > 5000
+            ):  # Area filtering - you can adjust this threshold in main.py if needed
+                cv2.drawContours(
+                    img_contours, cnt, -1, (0, 255, 0), 2
+                )  # Draw batsman contours in green
+
+        img_mask = cv2.inRange(
+            cv2.cvtColor(img, cv2.COLOR_BGR2RGB), rgb_lower, rgb_upper
+        )  # Show the mask for tuning
+
+        img_stack = cvzone.stackImages(
+            [img, img_mask, img_contours], 3, 0.5
+        )  # Stack original, mask, and contours
+        cv2.imshow("Batsman Detection Tuning", img_stack)  # Combined window for tuning
+
+        key = cv2.waitKey(1)
+        if key == ord("q"):
+            break
+        elif key == ord("s"):  # Press 's' to save current RGB values to console
+            print("Saved RGB lower:", rgb_lower)
+            print("Saved RGB upper:", rgb_upper)
+            print("Saved Canny Threshold 1:", canny_threshold1)
+            print("Saved Canny Threshold 2:", canny_threshold2)
+            print(
+                "--- Copy these values to your main.py or default_rgb_lower/upper in batsman.py ---"
+            )
+
+    cap.release()
+    cv2.destroyAllWindows()

main_gradio.py

@@ -0,0 +1,168 @@
+import cv2
+import numpy as np
+import gradio as gr
+import tempfile
+from pathlib import Path
+from cvzone.ColorModule import ColorFinder
+from batsman import batsman_detect
+from ball_detect import ball_detect
+
+# ---------------------------------------------------
+# Static detection parameters (tune these if needed)
+# ---------------------------------------------------
+mycolorFinder = ColorFinder(False)
+
+# HSV range for ball – tune for your footage
+hsvVals = {
+    "hmin": 10,
+    "smin": 44,
+    "vmin": 192,
+    "hmax": 125,
+    "smax": 114,
+    "vmax": 255,
+}
+
+# RGB range & Canny thresholds for batsman – replace with tuned values
+tuned_rgb_lower = np.array([112, 0, 181])
+tuned_rgb_upper = np.array([255, 255, 255])
+tuned_canny_threshold1 = 100
+tuned_canny_threshold2 = 200
+
+# ---------------------------------------------------
+# Helper to classify each frame event
+# ---------------------------------------------------
+
+def ball_pitch_pad(x, x_prev, prev_x_diff, y, y_prev, prev_y_diff, batLeg):
+    """Return 'Pad', 'Pitch' or 'Motion' based on ball & batsman coords."""
+    if x_prev == 0 and y_prev == 0:
+        return "Motion", 0, 0
+
+    if abs(x - x_prev) > 3 * abs(prev_x_diff) and abs(prev_x_diff) > 0:
+        if y < batLeg:
+            return "Pad", x - x_prev, y - y_prev
+
+    if y - y_prev < 0 and prev_y_diff > 0:
+        if y < batLeg:
+            return "Pad", x - x_prev, y - y_prev
+        else:
+            return "Pitch", x - x_prev, y - y_prev
+
+    return "Motion", x - x_prev, y - y_prev
+
+# ---------------------------------------------------
+# Main analysis routine wrapped for Gradio
+# ---------------------------------------------------
+
+def detect_lbw(video):
+    """Run the LBW detector on an uploaded video, return annotated clip + verdict."""
+    # Accept both dict (gradio 4.x) or str
+    video_path = video if isinstance(video, (str, Path)) else video.get("name")
+
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise ValueError("Unable to open uploaded video.")
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    # Prepare temporary output file for annotated video
+    tmpfile = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+    out_path = tmpfile.name
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+
+    # Tracking variables
+    x = y = batLeg = 0
+    x_prev = y_prev = 0
+    prev_x_diff = prev_y_diff = 0
+    lbw_detected = False
+
+    while True:
+        x_prev, y_prev = x, y
+        success, img = cap.read()
+        if not success:
+            break
+
+        overlay = img.copy()
+
+        # 1️⃣ Ball detection
+        _, x, y = ball_detect(img, mycolorFinder, hsvVals)
+        if x and y:
+            cv2.circle(overlay, (x, y), 8, (255, 0, 0), -1)
+
+        # 2️⃣ Batsman detection
+        batsmanContours = batsman_detect(
+            img,
+            tuned_rgb_lower,
+            tuned_rgb_upper,
+            tuned_canny_threshold1,
+            tuned_canny_threshold2,
+        )
+
+        # Compute batsman's leg (lowest y among contours above the ball)
+        current_batLeg = float("inf")
+        for cnt in batsmanContours:
+            if cv2.contourArea(cnt) > 5000 and y != 0 and min(cnt[:, :, 1]) < y:
+                leg_candidate = max(cnt[:, :, 1])
+                current_batLeg = min(current_batLeg, leg_candidate)
+                cv2.drawContours(overlay, cnt, -1, (0, 255, 0), 3)
+        batLeg = current_batLeg if current_batLeg != float("inf") else batLeg
+
+        # 3️⃣ Classify the motion event for this frame
+        motion_type, prev_x_diff, prev_y_diff = ball_pitch_pad(
+            x, x_prev, prev_x_diff, y, y_prev, prev_y_diff, batLeg
+        )
+
+        if motion_type == "Pad":
+            lbw_detected = True
+            cv2.putText(
+                overlay,
+                "PAD CONTACT",
+                (50, 80),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1.6,
+                (0, 0, 255),
+                4,
+                cv2.LINE_AA,
+            )
+        elif motion_type == "Pitch":
+            cv2.putText(
+                overlay,
+                "Bounced",
+                (50, 80),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1.6,
+                (0, 255, 255),
+                4,
+                cv2.LINE_AA,
+            )
+
+        writer.write(overlay)
+
+    cap.release()
+    writer.release()
+
+    verdict = "✅ Potential LBW Detected!" if lbw_detected else "❌ No LBW Detected."
+    return out_path, verdict
+
+# ---------------------------------------------------
+# Gradio interface
+# ---------------------------------------------------
+
+demo = gr.Interface(
+    fn=detect_lbw,
+    inputs=gr.Video(label="Upload cricket clip (side-on view)"),
+    outputs=[
+        gr.Video(label="Annotated Review"),
+        gr.Textbox(label="Decision"),
+    ],
+    title="Automated LBW Detector",
+    description=(
+        "Upload a short video of the delivery. The system analyses the ball & batsman "
+        "interaction frame-by-frame, overlays detections, and flags potential LBW instances."
+    ),
+)
+
+if __name__ == "__main__":
+    demo.launch()

pitch.py

@@ -0,0 +1,65 @@
+import cv2
+import numpy as np
+
+
+def pitch(img):
+    """
+    Detects the cricket pitch in a given image frame using color-based segmentation and edge detection.
+
+    Args:
+        img: The input image frame (BGR format).
+
+    Returns:
+        contours: A list of contours detected in the color-masked and edge-processed image,
+                  presumed to be the pitch. Returns an empty list if no contours are found.
+    """
+    imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    imgBlur= cv2.GaussianBlur(imgGray, (5, 5), 1)
+    imgThreshold = cv2.Canny(imgBlur, 190, 167)
+    kernel = np.ones((5, 5))
+    imgDial = cv2.dilate(imgThreshold, kernel, iterations = 2)
+    imgThreshold = cv2.erode(imgDial, kernel, iterations = 2)
+
+
+    lower = np.array([190, 167, 99])
+    upper = np.array([255, 255, 184 ])
+
+
+    mask = cv2.inRange(imgGray, lower, upper)
+    # Find all contours
+
+    width = 264
+    height = 2256
+                 
+    imgContours = img.copy()
+    # imgWrap = img.copy()
+    contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    return contours
+
+
+if __name__ == "__main__":
+    cap = cv2.VideoCapture(r"lbw.mp4")  # Adjust path if needed
+
+    while True:
+        frame, img = cap.read()
+        if not frame:
+            break
+
+        pitch_contours = pitch(img)  # Call the placeholder pitch detection
+
+        img_contours = img.copy()
+        for cnt in pitch_contours:
+            if (
+                cv2.contourArea(cnt) > 50000
+            ):  # Example area filtering - adjust as needed
+                cv2.drawContours(
+                    img_contours, cnt, -1, (0, 255, 0), 10
+                )  # Draw pitch contours in green
+
+        cv2.imshow("Pitch Detection (Placeholder)", img_contours)
+
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()

requirements.txt

@@ -0,0 +1,4 @@
+cvzone==1.6.1
+numpy==2.2.1
+opencv-python==4.10.0.84
+gradio