def test_mergeROIs(self): roi1 = ia.WeightedROI(np.arange(9).reshape((3, 3))) roi2 = ia.WeightedROI(np.arange(1, 10).reshape((3, 3))) merged_ROI = sca.merge_weighted_rois(roi1, roi2) merged_ROI2 = sca.merge_binary_rois(roi1, roi2) assert (np.array_equal(merged_ROI.get_weighted_mask(), np.arange(1, 18, 2).reshape((3, 3)))) assert (np.array_equal(merged_ROI2.get_binary_mask(), np.ones((3, 3))))
def get_traces(params): t0 = time.time() chunk_ind, chunk_start, chunk_end, nwb_path, data_path, curr_folder, center_array, surround_array = params nwb_f = h5py.File(nwb_path, 'r') print('\nstart analyzing chunk: {}'.format(chunk_ind)) curr_mov = nwb_f[data_path][chunk_start:chunk_end] nwb_f.close() # print 'extracting traces' curr_traces_center = np.empty((center_array.shape[0], curr_mov.shape[0]), dtype=np.float32) curr_traces_surround = np.empty((center_array.shape[0], curr_mov.shape[0]), dtype=np.float32) for i in range(center_array.shape[0]): curr_center = ia.WeightedROI(center_array[i]) curr_surround = ia.ROI(surround_array[i]) curr_traces_center[i, :] = curr_center.get_weighted_trace_pixelwise( curr_mov) # scale surround trace to be similar as center trace mean_center_weight = curr_center.get_mean_weight() curr_traces_surround[i, :] = curr_surround.get_binary_trace_pixelwise( curr_mov) * mean_center_weight # print 'saveing chunk {} ...'.format(chunk_ind) chunk_folder = os.path.join(curr_folder, 'chunks') if not os.path.isdir(chunk_folder): os.mkdir(chunk_folder) chunk_f = h5py.File( os.path.join(chunk_folder, 'chunk_temp_' + ft.int2str(chunk_ind, 4) + '.hdf5')) chunk_f['traces_center'] = curr_traces_center chunk_f['traces_surround'] = curr_traces_surround chunk_f.close() print('\n\t{:06d} seconds: chunk: {}; demixing finished.'.format( int(time.time() - t0), chunk_ind)) return None
mask_nor = (mask - np.mean(mask.flatten())) / np.abs( np.std(mask.flatten())) mask_nor_f = ni.filters.gaussian_filter(mask_nor, filter_sigma) mask_bin = np.zeros(mask_nor_f.shape, dtype=np.uint8) mask_bin[mask_nor_f > cut_thr] = 1 else: mask_bin = np.zeros(mask.shape, dtype=np.uint8) mask_bin[mask > 0] = 1 mask_labeled, mask_num = ni.label(mask_bin) curr_mask_dict = ia.get_masks(labeled=mask_labeled, keyPrefix='caiman_mask_{:03d}'.format(i), labelLength=5) for roi_key, roi_mask in curr_mask_dict.items(): final_roi_dict.update({roi_key: ia.WeightedROI(roi_mask * mask)}) print('Total number of ROIs:', len(final_roi_dict)) f = plt.figure(figsize=(15, 8)) ax1 = f.add_subplot(121) ax1.imshow(bg, vmin=0, vmax=0.5, cmap='gray', interpolation='nearest') colors1 = pt.random_color(masks.shape[0]) for i, mask in enumerate(masks): pt.plot_mask_borders(mask, plotAxis=ax1, color=colors1[i]) ax1.set_title('original ROIs') ax1.set_axis_off() ax2 = f.add_subplot(122) ax2.imshow(ia.array_nor(bg), vmin=0, vmax=0.5,
def add_rois_and_traces( data_folder, nwb_f, plane_n, imaging_depth, mov_path='/processing/motion_correction/MotionCorrection'): mov_grp = nwb_f.file_pointer[mov_path + '/' + plane_n + '/corrected'] data_f = h5py.File(os.path.join(data_folder, 'rois_and_traces.hdf5'), 'r') mask_arr_c = data_f['masks_center'].value mask_arr_s = data_f['masks_surround'].value traces_center_raw = data_f['traces_center_raw'].value # traces_center_demixed = data_f['traces_center_demixed'].value traces_center_subtracted = data_f['traces_center_subtracted'].value # traces_center_dff = data_f['traces_center_dff'].value traces_surround_raw = data_f['traces_surround_raw'].value neuropil_r = data_f['neuropil_r'].value neuropil_err = data_f['neuropil_err'].value data_f.close() if traces_center_raw.shape[1] != mov_grp['num_samples'].value: raise ValueError( 'number of trace time points ({}) does not match frame number of ' 'corresponding movie ({}).'.format(traces_center_raw.shape[1], mov_grp['num_samples'].value)) # traces_center_raw = traces_center_raw[:, :mov_grp['num_samples'].value] # traces_center_subtracted = traces_center_subtracted[:, :mov_grp['num_samples'].value] # traces_surround_raw = traces_surround_raw[:, :mov_grp['num_samples'].value] rf_img_max = tf.imread( os.path.join(data_folder, 'corrected_max_projection.tif')) rf_img_mean = tf.imread( os.path.join(data_folder, 'corrected_mean_projection.tif')) print('adding segmentation results ...') rt_mo = nwb_f.create_module('rois_and_traces_' + plane_n) rt_mo.set_value('imaging_depth_micron', imaging_depth) is_if = rt_mo.create_interface('ImageSegmentation') is_if.create_imaging_plane('imaging_plane', description='') is_if.add_reference_image('imaging_plane', 'max_projection', rf_img_max) is_if.add_reference_image('imaging_plane', 'mean_projection', rf_img_mean) for i in range(mask_arr_c.shape[0]): curr_cen = mask_arr_c[i] curr_cen_n = 'roi_' + ft.int2str(i, 4) curr_cen_roi = ia.WeightedROI(curr_cen) curr_cen_pixels_yx = curr_cen_roi.get_pixel_array() curr_cen_pixels_xy = np.array( [curr_cen_pixels_yx[:, 1], curr_cen_pixels_yx[:, 0]]).transpose() is_if.add_roi_mask_pixels(image_plane='imaging_plane', roi_name=curr_cen_n, desc='', pixel_list=curr_cen_pixels_xy, weights=curr_cen_roi.weights, width=512, height=512) curr_sur = mask_arr_s[i] curr_sur_n = 'surround_' + ft.int2str(i, 4) curr_sur_roi = ia.ROI(curr_sur) curr_sur_pixels_yx = curr_sur_roi.get_pixel_array() curr_sur_pixels_xy = np.array( [curr_sur_pixels_yx[:, 1], curr_sur_pixels_yx[:, 0]]).transpose() is_if.add_roi_mask_pixels(image_plane='imaging_plane', roi_name=curr_sur_n, desc='', pixel_list=curr_sur_pixels_xy, weights=None, width=512, height=512) is_if.finalize() trace_f_if = rt_mo.create_interface('Fluorescence') seg_if_path = '/processing/rois_and_traces_' + plane_n + '/ImageSegmentation/imaging_plane' # print seg_if_path ts_path = mov_path + '/' + plane_n + '/corrected' print('adding center fluorescence raw') trace_raw_ts = nwb_f.create_timeseries('RoiResponseSeries', 'f_center_raw') trace_raw_ts.set_data(traces_center_raw, unit='au', conversion=np.nan, resolution=np.nan) trace_raw_ts.set_value('data_format', 'roi (row) x time (column)') trace_raw_ts.set_value('data_range', '[-8192, 8191]') trace_raw_ts.set_description( 'fluorescence traces extracted from the center region of each roi') trace_raw_ts.set_time_as_link(ts_path) trace_raw_ts.set_value_as_link('segmentation_interface', seg_if_path) roi_names = [ 'roi_' + ft.int2str(ind, 4) for ind in range(traces_center_raw.shape[0]) ] trace_raw_ts.set_value('roi_names', roi_names) trace_raw_ts.set_value('num_samples', traces_center_raw.shape[1]) trace_f_if.add_timeseries(trace_raw_ts) trace_raw_ts.finalize() print('adding neuropil fluorescence raw') trace_sur_ts = nwb_f.create_timeseries('RoiResponseSeries', 'f_surround_raw') trace_sur_ts.set_data(traces_surround_raw, unit='au', conversion=np.nan, resolution=np.nan) trace_sur_ts.set_value('data_format', 'roi (row) x time (column)') trace_sur_ts.set_value('data_range', '[-8192, 8191]') trace_sur_ts.set_description( 'neuropil traces extracted from the surroud region of each roi') trace_sur_ts.set_time_as_link(ts_path) trace_sur_ts.set_value_as_link('segmentation_interface', seg_if_path) sur_names = [ 'surround_' + ft.int2str(ind, 4) for ind in range(traces_center_raw.shape[0]) ] trace_sur_ts.set_value('roi_names', sur_names) trace_sur_ts.set_value('num_samples', traces_surround_raw.shape[1]) trace_f_if.add_timeseries(trace_sur_ts) trace_sur_ts.finalize() roi_center_n_path = '/processing/rois_and_traces_' + plane_n + '/Fluorescence/f_center_raw/roi_names' # print 'adding center fluorescence demixed' # trace_demix_ts = nwb_f.create_timeseries('RoiResponseSeries', 'f_center_demixed') # trace_demix_ts.set_data(traces_center_demixed, unit='au', conversion=np.nan, resolution=np.nan) # trace_demix_ts.set_value('data_format', 'roi (row) x time (column)') # trace_demix_ts.set_description('center traces after overlapping demixing for each roi') # trace_demix_ts.set_time_as_link(mov_path + '/' + plane_n + '/corrected') # trace_demix_ts.set_value_as_link('segmentation_interface', seg_if_path) # trace_demix_ts.set_value('roi_names', roi_names) # trace_demix_ts.set_value('num_samples', traces_center_demixed.shape[1]) # trace_f_if.add_timeseries(trace_demix_ts) # trace_demix_ts.finalize() print('adding center fluorescence after neuropil subtraction') trace_sub_ts = nwb_f.create_timeseries('RoiResponseSeries', 'f_center_subtracted') trace_sub_ts.set_data(traces_center_subtracted, unit='au', conversion=np.nan, resolution=np.nan) trace_sub_ts.set_value('data_format', 'roi (row) x time (column)') trace_sub_ts.set_description( 'center traces after overlap demixing and neuropil subtraction for each roi' ) trace_sub_ts.set_time_as_link(mov_path + '/' + plane_n + '/corrected') trace_sub_ts.set_value_as_link('segmentation_interface', seg_if_path) trace_sub_ts.set_value_as_link('roi_names', roi_center_n_path) trace_sub_ts.set_value('num_samples', traces_center_subtracted.shape[1]) trace_sub_ts.set_value('r', neuropil_r, dtype='float32') trace_sub_ts.set_value('rmse', neuropil_err, dtype='float32') trace_sub_ts.set_comments( 'value "r": neuropil contribution ratio for each roi. ' 'value "rmse": RMS error of neuropil subtraction for each roi') trace_f_if.add_timeseries(trace_sub_ts) trace_sub_ts.finalize() trace_f_if.finalize() # print 'adding global dF/F traces for each roi' # trace_dff_if = rt_mo.create_interface('DfOverF') # # trace_dff_ts = nwb_f.create_timeseries('RoiResponseSeries', 'dff_center') # trace_dff_ts.set_data(traces_center_dff, unit='au', conversion=np.nan, resolution=np.nan) # trace_dff_ts.set_value('data_format', 'roi (row) x time (column)') # trace_dff_ts.set_description('global df/f traces for each roi center, input fluorescence is the trace after demixing' # ' and neuropil subtraction. global df/f is calculated by ' # 'allensdk.brain_observatory.dff.compute_dff() function.') # trace_dff_ts.set_time_as_link(ts_path) # trace_dff_ts.set_value_as_link('segmentation_interface', seg_if_path) # trace_dff_ts.set_value('roi_names', roi_names) # trace_dff_ts.set_value('num_samples', traces_center_dff.shape[1]) # trace_dff_if.add_timeseries(trace_dff_ts) # trace_dff_ts.finalize() # trace_dff_if.finalize() rt_mo.finalize()