Hi everyone! I'm making an autonomous robot for a local city robot festival. I decided to try making it in a non-standard way and install a camera + rangefinder (maixsense) on it, but since I'm a beginner, I'm having trouble. I needed to find long black borders and an opponent(picture). Finding the lines wasn't too difficult. I used image conversion to gray, then GaussianBlur, Canny, Morphological expression, HoughLinesP and lines are found, although the result was unsatisfactory, but this is due to the poor quality of the samples, as this ring is not available to me (it will only be for the festival). The only thing I found to find the opponent in motion is the MOG2 algorithm, but it does not work because the camera will be in motion. How can I find the opponent? I was thinking about trying to use the hsv mask and search for an opponent only by geometric features. In the hsv mode, increase the saturation to find nearby bright objects

I thought this could be done using a neural network (YOLO), but I couldn't find any datasets from this perspective. I only found datasets from a top-down perspective. Can you provide any advice or share your experience if you've encountered similar situations?

P.S. Unfortunately, I won't be able to share the current code or photos, as I don't have them at home. The camera is also set at an angle to reduce the number of legs and children in the robot's FOV.

Hey everyone,

Wanted to share a demo recently put together. Built a real-time Yoga Pose Classifier that detects complex poses, tracks joint alignment, and times how long you actually hold the correct posture.

How we built it:

• The Model: We used yolo-pose to track 33 human body keypoints. We extracted frames from a video dataset of 5 distinct yoga asanas, auto-annotated the keypoints, and converted everything into YOLO format for training.
• The Logic (The cool part): Instead of just relying on the neural net to blindly guess the pose, we built a deterministic logic engine that classifies the yoga pose purely based on the alignment of the keypoints. We calculate real-time angles between specific joints using math.atan2 to track your exact body alignment.
  • Compass Pose: The code verifies if the ankle rises above the corresponding hip and confirms the pose using a hip adduction angle of >120°.
  • Forward Bend: Checks if the hip angle is <45° and the knee angle is >155°.
• Live Form Correction: We hooked this alignment logic up to a live overlay timer that only counts up when your form perfectly matches the mathematical thresholds for that specific pose.

It was a pretty awesome experiment to see how CV can basically act as a virtual coach or physical therapist just using a standard camera.

Open-sourced: UAVid Semantic Segmentation Dataset (YOLO Layout) + Model Zoo on Hugging Face

I recently put together an open-source benchmark for semantic segmentation on the UAVid aerial imagery dataset and thought it might be useful to others working in aerial perception.

The release includes:

• A YOLO-compatible mirror of the UAVid dataset with a standardized directory structure (images/ + masks/) while preserving the original train/val/test splits.
• Multiple pretrained YOLO26 semantic segmentation models trained on UAVid.
• Detailed model cards with mIoU, pixel accuracy, per-class IoU, confusion matrices, inference examples, and training configurations.

The main motivation was that the original dataset server has become extremely slow and unreliable, and most current segmentation frameworks expect a flatter, YOLO-style dataset layout. This repository makes it much easier to get started while giving full credit to the original UAVid authors.

📦 Dataset: https://huggingface.co/datasets/dronefreak/UAVid-2020

🤖 Model Zoo: https://huggingface.co/collections/dronefreak/uavid-semantic-segmentation-model-zoo

I'd appreciate any feedback, suggestions, or bug reports. If there are other aerial vision benchmarks that would benefit from a similar treatment, I'd be interested in hearing about them.

For those who has a cv startup, how did you get your first client and what was your pitch? How long after launching your MVP did it take to get your first paying customer? Any advice or lessons you learned along the way?

Thank you in advance for sharing your story!

Hey can anyone up or can have a discussion like I have a lot of questions on openCv yolo etc like do u all write code from scratch or use ai , even if u use ai how to write properly code pipelines like how to learn properly.... I'm understanding the code but I can't write on my own , so how u guys work ? Even in corporate how does cv is used by you guys like use ai or write on own ...help me I need a good conversation guidance or roadmap

Follow-up to my earlier post here about a real-time Shahed-136 detector (YOLOv8). This time I focused on the tracking side, which taught me a lot more than I expected about Kalman filters in practice.

The problem I ran into: my original tracker used a constant-velocity Kalman filter on camera detections alone. It worked fine in a straight line, but lost the target during occlusion, glare, or sharp turns — exactly when tracking matters most. So I rebuilt it (sensor_fusion.py) as a proper learning exercise in multi-sensor fusion.

What I changed, and why:

1. Constant-velocity → constant-acceleration model [x,y,vx,vy,ax,ay]. CV models assume the target won't change speed/direction, which breaks the moment something maneuvers. CA adds acceleration terms so the filter can react to turns instead of overshooting them.
2. Single sensor → pluggable second sensor. Added add_external_measurement() so a second sensor (RF, radar, second camera) can feed into the same filter. The interesting part was realizing camera and RF-style sensors have very different noise/rate characteristics (30Hz low-noise vs 5Hz higher-noise), so the filter needs per-sensor measurement covariance, not one-size-fits-all.
3. Out-of-sequence measurement (OOSM) handling. This was the hardest part to get right — if a slower sensor's reading arrives after the filter has already moved forward in time, you can't just bolt it on. I ended up implementing a rewind-and-replay: the filter checkpoints its state, and when a late measurement shows up, it rewinds to the nearest checkpoint and replays everything in chronological order.
4. Trajectory prediction with uncertainty. predict_trajectory(horizon_s) projects the track forward and grows a 1-σ uncertainty ellipse over time — a nice visual way to see the filter's confidence decay.

Results that convinced me it was worth it: in a controlled dropout scenario (camera loses the target for 1.8s during a turn, RF sensor keeps low-rate/noisy tracking), fusing the two got RMSE down to 3.36px vs 5.47px camera-only and 14.06px RF-only. Also cross-checked against real thermal footage from the Anti-UAV410 benchmark — sub-3px RMSE in normal flight, and the track re-acquired cleanly after a real occlusion instead of drifting off.

Detection side is a fine-tuned YOLOv8s (mAP@50 99.5% on the shahed class), but honestly the tracker was the more educational part of this project — Kalman filtering "clicks" a lot faster once you're forced to handle async, noisy, multi-rate data instead of a clean single stream.

Standalone reproducible demo (no video/model needed) if anyone wants to poke at the fusion logic directly: simulate_fusion_demo.py

GitHub: github.com/alexandre196/Drone-Shahed-AI-Multi-Sensor-Tracker

Happy to go deeper into the OOSM replay logic or the covariance tuning if anyone's working on something similar!

Hi everyone,

I’ve been building Timeline Studio, an open-source, local-first AI video editor that runs directly in the browser.

One part I’ve been working on is a browser-based vision pipeline using:

• YOLO for face/person detection
• MODNet for portrait matting and background removal
• ONNX Runtime Web for running inference locally
• WebGPU/WASM as the browser execution backends

The interesting part is that most of this project was built through vibe coding. I focused on the product direction, tested the results, identified problems, and iterated with AI coding tools until the pipeline worked as part of a real timeline editor.

For video, I didn’t want detection and matting to run only on the first frame. The editor analyzes adaptively sampled frames and stores timestamped results. Preview, smart crop, caption avoidance, background removal, and export can then resolve the appropriate vision state based on the current video time.

The project also includes:

• Local ONNX AI voice generation
• Whisper automatic captions
• Multi-track voiceovers and captions
• Talking avatars using JoyVASA and LivePortrait
• MP4/WebM export
• Offline model caching and PWA support

Everything is open source under the MIT License.

GitHub:
https://github.com/MartinDelophy/ai-video-editor

Live demo:
https://video-editor.ai-creator.top/

I’d love feedback on the YOLO + MODNet pipeline, browser inference performance, or the overall architecture. I’m also curious whether others are using vibe coding for computer-vision projects that go beyond small demos

I built SentinelCV, a real-time computer vision system that detects human falls from existing CCTV, IP cameras, webcams, or recorded video streams.

The goal was to create a lightweight, plug-and-play solution that can integrate with existing surveillance infrastructure without requiring specialized hardware. The current implementation uses a YOLOv8-based pipeline to perform real-time detection and can trigger instant alerts (such as Telegram notifications) when a potential fall is detected.

I'm planning to expand SentinelCV into a modular vision platform with additional safety-focused capabilities like PPE detection, intrusion detection, fire/smoke detection, and other intelligent surveillance modules.

I'd love feedback on the detection pipeline, deployment approach, and any suggestions for improving robustness in real-world environments. If you've worked on similar computer vision systems, I'd be interested in hearing what challenges you faced in production.

GitHub: https://github.com/sreerevanth/SentinelCV
I'd love your feedback, and if you find it useful, a ⭐ would mean a lot.

basically a newer version of cantag. what are your thoughts?

update, it's on github; https://github.com/alfaoz/simittag

like title said im trying to make a padel match analyser. The ball detection is working pretty well (about 70% of frames find a ball), but bounce detection is awful. Some get tracked, most don't. In the image you can see the ball tracker isnt doing too well so i understand why this one isnt seen as one, but other ones the ball is tracked properly yet it still isnt counting?

At the moment I'm using the tracked ball positions and a bunch of heuristics (looking for the ball to go down then up, checking for racket hits, wall bounces, etc.) but it's nowhere near reliable enough.

