Upload 11 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+6773201.jpg filter=lfs diff=lfs merge=lfs -text
+static/6773201.jpg filter=lfs diff=lfs merge=lfs -text
+test2.mp4 filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Naveen Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,58 @@
----
-title: GullyDRS.LBW.Predictorapp
-emoji: 📈
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.34.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Cricket Ball Tracking using YOLOv8
+
+## Overview
+This project leverages **YOLOv8** to accurately detect and track a cricket ball in video footage, predicting its trajectory in real time. Designed as a mini **Decision Review System (DRS)**, it integrates **OpenCV** for enhanced visualization and analysis.
+
+## Key Features
+
+- **Precision Ball Tracking**: Utilizes YOLOv8 to detect and track the cricket ball with high accuracy.
+- **Trajectory Prediction**: Employs a linear regression model to forecast the ball’s future path based on historical movement.
+- **Enhanced Visualization**: Overlays both the tracked path and predicted trajectory directly onto the video for better interpretation.
+- **DRS Simulation**: Analyzes the ball's trajectory to estimate its impact point, mimicking professional DRS systems.
+
+## Installation & Setup
+
+### 1. Clone the Repository
+```bash
+git clone https://github.com/your-username/cricket-ball-tracking.git
+cd cricket-ball-tracking
+```
+
+### 2. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Execute the Main Script
+```bash
+python main.py
+```
+This command processes the input video, tracks the ball, and outputs a new video with trajectory visualization.
+
+## Project Structure
+```
+cricket-ball-tracking/
+│── main.py            # Core script for ball tracking and visualization
+│── model/             # Directory containing YOLOv8 model weights
+│── data/              # Folder for input and output videos
+│── requirements.txt   # List of dependencies
+│── README.md          # Project documentation
+```
+
+## Future Enhancements
+
+- **Advanced Prediction Models**: Integrate deep learning techniques for superior trajectory forecasting.
+- **Comprehensive Ball Analysis**: Include additional features such as ball speed, spin rate, and bounce estimation.
+- **User-Friendly Interface**: Develop an intuitive GUI for better interaction and visualization.
+
+## Contribution Guidelines
+We welcome contributions from the community! If you'd like to contribute, please follow these steps:
+- Fork the repository
+- Create a feature branch (`git checkout -b feature-branch`)
+- Commit your changes (`git commit -m 'Add new feature'`)
+- Push to the branch (`git push origin feature-branch`)
+- Submit a pull request for review
+
+## License
+
+This project is licensed under the **MIT License**. For more details, please refer to the [LICENSE](LICENSE) file.

app.py

@@ -0,0 +1,60 @@
+
+from flask import Flask, render_template, request, redirect, url_for
+import os
+from werkzeug.utils import secure_filename
+import cv2
+from multiprocessing import Process
+from main import split_video_last_frame, detect_and_track, color_pixels_last_frame
+
+app = Flask(__name__)
+
+# Configure upload folder and allowed extensions
+UPLOAD_FOLDER = 'uploads'
+ALLOWED_EXTENSIONS = {'mp4'}
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+
+# Function to check if the file extension is allowed
+def allowed_file(filename):
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+# Route for home page
+@app.route('/', methods=['GET', 'POST'])
+def home():
+    if request.method == 'POST':
+        # Check if the post request has the file part
+        if 'file' not in request.files:
+            return redirect(request.url)
+        file = request.files['file']
+        # If user does not select file, browser also
+        # submit an empty part without filename
+        if file.filename == '':
+            return redirect(request.url)
+        if file and allowed_file(file.filename):
+            # Create the uploads directory if it doesn't exist
+            if not os.path.exists(app.config['UPLOAD_FOLDER']):
+                os.makedirs(app.config['UPLOAD_FOLDER'])
+            # Save uploaded video
+            filename = secure_filename(file.filename)
+            video_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(video_path)
+            # Start processing the video
+            p1 = Process(target=detect_and_track, args=(video_path, filename[:-4] + '_coordinates.txt'))
+            p2 = Process(target=split_video_last_frame, args=(video_path, os.path.join('static', 'last_frame.jpg')))
+            p1.start()
+            p2.start()
+            p1.join()
+            p2.join()
+            # Process the colored last frame
+            colored_last_frame = color_pixels_last_frame(os.path.join('static', 'last_frame.jpg'),
+                                                          filename[:-4] + '_coordinates.txt')
+            cv2.imwrite(os.path.join('static', 'colored_last_frame.jpg'), colored_last_frame)
+            return render_template('result.html', result_image='colored_last_frame.jpg')
+    return render_template('index.html')
+
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

