def plot_deceleration_for_flybys(dataset):
    fig = plt.figure()
    ax = fig.add_subplot(111)
    
    fig_saccade_flyby = plt.figure()
    ax_saccade_flyby = fig_saccade_flyby.add_subplot(111)
    
    for k, trajec in dataset.trajecs.items():
        fd, fs = get_frame_of_decel_and_last_saccade(trajec)
        if np.abs(trajec.angle_to_post[fd]) < 180.*np.pi/180.:
            
            if 0:#fs is not None:
                
                if trajec.angle_subtended_by_post[fs] > 20*np.pi/180.:
                
                    if fs > fd:
                        ax.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='green')
                        #ax.plot(np.log(trajec.angle_subtended_by_post[fs]), trajec.speed[fs], '.', color='green')
                        #ax.plot([np.log(trajec.angle_subtended_by_post[fd]), np.log(trajec.angle_subtended_by_post[fs])], [trajec.speed[fd], trajec.speed[fs]], '-', color='black')
                        sac_range = get_saccade_range_from_first_frame(trajec, fs)
                        angle = sac.get_angle_of_saccade(trajec, sac_range)
                        ax_saccade_flyby.plot(trajec.angle_to_post[fs], angle, '.', color='green')
                    else:
                        print trajec.key # saccade before deceleration
                        ax.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='red')
                        sac_range = get_saccade_range_from_first_frame(trajec, fs)
                        angle = sac.get_angle_of_saccade(trajec, sac_range)
                        ax_saccade_flyby.plot(trajec.angle_to_post[fs], angle, '.', color='red')
                    
            if fs is not None:
                if np.abs(fs-fd) > 10 and np.abs(trajec.angle_to_post[fd]) < 60.*np.pi/180.:
                    ax.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
                    
            
            
        
        # try looking for trajectories that slowed down after saccading?
    
    set_log_angle_ticks(ax)
    fig.savefig('deceleration_for_flybys.pdf', format='pdf') 
    
    fpl.adjust_spines(ax_saccade_flyby, ['left', 'bottom'], yticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], xticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], smart_bounds=True)
    
    ax_saccade_flyby.set_xlim([-np.pi, np.pi])
    ax_saccade_flyby.set_ylim([-np.pi, np.pi])
    
    fig_saccade_flyby.savefig('last_saccade_of_flyby.pdf', format='pdf')
def heatmap_of_straight_landing_trajecs(dataset_landing, dataset_flyby):

    speeds = []
    angles_subtended = []
    for k, trajec in dataset_landing.trajecs.items():
        if trajec.classification == 'no_saccade_after_deceleration':
            speeds.extend(trajec.speed[0:trajec.frame_of_landing].tolist())
            angles_subtended.extend(trajec.angle_subtended_by_post[0:trajec.frame_of_landing].tolist())
        
    fig = plt.figure()
    ax = fig.add_subplot(111)
    
    fpl.histogram2d(ax, np.log(np.array(angles_subtended)), np.array(speeds), bins=50, normed=False, histrange=None, weights=None, logcolorscale=True, colormap='jet', interpolation='bicubic')
    
    fig_saccades_flyby = plt.figure()
    ax_saccades_flyby = fig_saccades_flyby.add_subplot(111)
    
    
    # now look at speed and retinal size for flyby trajectories at last saccade if headed towards post:
    for k, trajec in dataset_flyby.trajecs.items():
        fd, fs = get_frame_of_decel_and_last_saccade(trajec)
        for sac_range in trajec.sac_ranges:
            if fs in sac_range:
                if trajec.angle_subtended_by_post[sac_range[0]] > 0.*np.pi/180.:
                    
                #if np.abs(trajec.angle_to_post[sac_range[0]]) < 180.*np.pi/180.:
                    ax.plot(np.log(trajec.angle_subtended_by_post[sac_range[0]]), trajec.speed[sac_range[0]], '.', markersize=2, color='white', markeredgecolor='black', linewidth=0.5)

                    angle = sac.get_angle_of_saccade(trajec, sac_range)
                    ax_saccades_flyby.plot(-1*trajec.angle_to_post[sac_range[0]], angle, '.', color='red', markersize=2)

    set_log_angle_ticks(ax)
    ax.set_aspect('auto')
        
    fig.savefig('landing_deceleration_heatmap.pdf')
        
    fpl.adjust_spines(ax_saccades_flyby, ['left', 'bottom'], yticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], xticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], smart_bounds=True)
    ax_saccades_flyby.set_xlim([-np.pi, np.pi])
    ax_saccades_flyby.set_ylim([-np.pi, np.pi])
    
    deg_ticks = ['-180', '-90', '0', '90', '180']
    ax_saccades_flyby.set_xticklabels(deg_ticks)
    ax_saccades_flyby.set_yticklabels(deg_ticks)
    
    ax_saccades_flyby.set_xlabel('Angle to post, deg')
    ax_saccades_flyby.set_ylabel('Turn angle, deg')
    
    fig_saccades_flyby.savefig('saccades_flyby.pdf', format='pdf')
