import fiji.plugin.trackmate.util.TMUtils as TMUtils batchmode = True # Get currently selected image imp = WindowManager.getCurrentImage() #imp = IJ.openImage('http://fiji.sc/samples/FakeTracks.tif') #imp.show() #------------------------- # Instantiate model object #------------------------- model = Model() model.setPhysicalUnits(imp.getCalibration().getUnits(), imp.getCalibration().getTimeUnit()) # Set logger model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) settings.tstart = 2 settings.tend = settings.tend - 5 print('min threshold: ' + str(imp.getProcessor().getMinThreshold()))
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
cal = Calibration() cal.setUnit('micron') cal.pixelHeight = resolution cal.pixelWidth = resolution cal.pixelDepth = 0. cal.fps = 1 cal.frameInterval = 1 imp.setCalibration(cal) #------------------------- # Instantiate model object #------------------------- model = Model() model.setPhysicalUnits('micron', 'frames') # Set logger 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': True,
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'] = 20.0 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 20.0 settings.trackerSettings['MAX_FRAME_GAP'] = 3 settings.initialSpotFilterValue = -1. return trackmate
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)])
rm.runCommand("Open", Roi_File); total_rois = rm.getCount(); for idx in range(total_rois): #---------------------------- # 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); model.setPhysicalUnits(Calib.getUnit(), Calib.getTimeUnit()); #------------------------ # Prepare settings object #------------------------ settings = Settings(); rm.select(imp,idx); actual_roi = rm.getRoi(idx); imp.setRoi(actual_roi); settings.setFrom(imp); settings.tstart = Initial_frames; settings.tend = imp.getNFrames() - Final_frames -1; #settings.roi = rm.getSelectedRoisAsArray(); # Configure detector - We use the Strings for the keys
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))