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

PYMEcs/experimental/randMap.py

@@ -0,0 +1,188 @@
+import numpy as np
+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
+
+class ChannelSelector(HasTraits):
+    clist = List([])
+    Channel = Enum(values='clist')
+
+    traits_view = View(Group(Item(name = 'Channel')),
+                             title = 'Select Channel',
+                             buttons = OKCancelButtons
+    )
+
+    def add_keys(self,chans):
+        for chan in chans:
+            if chan not in self.clist:
+                self.clist.append(chan)
+
+
+class TimeSelector(HasTraits):
+    clist = List([])
+    Channel = Enum(values='clist')
+    FromTime = Float()
+    ToTime = Float()
+    FilterEvents = Bool(False)
+
+    traits_view = View(Group(Item(name = 'Channel'),
+                             Item(name = 'FromTime'),
+                             Item(name = 'ToTime'),
+                             Item(name = 'FilterEvents')),
+                       title = 'Select Channel',
+                       buttons = OKCancelButtons
+    )
+
+    def add_keys(self,chans):
+        for chan in chans:
+            if chan not in self.clist:
+                self.clist.append(chan)
+
+
+class TimeBlock(HasTraits):
+    BlockSize = Int(100)   
+
+
+class ExtraColumns:
+    """
+
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Add random value column',
+                          self.OnRandMap,
+                          helpText='the added random value column can be used to select a fraction of all events')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Add time block choice column',
+                          self.OnTimeBlocks,
+                          helpText='the added column can be used to select blocks of frames as even or odd numbered blocks')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Select 50% of events from even numbered time blocks - EVEN',
+                          self.OnSelectTB1,
+                          helpText='select half of all events for FRC - even numbered time blocks')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Select 50% of events from from odd numbered time blocks - ODD',
+                          self.OnSelectTB2,
+                          helpText='select half of all events for FRC - second half')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Select 50% of events from random value column - half 1',
+                          self.OnSelectHalf1,
+                          helpText='select half of all events for FRC - first half')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Select 50% of events from random value column - half 2',
+                          self.OnSelectHalf2,
+                          helpText='select half of all events for FRC - second half')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Add channel based time selection column',
+                          self.OnTimeSelectChannel,
+                          helpText='the added column can be used to select a time window of events of a specific colour, filter tsel_channel in range (0.5,2)')
+        visFr.AddMenuItem('Experimental>Deprecated>ExtraColumns',
+                          'Add channel based random fraction selection column',
+                          self.OnRandomSelectChannel,
+                          helpText='the added column can be used to select a fraction of events of a specific colour by random sub-sampling, filter rand_channel in range (-.1,fraction)')
+
+    def OnRandMap(self, event=None):
+        self.pipeline.selectedDataSource.setMapping('randVal','0*x+np.random.rand(x.size)')
+        self.pipeline.Rebuild()
+
+    def OnTimeBlocks(self, event=None):
+        tb = TimeBlock()
+        if tb.configure_traits(kind='modal'):
+            psd = self.pipeline.selectedDataSource
+            blockSel = np.mod((psd['t']/tb.BlockSize).astype('int'),2)
+            # self.pipeline.selectedDataSource.setMapping('timeBlock',"np.mod((t/%d).astype('int'),2)" % tb.BlockSize)
+            self.pipeline.selectedDataSource.addColumn('timeBlock',blockSel)
+            self.pipeline.Rebuild()
+
+    def OnSelectTB1(self, event=None):
+        if 'timeBlock' not in self.pipeline.keys():
+            print('Need randVal property, call "Add random value column" first')
+            return
+
+        self.pipeline.filterKeys['timeBlock'] = (-0.1,0.5)
+        self.pipeline.Rebuild()
+        self.visFr.CreateFoldPanel()
+
+    def OnSelectTB2(self, event=None):
+        if 'timeBlock' not in self.pipeline.keys():
+            print('Need randVal property, call "Add random value column" first')
+            return
+
+        self.pipeline.filterKeys['timeBlock'] = (0.5,1.5)
+        self.pipeline.Rebuild()
+        self.visFr.CreateFoldPanel()
+
+            
+    def OnSelectHalf1(self, event=None):
+        if 'randVal' not in self.pipeline.keys():
+            print('Need randVal property, call "Add random value column" first')
+            return
+
+        self.pipeline.filterKeys['randVal'] = (-0.1,0.4999)
+        self.pipeline.Rebuild()
+        self.visFr.CreateFoldPanel()
+
+    def OnSelectHalf2(self, event=None):
+        if 'randVal' not in self.pipeline.keys():
+            print('Need randVal property, call "Add random value column" first')
+            return
+
+        self.pipeline.filterKeys['randVal'] = (0.5,1.1)
+        self.pipeline.Rebuild()
+        self.visFr.CreateFoldPanel()
+
+    def OnTimeSelectChannel(self, event=None):
+        pipeline = self.pipeline
+        if pipeline.selectedDataSource is None:
+            return
+        if len(pipeline.colourFilter.getColourChans()) < 1:
+            return
+        timeSelector = TimeSelector()
+        timeSelector.add_keys(pipeline.colourFilter.getColourChans())
+        if timeSelector.configure_traits(kind='modal'):
+            psd = pipeline.selectedDataSource
+            tall = np.ones_like(psd['x'], dtype='float')
+            tsel = (psd['t'] >= timeSelector.FromTime) * (psd['t'] <= timeSelector.ToTime)
+
+            dispColor = pipeline.colourFilter.currentColour
+            pipeline.colourFilter.setColour(timeSelector.Channel)
+            idx = pipeline.filter.Index.copy()
+            idx[idx] = pipeline.colourFilter.index
+            tall[idx] = tsel[idx]
+            pipeline.colourFilter.setColour(dispColor)
+            pipeline.selectedDataSource.addColumn('tselect_%s' % timeSelector.Channel,tall)
+            if timeSelector.FilterEvents:
+                self.pipeline.filterKeys['tselect_%s' % timeSelector.Channel] = (0.5,2.0)
+            pipeline.Rebuild()
+            self.visFr.CreateFoldPanel()
+
+    def OnRandomSelectChannel(self, event=None):
+        pipeline = self.pipeline
+        if pipeline.selectedDataSource is None:
+            return
+        if len(pipeline.colourFilter.getColourChans()) < 1:
+            return
+        chanSelector = ChannelSelector()
+        chanSelector.add_keys(pipeline.colourFilter.getColourChans())
+        if chanSelector.configure_traits(kind='modal'):
+            psd = pipeline.selectedDataSource
+            eall = np.zeros_like(psd['x'], dtype='float')
+            erand = np.random.rand(eall.size)
+
+            dispColor = pipeline.colourFilter.currentColour
+            pipeline.colourFilter.setColour(chanSelector.Channel)
+            idx = pipeline.filter.Index.copy()
+            idx[idx] = pipeline.colourFilter.index
+            eall[idx] = erand[idx]
+            pipeline.colourFilter.setColour(dispColor)
+            pipeline.selectedDataSource.addColumn('rand_%s' % chanSelector.Channel,eall)
+            pipeline.Rebuild()
+            self.visFr.CreateFoldPanel()
+
+            
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    visFr.extraCols = ExtraColumns(visFr)

PYMEcs/experimental/regExtraCmaps.py

@@ -0,0 +1,11 @@
+import PYMEcs.misc.ExtraCmaps
+
+# this module hijacks the plugin system to run colour map registration
+# at startup of visgui, dsviewer
+
+# I am exploring the alternative option to do this via the startup console script
+# which has the advantage of doing this at startup for dsviewer which is an issue otherwise
+
+def Plug(arg):
+    # registerCmaps()
+    pass

PYMEcs/experimental/selectROIfilterTable.py

@@ -0,0 +1,72 @@
+import numpy as np
+from PYME.recipes.tablefilters import FilterTable
+import wx
+
+def selectWithDialog(choices, message='select image from list', caption='Selection'):
+    dlg = wx.SingleChoiceDialog(None, message, caption, choices, wx.CHOICEDLG_STYLE)
+    if dlg.ShowModal() == wx.ID_OK:
+        item = dlg.GetStringSelection()
+    else:
+        item = None
+    dlg.Destroy()
+    return item
+
+
+class SelectROIFT:
+    def __init__(self, visFr):
+        self.visFr = visFr
+
+        visFr.AddMenuItem('Experimental>View', "Add ROI FilterTable module from selection", self.OnSelROIFT)
+        visFr.AddMenuItem('Experimental>View', "Add ROI FilterTable module from image", self.OnImROIFT)
+
+    def OnSelROIFT(self, event):
+        try:
+            #old glcanvas
+            x0, y0 = self.visFr.glCanvas.selectionStart[0:2]
+            x1, y1 = self.visFr.glCanvas.selectionFinish[0:2]
+        except AttributeError:
+            #new glcanvas
+            x0, y0 = self.visFr.glCanvas.selectionSettings.start[0:2]
+            x1, y1 = self.visFr.glCanvas.selectionSettings.finish[0:2]
+
+        filters = {}
+        filters['x'] = [float(min(x0, x1)), float(max(x0, x1))] # must ensure all values are eventually scalars to avoid issue with recipe yaml output
+        filters['y'] = [float(min(y0, y1)), float(max(y0, y1))] # ditto
+
+        recipe = self.visFr.pipeline.recipe
+        ftable = FilterTable(recipe, inputName=self.visFr.pipeline.selectedDataSourceKey,
+                                  outputName='selectedROI', filters=filters)
+        if not ftable.configure_traits(kind='modal'):
+            return
+
+        recipe.add_module(ftable)
+        recipe.execute()
+
+    def OnImROIFT(self, event):
+        from PYME.DSView import dsviewer
+        selection = selectWithDialog(list(dsviewer.openViewers.keys()))
+        if selection is not None:
+            img = dsviewer.openViewers[selection].image
+        else:
+            return
+        if img.mdh.getOrDefault('Filter.Keys',None) is None:
+            logger.debug('no Filter.Keys in image metadata')
+            return
+
+        filters = {}
+        filters['x'] = list(img.mdh['Filter.Keys']['x'])
+        filters['y'] = list(img.mdh['Filter.Keys']['y'])
+
+        recipe = self.visFr.pipeline.recipe
+        ftable = FilterTable(recipe, inputName=self.visFr.pipeline.selectedDataSourceKey,
+                                  outputName='selectedROI', filters=filters)
+        if not ftable.configure_traits(kind='modal'):
+            return
+
+        recipe.add_module(ftable)
+        recipe.execute()
+        
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    SelectROIFT(visFr)

PYMEcs/experimental/showErrs.py

@@ -0,0 +1,51 @@
+import  wx
+from  wx.lib.dialogs import ScrolledMessageDialog
+from PYMEcs.misc.guiMsgBoxes import Warn
+
+def isDarwin():
+   import os
+   from sys import platform
+   return platform == "darwin"
+
+class ShowErr:
+   """
+
+   """
+   def __init__(self, visFr):
+      self.visFr = visFr
+      self.txtwin = None
+      visFr.AddMenuItem('Experimental', 'Errors in scrolled message dialog\tCtrl+E', self.OnErrScrolledDialog)
+
+   def getLogFileName(self, pidoffset = -1):
+      import os
+      pid = int(os.getpid()) + pidoffset
+      return os.path.join('/tmp','visgui-%d.tmp' % pid)
+
+   def OnErrScrolledDialog(self, event=None):
+      if not isDarwin():
+         Warn(None,'aborting: functionality only available on mac','Error')
+         return
+
+      ok = False
+      import os.path
+      fname = self.getLogFileName(pidoffset = -1)
+      if os.path.isfile(fname):
+         ok = True
+      else:
+         fname = self.getLogFileName(pidoffset = 0)
+         if os.path.isfile(fname):
+            ok = True
+         else:
+            Warn(None,'aborting: cannot find log file, tried %s and %s' % (self.getLogFileName(pidoffset = -1),
+                                                                           self.getLogFileName(pidoffset = 0)))
+      if ok:
+         with open(fname,"r") as f:
+            txt = "\n".join(f.readlines())
+            dlg = ScrolledMessageDialog(self.visFr, txt, "VisGUI Error Output", size=(900,400),
+                                        style=wx.RESIZE_BORDER | wx.DEFAULT_DIALOG_STYLE )
+            dlg.ShowModal()
+            dlg.Destroy()
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.showErr = ShowErr(visFr)

PYMEcs/experimental/showErrsDh5view.py

@@ -0,0 +1,58 @@
+import wx
+from  wx.lib.dialogs import ScrolledMessageDialog
+from PYMEcs.misc.guiMsgBoxes import Warn
+
+from PYMEcs.misc.versionCheck import PYMEversionCheck
+try:
+   from PYME.DSView.modules._base import Plugin
+except ImportError:
+   PYMEversionCheck('PluginClass')
+
+def isDarwin():
+   import os
+   from sys import platform
+   return platform == "darwin"
+
+class ShowErr(Plugin):
+   """
+
+   """
+   def __init__(self, dsviewer):
+
+      Plugin.__init__(self, dsviewer)
+      
+      self.txtwin = None
+      dsviewer.AddMenuItem('Experimental', 'Errors in scrolled message dialog\tCtrl+E', self.OnErrScrolledDialog)
+
+   def getLogFileName(self, pidoffset = -1):
+      import os
+      pid = int(os.getpid()) + pidoffset
+      return os.path.join('/tmp','dh5view-%d.tmp' % pid)
+
+   def OnErrScrolledDialog(self, event=None):
+      if not isDarwin():
+         Warn(None,'aborting: functionality only available on mac','Error')
+         return
+      ok = False
+      import os.path
+      fname = self.getLogFileName(pidoffset = -1)
+      if os.path.isfile(fname):
+         ok = True
+      else:
+         fname = self.getLogFileName(pidoffset = 0)
+         if os.path.isfile(fname):
+            ok = True
+         else:
+            Warn(None,'aborting: cannot find log file, tried %s and %s' % (self.getLogFileName(pidoffset = -1),
+                                                                           self.getLogFileName(pidoffset = 0)))
+      if ok:
+         with open(fname,"r") as f:
+            txt = "\n".join(f.readlines())
+            dlg = ScrolledMessageDialog(self.dsviewer, txt, "VisGUI Error Output", size=(900,400),
+                                        style=wx.RESIZE_BORDER | wx.DEFAULT_DIALOG_STYLE )
+            dlg.ShowModal()
+            dlg.Destroy()
+
+def Plug(dsviewer):
+    """Plugs this module into the gui"""
+    return ShowErr(dsviewer)

PYMEcs/experimental/showShiftMap.py

@@ -0,0 +1,56 @@
+import numpy as np
+import logging
+logger = logging.getLogger(__file__)
+
+# note: to turn this into a standalone shiftmap display tool, add code to open a shiftfield:
+# import PYME.Acquire.Hardware.splitter as sp
+# dx2,dy2 = sp.LoadShiftField(h5file_or_sf_file)
+#
+# if it is purely a shiftfield file then we have to supply some additional info, e.g. voxelsizes
+# and ROI size for the splitter
+
+class ShowMap:
+    """
+
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+
+        visFr.AddMenuItem('Experimental>ShiftMap', 'Show Shiftmap', self.OnShowShiftMap,
+                          helpText='Show a shiftmap from metadata info')
+        visFr.AddMenuItem('Experimental>ShiftMap', 'Shiftmap as image', self.OnShiftMapAsImage,
+                          helpText='Show a shiftmap from metadata info and display as image')
+
+    def OnShowShiftMap(self, event=None):
+        from PYME.Analysis.points import twoColour, twoColourPlot
+        mdh = self.pipeline.mdh
+        vs = [mdh['voxelsize.x']*1e3, mdh['voxelsize.y']*1e3, mdh['voxelsize.z']*1e3]
+        dx = mdh.getEntry('chroma.dx')
+        dy = mdh.getEntry('chroma.dy')
+
+        shape = mdh['Splitter.Channel0ROI'][2:]
+
+        twoColourPlot.PlotShiftField2(dx,dy,shape,vs)
+
+    def OnShiftMapAsImage(self, event=None):
+        mdh = self.pipeline.mdh
+        voxelsize = [mdh['voxelsize.x']*1e3, mdh['voxelsize.y']*1e3, mdh['voxelsize.z']*1e3]
+        spx = mdh.getEntry('chroma.dx')
+        spy = mdh.getEntry('chroma.dy')
+
+        shape = mdh['Splitter.Channel0ROI'][2:]
+        xi, yi = np.meshgrid(np.arange(0, shape[0]*voxelsize[0], 100), np.arange(0, shape[1]*voxelsize[1], 100))
+        xin = xi.ravel()
+        yin = yi.ravel()
+        dx = spx.ev(xin[:], yin[:]).reshape(xi.shape)
+        dy = spy.ev(xin[:], yin[:]).reshape(xi.shape)
+        
+        from PYME.DSView.dsviewer import View3D
+        image = np.stack([dx[::-1, :],dy[::-1, :]],axis=-1)
+        View3D(image,  parent=self.visFr, titleStub='ShiftMap')
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.showShiftMap = ShowMap(visFr)
+

