added nearly all of estimate_white's post processing (particles removal)

As a result, the implementation of estimate_white is getting closer to completion. However, the performance of fiji's gray morphology is very poor, which makes it practically unusable with the default settings provided in the original code (estimateWhiteFluoImageTelemos)

Bug 2623 - Faire un traitement automatique pour les images du projet lipase

preprocessing.py

@@ -5,6 +5,21 @@ from ij.plugin import ImageCalculator
 from catalog import ImageCatalog, Sequence
 
 
+def imagej_run_image_command(image, command, options):
+    """performs the given imagej command on the given image
+
+    :param ImagePlus image:
+    :param str command: imagej command (eg "Gray Morphology")
+    :param str options: imagej options (eg "radius=1 type=square operator=open")
+
+    wrapper around IJ.run (https://imagej.nih.gov/ij/developer/api/ij/IJ.html#run-ij.ImagePlus-java.lang.String-java.lang.String-) which raises an exception on error
+    """
+    IJ.run(image, command, options)
+    error_message = IJ.getErrorMessage()
+    if error_message is not None:
+        raise Exception('The command "%s" with options "%s" failed because of the following error : %s' % (command, options, error_message))
+
+
 def compute_max(images_file_path):
     """Computes for each pixel position the maximum at this position in all input images.
 
@@ -45,12 +60,48 @@ def replace_outer_frame(image, band_width):
     return image
 
 
+def perform_gray_morphology(image, operator, structuring_element_shape, structuring_element_radius):
+    """
+    :param ImagePlus image:
+    :param str operator: eg 'open'
+    :param str structuring_element_shape: eg 'square'
+    :param int structuring_element_radius:
+    """
+    assert operator not in ['fast open', 'fast erode'], "as of 13/09/2019, fast operators such as 'fast erode' seem broken in fiji (the resulting image is not at all similar to their slow equivalent)"
     
-def estimate_white(sequences, channel_ids, dark=None):
+    processor = image.getProcessor()
+    convert_to_byte = False
+    if processor.getBitDepth() != 8:
+        convert_to_byte = True
+        min_value = processor.getMin()
+        max_value = processor.getMax()
+        print("warning: downgrading image to byte as imagej's Gray Morphology processing doesn't handle 16bit images (range=[%d, %d])" % (min_value, max_value))
+        do_scaling = True
+        image.setProcessor(processor.convertToByte(do_scaling))
+    print("before gray morphology")
+    assert structuring_element_radius < 11, "the radius of the structuring element is too big (%d); using it with Fiji's 'Gray Morphology' tool would result in very long computations." % structuring_element_radius
+    imagej_run_image_command(image, "Gray Morphology", "radius=%d type=%s operator=%s" % (structuring_element_radius, structuring_element_shape, operator))
+    print("after gray morphology")
+
+
+class WhiteEstimator(object):
+
+    def __init__(self, open_size, close_size, average_size):
+        self.open_size = open_size
+        self.close_size = close_size
+        self.average_size = average_size
+
+    def _remove_particles(self, white_estimate):
+        perform_gray_morphology(white_estimate, operator='open', structuring_element_shape='square', structuring_element_radius=(self.open_size + 1)/2)
+        perform_gray_morphology(white_estimate, operator='close', structuring_element_shape='square', structuring_element_radius=(self.close_size + 1)/2)
+
+    def estimate_white(self, sequences, channel_ids, dark=None):
         """Estimation of the white fluorescence image shape of synchrotron light from experimental images of Telemos microscope.
 
-    :param list(Sequence) sequences:
-    :param list(str) channel_ids:
+        :param list(Sequence) sequences: the sequences to consider
+        :param list(str) channel_ids: the channels to consider, eg ['DM300_327-353_fluo']
+        :param WhiteEstimatorSettings white_estimator_settings: 
+
         :param ImagePlus or None dark:
         :rtype ImagePlus:
         Code adapted from matlab telemosToolbx's estimatedwhiteFluoImageTelemos function
@@ -151,16 +202,39 @@ def estimate_white(sequences, channel_ids, dark=None):
 
         white_estimate = compute_max(images_file_path)
         
-    # modifiy spurious pixels on the side of the images
+        # modify spurious pixels on the side of the images
         try:
             replace_outer_frame(white_estimate, 3)
         except NotImplementedError as error:
             print('warning: replace_outer_frame is not implemented yet')
 
+        self._remove_particles(white_estimate)
         
         return white_estimate
 
 
+class InteractiveWhiteEstimator(WhiteEstimator):
+
+    def __init__(self, open_size, close_size, average_size):
+        WhiteEstimator.__init__(self, open_size, close_size, average_size)
+
+    def _remove_particles(self, white):
+        """shows the image to a user so that he can visually check that the particles have been removed correctly in the given image
+        """
+        raise NotImplementedError()
+        # part_rem_settings_are_good = False
+        # while part_rem_settings_are_good == False:
+        #     # perform opening to remove white particles
+        #     IJ.run( white_estimate, "Gray Morphology", "radius=1 type=square operator=open" )
+        #     # run("Gray Morphology", "radius=1 type=square operator=open");
+        #     # IJ.run( input_image_plus_copy, "Skeletonize (2D/3D)", "" )
+        #     # perform 
+        #     if white_estimator_settings.particles_are_removed():
+        #         part_rem_settings_are_good = true
+        #     else
+        #         white_estimator_settings.ask
+
+
 def find_white_reference_image(white_estimate, white_z_stack):
     """Find the white reference Image among a z stack of reference image the most correlated to the white image estimated from a serie of acquisition.
 
@@ -263,7 +337,8 @@ def test_preprocessing():
     """Test preprocessing."""
     catalog = ImageCatalog('/Users/graffy/ownCloud/ipr/lipase/raw-images')
     sequence = catalog.sequences['res_soleil2018/GGH/GGH_2018_cin2_phiG_I_327_vis_-40_1/Pos2']
-    white_estimate = estimate_white([sequence], ['DM300_327-353_fluo'])
+    white_estimator = WhiteEstimator(open_size=75, close_size=75, average_size=75)
+    white_estimate = white_estimator.estimate_white([sequence], ['DM300_327-353_fluo'])
     find_white_reference_image(white_estimate, sequence.get_white())
 
 

tests/test0001.py

@@ -16,12 +16,15 @@ sys.path.append(lipase_src_root_path)  # necessary if run from fiji as script ot
 from ij import IJ
 from lipase import Lipase, ImageLogger
 from catalog import ImageCatalog
+from preprocessing import WhiteEstimator
 
 def run_script():
     catalog = ImageCatalog(raw_images_root_path)  # eg '/Users/graffy/ownCloud/ipr/lipase/raw-images'
     lipase = Lipase(catalog, debugger=ImageLogger())
     sequence = catalog.sequences['res_soleil2018/GGH/GGH_2018_cin2_phiG_I_327_vis_-40_1/Pos2']
-    white_estimate = lipase.estimate_white(sequence, 'DM300_327-353_fluo')
+    # white_estimator = WhiteEstimator(open_size=75, close_size=75, average_size=75)
+    white_estimator = WhiteEstimator(open_size=3, close_size=3, average_size=3)
+    white_estimate = white_estimator.estimate_white([sequence], ['DM300_327-353_fluo'])
     print(white_estimate)
     IJ.saveAsTiff(white_estimate, './white_estimate.tiff')
     print('end')