Shawn at 04:06, 1 March 2026

2026-03-01T04:06:07Z

← Older revision		Revision as of 21:06, 28 February 2026
Line 10:		Line 10:
	"""Todo		"""Todo
	Display on frame notice if no cameras found.		Display on frame notice if no cameras found.
	~~Button for quitting.~~
	Button for going back to camera selection.		Button for going back to camera selection.
	Convert from global variables to parameters passed to functions.		Convert from global variables to parameters passed to functions.
Line 16:		Line 15:
	Sliders/dials for parameters		Sliders/dials for parameters
	Smoothly add/reduce particles		Smoothly add/reduce particles
	~~KNOW THAT VARIABLES INSIDE A FUNCTION CAN BE ACCESSED BY ENCLOSED FUNCTIONS~~

	"""		"""

Shawn: New page with code

2026-03-01T04:05:31Z

New page with code

New page

I'd enjoyed the interactive particles on a screen with a camera I've seen at the Museum of Science and other places, and I've wanted to program them for years, so as I started to learn Python I used Devstral LLM to jumpstart a program, then added features.
Here's the code:
<syntaxhighlight lang="python" line copy>
from cv2_enumerate_cameras import enumerate_cameras
import cv2
import numpy as np
import random
from collections import deque
import time
"""Todo
Display on frame notice if no cameras found.
Button for quitting.
Button for going back to camera selection.
Convert from global variables to parameters passed to functions.
Variable particle colors, size, mass
Sliders/dials for parameters
Smoothly add/reduce particles
KNOW THAT VARIABLES INSIDE A FUNCTION CAN BE ACCESSED BY ENCLOSED FUNCTIONS

"""
# Global variables
particle_count = 80 # Initial number of particles
min_area = 500 # Minimum area to consider as motion
history = 10 # Number of frames for background subtraction
particles = deque(maxlen=particle_count)
particle_size = 10
particle_color = (250, 200, 50)
motion_objects = [] # List to store motion objects (center, direction)
damping = 0.9995
gravity = 0.09
MAX_MOTION_OBJECTS = 10
STATES = ("Camera selection", "Activity")
state = 0
window_size = {"width":1024,"height":768}

def capture_still(camera):
"""Capture a still image from the specified camera on its backend"""
cap = cv2.VideoCapture(camera.index, camera.backend)
time.sleep(0.6) # Wait for camera to open before getting snapshot; some short times cause error.
#print("Captured a still")
ret, frame = cap.read()
cap.release()
return frame

def display_cameras_and_get_selection(cameras):
"""Display stills from all cameras and let user select one"""
# cameras is a list of CameraInfo objects with properties we'll use: CameraInfo.name and CameraInfo.index
camera_ID = None
camera_indices = [camera.index for camera in cameras]
#print(f"debug: camera_indices:{camera_indices}")

def on_mouse_event_camera_selection(event, x, y, flags, param):
nonlocal camera_ID
"""Click event during camera selection"""
if event == cv2.EVENT_LBUTTONDOWN:
# Get the list of camera indices and their positions
camera_indices, positions = param
# Check which camera was clicked
for i, (cx, cy, cw, ch) in enumerate(positions):
if cx <= x <= cx + cw and cy <= y <= cy + ch:
camera_ID = camera_indices[i]
#print(f"on_mouse_event_camera_selection set camera_ID: {camera_ID}")
return
return

# Capture stills from all cameras
stills = []
for camera in cameras:
stills.append(capture_still(camera))

# Create a window to display all stills
window_name = "Select Camera"
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
cv2.resizeWindow(window_name, window_size["width"], window_size["height"])

# Calculate grid layout
cols = 4
rows = (len(stills) + cols - 1) // cols

# Prepare to store camera positions
camera_positions = []

# Calculate image size and spacing
spacing = 10
img_width = (window_size["width"] - 2*spacing)//cols
img_height = img_width * window_size["height"] // window_size["width"]
#print(img_width, " ", img_height)

