Generally, developing this type of detection system is very easy. You might want to lynch me for saying this, but the biggest challenge is integrating these detection modules into multiple IP cameras or numerous cameras managed by a single NVR device. This is because when it comes to streaming, a lot of unexpected situations arise, and it took me about a month to set up this infrastructure. Now, I can integrate the AI modules I've developed (regardless of whether they detect or track anything) to send notifications to real-time cameras in under 1 second if the internet connection is good, or under 2-3 seconds if it's poor.

resources: youtube, code, blog

- player and number detection with RF-DETR

- player tracking with SAM2

- team clustering with SigLIP, UMAP and K-Means

- number recognition with SmolVLM2

- perspective conversion with homography

- player trajectory correction

- shot detection and classification

This is pit stop a Video from the recent Singapore GP.

You'll notice that video shows a seemless transition between 2 camera angles: One besides the pit and the other being the top mounted camera on car.

When this video was posted on F1 subreddit, most people guess the transition to be GenAI generated. Some theorized it to be Gaussian Splatting.

I tried to do some amateur research and found that none of the FIA, FoM, Liberty Media (all F1 authorities) have made any statements about what they use.

I also didn't find any other articles explaining about such F1 videos.

Ultimately I fed the video to Claude and ChatGPT for explanation and Got this:

Claude: My best guess: the fly-in is a 3D Gaussian-splat reconstruction of the pit box, with the virtual camera ending at the real onboard camera and cross-faded into the live onboard feed. There may be a little AI clean-up on top, but it doesn’t look like the move was generated by AI. F1 hasn’t said publicly how it’s done, so this is a reading of the footage, not a confirmed answer.

ChatGpt: This looks more like a virtual-camera transition using 3D reconstruction and image-based interpolation than a purely generative AI video. Gaussian Splatting is a plausible technique, but the footage alone doesn't establish that it was used.

So looks like Claude And ChatGpt are just two redditors giving their hypothesis.

Any experts here who might be able to provide a better answer?

Guys, I need help. We have a project using YOLOv8. We're trying to count chicks on a very fast conveyor belt. The challenges we're facing are: all chicks look very similar to each other, which complicates tracking. At the same time, during their passage under the camera, they constantly change in size and shape, which can cause the tracker to lose them, or detection may even disappear completely at the detection line. Also, sometimes 2–3 chicks can merge into a single object. The detection zone is very short, and the conveyor speed is high. We've achieved a maximum accuracy of 99%, but we need it even higher. Any ideas on how to achieve that? Increasing the dataset no longer helps.

I'm attaching an old video. We've now added lighting and set the exposure to 300 on the Hikrobot global shutter camera, but we still can't achieve a stable 99.8% accuracy for the reasons mentioned above.

Any ideas?

Made a tracker for small aerial targets. Its free to use, for now I would like to get some feedback on it. SDKs are in python and node. Runs 30+ fps on Rasp pi 4 (not yet tested on zero) https://sky-tracker.dev

Disclosure up front: I build road inspection tooling, which is why there's a logo in the corner. This is a weekend experiment, not a product demo.

Setup: one drive at about 40 km/h on a rural road in the Netherlands.

Top half is dashcam footage with a detection model flagging road damage per frame (cracks, patches, crack sealing), plus signs and posts for context. Bottom half is vertical acceleration from the GoPro's own accelerometer at 200 Hz, pulled from the metadata track in the MP4, high-passed above 1 Hz, with a 0.25 s RMS as a roughness line.

The catch is that the camera sees the damage before the wheels hit it. I cross-correlated a "damage in view" score against the roughness signal and took the best lag of about 1.75 s. The dashed line in the video marks that moment: what is in view now reaches the wheels there. The correlation is weak, r around 0.23, but the shape lines up better than I expected for a single pass.

Questions for people who actually do this:

1. How do you use accelerometer or IMU data for road condition? IRI-style indices, per-event thresholds, or something learned from data?

2. How do you deal with speed and vehicle differences? Same pothole, different car, completely different shock.

3. Has anyone fused the visual and the vibration side, for example using vibration to confirm or rank what the camera flagged?

🚀 Excited to share my latest project: Real-time Abandoned Object Detection using YOLOv11n! 🎥🧳

I implemented YOLOv11n to automatically detect and track abandoned objects (like bags, backpacks, and suitcases) within a Region of Interest (ROI) in a video stream. This system is designed with public safety and surveillance in mind.

