def local_correlations(self,eight_neighbours=False,swap_dim=True):
"""Computes the correlation image for the input dataset Y
Parameters
-----------
Y: np.ndarray (3D or 4D)
Input movie data in 3D or 4D format
eight_neighbours: Boolean
Use 8 neighbors if true, and 4 if false for 3D data (default = True)
Use 6 neighbors for 4D data, irrespectively
swap_dim: Boolean
True indicates that time is listed in the last axis of Y (matlab format)
and moves it in the front
Returns
--------
rho: d1 x d2 [x d3] matrix, cross-correlation with adjacent pixels
"""
rho = si.local_correlations(self, eight_neighbours=eight_neighbours, swap_dim=swap_dim)
return rho
def fit_file(self, motion_correct=False, indices=None, include_eval=False):
"""
This method packages the analysis pipeline (motion correction, memory
mapping, patch based CNMF processing and component evaluation) in a
single method that can be called on a specific (sequence of) file(s).
It is assumed that the CNMF object already contains a params object
where the location of the files and all the relevant parameters have
been specified. The method will perform the last step, i.e. component
evaluation, if the flag "include_eval" is set to `True`.
Args:
motion_correct (bool)
flag for performing motion correction
indices (list of slice objects)
perform analysis only on a part of the FOV
include_eval (bool)
flag for performing component evaluation
Returns:
cnmf object with the current estimates
"""
if indices is None:
indices = (slice(None), slice(None))
fnames = self.params.get('data', 'fnames')
if os.path.exists(fnames[0]):
_, extension = os.path.splitext(fnames[0])[:2]
extension = extension.lower()
else:
logging.warning("Error: File not found, with file list:\n" + fnames[0])
raise Exception('File not found!')
base_name = pathlib.Path(fnames[0]).stem + "_memmap_"
if extension == '.mmap':
fname_new = fnames[0]
Yr, dims, T = mmapping.load_memmap(fnames[0])
if np.isfortran(Yr):
raise Exception('The file should be in C order (see save_memmap function)')
else:
if motion_correct:
mc = MotionCorrect(fnames, dview=self.dview, **self.params.motion)
mc.motion_correct(save_movie=True)
fname_mc = mc.fname_tot_els if self.params.motion['pw_rigid'] else mc.fname_tot_rig
if self.params.get('motion', 'pw_rigid'):
b0 = np.ceil(np.maximum(np.max(np.abs(mc.x_shifts_els)),
np.max(np.abs(mc.y_shifts_els)))).astype(np.int)
self.estimates.shifts = [mc.x_shifts_els, mc.y_shifts_els]
else:
b0 = np.ceil(np.max(np.abs(mc.shifts_rig))).astype(np.int)
self.estimates.shifts = mc.shifts_rig
# TODO - b0 is currently direction inspecific, which can cause
# sub-optimal behavior. See
# https://github.com/flatironinstitute/CaImAn/pull/618#discussion_r313960370
# for further details.
# b0 = 0 if self.params.get('motion', 'border_nan') is 'copy' else 0
b0 = 0
fname_new = mmapping.save_memmap(fname_mc, base_name=base_name, order='C',
border_to_0=b0)
else:
fname_new = mmapping.save_memmap(fnames, base_name=base_name, order='C')
Yr, dims, T = mmapping.load_memmap(fname_new)
images = np.reshape(Yr.T, [T] + list(dims), order='F')
self.mmap_file = fname_new
if not include_eval:
return self.fit(images, indices=indices)
fit_cnm = self.fit(images, indices=indices)
Cn = summary_images.local_correlations(images[::max(T//1000, 1)], swap_dim=False)
Cn[np.isnan(Cn)] = 0
fit_cnm.save(fname_new[:-5]+'_init.hdf5')
#fit_cnm.params.change_params({'p': self.params.get('preprocess', 'p')})
# RE-RUN seeded CNMF on accepted patches to refine and perform deconvolution
cnm2 = fit_cnm.refit(images, dview=self.dview)
cnm2.estimates.evaluate_components(images, cnm2.params, dview=self.dview)
# update object with selected components
#cnm2.estimates.select_components(use_object=True)
# Extract DF/F values
cnm2.estimates.detrend_df_f(quantileMin=8, frames_window=250)
cnm2.estimates.Cn = Cn
cnm2.save(cnm2.mmap_file[:-4] + 'hdf5')
cluster.stop_server(dview=self.dview)
log_files = glob.glob('*_LOG_*')
for log_file in log_files:
os.remove(log_file)
return cnm2
def nb_view_patches3d(Yr, A, C, b, f, dims, image_type='mean',
max_projection=False, axis=0, thr=0.99, denoised_color=None):
'''
Interactive plotting utility for ipython notbook
Parameters
-----------
Yr: np.ndarray
movie
A,C,b,f: np.ndarrays
outputs of matrix factorization algorithm
dims: tuple of ints
dimensions of movie (x, y and z)
image_type: 'mean', 'max' or 'corr'
image to be overlaid to neurons (average, maximum or nearest neigbor correlation)
max_projection: boolean
plot max projection along specified axis if True, plot layers if False
axis: int (0, 1 or 2)
axis along which max projection is performed or layers are shown
thr: double
threshold regulating the extent of the displayed patches
denoised_color: string or None
color name (e.g. 'red') or hex color code (e.g. '#F0027F')
'''
d, T = Yr.shape
order = list(range(4))
order.insert(0, order.pop(axis))
Yr = Yr.reshape(dims + (-1,), order='F').transpose(order).reshape((d, T), order='F')
A = A.reshape(dims + (-1,), order='F').transpose(order).reshape((d, -1), order='F')
dims = tuple(np.array(dims)[order[:3]])
d1, d2, d3 = dims
colormap = cm.get_cmap("jet") # choose any matplotlib colormap here
grayp = [mpl.colors.rgb2hex(m) for m in colormap(np.arange(colormap.N))]
nr, T = C.shape
nA2 = np.sum(np.array(A)**2, axis=0)
b = np.squeeze(b)
f = np.squeeze(f)
Y_r = np.array(spdiags(old_div(1, nA2), 0, nr, nr) *
(A.T * np.matrix(Yr) - (A.T * np.matrix(b[:, np.newaxis])) *
np.matrix(f[np.newaxis]) - (A.T.dot(A)) * np.matrix(C)) + C)
bpl.output_notebook()
x = np.arange(T)
z = old_div(np.squeeze(np.array(Y_r[:, :].T)), 100)
k = np.reshape(np.array(A), dims + (A.shape[1],), order='F')
source = ColumnDataSource(data=dict(x=x, y=z[:, 0], y2=old_div(C[0], 100), z=z, z2=old_div(C.T, 100)))
if max_projection:
if image_type == 'corr':
image_neurons = [(local_correlations(
Yr.reshape(dims + (-1,), order='F'))[:, ::-1]).max(i)
for i in range(3)]
elif image_type in ['mean', 'max']:
tmp = [({'mean': np.nanmean, 'max': np.nanmax}[image_type]
(k, axis=3)[:, ::-1]).max(i) for i in range(3)]
else:
raise ValueError("image_type must be 'mean', 'max' or 'corr'")
# tmp = [np.nanmean(k.max(i), axis=2) for i in range(3)]
image_neurons = np.nan * np.ones((int(1.05 * (d1 + d2)), int(1.05 * (d1 + d3))))
image_neurons[:d2, -d3:] = tmp[0][::-1]
image_neurons[:d2, :d1] = tmp[2].T[::-1]
image_neurons[-d1:, -d3:] = tmp[1]
offset1 = image_neurons.shape[1] - d3
offset2 = image_neurons.shape[0] - d1
coors = [plot_contours(coo_matrix(A.reshape(dims + (-1,), order='F').max(i)
.reshape((old_div(np.prod(dims), dims[i]), -1), order='F')),
tmp[i], thr=thr) for i in range(3)]
pl.close()
cc1 = [[cor['coordinates'][:, 0] + offset1 for cor in coors[0]],
[cor['coordinates'][:, 1] for cor in coors[2]],
[cor['coordinates'][:, 0] + offset1 for cor in coors[1]]]
cc2 = [[cor['coordinates'][:, 1] for cor in coors[0]],
[cor['coordinates'][:, 0] for cor in coors[2]],
[cor['coordinates'][:, 1] + offset2 for cor in coors[1]]]
c1x = cc1[0][0]
c2x = cc2[0][0]
c1y = cc1[1][0]
c2y = cc2[1][0]
c1z = cc1[2][0]
c2z = cc2[2][0]
source2 = ColumnDataSource(data=dict( # x=npointsx, y=npointsy, z=npointsz,
c1x=c1x, c1y=c1y, c1z=c1z,
c2x=c2x, c2y=c2y, c2z=c2z, cc1=cc1, cc2=cc2))
callback = CustomJS(args=dict(source=source, source2=source2), code="""
var data = source.get('data');
var f = cb_obj.get('value')-1
y = data['y']
y2 = data['y2']
for (i = 0; i < y.length; i++) {
y[i] = data['z'][i][f];
y2[i] = data['z2'][i][f];
}
var data2 = source2.get('data');
c1x = data2['c1x'];
c2x = data2['c2x'];
c1y = data2['c1y'];
c2y = data2['c2y'];
c1z = data2['c1z'];
c2z = data2['c2z'];
cc1 = data2['cc1'];
cc2 = data2['cc2'];
for (i = 0; i < c1x.length; i++) {
c1x[i] = cc1[0][f][i]
c2x[i] = cc2[0][f][i]
}
for (i = 0; i < c1y.length; i++) {
c1y[i] = cc1[1][f][i]
c2y[i] = cc2[1][f][i]
}
for (i = 0; i < c1z.length; i++) {
c1z[i] = cc1[2][f][i]
c2z[i] = cc2[2][f][i]
}
source2.trigger('change');
source.trigger('change');
""")
else:
if image_type == 'corr':
image_neurons = local_correlations(Yr.reshape(dims + (-1,), order='F'))[:, ::-1]
elif image_type in ['mean', 'max']:
image_neurons = {'mean': np.nanmean, 'max': np.nanmax}[image_type](k, axis=3)[:, ::-1]
else:
raise ValueError('image_type must be mean, max or corr')
cmap = bokeh.models.mappers.LinearColorMapper([mpl.colors.rgb2hex(m)
for m in colormap(np.arange(colormap.N))])
cmap.high = image_neurons.max()
coors = get_contours3d(A, dims, thr=thr)
pl.close()
cc1 = [[l[:, 0] for l in n['coordinates']] for n in coors]
cc2 = [[l[:, 1] for l in n['coordinates']] for n in coors]
linit = int(round(coors[0]['CoM'][0])) # pick initl layer in which first neuron lies
c1 = cc1[0][linit]
c2 = cc2[0][linit]
source2 = ColumnDataSource(data=dict(c1=c1, c2=c2, cc1=cc1, cc2=cc2))
x = list(range(d2))
y = list(range(d3))
source3 = ColumnDataSource(
data=dict(im1=[image_neurons[linit]], im=image_neurons, xx=[x], yy=[y]))
callback = CustomJS(args=dict(source=source, source2=source2), code="""
var data = source.get('data');
var f = slider_neuron.get('value')-1;
var l = slider_layer.get('value')-1;
y = data['y']
y2 = data['y2']
for (i = 0; i < y.length; i++) {
y[i] = data['z'][i][f];
y2[i] = data['z2'][i][f];
}
var data2 = source2.get('data');
c1 = data2['c1'];
c2 = data2['c2'];
for (i = 0; i < c1.length; i++) {
c1[i] = data2['cc1'][f][l][i];
c2[i] = data2['cc2'][f][l][i];
}
source2.trigger('change');
source.trigger('change');
""")
callback_layer = CustomJS(args=dict(source=source3, source2=source2), code="""
var f = slider_neuron.get('value')-1;
var l = slider_layer.get('value')-1;
var im1 = source.get('data')['im1'][0];
for (var i = 0; i < source.get('data')['xx'][0].length; i++) {
for (var j = 0; j < source.get('data')['yy'][0].length; j++){
im1[i][j] = source.get('data')['im'][l][i][j];
}
}
var data2 = source2.get('data');
c1 = data2['c1'];
c2 = data2['c2'];
for (i = 0; i < c1.length; i++) {
c1[i] = data2['cc1'][f][l][i];
c2[i] = data2['cc2'][f][l][i];
}
source.trigger('change');
source2.trigger('change');
""")
plot = bpl.figure(plot_width=600, plot_height=300)
plot.line('x', 'y', source=source, line_width=1, line_alpha=0.6)
if denoised_color is not None:
plot.line('x', 'y2', source=source, line_width=1, line_alpha=0.6, color=denoised_color)
slider = bokeh.models.Slider(start=1, end=Y_r.shape[0], value=1, step=1,
title="Neuron Number", callback=callback)
xr = Range1d(start=0, end=image_neurons.shape[1] if max_projection else d3)
yr = Range1d(start=image_neurons.shape[0] if max_projection else d2, end=0)
plot1 = bpl.figure(x_range=xr, y_range=yr, plot_width=300, plot_height=300)
if max_projection:
plot1.image(image=[image_neurons[::-1, :]], x=0,
y=image_neurons.shape[0], dw=image_neurons.shape[1], dh=image_neurons.shape[0], palette=grayp)
plot1.patch('c1x', 'c2x', alpha=0.6, color='purple', line_width=2, source=source2)
plot1.patch('c1y', 'c2y', alpha=0.6, color='purple', line_width=2, source=source2)
plot1.patch('c1z', 'c2z', alpha=0.6, color='purple', line_width=2, source=source2)
layout = vform(slider, hplot(plot1, plot))
else:
slider_layer = bokeh.models.Slider(start=1, end=d1, value=linit + 1, step=1,
title="Layer", callback=callback_layer)
callback.args['slider_neuron'] = slider
callback.args['slider_layer'] = slider_layer
callback_layer.args['slider_neuron'] = slider
callback_layer.args['slider_layer'] = slider_layer
plot1.image(image='im1', x=[0], y=[d2], dw=[d3], dh=[d2],
color_mapper=cmap, source=source3)
plot1.patch('c1', 'c2', alpha=0.6, color='purple', line_width=2, source=source2)
layout = vform(slider, slider_layer, hplot(plot1, plot))
bpl.show(layout)
return Y_r
video,
padtype='odd',
padlen=3 * (max(len(b), len(a)) - 1)))
return videoFilt
#%%
dims = m.shape
dims
#%%
data = m[13000:33000, :, :].reshape((10000, -1), order='F')
datahp = highpassVideo(data.T, 1 / 3, 400).T
datahp = datahp.reshape((20000, dims[1], dims[2]), order='F')
from caiman.summary_images import local_correlations
img_corr = local_correlations(datahp, swap_dim=False)
plt.figure()
plt.imshow(img_corr)
plt.savefig('/home/nel/Code/VolPy/403106-corr-hp.pdf')
#%%
i = 0
j = 0
number = 0
number1 = 0
Cn = img_corr
A = A.astype(np.float64)
for i in range(n_group):
plt.figure()
vmax = np.percentile(Cn, 99)
vmin = np.percentile(Cn, 5)