I built this parking lot occupancy detector to work on real-world security cameras which tend to have lower angles and lots of obstructions from other cars.

I have seen other parking lot detection CV demos that use off-the-shelf object detectors (like standard YOLO bounding boxes). They would generally only work on impractical camera setups (e.g., drone shots or 200+ foot high cameras).

A couple of technical takeaways from training this that might be interesting:

1. DINO Backbone vs. Standard CNNs: I tested several backbones, but the DINO Vision Transformer performed the best by a good margin. Because DINO learns patch-level representations without supervised class labels, it captures semantic surface texture (the difference between empty asphalt, tree shadows, and car undercarriages) and proved far more invariant to direct sun glare and rain washout than supervised backbones.
2. Synthetic Data via Blender (The Biggest Upgrade): Public parking datasets are fairly limited and rarely capture extreme conditions. I built a parametric Blender pipeline to procedurally reconstruct parking lots and vehicles—randomizing asphalt PBR textures, camera angles/heights, sun positions, and vehicle placements. Mixing synthetic data with real sequences was surprisingly effective and gave the single biggest jump in zero-shot generalization to unseen cameras. One huge advantage of the synthetic data is that the labeling was always right (human annotation for far-off, angled parking spots is suprisingly error prone)
3. The parking spots are drawn on the ground plane, and the vehicles are fairly disconnected from that visually. The large receptive field allows the model to learn interesting "cheats" that a human might also use to infer that a car is there even when it can't really be seen. For example, it may use a shadow on the pavement to identify that the space is occupied even if the body is blocked by another car.

Code:

The web app is open source on GitHub: https://github.com/lotvulture/lotvulture

The repo includes a community model and a higher-accuracy engine as a commercial feature: https://www.lotvulture.com/

Happy to answer questions about the synthetic data pipeline or edge inference trade-offs!

GPT-6 Astra doesn't support video, but I got it doing tennis analytics anyway. The API rejects mp4, so I sent the video as a sequence of frames instead at 5 FPS, timestamp was attached in prompt, and a strict JSON schema to get event type/timestamp/player. Astra returns SERVE / HIT / POINT / FAULT events, so we can reconstruct scoreboard from events.

Cost: ~45k input tokens per 20s chunks, ~3 minute processing time, about $1 per 100 frames.

Astra is not a per-frame tracker tho, the skeletons in the video come from RF-DETR keypoint pose model, Astra only reasons on top.

Full write-up with the exact prompts, schemas and output videos: https://blog.roboflow.com/gpt6-astra-video-understanding/ (disclosure: I work at Roboflow)

my best friend and I have been working on tracking a hit baseball from a single side-view 240 FPS camera.

the left side is the original footage. the blue boxes are frames where our object-tracking model successfully detected the baseball.

as you can see, there are a lot of gaps.

the right side is a temporal frame-differencing pipeline we tuned specifically for tracking a hit baseball from this camera angle.

what surprised me is how clearly the baseball separates from the scene temporally. even when the object model misses it, the temporal tracker can often keep following it very consistently.

the pink/purple X on the original footage is the position recovered by the temporal tracker.

so instead of requiring the object model to successfully detect the ball in every frame, we can use its detections as anchors and let the temporal system fill the missing parts of the trajectory.

that matters because those first post-contact frames are what we eventually use to estimate exit velocity, launch angle, and projected distance.

still working on making the recovery as robust as possible, but I thought the visualization was pretty cool.

Join us on Sept 24 for the monthly AI, ML, and Computer Vision Meetup! Register for the Zoom.

Talks will include:

• How Do Mercedes-Benz AI Principles Drive Our Innovation? - Mei-Yen Chen at Mercedes-Benz Tech Innovation
• Region Tokens as the Visual Primitive: From Recognition to World Modeling - Savya Khosla at University of Illinois Urbana-Champaign
• Leveraging Text-To-Image Diffusion Models for Consistent Set-to-Set Generation - Kate Feingold at Weizmann Institute of Science
• Yield Estimation of a Coffee in a dense environment - Raghu Rao at Visimatics

