biapy 3.3.1__tar.gz → 3.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biapy
-Version: 3.3.1
+Version: 3.3.3
 Summary: BiaPy: Bioimage analysis pipelines in Python
 Home-page: https://github.com/BiaPyX/BiaPy
 Author: BiaPy Contributors
@@ -52,29 +52,34 @@ Requires-Dist: imagecodecs>=2023.3.16
       <img src="https://img.shields.io/badge/IEEE-Paper-00629B.svg" /></a>
 </p>
 
-[BiaPy](https://github.com/BiaPyX/BiaPy) is an open source Python library for building bioimage analysis pipelines. This repository is actively under development by the Biomedical Computer Vision group at the [University of the Basque Country](https://www.ehu.eus/en/en-home) and the [Donostia International Physics Center](http://dipc.ehu.es/). 
+[BiaPy](https://biapyx.github.io) is an open source ready-to-use all-in-one library that provides deep-learning workflows for a large variety of bioimage analysis tasks, including 2D and 3D [semantic segmentation](https://biapy.readthedocs.io/en/latest/workflows/semantic_segmentation.html), [instance segmentation](https://biapy.readthedocs.io/en/latest/workflows/instance_segmentation.html), [object detection](https://biapy.readthedocs.io/en/latest/workflows/detection.html), [image denoising](https://biapy.readthedocs.io/en/latest/workflows/denoising.html), [single image super-resolution](https://biapy.readthedocs.io/en/latest/workflows/super_resolution.html), [self-supervised learning](https://biapy.readthedocs.io/en/latest/workflows/self_supervision.html) and [image classification](https://biapy.readthedocs.io/en/latest/workflows/classification.html). 
+                        
+BiaPy is a versatile platform designed to accommodate both proficient computer scientists and users less experienced in programming. It offers diverse and user-friendly access points to our workflows.
+
+This repository is actively under development by the Biomedical Computer Vision group at the [University of the Basque Country](https://www.ehu.eus/en/en-home) and the [Donostia International Physics Center](http://dipc.ehu.es/).       
 
-The library provides an easy way to create image processing pipelines that are typically used in the analysis of biology microscopy images in 2D and 3D. Namely, BiaPy contains ready-to-use solutions for the tasks of [semantic segmentation](https://biapy.readthedocs.io/en/latest/workflows/semantic_segmentation.html), [instance segmentation](https://biapy.readthedocs.io/en/latest/workflows/instance_segmentation.html), [object detection](https://biapy.readthedocs.io/en/latest/workflows/detection.html), [image denoising](https://biapy.readthedocs.io/en/latest/workflows/denoising.html), [single image super-resolution](https://biapy.readthedocs.io/en/latest/workflows/super_resolution.html), [self-supervised learning](https://biapy.readthedocs.io/en/latest/workflows/self_supervision.html) and [image classification](https://biapy.readthedocs.io/en/latest/workflows/classification.html). The source code is based on Pytorch as backend. Given BiaPy’s deep learning based core, a machine with a graphics processing unit (GPU) is recommended for fast training and execution.                                                                                                                                
 ![BiaPy workflows](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy-workflow-readme.svg)
 
 ## Description video
-Find a gentle introduction to BiaPy in this video of Ignacio Arganda-Carreras in [the Virtual Pub of Euro-BioImaging](https://www.eurobioimaging.eu/about-us/virtual-pub):
+Find a comprehensive overview of BiaPy and its functionality in the following videos:
+
+| [![BiaPy history and GUI demo](./img/BiaPy_presentation_and_demo_at_RTmfm.jpg)](https://www.youtube.com/watch?v=Gnm-VsZQ6Cc "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> <span style="font-weight:normal">BiaPy history and GUI demo at [RTmfm](https://rtmfm.cnrs.fr/en/) by Ignacio Arganda-Carreras and Daniel Franco-Barranco.</span> |
+|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [![BiaPy presentation](./img/BiaPy-Euro-BioImaging-youtube.png)](https://youtu.be/6eYtX-ySpc0 "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> BiaPy presentation at [Virtual Pub of Euro-BioImaging](https://www.eurobioimaging.eu/) by Ignacio Arganda-Carreras.                                                                      |                          |                          |                              |                           |
 
-[![BiaPy description video](./img/BiaPy-Euro-BioImaging-youtube.png)](https://www.youtube.com/watch?v=t5cqpjWQS9Q "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines")
 ## User interface
 
 You can also use BiaPy through our graphical user interface (GUI).
 
 ![BiaPy GUI](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy_GUI_main_page.png)
 
-### Download BiaPy GUI for you OS
+## Download BiaPy GUI for you OS
 
 - [Windows 64-bit](https://drive.google.com/uc?export=download&id=1iV0wzdFhpCpBCBgsameGyT3iFyQ6av5o) 
 - [Linux 64-bit](https://drive.google.com/uc?export=download&id=13jllkLTR6S3yVZLRdMwhWUu7lq3HyJsD) 
 - [macOS 64-bit](https://drive.google.com/uc?export=download&id=1fIpj9A8SWIN1fABEUAS--DNhOHzqSL7f) 
 
-### Project's page
-[[BiaPy GUI](https://github.com/BiaPyX/BiaPy-GUI)]
+Project's page: [[BiaPy GUI](https://github.com/BiaPyX/BiaPy-GUI)]
 
 ## Applications using BiaPy
 

{biapy-3.3.1 → biapy-3.3.3}/README.md

@@ -17,29 +17,34 @@
       <img src="https://img.shields.io/badge/IEEE-Paper-00629B.svg" /></a>
 </p>
 
-[BiaPy](https://github.com/BiaPyX/BiaPy) is an open source Python library for building bioimage analysis pipelines. This repository is actively under development by the Biomedical Computer Vision group at the [University of the Basque Country](https://www.ehu.eus/en/en-home) and the [Donostia International Physics Center](http://dipc.ehu.es/). 
+[BiaPy](https://biapyx.github.io) is an open source ready-to-use all-in-one library that provides deep-learning workflows for a large variety of bioimage analysis tasks, including 2D and 3D [semantic segmentation](https://biapy.readthedocs.io/en/latest/workflows/semantic_segmentation.html), [instance segmentation](https://biapy.readthedocs.io/en/latest/workflows/instance_segmentation.html), [object detection](https://biapy.readthedocs.io/en/latest/workflows/detection.html), [image denoising](https://biapy.readthedocs.io/en/latest/workflows/denoising.html), [single image super-resolution](https://biapy.readthedocs.io/en/latest/workflows/super_resolution.html), [self-supervised learning](https://biapy.readthedocs.io/en/latest/workflows/self_supervision.html) and [image classification](https://biapy.readthedocs.io/en/latest/workflows/classification.html). 
+                        
+BiaPy is a versatile platform designed to accommodate both proficient computer scientists and users less experienced in programming. It offers diverse and user-friendly access points to our workflows.
+
+This repository is actively under development by the Biomedical Computer Vision group at the [University of the Basque Country](https://www.ehu.eus/en/en-home) and the [Donostia International Physics Center](http://dipc.ehu.es/).       
 
-The library provides an easy way to create image processing pipelines that are typically used in the analysis of biology microscopy images in 2D and 3D. Namely, BiaPy contains ready-to-use solutions for the tasks of [semantic segmentation](https://biapy.readthedocs.io/en/latest/workflows/semantic_segmentation.html), [instance segmentation](https://biapy.readthedocs.io/en/latest/workflows/instance_segmentation.html), [object detection](https://biapy.readthedocs.io/en/latest/workflows/detection.html), [image denoising](https://biapy.readthedocs.io/en/latest/workflows/denoising.html), [single image super-resolution](https://biapy.readthedocs.io/en/latest/workflows/super_resolution.html), [self-supervised learning](https://biapy.readthedocs.io/en/latest/workflows/self_supervision.html) and [image classification](https://biapy.readthedocs.io/en/latest/workflows/classification.html). The source code is based on Pytorch as backend. Given BiaPy’s deep learning based core, a machine with a graphics processing unit (GPU) is recommended for fast training and execution.                                                                                                                                
 ![BiaPy workflows](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy-workflow-readme.svg)
 
 ## Description video
-Find a gentle introduction to BiaPy in this video of Ignacio Arganda-Carreras in [the Virtual Pub of Euro-BioImaging](https://www.eurobioimaging.eu/about-us/virtual-pub):
+Find a comprehensive overview of BiaPy and its functionality in the following videos:
+
+| [![BiaPy history and GUI demo](./img/BiaPy_presentation_and_demo_at_RTmfm.jpg)](https://www.youtube.com/watch?v=Gnm-VsZQ6Cc "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> <span style="font-weight:normal">BiaPy history and GUI demo at [RTmfm](https://rtmfm.cnrs.fr/en/) by Ignacio Arganda-Carreras and Daniel Franco-Barranco.</span> |
+|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [![BiaPy presentation](./img/BiaPy-Euro-BioImaging-youtube.png)](https://youtu.be/6eYtX-ySpc0 "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines") <br> BiaPy presentation at [Virtual Pub of Euro-BioImaging](https://www.eurobioimaging.eu/) by Ignacio Arganda-Carreras.                                                                      |                          |                          |                              |                           |
 
-[![BiaPy description video](./img/BiaPy-Euro-BioImaging-youtube.png)](https://www.youtube.com/watch?v=t5cqpjWQS9Q "BiaPy: a ready-to-use library for Bioimage Analysis Pipelines")
 ## User interface
 
 You can also use BiaPy through our graphical user interface (GUI).
 
 ![BiaPy GUI](https://raw.githubusercontent.com/BiaPyX/BiaPy/master/img/BiaPy_GUI_main_page.png)
 
-### Download BiaPy GUI for you OS
+## Download BiaPy GUI for you OS
 
 - [Windows 64-bit](https://drive.google.com/uc?export=download&id=1iV0wzdFhpCpBCBgsameGyT3iFyQ6av5o) 
 - [Linux 64-bit](https://drive.google.com/uc?export=download&id=13jllkLTR6S3yVZLRdMwhWUu7lq3HyJsD) 
 - [macOS 64-bit](https://drive.google.com/uc?export=download&id=1fIpj9A8SWIN1fABEUAS--DNhOHzqSL7f) 
 
-### Project's page
-[[BiaPy GUI](https://github.com/BiaPyX/BiaPy-GUI)]
+Project's page: [[BiaPy GUI](https://github.com/BiaPyX/BiaPy-GUI)]
 
 ## Applications using BiaPy
 

{biapy-3.3.1 → biapy-3.3.3}/biapy/_biapy.py

@@ -290,12 +290,23 @@ class BiaPy():
         output_sample_path = os.path.join(bmz_cfg['build_dir'], "test-output.npy")
         test_input = self.workflow.bmz_test_input if 'test_input' not in bmz_cfg else bmz_cfg['test_input']
         test_output = self.workflow.bmz_test_output if 'test_output' not in bmz_cfg else bmz_cfg['test_output']
+        
         if test_input.ndim == 3:
             np.save(input_sample_path, test_input.permute((2, 0 ,1)).unsqueeze(0))
-            np.save(output_sample_path, test_output.permute((2, 0 ,1)).unsqueeze(0))
+            in_axis = ["bcyx"]
         else:
             np.save(input_sample_path, test_input.permute((3, 0 ,1, 2)).unsqueeze(0))
+            in_axis = ["bczyx"]
+
+        if test_output.ndim == 3:
+            np.save(output_sample_path, test_output.permute((2, 0 ,1)).unsqueeze(0))
+            out_axis = ["bcyx"]
+        elif test_output.ndim == 4:
             np.save(output_sample_path, test_output.permute((3, 0 ,1, 2)).unsqueeze(0))
+            out_axis = ["bczyx"]
+        else:
+            np.save(output_sample_path, test_output.unsqueeze(0))
+            out_axis = ["bc"]
 
         # Name of the model
         if 'model_name' in bmz_cfg:
@@ -359,8 +370,8 @@ class BiaPy():
             # these are passed as list because we support multiple inputs / outputs per model
             test_inputs=[input_sample_path],
             test_outputs=[output_sample_path],
-            input_axes=["bcyx"] if 'input_axes' not in bmz_cfg else bmz_cfg['input_axes'],
-            output_axes=["bcyx"] if 'output_axes' not in bmz_cfg else bmz_cfg['output_axes'],
+            input_axes=in_axis if 'input_axes' not in bmz_cfg else bmz_cfg['input_axes'],
+            output_axes=out_axis if 'output_axes' not in bmz_cfg else bmz_cfg['output_axes'],
             # where to save the model zip, how to call the model and a short description of it
             output_path=os.path.join(bmz_cfg['build_dir'], "model.zip"),
             name=model_name,
@@ -395,5 +406,4 @@ class BiaPy():
             dist.barrier()
             dist.destroy_process_group()
 
-        print("FINISHED JOB {} !!".format(self.job_identifier))
-        sys.exit(0)
+        print("FINISHED JOB {} !!".format(self.job_identifier))

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

@@ -229,7 +229,7 @@ class Config:
 
         # Resize datasets
         _C.DATA.PREPROCESS.RESIZE = CN()
-        _C.DATA.PREPROCESS.RESIZE.ACTIVATE = False
+        _C.DATA.PREPROCESS.RESIZE.ENABLE = False
         # Desired resize size. when using 3D data, size must be also in 3D (ex. (512,512,512))
         _C.DATA.PREPROCESS.RESIZE.OUTPUT_SHAPE = (512,512)
         # interpolation order: {0: Nearest-neighbor, 1: Bi-linear (default), 2: Bi-quadratic, 3: Bi-cubic, 4: Bi-quartic, 5: Bi-quintic}
@@ -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.
@@ -247,7 +247,7 @@ class Config:
 
         # Gaussian blur
         _C.DATA.PREPROCESS.GAUSSIAN_BLUR = CN()
-        _C.DATA.PREPROCESS.GAUSSIAN_BLUR.ACTIVATE = False
+        _C.DATA.PREPROCESS.GAUSSIAN_BLUR.ENABLE = False
         # Standard deviation for Gaussian kernel.
         _C.DATA.PREPROCESS.GAUSSIAN_BLUR.SIGMA = 1
         # The mode parameter determines how the array borders are handled: {‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’} ‘constant’ value = 0
@@ -258,20 +258,17 @@ class Config:
 
         # Median blur
         _C.DATA.PREPROCESS.MEDIAN_BLUR = CN()
-        _C.DATA.PREPROCESS.MEDIAN_BLUR.ACTIVATE = False
-        # is a N-D array of 1’s and 0’s with the same number of dimension than image. 
-        # If None, footprint will be a N-D array with 3 elements for each dimension (e.g., vector, square, cube, etc.)
-        _C.DATA.PREPROCESS.MEDIAN_BLUR.FOOTPRINT = None
+        _C.DATA.PREPROCESS.MEDIAN_BLUR.ENABLE = False
         
-        # Histogram matching
+        # Histogram matching. More info at: https://en.wikipedia.org/wiki/Histogram_matching
         _C.DATA.PREPROCESS.MATCH_HISTOGRAM = CN()
-        _C.DATA.PREPROCESS.MATCH_HISTOGRAM.ACTIVATE = False
+        _C.DATA.PREPROCESS.MATCH_HISTOGRAM.ENABLE = False
         # the path of the reference images, from which the reference histogram will be extracted 
         _C.DATA.PREPROCESS.MATCH_HISTOGRAM.REFERENCE_PATH = os.path.join("user_data", 'test', 'x')
 
-        # Contrast Limited Adaptive Histogram Equalization
+        # Contrast Limited Adaptive Histogram Equalization. More info at: https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_AHE
         _C.DATA.PREPROCESS.CLAHE = CN()
-        _C.DATA.PREPROCESS.CLAHE.ACTIVATE = False
+        _C.DATA.PREPROCESS.CLAHE.ENABLE = False
         # Defines the shape of contextual regions used in the algorithm. 
         # By default, kernel_size is 1/8 of image height by 1/8 of its width.
         _C.DATA.PREPROCESS.CLAHE.KERNEL_SIZE = None
@@ -280,7 +277,7 @@ class Config:
 
         # Canny or edge detection (only 2D - grayscale or RGB)
         _C.DATA.PREPROCESS.CANNY = CN()
-        _C.DATA.PREPROCESS.CANNY.ACTIVATE = False
+        _C.DATA.PREPROCESS.CANNY.ENABLE = False
         # Lower bound for hysteresis thresholding (linking edges). If None, low_threshold is set to 10% of dtype’s max.
         _C.DATA.PREPROCESS.CANNY.LOW_THRESHOLD = None
         # Upper bound for hysteresis thresholding (linking edges). If None, high_threshold is set to 20% of dtype’s max.
@@ -787,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.)
@@ -833,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
@@ -961,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.1 → biapy-3.3.3}/biapy/data/pre_processing.py

@@ -1172,10 +1172,10 @@ def preprocess_data(cfg, x_data=[], y_data=[], is_2d=True, is_y_mask=False):
         In case of using a list, the format of the images remains the same. Each item in the list
         corresponds to a different image.
       
-    is_2d: Bool, optional
+    is_2d: bool, optional
         A boolean flag indicating whether the reference data for histogram matching is 2D or not. Defaults to True.
       
-    is_y_mask: Bool, optional
+    is_y_mask: bool, optional
         is_y_mask is a boolean parameter that indicates whether the y_data is a mask or not. If
         it is set to True, the resize operation for y_data will use the nearest neighbor interpolation
         method (order=0), otherwise it will use the interpolation method specified in the cfg.RESIZE.ORDER
@@ -1190,7 +1190,8 @@ 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,
                 output_shape = cfg.RESIZE.OUTPUT_SHAPE,
@@ -1215,27 +1216,32 @@ 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,
                 high_threshold = cfg.CANNY.HIGH_THRESHOLD,

{biapy-3.3.1 → 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
@@ -588,7 +590,7 @@ class Base_Workflow(metaclass=ABCMeta):
         if self.val_generator is not None:
             print("Val loss: {}".format(val_best_loss))
             for i in range(len(self.metric_names)):
-                print("Val {}: {}".format(self.metric_names[i], val_best_metric))
+                print("Val {}: {}".format(self.metric_names[i], val_best_metric[i]))
 
         print('Finished Training')
 
@@ -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):