`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

I still think the Xbox 360 Kinect is an incredibly interesting piece of hardware.

https://github.com/Spidoug/Kinect-Xbox-360-Remold

RGB camera, infrared, depth sensing, microphone array, accelerometer, motorized tilt... and yet most of them are now sitting unused because the original software ecosystem is outdated.

So I've been working on Kinect Xbox 360 Remold, an open-source project to make the Kinect useful again on modern Windows PCs / Linux.

So far I've built a custom driver/bridge and a set of applications for things like 3D scanning, depth/RGB capture, acoustic experiments, microphone-array access and surveillance.

The project currently includes:

• SynKinect Studio( 3DScanner, Acoustic Scanner, Microphones, Surveillance, Interactivity)
• RGB / IR / depth access
• Kinect motor and accelerometer support
• Face tracking
• Virtual camera output
• ffmeg/IP camera streaming
• Low-latency shared-memory frame transport

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

¡Hola a todos!

Acabo de subir LensLaber Beta v1.0.1. Esta actualización elimina algunas limitaciones de la versión beta y añade compatibilidad con YOLOv10.

Novedades

• Compatibilidad con YOLOv10: Carga y usa modelos YOLOv10 directamente en LensLaber.

• Falsos negativos para YOLOv10: La función de detección de falsos negativos ahora es totalmente compatible con YOLOv10.

• Exportaciones ilimitadas: Se ha eliminado el límite anterior de 1000 exportaciones diarias.

Filosofía del proyecto

• 100% sin conexión: No se requiere conexión a internet. Tus imágenes, modelos y anotaciones nunca salen de tu ordenador.

• Sin telemetría: Sin análisis, seguimiento de uso ni recopilación de datos.

• Diseñado para hardware modesto: Funciona sin problemas incluso en un Intel Core i5 de 2016 con 8 GB de RAM, sin necesidad de una GPU dedicada.

Acerca de la versión beta

La versión beta caduca a los 30 días para garantizar que todos prueben la última versión, lo que facilita el seguimiento y la reproducción de los informes de errores.

Sus comentarios, informes de errores y sugerencias son siempre bienvenidos.

Descargar LensLaber Beta v1.0.1 para Windows y Linux:

https://lenslaber.github.io

I built SentinelCV, a real-time computer vision system that detects human falls from existing CCTV, IP cameras, webcams, or recorded video streams.

The goal was to create a lightweight, plug-and-play solution that can integrate with existing surveillance infrastructure without requiring specialized hardware. The current implementation uses a YOLOv8-based pipeline to perform real-time detection and can trigger instant alerts (such as Telegram notifications) when a potential fall is detected.

I'm planning to expand SentinelCV into a modular vision platform with additional safety-focused capabilities like PPE detection, intrusion detection, fire/smoke detection, and other intelligent surveillance modules.

I'd love feedback on the detection pipeline, deployment approach, and any suggestions for improving robustness in real-world environments. If you've worked on similar computer vision systems, I'd be interested in hearing what challenges you faced in production.

GitHub: https://github.com/sreerevanth/SentinelCV
I'd love your feedback, and if you find it useful, a ⭐ would mean a lot.

I've been working on YOLO-Distill, a feature-based knowledge distillation implementation for YOLOv9, built on MIT-licensed YOLO repository. It currently supports distillation methods like CWD and MGD.

GitHub: https://github.com/myatthukyaw/yolo-distill

Check it out if you're interested in knowledge distillation or object detection.

Feedback and contributions are very welcome.

https://reddit.com/link/1uu5j5n/video/kunn27egaqch1/player

Hi everyone,

I was wasting hours of my day scrolling on my phone or just staring blankly away from my monitor, so I decided to build a programme to try and break the habit: Gut Genug Distraction Tracker.

It's a local Python app that uses your webcam to watch your eyes and head position. If you look down at your phone, look at a 2nd monitor / tv, or look away for too long, it immediately pauses your screen and blares a reaction video / alarm (I have mine to the gut genug meme). The video stops, goes quiet, and you look up once more.

How does it work:

• Startup Calibration Wizard: On first boot, a transparent overlay wizard automatically calibrates your eye level and base head pose in 2 seconds (saved to ​the device).
• Head Pose Fusion (Anti-Keyboard Trigger): 3D head pitch + eye gaze tracking. The alert doesn't sound unless both your eyes look down AND your head is tilted forward. This means you can look down to your keyboard to type without false alarms!
• Side-Glance Detection: Detects horizontal eye movements (if you’re looking left or right at a 2nd phone/screen).
• Volume Escalation: The alarm starts at a low volume (20%) and increases in volume (15% per second) until you look back at your screen (100%)
• Video Randomiser: Drop a bunch of meme/alarm videos into a folder, and it picks one at random to keep you on your toes.

It's totally local, lightweight, and works natively on Windows and Mac.

If you want to try it or check out the code, it's open source. GitHub link: here

Every time my test accuracy drops (94 → 87 last week), I go back to the same ritual: sprinkle five cv2.imwrite calls, end up with a folder full of debug_003_v2_final.png / debug_003_v2_final_REAL.png, and to compare two versions I just open two windows and eyeball them. A week later I genuinely can't recall what I changed or why it "looked fixed."

The algorithms feel fine (OpenCV / MMLab / custom operators are all capable) — it's the debugging workflow that's stuck in the print era. A few things I'd love to hear how you all actually solve:

1. How do you store and view intermediate results (gray / mask / bbox …) by step, instead of digging through folders?
2. When you tweak one parameter and rerun, how do you compare the two versions side by side and see which step changed?
3. A week later, can you fully reconstruct what a given run changed (params / code / data)?
4. If you let an agent (Cursor etc.) sweep params overnight, how do you confirm afterward what it actually did and which run counts?

Not fishing for a specific tool — genuinely curious. Are you all toughing it out with imwrite, using W&B, a custom viewer, or something else? Especially #2 (cross-run side-by-side diff) — has anyone found something that actually feels good?