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

PYMEcs/experimental/Simpler.py

@@ -0,0 +1,369 @@
+from traitsui.api import View, Item, Group
+from traitsui.menu import OKButton, CancelButton, OKCancelButtons
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float, Bool
+
+
+#from PYME.DSView.dsviewer import View3D
+#from PYME.IO.MetaDataHandler import NestedClassMDHandler
+
+import numpy as np
+import wx
+
+def rendHistw(x,y, imageBounds, pixelSize, weights=None):
+    X = np.arange(imageBounds.x0, imageBounds.x1 + 1.01*pixelSize, pixelSize)
+    Y = np.arange(imageBounds.y0, imageBounds.y1 + 1.01*pixelSize, pixelSize)
+    
+    im, edx, edy = np.histogram2d(x,y, bins=(X,Y), weights=weights)
+
+    return im
+
+
+from PYME.LMVis.renderers import ColourRenderer
+class BackgroundHistogramRenderer(ColourRenderer):
+    """2D background histogram rendering"""
+
+    name = 'Histogram Background'
+    mode = 'histogram'
+
+    def genIm(self, settings, imb, mdh):
+        im_hist = rendHistw(self.colourFilter['x'],self.colourFilter['y'], imb, settings['pixelSize'])
+        im_background = rendHistw(self.colourFilter['x'],self.colourFilter['y'], imb, settings['pixelSize'],
+                                  weights=self.colourFilter['fitResults_background'])
+        Inds = im_hist > 0
+        im_bgmean = np.zeros_like(im_background)
+        im_bgmean[Inds] = im_background[Inds]/im_hist[Inds]
+
+        return im_bgmean
+
+def voxelsize_mdh(pixelsize_nm):
+    from PYME.IO.MetaDataHandler import NestedClassMDHandler
+    
+    mdh = NestedClassMDHandler()
+
+    #voxelsize
+    mdh.setEntry('voxelsize.x',1e-3*pixelsize_nm)
+    mdh.setEntry('voxelsize.y',1e-3*pixelsize_nm)
+    mdh.setEntry('voxelsize.z',0.2)
+    mdh.setEntry('voxelsize.units','um')
+
+    return mdh
+
+class InterpolChoice(HasTraits):
+    InterpolationMethod = Enum(['Splines','Radial Basis functions','Constraint Model'])
+
+import wx
+#import deClump
+#from pylab import *
+#import numpy as np
+
+class simplerFilterDialog(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, '2.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, 'Minimum Clump Size (post filter): '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        self.tClumpMin = wx.TextCtrl(self, -1, '3')
+        hsizer.Add(self.tClumpMin,1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        vsizer.Add(hsizer, 0, wx.ALL, 5)
+
+        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 GetClumpMinSize(self):
+        return int(self.tClumpMin.GetValue())
+
+
+    
+# things still to add
+# - done -  "Filter events for SIMPLER": choose clump radius and min clumpsize interactively
+# - new function to calculate N0 from data background
+# - done - new function to insert SIMPLERzgenerator
+# - add error estimates for SIMPLER (combination of formula and/or stddev) -> do in recipe module
+class SIMPLER():
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.intMeth = InterpolChoice()
+        # pass visFr = None in constructor to avoid autogenerated menu entry
+        self.bgrend = BackgroundHistogramRenderer(visFr=None,pipeline=visFr.pipeline,mainWind=visFr)
+        # note we need to set the visFr posthoc so that rendering works as expected
+        self.bgrend.visFr = visFr
+        
+        # entries to set N0
+        visFr.AddMenuItem('Experimental>SIMPLER', "Set N0 from Image Map", self.OnN0FromImage)
+        visFr.AddMenuItem('Experimental>SIMPLER', "Set N0 from Interpolation Map", self.OnN0FromIinterpolationField)
+        visFr.AddMenuItem('Experimental>SIMPLER', itemType='separator')
+        # entries for next steps in SIMPLER calculations
+        visFr.AddMenuItem('Experimental>SIMPLER', "Filter events for SIMPLER", self.OnFilterSIMPLER)
+        visFr.AddMenuItem('Experimental>SIMPLER', "Generate z estimates with SIMPLER", self.OnGenerateZSIMPLER)
+        visFr.AddMenuItem('Experimental>SIMPLER', itemType='separator')
+        # entries for N0 generation/interpolation
+        visFr.AddMenuItem('Experimental>SIMPLER', "Calculate Cluster modes for N0 (from origami)", self.OnModesN0SIMPLER)
+        visFr.AddMenuItem('Experimental>SIMPLER', "Interpolate N0 Map", self.OnInterpolateN0Field)
+        visFr.AddMenuItem('Experimental>SIMPLER', "Generate N0 Image Map from Background", self.bgrend.GenerateGUI)
+        visFr.AddMenuItem('Experimental>SIMPLER', itemType='separator')
+        # entries for showing N0, can also be used to save resulting image for later setting N0 by image 
+        visFr.AddMenuItem('Experimental>SIMPLER', "Show N0 Map from N0 Interpolation file", self.OnShowN0Map)
+        
+    def OnFilterSIMPLER(self, event):
+        from PYME.recipes.tablefilters import FilterTable
+        from PYME.recipes.tracking import FindClumps
+        recipe = self.visFr.pipeline.recipe
+        pipeline = self.visFr.pipeline
+
+        dlg = simplerFilterDialog(None)
+        ret = dlg.ShowModal()
+        if ret == wx.ID_OK:
+            minClumpSizePostFilt = dlg.GetClumpMinSize() + 2 # since 2 events are removed for edges
+            clumpName = recipe.new_output_name('with_clumps')
+            simplerName = recipe.new_output_name('simpler_filtered')
+            recipe.add_modules_and_execute([FindClumps(recipe, inputName=pipeline.selectedDataSourceKey,
+                                                       outputName=clumpName,
+                                                       timeWindow=0,
+                                                       clumpRadiusVariable=dlg.GetClumpRadiusVariable(),
+                                                       clumpRadiusScale=dlg.GetClumpRadiusMultiplier()),
+                                            FilterTable(recipe, inputName=clumpName,
+                                                        outputName=simplerName,
+                                                        filters={'clumpEdge' : [-0.1,0.1],
+                                                                 'clumpSize' : [minClumpSizePostFilt-0.5,1e5]})])
+            self.visFr.pipeline.selectDataSource(simplerName)
+
+        dlg.Destroy()
+
+    def OnGenerateZSIMPLER(self, event):
+        from PYMEcs.recipes.simpler import SIMPLERzgenerator
+        recipe = self.visFr.pipeline.recipe
+        pipeline = self.visFr.pipeline
+        
+        szg = SIMPLERzgenerator(recipe,inputName='simpler_filtered',outputName='with_simpler_z')
+        if szg.configure_traits(kind='modal'):
+           recipe.add_modules_and_execute([szg])
+           self.visFr.pipeline.selectDataSource(szg.outputName)
+
+    def OnN0FromIinterpolationField(self, event):
+        from PYMEcs.recipes.simpler import N0FromInterpolationMap
+        recipe = self.visFr.pipeline.recipe
+        pipeline = self.visFr.pipeline
+
+        n0i = N0FromInterpolationMap(recipe,inputName=pipeline.selectedDataSourceKey,
+                                     outputName=recipe.new_output_name('with_N0'))
+        if n0i.configure_traits(kind='modal'):
+           recipe.add_modules_and_execute([n0i])
+           self.visFr.pipeline.selectDataSource(n0i.outputName)     
+
+    def OnModesN0SIMPLER(self, event):
+        # what we have to do here:
+        # DBSCANclustering (currently use minClumpSize: 40, searchRadius: 35.0
+        # filter out clumpID 0 (not clustered)
+        # follow that by simpler.ClusterModes to determine modes of objects recognised as origami clusters
+        from PYMEcs.recipes.simpler import ClusterModes
+        from PYME.recipes import localisations, tablefilters
+        recipe = self.visFr.pipeline.recipe
+        pipeline = self.visFr.pipeline
+        recipe.add_modules_and_execute([localisations.DBSCANClustering(inputName='simpler_filtered',outputName='dbscanClumped',
+                                                                       minClumpSize=40,searchRadius=35.0),
+                                        tablefilters.FilterTable(inputName='dbscanClumped',outputName='validClusters',
+                                                                 filters={'dbscanClumpID':[0.5, 10000.0]}),
+                                        ClusterModes(inputName='validClusters',outputName='with_clusterModes')])
+        pipeline.selectDataSource('with_clusterModes')   
+
+    def OnInterpolateN0Field(self, event):
+        from PYME.Analysis.points import twoColour
+        from PYME.DSView import View3D
+        from scipy.interpolate import Rbf, SmoothBivariateSpline
+        
+        if not self.intMeth.configure_traits(kind='modal'):
+            return # do nothing
+        
+        p = self.visFr.pipeline
+
+        idu,idx = np.unique(p['dbscanClumpID'],return_index=True)
+        ccx = p['clusterCentroid_x'][idx]
+        ccy = p['clusterCentroid_y'][idx]
+        cm = p['clusterMode'][idx]
+        cme = p['clusterModeError'][idx]
+
+        wonky = twoColour.findWonkyVectors(ccx, ccy, cm, cm, tol=2.0*cme.mean())
+        good = wonky == 0
+        cmn2 = 0.01*(cm-cm.mean())
+        cme2 = 0.01*cme
+        
+        pixelsize = 100.0
+        x0=ccx.min()
+        x1=ccx.max()
+        y0=ccy.min()
+        y1=ccy.max()
+        nx = int((x1-x0)/pixelsize)
+        xn = x0+pixelsize*np.arange(nx+1)
+        ny = int((y1-y0)/pixelsize)
+        yn = y0+pixelsize*np.arange(ny+1)
+        xv,yv = np.meshgrid(xn,yn,indexing='ij')
+
+        if self.intMeth.InterpolationMethod == 'Splines':
+            spm = SmoothBivariateSpline(ccx[good], ccy[good], cm[good], 1./cme[good],bbox=[x0,x1,y0,y1])
+            #n0map = 100.0*spms(xv,yv,grid=False)+cm.mean()
+            n0map = spm(xv,yv,grid=False)
+        elif self.intMeth.InterpolationMethod == 'Radial Basis functions':
+            spm = Rbf(ccx[good], ccy[good], cm[good], epsilon=1)
+            n0map = spm(xv,yv)
+        elif self.intMeth.InterpolationMethod == 'Constraint Model':
+            spm = twoColour.lin3Model(ccx[good],ccy[good],cm[good],cme[good]**2)
+            # n0map = 100.0*spm(xv,yv)+cm.mean()
+            n0map = spm(xv,yv)
+
+        from PYME.IO.MetaDataHandler import origin_nm
+        origin = origin_nm(p.mdh)
+        origin_img = [origin[0]+xn[0], origin[1]+yn[0], origin[2]]
+ 
+        mdh=voxelsize_mdh(pixelsize)
+        mdh['ImageBounds.x0'] = xn[0]
+        mdh['ImageBounds.y0'] = yn[0]
+        mdh['ImageBounds.x1'] = xn[-1] + pixelsize
+        mdh['ImageBounds.y1'] = yn[-1] + pixelsize
+        mdh['ImageBounds.z0'] = 0
+        mdh['ImageBounds.z1'] = 0
+        mdh['Origin.x'] = origin_img[0]
+        mdh['Origin.y'] = origin_img[1]
+        mdh['Origin.z'] = 0
+            
+
+        View3D(n0map, titleStub='Interpolated N0 - Method %s' % (self.intMeth.InterpolationMethod),
+                 glCanvas=self.visFr.glCanvas, parent=self.visFr, mdh=mdh)
+        
+        from six.moves import cPickle
+        bbox = [x0,x1,y0,y1]
+        fdialog = wx.FileDialog(None, 'Save N0 map as ...',
+                                wildcard='N0 map file (*.n0m)|*.n0m',
+                                style=wx.FD_SAVE)
+        succ = fdialog.ShowModal()
+        if (succ == wx.ID_OK):
+            fpath = fdialog.GetPath()
+            #save as a pickle containing the data and voxelsize
+
+            fid = open(fpath, 'wb')
+            cPickle.dump((spm,bbox,origin_img), fid, 2)
+            fid.close()
+
+    def OnShowN0Map(self, event):
+        from six.moves import cPickle
+        fdialog = wx.FileDialog(None, 'Please select N0 map to use ...',
+                    wildcard='N0 map file (*.n0m)|*.n0m', style=wx.FD_OPEN)
+        succ = fdialog.ShowModal()
+        if (succ == wx.ID_OK):
+            nmFilename = fdialog.GetPath()
+            with open(nmFilename, 'rb') as fid:
+                n0m,bb,origin = cPickle.load(fid)
+            pixelsize = 100.0
+            x0,x1,y0,y1 = bb
+            nx = int((x1-x0)/pixelsize)
+            xn = x0+pixelsize*np.arange(nx+1)
+            ny = int((y1-y0)/pixelsize)
+            yn = y0+pixelsize*np.arange(ny+1)
+            xv,yv = np.meshgrid(xn,yn,indexing='ij')
+
+            mdh=voxelsize_mdh(pixelsize)
+            mdh['ImageBounds.x0'] = xn[0]
+            mdh['ImageBounds.y0'] = yn[0]
+            mdh['ImageBounds.x1'] = xn[-1] + pixelsize
+            mdh['ImageBounds.y1'] = yn[-1] + pixelsize
+            mdh['ImageBounds.z0'] = 0
+            mdh['ImageBounds.z1'] = 0
+            mdh['Origin.x'] = origin[0]
+            mdh['Origin.y'] = origin[1]
+            mdh['Origin.z'] = 0
+            
+            from PYME.DSView import View3D
+            try:
+                n0map = n0m(xv,yv)
+            except ValueError:
+                n0map = n0m(xv,yv,grid=False)
+
+            View3D(n0map, titleStub='N0 Map', mdh=mdh,
+                   glCanvas=self.visFr.glCanvas, parent=self.visFr)
+
+    def OnN0FromImage(self, event):
+        """
+
+        Function to propagate N0 values from an image (or stack of images) to localizations within the pipeline.
+        Localizations in the same area (or volume) of image. ImageStack values will be given the N0 value from
+        corresponding values. The ImageStack containing the values is selected through the GUI.
+
+        Parameters
+        ----------
+        event: GUI event
+
+        Returns
+        -------
+        Nothing, but adds N0 column to the pipeline
+            N0: N0 values from image, mapped to each localization within that label
+        """
+        
+        from PYME.IO import image
+        from PYMEcs.recipes.simpler import N0FromImage
+        #from PYME.Analysis.points import objectMeasure
+
+        visFr = self.visFr
+        pipeline = visFr.pipeline
+        recipe = pipeline.recipe
+
+        dlg = wx.SingleChoiceDialog(
+                None, 'choose the image which contains N0 values', 'Set N0',
+                list(image.openImages.keys()),
+                wx.CHOICEDLG_STYLE
+                )
+
+        if dlg.ShowModal() == wx.ID_OK:
+            img_name = dlg.GetStringSelection()
+            img = image.openImages[img_name]
+            
+            recipe.namespace[img_name] = img
+            
+            output_name = recipe.new_output_name('with_N0')
+            mod = N0FromImage(recipe, inputName=pipeline.selectedDataSourceKey,inputImage=img_name,
+                                  outputName=output_name,value_key_name='N0')
+            if mod.configure_traits(kind='modal'):
+                recipe.add_modules_and_execute([mod,])
+                pipeline.selectDataSource(mod.outputName)
+
+        dlg.Destroy()
+
+def Plug(visFr):
+    return SIMPLER(visFr)

PYMEcs/experimental/Sofi.py

@@ -0,0 +1,78 @@
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float, Bool
+from traitsui.api import View, Item, Group
+from traitsui.menu import OKButton, CancelButton, OKCancelButtons
+from PYME.DSView.dsviewer import View3D
+from PYME.IO.MetaDataHandler import NestedClassMDHandler
+
+import numpy as np
+from PYMEcs.Analysis.Sofi import calcCorrelates, calcCorrelatesI
+import sys
+
+# plugin interface to David's SOFI code
+# current version allows integer zooming but no interface yet to calcCorrelatesZ
+# this may better be addressed once the SOFI code data model modernisation has been considered
+
+class SOFIconfig(HasTraits):
+        numberOfOrders = Int(3) # so far I have not seen to much reason to include higher orders
+        startAtFrame = Int(50)
+        stopAtFrame = Int(sys.maxsize)
+        filterHalfWidth = Int(25)
+        useZooming = Bool(False)
+        zoomFactor = Int(1)
+
+
+from PYME.DSView.modules._base import Plugin
+class SOFIengine(Plugin):
+    def __init__(self, dsviewer):
+        Plugin.__init__(self, dsviewer)
+        self.sconf = SOFIconfig(stopAtFrame=self.dsviewer.image.data.shape[2])
+        
+        dsviewer.AddMenuItem('Experimental>Sofi', "Calculate SOFI moments", self.OnCalcSofi)
+
+    def OnCalcSofi(self, event):
+        if not self.sconf.configure_traits(kind='modal'):
+            return
+        sc = self.sconf
+        data = self.dsviewer.image.data # need to check how to best switch to new data model
+        if sc.useZooming:
+            # note: we need to modify result voxel sizes if zooming!
+            corrs, means = calcCorrelatesI(data,
+                                           nOrders=sc.numberOfOrders,
+                                           zoom=sc.zoomFactor,
+                                           startAt=sc.startAtFrame,
+                                           stopAt=sc.stopAtFrame,
+                                           filtHalfWidth=sc.filterHalfWidth)
+        else:
+            corrs, means = calcCorrelates(data,
+                                          nOrders=sc.numberOfOrders,
+                                          startAt=sc.startAtFrame,
+                                          stopAt=sc.stopAtFrame,
+                                          filtHalfWidth=sc.filterHalfWidth)
+
+
+        cmdh = NestedClassMDHandler(self.dsviewer.image.mdh)
+        cmdh['SofiProcessing.StartFrame'] = sc.startAtFrame
+        cmdh['SofiProcessing.StopFrame'] = sc.stopAtFrame
+        cmdh['SofiProcessing.FilterHalfWidth'] = sc.filterHalfWidth
+        cmdh['SofiProcessing.NumberOfOrders'] = sc.numberOfOrders
+        cmdh['SofiProcessing.Mode'] = 'moments'
+        if sc.useZooming: # is this the right way to handle voxel sizes? more suitable API interface available?
+            cmdh['voxelsize.x'] = self.dsviewer.image.mdh['voxelsize.x'] / float(sc.zoomFactor)
+            cmdh['voxelsize.y'] = self.dsviewer.image.mdh['voxelsize.y'] / float(sc.zoomFactor)
+            cmdh['SofiProcessing.ZoomFactor'] = sc.zoomFactor
+            
+        mmdh = NestedClassMDHandler(self.dsviewer.image.mdh)
+        mmdh['SofiProcessing.StartFrame'] = sc.startAtFrame
+        mmdh['SofiProcessing.StopFrame'] = sc.stopAtFrame
+        mmdh['SofiProcessing.Mode'] = 'mean'
+        if sc.useZooming:
+            mmdh['voxelsize.x'] = self.dsviewer.image.mdh['voxelsize.x'] / float(sc.zoomFactor)
+            mmdh['voxelsize.y'] = self.dsviewer.image.mdh['voxelsize.y'] / float(sc.zoomFactor)
+            mmdh['SofiProcessing.ZoomFactor'] = sc.zoomFactor
+
+        View3D(corrs, titleStub='SOFI correlates', mdh=cmdh)
+        View3D(means, titleStub='Data mean', mdh=mmdh)
+
+
+def Plug(dsviewer):
+    return SOFIengine(dsviewer)

PYMEcs/experimental/binEventProperty.py

@@ -0,0 +1,187 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import wx
+
+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
+
+from PYME.DSView.dsviewer import ViewIm3D, ImageStack
+
+class propertyChoice(HasTraits):
+    clist = List([])
+    EventProperty = Enum(values='clist')
+    BinByProperty = Enum(values='clist')
+    BinWidth = Float(100.0)
+
+    traits_view = View(Group(Item(name = 'EventProperty'),
+                             Item(name = 'BinByProperty'),
+                             Item('_'),
+                             Item(name = 'BinWidth'),
+                             label = 'Select Properties and Binning',
+                             show_border = True),
+                       buttons = OKCancelButtons)
+
+    def add_channels(self,chans):
+        for chan in chans:
+            if chan not in self.clist:
+                self.clist.append(chan)
+
+
+class propertyChoice2D(HasTraits):
+    clist = List([])
+    EventProperty = Enum(values='clist')
+    BinWidth = Float(200.0)
+    StatsType = CStr('median')
+
+    traits_view = View(Group(Item(name = 'EventProperty'),
+                             Item('_'),
+                             Item(name = 'BinWidth'),
+                             Item(name = 'StatsType'),
+                             label = 'Select Properties and Binning',
+                             show_border = True),
+                       buttons = OKCancelButtons)
+
+    def add_channels(self,chans):
+        for chan in chans:
+            if chan not in self.clist:
+                self.clist.append(chan)
+
+
+class PropertyBinning:
+    """
+
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          'Bin Event Property by coordinate',
+                          self.OnBinProperty,
+                          helpText='Bin average an event property, e.g. background,  as a function of another property, e.g. x')
+
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          'Bin Event Property in 2D',
+                          self.OnBin2DProperty,
+                          helpText='Bin average an event property, e.g. background,  as a function of x and y coordinates')
+
+
+    def OnBinProperty(self, event=None):
+        # these are the defaults
+        avProperty = 'nPhotons'
+        byProperty = 'x'
+        binwidth = 100
+
+        # traitsui dialog to set the event properties etc
+        pChoice = propertyChoice()
+        pChoice.add_channels(sorted(self.pipeline.keys()))
+        # select defaults if these event properties exist
+        if avProperty in pChoice.clist:
+            pChoice.EventProperty = avProperty
+        if byProperty in pChoice.clist:
+            pChoice.BinByProperty = byProperty
+
+        if pChoice.configure_traits(kind='modal'):
+            avProperty = pChoice.EventProperty
+            byProperty = pChoice.BinByProperty
+            binwidth = pChoice.BinWidth
+        else:
+            return
+
+        avp = self.pipeline[avProperty]
+        byp = self.pipeline[byProperty]
+
+        bypmin = byp.min()
+        bypmax = byp.max()
+        nbins = int((bypmax-bypmin)/binwidth)
+        bins = bypmin + np.arange(nbins+1)*binwidth
+
+        binctrs = 0.5*(bins[0:-1]+bins[1:])
+        
+        avbin, abins = np.histogram(byp, bins=bins, weights=avp)
+        bybin, bybins = np.histogram(byp, bins=bins)
+
+        good = bybin > 0
+        bad = bybin <= 0
+
+        avmean = np.zeros_like(avbin,dtype='float64')
+        avmean[good] = avbin[good]/bybin[good]
+        avmean[bad] = np.nan
+
+        # direct matplotlib plotting scrapped for ImageStack approach
+        # which allows saving of data
+        #plt.figure()
+        #plt.plot(binctrs, avmean)
+        #plt.xlabel(byProperty)
+        #plt.ylabel('mean of %s' % avProperty)
+
+        plots = []
+        plots.append(avmean.reshape(-1, 1,1))
+
+        im = ImageStack(plots, titleStub='mean of %s' % avProperty)
+        im.xvals = binctrs
+        im.xlabel = byProperty
+
+        im.ylabel = 'mean of %s' % avProperty
+        im.defaultExt = '*.txt'
+
+        im.mdh['voxelsize.x'] = binwidth
+        im.mdh['ChannelNames'] = [avProperty]
+        im.mdh['Profile.XValues'] = im.xvals
+        im.mdh['Profile.XLabel'] = im.xlabel
+        im.mdh['Profile.YLabel'] = im.ylabel
+
+        im.mdh['OriginalImage'] = self.pipeline.filename
+
+        ViewIm3D(im, mode='graph', parent=wx.GetTopLevelParent(self.visFr))
+
+
+    def OnBin2DProperty(self, event=None):
+        from scipy.stats import binned_statistic_2d
+        # these are the defaults
+        avProperty = 'nPhotons'
+        binwidth = 200 # 200 nm default
+
+        # traitsui dialog to set the event properties etc
+        pChoice = propertyChoice2D()
+        pChoice.add_channels(sorted(self.pipeline.keys()))
+        # select defaults if these event properties exist
+        if avProperty in pChoice.clist:
+            pChoice.EventProperty = avProperty
+
+        if pChoice.configure_traits(kind='modal'):
+            avProperty = pChoice.EventProperty
+            binwidth = pChoice.BinWidth
+        else:
+            return
+
+        avp = self.pipeline[avProperty]
+        x = self.pipeline['x']
+        y = self.pipeline['y']
+        xmin = x.min()
+        xmax = x.max()
+        ymin = y.min()
+        ymax = y.max()
+        
+        nbinsx = int((xmax-xmin)/binwidth)
+        xbins = xmin + np.arange(nbinsx+1)*binwidth
+        nbinsy = int((ymax-ymin)/binwidth)
+        ybins = ymin + np.arange(nbinsy+1)*binwidth
+
+        propstats, x_edge, y_edge, binno = binned_statistic_2d(x,y,avp,statistic=pChoice.StatsType,bins=(xbins,ybins))
+        propstats[np.isnan(propstats)] = 0.0 # we replacenans with zeros (for now)
+        
+        imps = ImageStack(propstats, titleStub = '%s Map' % avProperty)
+        imps.mdh.setEntry('voxelsize.x',1e-3*binwidth)
+        imps.mdh.setEntry('voxelsize.y',1e-3*binwidth)
+
+        ViewIm3D(imps)
+        
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.propBin = PropertyBinning(visFr)
+

PYMEcs/experimental/chaining.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+class ParticleTracker2:
+    def __init__(self, visFr):
+        self.visFr = visFr
+
+        visFr.AddMenuItem('Experimental>Deprecated>Chaining', "Clump consecutive appearances", self.OnCoalesce)
+
+    def OnCoalesce(self, event):
+        from PYMEcs.recipes import localisations
+        recipe = self.visFr.pipeline.recipe
+
+        from PYMEcs.misc.utils import unique_name
+        outputName = unique_name('coalesced',self.visFr.pipeline.dataSources.keys())
+        recipe.add_module(localisations.MergeClumpsTperiod(recipe, inputName='with_clumps', outputName=outputName))
+    
+        recipe.execute()
+        self.visFr.pipeline.selectDataSource(outputName)
+
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    ParticleTracker2(visFr)