def extract_masks(scan, mmap_scan, num_components=200, num_background_components=1,
merge_threshold=0.8, init_on_patches=True, init_method='greedy_roi',
soma_diameter=(14, 14), snmf_alpha=None, patch_size=(50, 50),
proportion_patch_overlap=0.2, num_components_per_patch=5,
num_processes=8, num_pixels_per_process=5000, fps=15):
""" Extract masks from multi-photon scans using CNMF.
Uses constrained non-negative matrix factorization to find spatial components (masks)
and their fluorescence traces in a scan. Default values work well for somatic scans.
Performed operations are:
[Initialization on full image | Initialization on patches -> merge components] ->
spatial update -> temporal update -> merge components -> spatial update ->
temporal update
:param np.array scan: 3-dimensional scan (image_height, image_width, num_frames).
:param np.memmap mmap_scan: 2-d scan (image_height * image_width, num_frames)
:param int num_components: An estimate of the number of spatial components in the scan
:param int num_background_components: Number of components to model the background.
:param int merge_threshold: Maximal temporal correlation allowed between the activity
of overlapping components before merging them.
:param bool init_on_patches: If True, run the initialization methods on small patches
of the scan rather than on the whole image.
:param string init_method: Initialization method for the components.
'greedy_roi': Look for a gaussian-shaped patch, apply rank-1 NMF, store
components, calculate residual scan and repeat for num_components.
'sparse_nmf': Regularized non-negative matrix factorization (as impl. in sklearn)
:param (float, float) soma_diameter: Estimated neuron size in y and x (pixels). Used
in'greedy_roi' initialization to search for neurons of this size.
:param int snmf_alpha: Regularization parameter (alpha) for sparse NMF (if used).
:param (float, float) patch_size: Size of the patches in y and x (pixels).
:param float proportion_patch_overlap: Patches are sampled in a sliding window. This
controls how much overlap is between adjacent patches (0 for none, 0.9 for 90%).
:param int num_components_per_patch: Number of components per patch (used if
init_on_patches=True)
:param int num_processes: Number of processes to run in parallel. None for as many
processes as available cores.
:param int num_pixels_per_process: Number of pixels that a process handles each
iteration.
:param fps: Frame rate. Used for temporal downsampling and to remove bad components.
:returns: Weighted masks (image_height x image_width x num_components). Inferred
location of each component.
:returns: Denoised fluorescence traces (num_components x num_frames).
:returns: Masks for background components (image_height x image_width x
num_background_components).
:returns: Traces for background components (image_height x image_width x
num_background_components).
:returns: Raw fluorescence traces (num_components x num_frames). Fluorescence of each
component in the scan minus activity from other components and background.
..warning:: The produced number of components is not exactly what you ask for because
some components will be merged or deleted.
..warning:: Better results if scans are nonnegative.
"""
# Get some params
image_height, image_width, num_frames = scan.shape
# Start processes
log('Starting {} processes...'.format(num_processes))
pool = mp.Pool(processes=num_processes)
# Initialize components
log('Initializing components...')
if init_on_patches:
# TODO: Redo this (per-patch initialization) in a nicer/more efficient way
# Make sure they are integers
patch_size = np.array(patch_size)
half_patch_size = np.int32(np.round(patch_size / 2))
num_components_per_patch = int(round(num_components_per_patch))
patch_overlap = np.int32(np.round(patch_size * proportion_patch_overlap))
# Create options dictionary (needed for run_CNMF_patches)
options = {'patch_params': {'ssub': 'UNUSED.', 'tsub': 'UNUSED', 'nb': num_background_components,
'only_init': True, 'skip_refinement': 'UNUSED.',
'remove_very_bad_comps': False}, # remove_very_bads_comps unnecesary (same as default)
'preprocess_params': {'check_nan': False}, # check_nan is unnecessary (same as default value)
'spatial_params': {'nb': num_background_components}, # nb is unnecessary, it is pased to the function and in init_params
'temporal_params': {'p': 0, 'method': 'UNUSED.', 'block_size': 'UNUSED.'},
'init_params': {'K': num_components_per_patch, 'gSig': np.array(soma_diameter)/2,
'gSiz': None, 'method': init_method, 'alpha_snmf': snmf_alpha,
'nb': num_background_components, 'ssub': 1, 'tsub': max(int(fps / 2), 1),
'options_local_NMF': 'UNUSED.', 'normalize_init': True,
'rolling_sum': True, 'rolling_length': 100, 'min_corr': 'UNUSED',
'min_pnr': 'UNUSED', 'deconvolve_options_init': 'UNUSED',
'ring_size_factor': 'UNUSED', 'center_psf': 'UNUSED'},
# gSiz, ssub, tsub, options_local_NMF, normalize_init, rolling_sum unnecessary (same as default values)
'merging' : {'thr': 'UNUSED.'}}
# Initialize per patch
res = map_reduce.run_CNMF_patches(mmap_scan.filename, (image_height, image_width, num_frames),
options, rf=half_patch_size, stride=patch_overlap,
gnb=num_background_components, dview=pool)
initial_A, initial_C, YrA, initial_b, initial_f, pixels_noise, _ = res
# Merge spatially overlapping components
merged_masks = ['dummy']
while len(merged_masks) > 0:
res = merging.merge_components(mmap_scan, initial_A, initial_b, initial_C,
initial_f, initial_C, pixels_noise,
{'p': 0, 'method': 'cvxpy'}, spatial_params='UNUSED',
dview=pool, thr=merge_threshold, mx=np.Inf)
initial_A, initial_C, num_components, merged_masks, S, bl, c1, neurons_noise, g = res
# Delete log files (one per patch)
log_files = glob.glob('caiman*_LOG_*')
for log_file in log_files:
os.remove(log_file)
else:
from scipy.sparse import csr_matrix
if init_method == 'greedy_roi':
res = _greedyROI(scan, num_components, soma_diameter, num_background_components)
log('Refining initial components (HALS)...')
res = initialization.hals(scan, res[0].reshape([image_height * image_width, -1], order='F'),
res[1], res[2].reshape([image_height * image_width, -1], order='F'),
res[3], maxIter=3)
initial_A, initial_C, initial_b, initial_f = res
else:
print('Warning: Running sparse_nmf initialization on the entire field of view '
'takes a lot of time.')
res = initialization.initialize_components(scan, K=num_components, nb=num_background_components,
method=init_method, alpha_snmf=snmf_alpha)
initial_A, initial_C, initial_b, initial_f, _ = res
initial_A = csr_matrix(initial_A)
log(initial_A.shape[-1], 'components found...')
# Remove bad components (based on spatial consistency and spiking activity)
log('Removing bad components...')
good_indices, _ = components_evaluation.estimate_components_quality(initial_C, scan,
initial_A, initial_C, initial_b, initial_f, final_frate=fps, r_values_min=0.7,
fitness_min=-20, fitness_delta_min=-20, dview=pool)
initial_A = initial_A[:, good_indices]
initial_C = initial_C[good_indices]
log(initial_A.shape[-1], 'components remaining...')
# Estimate noise per pixel
log('Calculating noise per pixel...')
pixels_noise, _ = pre_processing.get_noise_fft_parallel(mmap_scan, num_pixels_per_process, pool)
# Update masks
log('Updating masks...')
A, b, C, f = spatial.update_spatial_components(mmap_scan, initial_C, initial_f, initial_A, b_in=initial_b,
sn=pixels_noise, dims=(image_height, image_width),
method='dilate', dview=pool,
n_pixels_per_process=num_pixels_per_process,
nb=num_background_components)
# Update traces (no impulse response modelling p=0)
log('Updating traces...')
res = temporal.update_temporal_components(mmap_scan, A, b, C, f, nb=num_background_components,
block_size=10000, p=0, method='cvxpy', dview=pool)
C, A, b, f, S, bl, c1, neurons_noise, g, YrA, _ = res
# Merge components
log('Merging overlapping (and temporally correlated) masks...')
merged_masks = ['dummy']
while len(merged_masks) > 0:
res = merging.merge_components(mmap_scan, A, b, C, f, S, pixels_noise, {'p': 0, 'method': 'cvxpy'},
'UNUSED', dview=pool, thr=merge_threshold, bl=bl, c1=c1,
sn=neurons_noise, g=g)
A, C, num_components, merged_masks, S, bl, c1, neurons_noise, g = res
# Refine masks
log('Refining masks...')
A, b, C, f = spatial.update_spatial_components(mmap_scan, C, f, A, b_in=b, sn=pixels_noise,
dims=(image_height, image_width),
method='dilate', dview=pool,
n_pixels_per_process=num_pixels_per_process,
nb=num_background_components)
# Refine traces
log('Refining traces...')
res = temporal.update_temporal_components(mmap_scan, A, b, C, f, nb=num_background_components,
block_size=10000, p=0, method='cvxpy', dview=pool)
C, A, b, f, S, bl, c1, neurons_noise, g, YrA, _ = res
# Removing bad components (more stringent criteria)
log('Removing bad components...')
good_indices, _ = components_evaluation.estimate_components_quality(C + YrA, scan, A,
C, b, f, final_frate=fps, r_values_min=0.8, fitness_min=-40, fitness_delta_min=-40,
dview=pool)
A = A.toarray()[:, good_indices]
C = C[good_indices]
YrA = YrA[good_indices]
log(A.shape[-1], 'components remaining...')
# Stop processes
log('Done.')
pool.close()
# Get results
masks = A.reshape((image_height, image_width, -1), order='F') # h x w x num_components
traces = C # num_components x num_frames
background_masks = b.reshape((image_height, image_width, -1), order='F') # h x w x num_components
background_traces = f # num_background_components x num_frames
raw_traces = C + YrA # num_components x num_frames
# Rescale traces to match scan range (~ np.average(trace*mask, weights=mask))
scaling_factor = np.sum(masks**2, axis=(0, 1)) / np.sum(masks, axis=(0, 1))
traces = traces * np.expand_dims(scaling_factor, -1)
raw_traces = raw_traces * np.expand_dims(scaling_factor, -1)
masks = masks / scaling_factor
background_scaling_factor = np.sum(background_masks**2, axis=(0, 1)) / np.sum(background_masks,
axis=(0,1))
background_traces = background_traces * np.expand_dims(background_scaling_factor, -1)
background_masks = background_masks / background_scaling_factor
return masks, traces, background_masks, background_traces, raw_traces
def extract_masks(scan, mmap_scan, num_components=200, num_background_components=1,
merge_threshold=0.8, init_on_patches=True, init_method='greedy_roi',
soma_diameter=(14, 14), snmf_alpha=None, patch_size=(50, 50),
proportion_patch_overlap=0.2, num_components_per_patch=5,
num_processes=8, num_pixels_per_process=5000, fps=15):
""" Extract masks from multi-photon scans using CNMF.
Uses constrained non-negative matrix factorization to find spatial components (masks)
and their fluorescence traces in a scan. Default values work well for somatic scans.
Performed operations are:
[Initialization on full image | Initialization on patches -> merge components] ->
spatial update -> temporal update -> merge components -> spatial update ->
temporal update
:param np.array scan: 3-dimensional scan (image_height, image_width, num_frames).
:param np.memmap mmap_scan: 2-d scan (image_height * image_width, num_frames)
:param int num_components: An estimate of the number of spatial components in the scan
:param int num_background_components: Number of components to model the background.
:param int merge_threshold: Maximal temporal correlation allowed between the activity
of overlapping components before merging them.
:param bool init_on_patches: If True, run the initialization methods on small patches
of the scan rather than on the whole image.
:param string init_method: Initialization method for the components.
'greedy_roi': Look for a gaussian-shaped patch, apply rank-1 NMF, store
components, calculate residual scan and repeat for num_components.
'sparse_nmf': Regularized non-negative matrix factorization (as impl. in sklearn)
:param (float, float) soma_diameter: Estimated neuron size in y and x (pixels). Used
in'greedy_roi' initialization to search for neurons of this size.
:param int snmf_alpha: Regularization parameter (alpha) for sparse NMF (if used).
:param (float, float) patch_size: Size of the patches in y and x (pixels).
:param float proportion_patch_overlap: Patches are sampled in a sliding window. This
controls how much overlap is between adjacent patches (0 for none, 0.9 for 90%).
:param int num_components_per_patch: Number of components per patch (used if
init_on_patches=True)
:param int num_processes: Number of processes to run in parallel. None for as many
processes as available cores.
:param int num_pixels_per_process: Number of pixels that a process handles each
iteration.
:param fps: Frame rate. Used for temporal downsampling and to remove bad components.
:returns: Weighted masks (image_height x image_width x num_components). Inferred
location of each component.
:returns: Denoised fluorescence traces (num_components x num_frames).
:returns: Masks for background components (image_height x image_width x
num_background_components).
:returns: Traces for background components (image_height x image_width x
num_background_components).
:returns: Raw fluorescence traces (num_components x num_frames). Fluorescence of each
component in the scan minus activity from other components and background.
..warning:: The produced number of components is not exactly what you ask for because
some components will be merged or deleted.
..warning:: Better results if scans are nonnegative.
"""
# Get some params
image_height, image_width, num_frames = scan.shape
# Start processes
log('Starting {} processes...'.format(num_processes))
pool = mp.Pool(processes=num_processes)
# Initialize components
log('Initializing components...')
if init_on_patches:
# TODO: Redo this (per-patch initialization) in a nicer/more efficient way
# Make sure they are integers
patch_size = np.array(patch_size)
half_patch_size = np.int32(np.round(patch_size / 2))
num_components_per_patch = int(round(num_components_per_patch))
patch_overlap = np.int32(np.round(patch_size * proportion_patch_overlap))
# Create options dictionary (needed for run_CNMF_patches)
options = {'patch_params': {'ssub': 'UNUSED.', 'tsub': 'UNUSED', 'nb': num_background_components,
'only_init': True, 'skip_refinement': 'UNUSED.',
'remove_very_bad_comps': False}, # remove_very_bads_comps unnecesary (same as default)
'preprocess_params': {'check_nan': False}, # check_nan is unnecessary (same as default value)
'spatial_params': {'nb': num_background_components}, # nb is unnecessary, it is pased to the function and in init_params
'temporal_params': {'p': 0, 'method': 'UNUSED.', 'block_size': 'UNUSED.'},
'init_params': {'K': num_components_per_patch, 'gSig': np.array(soma_diameter)/2,
'gSiz': None, 'method': init_method, 'alpha_snmf': snmf_alpha,
'nb': num_background_components, 'ssub': 1, 'tsub': max(int(fps / 2), 1),
'options_local_NMF': 'UNUSED.', 'normalize_init': True,
'rolling_sum': True, 'rolling_length': 100, 'min_corr': 'UNUSED',
'min_pnr': 'UNUSED', 'deconvolve_options_init': 'UNUSED',
'ring_size_factor': 'UNUSED', 'center_psf': 'UNUSED'},
# gSiz, ssub, tsub, options_local_NMF, normalize_init, rolling_sum unnecessary (same as default values)
'merging' : {'thr': 'UNUSED.'}}
# Initialize per patch
res = map_reduce.run_CNMF_patches(mmap_scan.filename, (image_height, image_width, num_frames),
options, rf=half_patch_size, stride=patch_overlap,
gnb=num_background_components, dview=pool)
initial_A, initial_C, YrA, initial_b, initial_f, pixels_noise, _ = res
# Merge spatially overlapping components
merged_masks = ['dummy']
while len(merged_masks) > 0:
res = merging.merge_components(mmap_scan, initial_A, initial_b, initial_C,
initial_f, initial_C, pixels_noise,
{'p': 0, 'method': 'cvxpy'}, spatial_params='UNUSED',
dview=pool, thr=merge_threshold, mx=np.Inf)
initial_A, initial_C, num_components, merged_masks, S, bl, c1, neurons_noise, g = res
# Delete log files (one per patch)
log_files = glob.glob('caiman*_LOG_*')
for log_file in log_files:
os.remove(log_file)
else:
from scipy.sparse import csr_matrix
if init_method == 'greedy_roi':
res = _greedyROI(scan, num_components, soma_diameter, num_background_components)
log('Refining initial components (HALS)...')
res = initialization.hals(scan, res[0].reshape([image_height * image_width, -1], order='F'),
res[1], res[2].reshape([image_height * image_width, -1], order='F'),
res[3], maxIter=3)
initial_A, initial_C, initial_b, initial_f = res
else:
print('Warning: Running sparse_nmf initialization on the entire field of view '
'takes a lot of time.')
res = initialization.initialize_components(scan, K=num_components, nb=num_background_components,
method=init_method, alpha_snmf=snmf_alpha)
initial_A, initial_C, initial_b, initial_f, _ = res
initial_A = csr_matrix(initial_A)
log(initial_A.shape[-1], 'components found...')
# Remove bad components (based on spatial consistency and spiking activity)
log('Removing bad components...')
good_indices, _ = components_evaluation.estimate_components_quality(initial_C, scan,
initial_A, initial_C, initial_b, initial_f, final_frate=fps, r_values_min=0.7,
fitness_min=-20, fitness_delta_min=-20, dview=pool)
initial_A = initial_A[:, good_indices]
initial_C = initial_C[good_indices]
log(initial_A.shape[-1], 'components remaining...')
# Estimate noise per pixel
log('Calculating noise per pixel...')
pixels_noise, _ = pre_processing.get_noise_fft_parallel(mmap_scan, num_pixels_per_process, pool)
# Update masks
log('Updating masks...')
A, b, C, f = spatial.update_spatial_components(mmap_scan, initial_C, initial_f, initial_A, b_in=initial_b,
sn=pixels_noise, dims=(image_height, image_width),
method='dilate', dview=pool,
n_pixels_per_process=num_pixels_per_process,
nb=num_background_components)
# Update traces (no impulse response modelling p=0)
log('Updating traces...')
res = temporal.update_temporal_components(mmap_scan, A, b, C, f, nb=num_background_components,
block_size=10000, p=0, method='cvxpy', dview=pool)
C, A, b, f, S, bl, c1, neurons_noise, g, YrA, _ = res
# Merge components
log('Merging overlapping (and temporally correlated) masks...')
merged_masks = ['dummy']
while len(merged_masks) > 0:
res = merging.merge_components(mmap_scan, A, b, C, f, S, pixels_noise, {'p': 0, 'method': 'cvxpy'},
'UNUSED', dview=pool, thr=merge_threshold, bl=bl, c1=c1,
sn=neurons_noise, g=g)
A, C, num_components, merged_masks, S, bl, c1, neurons_noise, g = res
# Refine masks
log('Refining masks...')
A, b, C, f = spatial.update_spatial_components(mmap_scan, C, f, A, b_in=b, sn=pixels_noise,
dims=(image_height, image_width),
method='dilate', dview=pool,
n_pixels_per_process=num_pixels_per_process,
nb=num_background_components)
# Refine traces
log('Refining traces...')
res = temporal.update_temporal_components(mmap_scan, A, b, C, f, nb=num_background_components,
block_size=10000, p=0, method='cvxpy', dview=pool)
C, A, b, f, S, bl, c1, neurons_noise, g, YrA, _ = res
# Removing bad components (more stringent criteria)
log('Removing bad components...')
good_indices, _ = components_evaluation.estimate_components_quality(C + YrA, scan, A,
C, b, f, final_frate=fps, r_values_min=0.8, fitness_min=-40, fitness_delta_min=-40,
dview=pool)
A = A.toarray()[:, good_indices]
C = C[good_indices]
YrA = YrA[good_indices]
log(A.shape[-1], 'components remaining...')
# Stop processes
log('Done.')
pool.close()
# Get results
masks = A.reshape((image_height, image_width, -1), order='F') # h x w x num_components
traces = C # num_components x num_frames
background_masks = b.reshape((image_height, image_width, -1), order='F') # h x w x num_components
background_traces = f # num_background_components x num_frames
raw_traces = C + YrA # num_components x num_frames
# Rescale traces to match scan range
scaling_factor = np.sum(masks**2, axis=(0, 1)) / np.sum(masks, axis=(0, 1))
traces = traces * np.expand_dims(scaling_factor, -1)
raw_traces = raw_traces * np.expand_dims(scaling_factor, -1)
masks = masks / scaling_factor
background_scaling_factor = np.sum(background_masks**2, axis=(0, 1)) / np.sum(background_masks,
axis=(0,1))
background_traces = background_traces * np.expand_dims(background_scaling_factor, -1)
background_masks = background_masks / background_scaling_factor
return masks, traces, background_masks, background_traces, raw_traces
def fit(self, images):
"""
This method uses the cnmf algorithm to find sources in data.
Parameters
----------
images : mapped np.ndarray of shape (t,x,y[,z]) containing the images that vary over time.
Returns
--------
self
"""
T = images.shape[0]
dims = images.shape[1:]
Yr = images.reshape([T, np.prod(dims)], order='F').T
Y = np.transpose(images, list(range(1, len(dims) + 1)) + [0])
print((T,) + dims)
options = CNMFSetParms(Y, self.n_processes, p=self.p, gSig=self.gSig, K=self.k, ssub=self.ssub, tsub=self.tsub,
p_ssub=self.p_ssub, p_tsub=self.p_tsub, method_init=self.method_init,
n_pixels_per_process=self.n_pixels_per_process, block_size=self.block_size, check_nan=self.check_nan)
self.options = options
if self.rf is None: # no patches
print('preprocessing ...')
Yr, sn, g, psx = preprocess_data(Yr, dview=self.dview, **options['preprocess_params'])
if self.Ain is None:
print('initializing ...')
if self.alpha_snmf is not None:
options['init_params']['alpha_snmf'] = self.alpha_snmf
self.Ain, self.Cin, self.b_in, self.f_in, center = initialize_components(
Y, normalize=True, **options['init_params'])
if self.only_init: # only return values after initialization
nA = np.squeeze(np.array(np.sum(np.square(self.Ain),axis=0)))
nr=nA.size
Cin=scipy.sparse.coo_matrix(self.Cin)
YA = (self.Ain.T.dot(Yr).T)*scipy.sparse.spdiags(old_div(1.,nA),0,nr,nr)
AA = ((self.Ain.T.dot(self.Ain))*scipy.sparse.spdiags(old_div(1.,nA),0,nr,nr))
self.YrA = YA - Cin.T.dot(AA)
self.C = Cin.todense()
self.bl = None
self.c1 = None
self.neurons_sn = None
self.g = g
self.A = self.Ain
self.b = self.b_in
self.f = self.f_in
self.sn = sn
return self
print('update spatial ...')
A, b, Cin, self.f_in = update_spatial_components(Yr, self.Cin, self.f_in, self.Ain, sn=sn, dview=self.dview, **options['spatial_params'])
print('update temporal ...')
if not self.skip_refinement:
# set this to zero for fast updating without deconvolution
options['temporal_params']['p'] = 0
else:
options['temporal_params']['p'] = self.p
options['temporal_params']['method'] = self.method_deconvolution
C, f, S, bl, c1, neurons_sn, g, YrA = update_temporal_components(
Yr, A, b, Cin, self.f_in, dview=self.dview, **options['temporal_params'])
if not self.skip_refinement:
g1 = g
for _ in range(self.N_iterations_refinement):
if self.do_merge:
print('merge components ...')
A, C, nr, merged_ROIs, S, bl, c1, sn1, g1 = merge_components(Yr, A, b, C, f, S, sn, options['temporal_params'], options[
'spatial_params'], dview=self.dview, bl=bl, c1=c1, sn=neurons_sn, g=g1, thr=self.merge_thresh, mx=50, fast_merge=True)
print((A.shape))
print('update spatial ...')
A, b, C, f = update_spatial_components(
Yr, C, f, A, sn=sn, dview=self.dview, **options['spatial_params'])
# set it back to original value to perform full deconvolution
options['temporal_params']['p'] = self.p
print('update temporal ...')
C, f, S, bl, c1, neurons_sn, g1, YrA = update_temporal_components(
Yr, A, b, C, f, dview=self.dview, bl=None, c1=None, sn=None, g=None, **options['temporal_params'])
else:
A, b, C = A, b, Cin
C, f, S, bl, c1, neurons_sn, g1, YrA = C, f, S, bl, c1, neurons_sn, g, YrA
else: # use patches
if self.stride is None:
self.stride = np.int(self.rf * 2 * .1)
print(('**** Setting the stride to 10% of 2*rf automatically:' + str(self.stride)))
if type(images) is np.ndarray:
raise Exception(
'You need to provide a memory mapped file as input if you use patches!!')
if self.only_init:
options['patch_params']['only_init'] = True
if self.alpha_snmf is not None:
options['init_params']['alpha_snmf'] = self.alpha_snmf
A, C, YrA, b, f, sn, optional_outputs = run_CNMF_patches(images.filename, dims + (T,), options, rf=self.rf, stride=self.stride,
dview=self.dview, memory_fact=self.memory_fact, gnb=self.gnb)
options = CNMFSetParms(Y, self.n_processes, p=self.p, gSig=self.gSig, K=A.shape[
-1], thr=self.merge_thresh, n_pixels_per_process=self.n_pixels_per_process, block_size=self.block_size, check_nan=self.check_nan)
# pix_proc=np.minimum(np.int((d1*d2)/self.n_processes/(old_div(T,2000.))),np.int(old_div((d1*d2),self.n_processes))) # regulates the amount of memory used
# options['spatial_params']['n_pixels_per_process']=pix_proc
# options['temporal_params']['n_pixels_per_process']=pix_proc
options['temporal_params']['method'] = self.method_deconvolution
print("merging")
merged_ROIs = [0]
while len(merged_ROIs) > 0:
A, C, nr, merged_ROIs, S, bl, c1, sn_n, g = merge_components(Yr, A, [], np.array(C), [], np.array(
C), [], options['temporal_params'], options['spatial_params'], dview=self.dview, thr=self.merge_thresh, mx=np.Inf)
print("update temporal")
C, f, S, bl, c1, neurons_sn, g1, YrA = update_temporal_components(
Yr, A, b, C, f, dview=self.dview, bl=None, c1=None, sn=None, g=None, **options['temporal_params'])
# idx_components, fitness, erfc ,r_values, num_significant_samples = evaluate_components(Y,C+YrA,A,N=self.N_samples_fitness,robust_std=self.robust_std,thresh_finess=self.fitness_threshold)
# sure_in_idx= idx_components[np.logical_and(np.array(num_significant_samples)>0 ,np.array(r_values)>=self.corr_threshold)]
#
# print ('Keeping ' + str(len(sure_in_idx)) + ' components out of ' + str(len(idx_components)))
#
#
# A=A[:,sure_in_idx]
# C=C[sure_in_idx,:]
# YrA=YrA[sure_in_idx]
self.A=A
self.C=C
self.b=b
self.f=f
self.S = S
self.YrA=YrA
self.sn=sn
self.g = g1
self.bl = bl
self.c1 = c1
self.neurons_sn = neurons_sn
return self