def initFindAndFit(parameters): """ Initialize and return a SplinerFinderFitter object. """ # Create spline object. spline_fn = splineToPSF.loadSpline(parameters.getAttr("spline")) # Create peak finder. finder = fitting.PeakFinderArbitraryPSF(parameters=parameters, psf_object=spline_fn) # Create cubicFitC.CSplineFit object. mfitter = initFitter(finder, parameters, spline_fn) # Create peak fitter. fitter = fitting.PeakFitterArbitraryPSF(mfitter=mfitter, parameters=parameters) # Specify which properties we want from the analysis. properties = [ "background", "error", "height", "iterations", "significance", "sum", "x", "y", "z" ] return fitting.PeakFinderFitter(peak_finder=finder, peak_fitter=fitter, properties=properties)
def initFindAndFit(parameters): """ Initialize and return a PSFFFTFinderFitter object. """ # Create psf fft function object. psf_fn = psfFn.PSFFn(psf_filename=parameters.getAttr("psf")) # Check that the PSF FFT and camera pixel sizes agree. diff = abs( parameters.getAttr("pixel_size") - psf_fn.getPixelSize() * 1.0e3) assert (diff < 1.0e-6), "Wrong pixel size, incorrect PSF data?" # Create peak finder. finder = fitting.PeakFinderArbitraryPSF(parameters=parameters, psf_object=psf_fn) # Create fftFitC.CFFTFit object. mfitter = initFitter(finder, parameters, psf_fn) # Create peak fitter. fitter = fitting.PeakFitterArbitraryPSF(mfitter=mfitter, parameters=parameters) # Specify which properties we want from the analysis. properties = [ "background", "error", "height", "iterations", "significance", "sum", "x", "y", "z" ] return fitting.PeakFinderFitter(peak_finder=finder, peak_fitter=fitter, properties=properties)
def initFindAndFit(parameters): """ Initialize and return a fitting.PeakFinderFitter object. """ # Create pupil function object. [min_z, max_z] = parameters.getZRange() pupil_fn = pupilFn.PupilFunction(pf_filename = parameters.getAttr("pupil_function"), zmin = min_z * 1.0e+3, zmax = max_z * 1.0e+3) # PSF debugging. if False: tifffile.imsave("pupil_fn_psf.tif", pupil_fn.getPSF(0.1).astype(numpy.float32)) # Check that the PF and camera pixel sizes agree. diff = abs(parameters.getAttr("pixel_size") - pupil_fn.getPixelSize()*1.0e3) assert (diff < 1.0e-6), "Incorrect pupil function?" # Create peak finder. finder = fitting.PeakFinderArbitraryPSF(parameters = parameters, psf_object = pupil_fn) # Create cubicFitC.CSplineFit object. mfitter = initFitter(finder, parameters, pupil_fn) # Create peak fitter. fitter = fitting.PeakFitterArbitraryPSF(mfitter = mfitter, parameters = parameters) # Specify which properties we want from the analysis. properties = ["background", "error", "height", "iterations", "significance", "sum", "x", "y", "z"] return fitting.PeakFinderFitter(peak_finder = finder, peak_fitter = fitter, properties = properties)
def initFindAndFit(parameters): """ Return the appropriate type of finder and fitter. """ fmodel = parameters.getAttr("model") # Create peak finder. finder = fitting.PeakFinderGaussian(parameters = parameters) # Initialize Z fitting parameters. wx_params = None wy_params = None min_z = None max_z = None if (parameters.getAttr("model", "na") == "Z"): [wx_params, wy_params] = parameters.getWidthParams(for_mu_Zfit = True) [min_z, max_z] = parameters.getZRange() # Check for camera calibration (this function is also used by sCMOS analysis). rqe = None variance = None if parameters.hasAttr("camera_calibration"): # Load variance, scale by gain. # # Offset is in units of ADU. # Variance is in units of ADU*ADU. # Gain is ADU/photo-electron. # RQE is dimensionless, it should be around 1.0. # [offset, variance, gain, rqe] = analysisIO.loadCMOSCalibration(parameters.getAttr("camera_calibration")) variance = variance/(gain*gain) # Set variance in the peak finder, this method also pads the # variance to the correct size. variance = finder.setVariance(variance) # Pad relative quantum efficiency array to the correct size. rqe = finder.padArray(rqe) # Create C fitter object. kwds = {'roi_size' : finder.getROISize(), 'als_fit' : (parameters.getAttr("anscombe", 0) != 0), 'rqe' : rqe, 'scmos_cal' : variance, 'wx_params' : wx_params, 'wy_params' : wy_params, 'min_z' : min_z, 'max_z' : max_z} if (fmodel == '2dfixed'): mfitter = daoFitC.MultiFitter2DFixed(**kwds) elif (fmodel == '2d'): sigma = parameters.getAttr("sigma") kwds['sigma_range'] = [0.5 * sigma, 5.0 * sigma] mfitter = daoFitC.MultiFitter2D(**kwds) elif (fmodel == '3d'): sigma = parameters.getAttr("sigma") kwds['sigma_range'] = [0.5 * sigma, 5.0 * sigma] mfitter = daoFitC.MultiFitter3D(**kwds) elif (fmodel == 'Z'): mfitter = daoFitC.MultiFitterZ(**kwds) else: raise Exception("Unknown fitting model " + fmodel) # Create peak fitter. fitter = fitting.PeakFitter(mfitter = mfitter, parameters = parameters) # Specify which properties we want from the analysis. properties = ["background", "error", "height", "iterations", "significance", "sum", "x", "y"] if (fmodel == "2dfixed") or (fmodel == "2d"): properties.append("xsigma") elif (fmodel == "3d"): properties.append("xsigma") properties.append("ysigma") elif (fmodel == "Z"): properties.append("xsigma") properties.append("ysigma") properties.append("z") return fitting.PeakFinderFitter(peak_finder = finder, peak_fitter = fitter, properties = properties)
def initFindAndFit(parameters): """ Return the appropriate type of finder and fitter. """ fmodel = parameters.getAttr("model") # Create peak finder. finder = fitting.PeakFinderGaussian(parameters=parameters) # Initialize Z fitting parameters. wx_params = None wy_params = None min_z = None max_z = None if (parameters.getAttr("model", "na") == "Z"): [wx_params, wy_params] = parameters.getWidthParams(for_mu_Zfit=True) [min_z, max_z] = parameters.getZRange() # Check for camera calibration (this function is also used by sCMOS analysis). variance = None if parameters.hasAttr("camera_calibration"): # Load variance, scale by gain. # # Variance is in units of ADU*ADU. # Gain is ADU/photo-electron. # [offset, variance, gain] = analysisIO.loadCMOSCalibration( parameters.getAttr("camera_calibration")) variance = variance / (gain * gain) # Set variance in the peak finder, this method also pads the # variance to the correct size. variance = finder.setVariance(variance) # Create C fitter object. fitters = { '2dfixed': daoFitC.MultiFitter2DFixed, '2d': daoFitC.MultiFitter2D, '3d': daoFitC.MultiFitter3D, 'Z': daoFitC.MultiFitterZ } mfitter = fitters[fmodel](roi_size=finder.getROISize(), scmos_cal=variance, wx_params=wx_params, wy_params=wy_params, min_z=min_z, max_z=max_z) # Create peak fitter. fitter = fitting.PeakFitter(mfitter=mfitter, parameters=parameters) # Specify which properties we want from the analysis. properties = [ "background", "error", "height", "iterations", "significance", "sum", "x", "y" ] if (fmodel == "2dfixed") or (fmodel == "2d"): properties.append("xsigma") elif (fmodel == "3d"): properties.append("xsigma") properties.append("ysigma") elif (fmodel == "Z"): properties.append("xsigma") properties.append("ysigma") properties.append("z") return fitting.PeakFinderFitter(peak_finder=finder, peak_fitter=fitter, properties=properties)