python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/Acquire/PYMEAcquire.py

@@ -0,0 +1,186 @@
+#!/usr/bin/python
+
+##################
+# PYMEAquire.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/>.
+#
+##################
+"""
+This is the principle entry point for `PYMEAcquire`, the acquisition component of PYME.
+
+`PYMEAcquire` takes one option to specify the initialisation file, which should be in the 
+'PYME/Acquire/Scripts' directory
+
+.. code-block:: bash
+
+    python PYMEAcquire.py -i <initialisation file>
+    
+If run without an intialisation file it defaults to using simulated hardware.
+"""
+from PYME.misc import big_sur_fix
+from PYME.ui import patch_traitsui
+
+#!/usr/bin/python
+import wx
+#import matplotlib
+#matplotlib.use('WXAgg')
+#from PYME import mProfile
+
+#make wx less spammy with warnings
+import warnings
+warnings.simplefilter('once', wx.wxPyDeprecationWarning)
+
+import os
+import logging
+import logging.config
+import os
+
+import PYME.config as pyme_config
+
+def setup_logging(default_level=logging.DEBUG):
+    """Setup logging configuration
+
+    """
+    import yaml
+    import PYME.config
+    from PYME.util import log_verbosity
+    default_config_file = os.path.join(os.path.split(__file__)[0], 'logging.yaml')
+    
+    path = PYME.config.get('Acquire-logging_conf_file', default_config_file)
+    print('attempting to load load logging config from %s' % path)
+    
+    if os.path.exists(path):
+        with open(path, 'rt') as f:
+            config = yaml.safe_load(f)
+
+        if pyme_config.get('Acquire-logging_include_pid', False):
+            # replace the filename in the file handler with a version that includes the PID
+            # this is useful for debugging multiple instances of PYMEAcquire
+            # The caveat is that each time you run the program you will get a new log file
+            # and these will accumulate until manually deleted / removed.
+            # To enable, add the following line to ~/.PYME/config.yaml
+            # Acquire-logging_include_pid: True
+            try:
+                config['handlers']['file']['filename'] = config['handlers']['file']['filename'].replace('.log', f'_{os.getpid()}.log')
+            except KeyError:
+                print('No file handler in logging config - skipping PID replacement')
+            
+        logging.config.dictConfig(config)
+    else:
+        logging.basicConfig(level=default_level)
+
+    # suppress excessively verbose logging in dependency packages
+    log_verbosity.patch_log_verbosity()
+
+class BoaApp(wx.App):
+    def __init__(self, options, *args):
+        self.options = options
+        wx.App.__init__(self, *args)
+        
+        
+    def OnInit(self):
+        if self.options.server:
+            from PYME.Acquire import acquirewx as acquiremainframe
+        else:
+            from PYME.Acquire import acquiremainframe
+
+        self.main = acquiremainframe.create(None, self.options)
+        self.SetTopWindow(self.main)
+
+        if self.options.browser:
+            import webbrowser
+            webbrowser.open('http://localhost:8999') #FIXME - delay this until server is up
+        return True
+
+
+def main():
+    import os
+    import sys
+    #from optparse import OptionParser
+    import argparse
+    setup_logging()
+    
+    from PYME import config
+    
+    logger = logging.getLogger(__name__)
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-i", "--init-file", dest="initFile",
+                      help="Read initialisation from file [defaults to init.py]",
+                      metavar="FILE", default='init.py')
+
+    parser.add_argument("-m", "--gui_mode", dest="gui_mode", default='default',
+                      help="GUI mode for PYMEAcquire - either default or 'compact'")
+
+    parser.add_argument("-t", "--title", dest="window_title", default='PYME Acquire',
+                      help="Set the PYMEAcquire display name (useful when running multiple copies - e.g. for drift tracking)")
+    
+    parser.add_argument('-p', '--port', dest='port', default=8999, help='port to use for server functions')
+    parser.add_argument('-a', '--bind_addr', dest='bind_addr', default=None, help='address to bind to for server functions (defaults to localhost). Only bind to an external address if you are on a trusted network and *really* know what you are doing. NB - university networks should generally not be trusted.')
+    parser.add_argument('-s', '--server', dest='server', default=False, action='store_true', help='run in server mode')
+    parser.add_argument('-b', '--browser', dest='browser', default=False, action='store_true', help='launch web browser based ui')
+    parser.add_argument('-e', '--threaded_event_loop', dest='threaded_event_loop', default=False, action='store_true', help='Run hardware event loop in separate thread. Required (and implied) for server mode.')
+    parser.add_argument('-I', '--ipy', dest='ipy', default=False, action='store_true', help='launch ipython server for remote control')
+    parser.add_argument('--no-wx', dest='no_wx', default=False, action='store_true', help='run without wx gui')
+
+    #(options, args) = parser.parse_args()
+
+    options = parser.parse_args()
+
+    print(options)
+
+    if options.server:
+        options.threaded_event_loop = True
+
+    # continue to support loading scripts from the PYMEAcquire/Scripts directory
+    legacy_scripts_dir = os.path.join(os.path.dirname(__file__), 'Scripts')
+    
+    # use new config module to locate the initialization file
+    init_file = config.get_init_filename(options.initFile, legacy_scripts_directory=legacy_scripts_dir)
+    if init_file is None:
+        logger.critical('init script %s not found - aborting' % options.initFile)
+        sys.exit(1)
+
+    #overwrite initFile in options with full path - CHECKME - does this work?
+    options.initFile = init_file
+    logger.info('using initialization script %s' % init_file)
+
+    logger.debug('using initialization script %s, %s' % (init_file, os.path.abspath(init_file)))
+
+    if options.no_wx:
+        #implies server mode (with or without a browser GUI)
+        assert options.server
+
+        from PYME.Acquire.acquire_server import AcquireHTTPServer
+        server = AcquireHTTPServer(options, port=int(options.port), bind_addr=options.bind_addr)
+        if options.browser:
+            import webbrowser
+            webbrowser.open('http://localhost:8999') #FIXME - delay this until server is up
+
+        server.run()
+    else:
+        application = BoaApp(options, 0)
+        application.MainLoop()
+
+if __name__ == '__main__':
+    from PYME.util import mProfile, fProfile
+    #mProfile.profileOn(['acquiremainframe.py', 'microscope.py', 'frameWrangler.py', 'fakeCam.py', 'rend_im.py'])
+    #fp = fProfile.thread_profiler()
+    #fp.profileOn()
+    main()
+    #fp.profileOff()
+    #mProfile.report()

