small-fish-gui 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

small_fish_gui/gui/_napari_widgets.py

@@ -1,14 +1,29 @@
 """
 Submodule containing custom class for napari widgets
 """
+import os
 import numpy as np
 import pandas as pd
 import bigfish.detection as detection
-from napari.layers import Labels, Points
+import bigfish.stack as stack
+from skimage.segmentation import find_boundaries
+from ..pipeline._bigfish_wrapers import _apply_log_filter, _local_maxima_mask
+
+from napari.layers import Labels, Points, Image
+from napari.utils.events import Event, EmitterGroup
 from magicgui import magicgui
+from magicgui.widgets import SpinBox, Container
+from bigfish.detection import spots_thresholding, automated_threshold_setting
+from napari.types import LayerDataTuple
 
 from abc import ABC, abstractmethod
-from typing import Tuple
+from typing import Tuple, List
+from ..utils import compute_anisotropy_coef
+
+from AF_eraser import remove_autofluorescence_RANSACfit
+from pathlib import Path
+from ..interface import open_image
+
 
 class NapariWidget(ABC) :
     """
@@ -25,6 +40,8 @@ class NapariWidget(ABC) :
         """
         pass
 
+# Corrector widgets
+
 class ClusterWidget(NapariWidget) :
     """
     Widget for clusters interaction are all init with cluster_layer and single_layer
@@ -262,9 +279,6 @@ class ClusterMerger(ClusterWidget) :
 
         return merge_cluster
 
-
-
-
 class ClusterUpdater(NapariWidget) :
     """
     Relaunch clustering algorithm taking into consideration new spots, new clusters and deleted clusters.
@@ -510,4 +524,402 @@ class ClusterCleaner(ClusterWizard) :
                 self.cluster_layer.refresh()
 
         self.cluster_layer.events.features.connect(delete_empty_cluster)
