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 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):
# 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 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 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 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()
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
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