PYME/Acquire/Protocols/DMDMFM.py

@@ -0,0 +1,74 @@
+#!/usr/bin/python
+
+##################
+# simulPA.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 all the stuff to make this work
+from PYME.Acquire.protocol import *
+from PYME.Acquire.Hardware.Simulator import rend_im
+import numpy as np
+
+def SetPattern(ph1, ph2):
+    m = (((scope.LC.X + ph1) % 100) <= 3)*(((scope.LC.Y + ph2) % 100) <= 3)
+    scope.LC.SetMask(m)    
+    
+def stop():
+    MainFrame.pan_spool.OnBStopSpoolingButton(None)
+    
+#def SetTheta(th):
+#    rend_im.SIM_theta = th
+
+#set illumination period to 180 nm    
+#rend_im.SIM_k = np.pi/180
+    
+#define a list of tasks, where T(when, what, *args) creates a new task
+#when is the frame number, what is a function to be called, and *args are any
+#additional arguments
+taskList = [
+#T(20, Ex, 'scope.cam.compT.laserPowers[0] = 1'),
+#T(-1, Ex, "scope.cam.compT.illumFcn = 'SIMIllumFcn'"), #Turn on SIM
+#T(-1, SetTheta, 0),
+T(-1, SetPattern, 0, 0),
+T(1, SetPattern,  0, 2*np.pi/3),
+T(2, SetPattern,  0, 4*np.pi/3),
+T(3, SetPattern, np.pi/2, 0),
+T(4, SetPattern, np.pi/2,  2*np.pi/3),
+T(5, SetPattern, np.pi/2,  4*np.pi/3),
+T(6, SetPattern, np.pi/4, 0),
+T(7, SetPattern, np.pi/4,  2*np.pi/3),
+T(8, SetPattern, np.pi/4,  4*np.pi/3),
+T(9, SetPattern, -np.pi/4, 0),
+T(10, SetPattern, -np.pi/4,  2*np.pi/3),
+T(11, SetPattern, -np.pi/4,  4*np.pi/3),
+#T(13, stop),
+#T(maxint, Ex, "scope.cam.compT.illumFcn = 'ConstIllum'")
+#T(201, MainFrame.pan_spool.OnBAnalyse, None)
+]
+
+#optional - metadata entries
+metaData = [
+#('Protocol.DarkFrameRange', (0, 20)),
+#('Protocol.DataStartsAt', 21)
+]
+
+#must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 20, 100, metaData, randomise = False)

