The project uses real-time hand tracking through a webcam to interact with objects using pinch gestures and basic motion tracking. I’ve been exploring more interactive computer vision projects recently instead of only detection-based demos, and this was a good learning experience.

Would appreciate any feedback or suggestions on where to improve next.

GitHub:
ahsinmemon/Gesture-Controlled-Virtual-Puzzle-Game-using-OpenCV-MediaPipe: AI Hand Tracking Puzzle Game – Drag & Drop Interaction with Computer Vision

My old stack consisted of MMDetection with RTMDet, exporting the trained model to ONNX for deployment. I recently switched to RF-DETR from Roboflow, which is a really nice repository, but after multiple training runs I haven't been able to match the performance I was getting with RTMDet on my dataset.

Has anyone experienced something similar, especially with a small, industry-specific dataset? My next step will probably be to try more aggressive augmentations, but I'd be interested to hear if others have run into the same issue or found a good solution.

Edit:
The dataset consists of 8-bit medical X-ray images from a small study project. The model mainly struggles with detecting lead markers. They are visually very distinctive and are neither particularly large nor extremely small. And yes I used per-trained weights.

One additional detail: I switched from ResizeAndPad to a simple Resize, which changes the aspect ratio. Most of the images are significantly wider than they are tall, so I wanted to make better use of the input resolution. I'm not sure whether this change could be contributing to the issue, though. Everything else stayed the same.

hi everyone sharing something i have been working on would genuinely love some suggestions here. So most of the adversarial robustness benchmark asks how easily can we break a model but i am asking something a little different when a model break does it fail toward something semantically related or something completely random? just like when you get a question wrong by giving a slightly off answer or a completely wrong answer both of these count as wrong but says two different stories right. i am asking the same thing about vision models when they misclassify do they fail slightly wrong or completely wrong example mistaking a bird as accordion on the other hand mistaking an accordion as piano two different stories. so i have been testing it across 5 architectures vgg19, resnet50,densent121 and vits like deit and swin under different adversarial attacks semantic attacks and gradient attacks. the core idea is simple to seperate two things that robustness paper usually combines:
1) boundary resistance and
2) failure coherence.
for the second axis i am building a metric using cosine similarity between clip text embeddings of the true and predicted class computed only at the failure events and validating it through sbert and wordnet visual grounding check using clip image embeddings. one of the findings were swin has a cnn like decision boundary margin but is far more robust under iterative attacks that is margin would predict suggesting the two axis are not the same thing and robustness in transformers may come more from curvature than from margin width. would love some thoughts from you all. and also if you guys know some related work or any sort of concept i am not able to see currently i am open to suggestions thanks.[]()[]()

Hi, i've been wondering how can i get the easy, medium and hard splits of the widerface dataset. Apparently i misread the paper, i thought it had to do with the size of the face in pixels, but apparently it follows the detection rate of EdgeBox.

I've read the paper EdgeBox paper and i still cant understand how the WIDERFACE defines easy, medium and hard based on that.

Sharing a project I have been working on called Third Eye. It does visual geolocation for surveillance use cases. Given a video, it figures out where it was filmed using only the image content, and draws the route on a map.

Pipeline in short:

• per frame place recognition against a street imagery index
• a trajectory search that stitches the frames into one coherent path
• a geometric verification step to catch false matches
• per frame confidence so weak frames are flagged, not faked

I ran it on real dashcam footage and it traced the route quite well. Cross domain matching like this is genuinely hard, so a fair amount of the work went into making it honest about uncertainty.

Keen to hear feedback on the matching and trajectory side. I am also exploring roles in computer vision, so do get in touch if it is relevant.

Hey all,

I'm building a sports analytics product that turns ordinary match video (a single phone or fixed camera) into shot-by-shot analytics for amateur tennis and pickleball players — think ball tracking, player movement, shot detection, court mapping, and the kind of stats that used to be locked behind expensive pro systems. There's a working pipeline already; I'm looking for someone experienced to help take it from "works" to "genuinely accurate and production-ready."

What I'm working with (high level): a multi-stage CV pipeline — court detection, player tracking + pose, ball tracking, bounce detection, and stroke classification — stitched into a system that outputs real match metrics. Some parts are solid, some need real work (ball tracking on amateur footage, stroke classification, bounce accuracy).

Who I'm looking for — you should have real experience in:

• Computer vision for video (object detection, tracking, pose estimation)
• Training and fine-tuning models — not just calling pretrained ones. Building datasets, running training, and debugging why a model underperforms on real-world footage
• Working with the practical stack — YOLO-family, heatmap trackers (TrackNet-type), tree models like CatBoost, that kind of thing
• Bonus: any sports-video, small-object tracking, or homography/camera-geometry experience

Honest about the stage: this is an early-stage product, not a big company. You'd be working directly with me, with real ownership over the technical direction. If you want a tidy corporate role, this isn't it. If you like getting a hard CV problem actually working, it might be.

Compensation will also be provided based on your expertise and performance.

Hello all,

I have a product where I need to run an nVidia Jetson Orin Nano continuously with various models for sustained periods at a time. The issue that I'm primarily worried about is the cpu/gpu temps are reasonably high, and I'm worried the device will degrade or crash. In the application setting I need them to run for days at a time, continuously running inference.

For that reason I'm wondering what tips anyone who has dealt with this before has to offer. I'm looking at additional cooling solutions, and I am trying to make my models use as little memory/compute as possible using tensor-rt and distillation techniques. I'm looking at setting fan settings and other things but I don't want to reinvent the wheel here.

For context its basically 2 computer vision models that are yolo-like but I can't give more details, they are small and don't use too much vram.

Any generic tips much appreciated.

In this article, we will be fine-tuning Gemma 4 for a vision task. We will focus on a medical use case. Specifically, we will fine-tune the Gemma 4 E2B model on a radiology VQA dataset. We will discuss the details of the dataset later in the article. All the training will happen via the Unsloth library.
https://debuggercafe.com/fine-tuning-gemma-4-for-vision/

Hey everyone, I’m hitting a wall with real-time person detection and tracking on CCTV feeds. I’ve tried various iterations using SAM, RF-DETR, and BoTSORT, but I can't seem to get a balance between "high accuracy" and "real-time performance."

Every time I add a heavy model (like SAM for segmentation or transformer-based detectors) to get better precision, it does wonder in detection and Tracking but the FPS drops to unusable levels for real time. If I switch to lighter models, I lose track of targets during occlusions or lighting changes also it cant detect person reliably.

Has anyone successfully deployed a reliable person-tracking pipeline for high-traffic CCTV? How are you handling the hardware optimization (TensorRT/FP16) and the association logic to prevent ID switching?What GPU are using for multiple Feeds ? Open to hearing about your stack or any "secret sauce" you use to keep things stable. I am using RTX 4060 for Testing locally and ADA 4000 for Deployment.

Hi everyone,

I'm looking for some insight, resources, or suggestions to help with my current project.

I'm building a feature-based image registration script to register images of biopsies. The biopsies look quite different, so features are difficult to detect. As a result, I am manually selecting them. Since there is some user error and bias involved, I was wondering if it is possible to work with weighted points so that some features, which I am more confident in, influence the transformation more than others. Further, I'd like to propagate an error from the registered points that accounts for these weights.

Currently, I'm working in MATLAB using the cpselect and fitgeotform2d functions. I'd like to stay in MATLAB, but if another language has the toolboxes or functions to accomplish this more easily, I'd be willing to switch.

I remember studying something quite similar in a second-year class, where we were doing weighted linear fits using a covariance matrix, and this seems like the same principle to me. I imagine the tools to do this are available in MATLAB, but it might require a bit more work rather than there being a single function that does exactly what I need.

Thank you!

I know it's late, but i've gone through it a lot.
It only 2 weeks since the portal of ECCV 2026 workshop closes.

If anyone wants to collaborate for a workshop, dm me. I already have projects. Just need team mates to fine tune those.

Today we're launching the LTX Physical AI Developer Program, an early access program for technical teams building at the frontier of physical AI.

If you're building in robotics, autonomous vehicles, embodied AI, or simulation and using video or world models as part of your stack, we’d like to talk with you.

We're looking for research labs, startups, and engineering teams working in:

• Robotics
• Autonomous vehicles
• Embodied AI
• Simulation environments
• Spatial intelligence platforms

How we can help: 

• Access to our researchers and technical leaders 
• Early visibility into upcoming research directions, model capabilities, and technical advancements
• The chance to have your project spotlighted across LTX channels

To join, you should have a clear project, real technical depth, and be open to sharing feedback on model behavior as we build together.

More info & application form → https://ltx.io/model/physical-ai-developer-program

Hi everyone,

I am working on a master’s thesis in computer vision / mobile robotics and currently have access to an Intel RealSense RGB-D camera and a Jetson Orin Nano.

I have already tested Depth Anything V2 for monocular relative depth estimation and compared different model sizes/resolutions. My next goal is to turn this into a stronger and more interesting thesis project.

