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) (let ((r-squared (* radius 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
r^{2}-x^{2}. 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?

## No comments:

Post a Comment