PYME-extra 1.0.4.post0__py3-none-any.whl

PYMEcs/experimental/clusterTrack.py

@@ -0,0 +1,179 @@
+import numpy as np
+import sys
+from scipy import ndimage
+import matplotlib.pyplot as plt
+
+import logging
+logger = logging.getLogger(__file__)
+
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float
+from traitsui.api import View, Item, Group
+from traitsui.menu import OKButton, CancelButton, OKCancelButtons
+
+class FilterChoice(HasTraits):
+    windowSize = Int(11)
+    filterType = Enum(['Gaussian','Median'])
+    funcmap = {
+        'Gaussian' : ndimage.gaussian_filter1d,
+        'Median'   : ndimage.median_filter}
+    
+    def get_filter(self):
+        
+        def filterfunc(data):
+            return self.funcmap[self.filterType](data,self.windowSize)
+
+        return filterfunc
+    
+class GetTime(HasTraits):
+    alignmentTime = Int(0)
+    averagePeriod = Int(50)
+
+def zeroshift(t,data,navg=50, alignmentTime=0):
+    ti,idx = np.unique(t.astype('int'),return_index=True)
+    di = data[idx]
+    if alignmentTime<0:
+        alignmentTime = 0
+    nmin = min(alignmentTime,di.shape[0])
+    nmax = min(alignmentTime+navg,di.shape[0])
+    offset = di[nmin:nmax].mean()
+    return data - offset
+
+def atLeastRange(rmin=-20,rmax=-20):
+    ymin,ymax = plt.ylim()
+    if ymin > rmin:
+        plt.ylim(ymin=rmin)
+    if ymax < rmax:
+        plt.ylim(ymax=rmax)
+
+class ClusterTracker:
+    """
+
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+        self.clusterTracks = []
+        self.alignmentTime = 0
+        self.averagePeriod = 50
+
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'DBSCAN Clump', self.OnClumpDBSCAN,
+                          helpText='Calculate ClumpIndex using DBSCAN algorithm')
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'Track Clumps', self.OnTrackClumps,
+                          helpText='extract the tracks for all clusters (clumps) that we found')
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'Plot Tracks', self.OnShowTracks,
+                          helpText='plot tracks of clusters (clumps) that we found')
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'Plot Tracks Filtered', self.OnShowTracksFiltered,
+                          helpText='plot filtered tracks of clusters (clumps) that we found')
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'Clear Tracks', self.OnClearTracks,
+                          helpText='clear tracks from memory')
+        visFr.AddMenuItem('Experimental>Deprecated>Clusters', 'Set Alignment Time', self.OnSetAlignmentTime,
+                          helpText='set alignment time')
+        
+
+    def OnClumpDBSCAN(self, event=None):
+        """
+        Runs sklearn DBSCAN clustering algorithm on pipeline filtered results using the GUI defined in the DBSCAN
+        recipe module.
+
+        Args are user defined through GUI
+            searchRadius: search radius for clustering
+            minClumpSize: number of points within eps required for a given point to be considered a core point
+
+        This version is generally used to identify clumps identifying fiduciaries and therefore the
+        default searchRadius is set fairly generous.
+        """
+        from PYMEcs.recipes import localisations
+
+        clumper = localisations.DBSCANClustering2(minClumpSize = 50, searchRadius = 20.0)
+        if clumper.configure_traits(kind='modal'):
+            namespace = {clumper.inputName: self.pipeline}
+            clumper.execute(namespace)
+
+            self.pipeline.addColumn(clumper.outputName, namespace[clumper.outputName]['dbscanClumpID'])
+
+    def OnTrackClumps(self, event=None):
+        pipeline = self.pipeline
+        from PYMEcs.recipes import localisations
+        clumper = localisations.DBSCANClustering2()
+        clusterID = clumper.outputName
+
+        if not clusterID in pipeline.keys():
+            logger.error('Cannot find column %s in pipeline' % clusterID)
+            return
+
+        clusterIDs = pipeline[clusterID].astype('int')
+        idmax = max(clusterIDs)
+       
+        for id in range(1,idmax+1):
+            thiscluster = clusterIDs == id 
+            t_id = pipeline['t'][thiscluster]
+            x_id = pipeline['x'][thiscluster]
+            y_id = pipeline['y'][thiscluster]
+            z_id = pipeline['z'][thiscluster]
+            I = np.argsort(t_id)
+            self.clusterTracks.append([t_id[I],x_id[I],y_id[I],z_id[I]])
+
+
+    def OnShowTracks(self, event=None):
+        import matplotlib.pyplot as plt
+        if len(self.clusterTracks) > 0:
+            navg = self.averagePeriod
+            atime = self.alignmentTime
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,zeroshift(t,x, navg, atime))
+            plt.title('x tracks')
+            atLeastRange(-20,20)
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,zeroshift(t,y, navg, atime))
+            plt.title('y tracks')
+            atLeastRange(-20,20)
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,zeroshift(t,z, navg, atime))
+            plt.title('z tracks')
+            atLeastRange(-20,20)
+
+    def OnShowTracksFiltered(self, event=None):
+        import matplotlib.pyplot as plt
+        fc = FilterChoice()
+        if len(self.clusterTracks) > 0 and fc.configure_traits(kind='modal'):
+            navg = self.averagePeriod
+            atime = self.alignmentTime
+            filterfunc = fc.get_filter()
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,filterfunc(zeroshift(t,x, navg, atime)))
+            plt.title('x tracks')
+            atLeastRange(-20,20)
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,filterfunc(zeroshift(t,y, navg, atime)))
+            plt.title('y tracks')
+            atLeastRange(-20,20)
+            plt.figure()
+            for entry in self.clusterTracks:
+                t,x,y,z = entry
+                plt.plot(t,filterfunc(zeroshift(t,z, navg, atime)))
+            plt.title('z tracks')
+            atLeastRange(-20,20)
+
+    def OnClearTracks(self, event=None):
+        self.clusterTracks = []
+
+    def OnSetAlignmentTime(self, event=None):
+        gtime = GetTime()
+        if gtime.configure_traits(kind='modal'):
+            self.alignmentTime = gtime.alignmentTime
+            self.averagePeriod = gtime.averagePeriod
+            
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.clusterTracker = ClusterTracker(visFr)
+

PYMEcs/experimental/combine_maps.py

@@ -0,0 +1,104 @@
+import wx
+import os.path
+
+
+def on_map(image, parentWindow=None, glCanvas=None):
+    from PYME.Analysis import gen_sCMOS_maps
+    from PYME.DSView import ViewIm3D
+    from PYMEcs.Analysis.MapUtils import combine_maps
+
+    # combine maps with dialogue here
+    # also show valid map
+
+    with wx.FileDialog(parentWindow, "Choose maps", wildcard='TIFF (*.tif)|*.tif',
+                       style=wx.FD_OPEN | wx.FD_MULTIPLE) as dialog:
+
+        if dialog.ShowModal() == wx.ID_CANCEL:
+            return
+
+        filelist = dialog.GetPaths()
+
+        combinedMap, vMap = combine_maps(filelist,return_validMap=True)
+
+        if combinedMap.mdh['CameraMap.Type'] == 'mean':
+            mapType = 'dark'
+        elif combinedMap.mdh['CameraMap.Type'] == 'variance':
+            mapType = 'variance'
+            
+    if mapType == 'dark':
+        ViewIm3D(combinedMap, title='Dark Map', parent=parentWindow, glCanvas=glCanvas)
+    else:
+        ViewIm3D(combinedMap, title='Variance Map', parent=parentWindow, glCanvas=glCanvas)
+
+    ViewIm3D(vMap, title='Valid Regions', parent=parentWindow, glCanvas=glCanvas)
+    
+    if mapType == 'dark':
+        mapname = gen_sCMOS_maps.mkDefaultPath('dark', combinedMap.mdh)
+    else:
+        mapname = gen_sCMOS_maps.mkDefaultPath('variance', combinedMap.mdh)
+
+    # on windows we may need to pass the full path to defaultFile to force selecting the
+    # directory we want; otherwise the last used directory may be used on some
+    # windows 7+ installs, see also https://forums.wxwidgets.org/viewtopic.php?t=44404
+    import platform
+    if platform.system() == 'Windows':
+        fname = mapname
+    else:
+        fname = os.path.basename(mapname)
+    map_dlg = wx.FileDialog(parentWindow, message="Save dark map as...",
+                            defaultDir=os.path.dirname(mapname),
+                            defaultFile=fname, 
+                            wildcard='TIFF (*.tif)|*.tif', 
+                            style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+    
+    if map_dlg.ShowModal() == wx.ID_OK:
+        mapfn = map_dlg.GetPath()
+        combinedMap.Save(filename=mapfn)
+
+from PYME.recipes.batchProcess import bake
+from PYME.recipes import modules
+import os
+
+def on_bake(image, parentWindow=None, glCanvas=None):
+    with wx.FileDialog(parentWindow, "Choose all series", wildcard='H5 (*.h5)|*.h5',
+                       style=wx.FD_OPEN | wx.FD_MULTIPLE) as dialog:
+
+        if dialog.ShowModal() == wx.ID_CANCEL:
+            return
+
+        filelist = dialog.GetPaths()
+        
+    inputGlobs = {'input' : filelist}
+    map_dir = os.path.dirname(filelist[0])
+    output_dir = os.path.join(map_dir,'analysis')
+     
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    recipe_str = """
+- processing.DarkAndVarianceMap:
+    input: input
+    output_dark: dark
+    output_variance: variance
+- output.ImageOutput:
+    filePattern: '{output_dir}/{file_stub}_dark.tif'
+    inputName: dark
+- output.ImageOutput:
+    filePattern: '{output_dir}/{file_stub}_variance.tif'
+    inputName: variance
+"""
+
+    try:
+        recipe = modules.ModuleCollection.fromYAML(recipe_str)
+    except AttributeError:
+        from PYME.recipes.recipe import Recipe
+        recipe = Recipe.fromYAML(recipe_str)
+        
+    bake(recipe, inputGlobs, output_dir)
+
+
+def Plug(dsviewer):
+    dsviewer.AddMenuItem(menuName='Experimental>Map Tools', itemName='Analyse tiled ROI Map Series',
+                         itemCallback = lambda e : on_bake(dsviewer.image, dsviewer, dsviewer.glCanvas))
+    dsviewer.AddMenuItem(menuName='Experimental>Map Tools', itemName='Combine tiled ROI Maps',
+                         itemCallback = lambda e : on_map(dsviewer.image, dsviewer, dsviewer.glCanvas))

PYMEcs/experimental/eventProcessing.py

@@ -0,0 +1,93 @@
+import matplotlib.pyplot as plt
+from PYMEcs.pyme_warnings import warn
+
+class EventProcessing:
+    """
+    plugins to conduct some event processing from events in h5r data
+    currently mostly using events from Piezobased tracking
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+
+        visFr.AddMenuItem('Experimental',
+                          'Display Piezo events in h5r file',
+                          self.OnDisplayEvents,
+                          helpText='display recorded events (in the PYMEAcquire sense) from an h5r file')
+
+    def OnDisplayEvents(self, event=None):
+        from PYME.Analysis import piecewiseMapping
+        p = self.pipeline
+
+        if p.events is None:
+            warn('No events in pipeline')
+            return
+        
+        offupd = piecewiseMapping.GeneratePMFromEventList(p.events, p.mdh, p.mdh.getEntry('StartTime'), 0, b'PiezoOffsetUpdate',0)
+        tminutes = offupd.xvals * p.mdh['Camera.CycleTime'] / 60.0
+
+        offsets = piecewiseMapping.GeneratePMFromEventList(p.events, p.mdh, p.mdh.getEntry('StartTime'), 0, b'PiezoOffset',0)
+        correlamp = piecewiseMapping.GeneratePMFromEventList(p.events, p.mdh, p.mdh.getEntry('StartTime'), 0, b'CorrelationAmplitude',0)
+        
+        has_offsets = offsets.yvals.size > 0
+        has_offupd = offupd.yvals.size > 0 # not using this one at the moment
+        has_correlamp = correlamp.yvals.size > 0
+        has_drift = 'driftx' in p.keys()
+
+        plot_rows = 0
+        if has_offsets:
+            plot_rows += 1
+        if has_correlamp:
+            plot_rows += 1
+        if has_drift:
+            plot_rows += 3
+
+        row = 1
+        fig, axs = plt.subplots(nrows=plot_rows,figsize=(6.4,6.4), num='OffsetPiezo Event Analysis')
+        if has_drift:
+            plt.subplot(plot_rows,1,row)
+            plt.plot(p['t'],p['driftx'])
+            plt.title('Drift in x (nm)')
+            plt.ylabel('Drift')
+            plt.subplot(plot_rows,1,row+1)
+            plt.plot(p['t'],p['drifty'])
+            plt.title('Drift in y (nm)')
+            plt.ylabel('Drift')
+            plt.subplot(plot_rows,1,row+2)
+            plt.plot(p['t'],1e3*p['driftz']) # is driftz in um?
+            plt.title('Drift in z (nm)')
+            plt.ylabel('Drift')
+            row += 3
+
+        if has_offsets:
+            offsVSt = offsets(p['t']-0.01)
+            plt.subplot(plot_rows,1,row)
+            plt.plot(p['t'],offsVSt)
+            plt.xlabel('time (frame number)')
+            plt.ylabel('offset (um)')
+            plt.title('OffsetPiezo offsets from PiezoOffset events')
+            row += 1
+
+        if has_correlamp:
+            campVSt = correlamp(p['t']-0.01)
+            plt.subplot(plot_rows,1,row)
+            plt.plot(p['t'],campVSt)
+            plt.xlabel('time (frame number)')
+            plt.ylabel('amp')
+            plt.title('normalised correlation amplitude')
+            plt.ylim(0.3,1.2)
+            axs[-1].set_yticks([0.75],minor=True)
+            plt.grid(which='both',axis='y')
+            row += 1
+
+        plt.tight_layout()
+
+            #plt.step(tminutes,offupd.yvals,where='post')
+            #plt.xlabel('time (minutes)')
+            #plt.ylabel('OffsetPiezo offset (um)')
+            #plt.title('OffsetPiezo offsets from PiezoOffsetUpdate events')
+
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    EventProcessing(visFr)

