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

PYMEcs/experimental/meas2DplotDh5view.py

@@ -0,0 +1,107 @@
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float
+
+class clusterParam(HasTraits):
+    Ryrminsize = Float(1.0)
+
+class Meas2DPlotter:
+    """
+
+    """
+    def __init__(self, dsviewer):
+        self.dsviewer = dsviewer
+        dsviewer.AddMenuItem('Experimental>Meas2D', 'Plot cluster measurements', self.OnPlotClust)
+        dsviewer.AddMenuItem('Experimental>Meas2D', 'Plot per cluster colocalisation', self.OnClusterColoc)
+        self.clusterPar = clusterParam() # initialise parameter selector
+        
+
+    def OnPlotClust(self, event=None):
+        nodata = False
+        try:
+            pipeline = self.dsviewer.pipeline
+        except AttributeError:
+            nodata = True
+        else:
+            if 'area' not in pipeline.keys():
+                nodata = True
+        if nodata:
+            print('no area column found - returning')
+            return
+        
+        if not self.clusterPar.configure_traits(kind='modal'):
+            return
+
+        mdh = self.dsviewer.image.mdh
+        vx = 1e3*mdh['voxelsize.x']
+        vy = 1e3*mdh['voxelsize.y']
+        RyRsz = 900.0 # RyR footprint in nm
+        ryrmin = self.clusterPar.Ryrminsize # minimal size of cluster to check
+        
+        ryrsall = pipeline['area']*vx*vy/RyRsz
+        ryrs = ryrsall[ryrsall > ryrmin]
+        ryrmean = ryrs.mean()
+        
+        import matplotlib.pyplot as plt
+        # plot data and fitted curves
+        plt.figure()
+        plt.hist(ryrs, bins=20)
+        plt.xlabel('RyRs')
+        plt.ylabel('Frequency')
+        plt.title('RyR size distribution (mean %.1f RyRs, %d clusters)' % (ryrmean,ryrs.shape[0]))
+        plt.show()
+
+    def OnClusterColoc(self, event=None):
+        nodata = False
+        try:
+            pipeline = self.dsviewer.pipeline
+        except AttributeError:
+            nodata = True
+        else:
+            if 'area' not in pipeline.keys():
+                nodata = True
+            if 'mean_intensity' not in pipeline.keys():
+                nodata = True
+        if nodata:
+            print('no area column found - returning')
+            return
+
+        if not self.clusterPar.configure_traits(kind='modal'):
+            return
+        
+        mdh = self.dsviewer.image.mdh
+        vx = 1e3*mdh['voxelsize.x']
+        vy = 1e3*mdh['voxelsize.y']
+        RyRsz = 900.0 # RyR footprint in nm
+        ryrmin = self.clusterPar.Ryrminsize # minimal size of cluster to check
+        
+        ryrs = pipeline['area']*vx*vy/RyRsz
+        ryrgtmin = ryrs > ryrmin
+
+        import matplotlib.pyplot as plt
+        import numpy as np
+        plt.figure()
+        plt.scatter(ryrs[ryrgtmin],pipeline['mean_intensity'][ryrgtmin],
+                    facecolors='lightgray', edgecolors='black')
+        plt.xlabel('RyRs')
+        plt.ylabel('fractional coloc')
+        plt.title('area fraction of IP3R in RyR clusters')
+        plt.ylim(0,1)
+
+        fracs1 = pipeline['mean_intensity'][ryrgtmin]
+        meanclc = fracs1.mean()
+        #print('mean fraction colocalising per cluster (RyRs>5): %.2f' % meanclc)
+
+        positive1 = (fracs1 > 0.05).sum()/float(fracs1.shape[0])
+        #print('fraction with positive staining: %.2f' % positive1)
+
+        plt.figure()
+        #mbins = np.arange(0,10,1.0)/10.0
+        h0 = plt.hist(pipeline['mean_intensity'][ryrgtmin],bins=10)
+        plt.title('mean coloc frac %.2f, cluster frac positive %.2f' % (meanclc,positive1))
+        plt.xlabel('coloc fraction per cluster')
+        plt.ylabel('frequency')
+        plt.show()
+
+        
+def Plug(dsviewer):
+    """Plugs this module into the gui"""
+    dsviewer.meas2Dplt = Meas2DPlotter(dsviewer)

