def test_fitz_c_5(): """ Test that fitz_c.wXwYCurveDistance works correctly. """ # Load 3D parameters. settings = storm_analysis.getData("test/data/test_3d_3d.xml") parameters = params.ParametersDAO().initFromFile(settings) [wx_params, wy_params] = parameters.getWidthParams() [min_z, max_z] = parameters.getZRange() pixel_size = parameters.getAttr("pixel_size") # Calculate widths. z_vals = numpy.arange(-250.0, 251.0, 50) [sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals) # Distances should be very close to zero. dist = fitzC.wXwYCurveDistance(wx_params, wy_params, 2.0 * sx, 2.0 * sy, min_z, max_z, 0.001) assert numpy.allclose(dist, numpy.zeros(sx.size)) # First distance should be larger. sx[0] += 10.0 dist = fitzC.wXwYCurveDistance(wx_params, wy_params, 2.0 * sx, 2.0 * sy, min_z, max_z, 0.001) expected = numpy.zeros(sx.size) expected[0] = 0.0345862 assert numpy.allclose(dist, expected)
def trackAverageCorrect(input_file, output_file, params_file): parameters = params.ParametersDAO().initFromFile(params_file) # Tracking print("Tracking") std_analysis.tracking(input_file, parameters) # Averaging print("Averaging") did_averaging = False if (parameters.getAttr("radius") > 0.0): did_averaging = True std_analysis.averaging(input_file, output_file) print("") # Z fitting. if (parameters.getAttr("do_zfit", 0) != 0): print("Fitting Z") std_analysis.zFitting(input_file, parameters) std_analysis.zFitting(output_file, parameters) print("") # Drift correction print("Drift Correction") if (parameters.getAttr("drift_correction", 0) != 0): if did_averaging: std_analysis.driftCorrection([input_file, output_file], parameters) else: std_analysis.driftCorrection([input_file], parameters) print("")
def testingParameters(): """ Create a 3D-DAOSTORM parameters object. """ params = parameters.ParametersDAO() params.setAttr("max_frame", "int", -1) params.setAttr("start_frame", "int", -1) params.setAttr("background_sigma", "float", 8.0) params.setAttr("camera_gain", "float", settings.camera_gain) params.setAttr("camera_offset", "float", settings.camera_offset) params.setAttr("find_max_radius", "int", 5) params.setAttr("foreground_sigma", "float", 1.0) params.setAttr("iterations", "int", settings.iterations) params.setAttr("model", "string", settings.model) params.setAttr("pixel_size", "float", settings.pixel_size) params.setAttr("roi_size", "int", 9) params.setAttr("sigma", "float", 1.5) params.setAttr("threshold", "float", 6.0) # Do tracking. params.setAttr("descriptor", "string", "1") params.setAttr("radius", "float", "0.5") # Do drift-correction. params.setAttr("d_scale", "int", 2) params.setAttr("drift_correction", "int", 1) params.setAttr("frame_step", "int", 500) params.setAttr("z_correction", "int", 1) return params
def test_xml_round_trip(): original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") output = storm_analysis.getPathOutputTest("test_rt.xml") # Load parameters. p1 = params.ParametersDAO().initFromFile(original, warnings=True) # Convert back to XML. p1.toXMLFile(output) # And read again. p2 = params.ParametersDAO().initFromFile(output, warnings=True) # And compare. if (p1.getAttr("threshold") != p2.getAttr("threshold")): raise Exception("Parameter XML input / output failed.")
def createParametersFile(): """ Create a 3D-DAOSTORM parameters file. """ params = parameters.ParametersDAO() params.setAttr("max_frame", "int", -1) params.setAttr("start_frame", "int", -1) params.setAttr("background_sigma", "float", 8.0) params.setAttr("camera_gain", "float", camera_gain) params.setAttr("camera_offset", "float", camera_offset) params.setAttr("find_max_radius", "int", 5) params.setAttr("foreground_sigma", "float", 1.0) params.setAttr("iterations", "int", 1) params.setAttr("model", "string", model) params.setAttr("pixel_size", "float", pixel_size) params.setAttr("peak_locations", "filename", "peak_locs.hdf5") params.setAttr("roi_size", "int", 9) params.setAttr("sigma", "float", 1.5) params.setAttr("threshold", "float", 6.0) # Z fitting. params.setAttr("do_zfit", "int", 0) params.setAttr("cutoff", "float", 0.0) params.setAttr("max_z", "float", 0.5) params.setAttr("min_z", "float", -0.5) params.setAttr("z_value", "float", 0.0) params.setAttr("z_step", "float", 0.001) params.setAttr("wx_wo", "float", 300.0) params.setAttr("wx_c", "float", 150.0) params.setAttr("wx_d", "float", 400.0) params.setAttr("wxA", "float", 0.0) params.setAttr("wxB", "float", 0.0) params.setAttr("wxC", "float", 0.0) params.setAttr("wxD", "float", 0.0) params.setAttr("wy_wo", "float", 300.0) params.setAttr("wy_c", "float", -150.0) params.setAttr("wy_d", "float", 400.0) params.setAttr("wyA", "float", 0.0) params.setAttr("wyB", "float", 0.0) params.setAttr("wyC", "float", 0.0) params.setAttr("wyD", "float", 0.0) # Do tracking. params.setAttr("descriptor", "string", "1") params.setAttr("radius", "float", "0.5") # Do drift-correction. params.setAttr("d_scale", "int", 2) params.setAttr("drift_correction", "int", 1) params.setAttr("frame_step", "int", 500) params.setAttr("z_correction", "int", 0) params.toXMLFile("dao3d_crao.xml")
def daoSTORMXML(): """ Create a 3D-DAOSTORM parameters object. """ params = parameters.ParametersDAO() params.setAttr("max_frame", "int", -1) params.setAttr("start_frame", "int", -1) params.setAttr("background_sigma", "float", 8.0) params.setAttr("camera_gain", "float", 1.0) params.setAttr("camera_offset", "float", camera_offset) params.setAttr("find_max_radius", "int", 5) params.setAttr("foreground_sigma", "float", 1.0) params.setAttr("iterations", "int", iterations) params.setAttr("model", "string", "2dfixed") params.setAttr("pixel_size", "float", pixel_size) params.setAttr("roi_size", "int", 9) params.setAttr("sigma", "float", 1.5) params.setAttr("threshold", "float", threshold) # Don't do tracking. params.setAttr("descriptor", "string", "1") params.setAttr("radius", "float", "0") # Don't do drift-correction. params.setAttr("d_scale", "int", 2) params.setAttr("drift_correction", "int", 0) params.setAttr("frame_step", "int", 500) params.setAttr("z_correction", "int", 0) # Z fitting. params.setAttr("do_zfit", "int", 0) params.setAttr("cutoff", "float", 0.0) params.setAttr("max_z", "float", 0.5) params.setAttr("min_z", "float", -0.5) params.setAttr("z_value", "float", 0.0) params.setAttr("z_step", "float", 1.0) params.setAttr("wx_wo", "float", 1.0) params.setAttr("wx_c", "float", 1.0) params.setAttr("wx_d", "float", 1.0) params.setAttr("wxA", "float", 0.0) params.setAttr("wxB", "float", 0.0) params.setAttr("wxC", "float", 0.0) params.setAttr("wxD", "float", 0.0) params.setAttr("wy_wo", "float", 1.0) params.setAttr("wy_c", "float", 1.0) params.setAttr("wy_d", "float", 1.0) params.setAttr("wyA", "float", 0.0) params.setAttr("wyB", "float", 0.0) params.setAttr("wyC", "float", 0.0) params.setAttr("wyD", "float", 0.0) params.toXMLFile("daostorm.xml")
def test_get_attr_3(): """ Test getting parameters. """ # Load some parameters. original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") p1 = params.ParametersDAO().initFromFile(original, warnings=True) v1 = p1.getAttr("start_frame") v1 = p1.getAttr("x_start", 1)
def test_get_help_1(): """ Test getting help. """ # Load some parameters. original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") p1 = params.ParametersDAO().initFromFile(original, warnings=True) v1 = p1.helpAttr("max_frame") v1 = p1.helpAttr("convert_to")
def test_pretty_print_1(): # This just tests that it doesn't fail. It does not check the # formatting of the output file. original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") output = storm_analysis.getPathOutputTest("test_pp1.xml") # Load parameters. p1 = params.ParametersDAO().initFromFile(original, warnings=True) # Convert back to XML. p1.toXMLFile(output, pretty=True)
def test_change_attr_2(): """ Test specifying a node type that doesn't exist. """ p1 = params.ParametersDAO() try: v1 = p1.changeAttr("find_max_radius", 1, node_type="foo") except params.ParametersException: return assert False
def test_change_attr_1(): """ Test not specifying the node type. """ p1 = params.ParametersDAO() try: v1 = p1.changeAttr("find_max_radius", 1) except params.ParametersException: return assert False
def test_get_attr_2(): """ Test no such parameter with default value. """ # Load some parameters. original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") p1 = params.ParametersDAO().initFromFile(original, warnings=True) try: v1 = p1.getAttr("foo", default="bar") except params.ParametersException: return assert False
def test_get_help_2(): """ Test getting help with a parameter that does not exist. """ # Load some parameters. original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") p1 = params.ParametersDAO().initFromFile(original, warnings=True) try: v1 = p1.helpAttr("foo") except params.ParametersException: return assert False
def test_mspb_3(): """ Test (single) PSF measurement with drift. """ # Make test movie. im_max = 1000.0 n_pts = 10 x = 7.0 y = 11.0 drift_xy = numpy.random.uniform(size=(n_pts, 2)) psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif") with tifffile.TiffWriter(psf_movie) as tf: for i in range(n_pts): image = dg.drawGaussiansXY((20, 20), numpy.array([x + drift_xy[i][0]]), numpy.array([y + drift_xy[i][1]])) image = image * im_max tf.save(image.astype(numpy.float32)) # Parameters. p = params.ParametersDAO() p.changeAttr("camera_gain", 1.0) p.changeAttr("camera_offset", 0.0) # Frame reader. frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p) z_index = numpy.zeros(n_pts).astype(numpy.int) - 1 z_index[0] = 0 [psf0, samples] = mPSFUtils.measureSinglePSFBeads(frdr, z_index, 6, x + drift_xy[0][0], y + drift_xy[0][1], zoom=2) for i in range(1, n_pts): z_index = numpy.zeros(n_pts).astype(numpy.int) - 1 z_index[i] = 0 [psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr, z_index, 6, x, y, drift_xy=drift_xy, zoom=2) assert (numpy.max(numpy.abs(psf0 - psf) / numpy.max(psf)) < 0.05)
def test_fitz_c_4(): """ Test that tracks with wx, wy values that are not near the calibration curve are assigned z values less than z minimum. Their category remains unchanged as this is done in a separate step. """ # Load 3D parameters. settings = storm_analysis.getData("test/data/test_3d_3d.xml") parameters = params.ParametersDAO().initFromFile(settings) [wx_params, wy_params] = parameters.getWidthParams() [min_z, max_z] = parameters.getZRange() pixel_size = parameters.getAttr("pixel_size") # Calculate widths. z_vals = numpy.arange(-250.0, 251.0, 50) [sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals) # Create HDF5 file with these widths. track_length = numpy.ones(sx.size) track_length[:2] = 2 tracks = { "category": numpy.ones(sx.size, dtype=numpy.int32), "track_length": track_length, "x": numpy.zeros(sx.size), "xsigma": track_length * (sx / pixel_size + numpy.ones(sx.size)), "ysigma": track_length * (sy / pixel_size + numpy.ones(sx.size)) } h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5") storm_analysis.removeFile(h5_name) with saH5Py.SAH5Py(h5_name, is_existing=False) as h5: h5.setMovieInformation(256, 256, 10, "XYZZY") h5.setPixelSize(pixel_size) h5.addTracks(tracks) # Calculate Z values. fitzC.fitzTracks(h5_name, 1.5, wx_params, wy_params, min_z, max_z, 1.0e-3) # Check Z values. with saH5Py.SAH5Py(h5_name) as h5: for tracks in h5.tracksIterator(): assert (numpy.allclose(tracks["z"], min_z * numpy.ones(sx.size) - 1.0e-3)) assert (numpy.allclose(tracks["category"], numpy.ones(sx.size)))
def test_mspb_2(): """ Test (single) PSF measurement, no drift, recentering. The maximum relative difference is typically on the order of 2%. """ # Make test movie. im_max = 1000.0 x = 7.0 + numpy.random.uniform(size=10) y = 11.0 + numpy.random.uniform(size=10) psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif") with tifffile.TiffWriter(psf_movie) as tf: for i in range(x.size): image = dg.drawGaussiansXY((20, 20), numpy.array([x[i]]), numpy.array([y[i]])) image = image * im_max tf.save(image.astype(numpy.float32)) # Parameters. p = params.ParametersDAO() p.changeAttr("camera_gain", 1.0) p.changeAttr("camera_offset", 0.0) # Frame reader. frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p) z_index = numpy.zeros(x.size).astype(numpy.int) - 1 z_index[0] = 0 [psf0, samples] = mPSFUtils.measureSinglePSFBeads(frdr, z_index, 6, x[0], y[0], zoom=2) for i in range(1, x.size): z_index = numpy.zeros(x.size).astype(numpy.int) - 1 z_index[i] = 0 [psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr, z_index, 6, x[i], y[i], zoom=2) assert (numpy.max(numpy.abs(psf0 - psf) / numpy.max(psf)) < 0.05)
def test_std_analysis_1(): """ Test zCheck. """ # Load 3D parameters. settings = storm_analysis.getData("test/data/test_3d_3d.xml") parameters = params.ParametersDAO().initFromFile(settings) [min_z, max_z] = parameters.getZRange() assert (abs(min_z + 0.5) < 1.0e-6) assert (abs(max_z - 0.5) < 1.0e-6) # Create HDF5 file with localizations and tracks. zvals = numpy.arange(-1.0, 1.05, 0.2) peaks = { "category": numpy.ones(zvals.size, dtype=numpy.int32), "x": numpy.zeros(zvals.size), "z": zvals } h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5") storm_analysis.removeFile(h5_name) with saH5Py.SAH5Py(h5_name, is_existing=False) as h5: h5.setMovieInformation(256, 256, 10, "XYZZY") h5.addLocalizations(peaks, 1) h5.addTracks(peaks) # Run z check on the file. stdAnalysis.zCheck(h5_name, parameters) # Check track and localization categories. category = numpy.ones(zvals.size, dtype=numpy.int32) z_mask = (zvals < min_z) | (zvals > max_z) category[z_mask] = 9 with saH5Py.SAH5Py(h5_name) as h5: for fnum, locs in h5.localizationsIterator(fields=["category"]): assert (numpy.allclose(locs["category"], category)) for tracks in h5.tracksIterator(fields=["category"]): assert (numpy.allclose(tracks["category"], category))
def test_fitz_c_2(): """ Test that localizations with wx, wy values that are not near the calibration curve are assigned z values less than z minimum. """ # Load 3D parameters. settings = storm_analysis.getData("test/data/test_3d_3d.xml") parameters = params.ParametersDAO().initFromFile(settings) [wx_params, wy_params] = parameters.getWidthParams() [min_z, max_z] = parameters.getZRange() pixel_size = parameters.getAttr("pixel_size") # Calculate widths. z_vals = numpy.arange(-250.0, 251.0, 100) [sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals) # Create HDF5 file with these widths. peaks = { "x": numpy.zeros(sx.size), "xsigma": sx / pixel_size + numpy.ones(sx.size), "ysigma": sy / pixel_size + numpy.ones(sx.size) } h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5") storm_analysis.removeFile(h5_name) with saH5Py.SAH5Py(h5_name, is_existing=False) as h5: h5.setMovieInformation(256, 256, 10, "XYZZY") h5.setPixelSize(pixel_size) h5.addLocalizations(peaks, 1) # Calculate Z values. fitzC.fitzRaw(h5_name, 1.5, wx_params, wy_params, min_z, max_z, 1.0e-3) # Check Z values. with saH5Py.SAH5Py(h5_name) as h5: locs = h5.getLocalizationsInFrame(1) assert (numpy.allclose(locs["z"], min_z * numpy.ones(sx.size) - 1.0e-3))
def test_mspb_1(): """ Test (single) PSF measurement, no drift. """ # Make test movie. x = 7.2 y = 9.8 psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif") image = 1000.0 * dg.drawGaussiansXY( (20, 20), numpy.array([x]), numpy.array([y])) with tifffile.TiffWriter(psf_movie) as tf: for i in range(6): tf.save(image.astype(numpy.float32)) # Parameters. p = params.ParametersDAO() p.changeAttr("camera_gain", 1.0) p.changeAttr("camera_offset", 0.0) # Frame reader. frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p) z_index = numpy.array([0, 1, 2, 2, -1, -1]) [psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr, z_index, 6, x, y, zoom=2) assert (numpy.allclose(samples, numpy.array([1, 1, 2]))) for i in range(1, psf.shape[0]): assert (numpy.allclose(psf[0, :, :], psf[i, :, :] / samples[i])) if False: with tifffile.TiffWriter("psf.tif") as tf: for i in range(psf.shape[0]): tf.save(psf[i, :, :].astype(numpy.float32))
def test_3ddao_scmos_cal(): """ Test that scmos calibration data is initialized to 0.0. """ settings = storm_analysis.getData("test/data/test_3d_2d_fixed.xml") parameters = params.ParametersDAO().initFromFile(settings) # Create analysis object and reach deep into it.. find_fit = findPeaks.initFindAndFit(parameters) fitter = find_fit.peak_fitter mfitter = fitter.mfitter # Initialize with an image. image = numpy.ones((100, 100)) fitter.newImage(image) # Verify that the image is still all ones. resp = mfitter.getResidual() assert (numpy.max(resp - 1.0) < 1.0e-6) # Cleanup. fitter.cleanUp()
def analyze(movie_name, mlist_name, settings_name): # Load parameters. parameters = params.ParametersDAO().initFromFile(settings_name) # Check for possibly v1.0 parameters. if not parameters.hasAttr("background_sigma"): raise Exception("Parameter 'background_sigma' is missing. Version 1.0 parameters?") # Create finding and fitting object. finder = find_peaks.initFindAndFit(parameters) # Create object for reading (non sCMOS) camera frames. movie_ext = os.path.splitext(movie_name)[1] if movie_ext == '.nd2': frame_reader = FrameReaderStdNd2(movie_file = movie_name, parameters = parameters) else: frame_reader = analysisIO.FrameReaderStd(movie_file = movie_name, parameters = parameters) # Create movie reader (uses frame_reader). movie_reader = analysisIO.MovieReader(frame_reader = frame_reader, parameters = parameters) # Create localization file writer. data_writer = analysisIO.DataWriterHDF5(data_file = mlist_name, parameters = parameters, sa_type = '3D-DAOSTORM') # Run the analysis. std_analysis.standardAnalysis(finder, movie_reader, data_writer, parameters)
if (__name__ == "__main__"): import argparse import storm_analysis.sa_library.parameters as params parser = argparse.ArgumentParser(description = 'Z fitting given Wx, Wy calibration curves.') parser.add_argument('--bin', dest='mlist', type=str, required=True, help = "The name of the localizations file.") parser.add_argument('--xml', dest='settings', type=str, required=True, help = "The name of the settings xml file.") args = parser.parse_args() parameters = params.ParametersDAO().initFromFile(args.settings) [wx_params, wy_params] = parameters.getWidthParams() [min_z, max_z] = parameters.getZRange() fitz(args.mlist, parameters.getAttr("cutoff"), wx_params, wy_params, min_z, max_z, parameters.getAttr("z_step", 0.001))
def analyze(movie_name, mlist_name, settings_name): parameters = params.ParametersDAO().initFromFile(settings_name) finder = find_peaks.initFindAndFit(parameters) std_analysis.standardAnalysis(finder, movie_name, mlist_name, parameters)
def testingParameters(): """ Create a 3D-DAOSTORM parameters object. """ params = parameters.ParametersDAO() params.setAttr("max_frame", "int", -1) params.setAttr("start_frame", "int", -1) params.setAttr("background_sigma", "float", 8.0) params.setAttr("camera_gain", "float", settings.camera_gain) params.setAttr("camera_offset", "float", settings.camera_offset) params.setAttr("find_max_radius", "int", 5) params.setAttr("foreground_sigma", "float", 1.0) params.setAttr("iterations", "int", settings.iterations) params.setAttr("model", "string", settings.model) params.setAttr("pixel_size", "float", settings.pixel_size) params.setAttr("roi_size", "int", 9) params.setAttr("sigma", "float", 1.5) params.setAttr("threshold", "float", 6.0) # Don't do tracking. params.setAttr("descriptor", "string", "1") params.setAttr("radius", "float", "0") # Don't do drift-correction. params.setAttr("d_scale", "int", 2) params.setAttr("drift_correction", "int", 0) params.setAttr("frame_step", "int", 500) params.setAttr("z_correction", "int", 0) # Z fitting. # # These are nonsense values. We test either '2D' or '3D' mode # and check how will we do at fitting the localization widths. # params.setAttr("do_zfit", "int", 0) params.setAttr("cutoff", "float", 0.0) params.setAttr("max_z", "float", 0.5) params.setAttr("min_z", "float", -0.5) params.setAttr("z_value", "float", 0.0) params.setAttr("z_step", "float", 1.0) params.setAttr("wx_wo", "float", 300.0) params.setAttr("wx_c", "float", 150.0) params.setAttr("wx_d", "float", 400.0) params.setAttr("wxA", "float", 0.0) params.setAttr("wxB", "float", 0.0) params.setAttr("wxC", "float", 0.0) params.setAttr("wxD", "float", 0.0) params.setAttr("wy_wo", "float", 300.0) params.setAttr("wy_c", "float", -150.0) params.setAttr("wy_d", "float", 400.0) params.setAttr("wyA", "float", 0.0) params.setAttr("wyB", "float", 0.0) params.setAttr("wyC", "float", 0.0) params.setAttr("wyD", "float", 0.0) # File conversion testing. #params.setAttr("convert_to", "string", ".bin,.txt") #params.setAttr("convert_to", "string", ".bin") #params.setAttr("convert_to", "string", ".txt") # 'peak_locations' testing. if hasattr(settings, "peak_locations") and (settings.peak_locations is not None): params.setAttr("peak_locations", "filename", settings.peak_locations) return params