'''

Notes

-----

Tested visually.

'''

u, v = np.squeeze(np.random.uniform(size=(2, size)))

phi = 2 * np.pi * u

theta = np.arccos(2 * v - 1)

'''

Notes

-----

Tested visually.

'''

xyz = np.random.normal(size=(size, 3))

'''Convert a point described by two angles to Cartesian co-ordinates.

Parameters

----------

theta : scalar

phi : scalar

Returns

-------

vector : array, shape (3,)

x,y,z co-ordinates of equivalent vector

'''

warn("Use spherical.pol2cart instead.", DeprecationWarning, stacklevel=2)

sin, cos = np.sin, np.cos

x = sin(theta) * cos(phi)

y = sin(theta) * sin(phi)

z = cos(theta)

"""

(This docstring should be overwritten)

"""

arr = array(arr, copy=False, subok=True)

nd = arr.ndim

if axis < 0:

axis += nd

if (axis >= nd):

raise ValueError("axis must be less than arr.ndim; axis=%d, rank=%d."

% (axis,nd))

ind = [0]*(nd-1)

i = np.zeros(nd,'O')

indlist = range(nd)

indlist.remove(axis)

i[axis] = slice(None,None)

outshape = np.asarray(arr.shape).take(indlist)

i.put(indlist, ind)

j = i.copy()

res = func1d(arr[tuple(i.tolist())], *args, **kwargs)

# if res is a number, then we have a smaller output array

asscalar = np.isscalar(res)

if not asscalar:

try:

len(res)

except TypeError:

asscalar = True

# Note: we shouldn't set the dtype of the output from the first result...

#...so we force the type to object, and build a list of dtypes

#...we'll just take the largest, to avoid some downcasting

dtypes = []

if asscalar:

dtypes.append(np.asarray(res).dtype)

outarr = zeros(outshape, object)

outarr[tuple(ind)] = res

Ntot = np.product(outshape)

k = 1

while k < Ntot:

# increment the index

ind[-1] += 1

n = -1

while (ind[n] >= outshape[n]) and (n > (1-nd)):

ind[n-1] += 1

ind[n] = 0

n -= 1

i.put(indlist, ind)

res = func1d(arr[tuple(i.tolist())], *args, **kwargs)

outarr[tuple(ind)] = res

dtypes.append(asarray(res).dtype)

k += 1

else:

res = array(res, copy=False, subok=True)

j = i.copy()

j[axis] = ([slice(None, None)] * res.ndim)

j.put(indlist, ind)

Ntot = np.product(outshape)

holdshape = outshape

outshape = list(arr.shape)

outshape[axis] = res.shape

dtypes.append(asarray(res).dtype)

outshape = flatten_inplace(outshape)

outarr = zeros(outshape, object)

outarr[tuple(flatten_inplace(j.tolist()))] = res

k = 1

while k < Ntot:

# increment the index

ind[-1] += 1

n = -1

while (ind[n] >= holdshape[n]) and (n > (1-nd)):

ind[n-1] += 1

ind[n] = 0

n -= 1

i.put(indlist, ind)

j.put(indlist, ind)

res = asarray(func1d(arr[tuple(i.tolist())], *args, **kwargs))

outarr[tuple(flatten_inplace(j.tolist()))] = res

dtypes.append(asarray(res).dtype)

k += 1

max_dtypes = np.dtype(np.asarray(dtypes).max())

if not hasattr(arr, '_mask'):

result = np.asarray(outarr, dtype=max_dtypes)

else:

result = asarray(outarr, dtype=max_dtypes)

result.fill_value = ma.default_fill_value(result)

#print result.mask

'''Convert a vector into two angles

Parameters

----------

mu : array_like, shape (3,)

x,y,z components of vector

Returns

-------

theta : scalar

phi : scalar

'''

warn("Use spherical.cart2pol instead.", DeprecationWarning, stacklevel=2)

x,y,z = vector

theta = np.arccos(z)

if np.allclose(theta, 0):

# theta should be of size 1, but allclose handles masked values better

# vector points straight up, phi is irrelevant,

#... automatically define as 0

phi = 0

else:

phi = np.arctan2(y,x)

'''Convert a vector into two angles

Parameters

----------

mu : array_like, shape (3,)

x,y,z components of vector

Returns

-------

theta : scalar

phi : scalar

'''

warn("Use spherical.cart2pol instead.", DeprecationWarning, stacklevel=2)

x,y,z = vector

theta = np.ma.arccos(z)

if np.allclose(theta, 0):

# theta should be of size 1, but allclose handles masked values better

