RF: finish cleaning up cost to thresh, caught corner case in slice data

Author: CindeeM

brainx/tests/test_util.py

@@ -72,17 +72,24 @@ def setUp(self):
         for sblock in range(nsubblocks):
             for block in range(nblocks):
                 for sid in range(nsub):
-                    tmp = data_5d[sblock, block, sid]
-                    self.lookup[sblock,block,sid,0,:] = tmp[ind]
+                    tmp = self.data_5d[sblock, block, sid]
+                    self.lookup[sblock,block,sid,0,:] = sorted(tmp[ind], 
+                            reverse=True)
 
-        def test_cost2thresh2(self):
-            thr = util.cost2thresh2(self.costs[100], 0,0,0,self.lookup)
-            npt.assert_almost_equal(thr, 0.24929222914887494, decimal=7)
-
-        def test_cost2thresh(self):
-            lookup = self.lookup[0].squeeze()
-            thr = util.cost2thresh(self.costs[100],0,0,0,lookup)
-            npt.assert_almost_equal(thr, 0.24929222914887494, decimal=7)
+    def test_cost2thresh2(self):
+        thr = util.cost2thresh2(self.costs[100], 0,0,0,self.lookup)
+        npt.assert_almost_equal(thr, 0.24929222914887494, decimal=7)
+
+    def test_cost2thresh(self):
+        lookup = self.lookup[0].squeeze()
+        thr = util.cost2thresh(self.costs[100],0,0,0,lookup)
+        npt.assert_almost_equal(thr, 0.24929222914887494, decimal=7)
+
+    def test_format_matrix(self):
+        thresh_matrix = util.format_matrix2(self.data_5d, 0,0,0,
+                self.lookup, self.costs[100])
+        print thresh_matrix.sum()
+        npt.assert_equal(thresh_matrix.sum(), 22)
 
 def test_apply_cost():
     corr_mat = np.array([[0.0, 0.5, 0.3, 0.2, 0.1],

brainx/util.py

@@ -32,7 +32,7 @@ def slice_data(data, sub, block, subcond=None):
     adjacency_matrix : numpy array
         symmetric numpy array (innode, nnode)
     """
-    if subcond:
+    if not subcond is None:
         return data[subcond, block, sub]
     return data[block, sub]
 
@@ -91,16 +91,17 @@ def format_matrix2(data,s,sc,c,lk,co,idc = [],costlist=[],nouptri = False):
     nouptri : bool
         False zeros out diag and below, True returns symmetric matrix
 """
-    
-    cmat = data[sc,c,s]
+    cmat = slice_data(data, s, c, sc) 
+    #cmat = data[sc,c,s]
     th = cost2thresh2(co,s,sc,c,lk,[],idc,costlist) #get the right threshold
 
     #cmat = replace_diag(cmat) #replace diagonals with zero
     cmat = thresholded_arr(cmat,th,fill_val=0)
 
     if not nouptri:
         cmat = np.triu(cmat,1)
-        
+    
+    # return boolean mask
     return cmat
 
 def threshold_adjacency_matrix(adj_matrix, cost):
@@ -606,32 +607,8 @@ def cost2thresh(cost, sub, bl, lk, idc=[], costlist=[]):
     be registered.
 
     """
-    return cost2thresh2(cost, sub, bl, axis0=None, lk=lk, last = None, idc=idc,costlist = costlist)
-    # For this subject and block, find the indices corresponding to this cost.
-    # Note there may be more than one such index.  There will be no such
-    # indices if cost is not a value in the array.
-    ind = np.where(lk[bl][sub][1] == cost)
-    # The possibility of multiple (or no) indices implies multiple (or no)
-    # thresholds may be acquired here.
-    th = lk[bl][sub][0][ind]
-    n_thresholds = len(th)
-    if n_thresholds > 1:
-        th=th[0]
-        print(''.join(['Subject %s has multiple thresholds in block %d ',
-                       'corresponding to a cost of %f.  The smallest is being',
-                       ' used.']) % (sub, bl, cost))
-    elif n_thresholds < 1:
-        idc = idc - 1
-        newcost = costlist[idc]
-        th = cost2thresh(newcost, sub, bl, lk, idc, costlist)
-        print(''.join(['Subject %s does not have a threshold in block %d ',
-                       'corresponding to a cost of %f.  The threshold ',
-                       'matching the nearest previous cost in costlist is ',
-                       'being used.']) % (sub, block, cost))
-    else:
-        th=th[0]
-    return th
-
+    return cost2thresh2(cost, sub, bl, axis0=None, 
+            lk=lk, last = None, idc=idc,costlist = costlist)
 
 def cost2thresh2(cost, sub, axis1, axis0, lk, 
         last = None, idc = [], costlist=[]):
@@ -667,7 +644,7 @@ def cost2thresh2(cost, sub, axis1, axis0, lk,
 
     subject_lookup = slice_data(lk, sub, axis0, subcond=axis1) 
     index = np.where(subject_lookup[1] == cost)
-    threshold = subject_lookup[0][ind]
+    threshold = subject_lookup[0][index]
 
     if len(threshold) > 1:
         threshold = threshold[0]