Project Goal

We are developing an autonomous drone system capable of landing on a moving platform across six different simulated environments: CITY, MOUNTAIN, WAREHOUSE, FOREST, VILLAGE, and OPEN. The drone operates fully autonomously using onboard perception, navigation, and control logic under strict timing constraints and noisy sensor conditions. The objective is to achieve highly reliable navigation and precision landing performance across all environments while maintaining stability and generalization.

Challenge 1: False Positive Platform Detection

The drone uses a depth-camera combined with an ONNX-based neural network for visual platform detection. One of the biggest issues is false positives: the detector sometimes classifies rooftops, flat terrain, or building surfaces as valid landing platforms. When this happens, the navigation stack immediately redirects toward an incorrect target, often leading to collision or mission failure.

Approaches Tested

• Increasing confidence thresholds (0.40 → 0.55)
  • Reduced false positives but also blocked legitimate detections
• GPS proximity gating
  • Helped slightly but failed because GPS measurements contain significant positional noise
• XY spatial filtering
  • Reduced extreme outliers but still allowed plausible false detections
• Z-plausibility constraints
  • Rejected underground or unrealistic altitude predictions

Core Problem

Both the GPS estimate and neural network predictions contain noise and uncertainty. A filter strict enough to eliminate false positives also suppresses valid detections, while a permissive filter allows incorrect target acquisition. The unresolved challenge is determining how to reliably distinguish true targets from visually similar structures when confidence, position, and altitude all appear plausible.

Challenge 2: Transition Instability During Navigation Entry

The simulator terminates episodes when drone tilt exceeds 60°. In several scenarios, the drone crashes roughly 2 seconds after launch, specifically during the transition from vertical takeoff into horizontal navigation.

Root Cause

The velocity controller receives an abrupt command transition:

[0, 0, 0.7]
→
[2.37, 1.44, 1.14]

This sudden directional acceleration causes transient PID overshoot, resulting in excessive tilt.

Approaches Tested

• Global speed caps
• Horizontal/vertical ratio limits
• Mandatory cruise states before navigation
• Minimum cruise duration constraints
• Progressive speed ramps

Core Problem

Scenarios that require immediate navigation need aggressive early movement, while unstable seeds require smoother transitions. Any delay introduced to stabilize one class of scenarios negatively impacts time-critical cases.

Challenge 3: Altitude Estimation in Mountain Environments

In mountain environments, the moving platform operates at significantly higher altitude, while GPS altitude measurements remain noisy and unreliable. The estimated platform height converges gradually through EMA smoothing, causing the drone to initially target incorrect altitudes during approach.

Effect

The drone may spend critical early navigation time flying below the platform, resulting in missed intercept windows or timing out before successful landing.

Approaches Tested

• Altitude hold strategies
• Fixed cruise-height logic
• Natural EMA convergence

Core Problem

Aggressive altitude correction destabilizes perception and navigation, while gradual convergence delays interception too long for the mission horizon.

Challenge 4: Benchmark vs Real Evaluation Mismatch

The local simulator does not perfectly replicate all deployment environments. Several environments must currently be approximated, meaning local benchmark scores do not consistently reflect real-world evaluation performance.

Effect

Systems that perform well locally may underperform under the full evaluation distribution due to differences in environmental dynamics and challenge composition.

Challenge 5: Regression Cycles

The most difficult engineering challenge so far has been regression behavior:

Fixing one scenario frequently breaks another.

Examples include:

• Stabilizing tilt transitions while reducing navigation speed too much
• Improving false-positive filtering while blocking legitimate detections
• Increasing safety margins while destroying approach efficiency

This indicates the system is becoming overly reactive to local heuristics rather than maintaining globally stable trajectory behavior.

Current Engineering Insight

The emerging conclusion is that the primary bottleneck is no longer perception quality or basic navigation capability, but control-state stability. High-performing systems appear to rely heavily on temporal consistency, smooth behavioral transitions, damping mechanisms, hysteresis, and trajectory commitment rather than frame-by-frame reactive decision-making.

The next major architectural focus is therefore shifting toward:

• trajectory stability
• temporal commitment behavior
• smooth state transitions
• predictive interception
• control-layer stabilization

rather than simply adding more heuristics or reward shaping.

Current Stack

• Autonomous flight controller (drone_agent.py)
• ONNX-based visual perception
• Depth-camera navigation
• Physics simulation using pybullet-drones
• Multi-stage learning pipeline (imitation learning + reinforcement learning)
• Custom local benchmarking framework

