biapy 3.3.2__tar.gz → 3.3.3__tar.gz

{biapy-3.3.2/biapy.egg-info → biapy-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biapy
-Version: 3.3.2
+Version: 3.3.3
 Summary: BiaPy: Bioimage analysis pipelines in Python
 Home-page: https://github.com/BiaPyX/BiaPy
 Author: BiaPy Contributors

{biapy-3.3.2 → biapy-3.3.3}/biapy/config/config.py

@@ -237,7 +237,7 @@ class Config:
         # Points outside the boundaries of the input are filled according to the given mode: {‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}
         _C.DATA.PREPROCESS.RESIZE.MODE = 'reflect'
         # Used in conjunction with mode ‘constant’, the value outside the image boundaries.
-        _C.DATA.PREPROCESS.RESIZE.CVAL = 0
+        _C.DATA.PREPROCESS.RESIZE.CVAL = 0.
         # Whether to clip the output to the range of values of the input image.
         _C.DATA.PREPROCESS.RESIZE.CLIP = True
         # Whether to keep the original range of values.
@@ -784,14 +784,12 @@ class Config:
         _C.TEST.AUGMENTATION = False
         # Whether to evaluate or not
         _C.TEST.EVALUATE = True
-        # Stack 2D images into a 3D image and then process it entirely instead of going image per image. This stacks
-        # images that have been merged with 'TEST.STATS.MERGE_PATCHES' = True or 'TEST.STATS.FULL_IMG' (priorizes this later)  
+        # Stack 2D images into a 3D image and then process it entirely instead of going image per image
         _C.TEST.ANALIZE_2D_IMGS_AS_3D_STACK = False
 
-        _C.TEST.STATS = CN()
-        _C.TEST.STATS.PER_PATCH = False
-        _C.TEST.STATS.MERGE_PATCHES = False # Only used when _C.TEST.STATS.PER_PATCH = True
-        _C.TEST.STATS.FULL_IMG = True # Only when if PROBLEM.NDIM = '2D' as 3D images are huge for the GPU
+        # If PROBLEM.NDIM = '2D' this can be activated to process each image entirely instead of patch by patch. Only can be done 
+        # if the neural network is fully convolutional
+        _C.TEST.FULL_IMG = False 
 
         ### Instance segmentation
         # Whether to calculate matching statistics (average overlap, accuracy, recall, precision, etc.)
@@ -830,8 +828,7 @@ class Config:
         #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         # Post-processing
         #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        # When PROBLEM.NDIM = '2D' only applies when _C.TEST.STATS.FULL_IMG = True, if PROBLEM.NDIM = '3D' is applied
-        # when _C.TEST.STATS.MERGE_PATCHES = True
+        # When PROBLEM.NDIM = '2D' only applies when _C.TEST.ANALIZE_2D_IMGS_AS_3D_STACK = True
         _C.TEST.POST_PROCESSING = CN()
         _C.TEST.POST_PROCESSING.YZ_FILTERING = False
         _C.TEST.POST_PROCESSING.YZ_FILTERING_SIZE = 5
@@ -958,6 +955,9 @@ class Config:
         _C.PATHS.RESULT_DIR.PER_IMAGE_POST_PROCESSING = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'per_image_post_processing')
         _C.PATHS.RESULT_DIR.FULL_IMAGE = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'full_image')
         _C.PATHS.RESULT_DIR.FULL_IMAGE_BIN = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'full_image_binarized')
+        _C.PATHS.RESULT_DIR.FULL_IMAGE_INSTANCES = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'full_image_instances')
+        _C.PATHS.RESULT_DIR.FULL_IMAGE_POST_PROCESSING = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'full_image_post_processing')
+        _C.PATHS.RESULT_DIR.AS_3D_STACK = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'as_3d_stack')
         _C.PATHS.RESULT_DIR.AS_3D_STACK_POST_PROCESSING = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'as_3d_stack_post_processing')
         _C.PATHS.RESULT_DIR.DET_LOCAL_MAX_COORDS_CHECK = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'per_image_local_max_check')
         _C.PATHS.RESULT_DIR.DET_ASSOC_POINTS = os.path.join(_C.PATHS.RESULT_DIR.PATH, 'point_associations')

