def icosahedron_ke4():
"""Microphone positions of the KE4 spherical microphone array.
The microphone marked as "1" defines the positive x-axis.
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
theta = np.array([
1.565269801525254, 2.294997457752220, 1.226592351686568,
1.226592351686568, 1.696605844149543, 2.409088979442091,
2.409088979442090, 1.696605844149543, 0.506378251408914,
0.506378251408914, 2.635214402180879, 1.444986809440250,
0.732503674147703, 0.732503674147703, 1.444986809440250,
2.635214402180879, 1.915000301903226, 0.846595195837573,
1.915000301903225, 1.576322852064539
])
phi = np.array([
0.000000000000000, 6.283185307179586, 0.660263824203969,
5.622921482975618, 5.055791576545843, 5.241315660913181,
1.041869646266405, 1.227393730633743, 0.826693168093822,
5.456492139085764, 3.968285821683615, 4.368986384223536,
4.183462299856198, 2.099723007323388, 1.914198922956050,
2.314899485495971, 2.481328829385824, 3.141592653589793,
3.801856477793762, 3.141592653589793
])
rad = np.ones(20) * 0.065
sampling = SamplingSphere.from_spherical(rad, theta, phi)
return sampling
def eigenmike_em32():
"""Microphone positions of the Eigenmike em32 by mhacoustics according to the
Eigenstudio user manual on the homepage [1]_.
References
----------
.. [1] Eigenstudio User Manual, https://mhacoustics.com/download
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
rad = np.ones(32)
theta = np.array([
69.0, 90.0, 111.0, 90.0, 32.0, 55.0, 90.0, 125.0, 148.0, 125.0, 90.0,
55.0, 21.0, 58.0, 121.0, 159.0, 69.0, 90.0, 111.0, 90.0, 32.0, 55.0,
90.0, 125.0, 148.0, 125.0, 90.0, 55.0, 21.0, 58.0, 122.0, 159.0
]) * np.pi / 180
phi = np.array([
0.0, 32.0, 0.0, 328.0, 0.0, 45.0, 69.0, 45.0, 0, 315.0, 291.0, 315.0,
91.0, 90.0, 90.0, 89.0, 180.0, 212.0, 180.0, 148.0, 180.0, 225.0,
249.0, 225.0, 180.0, 135.0, 111.0, 135.0, 269.0, 270.0, 270.0, 271.0
]) * np.pi / 180
sampling = SamplingSphere.from_spherical(rad, theta, phi)
return sampling
def gaussian(n_max):
"""Generate sampling of the sphere based on the Gaussian quadrature.
Paramters
---------
n_max : integer
Spherical harmonic order of the sampling
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
legendre, weights = np.polynomial.legendre.leggauss(n_max + 1)
theta_angles = np.arccos(legendre)
n_phi = np.round((n_max + 1) * 2)
phi_angles = np.arange(0, 2 * np.pi, 2 * np.pi / n_phi)
theta, phi = np.meshgrid(theta_angles, phi_angles)
rad = np.ones(theta.size)
weights = np.tile(weights * np.pi / (n_max + 1), 2 * (n_max + 1))
sampling = SamplingSphere.from_spherical(rad, theta.reshape(-1),
phi.reshape(-1))
sampling.weights = weights
return sampling
def equiangular(n_max):
"""Generate an equiangular sampling of the sphere.
Paramters
---------
n_max : integer
Spherical harmonic order of the sampling
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
n_theta = np.round((n_max + 1) * 2)
n_phi = n_theta
theta_angles = np.arange(np.pi / (n_theta * 2), np.pi, np.pi / n_theta)
phi_angles = np.arange(0, 2 * np.pi, 2 * np.pi / n_phi)
theta, phi = np.meshgrid(theta_angles, phi_angles)
rad = np.ones(theta.size)
# calculate weights
L = 2 * np.arange(0, n_max + 1) + 1
factor_phi = 2 * np.pi / n_phi
factor_theta = 2 / n_theta
factor_sin = 4/np.pi * np.sin(theta_angles) * \
(1/L @ L[np.newaxis].T @ theta_angles[np.newaxis])
weights = np.tile(factor_phi * factor_theta * np.pi / 2 * factor_sin,
n_phi)
sampling = SamplingSphere.from_spherical(rad, theta.reshape(-1),
phi.reshape(-1))
sampling.weights = weights
return sampling
def dodecahedron():
"""Generate a sampling based on the center points of the twelve dodecahedron faces.
Returns
-------
rad : ndarray
Radius of the sampling points
theta : ndarray
Elevation angle in the range [0, pi]
phi : ndarray
Azimuth angle in the range [0, 2 pi]
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
dihedral = 2 * np.arcsin(np.cos(np.pi / 3) / np.sin(np.pi / 5))
R = np.tan(np.pi / 3) * np.tan(dihedral / 2)
rho = np.cos(np.pi / 5) / np.sin(np.pi / 10)
theta1 = np.arccos(
(np.cos(np.pi / 5) / np.sin(np.pi / 5)) / np.tan(np.pi / 3))
a2 = 2 * np.arccos(rho / R)
theta2 = theta1 + a2
theta3 = np.pi - theta2
theta4 = np.pi - theta1
phi1 = 0
phi2 = 2 * np.pi / 3
phi3 = 4 * np.pi / 3
theta = np.concatenate((np.tile(theta1, 3), np.tile(theta2, 3),
np.tile(theta3, 3), np.tile(theta4, 3)))
phi = np.tile(
np.array([
phi1, phi2, phi3, phi1 + np.pi / 3, phi2 + np.pi / 3,
phi3 + np.pi / 3
]), 2)
rad = np.ones(np.size(theta))
sampling = SamplingSphere.from_spherical(rad, theta, phi)
return sampling
def icosahedron():
"""Generate a sampling based on the center points of the twenty \
icosahedron faces.
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
"""
gamma_R_r = np.arccos(np.cos(np.pi / 3) / np.sin(np.pi / 5))
gamma_R_rho = np.arccos(1 / (np.tan(np.pi / 5) * np.tan(np.pi / 3)))
theta = np.tile(
np.array([
np.pi - gamma_R_rho, np.pi - gamma_R_rho - 2 * gamma_R_r,
2 * gamma_R_r + gamma_R_rho, gamma_R_rho
]), 5)
theta = np.sort(theta)
phi = np.arange(0, 2 * np.pi, 2 * np.pi / 5)
phi = np.concatenate((np.tile(phi, 2), np.tile(phi + np.pi / 5, 2)))
rad = np.ones(20)
sampling = SamplingSphere.from_spherical(rad, theta, phi)
return sampling
def spiral_points(n_max, condition_num=2.5, n_points=None):
"""Sampling based on a spiral distribution of points on a sphere [1]_.
Parameters
----------
n_max : int
Spherical harmonic order
condition_num : double
Desired maximum condition number of the spherical harmonic basis matrix
n_points : int, optional
Number of points to start the condition number optimization. If set to
None n_points will be (n_max+1)**2
Returns
-------
sampling : SamplingSphere
SamplingSphere object containing all sampling points
References
----------
.. [1] E. a. Rakhmanov, E. B. Saff, and Y. M. Zhou, “Minimal Discrete
Energy on the Sphere,” Mathematical Research Letters, vol. 1,
no. 6, pp. 647–662, 1994.
"""
if n_points is None:
n_points = (n_max + 1)**2
def _spiral_points(n_points):
"""Helper function doing the actual calculation of the points"""
r = np.zeros(n_points)
h = np.zeros(n_points)
theta = np.zeros(n_points)
phi = np.zeros(n_points)
p = 1 / 2
a = 1 - 2 * p / (n_points - 3)
b = p * (n_points + 1) / (n_points - 3)
r[0] = 0
theta[0] = np.pi
phi[0] = 0
# Then for k stepping by 1 from 2 to n-1:
for k in range(1, n_points - 1):
kStrich = a * k + b
h[k] = -1 + 2 * (kStrich - 1) / (n_points - 1)
r[k] = np.sqrt(1 - h[k]**2)
theta[k] = np.arccos(h[k])
phi[k] = np.mod(
(phi[k - 1]) + 3.6 / np.sqrt(n_points) * 2 / (r[k - 1] + r[k]),
2 * np.pi)
# Finally:
theta[n_points - 1] = 0
phi[n_points - 1] = 0
return theta, phi
while True:
theta, phi = _spiral_points(n_points)
sampling = SamplingSphere.from_spherical(np.ones(n_points), theta, phi)
if condition_num != np.inf:
Y = spharpy.spherical.spherical_harmonic_basis(n_max, sampling)
cond = np.linalg.cond(Y)
if cond < condition_num:
break
else:
break
n_points += 1
sampling.n_max = n_max
return sampling