def print_frame_diff_btwn_decel_and_saccade(dataset):
    
    neg = 0
    pos = 0
    none = 0
    
    fig_neg = plt.figure()
    ax_neg = fig_neg.add_subplot(111)
    
    fig_pos = plt.figure()
    ax_pos = fig_pos.add_subplot(111)
    
    fig_none = plt.figure()
    ax_none = fig_none.add_subplot(111)
    
    fig_saccades = plt.figure()
    ax_saccades = fig_saccades.add_subplot(111)
    
    fig_deceleration = plt.figure()
    ax_deceleration = fig_deceleration.add_subplot(111)
        
    for k, trajec in dataset.trajecs.items():
        fd, fs = get_frame_of_decel_and_last_saccade(trajec)
        pos_frame_minus_landing = []
        
        if trajec.classification == 'straight':
            none += 1
            ax_none.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
            ax_deceleration.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
        else:
            try:
                difference = fd - fs
                if difference < 0:
                    neg += 1
                    ax_neg.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
                    ax_neg.plot(np.log(trajec.angle_subtended_by_post[fs]), trajec.speed[fs], '.', color='green')
                    ax_neg.plot([np.log(trajec.angle_subtended_by_post[fd]), np.log(trajec.angle_subtended_by_post[fs])], [trajec.speed[fd], trajec.speed[fs]], '-', color='black')
                    ax_deceleration.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='red')
                    
                    sac_range = get_saccade_range_from_first_frame(trajec, fs)
                    angle = sac.get_angle_of_saccade(trajec, sac_range)
                    print trajec.angle_to_post, angle
                    ax_saccades.plot(trajec.angle_to_post[fs], angle, '.')
                    print trajec.angle_to_post, angle
                    
                elif difference > 0:
                    pos += 1
                    pos_frame_minus_landing.append(trajec.frame_of_landing - fs)
                    ax_pos.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
                    ax_pos.plot(np.log(trajec.angle_subtended_by_post[fs]), trajec.speed[fs], '.', color='green')
                    #ax_pos.plot([np.log(trajec.angle_subtended_by_post[fd]), np.log(trajec.angle_subtended_by_post[fs])], [trajec.speed[fd], trajec.speed[fs]], '-', color='black')
                    ax_pos.plot(np.log(trajec.angle_subtended_by_post[0:trajec.frame_of_landing]), trajec.speed[0:trajec.frame_of_landing], '-', color='black', linewidth=0.5)
                    ax_deceleration.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='green')
            except:
                none += 1
                ax_none.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
                ax_deceleration.plot(np.log(trajec.angle_subtended_by_post[fd]), trajec.speed[fd], '.', color='purple')
            
            
    yticks = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
    xticks = np.log(np.array([10, 20, 30, 60, 90, 180])*np.pi/180.).tolist()
    
    set_log_angle_ticks(ax_neg)
    set_log_angle_ticks(ax_pos)
    set_log_angle_ticks(ax_none)
    set_log_angle_ticks(ax_deceleration)
            
    fpl.adjust_spines(ax_saccades, ['left', 'bottom'], yticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], xticks=[-np.pi, -np.pi/2., 0, np.pi/2., np.pi], smart_bounds=True)
            
    fig_neg.savefig('decel_and_saccade_neg.pdf', format='pdf')
    fig_pos.savefig('decel_and_saccade_pos.pdf', format='pdf')    
    fig_none.savefig('decel_and_saccade_none.pdf', format='pdf')   
    fig_deceleration.savefig('decel_for_all.pdf', format='pdf')    
    fig_saccades.savefig('saccade_for_saccade_after_deceleration.pdf', format='pdf')
    
    
    print 'neg: ', neg, 'pos: ', pos, 'none: ', none
    print pos_frame_minus_landing
def collect_saccade_data(dataset, behavior=['landing', 'flyby'], last_saccade_only=True, min_angle=0):
    if type(behavior) is not list:
        behavior = [behavior]
    
    saccades = floris_misc.Object()
    saccades.keys = []
    saccades.angle_to_post = []
    saccades.angle_to_post_after_turn = []
    saccades.turn_angle = []
    saccades.true_turn_angle = []
    saccades.angle_subtended_by_post = []
    saccades.distance_to_post = []
    saccades.speed = []
    saccades.expansion = []
    saccades.angular_velocity = []
    saccades.xvelocity = []
    saccades.post_type = []
    
    if last_saccade_only:
        for k, trajec in dataset.trajecs.iteritems():
            if trajec.behavior in behavior:
                if len(trajec.last_saccade_range) > 0: 
                    sac_range = trajec.last_saccade_range
                    angle_subtended = trajec.angle_subtended_by_post[sac_range[0]]
                    if angle_subtended > min_angle*np.pi/180.:
                        angle_of_saccade = sac.get_angle_of_saccade(trajec, sac_range, method='integral')
                        saccades.keys.append(k)
                        saccades.angle_to_post.append(trajec.angle_to_post[sac_range[0]])
                        saccades.angle_to_post_after_turn.append(trajec.angle_to_post[sac_range[-1]])
                        saccades.xvelocity.append(trajec.velocities[sac_range[0],0])
                        saccades.true_turn_angle.append(angle_of_saccade)
                        
                        saccades.turn_angle.append(trajec.angle_to_post[sac_range[0]] - trajec.angle_to_post[sac_range[-1]])
                        
                        saccades.angle_subtended_by_post.append(trajec.angle_subtended_by_post[sac_range[0]])
                        saccades.distance_to_post.append(trajec.dist_to_stim_r_normed[sac_range[0]])
                        saccades.speed.append(trajec.speed[sac_range[0]])
                        saccades.expansion.append(trajec.expansion[sac_range[0]])
                        
                        saccades.angular_velocity.append( saccades.true_turn_angle[-1] / (float(len(sac_range))/trajec.fps) )
                        
                        if 'black' in trajec.post_type:
                            saccades.post_type.append( 1 )
                        elif 'checkered' in trajec.post_type:
                            saccades.post_type.append( 0 )
    else:
        print 'calculating for all saccades prior to nearest approach to post'
        for k, trajec in dataset.trajecs.iteritems():
            if trajec.behavior in behavior:
                if len(trajec.sac_ranges) > 0:
                    for sac_range in trajec.sac_ranges: 
                        if sac_range[0] < trajec.frame_nearest_to_post:
                            angle_subtended = trajec.angle_subtended_by_post[sac_range[0]]
                            if angle_subtended > min_angle*np.pi/180.:
                                angle_of_saccade = sac.get_angle_of_saccade(trajec, sac_range)
                                saccades.keys.append(k)
                                saccades.angle_to_post.append(trajec.angle_to_post[sac_range[0]])
                                saccades.angle_to_post_after_turn.append(trajec.angle_to_post[sac_range[-1]])
                                
                                saccades.true_turn_angle.append(angle_of_saccade)
                                
                                saccades.turn_angle.append(trajec.angle_to_post[sac_range[0]] - trajec.angle_to_post[sac_range[-1]])
                                
                                saccades.angle_subtended_by_post.append(trajec.angle_subtended_by_post[sac_range[0]])
                                saccades.distance_to_post.append(trajec.dist_to_stim_r_normed[sac_range[0]])
                                saccades.speed.append(trajec.speed[sac_range[0]])
                                saccades.expansion.append(trajec.expansion[sac_range[0]])
                                
                                saccades.angular_velocity.append( saccades.true_turn_angle[-1] / (float(len(sac_range))/trajec.fps) )

    saccades.angle_to_post = np.array(saccades.angle_to_post)
    saccades.angle_to_post_after_turn = np.array(saccades.angle_to_post_after_turn) 
    saccades.turn_angle = np.array(saccades.turn_angle)
    saccades.true_turn_angle = np.array(saccades.true_turn_angle)
    saccades.angle_subtended_by_post = np.array(saccades.angle_subtended_by_post) 
    saccades.distance_to_post = np.array(saccades.distance_to_post) 
    saccades.speed = np.array(saccades.speed)
    saccades.expansion = np.array(saccades.expansion)
    saccades.angular_velocity = np.array(saccades.angular_velocity)
    saccades.xvelocity = np.array(saccades.xvelocity)
    
    saccades.angle_to_far_edge = saccades.angle_to_post + np.sign(saccades.angle_to_post)*saccades.angle_subtended_by_post/2.
    saccades.angle_to_near_edge = saccades.angle_to_post - np.sign(saccades.angle_to_post)*saccades.angle_subtended_by_post/2.
    saccades.post_type = np.array(saccades.post_type)
    
    dataset.saccades = saccades
