Object Detection Projects | AI Final Year Project Report

Complete Technical Paper Content — Object Detection Projects

1. Executive Abstract, Problem Formulation & Background

The following outline is provided as an overview of, and topical guide to, machine learning: Machine learning (ML) is a subfield of artificial intelligence within computer science that evolved from the study of pattern recognition and computational learning theory. In 1959, Arthur Samuel defined machine learning as a "field of study that gives computers the ability to learn without being explicitly programmed". ML involves the study and construction of algorithms that can learn from and make predictions on data. These algorithms operate by building a model from a training set of example observations to make data-driven predictions or decisions expressed as outputs, rather than following strictly static program instructions.

Canonical correlation analysis (CCA) Factor analysis Feature extraction Feature selection Independent component analysis (ICA) Linear discriminant analysis (LDA) Multidimensional scaling (MDS) Non-negative matrix factorization (NMF) Partial least squares regression (PLSR) Principal component analysis (PCA) Principal component regression (PCR) Projection pursuit Sammon mapping t-distributed stochastic neighbor embedding (t-SNE)

AdaBoost Boosting Bootstrap aggregating (also "bagging" or "bootstrapping") Ensemble averaging Gradient boosted decision tree (GBDT) Gradient boosting Random Forest Stacked Generalization

Q-learning State–action–reward–state–action (SARSA) Temporal difference learning (TD) Learning Automata

Averaged one-dependence estimators (AODE) Artificial neural network Case-based reasoning Gaussian process regression Gene expression programming Group method of data handling (GMDH) Inductive logic programming Instance-based learning Lazy learning Learning Automata Learning Vector Quantization Logistic Model Tree Minimum message length (decision trees, decision graphs, etc.) Nearest Neighbor Algorithm Analogical modeling Probably approximately correct learning (PAC) learning Ripple down rules, a knowledge acquisition methodology Symbolic machine learning algorithms Support vector machines Random Forests Ensembles of classifiers Bootstrap aggregating (bagging) Boosting (meta-algorithm) Ordinal classification Conditional Random Field ANOVA Quadratic classifiers k-nearest neighbor Boosting SPRINT Bayesian networks Naive Bayes Hidden Markov models Hierarchical hidden Markov model

Bayesian knowledge base Naive Bayes Gaussian Naive Bayes Multinomial Naive Bayes Averaged One-Dependence Estimators (AODE) Bayesian Belief Network (BBN) Bayesian Network (BN)

Decision tree Classification and regression tree (CART) Iterative Dichotomiser 3 (ID3) C4.5 algorithm C5.0 algorithm Chi-squared Automatic Interaction Detection (CHAID) Decision stump Conditional decision tree ID3 algorithm Random forest SLIQ

Fisher's linear discriminant Linear regression Logistic regression Multinomial logistic regression Naive Bayes classifier Perceptron Support vector machine

Expectation-maximization algorithm Vector Quantization Generative topographic map Information bottleneck method Association rule learning algorithms Apriori algorithm Eclat algorithm

Feedforward neural network Extreme learning machine Convolutional neural network Recurrent neural network Long short-term memory (LSTM) Logic learning machine Self-organizing map

BIRCH DBSCAN Expectation–maximization (EM) Fuzzy clustering Hierarchical clustering k-means clustering k-medians Mean-shift OPTICS algorithm

Active learning Generative models Low-density separation Graph-based methods Co-training Transduction

Deep belief networks Deep Boltzmann machines Deep Convolutional neural networks Deep Recurrent neural networks Hierarchical temporal memory Generative Adversarial Network Style transfer Transformer Stacked Auto-Encoders

2. Related Work, Literature Survey & Algorithmic Foundations

Data Science: Data to Insights from MIT (machine learning) Popular online course by Andrew Ng, at Coursera. It uses GNU Octave. The course is a free version of Stanford University's actual course taught by Ng, see.stanford.edu/Course/CS229 available for free]. mloss is an academic database of open-source machine learning software.

This is a list of datasets for machine learning research. It is part of the list of datasets for machine-learning research. These datasets consist primarily of images or videos for tasks such as object detection, facial recognition, and multi-label classification.

