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