def pick_roi_and_crop(self):
     self.show()
     self.display_roi()
     wait = NonBlockingGenericDialog("Move the ROI around the cell of interest")
     wait.addMessage(
         "Click ok to crop and process ROI\n" "Cancel to skip this image\n" "Check 'Quit' to terminate script"
     )
     wait.addCheckbox("Quit", False)
     wait.showDialog()
     kill_switch = wait.getCheckboxes()[0].state
     # print kill_switch
     if wait.wasOKed():
         self.crop_project_and_montage()
         while True:
             proceed = NonBlockingGenericDialog("Process another ROI?")
             proceed.addMessage("Click ok to repeat this image\n" "Click cancel to move onto next image")
             proceed.showDialog()
             if proceed.wasOKed():
                 print "Repeat this image"
                 self.crop_project_and_montage()
             else:
                 print "Lets move on"
                 for i in self.stack_imps.values():
                     i.close()
                 break
         return kill_switch
     else:
         print "User canceled this image before doing anything"
         for i in self.stack_imps.values():
             i.close()
         return kill_switch
示例#2
0
def MakeSubset(directory_load, directory_save, chl, frames, z_planes, loops,
               total, pat, title, imp2):
    subd = NonBlockingGenericDialog("Make subset")
    subd.addCheckbox("Duplicate only the current frames", False)
    subd.addCheckbox("Export XYTC of a subset of loops", False)

    subd.addSlider("Subset from loop number", 0, loops - 1, 0)
    subd.addSlider("Subset to loop number", 0, loops - 1, 0)
    subd.showDialog()

    slider_subd1 = subd.getSliders().get(0).getValue()
    slider_subd2 = subd.getSliders().get(1).getValue()
    checkbox_subd1 = subd.getNextBoolean()
    checkbox_subd2 = subd.getNextBoolean()

    if checkbox_subd1 == True:
        SliceNum = imp2.getCurrentSlice()
        FloorSlice50 = float(SliceNum) / frames
        S50 = (math.floor(FloorSlice50) * frames) + 1
        S100 = S50 + (frames - 1)
        print("Slice" + str(SliceNum) + "_FloorSlice_" + str(FloorSlice50) +
              "_frames_" + str(S50) + "-" + str(S100) + "")
        IJ.run(
            "Duplicate...", "title=Image_DUP duplicate range=" + str(S50) +
            "-" + str(S100) + "")
        impDup = WM.getImage("Image_DUP")
    if checkbox_subd2 == True:
        SubsetL(directory_load, directory_save, chl, frames, z_planes, loops,
                total, pat, title, slider_subd1, slider_subd2)
示例#3
0
	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
示例#4
0
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)
示例#5
0
def apply_thresh_overlay(overlay):
    ''' Clear outside rois in overlay '''

    # --- Dialog -----------------------------------
    wlist = WindowManager.getImageTitles()
    gd = NonBlockingGenericDialog('Apply Mask to')
    gd.setCancelLabel('Exit')
    gd.addChoice('Select Movie', wlist, wlist[0])
    gd.addCheckbox('Duplicate', True)

    gd.showDialog()  # dialog is open

    if gd.wasCanceled():
        return False

    sel_win = gd.getNextChoice()
    do_duplicate = gd.getNextBoolean()

    # --- Dialog End ------------------------------

    win_name = IJ.selectWindow(sel_win)
    movie = IJ.getImage()
    movie = slices_to_frames(movie)

    C = movie.getC()
    S = movie.getSlice()

    if do_duplicate:
        IJ.log('duplicating ' + movie.shortTitle)
        movie = movie.duplicate()

    NFrames = movie.getNFrames()

    if overlay.size() != NFrames:  # one roi for each frame!
        display_msg(
            'Mask count mismatch!', 'Mask count mismatch!\nGot ' + str(Nrois) +
            ' masks and ' + str(NFrames) + ' frames.. !')

    for frame in range(1, NFrames + 1):
        movie.setPosition(C, S, frame)
        mask_roi = overlay.get(frame - 1)
        ip = movie.getProcessor()
        ip.setValue(0)
        ip.setRoi(mask_roi)
        ip.fillOutside(mask_roi)

    movie.show()
    return True
valplot.add(
    "line",
    (icalibration.getX(retval[2] + 1), icalibration.getX(retval[1] + 1)),
    (retval[4], retval[4]))
valplot.add(
    "line",
    (icalibration.getX(retval[1] + 1), icalibration.getX(retval[1] + 1)),
    (retval[3], retval[4]))
valplot.add(
    "line",
    (icalibration.getX(retval[2] + 1), icalibration.getX(retval[2] + 1)),
    (retval[3], retval[4]))
valplot.show()
valplot.update()
proceed = NonBlockingGenericDialog("Accept Or Reject?")
proceed.addCheckbox("Uncheck To Reject", True)
proceed.showDialog()
proceed = proceed.getNextBoolean()
WindowManager.getWindow("Angle-Distance Correlation Values").close()
WindowManager.getImage("pixarr").close()
WindowManager.getImage("DUP_" + title).close()
if proceed:
    roi = analyte.getRoi()
    roiStats = roi.getStatistics()
    ferets = roi.getFeretValues()
    rt = WindowManager.getWindow(
        "Cardiomyocyte Results").getTextPanel().getOrCreateResultsTable()
    a = rt.getCounter()
    rt.setValue("Correlation Score", a, retval[0])
    rt.setValue("Sarcomere Length", a, icalibration.getX(retval[1] + 1))
    rt.setValue("Area", a, roiStats.area)
示例#7
0
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(
    "Select the directory of your files").getDirectory()
示例#8
0
	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
示例#9
0
	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
示例#10
0
	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
		
