def batchAnalysis(analysis_exe, input_directory, output_directory, multi_xml, max_processes=2): minimum_length = 100 dax_files = glob.glob(input_directory + "*.dax") # setup process queue process_count = 0 results = Queue.Queue() # start processes procs = [] for i, file in enumerate(dax_files): print "Found:", file movie_obj = datareader.inferReader(file) if (movie_obj.filmSize()[2] > minimum_length): basename = os.path.basename(file) mlistname = output_directory + "/" + basename[:-4] + "_mlist.bin" print " ->", mlistname try: # Wait for a process to stop before starting # the next one if we are at the limit. if (process_count >= max_processes): description, rc = results.get() print description process_count -= 1 proc = subprocess.Popen( ['python', analysis_exe, file, mlistname, multi_xml]) procs.append(proc) thread.start_new_thread( process_waiter, (proc, "Finished: " + basename, results)) process_count += 1 except KeyboardInterrupt: for proc in procs: if (not proc.poll()): proc.send_signal(signal.CTRL_C_EVENT) # wait until all the processes finish try: while (process_count > 0): description, rc = results.get() print description process_count -= 1 except KeyboardInterrupt: for proc in procs: if (not proc.poll()): proc.send_signal(signal.CTRL_C_EVENT)
def loadMovie(self): movie_filename = str(QtGui.QFileDialog.getOpenFileName(self, "Load Movie", self.directory, "*.dax *.spe *.tif")) if movie_filename: self.directory = os.path.dirname(movie_filename) self.movie_file = datareader.inferReader(movie_filename) [self.film_x, self.film_y, self.film_l] = self.movie_file.filmSize() self.ui.fileLabel.setText(movie_filename) self.cur_frame = 0 self.multi_list = False self.incCurFrame(0)
def batchAnalysis(analysis_exe, input_directory, output_directory, multi_xml, max_processes = 2): minimum_length = 100 dax_files = glob.glob(input_directory + "*.dax") # setup process queue process_count = 0 results = Queue.Queue() # start processes procs = [] for i, file in enumerate(dax_files): print "Found:", file movie_obj = datareader.inferReader(file) if(movie_obj.filmSize()[2] > minimum_length): basename = os.path.basename(file) mlistname = output_directory + "/" + basename[:-4] + "_mlist.bin" print " ->",mlistname try: # Wait for a process to stop before starting # the next one if we are at the limit. if(process_count >= max_processes): description, rc = results.get() print description process_count -= 1 proc = subprocess.Popen(['python', analysis_exe, file, mlistname, multi_xml]) procs.append(proc) thread.start_new_thread(process_waiter, (proc, "Finished: " + basename, results)) process_count += 1 except KeyboardInterrupt: for proc in procs: if(not proc.poll()): proc.send_signal(signal.CTRL_C_EVENT) # wait until all the processes finish try: while(process_count>0): description, rc = results.get() print description process_count -= 1 except KeyboardInterrupt: for proc in procs: if(not proc.poll()): proc.send_signal(signal.CTRL_C_EVENT)
# if __name__ == "__main__": import numpy import camera.frame as frame # This file is available in the ZhuangLab storm-analysis project on github. import sa_library.datareader as datareader if (len(sys.argv) != 4): print "usage: <settings> <movie_in> <png_out>" exit() # Open movie & get size. data_file = datareader.inferReader(sys.argv[2]) [width, height, length] = data_file.filmSize() # Start spotCounter as a stand-alone application. app = QtGui.QApplication(sys.argv) parameters = params.halParameters(sys.argv[1]) parameters.set("setup_name", "offline") parameters.set("camera1.x_pixels", width) parameters.set("camera1.y_pixels", height) parameters.set("camera1.x_bin", 1) parameters.set("camera1.y_bin", 1) spotCounter = SingleSpotCounter(None, parameters) #spotCounter.newParameters(parameters, [[255,255,255]]) spotCounter.newParameters(parameters)
# setup process queue results = Queue.Queue() def process_waiter(popen, description, que): try: popen.wait() finally: que.put((description, popen.returncode)) process_count = 0 # start processes procs = [] for i, file in enumerate(dax_files): print "Found:", file movie_obj = datareader.inferReader(file) if(movie_obj.filmSize()[2] > minimum_length): basename = os.path.basename(file) mlistname = output_directory + "/" + basename[:-4] + "_mlist.bin" print " ->",mlistname try: # Wait for a process to stop before starting # the next one if we are at the limit. if(process_count >= max_processes): description, rc = results.get() print description process_count -= 1 proc = subprocess.Popen(['python', mufit_exe, file, mlistname, multi_xml]) procs.append(proc) thread.start_new_thread(process_waiter, (proc, "Finished: " + basename, results))
# if __name__ == "__main__": import numpy import camera.frame as frame # This file is available in the ZhuangLab storm-analysis project on github. import sa_library.datareader as datareader if (len(sys.argv) != 4): print "usage: <settings> <movie_in> <png_out>" exit() # Open movie & get size. data_file = datareader.inferReader(sys.argv[2]) [width, height, length] = data_file.filmSize() # Start spotCounter as a stand-alone application. app = QtGui.QApplication(sys.argv) parameters = params.halParameters(sys.argv[1]) parameters.set("setup_name", "offline") parameters.set("camera1.x_pixels", width) parameters.set("camera1.y_pixels", height) parameters.set("camera1.x_bin", 1) parameters.set("camera1.y_bin", 1) spotCounter = SingleSpotCounter(None, parameters) spotCounter.newParameters(parameters)
# import numpy import sys import sa_library.datareader as datareader import sa_library.daxwriter as daxwriter import scmos_utilities_c if (len(sys.argv) != 6): print "usage: <input_dax> <output_dax> <calib> <sigma> <frames>" exit() # Open the input file. in_file = datareader.inferReader(sys.argv[1]) f_len = in_file.filmSize()[2] if (int(sys.argv[5]) > 0) and (int(sys.argv[5]) < f_len): f_len = int(sys.argv[5]) # Open the output file. out_file = daxwriter.DaxWriter(sys.argv[2], 0, 0) # Load camera calibration (sliced as appropriate # for the ROI) and create the smoother class. [offset, variance, gain] = numpy.load(sys.argv[3]) smoother = scmos_utilities_c.Smoother(offset, variance, gain) # Load images, smooth & output. sigma_psf = int(round(float(sys.argv[4]))) for i in range(f_len):
def peakFinding(find_peaks, movie_file, mlist_file, parameters): # open files for input & output movie_data = datareader.inferReader(movie_file) [movie_x,movie_y,movie_l] = movie_data.filmSize() # if the i3 file already exists, read it in, # write it out & start the analysis from the # end. total_peaks = 0 if(os.path.exists(mlist_file)): print "Found", mlist_file i3data_in = readinsight3.loadI3File(mlist_file) try: curf = int(numpy.max(i3data_in['fr'])) except ValueError: curf = 0 print " Starting analysis at frame:", curf i3data = writeinsight3.I3Writer(mlist_file) if (curf > 0): i3data.addMolecules(i3data_in) total_peaks = i3data_in['x'].size else: curf = 0 i3data = writeinsight3.I3Writer(mlist_file) # process parameters if hasattr(parameters, "start_frame"): if (parameters.start_frame>=curf) and (parameters.start_frame<movie_l): curf = parameters.start_frame if hasattr(parameters, "max_frame"): if (parameters.max_frame>0) and (parameters.max_frame<movie_l): movie_l = parameters.max_frame # analyze the movie # catch keyboard interrupts & "gracefully" exit. try: while(curf<movie_l): #for j in range(l): # Set up the analysis. image = movie_data.loadAFrame(curf) - parameters.baseline mask = (image < 1.0) if (numpy.sum(mask) > 0): print " Removing negative values in frame", curf image[mask] = 1.0 # Find and fit the peaks. [peaks, residual] = find_peaks.analyzeImage(image) # Save the peaks. if (type(peaks) == type(numpy.array([]))): # remove unconverged peaks peaks = find_peaks.getConvergedPeaks(peaks) # save results if(parameters.orientation == "inverted"): i3data.addMultiFitMolecules(peaks, movie_x, movie_y, curf+1, parameters.pixel_size, inverted = True) else: i3data.addMultiFitMolecules(peaks, movie_x, movie_y, curf+1, parameters.pixel_size, inverted = False) total_peaks += peaks.shape[0] print "Frame:", curf, peaks.shape[0], total_peaks else: print "Frame:", curf, 0, total_peaks curf += 1 print "" i3data.close() find_peaks.cleanUp() return 0 except KeyboardInterrupt: print "Analysis stopped." i3data.close() find_peaks.cleanUp() return 1
def peakFinding(find_peaks, movie_file, mlist_file, parameters): # open files for input & output movie_data = datareader.inferReader(movie_file) [movie_x, movie_y, movie_l] = movie_data.filmSize() # if the i3 file already exists, read it in, # write it out & start the analysis from the # end. total_peaks = 0 if (os.path.exists(mlist_file)): print "Found", mlist_file i3data_in = readinsight3.loadI3File(mlist_file) try: curf = int(numpy.max(i3data_in['fr'])) except ValueError: curf = 0 print " Starting analysis at frame:", curf i3data = writeinsight3.I3Writer(mlist_file) if (curf > 0): i3data.addMolecules(i3data_in) total_peaks = i3data_in['x'].size else: curf = 0 i3data = writeinsight3.I3Writer(mlist_file) # process parameters if hasattr(parameters, "start_frame"): if (parameters.start_frame >= curf) and (parameters.start_frame < movie_l): curf = parameters.start_frame if hasattr(parameters, "max_frame"): if (parameters.max_frame > 0) and (parameters.max_frame < movie_l): movie_l = parameters.max_frame # analyze the movie # catch keyboard interrupts & "gracefully" exit. try: while (curf < movie_l): #for j in range(l): # Set up the analysis. image = movie_data.loadAFrame(curf) - parameters.baseline mask = (image < 1.0) if (numpy.sum(mask) > 0): print " Removing negative values in frame", curf image[mask] = 1.0 # Find and fit the peaks. [peaks, residual] = find_peaks.analyzeImage(image) # Save the peaks. if (type(peaks) == type(numpy.array([]))): # remove unconverged peaks peaks = find_peaks.getConvergedPeaks(peaks) # save results if (parameters.orientation == "inverted"): i3data.addMultiFitMolecules(peaks, movie_x, movie_y, curf + 1, parameters.pixel_size, inverted=True) else: i3data.addMultiFitMolecules(peaks, movie_x, movie_y, curf + 1, parameters.pixel_size, inverted=False) total_peaks += peaks.shape[0] print "Frame:", curf, peaks.shape[0], total_peaks else: print "Frame:", curf, 0, total_peaks curf += 1 print "" i3data.close() find_peaks.cleanUp() return 0 except KeyboardInterrupt: print "Analysis stopped." i3data.close() find_peaks.cleanUp() return 1
import sa_library.ia_utilities_c as util_c import sa_library.datareader as datareader import sa_library.readinsight3 as readinsight3 if (len(sys.argv) != 4): print "usage: homotopy_psf <dax_file, input> <bin_file, input> <npy_file, output>" exit() # Minimum number of peaks to calculate the PSF from. min_peaks = 500 # Half width of the aoi size in pixels. aoi_size = 8 # Load dax file and corresponding molecule list file. dax_data = datareader.inferReader(sys.argv[1]) i3_data = readinsight3.loadI3File(sys.argv[2]) # Go through the frames identifying good peaks and adding them # to the average psf average_psf = numpy.zeros((4 * aoi_size, 4 * aoi_size)) curf = 1 peaks_used = 0 total = 0.0 [dax_x, dax_y, dax_l] = dax_data.filmSize() while (curf < dax_l) and (peaks_used < min_peaks): # Select localizations in current frame & not near the edges. mask = (i3_data['fr'] == curf) & (i3_data['x'] > aoi_size) & ( i3_data['x'] < (dax_y - aoi_size - 1)) & (i3_data['y'] > aoi_size) & ( i3_data['y'] < (dax_x - aoi_size - 1))
if not os.path.exists(acq_folder + "avg561ffc.tif"): os.mkdir(acq_folder + "dist_corr//") # determine the 99th percentile of intensity values for all pixels in the conventional images # find all the Visconv movies Visconv_files = glob.glob(acq_folder + 'Visconv_' + '*.dax') if len(Visconv_files) > 0: cnt = 0 # pad matrices aperc_v488 = [0] * len(Visconv_files) aperc_v561 = [0] * len(Visconv_files) aperc_v647 = [0] * len(Visconv_files) for file in Visconv_files: # read 647 image intensities and load to matrix dax_file = daxspereader.inferReader(file) image = dax_file.loadAFrame(6).astype(numpy.uint16) aperc_v647[cnt] = numpy.percentile(image, 99.999) # read 561 image intensities and load to matrix image = dax_file.loadAFrame(11).astype(numpy.uint16) aperc_v561[cnt] = numpy.percentile(image, 99.999) # read 488 image intensities and load to matrix image = dax_file.loadAFrame(19).astype(numpy.uint16) aperc_v488[cnt] = numpy.percentile(image, 99.999) cnt = cnt + 1 # find all the IRconv movies IRconv_files = glob.glob(acq_folder + 'IRconv_' + '*.dax') if len(IRconv_files) > 0: cnt = 0
""" return image - self.estimateBG(image, iterations, threshold, wavelet_level) if (__name__ == "__main__"): import sys import sa_library.datareader as datareader import sa_library.daxwriter as daxwriter if (len(sys.argv) < 6): print "usage <movie> <wavelet_type> <wavelet_level> <iterations> <threshold> <baseline (optional, 100 default)>" exit() input_movie = datareader.inferReader(sys.argv[1]) output_dax = daxwriter.DaxWriter("subtracted.dax", 0, 0) iterations = int(sys.argv[4]) threshold = float(sys.argv[5]) wavelet_level = int(sys.argv[3]) offset = 100.0 if (len(sys.argv) == 7): offset = float(sys.argv[6]) wbgr = WaveletBGR(wavelet_type = sys.argv[2]) for i in range(input_movie.filmSize()[2]): if((i%10) == 0):
return image - self.estimateBG(image, iterations, threshold, wavelet_level) if (__name__ == "__main__"): import sys import sa_library.datareader as datareader import sa_library.daxwriter as daxwriter if (len(sys.argv) < 6): print "usage <movie> <wavelet_type> <wavelet_level> <iterations> <threshold> <baseline (optional, 100 default)>" exit() input_movie = datareader.inferReader(sys.argv[1]) output_dax = daxwriter.DaxWriter("subtracted.dax", 0, 0) iterations = int(sys.argv[4]) threshold = float(sys.argv[5]) wavelet_level = int(sys.argv[3]) offset = 100.0 if (len(sys.argv) == 7): offset = float(sys.argv[6]) wbgr = WaveletBGR(wavelet_type=sys.argv[2]) for i in range(input_movie.filmSize()[2]): if ((i % 10) == 0):
import sa_library.ia_utilities_c as util_c import sa_library.datareader as datareader import sa_library.readinsight3 as readinsight3 if (len(sys.argv)!=4): print "usage: homotopy_psf <dax_file, input> <bin_file, input> <npy_file, output>" exit() # Minimum number of peaks to calculate the PSF from. min_peaks = 500 # Half width of the aoi size in pixels. aoi_size = 8 # Load dax file and corresponding molecule list file. dax_data = datareader.inferReader(sys.argv[1]) i3_data = readinsight3.loadI3File(sys.argv[2]) # Go through the frames identifying good peaks and adding them # to the average psf average_psf = numpy.zeros((4*aoi_size,4*aoi_size)) curf = 1 peaks_used = 0 total = 0.0 [dax_x, dax_y, dax_l] = dax_data.filmSize() while (curf < dax_l) and (peaks_used < min_peaks): # Select localizations in current frame & not near the edges. mask = (i3_data['fr'] == curf) & (i3_data['x'] > aoi_size) & (i3_data['x'] < (dax_y - aoi_size - 1)) & (i3_data['y'] > aoi_size) & (i3_data['y'] < (dax_x - aoi_size - 1)) xr = i3_data['x'][mask] yr = i3_data['y'][mask]
spot_list.pixel_size = pix_to_nm spot_list.nr_spots = localization_number spot_list.nr_channels = len(channels) # These are always the same. spot_list.nr_slices = 1 spot_list.nr_pos = 1 spot_list.fit_mode = 1 spot_list.location_units = 0 spot_list.intensity_units = 0 spot_list.is_track = False # If a dax file is provided, get the film size. if os.path.exists(sys.argv[1]): data_reader = datareader.inferReader(sys.argv[1]) [x, y, l] = data_reader.filmSize() spot_list.nr_pixels_x = x spot_list.nr_pixels_y = y spot_list.nr_frames = l spot_list_offset = tsf_file.tell() - 12 out = spot_list.SerializeToString() out = encoder._VarintBytes(len(out)) + out tsf_file.write(out) # Rewind to the beginning and record the offset of the SpotList message. tsf_file.seek(4) setV(tsf_file, ">Q", spot_list_offset)