Merge pull request #5 from gletort/main

update the rnanuclei branch to main version

Author: gletort

pyproject.toml

@@ -27,14 +27,12 @@ dependencies = [
     "opencv_python_headless<4.12; python_version< '3.11' ",
     "opencv_python_headless; python_version >= '3.11'",
     "pyqt6<6.10; python_version < '3.11'",
-    "epyseg; python_version < '3.11'",
-	"tensorflow<2.15; python_version < '3.11'",
-	"tensorflow; python_version >= '3.11'",
     "big-fish>=0.6.2",
     "napari<0.6.4; python_version < '3.11'",
-    "napari; python_version >= '3.11'",
+    "napari;python_version >= '3.11'",
+	"appose",
 	"nninteractive",
-	"torch<=2.6",
+	"torch<=2.7",
     "numpy==1.26.4; python_version < '3.11'",
     "numpy; python_version >= '3.11'",
 	"pyqt5",
@@ -47,6 +45,14 @@ dependencies = [
     "lxml",
     "packaging",
     "cellpose[distributed]",
+]
+
+[project.optional-dependencies]
+
+full = [
+    "epyseg; python_version < '3.11'",
+	"tensorflow<2.15; python_version < '3.11'",
+	"tensorflow; python_version >= '3.11'",
     "stardist",
 ]
 #dynamic = ["version"]

src/fish_feats/MainImage.py

@@ -9,9 +9,12 @@
 
 try:
     from fish_feats.SegmentObj import local_max_proj, prepJunctions, segmentJunctions
+except ImportError as e:
+    print( "Module missing in seg "+e )
+try:
     from fish_feats.RNASpots import RNASpots
-except ImportError:
-    print("Module missing")
+except ImportError as e:
+    print( "Module missing in RNASpots "+e )
 
 ####### Z map functions
 def score_each_z( img3d, projimg ):
@@ -366,9 +369,13 @@ def separate_junctions_nuclei( self, wth_radxy=4, wth_radz=1, rmoutlier_radxy=5,
         self.nucstain = smoothNuclei(self.nucstain, radxy=smoothnucxy, radz=smoothnucz)
 
     def separate_with_sepanet( self, model_dir ):
-        from fish_feats.Separe import sepanet
         bothimage = np.copy(self.image[self.nucchan,])
-        self.junstain, self.nucstain = sepanet( bothimage, model_dir )
+        if ut.has_dependency( "tensorflow" ):
+            from fish_feats.Separe import sepanet_local
+            self.junstain, self.nucstain = sepanet_local( bothimage, model_dir )
+        else:
+            from fish_feats.Separe import sepanet_appose
+            self.junstain, self.nucstain = sepanet_appose( bothimage, model_dir )
 
     def should_separate( self ):
         if self.junchan==self.nucchan:
@@ -614,7 +621,7 @@ def do_segmentation_cellpose(self, diameter, threshold, resample=True, in3D=True
             self.pop.setNucleiImage(self.nucmask)
 
     # stardist2D+association 3D
-    def do_segmentation_stardist(self, threshold, overlap, assoMethod, associationlim, threshold_overlap):
+    def do_segmentation_stardist(self, threshold, overlap, assoMethod, associationlim, threshold_overlap, progress_bar=None):
         ut.show_info("Segmenting nuclei with Stardist2D+association3D")
         from fish_feats.SegmentObj import prepNuclei, getNuclei_stardist2DAsso3D
         treatedNuclei = prepNuclei(self.nucstain)  ## normalize the image
@@ -624,7 +631,7 @@ def do_segmentation_stardist(self, threshold, overlap, assoMethod, associationli
                             assoMode = assoMethod,
                             assolim=associationlim,
                             threshold_overlap=threshold_overlap,
-                            verbose=self.verbose )
+                            verbose=self.verbose, progress_bar=progress_bar )
         if self.nucmask is None:
             return
         self.nucmask[self.nucmask>0] = self.nucmask[self.nucmask>0] + 1

src/fish_feats/NapaNuclei.py

@@ -251,7 +251,7 @@ def go_segnuclei_stardist( self ):
             float(self.stardist_nuclei_overlap.text()),
             self.stardist_association_method.currentText(), 
             float(self.stardist_association_distance_limit_micron.text()),
-            float(self.stardist_threshold_overlap.text()) )
+            float(self.stardist_threshold_overlap.text()), pbar )
         if self.mig.nucmask is None:
             ut.close_progress( self.viewer, pbar )
             return

