Changeset 427

Timestamp:

08/25/09 14:31:39 (3 years ago)

Author:

pierre

Message:

Now all the tests are passed, more or less, with the Intervals. So backward compatibility is ensured :-)

Location:

branches/interval

Files:

• src/io.py (modified) (1 diff)
• src/signals/intervals.py (modified) (1 diff)
• src/signals/spikes.py (modified) (32 diffs)
• test/test_spikes.py (modified) (1 diff)

branches/interval/src/io.py

@@ -195 +195 @@
         p = self.__check_params(params)
         from NeuroTools.signals import spikes
-        return spikes.SpikeList(self.get_data(), p['id_list'], p['t_start'], p['t_stop'], p['dims'])
+        return spikes.SpikeList(self.get_data(), p['id_list'], t_start=p['t_start'], t_stop=p['t_stop'], dims=p['dims'])
 
     def read_analogs(self, type, params):

branches/interval/src/signals/intervals.py

@@ -102 +102 @@
         Return a copy of the SpikeTrain object
         """
-        return Interval(self.start_times, self.end_times, self.t_start, self.t_stop)
+        return Interval(self.sub_intervals)
 
     def offset_start(self, shift, from_stop=False, colapse=False) :

branches/interval/src/signals/spikes.py

@@ -25 +25 @@
 """
 
-import os, re, numpy
-import copy
-import logging
+import os, re, numpy, copy, logging
 from NeuroTools import check_dependency, check_numpy_version, analysis
 from NeuroTools.io import *
@@ -97 +95 @@
             raise ValueError("spikes time stamps should be *positive* *numbers*")
 
-        self.interval = self.extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
-        self.update_t_start_and_t_stop()
+        self.interval = self.create_intervals(t_start, t_stop, interval)
+        self.init_times()
         
         if not (self.t_start >= 0) and (self.t_stop >= 0) :
@@ -110 +108 @@
 
 
-    def extract_intervals_from_SpikeTrain_arguments(self, t_start=None, t_stop=None, interval=None) :
+    def create_intervals(self, t_start=None, t_stop=None, interval=None) :
         if interval is not None:
             # interval is fully defined by the user
-            if interval.__class__.__name__ == 'Interval' :
-                interval_out = interval
+            if type(interval) == Interval:
+                interval_out = interval.copy()
             else :
                 interval_out = Interval(interval) 
-        else: 
-            if t_start == None and t_stop == None :
+        else:
+            if t_start is None and t_stop is None :
                 try:
                     t_start = numpy.min(self.spike_times)
                 except Exception:
-                    print "Error in guessing t_start (first spike), spikes may be empty !"
+                    print "SpikeList error in guessing t_start (first spike), spikes may be empty !"
                     t_start = 0
                 try:
                     t_stop  = numpy.max(self.spike_times)
                 except Exception:
-                    print "Error in guessing t_stop (last spike), spikes may be empty !"
+                    print "SpikeList error in guessing t_stop (last spike), spikes may be empty !"
                     t_stop = t_start+0.1
                 interval_out = Interval([[t_start, t_stop]])
-            else :
-                if t_start == None :
+            elif t_start is None and t_stop is not None:
+                try:
+                    t_start  = numpy.min(self.spike_times)
+                except Exception:
+                    print "SpikeList error in guessing t_start (first spike), spikes may be empty !"
+                    t_start = 0
+                interval_out = Interval([[t_start, t_stop]])
+            elif t_start is not None and t_stop is not None:
+                interval_out = Interval([[t_start, t_stop]])
+            elif t_start is not None and t_stop is None:
+                if type(t_start) == float or type(t_start) == int:
                     try:
-                        t_start  = numpy.min(self.spike_times)
+                        t_stop  = numpy.max(self.spike_times)
                     except Exception:
-                        print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        t_start = 0
-                    interval_out = Interval([[t_start, t_stop]])
-                if t_stop == None :
-                    if t_start.__class__.__name__ == 'float' or t_start.__class__.__name__ == 'int' :
-                        try:
-                            t_stop  = numpy.max(self.spike_times)
-                        except Exception:
-                            print "Error in guessing t_stop (last spike), spikes may be empty !"
-                            t_stop = t_start+0.1
-                        interval_out = Interval([[t_start, t_stop]]) 
-                    else :
-                        if t_start.__class__.__name__ == 'Interval' :
-                            interval_out = t_start
-                        else :
-                            interval_out = Interval(t_start)
-                if not (t_start == None or t_stop == None) :
-                    interval_out = Interval([[t_start, t_stop]])
+                        print "SpikeList error in guessing t_stop (last spike), spikes may be empty !"
+                        t_stop = t_start+0.1
+                    interval_out = Interval([[t_start, t_stop]]) 
+                else :
+                    if type(t_start) == Interval:
+                        interval_out = t_start.copy()
+                    else :
+                        interval_out = Interval(t_start)
         return interval_out
 