PYME/Acquire/Protocols/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python
+
+###############
+# __init__.py
+#
+# Copyright David Baddeley, 2012
+# 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/>.
+#
+################

PYME/Acquire/Protocols/darkCalibrate.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python
+
+##################
+# standard671.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 all the stuff to make this work
+from PYME.Acquire.protocol import *
+import numpy as np
+import wx
+
+nframes=200
+INTEGRATIONTIMES = [5, 10, 25, 50, 100, 250]
+TRANSITIONS = list(nframes*np.arange(len(INTEGRATIONTIMES)) + 20)
+
+def stop():
+    #ps.stop()
+    wx.CallAfter(MainFrame.pan_spool.OnBStopSpoolingButton(None))
+
+#define a list of tasks, where T(when, what, *args) creates a new task
+#when is the frame number, what is a function to be called, and *args are any
+#additional arguments
+taskList = [T(-1, scope.turnAllLasersOff),]
+#taskList += [T(i,scope.cam.SetIntegTime, iTime) for i, iTime in zip(TRANSITIONS, INTEGRATIONTIMES)]
+for i, iTime in zip(TRANSITIONS, INTEGRATIONTIMES):
+	taskList += [T(i,scope.cam.SetIntegTime, iTime)]
+
+# taskList += [T(10000, scope.filterWheel.SetFilterPos, "EMPTY"),]
+taskList += [T(TRANSITIONS[-1]+nframes, stop),]
+
+#optional - metadata entries
+metaData = [
+('Protocol.Transitions', TRANSITIONS),
+('Protocol.IntegrationTimes', INTEGRATIONTIMES),
+]
+
+#must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 20, 100, metaData, randomise = False)

PYME/Acquire/Protocols/dual671_470.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python
+
+###############
+# dual671_470.py
+#
+# Copyright David Baddeley, 2012
+# 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 all the stuff to make this work
+from PYME.Acquire.protocol import *
+import numpy
+
+#define a list of tasks, where T(when, what, *args) creates a new task
+#when is the frame number, what is a function to be called, and *args are any
+#additional arguments
+taskList = [
+T(-1, scope.turnAllLasersOff),
+T(20, scope.l671.TurnOn),
+#T(20, scope.l543.TurnOn),
+T(30, MainFrame.pan_spool.OnBAnalyse, None)
+]
+
+#optional - metadata entries
+metaData = [
+('Protocol.DarkFrameRange', (0, 20)),
+('Protocol.DataStartsAt', 21)
+]
+
+#must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 20, 100, metaData, randomise = False)

PYME/Acquire/Protocols/dual671_488.py

