def geodistance_cp(lng1, lat1, lng2, lat2):
lng1, lat1, lng2, lat2 = map(cp.radians, [lng1, lat1, lng2, lat2])
dlon = lng2 - lng1
dlat = lat2 - lat1
a = cp.sin(dlat / 2)**2 + cp.cos(lat1) * cp.cos(lat2) * cp.sin(dlon / 2)**2
dis = 2 * cp.arcsin(cp.sqrt(a)) * 6371 * 1000
return dis
def HaversineLocal(busMatrix, lineMatrix, haversine=True):
MatrizOnibus = cp.copy(busMatrix)
MatrizLinhas = cp.copy(lineMatrix)
MatrizLinhas = cp.dsplit(MatrizLinhas, 2)
MatrizOnibus = cp.dsplit(MatrizOnibus, 2)
infVector = cp.squeeze(cp.sum(cp.isnan(MatrizLinhas[0]), axis=1), axis=-1)
MatrizLinhas[0] = cp.expand_dims(MatrizLinhas[0], axis=-1)
MatrizLinhas[1] = cp.expand_dims(MatrizLinhas[1], axis=-1)
MatrizOnibus[0] = cp.expand_dims(MatrizOnibus[0], axis=-1)
MatrizOnibus[1] = cp.expand_dims(MatrizOnibus[1], axis=-1)
MatrizOnibus[0] *= cp.pi / 180
MatrizOnibus[1] *= cp.pi / 180
MatrizLinhas[1] = cp.transpose(MatrizLinhas[1], [2, 3, 0, 1]) * cp.pi / 180
MatrizLinhas[0] = cp.transpose(MatrizLinhas[0], [2, 3, 0, 1]) * cp.pi / 180
# Haversine or euclidian, based on <haversine>
if haversine:
results = 1000*2*6371.0088*cp.arcsin(
cp.sqrt(
(cp.sin((MatrizOnibus[0] - MatrizLinhas[0])*0.5)**2 + \
cp.cos(MatrizOnibus[0])* cp.cos(MatrizLinhas[0]) * cp.sin((MatrizOnibus[1] - MatrizLinhas[1])*0.5)**2)
))
else:
results = cp.sqrt((MatrizOnibus[0] - MatrizLinhas[0])**2 +
(MatrizOnibus[1] - MatrizLinhas[1])**2)
return results, infVector
def exactFilter(tilt_angles, tiltAngle, sX, sY, sliceWidth, arr=[]):
"""
exactFilter: Generates the exact weighting function required for weighted backprojection - y-axis is tilt axis
Reference : Optik, Exact filters for general geometry three dimensional reconstuction, vol.73,146,1986.
@param tilt_angles: list of all the tilt angles in one tilt series
@param titlAngle: tilt angle for which the exact weighting function is calculated
@param sizeX: size of weighted image in X
@param sizeY: size of weighted image in Y
@return: filter volume
"""
from cupy import array, matrix, sin, pi, arange, float32, column_stack, argmin, clip, ones, ceil
# Using Friedel Symmetry in Fourier space.
# sY = sY // 2 + 1
# Calculate the relative angles in radians.
diffAngles = (array(tilt_angles) - tiltAngle) * pi / 180.
# Closest angle to tiltAngle (but not tiltAngle) sets the maximal frequency of overlap (Crowther's frequency).
# Weights only need to be calculated up to this frequency.
sampling = min(abs(diffAngles)[abs(diffAngles) > 0.001])
crowtherFreq = min(sX // 2, int(ceil(1 / sin(sampling))))
arrCrowther = matrix(abs(arange(-crowtherFreq, min(sX // 2, crowtherFreq + 1))))
# Calculate weights
wfuncCrowther = 1. / (clip(1 - array(matrix(abs(sin(diffAngles))).T * arrCrowther) ** 2, 0, 2)).sum(axis=0)
# Create full with weightFunc
wfunc = ones((sX, sY, 1), dtype=float32)
wfunc[sX // 2 - crowtherFreq:sX // 2 + min(sX // 2, crowtherFreq + 1), :, 0] = column_stack(
([(wfuncCrowther), ] * (sY))).astype(float32)
return wfunc
def unit_vectors(direction, return_numpy=True):
"""
Calculate the unit vectors (UnitX, UnitY) from a given direction angle.
Args:
direction: 3D NumPy array - direction angles in degrees
return_numpy: Necessary if using `use_gpu`. Specifies if a CuPy or Numpy
array will be returned.
Returns:
UnitX, UnitY: 3D NumPy array, 3D NumPy array
x- and y-vector component in arrays
"""
direction_gpu = cupy.array(direction)
direction_gpu_rad = cupy.deg2rad(direction_gpu)
UnitX = -cupy.sin(0.5 * cupy.pi) * cupy.cos(direction_gpu_rad)
UnitY = cupy.sin(0.5 * cupy.pi) * cupy.sin(direction_gpu_rad)
del direction_gpu_rad
UnitX[cupy.isclose(direction_gpu, -1)] = 0
UnitY[cupy.isclose(direction_gpu, -1)] = 0
del direction_gpu
if return_numpy:
return UnitX.get(), UnitY.get()
return UnitX, UnitY
def ripple(x, y, z, t):
f = cp.sin(x + t / 5) + cp.sin(y + t / 5)
r = cp.abs(z - f) < 0.2
f = cp.cos(x + t / 5) + cp.cos(y + t / 5)
g = cp.abs(z - f) < 0.2
b = g * 0
return r * 10, g * 10, b
def latlong2osgbgrid_cupy(lat, long, input_degrees=True):
'''
Converts latitude and longitude (ellipsoidal) coordinates into northing and easting (grid) coordinates, using a Transverse Mercator projection.
Inputs:
lat: latitude coordinate (north)
long: longitude coordinate (east)
input_degrees: if True (default), interprets the coordinates as degrees; otherwise, interprets coordinates as radians
Output:
(northing, easting)
'''
if input_degrees:
lat = lat * cp.pi / 180
long = long * cp.pi / 180
a = 6377563.396
b = 6356256.909
e2 = (a**2 - b**2) / a**2
N0 = -100000 # northing of true origin
E0 = 400000 # easting of true origin
F0 = .9996012717 # scale factor on central meridian
phi0 = 49 * cp.pi / 180 # latitude of true origin
lambda0 = -2 * cp.pi / 180 # longitude of true origin and central meridian
sinlat = cp.sin(lat)
coslat = cp.cos(lat)
tanlat = cp.tan(lat)
latdiff = lat - phi0
longdiff = long - lambda0
n = (a - b) / (a + b)
nu = a * F0 * (1 - e2 * sinlat**2)**-.5
rho = a * F0 * (1 - e2) * (1 - e2 * sinlat**2)**-1.5
eta2 = nu / rho - 1
M = b * F0 * (
(1 + n + 5 / 4 * (n**2 + n**3)) * latdiff -
(3 *
(n + n**2) + 21 / 8 * n**3) * cp.sin(latdiff) * cp.cos(lat + phi0) +
15 / 8 * (n**2 + n**3) * cp.sin(2 * (latdiff)) * cp.cos(2 *
(lat + phi0)) -
35 / 24 * n**3 * cp.sin(3 * (latdiff)) * cp.cos(3 * (lat + phi0)))
I = M + N0
II = nu / 2 * sinlat * coslat
III = nu / 24 * sinlat * coslat**3 * (5 - tanlat**2 + 9 * eta2)
IIIA = nu / 720 * sinlat * coslat**5 * (61 - 58 * tanlat**2 + tanlat**4)
IV = nu * coslat
V = nu / 6 * coslat**3 * (nu / rho - cp.tan(lat)**2)
VI = nu / 120 * coslat**5 * (5 - 18 * tanlat**2 + tanlat**4 + 14 * eta2 -
58 * tanlat**2 * eta2)
northing = I + II * longdiff**2 + III * longdiff**4 + IIIA * longdiff**6
easting = E0 + IV * longdiff + V * longdiff**3 + VI * longdiff**5
return (northing, easting)
def helix2(x, y, z, t):
R = 2
t *= -1
z2 = z + cp.sin(3 * z) + (t + cp.sin(t / 10)) / 5
x2 = R * cp.sin(z2)
y2 = R * cp.cos(z2)
dist = (x - x2)**2 + (y - y2)**2
g = dist < 1
return g * 2, g * 10, g * 5
def wave_tiles(x, y, z, t):
tile_size = 2
floor_x, floor_y = cp.floor(x / tile_size), cp.floor(y / tile_size)
red_tiles = ((floor_x + floor_y) % 2) < 1
tile_height = .5 * (cp.sin(floor_x + t / 10) + cp.sin(floor_y + t / 10))
tile_mask = (z < tile_height) & (z > tile_height - 1)
blue_tiles = ~red_tiles & tile_mask
red_tiles = red_tiles & tile_mask
return red_tiles * 5, 0 * red_tiles, blue_tiles * 5
def chalice(x, y, z, t):
r = cp.sqrt(x**2 + y**2)
foot = (r < 2) & (z < .5 - r / 2) & (z > 0)
stem = (r < .15) & (z > 0) & (z < 3)
cup = (z > r**2 + 3) & (z < (r + .1)**2 + 3) & (r < 2)
liquid = (z > (r + .1)**2 + 3) & (
z < r**2 * 0.5 + 5 + .1 *
(cp.sin(r * 2 * 4 + t / 4) + cp.sin(x + y + t / 3))) & (r < 2)
return liquid * 8, foot * 10 + stem * 10 + cup * 10, liquid * 4
def helix(x, y, z, t):
R = 3
z2 = z + cp.sin(-2 * z) + (t + cp.sin(t / 10)) / 5
x2 = R * cp.cos(z2)
y2 = R * cp.sin(z2)
dist = (x - x2)**2 + (y - y2)**2
r = (dist < 1)
g = r * 0
b = g
return r * 10, g, b
def rotate(x, theta, reverse=False):
"""Rotate coordinates with respect to the angle theta
"""
R = cp.array([[cp.cos(theta), -cp.sin(theta)],
[cp.sin(theta), cp.cos(theta)]])
if (reverse):
R = R.swapaxes(0, 1)
xr = cp.zeros(x.shape, dtype='float32')
xr[:, 0] = R[1, 0] * x[:, 1] + R[1, 1] * x[:, 0]
xr[:, 1] = R[0, 0] * x[:, 1] + R[0, 1] * x[:, 0]
return xr
def getparameters(beta, dtheta, ds, N, Nproj):
aR = cp.sin(beta / 2) / (1 + cp.sin(beta / 2))
am = (cp.cos(beta / 2) - cp.sin(beta / 2)) / (1 + cp.sin(beta / 2))
# wrapping
g = osg(aR, beta / 2)
Ntheta = N
Nrho = 2 * N
dtheta = (2 * beta) / Ntheta
drho = (g - cp.log(am)) / Nrho
return (Nrho, Ntheta, dtheta, drho, aR, am, g)
def beach(x, y, z, t):
sun = 10 * (((x - 10)**2 + y**2 + (z - 5)**2) < 2)
sky = z > -1
water_freq = .1
sand = ((x < 0) & (z < cp.abs(x) / 100)) | ((x >= 0) & (z < -x**2 / 100))
water = (x > 2 * cp.sin(y / 4 + .25 * cp.sin(t * water_freq / 2))
) * ~sand * (z < .15 * (cp.sin(t * water_freq) - 1))
depths = z / 100 * sand + z / 10 * water
return (sand + depths + sky / 2 + sun,
sand + water + depths + sky / 20 + sun * .75,
water * 15 + depths * 5 + sky / 2)
def bars(x, y, z, t):
w = 1
h = 1
R = 3
f = .125
r = (x % R < w) & (y % 4 > R - h) & (z / 2 + 1 < cp.sin(
f * cp.ceil(x / R) * cp.ceil(y / R) * t / 100))
g = (x % R < w) & (y % 4 > R - h) & (z / 2 + 1 < cp.sin(
f * cp.ceil(x / R) * cp.ceil(y / R) * t / 100))
b = (x % R < w) & (y % 4 > R - h) & (z / 2 + 1 < cp.sin(
f * cp.ceil(x / R) * cp.ceil(y / R) * t / 100))
return r * 20, g * 3 - z / 10, b * 20
def create_fwd(P):
# convolution function
fZ = cp.fft.fftshift(fzeta_loop_weights(
P.Ntheta, P.Nrho, 2*P.beta, P.g-cp.log(P.am), 0, 4))
# (lp2C1,lp2C2), transformed log-polar to Cartesian coordinates
tmp1 = cp.outer(cp.exp(cp.array(P.rhosp)), cp.cos(cp.array(P.thsp))).flatten()
tmp2 = cp.outer(cp.exp(cp.array(P.rhosp)), cp.sin(cp.array(P.thsp))).flatten()
lp2C1 = [None]*P.Nspan
lp2C2 = [None]*P.Nspan
for k in range(P.Nspan):
lp2C1[k] = ((tmp1-(1-P.aR))*cp.cos(k*P.beta+P.beta/2) -
tmp2*cp.sin(k*P.beta+P.beta/2))/P.aR
lp2C2[k] = ((tmp1-(1-P.aR))*cp.sin(k*P.beta+P.beta/2) +
tmp2*cp.cos(k*P.beta+P.beta/2))/P.aR
lp2C2[k] *= (-1) # adjust for Tomopy
cids = cp.where((lp2C1[k]**2+lp2C2[k]**2) <= 1)[0]
lp2C1[k] = lp2C1[k][cids]
lp2C2[k] = lp2C2[k][cids]
# pids, index in polar grids after splitting by spans
pids = [None]*P.Nspan
[s0, th0] = cp.meshgrid(P.s, P.proj)
th0 = th0.flatten()
s0 = s0.flatten()
for k in range(0, P.Nspan):
pids[k] = cp.where((th0 >= k*P.beta-P.beta/2) &
(th0 < k*P.beta+P.beta/2))[0]
# (p2lp1,p2lp2), transformed polar to log-polar coordinates
p2lp1 = [None]*P.Nspan
p2lp2 = [None]*P.Nspan
for k in range(P.Nspan):
th00 = th0[pids[k]]-k*P.beta
s00 = s0[pids[k]]
p2lp1[k] = th00
p2lp2[k] = np.log(s00*P.aR+(1-P.aR)*np.cos(th00))
# adapt for gpu interp
for k in range(0, P.Nspan):
lp2C1[k] = (lp2C1[k]+1)/2*(P.N-1)
lp2C2[k] = (lp2C2[k]+1)/2*(P.N-1)
p2lp1[k] = (p2lp1[k]-P.thsp[0])/(P.thsp[-1]-P.thsp[0])*(P.Ntheta-1)
p2lp2[k] = (p2lp2[k]-P.rhosp[0])/(P.rhosp[-1]-P.rhosp[0])*(P.Nrho-1)
const = cp.sqrt(P.N*P.osangles/P.Nproj)*cp.pi/4 / \
P.aR/cp.sqrt(2) # adjust constant
fZgpu = fZ[:, :P.Ntheta//2+1]*const
if(P.interp_type == 'cubic'):
fZgpu = fZgpu/(P.B3com[:, :P.Ntheta//2+1])
Pfwd0 = Pfwd(fZgpu, lp2C1, lp2C2, p2lp1, p2lp2, cids, pids)
# array representation
parsi, parsf = savePfwdpars(Pfwd0)
return Pfwd0, parsi, parsf
def nonlin_evo(psiP2, psiP1, psi0, psiM1, psiM2, c0, c2, c4, V, p, dt, spin_f):
# Calculate densities:
n = abs(psiP2) ** 2 + abs(psiP1) ** 2 + abs(psi0) ** 2 + abs(psiM1) ** 2 + abs(psiM2) ** 2
A00 = 1 / cp.sqrt(5) * (psi0 ** 2 - 2 * psiP1 * psiM1 + 2 * psiP2 * psiM2)
fz = 2 * (abs(psiP2) ** 2 - abs(psiM2) ** 2) + abs(psiP1) ** 2 - abs(psiM1) ** 2
# Evolve spin-singlet term -c4*(n^2-|alpha|^2)
S = cp.sqrt(n ** 2 - abs(A00) ** 2)
S = cp.nan_to_num(S)
cosT = cp.cos(c4 * S * dt)
sinT = cp.sin(c4 * S * dt) / S
sinT[S == 0] = 0 # Corrects division by 0
Wfn = [psiP2 * cosT + 1j * (n * psiP2 - A00 * cp.conj(psiM2)) * sinT,
psiP1 * cosT + 1j * (n * psiP1 + A00 * cp.conj(psiM1)) * sinT,
psi0 * cosT + 1j * (n * psi0 - A00 * cp.conj(psi0)) * sinT,
psiM1 * cosT + 1j * (n * psiM1 + A00 * cp.conj(psiP1)) * sinT,
psiM2 * cosT + 1j * (n * psiM2 - A00 * cp.conj(psiP2)) * sinT]
# Calculate spin vectors
fp = cp.sqrt(6) * (Wfn[1] * cp.conj(Wfn[2]) + Wfn[2] * cp.conj(Wfn[3])) + 2 * (Wfn[3] * cp.conj(Wfn[4]) +
Wfn[0] * cp.conj(Wfn[1]))
F = cp.sqrt(fz ** 2 + abs(fp) ** 2)
# Calculate cos, sin and Qfactor terms:
C1, S1 = cp.cos(c2 * F * dt), cp.sin(c2 * F * dt)
C2, S2 = cp.cos(2 * c2 * F * dt), cp.sin(2 * c2 * F * dt)
Qfactor = 1j * (-4 / 3 * S1 + 1 / 6 * S2)
Q2factor = (-5 / 4 + 4 / 3 * C1 - 1 / 12 * C2)
Q3factor = 1j * (1 / 3 * S1 - 1 / 6 * S2)
Q4factor = (1 / 4 - 1 / 3 * C1 + 1 / 12 * C2)
fzQ = cp.nan_to_num(fz / F)
fpQ = cp.nan_to_num(fp / F)
Qpsi = calc_Qpsi(fzQ, fpQ, Wfn)
Q2psi = calc_Qpsi(fzQ, fpQ, Qpsi)
Q3psi = calc_Qpsi(fzQ, fpQ, Q2psi)
Q4psi = calc_Qpsi(fzQ, fpQ, Q3psi)
# Evolve spin term c2 * F^2
for ii in range(len(Wfn)):
Wfn[ii] += Qfactor * Qpsi[ii] + Q2factor * Q2psi[ii] + Q3factor * Q3psi[ii] + Q4factor * Q4psi[ii]
# Evolve (c0+c4)*n^2 + (V + pm)*n:
for ii in range(len(Wfn)):
mF = spin_f - ii
Wfn[ii] *= cp.exp(-1j * dt * ((c0 + c4) * n + V + p * mF))
return Wfn
def run_cupy(lat2, lon2):
import cupy as cp
# Allocate temporary arrays
size = len(lat2)
a = cp.empty(size, dtype='float64')
dlat = cp.empty(size, dtype='float64')
dlon = cp.empty(size, dtype='float64')
# Transfer inputs to the GPU
lat2 = cp.array(lat2)
lon2 = cp.array(lon2)
# Begin computation
lat1 = 0.70984286
lon1 = 1.23892197
MILES_CONST = 3959.0
cp.subtract(lat2, lat1, out=dlat)
cp.subtract(lon2, lon1, out=dlon)
# dlat = sin(dlat / 2.0) ** 2.0
cp.divide(dlat, 2.0, out=dlat)
cp.sin(dlat, out=dlat)
cp.multiply(dlat, dlat, out=dlat)
# a = cos(lat1) * cos(lat2)
lat1_cos = math.cos(lat1)
cp.cos(lat2, out=a)
cp.multiply(a, lat1_cos, out=a)
# a = a + sin(dlon / 2.0) ** 2.0
cp.divide(dlon, 2.0, out=dlon)
cp.sin(dlon, out=dlon)
cp.multiply(dlon, dlon, out=dlon)
cp.multiply(a, dlon, out=a)
cp.add(dlat, a, out=a)
c = a
cp.sqrt(a, out=a)
cp.arcsin(a, out=a)
cp.multiply(a, 2.0, out=c)
mi = c
cp.multiply(c, MILES_CONST, out=mi)
# Transfer outputs back to CPU
a = cp.asnumpy(a)
return a
def random_in_unit_sphere():
u = random_float()
v = random_float()
theta = u * 2 * cp.pi
phi = cp.arccos(2 * v - 1)
r = cp.cbrt(random_float())
sinTheta = cp.sin(theta)
cosTheta = cp.cos(theta)
sinPhi = cp.sin(phi)
cosPhi = cp.cos(phi)
x = r * sinPhi * cosTheta
y = r * sinPhi * sinTheta
z = r * cosPhi
return Vec3(x, y, z)
def rotshift3D_spline(v, phi=0, shifts=np.array([0,0,0]), mode='wrap'):
# With a nod to:
# http://stackoverflow.com/questions/20161175/how-can-i-use-scipy-ndimage-interpolation-affine-transform-to-rotate-an-image-ab
rot_origin = 0.5*np.array(v.shape)
rot_rad = -phi*np.pi/180.0
rot_matrix = np.array([[np.cos(rot_rad), np.sin(rot_rad), 0],
[-np.sin(rot_rad),np.cos(rot_rad), 0],
[0 , 0 , 1]])
offset = -(rot_origin-rot_origin.dot(rot_matrix)).dot(np.linalg.inv(rot_matrix))
offset = offset - shifts
transformed_v = ndimage.interpolation.affine_transform(v,rot_matrix,offset=offset,mode=mode)
return transformed_v
def apply(self, helper, qubits, targets):
n_qubits = helper["n_qubits"]
i = helper["indices"]
theta = self.theta
for target in slicing(targets, n_qubits):
newq = cupy.zeros_like(qubits)
newq[(i & (1 << target)) == 0] = (
cupy.cos(theta / 2) * qubits[(i & (1 << target)) == 0] +
-cupy.sin(theta / 2) * qubits[(i & (1 << target)) != 0])
newq[(i & (1 << target)) != 0] = (
cupy.sin(theta / 2) * qubits[(i & (1 << target)) == 0] +
cupy.cos(theta / 2) * qubits[(i & (1 << target)) != 0])
qubits = newq
return qubits
def random_in_unit_sphere_list(size: int) -> Vec3List:
u = random_float_list(size)
v = random_float_list(size)
theta = u * 2 * cp.pi
phi = cp.arccos(2 * v - 1)
r = cp.cbrt(random_float_list(size))
sinTheta = cp.sin(theta)
cosTheta = cp.cos(theta)
sinPhi = cp.sin(phi)
cosPhi = cp.cos(phi)
x = r * sinPhi * cosTheta
y = r * sinPhi * sinTheta
z = r * cosPhi
return Vec3List(cp.transpose(cp.array([x, y, z])))
def sin(a, cuda=False):
if cuda:
res = cp.sin(a)
cp.cuda.Stream.null.synchronize()
return res
else:
return np.sin(a)
def sin_ac(z):
if (cupy_ready and (z.size > 40000) and (z.size <= gpu_array_max_size)):
z_gpu = cp.asarray(z)
r_gpu = cp.sin(z_gpu)
return cp.asnumpy(r_gpu)
else:
return np.sin(z)
def jackson(
num_moments,
precision=32,
):
"""
This function generates the Jackson kernel for a given number of
Chebyscev moments
Parameters
----------
num_moments: (uint)
number of Chebyshev moments
Return
------
jackson_kernel: cupy array(shape=(num_moments,), dtype=tf_float)
Note
----
See .. _The Kernel Polynomial Method:
https://arxiv.org/pdf/cond-mat/0504627.pdf for more details
"""
cp_float = cp.float64
if precision == 32:
cp_float = cp.float32
kernel_moments = cp.arange(num_moments, dtype=cp_float)
norm = cp.pi / (num_moments + 1)
phase_vec = norm * kernel_moments
kernel = (num_moments - kernel_moments + 1) * cp.cos(phase_vec)
kernel = kernel + cp.sin(phase_vec) / cp.tan(norm)
kernel = kernel / (num_moments + 1)
return kernel
def _sin_flow_gen(image0, max_motion=4.5, npics=5):
"""Generate a synthetic ground truth optical flow with a sinusoid as
first component.
Parameters:
----
image0: ndarray
The base image to be warped.
max_motion: float
Maximum flow magnitude.
npics: int
Number of sinusoid pics.
Returns
-------
flow, image1 : ndarray
The synthetic ground truth optical flow with a sinusoid as
first component and the corresponding warped image.
"""
grid = cp.meshgrid(*[cp.arange(n) for n in image0.shape], indexing='ij')
grid = cp.stack(grid)
# TODO: make upstream scikit-image PR changing gt_flow dtype to float
gt_flow = cp.zeros_like(grid, dtype=float)
gt_flow[0,
...] = max_motion * cp.sin(grid[0] / grid[0].max() * npics * np.pi)
image1 = warp(image0, grid - gt_flow, mode="nearest")
return gt_flow, image1
def _log_polar_mapping(output_coords, k_angle, k_radius, center):
"""Inverse mapping function to convert from Cartesian to polar coordinates
Parameters
----------
output_coords : ndarray
`(M, 2)` array of `(col, row)` coordinates in the output image
k_angle : float
Scaling factor that relates the intended number of rows in the output
image to angle: ``k_angle = nrows / (2 * np.pi)``
k_radius : float
Scaling factor that relates the radius of the circle bounding the
area to be transformed to the intended number of columns in the output
image: ``k_radius = width / math.log(radius)``
center : tuple (row, col)
Coordinates that represent the center of the circle that bounds the
area to be transformed in an input image.
Returns
-------
coords : ndarray
`(M, 2)` array of `(col, row)` coordinates in the input image that
correspond to the `output_coords` given as input.
"""
angle = output_coords[:, 1] / k_angle
rr = ((cp.exp(output_coords[:, 0] / k_radius)) * cp.sin(angle)) + center[0]
cc = ((cp.exp(output_coords[:, 0] / k_radius)) * cp.cos(angle)) + center[1]
coords = cp.column_stack((cc, rr))
return coords
def mixed_matrix(grid_steps, grid_step_size, subtraction_trick):
"""
Calculate a magical matrix that solves the Helmholtz or Laplace equation
(subtraction_trick=True and subtraction_trick=False correspondingly)
if you elementwise-multiply the RHS by it "in DST-DCT-transformed-space".
See Samarskiy-Nikolaev, p. 189 and around.
"""
# mul[i, j] = 1 / (lam[i] + lam[j])
# lam[k] = 4 / h**2 * sin(k * pi * h / (2 * L))**2, where L = h * (N - 1)
# but k for lam_i spans from 1..N-2, while k for lam_j covers 0..N-1
ki, kj = cp.arange(1, grid_steps - 1), cp.arange(grid_steps)
li = 4 / grid_step_size**2 * cp.sin(ki * cp.pi / (2 * (grid_steps - 1)))**2
lj = 4 / grid_step_size**2 * cp.sin(kj * cp.pi / (2 * (grid_steps - 1)))**2
lambda_i, lambda_j = li[:, None], lj[None, :]
mul = 1 / (lambda_i + lambda_j + (1 if subtraction_trick else 0))
return mul / (2 * (grid_steps - 1))**2 # additional 2xDST normalization
def setRandomMagnetization(self):
"""
Set initial magnetization to a random state.
"""
self.thetaM0 = np.random.uniform(0, 180, size=self.mask.shape)
self.phiM0 = np.random.uniform(0, 360, size=self.mask.shape)
thetaM0_ = self.thetaM0 * degree
phiM0_ = self.phiM0 * degree
self.mx = np.zeros(shape=(self.mask.shape))
self.my = np.zeros(shape=(self.mask.shape))
self.mz = np.zeros(shape=(self.mask.shape))
self.mx = self.mask * np.sin(thetaM0_) * np.cos(phiM0_)
self.my = self.mask * np.sin(thetaM0_) * np.sin(phiM0_)
self.mz = self.mask * np.cos(thetaM0_)
def sphere(self, n, diameter=None):
if n is None:
dia = diameter
else:
dia = self.sphere_dia[n]
s = cp.pi * self.rad * dia / self.size
s[s == 0] = 1.e-5
return ((cp.sin(s) - s * cp.cos(s)) / s**3).ravel()
def test_denoise_tv_chambolle_1d():
"""Apply the TV denoising algorithm on a 1D sinusoid."""
x = 125 + 100 * cp.sin(cp.linspace(0, 8 * cp.pi, 1000))
x += 20 * cp.random.rand(x.size)
x = cp.clip(x, 0, 255)
res = restoration.denoise_tv_chambolle(x.astype(np.uint8), weight=0.1)
assert res.dtype == float
assert res.std() * 255 < x.std()
def testGetstateSetstate(self):
nDims = 32 # need multiple of 8, because of sse
nClass = 4
size = 20
labels = _RGEN.random_integers(0, nClass - 1, size)
samples = np.zeros((size, nDims), dtype=_DTYPE)
centers = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for i in range(0, size):
t = 6.28 * _RGEN.random_sample()
samples[i][0] = 2 * centers[labels[i]][0] + 0.5*_RGEN.rand() * np.cos(t)
samples[i][1] = 2 * centers[labels[i]][1] + 0.5*_RGEN.rand() * np.sin(t)
classifier = svm_dense(0, nDims, seed=_SEED, probability = True)
for y, xList in zip(labels, samples):
x = np.array(xList, dtype=_DTYPE)
classifier.add_sample(float(y), x)
classifier.train(gamma=1.0/3.0, C=100, eps=1e-1)
classifier.cross_validate(2, gamma=0.5, C=10, eps=1e-3)
s1 = classifier.__getstate__()
h1 = hashlib.md5(s1).hexdigest()
classifier2 = svm_dense(0, nDims)
classifier2.__setstate__(s1)
s2 = classifier2.__getstate__()
h2 = hashlib.md5(s2).hexdigest()
self.assertEqual(h1, h2)
with open("svm_test.bin", "wb") as f:
pickle.dump(classifier, f)
with open("svm_test.bin", "rb") as f:
classifier3 = pickle.load(f)
s3 = classifier3.__getstate__()
h3 = hashlib.md5(s3).hexdigest()
self.assertEqual(h1, h3)
os.unlink("svm_test.bin")
