Evenly distributing n points on a sphere

Question

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    This question provided good code  but I couldn t find a way to make this uniform  as this seemed 100  randomized  This blog post recommended had two ways allowing input of number of points on the sphere  but the Saff and Kuijlaars algorithm is exactly in psuedocode I could transcribe  and the code example I found contained  node k    which I couldn t see explained and ruined that possibility  The second blog example was the Golden Section Spiral  which gave me strange  bunched up results  with no clear way to define a constant radius  This algorithm from this question seems like it could possibly work  but I can t piece together what s on that page into psuedocode or anything    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

User · Answer

OR    to place 20 points  compute the centers of the icosahedronal faces  For 12 points  find the vertices of the icosahedron  For 30 points  the mid point of the edges of the icosahedron  you can do the same thing with the tetrahedron  cube  dodecahedron and octahedrons  one set of points is on the vertices  another on the center of the face and another on the center of the edges  They cannot be mixed  however

User · Answer

create uniform spiral grid numOfPoints   varargin 0  vxyz   zeros  numOfPoints 3  dtype float  sq0   0 00033333333  2 sq2   0 9999998  2 sumsq   2 sq0   sq2 vxyz numOfPoints -1    array   sqrt sq0 sumsq                                    sqrt sq0 sumsq                                    -sqrt sq2 sumsq     vxyz 0    -vxyz numOfPoints -1   phi2   sqrt 5  0 5   2 5 rootCnt   sqrt numOfPoints  prevLongitude   0 for index in arange 1   numOfPoints -1   1  dtype float     zInc    2 index   numOfPoints  -1   radius   sqrt 1-zInc  2     longitude   phi2  rootCnt radius    longitude   longitude   prevLongitude   while  longitude  gt  2 pi        longitude   longitude - 2 pi    prevLongitude   longitude   if  longitude  gt  pi       longitude   longitude - 2 pi    latitude   arccos zInc  - pi 2   vxyz index    array    cos latitude    cos longitude                              cos latitude    sin longitude                             sin latitude

User · Answer

This works and it s deadly simple  As many points as you want       private function moveTweets   void             var newScale Number Scale meshes length 50 500 6 2           trace  new scale   newScale             var l Number this meshes length          var tweetMeshInstance TweetMesh          var destx Number          var desty Number          var destz Number          for  var i Number 0 i lt this meshes length i                  tweetMeshInstance meshes i                var phi Number   Math acos  -1     2   i     l                var theta Number   Math sqrt  l   Math PI     phi               tweetMeshInstance origX    sphereRadius 5    Math cos  theta     Math sin  phi                tweetMeshInstance origY   sphereRadius 5    Math sin  theta     Math sin  phi                tweetMeshInstance origZ    sphereRadius 5    Math cos  phi                 destx sphereRadius   Math cos  theta     Math sin  phi                desty sphereRadius   Math sin  theta     Math sin  phi                destz sphereRadius   Math cos  phi                 tweetMeshInstance lookAt new Vector3D                   TweenMax to tweetMeshInstance  1   scaleX newScale scaleY newScale x destx y desty z destz onUpdate onLookAtTween  onUpdateParams  tweetMeshInstance                           private function onLookAtTween theMesh TweetMesh  void           theMesh lookAt new Vector3D

User · Answer

This is known as packing points on a sphere  and there is no  known  general  perfect solution   However  there are plenty of imperfect solutions   The three most popular seem to be    Create a simulation   Treat each point as an electron constrained to a sphere  then run a simulation for a certain number of steps   The electrons  repulsion will naturally tend the system to a more stable state  where the points are about as far away from each other as they can get  Hypercube rejection   This fancy-sounding method is actually really simple   you uniformly choose points  much more than n of them  inside of the cube surrounding the sphere  then reject the points outside of the sphere   Treat the remaining points as vectors  and normalize them   These are your  samples  - choose n of them using some method  randomly  greedy  etc   Spiral approximations   You trace a spiral around a sphere  and evenly-distribute the points around the spiral   Because of the mathematics involved  these are more complicated to understand than the simulation  but much faster  and probably involving less code    The most popular seems to be by Saff  et al    A lot more information about this problem can be found here

