epicure.outputing

   1"""
   2    **EpiCure output interface**
   3
   4    Handles the onglet `Output` of EpiCure interface.
   5    This panel offers option to export the results in various format or to analyse directly the results in the plugin and display the measures tables, plot and save it.
   6
   7"""
   8import pandas as pand
   9import numpy as np
  10import roifile
  11from skimage.measure import label
  12import os, time
  13import napari
  14from napari.utils import progress
  15import epicure.Utils as ut
  16import epicure.epiwidgets as wid
  17from epicure.trackmate_export import save_trackmate_xml
  18from epicure.geff_export import save_geff
  19import plotly.express as px
  20from qtpy import QtCore
  21from qtpy.QtCore import Qt
  22from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget, QTableWidget, QTableWidgetItem, QGridLayout, QListWidget, QTextBrowser
  23from qtpy.QtWidgets import QAbstractItemView as aiv
  24from random import sample
  25from joblib import Parallel, delayed
  26import webbrowser
  27import tempfile
  28try:
  29    QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts, True)  ## for QtWebEngine import to work on some computers
  30except:
  31    pass
  32
  33from skimage.morphology import disk
  34import skimage
  35if ut.version_above( skimage, "0.25" ):
  36    try:
  37        from skimage.morphology import erosion as binary_erosion 
  38    except:
  39        from skimage.morphology import binary_erosion
  40else:
  41    try:
  42        from skimage.morphology import binary_erosion
  43    except:
  44        from skimage.morphology import erosion as binary_erosion 
  45    
  46
  47class Outputing(QWidget):
  48
  49    def __init__(self, napari_viewer, epic):
  50        """ Initialisation of the interface """
  51        super().__init__()
  52        self.viewer = napari_viewer
  53        self.epicure = epic
  54        self.table = None
  55        self.table_selection = None
  56        self.seglayer = self.viewer.layers["Segmentation"]
  57        self.movlayer = self.viewer.layers["Movie"]
  58        self.selection_choices = ["All cells", "Only selected cell"]
  59        self.output_options = ["", "Export to extern plugins", "Export segmentations", "Measure cell features", "Measure track features", "Export/Measure events", "Save as...", "Save screenshot movie", "Measure vertices"]
  60        self.tplots = None
  61        
  62        chanlist = ["Movie"]
  63        if self.epicure.others is not None:
  64            for chan in self.epicure.others_chanlist:
  65                chanlist.append( "MovieChannel_"+str(chan) )
  66        self.cell_features = CellFeatures( chanlist )
  67        self.event_classes = EventClass( self.epicure ) 
  68        
  69        all_layout = QVBoxLayout()
  70        self.scaled_unit = wid.add_check( "Measures in scaled units", False, check_func=None, descr="Scales the output measures in the given spatio-temporal units (µm, min..)" )
  71        all_layout.addWidget( self.scaled_unit )
  72        self.choose_output = wid.listbox() 
  73        all_layout.addWidget(self.choose_output)
  74        for option in self.output_options:
  75            self.choose_output.addItem(option)
  76        self.choose_output.currentIndexChanged.connect(self.show_output_option)
  77        
  78        ## Choice of active selection
  79        #layout = QVBoxLayout()
  80        selection_layout, self.output_mode = wid.list_line( "Apply on", descr="Choose on which cell(s) to do the action", func=None )
  81        for sel in self.selection_choices:
  82            self.output_mode.addItem(sel)
  83        all_layout.addLayout(selection_layout)
  84       
  85        ## Choice of interface
  86        self.export_group, export_layout = wid.group_layout( "Export to extern plugins" )
  87        griot_btn = wid.add_button( "Current frame to Griottes", self.to_griot, "Launch(in new window) Griottes plugin on current frame" )
  88        export_layout.addWidget(griot_btn)
  89        ncp_btn = wid.add_button( "Current frame to Cluster-Plotter", self.to_ncp, "Launch (in new window) cluster-plotter plugin on current frame" )
  90        export_layout.addWidget(ncp_btn)
  91        self.export_group.setLayout(export_layout)
  92        all_layout.addWidget(self.export_group)
  93        
  94        ## Option to export segmentation results
  95        self.export_seg_group, layout = wid.group_layout(self.output_options[2])
  96        save_line, self.save_choice = wid.button_list( "Save segmentation as", self.save_segmentation, "Save the current segmentation either as ROI, label image or skeleton" ) 
  97        self.save_choice.addItem( "labels" )
  98        self.save_choice.addItem( "ROI" )
  99        self.save_choice.addItem( "skeleton" )
 100        layout.addLayout( save_line )
 101
 102        self.export_seg_group.setLayout(layout)
 103        all_layout.addWidget(self.export_seg_group)
 104
 105        #### Features group
 106        self.feature_group, featlayout = wid.group_layout(self.output_options[3])
 107        
 108        self.choose_features_btn = wid.add_button( "Choose features...", self.choose_features, "Open a window to select the features to measure" )
 109        featlayout.addWidget(self.choose_features_btn)
 110
 111        self.feature_table = wid.add_button( "Create features table", self.show_table, "Measure the selected features and display it as a clickable table" )
 112        featlayout.addWidget(self.feature_table)
 113        self.featTable = FeaturesTable(self.viewer, self.epicure)
 114        featlayout.addWidget(self.featTable)
 115        
 116        ######## Temporal option  
 117        self.temp_graph = wid.add_button( "Table to temporal graphs...", self.temporal_graphs, "Open a plot interface of measured features temporal evolution" )
 118        featlayout.addWidget(self.temp_graph)
 119        self.temp_graph.setEnabled(False)
 120       
 121        ######## Drawing option
 122        featmap, self.show_feature_map = wid.list_line( "Draw feature map:", descr="Add a layer with the cells colored by the selected feature value", func=self.show_feature )
 123        featlayout.addLayout(featmap)
 124        orienbtn = wid.add_button( "Draw cell orientation", self.draw_orientation, "Add a layer with each cell main axis orientation and length " )
 125        featlayout.addWidget( orienbtn )
 126
 127        save_tab_line, self.save_format = wid.button_list( "Save features table", self.save_measure_features, "Save the current table in a .csv file" )
 128        self.save_format.addItem( "csv" )
 129        self.save_format.addItem( "xlsx" )
 130        featlayout.addLayout(save_tab_line)
 131
 132        ## skrub table
 133        self.stat_table = wid.add_button( "Open statistiques table...", self.skrub_features, "Open interactive table with the features statistiques (skrub library)" )
 134        featlayout.addWidget(self.stat_table)
 135        
 136        self.feature_group.setLayout(featlayout)
 137        self.feature_group.hide()
 138        all_layout.addWidget(self.feature_group)
 139
 140        ## Track features
 141        self.trackfeat_group, trackfeatlayout = wid.group_layout(self.output_options[4])
 142        self.trackfeat_table = wid.add_button( "Track features table", self.show_trackfeature_table, "Measure track-related feature and show a table by track" )
 143        trackfeatlayout.addWidget(self.trackfeat_table)
 144        self.trackTable = FeaturesTable(self.viewer, self.epicure)
 145        trackfeatlayout.addWidget(self.trackTable)
 146        self.save_table_track = wid.add_button( "Save track table", self.save_table_tracks, "Save the current table in a .csv file" )
 147        trackfeatlayout.addWidget(self.save_table_track)
 148        
 149        self.trackfeat_group.setLayout(trackfeatlayout)
 150        self.trackfeat_group.hide()
 151        all_layout.addWidget(self.trackfeat_group)
 152
 153        ## Option to export/measure events (Fiji ROI or table), + graphs ?
 154        self.handle_event_group, elayout = wid.group_layout(self.output_options[5])
 155        self.choose_events_btn = wid.add_button( "Choose events...", self.choose_events, "Open a window to select the events to export/measure" )
 156        elayout.addWidget( self.choose_events_btn )
 157        save_evt_line, self.save_evt_choice = wid.button_list( "Export events as", self.export_events, "Save the checked events as Fiji ROIs or .csv table" ) 
 158        self.save_evt_choice.addItem( "Fiji ROI" )
 159        self.save_evt_choice.addItem( "CSV File" )
 160        elayout.addLayout( save_evt_line )
 161        count_evt_btn = wid.add_button( "Count events", self.temporal_graphs_events, descr="Create temporal plot of number of events" )
 162        elayout.addWidget( count_evt_btn )
 163
 164        self.handle_event_group.setLayout( elayout )
 165        self.handle_event_group.hide()
 166        all_layout.addWidget( self.handle_event_group )
 167
 168        ## Save TrackMate XML option
 169        self.save_as_group, save_as_layout = wid.group_layout( "Save as..." )
 170        self.save_tm_btn = wid.add_button( "Save as TrackMate XML", self.save_tm_xml, "Save the current segmentation and the optional tracking in a TrackMate XML file" )
 171        self.save_geff_btn = wid.add_button( "Save as GEFF", self.save_geff, "Save the segmentation and tracks to GEFF" )
 172        save_as_layout.addWidget( self.save_tm_btn )
 173        save_as_layout.addWidget( self.save_geff_btn )
 174        
 175        self.save_as_group.setLayout( save_as_layout )
 176        self.save_as_group.hide()
 177        all_layout.addWidget( self.save_as_group )
 178       
 179        ## Save screenshots option
 180        current_frame = ut.current_frame( self.epicure.viewer )
 181        self.screenshot_group, screenshot_layout = wid.group_layout( "Save screenshot movie" )
 182        self.show_scalebar = wid.add_check_tolayout( screenshot_layout, "With the scale bar", True, check_func=None, descr="Show the scale bar in the screenshots" )
 183        sframe_line, self.sframe = wid.slider_line( "From frame", 0, self.epicure.nframes, 1, value=current_frame, show_value=True, slidefunc=None, descr="Frame from which to start saving screenshots" )
 184        eframe_line, self.eframe = wid.slider_line( "To frame", 0, self.epicure.nframes, 1, value=current_frame+1, show_value=True, slidefunc=None, descr="Frame until which to save screenshots" )
 185        screenshot_layout.addLayout( sframe_line )
 186        screenshot_layout.addLayout( eframe_line )
 187        savescreen_btn = wid.add_button( "Save current view", self.screenshot_movie, "Save the current view (with current display parameters) for frame between the two specified frames in a movie" )
 188
 189        screenshot_layout.addWidget(savescreen_btn)
 190        self.screenshot_group.setLayout(screenshot_layout)
 191        all_layout.addWidget(self.screenshot_group)
 192        self.screenshot_group.hide()
 193        
 194        ## Measure vertex options
 195        self.vertex_group, vertices_layout = wid.group_layout( "Measure vertices" )
 196        radius_line, self.vertice_radius = wid.value_line("Vertex radius", "1.25", descr="Radius of a vertex (TCJ) to consider as one point and measure intensities")
 197        display_radius_line, self.vertice_display_radius = wid.value_line("Display radius", "3", descr="Radius of a vertex for DISPLAY only (size of drawing in the layer)")
 198        vertices_layout.addLayout(radius_line)
 199        vertices_layout.addLayout(display_radius_line)
 200        self.vertices_btn = wid.add_button( "Measure", self.show_vertices_table, "Measure the vertices (connectivity, intensity)" )
 201        vertices_layout.addWidget( self.vertices_btn )
 202        self.verticesTable = FeaturesTable(self.viewer, self.epicure)
 203        vertices_layout.addWidget(self.verticesTable)
 204        self.save_table_vertices = wid.add_button( "Save vertices table", self.save_vertices_table, "Save the current table in a .csv file" )
 205        vertices_layout.addWidget(self.save_table_vertices)
 206        
 207        self.vertex_group.setLayout( vertices_layout )
 208        all_layout.addWidget(self.vertex_group)
 209        self.vertex_group.hide()
 210        
 211        ## Finished
 212        self.setLayout(all_layout)
 213        self.show_output_option()
 214
 215    def get_current_settings( self ):
 216        """ Returns current settings of the widget """
 217        disp = {}
 218        disp["Apply on"] = self.output_mode.currentText() 
 219        disp["Current option"] = self.choose_output.currentText()
 220        disp["Show scalebar"] = self.show_scalebar.isChecked()
 221        disp = self.cell_features.get_current_settings( disp )
 222        disp = self.event_classes.get_current_settings( disp )
 223        return disp
 224
 225    def apply_settings( self, settings ):
 226        """ Set the current state of the widget from preferences if any """
 227        for setting, val in settings.items():
 228            if setting == "Apply on":
 229                self.output_mode.setCurrentText( val )
 230            if setting == "Current option":
 231                self.choose_output.setCurrentText( val )
 232            if setting == "Show scalebar":
 233                self.show_scalebar.setChecked( val )
 234            
 235        self.cell_features.apply_settings( settings )
 236        self.event_classes.apply_settings( settings )
 237
 238    def screenshot_movie( self ):
 239        """ Save screenshots of the current view """
 240        scale_visibility = self.viewer.scale_bar.visible
 241        current_frame = ut.current_frame( self.epicure.viewer )
 242        self.viewer.scale_bar.visible = self.show_scalebar.isChecked()
 243        start_frame = max( self.sframe.value(), 0 )
 244        end_frame = min( self.eframe.value(), self.epicure.nframes )
 245        outname = os.path.join( self.epicure.outdir, self.epicure.imgname+"_screenshots_f"+str(start_frame)+"-"+str(end_frame)+".tif" )
 246        if os.path.exists(outname):
 247            os.remove(outname)
 248        if start_frame > end_frame:
 249            ut.show_warning("From frame > to frame, no screenshot saved")
 250            return
 251        for frame in range(start_frame, end_frame+1):
 252            self.viewer.dims.set_point(0, frame)
 253            shot = self.viewer.screenshot( canvas_only=True, flash=False )
 254            ut.appendToTif( shot, outname )
 255        self.viewer.scale_bar.visible = scale_visibility
 256        self.viewer.dims.set_point(0, current_frame)
 257        ut.show_info( "Screenshot movie saved in "+outname )
 258
 259    def events_select( self, event, check ):
 260        """ Check/Uncheck the event in event types list """
 261        if event in self.event_classes.evt_classes:
 262            self.event_classes.evt_classes[ event ][0].setChecked( check )
 263        else:
 264            print(event+" not found in possible event types to export")
 265
 266    def show_output_option(self):
 267        """ Show selected output panel """
 268        cur_option = self.choose_output.currentText()
 269        self.export_group.setVisible( cur_option == "Export to extern plugins" )
 270        self.export_seg_group.setVisible( cur_option == "Export segmentations" )
 271        self.feature_group.setVisible( cur_option == "Measure cell features" )
 272        self.vertex_group.setVisible( cur_option == "Measure vertices" )
 273        self.trackfeat_group.setVisible( cur_option == "Measure track features" )
 274        self.handle_event_group.setVisible( cur_option == "Export/Measure events" )
 275        self.save_as_group.setVisible( cur_option == "Save as..." )
 276        self.screenshot_group.setVisible( cur_option == "Save screenshot movie" )
 277
 278    def get_current_labels( self ):
 279        """ Get the cell labels to process according to current selection of apply on"""
 280        if self.output_mode.currentText() == "Only selected cell": 
 281            lab = self.epicure.seglayer.selected_label
 282            return [lab]
 283        if self.output_mode.currentText() == "All cells": 
 284            return self.epicure.get_labels()
 285        else:
 286            group = self.output_mode.currentText()
 287            label_group = self.epicure.groups[group]
 288            return label_group
 289
 290            
 291    def get_selection_name(self):
 292        if self.output_mode.currentText() == "Only selected cell": 
 293            lab = self.epicure.seglayer.selected_label
 294            return "_cell_"+str(lab) 
 295        #if self.output_mode.currentText() == "Only checked cells":
 296        #    return "_checked_cells"
 297        if self.output_mode.currentText() == "All cells":
 298            return ""
 299        return "_"+self.output_mode.currentText()
 300
 301    def skrub_features( self ):
 302        """ Open html table interactive and stats with skrub module """
 303        try:
 304            from skrub import TableReport
 305        except:
 306            ut.show_error( "Needs skrub library for this option. Install it (`pip install skrub`) before" )
 307            return
 308        if self.table is None:
 309            ut.show_warning( "Create/update the table before" )
 310            return
 311        report = TableReport( self.table )
 312        report.open()
 313        
 314
 315    def save_measure_features(self):
 316        """ Save measures table to file whether it was created or not """
 317        if self.table is None or self.table_selection is None or self.selection_changed() :
 318            ut.show_warning("Create/update the table before")
 319            return
 320        ext = self.save_format.currentText()
 321        outfile = self.epicure.outname()+"_features"+self.get_selection_name()+"."+ext
 322        if ext == "xlsx":
 323            self.table.to_excel( outfile, sheet_name='EpiCureMeasures' )
 324        else:
 325            self.table.to_csv( outfile, index=False )
 326        if self.epicure.verbose > 0:
 327            ut.show_info("Measures saved in "+outfile)
 328    
 329    def save_table_tracks(self):
 330        """ Save tracks table to file whether it was created or not """
 331        if self.table is None or self.table_selection is None or self.selection_changed() :
 332            ut.show_warning("Create/update the table before")
 333            return
 334        outfile = self.epicure.outname()+"_trackfeatures"+self.get_selection_name()+".xlsx"
 335        self.table.to_excel( outfile, sheet_name='EpiCureTrackMeasures' )
 336        if self.epicure.verbose > 0:
 337            ut.show_info("Track measures saved in "+outfile)
 338
 339
 340    def save_one_roi(self, lab):
 341        """ Save the Rois of cell with label lab """
 342        keep = self.seglayer.data == lab
 343        rois = []
 344        if np.sum(keep) > 0:
 345            ## add 2D case
 346            for iframe, frame in enumerate(keep):
 347                if np.sum(frame) > 0:
 348                    contour = ut.get_contours(frame)
 349                    roi = self.create_roi(contour[0], iframe, lab)
 350                    rois.append(roi)
 351
 352        roifile.roiwrite(self.epicure.outname()+"_rois_cell_"+str(lab)+".zip", rois, mode='w')
 353
 354    def create_roi(self, contour, frame, label):
 355        croi = roifile.ImagejRoi()
 356        croi.version = 227
 357        croi.roitype = roifile.ROI_TYPE(0) ## polygon
 358        croi.n_coordinates = len(contour)
 359        croi.position = frame + 1
 360        croi.t_position = frame+1
 361        coords = []
 362        cent0 = 0
 363        cent1 = 0
 364        for cont in contour:
 365            coords.append([int(cont[1]), int(cont[0])])
 366            cent0 += cont[1]
 367            cent1 += cont[0]
 368        croi.integer_coordinates = np.array(coords)
 369        #croi.top = int(np.min(coords[0]))
 370        #croi.left = int(np.min(coords[1]))
 371        croi.name = str(frame+1).zfill(4)+'-'+str(int(cent0/len(contour))).zfill(4)+"-"+str(int(cent1/len(contour))).zfill(4)
 372        return croi
 373    
 374    def save_segmentation( self ):
 375        """ Save current segmentation in selected format """
 376        if self.output_mode.currentText() == "Only selected cell": 
 377            ## output only the selected cell
 378            lab = self.seglayer.selected_label
 379            if self.save_choice.currentText() == "ROI":
 380                self.save_one_roi(lab)
 381                if self.epicure.verbose > 0:
 382                    ut.show_info("Cell "+str(lab)+" saved to Fiji ROI")
 383                return
 384            else:
 385                tosave = np.zeros(self.seglayer.data.shape, dtype=self.epicure.dtype)
 386                if np.sum(self.seglayer.data==lab) > 0:
 387                    tosave[self.seglayer.data==lab] = lab
 388                endname = "_"+self.save_choice.currentText()+"_"+str(lab)+".tif"
 389        else:
 390            ## output all cells
 391            if self.output_mode.currentText() == "All cells":
 392                if self.save_choice.currentText() == "ROI":
 393                    self.save_all_rois()
 394                    return
 395                tosave = self.seglayer.data
 396                endname = "_"+self.save_choice.currentText()+".tif"
 397            else:
 398                ## or output only selected group
 399                group = self.output_mode.currentText()
 400                label_group = self.epicure.groups[group]
 401                if self.save_choice.currentText() == "ROI":
 402                    ncells = 0
 403                    for lab in label_group:
 404                        self.save_one_roi(lab)
 405                        ncells += 1
 406                    if self.epicure.verbose > 0:
 407                        ut.show_info(str(ncells)+" cells saved to Fiji ROIs")
 408                    return
 409                tosave = np.zeros(self.seglayer.data.shape, dtype=self.epicure.dtype)
 410                endname = "_"+self.save_choice.currentText()+"_"+self.output_mode.currentText()+".tif"
 411                for lab in label_group:
 412                    tosave[self.seglayer.data==lab] = lab
 413        
 414        ## save filled image (for label or skeleton) to file
 415        outname = os.path.join( self.epicure.outdir, self.epicure.imgname+endname )
 416        if self.save_choice.currentText() == "skeleton":
 417            parallel = 0
 418            if self.epicure.process_parallel:
 419                parallel = self.epicure.nparallel
 420            tosave = ut.get_skeleton( tosave, viewer=self.viewer, verbose=self.epicure.verbose, parallel=parallel )
 421            ut.writeTif( tosave, outname, self.epicure.epi_metadata["ScaleXY"], 'uint8', what="Skeleton" )
 422        else:
 423            ut.writeTif(tosave, outname, self.epicure.epi_metadata["ScaleXY"], 'float32', what="Segmentation")
 424                
 425    def save_all_rois( self ):
 426        """ Save all cells to ROI format """
 427        ncells = 0
 428        for lab in np.unique(self.epicure.seglayer.data):
 429            self.save_one_roi(lab)
 430            ncells += 1
 431        if self.epicure.verbose > 0:
 432            ut.show_info(str(ncells)+" cells saved to Fiji ROIs")
 433
 434    def choose_features( self ):
 435        """ Pop-up widget to choose the features to measure """
 436        self.cell_features.choose()
 437    
 438    def show_vertices_table(self):
 439        """ Show the measurement of vertices table """
 440        self.measure_vertices()
 441        self.verticesTable.set_table(self.table)
 442    
 443    def save_vertices_table(self):
 444        """ Save vertices table to file whether it was created or not """
 445        if self.table is None:
 446            ut.show_warning("Create/update the table before")
 447            return
 448        outfile = self.epicure.outname()+"_vertices"+".xlsx"
 449        self.table.to_excel( outfile, sheet_name='EpiCureVerticesMeasures' )
 450        if self.epicure.verbose > 0:
 451            ut.show_info("Vertices measures saved in "+outfile)
 452
 453
 454    def measure_vertices(self):
 455        """ Get all vertices (TCJ) and measure their properties """
 456        def nb_neighbors(regionmask, labimg):
 457            """ Measure the nb of neighbors (labels) around each point """
 458            #footprint = disk(radius=8)
 459            #dilated = binary_dilation(regionmask, footprint)
 460            labels = np.unique(labimg[regionmask]).tolist()
 461            nb_nei = len(labels)
 462            if 0 in labels:
 463                nb_nei = nb_nei - 1
 464            return nb_nei 
 465
 466        self.table = None
 467        radius = float(self.vertice_radius.text()) 
 468        display_radius = float(self.vertice_display_radius.text()) 
 469        ## difference between the measured radius and the displayed radius
 470        diff_radius = display_radius - radius
 471        if diff_radius < 0:
 472            diff_radius = 0
 473        parallel = 0
 474        if self.epicure.process_parallel:
 475            parallel = self.epicure.nparallel
 476        ## Get the vertices: junctions of several skeleton lines
 477        vertex_img = ut.get_vertices( self.epicure.seg, viewer=None, verbose=self.epicure.verbose, parallel=parallel )
 478        vertices_img = np.zeros(vertex_img.shape, dtype=np.int8)
 479        ## Individualise, measure, draw
 480        for ind, frame in enumerate(vertex_img):
 481            props = ut.binary_properties(frame)
 482            nvertex = len(props)
 483            vertices = []
 484            for prop in props:
 485                if prop.label > 0:
 486                    pt = prop.centroid
 487                    vertices.append(pt)
 488            vert_img = ut.draw_points(vertices, vertex_img.shape[1:], radius=radius)
 489            props = ut.binary_properties(vert_img)
 490            if nvertex != len(props):
 491                ## one or more vertices had been merged
 492                vertices = []
 493                for prop in props:
 494                    if prop.label > 0:
 495                        pt = prop.centroid
 496                        vertices.append(pt)
 497                vert_img = ut.draw_points(vertices, vertex_img.shape[1:], radius=radius)
 498            #vertices_img[ind] = vert_img
 499            lbl_img = label(vert_img)
 500            int_measures = pand.DataFrame(ut.regionprops_table(lbl_img, self.movlayer.data[ind], properties=["label", "centroid", "intensity_mean"]))
 501            ## expand to measure neighbors
 502            exp_lbl = ut.touching_labels(lbl_img, expand=3)
 503            measures = pand.DataFrame(ut.regionprops_table(exp_lbl, self.epicure.seg[ind], properties=["label"], extra_properties=[nb_neighbors] ))
 504            ## Color the vertices by their number of neighbors
 505            for lab in measures["label"]:
 506                vertices_img[ind][lbl_img==lab] = int(measures.loc[measures["label"]==lab,"nb_neighbors"].iloc[0])
 507            df = pand.merge(int_measures, measures, on="label", how="inner")
 508            df["Frame"] = ind
 509            
 510            if self.table is None:
 511                self.table = df
 512            else:
 513                self.table = pand.concat([self.table, df])
 514
 515            ## Expand for display only
 516            vertices_img[ind] = ut.touching_labels(vertices_img[ind], expand=diff_radius)
 517
 518        ## Display the vertices in a new layer
 519        ut.remove_layer(self.viewer, "Vertices") # in case already present
 520        self.viewer.add_labels(vertices_img, blending="additive", name="Vertices",  scale=self.viewer.layers["Movie"].scale, opacity=1)
 521
 522    def measure_features(self):
 523        """ Measure features and put them to table """
 524        thick = self.epicure.thickness
 525
 526        def intensity_junction_cytoplasm(regionmask, intensity):
 527            """ Measure the intensity only on the contour of regionmask """
 528            footprint = disk(radius=thick)
 529            inside = binary_erosion(regionmask, footprint)
 530            inside_intensity = ut.mean_nonzero(intensity*inside)
 531            periph_intensity = ut.mean_nonzero(intensity*(regionmask^inside))
 532            return inside_intensity, periph_intensity
 533        
 534        if self.epicure.verbose > 0:
 535            print("Measuring features")
 536        #self.viewer.window._status_bar._toggle_activity_dock(True)
 537        pb = ut.start_progress( self.viewer, total=2, descr="Measuring cells in all movie" )
 538        start_time = time.time()
 539        if self.output_mode.currentText() == "Only selected cell": 
 540            meas = np.zeros(self.epicure.seglayer.data.shape, self.epicure.dtype)
 541            lab = self.epicure.seglayer.selected_label
 542            meas[self.epicure.seglayer.data==lab] = lab
 543        else:
 544            if self.output_mode.currentText() == "All cells": 
 545                meas = self.epicure.seglayer.data
 546            else:
 547                group = self.output_mode.currentText()
 548                meas = np.zeros(self.epicure.seglayer.data.shape, self.epicure.dtype)
 549                label_group = self.epicure.groups[group]
 550                for lab in label_group:
 551                    meas[self.epicure.seglayer.data==lab] = lab
 552            
 553        properties, prop_extra, other_features, int_feat, int_extrafeat = self.cell_features.get_features()
 554        do_channels = self.cell_features.get_channels()
 555        extra_prop = []
 556        if "intensity_junction_cytoplasm" in int_extrafeat:
 557            extra_prop = extra_prop + [intensity_junction_cytoplasm]
 558
 559        extra_properties = []
 560        if (do_channels is not None) and ("Movie" in do_channels):
 561            properties = properties + int_feat
 562            for extra in int_extrafeat:
 563                if extra == "intensity_junction_cytoplasm":
 564                    extra_properties = extra_properties + [intensity_junction_cytoplasm]
 565        
 566        pb.update()
 567        labgroups = self.epicure.group_of_labels()
 568        pb.total = self.epicure.nframes
 569        chan_dict = dict()
 570        if ( do_channels is not None ):
 571            for chan in do_channels:
 572                if chan == "Movie":
 573                    continue
 574                chan_dict[chan] = self.viewer.layers[chan].data
 575        seg = self.epicure.seg
 576        mov = self.movlayer.data
 577        
 578        def measure_one_frame_collect( img, frame ):
 579            """ Measure on one frame and return a list of dicts for each label """
 580            #pb.update()
 581            intimg = mov[frame]
 582            frame_table = pand.DataFrame( ut.labels_table(img, intensity_image=intimg, properties=properties, extra_properties=extra_properties) )
 583            if "group" in other_features:
 584                frame_table["group"] = frame_table["label"].map(labgroups).fillna("Ungrouped")
 585            frame_table["frame"] = frame
 586            
 587            # Boundary
 588            if "Boundary" in other_features:
 589                boundimg = seg[frame]
 590                bds = ut.get_boundary_cells(boundimg)
 591                frame_table["Boundary"] = frame_table["label"].isin(bds).astype(int)
 592            # Border
 593            if "Border" in other_features:
 594                bds = ut.get_border_cells(img)
 595                frame_table["Border"] = frame_table["label"].isin(bds).astype(int)
 596            
 597            # Intensity features in other channels
 598            for chan, intimg_chan in chan_dict.items():
 599                intimg_frame = intimg_chan[frame]
 600                frame_tab = ut.labels_table(img, intensity_image=intimg_frame, properties=int_feat, extra_properties=extra_prop)
 601                for add_prop in int_feat:
 602                    frame_table[add_prop+"_"+str(chan)] = frame_tab[add_prop]
 603                if "intensity_junction_cytoplasm-0" in frame_tab.keys():
 604                    frame_table["intensity_cytoplasm_"+str(chan)] = frame_tab["intensity_junction_cytoplasm-0"]
 605                    frame_table["intensity_junction_"+str(chan)] = frame_tab["intensity_junction_cytoplasm-1"]
 606            
 607            if prop_extra != []:
 608                if "shape_index" in prop_extra:
 609                    frame_table["shape_index"] = frame_table["perimeter"] / np.sqrt(frame_table["area"])
 610                if "roundness" in prop_extra:
 611                    frame_table["roundness"] = 4*frame_table["area"] /(np.pi * np.power(frame_table["axis_major_length"],2) )
 612                if "aspect_ratio" in prop_extra:
 613                    frame_table["aspect_ratio"] = frame_table["axis_major_length"] / frame_table["axis_minor_length"]
 614
 615            # Neighbor features
 616            do_neighbor = "NbNeighbors" in other_features
 617            get_neighbor = "Neighbors" in other_features
 618            if do_neighbor or get_neighbor:
 619                nimg = seg[frame]
 620                graph = ut.get_neighbor_graph(nimg, distance=3)
 621                all_neighbors = {label: list(graph.adj[label]) for label in graph.nodes}
 622                frame_table["neighborlist"] = frame_table["label"].map(lambda l: all_neighbors.get(l, []))
 623
 624            if do_neighbor:
 625                frame_table["NbNeighbors"] = frame_table["neighborlist"].apply(
 626                lambda x: len(x) if x else -1
 627                )
 628            if get_neighbor:
 629                frame_table["Neighbors"] = frame_table["neighborlist"].apply(
 630                lambda x: "&".join(map(str, x)) if x else ""
 631                )
 632            if do_neighbor or get_neighbor:
 633                frame_table.drop(columns="neighborlist", inplace=True)
 634            return pand.DataFrame( frame_table.to_dict(orient="records") )
 635
 636        if self.epicure.process_parallel:
 637            frame_tables = Parallel( n_jobs=self.epicure.nparallel ) ( 
 638                delayed( measure_one_frame_collect ) ( frame, iframe ) for iframe, frame in enumerate(meas) )
 639        else:
 640            frame_tables = [
 641                measure_one_frame_collect( frame, iframe )
 642                for iframe, frame in (enumerate(meas))
 643            ]
 644        self.table = pand.concat(frame_tables, ignore_index=True)
 645
 646        if "intensity_junction_cytoplasm-0" in self.table.columns:
 647            self.table = self.table.rename(columns={"intensity_junction_cytoplasm-0": "intensity_cytoplasm", "intensity_junction_cytoplasm-1":"intensity_junction"})
 648        self.table_selection = self.selection_choices.index(self.output_mode.currentText())
 649        ut.close_progress( self.viewer, pb )
 650        #self.viewer.window._status_bar._toggle_activity_dock(False)
 651        if self.epicure.verbose > 0:
 652            ut.show_info("Features measured in "+"{:.3f}".format((time.time()-start_time)/60)+" min")
 653
 654    def measure_one_frame(self, img, properties, extra_properties, other_features, channels, int_feat, int_extrafeat, frame, labgroups, prop_extra ):
 655        """ Measure on one frame """
 656        if frame is not None:
 657            intimg = self.movlayer.data[frame]
 658        else:
 659            intimg = self.movlayer.data
 660        first = "label" not in self.table.keys()
 661        nrows = len(self.table["label"]) if "label" in self.table.keys() else 0
 662        
 663        ## add the basic label measures
 664        frame_table = ut.labels_table( img, intensity_image=intimg, properties=properties, extra_properties=extra_properties )
 665        ndata = len(frame_table["label"])
 666        for key, value in frame_table.items():
 667            if first:
 668                self.table[key] = []
 669            self.table[key].extend(list(value))
 670
 671        ## add the frame column
 672        if frame is not None:
 673            if first:
 674                self.table["frame"] = []
 675            self.table["frame"].extend([frame]*ndata)
 676
 677        ## add info of the cell group
 678        if "group" in other_features:
 679            frame_group = [ labgroups[label] if label in labgroups.keys() else "Ungrouped" for label in frame_table["label"] ]
 680            if first:
 681                self.table["group"] = []
 682            self.table["group"].extend( frame_group )
 683
 684        ## add the extra shape features
 685        if prop_extra != []:
 686            if "shape_index" in prop_extra:
 687                si = frame_table["perimeter"] /np.sqrt( frame_table["area"] ) 
 688                if first:
 689                    self.table["shape_index"] = []
 690                self.table["shape_index"].extend( si )
 691            if "roundness" in prop_extra:
 692                rou = 4*frame_table["area"] /(np.pi * np.power(frame_table["axis_major_length"],2) ) 
 693                if first:
 694                    self.table["roundness"] = []
 695                self.table["roundness"].extend( rou )
 696            if "aspect_ratio" in prop_extra:
 697                ar = list( np.array(frame_table["axis_major_length"])/np.array(frame_table["axis_minor_length"]) )
 698                if first:
 699                    self.table["aspect_ratio"] = []
 700                self.table["aspect_ratio"].extend( ar )
 701
 702        ### Measure intensity features in other chanels if option is on
 703        if (channels is not None):
 704            for chan in channels:
 705                ## if it's movie, already measured in the general measure
 706                if chan == "Movie":
 707                    continue
 708                ## otherwise, do a new measure on the selected channels
 709                if frame is not None:
 710                    intimg = self.viewer.layers[chan].data[frame]
 711                else:
 712                    intimg = self.viewer.layers[chan].data
 713                frame_tab = ut.labels_table( img, intensity_image=intimg, properties=int_feat, extra_properties=int_extrafeat )
 714                for add_prop in int_feat:
 715                    if first:
 716                        self.table[add_prop+"_"+chan] = []
 717                    self.table[add_prop+"_"+chan].extend( list(frame_tab[add_prop]) )
 718                if "intensity_junction_cytoplasm-0" in frame_tab.keys():
 719                    if first:
 720                        self.table["intensity_cytoplasm_"+chan] = []
 721                        self.table["intensity_junction_"+str(chan)] = []
 722                    self.table["intensity_cytoplasm_"+chan].extend( list(frame_tab["intensity_junction_cytoplasm-0"]) )
 723                    self.table["intensity_junction_"+str(chan)].extend( list(frame_tab["intensity_junction_cytoplasm-1"]) )
 724                
 725            
 726        ## add features of neighbors relationship with graph
 727        do_neighbor = "NbNeighbors" in other_features
 728        get_neighbor = "Neighbors" in other_features
 729        if do_neighbor or get_neighbor:
 730            if frame is not None:
 731                nimg = self.epicure.seg[frame]
 732            else:
 733                nimg = self.epicure.seg
 734            #start_time = ut.start_time()
 735            graph = ut.get_neighbor_graph( nimg, distance=3 )
 736            
 737            if first:
 738                if do_neighbor:
 739                    self.table["NbNeighbors"] = []
 740                if get_neighbor:
 741                    self.table["Neighbors"] = []
 742            if do_neighbor:
 743                self.table["NbNeighbors"].extend( [-1]*ndata )
 744            if get_neighbor:
 745                self.table["Neighbors"].extend( [""]*ndata )
 746
 747            for label in np.unique(frame_table["label"]):
 748                if label in graph.nodes:
 749                    rlabel = np.where( (frame_table["label"] == label) )[0]
 750                    nneighbor = len(graph.adj[label])
 751                    for ind in rlabel:
 752                        if do_neighbor:
 753                            self.table["NbNeighbors"][ind+nrows] = nneighbor
 754                        if get_neighbor:
 755                            self.table["Neighbors"][ind+nrows] = ""
 756                            sep = ""
 757                            for key in graph.adj[label].keys():
 758                                self.table["Neighbors"][ind+nrows] += sep + str(key)
 759                                sep = "&"
 760            #ut.show_duration( start_time, "Neighborhoods measured" )
 761
 762        ## measure cells on boundary    
 763        if "Boundary" in other_features:
 764            if frame is not None:
 765                boundimg = self.epicure.seg[frame]
 766            else:
 767                boundimg = self.epicure.seg
 768            bounds = ut.get_boundary_cells( boundimg )
 769            if first:
 770                self.table["Boundary"] = []
 771            self.table["Boundary"].extend( [0]*ndata )
 772            for label in np.unique(frame_table["label"]):
 773                if label in bounds:
 774                    rlabel = np.where( (frame_table["label"] == label) )[0]
 775                    for ind in rlabel:
 776                        self.table["Boundary"][ind+nrows] = 1
 777        
 778        ## measure cells on border  
 779        if "Border" in other_features:
 780            bounds = ut.get_border_cells( img )
 781            if first:
 782                self.table["Border"] = []
 783            self.table["Border"].extend( [0]*ndata )
 784            for label in bounds:
 785                rlabel = np.where( (frame_table["label"] == label) )[0]
 786                for ind in rlabel:
 787                    self.table["Border"][ind+nrows] = 1
 788
 789        
 790    def selection_changed(self):
 791        if self.table_selection is None:
 792            return True
 793        return self.output_mode.currentText() != self.selection_choices[self.table_selection]
 794
 795    def update_selection_list(self):
 796        """ Update the possible selection from group cell list """
 797        self.selection_choices = ["Only selected cell", "All cells"]
 798        for group in self.epicure.groups.keys():
 799            self.selection_choices.append(group)
 800        self.output_mode.clear()
 801        for sel in self.selection_choices:
 802            self.output_mode.addItem(sel)
 803
 804    def show_table(self):
 805        """ Show the measurement table """
 806        #disable automatic update (slow)
 807        #if self.table is None:
 808            ## create the table and connect action to update it automatically
 809            #self.output_mode.currentIndexChanged.connect(self.show_table)
 810            #self.measure_other_chanels_cbox.stateChanged.connect(self.show_table)
 811            #self.feature_graph_cbox.stateChanged.connect(self.show_table)
 812            #self.feature_intensity_cbox.stateChanged.connect(self.show_table)
 813            #self.feature_shape_cbox.stateChanged.connect(self.show_table)
 814        
 815        ut.set_active_layer( self.viewer, "Segmentation" )
 816        self.show_feature_map.clear()
 817        self.show_feature_map.addItem("")
 818        laynames = [lay.name for lay in self.viewer.layers]
 819        for lay in laynames:
 820            if lay.startswith("Map_"):
 821                ut.remove_layer(self.viewer, lay)
 822        self.measure_features()
 823        featlist = self.table.keys()
 824        ## Scaling the features
 825        if self.scaled_unit.isChecked():
 826            for feat in featlist:
 827                feat_scale, scaled = self.scale_feature( feat, self.table[feat] )
 828                if feat_scale is not None:
 829                    if (feat_scale[0:4] != "Time") and (feat_scale[0:9] != "centroid-"):
 830                        del self.table[feat]
 831                    self.table[feat_scale] = scaled
 832        featlist = self.table.keys()
 833        ## Adding the list to the feature maps
 834        for feat in featlist:
 835            self.show_feature_map.addItem(feat)
 836        self.featTable.set_table(self.table)
 837        self.temp_graph.setEnabled(True)
 838        if self.tplots is not None:
 839            self.tplots.update_table(self.table)
 840
 841    def scale_feature( self, feat, featVals ):
 842        """ Scale if necessary the feature values """
 843        dist_feats = ["centroid-0", "centroid-1", "perimeter", "axis_major_length", "axis_minor_length", "feret_diameter_max", "equivalent_diameter_area" ]
 844        if feat in dist_feats:
 845            return feat+"_"+self.epicure.epi_metadata["UnitXY"], np.array(featVals)*self.epicure.epi_metadata["ScaleXY"]
 846        area_feats = ["area", "area_convex"]
 847        if feat in area_feats:
 848            return feat+"_"+self.epicure.epi_metadata["UnitXY"]+"²", np.array(featVals)*self.epicure.epi_metadata["ScaleXY"] * self.epicure.epi_metadata["ScaleXY"]
 849        if feat == "frame":
 850            return "Time_"+self.epicure.epi_metadata["UnitT"], np.array(featVals)*self.epicure.epi_metadata["ScaleT"]
 851        return None, None
 852
 853
 854    def show_feature(self):
 855        """ Add the image map of the selected feature """
 856        feat = self.show_feature_map.currentText()
 857        if (feat is not None) and (feat != ""):
 858            if feat in self.table.keys():
 859                values = list(self.table[feat])
 860                if feat == "group":
 861                    for i, val in enumerate(values):
 862                        if (val is None) or (val == 'None'):
 863                            values[i] = 0
 864                        else:
 865                            values[i] = list(self.epicure.groups.keys()).index(val) + 1
 866                labels = list(self.table["label"])
 867                frames = None
 868                if "frame" in self.table:
 869                    frames = list(self.table["frame"])
 870                self.draw_map(labels, values, frames, feat)
 871
 872    def draw_map(self, labels, values, frames, featname):
 873        """ Add image layer of values by label """
 874        ## special feature: orientation, draw the axis instead
 875        self.viewer.window._status_bar._toggle_activity_dock(True)
 876        labels = np.array(labels)
 877        values = np.array(values)
 878        frames = np.array(frames)
 879        def map_frame( iframe, segframe ):
 880            """ Draw one frame of the map """
 881            mask = np.where(frames==iframe)[0]
 882            labs = labels[mask]
 883            vals = values[mask]
 884            mapping = np.zeros(segframe.max()+1)
 885            mapping[:] = np.nan
 886            mapping[labs] = vals 
 887            return mapping[segframe] 
 888
 889        if frames is not None:
 890            ## Plotting a movie
 891            if self.epicure.process_parallel:
 892                mapfeat = Parallel( n_jobs=self.epicure.nparallel) (
 893                    delayed ( map_frame )(iframe, frame ) for iframe, frame in enumerate(self.seglayer.data)
 894                )
 895                mapfeat = np.array(mapfeat)
 896            else:
 897                mapfeat = np.empty(self.epicure.seg.shape, dtype="float16")
 898                mapfeat[:] = np.nan
 899                for iframe in np.unique(frames):
 900                    segdata = self.seglayer.data[iframe]
 901                    mapfeat[iframe] = map_frame( iframe, segdata )
 902        else:
 903            mapfeat = np.empty(self.epicure.seg.shape, dtype="float16")
 904            mapfeat[:] = np.nan
 905            for lab, val in progress(zip(labels, values)):
 906                cell = self.seglayer.data==lab
 907                mapfeat[cell] = val
 908        ut.remove_layer(self.viewer, "Map_"+featname)
 909        self.viewer.add_image(mapfeat, name="Map_"+featname, scale=self.viewer.layers["Segmentation"].scale )
 910        self.viewer.window._status_bar._toggle_activity_dock(False)
 911
 912    def draw_orientation( self ):
 913        """ Display the cells orientation axis in a new layer """
 914        ## check that necessary features are measured
 915        ut.remove_layer( self.viewer, "CellOrientation" )
 916        feats = ["centroid-0", "centroid-1", "orientation"]
 917        if self.table is None:
 918            print("Features centroid and orientation necessary to draw orientation, but are not measured yet")
 919            return
 920        for feat in feats:
 921            if feat not in self.table.keys():
 922                print("Feature "+feat+" necessary to draw orientation, but was not measured")
 923                return
 924        ## ok, can work now
 925        self.viewer.window._status_bar._toggle_activity_dock(True)
 926
 927        ## get the coordinates of the axis lines by getting the cell centroid, main orientation
 928        xs = np.array( self.table["centroid-0"] )
 929        ys = np.array( self.table["centroid-1"] )
 930        angles = np.array( self.table["orientation"] )
 931        lens = np.array( [10]*len(angles) )
 932        oriens = np.zeros( (self.epicure.seg.shape), dtype="uint8" )
 933
 934        ## draw axis length depending on the eccentricity
 935        if "eccentricity" in self.table.keys():
 936            lens = np.array(self.table["eccentricity"]*16)             
 937        
 938        if "frame" in self.table:
 939            frames = np.array( self.table["frame"] ).astype(int)
 940        else:
 941            frames = np.array( [0]*len(angles) )
 942
 943        ## draw the lines in between the two extreme points (using Shape layer is too slow on display for big movies)
 944        npts = 30
 945        xmax = oriens.shape[1]-1
 946        ymax = oriens.shape[2]-1
 947        for i in range(npts):
 948            xas = np.clip(xs - lens/2 * np.cos( angles ) * i/float(npts), 0, xmax).astype(int)
 949            xbs = np.clip(xs + lens/2 * np.cos( angles ) * i/float(npts), 0, xmax).astype(int)
 950            yas = np.clip(ys - lens/2 * np.sin( angles ) * i/float(npts), 0, ymax).astype(int)
 951            ybs = np.clip(ys + lens/2 * np.sin( angles ) * i/float(npts), 0, ymax).astype(int)
 952            oriens[ (frames, xas, yas) ] = 255
 953            oriens[ (frames, xbs, ybs) ] = 255
 954        
 955        self.viewer.add_image( oriens, name="CellOrientation", blending="additive", opacity=1, scale=self.viewer.layers["Segmentation"].scale )
 956        self.viewer.window._status_bar._toggle_activity_dock(False)
 957
 958    ################### Export to other plugins
 959
 960    def to_griot(self):
 961        """ Export current frame to new viewer and makes it ready for Griotte plugin """
 962        try:
 963            from napari_griottes import make_graph
 964        except:
 965            ut.show_error("Plugin napari-griottes is not installed")
 966            return
 967        gview = napari.Viewer()
 968        tframe = ut.current_frame(self.viewer)
 969        segt = self.epicure.seglayer.data[tframe]
 970        touching_frame = self.touching_labels(segt)
 971        gview.add_labels(touching_frame, name="TouchingCells", opacity=1)
 972        gview.window.add_dock_widget(make_graph(), name="Griottes")
 973
 974    def touching_labels(self, labs):
 975        """ Dilate labels so that they all touch """
 976        from skimage.segmentation import find_boundaries
 977        from skimage.morphology import skeletonize
 978        from skimage.morphology import binary_closing, binary_opening
 979        if self.epicure.verbose > 0:
 980            print("********** Generate touching labels image ***********")
 981
 982        ## skeletonize it
 983        skel = skeletonize( binary_closing( find_boundaries(labs), footprint=np.ones((10,10)) ) )
 984        ext = np.zeros(labs.shape, dtype="uint8")
 985        ext[labs==0] = 1
 986        ext = binary_opening(ext, footprint=np.ones((2,2)))
 987        newimg = ut.touching_labels(labs, expand=4)
 988        newimg[ext>0] = 0
 989        return newimg
 990    
 991    def to_ncp(self):
 992        """ Export current frame to new viewer and makes it ready for napari-cluster-plots plugin """
 993        try:
 994            import napari_skimage_regionprops as nsr
 995        except:
 996            ut.show_error("Plugin napari-skimage-regionprops is not installed")
 997            return
 998        gview = napari.Viewer()
 999        tframe = ut.current_frame(self.viewer)
