return (f_gauss2d(params, X, Y), X[0], Y[0], 0)
#so that fit tasks know which class to use
FitFactory = GaussianFitFactory
#FitResult = GaussianFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
#this means that factory is reponsible for it's own object finding and implements
#a GetAllResults method that returns a list of localisations
MULTIFIT = True
import PYME.localization.MetaDataEdit as mde
#from PYME.localization.FitFactories import Interpolators
#from PYME.localization.FitFactories import zEstimators
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','LinearInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
#mde.FilenameParam('PSFFilename', 'PSF:', prompt='Please select PSF to use ...', wildcard='PSF Files|*.psf'),
#mde.ShiftFieldParam('chroma.ShiftFilename', 'Shifts:', prompt='Please select shiftfield to use', wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
mde.FloatParam('Analysis.PSFSigma', u'PSF \u03c3 [nm]:', 130.),
mde.FloatParam('Analysis.ResidualMax', 'Max residual:', 0.25),
#mde.ChoiceParam('Analysis.EstimatorModule', 'Z Start Est:', 'astigEstimator', choices=zEstimators.estimatorList),
#mde.ChoiceParam('PRI.Axis', 'PRI Axis:', 'y', choices=['x', 'y'])
]
DESCRIPTION = '2D Gaussian multi-emitter fitting'
LONG_DESCRIPTION = '2D Gaussian multi-emitter fitting: Fits x, y and I, assuming background is already subtracted. Uses it\'s own object detection routine'
USE_FOR = '2D multi-emitter'
slicesUsed=(xslice, yslice, zslice),
subtractedBackground=bgm,
meanSquaredError=np.mean(infodict['fvec']**2))
@classmethod
def evalModel(cls, params, md, x=0, y=0, roiHalfSize=5):
"""Evaluate the model that this factory fits - given metadata and fitted parameters.
Used for fit visualisation"""
# generate grid to evaluate function on
vs = md.voxelsize_nm
X = vs.x * np.mgrid[(x - roiHalfSize):(x + roiHalfSize + 1)]
Y = vs.y * np.mgrid[(x - roiHalfSize):(x + roiHalfSize + 1)]
return 'FIXME' # (f_gaussAstigBead(params, X, Y, beadDiam), X[0], Y[0], 0)
# so that fit tasks know which class to use
FitFactory = GaussianFitFactory
FitResultsDType = fresultdtype # only defined if returning data as numarray
import PYME.localization.MetaDataEdit as mde
PARAMETERS = [
mde.IntParam('Analysis.ROISize', u'ROI half size', 7),
]
DESCRIPTION = 'Fitting astigmatic gaussian after convolution with bead shape'
LONG_DESCRIPTION = 'Fitting astigmatic gaussian after convolution with bead shape'
USE_FOR = '3D astigmatism calibrations'
X = vs.x * scipy.mgrid[(x - roiHalfSize):(x + roiHalfSize + 1)]
Y = vs.y * scipy.mgrid[(x - roiHalfSize):(x + roiHalfSize + 1)]
return (f_gauss2d(params, X, Y), X[0], Y[0], 0)
#so that fit tasks know which class to use
FitFactory = GaussianFitFactory
FitResult = GaussianFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
#this means that factory is reponsible for it's own object finding and implements
#a GetAllResults method that returns a list of localisations
MULTIFIT = True
import PYME.localization.MetaDataEdit as mde
#from PYME.localization.FitFactories import Interpolators
#from PYME.localization.FitFactories import zEstimators
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','LinearInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
#mde.FilenameParam('PSFFilename', 'PSF:', prompt='Please select PSF to use ...', wildcard='PSF Files|*.psf'),
mde.ShiftFieldParam('chroma.ShiftFilename',
'Shifts:',
prompt='Please select shiftfield to use',
wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
#mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', 0),
#mde.ChoiceParam('Analysis.EstimatorModule', 'Z Start Est:', 'astigEstimator', choices=zEstimators.estimatorList),
#mde.ChoiceParam('PRI.Axis', 'PRI Axis:', 'y', choices=['x', 'y'])
]
#return PSFFitResultR(res, self.metadata, numpy.array((sig_xl, sig_xr, sig_yu, sig_yd)),(xslice, yslice, zslice), resCode, fitErrors, numpy.array(startParameters), nchi2)
return PSFFitResultR(res1, self.metadata,
(xslice, yslice, zslice), resCode1, fitErrors,
np.array(startParameters1), nchi21)
#so that fit tasks know which class to use
FitFactory = WFPSFFitFactory
FitResult = PSFFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
import PYME.localization.MetaDataEdit as mde
from PYME.localization.FitFactories import Interpolators
#from PYME.localization.FitFactories import zEstimators
#set of parameters that this fit needs to know about
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','CSInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
mde.FilenameParam('PSFFile',
'PSF:',
prompt='Please select PSF to use ...',
wildcard='PSF Files|*.psf|TIFF files|*.tif'),
#mde.ShiftFieldParam('chroma.ShiftFilename', 'Shifts:', prompt='Please select shiftfield to use', wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
#mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', 0),
#mde.ChoiceParam('Analysis.EstimatorModule', 'Z Start Est:', 'astigEstimator', choices=zEstimators.estimatorList),
#mde.ChoiceParam('PRI.Axis', 'PRI Axis:', 'y', choices=['x', 'y'])
]
DESCRIPTION = 'EXP. 3D, single colour fitting for widefield PSF.'
LONG_DESCRIPTION = 'Experimental 3D, single colour fitting optimized for widefield PSF. Attempts to work around the symmetry problem by starting the fit both above and below the focus, and seeing which converges to the better fit. Uses an interpolated experimental PSF like the other Interp fits. Unlikely to work very well unless there are significant abberations (e.g. S.A.) in the PSF.'
class AnalysisSettingsView(object):
FINDING_PARAMS = [
mde.FloatParam('Analysis.DetectionThreshold', 'Thresh:', 1.0),
mde.IntParam('Analysis.DebounceRadius', 'Debounce rad:', 4),
]
DEFAULT_PARAMS = [
mde.IntParam('Analysis.StartAt', 'Start at:', default=30),
mde.ParamGroup('Background Subtraction', [
mde.RangeParam('Analysis.BGRange', 'Background:',
default=(-30, 0)),
mde.BoolParam('Analysis.subtractBackground',
'Subtract background in fit',
default=True),
mde.BoolFloatParam('Analysis.PCTBackground',
'Use percentile for background',
default=False,
helpText='',
ondefault=0.25,
offvalue=0),
],
folded=False),
mde.ParamGroup('sCMOS camera noise maps', [
mde.FilenameParam('Camera.VarianceMapID',
'Variance Map:',
prompt='Please select variance map to use ...',
wildcard=MAP_WILDCARDS,
filename=''),
mde.FilenameParam('Camera.DarkMapID',
'Dark Map:',
prompt='Please select dark map to use ...',
wildcard=MAP_WILDCARDS,
filename=''),
mde.FilenameParam('Camera.FlatfieldMapID',
'Flatfield Map:',
prompt='Please select flatfield map to use ...',
wildcard=MAP_WILDCARDS,
filename=''),
]),
mde.ParamGroup('Fiducial based drift tracking', [
mde.BoolParam(
'Analysis.TrackFiducials', 'Track Fiducials', default=False),
mde.FloatParam('Analysis.FiducialThreshold',
'Fiducial Threshold',
default=1.8),
mde.IntParam(
'Analysis.FiducialROISize', 'Fiducial ROI', default=11),
mde.FloatParam('Analysis.FiducialSize',
'Fiducial Diameter [nm]',
default=1000.),
]),
]
def __init__(self, dsviewer, analysisController, lmanal=None):
self.foldAnalPanes = False
self.analysisController = analysisController
self.analysisMDH = analysisController.analysisMDH
self.lmanal = lmanal
dsviewer.paneHooks.append(self.GenPointFindingPanel)
dsviewer.paneHooks.append(self.GenAnalysisPanel)
self.analysisController.onMetaDataChange.connect(
self.on_metadata_change)
def _populateStdOptionsPanel(self, pan, vsizer):
for param in self.DEFAULT_PARAMS:
pg = param.createGUI(
pan,
self.analysisMDH,
syncMdh=True,
mdhChangedSignal=self.analysisController.onMetaDataChange)
vsizer.Add(pg, 0, wx.BOTTOM | wx.EXPAND, 5)
vsizer.Fit(pan)
def _populateFindOptionsPanel(self, pan, vsizer):
for param in self.FINDING_PARAMS:
pg = param.createGUI(
pan,
self.analysisMDH,
syncMdh=True,
mdhChangedSignal=self.analysisController.onMetaDataChange)
vsizer.Add(pg, 0, wx.BOTTOM | wx.EXPAND, 5)
def _populateCustomAnalysisPanel(self, pan, vsizer):
try:
fitMod = self.fitFactories[self.cFitType.GetSelection()]
fm = __import__('PYME.localization.FitFactories.' + fitMod,
fromlist=['PYME', 'localization', 'FitFactories'])
#vsizer = wx.BoxSizer(wx.VERTICAL)
for param in fm.PARAMETERS:
pg = param.createGUI(
pan,
self.analysisMDH,
syncMdh=True,
mdhChangedSignal=self.analysisController.onMetaDataChange)
vsizer.Add(pg, 0, wx.BOTTOM | wx.EXPAND, 5)
vsizer.Fit(pan)
except AttributeError:
pass
def on_metadata_change(self, *args, **kwargs):
fit_module = self.analysisMDH.getOrDefault('Analysis.FitModule',
'LatGaussFitFR')
if not fit_module == self.fitFactories[self.cFitType.GetSelection()]:
self.cFitType.SetSelection(self.fitFactories.index(fit_module))
self.OnFitModuleChanged(None)
def OnFitModuleChanged(self, event):
self.customOptionsSizer.Clear(True)
self._populateCustomAnalysisPanel(self.customOptionsPan,
self.customOptionsSizer)
self.customOptionsPan.GetTopLevelParent().OnSize(None)
self.analysisMDH['Analysis.FitModule'] = self.fitFactories[
self.cFitType.GetSelection()]
def GenAnalysisPanel(self, _pnl):
item = afp.foldingPane(_pnl,
-1,
caption="Analysis",
pinned=not (self.foldAnalPanes))
#############################
#std options
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
pan.SetSizer(vsizer)
self._populateStdOptionsPanel(pan, vsizer)
item.AddNewElement(pan)
#######################
#Fit factory selection
pan = wx.Panel(item, -1)
#find out what fit factories we have
self.fitFactories = PYME.localization.FitFactories.resFitFactories
print((self.fitFactories))
vsizer = wx.BoxSizer(wx.VERTICAL)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(pan, -1, 'Type:'), 0,
wx.RIGHT | wx.ALIGN_CENTER_VERTICAL, 5)
self.cFitType = wx.Choice(
pan,
-1,
choices=[
'{:<35} \t- {:} '.format(
f, PYME.localization.FitFactories.useFor[f])
for f in self.fitFactories
],
size=(110, -1))
if 'Analysis.FitModule' in self.analysisMDH.getEntryNames():
#has already been analysed - most likely to want the same method again
try:
self.cFitType.SetSelection(
self.fitFactories.index(
self.analysisMDH['Analysis.FitModule']))
#self.tThreshold.SetValue('%s' % self.image.mdh.getOrDefault('Analysis.DetectionThreshold', 1))
except ValueError:
self.cFitType.SetSelection(
self.fitFactories.index('LatGaussFitFR'))
#elif 'Camera.ROIPosY' in self.image.mdh.getEntryNames() and (self.image.mdh.getEntry('Camera.ROIHeight') + 1 + 2*(self.image.mdh.getEntry('Camera.ROIPosY')-1)) == 512:
# #we have a symetrical ROI about the centre - most likely want to analyse using splitter
# self.cFitType.SetSelection(self.fitFactories.index('SplitterFitQR'))
# self.tThreshold.SetValue('0.5')
else:
self.cFitType.SetSelection(
self.fitFactories.index('LatGaussFitFR'))
self.analysisMDH['Analysis.FitModule'] = 'LatGaussFitFR'
self.cFitType.Bind(wx.EVT_CHOICE, self.OnFitModuleChanged)
hsizer.Add(self.cFitType, 1, wx.ALIGN_CENTER_VERTICAL, 0)
vsizer.Add(hsizer, 0, wx.BOTTOM | wx.EXPAND, 2)
pan.SetSizer(vsizer)
vsizer.Fit(pan)
item.AddNewElement(pan)
########################################
#custom (fit factory dependant) options
self.customOptionsPan = wx.Panel(item, -1)
self.customOptionsSizer = wx.BoxSizer(wx.VERTICAL)
self.customOptionsPan.SetSizer(self.customOptionsSizer)
self._populateCustomAnalysisPanel(self.customOptionsPan,
self.customOptionsSizer)
item.AddNewElement(self.customOptionsPan)
######################
#Go
if self.lmanal:
self.bGo = wx.Button(item, -1, 'Go')
self.bGo.Bind(wx.EVT_BUTTON, lambda e: self.lmanal.OnGo(e))
item.AddNewElement(self.bGo)
_pnl.AddPane(item)
self.analysisPanel = item
def GenPointFindingPanel(self, _pnl):
item = afp.foldingPane(_pnl,
-1,
caption="Point Finding",
pinned=not (self.foldAnalPanes))
pan = wx.Panel(item, -1)
vsizer = wx.BoxSizer(wx.VERTICAL)
#load point finding settings
self._populateFindOptionsPanel(pan, vsizer)
if not self.lmanal is None:
hsizer = wx.BoxSizer(wx.HORIZONTAL)
#bTest = wx.Button(pan, -1, 'Test', style=wx.BU_EXACTFIT)
#bTest.Bind(wx.EVT_BUTTON, lambda e : self.lmanal.Test())
#hsizer.Add(bTest, 0,wx.LEFT|wx.ALIGN_CENTER_VERTICAL, 5)
bTestF = wx.Button(pan,
-1,
'Test This Frame',
style=wx.BU_EXACTFIT)
bTestF.Bind(wx.EVT_BUTTON, lambda e: self.lmanal.OnTestFrame(e))
hsizer.Add(bTestF, 0, wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 5)
vsizer.Add(hsizer, 0, wx.BOTTOM | wx.EXPAND, 2)
pan.SetSizerAndFit(vsizer)
item.AddNewElement(pan)
_pnl.AddPane(item)
(xslice, yslice, zslice), resCode, fitErrors,
numpy.array(startParameters), nchi2)
#so that fit tasks know which class to use
FitFactory = PSFFitFactory
FitResult = PSFFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
import PYME.localization.MetaDataEdit as mde
from PYME.localization.FitFactories import Interpolators
from PYME.localization.FitFactories import zEstimators
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','CSInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
mde.FilenameParam('PSFFile',
'PSF:',
prompt='Please select PSF to use ...',
wildcard='PSF Files|*.psf|TIFF files|*.tif'),
mde.ShiftFieldParam('chroma.ShiftFilename',
'Shifts:',
prompt='Please select shiftfield to use',
wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', 0),
mde.ChoiceParam('Analysis.EstimatorModule',
'Z Start Est:',
'astigEstimator',
choices=zEstimators.estimatorList),
mde.ChoiceParam('PRI.Axis',
'PRI Axis:',
'none',
choices=['x', 'y', 'none']),
bgROI.mean(0).mean(0), ratio)
#return PSFFitResultR(res, self.metadata, , resCode, fitErrors, numpy.array(startParameters), nchi2)
#so that fit tasks know which class to use
FitFactory = InterpFitFactory
FitResult = PSFFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
import PYME.localization.MetaDataEdit as mde
from PYME.localization.FitFactories import Interpolators
from PYME.localization.FitFactories import zEstimators
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','CSInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
mde.FilenameParam('PSFFile',
'PSF:',
prompt='Please select PSF to use ...',
wildcard='PSF Files|*.psf|TIFF files|*.tif'),
mde.ShiftFieldParam('chroma.ShiftFilename',
'Shifts:',
prompt='Please select shiftfield to use',
wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', -270),
mde.ChoiceParam('Analysis.EstimatorModule',
'Z Start Est:',
'biplaneEstimator',
choices=zEstimators.estimatorList),
mde.ChoiceParam('PRI.Axis',
'PRI Axis:',
'none',
choices=['x', 'y', 'none']),
X = 1e3 * md.voxelsize.x * np.mgrid[(x - roiHalfSize):
(x + roiHalfSize + 1)]
Y = 1e3 * md.voxelsize.y * np.mgrid[(y - roiHalfSize):
(y + roiHalfSize + 1)]
return (astigmatic_gaussian(params, X, Y), X[0], Y[0], 0)
# so that fit tasks know which class to use
FitFactory = GaussianFitFactory
#FitResult = GaussianFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
GPU_PREFIT = True # fit factory does its own prefit steps on the GPU
import PYME.localization.MetaDataEdit as mde
PARAMETERS = [
mde.FloatParam('Analysis.ROISize', u'ROI half size', 7.5),
mde.BoolParam('Analysis.GPUPCTBackground',
'Calculate percentile background on GPU', True),
mde.IntParam(
'Analysis.DetectionFilterSize', 'Detection Filter Size:', 4,
'Filter size used for point detection; units of pixels. Should be slightly less than the PSF FWHM'
),
]
DESCRIPTION = 'Astigmatic Gaussian fitting performed at warp-speed on the GPU'
LONG_DESCRIPTION = 'Astigmatic Gaussian fitting on the GPU: Fits astigmatic gaussian with sCMOS noise model. Uses it\'s own object detection routine'
USE_FOR = '3D via Astigmatism, with sCMOS noise model'
class AnalysisDetailsPanel(wx.Panel):
DEFAULT_PARAMS = [mde.FloatParam('Analysis.DetectionThreshold', 'Thresh:', 1.0),
mde.IntParam('Analysis.DebounceRadius', 'Debounce rad:', 4),
mde.IntParam('Analysis.StartAt', 'Start at:', default=30),
mde.RangeParam('Analysis.BGRange', 'Background:', default=(-30,0)),
mde.BoolParam('Analysis.subtractBackground', 'Subtract background in fit', default=True),
mde.BoolFloatParam('Analysis.PCTBackground' , 'Use percentile for background', default=False, helpText='', ondefault=0.25, offvalue=0),
#mde.FilenameParam('Camera.VarianceMapID', 'Variance Map:', prompt='Please select variance map to use ...', wildcard='TIFF Files|*.tif', filename=''),
#mde.FilenameParam('Camera.DarkMapID', 'Dark Map:', prompt='Please select dark map to use ...', wildcard='TIFF Files|*.tif', filename=''),
#mde.FilenameParam('Camera.FlatfieldMapID', 'Flatfield Map:', prompt='Please select flatfield map to use ...', wildcard='TIFF Files|*.tif', filename=''),
mde.BoolParam('Analysis.TrackFiducials', 'Track Fiducials', default=False),
mde.FloatParam('Analysis.FiducialThreshold', 'Fiducial Threshold', default=1.8),
]
def __init__(self, parent, analysisSettings, mdhChangedSignal=None):
wx.Panel.__init__(self, parent, -1)
self.analysisSettings = analysisSettings
self.analysisMDH = analysisSettings.analysisMDH
self.mdhChangedSignal = mdhChangedSignal
mdhChangedSignal.connect(self.OnMDChanged)
self._analysisModule = ''
vsizer = wx.BoxSizer(wx.VERTICAL)
vsizer_std = wx.BoxSizer(wx.VERTICAL)
self._populateStdOptionsPanel(self, vsizer_std)
vsizer.Add(vsizer_std, 0, wx.EXPAND, 0)
self.customOptionsSizer = wx.BoxSizer(wx.VERTICAL)
self._populateCustomAnalysisPanel(self, self.customOptionsSizer)
vsizer.Add(self.customOptionsSizer, 0, wx.EXPAND, 0)
self.SetSizerAndFit(vsizer)
def _populateStdOptionsPanel(self, pan, vsizer):
for param in self.DEFAULT_PARAMS:
pg = param.createGUI(pan, self.analysisMDH, syncMdh=True,
mdhChangedSignal = self.mdhChangedSignal)
vsizer.Add(pg, 0,wx.BOTTOM|wx.EXPAND, 5)
vsizer.Fit(pan)
def _populateCustomAnalysisPanel(self, pan, vsizer):
try:
#fitMod = self.fitFactories[self.cFitType.GetSelection()]
self._analysisModule = self.analysisMDH['Analysis.FitModule']
fm = __import__('PYME.localization.FitFactories.' + self._analysisModule, fromlist=['PYME', 'localization', 'FitFactories'])
#vsizer = wx.BoxSizer(wx.VERTICAL)
for param in fm.PARAMETERS:
pg = param.createGUI(pan, self.analysisMDH, syncMdh=True,
mdhChangedSignal = self.mdhChangedSignal)
vsizer.Add(pg, 0,wx.BOTTOM|wx.EXPAND, 5)
vsizer.Fit(pan)
self.Layout()
self.SetMinSize([200, self.GetBestSize()[1]])
self.GetParent().Layout()
print('custom analysis settings populated')
except (KeyError, AttributeError):
pass
def OnMDChanged(self, event=None, sender=None, signal=None, mdh=None):
if not self._analysisModule == self.analysisMDH['Analysis.FitModule']:
self.customOptionsSizer.Clear(True)
self._populateCustomAnalysisPanel(self, self.customOptionsSizer)
# FIXME - can't figure out a better way to redo the vertical sizer for longer menus
self.GetParent().fold1(self)
self.GetParent().fold1(self)
import logging
import django.forms
from django.http import HttpResponseRedirect
from django.shortcuts import render
logger = logging.getLogger(__name__)
import collections
from PYME.localization import MetaDataEdit as mde
#from PYME.cluster import HTTPTaskPusher
from PYME.cluster import HTTPRulePusher, HTTPTaskPusher
FINDING_PARAMS = [ #mde.ChoiceParam('Analysis.FitModule', 'Fit module:', default='LatGaussFitFR', choices=PYME.localization.FitFactories.resFitFactories),
mde.FloatParam('Analysis.DetectionThreshold', 'Detection threshold:', 1.0),
mde.IntParam('Analysis.DebounceRadius', 'Debounce radius:', 4),
mde.IntParam('Analysis.StartAt', 'Start at:', default=30),
]
BACKGROUND_PARAMS = [ #mde.IntParam('Analysis.StartAt', 'Start at:', default=30),
mde.RangeParam('Analysis.BGRange', 'Background range:', default=[-30, 0]),
mde.BoolParam('Analysis.subtractBackground',
'Subtract background in fit',
default=True),
mde.BoolFloatParam('Analysis.PCTBackground',
'Use percentile for background',
default=False,
helpText='',
ondefault=0.25,
offvalue=0),
]
np.array(startParameters), nchi2, np.mean(bgMean))
#so that fit tasks know which class to use
FitFactory = PSFFitFactory
FitResult = PSFFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
import PYME.localization.MetaDataEdit as mde
from PYME.localization.FitFactories import Interpolators
from PYME.localization.FitFactories import zEstimators
#set of parameters that this fit needs to know about
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','CSInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
mde.FilenameParam('PSFFile',
'PSF:',
prompt='Please select PSF to use ...',
wildcard='PSF Files|*.psf|TIFF files|*.tif'),
#mde.ShiftFieldParam('chroma.ShiftFilename', 'Shifts:', prompt='Please select shiftfield to use', wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
#mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', 0),
mde.ChoiceParam('Analysis.EstimatorModule',
'Z Start Est:',
'astigEstimator',
choices=zEstimators.estimatorList),
mde.ChoiceParam('PRI.Axis',
'PRI Axis:',
'none',
choices=['x', 'y', 'none']),
mde.BoolParam('Analysis.FitBackground', 'Fit Background', True),
]
#print res, fitErrors, resCode
#return PSFFitResultR(res, self.metadata, numpy.array((sig_xl, sig_xr, sig_yu, sig_yd)),(xslice, yslice, zslice), resCode, fitErrors, numpy.array(startParameters), nchi2)
return PSFFitResultR(res, self.metadata,
(xslice, yslice, zslice), resCode, fitErrors,
numpy.array(startParameters), nchi2)
#so that fit tasks know which class to use
FitFactory = PSFFitFactory
FitResult = PSFFitResultR
FitResultsDType = fresultdtype #only defined if returning data as numarray
PARAMETERS = [ #mde.ChoiceParam('Analysis.InterpModule','Interp:','CSInterpolator', choices=Interpolators.interpolatorList, choiceNames=Interpolators.interpolatorDisplayList),
mde.FilenameParam('PSFFile',
'PSF:',
prompt='Please select PSF to use ...',
wildcard='PSF Files|*.psf'),
#mde.ShiftFieldParam('chroma.ShiftFilename', 'Shifts:', prompt='Please select shiftfield to use', wildcard='Shiftfields|*.sf'),
#mde.IntParam('Analysis.DebounceRadius', 'Debounce r:', 4),
#mde.FloatParam('Analysis.AxialShift', 'Z Shift [nm]:', 0),
mde.ChoiceParam('Analysis.EstimatorModule',
'Z Start Est:',
'astigEstimator',
choices=zEstimators.estimatorList),
mde.ChoiceParam('PRI.Axis', 'PRI Axis:', 'y', choices=['x', 'y'])
]
DESCRIPTION = '3D fitting for the PRI PSF with variable lobe heights.'
LONG_DESCRIPTION = '3D fitting for the PRI PSF with variable lobe heights. A special version of InterpFit which allows us to measure the realative strength of the two PRI lobes. Assumes background subtracted. Fairly specialised use cases - unless you know you need it use InterpFitR instead.'
