def configureTest(): """ These tests have a lot of setup. This function takes care of this. """ mparams = params.ParametersMultiplane() # sCMOS calibration files. gain = numpy.ones(im_size) offset = numpy.zeros(im_size) variance = numpy.ones(im_size) rqe = numpy.ones(im_size) cal_file = storm_analysis.getPathOutputTest("c1_cal.npy") numpy.save(cal_file, [offset, variance, gain, rqe, 2]) mparams.changeAttr("channel0_cal", cal_file) cal_file = storm_analysis.getPathOutputTest("c2_cal.npy") numpy.save(cal_file, [offset, variance, gain, rqe, 2]) mparams.changeAttr("channel1_cal", cal_file) mparams.changeAttr("channel0_ext", "_c1.tif") mparams.changeAttr("channel1_ext", "_c2.tif") mparams.changeAttr("channel0_offset", 0) mparams.changeAttr("channel1_offset", 0) return mparams
def analyze(base_name, mlist_name, olist_name, settings_name): parameters = params.ParametersMultiplane().initFromFile(settings_name) finder = PFPeakFinder(parameters) fitter = findPeaksStd.MPPeakFitter(parameters) finder_fitter = PFPeakFinderFitter(parameters, finder, fitter) reader = PFMovieReader(base_name=base_name, bin_name=olist_name, parameters=parameters) stdAnalysis.standardAnalysis(finder_fitter, reader, mlist_name, parameters)
def analyze(base_name, mlist_name, settings_name): parameters = params.ParametersMultiplane().initFromFile(settings_name) finder = findPeaksStd.MPPeakFinder(parameters) fitter = findPeaksStd.MPPeakFitter(parameters) finder_fitter = findPeaksStd.MPFinderFitter(parameters, finder, fitter) reader = findPeaksStd.MPMovieReader(base_name = base_name, parameters = parameters) data_writer = findPeaksStd.MPDataWriter(data_file = mlist_name, parameters = parameters) stdAnalysis.standardAnalysis(finder_fitter, reader, data_writer, parameters)
def splitPeaks(mlist_filename, params_filename): parameters = params.ParametersMultiplane().initFromFile(params_filename) # Load the plane to plane mapping data. mappings = {} if parameters.hasAttr("mapping"): if os.path.exists(parameters.getAttr("mapping")): with open(parameters.getAttr("mapping"), 'rb') as fp: mappings = pickle.load(fp) else: print("No mapping file parameter, nothing to do") # Load frame offset information. frame_offsets = list( map(parameters.getAttr, mpUtilC.getOffsetAttrs(parameters))) print(frame_offsets) # Load the molecule list. ch0_data = readinsight3.loadI3File(mlist_filename) # Map to other channels. basename = mlist_filename[:-4] channel = 1 m_key = "0_1_" while (m_key + "x") in mappings: chn_data = ch0_data.copy() # Map x. tx = mappings[m_key + "x"] chn_data['x'] = tx[0] + ch0_data['x'] * tx[1] + ch0_data['y'] * tx[2] # Map y. ty = mappings[m_key + "y"] chn_data['y'] = ty[0] + ch0_data['x'] * ty[1] + ch0_data['y'] * ty[2] # Map frame. chn_data[ 'fr'] = ch0_data['fr'] - frame_offsets[0] + frame_offsets[channel] with writeinsight3.I3Writer(basename + "_ch" + str(channel) + ".bin") as i3w: i3w.addMolecules(chn_data) channel += 1 m_key = "0_" + str(channel) + "_"
def analyze(base_name, mlist_name, settings_name): parameters = params.ParametersMultiplane().initFromFile(settings_name) # Set to only analyze 1 frame, 1 iteration of peak finding. parameters.setAttr("max_frame", "int", 1) parameters.setAttr("iterations", "int", 1) # Analyze one frame. finder = PFPeakFinder(parameters) fitter = PFPeakFitter(parameters) finder_fitter = findPeaksStd.MPFinderFitter(parameters, finder, fitter) reader = findPeaksStd.MPMovieReader(base_name=base_name, parameters=parameters) stdAnalysis.standardAnalysis(finder_fitter, reader, mlist_name, parameters) # Evaluate found vs fit parameters. hi = utilC.getHeightIndex() xi = utilC.getXCenterIndex() yi = utilC.getYCenterIndex() # First identify peak pairs. fi_x = fitted_peaks[:, xi] fi_y = fitted_peaks[:, yi] fo_x = found_peaks[:, xi] fo_y = found_peaks[:, yi] dd = utilC.peakToPeakDist(fo_x, fo_y, fi_x, fi_y) di = utilC.peakToPeakIndex(fo_x, fo_y, fi_x, fi_y) print(numpy.mean(dd), fi_x.size, fo_x.size) fo_h = [] fi_h = [] for i in range(dd.size): if (dd[i] < 2.0): fo_h.append(found_peaks[i, hi]) fi_h.append(fitted_peaks[di[i], hi]) fi_h = numpy.array(fi_h) fo_h = numpy.array(fo_h) print(numpy.mean(fi_h), fi_h.size) print(numpy.mean(fo_h), fo_h.size) print(numpy.mean(fi_h) / numpy.mean(fo_h))
def test_offset_2(): """ Movie reading test with non-zero offset. """ # Create XML file and sCMOS calibration files. mparams = configureTest() xml_file = storm_analysis.getPathOutputTest("mp_analysis.xml") mparams.changeAttr("channel1_offset", 1) mparams.toXMLFile(xml_file) # Create movies. mv_file = storm_analysis.getPathOutputTest("mp_c1.tif") with tifffile.TiffWriter(mv_file) as tf: for i in range(10): im = (i + 1) * numpy.ones(im_size, dtype=numpy.int16) tf.save(im.astype(numpy.int16)) mv_file = storm_analysis.getPathOutputTest("mp_c2.tif") with tifffile.TiffWriter(mv_file) as tf: for i in range(10): im = (i + 1) * numpy.ones(im_size, dtype=numpy.int16) tf.save(im.astype(numpy.int16)) # Create and test MPMovieReader mpmr = analysis_io.MPMovieReader( base_name=os.path.join(storm_analysis.getPathOutputTest(), "mp"), parameters=params.ParametersMultiplane().initFromFile(xml_file)) mpmr.setup(0) [mx, my, ml] = mpmr.getFilmSize() assert (mx == im_size[1]) assert (my == im_size[0]) assert (ml == 9) # Check that all of the frames are the same. for i in range(ml): frames = mpmr.getFrames(i) assert (numpy.allclose(frames[0], frames[1] - 1))
parser.add_argument( '--photons', dest='photons', type=int, required=True, help="An estimate of the average number of photons in the localization." ) parser.add_argument('--xml', dest='xml', type=str, required=True, help="The name of the settings xml file.") args = parser.parse_args() parameters = params.ParametersMultiplane().initFromFile(args.xml) spline_file_names = [] for spline_attr in mpUtilC.getSplineAttrs(parameters): spline_file_names.append(parameters.getAttr(spline_attr)) # # FIXME: Variances or weights need to be adjusted in x, y based on # the mapping. This won't make much difference for symmetric # PSFs but it is currently incorrect for asymmetric PSFs. # variances = planeVariances(args.background, args.photons, parameters.getAttr("pixel_size"), spline_file_names) weights = { "bg": planeWeights(variances[0]),
def findOffsets(base_name, params_file, background_scale=4.0, foreground_scale=1.0): """ The 'main' function of this module. base_name - The basename for the group of movies. params_file - An analysis XML file containing the details for this experiment. background_scale - Features in the background change on this scale (in pixels) or more slowly. foreground_scale - Features that change on this scale are likely foreground. Notes: 1. This only checks a limited range of offsets between the two channels. 2. This assumes that the movies are longer than just a few frames. """ n_tests = 10 search_range = 5 # Load parameters. parameters = params.ParametersMultiplane().initFromFile(params_file) # Load the movies from each camera. n_channels = 0 movies = [] for ext in mpUtil.getExtAttrs(parameters): movie_name = base_name + parameters.getAttr(ext) movies.append(datareader.inferReader(movie_name)) n_channels += 1 print("Found", n_channels, "movies.") # Load sCMOS calibration data. offsets = [] gains = [] for calib_name in mpUtil.getCalibrationAttrs(parameters): [offset, variance, gain, rqe] = analysisIO.loadCMOSCalibration(parameters.getAttr(calib_name)) offsets.append(offset) gains.append(1.0 / gain) assert (len(offsets) == n_channels) # Load the plane to plane mapping data & create affine transform objects. mappings = {} with open(parameters.getAttr("mapping"), 'rb') as fp: mappings = pickle.load(fp) atrans = [] for i in range(n_channels - 1): xt = mappings["0_" + str(i + 1) + "_x"] yt = mappings["0_" + str(i + 1) + "_y"] atrans.append(affineTransformC.AffineTransform(xt=xt, yt=yt)) # Create background and foreground variance filters. # # FIXME: Is this right for movies that are not square? # [y_size, x_size] = movies[0].filmSize()[:2] psf = dg.drawGaussiansXY((x_size, y_size), numpy.array([0.5 * x_size]), numpy.array([0.5 * y_size]), sigma=background_scale) psf = psf / numpy.sum(psf) bg_filter = matchedFilterC.MatchedFilter(psf) psf = dg.drawGaussiansXY((x_size, y_size), numpy.array([0.5 * x_size]), numpy.array([0.5 * y_size]), sigma=foreground_scale) psf = psf / numpy.sum(psf) fg_filter = matchedFilterC.MatchedFilter(psf) var_filter = matchedFilterC.MatchedFilter(psf * psf) # Check background estimation. if False: frame = loadImage(movies[0], 0, offsets[0], gain[0]) frame_bg = estimateBackground(frame, bg_filter, fg_filter, var_filter) with tifffile.TiffWriter("bg_estimate.tif") as tif: tif.save(frame.astype(numpy.float32)) tif.save(frame_bg.astype(numpy.float32)) tif.save((frame - frame_bg).astype(numpy.float32)) votes = numpy.zeros((n_channels - 1, 2 * search_range + 1)) for i in range(n_tests): print("Test", i) # Load reference frame. ref_frame = loadImage(movies[0], search_range + i, offsets[0], gain[0]) ref_frame_bg = estimateBackground(ref_frame, bg_filter, fg_filter, var_filter) ref_frame -= ref_frame_bg # Load test frames and measure correlation. for j in range(n_channels - 1): best_corr = 0.0 best_offset = 0 for k in range(-search_range, search_range + 1): test_frame = loadImage(movies[j + 1], search_range + i + k, offsets[j + 1], gain[j + 1], transform=atrans[j]) test_frame_bg = estimateBackground(test_frame, bg_filter, fg_filter, var_filter) test_frame -= test_frame_bg test_frame_corr = numpy.sum( ref_frame * test_frame) / numpy.sum(test_frame) if (test_frame_corr > best_corr): best_corr = test_frame_corr best_offset = k + search_range votes[j, best_offset] += 1 # Print results. print("Offset votes:") print(votes) frame_offsets = [0] frame_offsets += list(numpy.argmax(votes, axis=1) - search_range) print("Best offsets:") for i in range(n_channels): print(str(i) + ": " + str(frame_offsets[i])) # Create stacks with optimal offsets. print("Saving image stacks.") for i in range(n_channels): with tifffile.TiffWriter("find_offsets_ch" + str(i) + ".tif") as tif: for j in range(5): if (i == 0): frame = loadImage(movies[i], search_range + frame_offsets[i] + j, offsets[i], gain[i]) else: frame = loadImage(movies[i], search_range + frame_offsets[i] + j, offsets[i], gain[i], transform=atrans[i - 1]) frame_bg = estimateBackground(frame, bg_filter, fg_filter, var_filter) frame -= frame_bg tif.save(frame.astype(numpy.float32))