Changeset 436 for trunk

Timestamp:

09/25/09 14:02:04 (3 years ago)

Author:

apdavison

Message:

Modified the mapping of cell id to image position for plotting activity maps/movies.

Location:

trunk/src

Files:

• io.py (modified) (1 diff)
• signals/spikes.py (modified) (8 diffs)
• visualization/__init__.py (modified) (3 diffs)

trunk/src/io.py

@@ -147 +147 @@
         if not ('id_list' in params) or (params['id_list'] is None):
             if ('first_id' in self.metadata) and ('last_id' in self.metadata):
-                logging.debug("id_list is infered from the file header")
                 params['id_list'] = range(int(self.metadata['first_id']), int(self.metadata['last_id'])+1)
+                logging.debug("id_list (%d...%d) is infered from the file header" % (int(self.metadata['first_id']), int(self.metadata['last_id'])+1))
             else:
                 raise Exception("id_list can not be infered while reading %s" %self.filename)

trunk/src/signals/spikes.py

@@ -1663 +1663 @@
 
     
-    def id2position(self, id):
+    def id2position(self, id, offset=0):
         """
         Return a position (x,y) from an id if the cells are aranged on a
-        grid of size dims, as defined in the dims attribute of the SpikeList object
+        grid of size dims, as defined in the dims attribute of the SpikeList object.
+        This assumes that cells are ordered from left to right, top to bottom,
+        and that dims specifies (height, width), i.e. if dims = (10,12), this is
+        an array with 10 rows and 12 columns, and hence has width 12 units and
+        height 10 units.
         
         Inputs:
@@ -1672 +1676 @@
         
         The 'dimensions' attribute of the SpikeList must be defined
-        
-        Examples:
-            >> spklist.id2position(2536)
-                (25, 35)
         
         See also
@@ -1683 +1683 @@
             raise Exception("Dimensions of the population are not defined ! Set spikelist.dimensions")
         if len(self.dimensions) == 1:
-            return id
+            return id-offset
         if len(self.dimensions) == 2:
-            x = id % self.dimensions[0]
-            y = numpy.floor(id/self.dimensions[0])
+            x = (id-offset) % self.dimensions[1]
+            y = self.dimensions[0] - 1 - int(numpy.floor((id-offset)/self.dimensions[1]))
             return (x,y)
 
 
-    def position2id(self, position):
+    def position2id(self, position, offset=0):
         """
         Return the id of the cell at position (x,y) if the cells are aranged on a
@@ -1701 +1701 @@
         as the position argument
         
-        Examples:
-            >> spklist.position2id((25,35))
-                2536
-        
         See also
             activity_map, activity_movie, id2position
@@ -1710 +1706 @@
         if self.dimensions is None:
             raise Exception("Dimensions of the population are not defined ! Set spikelist.dimensions")
-        assert array(position).shape == self.dimensions.shape, "position does not have the correct shape !"
+        assert len(position) == len(tuple(self.dimensions)), "position does not have the correct shape !"
         if len(self.dimensions) == 1:
-            return position
+            return position+offset
         if len(self.dimensions) == 2:
-            return position[0]*self.dimensions[0] + position[1]
+            return (self.dimensions[0] - 1 - position[1])*self.dimensions[1] + position[0] + offset
 
 
@@ -1728 +1724 @@
             float_positions - None by default, meaning that the dimensions attribute 
                               of the SpikeList is used to arange the ids on a 2D grid. 
-                              Otherwise, if the cells have flotting positions, 
+                              Otherwise, if the cells have floating positions, 
                               float_positions should be an array of size
                               (2, nb_cells) with the x (first line) and y (second line) 
@@ -1763 +1759 @@
             activity_map = numpy.zeros(self.dimensions, float)
             rates        = spklist.mean_rates()
+            id_offset = min(self.id_list())
             for count, id in enumerate(spklist.id_list()):
-                position = spklist.id2position(id)
-                activity_map[position] = rates[count]
+                x,y = spklist.id2position(id, id_offset)
+                j,i = x, self.dimensions[0] - 1 -y
+                activity_map[i,j] = rates[count]
             if not subplot or not HAVE_PYLAB or not HAVE_MATPLOTLIB:
                 return activity_map
@@ -2229 +2227 @@
                 while (t_start < t_stop):
                     activity_map = numpy.zeros(spk.dimensions)
-                    while ((time[idx] < t_start + time_bin) and (idx < max_idx)):
-                        addr = spk.id2position(pos[idx])
-                        activity_map[addr] += 1
+                    while ((time[idx] < t_start + time_bin) and (idx < max_idx)):                        
+                        x,y = spk.id2position(pos[idx])
+                        j,i = x, self.dimensions[0] - 1 -y
+                        activity_map[i,j] += 1
                         idx += 1
                     im.set_array(activity_map)

trunk/src/visualization/__init__.py

@@ -103 +103 @@
         return self.t, numpy.sin(self.t + self.phase)
 
-def xy2ij(coordinates):
+def xy2ij(coordinates, height):
     """
     Generally, we use (x,y) coordinates, but since arrays use matrix coordinates,
@@ -109 +109 @@
     """
     assert len(coordinates) == 2
-    return (coordinates[1], coordinates[0])
+    x,y = coordinates
+    j = x
+    i = height - 1 - y
+    return (i,j)
 
 class ActivityMap(object):
@@ -122 +125 @@
             raise Exception("Dimensions of the population are not defined ! Set spikelist.dims")
         
-        self.time, self.pos = self.spikelist.convert("times, ids")
+        self.time, self.ids = self.spikelist.convert("times, ids")
         # We sort the spikes to allow faster process later
         sort_idx = self.time.ravel().argsort(kind="quicksort")
         self.time = self.time[sort_idx]
-        self.pos = self.pos[sort_idx]
-        self.idx = 0
-        self.max_idx = len(self.time)-1
+        self.ids = self.ids[sort_idx]
+        self.i = 0
+        self.max_i = len(self.time)-1
         self.t_start = 0
         
     def next_frame(self):
         spk = self.spikelist
-        activity_map = numpy.zeros(xy2ij(spk.dimensions))
-        
-        while ((self.idx < self.max_idx) and (self.time[self.idx] < self.t_start + self.frame_duration)):
-            addr = spk.id2position(self.pos[self.idx])
-            activity_map[xy2ij(addr)] += 1
-            self.idx += 1
+        activity_map = numpy.zeros(spk.dimensions)
+        h,w = spk.dimensions
+        id_offset = min(spk.id_list())
+        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
+            self.i += 1
         self.t_start += self.frame_duration
-        #logging.debug("next_frame: idx=%d, t_start=%g, max_idx=%d, time[idx]=%g" % (self.idx, self.t_start, self.max_idx, self.time[self.idx]))
+        #logging.debug("next_frame: i=%d, t_start=%g, max_i=%d, time[i]=%g" % (self.i, self.t_start, self.max_i, self.time[self.i]))
         activity_map *= 1000.0/self.frame_duration # convert to spikes/second    
         return [activity_map]