Welcome back, everyone! This is Paul McWhorter from TopTechBoy.com, and welcome to Lesson 55 in our AI on the Edge tutorial series!

If you’ve been following along, grab yourself a nice, hot cup of black coffee, fire up your Raspberry Pi 5, and let’s get right into it!

What We Are Doing in Lesson 55

Up to this point in the series, we have spent a lot of time working with land-marking models—tracking human hands, pose points, and facial features. But today, we step into full-blown computer vision object detection!

In this lesson, we learn how to implement MediaPipe’s lightweight, standalone object detection task API (mediapipe.tasks.python.vision.ObjectDetector) running on the Raspberry Pi 5. Using the pre-trained COCO dataset model (efficientdet_lite0.tflite), our Pi 5 can instantly identify up to 80 different real-world objects—from people, cups, and bottles to chairs, laptops, and cell phones—and draw real-time bounding boxes around them on our video feed.

Key Takeaways & Concepts Covered

Setting Up the MediaPipe Object Detector Task API:

Unlike older mp.solutions wrappers, the modern MediaPipe Tasks API requires configuring BaseOptions with the explicit local path to your .tflite model asset (modelPath = "/home/pi/ai-lab-kit/mediapipe/efficientdet_lite0.tflite").
Configuring Detector Parameters:
- score_threshold (0.35): Sets the minimum confidence score required to accept a detected object. Lowering this value captures weaker detections but risks false positives; raising it ensures high-confidence target lock.
- max_results (3): Limits the maximum number of bounding boxes predicted per frame to keep our processing loop lean and fast.
Decoding Detection Bounding Boxes:

MediaPipe returns detected objects with bounding box geometry relative to the frame origin (origin_x, origin_y, width, height). We parse these dimensions directly into OpenCV integers (x, y, w, h) to draw bounding boxes with cv2.rectangle().
Category Labeling & Confidence Rendering:

We pull category names (category_name) and classification scores (category.score) from detection.categories[0], format the confidence as a percentage, and render clean text labels anchored directly above each target box.
Optimal Frame Alignment & FPS Monitoring:

We capture 60 FPS video directly from picamera2 in RGB888 format, flip it properly to match our physical camera mounting, and track real-time frames-per-second using our low-pass smoothing formula.

What You Will Need

To follow along with this lesson, ensure you have your standard gear ready from the kit:

Raspberry Pi 5 (with Active Cooler/Heat Sink)
Raspberry Pi Camera Module 3 (or compatible Camera Module driven via picamera2)
SunFounder Fusion AI Lab Kit (with pre-downloaded MediaPipe .tflite model weights)

Homework Assignment

Alright, class, you know I never let you off the hook without some homework!

Your assignment for this lesson is to take this foundational object detection script and upgrade its intelligence:

Target Filter: Modify the loop so that it only draws bounding boxes around a specific target object of your choice (for instance, only detect "person" or only detect "bottle"), ignoring all other detected COCO classes.
Target Tracking Dot: Calculate the exact center pixel coordinate $(x + \frac{w}{2}, y + \frac{h}{2})$ of your targeted object, and draw a solid red target circle (cv2.circle) right on the object’s center point.
Dynamic On-Screen Target Status: If your target object is visible in the frame, display a green text banner in the upper corner reading "TARGET ACQUIRED". If it leaves the frame, change the status banner to a red "SEARCHING...".

Give it a shot, take your time, and write your solution from scratch without copying and pasting! Drop a comment on the YouTube video to let me know if you got it working or if you ran into any snags.

Until next time, get your coffee, keep coding, and I’ll see you guys in Lesson 56!

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
 
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision

piCam = Picamera2(1)
W=1280
H=720
tStart = time.time()
fps = 0
RES = (W,H)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate=60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W/425)
fontScale = H*.0015
fontColor = (0,0,255)
topBar = 65
windowPadding = 0
cv2.namedWindow('Camera', cv2.WINDOW_GUI_NORMAL)
cv2.resizeWindow('Camera', W, H)
tSettle = .1
time.sleep(tSettle)
cv2.moveWindow('Camera', windowPadding, topBar)

modelPath = "/home/pi/ai-lab-kit/mediapipe/efficientdet_lite0.tflite"
scoreThreshold = .35
maxObj = 3

baseOptions = python.BaseOptions(model_asset_path = modelPath)
options = vision.ObjectDetectorOptions(base_options = baseOptions,
                                       score_threshold=scoreThreshold,
                                       max_results=maxObj)
myDetector = vision.ObjectDetector.create_from_options(options)

while True:
    deltaT = time.time() - tStart
    tStart=time.time()
    fps = fps*.95 + (1/deltaT)*.05
    frame= piCam.capture_array()
    frame=cv2.flip(frame,-1)
    myImage = mp.Image(image_format = mp.ImageFormat.SRGB, data=frame)
    myDetections = myDetector.detect(myImage)
    #print(myDetections.detections)
    for detection in myDetections.detections:
        box = detection.bounding_box
        x = box.origin_x
        y = box.origin_y
        w = box.width
        h = box.height
        cv2.rectangle(frame, (x,y), (x+w,y+h), (255,0,0), fontThickness)
    if detection.categories:
        category = detection.categories[0]
        myLabel = category.category_name
        labelText = myLabel+" "+ str(round(category.score*100))+"%"
        cv2.putText(frame,labelText, (x, max(y-10,25)),fontFace,
                                      fontScale*.8,
                                      (0,255,0),
                                      2)
                                      
    myText = "FPS: "+str(round(fps,1))
    cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)
    cv2.imshow("Camera", frame)
    #cv2.moveWindow("Camera",0,60)
    if cv2.waitKey(1)==ord('q'):
        break
myDetector.close()
cv2.destroyAllWindows()
print('Program Terminated')

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

from mediapipe.tasks import python

from mediapipe.tasks.python import vision

piCam = Picamera2(1)

W=1280

H=720

tStart = time.time()

fps = 0

RES = (W,H)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate=60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W/425)

fontScale = H*.0015

fontColor = (0,0,255)

topBar = 65

windowPadding = 0

cv2.namedWindow('Camera', cv2.WINDOW_GUI_NORMAL)

cv2.resizeWindow('Camera', W, H)

tSettle = .1

time.sleep(tSettle)

cv2.moveWindow('Camera', windowPadding, topBar)

modelPath = "/home/pi/ai-lab-kit/mediapipe/efficientdet_lite0.tflite"

scoreThreshold = .35

maxObj = 3

baseOptions = python.BaseOptions(model_asset_path = modelPath)

options = vision.ObjectDetectorOptions(base_options = baseOptions,

score_threshold=scoreThreshold,

max_results=maxObj)

myDetector = vision.ObjectDetector.create_from_options(options)

while True:

deltaT = time.time() - tStart

tStart=time.time()

fps = fps*.95 + (1/deltaT)*.05

frame= piCam.capture_array()

frame=cv2.flip(frame,-1)

myImage = mp.Image(image_format = mp.ImageFormat.SRGB, data=frame)

myDetections = myDetector.detect(myImage)

#print(myDetections.detections)

for detection in myDetections.detections:

box = detection.bounding_box

x = box.origin_x

y = box.origin_y

w = box.width

h = box.height

cv2.rectangle(frame, (x,y), (x+w,y+h), (255,0,0), fontThickness)

if detection.categories:

category = detection.categories[0]

myLabel = category.category_name

labelText = myLabel+" "+ str(round(category.score*100))+"%"