{biapy-3.3.2 → biapy-3.3.3}/biapy/data/pre_processing.py

@@ -1190,7 +1190,7 @@ def preprocess_data(cfg, x_data=[], y_data=[], is_2d=True, is_y_mask=False):
         Preprocessed data. The same structure and dimensionality of the given data will be returned.
     """
     
-    if cfg.RESIZE.ACTIVATE:
+    if cfg.RESIZE.ENABLE:
         print("Preprocessing: applying resize . . .")
         if len(x_data) > 0:
             x_data = resize_images(x_data,
@@ -1216,31 +1216,31 @@ def preprocess_data(cfg, x_data=[], y_data=[], is_2d=True, is_y_mask=False):
             )
 
     if len(x_data) > 0:
-        if cfg.GAUSSIAN_BLUR.ACTIVATE:
+        if cfg.GAUSSIAN_BLUR.ENABLE:
             print("Preprocessing: applying gaussian blur . . .")
             x_data = apply_gaussian_blur(x_data,
                 sigma = cfg.GAUSSIAN_BLUR.SIGMA,
                 mode = cfg.GAUSSIAN_BLUR.MODE,
                 channel_axis = cfg.GAUSSIAN_BLUR.CHANNEL_AXIS,
             )
-        if cfg.MEDIAN_BLUR.ACTIVATE:
+        if cfg.MEDIAN_BLUR.ENABLE:
             print("Preprocessing: applying median blur . . .")
             x_data = apply_median_blur(x_data,
                 footprint = cfg.MEDIAN_BLUR.FOOTPRINT,
             )
-        if cfg.MATCH_HISTOGRAM.ACTIVATE:
+        if cfg.MATCH_HISTOGRAM.ENABLE:
             print("Preprocessing: applying histogram matching . . .")
             x_data = apply_histogram_matching(x_data,
                 reference_path = cfg.MATCH_HISTOGRAM.REFERENCE_PATH,
                 is_2d = is_2d,
             )
-        if cfg.CLAHE.ACTIVATE:
+        if cfg.CLAHE.ENABLE:
             print("Preprocessing: applying CLAHE . . .")
             x_data = apply_clahe(x_data,
                 kernel_size = cfg.CLAHE.KERNEL_SIZE,
                 clip_limit = cfg.CLAHE.CLIP_LIMIT,
             )
-        if cfg.CANNY.ACTIVATE:
+        if cfg.CANNY.ENABLE:
             print("Preprocessing: applying Canny . . .")
             x_data = detect_edges(x_data,
                 low_threshold = cfg.CANNY.LOW_THRESHOLD,

{biapy-3.3.2 → biapy-3.3.3}/biapy/engine/base_workflow.py

@@ -59,7 +59,7 @@ class Base_Workflow(metaclass=ABCMeta):
         self.cross_val_samples_ids = None
         self.post_processing = {}
         self.post_processing['per_image'] = False
-        self.post_processing['all_images'] = False
+        self.post_processing['as_3D_stack'] = False
         self.test_filenames = None 
         self.metrics = []
         self.data_norm = None
@@ -88,18 +88,20 @@ class Base_Workflow(metaclass=ABCMeta):
         self.stats['patch_counter'] = 0
 
         # Merging the image
-        self.stats['iou_per_image'] = 0
-        self.stats['ov_iou_per_image'] = 0
+        self.stats['iou_merge_patches'] = 0
+        self.stats['ov_iou_merge_patches'] = 0
+        self.stats['iou_merge_patches_post'] = 0
+        self.stats['ov_iou_merge_patches_post'] = 0
+
+        # As 3D stack
+        self.stats['iou_as_3D_stack_post'] = 0
+        self.stats['ov_iou_as_3D_stack_post'] = 0
 
         # Full image
         self.stats['loss'] = 0
         self.stats['iou'] = 0
         self.stats['ov_iou'] = 0
 
-        # Post processing
-        self.stats['iou_post'] = 0
-        self.stats['ov_iou_post'] = 0
-
         self.world_size = get_world_size()
         self.global_rank = get_rank()
         if self.cfg.TEST.BY_CHUNKS.ENABLE and self.cfg.PROBLEM.NDIM == '3D':
@@ -111,7 +113,7 @@ class Base_Workflow(metaclass=ABCMeta):
         # Test variables
         if self.cfg.TEST.ANALIZE_2D_IMGS_AS_3D_STACK and self.cfg.PROBLEM.NDIM == "2D":
             if self.cfg.TEST.POST_PROCESSING.YZ_FILTERING or self.cfg.TEST.POST_PROCESSING.Z_FILTERING:
-                self.post_processing['all_images'] = True
+                self.post_processing['as_3D_stack'] = True
         elif self.cfg.PROBLEM.NDIM == "3D":
             if self.cfg.TEST.POST_PROCESSING.YZ_FILTERING or self.cfg.TEST.POST_PROCESSING.Z_FILTERING:
                 self.post_processing['per_image'] = True
@@ -1119,7 +1121,7 @@ class Base_Workflow(metaclass=ABCMeta):
         #################
         ### PER PATCH ###
         #################
-        if self.cfg.TEST.STATS.PER_PATCH:
+        if not self.cfg.TEST.FULL_IMG or self.cfg.PROBLEM.NDIM == '3D':
             # Reflect data to complete the needed shape
             if self.cfg.DATA.REFLECT_TO_COMPLETE_SHAPE:
                 reflected_orig_shape = self._X.shape
@@ -1278,49 +1280,45 @@ class Base_Workflow(metaclass=ABCMeta):
                 save_tif(np.expand_dims(pred,0), self.cfg.PATHS.RESULT_DIR.PER_IMAGE, self.processing_filenames, 
                     verbose=self.cfg.TEST.VERBOSE)
 
-            #########################
-            ### MERGE PATCH STATS ###
-            #########################
-            if self.cfg.TEST.STATS.MERGE_PATCHES:
-                if self.cfg.DATA.TEST.LOAD_GT and self.cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS != "Dv2":
-                    if self._Y.ndim > pred.ndim: self._Y = self._Y[0]
-                    if self.cfg.LOSS.TYPE != 'MASKED_BCE':
-                        _iou_per_image = jaccard_index_numpy((self._Y>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8))
-                        _ov_iou_per_image = voc_calculation((self._Y>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8),
-                                                        _iou_per_image)
-                    else:
-                        exclusion_mask = self._Y < 2
-                        binY = self._Y * exclusion_mask.astype( float )
-                        _iou_per_image = jaccard_index_numpy((binY>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8))
-                        _ov_iou_per_image = voc_calculation((binY>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8),
-                                                        _iou_per_image)
-                    self.stats['iou_per_image'] += _iou_per_image
-                    self.stats['ov_iou_per_image'] += _ov_iou_per_image
-
-                ############################
-                ### POST-PROCESSING (3D) ###
-                ############################
-                if self.post_processing['per_image']:
-                    pred, _iou_post, _ov_iou_post = apply_post_processing(self.cfg, pred, self._Y)
-                    self.stats['iou_post'] += _iou_post
-                    self.stats['ov_iou_post'] += _ov_iou_post
-                    if pred.ndim == 4:
-                        save_tif(np.expand_dims(pred,0), self.cfg.PATHS.RESULT_DIR.PER_IMAGE_POST_PROCESSING,
-                            self.processing_filenames, verbose=self.cfg.TEST.VERBOSE)
-                    else:
-                        save_tif(pred, self.cfg.PATHS.RESULT_DIR.PER_IMAGE_POST_PROCESSING, self.processing_filenames,
-                            verbose=self.cfg.TEST.VERBOSE)
+            if self.cfg.DATA.TEST.LOAD_GT and self.cfg.PROBLEM.INSTANCE_SEG.DATA_CHANNELS != "Dv2":
+                if self._Y.ndim > pred.ndim: self._Y = self._Y[0]
+                if self.cfg.LOSS.TYPE != 'MASKED_BCE':
+                    _iou_merge_patches = jaccard_index_numpy((self._Y>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8))
+                    _ov_iou_merge_patches = voc_calculation((self._Y>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8),
+                                                    _iou_merge_patches)
+                else:
+                    exclusion_mask = self._Y < 2
+                    binY = self._Y * exclusion_mask.astype( float )
+                    _iou_merge_patches = jaccard_index_numpy((binY>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8))
+                    _ov_iou_merge_patches = voc_calculation((binY>0.5).astype(np.uint8), (pred>0.5).astype(np.uint8),
+                                                    _iou_merge_patches)
+                self.stats['iou_merge_patches'] += _iou_merge_patches
+                self.stats['ov_iou_merge_patches'] += _ov_iou_merge_patches
+
+            ############################
+            ### POST-PROCESSING (3D) ###
+            ############################
+            if self.post_processing['per_image']:
+                pred, _iou_post, _ov_iou_post = apply_post_processing(self.cfg, pred, self._Y)
+                self.stats['iou_merge_patches_post'] += _iou_post
+                self.stats['ov_iou_merge_patches_post'] += _ov_iou_post
+                if pred.ndim == 4:
+                    save_tif(np.expand_dims(pred,0), self.cfg.PATHS.RESULT_DIR.PER_IMAGE_POST_PROCESSING,
+                        self.processing_filenames, verbose=self.cfg.TEST.VERBOSE)
+                else:
+                    save_tif(pred, self.cfg.PATHS.RESULT_DIR.PER_IMAGE_POST_PROCESSING, self.processing_filenames,
+                        verbose=self.cfg.TEST.VERBOSE)
 
             self.after_merge_patches(pred)
             
-            if not self.cfg.TEST.STATS.FULL_IMG and self.cfg.TEST.ANALIZE_2D_IMGS_AS_3D_STACK:
+            if self.cfg.TEST.ANALIZE_2D_IMGS_AS_3D_STACK:
                 self.all_pred.append(pred)
                 if self.cfg.DATA.TEST.LOAD_GT: self.all_gt.append(self._Y)            
 
         ##################
         ### FULL IMAGE ###
         ##################
-        if self.cfg.TEST.STATS.FULL_IMG and self.cfg.PROBLEM.NDIM == '2D':
+        if self.cfg.TEST.FULL_IMG and self.cfg.PROBLEM.NDIM == '2D':
             self._X, o_test_shape = check_downsample_division(self._X, len(self.cfg.MODEL.FEATURE_MAPS)-1)
             if self.cfg.DATA.TEST.LOAD_GT:
                 self._Y, _ = check_downsample_division(self._Y, len(self.cfg.MODEL.FEATURE_MAPS)-1)
@@ -1398,18 +1396,21 @@ class Base_Workflow(metaclass=ABCMeta):
         self.stats['iou_per_crop'] = self.stats['iou_per_crop'] / self.stats['patch_counter'] if self.stats['patch_counter'] != 0 else 0
 
         # Merge patches
-        self.stats['iou_per_image'] = self.stats['iou_per_image'] / image_counter
-        self.stats['ov_iou_per_image'] = self.stats['ov_iou_per_image'] / image_counter
+        self.stats['iou_merge_patches'] = self.stats['iou_merge_patches'] / image_counter
+        self.stats['ov_iou_merge_patches'] = self.stats['ov_iou_merge_patches'] / image_counter
 
         # Full image
         self.stats['iou'] = self.stats['iou'] / image_counter
         self.stats['loss'] = self.stats['loss'] / image_counter
         self.stats['ov_iou'] = self.stats['ov_iou'] / image_counter
 
-        if self.post_processing['per_image'] or self.post_processing['all_images']:
-            self.stats['iou_post'] = self.stats['iou_post'] / image_counter
-            self.stats['ov_iou_post'] = self.stats['ov_iou_post'] / image_counter
-
+        if self.post_processing['per_image']:
+            self.stats['iou_merge_patches_post'] = self.stats['iou_merge_patches_post'] / image_counter
+            self.stats['ov_iou_merge_patches_post'] = self.stats['ov_iou_merge_patches_post'] / image_counter
+        if self.post_processing['as_3D_stack']:
+            self.stats['iou_as_3D_stack_post'] = self.stats['iou_as_3D_stack_post'] / image_counter
+            self.stats['ov_iou_as_3D_stack_post'] = self.stats['ov_iou_as_3D_stack_post'] / image_counter
+            
     def print_stats(self, image_counter):
         """
         Print statistics.  