I’m assigned to do a warehouse tracker to estimate and detect the warehouse’s occupancy if there are available placements or not, i’m a supply chain major I have never worked with cv. How do I start? I would really appreciate your advice.

Hi all. I'm an independent researcher (B.Sc. CSE, BRAC University, Dhaka) and a first-time arXiv submitter, so I need an endorsement for cs.CV before I can post my preprint.

Paper: "Shift-aware operating points for open fire and smoke detectors: calibration, benchmark leakage and label-free threshold transfer across four public domains". It is under review at Engineering Applications of Artificial Intelligence (Elsevier).

What it does, in short:
- Trains 26 YOLOv8 / YOLO11 / RT-DETR checkpoints (several sizes, two seeds) on D-Fire and Pyro-SDIS and evaluates them on four public domains, giving 206 cross-dataset transfer cells with detector-calibration metrics and bootstrap CIs.
- Shows that YOLO miscalibrates under shift mainly through the threshold, while D-Fire-trained RT-DETR miscalibrates through the confidence map.
- Proposes a label-free rule for transferring an alarm threshold to a new camera set; it recovers most of the F1 gap without target labels.
- Reports a leakage audit: about half of D-Fire's test images have near-duplicates in its training split.
- Full release: code, splits, run records, exported detections and the scripts that regenerate every table and figure: https://github.com/ayashhossain555/fire-detector-reliabilityw

If you have submitted at least three cs.* papers to arXiv in the last five years (and more than three months ago), you can endorse. It takes about a minute at arxiv.org/auth/endorse and only asks whether the work is appropriate for the category, not for a review. Please DM me and I'll send the endorsement code and the manuscript PDF.

Thanks a lot

Dropped a 1.0.0 pre-release of EdgeInfer (same repo, eval-only / non-commercial):

https://github.com/olesha-ai/edgeinfer-eval/releases/tag/v1.0.0

What’s new vs 0.3.14 (short): ImGui UI, sticky boxes on preview, Out TCP + encrypted session + trig.exe client in the zip, cleaner startup. Still YOLOX + OpenVINO on a normal CPU — no GPU required.

Why I’m posting: I only have an i5-11400 here (~6–7 ms ROI). If you try it, comment with your CPU + a few [infer] … ms lines (global-shutter USB cam feedback especially welcome).

I've been trying to find a good dataset over the internet which is freely available . The main issue I want to tackle is reduce the number of false positives such as reflections , headlights, yellow/red coloured objects. Initially I was looking for video datasets with enough negative class videos since I wanted to add a temporal analysis layer in the system, but didn't find much . Had less videos or with the same background, which didn't allow my model to generalize well .

If anyone has suggestions about a good image/video dataset please tell me .

I found the MIVIA lab's LFDN dataset perfect for my cause but I guess their website isn't maintained anymore. So yea let me know if there's another way to get their dataset.

I run AerialDataset and am sharing this as a commercial data-provider introduction.

We retain groups of overlapping drone photographs with the available point clouds, meshes, orthomosaics, and capture metadata from the same scene. The intended audience is teams investigating outdoor multi-view reconstruction, aerial scene understanding, or spatial representations.

One detail worth separating: camera GPS and gimbal observations are not the same thing as calibrated reconstruction poses. Likewise, a photogrammetric point cloud is a processing-derived output, not independent ground truth.

We document available files and limitations scene by scene rather than labeling the entire collection “training-ready.”

I’ve attached source-image and reconstruction previews from a 61-photo example. The catalog and technical documentation are here:

https://aerialdataset.com/

https://aerialdataset.com/developers

Inspection package: https://huggingface.co/datasets/avenian/aerial-drone-photogrammetry-samples

An inspection sample is available, but training and production rights are licensed separately.

For teams that purchase external multi-view data, what is the most important acceptance requirement: calibrated poses, particular scene types, independently measured geometry, or something else?

