Inheritance diagram for microscope.abc.DataDevice:

Public Member Functions
None	__init__ (self, int buffer_length=0, **kwargs)

def	__del__ (self)

None	abort (self)

None	enable (self)

None	disable (self)

None	set_client (self, new_client)

None	update_settings (self, settings, bool init=False)

None	receiveClient (self, str client_uri)

def	grab_next_data (self, bool soft_trigger=True)

None	receiveData (self, data, timestamp)

Public Member Functions inherited from microscope.abc.Device
None	__init__ (self)

None	__del__ (self)

bool	get_is_enabled (self)

None	disable (self)

None	enable (self)

None	initialize (self)

None	shutdown (self)

None	add_setting (self, name, dtype, get_func, set_func, values, typing.Optional[typing.Callable[[], bool]] readonly=None)

def	get_setting (self, str name)

def	get_all_settings (self)

None	set_setting (self, str name, value)

def	describe_setting (self, str name)

def	describe_settings (self)

def	update_settings (self, incoming, bool init=False)

Public Attributes
	enabled

Public Attributes inherited from microscope.abc.Device
	enabled

Static Public Attributes
	set_setting = keep_acquiring(Device.set_setting)

Detailed Description

A data capture device.

This class handles a thread to fetch data from a device and dispatch
it to a client.  The client is set using set_client(uri) or (legacy)
receiveClient(uri).

Derived classed should implement::

* :meth:`abort` (required)
* :meth:`_fetch_data` (required)
* :meth:`_process_data` (optional)

Derived classes may override `__init__`, `enable` and `disable`,
but must ensure to call this class's implementations as indicated
in the docstrings.

Definition at line 539 of file abc.py.

Constructor & Destructor Documentation

◆ init()

None microscope.abc.DataDevice.__init__	(		self,
		int	buffer_length = `0`,
		**	kwargs
	)

Derived.__init__ must call this at some point.

Reimplemented from microscope.abc.Device.

Reimplemented in microscope.abc.Camera, microscope.simulators.SimulatedCamera, microscope.testsuite.devices.TestCamera, microscope.cameras.picam.PiCamera, microscope.simulators.stage_aware_camera.StageAwareCamera, and microscope.cameras.ximea.XimeaCamera.

Definition at line 558 of file abc.py.

    def __init__(self, buffer_length: int = 0, **kwargs) -> None:
        """Derived.__init__ must call this at some point."""
        super().__init__(**kwargs)
        # A thread to fetch and dispatch data.
        self._fetch_thread = None
        # A flag to control the _fetch_thread.
        self._fetch_thread_run = False
        # A flag to indicate that this class uses a fetch callback.
        self._using_callback = False
        # Clients to which we send data.
        self._clientStack = []
        # A set of live clients to avoid repeated dispatch to disconnected client.
        self._liveClients = set()
        # A thread to dispatch data.
        self._dispatch_thread = None
        # A buffer for data dispatch.
        self._dispatch_buffer = queue.Queue(maxsize=buffer_length)
        # A flag to indicate if device is ready to acquire.
        self._acquiring = False
        # A condition to signal arrival of a new data and unblock grab_next_data
        self._new_data_condition = threading.Condition()
 

Referenced by microscope.abc.DataDevice.__init__().

◆ del()

def microscope.abc.DataDevice.__del__ ( self )

Reimplemented from microscope.abc.Device.

Definition at line 580 of file abc.py.

    def __del__(self):
        self.disable()
        super().__del__()
 

Member Function Documentation

◆ abort()

None microscope.abc.DataDevice.abort ( self )

Stop acquisition as soon as possible.

Reimplemented in microscope.cameras.andorsdk3.AndorSDK3, microscope.cameras.atmcd.AndorAtmcd, microscope.cameras.picam.PiCamera, microscope.cameras.pvcam.PVCamera, microscope.cameras.ximea.XimeaCamera, and microscope.simulators.SimulatedCamera.

Definition at line 588 of file abc.py.

    def abort(self) -> None:
        """Stop acquisition as soon as possible."""
        self._acquiring = False
 

References microscope.abc.DataDevice._acquiring, microscope.cameras.andorsdk3.AndorSDK3._acquiring(), microscope.cameras.atmcd.AndorAtmcd._acquiring(), microscope.cameras.picam.PiCamera._acquiring, microscope.cameras.pvcam.PVCamera._acquiring, microscope.cameras.ximea.XimeaCamera._acquiring, and microscope.simulators.SimulatedCamera._acquiring.

