DEV Community: Matiwos Kebede

Replacing a Slow QR + Edge Detection Pipeline with a Fast ArUco-Based Vision System

Matiwos Kebede — Wed, 22 Jul 2026 11:15:11 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

OpenScanVision is an offline Android computer vision scanning system designed for fast and accurate scanning of structured voting cards.

The application uses the device camera to capture a card, detect its position, correct perspective distortion, decode QR information, and analyze OMR (Optical Mark Recognition) bubbles to produce accurate scan results.

The system uses computer vision techniques including ArUco marker detection, homography transformation, QR decoding, and optimized OMR bubble analysis to achieve reliable real-time scanning on mobile devices.

Bug Fix or Performance Improvement

The original OpenScanVision scanning pipeline used QR-based positioning combined with edge detection and homography transformation to detect, rotate, and wrap the card.

Although the approach worked, it had major performance and accuracy issues:

Scan processing took 7000ms+ on Samsung A11
Edge detection was slow and required heavy image processing
Card boundary detection was unreliable with different angles and positions
Incorrect perspective correction reduced QR decoding and OMR bubble detection accuracy

The main challenge was improving both speed and accuracy at the same time.

The goal was to replace the bottleneck in the detection pipeline and create a fast, reliable real-time scanner.

Code

Repository:

https://github.com/MatiwosKebede/openscanvisionnd

Main optimization commits:

0f0ba7b — Implemented ArUco finder
555d0c0 — Improved ArUco position detection
709b008 — Added capture preview with overlay and perspective transformation
961f8f5 — Implemented high accuracy ArUco and OMR bubble detection
1d5834b — Improved QR decoding and accuracy

My Improvements

I replaced the original QR + edge detection based card localization pipeline with a four-corner ArUco marker-based computer vision pipeline.

Original Pipeline

Camera Frame
↓
QR Detection
↓
Edge Detection
↓
Card Boundary Detection
↓
Homography Transformation
↓
Card Wrapping
↓
QR + OMR Processing


The original approach had two major problems:

1. Edge detection created a large performance bottleneck.
2. Card boundary estimation was not reliable enough for accurate perspective correction.

This caused slow scanning and inconsistent recognition.


## Optimized Pipeline


Camera Frame
      ↓
Four-Corner ArUco Detection
      ↓
Accurate Card Corner Localization
      ↓
Homography Transformation
      ↓
Card Wrapping
      ↓
QR Decoding
      ↓
OMR Bubble Detection

Technical Improvements

Replaced slow edge-based card localization with ArUco marker detection
Added four ArUco markers on the card corners for stable position tracking
Improved rotation and perspective correction
Improved card wrapping accuracy using reliable corner coordinates
Reduced unnecessary image processing operations
Improved QR decoding reliability after accurate alignment
Improved OMR bubble detection accuracy after consistent transformation

The main engineering challenge was balancing speed and accuracy.

During development, some optimizations increased speed but reduced accuracy. The final pipeline achieved both high performance and reliable recognition.

Results

The optimization transformed the scanner from:

7000ms+ → <140ms

on a Samsung A11 device.

The final system achieved:

Faster real-time scanning
Accurate card localization
Reliable rotation correction
Accurate perspective transformation
High QR decoding accuracy
High OMR bubble detection accuracy
Better handling of different card positions and angles

This improvement transformed OpenScanVision from a slow and unreliable scanning pipeline into a fast and robust mobile computer vision system.

Best Use of Sentry

Not submitting for this category.

Best Use of Google AI

Not submitting for this category.

How I Built a High‑Performance OMR and QR Scanner for Android (Open‑Source)

Matiwos Kebede — Sat, 18 Jul 2026 04:05:46 +0000

How I Built a High‑Performance OMR Scanner for Android (Open‑Source)

Introduction

Scanning printed voting cards, surveys, and bubble sheets on Android has always been a challenge. Most existing solutions are either expensive, require an internet connection, or are not accurate enough for real‑world use.

That's why I built OpenScanVision – an open‑source Android library that combines Optical Mark Recognition (OMR) and QR code decoding, working entirely offline.

The Problem

When I started this project, I needed a scanner that could:

Detect a card in real‑time from a camera feed.
Correct perspective distortion (cards are rarely perfectly aligned).
Accurately extract filled bubbles (even in uneven lighting).
Decode QR codes to identify the card.
Work offline – no internet connection required.
Be easy to integrate into any Android app.

Existing libraries were either closed‑source, inaccurate, or tightly coupled to specific UI frameworks. I wanted something modular, accurate, and open.

