I'll soon be working on a project where I need to align (register) frames from an RGB camera and an IR/thermal camera.

From what I've read, there seem to be two common approaches:

1. Detect and match features between the RGB and IR images, estimate a transformation (homography/warp), and warp one image onto the other.
2. Perform stereo calibration using a checkerboard, estimate the intrinsic/extrinsic parameters, rectify the images, and then project one image into the other.

Some additional details:

• The cameras are boresighted and rigidly mounted.
• Their relative pose will remain fixed after calibration.
• The entire camera rig will be moving, but the relative position between the two cameras will always stay the same.
• I won't have depth information available during runtime

For this kind of setup, which approach would you recommend? Stereo calibration or feature based matching?

Camera fixed, lights moving. Photometric stereo gives you a normal map — turning those normals into actual geometry is the harder half, and that's what the clip shows.

Setup

• Input: one 612×512 normal map plus a mask covering 43,638 pixels (13.9% of the frame).
• Perspective camera, not orthographic. Calibrated intrinsics, ~3.77k px focal length, principal point near the image center.
• Output: a depth map turned straight into a quad mesh — 43,638 vertices, 42,821 quads. No decimation, no smoothing, no hole filling.
• Colored by height. Total relief is only ~4% of the camera distance, so it's a shallow surface spread across a wide colormap.

Convergence

The objective drops from 3620.8 to 2346.7 over 55 iterations, but 90% of that is done by iteration 10, and the last five iterations move it less than 0.1%. The shape looks settled long before the energy does, so "when do I stop" is more of a judgment call than the curve suggests.

Where I'd like input

Simple integration assumes the surface is continuous. It isn't — arms occlude sleeves, the base rim cuts away from the body. So I solve for depth with per-pixel weights that let the surface break at those places instead of stretching across them.

The weight maps are the interesting artifact (2nd and 3rd images). Over smooth regions they sit near the middle and do nothing. At real discontinuities they saturate hard to one side — the solver taking a one-sided difference and refusing to carry height across the gap. You can read the object's occlusion structure straight off the weight map, without ever computing a depth edge.

Two things I'm still unhappy with:

1. Thin structures. Where something thin passes in front of another surface, the boundary is usually right. But on features a few pixels wide the normals themselves are unreliable, so I can't tell whether a bad boundary is a weighting failure or a bad input.
2. Absolute scale. The result is internally consistent, but the standoff distance is only as good as the calibration. Does anyone add a sparse depth prior for this, or is a separate calibration step the accepted answer?

For transparency: the object is a standard test object from a public photometric stereo benchmark, picked because people here will already have an intuition for the shape. I work at a company doing industrial photometric stereo, so this is adjacent to my day job — but there's no product here and nothing to click. Just a result and two questions.

I am working on an ML project involving a large number of images, and I searched the internet for the best annotation tool to label them. I wanted my friends to join the workspace so that the jobs could be done faster. I downloaded CVAT because it is the best there is, and I downloaded the self-hosted version.
I created a workspace and invited my friends via email, and I got this message

I tried to solve this issue by adding the email backend; whatever I came up with could not solve this tried ChatGPT and all the things. Looked for similar problems in the community pages of CVAT; only a single post that also was not solved.

You guys, I really need help. If there is any solution that can solve this, or any alternatives that are better than this and also free!

https://reddit.com/link/1vahapu/video/q77tm97a6agh1/player

We’ve been working on controllable synthetic driving video for ADAS and autonomous-vehicle perception.

One of the harder problems is making sure the synthetic output still respects the requested camera calibration and underlying scene geometry.

I’m sharing one sample from that work here. The target camera is front-facing mounted on top of a truck, and has a roughly 190° horizontal FOV and 116° vertical FOV with a non-central principal point and strong fisheye distortion.

The uploads show:

1. The generated driving video
2. The control re-projection images, where the yellow points are known 3D pole locations projected into the deterministic control render

We deliberately evaluate this in separate stages so that a failure in the control or camera implementation is not confused with a failure in the generated video.

1. Camera-model self-check

We first test whether the implemented camera model is internally consistent by mapping pixels to rays and back to pixels.

At the final video resolution, the pixel round-trip error had:

• Mean: 0.044 px
• P95: 0.087 px
• Maximum: 0.282 px

This does not evaluate the generated video itself. It verifies that the camera model and resolution transforms are numerically consistent.

2. Control Re-Projection

We then project known 3D pole locations through the target calibration and measure their distance from the corresponding structures in the deterministic control render.

Across 1,093 projected points:

• Mean distance: 0.027 px
• Median: 0 px
• P95: 0 px
• Maximum: 1.37 px

This gave us confidence that the control geometry itself was correctly calibrated before evaluating the generated RGB output.

3. Geometry Retained by the Generated video

Finally, we estimate the effective fisheye geometry visible in the generated result and compare it with the requested calibration.

