def getSpots(imp, channel, detector_type, radius, threshold, overlay, roi_type="large", roi_color=ColorRGB("blue")): """ Performs the detection, adding spots to the image overlay :imp: The image (ImagePlus) being analyzed :channel: The target channel :detector_type: A string describing the detector: "LoG" or "DoG" :radius: Spot radius (NB: trackmate GUI accepts diameter) :threshold: Quality cutoff value :overlay: The image overlay to store spot (MultiPoint) ROIs :roi_type: A string describing how spot ROIs should be displayed :returns: The n. of detected spots """ settings = Settings() settings.setFrom(imp) settings.detectorFactory = (LogDetectorFactory() if "LoG" in detector_type else DogDetectorFactory()) settings.detectorSettings = { DK.KEY_DO_SUBPIXEL_LOCALIZATION: False, DK.KEY_DO_MEDIAN_FILTERING: True, DK.KEY_TARGET_CHANNEL: channel, DK.KEY_RADIUS: radius, DK.KEY_THRESHOLD: threshold, } trackmate = TrackMate(settings) if not trackmate.execDetection(): lservice.error(str(trackmate.getErrorMessage())) return 0 model = trackmate.model spots = model.getSpots() count = spots.getNSpots(False) ch_id = "Spots Ch%d" % channel if count > 0: roi = None cal = imp.getCalibration() t_pos = imp.getT() if (t_pos > 1): lservice.warn("Only frame %d was considered..." % t_pos) for spot in spots.iterable(False): x = cal.getRawX(spot.getFeature(spot.POSITION_X)) y = cal.getRawY(spot.getFeature(spot.POSITION_Y)) z = spot.getFeature(spot.POSITION_Z) if z == 0 or not cal.pixelDepth or cal.pixelDepth == 0: z = 1 else: z = int(z // cal.pixelDepth) imp.setPosition(channel, z, t_pos) if roi is None: roi = PointRoi(int(x), int(y), imp) else: roi.addPoint(imp, x, y) roi.setStrokeColor(colorRGBtoColor(roi_color)) if "large" in roi_type: roi.setPointType(3) roi.setSize(4) else: roi.setPointType(2) roi.setSize(1) overlay.add(roi, ch_id) return count
#------------------------- # 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())) # Configure detector settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { DetectorKeys.KEY_DO_SUBPIXEL_LOCALIZATION : True, DetectorKeys.KEY_RADIUS : .30, DetectorKeys.KEY_TARGET_CHANNEL : 1, DetectorKeys.KEY_THRESHOLD : 50., DetectorKeys.KEY_DO_MEDIAN_FILTERING : False,
import fiji.plugin.trackmate.detection.LogDetectorFactory import fiji.plugin.trackmate.tracking.LAPUtils import fiji.plugin.trackmate.tracking.sparselap.SparseLAPTrackerFactory import fiji.plugin.trackmate.action.ExportTracksToXML # Swap Z and T dimensions if T=1 dims = imp.getDimensions() # default order: XYCZT if (dims[4] == 1) { imp.setDimensions( dims[2,4,3] ) } # Setup settings for TrackMate settings = new Settings() settings.setFrom(imp) settings.dt = 0.05 settings.detectorFactory = new LogDetectorFactory() settings.detectorSettings = settings.detectorFactory.getDefaultSettings() println settings.detectorSettings settings.detectorSettings['RADIUS'] = radius settings.detectorSettings['THRESHOLD'] = threshold println settings.detectorSettings settings.trackerFactory = new SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
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")))
#---------------------------- # 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': True, 'RADIUS': 2.5, 'TARGET_CHANNEL': 1, 'THRESHOLD': 0., 'DO_MEDIAN_FILTERING': False, } # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 1, True) settings.addSpotFilter(filter1)
print 'track', 'load' imp = ij.IJ.openImage(path + gg.replace('original', 'filter')) # open Golgi image imp.show() lx, ly, lc, lz, lt = imp.getDimensions() # get image dimensions lz, lt = min(lz, lt), max(lz, lt) ij.IJ.run( 'Properties...', 'channels=1 slices=' + str(lz) + ' frames=' + str(lt) + ' unit=pixel pixel_width=1.0000 pixel_height=1.0000 voxel_depth=' + str(depth) ) # set number of z-slices and frames and spacing between z-slices print 'track', 'setup' model = Model() # set tracking model factories settings = Settings() settings.setFrom(imp) settings.detectorFactory = DogDetectorFactory() 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))
imp.show() #---------------------------- # Create the model object 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 = DownsampleLogDetectorFactory() settings.detectorSettings = { DetectorKeys.KEY_RADIUS: 5., DetectorKeys.KEY_DOWNSAMPLE_FACTOR: 4, DetectorKeys.KEY_THRESHOLD : 1., } print(settings.detectorSettings) # Config initial spot filters value settings.initialSpotFilterValue = 3.5 # Configure spot filters - Classical filter on quality
#------------------------- # Instantiate model object #------------------------- model = Model() # Set logger model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Configure detector settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = { DetectorKeys.KEY_DO_SUBPIXEL_LOCALIZATION : True, DetectorKeys.KEY_RADIUS : 2.5, DetectorKeys.KEY_TARGET_CHANNEL : 1, DetectorKeys.KEY_THRESHOLD : 5., DetectorKeys.KEY_DO_MEDIAN_FILTERING : False, } # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
# ---------------------------- # 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': True, 'RADIUS': 2.5, 'TARGET_CHANNEL': 1, 'THRESHOLD': 0., 'DO_MEDIAN_FILTERING': False, } # Configure spot filters - Classical filter on quality # filter1 = FeatureFilter('QUALITY', 30, True) # settings.addSpotFilter(filter1)
def run_process(input_path, output_path): IJ.run("Image Sequence...", "open=[" + input_path + "] convert sort") imp = WindowManager.getCurrentImage() dims = imp.getDimensions() imp.setDimensions(dims[2], dims[4], dims[3]) dims = imp.getDimensions() ImageConverter(imp).convertToGray8() model = Model() model.setLogger(Logger.IJ_LOGGER) settings = Settings() settings.setFrom(imp) settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': float(11.0), 'THRESHOLD': float(0.0), 'DO_MEDIAN_FILTERING': True } # Configure spot filters - Classical filter on quality # filter1 = FeatureFilter('QUALITY', 30, True) # settings.addSpotFilter(filter1) settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap( ) #this sets tens of madatory settings settings.trackerSettings['LINKING_MAX_DISTANCE'] = 15.0 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 15.0 settings.trackerSettings['MAX_FRAME_GAP'] = 2 # print(LAPUtils.getDefaultLAPSettingsMap()) # # settings.trackerFactory = SimpleLAPTrackerFactory() ## settings.trackerSettings = LAPUtils.SimpleLAPTrackerFactory() #this sets tens of madatory settings # settings.trackerSettings['LINKING_MAX_DISTANCE'] = 15.0 # settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE']=15.0 # settings.trackerSettings['MAX_FRAME_GAP']= 2 # settings.trackerSettings['ALLOW_GAP_CLOSING']= True # settings.trackerSettings['ALLOW_TRACK_SPLITTING']= False # settings.trackerSettings['ALLOW_TRACK_MERGING']= False # settings.trackerSettings['SPLITTING_MAX_DISTANCE']= 1000.0 # settings.trackerSettings['MERGING_MAX_DISTANCE']= 1000.0 # settings.trackerSettings['ALTERNATIVE_LINKING_COST_FACTOR']= 1000.0 # # ? # settings.trackerSettings['CUTOFF_PERCENTILE']= 1000.0 # settings.trackerSettings['BLOCKING_VALUE']= 1000.0 # # filter2 = FeatureFilter('NUMBER_OF_SPOTS_IN_TRACK', 6.86, True) # settings.addTrackFilter(filter2) trackmate = TrackMate(model, settings) ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) raise Exception("trackmate: checkInput failed") # if ok: # print("Input ok") ok = trackmate.process() if not ok: raise Exception("trackmate: process failed") # if ok: # print("Process ok") #---------------- # Display results #---------------- model.getLogger().log('Found ' + str(model.getTrackModel().nTracks(True)) + ' tracks.') selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) # displayer.render() # The feature model, that stores edge and track features. fm = model.getFeatureModel() # print(fm) labels_row = [ 'id', 'spot_id', 'x', 'y', 'frame', 'quality', 'type', 'length' ] #'qualitiy','visability', 'track_length'] #rows = [] track_ids = model.getTrackModel().trackIDs(True) with open(output_path, 'w') as file: writer = csv.writer(file) writer.writerow(labels_row) for id in track_ids: # Fetch the track feature from the feature model. # model.getLogger().log('') # model.getLogger().log('Track ' + str(id) + ': mean velocity = ' + str(v) + ' ' + model.getSpaceUnits() + '/' + model.getTimeUnits()) track = model.getTrackModel().trackSpots(id) num_spots = track.size() for spot in track: # print(spot.getFeatures()) row = [] row.append(id) sid = spot.ID() row.append(sid) # Fetch spot features directly from spot. x = spot.getFeature('POSITION_X') row.append(x) y = spot.getFeature('POSITION_Y') row.append(y) t = spot.getFeature('FRAME') row.append(int(t)) # print("x: {} y: {} t: {}".format(x, y, t)) q = spot.getFeature('QUALITY') row.append(q) # snr=spot.getFeature('SNR') # row.append(snr) # mean=spot.getFeature('MEAN_INTENSITY') # row.append(mean) # visibility=spot.getFeature('VISIBILITY') # print(visibility) # break # row.append(visability) # model.getLogger().log('\tspot ID = ' + str(sid) + ': x='+str(x)+', y='+str(y)+', t='+str(t)+', q='+str(q) + ', snr='+str(snr) + ', mean = ' + str(mean)) row.append(1) row.append(num_spots) writer.writerow(row) # rows.append(row) file.close() return IJ
def detection(imp, c): cal = imp.getCalibration() model = Model() settings = Settings() settings.setFrom(imp) # Configure detector - Manually determined as best settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 2.0, 'TARGET_CHANNEL': c, 'THRESHOLD': 20.0, 'DO_MEDIAN_FILTERING': False, } settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() trackmate = TrackMate(model, settings) ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) try: ok = trackmate.process() except: IJ.log("Nothing detected") IJ.selectWindow('test') IJ.run('Close') else: selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() # Get spots information spots = model.getSpots() spotIt = spots.iterator(0, False) # Loop through spots and save into files # Fetch spot features directly from spot sid = [] x = [] y = [] q = [] r = [] spotID = 0 for spot in spotIt: spotID = spotID + 1 sid.append(spotID) x.append(spot.getFeature('POSITION_X')) y.append(spot.getFeature('POSITION_Y')) q.append(spot.getFeature('QUALITY')) r.append(spot.getFeature('RADIUS')) data = zip(sid, x, y, q, r) return data
def nucleus_detection(infile, nucleus_channel, stacksize, animation): # Detect nucleus with 3d log filters fullpath = infile infile = filename(infile) IJ.log("Start Segmentation " + str(infile)) # First get Nb Stacks reader = ImageReader() omeMeta = MetadataTools.createOMEXMLMetadata() reader.setMetadataStore(omeMeta) reader.setId(fullpath) default_options = "stack_order=XYCZT color_mode=Composite view=Hyperstack specify_range c_begin=" + \ str(nucleus_channel) + " c_end=" + str(nucleus_channel) + \ " c_step=1 open=[" + fullpath + "]" NbStack = reader.getSizeZ() reader.close() output = re.sub('.ids', '.csv', infile) with open(os.path.join(folder5, output), 'wb') as outfile: DETECTwriter = csv.writer(outfile, delimiter=',') DETECTwriter.writerow( ['spotID', 'roundID', 'X', 'Y', 'Z', 'QUALITY', 'SNR', 'INTENSITY']) rounds = NbStack // stacksize spotID = 1 for roundid in xrange(1, rounds + 2): # Process stacksize by stacksize otherwise crash because too many spots Zstart = (stacksize * roundid - stacksize + 1) Zend = (stacksize * roundid) if(Zend > NbStack): Zend = NbStack % stacksize + (roundid - 1) * stacksize IJ.log("Round:" + str(roundid) + ' Zstart=' + str(Zstart) + ' Zend=' + str(Zend) + ' out of ' + str(NbStack)) IJ.run("Bio-Formats Importer", default_options + " z_begin=" + str(Zstart) + " z_end=" + str(Zend) + " z_step=1") imp = IJ.getImage() imp.show() cal = imp.getCalibration() model = Model() settings = Settings() settings.setFrom(imp) # Configure detector - Manually determined as best settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 5.5, 'TARGET_CHANNEL': 1, 'THRESHOLD': 50.0, 'DO_MEDIAN_FILTERING': False, } filter1 = FeatureFilter('QUALITY', 1, True) settings.addSpotFilter(filter1) settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() trackmate = TrackMate(model, settings) ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) try: ok = trackmate.process() except: IJ.log("Nothing detected, Round:" + str(roundid) + ' Zstart=' + str(Zstart) + ' Zend=' + str(Zend) + ' out of ' + str(NbStack)) IJ.selectWindow(infile) IJ.run('Close') continue else: if animation: # For plotting purpose only imp.setPosition(1, 1, imp.getNFrames()) imp.getProcessor().setMinAndMax(0, 4000) selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() for i in xrange(1, imp.getNSlices() + 1): imp.setSlice(i) time.sleep(0.05) IJ.selectWindow(infile) IJ.run('Close') spots = model.getSpots() spotIt = spots.iterator(0, False) sid = [] sroundid = [] x = [] y = [] z = [] q = [] snr = [] intensity = [] for spot in spotIt: sid.append(spotID) spotID = spotID + 1 sroundid.append(roundid) x.append(spot.getFeature('POSITION_X')) y.append(spot.getFeature('POSITION_Y')) q.append(spot.getFeature('QUALITY')) snr.append(spot.getFeature('SNR')) intensity.append(spot.getFeature('MEAN_INTENSITY')) # Correct Z position correct_z = spot.getFeature( 'POSITION_Z') + (roundid - 1) * float(stacksize) * cal.pixelDepth z.append(correct_z) with open(os.path.join(folder5, output), 'ab') as outfile: DETECTwriter = csv.writer(outfile, delimiter=',') Sdata = zip(sid, sroundid, x, y, z, q, snr, intensity) for Srow in Sdata: DETECTwriter.writerow(Srow)
def analyze(tempFile): # Get currently selected image #imp = WindowManager.getCurrentImage() imp = IJ.openImage(tempFile) imp.show() dims = imp.getDimensions(); imp.setDimensions(dims[2], dims[4], dims[3]); #---------------------------- # 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) print(settings.imageFileName) # Configure detector - We use the Strings for the keys settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION' : False, 'RADIUS' : 20., 'TARGET_CHANNEL' : 1, 'THRESHOLD' : 0.95, 'DO_MEDIAN_FILTERING' : True, } # Configure spot filters - Classical filter on quality #filter1 = FeatureFilter('QUALITY', 0.5, True) #settings.addSpotFilter(filter1) # Configure tracker - We want to allow merges and fusions settings.trackerFactory = SimpleSparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() #probably good enough #settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = False #settings.trackerSettings['ALLOW_TRACK_MERGING'] = False settings.trackerSettings['LINKING_MAX_DISTANCE'] = 35.0 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE']= 60.0 settings.trackerSettings['MAX_FRAME_GAP']= 2 # 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()) #------------------- # Instantiate plugin #------------------- trackmate = TrackMate(model, settings) ok = trackmate.process() if not ok: sys.exit(str(trackmate.getErrorMessage())) #---------------- # Display results #---------------- 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)) print(str(settings)) filename = os.path.splitext(settings.imageFileName) pathname = settings.imageFolder + "" + filename[0] + "tracks.xml" guicontroller = TrackMateGUIController(trackmate) newFile = File(pathname) ExportTracksToXML(guicontroller).export(model, settings, newFile) actionObject = CaptureOverlayAction() actionObject.execute(trackmate) imp = WindowManager.getCurrentImage() fileSaver = FileSaver(imp) fileSaver.saveAsTiffStack(settings.imageFolder + "" + filename[0] + "overlay.tif") WindowManager.closeAllWindows() guicontroller.quit() selectionModel.clearSelection(); model.clearTracks(1)
#---------------------------- # 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 = DogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 0.6, 'TARGET_CHANNEL': 1, 'THRESHOLD': 50.0, 'DO_MEDIAN_FILTERING': False, } # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 50, True) settings.addSpotFilter(filter1)
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
logger.log(str(id) + ' - ' + str(model.getTrackModel().trackEdges(id))) #--------------------------------------- # 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) logger.log(str('\n\nSETTINGS:')) logger.log(str(settings))
# We just need a model for this script. Nothing else, since # we will do everything manually. model = Model() model.setLogger(Logger.IJ_LOGGER) # Well actually, we still need a bit: # We want to color-code the tracks by their feature, for instance # with the track index. But for this, we need to compute the # features themselves. # # Manuall, this is done by declaring what features interest you # in a settings object, and creating a ModelFeatureUpdater that # will listen to changes in the model, and compute the feautures # on the fly. settings = Settings() settings.addTrackAnalyzer( TrackIndexAnalyzer() ) # If you want more, add more analyzers. # The object in charge of keeping the numerical features # up to date: ModelFeatureUpdater( model, settings ) # Nothing more to do. When the model changes, this guy will be notified and # recalculate all the features you declared in the settings object. # Every manual edit to the model must be made # between a model.beginUpdate() and a model.endUpdate() # call, otherwise you will mess with the event signalling # and feature calculation.
#---------------------------- # 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) settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) # Configure detector - We use the Strings for the keys settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': DO_SUBPIXEL_LOCALIZATION, 'RADIUS': RADIUS, 'TARGET_CHANNEL': TARGET_CHANNEL, 'THRESHOLD': THRESHOLD, 'DO_MEDIAN_FILTERING': DO_MEDIAN_FILTERING, } # Configure spot filters on contrast
def trackmate(self): calibration = self.imp.getCalibration() model = Model() model.setLogger(Logger.IJ_LOGGER) settings = Settings() settings.setFrom(self.imp) # Configure detector - We use the Strings for the keys settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': calibration.getX(self.trackmateSize), 'TARGET_CHANNEL': 1, 'THRESHOLD': self.trackmateThreashold, 'DO_MEDIAN_FILTERING': True, } # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 0.01, True) settings.addSpotFilter(filter1) settings.addSpotAnalyzerFactory(SpotIntensityMultiCAnalyzerFactory()) settings.initialSpotFilterValue = 1 # Configure tracker - We want to allow merges and fusions settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() trackmate = TrackMate(model, settings) #-------- # Process #-------- ok = trackmate.checkInput() if not ok: print("NOT OK") ok = trackmate.process() if not ok: print("NOT OK") #---------------- # Display results #---------------- #selectionModel = SelectionModel(model) #displayer = HyperStackDisplayer(model, selectionModel, self.imp) #displayer.render() #displayer.refresh() # Echo results with the logger we set at start: spots = model.getSpots() return spots.iterable(True)
# 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' : True, 'RADIUS' : 2.5, 'TARGET_CHANNEL' : 1, 'THRESHOLD' : 0., 'DO_MEDIAN_FILTERING' : False, } # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 1, True) settings.addSpotFilter(filter1)
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()
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
#---------------------------- # 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 settings.detectorFactory = LogDetectorFactory(); settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION' : Subpixel_localization, 'RADIUS' : Spot_radius, 'TARGET_CHANNEL' : 1,
import fiji.plugin.trackmate.extra.spotanalyzer.SpotMultiChannelIntensityAnalyzerFactory as SpotMultiChannelIntensityAnalyzerFactory import ij.IJ as IJ import java.io.File as File import java.util.ArrayList as ArrayList # Swap Z and T dimensions if T=1 dims = imp.getDimensions() # default order: XYCZT if (dims[4] == 1): imp.setDimensions(dims[2, 4, 3]) # Get the number of channels nChannels = imp.getNChannels() # Setup settings for TrackMate settings = Settings() settings.setFrom(imp) settings.dt = 0.05 # Spot analyzer: we want the multi-C intensity analyzer. settings.addSpotAnalyzerFactory(SpotMultiChannelIntensityAnalyzerFactory()) # Spot detector. settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = settings.detectorFactory.getDefaultSettings() settings.detectorSettings['RADIUS'] = radius settings.detectorSettings['THRESHOLD'] = threshold # Spot tracker. settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
# Get the number of channels. # IMPORTANT: This code assumes that the H2B channel is Channel 2 and ErkKTR is Channel 1 nChannels = imp.getNChannels() #---------------------------- # Create the model object now #---------------------------- model = Model() # Send all messages to ImageJ log window. model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Use the spot analyzer for assessing fluorescence intensities in each channel settings.addSpotAnalyzerFactory( SpotMultiChannelIntensityAnalyzerFactory()) # Configure the detector for finding nuclei settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 9., # KEY PARAMETER: expect a 9 um nucleus radius, which works very well for keratinocytes 'TARGET_CHANNEL': 2, # KEY PARAMETER: H2B for nucleus segmentation is Channel 2 'THRESHOLD': 2.,
# 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' : True, 'RADIUS' : 1.25, 'TARGET_CHANNEL' : 1, 'THRESHOLD' : int_thresh, 'DO_MEDIAN_FILTERING' : True, } settings.dx = 100.0 settings.dy = 100.0
def TrackMate_main(infile, outfile): file = File(infile) # We have to feed a logger to the reader. logger = Logger.IJ_LOGGER #------------------- # Instantiate reader #------------------- reader = TmXmlReader(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.setLogger(Logger.IJ_LOGGER) # model is a fiji.plugin.trackmate.Model #--------------------------------------- # Building a settings object from a file #--------------------------------------- # 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() reader.readSettings(settings, detectorProvider, trackerProvider, spotAnalyzerProvider, edgeAnalyzerProvider, trackAnalyzerProvider) #---------------- # Save results #---------------- # The feature model, that stores edge and track features. fm = model.getFeatureModel() f = open(outfile, 'wb') for id in model.getTrackModel().trackIDs(True): track = model.getTrackModel().trackSpots(id) for spot in track: sid = spot.ID() # Fetch spot features directly from spot. x = spot.getFeature('POSITION_X') y = spot.getFeature('POSITION_Y') t = spot.getFeature('FRAME') q = spot.getFeature('QUALITY') snr = spot.getFeature('SNR') mean = spot.getFeature('MEAN_INTENSITY') semiaxislength_c = spot.getFeature('ELLIPSOIDFIT_SEMIAXISLENGTH_C') if semiaxislength_c is None: semiaxislength_c = 0 semiaxislength_b = spot.getFeature('ELLIPSOIDFIT_SEMIAXISLENGTH_B') if semiaxislength_b is None: semiaxislength_b = 0 phi_b = spot.getFeature('ELLIPSOIDFIT_AXISPHI_B') if phi_b is None: phi_b = 0 data = Array.newInstance(Class.forName("java.lang.String"), 9) #String[] entries = "first#second#third".split("#"); data[0] = str(sid) data[1] = str(id) data[2] = str(x) data[3] = str(y) data[4] = str(t) data[5] = str(semiaxislength_c) data[6] = str(semiaxislength_b) data[7] = str(phi_b) data[8] = str(mean) # create csv writer writer = csv.writer(f) row = [ data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8] ] writer.writerow(row) f.close() print('Saved ' + str(model.getTrackModel().nTracks(True)) + ' tracks.')
#------------------------- # 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, 'RADIUS': spot_radius[i_col] * resolution, 'TARGET_CHANNEL': color, 'THRESHOLD': 0.000001, 'DO_MEDIAN_FILTERING': True, } # Configure spot filters w = imp.getWidth() h = imp.getHeight()
def run_trackmate( imp, path_out="./", detector="log", radius=2.5, threshold=0.0, median_filter=False ): """Log Trackmate detection run with given parameters. Saves spots in a csv file in the given path_out with encoded parameters. Args: imp: ImagePlus to be processed path_out: Output directory to save files. detector: Type of detection method. Options are 'log', 'dog'. radius: Radius of spots in pixels. threshold: Threshold value to filter spots. median_filter: True if median_filtering should be used. """ if imp.dimensions[2] != 1: raise ValueError( "Imp's dimensions must be [n, n, 1] but are " + imp.dimensions[2] ) # Create the model object now model = Model() model.setLogger(Logger.VOID_LOGGER) # Prepare settings object settings = Settings() settings.setFrom(imp) # Configure detector settings.detectorFactory = ( DogDetectorFactory() if detector == "dog" else LogDetectorFactory() ) settings.detectorSettings = { "DO_SUBPIXEL_LOCALIZATION": True, "RADIUS": radius, "TARGET_CHANNEL": 1, "THRESHOLD": threshold, "DO_MEDIAN_FILTERING": median_filter, } # Instantiate plugin trackmate = TrackMate(model, settings) # Process # output = trackmate.process() output = trackmate.execDetection() if not output: print("error process") return None # Get output from a single image fname = str(imp.title) spots = [["fname", "detector", "radius", "threshold", "median", "x", "y", "q"]] for spot in model.spots.iterator(0): x = spot.getFeature("POSITION_X") y = spot.getFeature("POSITION_Y") q = spot.getFeature("QUALITY") spots.append([fname, detector, radius, threshold, median_filter, x, y, q]) # Save output outname = os.path.splitext(os.path.basename(fname))[0] + "_" + str(radius) + ".csv" with open(os.path.join(path_out, outname), "wb") as f: wr = csv.writer(f) for row in spots: wr.writerow(row)
#imp.show() #------------------------- # Instantiate model object #------------------------- model = Model() # Set logger model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Configure detector settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = {{ DetectorKeys.KEY_DO_SUBPIXEL_LOCALIZATION: True, DetectorKeys.KEY_RADIUS: {radius}, DetectorKeys.KEY_TARGET_CHANNEL: 1, DetectorKeys.KEY_THRESHOLD: {threshold}, DetectorKeys.KEY_DO_MEDIAN_FILTERING: {do_median_filtering} }} # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
#---------------------------- # 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() model.getLogger().log('') model.getLogger().log('Filename' + file1 + "TEST:" + str(file1.endswith("*R3D_PRJ.dv"))) settings.setFrom(imp) # Configure detector - We use the Strings for the keys settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION' : True, 'RADIUS' : 5.0, 'TARGET_CHANNEL' : 1, 'THRESHOLD' : 20.0, 'DO_MEDIAN_FILTERING' : False, } # Configure spot filters - Classical filter on quality
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 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(): 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")
import fiji.plugin.trackmate.extra.spotanalyzer.SpotMultiChannelIntensityAnalyzerFactory as SpotMultiChannelIntensityAnalyzerFactory import ij. IJ as IJ import java.io.File as File import java.util.ArrayList as ArrayList # Swap Z and T dimensions if T=1 dims = imp.getDimensions() # default order: XYCZT if (dims[4] == 1): imp.setDimensions( dims[2,4,3] ) # Get the number of channels nChannels = imp.getNChannels() # Setup settings for TrackMate settings = Settings() settings.setFrom( imp ) settings.dt = 0.05 # Spot analyzer: we want the multi-C intensity analyzer. settings.addSpotAnalyzerFactory( SpotMultiChannelIntensityAnalyzerFactory() ) # Spot detector. settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = settings.detectorFactory.getDefaultSettings() settings.detectorSettings['RADIUS'] = radius settings.detectorSettings['THRESHOLD'] = threshold # Spot tracker. settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
def track(imp): from fiji.plugin.trackmate import Model from fiji.plugin.trackmate import Settings from fiji.plugin.trackmate import TrackMate from fiji.plugin.trackmate import SelectionModel from fiji.plugin.trackmate import Logger from fiji.plugin.trackmate.detection import LogDetectorFactory from fiji.plugin.trackmate.tracking.sparselap import SparseLAPTrackerFactory from fiji.plugin.trackmate.tracking import LAPUtils from ij import IJ import fiji.plugin.trackmate.visualization.hyperstack.HyperStackDisplayer as HyperStackDisplayer import fiji.plugin.trackmate.features.FeatureFilter as FeatureFilter import sys import fiji.plugin.trackmate.features.track.TrackDurationAnalyzer as TrackDurationAnalyzer # Get currently selected image #imp = WindowManager.getCurrentImage() #imp = IJ.openImage('http://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.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 3.0, 'TARGET_CHANNEL': 1, 'THRESHOLD': 1., 'DO_MEDIAN_FILTERING': False, } # Configure spot filters - Classical filter on quality filter1 = FeatureFilter('QUALITY', 30, 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['ALLOW_TRACK_SPLITTING'] = True 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()) #------------------- # 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 #---------------- 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)) fm = model.getFeatureModel() norm_x = [] norm_y = [] for id in model.getTrackModel().trackIDs(True): track = model.getTrackModel().trackSpots(id) for spot in track: t = spot.getFeature('FRAME') if (t == 0.0): min_x = spot.getFeature('POSITION_X') min_y = spot.getFeature('POSITION_Y') for spot in track: norm_x.append(spot.getFeature('POSITION_X') - min_x) norm_y.append(spot.getFeature('POSITION_Y') - min_y) max_x = abs(max(norm_x, key=abs)) max_y = abs(max(norm_y, key=abs)) return max_x, max_y
#6. Run trackmate #7. Get spot or track features #8. Save log as a parsable data set #1. #Opening data and determing auto quality number the_input = getArgument() the_list = the_input.rpartition(" ") image = the_list[0] imp = IJ.openImage(image) imp.show() subtraction = float(the_list[2]) model = Model() settings = Settings() settings.setFrom(imp) settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION': True, 'RADIUS': 0.350, 'TARGET_CHANNEL': 1, 'THRESHOLD': 0.0, 'DO_MEDIAN_FILTERING': True, } settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.trackerSettings['LINKING_MAX_DISTANCE'] = 1.000 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 1.000 settings.trackerSettings['MAX_FRAME_GAP'] = 3 #Running specific trackmate tasks
#imp.show() #------------------------- # Instantiate model object #------------------------- model = Model() # Set logger model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Configure detector settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = {{ DetectorKeys.KEY_DO_SUBPIXEL_LOCALIZATION: True, DetectorKeys.KEY_RADIUS: 2.5, DetectorKeys.KEY_TARGET_CHANNEL: 1, DetectorKeys.KEY_THRESHOLD: 5., DetectorKeys.KEY_DO_MEDIAN_FILTERING: False, }} # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
def runTrackMate(imp): import fiji.plugin.trackmate.Settings as Settings import fiji.plugin.trackmate.Model as Model import fiji.plugin.trackmate.SelectionModel as SelectionModel import fiji.plugin.trackmate.TrackMate as TrackMate import fiji.plugin.trackmate.Logger as Logger import fiji.plugin.trackmate.detection.DetectorKeys as DetectorKeys import fiji.plugin.trackmate.detection.DogDetectorFactory as DogDetectorFactory import fiji.plugin.trackmate.tracking.sparselap.SparseLAPTrackerFactory as SparseLAPTrackerFactory import fiji.plugin.trackmate.tracking.LAPUtils as LAPUtils import fiji.plugin.trackmate.visualization.hyperstack.HyperStackDisplayer as HyperStackDisplayer import fiji.plugin.trackmate.features.FeatureFilter as FeatureFilter import fiji.plugin.trackmate.features.FeatureAnalyzer as FeatureAnalyzer import fiji.plugin.trackmate.features.spot.SpotContrastAndSNRAnalyzerFactory as SpotContrastAndSNRAnalyzerFactory import fiji.plugin.trackmate.action.ExportStatsToIJAction as ExportStatsToIJAction import fiji.plugin.trackmate.io.TmXmlReader as TmXmlReader import fiji.plugin.trackmate.action.ExportTracksToXML as ExportTracksToXML import fiji.plugin.trackmate.io.TmXmlWriter as TmXmlWriter import fiji.plugin.trackmate.features.ModelFeatureUpdater as ModelFeatureUpdater import fiji.plugin.trackmate.features.SpotFeatureCalculator as SpotFeatureCalculator import fiji.plugin.trackmate.features.spot.SpotContrastAndSNRAnalyzer as SpotContrastAndSNRAnalyzer import fiji.plugin.trackmate.features.spot.SpotIntensityAnalyzerFactory as SpotIntensityAnalyzerFactory import fiji.plugin.trackmate.features.track.TrackSpeedStatisticsAnalyzer as TrackSpeedStatisticsAnalyzer import fiji.plugin.trackmate.util.TMUtils as TMUtils import fiji.plugin.trackmate.visualization.trackscheme.TrackScheme as TrackScheme import fiji.plugin.trackmate.visualization.PerTrackFeatureColorGenerator as PerTrackFeatureColorGenerator #------------------------- # Instantiate model object #------------------------- nFrames = imp.getNFrames() model = Model() # Set logger #model.setLogger(Logger.IJ_LOGGER) #------------------------ # Prepare settings object #------------------------ settings = Settings() settings.setFrom(imp) # Configure detector settings.detectorFactory = DogDetectorFactory() settings.detectorSettings = { DetectorKeys.KEY_DO_SUBPIXEL_LOCALIZATION: True, DetectorKeys.KEY_RADIUS: 12.30, DetectorKeys.KEY_TARGET_CHANNEL: 1, DetectorKeys.KEY_THRESHOLD: 100., DetectorKeys.KEY_DO_MEDIAN_FILTERING: False, } # Configure tracker settings.trackerFactory = SparseLAPTrackerFactory() settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap() settings.trackerSettings['LINKING_MAX_DISTANCE'] = 10.0 settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 10.0 settings.trackerSettings['MAX_FRAME_GAP'] = 3 # Add the analyzers for some spot features. # You need to configure TrackMate with analyzers that will generate # the data you need. # Here we just add two analyzers for spot, one that computes generic # pixel intensity statistics (mean, max, etc...) and one that computes # an estimate of each spot's SNR. # The trick here is that the second one requires the first one to be in # place. Be aware of this kind of gotchas, and read the docs. settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory()) settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory()) # Add an analyzer for some track features, such as the track mean speed. settings.addTrackAnalyzer(TrackSpeedStatisticsAnalyzer()) settings.initialSpotFilterValue = 1 print(str(settings)) #---------------------- # Instantiate trackmate #---------------------- trackmate = TrackMate(model, settings) #------------ # Execute all #------------ ok = trackmate.checkInput() if not ok: sys.exit(str(trackmate.getErrorMessage())) ok = trackmate.process() if not ok: sys.exit(str(trackmate.getErrorMessage())) #---------------- # Display results #---------------- selectionModel = SelectionModel(model) displayer = HyperStackDisplayer(model, selectionModel, imp) displayer.render() displayer.refresh() #--------------------- # Select correct spots #--------------------- # Prepare display. sm = SelectionModel(model) color = PerTrackFeatureColorGenerator(model, 'TRACK_INDEX') # launch TrackScheme to select spots and tracks trackscheme = TrackScheme(model, sm) trackscheme.setDisplaySettings('TrackColoring', color) trackscheme.render() # Update image with TrackScheme commands view = HyperStackDisplayer(model, sm, imp) view.setDisplaySettings('TrackColoring', color) view.render() # Wait for the user to select correct spots and tracks before collecting data dialog = WaitForUserDialog( "Spots", "Delete incorrect spots and edit tracks if necessary. (Press ESC to cancel analysis)" ) dialog.show() if dialog.escPressed(): IJ.run("Remove Overlay", "") imp.close() return ([], nFrames) # The feature model, that stores edge and track features. #model.getLogger().log('Found ' + str(model.getTrackModel().nTracks(True)) + ' tracks.') fm = model.getFeatureModel() crds_perSpot = [] for id in model.getTrackModel().trackIDs(True): # Fetch the track feature from the feature model.(remove """ to enable) """v = fm.getTrackFeature(id, 'TRACK_MEAN_SPEED') model.getLogger().log('') model.getLogger().log('Track ' + str(id) + ': mean velocity = ' + str(v) + ' ' + model.getSpaceUnits() + '/' + model.getTimeUnits())""" trackID = str(id) track = model.getTrackModel().trackSpots(id) spot_track = {} for spot in track: sid = spot.ID() # Fetch spot features directly from spot. x = spot.getFeature('POSITION_X') y = spot.getFeature('POSITION_Y') t = spot.getFeature('FRAME') q = spot.getFeature('QUALITY') snr = spot.getFeature('SNR') mean = spot.getFeature('MEAN_INTENSITY') #model.getLogger().log('\tspot ID = ' + str(sid) + ', x='+str(x)+', y='+str(y)+', t='+str(t)+', q='+str(q) + ', snr='+str(snr) + ', mean = ' + str(mean)) spot_track[t] = (x, y) crds_perSpot.append(spot_track) #print ("Spot", crds_perSpot.index(spot_track),"has the following coordinates:", crds_perSpot[crds_perSpot.index(spot_track)]) return (crds_perSpot, nFrames)
#---------------------------- # 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) #Take the rest of the settings from a xml file. file = File( "D:\\uni\\TFG\\TrackingImageJInfo\\ScriptingWithPy\\TrackFilterAfter.xml") # We have to feed a logger to the reader. logger = Logger.IJ_LOGGER #------------------- # Instantiate reader #------------------- reader = TmXmlReader(file) if not reader.isReadingOk():
from fiji.plugin.trackmate import Logger from fiji.plugin.trackmate.detection import LogDetectorFactory import fiji.plugin.trackmate.visualization.hyperstack.HyperStackDisplayer as HyperStackDisplayer import fiji.plugin.trackmate.features.FeatureFilter as FeatureFilter from ij import WindowManager import sys imp = WindowManager.getCurrentImage() imp.show() model = Model() model.setLogger(Logger.IJ_LOGGER) settings = Settings() settings.setFrom(imp) settings.detectorFactory = LogDetectorFactory() settings.detectorSettings = { 'DO_SUBPIXEL_LOCALIZATION' : True, 'RADIUS' : 0.22, 'TARGET_CHANNEL' : 2, 'THRESHOLD' : 0., 'DO_MEDIAN_FILTERING' : False, } filter1 = FeatureFilter('QUALITY', 1, True) settings.addSpotFilter(filter1) trackmate = TrackMate(model, settings)