@@ -173 +170 @@
         return (self.interval.t_start(), self.interval.t_stop())
 
-    def update_t_start_and_t_stop(self):
+    def init_times(self):
         """
         Update the t_start and t_stop constant to reflect the current t_start() and t_stop() methods
         """
         self.t_start = self.interval.t_start()
-        self.t_stop = self.interval.t_stop()
+        self.t_stop  = self.interval.t_stop()
     
     def is_equal(self, spktrain):
@@ -229 +226 @@
                                         spiketrain.spike_times)
         self.interval = self.interval.union(spiketrain.interval)
-        self.update_t_start_and_t_stop()
+        self.init_times()
 
     def format(self, relative=False, quantized=False):
@@ -304 +301 @@
                 34.2
         """
-        if not (t_start==None and t_stop==None and interval==None) :
-            rate_interval = self.extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
-            rate_interval = rate_interval.intersect(self.interval)
-            idx           = rate_interval.slice_times(self.spike_times)
-        else :
-            idx           = self.spike_times
-            rate_interval = self.interval
-
-        return 1000.*len(idx)/rate_interval.total_duration()
+        
+        interval = self.create_intervals(t_start, t_stop, interval)
+        
+        if interval.is_equal(self.interval):
+            idx      = self.spike_times
+        else:
+            interval = interval.intersect(self.interval)
+            idx      = interval.slice_times(self.spike_times)
+        return 1000.*len(idx)/interval.total_duration()
 
     def cv_isi(self, t_start=None, t_stop=None, interval=None):
@@ -416 +413 @@
         """
         if newnum:
-            axis = numpy.arange(self.interval.t_start(), self.interval.t_stop()+time_bin, time_bin)
-        else:
-            axis = numpy.arange(self.interval.t_start(), self.interval.t_stop(), time_bin)
+            axis = numpy.arange(self.t_start, self.t_stop+time_bin, time_bin)
+        else:
+            axis = numpy.arange(self.t_start, self.t_stop, time_bin)
         return axis
 
@@ -440 +437 @@
         """
         
-        raster_interval = extract_intervals_from_SpikeTrain_arguments(t_start, t_stop, interval)
+        raster_interval = self.create_intervals(t_start, t_stop, interval)
 
         if not raster_interval.is_equal(self.interval):
@@ -476 +473 @@
         self.interval.offset_full(offset)
         self.spike_times += offset
-        self.update_t_start_and_t_stop()
+        self.init_times()
 
 
@@ -496 +493 @@
         """
         interval = Interval((t_start, t_stop)) 
-        sliced = self.interval_slice(interval)
-        sliced.update_t_start_and_t_stop()
-        return sliced
+        return self.interval_slice(interval)
 
     def interval_slice(self, interval):
@@ -841 +836 @@
             break_points = numpy.concatenate((break_points, [N]))
 
-            # even if a spikeTrain is empty, add ID to the cell list
-            for id in id_list:
-                self.spiketrains[id] = SpikeTrain([])
             # if there are spikes corresponding to an ID, add it
             for idx in xrange(len(break_points)-1):
@@ -850 +842 @@
                     self.spiketrains[id] = SpikeTrain(spikes[break_points[idx]:break_points[idx+1], 1])
         
-        self.interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
+        self.interval = self.create_intervals(t_start, t_stop, interval)
         
         if len(self) > 0:
             for id in self.spiketrains.keys():
-                self.spiketrains[id].interval = self.interval
-                self.spiketrains[id].update_t_start_and_t_stop()
-
-        self.update_t_start_and_t_stop()
+                self.spiketrains[id] = self.spiketrains[id].interval_slice(self.interval)
+                self.spiketrains[id].init_times()
+        
+        self.init_times()
+        self.complete(id_list)
 
     def id_list(self):
@@ -868 +861 @@
                 [0,1,2,3,....,9999]
         """
-        return numpy.array(self.spiketrains.keys(), int)
+        return numpy.sort(numpy.array(self.spiketrains.keys(), int))
 
     def copy(self):
@@ -875 +868 @@
         """
 
-        spklist = SpikeList([], [], self.interval, self.dimensions)
+        spklist = SpikeList([], [], None, None, self.interval, self.dimensions)
         for id in self.id_list():
             spklist.append(float(id), self.spiketrains[float(id)])
         return spklist
 
-    def extract_intervals_from_SpikeList_arguments(self, t_start, t_stop, interval) : 
+    def create_intervals(self, t_start, t_stop, interval) : 
         if interval is not None:
             # interval is fully defined by the user
