end = (p + 1) * time_points_buffer x = spike_info['times'].values[np.logical_and(spike_info['times'] < end, spike_info['times'] > start)] templates = spike_info['template_after_sorting'].values[np.logical_and( spike_info['times'] < end, spike_info['times'] > start)] y = [] for t in templates: y.append(template_info[template_info['template number'] == t] ['position Y'].values[0]) y = np.array(y) * const.POSITION_MULT return x, y raster = None tr.connect_repl_var(globals(), 'pane', 'raster', 'raster_from_pane') osv.graph(globals(), 'y', 'x', True) # Calculating firing rates using arbitrary time windows ''' seconds_in_averaging_window = 0.5 averaging_window = int(seconds_in_averaging_window * const.SAMPLING_FREQUENCY) num_of_windows = int(ap_data.shape[1] / averaging_window) spike_rates = np.zeros((len(template_info), num_of_windows)) for t_index in np.arange(len(template_info)): template_index = template_info['template number'].iloc[t_index] spike_times_in_template = spike_info[spike_info['template_after_sorting'] == template_index]['times'].values
sync_funcs.get_time_points_of_events_in_sync_file(data_folder, clean=True, cam_ttl_pulse_period= const.CAMERA_TTL_PULSES_TIMEPOINT_PERIOD) points_per_pulse = np.mean(np.diff(camera_pulses)) camera_frames_in_video = csv_funcs.get_true_frame_array(data_folder) time_point_of_first_video_frame = camera_pulses[camera_frames_in_video][0] def time_point_to_frame(x): return sync_funcs.time_point_to_frame(time_point_of_first_video_frame, camera_frames_in_video, points_per_pulse, x) tr.connect_repl_var(globals(), 'pointer', 'video_frame', 'time_point_to_frame') # ----------------------------------------------------------------------------- # DETECTING SUBTHRESHOLD SPIKES WITH INSTANTANEOUS PHASE ---------------------- def butter_bandpass(lowcut, highcut, fs, order=5): nyq = 0.5 * fs low = lowcut / nyq high = highcut / nyq sos = butter(order, [low, high], analog=False, btype='band', output='sos') return sos def butter_bandpass_filter(data, lowcut, highcut, fs, order=5): sos = butter_bandpass(lowcut, highcut, fs, order=order)
sv.graph_range(globals(), 'sound_start', 'sound_step', 'rec2_sound') def sync_start_to_sound_start(sync_start): sound_start = int(sync_start * sound_to_sync_sampling_ratio + offset) if sound_start < 0: sound_start = 0 return sound_start def sync_step_to_sound_step(sync_step): return int(sync_step * sound_to_sync_sampling_ratio) tr.connect_repl_var(globals(), 'sync_start', 'sound_start', 'sync_start_to_sound_start') tr.connect_repl_var(globals(), 'sync_step', 'sound_step', 'sync_step_to_sound_step') # Calculate manually the different offsets # Get the long stretches of no sound in the sync file sync_signal_start = 2168624 sync_signal_end = 43394819 baseline = 5 smallest_sound = 6 times_between_pips = 2380 length_of_six_pip_sound = 12000 # test = sync_diff[sync_signal_start:sync_signal_end] test = sync_diff[sync_signal_start:]
markers_positions_no_large_movs = pd.read_pickle( join(dlc_project_folder, 'post_processing', 'markers_positions_no_large_movs.df')) frame = 3 global marker_dots marker_dots = np.zeros((640, 640, 4)) output = None overlay_dots.marker_dots = marker_dots marker_size = 3 markers_positions_no_large_movs_numpy = markers_positions_no_large_movs.values args = [markers_positions_no_large_movs_numpy, marker_size] update_markers_for_video = overlay_dots.update_markers_for_video tr.connect_repl_var(globals(), 'frame', 'output', 'update_markers_for_video', 'args') sv.image_sequence(globals(), 'frame', 'marker_dots', 'full_video_file') # ------------------------------------------------- # GET THE BODY POSITIONS # Get the body markers from the cleaned markers # Then interpolate the nans of the TailBase # Finally average the body markers to get the body position updated_body_markers = dlc_pp.seperate_markers(markers_positions_no_large_movs, body_parts) tail_base = updated_body_markers.loc[:, updated_body_markers.columns. get_level_values(1) == 'TailBase'] tail_base_cleaned = dlc_pp.clean_dlc_outpout(join(dlc_project_folder, 'post_processing',
global previous_template_number global result sys.stdout = result string = result.getvalue() new = string[-200:] try: template_number = int( new[new.find('Template number'):new.find('Template number') + 22][18:22]) if template_number != previous_template_number: template = template_info[template_info['template number'] == template_number] figure.clear() ax = figure.add_subplot(111) try: ax.plot(np.squeeze(avg_templates[template.index.values]).T) except: pass previous_template_number = template_number figure.suptitle('Template = {}, with {} number of spikes'.format( str(template_number), str(template['number of spikes'].values[0]))) except: template_number = None return template_number tr.connect_repl_var(globals(), 'f', 'template_number', 'show_average_template') # ---------------------------------------------------------------------------------------------------------------------- # ----------------------------------------------------------------------------------------------------------------------
tsne_spike_rates_count_pcs_0p1[start + s:start + s + 2, 1], c=colors[s]) return None fig_scat = plt.figure(0) ax1 = fig_scat.add_subplot(111) ax1.imshow(tsne_pcs_count_cn_image, extent=tsne_pcs_count_cn_image_extent, aspect='auto') ax2 = ax1.twinx() seconds_to_track = 1 out = None args = [ax1, ax2, seconds_to_track] tr.connect_repl_var(globals(), 'frame', 'out', 'phase_space', 'args') fig_plot = plt.figure(1) fig_plot_zoom = plt.figure(2) # </editor-fold> # ------------------------------------------------- # ------------------------------------------------- # <editor-fold desc="MAKE VIDEO OF RAT VIDEO WITH THE TSNE"> opencv_rat_video = cv2.VideoCapture(video_file) total_frames = int(opencv_rat_video.get(cv2.CAP_PROP_FRAME_COUNT)) frame_size_of_video_out = (int(2976), int(1549)) dpi = 100
osv.image(globals(), 'data2', 'im_l', 'cm', 'op', number_of_images=1) osv.graph(globals(), 'data2') import transform as tr a = 1 b = 2 c = 3 def t(a, b): return a + b tr.connect_repl_var(globals(), 'a', 'c', 't', 'b') ''' import drop_down as dd e = [1,2,3,4] dd.connect_repl_var(globals(), 'e', 't', 'c', 'b') ''' import slider as s s.connect_repl_var(globals(), 'a', 'c', 't', 'b', slider_limits=[0, 200]) import pandas as pd events_file = r'Y:\swc\kampff\George\DataAndResults\Experiments\Awake\NeuroSeeker\AK_47.2\2019_06_29-11_36\Events_worked_on.csv' events = pd.read_csv(events_file, parse_dates=[0],
# Look at the whole video with body trajectory superimposed traj = np.zeros((640, 640, 4)) frame = 3 output = None def update_trajectory_for_video(frame): traj[:, :, :] = 0 bp = body_positions.astype(int) bp[:, 1] = 640 - bp[:, 1] traj[bp[:frame, 1], bp[:frame, 0], :] = 255 return output tr.connect_repl_var(globals(), 'frame', 'output', 'update_trajectory_for_video') sv.image_sequence(globals(), 'frame', 'full_video_file', 'traj') # ------------------------------------------------------ space_occupancy = binning.bin_2d_array(body_positions, bins=[10, 10]) max_pix_per_frame = 20 # Rats run up to 13Km/h = 20 pixels/frame bins = [ np.logspace(np.log10(0.0001), np.log10(max_pix_per_frame * conversion_const), 30, base=10), 20 ] velocity_categories = binning.bin_2d_array(body_velocities_polar, bins=bins) speed_categories = pd.cut(body_velocities_polar[:, 0], bins=bins[0]) movement_categories = pd.cut(
(spike_data_fd, np.zeros((spike_data.shape[0], spike_data.shape[1], 1))), axis=2) seq_v.graph_pane(globals(), 's', 'spike_data_fd') spike_data_sd = np.diff(spike_data_fd, axis=2) spike_data_sd = np.concatenate( (spike_data_sd, np.zeros((spike_data.shape[0], spike_data.shape[1], 1))), axis=2) largest_channel_index = np.squeeze( np.argwhere(large_channels_full == large_channels[0])) def get_phase_x_of_channel_for_spike(s): return spike_data_sd[s, largest_channel_index, :] def get_phase_y_of_channel_for_spike(s): return spike_data_fd[s, largest_channel_index, :] phase_x = None phase_y = None tr.connect_repl_var(globals(), 's', 'phase_x', 'get_phase_x_of_channel_for_spike') tr.connect_repl_var(globals(), 's', 'phase_y', 'get_phase_y_of_channel_for_spike') s = 1 one_s_v.graph(globals(), 'phase_y', 'phase_x')
ax.plot(Y[fr_smooth - step:fr_smooth + step]) ax.plot(Y_pred[fr_smooth - step:fr_smooth + step]) ax.plot(scores_test_periods_cont_norm[fr_smooth - step:fr_smooth + step]) ax.vlines(x=step, ymin=-1.2, ymax=3) ax.hlines(y=r2_norm_threshold, xmin=0, xmax=2 * step) fig = plt.figure(3) ax = fig.add_subplot(111) args = [ax] out_tr = None sv.image_sequence(globals(), 'frame', 'video_file') dd.connect_repl_var(globals(), 'frame_starts_of_periods', 'frame') tr.connect_repl_var(globals(), 'frame', 'is_period_tracked', 'is_frame_tracked') tr.connect_repl_var(globals(), 'frame', 'out_tr', 'show_distances', 'args') # </editor-fold> # </editor-fold> # ------------------------------------------------- # ------------------------------------------------- # <editor-fold desc="DO THE MIs BETWEEN THE SPIKE RATES AND THE QUALITY OF PREDICTION OF THE DISTANCE TO TRAVEL TO POKE (RUN ONCE)"> n = 0 mi_spike_rates_vs_quality_of_regression_to_travel_to_poke = [] for rate in spike_rates_away_from_poke_close_to_poke_smoothed: mi_spike_rates_vs_quality_of_regression_to_travel_to_poke.append( MI.mi_LNC([rate.tolist(), list(scores_test_cont)], k=10,
channels_heights = ns_funcs.get_channels_heights_for_spread_calulation( lfp_channels_on_probe) bad_lfp_channels = [35, 36, 37] lfp_channels_used = np.delete( np.arange(const.NUMBER_OF_LFP_CHANNELS_IN_BINARY_FILE), bad_lfp_channels) def spread_lfp_pane(p): pane = lfp_data_panes[p, :, :] spread = ns_funcs.spread_data(pane, channels_heights, lfp_channels_used) spread = np.flipud(spread) return spread pane_data = None tr.connect_repl_var(globals(), 'pane', 'pane_data', 'spread_lfp_pane') one_v.graph(globals(), 'pane_data') camera_pulses, beam_breaks, sounds = \ sync_funcs.get_time_points_of_events_in_sync_file(data_folder, clean=True, cam_ttl_pulse_period= const.CAMERA_TTL_PULSES_TIMEPOINT_PERIOD) points_per_pulse = np.mean(np.diff(camera_pulses)) camera_frames_in_video = csv_funcs.get_true_frame_array(data_folder) time_point_of_first_video_frame = camera_pulses[camera_frames_in_video][0] video_frame = 0 video_file = join(data_folder, 'Video.avi')
bad_lfp_channels = [] lfp_channels_used = np.delete( np.arange(const.NUMBER_OF_LFP_CHANNELS_IN_BINARY_FILE), bad_lfp_channels) pane = 100 def spread_lfp_pane(p): pane = lfp_data_panes[p, :, :] spread = ns_funcs.spread_data(pane, channels_heights, lfp_channels_used) spread = np.flipud(spread) return spread pane_data = None tr.connect_repl_var(globals(), 'pane', 'pane_data', 'spread_lfp_pane') one_v.graph(globals(), 'pane_data') def do_nothing(p): return p nothing = None slider_limits = [0, lfp_data_panes.shape[0] - 1] sl.connect_repl_var(globals(), 'pane', 'nothing', slider_limits=slider_limits) # ---------------------------------------------------------------------------------------------------------------------- # SUBSAMPLE THE LFPS WITH DIFFERENT RATIOS AND SAVE THE FILES # ----------------------------------------------------------------------------------------------------------------------
# Show the sync trace gui sync_range = 2000 sync_point = time_point_of_first_video_frame - int(sync_range / 2) sv.graph_range(globals(), 'sync_point', 'sync_range', 'sync') # ---------------------------------- # Connect the video gui to the sync trace gui def time_point_to_frame(x): return sync_funcs.time_point_to_frame(time_point_of_first_video_frame, camera_frames_in_video, points_per_pulse, x) tr.connect_repl_var(globals(), 'sync_point', 'video_frame', 'time_point_to_frame') # ---------------------------------- # Connect the sync trace gui to the video gui def frame_to_time_point(x): return sync_funcs.frame_to_time_point(time_point_of_first_video_frame, camera_frames_in_video, points_per_pulse, x) tr.connect_repl_var(globals(), 'video_frame', 'sync_point', 'frame_to_time_point') # ----------------------------------
global traj_x traj_x = 0 global traj_y traj_y = 0 def update_trajectory(f): global traj_x global traj_y traj_x = body_positions[:f, 0] traj_y = body_positions[:f, 1] return body_positions[:f, :] traj = None tr.connect_repl_var(globals(), 'frame', 'traj', 'update_trajectory') osv.graph(globals(), 'traj_y', 'traj_x') # ------------------------------------------------- ''' # ------------------------------------------------- # FITTING THE MARKERS TO GET BETTER ESTIMATES OF THE LOW LIKELIHOOD ONES # Fitting 2d surface using multiple markers # DID NOT WORK body_markers_positions = markers.loc[:, markers.columns.get_level_values(1).isin(body_parts)] body_markers_positions = body_markers.loc[:, body_markers.columns.get_level_values(2).isin(['x', 'y'])] t = np.reshape(body_markers_positions.loc[:3605*120-1, :].values, (3605, 120, 6)) sec = 0
pane = 0 sequence_viewer.graph_pane(globals(), 'pane', 'data1') # The pane viewer shows te last one or two dimensions of a 2d or 3d data set and itterates over the first one. # Connect two guis def pos1_to_pos2(pos1): if pos1 >= 0 and pos1 <= 4000: return int(pos1 / 10) elif pos1 < 0: return 0 elif pos1 > 4000: return 400 transform.connect_repl_var(globals(), 'position1', 'pos1_to_pos2', 'position2') # Press the Transform to deactivate the function from running and so stop the connection # If the function passed to the transform returns bool then you get nice red/green leds for False and True # SOME NOTES # The variables in the command line are always connected to the guis. After you change them in the guys look for their # values in the repl. # Change the different values of the variables in the repl to see the guis update. # The other guis available at the moment are # 1) One more types of sequence_viewer for images or frames of video (you can pass the name of a video in the # image_sequence function, or a 2d numpy array). # 2) The two types of one_shot_viewers (graph and image) where the shown data gets updated by the repl and not by the gui # 3) The video_viewer where a video can be played at real time (but only gives out frame keys and not individual frames)