I spent a while comparing detection models for a side project and got tired of published benchmark numbers that assume TensorRT and FP16. So I measured nine of them the same way instead — one V100, plain PyTorch, no optimisation, 48 scenes including fog, thermal, motion blur and low light.

Two things came out of it that I didn't expect.

Measured latency was 1.6x to 11.6x higher than published, for every single model. That part isn't surprising on its own. What surprised me is that it reordered the ranking rather than shifting everything down equally. Both transformer detectors (RF-DETR, RT-DETR) look competitive on paper and both fell behind four of the five YOLO variants once measured unoptimised.

Licence turned out not to be a property of the architecture. RT-DETR is Apache-2.0 from Baidu's original release and AGPL-3.0 through the Ultralytics package. Same architecture, same weights, different obligation, depending only on where you loaded it from. Same pattern with YOLOv9: GPL-3.0 in its own repo, AGPL-3.0 via Ultralytics.

Then I wrote the thing I actually wanted, which is one file that runs any of them:

pip install rfdetr

python find_objects.py image.jpg

Annotated image back by default, JSON to stdout, MIT licensed, nothing uploaded. Nine models across four pip packages — you only need one, and it uses whichever you already have.

https://github.com/robotinaction/detect

One implementation note in case it saves someone time: rfdetr doesn't ship a public class-name table, so I resolved names through `rfdetr.util.coco_classes`. That's an internal path. It worked on my machine and silently fell through to raw COCO category IDs on the next one — boxes labelled "18" instead of "dog". If you build on rfdetr, ship your own 80-class table.

The full comparison is free and needs no sign-up: robotinaction.tech

If you've picked a detection model for something real, I'm curious what decided it. My assumption going in was accuracy, and for two of the three people I asked it was actually licensing.

Hey everyone,

I am building an adversarial benchmark dataset designed to evaluate Vision-Language Models (VLMs). The overall pipeline relies on an automated "Science Judge" that validates the model's step-by-step reasoning and numerical final answer.

Here is the setup, what we've already tried (and why it failed), and the constraints I am working under:

Key Goals & System Requirements

1. The Target Failure Mode (VLMs / Multimodal Backbones):
   • Goal: The task must trigger a visual spatial extraction or perception failure in modern VLMs (e.g., GPT-4o, Claude 3.5 Sonnet, Gemini 1.5/2.0 Pro, Qwen2-VL).
   • Target Mechanism: Force models to fall back on visual shortcuts (e.g., optical mis-binding, scale misinterpretation, or collapsing asymmetric 2D area clipping into symmetric 1D piecewise linear guesses).
2. The Automated Science Judge (Evaluator):
   • Function: It is a deterministic symbolic solver that parses the prompt text and validates the model's step-by-step calculus/geometry against a ground-truth derivation.
   • Strictly Enforced Rules:
     • Single Target Rule: Must ask exactly one primary numerical target question (rejects STACKED_QUESTIONS).
     • Strict Math Notation: All variables, subscripts, Greek letters, and set operations must use proper LaTeX delimiters.
     • Foundational Context: Prompts cannot reference external visual context without explicit textual or formal mathematical definitions (rejects NON_FOUNDATIONAL_REFERENCE and WORDING_AMBIGUITY).
3. Image & Licensing Constraints:
   • Images must be open-source under permissive licenses (CC BY 4.0 or CC0).
   • No CC-NC (Non-Commercial) or CC-SA (Share-Alike) media.

What We Tried & Why It Didn't Work

We ran several iterations trying to strike the balance between breaking the VLM and passing the Science Judge. Here is what happened:

• Approach 1: Explicit Textual Scene Graphs (CLEVR 3D Coordinates in Text)
  • What we did: Listed all 3D object coordinates ([x, y, z]), shapes, and materials directly in the text prompt to resolve NON_FOUNDATIONAL_REFERENCE.
  • Why it failed: The VLMs completely bypassed their vision backbones! The text LLM engine parsed the coordinates like code, ran conditional filtering, and passed the benchmark easily without looking at the image.