This project has evolved from a simple navigation experiment into a full hybrid robotics and learning system combining perception, control theory, reinforcement learning, and trajectory stabilization under noisy real-time conditions.

Project Goal

We are developing an autonomous drone system capable of landing on a moving platform across six different simulated environments: CITY, MOUNTAIN, WAREHOUSE, FOREST, VILLAGE, and OPEN. The drone operates fully autonomously using onboard perception, navigation, and control logic under strict timing constraints and noisy sensor conditions. The objective is to achieve highly reliable navigation and precision landing performance across all environments while maintaining stability and generalization.

Challenge 1: False Positive Platform Detection

The drone uses a depth-camera combined with an ONNX-based neural network for visual platform detection. One of the biggest issues is false positives: the detector sometimes classifies rooftops, flat terrain, or building surfaces as valid landing platforms. When this happens, the navigation stack immediately redirects toward an incorrect target, often leading to collision or mission failure.

Approaches Tested

• Increasing confidence thresholds (0.40 → 0.55)
  • Reduced false positives but also blocked legitimate detections
• GPS proximity gating
  • Helped slightly but failed because GPS measurements contain significant positional noise
• XY spatial filtering
  • Reduced extreme outliers but still allowed plausible false detections
• Z-plausibility constraints
  • Rejected underground or unrealistic altitude predictions

Core Problem

Both the GPS estimate and neural network predictions contain noise and uncertainty. A filter strict enough to eliminate false positives also suppresses valid detections, while a permissive filter allows incorrect target acquisition. The unresolved challenge is determining how to reliably distinguish true targets from visually similar structures when confidence, position, and altitude all appear plausible.

Challenge 2: Transition Instability During Navigation Entry

The simulator terminates episodes when drone tilt exceeds 60°. In several scenarios, the drone crashes roughly 2 seconds after launch, specifically during the transition from vertical takeoff into horizontal navigation.

Root Cause

The velocity controller receives an abrupt command transition:

[0, 0, 0.7]
→
[2.37, 1.44, 1.14]

This sudden directional acceleration causes transient PID overshoot, resulting in excessive tilt.

Approaches Tested

• Global speed caps
• Horizontal/vertical ratio limits
• Mandatory cruise states before navigation
• Minimum cruise duration constraints
• Progressive speed ramps

Core Problem

Scenarios that require immediate navigation need aggressive early movement, while unstable seeds require smoother transitions. Any delay introduced to stabilize one class of scenarios negatively impacts time-critical cases.

Challenge 3: Altitude Estimation in Mountain Environments

In mountain environments, the moving platform operates at significantly higher altitude, while GPS altitude measurements remain noisy and unreliable. The estimated platform height converges gradually through EMA smoothing, causing the drone to initially target incorrect altitudes during approach.

Effect

The drone may spend critical early navigation time flying below the platform, resulting in missed intercept windows or timing out before successful landing.

Approaches Tested

• Altitude hold strategies
• Fixed cruise-height logic
• Natural EMA convergence

Core Problem

Aggressive altitude correction destabilizes perception and navigation, while gradual convergence delays interception too long for the mission horizon.

Challenge 4: Benchmark vs Real Evaluation Mismatch

The local simulator does not perfectly replicate all deployment environments. Several environments must currently be approximated, meaning local benchmark scores do not consistently reflect real-world evaluation performance.

Effect

Systems that perform well locally may underperform under the full evaluation distribution due to differences in environmental dynamics and challenge composition.

Challenge 5: Regression Cycles

The most difficult engineering challenge so far has been regression behavior:

Fixing one scenario frequently breaks another.

Examples include:

• Stabilizing tilt transitions while reducing navigation speed too much
• Improving false-positive filtering while blocking legitimate detections
• Increasing safety margins while destroying approach efficiency

This indicates the system is becoming overly reactive to local heuristics rather than maintaining globally stable trajectory behavior.

Current Engineering Insight

The emerging conclusion is that the primary bottleneck is no longer perception quality or basic navigation capability, but control-state stability. High-performing systems appear to rely heavily on temporal consistency, smooth behavioral transitions, damping mechanisms, hysteresis, and trajectory commitment rather than frame-by-frame reactive decision-making.

The next major architectural focus is therefore shifting toward:

