## Monday, September 5, 2022

### Drawing a circle

SDL is your bare bones graphics interface. It gives you primitives like `draw-point`, `draw-line`, and `draw-rectangle`, but you're on your own if you want to draw a circle. Naturally, I cribbed the code from stackoverflow.

Small circles didn't look right — they were a little squarish. The code worked by walking along pixels in one direction and accumulating an error term. When the error term got large enough, it would be reset and the code would advance a step along the other pixel axis. The error term was computed using integer math so that the circle was drawn quickly. The problem is that the integer math has rounding error and the rounding error is noticable with small circles.

For reference, it is straightforward to draw an exact circle. A circle isn't a function, but circle segment between 0 and 45 degrees is a function. If we mirror that segment eight ways horizontally, vertically, and at 90 degrees, we'll get a full circle.

```(defun eightfold-point (renderer center-x center-y x y)
(sdl2:render-draw-point renderer (+ center-x x) (+ center-y y))
(sdl2:render-draw-point renderer (+ center-x x) (- center-y y))
(sdl2:render-draw-point renderer (- center-x x) (+ center-y y))
(sdl2:render-draw-point renderer (- center-x x) (- center-y y))

(sdl2:render-draw-point renderer (+ center-x y) (- center-y x))
(sdl2:render-draw-point renderer (+ center-x y) (+ center-y x))
(sdl2:render-draw-point renderer (- center-x y) (- center-y x))
(sdl2:render-draw-point renderer (- center-x y) (+ center-y x)))

(defun draw-circle (renderer center-x center-y radius)
(dotimes (x (1+ (ceiling (/ radius (sqrt 2)))))
(eightfold-point renderer
center-x center-y
x (round (sqrt (- r-squared (* x x))))))))```
This gives much rounder looking circles than the code I cribbed from stackoverflow.

The problem, of course, is that this code computes a square root on each iteration. These days, computers are fast and that's not a big issue, but let's try to improve things.

On each iteration, we are computing the square root of r2-x2. This quantity changes between iterations, but not by much. You can compute a square root pretty quickly using Newton's method. The square root computed last iteration isn't that far from the new square root, so we can use the previous square root as the initial guess for Newton's method. Since we started pretty close to the right answer, we only need a single pass of Newton's method to get close enough to the square root for the current iteration.

```(defun average (a b) (/ (+ a b) 2))

(defun draw-circle1 (renderer center-x center-y radius)
(let ((x-limit (ceiling (/ radius (sqrt 2)))))
(do ((x 0 (1+ x))
(o 1 (+ o 2))
(r2-x2 (* radius radius) (- r2-x2 o))
(y radius (round (average y (/ (- r2-x2 o) y)))))
((> x x-limit))
(eightfold-point renderer center-x center-y x y))))```

This gives us pretty round circles — rounder than the integer methods, but not as round as the sqrt method. It requires less arithmetic than the sqrt method, but more than the integer method. What is more annoying, squarish circles or the amount of time it takes to draw round ones?