def registerExtenderCallbacks(self, callbacks):
# keep a reference to our callbacks object
self._callbacks = callbacks
# obtain an extension helpers object
self._helpers = callbacks.getHelpers()
# define stdout writer
self._stdout = PrintWriter(callbacks.getStdout(), True)
self._stdout.println(self.EXTENSION_NAME + ' by @luxcupitor')
self._stdout.println('================================')
self._stdout.println('')
self._stdout.println('TIP: Go to "Custom Scanner" tab and click "Execute on Proxy History"')
self._stdout.println('to run the scanner checks on recently imported session files.')
self._stdout.println('')
# set our extension name
callbacks.setExtensionName(self.EXTENSION_NAME)
callbacks.registerScannerCheck(self)
# add the custom tab and button to Burp's UI
self._newpanel = Panel()
self._newpanel.setLayout(FlowLayout())
self._button = JButton("Execute on Proxy History", actionPerformed=self.checkProxyHistory)
self._newpanel.add(self._button)
callbacks.customizeUiComponent(self._newpanel)
callbacks.addSuiteTab(self)
return
def addControl(self, dialog):
if self.control_type==MyControlDefinition.Numeric:
dialog.addNumericField(self.label, self.default_val, 2);
dialog.getNumericFields()[-1].setEnabled(self.enabled);
elif self.control_type==MyControlDefinition.String:
dialog.addStringField(self.label, self.default_val);
dialog.getStringFields()[-1].setEnabled(self.enabled);
elif self.control_type==MyControlDefinition.Choice:
if not self.default_val in self.choices:
raise IndexError("default value isn''t in list of choices");
dialog.addChoice(self.label, self.choices, self.default_val);
dialog.getChoices()[-1].setEnabled(self.enabled);
elif self.control_type==MyControlDefinition.Checkbox:
if not isinstance(self.default_val, bool):
raise TypeError();
dialog.addCheckbox(self.label, self.default_val);
dialog.getCheckboxes()[-1].setEnabled(self.enabled);
elif self.control_type==MyControlDefinition.RadioButtonGroup:
if not self.default_val in self.choices:
raise IndexError("default value isn''t in list of choices");
panel = Panel();
cbg = CheckboxGroup();
for ch in self.choices:
cb = Checkbox(ch, cbg, ch==self.default_val)
cb.setEnabled(self.enabled);
self.checkboxes.append(cb);
panel.add(cb);
dialog.addPanel(panel);
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
class BurpExtender(IBurpExtender, IHttpListener, IScannerCheck, IScannerListener, IScanIssue, ITab, IMessageEditorTab):
def registerExtenderCallbacks(self, callbacks):
self._callbacks = callbacks
self.helpers = callbacks.getHelpers()
self._callbacks.setExtensionName("Suggester")
callbacks.registerHttpListener(self)
callbacks.registerScannerListener(self)
callbacks.registerScannerCheck(self)
callbacks.setProxyInterceptionEnabled(False)
############################
# add the custom tab and button to Burp's UI
self._newpanel = Panel()
self._newpanel.setLayout(FlowLayout())
callbacks.customizeUiComponent(self._newpanel)
callbacks.addSuiteTab(self)
return
### IScannerCheck ###
def doPassiveScan(self, baseRequestResponse):
# print "\n"
analyzedResponse = self.helpers.analyzeResponse(baseRequestResponse.getResponse()) # Returns IResponseInfo
analyzedRequest = self.helpers.analyzeRequest(baseRequestResponse)
urlList = analyzedRequest.getUrl()
paramList = analyzedRequest.getParameters()
contenttypeList = analyzedRequest.getContentType()
issues = []
# print "\nURL:"
# print urlList
if self._callbacks.isInScope(urlList):
for param in paramList:
vulnparam=param.getName()
vulncheck(urlList, vulnparam)
# print "\nCT:"
# print contenttypeList
# print "-----------------------------------------------"
return
def getTabCaption(self):
'''Name of our tab'''
return "Suggester"
def getUiComponent(self):
'''return our panel'''
return self._newpanel
def __init__(self, listCategories): """ listCategories: initial list of categories to fill the fields """ GenericDialogPlus.__init__(self, "Category names") self.addPanel( Panel(GridLayout(0,1)) ) self.panel = self.getComponent(0) for category in listCategories: self.panel.add( TextField(category) ) # Add string input to GUI self.addButton(CategoryDialog.ADD_CATEGORY, self)
def getUiComponent(self):
panel = Panel()
panel.setBackground(Color.gray)
button = Button('Hello Burp Button!')
panel.add(button)
self.callbacks.customizeUiComponent(
panel) # customize UI components in line with Burp's UI style
return panel
def gui(self):
x = 10 # panel padding
y = 5 # panel padding
self.panel = Panel()
self.panel.setLayout(None)
self.scn_lbl = JLabel("Enable scanning")
self.scn_lbl.setBounds(x, y, 100, 20)
self.panel.add(self.scn_lbl)
self.enable = JCheckBox()
self.enable.setBounds(x + 120, y, 50, 20)
self.panel.add(self.enable)
self.rand_lbl = JLabel("Randomize payloads")
self.rand_lbl.setBounds(x, y + 15, 100, 20)
self.panel.add(self.rand_lbl)
self.randomize = JCheckBox()
self.randomize.setBounds(x + 120, y + 15, 50, 20)
self.panel.add(self.randomize)
self.pyld_lbl = JLabel("Payloads List (Line separated)")
self.pyld_lbl.setBounds(x, y + 30, 180, 20)
self.panel.add(self.pyld_lbl)
self.payloads_list = JTextArea()
self.pyld_scrl = JScrollPane(self.payloads_list)
self.pyld_scrl.setBounds(x, y + 50, 600, 200)
self.panel.add(self.pyld_scrl)
self.save_btn = JButton("Save", actionPerformed=self.save_settings)
self.save_btn.setBounds(x, y + 250, 100, 30)
self.panel.add(self.save_btn)
# Settings loader from [utils/Helpers/load_settings]
self.load_settings()
return self
def registerExtenderCallbacks(self, callbacks):
self._callbacks = callbacks
self.helpers = callbacks.getHelpers()
self._callbacks.setExtensionName("Suggester")
callbacks.registerHttpListener(self)
callbacks.registerScannerListener(self)
callbacks.registerScannerCheck(self)
callbacks.setProxyInterceptionEnabled(False)
############################
# add the custom tab and button to Burp's UI
self._newpanel = Panel()
self._newpanel.setLayout(FlowLayout())
callbacks.customizeUiComponent(self._newpanel)
callbacks.addSuiteTab(self)
return
def choose_series(filepath, params):
"""if input file contains more than one image series (xy position), prompt user to choose which one to use"""
# todo: if necessary (e.g. if lots of series), can improve thumbnail visuals based loosely on https://github.com/ome/bio-formats-imagej/blob/master/src/main/java/loci/plugins/in/SeriesDialog.java
import_opts = ImporterOptions();
import_opts.setId(filepath);
reader = ImageReader();
ome_meta = MetadataTools.createOMEXMLMetadata();
reader.setMetadataStore(ome_meta);
reader.setId(filepath);
no_series = reader.getSeriesCount();
if no_series == 1:
return import_opts, params;
else:
series_names = [ome_meta.getImageName(idx) for idx in range(no_series)];
dialog = GenericDialog("Select series to load...");
dialog.addMessage("There are multiple series in this file! \n" +
"This is probably because there are multiple XY stage positions. \n " +
"Please choose which series to load: ");
thumbreader = BufferedImageReader(reader);
cbg = CheckboxGroup();
for idx in range(no_series):
p = Panel();
p.add(Box.createRigidArea(Dimension(thumbreader.getThumbSizeX(), thumbreader.getThumbSizeY())));
ThumbLoader.loadThumb(thumbreader, idx, p, True);
dialog.addPanel(p);
cb = Checkbox(series_names[idx], cbg, idx==0);
p.add(cb);
dialog.showDialog();
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled");
if dialog.wasOKed():
selected_item = cbg.getSelectedCheckbox().getLabel();
selected_index = series_names.index(selected_item);
params.setSelectedSeriesIndex(selected_index);
for idx in range(0, no_series):
import_opts.setSeriesOn(idx, True) if (idx==selected_index) else import_opts.setSeriesOn(idx, False);
reader.close();
return import_opts, params
return checkbox
############### GUI - CATEGORY DIALOG #############
textFilePath = textFile.getPath() if textFile else ""
listCategories = getCategoriesFrom(categorySource, textFilePath)
# Initialize a category dialog with list of categories
catDialog = CategoryDialog(listCategories)
catDialog.showDialog()
# Recover fields from the formular
if catDialog.wasOKed():
# Loop over categories, adding a tickbox to the panel for each
catPanel = Panel(GridLayout(
0, 4)) # Unlimited number of rows - fix to 4 columns
for category in catDialog.getListCategories():
# Make a checkbox with the category name
box = Checkbox(category, False)
box.setFocusable(
False) # important to have the keyboard shortcut working
# Add checkbox to the gui for this category
catPanel.add(box)
## Initialize dialog
winButton = MainDialog(catPanel, browse_mode, run_measure)
winButton.showDialog()
class BurpExtender(IBurpExtender, ITab, IScannerCheck, IScannerInsertionPoint):
# definitions
EXTENSION_NAME="CustomScanner"
def registerExtenderCallbacks(self, callbacks):
# keep a reference to our callbacks object
self._callbacks = callbacks
# obtain an extension helpers object
self._helpers = callbacks.getHelpers()
# define stdout writer
self._stdout = PrintWriter(callbacks.getStdout(), True)
self._stdout.println(self.EXTENSION_NAME + ' by @luxcupitor')
self._stdout.println('================================')
self._stdout.println('')
self._stdout.println('TIP: Go to "Custom Scanner" tab and click "Execute on Proxy History"')
self._stdout.println('to run the scanner checks on recently imported session files.')
self._stdout.println('')
# set our extension name
callbacks.setExtensionName(self.EXTENSION_NAME)
callbacks.registerScannerCheck(self)
# add the custom tab and button to Burp's UI
self._newpanel = Panel()
self._newpanel.setLayout(FlowLayout())
self._button = JButton("Execute on Proxy History", actionPerformed=self.checkProxyHistory)
self._newpanel.add(self._button)
callbacks.customizeUiComponent(self._newpanel)
callbacks.addSuiteTab(self)
return
def getTabCaption(self):
'''Name of our tab'''
return self.EXTENSION_NAME
def getUiComponent(self):
'''return our panel and button we setup'''
return self._newpanel
def checkProxyHistory(self,msg):
'''This is what gets executed when the button in our panel is clicked'''
for proxyitem in self._callbacks.getProxyHistory():
self.logScanIssue(proxyitem)
return
def getMatches(self, response, match):
'''This finds our pattern match in the request/response and returns an int array'''
start = 0
count = 0
matches = [array('i')]
while start < len(response):
start=self._helpers.indexOf(response, match, True, start, len(response))
if start == -1:
break
try:
matches[count]
except:
matches.append(array('i'))
matches[count].append(start)
matches[count].append(start+len(match))
start += len(match)
count += 1
return matches
def doPassiveScan(self, baseRequestResponse):
'''This sets up our custom check and returns the issue a list array'''
PATTERN="secretdata"
ISSUE_NAME="Pattern found in HTTP Response"
ISSUE_DETAIL="HTTP Response contains this pattern: " + PATTERN
ISSUE_BACKGROUND="The web site has exposed sensitive information"
REMEDIATION_BACKGROUND="Sensitive information"
REMEDIATION_DETAIL="Ensure sensitive information is only shown to authorized users"
SEVERITY="Information"
CONFIDENCE="Certain"
issue = list()
match = self.getMatches(baseRequestResponse.getResponse(), PATTERN)
if len(match) > 0:
httpmsgs = [self._callbacks.applyMarkers(baseRequestResponse,None,match)]
issue.append(ScanIssue(baseRequestResponse.getHttpService(), self._helpers.analyzeRequest(baseRequestResponse).getUrl(), httpmsgs, ISSUE_NAME, ISSUE_DETAIL, SEVERITY, CONFIDENCE, REMEDIATION_DETAIL, ISSUE_BACKGROUND, REMEDIATION_BACKGROUND))
return issue
def logScanIssue(self, baseRequestResponse):
'''This is redundant (mostly) of the doPassiveScan function'''
PATTERN="BEEFSESSION"
ISSUE_NAME="Pattern found in Cookie header"
ISSUE_DETAIL="HTTP Request contains this pattern: " + PATTERN
ISSUE_BACKGROUND="The web browser might be hooked with BeEF"
REMEDIATION_BACKGROUND="Potential XSS Zombie"
REMEDIATION_DETAIL="Ensure this was from you"
SEVERITY="High"
CONFIDENCE="Tentative"
for header in self._helpers.analyzeRequest(baseRequestResponse).getHeaders():
if "Cookie:" in header and PATTERN in header:
match = self.getMatches(baseRequestResponse.getRequest(), PATTERN)
httpmsgs = [self._callbacks.applyMarkers(baseRequestResponse,match,None)]
issue=ScanIssue(baseRequestResponse.getHttpService(), self._helpers.analyzeRequest(baseRequestResponse).getUrl(), httpmsgs, ISSUE_NAME, ISSUE_DETAIL, SEVERITY, CONFIDENCE, REMEDIATION_DETAIL, ISSUE_BACKGROUND, REMEDIATION_BACKGROUND)
self._callbacks.addScanIssue(issue)
return
def doActiveScan(self, baseRequestResponse, insertionPoint):
INJECTION="id"
PATTERN="uid="
ISSUE_NAME="Command Injection"
ISSUE_DETAIL="Vulnerable to command injection"
ISSUE_BACKGROUND="The web site has responded to command injection attempt"
REMEDIATION_BACKGROUND="Sanitize all inputs"
REMEDIATION_DETAIL="Assume all client supplied inputs are bad."
SEVERITY="High"
CONFIDENCE="Certain"
issue = list()
checkRequest = insertionPoint.buildRequest(INJECTION)
checkRequestResponse = self._callbacks.makeHttpRequest(baseRequestResponse.getHttpService(), checkRequest)
match = self.getMatches(checkRequestResponse.getResponse(), PATTERN)
if len(match) > 0:
requestHighlights = [insertionPoint.getPayloadOffsets(INJECTION)]
httpmsgs = [self._callbacks.applyMarkers(checkRequestResponse, requestHighlights, match)]
issue.append(ScanIssue(baseRequestResponse.getHttpService(), self._helpers.analyzeRequest(baseRequestResponse).getUrl(), httpmsgs,ISSUE_NAME, ISSUE_DETAIL, SEVERITY, CONFIDENCE, REMEDIATION_DETAIL, ISSUE_BACKGROUND, REMEDIATION_BACKGROUND))
return issue
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
if nCat <= 12: button.setToolTipText("Keyboard shortcut: F" + str(nCat)) # F shortcut labels are 1-based, ie match the len value
return button
############### GUI - CATEGORY DIALOG - collect N classes names (N define at first line) #############
textFilePath = textFile.getPath() if textFile else ""
listCategories = getCategoriesFrom(categorySource, textFilePath) # initial list, before user-edit
catDialog = CategoryDialog(listCategories)
catDialog.showDialog()
################# After OK clicking ###########
# Recover fields from the formular
if catDialog.wasOKed():
# Loop over categories and add a button to the panel for each
catPanel = Panel(GridLayout(0,4)) # Unlimited number of rows - fix to 4 columns - not possible to use a JPanel, not supported by GenericDialog
listCat = catDialog.getListCategories()
listShortcut = range( 112, 112+len(listCat)
)
for index, category in enumerate(listCat):
# Create a Button
button = JButton(category) # button label
if index<12: button.setToolTipText( "Keyboard shortcut: F" + str(index+1) ) # index is 0-based, F shortcut are 1-based
# Bind action to button
button.addActionListener(categoryAction)
self.fireTableRowsDeleted(first, last)
self.nRows -= last - first + 1
if __name__ in ['__builtin__', '__main__']:
'''
Test the table model by generating a simple window with just the table
1) Initialized a JTable with the RoiGroupTableModel
2) Put the JTable in a JScrollPane
3) Put the JScrollPane in a Panel
4) Put the Panel in a Generic Dialog
5) Display the GenericDialog
'''
from javax.swing import JTable, JScrollPane
from ij.gui import GenericDialog
from java.awt import Panel
tableModel = TableModel()
table = JTable(tableModel)
tableModel.setGroupColumn("A,B,C")
print tableModel.getGroupString()
tablePane = JScrollPane(table)
table.setFillsViewportHeight(True)
gd = GenericDialog("Roi-group table")
panel = Panel()
panel.add(tablePane)
gd.addPanel(panel) # Add current table instance to panel
gd.showDialog()
def settings():
""" Settings """
# Calls potential config file to set defaults
# for settings dialog. Sets all defaults to 0
# if no config file exists.
con_path = os.path.join(str(Root), "FRET_params.cfg")
if os.path.exists(con_path):
dflt = config_read()
print type(dflt.get("b_sub", "Rolling ball"))
print (dflt.get("b_sub", "Rolling ball"))
print type(int(dflt.get("b_sub", "Rolling ball")))
print (dflt.get("b_sub", "Rolling ball"))
else:
dflt = {}
feat_model_strings = ["Translation", "Rigid",
"Similarity", "Affine
]
reg_model_strings = ["Translation", "Rigid",
"Similarity", "Affine",
"Elastic", "Least Squares"
]
b_sub_strings = ["Rolling Ball", "Manual Selection"]
# Registration parameters dialog.
gd = GenericDialog("Advanced Settings")
gd.addMessage("REGISTRATION PARAMETERS")
gd.addNumericField("Steps per scale octave: ", float(dflt.get("steps", 6)), 0, 7, "")
gd.addNumericField("Max Octave Size: ", float(dflt.get("max_oct", 1024)), 0, 7, "")
gd.addNumericField("Feature Descriptor Size: ", float(dflt.get("fd_size", 12)), 1, 7, "")
gd.addNumericField("Initial Sigma: ", float(dflt.get("sigma", 1.2)), 2, 7, "")
gd.addNumericField("Max Epsilon: ", float(dflt.get("max_eps", 15)), 1, 7, "")
gd.addNumericField("Min Inlier Ratio: ", float(dflt.get("min_inlier", 0.05)), 3, 7, "")
gd.addCheckbox("Use Shrinkage Constraint", ast.literal_eval(dflt.get("shrinkage", "False")))
gd.addChoice("Feature extraction model", feat_model_strings,
feat_model_strings[int(dflt.get("feat_model", 1))]
)
gd.addChoice("Registration model", reg_model_strings,
reg_model_strings[int(dflt.get("reg_model", 1))]
)
# Background removal parameters dialog.
gd.addPanel(Panel())
gd.addMessage("BACKGROUND REMOVAL")
gd.addChoice("Subtraction method:", b_sub_strings,
b_sub_strings[int(dflt.get("b_sub", 0))]
)
gd.addNumericField("Rolling ball size: ",
float(dflt.get("ballsize", 50)), 1, 7, "px"
)
gd.addCheckbox("Create Background", ast.literal_eval(dflt.get("create_b", "False")))
gd.addCheckbox("Light Background", ast.literal_eval(dflt.get("light_b", "False")))
gd.addCheckbox("Use Parabaloid", ast.literal_eval(dflt.get("parab", "False")))
gd.addCheckbox("Do Pre-smoothing", ast.literal_eval(dflt.get("smooth", "False")))
gd.addCheckbox("Correct Corners", ast.literal_eval(dflt.get("corners", "False")))
# Measumrent parameters dialog.
gd.addPanel(Panel())
gd.addMessage("MEASUREMENT PARAMETERS")
gd.addNumericField("Max Cell Area", float(dflt.get("cell_max", 2200)), 0, 7, "px")
gd.addNumericField("Min Cell Area", float(dflt.get("cell_min", 200)), 0, 7, "px")
gd.addNumericField("Ratio Subtraction", float(dflt.get("subtr_ratio", 0.31)), 3, 7, "")
# Plot parameters dialog.
gd.addPanel(Panel())
gd.addMessage("PLOT PARAMETERS")
gd.addNumericField("Max y, d and aFRET", float(dflt.get("p_max", 0.65)), 2, 7, "")
gd.addNumericField("Min y, d and aFRET", float(dflt.get("p_min", 0.0)), 2, 7, "")
gd.addNumericField("Max y, norm. d and aFRET", float(dflt.get("p_max_n", 1.65)), 2, 7, "")
gd.addNumericField("Min y, norm. d and aFRET", float(dflt.get("p_min_n", 0.5)), 2, 7, "")
# Set location of dialog on screen.
#gd.setLocation(0,1000)
gd.showDialog()
# Checks if cancel was pressed, kills script.
if gd.wasCanceled() is True:
sys.exit("Cancel was pressed, script terminated.")
# Parameters dictionary.
parameters = {"steps" : gd.getNextNumber(),
"max_oct" : gd.getNextNumber(),
"fd_size" : gd.getNextNumber(),
"sigma" : gd.getNextNumber(),
"max_eps" : gd.getNextNumber(),
"min_inlier" : gd.getNextNumber(),
"shrinkage" : gd.getNextBoolean(),
"feat_model" : gd.getNextChoiceIndex(),
"reg_model" : gd.getNextChoiceIndex(),
"b_sub" : gd.getNextChoiceIndex(),
"ballsize" : gd.getNextNumber(),
"create_b" : gd.getNextBoolean(),
"light_b" : gd.getNextBoolean(),
"parab" : gd.getNextBoolean(),
"smooth" : gd.getNextBoolean(),
"corners" : gd.getNextBoolean(),
"cell_max" : gd.getNextNumber(),
"cell_min" : gd.getNextNumber(),
"subtr_ratio" : gd.getNextNumber(),
"p_max" : gd.getNextNumber(),
"p_min" : gd.getNextNumber(),
"p_max_n" : gd.getNextNumber(),
"p_min_n" : gd.getNextNumber()
}
parameters = config_write(parameters)
return parameters
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
def perform_user_qc(in_imp, edges, alt_edges, fixed_anchors_list, params):
"""allow the user to intervene to fix erroneously identified membrane edges"""
n_frames = in_imp.getNFrames();
n_channels = in_imp.getNChannels();
output_folder = params.output_path;
current_edges = edges;
rgbstack = ImageStack(in_imp.getWidth(), in_imp.getHeight());
if n_frames > 1:
for tidx in range(n_frames):
in_imp.setT(tidx+1);
ip = in_imp.getProcessor();
rgbip = ip.convertToRGB();
rgbstack.addSlice(rgbip);
else:
for cidx in range(n_channels):
in_imp.setC(cidx+1);
ip = in_imp.getProcessor();
rgbip = ip.convertToRGB();
rgbstack.addSlice(rgbip);
imp = ImagePlus(("RGB " + in_imp.getTitle()), rgbstack);
IJ.run("Colors...", "foreground=red background=white selection=yellow");
for tidx in range(imp.getNSlices()):
imp.setSlice(tidx+1);
for anchor in params.manual_anchor_positions:
imp.setRoi(PointRoi(anchor[0], anchor[1]));
IJ.run(imp, "Draw", "slice");
imp.show();
autoset_zoom(imp);
imp.setPosition(1);
imp.setRoi(current_edges[0]);
if n_frames > 1:
listener = UpdateRoiImageListener(current_edges);
imp.addImageListener(listener);
IJ.setTool("freeline");
do_flip = True;
while do_flip:
dialog = NonBlockingGenericDialog("User quality control");
dialog.enableYesNoCancel("Continue", "Flip all edges");
dialog.setCancelLabel("Cancel analysis");
dialog.addMessage("Please redraw the membrane edges as necessary, \n" +
"making sure to draw beyond anchor points at either end...\n" +
"Click OK when done. ");
p = Panel();
but = Button("Flip this edge");
al = Listener(edges, alt_edges, imp);
but.addActionListener(al);
p.add(but);
dialog.addPanel(p);
dialog.showDialog();
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled");
elif dialog.wasOKed():
do_flip = False;
else:
print("flip edges");
do_flip = True;
if n_frames > 1:
imp.removeImageListener(listener);
current_edges = alt_edges if (current_edges == edges) else edges;
imp.setPosition(1);
imp.setRoi(current_edges[0]);
if n_frames > 1:
listener = UpdateRoiImageListener(current_edges);
imp.addImageListener(listener);
last_roi = imp.getRoi();
if n_frames > 1:
qcd_edges = listener.getRoiList();
if imp.getNFrames() > imp.getNSlices():
qcd_edges[imp.getT() - 1] = last_roi;
else:
qcd_edges[imp.getZ() - 1] = last_roi;
imp.removeImageListener(listener);
else:
qcd_edges = [last_roi];
mbio.save_qcd_edges2(qcd_edges, output_folder);
# next four lines are a quick and dirty hack...
if n_frames > 1:
nframes = imp.getNFrames() if imp.getNFrames()>imp.getNSlices() else imp.getNSlices();
else:
nframes = n_frames;
for fridx in range(0, nframes):
if (qcd_edges[fridx].getType()==Roi.FREELINE) or (qcd_edges[fridx].getType()==Roi.POLYLINE):
if (fridx == 0) or params.constrain_anchors:
anchors = params.manual_anchor_positions;
else:
anchors = fixed_anchors_list[fridx - 1];
fixed_anchors = mb.fix_anchors_to_membrane(anchors, qcd_edges[fridx], params);
fixed_anchors = mb.order_anchors(fixed_anchors, params.manual_anchor_midpoint);
fixed_anchors_list[fridx] = fixed_anchors;
poly = qcd_edges[fridx].getInterpolatedPolygon(0.25, False);
polypoints = [(x,y) for x,y in zip(poly.xpoints, poly.ypoints)];
idx = [polypoints.index(fixed_anchors[0]), polypoints.index(fixed_anchors[1])];
idx.sort();
polypoints = polypoints[idx[0]:idx[1]];
newedge = PolygonRoi([x for (x,y) in polypoints],
[y for (x,y) in polypoints],
Roi.POLYLINE);
newedge = mb.check_edge_order(anchors, newedge);
imp.setPosition(fridx + 1);
imp.setRoi(newedge);
IJ.run(imp, "Interpolate", "interval=1.0 smooth adjust");
IJ.run(imp, "Fit Spline", "");
qcd_edges[fridx] = imp.getRoi();
mbio.save_qcd_edges2(qcd_edges, output_folder);
imp.changes = False;
imp.close();
return qcd_edges, fixed_anchors_list;
# inherits from the Java ActionListener interface.
#
class TestButtonAction(ActionListener):
def actionPerformed(self, e):
textArea.append("Test Button Clicked!\n")
#
# Create the Frame, Panel, Button,
# TextArea, and TestButtonAction objects.
#
frame = Frame("Hello World")
panel = Panel()
button = Button("Test Button")
buttonAction = TestButtonAction()
textArea = TextArea()
#
# Put everything together and show
# the window.
#
button.addActionListener(buttonAction)
panel.add(button)
panel.add(textArea)
frame.add(panel)
frame.pack()
frame.show()
# inherits from the Java ActionListener interface.
#
class TestButtonAction(ActionListener):
def actionPerformed(self, e):
textArea.append("Test Button Clicked!\n")
#
# Create the Frame, Panel, Button,
# TextArea, and TestButtonAction objects.
#
frame = Frame("Hello World")
panel = Panel()
button = Button("Test Button")
buttonAction = TestButtonAction()
textArea = TextArea()
#
# Put everything together and show
# the window.
#
button.addActionListener(buttonAction)
panel.add(button)
panel.add(textArea)
frame.add(panel)
frame.pack()
headers = csvIterator.next() # read first header line
n = len(headers)
dropdowns = [
[] for i in range(n)
] # [[], [], [], [], []] such that dropdowns[i] contains the list of choices for dropdowns i
for row in csvIterator:
for i, entry in enumerate(row): # row is a list
if entry:
dropdowns[i].append(
entry
) # dropdown[i] is the list of choices # if necessary since all columns might not have the same length
# Create horizontal panel for dropdowns
panel = Panel(GridLayout(
0, n)) # as many columns (n) as menus, as many rows as necessary (0)
# First panel row -> dropdown labels
for header in headers:
panel.add(Label(header))
# Second panel row -> dropdown choices
for i in range(n):
label = headers[i]
chooser = Choice()
chooser.setName(label) # not display but easier to recover infos
dropdown = dropdowns[i]
for option in dropdown:
chooser.add(option)
readme_fpath = os.path.join(script_path, "README.txt")
params = Parameters()
title = "Membrane Blebbing version " + Parameters._version_string
try:
f = open(readme_fpath, "rb")
text = f.readlines()
except:
raise IOError("Error reading README.txt")
finally:
f.close()
sb = StringBuilder()
for line in text:
sb.append(line)
panel = Panel()
txtArea = JTextArea(sb.toString())
txtArea.setEditable(False)
txtArea.setLineWrap(True)
txtArea.setWrapStyleWord(True)
scrollpane = JScrollPane(txtArea)
scrollpane.setPreferredSize(Dimension(500, 200))
panel.add(scrollpane)
dialog = NonBlockingGenericDialog(title)
#for line in text:
# dialog.addMessage(line);
dialog.addPanel(panel)
dialog.showDialog()