cv2.putText(frame,labelText, (x, max(y-10,25)),fontFace,

fontScale*.8,

(0,255,0),

myText = "FPS: "+str(round(fps,1))

cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

cv2.imshow("Camera", frame)

#cv2.moveWindow("Camera",0,60)

if cv2.waitKey(1)==ord('q'):

break

myDetector.close()

cv2.destroyAllWindows()

print('Program Terminated')

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 54: Custom Hand Gesture Recognition & Dynamic NeoPixel Control

October 9, 2026 admin

Welcome back, everyone! In this lesson, we take edge AI interactivity to the next level. Up until now, we have learned how to track hand landmarks, extract pixel coordinates, and calculate distances using MediaPipe. Today, we put all those building blocks together into a self-contained, real-time hand gesture recognition system running on the Raspberry Pi 5.

We are not relying on a black-box pre-trained gesture model. Instead, we write our own mathematical feature extractor, train our custom hand poses on the fly, save those gesture profiles directly to disk, and map each gesture to a non-blocking lighting animation on a NeoPixel LED ring driven over SPI.

System Architecture Overview

The system operates in three distinct phases running simultaneously inside our main loop:

Normalized Feature Extraction: MediaPipe extracts 3D hand landmark coordinates. To make gesture detection scale-invariant and distance-invariant, we normalize the distances between the fingertips and the wrist against a reference palm dimension.
Nearest-Neighbor Gesture Matching: Live distance vectors are compared against stored gesture profiles using a mean absolute error algorithm. If the error falls below our maximum threshold, the gesture is identified; otherwise, it defaults to “Unknown.”
Non-Blocking Hardware Animation Dispatch: The recognized gesture string triggers corresponding pattern functions on the 12-LED NeoPixel ring via neopixel_spi. Animations use non-blocking time delta checks to preserve high camera preview frame rates.

Gesture-to-Hardware Animation Mapping

Our script contains predefined animation routines mapped to recognized gesture strings. Here is how each pose controls the LED ring:

Recognized Gesture	LED Animation Pattern	Visual Effect
`fist`	Red Pulse	Sinusoidal breathing effect fading in and out
`palm`	Solid Beacon	Full brightness white ring
`peace`	Dual Spinner	Dual green and blue dots rotating over a dim red background
`thumbsup`	Solid Success	Constant green feedback
`point`	Radar Sweep	A green trailing dot chasing around a red ring
`rock`	Cyan Flame	Sinusoidal green-cyan intensity modulation
`ok`	Rainbow Wheel	Rotating HSV spectrum cycle
`Unknown` / Unmatched	Clear	LEDs turn completely off

Interactive Keyboard Controls

While the camera loop is active, you can interact with the system using your keyboard in the preview window:

Spacebar: Captures the current hand pose’s normalized distance vector, assigns it to the active target gesture name, and saves the updated dataset to gestureNEOPIXEL.pkl.
t: Prompts the terminal to add a new custom gesture name to your training queue dynamically.
d: Prompts the terminal to delete a specific gesture profile from the saved dataset.
q: Clears the NeoPixel ring, closes the camera pipeline, saves training data, and terminates the program cleanly.

Hardware Wiring Reference

Ensure your Raspberry Pi 5 SPI interface is enabled before running the code (sudo raspi-config -> Interface Options -> SPI).

NeoPixel Data Input (DIN): Connect to GPIO 10 (SPI0 MOSI / Pin 19).
NeoPixel Ground: Connect to any GND pin on the Pi expansion header.
NeoPixel Power: Connect to an external 5V power supply (ensure a shared ground with the Raspberry Pi).

Homework Challenge

Now that you have a working gesture recognition system linked to hardware animations, try adding your own custom gestures! Train a brand-new gesture pose (like a “three-finger count”), write a corresponding non-blocking animation function in updateNeoPixels(), and share your video results.

Here is the code we developed in the video lesson:

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import math
import pickle
import os
import colorsys

# ====================================================================
# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)
# ====================================================================

import board
import neopixel_spi as neopixel

NUM_LEDS = 12  # Set to match your NeoPixel ring size (e.g., 12)
PO = neopixel.GRB

# Initialize NeoPixel ring using SPI
spi = board.SPI()
strip = neopixel.NeoPixel_SPI(
    spi, 
    NUM_LEDS, 
    pixel_order=PO, 
    auto_write=False
)

# Turn off all LEDs on startup
strip.fill(0)
strip.show()

NEOPIXEL_ENABLED = True
print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)
animation_step = 0
lastAnimUpdate = time.time()
# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle
def saveTrainedData(filename, data):
    with open(filename, 'wb') as f:
        pickle.dump(data, f)
    print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file
def loadTrainedData(filename):
    if os.path.exists(filename):
        with open(filename, 'rb') as f:
            data = pickle.load(f)
            print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))
        return data
    return {}

# --- SETUP & INITIAL TRAINING ---
trainedData = loadTrainedData(DATA_FILE)
gestureNames = []

if not trainedData:
    print("HAND GESTURE TRAINING SETUP")
    numGestures = int(input("Enter Number of Gestures to Train On: "))
    for idx in range(numGestures):
        name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")
        gestureNames.append(name)

def findDistance(pt1, pt2):
    dX = pt1.x - pt2.x
    dY = pt1.y - pt2.y
    dZ = pt1.z - pt2.z
    return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):
    lm = handLm.landmark
    wrist = lm[0]
    indexBase = lm[5]  
    scaleFactor = findDistance(wrist, indexBase)
    tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]
    tipDistances = []
    for tip in tips:
        dist = findDistance(wrist, tip) / scaleFactor
        tipDistances.append(dist)
    for startTip in range(len(tips)):
        for endTip in range(startTip + 1, len(tips)):
            dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor
            tipDistances.append(dist)
    return tipDistances

def calculateError(tipDist, trainDist):
    totalError = 0
    for idx in range(len(tipDist)):
        diff = tipDist[idx] - trainDist[idx]
        totalError += abs(diff)
    return totalError

def findGesture(tipLive, trainedData, maxAllowedError):
    bestMatch = "Unknown"
    lowestError = 999999999
    for gestureName, trainedDist in trainedData.items():
        error = calculateError(tipLive, trainedDist)
        if error < lowestError:
            lowestError = error
            bestMatch = gestureName
    if lowestError > maxAllowedError:
        return "Unknown"
    return bestMatch

# ====================================================================
# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)
# ====================================================================
def hsv2rgb(h):
    """ Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """
    r, g, b = colorsys.hsv_to_rgb(h, 1, 1)
    return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):
    """ Non-blocking LED pattern update based on the current detected gesture """
    global animation_step, lastAnimUpdate
    if not NEOPIXEL_ENABLED:
        return

    now = time.time()
    gestureClean = gesture.lower()
    pattern_matched = False

    # 1. FIST / CHARGE (Red pulse)
    if gestureClean == "fist":
        pulse = int(127 + 127 * math.sin(now * 5.0))
        strip.fill((pulse, 0, 0))
        strip.show()
        pattern_matched = True

    # 2. OPEN PALM / BEACON (Solid Bright White)
    if gestureClean == "palm":
        strip.fill((255, 255, 255))
        strip.show()
        pattern_matched = True

    # 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)
    if gestureClean == "peace":
        if now - lastAnimUpdate > 0.08:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((40, 0, 0))  # Background red
        pos1 = animation_step
        pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS
        strip[pos1] = (0, 255, 0)   # Green spinner dot
        strip[pos2] = (0, 0, 255)   # Blue spinner dot
        strip.show()
        pattern_matched = True

    # 4. THUMBS UP / SUCCESS (Solid Green)
    if gestureClean == "thumbsup":
        strip.fill((0, 255, 0))
        strip.show()
        pattern_matched = True

    # 5. POINTING / CHASER (Radar sweep)
    if gestureClean in "point":
        if now - lastAnimUpdate > 0.06:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((255, 0, 0))
        strip[animation_step] = (0, 255, 0)
        strip.show()
        pattern_matched = True

    # 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)
    if gestureClean == "rock":
        step = int((now * 100) % 360)
        brightness = (math.sin(step * math.pi / 180) + 1) / 2
        g = int(255 * brightness)
        b = int(50 * brightness)
        strip.fill((0, g, b))
        strip.show()
        pattern_matched = True

    # 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)
    if gestureClean in "ok":
        if now - lastAnimUpdate > 0.03:
            animation_step = (animation_step + 1) % 100
            lastAnimUpdate = now
        hue = animation_step / 100.0
        strip.fill(hsv2rgb(hue))
        strip.show()
        pattern_matched = True

    # DEFAULT / UNKNOWN (LEDs OFF)
    if not pattern_matched:
        strip.fill((0, 0, 0))
        strip.show()
# ====================================================================

W, H = 1280, 720
tStart = time.time()
fps = 15
RES = (W, H)

piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate = 60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W / 425)
fontScale = H * .002
fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))
textGesture = (int(W * .01), int(H * .14))
textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5 

hands = mp.solutions.hands.Hands(
    model_complexity=0,
    min_detection_confidence=.5,
    min_tracking_confidence=.5,
    max_num_hands=2
)

trainIdx = 0

while True:
    deltaT = time.time() - tStart
    tStart = time.time()
    fps = fps * .95 + (1 / deltaT) * .05
    
    frame = piCam.capture_array()
    frame = cv2.flip(frame, -1)
    rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgbFrame)
    
    if results.multi_hand_landmarks:
        frameHeight, frameWidth, _ = frame.shape        
        for handLm in results.multi_hand_landmarks:
            for idx, landmark in enumerate(handLm.landmark):
                pixelX = int(landmark.x * frameWidth)
                pixelY = int(landmark.y * frameHeight)
                cv2.putText(
                    frame, str(idx), (pixelX, pixelY),
                    cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness
                )
                
    if trainIdx < len(gestureNames):
        targetName = gestureNames[trainIdx]
        promptText = "show " + targetName + " & Press Space"
        cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

    detectGesture = "Unknown"
    if results.multi_hand_landmarks:
        liveDistances = getTipDistances(results.multi_hand_landmarks[0])
        detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

    # ====================================================================
    # EXECUTE HARDWARE PATTERN UPDATE
    # ====================================================================
    updateNeoPixels(detectGesture)
    # ====================================================================

    labelText = "Gesture: " + detectGesture
    cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)
    myText = "FPS: " + str(round(fps, 1))
    cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)
    
    cv2.imshow("Camera", frame)
    #cv2.moveWindow("Camera", 0, 60)
    
    key = cv2.waitKey(1)
    
    # Save landmark measurements when Space is pressed
    if key == ord(' '):
        if results.multi_hand_landmarks:
            if trainIdx < len(gestureNames):
                targetHand = results.multi_hand_landmarks[0]
                targetName = gestureNames[trainIdx]
                trainedData[targetName] = getTipDistances(targetHand)
                saveTrainedData(DATA_FILE, trainedData)
                trainIdx += 1

    # 't' key allows adding a NEW gesture dynamically during runtime
    if key == ord('t'):
        newGestureName = input("Enter name for new gesture to train: ").strip()
        if newGestureName:
            gestureNames.append(newGestureName)

    # 'd' key deletes a gesture
    if key == ord('d'):
        delName = input("Enter name of gesture to remove: ").strip()
        if delName in trainedData:
            del trainedData[delName]
            saveTrainedData(DATA_FILE, trainedData)
            print("[INFO] Removed " + delName + " from trained data.")
            if delName in gestureNames:
                gestureNames.remove(delName)
        if delName not in trainedData:
            print("[WARNING] Gesture: " + delName + " not found in trained data.")
        trainIdx=min(trainIdx,len(gestureNames))
    if key == ord('q'):
        break