theImage = IJ.getImage()
stayinloop = True
# IJ.run("RGB Color")

injuryfirst = True
injuryLengths = []
totalLengths = []
injuryRatios = []
Xpositions = []
while stayinloop:
	gd = NonBlockingGenericDialog("Pick points...")
	gd.addMessage("Use multipoint tool to pick points along a column (Y-axis).\nAlternate points to mark injured vs uninjured area.")
	gd.setCancelLabel("Quit")
	gd.setOKLabel("Define column")
	gd.addCheckbox("First segment is injury?",injuryfirst)
	gd.showDialog()

	if (gd.wasOKed()):
		roi = theImage.getRoi()
		if roi is None:
			IJ.error("No ROI selected")
		else:		
			polygon = roi.getFloatPolygon()

			# if len(polygon.xpoints) % 2 == 0 and is_monotonic_increasing(polygon.ypoints):
			if is_monotonic_increasing(polygon.ypoints):
				xset = average(polygon.xpoints)
				IJ.setForegroundColor(255,255,0)
				IJ.run("Draw","stack")
				IJ.makeLine(xset,0,xset,theImage.getHeight())
				rescaledTup = [objectDB[i][j][27]/scale_info[0],objectDB[i][j][28]/scale_info[0],objectDB[i][j][29],objectDB[i][j][30]/scale_info[0],objectDB[i][j][31]/scale_info[0],objectDB[i][j][32]]
				objectDB[i][j] = objectDB[i][j] + rescaledTup

		## Draws the bounding boxes in the precomputed way
		virginImage = IJ.getImage()
		theImage = virginImage.duplicate()
		virginImage.hide()
		boxImages = []
		for i in range(len(objectDB)):
			boxImages.append(draw_bounding_boxes(objectDB[i],"image_"+str(i+1),virginImage))
		virginImage.show()
		
		## Sets up main GUI interface for examining found objects
		
		ngd = NonBlockingGenericDialog("Control box")
		ngd.addCheckbox("Contained_objects",False)
		ngd.addCheckbox("Duplicated_objects",False)
		ngd.addCheckbox("Restitched_objects",False)
		ngd.addCheckbox("Unique_objects",False)
		boxes = ngd.getCheckboxes()
		checkboxObjects = []
		for i in range(boxes.size()):
			checkboxObjects.append(boxes.elementAt(i))
		for i in range(len(checkboxObjects)):
			checkboxObjects[i].addItemListener(CustomCheckboxListener(objectDB,virginImage,boxImages,boxes))
		ngd.setCancelLabel("Exit")
		ngd.setOKLabel("Inspect")
		ngd.showDialog()
		if (ngd.wasCanceled()):
			titles = WindowManager.getImageTitles()
			p = re.compile(r'^Result')
示例#13
0
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()

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()
示例#14
0
    T = txt2list(os.path.join(thisdir, 't.csv'))
    X = txt2list(os.path.join(thisdir, 'x.csv'))
    Y = txt2list(os.path.join(thisdir, 'y.csv'))
    nuclei = defaultdict(list)
    for i, t in enumerate(T):
        nuclei[t] = (X[i], Y[i])
    print 'Working on: ', cID
    # Add listener to image
    listener = PointRoiRefresher(imp, nuclei)
    ImagePlus.addImageListener(listener)

    # Wait for user to clear current cell
    gd = NonBlockingGenericDialog("Advance to next cell?")
    gd.setOKLabel('Next')
    gd.setCancelLabel('Completely exit')
    gd.addCheckbox('Skip this cell?', False)
    gd.showDialog()
    if gd.wasOKed():  # OK means 'advance'
        imp.removeImageListener(listener)
        if gd.getNextBoolean():
            with open(os.path.join(thisdir, 'skipped.txt'), 'w') as f:
                f.write('Skipped')
        # Log the cell as done
        with open(log_filename, 'a') as f:
            f.write(''.join((cID, '\n')))
        print "Advancing to next cell..."
        continue

    if gd.wasCanceled():  # Cancel means 'exit'
        imp.removeImageListener(listener)
        print "Exiting completely."
示例#15
0
    )
    if ChCheck > 1:
        IJ.run(
            imp2, "Properties...", "channels=1 slices=" + str(total) +
            " frames=1 unit=micron pixel_width=2.3140 pixel_height=2.3140 voxel_depth=2.5005 frame=[0.02 sec]"
        )

    # The dialag has to be non-blocking to interact with the data, this dialog will access the controller classes and handle your images
    # The dialag needs to be out of a function to get global variables
    gd = NonBlockingGenericDialog("6D_processor")
    gd.addSlider("C", 1, ch, 1)
    gd.addSlider("Z", 0, zplanes - 1, 0)
    gd.addSlider("T", 0, frames - 1, 0)
    gd.addSlider("L", 0, loops - 1, 0)
    # Make checkboxes for output functions
    gd.addCheckbox("Make subset", False)
    gd.addCheckbox("Split into XYTC", False)
    gd.addCheckbox("Arg. csv BeatSync", False)
    # The UI elements for the above two inputs
    slider1 = gd.getSliders().get(0)  # the only one
    slider2 = gd.getSliders().get(1)
    slider3 = gd.getSliders().get(2)
    slider4 = gd.getSliders().get(3)

    # Set initial position for the two channels
    if ChCheck > 1:
        imp2.setPosition(1, 51, 1)

    #Access controller classes
    previewer1 = ControllerC(imp, slider1)
    previewer2 = ControllerZ(imp, slider2)
								" 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))
				workROIBox.addItemListener(WorkROICheckboxListener(dataImage,thresholdSlider,sizeText,workROIBox))
				gd10.showDialog()
	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()
		whichTiles = gd.getNextString()
		tileList = []
		parsingFailed = False
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()