Within the field of robotics, computer vision remains a significant barrier to progress, with many tasks hindered by inefficient vision systems. This research proposes a generalized vision module leveraging YOLOv9, a state-of-the-art framework optimized for computationally constrained environments like robots. The model is trained on a dataset tailored to the FIRA robotics Hurocup. A new vision module is implemented in ROS1 using a virtual environment to enable YOLO compatibility. Performance is evaluated using metrics such as frames per second (FPS) and Mean Average Precision (mAP). Performance is then compared to the existing geometric framework in static and dynamic contexts. The YOLO model achieved comparable precision at a higher computational cost then the geometric model, while providing improved robustness.

In computer vision, AI (Artificial Intelligence) powered frameworks have significantly increased performance in both speed and accuracy. Conventional object detection strategies have been rendered increasingly obsolete by object detection AI, such as CNNs (Convolutional Neural Networks). In robotics, applications of CNNs have remained limited due to their large computational cost on constrained systems. Machine learning frameworks typically require large datasets and a powerful GPU (Graphical Processing Unit) to achieve good performance. Robotic environments rarely have access to large amounts of memory, and their GPUs tend to be limited, or even non-existent. Recently, CNN frameworks have seen substantial performance improvements. Specifically, the latest YOLO (You Only Look Once) model, YOLOv9, outperforms almost every other framework in most aspects Wang et al. (2024) .

This paper presents the design and optimization of a lightweight, general-purpose vision module optimized for human robotics using YOLOv9. To evaluate its utility, we examine performance within the context of the FIRA (Federation of International Robot-Sports Association) Hurocup, a competition in which robots are tasked with performing visually intensive tasks such as archery, weightlifting, and basketball. The vision module is designed to run on a CPU-only platform, reflecting the limitations commonly found in humanoid robots

Our objectives are threefold : (1) assess whether YOLO-based detection can operate efficiently under the hardware constraints typical of humanoid robots; (2) compare its performance to traditional vision techniques; and (3) discuss the broader implications of integrating object detection frameworks in robotics. By demonstrating the viability of real-time YOLO-based detection on constrained systems, this work contributes to closing the gap between cutting-edge computer vision research and its deployments in field robotics.

Computer vision encompasses many subfields, with object detection being a critical area due to its growing relevance in real-time applications such as autonomous vehicles Arnold et al. (2019) , agriculture Wang et al. (2020) ; Salazar-Gomez et al. (2021) ; Khan and AlSuwaidan (2022) , surveillance Murugan et al. (2018) ; Angadi and Nandyal (2020) , and healthcare Ahmed et al. (2025) ; Wang et al. (2022a) . Modern object detection involves both classifying objects and localizing them with bounding boxes—tasks essential for systems requiring fast, accurate decisions.

Early methods relied on feature-based techniques like Histogram of Oriented Gradients (HOG), which showed high accuracy in pedestrian detection Suard et al. (2006) and facial recognition Déniz et al. (2011) . Scale-Invariant Feature Transform (SIFT) improved matching through keypoint detection Kasiselvanathan et al. (2020) ; Meng et al. (2013) , while Speeded-Up Robust Features (SURF) enhanced performance for real-time tasks Li et al. (2012) ; He et al. (2019) .

The rise of deep learning and convolutional neural networks (CNNs) revolutionized object detection. Two-Stage Detectors like Fast R-CNN emphasize accuracy and have shown success in pavement crack detection Xu et al. (2022) and facial expression recognition Li et al. (2017) . One-Stage Detectors, including SSD and the YOLO family, prioritize speed, making them ideal for real-time use.

While AI-powered vision has been widely applied in areas like surgical robotics Ai et al. (2023) and infrastructure monitoring Ward et al. (2021) , humanoid robotics lags behind. Most research in that domain emphasizes interaction and learning Kanda et al. (2002) ; Oztop et al. (2004) ; Bao et al. (2023) ; Hester et al. (2010) , rather than detection. This paper addresses that gap by developing a robust vision module suited for humanoid platforms, leveraging recent advances in real-time object detection.

The YOLO framework is a leading one-stage object detector used in both research and industry Chen et al. (2023) ; Hussain (2023) . As a CNN model, YOLO processes images through convolutional, pooling, and fully connected layers to detect and localize objects with labeled bounding boxes and confidence scores.

YOLOv1, introduced in 2015, pioneered the single-stage detection approach and achieved 45 FPS with 63.4% average precision (AP) Redmon et al. (2016) . YOLOv2 followed with major improvements, reaching 78.6% AP at 40 FPS Redmon and Farhadi (2016) , and YOLOv3 further refined the model in 2018 Redmon and Farhadi (2018) .

