试试:

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);
};

以上函数采用 N 回路总循环和 k 回路电流迭代进行循环运行。

它是基于向日葵种子图案，除了向日葵种子是弯曲成半圆顶，并再次成为一个球体。

这是一张照片，除了我把相机放在球体的一半，这样它看起来是2d 而不是3d，因为相机与所有点的距离是相同的。 Http://3.bp.blogspot.com/-9lbphlccqha/usxf88_bvvi/aaaaaaaaady/j7qhqsszsa8/s640/sphere.jpg

或者... 放置20个点，计算二十面体面的中心。对于12点，求二十面体的顶点。对于30点，二十面体边缘的中点。你可以对四面体，立方体，十二面体和八面体做同样的事情: 一组点在顶点上，另一组在面的中心，另一组在边的中心。然而，它们不能混合在一起。

斐波那契球面算法 对此很有用。它的速度很快，而且给出的结果一目了然，很容易欺骗人的眼睛。您可以看到一个处理完成的示例将随着时间的推移显示结果作为点被添加。这是另一个很棒的交互式例子由@gman 制作。下面是 Python 中的一个简单实现。

import math




def fibonacci_sphere(samples=1000):


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个样品给你这个:

你正在寻找的是所谓的 球形覆盖物球形覆盖物。球面覆盖问题是一个非常困难的问题，除了少数几个点外，其它解都是未知的。可以肯定的是，给定球面上的 n 个点，总是存在距离 d = (4-csc^2(\pi n/6(n-2)))^(1/2)或更近的两个点。

如果你想要一个概率方法来生成均匀分布在球面上的点，这很简单: 通过正态分布在空间中生成均匀分布的点(这是内置在 Java 中的，不难找到其他语言的代码)。所以在三维空间中，你需要

Random r = new Random();
double[] p = { r.nextGaussian(), r.nextGaussian(), r.nextGaussian() };

然后通过归一化球体与原点的距离将该点投影到球体上

double norm = Math.sqrt( (p[0])^2 + (p[1])^2 + (p[2])^2 );
double[] sphereRandomPoint = { p[0]/norm, p[1]/norm, p[2]/norm };

N 维的正态分布是球对称的，所以投影到球上是均匀的。

当然，并不能保证一个均匀生成的点集合中的任何两个点之间的距离都在下面，所以你可以使用拒绝来强制执行任何你可能具有的条件: 也许最好是生成整个集合，然后在必要时拒绝整个集合。(或者使用“早期拒绝”来拒绝你到目前为止已经生成的所有集合; 只是不要保留一些点数而放弃另一些点数。)您可以使用上面给出的 d公式，减去一些松弛，来确定点之间的最小距离，低于这个距离您将拒绝一组点。你将不得不计算 n 选择2个距离，拒绝的概率将取决于松弛; 很难说如何，所以运行一个模拟，以获得相关的统计数据的感觉。

黄金螺旋法

你说过你不能让黄金螺旋方法起作用那真是太遗憾了，因为它真的真的很好。我想给你一个完整的理解，这样也许你可以理解如何避免这个被“捆绑”

所以这里有一个快速，非随机的方法来创建一个近似正确的格子; ，如上所述，没有格子是完美的，但这可能是足够好的。它与其他方法相比，例如在 BendWavy.org，但它只是有一个很好的和漂亮的外观，以及一个保证，甚至间隔的限制。

底漆: 单位圆盘上的向日葵螺旋

为了理解这个算法，我首先请大家看看2D 向日葵螺旋算法。这是基于这样一个事实，即最无理数的是黄金比率 (1 + sqrt(5))/2，如果一个人通过“站在中心，转一个整圈的黄金比率，然后朝那个方向发射另一个点”的方法发射点，他就会自然而然地构建一个螺旋，当你得到越来越多的点时，尽管如此，仍然拒绝有明确定义的“条形”让这些点对齐

磁盘上均匀间距的算法是,

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()

它产生的结果看起来像(n = 100和 n = 1000) :

放射状的点间距

最奇怪的是公式 r = sqrt(indices / num_pts)，我是怎么得到这个的

我在这里使用平方根，因为我希望它们在磁盘周围有均匀的面积间距。也就是说，在大 N的极限下，我希望一个小区域 R∈(R，R + dR) ，Θ∈(Θ，Θ + dΘ)包含与其面积成正比的多个点，即 R dR dΘ。现在，如果我们假设我们在这里讨论的是一个随机变量，这里有一个直接的解释，就是(R，Θ)的联合概率密度，对于某个常数 R5只是 R4。在单位圆盘上的标准化将迫使 R5 = 1/π。

现在我来介绍一个小把戏。它来自于一个叫做 采样反向 CDF的概率论: 假设你想要 产生一个概率密度为 F(Z)的随机变量，并且你有一个随机变量 美国 ~ Uniform (0,1) ，就像大多数编程语言中的 random()一样。你是怎么做到的？

1. 首先，将你的密度转换成 累积分布函数或 CDF，我们称之为 F(Z)。请记住，CDF 随着导数 F(Z)从0单调增加到1。
2. 然后计算 CDF 的反函数 F^-1(Z)。
3. 你会发现 Z = F^-1(美国)是根据目标密度分布的

