fishfeats 1.1.19.post1.dev0__py3-none-any.whl

fish_feats/Analysis.py

@@ -0,0 +1,239 @@
+"""
+   To handle post pipeline analysis
+   - Hierarchical clustering: from csv results file and segmented cells, perform and display clustering.
+
+"""
+
+import numpy as np
+import pathlib, os, csv
+
+import matplotlib as mpl
+from matplotlib.backends.backend_qt5agg import FigureCanvas
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+        
+from scipy.cluster.hierarchy import dendrogram
+from scipy.cluster.hierarchy import fcluster
+from scipy.spatial.distance import pdist, squareform 
+from scipy.cluster.hierarchy import ward
+from skimage.io import imsave
+from sklearn.preprocessing import scale
+
+import napari
+from magicgui import magicgui
+from napari.utils.notifications import show_info
+
+import fish_feats.Utils as ut
+import fish_feats.MainImage as mi
+
+## disable scipy cluster warning
+from scipy.cluster.hierarchy import ClusterWarning
+from warnings import simplefilter
+simplefilter("ignore", ClusterWarning)
+
+def do_hierarchy():
+    mig = mi.MainImage( talkative=True )
+    viewer = napari.current_viewer()
+    viewer.title = "ZENnapari"
+    
+    filename = ut.dialog_filename()
+    if filename is None:
+        print("No file selected")
+        return
+    
+    mig.open_image( filename=filename )
+    ut.update_history(mig.imagedir)
+    
+    for chanel in range(mig.nbchannels):
+        cmap = ut.colormapname(chanel)
+        img = mig.get_channel(chanel)
+        cview = viewer.add_image( img, name="originalChannel"+str(chanel), blending="additive", scale=(mig.scaleZ, mig.scaleXY, mig.scaleXY), colormap=cmap )
+        dint = np.max(img)-np.min(img)
+        cview.contrast_limits=(np.min(img), np.max(img)-0.75*dint)
+    viewer.axes.visible = True
+
+    return getScales(mig, viewer)
+
+def getScales(mig, viewer):
+    @magicgui(call_button="Update", 
+            scaleXY={"widget_type": "LiteralEvalLineEdit"},
+            scaleZ={"widget_type": "LiteralEvalLineEdit"},
+            )
+    def get_scale( scaleXY= mig.scaleXY, scaleZ= mig.scaleZ,
+                   segmented_cells=pathlib.Path(mig.junction_filename(dim=2,ifexist=True)),
+        ):
+        mig.scaleXY = scaleXY
+        mig.scaleZ = scaleZ
+        for chan in range(mig.nbchannels):
+            viewer.layers['originalChannel'+str(chan)].scale = [mig.scaleZ, mig.scaleXY, mig.scaleXY]
+        viewer.window.remove_dock_widget("all")
+        mig.load_segmentation( segmented_cells )
+        mig.popFromJunctions()
+        
+        hiera = HierAnalysis()
+        hiera.set(mig, viewer)
+        hiera.get_data()
+    
+    wid = viewer.window.add_dock_widget(get_scale, name="Scale")
+    return wid
+
+############ hierarchical analysis
+class HierAnalysis:
+    """ Perform and display hierarchical analysis based on selected features """
+
+    def __init__(self):
+        self.nclusters = 4
+        self.wid = None
+        self.clustward = None
+
+    def set(self, mig, viewer):
+        self.mig = mig
+        self.viewer = viewer
+        self.cluster_img = np.zeros(mig.get_image_shape(in2d=True), np.uint8)
+        self.featlayer = self.viewer.add_labels(self.cluster_img, name="ClusteredCells", scale=(mig.scaleXY, mig.scaleXY), opacity=1)
+
+    def get_data(self):
+        """ Interface to select the file and the parameters """
+        def load_file():
+            """ Load the excel/csv file """
+            with open(get_columns.load_file.value, 'r') as infile:
+                csvreader = csv.DictReader(infile)
+                print(csvreader.fieldnames)
+                get_columns.use_column.choices = csvreader.fieldnames
+        
+        def load_table():
+            """ Load the specific columns """
+            keep = get_columns.use_column.value
+            self.prepare_data( get_columns.load_file.value, keep )
+            self.show_clusters()
+        
+        def update_clusters():
+            """ Update all with the new number of clusters chosen """
+            self.nclusters = int(get_columns.nb_clusters.value)
+            self.show_clusters()
+
+        def save_cluscells():
+            """ Save image of cells colored by cluster """
+            ccells = self.featlayer.data
+            outname = self.mig.build_filename( endname="_ClusteredCells_nclus_"+str(self.nclusters)+".png" )
+            vis = []
+            for lay in self.viewer.layers:
+                vis.append(lay.visible)
+                lay.visible = False
+            self.featlayer.visible = True
+            screenshot = self.viewer.screenshot()
+            for visib, lay in zip(vis, self.viewer.layers):
+                lay.visible = visib
+
+            imsave(outname, screenshot)
+            show_info("Saved in "+outname)
+
+        def save_dendrogram_img():
+            """ Save image of dendrogram to file """
+            outname = self.mig.build_filename(endname="_ClusterDendrogram_nclus_"+str(self.nclusters)+".png")
+            self.fig.savefig(outname)
+            show_info("Saved in "+outname)
+
+
+        @magicgui(call_button="Cluster from selected columns", 
+            use_column = dict(widget_type="Select", choices=[]), 
+            nb_clusters={"widget_type": "Slider", "min":1, "max": 50},
+            save_clustered_cells={"widget_type":"PushButton", "value": False},
+            save_dendrogram={"widget_type":"PushButton", "value": False},
+            )
+        def get_columns( 
+            #load_file=pathlib.Path(self.mig.rnacount_filename(ifexist=True)),
+            load_file=pathlib.Path(self.mig.resdir),
+            use_column = [],
+            nb_clusters = 4,
+            save_clustered_cells=False, save_dendrogram=False,
+            ):
+            load_table()
+        
+        get_columns.load_file.changed.connect(load_file)
+        get_columns.nb_clusters.changed.connect(update_clusters)
+        get_columns.save_clustered_cells.clicked.connect(save_cluscells)
+        get_columns.save_dendrogram.clicked.connect(save_dendrogram_img)
+        self.viewer.window.add_dock_widget( get_columns, name="Load data" )
+        
+
+    def get_cluster_colors(self):
+        """ To have same color between the label layer and the matplotlib plot """
+        return [0] + [mpl.colors.rgb2hex(self.featlayer.get_color(i+1)) for i in range(self.nclusters)]
+
+    def check_label(self, columns, lab):
+        """ Check if a label is in the list that should not """
+        if lab in columns:
+            ut.show_warning("Warning, "+lab+" is in the selected features list, that's weird")
+
+    def prepare_data(self, filename, columns):
+        """ normalisation of the data """
+        res = []
+        self.labels = []
+        self.check_label(columns, "CellLabel")
+        self.check_label(columns, "CellID")
+        self.check_label(columns, "NucleusID")
+        self.check_label(columns, "NucleusLabel")
+        with open(filename, 'r') as infile:
+            csvreader = csv.DictReader(infile)
+            for row in csvreader:
+                cres = []
+                clab = int(row["CellLabel"])
+                for col in columns:
+                    cres.append(float(row[col])+1)
+                res.append(cres)
+                self.labels.append(clab)
+            tab = np.array(res)    
+            nans = np.isnan( res ).any( axis=1 )
+            kinds = [ind for ind in range(tab.shape[0]) if not nans[ind] ] 
+            tab = tab[ kinds ]
+            self.labels = [ self.labels[ind] for ind in kinds]
+            negs = ( tab<0 ).any( axis=1 )
+            kinds = [ind for ind in range(tab.shape[0]) if not negs[ind] ] 
+            tab = tab[ kinds ]
+            self.labels = [ self.labels[ind] for ind in kinds]
+            tab = np.log(tab)
+            tab = scale(tab)
+            print(tab.shape)
+
+        dist_tab = pdist(tab, metric='euclidean')
+        dist_tab = squareform(dist_tab)
+        self.clustward = ward(dist_tab)
+
+       
+    def show_clusters(self):
+        """ Show dendogram and classified cells """
+        if self.clustward is None:
+            return
+        clustered = fcluster(self.clustward, t=self.nclusters, criterion="maxclust")
+        
+        self.mig.set_cells(self.cluster_img, clustered, self.labels)
+        self.featlayer.refresh()
+        #self.cmap = self.featlayer.colormap.colors 
+        if self.wid is None:
+            self.wid = self.create_plotwidget()
+        self.update_plotwidget(clustered)
+        if "Dendrogram" not in self.viewer.window._dock_widgets:
+            self.viewer.window.add_dock_widget( self.wid, name="Dendrogram" )
+
+    def create_plotwidget(self):
+        mpl_widget = FigureCanvas( Figure(figsize=(6,6) ) )
+        self.fig = mpl_widget.figure
+        self.ax = mpl_widget.figure.subplots()
+        return mpl_widget
+
+    def update_plotwidget(self, clustered):
+        clus_str = [ f"cluster #{l}: n={c}\n" for (l,c) in zip(*np.unique(clustered, return_counts=True)) ]
+
+        cluster_colors = self.get_cluster_colors()
+        cluster_colors_array = [cluster_colors[cl] for cl in clustered]
+        link_cols = {}
+        for i, i12 in enumerate(self.clustward[:,:2].astype(int)):
+            c1, c2 = (link_cols[x] if x > len(self.clustward) else cluster_colors_array[x] for x in i12)
+            link_cols[i+1+len(self.clustward)] = c1 if c1 == c2 else 'k'
+    
+        self.ax.cla()
+        dend = dendrogram(self.clustward, p=8, truncate_mode='level', no_labels=True, ax=self.ax, link_color_func=lambda x: link_cols[x] )
+        self.fig.canvas.draw_idle()
+        #plt.show()
+

