python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/localization/FitFactories/BeadConvolvedAstigGaussFit.py

@@ -0,0 +1,206 @@
+# Copyright David Baddeley, Andrew Barentine, 2017
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import numpy as np
+from .fitCommon import fmtSlicesUsed, pack_results
+from . import FFBase
+from PYME.Analysis._fithelpers import FitModelWeighted
+from scipy.signal import convolve2d
+
+
+##--------------------------------------------------------------------------------------------------------------------##
+#  Model functions
+
+# define factor by which to interpolate grid for evaluating numerical convolutions. Note the data is never interpolated
+INTERP_FACTOR = 5
+
+def bead(X, Y, beadDiam):
+    """
+    returns a sum-normalized bead projection
+    """
+    x0, y0 = np.mean(X), np.mean(Y)
+    beadRad = 0.5*beadDiam
+    beadProj = np.nan_to_num(np.sqrt(beadRad**2 - (X[:,None] - x0)**2 - (Y[None, :] - y0)**2))
+    # return normalized bead projection
+    return (1/np.sum(beadProj))*beadProj
+
+def f_gaussAstigBead(p, X, Y, beadDiam):
+    """
+    astigmatic Gaussian model function with linear background (parameter vector [A, x0, y0, sx, sy, b, b_x, b_y])
+    convolved with a bead shape
+    """
+    A, x0, y0, sx, sy, c, b_x, b_y = p
+
+    # interpolate, as the bead diameter will usually be roughly the size of a pixel
+    step = (X[1]-X[0])/float(INTERP_FACTOR)  # NB this assumes X and Y spacing is equal, i.e. square pixels
+    xx = np.arange(X[0] - INTERP_FACTOR*step, X[-1] + (INTERP_FACTOR + 1)*step, step)
+    yy = np.arange(Y[0] - INTERP_FACTOR*step, Y[-1] + (INTERP_FACTOR + 1)*step, step)
+
+    gauss = A * np.exp(-(xx[:, None] - x0) ** 2 / (2 * sx ** 2) - (yy[None, :] - y0) ** 2 / (2 * sy ** 2)) + c + b_x * xx[:,None] + b_y * yy[None,:]
+    # how many steps to include beadDiam
+    ns = np.ceil(beadDiam/step).astype(int) + 1
+    beadProj = bead(xx[:2*ns], yy[:2*ns], beadDiam)
+
+    model = convolve2d(gauss, beadProj, mode='same')
+
+    return model[INTERP_FACTOR:-INTERP_FACTOR:INTERP_FACTOR, INTERP_FACTOR:-INTERP_FACTOR:INTERP_FACTOR]
+
+def f_rotGaussAstigBead(p, X, Y, beadDiam, theta = 0):
+    """
+    astigmatic Gaussian model function with linear background (parameter vector [A, x0, y0, sx, sy, b, b_x, b_y])
+    rotated by theta radians and convolved with a bead shape.
+    """
+    A, x0, y0, sx, sy, c, b_x, b_y = p
+
+    # interpolate, as the bead diameter will usually be roughly the size of a pixel
+    step = (X[1]-X[0])/float(INTERP_FACTOR)  # NB this assumes X and Y spacing is equal, i.e. square pixels
+    xx = np.arange(X[0] - INTERP_FACTOR*step, X[-1] + (INTERP_FACTOR + 1)*step, step)
+    yy = np.arange(Y[0] - INTERP_FACTOR*step, Y[-1] + (INTERP_FACTOR + 1)*step, step)
+
+    #gauss = A * np.exp(-(xx[:, None] - x0) ** 2 / (2 * sx ** 2) - (yy[None, :] - y0) ** 2 / (2 * sy ** 2)) + c + b_x * xx[:,None] + b_y * yy[None,:]
+    alpha = (np.cos(theta)**2)/(2*sx**2) + (np.sin(theta)**2)/(2*sy**2)
+    beta = -np.sin(2*theta)/(4*sx**2) + np.sin(2*theta)/(4*sy**2)
+    charlie = (np.sin(theta)**2)/(2*sx**2) + (np.cos(theta)**2)/(2*sy**2)
+    rotGauss = A * np.exp(-(alpha*(xx[:, None] - x0)**2 - 2*beta*(xx[:, None] - x0)*(yy[None, :] - y0) + charlie*(yy[None, :] - y0)**2))
+    # how many steps to include beadDiam
+    ns = np.ceil(beadDiam/step) + 1
+    beadProj = bead(xx[:2*ns], yy[:2*ns], beadDiam)
+
+    model = convolve2d(rotGauss, beadProj, mode='same')
+
+    return model[INTERP_FACTOR:-INTERP_FACTOR:INTERP_FACTOR, INTERP_FACTOR:-INTERP_FACTOR:INTERP_FACTOR]
+
+
+
+
+
+##--------------------------------------------------------------------------------------------------------------------##
+# define the data type we're going to return
+fresultdtype = [('tIndex', '<i4'),
+                ('fitResults', [('A', '<f4'),
+                                ('x0', '<f4'), ('y0', '<f4'),
+                                ('sigmax', '<f4'),
+                                ('sigmay', '<f4'),
+                                ('background', '<f4'),
+                                ('bx', '<f4'),
+                                ('by', '<f4')]),
+                ('fitError', [('A', '<f4'),
+                              ('x0', '<f4'),
+                              ('y0', '<f4'),
+                              ('sigmax', '<f4'),
+                              ('sigmay', '<f4'),
+                              ('background', '<f4'),
+                              ('bx', '<f4'),
+                              ('by', '<f4')]),
+                ('startParams', [('A', '<f4'),
+                                 ('x0', '<f4'),
+                                 ('y0', '<f4'),
+                                 ('sigmax', '<f4'),
+                                 ('sigmay', '<f4'),
+                                 ('background', '<f4'),
+                                 ('bx', '<f4'),
+                                 ('by', '<f4')]),
+                ('resultCode', '<i4'),
+                ('slicesUsed', [('x', [('start', '<i4'), ('stop', '<i4'), ('step', '<i4')]),
+                                ('y', [('start', '<i4'), ('stop', '<i4'), ('step', '<i4')]),
+                                ('z', [('start', '<i4'), ('stop', '<i4'), ('step', '<i4')])]),
+                ('subtractedBackground', '<f4'),
+                ('meanSquaredError', '<f4')
+                ]
+
+
+class GaussianFitFactory(FFBase.FitFactory):
+    def __init__(self, data, metadata, fitfcn=f_gaussAstigBead, background=None, noiseSigma=None, **kwargs):
+        """Create a fit factory which will operate on image data (data), potentially using voxel sizes etc contained in
+        metadata. """
+        FFBase.FitFactory.__init__(self, data, metadata, fitfcn, background, noiseSigma, **kwargs)
+
+        self.solver = FitModelWeighted
+        try:  # check if bead diameter is stored in the metadata
+            self.beadDiam = metadata['Bead.Diameter']  # Should be in [nm]
+        except KeyError:
+            try:  # check if a bead diameter has been injected in just for analysis
+                self.beadDiam = metadata['Analysis.Bead.Diameter']
+            except KeyError:
+                raise UserWarning('BeadConvolvedAstigGauss fitfactory requires a Bead.Diameter entry in the metadata')
+
+    def FromPoint(self, x, y, z=None, roiHalfSize=5, axialHalfSize=15):
+        X, Y, data, background, sigma, xslice, yslice, zslice = self.getROIAtPoint(x, y, z, roiHalfSize, axialHalfSize)
+
+        dataMean = data - background
+
+        # estimate some start parameters...
+        A = data.max() - data.min()  # amplitude
+
+        vs = self.metadata.voxelsize_nm
+        x0 = vs.x * x
+        y0 = vs.y * y
+
+        bgm = np.mean(background)
+
+        startParameters = [A, x0, y0, 250 / 2.35, 250 / 2.35, dataMean.min(), .001, .001]
+
+        # do the fit
+        (res, cov_x, infodict, mesg, resCode) = self.solver(self.fitfcn, startParameters, dataMean, sigma, X, Y, self.beadDiam)
+
+        # try to estimate errors based on the covariance matrix
+        fitErrors = None
+        try:
+            fitErrors = np.sqrt(
+                np.diag(cov_x) * (infodict['fvec'] * infodict['fvec']).sum() / (len(dataMean.ravel()) - len(res)))
+            if np.any(np.isnan(fitErrors)):
+                # for some reason we occasionally get negatives on the diagonal of the covariance matrix (and NaN for the fitError.
+                # this shouldn't happen, but catch it here in case and flag the fit as having failed
+                fitErrors = None
+        except Exception:
+            pass
+        
+        tIndex = int(self.metadata.getOrDefault('tIndex', 0))
+        return pack_results(fresultdtype, tIndex=tIndex, fitResults=res, 
+                            fitError=fitErrors, startParams=np.array(startParameters), 
+                            resultCode=resCode, 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'

PYME/localization/FitFactories/ChecksumFR.py

@@ -0,0 +1,82 @@
+#!/usr/bin/python
+
+##################
+# LatGaussFitFR.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import numpy as np
+from .fitCommon import fmtSlicesUsed 
+from . import FFBase
+
+
+
+#####################
+
+#define the data type we're going to return
+fresultdtype=[('tIndex', '<i4'),
+              ('x', '<f4'), ('y', '<f4'),
+              ('ch_data', '<u4'), ('ch_sigma', '<u4'), ('ch_background', '<u4')
+              ]
+
+
+
+class ChecksumFitFactory(FFBase.FitFactory):
+    def __init__(self, data, metadata, fitfcn=None, background=None, noiseSigma=None, **kwargs):
+        """Create a fit factory which will operate on image data (data), potentially using voxel sizes etc contained in
+        metadata. """
+        FFBase.FitFactory.__init__(self, data, metadata, fitfcn, background, noiseSigma, **kwargs)
+
+    def FromPoint(self, x, y, z=None, roiHalfSize=5, axialHalfSize=15):
+        X, Y, data, background, sigma, xslice, yslice, zslice = self.getROIAtPoint(x, y, z, roiHalfSize, axialHalfSize)
+
+        import zlib
+        
+        if not isinstance(sigma, np.ndarray):
+            sigma = np.array(sigma)
+            
+        if not isinstance(background, np.ndarray):
+            background = np.array(background)
+
+        ch_data = zlib.crc32(np.ascontiguousarray(data.data))
+        ch_sigma = zlib.crc32(np.ascontiguousarray(sigma.data))
+        ch_background = zlib.crc32(np.ascontiguousarray(background.data))
+        
+        
+        #package results
+        res = np.zeros(1, fresultdtype)
+        res['tIndex'] = self.metadata['tIndex']
+        res['x'] = x
+        res['y'] = y
+        res['ch_sigma'] = ch_sigma
+        res['ch_data'] = ch_data
+        res['ch_background'] = ch_background
+        return res
+
+    
+
+
+#so that fit tasks know which class to use
+FitFactory = ChecksumFitFactory
+#FitResult = GaussianFitResultR
+FitResultsDType = fresultdtype #only defined if returning data as numarray
+
+DESCRIPTION = 'CRC32 checksum of ROI'
+LONG_DESCRIPTION = 'Takes a CRC32 checksum of detected ROIs'
+USE_FOR = 'Debugging to ensure reproducible ROI extraction and background correction'

PYME/localization/FitFactories/ChecksumGPUFR.py

@@ -0,0 +1,213 @@
+import scipy.ndimage as ndimage
+import numpy as np
+from .fitCommon import fmtSlicesUsed, pack_results
+
+from PYME.localization.cModels.gauss_app import *
+from PYME.Analysis._fithelpers import *
+
+
+fresultdtype=[
+    ('tIndex', '<i4'), ('ch_data_cpu', '<u4'), ('ch_data_e_gpu', '<u4'),
+    ('ch_sigma', '<u4'), ('ch_background', '<u4'), ('ch_dog', '<u4'),
+    ('ch_max_filter', '<u4'),
+]
+
+_warpdrive = None
+
+missing_warpdrive_msg = """
+Could not import the warpdrive module. GPU fitting requires the warpdrive module,
+which is distributed separately due to licensing issues. The warpdrive module is
+available on request and is free for academic use. Please contact David Baddeley
+or Joerg Bewersdorf.
+"""
+
+class ChecksumFitFactory(object):
+    X = None
+    Y = None
+    
+    def __init__(self, data, metadata, fitfcn=None, background=None, noiseSigma=None, **kwargs):
+        """
+
+        Create a fit factory which will operate on image data (data), potentially using voxel sizes etc contained in
+        metadata.
+
+        Parameters
+        ----------
+        data : numpy.ndarray
+            Uncorrected data, in raw ADU
+        metadata : PYME.IO.MetaDataHandler.MDHandlerBase or derived class
+        background : numpy.ndarray, warpdrive.buffers.Buffer, or scalar
+            warpdrive.buffers.Buffer allows asynchronous estimation of the per-pixel background on the GPU.
+        """
+
+        self.data = data
+        self.metadata = metadata
+
+        if isinstance(background, np.ndarray):
+            self.background = background.squeeze()  # will be set to contiguous float32 inside of detector class method
+        elif np.isscalar(background):
+            self.background = np.ascontiguousarray(background * np.ones_like(self.data), dtype=np.float32)
+        else:  # it's a buffer!
+            self.background = background
+
+
+    def refresh_warpdrive(self, cameraMaps):
+        try:
+            import warpdrive
+        except ImportError:
+            print("GPU fitting available on-request for academic use. Please contact David Baddeley or Joerg Bewersdorf.")
+
+            raise ImportError(missing_warpdrive_msg)
+
+        global _warpdrive  # One instance for each process, re-used for subsequent fits.
+
+        # get darkmap [ADU]
+        self.darkmap = cameraMaps.getDarkMap(self.metadata)
+        if np.isscalar(self.darkmap):
+            self.darkmap = self.darkmap * np.ones_like(self.data)
+
+        # get flatmap [unitless]
+        self.flatmap = cameraMaps.getFlatfieldMap(self.metadata)
+        if np.isscalar(self.flatmap):
+            self.flatmap = self.flatmap * np.ones_like(self.data)
+
+        # get varmap [e-^2]
+        self.varmap = cameraMaps.getVarianceMap(self.metadata)
+        if np.isscalar(self.varmap):
+            if self.varmap == 0:
+                self.varmap = np.ones_like(self.data)
+                logger.error('Variance map not found and read noise defaulted to 0; changing to 1 to avoid x/0.')
+            self.varmap = self.varmap*np.ones_like(self.data)
+
+        if isinstance(self.background, np.ndarray):  # flatfielding is done on CPU-calculated backgrounds
+            # fixme - do we change this control flow in remfitbuf by doing our own sigma calc?
+            self.background = self.background/self.flatmap  # no unit conversion here, still in [ADU]
+        else:
+            # if self.background is a buffer, the background is already on the GPU and has not been flatfielded
+            pass
+
+        # Account for any changes we need to make to the detector instance
+        small_filter_size = self.metadata.getOrDefault('Analysis.DetectionFilterSize', 
+                                                       4)
+        guess_psf_sigma_pix = self.metadata.getOrDefault('Analysis.GuessPSFSigmaPix',
+                                                         600 / 2.8 / (self.metadata.voxelsize_nm.x))
+
+        if not _warpdrive:  # if we don't have a detector, make one and return
+            _warpdrive = warpdrive.detector(small_filter_size, 2 * small_filter_size, guess_psf_sigma_pix)
+            _warpdrive.allocate_memory(np.shape(self.data))
+            _warpdrive.prepare_maps(self.darkmap, self.varmap, self.flatmap, self.metadata['Camera.ElectronsPerCount'],
+                                    self.metadata['Camera.NoiseFactor'], self.metadata['Camera.TrueEMGain'])
+            return
+
+        need_maps_filtered, need_mem_allocated = False, False
+        # check if our filter sizes are the same
+        if small_filter_size != _warpdrive.small_filter_size:
+            _warpdrive.set_filter_kernels(small_filter_size, 2 * small_filter_size)
+            # need to rerun map filters
+            need_maps_filtered = True
+
+        # check if the data is coming from a different camera region
+        if _warpdrive.varmap.shape != self.varmap.shape:
+            need_mem_allocated, need_maps_filtered = True, True
+        else:
+            # check if both corners are the same
+            top_left = np.array_equal(self.varmap[:20, :20], _warpdrive.varmap[:20, :20])
+            bot_right = np.array_equal(self.varmap[-20:, -20:], _warpdrive.varmap[-20:, -20:])
+            if not (top_left or bot_right):
+                need_maps_filtered = True
+
+        if need_mem_allocated:
+            _warpdrive.allocate_memory(np.shape(self.data))
+        if need_maps_filtered:
+            _warpdrive.prepare_maps(self.darkmap, self.varmap, self.flatmap,
+                                    self.metadata['Camera.ElectronsPerCount'], self.metadata['Camera.NoiseFactor'],
+                                    self.metadata['Camera.TrueEMGain'])
+
+    def FindAndFit(self, threshold, cameraMaps, **kwargs):
+        """
+
+        Parameters
+        ----------
+        threshold: float
+            detection threshold, as a multiple of per-pixel noise standard deviation
+        cameraMaps: cameraInfoManager object (see remFitBuf.py)
+
+        Returns
+        -------
+        results
+
+        """
+        import zlib
+        try:
+            import warpdrive
+        except ImportError:
+            print("GPU fitting available on-request for academic use. Please contact David Baddeley or Joerg Bewersdorf.")
+            raise ImportError(missing_warpdrive_msg)
+
+        res = np.zeros(1, fresultdtype)
+        res['tIndex'] = self.metadata['tIndex']
+        res['ch_data_cpu'] = zlib.crc32(self.data)
+        # make sure we've loaded and pre-filtered maps for the correct FOV
+        self.refresh_warpdrive(cameraMaps)
+        # prepare the frame
+        _warpdrive.prepare_frame(self.data)
+        warpdrive.cuda.memcpy_dtoh_async(_warpdrive.dtarget, _warpdrive.data_gpu,
+                                         stream=_warpdrive.main_stream_r)
+        _warpdrive.main_stream_r.synchronize()
+        res['ch_data_e_gpu'] = zlib.crc32(_warpdrive.dtarget)
+        warpdrive.cuda.memcpy_dtoh_async(_warpdrive.dtarget, _warpdrive.noise_sigma_gpu,
+                                         stream=_warpdrive.main_stream_r)
+        _warpdrive.main_stream_r.synchronize()
+        res['ch_sigma'] = zlib.crc32(_warpdrive.dtarget)
+        
+
+        #PYME ROISize is a half size
+        roi_size = int(2*self.metadata.getEntry('Analysis.ROISize') + 1)
+
+        ########## Actually do the fits #############
+        # toggle background subtraction (done both in detection and the fit)
+        if self.metadata.getOrDefault('Analysis.subtractBackground', False):
+            _warpdrive.difference_of_gaussian_filter(self.background)
+        else:
+            _warpdrive.difference_of_gaussian_filter()
+        
+        warpdrive.cuda.memcpy_dtoh_async(_warpdrive.dtarget, _warpdrive.bkgnd_gpu,
+                                         stream=_warpdrive.main_stream_r)
+        _warpdrive.main_stream_r.synchronize()
+        res['ch_background'] = zlib.crc32(_warpdrive.dtarget)
+        warpdrive.cuda.memcpy_dtoh_async(_warpdrive.dtarget, _warpdrive.unif1_gpu,
+                                         stream=_warpdrive.main_stream_r)
+        _warpdrive.main_stream_r.synchronize()
+        res['ch_dog'] = zlib.crc32(_warpdrive.dtarget)
+
+        _warpdrive.get_candidates(threshold, roi_size)
+        warpdrive.cuda.memcpy_dtoh_async(_warpdrive.dtarget, _warpdrive.maxf_data_gpu,
+                                         stream=_warpdrive.main_stream_r)
+        _warpdrive.main_stream_r.synchronize()
+        res['ch_max_filter'] = zlib.crc32(_warpdrive.dtarget)
+
+        return res
+
+
+   
+        
+
+
+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'),
+]
+#so that fit tasks know which class to use
+FitFactory = ChecksumFitFactory
+
+FitResultsDType = fresultdtype #only defined if returning data as numarray
+
+DESCRIPTION = 'CRC32 checksum of frame'
+LONG_DESCRIPTION = 'Takes a CRC32 checksum of frame'
+USE_FOR = 'Debugging to ensure frame data and background are reproducible'

PYME/localization/FitFactories/ChecksumMultifitSR.py

@@ -0,0 +1,86 @@
+#!/usr/bin/python
+
+##################
+# LatGaussFitFR.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+#import scipy
+import scipy.ndimage as ndimage
+import numpy as np
+from .fitCommon import fmtSlicesUsed, pack_results
+
+from PYME.localization.cModels.gauss_app import *
+from PYME.Analysis._fithelpers import *
+
+
+fresultdtype=[('tIndex', '<i4'),
+              ('ch_data', '<u4'), ('ch_sigma', '<u4'), ('ch_background', '<u4')
+              ]
+
+
+class ChecksumFitFactory:
+    X = None
+    Y = None
+    
+    def __init__(self, data, metadata, fitfcn=None, background=None, noiseSigma=None, **kwargs):
+        """Create a fit factory which will operate on image data (data), potentially using voxel sizes etc contained in
+        metadata. """
+        self.data = data
+        self.background = background
+        self.noiseSigma = noiseSigma
+        self.metadata = metadata
+            
+
+    def FindAndFit(self, threshold=2, gui=False, cameraMaps = None):
+        import zlib
+    
+        if not isinstance(self.noiseSigma, np.ndarray):
+            self.noiseSigma = np.array(self.noiseSigma)
+    
+        if not isinstance(self.background, np.ndarray):
+            self.background = np.array(self.background)
+    
+    
+        #package results
+        res = np.zeros(1, fresultdtype)
+        res['tIndex'] = self.metadata['tIndex']
+        res['ch_sigma'] = zlib.crc32(self.noiseSigma.data)
+        res['ch_data'] = zlib.crc32(self.data.data)
+        res['ch_background'] = zlib.crc32(self.background.data)
+        return res
+        
+
+
+   
+        
+
+
+#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
+
+#so that fit tasks know which class to use
+FitFactory = ChecksumFitFactory
+#FitResult = GaussianFitResultR
+FitResultsDType = fresultdtype #only defined if returning data as numarray
+
+DESCRIPTION = 'CRC32 checksum of frame'
+LONG_DESCRIPTION = 'Takes a CRC32 checksum of frame'
+USE_FOR = 'Debugging to ensure frame data and background are reproducible'

PYME/localization/FitFactories/ConfocCOIR.py

@@ -0,0 +1,93 @@
+#!/usr/bin/python
+
+##################
+# LatGaussFitFRTC.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+#from pylab import *
+import numpy
+from . import fitCommon
+from PYME.localization.cModels.gauss_app import *
+
+
+fresultdtype=[('tIndex', '<i4'),
+              ('fitResults', [('A', '<f4'),
+                              ('x0', '<f4'),
+                              ('y0', '<f4'),
+                              ('sigxl', '<f4'), 
+                              ('sigxr', '<f4'),
+                              ('sigyu', '<f4'),
+                              ('sigyd', '<f4')])]
+
+def COIFitResultR(fitResults, metadata, slicesUsed=None, resultCode=-1, fitErr=None):
+
+    tIndex = metadata['tIndex']
+
+    return numpy.array([(tIndex, fitResults.astype('f'))], dtype=fresultdtype)
+
+
+def ConfocCOI(data, metadata, thresh=5, background=None):
+    dataROI = data.squeeze()
+
+    #average in z
+    #dataMean = dataROI.mean(2) - self.metadata.CCD.ADOffset
+
+    #generate grid to evaluate function on
+    vs = metadata.voxelsize_nm
+    X, Y = numpy.mgrid[:dataROI.shape[0], :dataROI.shape[1]]
+    X = vs.x*X
+    Y = vs.y*Y
+
+
+    if not background is None and len(numpy.shape(background)) > 1 and not ('Analysis.subtractBackground' in metadata.getEntryNames() and metadata['Analysis.subtractBackground'] == False):
+        bgROI = background.squeeze()
+
+        dataROI = dataROI - bgROI
+
+    dataROI = (dataROI*(dataROI > thresh) - thresh).astype('f')
+
+
+    A = dataROI.sum()
+
+    #print Xg.shape, Ag.shape
+    x0 =  (X*dataROI).sum()/A
+    y0 =  (Y*dataROI).sum()/A
+
+    sig_xl = (numpy.maximum(0, x0 - X)*dataROI).sum()/A
+    sig_xr = (numpy.maximum(0, X - x0)*dataROI).sum()/A
+
+    sig_yu = (numpy.maximum(0, y0 - Y)*dataROI).sum()/A
+    sig_yd = (numpy.maximum(0, Y - y0)*dataROI).sum()/A
+
+    
+    res = numpy.array([A, x0, y0, sig_xl, sig_xr, sig_yu, sig_yd])
+
+    return COIFitResultR(res, metadata)
+
+    
+
+#so that fit tasks know which class to use
+FitFactory = ConfocCOI
+FitResult = COIFitResultR
+FitResultsDType = fresultdtype #only defined if returning data as numarray
+
+
+DESCRIPTION = '3D centroid for confocal data.'
+LONG_DESCRIPTION = '3D centroid suitable for use on 3D data sets (e.g. Confocal). Not useful for PALM/STORM analysis.'