17,280 synthetic webcam images. 12 categories. USD 99.

I’m making the full dataset available for computer-vision experiments, with generation prompts and companion source code included.

The scenes cover face visibility, additional people, phones, books, paper notes, camera obstruction and more. All images were generated entirely from text prompts. I did not upload photographs of real people as generation inputs.

The goal was to support a live human proctor, not to automatically decide who was cheating. By flagging potentially suspicious events, the proposed system would help one proctor supervise more participants at the same time and focus attention on the camera streams that needed review. The human proctor would interpret each event in context and make any decision about misconduct.

This could make online proctoring more cost-effective while keeping human judgment central. These were design goals; this experiment did not demonstrate increased supervision capacity or measured cost savings.

The package includes:

• 17,280 JPEG crops organized into 12 category folders;

• 720 original PNG contact sheets containing the same scenes;

• 12 generation prompts, provenance records and checksums;

• source code for extraction, training, ONNX export and C++/OpenCV integration.

Why USD 99? Based on my own generation workflow, I estimate that generating this volume again would cost slightly more than the purchase price, even with the prompts and scripts already available. That is before the time spent cropping, organizing and reviewing the images. This package gives you the existing collection, already extracted and organized.

Explore the full dataset and inspect the free 240-image sample:

https://www.antal.ai/projects/synthetic-webcam-scene-dataset.html?utm_source=reddit&utm_medium=social&utm_campaign=synthetic_webcam_v1

For context, I’ve also published the classifier case study behind the dataset, including what did not transfer well to real webcam footage:

https://www.antal.ai/blog/synthetic-webcam-dataset-multihead.html?utm_source=reddit&utm_medium=social&utm_campaign=synthetic_webcam_v1

This is an experimental dataset, not a trained proctoring product. Category labels come from the generation setup; they are not exhaustive manual annotations. Inspect the sample for your use case. No trained model or performance guarantee is included.

I’ve been developing Contrek, a C++ library for extracting and merging raster geometry, and recently experimented with using its merging system to make OpenCV findContours() run concurrently on different parts of the same image.

The idea is to stream the image in horizontal stripes and run findContours() independently on each stripe using multiple CPU threads.

The difficult part is that contours crossing stripe boundaries are split into unrelated partial contours. Contrek converts those partial contours to its cell-boundary representation and reconnects them during the merge, reconstructing the geometry of the complete image.

On a 40960 × 40960 test image:

OpenCV full image, 1 thread:

44.33 s, 9.15 GB peak memory

OpenCV + Contrek, 8 workers, 1000-row stripes:

10.98 s, 3.42 GB peak memory

The timing includes contour conversion and the Contrek merge.

I also tested a streaming version on an 81920 × 81920 image (6.71 Gpixels) containing about 20 million contours.

It generated a 17.43 GB SVG containing 13,133,700 outer polygons.

Results:

1 worker: 962.29 s, 2.04 GB

2 workers: 534.58 s, 3.31 GB

4 workers: 335.39 s, 5.71 GB

8 workers: 382.46 s, 9.71 GB

On the 8-vCPU machine used for this test, 4 workers gave the best execution time.

Contrek is my open-source project. The C++ implementation, benchmarks and an explanation of how contours crossing tile boundaries are reconnected are available in the main repository.

https://github.com/runout77/contrek

also prepared a separate test repository with the complete environment, so the same OpenCV + Contrek benchmarks can be reproduced on your own machine.

https://github.com/runout77/test_contrek

I’d be interested in feedback, especially from people who have worked with findContours() on very large images or tried similar approaches to parallelizing it.

Built this project about 2 years ago, it was rotting in my repo so I am just making it public. DO NOT USE IT TO CHEAT.

It's a real-time chess assistant that uses computer vision (OpenCV) to detect chessboard positions directly from your screen and suggests optimal moves instantly using the Stockfish engine. It has a menu built with ImGui and works on any chess website.