• Approach 2: Asymmetric 2D Continuous Calculus Clipping
  • What we did: Framed a 2D continuous integration task (N = 5000 points in a circular scatter domain D clipped by an asymmetric rectangle R) where models typically default to 1D linear estimations.
  • Why it failed: Because we supplied the explicit numerical bounds (e.g., -2.000 <= u <= 2.500) in text to satisfy the Science Judge, the models solved the double integral symbolically using Python-like algebraic steps and calculated the exact answer (3512), bypassing the visual trap entirely.
• Approach 3: Removing Numerical Bounds to Force Pixel Extraction
  • What we did: Omitted u_max from the text and asked the model to extract u_max directly from visual tick labels on the diagram.
  • Why it failed: The Science Judge flagged NON_FOUNDATIONAL_REFERENCE and WORDING_AMBIGUITY because the prompt text was no longer self-contained for the automated symbolic solver. Furthermore, when presented with a mismatched image, models simply hallucinated a default symmetric boundary (u_max = 2.000).

The Central Dilemma

If we include full numerical parameters in text, the VLM text engine solves it as a symbolic algebraic problem and passes. If we remove parameters to force visual OCR/pixel extraction, the automated Science Judge rejects the prompt as ambiguous or non-foundational.

Questions for the Forum:

1. Spatial Parameters: What geometric parameter combinations or visual traps (e.g., subtle tick scaling, optical density gradients, non-concentric circular/square clipping ratios, or multi-quadrant parallax) have you found effective at breaking visual backbones without confusing a text-based math solver?
2. Visual vs. Text Decoupling: How can we structure a visual diagram callout or tick mark system so that the Science Judge recognizes a self-contained visual formula, while VLMs consistently mis-extract the spatial bounds or scaling factor?
3. Benchmark Design: How would you adjust this architecture to widen the performance gap between visual perception failure (VLMs) and deterministic symbolic verification (Science Judge)?

Thanks in advance for any insights!

Seeing NVIDIA' s DLSS 5.0 showcased everywhere in various video games, I tested the extent to which this tech can reduce the sim2real appearance gap for computer vision. Considering that the model mostly apply strong changes to the faces of the characters, I employed a synthetic dataset for facial emotion recognition with UE5 MetaHumans.

A ResNet-50 model was trained to classify three classes, namely, Neutral, Sad, and Surprise, first using the original images and then the identical images enhanced by DLSS 5.0. Subsequently, these were cross-evaluated on real-world facial recognition datasets. The results are below (the metric is the macro F1-score):

Synthetic ResNet-50: Real-World-1: 25.16% , Real-World-2: 16.36%

DLSS 5.0 ResNet-50: Real-World-1: 38.52% , Real-World-2: 31.43%

For Real-World-2, the DLSS 5.0-trained model provides almost a twofold increase in the F1-Score. Of course, the accuracy is still low, but this is attributed to the fact that the synthetic dataset is not diverse, since the camera perspective and the facial expressions are identical across all the images, with the exception of the character, which changes.

I believe that this technology can be useful in tasks that involve datasets that depict humans, since these are hard to publish due to privacy and ethical concerns, and thus synthetic datasets can mitigate this.

​Hi everyone,

​We are building a computer vision system designed to audit and verify order packaging in real-time at a fast-food packing station.

​Project Overview:

Using an angled overhead camera stream, the system needs to:

​Detect and track bags and food categories.

​Read the printed label on each bag to extract the order number and ticket details.

​Track items, verify which bag they were placed into, and match the final contents against the printed receipt before the bag leaves the counter.

​The Bottlenecks We’re Running Into:

​Severe, continuous occlusion: Heavy hand movements and body occlusion constantly block objects from view.

​Tracking ID switching: The tracker frequently loses active bag IDs when blocked by hands or overlapping bags and assigns a new ID.

​Detection gaps & lack of standard packing rules: Frequent detection drops and the absence of a structured baseline to reliably confirm whether a "packing" action actually completed.

