def test_getTrace(self): mov = np.arange(64).reshape((4, 4, 4)) # print mov mask1 = np.zeros((4, 4)) mask1[2, 2] = 1 mask1[1, 1] = 1 trace1 = ia.get_trace(mov, mask1, maskMode='binary') assert (trace1[2] == 39.5) mask2 = np.zeros((4, 4), dtype=np.float) mask2[:] = np.nan mask2[2, 2] = 1 mask2[1, 1] = 1 trace2 = ia.get_trace(mov, mask2, maskMode='binaryNan') assert (trace2[2] == 39.5) mask3 = np.zeros((4, 4), dtype=np.float) mask3[2, 2] = 1 mask3[1, 1] = 2 trace3 = ia.get_trace(mov, mask3, maskMode='weighted') assert (trace3[2] == 58) mask4 = np.zeros((4, 4), dtype=np.float) mask4[:] = np.nan mask4[2, 2] = 1 mask4[1, 1] = 2 trace4 = ia.get_trace(mov, mask4, maskMode='weightedNan') assert (trace4[2] == 58)
def test_ROI_binary_overlap(self): roi1 = np.zeros((10, 10)) roi1[4:8, 3:7] = 1 roi1 = ia.ROI(roi1) roi2 = np.zeros((10, 10)) roi2[5:9, 5:8] = 1 roi2 = ia.ROI(roi2) assert(roi1.binary_overlap(roi2) == 6)
def test_plot_ROIs(self): aa = np.zeros((50, 50)); aa[15:20, 30:35] = np.random.rand(5, 5) roi1 = ia.ROI(aa) _ = roi1.plot_binary_mask_border(); _ = roi1.plot_binary_mask() roi2 = ia.WeightedROI(aa) _ = roi2.plot_binary_mask_border(); _ = roi2.plot_binary_mask(); _ = roi2.plot_weighted_mask()
def test_mergeROIs(self): import corticalmapping.core.ImageAnalysis as ia roi1 = ia.WeightedROI(np.arange(9).reshape((3, 3))) roi2 = ia.WeightedROI(np.arange(1, 10).reshape((3, 3))) merged_ROI = ia.merge_weighted_rois(roi1, roi2) merged_ROI2 = ia.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 test_get_circularity(self): aa = np.zeros((10, 10)) aa[3:5, 3:5] = 1 cir1 = ia.get_circularity(aa, is_skimage=False) # print(cir1) assert(0.7853981633974483 - 1e-15 < cir1 < 0.7853981633974483 + 1e-15) print(ia.get_circularity(aa, is_skimage=True)) aa[3:5, 5] = 1 cir2 = ia.get_circularity(aa, is_skimage=False) # print(cir2) assert (0.7539822368615503 - 1e-15 < cir2 < 0.7539822368615503 + 1e-15)
def test_ROI(self): a = np.zeros((10, 10)) a[5:7, 3:6] = 1 a[8:9, 7:10] = np.nan roi = ia.ROI(a) # plt.imshow(roi.get_binary_mask(),interpolation='nearest') assert (list(roi.get_center()) == [5.5, 4.])
def test_fit_ellipse(self): mask = np.zeros((100, 100), dtype=np.uint8) mask[20:50, 30:80] = 255 mask[40:50, 70:80] = 0 mask[20:30, 30:40] = 0 # import matplotlib.pyplot as plt # f = plt.figure(figsize=(4, 4)) # ax = f.add_subplot(111) # ax.set_aspect('equal') # ax.imshow(mask, interpolation='nearest') # plt.show() ell = ia.fit_ellipse(mask) print(ell.info()) assert((np.round(ell.angle * 100) / 100) % 180. == 44.16) import cv2 img = np.array([mask, mask, mask]).transpose((1, 2, 0)).copy() img = ell.draw(img=img, thickness=1) img = cv2.cvtColor(img, code=cv2.COLOR_BGR2RGB) import matplotlib.pyplot as plt plt.imshow(img, interpolation='nearest') plt.show()
def test_ROI_getBinaryTrace(self): mov = np.random.rand(5, 4, 4) mask = np.zeros((4, 4)) mask[2, 3] = 1 trace1 = mov[:, 2, 3] roi = ia.ROI(mask) trace2 = roi.get_binary_trace(mov) assert (np.array_equal(trace1, trace2))
def test_WeigthedROI_getWeightedCenter(self): aa = np.random.rand(5, 5); mask = np.zeros((5, 5)) mask[2, 3] = aa[2, 3]; mask[1, 4] = aa[1, 4]; mask[3, 4] = aa[3, 4] roi = ia.WeightedROI(mask) center = roi.get_weighted_center() assert (center[0] == (2 * aa[2, 3] + 1 * aa[1, 4] + 3 * aa[3, 4]) / (aa[2, 3] + aa[1, 4] + aa[3, 4]))
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
def on_draw(self): """ Redraws the figure """ self.axes.clear() if type(self.ReferenceVasMap) != type(None): width = self.ReferenceVasMap.shape[1] height = self.ReferenceVasMap.shape[0] elif type(self.MatchingVasMapAfterChange) != type(None): width = self.MatchingVasMapAfterChange.shape[1] height = self.MatchingVasMapAfterChange.shape[0] elif type(self.MatchingVasMap) != type(None): width = self.MatchingVasMap.shape[1] height = self.MatchingVasMap.shape[0] else: width = 1344 height = 1024 if (type(self.ReferenceVasMap) != type(None)) and (self.radiobutton_reference.isChecked() or self.radiobutton_both.isChecked()): greenChannel = ia.resize_image(self.ReferenceVasMap, (height, width)) greenChannel = ( np.power(ia.array_nor(greenChannel), self.reference_contrast) * 255).astype(np.uint8) else: greenChannel = np.zeros((height, width)).astype(np.uint8) if (self.radiobutton_matching.isChecked() or self.radiobutton_both.isChecked()): if type(self.MatchingVasMapAfterChange) != type(None): redChannel = ia.resize_image(self.MatchingVasMapAfterChange, (height, width)) redChannel = (np.power(ia.array_nor(redChannel), self.matching_contrast) * 255).astype( np.uint8) elif type(self.MatchingVasMap) != type(None): redChannel = ia.resize_image(self.MatchingVasMap, (height, width)) redChannel = (np.power(ia.array_nor(redChannel), self.matching_contrast) * 255).astype( np.uint8) else: redChannel = np.zeros((height, width)).astype(np.uint8) else: redChannel = np.zeros((height, width)).astype(np.uint8) blueChannel = np.zeros((height, width)).astype(np.uint8) pltImg = cv2.merge((redChannel, greenChannel, blueChannel)) self.axes.imshow(pltImg) self.axes.set_xlim([0, width]) self.axes.set_ylim([0, height]) self.axes.invert_yaxis() self.canvas.draw()
data_f = h5py.File('caiman_segmentation_results.hdf5') masks = data_f['masks'].value data_f.close() bg = tf.imread(bg_fn) final_roi_dict = {} for i, mask in enumerate(masks): 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 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(ia.array_nor(bg), vmin=0, vmax=0.1, 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.1, cmap='gray', interpolation='nearest')
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()
for i, mask in enumerate(masks): if is_filter: 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(ia.array_nor(bg), vmin=0, vmax=0.5, cmap='gray', interpolation='nearest') colors1 = pt.random_color(masks.shape[0]) for i, mask in enumerate(masks):
isRectify=False # should the fft method be applied to a rectify signal or not #wrap experiment parameters isAnesthetized=False visualStimType='KSstim' visualStimBackground='gray' analysisParams ={} if vasMapPaths: vasMap = hl.getVasMap(vasMapPaths,dtype=vasMapDtype,headerLength=vasMapHeaderLength,tailerLength=vasMapTailerLength, column=vasMapColumn,row=vasMapRow,frame=vasMapFrame,crop=vasMapCrop,mergeMethod=vasMapMergeMethod) else: print 'No vasculature map find. Taking first frame of movie as vasculature map.' vasMap = BinarySlicer(movPath)[0,:,:] vasMap = ia.array_nor(vasMap).astype(np.float32) tf.imsave(os.path.join(saveFolder,dateRecorded+'_M'+mouseID+'_Trial'+trialNum+'_vasMap.tif'),vasMap) _, jphys = ft.importRawNewJPhys(jphysPath,dtype=jphysDtype,headerLength=jphysHeaderLength,channels=jphysChannels,sf=jphysFs) pd = jphys['photodiode'] displayOnsets = hl.segmentPhotodiodeSignal(pd, digitizeThr=pdDigitizeThr, filterSize=pdFilterSize, segmentThr=pdSegmentThr, Fs=jphysFs) imgFrameTS = ta.get_onset_timeStamps(jphys['read'], Fs=jphysFs, threshold=readThreshold, onsetType=readOnsetType) logPath = hl.findLogPath(date=dateRecorded,mouseID=mouseID,stimulus='KSstimAllDir',userID=userID,fileNumber=str(fileNum),displayFolder=dataFolder) displayInfo = hl.analysisMappingDisplayLog(logPath)
import os import numpy as np import tifffile as tf import corticalmapping.core.ImageAnalysis as ia data_folder = r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" \ r"\180404-M360495-2p\2p_movie\reorged" xy_downsample_rate = 2 t_downsample_rate = 10 curr_folder = os.path.dirname(os.path.realpath(__file__)) os.chdir(curr_folder) corr_folder = os.path.join(data_folder, 'corrected') f_ns = [f for f in os.listdir(corr_folder) if f[-14:] == '_corrected.tif'] f_ns.sort() print('\n'.join(f_ns)) mov_d = [] for f_n in f_ns: print('processing {} ...'.format(f_n)) curr_mov = tf.imread(os.path.join(corr_folder, f_n)) curr_mov_d = ia.rigid_transform_cv2(img=curr_mov, zoom=(1. / xy_downsample_rate)) curr_mov_d = ia.z_downsample(curr_mov_d, downSampleRate=t_downsample_rate) mov_d.append(curr_mov_d) mov_d = np.concatenate(mov_d, axis=0).astype(np.int16) tf.imsave('2p_movie_downsampled.tif', mov_d)
channels = ['DAPI', 'GCaMP', 'mRuby', 'NeuN'] downsample_rate = 0.1 curr_folder = os.path.realpath(os.path.dirname(__file__)) os.chdir(curr_folder) fns = [f for f in os.listdir(curr_folder) if f[-4:] == '.btf'] fns.sort() print('\n'.join(fns)) for fn in fns: print('\nprocessing {} ...'.format(fn)) big_img = tf.imread(fn) fname = os.path.splitext(fn)[0] print('shape: {}'.format(big_img.shape)) print('dtype: {}'.format(big_img.dtype)) # comb_img = [] for chi, chn in enumerate(channels): print('\tchannel: {}'.format(chn)) down_img_ch = ia.rigid_transform_cv2(big_img[chi], zoom=downsample_rate).astype( np.uint16)[::-1, :] tf.imsave('thumbnail_{}_{:02d}_{}.tif'.format(fname, chi, chn), down_img_ch) # comb_img.append(down_img_ch) # comb_img = np.array(comb_img) # tf.imsave('{}_downsampled.tif'.format(fname), comb_img)
if len(curr_vasmap.shape) == 2: if len(channels) == 1: vasmaps[channels[0]].append(np.array([curr_vasmap])) else: raise ValueError( 'recorded file is 2d, cannot be deinterleved into {} channels.' .format(len(channels))) else: if len(curr_vasmap.shape) != 3: raise ValueError( 'shape of recorded file: {}. should be either 2d or 3d.'. format(curr_vasmap.shape)) for ch_i, ch_n in enumerate(channels): curr_vasmap_ch = curr_vasmap[ch_i::len(channels)] curr_vasmap_ch = ia.array_nor(np.mean(curr_vasmap_ch, axis=0)) if is_equalize: curr_vasmap_ch = (curr_vasmap_ch * 255).astype(np.uint8) curr_vasmap_ch = cv2.equalizeHist(curr_vasmap_ch).astype( np.float32) vasmaps[ch_n].append(curr_vasmap_ch) for ch_n, ch_vasmap in vasmaps.items(): # save_vasmap = np.concatenate(ch_vasmap, axis=0) # print(save_vasmap.shape) # save_vasmap = ia.array_nor(np.mean(save_vasmap, axis=0)) # print(save_vasmap.shape) save_vasmap = ia.array_nor(np.mean(ch_vasmap, axis=0)) if scope == 'scientifica':
td_rate) for save_file_id in range(num_file_to_save): save_chunk = total_movs[ch_i][save_file_id * (frames_per_file * td_rate):(save_file_id + 1) * (frames_per_file * td_rate)] save_path = os.path.join( save_folders[ch_i], '{}_{:05d}_reorged.tif'.format(file_identifier, save_ids[ch_i])) if td_rate != 1: print('\tdown sampling for {} ...'.format( os.path.split(save_path)[1])) save_chunk = ia.z_downsample(save_chunk, downSampleRate=td_rate, is_verbose=False) print('\tsaving {} ...'.format(os.path.split(save_path)[1])) tf.imsave(save_path, save_chunk) save_ids[ch_i] = save_ids[ch_i] + 1 if total_movs[ch_i].shape[0] % (frames_per_file * td_rate) == 0: total_movs[ch_i] = None else: frame_num_left = total_movs[ch_i].shape[0] % (frames_per_file * td_rate) total_movs[ch_i] = total_movs[ch_i][-frame_num_left:] print('\nprocessing residual frames ...')
curr_save_folder = os.path.join(data_folder, file_identifier, ch_n) if not os.path.isdir(curr_save_folder): os.makedirs(curr_save_folder) save_folders.append(curr_save_folder) curr_step = 0 for file_n in file_ns: curr_mov = tf.imread(os.path.join(data_folder, file_n)) # reorient movie if is_rotate: h_new = int(curr_mov.shape[1] * np.sqrt(2)) w_new = int(curr_mov.shape[2] * np.sqrt(2)) curr_mov = ia.rigid_transform_cv2(curr_mov, rotation=140, outputShape=(h_new, w_new))[:, :, ::-1] curr_frame_num = curr_mov.shape[0] / len(ch_ns) if curr_frame_num % frames_per_step != 0: raise ValueError( '{}: total frame number is not divisible by frames per step.'. format(file_n)) curr_mov_chs = [] for ch_i in range(len(ch_ns)): curr_mov_chs.append(curr_mov[ch_i::len(ch_ns)]) steps = curr_frame_num // frames_per_step for step_ind in range(steps):
data_folder = r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data\190822-M471944-deepscope\movie" identifier = '110_LSNDGCUC' start_ind = 121228 frame_num = 3 fns = [] for ind in np.arange(frame_num, dtype=np.int) + start_ind: if ind < 100000: fns.append('{}_{:05d}_00001.tif'.format(identifier, ind)) elif ind < 1000000: fns.append('{}_{:06d}_00001.tif'.format(identifier, ind)) elif ind < 10000000: fns.append('{}_{:07d}_00001.tif'.format(identifier, ind)) f = plt.figure(figsize=(5, 12)) for frame_i in range(frame_num): ax = f.add_subplot(frame_num, 1, frame_i + 1) ax.imshow(ia.array_nor(tf.imread(os.path.join(data_folder, fns[frame_i]))), cmap='gray', vmin=0, vmax=0.5, interpolation='nearest') ax.set_title(fns[frame_i]) ax.set_axis_off() plt.tight_layout() plt.show()
def align_mapping_img(mapping_img, alignment_json, zoom=0.5): return ia.rigidTransform(align_image(mapping_img, alignment_json, 1), zoom=zoom)
vas_map_paths = [ r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" r"\180404-M360495-2p\vasmap_wf\180404JCamF100", r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" r"\180404-M360495-2p\vasmap_wf\180404JCamF101", r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" r"\180404-M360495-2p\vasmap_wf\180404JCamF102", ] saveFolder = os.path.dirname(os.path.realpath(__file__)) os.chdir(saveFolder) vas_maps = [] for vas_map_path in vas_map_paths: vas_map_focused, _, _ = ft.importRawJCamF(vas_map_path, column=1024, row=1024, headerLength=116, tailerLength=452) vas_map_focused = vas_map_focused[2:] vas_map_focused = vas_map_focused[:, ::-1, :] vas_map_focused[vas_map_focused > 50000] = 400 vas_map_focused = np.mean(vas_map_focused, axis=0) vas_maps.append(ia.array_nor(vas_map_focused)) vas_map = ia.array_nor(np.mean(vas_maps, axis=0)) tf.imsave('vas_map_focused_wf.tif', vas_map.astype(np.float32))
data_folder = r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project\180404-M360495-2p\vasmap_2p" zoom1_paths = [ os.path.join(data_folder, f) for f in os.listdir(data_folder) if f[-12:] == '_rotated.tif' and '_zoom1_' in f ] # zoom2_paths = [os.path.join(data_folder, f) for f in os.listdir(data_folder) # if f[-12:] == '_rotated.tif' and '_zoom2_' in f] curr_folder = os.path.dirname(os.path.realpath(__file__)) os.chdir(curr_folder) vas_map_zoom1 = [] # vas_map_zoom2 = [] for zoom1_path in zoom1_paths: curr_vasmap = np.mean(tf.imread(zoom1_path), axis=0) vas_map_zoom1.append(curr_vasmap) # for zoom2_path in zoom2_paths: # curr_vasmap = np.mean(tf.imread(zoom2_path), axis=0) # vas_map_zoom2.append(curr_vasmap) vas_map_zoom1 = ia.array_nor(np.mean(vas_map_zoom1, axis=0)) # vas_map_zoom2 = ia.array_nor(np.mean(vas_map_zoom2, axis=0)) tf.imsave('vas_map_focused_2p_zoom1.tif', vas_map_zoom1.astype(np.float32)) # tf.imsave('vas_map_focused_2p_zoom2.tif', vas_map_zoom2.astype(np.float32))
print('\n'.join(file_ns)) save_folders = [] for ch_n in ch_ns: curr_save_folder = os.path.join(data_folder, file_identifier, ch_n) if not os.path.isdir(curr_save_folder): os.makedirs(curr_save_folder) save_folders.append(curr_save_folder) curr_step = 0 for file_n in file_ns: curr_mov = tf.imread(os.path.join(data_folder, file_n)) # reorient movie curr_mov = ia.rigid_transform_cv2_2d(curr_mov[:, ::-1, :], rotation=135) curr_frame_num = curr_mov.shape[0] / len(ch_ns) if curr_frame_num % frames_per_step != 0: raise ValueError( '{}: total frame number is not divisible by frames per step.'. format(file_n)) curr_mov_chs = [] for ch_i in range(len(ch_ns)): curr_mov_chs.append(curr_mov[ch_i::len(ch_ns)]) steps = curr_frame_num // frames_per_step for step_ind in range(steps):
import numpy as np import os mov_name = "160525_M235516_aveMov_102.tif" curr_folder = os.path.dirname(os.path.realpath(__file__)) os.chdir(curr_folder) mov_file_name, mov_file_ext = os.path.splitext(mov_name) save_name = mov_file_name + '_detrend' + mov_file_ext mov = tf.imread(mov_name).astype(np.float32) height = mov.shape[1] width = mov.shape[2] roi = ia.generate_oval_mask((height, width), (height / 2, width / 2), int(height * 0.6), int(width * 0.6)) f = plt.figure(figsize=(10, 10)) ax = f.add_subplot(111) ax.imshow(mov[0, :, :], cmap='gray', interpolation='nearest') pt.plot_mask_borders(roi, plotAxis=ax) plt.show() mov_detrend, trend, amp, rvalue = hl.regression_detrend(mov, roi) f = plt.figure(figsize=(15, 4)) ax = f.add_subplot(111) ax.plot(trend) ax.set_title('trend')
f_ns = [f for f in os.listdir(plane_folder) if f[-14:] == '_corrected.tif'] f_ns.sort() print('\n'.join(f_ns)) mov_join = [] for f_n in f_ns: curr_mov = tf.imread(os.path.join(plane_folder, f_n)) if curr_mov.shape[0] % t_downsample_rate != 0: print( 'the frame number of {} ({}) is not divisible by t_downsample_rate ({}).' .format(f_n, curr_mov.shape[0], t_downsample_rate)) curr_mov_d = ia.z_downsample(curr_mov, downSampleRate=t_downsample_rate) mov_join.append(curr_mov_d) mov_join = np.concatenate(mov_join, axis=0) add_to_mov = 10 - np.amin(mov_join) save_name = '{}_d1_{}_d2_{}_d3_1_order_C_frames_{}_.mmap'\ .format(base_name, mov_join.shape[2], mov_join.shape[1], mov_join.shape[0]) mov_join = mov_join.reshape( (mov_join.shape[0], mov_join.shape[1] * mov_join.shape[2]), order='F').transpose() mov_join_mmap = np.memmap(os.path.join(plane_folder, save_name), shape=mov_join.shape, order='C', dtype=np.float32,
file_id_save = 0 total_mov = None base_name = '_'.join(file_list[0].split('_')[:-1]) save_folder = os.path.join(data_folder, 'reorged') if not os.path.isdir(save_folder): os.makedirs(save_folder) for file_path in file_paths: print('\nprocessing {} ...'.format(os.path.split(file_path)[1])) curr_mov = tf.imread(file_path) curr_mov = curr_mov.transpose((0, 2, 1))[:, ::-1, :] if temporal_downsample_rate != 1: curr_mov = ia.z_downsample(curr_mov, downSampleRate=temporal_downsample_rate) if total_mov is None: total_mov = curr_mov else: total_mov = np.concatenate((total_mov, curr_mov), axis=0) while (total_mov is not None) and (total_mov.shape[0] >= frames_per_file): num_file_to_save = total_mov.shape[0] // frames_per_file for save_file_id in range(num_file_to_save): save_chunk = total_mov[save_file_id * frames_per_file:(save_file_id + 1) * frames_per_file] save_path = os.path.join(
vasmap_wf_path = r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" \ r"\180502-M376019-deepscope\Widefield.tif" vasmap_2p_zoom1_path = r"\\allen\programs\braintv\workgroups\nc-ophys\Jun\raw_data_rabies_project" \ r"\180502-M376019-deepscope\01\01_00001.tif" curr_folder = os.path.dirname(os.path.realpath(__file__)) os.chdir(curr_folder) vasmap_wf = io.imread(vasmap_wf_path, as_grey=True) vasmap_wf = vasmap_wf.transpose()[::-1, ::-1] vasmap_2p_zoom1 = tf.imread(vasmap_2p_zoom1_path).astype(np.float32) vasmap_2p_zoom1 = np.mean(vasmap_2p_zoom1, axis=0) vasmap_2p_zoom1 = vasmap_2p_zoom1.transpose()[::-1, ::-1] f = plt.figure(figsize=(12, 5)) ax_wf = f.add_subplot(121) ax_wf.imshow(ia.array_nor(vasmap_wf), vmin=0., vmax=1., cmap='gray', interpolation='nearest') ax_wf.set_title('vasmap wide field') ax_wf.set_axis_off() ax_2p = f.add_subplot(122) ax_2p.imshow(ia.array_nor(vasmap_2p_zoom1), vmin=0., vmax=0.15, cmap='gray', interpolation='nearest') ax_2p.set_title('vasmap 2p zoom1') ax_2p.set_axis_off() plt.show() tf.imsave('vasmap_wf.tif', vasmap_wf) tf.imsave('vasmap_2p_zoom1.tif', vasmap_2p_zoom1)
ax_and_scatter = f.add_subplot(4, 5, 16) ax_and_scatter.plot(df_and['rf_{}_on_center_azi'.format(response_dir)], df_and['rf_{}_on_center_alt'.format(response_dir)], '.', color='#ff0000') ax_and_scatter.plot( df_and['rf_{}_off_center_azi'.format(response_dir)], df_and['rf_{}_off_center_alt'.format(response_dir)], '.', color='#0000ff') ax_and_scatter.set_xlim([azi_min, azi_max]) ax_and_scatter.set_ylim([alt_min, alt_max]) # =============================pairwise distance============================================= dis_or = ia.pairwise_distance(df_or[[ 'rf_{}_onoff_center_azi'.format(response_dir), 'rf_{}_onoff_center_alt'.format(response_dir) ]].values) ax_or_pd = f.add_subplot(4, 5, 2) if len(dis_or) > 0: ax_or_pd.hist(dis_or, range=[0, 80], bins=20, facecolor='#aaaaaa', edgecolor='none') ax_or_pd.get_yaxis().set_ticks([]) ax_or_pd.set_title( 'pw RF dis') # pairwise receptive field center distance dis_on = ia.pairwise_distance(df_on[[ 'rf_{}_on_center_azi'.format(response_dir), 'rf_{}_on_center_alt'.format(response_dir)