Estimating crowd size by eye is notoriously hard. I've found a CNN called P2PNet to detect heads of people and created a custom pipeline to detect occluded people and reconstruct an approximate 3d scene.

Pipeline overview

1. P2PNet detection gives 2D head points
2. Depth Pro (Apple's metric monocular depth model) gives metric Z per pixel
3. Head points are back-projected to world-space XYZ using depth + focal length
4. RANSAC fits the dominant ground plane from the head point cloud
5. World scale is corrected for based on max. real-world crowd density of 6.5ppl/m2
6. Shadow-offset DBSCAN clusters the crowd — offset centers are computed per-person by projecting their occlusion shadow forward, which bridges the gaps that appear between rows of people at depth due to sparse data and the low camera angle.
7. Alpha shapes (Delaunay + circumradius threshold) trace concave hulls around each crowd cluster; interior voids naturally emerge as obstacle holes
8. From the DBSCAN densities-per-point a heatmap is created + missing region densities are interpolated and occluded people are populated using Poisson sampling

The shadow-offset trick (step 6) is the part I haven't seen elsewhere. DBSCAN breaks crowd clusters at depth because row-to-row gaps exceed the search radius. My original idea was a pill-shaped search area, but shifting each person's search center to the midpoint between their actual position and their shadow tip with search radius scaling linearly with depth is faster, and also reconnects those rows.

Output

The frontend renders a density-zoned map over the image: detected people, auto-generated obstacle polygons (holes in the alpha shape), occlusion shadow zones with predicted counts, and a confidence interval. AI assumptions are editable objects — the analyst can delete clusters, override predicted densities. I'm currently working on extending this to boundary editing and placing a POI to adjust the attenuation model. Modifications are logged to an audit trail that ships with the export.

Known limitations

- Ground plane assumption breaks on stairs and tiered seating (RANSAC fit flagged when inlier ratio < 60%)
- Single image only at this stage — video fusion is the next thing I'm building
- My method doesn't model crowd dynamics at an individual's scale — to calculate real individual positions an iterative approach may be needed which goes against optimizing for speed

Resources

- evolving blog post with up-to-date info: https://www.balazshimself.com/blog/crowd-predictor
- MVP tool: https://www.crowdcounting.net

Any feedback is welcome! Thanks for your time!

Somebody suggested this subreddit for this problem, I hope it is relevant.

https://imgur.com/a/RHUmoFz

I want to calculate the speed of this man's kick by measuring the distance his foot travels and dividing it by the time it takes. I know that the speed is written on the video, but I want to confirm it because it vastly exceeds the speeds from studies I've read. Max speed in studies is sub 20 m/s. This guy is kicking over 60 m/s.

Finding the time it takes for him to kick is easy enough.

Finding the distance is very difficult for me. I know that the guy's height is about 180 cm from an interview, and I think I can somehow use that information to solve my problem. I'm not sure though, and I don't want to waste my time on something that can't be done. So, is it doable?

If it isn't possible you can ignore the rest of the post.

Is there a software for doing this? Either free or cheap.

My idea (obviously can be wrong): use one of the first frames where he is standing to find what 180 cm looks like in a part of the frame. His knees are bent, so I have to first find how it would look in the frame if he was standing. I think this can be done with geometry. Since the camera is steady, I can copy the 180 cm line to the other frames. Then I approximate the arc of the kick by measuring a few small straight distances that the kick travels, frame by frame, and adding them.

I tried to do this for a few hours and didn't make any progress. So I kindly ask for help on how to solve this problem.

Alternatively, has AI gotten good enough to solve this kind of problem? Which AI could I use in that case?

I built a local AI video analytics PoC that analyzes uploaded videos and generates structured reports from the scene.

The system focuses on scene-level understanding rather than only basic object detection. It can report signals such as people density, movement patterns, zone activity, crossing behavior, forgotten-item candidates, and safety-event candidates like fall or lying-still behavior.

The goal was to create a review-oriented workflow where the system highlights possible events, generates a risk score, and produces visual/report-based outputs for human review.

It does not make final security decisions. The detected events are treated as candidate signals that should be reviewed by an operator.

For the test workflow, I intentionally used mixed video scenes to evaluate how the system handles pedestrian flow, object-related events, safety-event candidates, and scene transitions. Optional portfolio link : www.linkedin.com/in/brkndc

ofc meta would drop a dope model on a friday afternoon and have me scrambling to integrate it over my birthday weekend

you can quickly get started with the model in fiftyone by following the steps in this repo: https://github.com/harpreetsahota204/vggt_omega

I like spending my free time testing new AI tools and seeing where they might fit into real computer vision workflows. This time I experimented with synthetic training data generation for Driver Monitoring Systems using Seedance 2.0.

The inspiration came from Vision Banana: https://vision-banana.github.io/

The idea that really caught my attention is simple but powerful: many vision tasks can be represented as RGB outputs. A segmentation mask, an instance mask, a depth map, or another dense prediction target can all be treated as an image-like output.

So I tried to apply this thinking to video.

The workflow:

1. Generate a realistic synthetic driver monitoring video
2. Use the same video to generate a semantic segmentation mask
3. Use the same video to generate an instance segmentation mask
4. Combine the outputs into a dataset-like structure

The mosaic video shows the result:

RGB video + semantic mask + instance mask, aligned frame by frame.

The scene is a fictional driver gradually becoming drowsy behind the wheel. This kind of scenario is useful for DMS development, but difficult to collect and annotate at scale with real-world data.

Of course, generated annotations still need QA. They are not perfect ground truth.

But for prototyping, rare-case simulation, and early dataset generation, this feels like a very promising direction.

The interesting part is that the final output is not just a nice synthetic video. It can become structured training data:

• RGB frames from the generated video
• semantic classes from the semantic mask
• object regions and bounding boxes from the instance mask
• YOLO / COCO-style annotations after post-processing

I wrote a more detailed blog post about the experiment here:

https://www.antal.ai/blog/synthetic_dms_training_data.html

Put your reference image (what you want)
Type your prompt
Run

My next step is turn those pixels into vectors. Already working on it, if anyone has advice, I'm all ears

Learning about YOLO and Biomechanics was quite the wild ride.

I posted last week about an upgrade to my repo YoloLite. I have now decided to launch V2 directly via PyPI! You can test it out right now with a simple pip install yololite and help me find bugs and benchmark the models.

Everything is Apache 2.0, and the weights are automatically downloaded from GitHub on demand.

You can either use the API directly via Python or run everything via the CLI:

yololite mode=predict model=yololite_cs3_m.pt source=test.jpg conf=0.4 save=True
yololite mode=train model=yololite_mnv4_s.pt data="data.yaml" epochs=30 workers=4

I have pretrained a total of 9 models across 3 different lightweight backbones:

• CS3Darknet backbone: yololite_cs3_n.pt | yololite_cs3_s.pt | yololite_cs3_m.pt
• MobileNetV4 backbone: yololite_mnv4_n.pt | yololite_mnv4_s.pt | yololite_mnv4_m.pt
• HGNetV2 backbone: yololite_hg2_n.pt | yololite_hg2_s.pt | yololite_hg2_m.pt

The models have been pretrained on the official COCO-minitrain_25k dataset. (Check out their official repo for more info on the Pearson correlation coefficients between full COCO and minitrain).

Currently supported export formats include ONNX and TensorRT. The framework also supports post-export validation to ensure stability and mAP consistency after deployment.

Would love to get your feedback and bug reports!

PyPI: pip install yololite

I built an open-source traffic digital twin tool that works from just:

• CCTV footage
• Google Maps imagery

Project:
https://github.com/duy-phamduc68/TrafficLab-3D

It includes:

• staged camera calibration
• object detection/tracking
• speed + orientation estimation
• synchronized CCTV + satellite visualization with 3D/floor boxes

Still has a lot of limitations (planar assumptions, occlusion problems, manual calibration workload), but I wanted to release it openly anyway and iterate from feedback.

FFGear provides direct, transparent access to the full FFmpeg Decoder feature-set, including:

• Hardware-Accelerated Decoding — GPU-powered decoding with CUDA/CUVID and other hardware-accelerated backends 
• Flexible Pixel Formats — support for any FFmpeg pixel format (e.g., bgr24, yuv420p, gray) with optional OpenCV compatibility patches for YUV/NV layouts.
• Per-Frame Metadata Extraction — asynchronous frame metadata extraction through the showinfo filter.
• Live Complex Filtergraphs — support for live simple and complex FFmpeg filter pipelines.
• Wide Source Support — capture USB, virtual, and IP camera feeds by index similar to OpenCV, along with support for multimedia files, image sequences, desktop screen capture, and network streams (HTTP(s), RTSP/RTP, etc.).

Get Started here: https://abhitronix.github.io/vidgear/latest/gears/ffgear/

Hey guys,

With robotics growing so fast, first-person (egocentric) vision is becoming a massive domain in CV on its own. If robots are ever going to help us in the real world, they need to understand how humans handle objects from our own perspective.

I've been deep in experimentation mode and performing some test with CV model on egocentric video from scratch on everyday simple tasks (annotation -> model training -> implementation)!

For this project, I focused on a simple, everyday task: opening and closing a bottle cap. Here is a quick look at the video showing the real-time tracking and state changes in action:

• Data Annotation: I started by capturing raw egocentric footage. To get clean bounding boxes for the bottle and cap across the sequence, I used Labellerr. It made handling the frame-by-frame labeling smooth and kept the dataset precise.
• Model Training & Tracking: I paired object detection for the assets (bottle and cap) with hand skeleton tracking to map exactly how the fingers grasp and interact with the objects.
• State Logic Building: Once the spatial coordinates were tracking properly, I built a custom state machine logic on top of it. The system actively differentiates between IDLE, OPENING THE BOTTLE, and CLOSING THE BOTTLE based on hand-to-object intersections and hand velocity.

This is one of many examples i am experimenting with egocentric video (feel free to suggest some ideas regarding it)

Would love to hear your thoughts! Are any of you working on egocentric datasets or robotics perception pipelines right now? What are the biggest bottlenecks you’re running into with first-person data?

Resouces:
- video: link
- code: link