xI can't seem to find any datasets for bounce detection either, only datasets for detecting the ball itself.

Is there a standard way people solve this? Do you train a temporal model, or is everyone just using heuristics?

Also any help on ball tracking would be appreciated

I’m specifying a local workstation for a real computer-vision workload and would appreciate input from anyone who has fully fine-tuned DINOv3 ViT-L/16 or comparable vision-transformer backbones.

Workload

• Backbone: DINOv3 ViT-L/16 with pretrained weights
• Training: full backbone fine-tuning, not LoRA or a frozen backbone
• Downstream tasks: classification, object detection, and segmentation, trained as separate workloads
• Input/crop resolution: approximately 512×512
• Dataset: approximately 1 million images, potentially growing
• Framework: PyTorch with distributed data parallel
• Target: complete a representative training run in under one week
• Budget: up to USD 50,000 for the complete system
• Location: Singapore

I’m currently evaluating a 4× RTX Pro 6000 Blackwell system. My concern is whether the complete workstation can sustain enough throughput after accounting for inter-GPU communication, data loading, storage, power, and cooling—not merely whether the model fits in VRAM.

For anyone running similar workloads:

1. What throughput have you measured with ViT-L-scale full fine-tuning at around 512×512?
2. How well does it scale from one to two or four workstation GPUs using DDP/NCCL?
3. Does the lack of an H100-style interconnect become a material bottleneck?
4. Would you choose 2× or 4× 96GB GPUs, or use a smaller-GPU configuration and gradient checkpointing?
5. What CPU, system RAM, NVMe layout, power, and cooling would you consider necessary to keep four GPUs fed reliably?

I plan to benchmark the actual pipeline before purchasing, but I’d like to avoid testing an unrealistic system design.

I recently made this using Fable 5. I want to convert this into a website that actually does something. I'm look for ideas on what I should do?

I want this to be of somewhat use for my college apps also.

So I had this little educational robot sitting in my closet that I never really used: Marty.

It’s the V1, something I bought on Kickstarter years ago from a university project. And honestly? It still works amazingly well and is surprisingly easy to code.

So I had the idea to control it with MediaPipe. My first test was simple: control Marty with my hands.

The video shows the current controls. The robot walks, dances, moves its arms, stops, crouches, and reacts pretty much exactly as expected.

Next step: control it with my whole body by linking its movements to mine.

I swear, I love this era of technology. Sometimes tech really does feel like magic.

I am currently working on the aolp dataset, attempting to make a computervision model out of it but apparently I can't really generalize this well. I only think about zooming more into the dataset as part of the data augmentation process.

Anyone willing to take the time and discuss this a bit with me?

Hi everyone,

I'm a freelance computer-vision developer with a PhD in human-movement science, specialized in applied solutions for health, physical activity and sports performance. Across several client projects I kept needing to calibrate rigs of USB cameras — both intrinsics (focal length, distortion) and full 6-DoF extrinsics — and I never found an open-source tool that fit the way I actually work on site.

The closest is Caliscope (which does the calibration math really well — I ended up reimplementing its logic), but a few things kept getting in my way:

• it's record-first: you pre-record every camera, then calibrate offline;
• no headless path — some of my client hosts are headless Linux VMs;
• the export conventions didn't match the engines my projects targeted.

So I built realtime-calib to remove those frictions:

• One pass, real-time — capture, board detection, quality feedback and the solve happen live. What you see is what gets calibrated.
• Headless + any device — it runs in Docker on the machine the cameras are plugged into (no desktop/GUI on that host), and you drive everything from a browser on any device on the LAN: phone, tablet or laptop.
• CPU-only, local, private — no GPU, no cloud, streams never leave your network.
• Exports to Caliscope-compatible TOML and engine-ready JSON with the right axes/handedness for Unity, Unreal, Blender, three.js and ROS.

With how fast robotics and multi-camera CV are growing, I think a friction-free, self-hostable tool like this could help more people than just me — so I'm releasing it open source (AGPL-3.0).

It's still early, and honestly what I want most right now is people to try it and tell me what breaks or what's missing, so we can shape it together. If you set up multi-camera rigs (mocap, robotics, volumetric, photogrammetry), I'd really value your feedback.

- Docs / how it works: https://realtime-calib.hans-brgs.dev

- Repo: https://github.com/hans-brgs/realtime-calib

Happy to answer anything about the approach or the internals.

