updates in analysis

Author: miladh

expipe/analysis/misc/pretty_plotting.py

@@ -1,6 +1,7 @@
 import matplotlib.pyplot as plt
 
-def set_grid(ax, bgcolor="#EAEAF2" , linecolor="w", linestyle="-", linewidth=1.3):
+
+def set_grid(ax, bgcolor="#EAEAF2", linecolor="w", linestyle="-", linewidth=1.3):
     """
     Set background color and grid line options
 
@@ -21,13 +22,13 @@ def set_grid(ax, bgcolor="#EAEAF2" , linecolor="w", linestyle="-", linewidth=1.3
     linewidth : float
         linewidth
     """
-    ax.set_axis_bgcolor(bgcolor)
+    ax.set_facecolor(bgcolor)
     ax.set_axisbelow("True")
-    ax.grid(True, color=linecolor, linestyle=linestyle, linewidth=linewidth, zorder = 0)
+    ax.grid(True, color=linecolor, linestyle=linestyle, linewidth=linewidth, zorder=0)
 
 
-def spines_edge_color(ax, edges = {"top": "none", "bottom": "w",
-                                  "right": "none", "left": "w"}):
+def spines_edge_color(ax, edges={"top": "none", "bottom": "w",
+                                 "right": "none", "left": "w"}):
     """
     Set spines edge color
 
@@ -71,7 +72,7 @@ def remove_ticklabels(ax, x_axis=True, y_axis=True):
         ax.set_yticklabels(empty_string_labels)
 
 
-def move_spines(ax, edges = {"bottom": 0, "left": 0}):
+def move_spines(ax, edges={"bottom": 0, "left": 0}):
     """
     Move spines
     Parameters
@@ -84,7 +85,8 @@ def move_spines(ax, edges = {"bottom": 0, "left": 0}):
     """
 
     for edge, value in edges.iteritems():
-        ax.spines[edge].set_position(('data',value))
+        ax.spines[edge].set_position(('data', value))
+
 
 def remove_ticks(ax):
     """
@@ -113,7 +115,7 @@ def set_font():
         'font.size': 14,
         'axes.titlesize': 18,
         'axes.labelsize': 16,
-        'lines.linewidth':2,
+        'lines.linewidth': 2,
     }
     plt.rcParams.update(params)
 
