python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/LMVis/Extras/pointSetGeneration.py

@@ -0,0 +1,232 @@
+#!/usr/bin/python
+##################
+# pointSetGeneration.py
+#
+# Copyright David Baddeley, 2011
+# 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/>.
+#
+##################
+
+
+from PYME.recipes.traits import HasTraits, Float, File, BaseEnum, Enum, List, Instance, Str
+    
+from PYME.simulation.pointsets import PointSource, WormlikeSource, ImageSource, FileSource
+
+
+class Generator(HasTraits):
+    meanIntensity = Float(500)
+    meanDuration = Float(3)
+    backgroundIntensity = Float(300)
+    meanEventNumber = Float(2)
+    scaleFactor = Float(2) # Note: we don't expose the scale factor in the view
+    meanTime= Float(2000)
+    mode = Enum(['STORM','PAINT'])
+
+    sources = List([WormlikeSource(), ImageSource(), FileSource()])
+
+    source = Instance(PointSource)
+
+    helpInfo = {
+        'source': '''
+Select the type of point source to generate points.
+A wormlike source, an image based source and a file based source are supported.
+''',
+        'meanIntensity': '''
+This parameter specifies the mean number of photons in an event.
+Typically values are in the range from 100 to several 10000.
+''',
+        'meanDuration': '''
+The mean duration of events which is specified in units of frames.
+''',
+        'meanTime': '''
+This parameter, the mean time of the series in frame units, is the average time at which you expect to get events
+(i.e. the value of np.mean(pipeline['t']) for the simulated set of events). Since STORM mode draws event times from
+an exponential distribution, PAINT from a uniform one, it can also be related to the resulting apparent series duration,
+which may be more familar to experimentally minded users. For PAINT mode it works out as half the duration of the series,
+for STORM simulation mode the relationship is a little more complex,
+you can work it out from the decay time of an exponential distribution.
+''',
+        'meanEventNumber': '''
+This parameter specifies the mean number of times an event occurs at a single marker location.
+''',
+        'backgroundIntensity' : '''
+The background intensity per pixel in units of photons, typically in the range from a few tens to hundreds of photons.
+''',
+        'mode': '''
+With the simulation mode you can choose between STORM or PAINT mode.
+This parameter effects how event rate changes with time (it stays constant in PAINT mode).
+''',
+        'scaleFactor': '''
+This parameter is related to the size of the PSF for purposes of thresholding
+(used in combination with the background intensity, which is per pixel).
+There should be no need to modify this from the default and it is accordingly not exposed in the view.
+ 
+''',
+    }
+
+    def helpStr(self, name):
+        def cleanupHelpStr(str):
+            return str.strip().replace('\n', ' ').replace('\r', '')
+        
+        return cleanupHelpStr(self.helpInfo[name])
+        
+    def default_traits_view( self ):
+        from traitsui.api import View, Item, InstanceEditor
+
+        traits_view = View( Item( 'source',
+                            label= 'Point source',
+                            editor =
+                            InstanceEditor(name = 'sources',
+                                editable = True),
+                            help=self.helpStr('source'),
+                                ),
+                        Item('_'),
+                        Item('meanIntensity',tooltip='mean photon number of events',
+                             help=self.helpStr('meanIntensity')),
+                        Item('meanDuration',tooltip='mean duration of events in units of frames',
+                             help=self.helpStr('meanDuration')),
+                        Item('meanEventNumber',tooltip='mean number of times events occurs at a single marker location',
+                             help=self.helpStr('meanEventNumber')),
+                        Item('meanTime',tooltip='mean time of the series, roughly related to series duration, in frame units',
+                             help=self.helpStr('meanTime')),
+                        Item('_'),
+                        Item('backgroundIntensity',tooltip='background intensity in units of photons',
+                             help=self.helpStr('backgroundIntensity')),
+                        Item('_'),
+                        Item('mode',tooltip='STORM or PAINT mode, effects how event rate changes with time',
+                             help=self.helpStr('mode')),  
+                        
+                        buttons = ['OK', 'Help'])
+        
+        return traits_view
+
+    def __init__(self, visFr = None):
+        self.visFr = visFr
+        self.source = self.sources[0]
+
+        if visFr:
+            visFr.AddMenuItem('Extras>Synthetic Data', "Configure", self.OnConfigure)
+            visFr.AddMenuItem('Extras>Synthetic Data', 'Generate fluorophore positions and events', self.OnGenPoints)
+            visFr.AddMenuItem('Extras>Synthetic Data', 'Generate events', self.OnGenEvents)
+            visFr.AddMenuItem('Extras>Synthetic Data', 'Save fluorophore positions', self.OnSavePoints)
+
+
+
+    def OnConfigure(self, event):
+        self.source.refresh_choices()
+        self.edit_traits()
+
+    def OnGenPoints(self, event):
+        self.xp, self.yp, self.zp = self.source.getPoints()
+        self.OnGenEvents(None)
+
+
+    def OnSavePoints(self, event):
+        import wx
+        try:
+            x = self.xp
+        except AttributeError:
+            wx.MessageBox('No points! Generate fluorophore positions first', 'Warning', style=wx.OK)
+            return
+
+        # using a pandas based CSV IO here, there may be preferences for a more direct implementation
+        # I (CS) like it for the high-level interface
+        import pandas as pd
+        df = pd.DataFrame({'x': self.xp,
+                           'y': self.yp,
+                           'z': self.zp})
+        filename = wx.FileSelector("Save coordinates as",
+                                   wildcard='Comma separated values (*.csv)|*.csv',
+                                   flags=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+        df.to_csv(filename,index=False)
+
+        
+    def OnGenEvents(self, event):
+        from PYME.simulation import locify
+        from PYME.IO import tabular
+        from PYME.IO.image import ImageBounds
+        # import pylab
+        import matplotlib.pyplot as plt
+        
+        #wc = wormlike2.WormlikeChain(100)
+        
+        pipeline = self.visFr.pipeline
+        pipeline.filename='Simulation'
+
+        plt.figure()
+        plt.plot(self.xp, self.yp, 'x') #, lw=2)
+        if isinstance(self.source, WormlikeSource):
+            plt.plot(self.xp, self.yp, lw=2)
+
+        if self.mode == 'STORM':
+            res = locify.eventify(self.xp, self.yp, self.meanIntensity, self.meanDuration, self.backgroundIntensity,
+                                  self.meanEventNumber, self.scaleFactor, self.meanTime, z=self.zp)
+        else:
+            res = locify.eventify2(self.xp, self.yp, self.meanIntensity, self.meanDuration, self.backgroundIntensity,
+                                  self.meanEventNumber, self.scaleFactor, self.meanTime, z=self.zp)
+        
+        plt.plot(res['fitResults']['x0'],res['fitResults']['y0'], '+')
+
+        ds = tabular.MappingFilter(tabular.FitResultsSource(res))
+
+        try:
+            # some data sources (current ImageSource) have image bound info. Use this if available
+            # this could fail on either an AttributeError (if the data source doesn't implement bounds
+            # or another error if something fails in get_bounds(). Only catch the AttributeError, as we have
+            # should not be handling other errors here.
+            pipeline.imageBounds = self.source.get_bounds()
+        except AttributeError:
+            pipeline.imageBounds = ImageBounds.estimateFromSource(ds)
+
+        from PYME.IO.MetaDataHandler import NestedClassMDHandler
+        ds.mdh = NestedClassMDHandler()
+        ds.mdh['Camera.ElectronsPerCount'] = 1
+        ds.mdh['Camera.TrueEMGain'] = 1
+        ds.mdh['Camera.CycleTime'] = 1
+        ds.mdh['voxelsize.x'] = .110
+        # some info about the parameters
+        ds.mdh['GeneratedPoints.MeanIntensity'] = self.meanIntensity
+        ds.mdh['GeneratedPoints.MeanDuration'] = self.meanDuration
+        ds.mdh['GeneratedPoints.MeanEventNumber'] = self.meanEventNumber
+        ds.mdh['GeneratedPoints.BackgroundIntensity'] = self.backgroundIntensity
+        ds.mdh['GeneratedPoints.ScaleFactor'] = self.scaleFactor
+        ds.mdh['GeneratedPoints.MeanTime'] = self.meanTime
+        ds.mdh['GeneratedPoints.Mode'] = self.mode
+        # the source info
+        self.source.genMetaData(ds.mdh)
+            
+        pipeline.addDataSource('Generated Points', ds)
+        pipeline.selectDataSource('Generated Points')
+
+        try:
+            pipeline.filterKeys.pop('sig')
+        except:
+            pass
+
+        pipeline.Rebuild()
+        if len(self.visFr.layers) < 1:
+            self.visFr.add_pointcloud_layer() #TODO - move this logic so that layer added automatically when datasource is added?
+        #self.visFr.CreateFoldPanel()
+        self.visFr.SetFit()
+
+
+
+def Plug(visFr):
+    """Plugs this module into the gui"""
+    visFr.pt_generator = Generator(visFr)
+
+
+

PYME/LMVis/Extras/pointwiseColoc.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+##################
+# pointwiseColoc.py
+#
+# Copyright David Baddeley, 2010
+# d.baddeley@auckland.ac.nz
+# 
+# This file may NOT be distributed without express permision from David Baddeley
+#
+##################
+
+#import wx
+
+class PointwiseColocaliser:
+    def __init__(self, visFr):
+        self.visFr = visFr
+
+        visFr.AddMenuItem('Analysis', "Pointwise Colocalisation", self.OnPointwiseColoc)
+        
+    def OnPointwiseColoc(self, event):
+        import wx
+        #from PYME import mProfile
+        #mProfile.profileOn(['distColoc.py'])
+        from PYME.Analysis.Colocalisation import distColoc
+        from PYME.DSView.modules.coloc import ColocSettingsDialog
+
+        chans = self.visFr.pipeline.colourFilter.getColourChans()
+
+        if len(chans) == 0:
+            md = wx.MessageDialog(self.visFr, 'Not enough colour channels', 
+                                  'Pointwise colocalization requires 2 colour channels', wx.OK)
+            md.ShowModal()
+            return
+
+        dlg = ColocSettingsDialog(self.visFr, names=chans, show_bins=False)
+        
+        if dlg.ShowModal() == wx.ID_OK:
+
+            selected_chans = [chans[int(x)] for x in dlg.GetChans()]  # re-index into chans b/c calcDistCorr expects full channel names
+
+            #A vs B
+            distColoc.calcDistCorr(self.visFr.pipeline.colourFilter, *selected_chans)
+            #B vs A
+            #distColoc.calcDistCorr(self.visFr.colourFilter, *(self.visFr.colourFilter.getColourChans()[::-1]))
+            #mProfile.report()
+
+        dlg.Destroy()
+
+
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    PointwiseColocaliser(visFr)
+
+

PYME/LMVis/Extras/saved_views.py

@@ -0,0 +1,125 @@
+#!/usr/bin/python
+
+# ViewPanel.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# 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 json
+
+import wx
+
+from PYME.LMVis.Extras.dockedPanel import DockedPanel
+from PYME.LMVis.views import View
+
+
+class ViewPanel(DockedPanel):
+    def __init__(self, parent_panel, **kwargs):
+        kwargs['style'] = wx.TAB_TRAVERSAL
+        wx.Panel.__init__(self, parent_panel, **kwargs)
+        self.parent_panel = parent_panel
+        self.alternate = True
+        vertical_sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self.create_buttons(vertical_sizer)
+
+        self.SetSizerAndFit(vertical_sizer)
+
+    def create_buttons(self, vertical_sizer):
+        grid_sizer = wx.GridSizer(rows=6, cols=1, vgap=1, hgap=1)
+        x_button = wx.Button(self, -1, label='View in x', style=wx.BU_EXACTFIT)
+        y_button = wx.Button(self, -1, label='View in y', style=wx.BU_EXACTFIT)
+        z_button = wx.Button(self, -1, label='View in z', style=wx.BU_EXACTFIT)
+
+        skip = wx.StaticText(self, -1, label='', style=wx.BU_EXACTFIT)
+        save_button = wx.Button(self, -1, label='Save View', style=wx.BU_EXACTFIT)
+        load_button = wx.Button(self, -1, label='Load View', style=wx.BU_EXACTFIT)
+
+        self.Bind(wx.EVT_BUTTON, lambda e: self.set_view_x(), x_button)
+        self.Bind(wx.EVT_BUTTON, lambda e: self.set_view_y(), y_button)
+        self.Bind(wx.EVT_BUTTON, lambda e: self.set_view_z(), z_button)
+        self.Bind(wx.EVT_BUTTON, lambda e: self.save_view(), save_button)
+        self.Bind(wx.EVT_BUTTON, lambda e: self.load_view(), load_button)
+
+        grid_sizer.Add(x_button, flag=wx.EXPAND)
+        grid_sizer.Add(y_button, flag=wx.EXPAND)
+        grid_sizer.Add(z_button, flag=wx.EXPAND)
+        grid_sizer.Add(skip, flag=wx.EXPAND)
+        grid_sizer.Add(save_button, flag=wx.EXPAND)
+        grid_sizer.Add(load_button, flag=wx.EXPAND)
+        vertical_sizer.Add(grid_sizer, flag=wx.EXPAND)
+
+    def set_view_x(self):
+        vec_up = [0, 1, 0]
+        if self.alternate:
+            vec_back = [1, 0, 0]
+        else:
+            vec_back = [-1, 0, 0]
+        vec_right = [0, 0, 1]
+
+        self.set_view(vec_up, vec_back, vec_right)
+
+    def set_view_y(self):
+        vec_up = [0, 0, 1]
+        if self.alternate:
+            vec_back = [0, 1, 0]
+        else:
+            vec_back = [0, -1, 0]
+        vec_right = [1, 0, 0]
+        self.set_view(vec_up, vec_back, vec_right)
+
+    def set_view_z(self):
+        vec_up = [0, 1, 0]
+        if self.alternate:
+            vec_back = [0, 0, 1]
+        else:
+            vec_back = [0, 0, -1]
+        vec_right = [1, 0, 0]
+        self.set_view(vec_up, vec_back, vec_right)
+
+    def set_view(self, vec_up, vec_back, vec_right):
+        if self.get_canvas().displayMode == '2D':
+            dlg = wx.MessageDialog(self,
+                                   'Setting views in only possible in 3d mode', 'Info', wx.OK | wx.ICON_INFORMATION)
+            dlg.ShowModal()
+            dlg.Destroy()
+        else:
+            old_view = self.get_canvas().get_view()
+            self.alternate = not self.alternate
+            new_view = View(old_view.view_id, vec_up, vec_back, vec_right, old_view.translation, old_view.scale)
+            self.get_canvas().set_view(new_view)
+
+    def save_view(self):
+        view = self.get_canvas().get_view()
+        file_name = wx.FileSelector('Save view as json named... ')
+        if file_name:
+            if not file_name.endswith('.json'):
+                file_name = '{}.json'.format(file_name)
+            with open(file_name, 'w') as f:
+                f.writelines(json.dumps(view.to_json(), indent=4))
+
+    def load_view(self):
+        file_name = wx.FileSelector('Open View-JSON file')
+        if file_name:
+            with open(file_name, 'r') as f:
+                view = View.decode_json(json.load(f))
+            self.get_canvas().set_view(view)
+
+
+def Plug(vis_fr):
+    print('Saved Views are deprecated -  use the ones with animation instead and remove me!')
+    pass
+    #DockedPanel.add_menu_item(vis_fr, 'Saved Views', ViewPanel, 'view_panel')

PYME/LMVis/Extras/scaleBox.py

@@ -0,0 +1,115 @@
+#!/usr/bin/python
+
+# scaleBox.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# 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 numpy
+import wx
+
+import wx.lib.agw.cubecolourdialog as ccd
+
+from PYME.LMVis.Extras.dockedPanel import DockedPanel
+
+
+class ScaleBoxPanel(DockedPanel):
+    """
+    This panel is the gui for creating and controlling the bounding box of the
+     data and setting a grid with a given tick distance
+    """
+    def __init__(self, parent_panel, **kwargs):
+        super(ScaleBoxPanel, self).__init__(parent_panel, **kwargs)
+        self._show_box = False
+        vertical_sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self.create_gui(vertical_sizer)
+
+        self.SetSizerAndFit(vertical_sizer)
+        self.show_box()
+
+    def create_gui(self, vertical_sizer):
+        x_button = wx.Button(self, -1, label='x', style=wx.BU_EXACTFIT)
+        y_button = wx.Button(self, -1, label='y', style=wx.BU_EXACTFIT)
+        z_button = wx.Button(self, -1, label='z', style=wx.BU_EXACTFIT)
+        color_button = wx.Button(self, -1, label='Color', style=wx.BU_EXACTFIT)
+        show_button = wx.Button(self, -1, label='Show', style=wx.BU_EXACTFIT)
+
+        x_button.Bind(wx.EVT_BUTTON, lambda e: self.flip(x_flip=True))
+        y_button.Bind(wx.EVT_BUTTON, lambda e: self.flip(y_flip=True))
+        z_button.Bind(wx.EVT_BUTTON, lambda e: self.flip(z_flip=True))
+        color_button.Bind(wx.EVT_BUTTON, lambda e: self.pick_color())
+        show_button.Bind(wx.EVT_BUTTON, lambda e: self.show_box())
+
+        grid_sizer = wx.GridSizer(rows=3, cols=1, vgap=1, hgap=1)
+        horizontal_box = wx.BoxSizer(wx.HORIZONTAL)
+        horizontal_box.Add(x_button, 1, flag=wx.EXPAND | wx.ALL)
+        horizontal_box.Add(y_button, 1, flag=wx.EXPAND | wx.ALL)
+        horizontal_box.Add(z_button, 1, flag=wx.EXPAND | wx.ALL)
+        grid_sizer.Add(horizontal_box, 1, flag=wx.EXPAND | wx.ALL)
+        grid_sizer.Add(color_button, 1, flag=wx.EXPAND | wx.ALL)
+
+        grid_sizer.Add(show_button, 1, flag=wx.EXPAND | wx.ALL)
+        vertical_sizer.Add(grid_sizer, 0, flag=wx.EXPAND | wx.ALL)
+
+    def flip(self, x_flip=False, y_flip=False, z_flip=False):
+        self.get_scale_box_layer().flip_starts(x_flip, y_flip, z_flip)
+        self.refresh_canvas()
+
+    def show_box(self):
+        self._show_box = not self._show_box
+        self.get_scale_box_layer().show(self._show_box)
+        self.refresh_canvas()
+
+    def get_scale_box_layer(self):
+        return self.parent_panel.glCanvas.ScaleBoxOverlayLayer
+
+    def refresh_canvas(self):
+        #self.parent_panel.glCanvas.OnDraw()
+        self.parent_panel.glCanvas.Refresh()
+
+    def pick_color(self):
+        """
+        This is mostly from the wxPython Demo!
+        """
+        dlg = ccd.CubeColourDialog(self)
+
+        # Ensure the full colour dialog is displayed,
+        # not the abbreviated version.
+        dlg.GetColourData().SetChooseFull(True)
+
+        if dlg.ShowModal() == wx.ID_OK:
+            data = dlg.GetRGBAColour()
+            self.get_scale_box_layer().set_color(numpy.array(data)/255.0)
+        dlg.Destroy()
+        self.refresh_canvas()
+
+
+def Plug(vis_fr):
+    """
+    There's no chance to determine if shaders are supported or not. Since this layer is only
+    added to the shader version, it will fail in the non-shader version. The later doesn't
+    have the required methods.
+    It will fail, when you try to get a bounding box. If you don't select the menu item, the program will run normally
+    Parameters
+    ----------
+    vis_fr
+
+    Returns
+    -------
+
+    """
+    DockedPanel.add_menu_item(vis_fr, 'Scale Box', ScaleBoxPanel, 'scale_box')

PYME/LMVis/Extras/sequentialSpecies.py

@@ -0,0 +1,125 @@
+import wx
+import numpy as np
+
+class SpeciesDialog(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, 'Species 1: '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS1 = [wx.TextCtrl(self, -1, 'name1', size=[50,-1])]
+        hsizer.Add(self.tSpecStringS1[0], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'from'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS1.append(wx.TextCtrl(self, -1, '0', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS1[1], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'to'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS1.append(wx.TextCtrl(self, -1, '1e4', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS1[2], 0, 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, 'Species 2: '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS2 = [wx.TextCtrl(self, -1, 'name2', size=[50,-1])]
+        hsizer.Add(self.tSpecStringS2[0], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'from'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS2.append(wx.TextCtrl(self, -1, '1e4', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS2[1], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'to'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS2.append(wx.TextCtrl(self, -1, '2e4', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS2[2], 0, 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, 'Species 3: '), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS3 = [wx.TextCtrl(self, -1, '', size=[50,-1])]
+        hsizer.Add(self.tSpecStringS3[0], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'from'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS3.append(wx.TextCtrl(self, -1, '', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS3[1], 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        hsizer.Add(wx.StaticText(self, -1, 'to'), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        self.tSpecStringS3.append(wx.TextCtrl(self, -1, '', size=[30,-1]))
+        hsizer.Add(self.tSpecStringS3[2], 0, 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()
+
+        #hsizer.Add(btSizer,0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        vsizer.Add(btSizer, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL, 5)
+
+        self.SetSizerAndFit(vsizer)
+    
+    def GetSpeciesDescriptor(self):
+        speclist = []
+        for specstrings in [self.tSpecStringS1, self.tSpecStringS2, self.tSpecStringS3]:
+            sname =  specstrings[0].GetValue().strip()
+            if sname: # empty strings will be ignored
+                speclist.append({'name'   : sname,
+                                 't_start': float(specstrings[1].GetValue()),
+                                 't_end'  : float(specstrings[2].GetValue())})
+        print(speclist)
+        return speclist
+
+from PYME.LMVis import renderers
+
+class TimedSpecies:
+    def __init__(self, visFr):
+        self.visFr = visFr
+        self.timedSpecies = None
+
+        visFr.AddMenuItem('Extras', "&Sequential Imaging - Species assignment",self.OnTimedSpecies)
+        # this gives every image a TimedSpecies entry (None by default)
+        # this is probably not a good idea
+        # renderers.renderMetadataProviders.append(self.SaveMetadata)
+
+    def OnTimedSpecies(self,event):
+        dlg = SpeciesDialog(None)
+        ret = dlg.ShowModal()
+
+        speclist = dlg.GetSpeciesDescriptor()
+        #print 'Species Descriptor: ', speclist
+        if ret == wx.ID_OK:
+            pipeline = self.visFr.pipeline
+            if pipeline.selectedDataSource is not None:
+                self.SetTimedSpecies(speclist)
+                pipeline.selectedDataSource.setMapping('ColourNorm', '1.0 + 0*t')
+                for species in self.timedSpecies.keys():
+                    pipeline.selectedDataSource.setMapping('p_%s' % species,
+                                                           '(t>= %d)*(t<%d)' % self.timedSpecies[species])
+                if len(self.timedSpecies.keys()) > 0:
+                    pipeline.mdh.setEntry('TimedSpecies', speclist)
+                    self.visFr.RegenFilter()
+                    #self.visFr.CreateFoldPanel() #TODO - do we need this?
+
+    def SaveMetadata(self,mdh):
+        mdh['TimedSpecies'] = self.timedSpecies
+
+    def SetTimedSpecies(self,slist):
+        self.timedSpecies = {}
+        for spec in slist:
+            self.timedSpecies[spec['name']] = (spec['t_start'],spec['t_end'])
+
+def Plug(visFr):
+    '''Plugs this module into the gui'''
+    TimedSpecies(visFr)
+