• trajectory stability
• temporal commitment behavior
• smooth state transitions
• predictive interception
• control-layer stabilization

rather than simply adding more heuristics or reward shaping.

Current Stack

• Autonomous flight controller (drone_agent.py)
• ONNX-based visual perception
• Depth-camera navigation
• Physics simulation using pybullet-drones
• Multi-stage learning pipeline (imitation learning + reinforcement learning)
• Custom local benchmarking framework

This project has evolved from a simple navigation experiment into a full hybrid robotics and learning system combining perception, control theory, reinforcement learning, and trajectory stabilization under noisy real-time conditions.

Hello mga boss. Nag-build kami ng football event detector na may strict na 30-second inference budget per 30-second clip. Ganito ang pipeline:

1. YOLO (TensorRT) → sparse ball + player positions
2. Lucas-Kanade Optical Flow → fill-in sa mga frames na na-miss ng YOLO
3. PCHIP interpolation → trajectory reconstruction
4. Kinematic peak extraction → velocity spike = event candidate
5. Semantic classifiers → cos_sim, angle to goal, player proximity → final label

Problem 1 — False positives sa conf=0.450 (floor value) Palagi kaming nag-ge-generate ng 4-5 candidates na clustered sa 5-frame window, lalo na sa frames 15-100. Conf=0.450 lang lahat — ibig sabihin barely qualified. Kailangan naming malaman kung paano ma-distinguish ang "setup motion" (players nagpapaposisyon, free kick setup) at "actual event contact." Anong heuristic ang maganda dito?

Problem 2 — Missed GT events sa dense na scenes Sa mga situation na maraming players malapit sa goal (penalty box situations), palagi naming nami-miss ang GT events sa frames 250-400 kahit ~50% ang ball detection namin. Paano ba magbo-boost ng sensitivity sa high-density areas nang hindi nadadagdagan ang false positives?

Problem 3 — Timing error na ±1-2 seconds Nahahanap namin ang tamang region ng event pero 25-50 frames ang layo ng aming prediction sa actual GT frame. Ginagamit namin ang backward offset mula sa kinematic peak. May mas magandang paraan ba para ma-snap ang exact contact frame mula sa velocity curve?

Problem 4 — Ang pinakainteresting: mas magaling ang model sa malayo na bola kaysa sa malapit Paradox ito — kapag malayo ang bola sa camera (maluwag ang view, maliit ang bola sa frame), mas stable ang aming detection. Kapag malapit ang bola, mas maraming false positives at mas mataas ang timing error. Ang hypothesis namin: kapag malayo, mabagal ang pixel velocity at mas clean ang PCHIP curve. Kapag malapit, napakabilis ng pixel velocity at nagiging chaotic ang trajectory reconstruction. May paraan ba para i-compensate ang ganitong perspective distortion nang hindi kailangan ng full camera calibration / homography?

Lalong interesado kami sa Problem 4 kasi parang ito ang root cause ng maraming ibang issues namin. Salamat!

Hi everyone. I'm building a football event detector that runs on a strict 30-second inference budget per 30-second clip (1080p, 750 frames). The pipeline is layered:

1. YOLO (TensorRT) → sparse ball + player positions
2. Lucas-Kanade Optical Flow → fills gaps between YOLO detections
3. PCHIP interpolation → smooth trajectory reconstruction
4. Kinematic peak extraction → velocity spikes + acceleration = event candidates
5. Semantic classifiers → cos_sim, angle_to_goal, player proximity → final event label

Problem 1 — False positives at low confidence (conf=0.450 floor) We keep generating 4-5 candidates clustered in a 5-frame window at conf=0.450 (our floor value), particularly in frames 15-100. These are likely camera shake, free kick setup, or player repositioning — not real events. What's the best heuristic to distinguish "setup motion" from "event-triggering contact"?

Problem 2 — Missed GT events, especially in dense scenes In penalty-box situations (players clustered near goal), we consistently miss events at frames 250-400 despite having ~50% ball detection rate. Is there a principled way to boost sensitivity in high-player-density regions without introducing more FPs elsewhere?

Problem 3 — Timing error of ±1-2 seconds We detect the right event region but our predicted frame is 25-50 frames early or late. Our current approach: apply a backward offset from the kinematic peak (estimated by velocity). Is there a better way to snap to the actual contact frame from a velocity curve?