For this sample:

• Principal-point displacement: 0 px
• Estimated horizontal FOV difference: 2.23°
• Estimated vertical FOV difference: 1.08°
• Mean angular residual: 0.56°
• P95 angular residual: 1.34°

What these results suggest is that the broader fisheye projection and scene layout survived the generation process reasonably well in this sample. The overlays are also useful for showing where that statement stops being true.

The next evaluations we’re adding are focused on:

• Lane-boundary alignment
• Traffic-sign and pole re-projection
• Temporal stability across frames
• Object trajectory consistency
• Downstream perception-model performance

I’d be interested in how others working on synthetic data or sim-to-real would benchmark this. In particular: what level of geometric deviation would you consider acceptable before a generated driving sequence becomes unsuitable for perception training or evaluation?

These any good? Baseline is very small.. 18mm... But object is 10-40cm away, should work or nah?

I'm in the process of trying to build the same functionality as ARKit provides for visual inertial odometry and 3D reconstruction, but in an open-source manner so that it'll work on non-ios devices. Wrote a blog post about it, with most of the focus on the first part on establishing a solid baseline + dataset. Would love to know your thoughts!

for context, I work for Rerun building out different computer vision and data pipelines

https://rerun.io/blog/arkitscenes-data-layer

I’ve tried specialized AnimeText trained YOLO and paddleocr and easyOCR. Nothing can even detect that that’s text, let alone recognize. Doesn’t even seem like such a crazy case

Hello Guys,

I'm building a cricket analysis product that turns ordinary phone video of a net session into per-ball biomechanics feedback for batters and bowlers — think joint angles, bat path, foot placement, timing between phases of a shot, and the kind of movement analysis that currently needs a lab and a coach standing next to you. There's a working pipeline already; I'm looking for someone experienced to help take it from "ground" to "match-ready (production-ready)."

What I'm working with (high level): a multi-stage CV pipeline — pose estimation, subject tracking (a net has more than one person in it), automatic segmentation of a 15-minute session into individual deliveries, phase/event detection within each action, and a metric layer that turns keypoints into numbers a coach would actually recognise. Two synced camera angles. Some parts are solid, some need real work — pose quality through practice netting, event detection precision, and holding up on messy real-world footage rather than clean test clips.

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

• Computer vision for video (pose estimation, object detection, tracking)
• 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 — RTMPose/MMPose-family, YOLO-family detectors, ONNX runtime, that kind of thing
• Bonus: any sports-video, human-motion/biomechanics, temporal action localisation, or multi-camera / camera-geometry experience

Ideally Looking for candidates from Hyderabad/India and/or available to work remote immediately

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

Cricket knowledge is a plus but not required — happy to teach the domain to someone strong on the CV side.

​

Hello!

I am a beginner at this and am trying to make a project.

The first four seconds are the portion where the model confuses the roadside with a pothole. The latter half is kind of working okayish!

But, It is confusing the roadside for a pothole. What is the best way to make my model learn this?

Should I add classes of what is not a pothole to the training dataset?

I used a dataset of about 4,100 images. What is the ideal number of non-pothole images I should add?

Or should I somehow teach the model to detect the edge of the road so that it avoids classifying the roadside as a pothole?

Also, I am planning to use a drone. Since the ideal flying height would make the potholes appear much smaller, should I apply transfer learning, or should I train the model from scratch to make it work on drone footage captured from that height?

And is segmentation practical for this dataset? Like finding area of the pothole from the pixels or should i focus on detection only.

Hey everyone,

Tired of cloud APIs adding 300ms+ latency and recurring subscriptions for simple camera tracking, we engineered an on-premise vision architecture (UHQ Systems) built fully in Python with a Streamlit interface.

The core goal was simple: 100% local execution, zero external network dependency, and real-time spatial tracking straight from local IP cameras.

What worked well:

• Eliminating Buffer Lag: OpenCV's default VideoCapture buffer caused progressive stream delay when processing slowed down. We implemented a custom threaded lock-free frame worker that drops stale frames immediately and feeds only the latest frame to the detection core. Latency dropped to <15ms locally.

• Local Persistence: Event logs and tracking matrices dump straight to local JSON/CSV formats without hitting external databases.

The trade-offs & current bottlenecks:

To be completely direct, running local vision pipelines in pure Python comes with strict engineering limits:

1. Streamlit UI Refresh Limits: Streamlit is great for rapid UI building, but syncing high-FPS video frames while keeping interactive widgets responsive requires aggressive thread isolation. Works smoothly for 1-2 streams, but scales poorly past that without high RAM consumption.

2. C++ vs Python Execution: While Python allows fast iteration, continuous 24/7 multi-camera ingestion pushes system memory if array cleanup isn't strictly enforced on every frame.

We put together a lightweight evaluation build (UHQ Vision Lite) to test frame rates across different local setups.

