I need an algorithm that can give me positions around a sphere for N points (less than 20, probably) that vaguely spreads them out. There's no need for "perfection", but I just need it so none of them are bunched together.
A few other question threads I came across spoke of randomized uniform distribution, which adds a level of complexity I'm not concerned about. I apologize that this is such a silly question, but I wanted to show that I've truly looked hard and still come up short.
So, what I'm looking for is simple pseudocode to evenly distribute N points around a unit sphere, that either returns in spherical or Cartesian coordinates. Even better if it can even distribute with a bit of randomization (think planets around a star, decently spread out, but with room for leeway).
In this example code
node[k] is just the kth node. You are generating an array N points and
node[k] is the kth (from 0 to N-1). If that is all that is confusing you, hopefully you can use that now.
(in other words,
k is an array of size N that is defined before the code fragment starts, and which contains a list of the points).
Alternatively, building on the other answer here (and using Python):
> cat ll.py from math import asin nx = 4; ny = 5 for x in range(nx): lon = 360 * ((x+0.5) / nx) for y in range(ny): midpt = (y+0.5) / ny lat = 180 * asin(2*((y+0.5)/ny-0.5)) print lon,lat > python2.7 ll.py 45.0 -166.91313924 45.0 -74.0730322921 45.0 0.0 45.0 74.0730322921 45.0 166.91313924 135.0 -166.91313924 135.0 -74.0730322921 135.0 0.0 135.0 74.0730322921 135.0 166.91313924 225.0 -166.91313924 225.0 -74.0730322921 225.0 0.0 225.0 74.0730322921 225.0 166.91313924 315.0 -166.91313924 315.0 -74.0730322921 315.0 0.0 315.0 74.0730322921 315.0 166.91313924
If you plot that, you'll see that the vertical spacing is larger near the poles so that each point is situated in about the same total area of space (near the poles there's less space "horizontally", so it gives more "vertically").
This isn't the same as all points having about the same distance to their neighbours (which is what I think your links are talking about), but it may be sufficient for what you want and improves on simply making a uniform lat/lon grid.
The Fibonacci sphere algorithm is great for this. It's fast and gives results that at a glance will easily fool the human eye. You can see an example done with processing which will show the result over time as points are added. Here's another great interactive example made by @gman. And here's a quick python version with a simple randomization option:
import math, random def fibonacci_sphere(samples=1,randomize=True): rnd = 1. if randomize: rnd = random.random() * samples points =  offset = 2./samples increment = math.pi * (3. - math.sqrt(5.)); for i in range(samples): y = ((i * offset) - 1) + (offset / 2); r = math.sqrt(1 - pow(y,2)) phi = ((i + rnd) % samples) * increment x = math.cos(phi) * r z = math.sin(phi) * r points.append([x,y,z]) return points
1000 samples gives you this: