python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/LMVis/Extras/extra_layers.py

@@ -0,0 +1,373 @@
+import numpy as np
+import wx
+import os
+
+
+
+# def _gen_octree_layer_from_points(visFr):
+#     MIN_PIXEL_SIZE=5
+#
+#     pts = np.vstack([visFr.pipeline['x'], visFr.pipeline['y'], visFr.pipeline['z']]).T.astype('f4')
+#
+#     r_min = pts.min(axis=0)
+#     r_max = pts.max(axis=0)
+#
+#     bbox_size = (r_max - r_min).max()
+#
+#     bb_max = r_min + bbox_size
+#
+#     max_depth = np.log2(bbox_size/MIN_PIXEL_SIZE) + 1
+#
+#     ot = Octree([r_min[0], bb_max[0], r_min[1], bb_max[1], r_min[2], bb_max[2]], maxdepth=max_depth)
+#     ot.add_points(pts)
+#
+#     l = OctreeRenderLayer(visFr.pipeline, 'flat', ot, depth=0, alpha=1.0)
+#
+#     visFr.add_layer(l)
+
+
+def add_octree_layer(visFr):
+    # create the octree once and add to the pipeline as a new data source, rather than adding the
+    # octree module to the pipeline - this avoids
+    # regenerating everytime we change something with the points
+    # TODO - expose octree parameters
+    from PYME.LMVis.layers.octree import OctreeRenderLayer
+    
+    if not 'octree0' in visFr.pipeline.dataSources.keys():
+        gen_octree_from_points(visFr)
+        
+    l = OctreeRenderLayer(visFr.pipeline, 'flat', 'octree0', depth=0, alpha=1.0)
+    visFr.add_layer(l)
+        
+    print('Octree layer added')
+        
+def gen_octree_from_points(visFr):
+    from PYME.recipes.pointcloud import Octree
+    
+    pipeline = visFr.pipeline
+    oc_name = pipeline.new_ds_name('octree')
+    
+    colour_chans = pipeline.colourFilter.getColourChans()
+    current_colour = pipeline.colourFilter.currentColour
+    if len(colour_chans) > 1:
+        channel_choices = colour_chans + ['<all>',]
+
+        dlg = wx.SingleChoiceDialog(visFr, "Which colour channel do you want to skin?", "Multiple colour channels detected", channel_choices)
+
+        if not dlg.ShowModal():
+            dlg.Destroy()
+            return
+        else:
+            chan = dlg.GetStringSelection()
+            dlg.Destroy()
+            
+            if chan == '<all>':
+                chan = None
+                
+            pipeline.colourFilter.setColour(chan)
+    
+    otm = Octree()
+    pipeline.dataSources[oc_name] = otm.apply_simple(pipeline)
+    print('Octree  (%s) created' % oc_name)
+
+    pipeline.colourFilter.setColour(current_colour)
+    
+    return oc_name
+
+def gen_isosurface(visFr):
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    from PYME.recipes.surface_fitting import DualMarchingCubes
+    from PYME.misc.colormaps import cm
+    
+    oc_name = gen_octree_from_points(visFr)
+    surf_name, surf_count = visFr.pipeline.new_ds_name('surf', return_count=True)
+    
+    recipe = visFr.pipeline.recipe
+    dmc = DualMarchingCubes(recipe, invalidate_parent=False, input=oc_name,output=surf_name)
+    
+    if dmc.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([dmc,])
+
+        print('Isosurface generated, adding layer')
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='shaded', cmap = cm.solid_cmaps[surf_count % len(cm.solid_cmaps)])
+        visFr.add_layer(layer)
+        dmc._invalidate_parent = True
+        print('Isosurface layer added')
+
+def gen_point_dis_isosurface(visFr):
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    from PYME.recipes.surface_fitting import NthPointIsosurface
+    from PYME.misc.colormaps import cm
+    
+    recipe = visFr.pipeline.recipe
+    surf_name, surf_count = visFr.pipeline.new_ds_name('surf', return_count=True)
+    dmc = NthPointIsosurface(recipe, invalidate_parent=False, input=visFr.pipeline.selectedDataSourceKey,output=surf_name)
+    
+    if dmc.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([dmc,])
+
+        print('Isosurface generated, adding layer')
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='shaded', cmap = cm.solid_cmaps[surf_count % len(cm.solid_cmaps)])
+        visFr.add_layer(layer)
+        dmc._invalidate_parent = True
+        print('Isosurface layer added')
+
+def gen_octree_isosurface(visFr):
+    """
+    Generate an isosurface and octree in the pipeline
+    """
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    from PYME.recipes.surface_fitting import DualMarchingCubes
+    from PYME.recipes.pointcloud import Octree
+    from PYME.misc.colormaps import cm
+
+    oc_name = visFr.pipeline.new_ds_name('octree')
+    surf_name, surf_count = visFr.pipeline.new_ds_name('surf', return_count=True)
+    
+    recipe = visFr.pipeline.recipe
+     
+    otm = Octree(recipe,input_localizations=visFr.pipeline.selectedDataSourceKey,output_octree=oc_name)
+    dmc = DualMarchingCubes(recipe, invalidate_parent=False, input=oc_name,output=surf_name)
+    
+    if dmc.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([otm, dmc,])
+
+        print('Isosurface generated, adding layer')
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='shaded', cmap = cm.solid_cmaps[surf_count % len(cm.solid_cmaps)])
+        visFr.add_layer(layer)
+        dmc._invalidate_parent = True
+        print('Isosurface layer added')
+        
+def open_surface(visFr):
+    import wx
+    # from PYME.experimental import triangle_mesh
+    from PYME.experimental import _triangle_mesh as triangle_mesh
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    
+    filename = wx.FileSelector("Choose a file to open",
+                                   default_extension='stl',
+                                   wildcard='STL mesh (*.stl)|*.stl|PLY mesh (*.ply)|*.ply')
+    #print filename
+    if not filename == '':
+        tail = os.path.split(filename)[-1]
+        base_name = tail.split('.')[0]
+        surf_name, surf_count = base_name, 0
+        while surf_name in visFr.pipeline.dataSources.keys():
+            surf_count += 1
+            surf_name = '%s%d' % (base_name, surf_count)
+
+        ext = tail.split('.')[-1]
+        if ext == 'stl':
+            visFr.pipeline.dataSources[surf_name] = triangle_mesh.TriangleMesh.from_stl(filename)
+        elif ext == 'ply':
+            visFr.pipeline.dataSources[surf_name] = triangle_mesh.TriangleMesh.from_ply(filename)
+        else:
+            raise ValueError('Invalid file extension .' + str(ext))
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='shaded')
+        visFr.add_layer(layer)
+        visFr.update_datasource_panel()
+        
+def save_surface(visFr):
+    import wx
+    from PYME.experimental import _triangle_mesh as triangle_mesh
+    
+    surf_keys = [key for key, mesh in visFr.pipeline.dataSources.items() if isinstance(mesh, triangle_mesh.TriangleMesh)]
+    
+    if len(surf_keys) == 0:
+        raise RuntimeError('No surfaces present')
+    
+    if len(surf_keys) == 1:
+        key = surf_keys[0]
+    else:
+        dlg = wx.SingleChoiceDialog(visFr, "Which surface do you want to save?", "Choose a surface to save", surf_keys)
+        
+        if not dlg.ShowModal():
+            dlg.Destroy()
+            return
+        else:
+            key = dlg.GetStringSelection()
+            dlg.Destroy()
+
+    filename = wx.FileSelector('Save surface as...',
+                               default_extension='stl',
+                               wildcard='STL mesh (*.stl)|*.stl|PLY mesh (*.ply)|*.ply',
+                               flags=wx.FD_SAVE)
+
+    if not filename == '':
+        ext = filename.split('.')[-1]
+        if ext == 'stl':
+            visFr.pipeline.dataSources[key].to_stl(filename)
+        elif ext == 'ply':
+            colors = None
+            # Check if we've rendered this data source 
+            layer_list = [x.dsname for x in visFr.glCanvas.layers]
+            if key in layer_list:
+                # If we have, save the PLY with its colors
+                layer = visFr.glCanvas.layers[layer_list.index(key)]
+                # Construct a re-indexing for non-negative vertices
+                live_vertices = np.flatnonzero(visFr.pipeline.dataSources[key]._vertices['halfedge'] != -1)
+                new_vertex_indices = np.arange(live_vertices.shape[0])
+                vertex_lookup = np.zeros(visFr.pipeline.dataSources[key]._vertices.shape[0])
+                
+                vertex_lookup[live_vertices] = new_vertex_indices
+
+                # Grab the faces and vertices we want
+                faces = vertex_lookup[visFr.pipeline.dataSources[key].faces]
+
+                colors = np.zeros((live_vertices.size, 3), dtype=np.ubyte)
+                colors[faces.ravel().astype(int)] = np.floor(layer._colors[:,:3]*255).astype(np.ubyte)
+                
+            visFr.pipeline.dataSources[key].to_ply(filename, colors)
+        else:
+            raise ValueError('Invalid file extension .' + str(ext))
+    
+def distance_to_surface(visFr):
+    from PYME.recipes.surface_fitting import DistanceToMesh
+    from PYME.experimental._triangle_mesh import TriangleMesh
+
+    pipeline = visFr.pipeline
+
+    dist_name = visFr.pipeline.new_ds_name('distance')
+
+    mesh_names = [k for k, v in pipeline.dataSources.items() if isinstance(v, TriangleMesh)]
+    
+    dlg = wx.SingleChoiceDialog(visFr, "Measure distance to which mesh?", "Choose a mesh", mesh_names)
+
+    if dlg.ShowModal() == wx.ID_OK:
+        surf_name = dlg.GetStringSelection()
+        dlg.Destroy()
+    else:
+        dlg.Destroy()
+        return
+
+    recipe = visFr.pipeline.recipe
+    dts = DistanceToMesh(recipe, input_mesh=surf_name, input_points=pipeline.selectedDataSourceKey, output=dist_name)
+
+    recipe.add_modules_and_execute([dts,])
+    visFr.pipeline.selectDataSource(dist_name)
+ 
+def estimate_density(visFr):
+    from PYME.recipes.pointcloud import LocalPointDensity
+    dens_name = visFr.pipeline.new_ds_name('dense')
+
+    recipe = visFr.pipeline.recipe
+    dmc = LocalPointDensity(recipe, invalidate_parent=False, input=visFr.pipeline.selectedDataSourceKey, output=dens_name)
+
+    if dmc.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([dmc,])
+        dmc._invalidate_parent = True
+        visFr.pipeline.selectDataSource(dens_name)
+        
+        
+def estimate_circumcentre_densities(visFr):
+    from PYME.recipes.pointcloud import LocalPointDensity, DelaunayCircumcentres
+
+    recipe = visFr.pipeline.recipe
+    
+    tess_name = add_tesselation(visFr)
+    if tess_name is None:
+        return
+        
+    cc_name = visFr.pipeline.new_ds_name('circumcentres')
+    cc = DelaunayCircumcentres(recipe, input=tess_name, output=cc_name)
+    #recipe.add_module(cc)
+    
+    dens_name = visFr.pipeline.new_ds_name('dense')
+    dmc = LocalPointDensity(recipe, invalidate_parent=False, input=visFr.pipeline.selectedDataSourceKey, input_sample_locations=cc_name, output=dens_name)
+
+    if dmc.configure_traits(kind='modal'):
+        #recipe.add_module(dmc)
+        #recipe.execute()
+        recipe.add_modules_and_execute([cc, dmc])
+        dmc._invalidate_parent = True
+        visFr.pipeline.selectDataSource(dens_name)
+    
+    
+def add_tesselation(visFr):
+    from PYME.recipes.pointcloud import DelaunayTesselation
+
+    pipeline = visFr.pipeline
+    surf_name = pipeline.new_ds_name('delaunay')
+
+    colour_chans = pipeline.colourFilter.getColourChans()
+    current_colour = pipeline.colourFilter.currentColour
+    if len(colour_chans) > 1:
+        channel_choices = colour_chans + ['<all>', ]
+    
+        dlg = wx.SingleChoiceDialog(visFr, "Which colour channel do you want to skin?",
+                                    "Multiple colour channels detected", channel_choices)
+    
+        if not dlg.ShowModal():
+            dlg.Destroy()
+            return
+        else:
+            chan = dlg.GetStringSelection()
+            dlg.Destroy()
+        
+            if chan == '<all>':
+                chan = None
+        
+            pipeline.colourFilter.setColour(chan)
+
+    dt = DelaunayTesselation()
+    if dt.configure_traits(kind='modal'):
+        pipeline.dataSources[surf_name] = dt.apply_simple(pipeline)
+        print('Delaunay tesselation  (%s) created' % surf_name)
+        pipeline.colourFilter.setColour(current_colour)
+        return surf_name
+        
+    else:
+        pipeline.colourFilter.setColour(current_colour)
+        return None
+    
+def add_tesselation_layer(visFr):
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    surf_name = add_tesselation(visFr)
+    if surf_name is not None:
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='flat',
+                                    cmap='hot')
+        visFr.add_layer(layer)
+        print('Tesselation layer added')
+
+def gen_isosurface_from_tesselation(visFr):
+    from PYME.LMVis.layers.mesh import TriangleRenderLayer
+    from PYME.recipes.surface_fitting import DelaunayMarchingTetrahedra
+    from PYME.misc.colormaps import cm
+
+    if 'delaunay0' not in visFr.pipeline.dataSources.keys():
+        del_name = add_tesselation(visFr)
+    else:
+        _, c = visFr.pipeline.new_ds_name('delaunay', return_count=True)
+        del_name = 'delaunay{}'.format(c-1)
+
+    if 'dn' not in visFr.pipeline.dataSources[del_name].keys():
+        # visFr.pipeline.selectDataSource(del_name)
+        estimate_density(visFr)
+    
+    surf_name, surf_count = visFr.pipeline.new_ds_name('surf', return_count=True)
+    
+    recipe = visFr.pipeline.recipe
+    mt = DelaunayMarchingTetrahedra(recipe, invalidate_parent=False, input=del_name, output=surf_name)
+    
+    if mt.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([mt,])
+
+        print('Isosurface generated, adding layer')
+        layer = TriangleRenderLayer(visFr.pipeline, dsname=surf_name, method='shaded', cmap = cm.solid_cmaps[surf_count % len(cm.solid_cmaps)])
+        visFr.add_layer(layer)
+        mt._invalidate_parent = True
+        print('Isosurface layer added')
+
+
+def Plug(visFr):
+    visFr.AddMenuItem('View', 'Add Octree Layer', lambda e : add_octree_layer(visFr))
+    visFr.AddMenuItem('View', 'Estimate density', lambda e: estimate_density(visFr))
+    visFr.AddMenuItem('View', 'Estimate density [circumcentres]', lambda e: estimate_circumcentre_densities(visFr))
+    visFr.AddMenuItem('View', 'Create Delaunay Tesselation', lambda e: add_tesselation_layer(visFr))
+    visFr.AddMenuItem('View', 'Generate Isosurface from Delaunay Tesselation', lambda e: gen_isosurface_from_tesselation(visFr))
+    visFr.AddMenuItem('Mesh', 'Generate Isosurface', lambda e: gen_isosurface(visFr))
+    visFr.AddMenuItem('Mesh', 'Generate Isosurface (linked)', lambda e: gen_octree_isosurface(visFr))
+    visFr.AddMenuItem('Mesh', 'Point distance isosurface ', lambda e: gen_point_dis_isosurface(visFr))
+    visFr.AddMenuItem('Mesh', 'Load mesh', lambda e: open_surface(visFr))
+    visFr.AddMenuItem('Mesh', 'Save mesh', lambda e: save_surface(visFr))
+    visFr.AddMenuItem('Mesh>Analysis', 'Distance to mesh', lambda e: distance_to_surface(visFr))

