def plot_contours_evaluated(row = None, session_wise = False):
'''
Plot contours for all cells, selected cells and non selected cells, and saves it in
figure_path = '/data/interim/component_evaluation/trial_wise/meta/figures/contours/'
:param row: one analysis state row
'''
index = row.name
corr_min = round(eval(row['source_extraction_parameters'])['min_corr'],1)
pnr_min = round(eval(row['source_extraction_parameters'])['min_pnr'],1)
r_min = eval(row['component_evaluation_parameters'])['rval_thr']
snf_min = eval(row['component_evaluation_parameters'])['min_SNR']
output_source_extraction = eval(row.loc['source_extraction_output'])
corr_path = output_source_extraction['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
output_component_evaluation = eval(row.loc['component_evaluation_output'])
cnm_file_path = output_component_evaluation['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
figure, axes = plt.subplots(1, 3)
axes[0].imshow(cn_filter)
axes[1].imshow(cn_filter)
axes[2].imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[0].plot(*v.T, c='w')
axes[0].set_title('All components')
axes[0].set_ylabel('Corr=' + f'{corr_min}' + ', PNR = ' + f'{pnr_min}' + ', PCC = ' + f'{r_min}' + ', SNR =' + f'{snf_min}')
idx = cnm.estimates.idx_components
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A[:,idx], np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[1].plot(*v.T, c='b')
axes[1].set_title('Accepted components')
idx_b = cnm.estimates.idx_components_bad
coordinates_b = cm.utils.visualization.get_contours(cnm.estimates.A[:,idx_b], np.shape(cn_filter), 0.2, 'max')
for c in coordinates_b:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[2].plot(*v.T, c='r')
axes[2].set_title('Rejected components')
figure_path = '/home/sebastian/Documents/Melisa/calcium_imaging_analysis/data/interim/component_evaluation/trial_wise/meta/figures/contours/'
if session_wise:
figure_path = '/home/sebastian/Documents/Melisa/calcium_imaging_analysis/data/interim/component_evaluation/session_wise/meta/figures/contours/'
figure_name = figure_path + db.create_file_name(5,index) + '.png'
figure.savefig(figure_name)
return figure
def plot_traces_multiple_evaluated(row = None, session_wise = False):
'''
Plots different versions of contour images that change the inicialization parameters for source extraccion.
The idea is to see the impact of different seed selection in the final source extraction result.
:param row: one analysis state row
:return: figure
'''
corr_min = round(eval(row['source_extraction_parameters'])['min_corr'],1)
pnr_min = round(eval(row['source_extraction_parameters'])['min_pnr'],1)
r_min = eval(row['component_evaluation_parameters'])['rval_thr']
snf_min = eval(row['component_evaluation_parameters'])['min_SNR']
output_source_extraction = eval(row.loc['source_extraction_output'])
corr_path = output_source_extraction['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
cnm_file_path = output_source_extraction['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
C = cnm.estimates.C
output_component_evaluation = eval(row.loc['component_evaluation_output'])
cnm_file_path = output_component_evaluation['main']
cnm_eval = load_CNMF(db.get_file(cnm_file_path))
idx = cnm_eval.estimates.idx_components
idx_b = cnm_eval.estimates.idx_components_bad
fig, ax = plt.subplots(1)
C[0] += C[0].min()
for i in range(1, len(C)):
C[i] += C[i].min() + C[:i].max()
if i in idx_b:
color = 'red'
else:
color = 'blue'
ax.plot(C[i],color = color)
ax.set_xlabel('t [frames]')
ax.set_yticks([])
ax.set_ylabel('activity')
ax.set_title('Corr=' + f'{corr_min}' + ', PNR = ' + f'{pnr_min}' + ', PCC = ' + f'{r_min}' + ', SNR =' + f'{snf_min}')
fig.set_size_inches([10., .3 * len(C)])
fig_dir = 'data/interim/component_evaluation/trial_wise/meta/figures/traces/'
if session_wise:
fig_dir = 'data/interim/component_evaluation/session_wise/meta/figures/traces/'
fig_name = fig_dir + db.create_file_name(5,row.name) + '.png'
fig.savefig(fig_name)
return
def plot_multiple_contours_session_wise(selected_rows, version = None , corr_array = None, pnr_array = None):
'''
Plots different versions of contour images that change the initialization parameters for source extraction.
The idea is to see the impact of different seed selection in the final source extraction result.
:param selected_rows: all analysis state selected
:param version: array containing the version numbers of source extraction that will be plotted
:param corr_array: array of the same length of version and pnr_array containing the min_corr values for those versions
:param pnr_array: array of the same length of version and corr_array containing the min_pnr values for those versions
:return: figure
'''
states_df = db.open_analysis_states_database()
figure, axes = plt.subplots(len(corr_array), len(pnr_array), figsize=(15, 15))
color = ['w','b','r','m','c']
for row in range(len(selected_rows)):
mouse_row = selected_rows.iloc[row]
index = mouse_row.name
output = eval(mouse_row.loc['source_extraction_output'])
corr_path = output['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
for ii in range(corr_array.shape[0]):
for jj in range(pnr_array.shape[0]):
axes[ii, jj].imshow(cn_filter)
new_row = db.select(states_df, 'component_evaluation', mouse=index[0], session=index[1],
trial=index[2], is_rest=index[3], cropping_v=index[5], motion_correction_v=index[6],
source_extraction_v=version[ii * len(pnr_array) + jj])
new_row = new_row.iloc[0]
output = eval(new_row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[ii, jj].plot(*v.T, c = color[row])
axes[ii, jj].set_title('min_corr = ' + f'{round(corr_array[ii],2)}')
axes[ii, jj].set_ylabel('min_pnr = ' + f'{round(pnr_array[jj],2)}')
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/contours/'
fig_name = fig_dir + db.create_file_name(3, new_row.name)+'_corr_min' + f'{round(corr_array[0],1)}'+ '_pnr_min'+f'{round(pnr_array[0],1)}' + '_all.png'
figure.savefig(fig_name)
return figure
def plot_source_extraction_result_specific_cell(mouse_row_new, cell_number):
'''
(Still need to be finished) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
THERE IS AN ERROR IN THE
In the first plot shows correlation image and contour of the selected neurons.
In the second plot shows the traces for the selected neurons.
:param mouse_row_new: data base row
:param cell_number: array with the cells that are selected to be ploted
:return: None
'''
corr_min = round(eval(mouse_row_new['source_extraction_parameters'])['min_corr'], 1)
pnr_min = round(eval(mouse_row_new['source_extraction_parameters'])['min_pnr'], 1)
output_source_extraction = eval(mouse_row_new.loc['source_extraction_output'])
corr_path = output_source_extraction['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
cnm_file_path = output_source_extraction['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
f, (a0, a1) = plt.subplots(2, 1, gridspec_kw={'height_ratios': [3, 1]})
a0.imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for i in cell_number:
v = coordinates[i]['coordinates']
coordinates[i]['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
a0.plot(*v.T, c='w')
a0.set_title('Contour Plot')
fig, ax = plt.subplots(1)
C = cnm.estimates.C
C[0] += C[0].min()
for i in range(cell_number):
C[i] += C[i].min() + C[:i].max()
a1.plot(C[i])
a1.set_xlabel('t [frames]')
a1.set_yticks([])
a1.set_title('Calcium Traces')
fig.set_size_inches([10., .3 * len(C)])
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/'
fig_name = fig_dir + db.create_file_name(3, mouse_row_new.name) + '_example.png'
f.savefig(fig_name)
return
def plot_source_extraction_result(mouse_row_new):
'''
Generates and saves a contour plot and a trace plot for the specific mouse_row
'''
corr_min = round(eval(mouse_row_new['source_extraction_parameters'])['min_corr'], 1)
pnr_min = round(eval(mouse_row_new['source_extraction_parameters'])['min_pnr'], 1)
output_source_extraction = eval(mouse_row_new.loc['source_extraction_output'])
corr_path = output_source_extraction['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
cnm_file_path = output_source_extraction['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
figure, axes = plt.subplots(1)
axes.imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes.plot(*v.T, c='w')
axes.set_title('min_corr = ' + f'{corr_min}')
axes.set_ylabel('min_pnr = ' + f'{pnr_min}')
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/contours/'
file_name = db.create_file_name(3, mouse_row_new.name)
figure.savefig(fig_dir + file_name + '.png')
## up to here
fig, ax = plt.subplots(1)
C = cnm.estimates.C
C[0] += C[0].min()
for i in range(1, len(C)):
C[i] += C[i].min() + C[:i].max()
ax.plot(C[i])
ax.set_xlabel('t [frames]')
ax.set_yticks([])
ax.set_ylabel('activity')
fig.set_size_inches([10., .3 * len(C)])
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/traces/'
fig_name = fig_dir + db.create_file_name(3, mouse_row_new.name) + '.png'
fig.savefig(fig_name)
return
def plot_multiple_contours(rows, version = None , corr_array = None, pnr_array = None,session_wise = False):
'''
Plots different versions of contour images that change the initialization parameters for source extraction.
The idea is to see the impact of different seed selection in the final source extraction result.
:param row: one analysis state row
:param version: array containing the version numbers of source extraction that will be plotted
:param corr_array: array of the same length of version and pnr_array containing the min_corr values for those versions
:param pnr_array: array of the same length of version and corr_array containing the min_pnr values for those versions
:return: figure
'''
figure, axes = plt.subplots(len(corr_array), len(pnr_array), figsize=(15, 15))
for ii in range(corr_array.shape[0]):
for jj in range(pnr_array.shape[0]):
version_number = ii *corr_array.shape[0] + jj + 1
if version_number in version:
new_row = rows.query('(source_extraction_v == ' + f'{version_number}' + ')')
new_row = new_row.iloc[0]
output = eval(new_row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
corr_path = output['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
axes[ii, jj].imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[ii, jj].plot(*v.T, c='w')
axes[ii, jj].set_title('min_corr = ' + f'{round(corr_array[ii],2)}')
axes[ii, jj].set_ylabel('min_pnr = ' + f'{round(pnr_array[jj],2)}')
fig_dir = 'data/interim/source_extraction/trial_wise/meta/figures/contours/'
if session_wise:
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/contours/'
fig_name = fig_dir + db.create_file_name(3, new_row.name)+'_corr_min' + f'{round(corr_array[0],1)}'+ '_pnr_min'+f'{round(pnr_array[0],1)}' + '_.png'
figure.savefig(fig_name)
return figure
def plot_session_contours(selected_rows, version = None , corr_array = None, pnr_array = None):
'''
Plots different versions of contour images that change the initialization parameters for source extraction.
The idea is to see the impact of different seed selection in the final source extraction result.
:param selected_rows: rows corresponding to different trials
:param version: array containing the version numbers of source extraction that will be plotted
:param corr_array: array of the same length of version and pnr_array containing the min_corr values for those versions
:param pnr_array: array of the same length of version and corr_array containing the min_pnr values for those versions
:return: (saves multiple figures)
'''
for ii in range(corr_array.shape[0]):
for jj in range(pnr_array.shape[0]):
figure, axes = plt.subplots(len(selected_rows) / 5, 5, figsize=(50, 10*len(selected_rows) / 5))
version_rows = selected_rows.query('(source_extraction_v == ' + f'{ii * len(corr_array.shape[0] + jj)}' + ')')
for day in range(len(selected_rows)/5):
for trial in range(5):
new_row = version_rows.iloc[day*5+trial]
output = eval(new_row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
corr_path = output['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
#axes[i].imshow(np.clip(cn_filter, min_corr, max_corr), cmap='viridis')
axes[day,trial].imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[day,trial].plot(*v.T, c='w')
axes[day,trial].set_title('Trial = ' + f'{i+1}',fontsize=30)
axes[day,trial].set_xlabel('#cells = ' + f'{cnm.estimates.A.shape[1]}',fontsize=30)
figure.suptitle('min_corr = ' + f'{round(corr_array[ii],2)}' + 'min_pnr = ' + f'{round(pnr_array[jj],2)}', fontsize=50)
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/contours/'
fig_name = fig_dir + db.create_file_name(3, new_row.name)+'_version_' + f'{version[ii*len(pnr_array)+jj]}'+'.png'
figure.savefig(fig_name)
return
def plot_traces_multiple(rows, version = None , corr_array = None, pnr_array = None, session_wise = False):
'''
Plots different versions of contour images that change the inicialization parameters for source extraccion.
The idea is to see the impact of different seed selection in the final source extraction result.
:param row: one analysis state row
:param version: array containing the version numbers of source extraction that will be ploted
:param corr_array: array of the same length of version and pnr_array containing the min_corr values for those versions
:param pnr_array: array of the same length of version and corr_array containing the min_pnr values for those versions
:param: session_wise bool that indicates where the figure is save
:return: None
'''
for ii in range(corr_array.shape[0]):
for jj in range(pnr_array.shape[0]):
fig, ax = plt.subplots(1)
new_row = rows.query('(source_extraction_v == ' + f'{ii *corr_array.shape[0] + jj + 1}' + ')')
new_row = new_row.iloc[0]
output = eval(new_row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
C = cnm.estimates.C
idx_components = cnm.estimates.idx_components
C[0] += C[0].min()
for i in range(1, len(C)):
C[i] += C[i].min() + C[:i].max()
ax.plot(C[i])
ax.set_xlabel('t [frames]')
ax.set_yticks([])
ax.set_ylabel('activity')
fig.set_size_inches([10., .3 * len(C)])
fig_dir = 'data/interim/source_extraction/trial_wise/meta/figures/traces/'
if session_wise:
fig_dir = 'data/interim/source_extraction/session_wise/meta/figures/traces/'
fig_name = fig_dir + db.create_file_name(3,new_row.name) + '_corr_min' + f'{round(corr_array[ii], 1)}' + '_pnr_min' + f'{round(pnr_array[jj], 1)}' + '_.png'
fig.savefig(fig_name)
return
def plot_multiple_contours_session_wise_evaluated(selected_rows):
## IN DEVELOPMENT!!!!!!!
'''
Plots different versions of contour images that change the initialization parameters for source extraction.
The idea is to see the impact of different seed selection in the final source extraction result.
:param selected_rows: all analysis state selected
:return: figure
'''
figure, axes = plt.subplots(3, 5, figsize=(50, 30))
for row in range(len(selected_rows)):
mouse_row = selected_rows.iloc[row]
index = mouse_row.name
output = eval(mouse_row.loc['source_extraction_output'])
corr_path = output['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
axes[0,row].imshow(cn_filter)
axes[1,row].imshow(cn_filter)
axes[2,row].imshow(cn_filter)
output = eval(mouse_row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[0,row].plot(*v.T, c = 'w', linewidth=3)
axes[0,row].set_title('Trial = ' + f'{row}')
axes[0,row].set_ylabel('')
output = eval(mouse_row.loc['component_evaluation_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
idx = cnm.estimates.idx_components
coordinates = cm.utils.visualization.get_contours(cnm.estimates.A[:, idx], np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[1,row].plot(*v.T, c='b', linewidth=3)
idx_b = cnm.estimates.idx_components_bad
coordinates_b = cm.utils.visualization.get_contours(cnm.estimates.A[:,idx_b], np.shape(cn_filter), 0.2, 'max')
for c in coordinates_b:
v = c['coordinates']
c['bbox'] = [np.floor(np.nanmin(v[:, 1])), np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])), np.ceil(np.nanmax(v[:, 0]))]
axes[2,row].plot(*v.T, c='r', linewidth=3)
source_extraction_parameters = eval(mouse_row['source_extraction_parameters'])
corr_lim = source_extraction_parameters['min_corr']
pnr_lim = source_extraction_parameters['min_pnr']
component_evaluation_parameters = eval(mouse_row['component_evaluation_parameters'])
pcc = component_evaluation_parameters['rval_thr']
SNR = component_evaluation_parameters['min_SNR']
figure.suptitle('Corr = ' + f'{corr_lim}' + 'PNR = ' + f'{pnr_lim}' + 'PCC = ' + f'{pcc}' + 'SNR = ' + f'{SNR}',
fontsize=50)
fig_dir = 'data/interim/component_evaluation/session_wise/meta/figures/contours/'
fig_name = fig_dir + db.create_file_name(3, index)+'_Corr = ' + f'{corr_lim}' + '_PNR = ' + f'{pnr_lim}' + '_PCC = ' + f'{pcc}' + '_SNR = ' + f'{SNR}' +'_.png'
figure.savefig(fig_name)
return figure
def create_video(row, time_cropping, session_wise = False):
'''
This fuction creates a complete video with raw movie (motion corrected), source extracted cells and source extraction + background.
:param row: pandas dataframe containing the desired processing information to create the video. It can use the session_wise or trial_wise video.
:return:
'''
if session_wise:
input_mmap_file_path = eval(row.loc['alignment_output'])['main']
else:
input_mmap_file_path = eval(row.loc['motion_correction_output'])['main']
#load the mmap file
Yr, dims, T = cm.load_memmap(input_mmap_file_path)
logging.debug(f'{row.name} Loaded movie. dims = {dims}, T = {T}.')
#create a caiman movie with the mmap file
images = Yr.T.reshape((T,) + dims, order='F')
images = cm.movie(images)
#load source extraction result
output = eval(row.loc['source_extraction_output'])
cnm_file_path = output['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
#estimate the background from the extraction
W, b0 = cm.source_extraction.cnmf.initialization.compute_W(Yr, cnm.estimates.A.toarray(), cnm.estimates.C,
cnm.estimates.dims, 1.4 * 5, ssub=2)
cnm.estimates.W = W
cnm.estimates.b0 = b0
# this part could be use with the lastest caiman version
# movie_dir = '/home/sebastian/Documents/Melisa/calcium_imaging_analysis/data/processed/movies/'
# file_name = db.create_file_name(5,row.name)
# cnm.estimates.play_movie(cnm.estimates, images, movie_name= movie_dir + file_name + '.avi')
frame_range = slice(None, None, None)
# create a movie with the model : estimated A and C matrix
Y_rec = cnm.estimates.A.dot(cnm.estimates.C[:, frame_range])
Y_rec = Y_rec.reshape(dims + (-1,), order='F')
Y_rec = Y_rec.transpose([2, 0, 1])
# convert the variable to a caiman movie type
Y_rec = cm.movie(Y_rec)
## this part of the function is a copy from a caiman version
ssub_B = int(round(np.sqrt(np.prod(dims) / W.shape[0])))
B = images[frame_range].reshape((-1, np.prod(dims)), order='F').T - \
cnm.estimates.A.dot(cnm.estimates.C[:, frame_range])
if ssub_B == 1:
B = b0[:, None] + W.dot(B - b0[:, None])
else:
B = b0[:, None] + (np.repeat(np.repeat(W.dot(
downscale(B.reshape(dims + (B.shape[-1],), order='F'),
(ssub_B, ssub_B, 1)).reshape((-1, B.shape[-1]), order='F') -
downscale(b0.reshape(dims, order='F'),
(ssub_B, ssub_B)).reshape((-1, 1), order='F'))
.reshape(
((dims[0] - 1) // ssub_B + 1, (dims[1] - 1) // ssub_B + 1, -1), order='F'),
ssub_B, 0), ssub_B, 1)[:dims[0], :dims[1]].reshape(
(-1, B.shape[-1]), order='F'))
B = B.reshape(dims + (-1,), order='F').transpose([2, 0, 1])
Y_rec_2 = Y_rec + B
Y_res = images[frame_range] - Y_rec - B
images_np = np.zeros((time_cropping[1]-time_cropping[0],images.shape[1],images.shape[2]))
images_np = images[time_cropping[0]:time_cropping[1],:,:]
images_np = images_np / np.max(images_np)
images_np = cm.movie(images_np)
Y_rec_np = np.zeros((time_cropping[1]-time_cropping[0],images.shape[1],images.shape[2]))
Y_rec_np = Y_rec[time_cropping[0]:time_cropping[1],:,:]
Y_rec_np = Y_rec_np / np.max(Y_rec_np)
Y_rec_np = cm.movie(Y_rec_np)
Y_res_np = np.zeros((time_cropping[1]-time_cropping[0],images.shape[1],images.shape[2]))
Y_res_np = Y_res[time_cropping[0]:time_cropping[1],:,:]
Y_res_np = Y_res_np / np.max(Y_res_np)
Y_res_np = cm.movie(Y_res_np)
B_np = np.zeros((time_cropping[1]-time_cropping[0],images.shape[1],images.shape[2]))
B_np = B[time_cropping[0]:time_cropping[1],:,:]
B_np = B_np / np.max(B_np)
B_np = cm.movie(B_np)
mov1 = cm.concatenate((images_np, Y_rec_np), axis=2)
mov2 = cm.concatenate((B_np, Y_res_np), axis=2)
mov = cm.concatenate((mov1, mov2), axis=1)
figure_path = '/home/sebastian/Documents/Melisa/calcium_imaging_analysis/data/interim/movies/'
figure_name = db.create_file_name(5,row.name)
#mov.save(figure_path+figure_name+'.tif')
mov.save(figure_path+figure_name+'_'+f'{time_cropping[0]}' + '_' + f'{time_cropping[1]}'+'.tif')
return
_x - x_,
fill=False,
color='r',
linestyle='--',
linewidth=3)
axes[kk, 0].add_patch(rect)
output_cropping = mouse_row['cropping_output']
cropped_file = eval(output_cropping)['main']
m = cm.load(cropped_file)
axes[kk, 1].imshow(m[0, :, :], cmap='gray')
output_source_extraction = eval(
mouse_row['source_extraction_output'])
cnm_file_path = output_source_extraction['main']
cnm = load_CNMF(db.get_file(cnm_file_path))
corr_path = output_source_extraction['meta']['corr']['main']
cn_filter = np.load(db.get_file(corr_path))
axes[kk, 2].imshow(cn_filter)
coordinates = cm.utils.visualization.get_contours(
cnm.estimates.A, np.shape(cn_filter), 0.2, 'max')
for c in coordinates:
v = c['coordinates']
c['bbox'] = [
np.floor(np.nanmin(v[:, 1])),
np.ceil(np.nanmax(v[:, 1])),
np.floor(np.nanmin(v[:, 0])),
np.ceil(np.nanmax(v[:, 0]))
]
axes[kk, 2].plot(*v.T, c='w', linewidth=3)
is_rest=is_rest,
decoding_v=decoding_version,
cropping_v=cropping_version,
motion_correction_v=motion_correction,
alignment_v=alignment_version,
source_extraction_v=source_extraction_version,
component_evaluation_v=component_evaluation_version)
for i in range(len(selected_rows)):
row = selected_rows.iloc[i]
component_evaluation_hdf5_file_path = eval(
row['component_evaluation_output'])['main']
corr_path = eval(
row['source_extraction_output'])['meta']['corr']['main']
cnm = load_CNMF(component_evaluation_hdf5_file_path)
cn_filter = np.load(db.get_file(corr_path))
FOV_size.append(cn_filter.shape)
A_size.append(cnm.estimates.A.shape[0])
A_number_components.append(cnm.estimates.idx_components.shape[0])
A_list.append(cnm.estimates.A[:, cnm.estimates.idx_components])
C_dims.append(cnm.estimates.C.shape)
size = cnm.estimates.A[:, cnm.estimates.idx_components].sum(axis=0)
for j in range(len(cnm.estimates.idx_components)):
typical_size.append(size[0, j])
C_list.append(cnm.estimates.C[cnm.estimates.idx_components, :])
evaluated_trials.append((selected_rows.iloc[i].name[2] - 1) * 2 +
selected_rows.iloc[i].name[3] + 1)
## add a size restriction on the neurons that will further be proceced. This restriction boudary
# decision is based in the histogram of typical neuronal sizes