def run():
srcDir = DirectoryChooser("Choose directory").getDirectory()
if not srcDir:
return
targetDir = DirectoryChooser("Choose target directory").getDirectory()
if targetDir is None:
# User canceled the dialog
return
sId = ".tiff"
for root, directories, filenames in os.walk(srcDir):
for filename in filenames:
path = os.path.join(root, filename)
if not (sId in filename):
continue
cs = ChannelSeparator()
cs.setId(path)
print "cs", cs
bf = BFVirtualStack(path, cs, False, False, False)
for sliceIndex in xrange(1, bf.getSize() + 1):
print "Processing slice", sliceIndex
ip = bf.getProcessor(sliceIndex)
sliceFileName = os.path.join(targetDir + filename + "_" +
str(sliceIndex) + ".tiff")
print "writing ", sliceFileName
FileSaver(ImagePlus(str(sliceIndex),
ip)).saveAsTiff(sliceFileName)
def run():
srcDir = DirectoryChooser("Chose Source Dir").getDirectory()
if srcDir is None:
IJ.log("Choose Dir Canceled!")
return
outDir = DirectoryChooser("Chose >Output< Dir").getDirectory()
if outDir is None:
IJ.log("Output to same dir as source.")
ourtDir = srcDir
refImageId = getRefIdDialog()
if refImageId is None:
IJ.log("Select Reference Image Canceled!")
return
for root, directories, filenames in os.walk(srcDir):
for filename in filenames:
# Skip non-ND2 files
if not filename.endswith(".nd2"):
continue
inpath = os.path.join(root, filename)
# outfn = "reg_" + os.path.splitext(filename)[0] + ".tif"
# outpath = os.path.join(outDir, outfn)
# if os.path.exists(outpath):
# print "Skipped, already exists: ", outfn
# continue
IJ.log("Registering\n" + filename)
imp = regBf(fn=inpath, refId=refImageId)
if imp is None:
IJ.log("Skipped, wrong with registration:\n" + filename)
continue
else:
# fs = FileSaver(imp)
# fs.saveAsTiffStack(outpath)
# IJ.saveAsTiff(imp, outpath)
# print "Registered and saved to ", outfn
splittedimps = ChannelSplitter.split(imp)
for i, simp in enumerate(splittedimps):
outfn = "reg_" + os.path.splitext(
filename)[0] + "_C_" + str(i) + ".tif"
outpath = os.path.join(outDir, outfn)
if os.path.exists(outpath):
IJ.log("Skipped saving, file already exists:\n" +
outfn)
continue
IJ.saveAsTiff(simp, outpath)
IJ.log("Registered and saved to\n" + outfn)
IJ.log("done!")
def file_location_chooser(default_directory):
# input
dc = DirectoryChooser('Select the root folder for loading input images')
input_root = dc.getDirectory()
if input_root is None:
print("no input root")
# output
DirectoryChooser.setDefaultDirectory(default_directory)
dc = DirectoryChooser('Select the root folder for saving output')
output_root = dc.getDirectory()
if output_root is None:
print("no output root")
return input_root, output_root
def run():
bPrintLog(' ', 0)
bPrintLog('=====================================', 0)
bPrintLog('Running bAlign_Batch_v6', 0)
bPrintLog('=====================================', 0)
if len(sys.argv) < 2:
print " We need a hard-drive folder with .tif stacks as input"
print " Usage: ./fiji-macosx bALign_Batch_6 <full-path-to-folder>/"
# Prompt user for a folder
sourceFolder = DirectoryChooser(
"Please Choose A Directory Of .tif Files").getDirectory()
if not sourceFolder:
return 0
else:
sourceFolder = sys.argv[1] #assuming it ends in '/'
if not os.path.isdir(sourceFolder):
bPrintLog('\nERROR: run() did not find folder: ' + sourceFolder + '\n',
0)
return 0
if (Options(sourceFolder)):
runOneFolder(sourceFolder)
bPrintLog('=====================================', 0)
bPrintLog('Done bAlign_Batch_v6', 0)
bPrintLog('=====================================', 0)
bPrintLog(' ', 0)
def run():
sId = IJ.getString("Filenames contain:", "T0000")
srcDir = DirectoryChooser("Choose!").getDirectory()
if not srcDir:
# user canceled dialog
return
# Assumes all files have the same size
stack = None
for root, directories, filenames in os.walk(srcDir):
for filename in filenames:
# Skip non-TIFF files
if not (sId in filename):
continue
print(filename)
path = os.path.join(root, filename)
# Upon finding the first image, initialize the VirtualStack
imp = IJ.openImage(path)
if stack is None:
# stack = VirtualStack(imp.width, imp.height, None, srcDir)
stack = ImageStack(imp.width, imp.height)
# Add a slice to the virtual stack, relative to the srcDir
#
#stack.addSlice(path[len(srcDir):])
# Add a slice to the real stack
#
stack.addSlice(filename, imp.getProcessor())
# Make a ImagePlus from the stack
ImagePlus("Stack from subdirectories", stack).show()
def choose_dir_al(self, e):
dc = DirectoryChooser('Choose a bob_py experiment folder')
self.dir_path = dc.getDirectory()
self.choose_dir_textField.setText(self.dir_path)
self.got_exper(self.dir_path)
def run():
helpText = "This program will batch convert any tif image to 8-bit greyscale, " + \
"and empty calibration infomation.\n\n" + \
">> Press OK to Select a directory of TIFF images."
MessageDialog(IJ.getInstance(), "Empty Calibration Guide", helpText)
srcDir = DirectoryChooser("Chose Source Dir").getDirectory()
if srcDir is None:
IJ.log("Choose Dir Canceled!")
return
for root, directories, filenames in os.walk(srcDir):
for filename in filenames:
if not filename.endswith(".tif"):
continue
imgPath = os.path.join(root, filename)
outPath = os.path.join(root, "decal-" + filename)
imp = IJ.openImage(imgPath)
imp.setCalibration(Calibration())
ic = ImageConverter(imp)
ic.convertToGray8()
IJ.saveAsTiff(imp, outPath)
print "removed calibration and saved to ", os.path.basename(
outPath)
def obtain_prefixes(self):
self.sourceDir = DirectoryChooser(
"Choose directory to load stack from").getDirectory()
os.chdir(self.sourceDir)
curdir = os.getcwd()
listdire = os.listdir(curdir)
prefixlist = []
prefix_len = JOptionPane.showInputDialog(
None,
"how long is the file prefix to group by?(integer value only)")
for name in listdire:
if ".tif" in name:
prefixname = name[:int(prefix_len)]
prefixlist.append(prefixname)
unique_prefix = sorted(set(prefixlist))
self.pref_dict = {}
for a in unique_prefix:
pref_list = []
for b in listdire:
if b.startswith(a):
pref_list.append(b)
self.pref_dict[a] = pref_list
return self.pref_dict
def run():
imp = IJ.getImage()
if imp is None:
return
if not imp.isHyperStack():
print "Not a hyper stack!"
return
if 1 == imp.getNFrames():
print "There is only one time frame!"
return
if 1 == imp.getNSlices():
print "To register slices of a stack, use 'Register Virtual Stack Slices'"
return
dc = DirectoryChooser("Choose target folder")
target_folder = dc.getDirectory()
if target_folder is None:
return # user canceled the dialog
if not validate(target_folder):
return
gd = GenericDialog("Options")
channels = []
for ch in range(1, imp.getNChannels() + 1):
channels.append(str(ch))
gd.addChoice("channel:", channels, channels[0])
gd.showDialog()
if gd.wasCanceled():
return
channel = gd.getNextChoiceIndex() + 1 # zero-based
vs_imp = create_registered_hyperstack(imp, target_folder, channel)
vs_imp.show()
def get_tif_list(parent_dir=DirectoryChooser("Choose").getDirectory()):
if parent_dir is not None:
tif_list = glob.glob(parent_dir + "*" + ".tif")
return tif_list
else:
pass
def get_file_list():
parent_dir = DirectoryChooser("Choose").getDirectory()
if parent_dir is not None:
file_list = glob.glob(parent_dir + "*")
return file_list
else:
pass
def getDir():
dc = DirectoryChooser("Choose a folder")
sourcePath = dc.getDirectory()
if sourcePath is None:
print "User canceled the dialog!"
else:
print "Selected folder:", sourcePath
targetPath = sourcePath + '_figs/' #figure out how to mkdir in script
return sourcePath, targetPath
def choose_folder():
dc = DirectoryChooser("Choose a folder.")
folder = dc.getDirectory()
if folder is None:
print("User canceled the dialog.")
else:
print("Selected folder:", folder)
return folder
def run(debug=False):
srcDir = DirectoryChooser("Batch Splitter: Chose Source Dir").getDirectory()
# print srcDir
# print type(srcDir)
if srcDir is None:
return
sumf = open(os.path.join(srcDir, 'summary.z.txt'), 'w')
# fn = r'e:\Data\data\zby\imaging\20140627.imaging.alignment.z\526-4eGH146GC3-mCherry001.nd2'
# # fn = r'e:\Data\data\zby\imaging\20140627.imaging.alignment.z\526-4eGH146GC3-mCherry011.nd2'
# outfn = r'e:\Data\data\zby\imaging\20140627.imaging.alignment.z\526-4eGH146GC3-mCherry001.txt'
zString = ["Z position for position, plane #01", "Z position for position, plane #001", "Z position for position #1, plane #1", "dZStep", "dZLow", "dZPos", "dZHigh"]
for fn in os.listdir(srcDir):
# Skip non-ND2 files
if not fn.endswith(".nd2"):
continue
# get input and output filenames
fullfn = os.path.join(srcDir, fn)
outfn = os.path.splitext(fn)[0] + ".z.txt"
fulloutfn = os.path.join(srcDir, outfn)
# if os.path.exists(fulloutfn):
# print "Skipped, already exists: ", outfn
# continue
print "Reading ", fn
sumf.write(fn)
sumf.write('\n')
op = ImporterOptions()
op.setId(fullfn)
process = ImportProcess(op)
process.execute()
meta = process.getOriginalMetadata()
print "Writing", fulloutfn
# if debug:
# print meta.getMetadataString('\t')
# f.write('\n')
f = open(fulloutfn, 'w')
for k in meta.keySet():
if debug and 'Z' in k:
line = ''.join([k, '\t', str(meta[k])])
f.write(line)
f.write('\n')
if k in zString:
line = ''.join([k, '\t', str(meta[k])])
f.write(line)
f.write('\n')
sumf.write(line)
sumf.write('\n')
f.close()
sumf.write('\n')
sumf.close()
print 'done.'
def choose_dir_al(self, e):
dc = DirectoryChooser('Choose a bob_py experiment folder')
# self.dir_path = dc.getDirectory()
# self.dir_text_field.setText(self.dir_path)
# self.dir_text_field.setText('blerg')
# IJ.log('blerg')
# print('boop')
self.got_exper(dc.getDirectory())
def clickEx(self):
if self.exeunt == JOptionPane.YES_OPTION:
print "confirmed"
self.fileExt = str(self.filetype.getText())
self.frame.setVisible(False)
if self.saveState == "Y":
self.saveDir = DirectoryChooser(
"Choose directory to save MIPs to").getDirectory()
self.createMIP()
else:
print "cancelled"
def output_folder_chooser(default_directory):
"""choose where output data should be saved"""
DirectoryChooser.setDefaultDirectory(default_directory);
dc = DirectoryChooser('Select the folder for saving cropped images...');
output_root = dc.getDirectory();
if output_root is None:
raise IOError('no output path chosen');
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S');
output_folder = os.path.join(output_root, (timestamp + ' output'));
os.mkdir(output_folder);
return output_folder;
def get_tif_list():
"""
Tiff file のリストを得る関数
"""
from glob import glob
from ij.io import DirectoryChooser
parent_dir = DirectoryChooser("Choose").getDirectory()
if parent_dir:
tif_list = glob(parent_dir + "*" + ".tif")
return tif_list
else:
pass
def file_location_chooser(default_directory):
"""choose folder locations and prepare output folder"""
# input
file_path = input_file_location_chooser(default_directory)
# output
DirectoryChooser.setDefaultDirectory(os.path.dirname(file_path))
dc = DirectoryChooser('Select the root folder for saving output')
output_root = dc.getDirectory()
if output_root is None:
raise IOError('no output path chosen')
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S')
output_folder = os.path.join(output_root, (timestamp + ' output'))
os.mkdir(output_folder)
return file_path, output_folder
def getFileList():
default_root_path = r'D:\\data\Marcksl1 cell shape analysis\\MaximumProjections'
file_list = []
directory_list = []
dc = DirectoryChooser('Select the root folder containing all data...')
root_path = dc.getDirectory()
if root_path is None:
return file_list
for directory, dir_names, file_names in os.walk(root_path):
if (directory is not root_path):
#file_list = [file_list.append(os.path.join(directory.replace(root_path, ''), file_name)) for file_name in file_names]
file_list = [
os.path.join(directory.replace(root_path, ''), file_name)
for file_name in file_names if '.tif' in file_name
]
return root_path, file_list
def run():
imp = IJ.getImage()
if imp is None:
return
if not imp.isHyperStack():
print "Not a hyper stack!"
return
if 1 == imp.getNFrames():
print "There is only one time frame!"
return
if 1 == imp.getNSlices():
print "To register slices of a stack, use 'Register Virtual Stack Slices'"
return
options = getOptions(imp)
if options is not None:
channel, virtual = options
print "channel=" + str(channel) + " virtual=" + str(virtual)
if virtual is True:
dc = DirectoryChooser("Choose target folder to save image sequence")
target_folder = dc.getDirectory()
if target_folder is None:
return # user canceled the dialog
if not validate(target_folder):
return
else:
target_folder = None
registered_imp = create_registered_hyperstack(imp, channel, target_folder,
virtual)
if virtual is True:
if 1 == imp.getNChannels():
ip = imp.getProcessor()
ip2 = registered_imp.getProcessor()
ip2.setColorModel(ip.getCurrentColorModel())
registered_imp.show()
else:
registered_imp.copyLuts(imp)
registered_imp.show()
else:
if 1 == imp.getNChannels():
registered_imp.show()
else:
registered_imp.copyLuts(imp)
registered_imp.show()
registered_imp.show()
def run():
bPrintLog(' ', 0)
bPrintLog('=====================================', 0)
bPrintLog('Running bAlign_Batch_v7', 0)
bPrintLog('=====================================', 0)
if len(sys.argv) < 2:
print " We need a hard-drive folder with .tif stacks as input"
print " Usage: ./fiji-macosx bALign_Batch_7 <full-path-to-folder>/"
# Prompt user for a folder
sourceFolder = DirectoryChooser(
"Please Choose A Directory Of .tif Files").getDirectory()
if not sourceFolder:
return 0
strippedFolder = sourceFolder.replace(' ', '')
if sourceFolder != strippedFolder:
print 'found a space in specified path. Pease remove spaces and try again.'
print 'path:', sourceFolder
errorDialog = GenericDialog('Align Batch 7 Options')
errorDialog.addMessage('bAlignBatch7 Error !!!')
errorDialog.addMessage('There can not be any spaces in the path.')
errorDialog.addMessage('Please remove spaces and try again.')
errorDialog.addMessage('Offending path is:')
errorDialog.addMessage(sourceFolder)
errorDialog.showDialog()
return 0
else:
sourceFolder = sys.argv[1] #assuming it ends in '/'
if not os.path.isdir(sourceFolder):
bPrintLog('\nERROR: run() did not find folder: ' + sourceFolder + '\n',
0)
return 0
if (Options(sourceFolder)):
runOneFolder(sourceFolder)
bPrintLog('=====================================', 0)
bPrintLog('Done bAlign_Batch_v7', 0)
bPrintLog('=====================================', 0)
bPrintLog(' ', 0)
def rerun_location_chooser(default_filepath):
"""choose folder containing a previous analysis run to reanalyse"""
DirectoryChooser.setDefaultDirectory(os.path.dirname(default_filepath))
dc = DirectoryChooser(
'Select the folder containing the previous analysis output...')
old_output_folder = dc.getDirectory()
if old_output_folder is None:
raise IOError('no input path chosen')
# check that chosen folder contains the right files...
files_lst = os.listdir(old_output_folder)
#if not all([f in files_lst for f in ['user_defined_edges.zip', 'parameters used.json']]):
if not 'parameters used.json' in files_lst or not (
('user_defined_edges.json' in files_lst) or
('user_defined_edges.zip' in files_lst)):
raise IOError('chosen path isn'
't a valid membrane blebbing output folder')
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S')
new_output_folder = os.path.join(
os.path.dirname(os.path.normpath(old_output_folder)),
(timestamp + ' output'))
os.mkdir(new_output_folder)
return old_output_folder, new_output_folder
def run():
# Choose a file to open
od = OpenDialog("Choose multi-image file", None)
srcDir = od.getDirectory()
if srcDir is None:
# User canceled the dialog
return
path = os.path.join(srcDir, od.getFileName())
# Choose a directory to store each slice as a file
targetDir = DirectoryChooser("Choose target directory").getDirectory()
if targetDir is None:
# User canceled the dialog
return
# Ready:
cs = ChannelSeparator()
cs.setId(path)
print "cs", cs
bf = BFVirtualStack(path, cs, False, False, False)
for sliceIndex in xrange(1, bf.getSize() + 1):
print "Processing slice", sliceIndex
ip = bf.getProcessor(sliceIndex)
sliceFileName = os.path.join(targetDir, str(sliceIndex) + ".tif")
FileSaver(ImagePlus(str(sliceIndex), ip)).saveAsTiff(sliceFileName)
# this is the macro to quickly go through image stacks and choose which ones to make into a montage
# the input is sets of stacks and montages that match all in one folder
import os, csv
from ij import IJ, ImagePlus, ImageStack, WindowManager
from ij.io import DirectoryChooser
from ij.io import OpenDialog
from ij.io import FileSaver
from ij.gui import WaitForUserDialog
from ij.plugin import MontageMaker
from ij.gui import GenericDialog
dc = DirectoryChooser("Choose an input directory")
inputDirectory = dc.getDirectory()
dc = DirectoryChooser("Select an output directory")
outputDirectory = dc.getDirectory()
for image in os.listdir(inputDirectory):
print(image)
if "stack" in image:
imp = IJ.openImage(inputDirectory + "/" + image)
imp2 = IJ.openImage(inputDirectory + "/" +
image.replace("stack", "montage"))
imp.show()
imp2.show()
gd = GenericDialog("?")
gd.addChoice("Would you like to adjust this one?", ["No", "Yes"], "No")
gd.showDialog()
if gd.getNextChoice() == "Yes":
def loadStacks():
IJ.log(" ")
IJ.log(
"oib concatenator v0.5.1; 2012; [email protected]; [email protected]; revised by [email protected]"
)
IJ.log("tested with: ImageJ 1.47a; FIJI update on July 20th 2012")
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()
#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")
fs = FileSaver(imp)
fs.saveAsTiff(srcDir + filename + ".tiff")
else:
imp = IJ.getImage()
imp.setTitle(
filename +
".tiff") # in order of the combining to work additive
#IJ.run(imp,"Concatenate...", "image1=stack image2=st2 title=[stack]");
#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")
fs = FileSaver(imp)
fs.saveAsTiff(srcDir + filename + ".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"
)
IJ.log(
"if you got an error message from the hyperstack you probably ran out of memory and it did not load all files!"
)
retStr = yyyy + mm + dd
return retStr
##################################################################################################
# main
##################################################################################################
"""
print __name__
This is coming up as '__builtin__' in Fiji downloaded on 20170810.
"""
if __name__ in ['__main__', '__builtin__']:
startTime = time.time()
bPrintLog('\n=================')
bPrintLog('Starting bFolder2MapManager')
bPrintLog('*** IMPORTANT *** Using magic_scan_image_scale:' + str(magic_scan_image_scale) + ' for ScanImage files. voxel (um) = ' + str(magic_scan_image_scale) + '/zoom')
#sourceFolder = '/Volumes/fourt/MapManager_Data/sarah_immuno/8.17.16/8.17.16.mdb/'
sourceFolder = DirectoryChooser("Please Choose A Directory Of Files").getDirectory()
outFiles = 0
if (sourceFolder):
outFiles = runOneFolder(sourceFolder)
else:
bPrintLog('Canceled by user', 0)
stopTime = time.time()
bPrintLog('Finished bFolder2MapManager with ' + str(outFiles) + ' files in ' + str(round(stopTime-startTime,2)) + ' seconds')
bPrintLog('=================\n')
from ij import IJ, WindowManager, Prefs
from ij.plugin.frame import RoiManager
from ij.measure import ResultsTable
from ij.gui import Roi, Toolbar, WaitForUserDialog
import os
from ij.io import DirectoryChooser, OpenDialog
from ij.process import ImageProcessor
from ij.plugin import ChannelSplitter
# Bioformats
from loci.plugins import BF
from loci.common import Region
from loci.plugins.in import ImporterOptions
# get input path for merge file
opener = DirectoryChooser("Select the input folder")
input_folder = opener.getDirectory()
print input_folder
#Define results output folder
folder = input_folder+"timepoints/"
if not os.path.exists(folder):
os.mkdir(folder)
# collect list of files to be processed
#file_list = [filename for filename in os.listdir(input_folder) if ".tif" in filename]
# Recursive option
file_list = [os.path.join(dp, f) for dp, dn, fn in os.walk(input_folder) for f in fn if '.tif' in f]
for file_path in file_list:
from ij.io import DirectoryChooser
import ij.ImageStack
from ij import IJ, ImagePlus
import os
import time
# Choose a directory containing the data
dc = DirectoryChooser("Choose directory containing embryo folders...")
srcDir = dc.getDirectory()
print(srcDir)
IJ.log('Root directory: ' + srcDir)
# Prepare output directories...
nowStr = time.strftime('%Y-%m-%d %H%M%S')
outputDir = os.path.join(srcDir, nowStr+ " results")
if not os.path.exists(outputDir):
os.makedirs(outputDir)
# Loop through embryo sample directories, taking note of date and embryo number
folders=[f for f in os.listdir(srcDir)
if os.path.isdir(os.path.join(srcDir,f)) and not (f.endswith('results'))]
for folder in folders:
print(folder)
IJ.log('Working on data in sample folder: ' + folder)
(date, embryoNumber) = folder.split('_E')
# Identify the indices of the files where cuts occur
textFiles=[f for f in os.listdir(os.path.join(srcDir, folder))
if (f.endswith('.txt')) and not (f.endswith('para.txt'))]
psgd.addNumericField("Which frame to choose?", 1, 0)
psgd.addCheckbox("Use table of selected frames?", False)
psgd.showDialog()
choose = psgd.getNextNumber()
choice = psgd.getCheckboxes().get(0).getState()
#open a tab separated txt file with one column Frame selected
if choice == 1:
choose = 0
IJ.run("Table... ", "open=")
frametable = WM.getWindow("selected_frames.txt")
meta = frametable.getTextPanel()
metaRT = TP.getResultsTable(meta)
# Choose a directory
directory_load = DirectoryChooser(
"Select the directory of your files").getDirectory()
directory_load = directory_load.replace("\\", "/")
# get a list of all files in the directory
dList = os.listdir(directory_load)
# set a counter to 1
n = 1
for i in dList:
dL = directory_load + "/" + str(i)
#consider only files with .ome file ending
if ".ome" in dL:
#open the images as virtual stack
imp = IJ.run(
"Bio-Formats", "open=[" + dL +