src/fish_feats/SegmentObj.py

@@ -9,18 +9,54 @@
 from fish_feats.Association import associateNucleus, associateNucleusOverlap
 from skimage.filters import sato
 from skimage.morphology import skeletonize, binary_closing
-from skimage.segmentation import find_boundaries
-from skimage.segmentation import clear_border
+from skimage.segmentation import find_boundaries, clear_border
 from skimage.measure import label
 from skimage.exposure import adjust_gamma
 import time
 import tempfile
+from importlib import resources
+import appose
 
 """
     Functions to segment junctions or nuclei
 """
 
-def run_epyseg(input_folder):
+def run_epyseg_appose( input_folder ):
+    """ Run epyseg on a separate virtual environement through appose """
+    try:
+        pixi_file = resources.files("fish_feats.resources").joinpath("pixi.toml")
+        epyseg_script = resources.files("fish_feats.resources").joinpath("run_epyseg.py")
+        epyseg_script = epyseg_script.read_text()
+        ut.show_info("Build/Load tensorflow environment")
+        env = appose.pixi( pixi_file ).log_debug()
+        env = env.subscribe_output( lambda line: print("OUT:", line, end="") )
+        env = env.subscribe_error( lambda line: print("DBG:", line, end="") )
+        env_name = ut.get_env_name()
+        env = env.environment(env_name).build()
+        ut.show_info(f"Environment built at: {env.base()}")
+        python = env.python().init("import numpy as np; import tensorflow as tf;"\
+        "from epyseg.deeplearning.deepl import EZDeepLearning; import epyseg.deeplearning.deepl as deepl;")
+        python.debug(lambda msg: print("[DBG]", msg))
+        
+        def log_listener(event):
+            """ Transfer appose task message to the main logger """
+            if event.message:
+               print( f"[task] {event.message}" )
+
+        try:
+            task = python.task( epyseg_script )
+            task.listen( log_listener )
+            task.inputs["input_folder"] = input_folder 
+            task.wait_for()
+        except Exception as e:
+            raise RuntimeError("Running epyseg in separated environement failed") from e
+        finally:
+            python.close()
+    except Exception as e:
+        print(e)
+        raise RuntimeError("Epyseg in separated environement failed") from e
+
+def run_epyseg_local(input_folder):
     import tensorflow as tf
 
     # libraries loaded checking epyseg to see if everything is functional
@@ -93,12 +129,14 @@ def run_epyseg(input_folder):
     #deepTA = None
     del deepTA
 
+
 def run_epyseg_onimage(img, filedir, filename, verbose=True):
+    """ Run epyseg on an image: create temp dir because of epyseg requirements """
     from PIL import Image
-    import os
 
     binimg = None
     tmpdir_path = None
+    appose = not ut.has_dependency( "epyseg" )
     try:
         with tempfile.TemporaryDirectory() as tmpdir:
             print("tmp dir "+str(tmpdir))
@@ -114,7 +152,10 @@ def run_epyseg_onimage(img, filedir, filename, verbose=True):
                 print("Warning, issue in creating "+predict_output_folder+" folder")
 
             ## run Epyseg on tmp directory (contains current image)
-            run_epyseg(tmpdir)
+            if appose:
+                run_epyseg_appose( tmpdir )
+            else:
+                run_epyseg_local(tmpdir)
 
             ## return result and delete files
             im = Image.open(os.path.join(tmpdir,"predict",inputname)) 
@@ -132,7 +173,6 @@ def run_epyseg_onimage(img, filedir, filename, verbose=True):
 
 def run_epyseg_onimage_fold(img, filedir, filename, verbose=True):
     from PIL import Image
-    import os
     import shutil
     import stat
 
@@ -332,7 +372,13 @@ def prepNuclei(img):
     img = (img-quants[0])/(quants[1]-quants[0])
     return img
 
-def stardist2D(img, prob, over):
+def share_as_ndarray(img: np.ndarray) -> appose.NDArray:
+    """Copies a NumPy array into a same-sized newly allocated block of shared memory."""
+    shared = appose.NDArray(str(img.dtype), img.shape)
+    shared.ndarray()[:] = img
+    return shared
+
+def stardist2D_local(img, prob, over, progress_bar=None ):
     """ run stardist model, segment nuclei in 2D """
     try:
         from csbdeep.utils import Path, normalize