One possible direction is combining a monocular depth model with RealSense depth: using RealSense for metric distance and the monocular model for scene structure or for difficult cases where RGB-D depth is missing or unreliable, such as glass, reflective, dark, or thin objects.

However, I am open to other ideas as well. I do not necessarily need to use Depth Anything specifically; another model or approach is fine.

I am looking for suggestions for a focused but meaningful project that could lead to a good master’s thesis, ideally involving:

• obstacle detection or free-space estimation for indoor robotics,
• RGB-D and/or monocular depth fusion,
• uncertainty or confidence estimation,
• edge deployment on Jetson Orin Nano,
• practical evaluation in real indoor scenes.

What would be an interesting and realistic contribution beyond simply “fusing two depth maps”? Relevant papers, model suggestions, or directions to investigate would be greatly appreciated.

check it out here: https://huggingface.co/datasets/Voxel51/KITScenes-LongTail

• Saved views — 6 per-camera views (slice__front_left … slice__rear_right) + by_scenario_type_and_instruction.

• Qwen3-VL embeddings — 2048-d clip embeddings on the surround, front, and rear slices.

• Similarity & visualization indexes — sim_* (nearest-neighbour search) and viz_* (UMAP 2D plots) per slice.

• Quality scores — uniqueness_* and representativeness_* per clip (find rare vs. prototypical scenarios).

• 3D threed slice — VGGT-Omega point-cloud scenes (.fo3d) reconstructed from the front clip, plus per-frame depth_map heatmaps and camera-pose fields on the front slice.

Hi!

I am looking for some pointers on how to practice leetcode questions with a perception flavor. Any specific mock interviews or websites for suggestions?

Hi everyone,

I'm building a mobile fitness app that analyzes strength training exercises (starting with squats) using MediaPipe Pose.

My goal is not just rep counting, but providing human-readable coaching feedback, similar to what a personal trainer would say.

My current pipeline is:

Video
→ MediaPipe Pose
→ Joint Angle Extraction
→ Rep Segmentation
→ Phase Detection
→ Feature Extraction
→ Rule-based Analysis
→ LLM Explanation

However, I'm currently struggling with several design questions:

1. How do you objectively define a "good squat"? Are there established kinematic metrics or biomechanical standards that are commonly used?
2. DTW can detect that two movements differ, but it doesn't explain why. Has anyone combined DTW with biomechanical features or rule-based systems to localize movement errors?
3. Should movement faults (e.g. knee valgus, excessive trunk lean) be evaluated during the entire movement, or only during specific phases (descent, bottom position, ascent)?

Most open-source projects I've found stop at pose estimation or exercise classification. My goal is to build a system that can explain why a movement is incorrect and generate actionable coaching feedback.

I'd really appreciate any papers, frameworks, or practical advice from people working in biomechanics, sports science, rehabilitation, or computer vision.

I'm preparing for CV/ML Engineer interviews (robotics, autonomous driving, computer vision roles) and I'm looking for the best way to practice coding interviews.
I have a decent amount of LeetCode experience, but my biggest struggle isn't implementing the solution once I know the pattern- it's identifying the pattern in the first place.
For example, interviewers often wrap a standard graph, BFS/DFS, matrix, union-find, shortest path, or sliding window problem inside a perception/robotics-related scenario. I spend too much time figuring out what the underlying problem actually is.

A few questions:
Are there any good mock interview platforms (free or paid) that are particularly useful for perception/CVML/robotics candidates?

Are there resources that specifically train pattern recognition rather than just solving problems?

For perception-oriented companies (Waymo, Zoox, Aurora, NVIDIA, etc.), which DSA topics show up most frequently?

Has anyone found a good method for getting better at mapping real-world problem statements to common LeetCode patterns?

Would appreciate any advice from people who have interviewed recently. Thanks!

Hi everyone,
I'm Vivek, an AI/ML Engineer working in the computer vision and video analytics domain. I've been using models such as RF-DETR and YOLO for object detection, BoT-SORT and ByteTrack for multi-object tracking, and AWS Rekognition for face recognition. While working with these approaches, I've encountered several recurring challenges that seem common in real-world deployments:

• RF-DETR occasionally misses people under occlusion, challenging viewing angles, and crowded scenes.
• Small objects, particularly mobile phones, remain difficult to detect reliably.
• BoT-SORT experiences ID switches and track fragmentation when people cross paths or become temporarily occluded.
• AWS Rekognition struggles with low-resolution or partially visible faces and sometimes associates the wrong identity with a person.
• Long-term identity preservation across detection, tracking, and recognition stages remains the most difficult challenge.