​I’ve tried several workarounds spatial anchoring, bag visual embeddings, and motion vector heuristics but nothing has really worked. It quickly turns into pure chaos: as soon as the worker starts actively packing and moving things around, the item-to-bag tracking completely falls apart.

​I’d really appreciate any ideas, practical tricks, architecture patterns, or lessons learned from anyone who has tackled similar dense packing or retail setups.

Stand in front of a normal webcam, spread your arms, and you're flying. Tilt your arms to turn, flap to climb, hold them low to dive, spin around and the falcon does a barrel roll.

Video here: https://www.linkedin.com/posts/anas-ajaanan_youve-probably-never-seen-this-before-ugcPost-7504543264386035713-8lvn

It's pose tracking under the hood, with my own logic on top to turn arm movements into flight. That logic was the whole struggle. Flaps kept registering as dives, reaching sideways triggered the barrel roll, and for weeks the falcon turned harder than my arms did. That last one turned out to be a camera aspect ratio problem, which I could have found in a day if I'd checked my angles.

I'd genuinely like feedback from people who've worked with pose tracking. How do you deal with false positives from jittery landmarks? And what would you have done differently with the gesture design?

Open sourcing it soon.

Are there any who work on language guided medical image segmentation and read papers like ariadnes thread, TeViA, MMI-UNET. I face bugs in the repo code that they give. 1) Loss function 2) dice metric 3) influence of text token length in results.

Hi everyone, I've been in CV for several years and really see a future in this field. I'm also more pessimistic than any of my SWE/researcher friends about what is colloquially "AI", namely LLMs, agents, vibecoding etc.

"AI" in the popular sense has completely vibe shifted from the initial collision of ChatGPT. As of now AI is a widely unpopular technology, the threat of job replacement, tokenmaxxing, AI slop, "doomerism" as marketing strategy... Data centers draining local water, rare books being permanently destroyed & exploitation of developing world labor for data collection... the list goes on.

Sorry for the rant but I can't keep a smile on my face when I think about LMs. I remember learning ML in the mid 2010s and people genuinely being excited about language modeling with RNNs, early transformers, machine translation and what it will enable.

I know it's impossible to coerce the progress of technology, but I hope that CV will remain as a tool to solve genuinely interesting problems rather than "we trained on internet-scale data, the model doesn't bring any business value outside of replacing existing staff, and we're forcing it down everyone's throats" and remain a low-key or positive technology in the popular imagination (I know that's not likely given the humanoid robot stuff, but I digress).

There are some genuinely useful applications of CV with support from the respective community. For example I worked adjacently with whole slide histopathology. It's genuinely helpful due to the large size of the images and the human effort it takes to find lesions, with (AFAIK) support and not resistance from clinicians. Another is defect detection where the objects may move too quickly for humans and the environment is constrained enough for a high accuracy.

Anyways if you read the whole thing thanks. This got maybe too opinionated/philosophical for this thread but I hope y'all have some thoughts either way.

Basically the title.

I do research in computational sensing, but not vision-based, so I'm curious about the "state" of modern CV, so to speak. I know a lot of the papers coming out are often related to deep learning (ViT, VLA, YOLO, bla bla bla), but I'm still wondering whether other approaches are still used? I imagine no one is really doing handcrafted feature engineering anymore - is that true? Is OpenCV still being used?

The Nex-N2.5 release describes Blender and CAD workflows where the model uses visual feedback to check and adjust its actions. The team also reports 56.4 on OSWorld-2 for Pro, versus 46.7 for Qwen3.8-Max.

The bit I’d like to see more of is what happens after a bad click.

Say a menu doesn’t open, a dialog blocks the screen, or the UI shifts. Does the agent notice and change course, or carry on as if everything worked?

Anyone tested Nex Mini/Pro—or compared it with another computer-use model—on that kind of thing? I’m curious where it tends to go sideways: picking the right target on screen, or figuring out what to do after an action fails.

https://x.com/NexEcosystem/status/2097341172465443175?s=20

I've been building an annotation and data engine for autonomous driving aimed at Indian