-        
+
+
+
+#Detection widgets
+class BackgroundRemover(NapariWidget) :
+    def __init__(
+        self, 
+        signal : Image, 
+        voxel_size : tuple,
+        other_image : np.ndarray = None, 
+        ) :
+        
+        self.other_image = other_image
+        self.signal_layer = signal
+        self.signal_data_raw = np.array(signal.data)
+        self.voxel_size = voxel_size
+        self.scale = compute_anisotropy_coef(self.voxel_size)
+
+        self.signal_args = {
+                "name" : "raw signal",
+                "colormap" : 'green',
+                "scale" : self.scale,
+                "blending" : 'additive'
+            }
+
+        self.events = EmitterGroup(source=self.signal_layer, auto_connect=False, background_substraction_event = None)
+
+        super().__init__()
+        if self.other_image is None : self.disable_channel() #Image stack is None when image stack is not is_multichannel
+        self.reset_widget = self._create_reset_button()
+
+    def disable_channel(self) :
+        self.widget.channel.enabled = False
+
+    def _create_widget(self) :
+        @magicgui(
+            channel = {'min' : 0, 'max' : 0 if self.other_image is None else self.other_image.shape[0] - 1},
+            max_trial = {'min' : 0},
+        )
+        def remove_background(
+            background_path : Path,
+            channel : int,
+            max_trial : int = 100,
+        )-> LayerDataTuple :
+
+            print("Substracting background ...", end="", flush=True)
+            self.gui = remove_background
+
+            if os.path.isfile(background_path) :
+                background = open_image(str(background_path))
+            elif self.other_image is None :
+                raise FileNotFoundError(f"{background_path} is not a valid file.")
+            else :
+                background = self.other_image[channel]
+            if not background.shape == self.signal_data_raw.shape : raise ValueError(f"Shape missmatch between signal and background : {self.signal_data_raw.shape} ; {background.shape}")
+
+            result, score = remove_autofluorescence_RANSACfit(
+                signal=self.signal_data_raw.copy(),
+                background=background,
+                max_trials=max_trial
+            )
+
+            print("\rBackground substraction done.")
+            self.events.background_substraction_event(new_signal_array = result)
+            
+            return (result, self.signal_args, 'image')
+        return remove_background
+    
+    def _create_reset_button(self) :
+
+        @magicgui(call_button= "Reset signal")
+        def reset_signal() -> LayerDataTuple :
+            self.events.background_substraction_event(new_signal_array = self.signal_data_raw)
+            return (self.signal_data_raw, self.signal_args, 'image')
+        return reset_signal
+
+
+class SpotDetector(NapariWidget) :
+    """
+    Widget aimed at helping user to set detection parameters : threshold, spot radius and so on...
+    """
+
+    def __init__(
+        self,
+        image: np.ndarray,
+        default_threshold : int,
+        default_spot_size : tuple,
+        default_kernel_size : tuple,
+        default_min_distance : tuple,
+        voxel_size : tuple,
+        background_remover_instance : BackgroundRemover,
+        ) :
+        
+        self.image = image
+        self.voxel_size = voxel_size
+        self.dim = len(voxel_size)
+        self.default_threshold = default_threshold
+        self.spot_radius = default_spot_size
+        self.kernel_size = default_kernel_size
+        self.min_distance = default_min_distance
+        self._update_filtered_image()
+        self.maximum_threshold = self.filtered_image.max()
+        self.do_update = False
+        
+        super().__init__()
+        background_remover_instance.events.background_substraction_event.connect(self.on_background_updated)
+
+    def _update_filtered_image(self) :
+
+        print("Re-computing filtered image with new parameters : ...", end="", flush=True)
+        self.filtered_image = _apply_log_filter(
+            image=self.image,
+            voxel_size=self.voxel_size,
+            spot_radius=self.spot_radius,
+            log_kernel_size=self.kernel_size
+        )
+        print("\rRe-computing filtered image with new parameters : done")
+
+        self.local_maxima = _local_maxima_mask(
+            image_filtered=self.filtered_image,
+            voxel_size=self.voxel_size,
+            spot_radius=self.spot_radius,
+            minimum_distance=self.min_distance
+        )
+
+    def _create_widget(self) :
+        
+        dim = len(self.voxel_size)
+        if dim == 2 :
+            tuple_hint = Tuple[int,int]
+        else :
+            tuple_hint = Tuple[int,int,int]
+
+        if not self.default_threshold is None : 
+            default_threshold = min(self.default_threshold, self.filtered_image.max())
+        else :
+            default_threshold = None
+
+        @magicgui(
+            threshold = {"widget_type" : SpinBox, "min" : 0, "value" : default_threshold, "max" : self.filtered_image.max() + 1},
+            spot_radius = {"label" : "spot radius(zyx)", "value" : self.spot_radius},
+            kernel_size = {"label" : "LoG kernel size(zyx)"},
+            minimum_distance = {"label" : "Distance min between spots"},
+        )
+        def find_spots(
+            threshold : int,
+            spot_radius : tuple_hint,
+            kernel_size : tuple_hint,
+            minimum_distance : tuple_hint,
+        ) -> List[LayerDataTuple] :
+
+            if (np.array(spot_radius) < 0).any() :
+                raise ValueError("Spot radius : set value > 0 (0 to ignore argument)")
+            
+            if (np.array(kernel_size) < 0).any() :
+                raise ValueError("Spot radius : set value > 0 (0 to ignore argument)")
+            
+            if (np.array(minimum_distance) < 0).any() :
+                raise ValueError("Spot radius : set value > 0 (0 to ignore argument)")
+            
+            if isinstance(spot_radius, tuple) :
+                if not all(spot_radius) : spot_radius = None #any value set to 0
+            if isinstance(kernel_size, tuple) :
+                if not all(kernel_size) : kernel_size = None #any value set to 0
+            if isinstance(minimum_distance, tuple) :
+                if not all(minimum_distance) : minimum_distance = None #any value set to 0
+
+            if spot_radius != self.spot_radius :
+                self.spot_radius = spot_radius
+                self.do_update = True
+            if kernel_size != self.kernel_size :
+                self.kernel_size = kernel_size
+                self.do_update = True
+            if minimum_distance != self.min_distance :
+                self.min_distance = minimum_distance
+                self.do_update = True
+            
+            try :
+                if self.do_update :
+                    self._update_filtered_image()
+                    self.do_update = False
+                    self.widget.threshold.max = self.filtered_image.max() + 1
+                
+                print("Computing automated threshold : ...", end="", flush=True)
+                if threshold == 0 :
+                    threshold = automated_threshold_setting(
+                        self.filtered_image,
+                        mask_local_max=self.local_maxima
+                    )
+                    self.widget.threshold.value = threshold
+                print("\rComputing automated threshold : done.")
+
+                spots = spots_thresholding(
+                image=self.filtered_image,
+                mask_local_max=self.local_maxima,
+                threshold=threshold
+                )[0]
+            except ValueError as e :
+                print(str(e))
+
+
+            scale = compute_anisotropy_coef(self.voxel_size)
+    
+            spot_layer_args = {
+                'size': 5, 
+                'scale' : scale, 
+                'face_color' : 'transparent', 
+                'border_color' : 'red', 
+                'symbol' : 'disc', 
+                'opacity' : 0.7, 
+                'blending' : 'translucent', 
+                'name': 'single spots',
+                'visible' : True,
+                }
+
+            filtered_image_layer_args = {
+                "colormap" :  'gray',
+                "scale" : scale,
+                "blending" : 'additive',
+                "name" : "filtered image"
+            }
+
+            return [
+                    (self.filtered_image, filtered_image_layer_args, 'image'),
+                    (spots, spot_layer_args, 'points')
+                    ]
+
+        return find_spots
+
+    def on_background_updated(self, event):
+        print("Background was updated — recomputing filtered image...")
+        self.image = event.new_signal_array
+        self.do_update = True
+        self.widget()
+
+    def get_detection_parameters(self) :
+        detection_parameters = {"threshold" : self.widget.threshold.value}
+        if self.spot_radius is not None :
+            detection_parameters.update({
+            "spot_size" : self.spot_radius,
+            "spot_size_z" :  self.spot_radius[0] if self.dim == 3 else None,
+            "spot_size_y" :  self.spot_radius[0 + (self.dim==3)],
+            "spot_size_x" :  self.spot_radius[1 + (self.dim==3)]
+            })
+        if self.kernel_size is not None :
+            detection_parameters.update({
+            "log_kernel_size" : self.kernel_size,
+            "log_kernel_size_z" : self.kernel_size[0] if self.dim == 3 else None,
+            "log_kernel_size_y" : self.kernel_size[0 + (self.dim==3)],
+            "log_kernel_size_x" : self.kernel_size[1 + (self.dim==3)]
+            })
+        if self.min_distance is not None :
+            detection_parameters.update({
+            "minimum_distance" : self.min_distance,
+            "minimum_distance" : self.min_distance[0] if self.dim == 3 else None,
+            "minimum_distance" : self.min_distance[0 + (self.dim==3)],
+            "minimum_distance" : self.min_distance[1 + (self.dim==3)],
+            })
+
+        return detection_parameters
+        
+        
+
+
+
+class DenseRegionDeconvolver(NapariWidget) :
+    """
+    Widget for interactive detection. Create 2 layes : Labels layer representing dense region that could be deconvoluted and Points layer with deconvoluted spots
+    """
+    def __init__(
+        self,
+        image : Image,
+        spots : Points, 
+        alpha : float, 
+        beta : float, 
+        gamma : float,
+        spot_radius : tuple,
+        kernel_size : tuple,
+        voxel_size : tuple
+        ) :
+        
+        self.image = image
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
+        self.spots = spots
+        self.spot_radius = spot_radius
+        self.kernel_size = kernel_size
+        self.voxel_size = voxel_size
+        self.update_dense_regions()
+        super().__init__()
+
+    def update_dense_regions(self) :
+        dense_regions, spot_out_regions,max_size = detection.get_dense_region(
+            image=self.image.data,
+            spots=self.spots.data,
+            voxel_size = self.voxel_size,
+            beta=self.beta,
+            spot_radius=self.spot_radius
+        )
+        del spot_out_regions,max_size
+
+        mask = np.zeros(shape=self.image.data.shape, dtype= np.int16)
+        for label, region in enumerate(dense_regions) :
+            reg_im = region.image
+            coordinates = np.argwhere(reg_im)
+            z,y,x = coordinates.T
+            min_z,min_y,min_x,*_ = region.bbox
+            z += min_z
+            y += min_y
+            x += min_x
+
+            mask[z,y,x] = label + 1
+
+        self.dense_regions = mask
+
+    def _create_widget(self) :
+
+        dim = len(self.voxel_size)
+        tuple_hint = Tuple[int,int] if dim == 2 else Tuple[int,int,int]
+        tuple_dummy = tuple(0 for i in range(dim))
+
+        @magicgui
+        def dense_region_deconvolution(
+            alpha : float = self.alpha,
+            beta : float = self.beta,
+            gamma : float = self.gamma,
+            spot_radius : tuple_hint = tuple_dummy if self.spot_radius is None else self.spot_radius,
+            kernel_size : tuple_hint = tuple_dummy if self.kernel_size is None else self.kernel_size,
+        ) -> List[LayerDataTuple] :
+
+            if (np.array(spot_radius) < 0).any() :
+                    raise ValueError("Spot radius : set value > 0 (0 to ignore argument)")
+            if (np.array(kernel_size) < 0).any() :
+                raise ValueError("kernel size : set value > 0 (0 to ignore argument)")
+            
+            if isinstance(spot_radius,tuple) :
+                if not all(spot_radius) : spot_radius = None #any value set to 0
+            if isinstance(kernel_size,tuple) :
+                if not all(kernel_size) : kernel_size = None #any value set to 0
+
+            self.do_update = False
+            if spot_radius != self.spot_radius :
+                self.spot_radius = spot_radius
+                self.do_update = True
+            if beta != self.beta :
+                self.beta = beta
+                self.do_update=True
+            if self.do_update : 
+                print("Updating dense regions...", end="", flush=True)
+                self.update_dense_regions()
+                print("\rUpdating dense regions : done.")
+            self.alpha = alpha
+            self.gamma = gamma
+            self.kernel_size = kernel_size
+
+            print("Decomposing dense regions...", end="", flush=True)
+            spots, _dense_region, _reference_spot = detection.decompose_dense(
+                image= self.image.data, 
+                spots= self.spots.data, 
+                voxel_size=self.voxel_size, 
+                spot_radius=self.spot_radius, 
+                kernel_size=self.kernel_size, 
+                alpha=self.alpha, 
+                beta=self.beta, 
+                gamma=self.gamma
+            )
+            print("\rDecomposing dense regions : done")
+            del _dense_region, _reference_spot
+
+            scale = compute_anisotropy_coef(self.voxel_size)
+            spot_layer_args = {
+                'size': 5, 
+                'scale' : scale, 
+                'face_color' : 'transparent', 
+                'border_color' : 'blue', 
+                'symbol' : 'disc', 
+                'opacity' : 0.7, 
+                'blending' : 'translucent', 
+                'name': 'decovoluted spots',
+                'visible' : True,
+                }
+
+            dense_region_args = {
+                "scale" : scale,
+                "name": "Dense regions",
+                "colormap" : ["red"] * self.dense_regions.max()
+            }
+
+            return [(self.dense_regions, dense_region_args, 'labels'), (spots, spot_layer_args, 'points')]
+        return dense_region_deconvolution
+
+    def get_detection_parameters(self) :
+        return {
+            "alpha" : self.alpha,
+            "beta" : self.beta,
+            "gamma" : self.gamma
+        }
+