-            if interval.__class__.__name__ == 'Interval' :
-                interval_out = interval
+            if type(interval) == Interval:
+                interval_out = interval.copy()
             else :
                 interval_out = Interval(interval) 
         else: 
-            if t_start == None and t_stop == None :
+            if t_start is None and t_stop is None :
                 try:
-                    start_times = numpy.array([self.spiketrains[idx].t_start for idx in self.id_list()], numpy.float32)
-                    t_start     = numpy.min(start_times)
+                    start_times = numpy.array([self.spiketrains[idx].t_start for idx in self.id_list()])
+                    t_start     = numpy.min(start_times)
                     logging.debug("Warning, t_start is infered from the data : %f" %t_start)
                 except Exception:
-                    print "Error in guessing t_start (first spike), spikes may be empty !"
+                    print "SpikeList error in guessing t_start (first spike), spikes may be empty !"
                     t_start = 0
                 try:
-                    stop_times = numpy.array([self.spiketrains[idx].t_stop for idx in self.id_list()], numpy.float32)
+                    stop_times = numpy.array([self.spiketrains[idx].t_stop for idx in self.id_list()])
                     t_stop  = numpy.max(stop_times)
                     logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop)     
                 except Exception:
                     t_stop = t_start + 0.1
-                    print "Error in guessing t_stop (last spike), spikes may be empty !"
+                    print "SpikeList error in guessing t_stop (last spike), spikes may be empty !"
                 interval_out = Interval([[t_start, t_stop]])
-            else :
-                if t_start == None :
+            elif t_start is None and t_stop is not None:
+                try:
+                    start_times = numpy.array([self.spiketrains[idx].t_start for idx in self.id_list()])
+                    t_start = numpy.min(start_times)
+                    logging.debug("Warning, t_start is infered from the data : %f" %t_start)
+                except Exception:
+                    print "SpikeList error in guessing t_start (first spike), spikes may be empty !"
+                    t_start = 0
+                interval_out = Interval([[t_start, t_stop]])
+            elif t_start is not None and t_stop is not None:
+                interval_out = Interval([[t_start, t_stop]])
+            elif t_start is not None and t_stop is None:
+                if type(t_start) == float or type(t_start) == int :
                     try:
-                        start_times = numpy.array([self.spiketrains[idx].t_start for idx in self.id_list()], numpy.float32)
-                        t_start = numpy.min(start_times)
-                        logging.debug("Warning, t_start is infered from the data : %f" %t_start)
+                        stop_times = numpy.array([self.spiketrains[idx].t_stop for idx in self.id_list()])
+                        t_stop  = numpy.max(stop_times)
+                        logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop) 
                     except Exception:
-                        print "Error in guessing t_stop (last spike), spikes may be empty !"
-                        t_start = 0
-                    interval_out = Interval([[t_start, t_stop]])
-                if t_stop == None :
-                    if t_start.__class__.__name__ == 'float' or t_start.__class__.__name__ == 'int' :
-                        try:
-                            stop_times = numpy.array([self.spiketrains[idx].t_stop for idx in self.id_list()], numpy.float64)
-                            t_stop  = numpy.max(stop_times)
-                            logging.debug("Warning, t_stop  is infered from the data : %f" %t_stop)     
-                        except Exception:
-                            print "Error in guessing t_stop (last spike), spikes may be empty !"
-                            t_stop = t_start+0.1
-                        interval_out = Interval([[t_start, t_stop]]) 
+                        print "SpikeList error in guessing t_stop (last spike), spikes may be empty !"
+                        t_stop = t_start+0.1
+                    interval_out = Interval([[t_start, t_stop]]) 
+                else :
+                    if type(t_start) == Interval :
+                        interval_out = t_start.copy()
                     else :
-                        if t_start.__class__.__name__ == 'Interval' :
-                            interval_out = t_start
-                        else :
-                            interval_out = Interval(t_start)
-                if not (t_start == None or t_stop == None) :
-                    interval_out = Interval([[t_start, t_stop]])
+                        interval_out = Interval(t_start)
         return interval_out
 
 
     def __getitem__(self, id):
-        if id in self.id_list():
+        if self.spiketrains.has_key(id):
             return self.spiketrains[id]
         else:
@@ -1031 +1023 @@
         return (self.interval.t_start(), self.interval.t_stop())
 
-    def update_t_start_and_t_stop(self):
+    def init_times(self):
         """
         Update the t_start and t_stop constant to reflect the current t_start() and t_stop() methods
         """
         self.t_start = self.interval.t_start()
-        self.t_stop = self.interval.t_stop()
+        self.t_stop  = self.interval.t_stop()
 
     def time_axis(self, time_bin):
@@ -1076 +1068 @@
             for id in sl.id_list():
                 self.append(id, sl.spiketrains[id])
