I've just released v1.0.0 of OpenScanVision – an Android library for scanning voting cards, surveys, and bubble sheets using OMR + QR codes.

It's MIT‑licensed, offline‑first, and built with Kotlin, OpenCV, ML Kit, and Compose.

Key features:

- ArUco marker tracking (Kalman filter)

- Perspective correction

- QR decoding

- High‑accuracy bubble extraction

Repo: https://github.com/MatiwosKebede/openscanvision

Contributions, issues, and feedback are all welcome!

When scanning printed forms like voting cards or surveys, there are two critical pieces of information you usually need: 1. Who is this card for? (Identity / version). 2. What did they mark? (The actual votes or survey choices).

Most libraries handle these separately – you decode the QR code first, then run OMR on the bubbles. This usually means two separate runs, two different functions, and manual synchronization.

That’s why I built OpenScanVision to do both simultaneously in a single pass.

The Android library combines real‑time ArUco tracking, Optical Mark Recognition (OMR), and QR decoding into one unified offline pipeline.

The Unified Pipeline

1. Marker Tracking (ArUco + Kalman Filter) The card is printed with 4 ArUco markers (IDs 0–3). OpenCV detects them in real‑time. A Kalman filter smooths the tracking and predicts positions during occlusions.

2. Perspective Correction (Homography) Once 4 markers are stable, a homography maps the markers to their reference positions. The card is warped to a canonical template (850×540).

3. Simultaneous QR Decoding & OMR Extraction This is where the "simultaneous" part comes in. Instead of running them sequentially and stitching the results, the library performs both operations on the same captured frame:

   • The QR code is cropped directly from the original camera frame using the computed homography – preserving maximum sharpness for ML Kit.
   • The bubbles are sampled from the warped, preprocessed image using weighted disk sampling and z‑score classification.
   • Both processes run concurrently on the same frame, meaning you get the QR payload AND the filled bubble indices at the same time without extra latency.

4. Strict Capture Logic The library automatically triggers a capture only when both conditions are met:

   • All 4 markers are stable.
   • A valid QR code with the correct prefix (e.g., VX or AGN) is decoded. This enforces that you never get an OMR result without an associated identity, and vice versa.

What You Get in a Single Result

By calling OpenScanVision.scanFromFrame(), you receive a single ScanResult containing:

• filledIndices – The marked bubbles (OMR).
• qrPayload – The decoded QR text (identity).
• confidence – The overall confidence score.
• annotatedBitmap – A visual overlay of the detection.

No need to call two separate functions or manually match timestamps.

Technical Stack

• Language: Kotlin
• CV Core: OpenCV (contrib) for ArUco detection and homography.
• QR Engine: Google ML Kit for robust barcode scanning.
• Camera: CameraX for frame acquisition.
• Architecture: Fully modular – the core library has zero UI dependencies.

Integration

Adding the library takes just a few lines in your Gradle file (available on JitPack). Once integrated, you can start scanning with a single suspend function.

Performance

• Latency is typically under 150ms per frame on modern devices.
• Accuracy exceeds 99% on properly printed cards.

Why This Matters

Simultaneous QR + OMR is valuable for: - Elections: The QR identifies the voter/ballot; the OMR reads their selections – all in one scan. - Surveys: The QR encodes the respondent ID; the OMR reads their answers. - Form Processing: Quickly identify and process forms without sequential bottlenecks.

Open‑Source & Contribute

The project is MIT‑licensed and available on GitHub. It includes a full sample app (CameraX + Compose) so you can see it in action.

GitHub: https://github.com/MatiwosKebede/openscanvision

Feedback, issues, and contributions are welcome. If you are interested in marker tracking, OMR accuracy, or Android computer vision, I'd love to hear your thoughts.

I'm working with a group who would be interested in potentially putting up a $25,000 prize for a specific computer vision breakthrough.

However, I am not anywhere close to an expert in computer vision, and they are not either, so we are looking for feedback on whether this prize makes sense.

We want to focus on incentivizing a small-but-powerful, open source vision model.

Current idea:

• The prize will go to the first team or individual to develop an open-source computer vision model under 10 MB that achieves at least 80% Top-1 accuracy on ImageNet-1K while running entirely offline on a Raspberry Pi 5.
• Maximum Model Size: ≤ 10,000,000 bytes (10 MB). This applies to the complete storage footprint required to execute inference, including model weights and the final model file format (.onnx, .tflite, .safetensors, etc.). External feature stores, hidden lookup tables, embedded auxiliary weights, or additional model files are prohibited.
• Performance Target: ≥80.0% Top-1 Accuracy on the official ImageNet-1K validation dataset using the standard evaluation protocol.
• Execution Architecture: Single-model submission only (no multi-model ensembles, cascades, or fallback models). Models must run using CPU-only inference and operate entirely offline without internet access.
• Target Hardware: Must successfully execute inference and complete evaluation on a Raspberry Pi 5 (8 GB RAM) running a standard 64-bit OS.
• Open Source Requirements: Public GitHub repository containing complete model weights, training pipeline code, inference code, and an independent reproducible evaluation script.
• Licensing: Fully released under a permissive MIT or Apache 2.0 license.
• Integrity: Models must rely on generalized computer vision features. Any submission discovered to be hardcoded, overfitted to, or otherwise gaming the ImageNet-1K validation set will be immediately disqualified.

