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()))
