# 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) settings.addSpotAnalyzerFactory(SpotRadiusEstimatorFactory()) settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) # Add an analyzer for some track features, such as the track mean speed. settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) settings.addTrackAnalyzer(TrackSpotQualityFeatureAnalyzer()) settings.addTrackAnalyzer(TrackLocationAnalyzer()) settings.addTrackAnalyzer(TrackBranchingAnalyzer()) settings.addTrackAnalyzer(TrackIndexAnalyzer()) #settings.initialSpotFilterValue = 1 print(str(settings)) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) trackmate.setNumThreads(8) #-------- # Process #--------
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 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))
def processImages(cfg, wellName, wellPath, images): firstImage = IJ.openImage(images[0][0][0][0]) imgWidth = firstImage.getWidth() imgHeight = firstImage.getHeight() for c in range(0, cfg.getValue(ELMConfig.numChannels)): chanName = cfg.getValue(ELMConfig.chanLabel)[c] if cfg.getValue(ELMConfig.chanLabel)[c] in cfg.getValue( ELMConfig.chansToSkip): continue imColorSeq = ImageStack(imgWidth, imgHeight) imSeq = ImageStack(imgWidth, imgHeight) totalHist = [] for z in range(0, cfg.getValue(ELMConfig.numZ)): for t in range(0, cfg.getValue(ELMConfig.numT)): currIP = IJ.openImage(images[c][z][t][0]) imColorSeq.addSlice(currIP.duplicate().getProcessor()) currIP = ELMImageUtils.getGrayScaleImage( currIP, c, chanName, cfg) imSeq.addSlice(currIP.getProcessor()) imgStats = currIP.getStatistics() currHist = imgStats.getHistogram() if not totalHist: for i in range(len(currHist)): totalHist.append(currHist[i]) else: for i in range(len(currHist)): totalHist[i] += currHist[i] if cfg.hasValue(ELMConfig.thresholdFromWholeRange) and cfg.getValue( ELMConfig.thresholdFromWholeRange) == True: threshMethod = "Otsu" # Default works very poorly for this data if cfg.hasValue(ELMConfig.thresholdMethod): threshMethod = cfg.getValue(ELMConfig.thresholdMethod) thresholder = AutoThresholder() computedThresh = thresholder.getThreshold(threshMethod, totalHist) cfg.setValue(ELMConfig.imageThreshold, computedThresh) print("\tComputed threshold from total hist (" + threshMethod + "): " + str(computedThresh)) print() else: print("\tUsing threshold computed on individual images!") print() computedThresh = 0 chanName = cfg.getValue(ELMConfig.chanLabel)[c] imp = ImagePlus() imp.setStack(imSeq) imp.setDimensions(1, 1, cfg.getValue(ELMConfig.numT)) imp.setTitle(wellName + ", channel " + str(c)) impColor = ImagePlus() impColor.setStack(imColorSeq) impColor.setDimensions(1, 1, cfg.getValue(ELMConfig.numT)) impColor.setTitle(wellName + ", channel " + str(c) + " (Color)") #---------------------------- # 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) pa_features = [ "Area", "PercentArea", "Mean", "StdDev", "Mode", "Min", "Max", "X", "Y", "XM", "YM", "Perim.", "BX", "BY", "Width", "Height", "Major", "Minor", "Angle", "Circ.", "Feret", "IntDen", "Median", "Skew", "Kurt", "RawIntDen", "FeretX", "FeretY", "FeretAngle", "MinFeret", "AR", "Round", "Solidity" ] featureNames = {} featureShortNames = {} featureDimensions = {} isInt = {} for feature in pa_features: featureNames[feature] = feature featureShortNames[feature] = feature featureDimensions[feature] = Dimension.STRING isInt[feature] = False model.getFeatureModel().declareSpotFeatures(pa_features, featureNames, featureShortNames, featureDimensions, isInt) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) dbgPath = os.path.join(wellPath, 'debugImages_' + chanName) if not os.path.exists(dbgPath): os.makedirs(dbgPath) if cfg.hasValue(ELMConfig.thresholdMethod): threshMethod = cfg.getValue(ELMConfig.thresholdMethod) else: threshMethod = "Default" # Configure detector - We use the Strings for the keys settings.detectorFactory = ThresholdDetectorFactory() settings.detectorSettings = { 'THRESHOLD': computedThresh, 'ABOVE': True, 'DEBUG_MODE': True, 'DEBUG_OUTPATH': dbgPath, 'THRESHOLD_METHOD': threshMethod } #settings.detectorFactory = LocalThresholdDetectorFactory() #settings.detectorSettings = { # 'THRESHOLD' : computedThresh, # 'DEBUG_MODE' : True, # 'DEBUG_OUTPATH' : dbgPath #} # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 150, True) settings.addSpotFilter(filter1) # Configure tracker - We want to allow merges and fusions settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap( ) # almost good enough # Linking settings.trackerSettings[TrackerKeys.KEY_LINKING_MAX_DISTANCE] = 220.0 # in pixels linkFeaturePenalties = HashMap() linkFeaturePenalties['Area'] = 1.0 linkFeaturePenalties['POSITION_X'] = 1.0 linkFeaturePenalties['POSITION_Y'] = 1.0 #linkFeaturePenalties['Circ.'] = 1.0 #linkFeaturePenalties['Mean'] = 1.0 settings.trackerSettings[ TrackerKeys.KEY_LINKING_FEATURE_PENALTIES] = linkFeaturePenalties # Gap closing settings.trackerSettings[TrackerKeys.KEY_ALLOW_GAP_CLOSING] = True settings.trackerSettings[TrackerKeys.KEY_GAP_CLOSING_MAX_FRAME_GAP] = 8 settings.trackerSettings[ TrackerKeys.KEY_GAP_CLOSING_MAX_DISTANCE] = 120.0 # in pixels #settings.trackerSettings[TrackerKeys.KEY_GAP_CLOSING_FEATURE_PENALTIES] = new HashMap<>(DEFAULT_GAP_CLOSING_FEATURE_PENALTIES)); # Track splitting settings.trackerSettings[TrackerKeys.KEY_ALLOW_TRACK_SPLITTING] = False settings.trackerSettings[TrackerKeys.KEY_SPLITTING_MAX_DISTANCE] = 45.0 # in pixels #settings.trackerSettings[TrackerKeys.KEY_SPLITTING_FEATURE_PENALTIES] = new HashMap<>(DEFAULT_SPLITTING_FEATURE_PENALTIES)); # Track merging settings.trackerSettings[TrackerKeys.KEY_ALLOW_TRACK_MERGING] = True settings.trackerSettings[TrackerKeys.KEY_MERGING_MAX_DISTANCE] = 45.0 # in pixels #settings.trackerSettings[TrackerKeys.KEY_MERGING_FEATURE_PENALTIES] = new HashMap<>(DEFAULT_MERGING_FEATURE_PENALTIES)); # Others settings.trackerSettings[TrackerKeys.KEY_BLOCKING_VALUE] = float("inf") settings.trackerSettings[ TrackerKeys.KEY_ALTERNATIVE_LINKING_COST_FACTOR] = 1.05 settings.trackerSettings[TrackerKeys.KEY_CUTOFF_PERCENTILE] = 0.9 # 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, # no features are calculated. # The displacement feature is provided by the TrackDurationAnalyzer. settings.addTrackAnalyzer(TrackDurationAnalyzer()) settings.addTrackAnalyzer(TrackBranchingAnalyzer()) settings.addTrackAnalyzer(TrackIndexAnalyzer()) settings.addTrackAnalyzer(TrackLocationAnalyzer()) settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) # 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', 1, True) #settings.addTrackFilter(filter2) #filter2 = FeatureFilter('TRACK_DISPLACEMENT', 1, True) #settings.addTrackFilter(filter2) #print("Spot feature analyzers: " + settings.toStringFeatureAnalyzersInfo()) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) trackmate.setNumThreads(1) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) print("Processing " + chanName + "...") ok = trackmate.process() if not ok: sys.exit(str(trackmate.getErrorMessage())) #---------------- # Display results #---------------- print("Rendering...") # Set spot names based on track IDs # This allows track IDs to be displayed in the rendered video for tId in model.getTrackModel().trackIDs(True): trackSpots = model.getTrackModel().trackSpots(tId) for spot in trackSpots: spot.setName(str(tId)) # Determine sub-tracks within a track # Since tracks can merge, we want to keep track of which track a spot is # in prior to the merge spotToSubTrackMap = {} spotIt = model.getSpots().iterator(False) trackModel = model.getTrackModel() subTrackCount = {} while spotIt.hasNext(): spot = spotIt.next() spotEdges = trackModel.edgesOf(spot) # Find merge points within a track: ignore spots with fewer than 2 edges if (len(spotEdges) < 2): continue # We have a merge if we have multiple incoming edges incomingEdges = 0 edgeIt = spotEdges.iterator() ancestorSpots = [] while edgeIt.hasNext(): edge = edgeIt.next() src = trackModel.getEdgeSource(edge) dst = trackModel.getEdgeTarget(edge) if dst.ID() == spot.ID(): ancestorSpots.append(src) incomingEdges += 1 # Ignore non-merges if incomingEdges < 2: continue trackId = trackModel.trackIDOf(spot) if trackId in subTrackCount: subTrackId = subTrackCount[trackId] else: subTrackId = 1 for ancestorSpot in ancestorSpots: labelSubTrackAncestors(trackModel, spotToSubTrackMap, ancestorSpot, subTrackId, trackId, False) subTrackId += 1 subTrackCount[trackId] = subTrackId # Spots after the last merge still need to be labeled for tId in trackModel.trackIDs(True): trackSpots = trackModel.trackSpots(tId) spotIt = trackSpots.iterator() lastSpot = None while spotIt.hasNext(): spot = spotIt.next() outgoingEdges = 0 spotEdges = trackModel.edgesOf(spot) edgeIt = spotEdges.iterator() while edgeIt.hasNext(): edge = edgeIt.next() src = trackModel.getEdgeSource(edge) dst = trackModel.getEdgeTarget(edge) if src.ID() == spot.ID(): outgoingEdges += 1 if outgoingEdges == 0 and len(spotEdges) > 0: lastSpot = spot if tId in subTrackCount: subTrackId = subTrackCount[tId] else: subTrackId = 1 if not lastSpot == None: labelSubTrackAncestors(trackModel, spotToSubTrackMap, lastSpot, subTrackId, tId, True) # Create output file trackOut = os.path.join(wellPath, chanName + "_spotToTrackMap.csv") trackFile = open(trackOut, 'w') # Fetch the track feature from the feature model. trackFile.write('Spot Id, Track Sub Id, Track Id, Frame \n') for spotId in spotToSubTrackMap: trackFile.write( str(spotId) + ', ' + ','.join(spotToSubTrackMap[spotId]) + '\n') trackFile.close() # Write Edge Set trackOut = os.path.join(wellPath, chanName + "_mergeEdgeSet.csv") trackFile = open(trackOut, 'w') trackFile.write('Track Id, Spot Id, Spot Id \n') edgeIt = trackModel.edgeSet().iterator() while edgeIt.hasNext(): edge = edgeIt.next() src = trackModel.getEdgeSource(edge) dst = trackModel.getEdgeTarget(edge) trackId = trackModel.trackIDOf(edge) srcSubTrack = spotToSubTrackMap[src.ID()][0] dstSubTrack = spotToSubTrackMap[dst.ID()][0] if not srcSubTrack == dstSubTrack: trackFile.write( str(trackId) + ', ' + str(src.ID()) + ', ' + str(dst.ID()) + '\n') trackFile.close() selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, impColor) displayer.setDisplaySettings( TrackMateModelView.KEY_TRACK_COLORING, PerTrackFeatureColorGenerator(model, TrackIndexAnalyzer.TRACK_INDEX)) displayer.setDisplaySettings( TrackMateModelView.KEY_SPOT_COLORING, SpotColorGeneratorPerTrackFeature(model, TrackIndexAnalyzer.TRACK_INDEX)) displayer.setDisplaySettings(TrackMateModelView.KEY_DISPLAY_SPOT_NAMES, True) displayer.setDisplaySettings( TrackMateModelView.KEY_TRACK_DISPLAY_MODE, TrackMateModelView.TRACK_DISPLAY_MODE_LOCAL_BACKWARD_QUICK) displayer.setDisplaySettings( TrackMateModelView.KEY_TRACK_DISPLAY_DEPTH, 2) displayer.render() displayer.refresh() trackmate.getSettings().imp = impColor coa = CaptureOverlayAction(None) coa.execute(trackmate) WindowManager.setTempCurrentImage(coa.getCapture()) IJ.saveAs('avi', os.path.join(wellPath, chanName + "_out.avi")) imp.close() impColor.close() displayer.clear() displayer.getImp().hide() displayer.getImp().close() coa.getCapture().hide() coa.getCapture().close() # Echo results with the logger we set at start: model.getLogger().log(str(model)) # The feature model, that stores edge and track features. fm = model.getFeatureModel() # Write output for tracks numTracks = model.getTrackModel().trackIDs(True).size() print "Writing track data for " + str(numTracks) + " tracks." trackDat = {} for tId in model.getTrackModel().trackIDs(True): track = model.getTrackModel().trackSpots(tId) # Ensure track spots dir exists trackOut = os.path.join(wellPath, chanName + "_track_spots") if not os.path.exists(trackOut): os.makedirs(trackOut) # Create output file trackOut = os.path.join(trackOut, "track_" + str(tId) + ".csv") trackFile = open(trackOut, 'w') # Write Header header = 'Name, ID, Frame, ' for feature in track.toArray()[0].getFeatures().keySet(): if feature == 'Frame': continue header += feature + ", " header = header[0:len(header) - 2] header += '\n' trackFile.write(header) # Write spot data avgTotalIntensity = 0 for spot in track: #print spot.echo() data = [ spot.getName(), str(spot.ID()), str(spot.getFeature('FRAME')) ] for feature in spot.getFeatures(): if feature == 'Frame': continue elif feature == 'TOTAL_INTENSITY': avgTotalIntensity += spot.getFeature(feature) data.append(str(spot.getFeature(feature))) trackFile.write(','.join(data) + '\n') trackFile.close() avgTotalIntensity /= len(track) # Write out track stats # Make sure dir exists trackOut = os.path.join(wellPath, chanName + "_tracks") if not os.path.exists(trackOut): os.makedirs(trackOut) # Create output file trackOut = os.path.join(trackOut, "track_" + str(tId) + ".csv") trackFile = open(trackOut, 'w') # Fetch the track feature from the feature model. header = '' for featName in fm.getTrackFeatureNames(): header += featName + ", " header = header[0:len(header) - 2] header += '\n' trackFile.write(header) features = '' for featName in fm.getTrackFeatureNames(): features += str(fm.getTrackFeature(tId, featName)) + ', ' features = features[0:len(features) - 2] features += '\n' trackFile.write(features) trackFile.write('\n') trackFile.close() trackDat[tId] = [ str(tId), str(fm.getTrackFeature(tId, 'TRACK_DURATION')), str(avgTotalIntensity), str(fm.getTrackFeature(tId, 'TRACK_START')), str(fm.getTrackFeature(tId, 'TRACK_STOP')) ] # Create output file trackOut = os.path.join(wellPath, chanName + "_trackSummary.csv") trackFile = open(trackOut, 'w') # Fetch the track feature from the feature model. trackFile.write( 'Track Id, Duration, Avg Total Intensity, Start Frame, Stop Frame \n' ) for track in trackDat: trackFile.write(','.join(trackDat[track]) + '\n') trackFile.close() trackOut = os.path.join(wellPath, chanName + "_trackModel.xml") trackFile = File(trackOut) writer = TmXmlWriter(trackFile, model.getLogger()) #writer.appendLog( logPanel.getTextContent() ); writer.appendModel(trackmate.getModel()) writer.appendSettings(trackmate.getSettings()) #writer.appendGUIState( controller.getGuimodel() ); writer.writeToFile() model.clearSpots(True) model.clearTracks(True) return trackDat
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()) settings.addTrackAnalyzer(TrackBranchingAnalyzer()) 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)])