# Clean up hardware and exit
# ====================================================================
# CLEAR LEDS ON SHUTDOWN
# ====================================================================
if NEOPIXEL_ENABLED:
    strip.fill((0, 0, 0))
    strip.show()
# ====================================================================

cv2.destroyAllWindows()
saveTrainedData(DATA_FILE, trainedData)
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import math

import pickle

import os

import colorsys

# ====================================================================

# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)

# ====================================================================

import board

import neopixel_spi as neopixel

NUM_LEDS = 12 # Set to match your NeoPixel ring size (e.g., 12)

PO = neopixel.GRB

# Initialize NeoPixel ring using SPI

spi = board.SPI()

strip = neopixel.NeoPixel_SPI(

spi,

NUM_LEDS,

pixel_order=PO,

auto_write=False

)

# Turn off all LEDs on startup

strip.fill(0)

strip.show()

NEOPIXEL_ENABLED = True

print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)

animation_step = 0

lastAnimUpdate = time.time()

# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle

def saveTrainedData(filename, data):

with open(filename, 'wb') as f:

pickle.dump(data, f)

print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file

def loadTrainedData(filename):

if os.path.exists(filename):

with open(filename, 'rb') as f:

data = pickle.load(f)

print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))

return data

return {}

# --- SETUP & INITIAL TRAINING ---

trainedData = loadTrainedData(DATA_FILE)

gestureNames = []

if not trainedData:

print("HAND GESTURE TRAINING SETUP")

numGestures = int(input("Enter Number of Gestures to Train On: "))

for idx in range(numGestures):

name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")

gestureNames.append(name)

def findDistance(pt1, pt2):

dX = pt1.x - pt2.x

dY = pt1.y - pt2.y

dZ = pt1.z - pt2.z

return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):

lm = handLm.landmark

wrist = lm[0]

indexBase = lm[5]

scaleFactor = findDistance(wrist, indexBase)

tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]

tipDistances = []

for tip in tips:

dist = findDistance(wrist, tip) / scaleFactor

tipDistances.append(dist)

for startTip in range(len(tips)):

for endTip in range(startTip + 1, len(tips)):

dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor

tipDistances.append(dist)

return tipDistances

def calculateError(tipDist, trainDist):

totalError = 0

for idx in range(len(tipDist)):

diff = tipDist[idx] - trainDist[idx]

totalError += abs(diff)

return totalError

def findGesture(tipLive, trainedData, maxAllowedError):

bestMatch = "Unknown"

lowestError = 999999999

for gestureName, trainedDist in trainedData.items():

error = calculateError(tipLive, trainedDist)

if error < lowestError:

lowestError = error

bestMatch = gestureName

if lowestError > maxAllowedError:

return "Unknown"

return bestMatch

# ====================================================================

# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)

# ====================================================================

def hsv2rgb(h):

""" Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """

r, g, b = colorsys.hsv_to_rgb(h, 1, 1)

return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):

""" Non-blocking LED pattern update based on the current detected gesture """

global animation_step, lastAnimUpdate

if not NEOPIXEL_ENABLED:

return

now = time.time()

gestureClean = gesture.lower()

pattern_matched = False

# 1. FIST / CHARGE (Red pulse)

if gestureClean == "fist":

pulse = int(127 + 127 * math.sin(now * 5.0))

strip.fill((pulse, 0, 0))

strip.show()

pattern_matched = True

# 2. OPEN PALM / BEACON (Solid Bright White)

if gestureClean == "palm":

strip.fill((255, 255, 255))

strip.show()

pattern_matched = True

# 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)

if gestureClean == "peace":

if now - lastAnimUpdate > 0.08:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((40, 0, 0)) # Background red

pos1 = animation_step

pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS

strip[pos1] = (0, 255, 0) # Green spinner dot

strip[pos2] = (0, 0, 255) # Blue spinner dot

strip.show()

pattern_matched = True

# 4. THUMBS UP / SUCCESS (Solid Green)

if gestureClean == "thumbsup":

strip.fill((0, 255, 0))

strip.show()

pattern_matched = True

# 5. POINTING / CHASER (Radar sweep)

if gestureClean in "point":

if now - lastAnimUpdate > 0.06:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((255, 0, 0))

strip[animation_step] = (0, 255, 0)

strip.show()

pattern_matched = True

# 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)

if gestureClean == "rock":

step = int((now * 100) % 360)

brightness = (math.sin(step * math.pi / 180) + 1) / 2

g = int(255 * brightness)

b = int(50 * brightness)

strip.fill((0, g, b))

strip.show()

pattern_matched = True

# 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)

if gestureClean in "ok":

if now - lastAnimUpdate > 0.03:

animation_step = (animation_step + 1) % 100

lastAnimUpdate = now

hue = animation_step / 100.0

strip.fill(hsv2rgb(hue))

strip.show()

pattern_matched = True

# DEFAULT / UNKNOWN (LEDs OFF)

if not pattern_matched:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

W, H = 1280, 720

tStart = time.time()

fps = 15

RES = (W, H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate = 60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W / 425)

fontScale = H * .002

fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))

textGesture = (int(W * .01), int(H * .14))

textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5

hands = mp.solutions.hands.Hands(

model_complexity=0,

min_detection_confidence=.5,

min_tracking_confidence=.5,

max_num_hands=2

)

trainIdx = 0

while True:

deltaT = time.time() - tStart

tStart = time.time()

fps = fps * .95 + (1 / deltaT) * .05

frame = piCam.capture_array()

frame = cv2.flip(frame, -1)

rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = hands.process(rgbFrame)

if results.multi_hand_landmarks:

frameHeight, frameWidth, _ = frame.shape

for handLm in results.multi_hand_landmarks:

for idx, landmark in enumerate(handLm.landmark):

pixelX = int(landmark.x * frameWidth)

pixelY = int(landmark.y * frameHeight)

cv2.putText(

frame, str(idx), (pixelX, pixelY),

cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness

)

if trainIdx < len(gestureNames):

targetName = gestureNames[trainIdx]

promptText = "show " + targetName + " & Press Space"

cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

detectGesture = "Unknown"

if results.multi_hand_landmarks:

liveDistances = getTipDistances(results.multi_hand_landmarks[0])

detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

# ====================================================================

# EXECUTE HARDWARE PATTERN UPDATE

# ====================================================================

updateNeoPixels(detectGesture)

# ====================================================================

labelText = "Gesture: " + detectGesture

cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)

myText = "FPS: " + str(round(fps, 1))

cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)

cv2.imshow("Camera", frame)

#cv2.moveWindow("Camera", 0, 60)

key = cv2.waitKey(1)

# Save landmark measurements when Space is pressed

if key == ord(' '):

if results.multi_hand_landmarks:

if trainIdx < len(gestureNames):

targetHand = results.multi_hand_landmarks[0]

targetName = gestureNames[trainIdx]

trainedData[targetName] = getTipDistances(targetHand)

saveTrainedData(DATA_FILE, trainedData)

trainIdx += 1

# 't' key allows adding a NEW gesture dynamically during runtime

if key == ord('t'):

newGestureName = input("Enter name for new gesture to train: ").strip()

if newGestureName:

gestureNames.append(newGestureName)

# 'd' key deletes a gesture

if key == ord('d'):

delName = input("Enter name of gesture to remove: ").strip()

if delName in trainedData:

del trainedData[delName]

saveTrainedData(DATA_FILE, trainedData)

print("[INFO] Removed " + delName + " from trained data.")

if delName in gestureNames:

gestureNames.remove(delName)

if delName not in trainedData:

print("[WARNING] Gesture: " + delName + " not found in trained data.")

trainIdx=min(trainIdx,len(gestureNames))

if key == ord('q'):

break

# Clean up hardware and exit

# ====================================================================