Referenced by microscope.simulators.SimulatedCamera.abort(), microscope.cameras.andorsdk3.AndorSDK3.get_id(), microscope.cameras.atmcd.AndorAtmcd.get_id(), microscope.cameras.picam.PiCamera.initialize(), microscope.cameras.ximea.XimeaCamera.initialize(), microscope.cameras.andorsdk3.AndorSDK3.set_trigger(), and microscope.abc.Device.update_settings().

◆ disable()

None microscope.abc.DataDevice.disable ( self )

Disable the data capture device.

Implement device-specific code in `_do_disable`.

Reimplemented from microscope.abc.Device.

Definition at line 629 of file abc.py.

    def disable(self) -> None:
        """Disable the data capture device.
 
        Implement device-specific code in `_do_disable`.
 
        """
        self.enabled = False
        if self._fetch_thread:
            if self._fetch_thread.is_alive():
                self._fetch_thread_run = False
                self._fetch_thread.join()
        super().disable()
 

Referenced by microscope.abc.DataDevice.__init__(), microscope.abc.DataDevice.disable(), microscope.lights.cobolt.CoboltLaser.get_status(), microscope.lights.deepstar.DeepstarLaser.get_status(), microscope.lights.obis.ObisLaser.get_status(), and microscope.abc.Device.shutdown().

◆ enable()

None microscope.abc.DataDevice.enable ( self )

Enable the data capture device.

Ensures that a data handling threads are running.  Implement
device specific code in `_do_enable`.

Reimplemented from microscope.abc.Device.

Definition at line 592 of file abc.py.

    def enable(self) -> None:
        """Enable the data capture device.
 
        Ensures that a data handling threads are running.  Implement
        device specific code in `_do_enable`.
 
        """
        _logger.debug("Enabling ...")
        # Call device-specific code.
        try:
            result = self._do_enable()
        except Exception as err:
            _logger.debug("Error in _do_enable:", exc_info=err)
            self.enabled = False
            raise err
        if not result:
            self.enabled = False
        else:
            self.enabled = True
            # Set up data fetching
            if self._using_callback:
                if self._fetch_thread:
                    self._fetch_thread_run = False
            else:
                if not self._fetch_thread or not self._fetch_thread.is_alive():
                    self._fetch_thread = Thread(target=self._fetch_loop)
                    self._fetch_thread.daemon = True
                    self._fetch_thread.start()
            if (
                not self._dispatch_thread
                or not self._dispatch_thread.is_alive()
            ):
                self._dispatch_thread = Thread(target=self._dispatch_loop)
                self._dispatch_thread.daemon = True
                self._dispatch_thread.start()
            _logger.debug("... enabled.")
 

◆ grab_next_data()

def microscope.abc.DataDevice.grab_next_data	(		self,
		bool	soft_trigger = `True`
	)

Returns results from next trigger via a direct call.

Args:
    soft_trigger: calls :meth:`trigger` if `True`, waits for
        hardware trigger if `False`.

Definition at line 789 of file abc.py.

    def grab_next_data(self, soft_trigger: bool = True):
        """Returns results from next trigger via a direct call.
 
        Args:
            soft_trigger: calls :meth:`trigger` if `True`, waits for
                hardware trigger if `False`.
 
        """
        if not self.enabled:
            raise microscope.DisabledDeviceError("Camera not enabled.")
        self._new_data_condition.acquire()
        # Push self onto client stack.
        self.set_client(self)
        # Wait for data from next trigger.
        if soft_trigger:
            self.trigger()
        self._new_data_condition.wait()
        # Pop self from client stack
        self.set_client(None)
        # Return the data.
        return self._new_data
 

References microscope.abc.DataDevice._new_data, microscope.abc.DataDevice._new_data_condition, microscope.abc.Device.enabled, microscope.abc.DataDevice.enabled, microscope.testsuite.devices.DummySLM.enabled, microscope.testsuite.devices.DummyDSP.set_client(), microscope.abc.DataDevice.set_client(), microscope.abc.TriggerTargetMixin.trigger(), and microscope.abc.DeformableMirror.trigger().

