Introduction

If you place points on a spiral by stepping a fixed angle each time, the points will not be equally spaced along the curve. The angle step has to change as the spiral radius changes. For an Archimedean spiral, a practical solution is to step forward by arc length: at each point, estimate how much the angle must increase so the next point lands one chosen distance farther along the curve.

Use an Archimedean Spiral Model

A common spiral for drawing is the Archimedean spiral:

• 'r = a + b * theta'

Converted to Cartesian coordinates:

• 'x = r * cos(theta)'
• 'y = r * sin(theta)'

Here, a controls the starting radius and b controls how quickly the spiral expands.

Why Equal Angle Steps Do Not Work

The curve gets longer per unit of angle as the radius grows. So a constant angular increment creates points that spread farther apart as you move outward.

To keep the spacing approximately constant, step by distance along the curve instead of by raw angle.

Arc-Length-Based Step Formula

For the Archimedean spiral r = a + b * theta, the local arc-length factor is:

• 'sqrt((a + b * theta)^2 + b^2)'

If you want the next point to be about spacing units away, use this approximation:

• 'delta_theta = spacing / sqrt((a + b * theta)^2 + b^2)'

Then update theta repeatedly.

Runnable Python Example

The following script generates approximately equidistant points on the spiral.

1import math
2
3
4def spiral_points(a, b, spacing, count):
5    theta = 0.0
6    points = []
7
8    for _ in range(count):
9        r = a + b * theta
10        x = r * math.cos(theta)
11        y = r * math.sin(theta)
12        points.append((x, y))
13
14        step = spacing / math.sqrt(r * r + b * b)
15        theta += step
16
17    return points
18
19
20pts = spiral_points(a=0.0, b=0.5, spacing=1.0, count=10)
21for p in pts:
22    print(p)

This produces points with much more even spacing than a constant-angle approach.

Plot the Result

To visualize the points, plot them with Matplotlib.

1import math
2import matplotlib.pyplot as plt
3
4points = spiral_points(a=0.0, b=0.5, spacing=1.0, count=200)
5xs = [p[0] for p in points]
6ys = [p[1] for p in points]
7
8plt.figure(figsize=(6, 6))
9plt.plot(xs, ys, linewidth=0.7)
10plt.scatter(xs, ys, s=10)
11plt.axis("equal")
12plt.show()

The points will still be approximate because the step formula is local, not an exact inverse of the spiral’s cumulative arc-length function. For drawing and visualization, though, it is usually good enough.

When You Need Higher Accuracy

If the spacing must be extremely precise, solve for the next theta numerically using the exact arc-length function instead of the local approximation. That is more computation, but it gives tighter control when the geometry matters more than drawing speed.

For most graphics tasks, the iterative approximation is the better tradeoff because it is simple and stable.

Common Pitfalls

• Using a fixed angle increment and expecting equal distances along the curve.
• Forgetting that “equidistant” means equal arc length, not equal radius or equal angle.
• Mixing up the spiral parameters and getting the wrong growth rate.
• Expecting the local approximation to be mathematically exact over large steps.
• Plotting without an equal aspect ratio and misjudging the spacing visually.

Summary

• Equal spacing on a spiral is an arc-length problem, not an angle problem.
• For an Archimedean spiral, a changing delta_theta gives much better spacing than a constant angle.
• A practical approximation is spacing / sqrt(r^2 + b^2).
• The iterative method is simple and works well for drawing.
• Use a numerical arc-length solve only when you need higher precision than the approximation provides.