# CLEAR LEDS ON SHUTDOWN

# ====================================================================

if NEOPIXEL_ENABLED:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

cv2.destroyAllWindows()

saveTrainedData(DATA_FILE, trainedData)

print('Program Terminated')

Homework & Next Steps

Try setting up the circuit and running the code on your Raspberry Pi 5. Observe how the frame rate behaves when driving both the camera preview, the hand-tracking model, and the I2C OLED display simultaneously. For your homework, extend this script to include a dynamic color slider or gesture-based brightness control!

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 54: Custom Hand Gesture Recognition and Dynamic NeoPixel Control

October 8, 2026 admin

Welcome back, everyone! This is Paul McWhorter from TopTechBoy.com, and welcome to Lesson 54 in our AI on the Edge series.

In this lesson, we are taking our hand gesture recognition system to the next level by connecting it directly to real physical hardware! We’re going to take the normalized vector distance calculations and MediaPipe hand-tracking models we’ve been building over the past few lessons, and use them to drive a 12-LED NeoPixel Ring via SPI on the Raspberry Pi in real time.

If you’re following along in the series, pull up a chair, get yourself a nice hot cup of iced coffee, and let’s get right into it!

What We Are Building Today

In previous lessons, we learned how to extract 3D landmark coordinates from MediaPipe, scale them by the palm length to achieve scale-invariant gesture tracking, and store those relative Euclidean distances into a pickle database (gestureNEOPIXEL.pkl).

In Lesson 54, we map those live gesture detections directly to non-blocking LED animation patterns:

Fist: Pulses a dynamic red “charge” sine wave.
Open Palm: Drives the NeoPixel ring at full intensity white beacon.
Peace Sign (✌️): Runs a dual-spinner pattern with opposing green and blue tracer LEDs over a low background red glow.
Thumbs Up: Illumination of a solid, bright green “success” status.
Point: Sweeps a fast green radar chaser dot across a red background array.
Rock / Metal (🤘): Generates a smooth, sinusoidal cyan-to-green energy pulse.
OK Sign: Cycles through a full spectrum RGB rainbow wheel.
Unknown / Default: Gracefully turns off all LEDs.

Hardware Setup & Wiring (SPI Interface)

To ensure high frame rates without flickering, we drive our NeoPixels over the SPI bus using the neopixel_spi library.

Wiring Diagram Guide

NeoPixel VCC: Connect to 5V power supply (ensure adequate power if driving high brightness).
NeoPixel GND: Common ground with the Raspberry Pi GND pin.
NeoPixel DIN (Data In): Connect to GPIO 10 (SPI0 MOSI) on the Raspberry Pi pinout (Physical Pin 19).

Note: Ensure SPI is enabled in your Raspberry Pi system configuration (sudo raspi-config -> Interfaces -> SPI).

⌨️ Interactive Keyboard Controls

While running the main video processing loop, you can dynamically manage your trained gestures directly from your keyboard without interrupting the camera feed:

SPACE: Capture and train/overwrite the current gesture showing on screen.
T: Prompt the terminal to type in and add a brand-new gesture name on the fly.
D: Prompt the terminal to remove/delete an existing gesture from the active dataset.
Q: Cleanly turn off all NeoPixel LEDs, save the updated gesture data, and terminate the program.

Complete Python Source Code

Below is the complete, fully commented Python script for Lesson 54.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import math
import pickle
import os
import colorsys

# ====================================================================
# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)
# ====================================================================

import board
import neopixel_spi as neopixel

NUM_LEDS = 12  # Set to match your NeoPixel ring size (e.g., 12)
PO = neopixel.GRB

# Initialize NeoPixel ring using SPI
spi = board.SPI()
strip = neopixel.NeoPixel_SPI(
    spi, 
    NUM_LEDS, 
    pixel_order=PO, 
    auto_write=False
)

# Turn off all LEDs on startup
strip.fill(0)
strip.show()

NEOPIXEL_ENABLED = True
print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)
animation_step = 0
lastAnimUpdate = time.time()
# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle
def saveTrainedData(filename, data):
    with open(filename, 'wb') as f:
        pickle.dump(data, f)
    print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file
def loadTrainedData(filename):
    if os.path.exists(filename):
        with open(filename, 'rb') as f:
            data = pickle.load(f)
            print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))
        return data
    return {}

# --- SETUP & INITIAL TRAINING ---
trainedData = loadTrainedData(DATA_FILE)
gestureNames = []

if not trainedData:
    print("HAND GESTURE TRAINING SETUP")
    numGestures = int(input("Enter Number of Gestures to Train On: "))
    for idx in range(numGestures):
        name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")
        gestureNames.append(name)

def findDistance(pt1, pt2):
    dX = pt1.x - pt2.x
    dY = pt1.y - pt2.y
    dZ = pt1.z - pt2.z
    return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):
    lm = handLm.landmark
    wrist = lm[0]
    indexBase = lm[5]  
    scaleFactor = findDistance(wrist, indexBase)
    tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]
    tipDistances = []
    for tip in tips:
        dist = findDistance(wrist, tip) / scaleFactor
        tipDistances.append(dist)
    for startTip in range(len(tips)):
        for endTip in range(startTip + 1, len(tips)):
            dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor
            tipDistances.append(dist)
    return tipDistances

def calculateError(tipDist, trainDist):
    totalError = 0
    for idx in range(len(tipDist)):
        diff = tipDist[idx] - trainDist[idx]
        totalError += abs(diff)
    return totalError

def findGesture(tipLive, trainedData, maxAllowedError):
    bestMatch = "Unknown"
    lowestError = 999999999
    for gestureName, trainedDist in trainedData.items():
        error = calculateError(tipLive, trainedDist)
        if error < lowestError:
            lowestError = error
            bestMatch = gestureName
    if lowestError > maxAllowedError:
        return "Unknown"
    return bestMatch

# ====================================================================
# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)
# ====================================================================
def hsv2rgb(h):
    """ Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """
    r, g, b = colorsys.hsv_to_rgb(h, 1, 1)
    return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):
    """ Non-blocking LED pattern update based on the current detected gesture """
    global animation_step, lastAnimUpdate
    if not NEOPIXEL_ENABLED:
        return

    now = time.time()
    gestureClean = gesture.lower()
    pattern_matched = False

    # 1. FIST / CHARGE (Red pulse)
    if gestureClean == "fist":
        pulse = int(127 + 127 * math.sin(now * 5.0))
        strip.fill((pulse, 0, 0))
        strip.show()
        pattern_matched = True

    # 2. OPEN PALM / BEACON (Solid Bright White)
    if gestureClean == "palm":
        strip.fill((255, 255, 255))
        strip.show()
        pattern_matched = True

    # 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)
    if gestureClean == "peace":
        if now - lastAnimUpdate > 0.08:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((40, 0, 0))  # Background red
        pos1 = animation_step
        pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS
        strip[pos1] = (0, 255, 0)   # Green spinner dot
        strip[pos2] = (0, 0, 255)   # Blue spinner dot
        strip.show()
        pattern_matched = True

    # 4. THUMBS UP / SUCCESS (Solid Green)
    if gestureClean == "thumbsup":
        strip.fill((0, 255, 0))
        strip.show()
        pattern_matched = True

    # 5. POINTING / CHASER (Radar sweep)
    if gestureClean in "point":
        if now - lastAnimUpdate > 0.06:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((255, 0, 0))
        strip[animation_step] = (0, 255, 0)
        strip.show()
        pattern_matched = True

    # 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)
    if gestureClean == "rock":
        step = int((now * 100) % 360)
        brightness = (math.sin(step * math.pi / 180) + 1) / 2
        g = int(255 * brightness)
        b = int(50 * brightness)
        strip.fill((0, g, b))
        strip.show()
        pattern_matched = True

    # 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)
    if gestureClean in "ok":
        if now - lastAnimUpdate > 0.03:
            animation_step = (animation_step + 1) % 100
            lastAnimUpdate = now
        hue = animation_step / 100.0
        strip.fill(hsv2rgb(hue))
        strip.show()
        pattern_matched = True

    # DEFAULT / UNKNOWN (LEDs OFF)
    if not pattern_matched:
        strip.fill((0, 0, 0))
        strip.show()
# ====================================================================

W, H = 1280, 720
tStart = time.time()
fps = 15
RES = (W, H)

piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate = 60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W / 425)
fontScale = H * .002
fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))
textGesture = (int(W * .01), int(H * .14))
textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5 

hands = mp.solutions.hands.Hands(
    model_complexity=0,
    min_detection_confidence=.5,
    min_tracking_confidence=.5,
    max_num_hands=2
)

trainIdx = 0

while True:
    deltaT = time.time() - tStart
    tStart = time.time()
    fps = fps * .95 + (1 / deltaT) * .05
    
    frame = piCam.capture_array()
    frame = cv2.flip(frame, -1)
    rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgbFrame)
    
    if results.multi_hand_landmarks:
        frameHeight, frameWidth, _ = frame.shape        
        for handLm in results.multi_hand_landmarks:
            for idx, landmark in enumerate(handLm.landmark):
                pixelX = int(landmark.x * frameWidth)
                pixelY = int(landmark.y * frameHeight)
                cv2.putText(
                    frame, str(idx), (pixelX, pixelY),
                    cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness
                )
                
    if trainIdx < len(gestureNames):
        targetName = gestureNames[trainIdx]
        promptText = "show " + targetName + " & Press Space"
        cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

    detectGesture = "Unknown"
    if results.multi_hand_landmarks:
        liveDistances = getTipDistances(results.multi_hand_landmarks[0])
        detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

    # ====================================================================
    # EXECUTE HARDWARE PATTERN UPDATE
    # ====================================================================
    updateNeoPixels(detectGesture)
    # ====================================================================

    labelText = "Gesture: " + detectGesture
    cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)
    myText = "FPS: " + str(round(fps, 1))
    cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)
    
    cv2.imshow("Camera", frame)
    #cv2.moveWindow("Camera", 0, 60)
    
    key = cv2.waitKey(1)
    
    # Save landmark measurements when Space is pressed
    if key == ord(' '):
        if results.multi_hand_landmarks:
            if trainIdx < len(gestureNames):
                targetHand = results.multi_hand_landmarks[0]
                targetName = gestureNames[trainIdx]
                trainedData[targetName] = getTipDistances(targetHand)
                saveTrainedData(DATA_FILE, trainedData)
                trainIdx += 1

    # 't' key allows adding a NEW gesture dynamically during runtime
    if key == ord('t'):
        newGestureName = input("Enter name for new gesture to train: ").strip()
        if newGestureName:
            gestureNames.append(newGestureName)

    # 'd' key deletes a gesture
    if key == ord('d'):
        delName = input("Enter name of gesture to remove: ").strip()
        if delName in trainedData:
            del trainedData[delName]
            saveTrainedData(DATA_FILE, trainedData)
            print("[INFO] Removed " + delName + " from trained data.")
            if delName in gestureNames:
                gestureNames.remove(delName)
        if delName not in trainedData:
            print("[WARNING] Gesture: " + delName + " not found in trained data.")
        trainIdx=min(trainIdx,len(gestureNames))
    if key == ord('q'):
        break

# Clean up hardware and exit
# ====================================================================
# CLEAR LEDS ON SHUTDOWN
# ====================================================================
if NEOPIXEL_ENABLED:
    strip.fill((0, 0, 0))
    strip.show()
# ====================================================================

cv2.destroyAllWindows()
saveTrainedData(DATA_FILE, trainedData)
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import math

import pickle

import os

import colorsys

# ====================================================================

# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)

# ====================================================================

import board

import neopixel_spi as neopixel

NUM_LEDS = 12 # Set to match your NeoPixel ring size (e.g., 12)

PO = neopixel.GRB

# Initialize NeoPixel ring using SPI

spi = board.SPI()

strip = neopixel.NeoPixel_SPI(

spi,

NUM_LEDS,

pixel_order=PO,

auto_write=False

)

# Turn off all LEDs on startup

strip.fill(0)

strip.show()

NEOPIXEL_ENABLED = True

print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)

animation_step = 0

lastAnimUpdate = time.time()

# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle

def saveTrainedData(filename, data):

with open(filename, 'wb') as f:

pickle.dump(data, f)

print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file

def loadTrainedData(filename):

if os.path.exists(filename):

with open(filename, 'rb') as f:

data = pickle.load(f)

print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))

return data

return {}

# --- SETUP & INITIAL TRAINING ---

trainedData = loadTrainedData(DATA_FILE)

gestureNames = []

if not trainedData:

print("HAND GESTURE TRAINING SETUP")

numGestures = int(input("Enter Number of Gestures to Train On: "))

for idx in range(numGestures):

name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")

gestureNames.append(name)

def findDistance(pt1, pt2):

dX = pt1.x - pt2.x

dY = pt1.y - pt2.y

dZ = pt1.z - pt2.z

return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):

lm = handLm.landmark

wrist = lm[0]

indexBase = lm[5]

scaleFactor = findDistance(wrist, indexBase)

tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]

tipDistances = []

for tip in tips:

dist = findDistance(wrist, tip) / scaleFactor

tipDistances.append(dist)

for startTip in range(len(tips)):

for endTip in range(startTip + 1, len(tips)):

dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor

tipDistances.append(dist)

return tipDistances

def calculateError(tipDist, trainDist):

totalError = 0

for idx in range(len(tipDist)):

diff = tipDist[idx] - trainDist[idx]

totalError += abs(diff)

return totalError

def findGesture(tipLive, trainedData, maxAllowedError):

bestMatch = "Unknown"

lowestError = 999999999

for gestureName, trainedDist in trainedData.items():

error = calculateError(tipLive, trainedDist)

if error < lowestError:

lowestError = error

bestMatch = gestureName

if lowestError > maxAllowedError:

return "Unknown"

return bestMatch

# ====================================================================

# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)

# ====================================================================

def hsv2rgb(h):

""" Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """

r, g, b = colorsys.hsv_to_rgb(h, 1, 1)

return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):

""" Non-blocking LED pattern update based on the current detected gesture """

global animation_step, lastAnimUpdate

if not NEOPIXEL_ENABLED:

return

now = time.time()

gestureClean = gesture.lower()

pattern_matched = False

# 1. FIST / CHARGE (Red pulse)

if gestureClean == "fist":

pulse = int(127 + 127 * math.sin(now * 5.0))

strip.fill((pulse, 0, 0))

strip.show()

pattern_matched = True

# 2. OPEN PALM / BEACON (Solid Bright White)

if gestureClean == "palm":

strip.fill((255, 255, 255))

strip.show()

pattern_matched = True

# 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)

if gestureClean == "peace":

if now - lastAnimUpdate > 0.08:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((40, 0, 0)) # Background red

pos1 = animation_step

pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS

strip[pos1] = (0, 255, 0) # Green spinner dot

strip[pos2] = (0, 0, 255) # Blue spinner dot

strip.show()

pattern_matched = True

# 4. THUMBS UP / SUCCESS (Solid Green)

if gestureClean == "thumbsup":

strip.fill((0, 255, 0))

strip.show()

pattern_matched = True

# 5. POINTING / CHASER (Radar sweep)

if gestureClean in "point":

if now - lastAnimUpdate > 0.06:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((255, 0, 0))

strip[animation_step] = (0, 255, 0)

strip.show()

pattern_matched = True

# 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)

if gestureClean == "rock":

step = int((now * 100) % 360)

brightness = (math.sin(step * math.pi / 180) + 1) / 2

g = int(255 * brightness)

b = int(50 * brightness)

strip.fill((0, g, b))

strip.show()

pattern_matched = True

# 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)

if gestureClean in "ok":

if now - lastAnimUpdate > 0.03:

animation_step = (animation_step + 1) % 100

lastAnimUpdate = now

hue = animation_step / 100.0

strip.fill(hsv2rgb(hue))

strip.show()

pattern_matched = True

# DEFAULT / UNKNOWN (LEDs OFF)

if not pattern_matched:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

W, H = 1280, 720

tStart = time.time()

fps = 15

RES = (W, H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate = 60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W / 425)

fontScale = H * .002

fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))

textGesture = (int(W * .01), int(H * .14))

textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5

hands = mp.solutions.hands.Hands(

model_complexity=0,

min_detection_confidence=.5,

min_tracking_confidence=.5,

max_num_hands=2

)

trainIdx = 0

while True:

deltaT = time.time() - tStart

tStart = time.time()

fps = fps * .95 + (1 / deltaT) * .05

frame = piCam.capture_array()

frame = cv2.flip(frame, -1)

rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = hands.process(rgbFrame)

if results.multi_hand_landmarks:

frameHeight, frameWidth, _ = frame.shape

for handLm in results.multi_hand_landmarks:

for idx, landmark in enumerate(handLm.landmark):

pixelX = int(landmark.x * frameWidth)

pixelY = int(landmark.y * frameHeight)

cv2.putText(

frame, str(idx), (pixelX, pixelY),

cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness

)

if trainIdx < len(gestureNames):

targetName = gestureNames[trainIdx]

promptText = "show " + targetName + " & Press Space"

cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

detectGesture = "Unknown"

if results.multi_hand_landmarks:

liveDistances = getTipDistances(results.multi_hand_landmarks[0])

detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

# ====================================================================

# EXECUTE HARDWARE PATTERN UPDATE

# ====================================================================

updateNeoPixels(detectGesture)

# ====================================================================

labelText = "Gesture: " + detectGesture

cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)

myText = "FPS: " + str(round(fps, 1))

cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)

cv2.imshow("Camera", frame)

#cv2.moveWindow("Camera", 0, 60)

key = cv2.waitKey(1)

# Save landmark measurements when Space is pressed

if key == ord(' '):

if results.multi_hand_landmarks:

if trainIdx < len(gestureNames):

