openflexure_microscope_server.things.stage

class documentation

class RangeofMotionThing(lt.Thing): (source)

Constructor: RangeofMotionThing(thing_server_interface)

A class used to measure the range of motion of the stage in X and Y.

Method	`__init__`	Initialise and create the lock.
Method	`perform_recentre`	Measures the curvature of the motion to centre x and y axes.
Method	`perform_rom_test`	Measures the range of motion of the stage across the x and y axes.
Instance Variable	`calibrated_range`	Undocumented
Method	`_big_z_corrected_movement`	Take one big move with feed-forward z-correction.
Method	`_distance_in_img_percentage`	For a target location in stage coords return the distance in percentage of FOV.
Method	`_img_dir_from_stage_coords`	For a target location in stage coords, return the direction in image coordinates.
Method	`_img_percentage_to_img_coords`	For a given image percentage and axis return the distance in img coords.
Method	`_move_and_measure`	Move the stage and measure the offset between the two positions.
Method	`_move_back_until_motion_detected`	Move the stage against the direction of test unil motion is detected.
Method	`_move_until_edge`	Move in one direction until movement per step decreases significantly.
Method	`_movement_in_img_coords`	Return the dictionary for a move in image coordinates.
Method	`_moves_for_z_prediction`	Perform medium sized moves with autofocus for z feed-forward.
Method	`_offset_from`	Take an image and calculate the offset from an input image.
Method	`_recentre_axis`	Recentre a single axis.
Method	`_recentre_decision`	Decide what to do next during recentreing.
Method	`_set_stream_resolution`	Set the self._stream_resolution attribute by reading camera.
Method	`_stage_still_moves`	Carry out 3 small moves in a given direction and axis.
Class Variable	`_autofocus`	Undocumented
Class Variable	`_cam`	Undocumented
Class Variable	`_csm`	Undocumented
Class Variable	`_stage`	Undocumented
Instance Variable	`_lock`	Undocumented
Instance Variable	`_rom_data`	Undocumented
Instance Variable	`_stream_resolution`	Undocumented

def __init__(self, thing_server_interface: lt.ThingServerInterface): (source) ¶

Initialise and create the lock.

@lt.action

def perform_recentre(self): (source) ¶

Measures the curvature of the motion to centre x and y axes.

@lt.action

def perform_rom_test(self) -> Mapping[str, Any]: (source) ¶

Measures the range of motion of the stage across the x and y axes.

Returns
`Mapping[str, Any]`	Results dictionary separated into keys of each axis and direction.

calibrated_range: tuple[int, int] | None = (source) ¶

Undocumented

def _big_z_corrected_movement(self, axis: Literal['x', 'y'], direction: Literal[1, -1]): (source) ¶

Take one big move with feed-forward z-correction.

The size is defined by the BIG_STEP constant.

Parameters
axis:`Literal['x', 'y']`	The axis to move in.
direction:`Literal[1, -1]`	The direction to move in.

def _distance_in_img_percentage(self, target: Mapping[str, int], axis: Literal['x', 'y']) -> float: (source) ¶

For a target location in stage coords return the distance in percentage of FOV.

Parameters
target:`Mapping[str, int]`	The target poisiton in stage coordinates
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.

Returns
`float`	Percentage of field of view the stage should move by.

def _img_dir_from_stage_coords(self, target: Mapping[str, int], axis: Literal['x', 'y']) -> Literal[1, -1]: (source) ¶

For a target location in stage coords, return the direction in image coordinates.

Parameters
target:`Mapping[str, int]`	The target poisiton in stage coordinates
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.

Returns
`Literal[1, -1]`	Direction to move in image coordinates.

def _img_percentage_to_img_coords(self, fov_perc: int, axis: Literal['x', 'y']) -> float: (source) ¶

For a given image percentage and axis return the distance in img coords.

Parameters
fov_perc:`int`	The percentage of field of view the stage should move by.
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.

Returns
`float`	Distance in image coordinates (pixels)

def _move_and_measure(self, movement: Mapping[str, float], perform_autofocus: bool = True, max_autofocus_repeats: int = 0, abs_min_offset: float = 0.0) -> Mapping[str, float]: (source) ¶

Move the stage and measure the offset between the two positions.

Parameters
movement:`Mapping[str, float]`	A dictionary containing the distance to move in image coords.
perform_autofocus:`bool`	Set to False to disable autofocus after move. Default is True
max_autofocus_repeats:`int`	The number of times to repeat the focus if the detected (on-axis) offset is below `abs_min_offset`. This will only work if `abs_min_offset` is also set
abs_min_offset:`float`	The absolute minimum (on-axis) offset, under which the autofocus is repeated.

