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