Fibonacci Sphere
11–20 of 37 posts
Re: Fibonacci Sphere
#12One neat trick I’ve learned is that you can use the points on a Fibonacci sphere to optimally compress unit vectors, for things like normal textures. For example, if you have an array of 1024 points representing a Fibonacci sphere, you can compress unit vectors into lg(1024)=10 bits with a nearest neighbor search and decompress with an O(1) table lookup. In fact, the general strategy works for higher dimensions as we…
Re: Fibonacci Sphere
#13Earlier quoted context omitted.
This link - http://neilsloane.com/packings/index.html#I - has dead URLs. Like this - http://www.teleport.com/~tpgettys/dodeca.gif . I specifically wanted to check where the dodecahedron comes short. Good article, but it'll take some time to understand it. %1 is interesting, I used to use {..} for taking fractional part, %1 is intuitively easy, though not looking particularly good...
yeah. I think his website is extremely old and hasn’t been updated in the last decade or so. Despite this I linked to it because he is a legend in this field and so i think this is still the definitive reference. As far as i understand, part of the story as to why dodecahedron and the cube fall short is due their non-triangular faces.
Re: Fibonacci Sphere
#14Earlier quoted context omitted.
yeah. I think his website is extremely old and hasn’t been updated in the last decade or so. Despite this I linked to it because he is a legend in this field and so i think this is still the definitive reference. As far as i understand, part of the story as to why dodecahedron and the cube fall short is due their non-triangular faces.
Did the article switch the dodecahedron and icosahedron? It specified that the icosahedron is optimal for 12 points and the dodecahedron for 20 which seems backwards to me.
Icosahedron: 12 points, 20 faces (and 30 edges)
Dodecahedron: 20 points, 12 faces (and 30 edges)
Re: Fibonacci Sphere
#15One neat trick I’ve learned is that you can use the points on a Fibonacci sphere to optimally compress unit vectors, for things like normal textures. For example, if you have an array of 1024 points representing a Fibonacci sphere, you can compress unit vectors into lg(1024)=10 bits with a nearest neighbor search and decompress with an O(1) table lookup. In fact, the general strategy works for higher dimensions as we…
Re: Fibonacci Sphere
#16Author here. Happy to try to answer any questions! ;)
I've had Nash's infinitely collapsible sphere stuck in my head for some time: https://www.quantamagazine.org/mathematicians-identify-thres...
For purposes of nearest neighbors this seems like an incredibly interesting shape to inscribe into: The sphere, despite having spherical properties also maintains linear properties due to the corrugation. To me that means we can try to inscribe orthogonal properties into both of the spaces.
My understanding of these geometries isn't complex enough to make the connections, so my question is this: Do you think its feasible to use shapes with this 'corrugated' property to make better nearest neighbor compression? My intuition tells me that you can use the shape's linear nature to push apart independent components and inscribe the rest of the details into the spherical components. Or perhaps the opposite way.
Hopefully that made sense!
Re: Fibonacci Sphere
#17One neat trick I’ve learned is that you can use the points on a Fibonacci sphere to optimally compress unit vectors, for things like normal textures. For example, if you have an array of 1024 points representing a Fibonacci sphere, you can compress unit vectors into lg(1024)=10 bits with a nearest neighbor search and decompress with an O(1) table lookup. In fact, the general strategy works for higher dimensions as we…
I would expect the energy minimization approach to perform better than anything else, for vectors distributed uniformly on the surface of the N-sphere. Why go with the Fibonacci sphere instead?
def fibonacci_sphere_point(idx, num_points):
i = idx + 0.5
phi = math.acos(1 - 2 * i / num_points)
golden_ratio = (1 + 5 ** 0.5) / 2
theta = 2 * math.pi * i / golden_ratio
sin_phi = math.sin(phi)
cos_phi = math.cos(phi)
sin_theta = math.sin(theta)
cos_theta = math.cos(theta)
return (
cos_theta * sin_phi,
sin_theta * sin_phi,
cos_phi,
)
If you're willing to forgo using a spatial acceleration structure and instead do an O(n) scan for encoding, then you can get O(1) space complexity.Re: Fibonacci Sphere
#18One neat trick I’ve learned is that you can use the points on a Fibonacci sphere to optimally compress unit vectors, for things like normal textures. For example, if you have an array of 1024 points representing a Fibonacci sphere, you can compress unit vectors into lg(1024)=10 bits with a nearest neighbor search and decompress with an O(1) table lookup. In fact, the general strategy works for higher dimensions as we…
I would expect the energy minimization approach to perform better than anything else, for vectors distributed uniformly on the surface of the N-sphere. Why go with the Fibonacci sphere instead?
As I describe in the article, different methods produce similar but slightly different solutions. An optimal solution for one objective function, may not be the optimal for a different objective function. I then give details about how the solution that optimizes volume of the convex hull is different to the solution that optimizes for packing distance, etc.
Re: Fibonacci Sphere
#19Earlier quoted context omitted.
Did the article switch the dodecahedron and icosahedron? It specified that the icosahedron is optimal for 12 points and the dodecahedron for 20 which seems backwards to me.
I believe it is right. However, I often get these two intuitively mixed up because: Icosahedron: 12 points, 20 faces (and 30 edges) Dodecahedron: 20 points, 12 faces (and 30 edges)
Re: Fibonacci Sphere
#20One neat trick I’ve learned is that you can use the points on a Fibonacci sphere to optimally compress unit vectors, for things like normal textures. For example, if you have an array of 1024 points representing a Fibonacci sphere, you can compress unit vectors into lg(1024)=10 bits with a nearest neighbor search and decompress with an O(1) table lookup. In fact, the general strategy works for higher dimensions as we…
What you're saying sounds promising but I have no idea how to implement it - any articles about it that contain algorithms?