# Create a blank canvas of 1024x768
canvas = np.ones((window_size["height"], window_size["width"], 3), dtype=np.uint8)

# Display all stills in a grid on the canvas
for i, still in enumerate(stills):
row = i // cols
col = i % cols

# Resize image to 320x240
#print(f"Resizing: img_width, img_height:{img_width}, {img_height}")
resized = cv2.resize(still, (img_width, img_height))

# Calculate position in the grid
x = col * (img_width + spacing)
y = row * (img_height + spacing)

# Store camera position for click detection
camera_positions.append((x, y, img_width, img_height))

# Place image on canvas
canvas[y:y+img_height, x:x+img_width] = resized

# Add camera index text
cv2.putText(canvas, f"Camera {camera_indices[i]}", (x+10, y+20),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

# Display the canvas
cv2.imshow(window_name, canvas)

# Set mouse callback
cv2.setMouseCallback(window_name, on_mouse_event_camera_selection, (camera_indices, camera_positions))

# Wait for user to click on an image
last_time=time.time()
while True:
key = cv2.waitKey(1) & 0xFF
if time.time()-last_time > 1.0:
last_time = time.time()
if key == 27: # ESC key to exit
cv2.destroyAllWindows()
return None
if camera_ID is not None:
cv2.destroyAllWindows()
return camera_ID

def activity(camera):
global particle_count
global particles
class button:
def __init__(self, x, y, width, height, title):
self.x = x
self.y = y
self.width = width
self.height = height
self.title = title
self.clicked = False

reset_button = button(10,10,100,40,"RESET")
quit_button = button(120,10,100,40,"QUIT")
buttons = [reset_button, quit_button]

def on_mouse_click(event, x, y, flags, param):
buttons = param
if event == cv2.EVENT_LBUTTONDOWN:
#print("mouse clicked")
# Check if click is within the reset button area
for button in buttons:
if button.x <= x <= button.x+button.width and button.y <= y <= button.y+button.width:
#print("reset clicked")
button.clicked = True
return None

def on_particle_count_change(val):
"""Callback function for particle count trackbar"""
global particle_count
particle_count = val
def update_particles(motion_objects):
"""Update particle positions and accelerate near motion objects"""
global particles

for i in range(len(particles)):
x, y, dx, dy = particles[i]
# Damp motion, more for faster particles
dx *= damping/(1+(np.abs(dx)/1000))
dy *= damping/(1+(np.abs(dy)/1000))
dy += gravity

# Check proximity to motion objects
for obj in motion_objects:
obj_x, obj_y, obj_dx, obj_dy = obj
distance = np.sqrt((x - obj_x)**2 + (y - obj_y)**2)

# If particle is near a motion object, accelerate in that direction
if distance < 100: # Proximity threshold
# Add motion vector to particle velocity
dx += obj_dx * 1/(distance+2)
dy += obj_dy * 1/(distance+2)

# Update position
x += dx
y += dy

# Bounce off edges
frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)

if x <= 0:
dx = np.abs(dx)
x=0
if x >= frame_width:
dx = -1 * np.abs(dx)
x = frame_width
if y <= 0:
dy = np.abs(dy)
y=0
if y >= frame_height:
dy = -1 * np.abs(dy)
y = frame_height

particles[i] = [x, y, dx, dy]

def generate_particles(count=particle_count):
"""Generate particles at random positions"""
global particles
nonlocal cap
particles.clear()
frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)

for _ in range(count):
x = random.randint(0, int(frame_width))
y = random.randint(0, int(frame_height))
dx = random.uniform(-1, 1) # Random initial velocity
dy = random.uniform(-1, 1)
particles.append([x, y, dx, dy])

# Initialize video capture with selected camera
try:
cap = cv2.VideoCapture(camera.index, camera.backend)
if not cap.isOpened():
pass
#print(f"camera {camera_index} not available anymore.")
except ValueError:
pass
#print(f"camera {camera_index} not available anymore. error {ValueError}")