@@ -0,0 +1,46 @@
+#!/usr/bin/python
+
+###############
+# dual671_488.py
+#
+# Copyright David Baddeley, 2012
+# 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 all the stuff to make this work
+from PYME.Acquire.protocol import *
+import numpy
+
+#define a list of tasks, where T(when, what, *args) creates a new task
+#when is the frame number, what is a function to be called, and *args are any
+#additional arguments
+taskList = [
+T(-1, scope.turnAllLasersOff),
+T(0, scope.l488.TurnOn),
+T(20, scope.l671.TurnOn),
+T(20, scope.lFibre.TurnOn),
+T(30, MainFrame.pan_spool.OnBAnalyse, None)
+]
+
+#optional - metadata entries
+metaData = [
+('Protocol.DarkFrameRange', (0, 20)),
+('Protocol.DataStartsAt', 21)
+]
+
+#must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 20, 100, metaData, randomise = False)

PYME/Acquire/Protocols/gainCal.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+##################
+# standard488.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 all the stuff to make this work
+from PYME.Acquire.protocol import *
+import numpy
+
+#define a list of tasks, where T(when, what, *args) creates a new task
+#when is the frame number, what is a function to be called, and *args are any
+#additional arguments
+taskList = [
+T(-1, scope.turnAllLasersOff),
+T(-1, SetIntegTime, 25),
+T(-1, SetCameraShutter, False),
+T(20, SetCameraShutter, True),
+T(30, SetIntegTime, 50),
+T(40, SetIntegTime, 100),
+T(50, SetIntegTime, 250),
+T(60, SetIntegTime, 500),
+T(70, SetIntegTime, 1000),
+
+#T(30, MainFrame.pan_spool.OnBAnalyse, None),
+]
+
+#optional - metadata entries
+metaData = [
+('Protocol.DarkFrameRange', (0, 20)),
+('Protocol.DataStartsAt', 21)
+]
+
+#must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 20, 30, metaData, randomise = False)

PYME/Acquire/Protocols/htsms-cal-psf.py

@@ -0,0 +1,32 @@
+from PYME.Acquire.protocol import *
+
+# T(when, what, *args) creates a new task. "when" is the frame number, "what" is a function to
+# be called, and *args are any additional arguments.
+taskList = [
+    T(-1, scope.state.update, {
+        'Lasers.MPB560.On': True,
+        'Lasers.MPB560.Power': 0.0,
+        'Lasers.MPB642.On': True,
+        'Lasers.MPB642.Power': 0.0,
+        'Lasers.OBIS405.On': False,
+        'Lasers.OBIS488.On': False,
+        'Multiview.ActiveViews': [0, 1, 2, 3],
+        'Multiview.ROISize': [256, 256],
+        'Camera.IntegrationTime': 0.1,
+    }),
+    T(0, scope.focus_lock.DisableLock),
+    T(maxint, scope.turnAllLasersOff),
+    # T(maxint, scope.focus_lock.EnableLock),
+    # T(maxint, scope.spoolController.LaunchAnalysis)
+]
+
+metaData = [
+    ('Protocol.DataStartsAt', 0),
+]
+
+preflight = []  # no preflight checks
+
+# must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData, preflight, filename=__file__)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 1, 3, metaData, preflight, slice_order='saw',
+                                        require_camera_restart=True, filename=__file__)

PYME/Acquire/Protocols/htsms-cal-registration.py