1000        segt = self.epicure.seglayer.data[tframe]
1001        moviet = self.epicure.viewer.layers["Movie"].data[tframe]
1002        lab = gview.add_labels(segt, name="Segmentation[t="+str(tframe)+"]", blending="additive")
1003        im = gview.add_image(moviet, name="Movie[t="+str(tframe)+"]", blending="additive")
1004        if self.epicure.verbose > 0:
1005            print("Measure features with napari-skimage-regionprops plugin...")
1006        nsr.regionprops_table(im.data, lab.data, size=True, intensity=True, perimeter=True, shape=True, position=True, moments=True, napari_viewer=gview)
1007        try:
1008            import napari_clusters_plotter as ncp
1009        except:
1010            ut.show_error("Plugin napari-clusters-plotter is not installed")
1011            return
1012        gview.window.add_dock_widget( ncp.ClusteringWidget(gview) )
1013        gview.window.add_dock_widget( ncp.PlotterWidget(gview) )
1014
1015    ################### Temporal graphs
1016    def temporal_graphs_events( self ):
1017        """ New window with temporal graph of event counts """
1018        if self.tplots is not None:
1019            self.tplots.close()
1020        self.tplots = TemporalPlots( self.viewer, self.epicure )
1021        evt_table = self.count_events()
1022        self.tplots.setTable( evt_table )
1023        self.tplots.show()
1024        self.viewer.dims.events.current_step.connect(self.position_verticalline)
1025
1026
1027    def temporal_graphs(self):
1028        """ New window with temporal graph of the current table selection """
1029        #self.temporal_viewer = napari.Viewer()
1030        self.tplots = TemporalPlots( self.viewer, self.epicure )
1031        self.tplots.setTable(self.table)
1032        self.tplots.show()
1033        #self.plot_wid = self.viewer.window.add_dock_widget( self.tplots, name="Plots" )
1034        self.viewer.dims.events.current_step.connect(self.position_verticalline)
1035    
1036    def on_close_viewer(self):
1037        """ Temporal plots window is closed """
1038        if self.epicure.verbose > 1:
1039            print("Closed viewer")
1040        self.viewer.dims.events.current_step.disconnect(self.position_verticalline)
1041        self.temporal_viewer = None
1042        self.tplots = None
1043
1044    def position_verticalline(self):
1045        """ Place the vertical line in the temporal graph to the current frame """
1046        #try:
1047        #    wid = self.tplots
1048        #except:
1049        #    self.on_close_viewer()
1050        if self.tplots is not None:
1051            self.tplots.move_framepos(self.viewer.dims.current_step[0])
1052
1053    ############### track features 
1054
1055    def show_trackfeature_table(self):
1056        """ Show the measurement of tracks table """
1057        self.measure_track_features()
1058        self.trackTable.set_table( self.table )
1059    
1060    def measure_track_features(self):
1061        """ Measure track features and put them to table """
1062        if self.epicure.verbose > 0:
1063            print("Measuring track features")
1064        self.viewer.window._status_bar._toggle_activity_dock(True)
1065        start_time = time.time()
1066
1067        if self.output_mode.currentText() == "Only selected cell": 
1068            track_ids = self.epicure.seglayer.selected_label
1069        else:
1070            if self.output_mode.currentText() == "All cells": 
1071                track_ids = self.epicure.tracking.get_track_list()
1072            else:
1073                group = self.output_mode.currentText()
1074                track_ids = []
1075                label_group = self.epicure.groups[group]
1076                for lab in label_group:
1077                    track_ids.append(lab)
1078            
1079        properties = ["label", "area", "centroid"]
1080        self.table = None
1081
1082        if type(track_ids) == np.ndarray or type(track_ids)==np.array:
1083            track_ids = track_ids.tolist()
1084        if not type(track_ids) == list:
1085            track_ids = [track_ids]
1086
1087        labgroups = self.epicure.group_of_labels()
1088        frame_group = [ labgroups[label] if label in labgroups.keys() else "Ungrouped" for label in track_ids ]
1089        for itrack, track_id in progress(enumerate(track_ids)):
1090            track_frame = self.measure_one_track( track_id )
1091            track_frame["Group"] = frame_group[itrack]
1092            if self.table is None:
1093                self.table = pand.DataFrame([track_frame])
1094            else:
1095                self.table = pand.concat([self.table, pand.DataFrame([track_frame])])
1096
1097        self.table_selection = self.selection_choices.index(self.output_mode.currentText())
1098        self.viewer.window._status_bar._toggle_activity_dock(False)
1099        if self.epicure.verbose > 0:
1100            ut.show_info("Features measured in "+"{:.3f}".format((time.time()-start_time)/60)+" min")
1101
1102    def measure_one_track( self, track_id ):
1103        """ Measure features of one track """
1104        track_features = self.epicure.tracking.measure_track_features( track_id, self.scaled_unit.isChecked() )
1105        return track_features
1106
1107    ############## Events functions
1108
1109    def choose_events( self ):
1110        """ Pop-up widget to choose the event types to measure/export """
1111        self.event_classes.choose()
1112
1113    def count_events( self ):
1114        """ Count events of selected types """
1115        evt_types = self.event_classes.get_evt_classes()
1116        if self.epicure.verbose > 2:
1117            print("Counting events of type "+str(evt_types)+" " )
1118        
1119        ## keep only events related to selected cells
1120        labels = self.get_current_labels()
1121        ## count each type of event
1122        table = np.zeros(  (self.epicure.nframes,len(evt_types)), dtype="uint8" )        
1123        for itype, evt_type in enumerate( evt_types ):
1124            evts = self.epicure.inspecting.get_events_from_type( evt_type )
1125            if len( evts ) > 0:
1126                for evt_sid in evts:
1127                        pos, label = self.epicure.inspecting.get_event_infos( evt_sid )
1128                        if label in labels:
1129                            table[ pos[0], itype ] += 1
1130        df = pand.DataFrame( data=table, columns=evt_types )
1131        df["frame"] = range(len(df))
1132        df["label"] = [0]*len(df)
1133        return df          
1134
1135    def export_events( self ):
1136        """ Export events of selected types """
1137        evt_types = self.event_classes.get_evt_classes()
1138        export_type = self.save_evt_choice.currentText()
1139        if self.epicure.verbose > 2:
1140            print("Exporting events of type "+str(evt_types)+" to "+export_type )
1141        self.export_events_type_format( evt_types, export_type )
1142        
1143    def export_events_type_format( self, evt_types, export_type ):
1144        """ Export events of selected types in selected format """
1145        ## keep only events related to selected cells
1146        labels = self.get_current_labels()
1147        groups = self.epicure.get_groups( labels )
1148        if export_type == "CSV File":
1149            res = pand.DataFrame( columns=["label", "frame", "posY", "posX", "EventClass", "Group"] )  
1150        ## export each type of event in separate files
1151        for itype, evt_type in enumerate( evt_types ):
1152            evts = self.epicure.inspecting.get_events_from_type( evt_type )
1153            if len( evts ) > 0:
1154                rois = [] 
1155                for evt_sid in evts:
1156                    pos, label = self.epicure.inspecting.get_event_infos( evt_sid )
1157                    ind_lab = np.where( labels==label )
1158                    if len( ind_lab[0] ) > 0:
1159                        grp = groups[ int(ind_lab[0][0]) ]
1160                        if export_type == "Fiji ROI":
1161                            roi = self.create_point_roi( pos, itype )
1162                            rois.append( roi )
1163                        if export_type == "CSV File":
1164                            new_event = pand.DataFrame( [[label, pos[0], pos[1], pos[2], evt_type, grp ]], columns=res.columns )
1165                            res = pand.concat( [res, new_event], ignore_index=True )
1166                if export_type == "Fiji ROI":            
1167                    outfile = self.epicure.outname()+"_rois_"+evt_type +""+self.get_selection_name()+".zip" 
1168                    roifile.roiwrite(outfile, rois, mode='w')
1169                    if self.epicure.verbose > 0:
1170                        print( "Events "+str( evt_type )+" saved in ROI file: "+outfile )
1171            ## dont save anything if empty, just print info to user
1172            else:
1173                if self.epicure.verbose > 0:
1174                    print( "No events of type "+str(evt_type)+"" )
1175        
1176        if export_type == "CSV File":            
1177            outfile = self.epicure.outname()+"_events"+self.get_selection_name()+".csv" 
1178            res.to_csv( outfile,  sep='\t', header=True, index=False )
1179            if self.epicure.verbose > 0:
1180                print( "Events data "+" saved in CSV file: "+outfile )
1181
1182
1183    def create_point_roi( self, pos, cat=0 ):
1184        """ Create a point Fiji ROI """
1185        croi = roifile.ImagejRoi()
1186        croi.version = 227
1187        croi.roitype = roifile.ROI_TYPE(10)
1188        croi.name = str(pos[0]+1).zfill(4)+'-'+str(pos[1]).zfill(4)+"-"+str(pos[2]).zfill(4)
1189        croi.n_coordinates = 1
1190        croi.left = int(pos[2])
1191        croi.top = int(pos[1])
1192        croi.z_position = 1
1193        croi.t_position = pos[0]+1
1194        croi.c_position = 1
1195        croi.integer_coordinates = np.array( [[0,0]] )
1196        croi.stroke_width=3
1197        ncolors = 3
1198        if cat%ncolors == 0:  ## color type 0
1199            croi.stroke_color = b'\xff\x00\x00\xff'
1200        if cat%ncolors == 1:  ## color type 1
1201            croi.stroke_color = b'\xff\x00\xff\x00'
1202        if cat%ncolors == 2:  ## color type 2
1203            croi.stroke_color = b'\xff\xff\x00\x00'
1204        return croi
1205
1206    def save_tm_xml( self ):
1207        """ Save current segmentation and tracking in TrackMate XML format """
1208        outname = os.path.join( self.epicure.outdir, self.epicure.imgname+".xml" )
1209        save_trackmate_xml( self.epicure, outname )
1210        if self.epicure.verbose > 0:
1211            ut.show_info("TrackMate XML saved in "+outname)
1212    
1213    def save_geff( self ):
1214        """ Save current segmentation and tracking in GEFF format """
1215        ## save the label segmentation if it's not saved
1216        labelname = os.path.join( self.epicure.outdir, self.epicure.imgname + "_labels.tif" )
1217        ut.writeTif( self.epicure.seg, labelname, self.epicure.epi_metadata["ScaleXY"], "float32", what="Segmentation" )
1218        ## then export the GEFF file
1219        if self.epicure.tracking.graph is None:
1220            self.epicure.tracking.graph = {}
1221        outname = os.path.join( self.epicure.outdir, self.epicure.imgname+".geff" )
1222        save_geff( self.epicure, outname )
1223        if self.epicure.verbose > 0:
1224            ut.show_info("GEFF file saved in "+outname)
1225
1226
1227class CellFeatures(QWidget):
1228    """ Choice of features to measure """
1229    def __init__(self, chanlist):
1230        super().__init__()
1231        layout = QVBoxLayout()
1232        
1233        self.required = ["label"]
1234        self.features = {}
1235        self.chan_list = None
1236        
1237        other_list = ["group", "NbNeighbors", "Neighbors", "Boundary", "Border"]
1238        feat_layout = self.add_feature_group( other_list, "other" )
1239        layout.addLayout( feat_layout )
1240        sel_all_b = wid.add_button( "Select spatial features", lambda: self.select_all("other"), "Select all spatial features" )
1241        desel_all_b = wid.add_button( "Deselect spatial features", lambda: self.deselect_all("other"), "Deselect all spatial features" )
1242        sel_line_b = wid.hlayout()
1243        sel_line_b.addWidget( sel_all_b )
1244        sel_line_b.addWidget( desel_all_b )
1245        layout.addLayout( sel_line_b )
1246
1247
1248        ## Add shape features
1249        shape_list = ["centroid", "area", "area_convex", "axis_major_length", "axis_minor_length", "feret_diameter_max", "equivalent_diameter_area", "eccentricity", "orientation", "perimeter", "solidity"]
1250        other_shape_list = ["shape_index", "roundness", "aspect_ratio"]
1251        feat_layout = self.add_feature_group( shape_list, "prop" )
1252        feat_extra_layout = self.add_feature_group( other_shape_list, "prop_extra" )
1253        layout.addLayout( feat_layout )
1254        layout.addLayout( feat_extra_layout )
1255        sel_all = wid.add_button( "Select morphology features", lambda: self.select_all("props"), "Select all morphology features" )
1256        desel_all = wid.add_button( "Deselect morphology features", lambda: self.deselect_all("props"), "Deselect all morphology features" )
1257        sel_line = wid.hlayout()
1258        sel_line.addWidget( sel_all )
1259        sel_line.addWidget( desel_all )
1260        layout.addLayout( sel_line )
1261
1262        int_lab = wid.label_line( "Intensity features:")
1263        layout.addWidget( int_lab )
1264        intensity_list = ["intensity_mean", "intensity_min", "intensity_max"]
1265        extra_list = ["intensity_junction_cytoplasm"]
1266        feat_layout = self.add_feature_group( intensity_list, "intensity_prop" )
1267        layout.addLayout( feat_layout )
1268        feat_layout = self.add_feature_group( extra_list, "intensity_extra" )
1269        layout.addLayout( feat_layout )
1270        if len(chanlist) > 1:
1271            chan_lab = wid.label_line( "Measure intensity in channels:" )
1272            layout.addWidget( chan_lab )
1273            self.chan_list = QListWidget()
1274            self.chan_list.addItems( chanlist )
1275            self.chan_list.setSelectionMode(aiv.MultiSelection)
1276            self.chan_list.item(0).setSelected(True)
1277            layout.addWidget( self.chan_list )
1278        
1279        sel_all_int = wid.add_button( "Select intensity features", lambda: self.select_all("intensity"), "Select all spatial features" )
1280        desel_all_int = wid.add_button( "Deselect intensity features", lambda: self.deselect_all("intensity"), "Deselect all spatial features" )
1281        sel_line_int = wid.hlayout()
1282        sel_line_int.addWidget( sel_all_int )
1283        sel_line_int.addWidget( desel_all_int )
1284        layout.addLayout( sel_line_int )
1285
1286        bye = wid.add_button( "Ok", self.close, "Close the window" )
1287        layout.addWidget( bye )
1288        self.setLayout( layout )
1289
1290    def select_all( self, feat ):
1291        """ Select all features of type feat """
1292        if feat == "intensity":
1293            self.select_all( "intensity_prop" )
1294            self.select_all( "intensity_extra" )
1295            return
1296        if feat == "props":
1297            self.select_all( "prop" )
1298            self.select_all( "prop_extra" )
1299            return
1300        for featy, feat_val in self.features.items():
1301            if feat_val[1] == feat:
1302                feat_val[0].setChecked( True )
1303    
1304    def deselect_all( self, feat ):
1305        """ Deselect all features of type feat """
1306        if feat == "intensity":
1307            self.deselect_all( "intensity_prop" )
1308            self.deselect_all( "intensity_extra" )
1309            return
1310        if feat == "props":
1311            self.deselect_all( "prop" )
1312            self.deselect_all( "prop_extra" )
1313            return
1314        for featy, feat_val in self.features.items():
1315            if feat_val[1] == feat:
1316                feat_val[0].setChecked( False )
1317
1318
1319    def add_feature_group( self, feat_list, feat_type ):
1320        """ Add features to the GUI """
1321        layout = QVBoxLayout()
1322        ncols = 3
1323        for i, feat in enumerate(feat_list):
1324            if i%ncols == 0:
1325                line = QHBoxLayout()
1326            feature_check = wid.add_check( ""+feat, True, None, descr="" )
1327            line.addWidget(feature_check)
1328            self.features[ feat ] = [feature_check, feat_type]
1329            if i%ncols == (ncols-1):
1330                layout.addLayout( line )
1331                line = None
1332        if line is not None:
1333            layout.addLayout( line )
1334        return layout
1335
1336
1337    def close( self ):
1338        """ Close the pop-up window """
1339        self.hide()
1340
1341    def choose( self ):
1342        """ Show the interface to select the choices """
1343        self.show()
1344
1345    def get_current_settings( self, setting ):
1346        """ Get current settings of check or not of features """
1347        for feat, feat_cbox in self.features.items():
1348            setting[feat] = feat_cbox[0].isChecked()
1349        return setting
1350
1351    def apply_settings( self, settings ):
1352        """ Set the checkboxes from preferenced settings """
1353        for feat, checked in settings.items():
1354            if feat in self.features.keys():
1355                self.features[feat][0].setChecked( checked )
1356        
1357    def get_features( self ):
1358        """ Returns the list of features to measure """
1359        feats = self.required
1360        feats_extra = []
1361        int_extra_feats = []
1362        int_feats = []
1363        other_feats = []
1364        self.do_intensity = False
1365        for feat, feat_cbox in self.features.items():
1366            if feat_cbox[0].isChecked():
1367                if feat_cbox[1] == "prop":
1368                    feats.append( feat )
1369                if feat_cbox[1] == "prop_extra":
1370                    feats_extra.append( feat )
1371                    if feat == "shape_index":
1372                        if "perimeter" not in feats:
1373                            feats.append("perimeter")
1374                        if "area" not in feats:
1375                            feats.append("area")
1376                    if feat == "roundness":
1377                        if "area" not in feats:
1378                            feats.append("area")
1379                        if "axis_major_length" not in feats:
1380                            feats.append("axis_major_length")
1381                    if feat == "aspect_ratio":
1382                        if "axis_major_length" not in feats:
1383                            feats.append("axis_major_length")
1384                        if "axis_minor_length" not in feats:
1385                            feats.append("axis_minor_length")
1386                if feat_cbox[1] == "other":
1387                    other_feats.append( feat )
1388                if feat_cbox[1] == "intensity_prop":
1389                    int_feats.append( feat )
1390                    self.do_intensity = True
1391                if feat_cbox[1] == "intensity_extra":
1392                    int_extra_feats.append( feat )
1393                    self.do_intensity = True
1394        return feats, feats_extra, other_feats, int_feats, int_extra_feats
1395
1396    def get_channels( self ):
1397        """ Returns the list of channels to measure """
1398        if self.do_intensity:
1399            if self.chan_list is not None:
1400                wid_channels = self.chan_list.selectedItems()
1401                channels = []
1402                for chan in wid_channels:
1403                    channels.append( chan.text() )
1404            else:
1405                channels = ["Movie"]
1406            return channels
1407        return None
1408
1409class EventClass( QWidget ):
1410    """ Choice of event types to export/measure """
1411    def __init__( self, epicure ):
1412        super().__init__()
1413        layout = QVBoxLayout()
1414        
1415        self.evt_classes = {}
1416        possible_classes = epicure.event_class
1417        event_layout = self.add_events( possible_classes )
1418        layout.addLayout( event_layout )
1419
1420        bye = wid.add_button( "Ok", self.close, "Close the window" )
1421        layout.addWidget( bye )
1422        self.setLayout( layout )
1423
1424    def add_events( self, event_list ):
1425        """ Add events to the GUI """
1426        layout = QVBoxLayout()
1427        ncols = 3
1428        for i, event in enumerate( event_list ):
1429            if i%ncols == 0:
1430                line = QHBoxLayout()
1431            event_check = wid.add_check_tolayout( line, ""+event, checked=True, descr="")
1432            self.evt_classes[ event ] = [ event_check ]
1433            if i%ncols == (ncols-1):
1434                layout.addLayout( line )
1435                line = None
1436        if line is not None:
1437            layout.addLayout( line )
1438        return layout
1439
1440
1441    def close( self ):
1442        """ Close the pop-up window """
1443        self.hide()
1444
1445    def choose( self ):
1446        """ Show the interface to select the choices """
1447        self.show()
1448
1449    def get_current_settings( self, setting ):
1450        """ Get current settings of check or not of features """
1451        for event, event_cbox in self.evt_classes.items():
1452            setting[event] = event_cbox[0].isChecked()
1453        return setting
1454
1455    def apply_settings( self, settings ):
1456        """ Set the checkboxes from preferenced settings """
1457        for evt, checked in settings.items():
1458            if evt in self.evt_classes.keys():
1459                self.evt_classes[evt][0].setChecked( checked )
1460        
1461    def get_evt_classes( self ):
1462        """ Returns the list of events to measure """
1463        events = []
1464        for evt, evt_cbox in self.evt_classes.items():
1465            if evt_cbox[0].isChecked():
1466                events.append( evt )
1467        return events
1468
1469class FeaturesTable(QWidget):
1470    """ Widget to visualize and interact with the measurement table """
1471
1472    def __init__(self, napari_viewer, epicure):
1473        super().__init__()
1474        self.viewer = napari_viewer
1475        self.epicure = epicure
1476        self.wid_table = QTableWidget()
1477        self.wid_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
1478        self.setLayout(QGridLayout())
1479        self.layout().addWidget(self.wid_table)
1480        self.wid_table.clicked.connect(self.show_label)
1481        self.wid_table.setSortingEnabled(True)
1482
1483    def show_label(self):
1484        """ When click on the table, show selected cell """
1485        if self.wid_table is not None:
1486            row = self.wid_table.currentRow()
1487            self.epicure.seglayer.show_selected_label = False
1488            headers = [self.wid_table.horizontalHeaderItem(ind).text() for ind in range(self.wid_table.columnCount()) ]
1489            labelind = None
1490            if "label" in headers:
1491                labelind = headers.index("label") 
1492            if "Label" in headers:
1493                labelind = headers.index("Label") 
1494            frameind = None
1495            if "frame" in headers:
1496                frameind = headers.index("frame") 
1497            if labelind is not None and labelind >= 0:
1498                lab = int(self.wid_table.item(row, labelind).text())
1499                if frameind is not None:
1500                    ## set current frame to the selected row
1501                    frame = int(self.wid_table.item(row, frameind).text())
1502                    ut.set_frame(self.viewer, frame)
1503                else:
1504                    ## set current frame to the first frame where label or track is present
1505                    frame = self.epicure.tracking.get_first_frame( lab )
1506                    if frame is not None:
1507                        ut.set_frame(self.viewer, frame)
1508                self.epicure.seglayer.selected_label = lab
1509                self.epicure.seglayer.show_selected_label = True
1510
1511
1512    def get_features_list(self):
1513        """ Return list of measured features """
1514        return [ self.wid_table.horizontalHeaderItem(ind).text() for ind in range(self.wid_table.columnCount()) ]
1515
1516    def set_table(self, table):
1517        self.wid_table.clear()
1518        self.wid_table.setRowCount(table.shape[0])
1519        self.wid_table.setColumnCount(table.shape[1])
1520
1521        for c, column in enumerate(table.keys()):
1522            column_name = column
1523            self.wid_table.setHorizontalHeaderItem(c, QTableWidgetItem(column_name))
1524            for r, value in enumerate(table.get(column)):
1525                item = QTableWidgetItem()
1526                item.setData( Qt.EditRole, value)
1527                self.wid_table.setItem(r, c, item)
1528
1529class TemporalPlots(QWidget):
1530    """ Widget to visualize and interact with temporal plots """
1531
1532    def __init__(self, napari_viewer, epicure):
1533        super().__init__()
1534        self.viewer = napari_viewer
1535        self.epicure = epicure
1536        self.features_list = ["frame"]
1537        self.parameter_gui()
1538        self.vline = None
1539        self.ymin = None
1540        #self.viewer.window.add_dock_widget( self.plot_wid, name="Temporal plot" )
1541   
1542    def parameter_gui(self):
1543        """ add widget to choose plotting parameters """
1544        
1545        layout = QVBoxLayout()
1546
1547        ## choice of feature to plot
1548        feat_choice, self.feature_choice = wid.list_line( label="Plot feature", descr="Choose the feature to plot", func=self.plot_feature )
1549        layout.addLayout(feat_choice)
1550        ## option to average by group
1551        ck_line, self.avg_group, self.smooth = wid.double_check( "Average by groups", False, self.plot_feature, "Show a line by cell or a line by group", "Smooth lines", False, self.plot_feature, "Smooth temporally (moving average) the plotted lines" )
1552        layout.addLayout(ck_line)
1553        ## show the plot
1554        self.plot_wid = self.create_plotwidget()
1555        layout.addWidget(self.plot_wid)
1556        ## save plot or save data of the plot
1557        line = wid.double_button( "Save plot image", self.save_plot_image, "Save the grapic in a PNG file", "Save plot data", self.save_plot_data, "Save the value used for the plot in .csv file" )
1558        self.by_label = wid.add_check( "Arranged data by label", False, None, "Save the data with one column by label" )
1559        line.addWidget( self.by_label )
1560        layout.addLayout( line )
1561        self.setLayout(layout)
1562        self.resize(1000,800)
1563
1564    def setTable(self, table):
1565        """ Data table to plot """
1566        self.table = table
1567        self.features_list = self.table.keys()
1568        self.update_feature_list()
1569
1570    def update_table(self, table):
1571        """ Update the current plot with the updated table """
1572        self.table = table
1573        curchoice = self.feature_choice.currentText()
1574        self.features_list = self.table.keys()
1575        self.update_feature_list()
1576        if curchoice in self.features_list:
1577            ind = list(self.features_list).index(curchoice)
1578            self.feature_choice.setCurrentIndex(ind)
1579        self.plot_feature()
1580
1581    def update_feature_list(self):
1582        """ Update the list of feature in the GUI """
1583        self.feature_choice.clear()
1584        for feat in self.features_list:
1585            self.feature_choice.addItem(feat)
1586        if "division" in self.features_list and "extrusion" in self.features_list:
1587            self.feature_choice.addItem( "division&extrusion" )
1588    
1589    def plot_feature(self):
1590        """ Plot the selected feature in the temporal graph """
1591        feat = self.feature_choice.currentText()
1592        if feat == "label":
1593            return
1594        if feat == "":
1595            return
1596        if feat == "division&extrusion":
1597            feat = ["division", "extrusion"]
1598        else:
1599            feat = [feat]
1600        
1601        tab = list( zip(self.table["frame"]) )
1602        labname = []
1603        for ft in feat:
1604            tab = [ (*t, v) for t, v in zip( tab, self.table[ft]) ]
1605        tab = [ (*t, v) for t, v in zip( tab, self.table["label"]) ]
1606        labname.append("label")
1607        if "group" in self.table:
1608            tab = [ (*t, v) for t, v in zip( tab, self.table["group"]) ]
1609            labname.append("group")
1610
1611        self.df = pand.DataFrame( tab, columns=["frame"] + feat + labname )
1612        shape = "linear"
1613        if self.smooth.isChecked():
1614            shape = "spline"
1615        if "group" in self.table and self.avg_group.isChecked():
1616            self.dfmean = self.df.groupby(['group', 'frame'])[feat].mean().reset_index()
1617            self.df.columns.name = 'group'
1618            self.fig = px.line( self.dfmean, x='frame', y=feat, color='group', labels={'frame': 'Time (frame)'}, line_shape=shape, render_mode="svg" )
1619        else:
1620            if len( np.unique(self.df["label"]) ) > 1000:
1621                ut.show_warning( "Too many lines to plot; Using a random subset instead" )
1622                subset = sample( np.unique(self.df["label"]).tolist(), 1000)
1623                subdf = self.df[self.df["label"].isin(subset)]
1624                self.fig = px.line( subdf, x="frame", y=feat[0], color="label", labels={'frame': 'Time (frame)'}, line_shape = shape, render_mode="svg")
1625                if len(feat) > 1:
1626                    addfig = px.line(subdf, x="frame", y=feat[1], color="label", line_shape = shape )
1627                    addfig.update_traces( patch={"line": {"dash":"dot"}} )
1628                    self.fig.add_trace( addfig.data[0] )
1629            else:
1630                self.fig = px.line( self.df, x="frame", y=feat[0], color="label", labels={'frame': 'Time (frame)'}, line_shape = shape, render_mode="svg")
1631                if len(feat) > 1:
1632                    addfig = px.line(self.df, x="frame", y=feat[1], color="label", line_shape = shape )
1633                    addfig.update_traces( patch={"line": {"dash":"dot"}} )
1634                    self.fig.add_trace( addfig.data[0] )
1635    
1636        if self.webengine:
1637            self.browser.setHtml( self.fig.to_html(include_plotlyjs='cdn'))
1638        else:
1639            self.show_plot_in_browser( self.fig.to_html(include_plotlyjs='cdn'))
1640        
1641    def show_plot_in_browser(self,html):
1642        with tempfile.NamedTemporaryFile(mode='w', suffix='.html', delete=False) as f:
1643            f.write(html)
1644            url = 'file://' + f.name
1645            webbrowser.open(url)
1646
1647    def smooth_df( self, df ):
1648        """ Smooth temporally the dataframe by label or by group """
1649        rollsize = 20
1650        ## average on a smaller scale if only few frames
1651        if np.max( self.table["frame"] ) <= 20:
1652            rollsize = 5    
1653        if feat+"_smooth" in self.df.columns:
1654            feat = feat+"_smooth"
1655        else:
1656            self.df[feat+"_smooth"] = self.df[feat].rolling(rollsize, center=True).mean()
1657            #print(self.df)
1658            feat = feat+"_smooth"
1659
1660    def save_plot_image( self ):
1661        """ Save current plot graphic to PNG image """
1662        feat = self.feature_choice.currentText()
1663        outfile = self.epicure.outname()+"_plot_"+feat+".png"
1664        if self.fig is not None:
1665            self.fig.write_image( outfile )
1666        if self.epicure.verbose > 0:
1667            ut.show_info("Measures saved in "+outfile)
1668
1669    def save_plot_data( self ):
1670        """ Save the raw data to redraw the current plot to csv file """
1671        feat = self.feature_choice.currentText()
1672        outfile = self.epicure.outname()+"_time_"+feat+".csv"
1673        if self.avg_group.isChecked():
1674            data = self.dfmean.reset_index()[["frame", "group", feat]]
1675            if self.by_label.isChecked():
1676                df = pand.pivot_table( data, columns="label", index="frame", values=feat )
1677                df.to_csv( outfile,  sep='\t', header=True, index=True )
1678            else:
1679                data[["frame", "group", feat]].to_csv( outfile,  sep='\t', header=True, index=False )
1680        else:
1681            data = self.df.reset_index()[["frame", "label", feat]]
1682            if self.by_label.isChecked():
1683                df = pand.pivot_table( data, columns="label", index="frame", values=feat )
1684                df.to_csv( outfile,  sep='\t', header=True, index=True )
1685            else:
1686                data[["frame", "label", feat]].to_csv( outfile,  sep='\t', header=True, index=False )
1687
1688    def move_framepos(self, frame):
1689        """ Move the vertical line showing the current frame position in the main window """
1690        return
1691        #if self.fig is not None:
1692        #    self.fig.add_vline( x=frame, line_dash="dash", line_color="gray" )
1693        #    self.browser.setHtml( self.fig.to_html(include_plotlyjs='cdn'))
1694
1695
1696
1697    def import_webengineview(self):
1698        """Return QWebEngineView from whichever Qt is available."""
1699        import importlib
1700        try:
1701            # Fall back to Qt5
1702            mod = importlib.import_module("PyQt5.QtWebEngineWidgets")
1703            self.browser = mod.QWebEngineView(self)
1704            return 
1705        except Exception:
1706            pass
1707        
1708        try:
1709            # Try Qt6 first
1710            view = importlib.import_module("PyQt6.QtWebEngineWidgets")
1711            self.browser = view.QWebEngineView( parent=self )
1712            return  
1713        except Exception as e:
1714            print(e)
1715            pass
1716
1717        raise ImportError(
1718            "No QtWebEngine found. Install PyQt6-WebEngine or PyQtWebEngine."
1719        )
1720
1721
1722    def create_plotwidget(self):
1723        """ Create plot window """
1724        try:
1725            self.import_webengineview()
1726            self.webengine = True
1727        except:
1728            self.webengine = False
1729            self.browser = NoEngineViewer()
1730            return self.browser
1731        print(self.webengine)
1732        return self.browser
1733
1734class NoEngineViewer(QWidget):
1735    def __init__(self):
1736        super().__init__()
1737        layout = QVBoxLayout()
1738        self.text_browser = QTextBrowser()
1739        self.text_browser.setHtml("<h2>Plots will be redirected to web browser</h2>" \
1740        "" \
1741        "Your napari installation is using pyside6 that doesn't have the necessary dependency to show the plot in this window interactively. To have this option, reinstall napari with pyqt5 or pyqt6." \
1742        "" \
1743        "Otherwise, you can still see the plot, it will open in your web browser, but will be slower to display, reload the web page if nothing appears." \
1744        "")
1745        layout.addWidget(self.text_browser)
1746        self.setLayout(layout)