Draw equidistant points on a spiral

by

To a first approximation – which is probably good enough for plotting blocks close enough – the spiral is a circle and increment the angle by the ratio chord / radius.

// value of theta corresponding to end of last coil
final double thetaMax = coils * 2 * Math.PI;

// How far to step away from center for each side.
final double awayStep = radius / thetaMax;

// distance between points to plot
final double chord = 10;

DoSome ( centerX, centerY );

// For every side, step around and away from center.
// start at the angle corresponding to a distance of chord
// away from centre.
for ( double theta = chord / awayStep; theta <= thetaMax; ) {
    //
    // How far away from center
    double away = awayStep * theta;
    //
    // How far around the center.
    double around = theta + rotation;
    //
    // Convert 'around' and 'away' to X and Y.
    double x = centerX + Math.cos ( around ) * away;
    double y = centerY + Math.sin ( around ) * away;
    //
    // Now that you know it, do it.
    DoSome ( x, y );

    // to a first approximation, the points are on a circle
    // so the angle between them is chord/radius
    theta += chord / away;
}

10 coil spiral

However, for a looser spiral you will have to solve the path distance more accurately as spaces too wide where the difference between away for successive points is significant compared with chord:
1 coil spiral 1st approximation 1 coil spiral 2nd approximation

The second version above uses a step based on solving for delta based on using the average radius for theta and theta+delta:

// take theta2 = theta + delta and use average value of away
// away2 = away + awayStep * delta 
// delta = 2 * chord / ( away + away2 )
// delta = 2 * chord / ( 2*away + awayStep * delta )
// ( 2*away + awayStep * delta ) * delta = 2 * chord 
// awayStep * delta ** 2 + 2*away * delta - 2 * chord = 0
// plug into quadratic formula
// a= awayStep; b = 2*away; c = -2*chord

double delta = ( -2 * away + Math.sqrt ( 4 * away * away + 8 * awayStep * chord ) ) / ( 2 * awayStep );

theta += delta;

For even better results on a loose spiral, use a numeric iterative solution to find the value of delta where the calculated distance is within a suitable tolerance.

More Related Contents:

  1. Looping in a spiral
  2. Sign of a symbolic algebraic expression
  3. Algorithm to find Largest prime factor of a number
  4. How to make rounded percentages add up to 100%
  5. Write a function that returns the longest palindrome in a given string
  6. How do I efficiently determine if a polygon is convex, non-convex or complex?
  7. Cycles in an Undirected Graph
  8. Efficiently find binary strings with low Hamming distance in large set
  9. Roulette wheel selection algorithm [duplicate]
  10. “On-line” (iterator) algorithms for estimating statistical median, mode, skewness, kurtosis?
  11. Calculating mid in binary search
  12. Geo Fencing – point inside/outside polygon
  13. Find the missing and duplicate elements in an array in linear time and constant space
  14. Best Compression algorithm for a sequence of integers
  15. Smoothing data from a sensor
  16. A simple explanation of Naive Bayes Classification [closed]
  17. Basic Recursion, Check Balanced Parenthesis
  18. Euler project #18 approach
  19. Fastest available algorithm for distance transform
  20. What algorithm for a tic-tac-toe game can I use to determine the “best move” for the AI?
  21. Generating integers in ascending order using a set of prime numbers
  22. Big O when adding together different routines
  23. Finding height in Binary Search Tree
  24. How to understand the dynamic programming solution in linear partitioning?
  25. Clustering Algorithm for Mapping Application
  26. What are the pitfalls in implementing binary search? [closed]
  27. Can a Fibonacci function be written to execute in O(1) time?
  28. Finding rectangles in a 2d block grid
  29. Check if array B is a permutation of A
  30. Algorithm to list all unique permutations of numbers contain duplicates

Leave a Comment