我需要一种算法，它可以为我在一个球体周围提供 N 个点（可能小于 20 个）的位置，从而模糊地将它们分散开来。不需要“完美”，但我只需要它，所以它们都不会聚集在一起。
我遇到的其他一些问题线程谈到了随机均匀分布，这增加了我不关心的复杂程度。我很抱歉这是一个如此愚蠢的问题，但我想表明我真的很努力，但仍然做不到。
所以，我正在寻找的是简单的伪代码，可以在一个单位球体周围均匀分布 N 个点，它要么以球面坐标返回，要么以笛卡尔坐标返回。如果它甚至可以通过一点随机化来分布，那就更好了（想想恒星周围的行星，分布得体，但有余地）。
斐波那契球体算法非常适合这一点。它速度很快，并且给出的结果一目了然很容易欺骗人眼。您可以看到一个处理完成的示例，该示例将随着时间的推移在添加点时显示结果。这是@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 个样本为您提供：
你说你无法让黄金螺旋方法发挥作用，这很遗憾，因为它真的非常非常好。我想让你对它有一个完整的了解，这样也许你就能明白如何避免它被“捆绑”。</p>
因此，这是一种快速、非随机的方法来创建近似正确的晶格；如上所述，没有晶格是完美的，但这可能已经足够了。它与其他方法进行了比较，例如在BendWavy.org上，但它只是具有漂亮漂亮的外观以及在限制内均匀间距的保证。
为了理解这个算法，我先请大家看一下2D向日葵螺旋算法。这是基于这样一个事实，即最不合理的数字是黄金比例(1 + sqrt(5))/2，如果一个人通过“站在中心，转一圈黄金比例，然后向那个方向发射另一个点”的方法发射点，那么自然会构造一个螺旋，当您获得越来越多的点数时，它仍然拒绝具有明确定义的“条”，这些点排列在上面。（注 1。）
磁盘上均匀间距的算法是，
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)；我是怎么来的？（笔记2。）
好吧，我在这里使用平方根，因为我希望它们在磁盘周围具有均匀的区域间距。这就像说在大N的限制下，我想要一个小区域R ∈ ( r , r + d r ), Θ ∈ ( θ , θ + d θ ) 包含与其面积成比例的点数，这是r d r d θ。现在，如果我们假设我们在这里谈论的是一个随机变量，这有一个简单的解释，即 ( R , Θ ) 的联合概率密度就是cr对于一些常数c。单位圆盘上的归一化将迫使c = 1/π。
现在让我介绍一个技巧。它来自概率论，它被称为对逆 CDF 进行采样：假设您想生成一个概率密度为f ( z ) 的随机变量，并且您有一个随机变量U ~ Uniform(0, 1)，就像从random()在大多数编程语言中。你怎么做到这一点？
现在黄金比例螺旋技巧将这些点以一个非常均匀的模式隔开，让我们把它整合起来；对于单位圆盘，我们剩下F ( r ) = r 2。所以反函数是F -1 ( u ) = u 1/2，因此我们将在极坐标的磁盘上生成随机点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。
我们的面积元素，以前是r d r d θ，现在变成了不太复杂的 sin( φ ) d φ d θ。所以我们均匀间距的联合密度是 sin( φ )/4π。对θ进行积分，我们发现f ( φ ) = sin( φ )/2，因此F ( φ ) = (1 − cos( φ ))/2。反转这个我们可以看到均匀随机变量看起来像 acos(1 - 2 u )，但是我们均匀采样而不是随机采样，所以我们改为使用φ k = acos(1 - 2 ( k+ 0.5)/ N )。算法的其余部分只是将其投影到 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，结果如下所示：
我想对 Martin Roberts 的博客大喊一声。请注意，上面我通过向每个索引添加 0.5 创建了索引的偏移量。这只是在视觉上吸引了我，但事实证明，偏移量的选择很重要，并且在间隔内不是恒定的，如果选择正确，这意味着打包的准确度可以提高 8%。还应该有一种方法可以让他的 R 2序列覆盖一个球体，看看这是否也产生了一个很好的均匀覆盖，也许是原样但可能需要，比如说，只取自一半单位正方形对角线左右切割并拉伸得到一个圆圈。
这些“条”是由一个数字的有理逼近形成的，一个数字的最佳有理逼近来自其连分数表达式，z + 1/(n_1 + 1/(n_2 + 1/(n_3 + ...)))其中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/ φ ，从而得到黄金比例的公式。
对于不太熟悉 NumPy 的人来说——所有的函数都是“矢量化的”，所以这sqrt(array)和其他语言可能写的一样map(sqrt, array)。所以这是一个逐个组件的sqrt应用程序。这同样适用于除以标量或与标量加法 - 这些并行适用于所有组件。
一旦你知道这是结果，证明就很简单了。如果你问z < Z < z + d z的概率是多少，这与问z < F -1 ( U ) < z + d z的概率是多少相同，将F应用于所有三个表达式，注意它是一个单调递增函数，因此F ( z ) < U < F ( z + d z )，将右手边展开以找到F ( z ) + f( z ) d z，并且由于U是均匀的，因此该概率只是f ( z ) d z所承诺的。
这被称为球体上的填充点，并且没有（已知的）通用、完美的解决方案。但是，有很多不完美的解决方案。最受欢迎的三个似乎是：
n它们），然后拒绝球体外部的点。将剩余的点视为向量，并将它们归一化。这些是您的“样本” -n使用某种方法（随机、贪婪等）选择它们。可以在此处找到有关此问题的更多信息
在此示例中，代码 node[k]只是第 k 个节点。您正在生成一个数组 N 个点并且node[k]是第 k 个（从 0 到 N-1）。如果这就是让您感到困惑的全部，希望您现在可以使用它。
（换句话说，k是在代码片段开始之前定义的大小为 N 的数组，其中包含点列表）。
或者，基于此处的另一个答案（并使用 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
如果你绘制它，你会看到两极附近的垂直间距更大，因此每个点都位于大约相同的空间总面积中（在两极附近，“水平”空间较小，所以它提供更多“垂直” ）。
这与与邻居距离大致相同的所有点不同（我认为您的链接正在谈论），但它可能足以满足您的需求，并改进了简单地制作统一的纬度/经度网格.
您正在寻找的东西称为球形覆盖物。球形覆盖问题非常困难，除了少量点外，解决方案未知。可以确定的一件事是，给定球体上的 n 个点，总是存在两个距离d = (4-csc^2(\pi n/6(n-2)))^(1/2)或更近的点。
如果你想要一种概率方法来生成均匀分布在球体上的点，这很容易：通过高斯分布在空间中均匀生成点（它内置在 Java 中，不难找到其他语言的代码）。所以在 3 维空间中，你需要类似的东西
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 个距离，并且拒绝的概率将取决于 slack；很难说怎么做，所以运行一个模拟来感受一下相关的统计数据。
该答案基于此答案很好地概述的相同“理论”
我将这个答案添加为：
- 没有其他选项适合“一致性”需要“现场”（或不明显 - 显然如此）。（注意要在原始问题中获得特别想要的类似分布的行为，您只需从随机均匀创建的 k 个点的有限列表中拒绝（随机返回 k 个项目中的索引计数）。）
- 最接近的其他 impl 迫使您通过“角轴”来决定“N”，而不是在两个角轴值上仅使用“N 的一个值”（在 N 的低计数下很难知道什么可能或可能无关紧要（例如，你想要“5”分——玩得开心））
--此外，很难“理解”如何在没有任何图像的情况下区分其他选项，所以这就是这个选项的样子（下图），以及随之而来的准备运行的实现。
N 为 20：
然后是 80 处的 N：
这是可以运行的 python3 代码，其中的仿真是相同的来源：“ http://web.archive.org/web/20120421191837/http://www.cgafaq.info/wiki/Evenly_distributed_points_on_sphere ”由其他人发现. （我所包含的绘图在作为“主”运行时触发，取自：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
在低计数下测试（N 在 2、5、7、13 等）并且似乎工作“不错”
尝试：
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
Healpix 解决了一个密切相关的问题（用等面积像素对球体进行像素化）：
http://healpix.sourceforge.net/
这可能是矫枉过正，但也许在看过它之后，你会意识到它的一些其他不错的属性对你来说很有趣。它不仅仅是一个输出点云的函数。
我降落在这里试图再次找到它；“healpix”这个名字并不能完全唤起球体......
编辑：这不能回答 OP 想要问的问题，把它留在这里，以防人们发现它以某种方式有用。
我们使用概率乘法规则，结合无穷小。这会产生 2 行代码来实现您想要的结果：
longitude: φ = uniform([0,2pi))
azimuth: θ = -arcsin(1 - 2*uniform([0,1]))
（在以下坐标系中定义：）
您的语言通常具有统一的随机数原语。例如，在 python 中，您可以使用random.random()返回范围内的数字[0,1)。您可以将此数字乘以 k 以获得范围内的随机数[0,k)。因此，在 python 中，uniform([0,2pi))将意味着random.random()*2*math.pi.
证明
现在我们不能统一分配 θ，否则我们会在两极聚集。我们希望分配与球形楔的表面积成比例的概率（该图中的 θ 实际上是 φ）：
赤道处的角位移 dφ 将导致 dφ*r 的位移。在任意方位角 θ 处的位移是多少？嗯，从 z 轴的半径是r*sin(θ)，所以那个“纬度”与楔形相交的弧长是dφ * r*sin(θ)。因此，我们通过整合从南极到北极的切片面积来计算要从中采样的区域的累积分布。
（东西= dφ*r）
我们现在将尝试获取 CDF 的逆以从中采样：http ://en.wikipedia.org/wiki/Inverse_transform_sampling
首先，我们通过将近似 CDF 除以其最大值进行归一化。这具有抵消 dφ 和 r 的副作用。
azimuthalCDF: cumProb = (sin(θ)+1)/2 from -pi/2 to pi/2
inverseCDF: θ = -sin^(-1)(1 - 2*cumProb)
因此：
let x by a random float in range [0,1]
θ = -arcsin(1-2*x)
取你的两个最大的因素N，如果N==20那么两个最大的因素是{5,4}，或者，更一般地说{a,b}。计算
dlat = 180/(a+1)
dlong = 360/(b+1})
把你的第一个点放在{90-dlat/2,(dlong/2)-180}，你的第二个点{90-dlat/2,(3*dlong/2)-180}，你的第三个点{90-dlat/2,(5*dlong/2)-180}，直到你环游世界一次，到那时你已经到了{75,150}你去旁边的时间{90-3*dlat/2,(dlong/2)-180}。
显然，我在球形地球表面上以度为单位工作，使用通常的惯例将 +/- 转换为 N/S 或 E/W。显然，这给了你一个完全非随机的分布，但它是均匀的，并且点没有聚集在一起。
为了增加一定程度的随机性，您可以生成 2 个正态分布的（平均为 0 和 {dlat/3, dlong/3} 的标准偏差）并将它们添加到您的均匀分布点。
使用少量点，您可以运行模拟：
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 < closest_dist:
closest_dist = d
closest_index = i
if simulation % 100 == 0:
print simulation,closest_dist
if closest_dist > best_closest_d:
best_closest_d = closest_dist
best_points = points[:]
points[closest_index]=(x,y,z)
print best_points
>>> 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)]
或...放置 20 个点，计算二十面体面的中心。对于 12 个点，找到二十面体的顶点。对于 30 点，二十面体边缘的中点。您可以对四面体、立方体、十二面体和八面体做同样的事情：一组点位于顶点上，另一组位于面的中心，另一组位于边缘的中心。但是，它们不能混合。
根据 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
预览：
# 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 > 2*pi):
longitude = longitude - 2*pi
prevLongitude = longitude
if (longitude > pi):
longitude = longitude - 2*pi
latitude = arccos(zInc) - pi/2
vxyz[index] = array([ (cos(latitude) * cos(longitude)) ,
(cos(latitude) * sin(longitude)),
sin(latitude)])
@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()
这很有效，而且非常简单。你想要多少点：
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<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());
}