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