Improving testing of assignment localisation

Author: Carole Sudre

MetricsReloaded/utility/assignment_localization.py

@@ -110,6 +110,8 @@ def __init__(
         self.flag_fp_in = flag_fp_in
         self.pixdim = pixdim
         all_input = []
+        self.ref_loc_mod = None
+        self.pred_loc_mod = None
         if len(self.pixdim) == 0:
             if len(pred_loc) > 0:
                 if pred_loc[0].size > 0:
@@ -136,11 +138,14 @@ def __init__(
 
         flag_usable, flag_predmod, flag_refmod = self.check_input_localization()
         # self.pred_class = pred_class
-        
+        print('Flag', flag_usable, flag_predmod, flag_refmod)
         # self.ref_class = ref_class
         self.flag_usable = flag_usable
         self.flag_predmod = flag_predmod
         self.flag_refmod = flag_refmod
+        
+
+
         if self.flag_usable:
             if localization == "box_iou":
                 self.matrix = self.pairwise_boxiou()
@@ -163,12 +168,23 @@ def __init__(
             elif localization == "com_dist":
                 self.matrix = self.pairwise_pointcomdist()
             else:
+                print(' not valid localisation ')
                 self.flag_usable = False
+                self.df_matching = None
+                self.valid = None
+                warnings.warn("No adequate localization strategy chosen - not going ahead")
+        else:
+                print(' not valid localisation ')
+                self.flag_usable = False
+                self.df_matching = None
+                self.valid = None
                 warnings.warn("No adequate localization strategy chosen - not going ahead")
 
         if self.localization in ['point_in_mask','point_in_box']:
             if self.assignment == 'greedy_matching':
                 self.flag_usable = False
+                self.df_matching = None
+                self.valid = None
                 warnings.warn("The localization strategy does not provide grading. Impossible to base assignment on localization performance!")
         if self.flag_usable:        
             self.df_matching, self.valid = self.resolve_ambiguities_matching()
@@ -240,6 +256,7 @@ def check_input_localization(self):
                 return flag_usable, flag_predmod, flag_refmod
             if input_ref == 'mask':
                 flag_refmod = True
+                self.box_fromrefmask()
                 warnings.warn('We will need to modify ref to make it interpretable as box corners')
         elif self.localization == 'com_dist':
             if input_ref == 'mask':
@@ -359,8 +376,8 @@ def pairwise_pointinbox(self):
         pred_points = self.pred_loc
         if self.flag_refmod:
             ref_boxes = self.ref_loc_mod
-        if self.flag_predmod:
-            pred_points = self.pred_loc_mod
+        # if self.flag_predmod:
+        #     pred_points = self.pred_loc_mod
         matrix_pinb = np.zeros([pred_points.shape[0],ref_boxes.shape[0]])
         for (p, p_point) in enumerate(pred_points):
             for (r, r_box) in enumerate(ref_boxes):
@@ -376,10 +393,10 @@ def pairwise_pointinmask(self):
         """
         ref_masks = self.ref_loc
         pred_points = self.pred_loc
-        if self.flag_refmod:
-            ref_masks = self.ref_loc_mod
-        if self.flag_predmod:
-            pred_points = self.pred_loc_mod
+        # if self.flag_refmod:
+        #     ref_masks = self.ref_loc_mod
+        # if self.flag_predmod:
+        #     pred_points = self.pred_loc_mod
         matrix_pinm = np.zeros([pred_points.shape[0],ref_masks.shape[0]])
         for (p,p_point) in enumerate(pred_points):
             for (r,r_mask) in enumerate(ref_masks):
@@ -600,13 +617,13 @@ def resolve_ambiguities_matching(self):
             df_ambiguous_ref = df_matching[
                 (df_matching["count_ref"] > 1) & (df_matching["ref"] > -1)
             ]
-            df_ambiguous_seg = df_matching[
+            df_ambiguous_pred = df_matching[
                 (df_matching["count_pred"] > 1) & (df_matching["pred"] > -1)
             ]
         if (
             df_ambiguous_ref is None
             or df_ambiguous_ref.shape[0] == 0
-            and df_ambiguous_seg.shape[0] == 0
+            and df_ambiguous_pred.shape[0] == 0
         ):
             print("No ambiguity in matching")
             df_matching_all = pd.concat([df_matching, df_fp, df_fn])
@@ -620,7 +637,7 @@ def resolve_ambiguities_matching(self):
                 list_matching = []
                 for (r, c) in zip(row, col):
                     df_tmp = df_matching[
-                        df_matching["seg"] == list_valid[r] & (df_matching["ref"] == c)
+                        df_matching["pred"] == list_valid[r] & (df_matching["ref"] == c)
                     ]
                     list_matching.append(df_tmp)
                 df_ordered2 = pd.concat(list_matching)

test/test_utility/test_assignment_localization.py

@@ -51,6 +51,8 @@
 ref_351 = [pq_ref1, pq_ref2, pq_ref3]
 pred_351 = [pq_pred1, pq_pred2, pq_pred3,pq_pred4]
 
+pred_com_351 = [np.asarray([4.5,2]), np.asarray([14,5]), np.asarray([9,14.5]), np.asarray([13.5,14.5])]
+
 
 ## Data for figure 59 and testing of localisation
 f59_ref1 = np.zeros([15, 15])
@@ -63,6 +65,48 @@
 f59_pred2 = np.zeros([15, 15])
 f59_pred2[4:8, 5:9] = 1
 
+def test_pixdim_info():
+    asm = AssignmentMapping(pred_loc = pred_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9])
+    asm2 = AssignmentMapping(pred_loc=[], ref_loc=ref_351, pred_prob=[])
+    assert_allclose(asm.pixdim,[1,1])
+    assert_allclose(asm2.pixdim,[1,1])
+
+def test_not_suitable_localisation():
+    asm = AssignmentMapping(pred_loc=pred_com_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='box_iou')
+    assert not asm.flag_usable
+    assert asm.df_matching is None
+
+def test_emptyref_flags():
+    asm = AssignmentMapping(pred_loc=pred_351, ref_loc=[],  pred_prob=[0.4, 0.6, 0.3, 0.9])
+    assert asm.flag_usable
+
+def test_not_good_localisation_option():
+    asm = AssignmentMapping(pred_loc = pred_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='mask_iop')
+    assert not asm.flag_usable
+
+def test_boundaryiou_loc():
+    asm = AssignmentMapping(pred_loc = pred_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='boundary_iou')
+    assert asm.matrix[0,1] == 0
+
+def test_input_boxcom_maskcom():
+    asm1 = AssignmentMapping(pred_loc=pred_boxes_6a, ref_loc=ref_boxes_6a, pred_prob=pred_proba_6a, localization='box_com')
+    asm2 = AssignmentMapping(pred_loc = pred_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='box_com')
+    assert asm1.flag_refmod
+    assert asm1.flag_predmod
+    assert asm2.flag_refmod
+    assert asm2.flag_predmod
+
+def test_input_pim_maskmask():
+    asm2 = AssignmentMapping(pred_loc = pred_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='point_in_mask')
+    assert not asm2.flag_usable
+
+def test_input_pib_pm():
+    asm = AssignmentMapping(pred_loc=pred_com_351, ref_loc=ref_351, pred_prob=[0.4, 0.6, 0.3, 0.9], localization='point_in_box')
+    matrix_pib = asm.pairwise_pointinbox()
+    assert  asm.flag_refmod
+    assert matrix_pib[0,0] == 1
+
+
 def test_assignment_6c():
     asm1 = AssignmentMapping(pred_loc=pred_boxes_6a, ref_loc=ref_boxes_6a, pred_prob=pred_proba_6a, thresh=0.1,localization='box_iou')
     df_matching, df_fn, df_fp, list_valid = asm1.initial_mapping()
@@ -222,6 +266,11 @@ def test_pairwise_pointinbox():
     expected_matrix = np.asarray([[1,0],[0,0]])
     assert_allclose(am.matrix, expected_matrix)
 
+def test_pairwise_pointinbox_pm():
+    asm = AssignmentMapping(pred_com_351, ref_351,[1,1,1,1],'point_in_box')
+    assert asm.matrix[0,0] == 1
+
+
 def test_pairwise_pointcomdist():
     ref1 = [3,4]
     ref2 = [10,10]
@@ -257,6 +306,11 @@ def test_com_from_refbox_6a():
     expected_ref_com = [[5,3.5],[7.5,10],[2,17],[15,16]]
     assert_array_almost_equal(np.asarray(expected_ref_com), test_com)
 
+def test_pairwise_boxior_mm():
+    asm = AssignmentMapping(pred_351, ref_351,[1,1,1,1],'box_ior')
+    assert asm.matrix[0,0] == 0.8
+
+
 def test_com_from_predbox_6a():
     """
     Using figure 6a as illustration
@@ -308,6 +362,23 @@ def test_box_frompredmask():
     expected_box = [[3,1,6,6],[13,4,15,5],[7,13,11,16],[13,13,15,16]]
     assert_array_almost_equal(np.asarray(expected_box),test_box)
 
+def test_matching_ambiguity():
+        ref_box = np.asarray([2,3,10,11])
+        pred_box1 = np.asarray([1,1,8,8])
+        pred_box2 = np.asarray([2,8,11,11])
+        ref = [ref_box]
+        pred = [pred_box1, pred_box2]
+        asm = AssignmentMapping(pred, ref,[0.5,1],thresh=0.1,localization='box_iou')
+        asm_h = AssignmentMapping(pred, ref,[0.5,1],thresh=0.1,localization='box_iou',assignment='hungarian')
+        asm_p = AssignmentMapping(pred, ref,[0.5,1],thresh=0.1,localization='box_iou',assignment='greedy_performance')
+        df_match, list_val = asm.resolve_ambiguities_matching()
+        df_match_h, list_val_h = asm_h.resolve_ambiguities_matching()
+        df_match_p, list_val_p = asm_p.resolve_ambiguities_matching()
+        print(df_match, df_match_h, df_match_p)
+        assert df_match.shape[0] == 2
+        assert df_match_h.shape[0] == 2
+        assert df_match_p.shape[0] == 2
+
 
 def test_localization():
     ref = [f59_ref1, f59_ref2]
@@ -349,3 +420,9 @@ def test_localization():
         np.asarray(m12[m12["pred"] == 0]["ref"])[0] == 0
         and np.asarray(m21[m21["pred"] == 0]["ref"])[0] == -1
     )
+
+    
+
+
+
+