YOLOv4 (2020) introduced key techniques such as mosaic augmentation and drop block regularization Bochkovskiy et al. (2020) . Subsequent versions, including YOLOv5 and YOLOv6, enhanced performance further; YOLOv6 notably achieved 35.9% AP at 1234 FPS Li et al. (2022) . YOLOv7 improved both speed and accuracy Wang et al. (2022b) .

3. Dataset Ingestion, Preprocessing & Stochastic Augmentations

The latest version, YOLOv9, introduces programmable gradient information and the GELAN architecture, pushing the framework to new performance heights. Though widely adopted across domains, YOLOv9 has yet to be implemented on a humanoid robot.

Vision modules are critical to robotic systems, serving as the interface between sensory input and decision-making. Their primary function is to interpret visual data for tasks such as navigation and object detection. Earlier systems relied on classical techniques like segmentation, edge detection, and template matching. While effective in some cases, these methods struggle under real-world variability and noise. Recent advances in AI have greatly improved the adaptability and accuracy of vision modules, making research in this area crucial for modern robotics.

Classical approaches—such as color segmentation and template matching—were once standard for robotic vision Al-Jarrah et al. (2018) Hurtado and Valada (2022) . These methods are fast and require little processing power, but they lack robustness. Variability in lighting, background clutter, and object similarity can easily confuse such systems. For instance, similarly colored objects or reflective surfaces can lead to detection failures and hinder performance.

The emergence of deep learning revolutionized robotic vision. CNN-based frameworks like YOLO, Faster R-CNN, and SSD (Single-shot Detectors) allow for more precise detection in complex scenes Redmon et al. (2016) Liu et al. (2016) Ren et al. (2016) . These models, trained on large datasets, generalize far better than traditional methods. However, their implementation on robots introduces new challenges. Most robots lack GPUs, making real-time CPU inference difficult. Additionally, building large, diverse training datasets is time-consuming and resource-intensive. Variations in lighting, occlusion, and clutter still pose issues Kasiselvanathan et al. (2020) . Designing vision modules for humanoid robots thus requires carefully balancing accuracy, speed, and hardware constraints.

This research serves to address a critical gap in the intersection of Computer Vision, YOLO-based frameworks, and robotic vision. While YOLO has been extensively used for tasks such as autonomous driving and surveillance, its applications in humanoid robotics remain very limited. Current implementations of vision modules rely on task-specific configurations and traditional techniques. This can lead to struggles in tasks where a more generalized approach is required or in unpredictable environments such as FIRA competitions. This paper leverages YOLO to create a generalized vision module that balances efficiency and accuracy, enabling its deployment onto resource-constrained humanoid robots. This will contribute to the field by addressing the dual challenge of computational constraints and the lack of general-purpose vision solutions for humanoid robots. By employing various optimization tools and making the most of performance improvements, the YOLO framework might finally be accessible for humanoid robotics.

The humanoid robot used in this paper is the ROBOTIS-OP3 (See Fig. 1 ), a 51 cm tall, 3.5 kg platform equipped with 20 XM430-W350-R actuators and a Logitech C920 HD Pro Webcam. It’s powered by an 11.1V 1800mA LiPo battery or a direct cable connection. Minor modifications include 3D-printed plastic hands and feet. The OP3 runs ROS1 Kinetic, enabling smooth hardware interaction, while its computational efficiency and real-time processing make it suitable for object detection tasks. Local image processing reduces latency, though its modular architecture allows easy transition to external computing if needed. Connections can be made via a VNC client or an Ethernet cable.

As previously outlined, this project integrates the YOLO object detection framework into a humanoid robot to enable real-time detection within hardware constraints and ensure fast communication between vision and control systems. The software stack combines pre-trained models, open-source libraries, and middleware to maintain both flexibility and reproducibility. The implementation is built on the Robot Operating System (ROS) for its modular design and rich library support. ROS enables seamless integration of the camera, YOLO inference, and actuator control. Python is used for development, leveraging PyTorch and OpenCV—both essential for YOLO-based computer vision tasks.

YOLO was chosen for its strong balance between speed and accuracy. The latest version, YOLOv9, introduces Programmable Gradient Information (PGI) and the GELAN architecture, enhancing inference time and accuracy, making it well-suited for robotic deployment. This paper applies YOLO to three FIRA Hurocup events: Archery, Marathon, and Basketball. Table 1 shows an example of the objects used in training. In Archery, the model detects a moving target and fires an arrow at its center. In Marathon, the robot follows a red line and classifies directional arrow markers (left, right, forward), which may appear rotated. For Basketball, the robot detects an orange ball, retrieves it, locates a red net, approaches it, and shoots when close enough.

