def showGui(par, title): """Updated version discriminates between string and numeric outputs to treat them accordingly""" numflags = {} gd = NonBlockingGenericDialog(title) s_keys = sorted(par.keys()) for nm in s_keys: if isinstance(par[nm], (int, float, long)): gd.addNumericField(nm, par[nm], 1) numflags[nm] = True else: gd.addStringField(nm, par[nm]) numflags[nm] = False gd.setOKLabel("Go on!") gd.setCancelLabel("Recompute..") gd.centerDialog(False) gd.setLocation(50, 100) gd.showDialog() if gd.wasCanceled(): rep = True else: rep = False for nm in s_keys: if numflags[nm]: par[nm] = gd.getNextNumber() else: par[nm] = gd.getNextString().encode("ascii", "replace") return par, rep
def __mainsettings(self) : # options : #We ask if the user wants to import cells from .cell files # we track the cells in a stack that the user has to choose. def outputpath(event) : self.__pathdir=IJ.getDirectory("image") self.__pathdir=IJ.getDirectory("") self.__text.setText(self.__pathdir) panel0=Panel() pathbutton=Button("Select output path", actionPerformed = outputpath) #pathbutton.actionPerformed = outputpath self.__text = TextField(self.__pathdir) panel0.add(pathbutton) panel0.add(self.__text) firstgd=NonBlockingGenericDialog("First choices") firstgd.addMessage("------------------ WELCOME ----------------------") firstgd.addMessage("") firstgd.addMessage("Please fill the following options") firstgd.addMessage("") choices=["Already opened images", "Files from hard disk"] firstgd.addChoice("Images source : ", choices, choices[0]) # 1 choice firstgd.addCheckbox("Run in batch mode ?", False) # 2 batch firstgd.addMessage("") firstgd.addCheckbox("Import a set of cells from hardisk ?", self.__optionImport) # 3 import firstgd.addMessage("") firstgd.addNumericField("Size factor (binning)", 2, 0) # 4 number firstgd.addPanel(panel0) firstgd.showDialog() #self.__optionImages=firstgd.getNextBoolean() choice=firstgd.getNextChoiceIndex() # 1 choice self.__batch = firstgd.getNextBoolean() # 2 batch self.__optionImport=firstgd.getNextBoolean() # 3 import self.__binning = firstgd.getNextNumber() # 4 number if choice==0 : self.__optionImages=True else : self.__optionImages=False if firstgd.wasCanceled() : return False #IJ.showMessage("Select a working directory to save results") #self.__pathdir=IJ.getDirectory("image") #self.__pathdir=IJ.getDirectory("") #self.__pathdir=self.__pathdir+imp.getShortTitle()+os.path.sep+time.strftime('%d-%m-%y_%Hh%Mm%Ss',time.localtime())+os.path.sep if self.__pathdir is not None : return True else : return False
else: xtiles = int(m.group(1)) p = re.compile(r'Y Tiles: (\d+)') m = p.search(metadata) if m is None: ytiles = 0 else: ytiles = int(m.group(1)) nTiles = xtiles*ytiles ## Opens the options dialog box gd = NonBlockingGenericDialog("Select channel...") gd.addChoice("Analysis_channel",["Channel "+str(i) for i in range(1,nChannels+1)],"Channel 1") gd.addChoice("Bleeding_channel",["Channel "+str(i) for i in range(nChannels+1)],"Channel 0") gd.addChoice("Refractive_reference_channel",["Channel "+str(i) for i in range(nChannels+1)],"Channel 0") gd.addNumericField("Intensity_threshold",128,0) gd.addNumericField("Size_threshold",100,0) gd.addChoice("Process_filter",["None","Min","Median"],"None") gd.addCheckbox("Operate_on_tile_subset",False) gd.addStringField("Which_tile_subset","1-4,9,11",12) gd.showDialog() ## Parses the information from the dialog box if (gd.wasOKed()): analysisChannel = gd.getNextChoiceIndex()+1 bleedingChannel = gd.getNextChoiceIndex() refChannel = gd.getNextChoiceIndex() intThreshold = gd.getNextNumber() sizeThreshold = gd.getNextNumber() processFilter = gd.getNextChoiceIndex() doSubset = gd.getNextBoolean()
if (refractRefC > 0): params = ("reference_channel=" + str(refractRefC) + " application_channel=" + str(channel) + " automatic_operation" + " generate_log max_slice=43 surface_slice=87") IJ.run(activeImage,"Refractive Signal Loss Correction",params) dataImage = WindowManager.getImage("App Corrected") refCorrectedImage = WindowManager.getImage("Ref Corrected") refCorrectedImage.close() dataImage.setLut(LUT.createLutFromColor(Color.WHITE)) dataImage.setCalibration(calib) dataImage.show() ## Interface dialog for setting object finding parameters virginImage = dataImage.duplicate() gd10 = NonBlockingGenericDialog("Select size and threshold parameters...") gd10.addNumericField("Minimum_size:",100,0) gd10.addSlider("Threshold_intensity:",0,255,128) gd10.addCheckbox("Min_filter",False) gd10.addCheckbox("Med_filter",False) gd10.addCheckbox("Work_on_ROI",False) sliders = gd10.getSliders() boxes = gd10.getCheckboxes() texts = gd10.getNumericFields() sizeText = texts.elementAt(0) thresholdSlider = sliders.elementAt(0) thresholdSlider.addAdjustmentListener(ThresholdListener(dataImage)) minFilterBox = boxes.elementAt(0) medFilterBox = boxes.elementAt(1) workROIBox = boxes.elementAt(2) minFilterBox.addItemListener(MinCheckboxListener(dataImage,virginImage,medFilterBox)) medFilterBox.addItemListener(MedCheckboxListener(dataImage,virginImage,minFilterBox))
from ij.plugin import HyperStackConverter import ij.plugin from ij import WindowManager as WM import os from os import path import re from re import sub from ij.plugin import Concatenator from ij.io import OpenDialog, DirectoryChooser from ij.gui import GenericDialog, NonBlockingGenericDialog from ij.text import TextPanel as TP from ij.measure import ResultsTable as RT # Create a non-blocking dialog to enter the metadata psgd = NonBlockingGenericDialog( "Choose the frame that shows the right conformation of the heart?") psgd.addNumericField("Which frame to choose?", 1, 0) psgd.addCheckbox("Use table of selected frames?", False) psgd.showDialog() choose = psgd.getNextNumber() choice = psgd.getCheckboxes().get(0).getState() #open a tab separated txt file with one column Frame selected if choice == 1: choose = 0 IJ.run("Table... ", "open=") frametable = WM.getWindow("selected_frames.txt") meta = frametable.getTextPanel() metaRT = TP.getResultsTable(meta) # Choose a directory directory_load = DirectoryChooser(
def main(): # define here which membrane indices will be used in the analysis, with last index the "control" index membrane_indices = [-1, 0, 1, 3] # for now, work with frontmost open image... imp = IJ.getImage() im_title = imp.getTitle() settings = MembraneEvolutionAnalysisSettings( membrane_indices=membrane_indices) settings.loadPersistedSettings() timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S') DirectoryChooser.setDefaultDirectory((settings.output_path)) dc = DirectoryChooser('Select the root folder for saving output') output_root = dc.getDirectory() if output_root is None: raise IOError('no output path chosen') settings.output_path = output_root # get calibration cal = imp.getCalibration() if cal.getTimeUnit() == "sec": cal.setTimeUnit('s') # pop up a dialog prompting for selection of zero time point, frame interval, and time step for analysis time_steps_not_ok = True while time_steps_not_ok: dialog = NonBlockingGenericDialog("Determine time parameters...") dialog.addNumericField("0 timepoint frame (1-index): ", settings.zero_timepoint_frame, 0) dialog.addNumericField("Acquisition time step (s): ", cal.frameInterval, 2) # assume stored in seconds dialog.addNumericField( "Time step for analysis (s): ", cal.frameInterval * settings.analysis_frame_step, 2) dialog.showDialog() if dialog.wasCanceled(): return zero_f = dialog.getNextNumber() acq_t_step = dialog.getNextNumber() analysis_t_step = dialog.getNextNumber() if acq_t_step != 0 and analysis_t_step != 0: analysis_frame_step = analysis_t_step / acq_t_step if round(analysis_frame_step) == analysis_frame_step: time_steps_not_ok = False settings.zero_timepoint_frame = zero_f settings.analysis_frame_step = analysis_frame_step if time_steps_not_ok: warning_dlg = GenericDialog("Error!") warning_dlg.addMessage( "Analysis time step must be an integer multiple of acquisition time steps, and neither should be zero!!" ) warning_dlg.setOKLabel("Try again...") warning_dlg.showDialog() if warning_dlg.wasCanceled(): return start_frame = int(((zero_f - 1) % analysis_frame_step) + 1) end_frame = int(imp.getNFrames() - (imp.getNFrames() - zero_f) % analysis_frame_step) frames = [ f + 1 for f in range(start_frame - 1, end_frame, int(analysis_frame_step)) ] print("frames = " + str(frames)) imp.killRoi() analysis_imp = SubstackMaker().makeSubstack( imp, str(start_frame) + "-" + str(end_frame) + "-" + str(int(analysis_frame_step))) imp.changes = False imp.close() analysis_imp.show() drawn_membranes = [ TimepointsMembranes(input_image_title=im_title, time_point_s=(t - 1) * acq_t_step) for t in frames ] membranes_listener = UpdateRoiImageListener(drawn_membranes) analysis_imp.addImageListener(membranes_listener) # now attach roi listener to store all 0th membranes after showing a waitforuserdialog to prompt continuation IJ.setTool("freeline") for membrane_idx in membrane_indices: # if membrane_idx>50: # IJ.setTool("line"); analysis_imp.killRoi() membranes_listener.resetLastFrame() membranes_listener.setCurrentMembraneIndex(membrane_idx) analysis_imp.setZ(1) continue_dlg = WaitForUserDialog( "Continue?", "Click OK once all the " + str(membrane_idx) + "-index membranes have been drawn") continue_dlg.show() membranes_listener.imageUpdated(analysis_imp) drawn_membranes = membranes_listener.getDrawnMembraneTimepointsList() json_path = os.path.join(output_root, "Membranes " + timestamp + ".json") f = open(json_path, 'w+') try: json.dump(drawn_membranes, f, default=encode_membrane) finally: f.close() # save csv containing mebrane measurements for current membrane index csv_path = os.path.join( output_root, ("Membrane measurements " + timestamp + ".csv")) if membrane_idx == membrane_indices[0]: try: f = open(csv_path, 'wb') writer = csv.writer(f) writer.writerow([ "Membrane index", ("Time point, " + cal.getTimeUnit()), ("Membrane length, " + cal.getUnit()), ("Euclidean length, " + cal.getUnit()), "Membrane sinuoisty" ]) finally: f.close() try: f = open(csv_path, 'ab') writer = csv.writer(f) for mems in drawn_membranes: mem = mems.getMembrane(membrane_idx) if mem is not None: writer.writerow([ membrane_idx, mems.time_point_s, mem.getPathLength() * cal.pixelWidth, mem.getEuclidean() * cal.pixelWidth, mem.getSinuosity() ]) finally: f.close() settings.persistSettings() settings.save_settings() print("Finished getting all membranes with indices " + str(membrane_indices)) analysis_imp.close()
def __settings(self, imgName, flag) : """ Allows the user to choose several parameters for the tracking. """ #fenetre=JFrame("Import") #optionpane=JOptionPane("Do you want to import previous preferences ?",JOptionPane.QUESTION_MESSAGE ,JOptionPane.YES_NO_OPTION ) #optionpane.setVisible(True) #dialog = optionpane.createDialog(fenetre, "Import") #dialog.show() #choice = optionpane.getValue() #if choice==JOptionPane.YES_OPTION : self.__ImportPref() image=self.__dictImages[imgName] def outputpath(event) : macrodir=IJ.getDirectory("macros") frame = Frame("Select the macro file") fd = FileDialog(frame) fd.setDirectory(macrodir) fd.show() macrodir = fd.getDirectory() self.__macropath = fd.getFile() self.__text.setText(self.__macropath) print self.__macropath #self.__macropath=IJ.getDirectory("macros") #self.__macropath=IJ.getDirectory("") #self.__text.setText(self.__macropath) panel0=Panel() pathbutton=Button("Select macro file", actionPerformed = outputpath) #pathbutton.actionPerformed = outputpath self.__text = TextField(self.__macropath) panel0.add(pathbutton) panel0.add(self.__text) # -------- start batch mode --------- # if self.__batch : pass #self.__ImportPref(flag) image.hide() else : image.show() IJ.selectWindow(image.getID()) gd0=NonBlockingGenericDialog("Settings") gd0.setFont(Font("Courrier", 1, 10)) gd0.addMessage("---------------- PRE-PROCESSING OPTIONS -------------------") gd0.addCheckbox("Substract Background",self.__subback) #box 1 subback gd0.addNumericField("Radius",self.__radius,0) gd0.addCheckbox("Run a macro for pre processing",self.__runmacro) #box 2 runmacro gd0.addPanel(panel0) gd0.addMessage("-------------------------------------------") gd0.addMessage("Tracking parameters") gd0.addMessage("Coeffs modulate de weight of each parameter") gd0.addMessage("Max delta set the maximum allowed change in absolute units") gd0.addMessage(" ") gd0.addNumericField("Coeff Area : ",self.__distparam[0],0) gd0.addNumericField("Max deltaArea : ",self.__distparam[1],self.__nbdigits,6,"x times") gd0.addNumericField("Coeff Angle : ",self.__distparam[2],0) gd0.addNumericField("Max deltaAngle : ",self.__distparam[3],self.__nbdigits,6,"degrees") gd0.addNumericField("Coeff Feret : ",self.__distparam[4],0) gd0.addNumericField("Max deltaFeret : ",self.__distparam[5],self.__nbdigits,6,"x times") gd0.addNumericField("Coeff PositionX : ",self.__distparam[6],0) gd0.addNumericField("Max deltaPositionX : ",self.__distparam[7],self.__nbdigits,6,"pixels") gd0.addNumericField("Coeff PositionY : ",self.__distparam[8],0) gd0.addNumericField("Max deltaPositionY : ",self.__distparam[9],self.__nbdigits,6,"pixels") gd0.addMessage("-------------------------------------------") automethods=AutoThresholder.getMethods() gd0.addCheckbox("Manual Threshold",self.__manthresh) #box 3 manthresh gd0.addChoice("Threshol Method : ",automethods,self.__thresMethod) gd0.addMessage("-------------------------------------------") #gd0.addCheckbox("Symmetry Around 0-180",self.__optionAngle) #gd0.addMessage("-------------------------------------------") #gd0.addCheckbox("Save cell files", self.__optionSave) #gd0.addMessage("-------------------------------------------") gd0.addCheckbox("Track new cells", self.__optionNewCells) #box 4 newcells gd0.addMessage("-------------------------------------------") gd0.addCheckbox("Generate time list with follow time lapse interval ?", self.__optionTimelapse) #box 5 timelapse gd0.addNumericField("Estimated time lapse : ",self.__timelapse,self.__nbdigits,6,"seconds") #gd0.hideCancelButton() gd0.showDialog() if gd0.wasCanceled() : return False #chosenstack=gd0.getNextChoice() #self.__img=WindowManager.getImage(chosenstack) self.__subback=gd0.getNextBoolean() #box 1 subback self.__radius=gd0.getNextNumber() self.__runmacro=gd0.getNextBoolean() #box 2 runmacro for i in range(10) : self.__distparam[i]=gd0.getNextNumber() #self.__distmethod=gd0.getNextChoice() self.__manthresh=gd0.getNextBoolean() #box 3 manthresh self.__thresMethod=gd0.getNextChoice() #self.__optionAngle=gd0.getNextBoolean() #self.__optionSave=gd0.getNextBoolean() self.__optionNewCells=gd0.getNextBoolean() #box 4 newcells self.__optionTimelapse=gd0.getNextBoolean() #box 5 timelapse self.__timelapse=int(gd0.getNextNumber()) # -------- start end batch mode --------- # if self.__optionTimelapse : self.__dictTimeStack[imgName]=range(0,image.getImageStackSize()*self.__timelapse, self.__timelapse) if not self.__optionTimelapse and self.__source=="image" : self.__dictTimeStack[imgName]=range(0,image.getImageStackSize()) #if option_import==True : # temparray= #else : temparray=self.__calRois("image1", 1) #imp=self.__dictImages["image1"] if self.__manthresh : ip=image.getProcessor() self.__maxthr=ip.getMaxThreshold() self.__minthr=ip.getMinThreshold() temparray=self.__calRois(image, 1) self.__rr=RangeRois(temparray, image) if (not self.__batch) : image.show() self.__params=self.__rr.showSettingsDialog().values() if self.__batch : image.hide() return True
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
class CounterPoint: def __init__(self,x,y,clonenum): self.x = x self.y = y self.clonenum = clonenum theImage = IJ.getImage() stayinloop = True cloneNum = 1 pointList = [] while (stayinloop): gd = NonBlockingGenericDialog("Clone counter...") gd.addNumericField("Clone:",cloneNum,0) gd.setOKLabel("Finalize clone") gd.setCancelLabel("Quit") gd.showDialog() if (gd.wasOKed()): roi = theImage.getRoi() if (not roi is None): cloneNum = int(gd.getNextNumber()) polygon = roi.getFloatPolygon() for i in range(polygon.npoints): pointList.append(CounterPoint(polygon.xpoints[i],polygon.ypoints[i],cloneNum)) IJ.run("Draw","stack") theImage.deleteRoi() cloneNum = cloneNum + 1 else:
from ij import IJ from ij import ImagePlus from ij.gui import NonBlockingGenericDialog from ij.gui import WaitForUserDialog from ij.plugin import ChannelSplitter from ij.plugin import ImageCalculator from ij.measure import ResultsTable from ij.measure import Measurements from ij.plugin.filter import Analyzer ## Main body of script theImage = IJ.getImage() gd = NonBlockingGenericDialog("Pick parameters...") gd.addChoice("Analysis_channel",["Channel "+str(i+1) for i in range(theImage.getNChannels())],"Channel 1") gd.addNumericField("Pick_threshold",50,0) gd.addCheckbox("Apply_min",True) gd.showDialog() if (gd.wasOKed()): analysisChannel = gd.getNextChoiceIndex() + 1 intensityThreshold = gd.getNextNumber() doMin = gd.getNextBoolean() splitImage = ChannelSplitter.split(theImage) dataImage = splitImage[analysisChannel-1].duplicate() if doMin: IJ.run(dataImage,"Minimum...", "radius=2 stack") goRun = True rt = ResultsTable() while goRun: wfud = WaitForUserDialog("Pick freehand ROI, then hit OK to analyze") wfud.show() roi = theImage.getRoi()
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() rm.runCommand("reset") if imp.getOverlay() is not None : imp.getOverlay().clear() overlay=Overlay() imp.setOverlay(overlay) gd0=NonBlockingGenericDialog("settings") gd0.addCheckbox("Show the overlay during the process ? (slow option)", False) gd0.addNumericField("Minimal Lifetime : ",10,0) gd0.addNumericField("Minimal distance to reversion : ",4,0) gd0.addNumericField("Sub sampling ? : ",1,0) gd0.addNumericField("Radius for fluo tracking ? : ",8,0) gd0.showDialog() isShow = gd0.getNextBoolean() minLife = gd0.getNextNumber() mind = gd0.getNextNumber() subs = gd0.getNextNumber() rayon = gd0.getNextNumber() if gd0.wasCanceled() : isShow = True imp.show() else :
from ij import IJ from ij.gui import NonBlockingGenericDialog from ij import ImageStack from ij.gui import WaitForUserDialog from ij import ImagePlus from ij.process import ImageProcessor theImage = IJ.getImage() gd = NonBlockingGenericDialog("Set slice params...") gd.addNumericField("Slice start:",1,0) gd.addNumericField("Slice end:",theImage.getNSlices(),0) gd.showDialog() if (gd.wasOKed()): startSlice = gd.getNextNumber() endSlice = gd.getNextNumber() width = theImage.getWidth() height = theImage.getHeight() newStack = ImageStack(width,height) t_line = 240 for i in range(startSlice,endSlice+1): theImage.setSlice(i) waiter = WaitForUserDialog("Set ROI","Set ROI for thresholding region") waiter.show() roi = theImage.getRoi() newip = theImage.getProcessor().duplicate() newip.setColor(0) newip.fillOutside(roi) newip.snapshot()
def runGUI(defaultTargetChannel=2, defaultdt=1.0, defaultRadius=0.3, defaultThreshold=16, defaultFrameGap=0.01, defaultLinkingMax=0.01, defaultClosingMax=0.01): gd = NonBlockingGenericDialog("ZedMate - v0.18 beta") gd.addMessage( "\tZedMate is a TrackMate-based 3D prticle analyzer \n\t\t\t\t\t\t\t\t\t\t\t(copyright Artur Yakimovich 2018-19)\n\n" ) gd.addStringField("File_extension", ".tif") gd.addStringField("File_name_contains", "") gd.addNumericField("Target_Channel", defaultTargetChannel, 0) gd.addNumericField("dt", defaultdt, 2) gd.addNumericField("Radius", defaultRadius, 2) gd.addNumericField("Threshold", defaultThreshold, 2) gd.addNumericField("Frame_Gap", defaultFrameGap, 0) gd.addNumericField("Linking_Max", defaultLinkingMax, 2) gd.addNumericField("Closing_Max", defaultClosingMax, 2) gd.addMessage("\t\t\t\t\t\t_______________________________________") gd.addCheckbox("Preview Parameters on the First Image Only", 0) gd.addMessage("\t\t\t\t\t(Doesn't save results. Re-opens this Dialog).") gd.addMessage("\t\t\t\t\t\t_______________________________________") gd.addCheckbox("Save MNIST mimicry embedding (beta)", 0) gd.showDialog() if gd.wasCanceled(): return extension = gd.getNextString() containString = gd.getNextString() targetChannel = int(gd.getNextNumber()) dt = gd.getNextNumber() radius = gd.getNextNumber() threshold = gd.getNextNumber() frameGap = int(gd.getNextNumber()) linkingMax = gd.getNextNumber() closingMax = gd.getNextNumber() testMode = gd.getNextBoolean() mimicryEmbd = gd.getNextBoolean() inputDir = IJ.getDirectory("Input_directory") if not inputDir: return if not testMode: outputDir = IJ.getDirectory("Output_directory") if not outputDir: return else: outputDir = inputDir # for the case of test #if not os.path.exists(outputDir): # os.makedirs(outputDir) runBatch(inputDir, outputDir, extension, containString, targetChannel, dt, radius, threshold, frameGap,\ linkingMax, closingMax, testMode, mimicryEmbd)
from array import zeros from ij import IJ from ij.gui import NonBlockingGenericDialog from ij.process import ByteProcessor from ij import ImageStack from ij import ImagePlus theImage = IJ.getImage() gd = NonBlockingGenericDialog("Set slice params...") gd.addNumericField("Slice start:",1,0) gd.addNumericField("Slice end:",theImage.getNSlices(),0) gd.showDialog() if (gd.wasOKed()): startSlice = gd.getNextNumber() endSlice = gd.getNextNumber() width = theImage.getWidth() height = theImage.getHeight() newStack = ImageStack(width,height) for i in range(startSlice,endSlice+1): theImage.setSlice(i) theImage.killRoi() pixels = zeros('b',width*height) bp = ByteProcessor(width,height,pixels) bp.setColor(127) doStaySlice = True while doStaySlice: waiter = NonBlockingGenericDialog("Set cast")
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() rm.runCommand("reset") if imp.getOverlay() is not None : imp.getOverlay().clear() overlay=Overlay() imp.setOverlay(overlay) gd0=NonBlockingGenericDialog("settings") gd0.addCheckbox("Show the overlay during the process ? (slow option)", False) gd0.addNumericField("Minimal Lifetime : ",10,0) gd0.addNumericField("Minimal distance to reversion : ",2,0) gd0.addNumericField("Sub sampling ? : ",1,0) gd0.showDialog() isShow = gd0.getNextBoolean() minLife = gd0.getNextNumber() mind = gd0.getNextNumber() subs = gd0.getNextNumber() if gd0.wasCanceled() : isShow = True imp.show() else : if isShow : imp.show() else : imp.hide()