def bPrintLog(text, indent=0): msgStr = '' for i in (range(indent)): msgStr += ' ' print ' ', print text #to command line IJ.log(msgStr + text)
def main():
# Tricky hack to get ImagePlus from IJ1 interface
img = IJ.getImage()
display = DefaultLegacyService().getInstance().getImageMap().lookupDisplay(img)
dataset = DefaultImageDisplayService().getActiveDataset(display)
imp = dataset.getImgPlus()
# I don't really understand why sometime SCIFIO is not used
# When it's not, we can't access to getMetadata()
if not isinstance(imp, SCIFIOImgPlus):
IJ.showMessage("This image has not been opened with SCIFIO")
return
# Get metadata
metadata = imp.getMetadata()
# Why the f**k this is needed ?
while isinstance(metadata, AbstractMetadataWrapper):
metadata = metadata.unwrap()
# Check if metadata are OME or not
if isinstance(metadata, Metadata):
omeMeta = metadata.getOmeMeta()
else:
IJ.showMessage("This file does not contain OME metadata")
return
# Get xml string and print it with spaces indentation
xml_string = DefaultOMEXMLService().getOMEXML(omeMeta.getRoot())
xml = dom.parseString(xml_string)
xml_string = xml.toprettyxml(indent=" ")
IJ.log(xml_string)
def DirList(baseDir):
r = ImageReader()
imgStats = {}
for root, dirs, files in os.walk(str(baseDir)):
for f1 in files:
if f1.endswith(".jpg") or f1.endswith(".jpe") or f1.endswith(".jpeg"):
id = root + "/" + f1
r.setId(id)
if r is None:
print "Couldn\'t open image from file:", id
continue
w = r.getSizeX()
h = r.getSizeY()
imgStats[str(w) + "_" + str(h)] = imgStats.get(str(w) + "_" + str(h), 0)+1
IJ.log("Found image: " + str(id))
#counter += 1
r.close()
#print summary
summary = ''
for k, v in imgStats.iteritems():
dim = k.split("_")
ratio = float(dim[0])/float(dim[1])
IJ.log("Found " + str(v) + " images of dimension " + str(dim[0]) + "x" + str(dim[1]) + " apect ratio " + str(round(ratio, 2)))
summary = summary + "\nFound " + str(v) + " images of dimension " + str(dim[0]) + "x" + str(dim[1]) + " apect ratio " + str(round(ratio, 2))
return summary
def compute_frame_translations(imp, channel, frames = None):
""" imp contains a hyper virtual stack, and we want to compute
the X,Y,Z translation between every time point in it
using the given preferred channel. """
if frames is None:
frames = range(1, imp.getNFrames()+1)
t1_vs = extract_frame(imp, frames[0], channel)
shifts = []
# store the first shift: between t1 and t2
shifts.append(Point3i(0, 0, 0))
# append the rest:
IJ.showProgress(0)
i = 1
for t in frames[1:]:
IJ.log("Load frame " + str(t) + " up to " + str(frames[-1]))
t2_vs = extract_frame(imp, t, channel)
IJ.log("Compute difference " + str(t) + " to " + str(frames[0]))
shift = compute_stitch(ImagePlus("1", t1_vs), ImagePlus("2", t2_vs))
shifts.append(shift)
t1_vs = t2_vs
IJ.showProgress(i / float(imp.getNFrames()))
i += 1
IJ.showProgress(1)
return shifts, frames
def saveMask(self, maskdir):
imp = self.mask
imp.getProcessor().invert()
filebasename = os.path.basename(self.filename)
maskfilename = os.path.join(maskdir, "mask_%s" % filebasename)
IJ.save(imp, maskfilename)
IJ.log("Mask image: %s\n" % maskfilename)
def run():
projects = Project.getProjects()
if projects is None or projects.isEmpty():
IJ.log('No project open!')
return
ls = projects.get(0).getRootLayerSet()
trees = ls.getZDisplayables(Treeline)
trees.addAll(ls.getZDisplayables(AreaTree))
if trees.isEmpty():
IJ.log('No trees to process!')
return
dc = DirectoryChooser('Target folder')
targetFolder = dc.getDirectory()
if targetFolder is None:
return # user canceled
if targetFolder[len(targetFolder) -1] != '/':
targetFolder += '/'
fdir = File(targetFolder)
for f in fdir.listFiles():
if f.isHidden():
continue
yn = YesNoCancelDialog(IJ.getInstance(), "WARNING", "Folder not empty! Continue?")
if yn.yesPressed():
break
else:
return
process(trees, targetFolder)
def translate_single_stack_using_imglib2(imp, dx, dy, dz):
# wrap into a float imglib2 and translate
# conversion into float is necessary due to "overflow of n-linear interpolation due to accuracy limits of unsigned bytes"
# see: https://github.com/fiji/fiji/issues/136#issuecomment-173831951
img = ImagePlusImgs.from(imp.duplicate())
extended = Views.extendBorder(img)
converted = Converters.convert(extended, RealFloatSamplerConverter())
interpolant = Views.interpolate(converted, NLinearInterpolatorFactory())
# translate
if imp.getNDimensions()==3:
transformed = RealViews.affine(interpolant, Translation3D(dx, dy, dz))
elif imp.getNDimensions()==2:
transformed = RealViews.affine(interpolant, Translation2D(dx, dy))
else:
IJ.log("Can only work on 2D or 3D stacks")
return None
cropped = Views.interval(transformed, img)
# wrap back into bit depth of input image and return
bd = imp.getBitDepth()
if bd==8:
return(ImageJFunctions.wrapUnsignedByte(cropped,"imglib2"))
elif bd == 16:
return(ImageJFunctions.wrapUnsignedShort(cropped,"imglib2"))
elif bd == 32:
return(ImageJFunctions.wrapFloat(cropped,"imglib2"))
else:
return None
def core(imp):
pntsA = parsePoints(imp)
# Points must be passed to the Clusterer in Java List of Clusterable.
pntsAL = ArrayList()
for apnt in pntsA:
pntsAL.add(PosWrap(apnt[0], apnt[1], apnt[2]))
awrap = pntsAL.get(0)
pp = awrap.getPoint()
#print pp
clusterer = KMeansPlusPlusClusterer(Number_of_Cluster, Iteration)
res = clusterer.cluster(pntsAL)
outimp = imp.duplicate()
for i in range(res.size()):
if Verbose:
IJ.log('Cluster: ' + str(i))
for apnt in res.get(i).getPoints():
xpos = apnt.getPoint()[0]
ypos = apnt.getPoint()[1]
zpos = apnt.getPoint()[2]
if Verbose:
IJ.log('... ' + str(xpos) + ', ' + str(ypos) + ', ' + str(zpos))
outimp.getStack().getProcessor(int(zpos)+1).putPixel(int(xpos), int(ypos), i+1)
return outimp
def restore_metadata(input_dir,original_metadata,prefix):
# restore original metadata and filename to tiles
rewritten_data = glob.glob("%s*.tiff"%input_dir)
for f,filename in enumerate(rewritten_data):
new_filename = prefix+os.path.basename(filename)
IJ.log("Rewriting original meta data in image %s"%os.path.basename(new_filename))
replace_meta(original_metadata[f],filename)
os.rename(filename,new_filename)
def actionPerformed(self, event):
dlg = DirectoryChooser("Choose an output directory for the classifier")
if os.path.exists(self.path):
dlg.setDefaultDirectory(self.path)
self.path = dlg.getDirectory()
IJ.log("Added path: "+self.path)
def mousePressed(self, event):
canvas = event.getSource()
# imp = canvas.getImage()
p = canvas.getCursorLoc()
self.mouseWasPressed = True
IJ.log("mouse was clicked at:" + str(p.x) + " " + str(p.y))
self.x = p.x
self.y = p.y
def saveResult(self, resdir, header):
filebasename = os.path.basename(self.filename)
resfilename = os.path.join(resdir, "res_%s.csv" % os.path.splitext(filebasename)[0])
with codecs.open(resfilename, "w", "utf-8") as f:
table = [",".join(header) + "\n"]
table += ["%s, %s\n" % (filebasename, row.asRow()) for row in self.result]
f.writelines(table)
IJ.log("Result: %s" % resfilename)
def extract_stack_under_arealist():
# Check that a Display is open
display = Display.getFront()
if display is None:
IJ.log("Open a TrakEM2 Display first!")
return
# Check that an AreaList is selected and active:
ali = display.getActive()
if ali is None or not isinstance(ali, AreaList):
IJ.log("Please select an AreaList first!")
return
# Get the range of layers to which ali paints:
ls = display.getLayerSet()
ifirst = ls.indexOf(ali.getFirstLayer())
ilast = ls.indexOf(ali.getLastLayer())
layers = display.getLayerSet().getLayers().subList(ifirst, ilast +1)
# Create a stack with the dimensions of ali
bounds = ali.getBoundingBox()
stack = ImageStack(bounds.width, bounds.height)
# Using 16-bit. To change to 8-bit, use GRAY8 and ByteProcessor in the two lines below:
type = ImagePlus.GRAY16
ref_ip = ShortProcessor(bounds.width, bounds.height)
for layer in layers:
area = ali.getArea(layer)
z = layer.getZ()
ip = ref_ip.createProcessor(bounds.width, bounds.height)
if area is None:
stack.addSlice(str(z), bp)
continue
# Create a ROI from the area of ali at layer:
aff = ali.getAffineTransformCopy()
aff.translate(-bounds.x, -bounds.y)
roi = ShapeRoi(area.createTransformedArea(aff))
# Create a cropped snapshot of the images at layer under ali:
flat = Patch.makeFlatImage(type, layer, bounds, 1.0, layer.getDisplayables(Patch), Color.black)
b = roi.getBounds()
flat.setRoi(roi)
ip.insert(flat.crop(), b.x, b.y)
# Clear the outside of ROI (ShapeRoi is a non-rectangular ROI type)
bimp = ImagePlus("", ip)
bimp.setRoi(roi)
ip.setValue(0)
ip.setBackgroundValue(0)
IJ.run(bimp, "Clear Outside", "")
# Accumulate slices
stack.addSlice(str(z), ip)
imp = ImagePlus("AreaList stack", stack)
imp.setCalibration(ls.getCalibrationCopy())
imp.show()
def compute_and_update_frame_translations_dt(imp, channel, dt, process, shifts = None):
""" imp contains a hyper virtual stack, and we want to compute
the X,Y,Z translation between every t and t+dt time points in it
using the given preferred channel.
if shifts were already determined at other (lower) dt
they will be used and updated.
"""
nt = imp.getNFrames()
# get roi (could be None)
roi = imp.getRoi()
if roi:
print "ROI is at", roi.getBounds()
# init shifts
if shifts == None:
shifts = []
for t in range(nt):
shifts.append(Point3f(0,0,0))
# compute shifts
IJ.showProgress(0)
for t in range(dt, nt+dt, dt):
if t > nt-1: # together with above range till nt+dt this ensures that the last data points are not missed out
t = nt-1 # nt-1 is the last shift (0-based)
IJ.log(" between frames "+str(t-dt+1)+" and "+str(t+1))
# get (cropped and processed) image at t-dt
roi1 = shift_roi(imp, roi, shifts[t-dt])
imp1 = extract_frame_process_roi(imp, t+1-dt, channel, process, roi1)
# get (cropped and processed) image at t-dt
roi2 = shift_roi(imp, roi, shifts[t])
imp2 = extract_frame_process_roi(imp, t+1, channel, process, roi2)
if roi:
print "ROI at frame",t-dt+1,"is",roi1.getBounds()
print "ROI at frame",t+1,"is",roi2.getBounds()
# compute shift
local_new_shift = compute_stitch(imp2, imp1)
if roi: # total shift is shift of rois plus measured drift
print "correcting measured drift of",local_new_shift,"for roi shift:",shift_between_rois(roi2, roi1)
local_new_shift = add_Point3f(local_new_shift, shift_between_rois(roi2, roi1))
# determine the shift that we knew alrady
local_shift = subtract_Point3f(shifts[t],shifts[t-dt])
# compute difference between new and old measurement (which come from different dt)
add_shift = subtract_Point3f(local_new_shift,local_shift)
print "++ old shift between %s and %s: dx=%s, dy=%s, dz=%s" % (int(t-dt+1),int(t+1),local_shift.x,local_shift.y,local_shift.z)
print "++ add shift between %s and %s: dx=%s, dy=%s, dz=%s" % (int(t-dt+1),int(t+1),add_shift.x,add_shift.y,add_shift.z)
# update shifts from t-dt to the end (assuming that the measured local shift will presist till the end)
for i,tt in enumerate(range(t-dt,nt)):
# for i>dt below expression basically is a linear drift predicition for the frames at tt>t
# this is only important for predicting the best shift of the ROI
# the drifts for i>dt will be corrected by the next measurements
shifts[tt].x += 1.0*i/dt * add_shift.x
shifts[tt].y += 1.0*i/dt * add_shift.y
shifts[tt].z += 1.0*i/dt * add_shift.z
print "updated shift till frame",tt+1,"is",shifts[tt].x,shifts[tt].y,shifts[tt].z
IJ.showProgress(1.0*t/(nt+1))
IJ.showProgress(1)
return shifts
def call(self): self.thread_used = threading.currentThread().getName() self.started = time.time() try: applyLayerTransformToPatch(self.patch, self.transform) print self.patch.getTitle() + " patch transformed\n" except Exception, ex: self.exception = ex print str(ex) IJ.log(str(ex))
def isFrames(imp):
"""Determine whether the stack has >1 slices or >1 frames"""
NSlices = imp.getNSlices
NFrames = imp.getNFrames
#print "number of slices:", NSlices
#print "number of frames:", NFrames
if NSlices == 1 and NFrames != 1:
return True
elif NSlices != 1 and NFrames == 1:
return False
else:
IJ.log("stack dimension error!")
def detection(imp, c):
cal = imp.getCalibration()
model = Model()
settings = Settings()
settings.setFrom(imp)
# Configure detector - Manually determined as best
settings.detectorFactory = LogDetectorFactory()
settings.detectorSettings = {
'DO_SUBPIXEL_LOCALIZATION': True,
'RADIUS': 2.0,
'TARGET_CHANNEL': c,
'THRESHOLD': 20.0,
'DO_MEDIAN_FILTERING': False,
}
settings.addSpotAnalyzerFactory(SpotIntensityAnalyzerFactory())
settings.addSpotAnalyzerFactory(SpotContrastAndSNRAnalyzerFactory())
settings.trackerFactory = SparseLAPTrackerFactory()
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
trackmate = TrackMate(model, settings)
ok = trackmate.checkInput()
if not ok:
sys.exit(str(trackmate.getErrorMessage()))
try:
ok = trackmate.process()
except:
IJ.log("Nothing detected")
IJ.selectWindow('test')
IJ.run('Close')
else:
selectionModel = SelectionModel(model)
displayer = HyperStackDisplayer(model, selectionModel, imp)
displayer.render()
displayer.refresh()
# Get spots information
spots = model.getSpots()
spotIt = spots.iterator(0, False)
# Loop through spots and save into files
# Fetch spot features directly from spot
sid = []
x = []
y = []
q = []
r = []
spotID = 0
for spot in spotIt:
spotID = spotID + 1
sid.append(spotID)
x.append(spot.getFeature('POSITION_X'))
y.append(spot.getFeature('POSITION_Y'))
q.append(spot.getFeature('QUALITY'))
r.append(spot.getFeature('RADIUS'))
data = zip(sid, x, y, q, r)
return data
def concatenateImagePlus(files, outfile):
"""Concatenate images contained in files and save in outfile"""
options = ImporterOptions()
options.setId(files[0])
options.setVirtual(1)
options.setOpenAllSeries(1)
options.setQuiet(1)
images = BF.openImagePlus(options)
imageG = images[0]
nrPositions = len(images)
options.setOpenAllSeries(0)
nslices = imageG.getNSlices()
nframes = len(files)
nchannels = imageG.getNChannels()
luts = imageG.getLuts()
for i in range(0, nrPositions):
concatImgPlus = IJ.createHyperStack(
"ConcatFile", imageG.getWidth(), imageG.getHeight(),
imageG.getNChannels(), imageG.getNSlices(),
len(files), imageG.getBitDepth())
concatStack = ImageStack(imageG.getWidth(), imageG.getHeight())
IJ.showStatus("Concatenating files")
for file_ in files:
try:
print '...', basename(file_)
options.setSeriesOn(i, 1)
options.setId(file_)
image = BF.openImagePlus(options)[0]
imageStack = image.getImageStack()
sliceNr = imageStack.getSize()
for j in range(1, sliceNr+1):
concatStack.addSlice(imageStack.getProcessor(j))
image.close()
options.setSeriesOn(i, 0)
except Exception, e:
IJ.log("ERROR")
IJ.log(file_ + str(e))
raise
IJ.showProgress(files.index(file_), len(files))
concatImgPlus.setStack(concatStack, nchannels, nslices, nframes)
concatImgPlus.setCalibration(image.getCalibration())
concatImgPlus.setOpenAsHyperStack(True)
concatImgPlus.setLuts(luts)
concatImgPlus.close()
IJ.saveAs(concatImgPlus, "Tiff", outfile)
def write_object_db(objectDB, path):
try:
f = open(path,"w")
for tile in objectDB:
for obj in tile:
stringVersion = [str(x) for x in obj]
cereal = ','.join(stringVersion)
#print cereal
f.write(cereal+"\n")
except:
IJ.log("Could not write updated object file")
finally:
f.close()
def measure(self):
imp = IJ.openImage(self.filename)
IJ.log("Input file: %s" % self.filename)
ImageConverter(imp).convertToGray8()
res = Auto_Threshold().exec(imp, self.myMethod, self.noWhite, self.noBlack, self.doIwhite, self.doIset, self.doIlog, self.doIstackHistogram)
rt = ResultsTable()
rt.showRowNumbers(False)
pa = PA(self.options, PA.AREA + PA.PERIMETER + PA.CIRCULARITY, rt, self.MINSIZE, self.MAXSIZE)
pa.analyze(imp)
self.result = self.rtToResult(rt)
self.mask = imp
def saveStack(destFolder,file_name,imp):
#rename the result and save it to subfolder
if not os.path.isdir(destFolder):
os.makedirs(destFolder)
fullname=os.path.join(destFolder,file_name)
#print (fullname)
fs = FileSaver(imp)
#print 'bSaveStack()', fullPath, 'nslices=', sr_imp.getNSlices()
print('save result to: ',fullname)
msgStr = "Dimension:" + str(imp.width) + " X " + str(imp.height) + " X " + str(imp.getNSlices())
print (msgStr)
IJ.log(" -Save "+file_name+" to "+destFolder)
IJ.log(" -"+msgStr)
fs.saveAsTiffStack(fullname)
def CZI_convert(nucleus_channel):
# Convert CZI to IDS files
NbSeries = Z1_metadata(sourcefile)
IJ.log(INpath + " contains " + str(NbSeries) + " views")
options = "open=[" + INpath + \
"] stack_order=XYCZT color_mode=Composite view=Hyperstack"
for k in range(1, NbSeries + 1):
imp = IJ.run("Bio-Formats Importer", options + " series_" + str(k))
output = "view" + str(k) + ".ids"
IJ.run(imp, "Bio-Formats Exporter", "save=" +
os.path.join(folder1, output))
preprocessing(imp,nucleus_channel,output)
IJ.run("Close")
IJ.log("View " + str(k) + " Converted")
def run_stitch(filePath):
basePath,baseName = os.path.split(filePath)
imagePrefix = os.path.splitext(baseName)[0]
resizeName = basePath + "/" + baseName + "_tiles/resized/"
checkName = basePath + "/" + baseName + "_tiles/resized/" + imagePrefix + "_seq/"
activeName = basePath + "/" + baseName + "_tiles"
IJ.log("Stitching " + filePath + "...")
if (not os.path.isdir(checkName)):
thread = Thread.currentThread()
originalThread = thread.getName()
thread.setName("Run$_stitch_process")
options = "choose=" + resizeName + " select=" + activeName + "/tile_info.txt image_prefix=" + imagePrefix
Macro.setOptions(Thread.currentThread(),options)
try:
IJ.run("Stitch wrapper",options)
IJ.log("succeeded")
returnVal = 0
except:
IJ.log("failed")
os.rmdir(checkName)
returnVal = 1
thread.setName(originalThread)
Macro.setOptions(thread,None)
else:
IJ.log("skipped")
returnVal = 2
return returnVal
def selectZrange(infile, Qmin, Qmax):
infile = filename(infile)
data = retrieve_seeds(infile)
spotsZ = []
for row in data:
spotsZ.append(float(row[4]))
spotsZ = sorted(spotsZ)
if len(spotsZ) > 10:
Zmin = float(percentile(spotsZ, Qmin))
Zmax = float(percentile(spotsZ, Qmax))
else:
Zmin = 1
Zmax = 3
IJ.log(infile + ' zmin=' + str(Zmin) + ' zmax=' + str(Zmax))
return Zmin, Zmax
def orthoStackFrom4D(imp):
stkA = ArrayList()
for i in range(1, imp.getNFrames()+1):
e4d = Extractfrom4D()
e4d.setGstarttimepoint(i)
IJ.log("current time point" + str(i))
aframe = e4d.coreheadless(imp, 3)
ortho = XYZMaxProject(aframe)
orthoimp = ortho.getXYZProject()
stkA.add(orthoimp)
#orthoimp.show()
stk = ImageStack(stkA.get(0).getWidth(), stkA.get(0).getHeight())
for item in stkA:
stk.addSlice("slcie", item.getProcessor())
out = ImagePlus("out", stk)
return out
def run():
global cal, pw, ph
projects = Project.getProjects()
if projects is None or projects.isEmpty():
IJ.log('No project open!')
return
p = projects.get(0)
ls = p.getRootLayerSet()
cal = ls.getCalibrationCopy()
pw = float(cal.pixelWidth)
ph = float(cal.pixelHeight)
rpt = p.getRootProjectThing()
add_recursively(rpt,None)
add_connectors_recursively(rpt)
def run(self):
IJ.resetEscape()
IJ.setTool("point")
listener = ML()
self.imp.show()
canvas = self.imp.getWindow().getCanvas()
canvas.addMouseListener(listener)
# wait for mouse click
while (not listener.mouseWasPressed) and (not IJ.escapePressed()):
Thread.sleep(200) # todo: how to make this better?
canvas.removeMouseListener(listener)
if IJ.escapePressed():
IJ.log("command has been aborted")
else:
print listener.x, listener.y
self.pos = [listener.x, listener.y]
def retrieve_seeds(infile):
# Retrieve detected nucleus spots from csv files
data = {}
name = re.sub('.ids', '.csv', infile)
with open(os.path.join(folder5, name), 'rb') as f:
reader = csv.reader(f, delimiter=',', quotechar='"',
skipinitialspace=True)
header = reader.next()
for name in header:
data[name] = []
for row in reader:
for i, value in enumerate(row):
data[header[i]].append(value)
output = zip(data['spotID'], data['roundID'], data['X'], data['Y'], data[
'Z'], data['QUALITY'], data['SNR'], data['INTENSITY'])
IJ.log('Loading ' + str(len(output)) + ' seed spots from ' + name)
return output
def run():
helpText = "This program will batch convert .swc files to " + \
"SVG vector graphs.\n\n" + \
">> Press OK to Select a directory of .swc traces."
MessageDialog(IJ.getInstance(),"Batch SWC to SVG Guide", helpText)
d = DirectoryChooser("Chose Traces Dir").getDirectory()
if d is None:
IJ.log("Choose Dir Canceled!")
return
swc_files = [ os.path.join(d,x) for x in os.listdir(d) if re.search('(?i)\.swc$',x) ]
pafm = PathAndFillManager(10240, # width
10240, # height
1, # depth
1, # x spacing
1, # y spacing
1, # z spacing
"pixel")
for swc_file in swc_files:
out_file = swc_file + ".svg"
if not pafm.importSWC(swc_file,False): # second parameter is ignoreCalibration
IJ.error("Failed to load: "+swc_file)
for i in range(pafm.size()):
path = pafm.getPath(i)
f = open(out_file, "wb")
f.write(toSvgString_polyline(path))
f.close()
f = open(swc_file + "-path.svg", "wb")
f.write(toSvgString_path(path))
f.close()
f = open(swc_file + "-points.csv",'wb')
writer = csv.writer(f)
writer.writerow(["x", "y"])
writer.writerows(toListOfPoints(path))
f.close()
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))
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]])
random.shuffle(validParticles)
IJ.log("# valid particles = %d " % len(validParticles))
if len(validParticles) == 0:
validParticles = None
return impMetaProb, impBW, validParticles, rois
def getMatchingResults(features1, features2):
candidates = ArrayList()
inliers = ArrayList()
FeatureTransform.matchFeatures(features1, features2, candidates, 0.92)
# FeatureTransform.matchFeatures(features1, features2, candidates, 0.95)
model = AffineModel2D()
try:
modelFound = model.filterRansac(
candidates, inliers, 1000, 10, 0, 7
) # (candidates, inliers, iterations, maxDisplacement, ratioOfConservedFeatures, minNumberOfConservedFeatures)
except NotEnoughDataPointsException, e:
modelFound = False
IJ.log('NotEnoughDataPointsException')
return None
if not modelFound:
IJ.log('model not found ')
return None
else:
IJ.log('model found')
return [model, inliers]
def getScalingFactors(aff):
m = pythonToJamaMatrix([[aff.getScaleX(), aff.getShearX()],
[aff.getShearY(), aff.getScaleY()]])
SVD = SingularValueDecomposition(m)
S = SVD.getS().getArrayCopy()
return S[0][0], S[1][1]
def computeRegistration():
try: # look in priority for sectionOrder, which means that it has already been processed
orderPath = os.path.join(
MagCFolder,
filter(lambda x: 'sectionOrder' in x, os.listdir(MagCFolder))[0])
except Exception, e:
orderPath = os.path.join(
MagCFolder,
filter(lambda x: 'solution' in x, os.listdir(MagCFolder))[0])
sectionOrder = fc.readOrder(orderPath)
BIBMode = True
if BIBMode:
sectionOrder = [o / 2 for o in sectionOrder[::2]]
IJ.log('sectionOrder: ' + str(sectionOrder))
MagCParams = fc.readMagCParameters(MagCFolder)
executeLM = MagCParams[namePlugin]['executeLM']
executeEM = MagCParams[namePlugin]['executeEM']
##########################
########## LM ##########
##########################
if executeLM:
sourceLMDataFolder = os.path.join(MagCFolder, 'LMData')
targetLMDataFolder = os.path.join(MagCFolder, 'LMDataReordered')
try:
os.makedirs(targetLMDataFolder)
print "Output directory exists already, data might be overwritten"
#crop images ?
#get c-Fos
ListCfos = getCfosImages(In_dir)
#if it is empty stop
if len(ListCfos) == 0:
os.rmdir(Out_dir)
sys.exit('No c-Fos images found')
#get unique MouseIDs
MouseIDs = UniqueMouseIDs(ListCfos)
for MouseID in MouseIDs:
IJ.log("\nProcessing mouse " + MouseID)
#get the list of cFos images for a specific mouse
MouseIDcFos = getMouseCfos(ListCfos, MouseID)
#find the threshold values using the quantiles
percentiles = [98.5, 99.5, 99.9]
thresholds = FindThreholds(In_dir, MouseIDcFos, percentiles)
IJ.log('Thresholds for percentiles ' + str(percentiles) +
' selected to ' + str(thresholds))
#threshold and save images for each threshold value
for i, threshold in enumerate(thresholds):
# create directory
Perc_Out_dir = Out_dir + "percentile_" + str(percentiles[i]) + "/"
if not os.path.exists(Perc_Out_dir):
os.makedirs(Perc_Out_dir)
IJ.log('Processing ' + MouseID + ' for percentile ' +
str(percentiles[i]))
def processFile():
# start logging
IJ.log("\n______________________________\n\n\t\tOlympus DM correction\n\t\tVersion " + pluginVersion +"\n______________________________\n")
# ask user for file
ofd = OpenDialog("Choose a file", None)
filename = ofd.getFileName()
if filename is None:
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
directory = ofd.getDirectory()
filepath = directory + filename
IJ.log("File path: " + filepath)
if not filename.endswith(".oir"):
IJ.log("Not an Olympus (.oir) file.\nNo image to process.\n")
return
filenameExExt = os.path.splitext(filename)[0]
# parse metadata
reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(filepath)
numChannels = reader.getSizeC()
numSlices = reader.getSizeZ()
numFrames = reader.getSizeT()
seriesCount = reader.getSeriesCount()
globalMetadata = reader.getGlobalMetadata()
seriesMetadata = reader.getSeriesMetadata()
objLensName = globalMetadata['- Objective Lens name #1']
areaRotation = float(seriesMetadata['area rotation #1'])
acquisitionValueRotation = float(seriesMetadata['acquisitionValue rotation #1'])
if 'regionInfo rotation #1' in seriesMetadata:
regionInfoRotation = float(seriesMetadata['regionInfo rotation #1'])
else:
regionInfoRotation = float(0)
totalRotation = areaRotation + regionInfoRotation
physSizeX = omeMeta.getPixelsPhysicalSizeX(0)
physSizeY = omeMeta.getPixelsPhysicalSizeY(0)
pxSizeX = physSizeX.value(UNITS.MICROM)
pxSizeY = physSizeY.value(UNITS.MICROM)
# log metadata
IJ.log("\nMETADATA")
#IJ.log("Filename: " + filepath)
IJ.log("Number of series: " + str(seriesCount))
IJ.log("Number of channels: " + str(numChannels))
IJ.log("Number of frames: " + str(numFrames))
IJ.log("Number of slices: " + str(numSlices))
IJ.log("Objective lens: " + objLensName)
IJ.log("FOV rotation: " + str(areaRotation))
IJ.log("ROI rotation: " + str(regionInfoRotation))
IJ.log("Total rotation: " + str(totalRotation))
IJ.log("Pixel size:")
IJ.log("\t\tX = " + str(physSizeX.value()) + " " + physSizeX.unit().getSymbol())
IJ.log("\t\tY = " + str(physSizeY.value()) + " " + physSizeY.unit().getSymbol())
# ask user to identify dichroic mirror used for each channel
gdDM = GenericDialog("Dichroic mirrors")
DMs = ["DM1", "DM2", "DM3", "DM4", "DM5"]
for i in range(numChannels):
gdDM.addChoice("Channel " + str(i+1), DMs, DMs[0])
gdDM.addCheckbox("Merge channels", False)
gdDM.showDialog()
if gdDM.wasCanceled():
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
dichroics = []
for i in range(numChannels):
dichroics.append(gdDM.getNextChoice())
merge = gdDM.getNextBoolean()
IJ.log("\nUser selected dichroic mirrors")
for i in range(numChannels):
IJ.log("\t\tChannel " + str(i+1) + ": " + dichroics[i])
if merge:
channels = []
chDict = {}
for i in range(numChannels):
chName = "Channel"+str(i+1)
channels.append(chName)
chDict[chName] = i
channels.append("NONE")
colourChoices = ["red", "green", "blue", "gray", "cyan", "magenta", "yellow"]
gdMerge = GenericDialog("Merge channels")
for c in colourChoices:
gdMerge.addChoice(c + ":", channels, channels[numChannels])
gdMerge.showDialog()
if gdMerge.wasCanceled():
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
IJ.log("\nUser selected channel colours")
mergeList = []
for i in range(len(colourChoices)):
ch = gdMerge.getNextChoice()
if ch == "NONE":
mergeList.append(None)
else:
mergeList.append(chDict[ch])
IJ.log("\t\t" + colourChoices[i] + ": " + ch)
# ask user for an output directory
dc = DirectoryChooser("Choose folder for output")
od = dc.getDirectory()
if od is None:
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
if merge:
tifDir = od + "." + str(datetime.now()).replace(" ", "").replace(":", "") + "/"
if not os.path.exists(tifDir):
os.makedirs(tifDir)
IJ.log("\nCreated temporary folder: " + tifDir + "\n")
else:
IJ.log("Unable to create temporary folder!\n")
else:
tifDir = od + filenameExExt + "/"
if not os.path.exists(tifDir):
os.makedirs(tifDir)
IJ.log("\nCreated subfolder: " + tifDir + "\n")
else:
IJ.log("\nSubfolder " + tifDir + " already exists")
# correct images
tifFilePaths = []
for i in range(numChannels):
ip = extractChannel(oirFile=filepath, ch=i)
if dichroics[i] == "DM1":
IJ.log("Channel " + str(i+1) + " was imaged using DM1, so no correction required.")
else:
offsets = getOffset(obj=objLensName,dm=dichroicDict[dichroics[i]])
xom = offsets['x']
yom = offsets['y']
if abs(totalRotation) > 0.1:
rotOff = rotateOffset(x=xom, y=yom, angle=-totalRotation)
xom = rotOff['x']
yom = rotOff['y']
xop = int(round(xom/pxSizeX))
yop = int(round(yom/pxSizeY))
IJ.log("Channel " + str(i+1) + " offsets")
IJ.log("\t\tMicrometres")
IJ.log("\t\t\t\tx = " + str(xom))
IJ.log("\t\t\t\ty = " + str(yom))
IJ.log("\t\tPixels")
IJ.log("\t\t\t\tx = " + str(xop))
IJ.log("\t\t\t\ty = " + str(yop))
IJ.run(ip, "Translate...", "x=" + str(-xop) + " y=" + str(-yop) + " interpolation=None stack")
tifFilePath = tifDir + filenameExExt + "_ch_"+str(i+1)+".tif"
tifFilePaths.append(tifFilePath)
if os.path.exists(tifFilePath):
IJ.log("\nOutput file exists: " + tifFilePath)
IJ.log("Rerun plugin choosing a different output folder")
IJ.log("or delete file and then rerun plugin.")
IJ.log("Image processing terminated!\n")
return
FileSaver(ip).saveAsTiff(tifFilePath)
if merge:
for i in range(len(mergeList)):
if mergeList[i] != None:
mergeList[i] = readSingleChannelImg(tifFilePaths[mergeList[i]])
merged = RGBStackMerge.mergeChannels(mergeList, False)
mergedChannelFilepath = od + filenameExExt + ".tif"
if os.path.exists(mergedChannelFilepath):
IJ.log("\nOutput file exists: " + mergedChannelFilepath)
IJ.log("Rerun plugin choosing a different output folder")
IJ.log("or delete file and then rerun plugin.")
IJ.log("Image processing terminated!\n")
FileSaver(merged).saveAsTiff(mergedChannelFilepath)
for tf in tifFilePaths:
os.remove(tf)
os.rmdir(tifDir)
IJ.log("\nFinished processing file:\n" + filepath + "\n")
if merge:
IJ.log("Image file with channels aligned:\n" + od + filenameExExt + ".tif\n")
else:
IJ.log("Aligned images (one tiff file for each channel) can be found in:\n" + tifDir + "\n")
return y * nX + (nX - x - 1)
namePlugin = 'assembly_EM'
MagCFolder = fc.startPlugin(namePlugin)
MagCParameters = fc.readMagCParameters(MagCFolder)
ControlWindow.setGUIEnabled(False)
MagC_EM_Folder = os.path.join(MagCFolder, 'MagC_EM','')
# read metadata
EMMetadataPath = fc.findFilesFromTags(MagCFolder,['EM_Metadata'])[0]
EMMetadata = fc.readParameters(EMMetadataPath)
numTilesX = EMMetadata['numTilesX']
# reading transforms from the low-resolution montage
IJ.log('reading the affine transform parameters from the affine montage')
transformsPath = os.path.join(MagC_EM_Folder, 'assembly_lowEM_Transforms.txt')
with (open(transformsPath, 'r')) as f:
transforms = f.readlines()
nLayers = max([int(transforms[i]) for i in range(1, len(transforms),8) ]) + 1 # why not, could simply read the EM_Metadata parameters ...
# getting downsamplingFactor
downsamplingFactor = MagCParameters['downsample_EM']['downsamplingFactor']
factorString = str(int(1000000*downsamplingFactor)).zfill(8)
# create the normal resolution project
IJ.log('Creating project with the full size EM images')
projectPath = fc.cleanLinuxPath(os.path.join(MagC_EM_Folder,'EMProject.xml'))
projectFolder = fc.cleanLinuxPath(os.path.dirname(projectPath))
project, loader, layerset, _ = fc.getProjectUtils(fc.initTrakem(projectFolder, 1))
project.saveAs(projectPath, True)
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)
from net.clearcontrol.easyscopy import EasyScopy
from ij import IJ
IJ.log("Supported microscopes:")
for lMicroscopeClass in EasyScopy.listEasyScopes():
IJ.log(" * " + str(lMicroscopeClass))
if states[i][j] == states[i][j + 1]:
events[i].append("{}".format(states[i][j + 1]))
elif states[i][j] == "growth" and states[i][j + 1] == "shrink":
events[i].append("gs")
elif states[i][j] == "growth" and states[i][j + 1] == "pause":
events[i].append("gp")
elif states[i][j] == "pause" and states[i][j + 1] == "shrink":
events[i].append("ps")
elif states[i][j] == "pause" and states[i][j + 1] == "growth":
events[i].append("pg")
elif states[i][j] == "shrink" and states[i][j + 1] == "growth":
events[i].append("sg")
elif states[i][j] == "shrink" and states[i][j + 1] == "pause":
events[i].append("sp")
IJ.log("\\Clear") # logのclear command
IJ.log("indx" + "\t" + "id" + "\t" + "dt_s" + "\t" + "dlength_um" + "\t" +
"velocity_um/min" + "\t" + "state" + "\t" + "event" + "\t" +
"event_bool")
for i in range(len(vels)):
for j in range(len(vels[i])):
IJ.log(
str(j) + "\t" + str(i) + "\t" + str(dts[i][j]) + "\t" +
str(dls[i][j]) + "\t" + str(vels[i][j]) + "\t" +
str(states[i][j]) + "\t" + str(events[i][j]) + "\t" + str("TRUE"))
# logの結果をsave
from ij import IJ
import os
from ij import WindowManager as wm
os.makedirs(Out_dir)
else:
print("Output directory exists already, data might be overwritten")
# get tif files
ListTif = getTifImages(In_dir)
# if it is empty stop
if len(ListTif) == 0:
os.rmdir(Out_dir)
sys.exit('No .tif images found, bye')
# get unique MouseIDs
MouseIDs = UniqueMouseIDs(ListTif)
for MouseID in MouseIDs:
IJ.log("\nProcessing mouse " + MouseID)
# get the list of cFos images for a specific mouse
MouseIDFiles = getMouseFiles(ListTif, MouseID)
# calculate the number of channels
number_of_channels_in_mouse = getNumberOfChannels(MouseIDFiles)
print(
str(MouseID) + " contains " + str(number_of_channels_in_mouse) +
" distinct channels")
# run the function for each of the channels
for channel in range(1, (number_of_channels_in_mouse + 1)):
channel_files = getChannelFiles(MouseIDFiles, channel)
# get the full path
chf_fpaths = [path.join(In_dir, x) for x in channel_files]
# get the minimum and maximum pixel value
min_pixval, max_pixval = get_enhance_bounds(
chf_fpaths, low_theshold, high_threshold)
def process(srcDir, dstDir, currentDir, fileName, keepDirectories, Channel_1, Channel_2, radius_background, sigmaSmaller, sigmaLarger, minPeakValue, min_dist):
IJ.run("Close All", "")
# Opening the image
IJ.log("Open image file:" + fileName)
#imp = IJ.openImage(os.path.join(currentDir, fileName))
#imp = IJ.getImage()
imp = BF.openImagePlus(os.path.join(currentDir, fileName))
imp = imp[0]
# getDimensions(width, height, channels, slices, frames)
IJ.log("Computing Max Intensity Projection")
if imp.getDimensions()[3] > 1:
imp_max = ZProjector.run(imp,"max")
else:
imp_max = imp
ip1, ip2 = extract_channel(imp_max, Channel_1, Channel_2)
IJ.log("Substract background")
imp1, imp2 = back_substraction(ip1, ip2, radius_background)
IJ.log("Finding Peaks")
ip1_1, ip2_1, peaks_1, peaks_2 = find_peaks(imp1, imp2, sigmaSmaller, sigmaLarger, minPeakValue)
# Create a PointRoi from the DoG peaks, for visualization
roi_1 = PointRoi(0, 0)
roi_2 = PointRoi(0, 0)
roi_3 = PointRoi(0, 0)
roi_4 = PointRoi(0, 0)
# A temporary array of integers, one per dimension the image has
p_1 = zeros(ip1_1.numDimensions(), 'i')
p_2 = zeros(ip2_1.numDimensions(), 'i')
# Load every peak as a point in the PointRoi
for peak in peaks_1:
# Read peak coordinates into an array of integers
peak.localize(p_1)
roi_1.addPoint(imp1, p_1[0], p_1[1])
for peak in peaks_2:
# Read peak coordinates into an array of integers
peak.localize(p_2)
roi_2.addPoint(imp2, p_2[0], p_2[1])
# Chose minimum distance in pixel
#min_dist = 20
for peak_1 in peaks_1:
peak_1.localize(p_1)
for peak_2 in peaks_2:
peak_2.localize(p_2)
d1 = distance(p_1, p_2)
if d1 < min_dist:
roi_3.addPoint(imp1, p_2[0], p_2[1])
break
for peak_2 in peaks_2:
peak_2.localize(p_2)
for peak_1 in peaks_1:
peak_1.localize(p_1)
d2 = distance(p_2, p_1)
if d2 < min_dist:
roi_4.addPoint(imp1, p_2[0], p_2[1])
break
cal = imp.getCalibration()
min_distance = str(round((cal.pixelWidth * min_dist),1))
table = ResultsTable()
table.incrementCounter()
table.addValue("Numbers of Neuron Markers", roi_1.getCount(0))
table.addValue("Numbers of Glioma Markers", roi_2.getCount(0))
table.addValue("Numbers of Glioma within %s um of Neurons" %(min_distance), roi_3.getCount(0))
table.addValue("Numbers of Neurons within %s um of Glioma" %(min_distance), roi_4.getCount(0))
#table.show("Results Analysis")
saveDir = currentDir.replace(srcDir, dstDir) if keepDirectories else dstDir
if not os.path.exists(saveDir):
os.makedirs(saveDir)
IJ.log("Saving to" + saveDir)
table.save(os.path.join(saveDir, fileName + ".csv"))
IJ.selectWindow("Log")
IJ.saveAs("Text", os.path.join(saveDir, fileName + ".csv"));
def process_time_points(root, files, outdir):
'''Concatenate images and write ome.tiff file. If image contains already multiple time points just copy the image'''
concat = 1
files.sort()
options = ImporterOptions()
options.setId(files[0])
options.setVirtual(1)
image = BF.openImagePlus(options)
image = image[0]
if image.getNFrames() > 1:
IJ.log(files[0] + " Contains multiple time points. Can only concatenate single time points! Don't do anything!")
image.close()
return
width = image.getWidth()
height = image.getHeight()
for patt in pattern:
outName = re.match(patt, os.path.basename(files[0]))
if outName is None:
continue
if outdir is None:
outfile = os.path.join(root, outName.group(1) + '.ome.tif')
else:
outfile = os.path.join(outdir, outName.group(1) + '.ome.tif')
reader = ImageReader()
reader.setMetadataStore(MetadataTools.createOMEXMLMetadata())
reader.setId(files[0])
timeInfo = []
omeOut = reader.getMetadataStore()
omeOut = setUpXml(omeOut, image, files)
reader.close()
image.close()
IJ.log ('Concatenates ' + os.path.join(root, outName.group(1) + '.ome.tif'))
itime = 0
try:
for ifile, fileName in enumerate(files):
print fileName
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(fileName)
#print omeMeta.getPlaneDeltaT(0,0)
#print omeMeta.getPixelsTimeIncrement(0)
if fileName.endswith('.czi'):
if ifile == 0:
T0 = omeMeta.getPlaneDeltaT(0,0).value()
dT = omeMeta.getPlaneDeltaT(0,0).value() - T0
unit = omeMeta.getPlaneDeltaT(0,0).unit()
else:
timeInfo.append(getTimePoint(reader, omeMeta))
unit = omeMeta.getPixelsTimeIncrement(0).unit()
try:
dT = round(timeInfo[files.index(fileName)]-timeInfo[0],2)
except:
dT = (timeInfo[files.index(fileName)]-timeInfo[0]).seconds
nrImages = reader.getImageCount()
for i in range(0, reader.getImageCount()):
try:
omeOut.setPlaneDeltaT(dT, 0, i + itime*nrImages)
except TypeError:
omeOut.setPlaneDeltaT(Time(dT, unit),0, i + itime*nrImages)
omeOut.setPlanePositionX(omeOut.getPlanePositionX(0,i), 0, i + itime*nrImages)
omeOut.setPlanePositionY(omeOut.getPlanePositionY(0,i), 0, i + itime*nrImages)
omeOut.setPlanePositionZ(omeOut.getPlanePositionZ(0,i), 0, i + itime*nrImages)
omeOut.setPlaneTheC(omeOut.getPlaneTheC(0,i), 0, i + itime*nrImages)
omeOut.setPlaneTheT(NonNegativeInteger(itime), 0, i + itime*nrImages)
omeOut.setPlaneTheZ(omeOut.getPlaneTheZ(0,i), 0, i + itime*nrImages)
itime = itime + 1
reader.close()
IJ.showProgress(files.index(fileName), len(files))
try:
incr = float(dT/(len(files)-1))
except:
incr = 0
try:
omeOut.setPixelsTimeIncrement(incr, 0)
except TypeError:
#new Bioformats >5.1.x
omeOut.setPixelsTimeIncrement(Time(incr, unit),0)
outfile = concatenateImagePlus(files, outfile)
if outfile is not None:
filein = RandomAccessInputStream(outfile)
fileout = RandomAccessOutputStream(outfile)
saver = TiffSaver(fileout, outfile)
saver.overwriteComment(filein,omeOut.dumpXML())
fileout.close()
filein.close()
except:
traceback.print_exc()
finally:
#close all possible open files
try:
reader.close()
except:
pass
try:
filein.close()
except:
pass
try:
fileout.close()
except:
for l, layer in enumerate(layerset.getLayers()):
layerFolder = os.path.join(registrationFolder,
'layer_' + str(l).zfill(4))
registeredFolder = os.path.join(layerFolder, 'registered')
MLSTPath = os.path.join(registeredFolder, 'MLST.xml')
if os.path.isfile(MLSTPath):
MLSTransform = CoordinateTransformXML().parse(MLSTPath)
affineCroppedImPath = os.path.join(
affineCroppedFolder,
'affineCropped_' + channel + '_' + str(l).zfill(4) + '.tif')
patch = Patch.createPatch(p, affineCroppedImPath)
layer.add(patch)
patch.setCoordinateTransform(
MLSTransform
) # does the order matter ? apparently yes, but I have to be sure that it is not an offset problem
IJ.log('Setting the mlsTransform in layer ' + str(l) + ' ' +
str(MLSTransform))
patch.updateBucket()
if idChannel < len(channels) - 2: # if it is a fluochannel
MLSTransformedFolder = fc.mkdir_p(
os.path.join(LMFolder, 'MLS_Transformed_' + str(channel),
''))
imp = loader.getFlatImage(layer, roiExport, 1, 0x7fffffff,
ImagePlus.GRAY8, Patch,
layer.getAll(Patch), True,
Color.black, None)
impPath = os.path.join(
MLSTransformedFolder, 'MLSTransformed_' + channel + '_' +
str(l).zfill(4) + '.tif')
IJ.save(imp, impPath)
else:
IJ.log("Analysis Done!")
counter+=1
def measure_gd(src_folder,file_names):
from javax.swing import JButton
gd = NonBlockingGenericDialog("Loci to compartment")
gd.setResizable(True)
gd.pack()
gd.addMessage("Draw a freehand ROI aound loci and closest \n compartment(e.g. speckle) and press 0 on keyboard.")
gd.addMessage("To load next image press Next Image button.")
next_imp_bt = JButton('Next Image', actionPerformed=load_next_image)
gd.add(next_imp_bt)
gd.setLocation(10,10)
gd.setAlwaysOnTop(True)
gd.hideCancelButton()
gd.showDialog()
#
if gd.wasOKed():
IJ.log( "Measurement done! You're welcome!")
##MAIN
counter=0
images_path=get_files(src_dir,ext="*"+file_extension) # regex pattern to look in the folder.
if len(images_path)==0:
IJ.log("There are no images in the specified folder")
else:
measure_gd(src_dir,images_path)
def computeRegistration():
while atomicI.get() < nSections:
k = atomicI.getAndIncrement()
if k < nSections:
l = k
IJ.log('Computing EM/LM registration for layer ' + str(l).zfill(4))
layerFolder = fc.mkdir_p(
os.path.join(registrationFolder, 'layer_' + str(l).zfill(4)))
toRegisterFolder = fc.mkdir_p(
os.path.join(layerFolder, 'toRegister'))
registeredFolder = fc.mkdir_p(
os.path.join(layerFolder, 'registered'))
# Applying appropriate filters to make lowresEM and LM look similar for layer l
imLM = IJ.openImage(imPaths['LM'][l])
imLM = fc.localContrast(imLM)
imLMPath = os.path.join(toRegisterFolder,
'imLM_' + str(l).zfill(4) + '.tif')
IJ.save(imLM, imLMPath)
imEM = IJ.openImage(imPaths['EM'][l])
imEM = fc.localContrast(imEM)
imEMPath = os.path.join(toRegisterFolder,
'imEM_' + str(l).zfill(4) + '.tif')
IJ.save(imEM, imEMPath)
# Compute first a simple affine registration on the non-cropped images
IJ.log(
'Computing affine and moving least squares alignment for layer '
+ str(l).zfill(4))
firstStepRegistered = False
# registration at first step with 1step/octave (less features)
pLowRes = getSIFTMatchingParameters(nOctaves[0], 1.6, 16, 4000, 8,
4)
featuresLM = getFeatures(imLMPath, pLowRes)
featuresEM = getFeatures(imEMPath, pLowRes)
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'No registration matching at low resolution matching step 1 in layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
IJ.log('---Layer ' + str(l).zfill(4) + ' distance ' +
str(distance) + ' px with ' + str(len(inliers)) +
' inliers')
if distance > matchingThreshold[0]:
IJ.log(
'Matching accuracy is lower than the threshold at the low resolution step 1 - '
+ str(l).zfill(4) + ' - distance - ' + str(distance))
else:
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Layer ' + str(l).zfill(4) +
' scaling factors - step 1 - ' + str(s1) + ' - ' +
str(s2) + '--' + str(s1 * s2) + ' affDeterminant ' +
str(affTransform.getDeterminant()) + ' nInliers ' +
str(len(inliers)))
if (abs(s1 - 1) < 0.2) and (
abs(s2 - 1) < 0.2
): # scaling in both directions should be close to 1
IJ.log('First step ok - layer ' + str(l).zfill(4))
firstStepRegistered = True
loaderZ.serialize(
affTransform,
os.path.join(registeredFolder, 'affineSerialized'))
if not firstStepRegistered:
IJ.log(
'First step registration in layer ' + str(l).zfill(4) +
' with few features has failed. Trying with more features.'
)
# registration at first step with 3steps/octave (more features)
# pLowRes = getSIFTMatchingParameters(3, 1.6, 64, 4000, 8, 4)
pLowRes = getSIFTMatchingParameters(nOctaves[0], 1.6, 16, 4000,
8, 4) # for BIB
featuresLM = getFeatures(imLMPath, pLowRes)
featuresEM = getFeatures(imEMPath, pLowRes)
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'No registration matching at low resolution matching step 1bis in layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
IJ.log('---Layer ' + str(l).zfill(4) + ' distance ' +
str(distance) + ' px with ' + str(len(inliers)) +
' inliers')
if distance > matchingThreshold[0]:
IJ.log(
'Matching accuracy is lower than the threshold at the high resolution step 1bis - '
+ str(l).zfill(4) + ' - distance - ' +
str(distance))
else:
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Layer ' + str(l).zfill(4) +
' scaling factors - step 1bis - ' + str(s1) +
' - ' + str(s2) + '--' + str(s1 * s2) +
' affDeterminant ' +
str(affTransform.getDeterminant()) +
' nInliers ' + str(len(inliers)))
if (abs(s1 - 1) < 0.2) and (
abs(s2 - 1) < 0.2
): # scaling in both directions should be close to 1
IJ.log('First step 1bis ok - layer ' +
str(l).zfill(4))
firstStepRegistered = True
loaderZ.serialize(
affTransform,
os.path.join(registeredFolder,
'affineSerialized'))
if not firstStepRegistered:
IJ.log('The two first step trials in layer ' +
str(l).zfill(4) + ' have failed')
else:
# Affine transform and crop the LM, and compute a high res MLS matching
with lock: # only one trakem working at a time
# apply affTransform
patch = Patch.createPatch(pZ, imLMPath)
layerZ.add(patch)
patch.setAffineTransform(affTransform)
patch.updateBucket()
# crop and export
bb = Rectangle(0, 0, widthEM, heightEM)
affineCroppedIm = loaderZ.getFlatImage(
layerZ, bb, 1, 0x7fffffff, ImagePlus.GRAY8, Patch,
layerZ.getAll(Patch), True, Color.black, None)
affineCroppedImPath = os.path.join(
toRegisterFolder,
'affineCroppedLM_' + str(l).zfill(4) + '.tif')
IJ.save(affineCroppedIm, affineCroppedImPath)
affineCroppedIm.close()
layerZ.remove(patch)
layerZ.recreateBuckets()
pHighRes = getSIFTMatchingParameters(nOctaves[1], 1.6, 64,
4096, 8, 4)
featuresLM = getFeatures(affineCroppedImPath, pHighRes)
featuresEM = getFeatures(imEMPath, pHighRes)
# get the MLS
matchingResults = getMatchingResults(featuresLM, featuresEM)
if matchingResults is None:
IJ.log(
'It cannot be, there should be a good match given that an affine was computed. Layer '
+ str(l).zfill(4))
else:
model, inliers = matchingResults
affTransform = model.createAffine()
s1, s2 = getScalingFactors(affTransform)
IJ.log('Second step determinant - layer ' +
str(l).zfill(4) + ' - determinant - ' +
str(affTransform.getDeterminant()) + ' nInliers ' +
str(len(inliers)) + 'Scaling factors - step 2 - ' +
str(s1) + ' - ' + str(s2))
if (abs(s1 - 1) < 0.2) and (abs(s2 - 1) < 0.2) and len(
inliers
) > 50: # scaling in both directions should be close to 1
distance = PointMatch.meanDistance(
inliers
) # mean displacement of the remaining matching features
if distance > matchingThreshold[1]:
IJ.log(
'Weird: matching accuracy is lower than the threshold at the high resolution step 2 - '
+ str(l).zfill(4) + ' - distance - ' +
str(distance))
else:
mlst = MovingLeastSquaresTransform()
mlst.setModel(AffineModel2D)
mlst.setAlpha(1)
mlst.setMatches(inliers)
xmlMlst = mlst.toXML('\t')
with open(
os.path.join(registeredFolder, 'MLST.xml'),
'w') as f:
f.write(xmlMlst)
loaderZ.serialize(
mlst,
os.path.join(registeredFolder,
'mlstSerialized'))
registrationStats.append(
[l, distance, len(inliers)])
def run():
print "===== Batch Convert Scan Image 4 ====="
# Expecting one argument: the file path
if len(sys.argv) < 2:
print " We need a hard-drive folder with .tif stacks as input"
print " Usage: ./fiji-macosx bBatchConvertTo8Bitv3 <folder-path>/"
# Prompt user for a folder
sourceFolder = DirectoryChooser(
"Please Choose A Directory Of .tif Files").getDirectory()
if not sourceFolder:
return
else:
sourceFolder = sys.argv[1] #assuming it ends in '/'
destFolder = sourceFolder + "scanimage4/"
destMaxFolder = destFolder + "max/"
#make destination directory
if not os.path.isdir(destFolder):
os.makedirs(destFolder)
#make max destination directory
if not os.path.isdir(destMaxFolder):
os.makedirs(destMaxFolder)
print " Processing source folder: ", sourceFolder
print " Saving to destination folder: ", destFolder
IJ.log(" ====== Starting Batch Convert Scan Image 4 ======")
IJ.log(" Processing source folder: " + sourceFolder)
IJ.log(" Saving to destination folder: " + destFolder)
numOpened = 0
numSaved = 0
for filename in os.listdir(sourceFolder):
startWithDot = filename.startswith(".")
isMax = filename.endswith("max.tif")
isTif = filename.endswith(".tif")
if (not startWithDot) and (not isMax) and (isTif):
shortName, fileExtension = os.path.splitext(filename)
#source .tif output (after conversion)
outPath = destFolder + filename
#max projection output
outMaxPath = destMaxFolder + "max_" + filename
#before we open, check if eventual dest exists
if os.path.exists(outPath):
msgStr = " Destination file exists, not processing the image:" + filename
print msgStr
IJ.log(msgStr)
continue #with next iteration
print " ===================================="
msgStr = " -> Opening " + sourceFolder + filename
print msgStr
IJ.log(msgStr)
imp = IJ.openImage(sourceFolder + filename)
if imp is None:
msgStr = " ERROR: Could not open image from file: " + filename
print msgStr
IJ.log(msgStr)
continue #with next iteration
imp.show()
numOpened += 1
msgStr = " Original Image is: " + str(
imp.width) + " X " + str(imp.height) + " X " + str(
imp.getNSlices())
print msgStr
IJ.log(msgStr)
if 1:
msgStr = " Removing Calibration From ScanImage 4 .tif"
print msgStr
IJ.log(msgStr)
#20140810, I CAN'T BELIEVE I FINALLY FOUND THIS !!!
infoStr = imp.getProperty("Info")
#print infoStr
#scanimage4 has a linear Calibration Function: y = a+bx
# a: -32768.000000
# b: 1.000000
# Unit: "Gray Value"
#for some reason scanimage4 is setting a linear image calibration, we see negative values but there are NOT there
cal = imp.getCalibration()
calCoeff = cal.getCoefficients()
msgStr = ' calibration is y=ax+b' + ' a=' + str(
calCoeff[0]) + ' b=' + str(calCoeff[1])
print msgStr
IJ.log(msgStr)
#append calibration to info string
imp.setCalibration(None)
infoStr += 'calibCoeff_a = ' + str(calCoeff[0]) + '\n'
infoStr += 'calibCoeff_b = ' + str(calCoeff[1]) + '\n'
#i have appended to Info, update it
#found this burried here: http://code.google.com/p/fiji-bi/source/browse/ij/ImagePlus.java?repo=imageja&name=imagej
imp.setProperty("Info", infoStr)
#get and print out min/max
theMin = StackStatistics(imp).min
theMax = StackStatistics(imp).max
msgStr = ' min=' + str(theMin) + ' max=' + str(theMax)
print msgStr
IJ.log(msgStr)
#subtract the linear calibration slope 'a' (what about intercept 'b' ?)
#coefficient 'a' is normally negative, this is what we are using 'Add'
#run("Subtract...", "value=32768 stack");
subArgVal = 'value=%s stack' % (calCoeff[0], )
IJ.run('Add...', subArgVal)
#save file
fs = FileSaver(imp)
msgStr = " Saving File to" + outPath
print msgStr
IJ.log(msgStr)
numSlices = imp.getNSlices()
if (numSlices > 1):
fs.saveAsTiffStack(outPath)
else:
fs.saveAsTiff(outPath)
numSaved += 1
#max
if (numSlices > 1):
maxCmdParams = 'start=1' + ' stop=' + str(
numSlices) + ' projection=[Max Intensity]'
IJ.run("Z Project...", maxCmdParams)
impMax = IJ.getImage()
fs = FileSaver(impMax)
print " Saving Max File to", outMaxPath
fs.saveAsTiff(outMaxPath)
#close max
impMax.changes = 0
impMax.close()
#close original
imp.changes = 0
imp.close()
else:
print " File was not 16 bit???"
imp.close() #close original
else:
if (not startWithDot) and isTif:
#print " ===================================="
print filename
msgStr = " -> Ignoring .tif:" + filename
print msgStr
IJ.log(msgStr)
msgStr = " Batch Convert Scan Image 4 is Done, Number Opened " + str(
numOpened) + ", Number Saved " + str(numSaved)
print " ==="
print msgStr
print " ==="
IJ.log(msgStr)
MagCParameters = fc.readMagCParameters(MagCFolder)
downsamplingFactor = MagCParameters['downsample_EM']['downsamplingFactor']
factorString = str(int(1000000 * downsamplingFactor)).zfill(8)
# read some metadata
EMMetadataPath = fc.findFilesFromTags(MagCFolder, ['EM', 'Metadata'])[0]
EMMetadata = fc.readParameters(EMMetadataPath)
numTilesX = EMMetadata['numTilesX']
numTilesY = EMMetadata['numTilesY']
xPatchEffectiveSize = EMMetadata['xPatchEffectiveSize']
yPatchEffectiveSize = EMMetadata['yPatchEffectiveSize']
tileOverlapX = EMMetadata['tileOverlapX']
tileOverlapY = EMMetadata['tileOverlapY']
nbLayers = EMMetadata['nSections']
IJ.log('There are ' + str(nbLayers) + ' EM layers')
##########################################
# Stitching of the low-res EM project
##########################################
allPatchCoordinates = []
downsampledFolder = os.path.join(MagC_EM_Folder, 'MagC_EM_' + factorString)
IJ.log('downsampledFolder ' + downsampledFolder)
foldersToStitch = [
os.path.join(downsampledFolder, folderName)
for folderName in os.walk(downsampledFolder).next()[1]
]
foldersToStitch = fc.naturalSort(foldersToStitch)
IJ.log('foldersToStitch ------------- ' + str(foldersToStitch))
import fijiCommon as fc
namePlugin = 'init_EM'
MagCFolder = fc.startPlugin(namePlugin)
ControlWindow.setGUIEnabled(False)
EMDataFolder = os.path.join(MagCFolder, 'EMData')
MagCEMFolder = fc.makeNeighborFolder(EMDataFolder, 'MagC_EM')
imageFolders = [
os.path.join(EMDataFolder, sectionFolderName)
for sectionFolderName in fc.naturalSort(os.walk(EMDataFolder).next()[1])
]
nSections = len(imageFolders)
IJ.log('There are ' + str(nSections) + ' EM layers')
# reading EM metadata
EMMetadataPath = os.path.join(MagCEMFolder, 'EM_Metadata.txt')
try: # old Atlas format
mosaicMetadata = os.path.join(
imageFolders[0],
filter(lambda x: 'Mosaic' in x, os.listdir(imageFolders[0]))[0])
root = ET.parse(mosaicMetadata).getroot()
pixelSize = float(root.find('PixelSize').text)
tileinfo = root.find('TileInfo')
tileWidth = int(tileinfo.find('TileWidth').text)
tileHeight = int(tileinfo.find('TileHeight').text)
tileOverlapX = float(tileinfo.find('TileOverlapXum').text)
tileOverlapY = float(tileinfo.find('TileOverlapYum').text)
settings.trackerSettings = LAPUtils.getDefaultLAPSettingsMap()
settings.trackerSettings[
'LINKING_MAX_DISTANCE'] = 5. # KEY PARAMETER: don't let nuclei move more than 5 um between frames
settings.trackerSettings['ALLOW_GAP_CLOSING'] = True
settings.trackerSettings['MAX_FRAME_GAP'] = 2
settings.trackerSettings['GAP_CLOSING_MAX_DISTANCE'] = 5.
settings.trackerSettings['ALLOW_TRACK_SPLITTING'] = False
settings.trackerSettings['ALLOW_TRACK_MERGING'] = False
#-------------------
# Instantiate plugin
#-------------------
trackmate = TrackMate(model, settings)
if not trackmate.checkInput() or not trackmate.process():
IJ.log('Could not execute TrackMate: ' +
str(trackmate.getErrorMessage()))
else:
IJ.log('TrackMate completed successfully.')
IJ.log('Found %d spots in %d tracks.' %
(model.getSpots().getNSpots(True),
model.getTrackModel().nTracks(True)))
# Now open the output file & write a header with each field you need. Fields:
# Spot_ID, which is unique for each identified object
# Track_ID, which is unique for each 'track' - i.e. same object over time
# Frame, which specifies the current frame
# X-Y-Z, which are the spatial locations of the tracked object at the current frame.
headerStr = '%10s %10s %10s %10s %10s %10s' % ('Spot_ID', 'Track_ID',
'Frame', 'X', 'Y', 'Z')
rowStr = '%10d %10d %10d %10.1f %10.1f %10.1f'
# Finally, we also want the mean intensity of each tracked object in each frame.
def run():
print "===== bBatchConvertTo8Bitv3 ====="
global numberOfChannels
global replaceExisting
# Expecting one argument: the file path
if len(sys.argv) < 2:
print " We need a hard-drive folder with .tif stacks as input"
print " Usage: ./fiji-macosx bBatchConvertTo8Bitv3 <folder-path>/"
# Prompt user for a folder
sourceFolder = DirectoryChooser(
"Please Choose A Directory Of .tif Files").getDirectory()
if not sourceFolder:
return
else:
sourceFolder = sys.argv[1] #assuming it ends in '/'
#get user options
okGo = getOptions() # creates {numberOfChannels, replaceExisting}
if okGo == -1:
return 0
destFolder = sourceFolder + "channels8/"
destMaxFolder = sourceFolder + "max/"
#make destination directory
if not os.path.isdir(destFolder):
os.makedirs(destFolder)
#make max destination directory
if not os.path.isdir(destMaxFolder):
os.makedirs(destMaxFolder)
print " Processing source folder: ", sourceFolder
print " Saving to destination folder: ", destFolder
IJ.log(" ====== Startin bBatchConvertTo8Bitv3 ======")
IJ.log(" Processing source folder: " + sourceFolder)
IJ.log(" Saving to destination folder: " + destFolder)
numOpened = 0
numSaved = 0
for filename in os.listdir(sourceFolder):
startWithDot = filename.startswith(".")
isMax = filename.endswith("max.tif")
isTif = filename.endswith(".tif")
if (not startWithDot) and (not isMax) and (isTif):
shortName, fileExtension = os.path.splitext(filename)
outPath = destFolder + "/" + filename
outPath1 = destFolder + "/" + shortName + "_ch1" + ".tif"
outPath2 = destFolder + "/" + shortName + "_ch2" + ".tif"
#max projection output
outMaxPath = destMaxFolder + "/" + "max_" + filename
outMaxPath1 = destMaxFolder + "/" + "max_" + shortName + "_ch1" + ".tif"
outMaxPath2 = destMaxFolder + "/" + "max_" + shortName + "_ch2" + ".tif"
#before we open, check if eventual dest exists
if not replaceExisting:
if numberOfChannels == 2 and os.path.exists(
outPath1) and os.path.exists(outPath2):
msgStr = " 8-Bit Destination file exists, not processing the image:" + filename
print msgStr
IJ.log(msgStr)
continue #with next iteration
if numberOfChannels == 1 and os.path.exists(outPath):
msgStr = " 8-Bit Destination file exists, not processing the image:" + filename
print msgStr
IJ.log(msgStr)
continue #with next iteration
print " ===================================="
msgStr = " -> Opening " + sourceFolder + filename
print msgStr
IJ.log(msgStr)
imp = IJ.openImage(sourceFolder + filename)
if imp is None:
msgStr = " ERROR: Could not open image from file: " + filename
print msgStr
IJ.log(msgStr)
continue #with next iteration
imp.show()
numOpened += 1
#i can't get properties as long list of {key=value}
#how do i then set each property in new imp1/imp2? Do IJ.openImagehave ot loop?
#infoProperty = imp.getInfoProperty() #Returns the "Info" property string, java.lang.String
#print 'infoProperty'
#print infoProperty
#.getProp(key) #Returns the value from the "Info" property string associated with 'key'
#myProp = imp.getProperties() #returns java.util.Properties
#print 'myProp (really long)'
#print myProp
#print 'patrick'
#myList = str(myProp).split('\r')
#I want' to strip out 'Info=ImageDescription: '
#myList = re.sub('Info=ImageDescription: ', '', str(myList))
#for i in range (0,len(myList)):
# myList[i] = myList[i].split('=')
#print myList[0]
#print myList[1]
#print myList[2]
#print myList[3]
#imp.setProperty('myStr', 1)
#try usinf ImageStack
#myImageStack = imp.getImageStack()
#eventuallly just call imp.getProp(str) which Returns the value from the "Info"
#in the future IJ.openImagehavewant to have option to scale down to 512X512
#run("Scale...", "x=- y=- z=1.0 width=512 height=512 depth=196 interpolation=Bilinear average process create title=20131007_a144_008_ch1-1.tif");
msgStr = " Original Image is: " + str(
imp.width) + " X " + str(imp.height) + " X " + str(
imp.getNSlices())
print msgStr
IJ.log(msgStr)
if imp.getBitDepth() == 16:
msgStr = " Converting to 8-bit..."
print msgStr
IJ.log(msgStr)
IJ.run("8-bit")
if numberOfChannels == 2:
msgStr = " deinterleaving"
print msgStr
IJ.run("Deinterleave", "how=2")
#makes 2 window
#
#ch2
imp2 = IJ.getImage()
fs = FileSaver(imp2)
msgStr = " ch2: Saving deinterleaved 8bit File to: " + outPath2
print msgStr
IJ.log(msgStr)
numSlices = imp2.getNSlices()
if (numSlices > 1):
fs.saveAsTiffStack(outPath2)
else:
fs.saveAsTiff(outPath2)
#max, ch2
if (numSlices > 1):
maxCmdParams = 'start=1' + ' stop=' + str(
numSlices) + ' projection=[Max Intensity]'
IJ.run("Z Project...", maxCmdParams)
#impMax2 = IJ.getImage()
print " Saving 8bit Max File to", outMaxPath2
impMax2 = IJ.getImage()
fs = FileSaver(impMax2)
fs.saveAsTiff(outMaxPath2)
impMax2.changes = 0
impMax2.close()
numSaved += 1
imp2.changes = 0
imp2.close()
#
#ch1
imp1 = IJ.getImage()
fs = FileSaver(imp1)
msgStr = " ch1: Saving deinterleaved 8bit File to" + outPath1
print msgStr
numSlices = imp1.getNSlices()
if (numSlices > 1):
fs.saveAsTiffStack(outPath1)
else:
fs.saveAsTiff(outPath1)
#max, ch1
if (numSlices > 1):
maxCmdParams = 'start=1' + ' stop=' + str(
numSlices) + ' projection=[Max Intensity]'
IJ.run("Z Project...", maxCmdParams)
impMax1 = IJ.getImage()
fs = FileSaver(impMax1)
msgStr = " Saving 8bit Max File to" + outMaxPath1
print msgStr
IJ.log(msgStr)
fs.saveAsTiff(outMaxPath1)
impMax1.changes = 0
impMax1.close()
numSaved += 1
imp1.changes = 0
imp1.close()
elif numberOfChannels == 1: #single channel
fs = FileSaver(imp)
msgStr = " Saving 8bit File to" + outPath
print msgStr
IJ.log(msgStr)
numSlices = imp.getNSlices()
if (numSlices > 1):
fs.saveAsTiffStack(outPath)
else:
fs.saveAsTiff(outPath)
numSaved += 1
#max
if (numSlices > 1):
maxCmdParams = 'start=1' + ' stop=' + str(
numSlices) + ' projection=[Max Intensity]'
IJ.run("Z Project...", maxCmdParams)
impMax = IJ.getImage()
fs = FileSaver(impMax)
print " Saving 8bit Max File to", outMaxPath
fs.saveAsTiff(outMaxPath)
impMax.changes = 0
impMax.close()
imp.changes = 0
imp.close()
else:
print " File was not 16 bit???"
imp.close() #close original
else:
if (not startWithDot) and isTif:
#print " ===================================="
print filename
msgStr = " -> Ignoring .tif:" + filename
print msgStr
IJ.log(msgStr)
msgStr = " bBatchConvertTo8Bitv3.py is Done, Number Opened " + str(
numOpened) + ", Number Saved " + str(numSaved)
print " ==="
print msgStr
print " ==="
IJ.log(msgStr)
from ij import IJ
import sys
image = IJ.getImage()
if image == None:
sys.exit("No open image")
roi = image.getRoi()
if roi == None:
sys.exit("Image has no ROI")
polygon = roi.getPolygon()
if polygon == None:
sys.exit("ROI has no polygon??")
IJ.log("ROI polygon has {} points".format(polygon.npoints))
for i in range(polygon.npoints):
IJ.log("{} {}".format(polygon.xpoints[i], polygon.ypoints[i]))
smtpObj = smtplib.SMTP("smtp.unibas.ch")
smtpObj.sendmail(
sender, recipient,
message % (recipient, filename, total_execution_time_min))
print "Successfully sent email"
except smtplib.SMTPException:
print "Error: unable to send email"
# start the process
execution_start_time = time.time()
source = fix_ij_dirs(source)
all_source_dirs = list_dirs_containing_filetype(source, filetype)
for source in all_source_dirs:
IJ.log("now working on " + source)
print "bigdata= ", str(bigdata)
free_memory_bytes = MemoryTools().totalAvailableMemory()
folder_size_bytes = get_folder_size(source)
if free_memory_bytes / folder_size_bytes < 3.5:
bigdata = True
IJ.log("not enough free RAM, switching to BigData mode (slow)")
allimages = list_all_filenames(source, filetype)
ome_metadata = get_ome_metadata(source, allimages)
write_tileconfig(source, ome_metadata[0], allimages, ome_metadata[4],
ome_metadata[5], ome_metadata[6])
run_GC_stitcher(source)
if bigdata is True:
path = source + "temp/"
def getArea(roi_array = RoiManager.getInstance().getRoisAsArray()):
return [roi.getStatistics().area for roi in roi_array]
area = getArea()
def get_file_info(imp):
img_dir = imp.getOriginalFileInfo().directory
img_file = imp.getOriginalFileInfo().fileName
if img_dir and img_file is not None:
name, ext = os.path.splitext(img_file)
return img_dir, name
img_dir, file_name = get_file_info(imp)
IJ.log("\\Clear")
IJ.log(
"directory"+ "\t" +
"file_name"+ "\t" +
"Roi_id" + "\t" +
"frame_position" + "\t" +
"area" + "\t" +
"xcentroid" + "\t" +
"ycentroid" + "\t" +
"xpoint" + "\t" +
"ypoint"
)
def write_log(img_dir, file_name, roi_name, frame_position, area, xcentroid, ycentroid, xpoint, ypoint):
for i in range(len(roi_array)):
def process_cell(cs):
IJ.log('Cell at {}'.format(cs.center))
cs.set_calibration()
# filter the image
if method != 'none':
IJ.log('Applying ' + method + ' 3D filtering')
filter_cellstack(cs, method=method, sigma=sigma)
# cell stats
loc_max = local_max(cs, cs.center)
IJ.log('Local max in {}, value: {}'.format(loc_max, cs.get_voxel(loc_max)))
if recenter:
cs.center = loc_max
loc_mean = local_mean(cs, r0=r0, r1=r1, r2=r2, weight=meanw)
IJ.log('Local mean: ' + str(loc_mean))
tab = radial_distribution_3D(cs, max_rad=max_rad)
radius = radius_thresh(tab, loc_mean)
IJ.log('Radius: ' + str(radius))
# find local maxima in the whole image, even those far from the cell center
peaks = find_maxima(cs, radius / 2, loc_mean)
IJ.log('Peaks: ' + str(peaks))
# run mean shift with maxima that are closer to the cell center
IJ.log('Applying mean shift...')
centroid = ms_center(cs, radius, peaks, ms_sigma, loc_mean)
IJ.log('New center: ' + str(centroid))
# update the centroid
cs.center = centroid
# apply local_mean thresh to radial distribution
new_loc_mean = local_mean(cs,
r0=radius - 2,
r1=radius + 2,
r2=r2,
weight=meanw)
IJ.log('New local mean: ' + str(new_loc_mean))
new_tab = radial_distribution_3D(cs, max_rad=max_rad)
new_radius = radius_thresh(new_tab, new_loc_mean)
IJ.log('New radius: ' + str(new_radius))
# apply a different look up table for display
if cmap != 'default':
apply_lut(cs, cmap)
# show the cell stack positioned in the cell center
cs.setSlice(cs.center[2] + 1)
if circle:
# circle_roi(cs, radius, Color.YELLOW)
circle_roi(cs, new_radius, Color.RED)
# draw point for new centroid
# point = PointRoi(cs.center[0], cs.center[1])
# point.setSize(2)
# point.setColor(Color.RED)
# cs.setRoi(point)
cs.show()
w = cs.getWindow()
w.setLocationAndSize(1550, 400, 300, 300)
fragments_group_name = "Isolated synaptic terminals"
# FIXME: And also hardcode the separation:
x_separation = 4.0
z_separation = 50.0
radius_node_class = Class.forName('ini.trakem2.display.Treeline$RadiusNode')
# Set up the JDBC connection:
try:
Class.forName("org.postgresql.Driver")
except:
IJ.log("Failed to find the postgresql driver...")
raise
conf = {}
fp = open(os.path.join(os.environ['HOME'],'.catmaid-db'))
for line in fp:
line = line.strip()
if len(line) == 0:
continue
m = re.search('(\S*)\s*:\s*(\S*)', line)
if m:
conf[m.group(1)] = m.group(2)
fp.close()
database_url = "jdbc:postgresql://%s/%s" % (conf['host'], conf['database'])
regParams.featuresModelIndex = 1
regParams.sift.fdBins = 8
regParams.sift.fdSize = 4
regParams.sift.initialSigma = 1.6
regParams.sift.maxOctaveSize = 1024
regParams.sift.minOctaveSize = 64
regParams.sift.steps = 6
regParams.interpolate = True
regParams.maxEpsilon = 25
regParams.minInlierRatio = 0
regParams.rod = 0.92
# perform alignment
if executeAlignment:
fc.rigidAlignment(projectPath,
regParams,
name=namePlugin,
boxFactor=boxFactor)
# open the project and save all transforms of all tiles in all sections
IJ.log('Saving the coordinates transforms of each patch of each layer')
project, loader, layerset, nLayers = fc.openTrakemProject(projectPath)
transformsPath = os.path.join(os.path.dirname(projectPath),
namePlugin + 'transforms.txt')
fc.writeAllAffineTransforms(project, transformsPath)
fc.closeProject(project)
fc.terminatePlugin(namePlugin, MagCFolder)
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 measure_multi_roiset(name_list, tif_list, roiset_list):
if name_list and tif_list and roiset_list is not None:
for name in name_list:
for tif in tif_list:
for roiset in roiset_list:
if name in roiset and name in tif:
measure_rm(tif, roiset)
IJ.log("\\Clear")
IJ.log("Directory" + "\t" + "File" + "\t" + "Roi_id" + "\t" + "Area" + "\t" +
"Integrated_density" + "\t" + "Mean_intensity")
measure_multi_roiset(name_list, tif_list, roiset_list)
from ij import IJ
from ij.plugin.frame import RoiManager
from ij.gui import Roi
# 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", "{}{}_background.csv".format(path, measurements_filename))
IJ.selectWindow("Results")
IJ.run("Close")
IJ.log("Measurements saved at {}{}.csv".format(path, measurements_filename))
def loadStacks():
IJ.log(" ")
IJ.log("oib_tiff_converter_ver1.0; 08/24/2018; [email protected]")
IJ.log("tested with: ImageJ2; FIJI update on 8/24/2018")
srcDir = DirectoryChooser("Choose directory").getDirectory()
if not srcDir:
return
sId = ".oib"
#stackType = getChoice("", ["normal stack", "virtual stack"])
stackType = "normal stack" # Concatenate seems not to work with virtual
#filepath = srcDir +"tiff"
#print(filepath)
iStack = 0
for root, directories, filenames in os.walk(srcDir):
for filename in filenames:
path = os.path.join(root, filename)
if not (sId in filename):
continue
IJ.log("opening " + filename)
if stackType == "virtual stack":
IJ.run(
"Bio-Formats Importer", "open=" + path +
" color_mode=Default view=[Standard ImageJ] stack_order=Default use_virtual_stack"
)
else:
IJ.run(
"Bio-Formats Importer", "open=" + path +
" color_mode=Default view=[Standard ImageJ] stack_order=Default"
)
# first stack
if iStack == 0:
imp = IJ.getImage()
imp.setTitle(
filename +
".tiff") # in order of the combining to work additive
nSlices = imp.getNSlices()
nChannels = imp.getNChannels()
nTimeFrames = imp.getNFrames()
imp.setDimensions(nChannels, nSlices, nTimeFrames)
comp = CompositeImage(imp, CompositeImage.COLOR)
comp.show()
fs = FileSaver(comp)
fs.saveAsTiff(srcDir + filename + "_hyperstack" + ".tiff")
else:
imp = IJ.getImage()
comp = CompositeImage(imp, CompositeImage.COLOR)
comp.show()
fs = FileSaver(comp)
fs.saveAsTiff(srcDir + filename + "_hyperstack" + ".tiff")
iStack = iStack + 1
print(iStack)
#IJ.log("nChannels = "+str(nChannels))
#IJ.log("nSlices = "+str(nSlices))
#IJ.log("nFrames = "+str(nTimeFrames*iStack))
#IJ.run("Stack to Hyperstack...", "order=xyczt(default) channels="+str(nChannels)+" slices="+str(nSlices)+" frames="+str(nTimeFrames)+" display=Color");
IJ.log(
"convert back to normal stack: Image...Hyperstacks...Hyperstack to Stack"
)
original) # duplicate the original image, only the CFOV
CFOV.setTitle("CFOV")
CFOV.show()
######### Nema process including Re-bin image to larger pixels ################################################################################
desired_pixel_width = getPixel(
) # 6.4 mm default, remember tolerance is +/-30%
current_pixel_width = CFOV.getCalibration(
).pixelWidth #get pixel width, 1.16 mm
shrink_factor = int(desired_pixel_width /
current_pixel_width) # must be an integer
IJ.run(CFOV, "Bin...", "x=" + str(shrink_factor) + " y=" + str(shrink_factor) +
" bin=Sum") # run the bin plugin
IJ.run(CFOV, "Convolve...",
"text1=[1 2 1\n2 4 2\n1 2 1\n] normalize") # apply the nema filter
######## Analyse pixels
CFOVpixels = CFOV.getProcessor().convertToFloat().getPixels(
) # access processor, get float array of pixels
CFOVmean = sum(CFOVpixels) / len(CFOVpixels)
#pixels_above_threshold = filter(lambda pix: pix > 0.75*mean, pixels) # return a new array with values above zero, use anonymous function
CFOVunifiormity = getUniformity(min(CFOVpixels), max(CFOVpixels))
######## Print results
results_string = "The integral uniformity of the CFOV is: " + str(
CFOVunifiormity) + "% for pixel size of " + str(
desired_pixel_width) + " mm"
IJ.log(results_string)
IJ.showMessage(results_string)
gui.showDialog()
HOST = gui.getNextString()
PORT = int(gui.getNextString())
gui = GenericDialogPlus("Parameters")
gui.addFileField("Select an input file (*.tif) : ", "")
gui.showDialog()
if gui.wasOKed():
LOCAL_IMAGE_FILENAME = gui.getNextString()
LOCAL_RESULT_FILENAME = LOCAL_IMAGE_FILENAME + "_prediction.tif"
jsch = JSch()
# SSH Connection to DeepLearning server
IJ.log("-- Connection to Deep Learning Server")
time0 = time.time()
session = jsch.getSession("root", HOST, PORT)
session.setPassword("12345")
session.setConfig("StrictHostKeyChecking", "no")
session.connect()
IJ.log("Execution Time : " + str(time.time() - time0) + " seconds")
if (True):
#Download results
channel = session.openChannel("sftp")
channel.connect()
IJ.open(LOCAL_IMAGE_FILENAME)
IJ.log("Opening : " + LOCAL_IMAGE_FILENAME)
IJ.log('-- Uploading image to server ... please wait')
channel.put(LOCAL_IMAGE_FILENAME, "/content/toprocess.tif")
){kind=link}