The training process begins with collecting and preprocessing task-specific datasets. To maintain performance and efficiency, multiple smaller models are trained for individual tasks rather than a single large one. Each dataset corresponds to specific FIRA Hurocup events—for example, balls and nets for basketball or arrow markers for the marathon (see Table 3.1). Datasets are annotated using bounding boxes in Roboflow’s YOLOv9 format, where labels include class ID and normalized bounding box coordinates. Roboflow also handles augmentation tasks—such as rotation, lighting changes, and scaling—to improve generalization Pellegrino et al. (2024) ; P et al. (2023) ; Gupta et al. (2023) .

Training was conducted using PyTorch on an Nvidia RTX 1650 GPU. Models were trained over 100 epochs with a batch size of six and a close mosaic threshold of 50. To avoid overfitting, a patience flag of five was set, halting training if no improvement occurred within five epochs—an optimal value determined through prior experimentation. Images were processed at 640×640 resolution, and training began from pre-trained MSCOCO weights Ultralytics (2024) . Three architectures were used: YOLOv9-Tiny, YOLOv9-Small, and YOLOv9-Medium—the most lightweight variants. Training was executed via command line on an external laptop to reduce onboard computational load.

The vision module integrates tightly with the Robot Operating System (ROS), ensuring seamless communication between the camera, inference pipeline, and OP3’s actuators. The architecture consists of three core components: the YOLO node, a listener node, and event-specific nodes.

Given the limited CPU power onboard OP3, real-time inference performance remains a challenge. To mitigate this, training is performed externally, while onboard inference is optimized using frame skipping and resizing inputs to 640×640 resolution. Since OP3 lacks a GPU, the YOLO model is converted to OpenVINO for CPU efficiency. This involves first converting the model to ONNX format, where quantization reduces computational load. The modular nature of ROS further allows for easy substitution or scaling with alternative detection models.

To ensure reliable performance, the new vision module will undergo comprehensive testing in both static and dynamic environments. Initial evaluations will take place in a controlled laboratory setting with minimal background interference and fixed lighting. From a stationary position, the robot’s ability to detect objects will be assessed in order to measure frame rate and latency in a reproducible environment.

4. Neural Network Backbone, Layer Specifications & Loss Formulations

Following static tests, the vision module will be evaluated in real-world conditions by completing three FIRA Hurocup events: Archery, Basketball, and Marathon. Performance will be assessed using quantitative metrics such as FPS, Precision, Recall, mAP50, and mAP50–95. Static and dynamic FPS measurements will help evaluate latency and consistency. Distance estimation will be tested by comparing the vision module’s output to a geometric approach and ground truth measurements. This comparison will highlight the system’s accuracy and its advantages over previous methods. Extended testing will ensure robustness and guide iterative improvements to detection accuracy in dynamic conditions.

The deployment of the YOLO model involved a lengthy training process, beginning with dataset preparation and culminating in real-time inference. The dataset was composed of no more than 150 images per class to attain a balance between speed and accuracy. The data sets were manually labeled using RoboFlow to help the model focus on key objects, such as basketballs or arrow markers. Data augmentation techniques such as rotation, shear, exposure adjustment, and Gaussian blur were applied to improve overall robustness.

For real-time inference, a video feed is captured through the ROBOTIS-OP3’s webcam. Each captured frame was processed using a letterbox resizing function to maintain the image’s aspect ratio while fitting the required input size (640px x 640px). Several techniques were utilized to help optimize the model for a CPU-based inference, including model conversion into OpenVINO format. The bounding boxes are drawn only if they are over a confidence threshold, and non-max suppression (NMS) is applied to filter overlapping bounding boxes, retaining only the most accurate detections. Bounding boxes were then scaled back to the original image dimensions, correcting for the webcam’s aspect ratio and avoiding distorted bounding boxes. This step was crucial to ensure accurate placement of detections in the video feed. OpenCV 4.11 was used to draw bounding boxes and display class labels on the detected objects, along with a confidence score.

The YOLO object detection system is implemented using two separate ROS nodes due to Python version incompatibilities. ROS Kinetic requires Python 2.7, whereas YOLOv9 and its dependencies (e.g., PyTorch) need Python 3.8 or newer. To resolve this, the detection node runs in a Python 3.12 virtual environment, isolated from ROS. A second node—the listener node—operates in Python 2.7 and receives the detection results via WebSocket through a ROS bridge. This bridge enables seamless communication between the two environments.

