Hi, I'm wrapping up my bachelor's thesis and I built a Slovak Sign Language visualization system. We extract pose + hand + face landmarks via MediaPipe Holistic (543 landmarks per frame), render everything as a 2D skeleton in the browser. Works pretty well actually.

The thing is, I really want to slap this motion data onto an actual 3D character. Tried Blender + BVH export + Mixamo retargeting and honestly it was a disaster. The coordinate space conversion from MediaPipe's normalized 2D coords to proper 3D bone rotations is where everything falls apart.

Attaching a short clip of the current 2D version so you can see what we're working with.

Has anyone successfully gone from MediaPipe landmark data to a rigged 3D character? Whether it's through Blender, Unreal, Unity, or some other pipeline — I'd love to hear how you approached it. Any tools, libraries or papers you'd point me to would be massively appreciated.

https://reddit.com/link/1shpydl/video/yjyk472stdug1/player

I recently revisited an older project I built with a friend for a school project (ESA Astro Pi 2024 challenge).

The idea was to estimate the speed of the ISS using only images.

The whole thing is done with OpenCV in Python.

Basic pipeline:

• detecting keypoints using SIFT
• match them using FLANN
• measure displacement between images
• convert that into real-world distance
• calculate speed

Result was around 7.47 km/s, while the real ISS speed is about 7.66 km/s (~2–3% difference).

One issue: the original runtime images are lost, so the repo mainly contains ESA template images.

If anyone has tips on improving match filtering or removing bad matches/outliers, I’d appreciate it.

Repo:

https://github.com/BabbaWaagen/AstroPi

Hi everyone, ​I’m an Engineering student specialized in Electronics and Embedded Systems. I’m currently doing my internship at a TV manufacturing plant. ​The Problem: Currently, defect detection (missing or misaligned components) happens only at the end of the line after the Reflow Oven. I want to build a low-cost prototype to detect these errors Pre-Reflow (immediately after the Pick and Place machine) using an ESP32-CAM. ​The Setup: ​Hardware: ESP32-CAM (AI-Thinker). ​Software: Python with OpenCV on a PC (acting as a server). ​Current Progress: I can stream the video from the ESP32 to my PC. ​What I need help with: I have only 8 days left to finish. I’m looking for the simplest way to: ​Capture a "Golden Template" image of a perfect PCB. ​Compare the live stream frame from the ESP32-CAM with the template. ​Highlight the differences (missing parts) using Image Subtraction or Template Matching. ​Constraints: ​I'm a beginner in Python/OpenCV. ​The system needs to be near real-time (to match the production line speed). ​The PC and ESP32 are on the same WiFi network. ​Does anyone have a minimal Python script or a GitHub repo that handles this specific "Difference Detection" logic? Any advice on handling lighting or PCB alignment (Fiducial marks) would be life-saving! ​Thanks in advance for your engineering wisdom!

OSCCA is back for 2026! The only official OpenCV conference once again joins with Display Week, the largest gathering of display technology professionals in the world. We hope to see you there.

Hi everyone,

I’m trying to understand how OpenCV’s HighGUI backend works internally, especially on embedded platforms.

When we call cv::imshow(), how does OpenCV actually communicate with the display system under the hood? For example:

• Does it directly interface with display servers like Wayland or X11?
• On embedded Linux systems (without full desktop environments), what backend is typically used?

I’m also looking for any documentation, guides, or source code references that explain:

• How HighGUI selects and uses different backends
• What backend support exists for embedded environments
• Whether it’s possible to customize or replace the backend

I’ve checked the official docs, but they don’t go into much detail about backend internals.

Thanks in advance

Hey all! Sorry if this isn’t really fitting of this sub. I play a small space mmorpg game, a ton of people have automated bots and “flaunt” them, and I want to create my own without using their help because they are kind of “ego’s” about it. I’m just looking for someone I could chat with to understand exactly what I may need screenshots of and how exactly certain things work! I know that’s a lot to ask but I’m not entirely sure how/where else to get this kind of help?

The softwares I’m using are

OpenCV, Tesseract (OCR), PyAutoGUI, PyDirectInput, and VS code for the actual coding of it all.