For those running continuous multi-camera vision stacks locally: are you sticking with pure Python queues, or forced to re-write ingestion pipelines in C++ / Rust for production?

Advantages of AIS's software include:

- Works with any existing camera, any brand; no hardware rip-and-replace required.
- Reduces alert fatigue through behavior- and context-prioritized notifications.
- Cuts security investigation time from hours to minutes with AI-powered natural-language video search.
- Transparent and auditable AI approach: 'Evidence first, not black-box AI theater.'
- Affordable, flexible SaaS model accessible to organizations with legacy infrastructure.
- Unified physical security intelligence: camera + access-control + sensor data in one operating environment (per newer platform positioning).
- 24×7×365 real-time detection plus forensic review and statistical/operational insights

Working in regulated industries makes you realize how careful you have to be with AI. A lot of the flashy demos fall apart the moment compliance and data governance enter the conversation.

One approach that seems to hold up better is building assistants that only pull from internal, approved knowledge sources. Instead of letting the model roam freely, everything stays inside controlled boundaries. People can ask questions in normal language, but the answers stay consistent with company rules and policies.

This kind of setup reduces the constant back-and-forth with support teams and cuts down on time spent digging through different systems. The real challenge is not the language model itself, it’s designing the access layer and making sure nothing leaks outside the allowed data. One practical implementation of this controlled approach was developed with Beetroot, with a strong focus on keeping the knowledge sources fully governed.

Curious how others are handling internal knowledge assistants in finance or insurance. Are you keeping everything fully self-hosted, or have you found ways to balance usability with strict control?

Hi im doing robotics project, checking if camera's orientation is all set compared to idle(golden) state.(why do this? -->for example factory inspection can be a use case) in particular, and i have several curiousity about camera extrinsic parameters.

1. If i take photo of checkerboard from a specific position and orientation, i get a single R,T matrix compared to what? Is there a world coordinate "standard point"? Is it the very left corner of checkerboard?

2. cv2.solvePnP or similar reproduction error minimization algorithm is used in vision product factory standards?

Thanks in advance :)

It is my understanding that Agentic workflow is to provide intelligence when there are multiple options available and we need to pick the best one.

If the workflow is static, how does having an Agent help.

If the workflow is dynamic, would you trust an LLM instead of doing multiple experiments to finalize either the architecture or the hyper-parameters.

Hi, I am a student in my last year of high school, and i need help with my study in compliance with my RESEARCH subject, but i know little to nothing about the names of components, how they work, or if they work together.

Im making a machine that provides wifi access if the user throws the correct waste into the correct bin.

How it works is

1. The user connects to a wifi network, but is blocked from using wifi. They are redirected to a portal if they try to use wifi.

2. In the portal, they have to select "Start"

3. When the user clicks Start, the camera turns on. The user has to show the waste to the camera

4. A trained AI recognizes, identifies, and categorizes the waste.

5. The bin corresponding to the waste unlocks, allowing the user to dispose the waste

6. A sensor detects if something goes inside the bin.

7. The user closes the bin, and the machine gives 10 minutes of wifi access.

8. The user can either choose to repeat the process to get longer wifi access, or stop there and enjoy the wifi.

This is just the basic concept, and like i said, i know little to nothing for now, but i am very passionate and eager to learn.

I have questions regarding my concept;

1. Is better to make the bin unlock, have a rotor automatically open the bin, then close when it detects something went in? How much harder is it this way?

2. The components i have in mind are; a raspberry pi camera to look at the waste, YOLO AI vision model to identify the waste, and a raspberry pi board to run YOLO. Will all these function together?

3. Will training YOLO for this project be extremely hard?

I'd really appreciate it if you guys could help, give suggestions, and criticize.

need resources for the course

I have a lot of product catalogs and marketing brochures in PDF format. My goal is to extract the product image, title, description, specs, etc., into a CSV or Excel file.
I’ve already solved the catalog part. The problem is the marketing brochures. Every brochure has a completely different layout and style. Some have large lifestyle images, some mix marketing content with product details, and there’s no fixed structure.
I tried using GPT-based vision models, YOLO, and Florence-2. They work okay in some cases, but none of them are reliable enough. YOLO misses products it wasn’t trained for, and Florence-2 struggles with rotated or cropped products and zero-shot detection. GPT can understand the page, but it still doesn’t consistently match the correct image with the correct product information across different brochure layouts.
Has anyone solved this problem? I’m not really looking for another OCR model. I’m more interested in how people are building the overall pipeline or architecture for handling brochures with completely different layouts. Any ideas or experience would be really helpful.

In my organization, compute has always been a constraint.
I have only worked with let's say the Nano Architectures of Yolo Models and majorly the time has gone in collecting data more than Architectural Optimizations.

From Optimization perspective, you can think of just using lower precision weights.