@@ -355,13 +401,73 @@ def stardist2D(img, prob, over):
         nuclei[ind,] = labels
     return nuclei
 
-def getNuclei_stardist2DAsso3D(nucimg, scaleXY, proba=0.55, overlap=0.1, assoMode="Munkres", assolim=3, threshold_overlap=0.25, verbose=True):
+def stardist2D_appose( img, prob, over, progress_bar=None ):
+    """ run stardist model, segment nuclei in 2D """
+    try:
+        pixi_file = resources.files("fish_feats.resources").joinpath("pixi.toml")
+        ut.show_info("Build/Load tensorflow environment")
+        env = appose.pixi( pixi_file ).log_debug()
+        env = env.subscribe_output( lambda line: print("OUT:", line, end="") )
+        env = env.subscribe_error( lambda line: print("DBG:", line, end="") )
+        env_name = ut.get_env_name()
+        env = env.environment(env_name).build()
+        ut.show_info(f"Environment built at: {env.base()}")
+        python = env.python().init("import numpy as np; import tensorflow as tf;" \
+        "from stardist.models import StarDist2D")
+        #python.debug(lambda msg: print("[DBG]", msg))
+        if progress_bar is None:
+            progress_bar = ut.start_progress( None, total=1, descr="Stardist segmentation" )
+            toclose = True
+        else:
+            progress_bar.set_description( "Stardist segmentation" )
+            toclose = False
+        
+        def log_listener(event):
+            """ Transfer appose task message to the main logger """
+            if event.current and event.maximum:
+                print( f"Segmenting slice {event.current}/{event.maximum}" )
+                #ut.show_info( f"Segmenting slice {event.current}/{event.maximum}" )
+                #progress_bar.update( cur )
+                #progress_bar.total = total 
+            else:
+                if event.message:
+                    print( f"[task] {event.message} " )
+
+        try:
+            stardist_script = resources.files("fish_feats.resources").joinpath("run_stardist.py")
+            stardist_script = stardist_script.read_text()
+            with share_as_ndarray(img) as image:
+                task = python.task( stardist_script )
+                task.listen( log_listener )
+                task.inputs["img"] = image 
+                task.inputs["stardist_probability"] = prob
+                task.inputs["stardist_overlap"] = over
+                task.wait_for()
+                result = image.ndarray()
+                return np.uint16( result )
+        except Exception as e:
+            raise RuntimeError("Running stardist in separated environement failed") from e
+        finally:
+            python.close()
+            if toclose:
+                ut.close_progress( None, progress_bar=progress_bar )
+    except Exception as e:
+        raise RuntimeError("Stardist in separated environement failed") from e
+
+def getNuclei_stardist2DAsso3D(nucimg, scaleXY, proba=0.55, overlap=0.1, assoMode="Munkres", assolim=3, threshold_overlap=0.25, verbose=True, progress_bar=None):
     """ Segment nuclei with Stardist2D and reconstruct in 3D - return the nuclei list """
 
     ## segment 2D
-    labnuc = stardist2D(nucimg, prob=proba, over=overlap)
+    appose = not ut.has_dependency( "stardist" )
+    if appose:
+        labnuc = stardist2D_appose(nucimg, prob=proba, over=overlap, progress_bar=progress_bar)
+    else:
+        labnuc = stardist2D_local(nucimg, prob=proba, over=overlap, progress_bar=progress_bar)
+
     if labnuc is None:
         return None
+    if progress_bar is not None:
+        progress_bar.set_description( "Reconstructing now in 3D..." ) 
     ## reconstruct 3D
     if assoMode == "Munkres":
         labels = associateNucleus(labnuc, dlimit=assolim, scaleXY=scaleXY)  ## distance 2D in micrcons  -2.5

src/fish_feats/Separe.py

@@ -2,11 +2,69 @@
 import cv2
 import scipy.ndimage as ndimage
 from napari.utils.notifications import show_info
-from math import floor
 import time
+import fish_feats.Utils as ut
 from napari.utils import progress
+from importlib import resources
+import appose
 