@@ -1421,15 +1422,14 @@ class Base_Workflow(metaclass=ABCMeta):
         """
         self.normalize_stats(image_counter)
         if self.cfg.DATA.TEST.LOAD_GT:
-            if self.cfg.TEST.STATS.PER_PATCH:
+            if not self.cfg.TEST.FULL_IMG:
                 print("Loss (per patch): {}".format(self.stats['loss_per_crop']))
                 print("Test Foreground IoU (per patch): {}".format(self.stats['iou_per_crop']))
                 print(" ")
-                if self.cfg.TEST.STATS.MERGE_PATCHES:
-                    print("Test Foreground IoU (merge patches): {}".format(self.stats['iou_per_image']))
-                    print("Test Overall IoU (merge patches): {}".format(self.stats['ov_iou_per_image']))
-                    print(" ")
-            if self.cfg.TEST.STATS.FULL_IMG:
+                print("Test Foreground IoU (merge patches): {}".format(self.stats['iou_merge_patches']))
+                print("Test Overall IoU (merge patches): {}".format(self.stats['ov_iou_merge_patches']))
+                print(" ")
+            else:
                 print("Loss (per image): {}".format(self.stats['loss']))
                 print("Test Foreground IoU (per image): {}".format(self.stats['iou']))
                 print("Test Overall IoU (per image): {}".format(self.stats['ov_iou']))
@@ -1439,11 +1439,14 @@ class Base_Workflow(metaclass=ABCMeta):
         """
         Print post-processing statistics.
         """
-        if self.post_processing['per_image'] or self.post_processing['all_images']:
-            print("Test Foreground IoU (post-processing): {}".format(self.stats['iou_post']))
-            print("Test Overall IoU (post-processing): {}".format(self.stats['ov_iou_post']))
+        if self.post_processing['per_image']:
+            print("Test Foreground IoU (merge patches - post-processing): {}".format(self.stats['iou_merge_patches_post']))
+            print("Test Overall IoU (merge patches - post-processing): {}".format(self.stats['ov_iou_merge_patches_post']))
             print(" ")
-
+        if self.post_processing['as_3D_stack']:
+            print("Test Foreground IoU (as 3D stack - post-processing): {}".format(self.stats['iou_as_3D_stack_post']))
+            print("Test Overall IoU (as 3D stack - post-processing): {}".format(self.stats['ov_iou_as_3D_stack_post']))
+            print(" ")     
 
     @abstractmethod
     def after_merge_patches(self, pred):
@@ -1525,10 +1528,10 @@ class Base_Workflow(metaclass=ABCMeta):
         ############################
         ### POST-PROCESSING (2D) ###
         ############################
-        if self.post_processing['all_images']:
+        if self.post_processing['as_3D_stack']:
             self.all_pred = np.concatenate(self.all_pred)
             self.all_gt = np.concatenate(self.all_gt) if self.cfg.DATA.TEST.LOAD_GT else None
-            self.all_pred, self.stats['iou_post'], self.stats['ov_iou_post'] = apply_post_processing(self.cfg, self.all_pred, self.all_gt)
+            self.all_pred, self.stats['iou_as_3D_stack_post'], self.stats['ov_iou_as_3D_stack_post'] = apply_post_processing(self.cfg, self.all_pred, self.all_gt)
             save_tif(np.expand_dims(self.all_pred,0), self.cfg.PATHS.RESULT_DIR.AS_3D_STACK_POST_PROCESSING, verbose=self.cfg.TEST.VERBOSE)
 
 def extract_patch_from_dataset(data, cfg, input_queue, extract_info_queue, verbose=False):

{biapy-3.3.2 → biapy-3.3.3}/biapy/engine/check_configuration.py

@@ -153,15 +153,9 @@ def check_configuration(cfg, jobname, check_data_paths=True):
     assert cfg.PROBLEM.TYPE in ['SEMANTIC_SEG', 'INSTANCE_SEG', 'CLASSIFICATION', 'DETECTION', 'DENOISING', 'SUPER_RESOLUTION', 'SELF_SUPERVISED'],\
         "PROBLEM.TYPE not in ['SEMANTIC_SEG', 'INSTANCE_SEG', 'CLASSIFICATION', 'DETECTION', 'DENOISING', 'SUPER_RESOLUTION', 'SELF_SUPERVISED']"
 
-    if cfg.PROBLEM.NDIM == "2D" and not cfg.TEST.STATS.PER_PATCH and not cfg.TEST.STATS.FULL_IMG:
-        raise ValueError("At least one between 'TEST.STATS.PER_PATCH' or 'TEST.STATS.FULL_IMG' needs to be True")
-
-    if cfg.PROBLEM.NDIM == '3D':
-        if not cfg.TEST.STATS.PER_PATCH and not cfg.TEST.STATS.MERGE_PATCHES and cfg.PROBLEM.TYPE != "CLASSIFICATION":
-            raise ValueError("At least one between 'TEST.STATS.PER_PATCH' or 'TEST.STATS.MERGE_PATCHES' needs to be True when 'PROBLEM.NDIM'=='3D'")
-        if cfg.TEST.STATS.FULL_IMG:
-            print("WARNING: TEST.STATS.FULL_IMG == True while using PROBLEM.NDIM == '3D'. As 3D images are usually 'huge'"
-                ", full image statistics will be disabled to avoid GPU memory overflow")
+    if cfg.PROBLEM.NDIM == '3D' and cfg.TEST.FULL_IMG:
+        print("WARNING: TEST.FULL_IMG == True while using PROBLEM.NDIM == '3D'. As 3D images are usually 'huge'"
+            ", full image statistics will be disabled to avoid GPU memory overflow")
 
     if cfg.LOSS.TYPE != "CE" and cfg.PROBLEM.TYPE not in ['SEMANTIC_SEG', 'DETECTION']:
         raise ValueError("Not implemented pipeline option: LOSS.TYPE != 'CE' only available in 'SEMANTIC_SEG' and 'DETECTION'")
@@ -215,12 +209,9 @@ def check_configuration(cfg, jobname, check_data_paths=True):
                     f"'DATA.PATCH_SIZE' set is {cfg.DATA.PATCH_SIZE}")
             if cfg.PROBLEM.NDIM == '3D':
                 raise ValueError("TorchVision model's for semantic segmentation are only available for 2D images")
-            if not cfg.TEST.STATS.FULL_IMG:
-                raise ValueError("With TorchVision models for semantic segmentation workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
+            if not cfg.TEST.FULL_IMG:
+                raise ValueError("With TorchVision models for semantic segmentation workflow only 'TEST.FULL_IMG' setting is available, so "
                     "please set it.")
-            if cfg.TEST.STATS.PER_PATCH or cfg.TEST.STATS.MERGE_PATCHES:
-                raise ValueError("With TorchVision models for semantic segmentation workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
-                    "please enable it and disable 'TEST.STATS.PER_PATCH' and 'TEST.STATS.MERGE_PATCHES'")
             if cfg.LOSS.TYPE != "CE":
                 raise ValueError("Only 'LOSS.TYPE' = 'CE' is available in semantic segmentation workflow using TorchVision models")
 
@@ -263,12 +254,9 @@ def check_configuration(cfg, jobname, check_data_paths=True):
             if cfg.TEST.ANALIZE_2D_IMGS_AS_3D_STACK:
                 raise ValueError("'TEST.ANALIZE_2D_IMGS_AS_3D_STACK' can not be activated with TorchVision models for instance segmentation "
                     "workflow")
-            if not cfg.TEST.STATS.FULL_IMG:
-                raise ValueError("With TorchVision models for instance segmentation workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
+            if not cfg.TEST.FULL_IMG:
+                raise ValueError("With TorchVision models for instance segmentation workflow only 'TEST.FULL_IMG' setting is available, so "
                     "please set it.")
-            if cfg.TEST.STATS.PER_PATCH or cfg.TEST.STATS.MERGE_PATCHES:
-                raise ValueError("With TorchVision models for instance segmentation workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
-                    "please enable it and disable 'TEST.STATS.PER_PATCH' and 'TEST.STATS.MERGE_PATCHES'")
 
     #### Detection ####
     if cfg.PROBLEM.TYPE == 'DETECTION':
@@ -301,12 +289,9 @@ def check_configuration(cfg, jobname, check_data_paths=True):
                 raise ValueError("TorchVision model's for detection are only available for 2D images")
             if cfg.TRAIN.ENABLE:
                 raise NotImplementedError # require bbox generator etc.
-            if not cfg.TEST.STATS.FULL_IMG:
-                raise ValueError("With TorchVision models for detection workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
+            if not cfg.TEST.FULL_IMG:
+                raise ValueError("With TorchVision models for detection workflow only 'TEST.FULL_IMG' setting is available, so "
                     "please set it.")
-            if cfg.TEST.STATS.PER_PATCH or cfg.TEST.STATS.MERGE_PATCHES:
-                raise ValueError("With TorchVision models for detection workflow only 'TEST.STATS.FULL_IMG' setting is available, so "
-                    "please enable it and disable 'TEST.STATS.PER_PATCH' and 'TEST.STATS.MERGE_PATCHES'")
 
     #### Super-resolution ####
     elif cfg.PROBLEM.TYPE == 'SUPER_RESOLUTION':
@@ -395,25 +380,25 @@ def check_configuration(cfg, jobname, check_data_paths=True):
     
     ### Pre-processing ###
     if cfg.DATA.PREPROCESS.TRAIN or cfg.DATA.PREPROCESS.TEST or cfg.DATA.PREPROCESS.VAL:
-        if cfg.DATA.PREPROCESS.RESIZE.ACTIVATE:
+        if cfg.DATA.PREPROCESS.RESIZE.ENABLE:
             if cfg.PROBLEM.TYPE == 'DETECTION':
                 raise ValueError('Resizing preprocessing is not available for the DETECTION workflow.')
             if cfg.PROBLEM.NDIM == '3D':
                 if cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE == (512,512):
                     opts.extend(['DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE', (512,512,512)])
                 elif len(cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE) != 3:
-                    raise ValueError("When 'PROBLEM.NDIM' is 3D, cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE must indicate desired size for each dimension."
+                    raise ValueError("When 'PROBLEM.NDIM' is 3D, 'DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE' must indicate desired size for each dimension."
                                     f"Given shape ({cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE}) is not compatible.")
             if cfg.PROBLEM.NDIM == '2D' and len(cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE) != 2:
-                    raise ValueError("When 'PROBLEM.NDIM' is 2D, cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE must indicate desired size for each dimension."
+                    raise ValueError("When 'PROBLEM.NDIM' is 2D, 'DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE' must indicate desired size for each dimension."
                                     f"Given shape ({cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE}) is not compatible.")
             for i, s in enumerate(cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE):
                 if cfg.DATA.PATCH_SIZE[i] > s:
-                    raise ValueError(f'cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE {cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE} can not be smaller than cfg.DATA.PATCH_SIZE {cfg.DATA.PATCH_SIZE}.')
-        if cfg.DATA.PREPROCESS.CANNY.ACTIVATE and cfg.PROBLEM.NDIM != '2D':
+                    raise ValueError(f"'DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE' {cfg.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE} can not be smaller than 'DATA.PATCH_SIZE' {cfg.DATA.PATCH_SIZE}.")
+        if cfg.DATA.PREPROCESS.CANNY.ENABLE and cfg.PROBLEM.NDIM != '2D':
             raise ValueError("Canny or edge detection can not be activated when 'PROBLEM.NDIM' is 2D.")
         if not cfg.DATA.PREPROCESS.VAL and cfg.DATA.VAL.FROM_TRAIN and cfg.DATA.PREPROCESS.TRAIN:
-            raise ValueError('When validation data comes from train and cfg.DATA.PREPROCESS.TRAIN is True, cfg.DATA.PREPROCESS.VAL also needs to be True.')
+            raise ValueError("When 'DATA.VAL.FROM_TRAIN' is True and 'DATA.PREPROCESS.TRAIN' is True, 'DATA.PREPROCESS.VAL' also needs to be True.")
         if cfg.DATA.PREPROCESS.MATCH_HISTOGRAM.ENABLE:
             if not os.path.exists(cfg.DATA.PREPROCESS.MATCH_HISTOGRAM.REFERENCE_PATH):
                 raise ValueError(f"Path pointed by 'DATA.PREPROCESS.MATCH_HISTOGRAM.REFERENCE_PATH' does not exist: {cfg.DATA.PREPROCESS.MATCH_HISTOGRAM.REFERENCE_PATH}")

{biapy-3.3.2 → biapy-3.3.3}/biapy/engine/detection.py

@@ -45,9 +45,9 @@ class Detection_Workflow(Base_Workflow):
         self.stats['d_recall'] = 0
         self.stats['d_f1'] = 0
 
-        self.stats['d_precision_per_crop'] = 0
-        self.stats['d_recall_per_crop'] = 0
-        self.stats['d_f1_per_crop'] = 0
+        self.stats['d_precision_merge_patches'] = 0
+        self.stats['d_recall_merge_patches'] = 0
+        self.stats['d_f1_merge_patches'] = 0
         
         self.original_test_mask_path = self.prepare_detection_data()
 
@@ -451,11 +451,11 @@ class Detection_Workflow(Base_Workflow):
             for nr in range(len(self.cell_count_lines)):
                 csvwriter.writerow([nr+1] + self.cell_count_lines[nr])
         if self.cfg.DATA.TEST.LOAD_GT or self.cfg.DATA.TEST.USE_VAL_AS_TEST:
-            if self.cfg.TEST.STATS.PER_PATCH:
-                self.stats['d_precision_per_crop'] = self.stats['d_precision_per_crop'] / image_counter
-                self.stats['d_recall_per_crop'] = self.stats['d_recall_per_crop'] / image_counter
-                self.stats['d_f1_per_crop'] = self.stats['d_f1_per_crop'] / image_counter
-            if self.cfg.TEST.STATS.FULL_IMG:
+            if not self.cfg.TEST.FULL_IMG:
+                self.stats['d_precision_merge_patches'] = self.stats['d_precision_merge_patches'] / image_counter
+                self.stats['d_recall_merge_patches'] = self.stats['d_recall_merge_patches'] / image_counter
+                self.stats['d_f1_merge_patches'] = self.stats['d_f1_merge_patches'] / image_counter
+            else:
                 self.stats['d_precision'] = self.stats['d_precision'] / image_counter
                 self.stats['d_recall'] = self.stats['d_recall'] / image_counter
                 self.stats['d_f1'] = self.stats['d_f1'] / image_counter
@@ -469,7 +469,7 @@ class Detection_Workflow(Base_Workflow):
         pred : Torch Tensor
             Model prediction.
         """
