DetectorKeys.KEY_RADIUS: 4.3, DetectorKeys.KEY_TARGET_CHANNEL: 1, DetectorKeys.KEY_THRESHOLD: 3., DetectorKeys.KEY_DO_MEDIAN_FILTERING: False, } logger.log(str('\n\nSETTINGS:')) logger.log(str(settings)) """ TODO Filter. Think about how and what to implement in the filter. """ # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) filter2 = FeatureFilter('TRACK_DISPLACEMENT', 8, True) settings.addTrackFilter(filter2) filter2 = FeatureFilter('TRACK_DISPLACEMENT', 50, True) settings.addTrackFilter(filter2) filter2 = FeatureFilter('TRACK_DISPLACEMENT', 160, True) settings.addTrackFilter(filter2) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) #-------- # Process #--------
def create_trackmate( imp, results_table ): """ Creates a TrackMate instance configured to operated on the specified ImagePlus imp with cell analysis stored in the specified ResultsTable results_table. """ cal = imp.getCalibration() # TrackMate. # Model. model = Model() model.setLogger( Logger.IJ_LOGGER ) model.setPhysicalUnits( cal.getUnit(), cal.getTimeUnit() ) # Settings. settings = Settings() settings.setFrom( imp ) # Create the TrackMate instance. trackmate = TrackMate( model, settings ) # Add ALL the feature analyzers known to TrackMate, via # providers. # They offer automatic analyzer detection, so all the # available feature analyzers will be added. # Some won't make sense on the binary image (e.g. contrast) # but nevermind. spotAnalyzerProvider = SpotAnalyzerProvider() for key in spotAnalyzerProvider.getKeys(): print( key ) settings.addSpotAnalyzerFactory( spotAnalyzerProvider.getFactory( key ) ) edgeAnalyzerProvider = EdgeAnalyzerProvider() for key in edgeAnalyzerProvider.getKeys(): print( key ) settings.addEdgeAnalyzer( edgeAnalyzerProvider.getFactory( key ) ) trackAnalyzerProvider = TrackAnalyzerProvider() for key in trackAnalyzerProvider.getKeys(): print( key ) settings.addTrackAnalyzer( trackAnalyzerProvider.getFactory( key ) ) trackmate.getModel().getLogger().log( settings.toStringFeatureAnalyzersInfo() ) trackmate.computeSpotFeatures( True ) trackmate.computeEdgeFeatures( True ) trackmate.computeTrackFeatures( True ) # Skip detection and get spots from results table. spots = spots_from_results_table( results_table, cal.frameInterval ) model.setSpots( spots, False ) # Configure detector. We put nothing here, since we already have the spots # from previous step. settings.detectorFactory = ManualDetectorFactory() settings.detectorSettings = {} settings.detectorSettings[ 'RADIUS' ] = 1. # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() settings.trackerSettings[ 'LINKING_MAX_DISTANCE' ] = 10.0 settings.trackerSettings[ 'GAP_CLOSING_MAX_DISTANCE' ] = 15.0 settings.trackerSettings[ 'MAX_FRAME_GAP' ] = 3 settings.trackerSettings[ 'ALLOW_TRACK_SPLITTING' ] = True settings.trackerSettings[ 'SPLITTING_MAX_DISTANCE' ] = 7.0 settings.trackerSettings settings.initialSpotFilterValue = -1. ### print(model.getFeatureModel().getTrackFeatureNames()) # TRACK_START: Track start, # TRACK_INDEX: Track index, # NUMBER_MERGES: Number of merge events, # TRACK_STD_SPEED: Velocity standard deviation, # TRACK_ID: Track ID, # TRACK_MEDIAN_QUALITY: Median quality, # TRACK_STD_QUALITY: Quality standard deviation, # TRACK_X_LOCATION: X Location (mean), # TRACK_MEDIAN_SPEED: Median velocity, # NUMBER_SPOTS: Number of spots in track, # TRACK_MIN_SPEED: Minimal velocity, # NUMBER_GAPS: Number of gaps, # TRACK_Z_LOCATION: Z Location (mean), # TRACK_STOP: Track stop, # TRACK_MEAN_SPEED: Mean velocity, # NUMBER_SPLITS: Number of split events, # TRACK_MAX_SPEED: Maximal velocity, # TRACK_Y_LOCATION: Y Location (mean), # TRACK_DISPLACEMENT: Track displacement, # NUMBER_COMPLEX: Complex points, # TRACK_MEAN_QUALITY: Mean quality, # TRACK_DURATION: Duration of track, # TRACK_MAX_QUALITY: Maximal quality, # LONGEST_GAP: Longest gap, # TRACK_MIN_QUALITY: Minimal quality settings.addTrackFilter(FeatureFilter('NUMBER_SPLITS', 0.9, True)) return trackmate
def track(): imp = IJ.getImage() nChannels = imp.getNChannels() # Get the number of channels orgtitle = imp.getTitle() IJ.run("Subtract Background...", "rolling=50 sliding stack") IJ.run("Enhance Contrast...", "saturated=0.3") IJ.run("Multiply...", "value=10 stack") IJ.run("Subtract Background...", "rolling=50 sliding stack") IJ.run("Set Scale...", "distance=0") channels = ChannelSplitter.split(imp) imp_GFP = channels[0] imp_RFP = channels[1] IJ.selectWindow(orgtitle) IJ.run("Close") ic = ImageCalculator() imp_merge = ic.run("Add create stack", imp_GFP, imp_RFP) imp_merge.setTitle("add_channels") imp_merge.show() imp_RFP.show() imp_GFP.show() imp5 = ImagePlus() IJ.run(imp5, "Merge Channels...", "c1=[" + imp_merge.title + "] c2=" + imp_GFP.title + ' c3=' + imp_RFP.title + " create") print("c1=[" + imp_merge.title + "] c2=" + imp_GFP.title + ' c3=' + imp_RFP.title + " create") imp5.show() imp5 = IJ.getImage() nChannels = imp5.getNChannels() # Setup settings for TrackMate settings = Settings() settings.setFrom(imp5) # Spot analyzer: we want the multi-C intensity analyzer. settings.addSpotAnalyzerFactory(SpotMultiChannelIntensityAnalyzerFactory()) # Spot detector. settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = settings.detectorFactory.getDefaultSettings() settings.detectorSettings['TARGET_CHANNEL'] = 1 settings.detectorSettings['RADIUS'] = 24.0 settings.detectorSettings['THRESHOLD'] = 0.0 # Spot tracker. # Configure tracker - We don't want to allow merges or splits settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() # almost good enough settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = False settings.trackerSettings['ALLOW_TRACK_MERGING'] = False settings.trackerSettings['LINKING_MAX_DISTANCE'] = 8.0 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 8.0 settings.trackerSettings['MAX_FRAME_GAP'] = 1 # Configure track filters settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackSpotQualityFeatureAnalyzer()) filter1 = FeatureFilter('TRACK_DURATION', 20, True) settings.addTrackFilter(filter1) # Run TrackMate and store data into Model. model = Model() trackmate = TrackMate(model, settings) ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) ok = trackmate.process() if not ok: sys.exit(str(trackmate.getErrorMessage())) selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp5) displayer.render() displayer.refresh() IJ.log('TrackMate completed successfully.') IJ.log('Found %d spots in %d tracks.' % (model.getSpots().getNSpots(True) , model.getTrackModel().nTracks(True))) # Print results in the console. headerStr = '%10s %10s %10s %10s %10s %10s' % ('Spot_ID', 'Track_ID', 'Frame', 'X', 'Y', 'Z') rowStr = '%10d %10d %10d %10.1f %10.1f %10.1f' for i in range( nChannels ): headerStr += (' %10s' % ( 'C' + str(i+1) ) ) rowStr += ( ' %10.1f' ) #open a file to save results myfile = open('/home/rickettsia/Desktop/data/Clamydial_Image_Analysis/EMS_BMECBMELVA_20X_01122019/data/'+orgtitle.split('.')[0]+'.csv', 'wb') wr = csv.writer(myfile, quoting=csv.QUOTE_ALL) wr.writerow(['Spot_ID', 'Track_ID', 'Frame', 'X', 'Y', 'Z', 'Channel_1', 'Channel_2']) IJ.log('\n') IJ.log(headerStr) tm = model.getTrackModel() trackIDs = tm.trackIDs(True) for trackID in trackIDs: spots = tm.trackSpots(trackID) # Let's sort them by frame. ls = ArrayList(spots) for spot in ls: values = [spot.ID(), trackID, spot.getFeature('FRAME'), \ spot.getFeature('POSITION_X'), spot.getFeature('POSITION_Y'), spot.getFeature('POSITION_Z')] for i in range(nChannels): values.append(spot.getFeature('MEAN_INTENSITY%02d' % (i+1))) IJ.log(rowStr % tuple(values)) l1 = (values[0], values[1], values[2], values[3], values[4], values[5], values[7], values[8]) wr.writerow(l1) myfile.close() IJ.selectWindow("Merged") IJ.run("Close")
edgeAnalyzerProvider = EdgeAnalyzerProvider() for key in edgeAnalyzerProvider.getKeys(): # print( key ) settings.addEdgeAnalyzer( edgeAnalyzerProvider.getFactory(key)) trackAnalyzerProvider = TrackAnalyzerProvider() for key in trackAnalyzerProvider.getKeys(): # print( key ) settings.addTrackAnalyzer( trackAnalyzerProvider.getFactory(key)) # Configure track filters - track should start before frame 5 track_filter = FeatureFilter('TRACK_START', track_start, False) settings.addTrackFilter(track_filter) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage()))
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() deltaT = settings.dt settings.trackerSettings['LINKING_MAX_DISTANCE'] = 2.0 * deltaT settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE']=4.0 * deltaT settings.trackerSettings['MAX_FRAME_GAP']= 2 linkingFeaturePenalties = settings.trackerSettings['LINKING_FEATURE_PENALTIES'] linkingFeaturePenalties['POSITION_X'] = 9.9999E20 linkingFeaturePenalties['QUALITY'] = 1.0 gapClosingFeaturePenalties = settings.trackerSettings['GAP_CLOSING_FEATURE_PENALTIES'] gapClosingFeaturePenalties['POSITION_X'] = 9.9999E20 # Add filters settings.initialSpotFilterValue = 0 # settings.addSpotFilter(FeatureFilter('QUALITY', 50.0, True)) settings.addTrackFilter(FeatureFilter('TRACK_DISPLACEMENT', .75, True)) settings.addTrackFilter(FeatureFilter('NUMBER_SPOTS', 5, True)) # Add the analyzers for some spot features. # You need to configure TrackMate with analyzers that will generate # the data you need. img = TMUtils.rawWraps(settings.imp) settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotRadiusEstimatorFactory()) settings.addSpotAnalyzerFactory(SpotMorphologyAnalyzerFactory()) # Add analyhzers for edges settings.addEdgeAnalyzer(EdgeTargetAnalyzer()) settings.addEdgeAnalyzer(EdgeTimeLocationAnalyzer()) settings.addEdgeAnalyzer(EdgeVelocityAnalyzer())
def magic(file): # We have to feed a logger to the reader. logger = Logger.IJ_LOGGER #------------------- # Instantiate reader #------------------- reader = TmXmlReader(File(file)) if not reader.isReadingOk(): sys.exit(reader.getErrorMessage()) #----------------- # Get a full model #----------------- # This will return a fully working model, with everything # stored in the file. Missing fields (e.g. tracks) will be # null or None in python model = reader.getModel() # model is a fiji.plugin.trackmate.Model #model = Model() #model.setSpots(model2.getSpots(), True) #---------------- # Display results #---------------- # We can now plainly display the model. It will be shown on an # empty image with default magnification. sm = SelectionModel(model) #displayer = HyperStackDisplayer(model, sm) #displayer.render() #--------------------------------------------- # Get only part of the data stored in the file #--------------------------------------------- # You might want to access only separate parts of the # model. spots = model.getSpots() # spots is a fiji.plugin.trackmate.SpotCollection logger.log(str(spots)) # If you want to get the tracks, it is a bit trickier. # Internally, the tracks are stored as a huge mathematical # simple graph, which is what you retrieve from the file. # There are methods to rebuild the actual tracks, taking # into account for everything, but frankly, if you want to # do that it is simpler to go through the model: #--------------------------------------- # Building a settings object from a file #--------------------------------------- # Reading the Settings object is actually currently complicated. The # reader wants to initialize properly everything you saved in the file, # including the spot, edge, track analyzers, the filters, the detector, # the tracker, etc... # It can do that, but you must provide the reader with providers, that # are able to instantiate the correct TrackMate Java classes from # the XML data. # We start by creating an empty settings object settings = Settings() # Then we create all the providers, and point them to the target model: detectorProvider = DetectorProvider() trackerProvider = TrackerProvider() spotAnalyzerProvider = SpotAnalyzerProvider() edgeAnalyzerProvider = EdgeAnalyzerProvider() trackAnalyzerProvider = TrackAnalyzerProvider() # Ouf! now we can flesh out our settings object: reader.readSettings(settings, detectorProvider, trackerProvider, spotAnalyzerProvider, edgeAnalyzerProvider, trackAnalyzerProvider) settings.detectorFactory = ManualDetectorFactory() # Configure tracker - We want to allow merges and fusions settings.initialSpotFilterValue = 0 settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() # almost good enough settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = True settings.trackerSettings['ALLOW_TRACK_MERGING'] = False settings.trackerSettings['LINKING_MAX_DISTANCE'] = 40.0 settings.trackerSettings['ALLOW_GAP_CLOSING'] = True settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = True settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 30.0 settings.trackerSettings['MAX_FRAME_GAP'] = 4 # Configure track analyzers - Later on we want to filter out tracks # based on their displacement, so we need to state that we want # track displacement to be calculated. By default, out of the GUI, # not features are calculated. # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackBranchingAnalyzer()) settings.addTrackAnalyzer(TrackIndexAnalyzer()) settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) settings.addTrackAnalyzer(LinearTrackDescriptor()) # Configure track filters - We want to get rid of the two immobile spots at # the bottom right of the image. Track displacement must be above 10 pixels. filter2 = FeatureFilter('NUMBER_SPOTS', 31, True) settings.addTrackFilter(filter2) #filter3 = FeatureFilter('NUMBER_GAPS', 2, False) #settings.addTrackFilter(filter3) filter4 = FeatureFilter('NUMBER_SPLITS', 0.5, False) settings.addTrackFilter(filter4) settings.addEdgeAnalyzer(EdgeTargetAnalyzer()) settings.addEdgeAnalyzer(EdgeTimeLocationAnalyzer()) settings.addEdgeAnalyzer(EdgeVelocityAnalyzer()) settings.addEdgeAnalyzer(LinearTrackEdgeStatistics()) #------------------- # Instantiate plugin #------------------- logger.log(str('\n\nSETTINGS:')) logger.log(unicode(settings)) print("tracking") spots = model.getSpots() # spots is a fiji.plugin.trackmate.SpotCollection logger.log(str(spots)) logger.log(str(spots.keySet())) # The settings object is also instantiated with the target image. # Note that the XML file only stores a link to the image. # If the link is not valid, the image will not be found. #imp = settings.imp #imp.show() # With this, we can overlay the model and the source image: trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) trackmate.execInitialSpotFiltering() trackmate.execSpotFiltering(True) trackmate.execTracking() trackmate.computeTrackFeatures(True) trackmate.execTrackFiltering(True) trackmate.computeEdgeFeatures(True) outfile = TmXmlWriter(File(str(file[:-4] + ".trackmate.xml"))) outfile.appendSettings(settings) outfile.appendModel(model) outfile.writeToFile() ISBIChallengeExporter.exportToFile(model, settings, File(str(file[:-4] + ".ISBI.xml")))
def process(srcDir, dstDir, currentDir, fileName, keepDirectories): print "Processing:" # Opening the image print "Open image file", fileName imp = IJ.openImage(os.path.join(currentDir, fileName)) #Here we make sure the calibration are correct units = "pixel" TimeUnit = "unit" newCal = Calibration() newCal.pixelWidth = 1 newCal.pixelHeight = 1 newCal.frameInterval = 1 newCal.setXUnit(units) newCal.setYUnit(units) newCal.setTimeUnit(TimeUnit) imp.setCalibration(newCal) cal = imp.getCalibration() dims = imp.getDimensions() # default order: XYCZT if (dims[4] == 1): imp.setDimensions(1, 1, dims[3]) # Start the tracking model = Model() #Read the image calibration model.setPhysicalUnits(cal.getUnit(), cal.getTimeUnit()) # Send all messages to ImageJ log window. model.setLogger(Logger.IJ_LOGGER) settings = Settings() settings.setFrom(imp) # Configure detector - We use the Strings for the keys # Configure detector - We use the Strings for the keys settings.detectorFactory = DownsampleLogDetectorFactory() settings.detectorSettings = { DetectorKeys.KEY_RADIUS: 2., DetectorKeys.KEY_DOWNSAMPLE_FACTOR: 2, DetectorKeys.KEY_THRESHOLD: 1., } print(settings.detectorSettings) # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 0, True) settings.addSpotFilter(filter1) # Configure tracker - We want to allow merges and fusions settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap( ) # almost good enough settings.trackerSettings['LINKING_MAX_DISTANCE'] = LINKING_MAX_DISTANCE settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = ALLOW_TRACK_SPLITTING settings.trackerSettings['SPLITTING_MAX_DISTANCE'] = SPLITTING_MAX_DISTANCE settings.trackerSettings['ALLOW_TRACK_MERGING'] = ALLOW_TRACK_MERGING settings.trackerSettings['MERGING_MAX_DISTANCE'] = MERGING_MAX_DISTANCE settings.trackerSettings[ 'GAP_CLOSING_MAX_DISTANCE'] = GAP_CLOSING_MAX_DISTANCE settings.trackerSettings['MAX_FRAME_GAP'] = MAX_FRAME_GAP # Configure track analyzers - Later on we want to filter out tracks # based on their displacement, so we need to state that we want # track displacement to be calculated. By default, out of the GUI, # not features are calculated. # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) filter2 = FeatureFilter('TRACK_DISPLACEMENT', 10, True) settings.addTrackFilter(filter2) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) ok = trackmate.process() if not ok: sys.exit(str(trackmate.getErrorMessage())) #---------------- # Display results #---------------- if showtracks: model.getLogger().log('Found ' + str(model.getTrackModel().nTracks(True)) + ' tracks.') selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() # The feature model, that stores edge and track features. fm = model.getFeatureModel() with open(dstDir + fileName + 'tracks_properties.csv', "w") as file: writer1 = csv.writer(file) writer1.writerow([ "track #", "TRACK_MEAN_SPEED (micrometer.secs)", "TRACK_MAX_SPEED (micrometer.secs)", "NUMBER_SPLITS", "TRACK_DURATION (secs)", "TRACK_DISPLACEMENT (micrometer)" ]) with open(dstDir + fileName + 'spots_properties.csv', "w") as trackfile: writer2 = csv.writer(trackfile) #writer2.writerow(["spot ID","POSITION_X","POSITION_Y","Track ID", "FRAME"]) writer2.writerow( ["Tracking ID", "Timepoint", "Time (secs)", "X pos", "Y pos"]) for id in model.getTrackModel().trackIDs(True): # Fetch the track feature from the feature model. v = (fm.getTrackFeature(id, 'TRACK_MEAN_SPEED') * Pixel_calibration) / Time_interval ms = (fm.getTrackFeature(id, 'TRACK_MAX_SPEED') * Pixel_calibration) / Time_interval s = fm.getTrackFeature(id, 'NUMBER_SPLITS') d = fm.getTrackFeature(id, 'TRACK_DURATION') * Time_interval e = fm.getTrackFeature( id, 'TRACK_DISPLACEMENT') * Pixel_calibration model.getLogger().log('') model.getLogger().log('Track ' + str(id) + ': mean velocity = ' + str(v) + ' ' + model.getSpaceUnits() + '/' + model.getTimeUnits()) track = model.getTrackModel().trackSpots(id) writer1.writerow( [str(id), str(v), str(ms), str(s), str(d), str(e)]) for spot in track: sid = spot.ID() x = spot.getFeature('POSITION_X') y = spot.getFeature('POSITION_Y') z = spot.getFeature('TRACK_ID') t = spot.getFeature('FRAME') time = int(t) * int(Time_interval) writer2.writerow( [str(id), str(t), str(time), str(x), str(y)])
def track_cells(folder_w, filename, imp, correction): #imp = IJ.openImage(os.path.join(folder,filename)) #imp.show() #get image dimensions, set ROI remove part of flouresncent ring x_size = ImagePlus.getDimensions(imp)[0] y_size = ImagePlus.getDimensions(imp)[1] x_start = 0 y_start = 0 #calculate alternative ROI if crop_ring: x_start = 170 / 2 y_start = 170 / 2 x_size = x_size - 170 y_size = y_size - 170 print( str(x_start) + ", " + str(y_start) + ", " + str(x_size) + ", " + str(y_size)) imp.setRoi(OvalRoi(x_start, y_start, x_size, y_size)) #imp_dup = imp.duplicate() #imp_dup.show() #red_corrected_img.show() IJ.run(imp, "Make Inverse", "") IJ.setForegroundColor(0, 0, 0) IJ.run(imp, "Fill", "stack") imp.killRoi() #imp.show() #sys.exit() #img_filename = filename+"_corrected_red_stack.tif" #folder_filename= os.path.join(well_folder,img_filename) #IJ.save(imp, folder_filename) #---------------------------- # Create the model object now #---------------------------- # Some of the parameters we configure below need to have # a reference to the model at creation. So we create an # empty model now. model = Model() # Send all messages to ImageJ log window. model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Configure detector - We use the Strings for the keys settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': SUBPIXEL_LOCALIZATION, 'RADIUS': RADIUS, 'TARGET_CHANNEL': TARGET_CHANNEL, 'THRESHOLD': THRESHOLD, 'DO_MEDIAN_FILTERING': MEDIAN_FILTERING, } # Configure spot filters - Classical filter on quality settings.initialSpotFilterValue = SPOT_FILTER settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotMorphologyAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotRadiusEstimatorFactory()) filter1 = FeatureFilter('QUALITY', QUALITY, True) filter2 = FeatureFilter('CONTRAST', CONTRAST, True) filter2a = FeatureFilter('ESTIMATED_DIAMETER', MAX_ESTIMATED_DIAMETER, False) filter2b = FeatureFilter('MEDIAN_INTENSITY', MAX_MEDIAN_INTENSITY, False) settings.addSpotFilter(filter1) settings.addSpotFilter(filter2) settings.addSpotFilter(filter2a) settings.addSpotFilter(filter2b) print(settings.spotFilters) # Configure tracker - We want to allow merges and fusions settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap( ) # almost good enough ##adapted from https://forum.image.sc/t/trackmate-scripting-automatically-exporting-spots-in-tracks-links-in-tracks-tracks-statistics-and-branching-analysis-to-csv/6256 #linking settings settings.trackerSettings['LINKING_MAX_DISTANCE'] = LINKING_MAX_DISTANCE if LINKING_FEATURE_PENALTIES == True: settings.trackerSettings['LINKING_FEATURE_PENALTIES'] = { LINKING_FEATURE_PENALTIES_TYPE: LINKING_FEATURE_PENALTIES_VALUE } else: settings.trackerSettings['LINKING_FEATURE_PENALTIES'] = {} #gap closing settings settings.trackerSettings['ALLOW_GAP_CLOSING'] = ALLOW_GAP_CLOSING if ALLOW_GAP_CLOSING == True: settings.trackerSettings[ 'GAP_CLOSING_MAX_DISTANCE'] = GAP_CLOSING_MAX_DISTANCE settings.trackerSettings['MAX_FRAME_GAP'] = MAX_FRAME_GAP if GAP_CLOSING_FEATURE_PENALTIES == True: settings.trackerSettings['GAP_CLOSING_FEATURE_PENALTIES'] = { GAP_CLOSING_FEATURE_PENALTIES_TYPE: GAP_CLOSING_FEATURE_PENALTIES_VALUE } else: settings.trackerSettings['GAP_CLOSING_FEATURE_PENALTIES'] = {} #splitting settings settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = ALLOW_TRACK_SPLITTING if ALLOW_TRACK_SPLITTING == True: settings.trackerSettings[ 'SPLITTING_MAX_DISTANCE'] = SPLITTING_MAX_DISTANCE if SPLITTING_FEATURE_PENALTIES == True: settings.trackerSettings['SPLITTING_FEATURE_PENALTIES'] = { SPLITTING_FEATURE_PENALTIES_TYPE: SPLITTING_FEATURE_PENALTIES_VALUE } else: settings.trackerSettings['SPLITTING_FEATURE_PENALTIES'] = {} #merging settings settings.trackerSettings['ALLOW_TRACK_MERGING'] = ALLOW_TRACK_MERGING if ALLOW_TRACK_MERGING == True: settings.trackerSettings['MERGING_MAX_DISTANCE'] = MERGING_MAX_DISTANCE if MERGING_FEATURE_PENALTIES == True: settings.trackerSettings['MERGING_FEATURE_PENALTIES'] = { MERGING_FEATURE_PENALTIES_TYPE: MERGING_FEATURE_PENALTIES_VALUE } else: settings.trackerSettings['MERGING_FEATURE_PENALTIES'] = {} print(settings.trackerSettings) # Configure track analyzers - Later on we want to filter out tracks # based on their displacement, so we need to state that we want # track displacement to be calculated. By default, out of the GUI, # not features are calculated. # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackSpotQualityFeatureAnalyzer()) # Configure track filters - We want to get rid of the two immobile spots at # the bottom right of the image. Track displacement must be above 10 pixels. filter3 = FeatureFilter('TRACK_DISPLACEMENT', TRACK_DISPLACEMENT, True) filter4 = FeatureFilter('TRACK_START', TRACK_START, False) #filter5 = FeatureFilter('TRACK_STOP', float(imp.getStack().getSize())-1.1, True) settings.addTrackFilter(filter3) settings.addTrackFilter(filter4) #settings.addTrackFilter(filter5) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) ok = trackmate.process() # if not ok: #sys.exit(str(trackmate.getErrorMessage())) #---------------- # Display results #---------------- #Set output folder and filename and create output folder well_folder = os.path.join(folder_w, filename) output_folder = os.path.join(well_folder, "Tracking") create_folder(output_folder) xml_file_name = filename + "_" + correction + "_trackmate_analysis.xml" folder_filename_xml = os.path.join(output_folder, xml_file_name) #ExportTracksToXML.export(model, settings, File(folder_filename_xml)) outfile = TmXmlWriter(File(folder_filename_xml)) outfile.appendSettings(settings) outfile.appendModel(model) outfile.writeToFile() # Echo results with the logger we set at start: #model.getLogger().log(str(model)) #create araray of timepoint length with filled 0 cell_counts = zerolistmaker(imp.getStack().getSize()) if ok: for id in model.getTrackModel().trackIDs(True): # Fetch the track feature from the feature model. track = model.getTrackModel().trackSpots(id) for spot in track: # Fetch spot features directly from spot. t = spot.getFeature('FRAME') print(t) cell_counts[int(t)] = cell_counts[int(t)] + 1 else: print("No spots detected!") if HEADLESS == False: selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() del imp return (cell_counts + [len(model.getTrackModel().trackIDs(True))])
def run_trackmate(imp, path, filename, params, batch_mode=False): # initialize trackmate model model = Model() # Set logger - use to see outputs, not needed in batch mode model.setLogger(Logger.IJ_LOGGER) # Create setting object from image settings = Settings() settings.setFrom(imp) cal = imp.getCalibration() model.setPhysicalUnits("micron", "sec") # Configure detector settings.detectorFactory = LogDetectorFactory() # settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': params.do_subpixel_localization, 'RADIUS': params.radius, 'TARGET_CHANNEL': 0, 'THRESHOLD': params.threshold, 'DO_MEDIAN_FILTERING': params.do_median_filtering, } # print(params) # Add spot filters filter_quality = FeatureFilter('QUALITY', params.quality, True) settings.addSpotFilter(filter_quality) filter_snr = FeatureFilter('SNR', params.snr, True) settings.addSpotFilter(filter_snr) # Compute spot features settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) # Compute track features settings.addTrackAnalyzer(TrackBranchingAnalyzer()) settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackIndexAnalyzer()) settings.addTrackAnalyzer(TrackLocationAnalyzer()) settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) settings.addTrackAnalyzer(TrackSpotQualityFeatureAnalyzer()) # Update model ModelFeatureUpdater(model, settings) # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() settings.trackerSettings[ 'LINKING_MAX_DISTANCE'] = params.linking_max_distance settings.trackerSettings[ 'GAP_CLOSING_MAX_DISTANCE'] = params.gap_closing_max_distance settings.trackerSettings['MAX_FRAME_GAP'] = params.max_frame_gap # Add track filters filter_T1 = FeatureFilter('TRACK_DURATION', params.track_duration, True) filter_MTD = FeatureFilter('TRACK_DISPLACEMENT', params.track_displacement, True) settings.addTrackFilter(filter_T1) settings.addTrackFilter(filter_MTD) # Instantiate trackmate trackmate = TrackMate(model, settings) # Execute all ok = trackmate.checkInput() if not ok: IJ.showMessage("No spots found... Adjust detection parameter.\n" + str(trackmate.getErrorMessage())) sys.exit(str(trackmate.getErrorMessage())) ok = trackmate.process() if not ok: IJ.showMessage("No spots found... Adjust detection parameter.\n" + str(trackmate.getErrorMessage())) sys.exit(str(trackmate.getErrorMessage())) filename = os.path.splitext(filename)[0] #filename without extension outFile = File(os.path.join(path, filename + "_Tracks.xml")) ExportTracksToXML.export(model, settings, outFile) #imp.close() tm_writer = TmXmlWriter(File(os.path.join(path, filename + "_TM.xml"))) tm_writer.appendModel(model) tm_writer.appendSettings(settings) tm_writer.writeToFile() if not batch_mode: selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() # Echo results with the logger we set at start: model.getLogger().log(str(model))
settings.trackerSettings['ALLOW_TRACK_MERGING'] = True # Configure track analyzers - Later on we want to filter out tracks # based on their displacement, so we need to state that we want # track displacement to be calculated. By default, out of the GUI, # not features are calculated. # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) # Configure track filters - We want to get rid of the two immobile spots at # the bottom right of the image. Track displacement must be above 10 pixels. filter2 = FeatureFilter('TRACK_DISPLACEMENT', 10, True) settings.addTrackFilter(filter2) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage()))