@@ -0,0 +1,52 @@
+from PYME.Acquire.protocol import *
+from PYME.Acquire.Utils.pointScanner import PointScanner
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Scanner(PointScanner):
+    def __init__(self, steps=10):
+        self._steps = steps
+    
+    def setup(self):
+        fs = np.array((scope.cam.size_x, scope.cam.size_y))
+        fov_size = 2 * np.mean(fs * np.array(scope.GetPixelSize()))
+
+        PointScanner.__init__(self, scope, self._steps, 
+                                      fov_size/self._steps, 1, 0, 
+                                      False, True, trigger=True, 
+                                      stop_on_complete=True, 
+                                      return_to_start=True)
+        self.on_stop.connect(scope.spoolController.StopSpooling)
+        self.genCoords()
+
+scanner = Scanner()
+
+taskList = [
+    T(-1, scope.state.update, {
+        'Lasers.MPB560.On': True,
+        'Lasers.MPB560.Power': 0.0,
+        'Lasers.MPB642.On': True,
+        'Lasers.MPB642.Power': 0.0,
+        'Lasers.OBIS405.On': False,
+        'Lasers.OBIS488.On': False,
+        'Multiview.ActiveViews': [0, 1, 2, 3],
+        'Multiview.ROISize': [256, 256],
+        'Camera.IntegrationTime': 0.1,
+    }),
+    T(-1, scanner.setup),
+    T(0, scanner.start),
+    T(maxint, scope.turnAllLasersOff),
+]
+
+metaData = [
+    ('Protocol.DataStartsAt', 0),
+]
+
+preflight = []  # no preflight checks
+
+# must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData, preflight, filename=__file__)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 1, 3, metaData, preflight, slice_order='saw',
+                                        require_camera_restart=True, filename=__file__)

PYME/Acquire/Protocols/htsms-flow.py

@@ -0,0 +1,29 @@
+from PYME.Acquire.protocol import *
+
+# T(when, what, *args) creates a new task. "when" is the frame number, "what" is a function to
+# be called, and *args are any additional arguments.
+taskList = [
+    T(-1, scope.state.update, {
+        'Lasers.MPB560.On': True,
+        'Lasers.MPB560.Power': 550.0,
+        'Lasers.MPB642.On': True,
+        'Lasers.MPB642.Power': 575.0,
+        'Multiview.ActiveViews': [0, 1, 2, 3],
+        'Multiview.ROISize': [256, 256],
+        'Camera.IntegrationTime': 0.00125,
+    }),
+    T(-1, scope.focus_lock.DisableLockAfterAcquiringIfEnabled),
+    # T(maxint, scope.turnAllLasersOff),
+    T(maxint, scope.focus_lock.EnableLock)
+]
+
+metaData = [
+    ('Protocol.DataStartsAt', 0),
+]
+
+preflight = []  # no preflight checks
+
+# must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData, preflight, filename=__file__)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 1, 800, metaData, preflight, slice_order='triangle',
+                                        require_camera_restart=False, filename=__file__)

PYME/Acquire/Protocols/htsms-staggered.py

@@ -0,0 +1,31 @@
+from PYME.Acquire.protocol import *
+
+# T(when, what, *args) creates a new task. "when" is the frame number, "what" is a function to
+# be called, and *args are any additional arguments.
+taskList = [
+    T(-1, scope.state.update, {
+        'Lasers.MPB560.On': False,
+        'Lasers.MPB560.Power': 550.0,
+        'Lasers.MPB642.On': True,
+        'Lasers.MPB642.Power': 575.0,
+        'Multiview.ActiveViews': [0, 1, 2, 3],
+        'Multiview.ROISize': [256, 256],
+        'Camera.IntegrationTime': 0.00125,
+    }),
+    T(-1, scope.focus_lock.DisableLockAfterAcquiringIfEnabled),
+    T(8000, scope.l560.TurnOn),
+    T(maxint, scope.turnAllLasersOff),
+    T(maxint, scope.focus_lock.EnableLock),
+    # T(maxint, scope.spoolController.LaunchAnalysis)
+]
+
+metaData = [
+    ('Protocol.DataStartsAt', 0),
+]
+
+preflight = []  # no preflight checks
+
+# must be defined for protocol to be discovered
+PROTOCOL = TaskListProtocol(taskList, metaData, preflight, filename=__file__)
+PROTOCOL_STACK = ZStackTaskListProtocol(taskList, 1, 1000, metaData, preflight, slice_order='triangle',
+                                        require_camera_restart=False, filename=__file__)