herosdevices.hardware.dummy.cameras - Heros Devices 0.6.1 documentation

Skip to content
Back to top
View this page

# herosdevices.hardware.dummy.cameras

Dummy camera devices for use in testing. Do not use in production.

## Module Contents

class herosdevices.hardware.dummy.cameras.ImageGeneratorDummy

  Act like a real camera, no one will notice.

  width = 800
  height = 600
  frame_count = 1
  set_shape(width: int = 800, height: int = 600) → None

    Set the image shape.

  static generate_gaussian_image(w: int, h: int, amplitude: float = 65535, noise_level: float = 0.05) → numpy.typing.NDArray[numpy.uint16]

    Generate a 2D Gaussian image with added random noise.

    The Gaussian is centered in the image with a fixed standard deviation, scaled to the specified amplitude. Additive Gaussian noise is applied and the result is clipped to the valid uint16 range.

    Parameters:

      - w – Width of the image.

      - h – Height of the image.

      - amplitude – Peak value of the Gaussian. Defaults to 65535.

      - noise_level – Standard deviation of noise relative to the amplitude (e.g., 0.05 means ±5% noise). Defaults to 0.05.

    Returns:

      A (h, w) image array of dtype np.uint16.

    Return type:

      np.ndarray

  arm() → None

    Arm the dummy device.

  trigger() → None

    Append an image to the buffer.

  get_image() → numpy.ndarray

    Get the last image from the buffer.

  clear_buffer() → None

    Clear the image buffer.

  abort() → None

    Abort the acquisition.

class herosdevices.hardware.dummy.cameras.CameraDummy

  Bases: `herosdevices.core.templates.CameraTemplate`

  A dummy camera.

  default_config_dict: dict
  get_camera
  acquisition_running: bool = False
  payload_metadata: dict
  keep_device_open = True
  default_config: str
  get_device() → collections.abc.Iterator[None]

    Yield a device handle.

        # use the device in a with statement
        with self.get_device() as camera:
            camera.do_something()

  open() → Any

    Open the device handler and assign it to self._device.

  teardown() → None

    Release the device handler and potentially de-initialize the API.

  start() → bool

    Fire a software trigger.

    Returns:

      True if successful

  stop() → bool

    Abort the exposure and release queued buffers.

    Returns:

      True if successful

  reset() → None

    Reset the device by aborting any ongoing exposure, closing and re-opening the handler.

  get_status() → dict

    Get a dict with the current device status.

    Returns:

      A dict with the device status

  property config_dict: dict

    Get a copy of the configuration dict.

    Returns:

      Copy of the configuration dict

  update_configuration(new_config_dict: dict, merge: bool = True) → None

    Update the configuration dict with new configuration.

    Each dict key corresponds a (new) configuration name. Each value is a dict with config property -> config value.

    Parameters:

      - new_config_dict – A dict of configurations where the keys are the configuration names

      - merge – If `True`, the new dict is recursively merged with the current set config dict. If `False` the old configurations with the provided names (keys) are overwritten.

  get_configuration() → dict

    Get the currently active configuration.

    Returns:

      The currently active configuration.

  configure(config: str = '', metadata: dict | None = None) → bool

    Configure the device with the known configuration config.

    To add a configuration to the device, use `update_configuration()`.

    Parameters:

      - config – Key (name) of the configuration

      - metadata – Metadata that is merged into the current payload metadata dict which is send with every emitted `acquisition_data` event.

  set_configuration
  update_payload_metadata(metadata: dict, merge: bool = True) → None

    Update metadata dict send with every emitted frame by the `acquisition_data` event method.

    Parameters:

      - metadata – Metadata that is merged into the current payload metadata dict which is send with every emitted `acquisition_data` event.

      - merge – If `True`, the new dict is merged with the current set metadata dict. If `False` the old metadata is overwritten by the given dict.

  arm(metadata: dict | None = None, kill_running: bool = False) → bool

    Arm the device with the currently active configuration.

    Parameters:

      - metadata – Metadata that is merged into the current payload metadata dict which is send with every emitted `acquisition_data` event.

      - kill_running – If `True` any running acquisition will be stopped. If `False` and an acquisition is

      - running (already)

      - raised. (an error will be)

    Returns:

      True if arming was successful else False

  acquisition_data(frame: numpy.ndarray, metadata: dict | None = None) → tuple

    Event to emit new frames.

    Note

    The dtype of the frame is not changed here.

    Parameters:

      - frame – The frame payload data (for example an image or an scope trace)

      - metadata – The metadata which is passed along the payload. This argument takes precedence over the `payload_metadata` attribute (for example set by the `update_payload_metadata` method) while merging the two dicts.

    Returns:

      A tuple of image and metadata(-dict)

  acquisition_started(metadata: dict | None = None) → dict

    Event emitted when the acquisition thread starts.

    Returns:

      A dict with acquisition metadata

  acquisition_stopped(metadata: dict | None = None) → dict

    Event emitted when the acquisition thread stops.

    Returns:

      A dict with acquisition metadata