Seeing Smarter: How ArUco Markers Inspired Our Fast Logo Detection

Vision that starts with a square

At Hoomanely, we're building systems that see and understand pets, from their eyes and movement to the bowls they eat from. That means our camera pipeline needs to detect key visual cues with precision and speed, even on a small edge chip like the Broadcom-based ARM7 MPU. One piece of technology that shaped our detection stack is deceptively simple: the ArUco marker.

These black-and-white squares show up everywhere in robotics and AR, acting as visual anchors machines use to place themselves in space. What makes them so fast and reliable, and how did the same principles help us build a Hoomanely logo detection system that runs in real time on embedded devices? Here's the breakdown.

What ArUco markers are

Think of a QR code, but leaner and simpler. ArUco markers are binary square patterns designed to be easy for computer vision systems to detect. Each marker encodes a small binary ID inside a thick black border, and unlike QR codes, they aren't meant to store data, they serve as unique identifiers for positioning and tracking. They show up in AR applications for overlaying virtual objects on physical surfaces, in robotics for localization and mapping, and in drones for autonomous landing and alignment. Point a camera at one, and the system instantly knows which marker it is and where it sits in 3D space.

How ArUco markers work

At its core, ArUco detection is a pattern-recognition pipeline built for speed and robustness. The input image is converted to grayscale to cut computational load, then adaptive thresholding turns it into a binary black-and-white map that holds up under changing light. Contours, the closed curves around white regions, get extracted and filtered down to quadrilateral shapes as candidate markers. Each detected square is perspective-corrected using homography and warped to a fixed-size grid, then the interior grid is sampled to decode the binary pattern, which maps to a specific marker ID from a predefined dictionary. Optionally, using the 2D corner coordinates and the marker's known physical size, OpenCV's solvePnP() estimates its 3D position and orientation relative to the camera.

It's fast for a few reasons: the binary design keeps the data to process minimal, thresholding and contour-based detection skip deep learning entirely, and corner-based pose estimation is pure geometry, just matrix math with no neural net involved. In practice, ArUco detection runs at 30 to 60 FPS even on small CPUs, which suits drones, AR glasses, or our CM4-based smart bowl equally well.

The math behind it

ArUco leans on two main building blocks. Perspective-n-Point (PnP): once corner correspondences are known, the camera's rotation R and translation t are estimated from

s [u, v, 1]ᵀ = K [R | t] [X, Y, Z, 1]ᵀ

where K is the camera's intrinsic matrix. This step is what gives us 3D tracking, letting us know exactly how far and at what angle a marker sits relative to the camera.

Homography estimation maps each 2D corner (x, y) to a real-world coordinate (X, Y) using

[x, y, 1]ᵀ ≈ H [X, Y, 1]ᵀ

where H is the homography matrix from perspective correction. The whole operation is algebraic, matrix multiplication and bit comparisons, with no neural network inference latency involved.

From ArUco to Hoomanely: logo detection at the edge

We needed to detect our logo on bowls and packaging so we could align RGB, thermal, and proximity readings in real time. The catch: our logo isn't a binary square, lighting varies between indoor, outdoor, and shadowed bowls, and the camera runs on a low-power ARM7 MPU.

We borrowed ArUco's binary encoding and threshold-based speed to build a custom logo detector. We convert RGB to grayscale, then apply adaptive thresholding to isolate the logo outline. Instead of perfect squares, we use template matching plus contour filters to catch the curved logo shape. We compute a binary hash of key logo regions (the high-contrast zones), similar to how ArUco encodes bits, to quickly reject false positives. Once detected, the logo's corners feed into homography estimation, aligning overlays like temperature readings or motion vectors. This hybrid classical pipeline runs in 40 to 50ms on the ARM7 MPU, close to ArUco speeds but with more flexible logo shapes.

Why we didn't just use deep learning

A CNN or YOLO would seem like the obvious answer, but they come with real trade-offs on this hardware: a CNN can take 300 to 700ms per frame on the ARM7 MPU, power draw rises with heavy inference cycles, and training needs hundreds of labeled logo samples across different lighting conditions. Classical CV inspired by ArUco gives us a lightweight, deterministic alternative that's a better fit for reliably detecting the bowl logo, keeping thermal and RGB frames in sync, and conserving battery life. Deep learning still earns its place for harder problems like eyes or faces, but classical vision wins for known, fixed patterns: simpler, faster, and easier to explain.

Field results

Across multiple bowl units in real-world testing, we saw about 92% detection accuracy under varying light conditions, and latency of roughly 40 to 50ms per frame compared with about 500ms for YOLOv8. That kept RGB and thermal overlays consistent even when the bowl shifted slightly, which matters for accurate eye-temperature readings.

Key takeaways

• Simplicity scales. ArUco's power comes from binary encoding plus geometric math, which adds up to speed.
• Edge efficiency matters. A lightweight algorithm can outperform a deep model in real-time, power-constrained systems.
• Old tricks adapt well. Combining classical techniques like thresholding and homography with a tailored design got us robust logo detection for Hoomanely.

Sometimes the useful move isn't the newest algorithm but a smart reuse of an old idea. ArUco markers are a good reminder that simple geometry can still carry a lot of weight in modern perception systems.