python-microscopy 26.7.9__cp313-cp313-macosx_26_0_arm64.whl

PYME/setup_exe.py

@@ -0,0 +1,57 @@
+#!/usr/bin/python
+
+##################
+# setup.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/>.
+#
+##################
+
+
+def configuration(parent_package='',top_path=None):
+    from numpy.distutils.misc_util import Configuration
+    config = Configuration('PYME',parent_package,top_path)
+    config.add_subpackage('Analysis')
+    config.add_subpackage('Acquire')
+    config.add_subpackage('DSView')
+    config.add_subpackage('PSFGen')
+    config.add_subpackage('cSMI')
+    config.add_subpackage('ParallelTasks')
+    config.add_subpackage('io')
+    config.add_subpackage('misc')
+    config.add_subpackage('pad')
+    config.add_subpackage('dataBrowser')
+    
+    #config.make_svn_version_py()  # installs __svn_version__.py
+    #config.make_config_py()
+    return config
+
+if __name__ == '__main__':
+    #from numpy.distutils.core import setup
+    #setup(**configuration(top_path='').todict())
+
+    from cx_Freeze import setup, Executable
+    import matplotlib
+    setup(executables=[Executable('LMVis/VisGUI.py'),Executable('Acquire/PYMEAquire.py'),Executable('DSView/dh5view.py')],
+        options= {'build_exe' : {
+          'excludes' : ['pyreadline', 'Tkconstants', 'Tkinter', 'tcl', '_imagingtk', 'PIL._imagingtk', 'ImageTK', 'PIL.ImageTK', 'FixTk'],
+          'packages' : ['OpenGL', 'OpenGL.platform', 'OpenGL.arrays']}},
+
+        #data_files=matplotlib.get_py2exe_datafiles(),
+      #cmdclass = {'build_ext': build_ext},
+      #ext_modules = ext_modules
+      )

PYME/simulation/locify.py

@@ -0,0 +1,319 @@
+#!/usr/bin/python
+
+##################
+# locify.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This file may NOT be distributed without express permision from David Baddeley
+#
+# Generates a series of point/fluorophore positions from a given grayscale image
+#
+##################
+
+from numpy.random import rand
+import numpy as np
+#import np.random
+
+
+def locify(im, pixelSize=1, pointsPerPixel=0.1):
+    '''Create a set of point positions with a density corresponding to the
+    input image im. Useful for generating localisation microscopy images from
+    conventional images. Assumes im is a 2D array with values between 0 and 1
+    and interprets this value as a probability. pointsPerPixel gives the point density for a prob. of 1.'''
+    
+    im = np.atleast_3d(im)
+
+    #what range shold we generate points in
+    xmax = im.shape[0]
+    ymax = im.shape[1]
+    zmax = im.shape[2]
+
+    #generate a number of candidate points based on uniform labelling
+    #which will be accepted/rejected later
+    numPoints = int(xmax*ymax*zmax*pointsPerPixel)
+
+    x = xmax*rand(numPoints)
+    y = ymax*rand(numPoints)
+    z = zmax*rand(numPoints)
+    
+    #print len(x)
+
+    #index into array to get probability of acceptance
+    p = im[np.floor(x).astype('i'), np.floor(y).astype('i'), np.floor(z).astype('i')]
+
+    #use monte-carlo to accept points with the given probability
+    mcInd = rand(len(x)) < p.ravel()
+
+    #print x.shape, mcInd.shape, p.shape, rand(len(x)).shape
+
+    #take subset of positions and scale to pixel size
+    #NOTE: we currently return co-ordinates referenced to the top-left corner of the input image, not pixel centres, as returned by fits
+    x = pixelSize*(x[mcInd])
+    y = pixelSize*(y[mcInd])
+    z = pixelSize *(z[mcInd])
+
+    return (x,y,z)
+
+
+def points_from_sdf(sdf, r_max=1, centre=(0,0,0), dx_min=1, p=0.1):
+    '''
+    Generate points from a signed distance function. Effectively does octree-like subdivision of the function domain to
+    assign points on a regular grid, then passes through a Monte-Carlo acceptance function to simulate labelling efficiency
+    
+    Parameters
+    ----------
+    sdf : function
+        the signed distance function. Should be of the form dist = sdf(pts) where pts is a 3xN ndarray/
+    r_max: float
+        The maximum radius of the object (from centre)
+    centre : 3-tuple / array of float
+        The centre of the object
+    dx_min : float
+        The target side length of a voxel. Effectively a density parameter (density = 1/dx_min^3).
+    p : float
+        Monte-Carlo acceptance probability.
+
+    Returns
+    -------
+    
+    verts : 3xN ndarray of fluorophore positions
+
+    '''
+    dx = 1.2 * r_max
+
+    dx = (2**np.ceil(np.log2(dx/dx_min)))*dx_min - 0.1
+    
+    #vx, vy, vz = [v.ravel() for v in np.mgrid[-1:2, -1:2, -1:2]]
+
+    #v_offs = np.vstack([vx, vy, vz])
+    #print(v_offs.shape)
+    
+    #verts = dx * v_offs + np.array(centre)[:,None]
+    #print(verts.shape)
+
+    verts = np.array(centre)[:,None]
+    
+    c_offs = np.array(
+        [[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]], 'f')
+    
+    #test_offs =
+
+    #print(dx, verts.T)
+    
+    while dx > dx_min:
+       
+        #test and discard.
+        corners = [verts + dx * c_offs[i][:, None] for i in range(8)]
+        #print(dx)
+        #print(np.array(corners).shape)
+        corner_dists = [sdf(c) for c in corners] + [sdf(verts), ]
+        
+        #corner_dists = [sdf(verts),]
+        
+        #contains_points = np.abs(np.sum([np.sign(c) for c in corner_dists], axis=0)) < 9
+        # for some reason the sign test doesn't seem to work properly. Use a generous
+        # distance based test instead
+        contains_points = np.min([np.abs(c) for c in corner_dists], axis=0) < ( 1.5*dx)
+        #print(dx, np.min([np.abs(c) for c in corner_dists], axis=0), contains_points)
+        
+        verts = verts[:, contains_points]
+        #print(verts.shape)
+        dx /= 2.0
+        
+        #subdivide
+        verts = np.concatenate([verts + dx * c_offs[i, :][:, None] for i in range(8)], axis=1)
+        #print(verts.shape)
+
+    
+    # because we use a fairly relaxed / conservative criterea for discarding above (which will
+    # effectively match the cell containing the surface AND it's neighbours)
+    # we perform a more stringent test on the final set of points.
+    #corners = [verts + dx * c_offs[i][:, None] for i in range(9)]
+    #corner_dists = [sdf(c) for c in corners]
+    #print(dx, corner_dists)
+    
+    #contains_points = (np.abs(np.sum([np.sign(c) for c in corner_dists], axis=0)) < 9) & (sdf(verts) < dx)
+    contains_points = (sdf(verts) < dx/2)
+    verts = verts[:, contains_points]
+    
+    #print(verts.shape)
+    #return verts
+    return verts[:, (np.random.rand(verts.shape[1]) < p)]
+
+def testPattern():
+    '''generate a test pattern'''
+    pass
+    
+fresultdtype=[('tIndex', '<i4'),
+              ('fitResults', [('A', '<f4'),('x0', '<f4'),('y0', '<f4'), ('z0', '<f4'),('sigma', '<f4')]),
+              ('fitError', [('A', '<f4'),('x0', '<f4'),('y0', '<f4'), ('z0', '<f4'),('sigma', '<f4')])]
+
+
+_s2 = 110.**2
+_a2 = 70.**2
+
+_s2_a2_12 = _s2 + _a2/12
+_8_pi_s2_2_a2 = (8*np.pi*_s2**2)/_a2
+_r_2_pi = 1.0/2*np.pi
+
+def FitResultR(x,y,z,I,t, b2, z_err_mult=3):
+    r_I = np.sqrt(I)
+        
+    s2 = 110**2
+    a2 = 70**2
+    
+    err_x = np.sqrt((s2 + a2/12)/I + 8*np.pi*s2**2*b2/(a2*I**2))
+    err_z = z_err_mult*err_x
+
+    return np.array([(t, np.array([I/(2*np.pi), x, y, z, 110.], 'f'), np.array([r_I/(2*np.pi), err_x, err_x, err_z, err_x], 'f'))], dtype=fresultdtype)
+
+def _eventify(x,y,meanIntensity, meanDuration, backGroundIntensity, meanEventNumber, sf = 2, tm=2000, z=0, z_err_scale=1.0):
+    Is = np.random.exponential(meanIntensity, x.shape)
+    Ns = np.random.poisson(meanEventNumber, x.shape)
+    
+    if np.isscalar(z):
+        z = z*np.ones_like(x)
+    
+    evts = []
+    #t = 0
+
+    for x_i, y_i, z_i, I_i, N_i in zip(x,y, z,Is,Ns):
+        for j in range(N_i):
+            duration = np.random.exponential(meanDuration)
+            t = np.random.exponential(tm)
+
+            #evts += [(x_i, y_i, I_i, t+k) for k in range(duration)] + [(x_i, y_i, I_i*(duration%1), t+floor(duration))]
+            evts.extend([FitResultR(x_i, y_i, z_i, I_i, t+k, backGroundIntensity, z_err_mult=z_err_scale) for k in range(int(np.floor(duration)))])
+            evts.append(FitResultR(x_i, y_i, z_i, I_i*(duration%1), t+np.floor(duration), backGroundIntensity, z_err_mult=z_err_scale))
+
+    evts = np.vstack(evts)
+    
+    #xn, yn, In = evts[:,0], evts[:,1], evts[:,2]
+
+    In = evts['fitResults']['A']
+
+    detect = np.exp(-(In)**2/(2*sf**2*backGroundIntensity)) < np.random.uniform(size=In.shape)
+
+    #xn = xn[detect]
+    #yn = yn[detect]
+    #In = In[detect]
+
+    evts = evts[detect]
+
+    s = evts['fitResults']['x0'].shape
+
+    evts['fitResults']['x0'] = evts['fitResults']['x0'] + evts['fitError']['x0']*np.random.normal(size=s)
+    evts['fitResults']['y0'] = evts['fitResults']['y0'] + evts['fitError']['y0']*np.random.normal(size=s)
+    evts['fitResults']['z0'] = evts['fitResults']['z0'] + evts['fitError']['z0']*np.random.normal(size=s)
+
+    #filter
+
+    return evts
+
+def eventify(*args, **kwargs):
+    return eventify2(*args, paint_mode=False, **kwargs)
+
+
+def eventify2(x, y, meanIntensity, meanDuration, backGroundIntensity, meanEventNumber, sf=2, tm=10000, z=0,
+             z_err_scale=1.0, paint_mode=True):
+    """ PAINT version of eventify """
+    
+    
+    #Is =
+    Ns = np.random.poisson(meanEventNumber, x.shape)
+
+    if np.isscalar(z):
+        z = z * np.ones_like(x)
+
+    evts = []
+    #t = 0
+
+    for x_i, y_i, z_i, N_i in zip(x, y, z, Ns):
+        duration = np.random.exponential(meanDuration, size=N_i)
+        n_frames = np.ceil(duration).astype('i')
+        
+        if paint_mode:
+            Is = np.random.exponential(meanIntensity, size=N_i)
+            ts = 2*tm*np.random.uniform(size=N_i)
+        else:
+            Is = np.random.exponential(meanIntensity)*np.ones(N_i)
+            ts = np.random.exponential(tm, size=N_i)
+        
+        evts_i = np.empty(n_frames.sum(), dtype=fresultdtype)
+        
+        evts_i['fitResults']['x0'] = x_i
+        evts_i['fitResults']['y0'] = y_i
+        evts_i['fitResults']['z0'] = z_i
+        
+        k = 0
+        
+        for j in range(N_i):
+            k2 = k + n_frames[j]
+            evts_i['fitResults']['A'][k:k2] = Is[j]
+            evts_i['fitResults']['A'][k2-1] = Is[j]*(duration[j] %1)
+            evts_i['tIndex'][k:k2] = ts[j]+np.arange(n_frames[j])
+            
+            k = k2
+            
+            #n_frames = int(np.ceil(duration[j]))
+            #t = 2*tm*np.random.uniform()
+            
+            #I_i = np.random.exponential(meanIntensity)
+            
+            #t_i = ts[j]+np.arange(n_frames[j])
+            
+            #I_i = Is[j]*np.ones(n_frames[j])
+            #I_i[-1] = I_i[-1]*(duration[j] %1)
+        
+            #evts += [(x_i, y_i, I_i, t+k) for k in range(duration)] + [(x_i, y_i, I_i*(duration%1), t+floor(duration))]
+            #evts.extend([FitResultR(x_i, y_i, z_i, I_i, t + k, backGroundIntensity, z_err_mult=z_err_scale) for k in
+            #             range(int(np.floor(duration)))])
+            #evts.append(FitResultR(x_i, y_i, z_i, I_i, t_i, backGroundIntensity, z_err_mult=z_err_scale))
+        evts.append(evts_i)
+
+    evts = np.hstack(evts)
+
+    #xn, yn, In = evts[:,0], evts[:,1], evts[:,2]
+    
+    
+
+    In = evts['fitResults']['A']*_r_2_pi
+
+    detect = np.exp(-(In) ** 2 / (2 * sf ** 2 * backGroundIntensity)) < np.random.uniform(size=In.shape)
+
+    #xn = xn[detect]
+    #yn = yn[detect]
+    #In = In[detect]
+
+    evts = evts[detect]
+    
+    I = evts['fitResults']['A']
+
+    err_x = np.sqrt(_s2_a2_12 / I + _8_pi_s2_2_a2 * backGroundIntensity / (I * I))
+    evts['fitError']['x0'] = err_x
+
+    evts['fitResults']['A'] = I*_r_2_pi
+    evts['fitError']['A'] = np.sqrt(I) * _r_2_pi
+    
+    
+    evts['fitError']['x0'] =err_x
+    evts['fitError']['y0'] = err_x
+    evts['fitError']['z0'] = z_err_scale*err_x
+
+    #fill in the things we don't really need.
+    evts['fitResults']['sigma'] = 110.
+    evts['fitError']['sigma'] = err_x
+
+    s = evts['fitResults']['x0'].shape
+
+    evts['fitResults']['x0'] = evts['fitResults']['x0'] + evts['fitError']['x0'] * np.random.normal(size=s)
+    evts['fitResults']['y0'] = evts['fitResults']['y0'] + evts['fitError']['y0'] * np.random.normal(size=s)
+    evts['fitResults']['z0'] = evts['fitResults']['z0'] + evts['fitError']['z0'] * np.random.normal(size=s)
+
+    #filter
+
+    return evts
+
+    #return xn, yn, In

PYME/simulation/pointsets.py

@@ -0,0 +1,279 @@
+from PYME.recipes.traits import HasTraits, Float, File, BaseEnum, Enum, List, Instance, Str, Int, Bool
+from PYME.misc.exceptions import UserError
+from PYME.IO import image
+import numpy as np
+
+
+class PointSource(HasTraits):
+    def refresh_choices(self):
+        pass
+
+    def points(self):
+        x, y, z = self.getPoints()
+        c = np.zeros_like(x)
+        yield np.array([x,y,z,c], 'f').T
+
+class RandomSource(PointSource):
+    numPoints = Int(100)
+    xRange = Float(10000)
+    yRange = Float(10000)
+    zRange = Float(100)
+    
+    #name = Str('Random')
+    
+    def getPoints(self):
+        return np.random.uniform(-self.xRange, self.xRange, self.numPoints), np.random.uniform(-self.yRange, self.yRange, self.numPoints), np.random.uniform(-self.zRange, self.zRange, self.numPoints)
+
+    def genMetaData(self, mdh):
+        mdh['GeneratedPoints.Source.Type'] = 'Random'
+        mdh['GeneratedPoints.Source.NumPoints'] = self.numPoints
+        mdh['GeneratedPoints.Source.XRange'] = self.xRange
+        mdh['GeneratedPoints.Source.YRange'] = self.yRange
+        mdh['GeneratedPoints.Source.ZRange'] = self.zRange
+
+
+class WormlikeSource(PointSource):
+    kbp = Float(200)
+    steplength = Float(1.0)
+    lengthPerKbp = Float(10.0)
+    persistLength = Float(150.0)
+    
+    #name = Str('Wormlike Chain')
+    
+    def getPoints(self):
+        from PYME.simulation import wormlike2
+        wc = wormlike2.WormlikeChain(self.kbp, self.steplength, self.lengthPerKbp, self.persistLength)
+        
+        return wc.xp, wc.yp, wc.zp
+
+    def genMetaData(self, mdh):
+        mdh['GeneratedPoints.Source.Type'] = 'Wormlike'
+        mdh['GeneratedPoints.Source.Kbp'] = self.kbp
+        mdh['GeneratedPoints.Source.StepLength'] = self.steplength
+        mdh['GeneratedPoints.Source.LengthPerKbp'] = self.lengthPerKbp
+        mdh['GeneratedPoints.Source.PersistLength'] = self.persistLength
+
+class WiglyFibreSource(PointSource):
+    length = Float(50e3)
+    persistLength=Float(1500)
+    numFluors= Int(1000)
+    centre = Bool(True)
+    flatten = Bool(False)
+
+    zScale = Float(1.0)
+
+    def getPoints(self):
+        from PYME.simulation import wormlike2
+        wc = wormlike2.wiglyFibre(self.length, self.persistLength, self.length/self.numFluors)
+
+        if self.centre:
+            wc.xp -= wc.xp.mean()
+            wc.yp -= wc.yp.mean()
+            wc.zp -= wc.zp.mean()
+
+
+        if self.flatten:
+            wc.zp *= 0
+        else:
+            wc.zp *= self.zScale
+        
+        return wc.xp, wc.yp, wc.zp
+
+class SHNucleusSource(PointSource):
+    axis_scaling = List(Float, [6000., 4000., 2000.])
+    axis_sigmas = List(Float, [1000, 1000, 1000])
+    #fixme - modes
+    point_spacing = Float(500.)
+
+    def getPoints(self):
+        from PYME.simulation import locify
+        from PYME.Analysis.points.spherical_harmonics import SHShell
+        
+        axis_scales = np.array(self.axis_scaling) + np.array(self.axis_sigmas)*np.random.normal(size=3)
+
+        
+        #axis_scales = np.array([1,1,1])
+        sf = 0.5*np.sqrt(1./np.pi) # scipy sph harmonic normalisation
+
+        #a_s = axis_scales/axis_scales.max()
+
+        modes = [(0,0)]
+        amplitudes = [1]
+
+        for n in range(1,5):
+            for m in range(-n, n+1):
+                modes.append((m, n))
+                amplitudes.append(np.random.randn(1)*(0.1*n**-1.5))
+
+        #TODO - tip - we currently do rotation only
+        theta = np.random.uniform(0, 2*np.pi)
+        prin_axes = ((np.sin(theta), np.cos(theta), 0), (np.cos(theta), -np.sin(theta), 0), (0,0,1))
+
+        shell = SHShell(principle_axes=prin_axes, axis_scaling=sf/axis_scales, modes=modes, coefficients=amplitudes)
+
+        print('axis_scales:', axis_scales)
+        r_max = 1.5*np.max(axis_scales)
+
+        pts = locify.points_from_sdf(shell.radial_distance_to_shell, r_max=r_max, dx_min=0.1*self.point_spacing)
+
+        print('pts.shape:', pts.shape)
+        return pts
+
+        
+        zenith = []
+        azimuth = []
+        for z in np.linspace(-np.pi/2, np.pi/2, 100):
+            az = np.linspace(0, 2*np.pi, int(np.abs(np.cos(z))*100))
+            azimuth.append(az)
+            zenith.append(z*np.ones_like(az))
+
+        azimuth = np.hstack(azimuth)
+        zenith = np.hstack(zenith)
+
+        x, y, z = shell.get_fitted_shell(azimuth, zenith)
+
+        print(x.min(), x.max())
+        
+        return x.ravel(), y.ravel(), z.ravel()
+
+
+        
+class FileSource(PointSource):
+    file = File(filter=['*.npy', '*.csv'],exists=True)
+    
+    #name = Str('Points File')
+    
+    def getPoints(self):
+        if self.file.endswith('.csv'):
+            # csv based storage format
+            import pandas as pd
+            df = pd.read_csv(self.file)
+            return (df['x'].values,df['y'].values,df['z'].values)
+        else:
+            import numpy as np
+            return np.load(self.file)
+
+    def genMetaData(self, mdh):
+        mdh['GeneratedPoints.Source.Type'] = 'File'
+        mdh['GeneratedPoints.Source.FileName'] = self.file
+
+
+class WRDictEnum(BaseEnum):
+    def __init__(self, wrdict, *args, **metadata):
+        self.wrdict = wrdict
+        #self.values        = tuple( values )
+        #self.fast_validate = ( 5, self.values )
+        self.name = ''
+        super(BaseEnum, self).__init__(None, **metadata)
+    
+    @property
+    def values(self):
+        return list(self.wrdict.keys())
+    
+    #def info ( self ):
+    #    return ' or '.join( [ repr( x ) for x in self.values ] )
+    
+    def create_editor(self):
+        from traitsui.api import EnumEditor
+        #print dict(self.wrdict.items())
+        
+        ed = EnumEditor(values=self,
+                        cols=self.cols or 3,
+                        evaluate=self.evaluate,
+                        mode=self.mode or 'radio')
+        
+        return ed
+
+
+class ImageSource(PointSource):
+    image = WRDictEnum(image.openImages)
+    points_per_pixel = Float(0.1)
+    #name = Str('Density Image')
+    #foo = Enum([1,2,3,4])
+    
+    helpInfo = {
+        'points_per_pixel': '''
+Select average number of points (dye molecules or docking sites) per pixel in image regions where the density values are 1.
+The number is a floating point fraction, e.g. 0.1, and shouldn't exceed 1. It is used for Monte-Carlo rejection of positions
+and larger values (>~0.2) will result in images which have visible pixel-grid structure because the Monte-Carlo sampling
+is no longer a good approximation to random sampling over the grid. If this is a problem for your application / you can't
+get high enough density without a high acceptance fraction, use an up-sampled source image with a smaller pixel size.
+''',
+        'image': '''
+Select an image from the list of open images.
+Note that you need to open or generate the source image you want to use so that this
+list is not empty. The image will be normalised for the purpose of the simulation,
+with its maximum set to 1. It describes the density of markers in the simulated sample,
+where values of 1 have a density of markers as given by the `points per pixel` parameter, i.e.
+in the Monte-Carlo sampling the acceptance probability = image*points_per_pixel. Smaller
+density values therefore give rise to proportionally fewer markers per pixel.
+''',
+    }
+    
+    def helpStr(self, name):
+        def cleanupHelpStr(str):
+            return str.strip().replace('\n', ' ').replace('\r', '')
+        
+        return cleanupHelpStr(self.helpInfo[name])
+    
+    def default_traits_view(self):
+        from traitsui.api import View, Item
+        
+        traits_view = View(Item('points_per_pixel', help=self.helpStr('points_per_pixel'),
+                                tooltip='mean number of marker points per pixel'),
+                           Item('image', help=self.helpStr('image'),
+                                tooltip='select the marker density image from the list of open images'),
+                           buttons=['OK', 'Help'])
+        
+        return traits_view
+    
+    def getPoints(self):
+        from PYME.simulation import locify
+        # print((self.image))  # if still needed should be replaced by a logging statement
+        
+        try:
+            im = image.openImages[self.image]
+        except KeyError:
+            # no image of that name:
+            # If uncaught this will pop up in the error dialog from 'Computation in progress', so shouldn't need
+            # an explicit dialog / explicit handing. TODO - do we need an error subclass - e.g. UserError or ParameterError
+            # which the error dialog treats differently to more generic errors so as to make it clear that it's something
+            # the user has done wrong rather than a bug???
+            raise UserError('No open image found with name: "%s", please set "image" property of ImageSource to a valid image name\nThis must be an image which is already open.\n\n' % self.image)
+        
+        #import numpy as np
+        d = im.data[:, :, 0, 0].astype('f')
+        
+        #normalise the image
+        d = d / d.max()
+        
+        return locify.locify(d, pixelSize=im.pixelSize, pointsPerPixel=self.points_per_pixel)
+    
+    def get_bounds(self):
+        return image.openImages[self.image].imgBounds
+    
+    def refresh_choices(self):
+        ed = self.trait('image').editor
+        
+        if ed:
+            try:
+                ed._values_changed()
+            except TypeError:
+                # TODO - why can _values_changed be None??
+                # is there a better way to handle/avoid this?
+                pass
+            #super( HasTraits, self ).configure_traits(*args, **kwargs)
+
+#    traits_view = View( Item('points_per_pixel'),
+#                        Item('image'),
+##                        Item( 'image',
+##                              label='Image',
+##                              editor =
+##                                  EnumEditor(values={'foo':0, 'bar' : 1}),#image.openImages),
+##                              ),
+#                        buttons = ['OK'])
+
+    def genMetaData(self, mdh):
+        mdh['GeneratedPoints.Source.Type'] = 'Image'
+        mdh['GeneratedPoints.Source.PointsPerPixel'] = self.points_per_pixel
+        mdh['GeneratedPoints.Source.Image'] = self.image