PYMEcs/experimental/fiducials.py

@@ -0,0 +1,323 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jun 30 10:24:45 2015
+
+@author: Kenny
+"""
+
+# this is Kenny's code with minimal changes to run as standonlone plugin
+# using the new PYME.config system
+
+# mostly used as a comparison to the newer recipe based implementation
+# will be dropped once the recipe based version is complete
+
+import wx
+import numpy as np
+from scipy import ndimage
+from collections import OrderedDict
+
+import logging
+logger = logging.getLogger(__name__)
+
+def foffset(t,ft,navg=100):
+    tu,idx = np.unique(t.astype('int'), return_index=True)
+    fu = ft[idx]
+    offs = fu[0:min(navg,fu.shape[0])].mean()
+    return offs
+
+def makeFilter(filtFunc):
+    '''wrapper function for different filters'''
+    def ffcn(t, data, scale):
+        out = {}
+        for k, v in data.items():
+            r_v = v[~np.isnan(v)]
+            r_t = t[~np.isnan(v)]
+            out[k] = filtFunc(np.interp(t, r_t, r_v), scale)
+        return out
+    return ffcn
+    
+FILTER_FUNCS = {
+    'Gaussian' : makeFilter(ndimage.gaussian_filter),
+    'Uniform' : makeFilter(ndimage.uniform_filter),
+    'Median' : makeFilter(ndimage.median_filter)
+    } 
+
+def _extractAverageTrajectory(pipeline, clumpRadiusVar = 'error_x', clumpRadiusMultiplier=5.0, 
+                                  timeWindow=25, filter='Gaussian', filterScale=10.0):
+                                      
+    #import PYME.Analysis.trackUtils as trackUtils
+    import PYME.Analysis.points.DeClump.deClump as deClump
+    from scipy.optimize import fmin
+    #track beads through frames
+    if clumpRadiusVar == '1.0':
+        delta_x = 0*pipeline['x'] + clumpRadiusMultiplier
+    else:
+        delta_x = clumpRadiusMultiplier*pipeline[clumpRadiusVar]
+        
+    t = pipeline['t'].astype('i')
+    x = pipeline['x'].astype('f4')
+    y = pipeline['y'].astype('f4')
+    delta_x = delta_x.astype('f4')
+    
+    I = np.argsort(t)
+
+    clumpIndex = np.zeros(len(x), dtype='i')
+    clumpIndex[I] = deClump.findClumpsN(t[I], x[I], y[I], delta_x[I], timeWindow)
+    #trackUtils.findTracks(pipeline, clumpRadiusVar,clumpRadiusMultiplier, timeWindow)
+    
+    #longTracks = pipeline['clumpSize'] > 50            
+    
+    #x = x[longTracks].copy()
+    #y = pipeline['y_raw'][longTracks].copy()
+    #t = pipeline['t'][longTracks].copy() #.astype('i')
+    #clumpIndex = pipeline['clumpIndex'][longTracks].copy()
+    
+    tMax = t.max()
+    
+    clumpIndices = list(set(clumpIndex))
+
+    x_f = []
+    y_f = []
+    clump_sizes = []
+    
+    t_f = np.arange(0, tMax + 1, dtype='i')
+    
+    #loop over all our clumps and extract trajectories
+    for ci in clumpIndices:
+        if ci > 0:
+            clump_mask = (clumpIndex == ci)
+            x_i = x[clump_mask]
+            clump_size = len(x_i)
+            
+            if clump_size > 50:
+                y_i = y[clump_mask]
+                t_i = t[clump_mask].astype('i')
+                
+                x_i_f = np.NaN*np.ones_like(t_f)
+                x_i_f[t_i]= x_i - x_i.mean()
+                
+                y_i_f = np.NaN*np.ones_like(t_f)
+                y_i_f[t_i]= y_i - y_i.mean()
+                
+                #clumps.append((x_i_f, y_i_f))
+                x_f.append(x_i_f)
+                y_f.append(y_i_f)
+                clump_sizes.append(len(x_i))
+    
+    #re-order to start with the largest clump
+    clumpOrder = np.argsort(clump_sizes)[::-1]
+    x_f = np.array(x_f)[clumpOrder,:]
+    y_f = np.array(y_f)[clumpOrder,:]
+    
+    def _mf(p, meas):
+        '''calculate the offset between trajectories'''
+        m_adj = meas + np.hstack([[0], p])[:,None]
+        
+        return np.nansum(np.nanvar(m_adj, axis=0))
+        
+    #print x_f.shape, np.hstack([[0], np.random.randn(x_f.shape[0]-1)]).shape
+        
+    def _align(meas, tol=.1):
+        n_iters = 0
+        
+        dm_old = 5e12
+        dm = 4e12
+        
+        mm = np.nanmean(meas, 0)
+        
+        while ((dm_old - dm) > tol) and (n_iters < 50):  
+            dm_old = dm
+            mm = np.nanmean(meas, 0)        
+            d = np.nanmean(meas - mm, 1)
+            dm = sum(d**2)
+            meas = meas - d[:,None]
+            n_iters +=1
+            print(n_iters, dm)
+         
+        mm = np.nanmean(meas, 0)
+        print('Finished:', n_iters, dm)
+        return mm
+        
+    x_corr = _align(x_f)
+    y_corr = _align(y_f)
+     
+    filtered_corr = FILTER_FUNCS[filter](t_f, {'x' : x_corr, 'y':y_corr}, filterScale)
+    
+    return t_f, filtered_corr
+
+class FiducialAnalyser:
+    def __init__(self, visFr):
+        self.visFr = visFr
+
+        visFr.AddMenuItem('Experimental>Deprecated>FiducialsOld', "Estimate drift from Fiducials", self.FindBeadsAndTrack)
+        visFr.AddMenuItem('Experimental>Deprecated>FiducialsOld', 'Apply fiducial correction', self.OnApplyFiducial,
+                          helpText='Apply fiducial to x, y, z')
+        visFr.AddMenuItem('Experimental>Deprecated>FiducialsOld', 'Revert fiducial correction', self.OnRevertFiducial,
+                          helpText='Revert fiducial correction to x, y, z')
+
+    def FindBeadsAndTrack(self, event):      
+        dlg = ExtractTrajectoriesDialog(self.visFr)
+        succ = dlg.ShowModal()
+        if succ == wx.ID_OK:
+            pipeline = self.visFr.pipeline
+            
+            beadTraj = _extractAverageTrajectory(pipeline, dlg.GetClumpRadiusVariable(),
+                                                 dlg.GetClumpRadiusMultiplier(), dlg.GetClumpTimeWindow(),
+                                                 filter=dlg.GetFilterMethod(),filterScale=dlg.GetFilterScale())
+
+            self.ApplyCorrections([beadTraj,])
+                
+    def ApplyCorrections(self, interpInfos):
+        """Averages drift from multiple files.
+        Adds the drift as fiducial_? to pipeline.inputMapping.
+        Overwrites the drift panel with ? + fiducial_?
+        """
+        pipeline = self.visFr.pipeline
+        count = len(interpInfos)
+        #master dim key list assuming first file is correct
+        dims = interpInfos[0][1].keys()
+        
+        #loop over data sources and add drift info to each
+        logger.debug('about to update datasources...')
+        curds = pipeline.selectedDataSourceKey
+        for dsname in pipeline.dataSources:
+            logger.debug('updating datasource %s' % dsname)
+            pipeline.selectDataSource(dsname)
+            tCache = pipeline['t']
+            fudical_multi = np.zeros((count, len(dims), len(tCache))) #num of files, num of dims, num of time points
+            for i, j in enumerate(interpInfos):
+                realTime, filtered = j
+                for k, l in enumerate(dims):
+                    print(l)
+                    fudical_multi[i, k, :] = np.interp(tCache, realTime, filtered[l])
+                
+            fuducial_mean = fudical_multi.mean(0)
+            for i, dim in enumerate(dims):
+                fiducial = 'fiducial_%s' % dim
+                pipeline.addColumn(fiducial, fuducial_mean[i,:]-foffset(tCache,fuducial_mean[i,:]))
+                logger.debug('setting attribute %s' % fiducial)
+            pipeline.Rebuild()
+        pipeline.selectDataSource(curds)
+
+    def OnApplyFiducial(self, event=None):
+        pipeline = self.visFr.pipeline
+        for dim in ('x','y','z'):
+            fiducial = 'fiducial_%s' % dim
+            if fiducial in pipeline.keys():
+                pipeline.mapping.setMapping(dim,'%s - %s' % (dim, fiducial))
+        pipeline.Rebuild()
+
+    def OnRevertFiducial(self, event=None):
+        pipeline = self.visFr.pipeline
+        changed = False
+        for dim in ('x','y','z'):
+            if dim in pipeline.mapping.mappings:
+                pipeline.mapping.mappings.pop(dim)
+                changed = True
+        if changed:
+            pipeline.Rebuild()
+
+    def Calculate(self, func, arg):
+        """Returns tuple of 3 objects.
+        realTime: arange from 0 to max time
+        interp: interpolated x, y, z
+        filtered: 'interp' filtered using the given filter function
+        """
+        pipeline = self.visFr.pipeline
+        
+        realTime = np.arange(0, pipeline['t'].max())
+        
+        interp = OrderedDict()
+        filtered = OrderedDict()
+        for dim in ['x', 'y', 'z']:
+#            print(dim)
+            if dim in pipeline.keys():
+                interp[dim] = np.interp(realTime, pipeline['t'], pipeline[dim])
+                filtered[dim] = func(interp[dim], arg)
+        
+        
+        return (realTime, interp, filtered)
+    
+        
+class ExtractTrajectoriesDialog(wx.Dialog):
+    def __init__(self, *args, **kwargs):
+        wx.Dialog.__init__(self, *args, **kwargs)
+
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+
+        hsizer.Add(wx.StaticText(self, -1, 'Clump Radius: '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        self.tClumpRadMult = wx.TextCtrl(self, -1, '5.0', size=[30,-1])
+        hsizer.Add(self.tClumpRadMult, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'X'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        self.cClumpRadVar = wx.Choice(self, -1, choices=['1.0', 'error_x'])
+        self.cClumpRadVar.SetSelection(1)
+        hsizer.Add(self.cClumpRadVar,1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        
+        vsizer.Add(hsizer, 0, wx.ALL, 5)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, 'Time Window: '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        self.tClumpTime = wx.TextCtrl(self, -1, '25')
+        hsizer.Add(self.tClumpTime,1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        vsizer.Add(hsizer, 0, wx.ALL, 5)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, wx.ID_ANY, 'filter:'), 1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.filter = wx.Choice(self, wx.ID_ANY, choices=['Gaussian', 'Uniform', 'Median'])
+        self.filter.SetSelection(0)
+        #self.filter.Bind(wx.EVT_CHOICE, self.OnFilterSelected)            
+        hsizer.Add(self.filter, 1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        
+        
+        vsizer.Add(hsizer)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.argText = wx.StaticText(self, wx.ID_ANY, 'Filter scale:')
+        hsizer.Add(self.argText, 1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.filtScale = wx.TextCtrl(self, wx.ID_ANY, '10')
+        hsizer.Add(self.filtScale, 1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        vsizer.Add(hsizer)
+
+        btSizer = wx.StdDialogButtonSizer()
+
+        btn = wx.Button(self, wx.ID_OK)
+        btn.SetDefault()
+
+        btSizer.AddButton(btn)
+
+        btn = wx.Button(self, wx.ID_CANCEL)
+
+        btSizer.AddButton(btn)
+
+        btSizer.Realize()
+
+        vsizer.Add(btSizer, 0, wx.ALL, 5)
+
+        self.SetSizerAndFit(vsizer)
+
+    def GetClumpRadiusMultiplier(self):
+        return float(self.tClumpRadMult.GetValue())
+
+    def GetClumpRadiusVariable(self):
+        return self.cClumpRadVar.GetStringSelection()
+
+    def GetClumpTimeWindow(self):
+        return int(self.tClumpTime.GetValue())
+    
+    def GetFilterMethod(self):
+        return self.filter.GetStringSelection()
+    
+    def GetFilterScale(self):
+        return float(self.filtScale.GetValue())
+
+
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    visFr.experimentalFiducialAnalyzer = FiducialAnalyser(visFr)