def get_template_from_img(img, rect):
################### CALCULATING SPLINE AND INTERPOLATING IMAGE WARP #########################
spline_It = RectBivariateSpline( np.arange(img.shape[0]), np.arange(img.shape[1]), img)
template = spline_It.__call__( np.linspace(rect[1], rect[3], np.round(rect[3] - rect[1]+1), endpoint=True),
np.linspace(rect[0], rect[2], np.round(rect[2] - rect[0]+1), endpoint=True), grid=True)
return template
def __call__(self, x, y, dx=0, dy=0, grid=False):
"""Overloaded __call__method.
Here we basically override the default value of the `grid` parameter
from `True` to `False`, since we're typically interested in evaluating
the splined at given physical coordinates, rather than grid points.
"""
return RectBivariateSpline.__call__(self, x, y, dx, dy, grid)
def __call__(self, x, y, **kwargs):
if 'grid' not in kwargs:
x, y = np.meshgrid(x, y)
kwargs['grid'] = False
result = RectBivariateSpline.__call__(self, x, y, **kwargs)
# result = np.where((x < self.xmax) & (x > self.xmin), result, 0.)
# result[np.isnan(result)] = 0.
# return result.T
return np.where(np.isnan(result), 0., result).T
else:
result = RectBivariateSpline.__call__(self, x, y, **kwargs)
# result = np.where((x <= xmax) & (x >= xmin), result, 0.)
# result[np.isnan(result)] = 0.
# return result
return np.where(np.isnan(result), 0., result)
def __call__(self, x, y, dx=0, dy=0, grid=False):
"""Overloaded __call__method.
Here we basically override the default value of the `grid` parameter
from `True` to `False`, since we're typically interested in evaluating
the splined at given physical coordinates, rather than grid points.
"""
return RectBivariateSpline.__call__(self, x, y, None, dx, dy, grid)
def sparsery(ops):
rez, max_proj = get_mov(ops)
ops['max_proj'] = max_proj
nframes, Ly, Lx = rez.shape
ops['Lyc'] = Ly
ops['Lxc'] = Lx
sdmov = get_sdmov(rez, ops)
rez /= sdmov
#rez *= -1
rez = neuropil_subtraction(rez, ops['spatial_hp'])
LL = np.meshgrid(np.arange(Lx), np.arange(Ly))
Lyp = np.zeros(5, 'int32')
Lxp = np.zeros(5,'int32')
gxy = [np.array(LL).astype('float32')]
dmov = rez
movu = []
for j in range(5):
movu.append(square_conv2(dmov, 3))
dmov = 2 * downsample(dmov)
gxy0 = downsample(gxy[j], False)
gxy.append(gxy0)
nfr, Lyp[j], Lxp[j] = movu[j].shape
movu[j] = np.reshape(movu[j], (nfr,-1))
nfr, Lyc,Lxc = rez.shape
V0 = []
ops['Vmap'] = []
for j in range(len(movu)):
V0.append(np.amax(movu[j], axis=0))
#V0.append(np.sum(movu[j]**2 * np.float32(movu[j]>Th2), axis=0)**.5)
V0[j] = np.reshape(V0[j], (Lyp[j], Lxp[j]))
ops['Vmap'].append(V0[j].copy())
I = np.zeros((len(gxy), gxy[0].shape[1], gxy[0].shape[2]))
for t in range(1,len(gxy)-1):
gmodel = RectBivariateSpline(gxy[t][1,:,0], gxy[t][0, 0,:], ops['Vmap'][t],
kx=min(3, gxy[t][1,:,0].size-1), ky=min(3, gxy[t][0,0,:].size-1))
I[t] = gmodel.__call__(gxy[0][1,:,0], gxy[0][0, 0,:])
I0 = np.amax(I, axis=0)
ops['Vcorr'] = I0
imap = np.argmax(I, axis=0).flatten()
ipk = np.abs(I0 - maximum_filter(I0, size=(11,11))).flatten() < 1e-4
isort = np.argsort(I0.flatten()[ipk])[::-1]
im, nm = mode(imap[ipk][isort[:50]])
if ops['spatial_scale'] > 0:
im = max(1, min(4, ops['spatial_scale']))
fstr = 'FORCED'
else:
fstr = 'estimated'
if im==0:
print('ERROR: best scale was 0, everything should break now!')
Th2 = ops['threshold_scaling']*5*max(1,im)
vmultiplier = max(1, np.float32(rez.shape[0])/1200)
print('NOTE: %s spatial scale ~%d pixels, time epochs %2.2f, threshold %2.2f '%(fstr, 3*2**im, vmultiplier, vmultiplier*Th2))
ops['spatscale_pix'] = 3*2**im
V0 = []
ops['Vmap'] = []
for j in range(len(movu)):
#V0.append(np.amax(movu[j], axis=0))
#V0.append(np.sum(movu[j]**2 * np.float32(movu[j]>Th2), axis=0)**.5)
V0.append(threshold_reduce(movu[j], Th2))
V0[j] = np.reshape(V0[j], (Lyp[j], Lxp[j]))
ops['Vmap'].append(V0[j].copy())
I = np.zeros((len(gxy), gxy[0].shape[1], gxy[0].shape[2]))
for t in range(1,len(gxy)-1):
gmodel = RectBivariateSpline(gxy[t][1,:,0], gxy[t][0, 0,:], ops['Vmap'][t],
kx=min(3, gxy[t][1,:,0].size-1), ky=min(3, gxy[t][0,0,:].size-1))
I[t] = gmodel.__call__(gxy[0][1,:,0], gxy[0][0, 0,:])
I0 = np.amax(I, axis=0)
ops['Vcorr'] = I0
xpix,ypix,lam = [],[],[]
rez = np.reshape(rez, (-1,Ly*Lx))
lxs = 3 * 2**np.arange(5)
nscales = len(lxs)
niter = 250 * ops['max_iterations']
Vmax = np.zeros((niter))
ihop = np.zeros((niter))
vrat = np.zeros((niter))
Npix = np.zeros((niter))
t0 = time.time()
for tj in range(niter):
v0max = np.array([np.amax(V0[j]) for j in range(5)])
imap = np.argmax(v0max)
imax = np.argmax(V0[imap])
yi, xi = np.unravel_index(imax, (Lyp[imap], Lxp[imap]))
yi, xi = gxy[imap][1,yi,xi], gxy[imap][0,yi,xi]
Vmax[tj] = np.amax(v0max)
if Vmax[tj] < vmultiplier*Th2:
break
ls = lxs[imap]
ihop[tj] = imap
ypix0, xpix0, lam0 = add_square(int(yi),int(xi),ls,Ly,Lx)
xproj = rez[:, ypix0*Lx+ xpix0] @ lam0
goodframe = np.nonzero(xproj>Th2)[0]
for j in range(3):
ypix0, xpix0, lam0 = iter_extend(ypix0, xpix0, rez, Ly,Lx, goodframe)
xproj = rez[:, ypix0*Lx+ xpix0] @ lam0
goodframe = np.nonzero(xproj>Th2)[0]
if len(goodframe)<1:
break
if len(goodframe)<1:
break
vrat[tj], ipack = two_comps(rez[:, ypix0*Lx+ xpix0], lam0, Th2)
if vrat[tj]>1.25:
lam0, xp, goodframe = ipack
xproj[goodframe] = xp
ix = lam0>lam0.max()/5
xpix0 = xpix0[ix]
ypix0 = ypix0[ix]
lam0 = lam0[ix]
# update residual on raw movie
rez[np.ix_(goodframe, ypix0*Lx+ xpix0)] -= xproj[goodframe][:,np.newaxis] * lam0
# update filtered movie
ys, xs, lms = multiscale_mask(ypix0,xpix0,lam0, Lyp, Lxp)
for j in range(nscales):
movu[j][np.ix_(goodframe,xs[j]+Lxp[j]*ys[j])] -= np.outer(xproj[goodframe], lms[j])
#V0[j][xs[j] + Lxp[j]*ys[j]] = np.amax(movu[j][:,xs[j]+Lxp[j]*ys[j]], axis=0)
Mx = movu[j][:,xs[j]+Lxp[j]*ys[j]]
#V0[j][xs[j] + Lxp[j]*ys[j]] = np.sum(Mx**2 * np.float32(Mx>Th2), axis=0)**.5
V0[j][ys[j], xs[j]] = np.sum(Mx**2 * np.float32(Mx>Th2), axis=0)**.5
#V0[j][xs[j] + Lxp[j]*ys[j]] = np.sum(movu[j][:,xs[j]+Lxp[j]*ys[j]]**2 * np.float32(movu[j][:,xs[j]+Lxp[j]*ys[j]]>Th2), axis=0)**.5
xpix.append(xpix0)
ypix.append(ypix0)
lam.append(lam0)
if tj%1000==0:
print('%d ROIs, score=%2.2f'%(tj, Vmax[tj]))
#print(tj, time.time()-t0, Vmax[tj])
ops['Vmax'] = Vmax
ops['ihop'] = ihop
ops['Vsplit'] = vrat
stat = [{'ypix':ypix[n], 'lam':lam[n]*sdmov[ypix[n], xpix[n]], 'xpix':xpix[n]} for n in range(len(xpix))]
stat = get_stat(ops, stat)
return ops,stat
def __call__(self, x, y):
outside = self.is_outside_domain(x, y)
return np.where(outside, self.fill_value,
RectBivariateSpline.__call__(self, x, y))
def sparsery(ops):
""" bin ops['reg_file'] then detect ROIs using correlations in time
Parameters
----------------
ops : dictionary
'reg_file', 'Ly', 'Lx', 'yrange', 'xrange', 'tau', 'fs', 'nframes', 'high_pass', 'batch_size'
Returns
----------------
ops : dictionary
adds 'max_proj', 'Vcorr', 'Vmap', 'Vsplit'
stat : array of dicts
list of ROIs
"""
rez, max_proj = bin_movie(ops)
ops['max_proj'] = max_proj
nbinned, Lyc, Lxc = rez.shape
# cropped size
ops['Lyc'] = Lyc
ops['Lxc'] = Lxc
sdmov = get_sdmov(rez, ops)
rez /= sdmov
# subtract low-pass filtered version of binned movie
rez = neuropil_subtraction(rez, ops['spatial_hp'])
LL = np.meshgrid(np.arange(Lxc), np.arange(Lyc))
gxy = [np.array(LL).astype('float32')]
dmov = rez
movu = []
# downsample movie at various spatial scales
# downsampled sizes
Lyp = np.zeros(5, 'int32')
Lxp = np.zeros(5, 'int32')
for j in range(5):
# convolve
movu.append(square_conv2(dmov, 3))
# downsample
dmov = 2 * downsample(dmov)
gxy0 = downsample(gxy[j], False)
gxy.append(gxy0)
nbinned, Lyp[j], Lxp[j] = movu[j].shape
# find maximum spatial scale for each pixel
V0 = []
ops['Vmap'] = []
for j in range(len(movu)):
V0.append(movu[j].max(axis=0))
ops['Vmap'].append(V0[j].copy())
# spline over scales
I = np.zeros((len(gxy), gxy[0].shape[1], gxy[0].shape[2]))
for t in range(1, len(gxy) - 1):
gmodel = RectBivariateSpline(gxy[t][1, :, 0],
gxy[t][0, 0, :],
ops['Vmap'][t],
kx=min(3, gxy[t][1, :, 0].size - 1),
ky=min(3, gxy[t][0, 0, :].size - 1))
I[t] = gmodel.__call__(gxy[0][1, :, 0], gxy[0][0, 0, :])
I0 = I.max(axis=0)
ops['Vcorr'] = I0
# find best scale based on scale of top peaks
# (used to set threshold)
imap = np.argmax(I, axis=0).flatten()
ipk = np.abs(I0 - maximum_filter(I0, size=(11, 11))).flatten() < 1e-4
isort = np.argsort(I0.flatten()[ipk])[::-1]
im, nm = mode(imap[ipk][isort[:50]])
if ops['spatial_scale'] > 0:
im = max(1, min(4, ops['spatial_scale']))
fstr = 'FORCED'
else:
fstr = 'estimated'
if im == 0:
print('ERROR: best scale was 0, everything should break now!')
# threshold for accepted peaks (scale it by spatial scale)
Th2 = ops['threshold_scaling'] * 5 * max(1, im)
vmultiplier = max(1, np.float32(rez.shape[0]) / 1200)
print(
'NOTE: %s spatial scale ~%d pixels, time epochs %2.2f, threshold %2.2f '
% (fstr, 3 * 2**im, vmultiplier, vmultiplier * Th2))
ops['spatscale_pix'] = 3 * 2**im
V0 = []
ops['Vmap'] = []
# get standard deviation for pixels for all values > Th2
for j in range(len(movu)):
V0.append(threshold_reduce(movu[j], Th2))
ops['Vmap'].append(V0[j].copy())
movu[j] = np.reshape(movu[j], (movu[j].shape[0], -1))
xpix, ypix, lam = [], [], []
rez = np.reshape(rez, (-1, Lyc * Lxc))
lxs = 3 * 2**np.arange(5)
nscales = len(lxs)
niter = 250 * ops['max_iterations']
Vmax = np.zeros((niter))
ihop = np.zeros((niter))
vrat = np.zeros((niter))
Npix = np.zeros((niter))
t0 = time.time()
for tj in range(niter):
# find peaks in stddev's
v0max = np.array([V0[j].max() for j in range(5)])
imap = np.argmax(v0max)
imax = np.argmax(V0[imap])
yi, xi = np.unravel_index(imax, (Lyp[imap], Lxp[imap]))
# position of peak
yi, xi = gxy[imap][1, yi, xi], gxy[imap][0, yi, xi]
# check if peak is larger than threshold * max(1,nbinned/1200)
Vmax[tj] = v0max.max()
if Vmax[tj] < vmultiplier * Th2:
break
ls = lxs[imap]
ihop[tj] = imap
# make square of initial pixels based on spatial scale of peak
ypix0, xpix0, lam0 = add_square(int(yi), int(xi), ls, Lyc, Lxc)
# project movie into square to get time series
tproj = rez[:, ypix0 * Lxc + xpix0] @ lam0
goodframe = np.nonzero(tproj > Th2)[0] # frames with activity > Th2
# extend mask based on activity similarity
for j in range(3):
ypix0, xpix0, lam0 = iter_extend(ypix0, xpix0, rez[goodframe], Lyc,
Lxc)
tproj = rez[:, ypix0 * Lxc + xpix0] @ lam0
goodframe = np.nonzero(tproj > Th2)[0]
if len(goodframe) < 1:
break
if len(goodframe) < 1:
break
# check if ROI should be split
vrat[tj], ipack = two_comps(rez[:, ypix0 * Lxc + xpix0], lam0, Th2)
if vrat[tj] > 1.25:
lam0, xp, goodframe = ipack
tproj[goodframe] = xp
ix = lam0 > lam0.max() / 5
xpix0 = xpix0[ix]
ypix0 = ypix0[ix]
lam0 = lam0[ix]
# update residual on raw movie
rez[np.ix_(goodframe, ypix0 * Lxc +
xpix0)] -= tproj[goodframe][:, np.newaxis] * lam0
# update filtered movie
ys, xs, lms = multiscale_mask(ypix0, xpix0, lam0, Lyp, Lxp)
for j in range(nscales):
movu[j][np.ix_(goodframe, xs[j] + Lxp[j] * ys[j])] -= np.outer(
tproj[goodframe], lms[j])
Mx = movu[j][:, xs[j] + Lxp[j] * ys[j]]
V0[j][ys[j],
xs[j]] = (Mx**2 * np.float32(Mx > Th2)).sum(axis=0)**.5
xpix.append(xpix0)
ypix.append(ypix0)
lam.append(lam0)
if tj % 1000 == 0:
print('%d ROIs, score=%2.2f' % (tj, Vmax[tj]))
ops['Vmax'] = Vmax
ops['ihop'] = ihop
ops['Vsplit'] = vrat
stat = [{
'ypix': ypix[n] + ops['yrange'][0],
'lam': lam[n] * sdmov[ypix[n], xpix[n]],
'xpix': xpix[n] + ops['xrange'][0],
'footprint': ops['ihop'][n]
} for n in range(len(xpix))]
return ops, stat
def LucasKanadeBasis(It, It1, rect, bases, p0=np.zeros(2)):
# Input:
# It: template image
# It1: Current image
# rect: Current position of the car
# (top left, bot right coordinates)
# bases: [n, m, k] where nxm is the size of the template.
# Output:
# p: movement vector [dp_x, dp_y]
# Put your implementation here
p = p0
width_patch = np.round(rect[2] - rect[0] + 1)
height_patch = np.round(rect[3] - rect[1] + 1)
# gradX = cv2.Sobel(It1, -1, 1, 0, borderType=cv2.BORDER_CONSTANT)
# gradY = cv2.Sobel(It1, -1, 0, 1, borderType=cv2.BORDER_CONSTANT)
gradY, gradX = np.gradient(It1)
################################### SPLINES ########################################
spline_It1 = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), It1)
spline_It1_X_grad = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), gradX)
spline_It1_Y_grad = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), gradY)
threshold = 1e-1
p_delta_norm = np.inf
while (p_delta_norm > threshold):
warp = rect + [p[0], p[1], p[0], p[1]]
jacobian = np.asarray([[1, 0], [0, 1]])
################################### INTERPOLATING IT WARP ##################################
It1_patch = spline_It1.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
##################################### TEMPLATE ERROR #####################################
b = It - It1_patch
# print('b flatten shape: ', b.shape)
b_vect = b.reshape(b.shape[0] * b.shape[1], 1)
################################### INTERPOLATING GRAD X and Y WARP ################################
gradX_It1_patch = spline_It1_X_grad.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
gradY_It1_patch = spline_It1_Y_grad.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
gradX_It1_patch_vect = gradX_It1_patch.reshape(
gradX_It1_patch.shape[0] * gradX_It1_patch.shape[1], 1)
gradY_It1_patch_vect = gradY_It1_patch.reshape(
gradY_It1_patch.shape[0] * gradY_It1_patch.shape[1], 1)
################################## CALCULATING B, WEIGHTS, BW ################################
B = np.zeros((bases.shape[0] * bases.shape[1], bases.shape[2]))
for i in range(bases.shape[2]):
B[:, i] = bases[:, :, i].flatten()
# error_vect = It1_patch - It
# weights2 = B.T.dot(error_vect.reshape( error_vect.shape[0]*error_vect.shape[1] , 1))
# print('weights1 : ', weights1)
# weights = []
# Bw_vect = np.zeros( It.shape[0]* It.shape[1] )
# for i in range(bases.shape[2]):
# base_vect = bases[:, :, i].reshape( bases.shape[0] * bases.shape[1])
# weight = np.dot(base_vect, -b_vect)
# weights.append(weight)
# Bw_vect += weight * base_vect
# print('weights2 : ', weights2)
################################### STACKING GRAD X and Y WARP ################################
grad_It1_patch = np.hstack(
(gradX_It1_patch_vect, gradY_It1_patch_vect))
# print('grad_It1_patch shape: ', grad_It1_patch.shape)
A = np.matmul(grad_It1_patch, jacobian)
# print('A: ', A)
# print('A shape: ', A.shape)
################################ UPDATION FOR APPEARANCE CHANGES #############################
# Bw_vect = np.expand_dims(Bw_vect, 0)
# print('Bw: ', Bw_vect)
# print('Bw shape: ', Bw_vect.shape)
# b_vect = b_vect + Bw_vect
# gradX_It1_patch_vect = gradX_It1_patch_vect - Bw_vect.T
# gradY_It1_patch_vect = gradY_It1_patch_vect - Bw_vect.T
# print('b_vect shape: ', b_vect.shape)
# print('gradX_It1_patch_vect shape: ', gradX_It1_patch_vect.shape)
span_term = np.eye(B.shape[0], B.shape[0]) - np.matmul(B, B.T)
# print('span_term: ', span_term)
# print('span_term shape: ', span_term.shape)
b_vect_new = np.matmul(span_term, b_vect)
A_new = np.matmul(span_term, A)
hessian = np.matmul(A_new.T, A_new)
# print('Hessian shape: ', hessian.shape)
p_delta = np.matmul(np.linalg.inv(hessian),
np.matmul(A_new.T, b_vect_new))
p_delta = p_delta.flatten()
# print('p_delta shape: ',p_delta.shape)
p += p_delta
p_delta_norm = np.sqrt(p_delta[0]**2 + p_delta[1]**2)
print('image error: ', b.sum(), ', p_delta: ', p_delta, ', norm: ',
p_delta_norm)
return p
def LucasKanade(It, It1, rect, p0=np.zeros(2)):
# Input:
# It: template image
# It1: Current image
# rect: Current position of the car
# (top left, bot right coordinates)
# p0: Initial movement vector [dp_x0, dp_y0]
# Output:
# p: movement vector [dp_x, dp_y]
# Put your implementation here
# pad_width = int(It.shape[1]/2)
# It = np.pad(It, pad_width, mode='symmetric')
# It1 = np.pad(It1, pad_width, mode='symmetric')
p = p0
width_patch = np.round(rect[2] - rect[0] + 1)
height_patch = np.round(rect[3] - rect[1] + 1)
gradX = cv2.Sobel(It1, -1, 1, 0, borderType=cv2.BORDER_CONSTANT)
gradY = cv2.Sobel(It1, -1, 0, 1, borderType=cv2.BORDER_CONSTANT)
# gradX, gradY = np.gradient(It1)
################################### SPLINES ########################################
spline_It1 = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), It1)
spline_It1_X_grad = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), gradX)
spline_It1_Y_grad = RectBivariateSpline(np.arange(It1.shape[0]),
np.arange(It1.shape[1]), gradY)
threshold = 1.5e-3
p_delta_norm = np.inf
while (p_delta_norm > threshold):
warp = rect + [p[0], p[1], p[0], p[1]]
jacobian = np.asarray([[1, 0], [0, 1]])
################################### INTERPOLATING IT WARP ##################################
It1_patch = spline_It1.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
##################################### TEMPLATE ERROR #####################################
b = It - It1_patch
b_vect = b.reshape(1, b.shape[0] * b.shape[1])
# print('b flatten shape: ', b.shape)
################################### INTERPOLATING GRAD X and Y WARP ################################
gradX_It1_patch = spline_It1_X_grad.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
gradY_It1_patch = spline_It1_Y_grad.__call__(
np.linspace(warp[1], warp[3], height_patch, endpoint=True),
np.linspace(warp[0], warp[2], width_patch, endpoint=True))
gradX_It1_patch_vect = gradX_It1_patch.reshape(
gradX_It1_patch.shape[0] * gradX_It1_patch.shape[1], 1)
gradY_It1_patch_vect = gradY_It1_patch.reshape(
gradY_It1_patch.shape[0] * gradY_It1_patch.shape[1], 1)
################################### STACKING GRAD X and Y WARP ################################
grad_It1_patch = np.hstack(
(gradX_It1_patch_vect, gradY_It1_patch_vect))
# print('grad_It1_patch shape: ', grad_It1_patch.shape)
A = np.matmul(grad_It1_patch, jacobian)
# print('A: ', A)
# print('A shape: ', A.shape)
hessian = np.matmul(A.T, A)
# print('Hessian shape: ', hessian.shape)
p_delta = np.matmul(np.linalg.inv(hessian), np.matmul(A.T, b_vect.T))
p_delta = p_delta.flatten()
# print('p_delta shape: ',p_delta.shape)
p += p_delta
p_delta_norm = np.sqrt(p_delta[0]**2 + p_delta[1]**2)
print('image error: ', b.sum(), ', p_delta: ', p_delta, ', norm: ',
p_delta_norm)
return p
def __call__(self, x, y):
outside = self.is_outside_domain(x, y)
return np.where(outside, self.fill_value,
RectBivariateSpline.__call__(self, x, y))
def Interp2DScalar(list_rLs,
list_keys,
xs,
ys,
file_input,
do_clip=False,
clip_bounds=np.array([0.0,1.0]),
k_spline=1,
transforms=None):
"""
Interpolation of scalar data in refened mesh onto continuous domain.
Args:
list_rLs - list of refinement levels for interpolation
list_keys - list of HDF5 keys
xs - output x coordinates
ys - output y coordinates
file_input - HDF5 file containing keys
Kwargs:
do_clip=False - bool - clip data outside clip_bounds
clip_bounds=np.array([0.0,1.0]) - array(float) - bounds for clipping of data
k_spline=1 - int - degree of spline representation
transforms=None - list(str) - transformations to appy to data after interpolation
Returns:
array(float) - interpolated and possibly transformed data
"""
output = np.zeros((len(xs),len(ys)))
for rL in list_rLs:
keys_rL = GetKeysForRefinement_Level(rL,list_keys)
datasets_current = []
for key in keys_rL:
datasets_current.append(file_input[key])
delta = datasets_current[0].attrs['delta'][0]
for dataset in datasets_current:
extent_current = GetDatasetExtent2D(dataset)
extent_current_IG = GetDatasetExtentIncGhost2D(dataset)
xs_domain = np.arange(extent_current_IG[0],extent_current_IG[1]+0.1*delta,delta)
ys_domain = np.arange(extent_current_IG[2],extent_current_IG[3]+0.1*delta,delta)
interp_spline = RectBivariateSpline(xs_domain,ys_domain,np.asarray(dataset).T,kx=k_spline,ky=k_spline)
xs_mask = np.logical_and(extent_current[0]<=xs,xs<=extent_current[1])
ys_mask = np.logical_and(extent_current[2]<=ys,ys<=extent_current[3])
xs_current = np.extract(xs_mask,xs)
ys_current = np.extract(ys_mask,ys)
shift = np.array([np.argmax(xs_mask),np.argmax(ys_mask)])
data_interp = interp_spline.__call__(xs_current,ys_current)
np.copyto(output[shift[0]:shift[0]+len(xs_current),
shift[1]:shift[1]+len(ys_current)],
data_interp)
if do_clip:
np.clip(output,clip_bounds[0],clip_bounds[1],out=output)
if transforms:
for i in range(len(transforms)):
if transforms[i] == "rotate_right_half":
output = RotateAndCopyY(output)
#elif transforms[i] == "reflect_y":
# output = ReflectY(output)
else:
raise ValueError("Unknown tranformation requested")
return output
def Interp2DSpeedDirection(list_rLs,
list_keys_velx,
list_keys_vely,
xs,
ys,
file_input_velx,
file_input_vely,
do_clip=[False,False],
clip_bounds=np.array([[0.0,1.0],[-np.pi,np.pi]]),
k_spline=1,
transforms=None):
"""
Interpolation of velocity data in refened mesh onto continuous domain returning velocity magnitude and direction.
Args:
list_rLs - list of refinement levels for interpolation
list_keys_velx - list of HDF5 keys for x component of velocity
list_keys_vely - list of HDF5 keys for y component of velocity
xs - output x coordinates
ys - output y coordinates
file_input_velx - HDF5 file containing keys
file_input_velx - HDF5 file containing keys
Kwargs:
do_clip=[False,False] - list(bool) - clip data outside clip_bounds for speed and/or direction respectively
clip_bounds=np.array([[0.0,1.0],[-np.pi,np.pi]]) - array(float) - bounds for clipping of data for speed and/or direction respectively
k_spline=1 - int - degree of spline representation
transforms=None - list(str) - transformations to appy to data after interpolation
Returns:
array(float) - interpolated and possibly transformed speed data
array(float) - interpolated and possibly transformed direction data
"""
output_speed = np.zeros((len(xs),len(ys)))
output_direc = np.zeros((len(xs),len(ys)))
for rL in list_rLs:
keys_rL_velx = GetKeysForRefinement_Level(rL,list_keys_velx)
keys_rL_vely = GetKeysForRefinement_Level(rL,list_keys_vely)
datasets_current_velx = []
datasets_current_vely = []
for key in keys_rL_velx:
datasets_current_velx.append(file_input_velx[key])
for key in keys_rL_vely:
datasets_current_vely.append(file_input_vely[key])
delta = datasets_current_velx[0].attrs['delta'][0]
for ds_idx in range(len(datasets_current_velx)):
dataset_velx = datasets_current_velx[ds_idx]
dataset_vely = datasets_current_vely[ds_idx]
extent_current = GetDatasetExtent2D(dataset_velx)
extent_current_IG = GetDatasetExtentIncGhost2D(dataset_velx)
xs_domain = np.arange(extent_current_IG[0],extent_current_IG[1]+0.1*delta,delta)
ys_domain = np.arange(extent_current_IG[2],extent_current_IG[3]+0.1*delta,delta)
interp_spline_velx = RectBivariateSpline(xs_domain,ys_domain,np.asarray(dataset_velx).T,kx=k_spline,ky=k_spline)
interp_spline_vely = RectBivariateSpline(xs_domain,ys_domain,np.asarray(dataset_vely).T,kx=k_spline,ky=k_spline)
xs_mask = np.logical_and(extent_current[0]<=xs,xs<=extent_current[1])
ys_mask = np.logical_and(extent_current[2]<=ys,ys<=extent_current[3])
xs_current = np.extract(xs_mask,xs)
ys_current = np.extract(ys_mask,ys)
shift = np.array([np.argmax(xs_mask),np.argmax(ys_mask)])
data_interp_velx = interp_spline_velx.__call__(xs_current,ys_current)
data_interp_vely = interp_spline_vely.__call__(xs_current,ys_current)
data_interp_speed = np.sqrt(data_interp_velx**2 + data_interp_vely**2)
data_interp_direc = np.arctan2(data_interp_vely,data_interp_velx)
np.copyto(output_speed[shift[0]:shift[0]+len(xs_current),
shift[1]:shift[1]+len(ys_current)],
data_interp_speed)
np.copyto(output_direc[shift[0]:shift[0]+len(xs_current),
shift[1]:shift[1]+len(ys_current)],
data_interp_direc)
if do_clip[0]:
np.clip(output_speed,clip_bounds[0,0],clip_bounds[0,1],out=output_speed)
if do_clip[1]:
np.clip(output_direc,clip_bounds[1,0],clip_bounds[1,1],out=output_direc)
if transforms:
for i in range(len(transforms)):
if transforms[i] == "rotate_right_half":
output_speed = RotateAndCopyY(output_speed)
output_direc = RotateAndCopyY_angle(output_direc)
#elif transforms[i] == "reflect_y":
# output_speed = ReflectY(output_speed)
else:
raise ValueError("Unknown tranformation requested")
return output_speed, output_direc