PYMEcs/experimental/mortensen.py

@@ -0,0 +1,131 @@
+import numpy as np
+# you may need a lot more imports depending what functionality your require in your plugin
+
+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 PYMEcs.misc.guiMsgBoxes import Warn
+import PYMEcs.misc.shellutils as su
+
+class PlotOptions(HasTraits):
+    plotMode = Enum(('Compare with and without background',
+                     'Colour errors by photon number',
+                     'Scatter Density Plot',
+                     'Plot z errors (colour by photon number)'))
+
+# We use the formula (S30) from Mortensen et al, 2010 [1] which provides a nice closed-form expression for the localisation error;
+# note that this is likely a lower bound on actual error due to simplifying model assumptions (no read noise etc) 
+
+# Reference
+
+# 1. Optimized localization analysis for single-molecule tracking and super-resolution microscopy.
+#    Kim I Mortensen, L Stirling Churchman, James A Spudich, and Henrik Flyvbjerg.
+#    Nat Meth, 2017 vol. 18 (5) pp. 377-381.
+#    http://www.nature.com/doifinder/10.1038/nmeth.1447
+
+class MortensenFormula:
+    """
+    A plugin that calculates errors according to the Mortensen formula using photon number and background
+    estimates that event analysis has provided.
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+        self.plotOptions = PlotOptions()
+
+        visFr.AddMenuItem('Experimental>ExtraColumns>Errors', 'Add Mortensen Formula', self.OnAddMort,
+                          helpText='Add an event property that provides an estimate by the Mortensen Formula (from background and amplitude)')
+        visFr.AddMenuItem('Experimental>ExtraColumns>Errors', 'Plot Mortensen Error', self.OnPlotMort,
+                          helpText='Scatterplot estimate by the Mortensen Formula')
+        
+
+    def OnAddMort(self, event=None):
+        """
+        this function adds a 'mortensenError' property to events - there could be some discussion how that is actually best calculated
+        """
+        import math
+        mdh = self.pipeline.mdh
+        # the formula below is very adhoc
+        # I am not even sure this is remotely correct nor the best way
+        # so use only as a basis for experimentation and/or better plugins
+        N = self.pipeline['nPhotons']
+        # we think we do not need to subtract the camera offset
+        Nb = mdh['Camera.ElectronsPerCount'] * np.maximum(0,self.pipeline['fitResults_background'] / mdh['Camera.TrueEMGain'])
+        a = 1e3*mdh['voxelsize.x']
+        siga = np.sqrt(self.pipeline['sig']**2+a*a/12.0)
+
+        emort = siga /np.sqrt(N) * np.sqrt(16.0/9.0 + 8*math.pi*siga*siga*Nb/(N*a*a))
+        emort_nobg = siga /np.sqrt(N) * np.sqrt(16.0/9.0)
+        
+        cb = 1.0*Nb/N
+        self.pipeline.addColumn('cb_estimate', cb)
+        self.pipeline.addColumn('mortensenError',emort)
+        self.pipeline.addColumn('mortensenErrorNoBG',emort_nobg)
+        self.pipeline.addColumn('backgroundPhotons',Nb)
+        
+        self.pipeline.Rebuild()
+        self.visFr.CreateFoldPanel() # to make, for example, new columns show up in filter column selections
+
+
+    def OnPlotMort(self, event=None):
+        import matplotlib.pyplot as plt
+        pipeline = self.pipeline
+
+        err = pipeline['mortensenError']
+        err1 = np.percentile(err,1)
+        err99 = np.percentile(err,99)
+
+        errnbg = pipeline['mortensenErrorNoBG']
+        errnbg1 = np.percentile(errnbg,1)
+        errnbg99 = np.percentile(errnbg,99)
+
+        popt = self.plotOptions
+        if popt.configure_traits(kind='modal'):
+            if popt.plotMode == 'Compare with and without background':
+                plt.figure()
+                ebg = plt.scatter(pipeline['error_x'],pipeline['mortensenError'],
+                                  c='g',alpha=0.5)
+                enobg = plt.scatter(pipeline['error_x'],pipeline['mortensenErrorNoBG'],
+                                    c='r',alpha=0.5)
+                plt.legend((ebg,enobg),('error with bg','error assuming zero bg'))
+                plt.plot([errnbg1,err99],[errnbg1,err99])
+                plt.xlabel('Fit error x')
+                plt.ylabel('Error from Mortensen Formula')
+            elif popt.plotMode == 'Colour errors by photon number':
+                nph = pipeline['nPhotons']
+                nph5 = np.percentile(nph,5)
+                nph95 = np.percentile(nph,95)
+                plt.figure()
+                plt.scatter(pipeline['error_x'],pipeline['mortensenError'],
+                            c=nph,vmin=nph5,vmax=nph95,cmap=plt.cm.jet)
+                plt.plot([err1,err99],[err1,err99])
+                plt.xlabel('Fit error x')
+                plt.ylabel('Error from Mortensen Formula')
+                plt.title('error coloured with nPhotons')
+                plt.colorbar()
+            elif popt.plotMode == 'Scatter Density Plot':
+                plt.figure()
+                su.scatterdens(pipeline['error_x'],pipeline['mortensenError'],
+                               subsample=0.2, xlabel='Fit error x',
+                               ylabel='Error from Mortensen Formula',s=20)
+                plt.plot([err1,err99],[err1,err99])
+            elif popt.plotMode == 'Plot z errors (colour by photon number)':
+                if 'fitError_z0' not in pipeline.keys():
+                    Warn('No z error -  works only with fitError_z0 property')
+                    return
+                nph = pipeline['nPhotons']
+                nph5 = np.percentile(nph,5)
+                nph95 = np.percentile(nph,95)
+                plt.figure()
+                plt.scatter(pipeline['fitError_z0'],pipeline['mortensenError'],
+                            c=nph,vmin=nph5,vmax=nph95,cmap=plt.cm.jet)
+                plt.plot([err1,err99],[err1,err99])
+                plt.xlabel('Fit error z')
+                plt.ylabel('Error from Mortensen Formula')
+                plt.title('error coloured with nPhotons')
+                plt.colorbar()
+                
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.mortForm = MortensenFormula(visFr)

PYMEcs/experimental/ncsDenoise.py

@@ -0,0 +1,158 @@
+from PYME.DSView import ViewIm3D
+from PYME.localization.remFitBuf import CameraInfoManager
+
+# the NCS functionality needs the pyNCS in the path, either linked
+# into the PYMEcs.Analysis directory (e.g. via symlink) or as pyNCS in the PYTHONPATH
+# the code can be obtained from https://github.com/HuanglabPurdue/NCS,
+#   in the python3-6 directory
+# my testing shows that the implementation runs fine under python-2.7
+try:
+    import PYMEcs.Analysis.pyNCS.denoisetools as ncs
+except ImportError:
+    try:
+        import pyNCS.denoisetools as ncs
+    except ImportError:
+        ncs = None
+
+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 PYMEcs.misc.guiMsgBoxes import Warn
+
+from PYMEcs.misc.mapUtils import check_mapexists
+
+class ncsSelect(HasTraits):
+    winSize = Enum(64,128,256)
+    Rs = Int(8) # IMPORTANT: looks like the pyncs code assumes Rs is a divider of the imgsz (see imagsz2 below)!!
+    Lambda_nm = Float(690) # emission wavelength
+    NA = Float(1.49)     # objective NA
+    iterations = Int(15)
+    alpha = Float(0.2)
+
+class ncsDenoiser:
+    """
+GUI class to supply various map tools
+    """
+    def __init__(self, dsviewer):
+        self.dsviewer = dsviewer
+        self.do = dsviewer.do
+        self.image = dsviewer.image
+        self.ncsSel = ncsSelect() # by making it part of the object we retain parameters across invocations
+        self.ci = CameraInfoManager()
+
+        dsviewer.AddMenuItem('Experimental',
+                             'NCS denoising of small square ROI',
+                             self.OnNCSDenoise)
+
+    def OnNCSDenoise(self, event=None):
+        ncsSel = self.ncsSel
+        if not ncsSel.configure_traits(kind='modal'):
+            return
+        
+        mdh = self.image.mdh
+        img = self.image.data[:,:, self.do.zp, 0].squeeze() # current frame
+
+        # code below from pyncs.addnoise
+        # I is presumably average photon number; bg is background photons/pixel
+        # idealimg = np.abs(normimg)*I+bg
+        # poissonimg = np.random.poisson(idealimg)
+
+        # UNITS: scmosimg (ADUs) = electrons * [gain-as-ADU/electrons / flatfield] + readnoise(ADUs) + offset
+        # from which follows gain_for_pyNCS = [gain-as-ADU/electrons / flatfield]
+        # scmosimg = poissonimg*gainmap + np.sqrt(varmap)*np.random.randn(R,R)
+        # scmosimg += offset
+
+        if check_mapexists(mdh,'dark') is None:
+            Warn(None, 'ncsimage: no dark map found')
+            return
+        else:
+            dark = self.ci.getDarkMap(mdh)
+
+        if check_mapexists(mdh,'variance') is None:
+            Warn(None, 'ncsimage: no variance map found')
+            return
+        else:
+            # we need to convert to units of ADU^2
+            variance = self.ci.getVarianceMap(mdh)/(mdh['Camera.ElectronsPerCount']**2)
+
+        if check_mapexists(mdh,'flatfield') is None:
+            gain = 1.0/mdh['Camera.ElectronsPerCount']*np.ones_like(variance)
+        else:
+            # code above argues we need to divide by flatfield
+            gain = 1.0/(mdh['Camera.ElectronsPerCount']*self.ci.getFlatfieldMap(mdh))
+        
+        # the slice code needs a little bit of further checking
+        isz = ncsSel.winSize
+        imshape = img.shape
+        xstart = self.do.xp - isz/2
+        if xstart < 0:
+            xstart = imshape[0]/2 - isz/2
+        ystart = self.do.yp - isz/2
+        if ystart < 0:
+            ystart = imshape[1]/2 - isz/2
+
+        sliceSquare = np.s_[xstart:xstart+isz,ystart:ystart+isz] # either on crosshairs or in the centre
+        roi = [[xstart,xstart+isz],[ystart,ystart+isz],[self.do.zp,self.do.zp]]
+        
+        var_sl = variance[sliceSquare]
+        dark_sl = dark[sliceSquare]
+        gain_sl = gain[sliceSquare]
+        
+        # next few lines from NCSdemo_experiment which show how raw cmos data is pre-corrected
+        #  apply gain and offset correction
+        #  N = subims.shape[0]
+        #  imsd = (subims-np.tile(suboffset,(N,1,1)))/np.tile(subgain,(N,1,1))
+        #  imsd[imsd<=0] = 1e-6
+        
+        # therefore this needs to be in photoelectrons
+        imgcorr = mdh['Camera.ElectronsPerCount']*self.ci.correctImage(mdh, img)
+        imgc_sl = imgcorr[sliceSquare].squeeze()
+
+        imgc_sl_T = imgc_sl[:,:,None].transpose((2,0,1))
+        ret = np.clip(imgc_sl_T,1e-6,None,out=imgc_sl_T) # clip inplace at 1e-6
+
+        Rs = ncsSel.Rs # IMPORTANT: looks like the pyncs code assumes Rs is a divider of the imgsz (see imagsz2 below)!!
+        Pixelsize = mdh['voxelsize.x']
+        Lambda = ncsSel.Lambda_nm / 1e3 # emission wavelength
+        NA = ncsSel.NA     # objective NA
+        iterationN = ncsSel.iterations
+        alpha = ncsSel.alpha
+
+        if ncs is not None:
+            out = ncs.reducenoise(Rs,imgc_sl_T,var_sl,gain_sl,isz,Pixelsize,NA,Lambda,alpha,iterationN)
+        else:
+            out = imgc_sl_T # no reduction performed
+
+        # now we need code to show this image and make it possible to save that
+        disp_img = np.dstack([imgc_sl_T.squeeze(), out.squeeze()])
+        im = ImageStack(disp_img, titleStub = '%d pixel crop of Frame %d denoised' % (isz,self.do.zp))
+        im.mdh.copyEntriesFrom(mdh)
+
+        # NCS parameters and crop info
+        im.mdh['Parent'] = self.image.filename
+        im.mdh['Processing.Units'] = 'PhotoElectrons'
+        im.mdh['Processing.Type'] = 'NCS Denoising'
+        im.mdh['Processing.NCS.alpha'] = ncsSel.alpha
+        im.mdh['Processing.NCS.iterations'] = ncsSel.iterations
+        im.mdh['Processing.NCS.Rs'] = ncsSel.Rs
+        im.mdh['Processing.NCS.LambdaNM'] = ncsSel.Lambda_nm
+        im.mdh['Processing.NCS.NA'] = ncsSel.NA
+        im.mdh['Processing.CropROI'] = roi
+        im.mdh['Processing.Comment'] = 'First frame: original (photoelectrons), second frame: denoised'
+        
+        vx, vy, vz = self.image.voxelsize
+        ox, oy, oz = self.image.origin
+        im.mdh['Origin.x'] = ox + roi[0][0]*vx
+        im.mdh['Origin.y'] = oy + roi[1][0]*vy
+        im.mdh['Origin.z'] = oz
+
+        if self.dsviewer.mode == 'visGUI':
+            mode = 'visGUI'
+        else:
+            mode = 'lite'
+
+        dv = ViewIm3D(im, mode=mode, glCanvas=self.dsviewer.glCanvas, parent=wx.GetTopLevelParent(self.dsviewer))        
+                            
+def Plug(dsviewer):
+    dsviewer.ncsDenoiser = ncsDenoiser(dsviewer)

PYMEcs/experimental/onTimes.py

@@ -0,0 +1,295 @@
+import wx
+import numpy as np
+import sys
+from scipy import ndimage
+from PYMEcs.misc.guiMsgBoxes import Warn, Info
+
+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
+
+
+import logging
+logger = logging.getLogger(__file__)
+
+class propertyChoice(HasTraits):
+    clist = List([])
+    EventProperty = Enum(values='clist')
+
+    traits_view = View(Group(Item(name = 'EventProperty'),
+                             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 onTimer:
+    """
+
+    """
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.pipeline = visFr.pipeline
+
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          "onTimes from selected coalesced events",
+                          self.OnTimes,
+                          helpText='analyse the on time distribution of events in a region - needs the coalesced data source with nFrames event property')
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          "plot time series of clumps",
+                          self.OnPlotClumps,
+                          helpText='plots the time course of the selected events in a "single channel trace" - needs the clumpIndex event property')
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          "plot time series of event property",
+                          self.OnPlotProperty,
+                          helpText='plots a time series of the selected events in a "single channel trace" - using a user chosen event property')
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          "plot time gating from selected events\tCtrl+G",
+                          self.OnPlotTser,
+                          helpText='plots the time series of gating of detected molecules from the selected group of events')
+        visFr.AddMenuItem('Experimental>Event Processing',
+                          "Event density in ROI\tCtrl+D",
+                          self.OnEvtDensity,
+                          helpText='calculate the event density (events/unit area) in the current ROI/image area')
+
+
+    def OnEvtDensity(self,event):
+        from PYMEcs.Analysis.eventProperties import evtDensity, getarea
+        visFr = self.visFr
+        pipeline = visFr.pipeline
+
+        dens, intens1, intens2, trange = evtDensity(pipeline)
+        area = getarea(pipeline)
+
+        if dens is None:
+            Warn(visFr,'area too small (%.2f um^2)' % (area))
+        else:
+            infostr = \
+"""
+Event density:        %.1f events/um^2
+Norm. intens.: %.1f events/um^2/5K-fr
+Norm. intens.: %.1f events/(20um)^2/fr
+Number of Events:     %d events
+Area probed:          %.2f um^2
+Time range:           %.2fK frames""" % (dens, intens1, intens2, dens*area, area, trange/1e3)
+            Info(visFr,infostr)
+
+
+    def OnPlotTser(self,event):
+        from PYMEcs.misc.shellutils import plotserpipeline
+
+        visFr = self.visFr
+        pipeline = visFr.pipeline
+        mdh = pipeline.mdh
+
+        t = pipeline['t']
+        maxPts = 1e4
+        if len(t) > maxPts:
+            Warn(None,'aborting darktime analysis: too many events, current max is %d' % maxPts)
+            return
+
+        p = pipeline
+
+        # if we have coalesced events use this info
+        if ('tmin' in pipeline.keys()) and ('tmax' in pipeline.keys()):
+            tmin = pipeline['tmin']
+            tmax = pipeline['tmax']
+            tc = np.arange(tmin[0],tmax[0]+1)
+            for i in range(1,tmin.shape[0]):
+                tc = np.append(tc,np.arange(tmin[i],tmax[i]+1))
+            tc.sort()
+        else:
+            tc = t
+        
+        startn = pipeline.selectedDataSource['t'].min()
+        endn = pipeline.selectedDataSource['t'].max()
+
+        tt, v = plotserpipeline(tc, np.ones_like(tc))
+
+        # add points to start from beginning of series
+        tt2 = np.append([startn,tt[0],tt[0]],tt)
+        v2 = np.append([0,0,1],v)
+        # add points to go to end of series
+        tt2 = np.append(tt2,[tt[-1],tt[-1],endn])
+        v2 = np.append(v2,[1,0,0])
+        
+        import matplotlib.pyplot as plt
+        # plot data and fitted curves
+        plt.figure()
+        plt.plot(tt2,v2)
+        plt.show()
+        plt.xlim(startn,endn)
+        
+    def OnTimes(self,event):
+        import StringIO
+        from PYMEcs.Analysis import fitDarkTimes
+        
+        visFr = self.visFr
+        pipeline = visFr.pipeline
+        mdh = pipeline.mdh
+
+        NTMIN = 5
+        maxPts = 1e5
+        t = pipeline['t']
+        if len(t) > maxPts:
+            Warn(None,'aborting analysis: too many events, current max is %d' % maxPts)
+            return
+        x = pipeline['x']
+        y = pipeline['y']
+
+        # determine darktime from gaps and reject zeros (no real gaps) 
+
+        try:
+            dtg = pipeline['nFrames']
+        except KeyError:
+            Warn(None,'aborting analysis: could not find "nFrames" property, needs "Coalesced" Data Source','Error')
+            return
+
+        nts = dtg.shape[0]
+
+        if nts > NTMIN:
+            # now make a cumulative histogram from these
+            cumux,cumuy = fitDarkTimes.cumuhist(dtg)
+            binctrs,hc,binctrsg,hcg = fitDarkTimes.cumuhistBinned(dtg)
+            
+            bbx = (x.min(),x.max())
+            bby = (y.min(),y.max())
+            voxx = 1e3*mdh['voxelsize.x']
+            voxy = 1e3*mdh['voxelsize.y']
+            bbszx = bbx[1]-bbx[0]
+            bbszy = bby[1]-bby[0]
+
+        # fit theoretical distributions
+        popth,pcovh,popt,pcov = (None,None,None,None)
+        if nts > NTMIN:
+            from scipy.optimize import curve_fit
+
+            idx = (np.abs(hcg - 0.63)).argmin()
+            tauesth = binctrsg[idx]
+            popth,pcovh,infodicth,errmsgh,ierrh = curve_fit(fitDarkTimes.cumuexpfit,binctrs,hc, p0=(tauesth),full_output=True)
+            chisqredh = ((hc - infodicth['fvec'])**2).sum()/(hc.shape[0]-1)
+            idx = (np.abs(cumuy - 0.63)).argmin()
+            tauest = cumux[idx]
+            popt,pcov,infodict,errmsg,ierr = curve_fit(fitDarkTimes.cumuexpfit,cumux,cumuy, p0=(tauest),full_output=True)
+            chisqred = ((cumuy - infodict['fvec'])**2).sum()/(nts-1)
+
+            import matplotlib.pyplot as plt
+            # plot data and fitted curves
+            plt.figure()
+            plt.subplot(211)
+            plt.plot(cumux,cumuy,'o')
+            plt.plot(cumux,fitDarkTimes.cumuexpfit(cumux,popt[0]))
+            plt.plot(binctrs,hc,'o')
+            plt.plot(binctrs,fitDarkTimes.cumuexpfit(binctrs,popth[0]))
+            plt.ylim(-0.2,1.2)
+            plt.subplot(212)
+            plt.semilogx(cumux,cumuy,'o')
+            plt.semilogx(cumux,fitDarkTimes.cumuexpfit(cumux,popt[0]))
+            plt.semilogx(binctrs,hc,'o')
+            plt.semilogx(binctrs,fitDarkTimes.cumuexpfit(binctrs,popth[0]))
+            plt.ylim(-0.2,1.2)
+            plt.show()
+            
+            outstr = StringIO.StringIO()
+
+            analysis = {
+                'Nevents' : t.shape[0],
+                'Ndarktimes' : nts,
+                'filterKeys' : pipeline.filterKeys.copy(),
+                'darktimes' : (popt[0],popth[0]),
+                'darktimeErrors' : (np.sqrt(pcov[0][0]),np.sqrt(pcovh[0][0]))
+            }
+
+            #if not hasattr(self.visFr,'analysisrecord'):
+            #    self.visFr.analysisrecord = []
+            #    self.visFr.analysisrecord.append(analysis)
+
+            print >>outstr, "events: %d, on times: %d" % (t.shape[0],nts)
+            print >>outstr, "region: %d x %d nm (%d x %d pixel)" % (bbszx,bbszy,bbszx/voxx,bbszy/voxy)
+            print >>outstr, "centered at %d,%d (%d,%d pixels)" % (x.mean(),y.mean(),x.mean()/voxx,y.mean()/voxy)
+            print >>outstr, "ontime: %.1f+-%d (%.1f+-%d) frames - chisqr %.2f (%.2f)" % (popt[0],np.sqrt(pcov[0][0]),
+                                                                                           popth[0],np.sqrt(pcovh[0][0]),
+                                                                                           chisqred,chisqredh)
+            print >>outstr, "ontime: starting estimates: %.1f (%.1f)" % (tauest,tauesth)
+            print >>outstr, "qunits: %.2f (%.2f), mean on time: %.2f" % (100.0/popt[0], 100.0/popth[0], dtg.mean())
+
+            labelstr = outstr.getvalue()
+            plt.annotate(labelstr, xy=(0.5, 0.1), xycoords='axes fraction',
+                         fontsize=10)
+        else:
+            Warn(None, 'not enough data points, only found %d on times (need at least  %d)' % (nts,NTMIN), 'Error')
+
+    def OnPlotClumps(self,event):
+        import PYMEcs.Analysis.timeSeries as ts
+        try:
+            ci = self.pipeline['clumpIndex']
+        except KeyError:
+            Warn(None,'aborting analysis: could not find "clumpIndex" property','Error')
+            return
+        t = self.pipeline['t']
+
+        maxPts = 1e4
+        if len(t) > maxPts:
+            Warn(None,'aborting analysis: too many events, current max is %d' % maxPts)
+            return
+
+        ts.plotClumpSeries(t, ci)
+
+    def tserFromPipeline(self,key,base=0):
+    # t is on integer times assumed (from pipeline)
+    # val is the corresponding value
+        t = self.pipeline['t']
+        val = self.pipeline[key]
+    
+        tmin = t.min()
+        tmax = t.max()
+        tstart = tmin-1
+        tend = tmax + 1
+        tlen = tend-tstart+1
+
+        to = t-tstart
+        tidx = np.argsort(to)
+        tos = to[tidx]
+        vs = val[tidx]
+
+        tvalid = np.zeros((tlen))
+        tvalid[tos] = 1
+    
+        vals = np.zeros((tlen))
+        vals[tos] = vs
+    
+        tup = tos[1:][(tos[1:]-tos[:-1] > 1)]
+        tvalid[tup-1] = 1
+        vals[tup-1] = base
+
+        tdown = tos[:-1][(tos[1:]-tos[:-1] > 1)]
+        tvalid[tdown+1] = 1
+        vals[tdown+1] = base
+
+        tplot = tvalid.nonzero()[0]
+        vplot = vals[tplot]
+        
+        return (tplot+tstart,vplot)
+
+
+    def OnPlotProperty(self,event):
+        pChoice = propertyChoice()
+        pChoice.add_channels(sorted(self.pipeline.keys()))
+        if pChoice.configure_traits(kind='modal'):
+            t,prop = self.tserFromPipeline(pChoice.EventProperty)
+            if t.shape[0] > 2e4:
+                 Warn(None,'aborting analysis: too many events, current max is %d' % 2e4)
+                 return
+            import matplotlib.pyplot as plt
+            plt.figure()
+            plt.plot(t,prop)
+            plt.xlabel('Frame Number')
+            plt.ylabel(pChoice.EventProperty)
+            plt.show()
+            
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.onTimer = onTimer(visFr)