def analyzeData():
dirs = sorted(glob.glob("test*"))
for a_dir in dirs:
print()
print("Analyzing:", a_dir)
print()
mlist = a_dir + "/test.hdf5"
# Remove stale results, if any.
if os.path.exists(mlist):
os.remove(mlist)
# Run analysis.
start_time = time.time()
scmos.analyze(a_dir + "/test.tif", mlist, "scmos.xml")
stop_time = time.time()
# Save timing results.
print("Analysis completed in {0:.2f} seconds".format(stop_time -
start_time))
with open(a_dir + "/timing.txt", "w") as fp:
fp.write(str(stop_time - start_time) + "\n")
def test_scmos_2d_fixed():
movie_name = storm_analysis.getData("test/data/test.dax")
settings = storm_analysis.getData("test/data/test_sc_2d_fixed.xml")
mlist = storm_analysis.getPathOutputTest("test_sc_2d_fixed.bin")
storm_analysis.removeFile(mlist)
from storm_analysis.sCMOS.scmos_analysis import analyze
analyze(movie_name, mlist, settings)
def test_scmos_Z():
movie_name = storm_analysis.getData("test/data/test.dax")
settings = storm_analysis.getData("test/data/test_sc_Z.xml")
mlist = storm_analysis.getPathOutputTest("test_sc_Z.hdf5")
storm_analysis.removeFile(mlist)
from storm_analysis.sCMOS.scmos_analysis import analyze
analyze(movie_name, mlist, settings)
# Verify number of localizations found.
num_locs = veri.verifyNumberLocalizations(mlist)
if not veri.verifyIsCloseEnough(num_locs, 1942):
raise Exception("sCMOS Z did not find the expected number of localizations.")
def test_scmos_Z():
movie_name = storm_analysis.getData("test/data/test.dax")
settings = storm_analysis.getData("test/data/test_sc_Z.xml")
mlist = storm_analysis.getPathOutputTest("test_sc_Z.bin")
storm_analysis.removeFile(mlist)
from storm_analysis.sCMOS.scmos_analysis import analyze
analyze(movie_name, mlist, settings)
# Verify number of localizations found.
num_locs = veri.verifyNumberLocalizations(mlist)
if not veri.verifyIsCloseEnough(num_locs, 1958):
raise Exception(
"sCMOS Z did not find the expected number of localizations.")
def test_scmos_3d():
movie_name = storm_analysis.getData("test/data/test.dax")
settings = storm_analysis.getData("test/data/test_sc_3d.xml")
mlist = storm_analysis.getPathOutputTest("test_sc_3d.hdf5")
storm_analysis.removeFile(mlist)
from storm_analysis.sCMOS.scmos_analysis import analyze
analyze(movie_name, mlist, settings)
# Verify number of localizations found.
num_locs = veri.verifyNumberLocalizations(mlist)
if not veri.verifyIsCloseEnough(num_locs, 1950):
raise Exception("sCMOS 3D did not find the expected number of localizations.")
# Verify that the Z values actually got calculated.
if not veri.verifyZWasCalculated(mlist):
raise Exception("Z values were not calculated for sCMOS 3D fitting.")
def test_scmos_3d():
movie_name = storm_analysis.getData("test/data/test.dax")
settings = storm_analysis.getData("test/data/test_sc_3d.xml")
mlist = storm_analysis.getPathOutputTest("test_sc_3d.hdf5")
storm_analysis.removeFile(mlist)
from storm_analysis.sCMOS.scmos_analysis import analyze
analyze(movie_name, mlist, settings)
# Verify number of localizations found.
num_locs = veri.verifyNumberLocalizations(mlist)
if not veri.verifyIsCloseEnough(num_locs, 1950):
raise Exception(
"sCMOS 3D did not find the expected number of localizations.")
# Verify that the Z values actually got calculated.
if not veri.verifyZWasCalculated(mlist):
raise Exception("Z values were not calculated for sCMOS 3D fitting.")
def analyzeData():
dirs = sorted(glob.glob("test*"))
for a_dir in dirs:
print()
print("Analyzing:", a_dir)
print()
mlist = a_dir + "/test.hdf5"
# Remove stale results, if any.
if os.path.exists(mlist):
os.remove(mlist)
# Run analysis.
start_time = time.time()
scmos.analyze(a_dir + "/test.tif", mlist, "scmos.xml")
stop_time = time.time()
# Save timing results.
print("Analysis completed in {0:.2f} seconds".format(stop_time - start_time))
with open(a_dir + "/timing.txt", "w") as fp:
fp.write(str(stop_time - start_time) + "\n")
def configure():
# Get relevant paths.
mm_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/micrometry/"
mp_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/multi_plane/"
sp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/"
# Create analysis XML files.
#
print("Creating XML files.")
params = testingParametersSCMOS()
params.toXMLFile("scmos.xml")
params = testingParametersMC()
params.toXMLFile("multicolor.xml")
# Useful variables
aoi_size = int(settings.psf_size / 2) + 1
# Create sCMOS data and HDF5 files we'll need for the simulation.
#
if True:
# Create sCMOS camera calibration files.
#
numpy.save("calib.npy", [
numpy.zeros(
(settings.y_size, settings.x_size)) + settings.camera_offset,
numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_variance,
numpy.ones(
(settings.y_size, settings.x_size)) * settings.camera_gain, 1
])
# Create localization on a grid file.
#
print("Creating gridded localizations.")
sim_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/simulator/"
subprocess.call([
"python", sim_path + "emitters_on_grid.py", "--bin",
"grid_list.hdf5", "--nx",
str(settings.nx), "--ny",
str(settings.ny), "--spacing", "20", "--zrange",
str(settings.test_z_range), "--zoffset",
str(settings.test_z_offset)
])
# Create randomly located localizations file (for STORM movies).
#
print("Creating random localizations.")
subprocess.call([
"python", sim_path + "emitters_uniform_random.py", "--bin",
"random_storm.hdf5", "--density", "1.0", "--margin",
str(settings.margin), "--sx",
str(settings.x_size), "--sy",
str(settings.y_size), "--zrange",
str(settings.test_z_range)
])
# Create randomly located localizations file (for mapping measurement).
#
print("Creating random localizations.")
subprocess.call([
"python", sim_path + "emitters_uniform_random.py", "--bin",
"random_map.hdf5", "--density", "0.0003", "--margin",
str(settings.margin), "--sx",
str(settings.x_size), "--sy",
str(settings.y_size)
])
# Create sparser grid for PSF measurement.
#
print("Creating data for PSF measurement.")
sim_path = os.path.dirname(
inspect.getfile(storm_analysis)) + "/simulator/"
subprocess.call([
"python", sim_path + "emitters_on_grid.py", "--bin",
"psf_list.hdf5", "--nx", "6", "--ny", "3", "--spacing", "40"
])
## This part makes / tests measuring the mapping.
##
if True:
print("Measuring mapping.")
# Make localization files for simulations.
#
locs = saH5Py.loadLocalizations("random_map.hdf5")
locs["z"][:] = 1.0e-3 * settings.z_planes[0]
saH5Py.saveLocalizations("c1_random_map.hdf5", locs)
for i in range(1, 4):
locs["x"] += settings.dx
locs["y"] += settings.dy
locs["z"][:] = settings.z_planes[i]
saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5",
locs)
# Make localization files for simulations.
#
locs = saH5Py.loadLocalizations("random_map.hdf5")
locs["z"][:] = 1.0e-3 * settings.z_planes[0]
saH5Py.saveLocalizations("c1_random_map.hdf5", locs)
for i in range(1, 4):
locs["x"] += settings.dx
locs["y"] += settings.dy
locs["z"][:] = settings.z_planes[i]
saH5Py.saveLocalizations("c" + str(i + 1) + "_random_map.hdf5",
locs)
# Make simulated mapping data.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy")
pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, i3: psf.GaussianPSF(s, x, y, i3, settings.
pixel_size)
sim = simulate.Simulate(background_factory=bg_f,
camera_factory=cam_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
for i in range(4):
sim.simulate("c" + str(i + 1) + "_map.dax",
"c" + str(i + 1) + "_random_map.hdf5", 1)
# Analyze simulated mapping data
#
for i in range(4):
scmos.analyze("c" + str(i + 1) + "_map.dax",
"c" + str(i + 1) + "_map.hdf5", "scmos.xml")
# Measure mapping.
#
for i in range(3):
subprocess.call([
"python", mm_path + "micrometry.py", "--locs1", "c1_map.hdf5",
"--locs2", "c" + str(i + 2) + "_map.hdf5", "--results",
"c1_c" + str(i + 2) + "_map.map", "--no_plots"
])
# Merge mapping.
#
subprocess.call([
"python", mm_path + "merge_maps.py", "--results", "map.map",
"--maps", "c1_c2_map.map", "c1_c3_map.map", "c1_c4_map.map"
])
# Print mapping.
#
if True:
print("Mapping is:")
subprocess.call([
"python", mp_path + "print_mapping.py", "--mapping", "map.map"
])
print("")
# Check that mapping is close to what we expect (within 5%).
#
with open("map.map", 'rb') as fp:
mappings = pickle.load(fp)
for i in range(3):
if not numpy.allclose(mappings["0_" + str(i + 1) + "_x"],
numpy.array(
[settings.dx * (i + 1), 1.0, 0.0]),
rtol=0.05,
atol=0.05):
print("X mapping difference for channel", i + 1)
if not numpy.allclose(mappings["0_" + str(i + 1) + "_y"],
numpy.array(
[settings.dy * (i + 1), 0.0, 1.0]),
rtol=0.05,
atol=0.05):
print("Y mapping difference for channel", i + 1)
## This part measures / test the PSF measurement.
##
if True:
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.05,
0.01)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:, 2] = dz
numpy.savetxt("drift.txt", drift_data)
# Also create the z-offset file.
#
z_offset = numpy.ones((dz.size, 2))
z_offset[:, 1] = dz
numpy.savetxt("z_offset.txt", z_offset)
# Create simulated data for PSF measurements.
#
bg_f = lambda s, x, y, h5: background.UniformBackground(
s, x, y, h5, photons=10)
cam_f = lambda s, x, y, h5: camera.SCMOS(s, x, y, h5, "calib.npy")
drift_f = lambda s, x, y, h5: drift.DriftFromFile(
s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5: photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, h5: psf.PupilFunction(s, x, y, h5, settings.
pixel_size, [])
sim = simulate.Simulate(background_factory=bg_f,
camera_factory=cam_f,
drift_factory=drift_f,
photophysics_factory=pp_f,
psf_factory=psf_f,
x_size=settings.x_size,
y_size=settings.y_size)
if True:
for i in range(4):
sim.simulate("c" + str(i + 1) + "_zcal.dax",
"c" + str(i + 1) + "_random_map.hdf5", dz.size)
# Get localizations to use for PSF measurement.
#
subprocess.call([
"python", mp_path + "psf_localizations.py", "--bin",
"c1_map_ref.hdf5", "--map", "map.map", "--aoi_size",
str(aoi_size)
])
# Create PSF z stacks.
#
for i in range(4):
subprocess.call([
"python", mp_path + "psf_zstack.py", "--movie",
"c" + str(i + 1) + "_zcal.dax", "--bin",
"c1_map_ref_c" + str(i + 1) + "_psf.hdf5", "--zstack",
"c" + str(i + 1) + "_zstack", "--scmos_cal", "calib.npy",
"--aoi_size",
str(aoi_size)
])
# Measure PSF.
#
for i in range(4):
subprocess.call([
"python", mp_path + "measure_psf.py", "--zstack",
"c" + str(i + 1) + "_zstack.npy", "--zoffsets", "z_offset.txt",
"--psf_name", "c" + str(i + 1) + "_psf_normed.psf",
"--z_range",
str(settings.psf_z_range), "--normalize"
])
## This part creates the splines.
##
if True:
print("Measuring Splines.")
for i in range(4):
subprocess.call([
"python", sp_path + "psf_to_spline.py", "--psf",
"c" + str(i + 1) + "_psf_normed.psf", "--spline",
"c" + str(i + 1) + "_psf.spline", "--spline_size",
str(settings.psf_size)
])
## This part measures the Cramer-Rao weights.
##
if True:
print("Calculating weights.")
subprocess.call([
"python", mp_path + "plane_weighting.py", "--background",
str(settings.photons[0][0]), "--photons",
str(settings.photons[0][1]), "--output", "weights.npy", "--xml",
"multicolor.xml", "--no_plots"
])
def configure():
# Get relevant paths.
mm_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/micrometry/"
mp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/multi_plane/"
sp_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/spliner/"
# Create analysis XML files.
#
print("Creating XML files.")
params = testingParametersSCMOS()
params.toXMLFile("scmos.xml")
params = testingParametersMC()
params.toXMLFile("multicolor.xml")
# Useful variables
aoi_size = int(settings.psf_size/2)+1
# Create sCMOS data and HDF5 files we'll need for the simulation.
#
if True:
# Create sCMOS camera calibration files.
#
numpy.save("calib.npy", [numpy.zeros((settings.y_size, settings.x_size)) + settings.camera_offset,
numpy.ones((settings.y_size, settings.x_size)) * settings.camera_variance,
numpy.ones((settings.y_size, settings.x_size)) * settings.camera_gain,
numpy.ones((settings.y_size, settings.x_size)),
2])
# Create localization on a grid file.
#
print("Creating gridded localizations.")
sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/"
subprocess.call(["python", sim_path + "emitters_on_grid.py",
"--bin", "grid_list.hdf5",
"--nx", str(settings.nx),
"--ny", str(settings.ny),
"--spacing", "20",
"--zrange", str(settings.test_z_range),
"--zoffset", str(settings.test_z_offset)])
# Create randomly located localizations file (for STORM movies).
#
print("Creating random localizations.")
subprocess.call(["python", sim_path + "emitters_uniform_random.py",
"--bin", "random_storm.hdf5",
"--density", "1.0",
"--margin", str(settings.margin),
"--sx", str(settings.x_size),
"--sy", str(settings.y_size),
"--zrange", str(settings.test_z_range)])
# Create randomly located localizations file (for mapping measurement).
#
print("Creating random localizations.")
subprocess.call(["python", sim_path + "emitters_uniform_random.py",
"--bin", "random_map.hdf5",
"--density", "0.0003",
"--margin", str(settings.margin),
"--sx", str(settings.x_size),
"--sy", str(settings.y_size)])
# Create sparser grid for PSF measurement.
#
print("Creating data for PSF measurement.")
sim_path = os.path.dirname(inspect.getfile(storm_analysis)) + "/simulator/"
subprocess.call(["python", sim_path + "emitters_on_grid.py",
"--bin", "psf_list.hdf5",
"--nx", "6",
"--ny", "3",
"--spacing", "40"])
## This part makes / tests measuring the mapping.
##
if True:
print("Measuring mapping.")
# Make localization files for simulations.
#
locs = saH5Py.loadLocalizations("random_map.hdf5")
locs["z"][:] = 1.0e-3 * settings.z_planes[0]
saH5Py.saveLocalizations("c1_random_map.hdf5", locs)
for i in range(1,4):
locs["x"] += settings.dx
locs["y"] += settings.dy
locs["z"][:] = settings.z_planes[i]
saH5Py.saveLocalizations("c" + str(i+1) + "_random_map.hdf5", locs)
# Make localization files for simulations.
#
locs = saH5Py.loadLocalizations("random_map.hdf5")
locs["z"][:] = 1.0e-3 * settings.z_planes[0]
saH5Py.saveLocalizations("c1_random_map.hdf5", locs)
for i in range(1,4):
locs["x"] += settings.dx
locs["y"] += settings.dy
locs["z"][:] = settings.z_planes[i]
saH5Py.saveLocalizations("c" + str(i+1) + "_random_map.hdf5", locs)
# Make simulated mapping data.
#
bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10)
cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy")
pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, i3 : psf.GaussianPSF(s, x, y, i3, settings.pixel_size)
sim = simulate.Simulate(background_factory = bg_f,
camera_factory = cam_f,
photophysics_factory = pp_f,
psf_factory = psf_f,
x_size = settings.x_size,
y_size = settings.y_size)
for i in range(4):
sim.simulate("c" + str(i+1) + "_map.dax", "c" + str(i+1) + "_random_map.hdf5", 1)
# Analyze simulated mapping data
#
for i in range(4):
scmos.analyze("c" + str(i+1) + "_map.dax", "c" + str(i+1) + "_map.hdf5", "scmos.xml")
# Measure mapping.
#
for i in range(3):
subprocess.call(["python", mm_path + "micrometry.py",
"--locs1", "c1_map.hdf5",
"--locs2", "c" + str(i+2) + "_map.hdf5",
"--results", "c1_c" + str(i+2) + "_map.map",
"--no_plots"])
# Merge mapping.
#
subprocess.call(["python", mm_path + "merge_maps.py",
"--results", "map.map",
"--maps", "c1_c2_map.map", "c1_c3_map.map", "c1_c4_map.map"])
# Print mapping.
#
if True:
print("Mapping is:")
subprocess.call(["python", mp_path + "print_mapping.py",
"--mapping", "map.map"])
print("")
# Check that mapping is close to what we expect (within 5%).
#
with open("map.map", 'rb') as fp:
mappings = pickle.load(fp)
for i in range(3):
if not numpy.allclose(mappings["0_" + str(i+1) + "_x"], numpy.array([settings.dx*(i+1), 1.0, 0.0]), rtol = 0.05, atol = 0.05):
print("X mapping difference for channel", i+1)
if not numpy.allclose(mappings["0_" + str(i+1) + "_y"], numpy.array([settings.dy*(i+1), 0.0, 1.0]), rtol = 0.05, atol = 0.05):
print("Y mapping difference for channel", i+1)
## This part measures / test the PSF measurement.
##
if True:
# Create drift file, this is used to displace the localizations in the
# PSF measurement movie.
#
dz = numpy.arange(-settings.psf_z_range, settings.psf_z_range + 0.05, 0.01)
drift_data = numpy.zeros((dz.size, 3))
drift_data[:,2] = dz
numpy.savetxt("drift.txt", drift_data)
# Also create the z-offset file.
#
z_offset = numpy.ones((dz.size, 2))
z_offset[:,1] = dz
numpy.savetxt("z_offset.txt", z_offset)
# Create simulated data for PSF measurements.
#
bg_f = lambda s, x, y, h5 : background.UniformBackground(s, x, y, h5, photons = 10)
cam_f = lambda s, x, y, h5 : camera.SCMOS(s, x, y, h5, "calib.npy")
drift_f = lambda s, x, y, h5 : drift.DriftFromFile(s, x, y, h5, "drift.txt")
pp_f = lambda s, x, y, h5 : photophysics.AlwaysOn(s, x, y, h5, 20000.0)
psf_f = lambda s, x, y, h5 : psf.PupilFunction(s, x, y, h5, settings.pixel_size, [])
sim = simulate.Simulate(background_factory = bg_f,
camera_factory = cam_f,
drift_factory = drift_f,
photophysics_factory = pp_f,
psf_factory = psf_f,
x_size = settings.x_size,
y_size = settings.y_size)
if True:
for i in range(4):
sim.simulate("c" + str(i+1) + "_zcal.dax",
"c" + str(i+1) + "_random_map.hdf5",
dz.size)
# Get localizations to use for PSF measurement.
#
subprocess.call(["python", mp_path + "psf_localizations.py",
"--bin", "c1_map_ref.hdf5",
"--map", "map.map",
"--aoi_size", str(aoi_size)])
# Create PSF z stacks.
#
for i in range(4):
subprocess.call(["python", mp_path + "psf_zstack.py",
"--movie", "c" + str(i+1) + "_zcal.dax",
"--bin", "c1_map_ref_c" + str(i+1) + "_psf.hdf5",
"--zstack", "c" + str(i+1) + "_zstack",
"--scmos_cal", "calib.npy",
"--aoi_size", str(aoi_size)])
# Measure PSF.
#
for i in range(4):
subprocess.call(["python", mp_path + "measure_psf.py",
"--zstack", "c" + str(i+1) + "_zstack.npy",
"--zoffsets", "z_offset.txt",
"--psf_name", "c" + str(i+1) + "_psf_normed.psf",
"--z_range", str(settings.psf_z_range),
"--normalize"])
## This part creates the splines.
##
if True:
print("Measuring Splines.")
for i in range(4):
subprocess.call(["python", sp_path + "psf_to_spline.py",
"--psf", "c" + str(i+1) + "_psf_normed.psf",
"--spline", "c" + str(i+1) + "_psf.spline",
"--spline_size", str(int(settings.psf_size/2))])
## This part measures the Cramer-Rao weights.
##
if True:
print("Calculating weights.")
subprocess.call(["python", mp_path + "plane_weighting.py",
"--background", str(settings.photons[0][0]),
"--photons", str(settings.photons[0][1]),
"--output", "weights.npy",
"--xml", "multicolor.xml",
"--no_plots"])
def 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)