# vector points straight up, phi is irrelevant,

#... automatically define as 0

if type(theta) != np.ma.MaskedArray:

phi = 0

else:

phi = np.ma.array(0., mask=True)

else:

phi = np.ma.arctan2(y,x)

# if type(theta) == np.ma.MaskedArray:

# if theta.mask:

# print "o",

# else:

# print "x",

# if type(phi) == np.ma.MaskedArray:

# if phi.mask:

# print "o"

# else:

# print "x"

'''

Parameters

----------

x, y : scalars

Returns

-------

psi, rho : scalars

psi angle, and rho radius

'''

rho = np.sqrt(x**2 + y**2)

psi = np.arctan2(y, x)

'''

Parameters

----------

psi, rho : scalars

Returns

-------

x, y : scalars

'''

x = rho * np.cos(psi)

y = rho * np.sin(psi)

'''A stereographic plot of a sphere on to a 2d plane'''

def __init__(self, cmap=mpl.cm.Blues, n_items=None, fig=None,

fig_num=None, panel_positions=[121, 122]):

self.theory_rmax = np.sqrt(2.)

if fig == None:

self.figure = plt.figure(num=fig_num, figsize=(8,4))

else:

self.figure = fig

if type(panel_positions[0]) == int:

fn = self.figure.add_subplot

else:

fn = self.figure.add_axes

self.ax_top = fn(panel_positions[0], projection='polar',

resolution=1)

self.ax_top.set_thetagrids([])

self.ax_top.set_rticks([])

self.ax_bot = fn(panel_positions[1], projection='polar',

resolution=1)

self.ax_bot.set_thetagrids([])

self.ax_bot.set_rticks([])

# self.scale_axes()

self.ax_top.set_autoscale_on(False)

self.ax_bot.set_autoscale_on(False)

self.cmap = cmap

self.n_items = n_items

self.i_item = 0

def next_colour(self, inc=True):

if self.n_items == None:

return self.cmap(0)

else:

c_ind = 255 * self.i_item / float(self.n_items)

next_colour = self.cmap(int(round(c_ind)))

if inc:

self.i_item += 1

return next_colour

def get_colours(self, n):

if self.n_items == None:

return self.cmap(0)

else:

c_ind = np.linspace(0, 255 * (n / self.n_items), n)

next_colours = self.cmap(np.round(c_ind).astype(int))

return next_colours

def project_polar(self, polar_coords):

theta, phi = polar_coords

rho, psi = 2 * np.sin((np.pi - theta)/2.), phi

return rho, psi

def flip_hemisphere_polar(self, polar_coords):

theta, phi = polar_coords

# flip theta

theta = np.pi - theta

# flip phi

phi = (np.pi - phi) % (2 * np.pi)

return theta, phi

def plot_xy(self, X, Y, Z, color='next', inc_color=True):

if Z > 0:

# need to flip hemisphere over and change axes accordingly

ax = self.ax_top

Z *= -1

X *= -1

else:

ax = self.ax_bot

if color == 'next':

color = self.next_colour(inc=inc_color)

x, y = X * np.sqrt(2/(1. - Z)), Y * np.sqrt(2/(1. - Z))

rho, psi = cart_to_polar_2d(x, y)

ax.plot((psi,), (rho,), 'o', color=color)

if rho.max() > self.theory_rmax:

print "Range warning."

plt.draw()

def plot_polar(self, theta, phi, color='next', inc_color=True, symbol='o'):

if theta < np.pi/2.:

# flip hemisphere

ax = self.ax_top

theta, phi = self.flip_hemisphere_polar((theta, phi))

else:

ax = self.ax_bot

if color == 'next':

color=self.next_colour()

rho, psi = self.project_polar((theta, phi))

ax.plot((psi,), (rho,), symbol, color=color)

if rho.max() > self.theory_rmax:

print "Range warning."

plt.draw()

def plot_polar2(self, theta, phi, color='next',

inc_color=True, symbol='o'):

tops = theta < np.pi/2.

bottoms = ~tops

if color == 'next':

color=self.get_colours(theta.shape[0])

if np.any(tops):

# plot tops

# flip hemisphere

theta_t, phi_t = \

self.flip_hemisphere_polar((theta[tops], phi[tops]))

rho, psi = self.project_polar((theta_t, phi_t))

self.ax_top.scatter(psi, rho, edgecolors='k', color=color,

linewidths=.5)

if np.any(bottoms):

# plot bottoms

rho, psi = self.project_polar((theta[bottoms], phi[bottoms]))

self.ax_bot.scatter(psi, rho, marker='o',

edgecolors='k', color=color,

linewidths=.5)

#will have to keep a list of colours assigned earlier, and then

#select from it when drawing

if rho.max() > self.theory_rmax:

print "Range warning."

plt.draw()

def plot_circle(self, theta, phi, angle, resolution=100.,

color='next', inc_color=True, **kwargs):

# calculate points in circle, in X,Y,Z

x, y, z = 0, 1, 2

rho, psi = 0, 1

P_c = generate_cone_circle(theta, phi, angle)

#P_c = P_c # [:-1]

if angle > np.pi/2.:

symbol = '--'

else:

symbol = '-'

if color == 'next':

color = self.next_colour(inc=inc_color)

# divide circle points into each hemisphere

top_hemisphere = P_c[..., z] >= 0

bot_hemisphere = P_c[..., z] <= 0

# convert P_c to 3d polar co-ordinates

P_p = cart2pol(P_c, 1)

#P_p = np.apply_along_axis(convert_cartesian_to_polar, 1, P_c)

# correct order of points must be maintained!!

# there are three cases: top only, bottom only, top and bottom

if np.all(top_hemisphere):

# top only

# flip hemisphere

P_flipped = np.apply_along_axis(self.flip_hemisphere_polar, 1, P_p)

# convert to Lambert projection

Q_p = np.apply_along_axis(self.project_polar, 1, P_flipped)

#if np.diff(Q_p[..., psi])[0] > 0.:

# Q_p = Q_p[::-1]

line = self.ax_top.plot(Q_p[..., psi], Q_p[..., rho],

symbol, color=color, zorder=0, **kwargs)

elif np.all(bot_hemisphere):

# bottom only

# convert P_p to Lambert projection

Q_p = np.apply_along_axis(self.project_polar, 1,

P_p % (2 * np.pi))

line = self.ax_bot.plot(Q_p[..., psi], Q_p[..., rho],

symbol, color=color, zorder=0, **kwargs)

#return P_c, P_p, Q_p

else:

# top and bottom

# rotate points list to a beginning

# (can rely on there being at most one contiguous

# region in each hemisphere)

switch_pt = np.nonzero(np.diff(top_hemisphere))[0][0] + 1

P_roll = np.roll(P_p, switch_pt, axis=0)

P_top_mask = np.roll(top_hemisphere, switch_pt, axis=0)

P_bot_mask = np.roll(bot_hemisphere, switch_pt, axis=0)

P_top = P_roll[P_top_mask]

P_bot = P_roll[P_bot_mask]

# flip top hemisphere

P_flipped = np.apply_along_axis(self.flip_hemisphere_polar,

1, P_top)

# convert to Lambert projection

Q_top = np.apply_along_axis(self.project_polar, 1,

P_flipped % (2 * np.pi))

Q_bot = np.apply_along_axis(self.project_polar, 1,

P_bot)

# plot each set of points

self.ax_top.plot(Q_top[..., psi], Q_top[..., rho],

symbol, color=color, zorder=0, **kwargs)

line = self.ax_bot.plot(Q_bot[..., psi], Q_bot[..., rho],

symbol, color=color, zorder=0, **kwargs)

plt.draw()

return line

#return P_c, P_p, P_top, P_bot, Q_top, Q_bot

# def plot_line(elf, array):

# '''

# Plot a line on the Lambert plot.

# Parameters

# ----------

# array : ndarray

# co-ordinates in xyz format, shape should be (npt, 3)

# '''

# # divide line into upper and lower hemispheres

# # interpolate point on circle edge, so that lines go to edges

# #

# def scale_axes(self):

# self.ax_top.set_rmax(np.sqrt(2.))

# self.ax_bot.set_rmax(np.sqrt(2.))

# def clear(self):

# self.ax_top.lines = []

# self.ax_bot.lines = []

# plt.draw()

# def savefig(self, filename):

'''Returns a point on a circle defined by two points on the circle, its

center, and the angle around the circle from the first point.

Parameters

----------

t : scalar

angle parameter around circle, starting at `a`

a : sequence, (3,)

x,y,z position of first pt on circle

b : sequence, (3,)

x,y,z position of second pt on circle

c : sequence, (3,)

x,y,z position of circle center

'''

r = np.sqrt(((a - c) ** 2).sum())

# u is unit vector from center to a

u = (a - c) / r

# n is unit normal to circle

n = np.cross(a - c, b - c)

len_n = np.sqrt((n**2).sum())

n /= len_n

'''Returns R, the resultant vector, of a collection of vectors.'''

S = np.sum(P_i, axis=0) # 3.2