Problem 4 — The detection paradox (far balls detected better than near balls) Strangely, our pipeline detects events more reliably when the ball is far from the camera (wide-angle, small in frame) than when it's nearby. Our hypothesis: when the ball is far, its pixel velocity is slow and structured, giving clean PCHIP curves. When it's nearby, pixel velocity is high and chaotic, creating noisy trajectory reconstructions. Does anyone have experience compensating for this perspective-dependent velocity distortion without full camera calibration/homography?

Any insights appreciated — especially on Problem 4 which feels fundamental to single-camera sports analytics.

Hi everyone. I'm building a football event detector that runs on a strict 30-second inference budget per 30-second clip (1080p, 750 frames). The pipeline is layered:

1. YOLO (TensorRT) → sparse ball + player positions
2. Lucas-Kanade Optical Flow → fills gaps between YOLO detections
3. PCHIP interpolation → smooth trajectory reconstruction
4. Kinematic peak extraction → velocity spikes + acceleration = event candidates
5. Semantic classifiers → cos_sim, angle_to_goal, player proximity → final event label

We're getting partial scores (~5-20%) and consistently hitting four problems:

Problem 1 — False positives at low confidence (conf=0.450 floor) We keep generating 4-5 candidates clustered in a 5-frame window at conf=0.450 (our floor value), particularly in frames 15-100. These are likely camera shake, free kick setup, or player repositioning — not real events. What's the best heuristic to distinguish "setup motion" from "event-triggering contact"?

Problem 2 — Missed GT events, especially in dense scenes In penalty-box situations (players clustered near goal), we consistently miss events at frames 250-400 despite having ~50% ball detection rate. Is there a principled way to boost sensitivity in high-player-density regions without introducing more FPs elsewhere?

Problem 3 — Timing error of ±1-2 seconds We detect the right event region but our predicted frame is 25-50 frames early or late. Our current approach: apply a backward offset from the kinematic peak (estimated by velocity). Is there a better way to snap to the actual contact frame from a velocity curve?

Problem 4 — The detection paradox (far balls detected better than near balls) Strangely, our pipeline detects events more reliably when the ball is far from the camera (wide-angle, small in frame) than when it's nearby. Our hypothesis: when the ball is far, its pixel velocity is slow and structured, giving clean PCHIP curves. When it's nearby, pixel velocity is high and chaotic, creating noisy trajectory reconstructions. Does anyone have experience compensating for this perspective-dependent velocity distortion without full camera calibration/homography?

Any insights appreciated — especially on Problem 4 which feels fundamental to single-camera sports analytics.

I’m frustrated with the result of my braces treatment. I had braces for a long time and only got them removed 2 years ago because my dentist said my teeth were already stable and okay. Before treatment, I had a severe overbite, but now it feels like my upper teeth are slowly becoming overbite again. What disappoints me more is that my lower front teeth started separating, even though I trusted the advice that I no longer needed a retainer for the bottom teeth. I even asked about getting retainers for both upper and lower teeth, but I was told the lower one was unnecessary because my teeth had already stabilized for so long with the wire. Looking back now, I regret not insisting more because I’m unhappy with how my teeth are shifting again after all those years of treatment.

Hey everyone. I’m currently participating in a challenging CV competition focused on fine-grained football (soccer) event detection. The task is to accurately timestamp and classify semantic events like passes, interceptions, tackles, clearances, and blocks within 30-second 1080p clips 750 frames. The catch: there is a strict 30-second inference timeout limit.

I’m running this entirely on a local RTX 3060 (12GB VRAM). Because I can't run heavy 3D-CNNs or massive tracking transformers, my pipeline is heavily layered and engineered for efficiency:

1. Lightweight YOLO (via TensorRT) extracting sparse ball/player coordinates.
2. Kinematic smoothing (PCHIP interpolation) to reconstruct trajectories.
3. Mathematical gating (velocity drops, acceleration spikes, trajectory angles, player proximity) to extract temporal event candidates.

Right now, my raw ball detection rate hovers around 40-50% due to motion blur and occlusions, but my temporal extraction logic is solid enough that I'm staying competitive. However, the top leaderboard scorers are only averaging around 30% accuracy themselves, which tells me they are likely using brute-force compute (A6000s/A100s) with heavy temporal models (VideoMAE, SlowFast, etc.), yet still struggling because the semantic reasoning is just fundamentally hard.

My question for the veterans here: Is there a hard "compute ceiling" I am going to hit?

