Changeset 446

Timestamp:

04/12/10 15:37:12 (22 months ago)

Author:

apdavison

Message:

SpikeTrain.time_slice() now (again) accepts a sequence of t_start values and a sequence of t_stop values, if you wish to extract multiple slices.

Location:

trunk/src

Files:

• __init__.py (modified) (1 diff)
• facets/fkbtools.py (modified) (1 diff)
• io.py (modified) (1 diff)
• random.py (modified) (2 diffs)
• signals/spikes.py (modified) (6 diffs)
• stgen.py (modified) (1 diff)
• visualization/__init__.py (modified) (1 diff)

trunk/src/__init__.py

@@ -119 +119 @@
     import ll.ansistyle
     def colour(col, text):
-        return unicode(ll.ansistyle.Text(col, unicode(text)))
+        try:
+            return unicode(ll.ansistyle.Text(col, unicode(text)))
+        except UnicodeDecodeError, e:
+            raise UnicodeDecodeError("%s. text was %s" % (e, text))
 except ImportError:
     def colour(col, text):

trunk/src/facets/fkbtools.py

@@ -19 +19 @@
 if check_dependency('srblib'):
     import srblib
+else:
+    import urllib as srblib
 
 import os, sys, zipfile, tempfile, shutil, subprocess, logging, time, numpy

trunk/src/io.py

@@ -393 +393 @@
 
 
+class PyNNNumpyBinaryFile(FileHandler):
+    
+    def __init__(self, filename):
+        FileHandler.__init__(self, filename)
+        self.fileobj = open(self.filename, 'r')
+        
+    def read_spikes(self, params):
+        from NeuroTools.signals import spikes
+        contents = numpy.load(self.fileobj)
+        spike_data = contents['data'][:, (1,0)]
+        self.metadata = M = {}
+        for k,v in contents['metadata']:
+            M[k] = eval(v)
+        id_list = range(M['first_id'], M['last_id'])
+        t_stop = params['t_stop']
+        # really need to check the agreement between file metadata and
+        # params for all metadata items
+        return spikes.SpikeList(spike_data, id_list, t_start=0.0, t_stop=t_stop,
+                                dims=M['dimensions'])
+        
+    #def read_analogs(self, type, params):
+    #    contents = numpy.load(self.fileobj)
+    #    values, ids = contents['data'].T # need to check the shape first
+    
+
 
 class DataHandler(object):

trunk/src/random.py

@@ -20 +20 @@
 
 have_scipy = check_dependency('scipy')
-if have_scipy:
-    import scipy.stats
 
     
@@ -95 +93 @@
         self.dist_name = 'GammaDist'
 
-    if have_scipy:    
+    if have_scipy:
+        import scipy.stats
         def next(self,n=1):
             return scipy.stats.gamma.rvs(self.params['a'],size=n)*self.params['b']

trunk/src/signals/spikes.py

@@ -186 +186 @@
     
     
-    def merge(self, spiketrain):
+    def merge(self, spiketrain, relative=False):
         """
         Add the spike times from a spiketrain to the current SpikeTrain
@@ -192 +192 @@
         Inputs:
             spiketrain - The SpikeTrain that should be added
+            relative - if True, relative_times() is called on both spiketrains before merging
         
         Examples:
@@ -204 +205 @@
                 500
         """
+        if relative:
+            self.relative_times()
+            spiketrain.relative_times()
         self.spike_times = numpy.insert(self.spike_times, self.spike_times.searchsorted(spiketrain.spike_times), \
                                         spiketrain.spike_times)
@@ -464 +468 @@
     def time_slice(self, t_start, t_stop):
         """ 
-        Return a new SpikeTrain obtained by slicing between t_start and t_stop. The new 
-        t_start and t_stop values of the returned SpikeTrain are the one given as arguments
+        Return a new SpikeTrain obtained by slicing between t_start and t_stop,
+        where t_start and t_stop may either be single values or sequences of
+        start and stop times.
         
         Inputs:
@@ -477 +482 @@
             >> spk.t_stop
                 100
-        """
-        spikes = numpy.extract((self.spike_times >= t_start) & (self.spike_times <= t_stop), self.spike_times)
+            >>> spk = spktrain.time_slice([20,70], [40,90])
+            >>> spk.t_start
+                20
+            >>> spk.t_stop
+                90
+            >>> len(spk.time_slice(41, 69))
+                0
+        """
+        if hasattr(t_start, '__len__'):
+            if len(t_start) != len(t_stop):
+                raise ValueError("t_start has %d values and t_stop %d. They must be of the same length." % (len(t_start), len(t_stop)))
+            mask = False
+            for t0,t1 in zip(t_start, t_stop):
+                mask = mask | ((self.spike_times >= t0) & (self.spike_times <= t1))
+            t_start = t_start[0]
+            t_stop = t_stop[-1]
+        else:
+            mask = (self.spike_times >= t_start) & (self.spike_times <= t_stop)
+        spikes = numpy.extract(mask, self.spike_times)
         return SpikeTrain(spikes, t_start, t_stop)
 
@@ -536 +558 @@
         
         Note that the SpikeTrain object itself is modified, t_start 
-        is substracted to spike_times, t_start and t_stop
+        is subtracted from spike_times, t_start and t_stop
         """
         if self.t_start != 0:

trunk/src/stgen.py

@@ -243 +243 @@
     def inh_poisson_generator(self, rate, t, t_stop, array=False):
         """
-        Returns a SpikeList whose spikes are a realization of an inhomogeneous 
+        Returns a SpikeTrain whose spikes are a realization of an inhomogeneous 
         poisson process (dynamic rate). The implementation uses the thinning 
         method, as presented in the references.

trunk/src/visualization/__init__.py

@@ -143 +143 @@
         h,w = spk.dimensions
         id_offset = min(spk.id_list())
+        xarr,yarr = spk.id2position(self.spikelist.id_list() - id_offset)
         while (self.i < self.max_i) and (self.time[self.i] < self.t_start + self.frame_duration):
-            xy = spk.id2position(self.ids[self.i] - id_offset) 
-            activity_map[xy2ij(xy, h)] += 1
+            id = self.ids[self.i] - id_offset
+            x = xarr[id]
+            y = yarr[id]
+            #xy = spk.id2position(self.ids[self.i] - id_offset)
+            #assert xy == (x,y), "%s != %s" % (xy, str((x,y)))
+            activity_map[xy2ij((x,y), h)] += 1
             self.i += 1
         self.t_start += self.frame_duration