R = np.sqrt(np.sum(S**2)) # 3.3

'''Calculates the mean direction of a set of unit vectors on a sphere.

Parameters

----------

P_i : array_like, shape (n_pts, 3)

n * x,y,z components of vectors

Returns

-------

vector : array_like, shape (3,)

x,y,z components of mean direction vector

'''

R, S = calc_R(P_i)

'''Returns the maximum likelihood estimate of the spread parameter (kappa)

of a von-Mises-Fisher distribution.

Parameters

----------

pts : array_like, shape (n, 3)

n unit vectors for which to find \kappa

mu : array_like, shape (3,)

vector of direction cosines for known population mean

Returns

-------

kappa : scalar

spread estimate for sample, assuming von-Mises-Fisher distribution

Notes

-----

Code is based on equations in Statistical Analysis of Spherical Data,

1987 by NI Fisher, T Lewis, and BJJ Embleton, section 5.3.2(iv).

coth(\kappa) - 1/\kappa = R/n

where R/n is the mean resultant vector.

In the case where the true mean direction is known, an improvement on the

above is to substitute R^* for R, where

R^* = RC

where C = \lambda\hat\lambda + \mu\hat\mu + v\hat{v}

where \lambda, \mu, and v are the mean direction cosines and those with a

hat are the sample statistic equivalents. Since this is the dot product

of (\lambda, \mu, v) and (\hat\lamda, \hat\mu, \hatv), C is the cosine of

the angle between the sample and population means.

Numbers in the code comments refer to equation numbers in the text.'''

n = P_i.shape[0]

R, S = calc_R(P_i)

#S = np.sum(P_i, axis=0) # 3.2

#R = np.sqrt(np.sum(S**2)) # 3.3

if mu != None:

sample_mean = S/R

C = np.dot(mu, sample_mean)

R *= C

k0 = 1.

lsq = opt.fmin_powell(to_min, k0, args=(R, n), disp=0)

'''Returns the probability density estimate for the von-Mises-Fisher function, for the 3d case, at the angle (th, ph), with mean (a, b), and spread k.

Equation is taken from Statistical Analysis of Spherical Data, 1987 by NI Fisher, T Lewis, and BJJ Embleton, equation 4.23

Parameters

----------

th : scalar

first angle for which to calculate h(theta)

ph : scalar

second angle for which to calculate h(theta)

a : scalar

first mean angle

b : scalar

second mean angle

k : scalar

spread parameter

'''

sin, cos, pi, sinh = np.sin, np.cos, np.pi, np.sinh