# Create window and trackbar
activityWindowName='Motion Detection with Particles'
cv2.namedWindow(activityWindowName)
cv2.createTrackbar('Particles', activityWindowName, particle_count, 100, on_particle_count_change)

# Initialize background subtractor
backSub = cv2.createBackgroundSubtractorMOG2(history, 16, True)

# Generate initial particles
generate_particles()
cv2.setMouseCallback(activityWindowName, on_mouse_click, buttons)

while True:
ret, frame = cap.read()
if not ret:
continue

# Flip the frame horizontally
frame = cv2.flip(frame, 1)

# Get current particle count from trackbar
current_particle_count = cv2.getTrackbarPos('Particles', activityWindowName)
if current_particle_count != particle_count:
particle_count = current_particle_count
particles = deque(maxlen=particle_count)
generate_particles(particle_count)

# Check if reset button was clicked
if reset_button.clicked:
#print("reset clicked")
reset_button.clicked = False
generate_particles(particle_count)
if quit_button.clicked:
break

# Convert to grayscale and apply background subtraction
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
fgMask = backSub.apply(gray)

# Find contours in the motion mask
contours, _ = cv2.findContours(fgMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

motion_objects = [] # Reset motion objects each frame

for cnt in contours:
if cv2.contourArea(cnt) > min_area and len(motion_objects) < MAX_MOTION_OBJECTS:
# Get bounding rectangle
x, y, w, h = cv2.boundingRect(cnt)

# Calculate center of motion
center_x = x + w // 2
center_y = y + h // 2

# Calculate direction from center to motion area
frame_center_x = frame.shape[1] // 2
frame_center_y = frame.shape[0] // 2

dx = center_x - frame_center_x
dy = center_y - frame_center_y

motion_objects.append((center_x, center_y, dx, dy))
#cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
cv2.circle(frame, (center_x, center_y), 20, (255, 0, 255), -1)
starsize=20
cv2.line(frame, (center_x, center_y), (center_x+starsize, center_y+starsize), (0, 255, 0), 2)
cv2.line(frame, (center_x, center_y), (center_x-starsize, center_y+starsize), (0, 255, 0), 2)
cv2.line(frame, (center_x, center_y), (center_x+starsize, center_y-starsize), (0, 255, 0), 2)
cv2.line(frame, (center_x, center_y), (center_x-starsize, center_y-starsize), (0, 255, 0), 2)

# Update and draw particles
update_particles(motion_objects)
for particle in particles:
x, y, _, _ = particle
cv2.circle(frame, (int(x), int(y)), particle_size, particle_color, -1)
for button in buttons:
cv2.rectangle(frame, (button.x, button.y), (button.width, button.height), (255, 255, 255), -1)
cv2.putText(frame, button.title, (button.x + 10, button.y + button.height - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)

# Display the frame
cv2.imshow(activityWindowName, frame)

# Exit on 'q' key
if cv2.waitKey(30) & 0xFF == ord('q'):
break

# Release resources
cap.release()
cv2.destroyAllWindows()
return None

def main():
# Get available cameras
#cameras = get_available_cameras
cameras = enumerate_cameras()
if not cameras:
#print("No cameras found!")
return
if 0 == len(cameras):
#print("No cameras found!")
return

# Display stills and get user selection
selected_camera = display_cameras_and_get_selection(cameras)
# print(f"selected_camera:{selected_camera}")

if selected_camera is not None:
#print(f"Starting activity with selected camera: {selected_camera}")
# You can now use this camera index for further processing
camera = next((camera for camera in cameras if camera.index == selected_camera), None)

if camera:
# print(f"Found camera: {camera.index}, {camera.backend}")
pass
else:
# print("Camera not found")
pass

activity(camera)
else:
#print("No camera selected or operation cancelled")
return None

if __name__ == "__main__":
main()
</syntaxhighlight>

[[Category:Computers]]

Python ball pits - Revision history

Shawn at 04:06, 1 March 2026

Shawn: New page with code