PYMEcs/experimental/snrEvents.py

@@ -0,0 +1,188 @@
+import numpy as np
+from PYMEcs.misc.guiMsgBoxes import Warn
+import wx
+import os
+
+def populate_fresults_wholep(fitMod,pipeline,bgzero=True):
+    r = np.zeros(pipeline['x'].size, fitMod.fresultdtype)
+    for k in pipeline.keys():
+        f = k.split('_')
+        if len(f) == 1:
+            try:
+                r[f[0]] = pipeline[k]
+            except ValueError:
+                pass
+        elif len(f) == 2:
+            try:
+                r[f[0]][f[1]] = pipeline[k]
+            except ValueError:
+                pass
+        elif len(f) == 3:
+            try:
+                r[f[0]][f[1]][f[2]] = pipeline[k]
+            except ValueError:
+                pass
+        else:
+            raise RuntimeError('more fields than expected: %d' % len(f))
+
+    if bgzero:
+        r['fitResults']['bg'] = 0
+        r['fitResults']['br'] = 0
+    
+    return r
+
+
+from PYME.IO.MetaDataHandler import NestedClassMDHandler
+def genFitImage(fitMod,fr,mdh,psfname=None):
+    mdh2 = NestedClassMDHandler(mdh)
+    if psfname is not None:
+        mdh2['PSFFile'] = psfname
+    fitim = fitMod.genFitImage(fr,mdh2)
+
+    return fitim
+
+def get_photons(fitim,mdh):
+    nph = fitim.sum()*mdh.getEntry('Camera.ElectronsPerCount')/mdh.getEntry('Camera.TrueEMGain')
+    return nph
+
+
+def nPhotons(fitMod,fr,mdh,psfname=None,nmax=100,progressBar=None,updateStep=100):
+    mdh2 = NestedClassMDHandler(mdh)
+    if psfname is not None:
+        mdh2['PSFFile'] = psfname
+    npoints = min(fr.shape[0],nmax)
+    nph = np.zeros((npoints))
+    us = int(updateStep)
+    for i in range(npoints):
+        nph[i] = get_photons(genFitImage(fitMod,fr[i],mdh2,psfname=None), mdh2)
+        if (progressBar is not None) and ((i % us) == 0):
+            progressBar.Update(100.0*i/float(npoints))
+            wx.Yield()
+    return nph
+
+
+# you may need a lot more imports depending what functionality your require in your plugin
+class SNRcalculator:
+    """
+    A plugin, very simple to demonstrate the concept. Also providing a simple
+    measure of some kind of SNR, the formula used is probably debatable.
+    For example, low background estimates cause very high SNRs which may or may not
+    be reasonable given the uncertainty in determining the background etc
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+        
+        visFr.AddMenuItem('Experimental>ExtraColumns', 'Add SNR property', self.OnAddSNR,
+                          helpText='Add an event property that provides some measure of SNR for events (from background and amplitude)')
+        visFr.AddMenuItem('Experimental>Biplane', 'Add Biplane nPhotons', self.OnAddnphBPlane,
+                          helpText='Add nPhotons for Biplane fitting')
+        visFr.AddMenuItem('Experimental>Biplane', 'Plot Biplane zErrors', self.OnPlotErrBPlane,
+                          helpText='Plot Biplane fitting z-errors')
+
+
+    def OnAddSNR(self, event=None):
+        """
+        this function adds an 'SNR' property to events - there could be some discussion how that is actually best calculated
+        """
+        from PYMEcs.recipes import localisations
+
+        if False: # this way does not make a special recipe module but uses the generic Mapping module and adds a few columns
+            from PYME.IO import tabular
+            from PYME.recipes import tablefilters
+            # the original formula was very adhoc
+            # we have now changed to a different way
+            # here we use an approach derived from a formula from Tang et al,
+            # Scientific Reports | 5:11073 | DOi: 10.1038/srep11073
+            mdh = self.pipeline.mdh
+            pipeline = self.pipeline
+            # there is an issue if we don't have the nPhotons property FIXME!
+            nph = self.pipeline['nPhotons']
+            bgraw = self.pipeline['fitResults_background']
+            bgph = np.clip((bgraw)*mdh['Camera.ElectronsPerCount']/mdh.getEntry('Camera.TrueEMGain'),1,None)
+        
+            npixroi = (2*mdh.getOrDefault('Analysis.ROISize',5) + 1)**2
+            snr = 1.0/npixroi * np.clip(nph,0,None)/np.sqrt(bgph)
+            #dirty copy of the pipeline output
+
+            recipe = pipeline.recipe
+            mapp = tablefilters.Mapping(recipe,inputName=pipeline.selectedDataSourceKey,
+                                  outputName='snr')
+            recipe.add_module(mapp)
+            recipe.execute()
+
+            snrmap = recipe.namespace['snr']
+            snrmap.addColumn('SNR', snr)
+            snrmap.addColumn('backgroundPhotons',bgph)
+
+        else:
+            recipe = self.pipeline.recipe
+            snr = localisations.SnrCalculation(recipe,inputName=self.pipeline.selectedDataSourceKey,
+                                               outputName='snr')
+            recipe.add_module(snr)
+            recipe.execute()
+            
+        self.pipeline.selectDataSource('snr')
+
+        self.pipeline.Rebuild()
+        #self.visFr.CreateFoldPanel() # we should not need this anymore
+
+
+    def OnAddnphBPlane(self, event=None):
+        """
+        this function adds nPhoton property to events for biplane
+        """
+        fdialog = wx.FileDialog(None, 'Please select PSF to use ...',
+                                #defaultDir=os.path.split(self.image.filename)[0],
+                                wildcard='PSF Files|*.psf|TIFF files|*.tif', style=wx.FD_OPEN)
+        succ = fdialog.ShowModal()
+        if (succ == wx.ID_OK):
+            psfn = filename = fdialog.GetPath()
+            mdh = self.pipeline.mdh
+            pipeline = self.pipeline
+            if mdh.getEntry('Analysis.FitModule') not in ['SplitterFitInterpBNR']:
+                Warn('Plugin works only for Biplane analysis')
+                return
+            fitMod = __import__('PYME.localization.FitFactories.' +
+                                self.pipeline.mdh.getEntry('Analysis.FitModule'),
+                                fromlist=['PYME', 'localization', 'FitFactories'])
+            fr = populate_fresults_wholep(fitMod, pipeline)
+            progress = wx.ProgressDialog("calculating photon numbers",
+                                         "calculating...", maximum=100, parent=None,
+                                         style=wx.PD_SMOOTH|wx.PD_AUTO_HIDE)
+            nph = nPhotons(fitMod, fr, mdh, psfname=psfn, nmax=1e6,
+                           progressBar=progress, updateStep = 100)
+            progress.Destroy()
+            self.pipeline.addColumn('nPhotons', nph)
+            self.pipeline.addColumn('fitResults_background', pipeline['fitResults_bg']+pipeline['fitResults_br'])
+            self.pipeline.addColumn('sig',float(137.0)+np.zeros_like(pipeline['x'])) # this one is a straight kludge for mortensenError
+            self.pipeline.Rebuild()
+            self.visFr.CreateFoldPanel()
+
+
+    def OnPlotErrBPlane(self, event=None):
+        mdh = self.pipeline.mdh
+        pipeline = self.pipeline
+        if mdh.getEntry('Analysis.FitModule') not in ['SplitterFitInterpBNR']:
+            Warn('Plugin works only for Biplane analysis')
+            return
+        bgraw = pipeline['fitResults_bg']+pipeline['fitResults_br']
+        bgph = bgraw * pipeline.mdh.getEntry('Camera.ElectronsPerCount')/pipeline.mdh.getEntry('Camera.TrueEMGain')
+
+        import matplotlib.pyplot as plt
+        plt.figure()
+        plt.scatter(pipeline['nPhotons'],pipeline['fitError_z0'],s=10,c=bgph)
+        plt.colorbar()
+        plt.xlim(0,None)
+        plt.xlabel('Photons')
+        plt.ylabel('z error (nm)')
+        
+# example use after adding the nPhotons entry:
+# def bg(pipeline):
+#     return (pipeline['fitResults_bg']+pipeline['fitResults_br'])*pipeline.mdh.getEntry('Camera.ElectronsPerCount')/pipeline.mdh.getEntry('Camera.TrueEMGain')
+# scatter(pipeline['nPhotons'],pipeline['fitError_z0'],s=10,c=bg(pipeline))
+# colorbar()            
+            
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.snrCalc = SNRcalculator(visFr)

PYMEcs/experimental/specLabeling.py

@@ -0,0 +1,51 @@
+import numpy as np
+from PYMEcs.recipes.localisations import ClusterTimeRange, ValidClumps
+from PYME.recipes.tablefilters import FilterTable
+from PYME.recipes.localisations import DBSCANClustering
+
+class SpecLabeling:
+    def __init__(self, visFr):
+        self.visFr = visFr
+
+        visFr.AddMenuItem('Experimental>Corrections', "Filter specific labeling (DNA-PAINT)", self.OnSpecFilter)
+        visFr.AddMenuItem('Experimental>Corrections', "Apply specific labeling to non-clumped data (DNA-PAINT)", self.OnSpecFilterNC)
+
+    def OnSpecFilter(self, event):
+        from PYMEcs.recipes import localisations
+        recipe = self.visFr.pipeline.recipe
+        bigLimit = 1e6 # size for filters big enough to capture everything
+        
+        # check 'coalesced' is available
+        recipe.add_module(DBSCANClustering(recipe,inputName='coalesced', outputName='dbscanClustered', columns=['x', 'y'],
+                                            searchRadius=50, minClumpSize=3, clumpColumnName='dbscanClumpID'))
+        filters={'dbscanClumpID' : [0.5,1e6]}
+        recipe.add_module(FilterTable(recipe, inputName='dbscanClustered',
+                                  outputName='validCluster', filters={'dbscanClumpID' : [0.5,bigLimit]}))
+        
+        recipe.add_module(ClusterTimeRange(recipe, inputName='validCluster',
+                                           outputName='withTrange', IDkey='dbscanClumpID'))
+        recipe.add_module(FilterTable(recipe, inputName='withTrange',
+                                  outputName='specLabeling', filters={'trange' : [2500,bigLimit]}))
+        
+        recipe.execute()
+        self.visFr.pipeline.selectDataSource('specLabeling')
+
+        
+    def OnSpecFilterNC(self, event):
+        from PYMEcs.recipes import localisations
+        recipe = self.visFr.pipeline.recipe
+
+        recipe.add_module(ValidClumps(inputName='with_clumps',
+                                      inputValid='specLabeling',
+                                      outputName='with_validClumps'))
+        recipe.add_module(FilterTable(recipe, inputName='with_validClumps',
+                                  outputName='specLabelingNC', filters={'validID' : [0.5,1.5]}))
+        recipe.add_module(FilterTable(recipe, inputName='with_validClumps',
+                                  outputName='nonSpecNC', filters={'validID' : [-0.5,0.5]}))
+        recipe.execute()
+        self.visFr.pipeline.selectDataSource('specLabelingNC')
+
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    SpecLabeling(visFr)