return C_F(k) * np.exp(k * (sin(th) * sin(a) * cos(ph - b)

'''Returns the probability density function for the

von-Mises-Fisher function, for the 3d case, at the angle theta.

Equation is taken from Statistical Analysis of Spherical Data,

1987 by NI Fisher, T Lewis, and BJJ Embleton, equation 4.23

Parameters

----------

theta : scalar

angle for which to calculate f(theta)

kappa : scalar

spread parameter

'''

'''Returns the value of the cumulative density function of the

von-Mises-Fisher function, 3d case, at angle theta.'''

theta = np.asarray(theta)

if theta.size > 1:

if np.rank(theta) > 1:

raise ValueError("theta should be at most 1d.")

cdf_list = [quad(vmf_pdf, 0, angle, args=(kappa))[0] for angle in theta]

cdf = np.array(cdf_list)

return cdf

else:

intgr, abserr = quad(vmf_pdf, 0, theta, args=(kappa))

#print abserr

'''Simulate a Fisher distribution. From Statistical Analysis of

Spherical Data, 1987, section 3.6.2'''

size = (n_pts, 2)

R = np.random.uniform(size=size)

R_0 = R[...,0]

R_1 = R[...,1]

l = np.exp(-2 * k)

colat = 2 * np.arcsin(np.sqrt(-np.log(R_0 * (1 - l) + l) / (2 * k)))

longit = 2 * np.pi * R_1

pts = convert_polar_to_cartesian(colat, longit)

#print mean_dir(pts.T)

alpha, beta = convert_cartesian_to_polar(mu)

assert (n >= 0)

if n > 12:

n = np.uint64(n)

'''from Stephens, 1962b, eqn 4'''

ss = np.arange(0, N / 2.)

rs = np.empty(ss.size)

for i, s in enumerate(ss):

rs[i] = (-1)**s * binomial_coef(N,s) * (lclip(N - R - 2 * s))**(N - 1)

result = rs.sum()

assert(~np.isnan(result))

Ro_low = 0

Ro_high = N

return opt.fminbound(prob_fn, Ro_low, Ro_high,

args=(N, Rstar, alpha))#, disp=0)

log = np.log

sqrt = np.sqrt

arccos = np.arccos

z = 2

n = P_i.shape[0]

R, S = calc_R(P_i)

if mu == None:

mu = S/R

#Rz = R * mu[z]

Rz = R

khat = estimate_kappa(P_i, mu=mu)

#print "khat %3f" % (khat)

if khat < 5:

if n <= 30:

R0 = calculate_R0(n, Rz, alpha)

theta_alpha = arccos(R0 / R)

elif (n > 8) & (n < 30):

if (Rz > 0) & (Rz < n/4.):

Ra1 = sqrt(Rz**2 - 2 / 3. * n * log( alpha ))

theta_alpha = arccos(Ra1 / R)

elif (Rz >= n/4.) and (Rz <= 3 * n / 5.):

Ra1 = sqrt(Rz**2 - 2 / 3. * n * log( alpha ))

astar = alpha**(1 / (n - 1))

Ra2 = n * (1 - astar) + Rz * astar

Ra = (Ra1 + Ra2) / 2.

theta_alpha = arccos(Ra / R)

else: # Rz > 3n/5

assert (Rz > (3 * n / 5))

astar = alpha**(1 / (n - 1))

Ra2 = n * (1 - astar) + Rz * astar

theta_alpha = arccos(Ra2 / R)

else: # n > 30

if verbose: print "-",

assert(n >= 30)

# !!!!!!!!!!!!!!!!!!!!!!!!

theta_alpha = arccos(1 + log(alpha)/(khat * R))

else: # khat >= 5

if verbose: print "*",

# !!!!!!!!!!!!!!!!!!!!!!!!

theta_alpha = arccos(1 - ((n - R) / R) *

((1 / alpha)**(1/float(n-1)) - 1))

'''calculates the (1 - alpha) * 100% confidence interval for the given

distribution of spherically distributed pts P_i

Parameters

----------

P_i : array, shape (n,3)

co-ordinates of n pts (x,y,z) in distribution

alpha : float

probability of acceptable alpha error

mu : array_like, shape (3,)

mean direction of distribution, in event it is known a priori of

variates

Returns

-------

theta_alpha : float

angle from the mean vector describing confidence cone'''

z = 2

n = P_i.shape[0]

R, S = calc_R(P_i)

if mu == None:

mu = S/R

Rz = R * mu[z]

# n <= 8 find R^0_{1-\alpha}

R0z = calculate_R0(n, Rz, alpha)

print "Rz=%f, R0z=%f" % (Rz, R0z)

theta_alpha = np.arccos(R0z / R)

'''

Creates a random distribution with large `n` and dispersion `kappa`,

and finds the angle that encompasses `confid` * 100% of the pts.

Parameters

----------

kappa : float

dispersion parameter of points

percentile : float

proportion of points to include inside angle

n_pts : int

number of points to create in distribution

Returns

-------

theta_percentile : float

angle that encompasses `percentile` * 100% of points `P_i`

Notes

-----

In this case I think theta_alpha does not depend on n, so it is best

to estimate with a large n for better accuracy.

'''

perpvec = np.array((0., 0., 1.))

P_i = vmf_rvs(perpvec, kappa, n_pts=n_pts)

'''

Find the angle that encompasses percentile * 100% of the pts in `P_i`.

Parameters

----------

P_i : array_like, shape (n_pts, 3)

x,y,z vectors of unit length points on a sphere

percentile : float

proportion of points to include inside angle

Returns

-------

theta_percentile : float

angle that encompasses `percentile` * 100% of points `P_i`

'''

# find angles between sample mean and each pt

muhat = mean_dir(P_i)

angles_to_mean = np.arccos(np.dot(muhat, P_i.T))

# take percentile of angles

sort_idxs = np.argsort(angles_to_mean)

sorted_angles = angles_to_mean[sort_idxs]

n_pts = P_i.shape[0]

pc_pts = np.arange(1, n_pts+1) / float(n_pts)

#... percentiles of each sorted pt

pt_below = np.nonzero(pc_pts < percentile)[0][-1]

pt_above = np.nonzero(pc_pts > percentile)[0][0]

pc_below = pc_pts[pt_below]

pc_above = pc_pts[pt_above]

theta_below = sorted_angles[pt_below]

theta_above = sorted_angles[pt_above]

# now weight two angles by how close they are to confid

#- i.e. linearly interpolate between them

theta_percentile = ((percentile - pc_below) * theta_above + \

(pc_above - percentile) * theta_below) / \

(pc_above - pc_below)