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)
if settings.use_dh:
psf_f = lambda s, x, y, i3 : psf.DHPSF(s, x, y, i3, 100.0, z_range = settings.spline_z_range)
else:
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,
photophysics_factory = pp_f,
psf_factory = psf_f,
x_size = settings.x_size,
y_size = settings.y_size)
sim.simulate(wdir + "/test.tif", "grid_list.hdf5", settings.n_frames)
index += 1
def makeDataPupilFn(settings, dither):
"""
Pupil function PSF, Ideal camera movies.
"""
index = 1
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,
dither=dither,
x_size=settings.x_size,
y_size=settings.y_size)
sim.simulate(wdir + "/test.tif", "grid_list.hdf5", settings.n_frames)
index += 1
makePeakFile(settings)
def createMovie(movie_name):
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-z_range, z_range + 0.001, 0.01)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:, 2] = dz
numpy.savetxt("drift.txt", drift_data)
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)
drift_f = lambda s, x, y, i3: drift.DriftFromFile(s, x, y, i3, "drift.txt")
pp_f = lambda s, x, y, i3: photophysics.SimpleSTORM(s, x, y, i3, signal)
psf_f = lambda s, x, y, i3: psf.PupilFunction(s, x, y, i3, pixel_size,
[[0.8, 2, 2]])
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)
sim.simulate(movie_name, "random_locs.hdf5", dz.size)
def makeSampleData():
# Create sample bead data for fiducial tracking.
#
# Create randomly located localizations file.
#
print("Creating random localizations.")
sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/"
subprocess.call([
"python", sim_path + "emitters_uniform_random.py", "--bin",
"random.hdf5", "--density",
str(density), "--margin",
str(margin), "--sx",
str(x_size), "--sy",
str(y_size)
])
# Create X/Y/Z drift file.
#
dx = numpy.random.normal(loc=x_loc, scale=x_scale, size=n_frames)
dy = numpy.random.normal(loc=y_loc, scale=y_scale, size=n_frames)
# Integrate dx, dy
for i in range(1, dx.size):
dx[i] = dx[i - 1] + dx[i]
dy[i] = dy[i - 1] + dy[i]
drift_data = numpy.zeros((dx.size, 3))
drift_data[:, 0] = dx
drift_data[:, 1] = dy
numpy.savetxt("drift.txt", drift_data)
# Create simulated data for fiducial tracking.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.Ideal(s, x, y, h5, camera_offset)
drift_f = lambda s, x, y, h5: drift.DriftFromFile(s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5: photophysics.SimpleSTORM(
s, x, y, h5, 4000, on_time=10.0, off_time=1.0)
psf_f = lambda s, x, y, h5: psf.GaussianPSF(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)
sim.simulate("fiducials.tif", "random.hdf5", n_frames)
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 test_simulate_1():
"""
No photo-physics, simple PSF, ideal camera.
"""
dax_name = storm_analysis.getPathOutputTest("test_sim1.dax")
bin_name = storm_analysis.getData("test/data/test_sim.hdf5")
sim = simulate.Simulate(background_factory = lambda settings, xs, ys, i3data : background.UniformBackground(settings, xs, ys, i3data),
camera_factory = lambda settings, xs, ys, i3data : camera.Ideal(settings, xs, ys, i3data, 100.0),
photophysics_factory = lambda settings, xs, ys, i3data : photophysics.AlwaysOn(settings, xs, ys, i3data, 1000.0),
psf_factory = lambda settings, xs, ys, i3data : psf.GaussianPSF(settings, xs, ys, i3data, 160.0),
x_size = 100, y_size = 75)
sim.simulate(dax_name, bin_name, 5)
def createMovie():
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)
def createMovie(gain=1.0, offset=100.0):
bg_f = lambda s, x, y, h5: background.GaussianBackground(
s, x, y, h5, photons=bg)
cam_f = lambda s, x, y, h5: camera.Ideal(s, x, y, h5, offset, gain=gain)
pp_f = lambda s, x, y, h5: photophysics.SimpleSTORM(
s, x, y, h5, photons=signal)
psf_f = lambda s, x, y, h5: psf.GaussianPSF(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)
sim.simulate("test.tif", "sim_locs.hdf5", n_frames)
def makeSampleData():
# Create sample bead data for fiducial tracking.
#
# Create randomly located localizations file.
#
print("Creating random localizations.")
emittersUniformRandom.emittersUniformRandom("random.hdf5", density, margin,
x_size, y_size, 0.0)
# Create X/Y/Z drift file.
#
dx = numpy.random.normal(loc=x_loc, scale=x_scale, size=n_frames)
dy = numpy.random.normal(loc=y_loc, scale=y_scale, size=n_frames)
# Integrate dx, dy
for i in range(1, dx.size):
dx[i] = dx[i - 1] + dx[i]
dy[i] = dy[i - 1] + dy[i]
drift_data = numpy.zeros((dx.size, 3))
drift_data[:, 0] = dx
drift_data[:, 1] = dy
numpy.savetxt("drift.txt", drift_data)
# Create simulated data for fiducial tracking.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.Ideal(s, x, y, h5, camera_offset)
drift_f = lambda s, x, y, h5: drift.DriftFromFile(s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5: photophysics.SimpleSTORM(
s, x, y, h5, 4000, on_time=10.0, off_time=1.0)
psf_f = lambda s, x, y, h5: psf.GaussianPSF(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)
sim.simulate("fiducials.tif", "random.hdf5", n_frames)
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 makeData():
index = 1
# Gaussian non-uniform background, STORM.
if True:
for elt in ["drift_xy.txt", "drift_xyz.txt"]:
bg = settings.background
photons = 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)
drift_f = lambda s, x, y, i3: drift.DriftFromFile(s, x, y, i3, elt)
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,
drift_factory=drift_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
sim.simulate(wdir + "/test.dax", "clusters_list.hdf5",
settings.n_frames)
#sim.simulate(wdir + "/test.dax", "lines_list.hdf5", settings.n_frames)
index += 1
def createMovie(movie_name, use_dh=False):
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-z_range, 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_offsets.txt", z_offset)
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)
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, signal)
if use_dh:
psf_f = lambda s, x, y, i3: psf.DHPSF(s, x, y, i3, pixel_size)
else:
psf_f = lambda s, x, y, i3: psf.PupilFunction(s, x, y, i3, pixel_size,
[[1.3, 2, 2]])
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)
sim.simulate(movie_name, "spliner_measure_psf.hdf5", dz.size)
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))
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)
if settings.use_dh:
psf_f = lambda s, x, y, i3: psf.DHPSF(
s, x, y, i3, 100.0, z_range=settings.spline_z_range)
else:
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,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
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))
parser = argparse.ArgumentParser(description = "A simple simulation example.")
parser.add_argument('--dax', dest='dax_file', type=str, required=True,
help = "The name of the dax file to save the simulated STORM movie.")
parser.add_argument('--bin', dest='hdf5', type=str, required=True,
help = "The name of the HDF5 file containing the emitter locations.")
parser.add_argument('--frames', dest='frames', type=int, required=True,
help = "The length of the movie in frames.")
parser.add_argument('--photons', dest='photons', type=float, required=True,
help = "The integral of a single emitter in photons.")
args = parser.parse_args()
sim = Simulate(lambda settings, xs, ys, h5data : background.UniformBackground(settings, xs, ys, h5data),
lambda settings, xs, ys, h5data : camera.Ideal(settings, xs, ys, h5data, 100.0),
lambda settings, xs, ys, h5data : photophysics.AlwaysOn(settings, xs, ys, h5data, args.photons),
lambda settings, xs, ys, h5data : psf.GaussianPSF(settings, xs, ys, h5data, 160.0))
sim.simulate(args.dax_file, args.hdf5, args.frames)
#
# 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
#
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 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)
if settings.use_dh:
psf_f = lambda s, x, y, i3 : psf.DHPSF(s, x, y, i3, 100.0, z_range = settings.spline_z_range)
else:
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)
def configure(no_splines, cal_file=None):
# Create sCMOS calibration file if requested.
#
if cal_file is not None:
offset = numpy.zeros(
(settings.y_size, settings.x_size)) + settings.camera_offset
variance = numpy.ones((settings.y_size, settings.x_size))
gain = numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_gain
rqe = numpy.ones((settings.y_size, settings.x_size))
numpy.save(cal_file, [offset, variance, gain, rqe, 2])
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file=cal_file)
params.toXMLFile("spliner.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",
"sparse_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40"
])
if no_splines:
return
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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)
sim.simulate("spline.dax", "sparse_list.hdf5", dz.size)
# Measure the PSF.
#
print("Measuring PSF.")
psf_name = "psf.psf"
spliner_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/spliner/"
subprocess.call([
"python", spliner_path + "measure_psf_beads.py", "--movie",
"spline.dax", "--zoffset", "z_offset.txt", "--beads", "beads.txt",
"--psf", psf_name, "--aoi_size",
str(settings.spline_size + 1)
])
# Smooth the PSF if requested.
#
if settings.smooth_psf:
with open(psf_name, "rb") as fp:
psf_data = pickle.load(fp)
sm_psf = measurePSFUtils.smoothPSF(psf_data["psf"],
xy_sigma=settings.smooth_psf_sigma,
z_sigma=settings.smooth_psf_sigma)
psf_data["psf"] = sm_psf
psf_data["smoothed"] = True
psf_name = "psf_smooth.psf"
with open(psf_name, "wb") as fp:
pickle.dump(psf_data, fp)
# Measure the Spline.
#
if True:
print("Measuring Spline.")
subprocess.call([
"python", spliner_path + "psf_to_spline.py", "--psf", psf_name,
"--spline", "psf.spline", "--spline_size",
str(settings.spline_size)
])
def configure(no_splines):
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters()
params.toXMLFile("fdecon.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("sparse_list.hdf5", 6, 3, 1.5, 40, 0.0, 0.0)
if no_splines:
return
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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)
if settings.use_dh:
psf_f = lambda s, x, y, i3: psf.DHPSF(
s, x, y, i3, 100.0, z_range=settings.spline_z_range)
else:
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)
sim.simulate("spline.dax", "sparse_list.hdf5", dz.size)
# Measure the PSF.
#
print("Measuring PSF.")
psf_name = "psf.psf"
measurePSFBeads.measurePSFBeads("spline.dax",
"z_offset.txt",
"beads.txt",
psf_name,
aoi_size=int(settings.spline_size + 1),
pixel_size=settings.pixel_size * 1.0e-3,
z_range=settings.spline_z_range)
# Measure the Spline.
#
if True:
print("Measuring Spline.")
psfToSpline.psfToSpline(psf_name, "psf.spline", settings.spline_size)
def configure():
# Create PF for pupil function.
#
pupilfn_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/pupilfn/"
print("Creating pupil function.")
subprocess.call([
"python", pupilfn_path + "make_pupil_fn.py", "--filename",
"pupilfn.pfn", "--size",
str(settings.spline_size), "--pixel-size",
str(settings.pixel_size), "--zmn",
str(settings.zmn), "--z-offset",
str(settings.z_offset)
])
# Create PSF using pupil functions directly.
#
if False:
psf_fft_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/psf_fft/"
print("Creating (theoritical) psf.")
subprocess.call([
"python", psf_fft_path + "make_psf_from_pf.py", "--filename",
"psf_fft.psf", "--size",
str(settings.spline_size), "--pixel-size",
str(settings.pixel_size), "--zrange",
str(settings.psf_fft_z_range), "--zstep",
str(settings.psf_fft_z_step)
])
exit()
# Localizations on a sparse parse grid for PSF
# measurement for Spliner and PSF FFT.
#
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_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40",
"--zoffset",
str(settings.z_offset)
])
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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)
sim.simulate("psf.dax", "sparse_list.hdf5", dz.size)
# Create spline for Spliner
#
# Measure the PSF for Spliner
#
print("Measuring PSF.")
spliner_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/spliner/"
subprocess.call([
"python", spliner_path + "measure_psf_beads.py", "--movie", "psf.dax",
"--zoffset", "z_offset.txt", "--aoi_size",
str(int(settings.spline_size / 2) + 1), "--beads", "beads.txt",
"--psf", "psf_spliner.psf"
])
# Measure the Spline.
#
# This is slow, sometimes you don't want to do it.
if True:
print("Measuring Spline.")
subprocess.call([
"python", spliner_path + "psf_to_spline.py", "--psf",
"psf_spliner.psf", "--spline", "psf.spline", "--spline_size",
str(settings.spline_size)
])
# Create measured PSF for PSF FFT.
#
# Measure the PSF using spliner/measure_psf_beads.py
#
print("Measuring PSF.")
subprocess.call([
"python", spliner_path + "measure_psf_beads.py", "--movie", "psf.dax",
"--zoffset", "z_offset.txt", "--aoi_size",
str(int(settings.spline_size / 2) + 1), "--beads", "beads.txt",
"--psf", "psf_fft_2x.psf", "--zrange",
str(settings.psf_fft_z_range), "--zstep",
str(settings.psf_fft_z_step)
])
# Downsample by 2x for use by PSF FFT.
#
psf_fft_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/psf_fft/"
print("Creating downsampled psf.")
subprocess.call([
"python", psf_fft_path + "downsample_psf.py", "--spliner_psf",
"psf_fft_2x.psf", "--psf", "psf_fft.psf", "--pixel-size",
str(settings.pixel_size)
])
def configure(cal_file = None):
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file = cal_file)
params.toXMLFile("psf_fft.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("sparse_list.hdf5",
6,
3,
1.5,
40,
0.0,
0.0)
if False:
# Create PSF using pupil functions directly.
#
print("Creating (theoritical) psf.")
makePSFFromPF.makePSF("psf.psf",
settings.psf_size,
settings.pixel_size * 1.0e-3,
settings.zmn,
settings.psf_z_range,
settings.z_step)
else:
# Create beads.txt file for PSF measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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)
# 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)
sim.simulate("psf.dax", "sparse_list.hdf5", dz.size)
# Measure the PSF using spliner/measure_psf_beads.py
#
print("Measuring PSF.")
measurePSFBeads.measurePSFBeads("psf.dax",
"z_offset.txt",
"beads.txt",
"psf.psf",
aoi_size = int(settings.psf_size/2)+1,
pixel_size = settings.pixel_size * 1.0e-3,
z_range = settings.psf_z_range,
z_step = settings.z_step)
def configure(no_splines, cal_file=None):
# Create sCMOS calibration file if requested.
#
if cal_file is not None:
offset = numpy.zeros(
(settings.y_size, settings.x_size)) + settings.camera_offset
variance = numpy.ones((settings.y_size, settings.x_size))
gain = numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_gain
rqe = numpy.ones((settings.y_size, settings.x_size))
numpy.save(cal_file, [offset, variance, gain, rqe, 2])
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file=cal_file)
params.toXMLFile("spliner.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("sparse_list.hdf5", 6, 3, 1.5, 40, 0.0, 0.0)
if no_splines:
return
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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)
sim.simulate("spline.dax", "sparse_list.hdf5", dz.size)
# Measure the PSF.
#
print("Measuring PSF.")
psf_name = "psf.psf"
measurePSFBeads.measurePSFBeads("spline.dax",
"z_offset.txt",
"beads.txt",
psf_name,
aoi_size=int(settings.spline_size + 1),
pixel_size=settings.pixel_size * 1.0e-3,
z_range=settings.spline_z_range)
# Smooth the PSF if requested.
#
if settings.smooth_psf:
with open(psf_name, "rb") as fp:
psf_data = pickle.load(fp)
sm_psf = measurePSFUtils.smoothPSF(psf_data["psf"],
xy_sigma=settings.smooth_psf_sigma,
z_sigma=settings.smooth_psf_sigma)
psf_data["psf"] = sm_psf
psf_data["smoothed"] = True
psf_name = "psf_smooth.psf"
with open(psf_name, "wb") as fp:
pickle.dump(psf_data, fp)
# Measure the Spline.
#
if True:
print("Measuring Spline.")
psfToSpline.psfToSpline(psf_name, "psf.spline", settings.spline_size)
def configure(no_splines, cal_file = None):
# Create sCMOS calibration file if requested.
#
if cal_file is not None:
offset = numpy.zeros((settings.y_size, settings.x_size)) + settings.camera_offset
variance = numpy.ones((settings.y_size, settings.x_size))
gain = numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain
rqe = numpy.ones((settings.y_size, settings.x_size))
numpy.save(cal_file, [offset, variance, gain, rqe, 2])
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file = cal_file)
params.toXMLFile("spliner.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"])
# 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)])
# 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_list.hdf5",
"--nx", "6",
"--ny", "3",
"--spacing", "40"])
if no_splines:
return
# 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.)
pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, 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,
dither = True,
x_size = settings.x_size,
y_size = settings.y_size)
sim.simulate("spline_2d.tif", "sparse_list.hdf5", 5)
# Measure the PSF.
#
print("Measuring PSF.")
spliner_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/"
subprocess.call(["python", spliner_path + "measure_psf.py",
"--movie", "spline_2d.tif",
"--bin", "spline_2d_ref.hdf5",
"--psf", "psf.psf",
"--want2d",
"--aoi_size", str(settings.spline_size+1)])
# Measure the Spline.
#
if True:
print("Measuring Spline.")
subprocess.call(["python", spliner_path + "psf_to_spline.py",
"--psf", "psf.psf",
"--spline", "psf.spline",
"--spline_size", str(settings.spline_size)])
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 configure(no_splines):
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters()
params.toXMLFile("fdecon.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", "--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",
"sparse_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40"
])
if no_splines:
return
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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)
if settings.use_dh:
psf_f = lambda s, x, y, i3: psf.DHPSF(
s, x, y, i3, 100.0, z_range=settings.spline_z_range)
else:
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)
sim.simulate("spline.dax", "sparse_list.hdf5", dz.size)
# Measure the PSF.
#
print("Measuring PSF.")
spliner_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/spliner/"
subprocess.call([
"python", spliner_path + "measure_psf_beads.py", "--movie",
"spline.dax", "--zoffset", "z_offset.txt", "--beads", "beads.txt",
"--psf", "psf.psf"
])
# Measure the Spline.
#
print("Measuring Spline.")
subprocess.call([
"python", spliner_path + "psf_to_spline.py", "--psf", "psf.psf",
"--spline", "psf.spline", "--spline_size",
str(settings.spline_size)
])
def configure(no_splines, cal_file = None):
# Create sCMOS calibration file if requested.
#
if cal_file is not None:
offset = numpy.zeros((settings.y_size, settings.x_size)) + settings.camera_offset
variance = numpy.ones((settings.y_size, settings.x_size))
gain = numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain
rqe = numpy.ones((settings.y_size, settings.x_size))
numpy.save(cal_file, [offset, variance, gain, rqe, 2])
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file = cal_file)
params.toXMLFile("spliner.xml")
# Create localization on a grid file.
#
print("Creating gridded localization.")
emittersOnGrid.emittersOnGrid("grid_list.hdf5",
settings.nx,
settings.ny,
1.5,
20,
0.0,
0.0)
# Create randomly located localizations file.
#
print("Creating random localization.")
emittersUniformRandom.emittersUniformRandom("random_list.hdf5",
1.0,
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_list.hdf5",
6,
3,
1.5,
40,
0.0,
0.0)
if no_splines:
return
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.txt", numpy.transpose(numpy.vstack((locs['x'], locs['y']))))
# 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.)
pp_f = lambda s, x, y, i3 : photophysics.AlwaysOn(s, x, y, i3, 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,
dither = True,
x_size = settings.x_size,
y_size = settings.y_size)
sim.simulate("spline_2d.tif", "sparse_list.hdf5", 5)
# Measure the PSF.
#
print("Measuring PSF.")
psf_name = "psf.psf"
measurePSF.measurePSF("spline_2d.tif",
"na",
"sparse_list.hdf5",
psf_name,
want2d = True,
aoi_size = int(settings.spline_size + 1),
pixel_size = settings.pixel_size * 1.0e-3)
# Measure the Spline.
#
if True:
print("Measuring Spline.")
psfToSpline.psfToSpline(psf_name, "psf.spline", settings.spline_size)
def configure():
# Create PF for pupil function.
#
print("Creating pupil function.")
pf_size = 2 * (settings.spline_size - 1)
makePupilFn.makePupilFunction("pupilfn.pfn",
pf_size,
settings.pixel_size * 1.0e-3,
settings.zmn,
z_offset=settings.z_offset)
# Create PSF using pupil functions directly.
#
if False:
print("Creating (theoritical) psf.")
makePSFFromPF.makePSF("psf_fft.psf", settings.spline_size,
settings.pixel_size * 1.0e-3, settings.zmn,
settings.psf_fft_z_range,
settings.psf_fft_z_step)
exit()
# Localizations on a sparse parse grid for PSF
# measurement for Spliner and PSF FFT.
#
print("Creating data for PSF measurement.")
emittersOnGrid.emittersOnGrid("sparse_list.hdf5", 6, 3, 1.5, 40, 0.0,
settings.z_offset)
# Create beads.txt file for spline measurement.
#
with saH5Py.SAH5Py("sparse_list.hdf5") as h5:
locs = h5.getLocalizations()
numpy.savetxt("beads.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.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 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.0)
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, settings.pixel_size, settings.zmn, pf_size=pf_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)
sim.simulate("psf.dax", "sparse_list.hdf5", dz.size)
# Create spline for Spliner
#
# Measure the PSF for Spliner
#
print("Measuring PSF.")
psf_name = "psf_spliner.psf"
measurePSFBeads.measurePSFBeads("psf.dax",
"z_offset.txt",
"beads.txt",
psf_name,
aoi_size=int(settings.spline_size + 1),
pixel_size=settings.pixel_size * 1.0e-3)
# Measure the Spline.
#
# This is slow, sometimes you don't want to do it.
if True:
print("Measuring Spline.")
psfToSpline.psfToSpline(psf_name, "psf.spline", settings.spline_size)
# Create measured PSF for PSF FFT.
#
# Measure the PSF using spliner/measure_psf_beads.py
#
print("Measuring PSF.")
measurePSFBeads.measurePSFBeads("psf.dax",
"z_offset.txt",
"beads.txt",
"psf_fft.psf",
aoi_size=int(settings.spline_size - 1),
pixel_size=settings.pixel_size * 1.0e-3,
z_range=settings.psf_fft_z_range,
z_step=settings.psf_fft_z_step)