-        self.detection_process(pred, self.processing_filenames, ['d_precision_per_crop', 'd_recall_per_crop', 'd_f1_per_crop'])
+        self.detection_process(pred, self.processing_filenames, ['d_precision_merge_patches', 'd_recall_merge_patches', 'd_f1_merge_patches'])
 
     def after_merge_patches_by_chunks_proccess_patch(self, filename):
         """
@@ -618,7 +618,7 @@ class Detection_Workflow(Base_Workflow):
             ##################
             ### FULL IMAGE ###
             ##################
-            if self.cfg.TEST.STATS.FULL_IMG:
+            if self.cfg.TEST.FULL_IMG:
                 # Make the prediction
                 with torch.cuda.amp.autocast():
                     pred = self.model_call_func(self._X)
@@ -701,11 +701,11 @@ class Detection_Workflow(Base_Workflow):
 
         print("Detection specific metrics:")
         if self.cfg.DATA.TEST.LOAD_GT or self.cfg.DATA.TEST.USE_VAL_AS_TEST:
-            if self.cfg.TEST.STATS.PER_PATCH:
-                print("Detection - Test Precision (merge patches): {}".format(self.stats['d_precision_per_crop']))
-                print("Detection - Test Recall (merge patches): {}".format(self.stats['d_recall_per_crop']))
-                print("Detection - Test F1 (merge patches): {}".format(self.stats['d_f1_per_crop']))
-            if self.cfg.TEST.STATS.FULL_IMG:
+            if not self.cfg.TEST.FULL_IMG:
+                print("Detection - Test Precision (merge patches): {}".format(self.stats['d_precision_merge_patches']))
+                print("Detection - Test Recall (merge patches): {}".format(self.stats['d_recall_merge_patches']))
+                print("Detection - Test F1 (merge patches): {}".format(self.stats['d_f1_merge_patches']))
+            else:
                 print("Detection - Test Precision (per image): {}".format(self.stats['d_precision']))
                 print("Detection - Test Recall (per image): {}".format(self.stats['d_recall']))
                 print("Detection - Test F1 (per image): {}".format(self.stats['d_f1']))