Color Detector Tutorial: Build Your Own Color Recognition SystemBuilding a color recognition system is a practical project that combines hardware, software, and basic color science. This tutorial walks you through the full process: how color sensing works, choosing hardware, writing detection code, improving accuracy, and practical applications. It’s written for hobbyists and developers with basic programming knowledge. Example code uses Python and a Raspberry Pi, but the concepts apply to Arduino, smartphones, or desktop systems.
What is color detection?
Color detection is the process of sensing or analyzing the color of an object or light and mapping that input to a human-readable label (for example, “red,” “#FF5733,” or “Pantone 186 C”). Systems do this using:
- Sensors that measure light intensity at different wavelengths (RGB, RGB+clear, or multispectral sensors).
- Cameras that capture images and allow software to analyze pixel color values.
- Algorithms that convert sensor/camera readings into color spaces (RGB, HSV, CIELAB) and then classify or match colors.
Key fact: color is a perceptual response to light of different wavelengths; sensors measure spectral power, which we map to color spaces and names.
Project overview and goals
This tutorial will produce a working color detector that:
- Reads color data from a sensor or camera.
- Converts readings into a uniform color space (HSV and CIELAB recommended).
- Matches the reading to predefined color names and hex codes.
- Displays results on a console, simple GUI, or web page.
- Optionally logs readings and supports calibration.
Hardware path options:
- Option A (sensor): Raspberry Pi + TCS34725 or TCS3200 color sensor.
- Option B (camera): Raspberry Pi Camera Module or any USB webcam.
- Option C (mobile): Smartphone camera + app framework (not covered in-depth).
Software stack used in examples:
- Python 3.8+
- Libraries: OpenCV, numpy, scikit-learn (optional), smbus2 (for sensor), flask (optional UI), PIL/Pillow.
Components and cost estimate
- Raspberry Pi 4 (or any model with camera/USB): \(35–\)75
- TCS34725 color sensor breakout (recommended): \(5–\)15
- Pi Camera or USB webcam: \(10–\)40
- Jumper wires, breadboard, enclosure: \(5–\)20
- Optional: small touchscreen or OLED display: \(10–\)50
Hardware setup
Option A — TCS34725 sensor with Raspberry Pi (I2C):
- Power off Pi. Connect sensor VCC to 3.3V, GND to ground. Connect SDA to SDA (GPIO2), SCL to SCL (GPIO3).
- Enable I2C via raspi-config and reboot.
- Install i2c tools to confirm connection: sudo apt install i2c-tools; run sudo i2cdetect -y 1 and verify sensor address (0x29 typical).
Option B — Camera:
- Attach Pi Camera or connect USB webcam.
- Enable camera in raspi-config or ensure drivers are present.
- Test with raspistill or fswebcam.
Software: reading raw color values
Option A — TCS34725 Python example (uses Adafruit library):
# tcs_example.py import time import board import busio import adafruit_tcs34725 i2c = busio.I2C(board.SCL, board.SDA) sensor = adafruit_tcs34725.TCS34725(i2c) sensor.integration_time = 50 sensor.gain = 4 while True: r, g, b, c = sensor.color_raw lux = sensor.lux color_temperature = sensor.color_temperature print(f"Raw R:{r} G:{g} B:{b} C:{c} Lux:{lux} Temp:{color_temperature}") time.sleep(0.5) Option B — Camera with OpenCV (sample reads average color from center region):
# camera_color.py import cv2 import numpy as np cap = cv2.VideoCapture(0) ret, frame = cap.read() if not ret: raise SystemExit("Camera not found") h, w = frame.shape[:2] cx, cy = w//2, h//2 size = 100 # region size while True: ret, frame = cap.read() if not ret: break roi = frame[cy-size//2:cy+size//2, cx-size//2:cx+size//2] avg_color_bgr = cv2.mean(roi)[:3] avg_color_rgb = avg_color_bgr[::-1] # convert BGR to RGB print("Avg RGB:", tuple(int(c) for c in avg_color_rgb)) cv2.rectangle(frame, (cx-size//2, cy-size//2), (cx+size//2, cy+size//2), (0,255,0), 2) cv2.imshow("Camera", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() Converting and normalizing color values
Raw sensor and camera RGB values vary with lighting. Convert to a color space less sensitive to illumination:
- RGB to HSV: Hue separates chromatic information from intensity (useful for naming colors).
- RGB to CIELAB (via XYZ): Perceptually uniform — better for distance-based matching.
Example: converting with OpenCV:
import cv2 import numpy as np rgb = np.uint8([[[R, G, B]]]) hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV)[0][0] lab = cv2.cvtColor(rgb, cv2.COLOR_RGB2LAB)[0][0] Calibration tips:
- Use a white reference (white card) to compute gain or white balance offsets.
- Normalize by dividing by the clear channel (sensor) or by overall brightness: r’ = R/(R+G+B).
Mapping readings to color names
Two approaches:
- Nearest-neighbor in a chosen color space (CIELAB recommended). Create a palette of named colors with their LAB values and find the minimal Euclidean distance.
- Classification with a machine learning model (k-NN, SVM). Collect labeled samples under different illuminations for robust models.
Example: nearest neighbor using scikit-learn
# color_match.py import numpy as np from sklearn.neighbors import NearestNeighbors import cv2 # Example palette: list of (name, RGB) palette = [ ("red", (255,0,0)), ("green", (0,255,0)), ("blue", (0,0,255)), ("yellow", (255,255,0)), ("white", (255,255,255)), ("black", (0,0,0)), ] def rgb_to_lab(rgb): arr = np.uint8([[list(rgb)]]) lab = cv2.cvtColor(arr, cv2.COLOR_RGB2LAB)[0][0] return lab names = [p[0] for p in palette] labs = np.array([rgb_to_lab(p[1]) for p in palette]) nn = NearestNeighbors(n_neighbors=1).fit(labs) def match_color(rgb): lab = rgb_to_lab(rgb).reshape(1, -1) dist, idx = nn.kneighbors(lab) return names[idx[0][0]], float(dist[0][0]) print(match_color((250,10,10))) Handling lighting and reflections
- Use a diffuse, controlled light source (LED ring or enclosure) to reduce variability.
- Take multiple samples and average.
- Implement white-balance and gamma correction.
- For reflective or metallic surfaces, use polarizing filters or ensure diffuse illumination.
User interface options
- Console: print RGB/HSV/LAB and name.
- GUI: Tkinter or PySimpleGUI to show swatch and info.
- Web UI: Flask app showing live camera feed and detected color swatch with hex code.
- Small display: render swatch and name on an OLED or small TFT attached to the Pi.
Example minimal Flask endpoint to return JSON result:
# app.py (excerpt) from flask import Flask, jsonify app = Flask(__name__) @app.route("/color") def color(): rgb = (123, 200, 50) # replace with actual reading name, dist = match_color(rgb) hexcode = "#{:02X}{:02X}{:02X}".format(*rgb) return jsonify({"name": name, "hex": hexcode, "rgb": rgb, "distance": dist}) Improving accuracy with machine learning
- Collect a dataset of labeled colors photographed under multiple lighting conditions.
- Augment with synthetic variations (brightness, white balance shifts).
- Train a classifier on HSV or LAB features; include contextual data (surrounding pixels, texture) if helpful.
- Use cross-validation and confusion matrices to find ambiguous pairs (e.g., maroon vs dark red) and refine palette or model.
Example project: full minimal pipeline
- Hardware: Pi + TCS34725 + LED ring.
- Read raw RGBC from sensor and normalize by clear channel.
- Convert normalized RGB to LAB.
- Match to palette via nearest-neighbor.
- Display name + hex on small screen; log to CSV.
Pseudocode summary:
initialize sensor and LED calibrate white reference loop: turn on LED read raw R,G,B,C normalize: Rn = R/C, Gn = G/C, Bn = B/C convert to LAB match nearest palette color show result and log Troubleshooting common issues
- Inconsistent readings: check lighting, sensor placement, averaging, and calibration.
- Poor matching: use LAB instead of RGB, expand palette with intermediate shades, or train a classifier.
- Camera white balance interfering: disable auto white balance in camera settings when possible.
Extensions and applications
- Assistive tool for colorblind users: announce or display color names for objects.
- Inventory or sorting systems: sort items by color on conveyor belts.
- Art and design tools: capture color palettes from real-world scenes.
- Educational kits: teach color science and programming.
Resources and libraries
- OpenCV (image processing)
- scikit-learn (simple ML)
- Adafruit CircuitPython TCS34725 library (sensor)
- Pillow (image handling)
- Flask (web UI)
Final notes
This tutorial outlines a complete, practical path from hardware to software and deployment for a color detector. Start simple (read raw values and display RGB), then add color-space conversion, calibration, and matching. If you tell me which hardware you’ll use (TCS34725, TCS3200, webcam, or smartphone), I’ll provide a tailored step-by-step script and wiring diagram.
Leave a Reply