targetHand = results.multi_hand_landmarks[0]

targetName = gestureNames[trainIdx]

trainedData[targetName] = getTipDistances(targetHand)

saveTrainedData(DATA_FILE, trainedData)

trainIdx += 1

# 't' key allows adding a NEW gesture dynamically during runtime

if key == ord('t'):

newGestureName = input("Enter name for new gesture to train: ").strip()

if newGestureName:

gestureNames.append(newGestureName)

# 'd' key deletes a gesture

if key == ord('d'):

delName = input("Enter name of gesture to remove: ").strip()

if delName in trainedData:

del trainedData[delName]

saveTrainedData(DATA_FILE, trainedData)

print("[INFO] Removed " + delName + " from trained data.")

if delName in gestureNames:

gestureNames.remove(delName)

if delName not in trainedData:

print("[WARNING] Gesture: " + delName + " not found in trained data.")

trainIdx=min(trainIdx,len(gestureNames))

if key == ord('q'):

break

# Clean up hardware and exit

# ====================================================================

# CLEAR LEDS ON SHUTDOWN

# ====================================================================

if NEOPIXEL_ENABLED:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

cv2.destroyAllWindows()

saveTrainedData(DATA_FILE, trainedData)

print('Program Terminated')

Homework Assignment

Your homework for this lesson is to modify the updateNeoPixels() function to add two new custom hand gestures of your own creation! Try implementing custom animations like a warm candle flicker or a pulsating dual-color pattern. Leave a link to your solution videos in the comments below!

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 53: Gesture Recognition on the Pi 5 with Training File

October 4, 2026 admin

Welcome back, everyone! In this lesson, we are taking our custom MediaPipe hand gesture recognition system to the next level. Up until now, every time you stopped your Python script, all of your hard-earned gesture training data vanished into thin air. If you wanted to run your project again, you had to re-train every single hand sign from scratch.

That ends today. We are going to make our AI remember what it learned by saving our gesture feature vectors to a local file using Python’s pickle library.

What You Will Learn in This Lesson

Data Persistence: How to serialize and save Python dictionaries containing landmark distance vectors directly to disk (gesture_data.pkl).
Automated Setup: How to check for existing training files at boot so your program automatically skips the initial training prompt if data already exists.
Dynamic Training Management: How to interactively train new gestures on the fly ('t' key) or delete outdated gestures ('d' key) during runtime while automatically updating the saved file.
Robust Error Handling: Ensuring index tracking (trainIdx) safely syncs with live gesture arrays so pressing the spacebar never crashes your video feed.

Key Concepts Explained

1. Pickling Data Objects In MediaPipe gesture recognition, a trained gesture isn’t a complex neural network weight file; it’s simply a dictionary mapping a gesture name (string) to a list of normalized keypoint ratios (floating-point numbers). Python’s pickle module allows us to convert this dictionary into a byte stream and write it directly to a file (.pkl). When the program launches, pickle.load() reconstructs the dictionary in milliseconds.

2. Managing Execution Flow on Startup When gesture_data.pkl exists, our program automatically populates gestureNames with the keys from trainedData and sets trainIdx past the end of the array. This keeps the camera pipeline running in Inference Mode immediately. If no file exists, the script seamlessly drops into Training Setup Mode to prompt the user for initial inputs.

This is the code we develop in this video lesson:

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import math
import os
import pickle

DATA_FILE = "gesture_data.pkl"

def saveTrainedData(filename, data):
    with open(filename, 'wb') as f:
        pickle.dump(data,f)
    print("[INFO] Saved Gesture Data to "+str(filename))
def loadTrainedData(filename):
    if os.path.exists(filename):
        with open(filename, 'rb') as f:
            data = pickle.load(f)
            print("[INFO] LOADED "+str(len(data))+ " gestures from " + str(filename))
            return data
    if not os.path.exists(filename):
        return {}

def findDistance(pt1, pt2):
    dX = pt1.x - pt2.x
    dY = pt1.y - pt2.y
    dZ = pt1.z - pt2.z
    dist = math.sqrt(dX*dX + dY*dY + dZ*dZ)
    return dist

def getTipDistances(handLm):
    lm = handLm.landmark
    wrist = lm[0]
    indexBase = lm[5]  
    scaleFactor = findDistance(wrist, indexBase)
    tips = [lm[4],lm[8],lm[12],lm[16],lm[20]]
    tipDistances =[]
    for tip in tips:
        dist = findDistance( wrist, tip) / scaleFactor
        tipDistances.append(dist)
    for startTip in range(len(tips)):
        for endTip in range(startTip+1, len(tips)):
            dist = findDistance(tips[startTip],tips[endTip]) / scaleFactor
            tipDistances.append(dist)
    return tipDistances

def calculateError(tipDist, trainDist):
    totalError = 0
    for idx in range(len(tipDist)):
        diff = tipDist[idx] -trainDist[idx]
        totalError = totalError + abs(diff)
    return totalError

def findGesture(tipLive, trainedData, maxAllowedError):
    bestMatch = "Unknown"
    lowestError = 999999999
    for gestureName, trainedDist in trainedData.items():
        error  = calculateError(tipLive, trainedDist)
        if error < lowestError:
            lowestError = error
            bestMatch = gestureName
    if lowestError > maxAllowedError:
        return "Unknown"
    if lowestError <= maxAllowedError:
        return bestMatch
trainedData = loadTrainedData(DATA_FILE)
gestureNames =[]
if not trainedData:
    print("HAND GESTURE TRAINING SETUP")
    numGestures = int(input("Enter Number of Gestures to Train On: "))
    gestureNames =[]
    for idx in range(numGestures):
        name = input("Enter Name for Gesture #"+ str(idx+1)+ ": ")
        gestureNames.append(name)
W=1280
H=720
tStart = time.time()
fps = 15
RES = (W,H)
piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate=60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W*.01),int(H*.07))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W/425)
fontScale = H*.002
fontColor = (0,0,255)

textFps = (int(W*.01),int(H*.07))
textGesture= (int(W*.01),int(H*.14))
textGesturePrompt = (int(W*.01),int(H*.21))

maxErrorThreshold = 3.5 

hands = mp.solutions.hands.Hands(
    model_complexity =  0,
    min_detection_confidence = .5,
    min_tracking_confidence = .5,
    max_num_hands =2)
trainIdx = 0

while True:
    deltaT = time.time() - tStart
    tStart=time.time()
    fps = fps*.95 + (1/deltaT)*.05
    frame= piCam.capture_array()
    frame=cv2.flip(frame,-1)
    rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgbFrame)
    if results.multi_hand_landmarks:
        frameHeight, frameWidth, _ = frame.shape        
        for handLm in results.multi_hand_landmarks:
            # Draw landmark numbers on hand joints
            for idx, landmark in enumerate(handLm.landmark):
                pixelX = int(landmark.x * frameWidth)
                pixelY = int(landmark.y * frameHeight)
                cv2.putText(
                    frame, str(idx), (pixelX, pixelY),
                    cv2.FONT_HERSHEY_SIMPLEX, .6*fontScale, (255, 0, 0), fontThickness
                )
    if trainIdx < len(gestureNames):
        targetName = gestureNames[trainIdx]
        promptText = "show " + targetName + " & Press Space"
        cv2.putText(frame,promptText, textGesturePrompt, fontFace,fontScale, (0,255,255), fontThickness)
    detectGesture = "Unknown"
    if results.multi_hand_landmarks:
        liveDistances = getTipDistances(results.multi_hand_landmarks[0])
        detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)
    labelText = "Gesture: " + detectGesture
    cv2.putText(frame, labelText, textGesture,fontFace,fontScale, (0,255,0),fontThickness)
    myText = "FPS: "+str(round(fps,1))
    cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)
    cv2.imshow("Camera", frame)
    #cv2.moveWindow("Camera",0,60)
    key = cv2.waitKey(1)
    if key == ord('t'):
        newGestureName = input("Enter Name for New Gesture: ")
        gestureNames.append(newGestureName)
        saveTrainedData(DATA_FILE, trainedData)
    if key == ord('d'):
        delName = input("Enter Name of Gesture to Remove: ")
        if delName not in trainedData:
            print("[WARNING] Gesture "+delName+ " Not Found in Training Data.")
        if delName in trainedData:
            del trainedData[delName]
            saveTrainedData(DATA_FILE,trainedData)
            print("[INFO] Removed "+delName+"from trained data.")
            if delName in gestureNames:
                gestureNames.remove(delName)
            trainIdx=min(trainIdx,len(gestureNames))
    if key == ord(' '):
        if results.multi_hand_landmarks:
            targetHand = results.multi_hand_landmarks[0]
            trainedData[targetName] = getTipDistances(targetHand)
            trainIdx = trainIdx + 1
    if key == ord('q'):
        break
cv2.destroyAllWindows()
saveTrainedData(DATA_FILE, trainedData)
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import math

import os

import pickle

DATA_FILE = "gesture_data.pkl"

def saveTrainedData(filename, data):