现在，黄金比例螺旋技巧为 Θ以一种很好的均匀模式来空间指出，所以让我们把它积分出来; 对于单位圆盘，我们剩下的是 F(R) = R²。所以反函数是 F^-1(你) = 你Θ0，因此我们可以用极坐标系 r = sqrt(random()); theta = 2 * pi * random()在圆盘上生成随机点。

现在我们不再使用 随机的采样，而是使用反函数 一致的采样，统一采样的好处是，我们得到的关于点在大型 N极限下的分布情况的结果，就好像我们是随机采样一样。这个组合就是诀窍。取代 random()，我们使用 (arange(0, num_pts, dtype=float) + 0.5)/num_pts，因此，如果我们想要采样10个点，他们是 r = 0.05, 0.15, 0.25, ... 0.95。我们统一采样 R得到等面积间隔，我们使用向日葵增量，以避免可怕的“酒吧”的点在输出。

现在在球体上画向日葵

我们需要做的改变，以点的球体只是涉及切换极坐标球坐标。径向坐标当然不包括在内，因为我们是在一个单位球面上。为了保持一致性，即使我是物理学家，我也会使用数学家的坐标，其中0≤ Φ≤ π 是从极点向下的纬度，0≤ Θ≤2π 是经度。所以与上面不同的是，我们基本上用 Φ代替了变量 R。

我们的 area 元素是 R dR dΘ，现在变成了不太复杂的 sin (Φ) dΦ dΘ。因此，均匀间距的联合密度是 sin (Φ)/4π。积分出 Θ，我们发现 F(Φ) = sin (Φ)/2，因此 R1(Φ) = (1-cos (Φ))/2。反过来，我们可以看到一个统一的随机变量看起来像 acos (1-2 R4) ，但是我们是统一采样而不是随机采样，所以我们使用 ΦR6 = acos (1-2(R7 + 0.5)/R8)。算法的其他部分只是把它投影到 x，y 和 z 坐标上:

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()

对于 n = 100和 n = 1000，结果同样如下:

进一步研究

我想为马丁 · 罗伯茨的博客大声疾呼。请注意，上面我通过向每个索引添加0.5来创建索引的偏移量。这只是视觉上吸引我，但 事实证明，补偿的选择非常重要和不是恒定的间隔，可以意味着获得多达8% 更好的准确性包装，如果选择正确。也应该有一种方法让 他的 R < sub > 2 序列覆盖一个球体，这将是有趣的，看看这是否也产生一个不错的均匀覆盖，也许是-是，但也许需要，说，从只有一半的单位方形斜切或左右，并拉伸周围得到一个圆。

笔记

1. 这些“条”是由一个数的有理近似形成的，最好的有理近似来自于它的连分数表达式，其中 z是一个整数，而 n_1, n_2, n_3, ...是一个正整数的有限或无限序列:

   def continued_fraction(r):
   while r != 0:
   n = floor(r)
   yield n
   r = 1/(r - n)
   

   因为小数部分 1/(...)总是介于0和1之间，所以连分数中的大整数允许一个特别好的有理近似: “一除以100和101之间的某个数”比“一除以1和2之间的某个数”要好因此，最有无理数的是 1 + 1/(1 + 1/(1 + ...))，它没有特别好的有理近似，人们可以通过乘以 Φ来求解 Φ = 1 + 1/Φ，从而得到黄金分割率的公式。

2. 对于不太熟悉 NumPy 的人来说——所有的函数都是“向量化的”，这样 sqrt(array)就和其他语言可能编写的 map(sqrt, array)一样。这是一个逐个组件的 sqrt应用程序。这同样适用于标量除法或标量加法——它们适用于并行的所有组件。

3. 一旦你知道这就是结果，证明就很简单了。如果你问 Z < Z < Z + dZ的概率是多少，这和问 Z < F^-1(美国) < Z + dZ的概率是多少是一样的，对所有三个表达式都应用 F，注意它是一个单调递增的函数，因此 F(Z) < 美国 < F(Z + dZ) ，向右边展开找到 F(Z) + Z9(Z) dZ，由于 美国是一致的，所以这个概率只是 Z9(Z) dZ。

Healpix 解决了一个紧密相关的问题(用等面积像素像素化球体) :

Http://healpix.sourceforge.net/

它可能是过度杀伤力，但也许在看了它之后，你会意识到它的其他一些不错的属性是你感兴趣的。它不仅仅是一个输出点云的函数。

我降落在这里，试图再次找到它; 名称“健康”不完全唤起球体..。

@ Robert King 这真是个不错的解决方案，不过里面有些马虎的小虫子。我知道这对我帮助很大，所以不要介意马虎。:) 这里是一个清理版本... 。

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 > lat or lat > halfpi:
raise ValueError("lat must be between -halfpi and halfpi")
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("{:} {:}: {:9.4f} to  {:9.4f}, {:9.4f} to  {:9.4f} => area {:10.4f}"
.format(i_lats, i_lons
, degrees(lat0), degrees(lat1)
, degrees(lon0), degrees(lon1)
, area))
total_area += area
print("total_area = {:10.4f} (difference of {:10.4f})"
.format(total_area, abs(total_area) - sphere_area(radius)))


test_sphere()

基于 fnord 的回答，这里有一个 Unity3D 版本，增加了范围:

密码:

// 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 < 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;
}

要点: https://gist.github.com/nukadelic/7449f0872f708065bc1afeb19df666f7/edit

预览: