python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/Acquire/acquirewx.py

@@ -0,0 +1,61 @@
+#!/usr/bin/python
+
+##################
+# smimainframe.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 contains the bulk of the GUI code for the main window of PYMEAcquire.
+"""
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+from PYME.Acquire.acquiremainframe import PYMEMainFrame   
+from PYME.Acquire.acquire_server import AcquireHTTPServerMixin
+
+def create(parent, options = None):
+    return AcquireWxHTTPServer(parent, options, port=int(options.port), bind_addr=options.bind_addr)
+
+class AcquireWxHTTPServer(PYMEMainFrame, AcquireHTTPServerMixin):
+    """Server with wx GUI"""
+    def __init__(self, parent, options, port, bind_addr=None):
+        assert(options.threaded_event_loop)
+        
+        PYMEMainFrame.__init__(self, parent, options)
+        AcquireHTTPServerMixin.__init__(self, port, bind_addr)
+
+    def run(self):
+        import threading
+        PYMEMainFrame.run(self)
+
+        if self.options.server:
+            # only start the server if requested
+            self._server_thread = threading.Thread(target=self.serve_forever)
+            self._server_thread.start()
+
+            if self.options.ipy:
+                # make this a separate config option as port is hard coded so can't run more than one
+                # process with this option. Also probably not desirable if you just want progamatic
+                # remote control (through REST API).
+                from PYME.Acquire.webui import ipy
+                ns = dict(scope=self.scope, server=self)
+                print('namespace:', ns)
+                ipy.launch_ipy_server_thread(user_ns=ns)

PYME/Acquire/acquisition_base.py

@@ -0,0 +1,148 @@
+"""
+Base class for acquisition modules 
+
+This exists to document the interface which acquisition types should implement in order 
+to be able to be used with spooling etc ...
+"""
+
+import abc
+from PYME.contrib import dispatch
+
+
+class AcquisitionBase(abc.ABC):
+    _backend=None
+
+    @abc.abstractmethod
+    def __init__(self, *args, **kwargs):
+        '''Create an Acquisition object'''
+        
+        # A signal to be emitted when progress is made in the acquisition
+        # this triggers a GUI update, and implementations can choose whether to emit this signal
+        # on every frame, or to throttle it. 
+        self.on_progress = dispatch.Signal()
+
+        # A signal to be emitted when the acquisition is stopped
+        # this should always be emitted when the acquisition is stopped, regardless of the reason
+        self.on_stop = dispatch.Signal()
+
+        # A flag to indicate whether the spool is complete. Ths should be set to True once spooling is finished 
+        # (it is watched by the ActionManager to determine if the acquisition is complete and the next action should be executed)
+        self.spool_complete = False
+
+    @classmethod
+    @abc.abstractmethod
+    def from_spool_settings(cls, scope, settings, backend, backend_kwargs={}, series_name=None, spool_controller=None):
+        '''Create an Acquisition object from settings and a backend.
+        
+        
+        Parameters
+        ----------
+
+        scope : microscope.Microscope
+            The microscope object to use for acquisition. Supplied in order to allow hardware control and access to the frameWrangler.
+
+        settings : dict
+            A dictionary of settings for the acquisition
+
+        backed : class
+            The class of the backend to use for the acquisition. Generally one of PYME.IO.acquisition_backends
+
+        backend_kwargs : dict
+            A dictionary of keyword arguments to pass to the backend constructor
+
+        series_name : str
+            The name of the series to create. series_name should be defined unless the MemoryBackend is used, in which case it is ignored.
+
+        spool_controller : object
+            The spool controller object to use for the acquisition. Generally scope.spoolController. Currently used by ProtocolAcquisition 
+            to access default protocol settings held by the spoolController, but a bit of a legacy hack. May be removed in the future.
+        
+        '''
+        pass
+
+    @classmethod
+    def get_frozen_settings(cls, scope, spool_controller=None):
+        '''Return a dictionary of settings for the acquisition
+        
+        Used to "freeze" the state of the spool_controller and/or other settings objects when queueing
+        acquisitions for subsequent execution via the ActionManager
+        '''
+
+        return {}
+    
+    @abc.abstractmethod
+    def start(self):
+        '''Start the acquisition
+        
+        This will usually record any metadata, connect self.on_frame to a frame source (i.e. scope.frameWrangler.onFrame), and initialise
+        the backend. It should not block, with the bulk of the acquisition logic taking place in frame source handler.
+        
+        '''
+        pass
+
+    @abc.abstractmethod
+    def stop(self):
+        '''Stop the acquisition
+        
+        This should disconnect from the frame souce, flush any remaining buffers, return hardware to starting state (if modified),
+        do any cleanup, and finalise the backend.
+
+        It is desirable to send a final on_progress signal so that the GUI reflects the actual number of frames spooled etc... .
+
+        Once everything is complete, the on_stop signal should be emitted and the spool_complete flag set.
+        
+        '''
+        pass
+
+    
+    def abort(self):
+        '''Abort the acquisition
+        
+        This should stop the acquisition as quickly as practical. In many cases this can just be a call to stop(),
+        but there is no expectation that buffers will be flushed, remaining protocol steps executed or hardware returned 
+        to a starting state. Especially for cases which involve moving translation stages or other hardware it is desirable
+        that the abort method not result in further movement of hardware unless to a known safe state (e.g. lasers off).
+        
+        Abort should, however, finalise the backend and emit the on_stop signal. 
+        TODO - should abort set spool_complete? 
+        '''
+        self.stop()
+
+    @abc.abstractmethod
+    def md(self):
+        ''' Return acqusition metadata (a PYME.IO.MetaDataHandler object)
+        
+        generally just a short wrapper around the backend metadata
+
+        #TODO - rename this to .mdh, or remove entirely and standardise backend access?
+        '''
+        pass
+        
+    @abc.abstractmethod
+    def on_frame(self, sender, frameData, **kwargs):
+        '''Frame source handler
+        
+        This method should be connected to the frame source signal (i.e. scope.frameWrangler.onFrame) and be responsible for 
+        handling incoming frames, passing them off to storage and performing anything that needs to be done (e.g. hardware movements
+        or protocol task handling) before the next frame. NOTE - this method is called when the frame is retrieved by the frame wrangler
+        - if the camera is running in continuous mode, this may be several frames after the camera has actually acquired the frame. 
+        
+        '''
+        pass
+
+    @property
+    def storage(self):
+        '''Return the storage object for the acquisition
+        
+        '''
+        return self._backend
+    
+    @storage.setter
+    def storage(self, storage):
+        '''Set the storage object for the acquisition
+        
+        '''
+        self._backend = storage
+
+    def getURL(self):
+        return self.storage.getURL()

PYME/Acquire/actions.py

@@ -0,0 +1,209 @@
+class Action(object):
+    '''
+    Base Action method - over-ride the __call__ function in derived classes
+    '''
+    
+    def __init__(self, **kwargs):
+        self.params = kwargs
+    
+    def __call__(self, scope):
+        pass
+    
+    def serialise(self):
+        '''Convert to a .json serializable dictionary'''
+        d = dict(self.params)
+        
+        then = getattr(self, '_then', None)
+        if then:
+            d['then'] = then.serialise()
+        
+        return {self.__class__.__name__: d}
+    
+    @property
+    def _repr_then(self):
+        if self._then is not None:
+            return '- then -> %s' % repr(self._then)
+        else:
+            return ''
+        
+    def _estimated_duration(self, scope):
+        '''Return the estimated duration of the action in seconds'''
+        return 1.0
+    
+    def estimated_duration(self, scope):
+        t =  self._estimated_duration(scope)
+
+        then = getattr(self, '_then', None)
+        if then:
+            t += then.estimated_duration(scope)
+
+        return t
+    
+    def finalise(self, scope):
+        ''' Called after the action has executed'''
+        # TODO - do then here??
+        pass
+
+        
+
+
+class FunctionAction(Action):
+    '''Legacy action which evals a string.
+
+    Used for handling old -style actions
+    '''
+    
+    def __init__(self, functionName, args=None):
+        Action.__init__(self, functionName=functionName, args=args)
+        self._fcn = functionName
+        if args is None:
+            args = {}
+        self._args = args
+    
+    def __call__(self, scope):
+        fcn = eval('.'.join(['scope', self._fcn]))
+        #fcn = getattr(scope, self._fcn)
+        return fcn(**self._args)
+    
+    def __repr__(self):
+        return 'FunctionAction: %s(%s)' % (self._fcn, self._args) + self._repr_then
+
+
+class StateAction(Action):
+    ''' Base class for actions which modify scope state, with chaining support
+
+    NOTE: we currently do not support chaining off the end of actions (e.g. spooling) which are likely to take some time.
+    This is because functions such as start_spooling are non-blocking - they return a callback instead.
+    '''
+    
+    def __init__(self, **kwargs):
+        self._then = None
+        Action.__init__(self, **kwargs)
+    
+    def then(self, task):
+        self._then = task
+        return self
+    
+    def _do_then(self, scope):
+        if self._then is not None:
+            return self._then(scope)
+
+
+class UpdateState(StateAction):
+    def __init__(self, state):
+        self._state = state
+        StateAction.__init__(self, state=state)
+    
+    def __call__(self, scope):
+        scope.state.update(self._state)
+        return self._do_then(scope)
+    
+    def __repr__(self):
+        return 'UpdateState: %s' % self._state + self._repr_then
+
+class MoveTo(StateAction):
+    """
+    Move to a specific position in absolute stage coordinates.
+
+    Most useful when queueing actions to return to a specific
+    already identified position.
+    """
+    def __init__(self, x, y):
+        StateAction.__init__(self, x=x, y=y)
+        self.x, self.y = x, y
+    
+    def __call__(self, scope):
+        scope.SetPos(x=self.x, y=self.y)
+        return self._do_then(scope)
+    
+    def __repr__(self):
+        return 'MoveTo: %f, %f (x, y)' % (self.x, self.y) + self._repr_then
+
+class CentreROIOn(StateAction):
+    """
+    Centre the ROI on a specific position in absolute stage coordinates.
+
+    Most useful when queueing actions where target have been automatically
+    identified.
+    """
+    def __init__(self, x, y):
+        StateAction.__init__(self, x=x, y=y)
+        self.x, self.y = x, y
+    
+    def __call__(self, scope):
+        scope.centre_roi_on(self.x, self.y)
+        return self._do_then(scope)
+    
+    def __repr__(self):
+        return 'CentreROIOn: %f, %f (x, y)' % (self.x, self.y) + self._repr_then
+
+
+class SpoolSeries(Action):
+    def __init__(self, **kwargs):
+        self._args = kwargs
+        Action.__init__(self, **kwargs)
+    
+    def __call__(self, scope):
+        return scope.spoolController.start_spooling(**self._args)
+    
+    def __repr__(self):
+        return 'SpoolSeries(%s)' % ', '.join(['%s = %s' % (k,repr(v)) for k, v in self._args.items()])
+    
+    def _estimated_duration(self, scope):
+        return scope.spoolController.estimate_spool_time(**self._args)
+    
+class RemoteSpoolSeries(Action):
+    def __init__(self, remote_instance='remote_acquire_instance', **kwargs):
+        self._remote_instance = remote_instance
+        self._args = kwargs
+        Action.__init__(self, **kwargs)
+    
+    def __call__(self, scope):
+        # let the local spoolController handle the filename incrementing
+        return getattr(scope,self._remote_instance).start_spooling(filename=scope.spoolController.seriesName, **self._args)
+    
+    def __repr__(self):
+        return 'RemoteSpoolSeries(%s)' % ', '.join(['%s = %s' % (k,repr(v)) for k, v in self._args.items()])
+    
+    def _estimated_duration(self, scope):
+        return 30*60 # 30 minutes
+    
+    def finalise(self, scope):
+        super().finalise()
+        scope.spoolController.SpoolStopped() #make sure file name increments
+
+class SimultaeneousSpoolSeries(Action):
+    '''Spool local and remote series simultaneously'''
+    def __init__(self, remote_instance='remote_acquire_instance', local_settings = {}, remote_settings = {}, **kwargs):
+        self._remote_instance = remote_instance
+        self._local_settings = local_settings
+        self._remote_settings = remote_settings
+        self._args = kwargs
+        Action.__init__(self, **kwargs)
+    
+    def __call__(self, scope):
+        a =  scope.spoolController.start_spooling(settings = self._local_settings, **self._args)
+        b =  getattr(scope,self._remote_instance).start_spooling(filename=scope.spoolController.seriesName + '_B', settings = self._remote_settings, **self._args)
+
+        return lambda : a() and b()
+    
+    def __repr__(self):
+        return 'SimultaeneousSpoolSeries(%s)' % ', '.join(['%s = %s' % (k,repr(v)) for k, v in self._args.items()])
+    
+    def _estimated_duration(self, scope):
+        return scope.spoolController.estimate_spool_time(**self._args)
+    
+
+
+def action_from_dict(serialised):
+    assert (len(serialised) == 1)
+    act, params = list(serialised.items())[0]
+    
+    then = params.pop('then', None)
+    # TODO - use a slightly less broad dictionary for action lookup (or move actions to a separate module)
+    a = globals()[act](**params)
+    
+    if then:
+        a.then(action_from_dict(then))
+    
+    return a

PYME/Acquire/autofocus.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+##################
+# <filename>.py
+#
+# Copyright David Baddeley, 2012
+# d.baddeley@auckland.ac.nz
+#
+# This file may NOT be distributed without express permision from David Baddeley
+#
+##################
+from scipy import ndimage
+
+class AutoFocus(object):
+    def __init__(self, scope, increment=0.5):
+        self.scope = scope
+        self.incr = increment
+        self.lastMax =0
+        self.lastMaxPos = 0
+        
+        self.lastStep = .5
+        
+    def OnFrameGroup(self, **kwargs):
+        im_f = self.scope.frameWrangler.currentFrame.astype('f')
+        self.im_d = ndimage.gaussian_filter(im_f, 1) - ndimage.gaussian_filter(im_f, 5)
+        m = self.im_d.std()#self.scope.frameWrangler.currentFrame.std()
+        #m = im_f.std()
+        if m > self.lastMax:
+            #continue
+            self.lastMax = m
+            self.lastMaxPos = self.scope.state['Positioning.z']
+            
+        else:
+            if self.incr > 0:
+                #reverse direction
+                self.incr = -self.incr
+            else:
+                #already runing backwards
+                self.scope.state['Positioning.z']=self.lastMaxPos
+                #self.scope.frameWrangler.WantFrameGroupNotification.remove(self.tick)
+                self.scope.frameWrangler.onFrameGroup.disconnect(self.OnFrameGroup)
+
+                print('af_done')
+            
+        #self.scope.SetPos(z=self.lastMaxPos + self.incr)
+        self.scope.state['Positioning.z'] = self.lastMaxPos + self.incr
+        
+        print('af, %s' % m)
+        
+    def af(self, incr=0.5):
+        self.lastMax = 0
+        self.incr = incr
+        #self.scope.frameWrangler.WantFrameGroupNotification.append(self.tick)
+        self.scope.frameWrangler.onFrameGroup.connect(self.OnFrameGroup)

PYME/Acquire/eventLog.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python
+
+##################
+# eventLog.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/>.
+#
+##################
+"""
+Log events from within PYMEAcquire.
+
+To log an event:
+ 
+ >>> from PYME.Acquire import eventLog
+ >>> eventLog.logEvent("eventName", "eventDescr") #NOTE - leave timestamp blank unless you are doing something funky
+ 
+To receive events:
+ 
+>>> from PYME.Acquire import eventLog
+>>> import time
+>>>
+>>> class MyReviever(object):
+>>>     def __init__(self, ...):
+>>>         #register as a receiver of events
+>>>         eventLog.WantEventNofication.append(self)
+>>>
+>>>     def eventLog(self, eventName, eventDescr = '', timestamp=None):
+>>>         # timestamp is usually not supplied, provide one
+>>>         if timestamp is None:
+>>>             timestamp = time.time() #this is the simplest thing you can do for a timestamp.
+>>>
+>>>         #your event handling logic here.
+ 
+ 
+TODO - Make this a bit saner by providing either an `EventReceiver` base class, or a `register_event_handler()` function
+"""
+
+WantEventNotification = []
+
+def register_event_handler(EventReceiver):
+    """
+    Register an event handler to receive events.
+    
+    Parameters
+    ----------
+    EventReceiver : object (PYME.IO.events.EventLogger or subclass thereof)
+        an object with a `logEvent(eventName, eventDescr = '', timestamp=None)` method
+    """
+    WantEventNotification.append(EventReceiver)
+
+def remove_event_handler(EventReceiver):
+    """
+    Remove an event handler from the list of event receivers.
+    
+    Parameters
+    ----------
+    EventReceiver : object (PYME.IO.events.EventLogger or subclass thereof)
+        an object with a `logEvent(eventName, eventDescr = '', timestamp=None)` method
+    """
+    WantEventNotification.remove(EventReceiver)
+
+def logEvent(eventName, eventDescr = '', timestamp=None):
+    """
+    Log an event to all event receivers.
+    
+    Parameters
+    ----------
+    eventName : str
+        a name for the event
+    eventDescr : str
+        a description (optionally containing event data)
+    timestamp : float / None
+        a timestamp. Note that timestamps are usually handled in the spooler and the parameter should **not** be provided
+        unless you want to do something funky and spoof a timestamp that doesn't match the actual time.
+
+    Returns
+    -------
+
+    """
+    for evl in WantEventNotification:
+            evl.logEvent(eventName, eventDescr, timestamp = timestamp)

PYME/Acquire/event_loop.py

@@ -0,0 +1,119 @@
+"""
+Implements an event-loop and timers for headless usage of PYMEAcquire
+
+"""
+import threading
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+import time
+import sys
+import weakref
+
+import logging
+logger = logging.getLogger(__name__)
+
+class _Timer(object):
+    def __init__(self):
+        self._next_trigger = sys.float_info.max
+        self._single_shot = False
+        self._delay_s = -1
+        
+        logger.debug('Created timer')
+    
+    def notify(self):
+        raise NotImplementedError('Over-ride in derived class')
+    
+    def check(self, t):
+        if t > self._next_trigger:
+            #logger.debug('Timer triggered')
+            self._next_trigger = sys.float_info.max
+            try:
+                self.notify()
+            except:
+                logger.exception('Error in timer event')
+            finally:
+                if not self._single_shot:
+                    self._next_trigger = t + self._delay_s
+                return True
+        else:
+            return False
+    
+    def start(self, delay_ms, single_shot=False):
+        self._single_shot = single_shot
+        self._delay_s = 0.001*delay_ms
+        self._next_trigger = time.time() + self._delay_s
+    
+    def stop(self):
+        self._next_trigger = sys.float_info.max
+        
+class _SingleTargetTimer(_Timer):
+    def __init__(self, target):
+        _Timer.__init__(self)
+        self._target = target
+        
+    def notify(self):
+        self._target()
+
+
+class _MultiTargetTimer(_Timer):
+    """
+    Timer which calls multiple handlers
+    """
+    
+    def __init__(self, PROFILE=False):
+        _Timer.__init__(self)
+        self.WantNotification = []
+    
+    def notify(self):
+        for a in self.WantNotification:
+            a()
+    
+    def register_callback(self, callback):
+        self.WantNotification.append(callback)
+
+class EventLoop(object):
+    def __init__(self):
+        self._loop_active = False
+        
+        #keep a list of stuff to execute
+        self._deferreds = queue.Queue()
+        self._timers = weakref.WeakSet()
+        
+    def loop_forever(self):
+        self._loop_active = True
+        while self._loop_active:
+            try:
+                # process stuff which needs to run in this thread
+                callable, args, kwargs = self._deferreds.get(timeout=0.01)
+                logger.debug('Calling %s' % repr((callable, args, kwargs)))
+                callable(*args, **kwargs)
+            except(queue.Empty):
+                #do timer stuff
+                t = time.time()
+                did_stuff = False
+                for tm in self._timers:
+                    did_stuff = did_stuff or tm.check(t)
+
+                if not did_stuff:
+                    # sleep a bit (to limit CPU usage)
+                    time.sleep(0.001)
+            
+    def stop(self):
+        self._loop_active = False
+
+    def call_in_main_thread(self, callable, *args, **kwargs):
+        self._deferreds.put((callable, args, kwargs))
+        
+    #factory functions for timers - create a timer and add it to _timers
+    def SingleTargetTimer(self, target):
+        tm = _SingleTargetTimer(target)
+        self._timers.add(tm)
+        return tm
+    
+    def MultiTargetTimer(self):
+        tm = _MultiTargetTimer()
+        self._timers.add(tm)
+        return tm
+