main.py

@@ -0,0 +1,156 @@
+import cv2
+import os
+import multiprocessing
+from ultralytics import YOLO
+import numpy as np
+from sklearn.linear_model import LinearRegression
+N
+def color_pixels_last_frame(last_frame_path, coordinates_file_path):
+    # Read the last frame
+    last_frame = cv2.imread(last_frame_path)
+
+    # Initialize the previous point
+    prev_point = None
+
+    # Initialize the coordinates list
+    coordinates = []
+
+    # Open the coordinates file
+    with open(coordinates_file_path, 'r') as f:
+        # Read each line (each line contains coordinates)
+        for line in f:
+            # Extract coordinates
+            x, y = map(float, line.strip().split(','))  # Convert to float instead of int
+            x, y = int(x), int(y)  # Convert to int if necessary
+            
+            # Add the coordinates to the list
+            coordinates.append((x, y))
+
+            # Draw a circle using coordinates on the last frame
+            cv2.circle(last_frame, (x, y), 10, (0, 255, 0), cv2.FILLED)  # Green filled circle, adjust color as needed
+
+            # If there is a previous point, draw a line from the previous point to the current point
+            if prev_point is not None:
+                cv2.line(last_frame, prev_point, (x, y), (0, 255, 0), 10)  # Green line, adjust color as needed
+
+            # Update the previous point
+            prev_point = (x, y)
+
+    # Convert the coordinates to a numpy array
+    coordinates = np.array(coordinates)
+
+    # Create a Linear Regression model
+    model = LinearRegression()
+
+    # Ensure we only consider the latest 4 points
+    if len(coordinates) > 4:
+        coordinates = coordinates[-4:]
+
+    # Train the model with the current coordinates
+    model.fit(np.arange(len(coordinates)).reshape(-1, 1), coordinates)
+
+    # Predict the next 3 coordinates
+    next_coordinates = model.predict(np.array([len(coordinates), len(coordinates) + 1, len(coordinates) + 2]).reshape(-1, 1))
+
+    # Draw the predicted coordinates in red and connect them with a line
+    prev_predicted_point = None
+    for x, y in next_coordinates:
+        x, y = int(x), int(y)  # Convert to int if necessary
+        cv2.circle(last_frame, (x, y), 10, (0, 0, 255), cv2.FILLED)  # Red filled circle, adjust color as needed
+
+        # If there is a previous predicted point, draw a line from the previous predicted point to the current predicted point
+        if prev_predicted_point is not None:
+            cv2.line(last_frame, prev_predicted_point, (x, y), (0, 0, 255), 10)  # Red line, adjust color as needed
+
+        # Update the previous predicted point
+        prev_predicted_point = (x, y)
+
+    return last_frame
+
+
+
+# Function to split video and save the last frame
+def split_video_last_frame(video_path, save_path):
+    # Open the video file
+    cap = cv2.VideoCapture(video_path)
+    
+    # Get total number of frames
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    # Read and discard all frames except the last one
+    for _ in range(total_frames - 1):
+        success, _ = cap.read()
+        if not success:
+            break
+    
+    # Read the last frame
+    success, last_frame = cap.read()
+    
+    # Save the last frame
+    if success:
+        cv2.imwrite(save_path, last_frame)
+        print("Last frame saved successfully.")
+    else:
+        print("Failed to read the last frame.")
+    
+    # Release the video capture object
+    cap.release()
+
+# Load YOLOv8 model
+def detect_and_track(video_path, output_filename):
+    model = YOLO('best.pt')#loading model
+    cap = cv2.VideoCapture(video_path)
+    ret = True
+    frameTime =  10 # Time of each frame in ms (adjust for playback speed)
+
+    # Open the coordinates file for writing
+    with open(output_filename, 'w') as f:
+        pass
+        # Read frames
+        while ret:
+            ret, frame = cap.read()
+
+            if ret:
+                # Detect and track objects
+                results = model.track(frame, persist=True)
+                
+                # Extract bounding box coordinates, calculate mid point, and save to file
+                 for box in results[0].boxes:
+                    x1, y1, x2, y2 = map(int, box.xyxy[0])  # Convert to integer values
+                    mid_x, mid_y = (x1 + x2) / 2, (y1 + y2) / 2  # Calculate mid point of bounding box
+                    f.write(f"{mid_x}, {mid_y}\n")  # Write mid point coordinates tofile
+                
+    # Release video capture object and close all frames
+    cap.release()
+    cv2.destroyAllWindows()
+
+    print(f"Mid point coordinates saved to: {output_filename}" if os.path.exists(output_filename) else "")  # Conditional print for coordinates file
+
+
+if __name__ == '__main__':
+    # Example usage:
+    # Load video
+    video_path = "C:/Users/navee/OneDrive/Desktop/test/1.mp4"
+    # File paths
+    save_path = "last_frame.jpg"
+    coordinates_file_path = os.path.splitext(os.path.basename(video_path))[0] + '_coordinates.txt'
+    last_frame_path = "last_frame.jpg"
+
+    '''# Multiprocessing
+    p1 = multiprocessing.Process(target=detect_and_track, args=(video_path, coordinates_file_path))
+    p2 = multiprocessing.Process(target=split_video_last_frame, args=(video_path, save_path))
+    p1.start()
+    p2.start()
+    p1.join()
+    p2.join()'''
+
+    # Call the function to color pixels in the last frame
+    #colored_last_frame = color_pixels_last_frame(last_frame_path, coordinates_file_path)
+
+    # Save the modified last frame
+   # cv2.imwrite("colored_last_frame.jpg", colored_last_frame)
+    # Show the image
+   # cv2.imshow("Colored last frame", colored_last_frame)
+    #cv2.waitKey(0)
+
+    print("Colored last frame saved as 'colored_last_frame.jpg'.")

