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)
