Update to empty dataframe instead of None and removing reliance on pkg_resources

Carole Sudre · Carole Sudre · commit 1c3300a540b6 · 2026-06-04T10:08:59.000+01:00
diff --git a/MetricsReloaded/metrics/pairwise_measures.py b/MetricsReloaded/metrics/pairwise_measures.py
@@ -201,6 +201,7 @@ def confusion_matrix(self):
         """
         one_hot_pred = one_hot_encode(self.pred, len(self.list_values))
         one_hot_ref = one_hot_encode(self.ref, len(self.list_values))
+        print(one_hot_ref.shape, one_hot_pred.shape)
         confusion_matrix = np.matmul(one_hot_pred.T, one_hot_ref)
         return confusion_matrix
 
diff --git a/MetricsReloaded/processes/mixed_measures_processes.py b/MetricsReloaded/processes/mixed_measures_processes.py
@@ -153,7 +153,7 @@ def detection_quality(self):
 
     def panoptic_quality(self):
         """
-        Calculates the panopitic quality defined as the production between
+        Calculates the panopitic quality defined as the product between
         detection quality and segmentation quality
 
         Alexander Kirillov, Kaiming He, Ross Girshick, Carsten Rother, and Piotr Dollár. 2019. Panoptic segmentation. In
@@ -248,7 +248,7 @@ def __init__(
         pixdim=[],
         empty=False,
         assignment="Greedy_IoU",
-        localization="iou",
+        localization="mask_iou",
         thresh=0.5,
         flag_fp_in=True,
         dict_args={},
@@ -476,7 +476,7 @@ def per_label_dict(self):
                     list_mt.append(res_mt)
         self.matching = pd.concat(self.matching)
         if len(list_seg) == 0:
-            df_seg = None
+            df_seg = pd.DataFrame()
         else:
             df_seg = pd.concat(list_seg)
         return (
@@ -541,8 +541,8 @@ def __init__(
         self.names = names
         self.pixdim = pixdim
         self.flag_fp_in = flag_fp_in
-        if len(self.names) < len(self.ref):
-            self.names = range(len(self.ref))
+        if len(self.names) < len(self.ref_class):
+            self.names = range(len(self.ref_class))
         self.flag_valid_proba = True
         if pred_prob is None or pred_prob[0] is None:
             self.flag_valid_proba=False
@@ -556,6 +556,7 @@ def per_label_dict(self):
         list_det = []
         list_mt = []
         for lab in self.list_values:
+            print('Taking care of label %d in OD process'%lab)
             list_pred = []
             list_ref = []
             list_prob = []
@@ -566,8 +567,9 @@ def per_label_dict(self):
                 ind_ref = np.where(ref_arr == lab)
                 pred_loc_tmp = [self.pred_loc[case][f] for f in ind_pred[0]]
                 ref_loc_tmp = [self.ref_loc[case][f] for f in ind_ref[0]]
+                print(self.pred_prob[case].shape)
                 if self.flag_valid_proba:
-                    pred_prob_tmp = [self.pred_prob[case][lab,f] for f in ind_pred[0]]
+                    pred_prob_tmp = [self.pred_prob[case][f,lab] for f in ind_pred[0]]
                 else:
                     pred_prob_tmp = None
                 AS = AssignmentMapping(
@@ -581,6 +583,9 @@ def per_label_dict(self):
                     pixdim=self.pixdim
                 )
                 df_matching = AS.df_matching
+                if df_matching is None:
+                    warnings.warn('Issue with the processing due to incorrect choices and/or input - output will be none')
+                    return None, None
                 pred_tmp_fin = np.asarray(df_matching["pred"])
                 pred_tmp_fin = np.where(
                     pred_tmp_fin > -1,
@@ -910,12 +915,12 @@ def multi_label_res(self):
                 list_mcc.append(dict_mcc)
                 pd_mcc = pd.DataFrame.from_dict(list_mcc)
             else:
-                pd_mcc = None
+                pd_mcc = pd.DataFrame()
             if len(self.measures_calibration) > 0 and overall_prob is not None:
                 CM = CalibrationMeasures(overall_prob, overall_ref,measures=self.measures_calibration)
                 dict_cal = CM.to_dict_meas()
                 list_cal.append(dict_cal)
                 pd_cal = pd.DataFrame.from_dict(list_cal)
             else:
-                pd_cal = None
+                pd_cal = pd.DataFrame()
         return pd_mcc, pd_cal
diff --git a/MetricsReloaded/processes/overall_process.py b/MetricsReloaded/processes/overall_process.py
@@ -357,7 +357,7 @@ def __init__(
         self.pixdim = pixdim
         if self.flag_valid:
             self.process_data()
-            if 'ref_missing' in self.data.keys():
+            if 'ref_missing_pred' in self.data.keys():
                 self.complete_missing_cases()
             if 'weights_labels' in self.data.keys():
                 self.weights_labels = self.data['weights_labels']
@@ -428,11 +428,11 @@ def process_data(self):
         
         """
         data = self.data
-        df_resdet = None
-        df_resseg = None
-        df_resmt = None
-        df_resmcc = None
-        df_rescal = None
+        df_resdet = pd.DataFrame()
+        df_resseg = pd.DataFrame()
+        df_resmt = pd.DataFrame()
+        df_resmcc = pd.DataFrame()
+        df_rescal = pd.DataFrame()
         if self.category == "InS":
             MLLS = MultiLabelLocSegPairwiseMeasure(
                 pred_loc=data["pred_loc"],
@@ -475,7 +475,7 @@ def process_data(self):
                 
             )
             df_resdet, df_resmt = MLDT.per_label_dict()
-            df_resseg = None
+            df_resseg = pd.DataFrame()
         elif self.category in ["ImLC", "SemS"]:
             if 'names' in data.keys():
                 list_names=data['names']
@@ -504,12 +504,12 @@ def process_data(self):
             # print(df_cal, 'CAL')
             if self.category == "ImLC":
                 df_resdet = df_bin
-                df_resseg = None
+                df_resseg = pd.DataFrame()
                 df_resmt = df_mt
                 df_resmcc = df_mcc
                 df_rescal = df_cal
             else:
-                df_resdet = None
+                df_resdet = pd.DataFrame()
                 df_resseg = df_bin
                 df_resmt = df_mt
                 df_resmcc = df_mcc
@@ -518,12 +518,14 @@ def process_data(self):
         self.resmt = df_resmt
         self.resmcc = df_resmcc
         self.rescal = df_rescal
-        self.create_mapping_column_nan_replaced_seg()
+        print('After process state of resdet', self.resdet, ' and resseg ',self.resseg)
+        if self.category == 'SemS':
+            self.create_mapping_column_nan_replaced_seg()
         return
     
     def create_mapping_column_nan_replaced_seg(self):
         """
-        For each measure (segmentation) for which nan are possible 
+        For each measure (semantic segmentation) for which nan are possible 
         creates an additional column in which nans are replaced by value (worse or best according to situation
         """
         list_to_map = []
@@ -547,8 +549,6 @@ def create_mapping_column_nan_replaced_seg(self):
 
         return
         
-        
-
     
     def identify_empty_ref(self):
         """
@@ -650,37 +650,50 @@ def label_aggregation(self, option='average',dict_args={}):
             # print('DET', self.resdet,'CAL',self.rescal, 'SEG',self.resseg,'MT', self.resmt,'MCC', self.resmcc)
             df_grouped_all = merge_list_df([self.resdet, self.resseg, self.resmt,self.resmcc, self.rescal])
             return df_grouped_all
-        df_all_labels = merge_list_df([self.resdet, self.resseg, self.resmt], on=['label','case'])
-        df_all_labels['weights_labels'] = 1
-        df_all_labels['prevalence_labels'] = 1 
-        for k in self.weights_labels.keys():
-            df_all_labels['weights_labels'] = np.where(df_all_labels['label']==k,self.weights_labels[k],df_all_labels['weights_labels'])
-        for (c,rc) in enumerate(self.data['ref_class']):
-            values,counts = np.unique(rc, return_counts=True)
-            for (v,co) in zip(values,counts):
-                df_all_labels['prevalence_labels'] = np.where(np.logical_and(df_all_labels['case']==c, df_all_labels['label']==v),co,df_all_labels['prevalence_labels'])
-        wm = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)), weights=df_all_labels.loc[x.index, "prevalence_labels"])
-        wm2 = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)), weights=df_all_labels.loc[x.index, "weights_labels"])
-        wm3 = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)))
-        list_measures = self.measures_boundary + self.measures_overlap + self.measures_detseg + self.measures_pcc + self.measures_mt
-        dict_measures = {k:[('prevalence',wm),('weights',wm2),('average',wm3)] for k in list_measures}
-        df_grouped_lab = df_all_labels.groupby('case',as_index=False).agg(dict_measures).reset_index()
-        df_grouped_lab.columns = ['_'.join(col).rstrip('_') for col in df_grouped_lab.columns.values]
+        if self.category == 'ImLC': 
+            print(self.resdet, self.resmt, self.rescal, self.resmcc)
+            df_all_labels = merge_list_df([self.resdet, self.resmt, self.rescal], on='label')
+            
+        else:
+            df_all_labels = merge_list_df([self.resdet, self.resseg, self.resmt], on=['label','case'])
+        if df_all_labels is not None:
+            df_all_labels['weights_labels'] = 1
+            df_all_labels['prevalence_labels'] = 1 
+            for k in self.weights_labels.keys():
+                df_all_labels['weights_labels'] = np.where(df_all_labels['label']==k,self.weights_labels[k],df_all_labels['weights_labels'])
+            for (c,rc) in enumerate(self.data['ref_class']):
+                values,counts = np.unique(rc, return_counts=True)
+                for (v,co) in zip(values,counts):
+                    df_all_labels['prevalence_labels'] = np.where(np.logical_and(df_all_labels['case']==c, df_all_labels['label']==v),co,df_all_labels['prevalence_labels'])
+            wm = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)), weights=df_all_labels.loc[x.index, "prevalence_labels"])
+            wm2 = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)), weights=df_all_labels.loc[x.index, "weights_labels"])
+            wm3 = lambda x: np.ma.average(np.ma.masked_array(x,np.isnan(x)))
+            list_measures = self.measures_boundary + self.measures_overlap + self.measures_detseg + self.measures_pcc + self.measures_mt
+            dict_measures = {k:[('prevalence',wm),('weights',wm2),('average',wm3)] for k in list_measures}
+            df_grouped_lab = df_all_labels.groupby('case',as_index=False).agg(dict_measures).reset_index()
+            df_grouped_lab.columns = ['_'.join(col).rstrip('_') for col in df_grouped_lab.columns.values]
         
         # print(df_grouped_lab, " grouped lab ")                                             