User · Answer

Based on fnord s answer  here is a Unity3D version with added ranges   Code      golden angle in radians static float Phi   Mathf PI     3f - Mathf Sqrt  5f      static float Pi2   Mathf PI   2   public static Vector3 Point  float radius   int index   int total   float min   0f  float max   1f   float angleStartDeg   0f  float angleRangeDeg   360            y goes from min  -  to max         var y       index     total - 1f         max - min     min     2f - 1f          golden angle increment     var theta   Phi   index                 if  angleStartDeg    0    angleRangeDeg    360                 theta     theta     Pi2               theta   theta  lt  0   theta   Pi2   theta                        var a1   angleStartDeg   Mathf Deg2Rad          var a2   angleRangeDeg   Mathf Deg2Rad                       theta   theta   a2   Pi2   a1                https   stackoverflow com a 26127012 2496170             radius at y     var rY   Mathf Sqrt  1 - y   y              var x   Mathf Cos  theta     rY      var z   Mathf Sin  theta     rY       return  new Vector3  x  y  z     radius     Gist   https   gist github com nukadelic 7449f0872f708065bc1afeb19df666f7 edit Preview

User · Answer

Healpix solves a closely related problem  pixelating the sphere with equal area pixels    http   healpix sourceforge net   It s probably overkill  but maybe after looking at it you ll realize some of it s other nice properties are interesting to you  It s way more than just a function that outputs a point cloud   I landed here trying to find it again  the name  healpix  doesn t exactly evoke spheres

User · Answer

The Fibonacci sphere algorithm is great for this  It is 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 simple implementation in python   import math   def fibonacci sphere samples 1        points          phi   math pi    3  - math sqrt 5       golden angle in radians      for i in range samples           y   1 -  i   float samples - 1     2    y goes from 1 to -1         radius   math sqrt 1 - y   y     radius at y          theta   phi   i    golden angle increment          x   math cos theta    radius         z   math sin theta    radius          points append  x  y  z        return points   1000 samples gives you this

User · Answer