Key highlights of the workflow:

✅ Detection of persons and bags using YOLOv11n

✅ Tracking objects within a defined ROI for smarter monitoring

✅ Proximity-based logic to check if a bag is left unattended

✅ Automatic alert system with blinking warnings when an abandoned object is detected

✅ Optimized pipeline tested on real surveillance footage⚡

A crucial step here: combining object detection with temporal logic (tracking how long an item stays unattended) is what makes this solution practical for real-world security use cases.💡

Next step: extending this into a real-time deployment-ready system with live CCTV integration and mobile-friendly optimizations for on-device inference.

As someone who has also been working on their own Apple Watch app for fitness, I’ve been curious about what computer vision might offer that wearables / IMUs might not. It’s been interesting to see the knee shape and ankle path visualizations as unique examples of what computer vision could offer.

Maybe you realize you are stepping too far ahead by seeing the knee visualization, and you adjust your stride length accordingly. The ankle visualization can be used to measure variance and highlight moments of fatigue or technique breakdown. A quantitative tool like this could provide unique insights to help improve your running.

I used ViTPose+ Large through the VLM Run Gateway for pose estimation, and used this to derive the running metrics.

This demo is a first attempt at running analysis. Runners, I would love to hear your feedback for what types of visualizations you’d like to see next!

The code is open-source on GitHub! Link in the comments.

Hey r/computervision! Alex ( u/MrPorkchop720 ) and I have been building something a bit unusual and we wanted to share it here.

It's LeNet-1, the 1989 convolutional network from LeCun et al., rebuilt as a physical object. Every one of its 4,624 neurons gets its own individually addressable LED, and each activation is mapped to LED brightness, so you can actually watch how LeNet-1 "thinks" as the signal propagates through it.

On the build itself, the network is made from transparent PCBs, low iron tempered glass, aluminium profiles, and 3D printed SLA parts in two resins, SLA-9600 and transparent SLA-8001. We designed the boards in EasyEDA and had them fabricated at JLCPCB (a quick word of thanks to the JLC team. They helped throughout the design to fabrication process, and even backed the project so we could build it despite a tight budget).

Here's a short video of it running.

The piece was selected as one of 12 spotlight works from 114 submissions for the CVPR 2026 Art Gallery, and it won the IEEE TCPAMI Art Award. We'd hoped to show it in person at CVPR in Denver, but it's still sitting in customs, so this video is the closest we can get you for now.

We're happy to answer anything on the architecture, the activation to LED mapping, or the fabrication.

Here are some relevant links!

Project: https://socius-org.github.io/artefacts/

CVPR 2026 Art Gallery: https://thecvf-art.com/project.php?year=2026&artist=nick-oh&id=992

YouTube: https://www.youtube.com/watch?v=QGxGXySgqCI

I came across ViTPose a few weeks ago and uploaded some fight footage to their hugging face hosted model. I want to iterate on this and start doing some fight analysis but not sure how to go about isolating the fighters.

As you can see, the audience and the ref are also being detected.

The footage was recorded on an old school camcorder so not sure if that will make things more difficult.

Any suggestions on how I can go about this?

Most object-detection guides expect you to learn Python before you’re allowed to touch computer vision.

For Java devs who just want to explore computer vision without learning Python first - checkout my YOLO11 + OpenCV video object detection in plain Java.

(ok, ok, there still will be some Python )) )

It covers:
• Exporting YOLO11 to ONNX
• Setting up OpenCV DNN in Java
• Processing video files with real-time detection
• Running the whole pipeline end-to-end

Code + detailed guide: https://github.com/vvorobiov/opencv_yolo

I’m currently developing a real-time AI-integrated system. While building the attendance module, I realized how vulnerable generic recognition models (like MobileNetV4) are to basic photo and screen attacks.

To address this, I spent the last month experimenting with dedicated liveness detection architectures and training a standalone security layer based on MiniFAS.

Key Technical Highlights:

• Model Size & Optimization: I used INT8 quantization to compress the model to just 600KB. This allows it to run entirely on the CPU without requiring a GPU or cloud inference.

• Dataset & Training: The model was trained on a diversified dataset of approximately 300,000 samples.

• Validation Performance: It achieves ~98% validation accuracy on the 70k+ sample CelebA benchmark.