-        df_grouped_all = merge_list_df([df_grouped_lab.reset_index(), self.resmcc, self.rescal], on=['case'])
-        # print(df_grouped_all, 'grouped all')
+            df_grouped_all = merge_list_df([df_grouped_lab.reset_index(), self.resmcc, self.rescal], on=['case'])
+        else:
+            df_grouped_all = merge_list_df([self.rescal,self.resmcc],on=['case'])
+        print(df_grouped_all, 'grouped all')
         return df_grouped_all
 
     def get_stats_res(self):
         """
         Create summary statistics overall and per label available in self.stats_lab and self.stats_all
         """
         df_stats_all = self.grouped_lab.describe()
+        self.stats_all = df_stats_all
+        print(self.resdet, self.resseg)
+        if len(self.resdet.index)==0 and len(self.resseg.index)==0:
+            return
+        
         df_all_labels = merge_list_df([self.resdet, self.resseg, self.resmt], on=['label','case'])
         df_stats_lab = df_all_labels.groupby('label').describe()
         self.stats_lab = df_stats_lab
-        self.stats_all = df_stats_all
+       
         return 
 
     
diff --git a/MetricsReloaded/utility/assignment_localization.py b/MetricsReloaded/utility/assignment_localization.py
@@ -123,7 +123,8 @@ def __init__(
 
             dim = 0
             print(all_input)
-            if all_input.shape[0] > 0:
+            if np.asarray(all_input).size > 0:
+            #if all_input.shape[0] > 0:
                 input = guess_input_style(all_input)
                 if input == 'mask':
                     dim = all_input.ndim
@@ -132,7 +133,7 @@ def __init__(
                     dim = int(np.size(all_input)/2)
                 else:
                     dim = np.size(all_input)
-            print(input, dim)
+                print(input, dim)
             if dim > 0:
                 self.pixdim = np.ones([dim])
             
@@ -168,13 +169,13 @@ def __init__(
             elif localization == "com_dist":
                 self.matrix = self.pairwise_pointcomdist()
             else:
-                print(' not valid localisation ')
+                print(' not valid localisation with ', localization)
                 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 ')
+                print(' not valid localisation with void entries')
                 self.flag_usable = False
                 self.df_matching = None
                 self.valid = None
@@ -627,6 +628,8 @@ def resolve_ambiguities_matching(self):
         ):
             print("No ambiguity in matching")
             df_matching_all = pd.concat([df_matching, df_fp, df_fn])
+            if df_matching_all.shape[0] == 0:
+                df_matching_all =pd.DataFrame(columns = ['pred','ref','pred_prob','performance'])
             return df_matching_all, list_valid
         else:
             if self.assignment == "hungarian":
@@ -696,6 +699,8 @@ def resolve_ambiguities_matching(self):
                 df_matching_all = pd.concat([df_ordered2, df_fn_all, df_fp, df_fp_new])
             else:
                 df_matching_all = pd.concat([df_ordered2, df_fp, df_fn_all])
+            if df_matching_all.shape[0] == 0:
+                df_matching_all =pd.DataFrame(columns = ['pred','ref','pred_prob','performance'])
             return df_matching_all, list_valid
 
     def matching_ref_predseg(self):
diff --git a/MetricsReloaded/utility/utils.py b/MetricsReloaded/utility/utils.py
@@ -521,9 +521,9 @@ def combine_df(df1,df2):
     if df1 is None or df1.shape[0]==0:
         print('Nothing in first')
         if df2 is None:
-            return None
+            return pd.DataFrame()
         elif df2.shape[0] == 0:
-            return None
+            return pd.DataFrame()
         else:
             return df2
     elif df2 is None or df2.shape[0]==0:
diff --git a/setup.py b/setup.py
@@ -4,7 +4,8 @@
 import os
 from glob import glob
 
-from pkg_resources import parse_requirements
+#from pkg_resources import parse_requirements
+from packaging.requirements import Requirement
 from setuptools import find_packages
 from setuptools import setup
 
@@ -17,7 +18,7 @@
 
 # read install requirements from requirements.txt
 with open(os.path.join(source_dir, "requirements.txt")) as o:
-    requirements = [str(r) for r in parse_requirements(o.read())]
+    requirements = [str(r) for r in Requirement(o.read())]
 
 setup(
     name="MetricsReloaded",
@@ -46,6 +47,10 @@
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
         "Topic :: Scientific/Engineering",
     ],
     project_urls={
diff --git a/test/test_processes/test_overall_process.py b/test/test_processes/test_overall_process.py
diff --git a/test/test_utility/test_utils.py b/test/test_utility/test_utils.py