The golden spiral method You said you couldn   t get the golden spiral method to work and that   s a shame because it   s really  really good  I would like to give you a complete understanding of it so that maybe you can understand how to keep this away from being    bunched up     So here   s a fast  non-random way to create a lattice that is approximately correct  as discussed above  no lattice will be perfect  but this may be good enough  It is compared to other methods e g  at BendWavy org but it just has a nice and pretty look as well as a guarantee about even spacing in the limit  Primer  sunflower spirals on the unit disk To understand this algorithm  I first invite you to look at the 2D sunflower spiral algorithm  This is based on the fact that the most irrational number is the golden ratio  1   sqrt 5   2 and if one emits points by the approach    stand at the center  turn a golden ratio of whole turns  then emit another point in that direction     one naturally constructs a spiral which  as you get to higher and higher numbers of points  nevertheless refuses to have well-defined    bars    that the points line up on  Note 1   The algorithm for even spacing on a disk is   from numpy import pi  cos  sin  sqrt  arange import matplotlib pyplot as pp  num pts   100 indices   arange 0  num pts  dtype float    0 5  r   sqrt indices num pts  theta   pi    1   5  0 5    indices  pp scatter r cos theta   r sin theta   pp show    and it produces results that look like  n 100 and n 1000    Spacing the points radially The key strange thing is the formula r   sqrt indices   num pts   how did I come to that one   Note 2   Well  I am using the square root here because I want these to have even-area spacing around the disk  That is the same as saying that in the limit of large N I want a little region R    r  r   dr   T           d   to contain a number of points proportional to its area  which is r dr d   Now if we pretend that we are talking about a random variable here  this has a straightforward interpretation as saying that the joint probability density for  R  T  is just c r for some constant c  Normalization on the unit disk would then force c   1 p  Now let me introduce a trick  It comes from probability theory where it   s known as sampling the inverse CDF  suppose you wanted to generate a random variable with a probability density f z  and you have a random variable U   Uniform 0  1   just like comes out of random   in most programming languages  How do you do this   First  turn your density into a cumulative distribution function or CDF  which we will call F z   A CDF  remember  increases monotonically from 0 to 1 with derivative f z   Then calculate the CDF   s inverse function F-1 z   You will find that Z   F-1 U  is distributed according to the target density   Note 3    Now the golden-ratio spiral trick spaces the points out in a nicely even pattern for   so let   s integrate that out  for the unit disk we are left with F r    r2  So the inverse function is F-1 u    u1 2  and therefore we would generate random points on the disk in polar coordinates with r   sqrt random     theta   2   pi   random    Now instead of randomly sampling this inverse function we   re uniformly sampling it  and the nice thing about uniform sampling is that our results about how points are spread out in the limit of large N will behave as if we had randomly sampled it  This combination is the trick  Instead of random   we use  arange 0  num pts  dtype float    0 5  num pts  so that  say  if we want to sample 10 points they are r   0 05  0 15  0 25      0 95  We uniformly sample r to get equal-area spacing  and we use the sunflower increment to avoid awful    bars    of points in the output  Now doing the sunflower on a sphere The changes that we need to make to dot the sphere with points merely involve switching out the polar coordinates for spherical coordinates  The radial coordinate of course doesn t enter into this because we re on a unit sphere  To keep things a little more consistent here  even though I was trained as a physicist I ll use mathematicians  coordinates where 0   f   p is latitude coming down from the pole and 0       2p is longitude  So the difference from above is that we are basically replacing the variable r with f  Our area element  which was r dr d   now becomes the not-much-more-complicated sin f  df d   So our joint density for uniform spacing is sin f  4p  Integrating out    we find f f    sin f  2  thus F f     1 - cos f   2  Inverting this we can see that a uniform random variable would look like acos 1 - 2 u   but we sample uniformly instead of randomly  so we instead use fk   acos 1 - 2  k   0 5  N   And the rest of the algorithm is just projecting this onto the x  y  and z coordinates  from numpy import pi  cos  sin  arccos  arange import mpl toolkits mplot3d import matplotlib pyplot as pp  num pts   1000 indices   arange 0  num pts  dtype float    0 5  phi   arccos 1 - 2 indices num pts  theta   pi    1   5  0 5    indices  x  y  z   cos theta    sin phi   sin theta    sin phi   cos phi    pp figure   add subplot 111  projection  3d   scatter x  y  z   pp show    Again for n 100 and n 1000 the results look like    Further research I wanted to give a shout out to Martin Roberts   s blog  Note that above I created an offset of my indices by adding 0 5 to each index  This was just visually appealing to me  but it turns out that the choice of offset matters a lot and is not constant over the interval and can mean getting as much as 8  better accuracy in packing if chosen correctly  There should also be a way to get his R2 sequence to cover a sphere and it would be interesting to see if this also produced a nice even covering  perhaps as-is but perhaps needing to be  say  taken from only a half of the unit square cut diagonally or so and stretched around to get a circle  Notes  Those    bars    are formed by rational approximations to a number  and the best rational approximations to a number come from its continued fraction expression  z   1  n 1   1  n 2   1  n 3          where z is an integer and n 1  n 2  n 3      is either a finite or infinite sequence of positive integers  def continued fraction r       while r    0          n   floor r          yield n         r   1  r - n   Since the fraction part 1       is always between zero and one  a large integer in the continued fraction allows for a particularly good rational approximation     one divided by something between 100 and 101    is better than    one divided by something between 1 and 2     The most irrational number is therefore the one which is 1   1  1   1  1         and has no particularly good rational approximations  one can solve f   1   1 f by multiplying through by f to get the formula for the golden ratio   For folks who are not so familiar with NumPy -- all of the functions are    vectorized     so that sqrt array  is the same as what other languages might write map sqrt  array   So this is a component-by-component sqrt application  The same also holds for division by a scalar or addition with scalars -- those apply to all components in parallel   The proof is simple once you know that this is the result  If you ask what s the probability that z  lt  Z  lt  z   dz  this is the same as asking what s the probability that z  lt  F-1 U   lt  z   dz  apply F to all three expressions noting that it is a monotonically increasing function  hence F z   lt  U  lt  F z   dz   expand the right hand side out to find F z    f z  dz  and since U is uniform this probability is just f z  dz as promised

