openflexure_microscope_server.scan_planners.SmartSpiral

class documentation

class SmartSpiral(ScanPlanner): (source)

Constructor: SmartSpiral(initial_position, planner_settings)

View In Hierarchy

A scan planner that spirals outward from the centre, prioritising short moves.

This planner spirals out from the centre, but prioritises short moves over rigidly sticking to minimising radius from the centre of the scan.

Each time and image is taken the four neighbouring images are added to the list of positions to image (unless they are already listed or tried). However, if a location is not imaged due no sample being detected, then neighbouring positions are not imaged.

The next image taken is the fewest scan sites (moves in dx and dy) from the current site, with ties broken by minimising the moves away from the start of the scan. Final tiebreak is the distance to each site, in motor steps rather than multiple of dx and dy.

Method __init__ Set up the lists inherited from ScanPlanner, plus a distance cutoff.
Method get_next_location_and_z_estimate Return the next location to scan and its estimated z-position.
Method mark_location_visited Mark the location as visited.
Method moves_between Return the larger of x moves or y moves between two xy positions.
Method select_nearby_focus_site Return the xyz position of the nearby site with the lowest z position.
Property secondary_locations A list of all secondary (intermediate) locations.
Method _add_intermediate_positions Add intermediate points after locating a background location.
Method _add_surrounding_positions Add the 4 surrounding positions to the list of remaining locations to visit.
Method _adjacent_positions Return 4 points +/-dx and +/-dy from the input location.
Method _initial_location_list Set the initial list of locations for this scan planner.
Method _intermediate_position Return an (x,y) position halfway between two input positions.
Method _is_primary_location Return True if input is a primary location not a secondary (intermediate) location.
Method _parse Parse SmartSpiral Settings dictionary.
Method _re_sort_remaining_locations Sort the remaining positions based on the current location.
Instance Variable _distance_cutoff Undocumented
Instance Variable _dx Undocumented
Instance Variable _dy Undocumented
Instance Variable _max_dist Undocumented

Inherited from ScanPlanner:

Method closest_focus_site Return the xyz position of the closest site where focus was achieved.
Method get_visited_location Return the scan location from the history that matches the input position.
Method position_planned Return True if input scan position position is planned.
Method position_visited Return True if input scan position has been visited before.
Property focused_locations Property to access a copy of the focused_locations.
Property imaged_locations Property to access a copy of the imaged_locations.
Property path_history Property to access a copy of the path_history.
Property remaining_locations Property to access a copy of the remaining_locations.
Property scan_complete Return True if there are no locations left to scan.
Instance Variable _initial_position Undocumented
Instance Variable _path_history Undocumented
Instance Variable _remaining_locations Undocumented
def __init__(self, initial_position: XYPos, planner_settings: dict | None = None): (source)
overrides openflexure_microscope_server.scan_planners.ScanPlanner.__init__

Set up the lists inherited from ScanPlanner, plus a distance cutoff.

Use the supplied _dx and _dy to set a distance cutoff for an image to be considered neighbouring another

def get_next_location_and_z_estimate(self) -> tuple[XYPos, int | None]: (source)
overrides openflexure_microscope_server.scan_planners.ScanPlanner.get_next_location_and_z_estimate

Return the next location to scan and its estimated z-position.

This overrides the default behaviour of ScanPlanner to take the lowest value of nearest neighbours as this works best for smart stack.

Note z-position may be None! This indicates that the current z position should be used.

def mark_location_visited(self, xyz_pos: XYZPos, imaged: bool = True, focused: bool = True): (source)
overrides openflexure_microscope_server.scan_planners.ScanPlanner.mark_location_visited

Mark the location as visited.

Parameters
xyz_pos:XYZPosthe x_y_z position
imaged:booltrue if an image was taken, false if not (due to background detect)
focused:booltrue if autofocus completed successfully
def moves_between(self, starting_pos: XYPos | np.ndarray | FutureScanLocation, ending_pos: XYPos | np.ndarray | FutureScanLocation) -> float: (source)

Return the larger of x moves or y moves between two xy positions.

Parameters
starting_pos:XYPos | np.ndarray | FutureScanLocationthe position to measure from
ending_pos:XYPos | np.ndarray | FutureScanLocationthe position to measure to
Returns
floatUndocumented
def select_nearby_focus_site(self, xy_pos: XYPos) -> XYZPos | None: (source)

Return the xyz position of the nearby site with the lowest z position.

Lowest position is best, as starting too high causes smart stacking to autofocus and restart. Starting too low just requires extra movements in +z. Nearby is defined as within 1.1 times the larger of the x and y scan offsets.

If no focused sites are within this range, use the height of the nearest focused site.

Returns None if no focused locations are present

@property
secondary_locations: XYZPosList = (source)

A list of all secondary (intermediate) locations.

def _add_intermediate_positions(self, xy_pos: XYPos): (source)

Add intermediate points after locating a background location.

This is called after an image is recorded that was background. Intermediate locations are added between any adjacent locations that were successfully imaged due to being labelled as containing sample.

Note that in the case that an imaged location has an adjacent background image then adding the intermediate image will be handled by _add_surrounding_positions().

def _add_surrounding_positions(self, xy_pos: XYPos): (source)

Add the 4 surrounding positions to the list of remaining locations to visit.

This adds the surrounding positions (with 4 point connectivity) to the remaining locations list if they are not:

  • too far away
  • already planned
  • already visited

If the already visited position was not imaged then an intermediate location is added. See also self._add_intermediate_positions() for adding intermediate locations after visiting a location that was not imaged.

def _adjacent_positions(self, xy_pos: XYPos) -> XYPosList: (source)

Return 4 points +/-dx and +/-dy from the input location.

def _initial_location_list(self) -> list[FutureScanLocation]: (source)
overrides openflexure_microscope_server.scan_planners.ScanPlanner._initial_location_list

Set the initial list of locations for this scan planner.

This is salled on initialisation.

For smart spiral this is just the first point

def _intermediate_position(self, xy_pos1: XYPos, xy_pos2: XYPos) -> XYPos: (source)

Return an (x,y) position halfway between two input positions.

def _is_primary_location(self, location: FutureScanLocation | VisitedScanLocation) -> bool: (source)

Return True if input is a primary location not a secondary (intermediate) location.

def _parse(self, planner_settings: dict | None = None): (source)
overrides openflexure_microscope_server.scan_planners.ScanPlanner._parse

Parse SmartSpiral Settings dictionary.

  • dx - the movement size in x
  • dy - the movement size in y
  • max_dist - The maximum distance to a location can be from the centre.
def _re_sort_remaining_locations(self, current_pos: XYPos): (source)

Sort the remaining positions based on the current location.

_distance_cutoff: float = (source)

Undocumented

_dx: int = (source)

Undocumented

_dy: int = (source)

Undocumented

_max_dist: int = (source)

Undocumented