The Solution: OpenScanVision

OpenScanVision is an Android library that solves these problems with a clean, modular architecture.

Tech Stack

Component	Technology
Language	Kotlin
Image Processing	OpenCV (contrib)
QR Decoding	Google ML Kit
Camera	CameraX
UI (Sample App)	Jetpack Compose
Publishing	JitPack

How It Works – The Scanning Pipeline

1. Frame Acquisition

CameraX provides YUV frames at a configurable resolution (default 640×360). The Y (luminance) plane is extracted into an OpenCV grayscale Mat for tracking.

2. ArUco Marker Tracking

The card has 4 ArUco markers (IDs 0–3) printed in the corners. OpenCV detects these markers in real‑time. A Kalman filter smooths the tracking and predicts marker positions when they are temporarily occluded.

3. Homography & Perspective Correction

Once all 4 markers are stable, a homography matrix is computed. This maps the markers to their reference positions, allowing the card to be warped to a canonical template (850×540 pixels).

4. QR Decoding

The QR code is cropped from the original camera frame using the homography – not from the warped image. This preserves sharpness for ML Kit. The crop is enhanced (contrast, denoise, resize) before decoding.

5. OMR Extraction

The warped image is preprocessed with CLAHE (contrast enhancement) and a median blur (denoise). Each bubble is sampled using a weighted disk. A per‑group z‑score classification determines which bubbles are filled. An inner‑core fill ratio rejects false positives from paper grain or printed outlines.

6. Strict Capture Logic

Auto‑capture triggers only when:

All 4 markers are stable.
A valid QR code with a recognised prefix (e.g., VX, AGN) is decoded.

This eliminates false positives and ensures every scan is high‑quality.

Architecture

The library is split into two modules:

openscanvision/
├── openscanvision-core/          # Core library (OMR + QR engine)
│   └── src/main/java/.../core/
│       ├── OpenScanVision.kt     # Public API facade
│       ├── ScanOptions.kt        # Builder pattern config
│       ├── ScanResult.kt         # Sealed result class
│       └── internal/             # Implementation (hidden)
├── sample/                       # Reference app (demo)
└── tools/                        # Supporting utilities

The core library has zero UI dependencies – no Compose, no CameraX, no Android Views. This means you can use it in any Android project, even headless services.

Integration Example

Adding OpenScanVision to your project takes just a few lines:

1. Add JitPack to your repositories

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

2. Add the dependency

// app/build.gradle.kts
dependencies {
    implementation("com.github.MatiwosKebede:OpenScanVision:openscanvision-core:v1.0.0")
}

3. Scan a card

// Initialize once
OpenScanVision.initialize(context)

// Scan a frame
suspend fun scanCard(bitmap: Bitmap) {
    val result = OpenScanVision.scanFromFrame(bitmap)
    when (result) {
        is ScanResult.Success -> {
            println("Filled: ${result.filledIndices}")
            println("Confidence: ${result.confidence}")
            println("QR: ${result.qrPayload}")
        }
        is ScanResult.Error -> {
            println("Failed: ${result.javaClass.simpleName}")
        }
    }
}

That's it.

Performance & Accuracy

Metric	Value
Average latency per frame	< 150 ms on modern devices
Accuracy (well‑printed cards)	> 99%
False positive rate	< 0.5%
False negative rate	< 2%

What's Next?

The roadmap for 2025 includes:

Multi‑frame averaging for improved accuracy.
Scan history with Room database.
Export results as CSV.
QR‑only / OMR‑only scanning modes.

Contribute

OpenScanVision is MIT‑licensed and open to contributions. If you're interested:

Star the repo on GitHub ⭐
Try the sample app and report issues.
Open a Pull Request with improvements.

Conclusion

Building OpenScanVision taught me a lot about computer vision, Android optimisation, and open‑source maintainership. I hope it helps other developers build better scanning apps.

If you have questions, feedback, or ideas – open an issue on GitHub or leave a comment below.

GitHub: MatiwosKebede/openscanvision

🙏 Acknowledgments

OpenCV – image processing and homography.
Google ML Kit – QR code scanning.
CameraX – camera lifecycle.
Jetpack Compose – modern UI.

Built with dedication by Matiwos Kebede.

📌 What to Do Next

Copy the article above.
Go to Dev.to → Click "New Post".
Paste the content.
Add tags: android, kotlin, opencv, omr, scanning.
Publish!

This article will attract developers who are looking for an OMR, QR and OMR and QR together solution or want to learn about Android + OpenCV. 🚀