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
# Add ALL the feature analyzers known to TrackMate, via
# providers.
# They offer automatic analyzer detection, so all the
# available feature analyzers will be added.
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))
# Configure track filters - track should start before frame 5
track_filter = FeatureFilter('TRACK_START', track_start, False)
settings.addTrackFilter(track_filter)
#-------------------
# Instantiate plugin
#-------------------
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())
# Add an analyzer for some track features, such as the track mean speed.
settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer())
settings.addTrackAnalyzer(TrackDurationAnalyzer())
settings.addTrackAnalyzer(TrackIndexAnalyzer())
settings.addTrackAnalyzer(TrackLocationAnalyzer())
settings.addTrackAnalyzer(TrackSpotFeatureAnalyzer())
print(str(settings))
if batchmode:
print 'Running in batchmode'
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 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
settings.detectorSettings[
'DO_SUBPIXEL_LOCALIZATION'] = True # do subpixel localization
settings.detectorSettings['RADIUS'] = radius # set blob radius
settings.detectorSettings['TARGET_CHANNEL'] = 1 # set target channel
settings.detectorSettings[
'THRESHOLD'] = 1.0 # set detection threshold to one to exclude region outside mask
settings.detectorSettings[
'DO_MEDIAN_FILTERING'] = True # do median filtering
settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory())
settings.addSpotAnalyzerFactory(SpotRadiusEstimatorFactory())
settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory())
settings.initialSpotFilterValue = quality
settings.addSpotFilter(FeatureFilter('QUALITY', quality, True))
settings.trackerFactory = SparseLAPTrackerFactory()
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
settings.addEdgeAnalyzer(EdgeTargetAnalyzer())
settings.addEdgeAnalyzer(EdgeVelocityAnalyzer())
settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer())
settings.addTrackAnalyzer(TrackDurationAnalyzer())
settings.addTrackAnalyzer(TrackIndexAnalyzer())
settings.addTrackAnalyzer(TrackLocationAnalyzer())
settings.trackerSettings[
'LINKING_MAX_DISTANCE'] = distL # set maximum linkage
settings.trackerSettings[
'GAP_CLOSING_MAX_DISTANCE'] = distF # maximum gap-closing distance in pixels
settings.trackerSettings[
'MAX_FRAME_GAP'] = distG # maximum frame gap number in pixels
print 'track', 'tracking'
trackmate = TrackMate(model, settings) # detect and track Golgi
trackmate.process()
#settings.trackerFactory = SimpleLAPTrackerFactory();
settings.trackerFactory = SimpleSparseLAPTrackerFactory();
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap(); # almost good enough
settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = Track_splitting;
settings.trackerSettings['ALLOW_TRACK_MERGING'] = Track_merging;
settings.trackerSettings['LINKING_MAX_DISTANCE'] = Max_jump;
settings.trackerSettings['ALLOW_GAP_CLOSING'] = Gap_closing;
settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = Gap_closing_distance;
settings.trackerSettings['MAX_FRAME_GAP'] = Max_frame_gap;
#----------------
# Configure track features analyzers
#----------------
if Analyze_tracks:
settings.addEdgeAnalyzer(EdgeTargetAnalyzer());
settings.addEdgeAnalyzer(EdgeTimeLocationAnalyzer());
settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory());
settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory());
settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer());
settings.addTrackAnalyzer(TrackDurationAnalyzer());
#----------------
# Configure track filters
#----------------
# the bottom right of the image. Track displacement must be above 10 pixels.
#filter2 = FeatureFilter('TRACK_DISPLACEMENT', 0, True);
#settings.addTrackFilter(filter2);
#-------------------
def track_single_batch(path, filename):
# Get currently selected image
imp = WindowManager.getCurrentImage()
# imp = IJ.openImage('https://fiji.sc/samples/FakeTracks.tif')
imp.show()
#----------------------------
# 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.detectorFactory = BlockLogDetectorFactory()
print
settings.detectorSettings = {
'DO_SUBPIXEL_LOCALIZATION': True,
'RADIUS': 7.5,
'TARGET_CHANNEL': 1,
'THRESHOLD': 0.25,
'DO_MEDIAN_FILTERING': False,
'NSPLIT': 3,
}
# Configure spot filters - Classical filter on quality
filter1 = FeatureFilter('QUALITY', 0.1, True) # in higher SNR;
settings.addSpotFilter(filter1)
# Configure tracker - We want to allow merges and fusions
settings.trackerFactory = SparseLAPTrackerFactory()
#settings.trackerFactory = LAPTrackerFactory()
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap(
) # almost good enough
settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = True
settings.trackerSettings['ALLOW_TRACK_MERGING'] = True
settings.trackerSettings['LINKING_MAX_DISTANCE'] = 15.0
settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 15.0
settings.trackerSettings['MAX_FRAME_GAP'] = 5
# feature
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))
#filter2 = FeatureFilter('TRACK_DISPLACEMENT', 3, True)
#settings.addTrackFilter(filter2)
# processing
trackmate = TrackMate(model, settings)
ok = trackmate.checkInput()
if not ok:
sys.exit(str(trackmate.getErrorMessage()))
try:
ok = trackmate.process()
except:
IJ.log("Nothing detected")
else:
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))
save_path = os.path.join(path, 'result')
if not os.path.exists(save_path):
os.mkdir(save_path, 0755)
outFile = File(save_path, filename)
ExportTracksToXML.export(model, settings, outFile)
imp.close()