@@ -123,15 +125,15 @@ def set_legend():
     legend options
     """
     params = {
-        'legend.fontsize' : 'medium',
-        'legend.handlelength' : 2.2,
+        'legend.fontsize': 'medium',
+        'legend.handlelength': 2.2,
         'legend.frameon': False,
         'legend.numpoints': 1,
         'legend.scatterpoints': 1,
-        'legend.fontsize' : 14,
-        'legend.handlelength' : 2.2,
-        'legend.borderpad' : 0.0,
-        'legend.framealpha' : 2,
+        'legend.fontsize': 14,
+        'legend.handlelength': 2.2,
+        'legend.borderpad': 0.0,
+        'legend.framealpha': 2,
     }
     plt.rcParams.update(params)
 
@@ -166,9 +168,9 @@ def colormap(color=0):
 
 #########################################################################################
 if __name__ == "__main__":
-    import numpy as np
-
-    t = np.linspace(0,100,1000)
+    import numpy as np 
+    
+    t = np.linspace(0, 100, 1000)
     fig = plt.figure()
     ax = fig.add_subplot(111)
 

expipe/analysis/visual_stimulus/__init__.py

@@ -0,0 +1,2 @@
+from .plot import polar_tuning_curve
+from .tools import (average_rate)

expipe/analysis/visual_stimulus/plot.py

@@ -1,23 +1,44 @@
 import numpy as np
 import matplotlib.colors as colors
 import matplotlib.pyplot as plt
+import quantities as pq
+import seaborn
+
+
+def polar_tuning_curve(orients, rates, params={}):
+    """
+    Direction polar tuning curve 
+    """
+    import numpy as np    
+    import math
+    from expipe.analysis.misc import pretty_plotting
+    
+    assert len(orients) == len(rates)
+    
+    fig, ax = plt.subplots()  
+    ax = plt.subplot(111, projection='polar')
+    ax.plot(orients, rates, '-o', **params)
+
+    return fig, ax
+    
 
 def _gauss_function(x, y, A=1, a=0.63):
     r2 = x**2 + y**2
     return A / a**2 / np.pi * np.exp(-r2 / a**2)
-    
 
+    
 def _dog_function(x, y, A=1.0, a=0.63, B=0.85, b=1.23):
     center = _gauss_function(x, y, A, a)
     surround = _gauss_function(x, y, B, b)
     return center - surround
+
 
 def _doe_function(t, a=1, b=2):
     return np.exp(-t / a) / a**2 - np.exp(-t / b) / b**2
 
 
 def _field(x, y, t, A=1.0, a=0.63, B=0.85, b=1.23, c=1, d=2):
-    return _dog_function(x, y, A, a, B, b) * _doe_function (t, c, d)
+    return _dog_function(x, y, A, a, B, b) * _doe_function(t, c, d)
 
 
 class MidpointNormalize(colors.Normalize):
@@ -30,7 +51,6 @@ def __call__(self, value, clip=None):
         return np.ma.masked_array(np.interp(value, x, y))
 
 
-
 def rectangular_scalebar(ax, params={}): 
         '''
         Adds scalebar (rectangle) to an axes object with text
@@ -180,29 +200,6 @@ def plot_advance_receptive_field(field):
 
 
 
-def polar_tuning_curve(trails,
-                       params={}):
-    """
-    Direction polar tuning curve 
-    """
-    import numpy as np
-    import matplotlib.pyplot as plt
-    from expipe.analysis.visual_stimulus.tools import average_rate
-    from expipe.analysis.misc import pretty_plotting
-
-    
-    # TODO: average rate should give both radians and degrees 
-    av_rate, orients = average_rate(trails)
-    orients *= np.pi/180.
-    
-    fig, ax = plt.subplots()  
-    ax = plt.subplot(111, projection='polar')
-    ax.plot(orients, av_rate, '-ro', **params)
-    
-    pretty_plotting.set_grid(ax)
-    
-    return fig, ax
-
 
 
 

expipe/analysis/visual_stimulus/tools.py

@@ -13,7 +13,7 @@ def average_rate(trails):
 
     Returns
     -------
-    av_rate : array
+    avg_rate : array
         average rates
     orients : array
         sorted stimulus orientations
@@ -23,21 +23,22 @@ def average_rate(trails):
     spike_count_rate = collect.defaultdict(list)
 
     for trail in trails:
-        orient = float(trail.annotations.values()[0])
-        rate = mean_firing_rate(trail, trail.t_start, trail.t_stop )
+        orient = float(list(trail.annotations.values())[0])
+        rate = mean_firing_rate(trail, trail.t_start, trail.t_stop)
         spike_count_rate[orient].append(rate)
 
-    av_rate = np.zeros(len(spike_count_rate))
-    orients =  np.zeros(len(spike_count_rate))
+    avg_rate = np.zeros(len(spike_count_rate))
+    orients = np.zeros(len(spike_count_rate))
 
     for i, orient in enumerate(spike_count_rate):
-        av_rate[i] = np.mean(spike_count_rate[orient])
+        avg_rate[i] = np.mean(spike_count_rate[orient])
         orients[i] = orient
 
     sorted_indices = np.argsort(orients)
-    orients = orients[sorted_indices]*pq.deg
-    av_rate = av_rate[sorted_indices]*1./pq.s
-    return av_rate, orients
+    orients = orients[sorted_indices] * pq.deg
+    avg_rate = avg_rate[sorted_indices] * 1./pq.s
+    
+    return avg_rate, orients
 
 
 def wrap_angle(angle, wrap_range=360.):
@@ -55,7 +56,7 @@ def wrap_angle(angle, wrap_range=360.):
         angle in interval [0, wrap_range]
 
     '''
-    return angle - wrap_range * np.floor(angle/float(wrap_range));
+    return angle - wrap_range * np.floor(angle/float(wrap_range))
 
 
 def compute_selectivity_index(av_rates, orients, selectivity_type):
@@ -77,36 +78,34 @@ def compute_selectivity_index(av_rates, orients, selectivity_type):
     out : float
         selectivity index
     '''
-
-    preferred = np.where(av_rates==av_rates.max())
-    null_angle   = wrap_angle(orients[preferred] + 180*pq.deg, wrap_range=360.)
+    preferred = np.where(av_rates == av_rates.max())
+    null_angle = wrap_angle(orients[preferred] + 180*pq.deg, wrap_range=360.)
 
     null = np.where(orients == null_angle)
     if len(null[0]) == 0:
-        raise Exception("orientation not found: "+ str(null_angle))
+        raise Exception("orientation not found: "+str(null_angle))
 
-    if(selectivity_type=="dsi"):
-        index = 1.- av_rates[null] / av_rates[preferred]
+    if(selectivity_type == "dsi"):
+        index = 1. - av_rates[null] / av_rates[preferred]
         return orients[preferred], index
 
-    elif(selectivity_type=="osi"):
+    elif(selectivity_type == "osi"):
         orth_angle_p = wrap_angle(orients[preferred] + 90*pq.deg, wrap_range=360.)
         orth_angle_n = wrap_angle(orients[preferred] - 90*pq.deg, wrap_range=360.)
         orth_p = np.where(orients == orth_angle_p)
         orth_n = np.where(orients == orth_angle_n)
 
         if len(orth_p[0]) == 0:
-            raise Exception("orientation not found: "+ str(orth_angle_p))
+            raise Exception("orientation not found: " BaseException+str(orth_angle_p))
         if len(orth_n[0]) == 0:
-            raise Exception("orientation not found: "+ str(orth_angle_n))
+            raise Exception("orientation not found: " + str(orth_angle_n))
 
-        index = 1.- (av_rates[orth_p] + av_rates[orth_n]) / (av_rates[preferred]+av_rates[null])
+        index = 1. - (av_rates[orth_p] + av_rates[orth_n]) / (av_rates[preferred]+av_rates[null])
         return orients[preferred], index
 
     else:
         raise ValueError("unknown selectivity type: ", str(selectivity_type), " options: osi, dsi")
 
-        
 
 def make_stim_off_epoch_array(epo, include_boundary=True):
     '''
@@ -136,11 +135,3 @@ def make_stim_off_epoch_array(epo, include_boundary=True):
         durations = np.append(epo.times[0], durations)*pq.s
 
     return EpochArray(times=times, durations=durations, labels=[np.NAN]*len(times))
-
-
-if __name__ == "__main__":
-    compute_receptive_field()
-
-    
-    
-