The detection node performs inference using PyTorch and Ultralytics’ YOLOv9, sending bounding box data as JSON messages over WebSocket. Each JSON includes object class, coordinates, size, and confidence score. OpenCV 4.11 is used to overlay detections on the video feed for debugging. The node also includes a cleanup routine to release camera resources and close WebSocket connections on shutdown.

This dual-node architecture ensures modern deep learning tools can be used without disrupting ROS compatibility. The modular design promotes maintainability and scalability, allowing future upgrades to the detection pipeline without altering the core ROS control structure.

The new vision module is integrated into the robot’s framework using a structured pipeline built on ROS architecture. This setup enables efficient data exchange between the vision system and behavioral modules, particularly for FIRA events, allowing real-time object detection to drive robot actions.

The main implementation challenge stemmed from YOLO’s Python 3 requirement conflicting with ROS Kinetic’s Python 2.7. To solve this, a WebSocket bridge was created to connect a Python 3.12 virtual environment (hosting the YOLO node) with the ROS system. Initial setup issues—such as the virtual environment defaulting to Python 2.7 libraries like OpenCV 3.3.1 and PIP—were resolved by restructuring the environment with the –no-site-packages flag. This allowed the isolated vision node to communicate with the ROS system without dependency conflicts.

The YOLO vision node sends detection data as JSON messages over WebSocket. These are received by a listener node, which repackages the data into ROS-compatible messages. This decoupled, asynchronous communication ensures low-latency performance—critical for the fast reactions required in FIRA events.

Optimizing the YOLOv9 model is essential to achieving real-time performance on the ROBOTIS-OP3’s CPU-only system. Several strategies—frame skipping, input resizing, model conversion, and quantization—were employed to reduce inference latency while preserving detection accuracy.

One of the most effective methods was frame skipping. Rather than processing every incoming frame, the system processes every nth frame, where n is a configurable parameter. This significantly reduces computational load while maintaining responsiveness, allowing the robot to track and react to objects without overloading the CPU. Another crucial optimization was input resizing. Camera frames are downscaled to 640×640 pixels—the native YOLO input size—prior to inference. This ensures efficient processing without unnecessary high-resolution computations, speeding up preprocessing and inference while retaining detection reliability. To further reduce inference time, the YOLOv9 model was converted from PyTorch to ONNX (Open Neural Netowrk Exchange), and then from ONNX to OpenVINO, Intel’s toolkit optimized for CPU performance. The ONNX conversion ensures model portability, while OpenVINO accelerates inference by leveraging CPU-specific instructions and pruning redundant operations. Finally, quantization was applied to reduce model size and inference time. PyTorch’s quantization tools lowered weights and activations from 32-bit floats to 8-bit integers.This step greatly decreased memory usage and sped up matrix operations—the core bottleneck of inference.

Together, these optimizations enable the YOLOv9 system to function efficiently within OP3’s hardware limitations. By combining model-level and hardware-specific techniques, the system strikes a strong balance between speed and accuracy, allowing real-time object detection in demanding robotic environments.

Training the YOLOv9 models was a crucial step in ensuring high detection accuracy while maintaining real-time performance. For this implementation, nine models were trained—three per FIRA event—using the YOLOv9-Tiny (T), Small (S), and Medium (M) architectures. This multi-model strategy allowed for a balance between accuracy and speed, essential for deployment on the limited hardware of the ROBOTIS-OP3. To improve model accuracy, all models employed weights that were pre-trained on the MSCOCO dataset. These weights can be found at Ultralytics (2024) . Additionally, all models were trained with a patience of 5, as to avoid overfitting. Results for the training can be found in Table 2

5. Training Protocol, Convergence Behavior & Experimental Evaluation

For this implementation, nine models were trained—three per FIRA event—using the YOLOv9-Tiny (T), Small (S), and Medium (M) architectures. This multi-model strategy allowed for a balance between accuracy and speed, essential for deployment on the limited hardware of the ROBOTIS-OP3.

Training results varied by event. In the Basketball event, all three models achieved high scores across mAP, precision, and recall metrics, indicating strong generalization and reliable detection across frames.

