def get_movie_header(rgb_files_with_path, correct_bad_pixels, correct_stray_light): # todo: rewrite to change it as a class """ get the movie "header" info :param rgb_files_with_path: :return: size(n_row, n_col, n_frame), and frame_rate """ # open one channel first to get the basics of the movie ext = os.path.splitext(rgb_files_with_path[0])[1] if ext == '.isxd': tmp = isx.Movie(rgb_files_with_path[0]) # frame_shape = tmp.shape num_frames = tmp.num_frames frame_rate = tmp.frame_rate frame_period = tmp.get_frame_period() data_type = tmp.data_type tmp.close() elif ext == '.tif': tmp = Image.open(rgb_files_with_path[0]) # frame_shape = tmp.size[::-1] num_frames = tmp.n_frames frame_rate = 20 # tmp.frame_rate #todo: does the tif file always have frame rate info? what's the tag name?? frame_period = 50000 tmp.close() # get an example frame to get accurate frame_shape (especially necessary when correct_bad_pixels == True tmp = get_rgb_frame(rgb_files_with_path, 0, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) frame_shape = tmp.shape[1:3] return frame_shape, num_frames, frame_period, data_type, frame_rate
def correct_bad_pixels(self): """ correct the first frame to get updated n_row, n_col :param correct_bad_pixels: :return: """ filename_with_path = self.filename_with_path channel = self.channel ext = self.extension if ext == '.isxd': mov = isx.Movie(filename_with_path) im = mov.read_frame(0) elif ext == '.tif': mov = Image.open(filename_with_path) mov.seek(0) im = np.array(mov) mov.close() x = DiscardBadPixels() # method0 = getattr(x, 'correct') # im = method0(im, channel) im = x.discard4channel(im, channel) self.n_row = im.shape[0] self.n_col = im.shape[1] self.shape = (self.n_row, self.n_col) self.correct_bad_pixels = True
def __init__(self, filename_with_path): # correct_bad_pixels, correct_stray_light): self.filename_with_path = filename_with_path # open movie to get the basics tmp = os.path.splitext(filename_with_path) filename = os.path.basename(tmp[0]) ext = tmp[1] if ext == '.isxd': mov = isx.Movie(filename_with_path) frame_shape = mov.shape n_row = frame_shape[0] n_col = frame_shape[1] n_frame = mov.num_frames frame_rate = mov.frame_rate frame_period = mov.get_frame_period() data_type = mov.data_type elif ext == '.tif': mov = Image.open(filename_with_path) frame_shape = mov.size[::-1] n_row = frame_shape[0] n_col = frame_shape[1] n_frame = 2000 # mov.n_frames #it's too slow to get the n_frames tag from a tif file frame_rate = 20 # mov.frame_rate #todo: does the tif file always have frame rate info? what's the tag name?? frame_period = int(10 ** 6 / frame_rate) data_type = np.uint16 mov.close() self.n_row = n_row self.n_col = n_col self.shape = frame_shape self.n_frame = n_frame self.frame_rate = frame_rate self.frame_period = frame_period self.data_type = data_type self.extension = ext channel = [] for thischannel in ['red', 'green', 'blue']: if thischannel in filename: channel.append(thischannel) self.channel = channel self.pixel_corrected = False
def generate_meanProj_subBg_files(root_dir, save_path, channel, dff=None): """ get mean intensity projection image for all red and green images """ if dff is None: dff = False fn = [ f for f in listdir(root_dir) if (isfile(join(root_dir, f)) and '_{}.isxd'.format(channel) in f) ] print('{} files have been found, they are \n {}'.format(len(fn), fn)) isx.initialize() for i, thisfile in enumerate(fn): mov = isx.Movie(join(root_dir, thisfile)) n_frame = mov.num_frames n_frame = min(n_frame, 1000) shape = mov.shape n_row = shape[0] n_col = shape[1] tmp = np.empty([n_row, n_col, n_frame]) for j in range(n_frame): tmp[:, :, j] = mov.read_frame(j) mov_mean = np.mean(tmp, axis=2) if dff: mov_dff = np.divide(np.subtract(tmp, mov_mean[:, :, np.newaxis]), mov_mean[:, :, np.newaxis]) mov_dff_max = np.max(mov_dff, axis=2) im = Image.fromarray(mov_dff_max) thisfile_basename = '{}_dff'.format(splitext(thisfile)[0]) else: mov_mean_median = np.median(mov_mean.flatten()) mov_mean = mov_mean - mov_mean_median im = Image.fromarray(mov_mean) thisfile_basename = splitext(thisfile)[0] im.save(join(save_path, thisfile_basename + '.tif')) print('the {}th file {} is completed'.format(i, thisfile)) mov.close() im.close() isx.shutdown()
def get_rgb_pixel_time(rgb_files_with_path, select_frame_idx=None, select_pixel_idx=None, correct_stray_light=None, correct_bad_pixels=None): import os from PIL import Image # Get intensity for specific pixels at specific frames ext = os.path.splitext(rgb_files_with_path[0])[1] if ext == '.isxd': tmp = isx.Movie(rgb_files_with_path[0]) frame_shape = tmp.shape n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.num_frames tmp.close() elif ext == '.tif': tmp = Image.open(rgb_files_with_path[0]) frame_shape = tmp.size[::-1] n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.n_frames else: frame_shape = [] n_frames = [] n_pixels = [] if select_frame_idx is None: select_frame_idx = np.arange(0, n_frames - 1) if select_pixel_idx is None: select_pixel_idx = np.arange(0, n_pixels - 1) if correct_stray_light is None: correct_stray_light = False if correct_bad_pixels is None: correct_bad_pixels = False rgb_pixel_time = np.empty([3, len(select_pixel_idx), len(select_frame_idx)]) print('Collect frame', end='') this_rgb_frame = np.empty([frame_shape[0], frame_shape[1]]) for i, frame_idx in enumerate(select_frame_idx): print('...', end='') this_rgb_frame = get_rgb_frame(rgb_files_with_path, frame_idx, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) rgb_pixel_time[:, :, i] = this_rgb_frame.reshape([-1, n_pixels])[:, select_pixel_idx] print('frame {}'.format(frame_idx)) return rgb_pixel_time
def get_header(self): """ open movie for each file, and get movie header :return: """ ext = self.ext rgb_filenames_with_path = self.rgb_filenames_with_path n_mov = len(rgb_filenames_with_path) mov_list = [0]*n_mov for i, thisfile in enumerate(rgb_filenames_with_path): if ext == '.isxd': mov = isx.Movie(thisfile) frame_shape = mov.shape n_row = frame_shape[0] n_col = frame_shape[1] n_frame = mov.num_frames frame_rate = mov.frame_rate frame_period = mov.get_frame_period() data_type = mov.data_type elif ext == '.tif': mov = Image.open(thisfile) frame_shape = mov.size[::-1] n_row = frame_shape[0] n_col = frame_shape[1] n_frame = 2000 # mov.n_frames #it's too slow to get the n_frames tag from a tif file frame_rate = 20 # mov.frame_rate #todo: does the tif file always have frame rate info? what's the tag name?? frame_period = int(10 ** 6 / frame_rate) data_type = np.uint16 mov_list[i] = mov self.mov = mov_list self.n_row = n_row self.n_col = n_col self.shape = frame_shape self.n_frame = n_frame self.frame_rate = frame_rate self.frame_period = frame_period self.data_type = data_type self.pixel_corrected = False self.correct_stray_light = False
def write_cssp_movie(rgb_basename_with_path, extension=None, correct_stray_light=None, correct_bad_pixels=None, save_pathname=None, save_basename=None): """ Write GCaMP and RGeco movie after color signal splitting. :param rgb_files_with_path: :param save_path: :param save_filename: :return: """ import pymsgbox if extension is None: extension = '.isxd' # todo: rewrite get_exp_label function, make it as a class with method like exp.led, exp.probe # exp = get_exp_label(rgb_files_basename) # exp.led.blue = 1 # exp.led.lime = 0.5 # exp.probe = ['GCaMP', 'RGeco'] # aM = calc_aMatrix_for_rgb_signal_split(exp.probe, exp.led, cssp=None) exp_led = [1.8, 0.9] exp_channel = ['red', 'green', 'blue'] exp_probe = ['GCaMP', 'RGeco', 'Autofluo'] aM = calc_aMatrix_for_rgb_signal_split(exp_led, cssp=None) aM_inv = np.linalg.inv(aM) if save_pathname is None: save_pathname = os.path.dirname(rgb_basename_with_path) if not os.path.exists(save_pathname): os.mkdir(save_pathname) rgb_basename = os.path.basename(rgb_basename_with_path) if save_basename is None: save_basename = rgb_basename save_filenames_with_path = [os.path.join(save_pathname, '{}_{}.isxd'.format(save_basename, probe)) for probe in exp_probe] if correct_stray_light is None: correct_stray_light = False if correct_bad_pixels is None: correct_bad_pixels = False rgb_filenames_with_path = find_rgb_files(rgb_basename_with_path, extension=extension, channel_list=exp_channel) header = MovieHeader(rgb_filenames_with_path[0]) if correct_bad_pixels: header.correct_bad_pixels() n_ch = len(exp_channel) n_frame = header.n_frame n_probe = len(exp_probe) output_mov_list = [0] * n_probe for i in range(n_probe): if os.path.exists(save_filenames_with_path[i]): os.remove(save_filenames_with_path[i]) pymsgbox.alert('File exists! do you want to rewrite {}'.format(save_filenames_with_path[i])) output_mov_list[i] = isx.Movie(save_filenames_with_path[i], frame_period=header.frame_period, shape=header.shape, num_frames=header.n_frame, data_type=header.data_type) print('Writing frame...') for frame_idx in range(n_frame): rgb_frame = get_rgb_frame(rgb_filenames_with_path, frame_idx, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) xyz = rgb_signal_split(rgb_frame, aM_inv) # xyz_min = xyz.reshape((n_probe, header.n_row * header.n_col)).min(axis=1) # xyz = np.subtract(xyz, xyz_min[:, np.newaxis, np.newaxis]) # xyz[xyz < 0] = 0 xyz += 30000 for i in range(n_probe): output_mov_list[i].write_frame(xyz[i, :, :], frame_idx) if (frame_idx + 1) / 10 != 0 and (frame_idx + 1) % 10 == 0: print('...') print('\n'.join(map(str, range(frame_idx - 9, frame_idx + 1)))) print('... all frames done!') for i in range(n_probe): output_mov_list[i].close()
def write_corrected_rgb_isxd_movie(rgb_basename_with_path, extension=None, correct_bad_pixels=None, correct_stray_light=None, save_pathname=None, save_basename=None): """ rewrite the movie to an .isxd file after different options, such as discard bad pixels, correct microscope stray light, etc. :param input_filename_with_path: input .isxd or .tif movie :param correct_bad_pixel: :param correct_stray_light: :param save_pathname: :param save_filename: :return: """ import pymsgbox if extension is None: extension = '.isxd' if save_pathname is None: save_pathname = os.path.dirname(rgb_basename_with_path) save_pathname = os.path.join(save_pathname, 'corrected') if not os.path.exists(save_pathname): os.mkdir(save_pathname) rgb_basename = os.path.basename(rgb_basename_with_path) if save_basename is None: save_basename = rgb_basename if correct_bad_pixels is None: correct_bad_pixels = False if correct_stray_light is None: correct_stray_light = False channel = ['red', 'green', 'blue'] # exp['channels'] # todo: rewrite get_exp_label() to add channel info. I am having a stronger feeling to write a class for # todo: movie such that each movie is a class with all movie data and header info rgb_filenames_with_path = find_rgb_files(rgb_basename_with_path, extension=extension, channel_list=channel) save_filenames_with_path = [os.path.join(save_pathname, '{}_{}.isxd' .format(save_basename, thischannel)) for thischannel in channel] header = MovieHeader(rgb_filenames_with_path[0]) if correct_bad_pixels: header.correct_bad_pixels() n_ch = len(channel) n_frame = header.n_frame output_mov_list = [0] * n_ch for i in range(n_ch): if os.path.exists(save_filenames_with_path[i]): pymsgbox.alert('File exists! do you want to rewrite {}'.format(save_filenames_with_path[i])) os.remove(save_filenames_with_path[i]) output_mov_list[i] = isx.Movie(save_filenames_with_path[i], frame_period=header.frame_period, shape=header.shape, num_frames=header.n_frame, data_type=header.data_type) print('Writing frame...') for frame_idx in range(n_frame): rgb_frame = get_rgb_frame(rgb_filenames_with_path, frame_idx, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) for i in range(n_ch): output_mov_list[i].write_frame(rgb_frame[i, :, :], frame_idx) if (frame_idx + 1) / 10 != 0 and (frame_idx + 1) % 10 == 0: print('...') print('\n'.join(map(str, range(frame_idx - 9, frame_idx + 1)))) print('... all frames done!') for i in range(n_ch): output_mov_list[i].close() return save_filenames_with_path
def get_rgb_frame(rgb_files, frame_idx, camera_bias=None, correct_stray_light=None, correct_bad_pixels=None): import os from PIL import Image # get movie info for each channel if camera_bias is None: camera_bias = 172 if correct_stray_light is None: correct_stray_light = False if correct_bad_pixels is None: correct_bad_pixels = False ext = os.path.splitext(rgb_files[0])[1] if ext == '.isxd': # for .isxd files # # For debug purpose: check if all channels are correct # for this_file in rgb_files: # this_movie = isx.Movie(this_file) # print('Frame rate:{:0.2f} Hz'.format(this_movie.frame_rate)) # print('#of frames:{}'.format(this_movie.num_frames)) # print('Movie size: {} rows by {} columns'.format(this_movie.shape[0], this_movie.shape[1])) # this_movie.close() # # may need to handle cases when the files detected are not red/green/blue channels, ect. this_movie = isx.Movie(rgb_files[0]) n_row = this_movie.shape[0] n_col = this_movie.shape[1] this_movie.close() n_ch = len(rgb_files) rgb_frame = np.empty([n_ch, n_row, n_col]) for i, this_file in enumerate(rgb_files): this_movie = isx.Movie(this_file) frame_idx = int(frame_idx) this_frame = this_movie.read_frame(frame_idx) rgb_frame[i, :, :] = this_frame - camera_bias this_movie.close() elif ext == '.tif': # # For debug purpose: check if all channels are correct # for this_file in rgb_files: # this_movie = Image.open(this_file) # print('Frame rate:{:0.2f} Hz'.format(this_movie.frame_rate)) # print('#of frames:{}'.format(this_movie.n_frames)) # print('Movie size: {} rows by {} columns'.format(this_movie.size[1], this_movie.size[0])) this_movie = Image.open(rgb_files[0]) n_row = this_movie.size[1] n_col = this_movie.size[0] this_movie.close() n_ch = len(rgb_files) rgb_frame = np.zeros((n_ch, n_row, n_col)) for i, this_file in enumerate(rgb_files): this_movie = Image.open(this_file) this_movie.seek(frame_idx) rgb_frame[i, :, :] = np.array(this_movie) this_movie.close() rgb_files_root = find_rgb_channels(rgb_files)[1] rgb_files_root = os.path.split(rgb_files_root)[1] exp = get_exp_label(rgb_files_root) exp_label = exp['label'] if correct_stray_light: rgb_frame = subtract_stray_light(rgb_frame, exp_label) if correct_bad_pixels: x = DiscardBadPixels() x.discard4channel(rgb_frame) rgb_frame = discard_bad_pixels(rgb_frame) return rgb_frame
def main(): isx.initialize() # input files root_dir = ('/ariel/data2/Alice/NV3_DualColor/D_Lab/' #NV3_color_sensor_12bit/' # 'Masa/20170816/led2') #'/Scope_Autofluorescence/NV3-04/led2_0_gain1_coverOff') #'V3-63/20170807/led2') #'V3-17/20170714') #'V3-55/20170710') #'V3-55/V3_55_20170717') #'V3-75/20171127/led2') #'V3_39/20170807/led2') #'V3-17/20170714') #'Scope_Autofluorescence/NV3-04/led2_4_gain1_coverOff') #NV3-04/led2_4_coverOff') # # 'Scope_Autofluorescence/NV3-01/led2_0') # # root_dir = '/Users/Sabrina/workspace/data/pipeline_s' fn = [f for f in listdir(root_dir) if isfile(join(root_dir, f))] print('{} files have been found, they are \n {}'.format(len(fn), fn)) # find the rgb channel, and sort fn as r/g/b ch = ['red', 'green', 'blue'] rgb_files, rgb_files_root = isxrgb.find_rgb_channels(fn, channel_list=ch) print('rgb files are \n {}'.format(rgb_files)) exp = isxrgb.get_exp_label(rgb_files_root) rgb_files_with_path = [os.path.join(root_dir, file) for file in rgb_files] # open one channel first to get the basics of the movie ext = os.path.splitext(rgb_files_with_path[0])[1] if ext == '.isxd': tmp = isx.Movie(rgb_files_with_path[0]) frame_shape = tmp.shape n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.num_frames frame_rate = tmp.frame_rate tmp.close() elif ext == '.tif': tmp = Image.open(rgb_files_with_path[0]) frame_shape = tmp.size[::-1] n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.n_frames frame_rate = 20 #tmp.frame_rate #todo: does the tif file always have frame rate info? what's the tag name?? tmp.close() # get an example frame to get accurate frame_shape (especially necessary when correct_bad_pixels == True tmp = isxrgb.get_rgb_frame(rgb_files_with_path, 0, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) frame_shape = tmp.shape[1:3] n_pixels = frame_shape[0] * frame_shape[1] #### if analyze_example_frame: for frame_idx in example_frame_idx: # get data example_rgb_frame = isxrgb.get_rgb_frame(rgb_files_with_path, frame_idx, camera_bias=None, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) # prepare figure fig = plt.figure(figsize=(18, 8)) gs = gsp.GridSpec(2, 4, wspace=0.2) plt.suptitle('{}\n\n{}'.format(exp['label'], rgb_files_root)) #, rgb_files_root, frame_idx)) #{} frame # {} # show rgb images hax = list() for k in range(3): hax.append(plt.subplot(gs[0, k])) # tmp = np.zeros((3, 20, 30)) # tmp[:, 0:10, 0:15] = example_rgb_frame[:, 0:10, 0:15] # show_rgb_frame(tmp, ax_list=hax, clim=clim) isxrgb.show_rgb_frame(example_rgb_frame, cmap='gray', ax_list=hax, clim=clim) # plot the histogram hax = plt.subplot(gs[0, 3]) plot_rbg_pixels_hist(example_rgb_frame, ax=hax) hax.set_xlim(clim) pos = hax.get_position() pos.x0 = pos.x0 + 0.3 * pos.width hax.set_position(pos) # plot scatter plot to show the ratio for r / g, g / b, and b / r pair hax = [] for k in range(3): hax.append(plt.subplot(gs[1, k])) show_rgb_ratio(example_rgb_frame, ax_list=hax, n_select_pixels=1000) gs.tight_layout(fig, rect=[0.02, 0.02, 0.96, 0.95]) figure_name = '{}/figures/{}_file{}_frame{}'.format(os.getcwd(), exp['label'], rgb_files_root[-2:], frame_idx) if correct_stray_light: figure_name = '{}_correct'.format(figure_name) plt.savefig(figure_name, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0, frameon=None) #### if analyze_time_pixel: # get data select_frame_idx = np.arange(0, n_frames - 1, int(n_frames / n_select_time_points)) select_pixel_idx = np.arange(0, n_pixels - 1, int(n_pixels / n_select_pixels)) if random_pixels: select_pixel_idx = random.sample(range(n_pixels), int(n_pixels / n_select_pixels)) rgb_pixel_time = isxrgb.get_rgb_pixel_time(rgb_files_with_path, select_frame_idx, select_pixel_idx, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) # make figure for plots plt.figure(figsize=(10, 8)) gs = gsp.GridSpec(3, 2, width_ratios=[3, 1], wspace=0.3) plt.suptitle('{}\n\n {} selected {} frames'.format(exp['label'], rgb_files_root, len(select_frame_idx))) hax = list() for i in range(2): for k in range(3): hax.append(plt.subplot(gs[k, i])) # for k in range(3) and i in range(2))) plot_rgb_pixel_time(rgb_pixel_time, select_frame_idx, frame_rate, measure_name=measure_name, ax_list=hax, fit_method=fit_method, ch=None) # plt.show() figure_name = '{}/figures/{}_time_{}_file{}'.format(os.getcwd(), exp['label'], measure_name, rgb_files_root[-2:]) if correct_stray_light: figure_name = '{}_correct'.format(figure_name) plt.savefig(figure_name, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None) if analyze_time: select_frame_idx = np.arange(0, n_frames - 1, int(n_frames / n_select_time_points)) rgb_stack = np.empty((len(ch), len(select_frame_idx))) print('Collect frame', end='') for i, frameIdx in enumerate(select_frame_idx): # show randomly selected frames print('...', end='') this_rgb_frame = isxrgb.get_rgb_frame(rgb_files_with_path, frameIdx, correct_stray_light=correct_stray_light, correct_bad_pixels=correct_bad_pixels) # calculate average intensity across the frame for R/G/B rgb_stack[:, i] = np.mean(this_rgb_frame.reshape(-1, len(ch)), axis=0) print('frame {}'.format(frameIdx)) # total_drop = (rgb_stack[:, 0] - rgb_stack[:, -1])/rgb_stack[:, 0] plt.figure(figsize=(10, 10)) gs = gsp.GridSpec(3, 1) htitle = plt.suptitle( '{}\n\n {} photobleaching selected {} frames'.format(exp['label'], rgb_files_root, len(select_frame_idx))) hax = [] for k in range(len(ch)): hax.append(plt.subplot(gs[k])) for i in range(len(ch)): plt.sca(hax[i]) x2plot = select_frame_idx / frame_rate / 60 y2plot = rgb_stack[i, :] plt.plot(x2plot, y2plot, color=ch[i], linestyle='None', marker='.', markersize=2) a, k, c, y_hat = mm.fit_exponential(x2plot, y2plot, linear_method=True, c0=0) a, k, c, y_hat = mm.fit_exponential(x2plot, y2plot, linear_method=False, p0=[a, k, c]) plt.plot(x2plot, y_hat, label='$F = %0.2f e^{%0.2f t} + %0.2f$' % (a, k, c)) hax[i].legend(bbox_to_anchor=(1, 1)) hax[i].set_ylabel('F_mean', color=ch[i]) pb_measured = np.diff(y2plot[[-1, 0]]) / y2plot[0] pb_fitted = np.diff(y_hat[[-1, 0]]) / y2plot[0] pb_measured_s = '{:.0%}'.format(pb_measured[0]) pb_fitted_s = '{:.0%}'.format(pb_fitted[0]) label = '{} {}'.format(pb_measured_s, pb_fitted_s) if i == 0: label = 'Total fluorescence drop in {:.1f} min is measured as {} fitted as {}'.format(x2plot[-1], pb_measured_s, pb_fitted_s) plt.text(x2plot[-1], hax[i].get_ylim()[-1] - 0.2 * np.diff(hax[i].get_ylim()), label, horizontalalignment='right', verticalalignment='top', color=ch[i]) hax[-1].set_xlabel('time (min)') # plt.show() figure_name = '{}/figures/{}_photobleaching_file{}'.format(os.getcwd(), exp['label'], rgb_files_root[-2:]) if correct_stray_light: figure_name = '{}_correct'.format(figure_name) plt.savefig(figure_name, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None)
def create_stray_light_fitting_files(root_dir_group_list, time_range, save_filename_straylight_data, save_filename_straylight, channel=None, correct_bad_green_pixels=None, ): if channel is None: ch = ['red', 'green', 'blue'] if correct_bad_green_pixels is None: correct_bad_green_pixels = False straylight = {} straylight['file_info'] = [] max_n_file = max(len(this_group_root_dir_list) for this_group_root_dir_list in root_dir_group_list) - 1 for group_idx, this_group_root_dir_list in enumerate(root_dir_group_list): straylight['file_info'].append({}) straylight['file_info'][group_idx]['tissue'] = [] straylight['file_info'][group_idx]['microscope'] = [] straylight['file_info'][group_idx]['led_name'] = [] straylight['file_info'][group_idx]['led_power'] = [] straylight['file_info'][group_idx]['filename'] = [] for file_idx in range(len(this_group_root_dir_list) - 1): root_dir = os.path.join(this_group_root_dir_list[0], this_group_root_dir_list[file_idx + 1]) fn = [f for f in listdir(root_dir) if isfile(join(root_dir, f))] print('{} files have been found, they are \n {}'.format(len(fn), fn)) # find the rgb channel, and sort fn as r/g/b rgb_files, rgb_files_root = isxrgb.find_rgb_channels(fn) print('rgb files are \n {}'.format(rgb_files)) exp_label = isxrgb.get_exp_label(rgb_files_root) rgb_files_with_path = [os.path.join(root_dir, file) for file in rgb_files] # open one channel first to get the frame numbers ext = os.path.splitext(rgb_files_with_path[0])[1] if ext == '.isxd': tmp = isx.Movie(rgb_files_with_path[0]) frame_shape = tmp.shape n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.num_frames frame_rate = tmp.frame_rate tmp.close() elif ext == '.tif': tmp = Image.open(rgb_files_with_path[0]) frame_shape = tmp.size[::-1] n_pixels = frame_shape[0] * frame_shape[1] n_frames = tmp.n_frames frame_rate = tmp.frame_rate tmp.close() # get an example frame to get accurate frame_shape # (especially necessary when correct_bad_green_pixels == True tmp = isxrgb.get_rgb_frame(rgb_files_with_path, 0, correct_bad_green_pixels=correct_bad_green_pixels) frame_shape = tmp.shape[1:3] n_pixels = frame_shape[0] * frame_shape[1] frame_range = np.array(time_range) * frame_rate select_frame_idx = np.arange(frame_range[0], frame_range[1]) rgb_frame_stack = np.zeros((len(ch), frame_shape[0], frame_shape[1], len(select_frame_idx))) print('Collect frame', end='') for i, frameIdx in enumerate(select_frame_idx): # show randomly selected frames print('...', end='') this_rgb_frame = isxrgb.get_rgb_frame(rgb_files_with_path, frameIdx, correct_bad_green_pixels=correct_bad_green_pixels) rgb_frame_stack[:, :, :, i] = this_rgb_frame print('frame {}'.format(frameIdx)) # calculate average intensity across time for R/G/B rgb_frame_stack_mean4time = np.mean(rgb_frame_stack, axis=3) # rgb_frame_stack_std4time = np.std(rgb_frame_stack, axis=3) if file_idx == 0 and group_idx == 0: rgb_frame_file_group = np.empty((len(ch), frame_shape[0], frame_shape[1], max_n_file, len(root_dir_group_list))) rgb_frame_file_group.fill(np.nan) rgb_frame_file_group[:, :, :, file_idx, group_idx] = rgb_frame_stack_mean4time # get experimental parameter from exp_label idx1 = exp_label.rfind('(') idx2 = exp_label.rfind(')') straylight['file_info'][group_idx]['led_power'].append( float(exp_label[idx1 + 1:idx2 - 2].replace(',', '.', 1))) idx3 = exp_label[0:idx1].rfind(',') idx4 = exp_label[0:idx3].rfind(',') straylight['file_info'][group_idx]['tissue'].append(exp_label[0:idx4]) straylight['file_info'][group_idx]['microscope'].append(exp_label[idx4 + 2:idx3]) straylight['file_info'][group_idx]['led_name'].append(exp_label[idx3 + 2:idx1 - 1]) straylight['file_info'][group_idx]['filename'].append(rgb_files_root) led_power = straylight['file_info'][group_idx]['led_power'] led_name = straylight['file_info'][group_idx]['led_name'][0] straylight[led_name] = {} # fit F - Power(LED) for each pixel x = led_power b1 = np.empty(n_pixels) b0 = np.empty(n_pixels) straylight[led_name]['b0'] = np.empty((len(ch), frame_shape[0], frame_shape[1])) straylight[led_name]['b1'] = np.empty((len(ch), frame_shape[0], frame_shape[1])) for i in range(len(ch)): tmp = np.reshape(rgb_frame_file_group[i, :, :, :, group_idx], [n_pixels, -1]) for count, j in enumerate(range(n_pixels)): if np.mod(count, 10000) == 0: print('fitting pixel # {} ...'.format(j)) y = tmp[j, :] y = y[~np.isnan(y)] coeff, y_hat = mm.linear_regression(x, y) # fit with linear b0[j] = coeff[0] b1[j] = coeff[1] # y_hat = m * x + b straylight[led_name]['b0'][i, :, :] = b0.reshape([frame_shape[0], frame_shape[1]]) straylight[led_name]['b1'][i, :, :] = b1.reshape([frame_shape[0], frame_shape[1]]) # save the result into files save_data_file = open(save_filename_straylight_data, 'wb') pickle.dump(rgb_frame_file_group, save_data_file) save_data_file.close() save_file = open(save_filename_straylight, 'wb') pickle.dump(straylight, save_file) save_file.close()
def run_test_data(): root_dir = '/Users/Sabrina/git/myWork/dualColor/result/isxd' #xyz.isxd' #'/ariel/data2/Sabrina/NV3_01_greenpixel_bitsdrop/' filename = 'xyz.isxd' #'v3-01_gr_0ff.isxd' #'v3-01_gb_0ff.isxd' #'v3-01_blue_0ff.isxd' #'v3-01_red_0ff.isxd' #'Movie_2018-01-30-12-53-38_red_only.isxd' #'Movie_2018-01-30-12-56-08_blue_only.isxd' #'img_2018-03-08-15-41-21 A80043050047 colorbars.tif' #'img_2018-03-08-15-43-46 A80043050039 colorbars.tif' # #'A80043050039.tif' #'Movie_2018-01-30-12-55-17_greenr_raw.isxd' #'Movie_2018-01-30-12-56-52_greenb_raw.isxd' #'both_green_fff_2016-02-11-14-15-10_raw.isxd' # select_frames = [0] microscope_name = 'NV3-1' #'JH_cropEdge' filename_with_path = os.path.join(root_dir, filename) ext = os.path.splitext(filename_with_path)[1] if ext == '.tif': this_movie = Image.open(filename_with_path) n_row = this_movie.size[1] n_col = this_movie.size[0] n_frame = this_movie.n_frames elif ext == '.isxd': this_movie = isx.Movie(filename_with_path) # print('Frame rate:{:0.2f} Hz'.format(this_movie.frame_rate)) n_row = this_movie.shape[0] n_col = this_movie.shape[1] n_frame = this_movie.num_frames print('#of frames:{}'.format(n_frame)) print('Movie size: {} rows by {} columns'.format(n_row, n_col)) stack = np.empty((n_row, n_col, len(select_frames))) # get first frame from each channel for i, frame_idx in enumerate(select_frames): if ext == '.tif': this_movie.seek(frame_idx) stack[:, :, i] = np.array(this_movie) this_movie.close() elif ext == '.isxd': stack[:, :, i] = this_movie.read_frame(frame_idx) this_movie.close() # n_colorPan_y_rng = {'w': [3, 155], 'y': [156, 315], 'c': [316, 475], 'g': [476, 635], # 'm': [636, 795], 'r': [796, 955], 'b': [956, 1115], 'k': [1116, 1275]} # select_colorPan = 'g' # u, u_inverse, u_count = np.unique(stack[:, np.arange(n_colorPan_y_rng[select_colorPan][0], # n_colorPan_y_rng[select_colorPan][1]+1)], return_inverse=True, return_counts=True) # stack = stack[2:-2, 1:-1, :] u, u_inverse, u_count = np.unique(stack[:, :, 0], return_inverse=True, return_counts=True) # add pixel value and the corresponding count label = [] for i in range(len(u)): label.append('{} (n={})'.format(int(u[i]), u_count[i])) if u[i] == 0: label[i] = '{}'.format(int(u[i])) fig = plt.figure(figsize=(8, 8)) gs = plt.GridSpec(1, 2, width_ratios=[20, 1], right=0.8, top=0.5, bottom=0.05) hax = [] for i in range(2): hax.append(plt.subplot(gs[i])) plt.suptitle('{} \n{}'.format(microscope_name, filename)) plt.sca(hax[0]) im = plt.imshow(stack[:, :, 0], cmap='jet', aspect='equal') #0:20, 0:30 # hax[0].xaxis.set_ticks(range(0, 30, 5)) # hax[0].yaxis.set_ticks(range(0, 20, 5)) # plt.sca(hax[1]) # hax[1].set_ylim(u[[0, -1]]) # s='' # for i in range(len(u)-1, -1, -1): # s = '{}\n{}'.format(s, label[i]) # plt.text(2, 0, '{}'.format(s), fontsize=8) cbar = plt.colorbar( im, cax=hax[1]) # , location='right', orientation='vertical') pos = hax[0].get_position() pos0 = hax[1].get_position() hax[1].set_position([pos0.x0, pos.y0, pos0.width, pos.height]) cbar.set_ticks(u[1::]) cbar.set_ticklabels(label[1::]) figure_name = '{}/figures/{}_{}'.format(os.getcwd(), microscope_name, filename[0:-5]) plt.savefig(figure_name, dpi=600, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0, frameon=None) plt.show()