def cell_processor(imp_particles, imp_measure, folder, impname, channel_name):
# Get ROI manager instance, save to zip
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
rm.reset()
imp_particles.show()
# Wait for user to add ROIs to manager
Prefs.multiPointMode = True
pause = WaitForUserDialog(
"Select ROIs of interest and add to manager \n \nPress OK to continue")
pause.show()
# get the ROI manager and save
rm = RoiManager.getInstance()
rm.runCommand("save selected",
os.path.join(folder, impname + "_cells_ROIs.zip"))
# select image to measure and show
imp_measure.show()
pixel_collector(rm, imp_measure, channel_name, impname, folder)
return rm
def readRois(path_):
RoiManager().close()
rm = RoiManager()
if rm is not None:
rm.getInstance()
rm.runCommand("Open", path_)
return rm
def measure_rois():
# Get the active image, its title, and the directory where it lies
imp = IJ.getImage()
imp_title = imp.getTitle()
path = IJ.getDirectory("image")
IJ.log("Active image source: {}{}".format(path, imp_title))
# Set measurements to redirect to the active image
IJ.run(
"Set Measurements...",
"area mean standard min center perimeter bounding fit feret's integrated median stack display redirect={}"
.format(imp_title))
# Instantiate RoiManager as rm, select all rois and measure them
roim = RoiManager.getInstance()
roim.runCommand("Select All")
roim.runCommand("Measure")
# Save the measurements just made using the name of the active image
measurements_filename = imp_title[:-4]
IJ.saveAs("Results", "{}{}.csv".format(path, measurements_filename))
IJ.selectWindow("Results")
IJ.run("Close")
IJ.log("Measurements saved at {}{}.csv".format(path,
measurements_filename))
# Close the active image so IJ can move on to the next
imp.close()
def resetpressed(event):
self.__ranges.clear()
self.__image=IJ.getImage()
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
self.__image.killRoi()
IJ.setAutoThreshold(self.__image, "MaxEntropy")
rt=ResultsTable()
pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00)
pa.analyze(self.__image)
self.__roisArray=[]
self.__roisArray=rm.getRoisAsArray()
#rm.runCommand("Show All")
#rm.runCommand("Select All")
#rm.runCommand("Set Color", "blue")
IJ.resetThreshold(self.__image)
keys=self.__slidersDict.keys()
for k in keys:
if k.endswith("min"):
self.__slidersDict[k].setValue(0)
self.__slidersDict[k].repaint()
else:
self.__slidersDict[k].setValue(self.__slidersDict[k].getMaximum())
self.__slidersDict[k].repaint()
def nuclei_processor(imp_particles, thresh_type, folder, impname,
channel_name):
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
rm.reset()
# define a results table
rt = ResultsTable.getResultsTable()
imp_particles.show()
# generate thresholded image for ROI
nuclei = imp_particles.duplicate()
nuclei.show()
IJ.run("Gaussian Blur...", "sigma=3")
IJ.setAutoThreshold(nuclei, thresh_type)
IJ.run("Convert to Mask")
IJ.run("Fill Holes")
# IJ.run("Watershed")
# select thresholded image (to set ROIs)
IJ.run(
"Set Measurements...",
"area mean standard min area_fraction limit display add redirect=[" +
imp_particles.title + "] decimal=3")
IJ.run("Analyze Particles...",
"size=30-Infinity show=Outlines display clear add")
# get the ROI manager and save
rm.runCommand(
"save selected",
os.path.join(folder, impname + '_' + channel_name + "_ROIs.zip"))
def __init__(self):
swing.JFrame.__init__(self, title="Stack Cells")
self.__impD = IJ.getImage()
self.setDefaultCloseOperation(swing.JFrame.DISPOSE_ON_CLOSE)
self.__n=0
self.__widthl = "11"
self.__iplist = []
self.__init = False
self.__initDIA = False
self.__initFLUO = False
self.__skip = False
self.__avg = True
self.__mosa = True
self.__maxfinder = True
self.__appmedian = True
self.__fire = True
self.__align = True
self.__alignC = False
self.__enlarge = True
self.__measures = True
self.__sens = []
self.__listrois = []
self.__cellsrois = []
self.__Cutoff = 0
self.__labels = []
self.__maxraf = 100.0
self.__minraf = 0.0
self.__conEllipses = False
self.__dictCells = {}
self.__rm = RoiManager.getInstance()
if (self.__rm==None): self.__rm = RoiManager()
self.run()
def read_xyz_from_RoiManager():
""" Reads x,y,z coordinates from 3 points in RoiManager
Parameters
----------
None
Returns
-------
P0, P1, P2 : array-like, shape=(3,)
x,y,z coordinates of points P0, P1 and P2.
"""
points = []
RoiM = RoiManager.getInstance()
for i in range(RoiM.getCount()):
roi = RoiM.getRoi(i)
x = roi.getContainedPoints()[0].getX()
y = roi.getContainedPoints()[0].getY()
z = roi.getPosition()
points.append([x, y, z])
P0 = points[0]
P1 = points[1]
P2 = points[2]
return P0, P1, P2
def saveCroppedROIs(self, event):
""" Duplicates cropped ROIs and saves """
# Create export dir, if not already present
current_export_dir = self.createExportDir("Cropped_ROI")
for Image in self.Images.values(): # for all Image instances
# save image
cropped_copy = Image.imp.crop() # returns cropped image as an imp
img_filename = os.path.join(current_export_dir, Image.title)
if os.path.splitext(img_filename)[1] != ".tif":
os.path.join(img_filename, ".tif")
FileSaver(cropped_copy).saveAsTiff(img_filename)
# save roi
roi_filename = os.path.splitext(img_filename)[0] + "_roi.roi"
roi = Image.imp.getRoi()
if roi != None:
rm = RM.getInstance()
if rm == None:
rm = RM()
rm.addRoi(roi)
rm.runCommand("Save", roi_filename) # which one does it save
rm.runCommand("Delete")
IJ.log("Cropped ROI saved: " +
os.path.join(current_export_dir, Image.title))
def showimage(self):
roim = RoiManager.getInstance()
if roim is None:
roim = RoiManager()
IJ.run("Close All")
IJ.run("Clear Results")
try:
roim.reset()
except AttributeError:
roim.runCommand("reset")
obj = self.fcsimages[self.idximg][0]
imgName = self.fcsimages[self.idximg][1]
img = BF.openImagePlus(imgName)[0]
img.setZ(obj[1][2]+1)
img.setC(3)
IJ.run(img, "Grays", "");
img.setC(1)
img.show()
#draw rois
for i in range(1, len(obj)+1):
PR = PointRoi(obj[i][0],obj[i][1])
try:
PR.setSize(3)
PR.setPointType(0)
roim.addRoi(PR)
except:
roim.addRoi(PR)
roim.runCommand('Show All with Labels')
def get_roi_manager(new=False):
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
if new:
rm.runCommand("Reset")
return rm
def measure_rm(img_path, roi_path):
imp = IJ.openImage(img_path)
img_dir = imp.getOriginalFileInfo().directory
img_file = imp.getOriginalFileInfo().fileName
ip = imp.getProcessor()
cal = Calibration(imp)
rm = RoiManager()
rm = RoiManager.getInstance()
rm.runCommand("Open", roi_path)
roi_array = rm.getRoisAsArray()
moptions = Measurements.MEAN | Measurements.AREA
for roi in roi_array:
roi_name = roi.getName()
ip.setRoi(roi)
stat = ImageStatistics.getStatistics(ip, moptions, cal)
IJ.log(img_dir + "\t" + img_file + "\t" + roi_name + "\t" +
str(stat.pixelCount) + "\t" +
str(stat.pixelCount * stat.umean) + "\t" + str(stat.umean))
rm.runCommand("delete")
def run():
roidir = '/Volumes/TRANSCEND/LauraLeopold/Rois/'
maskdir = '/Volumes/TRANSCEND/LauraLeopold/Mask/'
originaldir = '/Volumes/TRANSCEND/LauraLeopold/Original/'
Raw_path = os.path.join(originaldir, '*tif')
X = glob.glob(Raw_path)
axes = 'YX'
for fname in X:
print(fname)
IJ.open(fname)
imp = IJ.getImage()
Name = os.path.basename(os.path.splitext(fname)[0])
RoiName = roidir + Name + '.roi'
Roi = IJ.open(RoiName)
rm = RoiManager.getInstance()
if (rm == None):
rm = RoiManager()
rm.addRoi(Roi)
print(fname, RoiName)
if not rm:
print "Please first add some ROIs to the ROI Manager"
return
impMask = IJ.createImage("Mask", "8-bit grayscale-mode",
imp.getWidth(), imp.getHeight(),
imp.getNChannels(), imp.getNSlices(),
imp.getNFrames())
IJ.setForegroundColor(255, 255, 255)
rm.runCommand(impMask, "Deselect")
rm.runCommand(impMask, "Fill")
rm.runCommand('Delete')
IJ.saveAs(impMask, '.tif', maskdir + Name)
imp.close()
def run():
# ensure no other windows are open and clear resultstable
IJ.run("Close All")
IJ.run("Clear Results", "")
#Ask user for file to be converted
srcDir = IJ.getFilePath("Select file to analyse")
if not srcDir:
return
#open file
IJ.open(srcDir)
dstDir = os.path.dirname(srcDir)
print("dstDir = " + dstDir)
#open ROI manager, save ROI names as labels in measurements
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
rm.runCommand("UseNames", "true")
# set parameters to be measured
IJ.run("Set Measurements...",
"area mean integrated limit display redirect=None decimal=3")
FOVlist = WindowManager.getIDList()
chnls = IJ.getString(
"Please enter which channels you would like to analyse. Example: 123 analyses channels 1, 2 and 3",
'123')
for FOV in FOVlist:
imp = WindowManager.getImage(FOV)
IJ.run(imp, "Arrange Channels...", "new=" + chnls)
imp.close()
imp2 = WindowManager.getCurrentImage()
imageTitle = WindowManager.getImage(FOV).getTitle()
newDir = imageTitle + ' ROIs'
dirPath = os.path.join(dstDir, newDir)
if not os.path.exists(dirPath):
try:
os.makedirs(dirPath)
except OSError as e:
if e.errno != errno.EEXIST:
raise
# clear ROI list before analysis
rm.runCommand(imp2, "Deselect")
rm.runCommand(imp2, "Delete")
TMdata, nFrames = runTrackMate(imp2)
if TMdata:
iterateCoords(TMdata, nFrames, dirPath, imp2)
imp2.changes = 0
imp2.close()
#relabel()
resultsDir = os.path.splitext(srcDir)[0] + ".csv"
#while os.path.exists(resultsDir):
#resultsDir = resultsDir+"_1"+".csv"
IJ.saveAs("Results", resultsDir)
def main():
from ij import IJ
from ij.plugin.frame import RoiManager
istring = 0
area_last = 0
jj = 0
roim = RoiManager.getInstance()
istart = roim.getSelectedIndex()
#istart =0
ctypes = 'o n'.split()
for ii, i in enumerate(range(istart, roim.getCount())):
print(ii)
roi = roim.getRoi(i)
if (roi is not None):
ctype = ctypes[i % 2]
if (ctype == 'o'):
area_curr = roi.getStatistics().area
if (area_curr > 4 * area_last):
istring += 1
jj = 0
area_last = area_curr
jj += 1
name = "{}-{}-{}".format(istring, jj, ctype)
roi.setName(name)
roi.setStrokeWidth(1)
roim.rename(i, name)
roim.setRoi(roi, i)
def get_roi_manager(new=False):
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
if new:
rm.runCommand("Reset")
return rm
def anaParticlesWatershed(imp, strThrMeth="method=Default white", minPx=10, minCirc=0.35, labCol=Color.white, linCol=Color.green, bDebug=False, sl=0.005):
"""anaParticlesWatershed(imp, strThrMeth="method=Default white", minPx=10, minCirc=0.35, labCol=Color.white, linCol=Color.green, bDebug=False, sl=0.005)
A wrapper function to do particle analyis from an image after a watershed transformation and draw the detected
features into the overlay of the original image.
Inputs:
imp - the ImagePlus instance that we will process
strThrMeth - a string specifying the threshold method
minPx - the minimum pixels to detect
minCirc - the minimum circularity to detect
labCol - the color for labels in the overlay (default white)
linCol - the color for line/stroke in the overlay (default green)
bDebug - a flag (default False) that, if true, keeps the work image open
sl - a time (default 0.005) to sleep when adding ROIs to not overload
This adds the detected features to the overlay and returns the result table for
processing for output.
"""
title = imp.getTitle()
shortTitle = imp.getShortTitle()
typ = imp.getType()
imp.setTitle(shortTitle)
imp.show()
IJ.run(imp,"Duplicate...", "title=work")
wrk = IJ.getImage()
# if this is a 16 bit image, convert to 8 bit prior to threshold
if typ == ImagePlus.GRAY16:
IJ.run(wrk, "Enhance Contrast", "saturated=0.35")
IJ.run(wrk, "8-bit", "")
IJ.run(wrk, "Threshold", strThrMeth)
IJ.run(wrk, "Watershed", "")
wrk.show()
strMeas = "area mean modal min center perimeter bounding fit shape feret's display redirect=%s decimal=3" % shortTitle
IJ.run(wrk, "Set Measurements...", strMeas)
strAna = "size=%d-Infinity circularity=%g-1.00 exclude clear include add" % (minPx, minCirc)
IJ.run(wrk, "Analyze Particles...", strAna)
rt = ResultsTable().getResultsTable()
rm = RoiManager.getInstance()
ra = rm.getRoisAsArray()
# Let's draw the particles into the overlay of the original
i=0
for r in ra:
i += 1
rLab = "%d" % i
r.setName(rLab)
imp = addRoiToOverlay(imp, r, labCol=labCol, linCol=linCol)
# needed to put in sleep here on cruch to let this complete and not overrun buffer
time.sleep(sl)
# let's put a PointRoi outside the image to get the overlays all the same color
r = PointRoi(-10, -10)
imp = addRoiToOverlay(imp, r, labCol=labCol, linCol=linCol)
# clear the roi manager and return the results table
rm.reset()
rm.close()
if bDebug == False:
wrk.changes = False
wrk.close()
imp.setTitle(title)
return rt
def process(imp):
IJ.log("Processing " + str(imp.title) + "...")
#impOut = imp.duplicate()
impOut = imp
impOut.show()
# Prepare Roi Manager
rm = RoiManager.getInstance()
if rm is not None:
rm.reset()
### STEP 1 (Coralline, Tunicate) ###
# Coralline
UrchinCoral.identifyCoralline(impOut)
roiCount = rm.getCount()
coralline = UrchinTag.delete(impOut, rm, roiCount)
IJ.log("Coralline: " + str(coralline))
# Tunicate
UrchinTunicate.identifyTunicate(impOut)
roiCount = rm.getCount()
tunicate = UrchinTag.delete(impOut, rm, roiCount)
IJ.log("Tunicate: " + str(tunicate))
### STEP 2 (Red, Macro) ###
# Red
UrchinRed.identifyRed(impOut)
roiCount = rm.getCount()
red = UrchinTag.delete(impOut, rm, roiCount)
IJ.log("Red: " + str(red))
# Macro
UrchinMacro.identifyMacro(impOut)
roiCount = rm.getCount()
macro = UrchinTag.delete(impOut, rm, roiCount)
IJ.log("Macro: " + str(macro))
### STEP 3 (Stragglers) ###
straggler = UrchinStraggler.learn(impOut)
coralline = coralline + straggler[0]
tunicate = tunicate + straggler[1]
red = red + straggler[2]
macro = macro + straggler[3]
# New values
IJ.log("New values")
IJ.log("Coralline: " + str(coralline))
IJ.log("Tunicate: " + str(tunicate))
IJ.log("Red: " + str(red))
IJ.log("Macro: " + str(macro))
impOut.changes = False
impOut.close()
# Format String for output
return UrchinFF.formatData(coralline, tunicate, red, macro)
def getRoiManager():
"""
Return existing RoiManager or create a new instance if no existing one.
Always display the RoiManager
"""
rm = RoiManager.getInstance()
if not rm: rm = RoiManager() # create a new instance
return rm
def __add(self, event):
if ( not self.__init) :
IJ.showMessage("", "please start a new stack")
return
if ( not self.__initDIA) :
IJ.showMessage("", "please select an image for DIA")
return
if ( not self.__initFLUO) :
IJ.showMessage("", "please select an image for FLUO")
return
self.__widthl = self.__display2.getText()
roi = self.__impD.getRoi()
if roi == None :
IJ.showMessage("", "No selection")
return
if roi.getType() in [6,7] :
nslice = self.__impD.getCurrentSlice()
self.__impF.setSlice(nslice)
self.__impF.setRoi(roi)
elif roi.getType() in [2,4] :
nslice = self.__impD.getCurrentSlice()
self.__impF.setSlice(nslice)
m=Morph(self.__impF, roi)
m.setMidParams(10, 2)
roi=m.MidAxis
if roi == None :
self.__display.text = "roi fail"
if not self.__skip : IJ.showMessage("", "failed roi, please draw it as polyline")
return
#if roi.getType() != 6 : self.__impF.setRoi(roi)
else :
IJ.showMessage("", "This selection is not yet allowed")
return
self.__impF.setRoi(roi)
straightener = Straightener()
new_ip = straightener.straighten(self.__impF, roi, int(self.__widthl))
self.__iplist.append(new_ip)
self.__labels.append(self.__isF.getShortSliceLabel(nslice))
self.__display.text = self.__name + " cell " + str(len(self.__iplist)) +" width="+str(new_ip.getWidth())+ " height="+ str(new_ip.getHeight())
roi.setPosition(self.__impD.getCurrentSlice())
self.__rm = RoiManager.getInstance()
if (self.__rm==None): self.__rm = RoiManager()
self.__rm.add(self.__impD, roi, len(self.__iplist))
self.__cellsrois.append((roi, self.__impD.getCurrentSlice()))
#self.__rm.runCommand("Show All")
IJ.selectWindow(self.__impD.getTitle())
def get_clean_RoiManager(show=False): ''' Returns a clean instance of RoiManager. ''' rm = RoiManager.getInstance() if not rm: rm = RoiManager(show) rm.reset() return rm
def xypoint_flatten(roi_array = RoiManager.getInstance().getRoisAsArray()):
if roi_array is not None:
xpoint = [[] for _ in range(len(roi_array))]
ypoint = [[] for _ in range(len(roi_array))]
for i, roi in enumerate(roi_array):
xy_coord = list(roi.getContainedPoints())
for j, coord in enumerate(xy_coord):
xpoint[i].append(coord.x)
ypoint[i].append(coord.y)
return xpoint, ypoint
def get_clean_RoiManager(show=False):
'''
Returns a clean instance of RoiManager.
'''
from ij.plugin.frame import RoiManager
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager(show)
rm.reset()
return rm
def apply_roi_arr(func):
rm = RoiManager()
rm = rm.getInstance()
roi_arr = rm.getRoisAsArray() # => list
result_list = []
for roi in roi_arr:
result = func(roi)
if result is not None:
result_list.append(result)
return result_list
def run():
rm = RoiManager.getInstance()
if not rm:
print "Please first add some ROIs to the ROI Manager"
return
impMask = IJ.createImage("Mask", "8-bit grayscale-mode", imp.getWidth(),
imp.getHeight(), imp.getNChannels(),
imp.getNSlices(), imp.getNFrames())
IJ.setForegroundColor(255, 255, 255)
rm.runCommand(impMask, "Deselect")
rm.runCommand(impMask, "Fill")
impMask.show()
def open_files_and_roi(filepath):
imp=open_czi(filepath,2)
imp.show()
import os
from ij.plugin.frame import RoiManager
roifile = os.path.splitext(filepath)[0]+".zip"
roim = RoiManager.getInstance()
if(roim is None): roim = RoiManager()
roim.reset()
roim.runCommand("Open",roifile)
print(roifile)
return imp
def get_roi_manager(new=False):
"""
flexible ROI mgr handling, copied from Particles_From_Mask.py template in Fiji
if new = True, a new blank mgr is returned
if new = False (default) and the ROI manager is open, returns that mgr.
if new = False and the ROI manager is NOT open, creates a new one without throwing an error
"""
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
if new:
rm.runCommand("Reset")
return rm
def measureChannels(ROIset, imp, frameNumber):
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
nChannels = imp.getNChannels()
for channel in range(nChannels):
target_imp = extractChannel(imp, channel + 1, frameNumber)
target_imp.show()
for roi in ROIset:
rm.setSelectedIndexes([roi])
IJ.setAutoThreshold(target_imp, "Huang dark")
rm.runCommand(target_imp, "Measure")
target_imp.close()
def learn(imp):
IJ.run(imp, "Line Width...", "line=10")
IJ.run("Colors...", "foreground=black background=black selection=red")
# Clear ROI manager
roiMan = RoiManager.getInstance()
if roiMan is not None:
roiMan.reset()
# set results table
rt = ResultsTable.getResultsTable()
# set up analyzer
analyzer = Analyzer(imp, 1, rt)
impBrightness = ProcessHSB.getBrightness(imp)
IJ.run(impBrightness, "8-bit", "")
IJ.run(impBrightness, "Auto Threshold", "method=Shanbhag white")
IJ.run(impBrightness, "Analyze Particles...",
"size=50000-Infinity circularity=0.00-1.00 show=Masks add in_situ")
# Pixel running total
pixelTotal = zeros('f', 4)
roiTotal = roiMan.getCount()
if roiMan is not None:
# Iterate throught the ROIs
for roi in xrange(roiTotal):
roiMan.select(roi)
selectRoi = roiMan.getRoi(roi)
option = getOptions()
# measure
analyzer.measure()
meas = rt.getRowAsString(0)
newLine = meas.split(" ", 1)
pixels = float(newLine[1])
# Tag the ROI
IJ.run(imp, "Fill", "slice")
pixelTotal[0] = pixelTotal[0] + (option[0] * pixels)
pixelTotal[1] = pixelTotal[1] + (option[1] * pixels)
pixelTotal[2] = pixelTotal[2] + (option[2] * pixels)
pixelTotal[3] = pixelTotal[3] + (option[3] * pixels)
return pixelTotal
else:
return pixelTotal
def segmentChannel_Weka(image, **kwargs):
""" SegmentChannel using a Weka Classification"""
ch = kwargs['channel']
if ch > len(image):
raise Exception('Expecting at least ' + str(ch) + ' channels. Image has only ' + str(len(imageC)) + ' channel(s)')
imp = image[ch-1].duplicate()
ws = WekaSegmentation(imp) # create an instance
ws.loadClassifier(kwargs['clspath']) # load classifier
impProb = ws.applyClassifier(imp, 0, True)
impMetaProb = extractChannel(impProb,1,1)
impMetaProb.setTitle("MetaProb")
# segmentation
impBW = threshold(impMetaProb, kwargs['probThr'])
impMetaProb.show()
IJ.run("Set Measurements...", " mean center shape area redirect=MetaProb decimal=2");
# particle analysis
IJ.run(impBW, "Analyze Particles...", "size=10-10000 pixel area circularity=0.00-1.00 display exclude clear stack add");
rt = Analyzer.getResultsTable()
validParticles = []
roim = RoiManager.getInstance()
if roim == None:
raise Exception('Fiji error segmentNuclei.py: no RoiManager!')
if roim.getCount() > 0:
rois = roim.getRoisAsArray()
else:
IJ.log("# particles = 0")
return impMetaProb, impBW, None, None
X = rt.getColumn(rt.getColumnIndex("XM"))
Y = rt.getColumn(rt.getColumnIndex("YM"))
Mean = rt.getColumn(rt.getColumnIndex("Mean"))
Circ = rt.getColumn(rt.getColumnIndex("Circ."))
Area = rt.getColumn(rt.getColumnIndex("Area"))
print "# particles = " + str(len(Mean))
nValid = 0
for i in range(len(Mean)):
valid = (Mean[i]>kwargs['minProb']) and (Circ[i]<kwargs['maxCirc']) # filter particles post detection
if(valid):
validParticles.append([i, X[i], Y[i], Mean[i]])
print validParticles
IJ.log("# valid particles = %d " % len(validParticles))
# sort particles according to Mean
validParticlesSorted = sorted(validParticles, key=itemgetter(3))
# only keep the three with the largest Mean
validParticles = validParticlesSorted[-int(kwargs["nrPart"]):]
#random.shuffle(validParticles)
IJ.log("# valid particles = %d " % len(validParticles))
if len(validParticles) == 0:
validParticles = None
return impMetaProb, impBW, validParticles, rois
def createROI(xy_coord, diameter):
imp = WindowManager.getCurrentImage()
pixelWidth = imp.getCalibration().pixelWidth
pixelHeight = imp.getCalibration().pixelHeight
x_diameter = diameter / pixelWidth
y_diameter = diameter / pixelHeight
x_coord = xy_coord[0] / pixelWidth - (0.5 * x_diameter)
y_coord = xy_coord[1] / pixelHeight - (0.5 * y_diameter)
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
roi = OvalRoi(x_coord, y_coord, x_diameter, y_diameter)
rm.addRoi(roi)
def create(imp):
# Prep Roi Manager
rm = RoiManager.getInstance()
if rm is not None:
rm.reset()
# Get current image
imp2 = imp.duplicate()
IJ.run(imp2, "8-bit", "") # convert to 8-bit
IJ.run(imp2, "Auto Threshold", "method=Shanbhag white")
IJ.run(imp2, "Analyze Particles...", "size=10000-Infinity circularity=0-1.00 show=Masks add in_situ") # "add" right after "include" to include roi to manager
# Remove background
ic = ImageCalculator()
imp3 = ic.run("AND create", imp, imp2)
imp.close()
imp2.close()
### Begin manipulating ROIs ###
rm = RoiManager.getInstance()
# Get number of objects found
roiCount = rm.getCount()
print "Number of Particles found:" + str(roiCount)
def roiprocess(imp, filename):
# get the ROI manager instance
rm = RoiManager.getInstance()
if rm is None:
rm = RoiManager()
rm.runCommand(imp, "Select All")
# rm.runCommand("Deselect"); # deselect ROIs to save them all
rm.runCommand(imp, 'Show All')
# define the path to save the rois as azip file
roisavelocation = os.path.splitext(filename)[0] + '_RoiSet.zip'
# log.info('ROISs saved: ' + roisavelocation)
# print('ROIs saved: ', roisavelocation)
rm.runCommand("Save", roisavelocation)
return roisavelocation
def filter_hough():
new_image = IJ.getImage()
# Get the roi manager
roi_manager = RoiManager.getInstance()
roi_array = roi_manager.getRoisAsArray()
for cur_roi in roi_array:
new_image.setRoi(cur_roi)
stats = new_image.getStatistics(Measurements.CENTROID)
x_centroid_list.append(stats.xCentroid)
y_centroid_list.append(stats.yCentroid)
# Close the new image
new_image.killRoi() # Remove the remaining ROI
roi_manager.runCommand("Reset")
roi_manager.runCommand("Close")
new_image.changes = False
new_image.close()
def identifyTunicate(imp):
# Clear ROI manager
rm = RoiManager.getInstance()
if rm is not None:
rm.reset()
# Get hue from HSB stack
impHue = ProcessHSB.getHue(imp)
width = impHue.width
height = impHue.height
# Get processor
ipHue = impHue.getProcessor().convertToFloat()
huePixels = ipHue.getPixels()
# Get macro hue because it is the same color
newPixels = map(ProcessHSB.macroHue, huePixels)
ipNew = FloatProcessor(width, height, newPixels)
impTunicate = ImagePlus("MacroHue", ipNew)
# Bring brightness into the equation
impBrightness = ProcessHSB.getBrightness(imp)
IJ.run(impBrightness, "Auto Threshold", "method=MaxEntropy white")
#IJ.run(impBrightness, "Analyze Particles...", "size=10000-Infinity circularity=0.10-1.00 show=Masks in_situ") # "add" right after "include" to include roi to manager
# Logic AND pictures together
ic = ImageCalculator()
impTunicateMask = ic.run("AND create", impTunicate, impBrightness)
IJ.run(impTunicateMask, "8-bit", "") # convert to 8-bit
impTunicate.close()
impBrightness.close()
IJ.run(impTunicateMask, "Analyze Particles...",
"size=10000-Infinity circularity=0.50-1.00 show=Masks add in_situ"
) # "add" right after "include" to include roi to manager
impTunicateMask.close()
#imp.show()
#rm = RoiManager.getInstance()
#return rm
#testImp = IJ.getImage()
#result = identifyTunicate(testImp)
#print type(result)
def ShowRoi(self,imp,point, name): for indices in self.__gridrectangle.keys() : if self.__gridrectangle[indices].contains(point) : roitemp=self.__dictCells[name][self.__listcellname[indices[0]-1]].getRoi(indices[1]-1) if isinstance(roitemp,Roi) : idimages=WindowManager.getIDList() for i in range(len(idimages)) : if idimages[i]==self.__img.getID() : IJ.selectWindow(self.__img.getID()) rm = RoiManager.getInstance() for i in range(rm.getCount()) : if rm.getName(str(i))==roitemp.getName() : rm.select(i) selectroi=self.__img.getRoi() #col=rm.getSelectedRoisAsArray().getStrokeColor() selectroi.setStrokeColor(Color.red) selectroi.setStrokeWidth(3) self.__img.updateAndDraw() break
def main():
roi = RoiManager.getInstance()
image = IJ.getImage()
imageStack = image.getImageStack()
RoiCount = roi.getCount()
ImageCount = imageStack.getSize()
tmp = image.getShortTitle().split('_')
tmp.remove('DIC')
tmp.append('xy')
dirName = '_'.join(tmp)
outDir = os.path.join(rootDir, dirName)
if not os.path.exists(outDir):
os.mkdir(outDir)
if (RoiCount != ImageCount):
print("Warning: Not all Images have a corresponding ROI.")
for i in range(0, RoiCount):
filename = roi.getName(i).split('-')[0]
filename = str(int(filename))
roi.select(i)
Poly = roi.getSelectedRoisAsArray()[0].getFloatPolygon()
xPoints = Poly.xpoints
yPoints = Poly.ypoints
xCount = len(Poly.xpoints)
yCount = len(Poly.ypoints)
outfileName = outDir + '/' + dirName + '_' + filename + ".txt"
outFile = open(outfileName, "w")
if (xCount != yCount):
print("Error: something wrong with ROI file")
return None
for p in range(0, xCount):
xPoint = PixelSize * xPoints[p]
yPoint = PixelSize * yPoints[p]
outFile.write("%f\t%f\n" % (xPoint, yPoint))
outFile.close()
def identifyRed(imp):
# Clear ROI manager
rm = RoiManager.getInstance()
if rm is not None:
rm.reset()
# set results table
# rt = ResultsTable.getResultsTable()
# Get hue from HSB stack
impHue = ProcessHSB.getHue(imp)
width = impHue.width
height = impHue.height
# Get processor for hue
ipHue = impHue.getProcessor().convertToFloat()
huePixels = ipHue.getPixels()
# Bring brightness into the equation
impBrightness = ProcessHSB.getBrightness(imp)
IJ.run(impBrightness, "Auto Threshold", "method=MaxEntropy white")
IJ.run(impBrightness, "Analyze Particles...",
"size=10000-Infinity circularity=0.00-1.00 show=Masks in_situ")
# Get processor for brightness
ipBrightness = impBrightness.getProcessor().convertToFloat()
brightnessPixels = ipBrightness.getPixels()
# Do the thing now
newPixels = map(ProcessHSB.redHueBackground, brightnessPixels, huePixels)
# If hue < 30 and hue > 225, True
#newNewPixels = map(ProcessHSB.redHue, newPixels)
# Pause: Do this later
ipNew = FloatProcessor(width, height, newPixels)
impRed = ImagePlus("RedHue", ipNew)
IJ.run(impRed, "8-bit", "") # convert to 8-bit
#IJ.run(imp, "Options...", "iterations=20 count=1 black do=[Fill Holes]");
impRed.show()
def Weka_Segm(dirs):
""" Loads trained classifier and segments cells """
""" in aligned images according to training. """
# Define reference image for segmentation (default is timepoint000).
w_train = os.path.join(dirs["Composites_Aligned"], "Timepoint000.tif")
trainer = IJ.openImage(w_train)
weka = WekaSegmentation()
weka.setTrainingImage(trainer)
# Select classifier model.
weka.loadClassifier(str(classifier))
weka.applyClassifier(False)
segmentation = weka.getClassifiedImage()
segmentation.show()
# Convert image to 8bit
ImageConverter(segmentation).convertToRGB()
ImageConverter(segmentation).convertToGray8()
# Threshold segmentation to soma only.
hist = segmentation.getProcessor().getHistogram()
lowth = Auto_Threshold.IJDefault(hist)
segmentation.getProcessor().threshold(lowth)
segmentation.getProcessor().setThreshold(0, 0, ImageProcessor.NO_LUT_UPDATE)
segmentation.getProcessor().invert()
segmentation.show()
# Run Watershed Irregular Features plugin, with parameters.
IJ.run(segmentation, "Watershed Irregular Features",
"erosion=20 convexity_treshold=0 separator_size=0-Infinity")
# Make selection and add to RoiManager.
RoiManager()
rm = RoiManager.getInstance()
rm.runCommand("reset")
roi = ThresholdToSelection.run(segmentation)
segmentation.setRoi(roi)
rm.addRoi(roi)
rm.runCommand("Split")
def process(imp):
# Open and clear Roi Manager
rm = RoiManager.getInstance()
if rm is not None:
rm.reset()
# Duplicate image
imp2 = imp.duplicate()
#IJ.run(imp2, "8-bit", "") # convert to 8-bit
IJ.run(imp2, "HSB Stack", "")
IJ.run(imp2, "Delete Slice", "")
IJ.run(imp2, "Delete Slice", "")
IJ.run(imp2, "Auto Threshold",
"method=MaxEntropy white") #Shanbhag #MaxEntropy
IJ.run(imp2, "Analyze Particles...",
"size=10000-Infinity circularity=0-1.00 show=Masks add in_situ"
) # "add" right after "include" to include roi to manager
imp2.show()
return 0
def makeCell(cellfile) :
filetemp = open(cellfile,"r")
linestemp=filetemp.readlines()
for line in linestemp :
params=line.split("=")
values=params[1].split("\n")
if params[0] == "NAMECELL" :
celltemp=Bacteria_Cell(str(values[0]))
if params[0] == "PATHROIS" :
pathtemp = str(values[0])
if params[0] == "NSLICES" :
for i in range(int(values[0])) :
celltemp.getListRoi().append("")
if params[0] == "SLICEINIT" :
celltemp.setSlideInit(int(values[0]))
#for i in range(int(values[0])-2) :
# celltemp.setRoi("NOT HERE YET",i)
if params[0] == "SLICEEND" :
celltemp.setSlideEnd(int(values[0]))
#for i in range(int(values[0])) :
# celltemp.setRoi("LOST",i)
if params[0] == "COLOR" :
colorstemp=values[0].split(";")
celltemp.setColor(Color(int(colorstemp[0]),int(colorstemp[1]),int(colorstemp[2])))
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
rm.runCommand("Open", pathtemp)
rois=rm.getSelectedRoisAsArray()
celltemp.setlistRois(rois)
rm.runCommand("UseNames", "true")
rm.runCommand("Associate", "true")
return celltemp
def segmentation(imp, spot_data, channel, diameter_init, ES_tolerance, ES_area_max, ES_ctrl_pts, ES_iteration, repeat_max):
# Open files
cal = imp.getCalibration()
manager = RoiManager.getInstance()
if manager is None:
manager = RoiManager()
# Prepare log files for output
options = IS.MEDIAN | IS.AREA | IS.MIN_MAX | IS.CENTROID | IS.PERIMETER | IS.ELLIPSE | IS.SKEWNESS
convergence = []
Sintensity = []
for spot in spot_data:
repeat = 0
flag = False
spotID = int(spot[0])
Xcenter = (float(spot[1]) / cal.pixelWidth)
Ycenter = (float(spot[2]) / cal.pixelHeight)
Quality = float(spot[3])
diameter_init = float(spot[4] / cal.pixelWidth) * 2.0
while True:
manager = RoiManager.getInstance()
if manager is None:
manager = RoiManager()
Xcurrent = int(Xcenter - diameter_init / 2.0)
Ycurrent = int(Ycenter - diameter_init / 2.0)
Dcurrent1 = int(diameter_init * (1.2 - repeat / 10.0))
Dcurrent2 = int(diameter_init * (0.8 + repeat / 10.0))
roi = OvalRoi(Xcurrent, Ycurrent, Dcurrent1, Dcurrent2)
imp.setPosition(channel)
imp.setRoi(roi)
Esnake_options1 = "target_brightness=Bright control_points=" + \
str(ES_ctrl_pts) + " gaussian_blur=0 "
Esnake_options2 = "energy_type=Contour alpha=2.0E-5 max_iterations=" + \
str(ES_iteration) + " immortal=false"
IJ.run(imp, "E-Snake", Esnake_options1 + Esnake_options2)
roi_snake = manager.getRoisAsArray()
roi_ind = len(roi_snake) - 1
stats = IS.getStatistics(
imp.getProcessor(), options, imp.getCalibration())
perimeter = roi_snake[roi_ind].getLength() * cal.pixelWidth
circularity = 4.0 * 3.1417 * (stats.area / (perimeter * perimeter))
if stats.area > 17.0 and stats.area < ES_area_max and stats.skewness < -0.01 and circularity > 0.01 and stats.minor > 2.0 and boundaries(Xcenter, Ycenter, stats.xCentroid / cal.pixelWidth, stats.yCentroid / cal.pixelHeight, ES_tolerance):
Sintensity = stats.median
convergence.append(True)
break
if stats.median > 6000 and stats.area > 17.0 and stats.area < ES_area_max:
Sintensity = stats.median
convergence.append(True)
break
elif repeat > repeat_max:
manager.select(imp, roi_ind)
manager.runCommand(imp, 'Delete')
roi = OvalRoi(Xcenter + 1.0 - diameter_init / 2.0, Ycenter +
1.0 - diameter_init / 2.0, diameter_init, diameter_init)
imp.setRoi(roi)
manager.add(imp, roi, spotID)
roi_snake.append(roi)
stats = IS.getStatistics(
imp.getProcessor(), options, imp.getCalibration())
Sintensity = stats.median
convergence.append(False)
break
else:
IJ.log('Area=' + str(stats.area) + ' Skewness=' + str(stats.skewness) +
' circularity=' + str(circularity) + ' Minor=' + str(stats.minor))
manager.select(imp, roi_ind)
manager.runCommand(imp, 'Delete')
repeat += 1
# End Spot-segmentation
# End all Spots-segmentation
manager.runCommand(imp, 'Show All')
imp.setPosition(channel)
color = imp.createImagePlus()
ip = imp.getProcessor().duplicate()
color.setProcessor("segmentation" + str(channel), ip)
color.show()
IJ.selectWindow("segmentation" + str(channel))
manager.moveRoisToOverlay(color)
spot_optimal = manager.getRoisAsArray()
manager.reset()
for i in xrange(0, len(spot_optimal)):
spot = spot_optimal[i]
spot.setStrokeWidth(2)
if convergence[i]:
spot.setStrokeColor(Color.GREEN)
else:
spot.setStrokeColor(Color.MAGENTA)
imp.setRoi(spot)
manager.add(imp, spot, i)
manager.runCommand(imp, 'Show All')
imp.setPosition(channel)
def updatepressed(event):
self.__image=IJ.getImage()
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
self.__image.killRoi()
IJ.run("Threshold...")
IJ.setAutoThreshold(self.__image, "MaxEntropy")
rt=ResultsTable()
pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00)
pa.analyze(self.__image)
self.__roisArray=[]
self.__roisArray=rm.getRoisAsArray()
#for i in range(rm.getCount()) :
# rm.select(i)
# rm.runCommand("Set Color", "0000FF", 2)
IJ.resetThreshold(self.__image)
rt.show("tempRT")
areas=rt.getColumn(ResultsTable.AREA)
means=rt.getColumn(ResultsTable.MEAN)
majors=rt.getColumn(ResultsTable.MAJOR)
minors=rt.getColumn(ResultsTable.MINOR)
#print 0
if self.__slidersDict["Area_max"].getMaximum() < int(max(areas)+1):
# print 1
self.__slidersDict["Area_max"].setMaximum(int(max(areas))+1)
if self.__slidersDict["Area_min"].getMaximum() < int(max(areas)+1):
# print 2
self.__slidersDict["Area_min"].setMaximum(int(max(areas))+1)
if self.__slidersDict["Mean_max"].getMaximum() < int(max(means)+1):
# print 3
self.__slidersDict["Mean_max"].setMaximum(int(max(means))+1)
if self.__slidersDict["Mean_min"].getMaximum() < int(max(means)+1):
# print 4
self.__slidersDict["Mean_min"].setMaximum(int(max(means))+1)
if self.__slidersDict["Major_max"].getMaximum() < int(max(majors)):
# print 5
self.__slidersDict["Major_max"].setMaximum(int(max(majors))+1)
if self.__slidersDict["Major_min"].getMaximum() < int(max(majors)+1):
# print 6
self.__slidersDict["Major_min"].setMaximum(int(max(majors))+1)
if self.__slidersDict["Minor_max"].getMaximum() < int(max(minors)+1):
# print 7
self.__slidersDict["Minor_max"].setMaximum(int(max(minors))+1)
if self.__slidersDict["Minor_min"].getMaximum() < int(max(minors)+1):
# print 8
self.__slidersDict["Minor_min"].setMaximum(int(max(minors))+1)
if self.__slidersDict["AR_max"].getMaximum() < int((max(majors)+1)/min(minors)+1):
# print 9
self.__slidersDict["AR_max"].setMaximum(int((max(majors)+1)/(min(minors))))
if self.__slidersDict["AR_min"].getMaximum() < int((max(majors)+1)/min(minors)):
# print 10
self.__slidersDict["AR_min"].setMaximum(int((max(majors)+1)/(min(minors))))
#print 11
for sb in self.__slidersDict.values():
sb.repaint()
#rm.runCommand("reset")
#temprois=self.getIncludeRois()
#IJ.run(self.__image, "Remove Overlay", "")
#o=Overlay()
#for roi in temprois:
# o.addElement(roi)
#self.__image.killRoi()
#self.__image.setOverlay(o)
self.__image.updateAndDraw()
def __calRois(self, imp, indice) :
"""
Returns the ROIs of a slice given (identified with its n°) in a stack
"""
##imp=self.__dictImages[nameimages] # IL FAUT RÉCUPÉRER L'IMAGE DU STACK !!!!!
#if self.__batch : imp.hide()
#else : imp.show()
#imp.hide()
imp.show()
if self.__batch : imp.hide()
imp.setSlice(indice)
imp.killRoi()
ip = imp.getProcessor()
bs=BackgroundSubtracter()
#if str(self.__subback) == "0" or str(self.__subback) == "1" : self.__subback = bool(int(self.__subback))
#if self.__subback == True : IJ.run(imp, "Subtract Background...", "rolling="+str(self.__radius)+" light")
if self.__subback == True : bs.rollingBallBackground(ip, self.__radius, False, True, False, True, False)
if self.__runmacro :
imp.show()
imp.setSlice(indice)
imp.updateAndDraw()
IJ.runMacroFile(self.__macropath, imp.getTitle())
imp.updateAndDraw()
#if str(self.__manthresh) == "0" or str(self.__manthresh) == "1" : self.__manthresh = bool(int(self.__manthresh))
#if self.__manthresh : IJ.setThreshold(imp, self.__minthr, self.__maxthr)
if self.__manthresh :
ip.setThreshold(self.__minthr, self.__maxthr, ImageProcessor.RED_LUT)
else : self.__setThreshold(imp, indice)
rt=ResultsTable()
pa1=ParticleAnalyzer(ParticleAnalyzer.SHOW_MASKS+ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES , Measurements.AREA, rt, self.__minArea, self.__maxArea, self.__minCirc, self.__maxCirc)
pa1.setHideOutputImage(True)
pa1.analyze(imp)
masks=pa1.getOutputImage()
masks.getProcessor().erode()
masks.getProcessor().dilate()
masks.getProcessor().invertLut()
masks.getProcessor().threshold(1)
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
#rm.hide()
pa2=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET+ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES , Measurements.AREA, rt, self.__minArea, self.__maxArea, self.__minCirc, self.__maxCirc)
pa2.analyze(masks)
masks.close()
temparray=rm.getRoisAsArray()
for r in temparray :
tempnameroi=r.getName()
r.setPosition(indice)
r.setName(str(indice)+"-"+tempnameroi)
r.setStrokeWidth(1)
if len(self.__params) > 0 :
for k in self.__params:
#if k[0]=="Area": self.__minArea, self.__maxArea = str(k[1]), str(k[2])
if k[0]=="Area": self.__minArea, self.__maxArea = k[1], k[2]
for k in self.__params:
#if k[0]=="Circ": self.__minCirc, self.__maxCirc = str(k[1]), str(k[2])
if (k[0]=="Circ") and k[3] : self.__minCirc, self.__maxCirc = k[1], k[2]
else : self.__minCirc, self.__maxCirc = 0, 1
self.__rr.setRoisarray(temparray, imp)
self.__rr.setRange(indice, self.__params)
return self.__rr.includeRois
else : return temparray
def getRoiManager():
""" Obtain a valid instance of the ROI Manager.
Notice that it could still be null if its window is closed."""
if RoiManager.getInstance() is None:
RoiManager()
return RoiManager.getInstance()
myCalibration = imp1.getCalibration()
myCalibration.setUnit("um")
myCalibration.pixelWidth = float(voxelx)
myCalibration.pixelHeight = float(voxely)
myCalibration.pixelDepth = float(voxelz)
imp1.setCalibration(myCalibration)
if imp1 is None:
print "BAD imp1, nothin else will work."
#add sPoint list to ROI (don't add cPoint list for now)
if doROI==1:
#see: http://fiji.sc/Tips_for_developers#Interact_with_the_ROI_manager
print "building roi list"
manager = RoiManager.getInstance()
if (manager == None):
manager = RoiManager()
RoiManager(False) #sho the roi manager window, wierd interface
i = 1
for currPoint in pointList:
#print "point " + str(i)
x, y, z = currPoint.split(",")
#composite is interleaved with ch1/ch2
#if doComposite==1:
# z *= 2
#a point roi (This seems to be in pixels???)
pROI = PointRoi(int(x), int(y), imp1)
def run(self, cells, path) :
self.__cells=cells
cells.sort()
self.__cells.sort()
self.__path=path
if len(cells) <= 6 :
cols=len(cells)
rows=1
else :
cols=6
rows=int(len(cells)/6)+1
#print "cols", cols, "rows", rows
self.setFont(awt.Font("Courrier", 1, 10))
#self.size=(max(200*cols, 1100), max(70*rows, 300))
self.size=(max(150*cols, 800), max(50*rows, 250))
line = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED)
self.contentPane.layout = awt.BorderLayout()
self.__display = swing.JTextField(preferredSize=(400, 30), horizontalAlignment=swing.SwingConstants.LEFT)
self.__setDisplay()
northpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.LEFT))
northpanel.setBorder(line)
#northpanel.add(self.__display, awt.BorderLayout.NORTH)
northpanel.add(self.__display)
selectall = swing.JButton("select ALL", size=(100, 70), actionPerformed=self.__selectall)
#northpanel.add(selectall, awt.BorderLayout.WEST)
northpanel.add(selectall)
selectnone = swing.JButton("select NONE", size=(100, 70), actionPerformed=self.__selectnone)
#northpanel.add(selectnone, awt.BorderLayout.EAST)
northpanel.add(selectnone)
mem = swing.JButton("Memorize", size=(100, 70), actionPerformed= self.__memorize)
northpanel.add(mem)
recall = swing.JButton("Recall", size=(100, 70), actionPerformed=self.__recall)
northpanel.add(recall)
southpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.RIGHT))
southpanel.setBorder(line)
self.__label=swing.JLabel("validate selection with ok")
southpanel.add(self.__label)
ok = swing.JButton("ok", size=(100, 70), actionPerformed=self.__ok)
southpanel.add(ok)
close = swing.JButton("close", size=(100, 70), actionPerformed=self.__close)
southpanel.add(close)
westpanel=swing.JPanel(awt.FlowLayout(awt.FlowLayout.CENTER), preferredSize=(150, 200))
westpanel.setBorder(line)
show = swing.JButton("show overlay", size=(100, 70), actionPerformed=self.__show)
westpanel.add(show)
hide = swing.JButton("hide overlay", size=(100, 70), actionPerformed=self.__hide)
westpanel.add(hide)
allframes = swing.JButton("show all", size=(100, 70), actionPerformed=self.__showall)
westpanel.add(allframes)
oneframe = swing.JButton("show one frame", size=(100, 70), actionPerformed=self.__showone)
westpanel.add(oneframe)
reset = swing.JButton("reset", size=(100, 70), actionPerformed=self.__reset)
westpanel.add(reset)
title = BorderFactory.createTitledBorder("Edit Cells")
title.setTitleJustification(TitledBorder.CENTER)
eastpanel = swing.JPanel(awt.FlowLayout(awt.FlowLayout.CENTER), preferredSize=(130, 200))
eastpanel.setBorder(title)
split = swing.JButton("split", size=(100, 70), actionPerformed=self.__split)
eastpanel.add(split)
grid = awt.GridLayout()
grid.setRows(rows)
checkpanel=swing.JPanel(grid)
checkpanel.setFont(awt.Font("Courrier", 1, 10))
self.__boxes=[swing.JCheckBox(actionPerformed=self.__boxaction) for i in range(len(cells))]
for b in self.__boxes : b.setFont(awt.Font("Courrier", 1, 10))
#self.__mem=[True for i in range(len(cells))]
for i in range(len(self.__boxes)) :
self.__dictBox[cells[i]]=(cells[i], self.__boxes[i])
for i in range(len(self.__boxes)) :
self.__boxes[i].setText(str(cells[i]))
self.__boxes[i].setSelected(True)
checkpanel.add(self.__boxes[i])
for i in range(rows*cols-len(self.__boxes)) : checkpanel.add(awt.Label(""))
self.contentPane.add(northpanel, awt.BorderLayout.NORTH)
self.contentPane.add(checkpanel, awt.BorderLayout.CENTER)
self.contentPane.add(westpanel, awt.BorderLayout.WEST)
self.contentPane.add(eastpanel, awt.BorderLayout.EAST)
self.contentPane.add(southpanel, awt.BorderLayout.SOUTH)
self.contentPane.setFont(awt.Font("Courrier", 1, 10))
self.__rm = RoiManager.getInstance()
if (self.__rm==None): self.__rm = RoiManager()
self.__rm.runCommand("reset")
listfilescells=[]
listfilescells.extend(glob.glob(path+"*.zip"))
#includecells = [filename for filename in listfilescells if filename.rsplit("/",1)[1][0:-4] in cells]
includecells = [filename for filename in listfilescells if os.path.splitext(os.path.split(filename)[1])[0] in cells]
for cell in includecells :
#c = cell.rsplit("/",1)[1][0:-4]
c=os.path.splitext(os.path.split(cell)[1])[0]
self.__dictFiles[c] = (c, cell)
def run():
zk = ZeissKeys()
msg = Message()
timestart = time.clock()
channel = 1
#size in um2
minArea = 20
maxArea = 200
maxMetaArea = 70
minMetaAR = 1.8
method = "Triangle"
print "Enter run"
detectionNucleus = [minArea, maxArea]
detectionMetaphase = [minArea, maxMetaArea]
filepath = ""
try:
filepath = getArgument()
image = IJ.openImage(filepath) #arguments provided by runMacro
except NameError:
try:
filepath = newImagePath #argument provided by the macroRunner
except NameError: #no file name specified
errMsg = "Fiji error segmentNuclei.py: no filepath has been passed to the macro"
exitWithError(errMsg)
od = OpenDialog("Choose image file", None)
if od.getFileName() == None:
return
filepath = os.path.join(od.getDirectory(), od.getFileName())
# A roimanager is recquired
roim = RoiManager.getInstance()
if roim == None:
roim = RoiManager()
#test a last time
if roim == None:
print 'Fiji error segmentNuclei.py: no RoiManager!'
exitWithError('Fiji error segmentNuclei.py: no RoiManager!')
try:
IJ.run("Close all forced")
IJ.run("Clear Results")
IJ.log("\\Clear")
image = IJ.openImage(filepath)
IJ.log("File Path " + filepath)
try:
image.hide()
except:
image = IJ.getImage()
image.hide()
image.show()
if image is None:
exitWithError("Fiji failed to open image")
return 0
#convert um2 to pixels
pixelSize = image.getCalibration().pixelWidth
detectionNucleus = [area/pixelSize/pixelSize for area in detectionNucleus]
detectionMetaphase = [area/pixelSize/pixelSize for area in detectionMetaphase]
detectionMetaphase.append(minMetaAR)
title = image.getTitle()
imageC = None
#split colors if needed
if image.getNChannels() > 1:
chSp = ChannelSplitter()
imageC = chSp.split(image)
imageSeg = imageC[channel-1].duplicate()
else:
imageSeg = image.duplicate()
imageSeg.setTitle("SEG_"+title)
sp = segment_Particles()
imageSeg = sp.preprocessImage(imageSeg, "MAX", "C1", 2, 2)
imageSeg = sp.segmentParticles(imageSeg, method, detectionNucleus[0], detectionNucleus[1], 2, 2)
roim = RoiManager.getInstance()
if roim == None:
print 'Fiji error segmentNuclei.py: no RoiManager!'
exitWithError('Fiji error segmentNuclei.py: no RoiManager!')
#compute central object
if roim.getCount() > 0:
centPart, msg.position = centerParticle(imageSeg, roim)
msg.position = msg.position + (focusParticle(image, roim, centPart),)
writePositionToRegistry(msg.position)
else:
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+msg.CODE_NOTHING+"] windows=REG_SZ")
return 0
#create output image
if imageC is None:
impOut = createOutputImg(image, roim, centPart, 0)
else:
impOut = createOutputImg(imageC[channel-1], roim, centPart, 0)
impOut.show()
#save outut image
#saveOutputImg(impOut, filepath, 'Analyzed')
#check for roi properties to identofy metaphase
metaphase = isSpecialParticle(image, roim, centPart,detectionNucleus, detectionMetaphase,pixelSize, msg.position[2])
if os.path.basename(filepath).startswith('TR1_') or '_TR1_' in os.path.basename(filepath):
metaphase = 0
if metaphase:
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+msg.CODE_TRIGGER1+"] windows=REG_SZ")
else:
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+msg.CODE_FOCUS+"] windows=REG_SZ")
IJ.log("time focus " + str(time.clock() - timestart))
IJ.run("Collect Garbage")
#IJ.run("Close all forced")
#IJ.run("Clear Results")
except BaseException, err:
def __ImportCells(self, imagesnames) :
#self.__dictCells[imgName]={}
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
listpaths = []
listfilescells=[]
if self.__optionImages :
IJ.showMessage("Select the folder 'Cells' containing the cells to import")
selectdir=IJ.getDirectory("image")
selectdir=IJ.getDirectory("")
listfilescells.extend(glob.glob(selectdir+os.path.sep+"*"))
listpaths.append("")
else :
IJ.showMessage("Select the text file containing the list cell paths (listpaths.txt)")
selectdir=IJ.getDirectory("current")
frame = Frame("Text file settings ?")
fd = FileDialog(frame)
fd.setDirectory(selectdir)
fd.show()
selectdir = fd.getDirectory()
textfile = fd.getFile()
fichier = open(selectdir+textfile,"r")
listpaths=[ glob.glob(f.split("\n")[0]+"Selected-Cells"+os.path.sep+"*") for f in fichier.readlines()]
#for f in templist :
# listpaths.append(f.split("\n")+"Cells")
listfilescells.append("")
if listfilescells[0]=="" : importmode = True
else : importmode = False
for j in range(len(listpaths)) :
self.__dictCells[imagesnames[j]]={}
if importmode : listfilescells = listpaths[j]
pathtemp = []
for cellfile in listfilescells :
filetemp = open(cellfile,"r")
linestemp=filetemp.readlines()
for line in linestemp :
params=line.split("=")
values=params[1].split("\n")
if params[0] == "NAMECELL" :
celltemp=Bacteria_Cell(str(values[0]))
self.__dictCells[imagesnames[j]][values[0]]=celltemp
self.__dictMeasures[self.__dictCells[imagesnames[j]][values[0]]]={}
if params[0] == "PATHROIS" :
pathtemp.append(str(values[0]))
if params[0] == "NSLICES" :
for i in range(int(values[0])) :
celltemp.getListRoi().append("")
if params[0] == "SLICEINIT" :
celltemp.setSlideInit(int(values[0]))
for i in range(int(values[0])-2) :
celltemp.setRoi("NOT HERE YET",i)
if params[0] == "SLICEEND" :
celltemp.setSlideEnd(int(values[0]))
for i in range(int(values[0])) :
celltemp.setRoi("LOST",i)
if params[0] == "COLOR" :
colorstemp=values[0].split(";")
celltemp.setColor(Color(int(colorstemp[0]),int(colorstemp[1]),int(colorstemp[2])))
indiceroi=0
ind=0
tempimp = WindowManager.getImage(imagesnames[j])
if tempimp is not None :
IJ.selectWindow(imagesnames[j])
tempimp.show()
else :
if imagesnames[j][-4:]==".tif" :
IJ.selectWindow(imagesnames[j][:-4])
tempimp = IJ.getImage()
else :
IJ.selectWindow(imagesnames[j]+".tif")
tempimp = IJ.getImage()
rm.runCommand("reset")
for cellname in self.__dictCells[imagesnames[j]].keys() :
rm.runCommand("Open", pathtemp[ind])
ind+=1
nbtemp=self.__dictCells[imagesnames[j]][cellname].getLifeTime()
for i in range(nbtemp) :
rm.select(tempimp, indiceroi)
roi=rm.getSelectedRoisAsArray()[0]
self.__dictCells[imagesnames[j]][cellname].setRoi(roi,i+self.__dictCells[imagesnames[j]][cellname].getSlideInit()-1)
indiceroi+=1
IJ.run("Show Overlay", "")
rm.runCommand("UseNames", "true")
rm.runCommand("Associate", "true")
IJ.run(tempimp, "Labels...", "color=red font=12 show use")
if rm.getCount()>0 : IJ.run(tempimp, "From ROI Manager", "")
rm.runCommand("Show None")
rm.runCommand("Show All")
roipath = os.path.split(pathtemp[0])[0]+os.path.sep
rootpath = roipath.rsplit(os.path.sep, 2)[0]+os.path.sep
self.__listpaths[j] = rootpath
self.__rootpath=rootpath
# @LogService log
# This script exemplifies how to instruct KymographBuilder to
# process all the line ROIs present in the ROI Manager. For more
# details see http://imagej.net/KymographBuilder
import ij.plugin.frame.RoiManager as RM
import sc.fiji.kymographBuilder.KymographFactory as KFactory
def validDataset(dataset):
"""Assess if dataset has suitable dimensions"""
from net.imagej.axis import Axes
z = dataset.dimension(dataset.dimensionIndex(Axes.Z))
t = dataset.dimension(dataset.dimensionIndex(Axes.TIME))
return z * t > 1
rm = RM.getInstance()
counter = 0
if validDataset(dataset) and rm and rm.getCount():
for roi in rm.getRoisAsArray():
if roi.isLine():
kfactory = KFactory(context, dataset, roi)
kfactory.build()
counter += 1
title = "Kymograph" + str(counter).zfill(3) + "_" + roi.getName()
ij.ui().show(title, kfactory.getKymograph())
log.info("MultiKymographBuilder Finished. " + str(counter) + " ROIs processed")
else:
log.error("Either the ROI Manager is empty or " + dataset.getName() +" has invalid dimensions")
def __displayCells(self, nameimage, methodeleon=False):
"""
Displays all the ROIs of the cells with different colors
"""
# we define a list of colors that will be used.
colors = []
ncells= len(self.__dict[nameimage])
if ncells > 0 :
step=200/ncells
if step<1 : step=1
for i in range(ncells) :
r = random.randrange(5,205,step)
g = random.randrange(10,210,step)
b = random.randrange(30,230,step)
#r = int(0+i*step)
#g = random.randrange(10, 190, 30)
#b = int(250-i*step)
colors.append(Color(r, g, b))
else : colors=[Color.blue, Color.green, Color.magenta, Color.orange, Color.yellow]
tempcolors=list(colors)
# we try to have random and different colors for each cell.
for cellname in self.__dict[nameimage].keys() :
if len(tempcolors)>0 :
self.__dict[nameimage][cellname].setColor(tempcolors.pop(0))
else :
tempcolors=list(colors)
self.__dict[nameimage][cellname].setColor(tempcolors.pop(0))
self.__SaveCells(nameimage)
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
# if the user wants to save files, .zip for the ROIs are saved.
#if self.__optionSave == True :
#os.mkdir(self.__pathdir+"ROIs/", mode=0777)
os.makedirs(self.__pathdir+"ROIs/", mode=0777)
tempimp = IJ.createImage("tempimp", "8-bit Black", self.__dictImages[nameimage].getWidth(), self.__dictImages[nameimage].getHeight(), 1)
tempimp.show()
for cellname in self.__dict[nameimage].keys() :
for numslice in range(self.__dictImages[nameimage].getImageStackSize()) :
r = self.__dict[nameimage][cellname].getRoi(numslice)
try :
name=r.getName()
except AttributeError : continue
else :
s = "%04i" % (numslice+1)
#name=s+"-"+name.split("-", 1)[1]
name=s+"-cell"+name.split("cell")[1]
r.setName(name)
try :
rm.addRoi(r)
rname=rm.getName(rm.getCount()-1)
#rm.select(self.__dictImages[nameimage], rm.getCount()-1)
rm.select(tempimp, rm.getCount()-1)
rm.runCommand("Rename", name)
except TypeError : continue
#if isinstance(self.__dict[nameimage][cellname].getRoi(numslice),Roi) == True :
# s = "%04i" % (numslice)
# #rm.add(self.__dictImages[nameimage], self.__dict[nameimage][cellname].getRoi(numslice) , numslice)
# name=self.__dict[nameimage][cellname].getRoi(numslice).getName()
# name=s+name
# self.__dict[nameimage][cellname].getRoi(numslice).setName(name)
# rm.addRoi(self.__dict[nameimage][cellname].getRoi(numslice))
rm.runCommand("Save", self.__pathdir+"ROIs/"+cellname+".zip")
rm.runCommand("reset")
tempimp.close()
from ij import IJ from ij.plugin.frame import RoiManager print "'Multi Drift Correction' plugin; version 1.1; by Brandon Brown" #converts microns (or whatever the physical dist is to pixels) ''' def getPixelPos(x,y, imp): point = [0,0] point[0] = (x / cal.piXelW) point[1] = (imp.height * (y / 100)) return point ''' rm = RoiManager.getInstance() #get the open ROI manager instance ra = rm.getRoisAsArray() #get all the ROIs in an array #print r1.getPosition() imp = IJ.getImage() #get current image stack = imp.getStack() #get current rm = RoiManager.getInstance() ra = rm.getRoisAsArray() nRois = len(ra) proc = IJ.getProcessor() #get the image processor cal = imp.getCalibration(); #print cal.pixelWidth #print imp.width totSlices = int(stack.getSize()) #print stack.getSize() #print r1.getFloatPolygon().xpoints[0] #get xpoint #first convert our ROIs to something more useful, a tuple containing the point (x,y) and the Z position => (x,y,z) for i in range(0, nRois-1):
validParticles
random.shuffle(validParticles)
if kwargs['command'] != 'nothing':
autTool.writePositionToRegistry([[part[1], part[2]] for part in validParticles[0:int(kwargs["nrPart"])]])
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+kwargs['command']+"] windows=REG_SZ")
return validParticles
test = 0
if test ==0:
locDialogParameters('Weka_Metaphase_Detection')
if test ==1 :
IJ.run("Close All", "");
roim = RoiManager.getInstance()
if roim == None:
roim = RoiManager()
roim.runCommand("reset");
imagePath = r"C:\Users\toni\Code\AutomatedMicroscopy\IJMacros\WekaPipeline\TestImage_1024.tif"
imp = IJ.openImage(imagePath)
imp.show()
kwargs={'pip':'Default', 'task':1, 'channel':1, 'command':"trigger1", 'clspath':"C:\\Users\\toni\\Code\\AutomatedMicroscopy\\IJMacros\\WekaPipeline\\classifier.model", 'nrPart':3,
'Min Intensity':0.8, 'maxCirc': 0.8, 'probThr':0.6}
procs, segs, validParticles, rois = segmentChannel_Weka([imp], **kwargs)
executeTask_Weka(validParticles, **kwargs)
particle = [part[0] for part in validParticles]
print particle
roim = RoiManager(True) # Create a ParticleAnalyzer, with arguments: # 1. options (could be SHOW_ROI_MASKS, SHOW_OUTLINES, SHOW_MASKS, SHOW_NONE, ADD_TO_MANAGER, and others; combined with bitwise-or) # 2. measurement options (see [http://imagej.net/developer/api/ij/measure/Measurements.html Measurements]) # 3. a ResultsTable to store the measurements # 4. The minimum size of a particle to consider for measurement # 5. The maximum size (idem) # 6. The minimum circularity of a particle # 7. The maximum circularity pa = ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER, Measurements.AREA, table, 0, Double.POSITIVE_INFINITY, 0.0, 1.0) pa.setHideOutputImage(True) if pa.analyze(imp): print "All ok" else: print "There was a problem in analyzing", blobs # The measured areas are listed in the first column of the results table, as a float array: areas = table.getColumn(0) # Create a new list to store the mean intensity values of each blob: means = [] for roi in RoiManager.getInstance().getRoisAsArray(): blobs.setRoi(roi) stats = blobs.getStatistics(Measurements.MEAN) means.append(stats.mean) for area, mean in zip(areas, means): print area, mean
def runOnFile(self, afile, show = True, jobnr = None):
afile = str(afile)
if afile == '' or afile is None:
od = OpenDialog("Choose image file", None)
if od.getFileName() == None:
return
afile = os.path.join(od.getDirectory(), od.getFileName())
if '.log' in afile:
return
try:
zk = ZeissKeys()
msg = Message()
print "Hi"
if self.jobs is None:
IJ.showMessage("You need to first set the parameters")
if all([job['pip']=='None' for job in self.jobs]):
IJ.showMessage("Nothing to do! At least on job different than None")
return 0
#create a copy otherwise self.jobs gets overwritten
jobs = copy.deepcopy(self.jobs)
random.seed()
#create a roiManager in case one is missing and reset it
roim = RoiManager.getInstance()
if roim == None:
roim = RoiManager()
roim.runCommand("reset")
for i, job in enumerate(self.jobs):
jobl = job #not really necessary
if jobl['pip'] == 'None':
continue
self.JOBS_DICT[jobl['pip']] + jobl['task'] + "_"
if jobnr is not None:
if jobnr == i:
#force opening
imageDef = self.openFile(afile, self.getPrefix(self.JOBS_DICT[jobl['pip']], jobl['task']), 1)
else:
continue
else:
imageDef = self.openFile(afile, self.getPrefix(self.JOBS_DICT[jobl['pip']], jobl['task']))
print imageDef
jobl['channel'] = int(jobl['channel'])
if imageDef is None:
continue
#clean up registry for errors
IJ.log("Clean up errorMsg registry")
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_errormsg+" value=[""] windows=REG_SZ")
[imageC, pixelSize, filepath, filename] = imageDef
if jobl['channel'] > len(imageC):
raise IOError('Expecting at least ' + str(jobl['channel']) + ' channels. Image has only ' + str(len(imageC)) + ' channel(s)')
self.rois = [None]*self.nrOfJobs
self.Segs = [None]*self.nrOfJobs
self.Procs = [None]*self.nrOfJobs
#switch color to Cyan for better visibility
IJ.run(imageC[jobl['channel']-1], "Cyan", "")
#segment
self.Procs[i], self.Segs[i], validParticles, self.rois[i] = segmentChannel_Weka(imageC, **jobl)
if validParticles is None:
IJ.run("Read Write Windows Registry", "action=write location=[HKCU\\"+zk.regkey+"] key="+zk.subkey_codemic+" value=["+msg.CODE_NOTHING+"] windows=REG_SZ")
#write values to registry
try:
executeTask_Weka(validParticles, **jobl)
except Exception, err:
self.exitWithError(str(err))
return
if self.rois[i] is None:
imageC[jobl['channel']-1].show()
self.Segs[i].show()
self.Procs[i].show()
continue
if validParticles is None:
particle = []
else:
particle = [part[0] for part in validParticles]
imgOut = autTool.createOutputImg(imageC[jobl['channel']-1], self.rois[i], particle)
imgOut.show()
self.saveOutputImg(imgOut, filepath, i+1)
IJ.run("Collect Garbage", "")
def __addroi(self, event) :
if ( not self.__init) :
IJ.showMessage("", "please start a new stack")
return
if ( not self.__initDIA) :
IJ.showMessage("", "please select an image for DIA")
return
if ( not self.__initFLUO) :
IJ.showMessage("", "please select an image for FLUO")
return
twres = TextWindow("measures-"+self.__name, "label\tname\tsol\tarea\tcirc\tAR\tFeret\taxis\traf\tdMajor\tdFeret\tdArea", "", 300, 450)
tab="\t"
self.__widthl = self.__display2.getText()
IJ.selectWindow(self.__impF.getTitle())
self.__rm = RoiManager.getInstance()
if (self.__rm==None): self.__rm = RoiManager()
if self.__impF.getImageStackSize() > 1 :
roisarray =[(roi, self.__rm.getSliceNumber(roi.getName())) for roi in self.__rm.getRoisAsArray()]
else :
roisarray =[(roi, 1) for roi in self.__rm.getRoisAsArray()]
self.__rm.runCommand("reset")
#self.__rm.runCommand("Delete")
IJ.selectWindow(self.__impF.getTitle())
self.__maxraf=float(self.__display19.text)
self.__minraf=float(self.__display20.text)
count=1
for roielement in roisarray :
roi = roielement[0]
pos = roielement[1]
lab = self.__impF.getImageStack().getShortSliceLabel(pos)
if lab==None : lab=str(pos)
if self.__conEllipses :
IJ.selectWindow(self.__impF.getTitle())
self.__impF.setSlice(pos)
self.__impF.setRoi(roi)
self.__rm.runCommand("Add")
IJ.run(self.__impF, "Fit Ellipse", "")
ellipse=self.__impF.getRoi()
params = ellipse.getParams()
ferets = ellipse.getFeretValues()
imp2 = Duplicator().run(self.__impF,pos,pos)
IJ.run(imp2, "Rotate... ", "angle="+str(ferets[1])+" grid=0 interpolation=Bilinear enlarge slice")
temproi=Roi((imp2.getWidth()-ferets[0])/2.0,(imp2.getHeight()-ferets[2])/2.0,ferets[0],ferets[2])
imp2.setRoi(temproi)
imp3 = Duplicator().run(imp2,1,1)
ip3=imp3.getProcessor()
if int(self.__display5.text) < ip3.getWidth() < int(self.__display6.text) :
self.__iplist.append(ip3)
self.__display.text = self.__name + " cell " + str(len(self.__iplist))
fer=Line(params[0],params[1],params[2],params[3])
self.__cellsrois.append((fer, pos))
self.__labels.append(self.__isF.getShortSliceLabel(pos))
m=Morph(self.__impF, roi)
twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(fer.getLength())+tab+str(1)+tab+str(0)+tab+str(0)+tab+str(0))
self.__dictCells[count]=(str(roi.getName()), lab, roi)
count=count+1
continue
if roi.getType() in [6,7] :
self.__impF.setSlice(pos)
self.__impF.setRoi(roi)
self.__rm.runCommand("Add")
elif roi.getType() in [2,4] :
self.__impF.setSlice(pos)
self.__impF.setRoi(roi)
m=Morph(self.__impF, roi)
m.setMidParams(10, 2)
midroi=m.MidAxis
if midroi == None : continue
raf = m.MaxFeret/midroi.getLength()
if (self.__maxraf < raf) or (raf < self.__minraf) : continue
maxsol = float(self.__display7.text)
minsol = float(self.__display8.text)
maxarea = float(self.__display9.text)
minarea = float(self.__display10.text)
maxcirc = float(self.__display11.text)
mincirc = float(self.__display12.text)
maxar = float(self.__display13.text)
minar = float(self.__display14.text)
maxfer = float(self.__display15.text)
minfer = float(self.__display16.text)
maxmean = float(self.__display17.text)
minmean = float(self.__display18.text)
maxmferet = float(self.__display21.text)
minmferet = float(self.__display22.text)
testsol = (minsol< m.Solidity < maxsol)
testarea = (minarea< m.Area < maxarea)
testcirc = (mincirc< m.Circ < maxcirc)
testar = (minar< m.AR < maxar)
testfer = (minfer< m.MaxFeret < maxfer)
testmean = (minmean < m.Mean < maxmean)
testmferet = (minmferet < m.MinFeret < maxmferet)
#print minmferet , m.MinFeret , maxmferet
test = (testsol+testarea+testcirc+testar+testfer+testmean+testmferet)/7
if test :
fmaj, ffmx, fa =[],[],[]
for r in m.getMidSegments(10, 40, 0) :
if r == None : continue
m2=Morph(self.__impF, r)
fmaj.append(m2.Major)
ffmx.append(m2.MaxFeret)
fa.append(m2.Area)
diffmajor, diffferet, diffarea = 0,0,0
if len(fa) > 4 :
medfmaj = self.listmean(fmaj[1:-1])
medffmx = self.listmean(ffmx[1:-1])
medfa = self.listmean(fa[1:-1])
diffmajor = (max(fmaj[1:-1])-medfmaj)/medfmaj
diffferet = (max(ffmx[1:-1])-medffmx)/medffmx
diffarea = (max(fa[1:-1])-medfa)/medfa
twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea))
#print lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea)
self.__impF.setRoi(roi)
self.__rm.runCommand("Add")
self.__impF.killRoi()
self.__impF.setRoi(midroi)
#self.__dictCells[str(roi.getName())]=(str(roi.getName()), lab, roi)
self.__dictCells[count]=(str(roi.getName()), lab, roi)
count=count+1
else :
#print "test falls"
continue
else :
print "out loop"
continue
straightener = Straightener()
new_ip = straightener.straighten(self.__impF, midroi, int(self.__widthl))
if int(self.__display5.text) < new_ip.getWidth() < int(self.__display6.text) :
self.__iplist.append(new_ip)
self.__display.text = self.__name + " cell " + str(len(self.__iplist))
#print "add", roi.getName(), roi.getType()
self.__cellsrois.append((midroi, pos))
self.__labels.append(self.__isF.getShortSliceLabel(pos))
#roisarray=self.__rm.getRoisAsArray()
#self.__rm.runCommand("reset")
#self.__rm.runCommand("Delete")
self.__impD.killRoi()
self.__impF.killRoi()
IJ.selectWindow(self.__impD.getTitle())
def channel_segmentation(infile, diameter, tolerance, repeat_max, Zrepeat=10):
# ROI optimization by Esnake optimisation
default_options = "stack_order=XYCZT color_mode=Grayscale view=Hyperstack"
IJ.run("Bio-Formats Importer", default_options + " open=[" + infile + "]")
imp = IJ.getImage()
cal = imp.getCalibration()
channels = [i for i in xrange(1, imp.getNChannels() + 1)]
log = filename(infile)
log = re.sub('.ids', '.csv', log)
XZdrift, YZdrift = retrieve_Zdrift(log)
XZpt = [i * imp.getWidth() / Zrepeat for i in xrange(1, Zrepeat - 1)]
YZpt = [i * imp.getHeight() / Zrepeat for i in xrange(1, Zrepeat - 1)]
# Prepare head output file
for ch in channels:
csv_name = 'ch' + str(ch) + log
with open(os.path.join(folder6, csv_name), 'wb') as outfile:
SegLog = csv.writer(outfile, delimiter=',')
SegLog.writerow(['spotID', 'Xpos', 'Ypos', 'Zpos',
'Quality', 'area', 'intensity', 'min', 'max', 'std'])
# Retrieve seeds from SpotDetector
options = IS.MEDIAN | IS.AREA | IS.MIN_MAX | IS.CENTROID
spots = retrieve_seeds(log)
for ch in channels:
for spot in spots:
repeat = 0
# Spots positions are given according to calibration, need to
# convert it to pixel coordinates
spotID = int(spot[0])
Xcenter = int(float(spot[2]) / cal.pixelWidth)
Ycenter = int(float(spot[3]) / cal.pixelHeight)
Zcenter = float(spot[4]) / cal.pixelDepth
Quality = float(spot[5])
# find closest grid location in Zdrift matrix
Xpt = min(range(len(XZpt)), key=lambda i: abs(XZpt[i] - Xcenter))
Ypt = min(range(len(YZpt)), key=lambda i: abs(YZpt[i] - Ycenter))
# Calculate Z position according to SpotZ, calibration and
# channel-specific Zdrift #
Zshift = median([float(XZdrift[Xpt][ch - 1]),
float(YZdrift[Ypt][ch - 1])]) / cal.pixelDepth
correctZ = int(Zcenter - Zshift)
imp.setPosition(ch, correctZ, 1)
imp.getProcessor().setMinAndMax(0, 3000)
while True:
manager = RoiManager.getInstance()
if manager is None:
manager = RoiManager()
roi = OvalRoi(Xcenter - diameter * (1.0 + repeat / 10.0) / 2.0, Ycenter - diameter * (
1.0 + repeat / 10.0) / 2.0, diameter * (1.0 + repeat / 10.0), diameter * (1.0 + repeat / 10.0))
imp.setRoi(roi)
IJ.run(imp, "E-Snake", "target_brightness=Bright control_points=3 gaussian_blur=0 energy_type=Mixture alpha=2.0E-5 max_iterations=20 immortal=false")
roi_snake = manager.getRoisAsArray()[0]
imp.setRoi(roi_snake)
stats = IS.getStatistics(
imp.getProcessor(), options, imp.getCalibration())
manager.reset()
if stats.area > 20.0 and stats.area < 150.0 and boundaries(Xcenter, Ycenter, stats.xCentroid / cal.pixelWidth, stats.yCentroid / cal.pixelHeight, tolerance):
Sarea = stats.area
Sintensity = stats.median
Smin = stats.min
Smax = stats.max
Sstd = stats.stdDev
break
elif repeat > repeat_max:
roi = OvalRoi(Xcenter - diameter / 2.0,
Ycenter - diameter / 2.0, diameter, diameter)
imp.setRoi(roi)
manager.add(imp, roi, i)
stats = IS.getStatistics(
imp.getProcessor(), options, imp.getCalibration())
Sarea = stats.area
Sintensity = stats.median
Smin = stats.min
Smax = stats.max
Sstd = stats.stdDev
break
else:
repeat += 1
# Save results
csv_name = 'ch' + str(ch) + log
with open(os.path.join(folder6, csv_name), 'ab') as outfile:
SegLog = csv.writer(outfile, delimiter=',')
SegLog.writerow([spotID, Xcenter, Ycenter, correctZ,
Quality, Sarea, Sintensity, Smin, Smax, Sstd])
# End spot optimization
# End spots
# End channels
IJ.selectWindow(filename(infile))
IJ.run("Close")
def main():
# Get active dataset
#img = IJ.getImage()
display = displayservice.getActiveDisplay()
active_dataset = imagedisplayservice.getActiveDataset(display)
if not active_dataset:
IJ.showMessage('No image opened.')
return
# Get image path
fname = active_dataset.getSource()
dir_path = os.path.dirname(fname)
if not fname:
IJ.showMessage('Source image needs to match a file on the system.')
return
# Open ROIs
rois = RoiManager.getInstance()
if not rois:
roi_path = os.path.join(dir_path, "RoiSet.zip")
if not os.path.isfile(roi_path):
try:
roi_path = glob.glob(os.path.join(dir_path, "*.roi"))[0]
except:
roi_path = None
if not roi_path:
IJ.showMessage('No ROIs. Please use Analyze > Tools > ROI Manager...')
return
rois = RoiManager(True)
rois.reset()
rois.runCommand("Open", roi_path)
IJ.log('Image filename is %s' % fname)
dt = get_dt(active_dataset)
rois_array = rois.getRoisAsArray()
for i, roi in enumerate(rois_array):
crop_id = i + 1
IJ.log("Croping %i / %i" % (crop_id, len(rois_array)))
# Get filename and basename of the current cropped image
crop_basename = "crop%i_%s" % (crop_id, active_dataset.getName())
crop_basename = os.path.splitext(crop_basename)[0] + ".ome.tif"
crop_fname = os.path.join(os.path.dirname(fname), crop_basename)
# Get bounds and crop
bounds = roi.getBounds()
dataset = crop(ij, datasetservice, active_dataset,
bounds.x, bounds.y, bounds.width,
bounds.height, crop_basename)
# Show cropped image
ij.ui().show(dataset.getName(), dataset)
# Save cropped image (ugly hack)
IJ.log("Saving crop to %s" % crop_fname)
imp = IJ.getImage()
bfExporter = LociExporter()
macroOpts = "save=[" + crop_fname + "]"
bfExporter.setup(None, imp)
Macro.setOptions(macroOpts)
bfExporter.run(None)
imp.close()
IJ.log('Done')
def showSettingsDialog(self):
if self.__image.getOverlay() is not None : self.__image.getOverlay().clear()
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
#rm.runCommand("Deselect")
#for i in range(rm.getCount()) :
# rm.select(i)
# rm.runCommand("Set Color", "0000FF", 2)
IJ.resetThreshold(self.__image)
rm.runCommand("Show All")
self.__ranges.clear()
#areas, means, majors, minors=[],[],[],[]
#for roi in self.__roisArray:
# m=Morph(self.__image, roi)
# areas.append(m.Area)
# means.append(m.Mean)
# majors.append(m.Major)
# minors.append(m.Minor)
#maxarea=max(areas)*1000
#maxint=max(means)*10
#maxline=max(majors)*100
#maxminline=max(minors)*100
#minline=min(minors)
#namemeasures=["Area", "Mean", "Angle", "Major", "Minor", "Solidity", "AR", "Round", "Circ"]
#maxmeasures=[maxarea, maxint, 180*10, maxline, maxminline, 1*1000, (maxline/minline), 1*1000, 1*1000]
#set1000=Set(["Solidity", "Round", "Circ"])
#set10=Set(["Angle"])
def buttonPressed(event):
temprois=self.getIncludeRois()
for roi in temprois:
m=Morph(self.__image, roi)
IJ.log("----------------------------------")
IJ.log(roi.getName())
for r in self.__ranges.values():
IJ.log(r[0]+" min= "+str(r[1])+" < val="+str(m.__getattribute__(r[0]))+" < max= "+str(r[2]))
IJ.run(self.__image, "Remove Overlay", "")
o=Overlay()
for roi in temprois:
o.addElement(roi)
self.__image.killRoi()
self.__image.setOverlay(o)
self.__image.updateAndDraw()
def updatepressed(event):
self.__image=IJ.getImage()
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
self.__image.killRoi()
IJ.run("Threshold...")
IJ.setAutoThreshold(self.__image, "MaxEntropy")
rt=ResultsTable()
pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00)
pa.analyze(self.__image)
self.__roisArray=[]
self.__roisArray=rm.getRoisAsArray()
#for i in range(rm.getCount()) :
# rm.select(i)
# rm.runCommand("Set Color", "0000FF", 2)
IJ.resetThreshold(self.__image)
rt.show("tempRT")
areas=rt.getColumn(ResultsTable.AREA)
means=rt.getColumn(ResultsTable.MEAN)
majors=rt.getColumn(ResultsTable.MAJOR)
minors=rt.getColumn(ResultsTable.MINOR)
#print 0
if self.__slidersDict["Area_max"].getMaximum() < int(max(areas)+1):
# print 1
self.__slidersDict["Area_max"].setMaximum(int(max(areas))+1)
if self.__slidersDict["Area_min"].getMaximum() < int(max(areas)+1):
# print 2
self.__slidersDict["Area_min"].setMaximum(int(max(areas))+1)
if self.__slidersDict["Mean_max"].getMaximum() < int(max(means)+1):
# print 3
self.__slidersDict["Mean_max"].setMaximum(int(max(means))+1)
if self.__slidersDict["Mean_min"].getMaximum() < int(max(means)+1):
# print 4
self.__slidersDict["Mean_min"].setMaximum(int(max(means))+1)
if self.__slidersDict["Major_max"].getMaximum() < int(max(majors)):
# print 5
self.__slidersDict["Major_max"].setMaximum(int(max(majors))+1)
if self.__slidersDict["Major_min"].getMaximum() < int(max(majors)+1):
# print 6
self.__slidersDict["Major_min"].setMaximum(int(max(majors))+1)
if self.__slidersDict["Minor_max"].getMaximum() < int(max(minors)+1):
# print 7
self.__slidersDict["Minor_max"].setMaximum(int(max(minors))+1)
if self.__slidersDict["Minor_min"].getMaximum() < int(max(minors)+1):
# print 8
self.__slidersDict["Minor_min"].setMaximum(int(max(minors))+1)
if self.__slidersDict["AR_max"].getMaximum() < int((max(majors)+1)/min(minors)+1):
# print 9
self.__slidersDict["AR_max"].setMaximum(int((max(majors)+1)/(min(minors))))
if self.__slidersDict["AR_min"].getMaximum() < int((max(majors)+1)/min(minors)):
# print 10
self.__slidersDict["AR_min"].setMaximum(int((max(majors)+1)/(min(minors))))
#print 11
for sb in self.__slidersDict.values():
sb.repaint()
#rm.runCommand("reset")
#temprois=self.getIncludeRois()
#IJ.run(self.__image, "Remove Overlay", "")
#o=Overlay()
#for roi in temprois:
# o.addElement(roi)
#self.__image.killRoi()
#self.__image.setOverlay(o)
self.__image.updateAndDraw()
def resetpressed(event):
self.__ranges.clear()
self.__image=IJ.getImage()
rm = RoiManager.getInstance()
if (rm==None): rm = RoiManager()
rm.runCommand("reset")
self.__image.killRoi()
IJ.setAutoThreshold(self.__image, "MaxEntropy")
rt=ResultsTable()
pa=ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER+ParticleAnalyzer.CLEAR_WORKSHEET , Measurements.AREA+Measurements.ELLIPSE+Measurements.MEAN, rt, 0.00, 10000.00, 0.00, 1.00)
pa.analyze(self.__image)
self.__roisArray=[]
self.__roisArray=rm.getRoisAsArray()
#rm.runCommand("Show All")
#rm.runCommand("Select All")
#rm.runCommand("Set Color", "blue")
IJ.resetThreshold(self.__image)
keys=self.__slidersDict.keys()
for k in keys:
if k.endswith("min"):
self.__slidersDict[k].setValue(0)
self.__slidersDict[k].repaint()
else:
self.__slidersDict[k].setValue(self.__slidersDict[k].getMaximum())
self.__slidersDict[k].repaint()
def valueChanged(event):
name=event.getSource().getName()
names=name.split("_")
factor=1
if names[0] in self.__set1000: factor=0.001
if names[0] in self.__set10:factor=0.1
value=event.getSource().getValue()*factor
if names[1]=="min":
self.__ranges[names[0]]=(names[0], value, self.__slidersDict[names[0]+"_max"].getValue()*factor, self.__boxesDict[names[0]].getState())
#self.__ranges[names[0]]=(names[0], value, self.__slidersDict[names[0]+"_max"].getValue()*factor)
else: self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, value, self.__boxesDict[names[0]].getState())
#self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, value)
temprois=self.getIncludeRois()
IJ.run(self.__image, "Remove Overlay", "")
o=Overlay()
for roi in temprois:
o.addElement(roi)
self.__image.killRoi()
self.__image.setOverlay(o)
self.__image.updateAndDraw()
def selectAll(event):
name=event.getSource().getLabel()
names=name.split("_")
factor=1
if names[0] in self.__set1000: factor=0.001
if names[0] in self.__set10:factor=0.1
name=event.getSource().getLabel()
names=name.split("_")
value=event.getSource().getState()
self.__ranges[names[0]]=(names[0], self.__slidersDict[names[0]+"_min"].getValue()*factor, self.__slidersDict[names[0]+"_max"].getValue()*factor, value)
gd0=NonBlockingGenericDialog("settings")
gd0.setResizable(True)
gd0.setFont(Font("Courrier", 1, 8))
count=0
self.__slidersDict={}
self.__boxesDict={}
self.__boxesDict.clear()
self.__slidersDict.clear()
for i in range(len(self.__namemeasures)):
gd0.setInsets(-10,0,0)
gd0.addSlider("Min"+self.__namemeasures[i], 0, self.__maxmeasures[i], 0)
gd0.getSliders().get(count).adjustmentValueChanged = valueChanged
gd0.getSliders().get(count).setName(self.__namemeasures[i]+"_min")
self.__slidersDict[self.__namemeasures[i]+"_min"]=gd0.getSliders().get(count)
gd0.addSlider("Max"+self.__namemeasures[i], 0, self.__maxmeasures[i], self.__maxmeasures[i])
gd0.getSliders().get(count+1).adjustmentValueChanged = valueChanged
gd0.getSliders().get(count+1).setName(self.__namemeasures[i]+"_max")
self.__slidersDict[self.__namemeasures[i]+"_max"]=gd0.getSliders().get(count+1)
gd0.addCheckbox("all", True)
gd0.getCheckboxes().get(i).itemStateChanged = selectAll
gd0.getCheckboxes().get(i).setLabel(self.__namemeasures[i]+"_all")
self.__boxesDict[self.__namemeasures[i]]=gd0.getCheckboxes().get(i)
gd0.setInsets(-10,0,0)
#gd0.addMessage("...........................................................................")
count=count+2
panel0=Panel()
#trybutton=Button("Try")
#trybutton.setActionCommand("DrawOverlay")
#trybutton.actionPerformed = buttonPressed
#updatebutton=Button("Update")
#updatebutton.setActionCommand("Update")
#updatebutton.actionPerformed = updatepressed
#resetbutton=Button("Reset")
#resetbutton.setActionCommand("Reset")
#resetbutton.actionPerformed = resetpressed
#panel0.add(trybutton)
#panel0.add(updatebutton)
#panel0.add(resetbutton)
#gd0.addPanel(panel0)
gd0.setResizable(True)
gd0.showDialog()
#self.__image.setSlice(self.__firstslice)
#self.__image.updateAndDraw()
if gd0.wasOKed():
#for key in self.__ranges.keys(): IJ.log("Measure : "+str(self.__ranges[key][0])+" min = "+str(self.__ranges[key][1])+" max = "+str(self.__ranges[key][2]))
return self.__ranges
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
