def configure(cal_file=None):
# Create sCMOS calibration file if not specified.
#
if cal_file is None:
cal_file = "calib.npy"
offset = numpy.zeros(
(settings.y_size, settings.x_size)) + settings.camera_offset
variance = numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_variance
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)
params.toXMLFile("scmos.xml", pretty=True)
# 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, 10,
settings.x_size,
settings.y_size, 0.0)
def configure():
# Create directory, if necessary.
if not os.path.exists(settings.wdir):
os.makedirs(settings.wdir)
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters()
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 sCMOS camera calibration files.
#
numpy.save(os.path.join(settings.wdir, "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
])
shutil.copyfile(os.path.join(settings.wdir, "calib.npy"), "calib.npy")
# Create mapping file.
with open(os.path.join(settings.wdir, "map.map"), 'wb') as fp:
pickle.dump(settings.mappings, fp)
shutil.copyfile(os.path.join(settings.wdir, "map.map"), "map.map")
# Create pupil functions for 'pupilfn'.
print("Creating pupil functions.")
for i in range(len(settings.z_planes)):
fname = "c" + str(i + 1) + "_pupilfn.pfn"
makePupilFn.makePupilFunction(os.path.join(settings.wdir, fname),
settings.psf_size,
settings.pixel_size * 1.0e-3,
settings.pupil_fn,
z_offset=-settings.z_planes[i])
shutil.copyfile(os.path.join(settings.wdir, fname), fname)
# Calculate Cramer-Rao weighting.
#
print("Calculating weights.")
planeWeighting.runPlaneWeighting("multiplane.xml",
os.path.join(settings.wdir,
"weights.npy"),
[settings.photons[0]],
settings.photons[1],
no_plots=True)
def configure():
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters()
params.toXMLFile("dao.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)
def configure():
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters()
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 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)
def configure(cal_file = None):
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(cal_file = cal_file)
params.toXMLFile("pupilfn.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 the pupil function.
#
print("Creating pupil function.")
makePupilFn.makePupilFunction("pupil_fn.pfn",
settings.pupil_size,
settings.pixel_size * 1.0e-3,
settings.zmn)
def createLocalizations():
emittersOnGrid.emittersOnGrid("sim_locs.hdf5", nx, ny, 1.5, 20, 0.0, 0.0)
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 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 createLocalizations():
emittersOnGrid.emittersOnGrid("sim_locs.hdf5", nx, ny, 1.5, 20, 0.0, 0.0)
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(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,
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(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():
# 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)
def measurePSF():
# Create sparse random localizations for PSF measurement.
#
print("Creating random localization.")
emittersUniformRandom.emittersUniformRandom("sparse_random.hdf5", 0.0002,
settings.margin,
settings.x_size,
settings.y_size, 0.0)
# Create sparser grid for PSF measurement.
#
print("Creating data for PSF measurement.")
emittersOnGrid.emittersOnGrid("sparse_grid.hdf5", 8, 3, 1.5, 40, 0.0, 0.0)
# Create text files for PSF measurement.
#
locs = saH5Py.loadLocalizations("sparse_random.hdf5")
[xf, yf] = iaUtilsC.removeNeighbors(locs["x"], locs["y"],
2.0 * ((settings.psf_size / 2) + 1))
numpy.savetxt("sparse_random.txt", numpy.transpose(numpy.vstack((xf, yf))))
locs = saH5Py.loadLocalizations("sparse_grid.hdf5")
numpy.savetxt("sparse_grid.txt",
numpy.transpose(numpy.vstack((locs['x'], locs['y']))))
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.001,
0.010)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:, 2] = dz
numpy.savetxt("drift.txt", drift_data)
# Also create the z-offset file.
#
z_offset = numpy.ones((dz.size, 2))
z_offset[:, 1] = dz
numpy.savetxt("z_offset.txt", z_offset)
z_offset[:, 0] = 0
numpy.savetxt("z_offset_none_valid.txt", z_offset)
# Create simulated data for PSF measurement.
#
bg_f = lambda s, x, y, i3: background.UniformBackground(
s, x, y, i3, photons=10)
cam_f = lambda s, x, y, i3: camera.Ideal(s, x, y, i3, 100.)
drift_f = lambda s, x, y, i3: drift.DriftFromFile(s, x, y, i3, "drift.txt")
pp_f = lambda s, x, y, i3: photophysics.AlwaysOn(s, x, y, i3, 20000.0)
psf_f = lambda s, x, y, i3: psf.PupilFunction(s, x, y, i3, 100.0, settings.
zmn)
sim = simulate.Simulate(background_factory=bg_f,
camera_factory=cam_f,
drift_factory=drift_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
if True:
sim.simulate("sparse_grid.tif", "sparse_grid.hdf5", dz.size)
sim.simulate("sparse_random.tif", "sparse_random.hdf5", dz.size)
# Measure the PSF using spliner/measure_psf_beads.py and multiplane/measure_psf.py
#
diff_detected = False
# Grid.
if True:
# Remove old results.
for elt in [
"sparse_grid_beads.psf", "sparse_grid_hdf5_zo.psf",
"sparse_grid_hdf5.psf", "sparse_grid_hdf5_mp_zo.psf"
]:
if os.path.exists(elt):
os.remove(elt)
print("Measuring PSF (beads).")
measurePSFBeads.measurePSFBeads("sparse_grid.tif",
"z_offset.txt",
"sparse_grid.txt",
"sparse_grid_beads.psf",
aoi_size=int(settings.psf_size / 2 +
1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
print("Measuring PSF (HDF5, with zoffset).")
spMeasurePSF.measurePSF("sparse_grid.tif",
"z_offset.txt",
"sparse_grid_ref.hdf5",
"sparse_grid_hdf5_zo.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
print("Measuring PSF (HDF5).")
spMeasurePSF.measurePSF("sparse_grid.tif",
"",
"sparse_grid_ref.hdf5",
"sparse_grid_hdf5.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
multiplane_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/multi_plane/"
print("Measure PSF (multiplane).")
psfZStack.psfZStack("sparse_grid.tif",
"sparse_grid.hdf5",
"sparse_grid_zstack",
aoi_size=int(settings.psf_size / 2 + 1))
mpMeasurePSF.measurePSF("sparse_grid_zstack.npy",
"z_offset.txt",
"sparse_grid_hdf5_mp_zo.psf",
z_range=settings.psf_z_range,
z_step=settings.psf_z_step,
normalize=True)
# Check that the PSFs are the same.
psf_beads = numpy.load("sparse_grid_beads.psf",
allow_pickle=True)["psf"]
psf_hdf5_zo = numpy.load("sparse_grid_hdf5_zo.psf",
allow_pickle=True)["psf"]
psf_hdf5 = numpy.load("sparse_grid_hdf5.psf", allow_pickle=True)["psf"]
psf_hdf5_mp_zo = numpy.load("sparse_grid_hdf5_mp_zo.psf",
allow_pickle=True)["psf"]
diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo)
diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5)
# Here we are only checking they are close.
if (settings.psf_size >= 20):
diff_detected = diff_detected or psfDiffCheck(
psf_beads, psf_hdf5_mp_zo, atol=0.17, rtol=0.17)
# Grid, no valid z offsets. These are supposed to fail.
#
if True:
print("Measuring PSF (beads).")
try:
measurePSFBeads.measurePSFBeads(
"sparse_grid.tif",
"z_offset_none_valid.txt",
"sparse_grid.txt",
"sparse_grid_beads.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
except AssertionError:
pass
else:
assert False, "spliner.measure_psf_beads did not fail!"
print("Measuring PSF (HDF5, with zoffset).")
try:
spMeasurePSF.measurePSF("sparse_grid.tif",
"z_offset_none_valid.txt",
"sparse_grid_ref.hdf5",
"sparse_grid_hdf5_zo.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
except AssertionError:
pass
else:
assert False, "spliner.measure_psf did not fail!"
print("Measure PSF (multiplane).")
try:
psfZStack.psfZStack("sparse_grid.tif",
"sparse_grid.hdf5",
"sparse_grid_zstack",
aoi_size=int(settings.psf_size / 2 + 1))
mpMeasurePSF.measurePSF("sparse_grid_zstack.npy",
"z_offset_none_valid.txt",
"sparse_grid_hdf5_mp_zo.psf",
z_range=settings.psf_z_range,
z_step=settings.psf_z_step,
normalize=True)
except AssertionError:
pass
else:
assert False, "multiplane PSF measurement did not fail!"
# Random.
if True:
# Remove old results.
for elt in [
"sparse_random_beads.psf", "sparse_random_hdf5_zo.psf",
"sparse_random_hdf5.psf"
]:
if os.path.exists(elt):
os.remove(elt)
print("Measuring PSF (beads).")
measurePSFBeads.measurePSFBeads("sparse_random.tif",
"z_offset.txt",
"sparse_random.txt",
"sparse_random_beads.psf",
aoi_size=int(settings.psf_size / 2 +
1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
print("Measuring PSF (HDF5, with zoffset).")
spMeasurePSF.measurePSF("sparse_random.tif",
"z_offset.txt",
"sparse_random_ref.hdf5",
"sparse_random_hdf5_zo.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
print("Measuring PSF (HDF5).")
spMeasurePSF.measurePSF("sparse_random.tif",
"",
"sparse_random_ref.hdf5",
"sparse_random_hdf5.psf",
aoi_size=int(settings.psf_size / 2 + 1),
z_range=settings.psf_z_range,
z_step=settings.psf_z_step)
psf_beads = numpy.load("sparse_random_beads.psf",
allow_pickle=True)["psf"]
psf_hdf5_zo = numpy.load("sparse_random_hdf5_zo.psf",
allow_pickle=True)["psf"]
psf_hdf5 = numpy.load("sparse_random_hdf5.psf",
allow_pickle=True)["psf"]
diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5_zo)
diff_detected = diff_detected or psfDiffCheck(psf_beads, psf_hdf5)
if diff_detected:
print("Difference detected in PSF measurements!")
else:
print("No differences detected, all good.")
if False:
with tifffile.TiffWriter("psf_diff.tif") as tf:
for i in range(psf_beads.shape[0]):
tf.save((psf_beads[i, :, :] - psf_hdf5_zo[i, :, :]).astype(
numpy.float32))
def makeSampleData():
# Create sample bead data for PSF measurement.
#
# Create sparser grid for PSF measurement.
#
print("Creating data for PSF measurement.")
emittersOnGrid.emittersOnGrid("psf_locs.hdf5", 6, 3, 1.5, 40, 0.0, 0.0)
# Create localization files for PSF measurement.
#
locs = saH5Py.loadLocalizations("psf_locs.hdf5")
for i, z_offset in enumerate(z_planes):
cx = mappings["0_" + str(i) + "_x"]
cy = mappings["0_" + str(i) + "_y"]
locs_temp = {
"x": locs["x"].copy(),
"y": locs["y"].copy(),
"z": locs["z"].copy()
}
xi = locs_temp["x"]
yi = locs_temp["y"]
xf = cx[0] + cx[1] * xi + cx[2] * yi
yf = cy[0] + cy[1] * xi + cy[2] * yi
locs_temp["x"] = xf
locs_temp["y"] = yf
locs_temp["z"][:] = z_offset
saH5Py.saveLocalizations("c" + str(i + 1) + "_psf.hdf5", locs_temp)
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-spline_z_range, spline_z_range + 0.001, 0.01)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:, 2] = dz
numpy.savetxt("drift.txt", drift_data)
# Also create the z-offset file.
#
z_offset = numpy.ones((dz.size, 2))
z_offset[:, 1] = dz
numpy.savetxt("z_offset.txt", z_offset)
# Create simulated data for PSF measurements.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy")
drift_f = lambda s, x, y, h5: drift.DriftFromFile(s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, pixel_size, [])
sim = simulate.Simulate(background_factory=bg_f,
camera_factory=cam_f,
drift_factory=drift_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=x_size,
y_size=y_size)
for i in range(len(z_planes)):
sim.simulate("c" + str(i + 1) + "_zcal.dax",
"c" + str(i + 1) + "_psf.hdf5", dz.size)
def configure(psf_model, no_splines):
# Create parameters file for analysis.
#
print("Creating XML file.")
params = testingParameters(psf_model)
params.toXMLFile("multiplane.xml")
# Create localization on a grid file.
#
print("Creating gridded localization.")
emittersOnGrid.emittersOnGrid("grid_list.hdf5", settings.nx, settings.ny,
1.5, 20, settings.test_z_range,
settings.test_z_offset)
# Create randomly located localizations file.
#
print("Creating random localization.")
emittersUniformRandom.emittersUniformRandom("random_list.hdf5", 1.0,
settings.margin,
settings.x_size,
settings.y_size,
settings.test_z_range)
# Create sparser grid for PSF measurement.
#
print("Creating data for PSF measurement.")
emittersOnGrid.emittersOnGrid("psf_list.hdf5", 6, 3, 1.5, 40, 0.0, 0.0)
# Create sCMOS camera calibration files.
#
numpy.save("calib.npy", [
numpy.zeros(
(settings.y_size, settings.x_size)) + settings.camera_offset,
numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_variance,
numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain,
numpy.ones((settings.y_size, settings.x_size)), 2
])
# Create mapping file.
with open("map.map", 'wb') as fp:
pickle.dump(settings.mappings, fp)
if no_splines:
return
# Create pupil functions for 'pupilfn'.
if (psf_model == "pupilfn"):
print("Creating pupil functions.")
for i in range(len(settings.z_planes)):
makePupilFn.makePupilFunction("c" + str(i + 1) + "_pupilfn.pfn",
settings.psf_size,
settings.pixel_size * 1.0e-3,
settings.pupil_fn,
z_offset=-settings.z_planes[i])
# Both 'spline' and 'psf_fft' need measured PSFs.
else:
# Create localization files for PSF measurement.
#
locs = saH5Py.loadLocalizations("psf_list.hdf5")
for i, z_offset in enumerate(settings.z_planes):
cx = settings.mappings["0_" + str(i) + "_x"]
cy = settings.mappings["0_" + str(i) + "_y"]
locs_temp = {
"x": locs["x"].copy(),
"y": locs["y"].copy(),
"z": locs["z"].copy()
}
xi = locs_temp["x"]
yi = locs_temp["y"]
xf = cx[0] + cx[1] * xi + cx[2] * yi
yf = cy[0] + cy[1] * xi + cy[2] * yi
locs_temp["x"] = xf
locs_temp["y"] = yf
locs_temp["z"][:] = z_offset
saH5Py.saveLocalizations("c" + str(i + 1) + "_psf.hdf5", locs_temp)
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-settings.spline_z_range,
settings.spline_z_range + 0.001, 0.01)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:, 2] = dz
numpy.savetxt("drift.txt", drift_data)
# Also create the z-offset file.
#
z_offset = numpy.ones((dz.size, 2))
z_offset[:, 1] = dz
numpy.savetxt("z_offset.txt", z_offset)
# Create simulated data for PSF measurements.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy")
drift_f = lambda s, x, y, h5: drift.DriftFromFile(
s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, h5: psf.PupilFunction(
s, x, y, h5, settings.pixel_size, settings.pupil_fn)
sim = simulate.Simulate(background_factory=bg_f,
camera_factory=cam_f,
drift_factory=drift_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
for i in range(len(settings.z_planes)):
sim.simulate("c" + str(i + 1) + "_zcal.dax",
"c" + str(i + 1) + "_psf.hdf5", dz.size)
# Measure the PSF.
#
print("Measuring PSFs.")
for i in range(len(settings.z_planes)):
psfZStack.psfZStack("c" + str(i + 1) + "_zcal.dax",
"c" + str(i + 1) + "_psf.hdf5",
"c" + str(i + 1) + "_zstack",
aoi_size=int(settings.psf_size / 2 + 1))
# Measure PSF and calculate spline for Spliner.
#
if (psf_model == "spline"):
# PSFs are independently normalized.
#
if settings.independent_heights:
for i in range(len(settings.z_planes)):
mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy",
"z_offset.txt",
"c" + str(i + 1) + "_psf_normed.psf",
z_range=settings.spline_z_range,
normalize=True)
# PSFs are normalized to each other.
#
else:
for i in range(len(settings.z_planes)):
mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy",
"z_offset.txt",
"c" + str(i + 1) + "_psf.psf",
z_range=settings.spline_z_range)
norm_args = ["c1_psf.psf"]
for i in range(len(settings.z_planes) - 1):
norm_args.append("c" + str(i + 2) + "_psf.psf")
normalizePSFs.normalizePSFs(norm_args)
# Measure the spline for Spliner.
#
print("Measuring Spline.")
for i in range(len(settings.z_planes)):
psfToSpline.psfToSpline("c" + str(i + 1) + "_psf_normed.psf",
"c" + str(i + 1) + "_psf.spline",
int(settings.psf_size / 2))
# Measure PSF and downsample for PSF FFT.
#
elif (psf_model == "psf_fft"):
# PSFs are independently normalized.
#
if settings.independent_heights:
for i in range(len(settings.z_planes)):
mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy",
"z_offset.txt",
"c" + str(i + 1) + "_psf_normed.psf",
z_range=settings.spline_z_range,
normalize=True)
# PSFs are normalized to each other.
#
else:
for i in range(len(settings.z_planes)):
mpMeasurePSF.measurePSF("c" + str(i + 1) + "_zstack.npy",
"z_offset.txt",
"c" + str(i + 1) + "_psf.psf",
z_range=settings.spline_z_range)
norm_args = ["c1_psf.psf"]
for i in range(len(settings.z_planes) - 1):
norm_args.append("c" + str(i + 2) + "_psf.psf")
normalizePSFs.normalizePSFs(norm_args)
# Calculate Cramer-Rao weighting.
#
print("Calculating weights.")
planeWeighting.runPlaneWeighting("multiplane.xml",
"weights.npy", [settings.photons[0][0]],
settings.photons[0][1],
no_plots=True)