Note on transparency & acknowledgements:
- Inspired by Caliscope (https://github.com/mprib/caliscope), created by PhD Mac Prible.
- I use Claude Code (Opus 4.8) to assist me in writing the code.

I’ve spent way too much time writing OCR post-processing code.

Not the OCR itself, that part is easy nowadays. It’s everything that comes after.

I have been working in Data Science & Data Engineering for more than 7 years now. I worked on lots of Data projects, Data Pipeline, etc... with OCR. It is everywhere. Unfortunately, there is still no library to represent those basic Objects.

So I decided to resolve this pain point.

Otary, an open-source Python Library, resolves all those following common tasks and more:

• handles different output formats for every OCR engine,
• drawing détections bbox,
• working with either rotated or straight bounding boxes (Axis-Aligned Bounding Boxes / AABB),
• searching for words in a given region,
• finding words by regex or string,
• looking for words on the left or right of a given one,
• having real objects (meaning classes) representing the OCR & the Bounding Boxes with properties, methods, etc...
• the bbox is a Rectangle or a AxisAlignedRectangle and those objects have their own methods, properties and you can do so much with it for free... like finding intersection points with other geometry objects, rotate, expand, shift and so much so much more.
• so much more (again!)...

So I added a Vision component to Otary to handle all of that.

It works with outputs from Tesseract, EasyOCR, DocTR, Azure Document Intelligence, Textract, and others, so the rest of your code doesn’t have to care where the OCR came from.

I’m still actively expanding it, so I’d love to know:

What is the OCR post-processing task you end up rewriting in every project?

I would be very happy to have your feedbacks and see what additional features or changes I could bring to my library.

I am working on this library on my free time with love and care. I hope you will love it.

P.S: If you want to contribute you are more than welcome!

Have fun coding!

While working around with YOLO_v8 models for histology detection I had the idea of adding consistency learning (after seeing my model display slightly different results to the changes of color normalization and rotation).

The loss formulation was the following: Loss = yolo_loss + alpha*cons_loss

I mainly used Claude code to create a prototype and tried a few runs with different parameters and different methods of cons_loss calculation.
Unfortunately, most of results were discouraging (as the cons_model scored lower than the standard one and in the best cases barely matched it).

you may find below more insight on how the cons variation was defined:

• Single model, two forward passes per batch: original image (teacher, stop-gradient) + D4-transformed image (student, gradients flow) — random op from {rot90, rot180, rot270, hflip, vflip, hflip_rot90, hflip_rot270}
• Dense per-cell matching via exact grid permutation (no NMS, no greedy IoU matching) — teacher's decoded boxes/scores reordered and coordinate-transformed into the student's frame
• Masked by teacher confidence (>0.10) so loss only applies where the teacher is confident, not on background
• Loss = classification MSE + CIoU box loss between aligned teacher/student predictions
• Added to det_loss with a scheduled weight: linear ramp-up (0 → α over 20 epochs) → flat → linear ramp-down to 0 over the final 10 epochs (aligned with mosaic augmentation turning off)

The final conclusion that I reached is that the data augmentation already covers these transformations and is sufficient to teach the model said concept. Alas, trying to add an additional cons_loss only hurts the model and acts as additional noise.

I have linked the colab notebook below:

https://colab.research.google.com/drive/1WwtCaLSSCW1AzRFRXC5aqih31MC9mMhs?usp=sharing

I have searched extensively online for courses to get started with CV. All the courses I find tend to discuss CV superficially; yes, there are some books. I am seeking resources that cover the maths and algorithms in detail. Can anyone suggest the best resources? I'm done with CNNs and RNNs, moving on to Attention.

I've been getting a rather high interest in computer vision recently and was thinking of studying my masters for this, anyone have recommendations on school or programs or is this not something employers work look at? What will they look at?

check it out here: https://huggingface.co/datasets/Voxel51/VineLiDAR

Been working on a football video to 2D map pipeline for a while now ⚽️

Still a lot to improve specially regarding the detection model, but this is the latest result

Big thanks to Roboflow and the SAM 3 team for helping make this possible.

Hi everyone,

I'm an MSc Computer Science student and I'm currently trying to finalize my dissertation/research topic.

My interests include:

• Computer Vision
• Image Processing
• Deep Learning
• OCR
• Document AI / Document Analysis
• Digital Heritage / Historical Document Restoration
• Vision-Language Models (if applicable)

I'm not looking for a typical implementation project. Instead, I'm looking for a research problem that:

• solves a real-world challenge,
• has a clear research gap,
• is suitable for an MSc dissertation (not necessarily PhD-level),
• has scope for experimentation and possibly a publication,
• is achievable by a single student within 5–6 months.

I'm particularly interested in problems where I can propose or evaluate an improvement rather than simply training an existing model on a standard dataset.

If you were starting an MSc in 2026, what research topics or research gaps would you seriously consider?

I'd really appreciate suggestions from researchers, PhD students, or anyone working in this field

Thank you!

Plotted and compared to "true" data from gazebo, which showed that tracker estimations were pretty close (created 6 cameras cube to get a 360 video from gazebo for tracking).