• Feature Extraction logic: Unlike standard classifiers, this uses Fourier Transform loss to analyze the frequency domain for microscopic texture patterns—distinguishing the high-frequency "noise" of real skin from the pixel grids of digital screens or the flatness of printed paper.

As a stress test for edge deployment, I ran inference on a very old 2011 laptop. Even on a 14-year-old Intel Core i7 2nd gen, the model maintains a consistent inference time.

I have open-sourced the implementation under the Apache for anyone wants to contribute or needing a lightweight, edge-ready liveness detection layer.

I’m eager to hear the community's feedback on the texture analysis approach and would welcome any suggestions for further optimizing the quantization pipeline.

suriAI/face-antispoof-onnx: Ultra-lightweight (600KB) Face Anti-Spoofing classifier. Optimized MiniFASNetV2-SE implementation validated on 70k+ samples with ~98% accuracy for edge devices.

I've been building a road-condition mapping pipeline that takes raw dashcam footage and produces georeferenced crack inventories. This clip shows the result on a 200 m segment.

The pipeline goes from frame "where is this on the world map, and how much damage is in it":

• per-frame instance segmentation of pavement damage (crack, repair, etc.)

• ground-plane fitting from monocular depth + lateral fit anchored on cadastral road edges

• inverse-perspective projection (IPM) of every pixel of every detection mask, so a curving crack stays curved on the map (not just a bbox center)

• 5 m forward window per frame so 5 m frame stride = unique coverage, no double-counting

Output is a geojson + shapefile with class, polyline, length per detection. The video shows the live view, the cumulative meters, and a CartoDB basemap with the actual track-up of detections.

Where I'm stuck and would love input:

1. Plane fit drifts past ~10 m forward. Monocular depth is unreliable that far out, so my road-edge measurements collapse and I cap the linear-X correction at depth ≤ 7 m. Anyone with a robust strategy for trusting depth past ~15 m on outdoor dashcam scenes?

2. Polygon-on-bend geometry. The cadastral road polygon at intersections is one big blob, so my "lateral position within road" check breaks. I'm tempted to switch to centerline geometry but that's a separate ingest pipeline. Have others solved this with a vector approach?

3. IPM in general. I barely ever see IPM discussed on this sub. Is it largely abandoned in favor of other approaches, or is anyone here still actively working with it? Would really like to hear from people with hands-on experience.

Automated crack detection on a road in Cyprus using AI and GoPro footage.

What you're seeing: 🔴 Red = Vertical cracks (running along the road) 🟠 Orange = Diagonal cracks 🟡 Yellow = Horizontal cracks (crossing the road)

The histogram at the top grows as the video progresses, showing how much damage is detected over time. Background is blurred to keep focus on the road surface.

https://huggingface.co/nvidia/LocateAnything-3B

https://github.com/NVlabs/Eagle

demo

https://huggingface.co/spaces/nvidia/LocateAnything

Finetuning a computer vision system for automated road damage detection from GoPro footage. What you're seeing:

• Detection of 4 asphalt defect types (cracks, patches, alligator cracking, potholes)

• Progressive histogram overlay showing cumulative detections over time

• 199 frames @ 10 fps from vehicle-mounted GoPro survey

• 1,672 total detections with 80.7% being alligator cracking (severe deterioration)Technical details:

• Detection: Custom-trained model on road damage dataset

• Classes: Crack (red), Patch (purple), Alligator Crack (orange), Pothole (yellow)

• Visualization: Per-frame histogram updates with transparent overlay blending

• Output: Automated detection + visualization pipeline for infrastructure assessment

The pipeline uses:

• Region-based CNN with FPN for defect detection

• Multi-scale feature extraction (ResNet backbone)

• Semantic segmentation for road/non-road separation

• Test-Time Augmentation

The dominant alligator cracking (80.7%) indicates this road segment needs serious maintenance. This type of automated analysis could help municipalities prioritize road repairs using simple GoPro/Dashcam cameras.

Posting an update here with simplified PCB and robustness. Mighty Camera runs VIO on-device in a tiny package. But for it to be useful, you need things like mapping (and later occupancy, loop closure etc).

Here is a demo of lightweight mapping which uses VIO pose from Mighty and generates a semi-dense map on host-side in realtime.

It’s early but this will be part of the SDK along with other goodies.