-        self.update_t_start_and_t_stop()
+        self.init_times()
 
 
@@ -1103 +1095 @@
                     spiketrain.relative_times()
                 self.append(id, spiketrain)
-        self.update_t_start_and_t_stop()
+        self.init_times()
                 
     
@@ -1147 +1139 @@
             time_slice, interval_slice
         """
-        new_SpkList = SpikeList([], [], self.interval, self.dimensions)
+        new_SpkList = SpikeList([], [], None, None, self.interval, self.dimensions)
         id_list = self.__sub_id_list(id_list)
         for id in id_list:
@@ -1168 +1160 @@
         """
         interval = Interval((t_start, t_stop))
-        sliced = self.interval_slice(interval)
-        sliced.update_t_start_and_t_stop()
+        sliced   = self.interval_slice(interval)
         return sliced
         
@@ -1184 +1175 @@
             id_slice, time_slice
         """
-        new_SpkList = SpikeList([], [], interval, self.dimensions)
+        new_SpkList = SpikeList([], [], None, None, interval, self.dimensions)
         for id in self.id_list():
             new_SpkList.append(id, self.spiketrains[id].interval_slice(interval))
@@ -1207 +1198 @@
         for id in self.id_list():
             self.spiketrains[id].time_offset(offset)
-        self.update_t_start_and_t_stop()
+        self.init_times()
 
     def id_offset(self, offset):
@@ -1409 +1400 @@
             
         """
-        ids = self.id_list()
-        N   = len(ids)
+        ids     = self.id_list()
+        N       = len(ids)
         cvs_isi = numpy.empty(N)
         for idx in xrange(N):
@@ -1543 +1534 @@
         
         Inputs:
+            t_start  - ??
+            t_stop   - ??
             interval - An interval object
         
@@ -1554 +1547 @@
             mean_rates, mean_rate_std
         """
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
-
-        return numpy.mean(self.mean_rates(interval))
+        return numpy.mean(self.mean_rates(t_start, t_stop, interval))
 
 
@@ -1576 +1567 @@
             mean_rate, mean_rates
         """
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
-        return numpy.std(self.mean_rates(interval))
+        return numpy.std(self.mean_rates(t_start, t_stop, interval))
 
 
@@ -1592 +1582 @@
             mean_rate, mean_rate_std
         """
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)
-        rates = []
+        interval = self.create_intervals(t_start, t_stop, interval)
+        rates    = []
         for id in self.id_list():
             rates.append(self.spiketrains[id].mean_rate(interval))
@@ -1819 +1809 @@
         subplot = get_display(display)
 
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)        
+        interval = self.create_intervals(t_start, t_stop, interval)
         if not interval.is_equal(self.interval):
             spklist = self.interval_slice(interval)
@@ -1840 +1830 @@
                 pylab.draw()
         elif isinstance(float_positions, numpy.ndarray):
-            if not len(spklist.id_list()) == len(fspike2loat_positions[0]):
+            if not len(spklist.id_list()) == len(float_positions[0]):
                 raise Exception("Error, the number of flotting positions does not match the number of cells in the SpikeList")
             rates = spklist.mean_rates()
@@ -2138 +2128 @@
             spk = self.id_slice(id_list)
 
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)   
+        interval = self.create_intervals(t_start, t_stop, interval)
         if not interval.is_equal(spk.interval):
             spk = spk.interval_slice(interval)
+        t_start, t_stop = spk.time_parameters()
 
         if not subplot or not HAVE_PYLAB:
@@ -2265 +2256 @@
         subplot = get_display(display)
 
-        interval = self.extract_intervals_from_SpikeList_arguments(t_start, t_stop, interval)   
+        interval = self.create_intervals(t_start, t_stop, interval)   
         if not subplot or not HAVE_PYLAB:
             print PYLAB_ERROR
@@ -2308 +2299 @@
                     files.append(fname)
                     t_start += time_bin
-                    count += 1          
-            command = "mencoder 'mf://_tmp_*.png' -mf type=png:fps=%d -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s" %(fps,output)
+                    count += 1
+            print "Please wait while movie is created..."
+            command = "mencoder 'mf://_tmp_*.png' -mf type=png:fps=%d -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o %s >> movie.log" %(fps,output)
             logging.debug(command)
             os.system(command)
@@ -2483 +2475 @@
     """
     spike_loader = DataHandler(user_file)
-    return spike_loader.load_spikes(id_list=id_list, t_start=None, t_stop=None, dims=dims)
+    return spike_loader.load_spikes(id_list=id_list, t_start=t_start, t_stop=t_stop, dims=dims)
 
 

branches/interval/test/test_spikes.py

@@ -282 +282 @@
     def testLastSpikeTime(self):
         assert self.spk.last_spike_time() <= self.spk.t_stop
-    
     
     def testSelect_Ids(self):