def showimage(self): roim = RoiManager.getInstance() if roim is None: roim = RoiManager() IJ.run("Close All") IJ.run("Clear Results") try: roim.reset() except AttributeError: roim.runCommand("reset") obj = self.fcsimages[self.idximg][0] imgName = self.fcsimages[self.idximg][1] img = BF.openImagePlus(imgName)[0] img.setZ(obj[1][2]+1) img.setC(3) IJ.run(img, "Grays", ""); img.setC(1) img.show() #draw rois for i in range(1, len(obj)+1): PR = PointRoi(obj[i][0],obj[i][1]) try: PR.setSize(3) PR.setPointType(0) roim.addRoi(PR) except: roim.addRoi(PR) roim.runCommand('Show All with Labels')
def run(): global pmWin global imgData helpText = "This is Point Marker, " + \ "a program for marking points in images.\n\n" + \ ">> Press OK to Select a file for storing points infomation.\n"+\ ">> TIF-Images within the same directory will be auto-loaded." MessageDialog(IJ.getInstance(), "Point Marker Guide", helpText) fileChooser = OpenDialog("Point Marker: Choose working directory and file") outfilePath = fileChooser.getPath() imgDir = fileChooser.getDirectory() if not imgDir: return imgPaths = [] if imgDir: for root, directories, filenames in os.walk(imgDir): for filename in filenames: if not filename.endswith(".tif"): continue imgPaths.append(os.path.join(root, filename)) pointsTable1 = readPoints(outfilePath) imgData = PointMarkerData(imgPaths, outfilePath, pointsTable1) IJ.setTool("multipoint") PointRoi.setDefaultSize(3) pmWin = PointMarkerWin(imgData) pmWin.win.setLocation(IJ.getInstance().getLocation()) prepareNewImage(imgData)
def run(): global pmWin global imgData helpText = "This is Point Marker, " + \ "a program for marking points in images.\n\n" + \ ">> Press OK to Select a file for storing points infomation.\n"+\ ">> TIF-Images within the same directory will be auto-loaded." MessageDialog(IJ.getInstance(),"Point Marker Guide", helpText) fileChooser = OpenDialog("Point Marker: Choose working directory and file") outfilePath = fileChooser.getPath() imgDir = fileChooser.getDirectory() if not imgDir: return imgPaths = [] if imgDir: for root, directories, filenames in os.walk(imgDir): for filename in filenames: if not filename.endswith(".tif"): continue imgPaths.append(os.path.join(root, filename)) pointsTable1 = readPoints(outfilePath) imgData = PointMarkerData(imgPaths, outfilePath, pointsTable1) IJ.setTool("multipoint") PointRoi.setDefaultSize(3) pmWin = PointMarkerWin(imgData) pmWin.win.setLocation(IJ.getInstance().getLocation()) prepareNewImage(imgData)
def run(): global maxDist, minPts ip = IJ.getImage() roi = ip.getRoi() points = roi.getContainedPoints() pointList = Arrays.asList(points) dplist = [] for p in pointList: array = [] array.append(p.x) array.append(p.y) jArray = jarray.array(array, 'd') dp = DoublePoint(jArray) dplist.append(dp) clusterer = DBSCANClusterer(maxDist, minPts) clusters = clusterer.cluster(dplist) RoiManager() roiManager = RoiManager.getRoiManager() for c in clusters: xCoordinates = [] yCoordinates = [] for dp in c.getPoints(): p = dp.getPoint() xCoordinates.append(p[0]) yCoordinates.append(p[1]) roi = PointRoi(xCoordinates, yCoordinates) roiManager.addRoi(roi)
def scaleTypeROI(roi): if isinstance(roi,PointRoi): p=roi.getFloatPolygon() x,y=list(p.xpoints),list(p.ypoints) xNew,yNew=map(lambda c:c*scale[0],x),map(lambda c:c*scale[1],y) roiNew=PointRoi(xNew,yNew) elif isinstance(roi,ShapeRoi): roiSels=roi.getRois() roiNews=map(scaleTypeROI,roiSels) roiNew=0 for roi in roiNews: if roiNew==0: roiNew=ShapeRoi(roi) else: roiNew=roiNew.or(ShapeRoi(roi)) else: tp=roi.getType() if tp!=0: p=roi.getPolygon() x,y=list(p.xpoints),list(p.ypoints) posNew=map(lambda pos:(pos[0]*scale[0],pos[1]*scale[1]),zip(x,y)) xNew,yNew=zip(*posNew) roiNew=PolygonRoi(xNew,yNew,tp) else: x,y,w,h=roi.getXBase(),roi.getYBase(),roi.getFloatWidth(),roi.getFloatHeight() xNew,yNew,wNew,hNew=x*scale[0],y*scale[1],w*scale[0],h*scale[1] roiNew=Roi(xNew,yNew,wNew,hNew) return(roiNew)
def drawLines(imp, points=None): if points and (len(points)%2 == 0): # points is numeric list of even length pRoi = PointRoi(points[0::2], points[1::2], len(points)/2) pRoi.setShowLabels(True) pRoi.setSize(3) imp.setRoi(pRoi) roi = imp.getRoi() pp = roi.getFloatPolygon() # print "Added", pp.npoints if pp.npoints <= 1: # don't draw if only one point return xys = [] for i in xrange(pp.npoints): xys.append([pp.xpoints[i], pp.ypoints[i]]) ol = Overlay() x0 = xys[0][0] y0 = xys[0][1] cal = imp.getCalibration() for i in xrange(1, pp.npoints): xi = xys[i][0] yi = xys[i][1] # prepare text label d = math.sqrt((xi - x0)**2 + (yi - y0)**2) * cal.pixelWidth dText = String.format("%.2f ", d) + cal.getUnits() textOffset = 30 xt = xi yt = yi # if xi > x0: # xt += textOffset if xi < x0: xt -= textOffset # if yi > y0: # yt += textOffset if yi < y0: yt -= textOffset dTextRoi = TextRoi(xt, yt, dText) ol.add(dTextRoi) lineRoi = Line(x0, y0, xi, yi) lineRoi.setStrokeWidth(1) lineRoi.setStrokeColor(Color(255,255,0)) ol.add(lineRoi) imp.setOverlay(ol) imp.updateAndDraw()
def updatePointRoi(self): # Surround with try/except to prevent blocking # ImageJ's stack slice updater thread in case of error. try: # Update PointRoi self.imp.killRoi() point = self.nuclei[self.imp.getFrame()] # map 1-based slices # to 0-based nuclei Z coords if len(point) == 0: return IJ.log("Cell found in frame " + str(self.imp.getFrame())) # New empty PointRoi for the current slice roi = PointRoi(point[0], point[1]) # Style: large, red dots roi.setSize(4) # ranges 1-4 roi.setPointType(2) # 2 is a dot (filled circle) roi.setFillColor(Color.red) roi.setStrokeColor(Color.red) self.imp.setRoi(roi) except: IJ.error(sys.exc_info())
def draw_classes(inputfile,data): pathname,filename = os.path.split(inputfile) # last subdir is for well ## TODO ## support multiple plates, read plate and well from csv well = os.path.basename(pathname) # create output directory outputdir = os.path.join(OUTPUTROOT,well) if not os.path.isdir(outputdir): os.makedirs(outputdir) # create output filename head,tail = os.path.splitext(filename) outputfilename = head + "_classes" + tail outputfilename = os.path.join(outputdir,outputfilename) print outputfilename imp = IJ.openImage(inputfile).duplicate() IJ.run(imp,"RGB Color","") for d in data: x = int(float(d[0])) y = int(float(d[1])) c = int(float(d[2])) classname = classes[str(c)] colorname = colors[classname] color = colormap[colorname] #print colorname roi = PointRoi(x,y) roi.setDefaultMarkerSize("Large") roi.setStrokeColor(colormap[colorname]) imp.getProcessor().drawRoi(roi) IJ.saveAs(imp,"png",outputfilename)
def drawLines(imp, points=None): if points and (len(points) % 2 == 0): # points is numeric list of even length pRoi = PointRoi(points[0::2], points[1::2], len(points) / 2) pRoi.setShowLabels(True) pRoi.setSize(3) imp.setRoi(pRoi) roi = imp.getRoi() pp = roi.getFloatPolygon() # print "Added", pp.npoints if pp.npoints <= 1: # don't draw if only one point return xys = [] for i in xrange(pp.npoints): xys.append([pp.xpoints[i], pp.ypoints[i]]) ol = Overlay() x0 = xys[0][0] y0 = xys[0][1] cal = imp.getCalibration() for i in xrange(1, pp.npoints): xi = xys[i][0] yi = xys[i][1] # prepare text label d = math.sqrt((xi - x0)**2 + (yi - y0)**2) * cal.pixelWidth dText = String.format("%.2f ", d) + cal.getUnits() textOffset = 30 xt = xi yt = yi # if xi > x0: # xt += textOffset if xi < x0: xt -= textOffset # if yi > y0: # yt += textOffset if yi < y0: yt -= textOffset dTextRoi = TextRoi(xt, yt, dText) ol.add(dTextRoi) lineRoi = Line(x0, y0, xi, yi) lineRoi.setStrokeWidth(1) lineRoi.setStrokeColor(Color(255, 255, 0)) ol.add(lineRoi) imp.setOverlay(ol) imp.updateAndDraw()
def process_img(img_path): IJ.log('Processing {} ...'.format(img_path)) # open image imp = IJ.openImage(img_path) imp.show() w_big = imp.getWindow() w_big.setLocationAndSize(1050, 400, 500, 500) # read relative csv file rows (coordinates of centers) img_name, img_extension = os.path.splitext(img_path) marker_path = img_name + '.csv' if not os.path.exists(marker_path): root = os.path.dirname(marker_path) IJ.log('Creating corrected CSV files in {}...'.format(root)) mrk.markers_to_csv(root, y_inv_height=imp.height) markers = mrk.read_marker(marker_path, to_int=True) for cs in gen_cell_stacks(imp, markers, cube_roi_dim, scaleZ): # identify cell in original image imp.setSlice(cs.seed[2] + 1) point = PointRoi(cs.seed[0], cs.seed[1]) point.setSize(3) point.setColor(Color.RED) imp.setRoi(point) if discard_margin_cells: if not cs.onBorder: process_cell(cs) else: IJ.log('Skipped on border cell in seed ' + str(cs.seed)) else: process_cell(cs) c = raw_input( "Press enter to show the next cell or 'n' to go to the next image\n" ) cs.close() if c == 'n': IJ.log("Skipped remaining cells") break
def findEndPoints(imageID, maskID): endPoints1 = [] endPoints2 = [] imp = IJ.getImage() imp.setSlice(1); roiManager = RoiManager.getInstance2() rois = roiManager.getRoisAsArray() roisToBeRemoved = [] index = 0 for roi in rois: outerBounds = roi.getBounds() impMT, innerBounds = duplicateMaskInRoi(imp, roi) nr, endPoint1, endPoint2 = findEndPointsInSkeleton(impMT) if (nr==2): endPoint1.x = endPoint1.x + outerBounds.x + innerBounds.x - 1 endPoint1.y = endPoint1.y + outerBounds.y + innerBounds.y - 1 endPoint2.x = endPoint2.x + outerBounds.x + innerBounds.x - 1 endPoint2.y = endPoint2.y + outerBounds.y + innerBounds.y - 1 endPoints1.append(endPoint1) endPoints2.append(endPoint2) else: roisToBeRemoved.append(index) impMT.close() index = index + 1 if (len(roisToBeRemoved)>0): roiManager.setSelectedIndexes(roisToBeRemoved) roiManager.runCommand("Delete") roiManager.moveRoisToOverlay(WindowManager.getImage(maskID)) inputIMP = WindowManager.getImage(imageID) inputIMP.setOverlay(PointRoi([seq.x for seq in endPoints1], [seq.y for seq in endPoints1]), Color.magenta, 1, Color.magenta) otherPoints = PointRoi([seq.x for seq in endPoints2], [seq.y for seq in endPoints2]) otherPoints.setStrokeColor(Color.cyan) otherPoints.setFillColor(Color.cyan) inputIMP.getOverlay().add(otherPoints)
from ij.plugin.frame import RoiManager from ij import WindowManager from ij.gui import PointRoi,ShapeRoi roiManager=WindowManager.getFrame("ROI Manager") roiSel=roiManager.getSelectedRoisAsArray() if len(roiSel)==1: roiSel=roiSel[0].getRois() roiSel=map(ShapeRoi,roiSel) # convert roi composite to many roi x,y=[],[] for sel in roiSel: stat=sel.getStatistics() x.append(stat.xCentroid) y.append(stat.yCentroid) roi_new=PointRoi(x,y) roiManager.addRoi(roi_new)
def ana_particles_watershed(imp, strThrMeth="method=Default white", minPx=10, minCirc=0.35, labCol=Color.white, linCol=Color.green, bDebug=False, sl=0.005): """ana_particles_watershed(imp, strThrMeth="method=Default white", minPx=10, minCirc=0.35, labCol=Color.white, linCol=Color.green, bDebug=False, sl=0.005) A wrapper function to do particle analysis from an image after a watershed transformation and draw the detected features into the overlay of the original image. Inputs: imp - the ImagePlus instance that we will process strThrMeth - a string specifying the threshold method minPx - the minimum pixels to detect minCirc - the minimum circularity to detect labCol - the color for labels in the overlay (default white) linCol - the color for line/stroke in the overlay (default green) bDebug - a flag (default False) that, if true, keeps the work image open sl - a time (default 0.005) to sleep when adding ROIs to not overload This adds the detected features to the overlay and returns the result table for processing for output. """ title = imp.getTitle() shortTitle = imp.getShortTitle() typ = imp.getType() imp.setTitle(shortTitle) imp.show() IJ.run(imp, "Duplicate...", "title=work") wrk = IJ.getImage() # if this is a 16 bit image, convert to 8 bit prior to threshold if typ == ImagePlus.GRAY16: IJ.run(wrk, "Enhance Contrast", "saturated=0.35") IJ.run(wrk, "8-bit", "") IJ.run(wrk, "Threshold", strThrMeth) IJ.run(wrk, "Watershed", "") wrk.show() strMeas = "area mean modal min center perimeter bounding fit shape feret's display redirect=%s decimal=3" % shortTitle IJ.run(wrk, "Set Measurements...", strMeas) strAna = "size=%d-Infinity circularity=%g-1.00 exclude clear include add" % ( minPx, minCirc) IJ.run(wrk, "Analyze Particles...", strAna) rt = ResultsTable().getResultsTable() rm = RoiManager.getInstance() ra = rm.getRoisAsArray() # Draw the particles into the overlay of the original i = 0 for r in ra: i += 1 rLab = "%d" % i r.setName(rLab) imp = jmg.addRoiToOverlay(imp, r, labCol=labCol, linCol=linCol) # needed to put in sleep here on crunch to let this complete and not overrun buffer time.sleep(sl) # let's put a PointRoi outside the image to get the overlays all the same color r = PointRoi(-10, -10) imp = jmg.addRoiToOverlay(imp, r, labCol=labCol, linCol=linCol) # clear the roi manager and return the results table rm.reset() rm.close() imp.setTitle(title) if bDebug == False: wrk.changes = False wrk.close() return r
def extractFeatures(ip, params): sift = FloatArray2DSIFT(params) sift.init(FloatArray2D(ip.convertToFloat().getPixels(), ip.getWidth(), ip.getHeight())) features = sift.run() # instances of mpicbg.imagefeatures.Feature return features features1 = extractFeatures(imp1.getProcessor(), p) features2 = extractFeatures(imp2.getProcessor(), p) # Feature locations as points in an ROI # Store feature locations in the Roi manager for visualization later roi_manager = RoiManager() roi1 = PointRoi() roi1.setName("features for cut1") for f in features1: roi1.addPoint(f.location[0], f.location[1]) roi_manager.addRoi(roi1) roi2 = PointRoi() roi2.setName("features for cut2") for f in features2: roi2.addPoint(f.location[0], f.location[1]) roi_manager.addRoi(roi2) # Find matches between the two sets of features # (only by whether the properties of the features themselves match,
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
peaks = detector.getResult() print str(len(peaks)), "peaks were found." # Add points to ROI manager rm = RoiManager.getInstance() if not rm: rm = RoiManager() # Loop through all the peak that were found for peak in peaks: # Print the current coordinates print "peaks", peak.getDoublePosition(0), peak.getDoublePosition( 1), peak.getDoublePosition(2) # Add the current peak to the Roi manager roi = PointRoi( peak.getDoublePosition(0) / cal.pixelWidth, peak.getDoublePosition(1) / cal.pixelHeight) oval = OvalRoi( int( peak.getDoublePosition(0) / cal.pixelWidth - 0.5 * radius / cal.pixelWidth), int( peak.getDoublePosition(1) / cal.pixelHeight - 0.5 * radius / cal.pixelHeight), radius / cal.pixelWidth, radius / cal.pixelHeight) oval.setColor(Color.RED) # Set the Z position of the peak otherwise the peaks are all set on the same slice oval.setPosition( int(round(peak.getDoublePosition(2) / cal.pixelDepth)) + 1) roi.setPosition( int(round(peak.getDoublePosition(2) / cal.pixelDepth)) + 1)
for i in range(img.numDimensions())] # no calibration: identity sigmaSmaller = 15 # in pixels: a quarter of the radius of an embryo sigmaLarger = 30 # pixels: half the radius of an embryo extremaType = DogDetection.ExtremaType.MAXIMA minPeakValue = 10 normalizedMinPeakValue = False # In the differece of gaussian peak detection, the img acts as the interval # within which to look for peaks. The processing is done on the infinite imgE. dog = DogDetection(imgE, img, calibration, sigmaSmaller, sigmaLarger, extremaType, minPeakValue, normalizedMinPeakValue) peaks = dog.getPeaks() # Create a PointRoi from the DoG peaks, for visualization roi = PointRoi(0, 0) # A temporary array of integers, one per dimension the image has p = zeros(img.numDimensions(), 'i') # Load every peak as a point in the PointRoi for peak in peaks: # Read peak coordinates into an array of integers peak.localize(p) roi.addPoint(imp, p[0], p[1]) imp.setRoi(roi) # Now, iterate each peak, defining a small interval centered at each peak, # and measure the sum of total pixel intensity, # and display the results in an ImageJ ResultTable. table = ResultsTable()
def main(imp, tolerance, window_radius, pixel_size_nm, out_dir): # set output dir out_dir = str(out_dir) # Find maxima excludeOnEdge = True polygon = MaximumFinder().getMaxima(imp.getProcessor(), tolerance, excludeOnEdge) roi = PointRoi(polygon) # get RoiManager rm = RoiManager.getInstance(); if rm is None: rm = RoiManager() # Check if output table is writable out_table_fn = os.path.join(out_dir, "fwhm_values.txt") try: file_handle = open(out_table_fn, 'w') except IOError: IJ.showMessage("Output file '' not writeable. Check if file is open in Excel...") sys.exit(0) # iterate and write output with file_handle as csvfile: writer = csv.DictWriter(csvfile, fieldnames=["id", "peak_id", "x_pos", "y_pos", "type", "fwhm", "fwhm_nm", "r2_GoF", "avg_fwhm", "area_profile", "area_gauss"], delimiter="\t", lineterminator='\n') writer.writeheader() id_ = 0 # over all peaks for i, p in list(enumerate(roi)): IJ.showProgress(i, roi.getNCounters() +1) # Horizontal lroi = Line(p.x+0.5-window_radius, p.y+0.5, p.x+0.5+window_radius, p.y+0.5) output = fit_gauss(lroi, imp, p, i, id_, "H", rm) writer.writerow(output) id_+=1 # Vertical lroi = Line(p.x+0.5, p.y+0.5-window_radius, p.x+0.5, p.y+0.5+window_radius) output = fit_gauss(lroi, imp, p, i, id_, "V", rm) writer.writerow(output) id_+=1 # Diagonal 1 lroi = Line(p.x+0.5-MN*window_radius, p.y+0.5+MN*window_radius, p.x+0.5+MN*window_radius, p.y+0.5-MN*window_radius) output = fit_gauss(lroi, imp, p, i, id_, "D1", rm) writer.writerow(output) id_+=1 # Diagonal 2 lroi = Line(p.x+0.5-MN*window_radius, p.y+0.5-MN*window_radius, p.x+0.5+MN*window_radius, p.y+0.5+MN*window_radius) output = fit_gauss(lroi, imp, p, i, id_, "D2", rm) writer.writerow(output) id_+=1 IJ.showProgress(1) rm.runCommand("Deselect"); # deselect ROIs to save them all rm.runCommand("Save", os.path.join(out_dir, "fwhm_fiji_rois.zip")) IJ.showMessage("FWHM on Spots: Done")
f = open(str(xFile)) for line in f: x.append(line.replace("\n","").split(",")) f.close() f = open(str(yFile)) for line in f: y.append(line.replace("\n","").split(",")) f.close() f = open(str(zFile)) for line in f: z.append(line.replace("\n","").split(",")) f.close() x.pop(0) y.pop(0) z.pop(0) imp = IJ.getImage() rm = RoiManager() IJ.log("Processing started") for point in x: IJ.log("\\Update:Processing Object {}/{}".format(x.index(point)+1,len(x))) for time in point: if len(time) < 10 and time != 'NA': imp.setZ(int(round(float(z[x.index(point)][x[x.index(point)].index(time)])))) imp.setT(x[x.index(point)].index(time)+1) rm.add(imp,PointRoi(int(round(float(time))),int(round(float(y[x.index(point)][x[x.index(point)].index(time)])))),x.index(point)+1)
def process(srcDir, dstDir, currentDir, fileName, keepDirectories, Channel_1, Channel_2, radius_background, sigmaSmaller, sigmaLarger, minPeakValue, min_dist): IJ.run("Close All", "") # Opening the image IJ.log("Open image file:" + fileName) #imp = IJ.openImage(os.path.join(currentDir, fileName)) #imp = IJ.getImage() imp = BF.openImagePlus(os.path.join(currentDir, fileName)) imp = imp[0] # getDimensions(width, height, channels, slices, frames) IJ.log("Computing Max Intensity Projection") if imp.getDimensions()[3] > 1: imp_max = ZProjector.run(imp,"max") else: imp_max = imp ip1, ip2 = extract_channel(imp_max, Channel_1, Channel_2) IJ.log("Substract background") imp1, imp2 = back_substraction(ip1, ip2, radius_background) IJ.log("Finding Peaks") ip1_1, ip2_1, peaks_1, peaks_2 = find_peaks(imp1, imp2, sigmaSmaller, sigmaLarger, minPeakValue) # Create a PointRoi from the DoG peaks, for visualization roi_1 = PointRoi(0, 0) roi_2 = PointRoi(0, 0) roi_3 = PointRoi(0, 0) roi_4 = PointRoi(0, 0) # A temporary array of integers, one per dimension the image has p_1 = zeros(ip1_1.numDimensions(), 'i') p_2 = zeros(ip2_1.numDimensions(), 'i') # Load every peak as a point in the PointRoi for peak in peaks_1: # Read peak coordinates into an array of integers peak.localize(p_1) roi_1.addPoint(imp1, p_1[0], p_1[1]) for peak in peaks_2: # Read peak coordinates into an array of integers peak.localize(p_2) roi_2.addPoint(imp2, p_2[0], p_2[1]) # Chose minimum distance in pixel #min_dist = 20 for peak_1 in peaks_1: peak_1.localize(p_1) for peak_2 in peaks_2: peak_2.localize(p_2) d1 = distance(p_1, p_2) if d1 < min_dist: roi_3.addPoint(imp1, p_2[0], p_2[1]) break for peak_2 in peaks_2: peak_2.localize(p_2) for peak_1 in peaks_1: peak_1.localize(p_1) d2 = distance(p_2, p_1) if d2 < min_dist: roi_4.addPoint(imp1, p_2[0], p_2[1]) break cal = imp.getCalibration() min_distance = str(round((cal.pixelWidth * min_dist),1)) table = ResultsTable() table.incrementCounter() table.addValue("Numbers of Neuron Markers", roi_1.getCount(0)) table.addValue("Numbers of Glioma Markers", roi_2.getCount(0)) table.addValue("Numbers of Glioma within %s um of Neurons" %(min_distance), roi_3.getCount(0)) table.addValue("Numbers of Neurons within %s um of Glioma" %(min_distance), roi_4.getCount(0)) #table.show("Results Analysis") saveDir = currentDir.replace(srcDir, dstDir) if keepDirectories else dstDir if not os.path.exists(saveDir): os.makedirs(saveDir) IJ.log("Saving to" + saveDir) table.save(os.path.join(saveDir, fileName + ".csv")) IJ.selectWindow("Log") IJ.saveAs("Text", os.path.join(saveDir, fileName + ".csv"));
def save_membrane_edge_image(membrane_channel_imp, fixed_anchors_list, membrane_edges, area_rois, params): """Save an image with the membrane channel overlaid with original anchor positions, fixed anchor positions, and membrane edge""" IJ.run(membrane_channel_imp, "RGB Color", "") anchors = params.manual_anchor_positions midpoint = params.manual_anchor_midpoint[0] #print("membrane_edges = " + str(len(membrane_edges))); #print("membrane_channel_imp = " + str(membrane_channel_imp)); #print("fixed_anchors_list = " + str(len(fixed_anchors_list))); #print("area_rois = " + str(len(area_rois))); if fixed_anchors_list is None: fixed_anchors_list = [] # not pythonic, but never mind... for edge in membrane_edges: poly = edge.getPolygon() xs = poly.xpoints ys = poly.ypoints fixed_anchors_list.append([(xs[0], ys[0]), (xs[-1], ys[-1])]) try: for fridx in range(0, membrane_channel_imp.getNFrames()): membrane_channel_imp.setPosition(fridx + 1) membrane_channel_imp.setRoi(membrane_edges[fridx]) IJ.setForegroundColor(0, 255, 255) IJ.run(membrane_channel_imp, "Draw", "slice") membrane_channel_imp.setRoi(area_rois[fridx]) IJ.setForegroundColor(0, 255, 0) IJ.run(membrane_channel_imp, "Draw", "slice") for p in anchors: roi = PointRoi(p[0], p[1]) membrane_channel_imp.setRoi(roi) IJ.setForegroundColor(255, 0, 0) IJ.run(membrane_channel_imp, "Draw", "slice") roi = PointRoi(midpoint[0], midpoint[1]) membrane_channel_imp.setRoi(roi) IJ.setForegroundColor(255, 0, 0) IJ.run(membrane_channel_imp, "Draw", "slice") for p in fixed_anchors_list[fridx]: roi = PointRoi(p[0], p[1]) membrane_channel_imp.setRoi(roi) IJ.setForegroundColor(255, 255, 0) IJ.run(membrane_channel_imp, "Draw", "slice") # TODO: if coincidence between anchors and fixed anchors, or indeed with edge, consider # rendering in secondary colours (magenta = (255,0,255), orange = (255,200,0), green = (0,255,0)? except: pass FileSaver(membrane_channel_imp).saveAsTiff( os.path.join(params.output_path, "membrane identification check.tif")) IJ.setForegroundColor(255, 255, 255) #from ij import WindowManager as WM #import membrane_blebbing_fileio as mbio; #from ij.plugin import ChannelSplitter #folder = "D:\\data\\Inverse blebbing\\output\\2018-10-29 17-06-15 output"; #curvature_overlay = IJ.openImage(os.path.join(folder, "raw curvature.tif")); #curvature_profiles = mbio.load_csv_as_profile(os.path.join(folder, "curvatures.csv")); #imp = IJ.openImage("D:\\data\\Inverse blebbing\\MAX_2dpf marcksl1b-EGFP inj_TgLifeact-mCh_movie e4_split-bleb1.tif"); #intensity_channel_imp = ChannelSplitter.split(imp)[1]; #intensity_channel_imp.show(); #colormap_string = "physics" #generate_intensity_weighted_curvature(curvature_overlay, curvature_profiles, intensity_channel_imp, colormap_string);
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 perform_user_qc(in_imp, edges, alt_edges, fixed_anchors_list, params): """allow the user to intervene to fix erroneously identified membrane edges""" n_frames = in_imp.getNFrames(); n_channels = in_imp.getNChannels(); output_folder = params.output_path; current_edges = edges; rgbstack = ImageStack(in_imp.getWidth(), in_imp.getHeight()); if n_frames > 1: for tidx in range(n_frames): in_imp.setT(tidx+1); ip = in_imp.getProcessor(); rgbip = ip.convertToRGB(); rgbstack.addSlice(rgbip); else: for cidx in range(n_channels): in_imp.setC(cidx+1); ip = in_imp.getProcessor(); rgbip = ip.convertToRGB(); rgbstack.addSlice(rgbip); imp = ImagePlus(("RGB " + in_imp.getTitle()), rgbstack); IJ.run("Colors...", "foreground=red background=white selection=yellow"); for tidx in range(imp.getNSlices()): imp.setSlice(tidx+1); for anchor in params.manual_anchor_positions: imp.setRoi(PointRoi(anchor[0], anchor[1])); IJ.run(imp, "Draw", "slice"); imp.show(); autoset_zoom(imp); imp.setPosition(1); imp.setRoi(current_edges[0]); if n_frames > 1: listener = UpdateRoiImageListener(current_edges); imp.addImageListener(listener); IJ.setTool("freeline"); do_flip = True; while do_flip: dialog = NonBlockingGenericDialog("User quality control"); dialog.enableYesNoCancel("Continue", "Flip all edges"); dialog.setCancelLabel("Cancel analysis"); dialog.addMessage("Please redraw the membrane edges as necessary, \n" + "making sure to draw beyond anchor points at either end...\n" + "Click OK when done. "); p = Panel(); but = Button("Flip this edge"); al = Listener(edges, alt_edges, imp); but.addActionListener(al); p.add(but); dialog.addPanel(p); dialog.showDialog(); if dialog.wasCanceled(): raise KeyboardInterrupt("Run canceled"); elif dialog.wasOKed(): do_flip = False; else: print("flip edges"); do_flip = True; if n_frames > 1: imp.removeImageListener(listener); current_edges = alt_edges if (current_edges == edges) else edges; imp.setPosition(1); imp.setRoi(current_edges[0]); if n_frames > 1: listener = UpdateRoiImageListener(current_edges); imp.addImageListener(listener); last_roi = imp.getRoi(); if n_frames > 1: qcd_edges = listener.getRoiList(); if imp.getNFrames() > imp.getNSlices(): qcd_edges[imp.getT() - 1] = last_roi; else: qcd_edges[imp.getZ() - 1] = last_roi; imp.removeImageListener(listener); else: qcd_edges = [last_roi]; mbio.save_qcd_edges2(qcd_edges, output_folder); # next four lines are a quick and dirty hack... if n_frames > 1: nframes = imp.getNFrames() if imp.getNFrames()>imp.getNSlices() else imp.getNSlices(); else: nframes = n_frames; for fridx in range(0, nframes): if (qcd_edges[fridx].getType()==Roi.FREELINE) or (qcd_edges[fridx].getType()==Roi.POLYLINE): if (fridx == 0) or params.constrain_anchors: anchors = params.manual_anchor_positions; else: anchors = fixed_anchors_list[fridx - 1]; fixed_anchors = mb.fix_anchors_to_membrane(anchors, qcd_edges[fridx], params); fixed_anchors = mb.order_anchors(fixed_anchors, params.manual_anchor_midpoint); fixed_anchors_list[fridx] = fixed_anchors; poly = qcd_edges[fridx].getInterpolatedPolygon(0.25, False); polypoints = [(x,y) for x,y in zip(poly.xpoints, poly.ypoints)]; idx = [polypoints.index(fixed_anchors[0]), polypoints.index(fixed_anchors[1])]; idx.sort(); polypoints = polypoints[idx[0]:idx[1]]; newedge = PolygonRoi([x for (x,y) in polypoints], [y for (x,y) in polypoints], Roi.POLYLINE); newedge = mb.check_edge_order(anchors, newedge); imp.setPosition(fridx + 1); imp.setRoi(newedge); IJ.run(imp, "Interpolate", "interval=1.0 smooth adjust"); IJ.run(imp, "Fit Spline", ""); qcd_edges[fridx] = imp.getRoi(); mbio.save_qcd_edges2(qcd_edges, output_folder); imp.changes = False; imp.close(); return qcd_edges, fixed_anchors_list;
def main(): # ensure consistent preference settings Prefs.blackBackground = False; # get locations for previous and new outputs params = Parameters(); params.loadLastParams(); output_folder_old, output_folder = mbio.rerun_location_chooser(params.input_image_path); params.loadParametersFromJson(os.path.join(output_folder_old, 'parameters used.json')); params.setOutputPath(output_folder); # get original image file (for overlays etc.) if not os.path.isfile(params.input_image_path): mbui.warning_dialog(["The original data can't be found at the location specified in saved parameters. ", "(Possibly something as simple as a change in network drive mapping has occurred)", "Please specify the location of the original image file..."]); params.setInputImagePath(mbio.input_file_location_chooser(params.output_path)); import_opts, params = mbui.choose_series(params.input_image_path, params); imps = bf.openImagePlus(import_opts); imp = imps[0]; if imp.getNSlices() > 1: mbui.warning_dialog(["More than one Z plane detected.", "I will do a maximum projection before proceeding", "Continue?"]); imp = ZProjector.run(imp,"max all"); # prompt user to select ROI original_imp = Duplicator().run(imp); _, crop_params = mbui.crop_to_ROI(imp, params); imp.show(); if crop_params is not None: params.perform_spatial_crop = True; mbui.autoset_zoom(imp); imp.updateAndDraw(); review_crop = mb.check_cropping(output_folder_old, params); keep_crop = not review_crop; if review_crop: keep_crop = mbui.crop_review(); if not keep_crop: imp.changes = False; imp.close(); imp = original_imp; else: original_imp.close(); else: original_imp.close(); # prompt user to do time cropping imp, start_end_tuple = mbui.time_crop(imp, params); params.setTimeCropStartEnd(start_end_tuple); params = mbio.get_metadata(params); params.setCurvatureLengthUm(round(params.curvature_length_um / params.pixel_physical_size) * params.pixel_physical_size); params.persistParameters(); IJ.run(imp, "Set Scale...", "distance=0 known=0 pixel=1 unit=pixel"); imp.show(); if imp.getNChannels() > 1: imp.setPosition(params.membrane_channel_number, 1, 1); mbui.autoset_zoom(imp); IJ.run("Enhance Contrast", "saturated=0.35"); split_channels = mbfs.split_image_plus(imp, params); membrane_test_channel_imp = Duplicator().run(split_channels[0]); segmentation_channel_imp = split_channels[-1]; # import edges imp.hide(); membrane_edges = mbio.load_qcd_edges2(os.path.join(output_folder_old, "user_defined_edges.zip")); dummy_anchors = [params.manual_anchor_positions for _ in membrane_edges] membrane_edges, fixed_anchors = mbui.perform_user_qc(membrane_test_channel_imp, membrane_edges, membrane_edges, dummy_anchors, params); imp.show(); rgbstack = ImageStack(imp.getWidth(), imp.getHeight()); for tidx in range(imp.getNFrames()): imp.setT(tidx+1); ip = imp.getProcessor(); rgbip = ip.convertToRGB(); rgbstack.addSlice(rgbip); rgbimp = ImagePlus(("RGB " + imp.getTitle()), rgbstack); imp.close(); rgbimp.show(); IJ.run("Colors...", "foreground=yellow background=white selection=yellow"); for tidx in range(rgbimp.getNSlices()): rgbimp.setSlice(tidx+1); rgbimp.setRoi(membrane_edges[tidx]); IJ.run(rgbimp, "Draw", "slice"); IJ.run("Colors...", "foreground=red background=white selection=yellow"); for tidx in range(rgbimp.getNSlices()): rgbimp.setSlice(tidx+1); for anchor in params.manual_anchor_positions: rgbimp.setRoi(PointRoi(anchor[0], anchor[1])); IJ.run(rgbimp, "Draw", "slice"); params.saveParametersToJson(os.path.join(params.output_path, "parameters used.json")); params.persistParameters(); rgbimp.changes = False;
print "building roi list" manager = RoiManager.getInstance() if (manager == None): manager = RoiManager() RoiManager(False) #sho the roi manager window, wierd interface i = 1 for currPoint in pointList: #print "point " + str(i) x, y, z = currPoint.split(",") #composite is interleaved with ch1/ch2 #if doComposite==1: # z *= 2 #a point roi (This seems to be in pixels???) pROI = PointRoi(int(x), int(y), imp1) imp1.setSliceWithoutUpdate(int(z)) manager.add(imp1, pROI, int(z)) #add WITH slice, I want the pROI to be a 3D point #manager.addRoi(pROI) #add WITHOUT slice i += 1 print "added " + str(i) + " pnts to roi manager" if do3d == 1: #see: http://www.ini.uzh.ch/~acardona/fiji-tutorial/ ps = [] #list of Point3f (pointList) cps = [] #list of Point3f of connection points (cPointList) lps = [] #list of backbone centerline points (lPointList) cell_diameter = 3 #right now in pixels, eventually in um
def main(imp,options): from ij.plugin import ChannelSplitter from ij.gui import Roi,PointRoi, PolygonRoi, Overlay, Line from java.awt import Color from ij import WindowManager from ij.measure import ResultsTable from ij.text import TextWindow active_z=imp.getZ() imps = ChannelSplitter.split(imp) imp.setZ(active_z) roi_int = imp.getRoi() comp_imp=Zproj(imps[options["comp_ch"]], "SUM", active_z, options["z_range"]) comp_imp=mode_subtract(comp_imp,roi_int) loci_imp=Zproj(imps[options["loci_ch"]], "SUM", imp.getZ(), options["z_range"]) loci_imp=mode_subtract(loci_imp,roi_int) #Finding the boundaries of compartment and loci comp_roi=thresh(sum_prj=comp_imp,thresh=options["comp_T"],roi=roi_int,method="boundary") print "ok" if (options["loci_method"]== "locus center"): loci_roi=thresh(sum_prj=loci_imp, thresh=options["loci_T"], roi=roi_int, method="point") elif options["loci_method"]== "locus boundary": loci_roi=thresh(sum_prj=loci_imp, thresh=options["loci_T"], roi=roi_int, method="boundary") if options["loci_method"]== "locus center": dist,xc,yc,xl,yl=get_center_edge_dist(imp,comp_roi, loci_roi) elif options["loci_method"]== "locus boundary": dist,xc,yc,xl,yl=get_closest_points(imp,comp_roi,loci_roi) rt_exist = WindowManager.getWindow("Loci distance to compartment") if rt_exist==None or not isinstance(rt_exist, TextWindow): table= ResultsTable() else: table = rt_exist.getTextPanel().getOrCreateResultsTable() table.incrementCounter() table.addValue("Label", imp.title) table.addValue("Distance(micron)", dist) if options['measure_feret']: feret_roi,loci_feret,loci_area= feret(sum_prj=loci_imp,thresh=options["loci_T"], roi=roi_int,pixel_size=imp.getCalibration().pixelWidth) table.addValue("Loci feret", loci_feret) table.addValue("Loci area", loci_area) table.show("Loci distance to compartment") ## Adding loci overlay ov=imp.getOverlay() if ov==None: ov=Overlay() line = Line(xc,yc, xl,yl) line.setStrokeWidth(0.2) line.setStrokeColor(Color.PINK) ov.add(line) if options["loci_method"]== "locus center": ov.add(PointRoi(loci_roi["x"],loci_roi["y"])) elif options["loci_method"]== "locus boundary": ov.add(loci_roi) if options['measure_feret']: ov.add(feret_roi) ov.add(comp_roi) imp.setOverlay(ov)
for i in range(img.numDimensions())] # no calibration: identity sigmaSmaller = 15 # in pixels: a quarter of the radius of an embryo sigmaLarger = 30 # pixels: half the radius of an embryo extremaType = DogDetection.ExtremaType.MAXIMA minPeakValue = 10 normalizedMinPeakValue = False # In the differece of gaussian peak detection, the img acts as the interval # within which to look for peaks. The processing is done on the infinite imgE. dog = DogDetection(imgE, img, calibration, sigmaSmaller, sigmaLarger, extremaType, minPeakValue, normalizedMinPeakValue) peaks = dog.getSubpixelPeaks() # Create a PointRoi from the DoG peaks, for visualization roi = PointRoi(0, 0) # A temporary array of integers, one per dimension the image has p = zeros(img.numDimensions(), 'd') # Load every peak as a point in the PointRoi for peak in peaks: # Read peak coordinates into an array of integers peak.localize(p) roi.addPoint(imp, int(p[0]), int(p[1])) imp.setRoi(roi) # Now, iterate each peak, defining a small interval centered at each peak, # and measure the sum of total pixel intensity, # and display the results in an ImageJ ResultTable. table = ResultsTable()
One = Scalar(1.0) CorrMapInvCV = subtract(One, CorrMapCV).asMat() #CorrMapInv = MatToImProc(CorrMapInvCV) #CorrMapInv = ImagePlus("Inverted", CorrMapInv) #CorrMapInv.show() # Apply a "TO ZERO" threshold on the correlation map : to compensate the fact that maxima finder does not have a threshold argument # TO ZERO : below the threshold set to 0, above left untouched # NB : 1-score_threshold since we have inverted the image : we want to look for minima of value <x so we have to look for maxima of value>1-x in the inverted image CorrMapThreshCV = Mat() threshold(CorrMapInvCV, CorrMapThreshCV, 1 - score_threshold, 0, CV_THRESH_TOZERO) #CorrMapThreshImp = ImagePlus("Thresholded", CorrMapThresh) #CorrMapThreshImp.show() else: CorrMapThreshCV = Mat() threshold(CorrMapCV, CorrMapThreshCV, score_threshold, 0, CV_THRESH_TOZERO) # Display CorrMapThresh = MatToImProc( CorrMapThreshCV) # Keep this conversion, not only for visualisation CorrMapThreshImp = ImagePlus("Score Map - thresholded", CorrMapThresh) CorrMapThreshImp.show() ## For both cases (Multi-Min/Max-detection) detect maxima on the thresholded map excludeOnEdge = False # otherwise miss quite a lot of them tolerance = 0 Polygon = MaximumFinder().getMaxima(CorrMapThresh, tolerance, excludeOnEdge) roi = PointRoi(Polygon) CorrMapThreshImp.setRoi(roi)
def updatePointRoi(self): # Surround with try/except to prevent blocking # ImageJ's stack slice updater thread in case of error. try: # Update PointRoi self.imp.killRoi() points = self.nuclei[ self.imp.getSlice() - 1] # map 1-based slices to 0-based nuclei Z coords if 0 == len(points): IJ.log("No points for slice " + str(self.imp.getSlice())) return roi = PointRoi() # Style: large, red dots roi.setSize(4) # ranges 1-4 roi.setPointType(2) # 2 is a dot (filled circle) roi.setFillColor(Color.red) roi.setStrokeColor(Color.red) # Add points for point in points: # points are floats roi.addPoint(self.imp, int(point[0]), int(point[1])) self.imp.setRoi(roi) except: IJ.error(sys.exc_info())
def draw_centers(data): pathname = data[1] filename = data[2] platename = data[3] print data[4] nx = int(data[4]) ny = int(data[5]) nx_com = int(data[6]) ny_com = int(data[7]) ax = int(data[8]) ay = int(data[9]) orientation = 2*math.pi * float(data[10]) / 360.0 line_dy = int(round(math.atan(orientation) * LINE_DX)) ax2 = ax - LINE_DX ay2 = ay - line_dy orientation_avg = 2*math.pi * float(data[11]) / 360.0 line_dy = int(round(math.atan(orientation_avg) * LINE_DX)) ax3 = ax - LINE_DX ay3 = ay - line_dy imp = IJ.openImage(os.path.join(pathname,filename)) roi_nucleus = PointRoi(nx,ny) roi_nucleus.setDefaultMarkerSize("Large") roi_nucleus.setStrokeColor(Color.CYAN) roi_nucleus_com = PointRoi(nx_com,ny_com) roi_nucleus_com.setDefaultMarkerSize("Large") roi_nucleus_com.setStrokeColor(Color.GREEN) roi_anchor = PointRoi(ax,ay) roi_anchor.setDefaultMarkerSize("Large") imp.getProcessor().drawRoi(roi_nucleus) imp.getProcessor().drawRoi(roi_nucleus_com) imp.getProcessor().drawRoi(roi_anchor) imp.setColor(Color.RED) imp.getProcessor().drawLine(ax,ay,ax2,ay2) imp.setColor(Color.WHITE) imp.getProcessor().drawLine(ax,ay,ax3,ay3) IJ.saveAsTiff(imp,os.path.join(pathname,filename))
def processOneImage(inputDir): tmp = glob.glob(os.path.join(inputDir, "fibrone*")) fibronectin = tmp[0] tmp = glob.glob(os.path.join(inputDir, "nucleus*")) nucleus = tmp[0] tmp = glob.glob(os.path.join(inputDir, "actin*")) actin = tmp[0] # read sample name head,tail = os.path.split(inputDir) sample = tail.replace(".tif_Files","") # original images imp_fn_orig = IJ.openImage(fibronectin) imp_nuc_orig = IJ.openImage(nucleus) # work copies imp_fn = imp_fn_orig.duplicate() imp_nuc = imp_nuc_orig.duplicate() IJ.run(imp_fn,"Set Scale...", "distance=1 known=1 pixel=1 unit=pixels") IJ.run(imp_fn,"Gaussian Blur...","sigma=5") IJ.run(imp_fn,"Make Binary","") IJ.run(imp_nuc,"Set Scale...", "distance=1 known=1 pixel=1 unit=pixels") IJ.run(imp_nuc,"Gaussian Blur...","sigma=5") IJ.run(imp_nuc,"Make Binary","") # get moments of the fibronectin image moments_file = os.path.join(OUTPUT, sample + " moments.txt") printMoments(fibronectin, moments_file) moments = readMoments(moments_file) print moments.m00 sys.exit() # centroid of fibronectin anchor centers = getParticleCenters(imp_fn) cxfn = int(round(centers[0][0])) cyfn = int(round(centers[1][0])) fn_centroid_roi = PointRoi(cxfn,cyfn) fn_centroid_roi.setDefaultMarkerSize("Large") fn_centroid_roi.setStrokeColor(Color.CYAN) # center of mass of nucleus centers = getParticleCenters(imp_nuc) cxnuc = int(round(centers[2][0])) cynuc = int(round(centers[3][0])) nuc_com_roi = PointRoi(cxnuc,cynuc) nuc_com_roi.setDefaultMarkerSize("Large") # skeletonize fibronectin anchor to find its orientation IJ.run(imp_fn,"Skeletonize","") skel = AnalyzeSkeleton_() skel.setup("",imp_fn) skelResult = skel.run(skel.NONE, False, True, None, True, True) graph = skelResult.getGraph() print len(graph) print skelResult.getNumOfTrees() # find the longest graph graph = sorted(graph, key=lambda g: getGraphLength(g), reverse=True) graph = graph[0] edges = graph.getEdges() # find longest edge, the main axis of the anchor edges = sorted(edges, key=lambda edge: edge.getLength(), reverse=True) #for e in edges: # print e.getLength() v1long = edges[0].getV1() v2long = edges[0].getV2() x1 = v1long.getPoints()[0].x y1 = v1long.getPoints()[0].y x2 = v2long.getPoints()[0].x y2 = v2long.getPoints()[0].y anchor_roi = PointRoi(x1,y1) anchor_roi = anchor_roi.addPoint(x2,y2) # find top and bottom vertices of the graph vertices = graph.getVertices() vertices = sorted(vertices, key=lambda vertex: vertex.getPoints()[0].y) v1short = vertices[len(vertices)-1] v2short = vertices[0] x3 = v1short.getPoints()[0].x y3 = v1short.getPoints()[0].y x4 = v2short.getPoints()[0].x y4 = v2short.getPoints()[0].y anchor_roi = anchor_roi.addPoint(x3,y3) anchor_roi = anchor_roi.addPoint(x4,y4) # calculate angles a1 = math.atan(abs(float(y2-y1)/float(x2-x1))) / math.pi * 360 a2 = math.atan(abs(float(x4-x3)/float(y4-y3))) / math.pi * 360 amean = float((a1+a2)/2) dx = cxfn-cxnuc print sample,cxfn,cyfn,cxnuc,cynuc,dx,math.cos(amean)*dx,x1,y1,x2,y2,x3,y3,x4,y4,a1,a2 # create composite comp = ImagePlus("composite",imp_nuc_orig.getProcessor().convertToColorProcessor()) comp.getProcessor().setChannel(2,imp_fn_orig.getProcessor()) comp.getProcessor().setChannel(3,imp_fn.getProcessor()) comp.show() comp.getProcessor().drawRoi(fn_centroid_roi) comp.getProcessor().drawRoi(nuc_com_roi) comp.getProcessor().drawRoi(anchor_roi) comp.repaintWindow() IJ.saveAsTiff(comp, os.path.join(OUTPUT,sample + ".tif"))
print("%i regions/particles detected" % len(region_labels)) # Now use IJ1 RoiManager to display the detected regions rm = get_roi_manager(new=True) for label in region_labels: region = regions.getLabelRegion(label) # Get the center of mass of the region center = region.getCenterOfMass() x = center.getDoublePosition(0) y = center.getDoublePosition(1) roi = PointRoi(x, y) if center.numDimensions() >= 3: z = center.getDoublePosition(2) roi.setPosition(int(z)) rm.addRoi(roi) # You can also iterate over the `data` pixel by LabelRegion cursor = region.localizingCursor() dataRA = data.randomAccess() while cursor.hasNext(): cursor.fwd() dataRA.setPosition(cursor) x = cursor.getDoublePosition(0)
xmlfile = arg[0] ch = 1 #open xml file and parse it tree = ET.parse(xmlfile) root = tree.getroot() obj, imgName = getPosition(root) print imgName #open image img = BF.openImagePlus(imgName)[0] img.setZ(obj[1][2]+1) img.setC(int(ch)) img.show() #draw rois for i in range(1, len(obj)+1): PR = PointRoi(obj[i][0],obj[i][1]) try: PR.setSize(3) PR.setPointType(0) roim.addRoi(PR) except: roim.addRoi(PR) roim.runCommand('Show All with Labels')
def run(): IJ.run("Close All", "") IJ.log("\\Clear") IJ.log("Find_close_peaks") imp = IJ.run("Bio-Formats Importer") imp = IJ.getImage() Channel_1, Channel_2, radius_background, sigmaSmaller, sigmaLarger, minPeakValue, min_dist = getOptions() IJ.log("option used:" \ + "\n" + "channel 1:" + str(Channel_1) \ + "\n" + "channel 2:"+ str(Channel_2) \ + "\n" + "Radius Background:"+ str(radius_background) \ + "\n" + "Smaller Sigma:"+ str(sigmaSmaller) \ + "\n" + "Larger Sigma:"+str(sigmaLarger) \ + "\n" + "Min Peak Value:"+str(minPeakValue) \ + "\n" + "Min dist between peaks:"+str(min_dist)) IJ.log("Computing Max Intensity Projection") if imp.getDimensions()[3] > 1: imp_max = ZProjector.run(imp,"max") #imp_max = IJ.run("Z Project...", "projection=[Max Intensity]") #imp_max = IJ.getImage() else: imp_max = imp ip1, ip2 = extract_channel(imp_max, Channel_1, Channel_2) imp1, imp2 = back_substraction(ip1, ip2, radius_background) imp1.show() imp2.show() IJ.log("Finding Peaks") ip1_1, ip2_1, peaks_1, peaks_2 = find_peaks(imp1, imp2, sigmaSmaller, sigmaLarger, minPeakValue) # Create a PointRoi from the DoG peaks, for visualization roi_1 = PointRoi(0, 0) roi_2 = PointRoi(0, 0) roi_3 = PointRoi(0, 0) roi_4 = PointRoi(0, 0) # A temporary array of integers, one per dimension the image has p_1 = zeros(ip1_1.numDimensions(), 'i') p_2 = zeros(ip2_1.numDimensions(), 'i') # Load every peak as a point in the PointRoi for peak in peaks_1: # Read peak coordinates into an array of integers peak.localize(p_1) roi_1.addPoint(imp1, p_1[0], p_1[1]) for peak in peaks_2: # Read peak coordinates into an array of integers peak.localize(p_2) roi_2.addPoint(imp2, p_2[0], p_2[1]) # Chose minimum distance in pixel #min_dist = 20 for peak_1 in peaks_1: peak_1.localize(p_1) for peak_2 in peaks_2: peak_2.localize(p_2) d1 = distance(p_1, p_2) if d1 < min_dist: roi_3.addPoint(imp1, p_2[0], p_2[1]) break for peak_2 in peaks_2: peak_2.localize(p_2) for peak_1 in peaks_1: peak_1.localize(p_1) d2 = distance(p_2, p_1) if d2 < min_dist: roi_4.addPoint(imp1, p_2[0], p_2[1]) break rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.reset() rm.addRoi(roi_1) rm.addRoi(roi_2) rm.addRoi(roi_3) rm.addRoi(roi_4) rm.select(0) rm.rename(0, "ROI neuron") rm.runCommand("Set Color", "yellow") rm.select(1) rm.rename(1, "ROI glioma") rm.runCommand("Set Color", "blue") rm.select(2) rm.rename(2, "ROI glioma touching neurons") rm.runCommand("Set Color", "red") rm.select(3) rm.rename(3, "ROI neurons touching glioma") rm.runCommand("Set Color", "green") rm.runCommand(imp1, "Show All") #Change distance to be in um cal = imp.getCalibration() min_distance = str(round((cal.pixelWidth * min_dist),1)) table = ResultsTable() table.incrementCounter() table.addValue("Numbers of Neuron Markers", roi_1.getCount(0)) table.addValue("Numbers of Glioma Markers", roi_2.getCount(0)) table.addValue("Numbers of Glioma within %s um of Neurons" %(min_distance), roi_3.getCount(0)) table.addValue("Numbers of Neurons within %s um of Glioma" %(min_distance), roi_4.getCount(0)) table.show("Results Analysis")