Returns
`Mapping[str, float]`	The calculated offset from cross correlation.

def _move_back_until_motion_detected(self, axis: Literal['x', 'y'], direction: Literal[1, -1]): (source) ¶

Move the stage against the direction of test unil motion is detected.

In the case that the stage has reached the end of the motion, this method moves the motor in the opposite direction until reliable motion is detected.

Parameters
axis:`Literal['x', 'y']`	The axis in which the stage is moving. This must be 'x' or 'y'.
direction:`Literal[1, -1]`	The direction in which the stage was moving during the test, this method will move in the opposite direction.

def _move_until_edge(self, axis: Literal['x', 'y'], direction: Literal[1, -1]): (source) ¶

Move in one direction until movement per step decreases significantly.

This should move until the edge of the stage. Once the edge is reached there will be some movement as there is no hard stop, but it will reduce significantly.

Parameters
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.
direction:`Literal[1, -1]`	The direction which is being measured. This must be 1 or -1.

Returns
Results dictionary containing stage positions, correlations and the final position.

def _movement_in_img_coords(self, fov_perc: int, axis: Literal['x', 'y'], direction: Literal[1, -1]) -> Mapping[str, float]: (source) ¶

Return the dictionary for a move in image coordinates.

This dictionary can be passed directly to csm.move_in_image_coordinates

Parameters
fov_perc:`int`	The percentage of field of view the stage should move by.
axis:`Literal['x', 'y']`	The resolution of the stream from the camera.
direction:`Literal[1, -1]`	The direction the stage moves.

Returns
`Mapping[str, float]`	The movement size in image coordinates

def _moves_for_z_prediction(self, axis: Literal['x', 'y'], direction: Literal[1, -1], n_moves: int = 5): (source) ¶

Perform medium sized moves with autofocus for z feed-forward.

z-feed forward allows prediction of the z-position as the stage moves. For the feed forward calculation to work an initial number of measurements must be taken.

Parameters
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.
direction:`Literal[1, -1]`	The direction the stage moves.
n_moves:`int`	Number of moves to make. Default is 5 which is enough for an initial z estimate.

def _offset_from(self, before_img: np.ndarray) -> Mapping[str, float]: (source) ¶

Take an image and calculate the offset from an input image.

Parameters
before_img:`np.ndarray`	The image the offset should be calculated with respect to.

Returns
`Mapping[str, float]`	The calculated offset as a dictionary in pixels

def _recentre_axis(self, axis: Literal['x', 'y']): (source) ¶

Recentre a single axis.

Parameters
axis:`Literal['x', 'y']`	The axis to recentre

def _recentre_decision(self, axis: Literal['x', 'y']) -> tuple[bool, Literal[1, -1]]: (source) ¶

Decide what to do next during recentreing.

The algorithm here:

Estimate turning point location
Check if distance to point is further than a "BIG_STEP"
If smaller, move to estimated centre, and return that it is centred
If larger, return that it is not centred, and the direction to move in.

Parameters
axis:`Literal['x', 'y']`	The axis to recentre

Returns
`tuple[bool, Literal[1, -1]]`	A tuple. The first value is True for "the stage is now centred" and False for "the stage is not centred". The second value is the direction to move in, this only has meaning if the first value is False.

def _set_stream_resolution(self): (source) ¶

Set the self._stream_resolution attribute by reading camera.

def _stage_still_moves(self, axis: Literal['x', 'y'], direction: Literal[1, -1]) -> bool: (source) ¶

Carry out 3 small moves in a given direction and axis.

An image is taken before and after each move to check the stage has moved as far as it should. If the offset (calculated by cross correlation) is less than expected, 3 attempts are made to refocus the image to ensure that image quality is not causing the offset to mistakenly be reported as a low value. If the calculated offset is still too low then this is taken as an indication that the edge has been found.

Parameters
axis:`Literal['x', 'y']`	The axis which is being measured. This must be 'x' or 'y'.
direction:`Literal[1, -1]`	The direction the stage moves.

Returns
`bool`	Undocumented

_autofocus: AutofocusThing = (source) ¶

Undocumented

_cam: BaseCamera = (source) ¶

Undocumented

_csm: CameraStageMapper = (source) ¶

Undocumented

_stage: BaseStage = (source) ¶

Undocumented

_lock = (source) ¶

Undocumented

_rom_data = (source) ¶

Undocumented

_stream_resolution: tuple[int, int] | None = (source) ¶

Undocumented

openflexure_microscope_server.things.stage_measure.RangeofMotionThing

`openflexure_microscope_server.things.stage_measure.RangeofMotionThing`