def saveCroppedROIs(self, event): """ Duplicates cropped ROIs and saves """ # Create export dir, if not already present current_export_dir = self.createExportDir("Cropped_ROI") for Image in self.Images.values(): # for all Image instances # save image cropped_copy = Image.imp.crop() # returns cropped image as an imp img_filename = os.path.join(current_export_dir, Image.title) if os.path.splitext(img_filename)[1] != ".tif": os.path.join(img_filename, ".tif") FileSaver(cropped_copy).saveAsTiff(img_filename) # save roi roi_filename = os.path.splitext(img_filename)[0] + "_roi.roi" roi = Image.imp.getRoi() if roi != None: rm = RM.getInstance() if rm == None: rm = RM() rm.addRoi(roi) rm.runCommand("Save", roi_filename) # which one does it save rm.runCommand("Delete") IJ.log("Cropped ROI saved: " + os.path.join(current_export_dir, Image.title))
def measure_rm(img_path, roi_path): imp = IJ.openImage(img_path) img_dir = imp.getOriginalFileInfo().directory img_file = imp.getOriginalFileInfo().fileName ip = imp.getProcessor() cal = Calibration(imp) rm = RoiManager() rm = RoiManager.getInstance() rm.runCommand("Open", roi_path) roi_array = rm.getRoisAsArray() moptions = Measurements.MEAN | Measurements.AREA for roi in roi_array: roi_name = roi.getName() ip.setRoi(roi) stat = ImageStatistics.getStatistics(ip, moptions, cal) IJ.log(img_dir + "\t" + img_file + "\t" + roi_name + "\t" + str(stat.pixelCount) + "\t" + str(stat.pixelCount * stat.umean) + "\t" + str(stat.umean)) rm.runCommand("delete")
def measureTumor(original, locations): '''Returns the area from the original image with the highest kurtosis which generally corresponds to the most in focus image. Also saves an image corresponding to a mask of the measurement.''' # Prevent ROI manager from appearing roiM = RoiManager(True) ParticleAnalyzer.setRoiManager(roiM) # Locate particles above a minimum size and with a desired circularity IJ.run(locations, "Analyze Particles...", "size=" + str(minimumCancerArea) +"-" + str(maxCancerArea) +" circularity=" + str(circularityCutoff) + "-1.00 show=Nothing exclude add stack"); # Choose ROI with the highest kurtosis maxKurtosis = None area = None selectedROI = None for roi in roiM.getRoisAsArray(): original.setRoi(roi) stats = original.getStatistics(Measurements.KURTOSIS, Measurements.AREA) currentKurtosis = stats.kurtosis if currentKurtosis > maxKurtosis: maxKurtosis = stats.kurtosis area = stats.area selectedROI = roi original.killRoi() # Remove the remaining ROI roiM.runCommand("Reset") return (area, selectedROI)
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 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 readRois(path_): RoiManager().close() rm = RoiManager() if rm is not None: rm.getInstance() rm.runCommand("Open", path_) return rm
def resetpressed(event): self.__ranges.clear() self.__image=IJ.getImage() rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") self.__image.killRoi() IJ.setAutoThreshold(self.__image, "MaxEntropy") rt=ResultsTable() pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00) pa.analyze(self.__image) self.__roisArray=[] self.__roisArray=rm.getRoisAsArray() #rm.runCommand("Show All") #rm.runCommand("Select All") #rm.runCommand("Set Color", "blue") IJ.resetThreshold(self.__image) keys=self.__slidersDict.keys() for k in keys: if k.endswith("min"): self.__slidersDict[k].setValue(0) self.__slidersDict[k].repaint() else: self.__slidersDict[k].setValue(self.__slidersDict[k].getMaximum()) self.__slidersDict[k].repaint()
def cell_processor(imp_particles, imp_measure, folder, impname, channel_name): # Get ROI manager instance, save to zip rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.reset() imp_particles.show() # Wait for user to add ROIs to manager Prefs.multiPointMode = True pause = WaitForUserDialog( "Select ROIs of interest and add to manager \n \nPress OK to continue") pause.show() # get the ROI manager and save rm = RoiManager.getInstance() rm.runCommand("save selected", os.path.join(folder, impname + "_cells_ROIs.zip")) # select image to measure and show imp_measure.show() pixel_collector(rm, imp_measure, channel_name, impname, folder) return rm
def get_roi_manager(new=False): rm = RoiManager.getInstance() if not rm: rm = RoiManager() if new: rm.runCommand("Reset") return rm
def save_qcd_edges2(edges, output_folder, filename="user_defined_edges.zip"): """save edges as rois to a *.zip file""" roim = RoiManager(False) for edge in edges: if edge is not None: roim.addRoi(edge) roim.runCommand("Save", os.path.join(output_folder, filename)) roim.close()
def save_roi_set(imp=IJ.getImage()): img_dir, name = get_file_info() roi_dir = make_roi_dir(img_dir, name) roi_path = make_roi_path(roi_dir, name) rm = RoiManager().getInstance() rm.deselect() rm.runCommand("Save", roi_path) rm.runCommand("delete")
def save_cell_rois(rois, output_folder, filename): """save cell rois to a *.zip file""" roim = RoiManager(False) for roi in rois: if roi is not None: roim.addRoi(roi) roim.runCommand( "Save", os.path.join(output_folder, "{} cell rois.zip".format(filename))) roim.close()
def save_roi(directory, name, roi): """Saves ROI object in specific directory""" if roi is not None: rm = RoiManager(False) print roi.getName() roifile = path.join(directory, name+".zip") rm.addRoi(roi) rm.runCommand("Save", roifile) else: print "skipping saving ROI"
def particleRemover(image, minArea): '''Send in a thresholded image, remove the small spots''' numSlices = image.getImageStackSize() particleRoiM = RoiManager(True) ParticleAnalyzer.setRoiManager(particleRoiM) IJ.run(image, "Analyze Particles...", "size=0-" + str(minArea) + " circularity=0.00-1.00 include show=Nothing add stack"); # Set the fill color to black before filling IJ.setForegroundColor(0, 0, 0); particleRoiM.runCommand("Fill"); particleRoiM.runCommand("Reset");
def load_qcd_edges2(input_file_path): """load edges from roi *.zip file""" if os.path.isfile(input_file_path): roim = RoiManager(False) roim.runCommand("Open", input_file_path) edges = roim.getRoisAsArray() roim.close() else: edges = load_qcd_edges(os.path.splitext(input_file_path)[0] + '.json') return edges
def save_roi_set(imp): img_dir, name = get_file_info(imp) roi_path = make_roi_path(img_dir, name) rm = RoiManager().getInstance() rm.deselect() if roi_path is not None: rm.runCommand("Save",roi_path) rm.runCommand("delete")
def save_qc_image(imp, rois, output_path): """save rois overlaid on imp to output_path""" imp.killRoi() roim = RoiManager(False) for roi in rois: roim.addRoi(roi) roim.runCommand("Show All with labels") RGBStackConverter.convertToRGB(imp) roim.moveRoisToOverlay(imp) FileSaver(imp).saveAsTiff(output_path) roim.runCommand("Show None") roim.close()
def perform_manual_qc(imp, rois, important_channel=1): """given cell rois generated by automatic methods, allow user to delete/add/redraw as appropriate""" for ch in range(imp.getNChannels()): imp.setC(ch + 1) sat_frac = 0.99 if (ch + 1) == important_channel else 0.01 IJ.run(imp, "Enhance Contrast", "saturated={}".format(sat_frac)) imp.setC(important_channel) IJ.setTool("freehand") proceed = False roim = RoiManager() roim.runCommand("Show all with labels") for roi in rois: roim.addRoi(roi) auto_rois_only = rois while not proceed: dialog = NonBlockingGenericDialog("Perform manual segmentation") dialog.setOKLabel("Proceed to next image...") dialog.addMessage("Perform manual correction of segmentation: ") dialog.addMessage( "Draw around cells and add to the region of interest manager (Ctrl+T). " ) dialog.addMessage("Delete and redraw cells as appropriate. ") dialog.addMessage( "Then press \"proceed to next image\" when all cells have been added. " ) dialog.showDialog() if dialog.wasCanceled(): print("Manual segmentation canceled") return auto_rois_only elif dialog.wasOKed(): if roim.getCount() == 0: rois = [] confirm_dialog = GenericDialog("Continue?") confirm_dialog.addMessage( "No rois selected in this FOV. Are you sure you want to proceed?" ) confirm_dialog.setOKLabel("Yes, proceed") confirm_dialog.setCancelLabel("No, not yet") confirm_dialog.showDialog() if confirm_dialog.wasOKed(): proceed = True else: rois = roim.getRoisAsArray() proceed = True roim.reset() roim.close() for ch in range(imp.getNChannels()): imp.setC(ch + 1) IJ.run(imp, "Enhance Contrast", "saturated={}".format(0.35)) imp.setC(important_channel) return rois
def measureChannels(ROIset, imp, frameNumber): rm = RoiManager.getInstance() if not rm: rm = RoiManager() nChannels = imp.getNChannels() for channel in range(nChannels): target_imp = extractChannel(imp, channel + 1, frameNumber) target_imp.show() for roi in ROIset: rm.setSelectedIndexes([roi]) IJ.setAutoThreshold(target_imp, "Huang dark") rm.runCommand(target_imp, "Measure") target_imp.close()
def open_files_and_roi(filepath): imp=open_czi(filepath,2) imp.show() import os from ij.plugin.frame import RoiManager roifile = os.path.splitext(filepath)[0]+".zip" roim = RoiManager.getInstance() if(roim is None): roim = RoiManager() roim.reset() roim.runCommand("Open",roifile) print(roifile) return imp
def get_roi_manager(new=False): """ flexible ROI mgr handling, copied from Particles_From_Mask.py template in Fiji if new = True, a new blank mgr is returned if new = False (default) and the ROI manager is open, returns that mgr. if new = False and the ROI manager is NOT open, creates a new one without throwing an error """ rm = RoiManager.getInstance() if not rm: rm = RoiManager() if new: rm.runCommand("Reset") return rm
def generate_limit_labels(imp, limits, cb_fraction, params): """generate text ROIs in correct positions to label colorbar""" rois = [] w = imp.getWidth() h = imp.getHeight() txt_h_px = float(h) / 15 txt_sz_pt = int(round((18.0 / 24.0) * txt_h_px)) for limit in limits: roi = TextRoi(1, 1, str(round(limit, 3)), Font("SansSerif", Font.ITALIC, txt_sz_pt)) roi.setJustification(TextRoi.RIGHT) roi.setFillColor(Color.BLACK) roi.setStrokeColor(Color.WHITE) rois.append(roi) roim = RoiManager(False) roim.reset() imp.show() mbui.autoset_zoom(imp) for fridx in range(1, imp.getNSlices() + 1): imp.setPosition(fridx) roi_uu = rois[1].clone() xpos = w - cb_fraction * w - float(w) / 100 - rois[1].getFloatWidth() roi_uu.setLocation(xpos, 1) imp.setRoi(roi_uu) roim.addRoi(roi_uu) roi_ll = rois[0].clone() roi_ll.setLocation(xpos, h - rois[0].getFloatHeight()) imp.setRoi(roi_ll) roim.addRoi(roi_ll) roim.runCommand("Show All") FileSaver(imp).saveAsTiff( os.path.join(params.output_path, "overlaid curvature nudged labels.tif")) # nudge positions roim.reset() imp.killRoi() for fridx in range(1, imp.getNSlices() + 1): imp.setPosition(fridx) roi_uu = rois[1].clone() xpos = w - cb_fraction * w - float(w) / 100 roi_uu.setLocation(xpos, 1) imp.setRoi(roi_uu) roim.addRoi(roi_uu) roi_ll = rois[0].clone() roi_ll.setLocation(xpos, h - rois[0].getFloatHeight()) imp.setRoi(roi_ll) roim.addRoi(roi_ll) roim.runCommand("Show All") FileSaver(imp).saveAsTiff( os.path.join(params.output_path, "overlaid curvature.tif")) return imp
def save_all(srcDir, dstDir, filename, localfile, keepDirectories, imageID): saveDir = currentDir.replace(srcDir, dstDir) if keepDirectories else dstDir if not os.path.exists(saveDir): os.makedirs(saveDir) print "Saving to", saveDir IJ.selectWindow("Results for PA ") IJ.saveAs("Text", ""+saveDir+"\\"+localfile+".xls") IJ.selectWindow(imageID); imp=IJ.getImage() IJ.run("Duplicate...", "duplicate channels="+str(y)+"") #brightfield channel IJ.run("Z Project...", "projection=[Sum Slices]") rm= RoiManager(True) rm.runCommand("Show All without labels") rm.runCommand("Set Color", "red") rm.runCommand("Set Line Width", str(4)) imp=IJ.getImage() IJ.saveAs(imp,"Tiff", ""+saveDir+"\\"+localfile+"_OV.tif") rm.runCommand("Show None") IJ.saveAs(imp,"Tiff", ""+saveDir+"\\"+localfile+".tif") IJ.selectWindow("IMAGE") imp=IJ.getImage() IJ.saveAs(imp, "Tiff", os.path.join(saveDir, filename)) ROInumber = rm.getCount() if(ROInumber>0): RoiManager("Delete")
def analyzeTUB(): rm = RoiManager().getInstance() #Set imageJ preference meassurements to "area" IJ.run("Set Measurements...", "area display redirect=None decimal=3") #Variable used for iteration counter = 0 #Clear previous resuslts IJ.run("Clear Results") # Make library, to be iterated through. Room for improvement lis_dic = [{'path': sub[i]} for i in range(len(sub))] if not lis_dic: sys.exit('Did you check the right box?') # Calculate area of channel #1 (Calculation requires that area is chosen as measured value) for i in lis_dic: print i for p in data[counter][::-1]: print p if '_' + channel1 + '_' in p: imp1 = IJ.openImage(i['path'] + '/' + p) IJ.setThreshold(imp1, lowth1, 255) IJ.run(imp1, "Create Selection", "") roi = rm.getRoi(imp1) #rm.runCommand(imp1, 'Add') IJ.run(imp1, "Measure", "") if '_' + channel2 + '_' in p: imp2 = IJ.openImage(i['path'] + '/' + p) IJ.setThreshold(imp2, lowth2, 255) rm.runCommand(imp1, 'Select') IJ.run(imp2, "Analyze Particles...", "size=0-4000 summarize") counter += 1 # Reset counter counter = 0 IJ.renameResults(channel2)
def save_roi_set(imp=IJ.getImage()): img_dir, name = get_file_info() roi_dir = make_roi_dir(img_dir, name) roi_path = make_roi_path(roi_dir, name) Roi.setColor(Color.blue) rm = RoiManager().getInstance() rm.deselect() rm.runCommand("Save", roi_path) ol = imp.getOverlay() if ol is None: ol = Overlay() for roi in rm.getRoisAsArray(): ol.add(roi) imp.setOverlay(ol) rm.runCommand("delete") ol.setStrokeColor(Color.blue) Roi.setColor(Color.yellow)
def run(): roidir = '/Volumes/TRANSCEND/LauraLeopold/Rois/' maskdir = '/Volumes/TRANSCEND/LauraLeopold/Mask/' originaldir = '/Volumes/TRANSCEND/LauraLeopold/Original/' Raw_path = os.path.join(originaldir, '*tif') X = glob.glob(Raw_path) axes = 'YX' for fname in X: print(fname) IJ.open(fname) imp = IJ.getImage() Name = os.path.basename(os.path.splitext(fname)[0]) RoiName = roidir + Name + '.roi' Roi = IJ.open(RoiName) rm = RoiManager.getInstance() if (rm == None): rm = RoiManager() rm.addRoi(Roi) print(fname, RoiName) if not rm: print "Please first add some ROIs to the ROI Manager" return impMask = IJ.createImage("Mask", "8-bit grayscale-mode", imp.getWidth(), imp.getHeight(), imp.getNChannels(), imp.getNSlices(), imp.getNFrames()) IJ.setForegroundColor(255, 255, 255) rm.runCommand(impMask, "Deselect") rm.runCommand(impMask, "Fill") rm.runCommand('Delete') IJ.saveAs(impMask, '.tif', maskdir + Name) imp.close()
def run(): # ensure no other windows are open and clear resultstable IJ.run("Close All") IJ.run("Clear Results", "") #Ask user for file to be converted srcDir = IJ.getFilePath("Select file to analyse") if not srcDir: return #open file IJ.open(srcDir) dstDir = os.path.dirname(srcDir) print("dstDir = " + dstDir) #open ROI manager, save ROI names as labels in measurements rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.runCommand("UseNames", "true") # set parameters to be measured IJ.run("Set Measurements...", "area mean integrated limit display redirect=None decimal=3") FOVlist = WindowManager.getIDList() chnls = IJ.getString( "Please enter which channels you would like to analyse. Example: 123 analyses channels 1, 2 and 3", '123') for FOV in FOVlist: imp = WindowManager.getImage(FOV) IJ.run(imp, "Arrange Channels...", "new=" + chnls) imp.close() imp2 = WindowManager.getCurrentImage() imageTitle = WindowManager.getImage(FOV).getTitle() newDir = imageTitle + ' ROIs' dirPath = os.path.join(dstDir, newDir) if not os.path.exists(dirPath): try: os.makedirs(dirPath) except OSError as e: if e.errno != errno.EEXIST: raise # clear ROI list before analysis rm.runCommand(imp2, "Deselect") rm.runCommand(imp2, "Delete") TMdata, nFrames = runTrackMate(imp2) if TMdata: iterateCoords(TMdata, nFrames, dirPath, imp2) imp2.changes = 0 imp2.close() #relabel() resultsDir = os.path.splitext(srcDir)[0] + ".csv" #while os.path.exists(resultsDir): #resultsDir = resultsDir+"_1"+".csv" IJ.saveAs("Results", resultsDir)
def manual_analysis(imp, file_name, output_folder): """perform analysis based on manually drawn cells""" cal = imp.getCalibration() channel_imps = ChannelSplitter.split(imp) gfp_imp = channel_imps[0] IJ.setTool("freehand") proceed = False roim = RoiManager() roim.runCommand("Show all with labels") dialog = NonBlockingGenericDialog("Perform manual segmentation") dialog.setOKLabel("Proceed to next image...") dialog.addMessage("Perform manual segmentation: ") dialog.addMessage( "Draw around cells and add to the region of interest manager (Ctrl+T)") dialog.addMessage( "You can see what you've added so far if you check \"show all\" on the ROI manager" ) dialog.addMessage( "Then press \"proceed to next image\" when all cells have been added") dialog.showDialog() if dialog.wasCanceled(): raise KeyboardInterrupt("Run canceled") elif dialog.wasOKed(): rois = roim.getRoisAsArray() roim.reset() roim.close() out_stats = generate_cell_shape_results(rois, gfp_imp, cal, file_name) print("Number of cells identified = {}".format(len(out_stats))) # save output save_qc_image( imp, rois, "{}_plus_overlay.tiff".format( os.path.join(output_folder, os.path.splitext(file_name)[0]))) save_cell_rois(rois, output_folder, os.path.splitext(file_name)[0]) imp.changes = False imp.close() save_output_csv(out_stats, output_folder) return out_stats return None
def RoiSelection(): true=1 false=0 IJ.run("Invert", "stack"); IJ.run("Fill Holes", "stack"); IJ.run("Create Selection"); rm = RoiManager() rm.runCommand("add") rm.runCommand("split") #number_selected=rm.getCount() IJ.run("Select None"); rm.runCommand("deselect") #rm.select(0) #print number_selected roi_array=rm.getRoisAsArray() max_roi=None max_points=-1 for roi in roi_array: polygon=roi.getPolygon() if polygon is not None: number_of_points = polygon.npoints if max_points < number_of_points: max_points=number_of_points max_roi=roi #print max_points #sorted_roi_array=sorted(roi_array, key=methodcaller('getLength'), reverse=True) #length_array=[] #index=0 #for roi in roi_array: # index=index+1 # length_array.append((index,roi.getLength())) #sorted_length_array=sorted(length_array, key=itemgetter(0)) rm.runCommand("Select All") rm.runCommand("Delete") #for roi in roi_array: interpolated_polygon=max_roi.getInterpolatedPolygon(20,True) roi_polygon=PolygonRoi(interpolated_polygon,Roi.POLYGON) rm.addRoi(roi_polygon)
def AnalyzeParticle(IMP): rm = RoiManager().getInstance2() rt = ResultsTable() #再現性確保のために最終的には実装 #IJ.run("Set Measurements...","area centroid fit redirect=None decimal=3") #https://imagej.nih.gov/ij/developer/api/constant-values.html#ij.plugin.filter.ParticleAnalyzer.SHOW_RESULTS #表示オプション無し、resultは全部選択 PA = ParticleAnalyzer(0 , 1043199 , rt, 10000, 300000, 0.2, 1.0) PA.setRoiManager(rm) PA.analyze(IMP) #IJ.run(IMP, "Analyze Particles...", "display clear include add") rm.runCommand("Save", "C:/Users/For Programming/Documents/Python Scripts/OutletHDD/aaa.zip") rt.saveAs("C:/Users/For Programming/Documents/Python Scripts/OutletHDD/aaa.csv") #最後に全ての結果をCloseする。 #写真を先に消さないとバグる。 IMP.close() rm.close() rt.reset()
def process(srcDir, dstDir, currentDir, fileName, keepDirectories): print "Processing:" ROIpath, V1S1RL = os.path.split(currentDir) # Opening the image print "Open image file", fileName imp = IJ.openImage(os.path.join(currentDir, fileName)) imp.show() print "Compute F/F0" IJ.run(imp, "F div F0", "6") imp.close() V1S1RL = "RoiSet " + V1S1RL + ".zip" # Put your processing commands here! ROIPath = ROIpath + "/" + V1S1RL print "Open ROIS", ROIPath rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.reset() rm.runCommand("open", ROIPath) rm.runCommand("Show All") print "Multi Measure" imp = IJ.getImage() rt = rm.multiMeasure(imp) imp.close() imp = IJ.getImage() imp.close() # Saving the image saveDir = currentDir.replace(srcDir, dstDir) if keepDirectories else dstDir if not os.path.exists(saveDir): os.makedirs(saveDir) print "Saving to", saveDir rt.save(os.path.join(saveDir, fileName + '.csv')) # IJ.saveAs(imp, "Tiff", os.path.join(saveDir, fileName)); imp.close()
def main(parentpath, cellNo): rootname = "cell" + str(cellNo) roizipname = 'RoiSet_' + rootname + '.zip' imagename = rootname + '_virus_median.tif' #pp = '/Users/miura/Desktop/161122 ctrl croped and 16 frames/RoiSet_cell5.zip' # unzipping http://stackoverflow.com/questions/3451111/unzipping-files-in-python #pp = '/Users/miura/Desktop/161122 ctrl croped and 16 frames/RoiSet_cell5/0005-0419-0327.roi' zippp = os.path.join(parentpath, roizipname) rm = RoiManager(False) rm.runCommand("Open", zippp) cellroi = rm.getRoi(2) if cellroi.getType() != 3: print "ROI type mismatch! ... ABORT" sys.exit() #imagepath = '/Users/miura/Desktop/161122 ctrl croped and 16 frames/cell1_virus_median.tif' imagepath = os.path.join(parentpath, imagename) tracks, cellarea, postcounts, postcounts2, precounts, imp, reallength, secondFrameVirusCounts = core(cellroi, imagepath) return tracks, cellarea, postcounts, postcounts2, precounts, imp, reallength, secondFrameVirusCounts
def makeCell(cellfile) : filetemp = open(cellfile,"r") linestemp=filetemp.readlines() for line in linestemp : params=line.split("=") values=params[1].split("\n") if params[0] == "NAMECELL" : celltemp=Bacteria_Cell(str(values[0])) if params[0] == "PATHROIS" : pathtemp = str(values[0]) if params[0] == "NSLICES" : for i in range(int(values[0])) : celltemp.getListRoi().append("") if params[0] == "SLICEINIT" : celltemp.setSlideInit(int(values[0])) #for i in range(int(values[0])-2) : # celltemp.setRoi("NOT HERE YET",i) if params[0] == "SLICEEND" : celltemp.setSlideEnd(int(values[0])) #for i in range(int(values[0])) : # celltemp.setRoi("LOST",i) if params[0] == "COLOR" : colorstemp=values[0].split(";") celltemp.setColor(Color(int(colorstemp[0]),int(colorstemp[1]),int(colorstemp[2]))) rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") rm.runCommand("Open", pathtemp) rois=rm.getSelectedRoisAsArray() celltemp.setlistRois(rois) rm.runCommand("UseNames", "true") rm.runCommand("Associate", "true") return celltemp
def roiprocess(imp, filename): # get the ROI manager instance rm = RoiManager.getInstance() if rm is None: rm = RoiManager() rm.runCommand(imp, "Select All") # rm.runCommand("Deselect"); # deselect ROIs to save them all rm.runCommand(imp, 'Show All') # define the path to save the rois as azip file roisavelocation = os.path.splitext(filename)[0] + '_RoiSet.zip' # log.info('ROISs saved: ' + roisavelocation) # print('ROIs saved: ', roisavelocation) rm.runCommand("Save", roisavelocation) return roisavelocation
def __calRois(self, imp, indice) : """ Returns the ROIs of a slice given (identified with its n°) in a stack """ ##imp=self.__dictImages[nameimages] # IL FAUT RÉCUPÉRER L'IMAGE DU STACK !!!!! #if self.__batch : imp.hide() #else : imp.show() #imp.hide() imp.show() if self.__batch : imp.hide() imp.setSlice(indice) imp.killRoi() ip = imp.getProcessor() bs=BackgroundSubtracter() #if str(self.__subback) == "0" or str(self.__subback) == "1" : self.__subback = bool(int(self.__subback)) #if self.__subback == True : IJ.run(imp, "Subtract Background...", "rolling="+str(self.__radius)+" light") if self.__subback == True : bs.rollingBallBackground(ip, self.__radius, False, True, False, True, False) if self.__runmacro : imp.show() imp.setSlice(indice) imp.updateAndDraw() IJ.runMacroFile(self.__macropath, imp.getTitle()) imp.updateAndDraw() #if str(self.__manthresh) == "0" or str(self.__manthresh) == "1" : self.__manthresh = bool(int(self.__manthresh)) #if self.__manthresh : IJ.setThreshold(imp, self.__minthr, self.__maxthr) if self.__manthresh : ip.setThreshold(self.__minthr, self.__maxthr, ImageProcessor.RED_LUT) else : self.__setThreshold(imp, indice) rt=ResultsTable() pa1=ParticleAnalyzer(ParticleAnalyzer.SHOW_MASKS+ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES , Measurements.AREA, rt, self.__minArea, self.__maxArea, self.__minCirc, self.__maxCirc) pa1.setHideOutputImage(True) pa1.analyze(imp) masks=pa1.getOutputImage() masks.getProcessor().erode() masks.getProcessor().dilate() masks.getProcessor().invertLut() masks.getProcessor().threshold(1) rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") #rm.hide() pa2=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET+ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES , Measurements.AREA, rt, self.__minArea, self.__maxArea, self.__minCirc, self.__maxCirc) pa2.analyze(masks) masks.close() temparray=rm.getRoisAsArray() for r in temparray : tempnameroi=r.getName() r.setPosition(indice) r.setName(str(indice)+"-"+tempnameroi) r.setStrokeWidth(1) if len(self.__params) > 0 : for k in self.__params: #if k[0]=="Area": self.__minArea, self.__maxArea = str(k[1]), str(k[2]) if k[0]=="Area": self.__minArea, self.__maxArea = k[1], k[2] for k in self.__params: #if k[0]=="Circ": self.__minCirc, self.__maxCirc = str(k[1]), str(k[2]) if (k[0]=="Circ") and k[3] : self.__minCirc, self.__maxCirc = k[1], k[2] else : self.__minCirc, self.__maxCirc = 0, 1 self.__rr.setRoisarray(temparray, imp) self.__rr.setRange(indice, self.__params) return self.__rr.includeRois else : return temparray
def runOnFile(self, afile, show = True, jobnr = None): afile = str(afile) if afile == '' or afile is None: od = OpenDialog("Choose image file", None) if od.getFileName() == None: return afile = os.path.join(od.getDirectory(), od.getFileName()) if '.log' in afile: return try: zk = ZeissKeys() msg = Message() print "Hi" if self.jobs is None: IJ.showMessage("You need to first set the parameters") if all([job['pip']=='None' for job in self.jobs]): IJ.showMessage("Nothing to do! At least on job different than None") return 0 #create a copy otherwise self.jobs gets overwritten jobs = copy.deepcopy(self.jobs) random.seed() #create a roiManager in case one is missing and reset it roim = RoiManager.getInstance() if roim == None: roim = RoiManager() roim.runCommand("reset") for i, job in enumerate(self.jobs): jobl = job #not really necessary if jobl['pip'] == 'None': continue self.JOBS_DICT[jobl['pip']] + jobl['task'] + "_" if jobnr is not None: if jobnr == i: #force opening imageDef = self.openFile(afile, self.getPrefix(self.JOBS_DICT[jobl['pip']], jobl['task']), 1) else: continue else: imageDef = self.openFile(afile, self.getPrefix(self.JOBS_DICT[jobl['pip']], jobl['task'])) print imageDef jobl['channel'] = int(jobl['channel']) if imageDef is None: continue #clean up registry for errors IJ.log("Clean up errorMsg registry") IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_errormsg+" value=[""] windows=REG_SZ") [imageC, pixelSize, filepath, filename] = imageDef if jobl['channel'] > len(imageC): raise IOError('Expecting at least ' + str(jobl['channel']) + ' channels. Image has only ' + str(len(imageC)) + ' channel(s)') self.rois = [None]*self.nrOfJobs self.Segs = [None]*self.nrOfJobs self.Procs = [None]*self.nrOfJobs #switch color to Cyan for better visibility IJ.run(imageC[jobl['channel']-1], "Cyan", "") #segment self.Procs[i], self.Segs[i], validParticles, self.rois[i] = segmentChannel_Weka(imageC, **jobl) if validParticles is None: IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+msg.CODE_NOTHING+"] windows=REG_SZ") #write values to registry try: executeTask_Weka(validParticles, **jobl) except Exception, err: self.exitWithError(str(err)) return if self.rois[i] is None: imageC[jobl['channel']-1].show() self.Segs[i].show() self.Procs[i].show() continue if validParticles is None: particle = [] else: particle = [part[0] for part in validParticles] imgOut = autTool.createOutputImg(imageC[jobl['channel']-1], self.rois[i], particle) imgOut.show() self.saveOutputImg(imgOut, filepath, i+1) IJ.run("Collect Garbage", "")
def analyzeParticles(imp, minsize, maxsize, mincirc, maxcirc, #filename='Test.czi', addROIManager=False, #headless=False, exclude=True): if GraphicsEnvironment.isHeadless(): print('Headless Mode detected. Do not use ROI Manager.') addROIManager = False if addROIManager: # get the ROI manager instance rm = RoiManager.getInstance() if rm is None: rm = RoiManager() rm.runCommand("Associate", "true") if not exclude: options = PA.SHOW_ROI_MASKS \ + PA.SHOW_RESULTS \ + PA.DISPLAY_SUMMARY \ + PA.ADD_TO_MANAGER \ + PA.ADD_TO_OVERLAY \ if exclude: options = PA.SHOW_ROI_MASKS \ + PA.SHOW_RESULTS \ + PA.DISPLAY_SUMMARY \ + PA.ADD_TO_MANAGER \ + PA.ADD_TO_OVERLAY \ + PA.EXCLUDE_EDGE_PARTICLES if not addROIManager: if not exclude: options = PA.SHOW_ROI_MASKS \ + PA.SHOW_RESULTS \ + PA.DISPLAY_SUMMARY \ + PA.ADD_TO_OVERLAY \ if exclude: options = PA.SHOW_ROI_MASKS \ + PA.SHOW_RESULTS \ + PA.DISPLAY_SUMMARY \ + PA.ADD_TO_OVERLAY \ + PA.EXCLUDE_EDGE_PARTICLES measurements = PA.STACK_POSITION \ + PA.LABELS \ + PA.AREA \ + PA.RECT \ + PA.PERIMETER \ + PA.SLICE \ + PA.SHAPE_DESCRIPTORS \ + PA.CENTER_OF_MASS \ + PA.CENTROID results = ResultsTable() p = PA(options, measurements, results, minsize, maxsize, mincirc, maxcirc) p.setHideOutputImage(True) particlestack = ImageStack(imp.getWidth(), imp.getHeight()) for i in range(imp.getStackSize()): imp.setSliceWithoutUpdate(i + 1) ip = imp.getProcessor() # convert to a mask for the particle analyzer ip.invert() # do the particle analysis p.analyze(imp, ip) mmap = p.getOutputImage() # add the slide to the full stack particlestack.addSlice(mmap.getProcessor()) return particlestack, results
from ij.plugin.frame import RoiManager from operator import itemgetter, attrgetter from ij.gui import PolygonRoi, Roi true=1 false=0 IJ.run("Invert", "stack"); IJ.run("Fill Holes", "stack"); IJ.run("Create Selection"); rm = RoiManager() rm.runCommand("add") rm.runCommand("split") #number_selected=rm.getCount() IJ.run("Select None"); rm.runCommand("deselect") #rm.select(0) #print number_selected roi_array=rm.getRoisAsArray() max_roi=None max_points=-1 for roi in roi_array: polygon=roi.getPolygon() if polygon is not None: number_of_points = polygon.npoints if max_points < number_of_points: max_points=number_of_points max_roi=roi #print max_points #sorted_roi_array=sorted(roi_array, key=methodcaller('getLength'), reverse=True) #length_array=[] #index=0
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+kwargs['command']+"] windows=REG_SZ") return validParticles test = 0 if test ==0: locDialogParameters('Weka_Metaphase_Detection') if test ==1 : IJ.run("Close All", ""); roim = RoiManager.getInstance() if roim == None: roim = RoiManager() roim.runCommand("reset"); imagePath = r"C:\Users\toni\Code\AutomatedMicroscopy\IJMacros\WekaPipeline\TestImage_1024.tif" imp = IJ.openImage(imagePath) imp.show() kwargs={'pip':'Default', 'task':1, 'channel':1, 'command':"trigger1", 'clspath':"C:\\Users\\toni\\Code\\AutomatedMicroscopy\\IJMacros\\WekaPipeline\\classifier.model", 'nrPart':3, 'Min Intensity':0.8, 'maxCirc': 0.8, 'probThr':0.6} procs, segs, validParticles, rois = segmentChannel_Weka([imp], **kwargs) executeTask_Weka(validParticles, **kwargs) particle = [part[0] for part in validParticles] print particle imgOut = autTool.createOutputImg(imp, rois, particle)
def __ImportCells(self, imagesnames) : #self.__dictCells[imgName]={} rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") listpaths = [] listfilescells=[] if self.__optionImages : IJ.showMessage("Select the folder 'Cells' containing the cells to import") selectdir=IJ.getDirectory("image") selectdir=IJ.getDirectory("") listfilescells.extend(glob.glob(selectdir+os.path.sep+"*")) listpaths.append("") else : IJ.showMessage("Select the text file containing the list cell paths (listpaths.txt)") selectdir=IJ.getDirectory("current") frame = Frame("Text file settings ?") fd = FileDialog(frame) fd.setDirectory(selectdir) fd.show() selectdir = fd.getDirectory() textfile = fd.getFile() fichier = open(selectdir+textfile,"r") listpaths=[ glob.glob(f.split("\n")[0]+"Selected-Cells"+os.path.sep+"*") for f in fichier.readlines()] #for f in templist : # listpaths.append(f.split("\n")+"Cells") listfilescells.append("") if listfilescells[0]=="" : importmode = True else : importmode = False for j in range(len(listpaths)) : self.__dictCells[imagesnames[j]]={} if importmode : listfilescells = listpaths[j] pathtemp = [] for cellfile in listfilescells : filetemp = open(cellfile,"r") linestemp=filetemp.readlines() for line in linestemp : params=line.split("=") values=params[1].split("\n") if params[0] == "NAMECELL" : celltemp=Bacteria_Cell(str(values[0])) self.__dictCells[imagesnames[j]][values[0]]=celltemp self.__dictMeasures[self.__dictCells[imagesnames[j]][values[0]]]={} if params[0] == "PATHROIS" : pathtemp.append(str(values[0])) if params[0] == "NSLICES" : for i in range(int(values[0])) : celltemp.getListRoi().append("") if params[0] == "SLICEINIT" : celltemp.setSlideInit(int(values[0])) for i in range(int(values[0])-2) : celltemp.setRoi("NOT HERE YET",i) if params[0] == "SLICEEND" : celltemp.setSlideEnd(int(values[0])) for i in range(int(values[0])) : celltemp.setRoi("LOST",i) if params[0] == "COLOR" : colorstemp=values[0].split(";") celltemp.setColor(Color(int(colorstemp[0]),int(colorstemp[1]),int(colorstemp[2]))) indiceroi=0 ind=0 tempimp = WindowManager.getImage(imagesnames[j]) if tempimp is not None : IJ.selectWindow(imagesnames[j]) tempimp.show() else : if imagesnames[j][-4:]==".tif" : IJ.selectWindow(imagesnames[j][:-4]) tempimp = IJ.getImage() else : IJ.selectWindow(imagesnames[j]+".tif") tempimp = IJ.getImage() rm.runCommand("reset") for cellname in self.__dictCells[imagesnames[j]].keys() : rm.runCommand("Open", pathtemp[ind]) ind+=1 nbtemp=self.__dictCells[imagesnames[j]][cellname].getLifeTime() for i in range(nbtemp) : rm.select(tempimp, indiceroi) roi=rm.getSelectedRoisAsArray()[0] self.__dictCells[imagesnames[j]][cellname].setRoi(roi,i+self.__dictCells[imagesnames[j]][cellname].getSlideInit()-1) indiceroi+=1 IJ.run("Show Overlay", "") rm.runCommand("UseNames", "true") rm.runCommand("Associate", "true") IJ.run(tempimp, "Labels...", "color=red font=12 show use") if rm.getCount()>0 : IJ.run(tempimp, "From ROI Manager", "") rm.runCommand("Show None") rm.runCommand("Show All") roipath = os.path.split(pathtemp[0])[0]+os.path.sep rootpath = roipath.rsplit(os.path.sep, 2)[0]+os.path.sep self.__listpaths[j] = rootpath self.__rootpath=rootpath
odref = OpenDialog("Choose a reference image file", None) reffn = odref.getFileName() if reffn is None: print "User canceled the dialog!" else: refdir = odref.getDirectory() refpath = os.path.join(refdir, reffn) refImp = IJ.openImage(refpath) width = refImp.width height = refImp.height roim = RoiManager() roim.runCommand("open", roipath) roiArray = roim.getRoisAsArray() nRoi = len(roiArray) roim.close() bwStack = ImageStack(width, height, nRoi) for i in xrange(1, nRoi+1): bwStack.setProcessor(FloatProcessor(width, height, zeros('f', width * height), None), i) for i in xrange(1, nRoi+1): roi = roiArray[i-1] fp = bwStack.getProcessor(i) fp.setValue(1.0) fp.fill(roi)
def updatepressed(event): self.__image=IJ.getImage() rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") self.__image.killRoi() IJ.run("Threshold...") IJ.setAutoThreshold(self.__image, "MaxEntropy") rt=ResultsTable() pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00) pa.analyze(self.__image) self.__roisArray=[] self.__roisArray=rm.getRoisAsArray() #for i in range(rm.getCount()) : # rm.select(i) # rm.runCommand("Set Color", "0000FF", 2) IJ.resetThreshold(self.__image) rt.show("tempRT") areas=rt.getColumn(ResultsTable.AREA) means=rt.getColumn(ResultsTable.MEAN) majors=rt.getColumn(ResultsTable.MAJOR) minors=rt.getColumn(ResultsTable.MINOR) #print 0 if self.__slidersDict["Area_max"].getMaximum() < int(max(areas)+1): # print 1 self.__slidersDict["Area_max"].setMaximum(int(max(areas))+1) if self.__slidersDict["Area_min"].getMaximum() < int(max(areas)+1): # print 2 self.__slidersDict["Area_min"].setMaximum(int(max(areas))+1) if self.__slidersDict["Mean_max"].getMaximum() < int(max(means)+1): # print 3 self.__slidersDict["Mean_max"].setMaximum(int(max(means))+1) if self.__slidersDict["Mean_min"].getMaximum() < int(max(means)+1): # print 4 self.__slidersDict["Mean_min"].setMaximum(int(max(means))+1) if self.__slidersDict["Major_max"].getMaximum() < int(max(majors)): # print 5 self.__slidersDict["Major_max"].setMaximum(int(max(majors))+1) if self.__slidersDict["Major_min"].getMaximum() < int(max(majors)+1): # print 6 self.__slidersDict["Major_min"].setMaximum(int(max(majors))+1) if self.__slidersDict["Minor_max"].getMaximum() < int(max(minors)+1): # print 7 self.__slidersDict["Minor_max"].setMaximum(int(max(minors))+1) if self.__slidersDict["Minor_min"].getMaximum() < int(max(minors)+1): # print 8 self.__slidersDict["Minor_min"].setMaximum(int(max(minors))+1) if self.__slidersDict["AR_max"].getMaximum() < int((max(majors)+1)/min(minors)+1): # print 9 self.__slidersDict["AR_max"].setMaximum(int((max(majors)+1)/(min(minors)))) if self.__slidersDict["AR_min"].getMaximum() < int((max(majors)+1)/min(minors)): # print 10 self.__slidersDict["AR_min"].setMaximum(int((max(majors)+1)/(min(minors)))) #print 11 for sb in self.__slidersDict.values(): sb.repaint() #rm.runCommand("reset") #temprois=self.getIncludeRois() #IJ.run(self.__image, "Remove Overlay", "") #o=Overlay() #for roi in temprois: # o.addElement(roi) #self.__image.killRoi() #self.__image.setOverlay(o) self.__image.updateAndDraw()
def __settings(self, imgName) : """ Lets the user to choose different measures to make, and displays it following the choice of the user. """ try : dico=self.__dictCells[imgName] except KeyError : try : dico=self.__dictCells[imgName[:-4]] except KeyError : return False else : imgName=imgName[:-4] dico=self.__dictCells[imgName] for cellname in dico.keys() : self.__dictMeasures[dico[cellname]]={} # Represents the datas on a diagram def diagrambuttonPressed(event) : IJ.showMessage("Push 'Auto' button each time you want to see the diagram") x1=10 y1=20 x2=100 y2=50 x3=60 y3=30 xr=10 yr=20 wr=20 hr=20 rect=Rectangle(xr,yr,wr,hr) #img=IJ.getImage() #nbslices=self.__img.getImageStackSize() nbslices=self.__maxLife IJ.run("Hyperstack...", "title=Diagram type=32-bit display=Color width="+str(x2+(nbslices+1)*x3)+" height="+str(y2+y3*len(dico))+" channels=1 slices="+str(len(self.__measures))+" frames=1") im=IJ.getImage() ip=im.getProcessor() for i in range(len(self.__measures)) : indiceligne=0 maxvalue=0 minvalue=1000000 im.setPosition(1,i+1,1) for cellname in self.__listcellname : indiceligne+=1 for indicecolonne in range(1,nbslices+1): rect.setLocation(x2+indicecolonne*x3+int(x3/6),(y1+indiceligne*y3-int(y3/2))) # we create at the first iteration a dictionary with the rectangles (for a future use) if i==0 : self.__gridrectangle[(indiceligne,indicecolonne)]=Rectangle(rect) im.setRoi(rect) ipr=im.getProcessor() # we find the min and max values of the datas for a measure given. if self.__dictMeasures[dico[cellname]][self.__measures[i]][indicecolonne-1]>maxvalue : maxvalue=self.__dictMeasures[dico[cellname]][self.__measures[i]][indicecolonne-1] if self.__dictMeasures[dico[cellname]][self.__measures[i]][indicecolonne-1]<minvalue : minvalue=self.__dictMeasures[dico[cellname]][self.__measures[i]][indicecolonne-1] # we fill the rectangle with the value of the measure ipr.setValue(self.__dictMeasures[dico[cellname]][self.__measures[i]][indicecolonne-1]) ipr.fill() # we write the names and the n of slices on the image with the maxvalue. ip.setValue(maxvalue) ip.moveTo(x1,y1) ip.drawString(self.__measures[i]) for j in range(1,nbslices+1) : ip.moveTo(x2+j*x3,y1) ip.drawString("Slice "+str(j)) j=0 for cellname in self.__listcellname : ip.moveTo(x1,y2+j*y3) ip.drawString(cellname) j+=1 im.killRoi() im=IJ.run(im,"Fire","") IJ.run("Brightness/Contrast...", "") #im.setMinAndMax(minvalue,maxvalue) #im.updateImage() #we add a mouse listener in order to be able to show the roi corresponding to a rectangle when the user clicks on it. listener = ML() listener.name=imgName for imp in map(WindowManager.getImage, WindowManager.getIDList()): if imp.getTitle().startswith("Diagram") : win = imp.getWindow() if win is None: continue win.getCanvas().addMouseListener(listener) # Represents the datas on a series of graphs. def graphbuttonPressed(event) : colors=[] #img=IJ.getImage() #nbslices=self.__img.getImageStackSize() nbslices=self.__maxLife acell=dico.values()[0] if self.__useTime : x = acell.getListTimes() namex="Time sec" else : x = range(1,nbslices+1) namex = "Frame" maxx=max(x) minx=min(x) #x=[i for i in range(1,nbslices+1)] font=Font("new", Font.BOLD, 14) tempname = WindowManager.getUniqueName(self.__img.getShortTitle()) for i in range(len(self.__measures)) : #print "i", i, self.__measures[i] yarray=[] flag=True miny=10000000000 maxy=-1000000000 #we find the min and max values in order to set the scale. for cellname in self.__listcellname : colors.append(dico[cellname].getColor()) yarray.append(self.__dictMeasures[dico[cellname]][self.__measures[i]]) #for meas in self.__dictMeasures[dico[cellname]][self.__measures[i]] : for meas in yarray[-1] : if (meas<miny) and (Double.isNaN(meas)==False) : miny=meas if max(yarray[-1])>maxy : maxy=max(yarray[-1]) miny-=0.1*miny maxy+=0.1*maxy count=0.05 for j in range(len(yarray)) : if j==0 : if len(self.__measures)>1 : plot=Plot("Plots-"+str(self.__measures[i]),namex,str(self.__measures[i]),x,yarray[j]) else : plot=Plot("Plot-"+tempname,namex,str(self.__measures[i]),x,yarray[j]) plot.setLimits(minx,maxx,miny,maxy) plot.setColor(colors[j]) plot.changeFont(font) plot.addLabel(0.05, count, self.__listcellname[j]) else : plot.setColor(colors[j]) plot.setLineWidth(3) plot.addPoints(x,yarray[j],Plot.LINE) plot.addLabel(0.05, count, self.__listcellname[j]) count+=0.05 plot.setColor(colors[0]) plot.show() if len(self.__measures)>1 : IJ.run("Images to Stack", "name="+tempname+"-plots title=Plots- use") #def histbuttonPressed(event) : # # pass # Represents the values in a tab. def tabbuttonPressed(event) : tab="\t" headings=[] measures=[] #img=IJ.getImage() #for i in range(self.__img.getImageStackSize()+1) : for i in range(self.__maxLife+1) : headings.append("Slice "+str(i)) headings[0]=WindowManager.getUniqueName(self.__img.getShortTitle()) #for m in self.__measurescompl : for m in self.__dictMeasures[dico[self.__listcellname[0]]].keys() : headstring="" for head in headings: headstring+=head+tab tw=TextWindow(self.__listfiles[0]+"-"+m,headstring,"",800,600) tp=tw.getTextPanel() #for cellname in dico.keys() : for cellname in self.__listcellname : line=[] line=[str(meas)+tab for meas in self.__dictMeasures[dico[cellname]][m]] line.insert(0, cellname+tab) linestr="" for s in line: linestr+=s tp.appendLine(linestr) tp.updateDisplay() if self.__measuresparambool_global[0] : tw=TextWindow("Latency","cell\tLatency", "",800,600) tp=tw.getTextPanel() for i in range(len(self.__listcellname)) : #if latencies[i][0] : line=self.__listcellname[i]+"\t"+str(latencies[i][1]) #else : line=self.__listcellname[i]+"\t"+"NaN" line=self.__listcellname[i]+"\t"+str(latencies[i][1]) tp.appendLine(line) tp.updateDisplay() def helpbuttonPressed(event) : IJ.showMessage("TO DO") def newsetPressed(event) : gd0.dispose() self.__settings() def alignbuttonPressed(event) : IJ.showMessage("TO DO") def mergebuttonPressed(event) : IJ.showMessage("TO DO") def saveResults() : #if len(self.__listcellname) == 0 : nbslices=self.__maxLife acell=dico.values()[0] if self.__useTime : x = acell.getListTimes() namex="Time_sec" else : x = range(1,nbslices+1) namex = "Frame" if not path.exists(self.__rootpath+"Results"+os.path.sep) : os.makedirs(self.__rootpath+os.path.sep+"Results"+os.path.sep, mode=0777) tab="\t" nl="\n" measures=[] headstring="" #if self.__savemode : mode = "a" #else : mode ="w" mode = "a" #for i in range(1, self.__maxLife+1) :headstring += "Slice_"+str(i)+tab for i in range(self.__maxLife) :headstring += str(x[i])+tab #for m in self.__measurescompl : for m in self.__dictMeasures[dico[self.__listcellname[0]]].keys() : f = open(self.__rootpath+"Results"+os.path.sep+m+".txt", mode) #f.write(m+nl) f.write(imgName+"-"+self.__time+"-"+m+"-"+namex+tab+headstring+nl) if len(self.__listcellname) == 0 : f.write("no cells") else : for cellname in self.__listcellname : linestr=cellname+tab for measure in self.__dictMeasures[dico[cellname]][m] : #print m, cellname, measure linestr += str(measure)+tab linestr+=nl f.write(linestr) f.close() if self.__measuresparambool_global[0] : m = "Latency" f = open(self.__rootpath+"Results"+os.path.sep+m+".txt", mode) f.write(imgName+"-"+self.__time+"-"+m+nl) for i in range(len(self.__listcellname)) : #if latencies[i][0] : line=self.__listcellname[i]+"\t"+str(latencies[i][1]) #else : line=self.__listcellname[i]+"\t"+"NaN" line=self.__listcellname[i]+"\t"+str(latencies[i][1]) line+=nl f.write(line) f.close() # # ----------- main measures dialog ------------------------- # # Allows the user to choose the measures to make, etc.. measureslabels_indep=["MaxFeret","MinFeret","AngleFeret","XFeret","YFeret","Area","Angle","Major","Minor","Solidity","AR","Round","Circ","XC","YC","FerCoord","FerAxis","MidAxis"] measureslabels_dep=["Mean","StdDev","IntDen","Kurt","Skew","XM","YM","Fprofil","MidProfil","NFoci","ListFoci","ListAreaFoci","ListPeaksFoci","ListMeanFoci"] measureslabels_global=["Latency", "velocity", "cumulatedDist"] measureslabels_dep_tabonly=set(["MidAxis","FerCoord","FerAxis","Fprofil","MidProfil","ListFoci","ListAreaFoci","ListPeaksFoci","ListMeanFoci"]) ens_measures_global=set(measureslabels_global) ens_measures_indep=set(measureslabels_indep) ens_measures_dep=set(measureslabels_dep) measureslabels=[] for label in measureslabels_indep : measureslabels.append(label) for label in measureslabels_dep : measureslabels.append(label) #self.__defaultmeasures=[False for i in range(len(measureslabels))] #self.__defaultmeasures_global=[False for i in range(len(measureslabels_global))] gdmeasures=NonBlockingGenericDialog("MeasuresChoice") gdmeasures.setFont(Font("Courrier", 1, 10)) gdmeasures.addMessage("******* TIME SETTINGS *******") gdmeasures.addCheckbox("Only starting at begining :", self.__onlystart) # 1 only start gdmeasures.addNumericField("Minimal Lifetime : ",self.__minLife,0) gdmeasures.addNumericField("Maximal Lifetime : ",self.__maxLife,0) #gdmeasures.addNumericField("Maximal Lifetime : ",self.__img.getImageStackSize(),0) gdmeasures.addCheckbox("x axis in seconds", self.__useTime) # 2 use time gdmeasures.addMessage("") gdmeasures.addMessage("") gdmeasures.addMessage("Choose the measures to make on the cells : ") gdmeasures.addMessage("******* TIME MEASURES *******") gdmeasures.addCheckboxGroup(4,8,measureslabels,self.__defaultmeasures) gdmeasures.addMessage("") gdmeasures.addMessage("******* GLOBAL MEASURES *******") gdmeasures.addMessage("PLEASE : If you have selected movement parameters you MUST to select XC and YC !") gdmeasures.addCheckboxGroup(3,1,measureslabels_global,self.__defaultmeasures_global) gdmeasures.addNumericField("Noise value for maxima finder: ",self.__noise,0) gdmeasures.addMessage("") gdmeasures.addMessage("******* OPTIONS *******") gdmeasures.addCheckbox("Select the cells in next dialog ?", self.__onlyselect) # 3 only select gdmeasures.addCheckbox("Save results to text files ?", self.__savetables) # 4 save files #gdmeasures.addCheckbox("Append mode ?", self.__savemode) # 5 append mode gdmeasures.addCheckbox("Analyse in batch mode ?", self.__batchanalyse) # 6 analysis batch mode gdmeasures.addCheckbox("Update overlay ?", self.__updateoverlay) # 7 update overlay gdmeasures.addMessage("") gdmeasures.addMessage("") help_panel=Panel() helpbutton=Button("HELP") helpbutton.actionPerformed = helpbuttonPressed help_panel.add(helpbutton) gdmeasures.addPanel(help_panel) gdmeasures.hideCancelButton() if not self.__batchanalyse : gdmeasures.showDialog() self.__onlystart=gdmeasures.getNextBoolean() # 1 only start self.__minLife=gdmeasures.getNextNumber() self.__maxLife=gdmeasures.getNextNumber() self.__useTime=gdmeasures.getNextBoolean() # 2 use time self.__measuresparambool=[] self.__measuresparambool_global=[] for i in range(len(measureslabels)) : self.__measuresparambool.append(gdmeasures.getNextBoolean()) self.__defaultmeasures[i]=self.__measuresparambool[-1] for i in range(len(measureslabels_global)) : self.__measuresparambool_global.append(gdmeasures.getNextBoolean()) self.__defaultmeasures_global[i] = self.__measuresparambool_global[i] self.__noise=gdmeasures.getNextNumber() self.__onlyselect=gdmeasures.getNextBoolean() # 3 only select self.__savetables = gdmeasures.getNextBoolean() # 4 save files #self.__savemode = gdmeasures.getNextBoolean() # 5 append mode self.__batchanalyse = gdmeasures.getNextBoolean() # 6 analyse mode self.__updateoverlay = gdmeasures.getNextBoolean() # 7 update overlay # we update a list of all cells that have a lifetime corresponding to what the user chose. if len (self.__allcells) == 0 : for cellname in dico.keys() : if dico[cellname].getLifeTime()>=self.__minLife : #and dico[cellname].getLifeTime()<=self.__maxLife : if self.__onlystart : if dico[cellname].getSlideInit()<2 : self.__allcells.append(cellname) else : self.__allcells.append(cellname) if self.__noise == 0 : self.__noise = None if self.__batchanalyse : self.__onlyselect = False if self.__onlyselect : try : self.__gw except AttributeError : if not path.exists(self.__pathdir+"Selected-Cells"+os.path.sep) : os.makedirs(self.__pathdir+os.path.sep+"Selected-Cells"+os.path.sep, mode=0777) self.__gw = CellsSelection() self.__gw.setTitle(imgName) self.__gw.run(self.__allcells, self.__pathdir+"ROIs"+os.path.sep) self.__gw.show() self.__gw.setSelected(self.__allcells) while not self.__gw.oked and self.__gw.isShowing() : self.__gw.setLabel("Validate selection with OK !!") self.__listcellname = list(self.__gw.getSelected()) self.__gw.resetok() self.__gw.setLabel("...") self.__gw.hide() else : if self.__gw.getTitle() == imgName : self.__gw.show() self.__gw.setSelected(self.__listcellname) self.__listcellname[:]=[] while not self.__gw.oked and self.__gw.isShowing() : self.__gw.setLabel("Validate selection with OK !!") self.__listcellname = list(self.__gw.getSelected()) self.__gw.resetok() self.__gw.setLabel("...") self.__gw.hide() else : self.__gw.dispose() if not path.exists(self.__pathdir+"Selected-Cells"+os.path.sep) : os.makedirs(self.__pathdir+os.path.sep+"Selected-Cells"+os.path.sep, mode=0777) self.__gw = CellsSelection() self.__gw.setTitle(imgName) self.__gw.run(self.__allcells, self.__pathdir+"ROIs"+os.path.sep) self.__gw.show() self.__gw.setSelected(self.__allcells) self.__listcellname[:]=[] while not self.__gw.oked and self.__gw.isShowing() : self.__gw.setLabel("Validate selection with OK !!") self.__listcellname = list(self.__gw.getSelected()) self.__gw.resetok() self.__gw.setLabel("...") self.__gw.hide() filestodelet=glob.glob(self.__pathdir+"Selected-Cells"+os.path.sep+"*.cell") for f in filestodelet : os.remove(f) for cell in self.__listcellname : sourcestr = self.__pathdir+"Cells"+os.path.sep+cell+".cell" deststr = self.__pathdir+"Selected-Cells"+os.path.sep+cell+".cell" #os.system("copy "+sourcestr+", "+deststr) #shutil.copy(self.__pathdir+"Cells"+os.path.sep+cell+".cell",self.__pathdir+"Selected-Cells"+os.path.sep+cell+".cell") shutil.copy(sourcestr,deststr) self.__dictNcells[imgName] = len(self.__listcellname) else : self.__listcellname = list(self.__allcells) self.__dictNcells[imgName] = len(self.__listcellname) if len(self.__listcellname) == 0 : self.__dictNcells[imgName] = 0 return False self.__img.hide() # we make the measures. for i in range(len(measureslabels)) : IJ.showProgress(i, len(measureslabels)) if self.__measuresparambool[i]==True : self.__measurescompl.append(measureslabels[i]) if (measureslabels[i] in measureslabels_dep_tabonly)==False : self.__measures.append(measureslabels[i]) if (i<18) and (measureslabels[i] in ens_measures_indep) : self.__measureAll(self.__img,measureslabels[i],False, imgName, self.__noise) ens_measures_indep.discard(measureslabels[i]) if i>=18 : self.__measureAll(self.__img,measureslabels[i],True, imgName, self.__noise) if self.__measuresparambool_global[0] : # calculate latency latencies=[] for i in range(len(self.__listcellname)) : IJ.showProgress(i, len(self.__listcellname)) latencies.append(self.latencie(self.__listcellname[i], self.__img, imgName, self.__useTime)) if self.__measuresparambool_global[1] : # calculate velocity self.__measures.append("velocity") #velocities=[] for i in range(len(self.__listcellname)) : IJ.showProgress(i, len(self.__listcellname)) self.__measureVelocity(self.__img,imgName) if self.__measuresparambool_global[2] : # calculate cumulatedDistance self.__measures.append("cumulatedDist") #velocities=[] for i in range(len(self.__listcellname)) : IJ.showProgress(i, len(self.__listcellname)) self.__measurecumulDist(self.__img,imgName) self.__img.show() self.__img.getProcessor().resetThreshold() if self.__updateoverlay : if self.__img.getOverlay() is not None : self.__img.getOverlay().clear() outputrois=[] cellnames=[] self.__img.hide() for cellname in self.__listcellname : for r in dico[cellname].getListRoi(): if isinstance(r,Roi) : pos=r.getPosition() #print "MC overlay", cellname, r.getName(), pos #r.setPosition(0) #overlay.add(r) outputrois.append(r) if "cell" in r.getName() : cellnames.append(r.getName()) else : cellnames.append(str(pos)+"-"+cellname) #print cellnames[-1] rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.show() self.__img.show() IJ.selectWindow(self.__img.getTitle()) rm.runCommand("reset") for i in range(len(outputrois)) : outputrois[i].setName(cellnames[i]) rm.addRoi(outputrois[i]) rm.select(rm.getCount()-1) rm.runCommand("Rename", cellnames[i]) IJ.run("Show Overlay", "") rm.runCommand("UseNames", "true") rm.runCommand("Associate", "true") IJ.run(self.__img, "Labels...", "color=red font=12 show use") IJ.run(self.__img, "From ROI Manager", "") rm.runCommand("Show None") rm.runCommand("Show All") # ----------- batch analyse ------------------------ if self.__batchanalyse : if self.__savetables : saveResults() self.__dictMeasures.clear() self.__allcells[:]=[] self.__measurescompl[:]=[] self.__measures[:]=[] return False # ---------- display methodes dialog ---------------- # Allows the user to choose how to see the results of the measures. gd0=NonBlockingGenericDialog("Display") gd0.addMessage("How do you want to see the results ?") panel0=Panel() diagrambutton=Button("Diagram") diagrambutton.actionPerformed = diagrambuttonPressed panel0.add(diagrambutton) graphbutton=Button("Graph") graphbutton.actionPerformed = graphbuttonPressed panel0.add(graphbutton) tabbutton=Button("Tab") tabbutton.actionPerformed = tabbuttonPressed panel0.add(tabbutton) gd0.addPanel(panel0) gd0.addCheckbox("Analyse next stack ?", self.__nextstack) gd0.hideCancelButton() gd0.showDialog() self.__nextstack = gd0.getNextBoolean() # ---------- save tables --------------------------- if self.__savetables : saveResults() # --------- re-start analysis ------------------- self.__dictMeasures.clear() #self.__listcellname[:]=[] self.__allcells[:]=[] self.__measurescompl[:]=[] self.__measures[:]=[] if self.__nextstack : return False else : return True
#name=cellfile.rsplit("/", 1)[1][:-len(".cell")] name=os.path.splitext(os.path.split(cellfile)[1])[0] #allcellnames.append(allcells[-1].getName()) allcellnames.append(name) dictRois={} for r in listrois : #cle=r.rsplit("/", 1)[1][:-len(".zip")] cle=os.path.splitext(os.path.split(r)[1])[0] if cle in allcellnames : dictRois[cle]=r rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("UseNames", "true") rm.runCommand("Associate", "true") rm.runCommand("Show None") gw = CellsSelection() gw.setTitle(imp.getTitle()) gw.run(dictRois.keys(), pathdir) gw.show() gw.setSelected(dictRois.keys()) while not gw.oked and gw.isShowing() : gw.setLabel("Validate selection with OK !!") listcellname = list(gw.getSelected()) gw.resetok() gw.setLabel("...") gw.hide()
def showSettingsDialog(self): if self.__image.getOverlay() is not None : self.__image.getOverlay().clear() rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() #rm.runCommand("Deselect") #for i in range(rm.getCount()) : # rm.select(i) # rm.runCommand("Set Color", "0000FF", 2) IJ.resetThreshold(self.__image) rm.runCommand("Show All") self.__ranges.clear() #areas, means, majors, minors=[],[],[],[] #for roi in self.__roisArray: # m=Morph(self.__image, roi) # areas.append(m.Area) # means.append(m.Mean) # majors.append(m.Major) # minors.append(m.Minor) #maxarea=max(areas)*1000 #maxint=max(means)*10 #maxline=max(majors)*100 #maxminline=max(minors)*100 #minline=min(minors) #namemeasures=["Area", "Mean", "Angle", "Major", "Minor", "Solidity", "AR", "Round", "Circ"] #maxmeasures=[maxarea, maxint, 180*10, maxline, maxminline, 1*1000, (maxline/minline), 1*1000, 1*1000] #set1000=Set(["Solidity", "Round", "Circ"]) #set10=Set(["Angle"]) def buttonPressed(event): temprois=self.getIncludeRois() for roi in temprois: m=Morph(self.__image, roi) IJ.log("----------------------------------") IJ.log(roi.getName()) for r in self.__ranges.values(): IJ.log(r[0]+" min= "+str(r[1])+" < val="+str(m.__getattribute__(r[0]))+" < max= "+str(r[2])) IJ.run(self.__image, "Remove Overlay", "") o=Overlay() for roi in temprois: o.addElement(roi) self.__image.killRoi() self.__image.setOverlay(o) self.__image.updateAndDraw() def updatepressed(event): self.__image=IJ.getImage() rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") self.__image.killRoi() IJ.run("Threshold...") IJ.setAutoThreshold(self.__image, "MaxEntropy") rt=ResultsTable() pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00) pa.analyze(self.__image) self.__roisArray=[] self.__roisArray=rm.getRoisAsArray() #for i in range(rm.getCount()) : # rm.select(i) # rm.runCommand("Set Color", "0000FF", 2) IJ.resetThreshold(self.__image) rt.show("tempRT") areas=rt.getColumn(ResultsTable.AREA) means=rt.getColumn(ResultsTable.MEAN) majors=rt.getColumn(ResultsTable.MAJOR) minors=rt.getColumn(ResultsTable.MINOR) #print 0 if self.__slidersDict["Area_max"].getMaximum() < int(max(areas)+1): # print 1 self.__slidersDict["Area_max"].setMaximum(int(max(areas))+1) if self.__slidersDict["Area_min"].getMaximum() < int(max(areas)+1): # print 2 self.__slidersDict["Area_min"].setMaximum(int(max(areas))+1) if self.__slidersDict["Mean_max"].getMaximum() < int(max(means)+1): # print 3 self.__slidersDict["Mean_max"].setMaximum(int(max(means))+1) if self.__slidersDict["Mean_min"].getMaximum() < int(max(means)+1): # print 4 self.__slidersDict["Mean_min"].setMaximum(int(max(means))+1) if self.__slidersDict["Major_max"].getMaximum() < int(max(majors)): # print 5 self.__slidersDict["Major_max"].setMaximum(int(max(majors))+1) if self.__slidersDict["Major_min"].getMaximum() < int(max(majors)+1): # print 6 self.__slidersDict["Major_min"].setMaximum(int(max(majors))+1) if self.__slidersDict["Minor_max"].getMaximum() < int(max(minors)+1): # print 7 self.__slidersDict["Minor_max"].setMaximum(int(max(minors))+1) if self.__slidersDict["Minor_min"].getMaximum() < int(max(minors)+1): # print 8 self.__slidersDict["Minor_min"].setMaximum(int(max(minors))+1) if self.__slidersDict["AR_max"].getMaximum() < int((max(majors)+1)/min(minors)+1): # print 9 self.__slidersDict["AR_max"].setMaximum(int((max(majors)+1)/(min(minors)))) if self.__slidersDict["AR_min"].getMaximum() < int((max(majors)+1)/min(minors)): # print 10 self.__slidersDict["AR_min"].setMaximum(int((max(majors)+1)/(min(minors)))) #print 11 for sb in self.__slidersDict.values(): sb.repaint() #rm.runCommand("reset") #temprois=self.getIncludeRois() #IJ.run(self.__image, "Remove Overlay", "") #o=Overlay() #for roi in temprois: # o.addElement(roi) #self.__image.killRoi() #self.__image.setOverlay(o) self.__image.updateAndDraw() def resetpressed(event): self.__ranges.clear() self.__image=IJ.getImage() rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") self.__image.killRoi() IJ.setAutoThreshold(self.__image, "MaxEntropy") rt=ResultsTable() pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00) pa.analyze(self.__image) self.__roisArray=[] self.__roisArray=rm.getRoisAsArray() #rm.runCommand("Show All") #rm.runCommand("Select All") #rm.runCommand("Set Color", "blue") IJ.resetThreshold(self.__image) keys=self.__slidersDict.keys() for k in keys: if k.endswith("min"): self.__slidersDict[k].setValue(0) self.__slidersDict[k].repaint() else: self.__slidersDict[k].setValue(self.__slidersDict[k].getMaximum()) self.__slidersDict[k].repaint() def valueChanged(event): name=event.getSource().getName() names=name.split("_") factor=1 if names[0] in self.__set1000: factor=0.001 if names[0] in self.__set10:factor=0.1 value=event.getSource().getValue()*factor if names[1]=="min": self.__ranges[names[0]]=(names[0], value, self.__slidersDict[names[0]+"_max"].getValue()*factor, self.__boxesDict[names[0]].getState()) #self.__ranges[names[0]]=(names[0], value, self.__slidersDict[names[0]+"_max"].getValue()*factor) else: self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, value, self.__boxesDict[names[0]].getState()) #self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, value) temprois=self.getIncludeRois() IJ.run(self.__image, "Remove Overlay", "") o=Overlay() for roi in temprois: o.addElement(roi) self.__image.killRoi() self.__image.setOverlay(o) self.__image.updateAndDraw() def selectAll(event): name=event.getSource().getLabel() names=name.split("_") factor=1 if names[0] in self.__set1000: factor=0.001 if names[0] in self.__set10:factor=0.1 name=event.getSource().getLabel() names=name.split("_") value=event.getSource().getState() self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, self.__slidersDict[names[0]+"_max"].getValue()*factor, value) gd0=NonBlockingGenericDialog("settings") gd0.setResizable(True) gd0.setFont(Font("Courrier", 1, 8)) count=0 self.__slidersDict={} self.__boxesDict={} self.__boxesDict.clear() self.__slidersDict.clear() for i in range(len(self.__namemeasures)): gd0.setInsets(-10,0,0) gd0.addSlider("Min"+self.__namemeasures[i], 0, self.__maxmeasures[i], 0) gd0.getSliders().get(count).adjustmentValueChanged = valueChanged gd0.getSliders().get(count).setName(self.__namemeasures[i]+"_min") self.__slidersDict[self.__namemeasures[i]+"_min"]=gd0.getSliders().get(count) gd0.addSlider("Max"+self.__namemeasures[i], 0, self.__maxmeasures[i], self.__maxmeasures[i]) gd0.getSliders().get(count+1).adjustmentValueChanged = valueChanged gd0.getSliders().get(count+1).setName(self.__namemeasures[i]+"_max") self.__slidersDict[self.__namemeasures[i]+"_max"]=gd0.getSliders().get(count+1) gd0.addCheckbox("all", True) gd0.getCheckboxes().get(i).itemStateChanged = selectAll gd0.getCheckboxes().get(i).setLabel(self.__namemeasures[i]+"_all") self.__boxesDict[self.__namemeasures[i]]=gd0.getCheckboxes().get(i) gd0.setInsets(-10,0,0) #gd0.addMessage("...........................................................................") count=count+2 panel0=Panel() #trybutton=Button("Try") #trybutton.setActionCommand("DrawOverlay") #trybutton.actionPerformed = buttonPressed #updatebutton=Button("Update") #updatebutton.setActionCommand("Update") #updatebutton.actionPerformed = updatepressed #resetbutton=Button("Reset") #resetbutton.setActionCommand("Reset") #resetbutton.actionPerformed = resetpressed #panel0.add(trybutton) #panel0.add(updatebutton) #panel0.add(resetbutton) #gd0.addPanel(panel0) gd0.setResizable(True) gd0.showDialog() #self.__image.setSlice(self.__firstslice) #self.__image.updateAndDraw() if gd0.wasOKed(): #for key in self.__ranges.keys(): IJ.log("Measure : "+str(self.__ranges[key][0])+" min = "+str(self.__ranges[key][1])+" max = "+str(self.__ranges[key][2])) return self.__ranges
class StackCells(swing.JFrame): def __init__(self): swing.JFrame.__init__(self, title="Stack Cells") self.__impD = IJ.getImage() self.setDefaultCloseOperation(swing.JFrame.DISPOSE_ON_CLOSE) self.__n=0 self.__widthl = "11" self.__iplist = [] self.__init = False self.__initDIA = False self.__initFLUO = False self.__skip = False self.__avg = True self.__mosa = True self.__maxfinder = True self.__appmedian = True self.__fire = True self.__align = True self.__alignC = False self.__enlarge = True self.__measures = True self.__sens = [] self.__listrois = [] self.__cellsrois = [] self.__Cutoff = 0 self.__labels = [] self.__maxraf = 100.0 self.__minraf = 0.0 self.__conEllipses = False self.__dictCells = {} self.__rm = RoiManager.getInstance() if (self.__rm==None): self.__rm = RoiManager() self.run() def run(self) : self.size=(1100, 400) self.contentPane.layout = awt.BorderLayout() self.__display = swing.JTextField(preferredSize=(400, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__setDisplay() line = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED) northpanel1=swing.JPanel(awt.FlowLayout(awt.FlowLayout.LEFT)) northpanel1.setBorder(line) northpanel1.add(self.__display) new = swing.JButton("New", size=(100, 70), actionPerformed=self.__new) northpanel1.add(new) add = swing.JButton("Add", size=(100, 70), actionPerformed=self.__add) northpanel1.add(add) roiman = swing.JButton("Add Roi manager", size=(100, 70), actionPerformed= self.__addroi) northpanel1.add(roiman) end = swing.JButton("End", size=(100, 70), actionPerformed= self.__end) northpanel1.add(end) #grid = awt.GridLayout() #grid.setRows(2) #northpanel=swing.JPanel(grid) #northpanel.add(northpanel1) #northpanel2=swing.JPanel(awt.FlowLayout(awt.FlowLayout.LEFT)) grid0 = awt.GridLayout() grid0.setRows(6) northpanel2=swing.JPanel(grid0) northpanel2.setBorder(line) label=swing.JLabel("Label2") label.setText("Line width ?") northpanel2.add(label) self.__display2 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display2.text = "11" northpanel2.add(self.__display2) label=swing.JLabel("Label3") label.setText("Noise for peaks ?") northpanel2.add(label) self.__display3 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display3.text = "100" northpanel2.add(self.__display3) label=swing.JLabel("Label4") label.setText("Fluo threshold ?") northpanel2.add(label) self.__display4 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display4.text = "170" northpanel2.add(self.__display4) #northpanel3=swing.JPanel(awt.FlowLayout(awt.FlowLayout.LEFT)) #northpanel3.setBorder(line) label=swing.JLabel("Label5") label.setText("Min of length ?") northpanel2.add(label) self.__display5 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display5.text = "50" northpanel2.add(self.__display5) label=swing.JLabel("Label6") label.setText("Max of length ?") northpanel2.add(label) self.__display6 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display6.text = "500" northpanel2.add(self.__display6) dia = swing.JButton("DIA", size=(100, 70), actionPerformed= self.__dia) northpanel2.add(dia) fluo = swing.JButton("FLUO", size=(100, 70), actionPerformed= self.__fluo) northpanel2.add(fluo) southpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.RIGHT)) southpanel.setBorder(line) help = swing.JButton("Help", size=(100, 70), actionPerformed=self.__help) self.__label=swing.JLabel("Label") southpanel.add(self.__label) close = swing.JButton("Close", size=(100, 70), actionPerformed=self.__close) southpanel.add(help) southpanel.add(close) grid = awt.GridLayout() grid.setRows(4) checkpanel=swing.JPanel(grid) checkpanel.setBorder(line) self.__box0=swing.JCheckBox(actionPerformed=self.__boxaction0) self.__box0.setText("Skip failed ROIs") self.__box0.setSelected(False) self.__box1=swing.JCheckBox(actionPerformed=self.__boxaction1) self.__box1.setText("Mosaic") self.__box1.setSelected(True) self.__box2=swing.JCheckBox(actionPerformed=self.__boxaction2) self.__box2.setText("Mean Projection") self.__box2.setSelected(True) self.__box3=swing.JCheckBox(actionPerformed=self.__boxaction3) self.__box3.setText("Max Finder") self.__box3.setSelected(True) self.__box4=swing.JCheckBox(actionPerformed=self.__boxaction4) self.__box4.setText("Median filter") self.__box4.setSelected(True) self.__box5=swing.JCheckBox(actionPerformed=self.__boxaction5) self.__box5.setText("Fire LUT") self.__box5.setSelected(True) self.__box6=swing.JCheckBox(actionPerformed=self.__boxaction6) self.__box6.setText("Auto Align Left") self.__box6.setSelected(True) self.__box7=swing.JCheckBox(actionPerformed=self.__boxaction7) self.__box7.setText("Auto Enlarge") self.__box7.setSelected(True) self.__box8=swing.JCheckBox(actionPerformed=self.__boxaction8) self.__box8.setText("Measures") self.__box8.setSelected(True) self.__box9=swing.JCheckBox(actionPerformed=self.__boxaction9) self.__box9.setText("Auto Align Center") self.__box9.setSelected(False) self.__box10=swing.JCheckBox(actionPerformed=self.__boxaction10) self.__box10.setText("Use ellipses") self.__box10.setSelected(False) checkpanel.add(self.__box0) checkpanel.add(self.__box1) checkpanel.add(self.__box2) checkpanel.add(self.__box3) checkpanel.add(self.__box4) checkpanel.add(self.__box5) checkpanel.add(self.__box6) checkpanel.add(self.__box7) checkpanel.add(self.__box8) checkpanel.add(self.__box9) checkpanel.add(self.__box10) grid = awt.GridLayout() grid.setRows(10) checkpanel2=swing.JPanel(grid) checkpanel2.setBorder(line) label=swing.JLabel("Label7") label.setText("Max of Solidity") checkpanel2.add(label) self.__display7 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display7.text = "1" checkpanel2.add(self.__display7) label=swing.JLabel("Label8") label.setText("Min of Solidity") checkpanel2.add(label) self.__display8 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display8.text = "0" checkpanel2.add(self.__display8) label=swing.JLabel("Label9") label.setText("Max of Area") checkpanel2.add(label) self.__display9 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display9.text = "1447680" checkpanel2.add(self.__display9) label=swing.JLabel("Label10") label.setText("Min of Area") checkpanel2.add(label) self.__display10 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display10.text = "1" checkpanel2.add(self.__display10) label=swing.JLabel("Label11") label.setText("Max of Circ") checkpanel2.add(label) self.__display11 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display11.text = "1" checkpanel2.add(self.__display11) label=swing.JLabel("Label12") label.setText("Min of Circ") checkpanel2.add(label) self.__display12 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display12.text = "0" checkpanel2.add(self.__display12) label=swing.JLabel("Label13") label.setText("Max of AR") checkpanel2.add(label) self.__display13 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display13.text = "1392" checkpanel2.add(self.__display13) label=swing.JLabel("Label14") label.setText("Min of AR") checkpanel2.add(label) self.__display14 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display14.text = "1" checkpanel2.add(self.__display14) label=swing.JLabel("Label15") label.setText("Max of Feret") checkpanel2.add(label) self.__display15 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display15.text = "1392" checkpanel2.add(self.__display15) label=swing.JLabel("Label16") label.setText("Min of Feret") checkpanel2.add(label) self.__display16 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display16.text = "1" checkpanel2.add(self.__display16) label=swing.JLabel("Label17") label.setText("Max of Mean") checkpanel2.add(label) self.__display17 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display17.text = "65535" checkpanel2.add(self.__display17) label=swing.JLabel("Label18") label.setText("Min of Mean") checkpanel2.add(label) self.__display18 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display18.text = "0" checkpanel2.add(self.__display18) label=swing.JLabel("Label19") label.setText("max ratio Axis/Feret") checkpanel2.add(label) self.__display19 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display19.text = str(self.__maxraf) checkpanel2.add(self.__display19) label=swing.JLabel("Label20") label.setText("Min ratio Axis/Feret") checkpanel2.add(label) self.__display20 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display20.text = str(self.__minraf) checkpanel2.add(self.__display20) label=swing.JLabel("Label21") label.setText("Max MinFeret") checkpanel2.add(label) self.__display21 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display21.text = "1392" checkpanel2.add(self.__display21) label=swing.JLabel("Label22") label.setText("Min MinFeret") checkpanel2.add(label) self.__display22 = swing.JTextField(preferredSize=(50, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__display22.text = "1" checkpanel2.add(self.__display22) self.contentPane.add(northpanel1, awt.BorderLayout.NORTH) self.contentPane.add(checkpanel, awt.BorderLayout.WEST) self.contentPane.add(northpanel2, awt.BorderLayout.CENTER) self.contentPane.add(southpanel, awt.BorderLayout.SOUTH) self.contentPane.add(checkpanel2, awt.BorderLayout.EAST) def __close(self, event): self.oked = True time.sleep(0.01) self.dispose() def __new(self, event): self.__init = True self.__n += 1 self.__name = "stackcells"+str(self.__n) self.__display.text = self.__name self.__sens[:] = [] self.__listrois[:] = [] self.__iplist[:] = [] self.__cellsrois[:] = [] self.__labels[:] = [] def __add(self, event): if ( not self.__init) : IJ.showMessage("", "please start a new stack") return if ( not self.__initDIA) : IJ.showMessage("", "please select an image for DIA") return if ( not self.__initFLUO) : IJ.showMessage("", "please select an image for FLUO") return self.__widthl = self.__display2.getText() roi = self.__impD.getRoi() if roi == None : IJ.showMessage("", "No selection") return if roi.getType() in [6,7] : nslice = self.__impD.getCurrentSlice() self.__impF.setSlice(nslice) self.__impF.setRoi(roi) elif roi.getType() in [2,4] : nslice = self.__impD.getCurrentSlice() self.__impF.setSlice(nslice) m=Morph(self.__impF, roi) m.setMidParams(10, 2) roi=m.MidAxis if roi == None : self.__display.text = "roi fail" if not self.__skip : IJ.showMessage("", "failed roi, please draw it as polyline") return #if roi.getType() != 6 : self.__impF.setRoi(roi) else : IJ.showMessage("", "This selection is not yet allowed") return self.__impF.setRoi(roi) straightener = Straightener() new_ip = straightener.straighten(self.__impF, roi, int(self.__widthl)) self.__iplist.append(new_ip) self.__labels.append(self.__isF.getShortSliceLabel(nslice)) self.__display.text = self.__name + " cell " + str(len(self.__iplist)) +" width="+str(new_ip.getWidth())+ " height="+ str(new_ip.getHeight()) roi.setPosition(self.__impD.getCurrentSlice()) self.__rm = RoiManager.getInstance() if (self.__rm==None): self.__rm = RoiManager() self.__rm.add(self.__impD, roi, len(self.__iplist)) self.__cellsrois.append((roi, self.__impD.getCurrentSlice())) #self.__rm.runCommand("Show All") IJ.selectWindow(self.__impD.getTitle()) def __end(self, event): if len(self.__iplist)==0 : IJ.showMessage("", "Stack is empty") return self.__ipw=[ ip.getWidth() for ip in self.__iplist ] self.__iph=[ ip.getHeight() for ip in self.__iplist ] maxw=max(self.__ipw) maxh=max(self.__iph) if self.__enlarge : resizelist = [ ip.resize(maxw, maxh, True) for ip in self.__iplist ] else : resizelist = [] for ip in self.__iplist : tempip = ShortProcessor(maxw, maxh) tempip.copyBits(ip, 0, 0, Blitter.COPY) resizelist.append(tempip) ims = ImageStack(maxw, maxh) #for ip in resizelist : ims.addSlice("", ip) for i in range(len(resizelist)) : ims.addSlice(self.__labels[i], resizelist[i]) self.__impRes = ImagePlus(self.__name, ims) self.__impRes.show() self.__sens = [1 for i in range(len(self.__iplist)) ] if self.__appmedian : IJ.run(self.__impRes, "Median...", "radius=1 stack") if self.__align : self.__falign() if self.__avg : self.__favg() if self.__mosa : self.__fmosa() if self.__maxfinder : self.__fmaxfinder() if self.__fire : IJ.run(self.__impRes, "Fire", "") if self.__measures : self.__fmeasures() self.__sens[:] = [] self.__listrois[:] = [] self.__iplist[:] = [] self.__cellsrois[:] = [] self.__ipw[:] = [] self.__iph[:] = [] self.__init = False def __dia(self, event): IJ.run("Set Scale...", "distance=0 known=0 pixel=1 unit=pixel") #IJ.run("Properties...", "channels=1 slices=1 frames=20 unit=pixel pixel_width=1.0000 pixel_height=1.0000 voxel_depth=1.0000 frame=[1 sec] origin=0,0"); self.__impD = IJ.getImage() self.__isD = self.__impD.getImageStack() self.__display.text = "DIA="+self.__impD.getTitle() self.__initDIA = True def __fluo(self, event): IJ.run("Set Scale...", "distance=0 known=0 pixel=1 unit=pixel") self.__impF = IJ.getImage() self.__isF = self.__impF.getImageStack() self.__display.text = "FLUO="+self.__impF.getTitle() self.__initFLUO = True def __addroi(self, event) : if ( not self.__init) : IJ.showMessage("", "please start a new stack") return if ( not self.__initDIA) : IJ.showMessage("", "please select an image for DIA") return if ( not self.__initFLUO) : IJ.showMessage("", "please select an image for FLUO") return twres = TextWindow("measures-"+self.__name, "label\tname\tsol\tarea\tcirc\tAR\tFeret\taxis\traf\tdMajor\tdFeret\tdArea", "", 300, 450) tab="\t" self.__widthl = self.__display2.getText() IJ.selectWindow(self.__impF.getTitle()) self.__rm = RoiManager.getInstance() if (self.__rm==None): self.__rm = RoiManager() if self.__impF.getImageStackSize() > 1 : roisarray =[(roi, self.__rm.getSliceNumber(roi.getName())) for roi in self.__rm.getRoisAsArray()] else : roisarray =[(roi, 1) for roi in self.__rm.getRoisAsArray()] self.__rm.runCommand("reset") #self.__rm.runCommand("Delete") IJ.selectWindow(self.__impF.getTitle()) self.__maxraf=float(self.__display19.text) self.__minraf=float(self.__display20.text) count=1 for roielement in roisarray : roi = roielement[0] pos = roielement[1] lab = self.__impF.getImageStack().getShortSliceLabel(pos) if lab==None : lab=str(pos) if self.__conEllipses : IJ.selectWindow(self.__impF.getTitle()) self.__impF.setSlice(pos) self.__impF.setRoi(roi) self.__rm.runCommand("Add") IJ.run(self.__impF, "Fit Ellipse", "") ellipse=self.__impF.getRoi() params = ellipse.getParams() ferets = ellipse.getFeretValues() imp2 = Duplicator().run(self.__impF,pos,pos) IJ.run(imp2, "Rotate... ", "angle="+str(ferets[1])+" grid=0 interpolation=Bilinear enlarge slice") temproi=Roi((imp2.getWidth()-ferets[0])/2.0,(imp2.getHeight()-ferets[2])/2.0,ferets[0],ferets[2]) imp2.setRoi(temproi) imp3 = Duplicator().run(imp2,1,1) ip3=imp3.getProcessor() if int(self.__display5.text) < ip3.getWidth() < int(self.__display6.text) : self.__iplist.append(ip3) self.__display.text = self.__name + " cell " + str(len(self.__iplist)) fer=Line(params[0],params[1],params[2],params[3]) self.__cellsrois.append((fer, pos)) self.__labels.append(self.__isF.getShortSliceLabel(pos)) m=Morph(self.__impF, roi) twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(fer.getLength())+tab+str(1)+tab+str(0)+tab+str(0)+tab+str(0)) self.__dictCells[count]=(str(roi.getName()), lab, roi) count=count+1 continue if roi.getType() in [6,7] : self.__impF.setSlice(pos) self.__impF.setRoi(roi) self.__rm.runCommand("Add") elif roi.getType() in [2,4] : self.__impF.setSlice(pos) self.__impF.setRoi(roi) m=Morph(self.__impF, roi) m.setMidParams(10, 2) midroi=m.MidAxis if midroi == None : continue raf = m.MaxFeret/midroi.getLength() if (self.__maxraf < raf) or (raf < self.__minraf) : continue maxsol = float(self.__display7.text) minsol = float(self.__display8.text) maxarea = float(self.__display9.text) minarea = float(self.__display10.text) maxcirc = float(self.__display11.text) mincirc = float(self.__display12.text) maxar = float(self.__display13.text) minar = float(self.__display14.text) maxfer = float(self.__display15.text) minfer = float(self.__display16.text) maxmean = float(self.__display17.text) minmean = float(self.__display18.text) maxmferet = float(self.__display21.text) minmferet = float(self.__display22.text) testsol = (minsol< m.Solidity < maxsol) testarea = (minarea< m.Area < maxarea) testcirc = (mincirc< m.Circ < maxcirc) testar = (minar< m.AR < maxar) testfer = (minfer< m.MaxFeret < maxfer) testmean = (minmean < m.Mean < maxmean) testmferet = (minmferet < m.MinFeret < maxmferet) #print minmferet , m.MinFeret , maxmferet test = (testsol+testarea+testcirc+testar+testfer+testmean+testmferet)/7 if test : fmaj, ffmx, fa =[],[],[] for r in m.getMidSegments(10, 40, 0) : if r == None : continue m2=Morph(self.__impF, r) fmaj.append(m2.Major) ffmx.append(m2.MaxFeret) fa.append(m2.Area) diffmajor, diffferet, diffarea = 0,0,0 if len(fa) > 4 : medfmaj = self.listmean(fmaj[1:-1]) medffmx = self.listmean(ffmx[1:-1]) medfa = self.listmean(fa[1:-1]) diffmajor = (max(fmaj[1:-1])-medfmaj)/medfmaj diffferet = (max(ffmx[1:-1])-medffmx)/medffmx diffarea = (max(fa[1:-1])-medfa)/medfa twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea)) #print lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea) self.__impF.setRoi(roi) self.__rm.runCommand("Add") self.__impF.killRoi() self.__impF.setRoi(midroi) #self.__dictCells[str(roi.getName())]=(str(roi.getName()), lab, roi) self.__dictCells[count]=(str(roi.getName()), lab, roi) count=count+1 else : #print "test falls" continue else : print "out loop" continue straightener = Straightener() new_ip = straightener.straighten(self.__impF, midroi, int(self.__widthl)) if int(self.__display5.text) < new_ip.getWidth() < int(self.__display6.text) : self.__iplist.append(new_ip) self.__display.text = self.__name + " cell " + str(len(self.__iplist)) #print "add", roi.getName(), roi.getType() self.__cellsrois.append((midroi, pos)) self.__labels.append(self.__isF.getShortSliceLabel(pos)) #roisarray=self.__rm.getRoisAsArray() #self.__rm.runCommand("reset") #self.__rm.runCommand("Delete") self.__impD.killRoi() self.__impF.killRoi() IJ.selectWindow(self.__impD.getTitle()) def __boxaction0(self, event): self.__skip = event.getSource().isSelected() def __boxaction1(self, event): self.__mosa = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction2(self, event): self.__avg = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction3(self, event): self.__maxfinder = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction4(self, event): self.__appmedian = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction5(self, event): self.__fire = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction6(self, event): self.__align = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction7(self, event): self.__enlarge = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction8(self, event): self.__measures = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction9(self, event): self.__alignC = event.getSource().isSelected() #self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) def __boxaction10(self, event): self.__conEllipses = event.getSource().isSelected() def __favg(self) : zp = ZProjector(self.__impRes) zp.setMethod(ZProjector.AVG_METHOD) zp.doProjection() imp = zp.getProjection() imp.show() if self.__fire : IJ.run(imp, "Fire", "") def __fmosa(self) : mm = MontageMaker() imp = mm.makeMontage2(self.__impRes, 1, self.__impRes.getStackSize(), 1, 1, self.__impRes.getStackSize(), 1, 0, False) imp.setTitle("MONTAGE"+self.__name) imp.show() if self.__fire : IJ.run(imp, "Fire", "") def __fmaxfinder(self) : #stack = self.__impRes.getStack() self.__impD.killRoi() self.__impF.killRoi() stack = self.__impF.getStack() n_slices = stack.getSize() #newstack=ImageStack(self.__impRes.getWidth(), self.__impRes.getHeight()) newstack=ImageStack(self.__impF.getWidth(), self.__impF.getHeight()) noise = self.__display3.text for index in range(1,n_slices+1): IJ.selectWindow(self.__impF.getTitle()) self.__impF.setSlice(index) ip = self.__impF.getProcessor() mf=MaximumFinder() ipmax = mf.findMaxima(ip, int(noise), 0, 0, False, False) newstack.addSlice("", ipmax) newimage=ImagePlus("max points"+self.__name, newstack) newimage.show() newimage.updateAndDraw() listip = [] maxh=self.__impRes.getHeight() for roi in self.__cellsrois : straightener = Straightener() newimage.setSlice(roi[1]) newimage.setRoi(roi[0]) #listip.append(straightener.straighten(newimage, roi[0], int(self.__widthl))) listip.append(straightener.straighten(newimage, roi[0], maxh)) ipw=[ ip.getWidth() for ip in listip ] iph=[ ip.getHeight() for ip in listip ] maxw=max(ipw) maxh=max(iph) if self.__enlarge : resizelist = [ ip.resize(maxw, maxh, True) for ip in listip ] elif self.__alignC : resizelist = [] for ip in listip : tempip = ByteProcessor(maxw, maxh) tempip.copyBits(ip, 0, 0, Blitter.COPY) resizelist.append(tempip) else : resizelist = [] for ip in listip : tempip = ByteProcessor(maxw, maxh) tempip.copyBits(ip, 0, 0, Blitter.COPY) resizelist.append(tempip) ims = ImageStack(maxw, maxh) #for ip in resizelist : ims.addSlice("", ip) for i in range(len(resizelist)) : ims.addSlice(self.__labels[i], resizelist[i]) self.__impMax = ImagePlus(self.__name+"-max", ims) self.__impMax.show() stack = self.__impMax.getStack() # get the stack within the ImagePlus n_slices = stack.getSize() for index in range(1, n_slices+1): self.__impMax.killRoi() self.__impMax.setSlice(index) roi = self.__listrois[index-1] if self.__sens[index-1]<0 : self.__impMax.setRoi(roi) ip1 = self.__impMax.getProcessor() ip1.flipHorizontal() self.__impMax.killRoi() self.__impMax.updateAndDraw() ip = self.__impMax.getProcessor() for i in range(ip.getWidth()*ip.getHeight()) : if ip.getf(i) > 0 : ip.setf(i, 255) #else : ip.setf(i, 0) IJ.run(self.__impMax, "8-bit", "") IJ.run(self.__impMax, "Options...", "iterations=2 count=1 black edm=Overwrite do=Close stack") IJ.run(self.__impMax, "Ultimate Points", "stack") self.__impMax.updateAndDraw() def __falign(self) : #self.__impRes=IJ.getImage() stack = self.__impRes.getStack() # get the stack within the ImagePlus n_slices = stack.getSize() # get the number of slices ic = ImageCalculator() w = self.__impRes.getWidth() h = self.__impRes.getHeight() self.__sens[:] = [] self.__listrois[:] = [] for index in range(1, n_slices+1): self.__impRes.setSlice(index) ip1 = stack.getProcessor(index) imp1 = ImagePlus("imp1-"+str(index), ip1) imp1sqr = ic.run("Multiply create 32-bit", imp1, imp1) IJ.setThreshold(imp1sqr, 1, 4294836225) IJ.run(imp1sqr, "Create Selection", "") roi = imp1sqr.getRoi() rect=roi.getBounds() roi = Roi(rect) self.__listrois.append(roi) ipsqr = imp1sqr.getProcessor() is1 = ipsqr.getStatistics() self.__impRes.killRoi() if is1.xCenterOfMass > w/2.00 : self.__impRes.setRoi(roi) ip1 = self.__impRes.getProcessor() ip1.flipHorizontal() self.__impRes.killRoi() self.__sens.append(-1) else : self.__sens.append(1) self.__impRes.updateAndDraw() def __fmeasures(self) : self.__Cutoff = float(self.__display4.text) nslices = self.__impRes.getImageStackSize() rt = ResultsTable() rt.show("RT-"+self.__name) twpoints = TextWindow("points-"+self.__name, "index\tlabel\tname\tx\ty\taxis\tcellw\tcellh", "", 200, 450) twlabels = TextWindow("labels-"+self.__name, "index\tlabel\tname\tnpoints", "", 200, 450) isres = self.__impRes.getImageStack() for index in range(1, nslices+1): self.__impRes.setSlice(index) self.__impRes.killRoi() roi = self.__listrois[index-1] self.__impRes.setRoi(roi) analyser= Analyzer(self.__impRes, Analyzer.LABELS+Analyzer.CENTER_OF_MASS+Analyzer.CENTROID+Analyzer.INTEGRATED_DENSITY+Analyzer.MEAN+Analyzer.KURTOSIS+Analyzer.SKEWNESS+Analyzer.MIN_MAX+Analyzer.SLICE+Analyzer.STACK_POSITION+Analyzer.STD_DEV, rt) analyser.measure() rt.show("RT-"+self.__name) rect=roi.getBounds() ip = self.__impRes.getProcessor() xCoord = [] yCoord = [] currentPixel = [] m00 = 0.00 m10 = 0.00 m01 = 0.00 mc20 = 0.00 mc02 = 0.00 mc11 = 0.00 mc30 = 0.00 mc03 = 0.00 mc21 = 0.00 mc12 = 0.00 mc40 = 0.00 mc04 = 0.00 mc31 = 0.00 mc13 = 0.00 mm20 = 0.00 mm02 = 0.00 mm11 = 0.00 mm30 = 0.00 mm03 = 0.00 mm21 = 0.00 mm12 = 0.00 mm40 = 0.00 mm04 = 0.00 mm31 = 0.00 mm13 = 0.00 for y in range(rect.y, rect.y+rect.height, 1) : for x in range(rect.x, rect.x+rect.width, 1) : xCoord.append(x+0.5) yCoord.append(y+0.5) #pixel=ip.getf(x,y)-self.__Cutoff pixel = ip.getPixelValue(x,y)-self.__Cutoff if pixel < 0 : pixel = 0 currentPixel.append(pixel) m00 += currentPixel[-1] m10 += currentPixel[-1]*xCoord[-1] m01 += currentPixel[-1]*yCoord[-1] xm = m10/(m00+0.00000001) ym = m01/(m00+0.00000001) xc = rect.width/2.00 yc = rect.height/2.00 for i in range(rect.width*rect.height) : xcrel = xCoord[i]-xc ycrel = yCoord[i]-yc #mc20 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc) #mc02 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc) #mc11 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc) # #mc30 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc) #mc03 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc) #mc21 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(yCoord[i]-yc) #mc12 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc)*(yCoord[i]-yc) # #mc40 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc) #mc04 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc) #mc31 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)*(yCoord[i]-yc) #mc13 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc) mc20 += currentPixel[i]*xcrel*xcrel mc02 += currentPixel[i]*ycrel*ycrel mc11 += currentPixel[i]*xcrel*ycrel mc30 += currentPixel[i]*xcrel*xcrel*xcrel mc03 += currentPixel[i]*ycrel*ycrel*ycrel mc21 += currentPixel[i]*xcrel*xcrel*ycrel mc12 += currentPixel[i]*xcrel*ycrel*ycrel mc40 += currentPixel[i]*xcrel*xcrel*xcrel*xcrel mc04 += currentPixel[i]*ycrel*ycrel*ycrel*ycrel mc31 += currentPixel[i]*xcrel*xcrel*xcrel*ycrel mc13 += currentPixel[i]*xcrel*ycrel*ycrel*ycrel for i in range(rect.width*rect.height) : mm20 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm) mm02 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym) mm11 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym) mm30 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm) mm03 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym) mm21 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(yCoord[i]-ym) mm12 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym)*(yCoord[i]-ym) mm40 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm) mm04 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym) mm31 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)*(yCoord[i]-ym) mm13 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym) xxcVar = mc20/m00 yycVar = mc02/m00 xycVar = mc11/m00 xcSkew = mc30/(m00 * math.pow(xxcVar,(3.0/2.0))) ycSkew = mc03/(m00 * math.pow(yycVar,(3.0/2.0))) xcKurt = mc40 / (m00 * math.pow(xxcVar,2.0)) - 3.0 ycKurt = mc04 / (m00 * math.pow(yycVar,2.0)) - 3.0 ecc = (math.pow((mc20-mc02),2.0)+(4.0*mc11*mc11))/m00 xxmVar = mm20/m00 yymVar = mm02/m00 xymVar = mm11/m00 xmSkew = mm30/(m00 * math.pow(xxmVar,(3.0/2.0))) ymSkew = mm03/(m00 * math.pow(yymVar,(3.0/2.0))) xmKurt = mm40 / (m00 * math.pow(xxmVar,2.0)) - 3.0 ymKurt = mm04 / (m00 * math.pow(yymVar,2.0)) - 3.0 ecm = (math.pow((mm20-mm02),2.0)+(4.0*mm11*mm11))/m00 rt.addValue("xxcVar", xxcVar) rt.addValue("yycVar", yycVar) rt.addValue("xycVar", xycVar) rt.addValue("xcSkew", xcSkew) rt.addValue("ycSkew", ycSkew) rt.addValue("xcKurt", xcKurt) rt.addValue("ycKurt", ycKurt) rt.addValue("Ecc", ecc) rt.addValue("xxmVar", xxmVar) rt.addValue("yymVar", yymVar) rt.addValue("xymVar", xymVar) rt.addValue("xmSkew", xmSkew) rt.addValue("ymSkew", ymSkew) rt.addValue("xmKurt", xmKurt) rt.addValue("ymKurt", ymKurt) rt.addValue("Ecm", ecm) rt.addValue("roiw", rect.width) rt.addValue("roih", rect.height) rt.addValue("cellw", self.__ipw[index-1]) rt.addValue("cellh", self.__iph[index-1]) self.__impRes.killRoi() xCoord[:] = [] yCoord[:] = [] currentPixel[:] = [] points = [] points[:] = [] npointsmax = 0 #lab = self.__labels[index-1] nameroi = self.__dictCells[index][0] lab = self.__dictCells[index][1] self.__impMax.setSlice(index) ipmax = self.__impMax.getProcessor() for y in range(ipmax.getHeight()) : for x in range(ipmax.getWidth()) : if ipmax.getPixelValue(x,y) > 0 : #print str(index) #print lab #print nameroi #print str(x) #print str(y) #print str(self.__cellsrois[index-1][0].getLength()) #print str(self.__ipw[index-1]) #print str(self.__iph[index-1]) twpoints.append(str(index)+"\t"+lab+"\t"+nameroi+"\t"+str(x)+"\t"+str(y)+"\t"+str(self.__cellsrois[index-1][0].getLength())+"\t"+str(self.__ipw[index-1])+"\t"+str(self.__iph[index-1])) npointsmax+=1 rt.addValue("npoints", npointsmax) twlabels.append(str(index)+"\t"+lab+"\t"+nameroi+"\t"+str(npointsmax)) rt.show("RT-"+self.__name) rt.show("RT-"+self.__name) def __setDisplay(self, val=""): self.__display.text = str(val) def setLabel(self, text): self.__label.setText(text) def listmean(self, l) : return float(sum(l)/len(l)) def listmedian(self, l) : s=l[:] s.sort() w=len(l) return float(s[(w-1)/2]) if (w%2 == 1) else float((s[w/2]+s[(w/2)-1]))/2 def __help(self, event): IJ.log(""" -------------------------------------------------------------------------------------- New = Starts a new process with stacked cells Add = Adds un ROI as a new cell in the stack (poly segments line or a closed area ROI) Add Roi manager = adds all the ROIs contained in the roi manager End = Stops the stack process and generates images and results -------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------- Line width = width of the cells in pixels. Noise for peaks = value passed to detect peaks function Fluo threshold = value of the background in the fluo image. Used for acurated calculus of moments. Min length = filter for small short cells Max length = filter for long cells -------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------- DIA = Select the image and click to set the source image for cells ROI FLUO = Select the image and click to set the image containig the fluorescence signal (if Add Roi manager selected, this is not take in to account) -------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------- Skip failed ROIs = debug option Generate Mosaic = Generates a vertcal image with all the stacked cells Mean Projection = creates the projection of all cells by mean method Create maxFinder = uses the maxFinder function to generate peaks information Apply median = smooth the streched images by a 3x3 median filter Apply Fire LUT = shows all images with false colors (Fire LUT) Auto Align = Flip the cells to align the center of mass in the left part of the images Auto enlarge = Stretch the cell to fit the length of the longuest cell Generate measures = creates a text windows with measures parameters. """)
def main(): # Get active dataset #img = IJ.getImage() display = displayservice.getActiveDisplay() active_dataset = imagedisplayservice.getActiveDataset(display) if not active_dataset: IJ.showMessage('No image opened.') return # Get image path fname = active_dataset.getSource() dir_path = os.path.dirname(fname) if not fname: IJ.showMessage('Source image needs to match a file on the system.') return # Open ROIs rois = RoiManager.getInstance() if not rois: roi_path = os.path.join(dir_path, "RoiSet.zip") if not os.path.isfile(roi_path): try: roi_path = glob.glob(os.path.join(dir_path, "*.roi"))[0] except: roi_path = None if not roi_path: IJ.showMessage('No ROIs. Please use Analyze > Tools > ROI Manager...') return rois = RoiManager(True) rois.reset() rois.runCommand("Open", roi_path) IJ.log('Image filename is %s' % fname) dt = get_dt(active_dataset) rois_array = rois.getRoisAsArray() for i, roi in enumerate(rois_array): crop_id = i + 1 IJ.log("Croping %i / %i" % (crop_id, len(rois_array))) # Get filename and basename of the current cropped image crop_basename = "crop%i_%s" % (crop_id, active_dataset.getName()) crop_basename = os.path.splitext(crop_basename)[0] + ".ome.tif" crop_fname = os.path.join(os.path.dirname(fname), crop_basename) # Get bounds and crop bounds = roi.getBounds() dataset = crop(ij, datasetservice, active_dataset, bounds.x, bounds.y, bounds.width, bounds.height, crop_basename) # Show cropped image ij.ui().show(dataset.getName(), dataset) # Save cropped image (ugly hack) IJ.log("Saving crop to %s" % crop_fname) imp = IJ.getImage() bfExporter = LociExporter() macroOpts = "save=[" + crop_fname + "]" bfExporter.setup(None, imp) Macro.setOptions(macroOpts) bfExporter.run(None) imp.close() IJ.log('Done')
class CellsSelection(swing.JFrame): def __init__(self): swing.JFrame.__init__(self, title="Cells Selection") self.setFont(awt.Font("Courrier", 1, 10)) self.__dictBox = {} self.__dictFiles = {} self.oked = False self.__mem=[] self.setDefaultCloseOperation(swing.JFrame.DISPOSE_ON_CLOSE) def run(self, cells, path) : self.__cells=cells cells.sort() self.__cells.sort() self.__path=path if len(cells) <= 6 : cols=len(cells) rows=1 else : cols=6 rows=int(len(cells)/6)+1 #print "cols", cols, "rows", rows self.setFont(awt.Font("Courrier", 1, 10)) #self.size=(max(200*cols, 1100), max(70*rows, 300)) self.size=(max(150*cols, 800), max(50*rows, 250)) line = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED) self.contentPane.layout = awt.BorderLayout() self.__display = swing.JTextField(preferredSize=(400, 30), horizontalAlignment=swing.SwingConstants.LEFT) self.__setDisplay() northpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.LEFT)) northpanel.setBorder(line) #northpanel.add(self.__display, awt.BorderLayout.NORTH) northpanel.add(self.__display) selectall = swing.JButton("select ALL", size=(100, 70), actionPerformed=self.__selectall) #northpanel.add(selectall, awt.BorderLayout.WEST) northpanel.add(selectall) selectnone = swing.JButton("select NONE", size=(100, 70), actionPerformed=self.__selectnone) #northpanel.add(selectnone, awt.BorderLayout.EAST) northpanel.add(selectnone) mem = swing.JButton("Memorize", size=(100, 70), actionPerformed= self.__memorize) northpanel.add(mem) recall = swing.JButton("Recall", size=(100, 70), actionPerformed=self.__recall) northpanel.add(recall) southpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.RIGHT)) southpanel.setBorder(line) self.__label=swing.JLabel("validate selection with ok") southpanel.add(self.__label) ok = swing.JButton("ok", size=(100, 70), actionPerformed=self.__ok) southpanel.add(ok) close = swing.JButton("close", size=(100, 70), actionPerformed=self.__close) southpanel.add(close) westpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.CENTER), preferredSize=(150, 200)) westpanel.setBorder(line) show = swing.JButton("show overlay", size=(100, 70), actionPerformed=self.__show) westpanel.add(show) hide = swing.JButton("hide overlay", size=(100, 70), actionPerformed=self.__hide) westpanel.add(hide) allframes = swing.JButton("show all", size=(100, 70), actionPerformed=self.__showall) westpanel.add(allframes) oneframe = swing.JButton("show one frame", size=(100, 70), actionPerformed=self.__showone) westpanel.add(oneframe) reset = swing.JButton("reset", size=(100, 70), actionPerformed=self.__reset) westpanel.add(reset) title = BorderFactory.createTitledBorder("Edit Cells") title.setTitleJustification(TitledBorder.CENTER) eastpanel = swing.JPanel(awt.FlowLayout(awt.FlowLayout.CENTER), preferredSize=(130, 200)) eastpanel.setBorder(title) split = swing.JButton("split", size=(100, 70), actionPerformed=self.__split) eastpanel.add(split) grid = awt.GridLayout() grid.setRows(rows) checkpanel=swing.JPanel(grid) checkpanel.setFont(awt.Font("Courrier", 1, 10)) self.__boxes=[swing.JCheckBox(actionPerformed=self.__boxaction) for i in range(len(cells))] for b in self.__boxes : b.setFont(awt.Font("Courrier", 1, 10)) #self.__mem=[True for i in range(len(cells))] for i in range(len(self.__boxes)) : self.__dictBox[cells[i]]=(cells[i], self.__boxes[i]) for i in range(len(self.__boxes)) : self.__boxes[i].setText(str(cells[i])) self.__boxes[i].setSelected(True) checkpanel.add(self.__boxes[i]) for i in range(rows*cols-len(self.__boxes)) : checkpanel.add(awt.Label("")) self.contentPane.add(northpanel, awt.BorderLayout.NORTH) self.contentPane.add(checkpanel, awt.BorderLayout.CENTER) self.contentPane.add(westpanel, awt.BorderLayout.WEST) self.contentPane.add(eastpanel, awt.BorderLayout.EAST) self.contentPane.add(southpanel, awt.BorderLayout.SOUTH) self.contentPane.setFont(awt.Font("Courrier", 1, 10)) self.__rm = RoiManager.getInstance() if (self.__rm==None): self.__rm = RoiManager() self.__rm.runCommand("reset") listfilescells=[] listfilescells.extend(glob.glob(path+"*.zip")) #includecells = [filename for filename in listfilescells if filename.rsplit("/",1)[1][0:-4] in cells] includecells = [filename for filename in listfilescells if os.path.splitext(os.path.split(filename)[1])[0] in cells] for cell in includecells : #c = cell.rsplit("/",1)[1][0:-4] c=os.path.splitext(os.path.split(cell)[1])[0] self.__dictFiles[c] = (c, cell) #for i in range(len(cells)) : # f=listfilescells[i].rsplit("/",1)[1][0:-4] # #print "f=", f # for c in cells : # #print "c=", c, "f=", f # if f==c : # self.__dictFiles[c] = (c, listfilescells[i]) # #print "CS dictFiles", c, listfilescells[i] def __selectall(self, event): for b in self.__boxes : b.setSelected(True) def __selectnone(self, event): for b in self.__boxes : b.setSelected(False) def __ok(self, event): self.oked = True #self.dispose() def __close(self, event): self.oked = True time.sleep(0.01) self.dispose() def __memorize(self, event): self.__mem[:]=[] for i in range(len(self.__boxes)) : if self.__boxes[i].isSelected() : #print i, "mem", self.__boxes[i].text self.__mem.append(True) else : self.__mem.append(False) def __recall(self, event): for i in range(len(self.__boxes)) : if self.__mem[i] : self.__boxes[i].setSelected(True) else : self.__boxes[i].setSelected(False) def __show(self, event): IJ.run("Show Overlay", "") def __hide(self, event): IJ.run("Hide Overlay", "") def __showall(self, event) : self.__rm.runCommand("Associate", "false") self.__rm.runCommand("Show All") def __showone(self, event) : self.__rm.runCommand("Associate", "true") self.__rm.runCommand("Show All") def __reset(self, event) : self.__rm.runCommand("reset") def __boxaction(self, event): self.__setDisplay(str(event.getSource().text)+" is "+str(event.getSource().isSelected())) if event.getSource().isSelected() : #print self.__dictFiles[event.getSource().text][1] #self.__rm.runCommand("reset") self.__rm.runCommand("Open", self.__dictFiles[event.getSource().text][1]) def __setDisplay(self, val=""): self.__display.text = str(val) def __split(self, event) : sel = self.getSelected() if len(sel) != 1 : IJ.showMessage("only one cell should be selected !") return else : cellname = sel[0] rois = self.__rm.getRoisAsArray() self.__rm.runCommand("reset") n = int(IJ.getNumber("slice to split ?", 1)) for i in range(n) : self.__rm.addRoi(rois[i]) #print self.__path+cellname+"-a.zip" self.__rm.runCommand("Save", self.__path+cellname+"-a.zip") self.__rm.runCommand("reset") for i in range(n, len(rois)) : self.__rm.addRoi(rois[i]) self.__rm.runCommand("Save", self.__path+cellname+"-b.zip") self.__rm.runCommand("reset") root = self.__path.rsplit(os.path.sep, 2)[0]+os.path.sep if not path.exists(root+"Cells"+os.path.sep) :os.makedirs(root+"Cells"+os.path.sep, mode=0777) fichiertemp = open(root+"Cells"+os.path.sep+cellname+"-a.cell","w") fichiertemp.write("NAMECELL="+cellname+"-a\n") fichiertemp.write("PATHCELL="+root+"Cells"+os.path.sep+cellname+"-a.cell\n") fichiertemp.write("PATHROIS="+root+"ROIs"+os.path.sep+cellname+"-a.zip\n") fichiertemp.write("NSLICES="+str(len(rois))+"\n") fichiertemp.write("SLICEINIT="+str(1)+"\n") fichiertemp.write("SLICEEND="+str(n)+"\n") r = random.randrange(5,205,1) g = random.randrange(10,210,1) b = random.randrange(30,230,1) fichiertemp.write("COLOR="+str(r)+";"+str(g)+";"+str(b)+"\n") fichiertemp.close() fichiertemp = open(root+"Cells"+os.path.sep+cellname+"-b.cell","w") fichiertemp.write("NAMECELL="+cellname+"-b\n") fichiertemp.write("PATHCELL="+root+"Cells"+os.path.sep+cellname+"-b.cell\n") fichiertemp.write("PATHROIS="+root+"ROIs"+os.path.sep+cellname+"-b.zip\n") fichiertemp.write("NSLICES="+str(len(rois))+"\n") fichiertemp.write("SLICEINIT="+str(n+1)+"\n") fichiertemp.write("SLICEEND="+str(len(rois))+"\n") r = random.randrange(5,205,1) g = random.randrange(10,210,1) b = random.randrange(30,230,1) fichiertemp.write("COLOR="+str(r)+";"+str(g)+";"+str(b)+"\n") fichiertemp.close() def getSelected(self) : #selected=[self.__cells[i] for i in range(len(self.__cells)) if self.__boxes[i].isSelected()] selected=[b.getText() for b in self.__boxes if b.isSelected()] return selected def setSelected(self, selected) : for b in self.__boxes : b.setSelected(False) #for s in selected : print str(s) for c in self.__cells : #print str(c) if c in selected : self.__dictBox[c][1].setSelected(True) def resetok(self): self.oked = False def setLabel(self, text): self.__label.setText(text)
def analyze_homogeneity(image_title): IJ.selectWindow(image_title) raw_imp = IJ.getImage() IJ.run(raw_imp, "Duplicate...", "title=Homogeneity duplicate") IJ.selectWindow('Homogeneity') hg_imp = IJ.getImage() # Get a 2D image if hg_imp.getNSlices() > 1: IJ.run(hg_imp, "Z Project...", "projection=[Average Intensity]") hg_imp.close() IJ.selectWindow('MAX_Homogeneity') hg_imp = IJ.getImage() hg_imp.setTitle('Homogeneity') # Blur and BG correct the image IJ.run(hg_imp, 'Gaussian Blur...', 'sigma=' + str(HOMOGENEITY_RADIUS) + ' stack') # Detect the spots IJ.setAutoThreshold(hg_imp, HOMOGENEITY_THRESHOLD + " dark") rm = RoiManager(True) table = ResultsTable() pa = ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER, ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES, Measurements.AREA, # measurements table, # Output table 0, # MinSize 500, # MaxSize 0.0, # minCirc 1.0) # maxCirc pa.setHideOutputImage(True) pa.analyze(hg_imp) areas = table.getColumn(table.getHeadings().index('Area')) median_areas = compute_median(areas) st_dev_areas = compute_std_dev(areas, median_areas) thresholds_areas = (median_areas - (2 * st_dev_areas), median_areas + (2 * st_dev_areas)) roi_measurements = {'integrated_density': [], 'max': [], 'area': []} IJ.setForegroundColor(0, 0, 0) for roi in rm.getRoisAsArray(): hg_imp.setRoi(roi) if REMOVE_CROSS and hg_imp.getStatistics().AREA > thresholds_areas[1]: rm.runCommand('Fill') else: roi_measurements['integrated_density'].append(hg_imp.getStatistics().INTEGRATED_DENSITY) roi_measurements['max'].append(hg_imp.getStatistics().MIN_MAX) roi_measurements['integrated_densities'].append(hg_imp.getStatistics().AREA) rm.runCommand('Delete') measuremnts = {'mean_integrated_density': compute_mean(roi_measurements['integrated_density']), 'median_integrated_density': compute_median(roi_measurements['integrated_density']), 'std_dev_integrated_density': compute_std_dev(roi_measurements['integrated_density']), 'mean_max': compute_mean(roi_measurements['max']), 'median_max': compute_median(roi_measurements['max']), 'std_dev_max': compute_std_dev(roi_measurements['max']), 'mean_area': compute_mean(roi_measurements['max']), 'median_area': compute_median(roi_measurements['max']), 'std_dev_area': compute_std_dev(roi_measurements['max']), } # generate homogeinity image # calculate interpoint distance in pixels nr_point_columns = int(sqrt(len(measuremnts['mean_max']))) # TODO: This is a rough estimation that does not take into account margins or rectangular FOVs inter_point_dist = hg_imp.getWidth() / nr_point_columns IJ.run(hg_imp, "Maximum...", "radius="+(inter_point_dist*1.22)) # Normalize to 100 IJ.run(hg_imp, "Divide...", "value=" + max(roi_measurements['max'] / 100)) IJ.run(hg_imp, "Gaussian Blur...", "sigma=" + (inter_point_dist/2)) hg_imp.getProcessor.setMinAndMax(0, 255) # Create a LUT based on a predefined threshold red = zeros(256, 'b') green = zeros(256, 'b') blue = zeros(256, 'b') acceptance_threshold = HOMOGENEITY_ACCEPTANCE_THRESHOLD * 256 / 100 for i in range(256): red[i] = (i - acceptance_threshold) green[i] = (i) homogeneity_LUT = LUT(red, green, blue) hg_imp.setLut(homogeneity_LUT) return hg_imp, measuremnts
from ij import IJ from ij.gui import OvalRoi from ij.plugin.frame import RoiManager imp = IJ.getImage() rm = RoiManager() # instantiate manager # throws exception if it doesn't exist #rm = RoiManager.getInstance() # if manager exists roi = OvalRoi(75, 75, 50, 50); # define and add ROI imp.setRoi(roi) # make active on image rm.addRoi(roi) # add rm.select(0) # select the zeroth ROI and rename it rm.runCommand("Rename", "roi");
def __displayCells(self, nameimage, methodeleon=False): """ Displays all the ROIs of the cells with different colors """ # we define a list of colors that will be used. colors = [] ncells= len(self.__dict[nameimage]) if ncells > 0 : step=200/ncells if step<1 : step=1 for i in range(ncells) : r = random.randrange(5,205,step) g = random.randrange(10,210,step) b = random.randrange(30,230,step) #r = int(0+i*step) #g = random.randrange(10, 190, 30) #b = int(250-i*step) colors.append(Color(r, g, b)) else : colors=[Color.blue, Color.green, Color.magenta, Color.orange, Color.yellow] tempcolors=list(colors) # we try to have random and different colors for each cell. for cellname in self.__dict[nameimage].keys() : if len(tempcolors)>0 : self.__dict[nameimage][cellname].setColor(tempcolors.pop(0)) else : tempcolors=list(colors) self.__dict[nameimage][cellname].setColor(tempcolors.pop(0)) self.__SaveCells(nameimage) rm = RoiManager.getInstance() if (rm==None): rm = RoiManager() rm.runCommand("reset") # if the user wants to save files, .zip for the ROIs are saved. #if self.__optionSave == True : #os.mkdir(self.__pathdir+"ROIs/", mode=0777) os.makedirs(self.__pathdir+"ROIs/", mode=0777) tempimp = IJ.createImage("tempimp", "8-bit Black", self.__dictImages[nameimage].getWidth(), self.__dictImages[nameimage].getHeight(), 1) tempimp.show() for cellname in self.__dict[nameimage].keys() : for numslice in range(self.__dictImages[nameimage].getImageStackSize()) : r = self.__dict[nameimage][cellname].getRoi(numslice) try : name=r.getName() except AttributeError : continue else : s = "%04i" % (numslice+1) #name=s+"-"+name.split("-", 1)[1] name=s+"-cell"+name.split("cell")[1] r.setName(name) try : rm.addRoi(r) rname=rm.getName(rm.getCount()-1) #rm.select(self.__dictImages[nameimage], rm.getCount()-1) rm.select(tempimp, rm.getCount()-1) rm.runCommand("Rename", name) except TypeError : continue #if isinstance(self.__dict[nameimage][cellname].getRoi(numslice),Roi) == True : # s = "%04i" % (numslice) # #rm.add(self.__dictImages[nameimage], self.__dict[nameimage][cellname].getRoi(numslice) , numslice) # name=self.__dict[nameimage][cellname].getRoi(numslice).getName() # name=s+name # self.__dict[nameimage][cellname].getRoi(numslice).setName(name) # rm.addRoi(self.__dict[nameimage][cellname].getRoi(numslice)) rm.runCommand("Save", self.__pathdir+"ROIs/"+cellname+".zip") rm.runCommand("reset") tempimp.close()
def segmentation(imp, spot_data, channel, diameter_init, ES_tolerance, ES_area_max, ES_ctrl_pts, ES_iteration, repeat_max): # Open files cal = imp.getCalibration() manager = RoiManager.getInstance() if manager is None: manager = RoiManager() # Prepare log files for output options = IS.MEDIAN | IS.AREA | IS.MIN_MAX | IS.CENTROID | IS.PERIMETER | IS.ELLIPSE | IS.SKEWNESS convergence = [] Sintensity = [] for spot in spot_data: repeat = 0 flag = False spotID = int(spot[0]) Xcenter = (float(spot[1]) / cal.pixelWidth) Ycenter = (float(spot[2]) / cal.pixelHeight) Quality = float(spot[3]) diameter_init = float(spot[4] / cal.pixelWidth) * 2.0 while True: manager = RoiManager.getInstance() if manager is None: manager = RoiManager() Xcurrent = int(Xcenter - diameter_init / 2.0) Ycurrent = int(Ycenter - diameter_init / 2.0) Dcurrent1 = int(diameter_init * (1.2 - repeat / 10.0)) Dcurrent2 = int(diameter_init * (0.8 + repeat / 10.0)) roi = OvalRoi(Xcurrent, Ycurrent, Dcurrent1, Dcurrent2) imp.setPosition(channel) imp.setRoi(roi) Esnake_options1 = "target_brightness=Bright control_points=" + \ str(ES_ctrl_pts) + " gaussian_blur=0 " Esnake_options2 = "energy_type=Contour alpha=2.0E-5 max_iterations=" + \ str(ES_iteration) + " immortal=false" IJ.run(imp, "E-Snake", Esnake_options1 + Esnake_options2) roi_snake = manager.getRoisAsArray() roi_ind = len(roi_snake) - 1 stats = IS.getStatistics( imp.getProcessor(), options, imp.getCalibration()) perimeter = roi_snake[roi_ind].getLength() * cal.pixelWidth circularity = 4.0 * 3.1417 * (stats.area / (perimeter * perimeter)) if stats.area > 17.0 and stats.area < ES_area_max and stats.skewness < -0.01 and circularity > 0.01 and stats.minor > 2.0 and boundaries(Xcenter, Ycenter, stats.xCentroid / cal.pixelWidth, stats.yCentroid / cal.pixelHeight, ES_tolerance): Sintensity = stats.median convergence.append(True) break if stats.median > 6000 and stats.area > 17.0 and stats.area < ES_area_max: Sintensity = stats.median convergence.append(True) break elif repeat > repeat_max: manager.select(imp, roi_ind) manager.runCommand(imp, 'Delete') roi = OvalRoi(Xcenter + 1.0 - diameter_init / 2.0, Ycenter + 1.0 - diameter_init / 2.0, diameter_init, diameter_init) imp.setRoi(roi) manager.add(imp, roi, spotID) roi_snake.append(roi) stats = IS.getStatistics( imp.getProcessor(), options, imp.getCalibration()) Sintensity = stats.median convergence.append(False) break else: IJ.log('Area=' + str(stats.area) + ' Skewness=' + str(stats.skewness) + ' circularity=' + str(circularity) + ' Minor=' + str(stats.minor)) manager.select(imp, roi_ind) manager.runCommand(imp, 'Delete') repeat += 1 # End Spot-segmentation # End all Spots-segmentation manager.runCommand(imp, 'Show All') imp.setPosition(channel) color = imp.createImagePlus() ip = imp.getProcessor().duplicate() color.setProcessor("segmentation" + str(channel), ip) color.show() IJ.selectWindow("segmentation" + str(channel)) manager.moveRoisToOverlay(color) spot_optimal = manager.getRoisAsArray() manager.reset() for i in xrange(0, len(spot_optimal)): spot = spot_optimal[i] spot.setStrokeWidth(2) if convergence[i]: spot.setStrokeColor(Color.GREEN) else: spot.setStrokeColor(Color.MAGENTA) imp.setRoi(spot) manager.add(imp, spot, i) manager.runCommand(imp, 'Show All') imp.setPosition(channel)
# addAndDeleteROI_.py # Add and delete a ROI from an image # # Modifications # Date Who Ver What # ---------- --- ------ ------------------------------------------------- # 2014-10-21 JRM 0.1.00 Initial prototype from ij import WindowManager from ij import IJ from ij.plugin.frame import RoiManager raw = IJ.openImage("D:\\Data\\images\\tmp\\sis-efi-sc.png") raw.show() IJ.makeRectangle(0, 190, 1600, 260) wbROI = raw.getRoi() if (wbROI==None): exit("you must draw region first") print(wbROI) rm = RoiManager() rm.select(raw, 0) rm.runCommand("Show All") rm.runCommand("Draw") print("done")
pos[1] = int(nef.text) if nef.tag == 'z': pos[2] = int(nef.text) obj[int(child.attrib['ID'])] = pos return obj, imgName #close all open files and clean roimanager 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") #read argument when called from command line try: arg = getArgument() except: IJ.log(" ") IJ.log("Error in loading the file! Using default file!") IJ.log("Run macroscript: ./ImageJ-win64.exe -macro fcsxmlparser 'xmlfilename'") IJ.log("or ./ImageJ-win64.exe -macro fcsxmlparser 'xmlfilename -cchannelNr'") arg = 'X:\\AntonioP_t2\\RLadurner_JMPeters\\DoubleArrest\\150212_STAG2\\Mitosys2\\LSM\\DE_W0001_P0001\\DE_2_W0001_P0001_T0001\\TR1_W0001_P0001\\TR1_2_W0001_P0001_T0001.xml -c2' #split for channel argument arg = re.split('\s+-c', arg) if len(arg)>1: xmlfile = arg[0]