def make(self, scan_key):
scan_key = {**scan_key, 'tracking_method': 2}
log.info('Populating '+ pformat(scan_key))
radius, xy, eye_time = self.load_eye_traces(scan_key)
frame_times = self.load_frame_times(scan_key)
behavior_clock = self.load_behavior_timing(scan_key)
if len(frame_times) - len(behavior_clock) != 0:
assert abs(len(frame_times) - len(behavior_clock)) < 2, 'Difference bigger than 2 time points'
l = min(len(frame_times), len(behavior_clock))
log.info('Frametimes and stimulus.BehaviorSync differ in length! Shortening it.')
frame_times = frame_times[:l]
behavior_clock = behavior_clock[:l]
fr2beh = NaNSpline(frame_times, behavior_clock, k=1, ext=3)
duration, offset = map(float, (Preprocessing() & scan_key).fetch1('duration', 'offset'))
sample_point = offset + duration / 2
log.info('Downsampling eye signal to {}Hz'.format(1 / duration))
deye = np.nanmedian(np.diff(eye_time))
h_eye = self.get_filter(duration, deye, 'hamming', warning=True)
h_deye = self.get_filter(duration, deye, 'dhamming', warning=True)
pupil_spline = NaNSpline(eye_time,
np.convolve(radius, h_eye, mode='same'), k=1, ext=0)
dpupil_spline = NaNSpline(eye_time,
np.convolve(radius, h_deye, mode='same'), k=1, ext=0)
center_spline = SplineCurve(eye_time,
np.vstack([np.convolve(coord, h_eye, mode='same') for coord in xy]),
k=1, ext=0)
flip_times = (InputResponse.Input * Frame * stimulus.Trial & scan_key).fetch('flip_times',
order_by='row_id ASC')
flip_times = [ft.squeeze() for ft in flip_times]
# If no Frames are present, skip this scan
if len(flip_times) == 0:
log.warning('No static frames were present to be processed for {}'.format(scan_key))
return
stimulus_onset = InputResponse.stimulus_onset(flip_times, duration)
t = fr2beh(stimulus_onset + sample_point)
pupil = pupil_spline(t)
dpupil = dpupil_spline(t)
center = center_spline(t)
valid = ~np.isnan(pupil + dpupil + center.sum(axis=0))
if not np.all(valid):
log.warning('Found {} NaN trials. Setting to -1'.format((~valid).sum()))
pupil[~valid] = -1
dpupil[~valid] = -1
center[:, ~valid] = -1
self.insert1(dict(scan_key, pupil=pupil, dpupil=dpupil, center=center, valid=valid))
def get_trace_spline(self, key, sampling_period):
traces, frame_times, trace_keys = self.load_traces_and_frametimes(key)
log.info('Loaded {} traces'.format(len(traces)))
log.info('Generating lowpass filters to {}Hz'.format(1 / sampling_period))
h_trace = self.get_filter(sampling_period, np.median(np.diff(frame_times)), 'hamming',
warning=False)
# low pass filter
trace_spline = SplineCurve(frame_times,
[np.convolve(trace, h_trace, mode='same') for trace in traces], k=1, ext=1)
return trace_spline, trace_keys, frame_times.min(), frame_times.max()