User · Answer

What you are looking for is called a spherical covering  The spherical covering problem is very hard and solutions are unknown except for small numbers of points  One thing that is known for sure is that given n points on a sphere  there always exist two points of distance d    4-csc 2  pi n 6 n-2     1 2  or closer   If you want a probabilistic method for generating points uniformly distributed on a sphere  it s easy  generate points in space uniformly by Gaussian distribution  it s built into Java  not hard to find the code for other languages   So in 3-dimensional space  you need something like   Random r   new Random    double   p     r nextGaussian    r nextGaussian    r nextGaussian        Then project the point onto the sphere by normalizing its distance from the origin   double norm   Math sqrt   p 0   2    p 1   2    p 2   2     double   sphereRandomPoint     p 0  norm  p 1  norm  p 2  norm      The Gaussian distribution in n dimensions is spherically symmetric so the projection onto the sphere is uniform   Of course  there s no guarantee that the distance between any two points in a collection of uniformly generated points will be bounded below  so you can use rejection to enforce any such conditions that you might have  probably it s best to generate the whole collection and then reject the whole collection if necessary   Or use  early rejection  to reject the whole collection you ve generated so far  just don t keep some points and drop others   You can use the formula for d given above  minus some slack  to determine the min distance between points below which you will reject a set of points  You ll have to calculate n choose 2 distances  and the probability of rejection will depend on the slack  it s hard to say how  so run a simulation to get a feel for the relevant statistics

User · Answer

Take the two largest factors of your N  if N  20 then the two largest factors are  5 4   or  more generally  a b    Calculate   dlat    180  a 1  dlong   360  b 1     Put your first point at  90-dlat 2  dlong 2 -180   your second at  90-dlat 2  3 dlong 2 -180   your 3rd at  90-dlat 2  5 dlong 2 -180   until you ve tripped round the world once  by which time you ve got to about  75 150  when you go next to  90-3 dlat 2  dlong 2 -180    Obviously I m working this in degrees on the surface of the spherical earth  with the usual conventions for translating   - to N S or E W   And obviously this gives you a completely non-random distribution  but it is uniform and the points are not bunched together   To add some degree of randomness  you could generate 2 normally-distributed  with mean 0 and std dev of  dlat 3  dlong 3  as appropriate  and add them to your uniformly distributed points

User · Answer

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     gt  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                                                             gt  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

User · Answer

robert king It s a really nice solution but has some sloppy bugs in it     I know it helped me a lot though  so never mind the sloppiness      Here is a cleaned up version     from math import pi  asin  sin  degrees halfpi  twopi    5   pi  2   pi sphere area   lambda R 1 0  4   pi   R    2  lat dist   lambda lat  R 1 0  R  1-sin lat     A   2 pi R 2 1-sin lat   def sphere latarea lat  R 1 0       if -halfpi  gt  lat or lat  gt  halfpi          raise ValueError  quot lat must be between -halfpi and halfpi quot       return 2   pi   R    2    1-sin lat    sphere lonarea   lambda lon  R 1 0            4   pi   R    2   lon   twopi   A   2 pi R 2  sin lat1 -sin lat2    lon1-lon2  360         pi 180 R 2  sin lat1 -sin lat2    lon1-lon2  sphere rectarea   lambda lat0  lat1  lon0  lon1  R 1 0             sphere latarea lat0  R -sphere latarea lat1  R      lon1-lon0    twopi   def test sphere n lats 10  n lons 19  radius 540 0       total area   0 0     for i lons in range n lons           lon0   twopi   float i lons    n lons         lon1   twopi   float i lons 1    n lons         for i lats in range n lats               lat0   asin 2   float i lats    n lats - 1              lat1   asin 2   float i lats 1  n lats - 1              area   sphere rectarea lat0  lat1  lon0  lon1  radius              print  quot            9 4f  to    9 4f     9 4f  to    9 4f    gt  area   10 4f  quot                       format i lats  i lons                       degrees lat0   degrees lat1                        degrees lon0   degrees lon1                        area               total area    area     print  quot total area     10 4f   difference of   10 4f   quot               format total area  abs total area  - sphere area radius     test sphere