fish_feats/Association.py

@@ -0,0 +1,230 @@
+## Associate contours and nuclei by distance 
+## algorithm hongrois: Kuhn-Munkres
+import numpy as np
+from math import sqrt, floor
+from scipy.ndimage.morphology import distance_transform_edt
+from munkres import Munkres
+from skimage.measure import label, regionprops
+
+def distance2DCenters( cent0, cent1, scaleXY ):
+    if cent0 is None:
+        return 0
+    return sqrt( (cent0[0]-cent1[0])*(cent0[0]-cent1[0]) + (cent0[1]-cent1[1])*(cent0[1]-cent1[1]) )*scaleXY
+
+def associateWindows(wlab, wbal, dlim, scaleXY):
+    labels = np.unique(wlab[wlab>0])
+    balels = np.unique(wbal[wbal>0])
+    nbal = len(balels)
+    nlab = len(labels)
+    resbal = np.zeros_like(wbal)
+    n = max(nbal, nlab)
+    matrix = np.zeros((n, n))  ## should be square. 
+    if n == 0:
+        return resbal
+
+    ## distance_transform is distance to closest background, so inverse
+    dist2lab, nearest_coord = distance_transform_edt(wlab==0, return_indices=True)
+    dillabels = np.zeros_like(wlab)
+    ## check if within reasonnable distance
+    dilate_mask = ((dist2lab*scaleXY*scaleXY) <= dlim)
+    masked_nearest_label_coords = [ dind[dilate_mask] for dind in nearest_coord]
+    nearest_labels = wlab[tuple(masked_nearest_label_coords)]
+    dillabels[dilate_mask] = nearest_labels
+
+    ## look for best fit
+    for j, jlab in enumerate(balels):
+        nei = dillabels[wbal==jlab]
+        for i, ilab in enumerate(labels):
+                count = np.sum(nei==ilab)
+                if count > 0:
+                    matrix[i][j] = 1.0/(count+1)
+                else:
+                    matrix[i][j] = dlim+1
+    
+    ## algorithm hongrois: Kuhn-Munkres
+    dmat = np.copy(matrix)
+    munk = Munkres()
+    assoc = munk.compute(matrix)
+    matrix = None
+    munk = None
+    for asso in assoc:
+        if asso[0]<nlab and asso[1]<nbal:
+            if (dmat[asso[0]][asso[1]] > 0) and (dmat[asso[0]][asso[1]]<dlim):
+                ## associate
+                resbal[wbal==balels[asso[1]]] = labels[asso[0]]
+
+    return resbal
+    
+def associateLabWithLab(lab, bal, dlim, scaleXY):
+    """ associate labels of img 2 to labels of img 1 """
+    ##### do overlapping windows otherwise calcul distances too slow (to test)
+    sizex = 1000
+    sizey = 1000
+    over = 50
+    sizes = lab.shape
+
+    posy = 0
+    resbal = np.zeros(bal.shape, dtype="uint16")
+    while posy < sizes[0]:
+        posx = 0
+        while posx < sizes[1]:
+            windowbal = np.copy(bal[posy:(posy+sizey),posx:(posx+sizex)])
+            windowlab = lab[posy:(posy+sizey),posx:(posx+sizex)]
+            assobal = associateWindows( windowlab, windowbal, dlim, scaleXY )
+            bal[posy:(posy+sizey),posx:(posx+sizex)][assobal>0] = 0
+            resbal[posy:(posy+sizey),posx:(posx+sizex)][assobal>0] = assobal[assobal>0]
+                
+            posx += (sizex-over)        
+        posy += (sizey-over)
+
+    ## what is left in bal image has not been associated, add it to the result image as new label
+    maxlab = np.max(lab)
+    for l in np.unique(bal):
+        if l > 0:
+            resbal[bal==l] = maxlab+1
+            maxlab = np.max(resbal)
+ 
+    return resbal     
+
+def associateNucleus(labs, dlimit=3, scaleXY=1):
+    """ Associate each slice with previous slice """
+    for i in range(len(labs)):
+        if i > 1:
+            rlab = associateLabWithLab( labs[i-1,], labs[i,], dlimit, scaleXY )
+            labs[i,] = rlab
+    return labs
+
+def associateOverlap( labimg, labimgprev, threshold_overlap=0.25):
+    nuclei_prop = regionprops( labimg, intensity_image=labimgprev )
+    new_label = np.max(labimgprev) + 1
+    #taken = []
+    for nucprop in nuclei_prop:
+        overlap = nucprop.image_intensity
+        overlabs, counts = np.unique(overlap, return_counts=True)
+        if 0 in overlabs:
+            zero = np.where(overlabs==0)
+            zero = zero[0]
+            overlabs = [over for i, over in enumerate(overlabs) if i != zero]
+            counts = [over for i, over in enumerate(counts) if i != zero]
+        
+        done = False
+        if len(counts)>0:
+            maxlabind = np.argmax( counts )
+            #maxlabind = maxlabind[0]
+            if counts[maxlabind]/nucprop.area > threshold_overlap:
+                ## overlap between the two labels, associate
+                labimg[nucprop.bbox[0]:nucprop.bbox[2], nucprop.bbox[1]:nucprop.bbox[3]][nucprop.image] = overlabs[maxlabind]
+                done = True
+
+        if not done:
+            # no match found, new label
+            labimg[nucprop.bbox[0]:nucprop.bbox[2], nucprop.bbox[1]:nucprop.bbox[3]][nucprop.image] = new_label
+            new_label = new_label + 1
+            #taken.append(maxlabind)
+    return labimg
+
+
+def associateNucleusOverlap(labs, threshold_overlap):
+    """ Associate each slice with previous slice based on IOU """
+    for i, lab in enumerate(labs):
+        if i >= 1:
+            plab = associateOverlap( lab, plab, threshold_overlap )
+        else:
+            # first slice
+            plab = lab
+        labs[i,] = plab
+    return labs 
+
+
+def associate_objects(pop, wnuc, wcells, dlim, scaleXY, scaleZ):
+    ## algorithm hongrois: Kuhn-Munkres
+    ncells = len(wcells)
+    nnuclei = len(wnuc)
+    n = max(ncells, nnuclei)
+    #print(str(ncells)+" "+str(nnuclei)+" "+str(n))
+
+    matrix = np.zeros((n,n))  ## should be square.
+    row = 0
+    for i, cell in enumerate(wcells):
+        for j, nuc in enumerate(wnuc):
+            matrix[i][j] = pop.distanceNucleusToCell( nuc, cell, scaleXY, scaleZ )  ## put more weights to XY distance than z
+
+    munk = Munkres()
+    dmat = np.copy(matrix)
+    assoc = munk.compute(matrix)
+    munk = None
+    associated = []
+    associatedNuc = []
+    #acells = []
+    ## assoc contient indices. If indices > nnuclei or ncells, mean non associated
+    for asso in assoc:
+        if asso[0] < ncells and asso[1] < nnuclei:
+            if dmat[asso[0]][asso[1]] < dlim:
+                ## associate them
+                pop.associateNucleusAndRelabel( nucleus=wnuc[asso[1]], cell=wcells[asso[0]] )
+                associated.append(asso[0])
+                associatedNuc.append(asso[1])
+       
+    dmat = None
+    return associated, associatedNuc   
+
+        
+def associate_nucleiToCell(pop, imgsizes, dlim=20, scaleXY=1, scaleZ=1, pbar=None):
+    """ Need scaling for non isotropic distances """
+    ##### do overlapping windows otherwise association too slow (too big matrix)
+    sizex = floor(180/scaleXY)
+    sizey = floor(180/scaleXY)
+    over = floor(40/scaleXY)
+    margin = floor(5/scaleXY)
+
+    posy = 0
+    #fullcells = []  ## cells with associated nuclei
+    nuclei = pop.nuclei.values()
+    cells = pop.cells.values()
+    if pbar is not None:
+        pbar.total = imgsizes[0]
+    while posy < imgsizes[0]:
+        if pbar is not None:
+            pbar.update(posy)
+        posx = 0
+        while posx < imgsizes[1]:
+            border = (posy, posx, posy+sizey, posx+sizex)
+            
+            winuclei = []
+            leftnuclei = []
+            #print("newcnts "+str(len(newcnts)))
+            for nuc in nuclei:
+                    if nuc.insideBorderCenter(border):
+                        winuclei.append(nuc)
+                    else:
+                        leftnuclei.append(nuc)
+            nuclei = leftnuclei
+            
+            wincells = []
+            border = (posy-margin, posx-margin, posy+sizey+margin, posx+sizex+margin)
+            leftcells = []
+            for cell in cells:
+                    if cell.insideBorderCenter(border):
+                        wincells.append(cell)
+                    else:
+                        leftcells.append(cell)
+            
+            if len(winuclei)>0 and len(wincells)>0:
+                associated, associatedNuc = associate_objects(pop, winuclei, wincells, dlim, scaleXY, scaleZ)
+                #fullcells = fullcells + acells
+                
+                for i in range(len(wincells)):
+                    if i not in associated:
+                        leftcells.append(wincells[i])
+                
+                for i in range(len(winuclei)):
+                    if i not in associatedNuc:
+                        nuclei.append(winuclei[i])
+                        
+            cells = leftcells
+                
+            posx += (sizex-over)        
+        posy += (sizey-over)
+ 
+    print("Unassociated nuclei left "+str(len(nuclei)))
+    pop.relabelUnassociatedNuclei(nuclei)