def ijGUI():
from ij.io import DirectoryChooser
dc = DirectoryChooser("Choose directory with Stratec files to scrub")
dir_in = dc.getDirectory()
dc = DirectoryChooser("Choose directory to write scrubbed files")
dir_out = dc.getDirectory()
idle_task_ij (process_files (dir_in, dir_out))
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 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():
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 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 main():
#filename = sys.argv[1]
#exportDir = sys.argv[2]
inputDir = "/mnt/med-groups-lmu/ls1/users/l/lsalomie/"
defaultName = "lif.lif"
outputDir = "/home/hajaalin/tmp/lifexporttest"
filename = OpenDialog("Choose LIF",inputDir,defaultName).getPath()
if not filename:
# user canceled dialog
return
chooser = DirectoryChooser("Choose export directory")
chooser.setDefaultDirectory(outputDir)
exportDir = chooser.getDirectory()
if not exportDir:
# user canceled dialog
return
# EDF parameters
params = Parameters()
params.setQualitySettings(params.QUALITY_HIGH)
params.nScales = 10
worker = EdfWorker(exportDir,params)
iterateLif(filename,worker)
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 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 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_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 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 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():
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 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
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'))]
def selectOutputDir(self):
outputDialog = DirectoryChooser("Please select a directory to save your results")
self.outputDir = outputDialog.getDirectory()
import csv
import os
import sys
from array import array
import re
import zipfile
import ast
import platform
gene_list = ['dapi', 'syfp', 'sst', 'gad1', 'pvalb']
dir = DirectoryChooser('Select Directory')
fs = os.listdir(dir.getDirectory())
csv_path = os.path.join(dir.getDirectory(), 'cell_coordinates.csv')
#img_path = os.path.join(dir.getDirectory(), 'input', 'dapi_max-z.png')
print(csv_path)
#print(img_path)
#imp = IJ.openImage(img_path)
#imp.show()
roi_manager = RoiManager()
for gene in gene_list:
roi_manager.reset()
with open(csv_path) as csvfile:
def processDirectory():
# start logging
IJ.log("\n______________________________\n\n\t\tOlympus DM correction\n\t\tVersion " + pluginVersion +"\n______________________________\n")
# ask user for an input directory
dc = DirectoryChooser("Choose folder containing Olympus (.oir) files")
inputDir = dc.getDirectory()
if inputDir is None:
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
IJ.log("\nInput directory: " + inputDir + "\n")
oirFiles = []
for f in os.listdir(inputDir):
if f.endswith(".oir"):
oirFiles.append(f)
if len(oirFiles) < 1:
IJ.log("Input directory does not contain any Olympus (.oir) files.\nNo images to process.\n")
return
# find out how many channels are in first file (we will assume all files have same number of channels and were acquired using same DMs)
reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(inputDir + oirFiles[0])
numChannels = reader.getSizeC()
# 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("User selected dichroic mirrors")
for i in range(numChannels):
IJ.log("\t\tChannel " + str(i+1) + ": " + dichroics[i])
IJ.log("\n")
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("User selected channel colours")
usersMergeList = []
for i in range(len(colourChoices)):
ch = gdMerge.getNextChoice()
if ch == "NONE":
usersMergeList.append(None)
else:
usersMergeList.append(chDict[ch])
IJ.log("\t\t" + colourChoices[i] + ": " + ch)
IJ.log("\n\n")
# ask user for an output directory
dc = DirectoryChooser("Choose folder for output")
outputDir = dc.getDirectory()
if outputDir is None:
IJ.log("User canceled the dialog!\nImage processing canceled!\n")
return
counter = 0
totalFiles = len(oirFiles)
for o in oirFiles:
counter +=1
IJ.log("Processing file " + str(counter) + " of " + str(totalFiles) + "\n")
IJ.log("File path: " + inputDir + o)
if merge:
ml = usersMergeList[:]
else:
ml = None
processFile(o, inputDir, outputDir, dichroics, ml)
IJ.log("\n--------------------------\n")
def main():
check_dependencies()
# setup
Prefs.blackBackground = True
params = Parameters()
params.load_last_params()
# select folders
if params.last_input_path is not None:
DirectoryChooser.setDefaultDirectory(params.last_input_path)
dc = DirectoryChooser("Choose root folder containing data for analysis")
input_folder = dc.getDirectory()
params.last_input_path = input_folder
if input_folder is None:
print("Run canceled")
return
if params.last_output_path is not None:
DirectoryChooser.setDefaultDirectory(
os.path.dirname(params.last_output_path))
dc = DirectoryChooser("choose location to save output")
output_folder = dc.getDirectory()
if output_folder is None:
print("Run canceled")
return
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S')
output_folder = os.path.join(output_folder, (timestamp + ' output'))
params.last_output_path = output_folder
os.mkdir(output_folder)
analysis_mode, threshold_method, minimum_cell_area_um2 = choose_analysis_mode(
params)
if analysis_mode is None:
print("Run canceled")
return
params.last_analysis_mode = analysis_mode
do_manual_qc = "+ manual correction" in analysis_mode
params.last_threshold_method = threshold_method
params.last_minimum_cell_area_um2 = minimum_cell_area_um2
params.persist_parameters()
# load image(s):
files_lst = [
f for f in os.listdir(input_folder) if os.path.splitext(f)[1] == '.tif'
]
out_statses = []
for f in files_lst:
print("Working on image {}...".format(os.path.splitext(f)[0]))
imp = IJ.openImage(os.path.join(input_folder, f))
metadata = import_iq3_metadata(
os.path.join(input_folder,
os.path.splitext(f)[0] + '.txt'))
n_channels = int(metadata['n_channels'])
gfp_channel_number = [
("488" in ch) for ch in metadata['channel_list']
].index(True) + 1 if any(
[("488" in ch) for ch in metadata['channel_list']]) else None
dapi_channel_number = [
("405" in ch) for ch in metadata['channel_list']
].index(True) + 1 if any(
[("405" in ch) for ch in metadata['channel_list']]) else None
red_channel_number = [
("561" in ch) for ch in metadata['channel_list']
].index(True) + 1 if any(
[("561" in ch) for ch in metadata['channel_list']]) else None
imp = HyperStackConverter.toHyperStack(imp, n_channels,
imp.getNSlices() // n_channels,
1, "Color")
imp = ZProjector.run(imp, "max")
if dapi_channel_number is not None:
imp.setC(dapi_channel_number)
IJ.run(imp, "Blue", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
else:
raise NotImplementedError(
"Nuclear staining channel doesn't seem to exist!")
if red_channel_number is not None:
imp.setC(red_channel_number)
IJ.run(imp, "Red", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
if gfp_channel_number is not None:
imp.setC(gfp_channel_number)
IJ.run(imp, "Green", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
imp.setC(gfp_channel_number)
imp.show()
imp.setDisplayMode(IJ.COMPOSITE)
cal = imp.getCalibration()
cal.setUnit(metadata["y_unit"])
cal.pixelWidth = metadata["x_physical_size"]
cal.pixelHeight = metadata["y_physical_size"]
imp.setCalibration(cal)
min_size_pix = minimum_cell_area_um2 / (cal.pixelHeight *
cal.pixelWidth)
if "GFP intensity" in analysis_mode:
out_stats = gfp_analysis(imp,
f,
output_folder,
gfp_channel_number=gfp_channel_number,
dapi_channel_number=dapi_channel_number,
threshold_method=threshold_method,
do_manual_qc=do_manual_qc,
min_size_pix=min_size_pix)
elif analysis_mode == "Manual":
important_channel = gfp_channel_number if gfp_channel_number is not None else dapi_channel_number
out_stats = manual_analysis(
imp,
f,
output_folder,
gfp_channel_number=gfp_channel_number,
dapi_channel_number=dapi_channel_number,
important_channel=important_channel)
elif "E-cadherin watershed" in analysis_mode:
out_stats = ecad_analysis(imp,
f,
output_folder,
gfp_channel_number=gfp_channel_number,
red_channel_number=red_channel_number,
dapi_channel_number=dapi_channel_number,
do_manual_qc=do_manual_qc)
imp.close()
out_statses.extend(out_stats)
print("Current total number of cells identified: {}".format(
len(out_statses)))
# get # nuclei per "cell"
params.save_parameters_to_json(
os.path.join(output_folder, "parameters used.json"))
WaitForUserDialog(
"Done", "Done, having analysed {} cells in total!".format(
len(out_statses))).show()
return
def run():
IJ.log("Correct_3D_Drift")
imp = IJ.getImage()
if imp is None:
return
if 1 == imp.getNFrames():
print "There is only one time frame!"
return
options = getOptions(imp)
if options is not None:
channel, virtual, multi_time_scale, subpixel, process, only_compute = options
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
# compute shifts
IJ.log(" computing drifts..."); print("\nCOMPUTING SHIFTS:")
IJ.log(" at frame shifts of 1");
dt = 1; shifts = compute_and_update_frame_translations_dt(imp, channel, dt, process)
# multi-time-scale computation
if multi_time_scale is True:
dt_max = imp.getNFrames()-1
# computing drifts on exponentially increasing time scales 3^i up to 3^6
# ..one could also do this with 2^i or 4^i
# ..maybe make this a user choice? did not do this to keep it simple.
dts = [3,9,27,81,243,729,dt_max]
for dt in dts:
if dt < dt_max:
IJ.log(" at frame shifts of "+str(dt))
shifts = compute_and_update_frame_translations_dt(imp, channel, dt, process, shifts)
else:
IJ.log(" at frame shifts of "+str(dt_max));
shifts = compute_and_update_frame_translations_dt(imp, channel, dt_max, process, shifts)
break
# invert measured shifts to make them the correction
shifts = invert_shifts(shifts)
print(shifts)
# apply shifts
if not only_compute:
IJ.log(" applying shifts..."); print("\nAPPLYING SHIFTS:")
if subpixel:
registered_imp = register_hyperstack_subpixel(imp, channel, shifts, target_folder, virtual)
else:
shifts = convert_shifts_to_integer(shifts)
registered_imp = register_hyperstack(imp, channel, shifts, 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()
else:
if imp.getRoi():
xmin = imp.getRoi().getBounds().x
ymin = imp.getRoi().getBounds().y
zmin = 0
xmax = xmin + imp.getRoi().getBounds().width - 1
ymax = ymin + imp.getRoi().getBounds().height - 1
zmax = imp.getNSlices()-1
else:
xmin = 0
ymin = 0
zmin = 0
xmax = imp.getWidth() - 1
ymax = imp.getHeight() - 1
zmax = imp.getNSlices() - 1
save_shifts(shifts, [xmin, ymin, zmin, xmax, ymax, zmax])
IJ.log(" saving shifts...")
import os
from ij.io import DirectoryChooser
from ij import IJ
from ij.plugin import ChannelSplitter
from ij.process import LUT
from ij.process import StackConverter
from java.awt import Color
from ij.gui import GenericDialog
dc = DirectoryChooser("Select folder to operate on...")
dirPath = dc.getDirectory()
if dirPath is not None:
dc2 = DirectoryChooser("Select output directory...")
outPath = dc2.getDirectory()
if outPath is not None:
gd = GenericDialog("Options...")
gd.addCheckbox("Recolor_images",True)
gd.showDialog()
if (gd.wasOKed()):
doRecolor = gd.getNextBoolean()
for f in os.listdir(dirPath):
if f.endswith(".tif") or f.endswith(".tiff"):
theImage = IJ.openImage(dirPath+f)
IJ.log("Loaded " + f)
palette = [Color.GREEN,Color.RED,Color.BLUE]
if (theImage.getNChannels() < 4):
if doRecolor:
for i in range(theImage.getNChannels()):
theImage.setChannelLut(LUT.createLutFromColor(palette[i]),i+1)
try:
homedir=IJ.getDirectory('imagej')
jythondir=os.path.join(homedir,'plugins/Evalulab/')
jythondir=os.path.abspath(jythondir)
sys.path.append(jythondir)
import PoreDetectionTrueColor
reload(PoreDetectionTrueColor)
from PoreDetectionTrueColor import runPoreDetection
import MessageStrings
reload(MessageStrings)
from MessageStrings import Messages
import Utility
reload(Utility)
if __name__ == '__main__':
dlg=DirectoryChooser(Messages.ChooseImageDirectory)
print dlg.getDirectory()
imageList=Utility.getImageListFromDirectory(dlg.getDirectory())
for imageName in imageList:
fullImageName=os.path.join(dlg.getDirectory(), imageName)
image=IJ.openImage(fullImageName)
image.show()
runPoreDetection(image, data, ops, display)
image.close()
def run(title):
gd = GenericDialog('Record Window')
gd.addMessage(
"Maximum number of frames to record.\nZero means infinite, interrupt with ESC key."
)
gd.addNumericField('Max. frames:', 50, 0)
gd.addNumericField('Milisecond interval:', 300, 0)
gd.addSlider('Start in (seconds):', 0, 20, 5)
frames = []
titles = []
for f in Frame.getFrames():
if f.isEnabled() and f.isVisible():
frames.append(f)
titles.append(f.getTitle())
gd.addChoice('Window:', titles, titles[0])
gd.addCheckbox("To file", False)
gd.showDialog()
if gd.wasCanceled():
return
n_frames = int(gd.getNextNumber())
interval = gd.getNextNumber() / 1000.0 # in seconds
frame = frames[gd.getNextChoiceIndex()]
delay = int(gd.getNextNumber())
tofile = gd.getNextBoolean()
dir = None
if tofile:
dc = DirectoryChooser("Directory to store image frames")
dir = dc.getDirectory()
if dir is None:
return # dialog canceled
snaps = []
borders = None
executors = Executors.newFixedThreadPool(1)
try:
while delay > 0:
IJ.showStatus('Starting in ' + str(delay) + 's.')
time.sleep(1) # one second
delay -= 1
IJ.showStatus('Capturing frame borders...')
bounds = frame.getBounds()
robot = Robot()
frame.toFront()
time.sleep(0.5) # half a second
borders = robot.createScreenCapture(bounds)
IJ.showStatus("Recording " + frame.getTitle())
# Set box to the inside borders of the frame
insets = frame.getInsets()
box = bounds.clone()
box.x = insets.left
box.y = insets.top
box.width -= insets.left + insets.right
box.height -= insets.top + insets.bottom
start = System.currentTimeMillis() / 1000.0 # in seconds
last = start
intervals = []
real_interval = 0
i = 1
fus = None
if tofile:
fus = []
# 0 n_frames means continuous acquisition
while 0 == n_frames or (len(snaps) < n_frames
and last - start < n_frames * interval):
now = System.currentTimeMillis() / 1000.0 # in seconds
real_interval = now - last
if real_interval >= interval:
last = now
img = snapshot(frame, box)
if tofile:
fus.append(
executors.submit(
Saver(i, dir, bounds, borders, img,
insets))) # will flush img
i += 1
else:
snaps.append(img)
intervals.append(real_interval)
else:
time.sleep(interval / 5)
# interrupt capturing:
if IJ.escapePressed():
IJ.showStatus("Recording user-interrupted")
break
# debug:
#print "insets:", insets
#print "bounds:", bounds
#print "box:", box
#print "snap dimensions:", snaps[0].getWidth(), snaps[0].getHeight()
# Create stack
stack = None
if tofile:
for fu in snaps:
fu.get() # wait on all
stack = VirtualStack(bounds.width, bounds.height, None, dir)
files = File(dir).list(TifFilter())
Arrays.sort(files)
for f in files:
stack.addSlice(f)
else:
stack = ImageStack(bounds.width, bounds.height, None)
t = 0
for snap, real_interval in zip(snaps, intervals):
bi = BufferedImage(bounds.width, bounds.height,
BufferedImage.TYPE_INT_RGB)
g = bi.createGraphics()
g.drawImage(borders, 0, 0, None)
g.drawImage(snap, insets.left, insets.top, None)
stack.addSlice(str(IJ.d2s(t, 3)),
ImagePlus('', bi).getProcessor())
t += real_interval
snap.flush()
bi.flush()
borders.flush()
ImagePlus(frame.getTitle() + " recording", stack).show()
IJ.showStatus('Done recording ' + frame.getTitle())
except Exception, e:
print "Some error ocurred:"
print e.printStackTrace()
IJ.showStatus('')
if borders is not None: borders.flush()
for snap in snaps:
snap.flush()
from ij.plugin.frame import RoiManager
from ij.measure import Calibration
from loci.plugins import BF
from ij.io import FileSaver
from ij.measure import Measurements
from ij.process import ImageStatistics as IS
from java.awt import Color
from ij.io import DirectoryChooser
# Python imports
import os
import math
import sys
# Choose a folder that you want the images resized to the same scale
input_dc = DirectoryChooser("Choose a folder with images to be rescaled.")
inputDir = input_dc.getDirectory()
output_dc = DirectoryChooser("Choose output folder.")
outputDir = output_dc.getDirectory()
# What we need to do is crop EQUAL AREAS. First find the smallest
# image area.
# Find the minimum area per pixel
minArea = 999999
for filename in os.listdir(inputDir):
if '.tif' in filename:
print 'Opening ' , filename , '...'
image = IJ.openImage(inputDir + '/' + filename)
ip = image.getProcessor()
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")
from ij.process import Blitter, ImageConverter
from fiji.threshold import Auto_Threshold
from loci.plugins import BF
from loci.formats import UnknownFormatException
from algorithms import MandersColocalization
from net.imglib2 import TwinCursor
from net.imglib2.img import ImagePlusAdapter
from net.imglib2.view import Views
from gadgets import DataContainer
from gadgets import ThresholdMode
inputDialog = DirectoryChooser("Please select a directory contaning your images")
outputDialog = DirectoryChooser("Please select a directory to save your results")
inputDir = inputDialog.getDirectory()
outputDir = outputDialog.getDirectory()
imageA = 2 # Second channel
imageB = 3 # Third channel
methods = ["Mean", "Otsu"]
def createContainer(roi, imgA, imgB):
rect = roi.getBounds()
ipmask = roi.getMask()
offset = [rect.x, rect.y]
size = [rect.width, rect.height]
if (ipmask != None):
ipslice = ipmask.createProcessor(imgA.getWidth(), imgA.getHeight())
ipslice.setValue(0.0)
import os
import shutil
from ij import IJ
from ij.io import DirectoryChooser
dc = DirectoryChooser("Select Main Folder")
inputPath = dc.getDirectory()
file_list = os.listdir(inputPath)
if not os.path.exists(os.path.join(inputPath, "Channel 1")):
os.makedirs(os.path.join(inputPath, "Channel 1"))
if not os.path.exists(os.path.join(inputPath, "Channel 2")):
os.makedirs(os.path.join(inputPath, "Channel 2"))
channel_1 = inputPath + "Channel 1" + "\\"
channel_2 = inputPath + "Channel 2" + "\\"
for files in file_list:
if "Ch1" in files:
shutil.move(inputPath + files, channel_1 + files)
if "Ch2" in files:
shutil.move(inputPath + files, channel_2 + files)
if IN_DEV :
canceled = False
else :
canceled = not IJ.showMessageWithCancel(__program__,'To proceed program will close all open images and windows, continue?')
if not canceled :
setup()
if IN_DEV :
exper_path = "/Users/baylieslab/Documents/Amelia/data/patrick/2019-05-20_Dmef2-2xeGFP"
else :
dir_chooser = DirectoryChooser(__program__)
exper_path = dir_chooser.getDirectory()
if exper_path.endswith('/') :
exper_path = exper_path[:-1]
exper_name = os.path.basename(exper_path)
exper = Exper(exper_path, exper_name)
hemisegs = []
fs = os.listdir(exper_path)
for f in fs :
if f.startswith(exper_name) :
IJ.log("failed")
os.rmdir(outputName)
wList = WindowManager.getIDList()
for i in range(len(wList)):
currImage = WindowManager.getImage(wList[i])
currImage.close()
returnVal = 1
else:
IJ.log("skipped")
returnVal = 2
return returnVal
dc = DirectoryChooser("Choose root directory")
rootPath = dc.getDirectory()
if rootPath is not None:
gd = GenericDialog("Batch mode options...")
gd.addStringField("Filename extension","lsm",6)
gd.showDialog()
if (gd.wasOKed()):
extension = gd.getNextString()
for root, dirs, files in os.walk(rootPath):
LSMfiles = filter(lambda x: check_if_filetype(x,extension),files)
if len(LSMfiles)>0:
LSMpaths = map(lambda x: generate_path(x,root),LSMfiles)
explodeStatuses = map(run_explode,LSMpaths)
resizePaths = map(get_first_in_tuple,filter(filter_by_return_status,map(lambda x,y:(x,y),LSMpaths,explodeStatuses)))
if len(resizePaths)>0:
resizeStatuses = map(run_resize,resizePaths)
stitchPaths = map(get_first_in_tuple,filter(filter_by_return_status,map(lambda x,y:(x,y),resizePaths,resizeStatuses)))
import glob
import os.path
from ij import IJ, ImagePlus, ImageStack, WindowManager
from ij.io import DirectoryChooser
from edfgui import ExtendedDepthOfField, Parameters
dc = DirectoryChooser("Set input directory")
files = glob.glob(dc.getDirectory() + "/*.tiff")
dc = DirectoryChooser("Set output directory")
outputDir = dc.getDirectory()
# EDF parameters
params = Parameters()
params.setQualitySettings(params.QUALITY_HIGH)
for f in files:
imp = ImagePlus(f)
# output name
head,tail = os.path.split(f)
base,ext = os.path.splitext(tail)
output = os.path.join(outputDir,base + "_edf.tif")
print output
# make all-in-focus image
edf = ExtendedDepthOfField(imp,params)
edf.process()
import sys
homedir = IJ.getDirectory('imagej')
jythondir = os.path.join(homedir, 'plugins/Evalulab/')
jythondir = os.path.abspath(jythondir)
sys.path.append(jythondir)
import PoreDetectionTrueColor
reload(PoreDetectionTrueColor)
from PoreDetectionTrueColor import runPoreDetection
import MessageStrings
reload(MessageStrings)
from MessageStrings import Messages
import Utility
reload(Utility)
if __name__ == '__main__':
dlg = DirectoryChooser(Messages.ChooseImageDirectory)
print dlg.getDirectory()
imageList = Utility.getImageListFromDirectory(dlg.getDirectory())
for imageName in imageList:
fullImageName = os.path.join(dlg.getDirectory(), imageName)
image = IJ.openImage(fullImageName)
image.show()
runPoreDetection(image, data, ops, display)
image.close()
def run(title):
gd = GenericDialog("Record Window")
gd.addMessage("Maximum number of frames to record.\nZero means infinite, interrupt with ESC key.")
gd.addNumericField("Max. frames:", 50, 0)
gd.addNumericField("Milisecond interval:", 300, 0)
gd.addSlider("Start in (seconds):", 0, 20, 5)
frames = []
titles = []
for f in Frame.getFrames():
if f.isEnabled() and f.isVisible():
frames.append(f)
titles.append(f.getTitle())
gd.addChoice("Window:", titles, titles[0])
gd.addCheckbox("To file", False)
gd.showDialog()
if gd.wasCanceled():
return
n_frames = int(gd.getNextNumber())
interval = gd.getNextNumber() / 1000.0 # in seconds
frame = frames[gd.getNextChoiceIndex()]
delay = int(gd.getNextNumber())
tofile = gd.getNextBoolean()
dir = None
if tofile:
dc = DirectoryChooser("Directory to store image frames")
dir = dc.getDirectory()
if dir is None:
return # dialog canceled
snaps = []
borders = None
executors = Executors.newFixedThreadPool(1)
try:
while delay > 0:
IJ.showStatus("Starting in " + str(delay) + "s.")
time.sleep(1) # one second
delay -= 1
IJ.showStatus("Capturing frame borders...")
bounds = frame.getBounds()
robot = Robot()
frame.toFront()
time.sleep(0.5) # half a second
borders = robot.createScreenCapture(bounds)
IJ.showStatus("Recording " + frame.getTitle())
# Set box to the inside borders of the frame
insets = frame.getInsets()
box = bounds.clone()
box.x = insets.left
box.y = insets.top
box.width -= insets.left + insets.right
box.height -= insets.top + insets.bottom
start = System.currentTimeMillis() / 1000.0 # in seconds
last = start
intervals = []
real_interval = 0
i = 1
fus = None
if tofile:
fus = []
# 0 n_frames means continuous acquisition
while 0 == n_frames or (len(snaps) < n_frames and last - start < n_frames * interval):
now = System.currentTimeMillis() / 1000.0 # in seconds
real_interval = now - last
if real_interval >= interval:
last = now
img = snapshot(frame, box)
if tofile:
fus.append(executors.submit(Saver(i, dir, bounds, borders, img, insets))) # will flush img
i += 1
else:
snaps.append(img)
intervals.append(real_interval)
else:
time.sleep(interval / 5)
# interrupt capturing:
if IJ.escapePressed():
IJ.showStatus("Recording user-interrupted")
break
# debug:
# print "insets:", insets
# print "bounds:", bounds
# print "box:", box
# print "snap dimensions:", snaps[0].getWidth(), snaps[0].getHeight()
# Create stack
stack = None
if tofile:
for fu in snaps:
fu.get() # wait on all
stack = VirtualStack(bounds.width, bounds.height, None, dir)
files = File(dir).list(TifFilter())
Arrays.sort(files)
for f in files:
stack.addSlice(f)
else:
stack = ImageStack(bounds.width, bounds.height, None)
t = 0
for snap, real_interval in zip(snaps, intervals):
bi = BufferedImage(bounds.width, bounds.height, BufferedImage.TYPE_INT_RGB)
g = bi.createGraphics()
g.drawImage(borders, 0, 0, None)
g.drawImage(snap, insets.left, insets.top, None)
stack.addSlice(str(IJ.d2s(t, 3)), ImagePlus("", bi).getProcessor())
t += real_interval
snap.flush()
bi.flush()
borders.flush()
ImagePlus(frame.getTitle() + " recording", stack).show()
IJ.showStatus("Done recording " + frame.getTitle())
except Exception, e:
print "Some error ocurred:"
print e.printStackTrace()
IJ.showStatus("")
if borders is not None:
borders.flush()
for snap in snaps:
snap.flush()
def main():
userDir = DirectoryChooser("Choose a folder")
imgDir = userDir.getDirectory()
import_and_straighten(imgDir)
measure_growth(imgDir)
def main():
# define here which membrane indices will be used in the analysis, with last index the "control" index
membrane_indices = [-1, 0, 1, 3]
# for now, work with frontmost open image...
imp = IJ.getImage()
im_title = imp.getTitle()
settings = MembraneEvolutionAnalysisSettings(
membrane_indices=membrane_indices)
settings.loadPersistedSettings()
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S')
DirectoryChooser.setDefaultDirectory((settings.output_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')
settings.output_path = output_root
# get calibration
cal = imp.getCalibration()
if cal.getTimeUnit() == "sec":
cal.setTimeUnit('s')
# pop up a dialog prompting for selection of zero time point, frame interval, and time step for analysis
time_steps_not_ok = True
while time_steps_not_ok:
dialog = NonBlockingGenericDialog("Determine time parameters...")
dialog.addNumericField("0 timepoint frame (1-index): ",
settings.zero_timepoint_frame, 0)
dialog.addNumericField("Acquisition time step (s): ",
cal.frameInterval,
2) # assume stored in seconds
dialog.addNumericField(
"Time step for analysis (s): ",
cal.frameInterval * settings.analysis_frame_step, 2)
dialog.showDialog()
if dialog.wasCanceled():
return
zero_f = dialog.getNextNumber()
acq_t_step = dialog.getNextNumber()
analysis_t_step = dialog.getNextNumber()
if acq_t_step != 0 and analysis_t_step != 0:
analysis_frame_step = analysis_t_step / acq_t_step
if round(analysis_frame_step) == analysis_frame_step:
time_steps_not_ok = False
settings.zero_timepoint_frame = zero_f
settings.analysis_frame_step = analysis_frame_step
if time_steps_not_ok:
warning_dlg = GenericDialog("Error!")
warning_dlg.addMessage(
"Analysis time step must be an integer multiple of acquisition time steps, and neither should be zero!!"
)
warning_dlg.setOKLabel("Try again...")
warning_dlg.showDialog()
if warning_dlg.wasCanceled():
return
start_frame = int(((zero_f - 1) % analysis_frame_step) + 1)
end_frame = int(imp.getNFrames() -
(imp.getNFrames() - zero_f) % analysis_frame_step)
frames = [
f + 1
for f in range(start_frame - 1, end_frame, int(analysis_frame_step))
]
print("frames = " + str(frames))
imp.killRoi()
analysis_imp = SubstackMaker().makeSubstack(
imp,
str(start_frame) + "-" + str(end_frame) + "-" +
str(int(analysis_frame_step)))
imp.changes = False
imp.close()
analysis_imp.show()
drawn_membranes = [
TimepointsMembranes(input_image_title=im_title,
time_point_s=(t - 1) * acq_t_step) for t in frames
]
membranes_listener = UpdateRoiImageListener(drawn_membranes)
analysis_imp.addImageListener(membranes_listener)
# now attach roi listener to store all 0th membranes after showing a waitforuserdialog to prompt continuation
IJ.setTool("freeline")
for membrane_idx in membrane_indices:
# if membrane_idx>50:
# IJ.setTool("line");
analysis_imp.killRoi()
membranes_listener.resetLastFrame()
membranes_listener.setCurrentMembraneIndex(membrane_idx)
analysis_imp.setZ(1)
continue_dlg = WaitForUserDialog(
"Continue?", "Click OK once all the " + str(membrane_idx) +
"-index membranes have been drawn")
continue_dlg.show()
membranes_listener.imageUpdated(analysis_imp)
drawn_membranes = membranes_listener.getDrawnMembraneTimepointsList()
json_path = os.path.join(output_root,
"Membranes " + timestamp + ".json")
f = open(json_path, 'w+')
try:
json.dump(drawn_membranes, f, default=encode_membrane)
finally:
f.close()
# save csv containing mebrane measurements for current membrane index
csv_path = os.path.join(
output_root, ("Membrane measurements " + timestamp + ".csv"))
if membrane_idx == membrane_indices[0]:
try:
f = open(csv_path, 'wb')
writer = csv.writer(f)
writer.writerow([
"Membrane index", ("Time point, " + cal.getTimeUnit()),
("Membrane length, " + cal.getUnit()),
("Euclidean length, " + cal.getUnit()),
"Membrane sinuoisty"
])
finally:
f.close()
try:
f = open(csv_path, 'ab')
writer = csv.writer(f)
for mems in drawn_membranes:
mem = mems.getMembrane(membrane_idx)
if mem is not None:
writer.writerow([
membrane_idx, mems.time_point_s,
mem.getPathLength() * cal.pixelWidth,
mem.getEuclidean() * cal.pixelWidth,
mem.getSinuosity()
])
finally:
f.close()
settings.persistSettings()
settings.save_settings()
print("Finished getting all membranes with indices " +
str(membrane_indices))
analysis_imp.close()
from ij.io import DirectoryChooser
from ij.gui import GenericDialog
from ij import IJ
from ij import WindowManager
import os
import glob
dirChooser = DirectoryChooser("Choose directory of images to normalize...")
dirPath = dirChooser.getDirectory()
scaleXs = []
if dirPath is not None:
if not os.path.exists(dirPath + "resized"):
os.mkdir(dirPath + "resized")
gd = GenericDialog("Settings...")
gd.addNumericField("Final scale factor:",0.5,2)
gd.addCheckbox("Convert multichannel to RGB:",True)
gd.showDialog()
if (gd.wasOKed()):
common_scale = gd.getNextNumber()
convert_to_rgb = gd.getNextBoolean()
filecollection = glob.glob(os.path.join(dirPath, '*.tif'))
if (len(filecollection) > 0):
for path in filecollection:
theImage = IJ.openImage(path)
calibration = theImage.getCalibration()
scaleXs.append(calibration.pixelWidth)
theImage.close()
lc_scale = max(scaleXs)
print lc_scale
for path in filecollection:
from ij.io import FileSaver, DirectoryChooser
from ij import ImagePlus
from ij.io import FileSaver
import jmFijiGen as jmg
tic = time.time()
sFac = 0.0
barW = 5 # bar width, microns
barH = 6 # bar height, pts
barF = 24 # bar font, pts
barC = "White" # bar color
barL= "Lower Right" # bar location
dc = DirectoryChooser("Choose directory")
basePath = dc.getDirectory()
sPngPath = basePath + os.sep + "png" + os.sep
jmg.ensureDir(sPngPath)
names = []
for file in os.listdir(basePath):
if file.endswith(".tif"):
name = os.path.splitext(file)[0]
names.append(name)
names.sort()
sSat = "saturated=%.2f" % sFac
import glob
import os
from ij import IJ
from ij.io import DirectoryChooser
from ij.plugin import Memory
dc = DirectoryChooser("Choose directory of LSM files...")
dirPath = dc.getDirectory()
if dirPath is not None:
fileList = glob.glob(dirPath+"*.lsm")
for path in fileList:
processImage = False
theSize = os.path.getsize(path) / 1048576.0
print theSize
totFijiMem = Memory().maxMemory() / 1048576.0
print totFijiMem
if (theSize < totFijiMem/3.0):
basename = os.path.splitext(os.path.basename(path))[0]
outputPath = dirPath + basename + ".tif"
if not os.path.exists(outputPath):
processImage = True
params = "type=[Positions from file] order=[Defined by image metadata] browse=[" + path + "] multi_series_file=[" + path + "] fusion_method=[Linear Blending] regression_threshold=0.30 max/avg_displacement_threshold=2.50 absolute_displacement_threshold=3.50 compute_overlap ignore_z_stage increase_overlap=10 subpixel_accuracy computation_parameters=[Save memory (but be slower)] image_output=[Fuse and display]"
print params
if (processImage):
try:
IJ.run("Grid/Collection stitching", params)
stitchedImage = IJ.getImage()
IJ.saveAsTiff(stitchedImage,outputPath)
stitchedImage.close()
clij2 = CLIJ2.getInstance()
def run_tube(image, sigma, index, result):
tp = TubenessProcessor(sigma, True)
tubimg = tp.generateImage(image)
tubimg = tubimg.getProcessor().convertToShortProcessor()
tubimg = ImagePlus("img", tubimg)
result[index] = tubimg
# vessel detection training
dc = DirectoryChooser("Choose a folder")
folder = dc.getDirectory()
pos = IJ.openImage(folder + "\\vessels_positive.tif")
posroi = pos.getRoi()
neg = IJ.openImage(folder + "\\vessels_negative.tif")
negroi = neg.getRoi()
pos.close()
IJ.run("Select None", "")
channels = ChannelSplitter.split(neg)
neg.close()
image = channels[3]
channels = channels[0:3]
proc = image.getProcessor()
directional_op = ImagePlus("directional_op", proc)
headerStr = ''
for k, v in myInfoDict.items():
headerStr += k + ','
print(headerStr, file=f)
rowStr = ''
for k, v in myInfoDict.items():
rowStr += str(v) + ','
print(rowStr, file=f)
if __name__ in ['__main__', '__builtin__']:
# debug file open errors
#gTheseFileExtensions = ['.oir', '.tif', '.csv']
#
# ask user for a folder path
userFolder = DirectoryChooser('Choose a folder')
folderPath = userFolder.getDirectory()
if folderPath is None:
print('Warning: User did not choose a folder')
else:
# remove trailing / or \
if folderPath.endswith(os.sep):
folderPath = folderPath[:-1]
#
myRun(folderPath, gTheseFileExtensions)
#
print(' simpleFileInfo is done !!!')
def get_files_and_analyze(folder):
count = 0
timeseries = []
for root, directories, filenames in os.walk(folder):
#print directories
for directory in sorted(directories):
#print directory
if not (("field" in directory)): # "field is specific to the folder where the image files are"
continue
else:
print os.path.join(root, directory)
analyze(os.path.join(root, directory), 3, 7, 1)
if __name__ == '__main__':
dc = DirectoryChooser("Choose top directory containing all Matrix Screener images")
foldername = dc.getDirectory()
#od = OpenDialog("Click on one of the image files in the folder to be analysed", None )
#filename = od.getFileName()
#foldername = od.getDirectory()
#print foldername
print "\n\n\n\n\n\n"
#foldername = "/g/almf/software/scripts/imagej/Data_MatrixScreenerImport"
if None != foldername:
print "foldername = "+foldername
get_files_and_analyze(foldername)
sumSize = sumSize + theSize
return sumSize
def calculate_memory_recs(dirsize,maxmem):
values = []
maxchannel = maxmem / 10
maxtot = long(maxmem * 0.3)
for i in range(1,6):
if (maxtot/i > maxchannel):
values.append((maxchannel*i)/1048576)
else:
values.append(maxtot/1048576)
return values
dc = DirectoryChooser("Choose directory with OME.TIF files...")
sourceDir = dc.getDirectory()
if not(sourceDir is None):
if not os.path.exists(sourceDir + "resized"):
os.mkdir(sourceDir + "resized")
dirSize = get_directory_size(sourceDir)
dirSizeMB = dirSize / 1048576
memoryObj = Memory()
memFiji = memoryObj.maxMemory()
memFijiMB = memFiji / 1048576
gd = GenericDialog("Set Parameters...")
gd.addNumericField("Sizing_ratio (Final disk space / Initial disk space):",0.25,2)
gd.addMessage("Directory size: " + str(dirSizeMB) + "MB")
gd.addMessage("Maximum memory: " + str(memFijiMB) + "MB")
def run():
IJ.log("Correct_3D_Drift")
imp = IJ.getImage()
if imp is None:
return
if 1 == imp.getNFrames():
IJ.showMessage("Cannot register because there is only one time frame.\nPlease check [Image > Properties...].")
return
options = getOptions(imp)
if options is None:
return # user pressed Cancel
if options['z_min'] < 1:
IJ.showMessage("The minimal z plane must be >=1.")
return
if options['z_max'] > imp.getNSlices():
IJ.showMessage("Your image only has "+str(imp.getNSlices())+" z-planes, please adapt your z-range.")
return
if options['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
#
# compute drift
#
IJ.log(" computing drift...");
IJ.log(" at frame shifts of 1");
dt = 1; shifts = compute_and_update_frame_translations_dt(imp, dt, options)
# multi-time-scale computation
if options['multi_time_scale'] is True:
dt_max = imp.getNFrames()-1
# computing drifts on exponentially increasing time scales 3^i up to 3^6
# ..one could also do this with 2^i or 4^i
# ..maybe make this a user choice? did not do this to keep it simple.
dts = [3,9,27,81,243,729,dt_max]
for dt in dts:
if dt < dt_max:
IJ.log(" at frame shifts of "+str(dt))
shifts = compute_and_update_frame_translations_dt(imp, dt, options, shifts)
else:
IJ.log(" at frame shifts of "+str(dt_max));
shifts = compute_and_update_frame_translations_dt(imp, dt_max, options, shifts)
break
# invert measured shifts to make them the correction
shifts = invert_shifts(shifts)
#print(shifts)
# apply shifts
if not options['only_compute']:
IJ.log(" applying shifts..."); #print("\nAPPLYING SHIFTS:")
if options['subpixel']:
registered_imp = register_hyperstack_subpixel(imp, options['channel'], shifts, target_folder, options['virtual'])
else:
shifts = convert_shifts_to_integer(shifts)
registered_imp = register_hyperstack(imp, shifts, target_folder, options['virtual'])
if options['virtual'] is True:
if 1 == imp.getNChannels():
ip=imp.getProcessor()
ip2=registered_imp.getProcessor()
ip2.setColorModel(ip.getCurrentColorModel())
else:
registered_imp.copyLuts(imp)
else:
if imp.getNChannels() > 1:
registered_imp.copyLuts(imp)
registered_imp.show()
else:
if imp.getRoi():
xmin = imp.getRoi().getBounds().x
ymin = imp.getRoi().getBounds().y
zmin = 0
xmax = xmin + imp.getRoi().getBounds().width - 1
ymax = ymin + imp.getRoi().getBounds().height - 1
zmax = imp.getNSlices()-1
else:
xmin = 0
ymin = 0
zmin = 0
xmax = imp.getWidth() - 1
ymax = imp.getHeight() - 1
zmax = imp.getNSlices() - 1
save_shifts(shifts, [xmin, ymin, zmin, xmax, ymax, zmax])
IJ.log(" saving shifts...")
def dirchooser():
dc = DirCh("Choose data folder...")
return dc.getDirectory()
def selectInputDir(self):
inputDialog = DirectoryChooser("Please select a directory contaning your images")
inputDir = inputDialog.getDirectory()
for imageFile in os.listdir(inputDir):
self.files.append(inputDir + imageFile)
arr2 = [x - ma for x in arr]
start = find_index_greater_zero(arr1)
end = find_index_greater_zero(arr2)
length = end-start+1
return [start,end,length]
def make_tile_series(xs,ys,xlen,ylen):
arr = []
for y in range(ys[0],ys[1]+1):
arr.extend(range(xlen*y+xs[0],xlen*y+xs[1]+1))
arr = [m+1 for m in arr]
return arr
##### Sets directory of full-res tiles and gets metadata ######
dc = DirectoryChooser("Choose directory where full-res tiles are stored...")
imgDir = dc.getDirectory()
metadata = IJ.openAsString(imgDir+"tile_info.txt")
p = re.compile(r'X Tiles: (\d+)')
m = p.search(metadata)
if m is None:
xtiles = 0
else:
xtiles = int(m.group(1))
p = re.compile(r'Y Tiles: (\d+)')
m = p.search(metadata)
if m is None:
ytiles = 0
else:
ytiles = int(m.group(1))
if not os.path.exists(imgDir + "temp"):
os.mkdir(imgDir + "temp")
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:
def main():
userDir = DirectoryChooser("Choose a folder")
imgDir = userDir.getDirectory()
import_and_straighten(imgDir)
measure_growth(imgDir)
# 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 main():
# setup
Prefs.blackBackground = True
params = Parameters()
params.load_last_params()
# select folders
if params.last_input_path is not None:
DirectoryChooser.setDefaultDirectory(params.last_input_path)
dc = DirectoryChooser("Choose root folder containing data for analysis")
input_folder = dc.getDirectory()
params.last_input_path = input_folder
if input_folder is None:
raise KeyboardInterrupt("Run canceled")
if params.last_output_path is not None:
DirectoryChooser.setDefaultDirectory(
os.path.dirname(params.last_output_path))
dc = DirectoryChooser("choose location to save output")
output_folder = dc.getDirectory()
timestamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H-%M-%S')
output_folder = os.path.join(output_folder, (timestamp + ' output'))
params.last_output_path = output_folder
os.mkdir(output_folder)
analysis_mode = choose_analysis_mode(params)
params.last_analysis_mode = analysis_mode
params.persist_parameters()
# load image(s):
files_lst = [
f for f in os.listdir(input_folder) if os.path.splitext(f)[1] == '.tif'
]
out_statses = []
for f in files_lst:
print("Working on image {}...".format(os.path.splitext(f)[0]))
imp = IJ.openImage(os.path.join(input_folder, f))
metadata = import_iq3_metadata(
os.path.join(input_folder,
os.path.splitext(f)[0] + '.txt'))
imp = HyperStackConverter.toHyperStack(imp, 3,
imp.getNSlices() // 3, 1,
"Color")
imp = ZProjector.run(imp, "max")
imp.setC(3)
IJ.run(imp, "Blue", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
imp.setC(2)
IJ.run(imp, "Red", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
imp.setC(1)
IJ.run(imp, "Green", "")
IJ.run(imp, "Enhance Contrast", "saturated=0.35")
imp.show()
imp.setDisplayMode(IJ.COMPOSITE)
cal = imp.getCalibration()
cal.setUnit(metadata["y_unit"])
cal.pixelWidth = metadata["x_physical_size"]
cal.pixelHeight = metadata["y_physical_size"]
imp.setCalibration(cal)
if analysis_mode == "GFP intensity":
out_stats = gfp_analysis(imp, f, output_folder)
elif analysis_mode == "Manual":
out_stats = manual_analysis(imp, f, output_folder)
out_statses.extend(out_stats)
print("Current total number of cells identified: {}".format(
len(out_statses)))
# get # nuclei per "cell"
params.save_parameters_to_json(
os.path.join(output_folder, "parameters used.json"))
WaitForUserDialog(
"Done", "Done, having analysed {} cells in total!".format(
len(out_statses))).show()
return