with open(filename, 'wb') as f:

pickle.dump(data,f)

print("[INFO] Saved Gesture Data to "+str(filename))

def loadTrainedData(filename):

if os.path.exists(filename):

with open(filename, 'rb') as f:

data = pickle.load(f)

print("[INFO] LOADED "+str(len(data))+ " gestures from " + str(filename))

return data

if not os.path.exists(filename):

return {}

def findDistance(pt1, pt2):

dX = pt1.x - pt2.x

dY = pt1.y - pt2.y

dZ = pt1.z - pt2.z

dist = math.sqrt(dX*dX + dY*dY + dZ*dZ)

return dist

def getTipDistances(handLm):

lm = handLm.landmark

wrist = lm[0]

indexBase = lm[5]

scaleFactor = findDistance(wrist, indexBase)

tips = [lm[4],lm[8],lm[12],lm[16],lm[20]]

tipDistances =[]

for tip in tips:

dist = findDistance( wrist, tip) / scaleFactor

tipDistances.append(dist)

for startTip in range(len(tips)):

for endTip in range(startTip+1, len(tips)):

dist = findDistance(tips[startTip],tips[endTip]) / scaleFactor

tipDistances.append(dist)

return tipDistances

def calculateError(tipDist, trainDist):

totalError = 0

for idx in range(len(tipDist)):

diff = tipDist[idx] -trainDist[idx]

totalError = totalError + abs(diff)

return totalError

def findGesture(tipLive, trainedData, maxAllowedError):

bestMatch = "Unknown"

lowestError = 999999999

for gestureName, trainedDist in trainedData.items():

error = calculateError(tipLive, trainedDist)

if error < lowestError:

lowestError = error

bestMatch = gestureName

if lowestError > maxAllowedError:

return "Unknown"

if lowestError <= maxAllowedError:

return bestMatch

trainedData = loadTrainedData(DATA_FILE)

gestureNames =[]

if not trainedData:

print("HAND GESTURE TRAINING SETUP")

numGestures = int(input("Enter Number of Gestures to Train On: "))

gestureNames =[]

for idx in range(numGestures):

name = input("Enter Name for Gesture #"+ str(idx+1)+ ": ")

gestureNames.append(name)

W=1280

H=720

tStart = time.time()

fps = 15

RES = (W,H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate=60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W*.01),int(H*.07))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W/425)

fontScale = H*.002

fontColor = (0,0,255)

textFps = (int(W*.01),int(H*.07))

textGesture= (int(W*.01),int(H*.14))

textGesturePrompt = (int(W*.01),int(H*.21))

maxErrorThreshold = 3.5

hands = mp.solutions.hands.Hands(

model_complexity = 0,

min_detection_confidence = .5,

min_tracking_confidence = .5,

max_num_hands =2)

trainIdx = 0

while True:

deltaT = time.time() - tStart

tStart=time.time()

fps = fps*.95 + (1/deltaT)*.05

frame= piCam.capture_array()

frame=cv2.flip(frame,-1)

rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = hands.process(rgbFrame)

if results.multi_hand_landmarks:

frameHeight, frameWidth, _ = frame.shape

for handLm in results.multi_hand_landmarks:

# Draw landmark numbers on hand joints

for idx, landmark in enumerate(handLm.landmark):

pixelX = int(landmark.x * frameWidth)

pixelY = int(landmark.y * frameHeight)

cv2.putText(

frame, str(idx), (pixelX, pixelY),

cv2.FONT_HERSHEY_SIMPLEX, .6*fontScale, (255, 0, 0), fontThickness

)

if trainIdx < len(gestureNames):

targetName = gestureNames[trainIdx]

promptText = "show " + targetName + " & Press Space"

cv2.putText(frame,promptText, textGesturePrompt, fontFace,fontScale, (0,255,255), fontThickness)

detectGesture = "Unknown"

if results.multi_hand_landmarks:

liveDistances = getTipDistances(results.multi_hand_landmarks[0])

detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

labelText = "Gesture: " + detectGesture

cv2.putText(frame, labelText, textGesture,fontFace,fontScale, (0,255,0),fontThickness)

myText = "FPS: "+str(round(fps,1))

cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

cv2.imshow("Camera", frame)

#cv2.moveWindow("Camera",0,60)

key = cv2.waitKey(1)

if key == ord('t'):

newGestureName = input("Enter Name for New Gesture: ")

gestureNames.append(newGestureName)

saveTrainedData(DATA_FILE, trainedData)

if key == ord('d'):

delName = input("Enter Name of Gesture to Remove: ")

if delName not in trainedData:

print("[WARNING] Gesture "+delName+ " Not Found in Training Data.")

if delName in trainedData:

del trainedData[delName]

saveTrainedData(DATA_FILE,trainedData)

print("[INFO] Removed "+delName+"from trained data.")

if delName in gestureNames:

gestureNames.remove(delName)

trainIdx=min(trainIdx,len(gestureNames))

if key == ord(' '):

if results.multi_hand_landmarks:

targetHand = results.multi_hand_landmarks[0]

trainedData[targetName] = getTipDistances(targetHand)

trainIdx = trainIdx + 1

if key == ord('q'):

break

cv2.destroyAllWindows()

saveTrainedData(DATA_FILE, trainedData)

print('Program Terminated')

Homework Assignment

Now that your Pi 5 can remember hand gestures across reboots, it’s time to bridge software recognition with real-world hardware control!

The Challenge: Integrate an SPI NeoPixel Ring (WS2812B/SK6812) with your gesture recognition code.

Map distinct hand signs to dynamic LED patterns (for example: Fist = Red Pulse, Open Palm = Bright White Beacon, Peace Sign = Dual Spinner, OK Sign = Rainbow Wheel).
Make sure your animation updates are smooth and non-blocking so your OpenCV camera frame rate doesn’t drop!

We want to see who in the community can build the most impressive physical light demonstration controlled entirely by hand gestures. Share your video results and code modifications in the comments below!

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 52: Gesture Recognition on the Raspberry Pi 5

September 28, 2026 admin

Welcome back, everyone! In today’s lesson, AI on the Edge LESSON 52: Gesture Recognition on the Raspberry Pi 5, we are building a custom, real-time hand gesture recognition system from scratch. Up until now, we have been using MediaPipe to track keypoints, identify individual hand joints, and extract raw 3D coordinate data. But raw coordinates alone don’t tell the computer what your hand is actually doing. Today, we bridge that gap by teaching our Raspberry Pi 5 how to train on custom hand positions and dynamically classify live hand gestures using pure mathematics and vector geometry—no heavy neural network retraining required.

The core secret to making gesture recognition work reliably across different camera distances is scale-invariant distance normalization. If you simply measure the pixel distance between your fingertips and your wrist, bringing your hand closer to the camera lens will blow out those numbers and break your classifier. To solve this, our script establishes a baseline unit of measurement for every single frame: the distance between the wrist (landmark 0) and the index finger base joint (landmark 5). By dividing all measured finger-tip-to-wrist and tip-to-tip distances by this dynamic scale factor, the resulting feature vector remains identical whether your hand is two feet away or five feet away from the lens.

Once we extract this normalized 15-element feature vector—representing the spatial ratios between all five fingertips relative to the wrist and each other—we construct an interactive training phase directly inside the live video loop. The program prompts you in the terminal for the number of custom gestures you wish to record, along with their labels (such as “Peace”, “Thumbs Up”, or “Fist”). As you present each gesture to your camera feed and press the spacebar, the algorithm captures the instantaneous geometric signature of your hand and stores it in a runtime training dictionary.

During live inference, our classifier calculates the Sum of Absolute Errors (SAE), or Manhattan distance, between the live incoming feature vector and every stored profile in our training dataset. The function loops through all saved gestures to find the candidate with the absolute lowest cumulative error score. To prevent false positives when an untrained or messy hand pose is shown, we compare that lowest error score against a strict threshold value (maxErrorThreshold = 3.5). If the error falls within the allowable boundary, the matched gesture label is instantly displayed on the live OpenCV HUD; otherwise, the system safely defaults to “Unknown”.

We manage our camera feed using high-speed frame capture with Picamera2 running at 60 frames per second at 1280×720 resolution, processing hand detection with MediaPipe Hands, and rendering real-time performance diagnostics—including an exponential moving average FPS counter—directly onto the video output. Go ahead, study the methodology, load the concept onto your Raspberry Pi 5, grab a hot cup of coffee, and let’s get building!

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import math

def findDistance(pt1, pt2):
    dX = pt1.x - pt2.x
    dY = pt1.y - pt2.y
    dZ = pt1.z - pt2.z
    dist = math.sqrt(dX*dX + dY*dY + dZ*dZ)
    return dist

