def setReaderOptions(imagefile, stitchtiles=False,
setflatres=True,
setconcat=False,
openallseries=False,
showomexml=False,
attach=False,
autoscale=True):
czi_options = DynamicMetadataOptions()
czi_options.setBoolean("zeissczi.autostitch", stitchtiles)
czi_options.setBoolean("zeissczi.attachments", attach)
# set the option for the CZIReader
czireader = ImportTools.setCZIReaderOptions(imagefile, czi_options, setflatres=setflatres)
# Set the preferences in the ImageJ plugin
# Note although these preferences are applied, they are not refreshed in the UI
Prefs.set("bioformats.zeissczi.allow.autostitch", str(stitchtiles).lower())
Prefs.set("bioformats.zeissczi.include.attachments", str(attach).lower())
# set the option for the BioFormats import
reader_options = ImporterOptions()
reader_options.setOpenAllSeries(openallseries)
reader_options.setShowOMEXML(showomexml)
reader_options.setConcatenate(setconcat)
reader_options.setAutoscale(autoscale)
reader_options.setStitchTiles(stitchtiles)
reader_options.setId(imagefile)
return reader_options, czireader
def getImps(fpath): opt = IO() opt.setId(fpath) opt.setOpenAllSeries(True) impA = BF.openImagePlus(opt) print "Series number: " + str(len(impA)) #impA = BF.openImagePlus() return impA
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 run(imagefile, useBF=True,
series=0,
filtertype='MEDIAN',
filterradius='5'):
#log.log(LogLevel.INFO, 'Image Filename : ' + imagefile)
log.info('Image Filename : ' + imagefile)
# get basic image metainfo
metainfo = get_metadata(imagefile, imageID=series)
for k, v in metainfo.items():
#log.log(LogLevel.INFO, str(k) + ' : ' + str(v))
log.info(str(k) + ' : ' + str(v))
if not useBF:
# using IJ static method
imp = IJ.openImage(imagefile)
if useBF:
# initialize the importer options for BioFormats
options = ImporterOptions()
options.setOpenAllSeries(True)
options.setShowOMEXML(False)
options.setConcatenate(True)
options.setAutoscale(True)
options.setId(imagefile)
options.setStitchTiles(True)
# open the ImgPlus
imps = BF.openImagePlus(options)
imp = imps[series]
# apply the filter
if filtertype != 'NONE':
# apply filter
#log.log(LogLevel.INFO, 'Apply Filter : ' + filtertype)
#log.log(LogLevel.INFO, 'Filter Radius : ' + str(filterradius))
log.info('Apply Filter : ' + filtertype)
log.info('Filter Radius : ' + str(filterradius))
# apply the filter based on the chosen type
imp = apply_filter(imp,
radius=filterradius,
filtertype=filtertype)
if filtertype == 'NONE':
#log.log(LogLevel.INFO, 'No filter selected. Do nothing.')
log.info('No filter selected. Do nothing.')
return imp
def concatenateImagePlus(files, outfile):
"""concatenate images contained in files and save in outfile"""
'''
if len(files) == 1:
IJ.log(files[0] + " has only one time point! Nothing to concatenate!")
return
'''
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)
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:
IJ.log(" Add file " + 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:
traceback.print_exc()
IJ.log(file + " failed to concatenate!")
IJ.showProgress(files.index(file), len(files))
concatImgPlus.setStack(concatStack)
concatImgPlus.setCalibration(image.getCalibration())
if len(images) > 1:
outfileP = addPositionName(i+1,outfile)
IJ.saveAs(concatImgPlus, "Tiff", outfileP)
else:
IJ.saveAs(concatImgPlus, "Tiff", outfile)
concatImgPlus.close()
def open_czi_series(file_name, series_number, rect=False):
# see https://downloads.openmicroscopy.org/bio-formats/5.5.1/api/loci/plugins/in/ImporterOptions.html
options = ImporterOptions()
options.setId(file_name)
options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE)
# select image to open
options.setOpenAllSeries(False)
options.setAutoscale(False)
options.setSeriesOn(series_number, True)
# default is not to crop
options.setCrop(False)
if rect: # crop if asked for
options.setCrop(True)
options.setCropRegion(series_number, Region(rect[0], rect[1], rect[2], rect[3]))
imps = BF.openImagePlus(options)
return imps[0]
def trans_to_tif(file_list, overwrite = False):
if file_list is not None:
for path in file_list:
opts = ImporterOptions()
opts.setId(path)
opts.setVirtual(True)
opts.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE)
opts.setOpenAllSeries(True)
process = ImportProcess(opts)
try:
process.execute()
except:
pass
else:
process.execute()
try:
imps = ImagePlusReader(process).openImagePlus()
except:
IJ.log(path + "\n" + "This file was not properly processed")
pass
else:
dir_name = os.path.dirname(path)
file_name = os.path.basename(os.path.splitext(path)[0])
save_dir = os.path.join(dir_name, file_name)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
imps = ImagePlusReader(process).openImagePlus()
for i, imp in enumerate(imps):
save_path = os.path.join(save_dir, file_name + "_pos{}.tif".format(i + 1))
if not os.path.exists(save_path):
IJ.saveAsTiff(imp, save_path)
IJ.freeMemory()
else:
if overwrite:
IJ.saveAsTiff(imp, save_path)
IJ.freeMemory()
else:
pass
def readbf(imagefile, metainfo,
setflatres=False,
readpylevel=0,
setconcat=False,
openallseries=True,
showomexml=False,
autoscale=True,
stitchtiles=True):
# initialize the importer options
options = ImporterOptions()
options.setOpenAllSeries(openallseries)
options.setShowOMEXML(showomexml)
options.setConcatenate(setconcat)
options.setAutoscale(autoscale)
options.setId(imagefile)
options.setStitchTiles(stitchtiles)
# in case of concat=True all series set number of series = 1
# and set pyramidlevel = 0 (1st level) since there will be only one
# unless setflatres = True --> read pyramid levels
series = metainfo['SeriesCount_BF']
if setconcat and setflatres:
series = 1
readpylevel = 0
metainfo['Pyramid Level Output'] = readpylevel
# open the ImgPlus
imps = BF.openImagePlus(options)
# read image data using the specified pyramid level
imp, slices, width, height, pylevel = ImageTools.getImageSeries(imps, series=readpylevel)
metainfo['Output Slices'] = slices
metainfo['Output SizeX'] = width
metainfo['Output SizeY'] = height
return imp, metainfo
def run(imagefile, useBF=True, series=0):
log.info('Image Filename : ' + imagefile)
if not useBF:
# using IJ static method
imp = IJ.openImage(imagefile)
if useBF:
# initialize the importer options
options = ImporterOptions()
options.setOpenAllSeries(True)
options.setShowOMEXML(False)
options.setConcatenate(True)
options.setAutoscale(True)
options.setId(imagefile)
# open the ImgPlus
imps = BF.openImagePlus(options)
imp = imps[series]
# apply the filter
if FILTERTYPE != 'NONE':
# apply filter
log.info('Apply Filter : ' + FILTERTYPE)
log.info('Filter Radius : ' + str(FILTER_RADIUS))
# apply the filter based on the choosen type
imp = apply_filter(imp,
radius=FILTER_RADIUS,
filtertype=FILTERTYPE)
if FILTERTYPE == 'NONE':
log.info('No filter selected. Do nothing.')
return imp
def open_fli(filepth):
# load the dataset
options = ImporterOptions()
options.setId(filepth)
options.setOpenAllSeries(1)
imps = BF.openImagePlus(options)
for imp in imps:
title = imp.getTitle()
if title.find("Background Image")==-1:
img = imp
imp.close()
else:
bkg = imp
imp.close()
ic = ImageCalculator()
img2 = ic.run("Subtract create 32-bit stack",img,bkg)
#copy the metadata
props = img.getProperties()
for prop in props:
img2.setProperty(prop,props.getProperty(prop))
img.close()
bkg.close()
return img2
def main():
Interpreter.batchMode = True
if (lambda_flat == 0) ^ (lambda_dark == 0):
print ("ERROR: Both of lambda_flat and lambda_dark must be zero,"
" or both non-zero.")
return
lambda_estimate = "Automatic" if lambda_flat == 0 else "Manual"
print "Loading images..."
# Use BioFormats reader directly to determine dataset dimensions without
# reading every single image. The series count (num_images) is the one value
# we can't easily get any other way, but we might as well grab the others
# while we have the reader available.
bfreader = ImageReader()
bfreader.id = str(filename)
num_images = bfreader.seriesCount
num_channels = bfreader.sizeC
width = bfreader.sizeX
height = bfreader.sizeY
bfreader.close()
# The internal initialization of the BaSiC code fails when we invoke it via
# scripting, unless we explicitly set a the private 'noOfSlices' field.
# Since it's private, we need to use Java reflection to access it.
Basic_noOfSlices = Basic.getDeclaredField('noOfSlices')
Basic_noOfSlices.setAccessible(True)
basic = Basic()
Basic_noOfSlices.setInt(basic, num_images)
# Pre-allocate the output profile images, since we have all the dimensions.
ff_image = IJ.createImage("Flat-field", width, height, num_channels, 32);
df_image = IJ.createImage("Dark-field", width, height, num_channels, 32);
print("\n\n")
# BaSiC works on one channel at a time, so we only read the images from one
# channel at a time to limit memory usage.
for channel in range(num_channels):
print "Processing channel %d/%d..." % (channel + 1, num_channels)
print "==========================="
options = ImporterOptions()
options.id = str(filename)
options.setOpenAllSeries(True)
# concatenate=True gives us a single stack rather than a list of
# separate images.
options.setConcatenate(True)
# Limit the reader to the channel we're currently working on. This loop
# is mainly why we need to know num_images before opening anything.
for i in range(num_images):
options.setCBegin(i, channel)
options.setCEnd(i, channel)
# openImagePlus returns a list of images, but we expect just one (a
# stack).
input_image = BF.openImagePlus(options)[0]
# BaSiC seems to require the input image is actually the ImageJ
# "current" image, otherwise it prints an error and aborts.
WindowManager.setTempCurrentImage(input_image)
basic.exec(
input_image, None, None,
"Estimate shading profiles", "Estimate both flat-field and dark-field",
lambda_estimate, lambda_flat, lambda_dark,
"Ignore", "Compute shading only"
)
input_image.close()
# Copy the pixels from the BaSiC-generated profile images to the
# corresponding channel of our output images.
ff_channel = WindowManager.getImage("Flat-field:%s" % input_image.title)
ff_image.slice = channel + 1
ff_image.getProcessor().insert(ff_channel.getProcessor(), 0, 0)
ff_channel.close()
df_channel = WindowManager.getImage("Dark-field:%s" % input_image.title)
df_image.slice = channel + 1
df_image.getProcessor().insert(df_channel.getProcessor(), 0, 0)
df_channel.close()
print("\n\n")
template = '%s/%s-%%s.tif' % (output_dir, experiment_name)
ff_filename = template % 'ffp'
IJ.saveAsTiff(ff_image, ff_filename)
ff_image.close()
df_filename = template % 'dfp'
IJ.saveAsTiff(df_image, df_filename)
df_image.close()
print "Done!"
def imageprojector(channels, timelist_unsorted, dirs):
""" Projects .lif timepoints and saves in a common directory,
as well as channel separated directories. """
# Defines in path
path = str(Experiment)
# BF Importer
options = ImporterOptions()
try:
options.setId(path)
except Exception(e):
print str(e)
options.setOpenAllSeries(True)
options.setSplitTimepoints(True)
options.setSplitChannels(True)
imps = BF.openImagePlus(options)
timelist = [x for item in timelist_unsorted for x in repeat(item, channels)]
timelist, imps = zip(*sorted(zip(timelist, imps)))
counter_C0 = -1
counter_C1 = -1
counter_C2 = -1
# Opens all images, splits channels, z-projects and saves to disk
for imp in (imps):
# Projection, Sum Intensity
project = ZProjector()
project.setMethod(ZProjector.SUM_METHOD)
project.setImage(imp)
project.doProjection()
impout = project.getProjection()
projection = impout.getTitle()
try:
# Saves channels to disk,
# add more channels here if desired,
# remember to define new counters.
if "C=0" in projection:
counter_C0 += 1
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections"],
"Scan" + str(counter_C0).zfill(3) + "C0"))
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections_C0"],
"Scan" + str(counter_C0).zfill(3) + "C0"))
elif "C=1" in projection:
counter_C1 += 1
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections"],
"Scan" + str(counter_C1).zfill(3) + "C1"))
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections_C1"],
"Scan" + str(counter_C1).zfill(3) + "C1"))
elif "C=2" in projection:
counter_C2 += 1
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections"],
"Scan" + str(counter_C2).zfill(3) + "C2"))
IJ.saveAs(impout, "TIFF", os.path.join(dirs["Projections_C2"],
"Scan" + str(counter_C2).zfill(3) + "C2"))
except IOException:
print "Directory does not exist"
raise
IJ.log("Images projected and saved to disk")
for m in masks:
m.close()
mergedmask.setTitle(imagetitle + "-"+str(index)+"-mask.tif")
outputfile = path.join(outdir, mergedmask.getTitle())
IJ.saveAs(mergedmask, "TIFF", outputfile)
# Main code
inputdir = str(inputdir) # convert from File object to String
outputdir = str(outputdir) # convert from File object to String
if not path.isdir(inputdir):
print inputdir, " does not exist or is not a directory."
else:
size = 10000
imp_options = ImporterOptions()
imp_options.setOpenAllSeries(True)
imp_options.setConcatenate(True)
if not path.isdir(outputdir):
# create output directory if it does not exist
os.makedirs(outputdir)
filenames = os.listdir(inputdir) # get list of files to process
imagefiles = [f for f in filenames if f.split(".")[-1] in ['tif','tiff','nd2']]
# close existing Summary window
rtframe = WindowManager.getFrame("Summary")
if rtframe is not None:
rtframe.close()
for img_file in imagefiles:
# execute the following block for each file
fullpath = path.join(inputdir, img_file)
print stages
print folder
print basename
for c in channels:
for s in stages:
print basename+"_w"+c+channels[c]+"_s"+s+".stk"
"""
######################### Pre-process image files
# load all series from nd file, optionally create MIP, save merged channel files
# "raw" stitching (with tmp-renamed nd) only if not multichannel and not doMIP or not zstack
if (zstack and doMIP) or multichannel:
print "Resaving intermediate files"
options = ImporterOptions()
options.setId(ndPath)
options.setOpenAllSeries(True)
# TODO get number of series and loop over each series instead of opening all at once
imps = BF.openImagePlus(options)
pixelWidth = imps[0].getCalibration().pixelWidth
pixelHeight = imps[0].getCalibration().pixelHeight
fileNamePattern = basename + "_s{i}.tif"
for imp in imps:
m4 = re.match('.+Stage(\d+).+', imp.getTitle())
savePath = folder + basename + "_s" + m4.group(1) + ".tif"
if doMIP:
mip = getMIP(imp)
imp.close()
print "Saving MIP as", savePath
IJ.saveAs(mip, "Tiff", savePath);
mip.close()
else:
# @File(label="Input file") input # @File(label="Output folder") output # Splits multi-point CZI files into multiple TIFFs using Bio-Formats. # # Stefan Helfrich (University of Konstaz), 05/09/2016 from ij import IJ from loci.plugins import BF from loci.plugins.in import ImporterOptions import os srcPath = input.getAbsolutePath() # using LOCI BioFormats settings = ImporterOptions() settings.setId(srcPath) settings.setOpenAllSeries(True) settings.setVirtual(True) settings.setWindowless(True) imps = BF.openImagePlus(settings) for i in range(0, len(imps)): currentImp = imps[i] filename = os.path.split(srcPath)[1] filenameWithoutExtension = os.path.splitext(filename)[0] IJ.saveAs(currentImp, "TIFF", output.getAbsolutePath() + "/" + filenameWithoutExtension + "-" + str(i) + ".tif")
def bfopenall(path): options = ImporterOptions(); options.setId(path); options.setOpenAllSeries(True); return BF.openImagePlus(options);
def main():
Interpreter.batchMode = True
if (lambda_flat == 0) ^ (lambda_dark == 0):
print ("ERROR: Both of lambda_flat and lambda_dark must be zero,"
" or both non-zero.")
return
lambda_estimate = "Automatic" if lambda_flat == 0 else "Manual"
print "Loading images..."
options = ImporterOptions()
options.setId(str(filename))
options.setOpenAllSeries(True)
options.setConcatenate(True)
options.setSplitChannels(True)
imps = BF.openImagePlus(options)
num_channels = len(imps)
w = imps[0].getWidth()
h = imps[0].getHeight()
ff_imp = IJ.createImage("Flat-field", w, h, num_channels, 32);
df_imp = IJ.createImage("Dark-field", w, h, num_channels, 32);
basic = Basic()
Basic_noOfSlices = Basic.getDeclaredField('noOfSlices')
Basic_noOfSlices.setAccessible(True)
for channel, imp in enumerate(imps):
title = imp.getTitle()
print "Processing:", title
x, y, c, z, t = imp.getDimensions()
assert z == 1 and c == 1
imp.setDimensions(1, t, 1)
WindowManager.setTempCurrentImage(imp)
Basic_noOfSlices.setInt(basic, t)
basic.exec(
imp, None, None,
"Estimate shading profiles", "Estimate both flat-field and dark-field",
lambda_estimate, lambda_flat, lambda_dark,
"Ignore", "Compute shading only"
)
ff_channel = WindowManager.getImage('Flat-field:' + title)
ff_channel.copy()
ff_imp.setSlice(channel + 1)
ff_imp.paste()
ff_channel.close()
df_channel = WindowManager.getImage('Dark-field:' + title)
df_channel.copy()
df_imp.setSlice(channel + 1)
df_imp.paste()
df_channel.close()
imp.close()
# Setting the active slice back to 1 seems to fix an issue where
# the last slice was empty in the saved TIFFs. Not sure why.
ff_imp.setSlice(1)
df_imp.setSlice(1)
ff_filename = '%s/%s-ffp-basic.tif' % (output_dir, experiment_name)
IJ.saveAsTiff(ff_imp, ff_filename)
ff_imp.show()
ff_imp.close()
df_filename = '%s/%s-dfp-basic.tif' % (output_dir, experiment_name)
IJ.saveAsTiff(df_imp, df_filename)
df_imp.show()
df_imp.close()
print "Done!"