def collect_saccade_data(dataset,
                         behavior=['landing', 'flyby'],
                         last_saccade_only=True,
                         min_angle=0):
    if type(behavior) is not list:
        behavior = [behavior]

    saccades = floris_misc.Object()
    saccades.keys = []
    saccades.angle_to_post = []
    saccades.angle_to_post_after_turn = []
    saccades.turn_angle = []
    saccades.true_turn_angle = []
    saccades.angle_subtended_by_post = []
    saccades.distance_to_post = []
    saccades.speed = []
    saccades.expansion = []
    saccades.angular_velocity = []
    saccades.xvelocity = []
    saccades.post_type = []

    if last_saccade_only:
        for k, trajec in dataset.trajecs.iteritems():
            if trajec.behavior in behavior:
                if len(trajec.last_saccade_range) > 0:
                    sac_range = trajec.last_saccade_range
                    angle_subtended = trajec.angle_subtended_by_post[
                        sac_range[0]]
                    if angle_subtended > min_angle * np.pi / 180.:
                        angle_of_saccade = sac.get_angle_of_saccade(
                            trajec, sac_range, method='integral')
                        saccades.keys.append(k)
                        saccades.angle_to_post.append(
                            trajec.angle_to_post[sac_range[0]])
                        saccades.angle_to_post_after_turn.append(
                            trajec.angle_to_post[sac_range[-1]])
                        saccades.xvelocity.append(
                            trajec.velocities[sac_range[0], 0])
                        saccades.true_turn_angle.append(angle_of_saccade)

                        saccades.turn_angle.append(
                            trajec.angle_to_post[sac_range[0]] -
                            trajec.angle_to_post[sac_range[-1]])

                        saccades.angle_subtended_by_post.append(
                            trajec.angle_subtended_by_post[sac_range[0]])
                        saccades.distance_to_post.append(
                            trajec.dist_to_stim_r_normed[sac_range[0]])
                        saccades.speed.append(trajec.speed[sac_range[0]])
                        saccades.expansion.append(
                            trajec.expansion[sac_range[0]])

                        saccades.angular_velocity.append(
                            saccades.true_turn_angle[-1] /
                            (float(len(sac_range)) / trajec.fps))

                        if 'black' in trajec.post_type:
                            saccades.post_type.append(1)
                        elif 'checkered' in trajec.post_type:
                            saccades.post_type.append(0)
    else:
        print 'calculating for all saccades prior to nearest approach to post'
        for k, trajec in dataset.trajecs.iteritems():
            if trajec.behavior in behavior:
                if len(trajec.sac_ranges) > 0:
                    for sac_range in trajec.sac_ranges:
                        if sac_range[0] < trajec.frame_nearest_to_post:
                            angle_subtended = trajec.angle_subtended_by_post[
                                sac_range[0]]
                            if angle_subtended > min_angle * np.pi / 180.:
                                angle_of_saccade = sac.get_angle_of_saccade(
                                    trajec, sac_range)
                                saccades.keys.append(k)
                                saccades.angle_to_post.append(
                                    trajec.angle_to_post[sac_range[0]])
                                saccades.angle_to_post_after_turn.append(
                                    trajec.angle_to_post[sac_range[-1]])

                                saccades.true_turn_angle.append(
                                    angle_of_saccade)

                                saccades.turn_angle.append(
                                    trajec.angle_to_post[sac_range[0]] -
                                    trajec.angle_to_post[sac_range[-1]])

                                saccades.angle_subtended_by_post.append(
                                    trajec.angle_subtended_by_post[
                                        sac_range[0]])
                                saccades.distance_to_post.append(
                                    trajec.dist_to_stim_r_normed[sac_range[0]])
                                saccades.speed.append(
                                    trajec.speed[sac_range[0]])
                                saccades.expansion.append(
                                    trajec.expansion[sac_range[0]])

                                saccades.angular_velocity.append(
                                    saccades.true_turn_angle[-1] /
                                    (float(len(sac_range)) / trajec.fps))

    saccades.angle_to_post = np.array(saccades.angle_to_post)
    saccades.angle_to_post_after_turn = np.array(
        saccades.angle_to_post_after_turn)
    saccades.turn_angle = np.array(saccades.turn_angle)
    saccades.true_turn_angle = np.array(saccades.true_turn_angle)
    saccades.angle_subtended_by_post = np.array(
        saccades.angle_subtended_by_post)
    saccades.distance_to_post = np.array(saccades.distance_to_post)
    saccades.speed = np.array(saccades.speed)
    saccades.expansion = np.array(saccades.expansion)
    saccades.angular_velocity = np.array(saccades.angular_velocity)
    saccades.xvelocity = np.array(saccades.xvelocity)

    saccades.angle_to_far_edge = saccades.angle_to_post + np.sign(
        saccades.angle_to_post) * saccades.angle_subtended_by_post / 2.
    saccades.angle_to_near_edge = saccades.angle_to_post - np.sign(
        saccades.angle_to_post) * saccades.angle_subtended_by_post / 2.
    saccades.post_type = np.array(saccades.post_type)

    dataset.saccades = saccades