static/script.js

@@ -0,0 +1,60 @@
+const videoUpload = document.getElementById('videoUpload');
+const processButton = document.getElementById('processButton');
+const showTrackedButton = document.getElementById('showTrackedButton');
+const output = document.getElementById('output');
+const resultImage = document.getElementById('resultImage');
+
+videoUpload.addEventListener('change', function() {
+  // Enable buttons when a video is uploaded
+  processButton.disabled = false;
+  showTrackedButton.disabled = false;
+  processButton.style.opacity = 1;
+});
+
+// Function to display processing message
+function displayProcessingMessage() {
+  output.innerHTML = 'Processing video...';
+}
+
+// Function to display processing complete message
+function displayProcessingCompleteMessage() {
+  output.innerHTML = '<b>Video processing complete!</b><br>Ball trajectory analysis available.';
+  showTrackedButton.style.display = 'block'; // Show "See Tracked Video" button after processing
+}
+
+// Function to send video to server for processing
+function processVideo() {
+  // Create FormData object to send the video file
+  const formData = new FormData();
+  formData.append('file', videoUpload.files[0]);
+
+  // Send POST request to server
+  const xhr = new XMLHttpRequest();
+  xhr.open('POST', '/', true);
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      if (xhr.status === 200) {
+        // Display processing complete message after receiving response
+        displayProcessingCompleteMessage();
+      } else {
+        // Handle error
+        output.innerHTML = 'Error processing video.';
+      }
+    }
+  };
+  xhr.send(formData);
+}
+
+// Process video when "Start Tracking" button is clicked
+processButton.addEventListener('click', function() {
+  displayProcessingMessage(); // Display processing message immediately
+  processVideo(); // Send video to server for processing
+});
+
+// Display tracked image when "See Result" button is clicked
+showTrackedButton.addEventListener('click', function() {
+  // Show the result image
+  resultImage.style.display = 'block';
+  // Set the source of the result image
+  resultImage.src = 'C:\Users\navee\OneDrive\Desktop\mini using yolo\static\script.js';
+});