def getTipDistances(handLm):
    lm = handLm.landmark
    wrist = lm[0]
    indexBase = lm[5]  
    scaleFactor = findDistance(wrist, indexBase)
    tips = [lm[4],lm[8],lm[12],lm[16],lm[20]]
    tipDistances =[]
    for tip in tips:
        dist = findDistance( wrist, tip) / scaleFactor
        tipDistances.append(dist)
    for startTip in range(len(tips)):
        for endTip in range(startTip+1, len(tips)):
            dist = findDistance(tips[startTip],tips[endTip]) / scaleFactor
            tipDistances.append(dist)
    return tipDistances

def calculateError(tipDist, trainDist):
    totalError = 0
    for idx in range(len(tipDist)):
        diff = tipDist[idx] -trainDist[idx]
        totalError = totalError + abs(diff)
    return totalError

def findGesture(tipLive, trainedData, maxAllowedError):
    bestMatch = "Unknown"
    lowestError = 999999999
    for gestureName, trainedDist in trainedData.items():
        error  = calculateError(tipLive, trainedDist)
        if error < lowestError:
            lowestError = error
            bestMatch = gestureName
    if lowestError > maxAllowedError:
        return "Unknown"
    if lowestError <= maxAllowedError:
        return bestMatch
print("HAND GESTURE TRAINING SETUP")
numGestures = int(input("Enter Number of Gestures to Train On: "))
gestureNames =[]
for idx in range(numGestures):
    name = input("Enter Name for Gesture #"+ str(idx+1)+ ": ")
    gestureNames.append(name)
W=1280
H=720
tStart = time.time()
fps = 15
RES = (W,H)
piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate=60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W*.01),int(H*.07))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W/425)
fontScale = H*.002
fontColor = (0,0,255)

textFps = (int(W*.01),int(H*.07))
textGesture= (int(W*.01),int(H*.14))
textGesturePrompt = (int(W*.01),int(H*.21))

maxErrorThreshold = 3.5 

hands = mp.solutions.hands.Hands(
    model_complexity =  0,
    min_detection_confidence = .5,
    min_tracking_confidence = .5,
    max_num_hands =2)

trainedData ={}
trainIdx = 0

while True:
    deltaT = time.time() - tStart
    tStart=time.time()
    fps = fps*.95 + (1/deltaT)*.05
    frame= piCam.capture_array()
    frame=cv2.flip(frame,-1)
    rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgbFrame)
    if results.multi_hand_landmarks:
        frameHeight, frameWidth, _ = frame.shape        
        for handLm in results.multi_hand_landmarks:
            # Draw landmark numbers on hand joints
            for idx, landmark in enumerate(handLm.landmark):
                pixelX = int(landmark.x * frameWidth)
                pixelY = int(landmark.y * frameHeight)
                cv2.putText(
                    frame, str(idx), (pixelX, pixelY),
                    cv2.FONT_HERSHEY_SIMPLEX, .6*fontScale, (255, 0, 0), fontThickness
                )
    if trainIdx < len(gestureNames):
        targetName = gestureNames[trainIdx]
        promptText = "show " + targetName + " & Press Space"
        cv2.putText(frame,promptText, textGesturePrompt, fontFace,fontScale, (0,255,255), fontThickness)
        key = cv2.waitKey(1)
        if key == ord(' '):
            if results.multi_hand_landmarks:
                targetHand = results.multi_hand_landmarks[0]
                trainedData[targetName] = getTipDistances(targetHand)
                trainIdx = trainIdx + 1
        if key == ord('q'):
            break
    detectGesture = "Unknown"
    if results.multi_hand_landmarks:
        liveDistances = getTipDistances(results.multi_hand_landmarks[0])
        detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)
    labelText = "Gesture: " + detectGesture
    cv2.putText(frame, labelText, textGesture,fontFace,fontScale, (0,255,0),fontThickness)
    myText = "FPS: "+str(round(fps,1))
    cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)
    cv2.imshow("Camera", frame)
    cv2.moveWindow("Camera",0,60)
    if cv2.waitKey(1)==ord('q'):
        break
cv2.destroyAllWindows()
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import math

def findDistance(pt1, pt2):

dX = pt1.x - pt2.x

dY = pt1.y - pt2.y

dZ = pt1.z - pt2.z

dist = math.sqrt(dX*dX + dY*dY + dZ*dZ)

return dist

def getTipDistances(handLm):

lm = handLm.landmark

wrist = lm[0]

indexBase = lm[5]

scaleFactor = findDistance(wrist, indexBase)

tips = [lm[4],lm[8],lm[12],lm[16],lm[20]]

tipDistances =[]

for tip in tips:

dist = findDistance( wrist, tip) / scaleFactor

tipDistances.append(dist)

for startTip in range(len(tips)):

for endTip in range(startTip+1, len(tips)):

dist = findDistance(tips[startTip],tips[endTip]) / scaleFactor

tipDistances.append(dist)

return tipDistances

def calculateError(tipDist, trainDist):

totalError = 0

for idx in range(len(tipDist)):

diff = tipDist[idx] -trainDist[idx]

totalError = totalError + abs(diff)

return totalError

def findGesture(tipLive, trainedData, maxAllowedError):

bestMatch = "Unknown"

lowestError = 999999999

for gestureName, trainedDist in trainedData.items():

error = calculateError(tipLive, trainedDist)

if error < lowestError:

lowestError = error

bestMatch = gestureName

if lowestError > maxAllowedError:

return "Unknown"

if lowestError <= maxAllowedError:

return bestMatch

print("HAND GESTURE TRAINING SETUP")

numGestures = int(input("Enter Number of Gestures to Train On: "))

gestureNames =[]

for idx in range(numGestures):

name = input("Enter Name for Gesture #"+ str(idx+1)+ ": ")

gestureNames.append(name)

W=1280

H=720

tStart = time.time()

fps = 15

RES = (W,H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate=60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W*.01),int(H*.07))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W/425)

fontScale = H*.002

fontColor = (0,0,255)

textFps = (int(W*.01),int(H*.07))

textGesture= (int(W*.01),int(H*.14))

textGesturePrompt = (int(W*.01),int(H*.21))

maxErrorThreshold = 3.5

hands = mp.solutions.hands.Hands(

model_complexity = 0,

min_detection_confidence = .5,

min_tracking_confidence = .5,

max_num_hands =2)

trainedData ={}

trainIdx = 0

while True:

deltaT = time.time() - tStart

tStart=time.time()

fps = fps*.95 + (1/deltaT)*.05

frame= piCam.capture_array()

frame=cv2.flip(frame,-1)

rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = hands.process(rgbFrame)

if results.multi_hand_landmarks:

frameHeight, frameWidth, _ = frame.shape

for handLm in results.multi_hand_landmarks:

# Draw landmark numbers on hand joints

for idx, landmark in enumerate(handLm.landmark):

pixelX = int(landmark.x * frameWidth)

pixelY = int(landmark.y * frameHeight)

cv2.putText(

frame, str(idx), (pixelX, pixelY),

cv2.FONT_HERSHEY_SIMPLEX, .6*fontScale, (255, 0, 0), fontThickness

)

if trainIdx < len(gestureNames):

targetName = gestureNames[trainIdx]

promptText = "show " + targetName + " & Press Space"

cv2.putText(frame,promptText, textGesturePrompt, fontFace,fontScale, (0,255,255), fontThickness)

key = cv2.waitKey(1)

if key == ord(' '):

if results.multi_hand_landmarks:

targetHand = results.multi_hand_landmarks[0]

trainedData[targetName] = getTipDistances(targetHand)

trainIdx = trainIdx + 1

if key == ord('q'):

break

detectGesture = "Unknown"

if results.multi_hand_landmarks:

liveDistances = getTipDistances(results.multi_hand_landmarks[0])

detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

labelText = "Gesture: " + detectGesture

cv2.putText(frame, labelText, textGesture,fontFace,fontScale, (0,255,0),fontThickness)

myText = "FPS: "+str(round(fps,1))

cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

cv2.imshow("Camera", frame)

cv2.moveWindow("Camera",0,60)

if cv2.waitKey(1)==ord('q'):

break

cv2.destroyAllWindows()

print('Program Terminated')

Technology Tutorials

AI on the Edge LESSON 55: Object Detection on the Raspberry Pi 5 With MediaPipe

What We Are Doing in Lesson 55

Key Takeaways & Concepts Covered

What You Will Need

Homework Assignment

AI on the Edge LESSON 54: Custom Hand Gesture Recognition & Dynamic NeoPixel Control

System Architecture Overview

Gesture-to-Hardware Animation Mapping

Interactive Keyboard Controls

Hardware Wiring Reference

Homework Challenge

Homework & Next Steps

AI on the Edge LESSON 54: Custom Hand Gesture Recognition and Dynamic NeoPixel Control

What We Are Building Today

Hardware Setup & Wiring (SPI Interface)

Wiring Diagram Guide

⌨️ Interactive Keyboard Controls

Complete Python Source Code

Homework Assignment

AI on the Edge LESSON 53: Gesture Recognition on the Pi 5 with Training File

AI on the Edge LESSON 52: Gesture Recognition on the Raspberry Pi 5

Making The World a Better Place One High Tech Project at a Time. Enjoy!