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
def runPoreDetection():
'''roiManager=RoiManager(False)
roiManager.runCommand("open", roiname)
roiHash=roiManager.getROIs()
roi=roiHash.get("Right")
print roi'''
imageList = Utility.GetOpenImageList()
nbgd = NonBlockingGenericDialog(Messages.AddRoi)
nbgd.addMessage(Messages.ChooseImage)
if (imageList == None):
IJ.showMessage(Messages.noOpenImages)
return
nbgd.addChoice("Image1:", imageList, imageList[0])
nbgd.showDialog()
name = nbgd.getNextChoice()
inputImp = WindowManager.getImage(name)
inputDataset = Utility.getDatasetByName(data, name)
detectionParameters = DetectionParameters(10, 200, 0.5, 1.0, 0.3)
#inputImp.setRoi(roi)
nbgd2 = NonBlockingGenericDialog(Messages.PositionRoi)
nbgd2.addMessage(Messages.PositionRoiAndPressOK)
nbgd2.showDialog()
poreDetectionUV(inputImp, inputDataset,
inputImp.getRoi().clone(), ops, data, display,
detectionParameters)
def runPoreDetection():
'''roiManager=RoiManager(False)
roiManager.runCommand("open", roiname)
roiHash=roiManager.getROIs()
roi=roiHash.get("Right")
print roi'''
imageList=Utility.GetOpenImageList()
nbgd=NonBlockingGenericDialog(Messages.AddRoi)
nbgd.addMessage(Messages.ChooseImage)
if (imageList==None):
IJ.showMessage(Messages.noOpenImages)
return;
nbgd.addChoice("Image1:", imageList, imageList[0]);
nbgd.showDialog()
name = nbgd.getNextChoice()
inputImp = WindowManager.getImage(name)
inputDataset=Utility.getDatasetByName(data, name)
detectionParameters=DetectionParameters(10, 200, 0.5, 1.0, 0.3)
#inputImp.setRoi(roi)
nbgd2=NonBlockingGenericDialog(Messages.PositionRoi)
nbgd2.addMessage(Messages.PositionRoiAndPressOK)
nbgd2.showDialog()
poreDetectionUV(inputImp, inputDataset, inputImp.getRoi().clone(), ops, data, display, detectionParameters)
def createListfiles() :
IJ.showMessage("Select a folder with the .tif files")
selectdir=IJ.getDirectory("image")
selectdir=IJ.getDirectory("")
listfiles=glob.glob(selectdir+"*.tif")
#fullprefix = str.rsplit(str(listfiles[0]), "/", 1)
fullprefix = os.path.split(listfiles[0])
root = fullprefix[0]
lastprefix = str.split(fullprefix[1], "_")
del(listfiles)
gdselectfiles = NonBlockingGenericDialog("List files Choice")
gdselectfiles.addMessage("")
gdselectfiles.addStringField("Prefix ?", lastprefix[0], 32)
gdselectfiles.addStringField("Filter (w00001DIA) ?", "1DIA")
gdselectfiles.addStringField("Positions (s0001) ?", "1-2")
gdselectfiles.addStringField("Temps (t0001) ?", "1-11")
#gdselectfiles.addStringField("Files pattern", "*DIA_s*1_t*.tif", 32)
gdselectfiles.showDialog()
prefix = str(gdselectfiles.getNextString())
channel = str(gdselectfiles.getNextString())
temppositions = str(gdselectfiles.getNextString())
positions = str.split(temppositions, "-")
temptimes = str(gdselectfiles.getNextString())
times = str.split(temptimes, "-")
if channel != "" : channel = "_w000"+channel
positionslist=[]
if positions[0] != "" :
for p in range(int(positions[0]), int(positions[1])+1, 1) :
positionslist.append("_s"+"%04i"%(p))
else : positionslist.append("")
timeslist=[]
if times[0] != "" :
for t in range(int(times[0]), int(times[1])+1, 1) :
timeslist.append("_t"+"%04i"%(t))
else : timeslist.append("")
patterns=[]
listfiles = []
for p in positionslist :
files = []
for t in timeslist :
patterns.append(channel+p+t+".tif")
tempfilename = os.path.join(root, prefix+patterns[-1])
files.append(tempfilename)
#files.append(root+"/"+prefix+patterns[-1])
listfiles.append(files)
if len(listfiles)>1 : return (prefix, patterns, listfiles, positionslist)
else : return (prefix, patterns, files, "_s0001")
def displayInfoDialog(text, title = 'Info'): global infoDialog infoDialog = NonBlockingGenericDialog(title) infoDialog.addMessage(text) infoDialog.setLocation(0,0) infoDialog.setSize(400,800) infoDialog.show() return infoDialog
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 getEdgeCoord(x, y, circRad, imp, msg):
IJ.run(imp, "Select None", "")
imp.setRoi(IJ.OvalRoi(x, y, circRad * 2, circRad * 2))
gd = NonBlockingGenericDialog(msg)
gd.addMessage('Select ' + msg + ' coordinates')
gd.showDialog()
if gd.wasCanceled():
return None
# wait for user input
coord = imp.getRoi().getContourCentroid()
IJ.run(imp, "Select None", "")
return coord[0] - circRad, coord[1] - circRad
def makeSelections(x, y, rm, imp, circRad):
rm.reset()
for j in range(len(x)):
for i in range(len(x[-1])):
imp.setRoi(IJ.OvalRoi(x[j][i], y[j][i], circRad * 2, circRad * 2))
rm.addRoi(imp.getRoi())
rm.runCommand(imp, "Show All with labels")
gd = NonBlockingGenericDialog('Confirm ROI positions')
gd.addMessage('Are the ROIs positioned correctly? Move them if necessary')
gd.showDialog()
if gd.wasCanceled():
return None
return imp, rm
def measure_gd(src_folder,file_names):
from javax.swing import JButton
gd = NonBlockingGenericDialog("Loci to compartment")
gd.setResizable(True)
gd.pack()
gd.addMessage("Draw a freehand ROI aound loci and closest \n compartment(e.g. speckle) and press 0 on keyboard.")
gd.addMessage("To load next image press Next Image button.")
next_imp_bt = JButton('Next Image', actionPerformed=load_next_image)
gd.add(next_imp_bt)
gd.setLocation(10,10)
gd.setAlwaysOnTop(True)
gd.hideCancelButton()
gd.showDialog()
#
if gd.wasOKed():
IJ.log( "Measurement done! You're welcome!")
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 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)
def perform_manual_qc(imp, rois, important_channel=1):
"""given cell rois generated by automatic methods, allow user to delete/add/redraw as appropriate"""
for ch in range(imp.getNChannels()):
imp.setC(ch + 1)
sat_frac = 0.99 if (ch + 1) == important_channel else 0.01
IJ.run(imp, "Enhance Contrast", "saturated={}".format(sat_frac))
imp.setC(important_channel)
IJ.setTool("freehand")
proceed = False
roim = RoiManager()
roim.runCommand("Show all with labels")
for roi in rois:
roim.addRoi(roi)
auto_rois_only = rois
while not proceed:
dialog = NonBlockingGenericDialog("Perform manual segmentation")
dialog.setOKLabel("Proceed to next image...")
dialog.addMessage("Perform manual correction of segmentation: ")
dialog.addMessage(
"Draw around cells and add to the region of interest manager (Ctrl+T). "
)
dialog.addMessage("Delete and redraw cells as appropriate. ")
dialog.addMessage(
"Then press \"proceed to next image\" when all cells have been added. "
)
dialog.showDialog()
if dialog.wasCanceled():
print("Manual segmentation canceled")
return auto_rois_only
elif dialog.wasOKed():
if roim.getCount() == 0:
rois = []
confirm_dialog = GenericDialog("Continue?")
confirm_dialog.addMessage(
"No rois selected in this FOV. Are you sure you want to proceed?"
)
confirm_dialog.setOKLabel("Yes, proceed")
confirm_dialog.setCancelLabel("No, not yet")
confirm_dialog.showDialog()
if confirm_dialog.wasOKed():
proceed = True
else:
rois = roim.getRoisAsArray()
proceed = True
roim.reset()
roim.close()
for ch in range(imp.getNChannels()):
imp.setC(ch + 1)
IJ.run(imp, "Enhance Contrast", "saturated={}".format(0.35))
imp.setC(important_channel)
return rois
def measure_gd():
# Dialouge box for measurements.
# It
from javax.swing import JButton
gd = NonBlockingGenericDialog("Loci to compartment")
gd.setResizable(True)
gd.pack()
gd.addMessage(
"Draw a freehand ROI around the loci and closest \ncompartment(e.g. speckle) and press 0 on keyboard."
)
next_imp_bt = JButton('Analyze active image',
actionPerformed=analyze_image)
gd.add(next_imp_bt)
gd.setLocation(10, 10)
gd.setAlwaysOnTop(True)
gd.hideCancelButton()
gd.showDialog()
#
if gd.wasOKed():
IJ.log("Measurement done! Happy FISHing")
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 manual_analysis(imp, file_name, output_folder):
"""perform analysis based on manually drawn cells"""
cal = imp.getCalibration()
channel_imps = ChannelSplitter.split(imp)
gfp_imp = channel_imps[0]
IJ.setTool("freehand")
proceed = False
roim = RoiManager()
roim.runCommand("Show all with labels")
dialog = NonBlockingGenericDialog("Perform manual segmentation")
dialog.setOKLabel("Proceed to next image...")
dialog.addMessage("Perform manual segmentation: ")
dialog.addMessage(
"Draw around cells and add to the region of interest manager (Ctrl+T)")
dialog.addMessage(
"You can see what you've added so far if you check \"show all\" on the ROI manager"
)
dialog.addMessage(
"Then press \"proceed to next image\" when all cells have been added")
dialog.showDialog()
if dialog.wasCanceled():
raise KeyboardInterrupt("Run canceled")
elif dialog.wasOKed():
rois = roim.getRoisAsArray()
roim.reset()
roim.close()
out_stats = generate_cell_shape_results(rois, gfp_imp, cal, file_name)
print("Number of cells identified = {}".format(len(out_stats)))
# save output
save_qc_image(
imp, rois, "{}_plus_overlay.tiff".format(
os.path.join(output_folder,
os.path.splitext(file_name)[0])))
save_cell_rois(rois, output_folder, os.path.splitext(file_name)[0])
imp.changes = False
imp.close()
save_output_csv(out_stats, output_folder)
return out_stats
return None
if (diff < 0):
return False
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)
from ij import IJ
from ij.gui import NonBlockingGenericDialog
from ij import WindowManager
theImage = IJ.getImage()
gd = NonBlockingGenericDialog("Shine Light")
gd.addMessage("Select an ROI to shine light")
gd.showDialog()
doClose = False
continueProg = True
if (gd.wasCanceled()):
continueProg = False
while (continueProg):
if (doClose):
litImage.close()
nslices = theImage.getNSlices()
params = "title=dupped duplicate range=1-" + str(nslices)
IJ.run("Duplicate...", params)
litImage = WindowManager.getImage("dupped")
params = "saturated=0.4 normalize process_all"
IJ.run(litImage,"Enhance Contrast...", params)
gd = NonBlockingGenericDialog("Shine Light")
gd.addMessage("Select an ROI to shine light")
gd.showDialog()
if (gd.wasCanceled()):
continueProg = False
doClose = True
numSlices = theImage.getNSlices() * theImage.getNChannels() * theImage.getNFrames()
for zslice in range(1,numSlices+1):
theImage.setSliceWithoutUpdate(zslice)
ip = theImage.getProcessor()
ip.setColor(255*255)
for i in range(0,len(colCenters)):
for j in range(0,len(rowCenters)):
theString = str(int(j*xtiles+i+1))
ip.drawString(theString,int(colCenters[i]),int(rowCenters[j]))
theImage.updateAndDraw()
theImage.setSlice(visSlice)
### Sets up main interface for visualization #####
gd = NonBlockingGenericDialog("Explore full resolution...")
gd.addMessage("Select ROI for visualization at full resolution")
gd.showDialog()
doContinue = gd.wasOKed()
while (doContinue):
roi = theImage.getRoi()
boundRect = roi.getBounds()
xmin = boundRect.getX()
xmax = xmin + boundRect.getWidth()
ymin = boundRect.getY()
ymax = ymin + boundRect.getHeight()
xs = find_tile_range(xmin,xmax,colStarts)
ys = find_tile_range(ymin,ymax,rowStarts)
tiles = make_tile_series(xs,ys,xtiles,ytiles)
print tiles
# Copies tiles for stitching into temp directory and stitches, if necessary
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
width = theImage.getWidth()
height = theImage.getHeight()
newStack = ImageStack(width,height)
for i in range(startSlice,endSlice+1):
theImage.setSlice(i)
theImage.killRoi()
pixels = zeros('b',width*height)
bp = ByteProcessor(width,height,pixels)
bp.setColor(127)
doStaySlice = True
while doStaySlice:
waiter = NonBlockingGenericDialog("Set cast")
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
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 __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
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;
with open(outputDirectory + "annotations_" + name + ".csv", "w") as log:
subfolders = []
# for subfolder in os.listdir(inputDirectory):
# if os.path.isdir(inputDirectory + subfolder):
# subfolders.append(subfolder)
# for subfolder in subfolders:
for filename in os.listdir(inputDirectory):
if filename.endswith(".TIF"):
imp = IJ.openImage(inputDirectory + filename)
imp.show()
gd = NonBlockingGenericDialog("Channel Options")
gd.addMessage(
"Type in the number for how good you think the neurons are:")
gd.addMessage(
"1 = Very Bad, 2 = Bad, 3 = Mediocre, 4 = Good, 5 = Very Good")
gd.addStringField(":", "")
gd.showDialog()
log.write(filename + ',' + gd.getNextString())
log.write('\n')
imp.close()
cat = """
\ /\ Macro completed!
) ( ') meow!
( / )
\(__)|"""
if im.getNChannels() == 1:
LUTarray = [LUT.createLutFromColor(Color.WHITE)]
elif im.getNChannels() == 2:
LUTarray = [LUT.createLutFromColor(Color.RED),LUT.createLutFromColor(Color.WHITE)]
elif im.getNChannels() == 3:
LUTarray = [LUT.createLutFromColor(Color.GREEN),LUT.createLutFromColor(Color.RED),LUT.createLutFromColor(Color.WHITE)]
elif im.getNChannels() == 4:
LUTarray = [LUT.createLutFromColor(Color.BLUE),LUT.createLutFromColor(Color.RED),LUT.createLutFromColor(Color.GREEN),LUT.createLutFromColor(Color.WHITE)]
elif im.getNChannels() == 5:
LUTarray = [LUT.createLutFromColor(Color.BLUE),LUT.createLutFromColor(Color.RED),LUT.createLutFromColor(Color.GREEN),LUT.createLutFromColor(Color.YELLOW),LUT.createLutFromColor(Color.WHITE)]
else:
LUTarray = []
nbgd = NonBlockingGenericDialog("Pick freehand ROI")
nbgd.setLocation(0,0)
nbgd.addMessage("OK to run, cancel to exit")
nbgd.showDialog()
isContinue = nbgd.wasOKed()
while isContinue:
roi = im.getRoi()
if (roi is not None):
float_poly = roi.getFloatPolygon()
containing_tiles_superlist = []
for i in range(float_poly.npoints):
containing_tiles_superlist.append(find_containing_tiles([float_poly.xpoints[i],float_poly.ypoints[i],0],coords_vals,scale_info[1],scale_info[2]))
upscaled_coords = upscale_coords(coords,scale_info[0])
containing_tiles_dict = rearrange_tile_list(containing_tiles_superlist)
copy_fullsize_tiles(["tile_"+key for key in containing_tiles_dict.keys()],parentLSMFilePath+"_tiles/",parentLSMFilePath+"_tiles/subtiles/",".ome.tif")
subupcoords_vals = normalize_coords_in_list(get_list_from_dict(["tile_"+key for key in containing_tiles_dict.keys()],upscaled_coords))
hadStitched = False
if len(containing_tiles_dict.keys())>1: