python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/ui/editFilterDialog.py

@@ -0,0 +1,80 @@
+#!/usr/bin/python
+
+##################
+# editFilterDialog.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import wx
+
+
+class FilterEditDialog(wx.Dialog):
+    def __init__(self, parent, mode='new', possibleKeys=[], key="", minVal=0.0, maxVal=1e5):
+        wx.Dialog.__init__(self, parent, title='Edit Filter ...')
+
+        sizer1 = wx.BoxSizer(wx.VERTICAL)
+        sizer2 = wx.BoxSizer(wx.HORIZONTAL)
+        
+        sizer2.Add(wx.StaticText(self, -1, 'Key:'), 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        
+        self.cbKey = wx.ComboBox(self, -1, value=key, choices=sorted(possibleKeys), style=wx.CB_DROPDOWN, size=(150, -1))
+
+        if not mode == 'new':
+            self.cbKey.Enable(False)
+
+        sizer2.Add(self.cbKey, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+
+        sizer2.Add(wx.StaticText(self, -1, 'Min:'), 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+
+        self.tMin = wx.TextCtrl(self, -1, '%3.2f' % minVal, size=(60, -1))
+        
+
+        sizer2.Add(self.tMin, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+
+        sizer2.Add(wx.StaticText(self, -1, 'Max:'), 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+
+        self.tMax = wx.TextCtrl(self, -1, '%3.2f' % maxVal, size=(60, -1))
+
+        sizer2.Add(self.tMax, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+
+        sizer1.Add(sizer2, 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()
+
+        sizer1.Add(btSizer, 0, wx.ALIGN_RIGHT|wx.ALL, 5)
+
+        self.SetSizer(sizer1)
+        sizer1.Fit(self)
+        
+        
+
+        
+        

PYME/ui/editList.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python
+##################
+# editList.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import wx
+#import PYME.contrib.listctrlMixins  as  listmix
+from wx.lib.mixins import listctrl as listmix
+
+class EditListCtrl(wx.ListCtrl,
+                   listmix.ListCtrlAutoWidthMixin,
+                   listmix.TextEditMixin):
+
+    def __init__(self, parent, ID, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=0):
+        wx.ListCtrl.__init__(self, parent, ID, pos, size, style)
+
+        listmix.ListCtrlAutoWidthMixin.__init__(self)
+        listmix.TextEditMixin.__init__(self)
+
+    
+
+

PYME/ui/fastGraph.py

@@ -0,0 +1,240 @@
+#!/usr/bin/python
+
+##################
+# histLimits.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import wx
+import wx.lib.newevent
+from PYME.ui import wx_compat
+
+import sys,math
+import numpy
+import os
+import numpy as np
+
+#from PYME.Analysis.binAvg import binAvg
+from scipy.interpolate import interp1d
+
+LimitChangeEvent, EVT_LIMIT_CHANGE = wx.lib.newevent.NewCommandEvent()
+
+class FastGraphPanel(wx.Panel):
+    def __init__(self, parent, id, xvals, data, log=False, size =(200, 100), pos=(0,0), threshMode= False):
+        wx.Panel.__init__(self, parent, id, size=size, pos=pos, style=wx.BORDER_SUNKEN)
+
+        self.dragging = None
+        self.binSize=None
+
+        self.isinit = False
+        
+
+        self.textSize = 10
+        self.log = log
+        self.left_margin = 20
+
+        self.threshMode = threshMode
+
+        self.SetData(xvals, data)
+
+
+        wx.EVT_PAINT(self, self.OnPaint)
+        wx.EVT_SIZE(self, self.OnSize)
+        #wx.EVT_LEFT_DOWN(self, self.OnLeftDown)
+        #wx.EVT_LEFT_UP(self, self.OnLeftUp)
+        #wx.EVT_MOTION(self, self.OnMouseMove)
+        #wx.EVT_KEY_DOWN(self, self.OnKeyPress)
+
+        self.isinit = True
+
+    def SetData(self, xvals, data):
+        self.data = data.ravel()
+        self.xvals = xvals.ravel()
+
+        dSort = numpy.argsort(self.xvals)
+        
+        #self.data[np.isnan(self.data)]
+
+        #self.upper_pctile = float(data[dSort[len(data)*.99]])
+        #self.lower_pctile = float(data[dSort[len(data)*.01]])
+
+        self.xmin = xvals[dSort[0]]
+        self.xmax = xvals[dSort[-1]]
+
+        self.limit_lower = float(self.xmin)
+        self.limit_upper = float(self.xmax)
+
+        self.GenHist()
+        if self.isinit:
+            self.Refresh()
+            self.Update()
+
+    def GenHist(self):
+        #self.hmin = min(self.limit_lower, self.lower_pctile)
+        #self.hmax = max(self.limit_upper, self.upper_pctile)
+        #if not self.limit_upper >= (self.limit_lower + 1e-9):
+        #    self.limit_upper += 1e-9
+            
+        self.hmin = self.limit_lower
+        self.hmax = self.limit_upper
+        
+        hmid = (self.hmin + self.hmax)/2.0
+
+        #expand shown range to twice current range
+        #self.hmin = hmid - 1.5*(hmid-self.hmin)
+        #self.hmax = hmid + 1.5*(self.hmax-hmid)
+
+        
+
+        self.hstep = float(self.hmax - self.hmin)/max(self.Size[0] - self.left_margin, 1)
+
+        #print self.hmin, self.hmax, self.hstep
+
+        self.edges = numpy.arange(self.hmin, self.hmax, self.hstep)
+
+        #n, m, s = binAvg(self.xvals, self.data, numpy.arange(self.hmin, self.hmax, self.hstep))
+        #self.h = m
+        
+        inter = interp1d(self.xvals, self.data, 'nearest')
+        self.h = inter(self.edges)
+
+        if self.log:
+            self.h = numpy.log10(self.h+.01) - numpy.log10(.01)
+
+        self.dmean = self.data.mean()
+        
+
+    def DoPaint(self, dc):
+        if self.Size[0] < 1 or self.Size[1] < 1: #nothing to do
+            return
+        dc.SetFont(wx.NORMAL_FONT)
+        self.textSize = dc.GetTextExtent('test')[1] + 4
+        #text_x = dc.GetTextExtent('test')[0]
+        
+
+        h = (self.Size[1] - self.textSize - 2)*(1.0-((self.h - self.h.min())/(1.0*(self.h.max()-self.h.min() + .1))))
+
+        maxy = self.Size[1] - self.textSize
+        pointlist = [(i+self.left_margin,h_i) for i, h_i in zip(range(len(h)), h)]
+        #pointlist = [(10,h[0])] + pointlist + [(self.Size[0], maxy)]
+
+        dc.Clear()
+
+        #when being used to determine histogram bins
+        if not self.binSize is None:
+            binEdges = numpy.arange(self.hmin, self.hmax + self.binSize, self.binSize)
+
+            for i in range(len(binEdges) -1):
+                llx = math.floor((binEdges[i] - self.hmin)/self.hstep)
+                ulx = math.ceil((binEdges[i+1] - self.hmin)/self.hstep)
+
+                dc.SetPen(wx.TRANSPARENT_PEN)
+
+                if i % 2 == 0: #even
+                    dc.SetBrush(wx.Brush(wx.Colour(0xC0, 0xC0, 0xFF)))
+                else:
+                    dc.SetBrush(wx.Brush(wx.Colour(0xA0, 0xA0, 0xFF)))
+
+                dc.DrawRectangle(llx, 0, ulx - llx, maxy)
+
+        dc.SetPen(wx.BLACK_PEN)
+        dc.SetBrush(wx.BLACK_BRUSH)
+        dc.DrawLines(pointlist)
+        
+        #if self.dragging == 'lower':
+        #    dc.SetPen(wx.Pen(wx.GREEN, 2))
+        #else:
+        #    dc.SetPen(wx.Pen(wx.RED, 2))
+
+        #print self.limit_lower
+
+        llx = (self.limit_lower - self.hmin)/self.hstep
+        #dc.DrawLine(llx, 0, llx, maxy)
+        lab = '%1.3G' % self.limit_lower
+        labSize = dc.GetTextExtent(lab)
+        dc.DrawText(lab, max(int(llx - labSize[0]/2 + self.left_margin), 0), maxy + 2)
+
+
+        if not self.threshMode:
+            #if self.dragging == 'upper':
+            #    dc.SetPen(wx.Pen(wx.GREEN, 2))
+            #else:
+            #    dc.SetPen(wx.Pen(wx.RED, 2))
+
+            ulx = (self.limit_upper - self.hmin)/self.hstep
+            #dc.DrawLine(ulx, 0, ulx, maxy)
+            lab = '%1.3G' % self.limit_upper
+            labSize = dc.GetTextExtent(lab)
+            dc.DrawText(lab, min(int(ulx - labSize[0]/2), self.Size[0] - labSize[0]), maxy + 2)
+            
+        lly = 0 #self.h.min()
+        #dc.DrawLine(llx, 0, llx, maxy)
+        lab = '%1.3G' % self.h.max()
+        labSize = dc.GetTextExtent(lab)
+        dc.DrawText(lab, 0, lly)
+        
+        # -  #self.h.min()
+        #dc.DrawLine(llx, 0, llx, maxy)
+        lab = '%1.3G' % self.h.min()
+        labSize = dc.GetTextExtent(lab)
+        lly = maxy - labSize[1]
+        dc.DrawText(lab, 0, lly)
+
+
+        dc.SetPen(wx.NullPen)
+        dc.SetBrush(wx.NullBrush)
+        dc.SetFont(wx.NullFont)
+
+    def OnPaint(self,event):
+        DC = wx.PaintDC(self)
+        #self.PrepareDC(DC)
+
+        s = self.GetVirtualSize()
+        MemBitmap = wx_compat.EmptyBitmap(s.GetWidth(), s.GetHeight())
+        #del DC
+        MemDC = wx.MemoryDC()
+        OldBitmap = MemDC.SelectObject(MemBitmap)
+        try:
+            #DC.BeginDrawing()
+
+            self.DoPaint(MemDC)
+
+            DC.Blit(0, 0, s.GetWidth(), s.GetHeight(), MemDC, 0, 0)
+            #DC.EndDrawing()
+        finally:
+
+            del MemDC
+            del MemBitmap
+
+    def OnSize(self, event):
+        self.GenHist()
+        self.Refresh()
+        self.Update()
+
+    
+
+
+class SpecGraphPanel(FastGraphPanel):
+    def __init__(self, parent, scope, id=-1):
+        FastGraphPanel.__init__(self, parent, id, scope.cam.XVals, scope.cam.XVals)
+
+        self.scope = scope
+
+    def refr(self, sender=None, **kwargs):
+        self.SetData(self.scope.cam.XVals, self.scope.frameWrangler.currentFrame)

PYME/ui/filterPane.py

@@ -0,0 +1,348 @@
+#!/usr/bin/python
+##################
+# filterPane.py
+#
+# Copyright David Baddeley, 2010
+# d.baddeley@auckland.ac.nz
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import wx
+from PYME.ui import UI_MAXSIZE #hack for sys.maxsize bug
+import sys
+#import PYME.ui.autoFoldPanel as afp
+import PYME.ui.manualFoldPanel as afp
+import numpy as np
+from PYME.contrib import dispatch
+
+from PYME.ui import histLimits
+from PYME.ui import editFilterDialog
+
+import logging
+logger = logging.getLogger(__name__)
+
+def CreateFilterPane(panel, mapping, pipeline, visFr):
+    pane = FilterPane(panel, mapping, pipeline, visFr)
+    panel.AddPane(pane)
+    return pane
+
+class FilterPanel(wx.Panel):
+    def __init__(self, parent, filterKeys, dataSource=None):
+        """
+
+        Parameters
+        ----------
+        parent : wx.Window
+
+        filterKeys : dict
+            Dictionary keys
+
+        dataSource : function
+            function to call to get the current data source
+        """
+        wx.Panel.__init__(self, parent)
+
+        self.filterKeys = filterKeys
+        self._dataSource = dataSource
+
+        self.on_filter_changed=dispatch.Signal()
+
+        #GUI stuff
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+
+        self.lFiltKeys = wx.ListCtrl(self, -1, style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.SUNKEN_BORDER, size=(-1, 25*(max(len(self.filterKeys.keys())+1, 5))))
+
+        self.lFiltKeys.InsertColumn(0, 'Key')
+        self.lFiltKeys.InsertColumn(1, 'Min')
+        self.lFiltKeys.InsertColumn(2, 'Max')
+
+        self.populate()
+
+        self.lFiltKeys.SetColumnWidth(0, wx.LIST_AUTOSIZE)
+        self.lFiltKeys.SetColumnWidth(1, wx.LIST_AUTOSIZE)
+        self.lFiltKeys.SetColumnWidth(2, wx.LIST_AUTOSIZE)
+
+        # only do this part the first time so the events are only bound once
+        if not hasattr(self, "ID_FILT_ADD"):
+            self.ID_FILT_ADD = wx.NewIdRef()
+            self.ID_FILT_DELETE = wx.NewIdRef()
+            self.ID_FILT_EDIT = wx.NewIdRef()
+
+            self.Bind(wx.EVT_MENU, self.OnFilterAdd, id=self.ID_FILT_ADD)
+            self.Bind(wx.EVT_MENU, self.OnFilterDelete, id=self.ID_FILT_DELETE)
+            self.Bind(wx.EVT_MENU, self.OnFilterEdit, id=self.ID_FILT_EDIT)
+
+        # for wxMSW
+        self.lFiltKeys.Bind(wx.EVT_COMMAND_RIGHT_CLICK, self.OnFilterListRightClick)
+
+        # for wxGTK
+        self.lFiltKeys.Bind(wx.EVT_RIGHT_UP, self.OnFilterListRightClick)
+
+        self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnFilterItemSelected)
+        self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnFilterItemDeselected)
+        self.lFiltKeys.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnFilterEdit)
+        
+
+        vsizer.Add(self.lFiltKeys, 1, wx.ALL|wx.EXPAND, 0)
+        #self.stNumFiltered = wx.StaticText(self, -1, '')
+        #vsizer.Add(self.stNumFiltered, 0, wx.ALL | wx.EXPAND, 2)
+        self.SetSizerAndFit(vsizer)
+        
+    def update(self, filter_keys, data_source):
+        self.filterKeys = filter_keys
+        self._dataSource = data_source
+        
+        self.populate()
+
+    def populate(self):
+        self.lFiltKeys.DeleteAllItems()
+        ind = 0
+        for key, value in self.filterKeys.items():
+            ind = self.lFiltKeys.InsertItem(ind+1, key)
+            self.lFiltKeys.SetItem(ind, 1, '%3.2f' % value[0])
+            self.lFiltKeys.SetItem(ind, 2, '%3.2f' % value[1])
+
+    @property
+    def dataSource(self):
+        if self._dataSource is None:
+            return None
+        elif callable(self._dataSource):
+            #support passing data source as a callable
+            return self._dataSource()
+        else:
+            return self._dataSource
+
+    def OnFilterListRightClick(self, event):
+
+        x = event.GetX()
+        y = event.GetY()
+
+        item, flags = self.lFiltKeys.HitTest((x, y))
+
+        # make a menu
+        menu = wx.Menu()
+        # add some items
+        menu.Append(self.ID_FILT_ADD, "Add")
+
+        if item != wx.NOT_FOUND and flags & wx.LIST_HITTEST_ONITEM:
+            self.currentFilterItem = item
+            self.lFiltKeys.Select(item)
+
+            menu.Append(self.ID_FILT_DELETE, "Delete")
+            menu.Append(self.ID_FILT_EDIT, "Edit")
+
+        # Popup the menu.  If an item is selected then its handler
+        # will be called before PopupMenu returns.
+        self.PopupMenu(menu)
+        menu.Destroy()
+
+    def OnFilterItemSelected(self, event):
+        self.currentFilterItem = event.GetIndex()
+        event.Skip()
+
+    def OnFilterItemDeselected(self, event):
+        self.currentFilterItem = None
+        event.Skip()
+
+    def OnFilterAdd(self, event):
+        #key = self.lFiltKeys.GetItem(self.currentFilterItem).GetText()
+
+        try:
+            possibleKeys = list(self.dataSource.keys())
+        except:
+            logger.exception('Error getting datasource keys')
+            possibleKeys = []
+
+        dlg = editFilterDialog.FilterEditDialog(self, mode='new', possibleKeys=possibleKeys)
+
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_OK:
+            minVal = float(dlg.tMin.GetValue())
+            maxVal = float(dlg.tMax.GetValue())
+
+            key = str(dlg.cbKey.GetValue())
+
+            if key == "":
+                return
+
+            self.filterKeys[key] = [minVal, maxVal]
+
+            ind = self.lFiltKeys.InsertItem(UI_MAXSIZE, key)
+            self.lFiltKeys.SetItem(ind, 1, '%3.2f' % minVal)
+            self.lFiltKeys.SetItem(ind, 2, '%3.2f' % maxVal)
+
+        dlg.Destroy()
+
+        self.on_filter_changed.send(self)
+
+    def OnFilterDelete(self, event):
+        it = self.lFiltKeys.GetItem(self.currentFilterItem)
+        self.lFiltKeys.DeleteItem(self.currentFilterItem)
+        self.filterKeys.pop(it.GetText())
+
+        self.on_filter_changed.send(self)
+
+    def OnFilterEdit(self, event):
+        key = str(self.lFiltKeys.GetItem(self.currentFilterItem).GetText())
+        minVal, maxVal = self.filterKeys[key]
+        #dlg = editFilterDialog.FilterEditDialog(self, mode='edit', possibleKeys=[], key=key, minVal=self.filterKeys[key][0], maxVal=self.filterKeys[key][1])
+        try:
+            data = np.array(self.dataSource[key])
+
+            dlg = histLimits.HistLimitDialog(self, data, minVal, maxVal, title=key, action=self.notify, key=key)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_OK:
+                #minVal = float(dlg.tMin.GetValue())
+                #maxVal = float(dlg.tMax.GetValue())
+                minVal, maxVal = dlg.GetLimits()
+
+                self.filterKeys[key] = [minVal, maxVal]
+
+                self.lFiltKeys.SetItem(self.currentFilterItem, 1, '%3.2f' % minVal)
+                self.lFiltKeys.SetItem(self.currentFilterItem, 2, '%3.2f' % maxVal)
+
+            dlg.Destroy()
+        except (RuntimeError, KeyError, TypeError):
+            dlg = editFilterDialog.FilterEditDialog(self, mode='edit', key=key,minVal=minVal, maxVal=maxVal)
+
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_OK:
+                minVal = float(dlg.tMin.GetValue())
+                maxVal = float(dlg.tMax.GetValue())
+
+                self.filterKeys[key] = [minVal, maxVal]
+
+                self.lFiltKeys.SetItem(self.currentFilterItem, 1, '%3.2f' % minVal)
+                self.lFiltKeys.SetItem(self.currentFilterItem, 2, '%3.2f' % maxVal)
+
+            dlg.Destroy()
+
+        self.notify(key)
+
+    def notify(self, key, limits=None):
+        if limits is not None:
+            minVal, maxVal = limits
+
+            self.filterKeys[key] = [minVal, maxVal]
+
+            self.lFiltKeys.SetItem(self.currentFilterItem, 1, '%3.2f' % minVal)
+            self.lFiltKeys.SetItem(self.currentFilterItem, 2, '%3.2f' % maxVal)
+
+        self.on_filter_changed.send(self)
+
+class FilterPane(afp.foldingPane):
+    def __init__(self, panel, filterKeys, pipeline, visFr):
+        afp.foldingPane.__init__(self, panel, -1, caption="Output Filter", pinned = False)
+
+        #self.filterKeys = filterKeys
+        self.pipeline = pipeline
+        self.visFr = visFr
+
+        #self.lFiltKeys = wx.ListCtrl(self, -1, style=wx.LC_REPORT|wx.LC_SINGLE_SEL|wx.SUNKEN_BORDER, size=(-1, 200))
+
+        self.pFilter = FilterPanel(self, filterKeys, pipeline.selectedDataSource)
+        self.pFilter.on_filter_changed.connect(pipeline.Rebuild)
+
+        self.AddNewElement(self.pFilter)
+
+        self.stFilterNumPoints = wx.StaticText(self, -1, '')
+
+        self.setEventNumbers()
+        self.pipeline.onRebuild.connect(self.setEventNumbers)
+        
+        self.AddNewElement(self.stFilterNumPoints)
+        #self._pnl.AddFoldPanelWindow(self, self.stFilterNumPoints, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 10)
+
+        self.bClipToSelection = wx.Button(self, -1, 'Clip to selection')
+        self.AddNewElement(self.bClipToSelection)
+        #self._pnl.AddFoldPanelWindow(self, self.bClipToSelection, fpb.FPB_ALIGN_WIDTH, fpb.FPB_DEFAULT_SPACING, 10)
+
+
+        self.bClipToSelection.Bind(wx.EVT_BUTTON, self.OnFilterClipToSelection)
+        
+        pipeline.onRebuild.connect(self.update)
+        
+        
+        try:        
+            visFr.Bind(wx.EVT_MENU, self.OnFilterClipToSelection, id=visFr.ID_VIEW_CLIP_ROI)
+        except AttributeError:
+            pass
+        
+    @property
+    def filterKeys(self):
+        return self.pipeline.filterKeys
+        
+    def update(self, *args, **kwargs):#, filter_keys):
+        #self.filterKeys = filter_keys
+        self.pFilter.update(self.filterKeys, self.pipeline.selectedDataSource)
+
+    def setEventNumbers(self,**kwargs):
+        if not self.pipeline.filter is None:
+            self.stFilterNumPoints.SetLabel('%d of %d events' % (len(self.pipeline.filter['x']), len(self.pipeline.selectedDataSource['x'])))
+        
+    def OnFilterClipToSelection(self, event):
+        if 'x' in self.filterKeys.keys() or 'y' in self.filterKeys.keys():
+            if 'x' in self.filterKeys.keys():
+                i = 0
+                while not self.pFilter.lFiltKeys.GetItemText(i) == 'x':
+                    i +=1
+                self.pFilter.lFiltKeys.DeleteItem(i)
+                self.filterKeys.pop('x')
+            if 'y' in self.filterKeys.keys():
+                i = 0
+                while not self.pFilter.lFiltKeys.GetItemText(i) == 'y':
+                    i +=1
+                self.pFilter.lFiltKeys.DeleteItem(i)
+                self.filterKeys.pop('y')
+
+            self.bClipToSelection.SetLabel('Clip to Selection')
+        else:
+            try:
+                #old glcanvas
+                x0, y0 = self.visFr.glCanvas.selectionStart
+                x1, y1 = self.visFr.glCanvas.selectionFinish
+            except AttributeError:
+                #new glcanvas
+                x0, y0, _ = self.visFr.glCanvas.selectionSettings.start
+                x1, y1, _ = self.visFr.glCanvas.selectionSettings.finish
+
+            if not 'x' in self.filterKeys.keys():
+                indx = self.pFilter.lFiltKeys.InsertItem(UI_MAXSIZE, 'x')
+            else:
+                indx = [self.pFilter.lFiltKeys.GetItemText(i) for i in range(self.pFilter.lFiltKeys.GetItemCount())].index('x')
+
+            if not 'y' in self.filterKeys.keys():
+                indy = self.pFilter.lFiltKeys.InsertItem(UI_MAXSIZE, 'y')
+            else:
+                indy = [self.pFilter.lFiltKeys.GetItemText(i) for i in range(self.pFilter.lFiltKeys.GetItemCount())].index('y')
+
+
+            self.filterKeys['x'] = (min(x0, x1), max(x0, x1))
+            self.filterKeys['y'] = (min(y0, y1), max(y0,y1))
+
+            self.pFilter.lFiltKeys.SetItem(indx,1, '%3.2f' % min(x0, x1))
+            self.pFilter.lFiltKeys.SetItem(indx,2, '%3.2f' % max(x0, x1))
+
+            self.pFilter.lFiltKeys.SetItem(indy,1, '%3.2f' % min(y0, y1))
+            self.pFilter.lFiltKeys.SetItem(indy,2, '%3.2f' % max(y0, y1))
+
+            self.bClipToSelection.SetLabel('Clear Clipping ROI')
+
+        self.pipeline.Rebuild()
+