-def sepanet( img, sepdir, patchsize=256 ):
+def share_as_ndarray(img: np.ndarray) -> appose.NDArray:
+    """Copies a NumPy array into a same-sized newly allocated block of shared memory."""
+    shared = appose.NDArray(str(img.dtype), img.shape)
+    shared.ndarray()[:] = img
+    return shared
+
+def sepanet_appose( img, sepdir, patchsize=256 ):
+    """ Separate junctions and nuclei with trained DL """
+    print("sepaNet with models in "+str(sepdir))
+    try:
+        pixi_file = resources.files("fish_feats.resources").joinpath("pixi.toml")
+        ut.show_info("Build/Load tensorflow environment")
+        env = appose.pixi( pixi_file ).log_debug()
+        env = env.subscribe_output( lambda line: print("OUT:", line, end="") )
+        env_name = ut.get_env_name()
+        env = env.environment(env_name).build()
+        ut.show_info(f"Environment built at: {env.base()}")
+        python = env.python().init("import numpy as np; import tensorflow as tf;"\
+        "import keras; import scipy.ndimage as ndimage")
+        #python.debug(lambda msg: print("[DBG]", msg))
+        progress_bar = ut.start_progress( None, total=1, descr="SepaNet separation" )
+        
+        def log_listener(event):
+            """ Transfer appose task message to the main logger """
+            if event.current and event.maximum:
+                print( f"Separating slice {event.current}/{event.maximum}" )
+                #ut.show_info( f"Separiting slice {event.current}/{event.maximum}" )
+                #progress_bar.update( cur )
+                #progress_bar.total = total 
+            else:
+                if event.message:
+                    print( f"[task] {event.message} " )
+
+        try:
+            sepanet_script = resources.files("fish_feats.resources").joinpath("run_sepanet.py")
+            sepanet_script = sepanet_script.read_text()
+            result_junc = None
+            result_nuc = None
+            with share_as_ndarray(img) as image:
+                task = python.task( sepanet_script )
+                task.listen( log_listener )
+                task.inputs["img"] = image 
+                task.inputs["patchsize"] = patchsize
+                task.inputs["model_directory"] = sepdir
+                task.wait_for()
+                result_junc = np.uint8( task.outputs["junctions"].ndarray().copy() )
+                result_nuc = np.uint8( task.outputs["nuclei"].ndarray().copy() )
+            return result_junc, result_nuc 
+        except Exception as e:
+            raise RuntimeError("Running SepaNet in separated environement failed") from e
+        finally:
+            python.close()
+            ut.close_progress( None, progress_bar=progress_bar )
+    except Exception as e:
+        raise RuntimeError("SepaNet in separated environement failed") from e
+
+def sepanet_local( img, sepdir, patchsize=256 ):
     """ Separate junctions and nuclei with trained DL """
     print("sepaNet with models in "+str(sepdir))
 
@@ -28,6 +86,7 @@ def sepanet( img, sepdir, patchsize=256 ):
     return res[:,:,:,0], res[:,:,:,1]
 
 def run_on_image(imgtest, model, patchsize, step=50):
+    from math import floor
     imgtest.astype(float)
     imgtest = normalise(imgtest)
     imgtest = smooth(imgtest)
@@ -74,7 +133,6 @@ def run_on_image(imgtest, model, patchsize, step=50):
     resimg = np.uint8(resimg*255)
     return resimg
 
-
 def normalise(img):
     quants = np.quantile(img, [0.1, 0.99])
     img = (img - quants[0]) / (quants[1]-quants[0])
@@ -98,13 +156,23 @@ def both_MSE_percent_1( y_true, y_pred ):
     acc0 = keras.metrics.mean_absolute_percentage_error(y_true[:,:,:,1], y_pred[:,:,:,1])
     return acc0
 
-
 def mse_two(y_true, y_pred):
     y_true = tf.reshape(y_true, [-1])
     y_pred = tf.reshape(y_pred, [-1])
     mse = tf.keras.losses.MeanSquaredError()
     return mse(y_true, y_pred)
 
+### Separation based on filterings
+def junctionsCoherence(img, medblur=3, quant=0.98, dsig=3, cornersig=5, ratio=0.5, niter=4):
+    ## Coherence enhancing diffusion, Weickert et al.
+    #from skimage import exposure
+    height, width = img.shape[:2]
+    qmax = np.quantile(img, quant)
+    qmin = np.min(img)
+    img = np.uint8( (img-qmax)/(qmax-qmin)*255 )
+    #img = cv2.normalize(src=img, dst=None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+
+
 ### Separation based on filterings
 def junctionsCoherence(img, medblur=3, quant=0.98, dsig=3, cornersig=5, ratio=0.5, niter=4):
     ## Coherence enhancing diffusion, Weickert et al.