def openTW(self, openPath_tsv):
txtfile = open(openPath_tsv)
heads = txtfile.readlines(1)[0].split("\t")
tw = TextWindow("Results", heads[0]+"\t"+heads[2]+"\t Anaphase", "", 50, 500)
#tw.setLocation(20+, 5)
for line in txtfile.readlines(): # load file lines in textPanel.
frame, timeA, dist, volChI, volChII = line.split("\t")
tw.append(frame + "\t" + dist + "\t" )
return tw
def makeTw( FrameA, DistA, volFcA, volScA): #xFcA, yFcA, zFcA, xScA, yScA, zScA
tw = TextWindow("Summary", "Frame \t Time \t Distance \t volChI \t volChII", "", 400, 700) #xFcA, yFcA, zFcA, xScA, yScA, zScA
pxWidth = cal.pixelWidth
timeInterval = round(cal.frameInterval) # test!!
for row in range(len(FrameA)):
try:
product = cal.pixelWidth * float(DistA[row]) # distance in microns
DistMy = "%.5f" % product # round
except ValueError: # if is "NA"
DistMy = "NA"
time = "%.1f" % (timeInterval * float(FrameA[row]))
tw.append(str(int(FrameA[row])+1)+"\t"+time+"\t"+DistMy+"\t"+volFcA[row]+"\t"+volScA[row])
timePoint("test-tp")
return tw
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()
keyEvent.consume()
class ListenToKey(KeyAdapter):
def keyPressed(this, event):
eventSrc = event.getSource()
tp = eventSrc.getParent(
) #panel is the parent, canvas being component.
print eventSrc
print tp
print "selected line:", tp.getSelectionEnd()
print "...", tp.getLine(tp.getSelectionEnd())
#imp = event.getSource()
doSomething(imp, event)
# - - - M A I N - - -
listener = ListenToKey()
txtfile = open(path)
tw = TextWindow("Results_" + filename, txtfile.readlines(1)[0], "", 300, 700)
for line in txtfile.readlines():
frame, dist, volChI, volChII = line.split("\t")
tw.append(
str(frame) + "\t" + str(dist) + "\t" + str(volChI) + "\t" +
str(volChII))
tw.getTextPanel().addKeyListener(listener)
def __fmeasures(self) :
self.__Cutoff = float(self.__display4.text)
nslices = self.__impRes.getImageStackSize()
rt = ResultsTable()
rt.show("RT-"+self.__name)
if self.__maxfinder : twpoints = TextWindow("points-"+self.__name, "index\tlabel\tname\tx\ty\taxis\tcellw\tcellh", "", 200, 450)
twlabels = TextWindow("labels-"+self.__name, "index\tlabel\tname\tnpoints", "", 200, 450)
isres = self.__impRes.getImageStack()
for index in range(1, nslices+1):
pc = (index*100)/nslices
IJ.showStatus("Je suis a "+str(pc)+"%")
self.__impRes.setSlice(index)
self.__impRes.killRoi()
roi = self.__listrois[index-1]
self.__impRes.setRoi(roi)
analyser= Analyzer(self.__impRes, Analyzer.LABELS+Analyzer.CENTER_OF_MASS+Analyzer.CENTROID+Analyzer.INTEGRATED_DENSITY+Analyzer.MEAN+Analyzer.KURTOSIS+Analyzer.SKEWNESS+Analyzer.MIN_MAX+Analyzer.SLICE+Analyzer.STACK_POSITION+Analyzer.STD_DEV, rt)
analyser.measure()
rt.show("RT-"+self.__name)
rect=roi.getBounds()
ip = self.__impRes.getProcessor()
xCoord = []
yCoord = []
currentPixel = []
m00 = 0.00
m10 = 0.00
m01 = 0.00
mc20 = 0.00
mc02 = 0.00
mc11 = 0.00
mc30 = 0.00
mc03 = 0.00
mc21 = 0.00
mc12 = 0.00
mc40 = 0.00
mc04 = 0.00
mc31 = 0.00
mc13 = 0.00
mm20 = 0.00
mm02 = 0.00
mm11 = 0.00
mm30 = 0.00
mm03 = 0.00
mm21 = 0.00
mm12 = 0.00
mm40 = 0.00
mm04 = 0.00
mm31 = 0.00
mm13 = 0.00
#for y in range(rect.y, rect.y+rect.height, 1) :
# for x in range(rect.x, rect.x+rect.width, 1) :
# xCoord.append(x+0.5)
# yCoord.append(y+0.5)
# #pixel=ip.getf(x,y)-self.__Cutoff
# pixel = ip.getPixelValue(x,y)-self.__Cutoff
# if pixel < 0 : pixel = 0
# currentPixel.append(pixel)
# m00 += currentPixel[-1]
# m10 += currentPixel[-1]*xCoord[-1]
# m01 += currentPixel[-1]*yCoord[-1]
#xm = m10/(m00+0.00000001)
#ym = m01/(m00+0.00000001)
#xc = rect.width/2.00
#yc = rect.height/2.00
#for i in range(rect.width*rect.height) :
# xcrel = xCoord[i]-xc
# ycrel = yCoord[i]-yc
# #mc20 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)
# #mc02 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc)
# #mc11 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc)
# #
# #mc30 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)
# #mc03 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc)
# #mc21 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(yCoord[i]-yc)
# #mc12 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc)*(yCoord[i]-yc)
# #
# #mc40 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)
# #mc04 += currentPixel[i]*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc)
# #mc31 += currentPixel[i]*(xCoord[i]-xc)*(xCoord[i]-xc)*(xCoord[i]-xc)*(yCoord[i]-yc)
# #mc13 += currentPixel[i]*(xCoord[i]-xc)*(yCoord[i]-yc)*(yCoord[i]-yc)*(yCoord[i]-yc)
# mc20 += currentPixel[i]*xcrel*xcrel
# mc02 += currentPixel[i]*ycrel*ycrel
# mc11 += currentPixel[i]*xcrel*ycrel
# mc30 += currentPixel[i]*xcrel*xcrel*xcrel
# mc03 += currentPixel[i]*ycrel*ycrel*ycrel
# mc21 += currentPixel[i]*xcrel*xcrel*ycrel
# mc12 += currentPixel[i]*xcrel*ycrel*ycrel
# mc40 += currentPixel[i]*xcrel*xcrel*xcrel*xcrel
# mc04 += currentPixel[i]*ycrel*ycrel*ycrel*ycrel
# mc31 += currentPixel[i]*xcrel*xcrel*xcrel*ycrel
# mc13 += currentPixel[i]*xcrel*ycrel*ycrel*ycrel
#for i in range(rect.width*rect.height) :
# mm20 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)
# mm02 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym)
# mm11 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym)
# mm30 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)
# mm03 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym)
# mm21 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(yCoord[i]-ym)
# mm12 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym)*(yCoord[i]-ym)
# mm40 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)
# mm04 += currentPixel[i]*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym)
# mm31 += currentPixel[i]*(xCoord[i]-xm)*(xCoord[i]-xm)*(xCoord[i]-xm)*(yCoord[i]-ym)
# mm13 += currentPixel[i]*(xCoord[i]-xm)*(yCoord[i]-ym)*(yCoord[i]-ym)*(yCoord[i]-ym)
#xxcVar = mc20/m00
#yycVar = mc02/m00
#xycVar = mc11/m00
#xcSkew = mc30/(m00 * math.pow(xxcVar,(3.0/2.0)))
#ycSkew = mc03/(m00 * math.pow(yycVar,(3.0/2.0)))
#xcKurt = mc40 / (m00 * math.pow(xxcVar,2.0)) - 3.0
#ycKurt = mc04 / (m00 * math.pow(yycVar,2.0)) - 3.0
#ecc = (math.pow((mc20-mc02),2.0)+(4.0*mc11*mc11))/m00
#xxmVar = mm20/m00
#yymVar = mm02/m00
#xymVar = mm11/m00
#xmSkew = mm30/(m00 * math.pow(xxmVar,(3.0/2.0)))
#ymSkew = mm03/(m00 * math.pow(yymVar,(3.0/2.0)))
#xmKurt = mm40 / (m00 * math.pow(xxmVar,2.0)) - 3.0
#ymKurt = mm04 / (m00 * math.pow(yymVar,2.0)) - 3.0
#ecm = (math.pow((mm20-mm02),2.0)+(4.0*mm11*mm11))/m00
#rt.addValue("xxcVar", xxcVar)
#rt.addValue("yycVar", yycVar)
#rt.addValue("xycVar", xycVar)
#rt.addValue("xcSkew", xcSkew)
#rt.addValue("ycSkew", ycSkew)
#rt.addValue("xcKurt", xcKurt)
#rt.addValue("ycKurt", ycKurt)
#rt.addValue("Ecc", ecc)
#rt.addValue("xxmVar", xxmVar)
#rt.addValue("yymVar", yymVar)
#rt.addValue("xymVar", xymVar)
#rt.addValue("xmSkew", xmSkew)
#rt.addValue("ymSkew", ymSkew)
#rt.addValue("xmKurt", xmKurt)
#rt.addValue("ymKurt", ymKurt)
#rt.addValue("Ecm", ecm)
rt.addValue("roiw", rect.width)
rt.addValue("roih", rect.height)
rt.addValue("cellw", self.__ipw[index-1])
rt.addValue("cellh", self.__iph[index-1])
self.__impRes.killRoi()
xCoord[:] = []
yCoord[:] = []
currentPixel[:] = []
points = []
points[:] = []
npointsmax = 0
#lab = self.__labels[index-1]
nameroi = self.__dictCells[index][0]
lab = self.__dictCells[index][1]
if self.__maxfinder :
self.__impMax.setSlice(index)
ipmax = self.__impMax.getProcessor()
for y in range(ipmax.getHeight()) :
for x in range(ipmax.getWidth()) :
if ipmax.getPixelValue(x,y) > 0 :
twpoints.append(str(index)+"\t"+lab+"\t"+nameroi+"\t"+str(x)+"\t"+str(y)+"\t"+str(self.__cellsrois[index-1][0].getLength())+"\t"+str(self.__ipw[index-1])+"\t"+str(self.__iph[index-1]))
npointsmax+=1
rt.addValue("npoints", npointsmax)
twlabels.append(str(index)+"\t"+lab+"\t"+nameroi+"\t"+str(npointsmax))
rt.show("RT-"+self.__name)
rt.show("RT-"+self.__name)
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)[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.convertToShort(False))
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())
