Changeset 398 for trunk

Timestamp:

06/15/09 20:56:42 (3 years ago)

Author:

pierre

Message:

Add a DistanceDependentPairs? selector, to allow precise selection of cells when SpikeList are arranged on a grid

Files:

• trunk/src/signals/pairs.py (modified) (7 diffs)

trunk/src/signals/pairs.py

@@ -1 +1 @@
 import numpy
+
+
+# Function to calculate the euclidian distance between two positions
+# For the moment, we suppose the cells to be located in the same grid
+# of size NxN. Should then include a scaling parameter to allow
+# distances between distincts populations ?
+def distance(pos_1, pos_2, N):
+    # Since we deal with a toroidal space, we have to take the min distance
+    # on the torus.
+    dx = numpy.minimum(abs(pos_1[0]-pos_2[0]), N-(abs(pos_1[0]-pos_2[0])))
+    dy = numpy.minimum(abs(pos_1[1]-pos_2[1]), N-(abs(pos_1[1]-pos_2[1])))
+    return numpy.sqrt(dx*dx + dy*dy)
+
+
+
 
 class PairsGenerator(object):
@@ -18 +33 @@
         >> p.get_pairs(100)
     
-    See also AutoPairs, RandomPairs, CustomPairs
+    See also AutoPairs, RandomPairs, CustomPairs, DistantDependentPairs
     """
     def __init__(self, spk1, spk2, no_silent=False):
@@ -66 +81 @@
             [[1,1],[2,2],[4,4],[5,5]]
     
-    See also RandomPairs, CustomPairs
+    See also RandomPairs, CustomPairs, DistantDependentPairs
     """
     
@@ -109 +124 @@
         
         
-    See also RandomPairs, CustomPairs
+    See also RandomPairs, CustomPairs, DistantDependentPairs
     """
     def __init__(self, spk1, spk2, no_silent=False, no_auto=True):
@@ -116 +131 @@
     
     def get_pairs(self, nb_pairs):
-        cells1 = numpy.array(list(self.ids_1))
-        cells2 = numpy.array(list(self.ids_2))
+        cells1 = numpy.array(list(self.ids_1), int)
+        cells2 = numpy.array(list(self.ids_2), int)
         pairs  = numpy.zeros((0,2), int)
         N1     = len(cells1)
@@ -135 +150 @@
 
 
+
+class DistantDependentPairs(PairsGenerator):
+    """
+    DistantDependentPairs(SpikeList, SpikeList, no_silent, no_auto). Inherits from PairsGenerator.
+    Generator that will return pairs of elements according to the distances between the cells. The
+    dimensions attribute of the SpikeList should be not empty.
+        
+    Inputs:
+        spk1      - First SpikeList object to take cells from
+        spk2      - Second SpikeList object to take cells from
+        no_silent - Boolean to say if only non silent cells should
+                    be considered. False by default 
+        no_auto   - Boolean to say if pairs with the same element (id,id) should
+                    be remove. True by default, i.e those pairs are discarded
+        length    - the lenght (in mm) covered by the extend of spk1 and spk2. Currently, spk1
+                    and spk2 should cover the same surface. Default is spk1.length
+        
+    Examples:
+        >> p = DistantDependentPairs(spk1, spk1, True, False)
+        >> p.get_pairs(4, d_min=0, d_max = 50)
+            [[1,3],[2,5],[1,4],[5,5]]
+        >> p = DistantDependentPairs(spk1, spk1, True, True, lenght=1)
+        >> p.get_pairs(3, d_min=0.25, d_max=0.35)
+            [[1,3],[2,5],[1,4]]
+        
+        
+    See also RandomPairs, CustomPairs, AutoPairs
+    """
+    def __init__(self, spk1, spk2, no_silent=False, no_auto=True, lenght=1.):
+        PairsGenerator.__init__(self, spk1, spk2, no_silent)
+        self.lenght  = lenght
+        self.no_auto = no_auto
+    
+    def get_pairs(self, nb_pairs, d_min, d_max):
+        cells1 = numpy.array(list(self.ids_1), int)
+        cells2 = numpy.array(list(self.ids_2), int)
+        pairs  = numpy.zeros((0,2), int)
+        N1     = len(cells1)
+        N2     = len(cells2)
+        T      = min(N1,N2)
+        while len(pairs) < nb_pairs:
+            N         = min(nb_pairs-len(pairs), T)
+            cell1     = cells1[numpy.floor(numpy.random.uniform(0, N1, N)).astype(int)]
+            cell2     = cells2[numpy.floor(numpy.random.uniform(0, N1, N)).astype(int)]
+            pos_cell1 = numpy.array(self.spk1.id2position(cell1))*self.lenght/self.spk1.dimensions[0]
+            pos_cell2 = numpy.array(self.spk2.id2position(cell2))*self.lenght/self.spk2.dimensions[0]
+            dist      = distance(pos_cell1, pos_cell2, self.lenght)
+            idx       = numpy.where((dist >= d_min) & (dist < d_max))[0]
+            N         = len(idx)
+            if N > 0:
+                tmp_pairs = numpy.zeros((N, 2),int)
+                tmp_pairs[:,0] = cell1[idx]
+                tmp_pairs[:,1] = cell2[idx]
+                if self.no_auto:
+                    idx = numpy.where(tmp_pairs[:,0] == tmp_pairs[:,1])[0]
+                    pairs = numpy.concatenate((pairs, numpy.delete(tmp_pairs, idx, axis=0)))
+                else:
+                    pairs = numpy.concatenate((pairs, tmp_pairs))
+        return pairs
+
+
 class CustomPairs(PairsGenerator):
     """
@@ -151 +227 @@
             [[1,1],[2,2],[3,3],[4,4]]
         
-    See also RandomPairs, CustomPairs
+    See also RandomPairs, CustomPairs, DistantDependentPairs, AutoPairs
     """
     def __init__(self, spk1, spk2, pairs=[[],[]]):