add support for num_processes=0 in planning

nndet/planning/properties/instance.py

@@ -73,9 +73,13 @@ def run_analyze_instances(analyzer: DatasetAnalyzer,
         Dict: extract properties per case id [case_id, property_dict]
     """
     props_per_case = OrderedDict()
-    with Pool(analyzer.num_processes) as p:
-        props = p.starmap(analyze_instances_per_case, zip(
-            repeat(analyzer), analyzer.case_ids, repeat(all_classes)))
+    if analyzer.num_processes == 0:
+        props = [analyze_instances_per_case(*args) for args in zip(
+                 repeat(analyzer), analyzer.case_ids, repeat(all_classes))]
+    else:
+        with Pool(analyzer.num_processes) as p:
+            props = p.starmap(analyze_instances_per_case, zip(
+                repeat(analyzer), analyzer.case_ids, repeat(all_classes)))
 
     # props = [analyze_instances_per_case(analyzer, cid, all_classes) for cid in analyzer.case_ids]
 

nndet/planning/properties/intensity.py

@@ -80,25 +80,31 @@ def run_collect_intensity_properties(analyzer: DatasetAnalyzer,
             Evaluated statistics: `median`; `mean`; `std`; `min`; `max`; `percentile_99_5`; `percentile_00_5`
             `local_props`: contains a dict (with case ids) where statistics where computed per case
     """
-    with Pool(analyzer.num_processes) as p:
-        results = OrderedDict()
-        for mod_id in range(num_modalities):
-            logger.info(f"Processing intensity values of modality {mod_id}")
-            results[mod_id] = OrderedDict()
-
-            voxels = p.starmap(get_voxels_in_foreground,
-                               zip(repeat(analyzer), analyzer.case_ids, repeat(mod_id)))
-
-            local_props = p.map(compute_stats, voxels)
-            props_per_case = OrderedDict()
-            for case_id, lp in zip(analyzer.case_ids, local_props):
-                props_per_case[case_id] = lp
-            
-            all_voxels = []
-            for iv in voxels:
-                all_voxels += iv
-            results[mod_id]['local_props'] = props_per_case
-            results[mod_id].update(compute_stats(all_voxels))
+    
+    results = OrderedDict()
+    for mod_id in range(num_modalities):
+        logger.info(f"Processing intensity values of modality {mod_id}")
+        results[mod_id] = OrderedDict()
+
+        if analyzer.num_processes == 0:
+            voxels = [get_voxels_in_foreground(*args) for args in
+                      zip(repeat(analyzer), analyzer.case_ids, repeat(mod_id))]
+            local_props = [compute_stats(v) for v in voxels]
+        else:
+            with Pool(analyzer.num_processes) as p:
+                voxels = p.starmap(get_voxels_in_foreground,
+                                    zip(repeat(analyzer), analyzer.case_ids, repeat(mod_id)))
+                local_props = p.map(compute_stats, voxels)
+
+        props_per_case = OrderedDict()
+        for case_id, lp in zip(analyzer.case_ids, local_props):
+            props_per_case[case_id] = lp
+
+        all_voxels = []
+        for iv in voxels:
+            all_voxels += iv
+        results[mod_id]['local_props'] = props_per_case
+        results[mod_id].update(compute_stats(all_voxels))
 
     if save:
         with open(analyzer.intensity_properties_file, 'wb') as f:

nndet/planning/properties/segmentation.py

@@ -117,12 +117,17 @@ def run_analyze_segmentation(
         Dict[Dict]: computed properties per case
     """
     props_per_case = OrderedDict()
-    with Pool(analyzer.num_processes) as p:
-        props = p.starmap(analyze_fn, zip(
-            repeat(analyzer), analyzer.case_ids, repeat(all_classes)))
 
-        for case_id, prop in zip(analyzer.case_ids, props):
-            props_per_case[case_id] = prop
+    if analyzer.num_processes == 0:
+        props = [analyze_fn(*args) for args in zip(
+            repeat(analyzer), analyzer.case_ids, repeat(all_classes))]
+    else:
+        with Pool(analyzer.num_processes) as p:        
+                props = p.starmap(analyze_fn, zip(
+                    repeat(analyzer), analyzer.case_ids, repeat(all_classes)))
+
+    for case_id, prop in zip(analyzer.case_ids, props):
+        props_per_case[case_id] = prop
 
     if save:
         with open(analyzer.props_per_case_file, "wb") as f:

scripts/preprocess.py

@@ -232,7 +232,7 @@ def run_check(data_dir: Path,
                  for case in cases_npz]
 
     if processes == 0:
-        result = [check_case(case_npz, case_pkl, remove=remove)
+        result = [check_case(case_npz, case_pkl, remove=remove, keys=keys)
                   for case_npz, case_pkl in zip(cases_npz, cases_pkl)]
     else:
         with Pool(processes=processes) as p: