def ER_points(all_x, all_y, overlay, ER_measurements):
imp = IJ.getImage()
overlay = Overlay()
overlay = imp.getOverlay()
## gets points added to overlay, and extracts a list of x & y values. list length must be three ###
try:
roi_points = overlay.toArray()
except AttributeError as error:
nbgd = NonBlockingGenericDialog("Select three Roi's")
nbgd.hideCancelButton()
nbgd.showDialog()
overlay = imp.getOverlay()
roi_points = overlay.toArray()
pass
for i in range(overlay.size()):
roi = overlay.get(i)
p = roi_points[i].getPolygon()
all_x.append(p.xpoints[0])
all_y.append(p.ypoints[0])
while len(all_x) != 3:
if len(all_x) < 3:
nbgd = NonBlockingGenericDialog("Must Select three Roi's")
nbgd.setCancelLabel("Roi Reset")
nbgd.showDialog()
if nbgd.wasCanceled():
IJ.run("Remove Overlay", "")
ER_points(all_x, all_y, overlay, ER_measurements)
if len(all_x) > 3:
all_x.pop(0)
all_y.pop(0)
overlay.clear()
def showGui(par, title):
"""Updated version discriminates between string and numeric outputs to treat them accordingly"""
numflags = {}
gd = NonBlockingGenericDialog(title)
s_keys = sorted(par.keys())
for nm in s_keys:
if isinstance(par[nm], (int, float, long)):
gd.addNumericField(nm, par[nm], 1)
numflags[nm] = True
else:
gd.addStringField(nm, par[nm])
numflags[nm] = False
gd.setOKLabel("Go on!")
gd.setCancelLabel("Recompute..")
gd.centerDialog(False)
gd.setLocation(50, 100)
gd.showDialog()
if gd.wasCanceled():
rep = True
else:
rep = False
for nm in s_keys:
if numflags[nm]:
par[nm] = gd.getNextNumber()
else:
par[nm] = gd.getNextString().encode("ascii", "replace")
return par, rep
def getOptions(dest):
###function that allows the user to choose their next course of action###
# colorscale()
gd = NonBlockingGenericDialog("Continue?")
gd.setCancelLabel("Quit")
gd.enableYesNoCancel("Remain on Image", "Open Next")
gd.showDialog()
if gd.wasCanceled(): # quits
imp = IJ.getImage()
current_title = imp.getTitle()
imp.close()
renamer(dest, current_title, extension)
exit()
elif gd.wasOKed(): # remains on image
count_options = 0
return
else: # opens the next image in a directory.
count_options = 1
imp = IJ.getImage()
current_title = imp.getTitle()
imp.close()
renamer(dest, current_title, extension)
file_opener(current_title, extension)
imp = IJ.getImage()
imp.setDisplayMode(IJ.GRAYSCALE)
colorscale()
imp = IJ.getImage()
win = imp.getWindow()
win.maximize()
win.setLocation(int(xpos_def), int(ypos_def))
getOptions(dest)
def MyWaitForUser(title, message):
"""non-modal dialog with option to cancel the analysis"""
dialog = NonBlockingGenericDialog(title)
dialog.setCancelLabel("Cancel analysis")
if type(message) is list:
for line in message:
dialog.addMessage(line)
else:
dialog.addMessage(message)
dialog.showDialog()
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled")
return
def exit_assay():
gd = NonBlockingGenericDialog("Exit Assay")
gd.setCancelLabel("Quit & Save")
gd.setOKLabel("Quit")
gd.showDialog()
if gd.wasCanceled(): # quits
imp = IJ.getImage()
current_title = imp.getTitle()
imp.close()
renamer(dest, current_title, extension)
exit()
elif gd.wasOKed():
exit()
def selection(region):
nbgd = NonBlockingGenericDialog(region)
nbgd.setCancelLabel('Return')
nbgd.enableYesNoCancel('ROI OK', 'Redraw')
nbgd.showDialog()
if nbgd.wasOKed():
imp = IJ.getImage()
roi = imp.getRoi()
roi_check(roi)
return
if nbgd.wasCanceled():
exit_assay()
else:
repeat_measure()
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
def crop_review():
"""handle UI for reviewing cropping"""
print("doing crop review...");
dialog = NonBlockingGenericDialog("Review cropping")
dialog.enableYesNoCancel("Keep this crop", "Revert to uncropped image");
dialog.setCancelLabel("Cancel analysis");
dialog.addMessage("Please check whether this cropping is as expected, \n" +
"and choose whether to press on or revert to using the \n" +
"full, uncropped image. ");
dialog.showDialog();
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled");
elif dialog.wasOKed():
keep_cropping = True;
else:
keep_cropping = False;
return keep_cropping;
def qc_background_regions(intensity_imp, bg_rois):
"""allow the user to view and correct automatically-determined background regions"""
imp = Duplicator().run(intensity_imp);
imp.setTitle("Background region QC");
imp.show();
imp.setPosition(1);
autoset_zoom(imp);
imp.setRoi(bg_rois[0]);
IJ.setTool("freehand");
notOK = True;
while notOK:
listener = UpdateRoiImageListener(bg_rois, is_area=True);
imp.addImageListener(listener);
dialog = NonBlockingGenericDialog("Background region quality control");
dialog.enableYesNoCancel("Continue", "Use this region for all t");
dialog.setCancelLabel("Cancel analysis");
dialog.addMessage("Please redraw background regions as necessary...")
dialog.showDialog();
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled");
elif not(dialog.wasOKed()):
this_roi = imp.getRoi();
bg_rois = [this_roi for _ in listener.getRoiList()];
imp.removeImageListener(listener);
else:
last_roi = imp.getRoi();
qcd_bg_rois = listener.getRoiList();
if imp.getNFrames() > imp.getNSlices():
qcd_bg_rois[imp.getT() - 1] = last_roi;
else:
qcd_bg_rois[imp.getZ() - 1] = last_roi;
notOK = False;
imp.removeImageListener(listener);
imp.changes = False;
imp.close();
return qcd_bg_rois;
def __init__(self,x,y,clonenum):
self.x = x
self.y = y
self.clonenum = clonenum
theImage = IJ.getImage()
stayinloop = True
cloneNum = 1
pointList = []
while (stayinloop):
gd = NonBlockingGenericDialog("Clone counter...")
gd.addNumericField("Clone:",cloneNum,0)
gd.setOKLabel("Finalize clone")
gd.setCancelLabel("Quit")
gd.showDialog()
if (gd.wasOKed()):
roi = theImage.getRoi()
if (not roi is None):
cloneNum = int(gd.getNextNumber())
polygon = roi.getFloatPolygon()
for i in range(polygon.npoints):
pointList.append(CounterPoint(polygon.xpoints[i],polygon.ypoints[i],cloneNum))
IJ.run("Draw","stack")
theImage.deleteRoi()
cloneNum = cloneNum + 1
else:
stayinloop = False
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')
for title in titles:
m = p.search(title)
if m is not None:
theImage = WindowManager.getImage(title)
theImage.close()
virginImage.show()
for img in boxImages:
img.close()
else:
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;
waiter.show()
roi = theImage.getRoi()
newip = theImage.getProcessor().duplicate()
newip.setColor(0)
newip.fillOutside(roi)
newip.snapshot()
newip.setThreshold(0,t_line,ImageProcessor.BLACK_AND_WHITE_LUT)
newImage = ImagePlus("toggler",newip)
newImage.show()
doSameSlice = True
while (doSameSlice):
accept_waiter = NonBlockingGenericDialog("Thresholding...")
accept_waiter.addNumericField("Threshold:",t_line,0)
accept_waiter.setCancelLabel("Apply new threshold")
accept_waiter.setOKLabel("Accept threshold")
accept_waiter.showDialog()
if (accept_waiter.wasCanceled()):
newip.reset()
newip.snapshot()
t_line = accept_waiter.getNextNumber()
# if (t_line > 10):
# t_line = t_line - 5
# else:
# t_line = 5
newip.setThreshold(0,t_line,ImageProcessor.BLACK_AND_WHITE_LUT)
newImage.updateAndDraw()
else:
doSameSlice = False
for i in range(newImage.getWidth()):
newStack = ImageStack(width,height)
for i in range(startSlice,endSlice+1):
theImage.setSlice(i)
theImage.killRoi()
pixels = zeros('b',width*height)
bp = ByteProcessor(width,height,pixels)
bp.setColor(127)
doStaySlice = True
while doStaySlice:
waiter = NonBlockingGenericDialog("Set cast")
waiter.addMessage("Pick 2D ROI")
waiter.setOKLabel("Save and advance")
waiter.setCancelLabel("Save")
waiter.showDialog()
if (waiter.wasOKed()):
roi = theImage.getRoi()
if (roi is None):
doStaySlice = True
else:
bp.fill(roi)
doStaySlice = False
else:
roi = theImage.getRoi()
if (roi is None):
doStaySlice = True
else:
bp.fill(roi)
# Read csv files into lists, create nuclei list
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)