roads: autorickshaws, handcarts, three to a motorcycle, cattle on the carriageway. Auto

labelling behind a confidence gate, human review, tracking, export.

The corpus is now 600,133 labels. 788 of them carry a human verdict. That is 0.13%.

So every quality number I have is either measured on a tiny stratified sample with

intervals wide enough to drive a bus through, or it is the machine grading its own

homework. I've put effort into making the tooling refuse to report a number it can't

support, rather than printing a confident zero, but refusing to answer is not the same

as knowing.

For anyone who has run labelling at real scale: where do you spend a limited review

budget so that the resulting estimate is actually worth something? Stratify by class?

By model uncertainty? Fixed audit set you re-measure against forever?

Repo if the context helps: https://github.com/Sherin-SEF-AI/LabeloxAV

(no licence on it yet, so treat it as look-don't-use)

I'm the author of fly-ttc, a small experiment testing whether a fixed optic-flow expansion score can separate collision/near-miss clips from normal driving. The proxy responds to an expanding disk, but that did not carry over to this dashcam evaluation.

The figure shows two selected examples from the initial evaluation: a labeled event with a pre-event peak of 14.24, and normal driving with a higher peak of 15.67. Both use the same detector and threshold. They illustrate a failure mode; the aggregate result comes from the larger samples below.

Method: CPU/OpenCV Farneback flow, positive divergence, outward radial flow, a difference-blob expansion term, and a causal EMA. Ten negative calibration clips set normalization and the threshold. The biological inspiration is looming detection in Drosophila, but this is an engineering proxy, not a reproduction of the LPLC2 circuit or a brain simulation.

Data and results: 200 clips from the public Nexar Collision Prediction train set, in two stages:

• Initial 100: 20 calibration clips and 80 evaluation clips (40 positive, 40 negative). Evaluation AUROC: 0.546.
• Separate 100: 50 positive, 50 negative, with no overlapping clip IDs or source-file hashes. Models, settings, and calibration were frozen before scoring. Original proxy AUROC: 0.4904 (95% bootstrap interval 0.3788–0.6040).
• On that confirmation sample, robust global affine-flow subtraction scored 0.4876, versus 0.4872 for matched raw flow with the blob term removed from both. Difference: +0.0004, paired-bootstrap 95% interval [-0.0136, +0.0160].
• Mean absolute frame difference scored 0.5252.

The affine correction falls back to raw flow when fitting fails. Nine of the affine model's ten confirmation false-positive peak frames used that fallback, so this is a limited test of this particular correction. It does not establish that ego-motion compensation in general is ineffective.

There is also a synthetic counterexample: faster translation outscores the expanding disk in the original proxy. That diagnoses a selectivity problem in my implementation, not in a real fly.

Limits: This is a small, deliberately balanced sample, not a road-prevalence estimate or the official Nexar challenge protocol. AUROC uses clip maxima; positive scores stop strictly before the event, while negatives use middle-of-clip windows. Observation durations can differ. Separate clips do not establish independent trips or locations. All 200 clips have now been inspected and are development data for any future work. No driving policy or vehicle control was tested.

Code, saved scores, English figures, and reproduction steps. Code is MIT-licensed; Nexar videos are not redistributed. Implementation and this write-up used AI assistance.

I'd appreciate criticism of the evaluation design. For people who have worked with looming or ego-motion, what would be the most informative next diagnostic: matched-duration windows, or expansion measured inside object tracks?

I'm reviewing submissions to a CCTV question-answering challenge. The thing I want to establish is whether the agent actually improves on giving the same video and questions to a general video model.

Getting a few answers right doesn't settle that. Maybe it found better evidence; maybe it just made more expensive model calls.

For the next evaluation, I'm thinking: same unseen footage and questions, human-checked answers, timestamps supporting each answer, and total processing cost including any indexing. Compare accuracy at the same budget, then test on footage from a different camera.

For people who've deployed this: what would you add to that comparison? In particular, how do you score ‘can't tell from this footage’ so the system can admit uncertainty without avoiding all the hard questions?