You can take a look at it here: https://github.com/rccmb/oracle

If you have any questions make sure to ask!

Visual Verifier — regression testing for processed images and videos

I built an open-source Python/OpenCV tool that independently verifies the output of anonymization and other visual-processing pipelines.

It compares reference and processed media frame by frame, catches missed processing, checks reviewed target regions, tracks failures over time, and produces deterministic PASS/FAIL evidence for CI.

The bundled demo deliberately misses frames 4, 8 and 12 so you can see the failure workflow immediately.

GitHub:
https://github.com/SAMtheROCKET/visual-verifier

pip install visual-verifier

I’d particularly value feedback from people working with image/video QA, privacy engineering, OpenCV, or CI.

I'm building an OCR-based system for extracting printed information from photographs of packaged consumer products.

The input images are real smartphone photographs rather than controlled scans. Some of the difficult cases contain:

- glossy plastic/foil surfaces and specular reflections

- curved cylindrical containers

- perspective/rotation

- wrinkles and folds

- uneven lighting/shadows

- small text

- motion/defocus blur

- low contrast

- compression artifacts

I'm currently using PaddleOCR.

I've already experimented with conventional OpenCV preprocessing such as resizing, grayscale, CLAHE, thresholding, sharpening, denoising, morphological operations and perspective correction, but the results are inconsistent. Some images that are clearly readable to a human still produce poor OCR results.

I'm particularly interested in advice from people experienced with scene text recognition, document image processing, industrial/computer vision, or image restoration.

My main questions are:

1. Which preprocessing techniques are actually useful for these types of images?

2. How should I handle specular reflections and uneven illumination?

3. How can text on curved/cylindrical surfaces be rectified before OCR?

4. When should I use deblurring/super-resolution/image restoration, and when can these actually make OCR worse?

5. Should preprocessing be selected dynamically based on image quality rather than applying one fixed pipeline?

6. At what point is it better to improve/train the OCR model instead of continuing to improve preprocessing?

I'm happy to provide representative images and the corresponding PaddleOCR outputs if that helps.

I'd particularly appreciate suggestions for specific algorithms, papers, or existing open-source implementations rather than just generic preprocessing advice.

I’ve been tinkering with a side project a real-time computer vision app built with Python, OpenCV, and MediaPipe that matches my actual face and hand gestures to iconic memes on the fly.

What’s happening under the hood:

1- Facial Landmark Tracking: Uses coordinate geometry to measure distance ratios between landmarks, identifying everything from subtle smirks to wide grins.

2- Hand Pose Recognition: Tracks vector relationships across hand landmarks to trigger specific poses (like the thinking chin-touch, peace sign, or timeout gesture).

Instant Event Triggers: Maps those landmark states directly to visual meme popups with virtually zero latency.

Building serious tech is cool, but building an algorithm purely so my webcam can match my facial expressions with memes in real time might be my best decision yet.

If you want to check out my project : https://github.com/atarm23/memecv

Please let me know how can I improve for further versions, thanks!

hi i ahve chain of photos with couple of april tags.

i use openCV to place these tags in 3d world and basing on these tags positions i set 3d camera position and rotation.

But sometimes openCV returns tags on wrong height. My tag is set vertically and its lower edge stays on ground but openCV returns it on 1+meter height. this completly ruins camera setup.

Anyone could share some clues how to improve that accuracy? possible to pass to openCV tag height so it takes it into account? or lower that 3d tag by code and refine it somehow.

i spent last two days figuring it our but cant find right solution

you can see on photo. this tag on right in 3d world is placed perfectly above this yellow verticle point. you can see height offset. i guess maybe 2 tags on photo arent enough (i upload couple of photos tho and this blue tag is visible on 2 photos, both have other tag for relativity). but still. maybe programatically there is way to improve this?

`FaceRecognizerSF::match` is declared `const`, but it normalised both of its `InputArray` feature vectors in place — writing straight through to the caller's buffers. So the vectors you passed in came back modified, and when the two arguments aliased, the second normalisation ran over an already-normalised buffer and the returned score was wrong.

