Stroke Bot

Inspiration

We’ve always felt that there’s something cold about robotics. So much of the field is focused on making machines faster, stronger, and more capable, but we wanted to make something simply for the experience of creating.

What it does

Stroke Bot acts as a cognitive agent, bridging digital intent and physical execution. Depending on the input prompt, transcript, or image, it processes what it "sees" and transcribes that visual data into a physical portrait or sketch. It externalizes algorithmic thought into tangible lines, merging precise kinematics with creative expression.

How we built it

We built the system as a pipeline with three main stages:

Turning Images Into Drawing Paths

We converted black-and-white line art into executable, vectorized stroke paths, using OpenCV, to drive precise robotic movement.

Our initial approach used Potrace to generate SVG vector outlines. However, this caused the robot to trace both sides of thick lines, resulting in redundant dual-pass drawing. To resolve this, we switched to skeletonization via OpenCV’s cv2.ximgproc.thinning. This reduced filled regions and thick strokes into 1-pixel-wide centerlines, providing a one-way trajectory for the robot to follow.

We then extracted the paths, resampled them for consistent point density, normalized them into ordered lists of (x,y) coordinates, and exported them as a JSON file ready for path planning and motion execution.

This also gave us a clean separation between the vision pipeline and the robotics system.

Converting Paths Into Robot Motion

The challenge was translating the normalized stroke paths into executable joint trajectories.

Using the robot's URDF model to establish forward kinematics, we used SciPy's L-BFGS-B optimizer to find joint angles that bring the end effector to each target point with minimized error, while respecting the robot's physical limits.

To ensure smooth and collision-safe execution, we solved the IK sequentially along each path, using the joint configuration of the current waypoint as the initial guess for the next. This allowed the arm to move continuously instead of constantly finding completely different configurations, enforcing joint-space continuity and preventing sudden, dramatic configuration jumps.

From Simulation to Physical Hardware

We translated calculated coordinates into physical motor commands. To solve this, we built a hardware translation layer between our IK system and the robot's Feetech serial-bus servos.

This layer handles kinematic transformation and communication, including:

Converting Cartesian target points (meters) and joint angles (radians) into raw motor tick counts and rotational angles.
Factoring in gear reduction ratios and motor directions
Translating the vertical lift into wheel rotations
Publishing motor targets through the robot's bbos communication system

Challenges we ran into

Simplification of photo issues, not working with a physical robot, Pipeline Architecture
The biggest issue we had was with setting up the program on the physical robot.
Folder location mismatches
And the difficulty of physically implementing vs. the software idealization (the end-effector in the simulation was the arm, whereas there is additional length with the pen). Consistency and tilt when drawing

Accomplishments that we're proud of

First time successfully running a robotics simulation
Create a custom solution to translate line art images into robotic arm trajectory
First time running out of tokens twice in 10 hrs

What we learned

The overall workflow for taking input data and turning it into physical robot motion
Using cost functions and SciPy optimization to solve inverse kinematics for a 7-DOF arm
Setting up, modifying, and working within the ReRun simulation environment
Image-processing and preprocessing techniques for converting images into usable drawing paths

What's next for Stroke Bot

Interactive Frontend & Real-Time Response: Developing a frontend interface that accepts user prompts and real-time feedback, enabling interaction and adaptive stroke adjustments.
Agent-assisted Execution: Exploring code-generation agents to translate high-level intent or natural language into executable control scripts.
Physical testing and optimization