◆ receiveClient()

None microscope.abc.DataDevice.receiveClient	(		self,
		str	client_uri
	)

A passthrough for compatibility.

Definition at line 785 of file abc.py.

    def receiveClient(self, client_uri: str) -> None:
        """A passthrough for compatibility."""
        self.set_client(client_uri)
 

References microscope.testsuite.devices.DummyDSP.set_client(), and microscope.abc.DataDevice.set_client().

◆ receiveData()

None microscope.abc.DataDevice.receiveData	(	self,
		data,
		timestamp
	)

Unblocks grab_next_frame so it can return.

Definition at line 812 of file abc.py.

    def receiveData(self, data, timestamp) -> None:
        """Unblocks grab_next_frame so it can return."""
        with self._new_data_condition:
            self._new_data = (data, timestamp)
            self._new_data_condition.notify()
 
 

References microscope.abc.DataDevice._new_data, and microscope.abc.DataDevice._new_data_condition.

◆ set_client()

None microscope.abc.DataDevice.set_client	(	self,
		new_client
	)

Set up a connection to our client.

Clients now sit in a stack so that a single device may send
different data to multiple clients in a single experiment.
The usage is currently::

    device.set_client(client) # Add client to top of stack
    # do stuff, send triggers, receive data
    device.set_client(None)   # Pop top client off stack.

There is a risk that some other client calls ``None`` before
the current client is finished.  Avoiding this will require
rework here to identify the caller and remove only that caller
from the client stack.

Definition at line 749 of file abc.py.

    def set_client(self, new_client) -> None:
        """Set up a connection to our client.
 
        Clients now sit in a stack so that a single device may send
        different data to multiple clients in a single experiment.
        The usage is currently::
 
            device.set_client(client) # Add client to top of stack
            # do stuff, send triggers, receive data
            device.set_client(None)   # Pop top client off stack.
 
        There is a risk that some other client calls ``None`` before
        the current client is finished.  Avoiding this will require
        rework here to identify the caller and remove only that caller
        from the client stack.
 
        """
        if new_client is not None:
            if isinstance(new_client, (str, Pyro4.core.URI)):
                self._client = Pyro4.Proxy(new_client)
            else:
                self._client = new_client
        else:
            self._client = None
        # _client uses a setter. Log the result of assignment.
        if self._client is None:
            _logger.info("Current client is None.")
        else:
            _logger.info("Current client is %s.", str(self._client))
 

References microscope.abc.DataDevice._client, and microscope.testsuite.devices.DummyDSP._client.

Referenced by microscope.clients.DataClient.enable(), microscope.abc.DataDevice.grab_next_data(), and microscope.abc.DataDevice.receiveClient().

◆ update_settings()

None microscope.abc.DataDevice.update_settings	(		self,
			settings,
		bool	init = `False`
	)

Update settings, toggling acquisition if necessary.

Reimplemented from microscope.abc.Device.

Definition at line 780 of file abc.py.

    def update_settings(self, settings, init: bool = False) -> None:
        """Update settings, toggling acquisition if necessary."""
        super().update_settings(settings, init)
 

References microscope.abc.DataDevice.update_settings().

Referenced by microscope.abc.DataDevice.update_settings().

Member Data Documentation

◆ enabled

microscope.abc.DataDevice.enabled

Definition at line 605 of file abc.py.

Referenced by microscope.abc.Device.disable(), microscope.abc.DataDevice.disable(), microscope.abc.Device.enable(), microscope.abc.DataDevice.enable(), and microscope.abc.DataDevice.grab_next_data().

◆ set_setting

microscope.abc.DataDevice.set_setting = keep_acquiring(Device.set_setting)

static

Definition at line 585 of file abc.py.

Referenced by microscope.cameras.atmcd.AndorAtmcd.initialize(), and microscope.cameras.atmcd.AndorAtmcd.set_trigger().

The documentation for this class was generated from the following file:

F:/repos/BioImager/BioImager/PythonMicroscope/microscope/abc.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

◆ __del__()

Member Function Documentation

◆ abort()

◆ disable()

◆ enable()

◆ grab_next_data()

◆ receiveClient()

◆ receiveData()

◆ set_client()

◆ update_settings()

Member Data Documentation

◆ enabled

◆ set_setting

◆ init()

◆ del()