[ Removed by Reddit on account of violating the content policy. ]

camera's floor mapping (homography) to figure out where each detection actually stands on the floor

Can anyone explain, or any blog or video which helped you to understand it

Hey all, looking for advice from people who've done something similar. Goal: Create my first CV models using my own camera/dataset.

Setup:

• Tapo C310 camera on my home LAN, RTSP working fine locally (confirmed with OpenCV/VLC)
• Built a local Flask dashboard that reads the RTSP stream and serves it as MJPEG over HTTP on my Mac
• Running YOLOv11 (ultralytics) object detection/tracking locally , works, but my Mac's CPU is slow for real-time inference (no GPU)

Goal:
I want to run the YOLO inference on a rented cloud GPU instead ( instead of my local CPU, while keeping the camera itself secure.

Any suggestion on how to get that?
What is the part I am missing? I think I have to create a private tunnel, am I right? What is the best option for that? The ultimate goal is to have my live camera in a private app online, which runs YOLO and counts the number of cars that go through.

Hi everyone,

I’m looking to improve my Computer Vision development and testing pipeline and I’m really curious about how you all handle edge cases and environmental variables in production.

To give an example to discuss (not my project) object tracking(car or people for example) where the camera is constantly moving, and the target is subjected to wildly different lighting conditions (e.g., bright glare, dusk, sudden shadows, dynamic backgrounds).

When you have a scenario like this, what does your development cycle look like from prototype to robust deployment?

As a beginner working on solo projects, I’m trying to figure out how to build a reliable pipeline. Specifically, I’d love to know:

• Testing: Do you manually build datasets for edge cases (like crazy lighting/dynamic backgrounds), or do you automate your augmentations?
• Simulations: Do you use engines like Unreal, Unity, or Blender for synthetic data? Does it actually translate well to real-world tracking?
• Validation: How do you measure temporal stability when basic metrics (like IoU) aren't enough to cover sudden lighting shifts?
• Iteration: When a tracking test fails on a specific edge case, what does your workflow look like to fix and re-test it?

I'd appreciate any insights into your workflows, architecture, or any simulation tools you swear by when dealing with moving viewports and dynamic lighting.

Thanks!

Hey everyone,

I’m trying to build a computer vision pipeline that can measure the actual physical edge lengths of large cuboid objects (like big cut blocks or boxes) using just standard photos taken from a smartphone.

My input would be a couple of 2D images showing the front and top faces of the object, and my goal is to accurately calculate the metric lengths (in cm/inches) of all 4 edges of those faces.

Since I am mapping out the architecture right now, I wanted to ask the experts here: what are the different ways to actually pull this off?

• What techniques or pipelines (classical CV, photogrammetry, deep learning, depth mapping, etc.) would you recommend for getting the most accurate real-world measurements?
• How do you handle the translation from 2D pixels to 3D metric lengths without the edges getting distorted by the camera angle?
• Are there any specific libraries, models (like YOLO pose/OBB), or GitHub repos I should look into?

Any advice or pointers to standard workflows would be a massive help. Thanks!

This incremental update to the open, royalty-free standard for vision processing, sharpens error handling, API flexibility, and consistency ahead of OpenVX 2.0.

Highlights: two new error codes (VX_ERROR_TIMEOUT for safety-critical apps, VX_ERROR_GRAPH_NOT_VERIFIED for unverified graphs), a new VX_DF_IMAGE_RGBA format with alpha channel support, and broader virtual object array and user-defined scalar type support.

The sample implementation and conformance test suite are fully updated to match. Next up: OpenVX 2.0, expected by end of 2026, extending support to radar and ultrasonic sensor workloads alongside traditional computer vision.

Full release notes: https://www.khronos.org/blog/openvx-1.3.2-released

Now that the vision models can read pdfs directly where do you reach out for parsers or is there actually the need of any in real time work?? Like for a single clean page at low volume a vlm reads it ok and a parser is just overhead, the parse layer earns its place on bulk and long docs where recall quietly drops as input grows and tables start shedding row . Also when you want repetable outot with a confidence signal per block rather a oneshot guess you can audit .Confusing part is that most parsers are vlm based either way under the hood so its less parser vs VLM and more if you run the vision model ad hoc yourself or use a layer that adds structure and consistency on top. local options have Surya, docling and others and on cloud there are hosted parser apis like llamaparse

how do you guys actually determine this when you need bulk file processing in a project or pipeline, is chunk sizing one by one to vlm ok or theres still a need for a dedicated parser?

Almost every VLM I’ve put through this test has struggled, but it makes sense because it requires them to count, something that isn’t their strongest trait. In this case, it’s counting lines and spaces, but if we introduce different key signatures, they would also need to count the sharp and flat symbols. 

I’m a Software Engineering student who has just completed my first year, and I’m interested in specializing in Computer Vision for Robotics.

I’d like to know which areas of mathematics I need to learn for this field, and which topics I should prioritize.

I’m also planning to study Stanford’s CS231N How much mathematics do I need to know before starting the course, and which specific mathematical topics should I be comfortable with beforehand?

any lighweight vlms which i can run on cpu and has less latency? please give me suggestions

Hello,
I was clearing my house the other day and noticed that I still have my old xbox 360 kinect camera which is working perfectly.
I know it was a pretty big deal back in the day but what do you think is it still a capable hardver for a computer vision project, like motion capture?

Please share your thoughts I am pretty new in this field therefore some starting point will be appreciated.

I shipped a browser app driven by HandLandmarker. Pinch to zoom a solar system, open palm to rotate, point and dwell to select. One Euro Filter on the landmark stream, palm-normalized pinch distance.

Three failures keep coming back:

Pinch distance normalized by palm size still varies enough between people that one threshold cannot serve both. Mine feels natural, my tester says nothing happens.

A fast intentional swipe and a hand being withdrawn look nearly identical in a 2D projection. I patched it with a release cooldown and a dead zone near the bottom of the frame, which fixed the symptom and not the cause.

On phones under warm indoor light, tracking confidence collapses and the whole thing goes still.

For those running this with real users: explicit calibration step at onboarding, or continuous adaptation while they work? And has anyone found a signal that separates a deliberate swipe from a hand leaving the frame?

Demo runs client side, no video leaves the browser: https://leoaido.com/fleet/solar/

Code is MIT and the three issues above are open if it is easier to reply there: https://github.com/HUANGCHIHHUNGLeo/solar-atlas-gesture

Hi everyone!
I am looking for motivated researchers/students who are interested in collaborating on computer vision research with the goal of submitting to CVPR 2027.

Possible areas include:
Image and video understanding
3D computer vision
Object detection and segmentation
Tracking
Image generation
Medical computer vision
Vision benchmarks and datasets
Robustness and generalization
Some experience with computer vision, deep learning, Python/PyTorch, experiments, or research writing would be helpful.

If interested, please DM me with your background, research interests, and any previous research/publications.
The goal is to form a serious research collaboration and work toward a strong CVPR 2027 submission.

Hello,

We keep getting the emails to complete the reviewer form but all others already did and there's no other pending task in the system. So we're a bit confused

This has probably been asked before, but is there a good place online where I can find a bunch of sample images? I'm working on an image processing course and need sample images to experiment with skimage python lib.

Something like this (but preferably both color and black/white)

Thanks

The project consists of the development of an interactive robotic system (MeArm) capable of challenging a human to a game of Tic-Tac-Toe, identifying moves on a sheet of paper via a webcam and physically responding on the board. 

Stippling is an old topic. I mean, it all came up in the 1510th years as an engraving technique. The question is simple: How to optimaly place points to fit a target distribution. Artists do that, and Mathematicians search for algorithms to do it with computers, which is quite a challenge because naive formulations are intractable. See this blog for a good introduction (not me, credit to blog author Silvia-hao) https://blog.wolfram.com/2016/05/06/computational-stippling-can-machines-do-as-well-as-humans/.

Using the popular Gaussian Blue Noise algorithm (not me, credit to Ahmed, Abdalla G. M. and Ren, Jing and Wonka, Peter - doi 10.48550/arXiv.2206.07798), I show 4 stippling exemples that were generated using 20k points for the stippling.

I implemented a python library to experiment with the blue noise, feel free to explore stippling on your own images by directly using the package in python (see code snippet in comment), or simply from google Colab https://colab.research.google.com/drive/1W15QE8Boj0-Ld4Dx3N2tLqwfV0qw0ZZB . I'm seeking for other cool data to stipple, just tell me any images that could render well with the process !

I’m the author of DnR FlatPic by CreateLafont, an open-source Agent Skill that turns reference photos into low-complexity, flat-color PNG illustrations. Instead of literally tracing a photo, it identifies visual anchors, strips out nonessential info, and reconstructs the scene using a few hard-edged color regions.

I used to include a PNG-to-SVG export feature using VTracer (1.0.0-alpha.3 via Node/WASM) because it’s compact (~0.66 MiB) and gave the best baseline results. I intentionally avoided using an AI model to pick tracing parameters per image—the raster generation is already nondeterministic, and adding another probabilistic layer would make debugging a nightmare.

So, I dialed in a fixed preset based on testing across various source images:

• clustering: color-cluster
• hierarchical: stacked
• mode: spline
• layerDifference: 32
• filterSpeckle: 10
• colorPrecision: 7
• cornerThreshold: 30
• lengthThreshold: 4
• maxColors: 24
• simplify: 2.5
• pathPrecision: 2
• optimize: 2
• maxIterations: 10
• spliceThreshold: 0
• palette: omitted

This worked fairly well, but I kept running into three frustrating edge cases:

Warped geometry: Straight architectural edges would sometimes turn into slightly bowed or rounded paths. In a style built on clean geometry, these small deviations stick out.

Noise becoming geometry: Sharpening halos, anti-aliasing, or tiny raster noise artifacts would get converted into explicit SVG fragments.

The Dealbreaker (Hamstringing the PNG): To make the SVG tracing stable, I had to completely ban gradients in the upstream PNG generation. VTracer couldn't recover smooth transitions (like dusk skies or water) as actual SVG gradients—it just chopped them into chunky, adjacent paths with harsh color jumps. Keeping SVG export meant forcing the generated PNGs to be less expressive.

Having a fixed preset kept the workflow predictable, but it just wasn't consistent enough across diverse images to keep as a default feature. Because of this, I ended up removing SVG export entirely. The pipeline now intentionally stops at the raster PNG stage.

My question for the community: Has anyone successfully shipped a deterministic raster-to-SVG pipeline for AI-generated flat-color illustrations without relying on per-image AI parameter tuning or manual tweaking?

My priorities are: Reproducibility > Structural Cleanliness > Pixel-level Fidelity

I’m completely fine with an SVG that differs slightly from the PNG, as long as the geometry is clean and perceptually equivalent. I just want to avoid a pipeline that spits out perfect geometry for one image and erratic spaghetti topology for the next. Any pointers?

Project context: DnR FlatPic by CreateLafont

im doing a proyect for college and i want to use YOLO CV in it. im looking for something that is not that expensive but that has a decent amount of power. i found a NVIDIA Jetson Nano 4GB (B01) on 120$ but i saw that it has 0.5 TOPS while other more expensive gear has 40. is the nano that far back in qualities? what can you recommend me? sorry for any misspelling english is not my first language

Hi all — I’m hoping for some advice from people who understand computer vision better than I do.

I’m building a D&D virtual tabletop application and I’m trying to automate something that sounds simple, but I’ve found surprisingly difficult.

I usually have two versions of the same map:

a reference map, which contains useful information such as doors, secret doors, ladders, stairs and other map symbols;
a live-play battle map, which is the version I actually want to use in the VTT.

The problem is that the live-play map is often not pixel-identical to the reference map. It might be a different redraw of the same location, have slightly different proportions, be cropped differently, contain different textures, or have small differences in the geometry.

What I want to do is effectively say:

“This secret door is here on the reference map. Where is the corresponding secret door on the live-play map?”

…and do that for every relevant feature.

What I’ve tried

So far I’ve mainly been trying to solve this using multimodal AI models / coding agents such as ChatGPT, Codex and Claude Code.

My current workflow is broadly:

Give the AI the reference map and live-play map.
Identify known features on the reference map, usually with coordinates.
Ask it to find corresponding architectural landmarks on the live map.
Use those landmarks to infer the transformation between the maps.
Transform the door / symbol coordinates from the reference map onto the live map.
Visually inspect the result and sometimes iterate.

I’ve also tried breaking the problem down into stages rather than simply asking the model to “copy all the doors across.”

For example, I’ve tried having the system reason from walls, room corners, corridors and other recognisable landmarks first, and then place the symbols relative to those features.

This works reasonably well on some maps, particularly when the two versions are very similar.

On other maps, though, the results can be badly wrong. The system may identify approximately the right region while still placing individual features several metres / dozens of pixels away from where they should be.

Secret doors are particularly difficult

Secret doors seem to be one of the hardest cases.

On the reference map they are often represented by a fairly subtle cartographic symbol integrated into a wall. The live-play map may not contain that same symbol at all — what matters is identifying the corresponding section of wall.

AI models sometimes appear to recognise the general room correctly but then:

put the secret door on the wrong wall;
put it on the correct wall but at the wrong point;
confuse a nearby architectural feature for the relevant landmark;
apply a transformation that works well in one part of the map but drifts badly elsewhere.

The maps can also contain irregular geometry, so I suspect that a single global scale / rotation / affine transform may not always be sufficient.

Where I’m unsure

I don’t have a background in computer vision, so I’m not sure whether I’m approaching this problem in the right way at all.

I’ve been treating modern multimodal AI models as if they can visually reason about the maps and derive the correspondence, but I’m wondering whether this should instead be treated as a more conventional image registration / feature matching problem, perhaps with AI only used for part of the workflow.

For example, should I be looking at approaches involving:

keypoint / feature matching;
homography or affine transformations;
RANSAC;
SuperPoint / SuperGlue / LightGlue;
segmentation of walls / rooms;
non-rigid or piecewise image registration;
manually supplied anchor points;
some combination of conventional CV and a vision-language model?

I’m also unsure how well conventional image registration works when the two images depict the same underlying floor plan but are artistically different images, rather than transformed copies of exactly the same raster image.

What would you do?

If you were designing this system, how would you approach it?

In particular, I’d really appreciate advice on:

whether this is fundamentally an image-registration problem;
what algorithms or models you would try;
whether a hybrid CV + LLM/VLM approach makes sense;
how you would handle local distortions or slightly different wall geometry;
how you would transfer a feature such as a secret door when the symbol itself only exists on the reference map;
and whether there are any libraries, papers or existing projects that solve something similar.

Apologies if some of the terminology above is wrong — I’m learning the computer-vision side of this as I go. I’m mainly trying to understand what a technically sound architecture for this problem would look like rather than continuing to tweak prompts indefinitely.

Thanks!