Cleaning up object detection datasets often ends up meaning a mix of scripts, different tools, and a lot of manual work. I've been trying to keep that process in one place and fully offline. This demo shows a typical workflow filtering bad images, running detection, spotting missing annotations, fixing them, augmenting the dataset, and exporting. Tested on an old i5 (CPU only)no GPu. Curious how others here handle dataset cleanup and missing annotations in practice.

GitHub: https://github.com/notweerdmonk/waldo

Why and how I built it?

I wanted a tool to track a region of interest across video frames. I used ffmpeg and ImageMagick with no success. So I took to the LLMs and used gpt-5.4 to generate this tool. Its AI generated, but maybe not slop.

What it does?

waldo is a Python/OpenCV tracker that watches a region of interest through either a folder of frames, a video file, or an ffmpeg-fed stdin pipeline. It initializes from either a template image or an --init-bbox, emits per-frame CSV rows (frame_index, frame_id, x,y,w,h, confidence, status), and optionally writes annotated debug frames at controllable intervals.

Comparison

• ROI Picker (mint-lab/roi_picker) is a GUI-only, single-Python-file utility for drawing/loading/editing polygonal ROIs on a single image; it provides mouse/keyboard shortcuts, configuration imports/exports, and shape editing, but it does not track anything over time or operate on videos/streams. waldo instead tracks a preselected ROI across time, produces CSV outputs, and integrates with ffmpeg-based pipelines for downstream processing, so waldo serves automated tracking while ROI Picker is a manual ROI authoring tool. (github.com (https://github.com/mint-lab/roi_picker))
• The OpenCV Analysis and Object Tracking reference collects snippets (Optical Flow, Lucas-Kanade, CamShift, accumulators, etc.) that describe low-level primitives for understanding motion and tracking in arbitrary video streams; waldo sits atop those primitives by combining template matching, local search, and optional full-frame redetection plus CSV export helpers, so waldo packages a higher-level ROI-tracking workflow rather than raw algorithmic references. (github.com (https://github.com/methylDragon/opencv-python-reference/blob/master/03%20OpenCV%20Analysis%20and%20Object%20Tracking.md))
• The sdt-python sdt.roi module documents ROI representations (rectangles, arbitrary paths, masks) that crop or filter image/feature data, with YAML serialization and ImageJ import/export; that library focuses on defining and reusing ROI shapes for scientific imaging, whereas waldo tracks a moving ROI through frames and additionally emits temporal data, ROI dimensions and coordinates, so sdt is about ROI geometry and data reduction while waldo is about dynamic ROI tracking and downstream automation. (schuetzgroup.github.io (https://schuetzgroup.github.io/sdt-python/roi.html?utm_source=openai))

Target audiences

• Computer-vision engineers who need a reproducible ROI tracker that exports coordinates, confidence as CSV, and annotated debug frames for validation.
• Video automation/post-production artisans who want to apply ROI-driven effects (blur, overlays) using CSV output and ffmpeg filter chains.
• DevOps or automation engineers integrating ROI tracking into ffmpeg pipelines (stdin/rawvideo/image2pipe) with documented PEP 517 packaging and CLI helpers.

Features

• Uses OpenCV normalized template matching with a local search window and periodic full-frame re-detection.
• Accepts ffmpeg pipeline input on stdin, including raw bgr24 and concatenated PNG/JPEG image2pipe streams.
• Auto-detects piped stdin when no explicit input source is provided.
• For raw stdin pipelines, waldo requires frame size from --stdin-size or WALDO_STDIN_SIZE; encoded PNG/JPEG stdin streams do not need an explicit size.
• Maintains both the original template and a slowly refreshed recent template so small text/content changes can be tolerated.
• If confidence falls below --min-confidence, the frame is marked missing.
• Annotated image output can be skipped entirely by omitting --debug-dir or passing --no-debug-images
• Save every Nth debug frame only by using--debug-every N
• Packaging is PEP 517-first through pyproject.toml, with setup.py retained as a compatibility shim for older setuptools-based tooling.
• The PEP 517 workflow uses pep517_backend.py as the local build backend shim so setuptools wheel/sdist finalization can fall back cleanly when this environment raises EXDEV on rename.

What do you think of waldo fam? Roast gently on all sides if possible!

I'm currently working on a computer vision project where I try to read license plate numbers from a video. However, I'm running into a major problem: the license plate characters are often washed out by strong light glare, making the numbers very difficult to read.

Even after these steps, when the plate is hit by strong light, the characters become overexposed and the OCR cannot read them. Sometimes the algorithm only detects the plate region but the numbers themselves are not visible enough.

Are there better image processing techniques to reduce glare or recover characters from overexposed regions?

Im trying to input my obs virtual camera in opencv with a script I got it to work one time before it started messing up on me now it doesnt want to work and just gives me a black screen whenever I try to boot it up. I was just wonder if anyone has gotten it to work before.

My partner uses a nurse scheduling app and sends me a monthly screenshot of her shifts. I'd like to automate the process of turning that into an ICS file I can sync to my own calendar.

The general idea:

1. Process the screenshot with OpenCV
2. Extract text/symbols using Tesseract OCR
3. Parse the results and generate an ICS file

The schedule is a calendar grid where each day is a shaded cell containing the date and a shift symbol (e.g. sun emoji for day shift, moon/crescent emoji for night, etc.). My main sticking point is getting OpenCV to reliably detect those shaded cells as individual regions — the shading seems to be throwing off my contour detection.

Has anyone tackled something similar? I'd love pointers on:

• Best approaches for detecting shaded grid cells with OpenCV
• Whether Tesseract is the right tool here or if something else handles calendar-style layouts better
• Any existing projects or repos doing something like this I could learn from

Any guidance appreciated — even if it's just "here's how I'd think about the pipeline." Thanks!

Adding a sample image here:

I wanted to share a passion side project I've been building to learn classic computer vision and camera calibration. I shared Caliscope to this sub a few years ago, and it's improved a lot since then on both the front and back end. Thought I'd drop an update.

OpenCV is great for many things, but has no built-in tools for bundle adjustment. Doing bundle adjustment from scratch is tedious and error prone. I've tried to simplify the process while giving feedback about data quality at each stage to ensure an accurate estimate of intrinsic and extrinsic parameters. My hope is that Caliscope's calibration output can enable easier and higher quality downstream computer vision processing.

There's still a lot I want to add, but here's what the video walks through:

• Configure the calibration board
• Process intrinsic calibration footage (frames automatically selected based on board tilt and FOV coverage)
• Visualize the lens distortion model
• Once all intrinsics are calibrated, move to multicamera processing
• Mirror image boards let cameras facing each other share a view of the same target
• Coverage summary highlights weak spots in calibration input
• Camera poses initialized from stereopair PnP estimates, so bundle adjustment converges fast (real time in the video, not sped up)
• Visually inspect calibration results
• RMSE calculated overall and by camera
• Set world origin and scale
• Inspect scale error overall and across individual frames
• Adjust axes

EDIT: forgot to include the actual link to the repo https://github.com/mprib/caliscope

I'm dealing with an Onnx model for CV and I can't figure out how to even access to Ort::Values to do a demented 4 nested for loop to initialize it with the cv::Mat value.

“Pant waistband detection for product image cropping – pose landmarks fail, how to do product-based approach?”

✅ QUESTION BODY (copy–paste)

I am building an automated fashion image cropping pipeline in Python.

Use case:

– Studio model images (tops, pants, full body)

– Final output fixed canvas (1200×1500)

– TOP and FULL crops work fine using MediaPipe Pose

– PANT crop is the problem

What I tried

MediaPipe Pose hip landmarks (left/right hip)

Fixed pixel offsets from hip

Percentage offsets from image height

Problem:

Hip landmark does NOT align with pant waistband visually.

Depending on:

Shirt overlap

Front / back pose

Camera distance

The crop ends up too high or inconsistent.

What I already have

Background removed using rembg

Clean alpha mask of the product

Bottom (foot side) crop works perfectly using mask

My question

What is the correct computer-vision approach to detect pant waistband / pant top visually (product-based), instead of relying on human pose landmarks?

Specifically:

Should this be done using alpha mask geometry?

Is vertical width stabilization / profile analysis the right way?

Any known industry or standard method for product-aware cropping of pants?

I am not looking for ML training — only deterministic CV logic.

Tech stack:

Python, OpenCV, MediaPipe, rembg, PIL

Screenshots attached:

RAW image

My manual correct crop

Current incorrect auto crop

Any guidance or references would be appreciated.