User · Answer

with small numbers of points you could run a simulation   from random import random randint r   10 n   20 best closest d   0 best points      points     r 0 0  for i in range n   for simulation in range 10000       x   random   r     y   random   r     z   r- x  2 y  2   0 5     if randint 0 1           x   -x     if randint 0 1           y   -y     if randint 0 1           z   -z     closest dist    2 r   2     closest index   None     for i in range n           for j in range n               if i  j                  continue             p1 p2   points i  points j              x1 y1 z1   p1             x2 y2 z2   p2             d    x1-x2   2  y1-y2   2  z1-z2   2             if d  lt  closest dist                  closest dist   d                 closest index   i     if simulation   100    0          print simulation closest dist     if closest dist  gt  best closest d          best closest d   closest dist         best points   points        points closest index   x y z    print best points  gt  gt  gt  best points   9 921692138442777  -9 930808529773849  4 037839326088124     5 141893371460546  1 7274947332807744  -4 575674650522637     -4 917695758662436  -1 090127967097737  -4 9629263893193745     3 6164803265540666  7 004158551438312  -2 1172868271109184     -9 550655088997003  -9 580386054762917  3 5277052594769422     -0 062238110294250415  6 803105171979587  3 1966101417463655     -9 600996012203195  9 488067284474834  -3 498242301168819     -8 601522086624803  4 519484132245867  -0 2834204048792728     -1 1198210500791472  -2 2916581379035694  7 44937337008726     7 981831370440529  8 539378431788634  1 6889099589074377     0 513546008372332  -2 974333486904779  -6 981657873262494     -4 13615438946178  -6 707488383678717  2 1197605651446807     2 2859494919024326  -8 14336582650039  1 5418694699275672     -7 241410895247996  9 907335206038226  2 271647103735541     -9 433349952523232  -7 999106443463781  -2 3682575660694347     3 704772125650199  1 0526567864085812  6 148581714099761     -3 5710511242327048  5 512552040316693  -3 4318468250897647     -7 483466337225052  -1 506434920354559  2 36641535124918     7 73363824231576  -8 460241422163824  -1 4623228616326003     10  0  0

User · Answer

Try   function sphere   N float k int  Vector3       var inc    Mathf PI     3 - Mathf Sqrt 5        var off   2   N      var y   k   off - 1    off   2       var r   Mathf Sqrt 1 - y y       var phi   k   inc      return Vector3  Mathf Cos phi  r   y  Mathf Sin phi  r         The above function should run in loop with N loop total and k loop current iteration   It is based on a sunflower seeds pattern  except the sunflower seeds are curved around into a half dome  and again into a sphere   Here is a picture  except I put the camera half way inside the sphere so it looks 2d instead of 3d because the camera is same distance from all points  http   3 bp blogspot com -9lbPHLccQHA USXf88 bvVI AAAAAAAAADY j7qhQsSZsA8 s640 sphere jpg

User · Answer

