# Means per frame and then mean of mean
listmeans = ImagesMean(dataset, z)
stackmeans = computeMean(listmeans)
filemeans.append(stackmeans)
# Stds per frame.
liststds = ImagesStd(dataset,listmeans, z)
grouped = group_stds(liststds)
#std the std.
filestds.append(grouped)
return filemeans, filestds
# MAIN CODE
srcDir = DirectoryChooser("Choose").getDirectory()
filelist = get_file_list(srcDir, '.tif')
means, stds = main(filelist)
# PLOTTING
plot = Plot("PTC", "Mean", "Std")
plot.setLimits(0.00, 200.0, 0.00, 100.0)
plot.setColor(Color.BLUE)
plot.addPoints(means, stds, Plot.CROSS)
plot.show()
print means, stds
mx1 = []
mx2 = []
my1 = []
my2 = []
for i in range(0, len(x1)):
mx1.append(x1[i] - dx[i] / 2)
my1.append(y1[i] - dy[i] / 2)
mx2.append(x2[i] - dx[i] / 2)
my2.append(y2[i] - dy[i] / 2)
#plt = Plot(fName, "degrees","degrees")
#plt.setLimits(-10,10, -10, 10)
##plt.setAxes(False,False,True, True,False, False, 1, 10);
#plt.setFrameSize(500,500);
#plt.draw()
#plt.addPoints(cx,cy,Plot.CIRCLE);
#plt.drawVectors(x1,y1,x2,y2)
#plt.show()
plt2 = Plot(fName, "degrees", "degrees")
plt2.setLimits(-10, 10, -10, 10)
plt2.setAxes(False, False, True, True, False, False, 1, 10)
plt2.setFrameSize(500, 500)
plt2.draw()
plt2.addPoints(cx, cy, Plot.CIRCLE)
plt2.drawVectors(mx1, my1, mx2, my2)
plt2.setColor(java.awt.Color.RED)
plt2.setLineWidth(2)
plt2.addPoints(x1, y1, Plot.CIRCLE)
plt2.show()
from ij.gui import Plot
from java.awt import Color
import jarray
import os
# start clean
IJ.run("Close All")
# create example data arrays
xa = [1, 2, 3, 4]
ya = [3, 3.5, 4, 4.5]
# convert to java array
jxa = jarray.array(xa, 'd')
jya = jarray.array(ya, 'd')
# Create filled plot
plt = Plot("Line plot", "X", "Y")
plt.setLimits(0, 5, 0, 5)
plt.setFrameSize(600, 300)
plt.setColor("blue", "#ccccff")
# the circles are small. Can't figure out how to make
# them larger... These 2 calls are equivalent...
# plt.addPoints(jxa,jya, Plot.CIRCLE)
plt.add("circles", jxa, jya)
plt.setColor(Color.RED)
plt.setLineWidth(1)
plt.drawLine(0.0, 2.5, 4.0, 4.5)
plt.setXYLabels("X", "Y")
plt.show()
else:
sliceAvgInt[currentSlice - 1] = 0
sliceAboveZeroNorm[currentSlice - 1] = 0
sliceExpectedRadNorm[currentSlice - 1] = 0
print("writing to file...")
# Find
thisStr = IJ.getDirectory("image")
upStr = thisStr[:thisStr.find("merged_videos/")]
rezPath = upStr + "blink_files/result_new.txt"
myfile = open(rezPath, 'w')
for i in range(len(slicesIdx)):
myfile.write(
str(slicesIdx[i]) + " " + str(sliceAvgInt[i]) + " " +
str(sliceAboveZeroNorm[i]) + " " + str(sliceExpectedRadNorm[i]) + "\n")
myfile.close()
print("plotting...")
plot = Plot("Title", "X", "Y")
plot.setLimits(1.0, img2.getNSlices(), 0.0, 1.0)
plot.setColor(Color.RED)
plot.addPoints(slicesIdx, sliceAvgInt, Plot.CROSS)
plot.setColor(Color.BLUE)
plot.addPoints(slicesIdx, sliceAboveZeroNorm, Plot.CROSS)
plot.setColor(Color.GREEN)
plot.addPoints(slicesIdx, sliceExpectedRadNorm, Plot.CROSS)
plot.show()
row=[ str(p[i]) for p in profiles ]
row=",".join(row)
f.write(row+"\n")
# Generate a plot
if doPlot:
from ij.gui import Plot
from java.awt import Color
p = Plot('Profiles','Channel #','Intensity')
p.setSize(640,480)
maxP = len(profiles)
maxV = 0
for iprofile,profile in enumerate(profiles):
h = 0.66-(float(iprofile)/maxP)
if h<0:
h=h+1
p.setColor(Color.getHSBColor( h,.8,1))
p.addPoints(range(len(profile)),profile,p.LINE)
maxV_=max(profile)
if maxV < maxV_:
maxV = maxV_
p.setLimits(0,len(profile)-1,0,maxV*1.2)
p.setLegend("\n".join(names),p.TOP_LEFT|p.LEGEND_TRANSPARENT)
p.show()
# Save the plot as PNG
if doSavePlot:
imp = p.getImagePlus()
IJ.saveAs(imp,'PNG',file.absolutePath + "_compensationPlot.png")
if (amplificacion > MaxAmplificacion) :
MaxAmplificacion=amplificacion
ROptima=LogFilterSigma
if amplificacion <=ValuePrev :
RepCounter+=1
else:
RepCounter=0
ValuePrev=amplificacion
#Break if the value decreases for 3 consecutive values
if(RepCounter==3):
break
return MaxAmplificacion,ROptima
#Main Method
image = IJ.getImage()
Moment3=CheckMoment(image)
Mom3Norm=[i/Moment3[0]-1.0 for i in Moment3]
NFrames= image.getNFrames()
xArr = array(range(1,NFrames+1), 'd')
plot = Plot("Title", "Time", "Delta m ",xArr,Mom3Norm)
plot.setLimits(1, NFrames, min(Mom3Norm), max(Mom3Norm))
plot.setColor(Color.BLUE)
plot.addPoints(xArr,Mom3Norm,Plot.CROSS)
plot.show()
def plots(values, timelist, Cell_number, value_type, Stim_List, dirs, parameters):
""" Plots all calculated values, saves plots to generated directory, returns plot scale. """
Mean_plot = 0
# Flatten nested lists (normalized lists are not nested).
if value_type == "Normalized aFRET mean":
values_concat = [ values[i:i+Cell_number] for i in range(0, (len(values)), Cell_number) ]
Mean_sd = [ standard_deviation(values_concat[i]) for i in range(len(values_concat)) ]
Mean_sd = [item for sublist in Mean_sd for item in sublist]
Mean_plot = 1
elif value_type == "Normalized dFRET mean":
values_concat = [ values[i:i+Cell_number] for i in range(0, (len(values)), Cell_number) ]
Mean_sd = [ standard_deviation(values_concat[i]) for i in range(len(values_concat)) ]
Mean_sd = [item for sublist in Mean_sd for item in sublist]
Mean_plot = 1
else:
if "Normalized" not in value_type:
values = [item for sublist in values for item in sublist]
#Repeats list items x cell_number (match timepoints with # of cells).
timelist = [x for item in timelist for x in repeat(item, Cell_number)]
# Scaling of plots.
max_Y = 1
if max(values) > 3:
if not isinstance(values[0], list):
max_Y = max(values)*1.3
elif max(values) > 2.5:
max_Y = 3.3
elif max(values) > 2:
max_Y = 2.7
elif max(values) > 1.5:
max_Y = 2.2
elif max(values) > 1.3:
max_Y = 1.7
elif max(values) > 1:
max_Y = 1.4
min_Y = 0
if min(values) > 2:
min_Y = min(values)*0.8
elif min(values) > 1.5:
min_Y = 1.5
elif min(values) > 1:
min_Y = 1
elif min(values) > 0.5:
min_Y = 0.2
elif min(values) < -0.5:
min_Y = min(values)*1.3
elif min(values) < -0.2:
min_Y = -0.3
elif min(values) < -0.1:
min_Y = -0.15
elif min(values) < -0.08:
min_Y = -0.1
elif min(values) < -0.05:
min_Y = -0.08
elif min(values) < -0.01:
min_Y = -0.06
# Scaling of normalized plots..
if "Normalized" in value_type:
min_Y, max_Y = float(parameters["p_min_n"]), float(parameters["p_max_n"])
if value_type == "dFRET":
max_Y = float(parameters["p_max"])
min_y = float(parameters["p_min"])
elif value_type =="aFRET":
max_Y = float(parameters["p_max"])
min_y = float(parameters["p_min"])
# Call plot, set scale.
plot = Plot(Title, "Time (minutes)", value_type)
if len(timelist) > 1:
plot.setLimits(min(timelist), max(timelist), min_Y, max_Y)
else:
plot.setLimits(-1, 1, min_Y, max_Y)
# Retrieve colors.
Colors, Colors_old = colorlist()
# Set colors, plot points.
if Mean_plot == 0:
for i in range(Cell_number):
if i < 19:
plot.setColor(Color(*Colors[i][0:3]))
elif i >= 19:
plot.setColor(eval(Colors_old[i]))
print "Out of fancy colors, using java.awt.color defaults"
elif i > 28:
print "29 color limit exceeded"
return
plot.setLineWidth(1.5)
plot.addPoints(timelist[i :: Cell_number], values[i :: Cell_number], Plot.LINE)
plot.setLineWidth(1)
# Comment in to define color + fillcolor for circles.
plot.setColor(Color(*Colors[i][0:3]), Color(*Colors[i][0:3]))
#plot.addPoints(timelist[i :: Cell_number], values[i :: Cell_number], Plot.CIRCLE)
else:
min_Y, max_Y = 0.6, 1.6
if len(timelist) > 1:
plot.setLimits(min(timelist), max(timelist), min_Y, max_Y)
else:
plot.setLimits(-1, 1, min_Y, max_Y)
plot.setColor("Color.BLACK")
plot.setLineWidth(1.5)
plot.addPoints(timelist[0 :: Cell_number], Mean_sd[0::2], Plot.LINE)
plot.setLineWidth(1)
plot.setColor("Color.BLACK", "Color.BLACK")
plot.addPoints(timelist[0 :: Cell_number], Mean_sd[0::2], Plot.CIRCLE)
plot.setColor(Color(*Colors[6][0:3]))
plot.addErrorBars(Mean_sd[1::2])
# Get's stim name from input.
if not Stim_List == False:
text = [ sublist[i] for sublist in Stim_List for i in range(len(Stim_List)) ]
Stim_List = [ sublist[1:] for sublist in Stim_List ]
# Plot stimulation markers.
plot.setLineWidth(2)
for sublist in Stim_List:
plot.setColor("Color.GRAY")
plot.drawLine(sublist[0], min_Y+((max_Y-min_Y) * 0.82), sublist[1], min_Y+((max_Y-min_Y) * 0.82))
plot.drawDottedLine(sublist[0], min_Y+((max_Y-min_Y) * 0.82), sublist[0], -1, 4)
plot.drawDottedLine(sublist[1], min_Y+((max_Y-min_Y) * 0.82), sublist[1], -1, 4)
plot.setFont(Font.BOLD, 16)
plot.addText(text[0], sublist[0], min_Y+((max_Y-min_Y) * 0.82))
cell_num = 0
if "concentration" not in value_type:
testfile = open(os.path.join(dirs["Tables"], value_type + ".txt"), "w")
data = plot.getResultsTable()
headings = data.getHeadings()
datadict = {}
for heading in headings:
index = data.getColumnIndex(heading)
if "Y" in heading:
column = { "Cell "+str(cell_num).zfill(2) : [round(float(i), 4) for i in data.getColumn(index)] }
elif "X" in heading:
column = {"X" : [round(float(i), 4) for i in data.getColumn(index)] }
cell_num += 1
datadict.update(column)
sorted_data = []
for row in zip(*([key] + value for key, value in sorted(datadict.items()))):
sorted_data.append(row)
testfile.write("\t\t".join(sorted_data[0]))
# Prints output in columns, copy paste directly to sigma/prisma/excel etc.
for cell in range (1, len(sorted_data), 1):
testfile.write("\n")
for times in range(len(sorted_data[cell])):
testfile.write(str(sorted_data[cell][times]) + "\t\t")
# Dumps sorted data to JSON format, for use in eg. matplotlib.
with open(os.path.join(dirs["Tables"], value_type + ".json"), "w") as outfile:
datadict["Stim"] = Stim_List
json.dump(datadict, outfile, sort_keys=True)
testfile.close()
# Generate High-res plot with anti-aliasing (Scale x 1).
plot = plot.makeHighResolution(Title, 1, True, True)
#PlotWindow.noGridLines = True
# Save plot with appropriate title.
IJ.saveAs(plot, "PNG", os.path.join(dirs["Plots"], str(Title)+str(value_type)))
# (For ratiometric image-generator)
return max_Y, min_Y
def process(dirIn, es, ee):
roi_w = 30
roi_h = 30
iStart = 6-1
#srcDir = DirectoryChooser("Choose directory").getDirectory()
srcDir=dirIn
if not srcDir:
return
destDir = srcDir+"--analysis"
print "creating: "+destDir
# destDir = srcDir
if os.path.exists(destDir):
shutil.rmtree(destDir)
time.sleep(1)
os.mkdir(destDir)
# fileId = IJ.getString("filenames MUST contain:", "FRAP.lsm");
fileId = "FRAP.lsm"
iFile = 0
sOut = []
print "starting analysis in folder: "+srcDir
for root, directories, filenames in os.walk(srcDir):
print "sadsdfs"
print directories
for filename in filenames:
print filename
if not (fileId in filename):
continue
iFile = iFile + 1
if iFile < es:
continue
if iFile > ee:
f.close()
return()
# extract information from file and foldernames
print "root = %s" % root
(tmp,folder2) = splitLastFolder(root)
tmp = folder2.split("--")[4]
replicate = folder2
print replicate
wells = tmp.split("-")
print wells
tmp = filename.split("--")[1]
tmp = tmp.split("W")[1]
wellNum = int(tmp)
print wellNum
well = wells[wellNum-1]
print well
tmp = filename.split("--")[0:4]
tmp = '--'.join(tmp)
filenameDocu = tmp+".lsm--docu.png"
filenameLSM = tmp+".lsm"
pathFRAP = os.path.join(root,filename)
pathDocu = os.path.join(root,filenameDocu)
pathLSM = os.path.join(root,filenameLSM)
pathFRAPandSEG = os.path.join(destDir,filename+"--raw+seg.tif")
print pathFRAP
print pathFRAPandSEG
print pathDocu
print pathLSM
f = open(os.path.join(destDir, filename+"--metadata.csv"), 'w')
f.write("well,replicate,pathFRAP,pathFRAPandSEG,pathDocu,pathLSM\n")
f.write(well+","+replicate+","+pathFRAP+","+pathFRAPandSEG+","+pathDocu+","+pathLSM+"\n")
f.close()
#IJ.run("Close all forced", "")
# load data (possible headless)
path = os.path.join(root, filename)
#imp = IJ.openImage(path)
impA = getImps(path)
imp = impA[0]
imp.show()
#IJ.run("Bio-Formats Importer","open="+path+" color_mode=Default split_channels view=Hyperstack stack_order=XYCZT")
# remove transmisson channel
IJ.run("Slice Remover", "first=2 last=100000 increment=2");
imp = IJ.getImage()
#imp.show()
imp.setTitle("raw")
IJ.run("Properties...", "unit=pixels pixel_width=1 pixel_height=1");
dt = imp.getFileInfo().frameInterval
print "dt = %f" % dt
if dt==0:
dt=0.28
print "dt = %f" % dt
# todo: can i get the real time-stamps?
im_w = imp.getWidth()
im_h = imp.getHeight()
print "im_w ="+str(im_w)
print "im_h ="+str(im_h)
nt = max(imp.getNSlices(),imp.getNFrames())
print "nt = %f" % nt
roi_x = im_w/2 - roi_w/2
roi_y = im_h/2 - roi_h/2
roi_x2 = roi_x + roi_w
roi_y2 = roi_y + roi_h
# preprocessing
IJ.run("Duplicate...","title=gb duplicate stack")
# smooth
IJ.run("Gaussian Blur...", "sigma=2 stack");
# tophat
IJ.run("3D Fast Filters","filter=TopHat radius_x_pix=10 radius_y_pix=10 radius_z_pix=0 Nb_cpus=4");
IJ.getImage().setTitle("gb_th")
# threshold
IJ.run("Duplicate...","title=bw duplicate stack")
# maybe global TH now, because there is already a tophat?
#IJ.run("Auto Threshold", "method=Default white stack use_stack_histogram");
IJ.run("Auto Local Threshold", "method=Niblack radius=40 parameter_1=3 parameter_2=0 white stack");
# segment particles
#IJ.getImage().setRoi(roi_x, roi_y, roi_w, roi_h)
IJ.run("Set Measurements...", " mean min integrated center stack redirect=gb_th decimal=2");
IJ.run("Analyze Particles...", "size=10-10000 pixel circularity=0.00-1.00 show=Masks display exclude clear stack");
IJ.getImage().setTitle("particles")
# measure particles
rt = Analyzer.getResultsTable()
# todo: add the particles that are actually analyzed (size filter, see above)
# combine for documentation
IJ.run("Combine...", "stack1=raw stack2=bw");
IJ.getImage().setTitle("combine_raw_bw")
IJ.run("Combine...", "stack1=combine_raw_bw stack2=particles");
IJ.getImage().setTitle("combine_raw_bw_particles")
impFRAPandSEG = IJ.getImage()
IJ.saveAs(impFRAPandSEG, "Tiff", pathFRAPandSEG)
# extract intensity informations
nb = [0 for i in range(nt)]
nc = [0 for i in range(nt)]
ib = [0 for i in range(nt)]
ic = [0 for i in range(nt)]
fb = [0 for i in range(nt)]
fc = [0 for i in range(nt)]
t = [i*dt for i in range(nt)]
if(rt.getColumnIndex("Slice")==-1):
state = "no particles at all"
else:
Slice = rt.getColumn(rt.getColumnIndex("Slice"))
Mean = rt.getColumn(rt.getColumnIndex("Mean"))
Max = rt.getColumn(rt.getColumnIndex("Max"))
X = rt.getColumn(rt.getColumnIndex("XM"))
Y = rt.getColumn(rt.getColumnIndex("YM"))
IntDen = rt.getColumn(rt.getColumnIndex("IntDen"))
for i in range(len(Slice)):
# inside bleach roi?!
it = int(Slice[i])-1
# todo: maybe use a dictionary instead (one can remove items and have differnt t
if ( (X[i]>roi_x) & (X[i]<roi_x2) & (Y[i]>roi_y) & (Y[i]<roi_y2) ):
nb[it] = nb[it]+1
ib[it] = ib[it]+IntDen[i] # the IntDen copes best with in and out of focus motions as well as shape changes
fb[it] = fb[it]+Max[i]
else:
nc[it] = nc[it]+1
ic[it] = ic[it]+IntDen[i]
fc[it] = fc[it]+Max[i]
# compute mean values per particle
for i in range(len(t)):
if nb[i]>0:
fb[i] = fb[i]/ib[i]
ib[i] = ib[i]/nb[i]
if nc[i]>0:
fc[i] = fc[i]/ic[i]
ic[i] = ic[i]/nc[i]
nb1 = [(0,1)[i==1] for i in nb]
iShortlyAfter = iStart+10
if( sum(nb1[0:iStart]) < 0.5*iStart ):
state = "not enough pre-bleach measurements"
elif( sum(nb1[iStart:iShortlyAfter]) < 0.5*10 ):
state = "not enough short term measurements"
elif( sum(nb1[iShortlyAfter+1:len(nb1)-1]) < 0.5*(len(nb1)-(iShortlyAfter+1)) ):
state = "not enough long term measurements"
plot_size_x = 500
plot_size_y = 500
# plot number of particles
plotParticles = Plot( "Particles", "time", "number of particles", t, nb )
plotParticles.setFrameSize(plot_size_x,plot_size_y)
plotParticles.setSize(plot_size_x,plot_size_y)
plotParticles.setLimits(min(t),max(t),0,1.2*max(max(nb),max(nc)))
plotParticles.addPoints( t, nb, 3 )
plotParticles.addPoints( t, nc, 4 )
plotParticles.show()
# plot raw intensities
plotIntensities = Plot( "Intensities", "time", "gray values in particles", t, ib )
plotIntensities.setFrameSize(plot_size_x,plot_size_y)
plotIntensities.setSize(plot_size_x,plot_size_y)
plotIntensities.setLimits(min(t),max(t),0,1.2*max(max(ic),max(ib)))
plotIntensities.addPoints( t, ib, 3 )
plotIntensities.addPoints( t, ic, 4 )
#plotIntensities.show()
# plot sharpness
plotSharpness = Plot( "Sharpness", "time", "Max/IntDen", t, fb )
plotSharpness.setFrameSize(plot_size_x,plot_size_y)
plotSharpness.setSize(plot_size_x,plot_size_y)
plotSharpness.setLimits(min(t),max(t),0,1.2*max(max(fc),max(fb)))
plotSharpness.addPoints( t, fb, 3 )
plotSharpness.addPoints( t, fc, 4 )
#plotSharpness.show()
# FITTING
state = "ok"
# extract all time points relevant to the fitting
xTmp = []
yTmp = []
#print len(t)
#print range(iStart,len(t))
ipb = ib[0:iStart-1]
yTmpNorm = max(1,sum(ipb)/len(ipb)) # in order to avoid division by zero
#print ib[iStart-1]
for i in range(iStart,len(t)):
if nb1[i]==1: # only time-point with 1 particle
xTmp.append(float(t[i]-t[iStart]))
yTmp.append(float(ib[i]/yTmpNorm))
# do the fitting
# todo: how to add initial guesses??
imFrac = 0
tau = 0
xFit = []
yFit = []
if(len(yTmp)>20):
cf = CurveFitter( xTmp, yTmp )
cf.doFit(cf.EXP_RECOVERY)
print cf.getFormula()
p = cf.getParams()
for i in p:
print i
imFrac = (1-p[2]-p[0])
tau = (1/p[1])
for i in range(len(xTmp)):
xFit.append(float(xTmp[i]))
yFit.append(float(cf.f(cf.getParams(),xTmp[i])))
else:
state = "not enough data points for fitting"
# shift the fitting curves back to the original bleaching time point
#for i in range(len(xTmp)):
# xFit[i]=xFit[i]+t[iStart]
# xTmp[i]=xTmp[i]+t[iStart]
# plot fitting
plotFit = Plot( "Fitting", "time after bleach", "normalised intensity of bleached particle", xFit, yFit )
plotFit.setFrameSize(plot_size_x,plot_size_y)
plotFit.setSize(plot_size_x,plot_size_y)
if(len(xTmp)>0):
plotFit.setLimits(min(xTmp),max(xTmp),0,1.2*max(yTmp))
plotFit.addPoints( xTmp, yTmp, 3 )
#plotFit.addPoints( xFit, yFit, 4 )
plotFit.addLabel(0.1, 0.95, "imm_frac=%.2f tau[s]=%.2f" % (imFrac,tau))
plotFit.addLabel(0.1, 0.9, state)
# show the plots
IJ.run("Close all forced", "")
plotIntensities.show()
plotParticles.show()
plotSharpness.show()
plotFit.show()
# make one figure from the plots
IJ.run("Images to Stack", "name=Stack title=[] use");
IJ.run("Make Montage...", "columns=4 rows=1 scale=1 first=1 last=4 increment=1 border=0 font=12");
imp = IJ.getImage()
print "saving image: "+os.path.join(destDir, filename+"--IJ_graphs.png")
dest = os.path.join(destDir, filename+"--IJ_graphs.png")
IJ.saveAs(imp,"PNG", dest)
# write text files
dest = os.path.join(destDir, filename+"--intensBleach.csv")
writeXYfile(t,ib,dest,",")
dest = os.path.join(destDir, filename+"--intensCtrl.csv")
writeXYfile(t,ic,dest,",")
dest = os.path.join(destDir, filename+"--numParticlesBleach.csv")
writeXYfile(t,nb,dest,",")
dest = os.path.join(destDir, filename+"--numParticlesCtrl.csv")
writeXYfile(t,nc,dest,",")
IJ.run("Close all forced", "")
return()
# Fitter
fitter = CurveFitter(xtofit, ytofit)
fitter.doFit(CurveFitter.EXP_RECOVERY_NOOFFSET)
IJ.log("Fit FRAP curve by " + fitter.getFormula() )
param_values = fitter.getParams()
IJ.log( fitter.getResultString() )
# Overlay fit curve, with oversampling (for plot)
xfit = [ (t / 10.0 + bleach_frame) * frame_interval for t in range(10 * len(xtofit) ) ]
yfit = []
for xt in xfit:
yfit.append( fitter.f( fitter.getParams(), xt - xfit[0]) )
plot = Plot("Normalized FRAP curve for " + current_imp.getTitle(), "Time ("+time_units+')', "NU", [], [])
plot.setLimits(0, max(x), 0, 1.5 );
plot.setLineWidth(2)
plot.setColor(Color.BLACK)
plot.addPoints(x, y, Plot.LINE)
plot.addPoints(x,y,PlotWindow.X);
plot.setColor(Color.RED)
plot.addPoints(xfit, yfit, Plot.LINE)
plot.setColor(Color.black);
plot_window = plot.show()
stats = ImageStatistics.getStatistics(ip, Measurements.MEAN, calibration)
mean = stats.mean
# Store the measurement in the list
intensities.append(mean)
IJ.log('For image ' + current_imp.getTitle())
IJ.log('Time interval is ' + str(frame_interval) + ' ' + time_units)
# Build plot
x = [i * frame_interval for i in range(n_slices)]
y = intensities
plot = Plot("Backgrouncurve " + current_imp.getTitle(),
"Time (" + time_units + ')', "NU", [], [])
plot.setLimits(0, max(x), 0, max(y))
plot.setLineWidth(2)
plot.setColor(Color.BLACK)
plot.addPoints(x, y, Plot.LINE)
plot.addPoints(x, y, PlotWindow.X)
plot.setColor(Color.black)
plot_window = plot.show()
###############################
# Save data as a json file
###############################
# create example data arrays
xa = [1., 2., 3., 4.]
ya = [3., 3.5, 4., 4.5];
# construct a CurveFitter instance
cf = CurveFitter(xa, ya);
# actual fitting
# fit models: see http://rsb.info.nih.gov/ij/developer/api/constant-values.html#ij.measure.CurveFitter.STRAIGHT_LINE
cf.doFit(CurveFitter.STRAIGHT_LINE);
# print out fitted parameters.
b = cf.getParams()[0]
m = cf.getParams()[1]
strOut = str(b) + " : " + str(m)
IJ.log(strOut);
xb = [0 ,5]
yb = [b, 5*m+b]
pl = Plot("Data", "x", "y")
pl.setLimits(0,5,0,5)
pl.addPoints(xa, ya, Plot.CIRCLE)
pl.drawLine(xb[0], yb[0], xb[1], yb[1])
pl.show()
print(cf.getFormula())
plt = cf.getPlot()
plt.draw()
left = 0
right = 5
bottom = 0
top = 5
nPoints = 4
rng = right - left
# Create filled plot
plt = Plot("Line plot", "X", "Y")
plt.setLimits(left, right, bottom, top)
plt.setFrameSize(600, 300)
plt.setColor("blue", "#ccccff")
# the circles are small. Can't figure out how to make
# them larger... These 2 calls are equivalent...
# plt.addPoints(jxa,jya, Plot.CIRCLE)
plt.add("circles", jxa, jya)
# this is even harder to see...
# plt.addPoints(jxa,jya, Plot.CROSS)
plt.setColor(Color.RED)
plt.setLineWidth(1)
plt.drawLine(0.0, 2.5, 4.0, 4.5)
plt.setXYLabels("X", "Y")
plt.show()
plt_imp = plt.getImagePlus()