Captured at (local ISO): 2026-05-18 05:17:08

---

Series Index

Computer Vision: Smart Car Contest Vision Track Tech Notes — Color Blob Detection with OpenArt + OpenMV
Computer Vision: Smart Car Contest Vision Track Tech Notes — YOLO3 Nano Object Detection Deployed on OpenART
Computer Vision: Smart Car Contest Vision Track Tech Notes — Efficient Classification Training with eIQ
Computer Vision: Smart Car Contest Vision Track Tech Notes — Vision Module Ideas Analysis for the 20th Contest

Introduction

Whether blob detection belongs in your smart‑car vision stack depends on the course and constraints. Generally YOLO localizes more robustly, but costs more compute and FPS; authors often cite ~15 FPS YOLO on OpenART vs ~20–30 FPS blob pipelines, so weigh accuracy vs throughput. Blob detection stays a friendly on‑ramp to vision fundamentals.

Beyond the contest, detecting constant‑color blobs is ubiquitous—line following, robotic grasp cues, reactive installations.

This tutorial builds intuition, then walks through OpenMV Threshold Editor workflows and runnable code usable on OpenART‑class hardware.

I. Color blob detection basics

1. What is color blob detection?

Color blob detection partitions the image into spatially contiguous regions whose pixels sit inside a tuned color tube, extracting centroid, bbox, footprint, rough shape, etc. In practice:

1. Threshold segmentation (brightness + chroma gates).
2. Morphology / connectivity filtering to kill speckle.
3. Emit blob features for control.

2. Why HSV/LAB color space?

Raw RGB reacts strongly to lighting; the same matte red shifts channels under glare vs shade. OpenMV tooling therefore leans on HSV-like sliders or six‑axis LAB gates.

When using HSV (OpenMV simplifies ranges):

• H (hue) — “which pigment,” often 0–179 in OpenMV;
• S (saturation) — gray → vivid;
• V (value) — dark → bright.

HSV cleanly separates hue from illumination (V) so thresholds survive modest lighting swings.

(OpenMV Threshold Editor exposes LAB (L,A,B min/max) in many builds; LAB is likewise robust.)

3. Core pipeline

1. Acquire camera frames.
2. Convert RGB → working color space.
3. Threshold → binary mask.
4. find_blobs / connected components → features.
5. StreamUART / draw overlays / steer your controller.

II. OpenMV Threshold Editor — lock in a stable color range

You need plausible (min,max) tuples per axis. OpenMV IDE ships a Threshold Editor for interactive tuning:

1. Setup

• Plug the OpenMV cam into USB, launch OpenMV IDE, connect.
• Confirm live preview renders.

2. Capture reference frames

Run a minimalist grab loop aiming the lens at your marker (say, a red ball):

import sensor, image, time

sensor.reset()                      # reset camera
sensor.set_pixformat(sensor.RGB565) # RGB565 saves RAM
sensor.set_framesize(sensor.QVGA)   # 320x240
sensor.skip_frames(time = 2000)     # warmup
clock = time.clock()

while(True):
    clock.tick()
    img = sensor.snapshot()
    print(clock.fps())

Frame the ROI so representative lighting hits the colored target.

3. Open the Threshold Editor

Menu Tools → Machine Vision → Threshold Editor.

Left pane: source; right: binary preview (in‑threshold pixels highlighted). Bottom sliders expose six LAB channels (L/A/B mins & maxes) — or grayscale min/max depending on toggle. Flip modes at the boxed UI switch highlighted in screenshots.

4. Adjust thresholds

• Click the colored target pixels; the IDE seeds ranges.
• Drag sliders until only desired material lights up white while background stays black — toggle Inverse if you need inverted logic.

5. Copy/save thresholds

Hit Copy Threshold once satisfied; clipboard holds a tuple (LMin, … BMax) (or analogous HSV six‑tuple):

(4, 84, 10, 74, -15, 64)

Lighting dominates performance — re‑tune when venue lighting or materials change materially.

III. OpenMV blob detection implementation

Combining Threshold Editor outputs with MicroPython yields something like:

Full sample

import sensor, image, time

# Sensor init
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
sensor.set_auto_gain(False)          # lock exposure/gain helpers
sensor.set_auto_whitebal(False)      # lock AWB drift
clock = time.clock()

# Example threshold copied from Threshold Editor (replace!)
red_threshold = (30, 100, 100, 160, 100, 100)

while True:
    clock.tick()
    img = sensor.snapshot()

    blobs = img.find_blobs([red_threshold], x_stride=5, y_stride=5,
                           area_threshold=100, pixels_threshold=100)

    for blob in blobs:
        img.draw_rectangle(blob.rect(), color=(255, 0, 0), thickness=2)
        img.draw_cross(blob.cx(), blob.cy(), color=(0, 255, 0), thickness=2)
        print(f"Center: ({blob.cx()}, {blob.cy()}); size {blob.w()}x{blob.h()}; area {blob.area()}")

    print(f"FPS {clock.fps():.2f}")

Walkthrough

1. Sensor tuning — disable auto gain/WB stops color drift blowing thresholds.
2. find_blobs returns blob structs; tighten area_threshold / pixels_threshold against glitter noise.
3. Visualization aids debug; centroid prints feed steering logic downstream.

Effect demo

Because the author lacked OpenART hardware at writing time, the screenshot reflects an earlier strategy: inverted blue‑track masking, carve a non‑blue ROI, then isolate non‑white road and red crates—two nested boxes illustrate that pipeline.

IV. Summary

• LAB/HSV thresholds give practical lighting immunity for contest scenes.
• Threshold Editor slashes trial‑and‑error time.
• find_blobs + overlays + telemetry gets you iterating quickly toward OpenArt integration.

Hopefully this accelerates blob workflows for your upcoming smart‑car visuals!