This answer is based on the same  theory   that is outlined well by this answer  I m adding this answer as   -- None of the other options fit the  uniformity  need  spot-on   or not obviously-clearly so     Noting to get the planet like distribution looking behavior particurally wanted in the original ask  you just reject from the finite list of the k uniformly created points at random  random wrt the index count  in the k items back     --The closest other impl forced you to decide the  N  by  angular axis   vs  just  one value of N  across both angular axis values   which at low counts of N is very tricky  to know what may  or may not matter   e g  you want  5  points -- have fun       --Furthermore  it s very hard to  grok  how to differentiate between the other options without any imagery  so here s what this option looks like  below   and the ready-to-run implementation that goes with it    with N at 20      and then N at 80      here s the ready-to-run python3 code  where the emulation is that same source    http   web archive org web 20120421191837 http   www cgafaq info wiki Evenly distributed points on sphere   found by others     The plotting I ve included  that fires when run as  main   is taken from  http   www scipy org Cookbook Matplotlib mplot3D    from math import cos  sin  pi  sqrt  def GetPointsEquiAngularlyDistancedOnSphere numberOfPoints 45           each point you get will be of form  x  y  z   in cartesian coordinates         eg  the  l2 distance  from the origion  0   0   0   for each point will be 1 0          ------------         converted from   http   web archive org web 20120421191837 http   www cgafaq info wiki Evenly distributed points on sphere                dlong   pi  3 0-sqrt 5 0       2 39996323      dz      2 0 numberOfPoints     long    0 0     z       1 0 - dz 2 0     ptsOnSphere         for k in range  0  numberOfPoints            r      sqrt 1 0-z z          ptNew    cos long  r  sin long  r  z          ptsOnSphere append  ptNew           z      z - dz         long   long   dlong     return ptsOnSphere  if   name         main                         ptsOnSphere   GetPointsEquiAngularlyDistancedOnSphere  80            toggle True False to print them     if  True                for pt in ptsOnSphere   print  pt        toggle True False to plot them     if True           from numpy import           import pylab as p         import mpl toolkits mplot3d axes3d as p3          fig p figure           ax   p3 Axes3D fig           x s    y s     z s             for pt in ptsOnSphere              x s append  pt 0    y s append  pt 1    z s append  pt 2            ax scatter3D  array  x s   array  y s   array  z s                            ax set xlabel  X    ax set ylabel  Y    ax set zlabel  Z           p show            end   tested at low counts  N in 2  5  7  13  etc  and seems to work  nice

User · Answer

edit  This does not answer the question the OP meant to ask  leaving it here in case people find it useful somehow   We use the multiplication rule of probability  combined with infinitessimals  This results in 2 lines of code to achieve your desired result   longitude  f   uniform  0 2pi   azimuth        -arcsin 1 - 2 uniform  0 1       defined in the following coordinate system      Your language typically has a uniform random number primitive  For example in python you can use random random   to return a number in the range  0 1   You can multiply this number by k to get a random number in the range  0 k   Thus in python  uniform  0 2pi   would mean random random   2 math pi     Proof  Now we can t assign   uniformly  otherwise we d get clumping at the poles  We wish to assign probabilities proportional to the surface area of the spherical wedge  the   in this diagram is actually f      An angular displacement df at the equator will result in a displacement of df r  What will that displacement be at an arbitrary azimuth    Well  the radius from the z-axis is r sin     so the arclength of that  latitude  intersecting the wedge is df   r sin     Thus we calculate the cumulative distribution of the area to sample from it  by integrating the area of the slice from the south pole to the north pole     where stuff df r   We will now attempt to get the inverse of the CDF to sample from it  http   en wikipedia org wiki Inverse transform sampling  First we normalize by dividing our almost-CDF by its maximum value  This has the side-effect of cancelling out the df and r   azimuthalCDF  cumProb    sin    1  2 from -pi 2 to pi 2  inverseCDF      -sin  -1  1 - 2 cumProb    Thus   let x by a random float in range  0 1      -arcsin 1-2 x

[python] Evenly distributing n points on a sphere

Examples related to python

Examples related to algorithm

Examples related to math

Examples related to geometry

Examples related to uniform