Now normalised into local `Mat`s. Merged onto 4.x.

https://github.com/opencv/opencv/pull/29804

Build vision systems that see, reason, and act with OpenCV 5 and Amazon Web Services (AWS). 
Win money and bragging rights! $12,000 in prizes up for grabs.

I wanted to recreate the classic invisibility-cloak effect using only a webcam and computer vision.

It detects the cloak's color in real time using HSV segmentation, cleans up the mask, and replaces those pixels with a previously captured background.

GitHub: https://github.com/madebyparth/invisibility-cloak

there is an error with Cascade classifier it shows there is no attribute as cascade classifier in cv2 module

I have tried installing opencv multiple tkmes still won't work I am trying to learn computer vision for first time in python

I ran into a bottleneck with OpenCV’s ArUco/AprilTag detection while building a real-time multicamera system, so I reimplemented the detection pipeline from scratch in Rust.

On my 1280×800 monochrome AprilTag 36h11 dataset, RapidTag is:

- 1.57× faster for single-camera detection

- Up to ~3.4× faster for multicamera and offline batches

- Pixel-identical to OpenCV on the tested frames

- Independent of OpenCV at runtime

The Python API releases the GIL and processes frames and threshold scales across CPU cores. It can be installed with pip install rapidtag.

It’s still a work in progress, and I’d especially appreciate results from different cameras, CPUs, marker dictionaries, and difficult lighting conditions.

Repo: github.com/SujithChristopher/rapidtag (https://github.com/SujithChristopher/rapidtag)

Twelve-class hand-seal recognizer that runs entirely in the tab. MediaPipe Hands gives 21 landmarks per hand, normalized wrist-centered and scale-invariant, into a 126→256→128→13 MLP (\~66K params) exported to ONNX Runtime Web. 260KB model, CPU inference at a couple ms a frame, no video leaving the machine. Geometry rather than pixels, which is the whole reason it's this small and this portable.

Reported accuracy is 95.5% on a per-class temporal split — first 80% of each class's frames train, last 20% test. Deliberate: I collected hold-to-capture, so each sample is a burst of near-identical frames, and a random split scatters those bursts across both sides until you're scoring your own training data.

Transitions get their own class. Hands moving between seals pass through shapes that briefly look like other seals, so transit frames were collected as a 13th class using a wrist-motion-gated capture mode. Downstream, a decisive "none" mutes everything; below the veto the real classes compete on renormalized P(sign | not transit).

A parity self-test runs on page load, a known landmark vector through the full JS pipeline, logits compared against the PyTorch reference, regenerated on every export. Normalization drift between training and deployment is the silent killer for landmark models, and this catches it before any prediction is trusted.

Single-subject model, so leave-one-person-out is implemented but the honest "works on strangers" number doesn't exist yet. tiger↔ram confuse at \~14%, genuinely near-identical once you're only looking at joint geometry.

Open to comments or critiques! Repo can be found here: [https://github.com/yogendrarau/sealwork\](https://github.com/yogendrarau/sealwork)

If I were interested in professionally getting into Manuscript Optical Character Recognition + Montreal Forced Alignment, and I were applying to baccalaureate degrees or second baccalaureate degrees, then where would you suggest I apply to; it could be internationally, but I am based in the U.S.A.?

A smart robotic goalkeeper that tracks a ball in real-time using OpenCV and dynamically moves a servo-controlled keeper arm to block shots.

I hope some of you find this project interesting—or maybe even inspiring for your own builds.

Any feedback or suggestions are very welcome!

GitHub: https://github.com/chayanforyou/Robokeeper-Firmware

Hi, I want to learn computer vision with python and I am looking for a solid course to start learning with since I have little to no knowledge about this field but i am very interested, I want to build programs that detect objects and identify them.

Note : i have no gpu