def SqrtMean(gam):
"""
calculates the srsf of warping functions with corresponding shooting vectors
:param gam: numpy ndarray of shape (M,N) of M warping functions
with N samples
:rtype: 2 numpy ndarray and vector
:return mu: Karcher mean psi function
:return gam_mu: vector of dim N which is the Karcher mean warping function
:return psi: numpy ndarray of shape (M,N) of M SRSF of the warping functions
:return vec: numpy ndarray of shape (M,N) of M shooting vectors
"""
(T,n) = gam.shape
time = linspace(0,1,T)
binsize = mean(diff(time))
psi = zeros((T, n))
for k in range(0, n):
psi[:, k] = sqrt(gradient(gam[:, k],binsize))
# Find Direction
mnpsi = psi.mean(axis=1)
a = mnpsi.repeat(n)
d1 = a.reshape(T, n)
d = (psi - d1) ** 2
dqq = sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
mu = psi[:, min_ind]
maxiter = 501
tt = 1
lvm = zeros(maxiter)
vec = zeros((T, n))
stp = .3
itr = 0
for i in range(0,n):
out, theta = geo.inv_exp_map(mu,psi[:,i])
vec[:,i] = out
vbar = vec.mean(axis=1)
lvm[itr] = geo.L2norm(vbar)
while (lvm[itr] > 0.00000001) and (itr<maxiter):
mu = geo.exp_map(mu, stp*vbar)
itr += 1
for i in range(0,n):
out, theta = geo.inv_exp_map(mu,psi[:,i])
vec[:,i] = out
vbar = vec.mean(axis=1)
lvm[itr] = geo.L2norm(vbar)
gam_mu = cumtrapz(mu*mu, time, initial=0)
gam_mu = (gam_mu - gam_mu.min()) / (gam_mu.max() - gam_mu.min())
return mu, gam_mu, psi, vec
def SqrtMedian(gam):
"""
calculates the median srsf of warping functions with corresponding shooting vectors
:param gam: numpy ndarray of shape (M,N) of M warping functions
with N samples
:rtype: 2 numpy ndarray and vector
:return gam_median: Karcher median warping function
:return psi_meidan: vector of dim N which is the Karcher median srsf function
:return psi: numpy ndarray of shape (M,N) of M SRSF of the warping functions
:return vec: numpy ndarray of shape (M,N) of M shooting vectors
"""
(T, n) = gam.shape
time = linspace(0, 1, T)
# Initialization
psi_median = ones(T)
r = 1
stp = 0.3
maxiter = 501
vbar_norm = zeros(maxiter + 1)
# compute psi function
binsize = mean(diff(time))
psi = zeros((T, n))
v = zeros((T, n))
vtil = zeros((T, n))
d = zeros(n)
dtil = zeros(n)
for k in range(0, n):
psi[:, k] = sqrt(gradient(gam[:, k], binsize))
v[:, k], d[k] = geo.inv_exp_map(psi_median, psi[:, k])
vtil[:, k] = v[:, k] / d[k]
dtil[k] = 1 / d[k]
vbar = vtil.sum(axis=1) * dtil.sum()**(-1)
vbar_norm[r] = geo.L2norm(vbar)
# compute phase median by iterative algorithm
while (vbar_norm[r] > 0.00000001) and (r < maxiter):
psi_median = geo.exp_map(psi_median, stp * vbar)
r += 1
for k in range(0, n):
v[:, k], tmp = geo.inv_exp_map(psi_median, psi[:, k])
d[k] = arccos(geo.inner_product(psi_median, psi[:, k]))
vtil[:, k] = v[:, k] / d[k]
dtil[k] = 1 / d[k]
vbar = vtil.sum(axis=1) * dtil.sum()**(-1)
vbar_norm[r] = geo.L2norm(vbar)
vec = v
gam_median = cumtrapz(psi_median**2, time, initial=0.0)
return gam_median, psi_median, psi, vec
def SqrtMeanInverse(gam):
"""
finds the inverse of the mean of the set of the diffeomorphisms gamma
:param gam: numpy ndarray of shape (M,N) of M warping functions
with N samples
:rtype: vector
:return gamI: inverse of gam
"""
(T,n) = gam.shape
time = linspace(0,1,T)
binsize = mean(diff(time))
psi = zeros((T, n))
for k in range(0, n):
psi[:, k] = sqrt(gradient(gam[:, k],binsize))
# Find Direction
mnpsi = psi.mean(axis=1)
a = mnpsi.repeat(n)
d1 = a.reshape(T, n)
d = (psi - d1) ** 2
dqq = sqrt(d.sum(axis=0))
min_ind = dqq.argmin()
mu = psi[:, min_ind]
maxiter = 501
tt = 1
lvm = zeros(maxiter)
vec = zeros((T, n))
stp = .3
itr = 0
for i in range(0,n):
out, theta = geo.inv_exp_map(mu,psi[:,i])
vec[:,i] = out
vbar = vec.mean(axis=1)
lvm[itr] = geo.L2norm(vbar)
while (lvm[itr] > 0.00000001) and (itr<maxiter):
mu = geo.exp_map(mu, stp*vbar)
itr += 1
for i in range(0,n):
out, theta = geo.inv_exp_map(mu,psi[:,i])
vec[:,i] = out
vbar = vec.mean(axis=1)
lvm[itr] = geo.L2norm(vbar)
gam_mu = cumtrapz(mu*mu, time, initial=0)
gam_mu = (gam_mu - gam_mu.min()) / (gam_mu.max() - gam_mu.min())
gamI = invertGamma(gam_mu)
return gamI