I’m currently planning to bridge my 40% detection gap by integrating Lucas-Kanade Optical Flow to track the ball between sparse YOLO detections (essentially zero VRAM cost), and then using a lightweight DINOv2 linear probe strictly on the extracted temporal peaks to verify player pose semantics (e.g., kicking vs. contesting).

In your experience, can clever, layered engineering (Optical Flow + Kinematics + targeted zero-shot pose verification) actually beat brute-force temporal action models in the long run? Or will the raw VRAM advantage of tracking and processing every single frame perfectly always win out in these types of dense-action tasks? Would love to hear your grounded perspectives.

https://preview.redd.it/2lye1zum9z0h1.jpg?width=1024&format=pjpg&auto=webp&s=fccda1cd3a423ceb15d964de24ff751bda7e4422

Hi r/PinoyProgrammer

We're building a real-time football (soccer) event detection pipeline. Given a 25-second 1080p clip, we must detect and classify ~3 temporal events (kick, pass, shot) within a strict 30-second total budget (network download + inference + post-processing).

Current Pipeline

Ball Detection:

• YOLOv8 (TensorRT FP16) @ 640px input
• Tile-based: split 1920×1080 into two 1080×1080 overlapping tiles
• Detection rate: ~60–82% of frames (varies per clip)
• Missing frames filled with PCHIP interpolation (physics-like smooth curves)

Player Detection:

• YOLOv8 (TensorRT FP16) @ 640px
• Extracts jersey color patch (upper torso) for team classification
• Simple proximity tracker (IOU-free, distance-based at 120px threshold)

Event Classification (kinematic):

• Velocity = ‖pos[i] - pos[i-1]‖ smoothed with 5-frame moving average
• Peak detection: local max with min rise/fall of 2.0 px/frame
• Ball-player proximity: contact_strength = accel × contact_score
• Shot vs Pass: angle-to-goal proxy, density scoring, goal-direction vector

The Problem

On some clips, Primary extract returns 0 events even though the video clearly has action:

Ball detection rate: 123/750 (16%)  ← was using 6fps sampling
Primary extract: 0 events []
Detected 2 events: ['pass', 'pass']  ← FALLBACK only
Challenge time: 9.6s ✅ (under 30s budget)
Score: 5% (top 5 miners)

Root cause we identified:

• We were sampling every 5th frame (6fps effective) to reduce inference time
• PCHIP over 5-frame gaps smooths out sharp velocity spikes
• A kick lasting 3-4 frames becomes invisible at 6fps → zero kinematic candidates

After switching to all-frame processing (30fps), timing is ~16s total (still under budget), but we need to validate accuracy improvement.

Visualization

Ball Trajectory and Velocity Profile

Top: Ball trajectory with PCHIP interpolation (cyan) over sparse detections (red). Bottom: Velocity profile with detection thresholds — at 6fps sampling, peaks get smoothed below the min_vel=8 threshold.

Questions

1. Sparse detection + interpolation: Is PCHIP the best choice for filling missing ball positions? We've seen it create phantom velocity peaks between real kicks (double-counting). Any papers on ball trajectory interpolation in sports video?
2. Kick/pass/shot classification: Our current heuristic uses angle-to-goal + ball velocity + player proximity. What's the simplest temporal model that could improve this without breaking our 30s budget? (Optical flow? Lightweight LSTM on ball trajectory?)
3. Contact detection: We use bounding box proximity (ball centroid within 120px of player box) as a proxy for contact. Any better approach that doesn't require a separate contact detection model?
4. Velocity thresholds: Our min_vel=8 px/frame (at 30fps, 640px input). Is there a principled way to calibrate this across varying video quality and camera zoom levels?

Stack: Python, YOLOv8, TensorRT FP16, OpenCV, PCHIP (scipy), custom kinematic classifier

Thanks!

Current pipeline is mostly:

• pretrained football detectors
• tracking + interpolation
• velocity/acceleration peak analysis
• temporal gating
• rule-based event selection

At this stage the architecture is relatively stable already, but the remaining bottlenecks are more semantic than detection-related.

Main issues:

1. Bounce/aerial-ball continuation occasionally triggering false “pass” events because motion physics still looks valid.
2. Dense passing sequences becoming over-suppressed after tightening anti-hallucination filters.
3. Smooth real passes sometimes getting rejected after adding trajectory validation gates.
4. Multi-ball confusion in some clips causing tracking jumps between detections.

We recently added:

• local-density-aware trajectory gating
• temporal ball consistency selection
• field-zone filtering
• interpolation-aware validation

Question:
For people using rule-based or physics-heavy pipelines (not full transformer architectures), what lightweight strategies worked best for:

• validating true player-ball contact
• balancing dense-event recall vs false-positive suppression
• handling smooth valid passes without reopening hallucination problems

Would especially appreciate practical debugging insights from real sports CV pipelines.

Current pipeline is mostly:

• pretrained football detectors
• tracking + interpolation
• velocity/acceleration peak analysis
• temporal gating
• rule-based event selection

At this stage the architecture is relatively stable already, but the remaining bottlenecks are more semantic than detection-related.

Main issues:

1. Bounce/aerial-ball continuation occasionally triggering false “pass” events because motion physics still looks valid.
2. Dense passing sequences becoming over-suppressed after tightening anti-hallucination filters.
3. Smooth real passes sometimes getting rejected after adding trajectory validation gates.
4. Multi-ball confusion in some clips causing tracking jumps between detections.

We recently added:

• local-density-aware trajectory gating
• temporal ball consistency selection
• field-zone filtering
• interpolation-aware validation

Question:
For people using rule-based or physics-heavy pipelines (not full transformer architectures), what lightweight strategies worked best for:

• validating true player-ball contact
• balancing dense-event recall vs false-positive suppression
• handling smooth valid passes without reopening hallucination problems

Would especially appreciate practical debugging insights from real sports CV pipelines.

Hi everyone, I’m currently building a football event detection project focused on detecting actions like passes and shots from match clips using computer vision. I’m self-taught and honestly not a traditional programmer — I mostly learned through experimentation, OpenCV/YOLO resources, and AI-assisted coding workflows.

Right now the system uses:

• YOLO ball/player detection
• interpolation + velocity/acceleration analysis
• kinematic peak detection
• player proximity filtering
• temporal event selection

The main challenges I’m facing are:

• false positives from bounces/camera motion
• distinguishing real ball contact vs acceleration spikes
• pass vs shot classification
• timing calibration (early/late event anchoring)

I’m trying to improve the model step-by-step instead of endlessly rewriting it. I’d really appreciate advice from people experienced in:

• sports CV
• OpenCV
• tracking systems
• action/event detection
• signal processing for video

I’m not asking anyone to build it for me — I genuinely want to learn the correct engineering mindset and avoid bad architecture decisions. Even high-level advice, debugging strategies, or recommended papers/resources would help a lot. Thanks!

P.S The remaining problems are more about semantic filtering and event selection quality: reducing false positives, improving shot/pass judgment, and making the model stricter about which motion peaks should count as real football events. In short, the foundation is already there; what we are doing now is refining behavior, cleaning noisy selections, and stabilizing the decision logic based on real challenge data.

https://preview.redd.it/9377776hlhzg1.jpg?width=2048&format=pjpg&auto=webp&s=daf00fb74cc12b4052e62fc71bc961dd44568af4

Hi guys, hingi lang sana ako ng advice sa mga may experience sa computer vision or sports analytics.

Gumagawa kasi ako ngayon ng football event detection project na nagde-detect ng events like pass and shot from match clips. Self-taught lang ako at hindi talaga traditional programmer, more on natututo lang habang ginagawa using OpenCV, YOLO, docs, forums, at minsan AI tools din.

Sa ngayon ang gamit kong approach:

• YOLO for ball/player detection
• interpolation + velocity/acceleration analysis
• kinematic peak detection
• player proximity checks
• temporal event selection

Ang pinaka struggle ko ngayon:

• false positives kapag may bounce or mabilis camera pan
• hirap i-distinguish yung real ball contact vs random acceleration spikes
• pass vs shot classification
• timing calibration (minsan sobrang aga or late ng detected event)

Napapansin ko rin minsan sobrang sensitive ng shot logic ko lalo na sa youth football clips where most actions are actually just passes.

Hindi ako naghahanap ng magbu-build ng project para sakin. Gusto ko lang talaga matuto ng tamang workflow at mindset sa pag-debug ng ganitong klaseng system kasi pakiramdam ko minsan paikot-ikot na lang ako kakapalit ng logic. Kahit high-level advice lang, recommended resources, papers, or debugging techniques malaking tulong na sakin. Thank you po sa makakatulong.