openflexure_microscope_server.things.camera.simulation.SimulatedCamera

class documentation

class SimulatedCamera(BaseCamera): (source)

Constructor: SimulatedCamera(shape, glyph_shape, canvas_shape, sample_limits, ...)

A Thing that simulates a camera for testing.

Method	`__enter__`	Start the capture thread when the Thing context manager is opened.
Method	`__exit__`	Close the capture thread when the Thing context manager is closed.
Method	`__init__`	Initialise the simulated with settings for how images are generated.
Method	`attach_to_server`	Wrap the attach_to_server method so the server instance can be stored.
Method	`capture_array`	Acquire one image from the camera and return as an array.
Method	`capture_image`	Capture to a PIL image. This is not exposed as a ThingAction.
Method	`discard_frames`	Discard frames so that the next frame captured is fresh.
Method	`draw_sprite_on_canvas`	Place one sprite on canvas at given centre coordinates.
Method	`full_auto_calibrate`	Perform a full auto-calibration.
Method	`generate_blobs`	Generate coordinates of blobs and their sizes, centered around (0,0).
Method	`generate_canvas`	Generate a canvas with generated blobs centered at the middle.
Method	`generate_frame`	Generate a frame with blobs based on the stage coordinates.
Method	`generate_image`	Generate an image with blobs based on supplied coordinates.
Method	`generate_sprites`	Generate sprites to populate the image.
Method	`get_stage_position`	Return the stage position.
Method	`load_sample`	Show the simulated sample.
Method	`remove_sample`	Show the simulated background with no sample.
Method	`start_streaming`	Start the live stream.
Method	`validate_inputs`	Validate the inputs passed to the simulation, and raises an error if invalid.
Class Variable	`noise_level`	Undocumented
Instance Variable	`blank_canvas`	Undocumented
Instance Variable	`blobs`	Undocumented
Instance Variable	`canvas`	Undocumented
Instance Variable	`canvas_shape`	Undocumented
Instance Variable	`frame_interval`	Undocumented
Instance Variable	`glyph_shape`	Undocumented
Instance Variable	`sample_limits`	Undocumented
Instance Variable	`shape`	Undocumented
Instance Variable	`sprites`	Undocumented
Property	`calibration_required`	Whether the camera needs calibrating.
Property	`manual_camera_settings`	The camera settings to expose as property controls in the settings panel.
Property	`primary_calibration_actions`	The calibration actions for both calibration wizard and settings panel.
Property	`secondary_calibration_actions`	The calibration actions that appear only in settings panel.
Property	`stream_active`	Whether the MJPEG stream is active.
Method	`_capture_frames`	Undocumented
Instance Variable	`_capture_enabled`	Undocumented
Instance Variable	`_capture_thread`	Undocumented
Instance Variable	`_server`	Undocumented
Instance Variable	`_show_sample`	Undocumented
Instance Variable	`_stage`	Undocumented

Inherited from BaseCamera:

Method	`background_detector_data`	The data for each background detector, used to save to disk.
Method	`background_detector_data.setter`	Set the data for each detector. Only to be used as settings are loaded from disk.
Method	`capture_and_save`	Capture an image and save it to disk.
Method	`capture_downsampled_array`	Acquire one image from the camera, downsample, and return as an array.
Method	`capture_jpeg`	Acquire one image from the camera as a JPEG.
Method	`capture_to_memory`	Capture an image to memory. This can be saved later with `save_from_memory`.
Method	`clear_buffers`	Clear all images in memory.
Method	`detector_name`	The name of the active background selector.
Method	`detector_name.setter`	Validate and set detector_name.
Method	`grab_as_array`	Acquire one image from the preview stream and return as an array.
Method	`grab_jpeg`	Acquire one image from the preview stream and return as blob of JPEG data.
Method	`grab_jpeg_size`	Acquire one image from the preview stream and return its size.
Method	`image_is_sample`	Label the current image as either background or sample.
Method	`kill_mjpeg_streams`	Kill the streams now as the server is shutting down.
Method	`save_from_memory`	Save an image that has been captured to memory.
Method	`set_background`	Grab an image, and use its statistics to set the background.
Method	`settle`	Sleep for the settling time, ready to provide a fresh frame.
Method	`update_detector_settings`	Update the settings of the current detector.
Class Variable	`downsampled_array_factor`	The downsampling factor when calling capture_downsampled_array.
Class Variable	`lores_mjpeg_stream`	Undocumented
Class Variable	`mjpeg_stream`	Undocumented
Class Variable	`settling_time`	The settling time when calling the `settle()` method.
Instance Variable	`background_detectors`	Undocumented
Property	`active_detector`	The active background detector instance.
Property	`background_detector_status`	The status of the active detector for the UI.
Property	`thing_state`	Empty metadata dict for subclasses to populate.
Method	`_add_metadata_to_capture`	Add the EXIF metadata for a JPEG image.
Method	`_capture_metadata`	Return the metadata for a capture, from the thing states, time and known names.
Method	`_robust_image_capture`	Capture an image in memory and return it with metadata.
Method	`_save_capture`	Save the captured image and metadata to disk.
Class Variable	`_memory_buffer`	Undocumented
Instance Variable	`_detector_name`	Undocumented

