def t_test_for_evasive_saccades(dataset):
sac.calc_saccade_stats(dataset)
black_saccade_angle = []
checkered_saccade_angle = []
keys = dataset.keys_saccade_array
evasive_threshold = 0.836248003234
for i, key in enumerate(keys):
trajec = dataset.trajecs[key]
a = dataset.angle_of_saccade_array[i]
ap = dataset.angle_prior_array[i]
if np.abs(a-ap) > evasive_threshold:
if 'black' in trajec.post_type:
black_saccade_angle.append(dataset.angle_subtended_array[i])
elif 'checkered' in trajec.post_type:
checkered_saccade_angle.append(dataset.angle_subtended_array[i])
black_saccade_angle = np.array(black_saccade_angle)
checkered_saccade_angle = np.array(checkered_saccade_angle)
if 1:
fig = plt.figure()
ax = fig.add_subplot(111)
bins = np.linspace( np.log(5*np.pi/180.), np.log(180*np.pi/180.), 20)
bins, hists, curves = floris.histogram(ax, [np.log(black_saccade_angle), np.log(checkered_saccade_angle)], bins=bins, colors=['black', 'teal'], return_vals=True, normed_occurences=True, curve_line_alpha=0)
deg_ticks = np.array([5, 10, 30, 60, 90, 180])
deg_tick_strings = [str(d) for d in deg_ticks]
rad_ticks = deg_ticks*np.pi/180.
rad_ticks_log = np.log(rad_ticks)
dist_tick_strings = ['(21)', '(10)', '(2.7)', '(0.9)', '(0.4)', '(0)']
x_tick_strings = []
for i, d in enumerate(dist_tick_strings):
x_tick_strings.append( deg_tick_strings[i] + '\n' + dist_tick_strings[i] )
ax.set_xlim(rad_ticks_log[0], rad_ticks_log[-1])
ax.set_ylim(0,1)
fa.adjust_spines(ax,['left', 'bottom'])
ax.set_xlabel('Retinal size, deg\n(distance, cm)', labelpad=10)
ax.set_ylabel('Occurances')
ax.set_xticks(rad_ticks_log.tolist())
ax.set_xticklabels(x_tick_strings)
fig.subplots_adjust(bottom=0.25, top=0.9, right=0.9, left=0.2)
filename = 'saccade_histogram_black_vs_checkered' + '.pdf'
fig.savefig(filename, format='pdf')
print 't test: ', scipy.stats.ttest_ind(black_saccade_angle, checkered_saccade_angle)
print 'mann whitney u: ', scipy.stats.mannwhitneyu(black_saccade_angle, checkered_saccade_angle)
print 'black: ', np.mean(black_saccade_angle), 'n: ', len(black_saccade_angle)
print 'checkered: ', np.mean(checkered_saccade_angle), 'n: ', len(checkered_saccade_angle)
print 'total n - 2: ', len(black_saccade_angle) + len(checkered_saccade_angle) - 2
def decleration_color_coded_for_post(dataset, plot=True):
fa.calc_stats_at_deceleration(dataset, keys=None, time_offset=0, return_vals=False)
angleok = np.where( (dataset.angle_at_deceleration < 2)*(dataset.angle_at_deceleration > .01) )[0].tolist()
fig = plt.figure()
ax = fig.add_subplot(111)
black_post = []
checkered_post = []
for i, p in enumerate(dataset.post_type_at_deceleration):
if i in angleok:
if 'black' in p:
black_post.append(i)
if 'checkered' in p:
checkered_post.append(i)
print '*'*40
print len(black_post), len(checkered_post)
bins, hists, hist_std, curves = floris.histogram(ax, [np.log(dataset.angle_at_deceleration[black_post]), np.log(dataset.angle_at_deceleration[checkered_post])], bins=16, colors=['black', 'teal'], bin_width_ratio=0.9, edgecolor='none', bar_alpha=0.2, curve_fill_alpha=0, curve_line_alpha=0.8, return_vals=True, normed_occurences='total', bootstrap_std=True)
ax.plot(np.log(dataset.angle_at_deceleration[black_post]), dataset.speed_at_deceleration[black_post], '.', color='black', alpha=1)
ax.plot(np.log(dataset.angle_at_deceleration[checkered_post]), dataset.speed_at_deceleration[checkered_post], '.', color='teal', alpha=1)
#ax.set_ylim(0,1.2)
fa.fix_angle_log_spine(ax, histograms=True)
fig.savefig('deceleration_color_coded.pdf', format='pdf')
def get_slipangles_for_movie_dataset(movie_dataset):
keys = movie_dataset.get_movie_keys()
slipangles = []
for key in keys:
movie = movie_dataset.movies[key]
try:
tmp = get_slipangles(movie)
slipangles.extend(tmp)
except:
print key
slipangles_in_degrees = np.array(slipangles)*180/np.pi
fig = plt.figure()
ax = fig.add_subplot(111)
bins = np.linspace(-90, 90, 20, endpoint=True)
#ax.hist(slipangles_in_degrees, bins=bins, edgecolor='none', facecolor='purple')
bins, hists, curves = floris.histogram(ax, [slipangles_in_degrees], bins=bins, colors='black', bin_width_ratio=0.9, edgecolor='none', bar_alpha=0.8, curve_fill_alpha=0, curve_line_alpha=0, return_vals=True)
ax.set_xlim(-90,90)
ax.set_ylim(0, 250)
fa.adjust_spines(ax, ['left', 'bottom'])
xticks = [-90, -45, 0, 45, 90]
ax.set_xticks(xticks)
ax.set_xlabel('Slip angle')
ax.set_ylabel('Occurences')
N = len(slipangles)
n = len(keys)
string = 'N='+str(N)+'\nn='+str(n)
ax.text(45,60,string)
fig.savefig('slipangles_nosaccade.pdf', format='pdf')
return slipangles
def plot_touchdown_velocity(movie_dataset):
landing_keys = movie_dataset.get_movie_keys(behavior="landing")
legextension_time = []
touchdown_velocities = []
touchdown_position = []
sitting_position = []
touchdown_time = []
angle = []
for key in landing_keys:
movie = movie_dataset.movies[key]
try:
s = movie.scaled
except:
s = None
print key, ": excepted"
if (
movie.landingframe is not None
and "touchandgo" not in movie.subbehavior
and movie.trajec is not None
and s is not None
):
touchdown_velocities.append(movie.scaled.speed[movie.landingframe_relative])
touchdown_position.append(movie.scaled.dist_to_post[movie.landingframe_relative][0])
sitting_position.append(np.min(movie.scaled.dist_to_post))
legextensionframe = movie.legextensionrange[0] - movie.firstframe_ofinterest
touchdown_time.append(movie.timestamps[movie.landingframe_relative] - movie.timestamps[legextensionframe])
legextensionframe = movie.legextensionrange[0] - movie.firstframe_ofinterest
legextension_time.append(movie.timestamps[legextensionframe])
a = movie.scaled.signed_angletopost[movie.landingframe_relative]
while a < -np.pi:
a += np.pi
while a > np.pi:
a -= np.pi
angle.append(a)
else:
print key
print "n: ", len(touchdown_velocities)
time_after_leg_extension = np.array(touchdown_time) * 1000
fig = plt.figure()
ax = fig.add_subplot(111)
ma = np.min(time_after_leg_extension)
mi = np.max(time_after_leg_extension)
# bins = np.linspace(ma, mi, 10, endpoint=True)
bins, hists, curves = floris.histogram(
ax,
[time_after_leg_extension],
bins=10,
colors="black",
bin_width_ratio=0.9,
edgecolor="none",
bar_alpha=0.8,
curve_fill_alpha=0,
curve_line_alpha=0,
return_vals=True,
show_smoothed=False,
)
ax.set_ylim(0, np.max(hists))
ax.set_xlim(0, 400)
ax.set_autoscale_on(False)
fa.adjust_spines(ax, ["left", "bottom"])
ax.set_xlabel("Time to touchdown, ms")
ax.set_ylabel("Occurences")
filename = "time_to_touchdown_at_leg_ext.pdf"
fig.savefig(filename, format="pdf")
print "mean time to touchdown after leg ext: ", np.mean(touchdown_velocities)
touchdown_velocities = np.array(touchdown_velocities)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(touchdown_velocities)
filename = "touchdown_velocities.pdf"
fig.savefig(filename, format="pdf")
print "mean touchdown velocity: ", np.mean(touchdown_velocities), "+/-", np.std(touchdown_velocities)
dist_travelled_in_touchdown = np.array(touchdown_position) - np.array(sitting_position)
indices = np.where(dist_travelled_in_touchdown > 0)[0].tolist()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(dist_travelled_in_touchdown[indices])
filename = "touchdown_dist_travelled.pdf"
fig.savefig(filename, format="pdf")
print "mean dist travelled: ", np.mean(dist_travelled_in_touchdown)
time_travelled_in_touchdown = np.array(touchdown_time)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(time_travelled_in_touchdown)
filename = "time_travelled_in_touchdown.pdf"
fig.savefig(filename, format="pdf")
angle = np.array(angle) * 180 / np.pi
fig = plt.figure()
ax = fig.add_subplot(111)
bins = np.linspace(-90, 90, 20)
ax.hist(angle, bins=bins)
filename = "angle_to_post_at_touchdown.pdf"
fig.savefig(filename, format="pdf")
accel = touchdown_velocities[indices] ** 2 / (2 * dist_travelled_in_touchdown[indices])
mass = 0.001
force = accel * mass
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(force * 10 ** 4)
filename = "touchdown_deceleration.pdf"
fig.savefig(filename, format="pdf")
print "mean touchdown deceleration: ", np.mean(accel)
print "mean touchdown force: ", np.mean(force)
def plot_speeds_at_dist(dataset_landing, dataset_flyby, dataset_nopost, distance=None):
if distance is None:
distance = np.linspace(0.15, 0.01, 15, endpoint=True)
mean_landing_speeds_black = []
std_landing_speeds_black = []
mean_landing_speeds_checkered = []
std_landing_speeds_checkered = []
mean_flyby_speeds_black = []
mean_flyby_speeds_checkered = []
mean_nopost_speeds = []
histfig = plt.figure()
histax = histfig.add_subplot(111)
for d in distance:
landing_speeds_black = get_speeds_at_dist(dataset_landing, d, post_type=['black', 'black_angled'])
mean_landing_speeds_black.append(np.mean(landing_speeds_black))
std_landing_speeds_black.append(np.std(landing_speeds_black))
landing_speeds_checkered = get_speeds_at_dist(dataset_landing, d, post_type=['checkered', 'checkered_angled'])
mean_landing_speeds_checkered.append(np.mean(landing_speeds_checkered))
std_landing_speeds_checkered.append(np.std(landing_speeds_checkered))
print 'landing: ', scipy.stats.mannwhitneyu(landing_speeds_black, landing_speeds_checkered), np.mean(landing_speeds_black), np.mean(landing_speeds_checkered)
bins = np.linspace(0.1, 0.5, 15)
bins, hists, hist_std, curves = floris.histogram(histax, [landing_speeds_black, landing_speeds_checkered], bins=bins, colors=['black', 'teal'], bin_width_ratio=0.9, edgecolor='none', bar_alpha=0.8, curve_fill_alpha=0.2, curve_line_alpha=0, return_vals=True, normed_occurences=False, bootstrap_std=True)
flyby_speeds_black = get_speeds_at_dist(dataset_flyby, d, post_type=['black', 'black_angled'])
mean_flyby_speeds_black.append(np.mean(flyby_speeds_black))
flyby_speeds_checkered = get_speeds_at_dist(dataset_flyby, d, post_type=['checkered', 'checkered_angled'])
mean_flyby_speeds_checkered.append(np.mean(flyby_speeds_checkered))
print 'flyby: ', scipy.stats.mannwhitneyu(flyby_speeds_black, flyby_speeds_checkered), np.mean(flyby_speeds_black), np.mean(flyby_speeds_checkered)
nopost_speeds = get_speeds_at_dist(dataset_nopost, d)
mean_nopost_speeds.append(np.mean(nopost_speeds))
print 'flyby vs landing (black): ', scipy.stats.mannwhitneyu(flyby_speeds_black, landing_speeds_black)
print 'flyby vs landing (checkered): ', scipy.stats.mannwhitneyu(flyby_speeds_checkered, landing_speeds_checkered)
print 'flyby (black) vs landing (checkered): ', scipy.stats.mannwhitneyu(flyby_speeds_black, landing_speeds_checkered)
print 'flyby (checkered) vs landing (black): ', scipy.stats.mannwhitneyu(flyby_speeds_checkered, landing_speeds_black)
print 'flyby vs nopost (black): ', scipy.stats.mannwhitneyu(flyby_speeds_black, nopost_speeds)
print 'flyby vs nopost (checkered): ', scipy.stats.mannwhitneyu(flyby_speeds_checkered, nopost_speeds)
print 'landing vs nopost (black): ', scipy.stats.mannwhitneyu(landing_speeds_black, nopost_speeds)
print 'landing vs nopost (checkered): ', scipy.stats.mannwhitneyu(landing_speeds_checkered, nopost_speeds)
print
print 'mean flight speed black landing: ', np.mean(landing_speeds_black), np.std(landing_speeds_black)
print 'n: ', len(landing_speeds_black)
all_others = []
all_others.extend(landing_speeds_checkered)
all_others.extend(flyby_speeds_black)
all_others.extend(flyby_speeds_checkered)
all_others.extend(nopost_speeds)
print 'mean flight all others: ', np.mean(all_others), np.std(all_others)
print 'n: ', len(all_others)
mean_landing_speeds_black = np.array(mean_landing_speeds_black)
std_landing_speeds_black = np.array(std_landing_speeds_black)
mean_landing_speeds_checkered = np.array(mean_landing_speeds_checkered)
std_landing_speeds_checkered = np.array(std_landing_speeds_checkered)
mean_flyby_speeds_black = np.array(mean_flyby_speeds_black)
mean_flyby_speeds_checkered = np.array(mean_flyby_speeds_checkered)
mean_nopost_speeds = np.array(mean_nopost_speeds)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(distance, mean_landing_speeds_black, 'black')
ax.fill_between(distance, mean_landing_speeds_black+std_landing_speeds_black, mean_landing_speeds_black-std_landing_speeds_black, alpha=0.2, color='black', edgecolor='none')
ax.fill_between(distance, mean_landing_speeds_checkered+std_landing_speeds_checkered, mean_landing_speeds_checkered-std_landing_speeds_checkered, alpha=0.2, color='teal', edgecolor='none')
ax.plot(distance, mean_landing_speeds_checkered, '-', color='teal')
ax.plot(distance, mean_flyby_speeds_black, 'red')
ax.plot(distance, mean_flyby_speeds_checkered, ':', color='red')
ax.plot(distance, mean_nopost_speeds, 'blue')
ax.set_xlabel('distance, m')
ax.set_ylabel('speed, m/s')
fig.savefig('flight_speeds', format='pdf')
histfig.savefig('flight_speeds_hist', format='pdf')
def t_test_for_leg_ext(movie_dataset, behavior='landing'):
black_legext_angle = []
checkered_legext_angle = []
keys = movie_dataset.movies.keys()
n = 0
for movieid in keys:
movie = movie_dataset.movies[movieid]
if movie.behavior == behavior:
if movie.legextensionrange is not None:
legextensionframe = movie.legextensionrange[0] - movie.firstframe_ofinterest
#sa1_time = movie.timestamps[legextensionframe]
#flydra_frame = get_flydra_frame_at_timestamp(movie.trajec, sa1_time)
try:
tmp = movie.scaled
tmp = True
except:
tmp = False
if 'crash' not in movie.subbehavior and tmp and legextensionframe < movie.landingframe_relative: #tmp: #movie.trajec.classification == 'straight':
if 'black' in movie.posttype:
black_legext_angle.append(movie.scaled.angle_subtended_by_post[legextensionframe][0])
elif 'checkered' in movie.posttype:
checkered_legext_angle.append(movie.scaled.angle_subtended_by_post[legextensionframe][0])
n += 1
black_legext_angle = np.array(black_legext_angle)
checkered_legext_angle = np.array(checkered_legext_angle)
if 1:
fig = plt.figure()
ax = fig.add_subplot(111)
bins = np.linspace( np.log(5*np.pi/180.), np.log(180*np.pi/180.), 16)
bins, hists, curves = floris.histogram(ax, [np.log(black_legext_angle), np.log(checkered_legext_angle)], bins=bins, colors=['black', 'teal'], return_vals=True, normed_occurences=False, curve_line_alpha=0, show_smoothed=True)
deg_ticks = np.array([5, 10, 30, 60, 90, 180])
deg_tick_strings = [str(d) for d in deg_ticks]
rad_ticks = deg_ticks*np.pi/180.
rad_ticks_log = np.log(rad_ticks)
dist_tick_strings = ['(21)', '(10)', '(2.7)', '(0.9)', '(0.4)', '(0)']
x_tick_strings = []
for i, d in enumerate(dist_tick_strings):
x_tick_strings.append( deg_tick_strings[i] + '\n' + dist_tick_strings[i] )
ax.set_xlim(rad_ticks_log[0], rad_ticks_log[-1])
ax.set_ylim(0,10)
fa.adjust_spines(ax,['left', 'bottom'])
ax.set_xlabel('Retinal size, deg\n(distance, cm)', labelpad=10)
ax.set_ylabel('Occurances')
ax.set_xticks(rad_ticks_log.tolist())
ax.set_xticklabels(x_tick_strings)
fig.subplots_adjust(bottom=0.25, top=0.9, right=0.9, left=0.2)
filename = 'legext_histogram_black_vs_checkered' + '.pdf'
fig.savefig(filename, format='pdf')
print 'T-test', scipy.stats.ttest_ind(black_legext_angle, checkered_legext_angle)
print 'Mann Whitney U', scipy.stats.mannwhitneyu(black_legext_angle, checkered_legext_angle)
print 'black: ', np.mean(black_legext_angle), 'n: ', len(black_legext_angle)
print 'checkered: ', np.mean(checkered_legext_angle), 'n: ', len(checkered_legext_angle)
print 'total n - 2: ', len(black_legext_angle) + len(checkered_legext_angle) - 2
