Scripting solution.
The parametric equations and code can be found here http://blog.marmakoide.org/?p=1
Used the points generated to create a point cloud mesh with vert normals pointing out, and a dupli vert object to display.
I couldn't work out the vert order to skin this properly, it appears to follow a fibonacci like sequence with the vert order.
Here a 512 point with a cone and plane dupli, and a 32 pointer with a cube dupli.
import numpy
n = 512
golden_angle = numpy.pi * (3 - numpy.sqrt(5))
theta = golden_angle * numpy.arange(n)
z = numpy.linspace(1 - 1.0 / n, 1.0 / n - 1, n)
#z = numpy.zeros(n)
radius = numpy.sqrt(1 - z * z)
points = numpy.zeros((n, 3))
points[:,0] = radius * numpy.cos(theta)
points[:,1] = radius * numpy.sin(theta)
points[:,2] = z
import bpy
import bmesh
from math import radians
context = bpy.context
scene = context.scene
bm = bmesh.new()
meshdata = bpy.data.meshes.new("goldie")
verts = [bm.verts.new(p) for p in points]
"make vert normals point out"
for v in verts:
v.normal = -v.co.normalized()
#bmesh.ops.convex_hull(bm, input=verts)
bm.to_mesh(meshdata)
goldie = bpy.data.objects.new("goldie", meshdata)
scene.objects.link(goldie)
scene.objects.active = goldie
goldie.select = True
#make a dupe
bpy.ops.mesh.primitive_cone_add(location=(0,0,0))
plane = scene.objects.active
#plane.hide = True
plane.scale *= 32 / n
plane.rotation_euler = (radians(90), 0, 0)
bpy.ops.object.transform_apply(scale=True, rotation=True)
plane.parent = goldie
goldie.dupli_type = 'VERTS'
goldie.use_dupli_vertices_rotation = True
From a previous Loxodrome post
The vert order makes it easier to skin. Change values for spirals, revs and ang to create differing meshes.
Skinned loxodromes using varying parameters.
import bpy
from mathutils import Vector
from math import radians, sin, cos, tan, sqrt, floor
context = bpy.context
def loxodrome_points(spirals, revs, angle_step=10):
a = 1 / spirals
degs = floor(360 * revs / 2)
segs = [radians(d) for d in range(-degs, degs, angle_step)]
points = []
for t in segs:
den = sqrt(1 + a * a * t * t)
x = cos(t) / den
y = sin(t) / den
z = - a * t / den
l = Vector((x, y, z))
points.append(l)
return points
ang = 20
spirals = 16
revs = 100
points = loxodrome_points(spirals, revs, angle_step=ang)
# quick n dirty
lazy = 360 // ang
import bmesh
bm = bmesh.new()
loxodata = bpy.data.meshes.new("loxo")
verts = [bm.verts.new(p) for p in points]
faces = [[i, i+1, i+lazy, i+lazy-1] for i in range(len(points)-lazy-1)]
for f in faces:
bm.faces.new([verts[i] for i in f])
bm.to_mesh(loxodata)
loxodrome = bpy.data.objects.new("Loxodrome", loxodata)
context.scene.objects.link(loxodrome)