PYME/LMVis/Extras/fiducial.py

@@ -0,0 +1,230 @@
+from PYME.recipes.localisations import FiducialCorrection, DBSCANClustering
+from PYME.recipes.tablefilters import FilterTable, FilterTableByIDs
+
+import wx
+from PYME.IO.FileUtils import nameUtils
+
+# def drift_correct(pipeline):
+#     #pipeline=visgui.pipeline
+#
+#     recipe = pipeline.recipe
+#     recipe.add_module(FilterTable(recipe, inputName='Fiducials',
+#                                     outputName='filtered_fiducials', filters={'error_x':[0,10], 'sig': [330., 370.]}))
+#
+#     recipe.add_module(FiducialCorrection(recipe, inputLocalizations=pipeline.selectedDataSourceKey,
+#                                          inputFiducials='filtered_fiducials',
+#                                          outputName='corrected_localizations', outputFiducials='corrected_fiducials'))
+#
+#     recipe.execute()
+#     pipeline.selectDataSource('corrected_localizations')
+
+id_filter = None
+
+def drift_correct(pipeline):
+    global id_filter
+    import numpy as np
+    import matplotlib.pyplot as plt
+    #pipeline=visgui.pipeline
+
+    filters = {'error_x': [0, 10]}
+    if 'sig' in pipeline.keys():
+        dialog = wx.TextEntryDialog(None, 'Diameter (nm): ', 'Enter Fiducial Size', str(pipeline.mdh.getOrDefault('Analysis.FiducialSize', 1000)))
+
+        sig = [330., 370.]
+
+        if dialog.ShowModal() == wx.ID_OK:
+            size = float(dialog.GetValue())
+            sigE = float(np.sqrt((size/(np.sqrt(2)*2.35))**2 + 135.**2))  # Expected std of the bead + expected std of psf
+            sig = [0.95*sigE, 1.05*sigE]
+
+        filters['sig'] = sig
+
+    if 'fitError_z0' in pipeline.keys():
+        filters['fitError_z0'] = [0,30]
+
+    recipe = pipeline.recipe
+    filt_fiducials = FilterTable(recipe, inputName='Fiducials',
+                                  outputName='filtered_fiducials', filters=filters)
+    
+    filt_fiducials.configure_traits(kind='modal')
+    #print('Adding fiducial filter module')
+    #recipe.add_module(filt_fiducials)
+    
+    dbs = DBSCANClustering(recipe,inputName='filtered_fiducials', outputName='clumped_fiducials', columns=['x', 'y'],
+                                       searchRadius=500, minClumpSize=10, clumpColumnName='fiducialID')
+    recipe.add_modules_and_execute([filt_fiducials, dbs])
+    
+    
+    fids = recipe.namespace['clumped_fiducials']
+    
+    fid_ids = [int(id) for id in set(fids['fiducialID']) if id > 0]
+        
+    id_filter = FilterTableByIDs(recipe, inputName='clumped_fiducials', outputName='selected_fiducials',
+                      idColumnName='fiducialID', ids = fid_ids)
+    
+    #recipe.add_module(id_filter)
+    
+    fc = FiducialCorrection(recipe, inputLocalizations=pipeline.selectedDataSourceKey,
+                                         inputFiducials='selected_fiducials',
+                                         outputName='corrected_localizations', outputFiducials='corrected_fiducials')
+    
+    recipe.add_modules_and_execute([id_filter, fc])
+    pipeline.selectDataSource('corrected_localizations')
+    
+
+def manual_selection(pipeline):
+    import matplotlib.pyplot as plt
+    recipe = pipeline.recipe
+    
+    fids = recipe.namespace['clumped_fiducials']
+    
+    fid_ids = [int(id) for id in set(fids['fiducialID']) if id > 0]
+    
+    fid_positions = {}
+    
+    plt.figure()
+    
+    for fid_id in fid_ids:
+        mask = fids['fiducialID'] == fid_id
+        xc = fids['x'][mask].mean()
+        yc = fids['y'][mask].mean()
+        fid_positions[fid_id] = (xc, yc)
+        
+        plt.plot(xc, yc, 'x')
+        plt.text(xc + 50, yc + 50, '%d' % fid_id)
+        
+        plt.axis('equal')
+        plt.xlim(pipeline.imageBounds.x0, pipeline.imageBounds.x1)
+        plt.ylim(pipeline.imageBounds.y0, pipeline.imageBounds.y1)
+
+    id_filter.configure_traits()
+    recipe.execute()
+    
+def load_fiducial_info_from_second_file(pipeline):
+    msg = '''New analyses should fit fiducials at the same time as the localisations and not use this function.
+    When using this function, the raw localizations of all fiducials should be loaded and not a pre-filtered version'''
+    if wx.MessageBox(msg, 'Info', style=wx.OK|wx.CANCEL) != wx.OK:
+        return
+    
+    filename = wx.FileSelector("Choose a file to open",
+                               nameUtils.genResultDirectoryPath(),
+                               default_extension='h5r',
+                               wildcard='PYME Results Files (*.h5r)|*.h5r|Tab Formatted Text (*.txt)|*.txt|Matlab data (*.mat)|*.mat|Comma separated values (*.csv)|*.csv')
+    
+    #print filename
+    if not filename == '':
+        pipeline.OpenChannel(filename, channel_name='Fiducials')
+    
+    
+def fiducial_diagnosis_1(pipeline):
+    import numpy as np
+    import matplotlib.pyplot as plt
+    
+    fids = pipeline.datasources['corrected_fiducials']
+    ci = fids['clumpIndex']
+    
+    cis = np.arange(1, ci.max())
+    
+    clump_lengths =  [(ci==c).sum() for c in cis]
+    
+    largest_clump = ci == cis[np.argmax(clump_lengths)]
+    
+    x_c = fids['x'][largest_clump]
+    y_c = fids['y'][largest_clump]
+    
+    plt.figure()
+    
+    plt.hist(x_c - x_c.mean())
+
+
+def fiducial_diagnosis(pipeline):
+    import numpy as np
+    import matplotlib.pyplot as plt
+    
+    fids = pipeline.dataSources['corrected_fiducials']
+    ci = fids['clumpIndex']
+    
+    #cis = np.arange(1, ci.max())
+    
+    #clump_lengths = [(ci == c).sum() for c in cis]
+    
+    #largest_clump = ci == cis[np.argmax(clump_lengths)]
+    
+    #x_c = fids['x'][largest_clump]
+    #y_c = fids['y'][largest_clump]
+    
+    f1 = plt.figure()
+    a1 = plt.axes()
+    plt.title('Y residuals')
+    plt.grid()
+    
+    f2 = plt.figure()
+    plt.title('X residuals')
+    a2 = plt.axes()
+    plt.grid()
+
+    f3 = plt.figure()
+    plt.title('Z residuals')
+    a3 = plt.axes()
+    plt.grid()
+
+    for i in range(1, ci.max()):
+        mask = fids['clumpIndex'] == i
+        if mask.sum() > 0:
+            f_id = fids['fiducialID'][mask][0]
+            
+            fid_m = fids['fiducialID'] == f_id
+            
+            ym= fids['y'][fid_m].mean()
+            xm = fids['x'][fid_m].mean()
+            zm = fids['z'][fid_m].mean()
+            
+            a1.plot(fids['t'][mask], fids['y'][mask] - ym + f_id * 50,
+                 color=plt.cm.hsv( (i % 20.0)/20.))
+
+            a2.plot(fids['t'][mask], fids['x'][mask] - xm + f_id * 50,
+                    color=plt.cm.hsv((i % 20.0) / 20.))
+
+            a3.plot(fids['t'][mask], fids['z'][mask] - zm + f_id * 50,
+                    color=plt.cm.hsv((i % 20.0) / 20.))
+    
+    plt.figure()
+    plt.subplot(311)
+    plt.plot(pipeline['t'], pipeline['driftz'])
+    plt.title('Z drift from focus lock')
+    plt.subplot(312)
+    plt.plot(pipeline['t'], pipeline['driftx'])
+    plt.title('x drift from focus lock')
+    plt.subplot(313)
+    plt.plot(pipeline['t'], pipeline['drifty'])
+    plt.title('Y drift from focus lock')
+    
+    #plt.hist(x_c - x_c.mean())
+    
+    
+def drift_auto_corr(visFr):
+    from PYME.recipes import localisations
+    recipe = visFr.pipeline.recipe
+    
+    pipeline = visFr.pipeline
+    
+    m = localisations.AutocorrelationDriftCorrection(recipe, inputName=pipeline.selectedDataSourceKey,
+                                                     outputName='corrected_localizations')
+    
+    if m.configure_traits(kind='modal'):
+        recipe.add_modules_and_execute([m,])
+        
+        pipeline.selectDataSource('corrected_localizations')
+        #visFr.CreateFoldPanel() #TODO: can we capture this some other way?
+
+
+def Plug(visFr):
+    def correct():
+        drift_correct(visFr.pipeline)
+        #visFr.CreateFoldPanel()
+    
+    visFr.AddMenuItem('Corrections>Fiducials', 'Correct', lambda e : correct())
+    visFr.AddMenuItem('Corrections>Fiducials', 'Display correction residuals', lambda e: fiducial_diagnosis(visFr.pipeline))
+    visFr.AddMenuItem('Corrections>Fiducials', 'Manual selection', lambda e: manual_selection(visFr.pipeline))
+    visFr.AddMenuItem('Corrections>Fiducials', 'Load fiducial fits from 2nd file', lambda e: load_fiducial_info_from_second_file(visFr.pipeline))
+    visFr.AddMenuItem('Corrections', 'Autocorrelation based drift correction', lambda e : drift_auto_corr(visFr))

PYME/LMVis/Extras/flagZMotionArtifacts.py

@@ -0,0 +1,60 @@
+
+##################
+# flagZMotionArtifacts.py
+#
+# Copyright David Baddeley, Andrew Barentine
+# david.baddeley@yale.edu
+#
+# 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 logging
+
+logger = logging.getLogger(__name__)
+
+
+
+
+class motionFlagger:
+    """
+    Class with methods to flag localizations for filtering with respect to information stored in the events table
+    """
+    def __init__(self, visFr):
+        self.pipeline = visFr.pipeline
+
+
+        logging.debug('Adding menu items for event filters')
+
+        visFr.AddMenuItem('Corrections', 'Identify transient frames', self.OnIDTransient,
+                          helpText='Toss frames acquired during pifoc translation')
+
+
+    def OnIDTransient(self, event=None):
+        """
+        Adds an 'isTransient' column to the input datasource so that one can filter localizations that are from frames
+        acquired during z-translation
+        """
+        from PYME.experimental import zMotionArtifactUtils
+        mask = zMotionArtifactUtils.flagMotionArtifacts(self.pipeline.selectedDataSource, self.pipeline.events,
+                                           self.pipeline.mdh['StackSettings.FramesPerStep'])
+                                           
+        self.pipeline.selectedDataSource.addColumn('piezoUnstable', mask)
+        #eventFilterUtils.idTransientFrames(self.pipeline.selectedDataSource, self.pipeline.events,
+        #                                   self.pipeline.mdh['StackSettings.FramesPerStep'])
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.eventfilters = motionFlagger(visFr)
+

PYME/LMVis/Extras/fusionUtils.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jul  9 00:54:27 2015
+
+@author: david
+"""
+
+def Plug(dsviewer):
+    pass