def collateRQE(dirs, settings): """ Results collation for RQE correction. """ for a_dir in dirs: print("Processing", a_dir) t_locs = saH5Py.loadLocalizations("grid_list.hdf5", fields=["x", "y"]) t_locs_found = numpy.zeros_like(t_locs["x"]) n_frames = 0 with saH5Py.SAH5Py(os.path.join(a_dir, "test.hdf5")) as h5: for i in range(h5.getMovieLength()): n_frames += 1 m_locs = h5.getLocalizationsInFrame(i, fields=["x", "y"]) dist = iaUtilsC.peakToPeakDistAndIndex(t_locs['x'], t_locs['y'], m_locs['x'], m_locs['y'], max_distance=3)[0] for j in range(dist.size): if (dist[j] > -0.1): t_locs_found[j] += 1 # Check results against the binomial distribution. p = numpy.sum(t_locs_found) / (n_frames * t_locs["x"].size) print(" Mean P found : {0:.3f}".format(p)) print(" Expected variance: {0:.3f}".format(n_frames * p * (1 - p))) print(" Actual variance : {0:.3f}".format(numpy.var(t_locs_found))) print()
def makeData(): index = 1 # Create 'tracked' files with different numbers of localizations # randomly pulled from the clusters file. # locs = saH5Py.loadLocalizations("clusters_list.hdf5", fields = ["x", "y"]) i_arr = numpy.arange(locs["x"].size) for reps in settings.n_reps: wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) with saH5Py.SAH5Py(wdir + "/test.hdf5", is_existing = False, overwrite = True) as h5: h5.setMovieInformation(settings.x_size, settings.y_size, 1, "") h5.setPixelSize(settings.pixel_size) for i in range(reps): track_id = numpy.arange(i * settings.n_tracks_in_group, (i+1) * settings.n_tracks_in_group, dtype = numpy.int64) numpy.random.shuffle(i_arr) lx = locs["x"][i_arr] ly = locs["y"][i_arr] h5.addTracks({"x" : lx[:settings.n_tracks_in_group], "y" : ly[:settings.n_tracks_in_group], "track_id" : track_id}) index += 1
def makeData(): index = 1 # Create HDF5 files for each plane. # for elt in ["grid_list.hdf5", "random_storm.hdf5"]: locs = saH5Py.loadLocalizations(elt) locs["color"] = numpy.random.randint(4, size=locs["x"].size) zo = locs["z"].copy() locs["z"][:] = zo + 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("sim_input_c1_" + elt, locs) for i in range(1, 4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = zo + 1.0e-3 * settings.z_planes[i] saH5Py.saveLocalizations("sim_input_c" + str(i + 1) + "_" + elt, locs) if True: # Create a movie for each plane. for [bg, photons] in settings.photons: # Adjust photons by the number of planes. photons = photons / float(len(settings.z_planes)) wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) for i in range(4): bg_f = lambda s, x, y, i3: background.UniformBackground( s, x, y, i3, photons=bg) cam_f = lambda s, x, y, i3: camera.SCMOS( s, x, y, i3, "calib.npy") pp_f = lambda s, x, y, i3: photophysics.AlwaysOnMC( s, x, y, i3, color=i, photons=photons) psf_f = lambda s, x, y, i3: psf.PupilFunction( s, x, y, i3, settings.pixel_size, []) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) sim.simulate(wdir + "/test_c" + str(i + 1) + ".dax", "sim_input_c" + str(i + 1) + "_grid_list.hdf5", settings.n_frames) index += 1
def collate(): dirs = sorted(glob.glob("test*")) if (len(dirs) == 0): print("No test directories found.") exit() # Load reference localizations. ref = saH5Py.loadLocalizations("sim_input_c1_grid_list.hdf5", fields=["color", "x", "y"]) for a_dir in dirs: # Check color correspondence. # # Note: Currently only works for gridded localizations. # exp = saH5Py.loadTracks(a_dir + "/test.hdf5", fields=["x", "y", "km_color"]) # Identify corresponding peaks with 2 pixel maximum radius. p_index = iaUtilsC.peakToPeakDistAndIndex(exp["x"], exp["y"], ref["x"], ref["y"], max_distance=2.0)[1] # Create array for checking category correspondence. c_size = numpy.count_nonzero(p_index > -1) categories = numpy.zeros((c_size, 2), dtype=numpy.int32) i = 0 for j in range(p_index.size): if (p_index[j] < 0): continue categories[i, 0] = int(ref["color"][p_index[j]]) categories[i, 1] = int(exp["km_color"][j]) i += 1 # Measure fraction of experimental localizations assigned correctly. This # is complicated by the k-mean category being arbitrary. for i in range(8): ref_mask = (categories[:, 0] == i) if (numpy.count_nonzero(ref_mask) > 0): exp_cat = int(numpy.median(categories[ref_mask, 1])) exp_mask = (categories[:, 1] == exp_cat) total = numpy.count_nonzero(exp_mask) matched = numpy.count_nonzero( numpy.logical_and(ref_mask, exp_mask)) mismatched = total - matched print( "Color {0:0d}, matching fraction is {1:.2f}, unmatched fraction is {2:.2f}, total {3:0d}" .format(i, matched / total, mismatched / total, total))
def collate(): dirs = sorted(glob.glob("test*")) if(len(dirs) == 0): print("No test directories found.") exit() # Load reference localizations. ref = saH5Py.loadLocalizations("sim_input_c1_grid_list.hdf5", fields = ["color", "x", "y"]) for a_dir in dirs: # Check color correspondence. # # Note: Currently only works for gridded localizations. # exp = saH5Py.loadTracks(a_dir + "/test.hdf5", fields = ["x", "y", "km_color"]) # Identify corresponding peaks with 2 pixel maximum radius. p_index = iaUtilsC.peakToPeakDistAndIndex(exp["x"], exp["y"], ref["x"], ref["y"], max_distance = 2.0)[1] # Create array for checking category correspondence. c_size = numpy.count_nonzero(p_index > -1) categories = numpy.zeros((c_size, 2), dtype = numpy.int32) i = 0 for j in range(p_index.size): if (p_index[j] < 0): continue categories[i,0] = int(ref["color"][p_index[j]]) categories[i,1] = int(exp["km_color"][j]) i += 1 # Measure fraction of experimental localizations assigned correctly. This # is complicated by the k-mean category being arbitrary. for i in range(8): ref_mask = (categories[:,0] == i) if(numpy.count_nonzero(ref_mask) > 0): exp_cat = int(numpy.median(categories[ref_mask,1])) exp_mask = (categories[:,1] == exp_cat) total = numpy.count_nonzero(exp_mask) matched = numpy.count_nonzero(numpy.logical_and(ref_mask, exp_mask)) mismatched = total - matched print("Color {0:0d}, matching fraction is {1:.2f}, unmatched fraction is {2:.2f}, total {3:0d}".format(i, matched/total, mismatched/total, total))
def makeData(): index = 1 # Create 'tracked' files with different numbers of localizations # randomly pulled from the clusters file. # locs = saH5Py.loadLocalizations("clusters_list.hdf5", fields=["x", "y"]) i_arr = numpy.arange(locs["x"].size) for reps in settings.n_reps: wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) with saH5Py.SAH5Py(os.path.join(wdir, "test.hdf5"), is_existing=False, overwrite=True) as h5: h5.setMovieInformation(settings.x_size, settings.y_size, 1, "") h5.setPixelSize(settings.pixel_size) for i in range(reps): track_id = numpy.arange(i * settings.n_tracks_in_group, (i + 1) * settings.n_tracks_in_group, dtype=numpy.int64) numpy.random.shuffle(i_arr) lx = locs["x"][i_arr] ly = locs["y"][i_arr] h5.addTracks({ "x": lx[:settings.n_tracks_in_group], "y": ly[:settings.n_tracks_in_group], "track_id": track_id }) index += 1
def test_zcal_5(): """ Test that the z_calibration and fitz_c agree on the parameters. """ pixel_size = 100.0 zv = numpy.arange(-0.6, 0.601, 0.01) wx_params = [3.0, 0.3, 0.5] wx = zCalibration.zcalib0(wx_params, zv) wy_params = [3.0, -0.3, 0.5] wy = zCalibration.zcalib0(wy_params, zv) # Write HDF5 file. h5_name = storm_analysis.getPathOutputTest("test_3ddao_zcal.hdf5") with saH5Py.SAH5Py(h5_name, is_existing = False, overwrite = True) as h5: h5.setMovieInformation(100, 100, wx.size, "") h5.setPixelSize(pixel_size) for i in range(wx.size): locs = {"x" : numpy.array([1.0]), "y" : numpy.array([1.0]), "xsigma" : numpy.array([0.5 * wx[i]]), "ysigma" : numpy.array([0.5 * wy[i]])} h5.addLocalizations(locs, i) # Format parameters for fitzC. # wx_params = zCalibration.convertUnits(wx_params, pixel_size) wy_params = zCalibration.convertUnits(wy_params, pixel_size) # Fit z values. # fitzC.fitz(h5_name, 1.0, wx_params, wy_params, -0.7, 0.7) # Check results. fz = saH5Py.loadLocalizations(h5_name, fields = ["z"])["z"] assert(numpy.allclose(zv, fz, atol = 0.01, rtol = 0.01))
def configure(psf_model, no_splines): # Create parameters file for analysis. # print("Creating XML file.") params = testingParameters(psf_model) params.toXMLFile("multiplane.xml") # Create localization on a grid file. # print("Creating gridded localization.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call([ "python", sim_path + "emitters_on_grid.py", "--bin", "grid_list.hdf5", "--nx", str(settings.nx), "--ny", str(settings.ny), "--spacing", "20", "--zrange", str(settings.test_z_range), "--zoffset", str(settings.test_z_offset) ]) # Create randomly located localizations file. # print("Creating random localization.") subprocess.call([ "python", sim_path + "emitters_uniform_random.py", "--bin", "random_list.hdf5", "--density", "1.0", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size), "--zrange", str(settings.test_z_range) ]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call([ "python", sim_path + "emitters_on_grid.py", "--bin", "psf_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40" ]) # Create sCMOS camera calibration files. # numpy.save("calib.npy", [ numpy.zeros( (settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain, numpy.ones((settings.y_size, settings.x_size)), 2 ]) # Create mapping file. with open("map.map", 'wb') as fp: pickle.dump(settings.mappings, fp) if no_splines: return multiplane_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/multi_plane/" # Create pupil functions for 'pupilfn'. if (psf_model == "pupilfn"): pupilfn_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/pupilfn/" print("Creating pupil functions.") for i in range(len(settings.z_planes)): subprocess.call([ "python", pupilfn_path + "make_pupil_fn.py", "--filename", "c" + str(i + 1) + "_pupilfn.pfn", "--size", str(settings.psf_size), "--pixel-size", str(settings.pixel_size), "--zmn", str(settings.pupil_fn), "--z-offset", str(-settings.z_planes[i]) ]) # Both 'spline' and 'psf_fft' need measured PSFs. else: # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("psf_list.hdf5") for i, z_offset in enumerate(settings.z_planes): cx = settings.mappings["0_" + str(i) + "_x"] cy = settings.mappings["0_" + str(i) + "_y"] locs_temp = { "x": locs["x"].copy(), "y": locs["y"].copy(), "z": locs["z"].copy() } xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf locs_temp["z"][:] = z_offset saH5Py.saveLocalizations("c" + str(i + 1) + "_psf.hdf5", locs_temp) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.spline_z_range, settings.spline_z_range + 0.001, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5: drift.DriftFromFile( s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction( s, x, y, h5, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) for i in range(len(settings.z_planes)): sim.simulate("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_psf.hdf5", dz.size) # Measure the PSF. # print("Measuring PSFs.") psf_fft_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/psf_fft/" spliner_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/spliner/" for i in range(len(settings.z_planes)): subprocess.call([ "python", multiplane_path + "psf_zstack.py", "--movie", "c" + str(i + 1) + "_zcal.dax", "--bin", "c" + str(i + 1) + "_psf.hdf5", "--zstack", "c" + str(i + 1) + "_zstack", "--scmos_cal", "calib.npy", "--aoi_size", str(int(settings.psf_size / 2) + 1) ]) # Measure PSF and calculate spline for Spliner. # if (psf_model == "spline"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): subprocess.call([ "python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i + 1) + "_psf_normed.psf", "--z_range", str(settings.spline_z_range), "--normalize", "True" ]) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): subprocess.call([ "python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i + 1) + "_psf.psf", "--z_range", str(settings.spline_z_range) ]) norm_args = [ "python", multiplane_path + "normalize_psfs.py", "--psfs", "c1_psf.psf" ] for i in range(len(settings.z_planes) - 1): norm_args.append("c" + str(i + 2) + "_psf.psf") subprocess.call(norm_args) # Measure the spline for Spliner. # print("Measuring Spline.") for i in range(len(settings.z_planes)): subprocess.call([ "python", spliner_path + "psf_to_spline.py", "--psf", "c" + str(i + 1) + "_psf_normed.psf", "--spline", "c" + str(i + 1) + "_psf.spline", "--spline_size", str(settings.psf_size) ]) # Measure PSF and downsample for PSF FFT. # elif (psf_model == "psf_fft"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): subprocess.call([ "python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i + 1) + "_psf_normed.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize", "True" ]) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): subprocess.call([ "python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i + 1) + "_psf.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step) ]) norm_args = [ "python", multiplane_path + "normalize_psfs.py", "--psfs", "c1_psf.psf" ] for i in range(len(settings.z_planes) - 1): norm_args.append("c" + str(i + 2) + "_psf.psf") subprocess.call(norm_args) # Downsample the PSF to 1x for PSF FFT. print("Downsampling PSF.") for i in range(len(settings.z_planes)): subprocess.call([ "python", psf_fft_path + "downsample_psf.py", "--spliner_psf", "c" + str(i + 1) + "_psf_normed.psf", "--psf", "c" + str(i + 1) + "_psf_fft.psf", "--pixel-size", str(settings.pixel_size) ]) # Calculate Cramer-Rao weighting. # print("Calculating weights.") subprocess.call([ "python", multiplane_path + "plane_weighting.py", "--background", str(settings.photons[0][0]), "--photons", str(settings.photons[0][1]), "--output", "weights.npy", "--xml", "multiplane.xml", "--no_plots" ])
def configure(): # Get relevant paths. mm_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/micrometry/" mp_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/multi_plane/" sp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" # Create analysis XML files. # print("Creating XML files.") params = testingParametersSCMOS() params.toXMLFile("scmos.xml") params = testingParametersMC() params.toXMLFile("multicolor.xml") # Useful variables aoi_size = int(settings.psf_size / 2) + 1 # Create sCMOS data and HDF5 files we'll need for the simulation. # if True: # Create sCMOS camera calibration files. # numpy.save("calib.npy", [ numpy.zeros( (settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_gain, 1 ]) # Create localization on a grid file. # print("Creating gridded localizations.") sim_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call([ "python", sim_path + "emitters_on_grid.py", "--bin", "grid_list.hdf5", "--nx", str(settings.nx), "--ny", str(settings.ny), "--spacing", "20", "--zrange", str(settings.test_z_range), "--zoffset", str(settings.test_z_offset) ]) # Create randomly located localizations file (for STORM movies). # print("Creating random localizations.") subprocess.call([ "python", sim_path + "emitters_uniform_random.py", "--bin", "random_storm.hdf5", "--density", "1.0", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size), "--zrange", str(settings.test_z_range) ]) # Create randomly located localizations file (for mapping measurement). # print("Creating random localizations.") subprocess.call([ "python", sim_path + "emitters_uniform_random.py", "--bin", "random_map.hdf5", "--density", "0.0003", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size) ]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call([ "python", sim_path + "emitters_on_grid.py", "--bin", "psf_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40" ]) ## This part makes / tests measuring the mapping. ## if True: print("Measuring mapping.") # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1, 4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5", locs) # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1, 4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5", locs) # Make simulated mapping data. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, i3: psf.GaussianPSF(s, x, y, i3, settings. pixel_size) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) for i in range(4): sim.simulate("c" + str(i + 1) + "_map.dax", "c" + str(i + 1) + "_random_map.hdf5", 1) # Analyze simulated mapping data # for i in range(4): scmos.analyze("c" + str(i + 1) + "_map.dax", "c" + str(i + 1) + "_map.hdf5", "scmos.xml") # Measure mapping. # for i in range(3): subprocess.call([ "python", mm_path + "micrometry.py", "--locs1", "c1_map.hdf5", "--locs2", "c" + str(i + 2) + "_map.hdf5", "--results", "c1_c" + str(i + 2) + "_map.map", "--no_plots" ]) # Merge mapping. # subprocess.call([ "python", mm_path + "merge_maps.py", "--results", "map.map", "--maps", "c1_c2_map.map", "c1_c3_map.map", "c1_c4_map.map" ]) # Print mapping. # if True: print("Mapping is:") subprocess.call([ "python", mp_path + "print_mapping.py", "--mapping", "map.map" ]) print("") # Check that mapping is close to what we expect (within 5%). # with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i in range(3): if not numpy.allclose(mappings["0_" + str(i + 1) + "_x"], numpy.array( [settings.dx * (i + 1), 1.0, 0.0]), rtol=0.05, atol=0.05): print("X mapping difference for channel", i + 1) if not numpy.allclose(mappings["0_" + str(i + 1) + "_y"], numpy.array( [settings.dy * (i + 1), 0.0, 1.0]), rtol=0.05, atol=0.05): print("Y mapping difference for channel", i + 1) ## This part measures / test the PSF measurement. ## if True: # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.05, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5: drift.DriftFromFile( s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, settings. pixel_size, []) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) if True: for i in range(4): sim.simulate("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_random_map.hdf5", dz.size) # Get localizations to use for PSF measurement. # subprocess.call([ "python", mp_path + "psf_localizations.py", "--bin", "c1_map_ref.hdf5", "--map", "map.map", "--aoi_size", str(aoi_size) ]) # Create PSF z stacks. # for i in range(4): subprocess.call([ "python", mp_path + "psf_zstack.py", "--movie", "c" + str(i + 1) + "_zcal.dax", "--bin", "c1_map_ref_c" + str(i + 1) + "_psf.hdf5", "--zstack", "c" + str(i + 1) + "_zstack", "--scmos_cal", "calib.npy", "--aoi_size", str(aoi_size) ]) # Measure PSF. # for i in range(4): subprocess.call([ "python", mp_path + "measure_psf.py", "--zstack", "c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i + 1) + "_psf_normed.psf", "--z_range", str(settings.psf_z_range), "--normalize" ]) ## This part creates the splines. ## if True: print("Measuring Splines.") for i in range(4): subprocess.call([ "python", sp_path + "psf_to_spline.py", "--psf", "c" + str(i + 1) + "_psf_normed.psf", "--spline", "c" + str(i + 1) + "_psf.spline", "--spline_size", str(settings.psf_size) ]) ## This part measures the Cramer-Rao weights. ## if True: print("Calculating weights.") subprocess.call([ "python", mp_path + "plane_weighting.py", "--background", str(settings.photons[0][0]), "--photons", str(settings.photons[0][1]), "--output", "weights.npy", "--xml", "multicolor.xml", "--no_plots" ])
def configure(): # Get relevant paths. mm_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/micrometry/" mp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" sp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" # Create analysis XML files. # print("Creating XML files.") params = testingParametersSCMOS() params.toXMLFile("scmos.xml") params = testingParametersMC() params.toXMLFile("multicolor.xml") # Useful variables aoi_size = int(settings.psf_size/2)+1 # Create sCMOS data and HDF5 files we'll need for the simulation. # if True: # Create sCMOS camera calibration files. # numpy.save("calib.npy", [numpy.zeros((settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain, numpy.ones((settings.y_size, settings.x_size)), 2]) # Create localization on a grid file. # print("Creating gridded localizations.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "grid_list.hdf5", "--nx", str(settings.nx), "--ny", str(settings.ny), "--spacing", "20", "--zrange", str(settings.test_z_range), "--zoffset", str(settings.test_z_offset)]) # Create randomly located localizations file (for STORM movies). # print("Creating random localizations.") subprocess.call(["python", sim_path + "emitters_uniform_random.py", "--bin", "random_storm.hdf5", "--density", "1.0", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size), "--zrange", str(settings.test_z_range)]) # Create randomly located localizations file (for mapping measurement). # print("Creating random localizations.") subprocess.call(["python", sim_path + "emitters_uniform_random.py", "--bin", "random_map.hdf5", "--density", "0.0003", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size)]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "psf_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40"]) ## This part makes / tests measuring the mapping. ## if True: print("Measuring mapping.") # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1,4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i+1) + "_random_map.hdf5", locs) # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1,4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i+1) + "_random_map.hdf5", locs) # Make simulated mapping data. # bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10) cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy") pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, i3 : psf.GaussianPSF(s, x, y, i3, settings.pixel_size) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) for i in range(4): sim.simulate("c" + str(i+1) + "_map.dax", "c" + str(i+1) + "_random_map.hdf5", 1) # Analyze simulated mapping data # for i in range(4): scmos.analyze("c" + str(i+1) + "_map.dax", "c" + str(i+1) + "_map.hdf5", "scmos.xml") # Measure mapping. # for i in range(3): subprocess.call(["python", mm_path + "micrometry.py", "--locs1", "c1_map.hdf5", "--locs2", "c" + str(i+2) + "_map.hdf5", "--results", "c1_c" + str(i+2) + "_map.map", "--no_plots"]) # Merge mapping. # subprocess.call(["python", mm_path + "merge_maps.py", "--results", "map.map", "--maps", "c1_c2_map.map", "c1_c3_map.map", "c1_c4_map.map"]) # Print mapping. # if True: print("Mapping is:") subprocess.call(["python", mp_path + "print_mapping.py", "--mapping", "map.map"]) print("") # Check that mapping is close to what we expect (within 5%). # with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i in range(3): if not numpy.allclose(mappings["0_" + str(i+1) + "_x"], numpy.array([settings.dx*(i+1), 1.0, 0.0]), rtol = 0.05, atol = 0.05): print("X mapping difference for channel", i+1) if not numpy.allclose(mappings["0_" + str(i+1) + "_y"], numpy.array([settings.dy*(i+1), 0.0, 1.0]), rtol = 0.05, atol = 0.05): print("Y mapping difference for channel", i+1) ## This part measures / test the PSF measurement. ## if True: # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.05, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:,2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:,1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10) cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5 : drift.DriftFromFile(s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5 : psf.PupilFunction(s, x, y, h5, settings.pixel_size, []) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, drift_factory = drift_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) if True: for i in range(4): sim.simulate("c" + str(i+1) + "_zcal.dax", "c" + str(i+1) + "_random_map.hdf5", dz.size) # Get localizations to use for PSF measurement. # subprocess.call(["python", mp_path + "psf_localizations.py", "--bin", "c1_map_ref.hdf5", "--map", "map.map", "--aoi_size", str(aoi_size)]) # Create PSF z stacks. # for i in range(4): subprocess.call(["python", mp_path + "psf_zstack.py", "--movie", "c" + str(i+1) + "_zcal.dax", "--bin", "c1_map_ref_c" + str(i+1) + "_psf.hdf5", "--zstack", "c" + str(i+1) + "_zstack", "--scmos_cal", "calib.npy", "--aoi_size", str(aoi_size)]) # Measure PSF. # for i in range(4): subprocess.call(["python", mp_path + "measure_psf.py", "--zstack", "c" + str(i+1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i+1) + "_psf_normed.psf", "--z_range", str(settings.psf_z_range), "--normalize"]) ## This part creates the splines. ## if True: print("Measuring Splines.") for i in range(4): subprocess.call(["python", sp_path + "psf_to_spline.py", "--psf", "c" + str(i+1) + "_psf_normed.psf", "--spline", "c" + str(i+1) + "_psf.spline", "--spline_size", str(int(settings.psf_size/2))]) ## This part measures the Cramer-Rao weights. ## if True: print("Calculating weights.") subprocess.call(["python", mp_path + "plane_weighting.py", "--background", str(settings.photons[0][0]), "--photons", str(settings.photons[0][1]), "--output", "weights.npy", "--xml", "multicolor.xml", "--no_plots"])
def makeSampleData(mappings = None): # Create sample bead data for mapping measurement. # # Create randomly located localizations file (for STORM movies). # print("Creating random localizations.") emittersUniformRandom.emittersUniformRandom("random.hdf5", density, margin, x_size, y_size, 0.0) # Create mapping, if not specified. # if mappings is None: mappings = {"0_0_x" : numpy.array([0.0, 1.0, 0.0]), "0_0_y" : numpy.array([0.0, 0.0, 1.0]), "0_1_x" : numpy.array([2.0, 1.0, 0.0]), "0_1_y" : numpy.array([5.0, 0.0, 1.0]), "1_0_x" : numpy.array([-2.0, 1.0, 0.0]), "1_0_y" : numpy.array([-5.0, 0.0, 1.0])} # Figure out number of planes in the mapping. # n_planes = 0 for elt in mappings: [i, j] = map(int, elt.split("_")[:2]) if (i > n_planes): n_planes = i n_planes += 1 print(n_planes) # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("random.hdf5") for i in range(n_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] locs_temp = {"x" : locs["x"].copy(), "y" : locs["y"].copy(), "z" : locs["z"].copy()} xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf saH5Py.saveLocalizations("c" + str(i+1) + "_map.hdf5", locs_temp) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10) cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy") pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 10000.0) psf_f = lambda s, x, y, h5 : psf.PupilFunction(s, x, y, h5, pixel_size, []) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = x_size, y_size = y_size) for i in range(n_planes): sim.simulate("c" + str(i+1) + "_map.dax", "c" + str(i+1) + "_map.hdf5", 2)
def makeData(): index = 1 if True: # Create .bin files for each plane. h5_locs = saH5Py.loadLocalizations("grid_list.hdf5") # Load channel to channel mapping file. with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i, z_plane in enumerate(settings.z_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] xi = h5_locs["x"].copy() yi = h5_locs["y"].copy() zi = h5_locs["z"].copy() xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi zf = zi + z_plane h5_temp = {"x": xf, "y": yf, "z": zf} saH5Py.saveLocalizations("sim_input_c" + str(i + 1) + ".hdf5", h5_temp) # Create a movie for each plane. for [bg, photons] in settings.photons: # Adjust photons by the number of planes. photons = photons / float(len(settings.z_planes)) wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) bg_f = lambda s, x, y, i3: background.UniformBackground( s, x, y, i3, photons=bg) cam_f = lambda s, x, y, i3: camera.SCMOS(s, x, y, i3, "calib.npy") pp_f = lambda s, x, y, i3: photophysics.AlwaysOn( s, x, y, i3, photons) psf_f = lambda s, x, y, i3: psf.PupilFunction( s, x, y, i3, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) for i in range(len(settings.z_planes)): sim.simulate(wdir + "/test_c" + str(i + 1) + ".dax", "sim_input_c" + str(i + 1) + ".hdf5", settings.n_frames) index += 1 # Create "peak_locations" file if needed. # if hasattr(settings, "peak_locations") and (settings.peak_locations is not None): with saH5Py.SAH5Py("test_01/test_c1_ref.hdf5") as h5: locs = h5.getLocalizationsInFrame(0) if settings.peak_locations.endswith(".hdf5"): saH5Py.saveLocalizations(settings.peak_locations, locs) else: numpy.savetxt( settings.peak_locations, numpy.transpose( numpy.vstack((locs['x'], locs['y'], locs['height'], locs['background']))))
def configure(psf_model, no_splines): # Create parameters file for analysis. # print("Creating XML file.") params = testingParameters(psf_model) params.toXMLFile("multiplane.xml") # Create localization on a grid file. # print("Creating gridded localization.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "grid_list.hdf5", "--nx", str(settings.nx), "--ny", str(settings.ny), "--spacing", "20", "--zrange", str(settings.test_z_range), "--zoffset", str(settings.test_z_offset)]) # Create randomly located localizations file. # print("Creating random localization.") subprocess.call(["python", sim_path + "emitters_uniform_random.py", "--bin", "random_list.hdf5", "--density", "1.0", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size), "--zrange", str(settings.test_z_range)]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "psf_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40"]) # Create sCMOS camera calibration files. # numpy.save("calib.npy", [numpy.zeros((settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain, numpy.ones((settings.y_size, settings.x_size)), 2]) # Create mapping file. with open("map.map", 'wb') as fp: pickle.dump(settings.mappings, fp) if no_splines: return multiplane_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" # Create pupil functions for 'pupilfn'. if (psf_model == "pupilfn"): pupilfn_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/pupilfn/" print("Creating pupil functions.") for i in range(len(settings.z_planes)): subprocess.call(["python", pupilfn_path + "make_pupil_fn.py", "--filename", "c" + str(i+1) + "_pupilfn.pfn", "--size", str(settings.psf_size), "--pixel-size", str(settings.pixel_size), "--zmn", str(settings.pupil_fn), "--z-offset", str(-settings.z_planes[i])]) # Both 'spline' and 'psf_fft' need measured PSFs. else: # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("psf_list.hdf5") for i, z_offset in enumerate(settings.z_planes): cx = settings.mappings["0_" + str(i) + "_x"] cy = settings.mappings["0_" + str(i) + "_y"] locs_temp = {"x" : locs["x"].copy(), "y" : locs["y"].copy(), "z" : locs["z"].copy()} xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf locs_temp["z"][:] = z_offset saH5Py.saveLocalizations("c" + str(i+1) + "_psf.hdf5", locs_temp) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.spline_z_range, settings.spline_z_range + 0.001, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:,2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:,1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10) cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5 : drift.DriftFromFile(s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5 : psf.PupilFunction(s, x, y, h5, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, drift_factory = drift_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) for i in range(len(settings.z_planes)): sim.simulate("c" + str(i+1) + "_zcal.dax", "c" + str(i+1) + "_psf.hdf5", dz.size) # Measure the PSF. # print("Measuring PSFs.") psf_fft_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/psf_fft/" spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" for i in range(len(settings.z_planes)): subprocess.call(["python", multiplane_path + "psf_zstack.py", "--movie", "c" + str(i+1) + "_zcal.dax", "--bin", "c" + str(i+1) + "_psf.hdf5", "--zstack", "c" + str(i+1) + "_zstack", "--scmos_cal", "calib.npy", "--aoi_size", str(int(settings.psf_size/2)+1)]) # Measure PSF and calculate spline for Spliner. # if (psf_model == "spline"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i+1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i+1) + "_psf_normed.psf", "--z_range", str(settings.spline_z_range), "--normalize", "True"]) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i+1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i+1) + "_psf.psf", "--z_range", str(settings.spline_z_range)]) norm_args = ["python", multiplane_path + "normalize_psfs.py", "--psfs", "c1_psf.psf"] for i in range(len(settings.z_planes)-1): norm_args.append("c" + str(i+2) + "_psf.psf") subprocess.call(norm_args) # Measure the spline for Spliner. # print("Measuring Spline.") for i in range(len(settings.z_planes)): subprocess.call(["python", spliner_path + "psf_to_spline.py", "--psf", "c" + str(i+1) + "_psf_normed.psf", "--spline", "c" + str(i+1) + "_psf.spline", "--spline_size", str(int(settings.psf_size/2))]) # Measure PSF and downsample for PSF FFT. # elif (psf_model == "psf_fft"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i+1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i+1) + "_psf_normed.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize", "True"]) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "c" + str(i+1) + "_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "c" + str(i+1) + "_psf.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step)]) norm_args = ["python", multiplane_path + "normalize_psfs.py", "--psfs", "c1_psf.psf"] for i in range(len(settings.z_planes)-1): norm_args.append("c" + str(i+2) + "_psf.psf") subprocess.call(norm_args) # Calculate Cramer-Rao weighting. # print("Calculating weights.") subprocess.call(["python", multiplane_path + "plane_weighting.py", "--background", str(settings.photons[0][0]), "--photons", str(settings.photons[0][1]), "--output", "weights.npy", "--xml", "multiplane.xml", "--no_plots"])
def makeSampleData(mappings=None): # Create sample bead data for mapping measurement. # # Create randomly located localizations file (for STORM movies). # print("Creating random localizations.") emittersUniformRandom.emittersUniformRandom("random.hdf5", density, margin, x_size, y_size, 0.0) # Create mapping, if not specified. # if mappings is None: mappings = { "0_0_x": numpy.array([0.0, 1.0, 0.0]), "0_0_y": numpy.array([0.0, 0.0, 1.0]), "0_1_x": numpy.array([2.0, 1.0, 0.0]), "0_1_y": numpy.array([5.0, 0.0, 1.0]), "1_0_x": numpy.array([-2.0, 1.0, 0.0]), "1_0_y": numpy.array([-5.0, 0.0, 1.0]) } # Figure out number of planes in the mapping. # n_planes = 0 for elt in mappings: [i, j] = map(int, elt.split("_")[:2]) if (i > n_planes): n_planes = i n_planes += 1 print(n_planes) # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("random.hdf5") for i in range(n_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] locs_temp = { "x": locs["x"].copy(), "y": locs["y"].copy(), "z": locs["z"].copy() } xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf saH5Py.saveLocalizations("c" + str(i + 1) + "_map.hdf5", locs_temp) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 10000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, pixel_size, []) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=x_size, y_size=y_size) for i in range(n_planes): sim.simulate("c" + str(i + 1) + "_map.dax", "c" + str(i + 1) + "_map.hdf5", 2)
def makeSampleData(): # Create sample bead data for PSF measurement. # # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") emittersOnGrid.emittersOnGrid("psf_locs.hdf5", 6, 3, 1.5, 40, 0.0, 0.0) # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("psf_locs.hdf5") for i, z_offset in enumerate(z_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] locs_temp = {"x" : locs["x"].copy(), "y" : locs["y"].copy(), "z" : locs["z"].copy()} xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf locs_temp["z"][:] = z_offset saH5Py.saveLocalizations("c" + str(i+1) + "_psf.hdf5", locs_temp) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-spline_z_range, spline_z_range + 0.001, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:,2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:,1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10) cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5 : drift.DriftFromFile(s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5 : psf.PupilFunction(s, x, y, h5, pixel_size, []) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, drift_factory = drift_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = x_size, y_size = y_size) for i in range(len(z_planes)): sim.simulate("c" + str(i+1) + "_zcal.dax", "c" + str(i+1) + "_psf.hdf5", dz.size)
def makeData(): index = 1 if True: # Create localization files for each plane. h5_locs = saH5Py.loadLocalizations("grid_list.hdf5") # Load channel to channel mapping file. with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i, z_plane in enumerate(settings.z_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] xi = h5_locs["x"].copy() yi = h5_locs["y"].copy() zi = h5_locs["z"].copy() xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi zf = zi + z_plane h5_temp = {"x" : xf, "y" : yf, "z" : zf} saH5Py.saveLocalizations("sim_input_c" + str(i+1) + ".hdf5", h5_temp) # Create a movie for each plane. for [bg, photons] in settings.photons: # Adjust photons by the number of planes. photons = photons/float(len(settings.z_planes)) wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) bg_f = lambda s, x, y, i3 : background.UniformBackground(s, x, y, i3, photons = bg) cam_f = lambda s, x, y, i3 : camera.SCMOS(s, x, y, i3, "calib.npy") pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, photons) psf_f = lambda s, x, y, i3 : psf.PupilFunction(s, x, y, i3, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) for i in range(len(settings.z_planes)): sim.simulate(wdir + "/test_c" + str(i+1) + ".dax", "sim_input_c" + str(i+1) + ".hdf5", settings.n_frames) index += 1 # Create "peak_locations" file if needed. # if hasattr(settings, "peak_locations") and (settings.peak_locations is not None): with saH5Py.SAH5Py("test_01/test_c1_ref.hdf5") as h5: locs = h5.getLocalizationsInFrame(0) if settings.peak_locations.endswith(".hdf5"): saH5Py.saveLocalizations(settings.peak_locations, locs) else: numpy.savetxt(settings.peak_locations, numpy.transpose(numpy.vstack((locs['x'], locs['y'], locs['height'], locs['background']))))
def measurePSF(): # Create sparse random localizations for PSF measurement. # print("Creating random localization.") emittersUniformRandom.emittersUniformRandom("sparse_random.hdf5", 0.0002, settings.margin, settings.x_size, settings.y_size, 0.0) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") emittersOnGrid.emittersOnGrid("sparse_grid.hdf5", 8, 3, 1.5, 40, 0.0, 0.0) # Create text files for PSF measurement. # locs = saH5Py.loadLocalizations("sparse_random.hdf5") [xf, yf] = iaUtilsC.removeNeighbors(locs["x"], locs["y"], 2.0 * ((settings.psf_size / 2) + 1)) numpy.savetxt("sparse_random.txt", numpy.transpose(numpy.vstack((xf, yf)))) locs = saH5Py.loadLocalizations("sparse_grid.hdf5") numpy.savetxt("sparse_grid.txt", numpy.transpose(numpy.vstack((locs['x'], locs['y'])))) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.001, 0.010) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) z_offset[:, 0] = 0 numpy.savetxt("z_offset_none_valid.txt", z_offset) # Create simulated data for PSF measurement. # bg_f = lambda s, x, y, i3: background.UniformBackground( s, x, y, i3, photons=10) cam_f = lambda s, x, y, i3: camera.Ideal(s, x, y, i3, 100.) drift_f = lambda s, x, y, i3: drift.DriftFromFile(s, x, y, i3, "drift.txt") pp_f = lambda s, x, y, i3: photophysics.AlwaysOn(s, x, y, i3, 20000.0) psf_f = lambda s, x, y, i3: psf.PupilFunction(s, x, y, i3, 100.0, settings. zmn) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) if True: sim.simulate("sparse_grid.tif", "sparse_grid.hdf5", dz.size) sim.simulate("sparse_random.tif", "sparse_random.hdf5", dz.size) # Measure the PSF using spliner/measure_psf_beads.py and multiplane/measure_psf.py # diff_detected = False # Grid. if True: # Remove old results. for elt in [ "sparse_grid_beads.psf", "sparse_grid_hdf5_zo.psf", "sparse_grid_hdf5.psf", "sparse_grid_hdf5_mp_zo.psf" ]: if os.path.exists(elt): os.remove(elt) print("Measuring PSF (beads).") measurePSFBeads.measurePSFBeads("sparse_grid.tif", "z_offset.txt", "sparse_grid.txt", "sparse_grid_beads.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) print("Measuring PSF (HDF5, with zoffset).") spMeasurePSF.measurePSF("sparse_grid.tif", "z_offset.txt", "sparse_grid_ref.hdf5", "sparse_grid_hdf5_zo.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) print("Measuring PSF (HDF5).") spMeasurePSF.measurePSF("sparse_grid.tif", "", "sparse_grid_ref.hdf5", "sparse_grid_hdf5.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) multiplane_path = os.path.dirname( inspect.getfile(storm_analysis)) + "/multi_plane/" print("Measure PSF (multiplane).") psfZStack.psfZStack("sparse_grid.tif", "sparse_grid.hdf5", "sparse_grid_zstack", aoi_size=int(settings.psf_size / 2 + 1)) mpMeasurePSF.measurePSF("sparse_grid_zstack.npy", "z_offset.txt", "sparse_grid_hdf5_mp_zo.psf", z_range=settings.psf_z_range, z_step=settings.psf_z_step, normalize=True) # Check that the PSFs are the same. psf_beads = numpy.load("sparse_grid_beads.psf", allow_pickle=True)["psf"] psf_hdf5_zo = numpy.load("sparse_grid_hdf5_zo.psf", allow_pickle=True)["psf"] psf_hdf5 = numpy.load("sparse_grid_hdf5.psf", allow_pickle=True)["psf"] psf_hdf5_mp_zo = numpy.load("sparse_grid_hdf5_mp_zo.psf", allow_pickle=True)["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) # Here we are only checking they are close. if (settings.psf_size >= 20): diff_detected = diff_detected or psfDiffCheck( psf_beads, psf_hdf5_mp_zo, atol=0.17, rtol=0.17) # Grid, no valid z offsets. These are supposed to fail. # if True: print("Measuring PSF (beads).") try: measurePSFBeads.measurePSFBeads( "sparse_grid.tif", "z_offset_none_valid.txt", "sparse_grid.txt", "sparse_grid_beads.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) except AssertionError: pass else: assert False, "spliner.measure_psf_beads did not fail!" print("Measuring PSF (HDF5, with zoffset).") try: spMeasurePSF.measurePSF("sparse_grid.tif", "z_offset_none_valid.txt", "sparse_grid_ref.hdf5", "sparse_grid_hdf5_zo.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) except AssertionError: pass else: assert False, "spliner.measure_psf did not fail!" print("Measure PSF (multiplane).") try: psfZStack.psfZStack("sparse_grid.tif", "sparse_grid.hdf5", "sparse_grid_zstack", aoi_size=int(settings.psf_size / 2 + 1)) mpMeasurePSF.measurePSF("sparse_grid_zstack.npy", "z_offset_none_valid.txt", "sparse_grid_hdf5_mp_zo.psf", z_range=settings.psf_z_range, z_step=settings.psf_z_step, normalize=True) except AssertionError: pass else: assert False, "multiplane PSF measurement did not fail!" # Random. if True: # Remove old results. for elt in [ "sparse_random_beads.psf", "sparse_random_hdf5_zo.psf", "sparse_random_hdf5.psf" ]: if os.path.exists(elt): os.remove(elt) print("Measuring PSF (beads).") measurePSFBeads.measurePSFBeads("sparse_random.tif", "z_offset.txt", "sparse_random.txt", "sparse_random_beads.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) print("Measuring PSF (HDF5, with zoffset).") spMeasurePSF.measurePSF("sparse_random.tif", "z_offset.txt", "sparse_random_ref.hdf5", "sparse_random_hdf5_zo.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) print("Measuring PSF (HDF5).") spMeasurePSF.measurePSF("sparse_random.tif", "", "sparse_random_ref.hdf5", "sparse_random_hdf5.psf", aoi_size=int(settings.psf_size / 2 + 1), z_range=settings.psf_z_range, z_step=settings.psf_z_step) psf_beads = numpy.load("sparse_random_beads.psf", allow_pickle=True)["psf"] psf_hdf5_zo = numpy.load("sparse_random_hdf5_zo.psf", allow_pickle=True)["psf"] psf_hdf5 = numpy.load("sparse_random_hdf5.psf", allow_pickle=True)["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) if diff_detected: print("Difference detected in PSF measurements!") else: print("No differences detected, all good.") if False: with tifffile.TiffWriter("psf_diff.tif") as tf: for i in range(psf_beads.shape[0]): tf.save((psf_beads[i, :, :] - psf_hdf5_zo[i, :, :]).astype( numpy.float32))
def makeSampleData(): # Create sample bead data for PSF measurement. # # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") emittersOnGrid.emittersOnGrid("psf_locs.hdf5", 6, 3, 1.5, 40, 0.0, 0.0) # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("psf_locs.hdf5") for i, z_offset in enumerate(z_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] locs_temp = { "x": locs["x"].copy(), "y": locs["y"].copy(), "z": locs["z"].copy() } xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf locs_temp["z"][:] = z_offset saH5Py.saveLocalizations("c" + str(i + 1) + "_psf.hdf5", locs_temp) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-spline_z_range, spline_z_range + 0.001, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5: drift.DriftFromFile(s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, pixel_size, []) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=x_size, y_size=y_size) for i in range(len(z_planes)): sim.simulate("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_psf.hdf5", dz.size)
def configure(psf_model, no_splines): # Create parameters file for analysis. # print("Creating XML file.") params = testingParameters(psf_model) params.toXMLFile("multiplane.xml") # Create localization on a grid file. # print("Creating gridded localization.") emittersOnGrid.emittersOnGrid("grid_list.hdf5", settings.nx, settings.ny, 1.5, 20, settings.test_z_range, settings.test_z_offset) # Create randomly located localizations file. # print("Creating random localization.") emittersUniformRandom.emittersUniformRandom("random_list.hdf5", 1.0, settings.margin, settings.x_size, settings.y_size, settings.test_z_range) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") emittersOnGrid.emittersOnGrid("psf_list.hdf5", 6, 3, 1.5, 40, 0.0, 0.0) # Create sCMOS camera calibration files. # numpy.save("calib.npy", [ numpy.zeros( (settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain, numpy.ones((settings.y_size, settings.x_size)), 2 ]) # Create mapping file. with open("map.map", 'wb') as fp: pickle.dump(settings.mappings, fp) if no_splines: return # Create pupil functions for 'pupilfn'. if (psf_model == "pupilfn"): print("Creating pupil functions.") for i in range(len(settings.z_planes)): makePupilFn.makePupilFunction("c" + str(i + 1) + "_pupilfn.pfn", settings.psf_size, settings.pixel_size * 1.0e-3, settings.pupil_fn, z_offset=-settings.z_planes[i]) # Both 'spline' and 'psf_fft' need measured PSFs. else: # Create localization files for PSF measurement. # locs = saH5Py.loadLocalizations("psf_list.hdf5") for i, z_offset in enumerate(settings.z_planes): cx = settings.mappings["0_" + str(i) + "_x"] cy = settings.mappings["0_" + str(i) + "_y"] locs_temp = { "x": locs["x"].copy(), "y": locs["y"].copy(), "z": locs["z"].copy() } xi = locs_temp["x"] yi = locs_temp["y"] xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi locs_temp["x"] = xf locs_temp["y"] = yf locs_temp["z"][:] = z_offset saH5Py.saveLocalizations("c" + str(i + 1) + "_psf.hdf5", locs_temp) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.spline_z_range, settings.spline_z_range + 0.001, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5: drift.DriftFromFile( s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction( s, x, y, h5, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) for i in range(len(settings.z_planes)): sim.simulate("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_psf.hdf5", dz.size) # Measure the PSF. # print("Measuring PSFs.") for i in range(len(settings.z_planes)): psfZStack.psfZStack("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_psf.hdf5", "c" + str(i + 1) + "_zstack", aoi_size=int(settings.psf_size / 2 + 1)) # Measure PSF and calculate spline for Spliner. # if (psf_model == "spline"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy", "z_offset.txt", "c" + str(i + 1) + "_psf_normed.psf", z_range=settings.spline_z_range, normalize=True) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy", "z_offset.txt", "c" + str(i + 1) + "_psf.psf", z_range=settings.spline_z_range) norm_args = ["c1_psf.psf"] for i in range(len(settings.z_planes) - 1): norm_args.append("c" + str(i + 2) + "_psf.psf") normalizePSFs.normalizePSFs(norm_args) # Measure the spline for Spliner. # print("Measuring Spline.") for i in range(len(settings.z_planes)): psfToSpline.psfToSpline("c" + str(i + 1) + "_psf_normed.psf", "c" + str(i + 1) + "_psf.spline", int(settings.psf_size / 2)) # Measure PSF and downsample for PSF FFT. # elif (psf_model == "psf_fft"): # PSFs are independently normalized. # if settings.independent_heights: for i in range(len(settings.z_planes)): mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy", "z_offset.txt", "c" + str(i + 1) + "_psf_normed.psf", z_range=settings.spline_z_range, normalize=True) # PSFs are normalized to each other. # else: for i in range(len(settings.z_planes)): mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy", "z_offset.txt", "c" + str(i + 1) + "_psf.psf", z_range=settings.spline_z_range) norm_args = ["c1_psf.psf"] for i in range(len(settings.z_planes) - 1): norm_args.append("c" + str(i + 2) + "_psf.psf") normalizePSFs.normalizePSFs(norm_args) # Calculate Cramer-Rao weighting. # print("Calculating weights.") planeWeighting.runPlaneWeighting("multiplane.xml", "weights.npy", [settings.photons[0][0]], settings.photons[0][1], no_plots=True)
Hazen 01/18 """ import numpy import os import storm_analysis.sa_library.sa_h5py as saH5Py import settings index = 1 # Create 'tracked' files with different numbers of localizations # randomly pulled from the clusters file. # locs = saH5Py.loadLocalizations("clusters_list.hdf5", fields=["x", "y"]) i_arr = numpy.arange(locs["x"].size) for reps in settings.n_reps: wdir = "test_{0:02d}".format(index) print(wdir) if not os.path.exists(wdir): os.makedirs(wdir) with saH5Py.SAH5Py(wdir + "/test.hdf5", is_existing=False, overwrite=True) as h5: h5.setMovieInformation(settings.x_size, settings.y_size, 1, "") h5.setPixelSize(settings.pixel_size) for i in range(reps): track_id = numpy.arange(i * settings.n_tracks_in_group,
def makeData(): # Create .bin files for each plane. h5_locs = saH5Py.loadLocalizations("grid_list.hdf5") # Load channel to channel mapping file. with open("map.map", 'rb') as fp: mappings = pickle.load(fp) # Add z offset to reference localizations. x = h5_locs["x"].copy() y = h5_locs["y"].copy() z = h5_locs["z"].copy() + settings.z_planes[0] h5_temp = {"x" : x, "y" : y, "z" : z} saH5Py.saveLocalizations("sim_input_c1.hdf5", h5_temp) # Create a movie for first plane. [bg, photons] = settings.photons # Adjust photons by the number of planes. photons = photons/float(len(settings.z_planes)) bg_f = lambda s, x, y, i3 : background.UniformBackground(s, x, y, i3, photons = bg) cam_f = lambda s, x, y, i3 : camera.SCMOS(s, x, y, i3, "calib.npy") pp_f = lambda s, x, y, i3 : photophysics.SimpleSTORM(s, x, y, i3, photons = photons, on_time = settings.on_time, off_time = settings.off_time) psf_f = lambda s, x, y, i3 : psf.PupilFunction(s, x, y, i3, settings.pixel_size, settings.pupil_fn) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) sim.simulate(os.path.join(settings.wdir, "test_c1.dax"), "sim_input_c1.hdf5", settings.n_frames) # Create other movies. for i in range(1, len(settings.z_planes)): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] z_offset = settings.z_planes[i] - settings.z_planes[0] pp_f = lambda s, x, y, i3 : photophysics.Duplicate(s, x, y, i3, h5_name = os.path.join(settings.wdir, "test_c1_ref.hdf5"), cx = cx, cy = cy, z_offset = z_offset) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) sim.simulate(os.path.join(settings.wdir, "test_c" + str(i+1) + ".dax"), "sim_input_c1.hdf5", # This is not actually used. settings.n_frames) # Remove any old XML files. for elt in glob.glob(os.path.join(settings.wdir, "job*.xml")): os.remove(elt) # Make analysis XML files. splitAnalysisXML.splitAnalysisXML(settings.wdir, "multiplane.xml", 0, settings.n_frames, settings.divisions)
import storm_analysis.sa_library.sa_h5py as saH5Py import storm_analysis.simulator.background as background import storm_analysis.simulator.camera as camera import storm_analysis.simulator.photophysics as photophysics import storm_analysis.simulator.psf as psf import storm_analysis.simulator.simulate as simulate import settings index = 1 if True: # Create .bin files for each plane. h5_locs = saH5Py.loadLocalizations("grid_list.hdf5") # Load channel to channel mapping file. with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i, z_plane in enumerate(settings.z_planes): cx = mappings["0_" + str(i) + "_x"] cy = mappings["0_" + str(i) + "_y"] xi = h5_locs["x"].copy() yi = h5_locs["y"].copy() zi = h5_locs["z"].copy() xf = cx[0] + cx[1] * xi + cx[2] * yi yf = cy[0] + cy[1] * xi + cy[2] * yi zf = zi + z_plane h5_temp = {"x": xf, "y": yf, "z": zf}
def measurePSF(): # Create sparse random localizations for PSF measurement. # print("Creating random localization.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_uniform_random.py", "--bin", "sparse_random.hdf5", "--density", "0.0002", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size)]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "sparse_grid.hdf5", "--nx", "8", "--ny", "3", "--spacing", "40"]) # Create text files for PSF measurement. # locs = saH5Py.loadLocalizations("sparse_random.hdf5") [xf, yf] = iaUtilsC.removeNeighbors(locs["x"], locs["y"], 2.0 * ((settings.psf_size/2)+1)) numpy.savetxt("sparse_random.txt", numpy.transpose(numpy.vstack((xf, yf)))) locs = saH5Py.loadLocalizations("sparse_grid.hdf5") numpy.savetxt("sparse_grid.txt", numpy.transpose(numpy.vstack((locs['x'], locs['y'])))) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.001, 0.010) drift_data = numpy.zeros((dz.size, 3)) drift_data[:,2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:,1] = dz numpy.savetxt("z_offset.txt", z_offset) z_offset[:,0] = 0 numpy.savetxt("z_offset_none_valid.txt", z_offset) # Create simulated data for PSF measurement. # bg_f = lambda s, x, y, i3 : background.UniformBackground(s, x, y, i3, photons = 10) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, 100.) drift_f = lambda s, x, y, i3 : drift.DriftFromFile(s, x, y, i3, "drift.txt") pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, 20000.0) psf_f = lambda s, x, y, i3 : psf.PupilFunction(s, x, y, i3, 100.0, settings.zmn) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, drift_factory = drift_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) if True: sim.simulate("sparse_grid.dax", "sparse_grid.hdf5", dz.size) sim.simulate("sparse_random.dax", "sparse_random.hdf5", dz.size) # Measure the PSF using spliner/measure_psf_beads.py and multiplane/measure_psf.py # diff_detected = False # Grid. if True: print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" subprocess.call(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_grid.dax", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_grid.txt", "--psf", "sparse_grid_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5, with zoffset).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.dax", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5_zo.psf", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.dax", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5.psf", "--zoffset", "", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) multiplane_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" print("Measure PSF (multiplane).") subprocess.call(["python", multiplane_path + "psf_zstack.py", "--movie", "sparse_grid.dax", "--bin", "sparse_grid.hdf5", "--zstack", "sparse_grid_zstack", "--aoi_size", str(int(settings.psf_size/2)+1)]) subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "sparse_grid_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "sparse_grid_hdf5_mp_zo.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize", "True"]) # Check that the PSFs are the same. psf_beads = numpy.load("sparse_grid_beads.psf")["psf"] psf_hdf5_zo = numpy.load("sparse_grid_hdf5_zo.psf")["psf"] psf_hdf5 = numpy.load("sparse_grid_hdf5.psf")["psf"] psf_hdf5_mp_zo = numpy.load("sparse_grid_hdf5_mp_zo.psf")["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) # Here we are only checking they are close. if (settings.psf_size >= 20): diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_mp_zo, atol = 0.17, rtol = 0.17) # Grid, no valid z offsets. if True: print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" try: subprocess.check_output(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_grid.dax", "--zoffset", "z_offset_none_valid.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_grid.txt", "--psf", "sparse_grid_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) except subprocess.CalledProcessError: pass else: assert False, "spliner.measure_psf_beads did not fail!" print("Measuring PSF (HDF5, with zoffset).") try: subprocess.check_output(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.dax", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5_zo.psf", "--zoffset", "z_offset_none_valid.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) except subprocess.CalledProcessError: pass else: assert False, "spliner.measure_psf did not fail!" multiplane_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" print("Measure PSF (multiplane).") try: subprocess.check_output(["python", multiplane_path + "psf_zstack.py", "--movie", "sparse_grid.dax", "--bin", "sparse_grid.hdf5", "--zstack", "sparse_grid_zstack", "--aoi_size", str(int(settings.psf_size/2)+1)]) subprocess.check_output(["python", multiplane_path + "measure_psf.py", "--zstack", "sparse_grid_zstack.npy", "--zoffsets", "z_offset_none_valid.txt", "--psf_name", "sparse_grid_hdf5_mp_zo.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize", "True"]) except subprocess.CalledProcessError: pass else: assert False, "multiplane PSF measurement did not fail!" # Random. if True: print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" subprocess.call(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_random.dax", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_random.txt", "--psf", "sparse_random_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5, with zoffset).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_random.dax", "--bin", "sparse_random_ref.hdf5", "--psf", "sparse_random_hdf5_zo.psf", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_random.dax", "--bin", "sparse_random_ref.hdf5", "--psf", "sparse_random_hdf5.psf", "--zoffset", "", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) psf_beads = numpy.load("sparse_random_beads.psf")["psf"] psf_hdf5_zo = numpy.load("sparse_random_hdf5_zo.psf")["psf"] psf_hdf5 = numpy.load("sparse_random_hdf5.psf")["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) if diff_detected: print("Difference detected in PSF measurements!") else: print("No differences detected, all good.") if False: with tifffile.TiffWriter("psf_diff.tif") as tf: for i in range(psf_beads.shape[0]): tf.save((psf_beads[i,:,:] - psf_hdf5_zo[i,:,:]).astype(numpy.float32))
def measurePSF(): # Create sparse random localizations for PSF measurement. # print("Creating random localization.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_uniform_random.py", "--bin", "sparse_random.hdf5", "--density", "0.0002", "--margin", str(settings.margin), "--sx", str(settings.x_size), "--sy", str(settings.y_size)]) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/" subprocess.call(["python", sim_path + "emitters_on_grid.py", "--bin", "sparse_grid.hdf5", "--nx", "8", "--ny", "3", "--spacing", "40"]) # Create text files for PSF measurement. # locs = saH5Py.loadLocalizations("sparse_random.hdf5") [xf, yf] = iaUtilsC.removeNeighbors(locs["x"], locs["y"], 2.0 * ((settings.psf_size/2)+1)) numpy.savetxt("sparse_random.txt", numpy.transpose(numpy.vstack((xf, yf)))) locs = saH5Py.loadLocalizations("sparse_grid.hdf5") numpy.savetxt("sparse_grid.txt", numpy.transpose(numpy.vstack((locs['x'], locs['y'])))) # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.001, 0.010) drift_data = numpy.zeros((dz.size, 3)) drift_data[:,2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:,1] = dz numpy.savetxt("z_offset.txt", z_offset) z_offset[:,0] = 0 numpy.savetxt("z_offset_none_valid.txt", z_offset) # Create simulated data for PSF measurement. # bg_f = lambda s, x, y, i3 : background.UniformBackground(s, x, y, i3, photons = 10) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, 100.) drift_f = lambda s, x, y, i3 : drift.DriftFromFile(s, x, y, i3, "drift.txt") pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, 20000.0) psf_f = lambda s, x, y, i3 : psf.PupilFunction(s, x, y, i3, 100.0, settings.zmn) sim = simulate.Simulate(background_factory = bg_f, camera_factory = cam_f, drift_factory = drift_f, photophysics_factory = pp_f, psf_factory = psf_f, x_size = settings.x_size, y_size = settings.y_size) if True: sim.simulate("sparse_grid.tif", "sparse_grid.hdf5", dz.size) sim.simulate("sparse_random.tif", "sparse_random.hdf5", dz.size) # Measure the PSF using spliner/measure_psf_beads.py and multiplane/measure_psf.py # diff_detected = False # Grid. if True: # Remove old results. for elt in ["sparse_grid_beads.psf", "sparse_grid_hdf5_zo.psf", "sparse_grid_hdf5.psf", "sparse_grid_hdf5_mp_zo.psf"]: if os.path.exists(elt): os.remove(elt) print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" subprocess.call(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_grid.tif", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_grid.txt", "--psf", "sparse_grid_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5, with zoffset).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.tif", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5_zo.psf", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.tif", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5.psf", "--zoffset", "", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) multiplane_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" print("Measure PSF (multiplane).") subprocess.call(["python", multiplane_path + "psf_zstack.py", "--movie", "sparse_grid.tif", "--bin", "sparse_grid.hdf5", "--zstack", "sparse_grid_zstack", "--aoi_size", str(int(settings.psf_size/2)+1)]) subprocess.call(["python", multiplane_path + "measure_psf.py", "--zstack", "sparse_grid_zstack.npy", "--zoffsets", "z_offset.txt", "--psf_name", "sparse_grid_hdf5_mp_zo.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize"]) # Check that the PSFs are the same. psf_beads = numpy.load("sparse_grid_beads.psf", allow_pickle = True)["psf"] psf_hdf5_zo = numpy.load("sparse_grid_hdf5_zo.psf", allow_pickle = True)["psf"] psf_hdf5 = numpy.load("sparse_grid_hdf5.psf", allow_pickle = True)["psf"] psf_hdf5_mp_zo = numpy.load("sparse_grid_hdf5_mp_zo.psf", allow_pickle = True)["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) # Here we are only checking they are close. if (settings.psf_size >= 20): diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_mp_zo, atol = 0.17, rtol = 0.17) # Grid, no valid z offsets. These are supposed to fail. # if True: print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" try: subprocess.check_output(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_grid.tif", "--zoffset", "z_offset_none_valid.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_grid.txt", "--psf", "sparse_grid_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) except subprocess.CalledProcessError: pass else: assert False, "spliner.measure_psf_beads did not fail!" print("Measuring PSF (HDF5, with zoffset).") try: subprocess.check_output(["python", spliner_path + "measure_psf.py", "--movie", "sparse_grid.tif", "--bin", "sparse_grid_ref.hdf5", "--psf", "sparse_grid_hdf5_zo.psf", "--zoffset", "z_offset_none_valid.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) except subprocess.CalledProcessError: pass else: assert False, "spliner.measure_psf did not fail!" multiplane_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/" print("Measure PSF (multiplane).") try: subprocess.check_output(["python", multiplane_path + "psf_zstack.py", "--movie", "sparse_grid.tif", "--bin", "sparse_grid.hdf5", "--zstack", "sparse_grid_zstack", "--aoi_size", str(int(settings.psf_size/2)+1)]) subprocess.check_output(["python", multiplane_path + "measure_psf.py", "--zstack", "sparse_grid_zstack.npy", "--zoffsets", "z_offset_none_valid.txt", "--psf_name", "sparse_grid_hdf5_mp_zo.psf", "--z_range", str(settings.psf_z_range), "--z_step", str(settings.psf_z_step), "--normalize"]) except subprocess.CalledProcessError: pass else: assert False, "multiplane PSF measurement did not fail!" # Random. if True: # Remove old results. for elt in ["sparse_random_beads.psf", "sparse_random_hdf5_zo.psf", "sparse_random_hdf5.psf"]: if os.path.exists(elt): os.remove(elt) print("Measuring PSF (beads).") spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/" subprocess.call(["python", spliner_path + "measure_psf_beads.py", "--movie", "sparse_random.tif", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--beads", "sparse_random.txt", "--psf", "sparse_random_beads.psf", "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5, with zoffset).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_random.tif", "--bin", "sparse_random_ref.hdf5", "--psf", "sparse_random_hdf5_zo.psf", "--zoffset", "z_offset.txt", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) print("Measuring PSF (HDF5).") subprocess.call(["python", spliner_path + "measure_psf.py", "--movie", "sparse_random.tif", "--bin", "sparse_random_ref.hdf5", "--psf", "sparse_random_hdf5.psf", "--zoffset", "", "--aoi_size", str(int(settings.psf_size/2)+1), "--zrange", str(settings.psf_z_range), "--zstep", str(settings.psf_z_step)]) psf_beads = numpy.load("sparse_random_beads.psf", allow_pickle = True)["psf"] psf_hdf5_zo = numpy.load("sparse_random_hdf5_zo.psf", allow_pickle = True)["psf"] psf_hdf5 = numpy.load("sparse_random_hdf5.psf", allow_pickle = True)["psf"] diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo) diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5) if diff_detected: print("Difference detected in PSF measurements!") else: print("No differences detected, all good.") if False: with tifffile.TiffWriter("psf_diff.tif") as tf: for i in range(psf_beads.shape[0]): tf.save((psf_beads[i,:,:] - psf_hdf5_zo[i,:,:]).astype(numpy.float32))
def getPeakLocations(peak_filename, margin, pixel_size, sigma): """ This is for if you already know where your want fitting to happen, as for example in a bead calibration movie and you just want to use the approximate locations as inputs for fitting. There are two choices for peak_locations file format: 1. A text file with the peak x, y, height and background values as white spaced columns (x and y positions are in pixels as determined using visualizer). 1.0 2.0 1000.0 100.0 10.0 5.0 2000.0 200.0 ... 2. An HDF5 format localization file. This is treated in a similar fashion to the text file in that all of the locations are loaded. If the fields 'xsigma' or 'ysigma' exist they will be used for the initial X/Y sigma values of the localization. """ if os.path.exists(peak_filename): print("Using peak starting locations specified in", peak_filename) elif os.path.exists(os.path.basename(peak_filename)): peak_filename = os.path.basename(peak_filename) print("Using peak starting locations specified in", peak_filename) # Check if the file is a storm-analysis HDF5 file. # if saH5Py.isSAHDF5(peak_filename): peak_locations_type = "hdf5" peak_locations = saH5Py.loadLocalizations(peak_filename) if not "ysigma" in peak_locations: if not "xsigma" in peak_locations: peak_locations["xsigma"] = numpy.ones( peak_locations["x"].size) * sigma peak_locations["ysigma"] = peak_locations["xsigma"].copy() else: peak_locations_type = "text" # Load peak x,y locations. peak_locs = numpy.loadtxt(peak_filename, ndmin=2) # Create peak dictionary. peak_locations = { "background": peak_locs[:, 3], "height": peak_locs[:, 2], "x": peak_locs[:, 0], "y": peak_locs[:, 1] } peak_locations["xsigma"] = numpy.ones(peak_locations["x"].size) * sigma peak_locations["ysigma"] = numpy.ones(peak_locations["x"].size) * sigma peak_locations["z"] = numpy.zeros(peak_locations["x"].size) # Adjust positions for finding/fitting margin. peak_locations["x"] += margin peak_locations["y"] += margin print("Loaded", peak_locations["x"].size, "peak locations") # # We return is_text as the caller might want to do different things if # the file is text, like initialize the Z value. # return [peak_locations, peak_locations_type]
def configure(): # Create analysis XML files. # print("Creating XML files.") params = testingParametersSCMOS() params.toXMLFile("scmos.xml") params = testingParametersMC() params.toXMLFile("multicolor.xml") # Useful variables aoi_size = int(settings.psf_size / 2) + 1 # Create sCMOS data and HDF5 files we'll need for the simulation. # if True: # Create sCMOS camera calibration files. # numpy.save("calib.npy", [ numpy.zeros( (settings.y_size, settings.x_size)) + settings.camera_offset, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_variance, numpy.ones( (settings.y_size, settings.x_size)) * settings.camera_gain, numpy.ones((settings.y_size, settings.x_size)), 2 ]) # Create localization on a grid file. # print("Creating gridded localizations.") emittersOnGrid.emittersOnGrid("grid_list.hdf5", settings.nx, settings.ny, 1.5, 20, settings.test_z_range, settings.test_z_offset) # Create randomly located localizations file (for STORM movies). # print("Creating random localizations.") emittersUniformRandom.emittersUniformRandom("random_storm.hdf5", 1.0, settings.margin, settings.x_size, settings.y_size, settings.test_z_range) # Create randomly located localizations file (for mapping measurement). # print("Creating random localizations.") emittersUniformRandom.emittersUniformRandom("random_map.hdf5", 0.0003, settings.margin, settings.x_size, settings.y_size, settings.test_z_range) # Create sparser grid for PSF measurement. # print("Creating data for PSF measurement.") emittersOnGrid.emittersOnGrid("psf_list.hdf5", 6, 3, 1.5, 40, 0.0, 0.0) ## This part makes / tests measuring the mapping. ## if True: print("Measuring mapping.") # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1, 4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5", locs) # Make localization files for simulations. # locs = saH5Py.loadLocalizations("random_map.hdf5") locs["z"][:] = 1.0e-3 * settings.z_planes[0] saH5Py.saveLocalizations("c1_random_map.hdf5", locs) for i in range(1, 4): locs["x"] += settings.dx locs["y"] += settings.dy locs["z"][:] = settings.z_planes[i] saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5", locs) # Make simulated mapping data. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, i3: psf.GaussianPSF(s, x, y, i3, settings. pixel_size) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) for i in range(4): sim.simulate("c" + str(i + 1) + "_map.dax", "c" + str(i + 1) + "_random_map.hdf5", 1) # Analyze simulated mapping data # for i in range(4): h5_name = "c" + str(i + 1) + "_map.hdf5" if os.path.exists(h5_name): os.remove(h5_name) scmos.analyze("c" + str(i + 1) + "_map.dax", h5_name, "scmos.xml") # Measure mapping. # for i in range(3): micrometry.runMicrometry("c1_map.hdf5", "c" + str(i + 2) + "_map.hdf5", "c1_c" + str(i + 2) + "_map.map", min_size=5.0, max_size=100.0, max_neighbors=20, tolerance=1.0e-2, no_plots=True) # Merge mapping and save results. # merged_map = mergeMaps.mergeMaps( ["c1_c2_map.map", "c1_c3_map.map", "c1_c4_map.map"]) with open("map.map", 'wb') as fp: pickle.dump(merged_map, fp) # Print mapping. # if True: print("Mapping is:") printMapping.printMapping("map.map") print("") # Check that mapping is close to what we expect (within 5%). # with open("map.map", 'rb') as fp: mappings = pickle.load(fp) for i in range(3): if not numpy.allclose(mappings["0_" + str(i + 1) + "_x"], numpy.array( [settings.dx * (i + 1), 1.0, 0.0]), rtol=0.05, atol=0.05): print("X mapping difference for channel", i + 1) if not numpy.allclose(mappings["0_" + str(i + 1) + "_y"], numpy.array( [settings.dy * (i + 1), 0.0, 1.0]), rtol=0.05, atol=0.05): print("Y mapping difference for channel", i + 1) ## This part measures / test the PSF measurement. ## if True: # Create drift file, this is used to displace the localizations in the # PSF measurement movie. # dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.05, 0.01) drift_data = numpy.zeros((dz.size, 3)) drift_data[:, 2] = dz numpy.savetxt("drift.txt", drift_data) # Also create the z-offset file. # z_offset = numpy.ones((dz.size, 2)) z_offset[:, 1] = dz numpy.savetxt("z_offset.txt", z_offset) # Create simulated data for PSF measurements. # bg_f = lambda s, x, y, h5: background.UniformBackground( s, x, y, h5, photons=10) cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy") drift_f = lambda s, x, y, h5: drift.DriftFromFile( s, x, y, h5, "drift.txt") pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0) psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, settings. pixel_size, []) sim = simulate.Simulate(background_factory=bg_f, camera_factory=cam_f, drift_factory=drift_f, photophysics_factory=pp_f, psf_factory=psf_f, x_size=settings.x_size, y_size=settings.y_size) if True: for i in range(4): sim.simulate("c" + str(i + 1) + "_zcal.dax", "c" + str(i + 1) + "_random_map.hdf5", dz.size) # Get localizations to use for PSF measurement. # psfLocalizations.psfLocalizations("c1_map_ref.hdf5", "map.map", aoi_size=aoi_size) # Create PSF z stacks. # for i in range(4): psfZStack.psfZStack("c" + str(i + 1) + "_zcal.dax", "c1_map_ref_c" + str(i + 1) + "_psf.hdf5", "c" + str(i + 1) + "_zstack", aoi_size=aoi_size) # Measure PSF. # for i in range(4): mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy", "z_offset.txt", "c" + str(i + 1) + "_psf_normed.psf", z_range=settings.psf_z_range, normalize=True) ## This part creates the splines. ## if True: print("Measuring Splines.") for i in range(4): psfToSpline.psfToSpline("c" + str(i + 1) + "_psf_normed.psf", "c" + str(i + 1) + "_psf.spline", int(settings.psf_size / 2)) ## This part measures the Cramer-Rao weights. ## if True: print("Calculating weights.") planeWeighting.runPlaneWeighting("multicolor.xml", "weights.npy", [settings.photons[0][0]], settings.photons[0][1], no_plots=True)