def __enter__(self): (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.__enter__

Start the capture thread when the Thing context manager is opened.

def __exit__(self, _exc_type: type[BaseException], _exc_value: BaseException | None, _traceback: TracebackType | None): (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.__exit__

Close the capture thread when the Thing context manager is closed.

def __init__(self, shape: tuple[int, int, int] = (616, 820, 3), glyph_shape: tuple[int, int, int] = (121, 121, 3), canvas_shape: tuple[int, int, int] = (3000, 4000, 3), sample_limits: tuple[int, int] | None = (1000, 1500), frame_interval: float = 0.1): (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.__init__

Initialise the simulated with settings for how images are generated.

Parameters
shape:`tuple[int, int, int]`	The shape (size) of the generated image.
glyph_shape:`tuple[int, int, int]`	The size randomly positioned glyphs.
canvas_shape:`tuple[int, int, int]`	The shape (size) of the canvas generated on initialisation that images are cropped from. If this is too large the it uses resources, but its size limits the range of motion of the simulation.
sample_limits:`tuple[int, int] \| None`	The shape of the sample. Outside this range, the camera won't generate any blobs, preventing scanning from running indefinitely and better demonstrating background detect.
frame_interval:`float`	Nominally the time between frames on the MJPEG stream, however the rate may be slower due to calculation time for focus.

def attach_to_server(self, server: lt.ThingServer, path: str, setting_storage_path: str): (source) ¶

Wrap the attach_to_server method so the server instance can be stored.

Direct access to the server instance is needed to get the stage position while maintaining the same public API as a real camera that doesn't need this access.

@lt.thing_action

def capture_array(self, stream_name: Literal['main', 'full'] = 'full', wait: float | None = None) -> ArrayModel: (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.capture_array

Acquire one image from the camera and return as an array.

This function will produce a nested list containing an uncompressed RGB image. It's likely to be highly inefficient - raw and/or uncompressed captures using binary image formats will be added in due course.

Parameters
stream_name:`Literal['main', 'full']`	Currently ignored, this argument exists to ensure consistent API across camera Things.
wait:`float \| None`	Currently ignored, this argument exists to ensure consistent API across camera Things.

Returns
`ArrayModel`	Undocumented

def capture_image(self, stream_name: Literal['main', 'lores', 'raw'], wait: float | None = None) -> Image: (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.capture_image

Capture to a PIL image. This is not exposed as a ThingAction.

It is used for capture to memory.

Parameters
stream_name:`Literal['main', 'lores', 'raw']`	Currently ignored, this argument exists to ensure consistent API across camera Things.
wait:`float \| None`	Currently ignored, this argument exists to ensure consistent API across camera Things.

Returns
`Image`	Undocumented

@lt.thing_action

def discard_frames(self): (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.discard_frames

Discard frames so that the next frame captured is fresh.

There is nothing to do as this is a simulation!

def draw_sprite_on_canvas(self, sprite: np.ndarray, centre_y: int, centre_x: int): (source) ¶

Place one sprite on canvas at given centre coordinates.

Note that self.canvas is modified in place.

Parameters
sprite:`np.ndarray`	The sprite array to place on the canvas.
centre_y:`int`	The y coordinate to place the centre of the sprite.
centre_x:`int`	The x coordinate to place the centre of the sprite.

@lt.thing_action

def full_auto_calibrate(self, portal: lt.deps.BlockingPortal): (source) ¶

Perform a full auto-calibration.

For the simulation microscope the process is:

remove_sample
set_background
load_sample

def generate_blobs(self, n_blobs: int = 1000): (source) ¶

Generate coordinates of blobs and their sizes, centered around (0,0).

Note that blob density is determined by sample size and n_blobs, and for larger samples n_blobs will need increasing to keep a high level of sample coverage per field of view.

Parameters
n_blobs:`int`	The number of blobs to generate.

def generate_canvas(self): (source) ¶

Generate a canvas with generated blobs centered at the middle.

Canvas is int16 so that random noise can be added to simulation image before changing to unit8 to stop wrapping.

def generate_frame(self) -> Image: (source) ¶

Generate a frame with blobs based on the stage coordinates.

def generate_image(self, pos: tuple[int, int, int]) -> Image: (source) ¶

Generate an image with blobs based on supplied coordinates.

Parameters
pos:`tuple[int, int, int]`	a 3-item tuple containing the x,y,z coordinates of the 'stage'

Returns
`Image`	Undocumented

def generate_sprites(self): (source) ¶

Generate sprites to populate the image.

def get_stage_position(self) -> Mapping[str, int]: (source) ¶

Return the stage position.

The simulation camera has access to the stage position so it can generate a different image as the stage moves.

@lt.thing_action

def load_sample(self): (source) ¶

Show the simulated sample.

@lt.thing_action

def remove_sample(self): (source) ¶

Show the simulated background with no sample.

@lt.thing_action

def start_streaming(self, main_resolution: tuple[int, int] = (820, 616), buffer_count: int = 1): (source) ¶

overrides openflexure_microscope_server.things.camera.BaseCamera.start_streaming

Start the live stream.

The start_streaming method is used a camera Thing to begin streaming images or to adjust the stream resolution if streaming is already active.

The simulation camera does not currently support the resolution argument. It will always issue a warning that the resolution is not respected. If called while already streaming, the warning will be emitted and no other action will be taken.

Parameters
main_resolution:`tuple[int, int]`	Currently ignored, this argument exists to ensure consistent API across camera Things.
buffer_count:`int`	Currently ignored, this argument exists to ensure consistent API across camera Things.