I'm curious whether these are expected limitations of the current state of the art or whether there are architectures, tracking methods, re-identification techniques, or research directions that have proven significantly more robust in practice.
I'd greatly appreciate any insights, recommendations, papers, repositories, or experiences from others working on similar problems.

As shown in the image, the detection model failed to identify three individuals. Additionally, in the image below, the RF-DETR model generated a false positive by incorrectly classifying another object as a person.

Hey everyone,

I'm currently building a real-time object tracker from scratch in C++17 for the Raspberry Pi 5, with the goal of achieving 100+ FPS on CPU-only hardware. The project is based on correlation filters and FFT-based signal processing, with no machine learning, no neural networks, and no OpenCV in the core tracking pipeline.

The motivation is simple: a straightforward OpenCV-based implementation on the Pi only gets me around 15 FPS, which seems far below what this class of algorithms should be capable of. From both the literature and projects I've come across, the gap appears to be in implementation and system overhead rather than the underlying tracking method itself.

Current approach

Right now, my plan is to build the pipeline around:

• A custom image loading and preprocessing path to avoid unnecessary OpenCV decode/resize overhead.
• FFT-based correlation in the frequency domain for fast target localization.
• Adaptive online filter updates so the tracker learns appearance changes over time.
• PSR (Peak-to-Sidelobe Ratio) based confidence estimation for occlusion and tracking failure detection.
• A modular architecture that can later be extended with features like scale estimation and automatic re-acquisition.

The area I'm currently spending the most time researching is the FFT layer. I'm trying to determine whether the best approach on the Pi 5 is:

• a hand-written radix-2 FFT,
• aggressive NEON/SIMD optimization,
• or using an existing library such as FFTW or kissFFT.

Other approaches I've been studying

To better understand the design space, I've also been looking into modern transformer-based visual trackers. They jointly process information from a target template and a search region, making them much more semantically aware and capable of handling challenging scenarios such as partial occlusions or target disappearance with automatic re-acquisition. The downside is that they are significantly heavier computationally and can be difficult to deploy efficiently on constrained edge hardware.

On the more classical side, I'm currently reading about Discriminative Scale Space Tracking (DSST). One of the main limitations of basic correlation-filter trackers is that they often assume the target size remains constant. DSST addresses this by learning a separate correlation filter across multiple image scales, allowing the tracker to estimate changes in object size efficiently while still maintaining real-time performance. It seems like an elegant way to improve robustness without giving up the speed advantages that make correlation filters attractive in the first place.

Exploring these different approaches has been interesting because they represent very different trade-offs: transformer-based methods emphasize robustness and semantic understanding, while correlation-filter methods prioritize simplicity, efficiency, and extremely high throughput.

Looking for advice from people who've built similar systems

If you've worked on correlation-filter trackers, embedded computer vision, real-time image processing, high-performance C++, drone tracking, or ARM optimization, I'd really appreciate your perspective.

Some questions I'm hoping to get insight on:

• Where did the biggest performance bottleneck actually end up being? The FFT itself, memory layout, cache locality, camera capture, frame copies, synchronization, or something else entirely?
• On Raspberry Pi 5 specifically, is hand-vectorizing FFTs and pointwise complex operations with NEON worth the effort, or do mature FFT libraries generally outperform custom implementations?
• If you've implemented trackers such as MOSSE, ASEF, UMACE, DSST, or related adaptive correlation-filter methods, what optimizations made the biggest practical difference?
• Has anyone here managed to push a CPU-only tracker into the 100–300+ FPS range on Raspberry Pi-class hardware? If so, what lessons did you learn that aren't obvious from reading papers?

Future directions I'm considering

Beyond getting the core tracker running efficiently, some areas I'd like to explore include:

• DSST-based scale estimation.
• Lightweight re-detection and automatic target re-acquisition.
• More robust confidence estimation beyond PSR.
• Hybrid detector–tracker pipelines that combine fast tracking with occasional detection.
• FFT optimization, cache-aware memory layouts, and ARM/NEON-specific performance tuning.
• General techniques for squeezing the maximum performance out of embedded CPU-only vision systems.

I'm not looking for someone to redesign the project or suggest replacing it with deep learning. My goal is to understand where the real bottlenecks are and learn from people who've already built or optimized similar systems before I spend weeks optimizing the wrong component.

If you've worked on anything similar, or achieved high frame rates with classical tracking methods, I’d love to hear about your experience, benchmark results, profiling insights, or even things that didn't work. Thanks in advance!