def make_step_times(session):
for i in range(len(session.steps)):
(times, centroids, left, right) = step_times(session, i)
left_timestamps = utils.flatten(left)
right_timestamps = utils.flatten(right)
#step_timestamps = utils.flatten(step_times(session,i))
np.savetxt('step%s_times_left.csv' % (i), left_timestamps, '%s')
np.savetxt('step%s_times_right.csv' % (i), right_timestamps, '%s')
def save_trajectory_labels(trajectories):
for x in trajectories:
timestamp_path = os.path.splitext(x[2])[0] + '.csv'
timestamps = np.genfromtxt(timestamp_path, dtype=str)
datafolder = os.path.split(x[2])[0]
step_trial_files = [
os.path.join(datafolder, r'step%s_trials.csv') % (s)
for s in range(1, 7)
]
step_trials = np.array([
utils.ensure_list(np.genfromtxt(f, dtype=bool))
if os.path.exists(f) else np.array([]) for f in step_trial_files
])
left_rewards = utils.ensure_list(
np.genfromtxt(os.path.join(datafolder, r'left_rewards.csv'),
dtype=str))
right_rewards = utils.ensure_list(
np.genfromtxt(os.path.join(datafolder, r'right_rewards.csv'),
dtype=str))
reward_times = filter(
None, utils.flatten(it.izip_longest(left_rewards, right_rewards)))
trajectory_trial_mapping = []
for trajectory in x[1]:
candidate_trials = [
i + 1 for i in range(len(reward_times))
if reward_times[i] < timestamps[trajectory.start]
]
if len(candidate_trials) > 0:
trajectory_trial_mapping.append(candidate_trials[-1])
else:
trajectory_trial_mapping.append(0)
trajectory_labels = []
for i, trajectory in enumerate(x[1]):
labels = {}
trial_number = trajectory_trial_mapping[i]
step_state = [
step_trial[min(trial_number,
len(step_trial) - 1)]
for step_trial in step_trials
]
direction_label = 'left' if x[0][trajectory.start,
0] > 640 else 'right'
stable_crossing_label = 'stable' if np.all(
step_state) else 'unstable'
labels['direction'] = direction_label
labels['state'] = stable_crossing_label
trajectory_labels.append(labels)
trajectory_label_path = os.path.join(
datafolder, r'Analysis\trajectory_labels.csv')
np.savetxt(trajectory_label_path, trajectory_labels, fmt='%s')
def step_posture_clusters(session, stepindex, keep_image_list=True):
images = utils.flatten([
imgproc.load_image_folder(path + r'/Steps/Step%s' % (stepindex))
for path in session.path
])
distances = imgproc.pixel_distance_matrix(images)
clusters = hcl.complete(distances)
if not keep_image_list:
del images
images = None
return (distances, clusters, images)
def get_spatial_speed_distribution(trials):
spatial_distribution = filter(lambda x: x < 1077, utils.flatten(trials))
speed_distribution = get_tip_horizontal_speed_trials(trials)
hst = np.histogram(spatial_distribution, 100)
bins = hst[1]
bin_indices = [np.digitize(progression, bins) for progression in trials]
spatial_speed = np.zeros(len(bins))
spatial_samples = np.zeros(len(bins))
for i in xrange(len(speed_distribution)):
speed_values = speed_distribution[i]
speed_indices = bin_indices[i]
for j in xrange(len(speed_values)):
if speed_indices[j] < len(bins):
spatial_speed[speed_indices[j]] += speed_values[j]
spatial_samples[speed_indices[j]] += 1
return (hst, spatial_speed, spatial_samples)
def merge_sessions(name, sessions):
result = parse_session.session(
name=name,
path=utils.flatten([s.path for s in sessions]),
mean=utils.flatten([s.mean for s in sessions if s.mean is not None]),
tip_horizontal=utils.flatten([
s.tip_horizontal for s in sessions if s.tip_horizontal is not None
]),
tip_horizontal_path=utils.flatten([
s.tip_horizontal_path for s in sessions
if s.tip_horizontal_path is not None
]),
tip_vertical=utils.flatten(
[s.tip_vertical for s in sessions if s.tip_vertical is not None]),
crossing_direction=utils.flatten([
s.crossing_direction for s in sessions
if s.crossing_direction is not None
]),
step_activity=[],
steps=[],
left_crossings=[],
right_crossings=[],
merged_sessions=sessions,
session_type='merged')
offset = 0
for s in sessions:
if s.left_crossings is None:
continue
result.left_crossings.append(np.array(s.left_crossings) + offset)
offset = offset + len(s.mean)
result.left_crossings = utils.flatten(result.left_crossings)
if s.steps is not None:
result.steps = [
utils.flatten([s.steps[i] for s in sessions if s.steps])
for i in range(len(sessions[0].steps))
]
return result
np.mean(data),
width=barwidth,
yerr=[[0], [np.std(data)]],
color=color,
ecolor=color)
conditionselector = lambda x: None
average_speed = [[
procses.get_average_crossing_tip_speed(session, conditionselector(session),
valid_positions, slice(1, None))[1]
for session in mclesionsham[i]
] for i in range(0, 14)]
lesion_stable = np.array(
utils.flatten([average_speed[i][0] for i in range(0, 14) if i % 2 == 0]))
sham_stable = np.array(
utils.flatten([average_speed[i][0] for i in range(0, 14) if i % 2 != 0]))
lesion_centerunstable = np.array(
utils.flatten([average_speed[i][1] for i in range(0, 14) if i % 2 == 0]))
sham_centerunstable = np.array(
utils.flatten([average_speed[i][1] for i in range(0, 14) if i % 2 != 0]))
lesion_allreleased = np.array(
utils.flatten([average_speed[i][2] for i in range(0, 14) if i % 2 == 0]))
sham_allreleased = np.array(
utils.flatten([average_speed[i][2] for i in range(0, 14) if i % 2 != 0]))
### BARPLOT ###
offset = 0
barwidth = 0.35
barplot(lesion_stable, offset, barwidth, 'r')
def get_crossing_expansion(session, trial_variable):
trial_expansions = np.bincount(session.crossing_trial_mapping)
return utils.flatten([[x] * c for x, c in itertools.izip_longest(
trial_variable,
trial_expansions,
fillvalue=trial_expansions[len(trial_expansions) - 1])])
def get_speed_normalizer(speeds, q):
distribution = np.concatenate([utils.flatten(s) for s in speeds])
return np.percentile(distribution, q)
def parse_session(path, name, analysis=True):
cwd = os.getcwd()
os.chdir(path)
start_time = None
left_rewards = utils.ensure_list(
np.genfromtxt(r'..\left_rewards.csv', dtype=str))
right_rewards = utils.ensure_list(
np.genfromtxt(r'..\right_rewards.csv', dtype=str))
reward_times = filter(
None, utils.flatten(itertools.izip_longest(left_rewards,
right_rewards)))
frame_time = np.genfromtxt(r'..\front_video.csv', dtype=str, usecols=0)
start_time = dateutil.parser.parse(frame_time[0])
# Default member placeholders
mean = None
centroid_x = None
centroid_y = None
tip_horizontal = None
tip_vertical = None
tip_horizontal_path = None
tip_horizontal_path_indices = None
tip_vertical_path = None
step_activity = None
steps = None
left_crossings = None
right_crossings = None
crossing_direction = None
trial_time = None
crossing_trial_mapping = None
step_times = None
light_trials = None
crossing_light_condition = None
left_poke = None
right_poke = None
front_activity = None
crossing_labels = None
step_trials = None
if analysis:
if os.path.exists(r'..\front_activity.csv'):
front_activity = np.genfromtxt(r'..\front_activity.csv')
if os.path.exists(r'..\left_poke.csv'):
left_poke = [
np.genfromtxt(r'..\left_poke.csv', usecols=0),
np.genfromtxt(r'..\left_poke.csv', usecols=1, dtype=str)
]
right_poke = [
np.genfromtxt(r'..\right_poke.csv', usecols=0),
np.genfromtxt(r'..\right_poke.csv', usecols=1, dtype=str)
]
mean = utils.loadfromcsv('mean.csv')
centroid_x = utils.loadfromcsv('centroid_x.csv')
centroid_y = utils.loadfromcsv('centroid_y.csv')
tip_horizontal = utils.loadfromcsv('tip_horizontal.csv')
tip_vertical = utils.loadfromcsv('tip_vertical.csv')
trial_time = utils.loadfromcsv('trial_time.csv', lambda x: str(x))
crossing_trial_mapping = []
for crossing in trial_time:
candidate_trials = [
i + 1 for i in range(len(reward_times))
if reward_times[i] < crossing[0]
]
if len(candidate_trials) > 0:
crossing_trial_mapping.append(candidate_trials[-1])
else:
crossing_trial_mapping.append(0)
# extract light trial pattern and tile it to be as long as the number of trials
if os.path.exists(r'..\light_trials.csv'):
light_trials = np.genfromtxt(r'..\light_trials.csv', dtype=bool)
light_trials = np.tile(light_trials,
(len(reward_times) / len(light_trials) + 1))
light_trials = light_trials[0:len(reward_times)]
light_trial_crossing_count = np.bincount(crossing_trial_mapping)
crossing_light_condition = utils.flatten(
[[x] * c
for x, c in zip(light_trials, light_trial_crossing_count)])
else:
light_trials = None
crossing_light_condition = None
stepfiles = [f for f in glob.glob("step*.csv") if len(f) <= 9]
step_activity = [utils.loadfromcsv(step) for step in stepfiles]
step_threshold = [[
np.array([x > 100000 and 1 or 0 for x in trial]) for trial in step
] for step in step_activity]
steps = [[np.insert(np.diff(trial), 0, 0) > 0 for trial in step]
for step in step_threshold]
step_times_files = [
'step%s_times.csv' % (s) for s in range(len(stepfiles))
]
step_times = [
utils.ensure_list(np.genfromtxt(f, dtype=str))
if os.path.exists(f) else np.array([]) for f in step_times_files
]
step_trial_files = [r'..\step%s_trials.csv' % (s) for s in range(1, 7)]
step_trials = np.array([
utils.ensure_list(np.genfromtxt(f, dtype=bool))
if os.path.exists(f) else np.array([]) for f in step_trial_files
])
tip_horizontal_path = [[x for x in trial if x >= 0]
for trial in tip_horizontal]
tip_vertical_path = [[x for x in trial if x >= 0]
for trial in tip_vertical]
tip_horizontal_path_indices = [[
i for i, x in enumerate(trial) if x >= 0
] for trial in tip_horizontal]
crossing_labels = []
for i in range(len(trial_time)):
labels = {}
trial_number = crossing_trial_mapping[i]
step_state = [
step_trial[min(trial_number,
len(step_trial) - 1)]
for step_trial in step_trials
]
direction_label = 'left' if tip_horizontal_path[i][
0] > 640 else 'right'
steady_crossing_label = 'steady' if tip_horizontal[i][
0] < 0 and tip_horizontal[i][-1] < 0 else 'exploratory'
stable_crossing_label = 'stable' if np.all(
step_state) else 'unstable'
labels['direction'] = direction_label
labels['type'] = steady_crossing_label
labels['state'] = stable_crossing_label
crossing_labels.append(labels)
crossing_direction = [x[0] > 640 for x in tip_horizontal_path]
left_crossings = [i for i, x in enumerate(crossing_direction) if x]
right_crossings = [
i for i, x in enumerate(crossing_direction) if not x
]
for i in left_crossings:
for s in range(len(steps) / 2):
tmp = steps[s][i]
steps[s][i] = steps[len(steps) - 1 - s][i]
steps[len(steps) - 1 - s][i] = tmp
# for j in range(len(tip_horizontal_path[i])):
# tip_horizontal_path[i][j] = 1078 + (tip_horizontal_path[i][j] * -1)
if os.path.exists(r'..\left_trials.csv'):
left_trials = np.genfromtxt(r'..\left_trials.csv', dtype=bool)
right_trials = np.genfromtxt(r'..\right_trials.csv', dtype=bool)
manipulation_trials = utils.flatten(zip(left_trials, right_trials))
session_type = 'manipulation'
else:
manipulation_trials = None
session_type = 'stable'
reward_times = [dateutil.parser.parse(time) for time in reward_times]
inter_reward_intervals = np.diff(reward_times)
if len(reward_times) > 0:
inter_reward_intervals = np.insert(inter_reward_intervals, 0,
reward_times[0] - start_time)
os.chdir(cwd)
return session(path=[path],
name=name,
mean=mean,
front_activity=front_activity,
centroid_x=centroid_x,
centroid_y=centroid_y,
tip_horizontal=tip_horizontal,
tip_vertical=tip_vertical,
tip_horizontal_path=tip_horizontal_path,
tip_horizontal_path_indices=tip_horizontal_path_indices,
tip_vertical_path=tip_vertical_path,
step_activity=step_activity,
steps=steps,
step_times=step_times,
crossing_direction=crossing_direction,
left_crossings=left_crossings,
right_crossings=right_crossings,
frame_time=frame_time,
trial_time=trial_time,
start_time=start_time,
left_rewards=left_rewards,
right_rewards=right_rewards,
reward_times=reward_times,
inter_reward_intervals=inter_reward_intervals,
crossing_trial_mapping=crossing_trial_mapping,
manipulation_trials=manipulation_trials,
session_type=session_type,
crossing_labels=crossing_labels,
step_trials=step_trials,
light_trials=light_trials,
crossing_light_condition=crossing_light_condition,
left_poke=left_poke,
right_poke=right_poke)