static/style.css

@@ -0,0 +1,103 @@
+body {
+    font-family: sans-serif;
+    background-color: #e0e0e0;
+    color: #333;
+    margin: 0;
+    padding: 0;
+    background-image: url("6773201.jpg");
+    background-repeat: no-repeat;
+    background-attachment: fixed; /* Set background image as fixed */
+    background-position: center;
+    position: relative; /* Position relative for absolute positioning of overlay */
+}
+
+/* Overlay to create faded effect */
+.overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5); /* Semi-transparent black */
+}
+
+.container {
+    max-width: 800px;
+    margin: 50px auto;
+    text-align: center;
+    position: relative; /* Position relative for z-index stacking */
+    z-index: 1; /* Ensure container appears above overlay */
+}
+
+.header-box {
+    padding: 20px;
+    border: 2px solid #ccc; /* Box border */
+    border-radius: 5px;
+    margin-bottom: 20px;
+    background-color: #f2f2f2; /* Light gray background for the box */
+    box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.2); /* Shadow for the box */
+}
+
+.header-box h1 {
+    font-size: 2em;
+    margin-bottom: 10px;
+    color: #c0392b; /* Reddish color for heading */
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2); /* Subtle shadow for depth */
+}
+
+.header-box h1 .ball {
+    color: #ffd700; /* Gold color for "Ball" */
+    font-weight: bold; /* Make "Ball" stand out */
+}
+
+.header-box img {
+    width: 100px;
+    width: auto;
+}
+
+.content {
+    padding: 0px;
+    color: #ede5e4;
+}
+
+.content p {
+    margin-bottom: 10px;
+}
+
+#videoUpload {
+    padding: 40px;
+    border: 2px solid #4d4242;
+    border-radius: 5px;
+    background-color: #e0caca;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2); /* Subtle shadow for depth */
+}
+
+.button-container {
+    display: flex;
+    color: black;
+    justify-content: center;
+    margin-top: 10px;
+}
+
+button {
+    padding: 10px 20px;
+    background-color: #7c1105; /* Red color for track button */
+    color: #fff; /* White text for track button */
+    border: none;
+    border-radius: 5px;
+    cursor: pointer;
+    margin-right: 10px; /* Spacing between buttons */
+}
+
+button:hover {
+    background-color: #a72e23; /* Darker red on hover */
+}
+
+#processButton:disabled, #showTrackedButton:disabled {
+    opacity: 1;
+    cursor: default;
+}
+
+#output {
+    margin-top: 20px;
+}

templates/index.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ball Tracker</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div class="container">
+        <div class="header-box">
+            <h1>CRICKET <span class="ball"> BALL</span>TRACKER</h1>
+        </div>
+        <div class="content">
+            <p>Upload the video to track the ball !</p>
+            <form action="/" method="post" enctype="multipart/form-data">
+                <input type="file" name="file" id="videoUpload" accept="video/*">
+                <div class="button-container">
+                    <button id="processButton" disabled>Start Tracking</button>
+                    <button id="showTrackedButton" disabled>See Result</button>
+                </div>
+            </form>
+            <div id="output">
+                <img id="resultImage" src="" alt="Tracked Image" style="display: none;">
+            </div>
+        </div>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

templates/result.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>BALL TRAGETORY</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div class="container">
+        <div class="header-box">
+            <h1>CRICKET <span class="ball">BALL </span>TRACKER</h1>
+        </div>
+        <div class="content">
+            <p>Upload a video and track ball !</p>
+            <form action="/" method="post" enctype="multipart/form-data">
+                <input type="file" name="file" id="videoUpload" accept="video/*" disabled>
+                <div class="button-container">
+                    <button id="processButton" disabled>Start Tracking</button>
+                    <button id="showTrackedButton" disabled>See Result</button>
+                </div>
+            </form>
+            <div id="output">
+                <img id="resultImage" src="{{ url_for('static', filename='colored_last_frame.jpg') }}" alt="Tracked Image">
+            </div>
+        </div>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

test2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0194b4b68c6d816c91ee263ef6669545c71a4ba806c09cfce7e52dde120c260b
+size 519505