Smooth Curves for Light-Painting Drones

Picture your quadcopter wobbling through the night sky, LED strip blazing, trying to write elegant cursive letters for a long-exposure photograph. The problem isn’t your piloting—it’s mathematics. RC control signals are discrete, digital steps. Your camera, however, captures every stuttered movement as jagged light trails that look more like seismograph readings than flowing calligraphy.

The solution lies in Bezier curves, the mathematical foundation that transforms choppy waypoints into silk-smooth paths. Named after Pierre Bézier, who developed them at Renault in the 1960s for car body design, these curves use control points to define graceful arcs between any two coordinates.

# R: Calculate quadratic Bezier curve
bezier_point <- function(t, p0, p1, p2) {
  (1-t)^2 * p0 + 2*(1-t)*t * p1 + t^2 * p2
}

# Generate smooth path for letter 'S'
t_values <- seq(0, 1, length.out=50)
x_coords <- bezier_point(t_values, 0, 5, 10)
y_coords <- bezier_point(t_values, 0, 8, 0)
plot(x_coords, y_coords, type='l', lwd=3)

program LightCalligraphy;
type Point = record x, y: real; end;

function BezierPoint(t: real; p0, p1, p2: Point): Point;
begin
  BezierPoint.x := (1-t)*(1-t)*p0.x + 2*(1-t)*t*p1.x + t*t*p2.x;
  BezierPoint.y := (1-t)*(1-t)*p0.y + 2*(1-t)*t*p1.y + t*t*p2.y;
end;

var i: integer; t: real; current, p0, p1, p2: Point;
begin
  p0.x := 0; p0.y := 0;
  p1.x := 5; p1.y := 8;
  p2.x := 10; p2.y := 0;
  for i := 0 to 49 do begin
    t := i / 49.0;
    current := BezierPoint(t, p0, p1, p2);
    writeln('Move to: ', current.x:6:2, ', ', current.y:6:2);
  end;
end.

While R’s vectorized operations make curve generation effortless, Pascal’s explicit loop structure reveals the sequential nature of flight path execution. Both approaches transform three simple control points into fifty smooth coordinates—enough waypoints to guide your drone through flowing letterforms that would make any calligrapher proud. The mathematics does what your thumbsticks cannot: create continuous beauty from discrete commands.