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 makeData(): index = 1 # Ideal camera movies. # if True: for [bg, photons] in settings.photons: 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.Ideal(s, x, y, i3, settings. camera_offset) 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.zmn) 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.dax", "grid_list.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_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 makePeakFile(settings): # Create "peak_locations" file if needed. # if hasattr(settings, "peak_locations") and (settings.peak_locations is not None): with saH5Py.SAH5Py("test_01/test_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 makeData(): index = 1 # Ideal camera movies. # if True: for [bg, photons] in settings.photons: 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.Ideal(s, x, y, i3, settings.camera_offset) 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.zmn) 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.dax", "grid_list.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_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 createMovie(n_frames): bg_f = lambda s, x, y, i3 : background.UniformBackground(s, x, y, i3, photons = bg) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, camera_offset) pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, signal) psf_f = lambda s, x, y, i3 : psf.GaussianPSF(s, x, y, i3, 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) sim.simulate("test.tif", "sim_locs.hdf5", n_frames) # Also create file to use for peak locations. with saH5Py.SAH5Py("test_ref.hdf5") as h5: locs = h5.getLocalizationsInFrame(0) saH5Py.saveLocalizations("peak_locs.hdf5", locs)
def createMovie(n_frames): bg_f = lambda s, x, y, i3: background.UniformBackground( s, x, y, i3, photons=bg) cam_f = lambda s, x, y, i3: camera.Ideal(s, x, y, i3, camera_offset) pp_f = lambda s, x, y, i3: photophysics.AlwaysOn(s, x, y, i3, signal) psf_f = lambda s, x, y, i3: psf.GaussianPSF(s, x, y, i3, 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) sim.simulate("test.tif", "sim_locs.hdf5", n_frames) # Also create file to use for peak locations. with saH5Py.SAH5Py("test_ref.hdf5") as h5: locs = h5.getLocalizationsInFrame(0) saH5Py.saveLocalizations("peak_locs.hdf5", locs)
def emittersOnGrid(h5_name, nx, ny, sigma, spacing, zrange, zoffset, seed=0): if seed is not None: random.seed(seed) if (nx * ny > 1): curz = -zrange z_inc = 2.0 * zrange / (nx * ny - 1) else: curz = 0.0 z_inc = 0.0 peaks = { "id": numpy.zeros(nx * ny, dtype=numpy.int32), "x": numpy.zeros(nx * ny), "y": numpy.zeros(nx * ny), "z": numpy.zeros(nx * ny), "xsigma": sigma * numpy.ones(nx * ny), "ysigma": sigma * numpy.ones(nx * ny) } curx = spacing for i in range(nx): cury = spacing for j in range(ny): k = i * ny + j peaks['x'][k] = curx + random.random() - 0.5 peaks['y'][k] = cury + random.random() - 0.5 peaks['z'][k] = curz + zoffset # Record emitter id in the 'id' field. peaks['id'][k] = k cury += spacing curz += z_inc curx += spacing saH5Py.saveLocalizations(h5_name, peaks)
def emittersOnGrid(h5_name, nx, ny, sigma, spacing, zrange, zoffset, seed = 0): if seed is not None: random.seed(seed) if (nx*ny > 1): curz = -zrange z_inc = 2.0 * zrange/(nx*ny - 1) else: curz = 0.0 z_inc = 0.0 peaks = {"id" : numpy.zeros(nx*ny, dtype = numpy.int32), "x" : numpy.zeros(nx*ny), "y" : numpy.zeros(nx*ny), "z" : numpy.zeros(nx*ny), "xsigma" : sigma * numpy.ones(nx*ny), "ysigma" : sigma * numpy.ones(nx*ny)} curx = spacing for i in range(nx): cury = spacing for j in range(ny): k = i*ny+j peaks['x'][k] = curx + random.random() - 0.5 peaks['y'][k] = cury + random.random() - 0.5 peaks['z'][k] = curz + zoffset # Record emitter id in the 'id' field. peaks['id'][k] = k cury += spacing curz += z_inc curx += spacing saH5Py.saveLocalizations(h5_name, peaks)
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"])
fdecon.decon(parameters.getAttr("fista_iterations"), parameters.getAttr("fista_lambda"), verbose = True) # Save results. fx = fdecon.getXVector() print(numpy.min(fx), numpy.max(fx)) with tifffile.TiffWriter(args.output) as tf: tf.save(image.astype(numpy.float32)) for i in range(fx.shape[2]): tf.save(fx[:,:,i].astype(numpy.float32)) # Find peaks in the decon data. peaks = fdecon.getPeaks(parameters.getAttr("fista_threshold"), 5) saH5Py.saveLocalizations(args.output[:-4] + ".hdf5", peaks) # Clean up. fdecon.cleanup() # # The MIT License # # Copyright (c) 2016 Zhuang Lab, Harvard University # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is
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 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(): # 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)
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)
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 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 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 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']))))
else: curz = 0.0 z_inc = 0.0 peaks = { "id": numpy.zeros(nx * ny, dtype=numpy.int32), "x": numpy.zeros(nx * ny), "y": numpy.zeros(nx * ny), "z": numpy.zeros(nx * ny), "xsigma": 1.5 * numpy.ones(nx * ny), "ysigma": 1.5 * numpy.ones(nx * ny) } curx = spacing for i in range(nx): cury = spacing for j in range(ny): k = i * ny + j peaks['x'][k] = curx + random.random() - 0.5 peaks['y'][k] = cury + random.random() - 0.5 peaks['z'][k] = curz + args.zoffset # Record emitter id in the 'id' field. peaks['id'][k] = k cury += spacing curz += z_inc curx += spacing saH5Py.saveLocalizations(args.hdf5, peaks)
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)
# 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")
def makeData(dither = False): index = 1 # Gaussian PSF, uniform background. if True: for [bg, photons] in settings.photons: 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.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, photons) 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, dither = dither, x_size = settings.x_size, y_size = settings.y_size) sim.simulate(wdir + "/test.dax", "grid_list.hdf5", settings.n_frames) index += 1 # Pupil Function PSF. if False: for [bg, photons] in settings.photons: 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.Ideal(s, x, y, i3, settings.camera_offset) 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, []) 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.dax", "grid_list.hdf5", settings.n_frames) index += 1 # Gaussian non-uniform background, always on. if False: for [bg, photons] in settings.photons: 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.GaussianBackground(s, x, y, i3, photons = bg) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, photons) 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) sim.simulate(wdir + "/test.dax", "grid_list.hdf5", settings.n_frames) index += 1 # Uniform background, STORM. if False: for [bg, photons] in settings.photons: 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.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.SimpleSTORM(s, x, y, i3, photons) 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) sim.simulate(wdir + "/test.dax", "random_list.hdf5", settings.n_frames) index += 1 # Gaussian non-uniform background, STORM. if False: for [bg, photons] in settings.photons: 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.GaussianBackground(s, x, y, i3, photons = bg) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.SimpleSTORM(s, x, y, i3, photons) 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) sim.simulate(wdir + "/test.dax", "random_list.hdf5", settings.n_frames) index += 1 # Sloped non-uniform background, always on. if False: for [bg, photons] in settings.photons: 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.SlopedBackground(s, x, y, i3, slope = 0.4, offset = 10) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, photons) 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, dither = True, x_size = settings.x_size, y_size = settings.y_size) sim.simulate(wdir + "/test.dax", "grid_list.hdf5", settings.n_frames) index += 1 # Sine non-uniform background, always on. if False: for [bg, photons] in settings.photons: 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.SineBackground(s, x, y, i3, photons = bg, period = 45) cam_f = lambda s, x, y, i3 : camera.Ideal(s, x, y, i3, settings.camera_offset) pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, photons) 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, dither = True, x_size = settings.x_size, y_size = settings.y_size) sim.simulate(wdir + "/test.dax", "grid_list.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_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 psfLocalizations(h5_filename, mapping_filename, frame = 0, aoi_size = 8, min_height = 0.0): # Load localizations & movie size. with saH5Py.SAH5Py(h5_filename) as h5: locs = h5.getLocalizationsInFrame(frame) assert bool(locs), "No localizations found in frame " + str(frame) [movie_x, movie_y] = h5.getMovieInformation()[:2] # Load mapping. mappings = {} if os.path.exists(mapping_filename): with open(mapping_filename, 'rb') as fp: mappings = pickle.load(fp) else: print("Mapping file not found, single channel data?") # Remove localizations that are too dim. mask = (locs["height"] > min_height) locs_mask = {} for elt in ["x", "y"]: locs_mask[elt] = locs[elt][mask] # Remove localizations that are too close to each other. [xf, yf] = iaUtilsC.removeNeighbors(locs_mask["x"], locs_mask["y"], 2.0 * aoi_size) # Remove localizations that are too close to the edge or # outside of the image in any of the channels. # is_good = numpy.ones(xf.size, dtype = numpy.bool) for i in range(xf.size): # Check in Channel 0. if (xf[i] < aoi_size) or (xf[i] + aoi_size >= movie_x): is_good[i] = False continue if (yf[i] < aoi_size) or (yf[i] + aoi_size >= movie_y): is_good[i] = False continue # Check other channels. for key in mappings: if not is_good[i]: break coeffs = mappings[key] [ch1, ch2, axis] = key.split("_") if (ch1 == "0"): if (axis == "x"): xm = coeffs[0] + coeffs[1]*xf[i] + coeffs[2]*yf[i] if (xm < aoi_size) or (xm + aoi_size >= movie_x): is_good[i] = False break elif (axis == "y"): ym = coeffs[0] + coeffs[1]*xf[i] + coeffs[2]*yf[i] if (ym < aoi_size) or (ym + aoi_size >= movie_y): is_good[i] = False break # # Save localizations for each channel. # gx = xf[is_good] gy = yf[is_good] basename = os.path.splitext(h5_filename)[0] saH5Py.saveLocalizations(basename + "_c1_psf.hdf5", {"x" : gx, "y" : gy}) index = 1 while ("0_" + str(index) + "_x" in mappings): cx = mappings["0_" + str(index) + "_x"] cy = mappings["0_" + str(index) + "_y"] xm = cx[0] + cx[1] * gx + cx[2] * gy ym = cy[0] + cy[1] * gx + cy[2] * gy saH5Py.saveLocalizations(basename + "_c" + str(index+1) + "_psf.hdf5", {"x" : xm, "y" : ym}) index += 1 # # Print localizations that were kept. # print(gx.size, "localizations were kept out of", xf.size) for i in range(gx.size): print("ch0: {0:.2f} {1:.2f}".format(gx[i], gy[i])) index = 1 while ("0_" + str(index) + "_x" in mappings): cx = mappings["0_" + str(index) + "_x"] cy = mappings["0_" + str(index) + "_y"] xm = cx[0] + cx[1] * gx[i] + cx[2] * gy[i] ym = cy[0] + cy[1] * gx[i] + cy[2] * gy[i] print("ch" + str(index) + ": {0:.2f} {1:.2f}".format(xm, ym)) index += 1 print("") print("")