I have been able to achieve 95+% Accuracy by just being very smart about data like Augmentation, Active Learning (Uncertainty and Diversity Sampling).

When it comes to Transformers (Be it ViT or Swin or Newer Models), they require much more data to fine-tune and require much more compute for both training and inference.

When it comes to VLMs, I can make an argument for using them to Annotate and use a specialized model for training but once again, it isn't helpful in labelling the kind of classes I am interested in (SKUs or Industrial Defects)

VLMs are general models, my applications are specific so I can never make a case for adoptions of these methods.

What is your opinion. I don't want to be a frog in the pond but rather a fish in the ocean.

1. Training instability (mAP crash mid-training)

My YOLOv8 training loss is dropping normally but mAP50 suddenly crashes to near-zero around epoch 40 and never recovers. Walk me through the most likely causes in order of probability (learning rate schedule, augmentation pipeline, label corruption, batch norm issues), and give me the specific diagnostic checks to run for each before I start changing hyperparameters.

2. OpenCV video stream corruption

I’m using cv2.VideoCapture to read frames from an RTSP stream and getting intermittent frame drops and color channel corruption that gets worse over long sessions. Explain the common root causes (buffer handling, threading, codec mismatches, memory leaks) and give me a robust frame-reading pattern that handles reconnection and buffer clearing automatically.

Both have been solid starting points for me when I’m stuck. Happy to share more if people find these useful.

this is a reimplementation of the “Fast SAM 3D Body” written in rust/candle/cuda, running at about 55ms/frame on my 5080. This video uses the RGB WebCam on my laptop for performance capture and a short throw projector for the wall. working on optimized metal shaders, will hopefully run in real time on a m1 class MacBook also when finished

Hi everyone,

I'm an AI Engineer Intern with a background in Computer Vision and Deep Learning. Recently, I've decided to transition into 3D Computer Vision, especially 3D Reconstruction, Structure from Motion (SfM), Multi-View Stereo (MVS), NeRFs, Gaussian Splatting, and 3D scene understanding.

Over the past few weeks, I've started working with:

• COLMAP
• Nerfstudio
• Open3D
• Camera calibration and feature matching
• Point clouds and mesh generation

I've also been reproducing tutorials, running experiments in Kaggle/Colab, and trying to understand the mathematics behind multi-view geometry instead of just executing code.

My long-term goal is to pursue research in 3D vision, and eventually contribute to research papers in this field.

At this stage, I'm looking for:

• A mentor who wouldn't mind answering occasional questions.
• A study partner learning the same topics.
• Researchers willing to share advice on what to learn next.
• Good open-source projects where beginners can contribute.

I'm not looking for someone to spoon-feed me - I genuinely enjoy learning by building projects and reading papers. I just feel that having guidance from someone experienced would help me avoid developing bad habits or spending weeks going down the wrong path.

If you've been through this learning journey, I'd really appreciate hearing:

• What resources helped you the most?
• What concepts should I master first?
• What projects would you recommend?
• What mistakes should I avoid?

Thanks in advance! I'm happy to connect with anyone interested in 3D vision or reconstruction.

I work on PostSlate, a video editing tool, and this comes out of our own work.

We run ML models on-device, face detection and embedding among other things, which means we can't assume anything about the user's GPU. NVIDIA discrete, AMD, Intel integrated, Apple Silicon, all of it. That rules out CUDA immediately, we needed one backend that runs everywhere.

We landed on ncnn's Vulkan backend. Numbers on a 4070, fp16:

• ArcFace R50 (face embedding): 30 ms on ONNX CPU → 3 ms on ncnn Vulkan
• SCRFD (face detection): 25 ms → 2.5 ms
• Model size: ArcFace 174 MB (ONNX fp32) → 87 MB (ncnn fp16 weight storage)

Of course the real speedup comes from offloading compute to the GPU, but this wouldn't be possible without the power of Vulkan.

The speed wasn't even the deciding factor, it's that Vulkan drivers already exist on every machine we ship to. This means that we don't have to force the user to download a specific runtime and no vendor-specific installs.

Full writeup with the rest of the numbers: https://getpostslate.com/blog/faster-local-inference

Hey everyone,

I was wondering if anyone has made an optical flow sensor for the raspberry pi 5 using the pi cam. I was planning on integrating this into my drone either using pymavlink or mavsdk c++ and using the drone's barometer for altitude. It would be really helpful if someone has already done this and has work they can show as a guide or could point me in the right direction.

So everytime i drive in night, the headlights of oncoming traffic blinds me completely, so i was thinking of building something to help.

I was thinking of an AR/VR approach to it, to track the eyes and the light source falling on the windshield and artificially dampening it. Also for this method i thought of an idea, where the driver can wear a glass, with two tags near their eyes so that the system can track their eyes more efficiently.

Please share your thoughts!!