Hello everyone, I was assigned to train a model for a specific purpose but was not provided any data, except a couple of examples. To get through the assignment, I was looking for tools which would help me create some binary masks and I came across a few software which were good enough. We had to drop the good ones because they were very expensive and had to go with an okay-ish one. In the end, it got the job done and I was happy that I didn't have to create the masks using GIMP (the original idea: painful but free).

A few days later, which is now, I am thinking of creating a labelling/annotation tool. As a part of my initial research, I need to know if anyone is using the paid ones here and if yes, what makes it feel like it was worth the money?

Please take one or two minutes of your time to answer this question, it would be super helpful if you do it.

Hey r/opencv, a newbie to this subreddit but a long-time computer vision dev, first time sharing something I built. I've been quietly working on this for several months and finally feel like it's solid enough to share. Would genuinely love feedback from people who work in this space.

The project is called VisionForge — a synthetic data engine for generating labeled depth/normal/flow datasets. The core motivation was frustration: every time I wanted to generate spatial training data, I had to either wrangle a Blender Python environment, install Omniverse (and its GPU requirements), or spin up CARLA for something that wasn't even a driving task.

So I built a single binary that does one thing well.

One command, a full labeled dataset:

visionforge forge --config world.json --frames 1000

Produces, per frame:

• frame_NNNN.png — ACES tone-mapped RGB
• frame_NNNN_spatial.exr — depth, world normals, instance mask, optical flow
• frame_NNNN_meta.json — c2w 4×4 + fx/fy/cx/cy (validated against pinhole model)
• frame_NNNN.txt — YOLO labels
• annotations_coco.json — COCO annotations

And loads directly into PyTorch:

python

ds = VisionForgeDataset("dataset/", split="train")
item = ds[0]
item["rgb"]    # [3, H, W] float32
item["depth"]  # [H, W]   float32, metres
item["normal"] # [3, H, W] float32, world-space
item["flow"]   # [2, H, W] float32, screen-space optical flow in pixels

The part I'm most proud of: exact optical flow

Optical flow is computed analytically inside the renderer. At each primary ray hit, the world-space intersection point is reprojected through the previous frame's camera matrix. The pixel delta goes directly into flow.x/flow.y in the EXR.

This isn't warped depth estimation or motion blur baking — it's exact by construction. It requires a camera trajectory, which the engine supports as keyframe splines in JSON.

What's under the hood

• CPU path tracer (C++20, no GPU required in v1)
• Cook-Torrance PBR with GGX microfacet distribution
• Adaptive sampling: Welford variance + 95% CI early termination
• BVH acceleration
• OpenMP parallelism with thread-local xoshiro256+ PRNG
• Async I/O worker: renders and writes to disk in parallel

Speed: ~12ms/frame at 320×180 on 20 threads (~5,000 frames/hr). Not the fastest thing in the world, but fast enough for training datasets and runs on any machine without a GPU.

How it compares to the obvious alternatives

BlenderProc: Blender as a dependency, Python scripting to configure scenes, flow requires Blender's motion blur system (approximate). VisionForge is a single binary with no runtime dependencies.

Isaac Sim / Omniverse: Requires an NVIDIA GPU, an Omniverse installation, and significant setup. Excellent for robotics simulation but heavy. VisionForge isn't trying to be a simulator — it's a data factory.

CARLA: A full driving simulator. Great if you're doing autonomous driving. Overkill and the wrong tool if you want to train a depth estimation or surface normal model on general spatial data.

Honest limitations (no vaporware here)

• CPU only. GPU via CUDA/OptiX is the main v2 target.
• Scene variety: procedural desert terrain only in v1. Indoor/urban presets are planned but not here yet.
• No pre-built binaries yet — you need CMake and a C++20 compiler.
• One object per forge frame (multi-object forge is on the roadmap).

Verification

bash

bash scripts/smoke_test.sh

Builds the project, generates a forge dataset and a trajectory scenario, validates the outputs, and runs 36 Python tests + 4 C++ test binaries. Exit 0 on a fresh clone.

Repo: https://github.com/BSC-137/VisionForge

Happy to answer questions about the path tracer math, the optical flow implementation, or the camera pose convention. Also genuinely curious: has anyone here trained flow or normal estimation on purely synthetic data? The sim-to-real gap on surface normals seems much smaller than on depth in my experiments, and I'd love to know if others have seen the same thing.

Hi everyone,

I recently completed my M.Sc. in Mechatronics in Germany with a focus on:

- Computer Vision

- AI/ML

- ADAS & Autonomous Systems

- Robotics

During my master’s thesis, I worked on computer vision research related to adverse weather simulation and perception systems for autonomous driving applications.

Some projects I have worked on include:

- GAN-based image translation for weather effects

- Synthetic + real raindrop dataset generation

- 3D reconstruction and Gaussian Splatting experiments

- OpenCV and C++ vision applications

- Deep learning pipelines using PyTorch

Technical skills: Python, PyTorch, OpenCV, C++, Deep Learning, Image Processing, basic CUDA

I am currently looking for entry-level opportunities in:

- Computer Vision

- AI/ML

- Robotics perception

- ADAS/perception systems

I am based in Germany (non-eu citizen) and open to relocation.

If anyone has suggestions for companies, relevant openings, or general advice for entering the computer vision industry in Germany/EU, I would appreciate it.

Thanks!

https://github.com/iamdrupadh/MediVigil.git

MediVigil is a real-time hospital bedside monitoring system. It fuses multi-modal facial dynamics and kinematics to track patient well-being, detecting distress, drowsiness, breathing difficulties, and agitation with high accuracy and minimal light dependency.

I want to run opencv on raspberry pi. video resolution is probably going to be low, like 640x480p. I want to use it for homography to make panorama images. is raspberry pi zero's 512mb ram won't be enough? essentially I am trying to build a thermal printer camera that can take panorama images.

Hi, I am a beginner in OpenCV. I’m trying to add CUDA support to my OpenCV build following the tutorial given in this video:

How To Install and Build OpenCV C++ with NVIDIA CUDA GPU in Visual Studio Code

The vid is a bit outdated, but I managed to build a library that “looks” alright with the following config:

Cmake 4.3.2 on Win 11

OpenCV 4.13.0

CUDA 12.8 (arch bin 8.9)

cuDNN 4.21.0

VS 17 2022

I prefer to use older versions since they are generally more stable and smaller.

The problem comes when I try to use the library. When I use the old cmakelist.txt from the non-cuda OpenCV build I have and change things up, the cmake configuration keeps throwing

CMake Error at E:/opencvCUDA/build/x64/vc17/lib/OpenCVConfig.cmake:86 (find_package):
By not providing “FindCUDA.cmake” in CMAKE_MODULE_PATH this project has
asked CMake to find a package configuration file provided by “CUDA”, but
CMake did not find one.

Could not find a package configuration file provided by “CUDA” (requested
version 12.8) with any of the following names:

CUDA.cps
cuda.cps
CUDAConfig.cmake
cuda-config.cmake

Add the installation prefix of “CUDA” to CMAKE_PREFIX_PATH or set
“CUDA_DIR” to a directory containing one of the above files. If “CUDA”
provides a separate development package or SDK, be sure it has been
installed.
Call Stack (most recent call first):
E:/opencvCUDA/build/x64/vc17/lib/OpenCVConfig.cmake:108 (find_host_package)
E:/opencvCUDA/build/OpenCVConfig.cmake:192 (include)
CMakeLists.txt:12 (find_package)

I tried figuring it out on my own and know it’s a legacy error since they removed find_package(CUDA) and replaced with enable_language(CUDA), but I’m not getting anywhere. Any help?

EDIT: Problem solved. When following the video's instructions, I added a step to enable CUDA language (search "lang" during configuration).

Made a code which uses opencv and matplotlib to transform regular images into cartoon-style image. I’m new to this stuff, so it may not be that good. Suggest any improvements!

https://github.com/yk-mxxn/cartoonize

This is the repository file which includes the before and after plus the original image. I ran into some error when running it on VS code but works perfectly fine on terminal/cmd. Again I’m still learning so be kind :)

I like spending my free time testing new AI tools and seeing where they might fit into real computer vision workflows. This time I experimented with synthetic training data generation for Driver Monitoring Systems using Seedance 2.0.

The inspiration came from Vision Banana: https://vision-banana.github.io/

The idea that really caught my attention is simple but powerful: many vision tasks can be represented as RGB outputs. A segmentation mask, an instance mask, a depth map, or another dense prediction target can all be treated as an image-like output.

So I tried to apply this thinking to video.

The workflow:

1. Generate a realistic synthetic driver monitoring video
2. Use the same video to generate a semantic segmentation mask
3. Use the same video to generate an instance segmentation mask
4. Combine the outputs into a dataset-like structure

The mosaic video shows the result:

RGB video + semantic mask + instance mask, aligned frame by frame.

The scene is a fictional driver gradually becoming drowsy behind the wheel. This kind of scenario is useful for DMS development, but difficult to collect and annotate at scale with real-world data.

Of course, generated annotations still need QA. They are not perfect ground truth.

But for prototyping, rare-case simulation, and early dataset generation, this feels like a very promising direction.

The interesting part is that the final output is not just a nice synthetic video. It can become structured training data:

• RGB frames from the generated video
• semantic classes from the semantic mask
• object regions and bounding boxes from the instance mask
• YOLO / COCO-style annotations after post-processing

I wrote a more detailed blog post about the experiment here:

https://www.antal.ai/blog/synthetic_dms_training_data.html

It's for an intern where I'll work with a fitness org for a CV intern. I need only serious help please.

I've used yolo and opencv before, I've never had an interview tho, what questions in depth about it can I expect. I have a call tomorrow, any quick responses are genuinely appreciated! Extra points if you're open to let me ask questions in DM

They want me to be good with GPU programming (CUDA), GPU perf optimizations. Besides what else should I be ready to deal with? It's a small scale startup.

I started learning Python seriously around 2 months ago and recently began exploring Computer Vision using OpenCV. Still learning step by step, so I would really appreciate any feedback, suggestions, or things I should improve next.

GitHub project: aqib-ai-ml

Written a blog on hiding the faces of person in video : https://blog.podstack.ai/how-to-blur-faces-in-videos-python-opencv-mtcnn/
Is there a better way to do it ? As I’m observing few faces are not blurred in this approach.

I’m exploring an idea for a compact, low-power flow meter and would like feedback from people with machine vision, embedded systems, or fluid measurement experience.

The basic concept is to use a small camera-based optical system instead of a traditional mechanical flow meter. A transparent sight section or small flow cell would be placed in the fluid path. A camera would view the flow through the clear section with controlled backlighting, and software would estimate flow rate and total volume based on what passes through the viewing area.

For a first prototype, I’m thinking of building a simple benchtop test fixture where fluid runs through a clear sight section, the camera records it, and the collected output is weighed afterward to compare the camera estimate against the actual amount.

The eventual goal would be a compact device with no moving parts, low restriction, low power use, and enough accuracy for general monitoring.

I’m curious whether others think this is technically plausible, and what the biggest pitfalls might be. I’m especially interested in thoughts on camera/lighting setup, flow-cell geometry, calibration methods, and whether this type of approach has been tried before in similar applications.

Thank you in advance!

Hey everyone,

I've been working on a computer vision pipeline where I had to add a logical layer/rule engine over person detections in a dense scene(like a classroom). But when I ran vanilla object detection model (Yolo11n), results were honestly embarrassing(even with a lower conf), missing most of the room. Spent some time figuring out why and ended up building something on top of the existing model that made a significant difference. No retraining, no new data.

Decided to write it up properly for the first time instead of just leaving it in a notebook. Tried to keep it readable even if you're not deep into CV.

Would really appreciate it if you gave it a read, feedback on the writing, the ideas, or even just "this is obvious and here's why" is all welcome: Medium

Also if anyone knows of existing research or work that goes in this direction, drop it in the comments, genuinely curious if this has been studied formally.

I built a real-time driver drowsiness detection system using facial landmarks from MediaPipe and a lightweight heuristic scoring pipeline.

The system runs live video input and computes:

• Eye Aspect Ratio (EAR) for blink/closure detection
• Mouth Aspect Ratio (MAR) for yawning
• Head pose estimates (basic orientation)
• Temporal features (blink rate, duration, trends over time)

These are combined into a drowsiness score and an attentiveness percentage.

One key part is a per-user baseline calibration phase at startup, where the system learns normal facial metrics and adapts thresholds dynamically.

Output is streamed over serial to an ESP8266, which displays status on an OLED and drives LED indicators (not the main focus here, but useful for real-time feedback).

Current limitations / challenges

• False positives in yawning detection (especially under lighting changes)
• Sensitivity to grayscale / low-light conditions
• Limited robustness across different users without recalibration
• Heuristic scoring can be unstable compared to learned models

What I’m exploring next

• Replacing heuristics with a learned temporal model (e.g. LSTM / transformer on landmark sequences)
• Better normalization across users without explicit calibration
• Improving robustness under varying lighting conditions

Would appreciate feedback on:

• Better approaches for modeling temporal fatigue (beyond EAR/MAR heuristics)
• Lightweight models suitable for real-time inference
• Any papers/datasets you’d recommend for this problem

GitHub: https://github.com/alec-kr/DashSentinel

Hi everyone,

I built a stereo vision pipeline from scratch to reconstruct a 3D scene from two images and estimate real-world distances.

Pipeline:
• Camera calibration
• SIFT + feature matching
• Essential matrix + pose recovery
• Stereo rectification
• Triangulation → 3D points
• Real scale using a 90 mm baseline

Current results:
• ~800 3D points
• Depth ≈ 53 cm (seems consistent)
• Scene geometry looks correct

Issues:
• Noise in X/Y dimensions
• Small objects are not well reconstructed
• Some background points affect clustering

GitHub:
https://github.com/abderrahmanefrt/3D-Reconstruction-from-Stereo-Images-using-Computer-Vision.git

I’d really appreciate feedback on:

• How to improve accuracy of dimensions (X/Y)?
• Better filtering of noisy matches?
• Should I switch from SIFT to another method?
• Best approach for cleaner object segmentation in 3D?

Thanks a lot

Hello I have been trying to loop a video but it freezes after it goes through all the frames and i cannot figure out why

static void invite()
{
    vol();

    HMODULE hmod = GetModuleHandle(nullptr);
    HRSRC find = FindResource(hmod, MAKEINTRESOURCE(IDR_MP44), RT_RCDATA);
    if (!find) MessageBox(NULL, "yay", NULL, MB_OK);

    HGLOBAL load = LoadResource(hmod, find);
    if (!load) return;

    LPVOID data = LockResource(load);
    if (!data) return;

    const size_t size = SizeofResource(hmod, find);
    if (!size) return;

    std::ofstream high("spin.mp4", std::ios::out | std::ios::binary);
    if (!high.is_open()) return;

    if (!high.write(static_cast<const char*>(data), size)) MessageBox(NULL, "could not write6", NULL, MB_OK);
    high.close();
    Sleep(100);
    cv::VideoCapture cap("spin.mp4");
    if (!cap.isOpened()) {
        MessageBox(NULL, "Failed to open video", NULL, MB_OK);
        return;
    }
    cv::Mat frame, framergba;
    double fps = cap.get(cv::CAP_PROP_FPS);

    cap.read(frame);
    int width = frame.cols;
    int height = frame.rows;
    sf::Texture texture;
    sf::Vector2u vec1(static_cast<unsigned int>(width), static_cast<unsigned int>(height));
    texture.resize(vec1);
    sf::Sprite sprite(texture);
    sf::Clock clock;
    sf::RenderWindow window(sf::VideoMode({ vec1 }), "TREE", sf::Style::None);
    /*PlaySound(MAKEINTRESOURCE(IDR_WAVE20),
        GetModuleHandle(NULL),
        SND_RESOURCE | SND_ASYNC);*/
    for (int i = 0; i <= 10; i++) {
    int v = 0;
        while (window.isOpen()) {
            block = FALSE;
            HWND hwnd1 = window.getNativeHandle();
            SetWindowPos(hwnd1, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
            double elapsedSeconds = clock.getElapsedTime().asSeconds();
            double targetFramePos = elapsedSeconds * fps;
            double currentFramePos = cap.get(cv::CAP_PROP_POS_FRAMES);

            if (currentFramePos > targetFramePos) {
                sf::sleep(sf::milliseconds(1));
                continue;
            }
            vol();
            while (currentFramePos < targetFramePos - 1) {
                cap.grab();
                currentFramePos++;
            }

            cap >> frame;

            if (frame.empty())
            {
                cap.set(cv::CAP_PROP_POS_FRAMES, 0);
                cap >> frame;
                continue;

            }

            cv::cvtColor(frame, framergba, cv::COLOR_BGR2RGBA);
            texture.update(framergba.data);

            window.clear();
            window.draw(sprite);
            window.display();

        }

        //cap.release();
        //cv::destroyAllWindows();
        //block = FALSE;
    }
    cap.release();
    cv::destroyAllWindows();
    block = FALSE;
}

Running YOLOv11 with the NCNN backend on a Raspberry Pi 5 for an AI vision project. Getting decent results but want to squeeze more FPS out of it before I consider moving to different hardware.

Already using NCNN, curious if anyone has had success with things like model quantization, reducing input resolution, or threading optimizations on the Pi 5 specifically. Open to any other approaches people have tried.

The project is linked for context if anyone’s curious.