In contrast, Archery models exhibited mixed results. Despite high recall and mAP0.5, the mAP0.5–0.95 scores varied significantly. This, along with elevated recall scores, suggests overfitting: the models successfully identify targets seen during training but fail to generalize well to new data. Further investigation or dataset augmentation may be necessary to improve their robustness.

The Marathon models performed the weakest overall, showing lower mAP and precision across all three architectures. While recall remained relatively high, the models struggled with classification accuracy. This was largely due to the similar appearance of visual markers used in the event, particularly the left and right arrows, which the models frequently confused. Analysis of the confusion matrix in Fig. 4 confirmed this as a consistent error pattern.

The primary limiting factor in model performance was dataset generalization. Given the OP3’s limited computing resources, the training dataset had to be kept small to allow for real-time inference. This constraint often led to overfitting, with models memorizing training samples rather than learning robust feature representations. Although this tradeoff limited accuracy in complex events such as Marathon, it was necessary to preserve real-time operability.

Given the superior performance in terms of frame rate and efficiency, the Tiny (YOLOv9-T) models were selected for deployment. They offered the best balance of speed and acceptable accuracy, making them ideal for the real-time requirements of the robot’s vision system. Benchmark tests, conducted with all optimizations applied and with no objects in view, confirmed that the Tiny models consistently delivered the highest frame rates under idle conditions (see Table 3 ). As such, the performance tests for the YOLO Vision Module will be conducted using the YOLOv9-T models. Future work may focus on leveraging transfer learning or lightweight augmentation strategies to enhance model generalization without sacrificing speed.

Two distinct types of experiments were conducted to evaluate the performance of the YOLOv9 module in a robotic setting: a static test and a dynamic test. These tests aim to measure the system’s inference speed, real time performance, and accuracy in a controlled setting and in an active use case. Additionally, both tests will be compared to the geometric approach currently implemented on the robot. This is to serve as a baseline for assessing the vision based model’s effectiveness. All tests will be conducted inside the LIMRL as shown in Fig. 5

The static test isolates the vision system’s performance by processing frames while the robot remains stationary. Key metrics include inference time and frames per second, providing a baseline for real-time feasibility and computational load. The dynamic test evaluates the system under operational conditions, where the robot uses its vision module to interact with its environment. This reveals how movement, lighting, and real-time demands affect detection and responsiveness.

Both tests are compared to a geometric baseline that uses color segmentation and rule-based logic. This comparison quantifies the trade-offs between speed, accuracy, and practicality, helping assess the benefits of the YOLO-based system in robotic applications.

In the static experiments (see Table 4 ), the YOLOv9 models were able to record comparable precision levels to those achieved by the existing geometric model. In the marathon event, the YOLO model has exceeded the precision levels of the geometric model. While the YOLO model made more consistent detections, it frequently confused arrow marker types, resulting in false detections. Therefore, the number of true detections achieved by the YOLO module is likely closer to the geometric model than the numbers show.

In terms of FPS, the geometric approach still achieves better performance, sometimes reaching speeds 50% faster than the YOLO module. Even with the optimizations, the YOLO module still performs much slower than the geometric one, however, the YOLO module has several key advantages. Frameworks like YOLO don’t require any calibration post-training, unlike the current color-segmentation-based approach, which requires a lengthy fine-tuning period to achieve good results. Secondly, through data augmentation, the YOLO module is much more resistant to environmental changes. Dataset augmentations, such as brightness or rotation adjustments, allow YOLO to achieve a level of robustness that the geometric approach cannot match. While the geometric approach often struggles with background noise (See Fig. 6 ), the YOLO node ignores it completely.

In terms of performance, the dynamic experiment produced results similar to those of the static experiment (see Table 5 ). The FPS is lower for both modules; however, the gap in between them remains similar. The exception to this is the marathon event, where the YOLO module can compete with the geometric module because in the marathon event, the geometric module is required to process more complex tasks to detect the arrow markers.

Precision varies drastically between events due to their various requirements. In basketball, the YOLO module outperformed the Geometric module. The geometric module for basketball previously used contour detection, and it struggles with detecting spherical objects due to variances in lighting conditions. The ball detection is set up into two different segmentations and combined to account for the light; however, the approach remains cumbersome. The YOLO module is much better equipped to deal with this variability. In Archery, both modules performed similarly, and in Marathon, the Geometric module outperformed the YOLO module. Marathon requires the detection of arrow markers, and the YOLO module has a hard time differentiating between marker types. Figure 7 shows the output from the basketball event.