Merge pull request #8 from gletort/epidev Tests, Open from layers, Vertices measures and Bug correction

Tests, Open from layers, Vertices measures and Bug correction
Add and updated tests file
Add option to open first layers in Napari with other plugins, then start EpiCure from it
Add option in Output to get and measure the vertices (TCJ)
Bug corrections, especially in measuring junction intensity in an other channel than the main one

Author: gletort

docs/Output.md

@@ -1,14 +1,6 @@
 !!! abstract "Options to measure and export segmentation/events/tracks"
 	_Measurement and plotting options are/will be proposed here, as well as options to export the segmentation/measurements to use in other analysis softwares_
 
-* [Apply on: define current selection](#define-current-selection)
-* [Export to extern plugins](#export-to-other-plugins)
-* [Export segmentations](#save-segmentations)
-* [Export events](#export-events)
-* [Measure cell features](#measure-cell-features)
-* [Measure track features](#measure-track-features)
-
-
 ## Define current selection
 
 You can choose which cells to analyse/export with the `Apply on` option in the interface:
@@ -188,4 +180,22 @@ This allows to save screenshots of the current display/current view (same part o
 Choose the first and last frame of the screenshot movie and click on `save current view`.
 This will creates a `.tif` file in the `epics` folder containing the screenshots of the current view repeated on the given frames.
 
-![interface of screenshot movies](./imgs/output_screenshot.png)
+![interface of screenshot movies](./imgs/output_screenshot.png)
+
+## Measure vertices
+
+Find the vertices, points of junction of several cells (Tri-Cellular junctions or more), display it and measure intensity of the raw movie channel and the number of cells joining (the connectivity) at each vertex.
+
+Choose the option `measure vertices` to launch it.
+
+The parameter `vertex_radius` set the radius of a vertex, to find it (depending on the resolution, it can be bigger than a single pixel) and to measure the intensity inside the vertex (you might want to measure in a small circle rather than in only one point).
+
+The parameter `vertex_display` set the radius at which each point is displayed in the viewer.
+
+Click on `Measure` to launch the detection of vertices and their measures. It can take a few minutes.
+
+When it's finished, it will display a new layer, called "Vertices" that contained the defined vertices, colored by their connectivity measure (number of cells joining in this point) and of a size controlled by the `vertex_display` parameter (and not the one used for measurement, for clarity of visualization).
+
+The measures of each vertex position, connectivity (nb of neighbor cell joining) and intensity in the raw movie channel (the junction channel) are displayed in a table in the right side of the interface that can be saved for further analysis on the vertices connectivity or intensity distributions.
+
+![interface of vertices measurement](./imgs/output_vertices.png)

docs/Start-epicure.md

@@ -1,6 +1,9 @@
 !!! abstract "Start EpiCure: load the movies and metadata"
     _Choose `Start epicure` in Napari `Plugins>Epicure` to open it._ 
 
+EpiCure handles several inputs format through the `bioio` module.
+However, if some format is not correctly recongized/handled by EpiCure, you can open the images in Napari with any other plugin (for example [napari-bioformats](https://github.com/tlambert03/napari-bioformats), [napari-aicsimageio](https://github.com/AllenCellModeling/napari-aicsimageio)) and use the `Start from open layers` option (see more [here](#start-from-opened-layers)).
+
 ## Loading the movies
 
 In the `Start EpiCure` step, you have a dedicated interface in the right part of the main interface.
@@ -48,4 +51,23 @@ Depending on python/module versions and the input file itself, all the informati
 
 While EpiCure is optimized for a graphical usage as its scope relies on easing manual edition of segmentation, there's a possbility to launch it without starting Napari first (or at all).
 This can be useful for automatic testing or batching some process. 
-See our released [notebooks](https://github.com/gletort/Epicure/tree/main/notebooks/) for example of usage or our [test files](https://github.com/gletort/Epicure/tree/main/src/tests/). 
+See our released [notebooks](https://github.com/gletort/Epicure/tree/main/notebooks/) for example of usage or our [test files](https://github.com/gletort/Epicure/tree/main/src/tests/). 
+
+## Start from opened layers
+
+To make EpiCure compatible with as many input formats as possible, we added the option to start it from already opened layers, so that the images can be opened with other readers than the one proposed in EpiCure if necessary.
+
+Both the raw image and the segmentation can be opened before to start EpiCure, or only the raw image.
+
+In `Plugins>EpiCure`, choose the option `Start from opened layers`.
+
+In the parameters interface that open on the right side of the viewer, select the layer that corresponds to your raw movie (the layer containing the junction staining) in the `movie` parameter.
+
+Select the raw file of the movie in the `movie path` parameter. 
+This will not open it as it is already opened, but is necessary to know the path and name of the image to save correspondingly the output files.
+
+Select the layer containing the segmentation in the `segmentation` parameter if you have one, or select `None` otherwise.
+
+![interface to start Epicure from open layers](./imgs/start_from_layers.png)
+
+Once the parameters are properly filled, click `Use selected layers` and you will be back to the "normal" EpiCure [starting interface](#movie-metadata) to check the image metadata and choose the main parameters of your analysis.

docs/imgs/output_vertices.png

@@ -13,6 +13,11 @@ You can launch `EpiCure` in Napari by going to `Plugins>epicure>Start`. It will
 The first file to choose is the movie containing the epithelial staining. 
 It should be _2D(+time/channel) file_. 
 
+!!! Note "Input format" 
+	EpiCure relies on `bioio` module to open images, compatible with various formats.
+	Note that if your file format is not correctly handled by EpiCure, you can first open the image with other plugins and start EpiCure from the opened layer(s). See [Start EpiCure page](./Start-epicure.md#start-from-opened-layers) for more details.
+
+
 The second file is the segmentation of this movie (it should contain only the segmentation). It can be a binarized file of the junctions (skeletonized) or a labelled file (each cell is filled by a unique number).
 _Note that if you haven't done the segmentation yet, there's an [additional option](./Segment-option.md) in EpiCure to directly run [EpySeg](https://github.com/baigouy/EPySeg) on the loaded movie._ 
 

docs/imgs/start_from_layers.png

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "epicure"
-version = "1.3"
+version = "1.4"
 description = "Napari plugin to manually correct epithelia segmentation in movies"
 license.file = "LICENSE"
 readme = "README.md"

docs/index.md

@@ -6,7 +6,7 @@
 import os, sys
 import time
 import math
-from skimage.measure import regionprops, find_contours, regionprops_table
+from skimage.measure import label, regionprops, find_contours, regionprops_table
 from skimage.segmentation import find_boundaries, expand_labels
 from napari.utils.translations import trans # type: ignore
 from napari.utils.notifications import show_info # type: ignore
@@ -17,6 +17,8 @@
 from scipy.ndimage import binary_opening as ndbinary_opening
 from scipy.ndimage import sum as ndsum
 from scipy.ndimage import generate_binary_structure as ndi_structure
+from scipy import signal
+from skimage.morphology import medial_axis
 import pandas as pd
 from epicure.laptrack_centroids import LaptrackCentroids
 from bioio import BioImage
@@ -406,6 +408,32 @@ def copy_border( skel, bin ):
     skel[[0, -1], :] = bin[[0, -1], :]  # top and bottom borders
     skel[:, [0, -1]] = bin[:, [0, -1]]  # left and right borders
     return skel
+
+def draw_points(pts, imshape, radius):
+    """ Draw circle (2D) around the given points in 2D image """  
+    image = np.zeros(imshape, dtype=bool)
+    y, x = np.ogrid[:imshape[0], :imshape[1]]
+    for pt in pts:
+        # Calculate distance from pt, scaled to compare to radius
+        distances_sq = ((y - pt[0]))**2 + ((x - pt[1]))**2 
+        image |= distances_sq <= radius**2
+    return image
+
+def get_vertices(seg, viewer=None, verbose=0, parallel=0):
+    """ Get the vertices of the segmentation """
+    skeleton = get_skeleton(seg, viewer, verbose, parallel)
+    convfilter = np.array([[-1,-1,-1], [-1,3,-1],[-1,-1,-1]])
+    novert = np.zeros(skeleton.shape, dtype=np.int8)
+    ## pure skeleton
+    for ind, skel in enumerate(skeleton):
+        skeleton[ind] = medial_axis(skel)
+        novert[ind] = signal.convolve2d(skeleton[ind], convfilter, mode="same")
+    novert[novert<=0] = 0
+    nodeimg = skeleton - novert
+    nodeimg[nodeimg<=0] = 0
+    nodeimg[nodeimg>0] = 1 
+    return nodeimg 
+
 
 def get_skeleton( seg, viewer=None, verbose=0, parallel=0 ) :
     """ convert labels movie to skeleton (thin boundaries) """
@@ -890,6 +918,10 @@ def get_most_frequent( labimg, img, label ):
     vals, counts = np.unique( img[mask], return_counts=True )
     return vals[ np.argmax(counts) ]
 
+def binary_properties( labimg ):
+    """ Returns basic label properties """
+    return regionprops( label(labimg) )
+
 def labels_properties( labimg ):
     """ Returns basic label properties """
     return regionprops( labimg )

pyproject.toml

@@ -17,5 +17,5 @@
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.dev93+g99627b3.d20260109'
-__version_tuple__ = version_tuple = (0, 1, 'dev93', 'g99627b3.d20260109')
+__version__ = version = '0.1.dev103+g64f1ff3.d20260123'
+__version_tuple__ = version_tuple = (0, 1, 'dev103', 'g64f1ff3.d20260123')

src/epicure/Utils.py

@@ -94,6 +94,44 @@ def get_resetbtn_color(self):
     def set_thickness(self, thick):
         """Thickness of junctions (half thickness)"""
         self.thickness = thick
+    
+    def movie_from_layer(self, layer, imgpath):
+        """Prepare the intensity movie from opened layer, and get metadata"""
+        self.reset() ## reload everything 
+        self.epi_metadata["MovieFile"] = os.path.abspath(imgpath)
+        ## if the layer is scaled, should be the right scale
+        self.epi_metadata["ScaleXY"] = layer.scale[2]
+        self.img = layer.data
+        nchan = 0
+        if len(self.img.shape)>3:
+            ## Format TCYX in general
+            nchan = self.img.shape[1]
+        ## transform static image to movie (add temporal dimension)
+        if len(self.img.shape) == 2:
+            self.img = np.expand_dims(self.img, axis=0)
+        caxis = None
+        cval = 0
+        if nchan > 0 or len(self.img.shape) > 3:
+            if nchan > 0 and len(self.img.shape) > 3:
+                ## multiple chanels and multiple slices, order axis should be TCXY
+                caxis = 1
+                cval = nchan
+            else:
+                ## one image with multiple chanels
+                minshape = min(self.img.shape)
+                caxis = self.img.shape.index(minshape)
+                cval = minshape
+            self.mov = self.img
+
+        ## display the movie: rename the layer
+        ut.remove_layer(self.viewer, "Movie")
+        layer.name = "Movie"
+
+        self.imgshape = self.viewer.layers["Movie"].data.shape
+        self.imgshape2D = self.imgshape[1:3]
+        self.nframes = self.imgshape[0]
+        return caxis, cval
+
 
     def load_movie(self, imgpath):
         """Load the intensity movie, and get metadata"""
@@ -208,11 +246,21 @@ def add_other_chanels(self, chan, chanaxis):
                 mview.gamma=0.95
                 mview.visible = False
 
-    def load_segmentation(self, segpath):
+    def load_segmentation(self, seg_input):
         """Load the segmentation file"""
         start_time = ut.start_time()
+        ## compatibility to string input, the path to the image or a dictionnary
+        if isinstance(seg_input, dict):
+            segpath = seg_input["File"]
+        else:
+            segpath = seg_input
         self.epi_metadata["SegmentationFile"] = segpath
-        self.seg, _, _, _, _, _ = ut.open_image(segpath, get_metadata=False, verbose=self.verbose > 1)
+        if isinstance(seg_input, dict) and "Layer" in seg_input:
+            ## take the segmentation data and close it
+            self.seg = seg_input["Layer"].data
+            ut.remove_layer(self.viewer, seg_input["Layer"])
+        else:
+            self.seg, _, _, _, _, _ = ut.open_image(segpath, get_metadata=False, verbose=self.verbose > 1)
         self.seg = np.uint32(self.seg)
         ## transform static image to movie (add temporal dimension)
         if len(self.seg.shape) == 2:
@@ -289,17 +337,21 @@ def set_names(self, outdir):
         """Extract default names from imgpath"""
         self.imgname, self.imgdir, self.outdir = ut.extract_names(self.epi_metadata["MovieFile"], outdir, mkdir=True)
 
-    def go_epicure(self, outdir="epics", segmentation_file=None):
+    def go_epicure(self, outdir="epics", segmentation_input=None):
         """Initialize everything and start the main widget"""
         self.set_names(outdir)
-        if segmentation_file is None:
-            segmentation_file = self.suggest_segfile(outdir)
+        if segmentation_input is None:
+            segmentation_input = {}
+            segmentation_input["File"] = self.suggest_segfile(outdir)
         self.viewer.window._status_bar._toggle_activity_dock(True)
         progress_bar = progress(total=5)
         progress_bar.set_description("Reading segmented image")
         ## load the segmentation
-        self.load_segmentation(segmentation_file)
-        self.epi_metadata["SegmentationFile"] = segmentation_file
+        self.load_segmentation(segmentation_input)
+        if isinstance(segmentation_input, dict):
+            self.epi_metadata["SegmentationFile"] = segmentation_input["File"]
+        else:
+            self.epi_metadata["SegmentationFile"] = segmentation_input
         progress_bar.update(1)
         ut.set_active_layer(self.viewer, "Segmentation")
 

src/epicure/_version.py

@@ -6,6 +6,9 @@ contributions:
     - id: epicure.start
       python_name: epicure.start_epicuring:start_epicure
       title: Start
+    - id: epicure.start_from_layers
+      python_name: epicure.start_epicuring:start_from_layers
+      title: Start from opened layers
     - id: epicure.concatenate
       python_name: epicure.concatenate_movie:concatenate_movies
       title: Concatenate
@@ -18,6 +21,8 @@ contributions:
   widgets:
     - command: epicure.start
       display_name: Start EpiCure
+    - command: epicure.start_from_layers
+      display_name: Start from opened layer(s)
     - command: epicure.concatenate
       display_name: Concatenate EpiCured movies
     - command: epicure.doc