def main(tableName, showPlot): image = IJ.getImage(); roi = image.getRoi() if not roi: center = image.getWidth() / 2, image.getHeight() / 2 else: center = roi.getXBase(), roi.getYBase(); table = ResultsTable.getResultsTable(tableName) vectors = getVectorsFromTable(table, center) radialVelocity = calculateRadialVelocityPerTime(vectors, center) radialVelocityAndDistanceByTrack(table, center) stats = Tools.getStatistics(radialVelocity) median = calculateMedian(radialVelocity) rt = ResultsTable.getResultsTable(TABLE_NAME) if not rt: rt = ResultsTable() row = rt.getCounter() rt.setValue("label", row, tableName) rt.setValue("x", row, center[0]) rt.setValue("y", row, center[1]) rt.setValue("mean", row, stats.mean) rt.setValue("stdDev", row, stats.stdDev) rt.setValue("min", row, stats.min) rt.setValue("median", row, median) rt.setValue("max", row, stats.max) rt.show(TABLE_NAME) if showPlot: plot(radialVelocity, center)
def geometrical_measure_3D(imp_label): # remove results table if exists: close_non_image_window("Results") # measure #imp_label.show() rt = ResultsTable.getResultsTable() IJ.run(imp_label, "3D Geometrical Measure", ""); rt = ResultsTable.getResultsTable() return rt
def measure_roi_set(roi_set, imp, set_measure=MEAS_ALL) : """requires imp because it won't measure without one note.. side effects: ResultsTable and RoiManager cleared""" # imp.show() rt = ResultsTable.getResultsTable() rt.reset() rm = RoiManager.getRoiManager() rm.reset() if roi_set is not None : for roi in roi_set : add_roi(roi) rm.setSelectedIndexes([x for x in range(rm.getCount())]) setMeasurementInt(set_measure) print("before rm measure") # IJ.setActiveImage(imp) # IJ.selectWindow(imp.getTitle()) # imp.show() try : # input() # for roi in roi_set : # imp. rm.runCommand(imp, "Measure") except : input() print("after rm measure") results = rt_to_col_dict() # imp.hide() return results
def measure_growth(imgDir, filename = "Fiji_Growth.txt"): """ Collects measurement data in pixels and writes to a file. Uses straightened binary images""" f = open(imgDir + filename, 'w') f.write("Img number\tEnd point (pixels)\n") IJ.run("Set Measurements...", "area mean min center redirect=None decimal=3") index = "000000000" filename = imgDir + "/binary" + "/img_" + index + "__000-padded.tif" while path.exists(filename): imp = IJ.openImage(filename) imp.show() IJ.run("Clear Results") for i in xrange(800): #hard coded to target length for now IJ.makeRectangle(i, 0, 1, 80) IJ.run("Measure") table = RT.getResultsTable() #print "i:", i, "counter:", table.getCounter() maxi = RT.getValue(table, "Max", i) if maxi == 0: f.write(str(int(index)) + "\t" + str(i) + "\n") break IJ.runMacro("while (nImages>0) {selectImage(nImages);close();}") index = to_9_Digits(str(int(index)+1)) filename = imgDir + "/padded" + "/img_" + index + "__000-padded.tif" f.close()
def roiAnalysisToWrite(self, roiTableName): #I can't figure out the syntax to preallocate memory, #this will not scale to many speckles try: RT = ResultsTable.getResultsTable(roiTableName) headings = RT.getHeadings() labelCol = RT.getColumnAsVariables(headings[0]) headers = headings[1:] numCols = len(headers) numRows = len(labelCol) out = [] for col in range(numCols): out.append([]) column = RT.getColumnAsVariables(headers[col]) for row in range(numRows): out[col].append(column[row].getValue()) outT = [] for i in range(numRows): lis = [] lis.append(labelCol[i].getString()) for j in range(numCols): lis.append(out[j][i]) outT.append(lis) return outT except: print("failed roi read") return []
def __NbFoci(self): self.__boolFoci=True self.__image.killRoi() self.__image.setRoi(self.__contour) self.__ip=self.__image.getProcessor() rt=ResultsTable.getResultsTable() rt.reset() mf=MaximumFinder() mf.findMaxima(self.__ip, self.__noise, 0, MaximumFinder.LIST, True, False) self.__listMax[:]=[] #feret=self.getFercoord() #xc=feret[0]-((feret[0]-feret[2])/2.0) #yc=feret[1]-((feret[1]-feret[3])/2.0) #print xc, yc xc=self.getXC() yc=self.getYC() #print xc, yc for i in range(rt.getCounter()): x=int(rt.getValue("X", i)) y=int(rt.getValue("Y", i)) size=self.__localwand(x, y, self.__ip, self.__seuilPeaks, self.__peaksMethod, self.__light) coord=[(1, xc, x), (1, yc, y)] d=self.distMorph(coord,"Euclidean distance") d=( d / (self.getMaxF()/2) )*100 self.__listMax.append((x, y, size[0], size[1], size[2], size[3], size[4], d)) rt.reset()
def make_nucs(hseg): """given an hseg, assumed to have a nuc_bin_imp, creates the nuc""" rm = RoiManager.getRoiManager() rm.reset() if UPDATE1: IJ.run(hseg.nuc_bin_imp, "Invert", "") rt = ResultsTable.getResultsTable() rt.reset() IJ.run(hseg.nuc_bin_imp, "Analyze Particles...", "add") rois = rm.getRoisAsArray() problem_nucs = [] for roi in rois: nuc_cent = roi_cent(roi, integer=True) found_cell = False for cell in hseg.cells.values(): if cell.roi.contains(*nuc_cent): cell.add_nuc(roi) found_cell = True break if not found_cell: IJ.log('Nuc not in any cell for hemisegment {}'.format(hseg.name)) problem_nucs.append(roi) return problem_nucs
def delete(imp, roiMan, roiTotal): # set results table rt = ResultsTable.getResultsTable() # set up analyzer analyzer = Analyzer(imp, 1, rt) totalPixels = 0 # Set the color and line options for erasing IJ.run("Colors...", "foreground=black background=black selection=magenta") if roiMan is not None: # Iterate through the ROIs for roi in xrange(roiTotal): # Select the ROI roiMan.select(roi) selectRoi = roiMan.getRoi(roi) # measure analyzer.measure() meas = rt.getRowAsString(0) newLine = meas.split(" ", 1) pixels = float(newLine[1]) totalPixels = totalPixels + pixels # Tag the ROI IJ.run(imp, "Fill", "slice") # end for loop return totalPixels else: return 0
def relabel(): import re from ij.measure import ResultsTable rt = ResultsTable.getResultsTable() nResults = rt.size() for result in range(nResults): oldLabel = rt.getLabel(result) delimiters = [] keywords = ["series"] for keyword in keywords: if keyword in oldLabel: delimiters.append(oldLabel.index(keyword)) channel = oldLabel[0:2] try: series = "FOV" + oldLabel[(delimiters[0] + 7):(delimiters[0] + 9)] except IndexError: series = "FOV?" foundColons = [m.start() for m in re.finditer(':', oldLabel)] cell = oldLabel[foundColons[0] + 1:foundColons[1]] newLabel = channel + "_" + series + "_" + cell rt.setLabel(newLabel, result) rt.show("Results")
def containsRoot_(self): IJ.run("Clear Results") IJ.run("Measure") table = RT.getResultsTable() if RT.getValue(table, "Max", 0) == 0: return False return True
def create_nucs(self) : """ """ for cell in self.cells() : cell._nucs = [] rm = RoiManager.getRoiManager() rm.reset() IJ.run(self.nuc_bin(), "Invert", "") rt = ResultsTable.getResultsTable() rt.reset() IJ.run(self.nuc_bin(), "Analyze Particles...", "add") rois = rm.getRoisAsArray() IJ.run(self.nuc_bin(),"Remove Overlay", ""); problem_nucs = [] for roi in rois : nuc_cent = futils.roi_cent(roi, integer=True) found_cell = False for cell in self.cells() : if cell.roi().contains(*nuc_cent) : cell.add_nuc(roi) found_cell = True break if not found_cell : self.exper.log('Nuc not in any cell for hemisegment {}'.format(self.name)) problem_nucs.append(roi) return problem_nucs
def run_straighten(roiWindowsize=4): """ Original straightening function based on Nick's macro. Used in final version. Returns coordinate string used to make centerline. """ IJ.run("Set Measurements...", "mean min center redirect=None decimal=3") IJ.runMacro("//setTool(\"freeline\");") IJ.run("Line Width...", "line=80") numPoints = 512 / roiWindowsize xvals = [] yvals = [] maxvals = [] counter = 0 for i in range(0, 512, roiWindowsize): IJ.run("Clear Results") IJ.makeRectangle(i, 0, roiWindowsize, 512) IJ.run("Measure") table = RT.getResultsTable() xvals.append(i + roiWindowsize / 2) yvals.append(RT.getValue(table, "YM", 0)) maxvals.append((RT.getValue(table, "Max", 0))) if maxvals[counter] == 0 and counter > 0: yvals[counter] = yvals[counter - 1] counter += 1 coords = "" for i in range(numPoints - 1): coords += str(xvals[i]) + ", " + str(yvals[i]) + ", " coords += str(xvals[numPoints - 1]) + ", " + str(yvals[numPoints - 1]) IJ.runMacro("makeLine(" + coords + ")") IJ.run("Straighten...", "line = 80") return coords
def measure_growth(imgDir, filename="Fiji_Growth.txt"): """ Collects measurement data in pixels and writes to a file. Uses straightened binary images""" f = open(imgDir + filename, 'w') f.write("Img number\tEnd point (pixels)\n") IJ.run("Set Measurements...", "area mean min center redirect=None decimal=3") index = "000000000" filename = imgDir + "/binary" + "/img_" + index + "__000-padded.tif" while path.exists(filename): imp = IJ.openImage(filename) imp.show() IJ.run("Clear Results") for i in xrange(800): #hard coded to target length for now IJ.makeRectangle(i, 0, 1, 80) IJ.run("Measure") table = RT.getResultsTable() #print "i:", i, "counter:", table.getCounter() maxi = RT.getValue(table, "Max", i) if maxi == 0: f.write(str(int(index)) + "\t" + str(i) + "\n") break IJ.runMacro("while (nImages>0) {selectImage(nImages);close();}") index = to_9_Digits(str(int(index) + 1)) filename = imgDir + "/padded" + "/img_" + index + "__000-padded.tif" f.close()
def getColumnIndex(column): rt = ResultsTable.getResultsTable() headings = rt.getHeadings() for i, heading in enumerate(headings, start=1): if heading == column: return i return None
def nuclei_processor(imp_particles, thresh_type, folder, impname, channel_name): rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.reset() # define a results table rt = ResultsTable.getResultsTable() imp_particles.show() # generate thresholded image for ROI nuclei = imp_particles.duplicate() nuclei.show() IJ.run("Gaussian Blur...", "sigma=3") IJ.setAutoThreshold(nuclei, thresh_type) IJ.run("Convert to Mask") IJ.run("Fill Holes") # IJ.run("Watershed") # select thresholded image (to set ROIs) IJ.run( "Set Measurements...", "area mean standard min area_fraction limit display add redirect=[" + imp_particles.title + "] decimal=3") IJ.run("Analyze Particles...", "size=30-Infinity show=Outlines display clear add") # get the ROI manager and save rm.runCommand( "save selected", os.path.join(folder, impname + '_' + channel_name + "_ROIs.zip"))
def main(): features = ["Area"] numberOfClusters = 2 features, numberOfClusters = getArguments(features, numberOfClusters) rt = RT.getResultsTable() if (rt.size() < 2): exit("No data found") attributes = featuresToAttributes(features) data = readDataFromResultsTable(attributes, rt) clusterer = createClusterer(numberOfClusters) clusterer.buildClusterer(data) (mu1, sig1, mu2, sig2, prior1, prior2) = getClusterInformationFrom(clusterer) threshold = intersection(mu2, sig2, mu1, sig1) print(clusterer.toString()) print "intersection at: ", threshold if (mu1 > mu2): mu1, sig1, mu2, sig2, prior1, prior2 = mu2, sig2, mu1, sig1, prior2, prior1 writeToTable(mu1, sig1, prior1, mu2, sig2, prior2, threshold)
def linkSpots(): rt = ResultsTable.getResultsTable() X = rt.getColumn(ResultsTable.X_CENTROID) Y = rt.getColumn(ResultsTable.Y_CENTROID) D = rt.getColumn(ResultsTable.FERET) SLICE = rt.getColumn(ResultsTable.SLICE) spotsByScale = getRoisBySlice(SLICE) print(spotsByScale) ## set objects of spots i scale 1 to the id of the spot spots = spotsByScale[1] for spot in spots: spot['object']=spot['id'] for s in range(2, len(spotsByScale)+1): spots = spotsByScale[s] for spot in spots: spot['object']=spot['id'] # initially set the object to which the spot belong to the spot id spotsLastScale = spotsByScale[s-1] minDist = float("inf") minObject = None for spotLastScale in spotsLastScale: # for each spot on the next scale deltaX = X[spotLastScale['id']]-X[spot['id']] deltaY = Y[spotLastScale['id']]-Y[spot['id']] dist = math.sqrt((deltaX * deltaX) + (deltaY*deltaY)) print("spot", spot['id'], "spot s-1", spotLastScale['id'], dist) if (dist<(D[spot['id']])/2.0): if (dist<minDist): minDist = dist minObject = spotLastScale['object'] print('hit', minDist, minObject) if minObject is not None: spot['object'] = minObject print("minObject", minObject) return spotsByScale
def run_straighten(roiWindowsize = 4): """ Original straightening function based on Nick's macro. Used in final version. Returns coordinate string used to make centerline. """ IJ.run("Set Measurements...", "mean min center redirect=None decimal=3") IJ.runMacro("//setTool(\"freeline\");") IJ.run("Line Width...", "line=80"); numPoints = 512/roiWindowsize xvals = [] yvals = [] maxvals = [] counter = 0 for i in range(0, 512, roiWindowsize): IJ.run("Clear Results") IJ.makeRectangle(i, 0, roiWindowsize, 512) IJ.run("Measure") table = RT.getResultsTable() xvals.append(i + roiWindowsize/2) yvals.append(RT.getValue(table, "YM", 0)) maxvals.append((RT.getValue(table, "Max", 0))) if maxvals[counter] == 0 and counter > 0: yvals[counter] = yvals[counter - 1] counter += 1 coords = "" for i in range(numPoints - 1): coords += str(xvals[i]) + ", " + str(yvals[i]) +", " coords += str(xvals[numPoints-1]) + ", " + str(yvals[numPoints-1]) IJ.runMacro("makeLine("+coords+")") IJ.run("Straighten...", "line = 80") return coords
def intensity_measure_3D(imp_intens, imp_label): imp_intens.show() imp_label.show() IJ.run(imp_intens, "3D Intensity Measure", "objects=[%s] signal=[%s]" % (imp_label.getTitle(), imp_intens.getTitle()) ); imp_intens.hide() imp_label.hide() rt = ResultsTable.getResultsTable() return rt
def run_comdet(image): IJ.run( image, "Detect Particles", " two=[Detect in both channels independently] ch1a=" + str(ch1size) + " ch1s=" + str(ch1thresh) + " ch2a=" + str(ch2size) + " ch2s=" + str(ch2thresh) + " calculate max=" + str(coloc) + " add=Nothing") rt = ResultsTable.getResultsTable() return rt
def analyzeImage(passImage, passModel, passChannel, passProbability, passPixels, passOutput): retResults = list() windows = set() # Register current window registerWindow(passImage.title, windows) # Extract the requested channel IJ.run("Z Project...", "projection=[Max Intensity]") registerWindow("MAX_" + passImage.title, windows) IJ.run("Duplicate...", "title=temp") registerWindow("temp", windows) # Apply WEKA training model to image wekaSeg = WekaSegmentation(WindowManager.getCurrentImage()) wekaSeg.loadClassifier(passModel) wekaSeg.applyClassifier(True) # Extract first slice of probability map wekaImg = wekaSeg.getClassifiedImage() wekaImg.show() registerWindow("Probability maps", windows) IJ.setSlice(1) IJ.run("Duplicate...", "title=temp2") registerWindow("temp2", windows) # Apply threshold and save IJ.setThreshold(passProbability, 1, "Black & White") fileParts = passImage.getTitle().split(".") IJ.save( os.path.join( passOutput, "{0}-probmap.png".format(fileParts[0], '.'.join(fileParts[1:])))) # Perform particle analysis and save IJ.run("Analyze Particles...", "size={0}-Infinity show=Outlines pixel clear".format(passPixels)) registerWindow("Drawing of temp2", windows) IJ.save( os.path.join( passOutput, "{0}-particles.png".format(fileParts[0], '.'.join(fileParts[1:])))) # Get measurements tableResults = ResultsTable.getResultsTable() for rowIdx in range(tableResults.size()): retResults.append(tableResults.getRowAsString(rowIdx).split()) retResults[-1].insert( 0, WindowManager.getCurrentImage().getCalibration().unit) retResults[-1].append( float(retResults[-1][4]) / float(retResults[-1][3])) # Close windows closeWindows(windows) return retResults
def auto_resize_angle_measure(img, two_sarcomere_size): """Resizes and measures angle of offset for img based on T-tubules.""" # Run Fast Fourier Transform on Image to get Power Spectral Density IJ.run(img, "FFT", "") # Select PSD image. fft_title = "FFT of " + img.getTitle() fft_img = WindowManager.getImage(fft_title) # Threshold the image and create binary mask. IJ.setThreshold(151, 255) #IJ.setThreshold(135, 255) IJ.run(fft_img, "Convert to Mask", "") # Set measurements for fitting an ellipse and fit them to data. IJ.run(fft_img, "Set Measurements...", "area centroid fit redirect=None decimal=2") if dev_options: args = "size=10-Infinity show=Ellipses display" else: args = "size=10-Inifinity" IJ.run(fft_img, "Analyze Particles...", args) results = ResultsTable.getResultsTable() angle_column = results.getColumnIndex("Angle") area_column = results.getColumnIndex("Area") centroid_x_column = results.getColumnIndex("X") centroid_y_column = results.getColumnIndex("Y") # Sort by area since we need the largest two ellipses. results.sort("Area") # Grab info for the largest two ellipses. areas = results.getColumnAsDoubles(area_column) angles = results.getColumnAsDoubles(angle_column) c_xs = results.getColumnAsDoubles(centroid_x_column) c_ys = results.getColumnAsDoubles(centroid_y_column) # Calculate offset angle from main ellipse. rotation_angle = angles[-1] - 90. # Measure distance between centroids of two largest ellipses using distance measurement tool to get spatial frequency of T-tubules. # Note: This needs to be in pixels since the filter size is in pixels. c_x_0 = c_xs[-1] c_y_0 = c_ys[-1] c_x_1 = c_xs[-2] c_y_1 = c_ys[-2] dist_gap = ((c_x_0 - c_x_1)**2 + (c_y_0 - c_y_1)**2)**0.5 old_two_sarcomere_size = 2 * fft_img.getDimensions()[0] / dist_gap # Resize based on measured two sarcomere size resize_ratio = float(two_sarcomere_size) / float(old_two_sarcomere_size) old_width = img.width old_height = img.height new_width = resize_ratio * old_width new_height = resize_ratio * old_height resize_args = "width={} height={} depth=1 constrain average interpolation=Bicubic".format( new_width, new_height) IJ.run(img, "Size...", resize_args) return rotation_angle
def straighten_roi_rotation(roiWindowsize = 8): """ Root straightening function that rotates ROI to follow root slope. Does not work properly. """ IJ.run("Set Measurements...", "mean standard min center redirect=None decimal=3") IJ.runMacro("//setTool(\"freeline\");") IJ.run("Line Width...", "line=80"); #numPoints = 512/roiWindowsize xvals = [] yvals = [] maxvals = [] counter = 0 maxIters = 800/roiWindowsize minIters = 10 imp = IJ.getImage().getProcessor() rm = RoiManager() if find_first_pixel(0,imp) == None or find_last_pixel(0,imp)[1] == None: return y = (find_first_pixel(0,imp)[1]+find_last_pixel(0,imp)[1])/2 roi = roiWindow_(imp, center = (roiWindowsize/2,y), width = roiWindowsize, height = 512) xvals.append(roiWindowsize/2) yvals.append(y) maxvals.append(0) roi.findTilt_() i = 0 while i < maxIters and roi.containsRoot_(): roi.advance_(roiWindowsize) IJ.run("Clear Results") IJ.run("Measure") table = RT.getResultsTable() x = RT.getValue(table, "XM", 0) y = RT.getValue(table, "YM", 0) if imp.getPixel(int(x),int(y)) != 0: xvals.append(x) yvals.append(y) maxvals.append((RT.getValue(table, "Max", 0))) #roi.advance_(roiWindowsize) print "here" roi.unrotateRoot_() IJ.run("Clear Results") IJ.run("Measure") roi.restoreCenter_(RT.getValue(table, "XM", 0), RT.getValue(table, "YM", 0)) #exit(1) sleep(.5) roi.findTilt_() i += 1 coords = "" for i in range(len(xvals)-1): coords += str(xvals[i]) + ", " + str(yvals[i]) +", " coords += str(xvals[len(xvals)-1]) + ", " + str(yvals[len(xvals)-1]) IJ.runMacro("makeLine("+coords+")") IJ.run("Straighten...", "line = 80")
def getColumn(aC): rt = ResultsTable.getResultsTable() anIndex = getColumnIndex(aC) column = [] for i in range(0, rt.size()): columns = rt.getRowAsString(i).split('\t') v = float(columns[anIndex]) column.append(v) return column
def filterPaths(self): evaluationTableTitle = "PathEvaluationTest" pathTableTitle = "pathsTable" evaluationTable = ResultsTable.getResultsTable(evaluationTableTitle) pathTable = ResultsTable.getResultsTable(pathTableTitle) rowToDelete = [ index for index, p in enumerate(self.paths, start=0) if not p.isWanted(evaluationTable, index) ] for index in rowToDelete[::-1]: pathTable.deleteRow(index) evaluationTable.deleteRow(index) self.paths.pop(index) evaluationTable.show(evaluationTableTitle) pathTable.show(pathTableTitle) self.addPathsToRoiManager(evaluationTable)
def f3_clic_saveTable(event): print "Click Save Table" RM = RoiManager() # we create an instance of the RoiManager class rm = RM.getRoiManager() imp = gvars["workingImage"] table_message = [] is_scaled = imp.getCalibration().scaled() if not is_scaled: JOptionPane.showMessageDialog(None, "Warning: your image is not spatially calibrated. \nTo calibrate, go to Analyze > Set Scale...") nChannels = imp.getNChannels() print "Total channels:" print nChannels for current_channel in range(1,nChannels+1): print "Current channel:" print current_channel imp.setSlice(current_channel) current_slice = str(imp.getCurrentSlice()) #Get current slice for saving into filename print "Current slice:" print current_slice is_scaled = imp.getCalibration().scaled() if is_scaled: spatial_cal = "True" else: spatial_cal = "False" IJ.run("Clear Results", "") rm.runCommand(imp,"Select All"); rm.runCommand(imp,"Measure") table = ResultsTable.getResultsTable().clone() IJ.selectWindow("Results") IJ.run("Close") filename = os.path.split(gvars["path_original_image"])[1] print filename pixels = gvars['eroded_pixels'] #To save number of eroded pixels in table and table name for i in range(0, table.size()): table.setValue('File', i, str(filename)) table.setValue('Channel', i, current_channel) table.setValue('Pixels_eroded', i, str(pixels)) table.setValue('Spatial_calibration', i, spatial_cal) table.show("Tabla actualizada") path_to_table = str(gvars['path_original_image'].replace(".tif", "") + "_Erosion_" +str(pixels)+ "px_Channel_" + str(current_channel) + ".csv") IJ.saveAs("Results", path_to_table) table_message.append("Table saved to %s" % path_to_table) JOptionPane.showMessageDialog(None, "\n".join(table_message))
def measureSkeletonTotalLength(imp, root): IJ.run(imp,"Analyze Skeleton (2D/3D)", "prune=none") totalLength = 0 nBranches = 0 rt = ResultsTable.getResultsTable() avgLengths = rt.getColumn(rt.getColumnIndex("Average Branch Length")) for i in range(len(avgLengths)): totalLength = totalLength + rt.getValue("# Branches", i) * rt.getValue("Average Branch Length", i) nBranches = nBranches + rt.getValue("# Branches", i) print root,",",imp.getTitle(),",",totalLength,",",nBranches
def measureSkeletonTotalLength(imp): IJ.run(imp,"Analyze Skeleton (2D/3D)", "prune=none") totalLength = 0 nBranches = 0 rt = ResultsTable.getResultsTable() avgLengths = rt.getColumn(rt.getColumnIndex("Average Branch Length")) for i in range(len(avgLengths)): totalLength = totalLength + rt.getValue("# Branches", i) * rt.getValue("Average Branch Length", i) nBranches = nBranches + rt.getValue("# Branches", i) print root,",",imp.getTitle(),",",totalLength,",",nBranches
def drawMinima(minima): rt = ResultsTable.getResultsTable() X = rt.getColumn(ResultsTable.X_CENTROID) Y = rt.getColumn(ResultsTable.Y_CENTROID) D = rt.getColumn(ResultsTable.FERET) overlay = Overlay() for minimum in minima: index = minima[minimum] r = float(D[index]) / 2 roi = OvalRoi(float(X[index])-r, float(Y[index])-r, float(D[index]), float(D[index])) overlay.add(roi) IJ.getImage().setOverlay(overlay)
def main(minOverlap): rt = ResultsTable.getResultsTable() X = rt.getColumn(ResultsTable.X_CENTROID) Y = rt.getColumn(ResultsTable.Y_CENTROID) D = rt.getColumn(ResultsTable.FERET) width = len(X) height = width - 1 matrix = createGraph(X, Y, D, minOverlap) graph = matrix_to_list(matrix) components = findConnectedComponents(graph) mergeRois(components)
def main(tableName, showPlot): image = IJ.getImage(); roi = image.getRoi() if not roi: center = image.getWidth() / 2, image.getHeight() / 2 else: center = roi.getXBase(), roi.getYBase(); table = ResultsTable.getResultsTable(tableName) rma = RadialMovementAnalyzer(table, center) radialDistances = rma.getDeltaRadialDistancePerTrack() distances = rma.getDistances() frames = rma.getFrames() travelledDistances = rma.getTravelledDistances() TABLE_NAME = "Distance from " + str(center) rt = ResultsTable.getResultsTable(TABLE_NAME) if not rt: rt = ResultsTable() for index, dist in enumerate(radialDistances): row = rt.getCounter() rt.setValue("label", row, tableName) rt.setValue("track ID", row, rma.trackIDs[index]) rt.setValue("total augmentation of distance from center", row, dist) rt.setValue("distance start to end", row, distances[index]) rt.setValue("travelled distance", row, travelledDistances[index]) rt.setValue("nr. of frames", row, frames[index]) if not distances[index] == 0: rt.setValue("total augmentation / distance start to end", row, dist / distances[index]) else: rt.setValue("total augmentation / distance start to end", row, float("nan")) if not travelledDistances[index] ==0: rt.setValue("total augmentation / travelled distance", row, dist / travelledDistances[index]) else: rt.setValue("total augmentation / travelled distance", row, float("nan")) rt.setValue("mean speed", row, travelledDistances[index] / frames[index]) rt.setValue("mean outward speed", row, dist / frames[index]) rt.show(TABLE_NAME) if showPlot: plot(distances, radialDistances, center)
def learn(imp): IJ.run(imp, "Line Width...", "line=10") IJ.run("Colors...", "foreground=black background=black selection=red") # Clear ROI manager roiMan = RoiManager.getInstance() if roiMan is not None: roiMan.reset() # set results table rt = ResultsTable.getResultsTable() # set up analyzer analyzer = Analyzer(imp, 1, rt) impBrightness = ProcessHSB.getBrightness(imp) IJ.run(impBrightness, "8-bit", "") IJ.run(impBrightness, "Auto Threshold", "method=Shanbhag white") IJ.run(impBrightness, "Analyze Particles...", "size=50000-Infinity circularity=0.00-1.00 show=Masks add in_situ") # Pixel running total pixelTotal = zeros('f', 4) roiTotal = roiMan.getCount() if roiMan is not None: # Iterate throught the ROIs for roi in xrange(roiTotal): roiMan.select(roi) selectRoi = roiMan.getRoi(roi) option = getOptions() # measure analyzer.measure() meas = rt.getRowAsString(0) newLine = meas.split(" ", 1) pixels = float(newLine[1]) # Tag the ROI IJ.run(imp, "Fill", "slice") pixelTotal[0] = pixelTotal[0] + (option[0] * pixels) pixelTotal[1] = pixelTotal[1] + (option[1] * pixels) pixelTotal[2] = pixelTotal[2] + (option[2] * pixels) pixelTotal[3] = pixelTotal[3] + (option[3] * pixels) return pixelTotal else: return pixelTotal
def rt_to_col_dict() : """takes the ResultsTable and return its contents as an col_dict(dictionary whose keys are heads of columns and values are the columns)""" # print("rt_to_col_dict") rt = ResultsTable.getResultsTable() # print(headings) col_dict = {} col_dict["Label"] = [] for n in range(rt.size()) : col_dict['Label'].append(rt.getLabel(n)) headings = rt.getHeadings() for heading in headings : if heading == "Label" : continue col_ind = rt.getColumnIndex(heading) # print(col_ind) # print(heading) col = rt.getColumn(col_ind) col_dict[heading] = col # # for i in range(len(headings)) : # temp = rt.getColumn(i) # # t = temp is not None # print("{}. {} = {}".format(i, headings[i], temp is not None)) # # if temp is not None : # col_dict[rt.getColumnHeading(i)] = list(temp) # col_dict["Label"] = [] for n in range(rt.size()) : col_dict['Label'].append(rt.getLabel(n)) return col_dict
def analyse(imp, root, filename, thresholds): closeAllImageWindows() imp.show() print "" print(imp.getTitle()) print "**********************************" IJ.run("Set Measurements...", "integrated redirect=None decimal=2"); # get image calibration info IJ.run(imp, "Properties...", "unit=pixel pixel_width=1 pixel_height=1"); # convert to 8-bit IJ.setMinAndMax(imp, 0, 65535); IJ.run(imp, "8-bit", ""); thresholds = [(x / 65535 * 255) for x in thresholds] # Nuclei #closeAllNoneImageWindows() iChannel = 1 imp.setSlice(iChannel) IJ.run(imp, "Gaussian Blur...", "sigma=2 slice"); IJ.setThreshold(imp, thresholds[iChannel-1], 1000000000) IJ.run(imp, "Convert to Mask", "method=Default background=Dark only black"); IJ.run(imp, "Measure", ""); rt = ResultsTable.getResultsTable() values = rt.getColumnAsDoubles(rt.getColumnIndex("RawIntDen")) print("Area Nuclei (pixel^2) =",values[-1]/255) # Dots #closeAllNoneImageWindows() iChannel = 3 imp.setSlice(iChannel) IJ.run(imp, "Gaussian Blur...", "sigma=1 slice"); IJ.run(imp, "Find Maxima...", "noise="+str(thresholds[iChannel-1])+" output=Count"); rt = ResultsTable.getResultsTable() values = rt.getColumnAsDoubles(rt.getColumnIndex("Count")) print("Number of Dots =",values[-1])
def measureImage(passImage, passPixels, passSteps): retResults = list() # Analyze particles IJ.run("Analyze Particles...", "size={0}-Infinity show=Nothing pixel display clear include".format(passPixels)); # Obtain results (initialize if first iteration) tableResults = ResultsTable.getResultsTable() for rowIdx in range(tableResults.size()): retResults.append(tableResults.getRowAsString(rowIdx).split()) # Rotate IJ.run("Rotate... ", "angle={0} interpolation=Bilinear".format(passSteps)) return retResults
def getMinima(objects): minIndices = {} rt = ResultsTable.getResultsTable() minIntensities = rt.getColumn(ResultsTable.MIN) for key in objects: ids = objects[key] minIndex = -1 minimum = float('inf') for anID in ids: if minIntensities[anID]<minimum: minimum = minIntensities[anID] minIndex = anID minIndices[key] = minIndex return minIndices
def process(srcDir, currentDir, fileName): image = IJ.openImage(os.path.join(currentDir, fileName)) IJ.run("Clear Results") #set lowerbound threshold here IJ.setThreshold(image, 200, 10000) # Change (1,25) below to (1,n+1) where n is the number of frames for slice in range(1,(image.getNSlices()+1),1): image.setSlice(slice) IJ.run(image, "Select All", "") IJ.run(image, "Measure", "") rt = ResultsTable.getResultsTable() # this line calculates the baseline baseline = (rt.getValue("IntDen",1) + rt.getValue("IntDen",2) + rt.getValue("IntDen",3))/3.0 for result in range(0,rt.getCounter()): cur_intensity = rt.getValue("IntDen",result) ratio = cur_intensity/baseline rt.setValue("RawIntDen",result,ratio) rt.updateResults() image.close()
def run(): srcDir = srcFile.getAbsolutePath() IJ.run("Set Measurements...", "integrated limit redirect=None decimal=3") for dirName, subdirs, filenames in os.walk(srcDir): if len(subdirs)==0: finalResults = [] for filename in filenames: # Check for file extension if not filename.endswith(ext): continue process(srcDir, dirName, filename) rt = ResultsTable.getResultsTable() colRaw = rt.getColumnIndex("IntDen") colRatio = rt.getColumnIndex("RawIntDen") finalResults.append(rt.getColumn(colRaw)) finalResults.append(rt.getColumn(colRatio)) with open(os.path.join(dirName, dirName+'.csv'), 'wb') as csvfile: writer = csv.writer(csvfile, delimiter=",") for row in zip(*finalResults): writer.writerow(row)
options = "radius=%d cutoff=%d percentile=%f" % (radius, cutoff, percentile) thread = thr.currentThread() original_name = thread.getName() thread.setName("Run$_my_batch_process") Macro.setOptions(thr.currentThread(), options) pt = IJ.runPlugIn(imp, "de.embl.cmci.pt3d.Dot_Detector_3D", "") impdimA = imp.getDimensions() ims = imp.createEmptyStack() for i in range(impdimA[3]): ims.addSlice(None, ByteProcessor(impdimA[0], impdimA[1])) imp2 = ImagePlus("test", ims) nSlices = imp2.getNSlices() rt = ResultsTable.getResultsTable() xindex = rt.getColumnIndex("x") yindex = rt.getColumnIndex("y") zindex = rt.getColumnIndex("z") xA = rt.getColumn(xindex) yA = rt.getColumn(yindex) zA = rt.getColumn(zindex) neighbornumA = NeighborChecker(xA, yA, zA, True) for i in range(len(xA)): print xA[i], yA[i], zA[i], " .. Neighbor", neighbornumA[i] # if xA[i] > 0: if neighbornumA[i] == 0: cslice=Math.round(zA[i])+1 if cslice > 0 and cslice <= nSlices:
def clear_results_table_if_exists(): rt = ResultsTable.getResultsTable() if rt!=None: rt.reset()
# IJ BAR snippet https://github.com/tferr/Scripts/tree/master/Snippets # # Calculates the closest pair of points from a 2D/3D list of centroid coordinates (opened in the IJ # 'Results' table) calling another BAR script to plot the frequencies of nearest neighbor distances. # # TF 20150101 import math, sys from ij import IJ, Menus import ij.measure.ResultsTable as RT # Specify column headings listing x,y,z positions xHeading, yHeading, zHeading = "X", "Y", "Z" # Retrieve Results Table rt = RT.getResultsTable() # Retrive x,y positions try: x = rt.getColumn(rt.getColumnIndex(xHeading)) y = rt.getColumn(rt.getColumnIndex(yHeading)) except: x = y = None if not None in (x, y): # Retrive z positions. Ignore positions if column is not found try: z = rt.getColumn(rt.getColumnIndex(zHeading)) except: IJ.log("Z-column not found: Assuming 2D distances...")
def run(): mask_ip = impSkel.getProcessor() part_ip = impPart.getProcessor() if not mask_ip.isBinary(): error(impSkel.getTitle() + " is not a binary mask.") return # Mask grayscale image and skeletonize mask try: mask_pixels = mask_ip.getPixels() part_pixels = part_ip.getPixels() for i in xrange(len(part_pixels)): if mask_pixels[i] == 0: part_pixels[i] = 0 part_ip.setPixels(part_pixels) except IndexError: error("Chosen images are not the same size.") skeletonize(impSkel) # Get skeleton features end_points, junctions, junction_voxels, total_len = skeleton_properties(impSkel) if not end_points and not junction_voxels: error(impSkel.getTitle() + " does not seem a valid skeleton.") return # Retrieve centroids from IJ1 threshold_lower = get_threshold(impPart, thres_method) cx, cy, n_particles = get_centroids(impPart, threshold_lower) if None in (cx, cy): error("Verify parameters: No particles detected.") return # Loop through each centroids and categorize its position # according to its distance to skeleton features n_bp = n_tip = n_none = n_both = 0 overlay = cleanse_overlay(impPart.getOverlay()) for i in range(n_particles): j_dist = ep_dist = sys.maxint # Retrieve the distance between this particle and the closest junction voxel for jvoxel in junction_voxels: dist = distance(cx[i], cy[i], jvoxel.x, jvoxel.y) if (dist <= cutoff_dist and dist < j_dist): j_dist = dist # Retrieve the distance between this particle and the closest end-point for end_point in end_points: dist = distance(cx[i], cy[i], end_point.x, end_point.y) if (dist <= cutoff_dist and dist < ep_dist): ep_dist = dist roi_id = str(i).zfill(len(str(n_particles))) roi_name = "Unknown:" + roi_id roi_color = Color.ORANGE roi_type = 2 # dot # Is particle associated with neither junctions nor end-points? if j_dist > cutoff_dist and ep_dist > cutoff_dist: roi_name = "Unc:" + roi_id #n_none += 1 # Is particle associated with both? elif abs(j_dist - ep_dist) <= pixel_size(impPart) / 2: roi_name = "J+T:" + roi_id roi_color = Color.CYAN #roi_type = 1 # crosshair n_both += 1 # Is particle associated with an end-point? elif ep_dist < j_dist: roi_name = "Tip:" + roi_id roi_color = Color.GREEN #roi_type = 0 # hybrid n_tip += 1 # Is particle associated with a junction? elif ep_dist > j_dist: roi_name = "Junction:" + roi_id roi_color = Color.MAGENTA #roi_type = 3 # circle n_bp += 1 roi = PointRoi(cx[i], cy[i]) roi.setName(roi_name) roi.setStrokeColor(roi_color) roi.setPointType(roi_type) roi.setSize(2) # medium overlay.add(roi) # Display result impSkel.setOverlay(overlay) impPart.setOverlay(overlay) # Output some measurements if "table" in output: t = ResultsTable.getResultsTable() if "IJ1" in output else DefaultGenericTable() addToTable(t, "Part. image", "%s (%s)" % (impPart.getTitle(), impPart.getCalibration().getUnits())) addToTable(t, "Skel. image", "%s (%s)" % (impSkel.getTitle(), impSkel.getCalibration().getUnits())) addToTable(t, "Junction particles", n_bp) addToTable(t, "Tip particles", n_tip) addToTable(t, "J+T particles", n_both) addToTable(t, "Unc. particles", n_none) addToTable(t, "Junctions w/ particles", n_bp + n_both) addToTable(t, "Tips w/ particles", n_tip + n_both) addToTable(t, "Total skel. lenght", total_len) addToTable(t, "Total end points", len(end_points)) addToTable(t, "Total junctions", sum(junctions)) addToTable(t, "Unc. particles / Total skel. lenght)", n_none/total_len) addToTable(t, "Snap-to dist.", str(cutoff_dist) + impPart.getCalibration().getUnits()) addToTable(t, "Threshold", "%d (%s)" % (threshold_lower, thres_method)) showTable(t, "Results")
def import_and_straighten(imgDir): """ Core function. Opens images in given directory in series and calls a straightening function. Thresholds using weka if stddev of pixel intensities is too high (bright field), otherwise uses histogram based segmentation. """ targetWidth = 800 #adjustable make_directory(imgDir) index = "000000000" filename = imgDir + "/img_" + index + "__000.tif" if path.exists(filename): weka = Weka_segmentor(IJ.openImage(filename)) while path.exists(filename): IJ.run("Set Measurements...", "mean standard min center redirect=None decimal=3") IJ.run("Clear Results") imp = IJ.openImage(filename) imp.show() IJ.run("Rotate 90 Degrees Left") IJ.run("Measure") table = RT.getResultsTable() stddev = RT.getValue(table, "StdDev", 0) if stddev < 20: segmented = weka.getThreshold(imp) segmented.show() IJ.run("8-bit") IJ.run("Invert") imp.close() imp = segmented else: IJ.run(imp, "Auto Threshold", "method=Li white") #threshold imp = preProcess_(imp) #straighten_roi_rotation() coords = run_straighten() newImp = IJ.getImage() """ fs = FileSaver(newImp) fs.saveAsTiff(imgDir + "/straightened" + "/img_" + index + "__000-straight.tif") """ IJ.run("Image Padder", "pad_right="+str(targetWidth - newImp.getWidth())) paddedImp = IJ.getImage() fs = FileSaver(paddedImp) fs.saveAsTiff(imgDir + "/binary" + "/img_" + index + "__000-padded.tif") IJ.runMacro("while (nImages>0) {selectImage(nImages);close();}") #use same centerline for original greyscale image imp = IJ.openImage(filename) imp.show() IJ.run("Rotate 90 Degrees Left") IJ.run("8-bit") IJ.runMacro("makeLine("+coords+")") IJ.run("Straighten...", "line = 80") newImp = IJ.getImage() IJ.run("Image Padder", "pad_right="+str(targetWidth - newImp.getWidth())) paddedImp = IJ.getImage() IJ.run("8-bit") fs = FileSaver(paddedImp) fs.saveAsTiff(imgDir + "/greyscale" + "/img_" + index + "__000-padded.tif") IJ.runMacro("while (nImages>0) {selectImage(nImages);close();}") index = to_9_Digits(str(int(index)+1)) filename = filename = imgDir + "/img_" + index + "__000.tif"
def run_comdet(image): IJ.run(image,"Detect Particles", " two=[Detect in both channels independently] ch1a="+str(ch1size) + " ch1s=" + str(ch1thresh) + " ch2a="+str(ch2size) + " ch2s=" + str(ch2thresh) + " calculate max=" + str(coloc) + " add=Nothing") rt = ResultsTable.getResultsTable() return rt