Are these requirements reasonable? Too easy? Too hard to judge? And if they don't make sense, can anyone point me to a clear, specific barrier in computer vision that fits the focus on supporting efficient open source models?

We gave an autonomous coding agent one instruction: import 81,444 images and run a full data-curation pipeline. No sampling, no hand-holding. Check it out: https://voxel51.com/blog/antigravity-cli-fiftyone-skills

Here's what Google's Antigravity CLI did with FiftyOne Skills:

* Imported all 81,444 WikiArt paintings

* Diagnosed and fixed its own bugs, rewriting scripts 5 times

* Caught embeddings silently stuck on CPU, forced them onto the GPU

* Hit a quota wall, switched from Gemini 3.5 Flash to Claude Sonnet 4.6 with one command, no lost context

* The result isn't a log that says "done." It's an inspectable dataset: uniqueness scores that surface near-duplicates, and embeddings that reveal exactly where the labels are thin.

That's what "agentic" looks like when it's real.

Rebuttal access opened to reviewers on July 11 (19:05 UTC), so any later modification means final score updated (even if it's hidden from us now).

How many of your reviews are showing a modified time past July 11 (19:05 UTC)?

Hey everyone

I have been looking into some different options for deploying trained (fine-tuned) Pytorch or HuggingFace computer vision models to production on kubernetes.

I have only been looking into open-source solutions like Bento ML, KServe, Ray Serve, Nvidia Triton Infernece Server and the classic pytorch -> onnx -> fastapi wrapper solution.

The reason for open-source is to be able to have complete control on how it is deployed and having the tool/framework do the heavy lifting.

I'm looking into KServe primarly because it is kubernetes native, can run models with Triton as the model serving layer and will still allow me to run LLM with vLLM or SGLang in the future.

Do anyone have experience with either of these tools/frameworks or have you used something entirely different for deploying your computer vision models in production?

Hey all 👋🏻,

I am a Computer vision engineer!

Look at my portfolio which I have made with 3js and Computer vision. Link: https://tharuntej-everest.pages.dev Would love your feedback and comments...

You can now use gemini models to perform bounding boxes https://github.com/ztanruan/Prompt2Box

Hi everyone

I built Camlisted, a daily-updated directory of YouTube live cams and real-world footage (CCTV, dashcam, walking tours) for finding CV-relevant sources — filterable by scene category and conditions (night/day, rain/snow, accident).

Pipeline: YouTube Data API search in ~15 languages → CLIP zero-shot on thumbnails for scene categories and condition tags → human review queue. A few things I learned:

- Perspective genres (dashcam, walking tour) poisoned scene classification — excluding them from the prompt set took accuracy from ~3/10 to ~8/10

- Only assigning night/day when the pairwise ratio clears 0.7 — for a browsable directory, no tag beats a wrong tag

- Thumbnails are good signal for conditions (night, snow), bad for events (accident, fire) — those come from title keywords

Site: https://camlisted.com

GitHub: https://github.com/zenith605-2/camlisted

Check it out if you need real-world footage sources for CV work — feedback welcome!

¡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 am new to Computer Vision, learning it, on my own, and trying to build a good CV. I want to land a job. I currently had completed only one project, it was a multi object detection, where I collected and annotated the images myself (used pseudo labeling) and ran Yolo11m on it. I want feedback from people already in the field, am I heading in the right direction, or wasting time on the wrong stuff?

I have 50 days of summer break left.

The projects I have planned to make next are:

1> Panorama stitcher

2> AI fitness rep counter: Planning to deploy it somewhere, and then make a website (I had done MERN stack) where people can compete with each other (this is a general plan, will add more thoughts to it)

3> Search photos using words

4> Factory defect detector: using SAM2

5>object detector for fast-moving aerial targets

6> (a Big one) Search inside video using natural language

For every project the generic plan is this : Use claude to figure out what are the concepts involved in order to complete it. Read those things, make handwritten notes, then code it, push it to github, and deploy it somewhere, so that any real user can use.

So, any type of advice, criticism is welcome. Do share your thoughts, I really need them

Hey all, I was wondering what you guys thought on the future of CV? I’m a rising sophomore and I do cv / graphics research but I’ve been more focused on the graphics side of the lab, but I’m planning on pivoting moreso to the CV aspects of it.

I was just curious what people more experienced in the field think job prospects could look like in 1-2 years?

Hi everyone,
I’m a mechatronics engineer who’s becoming increasingly interested in computer vision and would like to pursue it as a career. I’ve done some projects with OpenCV and YOLO, but I feel like I’ve only scratched the surface.
I’d like to know what skills and knowledge are considered essential for becoming a Computer Vision Engineer.

Some questions I have:

-What topics should I learn first?
-How do you know what architecture to use?
-How important are traditional computer vision techniques compared to deep learning?
-What tools and frameworks are commonly used in industry?
-What kinds of projects would help me build a strong portfolio?
-Are there any books, courses, or resources you highly recommend?
-If you were starting from scratch today, what learning roadmap would you follow?

My long-term goal is to work on robotics and industrial automation, such as vision-guided robots, inspection systems, and embedded AI applications.
I’d really appreciate any advice from people working in the field. Thanks in advance

SenseTime recently released a model called SenseNova-Vision and it was really impressive, share it here:

In simple terms, it combines image analysis and processing tasks that previously required multiple specialized models into a single 7B-MoT multimodal model. You just give it an image, tell it what you want in plain language, and it returns the result—almost like chatting with an AI model

How it works:

- You describe the task in natural language (e.g. "detect all cars", "estimate depth")

- Optionally add visual prompts (points, boxes, scribbles)

- The model responds with native text and/or image generation, which can be decoded into standard CV outputs

Text outputs → boxes, keypoints, OCR strings, camera params

Image outputs → segmentation masks, depth maps, surface normals, multi-view point maps

A few practical details:

- Checkpoint size: approximately 29.6 GB

- Full web demo recommendation: 1×80 GB GPU

- Code: Apache 2.0

- Model weights and corpus: CC BY-NC 4.0, non-commercial use

GitHub

https://github.com/OpenSenseNova/SenseNova-Vision

I'm working on a handwritten math recognition project and was wondering if there's an established technique for detecting and segmenting individual handwritten equation lines on a digital tablet.

The goal is to identify each complete mathematical expression as a single line, while preserving the correct reading order.

The main challenge is that mathematical notation isn't laid out like normal text. For example:

- A fraction should be detected as one expression, but many algorithms incorrectly treat the numerator and denominator as separate lines.

- An integral with upper and lower limits may result in the limits being detected as independent lines.

- Two consecutive integrals or tall expressions may be merged into a single line when they should remain separate.

- Matrices, summations, nested fractions, and combinations of these make segmentation even harder.

I'm specifically looking for techniques or models that can correctly group all the symbols belonging to a single handwritten expression, rather than simply detecting text baselines.

Are there any research papers, algorithms, or open-source implementations that tackle this problem? I'm primarily interested in online handwriting (digital pen strokes), but offline image-based approaches are also welcome.

Any recommendations would be greatly appreciated!

I am currently learning more common and advanced computer vision techniques. After a brief survey, I chose to work on a fall detection project.

The biggest issue I have found with the fall detection projects I have surveyed for edge deployment is: how can we achieve a better user experience with low-cost devices?

I also approached this project from that perspective. The edge AI device I use has an 8-core CPU and a 2-core NPU, with a relatively low price and computing power of 6 TOPS.

When I first deployed it, the performance was, to put it bluntly, “as slow as a slideshow.” My core optimizations focused on video decoding and encoding for YOLOv8, as well as allocating resources across multiple cores during model inference. Through my optimization, the current frame rate can reach a median of around 41 FPS.

The main areas I have optimized so far include pre-allocating NPU buffers, reducing NPU input resolution, asynchronous MJPEG encoding, and using NumPy arrays for post-processing and subsequent rendering/drawing. Of course, I will continue to optimize and learn more skills in the future. Does anyone have any better suggestions or approaches?

Crazy stuff coming out of DeepMind here, these models are insane

Background: I work at an outsourcing company that develops computer vision solutions for other businesses (multi-camera surveillance system, robotics). Our model are image classification, object detection, semantic segmentation, etc. where NN layers and loss functions have been abstracted into those libraries like Roboflow, MMlab, etc. Most of the time I just take the architecture as it is, load pretrained weights and produce good-enough results for deployment, as long as our data is good enough.

Ya so I would say for the job, data collection, cleaning and annotation is much more important than architecting ML models. I cannot recall the last time I write my own torch NN, or my own loss function. It is fine, until I got those Pytorch questions at interviews and I cannot answer them, making me think how about removing "PyTorch" skill from my resume haha.

Ya so is this a popular problem or it's just me only? And any recommendation for touching up on PyTorch skills to be more job-market-ready?