From 89a810de47b904a21d7dcf537e20a58076ff7d41 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 13 May 2026 17:57:37 -0700 Subject: [PATCH 001/177] cleanup imports --- bapsf_motion/transform/lapd_droop.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bapsf_motion/transform/lapd_droop.py b/bapsf_motion/transform/lapd_droop.py index d6f33fcf..2a46af3d 100644 --- a/bapsf_motion/transform/lapd_droop.py +++ b/bapsf_motion/transform/lapd_droop.py @@ -4,13 +4,12 @@ __all__ = ["DroopCorrectABC", "LaPDXYDroopCorrect"] import astropy.units as u +import numpy as np from abc import ABC, abstractmethod from typing import Any, Dict, List, Union from warnings import warn -import numpy as np - from bapsf_motion.actors.drive_ import Drive From 71185031e3870dd6ad6d5129fcbbc34be33b5ee9 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 13 May 2026 18:00:53 -0700 Subject: [PATCH 002/177] apply black to enforce PEP8 --- bapsf_motion/transform/lapd.py | 39 +++++++++++++++++----------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index f09d4403..a4ff0f1f 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -195,6 +195,7 @@ class LaPDXYTransform(base.BaseTransform): "mspace_polarity": (1, 1), } """ + # TODO: confirm polarity descriptions once issue #38 is resolved # TODO: review that default polarities are correct # TODO: write a full primer on how the coordinate transform was @@ -252,7 +253,7 @@ def __call__(self, points, to_coords="drive") -> np.ndarray: points[..., 0] = _sign * (pivot_to_center - points[..., 0]) tr_points = super().__call__(points=points, to_coords=to_coords) - + if to_coords != "drive": # to motion space _sign = 1 if self.deployed_side == "East" else -1 pivot_to_center = np.abs(self.pivot_to_center) @@ -260,9 +261,7 @@ def __call__(self, points, to_coords="drive") -> np.ndarray: # - tr_points is in LaPD motion space coordinates # - need to convert motion space coordinates to droop scenario # 1. convert to ball valve coords - tr_points[..., 0] = np.absolute( - _sign * pivot_to_center - tr_points[..., 0] - ) + tr_points[..., 0] = np.absolute(_sign * pivot_to_center - tr_points[..., 0]) # 2. droop correct to droop coords tr_points = self.droop_correct(tr_points, to_points="droop") @@ -331,7 +330,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: self._droop_correct_callable = LaPDXYDroopCorrect( drive=_drive, pivot_to_feedthru=inputs["pivot_to_feedthru"], - droop_scale=inputs["droop_scale"] + droop_scale=inputs["droop_scale"], ) return inputs @@ -351,12 +350,12 @@ def _matrix_to_drive(self, points): theta = -np.arctan(tan_theta) T0 = np.zeros((npoints, 3, 3)).squeeze() - T0[..., 0, 2] = np.sqrt( - points[..., 1]**2 + (pivot_to_center + points[..., 0])**2 - ) - pivot_to_center - T0[..., 1, 2] = ( - self.pivot_to_drive * np.tan(theta) - + self.probe_axis_offset * (1 - (1 / np.cos(theta))) + T0[..., 0, 2] = ( + np.sqrt(points[..., 1] ** 2 + (pivot_to_center + points[..., 0]) ** 2) + - pivot_to_center + ) + T0[..., 1, 2] = self.pivot_to_drive * np.tan(theta) + self.probe_axis_offset * ( + 1 - (1 / np.cos(theta)) ) T0[..., 2, 2] = 1.0 @@ -386,8 +385,7 @@ def _matrix_to_motion_space(self, points: np.ndarray): # - alpha = beta - theta sine_alpha = self.probe_axis_offset / np.sqrt( - self.pivot_to_drive**2 - + (-self.probe_axis_offset + points[..., 1])**2 + self.pivot_to_drive**2 + (-self.probe_axis_offset + points[..., 1]) ** 2 ) tan_beta = (-self.probe_axis_offset + points[..., 1]) / -self.pivot_to_drive @@ -682,6 +680,7 @@ class LaPD6KTransform(LaPDXYTransform): :ref:`LaPD6KYTransform `. """ + _transform_type = "lapd_6k" _dimensionality = 2 @@ -724,8 +723,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: val = _inputs[key] if not isinstance(val, (float, np.floating, int, np.integer)): raise TypeError( - f"Keyword '{key}' expected type float or int, " - f"got type {type(val)}." + f"Keyword '{key}' expected type float or int, " f"got type {type(val)}." ) elif val < 0.0: val = np.abs(val) @@ -738,7 +736,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: # calculate distance between ball valve center (pivot) to the # pivot (pinion) point on the probe drive arm self._pivot_to_drive_pinion = np.sqrt( - _inputs["pivot_to_drive"]**2 + _inputs["probe_axis_offset"]**2 + _inputs["pivot_to_drive"] ** 2 + _inputs["probe_axis_offset"] ** 2 ) # calculate beta - the angular drop from the probe shaft to the @@ -812,7 +810,7 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # pivot point on the probe drive vertical axis (vpinion) pivot_to_vpinion = np.sqrt( self.pivot_to_drive**2 - + (self.six_k_arm_length - self.probe_axis_offset + points[..., 1])**2 + + (self.six_k_arm_length - self.probe_axis_offset + points[..., 1]) ** 2 ).squeeze() # calculate the angle (gamma) the line intersecting the ball valve @@ -840,12 +838,15 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # with the above mentioned "x-axis". # tan_2_phi = ( - 2 * pivot_to_vpinion * self.pivot_to_drive_pinion / ( + 2 + * pivot_to_vpinion + * self.pivot_to_drive_pinion + / ( self.six_k_arm_length**2 - self.pivot_to_drive_pinion**2 - pivot_to_vpinion**2 ) - )**2 - 1 + ) ** 2 - 1 phi = np.arctan(np.sqrt(tan_2_phi)) # calculate theta - the angle the probe shaft makes with the From 7b55fef43a39e0367ff90276d36208ee75e8b28f Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 13 May 2026 18:16:44 -0700 Subject: [PATCH 003/177] first really rough pass on LaPDXYZTransform --- bapsf_motion/transform/__init__.py | 14 +- bapsf_motion/transform/lapd.py | 297 ++++++++++++++++++++++++++++- 2 files changed, 305 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/transform/__init__.py b/bapsf_motion/transform/__init__.py index e539a67f..85a6d764 100644 --- a/bapsf_motion/transform/__init__.py +++ b/bapsf_motion/transform/__init__.py @@ -2,6 +2,7 @@ Module containing all functionality for converting probe drive coordinates to motion space coordinates, and vise versa. """ + __all__ = [ "transform_factory", "register_transform", @@ -9,11 +10,20 @@ "DroopCorrectABC", "LaPDXYDroopCorrect", ] -__transformer__ = ["IdentityTransform", "LaPDXYTransform", "LaPD6KTransform"] +__transformer__ = [ + "IdentityTransform", + "LaPDXYTransform", + "LaPD6KTransform", + "LaPDXYZTransform", +] __all__ += __transformer__ from bapsf_motion.transform.base import BaseTransform from bapsf_motion.transform.helpers import register_transform, transform_factory -from bapsf_motion.transform.lapd import LaPDXYTransform, LaPD6KTransform from bapsf_motion.transform.identity import IdentityTransform +from bapsf_motion.transform.lapd import ( + LaPD6KTransform, + LaPDXYTransform, + LaPDXYZTransform, +) from bapsf_motion.transform.lapd_droop import DroopCorrectABC, LaPDXYDroopCorrect diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index a4ff0f1f..5d7a1c99 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1,15 +1,23 @@ """Module that defines the LaPD related transform classes.""" -__all__ = ["LaPDXYTransform", "LaPD6KTransform"] -__transformer__ = ["LaPDXYTransform", "LaPD6KTransform"] + +from __future__ import annotations + +__all__ = ["LaPDXYTransform", "LaPD6KTransform", "LaPDXYZTransform"] +__transformer__ = ["LaPDXYTransform", "LaPD6KTransform", "LaPD6KTransform"] import numpy as np -from typing import Any, Dict, Tuple, Union +from typing import Any, Dict, Tuple, TYPE_CHECKING, Union from warnings import warn from bapsf_motion.transform import base from bapsf_motion.transform.helpers import register_transform -from bapsf_motion.transform.lapd_droop import LaPDXYDroopCorrect, DroopCorrectABC +from bapsf_motion.transform.lapd_droop import DroopCorrectABC, LaPDXYDroopCorrect + +if TYPE_CHECKING: + # This is done for typing purposes only. + # An actual import would cause cyclical imports. + from bapsf_motion.actors import Drive @register_transform @@ -883,3 +891,284 @@ def beta(self) -> float: # angle swept from the probe shaft to the probe drive pinion with # respect to the ball valve pivot return self._beta + + +@register_transform +class LaPDXYZTransform(base.BaseTransform): + _transform_type = "lapd_xyz" + _dimensionality = 3 + + def __init__( + self, + drive: Drive, + *, + pivot_to_center: float, + pivot_to_xzcross: float, + # pivot_to_feedthru: float, + table_pivot_to_probe_axis: float, + table_pivot_to_zlead_vertical: float, + table_pivot_to_zlead_horizontal: float, + drive_polarity: Tuple[int, int] = (1, 1, 1), + mspace_polarity: Tuple[int, int] = (-1, 1, 1), + # droop_correct: bool = False, + # droop_scale: Union[int, float] = 1.0, + ): + self._droop_correct_callable = None + self._deployed_side = None + super().__init__( + drive, + pivot_to_center=pivot_to_center, + pivot_to_xzcross=pivot_to_xzcross, + # pivot_to_feedthru=pivot_to_feedthru, + table_pivot_to_probe_axis=table_pivot_to_probe_axis, + table_pivot_to_zlead_vertical=table_pivot_to_zlead_vertical, + table_pivot_to_zlead_horizontal=table_pivot_to_zlead_horizontal, + drive_polarity=drive_polarity, + mspace_polarity=mspace_polarity, + # droop_correct=droop_correct, + # droop_scale=droop_scale, + ) + + # def __call__(self, points, to_coords="drive") -> np.ndarray: + # if self.droop_correct is None: + # return super().__call__(points=points, to_coords=to_coords) + + def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: + + for key in { + "pivot_to_center", + "pivot_to_xzcross", + # "pivot_to_feedthru", + "table_pivot_to_probe_axis", + "table_pivot_to_zlead_vertical", + "table_pivot_to_zlead_horizontal", + # "droop_scale", + }: + val = inputs[key] + if not isinstance(val, (float, np.floating, int, np.integer)): + raise TypeError( + f"Keyword '{key}' expected type float or int, " + f"got type {type(val)}." + ) + elif key == "pivot_to_center": + self._deployed_side = "East" if val >= 0.0 else "West" + # do not take the absolute value here, so the config + # dict properly maintains the negative value + # val = np.abs(val) + elif val < 0.0: + # TODO: HOW (AND SHOULD WE) ALLOW A NEGATIVE OFFSET FOR + # "probe_axis_offset" + val = np.abs(val) + warn( + f"Keyword '{val}' is NOT supposed to be negative, " + f"assuming the absolute value {val}." + ) + inputs[key] = val + + for key in ("drive_polarity", "mspace_polarity"): + polarity = inputs[key] + if not isinstance(polarity, np.ndarray): + polarity = np.array(polarity) + + if polarity.shape != (3,): + raise ValueError( + f"Keyword '{key}' is supposed to be a 3-element " + "array specifying the polarity of the axes, got " + f"an array of shape {polarity.shape}." + ) + elif not np.all(np.abs(polarity) == 1): + raise ValueError( + f"Keyword '{key}' is supposed to be a 3-element " + "array of 1 or -1 specifying the polarity of the " + "axes, array has values not equal to 1 or -1." + ) + inputs[key] = polarity + + # if not isinstance(inputs["droop_correct"], bool): + # raise TypeError( + # f"Keyword 'droop_correct' expected type bool, " + # f"got type {type(inputs['droop_correct'])}." + # ) + # elif inputs["droop_correct"]: + # _drive = self._drive if self._drive is not None else self.axes + # self._droop_correct_callable = LaPDXYDroopCorrect( + # drive=_drive, + # pivot_to_feedthru=inputs["pivot_to_feedthru"], + # droop_scale=inputs["droop_scale"] + # ) + + return inputs + + def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: + return self._matrix_to_motion_space(points) + + def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: + # given points are in (e0, e1, e2) with shape (N, 3) + # - N is the number of point to conver + # - 3 is the (e0, e1, e2) coordintes + # + # we will utilized two other coordinate systems + # - ball-valve pivot: (b0, b1, b2) or [for spherical] (br, btheat, bphi) + # - mspace (aka LaPD): (x, y, z) + # + # Coordinate orientations used for the derivation + # e1 b1 Y + # ^ ^ ^ + # | ... | ... | + # o---> e0 o---> b0 o---> X + # e2 b2 Z + # + + # polarity needs to be adjusted first, since the parameters for + # the following transformation matrices depend on the adjusted + # coordinate space + points = self.drive_polarity * points # type: np.ndarray + npoints = points.shape[0] + + pivot_to_center = np.abs(self.pivot_to_center) + lx = np.abs(self.pivot_to_xzcross) + lt = np.abs(self.table_pivot_to_zlead_horizontal) + # vt = np.abs(self.table_pivot_to_zlead_vertical) + vs = np.abs(self.table_pivot_to_probe_axis) + ls = lx - lt + + # Calculate how much the probe shaft moves (s1) with e1 + # - this is the location of the probe shaft directly above the + # pivot on the L-bracket table + # + # 0 = s1^2 [ls^2 - vs^2] + # + s1 [2 (vs - e1) ls^2] + # + ls^2 e1 (e1 - 2 vs) + # + a = ls**2 - vs**2 + b = 2.0 * (vs - points[..., 1]) * ls**2 + c = ls**2 * points[..., 1] * (points[..., 1] - 2.0 * vs) + s1 = (-b + np.sqrt(b**2 - 4 * a * c)) / (2 * a) + + # Let alpha be the angle made between the probe shaft and the + # horizontal + # + # b_phi = -alpha + # tan( alpha ) = s1 / ls + # + alpha = np.arctan(s1 / ls) + + # Let lz be the distance from the ball-valve pivot to the z-drive + # lead screws as projected along the probe shaft + # + # lz = ls / cos(alpha) - vs tan(alpha) + lt + # + lz = ls / np.cos(alpha) - vs * np.tan(alpha) + lt + + # The ball-valve polar angle btheta is given by + # + # b_theta = pi / 2 - beta + # tan(beta) = e2 / lz + # + b_phi = -alpha + b_theta = 0.5 * np.pi - np.arctan(points[..., 2] / lz) + + # build the matrix + T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa + T0[..., 0, 0] = np.sin(b_theta) * np.cos(b_phi) + T0[..., 0, 3] = pivot_to_center * (np.sin(b_theta) * np.cos(b_phi) - 1) + T0[..., 1, 0] = np.sin(b_theta) * np.sin(b_phi) + T0[..., 1, 3] = pivot_to_center * np.sin(b_theta) * np.sin(b_phi) + T0[..., 2, 0] = np.cos(b_theta) + T0[..., 2, 3] = pivot_to_center * np.cos(b_theta) + T0[..., 3, 3] = 1.0 + + T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) # noqa + T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) # noqa + + return np.matmul( + T_mpolarity, + np.matmul(T0, T_dpolarity), + ) + + @property + def pivot_to_center(self) -> float: + """ + Distance from the center of the :term:`LaPD` to the center + "pivot" point of the ball valve. + """ + return self.inputs["pivot_to_center"] + + @property + def pivot_to_xzcross(self) -> float: + """ + Horizontal distance from the center "pivot" point of the ball + valve to the crossing point of the x-drive and z-drive lead + screws, when the x-drive is level with the ground. + """ + return self.inputs["pivot_to_xzcross"] + + @property + def table_pivot_to_probe_axis(self) -> float: + """ + Vertical distance from the pivot on the L-bracket table to + the probe shaft, when the x-drive is level with the ground. + """ + return self.inputs["table_pivot_to_probe_axis"] + + @property + def table_pivot_to_zlead_vertical(self) -> float: + """ + Vertical distance from the pivot on the L-bracket table to + the z-drive lead screw, when the x-drive is level with the + ground. + """ + return self.inputs["table_pivot_to_zlead_vertical"] + + @property + def table_pivot_to_zlead_horizontal(self) -> float: + """ + Horizontal distance from the pivot on the L-bracket table to + the z-drive lead screw, when the x-drive is level with the + ground. + """ + return self.inputs["table_pivot_to_zlead_horizontal"] + + @property + def drive_polarity(self) -> np.ndarray: + """ + A three element array of +/- 1 values indicating the polarity of + the probe drive motion to how the math was done for the + underlying matrix transformations. + """ + # TODO: FIX WORDING OF EXAMPLE AND INTEGRATE BACK INTO THE DOCSTRING + """ + + For example, a value of ``[1, 1, 1]`` would indicate that + positivemovement (in probe drive coordinates) of the drive would + be into inwards on the x-drive, upwards on the y-drive, and to + the right on the z-drive (when standing behind the drive). + However, this is inconsistent if the vertical axis has the motor + mounted to the top of the axis. In this case the + ``drive_polarity`` would be ``[1, -1, 1]``. + """ + return self.inputs["drive_polarity"] + + @property + def mspace_polarity(self) -> np.ndarray: + """ + A three element array of +/- 1 values indicating the polarity of + the motion space motion to how the math was done for the + underlying matrix transformations. + """ + # TODO: FIX WORDING OF EXAMPLE AND INTEGRATE BACK INTO THE DOCSTRING + """ + + For example, a value of ``(-1, 1, 1)`` for a probe mounted on an + East port would indicate that inward probe drive movement would + correspond to a LaPD -X movement and downward probe drive + movement would correspond to LaPD +Y. If the probe was mounted + on a West port then the polarity would need to be ``(1, 1)`` + since inward probe drive movement corresponds to +X LaPD + coordinate movement. + """ + return self.inputs["mspace_polarity"] + + @property + def deployed_side(self): + return self._deployed_side From 0b0d3899a013959c84a6cddbc20a3b9cd2ef6b50 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 13 May 2026 19:30:35 -0700 Subject: [PATCH 004/177] first really rough pass on LaPDXYZTransform._matrix_to_drive --- bapsf_motion/transform/lapd.py | 71 +++++++++++++++++++++++++++++++++- 1 file changed, 70 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 5d7a1c99..166a4ab4 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1000,7 +1000,76 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: return inputs def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: - return self._matrix_to_motion_space(points) + # given points are in (x, y, z) with shape (N, 3) + # - N is the number of point to conver + # - 3 is the (x, y, z) coordintes + # + # we will utilized two other coordinate systems + # - ball-valve pivot: (b0, b1, b2) or [for spherical] (br, btheat, bphi) + # - mspace (aka LaPD): (x, y, z) + # - drive space: (e0, e1, e2) + # + # Coordinate orientations used for the derivation + # e1 b1 Y + # ^ ^ ^ + # | ... | ... | + # o---> e0 o---> b0 o---> X + # e2 b2 Z + # + + # polarity needs to be adjusted first, since the parameters for + # the following transformation matrices depend on the adjusted + # coordinate space + points = self.mspace_polarity * points # type: np.ndarray + npoints = points.shape[0] + + pivot_to_center = np.abs(self.pivot_to_center) + lx = np.abs(self.pivot_to_xzcross) + lt = np.abs(self.table_pivot_to_zlead_horizontal) + # vt = np.abs(self.table_pivot_to_zlead_vertical) + vs = np.abs(self.table_pivot_to_probe_axis) + ls = lx - lt + + # Let alpha be the angle made between the probe shaft and the + # horizontal + # + # b_phi = -alpha = arctan(by / bx) = arctan(y / (pivot_to_center + x) + # + alpha = -np.arctan(points[..., 1] / (pivot_to_center + points[..., 0])) + + # Let lz be the distance from the ball-valve pivot to the z-drive + # lead screws as projected along the probe shaft + # + # lz = ls / cos(alpha) - vs tan(alpha) + lt + # + lz = ls / np.cos(alpha) - vs * np.tan(alpha) + lt + + # The ball-valve polar angle b_theta is expressed as + # + # b_theta = pi / 2 - beta = arccos(bz / br) = arccoz(z / br) + # br**2 = (pivot_to_center + x)**2 + y**2 +z**2 + # tan(beta) = e2 / lz + # + b_r = np.sqrt( + (pivot_to_center + points[..., 0])**2 + points[..., 1]**2 + points[..., 2]**2 + ) + b_theta = np.arccos(points[..., 2] / b_r) + + # build the matrix + T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa + T0[..., 0, 3] = b_r - pivot_to_center + T0[..., 1, 3] = ls * np.tan(alpha) + vs * (1 - 1 / np.cos(alpha)) + T0[..., 2, 3] = lz * np.tan(0.5 * np.pi - b_theta) + T0[..., 3, 3] = 1.0 + + T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) + T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) + + return np.matmul( + T_dpolarity, + np.matmul(T0, T_mpolarity), + ) + def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # given points are in (e0, e1, e2) with shape (N, 3) From 42ebedaf37f1a3e5b6dd209985d5bdf91ea93232 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 11:37:25 -0700 Subject: [PATCH 005/177] refactor variable names and remove argument table_pivot_to_zlead_vertical --- bapsf_motion/transform/lapd.py | 125 +++++++++++++++------------------ 1 file changed, 55 insertions(+), 70 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 166a4ab4..9107d85a 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -905,9 +905,8 @@ def __init__( pivot_to_center: float, pivot_to_xzcross: float, # pivot_to_feedthru: float, - table_pivot_to_probe_axis: float, - table_pivot_to_zlead_vertical: float, - table_pivot_to_zlead_horizontal: float, + probe_axis_offset: float, + table_pivot_to_zlead_screw: float, drive_polarity: Tuple[int, int] = (1, 1, 1), mspace_polarity: Tuple[int, int] = (-1, 1, 1), # droop_correct: bool = False, @@ -920,9 +919,8 @@ def __init__( pivot_to_center=pivot_to_center, pivot_to_xzcross=pivot_to_xzcross, # pivot_to_feedthru=pivot_to_feedthru, - table_pivot_to_probe_axis=table_pivot_to_probe_axis, - table_pivot_to_zlead_vertical=table_pivot_to_zlead_vertical, - table_pivot_to_zlead_horizontal=table_pivot_to_zlead_horizontal, + probe_axis_offset=probe_axis_offset, + table_pivot_to_zlead_screw=table_pivot_to_zlead_screw, drive_polarity=drive_polarity, mspace_polarity=mspace_polarity, # droop_correct=droop_correct, @@ -939,9 +937,8 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: "pivot_to_center", "pivot_to_xzcross", # "pivot_to_feedthru", - "table_pivot_to_probe_axis", - "table_pivot_to_zlead_vertical", - "table_pivot_to_zlead_horizontal", + "probe_axis_offset", + "table_pivot_to_zlead_screw", # "droop_scale", }: val = inputs[key] @@ -1001,12 +998,12 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # given points are in (x, y, z) with shape (N, 3) - # - N is the number of point to conver + # - N is the number of point to convert # - 3 is the (x, y, z) coordintes # - # we will utilized two other coordinate systems - # - ball-valve pivot: (b0, b1, b2) or [for spherical] (br, btheat, bphi) - # - mspace (aka LaPD): (x, y, z) + # we will utilized three coordinate systems for the conversion + # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, btheat, b_phi) + # - motion space (aka LaPD): (x, y, z) # - drive space: (e0, e1, e2) # # Coordinate orientations used for the derivation @@ -1024,11 +1021,10 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: npoints = points.shape[0] pivot_to_center = np.abs(self.pivot_to_center) - lx = np.abs(self.pivot_to_xzcross) - lt = np.abs(self.table_pivot_to_zlead_horizontal) - # vt = np.abs(self.table_pivot_to_zlead_vertical) - vs = np.abs(self.table_pivot_to_probe_axis) - ls = lx - lt + L_cross = np.abs(self.pivot_to_xzcross) + L_p2z = np.abs(self.table_pivot_to_zlead_screw) + H_offset = np.abs(self.probe_axis_offset) + L_table_pivot = L_cross - L_p2z # Let alpha be the angle made between the probe shaft and the # horizontal @@ -1037,29 +1033,29 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # alpha = -np.arctan(points[..., 1] / (pivot_to_center + points[..., 0])) - # Let lz be the distance from the ball-valve pivot to the z-drive + # Let D_zlead be the distance from the ball-valve pivot to the e2-drive # lead screws as projected along the probe shaft # - # lz = ls / cos(alpha) - vs tan(alpha) + lt + # D_zlead = L_table_pivot / cos(alpha) - H_offset tan(alpha) + L_p2z # - lz = ls / np.cos(alpha) - vs * np.tan(alpha) + lt + D_zlead = L_table_pivot / np.cos(alpha) - H_offset * np.tan(alpha) + L_p2z # The ball-valve polar angle b_theta is expressed as # - # b_theta = pi / 2 - beta = arccos(bz / br) = arccoz(z / br) - # br**2 = (pivot_to_center + x)**2 + y**2 +z**2 - # tan(beta) = e2 / lz + # b_theta = pi / 2 - beta = arccos(bz / b_rho) = arccoz(z / b_rho) + # b_rho**2 = (pivot_to_center + x)**2 + y**2 +z**2 + # tan(beta) = e2 / D_zlead # - b_r = np.sqrt( + b_rho = np.sqrt( (pivot_to_center + points[..., 0])**2 + points[..., 1]**2 + points[..., 2]**2 ) - b_theta = np.arccos(points[..., 2] / b_r) + b_theta = np.arccos(points[..., 2] / b_rho) # build the matrix T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa - T0[..., 0, 3] = b_r - pivot_to_center - T0[..., 1, 3] = ls * np.tan(alpha) + vs * (1 - 1 / np.cos(alpha)) - T0[..., 2, 3] = lz * np.tan(0.5 * np.pi - b_theta) + T0[..., 0, 3] = b_rho - pivot_to_center + T0[..., 1, 3] = L_table_pivot * np.tan(alpha) + H_offset * (1 - 1 / np.cos(alpha)) + T0[..., 2, 3] = D_zlead * np.tan(0.5 * np.pi - b_theta) T0[..., 3, 3] = 1.0 T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) @@ -1070,14 +1066,13 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: np.matmul(T0, T_mpolarity), ) - def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # given points are in (e0, e1, e2) with shape (N, 3) # - N is the number of point to conver # - 3 is the (e0, e1, e2) coordintes # # we will utilized two other coordinate systems - # - ball-valve pivot: (b0, b1, b2) or [for spherical] (br, btheat, bphi) + # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, b_theta, b_phi) # - mspace (aka LaPD): (x, y, z) # # Coordinate orientations used for the derivation @@ -1095,47 +1090,46 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: npoints = points.shape[0] pivot_to_center = np.abs(self.pivot_to_center) - lx = np.abs(self.pivot_to_xzcross) - lt = np.abs(self.table_pivot_to_zlead_horizontal) - # vt = np.abs(self.table_pivot_to_zlead_vertical) - vs = np.abs(self.table_pivot_to_probe_axis) - ls = lx - lt + L_cross = np.abs(self.pivot_to_xzcross) + L_p2z = np.abs(self.table_pivot_to_zlead_screw) + H_offset = np.abs(self.probe_axis_offset) + L_table_pivot = L_cross - L_p2z # Calculate how much the probe shaft moves (s1) with e1 # - this is the location of the probe shaft directly above the # pivot on the L-bracket table # - # 0 = s1^2 [ls^2 - vs^2] - # + s1 [2 (vs - e1) ls^2] - # + ls^2 e1 (e1 - 2 vs) + # 0 = s1^2 [L_table_pivot^2 - H_offset^2] + # + s1 [2 (H_offset - e1) L_table_pivot^2] + # + L_table_pivot^2 e1 (e1 - 2 H_offset) # - a = ls**2 - vs**2 - b = 2.0 * (vs - points[..., 1]) * ls**2 - c = ls**2 * points[..., 1] * (points[..., 1] - 2.0 * vs) + a = L_table_pivot**2 - H_offset**2 + b = 2.0 * (H_offset - points[..., 1]) * L_table_pivot**2 + c = L_table_pivot**2 * points[..., 1] * (points[..., 1] - 2.0 * H_offset) s1 = (-b + np.sqrt(b**2 - 4 * a * c)) / (2 * a) # Let alpha be the angle made between the probe shaft and the # horizontal # # b_phi = -alpha - # tan( alpha ) = s1 / ls + # tan( alpha ) = s1 / L_table_pivot # - alpha = np.arctan(s1 / ls) + alpha = np.arctan(s1 / L_table_pivot) - # Let lz be the distance from the ball-valve pivot to the z-drive + # Let D_zlead be the distance from the ball-valve pivot to the e2-drive # lead screws as projected along the probe shaft # - # lz = ls / cos(alpha) - vs tan(alpha) + lt + # D_zlead = L_table_pivot / cos(alpha) - H_offset tan(alpha) + L_p2z # - lz = ls / np.cos(alpha) - vs * np.tan(alpha) + lt + D_zlead = L_table_pivot / np.cos(alpha) - H_offset * np.tan(alpha) + L_p2z - # The ball-valve polar angle btheta is given by + # The ball-valve polar angle b_theta is given by # # b_theta = pi / 2 - beta - # tan(beta) = e2 / lz + # tan(beta) = e2 / D_zlead # b_phi = -alpha - b_theta = 0.5 * np.pi - np.arctan(points[..., 2] / lz) + b_theta = 0.5 * np.pi - np.arctan(points[..., 2] / D_zlead) # build the matrix T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa @@ -1167,36 +1161,27 @@ def pivot_to_center(self) -> float: def pivot_to_xzcross(self) -> float: """ Horizontal distance from the center "pivot" point of the ball - valve to the crossing point of the x-drive and z-drive lead - screws, when the x-drive is level with the ground. + valve to the crossing point of the e0-drive and e2-drive lead + screws, when the e0-drive is level with the ground. """ return self.inputs["pivot_to_xzcross"] @property - def table_pivot_to_probe_axis(self) -> float: - """ - Vertical distance from the pivot on the L-bracket table to - the probe shaft, when the x-drive is level with the ground. - """ - return self.inputs["table_pivot_to_probe_axis"] - - @property - def table_pivot_to_zlead_vertical(self) -> float: + def probe_axis_offset(self) -> float: """ Vertical distance from the pivot on the L-bracket table to - the z-drive lead screw, when the x-drive is level with the - ground. + the probe shaft, when the e0-drive is level with the ground. """ - return self.inputs["table_pivot_to_zlead_vertical"] + return self.inputs["probe_axis_offset"] @property - def table_pivot_to_zlead_horizontal(self) -> float: + def table_pivot_to_zlead_screw(self) -> float: """ Horizontal distance from the pivot on the L-bracket table to - the z-drive lead screw, when the x-drive is level with the - ground. + the e2-drive "z-drive" lead screw, when the e0-drive is level + with the ground. """ - return self.inputs["table_pivot_to_zlead_horizontal"] + return self.inputs["table_pivot_to_zlead_screw"] @property def drive_polarity(self) -> np.ndarray: @@ -1210,8 +1195,8 @@ def drive_polarity(self) -> np.ndarray: For example, a value of ``[1, 1, 1]`` would indicate that positivemovement (in probe drive coordinates) of the drive would - be into inwards on the x-drive, upwards on the y-drive, and to - the right on the z-drive (when standing behind the drive). + be into inwards on the e0-drive, upwards on the y-drive, and to + the right on the e2-drive (when standing behind the drive). However, this is inconsistent if the vertical axis has the motor mounted to the top of the axis. In this case the ``drive_polarity`` would be ``[1, -1, 1]``. From fd1febac4aaf8cb0abbb1dac6680d1ff522f3ba9 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 11:39:12 -0700 Subject: [PATCH 006/177] update comments --- bapsf_motion/transform/lapd.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 9107d85a..490438a5 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1068,12 +1068,13 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # given points are in (e0, e1, e2) with shape (N, 3) - # - N is the number of point to conver + # - N is the number of point to convert # - 3 is the (e0, e1, e2) coordintes # - # we will utilized two other coordinate systems - # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, b_theta, b_phi) - # - mspace (aka LaPD): (x, y, z) + # we will utilized three coordinate systems for the conversion + # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, btheat, b_phi) + # - motion space (aka LaPD): (x, y, z) + # - drive space: (e0, e1, e2) # # Coordinate orientations used for the derivation # e1 b1 Y From e8475345d620fbbccb1f84ecfee792b90996b539 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 11:59:10 -0700 Subject: [PATCH 007/177] remove noqa associated with PEP8 N806 --- bapsf_motion/transform/lapd.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 490438a5..56901ca0 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -785,7 +785,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: / self.six_k_arm_length ) - T0 = np.zeros((npoints, 3, 3)).squeeze() # noqa + T0 = np.zeros((npoints, 3, 3)).squeeze() T0[..., 0, 0] = 1 / np.cos(theta) T0[..., 0, 2] = pivot_to_center * ((1 / np.cos(theta)) - 1) T0[..., 1, 2] = ( @@ -795,8 +795,8 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: ) T0[..., 2, 2] = 1.0 - T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) # noqa - T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) # noqa + T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) + T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) return np.matmul( T_dpolarity, @@ -1052,7 +1052,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: b_theta = np.arccos(points[..., 2] / b_rho) # build the matrix - T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa + T0 = np.zeros((npoints, 4, 4)).squeeze() T0[..., 0, 3] = b_rho - pivot_to_center T0[..., 1, 3] = L_table_pivot * np.tan(alpha) + H_offset * (1 - 1 / np.cos(alpha)) T0[..., 2, 3] = D_zlead * np.tan(0.5 * np.pi - b_theta) @@ -1133,7 +1133,7 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: b_theta = 0.5 * np.pi - np.arctan(points[..., 2] / D_zlead) # build the matrix - T0 = np.zeros((npoints, 4, 4)).squeeze() # noqa + T0 = np.zeros((npoints, 4, 4)).squeeze() T0[..., 0, 0] = np.sin(b_theta) * np.cos(b_phi) T0[..., 0, 3] = pivot_to_center * (np.sin(b_theta) * np.cos(b_phi) - 1) T0[..., 1, 0] = np.sin(b_theta) * np.sin(b_phi) @@ -1142,8 +1142,8 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: T0[..., 2, 3] = pivot_to_center * np.cos(b_theta) T0[..., 3, 3] = 1.0 - T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) # noqa - T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) # noqa + T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) + T_mpolarity = np.diag(self.mspace_polarity.tolist() + [1.0]) return np.matmul( T_mpolarity, From 5ffa4bbd9bfedd957f52cf88f5f3e9f9c60b1790 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 12:00:22 -0700 Subject: [PATCH 008/177] clean up comments --- bapsf_motion/transform/lapd.py | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 56901ca0..54e91985 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1026,15 +1026,16 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: H_offset = np.abs(self.probe_axis_offset) L_table_pivot = L_cross - L_p2z - # Let alpha be the angle made between the probe shaft and the - # horizontal + # Let alpha be the angle made between the probe shaft and the horizontal + # + # b_phi = -alpha + # tan(b_phi) = by / bx = y / (pivot_to_center + x) # - # b_phi = -alpha = arctan(by / bx) = arctan(y / (pivot_to_center + x) # alpha = -np.arctan(points[..., 1] / (pivot_to_center + points[..., 0])) # Let D_zlead be the distance from the ball-valve pivot to the e2-drive - # lead screws as projected along the probe shaft + # lead screw as projected along the probe shaft # # D_zlead = L_table_pivot / cos(alpha) - H_offset tan(alpha) + L_p2z # @@ -1042,8 +1043,10 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # The ball-valve polar angle b_theta is expressed as # - # b_theta = pi / 2 - beta = arccos(bz / b_rho) = arccoz(z / b_rho) # b_rho**2 = (pivot_to_center + x)**2 + y**2 +z**2 + # b_theta = pi / 2 - beta + # + # cos(b_theta) = bz / b_rho = z / b_rho # tan(beta) = e2 / D_zlead # b_rho = np.sqrt( @@ -1118,7 +1121,7 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: alpha = np.arctan(s1 / L_table_pivot) # Let D_zlead be the distance from the ball-valve pivot to the e2-drive - # lead screws as projected along the probe shaft + # lead screw as projected along the probe shaft # # D_zlead = L_table_pivot / cos(alpha) - H_offset tan(alpha) + L_p2z # From 32cd942a2acba7ea1fd85cef38e4a586279af668 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 12:31:27 -0700 Subject: [PATCH 009/177] be consistent... use "ball-valve" instead of "ball valve" --- bapsf_motion/transform/lapd.py | 36 +++++++++++++++++----------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 54e91985..051a85de 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -36,16 +36,16 @@ class LaPDXYTransform(base.BaseTransform): pivot_to_center: `float` Distance from the center of the :term:`LaPD` to the center - "pivot" point of the ball valve. A positive value indicates + "pivot" point of the ball-valve. A positive value indicates the probe drive is set up on the East side of the LaPD and a negative value indicates the West side. pivot_to_drive: `float` Distance from the center line of the :term:`probe drive` - vertical axis to the center "pivot" point of the ball valve. + vertical axis to the center "pivot" point of the ball-valve. pivot_to_feedthru: `float` - Distance from the center "pivot" point of the ball valve to the + Distance from the center "pivot" point of the ball-valve to the nearest face of the probe drive feed-through. probe_axis_offset: `float` @@ -251,7 +251,7 @@ def __call__(self, points, to_coords="drive") -> np.ndarray: # scenario before doing matrix multiplication points = self._condition_points(points) - # 1. convert to ball valve coords + # 1. convert to ball-valve coords points[..., 0] = np.absolute(_sign * pivot_to_center - points[..., 0]) # 2. droop correct to non-droop coords @@ -268,7 +268,7 @@ def __call__(self, points, to_coords="drive") -> np.ndarray: # - tr_points is in LaPD motion space coordinates # - need to convert motion space coordinates to droop scenario - # 1. convert to ball valve coords + # 1. convert to ball-valve coords tr_points[..., 0] = np.absolute(_sign * pivot_to_center - tr_points[..., 0]) # 2. droop correct to droop coords @@ -424,7 +424,7 @@ def _matrix_to_motion_space(self, points: np.ndarray): def pivot_to_center(self) -> float: """ Distance from the center of the :term:`LaPD` to the center - "pivot" point of the ball valve. + "pivot" point of the ball-valve. """ return self.inputs["pivot_to_center"] @@ -432,7 +432,7 @@ def pivot_to_center(self) -> float: def pivot_to_drive(self) -> float: """ Distance from the center line of the :term:`probe drive` - vertical axis to the center "pivot" point of the ball valve. + vertical axis to the center "pivot" point of the ball-valve. """ return self.inputs["pivot_to_drive"] @@ -513,17 +513,17 @@ class LaPD6KTransform(LaPDXYTransform): pivot_to_center: `float` Distance from the center of the :term:`LaPD` to the center - "pivot" point of the ball valve. A positive value indicates + "pivot" point of the ball-valve. A positive value indicates the probe drive is set up on the East side of the LaPD and a negative value indicates the West side. (DEFAULT: ``58.771`` cm) pivot_to_drive: `float` Distance from the center line of the :term:`probe drive` - vertical axis to the center "pivot" point of the ball valve. + vertical axis to the center "pivot" point of the ball-valve. (DEFAULT: ``116.84`` cm) pivot_to_feedthru: `float` - Distance from the center "pivot" point of the ball valve to the + Distance from the center "pivot" point of the ball-valve to the nearest face of the probe drive feed-through. (DEFAULT: ``53.76926`` cm) @@ -741,7 +741,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: ) _inputs[key] = val - # calculate distance between ball valve center (pivot) to the + # calculate distance between ball-valve center (pivot) to the # pivot (pinion) point on the probe drive arm self._pivot_to_drive_pinion = np.sqrt( _inputs["pivot_to_drive"] ** 2 + _inputs["probe_axis_offset"] ** 2 @@ -750,7 +750,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: # calculate beta - the angular drop from the probe shaft to the # probe drive pinion # - # ________ pivot_to_drive ________x (ball valve pivot) + # ________ pivot_to_drive ________x (ball-valve pivot) # | _________/ # probe_axis_offset __________/ # |__________/ ^-- pivot_to_drive_pinion @@ -771,7 +771,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: pivot_to_center = np.abs(self.pivot_to_center) # calculate theta ... the angle made by the probe shaft on the - # drive side of the ball valve + # drive side of the ball-valve tan_theta = points[..., 1] / (points[..., 0] + pivot_to_center) theta = -np.arctan(tan_theta) @@ -814,14 +814,14 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: pivot_to_center = np.abs(self.pivot_to_center) - # calculate the distance between the ball valve pivot point (pivot) to the + # calculate the distance between the ball-valve pivot point (pivot) to the # pivot point on the probe drive vertical axis (vpinion) pivot_to_vpinion = np.sqrt( self.pivot_to_drive**2 + (self.six_k_arm_length - self.probe_axis_offset + points[..., 1]) ** 2 ).squeeze() - # calculate the angle (gamma) the line intersecting the ball valve + # calculate the angle (gamma) the line intersecting the ball-valve # pivot (pivot) and probe drive vertical pinion (vpinion) makes # with the horizontal plane gamma = np.arctan( @@ -830,7 +830,7 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: ).squeeze() # imagine two circles: - # 1. circle one located at the ball valve pivot (pivot) with a + # 1. circle one located at the ball-valve pivot (pivot) with a # radius pivot_to_drive_pinion # 2. circle two located at the vpinion with a readius six_k_arm_length # @@ -889,7 +889,7 @@ def pivot_to_drive_pinion(self) -> float: @property def beta(self) -> float: # angle swept from the probe shaft to the probe drive pinion with - # respect to the ball valve pivot + # respect to the ball-valve pivot return self._beta @@ -1157,7 +1157,7 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: def pivot_to_center(self) -> float: """ Distance from the center of the :term:`LaPD` to the center - "pivot" point of the ball valve. + "pivot" point of the ball-valve. """ return self.inputs["pivot_to_center"] From 8688ac1023d82ab55bbb99711fdcec046dd1eb00 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 12:32:18 -0700 Subject: [PATCH 010/177] update annotations for drive_polarity and mspace_polarity --- bapsf_motion/transform/lapd.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 051a85de..7c65ad3b 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -907,8 +907,8 @@ def __init__( # pivot_to_feedthru: float, probe_axis_offset: float, table_pivot_to_zlead_screw: float, - drive_polarity: Tuple[int, int] = (1, 1, 1), - mspace_polarity: Tuple[int, int] = (-1, 1, 1), + drive_polarity: Tuple[int, int, int] = (1, 1, 1), + mspace_polarity: Tuple[int, int, int] = (-1, 1, 1), # droop_correct: bool = False, # droop_scale: Union[int, float] = 1.0, ): From 525d1be846951e3f740998b9b5ca89d97143df1d Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 13:37:50 -0700 Subject: [PATCH 011/177] fix __transformer__ so it does not contain LaPD6KTransform twice --- bapsf_motion/transform/lapd.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 7c65ad3b..893ff0e7 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -3,7 +3,7 @@ from __future__ import annotations __all__ = ["LaPDXYTransform", "LaPD6KTransform", "LaPDXYZTransform"] -__transformer__ = ["LaPDXYTransform", "LaPD6KTransform", "LaPD6KTransform"] +__transformer__ = ["LaPDXYTransform", "LaPD6KTransform", "LaPDXYZTransform"] import numpy as np From 10f6587086d50e02d14e99bf3d977ae642e13ed4 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 13:38:24 -0700 Subject: [PATCH 012/177] add default values to LaPDXYZTransform arguments --- bapsf_motion/transform/lapd.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 893ff0e7..e7098836 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -902,13 +902,13 @@ def __init__( self, drive: Drive, *, - pivot_to_center: float, - pivot_to_xzcross: float, + pivot_to_center: float = 58.771, + pivot_to_xzcross: float = 135.0, # pivot_to_feedthru: float, - probe_axis_offset: float, - table_pivot_to_zlead_screw: float, + probe_axis_offset: float = 24.7, + table_pivot_to_zlead_screw: float = 20.0, drive_polarity: Tuple[int, int, int] = (1, 1, 1), - mspace_polarity: Tuple[int, int, int] = (-1, 1, 1), + mspace_polarity: Tuple[int, int, int] = (1, 1, 1), # droop_correct: bool = False, # droop_scale: Union[int, float] = 1.0, ): From 7335192c116cd29353ec1217d3c93a5b80ccdeb9 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 13:38:39 -0700 Subject: [PATCH 013/177] audit all LaPDXYZTransform docstrings --- bapsf_motion/transform/lapd.py | 269 ++++++++++++++++++++++++++++----- 1 file changed, 235 insertions(+), 34 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index e7098836..272fe20a 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -895,6 +895,211 @@ def beta(self) -> float: @register_transform class LaPDXYZTransform(base.BaseTransform): + """ + Class that defines a coordinate transform for a :term:`LaPD` + "XYZ" :term:`probe drive`. + + **transform type:** ``'lapd_xyz'`` + + Parameters + ---------- + drive: |Drive| + The instance of |Drive| the coordinate transformer will be + working with. + + pivot_to_center: `float`, optional + (DEFAULT: ``58.771`` cm) Distance from the center of the + :term:`LaPD` to the center "pivot" point of the ball-valve. A + positive value indicates the probe drive is set up on the East + side of the LaPD and a negative value indicates the West side. + + pivot_to_xzcross: `float`, optional + (DEFAULT: ``58.771`` cm) Horizontal distance from the center + "pivot" point of the ball-valve to the crossing point of the + e0-drive ("x-drive") and the e2-drive ("z-drive") when the probe + drive is in its neutral postion. Neutral position is when the + e0-drive is parallel to the ground and perpendicular to the + LaPD. + + probe_axis_offset: `float`, optional + (DEFAULT: ``24.7`` cm) Vertical distance from the center of the + L-Bracket Table pivot to the centerline of the probe shaft, when + the :term:`probe drive` is in its neutral position. Neutral + position is when the e0-drive is parallel to the ground and + perpendicular to the LaPD. + + table_pivot_to_zlead_screw: `float`, optional + (DEFAULT: ``20.0`` cm) Horizontal distrance from the center of + the L-Bracket Table pivot to the centerline of the e2-drive + ("z-drive") lead scrws, when the :term:`probe drive` is in its + neutral position. Neutral position is when the e0-drive is + parallel to the ground and perpendicular to the LaPD. + + drive_polarity: Tuple[int, int, int], optional + A three element tuple of +/- 1 values indicating the polarity of + the actual probe drive coordinate system to the probe drive + coordinate system defined for the underlying matrix + transformations. For additional details refer to the Notes + section of the docstring. + + mspace_polarity: Tuple[int, int, int], optional + A three element tuple of +/- 1 values indicating the polarity of + the actual motion space coordinate system to the motion space + coordinate system defined for the underlying matrix + transformations. For additional details refer to the Notes + section of the docstring. + + Notes + ----- + + - Coordinate systems: + + The matrix transformation utilizes three different coordinate + systems: the drive space ``(e0, e1, e2)``, the ball-valve + coordiantes ``(b0, b1, b2)``, and the motion space coordinate + system ``(x, y, z)``. These systems may have different polarity + with respect to the actual systems used. To composate for these + polarities use the ``drive_polarity`` and ``mspace_polarity`` + arguments. + + The derivation coordinate systems look like: + + .. code-block:: bash + + Drive Space Ball-Valve Motion Space + + e1 b1 Y + ^ ^ ^ + | ... | ... | + o---> e0 o---> b0 o---> X + e2 b2 Z + + As can be seen, the derivation coordinate system have different + polarities with respect the the LaPD XYZ drive and the LaPD + motion space. For an East side deployed XYZ dive the + ``drive_polarity`` and ``mspace_polarity`` arguments would be + ``(1, -1, 1)`` and ``(-1, 1, -1)``, respectively. + + - Neutral Probe Drive Setup: + + A neutral probe drive setup / position is when the e0-drive is + parallel to the ground and perpendicular to the LaPD. + + Examples + -------- + + Let's set up a :term:`transformer` for a probe drive mounted on + an East port of the LaPD. In this case the motor for the vertical + axis is mounted at the base of the probe drive vertical axis. + (Values are NOT accurate to actual LaPD values.) + + .. tabs:: + .. code-tab:: py Class Instantiation + + tr = LaPDXYZTransform( + drive, + pivot_to_center = 58.771, + pivot_to_xzcross = 135.0, + probe_axis_offset = 24.7, + table_pivot_to_zlead_screw = 20.0, + mspace_polarity = (-1, 1, -1), + ) + + .. code-tab:: py Factory Function + + tr = transform_factory( + drive, + tr_type = "lapd_xyz", + **{ + "pivot_to_center": 58.771, + "pivot_to_xzcross": 135.0, + "probe_axis_offset": 24.7, + "table_pivot_to_zlead_screw": 20.0, + "mspace_polarity": (-1, 1, -1), + }, + ) + + .. code-tab:: toml TOML + + [...transform] + type = "lapd_xyz" + pivot_to_center = 58.771 + pivot_to_xzcross = 135.0 + probe_axis_offset = 24.7 + table_pivot_to_zlead_screw = 20.0 + mspace_polarity = [-1, 1, -1] + + .. code-tab:: py Dict Entry + + config["transform"] = { + "type": "lapd_xyz", + "pivot_to_center": 58.771, + "pivot_to_xzcross": 135.0, + "probe_axis_offset": 24.7, + "table_pivot_to_zlead_screw": 20.0, + "mspace_polarity": (-1, 1, -1), + } + + Now, let's do the same thing for a probe drive mounted on a West + port and has the vertical axis motor mounted at the top. + + .. tabs:: + .. code-tab:: py Class Instantiation + + tr = LaPDXYZTransform( + drive, + pivot_to_center = -62.94, + pivot_to_xzcross = 135.0, + probe_axis_offset = 24.7, + table_pivot_to_zlead_screw = 20.0, + drive_polarity = (1, -1, 1), + mspace_polarity = (1, 1, 1), + ) + + .. code-tab:: py Factory Function + + tr = transform_factory( + drive, + tr_type = "lapd_xyz", + **{ + "pivot_to_center": -62.94, + "pivot_to_xzcross": 135.0, + "probe_axis_offset": 24.7, + "table_pivot_to_zlead_screw": 20.0, + "drive_polarity": (1, -1, 1), + "mspace_polarity": (1, 1, 1), + }, + ) + + .. code-tab:: toml TOML + + [...transform] + type = "lapd_xyz" + pivot_to_center = -62.94 + pivot_to_xzcross = 135.0 + probe_axis_offset = 24.7 + table_pivot_to_zlead_screw = 20.0 + drive_polarity = [1, -1, 1] + mspace_polarity = [1, 1, 1] + + .. code-tab:: py Dict Entry + + config["transform"] = { + "type": "lapd_xyz", + "pivot_to_center": -62.94, + "pivot_to_xzcross": 135.0, + "probe_axis_offset": 24.7, + "table_pivot_to_zlead_screw": 20.0, + "drive_polarity": (1, -1, 1), + "mspace_polarity": (1, 1, 1), + } + + .. note:: + For further details reference the jupyter notebook for + :ref:`LaPD6KYTransform `. + + """ + _transform_type = "lapd_xyz" _dimensionality = 3 @@ -1164,66 +1369,62 @@ def pivot_to_center(self) -> float: @property def pivot_to_xzcross(self) -> float: """ - Horizontal distance from the center "pivot" point of the ball - valve to the crossing point of the e0-drive and e2-drive lead - screws, when the e0-drive is level with the ground. + Horizontal distance from the center + "pivot" point of the ball-valve to the crossing point of the + e0-drive ("x-drive") and the e2-drive ("z-drive") when the probe + drive is in its neutral postion. + + Neutral position is when the e0-drive is parallel to the ground + and perpendicular to the LaPD. """ return self.inputs["pivot_to_xzcross"] @property def probe_axis_offset(self) -> float: """ - Vertical distance from the pivot on the L-bracket table to - the probe shaft, when the e0-drive is level with the ground. + Vertical distance from the center of the L-Bracket Table pivot + to the centerline of the probe shaft, when the + :term:`probe drive` is in its neutral position. + + Neutral position is when the e0-drive is parallel to the ground + and perpendicular to the LaPD. """ return self.inputs["probe_axis_offset"] @property def table_pivot_to_zlead_screw(self) -> float: """ - Horizontal distance from the pivot on the L-bracket table to - the e2-drive "z-drive" lead screw, when the e0-drive is level - with the ground. + Horizontal distrance from the center of the L-Bracket Table + pivot to the centerline of the e2-drive ("z-drive") lead scrws, + when the :term:`probe drive` is in its neutral position. + + Neutral position is when the e0-drive is parallel to the ground + and perpendicular to the LaPD. """ return self.inputs["table_pivot_to_zlead_screw"] @property def drive_polarity(self) -> np.ndarray: """ - A three element array of +/- 1 values indicating the polarity of - the probe drive motion to how the math was done for the - underlying matrix transformations. - """ - # TODO: FIX WORDING OF EXAMPLE AND INTEGRATE BACK INTO THE DOCSTRING - """ + A three element tuple of +/- 1 values indicating the polarity of + the actual probe drive coordinate system to the probe drive + coordinate system defined for the underlying matrix + transformations. - For example, a value of ``[1, 1, 1]`` would indicate that - positivemovement (in probe drive coordinates) of the drive would - be into inwards on the e0-drive, upwards on the y-drive, and to - the right on the e2-drive (when standing behind the drive). - However, this is inconsistent if the vertical axis has the motor - mounted to the top of the axis. In this case the - ``drive_polarity`` would be ``[1, -1, 1]``. + For additional details refer to the Notes section of the docstring. """ return self.inputs["drive_polarity"] @property def mspace_polarity(self) -> np.ndarray: """ - A three element array of +/- 1 values indicating the polarity of - the motion space motion to how the math was done for the - underlying matrix transformations. - """ - # TODO: FIX WORDING OF EXAMPLE AND INTEGRATE BACK INTO THE DOCSTRING - """ + A three element tuple of +/- 1 values indicating the polarity of + the actual motion space coordinate system to the motion space + coordinate system defined for the underlying matrix + transformations. - For example, a value of ``(-1, 1, 1)`` for a probe mounted on an - East port would indicate that inward probe drive movement would - correspond to a LaPD -X movement and downward probe drive - movement would correspond to LaPD +Y. If the probe was mounted - on a West port then the polarity would need to be ``(1, 1)`` - since inward probe drive movement corresponds to +X LaPD - coordinate movement. + For additional details refer to the Notes section of the + docstring. """ return self.inputs["mspace_polarity"] From 56cb344c7f14eb5d46aae4b45d8a777848cb8cc3 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 20:17:49 -0700 Subject: [PATCH 014/177] fix typos --- bapsf_motion/transform/lapd.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 272fe20a..9d232487 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -685,7 +685,7 @@ class LaPD6KTransform(LaPDXYTransform): .. note:: For further details reference the jupyter notebook for - :ref:`LaPD6KYTransform `. + :ref:`LaPD6KTransform `. """ @@ -1096,7 +1096,7 @@ class LaPDXYZTransform(base.BaseTransform): .. note:: For further details reference the jupyter notebook for - :ref:`LaPD6KYTransform `. + :ref:`LaPDXYZTransform `. """ From 27869abfeafc4758a495003083629ffb6685995c Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 20:18:12 -0700 Subject: [PATCH 015/177] add ipykernel to the doc dependencies --- requirements/docs.txt | 1 + setup.cfg | 1 + 2 files changed, 2 insertions(+) diff --git a/requirements/docs.txt b/requirements/docs.txt index d85a4e16..0e29df74 100644 --- a/requirements/docs.txt +++ b/requirements/docs.txt @@ -2,6 +2,7 @@ # ought to mirror 'docs' under options.extras_require in setup.cfg -r gui.txt docutils >= 0.18.1 +ipykernel ipython jinja2 >= 3.1.2 nbsphinx >= 0.9.1 diff --git a/setup.cfg b/setup.cfg index cda58e77..ddc6b2b2 100644 --- a/setup.cfg +++ b/setup.cfg @@ -79,6 +79,7 @@ docs = # ought to mirror requirements/docs.txt %(gui)s docutils >= 0.18.1 + ipykernel ipython jinja2 >= 3.1.2 nbsphinx >= 0.9.1 From b58faf714c8613fd22ab1e87bae298bc57815971 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 20:18:49 -0700 Subject: [PATCH 016/177] nbsphinx_prolog explicitly convert to string --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 037dd214..6d6b4a7a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -494,7 +494,7 @@ # This is processed by Jinja2 and inserted before each notebook nbsphinx_prolog = r""" -{% set docname = 'docs/' + env.doc2path(env.docname, base=None) %} +{% set docname = 'docs/' + env.doc2path(env.docname, base=None)|string %} {% set nb_base = 'tree' if env.config.revision else 'blob' %} {% set nb_where = env.config.revision if env.config.revision else 'main' %} From 872b52ab127d697ca20039436eec9fc64bb2ef71 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 14 May 2026 20:19:01 -0700 Subject: [PATCH 017/177] nada commit --- docs/notebooks/motion_list/CircularExclusion.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/notebooks/motion_list/CircularExclusion.ipynb b/docs/notebooks/motion_list/CircularExclusion.ipynb index e3a6edf4..0d2ecdda 100644 --- a/docs/notebooks/motion_list/CircularExclusion.ipynb +++ b/docs/notebooks/motion_list/CircularExclusion.ipynb @@ -248,7 +248,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.13.13" } }, "nbformat": 4, From 5099930b15028c08a547d3a96c19433b6abba546 Mon Sep 17 00:00:00 2001 From: erik Date: Sun, 17 May 2026 09:58:24 -0700 Subject: [PATCH 018/177] fix beta to b_that relation --- bapsf_motion/transform/lapd.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 9d232487..a7d8affc 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1249,7 +1249,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # The ball-valve polar angle b_theta is expressed as # # b_rho**2 = (pivot_to_center + x)**2 + y**2 +z**2 - # b_theta = pi / 2 - beta + # b_theta = pi / 2 + beta # # cos(b_theta) = bz / b_rho = z / b_rho # tan(beta) = e2 / D_zlead @@ -1263,7 +1263,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: T0 = np.zeros((npoints, 4, 4)).squeeze() T0[..., 0, 3] = b_rho - pivot_to_center T0[..., 1, 3] = L_table_pivot * np.tan(alpha) + H_offset * (1 - 1 / np.cos(alpha)) - T0[..., 2, 3] = D_zlead * np.tan(0.5 * np.pi - b_theta) + T0[..., 2, 3] = D_zlead * np.tan(b_theta - 0.5 * np.pi) T0[..., 3, 3] = 1.0 T_dpolarity = np.diag(self.drive_polarity.tolist() + [1.0]) @@ -1334,11 +1334,11 @@ def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # The ball-valve polar angle b_theta is given by # - # b_theta = pi / 2 - beta + # b_theta = pi / 2 + beta # tan(beta) = e2 / D_zlead # b_phi = -alpha - b_theta = 0.5 * np.pi - np.arctan(points[..., 2] / D_zlead) + b_theta = 0.5 * np.pi + np.arctan(points[..., 2] / D_zlead) # build the matrix T0 = np.zeros((npoints, 4, 4)).squeeze() From 723fa07898977508fadea6549fd669b6ef73b19e Mon Sep 17 00:00:00 2001 From: erik Date: Sun, 17 May 2026 10:21:37 -0700 Subject: [PATCH 019/177] rough out example notebook --- .../transform/LaPDXYZTransform_.ipynb | 987 ++++++++++++++++++ 1 file changed, 987 insertions(+) create mode 100644 docs/notebooks/transform/LaPDXYZTransform_.ipynb diff --git a/docs/notebooks/transform/LaPDXYZTransform_.ipynb b/docs/notebooks/transform/LaPDXYZTransform_.ipynb new file mode 100644 index 00000000..3c0dd7b6 --- /dev/null +++ b/docs/notebooks/transform/LaPDXYZTransform_.ipynb @@ -0,0 +1,987 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fefb950-9158-4c62-b593-cda353ff5db1", + "metadata": {}, + "source": [ + "# Demo of `LaPDXYZTransform`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " from bapsf_motion.transform import LaPDXYZTransform\n", + "except ModuleNotFoundError:\n", + " from pathlib import Path\n", + "\n", + " HERE = Path().cwd()\n", + " BAPSF_MOTION = (HERE / \"..\" / \"..\" / \"..\" ).resolve()\n", + " sys.path.append(str(BAPSF_MOTION))\n", + " \n", + " from bapsf_motion.transform import LaPDXYZTransform" + ] + }, + { + "cell_type": "markdown", + "id": "f79461eb-d3a0-48bc-9a1e-13c6e5fee6db", + "metadata": {}, + "source": [ + "General input keyword arguments to use for the demo." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "15dd3644-c856-46c2-9f6f-846956b435d4", + "metadata": {}, + "outputs": [], + "source": [ + "input_kwargs = {\n", + " \"pivot_to_center\": 58.771,\n", + " \"pivot_to_xzcross\": 142.4804, # 0.81\" + 54.9cm + 0.75\" + 79.3cm + 1.7\"\n", + " # \"pivot_to_xzcross\": 58.771,\n", + " \"probe_axis_offset\": 30.47, # 0.5\" + 15.1cm + 5.4cm + 8.7cm\n", + " \"table_pivot_to_zlead_screw\": 12.488, # 0.5\" + 2.5cm + 4.4cm + 1.7\"\n", + " \"drive_polarity\": [1, -1, 1],\n", + " \"mspace_polarity\": [-1, 1, -1],\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "af05b4fc-afe4-4a5e-81a5-d11d95f022a4", + "metadata": {}, + "source": [ + "## Transfrom from Motion Space to Drive Space to Motion Space\n", + "\n", + "Let's show the transform can successfully convert from the motion space to the drive space, and back.\n", + "\n", + "Instantiate the transform class." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "768e0851-57e5-4b44-9f0f-541741376aeb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mspace_polarity': [-1, 1, -1],\n", + " 'pivot_to_center': 58.771,\n", + " 'table_pivot_to_zlead_screw': 12.488,\n", + " 'type': 'lapd_xyz',\n", + " 'drive_polarity': [1, -1, 1],\n", + " 'pivot_to_xzcross': 142.4804,\n", + " 'probe_axis_offset': 30.47}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tr = LaPDXYZTransform((\"x\", \"y\", \"z\"), **input_kwargs)\n", + "tr.config" + ] + }, + { + "cell_type": "markdown", + "id": "f540f0d3-4ce5-4f63-885e-1ca1584142a9", + "metadata": {}, + "source": [ + "Construct a set of points in the motion space to convert." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "ea80e434-af3a-42fe-b590-b4744f382ec5", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((3*40, 3))\n", + "npoints_in_plane = 40\n", + "delta = 10\n", + "\n", + "# xy-plane\n", + "points[0:10, 0] = np.linspace(-delta, delta, num=10, endpoint=False)\n", + "points[0:10, 1] = delta * np.ones(10)\n", + "points[10:20, 0] = delta * np.ones(10)\n", + "points[10:20, 1] = np.linspace(delta, -delta, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(delta, -delta, num=10, endpoint=False)\n", + "points[20:30, 1] = -delta * np.ones(10)\n", + "points[30:40, 0] = -delta * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-delta, delta, num=10, endpoint=False)\n", + "\n", + "# xz-plane\n", + "points[40:80, 0] = points[0:40, 0]\n", + "points[40:80, 2] = points[0:40, 1]\n", + "\n", + "# yz-plane\n", + "points[80:, 1] = points[0:40, 0]\n", + "points[80:, 2] = points[0:40, 1]\n", + "\n", + "key_points = np.array(\n", + " [\n", + " # xy-corners\n", + " [-delta, delta, 0],\n", + " [-delta, -delta, 0],\n", + " [delta, -delta, 0],\n", + " [delta, delta, 0],\n", + " # xz-corners\n", + " [-delta, 0, delta],\n", + " [-delta, 0, -delta],\n", + " [delta, 0, -delta],\n", + " [delta, 0, delta],\n", + " # yz-corners\n", + " [0, -delta, delta],\n", + " [0, -delta, -delta],\n", + " [0, delta, -delta],\n", + " [0, delta, delta],\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "de26ee8e-3926-4f2a-910f-a800b7cdb152", + "metadata": {}, + "source": [ + "Calcualte the drive space points `dpoints` and return to motion space points `mpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "6d03325f-6e57-445c-9717-19fb98ea29d6", + "metadata": {}, + "outputs": [], + "source": [ + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "4eaa3771-3571-4683-aae8-bd8d2f80b96e", + "metadata": {}, + "source": [ + "Plot the transform" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "a0c8f222-15a8-45f5-b20e-ec475ba3d854", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = 3*figheight\n", + "fig, axs = plt.subplots(3, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0, 0].set_title(\"Motion Space\")\n", + "axs[0, 1].set_title(\"Drive Space\")\n", + "axs[0, 2].set_title(\"Drive Space\")\n", + "\n", + "dkp = tr(key_points, to_coords=\"drive\")\n", + " \n", + "for ii in range(3):\n", + " if ii == 0: # xy-plane\n", + " p0 = 0\n", + " p1 = [1, 1, 2]\n", + " \n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Z\")\n", + " elif ii == 1: # xz-plane\n", + " p0 = 0\n", + " p1 = [2, 2, 1]\n", + "\n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", + "\n", + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Y\")\n", + " else: # yz-plane\n", + " p0 = 1\n", + " p1 = [2, 2, 0]\n", + " \n", + " axs[ii, 0].set_xlabel(\"Y\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", + "\n", + " axs[ii, 1].set_xlabel(\"Y\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"Y\")\n", + " axs[ii, 2].set_ylabel(\"X\")\n", + " \n", + " i_start = ii * npoints_in_plane\n", + " i_stop = i_start + npoints_in_plane\n", + " axs[ii, 0].fill(points[i_start:i_stop, p0], points[i_start:i_stop, p1[0]])\n", + " axs[ii, 1].fill(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[1]])\n", + " axs[ii, 2].plot(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[2]], \"-o\")\n", + "\n", + " \n", + " i_start = ii * 4\n", + " i_stop = i_start + 4\n", + " colors = [\"red\", \"orange\", \"black\", \"purple\"]\n", + "\n", + " axs[ii, 0].scatter(key_points[i_start:i_stop, p0], key_points[i_start:i_stop, p1[0]], c=colors)\n", + " axs[ii, 1].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[1]], c=colors)\n", + " axs[ii, 2].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[2]], c=colors, zorder=10)" + ] + }, + { + "cell_type": "markdown", + "id": "ea80f579-75af-47dc-a664-0c23b35d9ee0", + "metadata": {}, + "source": [ + "Plot the difference in the round trip conversion." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "6e52c2b4-5970-49dd-a21a-e8b84b3fb0e8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(points[..., 0] - mpoints[..., 0], \"-o\", label=\"X\")\n", + "plt.plot(points[..., 1] - mpoints[..., 1], \"-o\", label=\"Y\")\n", + "plt.plot(points[..., 2] - mpoints[..., 2], \"-o\", label=\"Z\")\n", + "\n", + "ax = plt.gca()\n", + "ax.set_xlabel(\"Index\")\n", + "ax.set_ylabel(\"Diff\")\n", + "ax.set_title(\"Difference in Motion --> Drive --> Motion Conversion\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "d95b6680-c8df-4be5-8b8e-a8915f553ad8", + "metadata": {}, + "source": [ + "Are the returned motion space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76f1c97e-a944-4d8b-91a6-9cc328671b5f", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4449700-7100-4c29-946c-4d22cea7ee0f", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "bd3dd84b-5a9a-48c1-b304-c62f84976b7a", + "metadata": {}, + "source": [ + "## Transform from Drive Sapce to Motion Space to Drive Space\n", + "\n", + "Let's show the transform can successfully convert from the drive space to the motion space, and back.\n", + "\n", + "Using the same transform and initial points in the previous section, lets construct the motion space points `mpoints` and return to drive space points `dpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e87c5d28-ec61-4a90-97cd-89db765fbd2c", + "metadata": {}, + "outputs": [], + "source": [ + "mpoints = tr(points, to_coords=\"motion_space\")\n", + "dpoints = tr(mpoints, to_coords=\"drive\")" + ] + }, + { + "cell_type": "markdown", + "id": "3529a742-cc81-44b9-ac1d-e3cf9e3cbc9a", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e61105e-3788-4edb-a54c-9a582f04f745", + "metadata": {}, + "outputs": [], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Drive Space\")\n", + "axs[1].set_title(\"Motion Space\")\n", + "axs[2].set_title(\"Drive Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(mpoints[...,0], mpoints[...,1])\n", + "axs[2].fill(dpoints[...,0], dpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " mpt = tr(pt, to_coords=\"motion_space\")\n", + " dpt = tr(mpt, to_coords=\"drive\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", + " axs[2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "4b0115f5-6e20-41d8-ae82-72452a1a831d", + "metadata": {}, + "source": [ + "Are the returned drive space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, dpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - dpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "a6ac8c55-eca5-44f7-9579-e7b61bdab6f0", + "metadata": {}, + "source": [ + "## Transform Can Droop Correct\n", + "\n", + "The transform `LaPD6KTransfrom` also incorporates droop correction via the `LaPDXYDroopCorrect` class.\n", + "\n", + "Instantiate the transfrom with droop correction enabled." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e2e4537-cb72-4d9a-b457-6f3160771261", + "metadata": {}, + "outputs": [], + "source": [ + "tr = LaPD6KTransform(\n", + " (\"x\", \"y\"),\n", + " **{\n", + " **input_kwargs,\n", + " \"droop_correct\": True,\n", + " \"droop_scale\": 2.0,\n", + " },\n", + ")\n", + "tr.config" + ] + }, + { + "cell_type": "markdown", + "id": "ac8d5ed5-c6e1-4632-9806-63d51d57fc63", + "metadata": {}, + "source": [ + "Construct a set of points for the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a4a8740-5b79-45cc-b67f-311d72caeb66", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "key_points = np.array(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3dc12ae7-0ef0-4eba-a652-e4980d76a61a", + "metadata": {}, + "source": [ + "Calcualte the drive space points `dpoints` and return to motion space points`mpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b9dc74c-298b-46db-b06b-8fe81d29b936", + "metadata": {}, + "outputs": [], + "source": [ + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "25f03021-a4f1-493c-b5f9-39b675857c49", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aafc667-d47e-4a3f-8f18-646b599bfc53", + "metadata": {}, + "outputs": [], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Motion Space\")\n", + "axs[1].set_title(\"Drive Space\")\n", + "axs[2].set_title(\"Motion Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", + "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " dpt = tr(pt, to_coords=\"drive\")\n", + " mpt = tr(dpt, to_coords=\"motion_space\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "c7293afa-e931-499d-84ad-f7f3f7c696e4", + "metadata": {}, + "source": [ + "Are the returned motion space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8dac0d50-a14d-4319-8630-fa9c1a750f09", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4995cb9b-7c5e-4660-95c1-e1fbe2b73283", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "8d84d8dd-8ec5-4c64-9696-3162096150f8", + "metadata": {}, + "source": [ + "## Configure for West Side Deployment\n", + "\n", + "The default values for `LaPD6KTransform` is for an East side depolyment on the LaPD. However, the transfrom can be configured for a West side deployment by using a negative `pivot_to_center` and `[1, 1]` for the `mspace_polarity`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", + "metadata": {}, + "outputs": [], + "source": [ + "tr = LaPD6KTransform(\n", + " (\"x\", \"y\"),\n", + " **{\n", + " **input_kwargs,\n", + " \"pivot_to_center\": -58.771,\n", + " \"mspace_polarity\": [1, 1],\n", + " \"droop_correct\": True,\n", + " \"droop_scale\": 2.0,\n", + " },\n", + ")\n", + "tr.config" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5853946-24e3-4286-aae6-aa48a59af280", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "key_points = np.array(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + ")\n", + "\n", + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "e0059a4f-f084-4d16-921c-6d2dd79fa3e5", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "024c67c5-b442-40ee-8cd4-3c57a9c9e21a", + "metadata": {}, + "outputs": [], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Motion Space\")\n", + "axs[1].set_title(\"Drive Space\")\n", + "axs[2].set_title(\"Motion Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", + "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " dpt = tr(pt, to_coords=\"drive\")\n", + " mpt = tr(dpt, to_coords=\"motion_space\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "4613643d-b83f-4f80-9c58-3053d48b43ad", + "metadata": {}, + "source": [ + "Are the returned motion space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62a2a57c-f919-4ae1-8fc3-1923c54d8c49", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "627126b3-419e-4a1b-8c28-7a45499709c8", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "8165d9e8-797e-4f76-885b-fabd164081c4", + "metadata": { + "tags": [] + }, + "source": [ + "## The Algorithms\n", + "\n", + "To start we will use $(e_0, e_1)$ to represent the drive space coordinates and $(x, y)$ to represent the motion space coordinates.\n", + "\n", + "
\n", + "\"top_level_cartoon\"\n", + "
Top-Level Cartoon of the Drive and Motion Space Relationship
\n", + "
\n", + "\n", + "**Note:** The motion space x-axis points towards the the LaPD -X when the probe drive is deployed on the East side of the machine. This is why the East side operation requires `mspace_polarity = [-1, 1]`, and the West side requires `mspace_polarity = [1, 1]`." + ] + }, + { + "cell_type": "markdown", + "id": "8c724e04-242d-4b3a-be03-f8c4dee2fffa", + "metadata": { + "tags": [] + }, + "source": [ + "### Algorithm: Drive to Motion Space\n", + "\n", + "The key parameter we need to determine to convert the drive space coordinates to the motion space coordinates is the angle $\\theta$, which is the angle the probe shaft makes with the horizontal. Let's consider the following diagram...\n", + "\n", + "
\n", + "\"drive_overview\"\n",\n", + "
Drive Space Overview
\n", + "
\n", + "\n", + "Here...\n", + "\n", + "- $d_o$ = `probe_axis_offset` which is the perpendicular distance from the probe axis to the pinion location on the horizontal arm of the 6K probe drive.\n", + "- $R_A$ = `six_k_arm_length` which is the length of the vertical hanging arm of the 6K probe drive.\n", + "- $\\beta$ is the angular drop of the pinion location from the probe drive shaft with respect to the ball valve\n", + "\n", + " $$\n", + " tan\\,\\beta = \\frac{d_o}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}=\\frac{\\texttt{probe}\\_\\texttt{axis}\\_\\texttt{offset}}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", + " $$\n", + "\n", + "- $R_P$ = `pivot_to_drive_pinion` the radial distance of the probe drive pinion from the ball valve pivot\n", + " \n", + " $$\n", + " R_P^2 = d_o^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", + " $$\n", + " \n", + "- The vertical pinoin location above the horizontal is given by $R_A - d_o + e_1$, assuming $e_1=0$ when the probe shaft is horizontal.\n", + "- $\\gamma$ is the angle the vertical pinion makes with respect to the ball valve pivot and the horizontal\n", + "\n", + " $$\n", + " \\tan\\,\\gamma = \\frac{R_A - d_o + e_1}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", + " $$\n" + ] + }, + { + "cell_type": "markdown", + "id": "979114a2-267d-4142-a6ae-d1ad13c480eb", + "metadata": {}, + "source": [ + "Now adopt a reference frame where the line intersecting the ball valve pivot and probe drive vertical (grey dashed above) is rotated to the horizontal and the ball valve is the origin. In this reference frame will use a coordinate system $(s_0, s_1)$. In this system the pinion point is located at the intersection of two circles:\n", + "\n", + "1. The circle about the ball valve pivot of radius $R_P$.\n", + " \n", + " $$\n", + " R_P^2 = s_0^2 + s_1^2\n", + " $$\n", + " \n", + "2. The circle about the vertical pinion of radius $R_A$.\n", + "\n", + " $$\n", + " R_A^2 = (s_0 + L)^2 + s_1^2\\\\\n", + " \\text{where}\\; L^2 = (R_A - d_o + e_1)^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", + " $$\n", + "\n", + "Solving this system of equations we can calcualte the location of the pinion and, thus, the angle $\\phi$ depicted in the Drive Space Overview figure.\n", + "\n", + "$$\n", + "\\tan^2 \\phi = \\left(\\frac{2\\,L\\,R_P}{R_A^2-R_P^2-L^2}\\right)^2 - 1\n", + "$$\n", + "\n", + "Knowing $\\phi$, the signed angle $\\theta$ can be expressed as\n", + "\n", + "$$\n", + "\\theta = \\gamma +|\\beta|-|\\phi|\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "ff994b3b-3eca-498d-8b60-38129b83970c", + "metadata": {}, + "source": [ + "Taking $\\theta$ and the radial projection of the probe into the motion space as $r=D_C + e_0$, where $D_C$ is the distans from the ball valve pivot to the motion space origin `pivot_to_center`, then the motion space coordinates can be expressed as\n", + "\n", + "$$\n", + "x = (\\cos\\theta) \\, e_0 + D_C \\,(\\cos\\theta-1)\\\\\n", + "y = (-\\sin\\theta)\\, e_0 - D_C \\,\\sin\\theta\n", + "$$\n", + "\n", + "and expressed as the `_matrix_to_motion_space`\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " x \\\\ y \\\\ 1\n", + "\\end{bmatrix}\n", + "=\n", + "\\begin{bmatrix}\n", + " \\cos\\theta & 0 & D_C \\, (\\cos\\theta - 1)\\\\\n", + " -\\sin\\theta & 0 & -D_C \\, \\sin\\theta\\\\\n", + " 0 & 0 & 1\\\\\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + " e_0 \\\\ e_1 \\\\ 1\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "9a2d6321-c59d-4771-9676-26600d4acf33", + "metadata": {}, + "source": [ + "Obviously this not a perfectly clean expression since $\\theta$ depents on $e_1$. However, this is the expression that must be used to work with the archatecture desinged int `BaseTransform`." + ] + }, + { + "cell_type": "markdown", + "id": "1c8d4e25-6b31-4acd-8070-610c9b87d829", + "metadata": {}, + "source": [ + "### Algorithm: Motion to Drive Space\n", + "\n", + "In order to convert from the motion space to the drive space the key parameter to determine is the location of the probe drive pinion. Again this boils down to determining the angle $\\theta$, since the pinion is always a distance $R_P$ from the ball valve pivot and at an angle of $\\theta - |\\beta|$.\n", + "\n", + "Knowing the motion space coordinates $(x, y)$ the angle $\\theta$ can be written as..\n", + "\n", + "$$\n", + "\\tan\\theta = -\\frac{y}{D_C + x}\n", + "$$\n", + "\n", + "Then the probe drive pinion is located at the following position with the ball valve coordinate system $(s_0, s_1)$\n", + "\n", + "$$\n", + "s_0 = -R_P \\cos(\\theta - |\\beta|)\\\\\n", + "s_1 = R_P \\sin(\\theta - |\\beta|)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "d24296ce-b36f-47f9-afa0-a8a25cedf8f4", + "metadata": {}, + "source": [ + "Now we can determine the angle $\\alpha$ in which the probe drive arm leans forward.\n", + "\n", + "$$\n", + "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} + s_0}{R_A}\n", + "= \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\n", + "$$\n", + "$$\n", + "\\cos\\alpha = \\frac{R_A - d_o + e_1 - s_1}{R_A}\n", + "= \\frac{R_A - d_o + e_1 - R_P \\sin(\\theta - |\\beta|)}{R_A}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "e9ae34a6-c658-415c-8950-5c28357b497a", + "metadata": {}, + "source": [ + "Now we can cast the drive space coordinates as\n", + "\n", + "$$\n", + "e_0 = \\frac{1}{\\cos\\theta}x + D_C\\left(\\frac{1}{\\cos\\theta}-1\\right)\\\\\n", + "e_1 = R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\\\\\n", + "\\tan\\theta = -\\frac{y}{D_C + x}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "70dde653-1b6a-4879-a5b3-daf15d212968", + "metadata": {}, + "source": [ + "The does yield a rather ugly, but functional, transformation matrix of\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " e_0 \\\\ e_1 \\\\ 1\n", + "\\end{bmatrix}\n", + "=\n", + "\\begin{bmatrix}\n", + " \\frac{1}{\\cos\\theta} & 0 & D_C \\, \\left(\\frac{1}{\\cos\\theta} - 1\\right)\\\\\n", + " 0 & 0 & R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\\\\\n", + " 0 & 0 & 1\\\\\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + " x \\\\ y \\\\ 1\n", + "\\end{bmatrix}\n", + "$$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From ba9628ff3b4452f6925bde8f0b4132cd745d91ce Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 18 May 2026 10:43:10 -0700 Subject: [PATCH 020/177] rename lapd_xy_transform.ipynb -> LaPDXYTransform.ipynb --- .../notebooks/transform/LaPDXYTransform.ipynb | 1081 +++++++++++++++++ .../transform/lapd_xy_transform.ipynb | 885 -------------- 2 files changed, 1081 insertions(+), 885 deletions(-) create mode 100644 docs/notebooks/transform/LaPDXYTransform.ipynb delete mode 100644 docs/notebooks/transform/lapd_xy_transform.ipynb diff --git a/docs/notebooks/transform/LaPDXYTransform.ipynb b/docs/notebooks/transform/LaPDXYTransform.ipynb new file mode 100644 index 00000000..358edd31 --- /dev/null +++ b/docs/notebooks/transform/LaPDXYTransform.ipynb @@ -0,0 +1,1081 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fefb950-9158-4c62-b593-cda353ff5db1", + "metadata": {}, + "source": [ + "# Demo of `LaPDXYTransform`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " from bapsf_motion.transform import LaPDXYTransform\n", + "except ModuleNotFoundError:\n", + " from pathlib import Path\n", + "\n", + " HERE = Path().cwd()\n", + " BAPSF_MOTION = (HERE / \"..\" / \"..\" / \"..\" ).resolve()\n", + " sys.path.append(str(BAPSF_MOTION))\n", + " \n", + " from bapsf_motion.transform import LaPDXYTransform" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "120c8907-672f-4915-aa03-506dd91b1d18", + "metadata": {}, + "outputs": [], + "source": [ + "tr = LaPDXYTransform(\n", + " (\"x\", \"y\"),\n", + " pivot_to_center=57.288,\n", + " pivot_to_drive=134.0,\n", + " pivot_to_feedthru=21.6,\n", + " # probe_axis_offset=10.00125,\n", + " probe_axis_offset=20.16125,\n", + " droop_correct=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4e61105e-3788-4edb-a54c-9a582f04f745", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-5, 5] [[ 5.20035847 -10.82133761]] [[-5. 5.]]\n", + "[-5, -5] [[ 5.20035847 10.69163439]] [[-5. -5.]]\n", + "[5, -5] [[-4.76148342 12.72168007]] [[ 5. -5.]]\n", + "[5, 5] [[ -4.76148342 -12.90561491]] [[5. 5.]]\n", + "[0, 0] [[0. 0.]] [[ 0.00000000e+00 -1.59006142e-15]]\n", + "X = -5 Δ = [0.] || Y = 5 Δ = [-6.21724894e-15]\n", + "X = -5 Δ = [0.] || Y = -5 Δ = [8.8817842e-16]\n", + "X = 5 Δ = [0.] || Y = -5 Δ = [8.8817842e-16]\n", + "X = 5 Δ = [0.] || Y = 5 Δ = [-6.21724894e-15]\n", + "X = 0 Δ = [0.] || Y = 0 Δ = [3.71924713e-15]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = 2.0 * figheight\n", + "fig, axs = plt.subplots(2, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0,0].set_xlabel(\"MSpace X\")\n", + "axs[0,0].set_ylabel(\"MSpace Y\")\n", + "axs[0,1].set_xlabel(\"Drive X\")\n", + "axs[0,1].set_ylabel(\"Drive Y\")\n", + "axs[0,2].set_xlabel(\"MSpace X\")\n", + "axs[0,2].set_ylabel(\"MSpace Y\")\n", + "\n", + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")\n", + "\n", + "axs[0,0].fill(points[...,0], points[...,1])\n", + "axs[0,1].fill(dpoints[...,0], dpoints[...,1])\n", + "axs[0,2].fill(mpoints[...,0], mpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " dpt = tr(pt, to_coords=\"drive\")\n", + " mpt = tr(dpt, to_coords=\"motion_space\")\n", + " print(pt, dpt, mpt)\n", + " axs[0,0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[0,1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " axs[0,2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", + "\n", + "##\n", + "\n", + "axs[1,0].set_xlabel(\"Drive X\")\n", + "axs[1,0].set_ylabel(\"Drive Y\")\n", + "axs[1,1].set_xlabel(\"MSpace X\")\n", + "axs[1,1].set_ylabel(\"MSpace Y\")\n", + "axs[1,2].set_xlabel(\"Drive X\")\n", + "axs[1,2].set_ylabel(\"Drive Y\")\n", + "\n", + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "mpoints = tr(points, to_coords=\"motion_space\")\n", + "dpoints = tr(mpoints, to_coords=\"drive\")\n", + "\n", + "axs[1,0].fill(points[...,0], points[...,1])\n", + "axs[1,1].fill(mpoints[...,0], mpoints[...,1])\n", + "axs[1,2].fill(dpoints[...,0], dpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " mpt = tr(pt, to_coords=\"motion_space\")\n", + " dpt = tr(mpt, to_coords=\"drive\")\n", + " axs[1,0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1,1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", + " axs[1,2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " print(f\"X = {pt[0]} Δ = {dpt[...,0] - pt[0]} || Y = {pt[1]} Δ = {dpt[...,1] - pt[1]}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3c7e7e77-c0d0-4df0-bbdf-a0729792c490", + "metadata": {}, + "source": [ + "### Test Transforming `drive -> motion space -> drive`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "094e94a9-ecbf-451a-855d-ab09e818785e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(True,\n", + " True,\n", + " True,\n", + " np.float64(-7.105427357601002e-15),\n", + " np.float64(7.105427357601002e-15))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mpoints = tr(points, to_coords=\"motion_space\")\n", + "dpoints = tr(mpoints, to_coords=\"drive\")\n", + "\n", + "(\n", + " np.allclose(dpoints, points),\n", + " np.allclose(dpoints[...,0], points[...,0]),\n", + " np.allclose(dpoints[...,1], points[...,1]),\n", + " np.min(dpoints - points),\n", + " np.max(dpoints - points),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a277810b-3553-4cdf-9fc9-dc0efab86cfc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[ True, True],\n", + " [ True, True]]),\n", + " True,\n", + " True,\n", + " True,\n", + " np.float64(-6.217248937900877e-15),\n", + " np.float64(0.0))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "points = np.array([[5, 5], [5, 5]])\n", + "mpoints = tr(points, to_coords=\"motion_space\")\n", + "dpoints = tr(mpoints, to_coords=\"drive\")\n", + "\n", + "(\n", + " np.isclose(dpoints, points),\n", + " np.allclose(dpoints, points),\n", + " np.allclose(dpoints[...,0], points[...,0]),\n", + " np.allclose(dpoints[...,1], points[...,1]),\n", + " np.min(dpoints - points),\n", + " np.max(dpoints - points),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "be2cbc76-fd22-48d3-aeeb-b1650fa93f9a", + "metadata": {}, + "source": [ + "### Test Transforming `motion space -> drive -> motion space`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8782f090-6ecb-4d25-8944-9cd1853be826", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(True,\n", + " True,\n", + " True,\n", + " np.float64(-1.7763568394002505e-15),\n", + " np.float64(-8.881784197001252e-16))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")\n", + "\n", + "(\n", + " np.allclose(mpoints, points),\n", + " np.allclose(mpoints[...,0], points[...,0]),\n", + " np.allclose(mpoints[...,1], points[...,1]),\n", + " np.min(mpoints - points),\n", + " np.max(mpoints - points),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "dea6120b-b00c-4828-83e8-68eff644a5e8", + "metadata": {}, + "source": [ + "## Prototyping" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0503ac38-33d2-442e-9a45-633f40bb562f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([-5., -5., 1.]), array([5.03615969, 1.94425505, 1. ]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pts = [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + "]\n", + "# pts = [[-5, 5]]\n", + "\n", + "pts = tr._condition_points(pts)\n", + "matrix = tr.matrix(pts, to_coords=\"mspace\")\n", + "pts = np.concatenate(\n", + " (pts, np.ones((pts.shape[0], 1))),\n", + " axis=1,\n", + ")\n", + "results = np.einsum(\"kmn,kn->km\", matrix, pts)[:-1,...]\n", + "ii = 1\n", + "# pts[ii, ...]\n", + "(pts[ii,...], results[ii,...])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "48b03845-2742-46f7-91d4-6dfa28ef3b0c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.99930845, 0. , 0.03961743],\n", + " [ 0.03718358, 0. , 2.13017296],\n", + " [ 0. , 0. , 1. ]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix[ii, ...]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "53a821b5-893f-4edf-93f0-2720ff5e8832", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([-5., -5.]), array([[5.03615969, 1.94425505]]))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(\n", + " pts[ii, :-1],\n", + " tr(pts[ii, :-1], to_coords=\"mspace\"),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "427ec57e-aca1-4d67-82ca-c0256bdae944", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[5.03615969, 1.94425505]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tr(pts[ii, :-1], to_coords=\"mspace\")" + ] + }, + { + "cell_type": "markdown", + "id": "bad1ea07-e6cd-4261-9baf-abdd685d35f3", + "metadata": {}, + "source": [ + "## Testing Matrix Math" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "483aa574-7a44-41b4-b2a4-3a980145a91b", + "metadata": {}, + "outputs": [], + "source": [ + "pivot_to_center = 57.288\n", + "pivot_to_drive = 134.0\n", + "drive_polarity = np.array([1.0, 1.0])\n", + "mspace_polarity = np.array([-1.0, 1.0])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "287b1f92-4241-482e-97f2-f4ab1e41a9bf", + "metadata": {}, + "outputs": [], + "source": [ + "def matrix_to_mspace(\n", + " points,\n", + " pivot_to_center,\n", + " pivot_to_drive,\n", + " drive_polarity,\n", + " mspace_polarity,\n", + "):\n", + " points = drive_polarity * points # type: np.ndarray\n", + "\n", + " theta = np.arctan(points[..., 1] / pivot_to_drive)\n", + " alpha = np.pi - theta\n", + "\n", + " npoints = 1 if points.ndim == 1 else points.shape[0]\n", + "\n", + " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T1[..., 0, 0] = np.cos(theta)\n", + " T1[..., 0, 2] = -pivot_to_drive * np.cos(theta)\n", + " T1[..., 1, 0] = -np.sin(theta)\n", + " T1[..., 1, 2] = pivot_to_drive * np.sin(theta)\n", + " T1[..., 2, 2] = 1.0\n", + "\n", + " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T2[..., 0, 0] = 1.0\n", + " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", + " T2[..., 1, 1] = 1.0\n", + " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", + " T2[..., 2, 2] = 1.0\n", + "\n", + " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T3[..., 0, 0] = 1.0\n", + " T3[..., 0, 2] = -pivot_to_center\n", + " T3[..., 1, 1] = 1.0\n", + " T3[..., 2, 2] = 1.0\n", + " \n", + " # return T1, T2, T3\n", + " \n", + " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", + " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", + " \n", + " return np.matmul(\n", + " T_mpolarity,\n", + " np.matmul(\n", + " T3,\n", + " np.matmul(\n", + " T2,\n", + " np.matmul(T1, T_dpolarity),\n", + " ),\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8ec05264-742e-40a2-8268-efebae168cd5", + "metadata": {}, + "outputs": [], + "source": [ + "def matrix_to_drive(\n", + " points,\n", + " pivot_to_center,\n", + " pivot_to_drive,\n", + " drive_polarity,\n", + " mspace_polarity,\n", + "):\n", + " points = mspace_polarity * points # type: np.ndarray\n", + "\n", + " # need to handle when x_L = pivot_to_center\n", + " # since alpha can never be 90deg we done need to worry about that case\n", + " alpha = np.arctan(points[..., 1] / (pivot_to_center + points[...,0]))\n", + "\n", + " npoints = 1 if points.ndim == 1 else points.shape[0]\n", + " \n", + " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T1[..., 0, 0] = 1.0\n", + " T1[..., 0, 2] = pivot_to_center\n", + " T1[..., 1, 1] = 1.0\n", + " T1[..., 2, 2] = 1.0\n", + "\n", + " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T2[..., 0, 0] = 1.0\n", + " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", + " T2[..., 1, 1] = 1.0\n", + " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", + " T2[..., 2, 2] = 1.0\n", + " \n", + " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", + " T3[..., 0, 0] = 1 / np.cos(alpha)\n", + " T3[..., 0, 2] = pivot_to_drive\n", + " T3[..., 1, 2] = -pivot_to_drive * np.tan(alpha)\n", + " T3[..., 2, 2] = 1.0\n", + " \n", + " # return T1, T2, T3\n", + " \n", + " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", + " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", + " \n", + " return np.matmul(\n", + " T_dpolarity,\n", + " np.matmul(\n", + " T3,\n", + " np.matmul(\n", + " T2,\n", + " np.matmul(T1, T_mpolarity),\n", + " ),\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "49b75bb5-e2cb-4703-ab52-ada40e8ee49d", + "metadata": {}, + "outputs": [], + "source": [ + "def convert(\n", + " points,\n", + " pivot_to_center,\n", + " pivot_to_drive,\n", + " drive_polarity,\n", + " mspace_polarity,\n", + " to_coord=\"drive\",\n", + "):\n", + " if not isinstance(points, np.ndarray):\n", + " points = np.array(points)\n", + " \n", + " if to_coord == \"drive\":\n", + " matrix = matrix_to_drive(\n", + " points,\n", + " pivot_to_center=pivot_to_center,\n", + " pivot_to_drive=pivot_to_drive,\n", + " drive_polarity=drive_polarity,\n", + " mspace_polarity=mspace_polarity,\n", + " )\n", + " elif to_coord == \"motion_space\":\n", + " matrix = matrix_to_mspace(\n", + " points,\n", + " pivot_to_center=pivot_to_center,\n", + " pivot_to_drive=pivot_to_drive,\n", + " drive_polarity=drive_polarity,\n", + " mspace_polarity=mspace_polarity,\n", + " )\n", + " else:\n", + " raise ValueError\n", + " \n", + " if points.ndim == 1:\n", + " points = np.concatenate((points, [1]))\n", + " return np.matmul(matrix, points)[:2]\n", + "\n", + " points = np.concatenate(\n", + " (points, np.ones((points.shape[0], 1))),\n", + " axis=1,\n", + " )\n", + " \n", + " return np.einsum(\"kmn,kn->km\", matrix, points)[..., :2]\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "830f6bd1-cc34-44ef-8a9f-cc4b2469d097", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. ],\n", + " [-0.96447966, -4.76122797],\n", + " [-2.85283725, -9.87326849],\n", + " [ 1.00857746, 2.29892945]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", + "\n", + "dpoints = convert(\n", + " points=point,\n", + " to_coord=\"drive\",\n", + " pivot_to_drive=pivot_to_drive,\n", + " pivot_to_center=pivot_to_center,\n", + " drive_polarity=drive_polarity,\n", + " mspace_polarity=mspace_polarity,\n", + ")\n", + "dpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e1664f8b-c219-4f14-b810-9544d24af201", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1.42108547e-14, -2.34260237e-14],\n", + " [ 1.00000000e+00, 2.00000000e+00],\n", + " [ 3.00000000e+00, 4.00000000e+00],\n", + " [-1.00000000e+00, -1.00000000e+00]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mpoints = convert(\n", + " points=dpoints,\n", + " to_coord=\"motion_space\",\n", + " pivot_to_drive=pivot_to_drive,\n", + " pivot_to_center=pivot_to_center,\n", + " drive_polarity=drive_polarity,\n", + " mspace_polarity=mspace_polarity,\n", + ")\n", + "mpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ac9140f2-f9d6-4299-bc17-19433b0ddf34", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ True, True],\n", + " [ True, True],\n", + " [ True, True],\n", + " [ True, True]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.isclose(mpoints, point)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "59326859-411b-41b8-9082-79d2008152a1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Erik\\AppData\\Local\\Temp\\ipykernel_21436\\1382693254.py:1: RuntimeWarning: divide by zero encountered in divide\n", + " (mpoints - point) / point\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[ -inf, -inf],\n", + " [ 2.88657986e-14, 5.99520433e-15],\n", + " [-2.36847579e-15, 2.66453526e-15],\n", + " [ 3.55271368e-15, -5.55111512e-15]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(mpoints - point) / point" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0796106e-ecc2-495a-932f-05b59cc40257", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'TT' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[21]\u001b[39m\u001b[32m, line 16\u001b[39m\n\u001b[32m 12\u001b[39m pivot_to_drive=pivot_to_drive,\n\u001b[32m 13\u001b[39m drive_polarity=drive_polarity,\n\u001b[32m 14\u001b[39m mspace_polarity=mspace_polarity,\n\u001b[32m 15\u001b[39m )\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m TT.shape\n", + "\u001b[31mNameError\u001b[39m: name 'TT' is not defined" + ] + } + ], + "source": [ + "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", + "# T1, T2, T3 = matrix_to_mspace(\n", + "# points=point,\n", + "# pivot_to_center=pivot_to_center,\n", + "# pivot_to_drive=pivot_to_drive,\n", + "# drive_polarity=drive_polarity,\n", + "# mspace_polarity=mspace_polarity,\n", + "# )\n", + "T = matrix_to_mspace(\n", + " points=point,\n", + " pivot_to_center=pivot_to_center,\n", + " pivot_to_drive=pivot_to_drive,\n", + " drive_polarity=drive_polarity,\n", + " mspace_polarity=mspace_polarity,\n", + ")\n", + "TT.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88a0662f-80d7-406f-9412-bbde9a8567db", + "metadata": {}, + "outputs": [], + "source": [ + "# (\n", + "# T1[1,...],\n", + "# T2[1,...],\n", + "# T3[1,...],\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e7a6431-983a-432c-ba63-d13ff0894357", + "metadata": {}, + "outputs": [], + "source": [ + "npt = np.concatenate(\n", + " (\n", + " point,\n", + " np.ones((point.shape[0], 1)),\n", + " ),\n", + " axis=1,\n", + ")\n", + "npt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce4e703d-1357-4c9a-bdc3-c38c5ea09466", + "metadata": {}, + "outputs": [], + "source": [ + "# np.matmul(TT, npt, axes=\"(k,m,n),(k,m)->(k,n)\")\n", + "np.einsum(\"kmn,kn->km\", TT, npt)[..., :2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a67bbad7-d5c7-4ff6-836c-be94b2837187", + "metadata": {}, + "outputs": [], + "source": [ + "point" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67082e99-d5a0-49c8-a28b-2ab0e08717fa", + "metadata": {}, + "outputs": [], + "source": [ + "P = np.diag([-1, -1, 1])\n", + "(\n", + " P,\n", + " np.linalg.inv(P),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cac88c7f-beec-4ff7-98ad-d4d2d805f952", + "metadata": {}, + "outputs": [], + "source": [ + "M = np.zeros((3, 3))\n", + "M[0,0] = 1\n", + "M[0,2] = -50\n", + "M[1,1] = 1\n", + "M[2,2] = 1\n", + "\n", + "(\n", + " M,\n", + " np.linalg.inv(M),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "377c98d5-5de0-4c83-b81a-714a7bda27b1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b8e8b58-b8e4-41ba-96a5-7f906204df89", + "metadata": {}, + "outputs": [], + "source": [ + "probe_axis_offset = 4.\n", + "pivot_to_drive = 20\n", + "pivot_to_center = 40" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b48262ae-75a3-499c-9d74-e2de4d0fd264", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.array([\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0],\n", + " [-5, 0],\n", + " [5, 0],\n", + "])\n", + "points" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a4493a4-4fd2-405b-b2fb-8899e6029255", + "metadata": {}, + "outputs": [], + "source": [ + "sine_alpha = probe_axis_offset / np.sqrt(\n", + " pivot_to_drive**2\n", + " + (-probe_axis_offset + points[..., 1])**2\n", + ")\n", + "alpha = np.arcsin(sine_alpha)\n", + "np.degrees(alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04b63d69-9d0b-478b-a58e-76a096de7da4", + "metadata": {}, + "outputs": [], + "source": [ + "tan_beta = (-probe_axis_offset + points[..., 1]) / -pivot_to_drive\n", + "beta = np.arctan(tan_beta)\n", + "np.degrees(beta)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c9eed1c-4b2a-48e8-9772-3b90920577c7", + "metadata": {}, + "outputs": [], + "source": [ + "theta = beta - alpha\n", + "theta" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a0f0cfd-af7f-4ecd-8e5b-6dbc73bdcd9f", + "metadata": {}, + "outputs": [], + "source": [ + "T0 = np.zeros((points.shape[0], 3, 3)).squeeze()\n", + "T0[..., 0, 0] = np.cos(theta)\n", + "T0[..., 0, 2] = -pivot_to_center * (1 - np.cos(theta))\n", + "T0[..., 1, 0] = np.sin(theta)\n", + "T0[..., 1, 2] = pivot_to_center * np.sin(theta)\n", + "T0[..., 2, 2] = 1.0\n", + "T0[0,...]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39cffcd6-2c05-416f-8ff1-6cce04d596a4", + "metadata": {}, + "outputs": [], + "source": [ + "pts = np.concatenate(\n", + " (points, np.ones((points.shape[0], 1))),\n", + " axis=1,\n", + ")\n", + "mpoints = np.einsum(\"kmn,kn->km\", T0, pts)[...,:-1]\n", + "mpoints" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a263dd6-b393-4bbc-8359-568c8495d511", + "metadata": {}, + "outputs": [], + "source": [ + "tan_theta = mpoints[...,1]/(mpoints[...,0]+pivot_to_center)\n", + "theta = -np.arctan(tan_theta)\n", + "np.degrees(theta)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25bc8990-cc13-456b-a4dc-0b0bed440c2b", + "metadata": {}, + "outputs": [], + "source": [ + "TI = np.zeros((points.shape[0], 3, 3)).squeeze()\n", + "TI[..., 0, 2] = np.sqrt(mpoints[...,1]**2 +(pivot_to_center + mpoints[...,0])**2) - pivot_to_center\n", + "TI[..., 1, 2] = pivot_to_axis * np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))\n", + "TI[..., 2, 2] = 1.0\n", + "TI[0,...]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90ac5781-d195-4019-bb2d-08dd721e7487", + "metadata": {}, + "outputs": [], + "source": [ + "mpts = np.concatenate(\n", + " (mpoints, np.ones((points.shape[0], 1))),\n", + " axis=1,\n", + ")\n", + "pts = mpoints = np.einsum(\"kmn,kn->km\", TI, mpts)[...,:-1]\n", + "pts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05d4a1fa-cecc-4e64-97d0-b02bb8b11dd7", + "metadata": {}, + "outputs": [], + "source": [ + "probe_axis_offset * (1 - (1/np.cos(theta)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6112917f-f237-46bc-a9ca-c215d2a1aef1", + "metadata": {}, + "outputs": [], + "source": [ + "pivot_to_axis*np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94ed0b37-ea33-4639-8f72-70008e4ac98e", + "metadata": {}, + "outputs": [], + "source": [ + "pivot_to_axis*np.tan(theta) - probe_axis_offset * np.cos(theta) + probe_axis_offset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5853946-24e3-4286-aae6-aa48a59af280", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/transform/lapd_xy_transform.ipynb b/docs/notebooks/transform/lapd_xy_transform.ipynb deleted file mode 100644 index 0beb9489..00000000 --- a/docs/notebooks/transform/lapd_xy_transform.ipynb +++ /dev/null @@ -1,885 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7fefb950-9158-4c62-b593-cda353ff5db1", - "metadata": {}, - "source": [ - "# Demo of `LaPDXYTransform`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import sys\n", - "\n", - "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", - "metadata": {}, - "outputs": [], - "source": [ - "try:\n", - " from bapsf_motion.transform import LaPDXYTransform\n", - "except ModuleNotFoundError:\n", - " from pathlib import Path\n", - "\n", - " HERE = Path().cwd()\n", - " BAPSF_MOTION = (HERE / \"..\" / \"..\" / \"..\" ).resolve()\n", - " sys.path.append(str(BAPSF_MOTION))\n", - " \n", - " from bapsf_motion.transform import LaPDXYTransform" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "120c8907-672f-4915-aa03-506dd91b1d18", - "metadata": {}, - "outputs": [], - "source": [ - "tr = LaPDXYTransform(\n", - " (\"x\", \"y\"),\n", - " pivot_to_center=57.288,\n", - " pivot_to_drive=134.0,\n", - " pivot_to_feedthru=21.6,\n", - " # probe_axis_offset=10.00125,\n", - " probe_axis_offset=20.16125,\n", - " droop_correct=False,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4e61105e-3788-4edb-a54c-9a582f04f745", - "metadata": {}, - "outputs": [], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = 2.0 * figheight\n", - "fig, axs = plt.subplots(2, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0,0].set_xlabel(\"MSpace X\")\n", - "axs[0,0].set_ylabel(\"MSpace Y\")\n", - "axs[0,1].set_xlabel(\"Drive X\")\n", - "axs[0,1].set_ylabel(\"Drive Y\")\n", - "axs[0,2].set_xlabel(\"MSpace X\")\n", - "axs[0,2].set_ylabel(\"MSpace Y\")\n", - "\n", - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")\n", - "\n", - "axs[0,0].fill(points[...,0], points[...,1])\n", - "axs[0,1].fill(dpoints[...,0], dpoints[...,1])\n", - "axs[0,2].fill(mpoints[...,0], mpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " dpt = tr(pt, to_coords=\"drive\")\n", - " mpt = tr(dpt, to_coords=\"motion_space\")\n", - " print(pt, dpt, mpt)\n", - " axs[0,0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[0,1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " axs[0,2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", - "\n", - "##\n", - "\n", - "axs[1,0].set_xlabel(\"Drive X\")\n", - "axs[1,0].set_ylabel(\"Drive Y\")\n", - "axs[1,1].set_xlabel(\"MSpace X\")\n", - "axs[1,1].set_ylabel(\"MSpace Y\")\n", - "axs[1,2].set_xlabel(\"Drive X\")\n", - "axs[1,2].set_ylabel(\"Drive Y\")\n", - "\n", - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "mpoints = tr(points, to_coords=\"motion_space\")\n", - "dpoints = tr(mpoints, to_coords=\"drive\")\n", - "\n", - "axs[1,0].fill(points[...,0], points[...,1])\n", - "axs[1,1].fill(mpoints[...,0], mpoints[...,1])\n", - "axs[1,2].fill(dpoints[...,0], dpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " mpt = tr(pt, to_coords=\"motion_space\")\n", - " dpt = tr(mpt, to_coords=\"drive\")\n", - " axs[1,0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1,1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", - " axs[1,2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " print(f\"X = {pt[0]} Δ = {dpt[...,0] - pt[0]} || Y = {pt[1]} Δ = {dpt[...,1] - pt[1]}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "3c7e7e77-c0d0-4df0-bbdf-a0729792c490", - "metadata": {}, - "source": [ - "### Test Transforming `drive -> motion space -> drive`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "094e94a9-ecbf-451a-855d-ab09e818785e", - "metadata": {}, - "outputs": [], - "source": [ - "mpoints = tr(points, to_coords=\"motion_space\")\n", - "dpoints = tr(mpoints, to_coords=\"drive\")\n", - "\n", - "(\n", - " np.allclose(dpoints, points),\n", - " np.allclose(dpoints[...,0], points[...,0]),\n", - " np.allclose(dpoints[...,1], points[...,1]),\n", - " np.min(dpoints - points),\n", - " np.max(dpoints - points),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a277810b-3553-4cdf-9fc9-dc0efab86cfc", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.array([[5, 5], [5, 5]])\n", - "mpoints = tr(points, to_coords=\"motion_space\")\n", - "dpoints = tr(mpoints, to_coords=\"drive\")\n", - "\n", - "(\n", - " np.isclose(dpoints, points),\n", - " np.allclose(dpoints, points),\n", - " np.allclose(dpoints[...,0], points[...,0]),\n", - " np.allclose(dpoints[...,1], points[...,1]),\n", - " np.min(dpoints - points),\n", - " np.max(dpoints - points),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "be2cbc76-fd22-48d3-aeeb-b1650fa93f9a", - "metadata": {}, - "source": [ - "### Test Transforming `motion space -> drive -> motion space`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8782f090-6ecb-4d25-8944-9cd1853be826", - "metadata": {}, - "outputs": [], - "source": [ - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")\n", - "\n", - "(\n", - " np.allclose(mpoints, points),\n", - " np.allclose(mpoints[...,0], points[...,0]),\n", - " np.allclose(mpoints[...,1], points[...,1]),\n", - " np.min(mpoints - points),\n", - " np.max(mpoints - points),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "dea6120b-b00c-4828-83e8-68eff644a5e8", - "metadata": {}, - "source": [ - "## Prototyping" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0503ac38-33d2-442e-9a45-633f40bb562f", - "metadata": {}, - "outputs": [], - "source": [ - "pts = [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - "]\n", - "# pts = [[-5, 5]]\n", - "\n", - "pts = tr._condition_points(pts)\n", - "matrix = tr.matrix(pts, to_coords=\"mspace\")\n", - "pts = np.concatenate(\n", - " (pts, np.ones((pts.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "results = np.einsum(\"kmn,kn->km\", matrix, pts)[:-1,...]\n", - "ii = 1\n", - "# pts[ii, ...]\n", - "(pts[ii,...], results[ii,...])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "48b03845-2742-46f7-91d4-6dfa28ef3b0c", - "metadata": {}, - "outputs": [], - "source": [ - "matrix[ii, ...]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "53a821b5-893f-4edf-93f0-2720ff5e8832", - "metadata": {}, - "outputs": [], - "source": [ - "(\n", - " pts[ii, :-1],\n", - " tr(pts[ii, :-1], to_coords=\"mspace\"),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "427ec57e-aca1-4d67-82ca-c0256bdae944", - "metadata": {}, - "outputs": [], - "source": [ - "tr(pts[ii, :-1], to_coords=\"mspace\")" - ] - }, - { - "cell_type": "markdown", - "id": "bad1ea07-e6cd-4261-9baf-abdd685d35f3", - "metadata": {}, - "source": [ - "## Testing Matrix Math" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "483aa574-7a44-41b4-b2a4-3a980145a91b", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_center = 57.288\n", - "pivot_to_drive = 134.0\n", - "drive_polarity = np.array([1.0, 1.0])\n", - "mspace_polarity = np.array([-1.0, 1.0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "287b1f92-4241-482e-97f2-f4ab1e41a9bf", - "metadata": {}, - "outputs": [], - "source": [ - "def matrix_to_mspace(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - "):\n", - " points = drive_polarity * points # type: np.ndarray\n", - "\n", - " theta = np.arctan(points[..., 1] / pivot_to_drive)\n", - " alpha = np.pi - theta\n", - "\n", - " npoints = 1 if points.ndim == 1 else points.shape[0]\n", - "\n", - " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T1[..., 0, 0] = np.cos(theta)\n", - " T1[..., 0, 2] = -pivot_to_drive * np.cos(theta)\n", - " T1[..., 1, 0] = -np.sin(theta)\n", - " T1[..., 1, 2] = pivot_to_drive * np.sin(theta)\n", - " T1[..., 2, 2] = 1.0\n", - "\n", - " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T2[..., 0, 0] = 1.0\n", - " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", - " T2[..., 1, 1] = 1.0\n", - " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", - " T2[..., 2, 2] = 1.0\n", - "\n", - " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T3[..., 0, 0] = 1.0\n", - " T3[..., 0, 2] = -pivot_to_center\n", - " T3[..., 1, 1] = 1.0\n", - " T3[..., 2, 2] = 1.0\n", - " \n", - " # return T1, T2, T3\n", - " \n", - " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", - " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", - " \n", - " return np.matmul(\n", - " T_mpolarity,\n", - " np.matmul(\n", - " T3,\n", - " np.matmul(\n", - " T2,\n", - " np.matmul(T1, T_dpolarity),\n", - " ),\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8ec05264-742e-40a2-8268-efebae168cd5", - "metadata": {}, - "outputs": [], - "source": [ - "def matrix_to_drive(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - "):\n", - " points = mspace_polarity * points # type: np.ndarray\n", - "\n", - " # need to handle when x_L = pivot_to_center\n", - " # since alpha can never be 90deg we done need to worry about that case\n", - " alpha = np.arctan(points[..., 1] / (pivot_to_center + points[...,0]))\n", - "\n", - " npoints = 1 if points.ndim == 1 else points.shape[0]\n", - " \n", - " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T1[..., 0, 0] = 1.0\n", - " T1[..., 0, 2] = pivot_to_center\n", - " T1[..., 1, 1] = 1.0\n", - " T1[..., 2, 2] = 1.0\n", - "\n", - " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T2[..., 0, 0] = 1.0\n", - " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", - " T2[..., 1, 1] = 1.0\n", - " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", - " T2[..., 2, 2] = 1.0\n", - " \n", - " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T3[..., 0, 0] = 1 / np.cos(alpha)\n", - " T3[..., 0, 2] = pivot_to_drive\n", - " T3[..., 1, 2] = -pivot_to_drive * np.tan(alpha)\n", - " T3[..., 2, 2] = 1.0\n", - " \n", - " # return T1, T2, T3\n", - " \n", - " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", - " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", - " \n", - " return np.matmul(\n", - " T_dpolarity,\n", - " np.matmul(\n", - " T3,\n", - " np.matmul(\n", - " T2,\n", - " np.matmul(T1, T_mpolarity),\n", - " ),\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49b75bb5-e2cb-4703-ab52-ada40e8ee49d", - "metadata": {}, - "outputs": [], - "source": [ - "def convert(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - " to_coord=\"drive\",\n", - "):\n", - " if not isinstance(points, np.ndarray):\n", - " points = np.array(points)\n", - " \n", - " if to_coord == \"drive\":\n", - " matrix = matrix_to_drive(\n", - " points,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - " )\n", - " elif to_coord == \"motion_space\":\n", - " matrix = matrix_to_mspace(\n", - " points,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - " )\n", - " else:\n", - " raise ValueError\n", - " \n", - " if points.ndim == 1:\n", - " points = np.concatenate((points, [1]))\n", - " return np.matmul(matrix, points)[:2]\n", - "\n", - " points = np.concatenate(\n", - " (points, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - " )\n", - " \n", - " return np.einsum(\"kmn,kn->km\", matrix, points)[..., :2]\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "830f6bd1-cc34-44ef-8a9f-cc4b2469d097", - "metadata": {}, - "outputs": [], - "source": [ - "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", - "\n", - "dpoints = convert(\n", - " points=point,\n", - " to_coord=\"drive\",\n", - " pivot_to_drive=pivot_to_drive,\n", - " pivot_to_center=pivot_to_center,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "dpoints" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1664f8b-c219-4f14-b810-9544d24af201", - "metadata": {}, - "outputs": [], - "source": [ - "mpoints = convert(\n", - " points=dpoints,\n", - " to_coord=\"motion_space\",\n", - " pivot_to_drive=pivot_to_drive,\n", - " pivot_to_center=pivot_to_center,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "mpoints" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ac9140f2-f9d6-4299-bc17-19433b0ddf34", - "metadata": {}, - "outputs": [], - "source": [ - "np.isclose(mpoints, point)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "59326859-411b-41b8-9082-79d2008152a1", - "metadata": {}, - "outputs": [], - "source": [ - "(mpoints - point) / point" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0796106e-ecc2-495a-932f-05b59cc40257", - "metadata": {}, - "outputs": [], - "source": [ - "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", - "# T1, T2, T3 = matrix_to_mspace(\n", - "# points=point,\n", - "# pivot_to_center=pivot_to_center,\n", - "# pivot_to_drive=pivot_to_drive,\n", - "# drive_polarity=drive_polarity,\n", - "# mspace_polarity=mspace_polarity,\n", - "# )\n", - "T = matrix_to_mspace(\n", - " points=point,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "TT.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "88a0662f-80d7-406f-9412-bbde9a8567db", - "metadata": {}, - "outputs": [], - "source": [ - "# (\n", - "# T1[1,...],\n", - "# T2[1,...],\n", - "# T3[1,...],\n", - "# )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5e7a6431-983a-432c-ba63-d13ff0894357", - "metadata": {}, - "outputs": [], - "source": [ - "npt = np.concatenate(\n", - " (\n", - " point,\n", - " np.ones((point.shape[0], 1)),\n", - " ),\n", - " axis=1,\n", - ")\n", - "npt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce4e703d-1357-4c9a-bdc3-c38c5ea09466", - "metadata": {}, - "outputs": [], - "source": [ - "# np.matmul(TT, npt, axes=\"(k,m,n),(k,m)->(k,n)\")\n", - "np.einsum(\"kmn,kn->km\", TT, npt)[..., :2]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a67bbad7-d5c7-4ff6-836c-be94b2837187", - "metadata": {}, - "outputs": [], - "source": [ - "point" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "67082e99-d5a0-49c8-a28b-2ab0e08717fa", - "metadata": {}, - "outputs": [], - "source": [ - "P = np.diag([-1, -1, 1])\n", - "(\n", - " P,\n", - " np.linalg.inv(P),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cac88c7f-beec-4ff7-98ad-d4d2d805f952", - "metadata": {}, - "outputs": [], - "source": [ - "M = np.zeros((3, 3))\n", - "M[0,0] = 1\n", - "M[0,2] = -50\n", - "M[1,1] = 1\n", - "M[2,2] = 1\n", - "\n", - "(\n", - " M,\n", - " np.linalg.inv(M),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "377c98d5-5de0-4c83-b81a-714a7bda27b1", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b8e8b58-b8e4-41ba-96a5-7f906204df89", - "metadata": {}, - "outputs": [], - "source": [ - "probe_axis_offset = 4.\n", - "pivot_to_drive = 20\n", - "pivot_to_center = 40" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b48262ae-75a3-499c-9d74-e2de4d0fd264", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.array([\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0],\n", - " [-5, 0],\n", - " [5, 0],\n", - "])\n", - "points" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a4493a4-4fd2-405b-b2fb-8899e6029255", - "metadata": {}, - "outputs": [], - "source": [ - "sine_alpha = probe_axis_offset / np.sqrt(\n", - " pivot_to_drive**2\n", - " + (-probe_axis_offset + points[..., 1])**2\n", - ")\n", - "alpha = np.arcsin(sine_alpha)\n", - "np.degrees(alpha)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "04b63d69-9d0b-478b-a58e-76a096de7da4", - "metadata": {}, - "outputs": [], - "source": [ - "tan_beta = (-probe_axis_offset + points[..., 1]) / -pivot_to_drive\n", - "beta = np.arctan(tan_beta)\n", - "np.degrees(beta)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1c9eed1c-4b2a-48e8-9772-3b90920577c7", - "metadata": {}, - "outputs": [], - "source": [ - "theta = beta - alpha\n", - "theta" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a0f0cfd-af7f-4ecd-8e5b-6dbc73bdcd9f", - "metadata": {}, - "outputs": [], - "source": [ - "T0 = np.zeros((points.shape[0], 3, 3)).squeeze()\n", - "T0[..., 0, 0] = np.cos(theta)\n", - "T0[..., 0, 2] = -pivot_to_center * (1 - np.cos(theta))\n", - "T0[..., 1, 0] = np.sin(theta)\n", - "T0[..., 1, 2] = pivot_to_center * np.sin(theta)\n", - "T0[..., 2, 2] = 1.0\n", - "T0[0,...]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "39cffcd6-2c05-416f-8ff1-6cce04d596a4", - "metadata": {}, - "outputs": [], - "source": [ - "pts = np.concatenate(\n", - " (points, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "mpoints = np.einsum(\"kmn,kn->km\", T0, pts)[...,:-1]\n", - "mpoints" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4a263dd6-b393-4bbc-8359-568c8495d511", - "metadata": {}, - "outputs": [], - "source": [ - "tan_theta = mpoints[...,1]/(mpoints[...,0]+pivot_to_center)\n", - "theta = -np.arctan(tan_theta)\n", - "np.degrees(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "25bc8990-cc13-456b-a4dc-0b0bed440c2b", - "metadata": {}, - "outputs": [], - "source": [ - "TI = np.zeros((points.shape[0], 3, 3)).squeeze()\n", - "TI[..., 0, 2] = np.sqrt(mpoints[...,1]**2 +(pivot_to_center + mpoints[...,0])**2) - pivot_to_center\n", - "TI[..., 1, 2] = pivot_to_axis * np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))\n", - "TI[..., 2, 2] = 1.0\n", - "TI[0,...]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "90ac5781-d195-4019-bb2d-08dd721e7487", - "metadata": {}, - "outputs": [], - "source": [ - "mpts = np.concatenate(\n", - " (mpoints, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "pts = mpoints = np.einsum(\"kmn,kn->km\", TI, mpts)[...,:-1]\n", - "pts" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05d4a1fa-cecc-4e64-97d0-b02bb8b11dd7", - "metadata": {}, - "outputs": [], - "source": [ - "probe_axis_offset * (1 - (1/np.cos(theta)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6112917f-f237-46bc-a9ca-c215d2a1aef1", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_axis*np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "94ed0b37-ea33-4639-8f72-70008e4ac98e", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_axis*np.tan(theta) - probe_axis_offset * np.cos(theta) + probe_axis_offset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5853946-24e3-4286-aae6-aa48a59af280", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 5829bfa9f404205d6ed2400efe99ff4d1a49adb9 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 18 May 2026 10:45:04 -0700 Subject: [PATCH 021/177] remove prototyping sections from LaPDXYTransform.ipynb --- .../notebooks/transform/LaPDXYTransform.ipynb | 741 ------------------ 1 file changed, 741 deletions(-) diff --git a/docs/notebooks/transform/LaPDXYTransform.ipynb b/docs/notebooks/transform/LaPDXYTransform.ipynb index 358edd31..d87b5dcb 100644 --- a/docs/notebooks/transform/LaPDXYTransform.ipynb +++ b/docs/notebooks/transform/LaPDXYTransform.ipynb @@ -314,747 +314,6 @@ " np.max(mpoints - points),\n", ")" ] - }, - { - "cell_type": "markdown", - "id": "dea6120b-b00c-4828-83e8-68eff644a5e8", - "metadata": {}, - "source": [ - "## Prototyping" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "0503ac38-33d2-442e-9a45-633f40bb562f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([-5., -5., 1.]), array([5.03615969, 1.94425505, 1. ]))" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pts = [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - "]\n", - "# pts = [[-5, 5]]\n", - "\n", - "pts = tr._condition_points(pts)\n", - "matrix = tr.matrix(pts, to_coords=\"mspace\")\n", - "pts = np.concatenate(\n", - " (pts, np.ones((pts.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "results = np.einsum(\"kmn,kn->km\", matrix, pts)[:-1,...]\n", - "ii = 1\n", - "# pts[ii, ...]\n", - "(pts[ii,...], results[ii,...])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "48b03845-2742-46f7-91d4-6dfa28ef3b0c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[-0.99930845, 0. , 0.03961743],\n", - " [ 0.03718358, 0. , 2.13017296],\n", - " [ 0. , 0. , 1. ]])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "matrix[ii, ...]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "53a821b5-893f-4edf-93f0-2720ff5e8832", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([-5., -5.]), array([[5.03615969, 1.94425505]]))" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(\n", - " pts[ii, :-1],\n", - " tr(pts[ii, :-1], to_coords=\"mspace\"),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "427ec57e-aca1-4d67-82ca-c0256bdae944", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[5.03615969, 1.94425505]])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tr(pts[ii, :-1], to_coords=\"mspace\")" - ] - }, - { - "cell_type": "markdown", - "id": "bad1ea07-e6cd-4261-9baf-abdd685d35f3", - "metadata": {}, - "source": [ - "## Testing Matrix Math" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "483aa574-7a44-41b4-b2a4-3a980145a91b", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_center = 57.288\n", - "pivot_to_drive = 134.0\n", - "drive_polarity = np.array([1.0, 1.0])\n", - "mspace_polarity = np.array([-1.0, 1.0])" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "287b1f92-4241-482e-97f2-f4ab1e41a9bf", - "metadata": {}, - "outputs": [], - "source": [ - "def matrix_to_mspace(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - "):\n", - " points = drive_polarity * points # type: np.ndarray\n", - "\n", - " theta = np.arctan(points[..., 1] / pivot_to_drive)\n", - " alpha = np.pi - theta\n", - "\n", - " npoints = 1 if points.ndim == 1 else points.shape[0]\n", - "\n", - " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T1[..., 0, 0] = np.cos(theta)\n", - " T1[..., 0, 2] = -pivot_to_drive * np.cos(theta)\n", - " T1[..., 1, 0] = -np.sin(theta)\n", - " T1[..., 1, 2] = pivot_to_drive * np.sin(theta)\n", - " T1[..., 2, 2] = 1.0\n", - "\n", - " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T2[..., 0, 0] = 1.0\n", - " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", - " T2[..., 1, 1] = 1.0\n", - " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", - " T2[..., 2, 2] = 1.0\n", - "\n", - " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T3[..., 0, 0] = 1.0\n", - " T3[..., 0, 2] = -pivot_to_center\n", - " T3[..., 1, 1] = 1.0\n", - " T3[..., 2, 2] = 1.0\n", - " \n", - " # return T1, T2, T3\n", - " \n", - " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", - " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", - " \n", - " return np.matmul(\n", - " T_mpolarity,\n", - " np.matmul(\n", - " T3,\n", - " np.matmul(\n", - " T2,\n", - " np.matmul(T1, T_dpolarity),\n", - " ),\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "8ec05264-742e-40a2-8268-efebae168cd5", - "metadata": {}, - "outputs": [], - "source": [ - "def matrix_to_drive(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - "):\n", - " points = mspace_polarity * points # type: np.ndarray\n", - "\n", - " # need to handle when x_L = pivot_to_center\n", - " # since alpha can never be 90deg we done need to worry about that case\n", - " alpha = np.arctan(points[..., 1] / (pivot_to_center + points[...,0]))\n", - "\n", - " npoints = 1 if points.ndim == 1 else points.shape[0]\n", - " \n", - " T1 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T1[..., 0, 0] = 1.0\n", - " T1[..., 0, 2] = pivot_to_center\n", - " T1[..., 1, 1] = 1.0\n", - " T1[..., 2, 2] = 1.0\n", - "\n", - " T2 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T2[..., 0, 0] = 1.0\n", - " T2[..., 0, 2] = -(pivot_to_drive + pivot_to_center) * np.cos(alpha)\n", - " T2[..., 1, 1] = 1.0\n", - " T2[..., 1, 2] = -(pivot_to_drive + pivot_to_center) * np.sin(alpha)\n", - " T2[..., 2, 2] = 1.0\n", - " \n", - " T3 = np.zeros((npoints, 3, 3)).squeeze()\n", - " T3[..., 0, 0] = 1 / np.cos(alpha)\n", - " T3[..., 0, 2] = pivot_to_drive\n", - " T3[..., 1, 2] = -pivot_to_drive * np.tan(alpha)\n", - " T3[..., 2, 2] = 1.0\n", - " \n", - " # return T1, T2, T3\n", - " \n", - " T_dpolarity = np.diag(drive_polarity.tolist() + [1.0])\n", - " T_mpolarity = np.diag(mspace_polarity.tolist() + [1.0])\n", - " \n", - " return np.matmul(\n", - " T_dpolarity,\n", - " np.matmul(\n", - " T3,\n", - " np.matmul(\n", - " T2,\n", - " np.matmul(T1, T_mpolarity),\n", - " ),\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "49b75bb5-e2cb-4703-ab52-ada40e8ee49d", - "metadata": {}, - "outputs": [], - "source": [ - "def convert(\n", - " points,\n", - " pivot_to_center,\n", - " pivot_to_drive,\n", - " drive_polarity,\n", - " mspace_polarity,\n", - " to_coord=\"drive\",\n", - "):\n", - " if not isinstance(points, np.ndarray):\n", - " points = np.array(points)\n", - " \n", - " if to_coord == \"drive\":\n", - " matrix = matrix_to_drive(\n", - " points,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - " )\n", - " elif to_coord == \"motion_space\":\n", - " matrix = matrix_to_mspace(\n", - " points,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - " )\n", - " else:\n", - " raise ValueError\n", - " \n", - " if points.ndim == 1:\n", - " points = np.concatenate((points, [1]))\n", - " return np.matmul(matrix, points)[:2]\n", - "\n", - " points = np.concatenate(\n", - " (points, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - " )\n", - " \n", - " return np.einsum(\"kmn,kn->km\", matrix, points)[..., :2]\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "830f6bd1-cc34-44ef-8a9f-cc4b2469d097", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0. , 0. ],\n", - " [-0.96447966, -4.76122797],\n", - " [-2.85283725, -9.87326849],\n", - " [ 1.00857746, 2.29892945]])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", - "\n", - "dpoints = convert(\n", - " points=point,\n", - " to_coord=\"drive\",\n", - " pivot_to_drive=pivot_to_drive,\n", - " pivot_to_center=pivot_to_center,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "dpoints" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e1664f8b-c219-4f14-b810-9544d24af201", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[-1.42108547e-14, -2.34260237e-14],\n", - " [ 1.00000000e+00, 2.00000000e+00],\n", - " [ 3.00000000e+00, 4.00000000e+00],\n", - " [-1.00000000e+00, -1.00000000e+00]])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mpoints = convert(\n", - " points=dpoints,\n", - " to_coord=\"motion_space\",\n", - " pivot_to_drive=pivot_to_drive,\n", - " pivot_to_center=pivot_to_center,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "mpoints" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "ac9140f2-f9d6-4299-bc17-19433b0ddf34", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ True, True],\n", - " [ True, True],\n", - " [ True, True],\n", - " [ True, True]])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.isclose(mpoints, point)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "59326859-411b-41b8-9082-79d2008152a1", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\Erik\\AppData\\Local\\Temp\\ipykernel_21436\\1382693254.py:1: RuntimeWarning: divide by zero encountered in divide\n", - " (mpoints - point) / point\n" - ] - }, - { - "data": { - "text/plain": [ - "array([[ -inf, -inf],\n", - " [ 2.88657986e-14, 5.99520433e-15],\n", - " [-2.36847579e-15, 2.66453526e-15],\n", - " [ 3.55271368e-15, -5.55111512e-15]])" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(mpoints - point) / point" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "0796106e-ecc2-495a-932f-05b59cc40257", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'TT' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[21]\u001b[39m\u001b[32m, line 16\u001b[39m\n\u001b[32m 12\u001b[39m pivot_to_drive=pivot_to_drive,\n\u001b[32m 13\u001b[39m drive_polarity=drive_polarity,\n\u001b[32m 14\u001b[39m mspace_polarity=mspace_polarity,\n\u001b[32m 15\u001b[39m )\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m TT.shape\n", - "\u001b[31mNameError\u001b[39m: name 'TT' is not defined" - ] - } - ], - "source": [ - "point = np.array([[0, 0], [1,2], [3,4], [-1, -1]])\n", - "# T1, T2, T3 = matrix_to_mspace(\n", - "# points=point,\n", - "# pivot_to_center=pivot_to_center,\n", - "# pivot_to_drive=pivot_to_drive,\n", - "# drive_polarity=drive_polarity,\n", - "# mspace_polarity=mspace_polarity,\n", - "# )\n", - "T = matrix_to_mspace(\n", - " points=point,\n", - " pivot_to_center=pivot_to_center,\n", - " pivot_to_drive=pivot_to_drive,\n", - " drive_polarity=drive_polarity,\n", - " mspace_polarity=mspace_polarity,\n", - ")\n", - "TT.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "88a0662f-80d7-406f-9412-bbde9a8567db", - "metadata": {}, - "outputs": [], - "source": [ - "# (\n", - "# T1[1,...],\n", - "# T2[1,...],\n", - "# T3[1,...],\n", - "# )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5e7a6431-983a-432c-ba63-d13ff0894357", - "metadata": {}, - "outputs": [], - "source": [ - "npt = np.concatenate(\n", - " (\n", - " point,\n", - " np.ones((point.shape[0], 1)),\n", - " ),\n", - " axis=1,\n", - ")\n", - "npt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce4e703d-1357-4c9a-bdc3-c38c5ea09466", - "metadata": {}, - "outputs": [], - "source": [ - "# np.matmul(TT, npt, axes=\"(k,m,n),(k,m)->(k,n)\")\n", - "np.einsum(\"kmn,kn->km\", TT, npt)[..., :2]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a67bbad7-d5c7-4ff6-836c-be94b2837187", - "metadata": {}, - "outputs": [], - "source": [ - "point" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "67082e99-d5a0-49c8-a28b-2ab0e08717fa", - "metadata": {}, - "outputs": [], - "source": [ - "P = np.diag([-1, -1, 1])\n", - "(\n", - " P,\n", - " np.linalg.inv(P),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cac88c7f-beec-4ff7-98ad-d4d2d805f952", - "metadata": {}, - "outputs": [], - "source": [ - "M = np.zeros((3, 3))\n", - "M[0,0] = 1\n", - "M[0,2] = -50\n", - "M[1,1] = 1\n", - "M[2,2] = 1\n", - "\n", - "(\n", - " M,\n", - " np.linalg.inv(M),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "377c98d5-5de0-4c83-b81a-714a7bda27b1", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b8e8b58-b8e4-41ba-96a5-7f906204df89", - "metadata": {}, - "outputs": [], - "source": [ - "probe_axis_offset = 4.\n", - "pivot_to_drive = 20\n", - "pivot_to_center = 40" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b48262ae-75a3-499c-9d74-e2de4d0fd264", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.array([\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0],\n", - " [-5, 0],\n", - " [5, 0],\n", - "])\n", - "points" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a4493a4-4fd2-405b-b2fb-8899e6029255", - "metadata": {}, - "outputs": [], - "source": [ - "sine_alpha = probe_axis_offset / np.sqrt(\n", - " pivot_to_drive**2\n", - " + (-probe_axis_offset + points[..., 1])**2\n", - ")\n", - "alpha = np.arcsin(sine_alpha)\n", - "np.degrees(alpha)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "04b63d69-9d0b-478b-a58e-76a096de7da4", - "metadata": {}, - "outputs": [], - "source": [ - "tan_beta = (-probe_axis_offset + points[..., 1]) / -pivot_to_drive\n", - "beta = np.arctan(tan_beta)\n", - "np.degrees(beta)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1c9eed1c-4b2a-48e8-9772-3b90920577c7", - "metadata": {}, - "outputs": [], - "source": [ - "theta = beta - alpha\n", - "theta" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a0f0cfd-af7f-4ecd-8e5b-6dbc73bdcd9f", - "metadata": {}, - "outputs": [], - "source": [ - "T0 = np.zeros((points.shape[0], 3, 3)).squeeze()\n", - "T0[..., 0, 0] = np.cos(theta)\n", - "T0[..., 0, 2] = -pivot_to_center * (1 - np.cos(theta))\n", - "T0[..., 1, 0] = np.sin(theta)\n", - "T0[..., 1, 2] = pivot_to_center * np.sin(theta)\n", - "T0[..., 2, 2] = 1.0\n", - "T0[0,...]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "39cffcd6-2c05-416f-8ff1-6cce04d596a4", - "metadata": {}, - "outputs": [], - "source": [ - "pts = np.concatenate(\n", - " (points, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "mpoints = np.einsum(\"kmn,kn->km\", T0, pts)[...,:-1]\n", - "mpoints" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4a263dd6-b393-4bbc-8359-568c8495d511", - "metadata": {}, - "outputs": [], - "source": [ - "tan_theta = mpoints[...,1]/(mpoints[...,0]+pivot_to_center)\n", - "theta = -np.arctan(tan_theta)\n", - "np.degrees(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "25bc8990-cc13-456b-a4dc-0b0bed440c2b", - "metadata": {}, - "outputs": [], - "source": [ - "TI = np.zeros((points.shape[0], 3, 3)).squeeze()\n", - "TI[..., 0, 2] = np.sqrt(mpoints[...,1]**2 +(pivot_to_center + mpoints[...,0])**2) - pivot_to_center\n", - "TI[..., 1, 2] = pivot_to_axis * np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))\n", - "TI[..., 2, 2] = 1.0\n", - "TI[0,...]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "90ac5781-d195-4019-bb2d-08dd721e7487", - "metadata": {}, - "outputs": [], - "source": [ - "mpts = np.concatenate(\n", - " (mpoints, np.ones((points.shape[0], 1))),\n", - " axis=1,\n", - ")\n", - "pts = mpoints = np.einsum(\"kmn,kn->km\", TI, mpts)[...,:-1]\n", - "pts" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05d4a1fa-cecc-4e64-97d0-b02bb8b11dd7", - "metadata": {}, - "outputs": [], - "source": [ - "probe_axis_offset * (1 - (1/np.cos(theta)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6112917f-f237-46bc-a9ca-c215d2a1aef1", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_axis*np.tan(theta) + probe_axis_offset * (1 - (1/np.cos(theta)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "94ed0b37-ea33-4639-8f72-70008e4ac98e", - "metadata": {}, - "outputs": [], - "source": [ - "pivot_to_axis*np.tan(theta) - probe_axis_offset * np.cos(theta) + probe_axis_offset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5853946-24e3-4286-aae6-aa48a59af280", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 57c2f890658cf12479ca2fb0f3cf129b1430a45c Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 18 May 2026 11:19:00 -0700 Subject: [PATCH 022/177] rename LaPDXYZTransform_.ipynb -> LaPDXYZTransform.ipynb --- .../transform/LaPDXYZTransform.ipynb | 1054 +++++++++++++++++ .../transform/LaPDXYZTransform_.ipynb | 987 --------------- 2 files changed, 1054 insertions(+), 987 deletions(-) create mode 100644 docs/notebooks/transform/LaPDXYZTransform.ipynb delete mode 100644 docs/notebooks/transform/LaPDXYZTransform_.ipynb diff --git a/docs/notebooks/transform/LaPDXYZTransform.ipynb b/docs/notebooks/transform/LaPDXYZTransform.ipynb new file mode 100644 index 00000000..f30f5681 --- /dev/null +++ b/docs/notebooks/transform/LaPDXYZTransform.ipynb @@ -0,0 +1,1054 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fefb950-9158-4c62-b593-cda353ff5db1", + "metadata": {}, + "source": [ + "# Demo of `LaPDXYZTransform`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " from bapsf_motion.transform import LaPDXYZTransform\n", + "except ModuleNotFoundError:\n", + " from pathlib import Path\n", + "\n", + " HERE = Path().cwd()\n", + " BAPSF_MOTION = (HERE / \"..\" / \"..\" / \"..\" ).resolve()\n", + " sys.path.append(str(BAPSF_MOTION))\n", + " \n", + " from bapsf_motion.transform import LaPDXYZTransform" + ] + }, + { + "cell_type": "markdown", + "id": "f79461eb-d3a0-48bc-9a1e-13c6e5fee6db", + "metadata": {}, + "source": [ + "General input keyword arguments to use for the demo.\n", + "\n", + "These input arguments are similar to a setup on an East port of the LaPD." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "15dd3644-c856-46c2-9f6f-846956b435d4", + "metadata": {}, + "outputs": [], + "source": [ + "input_kwargs = {\n", + " \"pivot_to_center\": 58.771,\n", + " \"pivot_to_xzcross\": 142.4804, # 0.81\" + 54.9cm + 0.75\" + 79.3cm + 1.7\"\n", + " \"probe_axis_offset\": 30.47, # 0.5\" + 15.1cm + 5.4cm + 8.7cm\n", + " \"table_pivot_to_zlead_screw\": 12.488, # 0.5\" + 2.5cm + 4.4cm + 1.7\"\n", + " \"drive_polarity\": [1, -1, 1],\n", + " \"mspace_polarity\": [-1, 1, -1],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "af05b4fc-afe4-4a5e-81a5-d11d95f022a4", + "metadata": {}, + "source": [ + "## Transfrom from Motion Space to Drive Space to Motion Space\n", + "\n", + "Let's show the transform can successfully convert from the motion space to the drive space, and back.\n", + "\n", + "Instantiate the transform class." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "768e0851-57e5-4b44-9f0f-541741376aeb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pivot_to_xzcross': 142.4804,\n", + " 'table_pivot_to_zlead_screw': 12.488,\n", + " 'mspace_polarity': [-1, 1, -1],\n", + " 'probe_axis_offset': 30.47,\n", + " 'pivot_to_center': 58.771,\n", + " 'drive_polarity': [1, -1, 1],\n", + " 'type': 'lapd_xyz'}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tr = LaPDXYZTransform((\"x\", \"y\", \"z\"), **input_kwargs)\n", + "tr.config" + ] + }, + { + "cell_type": "markdown", + "id": "f540f0d3-4ce5-4f63-885e-1ca1584142a9", + "metadata": {}, + "source": [ + "Construct a set of points in the motion space to convert.\n", + "\n", + "`points` will be an array of points defining the boundary of an XY-plane, XZ-plane, and YZ-plane. In that order." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ea80e434-af3a-42fe-b590-b4744f382ec5", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((3*40, 3))\n", + "npoints_in_plane = 40\n", + "delta = 10\n", + "\n", + "# xy-plane\n", + "points[0:10, 0] = np.linspace(-delta, delta, num=10, endpoint=False)\n", + "points[0:10, 1] = delta * np.ones(10)\n", + "points[10:20, 0] = delta * np.ones(10)\n", + "points[10:20, 1] = np.linspace(delta, -delta, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(delta, -delta, num=10, endpoint=False)\n", + "points[20:30, 1] = -delta * np.ones(10)\n", + "points[30:40, 0] = -delta * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-delta, delta, num=10, endpoint=False)\n", + "\n", + "# xz-plane\n", + "points[40:80, 0] = points[0:40, 0]\n", + "points[40:80, 2] = points[0:40, 1]\n", + "\n", + "# yz-plane\n", + "points[80:, 1] = points[0:40, 0]\n", + "points[80:, 2] = points[0:40, 1]\n", + "\n", + "# Define a set of \"key\" points, which are just the corner points\n", + "# of each plane.\n", + "key_points = np.array(\n", + " [\n", + " # xy-corners\n", + " [-delta, delta, 0],\n", + " [-delta, -delta, 0],\n", + " [delta, -delta, 0],\n", + " [delta, delta, 0],\n", + " # xz-corners\n", + " [-delta, 0, delta],\n", + " [-delta, 0, -delta],\n", + " [delta, 0, -delta],\n", + " [delta, 0, delta],\n", + " # yz-corners\n", + " [0, -delta, delta],\n", + " [0, -delta, -delta],\n", + " [0, delta, -delta],\n", + " [0, delta, delta],\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "de26ee8e-3926-4f2a-910f-a800b7cdb152", + "metadata": {}, + "source": [ + "Calcualte the drive space points `dpoints` and return to motion space points `mpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6d03325f-6e57-445c-9717-19fb98ea29d6", + "metadata": {}, + "outputs": [], + "source": [ + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "4eaa3771-3571-4683-aae8-bd8d2f80b96e", + "metadata": {}, + "source": [ + "Plot the transform" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "a0c8f222-15a8-45f5-b20e-ec475ba3d854", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figwidth\n", + "fig, axs = plt.subplots(\n", + " 3, 3, figsize=[figwidth, figheight], layout=\"constrained\",\n", + ")\n", + "\n", + "axs[0, 0].set_title(\"Motion Space\")\n", + "axs[0, 1].set_title(\"Drive Space\")\n", + "axs[0, 2].set_title(\"Drive Space\")\n", + "\n", + "dkp = tr(key_points, to_coords=\"drive\")\n", + " \n", + "for ii in range(3):\n", + " if ii == 0: # xy-plane\n", + " p0 = 0\n", + " p1 = [1, 1, 2]\n", + " \n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Z\")\n", + " elif ii == 1: # xz-plane\n", + " p0 = 0\n", + " p1 = [2, 2, 1]\n", + "\n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", + "\n", + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Y\")\n", + " else: # yz-plane\n", + " p0 = 1\n", + " p1 = [2, 2, 0]\n", + " \n", + " axs[ii, 0].set_xlabel(\"Y\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", + "\n", + " axs[ii, 1].set_xlabel(\"Y\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"Y\")\n", + " axs[ii, 2].set_ylabel(\"X\")\n", + " \n", + " i_start = ii * npoints_in_plane\n", + " i_stop = i_start + npoints_in_plane\n", + " axs[ii, 0].fill(points[i_start:i_stop, p0], points[i_start:i_stop, p1[0]])\n", + " axs[ii, 1].fill(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[1]])\n", + " axs[ii, 2].plot(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[2]], \"-o\")\n", + "\n", + " \n", + " i_start = ii * 4\n", + " i_stop = i_start + 4\n", + " colors = [\"red\", \"orange\", \"black\", \"purple\"]\n", + "\n", + " axs[ii, 0].scatter(key_points[i_start:i_stop, p0], key_points[i_start:i_stop, p1[0]], c=colors)\n", + " axs[ii, 1].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[1]], c=colors)\n", + " axs[ii, 2].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[2]], c=colors, zorder=10)" + ] + }, + { + "cell_type": "markdown", + "id": "ea80f579-75af-47dc-a664-0c23b35d9ee0", + "metadata": {}, + "source": [ + "How close are the points after the round trip conversion? Let's plot the difference." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "6e52c2b4-5970-49dd-a21a-e8b84b3fb0e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "fig, ax = plt.subplots(1, 1, figsize=[figwidth, figheight])\n", + "\n", + "ax.plot(points[..., 0] - mpoints[..., 0], \"-o\", label=\"X\")\n", + "ax.plot(points[..., 1] - mpoints[..., 1], \"-o\", label=\"Y\")\n", + "ax.plot(points[..., 2] - mpoints[..., 2], \"-o\", label=\"Z\")\n", + "\n", + "ax.set_xlabel(\"Index\")\n", + "ax.set_ylabel(\"Diff\")\n", + "ax.set_title(\"Difference in Motion --> Drive --> Motion Conversion\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "d95b6680-c8df-4be5-8b8e-a8915f553ad8", + "metadata": {}, + "source": [ + "Here we can see the points are virtually identical, with a difference on the order of $10^{-14}$." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "76f1c97e-a944-4d8b-91a6-9cc328671b5f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "f4449700-7100-4c29-946c-4d22cea7ee0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(1.1546319456101628e-14)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "bd3dd84b-5a9a-48c1-b304-c62f84976b7a", + "metadata": {}, + "source": [ + "## Transform from Drive Sapce to Motion Space to Drive Space\n", + "\n", + "Let's show the transform can successfully convert from the drive space to the motion space, and back.\n", + "\n", + "Using the same transform and initial points in the previous section, lets construct the motion space points `mpoints` and return to drive space points `dpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e87c5d28-ec61-4a90-97cd-89db765fbd2c", + "metadata": {}, + "outputs": [], + "source": [ + "mpoints = tr(points, to_coords=\"motion_space\")\n", + "dpoints = tr(mpoints, to_coords=\"drive\")" + ] + }, + { + "cell_type": "markdown", + "id": "3529a742-cc81-44b9-ac1d-e3cf9e3cbc9a", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4e61105e-3788-4edb-a54c-9a582f04f745", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Drive Space\")\n", + "axs[1].set_title(\"Motion Space\")\n", + "axs[2].set_title(\"Drive Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(mpoints[...,0], mpoints[...,1])\n", + "axs[2].fill(dpoints[...,0], dpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " mpt = tr(pt, to_coords=\"motion_space\")\n", + " dpt = tr(mpt, to_coords=\"drive\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", + " axs[2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "4b0115f5-6e20-41d8-ae82-72452a1a831d", + "metadata": {}, + "source": [ + "Are the returned drive space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(points, dpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(1.5987211554602254e-14)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(np.abs(points - dpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "a6ac8c55-eca5-44f7-9579-e7b61bdab6f0", + "metadata": {}, + "source": [ + "## Transform Can Droop Correct\n", + "\n", + "The transform `LaPD6KTransfrom` also incorporates droop correction via the `LaPDXYDroopCorrect` class.\n", + "\n", + "Instantiate the transfrom with droop correction enabled." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1e2e4537-cb72-4d9a-b457-6f3160771261", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'LaPD6KTransform' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m tr = LaPD6KTransform(\n\u001b[32m 2\u001b[39m (\u001b[33m\"x\"\u001b[39m, \u001b[33m\"y\"\u001b[39m),\n\u001b[32m 3\u001b[39m **{\n\u001b[32m 4\u001b[39m **input_kwargs,\n", + "\u001b[31mNameError\u001b[39m: name 'LaPD6KTransform' is not defined" + ] + } + ], + "source": [ + "tr = LaPD6KTransform(\n", + " (\"x\", \"y\"),\n", + " **{\n", + " **input_kwargs,\n", + " \"droop_correct\": True,\n", + " \"droop_scale\": 2.0,\n", + " },\n", + ")\n", + "tr.config" + ] + }, + { + "cell_type": "markdown", + "id": "ac8d5ed5-c6e1-4632-9806-63d51d57fc63", + "metadata": {}, + "source": [ + "Construct a set of points for the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a4a8740-5b79-45cc-b67f-311d72caeb66", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "key_points = np.array(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3dc12ae7-0ef0-4eba-a652-e4980d76a61a", + "metadata": {}, + "source": [ + "Calcualte the drive space points `dpoints` and return to motion space points`mpoints`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b9dc74c-298b-46db-b06b-8fe81d29b936", + "metadata": {}, + "outputs": [], + "source": [ + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "25f03021-a4f1-493c-b5f9-39b675857c49", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aafc667-d47e-4a3f-8f18-646b599bfc53", + "metadata": {}, + "outputs": [], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Motion Space\")\n", + "axs[1].set_title(\"Drive Space\")\n", + "axs[2].set_title(\"Motion Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", + "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " dpt = tr(pt, to_coords=\"drive\")\n", + " mpt = tr(dpt, to_coords=\"motion_space\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "c7293afa-e931-499d-84ad-f7f3f7c696e4", + "metadata": {}, + "source": [ + "Are the returned motion space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8dac0d50-a14d-4319-8630-fa9c1a750f09", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4995cb9b-7c5e-4660-95c1-e1fbe2b73283", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "8d84d8dd-8ec5-4c64-9696-3162096150f8", + "metadata": {}, + "source": [ + "## Configure for West Side Deployment\n", + "\n", + "The default values for `LaPD6KTransform` is for an East side depolyment on the LaPD. However, the transfrom can be configured for a West side deployment by using a negative `pivot_to_center` and `[1, 1]` for the `mspace_polarity`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", + "metadata": {}, + "outputs": [], + "source": [ + "tr = LaPD6KTransform(\n", + " (\"x\", \"y\"),\n", + " **{\n", + " **input_kwargs,\n", + " \"pivot_to_center\": -58.771,\n", + " \"mspace_polarity\": [1, 1],\n", + " \"droop_correct\": True,\n", + " \"droop_scale\": 2.0,\n", + " },\n", + ")\n", + "tr.config" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5853946-24e3-4286-aae6-aa48a59af280", + "metadata": {}, + "outputs": [], + "source": [ + "points = np.zeros((40, 2))\n", + "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "points[0:10, 1] = 5 * np.ones(10)\n", + "points[10:20, 0] = 5 * np.ones(10)\n", + "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", + "points[20:30, 1] = -5 * np.ones(10)\n", + "points[30:40, 0] = -5 * np.ones(10)\n", + "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", + "\n", + "key_points = np.array(\n", + " [\n", + " [-5, 5],\n", + " [-5, -5],\n", + " [5, -5],\n", + " [5, 5],\n", + " [0, 0]\n", + " ],\n", + ")\n", + "\n", + "dpoints = tr(points, to_coords=\"drive\")\n", + "mpoints = tr(dpoints, to_coords=\"motion_space\")" + ] + }, + { + "cell_type": "markdown", + "id": "e0059a4f-f084-4d16-921c-6d2dd79fa3e5", + "metadata": {}, + "source": [ + "Plot the transform." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "024c67c5-b442-40ee-8cd4-3c57a9c9e21a", + "metadata": {}, + "outputs": [], + "source": [ + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "figheight = figheight\n", + "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "\n", + "axs[0].set_title(\"Motion Space\")\n", + "axs[1].set_title(\"Drive Space\")\n", + "axs[2].set_title(\"Motion Space Return\")\n", + "\n", + "for ii in range(3):\n", + " axs[ii].set_xlabel(\"X\")\n", + " axs[ii].set_ylabel(\"Y\")\n", + "\n", + "axs[0].fill(points[...,0], points[...,1])\n", + "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", + "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", + "\n", + "for pt, color in zip(\n", + " key_points.tolist(),\n", + " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", + "):\n", + " dpt = tr(pt, to_coords=\"drive\")\n", + " mpt = tr(dpt, to_coords=\"motion_space\")\n", + " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", + " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", + " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" + ] + }, + { + "cell_type": "markdown", + "id": "4613643d-b83f-4f80-9c58-3053d48b43ad", + "metadata": {}, + "source": [ + "Are the returned motion space points \"identical\" to the starting points?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62a2a57c-f919-4ae1-8fc3-1923c54d8c49", + "metadata": {}, + "outputs": [], + "source": [ + "np.allclose(points, mpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "627126b3-419e-4a1b-8c28-7a45499709c8", + "metadata": {}, + "outputs": [], + "source": [ + "np.max(np.abs(points - mpoints))" + ] + }, + { + "cell_type": "markdown", + "id": "8165d9e8-797e-4f76-885b-fabd164081c4", + "metadata": { + "tags": [] + }, + "source": [ + "## The Algorithms\n", + "\n", + "To start we will use $(e_0, e_1)$ to represent the drive space coordinates and $(x, y)$ to represent the motion space coordinates.\n", + "\n", + "
\n", + "\"top_level_cartoon\"\n", + "
Top-Level Cartoon of the Drive and Motion Space Relationship
\n", + "
\n", + "\n", + "**Note:** The motion space x-axis points towards the the LaPD -X when the probe drive is deployed on the East side of the machine. This is why the East side operation requires `mspace_polarity = [-1, 1]`, and the West side requires `mspace_polarity = [1, 1]`." + ] + }, + { + "cell_type": "markdown", + "id": "8c724e04-242d-4b3a-be03-f8c4dee2fffa", + "metadata": { + "tags": [] + }, + "source": [ + "### Algorithm: Drive to Motion Space\n", + "\n", + "The key parameter we need to determine to convert the drive space coordinates to the motion space coordinates is the angle $\\theta$, which is the angle the probe shaft makes with the horizontal. Let's consider the following diagram...\n", + "\n", + "
\n", + "\"drive_overview\"\n",\n", + "
Drive Space Overview
\n", + "
\n", + "\n", + "Here...\n", + "\n", + "- $d_o$ = `probe_axis_offset` which is the perpendicular distance from the probe axis to the pinion location on the horizontal arm of the 6K probe drive.\n", + "- $R_A$ = `six_k_arm_length` which is the length of the vertical hanging arm of the 6K probe drive.\n", + "- $\\beta$ is the angular drop of the pinion location from the probe drive shaft with respect to the ball valve\n", + "\n", + " $$\n", + " tan\\,\\beta = \\frac{d_o}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}=\\frac{\\texttt{probe}\\_\\texttt{axis}\\_\\texttt{offset}}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", + " $$\n", + "\n", + "- $R_P$ = `pivot_to_drive_pinion` the radial distance of the probe drive pinion from the ball valve pivot\n", + " \n", + " $$\n", + " R_P^2 = d_o^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", + " $$\n", + " \n", + "- The vertical pinoin location above the horizontal is given by $R_A - d_o + e_1$, assuming $e_1=0$ when the probe shaft is horizontal.\n", + "- $\\gamma$ is the angle the vertical pinion makes with respect to the ball valve pivot and the horizontal\n", + "\n", + " $$\n", + " \\tan\\,\\gamma = \\frac{R_A - d_o + e_1}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", + " $$\n" + ] + }, + { + "cell_type": "markdown", + "id": "979114a2-267d-4142-a6ae-d1ad13c480eb", + "metadata": {}, + "source": [ + "Now adopt a reference frame where the line intersecting the ball valve pivot and probe drive vertical (grey dashed above) is rotated to the horizontal and the ball valve is the origin. In this reference frame will use a coordinate system $(s_0, s_1)$. In this system the pinion point is located at the intersection of two circles:\n", + "\n", + "1. The circle about the ball valve pivot of radius $R_P$.\n", + " \n", + " $$\n", + " R_P^2 = s_0^2 + s_1^2\n", + " $$\n", + " \n", + "2. The circle about the vertical pinion of radius $R_A$.\n", + "\n", + " $$\n", + " R_A^2 = (s_0 + L)^2 + s_1^2\\\\\n", + " \\text{where}\\; L^2 = (R_A - d_o + e_1)^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", + " $$\n", + "\n", + "Solving this system of equations we can calcualte the location of the pinion and, thus, the angle $\\phi$ depicted in the Drive Space Overview figure.\n", + "\n", + "$$\n", + "\\tan^2 \\phi = \\left(\\frac{2\\,L\\,R_P}{R_A^2-R_P^2-L^2}\\right)^2 - 1\n", + "$$\n", + "\n", + "Knowing $\\phi$, the signed angle $\\theta$ can be expressed as\n", + "\n", + "$$\n", + "\\theta = \\gamma +|\\beta|-|\\phi|\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "ff994b3b-3eca-498d-8b60-38129b83970c", + "metadata": {}, + "source": [ + "Taking $\\theta$ and the radial projection of the probe into the motion space as $r=D_C + e_0$, where $D_C$ is the distans from the ball valve pivot to the motion space origin `pivot_to_center`, then the motion space coordinates can be expressed as\n", + "\n", + "$$\n", + "x = (\\cos\\theta) \\, e_0 + D_C \\,(\\cos\\theta-1)\\\\\n", + "y = (-\\sin\\theta)\\, e_0 - D_C \\,\\sin\\theta\n", + "$$\n", + "\n", + "and expressed as the `_matrix_to_motion_space`\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " x \\\\ y \\\\ 1\n", + "\\end{bmatrix}\n", + "=\n", + "\\begin{bmatrix}\n", + " \\cos\\theta & 0 & D_C \\, (\\cos\\theta - 1)\\\\\n", + " -\\sin\\theta & 0 & -D_C \\, \\sin\\theta\\\\\n", + " 0 & 0 & 1\\\\\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + " e_0 \\\\ e_1 \\\\ 1\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "9a2d6321-c59d-4771-9676-26600d4acf33", + "metadata": {}, + "source": [ + "Obviously this not a perfectly clean expression since $\\theta$ depents on $e_1$. However, this is the expression that must be used to work with the archatecture desinged int `BaseTransform`." + ] + }, + { + "cell_type": "markdown", + "id": "1c8d4e25-6b31-4acd-8070-610c9b87d829", + "metadata": {}, + "source": [ + "### Algorithm: Motion to Drive Space\n", + "\n", + "In order to convert from the motion space to the drive space the key parameter to determine is the location of the probe drive pinion. Again this boils down to determining the angle $\\theta$, since the pinion is always a distance $R_P$ from the ball valve pivot and at an angle of $\\theta - |\\beta|$.\n", + "\n", + "Knowing the motion space coordinates $(x, y)$ the angle $\\theta$ can be written as..\n", + "\n", + "$$\n", + "\\tan\\theta = -\\frac{y}{D_C + x}\n", + "$$\n", + "\n", + "Then the probe drive pinion is located at the following position with the ball valve coordinate system $(s_0, s_1)$\n", + "\n", + "$$\n", + "s_0 = -R_P \\cos(\\theta - |\\beta|)\\\\\n", + "s_1 = R_P \\sin(\\theta - |\\beta|)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "d24296ce-b36f-47f9-afa0-a8a25cedf8f4", + "metadata": {}, + "source": [ + "Now we can determine the angle $\\alpha$ in which the probe drive arm leans forward.\n", + "\n", + "$$\n", + "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} + s_0}{R_A}\n", + "= \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\n", + "$$\n", + "$$\n", + "\\cos\\alpha = \\frac{R_A - d_o + e_1 - s_1}{R_A}\n", + "= \\frac{R_A - d_o + e_1 - R_P \\sin(\\theta - |\\beta|)}{R_A}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "e9ae34a6-c658-415c-8950-5c28357b497a", + "metadata": {}, + "source": [ + "Now we can cast the drive space coordinates as\n", + "\n", + "$$\n", + "e_0 = \\frac{1}{\\cos\\theta}x + D_C\\left(\\frac{1}{\\cos\\theta}-1\\right)\\\\\n", + "e_1 = R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\\\\\n", + "\\tan\\theta = -\\frac{y}{D_C + x}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "70dde653-1b6a-4879-a5b3-daf15d212968", + "metadata": {}, + "source": [ + "The does yield a rather ugly, but functional, transformation matrix of\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " e_0 \\\\ e_1 \\\\ 1\n", + "\\end{bmatrix}\n", + "=\n", + "\\begin{bmatrix}\n", + " \\frac{1}{\\cos\\theta} & 0 & D_C \\, \\left(\\frac{1}{\\cos\\theta} - 1\\right)\\\\\n", + " 0 & 0 & R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\\\\\n", + " 0 & 0 & 1\\\\\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + " x \\\\ y \\\\ 1\n", + "\\end{bmatrix}\n", + "$$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/notebooks/transform/LaPDXYZTransform_.ipynb b/docs/notebooks/transform/LaPDXYZTransform_.ipynb deleted file mode 100644 index 3c0dd7b6..00000000 --- a/docs/notebooks/transform/LaPDXYZTransform_.ipynb +++ /dev/null @@ -1,987 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7fefb950-9158-4c62-b593-cda353ff5db1", - "metadata": {}, - "source": [ - "# Demo of `LaPDXYZTransform`" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import sys\n", - "\n", - "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", - "metadata": {}, - "outputs": [], - "source": [ - "try:\n", - " from bapsf_motion.transform import LaPDXYZTransform\n", - "except ModuleNotFoundError:\n", - " from pathlib import Path\n", - "\n", - " HERE = Path().cwd()\n", - " BAPSF_MOTION = (HERE / \"..\" / \"..\" / \"..\" ).resolve()\n", - " sys.path.append(str(BAPSF_MOTION))\n", - " \n", - " from bapsf_motion.transform import LaPDXYZTransform" - ] - }, - { - "cell_type": "markdown", - "id": "f79461eb-d3a0-48bc-9a1e-13c6e5fee6db", - "metadata": {}, - "source": [ - "General input keyword arguments to use for the demo." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "15dd3644-c856-46c2-9f6f-846956b435d4", - "metadata": {}, - "outputs": [], - "source": [ - "input_kwargs = {\n", - " \"pivot_to_center\": 58.771,\n", - " \"pivot_to_xzcross\": 142.4804, # 0.81\" + 54.9cm + 0.75\" + 79.3cm + 1.7\"\n", - " # \"pivot_to_xzcross\": 58.771,\n", - " \"probe_axis_offset\": 30.47, # 0.5\" + 15.1cm + 5.4cm + 8.7cm\n", - " \"table_pivot_to_zlead_screw\": 12.488, # 0.5\" + 2.5cm + 4.4cm + 1.7\"\n", - " \"drive_polarity\": [1, -1, 1],\n", - " \"mspace_polarity\": [-1, 1, -1],\n", - "}\n" - ] - }, - { - "cell_type": "markdown", - "id": "af05b4fc-afe4-4a5e-81a5-d11d95f022a4", - "metadata": {}, - "source": [ - "## Transfrom from Motion Space to Drive Space to Motion Space\n", - "\n", - "Let's show the transform can successfully convert from the motion space to the drive space, and back.\n", - "\n", - "Instantiate the transform class." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "768e0851-57e5-4b44-9f0f-541741376aeb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'mspace_polarity': [-1, 1, -1],\n", - " 'pivot_to_center': 58.771,\n", - " 'table_pivot_to_zlead_screw': 12.488,\n", - " 'type': 'lapd_xyz',\n", - " 'drive_polarity': [1, -1, 1],\n", - " 'pivot_to_xzcross': 142.4804,\n", - " 'probe_axis_offset': 30.47}" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tr = LaPDXYZTransform((\"x\", \"y\", \"z\"), **input_kwargs)\n", - "tr.config" - ] - }, - { - "cell_type": "markdown", - "id": "f540f0d3-4ce5-4f63-885e-1ca1584142a9", - "metadata": {}, - "source": [ - "Construct a set of points in the motion space to convert." - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "ea80e434-af3a-42fe-b590-b4744f382ec5", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.zeros((3*40, 3))\n", - "npoints_in_plane = 40\n", - "delta = 10\n", - "\n", - "# xy-plane\n", - "points[0:10, 0] = np.linspace(-delta, delta, num=10, endpoint=False)\n", - "points[0:10, 1] = delta * np.ones(10)\n", - "points[10:20, 0] = delta * np.ones(10)\n", - "points[10:20, 1] = np.linspace(delta, -delta, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(delta, -delta, num=10, endpoint=False)\n", - "points[20:30, 1] = -delta * np.ones(10)\n", - "points[30:40, 0] = -delta * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-delta, delta, num=10, endpoint=False)\n", - "\n", - "# xz-plane\n", - "points[40:80, 0] = points[0:40, 0]\n", - "points[40:80, 2] = points[0:40, 1]\n", - "\n", - "# yz-plane\n", - "points[80:, 1] = points[0:40, 0]\n", - "points[80:, 2] = points[0:40, 1]\n", - "\n", - "key_points = np.array(\n", - " [\n", - " # xy-corners\n", - " [-delta, delta, 0],\n", - " [-delta, -delta, 0],\n", - " [delta, -delta, 0],\n", - " [delta, delta, 0],\n", - " # xz-corners\n", - " [-delta, 0, delta],\n", - " [-delta, 0, -delta],\n", - " [delta, 0, -delta],\n", - " [delta, 0, delta],\n", - " # yz-corners\n", - " [0, -delta, delta],\n", - " [0, -delta, -delta],\n", - " [0, delta, -delta],\n", - " [0, delta, delta],\n", - " ],\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "de26ee8e-3926-4f2a-910f-a800b7cdb152", - "metadata": {}, - "source": [ - "Calcualte the drive space points `dpoints` and return to motion space points `mpoints`." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "6d03325f-6e57-445c-9717-19fb98ea29d6", - "metadata": {}, - "outputs": [], - "source": [ - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")" - ] - }, - { - "cell_type": "markdown", - "id": "4eaa3771-3571-4683-aae8-bd8d2f80b96e", - "metadata": {}, - "source": [ - "Plot the transform" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "a0c8f222-15a8-45f5-b20e-ec475ba3d854", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = 3*figheight\n", - "fig, axs = plt.subplots(3, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0, 0].set_title(\"Motion Space\")\n", - "axs[0, 1].set_title(\"Drive Space\")\n", - "axs[0, 2].set_title(\"Drive Space\")\n", - "\n", - "dkp = tr(key_points, to_coords=\"drive\")\n", - " \n", - "for ii in range(3):\n", - " if ii == 0: # xy-plane\n", - " p0 = 0\n", - " p1 = [1, 1, 2]\n", - " \n", - " axs[ii, 0].set_xlabel(\"X\")\n", - " axs[ii, 0].set_ylabel(\"Y\")\n", - " \n", - " axs[ii, 1].set_xlabel(\"X\")\n", - " axs[ii, 1].set_ylabel(\"Y\")\n", - " \n", - " axs[ii, 2].set_xlabel(\"X\")\n", - " axs[ii, 2].set_ylabel(\"Z\")\n", - " elif ii == 1: # xz-plane\n", - " p0 = 0\n", - " p1 = [2, 2, 1]\n", - "\n", - " axs[ii, 0].set_xlabel(\"X\")\n", - " axs[ii, 0].set_ylabel(\"Z\")\n", - "\n", - " axs[ii, 1].set_xlabel(\"X\")\n", - " axs[ii, 1].set_ylabel(\"Z\")\n", - " \n", - " axs[ii, 2].set_xlabel(\"X\")\n", - " axs[ii, 2].set_ylabel(\"Y\")\n", - " else: # yz-plane\n", - " p0 = 1\n", - " p1 = [2, 2, 0]\n", - " \n", - " axs[ii, 0].set_xlabel(\"Y\")\n", - " axs[ii, 0].set_ylabel(\"Z\")\n", - "\n", - " axs[ii, 1].set_xlabel(\"Y\")\n", - " axs[ii, 1].set_ylabel(\"Z\")\n", - " \n", - " axs[ii, 2].set_xlabel(\"Y\")\n", - " axs[ii, 2].set_ylabel(\"X\")\n", - " \n", - " i_start = ii * npoints_in_plane\n", - " i_stop = i_start + npoints_in_plane\n", - " axs[ii, 0].fill(points[i_start:i_stop, p0], points[i_start:i_stop, p1[0]])\n", - " axs[ii, 1].fill(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[1]])\n", - " axs[ii, 2].plot(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[2]], \"-o\")\n", - "\n", - " \n", - " i_start = ii * 4\n", - " i_stop = i_start + 4\n", - " colors = [\"red\", \"orange\", \"black\", \"purple\"]\n", - "\n", - " axs[ii, 0].scatter(key_points[i_start:i_stop, p0], key_points[i_start:i_stop, p1[0]], c=colors)\n", - " axs[ii, 1].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[1]], c=colors)\n", - " axs[ii, 2].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[2]], c=colors, zorder=10)" - ] - }, - { - "cell_type": "markdown", - "id": "ea80f579-75af-47dc-a664-0c23b35d9ee0", - "metadata": {}, - "source": [ - "Plot the difference in the round trip conversion." - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "6e52c2b4-5970-49dd-a21a-e8b84b3fb0e8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(points[..., 0] - mpoints[..., 0], \"-o\", label=\"X\")\n", - "plt.plot(points[..., 1] - mpoints[..., 1], \"-o\", label=\"Y\")\n", - "plt.plot(points[..., 2] - mpoints[..., 2], \"-o\", label=\"Z\")\n", - "\n", - "ax = plt.gca()\n", - "ax.set_xlabel(\"Index\")\n", - "ax.set_ylabel(\"Diff\")\n", - "ax.set_title(\"Difference in Motion --> Drive --> Motion Conversion\")\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "d95b6680-c8df-4be5-8b8e-a8915f553ad8", - "metadata": {}, - "source": [ - "Are the returned motion space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "76f1c97e-a944-4d8b-91a6-9cc328671b5f", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, mpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f4449700-7100-4c29-946c-4d22cea7ee0f", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - mpoints))" - ] - }, - { - "cell_type": "markdown", - "id": "bd3dd84b-5a9a-48c1-b304-c62f84976b7a", - "metadata": {}, - "source": [ - "## Transform from Drive Sapce to Motion Space to Drive Space\n", - "\n", - "Let's show the transform can successfully convert from the drive space to the motion space, and back.\n", - "\n", - "Using the same transform and initial points in the previous section, lets construct the motion space points `mpoints` and return to drive space points `dpoints`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e87c5d28-ec61-4a90-97cd-89db765fbd2c", - "metadata": {}, - "outputs": [], - "source": [ - "mpoints = tr(points, to_coords=\"motion_space\")\n", - "dpoints = tr(mpoints, to_coords=\"drive\")" - ] - }, - { - "cell_type": "markdown", - "id": "3529a742-cc81-44b9-ac1d-e3cf9e3cbc9a", - "metadata": {}, - "source": [ - "Plot the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4e61105e-3788-4edb-a54c-9a582f04f745", - "metadata": {}, - "outputs": [], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0].set_title(\"Drive Space\")\n", - "axs[1].set_title(\"Motion Space\")\n", - "axs[2].set_title(\"Drive Space Return\")\n", - "\n", - "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", - "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(mpoints[...,0], mpoints[...,1])\n", - "axs[2].fill(dpoints[...,0], dpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " mpt = tr(pt, to_coords=\"motion_space\")\n", - " dpt = tr(mpt, to_coords=\"drive\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", - " axs[2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)" - ] - }, - { - "cell_type": "markdown", - "id": "4b0115f5-6e20-41d8-ae82-72452a1a831d", - "metadata": {}, - "source": [ - "Are the returned drive space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, dpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - dpoints))" - ] - }, - { - "cell_type": "markdown", - "id": "a6ac8c55-eca5-44f7-9579-e7b61bdab6f0", - "metadata": {}, - "source": [ - "## Transform Can Droop Correct\n", - "\n", - "The transform `LaPD6KTransfrom` also incorporates droop correction via the `LaPDXYDroopCorrect` class.\n", - "\n", - "Instantiate the transfrom with droop correction enabled." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1e2e4537-cb72-4d9a-b457-6f3160771261", - "metadata": {}, - "outputs": [], - "source": [ - "tr = LaPD6KTransform(\n", - " (\"x\", \"y\"),\n", - " **{\n", - " **input_kwargs,\n", - " \"droop_correct\": True,\n", - " \"droop_scale\": 2.0,\n", - " },\n", - ")\n", - "tr.config" - ] - }, - { - "cell_type": "markdown", - "id": "ac8d5ed5-c6e1-4632-9806-63d51d57fc63", - "metadata": {}, - "source": [ - "Construct a set of points for the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a4a8740-5b79-45cc-b67f-311d72caeb66", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "key_points = np.array(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "3dc12ae7-0ef0-4eba-a652-e4980d76a61a", - "metadata": {}, - "source": [ - "Calcualte the drive space points `dpoints` and return to motion space points`mpoints`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b9dc74c-298b-46db-b06b-8fe81d29b936", - "metadata": {}, - "outputs": [], - "source": [ - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")" - ] - }, - { - "cell_type": "markdown", - "id": "25f03021-a4f1-493c-b5f9-39b675857c49", - "metadata": {}, - "source": [ - "Plot the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0aafc667-d47e-4a3f-8f18-646b599bfc53", - "metadata": {}, - "outputs": [], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0].set_title(\"Motion Space\")\n", - "axs[1].set_title(\"Drive Space\")\n", - "axs[2].set_title(\"Motion Space Return\")\n", - "\n", - "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", - "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", - "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " dpt = tr(pt, to_coords=\"drive\")\n", - " mpt = tr(dpt, to_coords=\"motion_space\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" - ] - }, - { - "cell_type": "markdown", - "id": "c7293afa-e931-499d-84ad-f7f3f7c696e4", - "metadata": {}, - "source": [ - "Are the returned motion space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8dac0d50-a14d-4319-8630-fa9c1a750f09", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, mpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4995cb9b-7c5e-4660-95c1-e1fbe2b73283", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - mpoints))" - ] - }, - { - "cell_type": "markdown", - "id": "8d84d8dd-8ec5-4c64-9696-3162096150f8", - "metadata": {}, - "source": [ - "## Configure for West Side Deployment\n", - "\n", - "The default values for `LaPD6KTransform` is for an East side depolyment on the LaPD. However, the transfrom can be configured for a West side deployment by using a negative `pivot_to_center` and `[1, 1]` for the `mspace_polarity`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", - "metadata": {}, - "outputs": [], - "source": [ - "tr = LaPD6KTransform(\n", - " (\"x\", \"y\"),\n", - " **{\n", - " **input_kwargs,\n", - " \"pivot_to_center\": -58.771,\n", - " \"mspace_polarity\": [1, 1],\n", - " \"droop_correct\": True,\n", - " \"droop_scale\": 2.0,\n", - " },\n", - ")\n", - "tr.config" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5853946-24e3-4286-aae6-aa48a59af280", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "key_points = np.array(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - ")\n", - "\n", - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")" - ] - }, - { - "cell_type": "markdown", - "id": "e0059a4f-f084-4d16-921c-6d2dd79fa3e5", - "metadata": {}, - "source": [ - "Plot the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "024c67c5-b442-40ee-8cd4-3c57a9c9e21a", - "metadata": {}, - "outputs": [], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0].set_title(\"Motion Space\")\n", - "axs[1].set_title(\"Drive Space\")\n", - "axs[2].set_title(\"Motion Space Return\")\n", - "\n", - "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", - "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", - "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " dpt = tr(pt, to_coords=\"drive\")\n", - " mpt = tr(dpt, to_coords=\"motion_space\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" - ] - }, - { - "cell_type": "markdown", - "id": "4613643d-b83f-4f80-9c58-3053d48b43ad", - "metadata": {}, - "source": [ - "Are the returned motion space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "62a2a57c-f919-4ae1-8fc3-1923c54d8c49", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, mpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "627126b3-419e-4a1b-8c28-7a45499709c8", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - mpoints))" - ] - }, - { - "cell_type": "markdown", - "id": "8165d9e8-797e-4f76-885b-fabd164081c4", - "metadata": { - "tags": [] - }, - "source": [ - "## The Algorithms\n", - "\n", - "To start we will use $(e_0, e_1)$ to represent the drive space coordinates and $(x, y)$ to represent the motion space coordinates.\n", - "\n", - "
\n", - "\"top_level_cartoon\"\n", - "
Top-Level Cartoon of the Drive and Motion Space Relationship
\n", - "
\n", - "\n", - "**Note:** The motion space x-axis points towards the the LaPD -X when the probe drive is deployed on the East side of the machine. This is why the East side operation requires `mspace_polarity = [-1, 1]`, and the West side requires `mspace_polarity = [1, 1]`." - ] - }, - { - "cell_type": "markdown", - "id": "8c724e04-242d-4b3a-be03-f8c4dee2fffa", - "metadata": { - "tags": [] - }, - "source": [ - "### Algorithm: Drive to Motion Space\n", - "\n", - "The key parameter we need to determine to convert the drive space coordinates to the motion space coordinates is the angle $\\theta$, which is the angle the probe shaft makes with the horizontal. Let's consider the following diagram...\n", - "\n", - "
\n", - "\"drive_overview\"\n",\n", - "
Drive Space Overview
\n", - "
\n", - "\n", - "Here...\n", - "\n", - "- $d_o$ = `probe_axis_offset` which is the perpendicular distance from the probe axis to the pinion location on the horizontal arm of the 6K probe drive.\n", - "- $R_A$ = `six_k_arm_length` which is the length of the vertical hanging arm of the 6K probe drive.\n", - "- $\\beta$ is the angular drop of the pinion location from the probe drive shaft with respect to the ball valve\n", - "\n", - " $$\n", - " tan\\,\\beta = \\frac{d_o}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}=\\frac{\\texttt{probe}\\_\\texttt{axis}\\_\\texttt{offset}}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", - " $$\n", - "\n", - "- $R_P$ = `pivot_to_drive_pinion` the radial distance of the probe drive pinion from the ball valve pivot\n", - " \n", - " $$\n", - " R_P^2 = d_o^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", - " $$\n", - " \n", - "- The vertical pinoin location above the horizontal is given by $R_A - d_o + e_1$, assuming $e_1=0$ when the probe shaft is horizontal.\n", - "- $\\gamma$ is the angle the vertical pinion makes with respect to the ball valve pivot and the horizontal\n", - "\n", - " $$\n", - " \\tan\\,\\gamma = \\frac{R_A - d_o + e_1}{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}}\n", - " $$\n" - ] - }, - { - "cell_type": "markdown", - "id": "979114a2-267d-4142-a6ae-d1ad13c480eb", - "metadata": {}, - "source": [ - "Now adopt a reference frame where the line intersecting the ball valve pivot and probe drive vertical (grey dashed above) is rotated to the horizontal and the ball valve is the origin. In this reference frame will use a coordinate system $(s_0, s_1)$. In this system the pinion point is located at the intersection of two circles:\n", - "\n", - "1. The circle about the ball valve pivot of radius $R_P$.\n", - " \n", - " $$\n", - " R_P^2 = s_0^2 + s_1^2\n", - " $$\n", - " \n", - "2. The circle about the vertical pinion of radius $R_A$.\n", - "\n", - " $$\n", - " R_A^2 = (s_0 + L)^2 + s_1^2\\\\\n", - " \\text{where}\\; L^2 = (R_A - d_o + e_1)^2 + \\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive}^2\n", - " $$\n", - "\n", - "Solving this system of equations we can calcualte the location of the pinion and, thus, the angle $\\phi$ depicted in the Drive Space Overview figure.\n", - "\n", - "$$\n", - "\\tan^2 \\phi = \\left(\\frac{2\\,L\\,R_P}{R_A^2-R_P^2-L^2}\\right)^2 - 1\n", - "$$\n", - "\n", - "Knowing $\\phi$, the signed angle $\\theta$ can be expressed as\n", - "\n", - "$$\n", - "\\theta = \\gamma +|\\beta|-|\\phi|\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "ff994b3b-3eca-498d-8b60-38129b83970c", - "metadata": {}, - "source": [ - "Taking $\\theta$ and the radial projection of the probe into the motion space as $r=D_C + e_0$, where $D_C$ is the distans from the ball valve pivot to the motion space origin `pivot_to_center`, then the motion space coordinates can be expressed as\n", - "\n", - "$$\n", - "x = (\\cos\\theta) \\, e_0 + D_C \\,(\\cos\\theta-1)\\\\\n", - "y = (-\\sin\\theta)\\, e_0 - D_C \\,\\sin\\theta\n", - "$$\n", - "\n", - "and expressed as the `_matrix_to_motion_space`\n", - "\n", - "$$\n", - "\\begin{bmatrix}\n", - " x \\\\ y \\\\ 1\n", - "\\end{bmatrix}\n", - "=\n", - "\\begin{bmatrix}\n", - " \\cos\\theta & 0 & D_C \\, (\\cos\\theta - 1)\\\\\n", - " -\\sin\\theta & 0 & -D_C \\, \\sin\\theta\\\\\n", - " 0 & 0 & 1\\\\\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - " e_0 \\\\ e_1 \\\\ 1\n", - "\\end{bmatrix}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "9a2d6321-c59d-4771-9676-26600d4acf33", - "metadata": {}, - "source": [ - "Obviously this not a perfectly clean expression since $\\theta$ depents on $e_1$. However, this is the expression that must be used to work with the archatecture desinged int `BaseTransform`." - ] - }, - { - "cell_type": "markdown", - "id": "1c8d4e25-6b31-4acd-8070-610c9b87d829", - "metadata": {}, - "source": [ - "### Algorithm: Motion to Drive Space\n", - "\n", - "In order to convert from the motion space to the drive space the key parameter to determine is the location of the probe drive pinion. Again this boils down to determining the angle $\\theta$, since the pinion is always a distance $R_P$ from the ball valve pivot and at an angle of $\\theta - |\\beta|$.\n", - "\n", - "Knowing the motion space coordinates $(x, y)$ the angle $\\theta$ can be written as..\n", - "\n", - "$$\n", - "\\tan\\theta = -\\frac{y}{D_C + x}\n", - "$$\n", - "\n", - "Then the probe drive pinion is located at the following position with the ball valve coordinate system $(s_0, s_1)$\n", - "\n", - "$$\n", - "s_0 = -R_P \\cos(\\theta - |\\beta|)\\\\\n", - "s_1 = R_P \\sin(\\theta - |\\beta|)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "d24296ce-b36f-47f9-afa0-a8a25cedf8f4", - "metadata": {}, - "source": [ - "Now we can determine the angle $\\alpha$ in which the probe drive arm leans forward.\n", - "\n", - "$$\n", - "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} + s_0}{R_A}\n", - "= \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\n", - "$$\n", - "$$\n", - "\\cos\\alpha = \\frac{R_A - d_o + e_1 - s_1}{R_A}\n", - "= \\frac{R_A - d_o + e_1 - R_P \\sin(\\theta - |\\beta|)}{R_A}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "e9ae34a6-c658-415c-8950-5c28357b497a", - "metadata": {}, - "source": [ - "Now we can cast the drive space coordinates as\n", - "\n", - "$$\n", - "e_0 = \\frac{1}{\\cos\\theta}x + D_C\\left(\\frac{1}{\\cos\\theta}-1\\right)\\\\\n", - "e_1 = R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\n", - "$$\n", - "\n", - "where\n", - "\n", - "$$\n", - "\\sin\\alpha = \\frac{\\texttt{pivot}\\_\\texttt{to}\\_\\texttt{drive} - R_P \\cos(\\theta - |\\beta|)}{R_A}\\\\\n", - "\\tan\\theta = -\\frac{y}{D_C + x}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "70dde653-1b6a-4879-a5b3-daf15d212968", - "metadata": {}, - "source": [ - "The does yield a rather ugly, but functional, transformation matrix of\n", - "\n", - "$$\n", - "\\begin{bmatrix}\n", - " e_0 \\\\ e_1 \\\\ 1\n", - "\\end{bmatrix}\n", - "=\n", - "\\begin{bmatrix}\n", - " \\frac{1}{\\cos\\theta} & 0 & D_C \\, \\left(\\frac{1}{\\cos\\theta} - 1\\right)\\\\\n", - " 0 & 0 & R_A (\\cos\\alpha - 1) + d_o + R_P \\sin(\\theta - |\\beta|)\\\\\n", - " 0 & 0 & 1\\\\\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - " x \\\\ y \\\\ 1\n", - "\\end{bmatrix}\n", - "$$" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 2e2744fd4d4b08619dd1f669ca49ec502dabd4c1 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 18 May 2026 12:29:59 -0700 Subject: [PATCH 023/177] clean up example notebook --- .../transform/LaPDXYZTransform.ipynb | 624 +++++------------- 1 file changed, 164 insertions(+), 460 deletions(-) diff --git a/docs/notebooks/transform/LaPDXYZTransform.ipynb b/docs/notebooks/transform/LaPDXYZTransform.ipynb index f30f5681..59aaf112 100644 --- a/docs/notebooks/transform/LaPDXYZTransform.ipynb +++ b/docs/notebooks/transform/LaPDXYZTransform.ipynb @@ -27,6 +27,7 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "import matplotlib.transforms as mtrans\n", "import sys\n", "\n", "plt.rcParams[\"figure.figsize\"] = [10.5, 0.56 * 10.5]" @@ -63,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 4, "id": "15dd3644-c856-46c2-9f6f-846956b435d4", "metadata": {}, "outputs": [], @@ -83,7 +84,7 @@ "id": "af05b4fc-afe4-4a5e-81a5-d11d95f022a4", "metadata": {}, "source": [ - "## Transfrom from Motion Space to Drive Space to Motion Space\n", + "## Transfrom from **Motion Space** to **Drive Space** to **Motion Space**\n", "\n", "Let's show the transform can successfully convert from the motion space to the drive space, and back.\n", "\n", @@ -92,23 +93,23 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 5, "id": "768e0851-57e5-4b44-9f0f-541741376aeb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'pivot_to_xzcross': 142.4804,\n", + "{'probe_axis_offset': 30.47,\n", + " 'drive_polarity': [1, -1, 1],\n", " 'table_pivot_to_zlead_screw': 12.488,\n", " 'mspace_polarity': [-1, 1, -1],\n", - " 'probe_axis_offset': 30.47,\n", - " 'pivot_to_center': 58.771,\n", - " 'drive_polarity': [1, -1, 1],\n", - " 'type': 'lapd_xyz'}" + " 'type': 'lapd_xyz',\n", + " 'pivot_to_xzcross': 142.4804,\n", + " 'pivot_to_center': 58.771}" ] }, - "execution_count": 21, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -130,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 17, "id": "ea80e434-af3a-42fe-b590-b4744f382ec5", "metadata": {}, "outputs": [], @@ -190,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 18, "id": "6d03325f-6e57-445c-9717-19fb98ea29d6", "metadata": {}, "outputs": [], @@ -209,13 +210,13 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 19, "id": "a0c8f222-15a8-45f5-b20e-ec475ba3d854", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -231,6 +232,7 @@ "fig, axs = plt.subplots(\n", " 3, 3, figsize=[figwidth, figheight], layout=\"constrained\",\n", ")\n", + "fig.set_constrained_layout_pads(w_pad=0.2, h_pad=0.1)\n", "\n", "axs[0, 0].set_title(\"Motion Space\")\n", "axs[0, 1].set_title(\"Drive Space\")\n", @@ -278,18 +280,29 @@ " \n", " i_start = ii * npoints_in_plane\n", " i_stop = i_start + npoints_in_plane\n", + " \n", " axs[ii, 0].fill(points[i_start:i_stop, p0], points[i_start:i_stop, p1[0]])\n", " axs[ii, 1].fill(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[1]])\n", " axs[ii, 2].plot(dpoints[i_start:i_stop, p0], dpoints[i_start:i_stop, p1[2]], \"-o\")\n", "\n", - " \n", " i_start = ii * 4\n", " i_stop = i_start + 4\n", " colors = [\"red\", \"orange\", \"black\", \"purple\"]\n", "\n", " axs[ii, 0].scatter(key_points[i_start:i_stop, p0], key_points[i_start:i_stop, p1[0]], c=colors)\n", " axs[ii, 1].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[1]], c=colors)\n", - " axs[ii, 2].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[2]], c=colors, zorder=10)" + " axs[ii, 2].scatter(dkp[i_start:i_stop, p0], dkp[i_start:i_stop, p1[2]], c=colors, zorder=10)\n", + "\n", + "\n", + "# Get the bounding boxes of the axes including text decorations\n", + "r = fig.canvas.get_renderer()\n", + "get_bbox = lambda ax: ax.get_tightbbox(r).transformed(fig.transFigure.inverted())\n", + "bboxes = np.array(list(map(get_bbox, axs.flat)), mtrans.Bbox).reshape((*axs.shape, 2, 2))\n", + "\n", + "# Draw vertical divider between the different space plots\n", + "x = bboxes[:, 0, 1, 0].mean() - 1.15 * (0.2 / figwidth)\n", + "line = plt.Line2D([x, x], [0,1], transform=fig.transFigure, color=\"gray\", linestyle=\"--\")\n", + "fig.add_artist(line);" ] }, { @@ -302,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 20, "id": "6e52c2b4-5970-49dd-a21a-e8b84b3fb0e8", "metadata": {}, "outputs": [ @@ -342,7 +355,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 21, "id": "76f1c97e-a944-4d8b-91a6-9cc328671b5f", "metadata": {}, "outputs": [ @@ -352,7 +365,7 @@ "True" ] }, - "execution_count": 36, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -363,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 22, "id": "f4449700-7100-4c29-946c-4d22cea7ee0f", "metadata": {}, "outputs": [ @@ -373,7 +386,7 @@ "np.float64(1.1546319456101628e-14)" ] }, - "execution_count": 37, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -387,7 +400,7 @@ "id": "bd3dd84b-5a9a-48c1-b304-c62f84976b7a", "metadata": {}, "source": [ - "## Transform from Drive Sapce to Motion Space to Drive Space\n", + "## Transform from **Drive Space** to **Motion Space** to **Drive Space**\n", "\n", "Let's show the transform can successfully convert from the drive space to the motion space, and back.\n", "\n", @@ -396,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 23, "id": "e87c5d28-ec61-4a90-97cd-89db765fbd2c", "metadata": {}, "outputs": [], @@ -415,15 +428,15 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 24, "id": "4e61105e-3788-4edb-a54c-9a582f04f745", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABaoAAAXSCAYAAAD5aNjLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4FFXXwPGTbHoIoYUOCQSkCEhvShOkWlDEz4ooYm+AKEGUTiyooGLjFRAFURSxIU2kKFWkSJXeO5IAgbTd77kXMySk0LIzuzv/H888mbs7u3tzE3J3zp4518/lcrkEAAAAAAAAAACL+Fv1wgAAAAAAAAAAKASqAQAAAAAAAACWIlANAAAAAAAAALAUgWoAAAAAAAAAgKUIVAMAAAAAAAAALEWgGgAAAAAAAABgKQLVAAAAAAAAAABLEagGAAAAAAAAAFiKQDUAAAAAAAAAwFIB1r48AABQUlJSJD4+Xu/HxcVJUFAQAwMAAAAAsA0C1QAAeACHwyFt2rQx9gEAAAAAsBM/l8vlsroTAAAAAAAAAAD7okY1AAAAAAAAAMBSlP4AAMADOJ1OOXDggN4vVaqU+PvzWTIAAAAAwD44CwYAwAOkpaXJ//73P72pfQAAAAAA7IRANQAAAAAAAADAUgSqAQAAAAAAAACWIlANAAAAAAAAALAUgWoAAAAAAAAAgKUIVAM+pnv37hITE2N1NwAAsJ0JEyaIn5+f7Ny50+quAACAy8AcDngGAtWAh0yIGVtISIiULl1a2rVrJ++++66cPHlSvMWPP/4oLVq0kOLFi0tYWJhUrFhR7rrrLpk5c6bVXQMA2HBe/f3337Pd73K5pFy5cvr+m2+++YpeY8SIETJ9+nTxJCkpKTJ69GipU6eOFCxYUAoVKiTXXnutPProo7Jp0yaruwcAwEUxhzOHAwSqAQ8xZMgQ+fzzz+XDDz+UZ555Rt/2/PPPS82aNWXt2rWX/Dxjx46VzZs3i9lGjhwpt956qz7xj4uLk3feeUe6dOkiW7ZskSlTppjeH8DbOBwO/UGP2tQ+gKujPvidPHlyttsXLFgge/fuleDg4Ct+7twC1Q888ICcOXNGoqOjxWxqzu3Tp4/UqFFDXnvtNRk8eLA0b95cfvnlF1m6dKnp/QEA4EoxhzOHw74CrO4AgHM6dOgg9evXN4ZDBXvnzZuns71UAHjjxo0SGhqa63CdPn1awsPDJTAw0PQhTUtLk6FDh8pNN90ks2fPznb/4cOHTe8T4G1UcLply5ZWdwPwGR07dpSpU6fqq5MCAs6/5VXB63r16snRo0fd8v/Yig+aVqxYIT/99JMMHz5c+vfvn+W+999/X06cOGF6nwAAuFLM4ecwh8OOyKgGPNiNN94or7zyiuzatUu++OKLLHWoCxQoINu2bdOTeEREhNx3333ZalSnpqZKkSJF5KGHHsr23ImJifqT6hdeeMG4LTk5WQYOHCiVKlXSmWbq0ugXX3xR354XdbKvnu/666/P8X5VCiTD/Pnzddb1V199pU+mS5YsqQPsKhi/Z8+eLI9btGiRdO3aVcqXL2/0p1evXjpb7ULqsmZVZiQqKkoH9KtUqSIvv/xylmP27dsnDz/8sJQoUUI/n7okety4cXl+bwAA73TPPffIsWPHZM6cOVnKY3zzzTdy77335vqhr8pKVvONmifUXKKuGFLlQjKoOUwd99lnnxklRtTcm1d9yw8++EDPOeo5VXmvp556KlvwWH1QpbKhN2zYIK1atdIltMqUKSNvvPHGRb9X9X5AyWkeVoHzokWLGu1BgwbpPmbMm6pMiLr/ueeek7Nnz2Z57Pjx4/V7ETWPq75Xr15dX/mVE5W5ra4IUe9J1HM2aNAgW0b7smXLpH379hIZGam/P3X8H3/8cdHvDwBgL8zh5zCHw44IVAMeTl1GrFyYqayymFUda3XyqE6i1SW/F1LZ1bfffru+PFmdnGemblMB6Lvvvlu3nU6nDhar57rlllvkvffek86dO+sSHv/3f/+XZx9VH1RwWNWoPn78+CV9Xyrr6+eff5aXXnpJnn32WR1IaNOmTZYgtMqES0pKkieeeEL3R32/6mu3bt2yPJcqjdKoUSOdgd6zZ09do1P1XfUnw6FDh6Rx48Yyd+5cefrpp/UxKiDfo0cPGTVq1CX1GXAnFQhTVx+oLXNQDMCVUR/aNmnSRL788ssswdSEhARj7rvw/6CaB9W8p4Kpb7/9tg5U9+3bV3r37m0cp8p0qaBts2bN9L7aHnvssVz7oQLDKjCtAtRvvfWWnq8//vhjadu2rf5AObN///1Xv/Z1112nj61ataqeJ1W/85JRamTSpEn6/cGlUEFqFZiOj4/XH3qrzHNVzzozFZRWz60+WFb9UQH8J598UsaMGZPlOBWg79Spk34PoK4IU6VHateunWWNCjVHq1Ik6oNt9aG4Kp+igvUqEL58+fJL6jMAwB6Yw/PGHA6f5gJgqfHjx6uIlGvFihW5HhMZGemqU6eO0X7wwQf1Y/r165ftWHVfdHS00Z41a5Y+9scff8xyXMeOHV0VK1Y02p9//rnL39/ftWjRoizHffTRR/rxf/zxR57fx6uvvqqPCw8Pd3Xo0ME1fPhw18qVK7Md99tvv+njypQp40pMTDRu//rrr/Xto0ePNm5LSkrK9vj4+HiXn5+fa9euXcZtzZs3d0VERGS5TXE6ncZ+jx49XKVKlXIdPXo0yzF33323Ht+cXgswU3JysmvQoEF6U/sArn5eff/99/X8kPE3vmvXrq5WrVrpfTVXdurUyXjc9OnT9eOGDRuW5fnuvPNOPe9s3brVuE3NdWq+ze21d+zYoduHDx92BQUFudq2betKT083jlP9UseNGzfOuK1Fixb6tokTJ2b5u1CyZElXly5d8vye1XyX8fgSJUq47rnnHteYMWOyzYvKwIED9XG33nprltuffPJJffuaNWuM23KaG9u1a5fl/cOJEyf0GDdq1Mh15syZbP3K+Fq5cmX92Mxzs3r+ChUquG666aY8vz8AgD0whzOHA2RUA15Alfk4efJktttVpvHFqEylYsWK6VIbmTO2VAZz5kxplb1crVo1nb2lSnlkbOrxym+//Zbn66hFm9QlvnXq1JFZs2bpshuqBmjdunV1fe0LqaxodXlwhjvvvFNKlSolM2bMMG7LXJNbXWat+tO0aVOd9bZq1Sp9+5EjR2ThwoW6pIcqEZKZurRZUcd/++23OlNc7Wf+/lSWtsqu++uvvy46lgAA76IyjtSVOqp+s5pH1dfcyn6o+UddYquu8slMlQJRc8fFsppzoq7iUVc0qcWR/f3Pv+1WV/+o8hjqyqIL5/v777/faAcFBUnDhg1l+/bteb6Omu/U3Dts2DApXLiwziJXWdwqG1rN9TnVqFb3Z5axkHNu87CaK9W8qcp1qP6otqLeT6ix7devny4pdmG/lNWrV+vFldXYq3IsGXOwmttbt26t53F1ZRcAABmYw5nDYU8EqgEvcOrUqSxBXUUtDFW2bNmLPlYdpy4z/v77741a09OmTdOXG2cOVKsTyPXr1+saz5m3a6655pIXRFS1xFRdaRUIV6VK1AmpCiirAPGFdS8rV66c7WRWleLIXNdz9+7duu6nqrOtTt5Vf9QJspJxgpxx8q7qeuZGBbPVSfonn3yS7fvLqN/Ngo8A4HvU33lVVkp9kKrmvvT0dP3BaE7UehCqPMeF8636EDfj/suV8RhVQiQzFYCuWLFitudU83pGcDeDCjyrefViVDkS9SGx+nB4//79OlitSl59/fXXuuTVhS6ch2NjY3UwPfM8rOpHq/FTa0kUKlRIj2fGYo0Z83BGfey85mH1HkN58MEHs83D//vf//T7k4znA+Db1AdT6txA/b1Vf+9UOUKrX0+db2SsOZCxqTJMsBZzOHM47On8EugAPNLevXv1yZsK4l54Qpo5OysvqhanqoepssFU7WZ10qoyp1UNzAwqk6lmzZq6JmdOVF3KS6WyxG666Sa9qTrZasEptYBSRpD5Uqhggnq8qnep6nOq/qoTZbUgonozeTmZVxnHqiw1dZKck1q1al3y8wEAvIf60FRlMB88eFA6dOigA66eSmV05+Ry69arK5TU3K8+qFaLOKp5X9WRVh9e5+bCALkKQKtsZzX/qvcG6n2ACrCrjGtVx/tK5uE333xT167OifpAGoDvU1dSqHMQdTXkHXfc4TGvpwLTagHZzOdasB5zOHM47IdANeDh1CJNiipRcaXU4kXqpFWV/7jhhhv0gkYq6+rCTKo1a9bok9ILT1avRv369XWg+sCBAzlmV2U+Cd+6dasRMP7777/ln3/+0Y/NvHiiusQ4M5WRpqxbty7PT+NVhpwKfqvMMACAfahFhdVih0uXLs1SButCqkyGKtWhylhkzqretGmTcX+GS50nMx6zefNmY75SVDmQHTt2uH1OUh8Wq3lVzbmq1EbJkiWN+9RtFSpUMNpqDlYBZbWAlaIWJFaZzj/88EOW0loXlgJT7x8y5uELP1S/8Bj1QTbzMGBv6gNDteVG/d1R5ynqqhB1RaS6WuP111+Xli1buuX1MgemM/+NhGdgDmcOh/1Q+gPwYCqgPHToUH0ied99913x86jMa3WpszrpVIHvtLS0LGU/MmqAqWzlsWPHZnu8qu+pshFyk5SUJEuWLMnxvoyanhde9jxx4sQsdbe/+eYbHczOeCOZkVWWOYtM7Y8ePTpbEFoF4seNG6dLhWSW8Vj1XCqrTNWpzimgrUqDAAB8k8rU/fDDD2XQoEH68u/cdOzYUX+g+f7772e5XWUPq8B05kCHusInp7rPF1JBWZWF/O6772aZzz799FN9tVSnTp0kP6ig84VzoKL6qOZnVT5EzZeZjRkzJkv7vffe01/zmodVnzNnHCpt27bVgf34+PhsZb4yHqvWrFDB6pEjR+pyZhdiHgaQQZUqUn+3pkyZImvXrpWuXbvqbOcLk1zy2/z586V48eL6nEWtA6Tq6cN6zOHM4bAfMqoBD6ECuiprSwWRDx06pIPUKntYZWOpbKYLFyi6XCowrU5CBw4cqEt8ZNTczPDAAw/oS4Mff/xxnS11/fXX6xN21Sd1u1qkSWVH5xaoVoscqlqY6o2kujxYnRyrGnCqZrUqN6IWWcxM1Z1W2d2qRrT6fkeNGqUzsdTl2Yq61Fid1L7wwgs6gK6ysFSgOac6nSoAoJ5LLdz46KOP6sC+qrGpFqlSCzgpr732mv6+GjVqpF+jevXquqyIWkRRZdCpfQCAb8qt7FNmKojdqlUrncmn5hB1qbhab0Gt8aAWQ8zICs4IvKq5Q5XEUHVP1byj5pcLqeBwXFycXnBYzY+33nqrzq7+4IMPpEGDBlkWTrwa6ooodXm0CjI3a9ZMz7Fq7lRXJal61WqOvbCsiMroVv1R/VJBoS+++EI/R0ZZMBWAVkF2NS4qI10FmNWH2SqQk/kqKTU/q2D+I488or8n9RwqMK76pN4fqD6oD8xVLWrVP1WKRM39ZcqU0X1Uc7N6DvVhOgB7Ux+4qQ/D1Ff1t1VR5wIzZ87Ut48YMcItr6v+DqqyIOpvuSp7pGrxq79X6m9jbiWZYB7mcOZw2IwLgKXGjx+v0o2MLSgoyFWyZEnXTTfd5Bo9erQrMTEx22MefPBBV3h4eI7Pp+6Ljo7OdrvT6XSVK1dOv8awYcNyfGxKSorr9ddfd1177bWu4OBgV+HChV316tVzDR482JWQkJDr95CamuoaO3asq3Pnzvq11WPDwsJcderUcb355puu5ORk49jffvtN9+HLL790xcXFuYoXL+4KDQ11derUybVr164sz7thwwZXmzZtXAUKFHAVK1bM1bNnT9eaNWv049W4ZbZu3TrX7bff7ipUqJArJCTEVaVKFdcrr7yS5ZhDhw65nnrqKT0OgYGBepxbt27t+uSTT3L93gCzpKWluWbNmqU3tQ/g6ubVFStW5Hmcmq/U3JPZyZMnXb169XKVLl1azxOVK1fW85iaQzPbtGmTq3nz5nr+Uq+l5t7Mr71jx44sx7///vuuqlWr6ucsUaKE64knnnD9+++/WY5p0aKFnn8vdV6/cH577bXX9HOUKlXKFRAQoOfwG2+80fXNN99kOXbgwIG6j2qOvfPOO10RERH62Kefftp15syZLMf+8MMPrlq1aul5NSYmRr9HGDduXI7fozq2adOmekwKFizoatiwoZ7rM1u1apXrjjvucBUtWlS/V1Df11133eX69ddf8/z+APgm9bfku+++M9o//fSTvk2d52Te1N809bdC2bhxY5Zzp5y2l1566ZJeLzfbtm3Tx86dOzcfv1tcCuZw5nDATw2B1cFyAPahLqtTGWtTp07V5UgAAIB5VAkUleGtym0UK1aMoQdgGVVW6bvvvtNXXypqHQFV7nD9+vXZMplVCQhVQ1rV+N++fXuez1u0aNFs5Y5yer28qMcPGzZMX1ECeArmcNgBpT8AAAAAAIClVKlAVXrw8OHDuoxRTlRJIlUi0J327t2ra1SrxegBAOYiUA0AgAdQFziphcqUyMhInfUDAADgS1S9+61bt2apl6/WlFG19a+55hqdUd2tWzd56623dOBaXf3x66+/Sq1ata5oAdq8Xq98+fL6fnWViVp4XWVsqxrVL774ol47p127dvn2fQMALg2BagAAPEBqaqqMHj1a76vF11TGEAAAgC/5888/dRnADL179zYWzJswYYJeNFGV3OjTp49ecFWVKFILtt98881ueT1VYmTt2rV64Ve1GLxaxFEtJjt06FAJDg6+6u8XAHB5qFENAIAHUDUX4+Pj9T6BagAAAACA3fhb3QEAAAAAAAAAgL0RqAYAAAAAAAAAWIoa1fnA6XTK/v37JSIigsWvAMCGiyCePHlS1zT09+fzX3dhrgUAe2O+9V7M4QBgb67LOGcmUJ0PVJC6XLly+fFUAAAvtWfPHilbtqzV3fBZzLUAAIX51vswhwMALnUOJ1CdD1QmdcaAFyxYMD+eEgDgJRITE/WHlRlzAdyDuRYA7I351nsxhwOAvSVexjkzgep84Ofnp7+qIDWBagCw91xwpdQlUPXr1zf2kfP4MtcCgL1d7XwL8zGHAwAudQ4nUA0AgAcICAiQTp06Wd0NAAAAAAAsQcoWAAAAAAAAAMBSZFQDAOAhKyEnJSXp/bCwMC5tBgAAAADYChnVAAB4gNTUVBk5cqTe1D4AAAAAAHZCoBoAAAAAAAAAYCkC1QAAAAAAAAAASxGoBgAAAAAAAABYikA1AAAAAAAAAMBSBKoBAAAAAAAAAJYiUA0AAAAAAAAAsFSAtS8PAAAUf39/ue6664x9AAAAAADshEC1J9ixQ2TGDJGzZ0VUkOLGG1WUwupeAYDPcrlcsnP+Tjnw1wFxBDmkcsfKUiS2iKV9CggIkM6dO1vaBzs5uOag7Pxtp/5diG4WLaXrl7a6SwAAAABgqYSkVOk+fpmc2rVFeiZ9KaUCT8iZyArS9Nn3pUCRKLe/vlcFqhcuXChvvvmmrFy5Ug4cOCDfffddlpN6dbI5cOBAGTt2rJw4cUKuv/56+fDDD6Vy5cp5Pu+YMWP08x48eFBns7333nvSsGFD939Dp0+LPPKIyFdfnWur4HR6ukhsrMiUKSL167u/DwBgMwdXH5Spd02V41uOi5+/n547Zj43U6rdUU1uG3+bBEcEW91FuNHJAyflm7u/kd0Ld+ufv+JyuqRMwzJy59d3SqHoQow/AAAAANtp8eY82X30lHx+8lW5vsEakSARcYr4OVaI67uv5Zedt0qHod+7tQ9elbZ7+vRpHUhWgeWcvPHGG/Luu+/KRx99JMuWLZPw8HBp166dnFWZyrn46quvpHfv3jrA/ddff+nnV485fPiwG78THVUXueMOka+/PrevNhWkVnbuFGnVSmTLFvf2AQBs5t8d/8qElhPk3+3/GgFKcakdkU3TN8mUW6fowLUV1OumpKTozao++LrUpFT5rOVnsnfxXuPnr38HRHR2/YQWE+RsQu7vGQAAAADAV4PUu46dkQkJg+SGG9aIX7CIn58KUv93QIhIh2o/yLSBd7u1H14VqO7QoYMMGzZMbr/99mz3qZP6UaNGyYABA+S2226TWrVqycSJE2X//v0yffr0XJ/z7bfflp49e8pDDz0k1atX10HusLAwGTdunHu/md9/F5k9W8TpzH6fClir4Prrr7u3DwBgM4tHLpbU06niSs8eCFa3qXIgO+btsKRvqampEh8frze1j/y39ou1cmzLMXGmZZ971W0JuxNk1aerGHoAAAAAtir3sevYGSl55og0r5/z+ZAKWqt8qltKfiOnktyX3ONVgeq87NixQ5fuaNOmjXFbZGSkNGrUSJYsWZLjY1TWmiojkvkxagEr1c7tMUpycrIkJiZm2S7b5MmqIGnu96eliUyalHMgGwBwRdZ+vjbHIGUG/wB/+XvS34yuj1rz+ZqLHzPx4scAAAAAgK94eMJy/fXJpKniF5b7cSpYHRiZLlM+fsNtffGqGtV5UUFqpUSJElluV+2M+y509OhRSU9Pz/ExmzZtyvW1VLbb4MGDr67Dx45dPAh99qxU6TtdkgOplwoAV83lkodOpuR5iApinzl2hsH2UUlHks6VesmNSyTpaJKJPQIAwFy33nqrrF69Wpe6LFy4sE7Sev3116V06dwXFValNPv06SNTpkzRSVuqVOYHH3yQ7TwaAOCd9v9X/rCY34lLOt4/4VwpRXfwmYxqM8XFxUlCQoKx7dmz5/KfpEKFc4sn5uF4aIQkB6jK5QCAq+bnJ6cLBOZ5iMqoLlSBxfR8VZFKRcTPcW4BxZw4/UR2Bojc88lSGTD9b5nwxw5ZtOWIHEjgwwsAgG9o1aqVfP3117J582b59ttvZdu2bXLnnXfm+ZhevXrJjz/+KFOnTpUFCxbo8pp3qPWWAAA+oXRkiP661Vnuko5PKFbTbX3xmYzqkiVL6q+HDh2SUqVKGberdu3atXN8TLFixcThcOhjMlPtjOfLSXBwsN6uysMPq9Ufc7073c9fJtfucC6vHgCQLzbXjpLaf+wXf1fuGdV1etRhtH1U3Z51ZcvPuS9UrH4v1tUsJtu3H5Ml249luS88yCGxxQtIbFQBqaS/huuv0UXDJdDB5/4AAO+ggs4ZoqOjpV+/ftK5c2e9PkZgYPYP9FVi1qeffiqTJ0+WG2+8Ud82fvx4qVatmixdulQaN25sav8BAPlvXPeGct2Q2fJB5J3y9NGvxa+IS/xyOMVxOUVOHwqVnk8+Lu7iM2dWFSpU0MHlX3/91bhN1Y5etmyZNGnSJMfHBAUFSb169bI8xul06nZuj8k3VaqI9O2b411pfv6yu1AJGdsg+6KRAIArt6F+cUksHKIzZ3PS8NmGUqIml7H6qiq3VJFrbr5G/Pyz/wKo34n95SNkR9XCOT72dEq6rN2bIN+t2idvztosj3/xl7R5e6FUe2Wm3PjWfOk58U95feYm+WblXlm954ScPMuCmAAAz3b8+HGZNGmSNG3aNMcgtaLWdFJB7MzrOlWtWlXKly+f57pOAADvERkWKNFFQ+VsYKh8tO4O8XOdC0pn5kpXWbUiH53pIwVC875S2TYZ1adOnZKtW7dmWUBR1dcqUqSIniiff/55GTZsmFSuXFkHrl955RVda0t9QpyhdevWcvvtt8vTTz+t271795YHH3xQ6tevLw0bNpRRo0bJ6dOn5aGHHnL/N/T66yJly6qi16rItr4p1d8hP1ZrLsNufEQSQiPc3wcAsJHU4AD5+f6q0nDeHqm44bg4nOdSq8OLh8v1L10vjXuRFeTLVID6rm/vkvmD5suKMSskOTFZ354a6K+z7f9qXkZcl5kdneZ0yfYjp/U2Z0PWK7RKFAzOlIF9/mvJ/y6tAwDACi+99JK8//77kpSUpDOif/rpp1yPVes9qQSvQoUKXfJaUKqOtdoyJ5ABADzbL881l+qvzpI3ijwkp38Pk2cqTJGQ8ueTbxL3hMsnzj7Sd8BVrtnnS4HqP//8U9fUyqCCzIoKNE+YMEFefPFFHWR+9NFH5cSJE3LDDTfIzJkzJSTk/AmhqsGlFlHM8H//939y5MgRefXVV/VEq8qEqMeYsjCEKuvx7LMiTz4psmaNdHlnnmwrWlZOhBZ0/2sDgE2lhAbI750qyPIby0mhY2dk+vPNpcR1JcQR6LC0X/7+/lK9enVjH+7hCHJI6xGtpfkrzWXVgp3y1KS/5N+oUEkLyv+f/6HEZL0t3pa1jEhEcIBUjArPUkpElxEpEiYBlBEBAFwmVb5DLYiYl40bN+pMaKVv377So0cP2bVrlwwePFi6deumg9V++VR2Mj4+Xj8vAMA7pKU7dZA6w3cx3eSz03dL46XLpFLgEUkvV1ue6/2w9A1xfxjZz+Vy5VKpE5dKfUIcGRmp63cVLHjlQeaYfj8z6ABgsp2vdfKIOQDmj/PGA4nSYfQijxn6QIeflC8SliUDO2M/PNircgsAIN8x3+ZOJV4dO5b1Q9ELVaxYUWdGX2jv3r1Srlw5Wbx4cY7lL+fNm6evSv7333+zZFWr+tbqiubMNa/zyqhWr8F7JQDwPC6XSyrEzTDa3ZpEy5Dbalg2h3PWAwAAbCk57YLCaxZLTXfJtiOn9SaStYxIqciQLAs5qmzsSlEFpHhByogAgN1FRUXp7UqoNZqUzIHlzNSaTqp+tVrHqUuXLvq2zZs3y+7du3Nd1yk4OFhvAADPV3vIHGO/WeVi+R6kvlwEqgEAgC2dTVUrgniHAwln9fb71vPly5SCIaqMSNY62GpTmdmOHBaNBADY17Jly2TFihW6RGbhwoV1WUy1rlNsbKwRdN63b5/OoJ44caJew0llwKkyIarsplobSmXCPfPMM/p4Vd8aAOC97vpoiSScSTXW1/m8RyOru0SgGgAAT5CSkqJrOipxcXE5Xp4L386ovhKJZ9Nk9Z4TesssyOEvMcXCsi3mqGpjhwWRpwAAdhQWFibTpk2TgQMH6rWdSpUqJe3bt5cBAwYYGdCpqak6Y1ottJjhnXfe0etnqIxqlXndrl07+eCDDyz8TgAAV6vft2tl+c7jRntpXGvxBJypAAAAW/KmjOrLlZLulH8OndJbZmqdrNKRoTpgnTmArb5GRXCZNgD4spo1a+qa03mJiYnR9UozCwkJkTFjxugNAOD9Ppi/Vaas2GO0t43omG8L6l4tAtUAAMCWfCGj+nKp2MO+E2f0tmhL1jIihcICpWKxcwHszEHscoXDxJ8yIgAAAIDX+371Pnlj5majvWloe48qGUigGgAA2JIvZ1RfiRNJqfLX7hN6yywowF8HsFXgOva/xRwzAtkhgQ7L+gsAAADg0i3Zdkyem7LaaP/1yk0e936eQDUAALAlO2ZUX4mUNKdsOnhSb5mpqwPLFArNVgdbBbKLFqCMCAAAAOApthw6KfeMXWq0F/RtKUXCPW9dJALVAADAlpLJqL7qMiJ7/z2jtwX/HMlyX+GwwBwC2AWkbOFQyogAAAAAJjqceFZuemeh0f7uyaYSXTTcI38GBKoBAIAtkVHtPv8mpcqfu/7VW2Yhgf4SUzT7Qo5qcUdPu+wQAAAA8HanktOk4YhfjfYnD9STOuULi6ciUA0AgAfw9/eXypUrG/twP2pUm+9sas5lRNT6LWUKh0qlqEwBbLWoY1QBKeyBlyQCAAAAni413Sk1Bs4y2oNvvVbaXltSPBmBagAAPEBAQIDce++9VnfDVsio9hxOl8ie42f09tvmrGVEVO08HcAufn5Bx0r/lRHxU4WyAQAAAGThcrmk8su/GO2ezSrIg01jxNMRqAYAALZEjWrvcPx0iiw/fVyW7zyerYxIxWLnA9cqkK0ysSsUC5fgAMqIAAAAwL6qvTrT2G9Trbi83Km6eAMC1QAAwLZlKODdP78NBxL1dmEZkXJFwjLVwD4XwK4UFSGRYYGW9RcAAAAww23v/26c65QvEib/e7CB1ww8gWoAADxASkqKjBw5Uu+/8MILEhREXV53S05Ld/trwJoyIruOJelt3qbDWe4rViBIKmZaxDEjkF2mEGVEAAAA4P16f71a1uxNMNoL+rYUb0KgGgAAD5Gammp1F2yFjGr7OXoqRY6eOi7Ld2QtIxIW5NAlQ7IGsM+VEQkKYHFTAAAAeL7Rc7fItL/2Ge3tIzp63ZouBKoBAIAtkVGNDEkp6bJ+f6LeMnP4+0m5wqFG4Do2UyA7MpQyIgAAAPAM36zcK+/M/cdobxraXvxVTTwvQ6AaAADYEhnVuJh0p0t2HkvS29yNF5YRCZZKxcOzZGCrr6ULhTKwAAAAMM3vW47KC1PXGO01r7aVkEDvXFycQDUAALAlMqpxNY6eStbb0u1Zy4iEBzl0HeyMRRwzAtgxxcIl0EEZEQAAAOSfjQcS5f5PlxntRS+28uoFxAlUAwAAWyKjGu5wOiVd/t6XoLfMAvz99KrrmcuHZASzI0K892QCAAAA1jiQcEY6jF5ktH965gYpVyTMq38cBKoBAIAtkVENM6U5XbL96Gm9zZFDWe4rHhGcbSFH9bVkZAg/JAAAAGSTeDZVmsTPM9rjuzeQGmUixdsRqAYAwAOo1Zijo6ONfbgfGdXwFIdPJutt8bZjWW4vEBygs64vXMgxpmiYBFBGBAAAwJZS0pxSa9Bsoz3i9prSqmpx8QUEqgEA8ACBgYHSvXt3q7thK8lpTqu7AOTpVHKarNmboLfMAh3/lRG5IANbBbNVcBsAAAC+yel0yTUDfjHaT7aMlXsblRdfwTtZAABgS8mp6VZ3Abgiqeku2XbktN5mb8haRqRkwRCJLR4ulf7Lws74WqIgZUQAAAC8XezLM4z9jjVLyovtq4ovIVANAABsiYxq+KKDiWf19sfWrGVEIkICpGJURuD6fCA7ughlRAAAALxB+1ELxeU6t39NiQLywX31xNcQqAYAwAOkpKTI6NGj9f5zzz0nQUFBVnfJ5y+ZS0mn9Afs4+TZNFmz54TeMgty+Ev5omHnA9j/lRJRWzhlRAAAADzCU5P/kk0HTxrtWc83F19EoBoAAA+RlJRkdRdsg2xq4Bz1gc3Ww6f0JuvPj4pa01WVETEC10YZkXApHkEZEQAAALO8OWuT/Lz2gNHePqKj+Kk3az6IQDUAALCd5DTqUwN5UZeVHkg4q7dFW45mua9gSECW+tcZX9UCjw5/3zxpAgAAsMKXy3fLmN+2Ge1/hnUQfx9+v0WgGgAA2M7ZVMp+AFcq8WyarNp9Qm+ZBQX4S4wqI/JfFnbmMiKhQQ4GHAAA4CJS0pzy+ZKdsut4kqSmOeXLFXuM+9YOaqvfb/kyAtUAAMB2yKgG3HNi9c+hU3rLTF2ZWjoyVGddx0adr4OtvhYrEMyPAgAAQETiZ2yQsYt2iPO/BRMzW9zvRikYEujz40SgGgAA2A4Z1YC5ZUT2nTijt4X/HMlyX6GwwP+yrrMGsMsVDvPpy1oBAAAuDFJ/vHBHroPy2eIdEtexus8PGoFqAABgO2RUA57hRFKqrNz1r94yU5e1ViwWbizkmDmQHRJIGREAAOBbV6WpTOq8qPv7tK1K6Q8AAOB+atXm0qVLG/tw/5tBAJ79f3TTwZN6y0z9eSxTKDRLDexzX8OlKGVEAACAF1I1qXMq95GZul8d16NZRfFlZFQDAOABAgMDpWfPnlZ3wzYIVAPeW0Zk779n9LbggjIihf8rI5I5gK02FdimjAgAAPBUauHE/DzOmxGoBgAApnrttdckLi5OnnvuORk1apQlo5+STkY14Gv+TUqVP3f9q7fMQgL9pUKx7HWwKxQLp4wIAACwXHSRsHw9zpsRqAYAAKZZsWKFfPzxx1KrVi1LR52MasBei6duPJCot8zUWo1lC4dlC2CrrVBYkGX9BQAA9qJKelyMv5/IA01ixNcRqAYAwAOkpqbKmDFj9P5TTz2lS4H4mlOnTsl9990nY8eOlWHDhlnaFzKqAahaj7uPJ+ntt81Zy4gUDQ8yFnLMqIGdUUaEdQQAAEB+6TnxT9l5/MzFj2tWwecXUlQIVAMA4AFcLpckJCQY+75IBeA7deokbdq0sTxQnUrpDwB5OHY6RY6dPi7Ldx7PcntooEMqRoVnq4WtyojY4eQRAADknxEzNsqcDYeM9qPNKsj/ft+RZWFFlUmtgtRxHavbYuh9KlAdExMju3btynb7k08+aWSpZTZhwgR56KGHstwWHBwsZ8+edWs/AQCwmylTpshff/2lS39ciuTkZL1lSEzMesn+1aL0B4ArcSY1XdbvT9RbZg5/PylXONQIXmfOxo4M9b0rZAAAwNWX+/hk4XajvWV4Bwl0+MsL7arq+9TCiaomtSr3YacPw30qUK1OftPT0432unXr5KabbpKuXbvm+piCBQvK5s2bjTaX8gEAkL/27NmjF06cM2eOhISEXNJj4uPjZfDgwW77UaSk+2bWOgBrpDtdsvNYkt7mbjyc5b5iBYKz1cFWQezSkSGcewAAYENzNxySV75fb7TXDW6ng9SKCkr3aFZR7MqnAtVRUVFZ2q+99prExsZKixYtcn2MCkyXLFnShN4BAGBPK1eulMOHD0vdunWN29QHywsXLpT3339fZ047HI4sj4mLi5PevXtnyaguV65cvvWJjGoAZjl6Kllvy3ZkLSMSHuSQCiqAHZV1IceYYuHGySoAAPAta/ackEcm/mm0l/VvLQWCfSo8e1V8diRSUlLkiy++0Ce5eWVJq4WdoqOjxel06hPoESNGyLXXXmvp5cgAAPiS1q1by99//53lNlV6q2rVqvLSSy9lC1JnlOJSm7sQqAZgtdMp6bJuX6LeMgvw95PyRcKkolEH+79s7OIFpGAIZUQAAPBWu48lyW1j/jDas3s1lxIFL+2KU7vw2UD19OnT5cSJE9K9e/dcj6lSpYqMGzdOatWqpRewGjlypDRt2lTWr18vZcuWtexyZAAAfElERITUqFEjy23h4eFStGjRbLebhcUUAXiqNKdLth89rbe5G88vsKQUj1BlRDIHsCMktni4lIoMtay/AADg4v49nSLN3/zNaE/u2UiuKRHB0NklUP3pp59Khw4dpHTp0rke06RJE71lUEHqatWqyccffyxDhw7N9XHuvhwZAGA/6uqfjBJWrJfgfmRUA/BGh08m623J9mNZbleXDFfMKCOSqRZ2dNEwyogAAGCxs6npUmfoHKM96v9qS9PYYpb2yVP5ZKB6165dMnfuXJk2bdplPS4wMFDq1KkjW7duzfM4d1+ODACwHzUHPfnkk2IX8+fPt/T1yagG4EtOJafJ2r0JestWRqRomBHAPh/IDpcId5cRcblEli8XmTlT1WUUadBA5OabRQJ88hQUAIBcF1yu+spMo923XRXpXKcMo5ULn3yXMH78eClevLh06tTpsh6nFnZSNTQ7duzotr4BAADrJac5re4CAJhTRuTIab3JhqxlREoUDP6vhEiBLF/zpVbm4cMid9wh8scf5wLTas2g1FQRdbWrSiZq1OjqXwMAAA/ncrkktv8Mo/1/9cvJU60qWdonT+dzgWq1KKIKVD/44IMScMGn9d26dZMyZcroGtPKkCFDpHHjxlKpUiVdz/rNN9/U2diPPPKIRb0HAABmSEknUA3A3g4lJuvtj61Zy4hEqDIimRdxzCgjUiRMAhz+F39iFZC+6SaRDRvOtdPSMr3oIbXCrsiaNSKxsfn9LQEA4FFueP18TeoGMYXl9TtrWdofb+BzgWpV8mP37t3y8MMPZ7tP3e7vf/7N1b///is9e/aUgwcPSuHChaVevXqyePFiqV69usm9BgDYXWpqqowdO1bvq7lJlQKBG8ebjGoAyNHJ5DRZs+eE3jILdPhJdNHwbAFs9TU8ONNp5Q8/iKxdm/OTp6eLJCeLjBol8t57/AQAAD7rwXHLZd+JM3o/IiRApj7e1OoueQWfC1S3bdtWp9ZfSj3Md955R28AAFhNzV1Hjhwx9uFeZFQDwOVJTXfJ1sOn9DZrfdYyIqUiQ4zAdfcPx0u0v7/4OXO5ckVlWE+aRKAaAOCzBv2wXhb8c+7cTlk7sK2l/fEmPheoBgAAuBgWUwSA/HMg4azeft96VG7ctl9icgtSZzh1iuEHAPikcb/vkAmLdxrtrcM7iJ9aqwGX5BKKjAEAAPiWFEp/AIBbbCtaVtL8HLkfoE7WqU8NAPBBv/x9QIb89N8aDSKyYUi7S1vfAQZGCwAA2E4ygWoAcIuvarWVAFd63gc98QSjDwDwKSt3HZcnJv1ltFe83EbCgihkcbkIVAMAANuh9AcAuMem4hXkg8Z36v1sBUAcDpEmTUQefZThBwD4jB1HT0uXD5cY7bm9W0hURLClffJWBKoBAIDtUPoDANznjeYPykvtn5E9kSXP3xgZKfLCCyJz5oiEhDD8AACfcOxUsrQaOd9oT328iV5cGFeGHHQAADyAWmAjUp3E/7cP90pNdzHEAOAufn7y1XXtdBmQKqcPy6ynmohUqECAGgDgU86kpEu9YXON9vv31pEGMUUs7ZO3I1ANAIAHCAwMlOeff97qbtgGGdUAYAI/PzlcvKxItWoMNwDAp6Q7XVLt1ZlGu3/HqnJzrdKW9skXUPoDAADYTkp6tsqpAAA3CAl0MK4e5NZbb5Xy5ctLSEiIlCpVSh544AHZv39/rscfP35cnnnmGalSpYqEhobqxz777LOSkJBgar8BwJO4XC6J7T/DaN/fuLw82jzW0j75CgLVAADAdsioBgBzBAdwyulJWrVqJV9//bVs3rxZvv32W9m2bZvceee5xS9zooLYahs5cqSsW7dOJkyYIDNnzpQePXqY2m8A8CQNhp8v93F9paIyrHNNS/vjSyj9AQCAB0hNTdUnf0r37t11KRC4DxnVAGAOMqo9S69evYz96Oho6devn3Tu3Fm/D8npvUeNGjV0QDtDbGysDB8+XO6//35JS0uTgABCCgDs5e5PlsjRUyl6v1iBYJn0SGOru+RTmFUAAPCQy8cyLr1V+3CvVEp/AIApyKj2XKqsx6RJk6Rp06aX9QG5KvtRsGBBgtQAbKf/d3/L0u3HjfaKl1tb2h9fxHVYAADAdij9AQDmCKZGtcd56aWXJDw8XIoWLSq7d++W77///pIfe/ToURk6dKg8+uijuR6TnJwsiYmJWTYA8HYfLdgmk5ftNtrbRnQUPz8/S/vkiwhUAwAA2yFQDQDmIKPa/VT5DhUsyWvbtGmTcXzfvn1l1apVMnv2bHE4HNKtW7dLuppLBZw7deok1atXl0GDBuV6XHx8vERGRhpbuXLl8u17BQAr/Lhmv7z2y/m/oxuHtBeHP0Fqd6D0BwAAsBV1Mp7mpLwKAJiBGtXu16dPH72+RV4qVqxo7BcrVkxv11xzjVSrVk0HkpcuXSpNmjTJ9fEnT56U9u3bS0REhHz33Xd5lgqJi4uT3r17ZwlwE6wG4K2WbT8mz3y5ymivHNBGQoMclvbJlxGoBgAAtpKc5rS6CwBgG2RUu19UVJTeroTT6TTKdeRGBZrbtWsnwcHB8sMPP0hISEiez6mOUxsAeLuth0/K/32y1GjPf6GlFC3A3zd3ovQHAACwFRZSBADzkFHtOZYtWybvv/++rF69Wnbt2iXz5s2Te+65R2JjY41s6n379knVqlVl+fLlRpC6bdu2cvr0afn00091++DBg3pLT0+3+DsCAPc5fPKstHl7odGe9mRTiSkWzpC7GRnVAAB4iLCwMKu7YAvUpwYA85BR7VnvM6ZNmyYDBw7UgedSpUrpch4DBgwwMqBTU1Nl8+bNkpSUpNt//fWXDnArlSpVyvJ8O3bskJiYGAu+EwBwr9PJadJw+K9G+6P760nd8oUZdhMQqAYAwAMEBQXpxY3gfinplP4AALOQUe05atasqbOo86ICz5kXVmzZsuUlLbQIAN6eyPL5kp2y63iSlC0cKiNmnF84ceAt1aV9jZKW9s9OCFQDAABbSU3jhBsAzEJGNQDAk8XP2CBjF+2QnNZaf/j6CvLQ9RWs6JZtEagGAAC2kkJNTQAwDRnVAABPDlJ/vHBHrvcHOkztDlhMEQAAz6BqQk6YMEFvah/uk0JGNQCYhoxqAICnlvtQmdR5Ufezvo25/E1+PQAAkANV/3HXrl16oxake6U5qVENAGYhoxoA4IlUTeqcyn1kpu5Xx8E8BKoBAICtpF3sHSkAIN+QUQ0A8ERq4cT8PA75g0A1AACwlbR0AtUAYBYyqgEAnii6SFi+Hof8QaAaAADYSlo6pT8AwCxkVAMAPFHlqAIXPcbfT+SBJjGm9AfnEKgGAAC2kkrpDwAwDRnVAABPs/ngSek2YcVFj+vZrIIEBRA6NROjDQAAbCWdxRQBwDRkVAMAPMmhxLPSbtRCo3177TI6czoz1X6seQWJ61jd/A7aXIDVHQAAAOcEBgYyFCZIpUY1AJiGTDQAgKc4eTZVGo341WiP615fbqxaQl6/s5Z8vmSnXjhR1aRW5T6Yv6xBoBoAAA8QFBQk/fv3t7obtsBiigBgHk70AQCeIDXdKTUHzTbaw2+voYPUGXNVj2YVLewdMlD6AwAA2EoapT8AwDQEqgEAVnO5XFL55V+M9uMtYuW+RtGW9gk5I1ANAABshYxqADBPoINTTgCAtTIHqdtfW1L6dahqaX+QO0p/AADgAdLS0uTrr7/W+3fddZcEBDBFu22syagGANMEEagGAFio07uLJM3p0vuxUeHy0QP1+Hl4MM6CAQDwAE6nU7Zs2WLsw31YTBEAzEPpDwCAVZ79cpWs359otOf2bsEPw8NxHRYAALCV9P8yKgAA7kdGNQDACm/P+Ud+WLPfaG8f0VH8/Pz4YXg4AtUAAMB2K34DAMxBRjUAwGxf/7lH3v313NWqyuZh7cXfnyC1NyBQDQAAbCWjRh0AwP1YTBEAYKYF/xyRF79Za7TXDGwrwQEOfghewqcC1YMGDdJp/Jm3qlXzXslz6tSp+piQkBCpWbOmzJgxw7T+AgAA86WRUQ0AplBXWJNRDQAwy/r9CfLguOVG+49+N0pkaCA/AC/iU4Fq5dprr5UDBw4Y2++//57rsYsXL5Z77rlHevToIatWrZLOnTvrbd26dab2GQAAmIeMagAwR6C/z51uAgA81L4TZ6TTu+djgD8/e4OUKRRqaZ9w+XzunUNAQICULFnS2IoVK5brsaNHj5b27dtL3759pVq1ajJ06FCpW7euvP/++6b2GQAAmCctndIfAGAGsqkBAGZIOJMq1782z2h/9nBDubZ0JIPvhQLEx2zZskVKly6tS3k0adJE4uPjpXz58jkeu2TJEundu3eW29q1ayfTp083qbcAAJwTFBQkAwcOZDhMkOpkMUUAMAOBagCAuyWnpct1g2cb7Te61JIW10Qx8F7KpwLVjRo1kgkTJkiVKlV02Y/BgwdLs2bNdCmPiIiIbMcfPHhQSpQokeU21Va35yU5OVlvGRITE/PxuwAAAO5ERjUAmCPQ4cdQAwDcxul0SZUBM432szdWkrsalGPEvZhPBao7dOhg7NeqVUsHrqOjo+Xrr7/Wdajzi8rSVkFwAADgfdKdlP4AADOQUQ0AcBeXyyUV+88w2rdcV1p6t63CgHs5n6tRnVmhQoXkmmuuka1bt+Z4v6phfejQoSy3qba6PS9xcXGSkJBgbHv27MnXfgMA7CctLU2mTp2qN7UP90lNp/QHAJgh0OHTp5sAAAvd9M5CY796qYLy3j11+Hn4AJ9+53Dq1CnZtm2blCpVKsf7VQ3rX3/9Ncttc+bM0bfnJTg4WAoWLJhlAwDgajidTtmwYYPe1D7ch9IfAGCOIALVAAA3ePzzlbL18Cm9H+DvJzOea8Y4+wifClS/8MILsmDBAtm5c6csXrxYbr/9dnE4HHLPPffo+7t166azoTM899xzMnPmTHnrrbdk06ZNMmjQIPnzzz/l6aeftvC7AAAA7sRiigBgjuAAnzrdBAB4gNd+2SQz159fW+6fYefLAMP7+VSN6r179+qg9LFjxyQqKkpuuOEGWbp0qd5Xdu/eLf7+598sNW3aVCZPniwDBgyQ/v37S+XKlWX69OlSo0YNC78LAADgTtSoBgBzUPoDAJCfJi3bJR8t2JYlSO3vz8K9vsSnAtVTpkzJ8/758+dnu61r1656AwAA9kDpDwAwB4spAgDyy7xNh+Tl79YZ7b8HtWWe8UFciwUAAGyFxRQBwBxkVAMA8sPfexPk4Ql/Gu2lca0lIiSQwfVBBKoBAICtpDldVncBAGyBjGoAwNXaczxJbnn/d6M98/lmUjIyhIH1UQSqAQCArRCoBgBzEKgGAFyNE0kp0uyN34z25EcaSdWSBRlUH+ZTNaoBAPBWgYGBEhcXZ+zDfdLSnQwvAJggyEFeFADgypxNTZfaQ+YY7bfvuk6aVirGcPo4AtUAAHgAPz8/CQoKsrobtsBiigBgDgLVAIAr4XS6pOorM412n5uukTvqlmUwbYCPuAEAgK2kOcmoBgAzBAb4MdAAgMvicrmkYv8ZRvvOemXlmdaVGUWbIKMaAAAPkJaWJj/99JPev/nmmyUggCnabWPNYooAYIogh4ORBgBclsw1qeuULyQju17HCNoIGdUAAHgAp9Mpa9as0Zvah/ukprsYXgAwQaCDjGoAwKV7eMIK2fvvGb0fFuSQ7568nuGzGdK1AACArbCYIgCYw+FPoBoAkLOUNKd8vmSn7DqeJNFFwmT3v0kyb9Nh4/71g9sxdDZEoBoAANhKOqU/AMAUAQ4u4AUAZBc/Y4OMXbRDcntbvmV4B73YPOyHQDUAALCVVEqrAIApAsmoBgDkEKT+eOGOXMfloetjJJAPOm2Lj7gBAIDbxcfHS4MGDSQiIkKKFy8unTt3ls2bN1sy8unUqAYAU5BRDQC4sNyHyqTOy2eLd+rjYE8EqgEAgNstWLBAnnrqKVm6dKnMmTNHUlNTpW3btnL69GnTRz/dxWKKAGCGADKqAQCZqJrUF6vCp+5Xx8GeKP0BAADcbubMmVnaEyZM0JnVK1eulObNm5v6E0gnQQMATBHgoL4oAOA8tXBifh4H30OgGgAADxAYGCgvvPCCse/rEhIS9NciRYrkeH9ycrLeMiQmJubbazvJqAYAU1D6AwCQWXSRsHw9Dr6H0h8AAHgAtap1eHi43nx9hWun0ynPP/+8XH/99VKjRo1ca1pHRkYaW7ly5fLv9QlUA4ApKP0BAMjs3kbRFx0QVTXqgSYxDJxNEagGAACmUrWq161bJ1OmTMn1mLi4OJ11nbHt2bMn314//WKF8QAA+YJANQAgg8vlkmqvZi0HmJOezSpIUADhSrui9AcAAB4gLS1NZs2apffbtWsnAQG+OUU//fTT8tNPP8nChQulbNmyuR4XHBysN3dwEqgGAFMEOgg0AADOaTTiV2MoShUMkUMnz2ZZWFFlUqsgdVzH6gyZjfnmWTAAAF5YDuPPP//U+zfddJP4YgbFM888I999953Mnz9fKlSoYFlf0in9AQCmcKioAwDA9u7/3zI5fPLc+jNFwoNkSf/WkpLmlM+X7NQLJ6qa1KrcB5nUIFANAABMKfcxefJk+f777yUiIkIOHjyob1f1p0NDQ039CTidpr4cANhWoINANQDY3avfr5Pftx412isHtNFfVVC6R7OKFvYMnohrsQAAgNt9+OGHutZ0y5YtpVSpUsb21VdfmT76LKYIAOYI8Od0EwDsbOzC7TJxyS6jvXV4B59fOB5Xh4xqAABgSukPT0HpDwAwRwAZ1QBgWz+vPSDDZ2w02huHtJcA1i7ARfARNwAAsFXA3INi5gDg08ioBgB7WrHzuDw1+S+j/eeANhIa5LC0T/AOBKoBAIBtpGdeWhwA4FZkVHueW2+9VcqXLy8hISG6BNcDDzwg+/fvv+QPezt0OHfZ/vTp093eVwDeaduRU9L1oyVG+7cXWkqxAsGW9gneg0A1AACwDcp+AIB5WEzR87Rq1Uq+/vpr2bx5s3z77beybds2ufPOOy/psaNGjaK2LIA8HTmZLK3fWmC0v32iiVQoFs6o4ZJRoxoAAA8QGBgozz33nLEP93A6GVkAMIuDxRQ9Tq9evYz96Oho6devn3Tu3FlSU1PzfP+xevVqeeutt+TPP//UmdgAcKGklDRpMHyu0f7wvrpSL7oIA4XLQqAaAAAPoC6jLVSokNXd8HlOClQDgGkC/P0YbQ92/PhxmTRpkjRt2jTPIHVSUpLce++9MmbMGClZsuRFnzc5OVlvGRITE/OtzwA8U1q6U6q/Ostov3JzdelQkw+1cPko/QEAAGyD0h8AYJ5AB6ebnuill16S8PBwKVq0qOzevVu+//77i2Zhq2D2bbfddknPHx8fL5GRkcZWrly5fOo5AE+k6tdXevkXo929aYz0uKGCpX2C9+KdAwAAHiA9PV1mz56tN7UP93CymCIAmMZBRrUpVPkOdWVWXtumTZuM4/v27SurVq3S7zkcDod069ZNB5py8sMPP8i8efN0fepLFRcXJwkJCca2Z8+efPk+AXim2kPmGPvNr4mSQbdea2l/4N0o/QEAgAdQweklS86tjt2yZUt94gg3jDOBagAwDYspmqNPnz7SvXv3PI+pWLGisV+sWDG9XXPNNVKtWjWd8bx06VJp0qRJtsepILVacPHC8mRdunSRZs2ayfz587M9Jjg4WG8AfF/XjxZLwplUvV8qMkQmPtzQ6i7ByxGoBgAAtkHpDwAwTwClP0wRFRWltyvh/G+V4cw1pS/M1n7kkUey3FazZk1555135JZbbrmi1wTgG176Zq2s2Pmv0V7c70ZL+wPfQKAaAADYBmspAoB5Ain94VGWLVsmK1askBtuuEEKFy6sM6VfeeUViY2NNbKp9+3bJ61bt5aJEydKw4YN9eKJOS2gWL58ealQgRq0gF2N+W2rfPXn+bI+20Z01GWGgKtFjWoAAGAblP4AAPNQo9qzhIWFybRp03QgukqVKtKjRw+pVauWLFiwwCjVkZqaKps3b5akpCSruwvAQ32/ep+8OWuz0d40tD1/75FvyKgGAAC2QaAaAMwT4E9elCdRJTtUzem8xMTE5LqwYoaL3Q/Ady3Zdkyem7LaaK965SYJCWRtHeQf3jkAAADbcHJyDQCmIU4NAL7jn0Mn5Z6xS432wr6tpHB4kKV9gu8hUA0AAGyDjGoAMA+lPwDANxxKPCtt31lotKc/db2ULxpmaZ/gmyj9AQCABwgMDJQnnnjC2Id7kFENAObxZ2EtAPB6p5LTpNGIX4322G71pXa5Qpb2Cb7LpzKq4+PjpUGDBhIRESHFixeXzp0764Ug8jJhwgS9MmnmLSQkxLQ+AwCgqPlHzV1qY8Vs93FSVhMATENGNQB4t9R0p9QYOMtoD73tWrmpeglL+wTf5lOBarVa8VNPPSVLly6VOXPm6BWL27ZtK6dPn87zcQULFpQDBw4Y265du0zrMwAAMA+lPwDAPA4yqgHAa6mFUyu//IvRfrR5RXmgSYylfYLv86nSHzNnzsyWLa0y01auXCnNmzfP9XEqc61kyZIm9BAAgJylp6fLokWL9H6zZs3E4WD1bHcgUA0A5vH392O4AcBLVX3lfIytTbUS0r9jNUv7A3vwqYzqCyUkJOivRYoUyfO4U6dOSXR0tJQrV05uu+02Wb9+fZ7HJycnS2JiYpYNAICrDVSrK4PUpvbhHtSoBgBzUPYDALzXre//LslpTr0fUzRM/vdgfau7BJvw2UC10+mU559/Xq6//nqpUaNGrsdVqVJFxo0bJ99//7188cUX+nFNmzaVvXv35lkLOzIy0thUgBsAAHg+MqoBwBwkUwOAd+r91WpZu/dc4qfy2wstLe0P7MVnA9WqVvW6detkypQpeR7XpEkT6datm9SuXVtatGgh06ZNk6ioKPn4449zfUxcXJzO1s7Y9uzZ44bvAAAA5DcWUwQAc/hTnxoAvM6ouf/ItFX7jPb2ER1Z6B2m8qka1Rmefvpp+emnn2ThwoVStmzZy3psYGCg1KlTR7Zu3ZrrMcHBwXoDAADehdIfAGAOSn8AgHf5ZuVeGTV3i9HePKw9aw3AdP6+tiKpClJ/9913Mm/ePKlQocJlP4eqC/r3339LqVKl3NJHAABgHUp/AIA5HGRUA4DX+H3LUXlh6hqjvebVthIcwOLuMF+Ar5X7mDx5sq43HRERIQcPHtS3qzrSoaGhel+V+ShTpoyuM60MGTJEGjduLJUqVZITJ07Im2++Kbt27ZJHHnnE0u8FAADkPye1PwDAFP4UqQYAr7DxQKLc/+kyo/37S60kMizQ0j7BvnwqUP3hhx/qry1bZi30Pn78eOnevbve3717t/j7n08k//fff6Vnz546qF24cGGpV6+eLF68WKpXr25y7wEAgLulu1wMMgCYgNIfAOCZUtKc8vmSnbLreJIUCg2Ud+edL3370zM3SNnCYZb2D/YW4GulPy5m/vz5WdrvvPOO3gAAsFJAQIBxNY/ah3tQ+gMAzMFiigDgeeJnbJCxi3bkuMD4+IcaSI0ykVZ0C/DNGtUAAHgrdbWPKk2ltsxX/iB/kVANAOag8gcAeF6Q+uOFOQeplaXbjprdJSAbzoQBAIBtOIlUA4ApKP0BAJ5V7kNlUudF3a+OA6xEoBoAAA+Qnp4uf/zxh97UPtyDODUAmIPSHwDgOVRN6outKa7uV8cBVqIIJgAAHkAFp+fOnav3GzRoIA6Hw+ou+SSWUgQAc5BRDQCeQy2cmJ/HAe5CRjUAALCNS1l4GQBw9QhUA4DniC4Slq/HAe5CoBoAANgGYWoAMAeLKQKA5zh08uwl/d1+oEmMKf0BckOgGgAA2AYJ1QBgDjKqAcAzfLl8t3yyMO+FFJWezSpIUABhQliL30AAAGAj5FQDgBlYTBEArPfbpsMSN+1vo929aXS2K15U+7HmFSSuY3XzOwhcgMUUAQCAbZBRDQDmIFANANZaty9BHpqwwmgvibtRSkWGSv+O1eXzJTv1womqJrUq90EmNTwFgWoAAGAb5FMDgDko/QEA1tn7b5Lc/N7vRvuX55rpILWigtI9mlW0sHdA7ghUAwDgAQICAuTBBx809uEeZFQDgDn8WU0RACyRkJQqN7z+m9H+vEdDqVaqID8NeAXOhAEA8AD+/v4SE8Mq2+7mIqcaAEzhuKAGKgDA/c6mpst1Q2Yb7TfvrCXNKkcx9PAaLKYIAABsg4xqADAHNaoBwFxOp0uqvjLTaD/fprJ0rV+OHwO8ChnVAAB4gPT0dFm5cqXer1evnjgcDqu75JOoUQ0A5vAjoxoATONyuaRi/xlG+/Y6ZeT5NtfwE4DXIVANAICHBKp/+eUXvV+7dm0C1W58Ew8AcD8/IVINAGZpNXK+sX9d2Uh55/9qM/jwSpT+AAAAAADkL+LUAGCKRz5bITuPJen9kEB/+f7pGxh5eC0C1QAAwDZIqAYAcxCnBgD3G/7zBpm78bDR3jikPcMOr0agGgAAAACQr6hRDQDuNXHJThm7aIfR3jK8g/jxxxdejkA1AACwDRfLKQKAKahRDQDuM2fDIXn1+/VGe93gdhLoIMQH78dvMQAAsA1KfwCAOUjqAwD3WL3nhPSc+KfRXta/tRQIDmC44RMIVAMAANsgUA0A5iBQDQD5b9ex09J5zB9Ge3av5lKiYAhDDZ/BRy4AAHiAgIAAueeee4x9uIeLgQUAU1D6AwDy1/HTKdLizflG+8uejeWaEhEMM3wKZ8IAAHgAf39/ueaaa6zuhs9zkVINAAAAL3M2NV3qDp1jtEffXVuaxBa1tE+AO1D6AwAA2AYZ1QBgDkp/AED+SHe6pOorM432i+2ryG21yzC88ElkVAMA4AHS09Pl77//1vs1a9YUh8NhdZd8E5FqAAAAeNHVgLH9ZxjtuxuUkydbVrK0T4A7EagGAMBDAtXff/+93q9evTqBajdxEakGAFP4kVINAFetSfw8Y79BTGF5rUstRhU+jdIfAADANihRDQDm8GOgAeCqPPDpMjmYeFbvR4YGytTHmzKi8HkEqgEAgG1Q+QMAzEFCNQBcuYHfr5NFW44a7dWv3sRwwhYIVAMAANsgoxoAzEFGNQBcmf8t2i6fLdlltLcO70A5JdgGgWoAAGAb1KgGAHNQoxoALt+Mvw/IsJ83Gu0NQ9pJgIPQHeyD33YAAGAbZFQDgDnIqAaAy/PnzuPy5KS/zrcHtJGwoACGEbZCoBoAANgGNaoBwBzUqAaAS7f9yCm586MlRvvXPi2kWIFghhC2w0czAAB4gICAALnzzjuNfbgJKdUAYBJyqgHgUhw9lSw3vrXAaH/zeBOJjSrA4MGWOBMGAMAD+Pv7y7XXXmt1N3weGdUAYA4yqgHg4pJS0qT+sLlGe8y9daV+TBGGDrZF6Q8AAGAbJFQDgDnIpwaAvKWlO6X6q7OM9oBO1aRTrVIMG2yNQDUAAB7A6XTK+vXr9ab2fdGYMWMkJiZGQkJCpFGjRrJ8+XKruwQAAACYzuVySaWXfzHa3ZpEyyPNKvKTgO1dcqB6//79PnsiPHXqVKlatao+vmbNmjJjxgzT+goAgJKWlibffPON3tR+fvKEOfyrr76S3r17y8CBA+Wvv/6S6667Ttq1ayeHDx82/aQAAOB+lP4AgPNS0pzy6aLt8ur36/TX2oPPZ1LfUKmYDLmtBsMFXE5GtaqbOXnyZI8ftMs9EV68eLHcc8890qNHD1m1apV07txZb+vWrTO97wAAuIMnzOFvv/229OzZUx566CGpXr26fPTRRxIWFibjxo0ztR+EqQHAHH4U//A4t956q5QvX14naJUqVUoeeOCBS/owe8mSJXLjjTdKeHi4FCxYUJo3by5nzpwxpc+AL4ifsUGqvvKLDP15o0xcskt/TTibru8rHhEsXzzSyOouAt4XqB4+fLg89thj0rVrVzl+/Lh4qss9ER49erS0b99e+vbtK9WqVZOhQ4dK3bp15f333ze97wAAuIPVc3hKSoqsXLlS2rRpk2XxSNVWJ785SU5OlsTExCxbfiChGgDMQUZ1zlq3bi3Tpk3LddyOHj0qFSu65/L/Vq1ayddffy2bN2+Wb7/9VrZt2yZ33nlnno9R87Q6X27btq2+UnnFihXy9NNP63kcwKUFqT9euEOcuWRLdK5dmmEEMrnk2eXJJ5+UtWvXyrFjx3QA+McffxRPcyUnwur2zMcrKgM7t+MBAPA2Vs/h6qQ7PT1dSpQokeV21T548GCOj4mPj5fIyEhjK1euXL70hYxqAICVfvvtN7nrrrv0FcA5UfPlrl273PLavXr1ksaNG0t0dLQ0bdpU+vXrJ0uXLpXU1NQ8H/Pss8/qY9UVWlWqVNH9Dw4OdksfAV8r9zF20Y48j/nf7zv0cQDOuayPQStUqCDz5s2TAQMGyB133CG1atXS2ceZNytdyYmwuv1yjndnlhcAAO7i6XP4heLi4iQhIcHY9uzZky/P65cvzwIAwJX78MMPZdSoUXL77bfL6dOnLRlKdYXVpEmTdMA6MDAwx2NU+cxly5ZJ8eLF9XHqPLlFixby+++/5/ncnC8D53y+ZGeumdQZ1P3qOADnBMhlUp/uqkuVChcuLLfddpsEBFz2U3g9leU1ePBgq7sBAIBXzOHFihUTh8Mhhw4dynK7apcsWTLHx6hMLXdka3EpOgCYg1JLuVNz8A033KC/qgzn77//3m3lPi700ksv6TKXSUlJ+rV/+umnXI/dvn27/jpo0CAZOXKk1K5dWyZOnKjLl6g1nSpXrpzj4zhfBs7ZdTwpX48D7OCyzlDHjh0rffr00aUy1q9fL1FRUeJJruREWN1+OcdnZHmpBRszqIzq/LokGQAAd7ByDg8KCpJ69erJr7/+qhcsVpxOp26rOpdmIqMaAMzhothSntT6SKre8z333CMNGjSQr776KltJykuhSnK8/vrreR6zceNGqVq1qt5XazP16NFDf3itkq+6deumg9V+OXySq+ZqRa1zodaAUurUqaPnb7UGlApI54TzZeCc6CJh+XocYAeXHKhWCyioxRPUp69qMvNEV3Ii3KRJE33/888/b9w2Z84cfXtu3JXlBQCwL/VBq8qsytjPT54wh6sPeB988EGpX7++NGzYUF/yrC53zjjxNUtOJ+IAgPxHRvXFqTUYfv75Zx3Y7dixow4433vvvZc1zupD6O7du+d5TOZsbZXcpbZrrrlGB8tVwpWqU53T+W+pUqX0V7W+RWbqcbt378719ThfBs5pd21JGfrzxjyHw99P5IEmMQwZcLmBalX7WS3EVLZsWfFkFzsRVifoZcqUMT79fe6553Sdrbfeeks6deokU6ZMkT///FM++eQTi78TAICdqOC0uqTWHTxhDv+///s/OXLkiLz66qt6HQj1vc6cOTPbOhHuRpwaAMzB4rWX9oGpar/22mt6XnzkkUf0ehKXQ10hdaVXSWVkTKua0jmJiYmR0qVLy+bNm7Pc/s8//0iHDh2u6DUBuziVnCY3vPHbRY/r2ayCBAVc1vJxgE+75EC1yjL2Bhc7EVaf/Pr7n/8joBaFmDx5sl5cqn///rrO1vTp06VGjRoWfhcAAOQfT5nD1dVNZpf6uBD51ABgDjKqcxuXnEP4d999ty7PkXFlcH5TiyKqUiOqNrZaq2Lbtm3yyiuvSGxsrJFNvW/fPl1/WtWhVklfKoiuSoUMHDhQrrvuOn1u/dlnn8mmTZvkm2++cUs/AV+Qmu6UGgNnGe2msUVl6fZjWRZWVJnUKkgd1zHrFQuA3fnkSoh5nQjPnz8/221du3bVGwAAVlFZTVu3btX7lSpVyvKhKvIRKdUAYBJyqnPy22+/SZEiRXK8TwWCV65cqcuB5LewsDC9oLIKOqsrjlVZD1UaTCVsZZS1TE1N1dnTaqHFDKpE5tmzZ6VXr15y/PhxHbBWH4CrADeAnD+MqvzyL0a7xw0V5JWbq0tKmlM+X7JTL5yoalKrch9kUgM2CVQDAOBt0tLS5Msvv9T7qlalWncB+Y+MagAwBxnVOVNlJ/NStGhRt6wnUbNmzYuWFVGlPnLK+FYLNqoNwMVdmymTunXV4jpIraigdI9m5+vFA8gZ6VoAAMA2SKgGAHOQTw3Abm4b84ckpaTr/fJFwuTT7g2s7hLgdQhUAwAA2/AjpxoAAAD5rPdXq2XNnhNGe0HflowxcAUIVAMAANsgoxoArF00EAB8zei5W2Taqn1Ge/uIjnoxUgCXj0A1AAAAACBfEaYGYAffrtwr78z9x2hvGtpe/P0JUgNXikA1AACwDU4bAMAcJFQD8HV/bD0qfaauMdqrX71JQgIdlvYJ8HYEqgEAgG1wFSYAmIOMagC+bNPBRLnvf8uM9qIXW0mhsCBL+wT4ggCrOwAAAEQcDod06NDB2Id7sJgiAJiDGtUAfNWBhDPSftQio/3D09dLuSJhlvYJ8BUEqgEA8AAqON2wYUOru+H7qP0BAACAK3TybKo0iZ9ntMd1ry+1yhZiPIF8QukPAABgG8SpAcAc1KgG4GtS0pxSc9Bsoz389hpyY9USlvYJ8DVkVAMA4AGcTqfs3r1b75cvX178/fks2R38KFINAKZwUaUagA9xOl1yzYBfjPYTLWPlvkbRlvYJ8EWcBQMA4AHS0tLks88+05vah3uQUQ0A5iCjGoAv1dyv9PIMo92hRkl5qX1VS/sE+CoC1QAAwDZIqAYAcxCoBuArOoxeJE7Xuf3KxQvIh/fXs7pLgM8iUA0AAGyDQDUAmIPSHwB8wdOT/5JNB08a7dm9mlvaH8DXEagGAAC24UfxDwAwBRnVALzdyFmb5ae1B4z29hEdWe8EcDMC1QAAwDbIqAYAAMDFTFm+W97/bavR3jysvfj7s9oJ4G4EqgEAAAAA+eq/cq4A4HXmbz4s/ab9bbTXDGwrwQEOS/sE2AWBagAAYBt+pFQDgDmIVAPwQuv2JUj38SuM9uJ+N0pkaKClfQLsJMDqDgAAABGHwyFt2rQx9uEeXLAJAOZgMUUA3mbfiTNy83u/G+0ZzzaT0oVCLe0TYDcEqgEA8AAqOH399ddb3Q2fR0I1AJjDSUY1AC+ScCZVrn9tntGe+HBDqV66oKV9AuyI0h8AAMA2/MipBgBTOF1EqgF4h+S0dLlu8Gyj/cadtaT5NVGW9gmwKzKqAQDwAE6nUw4cOKD3S5UqJf7+fJYMAPBeTlKqAXjJ36oqA2Ya7WdbV5a76peztE+AnXEWDACAB0hLS5P//e9/elP7cA9KfwCAOdLJqAbg4Vwul1TsP8No31a7tPS+6RpL+wTYHYFqAABgGyymCADmSHcy0gA8W+u3Fhj7NcoUlNF317G0PwAIVAMAABshoxoAzEHpDwCe7NGJf8r2o6f1fpDDX356ppnVXQJAoBoAANgLOdUAYAYWUwTgqeJnbJTZGw4Z7U1D21vaHwDnUfoDAADYBhnVAGAOalQD8ESfL90lHy/cbrS3DO8g/v4kMgCeIsDqDgAAAJiF0xAAMAelPwBYLSXNKZ8v2Sm7jidJdJEwKVsoVF6Zvs64/+9BbSXQQf4m4EkIVAMAANvwI6UaAExBRjUAK8XP2CBjF+0Qpyvn+5fGtZaIkECzuwXgIghUAwDgARwOh7Ro0cLYh3uQUQ0A5nA6GWkA1gWpP164I9f776xXVkpGhpjaJwCXhmscAADwACo43bJlS70RqHYfEqoBwBzpuaUxAoCby32oTOq8TPtrrz4OgOchUA0AAGyDxXIAwByU/gBgBVWT+mKfk6n71XEAPA+lPwAA8AAul0uOHDmi96Oioqil7CYOUqoBwBQspgjACmrhxPw8DoC5yKgGAMADpKamyocffqg3tQ/38CdQDQCmcLoo/QHAfNFFwvL1OADmIlANAABsw593PgBgCmpUA7DCA01iLnqMv9+lHQfAfJyuAQAA26D0BwCYg7UUAVjh0c//vOgxPZtVkKAAwmGAJ+J/JgAAsA2HSqEBALgdGdUAzDb4x/Uyf/O5NV+UC9/2qfZjzStIXMfq/HAAD+UzgeqdO3dKjx49pEKFChIaGiqxsbEycOBASUlJyfNxLVu21AtWZd4ef/xx0/oNAADM40+gGgBMkU6NagAmGv/HDhn/x06jvXV4B9k0tIO80qmadGsSrb+qNkFqwLMFiI/YtGmTOJ1O+fjjj6VSpUqybt066dmzp5w+fVpGjhyZ52PVcUOGDDHaYWEU1QcAwBdR+gMAzOGk9gcAk8xcd1AG/7jBaK8f3E4CHOfyMns0q8jPAfAiPhOobt++vd4yVKxYUTZv3iwffvjhRQPVKjBdsmRJE3oJAACsROkPADAHGdUAzPDX7n/l8S9WGu3lL7eW8GCfCXUBtuMzpT9ykpCQIEWKFLnocZMmTZJixYpJjRo1JC4uTpKSkkzpHwAAGRwOhzRp0kRvah/u4UeJagAwBZU/ALjbjqOn5Y4PFhvtub1bSPGIEAYe8GI++zHT1q1b5b333rtoNvW9994r0dHRUrp0aVm7dq289NJLOhN72rRpuT4mOTlZbxkSExPzte8AAPtRwem2bdta3Q2fR0Y1AJi7oCJ/dwG4w7FTydJq5Hyj/dWjjaVS8QIMNuDlPD5Q3a9fP3n99dfzPGbjxo1StWpVo71v3z5dBqRr1666/nReHn30UWO/Zs2aUqpUKWndurVs27ZNL8iYk/j4eBk8ePBlfy8AAMBa1KgGAPMQqAbgDmdS0qXesLlG+7176kijikUZbMAHeHyguk+fPtK9e/c8j1H1qDPs379fWrVqJU2bNpVPPvnksl+vUaNGRkZ2boFqVR6kd+/eWTKqy5Urd9mvBQBABpfLpUtWKZGRkeJHjQq38Pen9gcAmMVJ/Q8AbvgArNqrM412XIeqcst1pRlnwEd4fKA6KipKb5dCZVKrIHW9evVk/Pjx4u9/+SW4V69erb+qzOrcBAcH6w0AgPySmpoqo0ePNj4QDQoKYnDdgIxqADA3oAQA+ZnYEdt/htG+r1F5eaxFzgmGALyTzyymqILULVu2lPLly+u61EeOHJGDBw/qLfMxqkTI8uXLdVuV9xg6dKisXLlSdu7cKT/88IN069ZNmjdvLrVq1bLwuwEAAO5ArVQAME86GdUA8lGD4b8a+00qFpXht9dkfAEf4/EZ1Zdqzpw5ulyH2sqWLZvtU7eMbDW1UGJSUpJuq2y1uXPnyqhRo+T06dO6fEeXLl1kwIABlnwPAADAvSj9AQDmcZJRDSCf3PPJUjl6KlnvFw0Pki8fbczYAj7IZwLVqo71xWpZx8TEGEFrRQWmFyxYYELvAACAJ6BENQCYJ41ANYB8MGD637Jk+zGj/eeANowr4KN8pvQHAADAxVCjGgDMk5ZOjWoAV+eThdvki6W7jfbW4R1YdBzwYQSqAQCAbVD6AwDMk5ruZLgBXLGf1u6XETM2Ge2NQ9pLgIMwFuDL+B8OAABsg4xqADBPOqU/AFyh5TuOy9OTVxntlQPaSGiQg/EEfJzP1KgGAMCb+fv7S/369Y19uGuc/RhaADBJmpOMagCXb+vhU3LXx0uM9m8vtJSiBYIZSsAGOBMGAMADBAQESKdOnfSm9uEeDgLVAGCaVGpUe5Rbb71VypcvLyEhIVKqVCl54IEHZP/+/Xk+5uDBg/q4kiVLSnh4uNStW1e+/fZb0/oM+zlyMlnavL3AaH/7RFOpUCzc0j4BMA+BagAAYBuU/gAA87CYomdp1aqVfP3117J582YdbN62bZvceeedeT6mW7du+vgffvhB/v77b7njjjvkrrvuklWrzpdkAPLL6eQ0aTB8rtH+8L66Ui+6MAMM2AiBagAAPIDL5ZLTp0/rTe3DPaiqAgDmSaX0h0fp1auXNG7cWKKjo6Vp06bSr18/Wbp0qaSmpub6mMWLF8szzzwjDRs2lIoVK8qAAQOkUKFCsnLlSlP7Dt+Xlu6UawfOMtqv3FxdOtQsZWmfAJiPQDUAAB5AnSSOHDlSb3mdMOLq+PtRoxoAzMJiip7r+PHjMmnSJB2wDgwMzPU4df9XX32lj3c6nTJlyhQ5e/astGzZ0tT+wrepJI1KL/9itLs3jZEeN1SwtE8ArEGgGgAA2AalPwDAPKnpLKboaV566SVda7po0aKye/du+f777/M8XpUKUR+gq+ODg4Plsccek++++04qVaqU62OSk5MlMTExywbkpdbg2cZ+i2uiZNCt1zJggE0RqAYAALbhz2KKAGAaalS7nyrf4efnl+e2adMm4/i+ffvq+tKzZ88Wh8Oha1DnVXLslVdekRMnTsjcuXPlzz//lN69e+sa1apedW7i4+MlMjLS2MqVK5fv3zd8R5cPF8vJs2l6v3RkiHz2cEOruwTAQgFWvjgAAIDZHP5+XI4OACZIo0a12/Xp00e6d++e5zGqtnSGYsWK6e2aa66RatWq6SCyqlPdpEmTbI9Tiy2+//77sm7dOrn22nMZrtddd50sWrRIxowZIx999FGOrxcXF6cD2hlURjXBauSk79Q1snLXv0b7j343MlCAzRGoBgAAtiv/kS4sWAkA7kZGtftFRUXp7UqomtMZpTpykpSUpL/6X7ASscrEznhsTlSJELUBeRnz21aZunKv0d42oqO+AgCAvVH6AwAAuM3OnTulR48eUqFCBQkNDZXY2FgZOHCgpKSkWDbqF5xvAwDcJM3Jh4KeYtmyZTo7evXq1bJr1y6ZN2+e3HPPPXpezsim3rdvn1StWlWWL1+u22pf1aJWdanVbSrD+q233pI5c+ZI586dLf6O4M2mr9onb87abLQ3DW2vr3gDADKqAQCA26i6mCrr6uOPP9Ynu+ry4Z49e8rp06dl5MiRlow8CyoCgDlYTNFzhIWFybRp0/SHxWoOLlWqlLRv314GDBhgZD+rRRM3b95sZFIHBgbKjBkzdB3sW265RU6dOqXn8s8++0w6duxo8XcEb7V421F5/qvVRnvVKzdJSKDD0j4B8BwEqgEA8ADqslpV9zFj31eok2C1Za6TqU6CP/zwQ8sC1f5cVgoApqD0h+eoWbOmzqLOS0xMTLaFFStXrizffvutm3sHu/jn0Em5d+wyo72wbyspHB5kaZ8AeBYC1QAAeICAgADbXEabkJAgRYoUsez1/bm0FABMkU7pDwD/OZR4Vtq+s9AYj+lPXS/li4YxPgCyIFANAABMs3XrVnnvvfcumk2tFnbKvLhTYmJivvWBGogAYI7UPBbcA2AfJ8+mSqMRvxrtsd3qS+1yhSztEwDP5DvXFgMA4MXUpbZqgUG1XXjZrSdS9SrVyux5bao+dWZqkSZVBqRr1666TnVe4uPjJTIy0tjKlSuXb32n9AcAmIPSH4A9r6T4Y8tRGTlrk4yctVkW/HNYag6abdw/tHMNual6CUv7CMBzkVENAIAHUAsYqeCsEhcXJ0FBnl2vr0+fPtK9e/c8j1H1qDPs379fWrVqJU2bNpVPPvnkos+vxqB3795ZMqrzK1jt4GN6ADAFiykC9jJz3QHpN+1vOZGUev7G387vPtq8ojzQONqSvgHwDgSqAQDAZYuKitLbpVCZ1CpIXa9ePRk/fvwlLRYZHBysN3dwsJgiAJiCGtWAvYLUj3/xV57H1C1PuQ8AeSOnCAAAuI0KUrds2VLKly+v61IfOXJEDh48qDersJgiAJgjjcUUAdt8KDXoh/UXPW7wjxv4AAtAnsioBgAAbjNnzhy9gKLaypYtm+U+q2pxs5giAJiD0h+APSzfcVwOJp5fBDs3BxLO6mObxBY1pV8AvA8Z1QAAwG1UHWsVkM5ps0qAv59lrw0AdsJiioA9HD551i3HArAfAtUAAMBWAllNEQBMQekPwB6KR4S45VgA9kOgGgAA2EqAg4xqADBDWrqTgQZsoGGFIlI4NPCix5WKDNHHAkBuqFENAIAH8Pf3l+rVqxv7cB8H4wsApiCjGrCHzQdPyr9nUi963MBbqrNWCIA8EagGAMADBAQESNeuXa3uhi0EUqMaAEyRQkY14PP2nzgjHd9dZLQjQgLk5Nm0LMcUDguU+DtqSvsapSzoIQBvQqAaAADYCqU/AMAcKWmU/gB8WcKZVGn62jyjPf6hBtK8cpQs3XZMlmw/KiJ+0iS2qDSuWJRMagCXhEA1AACwFRZTBABzpJJRDfis5LR0uW7wbKP92h01pVWV4nr/+srF9AYAl4tANQAAHiAlJUXi4+P1flxcnAQFBVndJZ8VQOkPADAFGdWAb3I6XVJlwEyj/XSrSnJ3w/KW9gmAb2C1JgAAYCsspggA5iBQDfgel8slFfvPMNqdapaSF9pVsbRPAHwHgWoAAGArgQ4/q7sAALbAYoqA72k3aqGxX6VEhIy5r66l/QHgWwhUAwAAWwlw8PYHAMxARjXgW574YqX8c+iU0Z75fDNL+wPA93CmBgAAbCWQGtUAYAoyqgHf8cbMTfLLuoNGe/uIjuLnx1VqAPIXgWoAAGArDgLVAGCK1HQnIw34gMnLdssH87cZ7X+GdRB/3k8BcAMC1QAAwFYo/QEA5qD0B+D9ftt0WPp/97fRXjuorQQFEEoC4B4BbnpeAABwGfz9/aVy5crGPtyHxRQBwBwEqgHv9vfeBHlowgqjvSTuRikYEmhpnwD4Np86E46JidE1kjJvr732Wp6POXv2rDz11FNStGhRKVCggHTp0kUOHTpkWp8BAFACAgLk3nvv1Zvah/sE8EEAAJiCQDXgvfYcT5Jb3v/daP/yXDMpFRlqaZ8A+D6fClQrQ4YMkQMHDhjbM888k+fxvXr1kh9//FGmTp0qCxYskP3798sdd9xhWn8BAIC5Ahws/AMAZkhJdzHQgBc6kZQizd74zWh/0aORVCtV0NI+AbAHn0vZioiIkJIlS17SsQkJCfLpp5/K5MmT5cYbb9S3jR8/XqpVqyZLly6Vxo0bu7m3AADAbAEs/gMApkhJS2ekAS9zNjVdag+ZY7RHdr1ObqhczNI+AbAPn8uoVqU+VBmPOnXqyJtvvilpaWm5Hrty5UpJTU2VNm3aGLdVrVpVypcvL0uWLMn1ccnJyZKYmJhlAwDgaqSkpMiIESP0pvbhPiymCADmSEl3MtSAF3E6XVL1lZlGu1eba+TOemUt7RMAe/GpjOpnn31W6tatK0WKFJHFixdLXFycLv/x9ttv53j8wYMHJSgoSAoVKpTl9hIlSuj7chMfHy+DBw/O9/4DAOxNfXgK9wskoxoATJFK6Q/Aa7hcLqnYf4bRvqNOGXmuzbmFvgHALB6fUd2vX79sCyReuG3atEkf27t3b2nZsqXUqlVLHn/8cXnrrbfkvffe0xnQ+UkFwFXZkIxtz549+fr8AADAfRzUqAYAU6Q7XXoD4PlavDnf2L+ubKS8/X+1Le0PAHvy+IzqPn36SPfu3fM8pmLFijne3qhRI136Y+fOnVKlSpVs96ta1ury6hMnTmTJqj506FCeda6Dg4P1BgAAvE+gv8d/Tg8APiMlzSmhQQ6ruwEgDz0mrJDdx5P0fnCAv3z/9A2MFwBLeHygOioqSm9XYvXq1eLv7y/FixfP8f569epJYGCg/Prrr9KlSxd92+bNm2X37t3SpEmTq+o3AADwTAFkVAOAqXWqQ4VANeCphv20QX7ddNhobxzS3tL+ALA3jw9UXyq1+OGyZcukVatWEhERodu9evWS+++/XwoXLqyP2bdvn7Ru3VomTpwoDRs2lMjISOnRo4cuGaLqWhcsWFCeeeYZHaRu3Lix1d8SAABwAxZTBABzM6oBeKbPFu+U//2+w2hvGd5B/FnLA4CFfCZQrUpxTJkyRQYNGqRrUleoUEEHqlUQOvMiVSpjOinp3CUtyjvvvKOzrlVGtXpcu3bt5IMPPrDouwAAAO4WwAkYAJiaUQ3A88xef1AG/rDeaK8b3E4CHZRHA2AtnwlU161bV5YuXZrnMTExMXol28xCQkJkzJgxegMAwCpqceDo6GhjH+5DoBoAzJNKRjXgcVbt/lce/Xyl0V7ev7UUCPaZ8BAAL8ZfIgAAPIBaM+Fiiwcjn8aabCEAMA0Z1YBn2XXstNz+wWKjPadXcyleMMTSPgFABq7rAAAAtsJiigBgHmpUA57j+OkUafHmfKP9Zc/GUrlEhKV9AoDMCFQDAABbofQHAJgnmdIfgEc4m5oudYfOMdqj764tTWKLWtonALgQpT8AAPAAKSkpMnr0aL3/3HPPSVBQkNVd8lkB/nxODwBmSWUxRcBy6U6XVH1lptF+sX0Vua12GUv7BAA5IVANAICHSEpKsroLtkDpDwAwD6U/AGu5XC6J7T/DaN/doJw82bKSpX0CgNyQUgQAAGyFxRQBwDwEqgFrNY7/1dhvEFNYXutSy9L+AEBeCFQDAABbcfj7Wd0FALCNs2npVncBsK0HPl0mhxKT9X7BkACZ+nhTq7sEAHmi9AcAALCVQAeBagAwS3Kqk8EGTLp64fMlO2XX8SSJLhIm24+ekkVbjhr3rxnYlp8DAI9HoBoAANgKiykCgHnIqAbcL37GBhm7aIc4XTnfv3V4B/Hz44N6AJ6PQDUAALAVFlMEAPOcJaMacHuQ+uOFO3K9/+HrYyTAQdVXAN6Bv1YAAHgAleVSunRpvZHx4l5kVAOAeZKpUQ24tdyHyqTOy4TFO1nUFIDXIKMaAAAPEBgYKD179rS6G7ZAjWoAMA8Z1YD7qJrUuZX7yKDuV8f1aFaRHwUAj0dGNQAAsJVALn8FANOQUQ24j1o4MT+PAwCrEagGAAC2EhzA2x8AMEsyNaoBt4kuEpavxwGA1ThTAwDAA6SmpsqoUaP0pvbhPmRUA4B5zqamM9yAm9zTsPxFj/H3E3mgSQw/AwBegRrVAAB4AJfLJQkJCcY+3CeIjGoAME1ympPRBtxAvV+sPnDWRY/r2awC730AeA0yqgEAgK0QqAYA85BRDbhHnaFzjP0yhUJ05nRmqv1Y8woS17E6PwIAXoOMagAAYLvSH35+KhPJ6p4AgO8jUA3kv7s+WiInks6ViitRMFj+6NdaUtKc8vmSnXrhRFWTWpX74MN5AN6GjGoAAGA71KkGAHNQ+sMzJScnS+3atcXPz09Wr16d57Fnz56Vp556SooWLSoFChSQLl26yKFDh0zrK7Lq9+1aWb7zuNFeGtdaf1VB6R7NKsqQ22rorwSpAXgjAtUAAMB2gh28BQIAM5BR7ZlefPFFKV269CUd26tXL/nxxx9l6tSpsmDBAtm/f7/ccccdbu8jsvtg/laZsmKP0d42oqP+sAEAfAVnaQAAwHbIMgIAc5xNZTFFT/PLL7/I7NmzZeTIkRc9Vi30/Omnn8rbb78tN954o9SrV0/Gjx8vixcvlqVLl5rSX5zz/ep98sbMzcZwbBzSXhwXFqYGAC9HoBoAAA+gsmGioqL0RmaM+1H6AwDMkZyWzlB7EFWyo2fPnvL5559LWFjYRY9fuXKlpKamSps2bYzbqlatKuXLl5clS5a4ubfIsGTbMXluyvkSLX+9cpOEBjkYIAA+h8UUAQDwAIGBgfLkk09a3Q3bIKMaAMxBRrXncLlc0r17d3n88celfv36snPnzos+5uDBgxIUFCSFChXKcnuJEiX0fbnVv1ZbhsTExHzovX1tOXRS7hl7Pnt9/gstpUh4kKV9AgB3IaMaAADYDoFqADAHiym6X79+/fTVWHltmzZtkvfee09OnjwpcXFxbu1PfHy8REZGGlu5cuXc+nq+7HDiWbnpnYVG+7snm0pMsXBL+wQA7kRGNQAAsB1KfwCAOZJTKf3hbn369NGZ0nmpWLGizJs3T5frCA4OznKfyq6+77775LPPPsv2uJIlS0pKSoqcOHEiS1a1KiGi7suJCoT37t07S0Y1werLdyo5TRqO+NVof/JAPalTvvAVPBMAeA8C1QAAeABV/3Hs2LF6X9WOVKVA4D5kVAOAOc5So9rtMta4uJh3331Xhg0bZrT3798v7dq1k6+++koaNWqU42PU4onqPcmvv/4qXbp00bdt3rxZdu/eLU2aNMnxMSoQfmEwHJcnNd0pNQbOMtqDb71W2l6b8wcDAOBLCFQDAOAhdSOPHDli7MO9gh1UPwMAM6Smu8TpdIm/vx8DbjG1AGJmBQoU0F9jY2OlbNmyen/fvn3SunVrmThxojRs2FCX7ujRo4fOkC5SpIgULFhQnnnmGR2kbty4sSXfh69T7wMrv/yL0X7khgryYNMYS/sEAGYhUA0AAGwnMICACQC4m584pXLwbkk5vERCilQTCaJsgTdc4aUyppOSkozb3nnnHfH399cZ1WqRRJWF/cEHH1jaT19W7dWZxn7rqsVlwM3VLe0PAJiJQDUAALCdIDKqAcCt7io8W54tMUXKBh0Wmaei1oEiMfeI1BkpEnLxMhVwv5iYmGxXceV0W0hIiIwZM0ZvcK/b3v9dzqY69X75ImHyafcGDDkAW+G6VwAAYDvUqAYA93m6+BR5o9y7Ujrw8PkbXakiOyeJzG4sknyM4Qcu0Pur1bJmb4LRXtC3JWMEwHYIVAMAANsJJKMaANyiTOBh6V1ikt7PVpbalS5yepfIhtcZfSCT0XO3yLRV+4z2thEdxc+PMmUA7IdANQAAsB0yqgHAPe4sPFeckkeATQWrt44VcabzIwBE5JuVe+Wduf8YY7FpaHtxsPgoAJuiRjUAAB5AZc1ERkYa+3Cv4AA+qwcAdygfdPDiB6WeEElLZHFF2N7vW47KC1PXGOOw+tWbJCTQYftxAWBfBKoBAPAAgYGB8vzzz1vdDdtgMUUAyB/qs9UyhUKlUvECUimqgNTwixH/RH8RlzOPBwWIOML5EcDWNh5IlPs/XWa0F73YSgqFBVnaJwCwGoFqAABgO9SoBoDLE+DvJ9FFw6Ry8YhzQen/ttioAhIalCkD9OijIrPH5R2kLt9VxEFADvZ1IOGMdBi9yGj/+PQNUq5ImKV9AgBPQKAaAADYDjWqASBnoYEOqRgVbmRIVy5xLiAdXTT80j7kK9pQpHQnkQMzz9WjzsL/XKD62jiGH7aVeDZVmsTPM9rjuzeQmmXPlX8DALvzmUD1/PnzpVWrVjnet3z5cmnQoEGO97Vs2VIWLFiQ5bbHHntMPvroI7f0EwCAnKSmpsqECRP0fvfu3XUpEF+TnJwsjRo1kjVr1siqVaukdu3alvWFQDUAu4sMDTSC0ZkzpMsWDr26tRLUY2/4WmTpwyK7v1Y3iPipUiBpIqGlRK7/UqRQzfz8VgCvkZLmlFqDZhvtEbfXlFZVi1vaJwDwJD4TqG7atKkcOHAgy22vvPKK/Prrr1K/fv08H9uzZ08ZMmSI0Q4L45IbAIC5XC6X7N+/39j3RS+++KKULl1aB6qtRukPAHZRPCLYCEJXVqU6/tsvHhHivhcNCBO5YYrIyeEi+34UST9zLjhdqoOIPwvFwZ6cTpdcM+AXo/1ky1i5t1F5S/sEAJ7GZwLVQUFBUrJkySyZad9//70888wzF80IUIHpzI8FAAD565dffpHZs2fLt99+q/etFhxwCZevA4CX8FcLGhYOPV8/Oup8QFplTlsmIlakKgsFAyoJoWL/GcZAdKxZUl5sX5WBAQBfDVRf6IcffpBjx47JQw89dNFjJ02aJF988YUOVt9yyy06E5usagAA8sehQ4f01UvTp0/3mPmV0h8AvFGgw09iiv5XP/qCBQ1DAslUBjxV5oUT1ZUNH9xXz9L+AICn8tlA9aeffirt2rWTsmXL5nncvffeK9HR0fpS5LVr18pLL70kmzdvlmnTpuVZY1NtGRITE/O17wAA+FIGkaq5/fjjj+tSXDt37rykx7l7rqX0BwBPX9Awtni4kSGtAtHqa0zRMAm4lAUNAXiMpyb/JZsOnjTas3s1t7Q/AODJPD5Q3a9fP3n99dfzPGbjxo1Ster5y2b27t0rs2bNkq+/Vot35O3RRx819mvWrCmlSpWS1q1by7Zt2yQ2NjbHx8THx8vgwYMv6/sAAMCXXOr8rMp9nDx5UuLi4i7r+d091wYR6AHgAQqFBWZbzFBtZQpd5YKGADzCyFmb5ee159fS2j6iI/+3AcCbA9V9+vTRmVh5qVixYpb2+PHjpWjRonLrrbde9us1atRIf926dWuugWp1st27d+8sWV7lypW77NcCAMBbXer8PG/ePFmyZIkEBwdnuU9lV993333y2WefWTLXUvoDgJlKFPxvQUMVlC4RYQSnoyKy/m0E4Du+XL5b3v9tq9HePKy9+KuC8gAA7w1UR0VF6e1yLjFWgepu3bpJYODlLxyyevVq/VVlVudGnWxfeMINAMDV8pT6zfk5P7/77rsybNgwo71//35dmuurr74yPhy2Yq6l9AeA/KbiT2ULh+n6s7pcR6YM6YIhFi5oCMB0v206LHHT/jbaawa2leAA6sgDgNcHqi+XytzasWOHPPLII9nu27dvny7rMXHiRGnYsKEu7zF58mTp2LGjzsBWNap79eolzZs3l1q1alnSfwCAPQUFBUnfvn3F15QvXz5Lu0CBAvqrumrpYutIuFNwADVeAVx56aCYYmHZMqQrRoWzoCEAWbcvQR6asMIYicX9bpTIUD6sAgBbBqrVIopNmzbNUrM6Q2pqql4oMSkpyQgKzJ07V0aNGiWnT5/WlxR36dJFBgwYYEHPAQCAWSj9AeBiwoIcehHDyhdkR0cXYUFDAOekpDnl8yU7ZdfxJP23oWWV4nLze78bwzPj2WZSulAowwUAdg1Uqwzp3MTExOjSIBlUYHrBggUm9QwAAFw4F1uFQDWAzAsaGuU6/qsdXblEhJSODGHRMwC5ip+xQcYu2iHOTG9rhv680dif+HBDqV66ICMIAHYOVAMA4I3UVT+TJk3S+2qRwStZZwGXjhrVgP2ULBhiZEVn3ooVYO0ZAJcfpP544Y5c729xTZQ0v+bS19oCAJxDoBoAAA+gsox37dpl7MP9NWYB+OaChuWKhJ0v1/FfhrTaIljQEEA+lftQmdR5WbTliD6OK7gA4PIQqAYAALbDiSPg/R82VSgWfq5cx3+BaBWcVreFBDqs7h4AH6ZqUmcu95ETdb86rkezimZ1CwB8AoFqAABgO8EBZFQD3iA8yJElGJ2RIR1dNFwcKn0aAEymFk7Mz+MAAOcRqAYAALYTHEigGvAkRcKDdBBaBaQzFjZUWykWNATgYaKLhOXrcQCA8whUAwAA2wkOoDQAYIXSkSHns6P/y5CuXCJCB6oBwBs80CRGhv28UfKq/qEu+FDHAQAuD4FqAABgOyFkVANuo0pylC8SJrE6CH2+XIcKUBcI5vQDgHebsmJ3nkFqpWezCqyHAQBXgHeKAAB4iMDAQKu7YKuMapXtdLHFkADkvShpxf8WNMzYKhePkJhiYVy1AMAnzdlwSF79fr3RvvC9hGqrIHVcx+rWdBAAvByBagAAPEBQUJD079/f6m7YLsh2NtVpdTcAj6eyoHW5jgsypMsVCWNBQwC2sXrPCek58U+jvax/aykcFiSfL9mpF05UNalVuQ/1/gIAcGUIVAMAAFsKCXQQqAYyKaoWNMxcP/q/DOmSkSGMEwBb23XstHQe84fRnvV8cylR8Nzfxh7NKlrYMwDwLQSqAQCALYXoBRVTre4GYCo/P7WgYWjWDOn/9guzoCEAZPPv6RRp8eZ8oz25ZyOpUjKCkQIANyBQDQCAB0hLS5Ovv/5a7991110SEMAU7W7BLKgIH1/QUF2GfmGGtNrCgvj7AgCX4mxqutQZOsdoj/q/2tI0thiDBwBuwrtUAAA8gNPplC1bthj7MCujGvBuwWpBw/9qRmfUjlZZ0jFFw6mTCgBXId3pkqqvzDTafdtVkc51yjCmAOBGBKoBAIAtkVENbxKRsaChrht9Pju6XOEw8ff3s7p7AOBTXC6XxPafYbT/r345eapVJUv7BAB2QKAaAADYEhnV8ETFCgRLpeLhmTKkI3SGdMaiXQAA92v62jxjv350YXn9zloMOwCYgEA1AACwJTKqYfWChhdmR6utUFgQPxgAsFC3ccvlQMJZvR8REiDfPNGUnwcAmIRANQAAsKVgalTDzQLUgoZFsy5oWLl4hFSMCmdBQwDwQIN+WC8L/zlitNcObGtpfwDAbghUAwAAWwoJ9Le6C/Ch36WKxc4tYpixoKHaYoqFS6CD3zMA8Aaf/r5DJizeabS3Du8gfuoSGACAaQhUAwAAWyKjGperYEhAtuxo9bVMoVAWNAQAL/bL3wdk6E8bjPb6we0kgA8aAcB0BKoBAPAAQUFBMnDgQKu7YStkVCM3URHBOjNaZ0gbixoWkOIsaAgAPmflruPyxKS/jPbyl1tLeDChEgCwAn99AQCALYUEOqzuAiykruYuWzg0S6mOSv9lSEeGBvKzAQAb2H7klHT5cInRntu7hRSPCLG0TwBgZwSqAQCALQUHUDvYDgIdakHD8CwZ0rFR57bQID6sAAC7OnoqWW58a4HR/vqxJnqOAABYh0A1AAAeIC0tTb777ju9f/vtt0tAAFO0u5FR7VtCAx0SWzw8W4Z0dNEwFjQEAGSRlJIm9YfNNdrv3VNHGlYowigBgMU4CwYAwAM4nU7ZsOHcIj633Xab1d2xBTKqvZMqy5FRN1plSMf+t6/KePipeh4AAOQhLd0p1V+dZbT7d6wqt1xXmjEDAA9AoBoAANgSGdWerbha0LB4Aan8X3a0CkhXLh6hFzoEAOBKuFwuqfTyL0b7gcbR8mjzWAYTADwEgWoAAGBLIYHUqLaav17QMCxTqY7zW8EQFjQEAOSvzOU+msYWlaGdazDEAOBBCFQDAABbCg5gIT0zFzSMKRp+bjFDtZBhRpZ0VAEy2wEAprj7kyVy7HSK3i9WIFgm92zMyAOAhyFQDQAAbImM6vwXFuTQwecLs6Oji4RJgIMMdgCANfp/97cs3X7caK94uTU/CgDwQASqAQCALZFRfeUKhQWerx2dKTBdphALGgIAPMvHC7bJ5GW7jfbW4R1YfBcAPBSBagAAYEvB1Ki+qJIFQ3KsH60umQYAwNP9uGa/xP+yyWhvHNKeK3wAwIMRqAYAwAMEBgZKXFycsQ/3CwmkRnXGgoblioTpDGldOzpThnQECxoCALzUsu3H5JkvVxntlQPaSGgQcz8AeDIC1QAAeAA/Pz8JCgqyuhu2Ehxgr5rJQQ5/qVAs/Fy5juIFjNId6jaC9gAAX7L18En5v0+WGu3fXmgpRbkaCAA8HoFqAABgS74anA1XCxpmLtXxX4Z0dNFwcaj0aQAAfNjhk2elzdsLjfa3TzTVH8oCADwfgWoAADxAWlqa/PTTT3r/5ptvloAApmh38/aM6iLhQToInRGUzsiQLhUZwiJRAABbOp2cJg2H/2q0P7q/rtSLLmxpnwAAl46zYAAAPIDT6ZQ1a9bo/Y4dO1rdHVvwloxqFXjW5TqiCkjlEuczpLmEGQBwpZKTk6VRo0b6vceqVaukdu3aOR53/PhxGThwoMyePVt2794tUVFR0rlzZxk6dKhERkZ61A8gNd0p1w6cZbQH3lJd2tcoZWmfAACXh0A1AACwJU8KVKuSHOUKh0ql4hHnS3b8txUI5u0aACB/vfjii1K6dGnjQ/Lc7N+/X28jR46U6tWry65du+Txxx/Xt33zzTce82NxuVxS+eVfjPbD11eQh66vYGmfAACXjzMfT5B+VuToEmkZ8adsPhstB1KjrO4RAPi8tJNHJfXwTvn11xBp0qSJhIWFWd0lmCgpKUn++P0PObPtTwksHiMBEcVMed2gAH+pWCz8XLmOjAzp/xY0DA7wnMA5AMB3/fLLLzpD+ttvv9X7ealRo4Y+LkNsbKwMHz5c7r//fl22zIpSZanJqTJn3Bz599C/UqlRJWnUoZHUHDTbuL9VlSh59ZbqpvcLAGCjQLWaDH/++WdZvXq1BAUFyYkTJ7Idoy5FeuKJJ+S3336TAgUKyIMPPijx8fF5Tp7qUqZnnnlGfvzxR/H395cuXbrI6NGj9ePdzuUUWT9CZONIkdQEmVBBxOnyk3kn68uAfU/JwVRzTpoBwE7STh2X47M/kDNblqk/xNLmG5GCBQvK888/L6+++qo4HAQLfVl6eroMHjxYRo0aJSdPnjx3o5+fhFZqLEXbPimOAvlTx1JlQcdGnQtIV86UJV2+SBgLGgIALHPo0CHp2bOnTJ8+/Yo/pE9ISNDvnXI7z1ZlRdSWITEx8Yr7a7xmUqp0H7dUkv43U65bmybhrnN93ypb5ZPgCZLWtqJI9epSplCojH+o4VW/HgDAGl4TqE5JSZGuXbvqrLdPP/00xxPPTp06ScmSJWXx4sVy4MAB6datmwQGBsqIESNyfd777rtPHztnzhxJTU2Vhx56SB599FGZPHmym78jEVnxlMjWj7Lc5O/nkpYRK2Va7Atyy5ZRciy9kPv7AQA2kX4mUQ5+8YKkJx7VQerMJ1Cq1uKePXtk3LhxlvYR7vXII4/IZ599pi8RNrhccmbrMjlweLuUenCUOEIjLm9Bw4wyHf/VjlZZ0qUiQ93zDQAAcIXU3Ne9e3dduqN+/fqyc+fOy36Oo0eP6vdM6pw5NypZTH0onF9avDlPdh07I9Wn/S5Nt4So65Oy3F82ubjc9uMx+c6xUX6f1iffXhcAYD6vCVRnTHQTJkzI8X516dKGDRtk7ty5UqJECb0YhJpAX3rpJRk0aJDOwr7Qxo0bZebMmbJixQo9USvvvfeeXsRK1eBSNbvc5sTf2YLUGQL8nFI88Lj0jJomrx182H19AACbSVzx/bkgtbqiJYeTt/Hjx8vTTz8tdevWtaR/cC813+f2PkL9TqQnHpGTf/4ghZrdl+3u0pEh58p1XJAhrQLVAABYqV+/fvL666/neYw691XnzOpqori4uCt6HfXBvkoOU7Wq1Tl2btTz9+7dO8vjypUrd1VB6pB/T0mDLTnPuf7iL8ESJA3nbRQ/P78reh0AgGfwmkD1xSxZskRq1qypg9QZ2rVrp0uBrF+/XurUqZPjYwoVKmQEqZU2bdroEiDLli2T22+/3X0d3j5BxC9AxJWWa7D6niKz5LWDD6lrkt3XDwCwkVNrZuYYpM6gLmFVGdUEqn2T+iBC/YxVTc0cuZxy5u9Z0vWx3lkypNUWzoKGAAAP1adPH50pnZeKFSvKvHnz9DlwcHBwlvvU+bC60lhdcZQbFeBu3769REREyHfffaevXM6Nev4LX+NKy32oILVSftHfaunhXI91iEMqJpaRtX9tkFp1qU8NAN7KZwLVBw8ezBKkVjLa6r7cHlO8ePEst6kT2CJFiuT6mHyruZW0J89giRIZcFqC/VIk2XX1kzwA2J3L5RRnUkKex6gApir/YQV1wvfCCy8Y+8h/e/fuzT1I/Z+Uk8flkwfqkZEFAPAaUVFReruYd999V4YNG2a09+/fr5O7vvrqK2nUqFGuj1Pnu+o4FXz+4YcfJCREld9wv4cnLDf2wxPPikvyrqmtgtVf/LBC3iBQDQBeK8AbLlGqWrWqeJJ8qbkVUkLEzz/vYLUjTDaPuF0v8gQAuHqFPymU42K8mT+svPADTLOoS1XDw8MteW27UD/bPDOq1e9I4cIEqQEAPql8+fJZ2gUKFNBfY2NjpWzZsnp/37590rp1a5k4caI0bNhQB6nbtm0rSUlJ8sUXX+h2RqKWCo67cxHq/Qlnjf2z4UHid5ErjZ3ilFPhl77OBADA8/hbfYmSCkTntalLlC6FWkRRrWCcWUZb3ZfbYw4fPpzlNnXyevz48Vwfk1FzS610nLFdUfZdzP25lv3QVFmQit0JUgNAPlKXxeZ1QqXmALUQL3zT/fffn2eQWv1uPPwwa0MAAOwrNTVVNm/erAPTyl9//aXLYv79999SqVIlKVWqlLG5+yo0tT5Eht1Nr80zUJ0u6fJP0B6p2+g6t/YJAODDGdWXeonSpWjSpIkMHz5cB54zsuHmzJkjBQsW1Is95PYYlVm3cuVKqVevnr5N1e1yOp15XvqULzW3ijYUKXeHyJ7p+rPfLPwcIgERItX6Xt1rAACyfUD6+eef67/96enpWe5T6xN06NBBbrjhBktGTQVQZ82apffV5bUq8xf5q0WLFnrBZLWQsprrLwxSq2zqXr16MewAAFuIiYnRi0nndVvLli2zHWOWcd0bynVDZuv90yUKyZrSp+S6/QWyBayd//1b26qCfNa0giV9BQD4QEb15di9e7esXr1af1XBBbWvtlOnTun71eVIKiD9wAMPyJo1a/TJ/oABA+Spp54ygsrLly/XZUTU5UxKtWrV9IIQPXv21Pf98ccf8vTTT8vdd98tpUuXdu83pMp5NJ0sUqnnuezpzArVFLlpkUiBGPf2AQBsRl3Wqv7W165dO8vtKij80EMPydSpUy0r+6ACp3/++afeLgyiIn+on+0333wjDz74YLbMerXosvrdKFOmDMMNAIAHiAwLlOiioUZ71b0tZGX5k5Im566Ocsm5APq/fgnyfUt/uf/ZLhIU4DUhDgBADrwmXevVV1/NsgqxOqFUfvvtN/0przrh/Omnn+SJJ57QmdKqzqc6ER0yZIjxGHX5krqMSV3OlGHSpEk6OK3qcKlsui5duuhFJkzhCBZp+JFIrSEiB2aJpJ8VKVxHpGh9c14fAGyoSpUqOhisLmVVV9SoDzPVh515lXyC7wgNDZVx48bJiBEjZPbs2XpxZHVVVd26da3uGgAAuMCCvjdKizfnya5jZ0Qc/vL3PTfKxpOnpfjytRKQdFYSi0fIifqt5LFWlSWuY85XUgMAvIefy6rreHyIWkwiMjJS16tWpUYAAPaRX3NASkqKXqw3Yy2EoKCgfOyl92OuBQB7Yx6w988uISlVuo9fJlsOn5R0p0sKhwZKyUKh0r56Kel+QwUyqQHAR+YBr8moBgAAAAAA9iwD8t1T1qwjAgAwDwWcAAAAAAAAAACWIlANAAAAAAAAALAUgWoAAAAAAAAAgKWoUQ0AgAcIDAyU5557ztgHAAAAAMBOCFQDAOAB/Pz8pFChQlZ3AwAAAAAAS1D6AwAAAAAAAABgKTKqAQDwAOnp6fLrr7/q/datW4vD4bC6SwAAAAAAmIaMagAAPCRQvWTJEr2pfQAAAAAA7IRANQAAAAAAAADAUgSqAQAAAAAAAACWIlANAAAAAAAAALAUiynmA5fLpb8mJibmx9MBALxIxt/+jLkA7sFcCwD2xnzrvZjDAcDeEi/jnJlAdT44efKk/lquXLn8eDoAgJfOBZGRkVZ3w2cx1wIAMuYD5lvvwhwOALjUOZxAdT4oXbq07NmzRyIiIsTPz++KP11QgW71PAULFhRPR38ZX2/9ffCmvir01/PHV30qrCZcNRfAs+dab/s/5U199bb+elNfva2/3tRXb+uvN/XVHf1lvvVezOH2+//qTt7UV2/rrzf11dv66019tXoOJ1CdD/z9/aVs2bL58VT6F8Abfmkz0F/G11t/H7yprwr99ezxzY/MrsDAQHniiSeMfbhvrvW2/1Pe1Fdv66839dXb+utNffW2/npTX/O7v2RSeyfmcHv+f3U3b+qrt/XXm/rqbf31pr5aNYcTqAYAwAOoLOHixYtb3Q0AAAAAACzhb83LAgAAAAAAAABwDhnVHiI4OFgGDhyov3oD+sv4euvvgzf1VaG/9hnf9PR0WbRokd5v1qyZOBwOq7vkkzzpZ+5LffW2/npTX72tv97UV2/rrzf11Rv7C8/nTb9T3tRXb+uvN/XV2/rrTX31tv56U1+t7q+fS1W0BgAAlkpJSZH4+Hi9HxcXJ0FBQfxEAAAAAAC2QekPAAAAAAAAAIClCFQDAAAAAAAAACxFoBoAAAAAAAAAYCkC1SYZPny4NG3aVMLCwqRQoUI5HrN7927p1KmTPqZ48eLSt29fSUtLy/N5jx8/Lvfdd58ULFhQP2+PHj3k1KlT+d7/+fPni5+fX47bihUrcn1cy5Ytsx3/+OOPixliYmKyvfZrr72W52POnj0rTz31lBQtWlQKFCggXbp0kUOHDrm1nzt37tQ/twoVKkhoaKjExsbqovWqXm1ezBzbMWPG6PEMCQmRRo0ayfLly/M8furUqVK1alV9fM2aNWXGjBliBlXft0GDBhIREaH/D3Xu3Fk2b96c52MmTJiQbRxVv80waNCgbK+txs0Txza3/1NqU/9nPGFsFy5cKLfccouULl1av9b06dOz3K+WZHj11VelVKlS+v9amzZtZMuWLfn++w9refN8621zrbfMswpzbf5gnnUf5ljmWDCHc76cM+bw/MEcbt95fKGXnScTqDaJCjp27dpVnnjiiRzvT09P1yfN6rjFixfLZ599pn9x1S9LXtRJ8/r162XOnDny008/6V/ARx99NN/7r076Dxw4kGV75JFHdHC1fv36eT62Z8+eWR73xhtviFmGDBmS5bWfeeaZPI/v1auX/PjjjzoYuGDBAtm/f7/ccccdbu3jpk2bxOl0yscff6x/lu+884589NFH0r9//4s+1oyx/eqrr6R37946eP7XX3/JddddJ+3atZPDhw/neLz6/b3nnnt0EGfVqlU6WKy2devWibupn5maCJYuXar/T6Smpkrbtm3l9OnTeT5OBZ4yj+OuXbvELNdee22W1/79999zPdbKsVVUoCxzX9UYK+pvmyeMrfo5q99PNWHmRP3/ePfdd/X/r2XLlkl4eLj+XVaBs/z6/Yf1vHm+9ca51hvmWYW5Nn8wz7oPcyxzLJjDOV/OGXN4/mAOt+88ftrbzpNdMNX48eNdkZGR2W6fMWOGy9/f33Xw4EHjtg8//NBVsGBBV3Jyco7PtWHDBpf6Ea5YscK47ZdffnH5+fm59u3b53KnlJQUV1RUlGvIkCF5HteiRQvXc88957JCdHS065133rnk40+cOOEKDAx0TZ061bht48aNeoyXLFniMtMbb7zhqlChgkeMbcOGDV1PPfWU0U5PT3eVLl3aFR8fn+Pxd911l6tTp05ZbmvUqJHrsccec5nt8OHD+ue3YMGCy/4/aYaBAwe6rrvuuks+3pPGVlG/f7GxsS6n0+lxY6t+7t99953RVn0sWbKk680338zyfz44ONj15Zdf5tvv/9VQf+sHDRqkt9z+7sNe862nz7XePM8qzLVXj3nWfZhjYWfM4ebw5nmcOfzqMYfbcx4XLzhPJqPaQyxZskRfxl+iRAnjNvVpRGJios7gyu0x6vLjzFlWKkXf399ffwriTj/88IMcO3ZMHnrooYseO2nSJClWrJjUqFFD4uLiJCkpScyiLkFWlxfXqVNH3nzzzTwv7V65cqXOwFVjmEGVWChfvrweazMlJCRIkSJFLB9blXGoxiXzmKjfL9XObUzU7ZmPz/hdNnsMM8ZRudhYqsv3o6OjpVy5cnLbbbfl+n/OHdQlNeoSnIoVK+qMTVWSIDeeNLbqd+OLL76Qhx9+WF8+5Iljm9mOHTvk4MGDWcYvMjJSX6KU2/hdye//1QgICNDZs2pT+3APb5pvvWGu9dZ5VmGuzZ8xVJhn8xdzrPl/D+AdmMPzn7fO48zh+TOGCnO4vefxHR54nsyZsIdQvxiZT5qVjLa6L7fHqNqamanghvpDk9tj8sunn36qT+zLli2b53H33nuv/o+nAnFr166Vl156SdcMnjZtmrjbs88+K3Xr1tXjoS7vVifu6nKKt99+O8fj1ZgFBQVlq2mqfg7uHs/Mtm7dKu+9956MHDnS8rE9evSovkw+p99NdQnW5fwumzmGiiqn8vzzz8v111+vAze5qVKliowbN05q1aqlJ2s17uryezVJXOz3+2qpP/6q5IDqg/rdHDx4sDRr1kyX8lB1tj11bBVV1+rEiRPSvXt3jxzbC2WM0eWM35X8/l8NNbmXKVMm358X3jvfevpc663zrMJce/WYZ92HOTb/51j4Bubw/OWt8zhz+NVjDncvb5rHD3rgeTKB6qvQr18/+X/27gPMqSp9/PibMh1maEMZGBiKShcFabqKggK6KupakJWiYgPXggVcLGABFQsqa1ux/BRB/NsLLH1VqmBBKQJL70VmgAFmktz/cw4kJEwhGZKbcr+f57nMzc1NcnIm5Mx973vf8/TTT5e7z/Lly084OVq8vYdNmzbJ1KlT5aOPPjrh8/vX71QZbKo4e9euXWXNmjV60sBItlfVy/FS//nVoHrrrbfqSQRSUlJCfu1IttVr8+bN0qNHD13HSNUbNbNvE42qVa0CvuXVfFY6deqkFy81ODRr1kzXDH/88ccj2saePXsGfEZV4FoFm9T/LVWHOpapAJpqvwqMxWLfIrHE+3gbT2NtPI2zCmNt9DDORg5jLBIJY3j5OF7meDkaGMMji3H85BCoPglDhgwp9wyJoi7nD0bt2rVLzJC5fft2331lPeb4QuXqUp09e/aU+ZhwvIe3335bXx502WWXSahUIM57FrQiwdST6XP12qp/1KzB6uzV8VSfqUsY1Jkv/7PE6vcQbH+eTFvVhFLnn3++Dua98cYbpvdtadRl5A6Hw/dZDKZP1PZQ9o+EwYMH+yY7C/VsZFJSkr70TfWj2dTn7tRTTy3ztWOhbxU1ycP06dNDztaMZt96+0j1lwrieanbbdq0Cdvn/2Sos9JqIlClY8eO+rWRGONtPI218TTOVqS9jLXhwTgbOYyx5v9dg8hiDA8Nx8uBGMPDjzE8suJtHK8di8fJJ13lGmGdGGL79u2+ba+//rqe3OnQoUPlTu70448/+rZNnTo1opM7qULrapK/IUOGVOjx33//vW7zL7/8Ypjt/fff1328Z8+ecieH+Pjjj33bVqxYYcrkEJs2bTJOOeUU47rrrjNcLldM9a0qkj948OCAIvl169YtdzLFv/71rwHbOnXqZMqEf+rzqQr6qyL+f/zxR4WeQ/X/aaedZtxzzz2G2fbt22dUrVrVGDt2bMz17fGTQKoJF4qLi2O2b8uaJGLMmDG+bfn5+UFNEhHK5/9kMJlieMXzeBuvY20sj7MKY+3JY5yNPMbYyIyxiC+M4RwvH48x/OQxhpsj1sdxiYPjZALVJlm/fr3x008/GSNGjDAqVaqk19WiAlPeD2XLli2Niy66yPj555+NKVOmGNnZ2cawYcN8z7FgwQL9wVVf0l49evQwzjjjDH2fOjBVwc7evXtH7H1Mnz5df7DV7L7HU+1S7VNtUVavXm2MHDlSH9ivXbvW+Pzzz41GjRoZ5557rhFpc+fO1TMYq75cs2aNPnhW/dm3b98y26vcdtttRv369Y2ZM2fqdqsgoFoiSbWjSZMmRteuXfX61q1bfUss9O3EiRP1l9Q777yjgzW33HKLUaVKFWPbtm36/htuuMEYOnSob/8ffvjBcDqd+otOfU7UF7UKTCxdutSItNtvv10HpmbPnh3Qj4WFhb59jm+v+j+pAk7qc7J48WJ9siA1NdX4/fffI95eFYRSbVW/Q9Vv3bp1M2rUqKFnYI61vvUfgNT/kQcffLDEfdHuW/V96v1uVd9Tzz//vF5X37/K6NGj9WdX/X/59ddfjcsvv1wHAw8ePOh7jgsuuMB4+eWXg/78hxOB6vBIhPE2HsbaeBpnvW1hrD15jLORxRgbuTEW8YExnOPl0jCGhwdjuHXH8X1xdpxMoNok/fr10x+I45dZs2b59lm3bp3Rs2dPIy0tTQerVBDL/yyM2lc9Rh2Ieu3evVsfKKuDcZUNNmDAAN/BeCSo1+rcuXOp96l2+b+nDRs26APlatWq6Q+wOkC8//779dmZSFP/0Tt06KCDluo/e7NmzYynnnoqIFvu+PYq6j/iHXfcobNa09PTjSuuuCIgYBypjIHSPhv+FzxEu2/VF5L6wk1OTtZnzubPn++777zzztOfb38fffSRceqpp+r9W7RoYXz99deGGcrqR9XHZbX37rvv9r23WrVqGRdffLGxZMkSU9p77bXXGnXq1NGvrc4+qtsq6FRWW6PZt15qMFV9unLlyhL3Rbtvvd+Rxy/eNqmzxQ8//LBui/p/o04OHf8+GjRooE8ABPv5DycC1eGRCONtPIy18TTOKoy14cE4G1mMsZEbYxEfGMM5Xi4NY3h4MIZbdxyfFWfHyTb1z8kXEAEAACdD1e5Vk9ApatZ1NTEdAAAAAABWYY92AwAAAAAAAAAA1kagGgAAAAAAAAAQVQSqAQAAAAAAAABRRY1qAABigMfjkQ0bNuj1+vXri93OuWQAAAAAgHUQqAYAAAAAAAAARBXpWgAAAAAAAACAqHJG9+UBAIDidrtl8eLFer1t27bicDjoGAAAAACAZRCoBgAgRgLV3377rV5v06YNgWoAAAAAgKVQ+gMAAAAAAAAAEFUEqgFUKPOzc+fOcuWVVwZsz8/Pl9zcXPnnP/9JrwIAcJIYbwEAiE+M4UDFEKgGEDJVO/edd96RKVOmyAcffODbfuedd0q1atXk0UcfpVcBADhJjLcAAMQnxnCgYqhRDaBCTj31VBk9erQOTl9wwQWycOFCmThxoixatEiSk5PpVQAAwoDxFgCA+MQYDoTOZhiGUYHHAYCorw8VpFZni5cuXaqD1sOHD6dngAooKiqSUaNG6fVhw4ZxwgeAD+MtAADxiTEcCA2BagAnZcWKFdKsWTNp1aqVLFmyRJxOLtQAKoJANQDGWwAAEg/HzEDwqFEN4KSMHz9e0tPTZe3atbJp0yZ6E6ggdZKnd+/eeuGEDwDGWwAAEgPHzEDwyKgGUGFz586V8847T/7zn//IE088obdNnz5dbDYbvQoAQJgw3gIAEJ8Yw4HQkFENoEIKCwulf//+cvvtt8v5558vb731lp5Q8bXXXqNHAQAIE8ZbAADiE2M4EDoyqgFUyF133SXffPON/PLLL7r0h/L666/LfffdpydWzMvLo2eBELjdbv1/R1E139UkpQDAeAsAQHxiDAdCR6AaQMjmzJkjXbt2ldmzZ8s555wTcF/37t3F5XJRAgQIEZMpAmC8BQAgMXDMDFQMgWoAAGIAgWoAAAAAgJVRoxoAAAAAAAAAEFUEqgEAAAAAAAAAUUWgGgAAAAAAAAAQVQSqAQAAAAAAAABRRaAaAAAAAAAAABBVNsMwjOg2AQAAeDweWb58ue6IZs2aid3OuWQAAAAAgHUQqAYAAAAAAAAARBXpWgAAAAAAAACAqHJG9+UBAIBC6Q8AAAAAgJWRUQ0AQAxwuVzy8ccf60WtAwAAAABgJQSqAQAAAAAAAABRRaAaAAAAAAAAABBVBKoBAAAAAAAAAFFFoBoAAAAAAAAAEFUEqgEAAAAAAAAAUUWgGgAAAAAAAAAQVc7ovjwAAFAcDodcfvnlvnUAAAAAAKzEZhiGEe1GAAAAAAAAAACsi9IfAAAAAAAAAICoovQHAAAxwOPxyOrVq/V6kyZNxG7nXDIAAAAAwDo4CgYAIAa4XC758MMP9aLWAQAAAACwEjKqw5QFt2XLFqlcubLYbLZwPCUAIE6oqR727dsnOTk5ZEFHEGMtAFgb4238YgwHAGszQjhmJlAdBipInZubG46nAgDEqY0bN0q9evWi3YyExVgLAFAYb+MPYzgAINgxnEB1GKhMam+HZ2ZmhuMpAQBxoqCgQJ+s9I4FiAzGWgCwNsbb+MUYDgDWVhDCMTOB6jDwlvtQQWoC1QBgTZR+Mqd/GWsBwNoYb+MPYzgAINgxnMkUAQAAAAAAAABRRaAaAAAAAAAAABBVlP4AACAGOBwO6dmzp28dAAAAAAArIVANAEAMUMHp9u3bR7sZAAAAAABEBaU/AAAAAAAAAABRRUY1AAAxwOPxyIYNG/R6/fr1xW7nXDIAAAAAwDo4CgYAIAa4XC5599139aLWAQAAAACwEgLVAAAAAAAAAICoIlANAAAAAAAAAIgqAtUAAAAAAAAAgKgiUA0AAAAAAAAAiKq4ClT/97//lUsvvVRycnLEZrPJZ599FnC/YRjyyCOPSJ06dSQtLU26desmq1atOuHzjhs3TvLy8iQ1NVU6dOggCxcuFNOsWSNyzz0i9euL1Kwp0rOnyFdfqTdjXhsAwELUWLHq21XywSUfyLM1n5UXcl+Qb//xrez+Y3e0mwYTFO0vkgUvLZBXW78qz9R4Rv9Ut9V2AAAAAED0xFWg+sCBA3L66afrwHJpnnnmGXnppZfktddekwULFkhGRoZ0795dDh06VOZzTpo0Se6991559NFHZcmSJfr51WN27NghETdjhkjLliKvvCKycaPIzp0i06aJXHqpyB13EKwGgAgEqafeM1UmXDxB1kxdI4U7C6VgU4H8+OqPOmC5espq+jyBHdh5QN5s/6ZMuXuK7PhthxzcfVD/VLffPOtNfT8AAAAAIDriKlDds2dPeeKJJ+SKK64oNfjw4osvyvDhw+Xyyy+X1q1by3vvvSdbtmwpkXnt7/nnn5eBAwfKgAEDpHnz5jrInZ6eLuPHj4/sm8nPF+nVS6SoSMTlOrbd7T7y87XXRN5/P7JtAACLWTZ5mSwYu0CvG+5jV654XB5xF7nlo6s+koN7DkalbQ6HQ18JpBa1jvD76pavZPeq3SLqV+/99R9dV9u/HPgl3Q4AAAAAURJXgeryrF27VrZt26YP8L2ysrJ0KY958+aV+piioiJZvHhxwGPsdru+XdZjwkYFoQ8cEPF4Sr/fbhd54YXItgEALGb+i/PFZreVfqchUnywWH5+52eJBhWcPvvss/VCoDr88jfky4rPV4jhKr20ljpxsfKLlXo/AAAAAID5EiZQrYLUSq1atQK2q9ve+463a9cucbvdIT1GOXz4sBQUFAQsIfvhhyPB6LKoAPZPPx3JuAYAnDR15c3mBZvF8JQ/B8DGHzbS2wlo04JNx7Koy2KIbJq/yaQWAQAAAAD8OQNuISijRo2SESNGnFxvlRek9tN4+BRx27kEHABOmmFIP8Mo/wytTcrOuI4wj8cjW7du1etqUmB1hQ/CJ9jf6x879kt2wSGpmZlK9wMAAACAiRImUF27dm39c/v27foA30vdbtOmTamPqVGjhr68Wu3jT932Pl9phg0bpidg9FIZ1bm5uaE1WJUb+eCDMu922eyyuG4zgtQAEC42m2ytnyl1NhSIvazMWkOkYbeGUelzl8sl//73v33jTHJyclTakaga/KWB2J12XY+8LB6byLCVW+XQU7ukcqpTGmdXkiY1jy5H13OrpYsjSiczAAAAACCRJUygumHDhjq4PGPGDF9gWgWQFyxYILfffnupj1FBgLZt2+rH9FITGx7NaFO3Bw8eXOZrpaSk6OWkXHutyAMPiOzZc2wCRT9OwyNvtr/y5F4DABDgt/a1pO76gjIzblOqpEjrPq3ptQSUUTNDWv29lfz6f78GTKTpH6Re06K6HMpI0rf3HXLJzxv36sVfstMuDatn6KB1Y78gdqPsDElN4gooAAAAALBEoHr//v2yevXqgAkUf/75Z6lWrZrUr19f7r77bnniiSfklFNO0YHrhx9+WHJycnxBaKVr165yxRVX+ALRKjO6X79+0q5dO2nfvr28+OKLcuDAARkwYEBk30xamsjUqUcyq/fu9U2q6LI7xOlxyzPn9pXpp3SIbBsAwGK2NMqSRV3qyVmzN+nApDezWgepM1Pk79/+XZIrkcmcqC5++WL5c82fsuG7DWJz2HTA2vs52FG3ksy/sP4Jn6PI5ZGV2/fpxZ9Ksq5bNc2Xea0D2UfXq6TzmQIAAACAhApU//jjj3L++ef7bnvLb6hA8zvvvCMPPPCADjLfcsstsnfvXjnnnHNkypQpkpp6rM7kmjVr9CSKXtdee63s3LlTHnnkET2BosrGVo85foLFiDjjDJFVq0Teflvk00/lt9Xb5NdaTeSDMy+W32s1jvzrA4AF/dahtmxumClNf9opNbYekDaNq0nTy5vKGTeeIek10qPdPESQOgnRb2Y/WfnFSvlp/E+y4rftssVpk1WtasiGU6qIcRIlPdQcnRv3HNTLrJU7A+6rUSnZF7T2LyeSUyUtDO8KAAAAABKDzTCMsip1IkiqxEhWVpbk5+dLZmZmhfstb+jX9DkAmGzd6EtiYgwoKirSk/Uq1KiOXD/7GzxhiXz165EJLKMhI9mhy4ccH8TOq54uTgeTaQJApMcBmIPfHQBYW0EIY3hcZVQDAACEiyrjEU0Hitzy66Z8vfhLctikQfUMaZx9pBb2kTrYlaVxzQxJT+ZPNwAAAACJiaMdAABgSUXu6Aaqy1LsNmT1jv16mfr7dt92m02kTmbqsUkcj07kqG7XqHSSkzwDAAAAQJQRqAYAIAY4HA4577zzfOtI/IzqUKlibVvyD+nlu1XH5ttQqqQnlTqRY72qaWJTEW4AAAAAiHEEqgEAiAEqON2lS5doN8NS4i1QXZ69hcXy4/o/9eIvNckujWqUnMixYY0MSXZSBxsAAABA7CBQDQAALClWS3+E06FijyzbWqAXfw67TepXS9fBa1X72j8bu3JqUtTaCwAAAMC6CFQDABADDMOQnTt36vXs7GzKNZggkTKqQ+X2GLJ21wG9TF8eeF+tzJSA7GtvELtmZmq0mgsAAADAAghUAwAQA4qLi+XVV1/V68OGDZPk5ORoNynhWTlQXZ7tBYf1MnfN7oDtlVOdpQawc6ul6wxtAAAAADgZBKoBAIAlHSZQHZJ9h1zy88a9evGnal03rJ5xpA62bzLHDB3UTk1iYlAAAAAAwSFQDQAALIlAdfgy01du36cXfyrJum7VNF/mtX82dpV0rhgAAAAAEIhANQAAsKQilzvaTUhoHkNk456Depm18kj9da8alZKPTuR4rISIWnKqpEWtvQAAAACii0A1AACwpCI3NaqjZdf+Itm1f48sWLsnYHtGskMa+QWuvVnYedXTxemwR629AAAAACKPQDUAALAkJlOMPQeK3LJ0c75e/CU5bFK/WvqxiRx1JnZlaVwzQ9KT+XMWAAAASAT8ZQ8AACzH5fbo0hSID8VuQ9bsPKCXqb9v92232UTqZKb6JnH0z8KuUSklqm0GAAAAEBoC1QAAxACHwyGdOnXyrSOyKPuRGAxDZEv+Ib18t2pXwH1V0pNKncixXtU0sakINwAAAICYQqAaAIAYoILTF110UbSbYRmU/Uh8ewuL5cf1f+rFX2qSXRrVKDmRY8MaGZLspA42AAAAEC0EqgEAgOUQqLauQ8UeWba1QC/+HPYjdbAbZ2eUCGJXTk2KWnsBAAAAqyBQDQBADDAMQ/Lzj0wgl5WVRWmCCDvs8kT6JRBn3B5D1u46oJfpy3cE3FcrMyWgfIgKYqtgdq3M1Ki1FwAAAEg0BKoBAIgBxcXFMnbsWL0+bNgwSU5OjnaTEho1qhGK7QWH9TJ3ze6A7ZVTnQEBbO+6ysxWGdoAAAAAgkegGgAAWM7hYjKqcfL2HXLJzxv36sWfqnXdsHrG0eD10VIiRwPZqUlMlgoAAACUhkA1AACwHDKqEdHPl8sjK7fv04s/lWRdt2rakdIh/qVEalaSKulcRQEAAABrI1ANAAAsh8kUEQ0eQ2TjnoN6mbVyZ8B9NSolSyNv8NoviJ1TJY1fFgAAACyBQDUAALAcAtWINbv2F8mu/Xtk4do9Adszkh3HAth+dbDzqqeL02GPWnsBAACAcCNQDQAATDV69Gg9YeRdd90lL774YlR6v8jtjsrrAqE6UOSWpZvz9eIvyWHTkzb6lw9RQWy1ZKTwJz4AAADiD3/FAgAA0yxatEhef/11ad26dVR7nYxqxLtityFrdh7Qy9Tft/u222widTJTAyZw9Aaya1RKiWqbAQAAgPIQqAYAIAbY7XZp166dbz0R7d+/X/r06SNvvvmmPPHEE1Fty2GXJ6qvD0SKYYhsyT+kl+9W7Qq4r0p6UqkTOdatkiZ2NdMjAAAAEEUEqgEAiAFOp1MuueQSSWSDBg3S77Fbt24nDFQfPnxYL14FBQVhbQsZ1bCivYXF8uP6P/XiLzXJLo1qVDqShe0XxG5YI0OSnYl54gwAAACxh0A1AACIuIkTJ8qSJUt06Y9gjBo1SkaMGBGx9hS5yagGvA4Ve2TZ1gK9+HPYbZJbNe1ICZHjgtiVU5PoQAAAAIQVgWoAAGKAYRhSWFio19PT08WmCs0miI0bN+qJE6dNmyapqalBPUZNtnjvvfcGZFTn5uaGrU2HiwlUAyfi9hiybnehXqYv3xFwX83KKSUmclQ/a2UG938cAAAAOB7X8gEAEAOKi4tlzJgxelHriWTx4sWyY8cOOfPMM3WJE7XMmTNHXnrpJb3udrtLPCYlJUUyMzMDlnAioxo4OTv2HZa5a3bLe/PWyyOf/y59/r1AOjw1Q1o9NlV6jftB7pv8i7w6e41MW7Zd1u46oIPeAMwxbtw4ycvL0yeHO3ToIAsXLix3/8mTJ0vTpk31/q1atZJvvvmmzH1vu+02fTL9xRdfjEDLAQBWR0Y1AACIqK5du8rSpUsDtg0YMEAfFD/44IPicDhM/w1QoxqIjH2HXPLzxr168adqXTesnnE0+zrjSCmRo5nYqUnmfwcAiWrSpEn6iqTXXntNB6lVQLl79+6ycuVKqVmzZon9586dK71799Ylt/7617/KhAkTpFevXrpcV8uWLQP2/fTTT2X+/PmSk5Nj4jsCAFgJgWoAABBRlStXLnGwm5GRIdWrVy+x3SwEqgHz/8+t3L5PL/7sNpG6VdOOlA7xq4GtlirpyfyagBA9//zzMnDgQH1CWFEB66+//lrGjx8vQ4cOLbH/2LFjpUePHnL//ffr248//rgu1fXKK6/ox3pt3rxZ7rzzTpk6dWrCT/4MAIgeAtUAAMByKP0BxAZVEWTjnoN6mb1yZ8B91TOSfZnX/kHsnCppUWsvEMuKiop0uS01z4OX3W6Xbt26ybx580p9jNruPyeEojKwP/vsM99tj8cjN9xwgw5mt2jR4oTtOHz4sF7855kAACAYBKoBAIDpZs+eHdVeJ6MaiH27DxTJ7rV7ZOHaPQHbM5Id0ij7+IkcM6RB9QxJcjAFD6xr165det6HWrVqBWxXt1esWFHqY7Zt21bq/mq719NPP63nlPjHP/4RVDtUGZERI0ZU6D0AAKyNQDUAALCcYrcn2k0AUEEHityydHO+XvwlOWxSv1q6X/D6WCA7I4XDHqAiVIa2Kg+ialarSRSDoTK6/bO0VUZ1bm4uvwAAwAnxFxsAALAcAtVA4il2G7Jm5wG9iGz3bVextTqZqbqMyPEB7OzKKVFtMxBONWrU0BMUb99+7POvqNu1a9cu9TFqe3n7f/fdd7Jjxw6pX7++736VtT1kyBA9UeO6detKPGdKSopeAAAIFYFqAABigKohefrpp/vWEVkut0EXAxZhGCJb8g/p5btVuwLuq5KeFDCRY+OaGdIku7LUq5omdjXTIxBHkpOTpW3btjJjxgzp1auXr760uj148OBSH9OpUyd9/9133+3bpiZTVNsVVZta1bg+voa12u6dsBEAgHAhUA0AQAxQtR+9B5WIPCZTBKDsLSyWxev/1Iu/1CS7NKyhsq4zfBnYamlYI0NSnA46DzFLldzo16+ftGvXTtq3b6+zng8cOOALKvft21fq1q2r60grd911l5x33nny3HPPySWXXCITJ06UH3/8Ud544w19f/Xq1fXiLykpSWdcn3baaVF4hwCARJZQgeq8vDxZv359ie133HGHjBs3rsT2d955p8RZYHWJ0qFDhyLaTgAAEF1kVAMoz6FijyzfWqAXfw67TWdbH8vAPlZOJCstiU5F1F177bWyc+dOeeSRR/SEiG3atJEpU6b4JkzcsGFDwJVbnTt3lgkTJsjw4cPloYceklNOOUU+++wzadmyZRTfBQDAqhIqUL1o0SJdL8vrt99+kwsvvFCuvvrqMh+TmZkpK1eu9N0OdoIIAADCyTAMKS4u9mUqMR5FFjWqAVSE22PI+t2FepmxYkfAfaretS+ArTOxK+v12lmpdDZMpcp8lFXqY/bs2SW2qePl8o6Zj1daXWoAAMIhoQLV2dnZAbdHjx4tjRs31pcylUUFAsqaWAIAALOoILX3Mtxhw4bpOpOIYH97qFENILx27jusl3n/2x2wvXKKUxqp0iHZ3hrYR4LZDapn6AxtAAAAJGCg2l9RUZG8//77ukZXeVlp+/fvlwYNGuhJJs4880x56qmnpEWLFqa2FQAAmKvY5aHLAZhi32GX/LJxr178JTvsklcj3Vc65Egm9pElLZk62AAAwHoSNlCt6mrt3btX+vfvX+Y+avKH8ePHS+vWrSU/P1/GjBmja3T9/vvvUq9evTIfd/jwYb14FRQE1q4DAACxzeUhUA0g+pO6/rF9v178qRybnKy0gEkc9ZJdSapmcLUNAABIXAkbqH7rrbekZ8+ekpOTU+Y+nTp10ouXClI3a9ZMXn/9dXn88cfLfJy6NHvEiBFhbzMAADBHkZvSHwBik2GIbN57UC9z/tgZcF+1jOSjJUT8a2FXkrpV0pjbAAAAxL2EDFSvX79epk+fLp988klIj1OTV51xxhmyevXqcvdTtUNVSRH/jOrc3NwKtxcAAJjL5SajGkD82XOgSBYe2CML1+0J2J6e7JBGKmjtm8zxyM+8GhmS5LBHrb0AAABi9UD122+/LTVr1pRLLrkkpMe53W5ZunSpXHzxxeXul5KSohcAABCfiglUA0gghUVu+W1zgV78Oe02qV89/VgWtjeQXbOSVEox4VDwf/8T+fJLkcJCkdatRXr0EHFQfxsAAFgkUK0mRVSB6n79+onTGfj2+vbtK3Xr1tWlO5SRI0dKx44dpUmTJrqe9bPPPquzsW+++eYotR4AAJjBRekPABbg8hjyv50H9CLLtgfcVycr1Zd57R/Ezq4choQcFZi+6SaRSZOOFN1Wi9stUreuyMSJIuecc/KvAQAAEk7CBapVyY8NGzbIjTfeWOI+td1uP3bp259//ikDBw6Ubdu2SdWqVaVt27Yyd+5cad68ucmtBgBYnRqfvOOP/1iFyE1iBgBWtjX/kF6+X70rYHtWWpKv9rV3UQHt3KrpYrfbgiuyfc01IlOmHFlXi+9Ft4pceKHIokUiLVtG4F0BAIB4lnCB6osuukgM/z+G/MyePTvg9gsvvKAXAACiTV0FdPXVV0e7GZZB6Q8AKF3+wWJZsmGvXvylOO3SsEbJALbalprkV85j4UKRr78u/ck9HhGXS+Spp0QmTOBXAAAAEjtQDQAAcCKU/gCA0Bx2eWTFtn168aeSrHOrHamDrYLXV/3fG9LE6RS7CkiX+gXsEpk8WeSdd0SSk/k1AAAAHwLVAADAcij9AQDh4TFE1u8u1MuMFTvk1N/WSSO3R8otYqWC1QcOEKgGAAABCFQDABADioqKfJP9Dhs2TJLJMosoMqoBIDI2ZtU68U5VqohkZvIrAAAAAZitCQAAWA41qgEgMia3ulDsZcwZpDkcIjfffOQnAACAHwLVAADAclzqWnUAQNhtzqopL5xzvV73HH+n0ynSoIHI0KH0PAAAKIFANQAAsJQiV4nQCQAgjF7ufJ080OMfsiWz5rGNSUkivXuLzJsnUr06/Q0AAEqgRjUAALAUl4dANQBElM0mH51+kUxu3U1O3bVBJvdtI5mtmolUq0bHAwCAMhGoBgAAllLsouwHAJjBsNllZXaeODt1EEnm0BMAAJSP0h8AAMBSismoBgBTJTs47AQAACfGaW0AAGKA3W6XU045xbeOyCl2U/oDAMxit4k4CVQDAIAgEKgGACAGOJ1Ouf7666PdDEug9AcAmCfZyclXAAAQHP5qAAAAlkLpDwAwD2U/AABAsAhUAwAAS6H0BwCYJ9npoLsBAEBQKP0BAEAMKCoqkjFjxuj1++67T5KTk6PdpITlchvRbgIAWEYKpT8AAECQCFQDABAjiouLo90ESyhiMkUAMA2BagAAECxKfwAAAEshoxoAzMNkigAAIFgEqgEAgKVQoxoAzEOgGgAABItANQAAsBQC1QBgnmQHh5wAACA4/NUAAAAspZjJFAHANGRUAwCAYBGoBgAAluJiMkUAMA2BagAAECxn0HsCAICIsdls0qBBA986IqeIQDUAmIbSHwAAIFgEqgEAiAFJSUnSv3//aDfDElyU/gAA05BRDQAAgkXpDwAAYCkujyfaTQAAy0hxOqLdBAAAECcIVAMAAEtxeYxoNwEALIOMagAAECxKfwAAEAOKiopk7Nixev2uu+6S5OTkaDcpYbkJVAOAaVKc5EYBAIDgEKgGACBGFBYWRrsJlkCNagAwDxnVAAAgWJzeBgAAlkJGNQCYJ9nBIScAAAgOfzUAAABLoUY1AJiHjGoAABAsAtUAAMBS3B5PtJsAAJZBoBoAAASLQDUAALAUMqoBwDxOu43uBgAAQSFQDQAALIUa1QBgHjKqAQBAsJxB7wkAACLGZrNJTk6Obx2RQ0Y1AJjHaSc3CgAABIdANQAAMSApKUkGDhwY7WZYAhnVAGCeJAcnXwEAQHA4vQ0AACzF5Tai3QQAsAxKfwAAgGARqAYAAJbi9nii3QQAsAxKfwAAgGBR+gMAgBhQXFws48aN0+uDBg3SpUAQGdSoBgDzUPoDAAAEi0A1AAAxwDAMyc/P960jcqhRDQDmSXJwES8AAAhOQv3V8Nhjj4nNZgtYmjZtWu5jJk+erPdJTU2VVq1ayTfffGNaewEAgPnIqAYA8xCoBgAAlgxUKy1atJCtW7f6lu+//77MfefOnSu9e/eWm266SX766Sfp1auXXn777TdT2wwAAMxDRjUAmMfpsNHdAADAmoFqp9MptWvX9i01atQoc9+xY8dKjx495P7775dmzZrJ448/Lmeeeaa88sorprYZAACYh4xqADAPGdUAAMCygepVq1ZJTk6ONGrUSPr06SMbNmwoc9958+ZJt27dArZ1795dby/P4cOHpaCgIGABAADxwe3xRLsJAGAZTKYIAAAsGaju0KGDvPPOOzJlyhR59dVXZe3atfKXv/xF9u3bV+r+27Ztk1q1agVsU7fV9vKMGjVKsrKyfEtubm5Y3wcAAIgcl5vJKgHALGRUAwAASwaqe/bsKVdffbW0bt1aZ0ariRH37t0rH330UVhfZ9iwYZKfn+9bNm7cGNbnBwBYj5oAODs7Wy9qHZFDjWoAMA+BagAAECynJLAqVarIqaeeKqtXry71flXDevv27QHb1G21vTwpKSl6AQAgXJKSkuSOO+6gQ01AjWoAMA+lPwAAgCUzqo+3f/9+WbNmjdSpU6fU+zt16iQzZswI2DZt2jS9HQAAJCYyqgHAPGRUAwAASwaq77vvPpkzZ46sW7dO5s6dK1dccYU4HA7p3bu3vr9v3766bIfXXXfdpetZP/fcc7JixQp57LHH5Mcff5TBgwdH8V0AAIBIcjGZIgCYxumgnBUAALBg6Y9NmzbpoPTu3bt1jc9zzjlH5s+fr9eVDRs2iN1+LDbfuXNnmTBhggwfPlweeughOeWUU+Szzz6Tli1bRvFdAACsqLi4WN588029PnDgQF0KBJFBnBoAzJPsSKjcKAAAEEEJFaieOHFiuffPnj27xDY1+aJaAACIJsMwZOfOnb51RA4Z1QBgHieBagAAECRObwMAAEuhRjUAmIfJFAEAQLAIVAMAAEtxechYBwCzJPmVXgQAACgPfzUAAABLIaMaAMzhsNvEbmcyRQAAEBwC1QAAwFLIqAYAc1D2AwAAhIJANQAAsBQyqgHAHJT9AAAAoSBQDQBADLDZbJKVlaUXtZ5oRo0aJWeddZZUrlxZatasKb169ZKVK1dGpS0ujycqrwsAVpPk5HATAAAEzxnCvgAAIEKSkpLk7rvvTtj+nTNnjgwaNEgHq10ulzz00ENy0UUXybJlyyQjI8PUtrjdTKYIAGZwUp8aAACEgEA1AACIuClTpgTcfuedd3Rm9eLFi+Xcc8819TdAjWoAMEeSg4xqAAAQPP5yAAAApsvPz9c/q1WrVur9hw8floKCgoAlXKhRDQDmcJBRHRXjxo2TvLw8SU1NlQ4dOsjChQvL3X/y5MnStGlTvX+rVq3km2++8d1XXFwsDz74oN6uroDKycmRvn37ypYtW0x4JwAAqyFQDQBADFAHgm+++aZe1Hoi83g8uszJ2WefLS1btiyzprW3ZrdacnNzw/b6ZFQDgDko/WG+SZMmyb333iuPPvqoLFmyRE4//XTp3r277Nixo9T9586dK71795abbrpJfvrpJz2HhFp+++03fX9hYaF+nocfflj//OSTT/QcE5dddpnJ7wwAYAUEqgEAiAGGYejsJLWo9USmalWrA+CJEyeWuc+wYcN01rV32bhxY9hen4xqADAHGdXme/7552XgwIEyYMAAad68ubz22muSnp4u48ePL3X/sWPHSo8ePeT++++XZs2ayeOPPy5nnnmmvPLKK/p+dbJ42rRpcs0118hpp50mHTt21Pep0l0bNmww+d0BABIdgWoAAGCawYMHy1dffSWzZs2SevXqlblfSkqKZGZmBizh4vJ4wvZcAICyEag2V1FRkQ4gd+vWzbfNbrfr2/PmzSv1MWq7//6KysAua39FnUC22WxSpUoV08t3AQASG4FqAAAQcSpLXAWpP/30U5k5c6Y0bNgwar1OnBoAzOF02OhqE+3atUvcbrfUqlUrYLu6vW3btlIfo7aHsv+hQ4d0zWpVLqSsk8iRLN8FAEhsBKoBAIAp5T7ef/99mTBhglSuXFkfAKvl4MGDpve+O8FLqwBArHDYOdxMJGoODVUCRJ18fvXVV6NSvgsAkNic0W4AAABIfN4D2i5dugRsf/vtt6V///6mtsVDoBoATMFkiuaqUaOGOBwO2b59e8B2dbt27dqlPkZtD2Z/b5B6/fr1+sqo8kpyqfJdagEAIFSc4gYAABGnsq9KW8wOUh9pi+kvCQCWRI1qcyUnJ0vbtm1lxowZvm0ej0ff7tSpU6mPUdv991fU5In++3uD1KtWrZLp06dL9erVI/guAABWRkY1AAAxIj09PdpNSHhuD1FqADALGdXmu/fee6Vfv37Srl07ad++vbz44oty4MABGTBggL6/b9++UrduXV1HWrnrrrvkvPPOk+eee04uueQSmThxovz444/yxhtv+ILUf/vb32TJkiV6MmRVA9tbv7patWo6OA4AQLgQqAYAIAaoA737778/2s1IeJT9AADzkFFtvmuvvVZ27twpjzzyiA4ot2nTRqZMmeKbMHHDhg1i96sd3rlzZz1/xPDhw+Whhx6SU045RT777DNp2bKlvn/z5s3yxRdf6HX1XP5mzZpVoqQXAAAng0A1AACwDALVAGAeMqqjY/DgwXopzezZs0tsu/rqq/VSmry8PF2qCwAAM1CjGgAAWIbHE+0WAIB1OPwydwEAAE6EjGoAAGKAqgH5wQcf6PU+ffpIUlJStJuUkMioBgDzkFENAABCQaAaAIAYoC6rXb9+vW8dkUGgGgDM43DY6G4AABA0rsUCAACWQekPADAPGdUAACAUBKoBAIBlkFENAOZx2MmoBgAAwSNQDQAALINANQCYh4xqAAAQCgLVAADAMtzU/wYA05BRDQAAQkGgGgAAWAZxagAwD4FqAAAQCmdIewMAgIhJSkqidyPM7THoYwAwidNOXhQAAAgegWoAAGJAcnKyPPTQQ9FuRsKjRjUAmIeMagAAEApOcQMAAMug9AcAmIfJFAEAQCgIVAMAAMug9AcAmIeMagAAEApKfwAAEANcLpd89NFHev2aa64Rp5MhOhIo/QEA5iGjGgAAhIKjYAAAYoDH45FVq1b51hGhfmYuRQAwjYPJFAEAQAgo/QEAACyDjGoAMI/TYaO7AQBA0AhUAwAAyyBQDQDmoUY1AAAIBYFqAABgGVRVAQDz2EmoBgAAVg1Ujxo1Ss466yypXLmy1KxZU3r16iUrV64s9zHvvPOO2Gy2gCU1NdW0NgMAAPOQUQ0A5rHbiFQDAACLBqrnzJkjgwYNkvnz58u0adOkuLhYLrroIjlw4EC5j8vMzJStW7f6lvXr15vWZgAAYB4C1QBgHgLVAAAgFE5JIFOmTCmRLa0yqxcvXiznnntumY9TWdS1a9c2oYUAACCaPAb9DwBmofQHAACwbKD6ePn5+fpntWrVyt1v//790qBBA/F4PHLmmWfKU089JS1atDCplQAAiCQnJ8ujjz5KV0SYm0g1AJiGyRQBAIBlS3/4U0Hnu+++W84++2xp2bJlmfuddtppMn78ePn888/l/fff14/r3LmzbNq0qczHHD58WAoKCgIWAAAQ+wyDlGoAMIu6chUAAECsnlGtalX/9ttv8v3335e7X6dOnfTipYLUzZo1k9dff10ef/zxMidtHDFiRNjbDAAAIouMagAwDxnVAABArJ5RPXjwYPnqq69k1qxZUq9evZAem5SUJGeccYasXr26zH2GDRumy4p4l40bN4ah1QAAK3O5XDJ58mS9qHVEBpU/AMA81KgGAACWDVSry3lVkPrTTz+VmTNnSsOGDUN+DrfbLUuXLpU6deqUuU9KSopkZmYGLAAAnAxVemrZsmV6UeuIDEp/AIB5KP0BAAAsW/pDlfuYMGGCrjdduXJl2bZtm96elZUlaWlper1v375St25dXb5DGTlypHTs2FGaNGkie/fulWeffVbWr18vN998c1TfCwAACD83NaoBwDQOalQDAACrBqpfffVV/bNLly4B299++23p37+/Xt+wYYPY7ccSyf/8808ZOHCgDmpXrVpV2rZtK3PnzpXmzZub3HoAABBplP4AAPP4HXYBAABYK1AdzOW8s2fPDrj9wgsv6AUAACQ+DxnVAGAaOxnVAAAgBJzjBgAAluEhpRoATEOgGgAAhIJANQAAsAzi1ABgHgLVAAAgFASqAQCAZVD6AwDMY7fR2wAAwKI1qgEAiFdJSUkybNgw3zqiN58FACA87ESqAQBACAhUAwAQA2w2myQnJ0e7GQmPODUAmIfSHwAAIBSU/gAAAJZBPjUAmMfB0SYAAAgBGdUAAMQAl8slX331lV7/61//Kk4nQ3QkkFENAOZeLQQAABAsznEDABADPB6P/PLLL3pR6wAAxDtKfwAAgFAQqAYAAJZhUPwDAEzjIKMaAACEgEA1AACwDEp/AIB57FT+AAAAISBQDQAALIPJFAHAPNSoBgAAoSBQDQAALMMgpRoATOMgpRoAAISAQDUAAAAAIOyIUwMAgFAQqAYAAAAAhB2lPwAAQCicIe0NAAAiIikpSe677z7fOiKDyh8AYB5KfwAAgFAQqAYAIEayzjIyMqLdjIRnMJ0iAJjGRl8DAIAQUPoDAAAAAAAAABBVZFQDABADXC6XTJ06Va93795dnE6G6Eig9AcAmMdGSjUAAAgBGdUAAMQAj8cjP/74o17UOiKDQDUAmMdG8Q8AABACAtUAAMAyjGg3AAAshIxqAAAQCgLVAADAMgxSqgEAAAAgJhGoBgAAAAAAAABEFYFqAABgGZT+AADzUPoDAACEgkA1AACwDiLVAGAaJlMEAAChIFANAAAswyBSDQCmIaMaAACEwhnS3gAAICKSkpLkrrvu8q0jMphLEQAAAABiE4FqAABigM1mkypVqkS7GQAAhA0Z1QAAIBSU/gAAAJZBiWoAMA81qgEAQCjIqAYAIAa43W6ZMWOGXu/atas4HI5oNykhUfoDAMxDRjUAAAgFGdUAAMRIoHrevHl6UeuIDCZTBADz2OhsAAAQAgLVAAAAAAAAAICoIlANAAAsg9IfAGAeSn8AAIBQEKgGAACWwWSKAGAmin8AAIDgEagGAADWQUo1AJiGjGoAABAKAtUAAMAyyKgGAAAAgNhEoBoAAAAAEHYU/gAAAKFwhrQ3AACIiKSkJLn99tt964gMKn8AgHls1P5ABCz6dpH8Pvt3Sa+SLhfffrFUqlKJfgaAcHO7RGa/KbJnrUjN00T+MkDEHvl854TMqB43bpzk5eVJamqqdOjQQRYuXFju/pMnT5amTZvq/Vu1aiXffPONaW0FAMB7MF+zZk29JOqBfajjcyQYRKoBwDSJOZqVbcuWLZKIx8Nq7HzkkUekTp06kpaWJt26dZNVq1aJmfILi+XSO96Rm1IHyzcXfyPrn1kvyx9aLk9WfVIe7/6EeDweiYYil0fe+u5/8sjnv+mf6raV20FbYr9fYqUdtCV2++VgkVtmP9FfXP9KEdl+h0jxsyKbbxZjXKrIV6Mi/vo2I4Qjtq5du8qgQYPkyiuvLPX+Xbt2Sfv27eV///ufRMukSZOkb9++8tprr+lB+cUXX9QD78qVK/XB//Hmzp0r5557rowaNUr++te/yoQJE+Tpp5+WJUuWSMuWLYN6zYKCAsnKypL8/HzJzMyscNvzhn5d4ccCACpm3ehLTqrrwjUGRFq0x/BQx+dI9fPbP6yVEV8uq/DjAQDBm3N/F2lQPSMsXRYP423VqlV1kPj6669PqONhdVvd/+6770rDhg3l4YcflqVLl8qyZct0cDvSv7vznp0p239aJb0+XCvJkiwOcZTYZ/0p+TL+j+fFTKO+WSZvfrdWPH4RFbtNZOBfGsqwi5tbrh20Jfb7JVbaQVtit18GvrdIzlr4lNzS+TMxPCI2v/RmdVuxZT0hcuk/Q3reUMaBkDKqZ82aJddcc408+uijpd7vdrtl/fr1Ek3PP/+8DBw4UAYMGCDNmzfXA3R6erqMHz++1P3Hjh0rPXr0kPvvv1+aNWsmjz/+uJx55pnyyiuvmN52AIB1qTF09uzZelHr4RbtMTzU8TlSSKgGAETKk08+KbfeeqtcffXVsmfPnoQ4HlZ5bSrYPXz4cLn88suldevW8t577+ns8c8++yzi70cFqdfvPigtvv2lzCC1Un9Vpjz47JdiZjDp9f8GBpMUdVttV/dbqR20Jfb7JVbaQVtit18GvrdI5vy2SW5q8bk+ZvIPUive28WrHxOJ4FUsIdeofvXVV+W+++6TX3/9Vd5//33JyAjPGfJwKCoqksWLF8uwYcN82+x2u740ad68eaU+Rm2/9957A7Z1797dlEEXAAD/QPGcOXP0eufOncXhKP1A7GREawyvyPgMAIh/NosV/7jjjjukZ8+ectNNN+kg8ZtvvimXXnppXB8Pr127VrZt26afw0tlxalsbfXY6667LqLlPlSQ2n7okDTfW73MILViiCG/vDJNtgzsJsnOyFY4VZfhq4zH8qj7+3VuGNG2xEo7aEvs90ustIO2xG6/HCxyy7RlO+T2ws/EkVV24Q0VrE6q5ZJDs96W1K43SUwEqtVZ1HPOOUf/7Nixo3z++efSqFEjiQXqsmV1oF+rVq2A7er2ihUrSn2MGnRL219tL8vhw4f14p/CDgBArIvWGF6R8TlSY23Q9c4AAKgAVRpj5syZOiNZldtSWcpOZ+BhtyqrES/Hw96foRwzh2sMv/GdI7W1HfkF4jxB6EIFqtP3u6Tz6JkSC1QGZCy0JVbaodCW2O6XWGmHQlui1y95EtxcC7P+O0d6RihQXaEwvBpsFy1aJLm5uXLWWWfJ9OnTxUpUfS51Ftm7qH4AACAexMsYHqmx1lq5fQCAaFCltD755BNds1qdHD5+SXThGsO35B/SP12VK4tbTlQWzSYH08N/NRoAWMlmOfHcQcpKd3D7mZJR7aUGnK+//lpfVnTxxRfrCRaiOWmEUqNGDX2p9Pbt2wO2q9u1a9cu9TFqeyj7K+o9+18epc4QE6wGAMQLs8fwiozPjLUAEP9UlqvVqHIfQ4YM0aUyfv/9d8nOzo7r42HvT7WtTp06Afu0adMmomN4TlaqbM0/JEZ6mqzI3ClNC7LLLP/hELus69xM7ul2ivTp2EAi6YP56+WF6atOuF+k2xIr7aAtsd8vsdIO2hK7/TL6m+Xy8ZLN8u/0XnL3vg/FVskQWykZPmpCRdduhyxvfJXERKDadlwr1e3Ro0frAermm2/WlzhFU3JysrRt21ZmzJghvXr10ts8Ho++PXjw4FIf06lTJ33/3Xff7ds2bdo0vb0sKSkpegEAIF5EcwyvyPgcqbG2tD+4AAAIBzUp4cKFC3XZj759+ybE8bAqZaKC1Wofb2BaBZ4XLFggt99+e0TH8PH928vpI/+j13/r3kqaTN6k657bj7swXNenrr5DDjdqJ7d3aRLxGrvqNcbOWFViwjN/dptEvC2x0g7aEvv9EivtoC2x2y+P92qlA9WF9nSZ+NtFcn2nqUcmVLQFBqnV5amvr7pSnhtzlkRKSO9OzfhbGjWBwvfffy9Lly6VaFNnbtVZ7HfffVeWL1+uB88DBw7oWY8V9QeD/+QSd911l0yZMkWee+45Xbfrsccekx9//LHMgRwAgHgU7TH8ROOzWYhTA4B5yhh6EpaqD60mLI5GkDpSx8PqxLYKYj/xxBPyxRdf6L8X1HPk5OT4guGRkpWeJA2qp+n1wkYN5IvLs2WnY2/APsVSLAtzdslP/bvLwL9EfiI4Rb2Geq3ymNGWWGkHbYn9fomVdtCW2O2XtGSHXNj8SDmPhzLulAnzuouxP/DIyVNgk9fnXSn/aXqnVEqtcIGOEwrpmWfNmiXVqlUr9T51dlXNMKwuJY6ma6+9Vnbu3CmPPPKIntxBtUsNvN7JHzZs2KBnPvbq3LmzTJgwQYYPHy4PPfSQnHLKKXqG45YtW0bxXQAAEF7RHsNPND5HK7McABA5FotT60zkaIvE8fADDzygg9233HKL7N27V0/MrJ4zNTU14u9nzv0XyHnPzpT1uw/K/qanytenNpGs31dK5uad4kp2ys52LcWTmSm3nttQhl3cXMzifa03v1sbkAGpMh5VMMmstsRKO2hL7PdLrLSDtsRuv7zZ9ywZ+N4imbZshw5Wj1w9UAYe/FTq2nbI/4y6Mj79MmnetIZ8MfgvEW2HzSgrxQpBU5c+qXqf+fn5kpmZWeGeyxsa3SA/AFjRutGXxMQYoC7N3bp1q15XNSD9DyIRvn5+b946eeTz3+lSADDBzCHnSaPsSjE1DsB84fjd5RcWS/+3F8iqHfvE7TGkalqS1K6SJj2a15H+55iTCVqaIpdH/m/eOlm/p1AaVEuXGzrlRaUtsdIO2hL7/RIr7aAtsdsvB4vc8tgXS2Xqb9tlX5FLUhw2OathNRl3fbsKZ1KHMg4QqA4DAtUAEL9iJVANc/qZQDUAmGfGkPOkMYFqy+NvJQCwtoIQjuVI1wIAAJZB4Q8AAAAAiE2Rq34NAABCmoBp/vz5er1jx47icDjovUigRjUAmIYikwAAIBQEqgEAiJFA9fTp0/X6WWedRaA6QsioBgAzMR0SAAAIHqU/AACAZZBQDQDmIaMaAACEgkA1AAAAAAAAACCqCFQDAADLsFH8AwBMQ+EPAAAQCgLVAADAMij9AQDmofQHAAAIBYFqAABgGUymCADmMcipBgAAISBQDQAAAAAAAACIKmd0Xx4AAChOp1P69evnW0dkUPoDAMxD6Q8AABAKjoQBAIgBdrtd8vLyot2MhMdkigBgHgLVAAAgFJT+AAAA1kGRagAwDTWqAQBAKMioBgAgBrjdblm8eLFeb9u2rTgcjmg3KSERpwYA85BRDQAAQkGgGgCAGAlUf/vtt3q9TZs2BKoBAAAAAJZC6Q8AAGAZNmZTBAAAAICYRKAaAABYBqU/AMA8lP4AAAChIFANAAAsg4RqADAPkykCAIBQEKgGAACWQaAaAAAAAGITgWoAAAAAQNhR+gMAAISCQDUAALAMG1WqAcA0Bn0NAABC4AxlZwAAEBlOp1N69+7tW0dkUPoDAMzjIaUaAACEgCNhAABigN1ul1NPPTXazQAAIGw8HnKqAQBA8Cj9AQAAAAAIO+LUAAAgFGRUAwAQA9xutyxdulSvt2rVShwOR7SblJBs1P4AANNQ+gMAAISCQDUAADESqP7888/1evPmzQlUR4gtUk8MACiB0h8AACAUlP4AAACWQUI1AJiH0h8AACAUBKoBAIBl2MipBgDTuA0mUwQAAMEjUA0AAAAACDtqVAMAgFAQqAYAAJZB6Q8AMI9BRjUAAAgBgWoAAGAZTKYIAOZxe+htAAAQPALVAADAMsioBgDzUPoDAACEwhnS3gAAICKcTqf87W9/860jUsipBgCzUPoDAACEgiNhAABigN1ulxYtWkS7GQnPYSdQDQBmofQHAAAIBaU/AACAZRCnBgDzUPoDAACEgoxqAABigMfjkeXLl+v1Zs2a6QxrhJ+dSDUAmIZANQAACAVHwQAAxACXyyUff/yxXtQ6IsPObIoAYBoC1QAAwJKB6nXr1slNN90kDRs2lLS0NGncuLE8+uijUlRUVO7junTpIjabLWC57bbbTGs3AAAwDwnVAGAej4feBgAAFiz9sWLFCn3Z9Ouvvy5NmjSR3377TQYOHCgHDhyQMWPGlPtYtd/IkSN9t9PT001oMQAAMJuDjGoAMI3bMOhtAABgvUB1jx499OLVqFEjWblypbz66qsnDFSrwHTt2rVNaCUAAIgmdeUUAMAcBoFqAABgxdIfpcnPz5dq1aqdcL8PPvhAatSoIS1btpRhw4ZJYWFhufsfPnxYCgoKAhYAABD7KP0BAObxkFANAACsmFF9vNWrV8vLL798wmzq66+/Xho0aCA5OTny66+/yoMPPqgzsT/55JMyHzNq1CgZMWJEBFoNAAAiyUGkGgBM4yZSDQAAEimjeujQoSUmOzx+UfWp/W3evFmXAbn66qt1/eny3HLLLdK9e3dp1aqV9OnTR9577z359NNPZc2aNWU+RmVdq2xt77Jx48awvV8AABA5lP4AAPNQ+gMAACRURvWQIUOkf//+5e6j6lF7bdmyRc4//3zp3LmzvPHGGyG/XocOHXwZ2Y0bNy51n5SUFL0AABAuDodDLr/8ct86IoOEagAwDwnVAAAgoQLV2dnZegmGyqRWQeq2bdvK22+/LXZ76AnjP//8s/5Zp06dkB8LAEBFqeB0mzZt6MAIo/QHAJiH0h8AACChSn8ESwWpu3TpIvXr19d1qXfu3Cnbtm3Ti/8+TZs2lYULF+rbqrzH448/LosXL5Z169bJF198IX379pVzzz1XWrduHcV3AwAAIsFus9GxAGASj8FsigAAIIEyqoM1bdo0Xa5DLfXq1Su1NlpxcbGeKLGwsFDfTk5OlunTp8uLL74oBw4ckNzcXLnqqqtk+PDhUXkPAADr8ng8egxTmjRpUqGrgnBixKkBwDzEqQEAgCUD1aqO9YlqWefl5QVM6KEC03PmzDGhdQAAlM/lcsmHH37om7RXnUxF+FH6AwDM4yZSDQAAQkC6FgAAsAxKfwCAeahRDQAAQkGgGgAAWAaBagAwj8tNjWoAABA8AtUAAMAy7MylCACmcXs89DYAAAgagWoAAGAZZFQDgHmoUQ0AAEJBoBoAAFgGkykCgHlcHkp/AACA4BGoBgAAlmGj9AcAmMZNjWoAABACZyg7AwCAyHA4HNKzZ0/fOiKD0h8AYB4yqgEAQCgIVAMAEANUcLp9+/bRbkbCo/QHAJjHTekPAAAQAkp/AAAAy6D0BwCYh4xqAAAQCjKqAQCIAR6PRzZs2KDX69evL3Y755IjgdIfAGAet8dDdwMAgKBxFAwAQAxwuVzy7rvv6kWtIzIcpFQDgGnIqAYAAKEgUA0AACyDjGoAMA81qgEAQCgIVAMAAMuw8ZcPAJiGjGoAABAKDtcAAIBlUPoDAMzjdht0NwAACBqBagAAYBmU/gAA85BRDQAAQkGgGgAAWIadv3wAwDRuj4feBgAAQeNwDQAAWAYZ1QBgHjKqAQBAKAhUAwAQAxwOh3Tr1k0vah2RQaAaAMzj9lCj2kx79uyRPn36SGZmplSpUkVuuukm2b9/f7mPOXTokAwaNEiqV68ulSpVkquuukq2b9/uu/+XX36R3r17S25urqSlpUmzZs1k7NixJrwbAIAVOaPdAAAAcCRQffbZZ9MVEeaw2+hjADAJGdXmUkHqrVu3yrRp06S4uFgGDBggt9xyi0yYMKHMx9xzzz3y9ddfy+TJkyUrK0sGDx4sV155pfzwww/6/sWLF0vNmjXl/fff18HquXPn6udUf7eofQEACCcC1QAAwFJsNhGDJD8AiDgyqs2zfPlymTJliixatEjatWunt7388sty8cUXy5gxYyQnJ6fEY/Lz8+Wtt97SgewLLrhAb3v77bd11vT8+fOlY8eOcuONNwY8plGjRjJv3jz55JNPCFQDAMKO0h8AAMQAj8cjmzdv1otaTxTr1q3Tlx43bNhQXzLcuHFjefTRR6WoqChqbaL8BwCYg4xq86jgsSr34Q1SK6qcmN1ulwULFpT6GJUtrTKv1X5eTZs2lfr16+vnK4sKcFerVi3M7wAAADKqAQCICS6XS/7973/r9WHDhklycrIkghUrVujA++uvvy5NmjSR3377TQYOHCgHDhzQGV7R4LDZxC2kVANApLkT6MRrrNu2bZsu0eHP6XTqgLK6r6zHqL83VIDbX61atcp8jCr9MWnSJF0upCyHDx/Wi1dBQUGI7wYAYFVkVAMAgIjp0aOHvoz4oosu0pcLX3bZZXLffffpS4ajxc5fPwBgCpebk4Ina+jQoWKz2cpd1ElhM6iTzZdffrm+MkqN62UZNWqUrnftXVRtawAAgkGNagAAYKpoXzLs1JFqsvwAINKoUX3yhgwZIv379y93H3UiuHbt2rJjx44SV2vt2bNH31catV2V4tq7d29AVvX27dtLPGbZsmXStWtXPZHi8OHDy22PujLs3nvvDcioJlgNAAgGgWoAAGCa1atX68mdTlT2I5KXDTvstrA9FwCgbASqT152drZeTqRTp0464KzqTrdt21Zvmzlzpi6/1aFDh1Ifo/ZLSkqSGTNmyFVXXaW3rVy5UjZs2KCfz+v333/Xky3269dPnnzyyRO2JSUlRS8AAISKi18BAIAplyKriSJVKZCrr75a16kuTyQvG3YSqAYAUzCZonmaNWumx1g1vi5cuFB++OEHGTx4sFx33XWSk5PjG4fVZInqfkWNr2rCY5X9PGvWLB3kHjBggA5Sd+zY0Vfu4/zzz9elPtR+qna1Wnbu3GniuwMAWAUZ1QAAIGKXIntt2bJFH+h27txZ3njjjRM+fyQvGyajGgDMQUa1uT744AMdnFYlOux2u86Sfumll3z3FxcX64zpwsJC37YXXnjBt6+6kql79+7yr3/9y3f/xx9/rIPS77//vl68GjRoIOvWrTPx3QEArIBANQAAiNilyN4MLhWkVpcYq4kV1QFxNC8bJqMaAMzh8jAfgJnU/A8TJkwo8/68vDwxjMAJLlNTU2XcuHF6Kc1jjz2mFwAAzECgGgCAGOBwOOS8887zrScKFaTu0qWLzrxSdan9LxUua3KnSHM4qFENAGYodgcGRQEAAMpDoBoAgBiggtMqoJtopk2bpidQVEu9evUC7js+q8ssziAyugEAJ6/YRUY1AAAIHkdqAAAgYlQdaxWQLm2JFmpUA4A5iin9AQAAQkBGNQAAMUAFbr1lMVTtZ5uN8hSR4qBvAcAUlP4AAAChIKMaAIAYUFxcLK+++qpe1Doih4xqADCH2xPdK2gAAEB8IVANAAAsxclkigBgmiI3daoBAEBwCFQDAABLIaMaAMzjcpNRDQAAgkOgGgAAWIrTTv1vADBLMRnVAADAioHqvLw8PfmU/zJ69OhyH3Po0CEZNGiQVK9eXSpVqiRXXXWVbN++3bQ2AwAAc5FRDQDmYUJFAABgyUC1MnLkSNm6datvufPOO8vd/5577pEvv/xSJk+eLHPmzJEtW7bIlVdeaVp7AQCAuZz2hPvzBwBiFhnVAAAgWE5JMJUrV5batWsHtW9+fr689dZbMmHCBLngggv0trfffluaNWsm8+fPl44dO0a4tQAAwGxkVAOAeQhUAwCAYCVcSpEq9aHKeJxxxhny7LPPisvlKnPfxYsXS3FxsXTr1s23rWnTplK/fn2ZN2+eSS0GAEDE4XBIp06d9KLWETnUqAYA81D6AwAAWDKj+h//+IeceeaZUq1aNZk7d64MGzZMl/94/vnnS91/27ZtkpycLFWqVAnYXqtWLX1fWQ4fPqwXr4KCgjC+CwCAFang9EUXXRTtZlgCGdUAYB4yqgEAQMJkVA8dOrTEBInHLytWrND73nvvvdKlSxdp3bq13HbbbfLcc8/Jyy+/HBBUDodRo0ZJVlaWb8nNzQ3r8wMAgMhxOmx0LwCYxOU26GsAAJAYGdVDhgyR/v37l7tPo0aNSt3eoUMHXfpj3bp1ctppp5W4X9WyLioqkr179wZkVW/fvr3cOtcqU1sFxf0zqglWAwBOhmEYeu4ERZ0EVSdiERkOJlMEANMUuT30NgAASIxAdXZ2tl4q4ueffxa73S41a9Ys9f62bdtKUlKSzJgxQ6666iq9beXKlbJhwwZdI7QsKSkpegEAIFzUnAljx471nRBVpakQGdSoBgDzuAhUAwCARAlUB0tNfrhgwQI5//zzpXLlyvr2PffcI3//+9+latWqep/NmzdL165d5b333pP27dvrjLWbbrpJZ0erutaZmZly55136iB1x44do/2WAABABFCjGgDMw2SKAADAcoFqleE8ceJEeeyxx3RN6oYNG+pAtX+JDpWtpjKmCwsLfdteeOEFnXWtMqrV47p37y7/+te/ovQuAABApJFRDQDmKfZQ+gMAAFgsUH3mmWfK/Pnzy90nLy9P1wD1l5qaKuPGjdMLAABIfGRUA4B5il0EqgEAQHDsdBQAALASMqoBwDyU/gAAAMEiUA0AACzFYefPHwAwi4vSHwAAIEgcqQEAAEtxOmzRbgIAWEYRpT8AAIDValQDABDP1MS+7dq1860jcqhRDQDmcXkC5wgCAAAoC4FqAABigNPplEsuuSTazbAEalQDgHmK3UymCAAAgkPKFgAAsBQyqgHAPEymCAAAgkVGNQAAMcAwDCksLNTr6enpYrNRRzlSyKgGAPOQUQ0AAIJFRjUAADGguLhYxowZoxe1jshxUAMcAExTzGSKAAAgSASqAQCApTj46wcATHOYQDUAAAgSh2oAAMBSyKgGAPMUMZkiAAAIEoFqAABgKdSoBgDzFJFRDQAAgkSgGgAAWIrDzkSVAGAWSn8AAIBgEagGAACWQkY1AJiHjGoAABAsAtUAAMBSkphNEQBMQ41qAAAQLGfQewIAgIix2+1y+umn+9YROU4HpT8AwCxFLjedDQAAgkKgGgCAGOB0OqVXr17RboYlkFENAOah9AcAAAgWKVsAAMBSCFQDgHmYTBEAAASLjGoAAGKAYRhSXFys15OSksRmozxFpFD6AwDMQ0Y1AAAIFhnVAADEABWkHjVqlF68AWtERjKTKQKAaZhMEQAABItANQAAsBSnnWx1ADALGdUAACBYBKoBAIClJDn58wcAzEKgGgAABIsjNQAAYCmU/gAA8zCZIgAACBaBagAAYClMpggA5qFGNQAACBaBagAAYClJTKYIAKah9AcAAAgWgWoAAGApSXb+/AEAsxx2uelsAAAQFGdwuwEAgEiy2+3SvHlz3zoiJ8lpo3sBwCRkVAMAgGARqAYAIAY4nU65+uqro90MS3ByIgAATOMxRFxujzgpuwQAAE6AlC0AAGApyQRLAMBUTKgIAACCQaAaAABYitNB6Q8AMIchdZN2iOvP30VchXQ6AAAoF6U/AACIAUVFRTJq1Ci9PmzYMElOTo52kxJWEhnVABBxl2R9J/+o+aGclrZBZIaIONJFGt8k0nqkSHIVfgMAAKAEMqoBAIClJJFRDQARdWONz2Vcg6elSerGYxvdhSKr/iUy7WyRonx+AwAAoAQC1QAAwFJsNps47ZT/AIBIqOXcJf+s82+97rAZgXcabpGClSLLn6XzAQBACQSqAQCA5VCnGgAi42/VVJ2Pck4GqmD1qldFDA+/AgAAEIBANQAAsBzqVANAZDRK3izH5VGXVLRHpLiAXwEAAAjAZIoAAMBykplQEQDCpkalZGmcXUma1KwkTR25Yt+v8qHKyZi2OUQcafwGAABAAALVAADAcij9AQChUaX961ZNkyZHA9Jq8Qanq6QnH9txx80i098t+4lsTpF6vUQcKfwKAABAAALVAADEALvdLqeccopvHZFF6Q8AKF2y0y4Nq2ccCUQfDUir4HSj7AxJTXKcuNuyzxapdb7Ijv8eqUcdQI1vNpEWQ+l+AACQuIHq2bNny/nnn1/qfQsXLpSzzjqr1Pu6dOkic+bMCdh26623ymuvvRaRdgIAUBqn0ynXX389nWMSAtUArK5yqjMgK9qbKZ1bLV0cKn26omw2kXM/E/n+OpGt3x4p86EC1EaxSHIVkc4TRKq1DedbAQAACSJhAtWdO3eWrVu3Bmx7+OGHZcaMGdKuXbtyHztw4EAZOXKk73Z6enrE2gkAAKIvyXESQRgAiCO1MlNKDUjXzEyN3IsmZYqc/43In7+KbPpcxH1QpEorkdwrKfkBAAASP1CdnJwstWvX9t0uLi6Wzz//XO68806xqbP65VCBaf/HAgCAxOakvAqABKIyoOtXS/cFoxtnHyvdkZmaFL2GVW19ZAEAALBSoPp4X3zxhezevVsGDBhwwn0/+OADef/993Ww+tJLL9WZ2OVlVR8+fFgvXgUFBWFrNwDAmoqKimTMmDF6/b777tMnYBE5SU7qgAOIP6lJdmlUo+Rkhnk10iXFGUT9aAAAgBiWsIHqt956S7p37y716tUrdz9VD7RBgwaSk5Mjv/76qzz44IOycuVK+eSTT8p8zKhRo2TEiBERaDUAwMrU1UAwR9LJ1F8FgAirkp7kK9Hhm9Qwu5LUrZImdr6/AABAgor5QPXQoUPl6aefLnef5cuXS9OmTX23N23aJFOnTpWPPvrohM9/yy23+NZbtWolderUka5du8qaNWukcePGpT5m2LBhcu+99wZkVOfm5gb5jgAAQLQxmSKAaFPVCXOy0qTR0TId/vWjq1dKiXbzAAAATBfzgeohQ4ZI//79y92nUaNGAbfffvttqV69ulx22WUhv16HDh30z9WrV5cZqE5JSdELAACIT04mUwRg4uStDapn6CB045pHg9LZlfV6enLMH44BAACYJub/MsrOztZLsAzD0IHqvn37SlJS6BOH/Pzzz/qnyqwGAACJKdlBjWoA4ZWR7PCV6GjsVz+6QfV0ruIAAABIhEB1qGbOnClr166Vm2++ucR9mzdv1mU93nvvPWnfvr0u7zFhwgS5+OKLdQa2qlF9zz33yLnnniutWzM7NQAAiYrSHwAqqkalZF8Q2n9CwzpZqWJT9TwAAABQIc5EnESxc+fOATWr/SepUhMlFhYW6tvJyckyffp0efHFF+XAgQO6zvRVV10lw4cPj0LLAQCAWSj9AaA8ar7CulXTAiY09Aalq6Qn03mISXv27JE777xTvvzyS7Hb7frYduzYsVKpUqUyH3Po0CFdbnPixIly+PBh6d69u/zrX/+SWrVqldh39+7dcvrpp+sEsD///FOqVKkS4XcEALCahAtUqwzpsuTl5enSIF4qMD1nzhyTWgYAQNlUFl6DBg1864gsSn8A0N8FTrs0qpGhA9C6bMfR0h1qgsPUJAedhLjSp08f2bp1q0ybNk0naQ0YMEBuueWWco+R1RXFX3/9tUyePFmysrJk8ODBcuWVV8oPP/xQYt+bbrpJX3msAtUAAERCwgWqAQCIR2pehRNNHozwIaMasJbKqU5fENpbR1rdzq2WLg6VPg3EueXLl8uUKVNk0aJF0q5dO73t5Zdf1mUux4wZIzk5OSUek5+fr69IVoHsCy64QG9T8z01a9ZM5s+fLx07dvTt++qrr8revXvlkUcekW+//dbEdwYAsBIC1QAAwHKoUQ0kplqZKaUGpGtmpka7aUBEzZs3T5fi8AaplW7duukSIAsWLJArrriixGMWL16sM6/Vfl6qhGb9+vX183kD1cuWLZORI0fq5/nf//7HbxIAEDEEqgEAgOUQqAbil8qArl8t3TeJYePsjCM/a1aSzNSkaDcPiIpt27ZJzZo1A7Y5nU6pVq2avq+sx6h5m46vNa3qU3sfo+pW9+7dW5599lkdwA4mUK0eoxavgoKCCr4rAIDVEKgGACAGFBUV6QmPlLvuuksfOCKydWkBxLbUJFU/uuRkhnk10iXFSf1oWMPQoUPl6aefPmHZj0gZNmyYLgXy97//PejHjBo1SkaMGBGxNgEAEheBagAAYkRhYaEkMpVd1aFDB/nll1/kp59+kjZt2kStLUymCMSOqulJvuxob2a0KtlRr2oak8vC8oYMGXLCOSwaNWoktWvXlh07dgRsd7lcsmfPHn1fadR2daJc1Z72z6revn277zEzZ86UpUuXyscff6xvG4ahf9aoUUP++c9/lhqQVsHte++9NyCjOjc31/K/SwDAiRGoBgAApnjggQf0ZE4qUB1tZFQD5rLZRHKy0nQQ2luqw1s/unqlFH4dQBmys7P1ciKdOnXSAWdVd7pt27a+ILPH49EniUuj9lOTOc+YMUOuuuoqvW3lypWyYcMG/XzK//t//08OHjzoe4yarPHGG2+U7777Tho3blzq86akpOgFAIBQEagGAAAR9+2338p//vMffcCr1qONQDUQGUkOmzSonnF0MkNvQLqyXk9P5tADiBRVnqNHjx4ycOBAee211/QkiYMHD5brrrtOnyRWNm/eLF27dpX33ntP2rdvL1lZWXLTTTfp7GdVyzozM1PuvPNOHaT2TqR4fDB6165dvtc7vrY1AAAni78WAQBARKlLiNWB82effSbp6ekx0duU/gBOTkayw1ei40iW9JHs6Lzq6eJ0UAMeiIYPPvhAB6dVMNput+ss6Zdeesl3vwpeq4xp/1JjL7zwgm9fVaKre/fu8q9//YtfIAAgKghUAwCAiFG1LFVtzdtuu03atWsn69atC+px6mBZLf71LcOJjGogODUqpRwr1eE3oWGdrFTqRwMxRmVFT5gwocz78/LyfDWmvVJTU2XcuHF6CUaXLl1KPAcAAOFCoBoAAIRs6NCh8vTTT5e7z/Lly3W5j3379umJlUIxatSoUidoChcC1cAxdptIvarpR4PQfkHp7MqSlZ5EVwEAAMAUBKoBAIgBNpvNV0NSrce6IUOG6Ezp8jRq1EhP5DRv3rwSkyqp7Oo+ffrIu+++W+pjVWBb1cz0z6jOzc0NU+tFUpyUJoD1qBM0jWpkBJTsUD8bZWdIapIj2s0DAACAxRGoBgAgBiQlJek6zvEiOztbLyeiamM+8cQTvttbtmzR9S8nTZokHTp0KPNxKrB9fHA7nKhRjUSWmer0BaH9S3bkVk0Xu0qfBgAAAGIQgWoAABAx9evXD7hdqVIl/bNx48ZSr169qPV8ShIZ1Yh/tTNT/epGH82UrllJalZOjXbTAAAAgJARqAYAAJaT7KDMAeKD026T+tXSfUFob8kOFZiunEr9aAAAACQOAtUAAMSA4uJiGTdunF4fNGiQLgWSiPLy8sQwjGg3g8kUEXPSkhy6VrQ3GO3NlG5QPYPPKwAAACyBQDUAADFABW/z8/N964j8pHJANFTLSD6aFZ0hjf0C0nWrpMXFRKoAAABApBCoBgAAlsNkiogkFW/OyUo7Wjs6cEJDFagGAAAAUBKBagAAYDlkVCMckhw2yat+tFyHX1BalfBIT+bPbAAAACAU/AUNAAAsJ4XSHwhBpRSnnrzw+AkNG1RLF6eDMjIAAABAOBCoBgAAlkNGNUpTo1KKNKnpP6FhZb1eOyuVDgMAAAAijEA1AACwHGpUW5fdJpJbLf1Y7eij2dHqZ1Z6UrSbBwAAAFgWgWoAAGKAzWaT7Oxs3zoiKyWJcg1WKO/SsEZGiQkN1bbUJEe0mwcAAADgOASqAQCIAUlJSXLHHXdEuxmWQUZ14shMdfqC0P5B6dyq6WJX6dMAAAAA4gKBagAAYDlqAjwVw/QY0W4JglU7M/VYMNpXsiNDalamfjQAAACQCAhUAwAAy06oeKjYE+1mwI/TbpP6qn60N0P6aHa0ul0phT9bAQAAgETGX/wAAMSA4uJiefPNN/X6wIEDdSkQRJYq/0GgOjrSkhw6G1qX6fCrH92geoY+gQAAAADAeghUAwAQAwzDkJ07d/rWEXnJTjWhnouujqBqGclHS3So2tFHJjZUS90qaUwaCgAAACAAgWoAAGBJKWTuhoXNJpKTlVbqhIYqUA0AAAAAwSBQDQAALIkSE6FJctgkr3pGiYC0WtKSVXY6AAAAAFQcgWoAAGDZGtUoSU1aqMp0HD+hoZrk0EmfAQAAAIgQAtUAAMCSUpKsHajOrpxytH50xtFgdGUdkK6dlRrtpgEAAACwIALVAADAkqyQUW23ieRWS/dlRetSHUczpbPSkqLdPAAAAADwIVANAEAMsNlskpWV5VtH5CVSjWo1MWTDGhklJjNU21KTqB8NAAAAIPYRqAYAIAYkJSXJ3XffHe1mWEo8BqozU50Bkxl6g9K5VdPFrtKnAQAAACBOEagGAACWFMulP2pnph4LRPtNaKjqSgMAAABAIiJQDQAALCnaGdVOu03qV0/3lenw1ZGuWUkqpfAnGgAAAABr4Sgo2or3i6yfILLpC/mg4Ub5/VBj+XB3D1lbVDfaLQOAhFX851bZ//O3UrRttVz86zi59NJL5e9//7tUrlw5em0qLpZ33nlHr/fv31+XAkH4eTwemTFjhrz77rsy56cVskcqS6WWXSU173Sx2SITuE5Lckjjmhk6EO0LStesJA2qZ0Q9WA4AAAAAsSJuAtVPPvmkfP311/Lzzz9LcnKy7N27t8Q+GzZskNtvv11mzZollSpVkn79+smoUaPE6Sz7be7Zs0fuvPNO+fLLL8Vut8tVV10lY8eO1Y+PuPxlIjO6iRzapm+eXdmQDpV+k5trfCojttwq7+6+NPJtAACL2ffzt7Jn6r/UjIUihkembFwqU6ZMkUcffVQHMFu1ahWVdhmGIVu2bPGtI/wOHTqkx/lvvvlGHA6HuN1uEZtdCpfNltRG7aTmFQ+JzZlc4eevlpF8JBjtqx19ZHLDulXSmCATAAAAABIlUF1UVCRXX321dOrUSd56660S96uDzUsuuURq164tc+fOla1bt0rfvn11RtpTTz1V5vP26dNH7ztt2jSdzTZgwAC55ZZbZMKECZF9Q+7DIjMvEjm8Q4UkfJudNo/+OaLu6/K/w3Xlu/1nRrYdAGAhh9b/Knumjjty42gw2BsUVicuL7zwQvnf//4n6enp0WwmIuSee+7RJyUUHaRWjCPj7qG1i2XPjDelevdB5T6HOr+Rk5VW6oSGKlANAAAAAEjwQPWIESP0T+9l0cf7z3/+I8uWLZPp06dLrVq1pE2bNvL444/Lgw8+KI899pjOwj7e8uXL9QHrokWLpF27dnrbyy+/LBdffLGMGTNGcnJyIveGNnwscnBzmXe7DLvckv3/CFQDQBjlL/xEZ9B6g5P+VOBy+/btMmnSJH3SEoll9+7d+kS3Kv1RKsOQ/b/+R6qce4M40jL1RIsNqqeXCEarJS3ZYXbzAQAAACDhxU2g+kTmzZunL9dWQWqv7t2761Igv//+u5xxxhmlPqZKlSq+ILXSrVs3XQJkwYIFcsUVV5T6WocPH9aLV0FBQegN3jpVxOYQMY5mdB1HZVafXekXcYhb3MIBMQCcLJU5fWjdT6UGqb3U9786gUmgOvHMmTNHXzlVLo9bBjQslP59LpX61dLF6aB+NAAAAACYJWEC1du2bQsIUive2+q+sh5Ts2bNgG2qnnW1atXKfIyi6l57M7wrzCj2XXZeFrtNZM2T3UUcKSf3WgAAnUmbNMYQzwmC2ScMZiIuuVyuoPZrUaeSNMo2YZ4KAAAAAECAqKYKDR06VE8uVN6yYsUKiTXDhg2T/Px837Jx48bQn6R6+4Da1CXZRLJaEKQGgDBR2dKqLJT6WeY3r80m7dur72ckGv+rp8pz1llnRbwtAAAAAIAYy6geMmSI9O/fv9x9GjVqFNRzqUkUFy5cGLBN1Rr13lfWY3bsUJMZBmZcqQm1ynqMkpKSopeT0rCfyC//FHEfKiNgbYicdvfJvQYAIMDdd9+tJ9otK0itrqq58cYbo9ZrTOIYOerviZ49e+rJk0vLrla/e1X+K9i/OwAAAAAACRSozs7O1ks4dOrUSZ588kkdePaW81AHo5mZmdK8efMyH7N3715ZvHixtG3bVm+bOXOmvjy8Q4cOElEp1UTOniTy3ZVHbhtHD5q9k3zl9RFpHL1gCQAkor///e8ye/ZsGT9+vM6s9k6sp4KUyocffliiJJRZ1KS/999/f1Re2yr+/e9/y9lnny0bNmwImFRRfRbq1aunJ1sEAAAAAERH3MwSpA4qf/75Z/3T7XbrdbXs379f33/RRRfpgPQNN9wgv/zyi0ydOlWGDx8ugwYN8mU/q4zrpk2byubNm/XtZs2aSY8ePWTgwIH6vh9++EEGDx4s1113neTk5ET+TdW7VKTnEpGGN4gkVRFxpIlU6yDSeYJIp/eOBK0BAGGjsqZVsHLSpEn6ZGVaWppkZWVJnz59ZNGiRXLllUdPHiIhqbF9yZIlMnLkSGnQoIGkpqbqn2reCXXS2pSxHwAAAABQKpuhZo6KA6pEyLvvvlti+6xZs6RLly56ff369XL77bfrbLmMjAzp16+fjB492pcpp7aff/75snbtWsnLy9PbVJkPFZz+8ssvdUbVVVddJS+99JJUqhT8REoFBQU60KHqVasMbgCAdTAG0M8AAMZb8LcSAODkj5njJlAdywhSAIB1hWsMKC4ulg8++ECvqwzvpKSkMLYy/jHWAoC1MQ7EL353AGBtoYwDUa1RDQAAjlDnjdWVQd51AAAAAACshCLIAAAAAAAAAICoIlANAAAAAAAAAIgqAtUAAAAAAAAAgKgiUA0AAAAAAAAAiCoC1QAAAAAAAACAqHJG9+UBAIBXUlISnQEAAAAAsCQC1QAAxIDk5GR56KGHot0MAAAAAACigtIfAAAAAAAAAICoIlANAAAAAAAAAIgqSn8AABADXC6XfPTRR3r9mmuuEaeTIRoAAAAAYB0cBYeBYRj6Z0FBQTieDgAQR7zf/d6xoKI8Ho+sWrXKt45AjLUAYG3hGm9hPsZwALC2ghDGcALVYbBv3z79Mzc3NxxPBwCI07EgKysr2s1IWIy1AADveMB4G18YwwEAwY7hBKrDICcnRzZu3CiVK1cWm81W4bMLKtCtniczM1NiHe2lf+P18xBPbVVob+z3rzorrAZcNRYgtsfaePs/FU9tjbf2xlNb46298dRWhfbGT98y3sYvxnC+C6383R1PbY239sZTW+OtvQVRHMMJVIeB3W6XevXqheOp9Acg1j+w/mgv/Ruvn4d4aqtCe2O7f8nsiq+xNt7+T8VTW+OtvfHU1nhrbzy1VaG98dG3jLfxiTGc78JIiafv7nhqa7y1N57aGm/tzYzCGG4Py6sBAAAAAAAAAFBBBKoBAAAAAAAAAFFFoDpGpKSkyKOPPqp/xgPaS//G6+chntqq0F76F9b9PxVPbY239sZTW+OtvfHUVoX20reIH/H0/zWe2qrQXvo2Hj8L8dTWeGtvShTbajNURWsAAAAAAAAAAKKEjGoAAAAAAAAAQFQRqAYAAAAAAAAARJUzui8PAAAUl8sln376qV6/4oorxOlkiAYAAAAAWAcZ1QAAxACPxyPLli3Ti1oHAAAAAMBKCFSb5Mknn5TOnTtLenq6VKlSpdR9NmzYIJdcconep2bNmnL//ffrDLvy7NmzR/r06SOZmZn6eW+66SbZv39/2Ns/e/ZssdlspS6LFi0q83FdunQpsf9tt90mZsjLyyvx2qNHjy73MYcOHZJBgwZJ9erVpVKlSnLVVVfJ9u3bI9rOdevW6d9bw4YNJS0tTRo3bqxnVy0qKir3cWb27bhx43R/pqamSocOHWThwoXl7j958mRp2rSp3r9Vq1byzTffiBlGjRolZ511llSuXFn/H+rVq5esXLmy3Me88847JfpRtdsMjz32WInXVv0Wi31b1v8ptaj/M7HQt//973/l0ksvlZycHP1an332WcD9au7gRx55ROrUqaP/r3Xr1k1WrVoV9s8/oiuex9t4G2vjZZxVGGvDg3HWuuMsYyzMwBjO8XJpGMOtOY5zrGzdcZxAtUlU0PHqq6+W22+/vdT73W63PmhW+82dO1feffdd/YWgPijlUQfNv//+u0ybNk2++uor/eG75ZZbwt5+ddC/devWgOXmm2/WwdV27dqV+9iBAwcGPO6ZZ54Rs4wcOTLgte+8885y97/nnnvkyy+/1MHAOXPmyJYtW+TKK6+MaBtXrFihsydff/11/bt84YUX5LXXXpOHHnrohI81o28nTZok9957rw6eL1myRE4//XTp3r277Nixo9T91ee3d+/eOojz008/6cFPLb/99ptEmvqdqYO5+fPn6/8TxcXFctFFF8mBAwfKfZwKPPn34/r168UsLVq0CHjt77//vsx9o9m3igqU+bdV9bGivttioW/V71l9PtVgWRr1/+Oll17S/78WLFggGRkZ+rOsAmfh+vwj+uJ5vI3HsTYexlmFsTY8GGetO84yxsIMjOEcL5eGMdy64zjHyhYdxw2Y6u233zaysrJKbP/mm28Mu91ubNu2zbft1VdfNTIzM43Dhw+X+lzLli0z1K9w0aJFvm3ffvutYbPZjM2bNxuRVFRUZGRnZxsjR44sd7/zzjvPuA9/gIIAAKpBSURBVOuuu4xoaNCggfHCCy8Evf/evXuNpKQkY/Lkyb5ty5cv1308b948w0zPPPOM0bBhw5jo2/bt2xuDBg3y3Xa73UZOTo4xatSoUve/5pprjEsuuSRgW4cOHYxbb73VMNuOHTv072/OnDkh/580w6OPPmqcfvrpQe8fS32rqM9f48aNDY/HE3N9q37vn376qe+2amPt2rWNZ599NuD/fEpKivHhhx+G7fN/MtR3/WOPPaaXsr73Ya3xNtbH2ngeZxXG2pPHOGvNcTYex1jEF8Zwc8TzOM4YnvjjOMfK1h3HyaiOEfPmzdOX8deqVcu3TZ2JKCgo0BlcZT1GXX7sn2Wl0vPtdrs+AxJJX3zxhezevVsGDBhwwn0/+OADqVGjhrRs2VKGDRsmhYWFYhZ1CbK6vPiMM86QZ599ttxLuxcvXqzPKKo+9FIlFurXr6/72kz5+flSrVq1qPetympQ/eLfJ+rzpW6X1Sdqu//+3s+y2X3o7UflRH2pLt9v0KCB5ObmyuWXX17m/7lIUJfTqMtvGjVqpDM2VUmCssRS36rPxvvvvy833nijvnQoFvvW39q1a2Xbtm0B/ZeVlaUvTyqr/yry+Ufsi6fxNh7G2ngdZxXG2vD0ocI4a+1xljEWZmEMD794HccZw8PXj7E8jnOsbM1x3HlSj0bYqA+F/0Gz4r2t7ivrMaqukD+n06m/ZMp6TLi89dZb+sC+Xr165e53/fXX6y80FYj79ddf5cEHH9Q1kD755BOJtH/84x9y5pln6v5Ql3erA3d1mcrzzz9f6v6qz5KTk0vUNFW/h0j3p7/Vq1fLyy+/LGPGjIl63+7atUtfJl/aZ1NdghXKZ9nMPlRUOZW7775bzj77bB24Kctpp50m48ePl9atW+uBWvW7uvxeDb4n+nyfLPXFr0oOqDaoz+aIESPkL3/5iy7loeqGxWrfKqqm1d69e6V///4x2bfH8/ZRKP1Xkc8/Yl88jbexPtbG6zirMNaePMbZyIqncZYxFmZ+1hjDwydex3HGcGuM4xwri2XHcQLVJ2Ho0KHy9NNPl7vP8uXLTzg5Wry9h02bNsnUqVPlo48+OuHz+9fvVBlsqjB7165dZc2aNXrSwEi2V9XK8VJfqmpQvfXWW/UEAikpKSG/diTb6rV582bp0aOHrkWo6o2a2beJRtXeUgHf8mo+K506ddKLlxp0mzVrpmuGP/744xFtY8+ePQM+o2owVsEm9X9L1aGOZSqAptqvAmOx2LdILPE+3sbTWBtP46zCWBs9jLORxTiLRMEYXj6OlzlejpZYH8c5VrYuAtUnYciQIeVmOSjqcv5g1K5du8TsmNu3b/fdV9Zjji9Sri7V2bNnT5mPCcd7ePvtt/XlQZdddpmESgXivGdBKxJMPZk+V6+t+kfNGqzOCh5P9Zm6fEFlr/ifJVa/h2D782TaqiaUOv/88/UX/xtvvGF635ZGXUbucDh8n8Vg+kRtD2X/SBg8eLBvsrNQz/ImJSXpS99UP5pNfe5OPfXUMl87FvpWUZNnTJ8+PeRszWj2rbePVH+pIJ6Xut2mTZuwff5PhuoflcniXUfijLfxNNbG0zhbkfYy1oYH42xkxds4Gw9jLKKHMTw0HC8HYgyPjHgcxzlWttA4flIVrhH2iSG2b9/u2/b666/ryZ0OHTpU7uROP/74o2/b1KlTIzq5kyqyrib5GzJkSIUe//333+s2//LLL4bZ3n//fd3He/bsKXdyiI8//ti3bcWKFaZMDrFp0ybjlFNOMa677jrD5XLFVN+qAvmDBw8OKJBft27dcidT/Otf/xqwrVOnTqZM+Kc+n6qYvyrg/8cff1ToOVT/n3baacY999xjmG3fvn1G1apVjbFjx8Zc3x4/sYWabKG4uDhm+7asCSLGjBnj25afnx/UBBGhfP4RO+J5vI3XsTaWx1mFsfbkMc6aI9bHWcZYRBpjOMfLx2MMD494Hsc5VrbOOE6g2iTr1683fvrpJ2PEiBFGpUqV9Lpa1H8273/2li1bGhdddJHx888/G1OmTDGys7ONYcOG+Z5jwYIF+gtBfUl79ejRwzjjjDP0ferAVAU7e/fuHbH3MX36dP2hVrP7Hk+1S7VPtUVZvXq1MXLkSH1gv3btWuPzzz83GjVqZJx77rlGpM2dO1fPYKz6cs2aNfrgWfVn3759y2yvcttttxn169c3Zs6cqdutgoBqiSTVjiZNmhhdu3bV61u3bvUtsdC3EydO1F9Q77zzjg7W3HLLLUaVKlWMbdu26ftvuOEGY+jQob79f/jhB8PpdOovOfU5UQdbKjCxdOlSI9Juv/12HZiaPXt2QD8WFhb69jm+ver/pAo4qc/J4sWL9cmC1NRU4/fff494e1UQSrVV/Q5Vv3Xr1s2oUaOGnn051vrWf/BR/0cefPDBEvdFu2/V96n3u1V9Tz3//PN6XX3/KqNHj9afXfX/5ddffzUuv/xyHQw8ePCg7zkuuOAC4+WXXw7684/YkwjjbTyMtfE0znrbwlh78hhnrTvOMsbCDIzhHC+XhjHcmuM4x8rWHccJVJukX79++sNw/DJr1izfPuvWrTN69uxppKWl6WCV+o/pn0mh9lWPUQeiXrt379YHyupgXGWDDRgwwHcwHgnqtTp37lzqfapd/u9pw4YN+kC5WrVq+sOrDhDvv/9+fWYm0tQXaIcOHfSXsPoSbdasmfHUU08FZMsd315F/Se84447dFZrenq6ccUVVwQEjCOVMVDaZ8P/godo9636MlIHTcnJyfqs2fz58333nXfeefrz7e+jjz4yTj31VL1/ixYtjK+//towQ1n9qPq4rPbefffdvvdWq1Yt4+KLLzaWLFliSnuvvfZao06dOvq11ZlHdVsFncpqazT71kv9kaL6dOXKlSXui3bfer8jj1+8bVJnih9++GHdFvX/Rp0cOv59NGjQQJ8ACPbzH07q+16d2VZLqFl0SKzxNh7G2ngaZxXG2vBgnLXuOBvvYyziA2M4x8ulYQy35jjOsbJ1x3Gb+ufkiocAAICTpWr3qknoFFWrWk1MBwAAAACAVdij3QAAAAAAAAAAgLURqAYAAAAAAAAARBWBagAAAAAAAABAVBGoBgAAAAAAAABEFYFqAAAAAAAAAEBUEagGAAAAAAAAAESVzTAMI7pNAAAAajguLCzUHZGeni42m41OAQAAAABYBoFqAAAAAAAAAEBUUfoDQMjcbrd07txZrrzyyoDt+fn5kpubK//85z/pVQAAThLjLQAA8YkxHKgYMqoBVMgff/whbdq0kTfffFP69Omjt/Xt21d++eUXWbRokSQnJ9OzQAhcLpdMnTpVr3fv3l2cTif9B4DxFgCAOMUxMxA6joIBVMipp54qo0ePljvvvFMuuOACWbhwoUycOJEgNVBBHo9HfvzxR71+4YUX0o8AGG8BAIhjHDMDoSOjGsBJTf6mgtQOh0OWLl2qg9bDhw+nR4EKKCoqklGjRun1YcOGcVUCAMZbAADiHMfMQGgIVAM4KStWrJBmzZpJq1atZMmSJZQrACqIQDUAxlsAABIPx8xA8JhMEcBJGT9+vKSnp8vatWtl06ZN9CYAABHAeAsAQHxiDAeCR6AaQIXNnTtXXnjhBfnqq6+kffv2ctNNN+lLmwAAQPgw3gIAEJ8Yw4HQEKgGUCGFhYXSv39/uf322+X888+Xt956S0+o+Nprr9GjAACECeMtAADxiTEcCB2BagAVoiZ7U9nTo0eP1rfz8vJkzJgx8sADD8i6devoVQAAwoDxFgCA+MQYDoSOyRQBhGzOnDnStWtXmT17tpxzzjkB93Xv3l1cLpdMnz5dbDYbvQsESZ34yc/P1+tZWVn8/wHAeAsAQJzimBmoGALVAAAAAAAAAICoovQHAAAAAAAAACCqnNF9eQAAoLjdbpkxY4ZeV6V1HA4HHQMAAAAAsAwyqgEAiJFA9bx58/Si1gEAAAAAsBIC1QAAAAAAAACAqCJQDQAAAAAAAACIKgLVAAAAAAAAAICoIlANAAAAAAAAAIgqAtUAAAAAAAAAgKgiUA0AAAAAAAAAiCqbYRhGdJsAAADUcLxz507dEdnZ2WKz2egUAAAAAIBlEKgGAAAAAAAAAEQVpT8AAAAAAAAAAFHljO7LAwAAxe12y3fffafX//KXv4jD4aBjAAAAAACWQaAaAIAYCVTPmTNHr3fu3JlANQAAAADAUij9AQAAAAAAAACIKgLVAAAAAAAAAICoIlANAAAAAAAAAIgqAtUAAAAAAAAAgKgiUA0AAAAAAAAAiCoC1QAAAAAAAACAqLIZhmFEtwkAAMDj8cjWrVt1R9SpU0fsds4lAwAAAACsg0B1mIILW7ZskcqVK4vNZgvHUwIA4oQ637tv3z7JyckhuBxBjLUAYG2Mt/GLMRwArM0I4ZjZaVqrEpgKUufm5ka7GQCAKNq4caPUq1eP30GEMNYCABhv4xNjOAAg2GNmAtVhoDKpvR2emZkZjqcEAMSJgoICfbLSOxZUlNvtlvnz5+v1jh07isPhCFMLEwNjLQBYW7jGW5iPMRwArK0ghDGcQHUYeMt9qCA1gWoAsKaTLf2kAtXTp0/X62eddRaB6jL6l7EWAKyNUovxhzEcABDsGM5MTQAAAAAAAACAqCJQDQAAAAAAAACIKgLVAAAAAAAAAICoIlANAAAAAAAAAIgqAtUAAAAAAAAAgKgiUA0AAAAAAAAAiCpndF8eAAAoTqdT+vXr51sHAAAAAMBKOBIGACAG2O12ycvLi3YzAAAAAACICkp/AAAAAAAAAACiioxqAABigNvtlsWLF+v1tm3bisPhiHaTAAAAAAAwDRnVAADESKD622+/1YtaBwAAON64ceN0qbDU1FTp0KGDLFy4sMxO+uSTT6Rdu3ZSpUoVycjIkDZt2sj//d//+e4vLi6WBx98UFq1aqXvz8nJkb59+8qWLVsCnke9ns1mC1hGjx7NLwcAEHZkVMeCggKR2bNFDh0SOf10kdNOi3aLACDh7V61W7b9tE0cyQ7J65InqVVSo90kRNrWrSJz54oYhkjnziI5OfQ5ACBuTJo0Se6991557bXXdJD6xRdflO7du8vKlSulZs2aJfavVq2a/POf/5SmTZtKcnKyfPXVVzJgwAC9r3pcYWGhLFmyRB5++GE5/fTT5c8//5S77rpLLrvsMvnxxx8DnmvkyJEycOBA3+3KlSuLqfJ3iMx8ReRQvkiTc0XOusrc1wcAmCKuMqr/+9//yqWXXqrP9KqzuJ999lnA/YZhyCOPPCJ16tSRtLQ06datm6xatSqsZ6XDyuUSefBBkVq1RC6/XOTaa0WaNhXp0kXkf/8zpw0AYDF71++Vd7u+K6+c+op8fO3HMumKSTKmzhiZeu9UcReTyZyQ8vNFrr9eJDdX5G9/E7n66iPrvXuL7N0b7dYBABCU559/XgeLVbC5efPmOmCdnp4u48ePL3X/Ll26yBVXXCHNmjWTxo0b6yB069at5fvvv9f3Z2VlybRp0+Saa66R0047TTp27CivvPKKLkW2YcOGgOdSgenatWv7FpWBbQq3S+SVrmL8v1oiBx8XMV4SWfU3MZ6vJLL4c3PaAAAwTVwFqg8cOKDP9KrAcmmeeeYZeemll/SAvWDBAj14qjPFh1Sm8gnOSj/66KP6bLJ6fvWYHTt2SMTddJPIs88eyaT298MPIp06iWzeHPk2AICF7N++X8Z3Hi/r/7s+YLv7kFvmvzhfPr3hU33SEwnk8GGRCy8U+egjVV/l2HaPR2TyZJGuXUuOwwAAxJiioiIdQFbJWF52u13fnjdv3gkfr/6+mTFjhs6+Pvfcc8vcLz8/XyeFqXIh/lSpj+rVq8sZZ5whzz77rLhU0pUZxnYQo+pMsR1/4Vv2ATF+6iWydJo57QAAmCKuAtU9e/aUJ554Qp8VLm3gVZc+DR8+XC6//HJ9pvi9997T9bWOz7w+mbPSYbNkich77x25/Ph4atDfvVtkzJjItgEALGbe8/N0sNpwlfLda4j8Pul32byQk4QJZeJEkUWLAoPUXmqbGo8//DAaLQMAIGi7du3Sc1jUUlfj+lG3t23bVm7guVKlSrr0xyWXXCIvv/yyXKhO4JZCJXipmtW9e/eWzMxM3/Z//OMfMnHiRJk1a5bceuut8tRTT8kDDzxQ5msePnxYCgoKApYKWTZbjFpLxGYreZdNzTmdIvLnJzdW7LkBADEprgLV5Vm7dq0eoP3PMKtLmVQpj7LOMJ/sWemTooLUznJKhKuD57feKj2QDQCokJ/e+kkMd9nfq3anXX5+52d6N5GoE8/2cv7cUfep8RYAgASkSnb8/PPPsmjRInnyySf11cSz1fxIx1ETK6oSICoB7NVXXw24Tz1GlRFRyWC33XabPPfcczrgrQLSpRk1apQ+FvcuuarcVgW4p48Q8ZR9vwpWV2m4SYr+NOFqaACAKRJmMkXvWeRQzjCXd1Z6xYoVZb6WGpD9B+UKnSFWMymry47Ls2/fkcuR09JCf34AQADDY8jB3QfL7RWPyyP7t+yn5xLJpk3lj7cej+xbvVY+/mGtOOw2sdts4lQ/7TZx2Gx6m3dR96mf/verOLfTbheHXXz3+xZ9/9H9y7nv+G0AAByvRo0a4nA4ZPv27QHb1W1VM7osKhGrSZMmer1NmzayfPlyHUhWgefjg9Tr16+XmTNnBmRTl0Ylg6nSH+vWrdO1rY83bNgwHdz2P16uSLC6YO8mOa4CSQk2p8g3M+dJr6suD/n5AQCxJ2EC1WZSA/uIESNO7klyco5kcZVz8Lw/OU1aPjZDSr3WCQAQst5pDkk96C43o7pSTqWo9KzT6dSX2nrXESb16omsW1fmeOu22WSlM0tGfLksJrpcDfnHB8h9wfGjQXSH4/gg+pFAuf5pOxI49wbQA4LhtmOP9QbbA376Pf+Rx6jns4lTPcbvefwfo/Ypfbv6aS/xHvRPh//r2f1er/TnULF7VS8VQPwp3FUou1bsEmeaU2qfXluPs6gYVbqjbdu2us50r1699DaPx6NvDx48OOjnUY/xT7ryBqlXrVqlS3uoOtQnojK0VQC8Zs2apd6fkpKil5P1p7uqVDnB17/hElnuqCZHegQAEO8S5kjYexZZnVGuU6eOb7u6rc4ch/OsdFjOEPftKzJ2bJl3u2x2mdT6IoLUABBGq1pnS4uF28RulJ1R3aZ/6WNGpKkDvlNPPTUqr53QbrxR5L//LfNuu2HIpNal1+qMBlXxy2UY4vJQ+sufN3Cd5DgS/PYPbB8JdJfc7ixtX29g3VFye1JAQD4wAO/dX73OkUC73/1+r3/sObz7lWy3ateRn2Xse/QEAxDPDuw4IFPvnarnflBjq1KpTiX5y0N/kbMGncXJpwpSx6D9+vWTdu3aSfv27fUcTQcOHNDzLSl9+/aVunXr6sQqRf1U+zZu3FgHp7/55hv5v//7P19pDxWk/tvf/iZLliyRr776Sl9t7L0auVq1ajo4rkpiLliwQM4//3xdRkTdvueee+Tvf/+7VK1aVSJpebO7paG7T5n3G26RDctrSc2L60a0HQAA8yRMoLphw4Y6uKzOKHsD0yqArAbV22+/PaxnpcNyhvjMM0VuuEHk/fdL1KFWQeq9aZXljfYlJ40EAFTcb2fVksa/7ZbUwuKSwWqbSPOrm0vd9hzsJJTrrhN55RWRn34qMaGiGm+X12woXzQ/dvkzYpMK3Kvl8NGAV6JTCeS+wLhfMN4b4D4+4B14X2AwXa17A+X+gfQj60d+lhZY972O//P5vXaSL1B/7Dn0z6Pt8n/N47chsR3cc1De6vyW7F2/N2Dy4v1b98u3d34rBZsLpNuoY3MEIXjXXnut7Ny5Ux555BEdUFbHvVOmTPGVstywYYM+8e2lgth33HGHbNq0SdLS0qRp06by/vvv6+dRNm/eLF988YVePz65S2VXq/Ig6rhXTaT42GOP6WC3Ou5WgWr/xK1IufBv18nvQ4dLizPWlrjIWAWppUhk+MFB8lanvIi3BQBgDpuhZkuIE/v375fVq1fr9TPOOEOef/55fWZXne2tX7++PP300zJ69Gh599139QD68MMPy6+//irLli2T1NRU/biuXbvKFVdc4QtET5o0SZ+Vfv31131npT/66CNdo/r42tVlUQFxNUmEmlH5RPW8ArhcIg89JPLyy0dqUR81P7eFPNDzbtlQ9VhmOAAgPCrlH5ZzvlkndTbs821zpDqk3W3t5MJnLhRHkppGPngVHgOOo7KYli5dqtdbtWqlr/hJVGqsVlcn3XXXXXrcjXg/790rok5af/SRrwSIKvnxzWnnyD+7D5KC1OiUewGsSAWbkvyC3seC4qVv8w+kBwS/vdv87vMF0b2PdR673xtc997v3b/Eax3dnuw8wf0OMt/LMuOhGfLDMz+UO3nx4D8GS/VTTlxiIhLjLcx3Mr+7UV/+KufNuEE6tf5VbEcO6bXCDSly95Yh0rBHHxl2cfPwNxoAEJVxIK4yqn/88UcdmPbynsVVgeZ33nlHHnjgAX3W+JZbbpG9e/fKOeeco88we4PUypo1a/QkisGelY4oVYP0mWdE/vlPdcpa7hw/V5bVbCRralRsVmQAwIntz0qRKb1Pk8zdh6T69kL514B20vD8hpJaxe/oJwpUoPrzzz/X682bN0/YQPWiRYv0yeHWrVub96JqJqYPPxQZM0bc338v/5jwkyyu20y2ZdYwrw0ANJUiU+T2SFHZ0wXEDZUcfnwA3D9A7gtyO+yS7LvPu/+RILgvYH50+5HH+AXTHUeC4t4gvF73PTbwOZP8guv+j/WuJ/k9Xu0XidrvKgdq8euLyw1SqzrVP7/9s3R9qmvYXx+JZ9ilrWWU40P5x6yfpO/BLyVTDshCewv5Jv0vcmuPhgSpASDBxFWgWl16VF4CuPpja+TIkXopi5qZ+HgquzqUCSjCLitLpFcv+XJ+UvTaAAAWU1A9VS/NrmgW7aZYhroyqk+fPvLmm2/KE088YX4D6tYVz9+ulq9/IoMawMlTpeSLXB5VfUCdboy7LvUGw71B72AC3Mevl3hssVuX/iiP4TFk79q9pr1PxD+VMT3koqZy7jO1ZVvBsSuRh/bkbzgASDRxFagGAADxa9CgQXLJJZdIt27dThioVnUw1eJ/uVg4eOKn4hkARFSx25BiXbs/fEF2m8eQG1T983Iyqm12m6RVTwvba8IaVDme7MopAYHq6ct3yIXNTbgSGgBgmmMzLQAAAESImohpyZIlMmrUqKD2V/upOmbeJTc3PGWxiFMDQOQYdpusaV5NPOVUFfG4PNLq+lb8GhD650sCT4CMmbqSXgSABEOgGgAARNTGjRv1xIkffPBBwLwR5VGTLarJNryLeg4AQOxb2qGOuJ32UoPVNodNmvRsIvU61YtG05BgVm4/NjE2ACAxEKgGAAARtXjxYtmxY4eceeaZ4nQ69TJnzhx56aWX9LqaSPJ4KSkpekZo/yUcyKgGgMhS8z+oSYsPZCYf+d5VAeujS4trWsg1H18TkYkcYR1/OeXYZMgutyeqbQEAhBc1qgEAQER17dpVli5dGrBtwIAB0rRpU3nwwQfF4XBE7bJhAED47aqTIR/f2krqrN8nTQ+65faLTpVTLzlVquRVobtx0ieb/96xgXy3apde/39LNsm1Z9WnVwEgQRCoBgAgBqjM4r/97W++9URSuXJladmyZcC2jIwMqV69eontkUZGNQCYxGaTrXmZUrlWJWk/qD3djrBJTTp2gvvZqX8QqAaABJJYR8IAAMQpu90uLVq0iHYzEh751ABg8vcuX7yIgJysVNmSf0h27T9M/wJAAiFQDQAATDd79uyo9LpBxAQAzP3epb8Rrs+S34fpvu6nyb0f/aLXC4tckp5MaAMAEgGTKQIAEAM8Ho/8/vvvelHriAwCJgBgLk4QItzUVJyXt6nru/3u3PV0MgAkCALVAADEAJfLJR9//LFe1Doig4RqADAXJwgRic+Sw67C1Uc8O3UFnQwACYJANQAAsA4iJgDA9y7imu1ojLpFTqb+6WFsB4CEQaAaAABYhkGkGgBM/t4FIuP+7qf51nczqSIAJAQC1QAAwDIo/QEAZn/vEqpGZD5L552a7Vt/bc4auhkAEgCBagAAYBkeAiYAYCrC1Ag3m55OUZUAOVan+s3v1tLRAJAACFQDAADLIGACACZ/7/LFiwj6yyk16F8ASCAEqgEAgGUQMAEAk793OUWICLrvomN1qjfsLqSvASDOEagGACAGOBwOufzyy/Wi1hEZBEwAwFycIES4+VX8kNNzq/jWX5zxB50NAHGOQDUAADFABafbtGmjFwLVEcQl6ABgKgLVMMsnSzbT2QAQ5whUAwAAyyBODQAmf+8SqUbYPkulb+/VJoc+BoAEQaAaAIAY4PF45I8//tCLWkdkEC8BAHNxghDh5lf5Q7u726m+9d8259PhABDHCFQDABADXC6XfPjhh3pR64gMalQDgLk4QYiwfZbKOO2RVyPDt/7cf1bS4QAQx5zRbgAAAIBZCJgAgLk4QYiIp1T7mbVyJx0OAGHw3adzZeJL/5EDB4slt2sLeXjEdZLsjHy+MxnVAADAMrgEHQBM/t7lixcmGHB2nt9njg8dAFTUhuUb5NbMO2XmldMke7ZIgwVOcT61Su5Mu1seePoLiTQC1QAAwDI4eAUAk7936XCE67NUzofpji5NfOvfr95FnwNABRwoOCBjTn9eau2rqm/bxCb2o6HjWq4q4h72nTz81hyJJALVAADAMkiyAgC+dxHfVODkeNmVU3zrY6ZSpxoAKuLt+9+V6sVVxSGOEvepbZWMdFnw5CdS5PJIpBCoBgAAlkGgGgBM/+aly2GqXzbl0+MAUAG/T1whHvGUe6LwtPV2+b956yRSCFQDAADLYFIvADD5e5c4NcL1WTrB/fdddKpv3ePhgwcAoXIeUoU+7OUGqtM9KbJ+T6FECoFqAP+/vfsAj6JaGzj+pgKhhw4CCUiVDoJBKV6R5mfFhgiCGCxgAWzxSldBRMDCBUWKICh6L+pV6ShFAUGQXqSFXuUSSiR1v+cc3MmmkrIzs+X/e54hZ2bO7h7Obmay75x5jwCwX1BQkHTp0kUvqgxzEDABAGsRLoS7BWTO/KH1uTnSKH+39TgdDwB5lFgiVVIkJdv9arT1+eB4qR4eJmYhUA0AgAdQwemWLVvqhUC1eQiYAIC1mMQWVilaKNgov0OeagDIszbPRmWZn9p1RPXuOqHSMypCzEKgGgAA+A0CJgBg8XGXDoe7Pku5uC2qdFiI/nn0f3/R7wCQR91fe1COlj6bZZ5qte1YyJ9y2/DuEhpsXjiZQDUAAB4gNTVVYmNj9aLKMAcBEwCwFimX4G7ZZP7QXupU1yhfScr+9nUAQGZBwUHywdF3ZF+ti3JFEoztSZIkW8ueketm9pCh9zcXM6XdGwMAAGyTnJwsn376qS7HxMRIaGgo74YJCJgAgLW4kwVu+yzlos4DLa6T177epsufrz+cLm81AODaCocVljNP3y1rDp6REnv2S4AjVbp27yDzekaZOpLaiRHVAADAjzCmGgA46sKbBWQ3m6KIhASlhTjGkacaAPLlj1OXxBFWROKaNpDzzRrJgx1usCRIrRCoBgAAfoMR1QBg9YGXHoe1apYrqn9eTiT1BwDkld1pkwhUAwAAAABMQZwaVn+YXupUxyjH/ZXEGwAAeTDjl1hb03gRqAYAAH6DgAkAWHzc5VYWuFkOmT+0TjdUNMqfrD5A/wNAHry9aLet36EIVAMAAL9BvAQALD7u0uGwMYf1Bz/uo/8BIB+aVy8tdvCpQHVERIQ+KWVc+vfvn2X9mTNnZqpbuHBhy9sNAACs4SBkAgCW4gIh3PZZykPdlhHhdDwA5NGRc/FGOaZLXVvO5cHiQzZs2CApKWlJv7dv3y633367PPDAA9k+pkSJErJnz55czSAMAIBZgoKCpEOHDkYZ5iBgAgDW4gIh3C0339hf7FRHHvxorS6fjLsiFUsyIA0ArmXckrT4aIt0F/ysi1T7VKC6XLly6dbHjBkjNWvWlHbt2mX7GBWYrlgxLYcVAAB2UMHpm2++mc43GYFqAAB8X8vItADLBz/ulTfvbWhrewDAG3y7+bjdTfCt1B+uEhMT5bPPPpPHH388x1HSly5dkurVq0vVqlXl7rvvlh07dlzzuRMSEuTChQvpFgAA4PkY2QcAFh93SVLtVpMmTdIpL1XKylatWsn69euzrTt//nxp0aKFlCpVSooWLSpNmjSR2bNnZ3h/HDJ06FCpVKmSFClSRN/dtXfv3nR1zp07Jz169NB3I6vn6tu3r/4e7S0Tc8759bDb2wIAvsbhcozt0apahn3WtcNnA9XffPONnD9/Xnr37p1tnTp16sj06dPl22+/1UHt1NRUad26tRw9ejTH5x49erSULFnSWFSQGwCAglDnoGPHjulFlQEA8AXEqd1n3rx5MmjQIBk2bJhs2rRJGjduLJ06dZLTp09nWT88PFz++c9/ytq1a2Xr1q3Sp08fvSxevNioM3bsWHn//fdlypQp8uuvv+qAtnrOK1euGHVUkFoN6Fq6dKl8//33smrVKunXr5/YJbfZOjvdUMHspgCAz1j5xxmj/HyHWrady302UD1t2jTp0qWLVK5cOds6UVFR0qtXL31lWaUHUVecVfqQjz76KMfnjomJkbi4OGM5cuSICf8DAIA/SU5Olk8++UQvqgxzMLIPACxGpNptxo8fL9HR0TrYXL9+fR1cDgsL04OvstK+fXu59957pV69ejol5vPPPy+NGjWSn3/++epb43DIxIkT5fXXX9d3F6t9s2bNkuPHj+uBX8quXbtk0aJF+u8TNYL7lltukQ8++EC++OILXc+TP0qDO9Yxyn+cuuj29gCALxm9YLdRLl/cvrz+PhmoPnTokCxbtkyeeOKJPD0uJCREmjZtKvv27cuxXqFChfRtT64LAAAAACA9Ui65L7Xlxo0bjYmXlcDAQL2uRkxfiwpKL1++XPbs2SNt27bV2w4ePCgnT55M95zqjmEVkHY+p/qp0n2oFCJOqr56bTUC2x65G1Jdu0Jxozxh6R8mtgcAvN+evy/ohYUG2TrYx6cmU3SaMWOGlC9fXu644448PS4lJUW2bdsmXbt2Na1tAADAPoyoBgCOu97o7Nmz+vtqhQrp01mo9d2700bBZaTuAK5SpYqeZ0lN3Pyvf/1Lbr/9dr1PBamdz5HxOZ371E/13dpVcHCwTivirJORei21OHnCnE4Lt2fdVgCAyJWkFKMbXutaz21zBOSHz42oVnk9VaD6scce0ydQVyrNh0rb4TRy5EhZsmSJHDhwQOf4evTRR/Vo7LyOxAYAAN6BkX0AAH9SvHhx2bx5s2zYsEHefPNNneN6xYoVpr6mWXM65SdO0r1l+gnBAACZzVwTa5QfujHzMZsc1QWgUn4cPnxYHn/88Uz71PYTJ04Y6//73/90ji+Vs0uNolZXetesWaPzfQEAAN/DiGoAsPi4S4e7RdmyZfWI6FOnTqXbrtYrVqyY7eNUio7rr79ez8s0ePBguf/++3UgWXE+LqfnVD8zTtao5tI4d+5ctq9r9pxOuZ1MUXnutuuN8obYc25tBwD4ijEL0+7MCQkKtPU7lM+NqO7YsaMekl67du1M+9SV45kzZxrrEyZM0COo1W1J6ralH374QeeoBgAAAAAUnJW3C/uy0NBQad68uc4z7Xo3sVqPiorK9fOoxzjTckRGRupgs+tzqsFbKve08znVz/Pnz+v82E4//vijfh6Vy9rT53SqVLKIUX5n8R7b2gEA3qBZtVJ2N8E3c1QDAABkhXAJAFiL4677qLQdKsWlmtiwZcuWMnHiRLl8+bL06dPHSHWp8lE7R0yrn6puzZo1dXB6wYIFMnv2bJk8ebLeHxAQIC+88IK88cYbUqtWLR24HjJkiFSuXFnuueceXUfdfdy5c2d9J/KUKVMkKSlJBgwYIA8//LCu503pu9YfZEQ1AGR05Fx8jvmprU6fSKAaAAAPoG7nbdeunVGGORjZBwDWYkC1+zz00ENy5swZGTp0qL4jWKXzWLRokTEZokp1qVJ9OKkg9jPPPCNHjx6VIkWKSN26deWzzz7Tz+P08ssv63r9+vXTI6dvueUW/ZyFCxc26syZM0cHp2+77Tb9/N26dZP3339f7JKHzB/agFuvlw9/2mf8HaAC9ACAq95dkna3SYuIcLH7qjOBagAAPIAKTrdv397uZvg8RvYBALyZChirJSsZJ0lUI6XVkhMVtB05cqReshMeHi5z584VbxXdtoYRqF6y85R0uiH7nN4A4G++2XxcPInP5agGAADIDiP7AADwr3N4ySIhRnkceaoBIEuPtKrmEYN9CFQDAOAB1K2op0+f1gvpKUztaVOfHQCQxZGXq4Rwo/yk7igScjWt2t7Tl3gvAOBvq/444yzKCx1qSXasPI0TqAYAwAOoyYnU5EZqUWUAAHwFcWrY/Tl6sVMdo5yUksobAgAi8taCXUY/lC+eNjeBnQhUAwAAv0GwBABsOPbS6XCj/EyF2MPllvZ/bzzK+wEAIrL75EXdD4VDcg4POyw8kxOoBgAAfoNgCQAA/qfw36k/FPJUA4DIlaQUoxv+2bVejl1C6g8AAAATMKIaAKxHjmp4giqliuiff15OtLspAGC7WWtjjfLDLbOfSFFhMkUAAAATECwBAOtxNwvcKR9zKWovueSpvpyQ7L4GAYAXemvBbqMcEnSN1B8WjvYh9QcAAPAbBEsAwIZjLwdfeIA7G1c2yjPXpI0kBAB/1qRqKfEkBKoBAAAAAKaxchIm+K6CjugLCkwbiv3O4j1uaBEAeKej/4s3yq9dIz+1YuVZPNjC1wIAANkICgqSqKgoowxzMKoPAKzHsRfuFCD5zP0hIg2rlJRtx+Lc2h4A8Dbjl/xhlFtGhosnRaoZUQ0AgAdQwemOHTvqhUC1eRjVBwCA/3rRJU/12UsJtrYFAOwy//djHtv5BKoBAID/4O5zAAD89hTetlZZozx5xX43PCMAeK/uLat63GAfAtUAAHhI3sXz58/rxcpZlf0NPQsANhx7OfjCjQLyn/lDAlwePO3ng+5pEAB4kdV7zxjlFzrU9rjzOIFqAAA8QFJSkrz33nt6UWWYg2AJAFiPtEtwy+fITYGSdrXLueeJAMALvbVgt1GuUKKweBoC1QAAwG8QLAEAG469jKiGB3mxY1qe6kN/Xra1LQBgtV0nLuifhYJzHxJmRDUAAAAAAICbNbyupFGeuGwv/QvAb1xJSjHKr3Wtl+vHWXm9mRHVAADAbzCqDwBsOPbS6XDL58j9n6Svfz/m9ucEAE/12bpDRrl7y2riiQhUAwAAv0GwBABsOPZylRAeMpmi031Nq7ijKQDgVd5csMsoh+Yp9Yd136IIVAMAAL9BsAQAbDj20unwMC90qG2Utx2Ns7UtAGAVx98n5CZVS+XtcWIdAtUAAAAAANMwoBqe9jmqVibMKI9bssd9TwwAHurY+b+MckyXuh57Hg+27qUAAEB2AgMDpUWLFkYZ5mBUHwAA3i1A3JD7w8XKP8649fkAwBONX/KHUW5Vo4zHfosiUA0AgAcIDg6WO+64w+5m+D4i1QDAsRcQkb63RMq0nw9e/fPA4ZAAdyS/BgAP9Z9NR8UbMGQLAAAAAGAaB1cJ4ZbPkXs93b6mUV6196ybnx0APFP3llXz/BgrU38QqAYAwAOokTyXL1/WCxP+mdjPBEsAwHLkqIY7uWvgc9lihYzyuMXkqQbgu352uRjnOplsbjGZIgAAfiYpKUnGjRunF1UGAACAuRc8nEHvbcfi6GoAPmv0wl1GuUKJwuLJGFENAAD8BqP6AMCGYy+dDjdyZyrpFzvWMcopqXxSAfimHccv6J+hwfkLA5P6AwAAwAQEqgEAgFOfmyOM8n+3HKNjAPichOQUo/zPrvU8Pn0iI6oBAAAAAKZh7gW46ZPk9o4MCw02yuMW/+H25wcAu81ee8god29ZTTwdgWoAAOA3uKkXAADvFiBuzP2hJ1UM1T+Pnf/Lrc8LAJ5g9MLdRpnUHwAAAAAAv8ZFQngy1zzVV5LSbpEHAF+Q8nf+/cbXlfSK8zgjqgEAgN/g9nMAALyTWfNMdGt+nVGe8+thc14EAGxwzOVOkZh85qe2+jsUgWoAADxAYGCgNG7cWC+qDHMwqg8ArMdEtnCnAPdm/pCQoLS/u8Yt3uPeJwcAG01YmpZ7/6YaZbzivUibOQAAANgmODhY7rnnHt4BAIDPcXCZEB6uVvlisvf0JfmL1B8AfMi/Nx4Vb+NTQ7aGDx8uAQEB6Za6devm+JivvvpK1ylcuLA0bNhQFixYYFl7AQCAtRjVBwCAdzLzrqiXOqXlqY6LTzLxlQDAeg+1qOo136F8KlCt3HDDDXLixAlj+fnnn7Otu2bNGunevbv07dtXfv/9dz2STS3bt2+3tM0AAKi8X4mJiXohjzIAwKeQdwlu5ObMH9rt9SsY5Y9X7zfhFQDAWr/sO2uUB95e22vujAr0xVunK1asaCxly5bNtu57770nnTt3lpdeeknq1asno0aNkmbNmsmHH35oaZsBAEhKSpLRo0frRZVhFqIlAAB4IzMv5Ku7sZ0m/USgGoD3G71wl1GuWLKweAufC1Tv3btXKleuLDVq1JAePXrI4cPZz9q7du1a6dChQ7ptnTp10tsBAIDvIfUHANhw7KXT4cGTKTq1igw354kBwAbbj13QP0OCCn7QJPVHPrVq1UpmzpwpixYtksmTJ8vBgwelTZs2cvHixSzrnzx5UipUSLvFR1HrantOEhIS5MKFC+kWAACQPTVS/MYbb5TixYtL+fLldaqtPXv20GUAAMAjuOapPn7+L1vbAgAFkZCcYpRf61pPCopAdT516dJFHnjgAWnUqJEeGa0mRjx//rx8+eWX4u4v2yVLljSWqlULlpQcAABft3LlSunfv7+sW7dOli5dqtObdOzYUS5fvmxpOxjVBwDW424WuOVzZHI3tohIG1H9wY/7TH41ADDPZ+vSskv0aFXdq7ra51J/uCpVqpTUrl1b9u3L+iSjclifOnUq3Ta1rrbnJCYmRuLi4ozlyJEjbm03AAC+Rt3t1Lt3bz3pcePGjfUdUCo918aNG+1uGgDAZFZOwgR/YFLuDxefr88+hSgAeLrRC9LyU4cGFzz0a+VZ3KcD1ZcuXZL9+/dLpUqVstwfFRUly5cvT7dNjfJS23NSqFAhKVGiRLoFAADknrrQq4SHW5sPklF9AAAgO10b5jxoDQC8QXLq1dBywyolPX4yW58OVL/44ov61uLY2FhZs2aN3HvvvRIUFCTdu3fX+3v16qVHQzs9//zzeoTXu+++K7t375bhw4fLb7/9JgMGDLDxfwEAgG9LTU2VF154QW6++WZp0KCBpfNBMKoPAKzHRUJ4y+do0O21jfKek1nPdQUAnuxEXFqO/Ziudd3ynIyozqejR4/qoHSdOnXkwQcflDJlyuhcmOXKldP71S3GJ06cMOq3bt1a5s6dKx9//LG+Dfnf//63fPPNN9l+aQYAwCyBgYFSv359vaiyL1O5qrdv3y5ffPFFtnWYDwIAgMwmTZokERERUrhwYWnVqpWsX78+226aOnWqtGnTRkqXLq2XDh06ZKofEBCQ5fLOO+8YddTrZdw/ZswY296eABMzf1xfvrhRHr+USZ8BeJ/xS/4wyq1rlhVvi1QHiw/J6QuvsmLFikzb1OSLagEAwE7BwcF+cT5Sdy19//33smrVKrnuuuuyrafugBo0aJCxrkZUu2PyYkb1AYD1yFDtHvPmzdPnxilTpugg9cSJE6VTp06yZ88eKV++fJbff9VALjVASwW23377bT2R8Y4dO6RKlSq6jutALmXhwoXSt29f6datW7rtI0eOlOjoaGO9ePG0gK6vWrwj/XxWAOANvtp4VLyZbw/ZAgAAHkHlNVNB6q+//lp+/PFHiYyMzLE+80EAAJDe+PHjdbC4T58++g4sFbAOCwuT6dOnZ9lVc+bMkWeeeUaaNGkidevWlU8++USn33Kdp6lixYrplm+//VZuvfVWqVGjRrrnUoFp13pFixa1/O1x5kg1eyrFHq2qmfwKAGC+B1tkPyjIk9MnEqgGAACWpPv47LPPdMot9WX35MmTevnrr7QcalZgVB8AWM/KSZh8VWJiomzcuFGn73BSqcLU+tq1a3P1HPHx8ZKUlJTtRManTp2SH374QY+ozkil+lCpNZs2barTgiQnJ4uvevYftYzyrwf+tLUtAJAXa/afNcoDXXLuF5SVp3GfSv0BAIA3fwFVeZmdaS9CQ0PFl0yePFn/bN++fbrtM2bMkN69e1vWDoIlAGA94tQFd/bsWUlJSZEKFSqk267Wd+/enavneOWVV6Ry5crpgt2uPv30U30x+b777ku3/bnnnpNmzZrpAPeaNWv03ykqZYga4Z3dhMhqcXLfhMjWqFiysFEet2SPfPVUa4teGQAKZvSCtPNBpZJFxBsRqAYAAKYjQAwAgH3UiGg1p5PKW63yVWdFpRDp0aNHpv2uc0Y0atRIX0x/8skn9QV2laorI7V9xIgRYhY1maNVNsT+z7LXAoCC2nYsTv8MCXLvcdLK+6JI/QEAAAAAgAcrW7asBAUF6fQcrtS6yhmdk3HjxulA9ZIlS3SgOSurV6/WkzI+8cQT12yLmshRpf6IjY3Ncr8acR0XF2csR44cEW/z3D+uN8pcbAfgDRKTU41yTJd6XntnFIFqAAAAAAA8mBrF3Lx583QTITonRoyKisr2cWPHjpVRo0bJokWLpEWLFtnWmzZtmn7+xo0bX7Mtmzdv1vmxy5cvb+2EyBYGSvq2SZtMcvGOk9a9MADk05xfDxnlHjd576SwBKoBAIDfIE8qAHDs9VYqBcfUqVN1Luldu3bJ008/LZcvX5Y+ffro/b169dKjmZ3efvttGTJkiE7pERERYUxkfOnSpXTPq3JIf/XVV1mOplYTNU6cOFG2bNkiBw4ckDlz5sjAgQPl0UcfldKlS4uVIwUTklN0+d+/HUk3ctAMJYuEGOV3Fu8x9bUAwB3eWrDLKBcKDnJrpzosvFJIjmoAAOA3rPwjCwAAd3rooYfkzJkzMnToUB1wbtKkiR4p7Zxg8fDhw3qks+tExmqy5vvvvz/d8wwbNkyGDx9urKvc1Sq9Rffu3bMcHa32q/pqgsTIyEgdqHbNW2220Qt2ytTVByX171P4pBX7ZfLK/RLdJlJiutY37XWLhgbJ5cQU2X/msmmvAQDukpRy9SDZsEpJrx7sQ6AaAAAAAGAaLhK6z4ABA/SSFTVRoqvsckhn1K9fP71kpVmzZrJu3TqxiwpSf7TqYKbtKmjt3G5WsPqlTnVk+Hc7dTkpJVVCgrghHYBnOhl3xSjHdK0r3owjLQAAHkCNgKpVq5ZeXEdDwb1I/QEA1uPYi/xQ6T3USOqcqP1mpQHp3iotx+uXv3nfhJAA/MeEpX8Y5dY1y7r9+a28J5VvwgAAeIDg4GB55JFH9KLKAAAA/mz22lgj3Ud21H5VzwyuOV7HkacagAebZ/bFNAuvOBOoBgAAfoNRfQBgw7GXTkc+HDoX79Z6+VE1vIj++b/4JNNeAwDc5YHm15nSmYyoBgAA8PI/sgAAQP5VDw9za738eLFjHaN8KSHZtNcBgPxad+BPozzw9tpeP9iHEdUAAHiAxMREeeutt/SiygAA+AoHt7MgH3pGRUhgQM511H5Vzyx3NqpslGf8nHO+bACww+gFu4xy5VJX7wLxZgSqAQDwEElJSXoBAADwd6HBgRLdJjLHOmq/qmeWQJdI+bsuk5UBgKfYcjRO/wy61pU9L7ngTKAaAAD4DUb1AYANx146HfkU07W+PNk2MtPIarWutqv9ZmtctZTprwEA+ZGYnGqUX+taz7ROJEc1AAAAAADweyoYvXtUF6MfHm1VTa9bEaRWXnLJU33mYoLfvx8APMfn6w8b5Udvqia+gBHVAAAAAADAY7mm9+jaqJKp6T4yuvn6Mkb5Xyv2Wfa6AHAtb7rkpy4UHCRmYTJFAAAAM/7IolcBwHLMpQhvFhCQlndkxi+xtrYFALJK/XFD5RJiJlJ/AAAAAAAAZBAg5k0Ylp1b65TjfQDgUU5duGKU/2lifmqrkfoDAAAPGa1TvXp1vbiO3IGbMaQaAACvZsefSYNd8lQfPHvZ+gYAQAYTl/1hlFtfX1Z8ZUL6YMteCQAAZCskJER69+5NDwEAfBBXCeE+dlzOb1ClZLrg0HsPN7WhFQCQ5vP1R8QXMaIaAAAAAAB4BbvvPPt283FbXx8AXHVrdp2YjckUAQAAzPgji1F9AADAQ4NBAJAbvx740ygP7lhbfOk7FCOqAQDwAImJifLOO+/oRZUBAPAVVo7Egu+za0D1Cx1qGeXNR87b0wgAEJHRC3cb/VC5VBGf6hMC1QAAeIj4+Hi9AAAAIGt2Jf6oGh5mlN9dssemVgCAGBfLAi06IJL6AwAAwMv/yAIAAL5p9d6zdjcBgJ9KTE41yq91rWfJa1r5FYoR1QAAAAAA03CNEO5k51yK/drWMMoOrn4DsMEXGw4b5Z5R1X3uPSBQDQAAAAAAvIR9keqn2tU0yiv+OGNbOwD4r7cW7DLKhYKDLHlNUn8AAACY8UcWvQoAgFezc0R1eNFQozxuMXmqAVjvStLV1B/1K5Ww7DUdFn6LYkQ1AAAAAMA0ZEiALwn6e/ayHccvyNBvt8u01QfS5YwFALOcunDF8vzUVgu2uwEAAECNDgqQypUrG2WYg2AJAADeze6/kppXKy3rY8/p8qy1h/TPNxfskug2kRLTtb7NrQPgyyYu22uUb6lV1ie/QxGoBgDAA4SEhEh0dLTdzQAAAPBodl7QH71gpxGkdpXqEPlo1UFdJlgNwCyfr0+bSNFsrneK/BZ7Tq+HBpufmIPUHwAAAAAAn8htCd9nV5haBWmmrr4ajM6O2k8aEABmu69ZFdMvytUdstBY/2nPGb2utpuNQDUAAPAbBEsAAEB+zF4bq0dO50TtV/UAwN3WH0y7m2PQ7bVN62AVjFZ3iGQ83jnvHDE7WE2gGgAAD5CUlCQTJ07UiyoDAAAgM7syfxw6F+/WegCQF6MX7jLK15UO89k7RwhUAwDgARwOh8TFxelFlQEA8BWc1uBOATYl/6geHubWegCQF78fPm/6xTpPuHPEpwLVo0ePlhtvvFGKFy8u5cuXl3vuuUf27NmT42NmzpypJ2NwXQoXLmxZmwEAgHUIlgAA4N3sGlHdMypCAq/x2mq/qgcA7pSUkjaC+bUu9Xz6zhGfClSvXLlS+vfvL+vWrZOlS5fqW6c7duwoly9fzvFxJUqUkBMnThjLoUOHLGszAAAAAADwbKHBgRLdJjLHOmq/qgcA7vTF+sNGuWdUdZ++cyRYfMiiRYsyjZZWI6s3btwobdu2zfZxahR1xYoVLWghAACwE0lVAMCGYy8HX/iImK71jRytGW+Pf7JtpLEfANzprQW7jXLhkCDTOlfdEfLmgl05pv8w+84Rn77Up/J8KuHh4TnWu3TpklSvXl2qVq0qd999t+zYsSPH+gkJCXLhwoV0CwAAAAAA8M3UH04qGL17VBcZckc9CXJpC0FqAGb5KylF/6xXqYTP3znis4Hq1NRUeeGFF+Tmm2+WBg0aZFuvTp06Mn36dPn222/ls88+049r3bq1HD16NMdc2CVLljQWFeAGAAAAAAC+TwVp+rapIVMfa2FsO3g255SjAJAfpy9cMcqvda1reieqi27qDpGMOfnVuhV3jvhsoFrlqt6+fbt88cUXOdaLioqSXr16SZMmTaRdu3Yyf/58KVeunHz00UfZPiYmJkaP1nYuR44cMeF/AADwJyoNlTr/qEWVYRLuPwcAyzlIvAQ3ChDP+TvpH3UrGOXBX262tS0AfNPE5XuNcpta5Sy9cyTtdcvqdSvuHPGpHNVOAwYMkO+//15WrVol1113XZ4eGxISIk2bNpV9+/ZlW6dQoUJ6AQDAXdT555lnnqFDAQAAcuBp1/OLhATp2/I3HT5vd1MA+KC5v6ZNpGgl1/QeTauWsmyiWJ8aUe1wOHSQ+uuvv5Yff/xRIiNzzquSlZSUFNm2bZtUqlTJlDYCAAAAAADfCFRP6tHUKJP+A4BZ7mtaxS86N9DX0n2oPNNz586V4sWLy8mTJ/Xy119/GXVUmg+VusNp5MiRsmTJEjlw4IBs2rRJHn30UTl06JA88cQTNv0vAACAWXKYwBoAYNaxl4MvfDT1h0L6DwBm+S32nFEe1LG2bR1t5Wncp1J/TJ48Wf9s3759uu0zZsyQ3r176/Lhw4clMDAtPv+///1PoqOjdUC7dOnS0rx5c1mzZo3Ur29+3hUAAJySkpJk6tSpuqzOSyoVCAAAADxfWGiQxCeS/gOAe721YJdRvq50mF9ccA72tdQf17JixYp06xMmTNALAAB2n8POnDljlAEAAOD5qT+USY80kz4zN+jygTOXpEa5YnY3CYAP2OSHue99KvUHAABATrgGAACA93G9iO+BcWq5tW55ozz4qy22tgWAb0hKSTXKr3Wta2tbHBYm/yBQDQAAAAAAPJY3XGhW6T+U3/1wBCQA95u34YhR7hUV4TfHYALVAADAb5BWBQAA7+aJqT+c6T+cVPoPAHBXfurCIVcvhNnFymuFBKoBAAAAAPACkyZNkoiICClcuLC0atVK1q9fn21dNUlzmzZtpHTp0nrp0KFDpvq9e/eWgICAdEvnzp3T1Tl37pz06NFDSpQoIaVKlZK+ffvKpUuXbAySeGakmvQfANwpPjFF/6xbsbjtHcuIagAAAACAT/CGtA3eYN68eTJo0CAZNmyYbNq0SRo3biydOnWS06dPZ1l/xYoV0r17d/npp59k7dq1UrVqVenYsaMcO3YsXT0VmD5x4oSxfP755+n2qyD1jh07ZOnSpfL999/LqlWrpF+/fmJbjmrPjFNrRUn/AaCAEpNT5b1lfxjrL3es41d9yohqAAA8gBrBVLJkSb2oMgAAgKvx48dLdHS09OnTR+rXry9TpkyRsLAwmT59epYdNWfOHHnmmWekSZMmUrduXfnkk08kNTVVli9fnq5eoUKFpGLFisaiRl877dq1SxYtWqQfq0Zw33LLLfLBBx/IF198IcePH7flDfLkv5I+dEn/sZ/0HwDyaPSCnVJ3yEKZsGyvse2J2b/p7XZiMkUAAPxMSEiIvPDCC3pRZQAAAKfExETZuHGjTt/hFBgYqNfVaOnciI+Pl6SkJAkPD8808rp8+fJSp04defrpp+XPP/809qnnVuk+WrRoYWxTr6le+9dff7XsDfKWQfmu6T9e/GqLrW0B4F1UMPqjVQclNcMBT62r7bYGq5lMEQAAAAAAKGfPnpWUlBSpUKFCug5R6ydPnsxVJ73yyitSuXLldMFulfZj1qxZepT122+/LStXrpQuXbro11LUc6sgtqvg4GAd7M7udRMSEuTChQvpFnemj/H0O89I/wEgP+k+pq4+mGMdtV/V83Wk/gAAAAAAwIeNGTNGp+v4+uuv9USMTg8//LDcdddd0rBhQ7nnnnt0DuoNGzboUdb5NXr0aCOdmVpUbmx38uwwNek/AOTd7LWxmUZSZ6T2q3p2sPKuFgLVAAB4AHUr7tSpU/WiygAAAE5ly5aVoKAgOXXqVLpOUesqr3ROxo0bpwPVS5YskUaNGuVYt0aNGvq19u3bp9fVc2ecrDE5OVnOnTuX7evGxMRIXFycsRw5csSr8qMWFOk/AOTVoXPxbq1n5oS2ZiNQDQCAB1AnfzUpkVqs/EMAAAB4vtDQUGnevHm6iRCdEyNGRUVl+7ixY8fKqFGj9ISIrnmms3P06FGdo7pSpUp6XT33+fPndX5spx9//FG/tppcMStqcsYSJUqkW9yb+kM8Huk/AORF9fAwt9bzZgSqAQAAAACm8abRsJ5s0KBB+s6rTz/9VHbt2qUnPrx8+bL06dNH7+/Vq5cezeykck4PGTJEpk+fLhERETqntFouXbqk96ufL730kqxbt05iY2N10Pvuu++W66+/Xjp16qTr1KtXT+exjo6OlvXr18svv/wiAwYM0ClDVL5rOwR4fPIPkQ97NDPK+89c7W8AyE7PqAgJvMahLTDgaj07WDmOikA1AADwG4RKAADe6qGHHtJpPIYOHSpNmjSRzZs365HSzgkWDx8+LCdOnDDqT548WRITE+X+++/XI6Sdi3oORaUS2bp1q85RXbt2benbt68etb169Wo9Ktppzpw5UrduXbntttuka9eucsstt8jHH39s6f/d2242u7VO2gSUg7/cYmtbAHi+0OBAiW4TmWMdtV/Vs4OVh+BgC18LAAAAAADkkxrNrJasZJwAUY2SzkmRIkVk8eLF13zN8PBwmTt3rngKb0j94Uz/cTkxRTYfOW93UwB4gVe71JOPVh3MciS1ClLHdK0v/oBANQAAAAAA8FjemD5Gpf/oM2ODkf6jZrlidjcJgAf7z6ZjRvn5266X/8Un6ZzUKt2HXSOp7birhUA1AAAAAADwWN42mWJW6T++6X+zre0B4Nle/CotTdDA2+uIv14sJFANAICHCAvz/VmcAQAACiLAWyLVIlKsULBcSkgm/QeAHKWkpgWC721axa97i0A1AAAeIDQ0VF566SW7mwEAAOBxvC/xx1UfPtJUev+d/mPf6UtyfXnSfwDIbMrK/UZ5+F03eFwXWZn6w94kJwAAAAAAn2blF1z4JofLh8h7xlOLtHdN/+FyWz8AuHpn8R6jXLJIiF93DoFqAAAAAADgFbwo84eR/kPZcuS83U0B4IHiE5ON8lPtaoqnXyw0G4FqAAA8QFJSksycOVMvqgwAAICrvHlQvkr/4aTSfwCAq7cW7DLKg26vLf5+DCZQDQCAh1ylPnTokF6svGLtb+haAAC8+/wd4FXJP0j/ASBnn607bJRDgwnT0gMAAAAAAMBzuQaqvStOrRUn/QeALJy9lGCUR3jgJIpOTKYIAAAAAACg49TeOZmi0wek/wCQhVf/s9Uo94qq7hXHYLMxohoAAAAAAHgHL4xUt69T3igP/mqLrW0B4DmW7TptlAO88XYRExCoBgAAAAAAHssX5pgg/QcAVwfOpE2uOuXR5h7dOQ4Lj8EEqgEAAAAApvGBGCM86DPkbZMpOn3Yo5lR3nc6LUAFwD89+/nvRrlzg4riyRwWvhaBagAAPERISIheAAAAkDVvvTu+Xe1yRpn0HwB2HL+gO6FssUJ0hotg1xUAAGCP0NBQee211+h+AACADBy+kPvj7/QfFxOSZcuR83Y3BYCNNh76n1H+uJdnp/1QSP0BAAAAAACQKfWH9yL9BwDlydkbjY5oVq20F3SKw7JXIvUHAAAAAADwCgHemvsjY/qPLzfb2hYA9jl7KUH/bFClBG9DBgSqAQDwAMnJyTJ37ly9qDLM4Rs3DgMA4F9cbzv33jD1VcULX83AuuVonN1NAWCDRdtPGuX3H27qFe+Bw8IvUQSqAQDwAKmpqbJ37169qDIAAACucrhcavbiAdXapEeaGeV9py/Z2hYA1nvqs7S0HzXKFfOKt8BBoBoAAAAA4At8ZSI8wB3akv4D8Fuu58MO9crb2hZPxYhqAAAAAADgudKl/vDyIdWk/wD81qy1h4zymG6NxBvvajEbgWoAAAAAAOCx0oVIvD9OTfoPwE8N++8Oo1y2WCHxFg5SfwAAAAAAAFgbJLEC6T8A/5OYnDYP0aM3VRNv4rDwtXxyRPWkSZMkIiJCChcuLK1atZL169fnWP+rr76SunXr6voNGzaUBQsWWNZWAAD8RV7PzwAAAL42maJT8cLB+ueWo3F2NwWABcYv/cMo/7Nrfa/qc4enjqi+7bbbZP78+dnuP3v2rNSoUUPsNG/ePBk0aJAMGzZMNm3aJI0bN5ZOnTrJ6dOns6y/Zs0a6d69u/Tt21d+//13ueeee/Syfft2y9sOAIBZ7D6H5/X8DACANxsyZIgkJydnu//w4cNy++23W9omX+EjceoM6T8u2toWAOabsnK/US4SGkSXuyNQ/dNPP8mDDz6ov2RmJSUlRQ4dSksMbofx48dLdHS09OnTR+rXry9TpkyRsLAwmT59epb133vvPencubO89NJLUq9ePRk1apQ0a9ZMPvzwQ8vbDgDwX6Ghofr8qhZVdje7z+F5PT8DAODNPv30U7nxxhuzHAD10UcfSYMGDSQ4+OqIWuRtNF+Ajwypdk3/MejLLba2BYC54v5KMsovdarjdd3t8OTJFCdPniwTJ06Ue++9Vy5fviyeJDExUTZu3CgdOnQwtgUGBur1tWvXZvkYtd21vqJGeGVXX0lISJALFy6kWwAA8HR2ncPzc37mXAsA8GYqQK3SSrZo0UJGjx4tqampehS1Ove9/PLLMm7cOFm4cKHdzfQariES3whTX1Xi7/QfW0n/Afi0Yd+mXbR8ql1N8ToO8dxA9d133y3r1q2THTt2yE033SQHDhwQT6FuW1YjwipUqJBuu1o/efJklo9R2/NSX1F/aJQsWdJYqlat6qb/AQAA5rHrHJ6f8zPnWgDwHT42D16ulChRQmbNmqVTX6m7eNVduypwrUYDb926Vfr162d3E+EBPiT9B+AXvtl83CgHBfrS5TYPmUxRpcjYsGGDDtCq25mWLVsm/iQmJkbi4uKM5ciRI3Y3CQDg5VQeSzW5r1pyymlZUN5yDudcCwC+w5+/kqsLwypArYLTalT166+/LtWrV7e7WV7H4ZL7w0cyf2ik/wB834m4v4zyuw80Fm/k8PRAtaJGEv/www8632TXrl1lwoQJYreyZctKUFCQnDp1Kt12tV6xYsUsH6O256W+UqhQIX2F3HUBAKAg1JfXnTt36kWVzWT1OTw/52fOtQAAb/f555/reRnUeX3Xrl3y9NNPS8eOHWXgwIFy5coVu5vnvTmqfezSB+k/AN82aF5aDvr7mlURb79Y6FGB6oyTFqj1MWPG6Fua1KzGTzzxhNhJTT7VvHlzWb58ubFN/VGg1qOiorJ8jNruWl9ZunRptvUBAPBGdp7D83N+BgDAm3Xr1k1fEB4+fLg+39WpU0fGjh2rJzdesGCBNG7cOMd5keA/JvVoZpT3nrpoa1sAuN/aA3/qn4VDAn1mMliPCVRnF0F/+OGH5eeff5Zt27aJ3QYNGiRTp07Vsyw7r1qrCaP69Omj9/fq1UvfTuz0/PPPy6JFi+Tdd9+V3bt36z8kfvvtNxkwYICN/wsAANzL7nP4tc7PAAD4EjUHw++//y7PPvtsuu2tW7eWzZs3S+fOnaVdu3a2tc+b+Vqcp02tckZ58FdpIy8BeL9dJy4Y5am9Woi3clj4WlenmM0ldfU3PDw8y31NmjSRjRs36luJ7fTQQw/JmTNnZOjQofqPA9UuFYh2TuCkZloODAxM94fC3Llzda6w1157TWrVqiXffPONNGjQwMb/BQAA7mX3Ofxa52cAAHzJ6tWr033vdFWkSBE9waIadY3cSUhKS4s2c81BefzmGhIanO9Mph6Z/uPClWTZejTO7qYAcKNn5mzK8qKUt3E4PDRQfa0rvmXKlNEjlu2mRkNnNyJ6xYoVmbY98MADegEAwFd5wjk8p/MzAAC+JLsgtau2bdta0hZvN3rBTpm6+qCxPmbhHhm7aI9Et4mUmK71xVfSf/Sctt5I/1GrQnG7mwTADQ6evax/Vi8TRn/mku9cggQAAAAAAD4VpP5o1UFJzTCaT62r7Wq/L3AdaTnoS9J/AL7g571njfLkHs3FmzksfC0C1QAAAAAA0zB5FPIjMTk13UjqrKj9qp4vKFkkRP/cdoz0H4AveGLWBqNcv3IJ8cX5jsxAoBoAAA8QEhKiJ/tViyoDAAD4s9lrYzONpM5I7Vf1fMGkR5oZZZX+A4B3B3av/J1bv1Vk1vMEIWsEqgEA8JDRZqGhoXph5JmJ/WzicwMAAPc5dC7erfU83S21yhpl0n8A3m3+pmNGecJDTcTbOSx8LQLVAAAAAADAo1QPD3NrPW9A+g/ANwz+Ki3XfOVSRcTrOax7KQLVAAB4gOTkZPnmm2/0osoAAAD+rGdUhARe41YotV/V8xWk/wC8X4pLzqJ7mlQWX+CwMFJNoBoAAA+QmpoqW7Zs0YsqAwAA+LPQ4ECJbhOZYx21X9XzFaT/ALzflJX7jfKIuxuIL3AwohoAAAAAAPizmK715cm2kZlGVqt1tV3t9zWlwq5Oqr3tWJzdTQGQD+8s3pMpnQ9yz3cuPQIAAAAAPA4T2brPpEmTJCIiQgoXLiytWrWS9evXZ1t36tSp0qZNGyldurReOnTokK5+UlKSvPLKK9KwYUMpWrSoVK5cWXr16iXHjx9P9zzq9dREz67LmDFjxCoqGP39s7cY60PuqCe7R3XxySC18mH3ZkZ576mLtrYFQN78lZhilJ9qV9Nnus/BiGoAAAAAAOA0b948GTRokAwbNkw2bdokjRs3lk6dOsnp06ez7KQVK1ZI9+7d5aeffpK1a9dK1apVpWPHjnLs2DG9Pz4+Xj/PkCFD9M/58+fLnj175K677sr0XCNHjpQTJ04Yy7PPPmvpGxMSlDbGrm+bGj6V7iOn9B8Dv9xsa1sA5M3ohbuM8qDba/tM9zkszFEdbNkrAQAAAACAfBk/frxER0dLnz599PqUKVPkhx9+kOnTp8urr76aqf6cOXPSrX/yySfyn//8R5YvX65HTpcsWVKWLl2ars6HH34oLVu2lMOHD0u1atWM7cWLF5eKFSva9s5ZOJjPY9J/nI9Pku3HLtjdFAB5MGvtIaPsyxfUzESvAQAAAADgwRITE2Xjxo06fYdTYGCgXlejpXNDjaBW6T7Cw8OzrRMXF6dTe5QqVSrddpXqo0yZMtK0aVN55513JDk5WXz1tnNPQPoPwPv8eSnBKA+/07dSEzksPAYzohoAAAAAAA929uxZSUlJkQoVKqTbrtZ3796dq+dQ+ahVHmrXYLerK1eu6DoqXUiJEiWM7c8995w0a9ZMB7jXrFkjMTExOv2HGuGdlYSEBL04XbjAqOCCpv/4/tk2eX4OANZ6df42o9wrKsKnut9h4WsRqAYAwAOEhITIiy++aJRhjgBm9AIA+CE1IvqLL77QeavVRIwZqZHWDz74oDgcDpk8eXK6fSovtlOjRo0kNDRUnnzySRk9erQUKlQo03Op7SNGjPDa/KiegvQfgHdZuvOUUQ4M5EtHfpH6AwAAD6Busy1atKheVBkAAMCpbNmyEhQUJKdOpQVCFLV+rdzR48aN04HqJUuW6EBzdkHqQ4cO6ZzVrqOps9KqVSud+iM2NjbL/WrEtUoh4lyOHDlS4DfS31J/ZEz/8cepi7a2BUDODp69bJSnPJr2u+srHBYegwlUAwAAAADgwdQo5ubNm+uJEJ1SU1P1elRUVLaPGzt2rIwaNUoWLVokLVq0yDZIvXfvXlm2bJnOQ30tmzdv1vmxy5cvn+V+NcpaBbtdFxQs/cegLzfThYAHe+7z341y5waVxPc4LHslUn8AAOAB1MikxYsX63KnTp0kOJhTNADAN3CjkHuoFByPPfaYDji3bNlSJk6cKJcvX5Y+ffro/b169ZIqVaro1BvK22+/LUOHDpW5c+dKRESEnDx5Um8vVqyYXlSQ+v7775dNmzbJ999/r3NgO+uofNQqOK4mavz111/l1ltvleLFi+v1gQMHyqOPPiqlS5cWq/jjiGqF9B+Ad9h2LE7/LFM01O6meD2+BQMA4AHUqKjffvtNl2+//Xa7mwMAADzMQw89JGfOnNHBZxVQbtKkiR4p7Zxg8fDhw3qks5PKNZ2YmKiD0a6GDRsmw4cPl2PHjsl///tfvU09l6uffvpJ2rdvr0dHq9zWqr6aIDEyMlIHql3zVlvBH3NUO9N/PDrtVyP9R+0Kxe1uEoAMNh76n1H+uFdzn+wfh4WHYALVAAAAAAB4gQEDBuglK2qiRFfZ5ZB2UqOs1eSJOWnWrJmsW7cuHy2FGek/vn+2DR0LeJgnZ280ys2rh4uvSExONcqH/rys10ODzc8gTY5qAAAAAADgsfw19YdSOixE/9x+7ILdTQGQhbOXEvTPGyr7Tj7+0Qt2St0hC431fWcu63W13WwEqgEAAAAAADzQpEeaGWWV/gOA51i842pef+WD7k3FF4xesFM+WnVQUjNcIFTrarvZwWoC1QAAAAAAwGP584jq1tenpf8YOG+zrW0BkH3ajxrlinl99yQmp8rU1QdzrKP2u6YFcTcC1QAAwG8E2N0AAACQZ/46mWLG9B87jpP+A/AUrjn+O9QrL75g9trYTCOpM1L7VT2zEKgGAAAAAJgmgMuEQIGQ/gPwPJ+tO2SUx3RrJL7g0Ll4t9bLj2DTnhkAAORaSEiIPP/880YZAAAAV/lz6o+s0n/88FwbW9sDQGTItzuMbihbrJBPdEn18DC31ssPRlQDAOABAgICpFSpUnpRZQAAAFzl53FqLbxoqP5J+g/Afq45mh+9qZr4ip5RERJ4ja+iar+qZxYC1QAAAAAAAB7sw+5NjfKekxdtbQvg7yYu+8Mov9a1nviK0OBAiW4TmWMdtV/VMwuBagAAPEBKSoosWbJEL6oMAACAzJOW+auM6T8A2OdfK/Yb5bBQ38qqHNO1vjzZNjLTyGq1rrar/WYiUA0AgAdQwem1a9fqhUA1AABAGsLU6dN/7DxxgY8HYJMLV5KM8uDba/vk+xDTtb7sHtXFWI8oE6bXzQ5SKwSqAQAAAACAx2JA9VWk/wDsN9xlEsWn29e0tS1mck3vUaV0EVPTfbgiUA0AAAAAADwYY6oV0n8A9pv/+zGjHBxEWNXd6FEAAAAAgGkCMuS5BJB/pP8A7HMi7i+j/M79jfzmrXBYeK2QQDUAAPAbAURLAADwOqT+SEP6D8A+g+ZtMcr3N7/Ob94KB4FqAAAAAAAAEn+4Iv0HYJ+1B/7UP1W+ZgbAmIMR1QAAAAAAAF6iTNFQ/XPniQt2NwXwG7tPpv2+fdKrhfgTh4XzBBCoBgDAA4SEhMjTTz+tF1WGOcj8AQCA9yH1R3ofPNLUKO85edHy9wPwR8/M2WSU29YuJ/7EQeqPvIuNjZW+fftKZGSkFClSRGrWrCnDhg2TxMTEHB/Xvn17PVzfdXnqqafy/eYBAJAf6vxTvnx5vXAbGQAAQBoHkep0Wtcsa5QHztvMRwWwwIEzl/XP6mXC/K6/HRa+VrD4iN27d0tqaqp89NFHcv3118v27dslOjpaLl++LOPGjcvxsareyJEjjfWwMP/70AEA4A8C7G4AAPgh7mYBzEn/8eflRNJ/ABb4Zd9Zozy5R3P/63OHdS/lM4Hqzp0768WpRo0asmfPHpk8efI1A9UqMF2xYkULWgkAQNZSUlJk9erVutymTRsJCgqiqwAAAJhMMdv0H49M/dVI/1GnYnE+K4BJomf9ZpTrVy5BP5vIp3NUx8XFSXh4+DXrzZkzR8qWLSsNGjSQmJgYiY+Pt6R9AAC4BqpXrlypF1UGAADAVWT+yDn9xwuk/wBMTT0Un3j1+1mryGvHGH2Rw8Ih1T4zojqjffv2yQcffHDN0dSPPPKIVK9eXSpXrixbt26VV155RY/Enj9/fraPSUhI0IvThQvMtAsAgFfg/nMAsP7QS+IleFGQxJuULRYqZy8lyq4TF2Tot9uleniY9IyKkNBgnx6TCFjqm83HjPL4h5r4Ze87mEwxzauvvpppssOMi8pP7erYsWM6DcgDDzyg80/npF+/ftKpUydp2LCh9OjRQ2bNmiVff/217N+/P9vHjB49WkqWLGksVatWLfCbDgAAAAAAskCcOks31ShjlGetPSSjftgldYcslNELdvIxAtxk4LwtRrlKqSL0q7+PqB48eLD07t07xzoqH7XT8ePH5dZbb5XWrVvLxx9/nOfXa9WqlTEiu2bNmlnWUelBBg0alG5ENcFqAAAAAABgBRWM/n7riUzbUx0iH606qMsxXevzZgAFkKJ+of52V+PKftuXDgtfy+MD1eXKldNLbqiR1CpI3bx5c5kxY4YEBub9dpfNmzfrn5UqVcq2TqFChfQCAAC8S4DdDQAAP0TWJRQUA6rTS0xOlamrrwajs6P2D+5YlzQgQAF8tCot28Kouxv4dZ5uq/hM4iIVpG7fvr1Uq1ZN56U+c+aMnDx5Ui+uderWrSvr16/X6yq9x6hRo2Tjxo0SGxsr//3vf6VXr17Stm1badSokY3/GwAAAAAAoDCZYnqz18bqkdM5UftVPQD5N3bRHqNcMiyErrSAx4+ozq2lS5fqdB1que6667KM/CclJemJEuPj4/V6aGioLFu2TCZOnCiXL1/W6Tu6desmr7/+ui3/BwAAYC5G9QEAAG936Fy8W+sByOyvxBSj/GTbtJTD/shh4Wv5TKBa5bG+Vi7riIiIdMPVVWB65cqVFrQOAICcBQcHyxNPPGGUAQDwFVwkREE5SP6RTvXwMLfWA5DZ6IW7jPKgjrX9uoscFkaqfSb1BwAA3kzNq1ClShW95GeOBQAAAF9F6o/0ekZFSOA1Jt5Q+1U9APkza+0ho1woOIhutAjfhAEAgN8IYDpFAADg5UKDAyW6TWSOddR+VQ9A3p27nGiUh91Z3++70GFhD3BvMQAAHiAlJUXWrVunyzfddJMEBXHVHgDgG7hICG8KkniLmK5Xg2dTVx/MNLFiicLBxn4A+fj9mr/VKD/GnQli5W0tBKoBAPCQQLWa4Fe58cYbCVQDAAD8zXWuKaRRwejBHevK7LWxeuLExdtPyqmLCXLhSrJcSUqRwiEMfADyY/GOU0Y58Fp5dvyAw8LX4j4QAADgN5jQCwAA70OYOnsqvUffNjVk5N0NZMnAdsb2J2dvtOS9AXzNoT8vG+UpjzaztS2egskUAQAAAAA+gYuEKDAi1blSMixEioZeHUW98o8zkpoxJwiAa3ru89+NcucGlegxizGiGgAAAAAAwAcseqGtUR7x3Q5b2wJ4oy1H4/TPMkVD7W6Kx3BYeLWQQDUAAPAbZJgDAMD7WBkk8XZVw8OM8qdrD9naFsBbJCanyrTVB+SZz9JS5nzcq7mtbfIkpP4AAAAAAPgELhKioJhLMW++fqa1UZ7xy0E+gEAORi/YKXWHLJRRP+ySBdtPGtuX7EgrwzqMqAYAAH6DPKkAAMDXNa1W2iiP+G6nrW0BPD1I/dGqg5JVOne1Xe2HMKIaAAB/ExwcLI899pheVBkAAABXMaI676Y82swoL915io8SkEW6j6mrc77jQO1X9fydw8LXYkQ1AAAeIDAwUCIiIvSiygAA+AruZkFBkaE67zo3qGSUo2f9xocQyGD22tgsR1K7UvtVPViHb8IAAMBvBJApFQAAr+NgSHW+/LNrPaO89eh5970hgA84dC7erfV8mcPCYzCBagAAPEBKSoqsX79eL6oMAACAq5Jcbr2ftvoAt+LnUnTbGkb5rg9/4eMEuKgeHubWenAPAtUAAHgAFZxeuHChXghUAwB8S4DdDfAZkyZN0mnCChcuLK1atdIXuLMzdepUadOmjZQuXVovHTp0yFRfjZIbOnSoVKpUSYoUKaLr7N27N12dc+fOSY8ePaREiRJSqlQp6du3r1y6dEmsoiYzG/DF78b6qB92Sd0hC5nkLJd6tKpmlI+d/8v9bxDgpXpGRUjgNU5Par+qB+sQqAYAAP6DWAkAwEvNmzdPBg0aJMOGDZNNmzZJ48aNpVOnTnL69Oks669YsUK6d+8uP/30k6xdu1aqVq0qHTt2lGPHjhl1xo4dK++//75MmTJFfv31VylatKh+zitXrhh1VJB6x44dsnTpUvn+++9l1apV0q9fP8uC1B+tOphpMkWVN1ZtV/uRs5F3NzDKd7y/mu4C/hYaHCjRbSJz7A+1X9Xzdw4LJwqgtwEAAAAA8HDjx4+X6Oho6dOnj9SvX18Hl8PCwmT69OlZ1p8zZ44888wz0qRJE6lbt6588sknkpqaKsuXLzdGU0+cOFFef/11ufvuu6VRo0Yya9YsOX78uHzzzTe6zq5du2TRokX6sWoE9y233CIffPCBfPHFF7qemRKTU2Xq6oM51lH7VT1kLygwQFrXLKPL5+OT5MKVJLoL+Ntzt9XOdiT1k20jJaZrffpK1IS25KgGAAAAAPiAAO5mKbDExETZuHGjTs3hFBgYqNfVaOnciI+Pl6SkJAkPD9frBw8elJMnT6Z7zpIlS+qAtPM51U+V7qNFixZGHVVfvbYagZ2VhIQEuXDhQrolP2avjdUjp3Oi9qt6yNknj6W9fz2nZZ8uBvA33aeuM8ovdqotvaKqy5A76snuUV0IUts0ojrYupcCAACwF7ESAIA3Onv2rJ7DokKFCum2q/Xdu3fn6jleeeUVqVy5shGYVkFq53NkfE7nPvWzfPny6fYHBwfrYLezTkajR4+WESNGSEEdOhfv1nr+LCw0WKqUKqJzVG85cl6SUlIlJIgb7OHf/kpMka1H43S5WniYDLi1lt1N8lgWxqlJ/QEAAAAAgC8bM2aMTtfx9ddf64kYzRQTEyNxcXHGcuTIkXw9T/XwMLfW83df929tlF/8aoutbQE8waPT0u4K+e+Am21tC9JwCQ0AAPiNAO4/BwB4obJly0pQUJCcOnUq3Xa1XrFixRwfO27cOB2oXrJkic5D7eR8XE7PqX5mnKwxOTlZzp07l+3rFipUSEqUKJFuyY+eURE6T2xO1H5VD9dWvnjaBYpvNx/XOcoBf3UlKUU2HvqfLlcqWVhKhYXa3SSP5rDweEGgGgAAD6Buo+3evbteVBkAAF9B2qWCCw0NlebNmxsTISrOiRGjoqKyfdzYsWNl1KhRekJE1zzTSmRkpA42uz6nyietck87n1P9PH/+vM6P7fTjjz/q11a5rM0UGhwo0W0ic6yj9qt6yJ0lA9sa5feW76Xb4Ld6TU/L1f7Dc21sbYs3cFj4WnwTBgDAA6hJiWrXznrWaQAAvBl3s7jHoEGD5LHHHtMB55YtW8rEiRPl8uXL0qdPH72/V69eUqVKFZ0jWnn77bdl6NChMnfuXImIiDByShcrVkwv6n154YUX5I033pBatWrpwPWQIUN0Hut77rlH161Xr5507txZoqOjZcqUKXoyxgEDBsjDDz+s65ktpmt9/fPj1QfTTealRlKrILVzP3KndoXiRnnisr3yQgf+9oR/jqZef/CcLpctVkjCizKa2pMQqAYAAH6DUX0AAG/10EMPyZkzZ3TwWQWdmzRpokdKOydDPHz4sL7w7TR58mRJTEyU+++/P93zDBs2TIYPH67LL7/8sg529+vXT4+cvuWWW/RzuuaxnjNnjg5O33bbbfr5u3XrJu+//75l/28VjK5boYQM/Duv8pA76ul0H4ykzp/P+rYycvPO33RU7mt2nRvfLcDzPfHpb0Z50QuMpva0IdUEqgEA8AApKSmybds2XW7YsKHOQwkAgC/gIqH7qICxWrKyYsWKdOuxsbHXfD41qnrkyJF6yU54eLgelW2nIJf0Hn3b1LC1Ld7ullpljfKgL7cQqIZfSUhOkZ/3ndXlUmEhekQ1PCv1B8mcAADwkED1t99+qxdVhjmYSxEAAPi7sd3SJtVcu/9PW9sCWOnJ2RuzzNkOz0GgGgAA+A0C1QDAsRfex+GaoBoF9uCNVY1y96nr6FH4haSUVFmx54wuFw0NkvLF01IcwXOOwQSqAQAAAAAA/Ej/W2sa5X2nL9naFsAKT3+2ySgvH9yeTs8DUn8AAACYIIBMqQBgOY69gOd5sWMdo9xh/Epb2wKYLTklVZbtOqXLaiLWiiUZTe2pGFENAAAAADANaZdQUGT+cD81keYdDSsZ62cvJZjwKoBneO6L343yTy8ymtqTj8EEqgEAgN8gWAIAgPdxWHrjuf+Y8FATo3z/5DW2tgUwczT1gm0ndTkwQKRKqSJ0di4kJqca5bi/EtOtm4lANQAAAAAA8FiMqDaHSoFQv1IJXY79M16uJKWY9EqAfQZ+ucUor3zpVt6KXBi9YKfUHbLQWI/7K1mvq+1mI1ANAIAHCA4Olvvvv18vqgwAAICrCFSb5/Pom4zyk7M38pGDT0lJdch3W44b61XDw2xtjzcYvWCnfLTqoKRmuJFFravtZgerCVQDAOABAgMD5YYbbtCLKvuK2NhY6du3r0RGRkqRIkWkZs2aMmzYMElMTLQtHyMAwOpjLz0OeKqSYSFSNDRIl1f+cUZSM0anAC/20r9dR1OTm/paVHqPqasP5lhH7TczDYjvfBMGAAAeZ/fu3ZKamiofffSR7NixQyZMmCBTpkyR1157ze6mAQAAL0Ho1FyLXmhrlEd+b/6t/YAV1EWX+ZuOGevVyxSl469h9trYTCOpM1L7VT2zcG8xAAAeQAVzd+3apcv16tXzmVHVnTt31otTjRo1ZM+ePTJ58mQZN26c5e1hUB8AWI+7WVBQDnJ/mMo1HcLMNbEy/K4bzH1BwAIx87cZ5Z9eZDR1bhw6F+/WevnhG9+CAQDwcsnJyfLvf/9bL6rsy+Li4iQ8PDzHOgkJCXLhwoV0iztw+zkAWI+LhIDn+/qZ1kZ5xi853/oPeMNo6nm/HTHWI8symjo3qucyh3du64m/B6ojIiL01XrXZcyYMTk+5sqVK9K/f38pU6aMFCtWTLp16yanTp2yrM0AAPiTffv2yQcffCBPPvlkjvVGjx4tJUuWNJaqVata1kYAAOBZSP1hvqbVShvlEd+R/gPebci3243yskHtbG2LN+kZFSGB17i6rParembxqUC1MnLkSDlx4oSxPPvssznWHzhwoHz33Xfy1VdfycqVK+X48eNy3333WdZeAAC80auvvprp4nDGReWndnXs2DGdBuSBBx6Q6OjoHJ8/JiZGj7x2LkeOpI2IKIgAxvUBgOW4mwUFRqTaElMebWaUl+5kAB+8N1XQnF8PG+vXly9ma3u8SWhwoES3icyxjtqv6pnF53JUFy9eXCpWrJiruuqL77Rp02Tu3Lnyj3/8Q2+bMWOGzg26bt06uemmm0xuLQAA3mnw4MHSu3fvHOuofNRO6kLwrbfeKq1bt5aPP/74ms9fqFAhvQAAADiIVFuic4NKRjl61m8SO+YOPnzwOq53BCx2mSgUuRPTtb7+OXX1wXQTK6qR1CpI7dxvFp8bUa1Sfag0Hk2bNpV33nknxzyfGzdulKSkJOnQoYOxrW7dulKtWjVZu3at5XkzAQDwFuXKldPnzJyW0NBQYyR1+/btpXnz5vqCsJ0TRTKqDwBsOPZyNwsKiLkUrfPPrvWM8rajcRa+MuCe0dRqQlCnOhWL0635oILRu0d1MdaLFQrS62YHqX0uUP3cc8/JF198IT/99JPOffnWW2/Jyy+/nG39kydP6i/RpUqVSre9QoUKel92yJsJAEDuOIPU6iLwuHHj5MyZM/ocm9N51kxM6AUAAJC96LZpd8Td+eHPdBW8yps/7DLKC59vY2tbvF2oS3qPsNBgU9N9eFWgOi85MAcNGqS/DDdq1Eieeuopeffdd/WETWoEtDuZlTcTAABfs3TpUj2B4vLly+W6666TSpUqGQsAwD9wNwsKihTV1urRqppRPnb+L4tfHcj/aOpPfj5orNerVIKu9MJjcLCv5cB01apVK536IzY2VurUqZNpv8plnZiYKOfPn083qvrUqVM55rkmbyYAwN2CgoLk7rvvNsq+Qp3Dr3UetxLBEgCw4dhLp6OASP1hrZF3NzAmo7vj/dWyeWhHi1sA5N3YxXuM8vfP3kIXeukxONgbcmCqJT82b96s82CWL18+y/0qV2ZISIge5dWtWze9bc+ePXL48GGJiooqULsBAMgLFZxu0qQJnQYAAABbBQUGSOuaZWTN/j/lfHySXLiSJCUKh/CuwKNHU09esd9Yb1ClpK3tgQ+n/sgtNfnhxIkTZcuWLXLgwAGZM2eODBw4UB599FEpXbq0kSdTTe60fv16vV6yZEnp27evThmi8lqryRX79Omjg9Q33XSTzf8jAADgfozrAwDLcehFATlI/mG5Tx5rYZR7TrsaQwE81YSlfxjl/w642da2+CaHZa/k8SOqc0ul41ATKQ4fPlznpI6MjNSBahWEdkpKStIjpuPj441tEyZM0KOu1Yhq9bhOnTrJv/71L5v+FwAAf5WamqpzOSvXX3+9PjfB/Uj9AQCA9yH1h/XU5GlVShXROaq3HDkvSSmpEhLE36fwTO//ePV7lNLourTUvnAPUn/kQ7NmzWTdunU51omIiNC3A7gqXLiwTJo0SS8AANhFzanw+eefG5P2hoaG8mYAAHxCAEOqAa/0df/W0vLN5br88r+3yoSHSFMHz/Pesr1Gef4zrW1tCwqOy2EAAMBvcPc5AADex8J5vOCifPHCRvnr349lGvgHeIIJy9LSfjSrdjX1L9zLyt98AtUAAAAAANOQdgkFRoDUNksGtjXK7y1PG7kKeIJ/rUhL+fHVU1G2tsWXOSw8BhOoBgAAfiOAaAkAWH/spc9RQIzjtU/tCsWN8kSXFAuAJxi7aI9RvjEi3Na2wD0IVAMAAL9BsAQAAO+jJvJzmrb6gCQmp63DfJ/1bWWU5286SpfDI0xddcAof9HvJlvb4uscFr4WgWoAAAAAgGm4mwUFMXrBTnnj+13G+qgfdkndIQv1dljjllpljfKgL7fQ7fAIby5IOy7cVKOMrW3xdQ4LI9UEqgEAgN8g8wcAAN5DBaM/WnUw02i+VIfo7QSrrTO2WyOjvO7Anxa+MpDZjF8OGuU5T6SN+Ic5yFENAICfCQoKki5duuhFlWEOAtUAYD3SLiE/VHqPqavTglFZUftJA2KNB2+sapQf/nidRa8KZG3Ed2l3VNx8fdqIf5iD1B8AAPgZFZxu2bKlXghUAwAAfzd7baweOZ0TtV/VgzX631rTKO87fYluhy1cf+dnPd6Sd8HHkPoDAAD4jQDG9QGA9cdehlQjHw6di3drPRTcix3rGOUO41fSpbDFkG93GOW2tcvxLliBHNUAAPiX1NRUiY2N1YsqAwDgK7hIiPyoHh7m1npwz8SodzSsZKyfvZRAt8JSn68/bJRn9L6R3rcIqT8AAPAzycnJ8umnn+pFlWESRvUBAOAVekZFSOA1zttqv6oH60x4qIlRvn/yGroeloqZv80o31q3PL3vg0j9AQAA/AZxagDg4AvvEBocKNFtInOso/arerCO6u/6lUrocuyf8XIlKYXuhyW++u2IUf64Z3N63UIOh3VjqjmiAwAAAABMQ45q5FdM1/ryZNvITBea1UhqtV3th/U+j77JKD/92UbeAljipX9vNcodb6hIr/to6o9gC18LAADA9tyKAACLj710OApABaNLFw2VMQv36PUhd9TT6T4YSW2fkmEhUjQ0SC4npshPe85IaqpDAq+VpwUogK9/P2qUJ/doRl9azMIB1YyoBgAA/oOvUABgw7GXi4QooKCAtJvB+7apQZDaAyx6oa1RHvn9TlvbAt83cN4Wo9zFZUJPWMNh4ZhqUn8AAAC/QawEAADvY2WQBLlTNTzMKM9cE0u3wTTfbTlulD/o3pSe9nEEqgEAAAAApuFuFhRUqst952v3/ykpqQSuPcHXz7Q2yjN+OWhrW+C7nv38d6N8Z+PKtrbFXzlI/QEAgH8JCgqSDh066EWVYY4AwiUAYDnuZkFBLNp+Qib9tN9Y7z51ndzy9o96O+zVtFppozziO9J/wP0Wbkv7PZ/wUGO62EKJyalGOSklNd26mRhRDQCAB1DB6ZtvvlkvBKrNQ7AEAKzHRULklwpGP/3ZJrl4JTnd9pNxV/R2gtX2m/Jo2sR2y3aesrUt8D1Pz9lklO9tep2tbfEnoxfslLpDFhrr6iYWta62m41ANQAA8Bvcfg4ANhx7Ofi6zaRJkyQiIkIKFy4srVq1kvXr12dbd8eOHdKtWzddX01oOXHixEx1nPsyLv379zfqtG/fPtP+p556Ssym0nuoUbpZ3XHu3Kb2kwbEXp0bpE1s98Ss32xtC3zLkh0njfK4BxhNbRUVjP5o1UEdnHal1tV2s4PVBKoBAPAAqampcuzYMb2oMkxCsAQA4KXmzZsngwYNkmHDhsmmTZukcePG0qlTJzl9+nSW9ePj46VGjRoyZswYqVixYpZ1NmzYICdOnDCWpUuX6u0PPPBAunrR0dHp6o0dO1bMtv7gOTkRdyXb/SqGovarerDXP7vWM8rbj8XZ2hb4jn6zNxrl+5szmtoKKr3H1NU555tX+81MA0KgGgAAD5CcnCyffPKJXlQZ5uD2cwCAtxo/frwOGPfp00fq168vU6ZMkbCwMJk+fXqW9W+88UZ555135OGHH5ZChQplWadcuXI6iO1cvv/+e6lZs6a0a9cuXT31Oq71SpQoIWY7ffGKW+vBPNFtaxjl//vgZxn67XaZtvqAZTlt4Xt+3J2WRmb0fQ1tbYs/mb02NtNI6ozUflXPLASqAQAAAACmIfVHwSUmJsrGjRv1pMtOgYGBen3t2rVue43PPvtMHn/8cZ3ew9WcOXOkbNmy0qBBA4mJidGjtbOTkJAgFy5cSLfkR/nihd1aD+aqV6m4UZ619pCM+mGXZTlt4Xsen5mWRqZ7y2q2tsWfHDoX79Z6+RFs2jMDAAB4GIIlAGDDsZe8SwV29uxZSUlJkQoVKqTbrtZ3795d8BcQkW+++UbOnz8vvXv3Trf9kUcekerVq0vlypVl69at8sorr8iePXtk/vz5WT7P6NGjZcSIEQVuT8vIcKlUsrCeODGrAX4qlF6xZGFdD/ZSwehdJy5m2u7MaavEdK1vQ8vgjVb+ccYoj7qnga1t8TfVw8PcWi8/GFENAAD8BimqAcCGYy8HX68wbdo06dKliw5Iu+rXr5/Ohd2wYUPp0aOHzJo1S77++mvZv39/ls+jRlzHxcUZy5EjR/LVnqDAABl259XgZsaPkHNd7Vf14N85beFbHpueNklsz5uq29oWf9MzKkKudUhV+1U9sxCoBgAAfiPjrcwAAAuOvXRygam0G0FBQXLqVFreVkWtZzdRYl4cOnRIli1bJk888cQ167Zq1Ur/3LdvX5b7VT5slcPadcmvzg0qyeRHm+mR067Uutqu9sNenpDTFr7jl31njbLzQhWsExocKNFtInOso/aremYh9QcAAPAbxKkBAN4oNDRUmjdvLsuXL5d77rlHb0tNTdXrAwYMKPDzz5gxQ8qXLy933HHHNetu3rxZ/6xUyZogsQpG316/oqw/eE5PnKhyUqt0H4yk9gyekNMWvqPHJ78a5T435xwwhTmcaXrUnRCuF6HUSGoVpDY7jQ+BagAA4DcY1QcANhx7uUroFoMGDZLHHntMWrRoIS1btpSJEyfK5cuXpU+fPnp/r169pEqVKjpHtHNyxJ07dxrlY8eO6SBzsWLF5PrrrzeeVwW8VaBaPXdwcPoQgUrvMXfuXOnatauUKVNG56geOHCgtG3bVho1aiRWUUHpqJplLHs9eFdOW/iGdQf+NMr/7FrP1rb4u5iu9WVwx7pS+/WFxrbdo7qYOpLaiUA1AAAeQN3O265dO6MMAICv4CKhezz00ENy5swZGTp0qJw8eVKaNGkiixYtMiZYPHz4sAQGpgURjh8/Lk2bNjXWx40bpxf198aKFSuM7Srlh3rs448/nuVIbrXfGRSvWrWqdOvWTV5//XU3/a/g7VSu2jcX7Mox/YfZOW3hGx7+eJ1Rjm5bw9a2QDIFpa0IUisEqgEA8AAqON2+fXu7m+HzGNQHABx7vZlK85Fdqg/X4LMSEREhDsc1kgeLSMeOHbOtpwLTK1euzGdr4U85bT9alf2EiiqIbVWQC95pQ+w5o/xK57q2tgVXpWS4+qTWrUi5xJECAAD4Ecb1AYDlR16uEgI+nybgybaReuR0dl76aouVTYKXSExOlWmrD8gDU9Ya255uX9PWNkFk0fYTcsvbP6brCrWutpuNQDUAAB5AjWQ6ffq0XnIz+gn5Q6wEAADAnGC1ymE75I560iuquv75xxtdjP1fbTwqv+w7S9fDMHrBTqk7ZKGM+mFX2t/qf2+HfVQw+unPNsmJuCvptp+Mu6K3mx2sJlANAIAHSEpKksmTJ+tFlWEOxlMDAACYQ6X36Numhoy8u4H+qdZ3jexs7O/xya9y4Qp/5+JqMFqli8mY21ytqu0Eq+2h0nuM+G6nfh8ycm5T+zOmBXEnAtUAAMBvcPs5AFh93KXHAX9WJDRI/vN0a2O90fAltrYHnpHuY+rq7HOaK2q/qgdrrT94LtNIalcqPK32q3pmIVANAAAAADAFcWoAzauXliduiTQ6ou/MDXSKH5u9NjbTSOqM1H5VD9Y6ffGKW+vlB4FqAADgNwiYAIDFx12GVAMQkdf/r77RD8t3n5ZF20/SL37q0Ll4t9aD+5QvXtit9fKDQDUAAPAbxEsAwOLjLh0O4G+ukys+9dlGOXspgb7xQ9XDw9xaD+7TMjJcKpUsnO25W21X+1U9s/hMoHrFihX6an1Wy4YN2d9W0r59+0z1n3rqKUvbDgAArBFAyAQAAMAWanLFRS+0MdZbvLFMHA7zJmWDZzr45+Vr1gkMEOkZFWFJe5AmKDBAht159e6HjMFq57rar+qZxWcC1a1bt5YTJ06kW5544gmJjIyUFi1a5PjY6OjodI8bO3asZe0GAADWYUQ1AFiL4y4AV3UrlpCXOtUx1u/51xo6yI/8sPWEfLbu8DXrRbeJ1Bc2YL3ODSrJ5EebScWS6dN7qHW1Xe03U7D4iNDQUKlYsaKxnpSUJN9++608++yz18yLFhYWlu6xAABYLSgoSKKioowyAAC+gDtZAGTU/9brZdrPB+Xc5UTZcuS8fPnbEXmwRVU6ysftPXVR+s/dZKz3uTlCPl2TfmJFNVBXBaljuqblNIf1VDD69voVZf3Bc3riRJWTWqX7MHMktc8FqjP673//K3/++af06dPnmnXnzJkjn332mQ5W33nnnTJkyBAdvM5OQkKCXpwuXLjgtnYDAPyTCk537NjR7mb4PEb2AYDVB156HEBmG/7ZQWq+tkCXX/73Vrn5+rJSpVQRuspHXbySJLdPWGWs/zi4ndQoV0xiutST2Wtj9cSJKie1SvfBSGrPoILSUTXLWP66PhuonjZtmnTq1Emuu+66HOs98sgjUr16dalcubJs3bpVXnnlFdmzZ4/Mnz8/28eMHj1aRowYYUKrAQAAAMB3EKcGkF0QbOVL7aXdOyv0+s1jfpQDb3WVQAtGbMJaKg95w+FLjPWPejbXQWpFBaX7tqnBWwKDxyd8efXVV7OdJNG57N69O91jjh49KosXL5a+ffte8/n79eunA9oNGzaUHj16yKxZs+Trr7+W/fv3Z/uYmJgYiYuLM5YjR4645f8KAPDvP+DOnz+vFyaVMQ+3oAMAAHiG6mWKyqh7Ghjrbcb+ZGt7YI7GI9KC1E+2rSGdbiD1Lrx4RPXgwYOld+/eOdapUSP91ZcZM2ZImTJl5K677srz67Vq1Ur/3Ldvn9SsWTPLOoUKFdILAADuouZWeO+994wLomruBbgfqT8AwFocdwHkpOdN1WXWmljZe/qSHDv/l0xddUCi2zLC1lcMmrdZLlxJ1uU6FYpLTNd6djcJHs7jA9XlypXTS26pUWgqUN2rVy8JCQnJ8+tt3rxZ/6xUydxZLAEAgPUImACAxcddkn8AuIYlA9tKZMzVfNVvLtglt9YtL9eXv5oaAt7ryw1HZP7vx4z1xQPb2toeeAePT/2RVz/++KMcPHhQnnjiiUz7jh07JnXr1pX169frdZXeY9SoUbJx40aJjY3VEzCqAHfbtm2lUaNGNrQeAACYiYAJAFiLC4QArn2cCJD1r91mrHcYv1KSU1LpOC+2/VicvPyfrcb67lGdbW0PvEegL06i2Lp1ax2Qzuq2ajVRYnx8vF5Xt1UvW7ZMOnbsqOurNCPdunWT7777zoaWAwAAsxEwAQBrMS0agNwoX6KwvN+9qbFef+hiOs5LnY9PlP/74Gdj/edXbpXCIUG2tgnew+NTf+TV3Llzs90XERGRboKqqlWrysqVKy1qGQAAAAD430hJAMiNuxpXli/WH5Y1+/+UxJRUGbtot7zcOfMgRHiulFSHNBm51Fif9XhLua50mK1tgnfxuRHVAAAA2SFcAgDW4rgLIC/mRt9klP+1Yr9sPXqeDvQiNV+7mmtcGXx7bWlbO/dzzgEKgWoAAOA3GNgHAFYfeOlxAHmzeejtRvmuD3+RK0kpdKEXeOLTDUa5ZWS4PHtbLVvbA+9EoBoAAA8QGBgoLVq00IsqwyxETADAShx1AeRVqbBQmdHnRmO97pBFdKKHm/7zQVm267Sx/uWTUba2B96Lb8IAAHiA4OBgueOOO/SiyjAHI6oBwFrkqAaQH7fWKa9zVju9+p+tdKSH+i32nIz8fqexvvfNLra2B96NQDUAAPAbjOwDAIuPuxx4AeTT+92bGuUvNhyRtfv/pC89zOmLV+T+KWuN9fX/vE1Cggg1Iv/49AAA4AEcDodcvnxZL6oMczCyDwCsRZwaQEHsHNnJKHefuk4uJSTToR4iKSVVWr653Fj/6qkoKV+8sK1tgvcjUA0AgAdISkqScePG6UWVYQ4CJgBgLS4QAiiIsNBg+fdTafmOGwxbTId6iFr/XGiUh/5ffbkxItzW9sA3EKgGAAB+g1vQAcDi4y4dDqCAWkSES+/WEcb6k7N/o09t9qBLuo8O9SrI47dE2toe+A4C1QAAwG8EEDIBAGuPu0SqAbjB8LtuMMqLd5ySpTtP0a82eX/5Xlkfe85Y/+SxFrwXcBsC1QAAwG8QMAEAy4+8dDkAt/jjjS5GOXrWb3LuciI9a7FVf5yR8Uv/MNb3v9WV9wBuRaAaAAAAAGAKLhACcJfQ4EBZ8FwbY73ZqKVMQm6hY+f/kl7T1xvrm4feLkGBXIyEexGoBgAAfiOQP6YBwFKEMAC4U/3KJeSFDrWM9ftdciXDPFeSUuTmMT8a698/e4uUCguly+F2BKoBAIDfIGACABYfdznwAnCzFzrUluKFgnV546H/yX82HqWPTVZ3yCKjPLZbI2lQpSR9DlMQqAYAwAMEBgZK48aN9aLKMAcBEwCwFpPYAjDD5mEdjfLgr7bI8fN/0dEm6ThhpVG+r1kVefDGqvQ1TMM3YQAAPEBwcLDcc889elFlmIOACQBYiwuEAMygciP/9GJ7Y731mB/JV22C0Qt2yR+nLulyicLBMv7BJma8DGAgUA0AAPwGARMAsPi4S4cDMElk2aIy4q4bjPV276ygr91o8Y6T8tGqA8b6FpdR7IBZCFQDAOABHA6HJCYm6kWVYQ4CJgBgrQCuEAIw0WOtI6RG2aK6fPhcvEz/+SD97QYHzlySJ2dvNNa3De/I8RyWIFANAIAHSEpKktGjR+tFlWESItUAAAA+ZfngdkZ55Pc7dZAV+RefmCz/eDctL/XSgW2leOEQuhSWIFANAAD8BjmqAcDi4y4XCAGYfpwJkHUxtxnrKsianJJKv+eDurOz/tDFxvqHjzSVWhWK05ewDIFqAADgNwiYAADHXQC+p2LJwjLxobSJ/hoOXyKJyakybfUBGfrtdv1TrSNnN41ebpR7t46Q/2tUmS6DpYKtfTkAAAD7MLAPAKw+7nLkBWCNe5pWkbnrD8v6g+fkr6QUqfP6QnGd+eXNBbskuk2kxHStz1uShZj52+TUhQRdrhYeJsNdJqoErMKIagAA4DeY1AsArBVInBqAhb58MsooZ5yePNUh8tGqgzJ6wU7ekwy+/v2ofL7+sLG+8qX29BFsQaAaAAD4DeIlAGDxcZecSwAspNJ7XOsC2dTVB0kD4mLXiQsycN4WY333qM4cu2EbUn8AAAC/EUjABAAsxQVCAFaavTZWj5zOidqv6vVtU0P8NZiv/v+HzsVL+RKFZNziP4x9q166VQqHBNnaPvg3RlQDAOABAgMDpX79+npRZZiEiAkAWIvjrltNmjRJIiIipHDhwtKqVStZv359tnV37Ngh3bp10/XVyPaJEydmqjN8+HC9z3WpW7duujpXrlyR/v37S5kyZaRYsWL6OU+dOuXe/xjgJir46s56vkalPak7ZKGM+mGXzFp7KF2QekbvG6VamTBb2wfwTRgAAA8QHBwsDzzwgF5UGeZgQDUAWIs4tfvMmzdPBg0aJMOGDZNNmzZJ48aNpVOnTnL69Oks68fHx0uNGjVkzJgxUrFixWyf94YbbpATJ04Yy88//5xu/8CBA+W7776Tr776SlauXCnHjx+X++67z43/M8B9qofnLtC6cs8Z+Ssxxe+C1CpHd3YjztcdOGt1k4BMCFQDAAC/QcAEACw+7nKF0G3Gjx8v0dHR0qdPH30H1pQpUyQsLEymT5+eZf0bb7xR3nnnHXn44YelUKFC2T6vukCuAtnOpWzZssa+uLg4mTZtmn7tf/zjH9K8eXOZMWOGrFmzRtatW+e+/xzgJj2jInI1iasaUV1v6CL5x7sr5Hx8ol+k+1C5uXNC7m54AgLVAADAbxAwAQCLj7t0uFskJibKxo0bpUOHDsY2lSpMra9du7ZAz713716pXLmyHn3do0cPOXz4sLFPvWZSUlK611WpQapVq5bt6yYkJMiFCxfSLYBVQoMDJbpNZI51CgWnhcIOnLksTUYulYbDFsux83+Jr8pL7m7ATgSqAQDwkC+gI0aM0Isq+yL1xbVJkyY6WLx582Zb2kDABAAsPu5y4HWLs2fPSkpKilSoUCHddrV+8uTJfD+vynM9c+ZMWbRokUyePFkOHjwobdq0kYsXL+r96rlDQ0OlVKlSuX7d0aNHS8mSJY2latWq+W4fkB8xXevLk20jM42sVutq+543usiWoR2lbsXixr6LCcly85gfJeLVH+SPU1c//75i0fYTOid1bvhr7m54DpJgAgAAS7z88st6xNaWLVts63ECJgBgneQLZ+TsuR3y00+pEhUVpScAhGfp0qWLUW7UqJEOXFevXl2+/PJL6du3b76eMyYmRufSdlIjqglWw45g9eCOdfUIYRV8VbmrVVoQNeJaKRkWIoteaCtXklKk3+yNsuqPM8ZjO05YpX/++6koaRER7pVv3vZjcdJv1m9yPO6KKTm+AbMQqAYAAKZbuHChLFmyRP7zn//osl0CGFMNAKZLvnBWzi2ZJH/t/02OiUP+MVX0iNyXXnpJXn31VZ2yAnmj8kYHBQXJqVOn0m1X6zlNlJhX6n2qXbu27Nu3T6+r51Z3ep0/fz7dqOqcXlflw84pJzZgFRWU7tumRo51CocEyazHW0pySqq88p9t8p9NR41990+5mt5maq8Wcnv99HczeKLTF6/I4C+3yOq9+ZsUUY04V8F8wE78hQAAAEylvsyqyZ9mz56tJ32yEyOqAcBcKZf/JydnD5a/DmwUkbSEqCrQ+c9//lOee+453oJ8UOk31ESGy5cvN7alpqbqdTVa3V0uXbok+/fvl0qVKul19ZohISHpXnfPnj06j7U7XxewW3BQoLz7YGM5OLqrPNO+Zrp90bN+0ylBvliflr/dU6gR4SO+26Hb1/LN5ZmC1LUrFJNlg9pJ7Jg7dNqTnKjc3s4R54BdGFENAABM43A4pHfv3vLUU09JixYtJDY2Ntf5rNXixERMAOAdLvw6XwerxZGa5f5JkyZJ//79pV69epa3zdupdBqPPfaYPp+2bNlSJk6cKJcvX5Y+ffro/b169ZIqVaroHNGKGgm9c+dOo3zs2DE9R0SxYsXk+uuv19tffPFFufPOO3W6j+PHj8uwYcP0yO3u3bvr/SrHtEoBol47PDxcSpQoIc8++6wOUt9000229QVgFjWXysud6+plxi8HZcR3V3+HlFfnb9PL4Ntry4B/XG/bJN3q7+s5vx6W17/ZnuX+oMAAmd77RmlXu1ymdCjK1NUH002sqEZSqyC1cz9gJwLVAAAgz9St22+//XaOdXbt2qXTfagJmVS+yrxQX7LVxJLuxohqADA3eHJx6+Jsg9RKcHCwzJgxQ8aOHctbkUcPPfSQnDlzRoYOHaonMlQTFKtJEJ0TLKpRzq5pVVTguWnTpsb6uHHj9NKuXTtZsWKF3nb06FEdlP7zzz+lXLlycsstt8i6det02WnChAn6ebt166YvInfq1En+9a9/8f7B5/W5OVIv/91yXJ77/Hdj+7tL/9BLz5uqy4i7bpDAjLM2mmTNvrPSe+YGSUzO+hg7/M768ljriBwD6NfK3Q3YLcCh/ppAgahRXupKc1xcnL7CnF/qVg0AgLXUbXCecA5QI52cI6BUUFfd4uvJ1Bdl9aU2JzVq1JAHH3xQvvvuu3R/MKekpOjRWj169JBPP/001yOq1URMBe7n5FSp/bp9ObIBwBsEBwZIcFCAhAQFSmhQoFG+ulwtq9vkQzOUHUkJMj26TY7PrQKe6tzw+eef23K+hfV47+Arftl3Vnp88mum7R3rV5APH2lmSrA39uxleWbOJtl54kKW+x+9qZr8s2t9KRIa5PbXBuw4DzCi2hOoawUX90mdwrFyOKGi/OVgNmwAMFtq0hVJPn9S51msVauW7RM7qddX7XCWPZ0aaeU62io777//vrzxxhvpRnepkVjz5s2TVq1aZfs4UyZiSk2SgAt7pFahQxKbWFmSHCHufX4AcKGuz+nAbmCAhAQHSnDg1WBucLpg798B4MBACQkO0HWcwWCjXrp96QPDV+v8Xd9lv/O5swsypw84X61ntCcwMN+jA1XO5M+fKyJ//fVXtnXUOa58+fJ8VgB4nZuvL6sHuWw/Fif/98HPxvYlO0/pgRBNqpaSz55oJcUKFSzUduFKkrz+9XY9kjsrUTXKyISHmkjFksSO4Hu8ZkT1m2++KT/88IPOqaVGmanJODJStzo9/fTT8tNPP+m8Wyp/lxqdpm4vy865c+d0ji012st5O9N7772nH2/JFeIDM0W2vyFyab9e/Ss1VL46d7u8c7KXXEwtmrfnAgBcU2pCvJxfPVsubVkijuSrI3YjIyPltdde0zkY85prjlFCeaNyVKv+/v333/Uty5b0c2qyyM4xInveE0m4OsHMueTiMuPsXfKv0w9KijACBfAkKremGtHrDJw6A7DOIKr6GeTcpkf+pg/Uqp+uQVq9/+96rs+RMcCr9//9umlB5LTnC8lq/9/7Mj9voP5/+CM1J8G0adMkOTk52zobNmzQeZbzgvOt9+K9g6869Odlue3dlZLsmvBZRKqUKiLfDrhZyhYrlO6uvpzSbSSnpMqkn/bLhGV/ZPla5YsXkqm9WkjjqqVM/B8B5vDJEdXqlugHHnhAT9qg/vDJSN1GfMcdd0jFihVlzZo1cuLECT2ZhJqh+K233sr2edVtx6ru0qVLJSkpSU9E0a9fP5k7d67J/yMR2TZKZNtQdb3A2FQkMFEeKbNQWhbdLt32vyOXU8PMbwcA+InUxCty8vMYSTp9MF3+TBU8jY6OlkOHDsmoUaNsbSPcTL3Pv3QXOfIftWJsDg++KAMrzJUbCh+Qpw/HiEM8fxQ7kG16hsBACXIGVF1SNrgGfFVZBV2v/rxazwj2/r3ufKwzMGsEgf+um26b87kCswgGuzxPxgBwxufNGDxW++yanAru8corr+i7ZtT8BOo7mis1MOjee+/Nc5AaADxR9TJFZd9bXeXMxQS5+8Of5XjcFb392Pm/pMUby/Q5bfngdjL310OZJjB8c8EuPYFhw+tKyYC5afmvM/qge1O5s3FlK/47gEfwmhHVTjNnzpQXXngh04jqhQsXyv/93//pW4qdk0lMmTJF/6Gk8mhmletTTfJUv379dFf01WQUXbt21ZNKVK5c2bwrxJcOiPxXzbScdfenOALlvVPd5f3TV2dbBgAUXNy6r+T8qllXUy5lQ50b6tatm+vnZJSQNfLdz0f/K7Lq7hyr9Iv9pyy5EFXwRsJ2V4OvAWk/XYK1zgBtuv3Gz7+3/x0o1UFZ9dO5HvD3PiOg6xzVG5ApiOt8XmfdjK/rGsh1vrbrY7Oq6wwIO9vj3EZAF55q27ZtekCQ+umk7nJVdy6pu1fzk9qJ86334r2Dv7iUkCyPfvKrbD6SOQNAXrzQoZYMuPV6/XcA4At8ckT1taxdu1YaNmxoBKkVlQNTpQLZsWNHutmOXR9TqlSpdFf0O3TooK/0//rrr/pqv2n2TxMJCBRxpB9l4BQUkCo9y/wg759+ON2IawBA/l38fUGOQWr1JfqTTz6RcePG2XLnkPN1X3zxRY+fTNFr7PtIJCAo2/NtsiNQepRZ4LWBapVZQAUs9RLw90/XQGvG5e86KjAaqIKvgQE6F61rXdfgreu+jM/nDOiq71Cur5f5ua7uy/m5AjO1K6vAsWtwN6uAM4FbwDOo72VbtmyR9evX65+FCxeWzp07k5sagE9Tuam/6X+zJCSnyLNzf9e5q3Pr/xpVkjfvbSglizCHCvybzwSqT548mS5IrTjX1b7sHpNxIg8VpAgPD8/2MUpCQoJeXK8M5NnFfTkGS5RyIeelUECSJDgIVgBAQTkcqZJy4UyOdVQ+zX379tnW2SoFFdzswu5sg9RKcECqNCx+Sh5pVS1DoPdqwNQZhL26T922/ndwN0NdtT/QZeStc79r0NW5P+1xKtCcFnTNHATOEGAOcgk0E5gF4OHUhSM1aW5OE+cCgC8qFBwkH/dqIZ+sOiBvLNh1zfpD7qgnfdvUsKRtgKezNVD96quvyttvv51jnbzegm0FNUHjiBEjCvYkoaX+HlGdliM1k8BQ2fPW3VfrAQAKrNikonL58uVs96uLleqWJPiQ0HA1c3GOVcJLlZe3uja0rEkAAADwfYf/F5+remqCRQBX2RoBHTx4sA5E57TUqJG7q0pqEsVTp9LfVuFcV/uye8zp06czjaY7d+5cto9RYmJidF4V53LkyBHJs2oPiTiynwlbAoJFqj9MkBoA3Kh79+46GJ0ddQ5QdeBDInpcI4VWoEjkoxY2CAAAAP6geniYW+sB/sDWQHW5cuX0aOmcltzm6IyKitKTdbgGnpcuXaqTdKsJE7N7jJqUcePGjca2H3/8UVJTU3O8RU1N/qGe13XJswq3ipRrczVvZkZqBHVgsEi9l/P+vACAbL300kv6vBIUlPnYq7apY3/Hjh3pQV9So49IWJVszrfBIkUqidR83I6WAQAAwIf1jIrQ84nkRO1X9QBc5TU5JQ4fPiybN2/WP1NSUnRZLZcuXdL7VWBBBaR79uypJ+xYvHixvP7669K/f39jVmk1mYcKfh87dkyv16tXT0/qER0drff98ssvMmDAAHn44YelcuXK5v6HAgJE2n0nUvHvgIj6Ah3wd9L8QuVEbl0sUuoGc9sAAH6mdu3asmzZMmN+AjW62hm0vvXWW2XBggV6Ql34kNCSIh1WipSolxacVotSos7VfaGlbW0iAAAAfE9ocKBEt4nMsY7ar+oB8LLJFIcOHSqffvqpsd60aVP986effpL27dvrQMP3338vTz/9tB4pXbRoUXnsscdk5MiRxmPi4+Nlz5496SarmjNnjg5O33bbbTo40a1bN3n//fet+/J86wKR89tEjn0vknJFpHRjkSp3igQy0ysAmEGdI9RFzx9++EE2bdqkL2becccd0rhxYzrcVxWrIdJ1q8jpVSKnV6qpNUXKt7u6qAvHAAAAgAliul69w3/q6oOS6kg/kloFqZ37AVwV4HA4XH5VkB8XLlzQk2+pfNX5SgMCABB/Pweoi6jq4qnSo0cPCQnhgqUZ/QwA8E6cB7wX7x0gkpicKrPXxuqJE1VOapXug5HU8BcX8vBdzmtGVAMA4MtUYLp37952NwMAAACAm6mgdN82NehX4BpIhAMAAAAAAAAAsBWBagAAAAAAAACArUj9AQCAB0hMTJT33ntPl59//nkJDQ21u0kAAAAAAFiGQDUAAB4iPj7e7iYAAAAAAGALUn8AAAAAAAAAAGxFoBoAAAAAAAAAYCsC1QAAAAAAAAAAWxGoBgAAAAAAAADYikA1AAAAAAAAAMBWwfa+PAAAUAICAqRy5cpGGQAAAAAAf0KgGgAADxASEiLR0dF2NwMAAAAAAFsQqHYDh8Ohf164cMEdTwcA8CLOY7/zXABzcK4FAP/G+dZ7cQ4HAP92IQ/fmQlUu8HFixf1z6pVq7rj6QAAXnouKFmypN3N8FmcawEAzvMB51vvwjkcAJDbc3iAgyFgBZaamirHjx+X4sWL5zuvqLq6oALdR44ckRIlSoino730r7d+HryprQrt9fz+VadRdcJV+aUDA/M/R3FSUpJMmjRJl/v3769TgcC951qzeNvvqaeg3+gzPmuezdN+R911voX1OIf7Hk87PngL+o0+89fPmiMP53BGVLuB6uTrrrvOHU+lP0Ce8CHKLdpL/3rr58Gb2qrQXs/uX3eM7FIn77i4OKMM8861ZvG231NPQb/RZ3zWPJsn/Y4ykto7cQ73XZ50fPAm9Bt95o+ftZK5/M7MpWgAAAAAAAAAgK0IVAMAAAAAAAAAbEWg2kMUKlRIhg0bpn96A9pL/3rr58Gb2qrQXvoXns/bfk89Bf1Gn/FZ82z8jsIf8Dmn3/i8eTZ+R/2v35hMEQAAD5CYmCijR4/W5ZiYGAkNDbW7SQAAAAAAWIYR1QAAAAAAAAAAWwXb+/IAAEAJCAiQcuXKGWUAAAAAAPwJqT8AAAAAAAAAALYi9YdF3nzzTWndurWEhYVJqVKlsqxz+PBhueOOO3Sd8uXLy0svvSTJyck5Pu+5c+ekR48eUqJECf28ffv2lUuXLrm9/StWrNAj/LJaNmzYkO3j2rdvn6n+U089JVaIiIjI9NpjxozJ8TFXrlyR/v37S5kyZaRYsWLSrVs3OXXqlKntjI2N1e9bZGSkFClSRGrWrKmT3qt8tTmxsm8nTZqk+7Nw4cLSqlUrWb9+fY71v/rqK6lbt66u37BhQ1mwYIFYQeX3vfHGG6V48eL6d+iee+6RPXv25PiYmTNnZupH1W4rDB8+PNNrq37zxL7N7ndKLep3xhP6dtWqVXLnnXdK5cqV9Wt988036fY7HA4ZOnSoVKpUSf+udejQQfbu3ev2zz+gJCQkSJMmTfRncfPmzXSKCedBf8TxyPy/C5Ce+ttZHcdeeOEFugZ+g3N47nEOzz3O4XnDOdx/z+MEqi2ivmw98MAD8vTTT2e5PyUlRQepVb01a9bIp59+qoM8KqiSExWk3rFjhyxdulS+//57Hajp16+f29uvguwnTpxItzzxxBP6S2WLFi1yfGx0dHS6x40dO1asMnLkyHSv/eyzz+ZYf+DAgfLdd9/pYODKlSvl+PHjct9995naxt27d0tqaqp89NFH+r2cMGGCTJkyRV577bVrPtaKvp03b54MGjRIBw02bdokjRs3lk6dOsnp06ezrK8+v927d9dBh99//11/KVTL9u3bxWzqPVNB03Xr1unfiaSkJOnYsaNcvnw5x8epCz2u/Xjo0CGxyg033JDutX/++eds69rZt4q6KOXaVtXHijq2eULfqvdZfT7VH4FZUb8f77//vv79+vXXX6Vo0aL6s6wuULnr8w84vfzyy/qiCcw9D/oTjkfW/V2AtPO++r1s1KgRXQK/wjk89ziH5w7n8LzjHO7H53EHLDVjxgxHyZIlM21fsGCBIzAw0HHy5Elj2+TJkx0lSpRwJCQkZPlcO3fudKi3cMOGDca2hQsXOgICAhzHjh1zmCkxMdFRrlw5x8iRI3Os165dO8fzzz/vsEP16tUdEyZMyHX98+fPO0JCQhxfffWVsW3Xrl26j9euXeuw0tixYx2RkZEe0bctW7Z09O/f31hPSUlxVK5c2TF69Ogs6z/44IOOO+64I922Vq1aOZ588kmH1U6fPq3fv5UrV+b5d9IKw4YNczRu3DjX9T2pbxX1+atZs6YjNTXV4/pWve9ff/21sa7aWLFiRcc777yT7ne+UKFCjs8//9xtn/+CHlcnTZqkF1WG91Ln9Lp16zp27NihP4u///673U3yOrk5D/obK49Hvio3fxfgqosXLzpq1arlWLp0qa1/zwNW4xxecJzDM+McXnCcw/3nPM6Iag+xdu1afRt/hQoVjG1q1N6FCxf06KLsHqPSfbiOaFa3sgcGBurRgmb673//K3/++af06dPnmnXnzJkjZcuWlQYNGkhMTIzEx8eLlbc5qDQeTZs2lXfeeSfHVCobN27UI21UHzqpFAvVqlXTfW2luLg4CQ8Pt71v1Qh/1S+ufaI+X2o9uz5R213rOz/LVvehsx+Va/WlSpdTvXp1qVq1qtx9993Z/s6ZQaWeUKMua9Sooe+QUCmAsuNJfas+G5999pk8/vjjOU78Z2ffujp48KCcPHkyXf+VLFlSp/LIrv/y8/kvCBVfP3PmjF6uxtrhjVS6KHW3y+zZs3UqL5h7HvQXVh+PfFVu/y6A6JHo6m7PjH93AL6Mc7h7cA5Pj3O4+z5XCudw3z+PB9vdAFylAiiuQWrFua72ZUVtV/n2XAUHB+tf3Owe4y7Tpk3TAbLrrrsux3qPPPKIDlKpQNzWrVvllVde0bkB58+fL2Z77rnnpFmzZro/VMoEFchVqQfGjx+fZX3VZ6GhoZlyiKv3wez+dLVv3z754IMPZNy4cbb37dmzZ3Vamqw+m+o2r7x8lq3sQ0XdRq7yMN188806kJ+dOnXqyPTp0/XtMOrkp/pdpbpRAdVrfb4LSgVJVYof1Qb12RwxYoS0adNGp/JQ+TQ9tW8Vlf/5/Pnz0rt3b4/s24ycfZSX/svP5x/+TV1gUL8Tar4AdRFZ5W2EeedBf8LxyLq/CyDyxRdf6HRXOc1DA/gazuHuwTk8M87hBcc53L/O44yoLoBXX3012wkGnYunBzPy8384evSoLF68WOfJvRaVL1sFtNVocTVadNasWfL111/L/v37TW+vyiurJhxUQTIVNHj33Xf1F181OYan9u2xY8ekc+fOOuevGpFnZd/64hVEFfBVB+mcREVFSa9evfSkZ+3atdOB/nLlyulcTmbr0qWLfq/VZ1S9l2piRBX8/fLLL8XTqYtVqv055eC1s28BO47n6hxz8eJFfWEU5p8HATP+LvB3R44ckeeff17ftWfV5NKAmTiHm9tvrjiHwyycw/3rPM6I6gIYPHhwjqMJFXU7f25UrFhR1q9fn+nWI+e+7B6TcUIvldri3Llz2T7GHf+HGTNm6HQad911l+RnBKnzSmvNmjUt7XP12qp/1Ag3NdIzI9Vn6rYcFSh0HVWt3ofc9mdB2qombrz11lv1iNOPP/7Y8r7NikorEhQUZHwWc9Mnante6pthwIABxuSieR25GxISolPFqH60mvrc1a5dO9vX9oS+VdSEiMuWLcvz6H07+9bZR6q/KlWqZGxX6yqQ7q7PP3xTbo/nP/74o07DUKhQoXT71OhqdUFRTZTsT6w+D/oyjkf2/V3gb1SKGfX9Qt2V6KTuLlJ99+GHH+oBH+rcCHgLzuHm9psT5/DscQ4vGM7h/nceJ1BdAGpkoFrcQY08fPPNN/UHypnOQ81OXqJECalfv362j1FBVfVBbN68ud6mviSr2yKcQUt3/x/ULVEqUK1GSaqgU15t3rxZ/3QNFFnV5+q1VT7HjOlSnFQfqv/T8uXLpVu3bnqbSqWhcgarvjazrerqs/pyrtqg+le10+q+zYpKhaLapPrknnvu0dvU50utqxNGVlRfqf3q9lon9VnOTx/mlfp8Pvvss3pk+YoVKyQyMjLPz6EO4tu2bZOuXbuK1VQ+ZzUivmfPnh7Xt67UZ1T9HqmcV97St+qzoILLqv+cgWk1B4DK5//000+77fMP35Tb4/n7778vb7zxRrovbepuCTXTe27Py77E6vOgL+N4ZN/fBf7mtttu0+dqV2pOGjVvi0oz5+lfboGMOIfnD+dw9+Ecnj+cw/34PG73bI7+4tChQ47ff//dMWLECEexYsV0WS1qJk4lOTnZ0aBBA0fHjh0dmzdvdixatMhRrlw5R0xMjPEcv/76q6NOnTqOo0ePGts6d+7saNq0qd73888/61k9u3fvbtr/Y9myZXq29F27dmXap9ql2qfaouzbt88xcuRIx2+//eY4ePCg49tvv3XUqFHD0bZtW4fZ1qxZ45gwYYLuy/379zs+++wz3Z+9evXKtr3KU0895ahWrZrjxx9/1O2OiorSi5lUO66//nrHbbfdpssnTpwwFk/o2y+++MJRqFAhx8yZMx07d+509OvXz1GqVCnHyZMn9f6ePXs6Xn31VaP+L7/84ggODnaMGzdOf06GDRvmCAkJcWzbts1htqefftpRsmRJx4oVK9L1Y3x8vFEnY3vV7+TixYv152Tjxo2Ohx9+2FG4cGHHjh07TG/v4MGDdVvVe6j6rUOHDo6yZcvqGY09rW+dUlJS9O/IK6+8kmmf3X2rjqfOY6s6To0fP16X1fFXGTNmjP7sqt+XrVu3Ou6++25HZGSk46+//jKe4x//+Ifjgw8+yPXn350SEhIcw4cP14sqw/up3231WVSfQxTsPAhrj0e+Ijd/F+Da2rVr53j++efpKvgVzuG5wzk8dziH5x3ncP89jxOotshjjz2mv6xmXH766SejTmxsrKNLly6OIkWK6GCVCmIlJSUZ+1Vd9Rh10nT6888/dWBaBb9LlCjh6NOnjxH8NoN6rdatW+d4Mnf+nw4fPqwDp+Hh4fqLlfoS+tJLLzni4uIcZlNBsVatWukvJyowVq9ePcdbb73luHLlSrbtVVTA6plnnnGULl3aERYW5rj33ntN/6I8Y8aMLD8brteR7O5bFbhTwcnQ0FBHy5YtHevWrUt30FOfb1dffvmlo3bt2rr+DTfc4Pjhhx8cVsiuH1UfZ9feF154wfi/VahQwdG1a1fHpk2bLGnvQw895KhUqZJ+7SpVquh1dREiu7ba2bdOKvCs+nTPnj2Z9tndt85jZMbF2abU1FTHkCFDdFvU740KimX8f1SvXl1fAMjt59+dEhMT9QU2tagyvB9fct13HoS1xyNfkZu/C+B7X3ABd+Acnjucw3OPc3jecA733/N4gPrH7lHdAAAAAAAAAAD/RQJAAAAAAAAAAICtCFQDAAAAAAAAAGwVbO/LAwAAJSkpSWbOnKnLvXv3lpCQEDoGAAAAAOA3CFQDAOAB1JQRx48fN8oAAAAAAPgTUn8AAAAAAAAAAGxFoBoAAAAAAAAAYCsC1QAAAAAAAAAAWxGoBgAAAAAAAADYikA1AAAAAAAAAMBWBKoB5JnD4ZAOHTpIp06dMu3717/+JaVKlZKjR4/Ss0AehYWF6QUAON8CAOC9+M4M5E+AQ/32AEAeHTlyRBo2bChvv/22PPnkk3rbwYMH9bbJkydLz5496VMAAAqI8y0AAN6JcziQdwSqAeTbp59+KgMGDJCtW7dKRESE3HbbbXo09fz58+lVAADchPMtAADeiXM4kDcEqgEUyD333CNxcXFy3333yahRo2THjh1Srlw5ehUAADfifAsAgHfiHA7kHoFqAAVy+vRpueGGG+TcuXPyn//8R5+EAeRdUlKSzJkzR5d79OghISEhdCMAzrcAAHg5vjMDucdkigAKpHz58jpHdb169QhSAwWgpow4dOiQXpg+AgDnWwAAfAPfmYHcI1ANoMCCg4P1AgAAzMP5FgAA78Q5HMgdAtUAAAAAAAAAAFsRqAYAAAAAAAAA2IpANQAAAAAAAADAVgEOZmwCAMB2iYmJMnr0aF2OiYmR0NBQu5sEAAAAAIBlmP0MAAAPERISYncTAAAAAACwBSOqAQAAAAAAAAC2Ikc1AAAAAAAAAMBWBKoBAAAAAAAAALYiRzUAAB4gOTlZvvzyS11+8MEHJTiYUzQAAAAAwH/wLRgAAA+Qmpoqe/fuNcoAAAAAAPgTUn8AAAAAAAAAAGxFoBoAAAAAAAAAYCsC1QAAAAAAAAAAWxGoBgAAAAAAAADYikA1AAAAAAAAAMBWBKoBAAAAAAAAALYKcDgcDnubAAAAAAAAAADwZ4yoBgAAAAAAAADYikA1AAAAAAAAAMBWBKoBAAAAAAAAALYiUA0AAAAAAAAAsBWBagAAAAAAAACArQhUAwAAAAAAAABsRaAaAAAAAAAAAGArAtUAAAAAAAAAAFsRqAYAAAAAAAAAiJ3+H3Vrs+j3894VAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -433,71 +446,140 @@ "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", + "figheight = figwidth\n", + "fig, axs = plt.subplots(\n", + " 3, 3, figsize=[figwidth, figheight], layout=\"constrained\",\n", + ")\n", + "fig.set_constrained_layout_pads(w_pad=0.2, h_pad=0.1)\n", "\n", - "axs[0].set_title(\"Drive Space\")\n", - "axs[1].set_title(\"Motion Space\")\n", - "axs[2].set_title(\"Drive Space Return\")\n", + "axs[0, 0].set_title(\"Drive Space\")\n", + "axs[0, 1].set_title(\"Motion Space\")\n", + "axs[0, 2].set_title(\"Motion Space\")\n", "\n", + "mkp = tr(key_points, to_coords=\"motion_space\")\n", + " \n", "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", + " if ii == 0: # xy-plane\n", + " p0 = 0\n", + " p1 = [1, 1, 2]\n", + " \n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Y\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Z\")\n", + " elif ii == 1: # xz-plane\n", + " p0 = 0\n", + " p1 = [2, 2, 1]\n", "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(mpoints[...,0], mpoints[...,1])\n", - "axs[2].fill(dpoints[...,0], dpoints[...,1])\n", + " axs[ii, 0].set_xlabel(\"X\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " mpt = tr(pt, to_coords=\"motion_space\")\n", - " dpt = tr(mpt, to_coords=\"drive\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)\n", - " axs[2].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)" + " axs[ii, 1].set_xlabel(\"X\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"X\")\n", + " axs[ii, 2].set_ylabel(\"Y\")\n", + " else: # yz-plane\n", + " p0 = 1\n", + " p1 = [2, 2, 0]\n", + " \n", + " axs[ii, 0].set_xlabel(\"Y\")\n", + " axs[ii, 0].set_ylabel(\"Z\")\n", + "\n", + " axs[ii, 1].set_xlabel(\"Y\")\n", + " axs[ii, 1].set_ylabel(\"Z\")\n", + " \n", + " axs[ii, 2].set_xlabel(\"Y\")\n", + " axs[ii, 2].set_ylabel(\"X\")\n", + " \n", + " i_start = ii * npoints_in_plane\n", + " i_stop = i_start + npoints_in_plane\n", + " \n", + " axs[ii, 0].fill(points[i_start:i_stop, p0], points[i_start:i_stop, p1[0]])\n", + " axs[ii, 1].fill(mpoints[i_start:i_stop, p0], mpoints[i_start:i_stop, p1[1]])\n", + " axs[ii, 2].plot(mpoints[i_start:i_stop, p0], mpoints[i_start:i_stop, p1[2]], \"-o\")\n", + "\n", + " i_start = ii * 4\n", + " i_stop = i_start + 4\n", + " colors = [\"red\", \"orange\", \"black\", \"purple\"]\n", + "\n", + " axs[ii, 0].scatter(key_points[i_start:i_stop, p0], key_points[i_start:i_stop, p1[0]], c=colors)\n", + " axs[ii, 1].scatter(mkp[i_start:i_stop, p0], mkp[i_start:i_stop, p1[1]], c=colors)\n", + " axs[ii, 2].scatter(mkp[i_start:i_stop, p0], mkp[i_start:i_stop, p1[2]], c=colors, zorder=10)\n", + "\n", + "# Get the bounding boxes of the axes including text decorations\n", + "r = fig.canvas.get_renderer()\n", + "get_bbox = lambda ax: ax.get_tightbbox(r).transformed(fig.transFigure.inverted())\n", + "bboxes = np.array(list(map(get_bbox, axs.flat)), mtrans.Bbox).reshape((*axs.shape, 2, 2))\n", + "\n", + "# Draw vertical divider between the different space plots\n", + "x = bboxes[:, 0, 1, 0].mean() - 1.15 * (0.2 / figwidth)\n", + "line = plt.Line2D([x, x], [0,1], transform=fig.transFigure, color=\"gray\", linestyle=\"--\")\n", + "fig.add_artist(line);" ] }, { "cell_type": "markdown", - "id": "4b0115f5-6e20-41d8-ae82-72452a1a831d", + "id": "f3bfadce-0ec8-411f-bd49-0371d8b3f599", "metadata": {}, "source": [ - "Are the returned drive space points \"identical\" to the starting points?" + "How close are the points after the round trip conversion? Let's plot the difference." ] }, { "cell_type": "code", "execution_count": 14, - "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", + "id": "7733412e", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "True" + "
" ] }, - "execution_count": 14, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "np.allclose(points, dpoints)" + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figwidth = 1.4 * figwidth\n", + "fig, ax = plt.subplots(1, 1, figsize=[figwidth, figheight])\n", + "\n", + "ax.plot(points[..., 0] - dpoints[..., 0], \"-o\", label=\"X\")\n", + "ax.plot(points[..., 1] - dpoints[..., 1], \"-o\", label=\"Y\")\n", + "ax.plot(points[..., 2] - dpoints[..., 2], \"-o\", label=\"Z\")\n", + "\n", + "ax.set_xlabel(\"Index\")\n", + "ax.set_ylabel(\"Diff\")\n", + "ax.set_title(\"Difference in Drive --> Motion --> Drive Conversion\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "4b0115f5-6e20-41d8-ae82-72452a1a831d", + "metadata": {}, + "source": [ + "Here we can see the points are virtually identical, with a difference on the order of $10^{-14}$." ] }, { "cell_type": "code", "execution_count": 15, - "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", + "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "np.float64(1.5987211554602254e-14)" + "True" ] }, "execution_count": 15, @@ -506,175 +588,38 @@ } ], "source": [ - "np.max(np.abs(points - dpoints))" - ] - }, - { - "cell_type": "markdown", - "id": "a6ac8c55-eca5-44f7-9579-e7b61bdab6f0", - "metadata": {}, - "source": [ - "## Transform Can Droop Correct\n", - "\n", - "The transform `LaPD6KTransfrom` also incorporates droop correction via the `LaPDXYDroopCorrect` class.\n", - "\n", - "Instantiate the transfrom with droop correction enabled." + "np.allclose(points, dpoints)" ] }, { "cell_type": "code", "execution_count": 16, - "id": "1e2e4537-cb72-4d9a-b457-6f3160771261", + "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'LaPD6KTransform' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m tr = LaPD6KTransform(\n\u001b[32m 2\u001b[39m (\u001b[33m\"x\"\u001b[39m, \u001b[33m\"y\"\u001b[39m),\n\u001b[32m 3\u001b[39m **{\n\u001b[32m 4\u001b[39m **input_kwargs,\n", - "\u001b[31mNameError\u001b[39m: name 'LaPD6KTransform' is not defined" - ] + "data": { + "text/plain": [ + "np.float64(1.5987211554602254e-14)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "tr = LaPD6KTransform(\n", - " (\"x\", \"y\"),\n", - " **{\n", - " **input_kwargs,\n", - " \"droop_correct\": True,\n", - " \"droop_scale\": 2.0,\n", - " },\n", - ")\n", - "tr.config" - ] - }, - { - "cell_type": "markdown", - "id": "ac8d5ed5-c6e1-4632-9806-63d51d57fc63", - "metadata": {}, - "source": [ - "Construct a set of points for the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a4a8740-5b79-45cc-b67f-311d72caeb66", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "key_points = np.array(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "3dc12ae7-0ef0-4eba-a652-e4980d76a61a", - "metadata": {}, - "source": [ - "Calcualte the drive space points `dpoints` and return to motion space points`mpoints`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b9dc74c-298b-46db-b06b-8fe81d29b936", - "metadata": {}, - "outputs": [], - "source": [ - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")" + "np.max(np.abs(points - dpoints))" ] }, { "cell_type": "markdown", - "id": "25f03021-a4f1-493c-b5f9-39b675857c49", - "metadata": {}, - "source": [ - "Plot the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0aafc667-d47e-4a3f-8f18-646b599bfc53", + "id": "a6ac8c55-eca5-44f7-9579-e7b61bdab6f0", "metadata": {}, - "outputs": [], "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0].set_title(\"Motion Space\")\n", - "axs[1].set_title(\"Drive Space\")\n", - "axs[2].set_title(\"Motion Space Return\")\n", - "\n", - "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", - "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", - "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", + "## Transform Can Droop Correct\n", "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " dpt = tr(pt, to_coords=\"drive\")\n", - " mpt = tr(dpt, to_coords=\"motion_space\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" - ] - }, - { - "cell_type": "markdown", - "id": "c7293afa-e931-499d-84ad-f7f3f7c696e4", - "metadata": {}, - "source": [ - "Are the returned motion space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8dac0d50-a14d-4319-8630-fa9c1a750f09", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, mpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4995cb9b-7c5e-4660-95c1-e1fbe2b73283", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - mpoints))" + "**Currently droop correction is NOT integrated but it will be.**" ] }, { @@ -684,129 +629,7 @@ "source": [ "## Configure for West Side Deployment\n", "\n", - "The default values for `LaPD6KTransform` is for an East side depolyment on the LaPD. However, the transfrom can be configured for a West side deployment by using a negative `pivot_to_center` and `[1, 1]` for the `mspace_polarity`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82aa413b-6546-4cbc-9115-125ffcc107ee", - "metadata": {}, - "outputs": [], - "source": [ - "tr = LaPD6KTransform(\n", - " (\"x\", \"y\"),\n", - " **{\n", - " **input_kwargs,\n", - " \"pivot_to_center\": -58.771,\n", - " \"mspace_polarity\": [1, 1],\n", - " \"droop_correct\": True,\n", - " \"droop_scale\": 2.0,\n", - " },\n", - ")\n", - "tr.config" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5853946-24e3-4286-aae6-aa48a59af280", - "metadata": {}, - "outputs": [], - "source": [ - "points = np.zeros((40, 2))\n", - "points[0:10, 0] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "points[0:10, 1] = 5 * np.ones(10)\n", - "points[10:20, 0] = 5 * np.ones(10)\n", - "points[10:20, 1] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 0] = np.linspace(5, -5, num=10, endpoint=False)\n", - "points[20:30, 1] = -5 * np.ones(10)\n", - "points[30:40, 0] = -5 * np.ones(10)\n", - "points[30:40, 1] = np.linspace(-5, 5, num=10, endpoint=False)\n", - "\n", - "key_points = np.array(\n", - " [\n", - " [-5, 5],\n", - " [-5, -5],\n", - " [5, -5],\n", - " [5, 5],\n", - " [0, 0]\n", - " ],\n", - ")\n", - "\n", - "dpoints = tr(points, to_coords=\"drive\")\n", - "mpoints = tr(dpoints, to_coords=\"motion_space\")" - ] - }, - { - "cell_type": "markdown", - "id": "e0059a4f-f084-4d16-921c-6d2dd79fa3e5", - "metadata": {}, - "source": [ - "Plot the transform." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "024c67c5-b442-40ee-8cd4-3c57a9c9e21a", - "metadata": {}, - "outputs": [], - "source": [ - "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", - "figwidth = 1.4 * figwidth\n", - "figheight = figheight\n", - "fig, axs = plt.subplots(1, 3, figsize=[figwidth, figheight])\n", - "\n", - "axs[0].set_title(\"Motion Space\")\n", - "axs[1].set_title(\"Drive Space\")\n", - "axs[2].set_title(\"Motion Space Return\")\n", - "\n", - "for ii in range(3):\n", - " axs[ii].set_xlabel(\"X\")\n", - " axs[ii].set_ylabel(\"Y\")\n", - "\n", - "axs[0].fill(points[...,0], points[...,1])\n", - "axs[1].fill(dpoints[...,0], dpoints[...,1])\n", - "axs[2].fill(mpoints[...,0], mpoints[...,1])\n", - "\n", - "for pt, color in zip(\n", - " key_points.tolist(),\n", - " [\"red\", \"orange\", \"green\", \"purple\", \"black\"]\n", - "):\n", - " dpt = tr(pt, to_coords=\"drive\")\n", - " mpt = tr(dpt, to_coords=\"motion_space\")\n", - " axs[0].plot(pt[0], pt[1], 'o', color=color)\n", - " axs[1].plot(dpt[..., 0], dpt[..., 1], 'o', color=color)\n", - " axs[2].plot(mpt[..., 0], mpt[..., 1], 'o', color=color)" - ] - }, - { - "cell_type": "markdown", - "id": "4613643d-b83f-4f80-9c58-3053d48b43ad", - "metadata": {}, - "source": [ - "Are the returned motion space points \"identical\" to the starting points?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "62a2a57c-f919-4ae1-8fc3-1923c54d8c49", - "metadata": {}, - "outputs": [], - "source": [ - "np.allclose(points, mpoints)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "627126b3-419e-4a1b-8c28-7a45499709c8", - "metadata": {}, - "outputs": [], - "source": [ - "np.max(np.abs(points - mpoints))" + "**TODO: Fill this section out!!**" ] }, { @@ -818,6 +641,9 @@ "source": [ "## The Algorithms\n", "\n", + "**TODO: Fill this section out!!**\n", + "\n", + "" ] }, { @@ -840,6 +667,9 @@ "source": [ "### Algorithm: Drive to Motion Space\n", "\n", + "**TODO: Fill this section out!!**\n", + "\n", + "" ] }, { @@ -953,6 +713,9 @@ "source": [ "### Algorithm: Motion to Drive Space\n", "\n", + "**TODO: Fill this section out!!**\n", + "\n", + "" ] } ], From 7335e13875f55d8b1b539f674b42fb33a48f104f Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 09:24:11 -0700 Subject: [PATCH 024/177] rough our layout for LaPDXYZTransformCalculator --- bapsf_motion/gui/__init__.py | 4 + .../gui/lapd_xyz_transform_calculator.py | 469 ++++++++++++++++++ 2 files changed, 473 insertions(+) create mode 100644 bapsf_motion/gui/lapd_xyz_transform_calculator.py diff --git a/bapsf_motion/gui/__init__.py b/bapsf_motion/gui/__init__.py index b9e2bf2d..25471b40 100644 --- a/bapsf_motion/gui/__init__.py +++ b/bapsf_motion/gui/__init__.py @@ -20,6 +20,10 @@ LaPDXYTransformCalculator, LaPDXYTransformCalculatorApp ) + from bapsf_motion.gui.lapd_xyz_transform_calculator import ( + LaPDXYZTransformCalculator, + LaPDXYZTransformCalculatorApp, + ) except (ModuleNotFoundError, ImportError) as err: msg = ( f"{err.msg} ... It is likely GUI dependencies were not installed. " diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py new file mode 100644 index 00000000..a532c02f --- /dev/null +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -0,0 +1,469 @@ +__all__ = ["LaPDXYZTransformCalculator", "LaPDXYZTransformCalculatorApp"] + +import ast +import re + +from pathlib import Path +from PySide6.QtCore import Qt, QPoint, Signal, Slot +from PySide6.QtGui import QPixmap +from PySide6.QtWidgets import ( + QApplication, + QMainWindow, + QWidget, + QVBoxLayout, + QHBoxLayout, + QLabel, + QFrame, + QLineEdit, + QRadioButton, +) +from typing import Union, Optional + +from bapsf_motion.gui.widgets import StyleButton + + +_HERE = Path(__file__).parent +_IMAGES_PATH = (_HERE / "_images").resolve() + + +class LaPDXYZTransformCalculator(QMainWindow): + closing = Signal() + + _defaults = { # all values in cm + "measure_1": 54.2, + "measure_2a": 58.0, + } + + def __init__(self): + super().__init__() + + _stylesheet = self.styleSheet() + _stylesheet += """ + QFrame#image_frame { + border: 2px solid rgb(125, 125, 125); + border-radius: 5px; + padding: 0px; + margin: 0px; + background-color: white; + } + + QLineEdit { border: 2px solid black; border-radius: 5px } + QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2a { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2b { border: 2px solid rgb(255, 0, 0) } + + QLineEdit#ball_valve_cap_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_kf40_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_drive_endplate_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#velmex_rail_width { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#fiducial_width { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + """ + self.setStyleSheet(_stylesheet) + + self.setCentralWidget(QWidget(parent=self)) + + self._image_file_path = (_IMAGES_PATH / "LaPDXYZTransform_diagram.png").resolve() + pixmap = QPixmap(f"{self._image_file_path}") + self._image = pixmap + + self._window_margin = 12 + self._define_main_window() + + self.image_label = QLabel(parent=self) + self.image_label.setPixmap(self._image) + + self.image_frame = QFrame(parent=self) + self.image_frame.setObjectName("image_frame") + self.image_frame.setStyleSheet(_stylesheet) + self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) + self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) + + # all values in cm + self.ball_valve_cap_thickness = 0.81 * 2.54 + self.probe_drive_endplate_thickness = 0.75 * 2.54 + self.probe_kf40_thickness = 2.54 + self.velmex_rail_width = 3.4 * 2.54 + self.fiducial_width = 1.775 * 2.54 + + # constants need to be defined first + self.measure_1 = self._defaults["measure_1"] + self.measure_2a = self._defaults["measure_2a"] + self.measure_2b = self.convert_measure_2a_to_measure_2b() + + # mesures and constants need to be defined first + self.pivot_to_center = 58.771 + self.pivot_to_feedthru = self.calc_pivot_to_feedthru() + self.pivot_to_drive = self.calc_pivot_to_drive() + + _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(260, 43) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_center_label = _txt + + _txt = QLineEdit(f"{self.measure_1:.2f} cm", parent=self) + _txt.setReadOnly(False) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(763, 432) + _txt.move(p) + _txt.setFixedWidth(120) + _txt.setObjectName("measure_1") + self.measure_1_label = _txt + + _txt = QLineEdit(f"{self.measure_2a:.2f} cm", parent=self) + _txt.setReadOnly(False) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1228, 447) + _txt.move(p) + _txt.setFixedWidth(120) + _txt.setObjectName("measure_2a") + self.measure_2a_label = _txt + + _txt = QLineEdit(f"{self.measure_2b:.2f} cm", parent=self) + _txt.setReadOnly(False) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1228, 499) + _txt.move(p) + _txt.setFixedWidth(120) + _txt.setObjectName("measure_2b") + self.measure_2b_label = _txt + self.measure_2b_label.setEnabled(False) + + _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(736, 98) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_feedthru_label = _txt + + _txt = QLineEdit(f"{self.pivot_to_drive:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1134, 43) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_drive_label = _txt + + _txt = QLineEdit(f"{self.ball_valve_cap_thickness:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(12) + font.setBold(True) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(691, 181) + _txt.move(p) + _txt.setFixedWidth(86) + _txt.setObjectName("ball_valve_cap_thickness") + self.ball_valve_cap_thickness_label = _txt + + _txt = QLineEdit(f"{self.probe_kf40_thickness:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(12) + font.setBold(True) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1218, 177) + _txt.move(p) + _txt.setFixedWidth(86) + _txt.setObjectName("probe_kf40_thickness") + self.probe_kf40_thickness_label = _txt + + _txt = QLineEdit(f"{self.probe_drive_endplate_thickness:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(12) + font.setBold(True) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1294, 220) + _txt.move(p) + _txt.setFixedWidth(86) + _txt.setObjectName("probe_drive_endplate_thickness") + self.probe_drive_endplate_thickness_label = _txt + + _txt = QLineEdit(f"{self.velmex_rail_width:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(12) + font.setBold(True) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1496, 121) + _txt.move(p) + _txt.setFixedWidth(86) + _txt.setObjectName("velmex_rail_width") + self.velmex_rail_width_label = _txt + + _txt = QLineEdit(f"{self.fiducial_width:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(12) + font.setBold(True) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1774, 512) + _txt.move(p) + _txt.setFixedWidth(86) + _txt.setObjectName("fiducial_width") + self.fiducial_width_label = _txt + + _btn = StyleButton("Reset to Defaults", parent=self) + _btn.setFixedWidth(200) + _btn.setFixedHeight(36) + _btn.setPointSize(14) + p = self.geometry().topLeft() + QPoint(32, 472) + _btn.move(p) + self.reset_btn = _btn + + _btn = QRadioButton(parent=self) + p = self.measure_2a_label.pos() + QPoint(self.measure_2a_label.width() + 6, 0) + _btn.move(p) + _btn.setChecked(True) + self.measure_2a_btn = _btn + + _btn = QRadioButton(parent=self) + p = self.measure_2b_label.pos() + QPoint(self.measure_2b_label.width() + 6, 0) + _btn.move(p) + self.measure_2b_btn = _btn + + layout = self._define_layout() + self.centralWidget().setLayout(layout) + + self._connect_signals() + + def _define_main_window(self): + self.setWindowTitle("LaPD XY Transform Calculator") + width = self._image.width() + 2 * self._window_margin + height = self._image.height() + 2 * self._window_margin + self.resize(width, height) + self.setFixedWidth(width) + self.setFixedHeight(height) + + def _connect_signals(self): + self.measure_1_label.editingFinished.connect(self._validate_measure_1) + self.measure_2a_label.editingFinished.connect(self._validate_measure_2a) + self.measure_2b_label.editingFinished.connect(self._validate_measure_2b) + + self.reset_btn.clicked.connect(self._reset_measure_values) + + self.measure_2a_btn.toggled.connect(self._measure_2a_input_selected) + self.measure_2b_btn.toggled.connect(self._measure_2b_input_selected) + + def _define_layout(self): + image_layout = QVBoxLayout() + image_layout.setContentsMargins(0, 0, 0, 0) + image_layout.addWidget(self.image_label) + self.image_frame.setLayout(image_layout) + + layout = QHBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addStretch() + layout.addWidget(self.image_frame) + layout.addStretch() + return layout + + def convert_measure_2a_to_measure_2b( + self, measure_2a: Optional[float] = None + ) -> float: + if measure_2a is None: + measure_2a = self.measure_2a + + return measure_2a + self.velmex_rail_width + self.fiducial_width + + def convert_measure_2b_to_measure_2a( + self, measure_2b: Optional[float] = None + ) -> float: + if measure_2b is None: + measure_2b = self.measure_2b + + return measure_2b - self.velmex_rail_width - self.fiducial_width + + def calc_pivot_to_feedthru(self): + return ( + self.ball_valve_cap_thickness + + self.measure_1 + - self.probe_kf40_thickness + ) + + def calc_pivot_to_drive(self): + return ( + self.ball_valve_cap_thickness + + self.measure_1 + + self.probe_drive_endplate_thickness + + self.measure_2a + + 0.5 * self.velmex_rail_width + ) + + def recalculate_parameters(self): + self.pivot_to_feedthru = self.calc_pivot_to_feedthru() + self.pivot_to_drive = self.calc_pivot_to_drive() + + self._update_all_labels() + + def _measure_2a_input_selected(self): + self.measure_2a_label.setEnabled(True) + self.measure_2b_label.setEnabled(False) + + def _measure_2b_input_selected(self): + self.measure_2a_label.setEnabled(False) + self.measure_2b_label.setEnabled(True) + + def _reset_measure_values(self): + self.measure_1 = self._defaults["measure_1"] + self.measure_2a = self._defaults["measure_2a"] + self.measure_2b = self.convert_measure_2a_to_measure_2b() + + self.recalculate_parameters() + + def _update_all_labels(self): + self._update_measure_1_label() + self._update_measure_2a_label() + self._update_measure_2b_label() + self._update_pivot_to_feedthru_label() + self._update_pivot_to_drive_label() + + def _update_pivot_to_feedthru_label(self): + _txt = f"{self.pivot_to_feedthru:.3f} cm" + self.pivot_to_feedthru_label.setText(_txt) + + def _update_pivot_to_drive_label(self): + _txt = f"{self.pivot_to_drive:.3f} cm" + self.pivot_to_drive_label.setText(_txt) + + def _update_measure_1_label(self): + _txt = f"{self.measure_1:.2f} cm" + self.measure_1_label.setText(_txt) + + def _update_measure_2a_label(self): + _txt = f"{self.measure_2a:.2f} cm" + self.measure_2a_label.setText(_txt) + + def _update_measure_2b_label(self): + _txt = f"{self.measure_2b:.2f} cm" + self.measure_2b_label.setText(_txt) + + @staticmethod + def _validate_measure(text: str) -> Union[float, None]: + match = re.compile(r"(?P\d+(.\d*)?)(\s*cm)?").fullmatch(text) + + if match is None: + return None + + value = ast.literal_eval(match.group("value")) + + if value == 0: + return None + + return float(value) + + @Slot() + def _validate_measure_1(self): + _txt = self.measure_1_label.text() + value = self._validate_measure(_txt) + + if value is None: + pass + elif value <= self.probe_kf40_thickness: + # not physically possible + pass + else: + self.measure_1 = value + self.recalculate_parameters() + return + + self._update_all_labels() + + @Slot() + def _validate_measure_2a(self): + _txt = self.measure_2a_label.text() + value = self._validate_measure(_txt) + + if value is None: + pass + elif value <= 0: + # not physically possible + pass + else: + self.measure_2a = value + self.measure_2b = self.convert_measure_2a_to_measure_2b() + self.recalculate_parameters() + return + + self._update_all_labels() + + @Slot() + def _validate_measure_2b(self): + _txt = self.measure_2b_label.text() + value = self._validate_measure(_txt) + + if value is None: + pass + elif value <= self.velmex_rail_width + self.fiducial_width: + # not physically possible + pass + else: + self.measure_2b = value + self.measure_2a = self.convert_measure_2b_to_measure_2a() + self.recalculate_parameters() + return + + self._update_all_labels() + + def closeEvent(self, event): + self.closing.emit() + super().closeEvent(event) + + +class LaPDXYZTransformCalculatorApp(QApplication): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + self.setStyle("Fusion") + self.styleHints().setColorScheme(Qt.ColorScheme.Light) + + self._window = LaPDXYZTransformCalculator() + self._window.show() + self._window.activateWindow() + + +if __name__ == "__main__": + app = LaPDXYZTransformCalculatorApp([]) + app.exec() From 0c4282d151fac486edc2ad43532a6feacf41de13 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 15:03:58 -0700 Subject: [PATCH 025/177] appease isort and black --- bapsf_motion/transform/__init__.py | 6 +----- bapsf_motion/transform/lapd.py | 4 +++- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/transform/__init__.py b/bapsf_motion/transform/__init__.py index 42ba3366..58de3d6b 100644 --- a/bapsf_motion/transform/__init__.py +++ b/bapsf_motion/transform/__init__.py @@ -21,9 +21,5 @@ from bapsf_motion.transform.base import BaseTransform from bapsf_motion.transform.helpers import register_transform, transform_factory from bapsf_motion.transform.identity import IdentityTransform -from bapsf_motion.transform.lapd import ( - LaPD6KTransform, - LaPDXYTransform, - LaPDXYZTransform, -) +from bapsf_motion.transform.lapd import LaPD6KTransform, LaPDXYTransform, LaPDXYZTransform from bapsf_motion.transform.lapd_droop import DroopCorrectABC, LaPDXYDroopCorrect diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 264643b5..7d27be25 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -1255,7 +1255,9 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # tan(beta) = e2 / D_zlead # b_rho = np.sqrt( - (pivot_to_center + points[..., 0])**2 + points[..., 1]**2 + points[..., 2]**2 + (pivot_to_center + points[..., 0]) ** 2 + + points[..., 1] ** 2 + + points[..., 2] ** 2 ) b_theta = np.arccos(points[..., 2] / b_rho) From 3c95a0da51b7dc7f239931cba8caeace9ee6a913 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 15:49:08 -0700 Subject: [PATCH 026/177] fix spelling errors and clear all outputs --- .../transform/LaPDXYZTransform.ipynb | 161 +++--------------- 1 file changed, 28 insertions(+), 133 deletions(-) diff --git a/docs/notebooks/transform/LaPDXYZTransform.ipynb b/docs/notebooks/transform/LaPDXYZTransform.ipynb index 59aaf112..cc751c93 100644 --- a/docs/notebooks/transform/LaPDXYZTransform.ipynb +++ b/docs/notebooks/transform/LaPDXYZTransform.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", "metadata": {}, "outputs": [], @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", "metadata": {}, "outputs": [], @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", "metadata": {}, "outputs": [], @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "15dd3644-c856-46c2-9f6f-846956b435d4", "metadata": {}, "outputs": [], @@ -84,7 +84,7 @@ "id": "af05b4fc-afe4-4a5e-81a5-d11d95f022a4", "metadata": {}, "source": [ - "## Transfrom from **Motion Space** to **Drive Space** to **Motion Space**\n", + "## Transform from **Motion Space** to **Drive Space** to **Motion Space**\n", "\n", "Let's show the transform can successfully convert from the motion space to the drive space, and back.\n", "\n", @@ -93,27 +93,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "768e0851-57e5-4b44-9f0f-541741376aeb", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'probe_axis_offset': 30.47,\n", - " 'drive_polarity': [1, -1, 1],\n", - " 'table_pivot_to_zlead_screw': 12.488,\n", - " 'mspace_polarity': [-1, 1, -1],\n", - " 'type': 'lapd_xyz',\n", - " 'pivot_to_xzcross': 142.4804,\n", - " 'pivot_to_center': 58.771}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tr = LaPDXYZTransform((\"x\", \"y\", \"z\"), **input_kwargs)\n", "tr.config" @@ -131,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "ea80e434-af3a-42fe-b590-b4744f382ec5", "metadata": {}, "outputs": [], @@ -186,12 +169,12 @@ "id": "de26ee8e-3926-4f2a-910f-a800b7cdb152", "metadata": {}, "source": [ - "Calcualte the drive space points `dpoints` and return to motion space points `mpoints`." + "Calculate the drive space points `dpoints` and return to motion space points `mpoints`." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "6d03325f-6e57-445c-9717-19fb98ea29d6", "metadata": {}, "outputs": [], @@ -210,21 +193,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "a0c8f222-15a8-45f5-b20e-ec475ba3d854", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", @@ -315,21 +287,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "6e52c2b4-5970-49dd-a21a-e8b84b3fb0e8", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", @@ -355,42 +316,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "76f1c97e-a944-4d8b-91a6-9cc328671b5f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.allclose(points, mpoints)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "f4449700-7100-4c29-946c-4d22cea7ee0f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(1.1546319456101628e-14)" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.max(np.abs(points - mpoints))" ] @@ -409,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "e87c5d28-ec61-4a90-97cd-89db765fbd2c", "metadata": {}, "outputs": [], @@ -428,21 +367,10 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "4e61105e-3788-4edb-a54c-9a582f04f745", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", @@ -532,21 +460,10 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "7733412e", + "execution_count": null, + "id": "2c1576f9", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", @@ -572,42 +489,20 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "054364ac-4e07-40f9-ada2-a3677c8c7404", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.allclose(points, dpoints)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "57e32b70-3829-4f29-93a8-5549b3e0daef", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(1.5987211554602254e-14)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.max(np.abs(points - dpoints))" ] From dfa3fd8b37f9dcf0470ab8810e2dcab9ec2a3945 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 15:49:32 -0700 Subject: [PATCH 027/177] add a codespell configuration to setup.cfg --- setup.cfg | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/setup.cfg b/setup.cfg index 30123eba..aad9de54 100644 --- a/setup.cfg +++ b/setup.cfg @@ -230,3 +230,22 @@ exclude_lines = coverage: ignore ImportError ModuleNotFoundError + +[codespell] +skip = + *.png, + *.pptx, + *cache*, + *egg*, + .git, + .hypothesis, + .idea, + .tox, + _build, + venv, + .\docs\notebooks\prototypes\*, +ignore-words-list = + assertIn, + crate, + oce, + DNE, From 8f502ddef96adf41667a26056b0294b66528be64 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 15:49:45 -0700 Subject: [PATCH 028/177] fix spelling errors --- bapsf_motion/transform/lapd.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/transform/lapd.py b/bapsf_motion/transform/lapd.py index 7d27be25..6b431b00 100644 --- a/bapsf_motion/transform/lapd.py +++ b/bapsf_motion/transform/lapd.py @@ -917,7 +917,7 @@ class LaPDXYZTransform(base.BaseTransform): (DEFAULT: ``58.771`` cm) Horizontal distance from the center "pivot" point of the ball-valve to the crossing point of the e0-drive ("x-drive") and the e2-drive ("z-drive") when the probe - drive is in its neutral postion. Neutral position is when the + drive is in its neutral position. Neutral position is when the e0-drive is parallel to the ground and perpendicular to the LaPD. @@ -956,7 +956,7 @@ class LaPDXYZTransform(base.BaseTransform): The matrix transformation utilizes three different coordinate systems: the drive space ``(e0, e1, e2)``, the ball-valve - coordiantes ``(b0, b1, b2)``, and the motion space coordinate + coordinates ``(b0, b1, b2)``, and the motion space coordinate system ``(x, y, z)``. These systems may have different polarity with respect to the actual systems used. To composate for these polarities use the ``drive_polarity`` and ``mspace_polarity`` @@ -1204,7 +1204,7 @@ def _validate_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]: def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: # given points are in (x, y, z) with shape (N, 3) # - N is the number of point to convert - # - 3 is the (x, y, z) coordintes + # - 3 is the (x, y, z) coordinates # # we will utilized three coordinate systems for the conversion # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, btheat, b_phi) @@ -1279,7 +1279,7 @@ def _matrix_to_drive(self, points: np.ndarray) -> np.ndarray: def _matrix_to_motion_space(self, points: np.ndarray) -> np.ndarray: # given points are in (e0, e1, e2) with shape (N, 3) # - N is the number of point to convert - # - 3 is the (e0, e1, e2) coordintes + # - 3 is the (e0, e1, e2) coordinates # # we will utilized three coordinate systems for the conversion # - ball-valve pivot: (b0, b1, b2) or [for spherical] (b_rho, btheat, b_phi) @@ -1374,7 +1374,7 @@ def pivot_to_xzcross(self) -> float: Horizontal distance from the center "pivot" point of the ball-valve to the crossing point of the e0-drive ("x-drive") and the e2-drive ("z-drive") when the probe - drive is in its neutral postion. + drive is in its neutral position. Neutral position is when the e0-drive is parallel to the ground and perpendicular to the LaPD. From 798e40413e139688aede5393379cf51b71ea014e Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 15:51:03 -0700 Subject: [PATCH 029/177] clear all outputs --- .../notebooks/transform/LaPDXYTransform.ipynb | 98 +++---------------- 1 file changed, 12 insertions(+), 86 deletions(-) diff --git a/docs/notebooks/transform/LaPDXYTransform.ipynb b/docs/notebooks/transform/LaPDXYTransform.ipynb index d87b5dcb..3cf31965 100644 --- a/docs/notebooks/transform/LaPDXYTransform.ipynb +++ b/docs/notebooks/transform/LaPDXYTransform.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "1bef64d2-1541-4dec-ac10-ebcf4cffe4b2", "metadata": {}, "outputs": [], @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "63c23fe0-5407-40b9-a998-6f1581d6eb6d", "metadata": {}, "outputs": [], @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "9e25f18e-6ce0-48b2-82ac-27c69b006a29", "metadata": {}, "outputs": [], @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "120c8907-672f-4915-aa03-506dd91b1d18", "metadata": {}, "outputs": [], @@ -71,37 +71,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "4e61105e-3788-4edb-a54c-9a582f04f745", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-5, 5] [[ 5.20035847 -10.82133761]] [[-5. 5.]]\n", - "[-5, -5] [[ 5.20035847 10.69163439]] [[-5. -5.]]\n", - "[5, -5] [[-4.76148342 12.72168007]] [[ 5. -5.]]\n", - "[5, 5] [[ -4.76148342 -12.90561491]] [[5. 5.]]\n", - "[0, 0] [[0. 0.]] [[ 0.00000000e+00 -1.59006142e-15]]\n", - "X = -5 Δ = [0.] || Y = 5 Δ = [-6.21724894e-15]\n", - "X = -5 Δ = [0.] || Y = -5 Δ = [8.8817842e-16]\n", - "X = 5 Δ = [0.] || Y = -5 Δ = [8.8817842e-16]\n", - "X = 5 Δ = [0.] || Y = 5 Δ = [-6.21724894e-15]\n", - "X = 0 Δ = [0.] || Y = 0 Δ = [3.71924713e-15]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", "figwidth = 1.4 * figwidth\n", @@ -203,25 +176,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "094e94a9-ecbf-451a-855d-ab09e818785e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(True,\n", - " True,\n", - " True,\n", - " np.float64(-7.105427357601002e-15),\n", - " np.float64(7.105427357601002e-15))" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mpoints = tr(points, to_coords=\"motion_space\")\n", "dpoints = tr(mpoints, to_coords=\"drive\")\n", @@ -237,27 +195,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "a277810b-3553-4cdf-9fc9-dc0efab86cfc", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([[ True, True],\n", - " [ True, True]]),\n", - " True,\n", - " True,\n", - " True,\n", - " np.float64(-6.217248937900877e-15),\n", - " np.float64(0.0))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "points = np.array([[5, 5], [5, 5]])\n", "mpoints = tr(points, to_coords=\"motion_space\")\n", @@ -283,25 +224,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "8782f090-6ecb-4d25-8944-9cd1853be826", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(True,\n", - " True,\n", - " True,\n", - " np.float64(-1.7763568394002505e-15),\n", - " np.float64(-8.881784197001252e-16))" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "dpoints = tr(points, to_coords=\"drive\")\n", "mpoints = tr(dpoints, to_coords=\"motion_space\")\n", From 435a0b12b0852c9ba67f18fbcc86e5f6c7b52fa0 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 18:46:35 -0700 Subject: [PATCH 030/177] add initial diagram for the xyz calculator --- .../gui/_images/LaPDXYZTransform_diagram.png | Bin 0 -> 101200 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 bapsf_motion/gui/_images/LaPDXYZTransform_diagram.png diff --git a/bapsf_motion/gui/_images/LaPDXYZTransform_diagram.png b/bapsf_motion/gui/_images/LaPDXYZTransform_diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..d11ff8a997b93115e84d622dd7b5ae7a0cb9c314 GIT binary patch literal 101200 zcmZ5|bwHDC+xNzR(IKFObSWTAN=mw0KtXaUAfqLv#wZDqh7r<@lyoyhrIBVZ0Z}>( zQu@2#zMtoP-|r8dyLRRgzw>t-$9Wm4ud7B*!bk!Ffygz~l?^~3!cGtfZ-$5v1Oofm zle7arfZYw$6hW24H`jqL_|Fw|6hNT&v81O@2!QXzuIi87L7*Gdmw&+hJiBrr&_$t! zvVze|%dInFEZ4)dRr2Z2F-$e$x4sdQ^XUckcGP{!yA>Q9bv*|gMiQk@Fl0)q$mwN< zGUK!-waL#jAdC54VlkYgLpQ6g$9aF8G-Ox(QJ z23`(M5l+tY&dp=F)sK%kzDGvWc%O=-yj3G&53Nhj(n=l@tY7X8FZy-;Y(g7?iz&dV zH^vI7>=ri}71w9VQRduc4~;`u`=PHXs$zbblQ?_aX78sF>{PK z);MOZ*!Hnd_BeUJq}s~;WPoH_V76$30_#zI|99sn|1+0Hbi?%a)02EM2pQT<-fkYr zuo57j&h7a=Q%h;kdmZ*osg9Lv=b$$VF-MGQm_&9|L+m=XKb~eI1GG=_#0yln8iQot zL&_1XSWR>SyGgCBjz#vSF#1}o6bDwhv_@a1uY^KGANIfJv4uPUB zx7dr3-0AHQcmA51_R72!-?`hD*hyQp+AE$xTLt2{zcH!TBEUc$4d3PvN!>SKoUR$#wM zAB_!(I14}N+tJ~Ffc#L%l>Hj9lv`jBcl>K@uMaJ^$GC(RSnwAqa+3abNRX;3cTb}~ zkwJS8o)}K;7%cGk{Sn9gUiB7157^FbQ9!!jf`8}jUzE3cDXJ;W{a+;5n?+DNiegXx z{^eF{U8B4eVdbX%YN3U;PByri(=T|4U!uZuhOEIqO4sZJLQ(^9?0!YAu`wG@y@Q7i zo>GBH+8h@R@Prc56UM&HIx`7)YQQtDPPfWCoofljYVeDnaa7>^YcpL!fU$e!RAgM% z#|EWDg5R+CR(n0LN5zl+psb#=n0+aM30|V8epl5dtYOiLuUb9&42q@5yFa$&!Cvg{ z-Rwx{$5_08RXBEHRxf@oB!s0cev?qyUALW|qcb+V*W;F;8J-dwd5#J`6_TX-WG*fI zbdT7G8QwI%|7cV<3$}JWl2L7js7ShliMB5X?1eIMDJ-QZpYb>th@BBn1J7nRQrO>< zq;P|#_Sb8{@tK%ga_?fYYT;eMyW@S5Z#N7Gtp4Oz(aHPjrVk~}(ArtzST+p|DAT&E zq1YDbU)l!Kf(nFKRW!F)K9f`=+!i%s`0<%?&udGsuP=JehUUB%GLO8R$Ci{~Nu@37 zmkMWzj*fwvmqE7LtjkdOv9i9+13ahe+2`w=g3`pYi(|5f3w|zo%TX<=Kx^vah-f(H zcV+YjsFf`(>X{H)H%TA=2Z;Y3rg!aSik2s;oii<+!~P~*j=J8aXMl`HwYo1?h*O6U z`yq_UpG%(NB>KIvP zn{yE_`T3lVcvJ+@l*UX~k_hJ5cU5{JEiEf&=S7IaY>e+Y$ZTya)T+wVf7;N2!bgzs z24Nb%Gb0k;ubvs6y|Cw!ndlfY2qz(j;m*5RPqb})4K(FCKsd+RH;*_HbnqF-?kDqW zVr$%1n9LsCIe(k6_XmpIZ7ff3em>BzG`|d(szh&p7Kc~RAUyqp;m4BwlQ%@<)RTJ- zj`RqoW&K#;93CcbqNJ$M&gP%h&l=0Kj+CS^Tc~bO?YKs9(so0+xqoev#jm19&vnr* zusC`UZvO*)^DopWJV(CzB55W5>F>;y9sS?U1yXmZ@9f^m`|XH6k6-&vWI?pud2!B~ z;9=m38sZj7o&C+N#;MLZsh#$^1KlFZ0Cy|%a}|D=Aa}7V7nnRi(Vaud>}gyyBl&N0 z`YxW}eN$gP6WBKvPlPb$x}bT4dP^~lAlLJsSdh@mE>c1FnFlD(N8k*57HrkbDhB+S zXo}WDi5DW^%G;C1@l}WN;N`{1!i6r{Mf4^-8m_ZwiRMwqmmaW*x8(NC7(G!o1Vc^M z!Pos`VkW|oeYxK%ef_~t_fJKJC4LZGYOMsqv`}*_ZFxaoA!Z>iW$U z^@sL70t@yEw&TmTd$a}G^)44w7gw;A62+7Ynl}iT$T}BhTT1`o#2Wpegvsz!Q8KP* zEZlfGFkA1wQKVBtEIh6PDZi~L*Y1@E*{T=Jv{!^|b?k47u&%_iASG^32Nn7-N4yMV zE4us5v8-m-KHZwex`?5Rr@L9uiTNC~`JeAf4oWr5a6P#*k5#S=w%Q-B2veOd>Z=0o zh}^$jn9Wie?byX)y=%5Qbke+%Td)}Cih9TdpEh^bDf(JwZ@~aGLCDw;rixOgD82W5 zFTId+^q72uMnolc56Mft0lqkf`I zdnk<_wZ@hcW(4Z_PfgMD%WqlpmQX)Tq3hKEjQ*{VIq=Pa-kmiCtHX&H%HF4T5L5J%Ev+l*9>%wQ z-oG~%p4+A0DA8n!nW`{rOk`e@*RZ;C9I!;neKI%IP1#9uRPp-yndX34m1kr^z{D~W zSMFg@ggiIXG0`|O=D1f)cBfc)F0kyrDBH#a7a>}3MDLETR#HW6qtP5! zjc2Zp2jLd1W>aYI75;p|^=0uPyD;b;MwiNB)2m>!g(LTHM*8R4X7WX~#tZ zB>E$Jh$GX?ivzlL#kyF#UxMmunLfws0cYQ!a=qG0mD>Z#okG5k)@b8_GZ~g9B-)SE z`2tq$g#)m*F}I=qyj4+xh*&Zq0~Cw z_cC=!`_LE+*Ei#Ci1zpgwE|Q(F%ZhrP8*aBa@Tf>QpNBIB^aI25hDRio zki0q;xtHJW_p_N75wgB2d)T~SgU@LVOS?4P`#Zgy8toJ?j}_2=9vvyJCP2szdmn{C zQndlQqLs#&FXVv_4C7NAHUgzB_sAs#RUVIc>H8@%s@THl$g4X~S~~}}zH)P>+Kk9E z7^(Fd0jwm1Fx4UZNd#C`owt{)XawZG9qjtg0>6VU?JFb_5TkD&84m?aaRb0T2@Fvw zfSMb}AnA{Vf1hUw`EsRczCT)M+7m@zOHi|gJ!F9E1h_2fDbo|RxCvcjuQG5v*FY+GPf66xlJ& z+>=6(#Hm@CsoH-R5hMuwHfG1cLBFx>qVC{_`;r35oMP74JVof>v_~)O8lk_7m1rlY z2{}#f158xsiKDds>(XU27mDhnerc}z^z59WkZ7`C>S!wA>m8e82C!hA8|UK#=QKl= zkDXw_@w!i-GzAc{s(#gt^!OqSk+=o6i(nmO=DnK9$p9exW8{*-n8DV!U{&TWYm}4Q zV*>)FF8ZPLSZ4FMeYmle54T)rQI~?)KiyhwwrA(pi!;Teh#E$1B7ZzUUw0de8cL(Y z4nxF)7v|FsBdS*#(sLrCAbM9+FL zTKE7K{N}o3T)9#il+`b1EQD+$4lfBIJsMjdVA`-wEZxM$4EO$u^h@Yi*$E$>I&e-= z>LPl?dDC&IheA*tihUM)f9eGD>BjD^1EZI|4i4n5wy|XNFm}&0OBBY&*yQ-Z5vS9s zPEr)w25xxL{Yv>tCiQW^3M)Kjg18_9K8i3q_)wO!({Wf~}~Cl)JDzJW+-+H;E~gFUIGn{pmd!mh2L1?vS|5w8%;Mm6&yg1Fm&3_Vbb zjM!V1A$Nnr)&qwuU-3|iOWNSR)ezTIPG?u!{@}Q`F34F>99TPEo24CwfOj@4nca8V z!+ozCZBUqZK)EVq%aBSqg#&{HHFsRLdl(y4%?n`Y3BnmSo?%2j%`yA*VDZhhS7J+Fm; zLvMgUGFv(B+|C1UmTcVgxjJzDR_|Dto`}a2d7%dqu5lHI-Zc-{pUifh(fBQnK4`v} z_w(a3p18e3h`n!hE(|rHdH;Z)7BI1ZK^xwnKwlpy)Z`^2U6cL}H+M?ke}Xu<1busiPp)NbDJf+^&)z&W3v z8FvIHpF2s3)h`A7@H!y4VLsxwK;62Egpo7A|GKS6#LHo%c%@TwFrar2pTB*fTHRJa zxbw?7PDdmS++edjSln1Hvt-fR+LgT3OCAg7eJu>x+RZqxaIXm=-hrBwd?`pq`hSY{ zj63t4{63%ZP~`B`cX`mM@)mfR@7`Hm-H~x7OXz}as|u;dvEymlcf*gva43za4NJM} zSzVA5{f0G8LE@s3C5MXa)gAsDfvly>^m-PD{bv>paj6Q%_)wGD>JVak+!Z&B%2eH8 z+Nz3xHL++Esj4rbS|s!YgV_UfH_{y{`;YKcPF~?W;T0Q0i4(Ggs2E^Z-SoDK!328((z&y}7 z-FYJmf-^V#!^2X+Yx{a&`)GKoo}J};8`-mPeo4${X^gs0)^gqJH5qiz`VUJnifVUd zUx$SDH+{nwDuOBuJGtWS-#|>iK+o_=-7~e!!kOV-JsV}G;75(a(uZH+J`ByVl@E=M zi&giy)hfuOF~8w?9R$YXh^Z2&39}ok#XAZ8(B~cV+1f)Hhcam0`+$$??am^IAVicL z_AIyO7c0lTauCSbk3`}s9_+#OI??a~fNA<2uNO=62CnX3suXto)4P*NK#22jG`@^l zTWY_&j%T^HGDd!ES8`aTGKB zVG6+v(e;zSqXZ2=($MlQSNz!vsMtYH7*(!h7Hq)5duoSyx2N`S+#Yt(+Ggq@AyolX=M;77wtB`{;j@A*Sd!MgIrXl}!G z(GJN8B-QWTOjSaxnni=*UukJ5Jp=J+x-8x0r;LjBLt9k9{(CdO9|>k$?Bij~+WPaL z&3#{YBt%e@N|n7)Lbw9H+NJUbpnx5k9ueBCCbvAaS`H|_`u<%s-XCzxxIH30f6$OM z*-a_;Hcgdjh6nmO#yg7dHFVe+@p>LkS9i8w+#$LYPw~5 zRA5`$*vQJwC|SQA=KJpg&sPJ7wKE#t*+^U5S${Vxh3SpJP`Lkia}TNEm4$w7DKOj0 zFSWZj?)OOUZx^NTc;y_aa+R`W!z4%Jj08qq=2}<6!o5w#15)ymjmC(|2&$*=0SEp8 z8c!ZLamy2sNsqJJf(PS41iS;&Q@}+FgcOYMlGg#%*Q{QV9fvDibw#U0BjF!?$#$l zP7l9{Etmm@AqPeesVfIV9D#(^nD$kBY;E@0RuLIYG5rl-964ayunsXwSb#hhy1U{O zY%K*WIEn!-y;a>kzGmizdIEZq!!~(O+b4|P-U+;Tx}H~ok?W||3jbrT+1#|j)DfvBNuxr>VzIzTX~styKr5JZ$h3Z-W! z02cTHMQy+dJOUa|L@;Yp0guI=LTM&azy~zw>rXlv@Am-wZa%~I#9zh3FpVG7yH6W9fBZMZ zDh6qq(wN1T)Oc1-gy7O^7XA2Bko-l5R(M_!s0d=UYLo3y6C&;M_*|i{v(>2hMGwpD z-!a_CUDj5ax@k`ZY0~U=`y1!0INx;F9Sx`|MiU)usM1q7qqx%QVPFSh5B-??%+_Ra zc(LgBwfM?uRq9|yh*>yxxX^|{3YAtXF$dP5pOY0iolO=6OTostV!ROyJlhx|cA8*b zg960qRN?!Hb&NXKSKH8nks#`9VW^rEOi_xYQ;|!@I@j(&`khb;M?BYzcy-~<<2BMw zlJyH=uDzhwLO<`H|NYUvnA)@R`iNv}cir~uxVx;)}zi?roRjAcMe9^8ydgZ}wRA${%cfF)Gx7$Mc zh@*r7@yyTzja-HPsZ9SPrK-m@Pj^)sSjGkUoy5;RR6$b@2E<}z)6wE`swBrY0OgHd z9&X6Kqh@Kd$z`#MCWnMbM{?1;^(S|O7iW8!a@@=QtO!+&qOYUT+hW8fEN66t(1Lky z{~nQFnRd{xQ6TyY{!F08gqa!|c6W{&J6ac&X9>~?$w=W&wk{hz>%WkB&)T%5j*(5> zGPYf)Q@2=|%NCb7A|ZgaAJDZB@?7jr3T9xcsQN@dt1d(DLm%2X>&0WmqNu?b z$8S0}X;8Rm-=}mByb0HT@Pe;k) z3=u*w4Zg%riRf5xmiWH} zeF7{>9;*6^ofdN)h$2S~MggMPK2T`fOzY`F(~ba~_bjyFdF1fczVDZWq$Fz~=k49> zpnR_-Pg4DN>v<9#C3DGif^Pd>_=!TLl)|QHHmy{hpt-D{Lo?BIIr6RLYX7j_E+(6> zfvmLsV0ofbSNueR;3vLzC2qg!OD>B~-Dpc)r=>S;j}%uKc4@IPP{MUU?o`My^`bYd zEuy`_1f;`>A1(R)3dh+6Ef&Xs^C;}}o#j3sS%Ms$O@s%7kXz{&NsjF*rx;I!fN@LR z3$h=W0+%&Y9t1D2%Xj1y(Q(3mr9D0eX@ElBeJ~F19~KO#(7NODF}rY`smfdB97yaT z4GuPpJCCg=fcVgOB^+Y8Qn6dp@Fd17Fm^f%~>P$KGfNDgF3FDY1XSID#{1qA8 zKc!guUnl!bNHNq3NIdu?-m_`IhWPf!i!?eplm#2HGa8ww^=F@LOpYp(J^e?W+skzr z6p`R|(SCTK=r&n!W{sC91Yn5RmV-Tt6*KJpcmTuN6HR3F<;D6<*@O47%zpcm#({%6 zUWAQ9F&f1?!~{aU4-*gm@m=jeQtje7|KO3Jctm$+GY8FOa`Ue(`XSZt-w)wgf`e%t zBg_S7QdR>k^q5e+sHn>I0CCzjHeXU6o=0hQH z!2gj#y1E6DYPm}~#AMSqhs4`yawe)H%elGRbU#hAm>uPioX-1$^U6A_d0>+iTc0

oT6=IrPD?`g-l_cd(YLNDWuHw#Dv@rnQodebtuaC z0RhXH^x1yZD(2?>5IpRDUaHlLhPP(}o3_5cq@Ny2W-~LJ$P!R&d5jY0eFYsH>0GFK z%GUrPb^;#{Dr`k-h>p;b?tBivk}FQb)WcS4@)U?mvij-vM};-Ab;puL(3}Ka2mH^S z-Dgaq@UXuMX9Ub14f&f*9~nDPNK@Ikn)A4F2WgLuT~74sFv>F17VstjL}!-9`pIVh z(x1LW_Q+2EX#B!|c)P5Mj$GO7k>L5c;dHxOAU-=eg=z6^_5ODGqW!D1`AVWsv(z0@ zDl)j)qhWu>fb;G2nPoCkW~}^QI*!PHomtp)>+{7Mq8sS?K?)>JS4cD8GEkQ_Kx_nI zrgH`&%586Ny1##FJ2^N>q%YUHksP=ZMZ1YX$u`M|(_`G8fH=Ey3i2SF7C$@%AD)65 zsW8G5%~DpaP|Wdm45&V)$^F`K-uzGq{XGkaM=XzD1m5l109@R29lAhRad zT&cQl^OjhxJFK)$oF5zte?Og3?qLl)UGKT+J~;j5{^8f!pDmk}tbV@~9fiFzLU+Vd zkGhC_GN)FHMPIIqRtMz$Yxgu{nq}e=u*czFtt{C-_AKO5W3u=a4paNwHJ@JpMN%sXy7ktDGw0I+O&|fujE^f+?-QpW5F+v{paD#%>*SZ_Zva8{TMP> zK|=+q+VW9Eus#$I`$F*3bW}2go*_&Bcd#OquPh+Jg3Y8diWnZ^u~=i%wew=5&HW2` zO03y>1gFjlHQJO=vO4#hSoIztSTj=xA3~$9x~yX7$(I?j9I%L<^;}>Z1M8>@|22_ z!MkZlEaNDo$QglTmrbB)NE%&#eML4$FB^zmg~0%yf7<~!D`PNpqA*fq{^m6rLe<*l62w zMnHSqb0NzrjNYA6Vndr$8{swjS60|@P+w(Jv}t}wpS$4Qc`^r|YvSHi>=l>_()cWU z`t>DOT!89SGb@$FAMB+)F}+Mfn8}t18c{qfPc`qmv4-`lXUpbrR4e@$McUay7}f8gO=uw&dy zrnB-f>U-^6(pu>{KPSdz#thqN*(TfE8i{PwgRCg^y$sX0r#Z=&M+J>!>3%a}?fwa5 zwPy8x!`}hA2S9n_C5@V0T4J18rfxpdVll^(r>P-u`oz`dXuCZ8@^0F#02x?AQo81r);%}4+jpI>*PTdB~ZW15L17}DU6A_^i zsA5x8ACC_iRC_K$9ldC)ICAoDwCkDHfr{9H!oG*A$%LQ?8Uf zfuwF}<##mmHRJVA&c~qHsfCdNj~xxgjt)AHac#*mb!7odHFd)uK$4X1j)wQUTmgbsf`jjIC%FU!QBd z^900Yov`QIe&jatn0LJ)Z@bZXt|i1yy3fThqndsc$ZH@geay1@TGzGBs+?nX`b#CR z`SRZMbFA#RIQzv*GFdu!+TeLIP|MZHS)@X$+{Ic?P7s7Jx&fJnUAU%o*uC3!l2uMS zN=OL`A)}CR`#p2PZ*|mvC!xb^4?GH0xuG%V$JHKZj}D#B{_5{uc@7kjZ$Bu}E!=fG zAv#E-HF}v`zA?9ce5A+B zh7sO=DDd!vdJGD^F)HqcnNb^~;SOkBYtK83oL?{ck~_e7 zi#d-}`9@?)&fD4=z9a`y-au_k1_|qH}!adiQ_lcqooKk~;kA9*7pS6$DmK zrTFUKgZCY?7j`jYox_kG2-ZT$lmN>CTxQ|?pm8;+@U;zyGn7jBCUCei@}P20v;2N) z9KSx<*`&u^S+k#8#m&5Cz0-mx8&ZP59MuS!Y|%7ZL=$)dY4UdQ1cFKQ=f zFL&aRba@KXUI8n4RQkNnAt;vVefL}~4gEM%5uv|4EPR$~{0NbZ&eq*4jnQth#k`4%)~GAn2g+^z62 zbAE4=>zlJoWR%;G>p#Ck^nOh??*xWtGZU^Hk( zfpE`9KpS_o{`lRLSrlP`r?FR-c$M7z%9q!}(X_cI@kIyI2==*RkA;dFN=R$xhVWL^ zi2b}3OLYKsFA;kRJAk(1B!^EF)o;6w=!aGB%lzQd`S>%R-7z3qi8FNKBL_NRJtUi% zy}(Sss^e?cU4wB>^Hp3AfBvngs8P+)y&o2k*7?GM=C_*$tVplWI1XELO+blpkq^d0 z1_255z62;9@cB>jhTYnz{BfQj)jHHVji;w z=vX*B0c{F?@x0A$(Ibb1&vr0P7WpW21wL-n`6Es<1j%T`dOyaym`g61mI@e%?Fb*s z<}Cs$*Z3vl=d+ZztruQssOS59E)01Yq-C`_)<7)+e>NQLDSLcvr7Z-CU_t8FKm+|y zjir>c;j?RPN;a~o(2cr^PRd+!h~6!f!tsXCAg@cOigadU=f!4C&~Re(HL2?Uw`*fE z2VSLL9_OJ8W+L;lTjfUfwI7D`<(zf1V$R!8_eEaqMVs!*qZgsDi-1(SRW!9C-(}$5 z8F9U6hHTd&UCj_L6?q`;^2POm?U&&CH%~iLh$lB0?gqz9;Xs6nM|lY0Iqa9opDs4l zyCXF0ujf{C_^{^>rwtKbTQ$w7F}?aS-wi-&2MwZT>WMe$*|{i~MqW|RKbfV?q5{lw z-J?9hBNW|QN0tlns?&P+yCmY5;vh66F-~Kw>Cd`k^+K~p%Qxc)B}1E&Nd}BF?Gt8t z%ud%qR~ird$1Vpr{?_*~;fc%aPiUNG(tTn$pu4yyxsZ2Za_$I$OYn^RP(>A4I5>3k z>dROZNYy@nFcJiqQE1#}*BGs5mtC}JfsofHBE%&QtTpxJ%YGCb^+NXVAbTG33;pxm`_O_6gt6J6^r7%n?)(FIuRDd6-cdN zewuZ5cz;26esuw+9gVA^dW}qKJo?T5F}_fK}^Jy|7Wm6o){fUSu8LRmGB#&z{mo~P?TN{_E^IchFUzn@l#PbN@|cdmPexc zkvvpfSiD*Ef0lTk7qwnrWj0m0-Pq;71L#n!3nVT~=rr9A-YQtm$bK=SsB8NEs8JB7 z*6$m)qStYnJN?&2U7>^p+cw2nwVpti5%~3s5OA4qhc5}dR6k6YyP!g~WBRi=G#Wy# z&91Tk7W4`ewrS;hRhI>HAe#0FA0{kZ>4k{c0Fyz_=`u(HSy;Do5{2eu+&2p4wz9Wp z8x z^axU1i|EIX9g2G)-Q|vKn!7;qjmXk8hL#PxUgzY3`#TOAPi4i+;@2GU$~8jk6)|0i zK#wJj3rpk<5VaSTS|sFJDK7nO5x7g`T}o!xDt8rQS^K?9#G-++Q?Z;F875)y^F=9T zRZ#qJF#H)LMmN0wtF`cUO=Q0J4UjzQ&pi@S!T7$GuQSpsM&>7 zdDHQ}#Nzii(yflcUg&tt$-^-M#5_nHok(26q#2Np_e-$td6gJr*(%6{_K0G7}JerN70bap_Xc0#`@=+ zgh-OO9%Ex?HwuGn|IDxnI)c$n*(PMjgiEYXlR#+@5J_C=wQ=MJAq7!YGBD`4wJ882 zy*?9#*9ohse*`P4@|I)irP5L%c&P_KCUiWJZ(?SXp9h7Y(%dOgvNR-@S{F-|yvJ;f zm#WKIHSH)GJ5jGQ>!3gGqnW{ah)!-+O|o<`7@4-wpb&=xo{$UV#>W-y)NDaaG;Z>p z12$SAsMW(mW)p)o`LqGsSsRE62M6odg5iuUY#nzsq73A^tqoMNoGC*ASrJESI9YbV50 z^#HFD>*|tn8-7t51}^V%)utj>21H&7>9&Zt3nb7GPo&YN|08NRNa>rwjaUEiJ524+ z``>(MJ|FPblBo1A6+v!t#n1iG0|_b5Ac;by6v(iWvCBzxh~PC8rzG*pi&jvkCCtGM zy0a{L2KJjY$`C_!17;8SOQ!Jia*_>LHqST!lAnV+MOF!_L&gLk*ru*bAK#1sOHks@ zX1w6zj&=7uuBx2Q`MKvVKGPE`@qA5&RNgeNe%jSFj)u(m6f_Pw0D)^w<4CbLPf=;J z$k?3QubrTMonIak!gVUF6^#g{_d$JVqc6npmj_x_+@Boa1x|mZ-3P_03-e-|_T12l zzdY6}^4=*w-v+o_s_bUl?(j)uK>^;ng5Pg21K6=IN+*`b3GLEyZ%;&wh%i#SdPJ%{ zz_Pe~=e+iD?}^i0z06lTDM7*|3xX4$3CcxL`;cS{b@xrfP#ZDgy1+KhsQKe(^ zXPd~;9hehZ?wrAccP{Q#$nRsKF+dgpiv9uR;V;di!R$Hhy%*Z$woaEA zE{u|@e%?xZbH(63|7=fT%5)3u7XOEVV5?MZVj%Lb3wW47!C`f=ro(?O+B8?#|DGc$ zcP{ysE0>iRgW~SgLBntZLgpGqc)DHPZxlnDV6=)1i(o5qf@RB?E+T<^6IPihAS?oO z00k)MuDQL&*OW!cyx5`{AHOD#`M`@`7x#BtRX@-O)~`K}F{;W~CYQopXEQmnL3WOa z2D8e~3%c9Kz5jq)lMcQ*wg7U~ckhL^460A6ZNR4Z24Qt%+zkxoXCCvIV>UMjzJNsa zYZdGtOP&uFuZ3{l3juQ8+x62Ov&r#`qY!=d0tgnfbOqPn8LAP-B=70K(a~?*El3o> zWcQwadt^UJEZF`i6jN_*)GNJkG)&ndP^$au-0xQ=XHxNG!L}WoM5AmK|LVpyG5kFc zCkQ)X8`CM>;Ihdb4IBHuel3nH7RV_9kATq+ps5$4urRJmAI^d(nSR%~dFkbU>Aqvt zk$U~qOqjh%gXE_5q72!s8ZNE18+ZT@VOG2HvNpn^pIVnF3cEsRY&A~u7r*lB_KFT+ zO4+~P-kNn*wf=0W7sNe0WwP+6$4JFo!m<>Qy&Stj_%44U1gTfJpc_zAn5W4lh1le} zX+NLX+@I$_7z4Z&a-}OMb1EI+$1>^PFs5K;?By&xs5i94a2L-RK?85lxZ8>2+fRX6 z!@(V<+4llrB{36Ml%@rcniYG3Fn0SU3H*T9m>#1#a0`;U;$*h8FDW4ddA{&CQVQ2Y zC>_XRtsNSipjj490oTd7lr?#)QaB!VQILQPo^N9WCbP3NJmqMtn3gYE6Y_HSUE4`; zBVC9AlABYIu<;1L8euz3C@VF$c35C&jgQ^F9}UUaooWAbm~D1k`wYaSJ_AxURlNk% zbSrjolr`rMe&ri&SsI#sCDqa%w@}QB2Kq~wW5`E>Dj;zTF(GUtW3c(6Q)InMMg%v4 z(voQMO{fu8n{PKRAc6dsy{#>ei7fcxt1btBEF~W;CdT7-#1YARW3iWD!fILG$OGNl z05=GB_1+oNBseTMf#gI%8$>#U?kB-%7?Iy-dzC>P`N{c*KB!jCE{z!8X<7d=f9?3r zG|Mcdo8Zfb=UeocV|Ye~(9i)81vCL!tFSXT7UXqu@0`bEUhIi2U*qFpH5#z-avR`lvP!_50}n3oUIhUVn&#W z%aN(zG7a9HwBJxJwWrf7=Q+oJsFpra^|s5!X?Zle5y+Ewn!00yQV**h4W9}br;M1n zf8an9)cbpp!6Cp_B(C(83o)UwvjcVeX@<{wojY}0&wO9>*QrEF*(>N?q^pDLHF^^I z&G4H<@UtA7-6;G5T%9(Aeq|BOo;@{0*Z}gH*8rU?r*|J}AD5e-CTV}ak&>M109OLo zAQfSC3=N>HQfC#A15C+DS`IZs*{!#aez}e3#KLBmqn#c8V3D86>75N`#o-en%>T~c zj7$TLYUm6-%#R(1p2h5NEnOK6q z`z^@!r>JsNhDd^F^MhvxJTVF8zYM5I;67a&9_W<3>CHQ?Geyq=H9sN)n2-6)a2uqq z;L0!d(zy8)GYYCj{#k|pSy_joHOPS&DX)o#?N2)&|7Kc+P=VThX#&vKis5_945>NE zHt(!MS1`d#!_fP7t9LJ^%v|;ZXMEB}GQxh_dU?WqcVkKZ;y%o4hf19_U&9rX0g%ai zC3FXPei*J22oF<=1YH@Rwgcg8La0&^tjeAraP$xZ8GIxw?P5bfTjwwBQKtBg-(f=L zzVkk-nZN~~@T#PB1QhoOLW`HSvMqi%m)tOlv9ZY9zCj8x=^-ZIPBv;>=2t$c&` zG#e>^GK6Ye6sB7#8od#A(CI4d?_JiDC<_0>)`huFcBNn}g`n1oTa`McfX{I<(SHPY zWsYCH$bSf;`4}Svj3f3AODy?)GiX>ORDJ7jhonTML{c?b#?cD~YR~kIkUt0HLO?wQTwp(9{U2`!LMR{-efmc(P9N0$D=0I; zmd4eB(2DZ=reXn+fjWDI(u`#fi=RMnm!;pY_QOqXC&s@E)aq2xTbQYDd0m91^PymU zV_FRDo$(Cmq`2`nLI1Hlvp;kk5c@utm+z6N# zjtx)iTY`h~-NMdL;BuBr+*P!(Rt!Zlh5^S&#s^Tt&td7ry+1vyztE4DlW%C8Abc+i zHpiDQT8ZeqvBFXU2}vV9N8Wh7l4$J+F~NEmN-V$^m~B&s(lv;}o?h3il?B=+(esq%cRvLJEY6sUBWffrJWbaoe7?mjR zwJLZ_O9(sTqtqoTWt9=lDY?uG1Urm-5g8C!+U4)oIyp*b9)x6)+rT+c3Go*no)(i}&XA*hei-@2+&4H8S z0}=-0n+^U|176*E2v*8vUh|08kE-abZ6cep`SgL{nRZFV%AMSryBL60{WFUr=<E6G$&?0*1tc^oPPcUN24&E7> zAG(ncaMP_YF=2M5a&Mu?Yk$7yJ0^K?a}#9~0hmK*oVq5oy3EtF?B{+r!^=sa>Xc+W zUAIqq*-6?F#AG`MoxH3*WfE4mAx(yXvXsx`C$g7YWFJyH_`38?xtC5ScovVo|Ee92 zz&kr+$cEyw{@hjBioN1;q**d1jJ|9XFt|}+a8-eF%ZUikwFc-CfT zgEk7zAX4V?5@+Hoj*|TDFJGzAKPq77y2fl`q(&!&Ez@VE!Ian?h4wSPKI3(4nJL5+ zjez?m1WYMJ_Z1{pB0FY3TfG{>d8BD+gahf#A*7&|=@p_#iKCV|POe#Q-6!i>jxjTd z_3*T}q20a7&{A^`z&Y2WQX2X_Jp>cEBNFpIAbuJlpoD&BV_G#H%GImz{5hKY4zEY` zBjB*Y!-fr{5DW|uZN^vXRzyF|;_PohymEyx%3tT`rDrG#h&6(_o&No^1(O)LR^u!@mq;fXNvVWQSK-a&cuIj;Dzw0lbSj| zP-UBA_h2*D@MNag@p=l^StT;wIb9l*+|b56f#w5 zk#S1dx>ci9J>Ng%_E!68S}4^R#ntbW%otT2yUeny=N>rfF-;&8@+M;LeR#z;cv`kq zgDz4izIEzG#l-`m2lGFpo*75jEZIux^1L53SR=77t3rOL>$pzxb$hG~Jm^d`gge5? zj4UI}1g2e-h!B#wkY>#?27u0Ur937%L!C{FJz=c!#cTMwa_82#vHa0~>eRGq>6U14 z(Mr(Dw$zO9*o&o{ZXh~ST$8U%um^Heroc*`Vn~E<0X0D@cCYY}Aam|X4}k1n8{jIK z>s1JE9Q6*pdUzQD01rdsyr`t&-W9a`v0^7_q42c(db#a7CS(|v8DPlVlbobi??C-} z7dtmA)pxNU`_n2q2pk>P0uWD%D`mw8gke8}9ti_19R}2q-ITv6!T=}(6>DSc@0@wCK(h7CJ zp85ivA(Qg&|4 zdyMO_rg-GyJ{{L_qsXb-Fh+zh8S8S&yRnRpY%-t+vAr7Pa(YP7pPs%pC@bgM&7C%YqkEdI11KjNhB7aj|)8 zVhM7ew8)LWs0y%1D&iyXVfyHp8M`q39lcq1p~)A>xP3aU5l_JhO?6t9cSo(s^jY0m z->3-Oz1PTv2;r7?Ij+yUWu!+wl^u9c+b&aK+1_%vl&HspC}B~|y!S=SEZcWO72T;B znwT44lWn@>RgX_t9jbcXi3AyLiS8VbGv_v##-6T-N{8#q>5HL`b~%|r&wKK=m*s0s zJVvJsb&rC!h|Vzb4<6R-$DXfQ&SVQxwHqB&Ieq<^f&rzB^j;VP*>FP$1zbpUMkjlhFVZcq1Gic>&vxZ5+^@3uX-7}wM$ZV3=&~uogAV~G`YnQE_7Z-Kx9xVfZym%`63ZVU^MLX))5rYnEBp1x(^(dZVv2Jw$p!ly&l9NFM7F zXQh9jU~4=_2jmUe3;1#y9ZCv(x2h7{0G&Hr2(gDws9l1n@0QT6=l^|_4tA{b*uLNn zjXS==(p~;`V#l7TwUen5(e_=`iI5rxtlWz^iZ_q@|P)lMl-03zbgR zit1Wd+~1f2US>0paz-@p=LtxQ9(R%9udn+MHO`l=_8@@Fb1;NzjQR?yl%TM+@$B=x zix8W~z=B@BKhjj%|e0)PupYpb1S+b)Nc zSTZ=V#YrGBdx7lLi1mapJD`kx%A7I)0?ZjG&_BFd()0mc9^K_LAOFb9>)Kb1fg4Jd zKJCEmh#vBreKH4M-M=8`SkD((&tt#>0Ad35+^f^8@+O8tYAvUriV)U2C4%DSvML73 z-KFwZr==U{MDJoF>Y zA{VI={uQRvppZVar1aM_WENNvgYwmira%Xj7r!abAYSBPGN*m+wb?Ja4h+Z{NWT(p zCVO&BSVze&licgr&8su}OpJOU=ZNNi^?kK`TZ{lE2V2v#;@(WQO$3S9buQ$a~0#_4QuOwUo;+ZuxA^{FG;6L}cvXmHdc;Qva zS(x^+h5gk}L;q$R0K+IqyRx*aYXzc-S80r^;-&4CQfx1a)nnRMivh|tREp^um(oqY zGz)c+E1MFzx@Y5{DQ=$F@fWJU$?>7e zk7W~|Z(Amm3h!!$XQXg4%NM80p&^}fzZpa0EYoaHz#k~NjuXfGz0K|4+Yp&V4U_Ip zErZI#EyU$rm6|Kx1^ZwT761dgt#gGq0^sN_ewIyFk8aLSqQN*9eYQ1d2q?%6pPQWT zx_0Vk828m`IR77KZy6Wm^TiE|NOyOa z(jX0jl!BC$Al=d>E!`p|D5a!;bOf41^KI{u@^3c<96P{ zf&|)rxgDMVL;Jq664d$bPs-c;r#6ev5Ja&uqrSBzyuBBS@{m_@r~FRq{4$_1b6Mzpx?n}jG(Wy@9v{*PnW=}$a_fr- zv5KhFVL&YYAs|)jg@7;3Ff(3n$zue%Y+kRg2wK#T#|Wr;2+P&55(zo|jkB&^v)&d_ zNAln^ZhL}F6y$xG*x04A!+4uo66&guUdA2veYB2gJ~ z3r`?5`U`Nsc^F@z&Es4>U6tk zwlzW0ns}E-V|dphX1y88UMUtlAzjPve>~}YrD&@wS8jJ@XFO`@u`Z8Z>d%k*^PSmk zqx4zvfk!U`H-3-UGCAhh`lh6^6Hvc&n??;J&z7`ocp54|&W%?ojez&=tcjb3;$y&W zjQNx+Mu1lxr}krg6$Q(NGFzKSN0ZEL0v!mbi}{&(W|Q1RDJA!^SxECOaofx9gyewv zQsWf;*TY?!W}hEX56fo-JzaDPRtQ6?5+Cv3m-%#mZ%P?;lXUWpIc3`bWR3 zXYEOnawr}(d6s39R!NRXwly1ZxAj?57|lyD1<1S`={f@0R5Pz}0ehOLBIedAy=&&m z4lE*^-bGq^5#$(x=~WUQi4GPSST7q)@-i}Lip}V8or_sDPuQ`ih8d1Gp=RQ<1Mp(H zdt%hNd&KSVSthw=Ipj{i9pOVH{_zN}v4tTU^E9Hr-~HWTRgLsEc4pBRm>SsI zhT!DSmh^sjRKce!%4d|V?kI6n5XB=#Pu_88RFCu)jJ-*FDHXwo{qtRRK%`0f3K93n zz3Oy4DeF63@yvPn|C%-*E+ysGJeO6o+-KN3^54$$Jf?mwzftG3+}YUsZ9CzsO+4XM z8GW`0m|-k^Pk5!hC*-Xhj0iqG36O!?-eh0)dewE5@RK_bEOSAh3# zB&#^y2qVhBU3wYY+2SDIL+F^ip=AZ(t-t+91nKvEDY+=K{-T*@h8(XG~_q95H*+>|6UXrT7jO=_cXaASxX{KA$X))WR3!qMvL=j3IyqY6;7- zZIs@hPl#pG(_tGs@5f9~c!OzmvdZhhqq7R=Ea&}`mK|igm z?6N!MePl>()0xMlmG(W*I`6{)`!AX>xygSk9D45=j1JQG{h6!6X|QljR^pr}2zTKJh)(OH04r1Dbj>aMG`GXRSuHH@#BCsw3A_ zf6}Z$8CEJ}IiK6iC2ftBwBlEU%mk58V;|+x{o+09ZuZ?bpq^K^>dazg)YpolGHj>5 zlIkGhWK?WIqVh6Zc}=j2T~vi*)VrzQjzl+KuebC-issC#-FT&0qrDx18^c*aweeK>?-;~yFGu*n5&&xRBF{Kd|8pvCWl7e%L z;<+pN7J-22(WC8HE}P~!Dak{DugHq)+iNx7Akyek=5AMUo7c4t=ONkKwp4UxUrtSV z&axQSS)tjT#hg|B2hw)O9%!3RtXK4f35A!E>V)tad0;)T7ap^!4_-bRRo+(l1mjo0 zJLD)$Oib$C@ma}y6iO@(lD3Ew{%<{iD8^-V;gFX48bqRj`YF2cWhJ>2jE}z0MFtm1 zgdWaLdwp^}InB+_8s%1pL|sYDkx1D4e(=q7EureS7|{w5_w0tcYc&hb3QOTLUn>zvXp6LjfO%q_+0+Y1FcL^fRru#qAagU4e z{j~cTCJ;{7pD*TKplyo%RRWINnGVew9-Np!&1q&JC}aYG!Yne2sCn!n3(%;8{%T#A>Ppcz6U91y-GvZfbA$xuzd@=V1r}r!NEYw!!uN82gmJaS_%s~)laCUk8 zsv@uJ_n;YyhY-#S_NV85y?hfaqu3kX<&;`uhL8`6=jZ0Zn36+$9k9h}zXc=(t2g_y z_`Ader`sDjvJzVuFWtxHc>#sK=I&yqx7f$@=ko_jztg-naek}UNy}l4AV&bv>^~s$;pQ^W>u%*Q<0DiIcx*4*&Cf_jG5H<4iQGqMPPV@Je(ir zew?~WtfGxm9uB@@=SRq=yET!4$%_n8jtVBndt>(^>NT6%=#Td~quee-b6>6tJ0}Mw z2Cs2wtv;}G>0-MWY~Wpe@@xaJeZ1qMt+HuVDQx1^Ma%3r(W z!Io7FGh6xCfHSi>4HzSY?;Zk+!P@E*8~ZJuN7_8Nu^gG5u|AIa-XAthvyX8zyN3 zMwxjV&3c{wOS-&sGnSqo?jDLNECV|{HXsj>%`x#?r~_v{<@9EL4b*Xsf?kJP9M8)) zNXu%r`E^6B zt|+Ar%eJ$2hb4|`Xq6`2PXuS>meEqONHZOZ5Zc~z8PZgr{>X; zkLxveaQtym#h z&=|ZN#rgH)Pc@7+2hYY0Pb-Lu^YlVg4ap#AR)8&!6H-$BBjP3hFP9ng$(UxLSGidB786CxcsV(&l)8X-yiw|U3p&?E*h zG`Qvf$BwmHn5FW0nie=l9>Z*-JN2V_1s_*NSnK<9&;ob_{Xj;ZTVK+e{1bV75pux! z%aNUr5DC09^Q2CW51xb^4!GJlM^*GlW1hA&S|2yg(S)(kthmW4ZoDUDiQUS1&`)v) z0~u4Rxsv)HH?dauIp4-2CSs^={vIz@hE@V!2L(0`E>)u9!0k~t+mziPHr>G|6+Q;r zY6^Ln4qA7rb*e5B8;^3-nZDbn`<%3R+4>DhqHtX8g-JvfzR*sW5oT$sR#RoB%}ga{ z+OF6eUylCYtb`2UCN& z%3D9(Ourn=e$Na;p^lu027Tv2aAI((#F_3mWA(Yg2T)LyuF3c6{5NCBz3Q(RgZ-A= z5m<7TFO*Pnja|kf>0-Q6X+|WGF*Ed{q5|uc+w`8B=FPyV&_D9IpHk>2Q$^DjP zrcTh`Ia144%}jKTV|Gd3K28z;jF$D+P%vMlw|@ zw~-f-?F&4`p+-rrc&NmXpkA}EV zGFNZ$TWq`$IR6*}`F&xeFSS~n4MLmcJ9Mcmf9<^)7Oc@$!i{rp*$kUD(`*285gK<{ z9PvIEJ=C1^NhAW|2@_>qcwFIAWd7%Qqq8K&MTAL0NrkKQq}9TG?4&Pee}de5`Zd^m z@Al6USDR3;cD%=W9XwA8o*w#+)`5OepF&Qo1VNs-J1LV_YJn6nw+Whauf%_!j2q;N z#Bm}H?0q75jHxUHo)u-~hFz}J91U9WDCp@#&~?qxEnLk1 z<{f;~@dd;XnsTL$=UXvMNZI2_SC|eb^#TLWm@O+0f^R09WEu`alyYQ6hX-S`xOP;3 zqKH;qTnZ30SmALqdtSVZL}=?1GAZ%j-5q)Ij_RfGuDjo20LnMVGbvc|xC$Wm*6CFc zC$Rc`gVqnq4E>~nUmW&sVPs_t_Y%y!0r)SvKYK9+5UtF)7@Jkp9<)8n)=3jEPS*$n zVF)k!Uccr%LT>BXI|}O>Hu>sdnw9;&2ZIdfyCw6%uOD#B1T=2T4@JB9^9P)ol98g8NwmS$^p?Ma=$POj5Me`QrC-|^}qbAK7 zNyyp`qUo`!(qx!P*T|F)Yy32o-iL8w1VQGR6uCn4VK zEvjfKa+H`aTdm*#KCdRGc{4GG&XKiz2CgQS_E>d1(S^Hw;Bqu_q=uP}z2s5U`@rLq zKG%8H4CH>U$!k_9M5>AUwkL8wB*?{A2d9$Lr6VfViWxrhcmX32Krr`AXU(6Ndds^1 zSP35bICphoIo+b-ceTxPrKls*t)V*Z@AJr|QDHKJ_Ms+XLS&txf#4{O`^3{04_L+K zEUdv##lG7Kn$SKII{p_cGdXCHj1O?xE z&!yIo7xK=e2MD1JNIa(Py`)?=Q=uWqMWQm~WmGa;L{#ivp9t(bI^L&;&_C_*_wgNV zQY9S6H&zT&RE->};zT6Y5o9&+^Xf``m3}(YX{0|Hd?n9Ej_Y5n=M+fJg_V%C5y_u7R7XZsW?HK z`QUuU=yRWHd9-WMhcuDM&DeVpc;^%5%@Gsvu0@4vEEmtxjkf{H-|u&c2aqML*EAHHGy|EJ$hqer=ALGoQE&tlYXyex`|s>n2-M$tm#n&+g(hgPp`vreiz;Q zdh;L%ClR`Iy#iIKYLU41TK#eDfKzjD@!c#vTo+f6+M=-P<| z5_8iY=gcjZeFf4BD+TfA3wrL_&RJZKei-r;uV&VF2LOo< z$!C-b+{wQ)1}cFe`}PN!+65)E1?jz#FGfe@3v07}xAGlopIRuT;Ij_eP+*)(7c=tX zRcJNe>cv-IE(vWx%~`!4W27@1d?3y(FYjZWR8Kj*Bm`$5(Uu3@&FEKvU-#O%`_TvRe*Pl;a9QtkQ^&SfxNJCjU(ajAfK({P)pG z$pT+@Q~=jrz)MqMxWy!gmWI~|g5}?H(8nGYZu=n3e8|erx4V!IbNt>Q$!6s>q+jDL zDFZ+G>uI@2HRt!}w$E!$FYXFzeNI#E)f$)^6_jVDq35@M9*^QO&HcQ3%K~$1)N35e z$j7B7frITuW59J%jGbY7yp8hI^=B=rgC)PZwb&KEgflS)==#82cO_&41Vkl%BUdTJ ziF>d-zAGLq`(#L7X3?yR%f?gg5xSUK<@jz}p4Wb}V%IhmXR8R|RVk`@_4p9V>d9k{ zaa!Z~Mg+te;#CN?XM;6yK}Fw$ry@`fY$h9=1nS2cCPQlR$D2S54)nCJ_HGB%53+Uo zr?R1y`oD!d{15WH1$o;ij!g{N{;4vah)kXS4eD`Xh{y@mE=8EUMkthy&7zE+si<0h zhetDl4Vy{}S8tk5G3MNASK<^nYt+?7KxFf;1#t6rfU!OyRv~V^XL5Jlq$pu+_&zk( zs!cqnoHzI}inP9){@3Fu3@q&y93EZARo5&^;P0ToTGN&~#)s7ZbOj){?c=yY50F0Zv%lo- z(ADhQS?9j5*%{*Z#%=uUog~(jjm(=-Tl0VOIN zuRAY|zV(*<0tK(f*D*djrYwHDHiokv8<}ASsEBJ@at~JQRGKJ9PdXlS7a~Zb$A*!i zHw1U%7l0f-m(4urSqI^GXn^%$!A;{%)U&i9@!dzLR%rkD4Mg0$cOqW|6LMR|w(B9Z zRp^%zw`fzbwo(v}TP~gDf0rdDW%o<_T&MAzw)MRX>HW*H3W#61<+Xj?uG_GtmcHvH zjD8@l3xoK;LcKv+ec;uWFaJ~%c3_pemZ&Mta&E5!+s4x*CXN^>IP zlRE&(C(9))r)ujEfyd$O+$w`0npbwrU;WCdX*2_3OrM<=8rQ+v;|bkCITm%!`n}ed z?cqx(ITw3CpYV8@ATB-mYB2rv|FSrSdwfRk7kwXh-`Zp7l~AdWG~k?3Kk7AOZJ0rl z4rSB76lSS|I{G-a2-YqK+%Q`51d-%q}?g}#Bv$uP0if64Pc`)|#4fZXrl zOot)xuQrrLci*j8H6sV=?(duozsT9)@M$wym)LocS;eiRM6Mr`{`zR*N&0_t1fP*v z#1d>a)P(v87D4S|h@q21gWTC39*KEOqyx0nXY_tXg9IYPS9RNJ(lGtx2&~}K!5qI}#2}vR17q+%0e778t%r6PSQscKe z=^%BZPQhuo+Xfo-b;Z4CE*cIjGqB$CwiO-ELnAL1%k-Iv!X3d6%)R?)LjiFD)3TYh z#p972_Nh`y76QIab2R>vd%X8NW9u8f&S*+@;nTwwNB}~GMOO+#gRCmj&N%Zc42BV) z7>#viK_tuZdlnFYV@#a2646)qXW@x1f&iEt;Jy;ZS*CGwr)fY&+YA0aJ19Xnvy^u6JGMnK;>pL%w;^)UCW<)3Q4AhmxX+;JyKI zyGH$O0k$2LEK(CtFM97XpuBLS8r0D(%btuMaGO2OelFF03(niWP(*D+XkYQ8<)`3C zl&5=YO5#_uc7vrjP*;7aa*v@w_b|!071vkobU7x+o^0Q<{)is6 zsh!D%rF~xp@!#IJ(>yhiQyd6#t;lc|xOm$9>8`a1e}B@W1$heYh=Y(T`I{YU!;y86 ztJno6Q+)n#5f8gfEvq`3Z`{fE$IDs8xQM?CXB1>?bg52hxE@URJ-3R;(xH#s9Fn*F zY8H8V4Sft~8e;=O+ z5~LD;Z_!i9@EEePXfX;3OH*UUp7cJ;G8k#%H(ziuPj?!X=&B6lO&nO^!I^z_P}4_o zXQsyXpOH0H`|CR!>P0$SRrrC&puRkh9Y6Kck_7I>tCE&YxrRm9OGYMZC9e|YfAj2+ zOVsKjDsw8m$P0!_!^w%7jBVt+(ruwMIH*4(_&nD>XJP(54H0YGCF1G==DXFe1N=q- zkoCF(2tG_Q!M3oC@K5U9|IBV-kSUPq*^&3nHAZ#Z73a9H_NVK~n`AA5i3iytlXMma z%RfofY$Yl&VC!~>$JEX<1e5*Fm2G_Sp5I7G`?o6EHbVp*1T@u90y(3R8|I=x_jo!j z!cnM0qDHV)X-nuzH~##y`KLUL{BN~RTrcLpXVoz8ZkXfKW!Eg_sxy&Y8=Lak8K2*h6#uF~~_8pfb#p*a-5S46v--vkkmu)m4%6*_K)L5_x z2ZgM@oa=8LgT`I$zKEkP)TD#?YM<{G=%d4_ppRTs0PYWoZ1)FjmQA1{#-o~7 z^67txAQF)Em-#^~miIAY(sMoS!(9zfVSU4DW8GyG4T{k82yD3uf)G)iwhRP@(e|zJ z!t{4OZs2+%R4bI0_$felePm2F-i{6E!vSmZq=e&-B4x%Z@)a)y4l=9;xCpGM57EB9 zrZa24^u*$|%xk&_YElsItrc!u?s&~}v_dm1YXZGexyp{aw<{N7a7QHJnZCcyOZ@VP zzO$ZJ;)jofEl`_}UVYDB9K&xo5wtgcmHi=SU$M_inQE%c+SZmjSU{xLR=EGQG7hhi z0F6ln>Qw;b_=1FtdqHls7^k;f%>Q`szBac5w^1gj)B+WDQgWhbX);}?K32{6fzU}I zS;S|rt)36&2T>&Ok%M407fpEhEN`dcwA@8X?iDKhQQ!)bOTiBGKYuKHFfuUWk?Yg6 zEmrN7Bl@va`^Z{XE*l&VzqJBd27lxU+yaVPAx^wwGooV{(fnu1pqOxz)j94Z#PS84 zkpE;HrjVzI?c>@d;RoEfQk}|w{coLzjvv~stMuKKAPZQ6b3>qbf7YuMBs`4Y1psZ5l7|NHom zKPcS~WLX3;xrp-lFbP8NL`o%%9kD$};%) ziB{>j%aR`@8Mj#Nr&G~L<-&l#t?ieczj@OL}6 zf9r>&u+2YCqxQ_Go7U)1)<~RNBtdeU`1bZ2flS{M=+g?K+uKG;qZv?@mU`*!&@Ym? zuo4rxQ3W{tVOxJYaMo<3)hnlP(z>>OVf?lrEnRRVDc~+SHncQ_jc%_*HKG@~7(`BCf(n!SJ+`|rc>NbJYI=)ef5i%N&}|5yc#^kj{pY5zt= z&7~a*>|d(tpZ#2D3{%18140Yj5E@>TAx}}ps@3c$1qD~sEs&tXR`_ zg)yu&lO@~djuJ>@0e7N6*Oc1;9c250V=YFvkJl(Ty5HJKV-=cJpd1it#s|-rKc>=@ z->|{b9{0>lZ!%E!(tCbaXGQJq%Oa<+JWI>wlzbj?E?5DGl-!{si;&Rtw8cOQe*>4Olx?db?@sW*uo7d2PdPuJCtH_<)0;gR@?|#_Lhamr4`RE0nC7nD zl$xLr;RgEGo#p_D8VaXFtjVmZhCEusWSX}#Q|7N+r4Q!?B3ws@lNeoi?uye2xrTRV zaN;(7WL{+$3yTF zaAmv(RTs!cu^N3Z9SX<1A!6@&V;5H*=f7=!zYc5&E_`b>KGa32G4? z;!VFL$Ndm;8G}XB61sJ6yTxiJddc(3BT@{{I{h;__|=qJJ?=ScGw~Qnf8SNB8{Xj? zF$a~P4t396BD%rx#24Jt22Q)ezSdv<#^l?-)f2m%ZFOllaK_IpMf=suujq`baDuHm z64+|zAt2p)dSMpqg8H#Od@t(Yo3m6!Om>+3IkNl$(8RX>`9%PFNKjM*>?-3 z@x7}2w$$GTH$o5nt_K?nzF}O|A3uqv`TE}(v8-ETHLoG75lgYN_}o@sh@CCJ_@0n5~IszSjK^RAFOk&x36cm% zEF4+w{_?ej*<2(`kXDTE^7zUg&)!Vf`iy?Keu9nbWuv#29i5f8`BZcCPUf$>nA&nZ zP8P#iFCYf4<31&rU70pbm#bWUC|WIyeu0z~28^2(OgRV)JbM*UcPO5KVi2=Ci|w+( z>rHNiORMCigsI-(9ugm&k>3%VMEZ0iy1|ZhLo}})6^5LL&FL#M?-nfKd(i;H@p>^@J%rC!riv;r8_UmQMrByJqMfaAxB+xH;wfi(aOCj`|;~&z(8mC zUca70isFWTH(gIcXS85?qRK!hl#)ZlAo?DQd;!-=bNSj=HMgwnQerCh8LeD*q9u$^ zc~x{H{&*-7y0CM1L>Atk!4{cyN~k#1%j1I{%cKUvO&?aA4uS-k#C0p zb6JFyg*H{Eog=bxWi9oMF#|>!7Kv^lwnbXD;f6& ztO)U_n<3`N4V=y{$WKS+xq(@mvZvcw(s83-QPCjX#+*ogtiC5YcRLFkBU+c4;d7YutnIFN`(WzovskSl})MOfKJ zaI8GRjpZZb97^iLuFVwM;whsEZ{2r|}$c=&H$NwFp zOdEDZL{%Rz{(tb-jdPrhF#B@w!G(`z`e{2$pdB5LF^)V1Iroq8n}G--&~o8Vv@cSY(l~yzHH(%YIiD8xGB3QqkvE8SV<*MA5>nUlQA29 zPV=(<6~R{0%`TW-e4?f62|nrA8{rxg^~vpPb*-q~CXdCHn+}ujxAgzWNF4oY~?w1hRKW z5@uv*V2&;Sxh&-o|BelCurIRK5R*4}2WyHKZ_PbIVYlA({8l3COqau}cm=^v&3Gve z)H4f^aVve4;!%=k8WOr=QFv4*YaT^R%68$vVO5L!vV2pG8v zn)tJC#;sb-zN~>Qsymlg=Br9!y*!55&w@zDh)217!B95X#b^5P^w>>{J6j#Og($Fro@Dsb5FzNTq(NV?XSv;5 znqY(R5jNwA=4mz~fl~D3bka+Rn-3ko6$Dca$VRCi^l_734;w7v0XD%5u4$_7A@4*3 zs3C_=zAN)mcv;@BW`#9mszQD5bDm>KJ1^LHpSKI{I5t=fguw8&Js_{R~DZ5 zz8dZZsxdl%%jSl*W`s9WeuO9>06PGIuOprwuG#*w6)wICJXEs!`*+5)Kc@(AAqR>< z>`#z&QxYB=>j9szj(+3~?D1jy$XzERaej_}uOIjQ9+)u?<%4jMayex?!Gp1aNlkim2}T3iRQri!j5wT{i0G zc*@*PPHWTr?t@;+<06E^DD-QVqBrD<{!pSR^B>T%T#Wpaedvofy96Ram|GZQX2w(j zSC}pjB-6^_AqN@L&EP?>!LvziOlEFH7V*czSGRn#Go!Z6mi2!&Yxxn@P&U7S(Z9Zd zKl%UfpG{(bh$7qmmHYM<);VsdehlxG-`0qH8^VyP#~uUL$}Lrrm^RqZ`45vb7TysU zruh>{&9w8uK|-<50v~Q;e5C&}`tb8FVvhTx4-bcw?&8{#@u7OpTF;tXHz!C2H9Ons zULjZIVXB$*9$rg?10Z3XJNtf2#lz2UqT4j1GhHdezD9M%4$x<;vSw%%fG9RyJvTS>t>$6EJSJj2_O&mW)mJ@BlaU6#6(%YBlLS-?)vbv z)8!)rtdv0BCLG{!;ftRP-ReB0JC$6(DZ2KueD%uN-|7M0t-r5ZK=xT+JPS?;fwGuI zbEosJvBmI0X{?0APT!)bPC8AQe7>rcJhkhi4ntT&*yJHL62GoTDb`Y*eQNk_S{o=O z0I7Y{0?Lj2fP*_XkVNQt+S)pzd)vW4RCKbSE%1d&GhY9_ByUxdBGAka+!TL627 z#i2Q(2wiFjiUcnm4A>Tn4Z~G&cj6%Qsp5@Tfej`I>@tRl;F$6TF@Yv~rY?pi*lgsW z^{-N0DtC#Y6Ed*M-~VQ<%H&;r5fm7uZqu}y)6Y*x$~`cmyn5zh!MnN$2ZeQqR~rN$ zzJ4srB^e-fIDTs`%t+<(ZUlKMK0~L|V^u~zlrUw4! zA2kGV@ZwWCTwY%x5Fx-YVjkDS|KGm&w{dgd?drn~LsnG5JQ zwswCWcVw`6T@Fq&3 zuf4X)j(|u?6iQ?!^X6c1eAVU6!HBNKHFpa8TLu zIW%8??H1G@NRH%hKHX^jg&ksWDCg=ETh&*w`(|%;=2-O;FKY4QE$E=Hp=eb7ci-j| zc3qm3st)`6{cZLnSL~{xgTx!qaI4DSP!)EJ-C=CI*vF!E4uF_F#wx@2tsun8M7!x0 z@>rHe6v$Y4JX5!HiS8KpcOjp!Zio^3eZTaQl6!Ev{6wWwlXSV+;l*d^wLUFsp_)na zTeB17Xh_F8C0&$$*KS@zUwkehLTTqvEj;bgSm7@|S9X}sLe;cQSi{hvNgz8|Te#&*!?Hr2Ln$9wz z-**X+Xs%df%-ojbS7q!)>GpzSVQV3m8BoM4S8BJ5OqyJxRB#?VLK?GcJqd#l$=#{m z#jT>jMlA7IEl=FY$x@J=4JQtli$Hc}qp+l-xbqcr%Il7F>V%h3pRH$jJp@v;!TQk- z0|DwcX5`REYowB8TVqI^5@yem4WS&_MRXwxj^%d4yeCrJ*_}QS4;|uBLVF+bw2dcE zBD?De2n+1iX{w~4hSZtIWnKC7m8o_#B9HC`^&0u|A?cKC=XJ@_Tu3}5Zkmf>ni!jQ zMmpA}>4roFR$Y8{6y>|+iwcA2wP6Sql(pxS8wr!VHtJ4`3S{PPaSC&w+wBR^$GOAD zPZTl1Fk~gs6ysa*+NkJ^^wQ41Q6QtsmZ1qN*T)zXBR`NVn*vqzE90gOhY$+Xfj77# zm}A~=6WR{H6WWKt7*z3Ay)$)b8W)B=7iFllzK9dEZR5^sV6S4&q+aoJMGWY+@fV%7 zx=^k4u^jmYNcu=0_7rwOZ6_%R!Dzgm-1a=;nL|8*m8faIa{tbJhq2Yyy&P4dnX>II zCsk;h9(>p`+xHDA=16T>Q*O5w2xlS0y7m{rWp?A0(_gY?pV;c68YO2sH(?_4xyUN2 zG)t|@l`Gd`9VQ@E`s76eWplZoN6wPD9LSpR)G%+uy`RR6ohGeyJU`puA9M_1@DB*B;NR8?Wz;DXN)M^|Dhl7LT zYuP*T?;npRI_3^U<*rG;b0_&wFyfha3}XschTaNeT3ouh*xs$O&RooU^4lGC>}%mx#w-Ns;*nZp#J90J)lYh z*6UzMJD~BBxlbp2^?nlw4tOJYONT*eMp>nLGl2fDj!6epLFL&?N^0F50@^zkts=-$ z@4|>+AW=4ol+N7$>?r8N)4Be>~v?G(St8VPzSWotE6E&M;_Sd z=KF3hnQMd$4mI9+arstJ3KfskUA>wLrvFE1uXS9Wr%<8s8D`%f^2P(bY9jwG&kEOL z{QNFxy9j=5*$6i5bno&L!k#oO7UBg!QviVFpWndtlD?6?mStc9+pt;^e1uIlI!N|Y zEvw8S%+|T!&O3px&MxaL39A%_!Fy2YsDjtn0KgGG;L36q%cyNJe4?lQBy`ypxK$|` zPq=^n;ri?VTNd&TU-?5>5kx?rYzr?~pL46sh0Z97`{Wh|0G0QzXEVjk?N^+VcYp%_v~mDE9(J!LfcyQ-E75 zG--rEAmLrovtVuG?)`yno=+QS{FY4Mnxh5lEa2&)?LfUU0hvU{{H4I3)mJBq4{iW3 zk)i3Ym7i36eF!H3z$yltg!q=PVT9U@2H_xY(*pFRMu7WAu!}sCuZ^0w0@px)0Mz_P zL%1L+HW`=%MamWct+|gSXto7El}Rc6qgVKnWV1wmtBAwMkq(=&Vkc?`I`~cEIP6j% zC2gufZ=Qc>wZ4T%nOL>x9pu8Fwe6LAv!yBX`Ocm|?|D1Ud? z+5#Y1@y_4#7*_X&6zYSvZ%OK50Pvzl1z`94FD@pyZ^HPY2*;s zgm;U}=5DA2=w&F(weau{;`P8!h6~K4<%XZfyGb*(GY!cOiJoWzfGNz~(Xl6fkOIJ~ ze`o<;S3wfjWoKferE~}!*BK2$`bs@q4N}^IBii z77_rA0#K~sUs1*1no>FI2OI%9s?6WLn0{>^2d?)pk0t|4>qsf3hd=%g>nG!1S8QzY z>5~2BeSQKy8Cj_&?ZX_c`XXD{1{X9}fA}NZ_m;$le~s9h|HDB4Y{wShI0bvj_Lqhb zN;m@KhUK~md3G8_-mkr38O}zZa{zeQcpj;8sirS$3YzQhVQX4FTgWo@t+He_tZs?7 z1Ycm$!r4c2U~)J8T*CqwW|*jVwl!qE0vL0+c*a_rMLsQpQGQ7&4Az|wL#r|N2eHf; z9B*myw8s?cw43zf1e^Jj?h*tI;vY z1=)ay2__pAKsMM+8+VRi)${kGU|aH!?3wkR(q!EqwYBQBZdBH;aC+PK%~)^wCjj00 zmYa2~y_qxP1kL2nqbo1=dlDs%QsST4ayHn{EGR`2)qU&n3Xek%8!K*ebBuqPcK}sJ zgiCJ^oJWez0;j)#c~H>zdd?dA{4s{T)iOsiDI5dZ1Bprgb&e)nGmfnhQFXOHf_ay} zNxTltkN5P$K1?|B(xQ|ZNYstF=5^KS!ym=xHcWz8JW^6L@XOwaPq1qwlQNjKPL7)jnD#Zcf{M8k}*Vb;{!QAi?w)VL)PdwZ$=-w;)<)cRmjB)oyjyD z>Qb(dD2|H5ua7wNEoQzIn>NMVSG{60tk_k1nPa}`(xhaPQHee3dy$O^E!D-*4I^~5 z47$vQYc|EsyKp_B^%ouKy+dE%wU;{fo@+d+q=3*1-={Ys3_EzZxBul??kg481&#T7 ziQ?RZ*0{Hk>G68U#jtn{A$k{5kfw>Ve4>8*-T=sc`L3%@Y09)YLchu^lPmqoev?AY z{WqI#PlL=Q7c?r?6xL%j5(Q^DMjN%;m-3 zS}kKHCfuu4PWhc!>X|*UH+428UTeGZ9Xc;)Xq61Fgp!RRW5t$86{tt#<)lJBkmq)zZixNT*m}mFU0+ospoC5Vyd3X;>WOje(xO2 zo-y{lkXcZ!$RRB}v%YOjkL!J96j|G@&4kRrgF(h%yx)g>jFNdW(?xW=Iaw2r-P6X+ z^hho-z{*b4k~*v17Qi-@OwRFZ;t5yau+7oc?7{8<^6Ke$x)o_3I=i4T&;c)*eLhL4 zv;0GUMi+{pu$$RgPvQgnFZi|B^H9nw3He#!!MhZ^kM2I((CYNYN_iwv6ut`Zw^d#G zwD!Ct|5yw~y3Y{>J5|7+p>$tOT0tAGY<};QQmZDu zzHr+Q&$Rd4kaW86#R*2Ti+IIh;1Ke?gxwFND}5Q$Tz+w9HuF9;@6Mc+LPQ1zi)p;g zxn|v>@%sL#^Bk^e4;UO@ka`BzW8l^q)S+T~JL0ABoYImT%;t8#Q!{V+V=-b0Nhux( zPxA50=Hm?)ZZEk#k2h8KujiMAVCS7V$NP-Y(!~(=bvhTF-Ih=7m!4#hZ?J+whkWH) zGQ6{oJXa&}K%a$<6fU`e#72vG^s7C!{ALm4uPa}at{xNqzFCpGyE>7L^B zT!LGT2YIC7YSZ=jz1B&o8$i=;euOR5pP=M&+ecZa(eqPD1sgNcUVRhHy;1K?l&Q*@ zwuIS-MPKP|_HTJ+(RE%UC4mSd0x6;Wi4Jo`;Cg^pHiq5a&!-FRwWA#xN6rRH;@7T@ zzZ~@P4pvWlBdsN60;3J01-r0QB{*XCU`;w30`p|VS@i0iKm$u4J@f{&Ud#iJ?!V`n zTa@Pmei?Es+_Hd_&%1&@i0DhP#~LTJivQ`AY&RZn$Lr!abzoFcO;|Pl;cvxh#Ld69 z;;$gI*gl6r&XZva)(H5=hg0u2eDh7YLRE3~zG1M2@$uHUdynr4Cn#>AYm0-=LHkgX z@jqP+^?rC?kh?I#_tr2RwAwz*@s&F0j@F|)gh&g^<$nJ#H{=e{KS41$R&tDGV+}bOos69Q zQZRL$>4}vhvE}jr)r$6IzZ%?4S;7kA)@eLCkp^>%-TJ#_{d8Hp7hD4*R#Za95>{tx zFBtXLBJdwsHSV?Le5qf+=EaX7k1%_nbdfzr%E`ndHE&ZHkKVGjD^~3E#m?W5`D|r; zcE-@~xY*7%HMP{oygHZmNXKbbxvvbg@kXz-vk+!p;5uAG;4ZdnF2YOIr)k2Xlja3b zRhTdNk9y{1$9*r1tFnqAXxSJJTx3KdZWC9>@d61v)3VLi%?AQc&f=e$+=_Pne(7qk z9zG&sd3vy z5zlz^?S9TOdo{)Dm!`8eh-jWNn9E(dd2$HFkqTwB3DqjrJByU@Jp7bVuQxEaVE)f}} z$woGHn}25gtmt6vvnvE71o$-`_W69eW2>wC*;C?chT>|3^SW^euRcjCvM# zj;e@qcwUJez*>+5Hh8H3k59x9_j`f`M)H$G*>2i)#|K`ph8yil(OANnhHk*fHoc6m zS!`d>%Rw`+JCGEPBs%b-Fi9CqL0#}>3JKJIq(*yc9+%=OUrJnaV3ZD`afw;#DG0oHD7SiRQgZ(c(4wT zfFMHi#zFXh1RqibZKj^Eh*GEdepc$}&cpxpb^jH5faoqihUPW6`3^C;m&AU^`zJwSJCh#9++Lw*G~u)`CMy zscFQ6$!x66{KsUyVI-5sTH?uvqzwO@qhW@e|83!O{Zce&4La6B}<{lsX-qo($U;2TS|WD&@>zZ&!Ik4NgT z#>>FXs<6+(&Wg%W{k|@?$-n>F{i4#2^n$7jE?KX%!$H1{X`0jUWL_!CUkvYD7Y>~k ztFkK8?~=O32OksC@=d+@7;MDr@e<8lqst#e0dA+Y<$>d+>~Yd*D~0Qhm@hRSv{nFa z0qpeD3ri1d3Z#CHcA5Jb(&pUDqllBsGk4-LOT(R*k3MorN$^rAGi}TpcX5aDoKI+z zHBjh~fu%bKmNF(WZeRO;St%(C+f!xX(4`C}<5+ zligejF296V%*9Tx@8q`k8&$~uP38l_V;$B%renZo(K9sP2KYf= z#>k#s1vpoU*W)hwU3@s#OgA+Ty*Hy_YqIiq1lN|Fq$|IvfW=yr!b zMWjeu7}9$#j<*PRcYg+*QQ z0fG0}U6q|;;>kUQXCBj^qdJBv4<4%dkE0BB zjJ3@asSL7V(D$E_(mT*ne}}9r_E@vRD8MX*XVdEJLdgZ* zgAQ$-8raHcw;1%6zL~!G(X->s{s~!nqz9D*J)_uU#*}BW@a*r2sM(2l7`qKsK3NEl zb6aTL{Mxf)cA1fg1m`cnqGI2P$62UYfn{~BXuly<9UYVx_*vD6ymA4qS?0rY&8J3K z+iTdn-`486{$JxMH|Mmo@3Kt(QjXa?8IiDz6*&fUk-{tO_@#1 z%zb`8pkC+LE%*Crtn#V#Z0)zqD$6}aa&R}9kX#&la7GntD(|)u1nw;2M|jel%(foo*@;*9yF;+)gA(v&HZzy#Bc|z)y5ypy_{J)dU)Nk zQm>0V@gRO+>#6I0FJ##lx?7p479^q&lyS?~WsS*+=T8V{rK&Lyvq{{FlryI3rru-C zuU~M0P&#eoW7TV%cgvZYM#BIeeDhPbBX!*eOot?7aGh8+KmI!LMw0b~psLxvP_cjT|O!+O6M+#qPW%QMe`@h#rCbW)meuY4() zS0>~q{pfzs)hK*aw24yeukyugCqh+9Ui5&X?dOL6#P(!DvqKkW)M^qBRkJp{`tC20 z%dB=@Bcj9#!ewqPo|bug1Kpd~B9~3je-rd;mSx<<{|9K7mN;q^^%Q_Wti*w0305-! z$H2+*_w(zoa#P?^lq^6$_?~fQ(pDA|)wA_Ll?NuaUaC#VU-a57jLoCU6KnpWFULhu znQ52t%@3srh$)42iq|ob6ek<(NyCRy<0U$lDqsF#ypnd{;ejM+2ldF0X`>S>RjO!v z)}}8Zcbk5n+Gt?qfn?&Wia(s^kGs9`olA}2$A8}9Lde#peuQ!yS6jL-nV7sW?zC0w zJyU+qKM*g-(w}pR_0sEx5>hY1oP3+%whlJ3mAf;b=i?3XOKbdqDBR+9bV@$m+$M1f zZR}jgA#-dHa||IOam|frSw225MnBVCCw! z&E=VX)H_hKfBpT`p$m221&xa}yB-FIXE7N3v+ zltWIl70-6p`ydR#a>wN-Nv$R#Y~r(6joss92eUhtSsv(X`5nnW`abqQ9Y+SQPbtj% zyjSrfr4tY$Lf1>pUJD5$?J+5+<{QC0Jv!#XD?X|`M+l`Kn8-~Um-%FMBakqiL*q|D z4zY#e?+kP4=0Ik~SS7jT5S<%1#QR0P%l0=h--}mmG`p-hu^om79&EQIt3T1jYu7MS z`+h69Gp42~1)@lLtC2QGVmQpgp_8KAOoacgsOH^zFlnD1f5lJqX9!1-rq=_ej)!%# zV80;#_w#=I~sk8RLKdI(FBE>l9Ff9Wg zfMX*LbxZuwZ#FeDN|Z|6I!@$29Y67(Z?i80s1fp>l`uXJ&!Rn~{iAQ+AJsYLF8fJa zo};umH9PNAPlqjt{?>!d%<%sGnVUdu02PBT0lfNzjien_WDXeM!ZzrW@)yPGHWupS zEp}j3o@_@dfcqe4vV&%*DgD7D?=s^!4{3jVD4q>|x?$nY4-u}#V)g)BAxw8k{jg4d z!4*Fz4RJKUN!a`jI&Y{T#IBR_@+$x|*=|EVwQb+qxAyyMCkqKbs@@5>fHZ;=TPRzr zBsgq}H}PyYKg0-+UNxJ0LLTy)e>bu9n^w@*na*|K>t0CgI~@SR&vNkbNymy^G?vIe zO7G#F_kudyIw^1v?|&}BQZq_3wGOc;)HErR>^-1jdmhh#iyQA%)&Fkd+o)&19u|Wb zI}J$~dj&d$EzfGbzxX-tyH@h`v;TZKW!Lh=j@)JelM-EI;Bk|L1;32H+i ztNG(NGFIhjxfT0O^-6~{q-qqo0nf~s3fX*huSir+aQXuL>Jpnd_k z&Dt|7pF!dgNh`m-BUv(VB;9SxkPx=cjXpdvAED-;%+R9>Iu}&C;k20x{IioyCVYfz? z{ZF!7-t4B=iRK7Q=pGdd&210X5tFue*W_wa?^*_Ju3$<$U0>SzbDQ|vOnsRYNxfb` zwD;Ip7cZe6&V{3SUrCV~*SF5J2~kSQnFV#v?S?+u9_-{O#rJl=hIi)l>jrllcWOZX z0D^wb!>BC0>tiMF2^$b5JdpT+`|0Mr1bXq+jp@pyqQQqfGAcg9;Nrt=pCyOv%(jy` zb~@%KchIz6hOR4rNxt_JybelM7o$t}j;(bAfH%1vl{cDfhfXTl~Z+xg>TjcE{ceg;qvN=A;DQjRfOFAhsauc4$8 z$?l#OYb#Qh+$E#?ic#F1aw34_wJN)G0)BO!&gVpw6mZicbnwjbDosp8P_g5q>3z}1 z-}%045L4jt!2u`BXNs-dhG1-~ov}fB5c}O^keYGZv+Mrb^Qot9)%w*>3gBjs+qH7* zXbq3gjF45MplJ}p=T#{X%kt4Hc_8Xj(cx}RUR!ovas?MNCaJnP=qAa+om(oO#mXJt z&aerkKt`t2ggz=Ub4$$fBj?fn=N@X=y#KvE6F&6uKSK0(G zMAuVqY}Wq%aCbGD1XozRt3m1&UW0G!lX>9gH~Lc>szj4EZZ!jOqc5~%ud^IHaqOr2#OJx#F0(1VS8mnAa_02BknSUo zW#Jl6)R!BgG4!~*+&9r6IbNi4fVAwBj4}7B)&8g@QFaTXTt7uPAL0D`Lb>YWLd{9j z0`kE!K2Asq>Y9K5qaZCApCfyH7URy!Sm)}pxL`6wd5L(o4F<852*Ad)ue~jqWOb_Q z5O^|@a@z@WJ|df(J#=m^NdKZ*{nG{MmjW|p{bLF*u8jBc-v*FG z6SnJ03;y~ZsE$FS`tMA?Y>_-K~wXA z$ZA#}izbD>*Y4}n|EyEQLci~I`BmhsWzgdy&%u+a4(QF~JBOq`pBWczYZn}E>EB~8 zB?`B^E)jeWTb$}a4Is9bvD?*A&rXG2w=tqn+KC|K$E`4g2 zTB~mZ8#V`}fuBX;9BNPh8S!A5CBWrAE>ch{3@F4S;W>5fR#Y-mwPKq;^C>~2mRI95 zeg;mYvyV$AT(ED$PfQhGZt{B?cbD6Rmf$Zj`jiHA_}aqLUwob&Di40`Ic%-Gcddan zBKt@f3kZCp^hhQq^Tk(atYE<6817lq@+c}90M{I;Dz(^r7kkWay4G}lA#LoTk3{-c z(XZ(1?YDwI`C(g9Jsu5Ncp<-yoj=xx5EPez*U6p}TW>2)EeWZ+_uC`hEv{F+U+2Iv zh8Hqw(;f@$N-H^^!eN-5*qhPMpcJLi_n`H7d+p?i{PqnJktGeK%+gRx@ zegI}e{Nyb!L!%3%C+V%9S4b1|Ht2_>6_(Tvo;K57ZucAFwVGb(=lvoHWhlaGAdTiC zOYg{;2;hge;?bxZ(Gt#;g_S zw?>pS6OvA(!}U#@oZ}l|bj|MB9XvXY=9=!_~eYK^1H; z{XVs&HWGZ@_rXL>#FG=gcyWvSa-L26ASB9}MXRmQ+7|LO8;s_`HdA4*%+Oy5ud{bf z{WZDo+Ha5a2F`fTZdV!8h}o+*Pjqkt{qH*LaYc<(uk{FkMK0@ahSQOp&pLZaNtx!` zM07IvgM8&VP8I7ByNLYL*mXRV?^n2RP+TpX+B71SdrIF6H4Olz0vFYW zaboF}NYTp6>Z}U%#JuW67>@aZ*y&uaW zeDemy;E0*6WGt29SmAounsuS>`Joplv%$Ft0;Gow&uyQ!E)U5+=X`Qc9mRVr`uI^- zE>FrF?sQV~;M*riN^~f^mTy|8^1YaM$V_<16ua!4s;9apa9=!>W9)884t&Jy9t!cU z;>?0O-z=PbwFzzX16qSEsraR;%Vn82F)w~s*gN;N*4}d0kIMDH1P2ZO z?2nk*%#r}E$Yf$jD1o3dO!o_1gqDg@$Rba3&z<+JX`jPP zsgOYX)`u0Bt9gdVdvtDY(fP}o!VeFEE74fe%H=O1Wu5)2RppMDZ^Zx7g4lLVb zee|Iw7p%ARxp&ToNDa|f>q)ZWoe1xPz(?0aZtH-U@sf*opb59_@S+~!uq%)5@g%R- zqN}hodsW7<*2msF8qYC(f4|Riu*4&xUI(^-<*iY${&m@zp_=7q-(^|Ln!I1Sj7kfV zMYYOqlHoicHZK3K?b$Jg@=^y@TJS$86P2#-(aI-pVHSs6EQ5?rb>ivh4Fh`*3cV^N zS3vgCU$B&cvyK+YhPOWXT3a7t??P;aZ8;MK9crD428V;s$X$sdE9iX!VRgRkJjQnyomY5ugBv2Cad(@ij=20Msge}UzkKV$ze5STp z4F(+XIPdk@ADoyz9KZ(c(7yM(#=Fdfywe-YCv zpA_$}s>ZE1##1C?YH@u%al|zR{r1(tdEM}@C3DRmUS2+O6Z7m4sQUQMk*t@%=Yc+K ziq59_G{H!0H^O_b3uff}dK^>7r=(uBe|(x#|6x7Le6zkKGaz8ga6wx^sg!(>GD%`O zR`~*Wy`v_#FqgU(!lDz{gMWp7^~g%Jof~?)KD||*4w*fTX}P~*;*MWRK0tg>YwN-K zcAR+wd%@H-ROk;d>62}*VdvQBz7zPoi>6|nHs_PlOIs6CQ8%vu2lzX{x9Xl&Uj~_w?BP74D2-t=(sIIoxt9Ma4v+DXQI9_) zqQ>MtjcKI(Zfq`>ki0d{m>%yWX_{8uz{qDm1z z|7M(-Qi+^nyy;*>8Dw7iEYn$4e5fG8S|T8IQkerFo!{C;-s1Y(bdFOYnee(pqh{u%TU7YqiNzq?250N}6alFt`@ zxJ5QTBuEBEw=#RYnh_b$0J>TKAWM=*w~UEuF2jKV%w$2n&SlC;66nPqFN00c$J!00 zUHHEG_JgY`GdNcE{o^<9dOW9$SXM7e@v2nwi}WGr$KopzrK!aXtoBvWbJFUh{Wm2Y zFG`NPyvAjyuL(Lp>%y5Jf|r6JUCdV)pNyPbKMI`jzNJABGWAiIDSfkb3zQX5ABw`u zQ&`wn4!aa{Bn%3;YCvVp>2S_fvu+W!9fEHw)S1`p1D07Fi*0zZdxH67-LB^d{S$#; zq7{P*0RIih=JT#=O^A0T7W#}W4{vXPOZFrwmEn^tlp zkck12nZy0E3(0%MnNy)Pgdyz3|l?MM2Yx$Qz#L|Bg9!dd7XDKM|h+zFk4mH0* zu@|mIUa6^F=6b##raaSeG{_eKTHjHd_dj)mUwizu&Bs08s{Zl-m&kpakwy8pwE>KT zbhsDj;T(P>MQmV(e4BaQd;$v2asa;cPpIp^Rmvll@34sZt8Xp?Nz=-HgL8d6CXzva zd$v#p@8Hq(%&Cgqde!YR><0Zt_GIJvSKq+Z9-<&roM5Eq|FJ-MS$GrvDC!_W_>Oy8 z+keETcDaM*FrH_v<`&%Rcd1gWjp0BlVRDny0e`khLj}qw^F9%XrA*m=)Rte;4gG?bKXv_bzdmQc z#pb_Wn_}EmFaMA21aNuE04^_r;Y*Y@Js_Xh-rUaYm`XuH4mm?b z9{#@_P>16h?F_o;o`O>9-fJGveHW~qGxWTj%!Nq zYaxZt_sDsya*lOrgy5KkbS9W*L44?hT#WxfaN25g(uxs%D>vnVRY-2%Y!N*!z=o9b z?}hIKKel=K;_=h#R)E`^5cEMm7^0FX^p=YFu>Q``Tf8Jgt8)*@IHzwTPYAy&aDL;= z)lx$C02i?NjVvX8aWn=NT!+2A)>EJyX33?c-1q%tZ)mQrZ81mviIW~}$=T$~!JY=jBFVS!x%p z)nXJl^#*LaT?ePEj|JP9!__h!KR(>=SHe<5VehuYqzWmSdPE< zYD^k#+v7!_D~Bqw76-Qj^A^;$Cf7OdkByOppI3$3OxR9@EjQM#&0J*r_x6CO<8zKQ z6fhvb{)8N|4}SUArBd>G&~xewuGWq?8gd|pVGk*XQJpVk?xP`AP}Z)BrO7##Y$&~t zGZpgE4FGTv`2tf!+&q%A{1dG*00v@O=`IH1slPoTo_WtlW4{P$e)cOTL8U%{?Hs!1 zYM3QoGh17~@q-{WU7in@@$wcp&3~QiurvsOdCfe1hLPo&nv-0z6gWx)Bdhe^$iUAW zRJwfa?SpL{X~fa1yc0qI?z`5!4>Y1;8}bXe2X_6q^j|F?I(Vf~>M*Fo*~_#&yU9;a z0kVim@7?HN?=%o9in76|5Uq|@tBTM98{7DNK8HWEJOi~UC02f_KdL~|RlrMF(CYNI zY-QO1kh-Pf=^Axd8fyFrUXXL;tO3jGIi@KN$f2FrOdB@P)?Qb(Q4_Zf1CH7A5oy*Y z{QbZ+>^*)Ln%jUmvolG%M8}(H{F4*p(5TQ+;{-~(g-A5EWt#|}XBXo-yAm+#kGM7O&)@>y`;+O0HU zzTAyIRHk%HaRWLS6bXG)NURU8F16y@6u1Dfyd4&>xsat0ktP(@%+Gad<`5+Q$} z5@Fd&+eJ^b_6(ZYMY)vhfDy9Sk#ilmHiQUk*`$8$KSR}sC^pKv%YS+)hn$@z^fwvp z7(p+JVDC2B>jWkvTDcdmXGzs9=8-B|(wo605ig9`NV)zz7wTD~QrkP^;f|<$-3=!s zGTfR~^~4OHg+pRHJN7NHN@qfLQiM+}+HiZ29S1kzAG-VRy~&;|6586oafO6)eFJLH z{-y<1THw5?QJ&j#puyCc7V%De$SQvx-X+#!XL1XTa5uvOK((49@9m?o@6aqnf4I|nQn&*S<@9d;=pO;T&}O0R;rQDZh)kwom!ZWCCnQoMz!L{){BK7BZ=$Uup~ zkPSok-+V%xOq2`!9Gxwc)miiG@H%iUG`_JF{owy_?3}nFe^R^W)JdCGHm*8@ zB^3^tW8jGAy|m34svq0s*?lb9!o))bD;Svl#c@@^0?5AL6jWW^g&w(tRs8zF-lFFf z-X@E&vZ3qsHd|SiXN8@QxA66Y1``ne7U66&{aXZ&WgMwH)23d3?Pf9XYj?NvKSd8x z?DV$~Wi5w-zL{N{Df}Tn0IV!29_6JtVhZyQ{E?Q&eeA%`2SA9lLrUPF4~LpAs`#19 z(!aTBpERg96$4$v+eSo2cHxS!*AdGzOC>mj31_QmA=>4q&zBtmeAw}{T=UJN*uy(k zVnJqbT6Q7Vfl-B9wCYiyTsmt%Gv%K)9+ABZZN0iuu&rDUWE`G*ar=Pa=`%a(KfE0*mpt73rH+0~a=K{fMAePgAJ1|# zPANEFgTAcEmxj9Esmw76bf2D;XPfNTorx39v~lTd(TF5kIOxi5v=!LFVAiWLccw*6RTy~!LIbtTmIjveXYTDZO{Puo;^1&g88{;J{3gg1J zt?iTL9icKo!!t=@FdCZaAu0Y3=)aCiHzVE&9dq?BWF5~TDnODUGH?mL=+>BV(UXwu5<2emXBm{K*`nF0CI8d zyh$>*VXqtKw5j*-%#CoK=z!sw7p75Zosiqs{s29OHexgu5jOp{w3IAjaXn*tmRlNC zLGgkbTUl$GOqh84dut^L(13U~Ek8Wywm*={v8|BU_q{8u;OQL%-vKD1-7kX$RSWDx z`?8$tV;NFg^2;|~k$8I`xt(ZZ?-f3uVG_Wcp*5}01b~vMdazAfwmevJ#@eC2cwAHl zVlwE>Q#n7HutUb!Dv)E_)d;$Gu({VIy#*7?BF)=tW&rf39#-9e+Ysq(As115jfMuw zYl=+jwE|c>J1KzuVSOF>Sv!!Uy2Z>zu2!x07}`9K#}S(W0_>q~E=P<|xa(SLS(wN- z-l??8gJeRLuX*OS9gzM#Nvq6mT1CW?`^^i0BWmn`Op4By$W@r30i9-581#h6lmqP3 z_iP7g;sfl%U}TbPkwk8VwG|5&=~5i+`@2ILgVn`0nH1Q2_wP^+sF-g2oQk(# zbcr4|&6wM8ur`Irk~Z%RS zhpvZB+w}!?E&?1@?le=A&#f-su#qOn8Ra&-pt?7NeZyfpqXx=7vb-Y=z975}zOlWD zqX^S@JGM$NC#1>h`D7-~dl41q%RYr;Ey-6`s_~T~w`e8GtMRh{!8 ze>ZP_+kH1Xw=pD&p@wQ$lM8kcNo1BIP|?MVpnAkJCSWih?>Xp=&d}mD%j$c}-D=x@|%Iv(wp+@srz3sPZd>xB3;o3UQRHN~6}Cw*#!f z_=krvlwV5U!UI33$nwNGkGBuOscUId3QCbWo4GqV2GGDuGySy`q5_qD37Q*Eexz7Q zXfrvn|JPR?F;}I50~O=@NU!sS9!c;$W~97C zdy_t*-IRu0Qp?#5tvv93py1nWWJW zWB2fx=tc~GP$;XY?iuuns3Nf@B{komSLJg<6;4&y`wx^D_i;F-wyRDYIGvAWd0S15 zOuGD`oSTD0eST2pqz$cOdVAJ@GfekR2F*NR6q0yh^r)p-+%?AQjZB8q$OJF5yoi&G z4E)xR8E|@bR=OKzyE>@^GN%bgcW5WG;2HhNx~|I-99SUdaBJwhvNpgE-HCjes&qc` zG8s5Ab=yf1hweCh*;fv3pOJoWIo$Dt}w9-E=&P;dt^xq1=*&6-{~V z(bS}6fd12Mvb}eI#_n9sEd1u<7?Jj z-I|a9|9?N=_Z(R4C0q~jXVfFP#HX!7D9ax^ewajZGj4ohqQuL($Xks}fNDscy@>q# z+hC}WBkN&$>#A;%;PSrb&yIW(0ylzCrSH??D61LuSc#9yk`0Led=W(UcSq`gO$luG zoLBxxMRm$OJ-oi2Nx!s=3aP6GC1DI;M3Qb_=`aAP1+q0cHE{wVjI}7eU+a^Xw#*%7dE3>F!m_#~+ ziGhW5P2B9&OW&o#8vF1~Eo~)pJCg&OMMI9YK0`DAoN17}TDHh;6B;D%F130U1@T>A_5jD>*sIBPcg)8j^+ z-7P%XZMG6F&r~ly4uU4uclq`Kv?Wf_@6;HZ&H&E0tjlVtvSlYLZ)|@teEW+u-3vtF z>zOd`tEOeWfbIEsWtpyjfV>gX#EMnT>7Ktca1T)6;TR2siAzOS@D}ylOMgqQ_4+wQ z;|OsawIk{BRRB?!+xUM(_Z6jrHR;9*;CM&(QUS)<^RX$cBSKs7Tb=l$hg0)Rh!;0p!X{f2r zC(+!6Kzo9}-vmeZuD%4Z8fOmP(BFF!S1*FU+!FhHb-P&ylj^2h=u5<)XEc2;Za;(e z4-s`>QqroQieM^A-#*8q8xhL^b!5y9lRa&wfimi&`>)Q)(+V#KB+tQ^8P0pgT`}Qi zF}1^75Kj-8dAPr1Q;tKnbO&kKVsauKWjjtpC2PhAGb6d)$7z***lTp}$~ z9Twmp&I)4#7X%*TSXdkkIIbCUTw~jtK_|!}^^)Eo>JXFPC4P?1^U@;sQf#kXI`y#d z=@Z_IS56yTh?7548~T;!cGMxlqv(x@ry;rnmV`Rp5gVNz{?*{&)Gb22h4-rB%+&k! z%GzS~nT>blgwoz#{a%unx4y5*a7i&eU3|0royym5z=eR&xe2x;esS$;*TIU`96ZrW z%}q!&;Jm-=+uW`pFyWz1-f8Q1it9R5Q4d?!_22jta>%o3Y!_wG59sul#g(1Ch%Mo z67?0!b&yVR_fe2XAt=(9N^%e9D2A8Mpi^h{D8oQ!amo?Q1H`p7ht+4g4cfdn}4Z5 zC%vIpXU@kQUb$CL|jN^=F=4DSh~wBzy7L=(FSjyeJ*r z(Mx;~qI#4MI>~b7ZFIUrGT+5>=6coWmi$aNSV-@^BzMd9S1)dp?Xg%P;m>*<-=4Lu zMq~o;PRP{U3Pn!IjgYaGP@q^zj8)yLxtW&a0mDsw4l;2QU5|{b5*-?n%JF$5b|(Mr zO1C!Sv+=;CE{zF$L2OG?-fC>JZJ@h-EocIY~sZQjqklxD8wXKlKlB$!*%Zn>e?D*31Lmml!C^Zb>zu&_11 zFb-yQwb>XGgZ_N)soH|1i!#VxZk8!@3-zoGZYC)>*sdZu`2jqMQu zpJr zXgV%>FlDbXvkCt>hb}VbI!<8DuMV5dnzfu%BF(I^r;UUzS?4+r@QJTWe{P%& z(&nagB_0y(px8|?pAAe`gDr9r!MXY!YFb|GreFn?_TT>%r#mDuSMA&^K9t(k{tTi@ zGU-~xZQzLP6{N(~iJQ8kH*ZZao8?x1wCl<|KJV;bt9I_)3?fn+wp^r7Nu;1Hpf^?? zzxLMnG5ebC8&uU~amo4+GjjEFJ9ohAly_$c#TY{o;@Q)kNz-+7@U7Eb2j zIHvmGsHv&-eHTV)1mkR6vd>?4=eHUn_ltQzV)SM@g5+Gub%c#iNp-7R&+D`*TVPOE zfww}Bbo99l%Zf`D6Ezm3KL_rQnhN-YQ8iH-EhTlXH)Bv~*_T zK^5*D83Jsx5!MRM6wWB!g>#+@varn`-Yd8cdJ?J5t1G%X5ekRAo{R`zkMj+hlH&e$ z2{LQ6WEl{Y3Tl7<01?G<;C{k41WN>PN|}lYq!jtS;e{z5hEz&C2>=B z$Ag6(iTsaZzs5KPttDA9JR9Gb_pOK04hcDly70-C;)O~yelcUVPTkGx@Jmt)5)yQb z6x^py&>mQRj~O7VJf%E6Fa`|(_XU)y3r=enmB8qjoEks>?1fk<&6+21n_D|~ale>8 z{;D@AQjFV@FX&tcpV-#f!ijBF_12cM4kTr3++*vuHCIKc>y33I2dl}6<)oFsXf^1K z08|%c-Ka6qUTv$0%j&i@W3&i$>>3zW3qL?dr^DceHuKtNp8SG<4_59Cp2jA@9qVUK z9f!PmVe218lu55@37&3wvW`LC6mLGHA_U7{9`7vy3VWlZe!YYyn-zEYT^59!@g4DE z3X`J?vIUlU!V5-kwHY60xK{gCXV!i~^h3R9(TT&9p%%K;pWC(naOCjQeDU|c&p*2g+s>OCLmTJzqvysw<%gqnWJ1`L}WO@ z*k5OcTRy8ie%rr_=p<(~kvpxQ<6AWunfU%X`ZyGR{xxYoU5eOHtZ+_r+8h?PU~tw| z9&4Qx)KVx_6;A2#4V}xD18rDOoRH{yL@)-s^4fQ_*e!E%&62fUm#OuvQ&%Ren&2W< z%UiM~W)X6`(Ag9YwQgwVzB-GbrxS{ob56K7q0OhT?)iz|ZB&C(l2Q~Sci(Hw9Oqr{ z!E#tdNHO2L;cheQ@wV!_qfI-MB5ynyG4d(&Lm9mP8B~NQnP&boQ&(bpvS}mw)OA<7 z!z%gG`QDqao7s-HB`+YvX>+Pr3v5HL@`b=fMqaLe`ZI@gx3L@7whr3(R9YiiCHHEO zh)_7Qc@l#Zix1{PZWi2=j*jlbs|NmT>n_AB!Zw1HlC~H8^q6!0&~n6h`XeOj@@rDq z5hxt|=y;<>wMR591_{xT^ud51I&1EP7n;flK;bENv=!66y!(UA0Og3$8X*6C0by~P z>^}}3yHNViW2*Jz;FtThVbCje*<|&1q_^O*0YdRdmIx$-rRX^l)sX;uFTAz4l`@ot z4`N;p!cM<~hu?ceTz?1OFl-*}T+?{_Y{{?kMOf)k@Ez-&ndf{XuebYRZ~?Sdu}C5| znVP}S3!$y>fwg?&U%eIn^ZgmMtobVs*uZ72l-V1#3IffANoCEA?c8*9g+|-!^5}uW zGpfN|mekka1lfAZAn!bj$TFV5T*~sZJ@>rQa1?h2nWUGzStWAa#LcMqYTg{j+@T1< z3i2Fk{e0XAYR#=4=9a04GVGN@_PG?Cb1TWs#v9YQ&3 zy$d+BmgCgq+^$A_Y#fJW{BKH_URyw*A-5nmu_rWL%Yz#D49$ne%QeT(% z;Ub*J@HD>qbL9Idxdt45_|(whC;1b&+BrI+Tad=d%z5aexT<)>@glE)+IVg){5snW zg*M-);#@b*uLWeiYsywPaRDs_+RAMO8jIcrZd36_>ad>K1JoI6 zn;GFau-P4map|E08v=3!!(Cp%IU6Wy0=^PHvb{5W{q4yUn2mWCa1LmT2iZs?po?x)JN9oBAvp zhucsx??{E1Y{~QBUFLtJOa|2Gk@T1E*Mc$5R^ECYN}B&?Sf>Hb)e8trKr!Eb`ooNe;uNR)%(=&>?TZ}xi9XaeC+ z1@Pg*Nz0w8>|vz2SB-4duSokn^Yi@5II6*G_a8snRy~M<<~OnSYEW$hE<^mQ3)%rJFm`@6yxnsWO#;V{&@Lol&IP#jV6fb{N{bTkD*6 zE9qRw;<+>rVZc#S%itwC8IkP`NnTi^ossQ^)sul}nV53tLgWSHXdX`yXb);U8Byr0X zdZlZrfb+^wZJzaV#pTGv1lK?f6?qYkt8n@MwK-IUrB!8h>6IiE$<`Sv(RMXOKk>{r9%>o<( zqnadyluxeK-_Z3YNa{G*w$sXeGRo@P5`N+CuAtVEOsvVj4rzxU z7$kSM$K=*)K;g9n-;?OFg}*LRm8_CPu1v96NMsT=dKED*Dx=4s(o>7LV&hNAqRz>y z0$&R>C{BtdSi?ZLfPsJs1PYGEX%|;vR-lrBp8aEhZ>WYinqE~0>p$f=Vv7Hrv8Ij z;;Tr@*!oQ@)g3!TFm!6znmshyNCFT1t<{_+TtFci)rdVmS#klv8S|EEB6_Vaiqm|cD5afqLr|h4g28d zN&@IY&2B;Ag+N7sM|RaLUvqo^g!1Y|%F`dKGQVtJ{mW!ReMO>R8*gAP;#Rdw@G`e% zUtiXT|5lp1vk2PV-DRN3eaen^!-6a7-%ohYBZ4;Y1ot_RTY$aZxNfEnbmD(&Uhg>s zzt4az^){}(GU|_!`!`+G>qy?~Qw3D7jk)T2ozP;MZAq!wJOCCVBeb*D7SK87Gc+Z^ zn(w}C(*4mMg!8@_nOGs9OToi7H+I-(=ZQ0)<=pqOD(fT;#jp6HPgH;KlW=7o1eXEpSvgTI?t%E?>;R?}qc}yiMWiB-pvn z%Usd=u#Mk!iv^RgX=$+u3q<&=Uu5uVX0}hDWlwl;L~!t%&A~QPvFXv(2usiPpwQ06 zvjU#$Mlz32PXvQa+C8>B`g~{~E?i@_fSw-eG?l>Zi=Q`kO!H~4JpD4$c>?M_bU-VQ zs#STzV*-n7kMU8cj0zTkQsxoF(L2h+zJ6z>`vrXKsb6tK^3CH*tSU1qGnXrK&SP#) zb_atsrtMft>3K+q5BkDY42Y+k9y0jNUHcQNjJX-tt(aEM|HODb^9+?ehgbkTZUWUQ z3iich`%LLwuf9v1tBf!5&S^<a#wd7Nc3_~}JL0!CO5qVHm3k+cehS&D>LLW@t8nmg+Aucu}7k#Eh z*Kr@*NzO_o-HGM$0vcO>8|E6|vpHNlCQ{h;XSwH2=0WL)w7QtB_$WhyU3!n|*C??2 z`TkHsQJ0>{PCJS5?gg|CfnYW>= zM1fBlgiwT&Av}*TE<0y}@xoI#uT^dZ6&wQRz1Gfo??fQmH8W4@2V;6FbEd(DHJ#nz zmNqDS){k~>|6vUa8f(xr>jgFpNqSyJ1!}ePz@@gG-|sWL8l{Ql|F?faO^;dmEUx+= zrMsWn=)k}Iu@vv)RJtQ8nLl{*(C-GOqAy>3Thoi45ub*`G^T7KlQt+nxhhXoDpy+5 ziS1drSZyfmv4_qM)Am>U+?lFy+9K$_Aew$cXNO)}A-|Om4Vq+$y5)>P@dkX$XZ;1P zDuj52NLU1C*!pJ`i15NCtYTVjW6$R@8Y@o2DdcspE`_hnY0r%6U0wu31IkIwiRT1D zuaL$TU$5Wm_D0Ep&wFcETdfbDcvfXfnkx@;We>cJJsNG>R~=50ocui=bI}Si<>Qv1 zsT|`TC?FAXgZx+aM1JN(2Qj7yuh@loz(|{7>{s9H?s|)5{)S?HIl^mg-#(+@`h`g- z;fH=f0rcqq8OLy zhlr6CxR&!ax+l&~kS0bs7a*B1{>Yyw#t>^jjJAA!ofjpNG)0pQ*nzQsM$$V!`8e5&YyW#oQ zBxwTMy3t)(yqpSie~a^?EyOJ47<$$g#cxS4$NE<0W+L4@MxkMt(`gH?K764*OgaAR zQz1N*+5d;S?+j})>)MUIprX=L1jd321cHK~AjAfUbfmXnp%WOow19m~6jVwmQVbo0 z&=Cj(ONbIA0#YL|f+2KFs0j(29h`BT_j}LzcdqN4{K#B`@I1S&b>H_|d+mv(1g;NV z^n}Vl^~a#Qhw9(bUrmGe zbpdt=G&z`l*i0a@|Qn%(m7G|Pvn*f8rV}N zJ`pNt-lwBc5s-&_xq?rpCe}e38l@sh_b0D{e{kG2xVY&_@yfQc*%XAi%byn`_HKb# z9iH&>$};U=A8Fk`ie+5r5vHWv^%m3qL_kmZ%xc~v59v-uWE@1pVQ7F^a!K{t^SeY z7k~Z1T@*FSxuj2&jrB7E-Li{#5I-?;^e^g(MT#}*&6C}ENrf0-mRwIjPE z3XI?2tVm2jN1wI`{^exbIf6bI`lk3<_%42(=|XljT`#`N&W9vY&kQ2mqpE|5EI&cz zz}@D{^&ZuorMCygo{TW12HB!Ka%)8TEL=EZiy&lA&a6_N{kKwRmH)`~p=hf5YAY3W zSxUrSEd{;Y=pm_w!K*8KIlLCU+0EZ~0Xn&D_VkT3Ke;&8@NbI*zIFyQfrjIJNcBHH zihB1669*uWD??)i`2O5jRj?Vr$GK&-=jfH4kVtFtzbr2}U=C?k(;Q#@y@r=VVB-FS zuZK8xGObrF7sOeD43E6abNN%92=MAhO@;-3r~c1RfcksZ+Y@>xf4mU_DgMK!=K@6O zPbj9yg=-?H?;Ae7y4qE#bW*DpP{ z&0C%R;+yPqBdD9SGj6*YFb7PSuLUa^o8F~J?TH3$-7yk+|0^Y`aY8HMs$}#c=aPVM z>xnvhhp?yRm!1|R)f?9v=A-r73LlG|t0_!Aw>YHVbv@ITSuk+Th`6D+T##4fW^$a& zm_9l0)rN}8XJpa*2BYB-VQ#PU-K&=uYox=A!jl$PJc#f*K9RL5R)_XBe5UF$FH&^l zFF=plI9xwXX1zJ_z}9Tfy2cMdv$%D;3`Q8~;P}~OrmC)b&pw@4pO*`>kjQ6vDJk!& zb$dp+Lm`vE_6V*J#u^13EJZf7ts8dFa5GPf>Eq0x%6T#4fyNOp!g^X0!fSu)6&(*! z|A@s04AFMEeZAPGva2uWTYfgo3_eb)lFm@c=)FJJb+Nuae{n{nLdsu%*`|f26TWyV zqst4wBJ`FumlpLlhfc%y`P;g9eWG)&&o6SApP4IrKxZ%sE!?*I*)8kEkBZbexc5}O z>gYQMg6KN7Emeem-)tvUflq?)hCi7pwaTrA?)^u4_cqfOqe`Z&a&#HdQ_+EkXHwps zc{`;%tez2!BPZc?oL+<-t&wegoklRIy0e+hnpr27M=0dXyDfjYNVQF!t@t)>4R2?h zuptJo*cjHdgr{<={YJZS^mPzp5@x>%*RRr6+z3AzudL8p|2_uQxu6tvb=Jm<)6+}c zgF}}4*XL8mxPF>OnY5e!1I0MxuyT>@N?&DN$Y@1sJ2~E4M{DnmP($jSS({Cgh(O}X zrnX5EYBt3F8`Td#_m!$=PYKZM!wykL&pU{P_cS;yulX%oPjc0BpF~u;9{PR%w4ZE< z8#z4VXTJ?AbvwAQfRnBjBns~GnAoz!#^ zo{-*ytP2WF$^NXZ`*;j64abs8RXuIrt+(nQkD5HF#T2;oed89#U7z+|iEwERwNHuY z%e~!&8AeHn+p92xTk8S&_=}`JPy$HQosIJW)%jw*z&1W)!S84~LLB3H&*%vG5Tbgk??VzyVi8Iaf`;1q2fsd-``-V# z7A5WOZ6OlA;UMqj4DNjSy42}!3x4Up$=YRZc;U5aN89;(Ir-m*!nmm>lbb_t9WlU@ zhpk6mKjj{$e<1HFRLvTL=$3Qy=i;k6LUa+Eg3rn9(^HG$p8U3;#WT|=Qhr)4D6blU z(~6E5nkPE5&hwi!cvWgUeF7Ct`QK5`xujk4F9RkOJ?t3xklx7a07rtb5*Ax ztY%*?`xqn~$f%!qQBU<8!yrVkTlFw@qm2&xG^N&jmVq}s&CWRHOq;+kcNc-DV@NC( zcN2>v_EO4r&@94%IrEkxpr&47A5+-|o|9C8gj z8&W>$%&ylGf6P%RcDu-wYsh*7XCF$Iu-t~~j3`)jBPt$VIa0^GlccBxMiC$?MS?l&b${zI}}cJ-w5H?89&grXEQ+ zs3Qut+p$THr-g39OSP9usF1^8*+iyRRz1Jo8cH{kkKu|ffF&2!xh7%5#QU|7$Sqmn zg`Jq_)7d3A)5KN1Uh20Gv6i8aOMe}+7fe-WNWzIwTg|JjOLQ0ItLII)TfbXxauh8- z1bTDC%w+cA*7E_RrAKIoRJF!{zNP*y&S2d_Wj&~{Sw2&#ryw&mvkYzME(YzHfUo8E znRmLGWsgyDwsd>59=9k`Og$a0)6xViiM}-LX&tS!wVygKe-uog{_UrrEZ~o4-+MIv zsNK+`FL1oD&_Gc06#f&v)xU40cZTXs9pYK@$2HIIg_d~Pif1c*=h5vyR^Qo}`wAzv zi%%=bh6Hbv=t==)axI@0$o8jYnScwOZek5RiziGB`78K7O9Z3h>Mi4CAd2Qk-XW1k zwwvA9r$wOVj?nk|+nF%Oqo;_(fEfc-5trLqGnq^)A%K!A+*_TDiHD6w&(M3p0WsvJ{!OjI12W)f5HWwGl zoG9{(CT@#Rs+`+p8=E0-^~dj zMrC0iaofKHBq=%z1EvN(2K#c~E2Dq3Y2;PgHB0{`m=x+}|K#d;i@)L%MTooaGkSz= z`BU|&^Sl0DME}egc&$i<*%ww>EnzWkxP|5|$S~&*&#Pt$h}p4~6Ok0jwGH3RTx)2! z$9BB^N5QDrAJGRAU4vOEa$ZE#zA+Bmr3Qh-+($OwOU4C`i;`?Tdtq~)fOfgYqcJg-P|Ga*Fwi` zwUZ4DpnO#A6K*NE84<5-!aa`;-}sx!vWqMC@m`4YCk8YGF2UHV{cnR{E*y@#ZEVlf z%)nt?KKYDp!*fqO2%fD2n#HYP@R**;17HcL{4l3K+H~%y%`!%7IuF)$_xS%FFf$I5IV%7DgNMpMI^B8-dK6jaKA9cyxt!%( zh+7uJRFmsQr6|c83Ll_4AJpwouu!j)Y|;%EpYzx}cYW1UfZhJj?A(ds8&|oOZb zvIF0;;TG=+|GLv(t%C+x&n|O(3|!wgixCYS%0{mgbb6s0N;&T;#M6uor`%07#|^&} z`;6*!YTg{qKbbsbT@lz$r+)*fJeNt)zHPU=LwJ{ME}ERXSf$gWqZ+(|xz|~UXOwU5 zaFCiWd#>!;kKY@4ElPf{eW4HWxWCm53~**FUV$lWFdG@n2d9T?;GYHscn$ zv$tNtyjTo)AXT1*J((PF75)}ym68@$@J)%;DqAC&Ts2c4 z%k?SXeF?V}uo{fkTM(-XC-e+?61AJiFXriClflv}b(YDbrhacPnE^kG*cf1KkKC%% zc>B}jboZHJ4@K!?l`i%+^e zJgo>D!_r5AOIMeI{ARp3I#NaP{A`q=xImzFA;8w@AX$qYtzhiGwaa zdR%$@pDqHc%DRVgyC70;Hfzei;V_gV21=Sgx8(1-pN6SXgX~+SCEj50+(~_ggcpMK zbYI+6;{Ddn^lbDwm&`cT2c;F8+Z66MW5i7Jr>GdYNt)Bs4BK-@t11*<&_9ZleJSRt z&(#Igx4e14p@l@awB0ssnv%n4r!bHAOkWk3D!>KK2z^JnbMi)A8eb03~vczFQ4h24i_Q5%hCFP1t;l`-*XcK*@RXvC;Tev!ehNdbt}VL z7hGIwzT_iwt)CVh((p2vK_-SRdA#VQ1@z3D9qtjGIUYy-z@5~UDsalAX&?3KeihCh zPY0;QY-hgQ-@bfh2P}mx(l@Q8xDth5b;p%P9II-h5XaM7AivEwzIPH_lkVUl-wRoG z^C@spLU8xp2X~?e3+>69{Zse!mfU;DvLz=wc7X%L>RTHe(j;I$x%RTfJ6#4dHb|sW z)JARPNj?G2zLQh!M4SE~Rk%JPHx}9+6V>HK<-IVlc$e%UzOv@2cW9heR^ZC$iMA52 zx`<`YC8^}aGr{VNg`A;U0o*$M3IXQ)fQVRtZm2Cat#poa z1<@54dXDTQgF0}sS!!ghQURB0%x>HUWWuAi%U^H{y;W}KAFr~O3w^_Zb_LY$Yqf6y z6nOUXy(eMfhm(d$xD%6WABh>ymJuX`iDC7Hl$o`Ualy(+527swHmRa}TxP#t?UO6e zD*N}k82!A=giQbE>~9NkssipgZp&8f0d1&l^_tI^*{t)Hl@7G)A873B{UPd-#05m9 zeAjqqrB;S%Z)aD`Fw;$wC_cI%N7g$27zX_tdfeZO6>Es4dDT@UWM5108aMqz_BMUy zCIL=S$thxE?s!Vr)2IvQZIj9VdECKg%k!bw?ot&AJU!Hwe29a~Wn1|T)E*UqUm zbn-f>kYoG{-*_K<;PQs}@HNbM_|L395O#_J#)2f ztwC>)IrD?L$X!#nTVAMPwAWiJStS|n}%yN|oxP{mOXr4ZuRT)sz(%E;2&3O)- z%v5Vg_^5ilk7KIPKuHN>?@A@|eGuSle<3b_-XZQKDfAU^YG%?p$yf-Ga5eaNck%j9 z!u{S5NOgJlAoI;bJ=#qZN>8~uO)D`ILZ9RY+UP$-tC~E`*6>zIt*%UQL5;f9JP&)R zFh)Vvd5^Q4JdS%_1*$x|tuwhifnF8TBRP4C z^a0+SfkEyT5>ahSOGgK(pD1Ors5FW)(y5${-|jORq0?$tSSsy zY;n_ngVx|%;{cY!yq2VQ&PgC#o(I~1unRGT3UDxB$Ph=99vYv0-XE8ZHU0%B{tC?k z0MPrWPSev;=<5tZjaG`0KP#m0S>`^cC7j(nKm2yRBAIRjo}SX_scWrHb_;(|;eS6lEbmp8Ql08CZXQN zBjF1Vk`%A~%@>4;m2G0|C9xH3%rGD4!N=AG7hXF}=!0 zm5)~J`a8_kqD>8pQs&Gx<3CQq8(I@i8jP2N{I;nyk1lpXGH!Y9IWR+-C?53aJ#O&m z0{aqsJd*%)s_1^zU;QULC}jJ-l^u#;?H;3T98xEK(gvz=?8@GK5!W|HYEA6H>}VXR z3yM4PXeSAO7C=A1B=$4{s2uLz(fd)*$|CJm;E+($2YZ81=J>nq;@J8dlXqN-0B%S% z2glkS3?%lQAf{H z+H3f72p`^kG(A3gK@=$*p)I8S2ha_~!vm0uC0DmN?m3F@@qZw7<0pE1E5deHJowm^4W6Sq|+W2TQ z2@j~-+9x&@&NEoto%XlGfbrCO!0{S%iDb)Id;Lr-AU-Z}*SAZNKUtTt8AlN{c|*`q z!V@!5!CulWLhdusld`75@MmxIO)rf>QKQS%f!53dovS+K&#wim4Evhap2gJz3zT`x z^idACE~C37Akh{Ra9Q(y=FWChSij1o?E=+c`ev9GyoN~VLlM{shihOdITW?6v_($w z(%Z7{+~eKTGmXT6l;(&tgLnyEYQ5pJfB~PKWdlCtv>qxB1Tu$aa>Ch!YgO$G8F|#l zWQXOgkRh{QjMVBH03@>h7$A=PY*XVG-=d+tiVlTa4xRr&LbnZloA^(Rt6wJs3w2!q z*w((r{p0Xs`d*~16kcPww8xlmQ?Y7l@XckL-xCm@6A+HRe#rcmwnS{Oi$PqOn15O} zUF&J=lw9xOq45rU^ywPd|H{*(WkroYSwQmkVwK;kNV+nRijSIOX$>~I1&%43NC9#G+~{tkFagfl420$m&Z64 zf0`1Bp_-}iX^(Jbe<&lI(e+b}`Y#6X5!pq)SFzvf%f9VEE)mI%1ybOnzK2*(JBQ_7 zRUi+)1M=_`U@n(KCImEM3N6=2%bXY9l-`EZws|-5K+KSJ@S@s%~8(l`} zGhtFJo0QnHc)e_(z3lF@izIyExU8EJkXY@wJ-rC!=!?-;C@gwFQ7t=K56AeE10x`cM}Wuz6Yki%stbsoC{i+1FASg+ zR#gHR|0m%*R;N8+#e)hbYWz2AT>Nn~o-7|CDA}PcOTt6a0wB(}Cg1m))Th}S8z$`` zP}f3=bKS%p9hkXOe=Af|1m1i-+RprMLjH?UF8(M46||a_Bp3>51I_G*9ykcnV-t*f zH*OaATai6S77-z?(kaye|0_O6tdx!R{a3pQ5%#Ja(O9e{72X31Ozuos)OJ0H!HY#8 zRUL_~T=V89MLRImmgt~1G!BHbR~f&}k7PuP4lHF&uUuw;RyK71{%Gwb5K{taC6GqO zHVUYcepXXkNc2~`mM$}|=@-mSohkKgdv|PL)9G%ID>Dc-NZWbiz8^+1%4Za+n6f=y z^lg9O2We9H5Bg^{8(4bgM(ajaMN;uuVd6eu_JIXyIH<}xcm=;YW@Vpz@^bm!doJL^ zg&*!#i|=AVCt7xhh7Vv>o)BMb5irwXj(_kY9z6fo1FC=)r}#tkO7I!=y+3Mg@8(~9 z0Zx%a1HT$O8KY@26(eZ{bmBkij{AZnjy?Ds>t#4b<(U`v8wP_9tzcAqXN&J zcDwdnQvlL{%SJ~2gt0)+b}Nyq;b8^gXQl%s`6~jAxWrGNphw(q97tFLL55muI=6;0 zbCj>H89OyIo=}aDlkg1AbF%jFNJct%@>j;8)d|o)_6vfbrVp8#=#k{%wG<4(jlX_> z{{ed{UxP?k`LA!7c@7XhQxIeOwjg6MOHV@Ezq(OLzUK3b_N-lE=1k0w^>;FvFEz;l zsmUva5I94kXEwgHsU4N-2nsHfdyL=Dh)_8Caeb(MkZ82W$6;}xakbZcBJc$=wedP{ zclcO99(|Mz^%mupjJlkbDSyHUeA2ZuGBJDM)<2^WXopI?phYU;^A?ur12+O(Kv89X z#!n2)ymDZ4lPL0-RQ8q&?zqK(T)HwPid4uxQn8pd{XWm>Z8X2JB@2lZ%EEJOT#WYA zx0A`574DP6o1g_ocD2kc^lz!aVLz3cC~UBZBjtXo0&5`Iv}vZ%x>1t+ zDdJ0)!k$>IyfY3XmjtrAW$+1VGuMHZyBUjBB~$FRLDFn+AQO;|v2eu==as5BI~@<>`1#SWPvAGRg$ zBGxxK-^*7S?XJ-%D#X*rm`he`9>p%hsB(upB>vWQ`_h)|$WA*#>8(0a$TX2*KE9{v z{=oM_lOY(DSgB)P+g(1B@ZglKZA-al&K8lt3PKa^d?JWSp8oA&wj5O^B6}e#xKs<7 znxv1xIi2ZiD@^GfK~=O*+o;N(80Jl{ygRDN{6k~mOFKh%dd8JghMKdCm>aPus3_z0 zgALT6Z1n@~H2e$h%%Kp;th0vWZ2?lt=X+dErM@V0o}n7m`?u$p*4~z~G7{{^>_}J& zQ)|$iZip~_^pt=+U7b#E`KV->@WESMUdjGG54vO6GTOt#=eG_AR5Urm&Ee*I@00}G?U02S&HDT<-%yEoO4$HIW4Lf=Jj@`DG66-!h0AEY zy+|B#ttv~?y7MfW%rIJF1(Uq01nzSBXy4i?h&7Mmm#2e-WB!UatpdWo*--^i0P;J1 zhcsVTXR3D$ic>}xT({$*l!&RP7Cc<5=~($XmC}GC-LQ{58(mU`5VTgTDt{E;V^}(2 z{v|*A;B$pmE8$#=LXcm)WPVREIE#J}v(=(WCMPvy>;fpK$*HE#&T3L&{Bs*!^<(CE z&N$E=>s0Alijdso9j;dXd%Jpfcs_rg!VX~d8bo)O2jmp-I0u|!wBwd!zd8vT5hh;n z_#1Z=@MhI`mu#d&l}1!)PXo6h1eLA{Q@lvpiLH`9DpvmGS}F??fugb3L}*n_x`Zea z57`(Vzn(q7pO8nz{=%D;kyG{T4ZG5Y#}7>&oy?Hs>yH7pafR1YYYXeqi3ZEvIPw^a z{4&k2Y7-3AGdoyq=1;4j#eu@Bg)?sEOtznSG@kdx1z+e89X!66k4E^lw+GbS4Fk+X^?vIU88>z2$3eZ%52xKpm{bT?9?IQeFcwc+$gZb|EEBEi{qoDsS z5H??p^PGKfNPeJrM1xIFQoL&-N-WgfL$&a`Ucuspo|V11Dmt4An*t7h1}%Amh8NhfjaK zE2KH#Ua$4GsTirx(dYwtg&Xd+WNu=%uVV$POWOx744$1^!@JpIn-l!{aAIc=Q*TI)G5X4= zrf`$Ad}rn`tV*fgfkk`PQae{-E+WW)JM)^e8E$y-v~2RJg^)kG${v$3*Zj0n7fbpQ z>$7o-9x$)E7KnMpJ8$2=1WRKp8m2ltH0|FMWRi zF7O1G4w9;3Rmr+8h3pm!bN?-rdyA=BlwfTikCsAFgDWfM3T3&Edo5bKKWm3?d%N_B zn(Y>zJMFc1-e(PRUeh9!>0uR4pc+2@)}XfOz1RVb>5%1_^V=cm1=o^Qe})>hHHtP# z-gM;0)R2k*^noH@{7j1;QbI{W!lGTxS8Nt90gC z&nFU|zg<@X&Z|J{HfLp$WSDQBo$%as#9rHGgyq(^)z%@QiDAIzy_NKwee>ni4vYDj z#mEh13wzOs?cFxqKd7azJ=M zIqFoLUg!SO8y}u^(WrtpMOC>U>*KxrgD<8?XHyPXwC=qsdwJ64OMYb&?x2GzwR}YV zo&S9s)eujj&oY}q9E)7HWAQGph&|sQNJCCnl5;7C#(XhNwhIFhD?~MLr#0$OiZeUF zBWEyaV7{DY7fg?X@4NQal=^rpCK;N+**0at-7Rv@A7RF2y)jAsd>)M$UVgP9a+BN}~m*^0F^`znl`ib7ihp_F6IP*5v_hS(_}0%xCJ-`ca(yn)^_v4NiX z(4<~)Y)-|rviYI>A~;T8d97CI=g8gPYw6$fcD#R~e%>0v(MU1^i~t}H$O#a(29fyT zqpoiv&6HVX*wkySdu@#>p%uBOI$?8#2Rn|(b3^M))hHA10L;{AWx4BBO+Pi+HGYF~ zl~m|1>yUS|YrMo&V+4xNQLrw(sC6XeWA-#e{UQ-NkEjityl;@Kl4qYKWO(W;7hKP= zlpn$Cis&nNu51*oL{#1(qAXRCseZw2>=?>iODic>ER=QrGFT`F+s|VVgUI$}T>WAB z#cyFDoSUpc>|%MCrzR1;10gu7tecZ_osvbu=bu72!^h9qZ*p5Bmm;arPv{mY6nB*6 z=lVFx3e&RxNp%?WL56&Pje}(0w({o(c4Lu83l*vo0r&+2p$`>#w)_US-8p5=$y^7p z$QICfJ1cXv?j5%m`V!%7TYBSRi)4GExs8Pxx6S&7?B@W#NUeLa^2FpTP@QJr>Rf)$ zv&SpdnSC+cg#B9J zHqBg5!i&Uv$PZLxs-F$`Miw1-t&2g(MtvhdaNq9jPm?5J&bj#ANKN1+j|Cqh2r zZ$Ga35Yr+gaZMg^c}5b#rJ&yQYSnHeoR&6I|)H_VYDR z{mN^$|EvhGmxx%6N5j9QNCX}0Nn9WKA)T^O)3tSDS<9Y%W+2$As%~YrhepFG)ten_ zqH;}J3%cmr1MbJR%$mL^L=SgK?`&5pIk?HzZ2jj~HDKG=ICOjQICJ8bMRs}D%;nc(I#*GItz`+ps6{V6a3bN)ZKI&+)o-Xu-PS<%WOidQ$AG07Q zB21Wa@@Im-=8Qc`&%JaKJ&4V`hw~z(%rd{VvF+i}By3_8^R`vhT1(YC!o-c%j8Wei z#%J16jUJc;@N)+eJV}AB|HQSFimL2=b;(YGA_mdDIe*dk z*gDCnV+cW^pgjL{pTGH5T)k`S6046?_?n;TUI~u9rntdVy<4S)1K97{J(JMqWj#k< z%Gw7S!{_?08V(3#WHaDu|FV*JN35 zI&MZWUn!7>g?|-5+-yz>>dyF# z)8SW62k+@q*mU}ja;wksZZGo2e8Xj%ziB0nKxLVMZU^$kU@E~OBIB%!_l_f+9n5w= z?xN*H!{ef5jFh#p3Pj7VZchRf%qKP6BKkTLPrUcLy9MMz2-$AFmIgAI~GVV&qvQ>ci_Vdh&H>hZ@2Q^c7U_1&tk#>7JOa9vqZHUyf3vVQFpz zoh~YmaLJc&YE?64Ufxh^nFf|g;i2d=V5|mK%=OC%ZLGG*s)6M}Y~6$tBQ3Dk4IlPe zz@fNTMHuE)VIzBKk`1odMDi{OYGekgVGQ6W2k>E_A^}TJQ=xhgEr*)XLvWs<-5|zt zH0PXE5#{NxA__mX1_le{i(|GC?C)3m%8|-=}t%vGBjj-<9Sb!5nxUvSb*tP|CdS#XCg!_y(1q0m|b2Nt{p6dRA z*sh0l{Je*|O;IF8^BS8#ZxqDMqk)*`rC)4 zsoH6`P;jHL0jRApl)(qh1H^IrX$}L<$$)eIv};EOvbhX6v6?XPb;or0bm)q0b=Y## zj6KCPKTHto$uH2y3rsFO2T?tbty=sHKo{AiIoWDC3xtXtAPg&Q)v0DdmGiDcQ!no%B{#!0C7XHj;h#K){MW51+zp zb*%aFbqOj}%6+Caa6qMX$EiOf83^F6BXS129;^1}Qq0#jTr=B0@^GtV#vd?*1n{j7 z|22GyL#AIrKq`D1yE0|s15G0H!%l%f$;fdd*VXaOF z2He>Vp!k8mZ9zv{Q0bZkFV5S$@Jc(U;Ap2px+F$Zj>{?@GX6ibIDJTMsJz_fd1`5m;@ zV_kzVsLt}%!SCHJ9qw|{NsqP_YKRmM2y|mndOqn#W$hjxtPcwS+WQexrnSV+B(*zH z6j*4kCvf0_2PSG3>hQ0=yjYFck0z|9XMm)rzl=9XTQvSFm+n&sU9?U$A_MfpM1<%s z^Tx$i+n%e|jiZPwz`Rc0Xif_-0u}Zhf=IQ%=u&J8Ehb&=)Xf!o^WO6d8Kxq`k(P$I z#SP7WfUC||qWUSF;3`nPcQsAK3Q6d(P)IZ7VK}; z`By4YWMMno&$aR?h&UvJN@UoW&F&*P2?od%mB|}bPNZ)!NPYt71HO7VDd{1(eni39ZUIh9!inn!9*+`uQwh$>BYKvZ{Ve-{om`S$qly58hdIm6@T!qlwGP1+9y|e{{ zE(q9FUS(TVb5TLc^L1dk7FDk-FCnb^B@=DEs_E-g2f}8g=>|GXfrMT5Xav4=Bz*n| zWmmk&cCEBsYC|s<3Fy^5Gypc~kt_e6UQh&F(p9XQRYvfto$Cxd;MoT905d@sw=6|B z1fkY6d<(|WbwrV;1X*3S8M3InKeLF#T?^*huW;KI11c>;Hnw$lGrnBTBAhk_2PwX2 zGJrdEu_=siDHXr>7FIXgX6qTeDYi-ioRiaj4xEY<;oCF4<+OsLnlS_VVdfxK;pmc= zf$Ni&30`K_sZT;8McTU%^+06T&mJsO`-!BJB(Z>ZfNgDj)e@rsE{$NEL#u!pl(#PZ zW;sbN5ta9NGKl4LEKmu(rO8eU)>O{i_)0Pw!EevkR-Q&F4Yf3xGgm-~l|Q^R1@4Al zl9~Tv9|r!}>*lahS}-VNk}|)gcKVJOB8)j*X;YX(n}%f5Wa0TP>>+TV1@xRARi+=#^f->{1lqPU72Mhu zp)>6?-i41qoYp;tlGnF!ZLQJQcssa|ckIf8BN)W!Q0q`jUIRF-e%{h1ec#Dx7@{g* zehVa5hgtuRCHf(Up$ElGeel}3vvu$YT_Mh2D4^dFUj8+#{N7-fFyDqqq7fB) z$`?B(n`ONHill1>V&;cPFxYyn)>C#>%OEiSZb?r_j%Tt|6@O_^6Sslg;=`c$^Xb&EtWbz`+f<1jymw1ISP3?OVtW z9Y-dqQnnpKx>WScK}Su^wA7+9e~ByHwUIq01n>VC8AxOj(!2WYvnj`IdX!J4<@%7b zyvFchY-ov78wPQmN61**kbW-53e}EN@=NKjI)>Wr{TZa{EXA2A_hAs1ZPs5FFmX60 z1luE%R~}xaL?jsWE66*`c!6C#V2JTx`?d#Im~$_u#dt+;0O$z4Fq!-B6eN>MSQAKz zgYHvv42qTxZ|5aCCEU54#K?*Fx3*E?%a~X+!n+(~Z5%fkY0quphSc#+wVwFkf(i)h z@3|w%nJIc+RR`5Wqy_PZ?2o~&kt|XoYL2EUZzkhr@;>+l8FRj_w>GS&>9@29x7LqB za}2Et!dYp}`{ifjL@B~jF{rUXoA)#1DN>o4W_|8j6Z>9PKqJuprg(J&9uie^+g}Z(r`H|V#%h=)<3_TAE4G0G*77!$90=rd z&gfuQ45)-0G361Qucd`of^M?nblhMT@PdO{F{$00oC1q-2cHp1l8d>+`cFuvet_PZp`4q^+Sw

  • MJ-#a&S=5-PEg~dFmZOdXl<7Rsj!-Q>kw4O zW=GYc%fqRN3a#+WBn1?|r2389|0H|!ZHtGRoW)DmLc8kH3bLf%67hx)BMu+t#3U0# z>@P0FXr&}}7H-z&H-KV=L4Z#u0r&(=GlUdY|^6 z>KZJq@~-$6v7YHq$%_w%a&}y-%h`|gc`QoQtQ(EsmjSr3b||gmU+aVDDzU50%!@GT zr^Ou4Ky>fvHxfl~>pq;Y_ire)ZE~(I13TRGjH5_R`GrK$x~8Q!cOp%s+?t#vaFzd0 zeaisgH~PA>)QPfeq#SKp{v3Y{WE>|nHJ?lYiH&R?s9P6mW9bm=G;ZJ>a>e6g(#gJI zxkcW1XQ4;R?{BtD&Zm}IKOorizjKjErPeyTpz7vfS`AJ@)td*a3Vc@P05999*AL`!Q!a@=TAWpN&UX5i%uWnLWv#odIK! zIxO={tWaA7Q6FvcFmNok+#uFfQrbQFNRrOO-t32KoKdTrhNAIpM5c-&L5!rrm=Ggz`AJ3Z@q?+dR#uo=OHN;4MW`;?dpR+eKXI_C4-FjZUI_c7_ zL^LcNd8BZ<@mXqXTw74Y=82VucxM8A@TA{#{a)n#_iv zH%nU%VAPlUZ|oJ3IBNH)q})UR<4}WaMUccI_6~UO+6FPM4JN^WbG?K{Xb()|*5#3H z++iq<`sES5i1OuJ3wUr?9~!}R?L*rxyS?>eO{YF}7#KY{tzT>+{2Fi$*H6bVh*}%N zs*$$)to4|!_F}gE*Q(#+U%@4lZ zgdeyYyEo1tUaFa=<^YthQTlco_5p75M*VnlmlQ8ws?e4>ka7O3df>{?xCIvhuOHhC z|D)o!XgtEFDt>8^lc8yDC~Iawb=$9!O{}Pdm!wTYk3K+?RlBB$D-?68IHyi~ChFR0 zp=&QmcxklIeDPnf0Y&dPyXZfxx*4sSHiuc&-=Pt z^mM4k7n6EP1#lEB!#|HSFz(fQ*XNVr??f&9el11EH@Tn6D|QwSCey#Yv3ok2yU-gB zXR6d~y~6A69Wdb#2P{r%Sc>9$k+mWj6U#RybjBh5#%*)T=m14$SyWvoZjO5a%w;i% zELqQ2LS-_D-y@zmopV9)ZoYjgx9r42Q=|~YLCU-uFAol%%spG$L$~QhFA*DYs z9?P)Z7w{mf0tmnrn!Yn1?+DlV&Y&G_;^XsZ@i1G6GAK4e(Ll|iRp;E5{wSpED_WFx zGVvJi%MmUwR>^7`{p0i8-F8dS-g3 zZI^dhz;afpRR=0unEJLRL$ZvqI5cl_Y9UR9;5gu0c{ya#W(fr^KvQccv7WSEZv2H! zpm)O}ugjqzXWLMzjW@h)(*kd`8Y!hs3{$LoWv#v(>!4 zwglBXU>QHxs?Z%5BO5nxV7{d^p>poT!@ye4-J-<9@(mwhze{hZ%v8)i|J*3L)2XJv zNjJclIldLc>CW8}zAtw%tE^<%sm}yoLiT;o(#9gw*<`usFm4GYYH{5X?_dhuyrt8i zorEu0WhwlyMZ@7=^_x}xD+)=F<|vGKJX;L4S3_nSCA1j^UGZkQ!6i0jeVh{|!sS_+ zq`dsKebu7g8E4+M>2bPONV`8~+{QKzPJX7Iy1BA7`#pEia!z`C`@tA7zb3!~zi}R- z)oq+j)|b)Q;WJw=*wUz>b!GTsWSQ zzbLJHZv3dtQILg_GS?~3?r}eqJ=hf>TF8L8olgT9Dk#F&_ZprlDIViXLp|dSQg;;0 z7o|gYD0D3Nxuv!pk9V8lW1C-WvoAryO zANUe-rL~w-y=M(5htcqPs4K|!9^c)>uTW|-5MI#?QSpUClRn-OD@KziztbbEiGwUM z{tPDp*zUQmeY{g2So;M?c*+08-kZlmy}tkBPQ5#wlS+%F4ei;+R7AtPixz7kgD^Grbu5Eon94yJkr88`!eAQGEDUD*-h=9N&UwGj=bztyzt`hYe|XHi z=Dx4{zOU=Luj_d|FM&Z?_g{8;mQkf)b!q=TYm0Ns!qlS4wH~Q=W#M_|sGSc`xAZJ! z&LR*JPYH0s5JKW1f$iHjZS`TxNa<>0nS!AeyR?U=r=NOdHk4q_kUK;xXwwg4HK3_k zEHa@9_4+X@2kCr3LBkayS(C0aWvG>5xB0FzZnpEN^QRnz-4)P{N#uQu2>Z8t{?nmC z&OFh{gttH~-%UY@lLsX5zbj@P_DuiCuHBv128Xtuh|FxLj_9tYs@uEY0l}j`&hR-a<{@U@CMb1Qoh~bVS$n2_B*{8MWWTb$8#i!=7Pen znz72&6?Uqv+p5Q9_FZHKbfC_6ZniLDKEI@BKGnIvA^85zUS1|Y+Bgf7dX0YdyQZ1HLJk-%x_(a{|)Wo=DbZK zlNqQddcqEJvu7OTq6f4Gs7~%j&K86a97p`g9R~KqraO( zU^N!F1{$EsmldXbhn4j~o;Ed;B$Bn$$nv~#zT%u}{t&|U;DJe^ut}}cppRx+Lt^?s z7O6w2kD&B?x3x$$8i`*sue^uo36MV*ImY3DGBiuHb8oF-+hd^il8|lzgBzu6Lz!7x zmZ2XIQnvmdVi}-B4?R0uEhf!xug+-Y=B$BsSEUw7h~WU}mQUQiRY4F$uUC)@tS#a6 zK*ew#Wyor`;WE%BxrBr6EeU2kAqAiD;cr6u;)a!wb1hqCLGb+E0xJ7d!(VO(f&zHK z^xA8QdB@_!PgL)L@SGeqAgd|Mt-HjUyZFK#1XFnCec! z&PR=`2GCy1BNJEI%6Whj@kUsnHjTJhk0WgP4Jf`ny8Vu3bmlB@wl_@Y=}Eg-fSmV; zbD~)*SB>pfPcQYZ_s$*Tk)fe4G^KqWoDH$=e^dV8(f=+}A?;*A-q?Od~&qQ?Aq z2AcCmN7K7>fY*7*wJR9a>7vmAU%7t(=oq1}vwsh}2<^uQpqC3Nyy<}OJ5eI>VvDg= z-!SbJQ}znC#c`)rUTG^?tu$q_xpKAwq$klOFnCU<%cR9Q%ZGxLB@EoH$@kn~bJB9^ zV<2PjJX{cNUf^5#=Ww%`0L5*v1s^0SblGpbB@fX2Tq!dFQPq4UoX@o}uS5WI@ZM5? zRvd@@tiJ^_ThXS;E}VUTPt%71Ja1p?y89ppd3%{}o{^sLDM>=FBw0Qhdc z<#0c$oHniTh`OcuP~u93hE_w9=UcRc=Ro<{{^Y;85r0#zYlXx|bf{**<-_d!AASqB-_3) zP0SdDTc?7+*L`aM$zg?j6ybdoffuEk+#3dY6!A1}g)Phqgs45>c_aC!5N1+)rl08@ zP~8(645RCvV4ZB(gADBl6Uwntv1pv;W6iY|^F0N-z&sxP!#n_CNg1(Tl1v2*d?&0M z={75cgyY0cagT<$qiF1yGMo{ZA@M; z5A%M6a`Cz`P2M^k)%OUVD0z0Qzy)3Y9vjUlA67OD%ua<%gl?m3cB@Oh--cvR(#MZb zv>VW|pwWw83?S~z5eFg((Ek^a$a$Ls^pdCy{Mj$|F!b`U6%?ROZ#HN1Gef`zth+d9 z3hSx&fz4UiX?w}n7;1%BKJu0KX!j9&K`5^=`KlXvnG#~ET_ejZ(U#slCFe2i8P~?i zr>}~vLyyiS9Wc-w$GrB5Zzai0vRa@O3}+)RImqQKmQDvllhAe(BaO5%#p>qd;NO_O zL+VCa)fHm4i@!r?s%YJQhlsZ&v`Zr-TK^b(hg^A&4M@yyrjM~<2|#a=!xg5gTzZUXdURS)jn6<9!%uG`BE0Yd?J(+f zr_2!E46t%v-uX9IL0G8e;2>2+4dTA2T}1Ic4r0G_5%s5(JHdiqRMwrAgZs*hk{Q{6PtZKu&Jd1lBTbp#09>P#0D@+<#@;+R_ya@3NS8bx z{SKRtpR)s^{$-P^)i=Ec=@exL;B5$%YzG(j%wg}liB5BA2#r+v7~e}X*SSVod36(? z`u#)l0uqtWRJ6}ktY#lS2n>c_<#*CCJ`i?yY>FDnq* z;U%ewS*K&JKm!lW9UH4%$3m**X~)~_01&T0Z=052(YDR9BXPh0EG3~ zeWi5pS8LEUfFy|y8lXze3knIWwDp4AknH|3ss1ttJ(_tj$lOa`;Jp41gB1rC*5!&m z#Tq2|)M2|5DjBmD7mEAJ9(%0F#Jv9if$eCGw4F1*R5fH~`A6gzgw1eslT!4*ZS*a^ z)179XAT?{27%%kn+@b=IZ7ZCA(E4%<=K56z$Nk9EQT$nkXn4`go^@kL+T#m-Lq}i5 zDZRo3i@nHi%yJl=gnTm3erX^ca(|p~@AejuHLQ-h!b`K23#440F#<6zIU&jfM68li zSU8|CFNNM`Rej_witL{;X0K3aP#`RF2Qxo;}p}Y$nNP zCTUe<%4i3&Vk|vKYG!1g)*SXmn+B_LIOgb=$|s(6bD3K`v9x4A+rCH}CTgE#@Yh#O z8vMC7EgFce^9Z0WgV9JYb{8OEuu}ru+YP|RE1qFDwhw9u8MXHoVSyT# zE}UC-+Fh`5!g{{efN65Bc)9M+P-Eyhy5yB)l|S{_dpp7gTAKSNOK*eA984My!MU{e zSehzN{hnxp(EVUxU(L*FG}3lNq_d(-rSr_W{2OGUah4vmXwRi)BA$FwO zJ~o7HhMVuq05)R+MuPYOU{gB#rbzHd0mQMKbOIXiN_ZxORYM9Hv-ThG9T#Bw3V;)8 zJ`$0J%)NdnVwT>y9-tJ@{LLF(DgZmNe8Frd!R4L@_n<@`T~RR+H|7vn*C~bhX$X*R zrOq%`M=I_Mh{)QSmNqS)$c?b-G&y#GmbX=`*W|tNj-rUhfHG}I57T!4`+0A=>Xb7y zva7m9qD{jOOw*M0vLY3$$ER_$t+>)>oi3*ErtVMoq`&I0taOpP%0(uRXa9x zR8gxcxY0XXJM_~2`*xfE<@|01CTe#xaajZOgY&{lQ2bHktzaz*33q;(2I!3tITOmq zY>>u%6A78~haVA(wYk>ru(rnNSw29TRutM+GA$D$F1Dqx4`nLhefIln3+mj`F`)l= zT^roy@{0ii&!z;}o=L+%fqd(Me5dK&#^WHN(}BJO+M}xi6a~!j{t=KdKW3om(N6Z1 zNSU%!xj3>ua_YGW840N}XRcgr8d3Q_r?L=KauO13rf0d`Bhou>^T@U1HTgc3@e#)i zOUDV})f}V;%Uy6$?SqdOqIW?6(}Sa7-fv>!w{_L5bV-}LG#UA~>Lm0XqfKq>-aA=* z_8eqgU%?EyEQiSo$1VV<5t<*8Z4uqEG35=GMO~E$(1h$Be>RqH9^Ryj<56+&E(6s8 zpT`xXid2)QvnwvIX3jljr5?{%mdHEy@Jmj8v6)H8tb<6Eo zbcB>nCt1|r7NG5qPK+h@fqYobq+_W9o2$rv)|6jf7qKniW!pI6v8Qe;{4Sm8szidvf+hf%fpcjhCxDQnU4d4i##s`K96X6x&in?dZhq zL=Q)Q-wTCp|8k!CBsB1-@(|7{8KLtzAUg1iP&O$X_#M_lhr14sgDSXH_msm2bdwsKxSG`ae9&1tdAOon`-2^@FOS^1juaOPRz>-FNk z?~!&II{yVowuE`H1`Oo>3GB@3el4L7i#m;xjW-X$qeRxF)gFohNWCaUgp8VAAqbM5 zT5-VIGG*jABJ;G)HpPh#5S*gglU*YuUZFGr);mA3h+OTn*%|vW+eh9d zi@}nEPpj!EK=o%_kh(6LGbAexfyQQ2>9;*AXZNhgaI%oF zI;WQnv#~m@eOU6UCMgc8S7qzi?jT*UI;}l%%k$X^yM~C3!0e1taex4Go8`G>zdn+{ z5$q7NAubYPah%F8c-WP<2(foi;H}JSJcgQK*O9fM64S}zQFOZmLsnCKrGc;=!Tm^{ z&uUXjqx6%eCeT-}foO}-WHdb*RGo}yTK_+NQvr1#h^{!jGzSixP=|q|2&H})FzeNC zHl^Vy?AHV(T%wgp_h;V+xP6xAD#n9qs@ut{YSJwBs+Ci)dWCyNo$TgJXseEP*;?v)8TJJoG(Ic>p1=%V9K$fd^U;H=CQoK z8Pru&)s7pRVk1Tk$dd&Thrn!MSDX`o!?tdu;}Fs$+JewT@}w159X;D8S7*~P{mDM2 z>*V9$7e@0It(o#tdjC_UIDY_rQ(6^-r9gTNTugo!_$5O6RfZPKPtTC``5Cj*qLBiV z>yt`(-0tsM+eY_@Y#ohQbw)}oL%p4=tL2`6wfE>juC~*p`z6AAtAmK%zIG65&Zqn99I=O8y zkj|WaEIvwjZCO2-;GtdQvwEO6D5=DDhjz^nrg}zwdVop-pe% z6>Q7L>+N?S}08DirH|1e3{_F)TfE4%UwHYq{;mWh5l1`{x(oix7s z876G#!72^sE2n7=u$wYzO?@L+C^X>(=6-hWVbSQGriT(Y|7dz7PTvhtp5sz5zzYBUt^!zow34%JA z72f3LF3=xv>mZ;;b~x?u0l!?R<#3vHmPiaJzp5`_3p7yiE`>2G`VJ%Aa)#rTTn7hqY3uO=@f7$;nqSGF;O^}^!M0y2Z z3=&YC0@PE=m$s9%$V}LztIY+h6jP}hsZci?6z^bix>jB2 z+RpQemn*1sP*364Cd$bLr#Z}-3WJ|8SO4y?Wk?&{F=E>_3-==f-uJZ;vVFv5Lgw54?Y(0yW>}Pr z4|XEq!fW>1A&~rvYa)SKvV)(=zX)ARXw9syM~Os}KHOOWj#))pKl=Vx0fA=~V-d>= z$LvCk9VN}3dqhkRg$MA-2te!u*sM|e1{<5H|hspyxGS3jSvE^=)GXf^wq1#aRRnh#P+thV7oC7QK?-8 zXq-nl#PdR@S#|1_^p((&HAg`f{b74HsqM2-;{si1c2lQM=$&;0!$19CZ97UNN?M{y z9KdnvK{WHvJK<7FxHyhen62DyVQh1Xz~O;r!hu&#v*y$Xv*qT@2}9>iw}xT|4b{Z= zK+a`#Xi#QRP3cuepyS3|cLL|d8FoZ^4yJ_swry7XOYXBK4s<@+oVoh#i#pk#E< z4P5IYC_ClUBH$qb~8CebK`4mlqv%=7H%y=AWEYH$U&C}B4LH5{+gPu>s zJqUnME`(lQnjdk9LeFppmCGy7^asz<#|U_`Z*T)R0qK~f0jczEGq3^eJ+DM zv*q?sM*=2S)fs`^edl3y$CTr=%r}0^r2{B|cyW~7iC#Ok?~cNkKb?@kyMV|wO%Pz~cB?{$kj<9O741Rk9)Y^mQgqIQ*yFTc4q`xelY%Vx9$5g)u zTiatUrC??sNqDOpy~@bnl#z*N&cLnk&3*FD((PQhEj-jx9ZXruwpij~wHPWmP^}T9 z6yh{nW$HM`!4wA_tL8czrwSspbOdpQ`GS;m#rhnPgTETuT+(B2zw@vm4y49)7Rg{z zq|7?FFd6tGWnhrr4*yt-@!&{J1-K2UNe4{~Ap1nC@->?1et0W|CiB3w2bc`9SfW@% z(K)$XYbVeyV};PM!tS}n5)iH4M|$z%M}CzBp^l5%4O?(&;)w(k2ozFiA{N8pIrV7b zBy6k2;!xyM4bXRE?hIdX2+j&=3c^l-4_2MhtiwJR-2=H4T{e5@&87t4Nd*Hhn z=)a7Xej+9(KOp{GY#fl4=``?s0wGpsg^dSVHFYB`Ok=evor4)WV2LXF14lV|KVpL>Kf8gB@g{heLK|EOJvD#1>F^ z>Oj(eRe;PeZE5l9sAmyIYF5;P_y>um;$rC2?h=u$>w=uUgoPUg5dVKs-mwp5L~&=N zLOsi(nsX5=g^~{30|72tTLVNN@|Po|1Jv?En&UQP=K_nRvPN+>d)J+Z@IRf!QSnGk znPORwD=q+X8usGbCH%kXbiCAt6V(kr)a{!Y(2@cC`hN^w3M`z^jiXC3c%7r(|IM!b zw_|1D-hS^7jRuI2P_|X+lD6i7c;ZHZb_^1_=_H)X%H;PE>g^ zLxkhnE({)uH3+rtRdnW8m%UY2;dbZN8mlCmohl>s0ctC)NBXvA=en3P_Oeq!X>t8u zHq{tVskAkEczJ{#%~hql<18%_EP_ShKMd;gYJ|q_J51dUtb{PW~^DVGY@VFI$x z;XGehjrCPJDM))#8GVWsglQ?Wcw*p+tbJVZPT1k31a88y)53ANR^64JgEH`U;z4RT zIkSfz;8UiXa!QKlMX0s>lEIbu#i5#aJ^n$!E-2rTDB73R7jk>AwRi*i3m8@Bk!*15 zm!O9DWi)wgeryC40p&dz*+Y@;rFp+~l+T(D&Y%puLUlXvY)({uj9ok&pc2C6({74c z-zv#?nnl7pPkMDv0q&8s-b7Y-1GJPq4-Xc8#5}pQ(5^d@7YC-*VYdO%IaQqkL@`)( zZ9`Khv&`J=#^&j2`VV?G0n0RMI@717O{v8dlRtZ?r7Zv8B)Z)xFvY^s%!uZiLVQeM z1|l2AORX07tx&L-Vw;bsT&2O8mq!Uo#3z0ui^{j0JV2zQ=Z(nZlQ{@0`Z|O7m{T z$kH~44eSe>j@q;I8QqW1ZX*`P)>3#0UQq)-L)Rm_;t7+QhTsZ^vF`MTuPHCg|8Qs~ zU*9gYSvg8W4&K>gYr5CVf;*!c*=}F8sKkZ#K2nhr^r}%f{oO&BTYHH|OygpV=zie8 z&zHJNxUw0RU4^V1WsR9&OD*^LG!+O#yCd77&Z!sELY%@lCqq+IsNhd~VVXb4iv>_$ zbYJ!7L+;&kDCZU;A7hb%CJhlwI#SZX=bPum^_bm|MgKYMtN>2(Cl~c&^}rYZ-V*Rm z!G{}zxrR>?!CN{G+A6zSjz(r1;Dfp67XDPO3H}r}#`t*&tBVS3IzUI_g|FJz@p2An zfR80GAc;TLEj|~FCegjJhvc2-5PzsHJ9V|bWYC%_oK+#ITV0ZL{O((aww@I;sUbw~ zB5oZjwLkh0;DGx!up~79r}4A{IiN|4f9e_oL!<|%{{)N!^-P_vz55w+4kD}pe^Rr` zZT%iIX;Majvmlg)T_$Lb__){K(VqB6^{5SaoTMjCwpo!n~1*m&SB3?^! zkma@_47ZXUZc;7H(v2Vmq&d2CVZp2H&KH9cdKkr}3s2bD3I`AdM&Ev=CgX zeTM=xbVb+$r9Xm9ewe*o|KzYRQs*MfM8jhcY2La4S{9d{&1%!XJL3TMh%pj$&AWVn zo+d4@#R@~GR$5aRdpZa#@vf_>7B9RVyrNEMWw76(S_PNrmw$jJKTvvSL(!*4~pfVekU9x8eG|Ptz4Tr^Z}^ywIHDIR8xRnOj^||z3MyV;Zmhy-&se?;!@B# z0&(Kq8vKa*H>`quP=yid@sT=QW^?kU#vjnT&vrwAub z3&1@RFfCYV7Ls?bvkhd)Y##)yH&~H*d^+&bmM3W8sT{LZ32BBeCA`=PJCMG0jO(Mv z3kX)wowo$0#Od2GrZR4~F7@MC6oode;Qjawjkia@wo&9AW4-PysAo&q|2&xI?M3%N z)3dh-^ockLW4fJ=$?hAbE1r0X;|S%5odXePYgZpcYiV)CWAnQlsx(*1!q=c&7T8^c zE?0{-tw8;kAAL64xj8gsJp9(9%OQ3ynVv#Mgx3)g;njQOHf6EQ#9Xj%He}@=+fXs> zBj3dwYIrI`F-NgAxT5HMA1Y~>+9P~HI*8jej25Xqzkfraq5c}1LZK3& z-dq#Va|t{p-J(s2-}|2|hPRZ_<_mRW;vsb$GE|~T=1VoT_$#kr)AvaYnWo+BnA*bx zErbBl>%%=z79}8sX-fEqHyM4pz3$r=m)R%4_nG1HhHG->Uj$!~iimxgAYfIT7W@bH zQ;hS^stj}onB1)xWM0h9{d)X9PLp}!)tM5_Uxdt8H{UJ`9$$WJjR0P?Uo2wzv!6UB zLGPX*N{n|9<(4%l{BxNmV68-#>LJ;sj=B-HNgnF4i=X_*kA47MSY7+KgrsT1x|EPTy`X40(hHEa zf~;HdbkuT@)no1lHKl~Jx3&Syk>CkSHrw`F^jbgSVyByhI_XzKgmJ1ubcD_4pgB6Z z2;>s80|o$WXaE$I4NLO_*!AwFKw5j_U-pn(4R*3xpVJdtsG z02~|UZMM;mx3(~tIT}UdtUXZJ+1dG6dIX4#C5`2++_p}!{L5^0+2v}Qx_}Gf<%uOK zpl`2zEbsjHxvIUKTBM#ga`>dzr$rFeUcUvL<*P#g(%9ZIm3ga2+RDjTa4azel$BY@e{hf~1d^?H@5>%Et(y*(~e;ypz zF{5HXCQ4tL=+fH~9nl&rH{6WPbiSEb_;7;{8K&yWuetEw)?LuPY(ZU?JXfAqdons(P0+138HNcoOjx+U zV1Xm~_c7`sj$*F&)YF`qzAEo%zFCj&<~1_z=iMl2uzfxsvJDV^g>tv;33VeuJwQ4C zcgCouc+|pf`~It2OvURkwLS(%et+lk)2m9m-Dna>ILpph4N}z`S81dS@y*}k$=Dou zijmV$5WL#x7db&Q_dJ{vES*ytA!XIO*V6O$o2I8tPqapTYBSsHzjb2w%s^e9=V-^4 zgI?^W8nNww*!&QOr3u=1Y=GVg z_=Jan9t`Q?4~?A(6!{rd@1~P!p?Yjn`ch&HbwV>F;%jA#u&y$ zDpWFn1A9MJ_hn@WFL)cwHsxXk$Zkyz3(gYAS)F9lKfU_0*stJwdF&xSunDq{)D>e0 z`#S@q4yf30A|iGSh2O)T*>UFDCTZa(ns$hK&6MF`k zS*{=*zd^&cw((L!q`osv?$8A2FrJdWFHj?ky5rpmBB=2IkJH6cLutv0;>Ers0@uEc zkPBL;6Q3XY^RD=#J99-mwtLud%tY)aHlV#|cF$mIq>Ry{KiI~`&h5LPbtYn_!4{?s zDewS68+BntUI2YMUflQYW5tuP^}_nPynv3e{UM6Mn<;_0mUm~p>9^vvT0N*Y-j5kp z)zq#f45iJt5ld%>snhez7e*GJaroT2pGS79A*-F(qx}5{G&TxL$*E~H-i0(%9;zb=N!vxi`uVR-^h;6H0F(0Ff25i0sS zeJZ;*+%Zo5(_ys#gh;}7Ow#?pmtUR|#JB{ePfPnRx*%U6*g1%j;=LiI^QW(GI>3h) z0}vK|Pj>#QsDTqSpw%z`w&)Z#&|-fcwV(~!mKvZoJGR-HSvn`V{A`=lx~+eNzZUxM zH5UIQ--UJfM-$}y-H;jF2)1_4x{|+W7r-}?U=26l|2z(H1x3mY!};%KP2oR+HUNwI zq zUc1Qp6Q>{6NWnv?(N(GH?%Gh*M3$Q1`$?OZPxm)4^>0Szbj*;%j*Pbn61Dvc z*<>KxYdRWoPe~x$omc5fyMFut_zfrHfASBYC-$l;U1WMMq-_O8{ew$I<({j1 zGZ6j{A$@L)`VtKgk~ELvIZK94ltwQ$fD~wFGS%^=!tWa@`YQWRfu6;`CBJNOYRC6v z%LxisgoHMo@wwhKv@*0(zC0vOvMiG&t7(|R4BPP5SkxM1G5B?pl}IKjvQH0D7cdwM z>KHX^aZcq|-_BzUY9>|sIKDbo2Ex5^T`Vq)Z6_6dmQ{fC2~<--s+j4gSfzh4>_dd) z0N9-7n_;Rd@A)lX3w5c`V359idtg4t_qA8kA@K!jVZnY!ppm=hX6}0y%&N4+0DMM| zEQphwt@0wcC&T*m$)g|M0C8pFS^~iEuPqIKT=wYo4$Z?RHm`F`rGzZ6b@){(RFV8E zCa&S8JbHHFzf_}Jiv6r6{Y#N42xc;*&y(Ne;5DWtQ8j&`>X3C+)xeCjZ_R8-PZ=xQ zy#s?NAC5t`PEqeCnkjaalbsEZ<|Wy3vpQiL zQ*Wefk z?T1Eq{-k$gVrk1zLuvCZ^A~v)mql^EQPQ=InckIoxP zkQz{%7vk1iH*-UaJ!it6^T8`Y+RD`XysvKtozz!a_~3dqic-gf@H~f^T^ePKRuRz^ zNdV;6I5ZP;l!q9ad9@Ok@w|4xkMHRf)R}KKJ2ik(nRJ+XG3J<|l5UqgSgHTv+}pl) zTM>rkq)2DVCiR(s2=)Zcw|{IileQ+=ND;(GQ=*(@9n-x|gPHP&pgh#Ur4aLG(%K`( z`t~L+pY(S}tM|dR{(x%|y`PhR!#^Uo)hpby#6)LQ8kRc+IoS$&I|t9!OKVPo>p=~# zajU0#rw4np9b?rMayIe341E0t$46qdsqSUQ0_q8&u(j~*+3GSNo4fXd=n5!159iip zt2TuY#rb>$?O-Ampp~gkum=^^4qArqyd%h0@n^*=j=n;{V#>F<9=XeWv`^FPhS7bC z(xHtFlVm*ZLcb_x`-1fEyP$}BZir`6 z$Yp)QU(KJ`RY%(o`be7{jG6IfRO)sH5LVM?e>FG~S{lVUu;Ij;gg-C|s%V=5b8H)K zz5tiM&>t2=?@#ybX!fdHa|6re?1^kO>6&TL16bGAl5vs4qFi`2*&*>l;Xt!@orGmf zS+4m^;S-N)inu$J+vv$@jP}E|Mi7&)sL3m6>~cG5^b)vZ9fobj1`vSfQ%pHJe? zAYdPFhIYCq>(-FeRi?0hs)L95?3WXjQWw-9hBbWU+v;`jxM+FZ!)rmbs3a+|>Iu=5NHQbY`(i!yxs5ZT%u3VwF>t!Y!BS#>Wk-5@X$!@P*Ic$y4;CZt{@jv z+cIhaqZU>1Dk~A7XamqQ^{Mr7AIy}?+_K=5-4~V%>onyU|8g9!!R{TC3~jwDA$jHv zhCH#R&BBJKYN79@RPo#X3o2I3*EXvg(9XbZOn(B8Fq1o+H+fjt&?dLzIcT-G^V3Re zg@zs*tI<023DP@33CS>H8(vsJ&6Voonqh}nyE-p7YxyzH^6|1DSI86wi>G_w9UPc7 zC`z^MWLLrq!I+(ki>L0dVm{nk`({W+(lu9PdyzysvIS)yeCVLOwg*Tw^U%P&1pg z^F)tW*xMZY>QyC|;lCPJExNfbA)APRW!Ldd&v=+FK9=PpB$T}v;n)Cv;$s} zrT*1ev~FVT%M9b}3}f>Q<2QDm-W;cl3l!5$Zt*R|TKf3QhiiG4uDob2D{h&O;jnR@ zGNCLLsdoz@w)IVz1j9i;D}h4!B+YyFO`$yW+3G;`Yl#izXtH6TYTDKvjd9;C)?l*k z!hs3*C#s%xl;WB%^IR=%hgK&STB=S$O`U+Ox-4#e(b6%D5*rIH>gF<9cZH+wAopyn z%_Z2Kkb}6Gilqdmg$y%-4!jnIv~NC1DGL<)pl&++S;zEBcK&!mRY71&F|qm)_M=jS zQXa=ko7zYOsaKzYQ9R76h#0^Q33h&xKSC`#*fM~ z(=OrMjx?c^YMEy5rZ8;ZFrAeTeBSG<3^VEPEg|!HIL|?PqbeMR2Y`K&TZSFgVW?Hj z)xKuUjx~EjBxm9wcm!YBaxE|_R-A(kNZyB>Es?A_0B1H`+901*8Jhe2`e~t_M@Ex$ zsxJ8t3|PTA!>)K0n|1Q5u851h^4Xi*`k#)hbU>`Q(Vgua4q(BVs;hFI)uXVLx)6)salLHb6WV)ZnI zMW$Tq9*UB9mY-f=Q(a^a^*N27foIHlbH#Bx+lM>c9oE$sgG$Q%;hgPyu$S5^Z4y5p zi^@7o1^85Dd5B}Lvi0bB(v8x}kae;$-h$-c9fd|w?NW)_aV^gmGrgn%I+TynT1(io zep=^b_3EJl_aK+YT)-?{&G{5RS=ovqZe|@dUs%&1`7N{N`_I1>UNJC)EirnG?SAjt zBlp}yES8=bo&z7Hy&noPghHXE+UfRYHFRyspiE)W1sAHKZM{*~m zLA#vWs@)hf3(&tT1G2J*%eM5Zx(+(o83m?E-gUW19%ZoEft5s7Ftk zgG6NAJ-g7Fko(-=XJpYxo}C4WX>b`qy2DOP=A+E4+}-qcC!g4c*j1mHc5 z37V)>+)<==R{9z&#r*TVCi+_{mb00Xm*wtKo*MGPX}mr3YD4#8nLg^r^HL!?zX}j! z;+r~*J-9_A7lpww5}!*lTRIqJK5mh_`;;ku1{n7XZp4Ji3I+F#l%Tpnmlt0Jsv^W4 z8bXgpa-s$HS?1&a%?aKiw6Ww*eB@dda-)GAz@ei$_)(VTuS-e$l~xi%r_MvkC$MYw4hf>Ffr8v)BON26nEH z&_~Y8$Sj#K3qQ<6;d12}#_tQB;%auD(ko_&Sd(CsIeRu?h#1 z-Rwh=Yk#fnMNQSdXWg&u_fFA9EHkz_Eih8;z(`dfY;n`;O&UovR?3^%}bGlH`I2-ltn4A%OMw1t>OQ zt~_aoVb7ExtFg>mioQwUCcAxs6GKR7CtN67zvj0}hcD=Ogq6?x)1jrDt8DAgT8=(D zZ)!yc%WNCKX=<+wwsAZ1imnIDYPO_3tWMiKw#2CpP>XH*XZo&gd8adGJ{-HK+U3duNRL>YK^VeP{a47?w`h<6Qfk%_1wanD?}M zD+xU|!ivGagR9f;K;YncA1xgvn{iu7?aZ*_ZOHT#=iq!@MD0XQ>*}C5?UjKuRegpP z+njJ(pgsxeN4)uz3phk`iz1w=3x{kX25|cX8~L2(N=Lt{agn>=(o=C~1vIOF!g8HpBM2_3 zpnZ)k<@lD!wY>^w0c^TBLb9sGy3R3=`@!}Q^>Xam`SGLmOhju<3}`Qoyb3YbOD;Hv(7WWe)*Yf#lL>mGk~KQT11Z zO+boUM!&ysfBD}MAY=}sjc-OIIXF7S*}@!0MxUsY%O#aQJg6EC-2 zKP5nNf&u>3dF%;^bB!9Or#RQpdUT32CE%x*?&iuX>?#MDsb%jKLeWnw8G|LaM;hdz zcQYSED9YK)abRqZ6$d;?1+%`jdu+dytVjvAXivHUJAU#l@#Kd_X|oSHYN0-%yjek} z(l5NQ+rXo*;dCiZ)kYR)T!CF%@kcTKAmmymIz9Pj%M4S__uYLd^zcR zqtnD_oC>`un?^<#T|)CiVK|p5I&ntEX5WI0pTZmJf`1}0GXz}%V0D14xIz)fq4T=| zNictazORcHfIkH?j@v&?`CfP@a+)P~SevsQ1{XRCvCLe_?pRK0e>HDoPrLn@^2%pS z`=-+i?pH4|{*1_o4s+HA*{jXraSmw5cJ|3pHerk6iVZ29{1dZk2Etok zXk5&t&iS`jZDh zv*h@FMIfvRh>7wlEW49f6Vz9kZxkK={o%5(a-2U^WZw0_QUr+F?6tB*GV$ba=Mw= zXf4Ii)VWuD%&~_Ba+{bP{E}dG*rPYTL5dC_@I0M$3Z0jVyVx132x<0>WW~=&Hn7Jl z6sx22Y)$RYvL_D3$kjHE;U~pHi)(9bPS#Cu{IuHkEDSwqbwgdq&#Unu;?nIAz>sxa2)zS zk^wA=Wu2bLQyt)SeT1Wz-HKyqW-K$+3VxxhHi|KiJLhjo-8+V-`6i-0&w`Gj%Rw~T z*3*>gCc5HR+Z@V4&JiXL8y)w#VsPGQ`Z>4M6hfSewXq+jXWyEjZg3@ObBLn$dEblQ6HW5>;{QzJ4=HP?<_HI=84rc{ZvWM{8kLplc}X z3C8^C>@U}2BP5(}>c15!2AG+*!iOoxrF0ZSL!h9ThOOBP*RZhe>5e$^?21{nr z$BwtFZ3%a>W(B&Xhc_b-O~kXzS;nb`#$3R3*+#r6<*Ej;_2Z>n?DLppuh$Ssmow#8 z5ysF&*CT-grqO!>t(`#kkdQ$SwBy2T_QN8${GX$$8^lUZCkwbMd^xlxz8i&*#SiRt z&KWQO*5x**cCAv_zKsjt6}m6h)cSMsSl6T^U*48SM_2*+-C$Y+p9GXjp_a1Loc}_{ z)UPZx{nGKMJr3RY4gqa6c*?U6Ulad}Ja?K}!^WT8vt$hhc~TAeOvA`N(tKByB`9Hh z0b&WSMvvsqA^Z7SGwx|B z@F>A^IW=Nf^yi%O9_aaKdB80n>WZ$NnFr20Ui0#>OQ>P@Q-P(K{jSnm3jeD94IivB z8g2o-7zk>B!kq_#nGT^&!&{#V7}buwCQ%oDQ4og~q#%EaK<;w%mQOzFtThq~t zhhRwN3FgI|dqP z@+d$)9+jo{{tvRz_jPzU#rd2V3uk5&frd}q_~=j(y!yZYUPG4i{W@W{oHW1r7aDhA zh~t^FD->MxAl2%hv8)%n1KZ368A`zumTa_5=x5U|Yjnl=18n4xj-@o`<4P-ZK!dzx zTVPkYB`8C+TF>PX5Oo;e`ZcPUy193rcNu>8Dqu3Y(u2O_EgxvIS_OENw5Rm(g5N=x zF8+wnOMTh3VSincT;+(|kJBkcZ1zCgjdVt8mjfstxm5PmKa}Nf70PJ}?Vq1;)anZ) z)(m#4alY2~O~T1$aEGTSx3m@NPyeQGWLLY#=_H*I<);~F9U2d zUEyen+H@Whun~jhpBcu2!)XQds8a}MSQ^Qi?O=;&&VIDBNn0-tIogcmyhURC`n`0- zUM7MV?qxb&+WW=HrT71NX9TGWT(Ao$J3>i&j}3UIXKBAc9Fno+W;8rQz+z(F2t?Bp z2#(_GI{Kx6PvQJhfOvq1fjw&+ICoOfe*pyW^CsUJyO3tlH950IW&Ru#ashELO3D$} z03|oeqZJZ;U;n=EP6%0mC$Ovm^9dCg=Vw2Su}CI&2~n~_Y9YOpko!>C4K$XjvP+)V zM2~y%K&MUs0Z>D)y}r<@ZoU&Ojt5#QZFG7)V3jrH08-JneL;Yp)h+7T0#)rI zVeS7H|F6XH^9zbyti2k*$ilaRDxCq-9XYJJXs*Xu=EBYbNz^0x=WVzBW=+sSar63^zK#xB5D7VB;gI%-_L^1{R4}R^`-wgv!P}}&Nwt9y#fW{-Y zAs|*W@F!?c5A|PE=B;nL>HHQ4pS|5+J03x|$p}s}$uSU?PK$En7(S^wJd78(;9psr zmZqCz0g{=2HEWOeYN*M(0U>k!xAJL;pbRFu^I9aXlF2T#a&Nci!o6Grov@Rvu!E*; zL`MafRhH}^za&L!G2<>Iq+I-WwK_!DJtk=95lhA+wCwCjg9Lz;?@n`RcXd4g!0GQ^ ziEF5G#i`gc*>jB!&+KIe$422xixSrJx4Vw4(M{(Kj5oVtF*Bgu39>h-4P#=N*#OmA zo(E!N)}9Y~GtWlu23>z)7=^J0w8vTD&8CjxvRrZJ{8M;lCY`NZ7o6sjs<`Ebsn_Wa zMx`^R?k+j}nGEFyP*ZUcUku}8U=N#!RNvky>WQ<+SP!hmlED7az8S=5fs-Kh>mNOrj4md*R+{U_mA9#xoyy>%RexEaAH$x?6;fZKbb%6 z94{RbwZg5Z4B0)qwsiHKA!65<${EXm@lF-!8DH0_a5TJi#F*f~O3~r2t&hAkfN}^b zRg7K*vH3uC43x5!J~$pIbqb?yIDd(?r96E(LcBOXZp#P__Di7^eWzI!jNoNPt6W-! zf4CIxk<*NpckL>ii%s+Er8KD&-;A^YRedz<+MvYM`(1(iv-I769DVLyhGXcAV^NM4 zm!f4=7d$uB6Od>re)W+!F28kRGjqd@mxVO`H}mt4KYyk(O=~V*3#7O?G_4+>T70t! zw8TdinGI+Q)u}^$I)Gw*Z@c|?qH|F2@CbGF{}@g~p3ztziRVWJ`f@%NV6M520vjMv zND6^e0F;2>miE6SaWQ&l)qtPX;++EUCd`<1wVi4E@)-ac1viQRCoPkHZ(^3kA|56=y>^m^W!SaHu`;{V_VSsDGf zlbQqZ^ZS7Srz&6~W%`0PbpPVCoj{B&+@S)dleV_oau)+qk z+vN8NygmCGPd8Fu#kzm>zf%1NVOo7&O_KZ&Fwxnk1L^mtCM|yh%zONqFVZ??1yReM zvyPo;`E}d+Pc6we^zJ{rBl&Q{l@pF5R~2qTwu>Koy`_6uo#WR>#pxauL4noipf7B0 zW(K8LYl=NsKrqkG*s?r6*nYZz&tGsJu4fnRxj;xRAQbe}nvF$c@qABW&Ut|55j_57 z6<2lDZkPrhs$qS`J{p!;2(bx;9qq9^xF_v}Ty4rgkni9duY`rLpwP=SH%M|^>!rsw z@4nQkd5#=zUR2#5&s8SspLHzOMPFmtq^WvuBQF}*>-((qvNM&;vdqeZ(5+jK#LyQH z!t?l_#)QmM(R`+h-&7}TSCi5I zKm7k8{nRQM9B-y=ipQ$KaZWFZ7JKyPrD%0cw3V%e^SMOn7*+a|C!a~Rt!+A9SZ4dBZJ5U%o-%s@VY32~lWzp=4tf_GN`Z}GM;QS=#kKqt1Xcom zD2^yk+}ZR73G*ycAM4dlM-B*f>6ef7j!Fe5#*2Pz;%#FWnxR<|Uv1RqKWa+P@)~SnI#4j=R2gK3g7C8{-5*CH6_H@8 z3;n2}+kQY|``kmVyna^hc3tN~2(k7JpaxhYC;W7Cj76P=Qd^pa>8;G&fhOu#ap`>- zFVIGpY8ww+dokFiVG~(Kt-^U16Z_IH>?QlYp^Z{Mc;0i!Nlcz&Snk#^vq8JIZzfW^ zLv955eQtxM1wE#|XQYHoR8T_%rz;2VxE=o&IodDCF`Zn`;b^Cw*daZe^C3y=BR^^9 zUMaDyX0oe|^~p4dsj*w3x|~$H-2alKiU3z{-fyL z_59McaraN{u~EPNQtSB1+Uw7sZgW5SICzu$sWq#wp3~N!8(q2nxz!Vi)!7?wJzkkT zJ^R}WJD{T)CO`SSHC6FT7*e+XJm-`5OV%2_s3l7#?3gD1)4@K~!D~aEw8r+QmYTKe zRFA}1tbOwDPrKq%r_)U`=B@sH-&e$(C=UCc+JE(9(V90G=h`p-q-~vk{axJ8zrUi6 zyqdNA0dQp&@3J}nze*?VeH+EJ_ME!$^Xux@t Date: Wed, 20 May 2026 18:48:02 -0700 Subject: [PATCH 031/177] rename all functionality of measure_2a -> measure_2, and remove measure_2b --- .../gui/lapd_xyz_transform_calculator.py | 110 ++++-------------- 1 file changed, 21 insertions(+), 89 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index a532c02f..b2eff99f 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -31,7 +31,7 @@ class LaPDXYZTransformCalculator(QMainWindow): _defaults = { # all values in cm "measure_1": 54.2, - "measure_2a": 58.0, + "measure_2": 58.0, } def __init__(self): @@ -49,8 +49,7 @@ def __init__(self): QLineEdit { border: 2px solid black; border-radius: 5px } QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } - QLineEdit#measure_2a { border: 2px solid rgb(255, 0, 0) } - QLineEdit#measure_2b { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2 { border: 2px solid rgb(255, 0, 0) } QLineEdit#ball_valve_cap_thickness { border: 2px solid rgb(68, 114, 196); @@ -102,8 +101,7 @@ def __init__(self): # constants need to be defined first self.measure_1 = self._defaults["measure_1"] - self.measure_2a = self._defaults["measure_2a"] - self.measure_2b = self.convert_measure_2a_to_measure_2b() + self.measure_2 = self._defaults["measure_2"] # mesures and constants need to be defined first self.pivot_to_center = 58.771 @@ -133,7 +131,7 @@ def __init__(self): _txt.setObjectName("measure_1") self.measure_1_label = _txt - _txt = QLineEdit(f"{self.measure_2a:.2f} cm", parent=self) + _txt = QLineEdit(f"{self.measure_2:.2f} cm", parent=self) _txt.setReadOnly(False) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) font = _txt.font() @@ -142,21 +140,8 @@ def __init__(self): p = self.geometry().topLeft() + QPoint(1228, 447) _txt.move(p) _txt.setFixedWidth(120) - _txt.setObjectName("measure_2a") - self.measure_2a_label = _txt - - _txt = QLineEdit(f"{self.measure_2b:.2f} cm", parent=self) - _txt.setReadOnly(False) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1228, 499) - _txt.move(p) - _txt.setFixedWidth(120) - _txt.setObjectName("measure_2b") - self.measure_2b_label = _txt - self.measure_2b_label.setEnabled(False) + _txt.setObjectName("measure_2") + self.measure_2_label = _txt _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) _txt.setReadOnly(True) @@ -254,15 +239,10 @@ def __init__(self): self.reset_btn = _btn _btn = QRadioButton(parent=self) - p = self.measure_2a_label.pos() + QPoint(self.measure_2a_label.width() + 6, 0) + p = self.measure_2_label.pos() + QPoint(self.measure_2_label.width() + 6, 0) _btn.move(p) _btn.setChecked(True) - self.measure_2a_btn = _btn - - _btn = QRadioButton(parent=self) - p = self.measure_2b_label.pos() + QPoint(self.measure_2b_label.width() + 6, 0) - _btn.move(p) - self.measure_2b_btn = _btn + self.measure_2_btn = _btn layout = self._define_layout() self.centralWidget().setLayout(layout) @@ -279,13 +259,11 @@ def _define_main_window(self): def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) - self.measure_2a_label.editingFinished.connect(self._validate_measure_2a) - self.measure_2b_label.editingFinished.connect(self._validate_measure_2b) + self.measure_2_label.editingFinished.connect(self._validate_measure_2) self.reset_btn.clicked.connect(self._reset_measure_values) - self.measure_2a_btn.toggled.connect(self._measure_2a_input_selected) - self.measure_2b_btn.toggled.connect(self._measure_2b_input_selected) + self.measure_2_btn.toggled.connect(self._measure_2_input_selected) def _define_layout(self): image_layout = QVBoxLayout() @@ -300,22 +278,6 @@ def _define_layout(self): layout.addStretch() return layout - def convert_measure_2a_to_measure_2b( - self, measure_2a: Optional[float] = None - ) -> float: - if measure_2a is None: - measure_2a = self.measure_2a - - return measure_2a + self.velmex_rail_width + self.fiducial_width - - def convert_measure_2b_to_measure_2a( - self, measure_2b: Optional[float] = None - ) -> float: - if measure_2b is None: - measure_2b = self.measure_2b - - return measure_2b - self.velmex_rail_width - self.fiducial_width - def calc_pivot_to_feedthru(self): return ( self.ball_valve_cap_thickness @@ -328,7 +290,7 @@ def calc_pivot_to_drive(self): self.ball_valve_cap_thickness + self.measure_1 + self.probe_drive_endplate_thickness - + self.measure_2a + + self.measure_2 + 0.5 * self.velmex_rail_width ) @@ -338,25 +300,18 @@ def recalculate_parameters(self): self._update_all_labels() - def _measure_2a_input_selected(self): - self.measure_2a_label.setEnabled(True) - self.measure_2b_label.setEnabled(False) - - def _measure_2b_input_selected(self): - self.measure_2a_label.setEnabled(False) - self.measure_2b_label.setEnabled(True) + def _measure_2_input_selected(self): + self.measure_2_label.setEnabled(True) def _reset_measure_values(self): self.measure_1 = self._defaults["measure_1"] - self.measure_2a = self._defaults["measure_2a"] - self.measure_2b = self.convert_measure_2a_to_measure_2b() + self.measure_2 = self._defaults["measure_2"] self.recalculate_parameters() def _update_all_labels(self): self._update_measure_1_label() - self._update_measure_2a_label() - self._update_measure_2b_label() + self._update_measure_2_label() self._update_pivot_to_feedthru_label() self._update_pivot_to_drive_label() @@ -372,13 +327,9 @@ def _update_measure_1_label(self): _txt = f"{self.measure_1:.2f} cm" self.measure_1_label.setText(_txt) - def _update_measure_2a_label(self): - _txt = f"{self.measure_2a:.2f} cm" - self.measure_2a_label.setText(_txt) - - def _update_measure_2b_label(self): - _txt = f"{self.measure_2b:.2f} cm" - self.measure_2b_label.setText(_txt) + def _update_measure_2_label(self): + _txt = f"{self.measure_2:.2f} cm" + self.measure_2_label.setText(_txt) @staticmethod def _validate_measure(text: str) -> Union[float, None]: @@ -412,8 +363,8 @@ def _validate_measure_1(self): self._update_all_labels() @Slot() - def _validate_measure_2a(self): - _txt = self.measure_2a_label.text() + def _validate_measure_2(self): + _txt = self.measure_2_label.text() value = self._validate_measure(_txt) if value is None: @@ -422,26 +373,7 @@ def _validate_measure_2a(self): # not physically possible pass else: - self.measure_2a = value - self.measure_2b = self.convert_measure_2a_to_measure_2b() - self.recalculate_parameters() - return - - self._update_all_labels() - - @Slot() - def _validate_measure_2b(self): - _txt = self.measure_2b_label.text() - value = self._validate_measure(_txt) - - if value is None: - pass - elif value <= self.velmex_rail_width + self.fiducial_width: - # not physically possible - pass - else: - self.measure_2b = value - self.measure_2a = self.convert_measure_2b_to_measure_2a() + self.measure_2 = value self.recalculate_parameters() return From 3d4de9a6329efc56891ecd955bf2c33d38d0eca5 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 18:48:27 -0700 Subject: [PATCH 032/177] reposition the "Reset to Defaults" button --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index b2eff99f..e8a7c30c 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -234,7 +234,7 @@ def __init__(self): _btn.setFixedWidth(200) _btn.setFixedHeight(36) _btn.setPointSize(14) - p = self.geometry().topLeft() + QPoint(32, 472) + p = self.geometry().topLeft() + QPoint(270, 694) _btn.move(p) self.reset_btn = _btn From 3a19f1754ac41adc049e5e060905b394862b4088 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:03:09 -0700 Subject: [PATCH 033/177] reposition the "pivot_to_center" text box --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index e8a7c30c..498d9772 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -114,7 +114,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(260, 43) + p = self.geometry().topLeft() + QPoint(265, 17) _txt.move(p) _txt.setFixedWidth(120) self.pivot_to_center_label = _txt From 7f85cd8910e9b7e522bc3b9242097d7343f2d7d6 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:05:18 -0700 Subject: [PATCH 034/177] rename functionality for pivot_to_drive -> pivot_to_xzcross --- .../gui/lapd_xyz_transform_calculator.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 498d9772..d2818810 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -106,7 +106,7 @@ def __init__(self): # mesures and constants need to be defined first self.pivot_to_center = 58.771 self.pivot_to_feedthru = self.calc_pivot_to_feedthru() - self.pivot_to_drive = self.calc_pivot_to_drive() + self.pivot_to_xzcross = self.calc_pivot_to_xzcross() _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) _txt.setReadOnly(True) @@ -154,7 +154,7 @@ def __init__(self): _txt.setFixedWidth(120) self.pivot_to_feedthru_label = _txt - _txt = QLineEdit(f"{self.pivot_to_drive:.3f} cm", parent=self) + _txt = QLineEdit(f"{self.pivot_to_xzcross:.3f} cm", parent=self) _txt.setReadOnly(True) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) font = _txt.font() @@ -163,7 +163,7 @@ def __init__(self): p = self.geometry().topLeft() + QPoint(1134, 43) _txt.move(p) _txt.setFixedWidth(120) - self.pivot_to_drive_label = _txt + self.pivot_to_xzcross_label = _txt _txt = QLineEdit(f"{self.ball_valve_cap_thickness:.3f} cm", parent=self) _txt.setReadOnly(True) @@ -285,7 +285,7 @@ def calc_pivot_to_feedthru(self): - self.probe_kf40_thickness ) - def calc_pivot_to_drive(self): + def calc_pivot_to_xzcross(self): return ( self.ball_valve_cap_thickness + self.measure_1 @@ -296,7 +296,7 @@ def calc_pivot_to_drive(self): def recalculate_parameters(self): self.pivot_to_feedthru = self.calc_pivot_to_feedthru() - self.pivot_to_drive = self.calc_pivot_to_drive() + self.pivot_to_xzcross = self.calc_pivot_to_xzcross() self._update_all_labels() @@ -313,15 +313,15 @@ def _update_all_labels(self): self._update_measure_1_label() self._update_measure_2_label() self._update_pivot_to_feedthru_label() - self._update_pivot_to_drive_label() + self._update_pivot_to_xzcross_label() def _update_pivot_to_feedthru_label(self): _txt = f"{self.pivot_to_feedthru:.3f} cm" self.pivot_to_feedthru_label.setText(_txt) - def _update_pivot_to_drive_label(self): - _txt = f"{self.pivot_to_drive:.3f} cm" - self.pivot_to_drive_label.setText(_txt) + def _update_pivot_to_xzcross_label(self): + _txt = f"{self.pivot_to_xzcross:.3f} cm" + self.pivot_to_xzcross_label.setText(_txt) def _update_measure_1_label(self): _txt = f"{self.measure_1:.2f} cm" From 6b2bd9fdeee143713a727a40321536f0eda3eba1 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:08:41 -0700 Subject: [PATCH 035/177] reposition pivot_to_center and pivot_to_xzcross text boxes --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index d2818810..f254b4a6 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -114,7 +114,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(265, 17) + p = self.geometry().topLeft() + QPoint(262, 17) _txt.move(p) _txt.setFixedWidth(120) self.pivot_to_center_label = _txt @@ -160,7 +160,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1134, 43) + p = self.geometry().topLeft() + QPoint(980, 17) _txt.move(p) _txt.setFixedWidth(120) self.pivot_to_xzcross_label = _txt From 0302ff3ff231367b830350c5a9d657f75b1b2dcd Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:11:28 -0700 Subject: [PATCH 036/177] reposition pivot_to_feedthru text box --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index f254b4a6..e75bdb4d 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -149,7 +149,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(736, 98) + p = self.geometry().topLeft() + QPoint(570, 108) _txt.move(p) _txt.setFixedWidth(120) self.pivot_to_feedthru_label = _txt From 45330e0e2919269ce74e601bcf9384b41a458162 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:13:11 -0700 Subject: [PATCH 037/177] remove "measure_2" radio button --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index e75bdb4d..26e59e38 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -238,12 +238,6 @@ def __init__(self): _btn.move(p) self.reset_btn = _btn - _btn = QRadioButton(parent=self) - p = self.measure_2_label.pos() + QPoint(self.measure_2_label.width() + 6, 0) - _btn.move(p) - _btn.setChecked(True) - self.measure_2_btn = _btn - layout = self._define_layout() self.centralWidget().setLayout(layout) @@ -263,8 +257,6 @@ def _connect_signals(self): self.reset_btn.clicked.connect(self._reset_measure_values) - self.measure_2_btn.toggled.connect(self._measure_2_input_selected) - def _define_layout(self): image_layout = QVBoxLayout() image_layout.setContentsMargins(0, 0, 0, 0) @@ -300,9 +292,6 @@ def recalculate_parameters(self): self._update_all_labels() - def _measure_2_input_selected(self): - self.measure_2_label.setEnabled(True) - def _reset_measure_values(self): self.measure_1 = self._defaults["measure_1"] self.measure_2 = self._defaults["measure_2"] From fb4e740a4ed23b4e4c71dcd4b947d981f534e03f Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:18:28 -0700 Subject: [PATCH 038/177] move "measure_1" text box --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 26e59e38..76b5ff6d 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -125,7 +125,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(763, 432) + p = self.geometry().topLeft() + QPoint(598, 442) _txt.move(p) _txt.setFixedWidth(120) _txt.setObjectName("measure_1") From 5ccec99419f49979827efd7afcf4ec9abc26b2fa Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:22:42 -0700 Subject: [PATCH 039/177] move "measure_2" text box --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 76b5ff6d..967d609b 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -137,7 +137,7 @@ def __init__(self): font = _txt.font() font.setPointSize(14) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1228, 447) + p = self.geometry().topLeft() + QPoint(1050, 508) _txt.move(p) _txt.setFixedWidth(120) _txt.setObjectName("measure_2") From 3ec71c5e55651cbf02270657bcfb12da0ce03383 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:25:38 -0700 Subject: [PATCH 040/177] remove functionality around fiducial_width --- .../gui/lapd_xyz_transform_calculator.py | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 967d609b..40e3f44a 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -67,10 +67,6 @@ def __init__(self): border: 2px solid rgb(68, 114, 196); color: rgb(68, 114, 196); } - QLineEdit#fiducial_width { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } """ self.setStyleSheet(_stylesheet) @@ -97,7 +93,6 @@ def __init__(self): self.probe_drive_endplate_thickness = 0.75 * 2.54 self.probe_kf40_thickness = 2.54 self.velmex_rail_width = 3.4 * 2.54 - self.fiducial_width = 1.775 * 2.54 # constants need to be defined first self.measure_1 = self._defaults["measure_1"] @@ -217,19 +212,6 @@ def __init__(self): _txt.setObjectName("velmex_rail_width") self.velmex_rail_width_label = _txt - _txt = QLineEdit(f"{self.fiducial_width:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(12) - font.setBold(True) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1774, 512) - _txt.move(p) - _txt.setFixedWidth(86) - _txt.setObjectName("fiducial_width") - self.fiducial_width_label = _txt - _btn = StyleButton("Reset to Defaults", parent=self) _btn.setFixedWidth(200) _btn.setFixedHeight(36) From 2b0d672471dd4dd20eb696c5af79ce90e182cecc Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 20 May 2026 19:39:17 -0700 Subject: [PATCH 041/177] move text boxes --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 40e3f44a..c46abcab 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -167,7 +167,7 @@ def __init__(self): font.setPointSize(12) font.setBold(True) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(691, 181) + p = self.geometry().topLeft() + QPoint(526, 191) _txt.move(p) _txt.setFixedWidth(86) _txt.setObjectName("ball_valve_cap_thickness") @@ -180,7 +180,7 @@ def __init__(self): font.setPointSize(12) font.setBold(True) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1218, 177) + p = self.geometry().topLeft() + QPoint(1053, 187) _txt.move(p) _txt.setFixedWidth(86) _txt.setObjectName("probe_kf40_thickness") @@ -193,7 +193,7 @@ def __init__(self): font.setPointSize(12) font.setBold(True) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1294, 220) + p = self.geometry().topLeft() + QPoint(1129, 230) _txt.move(p) _txt.setFixedWidth(86) _txt.setObjectName("probe_drive_endplate_thickness") @@ -206,7 +206,7 @@ def __init__(self): font.setPointSize(12) font.setBold(True) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1496, 121) + p = self.geometry().topLeft() + QPoint(1496-273, 121+24) _txt.move(p) _txt.setFixedWidth(86) _txt.setObjectName("velmex_rail_width") From 0875feb53085f26d72d884e9698be151e4fd8fd5 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 21 May 2026 12:12:42 -0700 Subject: [PATCH 042/177] reorder initialization of constants, measures, and calc parameters...add parameters probe_axis_offset and table_pivot_to_zlead_screw --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index c46abcab..3289c7ef 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -88,18 +88,20 @@ def __init__(self): self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) - # all values in cm + # Initialized measure values + self.measure_1 = self._defaults["measure_1"] + self.measure_2 = self._defaults["measure_2"] + + # Initialized constants self.ball_valve_cap_thickness = 0.81 * 2.54 self.probe_drive_endplate_thickness = 0.75 * 2.54 self.probe_kf40_thickness = 2.54 self.velmex_rail_width = 3.4 * 2.54 - # constants need to be defined first - self.measure_1 = self._defaults["measure_1"] - self.measure_2 = self._defaults["measure_2"] - - # mesures and constants need to be defined first + # Initilized "Calculated" Transform Parameters self.pivot_to_center = 58.771 + self.probe_axis_offset = 30.47 + self.table_pivot_to_zlead_screw = 12.488 self.pivot_to_feedthru = self.calc_pivot_to_feedthru() self.pivot_to_xzcross = self.calc_pivot_to_xzcross() From e8631f813459932c8bb0e72910a62e706b8fada1 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 21 May 2026 12:13:20 -0700 Subject: [PATCH 043/177] reorder definitions of label widgets --- .../gui/lapd_xyz_transform_calculator.py | 72 ++++++++++--------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 3289c7ef..b0534ed8 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -105,17 +105,7 @@ def __init__(self): self.pivot_to_feedthru = self.calc_pivot_to_feedthru() self.pivot_to_xzcross = self.calc_pivot_to_xzcross() - _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(262, 17) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_center_label = _txt - + # Place "measure" labels _txt = QLineEdit(f"{self.measure_1:.2f} cm", parent=self) _txt.setReadOnly(False) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) @@ -140,28 +130,7 @@ def __init__(self): _txt.setObjectName("measure_2") self.measure_2_label = _txt - _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(570, 108) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_feedthru_label = _txt - - _txt = QLineEdit(f"{self.pivot_to_xzcross:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(980, 17) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_xzcross_label = _txt - + # Place "constant" labels _txt = QLineEdit(f"{self.ball_valve_cap_thickness:.3f} cm", parent=self) _txt.setReadOnly(True) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) @@ -208,12 +177,47 @@ def __init__(self): font.setPointSize(12) font.setBold(True) _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1496-273, 121+24) + p = self.geometry().topLeft() + QPoint(1496 - 273, 121 + 24) _txt.move(p) _txt.setFixedWidth(86) _txt.setObjectName("velmex_rail_width") self.velmex_rail_width_label = _txt + # Place "Transform Parameter" labels + _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(262, 17) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_center_label = _txt + + _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(570, 108) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_feedthru_label = _txt + + _txt = QLineEdit(f"{self.pivot_to_xzcross:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(980, 17) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_xzcross_label = _txt + + # Place Action Buttons _btn = StyleButton("Reset to Defaults", parent=self) _btn.setFixedWidth(200) _btn.setFixedHeight(36) From b69c4b89dfcbb1da501f0c3611c7a7d39ff002f2 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 21 May 2026 12:13:45 -0700 Subject: [PATCH 044/177] update calc_pivot_to_xzcross() --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index b0534ed8..3ac67c4f 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -271,7 +271,7 @@ def calc_pivot_to_xzcross(self): + self.measure_1 + self.probe_drive_endplate_thickness + self.measure_2 - + 0.5 * self.velmex_rail_width + + self.table_pivot_to_zlead_screw ) def recalculate_parameters(self): From 4748dc35c758861819d21c0a3a468b089c2eba93 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 21 May 2026 12:14:03 -0700 Subject: [PATCH 045/177] add label probe_axis_offset_label --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 3ac67c4f..335f9eba 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -206,6 +206,17 @@ def __init__(self): _txt.setFixedWidth(120) self.pivot_to_feedthru_label = _txt + _txt = QLineEdit(f"{self.probe_axis_offset:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1590, 658) + _txt.move(p) + _txt.setFixedWidth(120) + self.probe_axis_offset_label = _txt + _txt = QLineEdit(f"{self.pivot_to_xzcross:.3f} cm", parent=self) _txt.setReadOnly(True) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) From 2f56a6006ad1694d17fe0289bfc9ada2564e0449 Mon Sep 17 00:00:00 2001 From: Erik Date: Thu, 21 May 2026 19:15:04 -0700 Subject: [PATCH 046/177] add label table_pivot_to_zlead_screw_label --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 335f9eba..412b4ea7 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -228,6 +228,17 @@ def __init__(self): _txt.setFixedWidth(120) self.pivot_to_xzcross_label = _txt + _txt = QLineEdit(f"{self.table_pivot_to_zlead_screw:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1437, 82) + _txt.move(p) + _txt.setFixedWidth(120) + self.table_pivot_to_zlead_screw_label = _txt + # Place Action Buttons _btn = StyleButton("Reset to Defaults", parent=self) _btn.setFixedWidth(200) From 696e26e315cc48fed2caf7027f0cbe5de69307e0 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 10:23:52 -0700 Subject: [PATCH 047/177] simplify _validate_measure_1 and _validate_measure_2 --- .../gui/lapd_xyz_transform_calculator.py | 32 ++++++++----------- 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 412b4ea7..ef614565 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -349,34 +349,30 @@ def _validate_measure_1(self): _txt = self.measure_1_label.text() value = self._validate_measure(_txt) - if value is None: - pass - elif value <= self.probe_kf40_thickness: - # not physically possible - pass - else: - self.measure_1 = value - self.recalculate_parameters() + if ( + value is None # input was invalid + or value <= self.probe_kf40_thickness # not physically possible + ): + self._update_all_labels() return - self._update_all_labels() + self.measure_1 = value + self.recalculate_parameters() @Slot() def _validate_measure_2(self): _txt = self.measure_2_label.text() value = self._validate_measure(_txt) - if value is None: - pass - elif value <= 0: - # not physically possible - pass - else: - self.measure_2 = value - self.recalculate_parameters() + if ( + value is None # input was invalid + or value <= 0 # not physically possible + ): + self._update_all_labels() return - self._update_all_labels() + self.measure_2 = value + self.recalculate_parameters() def closeEvent(self, event): self.closing.emit() From bac06e187cd213e39ee5678b722d391f285accc5 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 10:26:37 -0700 Subject: [PATCH 048/177] leave clarifying comment --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index ef614565..a5794c7b 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -309,6 +309,15 @@ def _reset_measure_values(self): self.recalculate_parameters() def _update_all_labels(self): + # No update of + # + # - pivot_to_center_label + # - probe_axis_offset_label + # - table_pivot_to_zlead_screw_label + # + # is needed because they do NOT change with measure_1 + # and measure_2 + # self._update_measure_1_label() self._update_measure_2_label() self._update_pivot_to_feedthru_label() From 3a3ac95f324198d3ed12c5e1ceca83ab589571c8 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:10:37 -0700 Subject: [PATCH 049/177] create module bapsf_motion.gui.calculators --- bapsf_motion/gui/calculators/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 bapsf_motion/gui/calculators/__init__.py diff --git a/bapsf_motion/gui/calculators/__init__.py b/bapsf_motion/gui/calculators/__init__.py new file mode 100644 index 00000000..e69de29b From e0091a5453cd08c37fe35d64b112a3365ebce8fd Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:11:20 -0700 Subject: [PATCH 050/177] create calculator base classes BaseCalculatorWindow and BaseCalculatorApp --- bapsf_motion/gui/calculators/bases.py | 31 +++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 bapsf_motion/gui/calculators/bases.py diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py new file mode 100644 index 00000000..f73719e6 --- /dev/null +++ b/bapsf_motion/gui/calculators/bases.py @@ -0,0 +1,31 @@ +__all__ = ["BaseCalculatorApp", "BaseCalculatorWindow"] +from abc import ABC, abstractmethod +from PySide6.QtCore import Qt, Signal +from PySide6.QtWidgets import QApplication, QMainWindow +from typing import Type + + +class BaseCalculatorWindow(QMainWindow): + ... + + +class BaseCalculatorApp(QApplication): + _CALCULATOR_CLASS = NotImplemented # type: Type[BaseCalculatorWindow] + + def __init__(self, *args, **kwargs): + + if not issubclass(self._CALCULATOR_CLASS, BaseCalculatorWindow): + raise TypeError( + f"The defined class attribute _CALCULATOR_CLASS is not " + f"a subclass of {BaseCalculatorWindow.__module__}." + f"{BaseCalculatorWindow.__name__}" + ) + + super().__init__(*args, **kwargs) + + self.setStyle("Fusion") + self.styleHints().setColorScheme(Qt.ColorScheme.Light) + + self._window = self._CALCULATOR_CLASS() + self._window.show() + self._window.activateWindow() From 1773ffe2dbe48638c9979372f7ba7a0485d73d0f Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:12:42 -0700 Subject: [PATCH 051/177] have LaPDXYZTransformCalculator inherit from BaseCalculatorWindow and LaPDXYZTransformCalculatorApp inherit from BaseCalculatorApp --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index a5794c7b..063d1451 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -19,6 +19,7 @@ ) from typing import Union, Optional +from bapsf_motion.gui.calculators.bases import BaseCalculatorWindow, BaseCalculatorApp from bapsf_motion.gui.widgets import StyleButton @@ -26,7 +27,7 @@ _IMAGES_PATH = (_HERE / "_images").resolve() -class LaPDXYZTransformCalculator(QMainWindow): +class LaPDXYZTransformCalculator(BaseCalculatorWindow): closing = Signal() _defaults = { # all values in cm @@ -388,16 +389,8 @@ def closeEvent(self, event): super().closeEvent(event) -class LaPDXYZTransformCalculatorApp(QApplication): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - self.setStyle("Fusion") - self.styleHints().setColorScheme(Qt.ColorScheme.Light) - - self._window = LaPDXYZTransformCalculator() - self._window.show() - self._window.activateWindow() +class LaPDXYZTransformCalculatorApp(BaseCalculatorApp): + _CALCULATOR_CLASS = LaPDXYZTransformCalculator if __name__ == "__main__": From ed1e3968cbc3ac9f838b6685b6b84d89d2f83965 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:13:23 -0700 Subject: [PATCH 052/177] remove unused imports --- bapsf_motion/gui/lapd_xyz_transform_calculator.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/lapd_xyz_transform_calculator.py index 063d1451..70d96cb5 100644 --- a/bapsf_motion/gui/lapd_xyz_transform_calculator.py +++ b/bapsf_motion/gui/lapd_xyz_transform_calculator.py @@ -7,8 +7,6 @@ from PySide6.QtCore import Qt, QPoint, Signal, Slot from PySide6.QtGui import QPixmap from PySide6.QtWidgets import ( - QApplication, - QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, From 6e5699f645c616e9a3128ed615d7d88a7e53daa2 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:16:37 -0700 Subject: [PATCH 053/177] move lapd_xyz_transform_calculator.py into the bapsf_motion.gui.calculators module --- bapsf_motion/gui/__init__.py | 2 +- bapsf_motion/gui/calculators/__init__.py | 6 ++++++ .../gui/{ => calculators}/lapd_xyz_transform_calculator.py | 0 3 files changed, 7 insertions(+), 1 deletion(-) rename bapsf_motion/gui/{ => calculators}/lapd_xyz_transform_calculator.py (100%) diff --git a/bapsf_motion/gui/__init__.py b/bapsf_motion/gui/__init__.py index 9c7eb2a2..1455fdf6 100644 --- a/bapsf_motion/gui/__init__.py +++ b/bapsf_motion/gui/__init__.py @@ -21,7 +21,7 @@ LaPDXYTransformCalculator, LaPDXYTransformCalculatorApp, ) - from bapsf_motion.gui.lapd_xyz_transform_calculator import ( + from bapsf_motion.gui.calculators import ( LaPDXYZTransformCalculator, LaPDXYZTransformCalculatorApp, ) diff --git a/bapsf_motion/gui/calculators/__init__.py b/bapsf_motion/gui/calculators/__init__.py index e69de29b..9ecee8d3 100644 --- a/bapsf_motion/gui/calculators/__init__.py +++ b/bapsf_motion/gui/calculators/__init__.py @@ -0,0 +1,6 @@ +__all__ = ["LaPDXYZTransformCalculator", "LaPDXYZTransformCalculatorApp"] + +from bapsf_motion.gui.calculators.lapd_xyz_transform_calculator import ( + LaPDXYZTransformCalculator, + LaPDXYZTransformCalculatorApp, +) diff --git a/bapsf_motion/gui/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/calculators/lapd_xyz_transform_calculator.py similarity index 100% rename from bapsf_motion/gui/lapd_xyz_transform_calculator.py rename to bapsf_motion/gui/calculators/lapd_xyz_transform_calculator.py From 0deb09f2a57f8c11c2450957f3a51ea44d8e72be Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:17:26 -0700 Subject: [PATCH 054/177] rename lapd_xyz_transform_calculator.py -> lapd_xyz_transform.py --- bapsf_motion/gui/calculators/__init__.py | 2 +- .../{lapd_xyz_transform_calculator.py => lapd_xyz_transform.py} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename bapsf_motion/gui/calculators/{lapd_xyz_transform_calculator.py => lapd_xyz_transform.py} (100%) diff --git a/bapsf_motion/gui/calculators/__init__.py b/bapsf_motion/gui/calculators/__init__.py index 9ecee8d3..8195d30d 100644 --- a/bapsf_motion/gui/calculators/__init__.py +++ b/bapsf_motion/gui/calculators/__init__.py @@ -1,6 +1,6 @@ __all__ = ["LaPDXYZTransformCalculator", "LaPDXYZTransformCalculatorApp"] -from bapsf_motion.gui.calculators.lapd_xyz_transform_calculator import ( +from bapsf_motion.gui.calculators.lapd_xyz_transform import ( LaPDXYZTransformCalculator, LaPDXYZTransformCalculatorApp, ) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform_calculator.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py similarity index 100% rename from bapsf_motion/gui/calculators/lapd_xyz_transform_calculator.py rename to bapsf_motion/gui/calculators/lapd_xyz_transform.py From be5a1faf23312e1b9bf3695c3905a1a70dc09b46 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:20:45 -0700 Subject: [PATCH 055/177] move closing Signal into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 6 +++++- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 5 ----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index f73719e6..fd472400 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -6,7 +6,11 @@ class BaseCalculatorWindow(QMainWindow): - ... + closing = Signal() + + def closeEvent(self, event): + self.closing.emit() + super().closeEvent(event) class BaseCalculatorApp(QApplication): diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 70d96cb5..841afe73 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -26,7 +26,6 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): - closing = Signal() _defaults = { # all values in cm "measure_1": 54.2, @@ -382,10 +381,6 @@ def _validate_measure_2(self): self.measure_2 = value self.recalculate_parameters() - def closeEvent(self, event): - self.closing.emit() - super().closeEvent(event) - class LaPDXYZTransformCalculatorApp(BaseCalculatorApp): _CALCULATOR_CLASS = LaPDXYZTransformCalculator From f3efb4ac3a4f8ebc61898e69a14d0a879e0c5bbe Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:46:22 -0700 Subject: [PATCH 056/177] move image defining architecture into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 49 ++++++++++++++++++- .../gui/calculators/lapd_xyz_transform.py | 13 +---- 2 files changed, 50 insertions(+), 12 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index fd472400..fa0d6214 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -1,14 +1,61 @@ __all__ = ["BaseCalculatorApp", "BaseCalculatorWindow"] from abc import ABC, abstractmethod +from pathlib import Path from PySide6.QtCore import Qt, Signal -from PySide6.QtWidgets import QApplication, QMainWindow +from PySide6.QtGui import QCloseEvent, QPixmap +from PySide6.QtWidgets import QApplication, QMainWindow, QWidget from typing import Type +_HERE = Path(__file__).parent +_IMAGES_PATH = (_HERE / ".." / "_images").resolve() + class BaseCalculatorWindow(QMainWindow): closing = Signal() def closeEvent(self, event): + _IMAGE_DIR = _IMAGES_PATH + _IMAGE_NAME = NotImplemented # type: str + + def __init__(self, parent=None): + super().__init__(parent) + + self.setCentralWidget(QWidget(parent=self)) + + self._image_path = self._generate_image_path() + pixmap = QPixmap(f"{self._image_path}") + self._image = pixmap + + def _generate_image_path(self): + if not isinstance(self._IMAGE_DIR, Path): + raise TypeError( + f"Class attribute is invalid, got type " + f"{type(self._IMAGE_DIR)} but expected a " + f"pathlib.Path instance." + ) + if not self._IMAGE_DIR.exists(): + raise ValueError( + f"The image directory '{self._IMAGE_DIR}' does NOT exist." + ) + if not self._IMAGE_DIR.is_dir(): + raise ValueError( + f"The image directory '{self._IMAGE_DIR}' does NOT a directory." + ) + if not isinstance(self._IMAGE_NAME, str): + raise TypeError( + f"Class attribute is invalid, got type " + f"{type(self._IMAGE_NAME)} but expected a string." + ) + _image_path = (self._IMAGE_DIR / self._IMAGE_NAME).resolve() + if not _image_path.exists(): + raise ValueError( + f"The image '{_image_path}' does NOT exist." + ) + if not _image_path.is_file(): + raise ValueError( + f"The image '{_image_path}' does NOT a file." + ) + return _image_path self.closing.emit() super().closeEvent(event) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 841afe73..cab0a33e 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -3,7 +3,6 @@ import ast import re -from pathlib import Path from PySide6.QtCore import Qt, QPoint, Signal, Slot from PySide6.QtGui import QPixmap from PySide6.QtWidgets import ( @@ -21,11 +20,9 @@ from bapsf_motion.gui.widgets import StyleButton -_HERE = Path(__file__).parent -_IMAGES_PATH = (_HERE / "_images").resolve() - - class LaPDXYZTransformCalculator(BaseCalculatorWindow): + _WINDOW_TITLE = "LaPD XYZ Calculator" + _IMAGE_NAME = "LaPDXYZTransform_diagram.png" _defaults = { # all values in cm "measure_1": 54.2, @@ -68,12 +65,6 @@ def __init__(self): """ self.setStyleSheet(_stylesheet) - self.setCentralWidget(QWidget(parent=self)) - - self._image_file_path = (_IMAGES_PATH / "LaPDXYZTransform_diagram.png").resolve() - pixmap = QPixmap(f"{self._image_file_path}") - self._image = pixmap - self._window_margin = 12 self._define_main_window() From e8d317bc75c61ce561b6e74d29e8972ad3ad7a20 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:47:22 -0700 Subject: [PATCH 057/177] add typing annotation to closeEvent --- bapsf_motion/gui/calculators/bases.py | 1 + 1 file changed, 1 insertion(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index fa0d6214..c10fcc5f 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -56,6 +56,7 @@ def _generate_image_path(self): f"The image '{_image_path}' does NOT a file." ) return _image_path + def closeEvent(self, event: QCloseEvent): self.closing.emit() super().closeEvent(event) From a079847f6d424add9ee07701a2a413cb3794bdf1 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:55:27 -0700 Subject: [PATCH 058/177] move definition of main window into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 15 ++++++++++++++- .../gui/calculators/lapd_xyz_transform.py | 11 ----------- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index c10fcc5f..e24c468c 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -13,7 +13,8 @@ class BaseCalculatorWindow(QMainWindow): closing = Signal() - def closeEvent(self, event): + _WINDOW_TITLE = NotImplemented # type: str + _WINDOW_MARGIN = 12 _IMAGE_DIR = _IMAGES_PATH _IMAGE_NAME = NotImplemented # type: str @@ -26,6 +27,9 @@ def __init__(self, parent=None): pixmap = QPixmap(f"{self._image_path}") self._image = pixmap + self._window_margin = self._WINDOW_MARGIN + self._define_main_window() + def _generate_image_path(self): if not isinstance(self._IMAGE_DIR, Path): raise TypeError( @@ -56,6 +60,15 @@ def _generate_image_path(self): f"The image '{_image_path}' does NOT a file." ) return _image_path + + def _define_main_window(self): + self.setWindowTitle(self._WINDOW_TITLE) + width = self._image.width() + 2 * self._window_margin + height = self._image.height() + 2 * self._window_margin + self.resize(width, height) + self.setFixedWidth(width) + self.setFixedHeight(height) + def closeEvent(self, event: QCloseEvent): self.closing.emit() super().closeEvent(event) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index cab0a33e..69444ae0 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -65,9 +65,6 @@ def __init__(self): """ self.setStyleSheet(_stylesheet) - self._window_margin = 12 - self._define_main_window() - self.image_label = QLabel(parent=self) self.image_label.setPixmap(self._image) @@ -242,14 +239,6 @@ def __init__(self): self._connect_signals() - def _define_main_window(self): - self.setWindowTitle("LaPD XY Transform Calculator") - width = self._image.width() + 2 * self._window_margin - height = self._image.height() + 2 * self._window_margin - self.resize(width, height) - self.setFixedWidth(width) - self.setFixedHeight(height) - def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) self.measure_2_label.editingFinished.connect(self._validate_measure_2) From f35229f4ff44dcfafca29f83da044fb08252e157 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:57:31 -0700 Subject: [PATCH 059/177] create abstract method _connect_signals --- bapsf_motion/gui/calculators/bases.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index e24c468c..5ccbecd9 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -10,7 +10,7 @@ _IMAGES_PATH = (_HERE / ".." / "_images").resolve() -class BaseCalculatorWindow(QMainWindow): +class BaseCalculatorWindow(QMainWindow, ABC): closing = Signal() _WINDOW_TITLE = NotImplemented # type: str @@ -30,6 +30,10 @@ def __init__(self, parent=None): self._window_margin = self._WINDOW_MARGIN self._define_main_window() + @abstractmethod + def _connect_signals(self): + ... + def _generate_image_path(self): if not isinstance(self._IMAGE_DIR, Path): raise TypeError( From ac8508c7d464a17cd699a7d58ae1bf3cb8884198 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 11:58:08 -0700 Subject: [PATCH 060/177] remove unnecessary setting of stylesheet --- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 1 - 1 file changed, 1 deletion(-) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 69444ae0..776871d1 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -70,7 +70,6 @@ def __init__(self): self.image_frame = QFrame(parent=self) self.image_frame.setObjectName("image_frame") - self.image_frame.setStyleSheet(_stylesheet) self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) From cb3b5e841c36ba5665583d8014dd88a8ce76f90e Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 12:10:31 -0700 Subject: [PATCH 061/177] create metaclass QABCMainWindow --- bapsf_motion/gui/calculators/bases.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 5ccbecd9..e8af8c70 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -1,5 +1,5 @@ __all__ = ["BaseCalculatorApp", "BaseCalculatorWindow"] -from abc import ABC, abstractmethod +from abc import ABCMeta, abstractmethod from pathlib import Path from PySide6.QtCore import Qt, Signal from PySide6.QtGui import QCloseEvent, QPixmap @@ -10,7 +10,11 @@ _IMAGES_PATH = (_HERE / ".." / "_images").resolve() -class BaseCalculatorWindow(QMainWindow, ABC): +class QABCMainWindow(ABCMeta, type(QMainWindow)): + ... + + +class BaseCalculatorWindow(QMainWindow, metaclass=QABCMainWindow): closing = Signal() _WINDOW_TITLE = NotImplemented # type: str From 1604cbda01f33d07521d0d28bf6422c46eb15988 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 12:12:03 -0700 Subject: [PATCH 062/177] create property _stylesheet_string and move stylesheet setting into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 16 +++++ .../gui/calculators/lapd_xyz_transform.py | 60 +++++++++---------- 2 files changed, 43 insertions(+), 33 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index e8af8c70..1b593bb9 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -25,6 +25,8 @@ class BaseCalculatorWindow(QMainWindow, metaclass=QABCMainWindow): def __init__(self, parent=None): super().__init__(parent) + self.setStyleSheet(self._stylesheet_string) + self.setCentralWidget(QWidget(parent=self)) self._image_path = self._generate_image_path() @@ -69,6 +71,20 @@ def _generate_image_path(self): ) return _image_path + @property + def _stylesheet_string(self): + _stylesheet = self.styleSheet() + _stylesheet += """ + QFrame#image_frame { + border: 2px solid rgb(125, 125, 125); + border-radius: 5px; + padding: 0px; + margin: 0px; + background-color: white; + } + """ + return _stylesheet + def _define_main_window(self): self.setWindowTitle(self._WINDOW_TITLE) width = self._image.width() + 2 * self._window_margin diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 776871d1..f1a5688b 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -32,39 +32,6 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): def __init__(self): super().__init__() - _stylesheet = self.styleSheet() - _stylesheet += """ - QFrame#image_frame { - border: 2px solid rgb(125, 125, 125); - border-radius: 5px; - padding: 0px; - margin: 0px; - background-color: white; - } - - QLineEdit { border: 2px solid black; border-radius: 5px } - QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } - QLineEdit#measure_2 { border: 2px solid rgb(255, 0, 0) } - - QLineEdit#ball_valve_cap_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#probe_kf40_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#probe_drive_endplate_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#velmex_rail_width { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - """ - self.setStyleSheet(_stylesheet) - self.image_label = QLabel(parent=self) self.image_label.setPixmap(self._image) @@ -257,6 +224,33 @@ def _define_layout(self): layout.addStretch() return layout + @property + def _stylesheet_string(self): + _stylesheet = super()._stylesheet_string + _stylesheet += """ + QLineEdit { border: 2px solid black; border-radius: 5px } + QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2 { border: 2px solid rgb(255, 0, 0) } + + QLineEdit#ball_valve_cap_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_kf40_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_drive_endplate_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#velmex_rail_width { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + """ + return _stylesheet + def calc_pivot_to_feedthru(self): return ( self.ball_valve_cap_thickness From 78a958560056e81a32a805dd4a59c8cfd8531949 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 12:18:50 -0700 Subject: [PATCH 063/177] add ABD to BaseCalculatorWindow inheritance --- bapsf_motion/gui/calculators/bases.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 1b593bb9..0531673f 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -1,5 +1,5 @@ __all__ = ["BaseCalculatorApp", "BaseCalculatorWindow"] -from abc import ABCMeta, abstractmethod +from abc import ABC, ABCMeta, abstractmethod from pathlib import Path from PySide6.QtCore import Qt, Signal from PySide6.QtGui import QCloseEvent, QPixmap @@ -14,7 +14,7 @@ class QABCMainWindow(ABCMeta, type(QMainWindow)): ... -class BaseCalculatorWindow(QMainWindow, metaclass=QABCMainWindow): +class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): closing = Signal() _WINDOW_TITLE = NotImplemented # type: str From ffe6a4674d64886992224f8a5edc9ae3a62162b4 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 16:27:07 -0700 Subject: [PATCH 064/177] move background image setup into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 25 ++++++++++++++----- .../gui/calculators/lapd_xyz_transform.py | 8 ------ 2 files changed, 19 insertions(+), 14 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 0531673f..4057763d 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -3,7 +3,7 @@ from pathlib import Path from PySide6.QtCore import Qt, Signal from PySide6.QtGui import QCloseEvent, QPixmap -from PySide6.QtWidgets import QApplication, QMainWindow, QWidget +from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QFrame, QLabel from typing import Type _HERE = Path(__file__).parent @@ -16,6 +16,7 @@ class QABCMainWindow(ABCMeta, type(QMainWindow)): class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): closing = Signal() + exportParameters = Signal() _WINDOW_TITLE = NotImplemented # type: str _WINDOW_MARGIN = 12 @@ -27,15 +28,18 @@ def __init__(self, parent=None): self.setStyleSheet(self._stylesheet_string) - self.setCentralWidget(QWidget(parent=self)) - + # set instance attributes + self._window_margin = self._WINDOW_MARGIN self._image_path = self._generate_image_path() - pixmap = QPixmap(f"{self._image_path}") - self._image = pixmap + self._image = QPixmap(f"{self._image_path}") - self._window_margin = self._WINDOW_MARGIN + # setup window + self.setCentralWidget(QWidget(parent=self)) self._define_main_window() + # intialize image widgets for background + self._init_image_widgets() + @abstractmethod def _connect_signals(self): ... @@ -85,6 +89,15 @@ def _stylesheet_string(self): """ return _stylesheet + def _init_image_widgets(self): + self.image_label = QLabel(parent=self) + self.image_label.setPixmap(self._image) + + self.image_frame = QFrame(parent=self) + self.image_frame.setObjectName("image_frame") + self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) + self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) + def _define_main_window(self): self.setWindowTitle(self._WINDOW_TITLE) width = self._image.width() + 2 * self._window_margin diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index f1a5688b..c3a9aad7 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -32,14 +32,6 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): def __init__(self): super().__init__() - self.image_label = QLabel(parent=self) - self.image_label.setPixmap(self._image) - - self.image_frame = QFrame(parent=self) - self.image_frame.setObjectName("image_frame") - self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) - self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) - # Initialized measure values self.measure_1 = self._defaults["measure_1"] self.measure_2 = self._defaults["measure_2"] From 8cee16ba203c264750f7faa3d2a4c2363823bb00 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 16:28:25 -0700 Subject: [PATCH 065/177] reorder methode definitions --- bapsf_motion/gui/calculators/bases.py | 44 +++++++++++++-------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 4057763d..bec8ec24 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -40,10 +40,32 @@ def __init__(self, parent=None): # intialize image widgets for background self._init_image_widgets() + @property + def _stylesheet_string(self): + _stylesheet = self.styleSheet() + _stylesheet += """ + QFrame#image_frame { + border: 2px solid rgb(125, 125, 125); + border-radius: 5px; + padding: 0px; + margin: 0px; + background-color: white; + } + """ + return _stylesheet + @abstractmethod def _connect_signals(self): ... + def _define_main_window(self): + self.setWindowTitle(self._WINDOW_TITLE) + width = self._image.width() + 2 * self._window_margin + height = self._image.height() + 2 * self._window_margin + self.resize(width, height) + self.setFixedWidth(width) + self.setFixedHeight(height) + def _generate_image_path(self): if not isinstance(self._IMAGE_DIR, Path): raise TypeError( @@ -75,20 +97,6 @@ def _generate_image_path(self): ) return _image_path - @property - def _stylesheet_string(self): - _stylesheet = self.styleSheet() - _stylesheet += """ - QFrame#image_frame { - border: 2px solid rgb(125, 125, 125); - border-radius: 5px; - padding: 0px; - margin: 0px; - background-color: white; - } - """ - return _stylesheet - def _init_image_widgets(self): self.image_label = QLabel(parent=self) self.image_label.setPixmap(self._image) @@ -98,14 +106,6 @@ def _init_image_widgets(self): self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) - def _define_main_window(self): - self.setWindowTitle(self._WINDOW_TITLE) - width = self._image.width() + 2 * self._window_margin - height = self._image.height() + 2 * self._window_margin - self.resize(width, height) - self.setFixedWidth(width) - self.setFixedHeight(height) - def closeEvent(self, event: QCloseEvent): self.closing.emit() super().closeEvent(event) From e49a9234a0adb7dcf8510110955ee20002b59e0c Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 16:40:38 -0700 Subject: [PATCH 066/177] create abstract methode _init_widgets --- bapsf_motion/gui/calculators/bases.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index bec8ec24..1a040eb2 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -40,6 +40,9 @@ def __init__(self, parent=None): # intialize image widgets for background self._init_image_widgets() + # initialized widgets + self._init_widgets() + @property def _stylesheet_string(self): _stylesheet = self.styleSheet() @@ -106,6 +109,10 @@ def _init_image_widgets(self): self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) + @abstractmethod + def _init_widgets(self): + ... + def closeEvent(self, event: QCloseEvent): self.closing.emit() super().closeEvent(event) From 948ad69b54042e01b544ce1a28c2e527a9c82667 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 16:41:32 -0700 Subject: [PATCH 067/177] move _define_layout() to BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 28 ++++++++++++++++++- .../gui/calculators/lapd_xyz_transform.py | 22 ++------------- 2 files changed, 30 insertions(+), 20 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 1a040eb2..be4b1bdb 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -3,7 +3,15 @@ from pathlib import Path from PySide6.QtCore import Qt, Signal from PySide6.QtGui import QCloseEvent, QPixmap -from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QFrame, QLabel +from PySide6.QtWidgets import ( + QApplication, + QMainWindow, + QWidget, + QFrame, + QLabel, + QVBoxLayout, + QHBoxLayout, +) from typing import Type _HERE = Path(__file__).parent @@ -43,6 +51,11 @@ def __init__(self, parent=None): # initialized widgets self._init_widgets() + layout = self._define_layout() + self.centralWidget().setLayout(layout) + + self._connect_signals() + @property def _stylesheet_string(self): _stylesheet = self.styleSheet() @@ -61,6 +74,19 @@ def _stylesheet_string(self): def _connect_signals(self): ... + def _define_layout(self): + image_layout = QVBoxLayout() + image_layout.setContentsMargins(0, 0, 0, 0) + image_layout.addWidget(self.image_label) + self.image_frame.setLayout(image_layout) + + layout = QHBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addStretch() + layout.addWidget(self.image_frame) + layout.addStretch() + return layout + def _define_main_window(self): self.setWindowTitle(self._WINDOW_TITLE) width = self._image.width() + 2 * self._window_margin diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index c3a9aad7..9183f31a 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -30,7 +30,6 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): } def __init__(self): - super().__init__() # Initialized measure values self.measure_1 = self._defaults["measure_1"] @@ -49,6 +48,9 @@ def __init__(self): self.pivot_to_feedthru = self.calc_pivot_to_feedthru() self.pivot_to_xzcross = self.calc_pivot_to_xzcross() + super().__init__() + + def _init_widgets(self): # Place "measure" labels _txt = QLineEdit(f"{self.measure_1:.2f} cm", parent=self) _txt.setReadOnly(False) @@ -192,30 +194,12 @@ def __init__(self): _btn.move(p) self.reset_btn = _btn - layout = self._define_layout() - self.centralWidget().setLayout(layout) - - self._connect_signals() - def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) self.measure_2_label.editingFinished.connect(self._validate_measure_2) self.reset_btn.clicked.connect(self._reset_measure_values) - def _define_layout(self): - image_layout = QVBoxLayout() - image_layout.setContentsMargins(0, 0, 0, 0) - image_layout.addWidget(self.image_label) - self.image_frame.setLayout(image_layout) - - layout = QHBoxLayout() - layout.setContentsMargins(0, 0, 0, 0) - layout.addStretch() - layout.addWidget(self.image_frame) - layout.addStretch() - return layout - @property def _stylesheet_string(self): _stylesheet = super()._stylesheet_string From 8c1174f6ebbe30ea55903d41430b323be924c1b1 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:39:24 -0700 Subject: [PATCH 068/177] move the reset_btn into BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 16 ++++++++++++++-- .../gui/calculators/lapd_xyz_transform.py | 7 +------ 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index be4b1bdb..6995a85f 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -1,7 +1,8 @@ __all__ = ["BaseCalculatorApp", "BaseCalculatorWindow"] + from abc import ABC, ABCMeta, abstractmethod from pathlib import Path -from PySide6.QtCore import Qt, Signal +from PySide6.QtCore import Qt, Signal, QPoint from PySide6.QtGui import QCloseEvent, QPixmap from PySide6.QtWidgets import ( QApplication, @@ -14,6 +15,8 @@ ) from typing import Type +from bapsf_motion.gui.widgets import StyleButton + _HERE = Path(__file__).parent _IMAGES_PATH = (_HERE / ".." / "_images").resolve() @@ -24,7 +27,7 @@ class QABCMainWindow(ABCMeta, type(QMainWindow)): class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): closing = Signal() - exportParameters = Signal() + exportParameters = Signal(object) _WINDOW_TITLE = NotImplemented # type: str _WINDOW_MARGIN = 12 @@ -48,6 +51,15 @@ def __init__(self, parent=None): # intialize image widgets for background self._init_image_widgets() + # define action buttons + _btn = StyleButton("Reset to Defaults", parent=self) + _btn.setFixedWidth(200) + _btn.setFixedHeight(36) + _btn.setPointSize(14) + p = self.geometry().topLeft() + QPoint(20, 20) + _btn.move(p) + self.reset_btn = _btn + # initialized widgets self._init_widgets() diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 9183f31a..e0f04e56 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -186,13 +186,8 @@ def _init_widgets(self): self.table_pivot_to_zlead_screw_label = _txt # Place Action Buttons - _btn = StyleButton("Reset to Defaults", parent=self) - _btn.setFixedWidth(200) - _btn.setFixedHeight(36) - _btn.setPointSize(14) p = self.geometry().topLeft() + QPoint(270, 694) - _btn.move(p) - self.reset_btn = _btn + self.reset_btn.move(p) def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) From b10bb9a41180c7f38c3e222bab9866f62e7e3cad Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:43:22 -0700 Subject: [PATCH 069/177] define an export parameters button --- bapsf_motion/gui/calculators/bases.py | 8 ++++++++ bapsf_motion/gui/calculators/lapd_xyz_transform.py | 3 +++ 2 files changed, 11 insertions(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 6995a85f..87297e14 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -60,6 +60,14 @@ def __init__(self, parent=None): _btn.move(p) self.reset_btn = _btn + _btn = StyleButton("Export Parameters", parent=self) + _btn.setFixedWidth(200) + _btn.setFixedHeight(36) + _btn.setPointSize(14) + p = self.geometry().topLeft() + QPoint(240, 20) + _btn.move(p) + self.export_btn = _btn + # initialized widgets self._init_widgets() diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index e0f04e56..723d4ca9 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -189,6 +189,9 @@ def _init_widgets(self): p = self.geometry().topLeft() + QPoint(270, 694) self.reset_btn.move(p) + p += QPoint(220, 0) + self.export_btn.move(p) + def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) self.measure_2_label.editingFinished.connect(self._validate_measure_2) From b99b5a1f9f2e10fe7330bdb1b78a4aab22c6e089 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:47:08 -0700 Subject: [PATCH 070/177] make abstract method _reset_parameters --- bapsf_motion/gui/calculators/bases.py | 5 +++++ bapsf_motion/gui/calculators/lapd_xyz_transform.py | 5 +++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 87297e14..a59fea75 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -74,6 +74,7 @@ def __init__(self, parent=None): layout = self._define_layout() self.centralWidget().setLayout(layout) + self.reset_btn.clicked.connect(self._reset_parameters) self._connect_signals() @property @@ -94,6 +95,10 @@ def _stylesheet_string(self): def _connect_signals(self): ... + @abstractmethod + def _reset_parameters(self): + ... + def _define_layout(self): image_layout = QVBoxLayout() image_layout.setContentsMargins(0, 0, 0, 0) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 723d4ca9..67476cd0 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -196,8 +196,6 @@ def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) self.measure_2_label.editingFinished.connect(self._validate_measure_2) - self.reset_btn.clicked.connect(self._reset_measure_values) - @property def _stylesheet_string(self): _stylesheet = super()._stylesheet_string @@ -253,6 +251,9 @@ def _reset_measure_values(self): self.recalculate_parameters() + def _reset_parameters(self): + self._reset_measure_values() + def _update_all_labels(self): # No update of # From 639203a0e8c01f21197a91a1241c77dac06425e8 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:51:53 -0700 Subject: [PATCH 071/177] decorate _reset_parameters() with @Slot() --- bapsf_motion/gui/calculators/bases.py | 3 ++- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index a59fea75..1c3a8452 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -2,7 +2,7 @@ from abc import ABC, ABCMeta, abstractmethod from pathlib import Path -from PySide6.QtCore import Qt, Signal, QPoint +from PySide6.QtCore import Qt, Signal, QPoint, Slot from PySide6.QtGui import QCloseEvent, QPixmap from PySide6.QtWidgets import ( QApplication, @@ -96,6 +96,7 @@ def _connect_signals(self): ... @abstractmethod + @Slot() def _reset_parameters(self): ... diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 67476cd0..c0edd3be 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -251,6 +251,7 @@ def _reset_measure_values(self): self.recalculate_parameters() + @Slot() def _reset_parameters(self): self._reset_measure_values() From a60de6eb00f5a651a7efeb906561332ce2372ea9 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:56:44 -0700 Subject: [PATCH 072/177] create abstract method _collect_export_parameters --- bapsf_motion/gui/calculators/bases.py | 4 ++++ bapsf_motion/gui/calculators/lapd_xyz_transform.py | 8 ++++++++ 2 files changed, 12 insertions(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 1c3a8452..9e62c4e5 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -91,6 +91,10 @@ def _stylesheet_string(self): """ return _stylesheet + @abstractmethod + def _collect_export_parameters(self) -> dict: + ... + @abstractmethod def _connect_signals(self): ... diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index c0edd3be..81237b03 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -223,6 +223,14 @@ def _stylesheet_string(self): """ return _stylesheet + def _collect_export_parameters(self) -> dict: + return { + "pivot_to_center": self.pivot_to_center, + "probe_axis_offset": self.probe_axis_offset, + "table_pivot_to_zlead_screw": self.table_pivot_to_zlead_screw, + "pivot_to_xzcross": self.pivot_to_xzcross, + } + def calc_pivot_to_feedthru(self): return ( self.ball_valve_cap_thickness From 936ce4ff921e6d6beb8ae5597fb9e6a77efcae3d Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 17:56:59 -0700 Subject: [PATCH 073/177] connect the export button --- bapsf_motion/gui/calculators/bases.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 9e62c4e5..bb5439bd 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -75,6 +75,7 @@ def __init__(self, parent=None): self.centralWidget().setLayout(layout) self.reset_btn.clicked.connect(self._reset_parameters) + self.export_btn.clicked.connect(self.emit_export_parameters) self._connect_signals() @property @@ -169,6 +170,11 @@ def _init_image_widgets(self): def _init_widgets(self): ... + @Slot() + def emit_export_parameters(self): + parameters = self._collect_export_parameters() + self.exportParameters.emit(parameters) + def closeEvent(self, event: QCloseEvent): self.closing.emit() super().closeEvent(event) From 7c6d4c9dbc5aa2e041a05381b22d4504a29b68d4 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:28:13 -0700 Subject: [PATCH 074/177] move lapd_xy_transform_calculator.py into bapsf_motion.gui.calculators --- bapsf_motion/gui/__init__.py | 8 ++------ bapsf_motion/gui/calculators/__init__.py | 11 ++++++++++- .../{ => calculators}/lapd_xy_transform_calculator.py | 0 bapsf_motion/gui/configure/configure_.py | 2 +- 4 files changed, 13 insertions(+), 8 deletions(-) rename bapsf_motion/gui/{ => calculators}/lapd_xy_transform_calculator.py (100%) diff --git a/bapsf_motion/gui/__init__.py b/bapsf_motion/gui/__init__.py index 1455fdf6..cc314288 100644 --- a/bapsf_motion/gui/__init__.py +++ b/bapsf_motion/gui/__init__.py @@ -2,7 +2,7 @@ __all__ = [ "ConfigureApp", - "LaPDXYTransformCalculator", + "LaPDXYTransformCalculatorApp", "LaPDXYTransformCalculatorApp", "get_qapplication", "get_color_scheme", @@ -17,12 +17,8 @@ get_qapplication, ) from bapsf_motion.gui.icons import icon_name_dict - from bapsf_motion.gui.lapd_xy_transform_calculator import ( - LaPDXYTransformCalculator, - LaPDXYTransformCalculatorApp, - ) from bapsf_motion.gui.calculators import ( - LaPDXYZTransformCalculator, + LaPDXYTransformCalculatorApp, LaPDXYZTransformCalculatorApp, ) except (ModuleNotFoundError, ImportError) as err: diff --git a/bapsf_motion/gui/calculators/__init__.py b/bapsf_motion/gui/calculators/__init__.py index 8195d30d..32411e73 100644 --- a/bapsf_motion/gui/calculators/__init__.py +++ b/bapsf_motion/gui/calculators/__init__.py @@ -1,5 +1,14 @@ -__all__ = ["LaPDXYZTransformCalculator", "LaPDXYZTransformCalculatorApp"] +__all__ = [ + "LaPDXYTransformCalculator", + "LaPDXYTransformCalculatorApp", + "LaPDXYZTransformCalculator", + "LaPDXYZTransformCalculatorApp", +] +from bapsf_motion.gui.calculators.lapd_xy_transform_calculator import ( + LaPDXYTransformCalculator, + LaPDXYTransformCalculatorApp, +) from bapsf_motion.gui.calculators.lapd_xyz_transform import ( LaPDXYZTransformCalculator, LaPDXYZTransformCalculatorApp, diff --git a/bapsf_motion/gui/lapd_xy_transform_calculator.py b/bapsf_motion/gui/calculators/lapd_xy_transform_calculator.py similarity index 100% rename from bapsf_motion/gui/lapd_xy_transform_calculator.py rename to bapsf_motion/gui/calculators/lapd_xy_transform_calculator.py diff --git a/bapsf_motion/gui/configure/configure_.py b/bapsf_motion/gui/configure/configure_.py index ca830bea..4c8445fc 100644 --- a/bapsf_motion/gui/configure/configure_.py +++ b/bapsf_motion/gui/configure/configure_.py @@ -37,7 +37,7 @@ from bapsf_motion.gui.configure.helpers import gui_logger, gui_logger_config_dict from bapsf_motion.gui.configure.motion_group_widget import MGWidget from bapsf_motion.gui.icons import icon_name_dict -from bapsf_motion.gui.lapd_xy_transform_calculator import LaPDXYTransformCalculator +from bapsf_motion.gui.calculators import LaPDXYTransformCalculator from bapsf_motion.gui.widgets import ( DiscardButton, DoneButton, From a7b424aa1088ea47399a6964bcf215e9763f1dfe Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:28:46 -0700 Subject: [PATCH 075/177] create property BaseCalculatorApp.calculator --- bapsf_motion/gui/calculators/bases.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index bb5439bd..e6781461 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -200,3 +200,7 @@ def __init__(self, *args, **kwargs): self._window = self._CALCULATOR_CLASS() self._window.show() self._window.activateWindow() + + @property + def calculator(self) -> BaseCalculatorWindow: + return self._window From 64758013985785d18928ff90686574859d10ce6d Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:31:23 -0700 Subject: [PATCH 076/177] rename lapd_xy_transform_calculator.py -> lapd_xy_transform.py --- bapsf_motion/gui/calculators/__init__.py | 2 +- .../{lapd_xy_transform_calculator.py => lapd_xy_transform.py} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename bapsf_motion/gui/calculators/{lapd_xy_transform_calculator.py => lapd_xy_transform.py} (100%) diff --git a/bapsf_motion/gui/calculators/__init__.py b/bapsf_motion/gui/calculators/__init__.py index 32411e73..a8365b30 100644 --- a/bapsf_motion/gui/calculators/__init__.py +++ b/bapsf_motion/gui/calculators/__init__.py @@ -5,7 +5,7 @@ "LaPDXYZTransformCalculatorApp", ] -from bapsf_motion.gui.calculators.lapd_xy_transform_calculator import ( +from bapsf_motion.gui.calculators.lapd_xy_transform import ( LaPDXYTransformCalculator, LaPDXYTransformCalculatorApp, ) diff --git a/bapsf_motion/gui/calculators/lapd_xy_transform_calculator.py b/bapsf_motion/gui/calculators/lapd_xy_transform.py similarity index 100% rename from bapsf_motion/gui/calculators/lapd_xy_transform_calculator.py rename to bapsf_motion/gui/calculators/lapd_xy_transform.py From ebaafc0dd49cf8c7a717850dcc24df4ade7bed73 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:38:15 -0700 Subject: [PATCH 077/177] appease grumpy isort --- bapsf_motion/gui/__init__.py | 8 ++++---- bapsf_motion/gui/calculators/bases.py | 8 ++++---- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 12 ++++++------ bapsf_motion/gui/configure/configure_.py | 2 +- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/bapsf_motion/gui/__init__.py b/bapsf_motion/gui/__init__.py index cc314288..98425965 100644 --- a/bapsf_motion/gui/__init__.py +++ b/bapsf_motion/gui/__init__.py @@ -10,6 +10,10 @@ ] try: + from bapsf_motion.gui.calculators import ( + LaPDXYTransformCalculatorApp, + LaPDXYZTransformCalculatorApp, + ) from bapsf_motion.gui.configure.configure_ import ConfigureApp from bapsf_motion.gui.helpers import ( cast_color_to_rgba_string, @@ -17,10 +21,6 @@ get_qapplication, ) from bapsf_motion.gui.icons import icon_name_dict - from bapsf_motion.gui.calculators import ( - LaPDXYTransformCalculatorApp, - LaPDXYZTransformCalculatorApp, - ) except (ModuleNotFoundError, ImportError) as err: msg = ( f"{err.msg} ... It is likely GUI dependencies were not installed. " diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index e6781461..cfd303aa 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -2,16 +2,16 @@ from abc import ABC, ABCMeta, abstractmethod from pathlib import Path -from PySide6.QtCore import Qt, Signal, QPoint, Slot +from PySide6.QtCore import QPoint, Qt, Signal, Slot from PySide6.QtGui import QCloseEvent, QPixmap from PySide6.QtWidgets import ( QApplication, - QMainWindow, - QWidget, QFrame, + QHBoxLayout, QLabel, + QMainWindow, QVBoxLayout, - QHBoxLayout, + QWidget, ) from typing import Type diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 81237b03..16c8dbd0 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -3,20 +3,20 @@ import ast import re -from PySide6.QtCore import Qt, QPoint, Signal, Slot +from PySide6.QtCore import QPoint, Qt, Signal, Slot from PySide6.QtGui import QPixmap from PySide6.QtWidgets import ( - QWidget, - QVBoxLayout, + QFrame, QHBoxLayout, QLabel, - QFrame, QLineEdit, QRadioButton, + QVBoxLayout, + QWidget, ) -from typing import Union, Optional +from typing import Optional, Union -from bapsf_motion.gui.calculators.bases import BaseCalculatorWindow, BaseCalculatorApp +from bapsf_motion.gui.calculators.bases import BaseCalculatorApp, BaseCalculatorWindow from bapsf_motion.gui.widgets import StyleButton diff --git a/bapsf_motion/gui/configure/configure_.py b/bapsf_motion/gui/configure/configure_.py index 4c8445fc..4c74a000 100644 --- a/bapsf_motion/gui/configure/configure_.py +++ b/bapsf_motion/gui/configure/configure_.py @@ -34,10 +34,10 @@ from typing import Any, Dict, Union from bapsf_motion.actors import MotionGroup, RunManager, RunManagerConfig +from bapsf_motion.gui.calculators import LaPDXYTransformCalculator from bapsf_motion.gui.configure.helpers import gui_logger, gui_logger_config_dict from bapsf_motion.gui.configure.motion_group_widget import MGWidget from bapsf_motion.gui.icons import icon_name_dict -from bapsf_motion.gui.calculators import LaPDXYTransformCalculator from bapsf_motion.gui.widgets import ( DiscardButton, DoneButton, From 7c58d2a743f1ede266471609275db88e85555123 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:49:18 -0700 Subject: [PATCH 078/177] appease grumpy black --- bapsf_motion/gui/calculators/bases.py | 27 ++++++------------- .../gui/calculators/lapd_xyz_transform.py | 8 +++--- 2 files changed, 11 insertions(+), 24 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index cfd303aa..8fa3b2ed 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -21,8 +21,7 @@ _IMAGES_PATH = (_HERE / ".." / "_images").resolve() -class QABCMainWindow(ABCMeta, type(QMainWindow)): - ... +class QABCMainWindow(ABCMeta, type(QMainWindow)): ... class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): @@ -93,17 +92,14 @@ def _stylesheet_string(self): return _stylesheet @abstractmethod - def _collect_export_parameters(self) -> dict: - ... + def _collect_export_parameters(self) -> dict: ... @abstractmethod - def _connect_signals(self): - ... + def _connect_signals(self): ... @abstractmethod @Slot() - def _reset_parameters(self): - ... + def _reset_parameters(self): ... def _define_layout(self): image_layout = QVBoxLayout() @@ -134,9 +130,7 @@ def _generate_image_path(self): f"pathlib.Path instance." ) if not self._IMAGE_DIR.exists(): - raise ValueError( - f"The image directory '{self._IMAGE_DIR}' does NOT exist." - ) + raise ValueError(f"The image directory '{self._IMAGE_DIR}' does NOT exist.") if not self._IMAGE_DIR.is_dir(): raise ValueError( f"The image directory '{self._IMAGE_DIR}' does NOT a directory." @@ -148,13 +142,9 @@ def _generate_image_path(self): ) _image_path = (self._IMAGE_DIR / self._IMAGE_NAME).resolve() if not _image_path.exists(): - raise ValueError( - f"The image '{_image_path}' does NOT exist." - ) + raise ValueError(f"The image '{_image_path}' does NOT exist.") if not _image_path.is_file(): - raise ValueError( - f"The image '{_image_path}' does NOT a file." - ) + raise ValueError(f"The image '{_image_path}' does NOT a file.") return _image_path def _init_image_widgets(self): @@ -167,8 +157,7 @@ def _init_image_widgets(self): self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) @abstractmethod - def _init_widgets(self): - ... + def _init_widgets(self): ... @Slot() def emit_export_parameters(self): diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 16c8dbd0..db42c991 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -232,7 +232,7 @@ def _collect_export_parameters(self) -> dict: } def calc_pivot_to_feedthru(self): - return ( + return ( # fmt: skip self.ball_valve_cap_thickness + self.measure_1 - self.probe_kf40_thickness @@ -328,10 +328,8 @@ def _validate_measure_2(self): _txt = self.measure_2_label.text() value = self._validate_measure(_txt) - if ( - value is None # input was invalid - or value <= 0 # not physically possible - ): + if value is None or value <= 0: + # input was invalid OR not physically possible self._update_all_labels() return From f9bf84ad4107d5ae215b6e61a31a35a750bfb5ed Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:52:31 -0700 Subject: [PATCH 079/177] remove unused imports --- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index db42c991..47b6a86e 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -3,17 +3,8 @@ import ast import re -from PySide6.QtCore import QPoint, Qt, Signal, Slot -from PySide6.QtGui import QPixmap -from PySide6.QtWidgets import ( - QFrame, - QHBoxLayout, - QLabel, - QLineEdit, - QRadioButton, - QVBoxLayout, - QWidget, -) +from PySide6.QtCore import QPoint, Qt, Slot +from PySide6.QtWidgets import QLineEdit from typing import Optional, Union from bapsf_motion.gui.calculators.bases import BaseCalculatorApp, BaseCalculatorWindow From 34783aa82a604dbcfe1084ae4113771d211e32d3 Mon Sep 17 00:00:00 2001 From: erik Date: Fri, 22 May 2026 18:55:40 -0700 Subject: [PATCH 080/177] have LaPDXYTransformCalculatorApp inherit from BaseCalculatorApp --- bapsf_motion/gui/calculators/lapd_xy_transform.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/bapsf_motion/gui/calculators/lapd_xy_transform.py b/bapsf_motion/gui/calculators/lapd_xy_transform.py index 8caa7104..5337ed39 100644 --- a/bapsf_motion/gui/calculators/lapd_xy_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xy_transform.py @@ -7,7 +7,6 @@ from PySide6.QtCore import QPoint, Qt, Signal, Slot from PySide6.QtGui import QPixmap from PySide6.QtWidgets import ( - QApplication, QFrame, QHBoxLayout, QLabel, @@ -19,6 +18,7 @@ ) from typing import Optional, Union +from bapsf_motion.gui.calculators.bases import BaseCalculatorApp from bapsf_motion.gui.widgets import StyleButton _HERE = Path(__file__).parent @@ -447,16 +447,8 @@ def closeEvent(self, event): super().closeEvent(event) -class LaPDXYTransformCalculatorApp(QApplication): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - self.setStyle("Fusion") - self.styleHints().setColorScheme(Qt.ColorScheme.Light) - - self._window = LaPDXYTransformCalculator() - self._window.show() - self._window.activateWindow() +class LaPDXYTransformCalculatorApp(BaseCalculatorApp): + _CALCULATOR_CLASS = LaPDXYTransformCalculator if __name__ == "__main__": From ed94d671f590457bbc9cab6e0b21cc56bcc89b66 Mon Sep 17 00:00:00 2001 From: erik Date: Sun, 24 May 2026 10:04:17 -0700 Subject: [PATCH 081/177] add word Transform to the XYZ window title --- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index 47b6a86e..d943cee4 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -12,7 +12,7 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): - _WINDOW_TITLE = "LaPD XYZ Calculator" + _WINDOW_TITLE = "LaPD XYZ Transform Calculator" _IMAGE_NAME = "LaPDXYZTransform_diagram.png" _defaults = { # all values in cm From 175345320bfc03bdffa9a2fb8abb612b62e40fe5 Mon Sep 17 00:00:00 2001 From: erik Date: Sun, 24 May 2026 10:05:00 -0700 Subject: [PATCH 082/177] Integrate BaseCalculoatorWindow into LaPDXYTransformCalculator --- .../gui/calculators/lapd_xy_transform.py | 244 +++++++----------- 1 file changed, 95 insertions(+), 149 deletions(-) diff --git a/bapsf_motion/gui/calculators/lapd_xy_transform.py b/bapsf_motion/gui/calculators/lapd_xy_transform.py index 5337ed39..9ef18399 100644 --- a/bapsf_motion/gui/calculators/lapd_xy_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xy_transform.py @@ -3,30 +3,16 @@ import ast import re -from pathlib import Path -from PySide6.QtCore import QPoint, Qt, Signal, Slot -from PySide6.QtGui import QPixmap -from PySide6.QtWidgets import ( - QFrame, - QHBoxLayout, - QLabel, - QLineEdit, - QMainWindow, - QRadioButton, - QVBoxLayout, - QWidget, -) +from PySide6.QtCore import QPoint, Qt, Slot +from PySide6.QtWidgets import QLineEdit, QRadioButton from typing import Optional, Union -from bapsf_motion.gui.calculators.bases import BaseCalculatorApp -from bapsf_motion.gui.widgets import StyleButton +from bapsf_motion.gui.calculators.bases import BaseCalculatorApp, BaseCalculatorWindow -_HERE = Path(__file__).parent -_IMAGES_PATH = (_HERE / "_images").resolve() - -class LaPDXYTransformCalculator(QMainWindow): - closing = Signal() +class LaPDXYTransformCalculator(BaseCalculatorWindow): + _WINDOW_TITLE = "LaPD XY Tansform Calculator" + _IMAGE_NAME = "LaPDXYTransform_diagram.png" _defaults = { # all values in cm "measure_1": 54.2, @@ -34,92 +20,29 @@ class LaPDXYTransformCalculator(QMainWindow): } def __init__(self): - super().__init__() - - _stylesheet = self.styleSheet() - _stylesheet += """ - QFrame#image_frame { - border: 2px solid rgb(125, 125, 125); - border-radius: 5px; - padding: 0px; - margin: 0px; - background-color: white; - } - - QLineEdit { border: 2px solid black; border-radius: 5px } - QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } - QLineEdit#measure_2a { border: 2px solid rgb(255, 0, 0) } - QLineEdit#measure_2b { border: 2px solid rgb(255, 0, 0) } - - QLineEdit#ball_valve_cap_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#probe_kf40_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#probe_drive_endplate_thickness { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#velmex_rail_width { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - QLineEdit#fiducial_width { - border: 2px solid rgb(68, 114, 196); - color: rgb(68, 114, 196); - } - """ - self.setStyleSheet(_stylesheet) - - self.setCentralWidget(QWidget(parent=self)) - - self._image_file_path = (_IMAGES_PATH / "LaPDXYTransform_diagram.png").resolve() - pixmap = QPixmap(f"{self._image_file_path}") - self._image = pixmap - - self._window_margin = 12 - self._define_main_window() - - self.image_label = QLabel(parent=self) - self.image_label.setPixmap(self._image) - - self.image_frame = QFrame(parent=self) - self.image_frame.setObjectName("image_frame") - self.image_frame.setStyleSheet(_stylesheet) - self.image_frame.setFixedWidth(self.width() - 2 * self._window_margin) - self.image_frame.setFixedHeight(self.height() - 2 * self._window_margin) - # all values in cm + # Initialized constants (all values in cm) self.ball_valve_cap_thickness = 0.81 * 2.54 self.probe_drive_endplate_thickness = 0.75 * 2.54 self.probe_kf40_thickness = 2.54 self.velmex_rail_width = 3.4 * 2.54 self.fiducial_width = 1.775 * 2.54 - # constants need to be defined first + # Initialized measure values self.measure_1 = self._defaults["measure_1"] self.measure_2a = self._defaults["measure_2a"] self.measure_2b = self.convert_measure_2a_to_measure_2b() - # measures and constants need to be defined first + # Initilized "Calculated" Transform Parameters self.pivot_to_center = 58.771 self.pivot_to_feedthru = self.calc_pivot_to_feedthru() self.pivot_to_drive = self.calc_pivot_to_drive() - _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(260, 43) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_center_label = _txt + super().__init__() + def _init_widgets(self): + # + # Place "measure" labels _txt = QLineEdit(f"{self.measure_1:.2f} cm", parent=self) _txt.setReadOnly(False) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) @@ -157,28 +80,7 @@ def __init__(self): self.measure_2b_label = _txt self.measure_2b_label.setEnabled(False) - _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(736, 98) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_feedthru_label = _txt - - _txt = QLineEdit(f"{self.pivot_to_drive:.3f} cm", parent=self) - _txt.setReadOnly(True) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - p = self.geometry().topLeft() + QPoint(1134, 43) - _txt.move(p) - _txt.setFixedWidth(120) - self.pivot_to_drive_label = _txt - + # Place "constant" labels _txt = QLineEdit(f"{self.ball_valve_cap_thickness:.3f} cm", parent=self) _txt.setReadOnly(True) _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) @@ -244,13 +146,46 @@ def __init__(self): _txt.setObjectName("fiducial_width") self.fiducial_width_label = _txt - _btn = StyleButton("Reset to Defaults", parent=self) - _btn.setFixedWidth(200) - _btn.setFixedHeight(36) - _btn.setPointSize(14) - p = self.geometry().topLeft() + QPoint(32, 472) - _btn.move(p) - self.reset_btn = _btn + # Place "Transform Parameter" Labels + _txt = QLineEdit(f"{self.pivot_to_center:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(260, 43) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_center_label = _txt + + _txt = QLineEdit(f"{self.pivot_to_feedthru:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(736, 98) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_feedthru_label = _txt + + _txt = QLineEdit(f"{self.pivot_to_drive:.3f} cm", parent=self) + _txt.setReadOnly(True) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + p = self.geometry().topLeft() + QPoint(1134, 43) + _txt.move(p) + _txt.setFixedWidth(120) + self.pivot_to_drive_label = _txt + + # Place Action Buttons + p = self.geometry().topLeft() + QPoint(262, 512) + self.reset_btn.move(p) + + p = self.reset_btn.pos() + QPoint(self.reset_btn.width() + 12, 0) + self.export_btn.move(p) _btn = QRadioButton(parent=self) p = self.measure_2a_label.pos() + QPoint(self.measure_2a_label.width() + 6, 0) @@ -263,41 +198,52 @@ def __init__(self): _btn.move(p) self.measure_2b_btn = _btn - layout = self._define_layout() - self.centralWidget().setLayout(layout) - - self._connect_signals() - - def _define_main_window(self): - self.setWindowTitle("LaPD XY Transform Calculator") - width = self._image.width() + 2 * self._window_margin - height = self._image.height() + 2 * self._window_margin - self.resize(width, height) - self.setFixedWidth(width) - self.setFixedHeight(height) - def _connect_signals(self): self.measure_1_label.editingFinished.connect(self._validate_measure_1) self.measure_2a_label.editingFinished.connect(self._validate_measure_2a) self.measure_2b_label.editingFinished.connect(self._validate_measure_2b) - self.reset_btn.clicked.connect(self._reset_measure_values) - self.measure_2a_btn.toggled.connect(self._measure_2a_input_selected) self.measure_2b_btn.toggled.connect(self._measure_2b_input_selected) - def _define_layout(self): - image_layout = QVBoxLayout() - image_layout.setContentsMargins(0, 0, 0, 0) - image_layout.addWidget(self.image_label) - self.image_frame.setLayout(image_layout) + @property + def _stylesheet_string(self): + _stylesheet = super()._stylesheet_string + _stylesheet += """ + QLineEdit { border: 2px solid black; border-radius: 5px } + QLineEdit#measure_1 { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2a { border: 2px solid rgb(255, 0, 0) } + QLineEdit#measure_2b { border: 2px solid rgb(255, 0, 0) } + + QLineEdit#ball_valve_cap_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_kf40_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#probe_drive_endplate_thickness { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#velmex_rail_width { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + QLineEdit#fiducial_width { + border: 2px solid rgb(68, 114, 196); + color: rgb(68, 114, 196); + } + """ + return _stylesheet - layout = QHBoxLayout() - layout.setContentsMargins(0, 0, 0, 0) - layout.addStretch() - layout.addWidget(self.image_frame) - layout.addStretch() - return layout + def _collect_export_parameters(self) -> dict: + return { + "pivot_to_center": self.pivot_to_center, + "pivot_to_drive": self.pivot_to_drive, + "pivot_to_feedthru": self.pivot_to_feedthru, + } def convert_measure_2a_to_measure_2b( self, measure_2a: Optional[float] = None @@ -348,6 +294,10 @@ def _reset_measure_values(self): self.recalculate_parameters() + @Slot() + def _reset_parameters(self): + self._reset_measure_values() + def _update_all_labels(self): self._update_measure_1_label() self._update_measure_2a_label() @@ -442,10 +392,6 @@ def _validate_measure_2b(self): self._update_all_labels() - def closeEvent(self, event): - self.closing.emit() - super().closeEvent(event) - class LaPDXYTransformCalculatorApp(BaseCalculatorApp): _CALCULATOR_CLASS = LaPDXYTransformCalculator From 0210c68011947b5eeab525c94d74e64fac1d357f Mon Sep 17 00:00:00 2001 From: erik Date: Tue, 26 May 2026 09:12:56 -0700 Subject: [PATCH 083/177] add class attributes _CALCULATOR_FAMILY and _CALCULATOR_TYPE to BaseCalculatorWindow --- bapsf_motion/gui/calculators/bases.py | 11 +++++++++-- bapsf_motion/gui/calculators/lapd_xy_transform.py | 7 ++++++- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 8fa3b2ed..d75c5bf4 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -13,7 +13,7 @@ QVBoxLayout, QWidget, ) -from typing import Type +from typing import Type, Union from bapsf_motion.gui.widgets import StyleButton @@ -33,6 +33,9 @@ class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): _IMAGE_DIR = _IMAGES_PATH _IMAGE_NAME = NotImplemented # type: str + _CALCULATOR_FAMILY = None # type: Union[str, None] + _CALCULATOR_TYPE = None # type: Union[str, None] + def __init__(self, parent=None): super().__init__(parent) @@ -92,7 +95,11 @@ def _stylesheet_string(self): return _stylesheet @abstractmethod - def _collect_export_parameters(self) -> dict: ... + def _collect_export_parameters(self) -> dict: + return { + "calculator_family": self._CALCULATOR_FAMILY, + "calculator_type": self._CALCULATOR_TYPE, + } @abstractmethod def _connect_signals(self): ... diff --git a/bapsf_motion/gui/calculators/lapd_xy_transform.py b/bapsf_motion/gui/calculators/lapd_xy_transform.py index 9ef18399..38e636f4 100644 --- a/bapsf_motion/gui/calculators/lapd_xy_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xy_transform.py @@ -14,6 +14,9 @@ class LaPDXYTransformCalculator(BaseCalculatorWindow): _WINDOW_TITLE = "LaPD XY Tansform Calculator" _IMAGE_NAME = "LaPDXYTransform_diagram.png" + _CALCULATOR_FAMILY = "transform" + _CALCULATOR_TYPE = "lapd_xy" + _defaults = { # all values in cm "measure_1": 54.2, "measure_2a": 58.0, @@ -239,11 +242,13 @@ def _stylesheet_string(self): return _stylesheet def _collect_export_parameters(self) -> dict: - return { + params = { + **super()._collect_export_parameters(), "pivot_to_center": self.pivot_to_center, "pivot_to_drive": self.pivot_to_drive, "pivot_to_feedthru": self.pivot_to_feedthru, } + return params def convert_measure_2a_to_measure_2b( self, measure_2a: Optional[float] = None From 4a3a09300b6ab6dde7da692ec4ed7c7b2cbd8add Mon Sep 17 00:00:00 2001 From: erik Date: Tue, 26 May 2026 09:13:54 -0700 Subject: [PATCH 084/177] start incorporating BaseCalculatorWindow.exportParameters into ConfigureGUI --- bapsf_motion/gui/configure/configure_.py | 25 ++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/bapsf_motion/gui/configure/configure_.py b/bapsf_motion/gui/configure/configure_.py index 4c74a000..7c01f5aa 100644 --- a/bapsf_motion/gui/configure/configure_.py +++ b/bapsf_motion/gui/configure/configure_.py @@ -37,6 +37,7 @@ from bapsf_motion.gui.calculators import LaPDXYTransformCalculator from bapsf_motion.gui.configure.helpers import gui_logger, gui_logger_config_dict from bapsf_motion.gui.configure.motion_group_widget import MGWidget +from bapsf_motion.gui.configure.transform_overlay import TransformConfigOverlay from bapsf_motion.gui.icons import icon_name_dict from bapsf_motion.gui.widgets import ( DiscardButton, @@ -772,9 +773,33 @@ def _launch_lapd_xy_calculator(self): _window.setObjectName("lapd_xy_calculator") _window.show() _window.activateWindow() + _window.exportParameters.connect(self._import_calculator_parameters) self._launched_windows["lapd_xy_calculator"] = _window + @Slot(object) + def _import_calculator_parameters(self, parameters: Dict[str, Any]): + if not isinstance(parameters, dict): + return + + calc_family = parameters.pop("calculator_family", None) + calc_type = parameters.pop("calculator_type", None) + + if calc_family != "transform": + return + + active_widget = self._stacked_widget.currentWidget() + if not isinstance(active_widget, MGWidget): + # TODO: ADD A WARNING DIALOG + return + + active_overlay = active_widget._overlay_widget + if not isinstance(active_overlay, TransformConfigOverlay): + # TODO: ADD WARNING DIALOG + return + + print(parameters) + @Slot(str) def _launched_windows_closed(self, name: str): if name not in self._launched_windows: From bfec80bf8c5706e177db03fab12854e84ac964f1 Mon Sep 17 00:00:00 2001 From: Erik Date: Tue, 26 May 2026 12:26:34 -0700 Subject: [PATCH 085/177] add to TransformConfigOverlay the signal importParameters --- .../gui/configure/transform_overlay.py | 33 ++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/transform_overlay.py b/bapsf_motion/gui/configure/transform_overlay.py index 850b9942..96a6fff5 100644 --- a/bapsf_motion/gui/configure/transform_overlay.py +++ b/bapsf_motion/gui/configure/transform_overlay.py @@ -10,7 +10,7 @@ import inspect import math -from PySide6.QtCore import QSize, Qt, Slot +from PySide6.QtCore import QSize, Qt, Slot, Signal from PySide6.QtWidgets import ( QComboBox, QGridLayout, @@ -37,6 +37,8 @@ class TransformConfigOverlay(_ConfigOverlay): + importParameters = Signal(object) + registry = transform_registry def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): @@ -91,6 +93,7 @@ def _connect_signals(self): super()._connect_signals() self.combo_widget.currentTextChanged.connect(self._refresh_params_widget) + self.importParameters.connect(self._import_params) def _define_layout(self): @@ -181,6 +184,7 @@ def _define_params_widget(self, tr_type: str): self._transform_inputs = {} _widget = QWidget(parent=self) + _widget.setObjectName("Parameters Widget") layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) @@ -279,6 +283,33 @@ def _define_params_widget(self, tr_type: str): _widget.setLayout(layout) return _widget + @Slot(object) + def _import_params(self, params: dict): + _backup_params = self.transform_inputs.copy() + + if not isinstance(params, dict): + return + params.pop("type", None) + + param_widget = self.findChild(QWidget, "Parameters Widget") + if not isinstance(param_widget, QWidget): + return + + for param_name, param_val in params.items(): + _input = param_widget.findChild(QLineEditSpecialized, param_name) + if not isinstance(_input, QLineEditSpecialized): + continue + + if param_val is None: + input_string = "" + elif isinstance(param_val, float): + input_string = f"{param_val:.4f}" + else: + input_string = f"{param_val}" + + _input.setText(input_string) + self._update_transform_inputs(_input) + @Slot(str) def _refresh_params_widget(self, tr_type): _widget = self._define_params_widget(tr_type) From e9739156daa7a8feefe61403428068faf704a593 Mon Sep 17 00:00:00 2001 From: Erik Date: Tue, 26 May 2026 12:27:26 -0700 Subject: [PATCH 086/177] update LaPDXYZTransformCalculator to utilize class attributes _CALCULATOR_FAMILY and _CALCULATOR_TYPE --- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index d943cee4..f6fd0150 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -15,6 +15,9 @@ class LaPDXYZTransformCalculator(BaseCalculatorWindow): _WINDOW_TITLE = "LaPD XYZ Transform Calculator" _IMAGE_NAME = "LaPDXYZTransform_diagram.png" + _CALCULATOR_FAMILY = "transform" + _CALCULATOR_TYPE = "lapd_xyz" + _defaults = { # all values in cm "measure_1": 54.2, "measure_2": 58.0, @@ -216,6 +219,7 @@ def _stylesheet_string(self): def _collect_export_parameters(self) -> dict: return { + **super()._collect_export_parameters(), "pivot_to_center": self.pivot_to_center, "probe_axis_offset": self.probe_axis_offset, "table_pivot_to_zlead_screw": self.table_pivot_to_zlead_screw, From df5f6a0c30e923fa51266bf187ea3aecad8175ba Mon Sep 17 00:00:00 2001 From: Erik Date: Tue, 26 May 2026 12:30:10 -0700 Subject: [PATCH 087/177] create a generic warning dialog box --- bapsf_motion/gui/configure/message_boxes.py | 25 +++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 bapsf_motion/gui/configure/message_boxes.py diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py new file mode 100644 index 00000000..4f2b98a0 --- /dev/null +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -0,0 +1,25 @@ +__all__ = ["WarningMessageBox"] + +from PySide6.QtWidgets import QMessageBox, QWidget +from typing import Union + + +class WarningMessageBox(QMessageBox): + """ + A generical modal warning dialog box to dispaly arbitrary warning + messages. + """ + + def __init__(self, message: str, parent: Union[QWidget, None] = None): + super().__init__(parent) + + self.setWindowTitle("!! WARNING !!") + self.setIcon(QMessageBox.Icon.Warning) + self.setStandardButtons(QMessageBox.StandardButton.Ok) + self.setDefaultButton(QMessageBox.StandardButton.Ok) + + # define font size for warning text + font = self.font() + font.setPointSize(14) + self.setFont(font) + self.setText(message) From fd251e41f4a30cba8f71552e0e1ccce6bd72949f Mon Sep 17 00:00:00 2001 From: Erik Date: Tue, 26 May 2026 12:30:53 -0700 Subject: [PATCH 088/177] flush out ConfigureGUI._import_calculator_parameters() --- bapsf_motion/gui/configure/configure_.py | 47 ++++++++++++++++++++++-- 1 file changed, 44 insertions(+), 3 deletions(-) diff --git a/bapsf_motion/gui/configure/configure_.py b/bapsf_motion/gui/configure/configure_.py index 7c01f5aa..c2a06e69 100644 --- a/bapsf_motion/gui/configure/configure_.py +++ b/bapsf_motion/gui/configure/configure_.py @@ -36,6 +36,7 @@ from bapsf_motion.actors import MotionGroup, RunManager, RunManagerConfig from bapsf_motion.gui.calculators import LaPDXYTransformCalculator from bapsf_motion.gui.configure.helpers import gui_logger, gui_logger_config_dict +from bapsf_motion.gui.configure.message_boxes import WarningMessageBox from bapsf_motion.gui.configure.motion_group_widget import MGWidget from bapsf_motion.gui.configure.transform_overlay import TransformConfigOverlay from bapsf_motion.gui.icons import icon_name_dict @@ -786,19 +787,59 @@ def _import_calculator_parameters(self, parameters: Dict[str, Any]): calc_type = parameters.pop("calculator_type", None) if calc_family != "transform": + warn_msg = ( + "Can NOT import parameters from the calculator, since " + f"the calculator family ('{calc_family}') is unknown." + ) + self.logger.warning(warn_msg) + + dialog = WarningMessageBox(warn_msg, parent=self) + dialog.exec() return active_widget = self._stacked_widget.currentWidget() if not isinstance(active_widget, MGWidget): - # TODO: ADD A WARNING DIALOG + warn_msg = ( + "Can NOT import parameters from the calculator, since " + f"the Transformation Configuration Overlay is NOT active." + ) + self.logger.warning(warn_msg) + + dialog = WarningMessageBox(warn_msg, parent=self) + dialog.exec() return active_overlay = active_widget._overlay_widget if not isinstance(active_overlay, TransformConfigOverlay): - # TODO: ADD WARNING DIALOG + warn_msg = ( + "Can NOT import parameters from the calculator, since " + f"the Transformation Configuration Overlay is NOT active." + ) + self.logger.warning(warn_msg) + + dialog = WarningMessageBox(warn_msg, parent=self) + dialog.exec() + return + + overlay_transform_type = active_overlay.transform_type + if calc_type != overlay_transform_type: + warn_msg = ( + "Can NOT import parameters from the calculator, since " + f"the calculator transform type ('{calc_type}') does NOT " + f"match the transfrom type ('{overlay_transform_type}') " + f"of the current configuration window." + ) + self.logger.warning(warn_msg) + + dialog = WarningMessageBox(warn_msg, parent=self) + dialog.exec() return - print(parameters) + transform_params = { + **active_overlay.transform_inputs, + **parameters, + } + active_overlay.importParameters.emit(transform_params) @Slot(str) def _launched_windows_closed(self, name: str): From 8c72c45ccc58275cce5ba36066f7fd47ff043b13 Mon Sep 17 00:00:00 2001 From: Erik Date: Wed, 27 May 2026 20:28:19 -0700 Subject: [PATCH 089/177] replace uses of Union[] with pipe | --- bapsf_motion/gui/calculators/bases.py | 4 ++-- bapsf_motion/gui/calculators/lapd_xyz_transform.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/calculators/bases.py b/bapsf_motion/gui/calculators/bases.py index 693aa624..13e3d865 100644 --- a/bapsf_motion/gui/calculators/bases.py +++ b/bapsf_motion/gui/calculators/bases.py @@ -33,8 +33,8 @@ class BaseCalculatorWindow(QMainWindow, ABC, metaclass=QABCMainWindow): _IMAGE_DIR = _IMAGES_PATH _IMAGE_NAME = NotImplemented # type: str - _CALCULATOR_FAMILY = None # type: Union[str, None] - _CALCULATOR_TYPE = None # type: Union[str, None] + _CALCULATOR_FAMILY = None # type: str | None + _CALCULATOR_TYPE = None # type: str | None def __init__(self, parent=None): super().__init__(parent) diff --git a/bapsf_motion/gui/calculators/lapd_xyz_transform.py b/bapsf_motion/gui/calculators/lapd_xyz_transform.py index f6fd0150..0f4d5724 100644 --- a/bapsf_motion/gui/calculators/lapd_xyz_transform.py +++ b/bapsf_motion/gui/calculators/lapd_xyz_transform.py @@ -5,7 +5,7 @@ from PySide6.QtCore import QPoint, Qt, Slot from PySide6.QtWidgets import QLineEdit -from typing import Optional, Union +from typing import Optional from bapsf_motion.gui.calculators.bases import BaseCalculatorApp, BaseCalculatorWindow from bapsf_motion.gui.widgets import StyleButton @@ -290,7 +290,7 @@ def _update_measure_2_label(self): self.measure_2_label.setText(_txt) @staticmethod - def _validate_measure(text: str) -> Union[float, None]: + def _validate_measure(text: str) -> float | None: match = re.compile(r"(?P\d+(.\d*)?)(\s*cm)?").fullmatch(text) if match is None: From b9ab658d746d7761a1d88ecb6a052fdce4052d79 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 09:28:58 -0700 Subject: [PATCH 090/177] DriveConfigOverlay: create init methods for add_axis_btn, validate_btn, and validate_led --- bapsf_motion/gui/configure/drive_overlay.py | 52 ++++++++++++--------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index a2fdc5b7..9fddb0a1 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -902,29 +902,9 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): self._axis_widgets = None # Define BUTTONS - - _btn = StyleButton("Add Axis", parent=self) - _btn.setFixedWidth(120) - _btn.setFixedHeight(36) - font = _btn.font() - font.setPointSize(20) - _btn.setFont(font) - _btn.setEnabled(False) - _btn.setHidden(True) - self.add_axis_btn = _btn - - _btn = StyleButton("Validate", parent=self) - _btn.setFixedWidth(150) - _btn.setFixedHeight(36) - font = _btn.font() - font.setPointSize(16) - _btn.setFont(font) - self.validate_btn = _btn - - _btn = LED(parent=self) - _btn.set_fixed_height(32) - _btn.off_color = "d43729" - self.validate_led = _btn + self.add_axis_btn = self._init_add_axis_btn() + self.validate_btn = self._init_validate_btn() + self.validate_led = self._init_validate_led() # Define TEXT WIDGETS _widget = QLineEdit(parent=self) @@ -1021,6 +1001,32 @@ def _define_second_row_layout(self): return layout + def _init_add_axis_btn(self): + _btn = StyleButton("Add Axis", parent=self) + _btn.setFixedWidth(120) + _btn.setFixedHeight(36) + font = _btn.font() + font.setPointSize(20) + _btn.setFont(font) + _btn.setEnabled(False) + _btn.setHidden(True) + return _btn + + def _init_validate_btn(self): + _btn = StyleButton("Validate", parent=self) + _btn.setFixedWidth(150) + _btn.setFixedHeight(36) + font = _btn.font() + font.setPointSize(16) + _btn.setFont(font) + return _btn + + def _init_validate_led(self): + _btn = LED(parent=self) + _btn.set_fixed_height(32) + _btn.off_color = "d43729" + return _btn + @property def drive(self) -> Union[Drive, None]: return self._drive From f960f8fed5fec59eadd368c2c1c7fdfa15e370be Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 09:30:31 -0700 Subject: [PATCH 091/177] DriveConfigOverlay: refactor dr_name_widget -> drive_name_input --- bapsf_motion/gui/configure/drive_overlay.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index 9fddb0a1..b3c0a338 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -912,7 +912,7 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): font.setPointSize(16) _widget.setFont(font) _widget.setMinimumWidth(220) - self.dr_name_widget = _widget + self.drive_name_input = _widget # Define ADVANCED WIDGETS @@ -941,9 +941,9 @@ def _connect_signals(self): self.validate_btn.clicked.connect(self._validate_drive) - self.configChanged.connect(self._update_dr_name_widget) + self.configChanged.connect(self._update_drive_name_input) - self.dr_name_widget.editingFinished.connect(self._change_drive_name) + self.drive_name_input.editingFinished.connect(self._change_drive_name) def _define_layout(self): @@ -986,12 +986,12 @@ def _define_second_row_layout(self): _label.setFont(font) name_label = _label - self._update_dr_name_widget() + self._update_drive_name_input() layout = QHBoxLayout() layout.addSpacing(18) layout.addWidget(name_label) - layout.addWidget(self.dr_name_widget) + layout.addWidget(self.drive_name_input) layout.addStretch() layout.addWidget(self.add_axis_btn) layout.addStretch() @@ -1044,7 +1044,7 @@ def drive_config(self) -> Dict[str, Any]: self._drive_config = self.drive.config.copy() return self._drive_config elif self._drive_config is None: - name = self.dr_name_widget.text() + name = self.drive_name_input.text() name = "A New Drive" if name == "" else name self._drive_config = {"name": name} @@ -1073,7 +1073,7 @@ def axis_ips(self): @Slot() def _change_drive_name(self): self.logger.info("Renaming drive...") - new_name = self.dr_name_widget.text() + new_name = self.drive_name_input.text() if isinstance(self.drive, Drive): self.drive.name = new_name else: @@ -1091,9 +1091,9 @@ def _change_validation_state(self, validate=False): self._set_drive(None) @Slot() - def _update_dr_name_widget(self): + def _update_drive_name_input(self): name = self.drive_config.get("name", "") - self.dr_name_widget.setText(name) + self.drive_name_input.setText(name) def set_drive_handler(self, handler: Callable): ... @@ -1126,7 +1126,7 @@ def _validate_drive(self): self.logger.warning("Drive is not valid since not all axes are online.") self._change_validation_state(False) return - elif self.dr_name_widget.text() == "": + elif self.drive_name_input.text() == "": self.logger.warning("Drive is not valid, it needs a name.") self._change_validation_state(False) return From 4c551a984cf8d8d13b54dfc74feeec9dcdf913b6 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 09:44:09 -0700 Subject: [PATCH 092/177] DriveConfigOverlay: create _init_drive_name_input() --- bapsf_motion/gui/configure/drive_overlay.py | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index b3c0a338..a77c9e1b 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -901,20 +901,11 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): self._drive_config = None self._axis_widgets = None - # Define BUTTONS + # Define WIDGETS self.add_axis_btn = self._init_add_axis_btn() self.validate_btn = self._init_validate_btn() self.validate_led = self._init_validate_led() - - # Define TEXT WIDGETS - _widget = QLineEdit(parent=self) - font = _widget.font() - font.setPointSize(16) - _widget.setFont(font) - _widget.setMinimumWidth(220) - self.drive_name_input = _widget - - # Define ADVANCED WIDGETS + self.drive_name_input = self._init_drive_name_input() # initialize drive configuration _drive_config = None @@ -1012,6 +1003,14 @@ def _init_add_axis_btn(self): _btn.setHidden(True) return _btn + def _init_drive_name_input(self): + _input = QLineEdit(parent=self) + font = _input.font() + font.setPointSize(16) + _input.setFont(font) + _input.setMinimumWidth(220) + return _input + def _init_validate_btn(self): _btn = StyleButton("Validate", parent=self) _btn.setFixedWidth(150) From e92c9838262a22d630426f88047686c39ba1cb8c Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:49:28 -0700 Subject: [PATCH 093/177] add annotations to AxisConfigWidget --- bapsf_motion/gui/configure/drive_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index a77c9e1b..82fcaff3 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -50,7 +50,7 @@ class AxisConfigWidget(QWidget): "speed": 4.0, } - def __init__(self, name, parent=None): + def __init__(self, name, parent: QWidget | None = None): super().__init__(parent=parent) self.axis_loop = asyncio.new_event_loop() From ddf73843e1f6ffb7e37f5290b725ff2f177f535c Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:50:42 -0700 Subject: [PATCH 094/177] DriveConfigOverlay: create a remove axis button and match style to add axis button --- bapsf_motion/gui/configure/drive_overlay.py | 22 ++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index 82fcaff3..9d735d3d 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -903,6 +903,7 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): # Define WIDGETS self.add_axis_btn = self._init_add_axis_btn() + self.remove_axis_btn = self._init_remove_axis_btn() self.validate_btn = self._init_validate_btn() self.validate_led = self._init_validate_led() self.drive_name_input = self._init_drive_name_input() @@ -993,14 +994,14 @@ def _define_second_row_layout(self): return layout def _init_add_axis_btn(self): - _btn = StyleButton("Add Axis", parent=self) - _btn.setFixedWidth(120) + _btn = StyleButton("ADD Axis", parent=self) + _btn.setFixedWidth(180) _btn.setFixedHeight(36) font = _btn.font() - font.setPointSize(20) + font.setPointSize(16) _btn.setFont(font) - _btn.setEnabled(False) - _btn.setHidden(True) + _btn.setEnabled(True) + _btn.setVisible(True) return _btn def _init_drive_name_input(self): @@ -1011,6 +1012,17 @@ def _init_drive_name_input(self): _input.setMinimumWidth(220) return _input + def _init_remove_axis_btn(self): + _btn = StyleButton("REMOVE Axis", parent=self) + _btn.setFixedWidth(180) + _btn.setFixedHeight(36) + font = _btn.font() + font.setPointSize(16) + _btn.setFont(font) + _btn.setEnabled(True) + _btn.setVisible(True) + return _btn + def _init_validate_btn(self): _btn = StyleButton("Validate", parent=self) _btn.setFixedWidth(150) From 4b9acfbbcf18c5ab38e3b50a81853dbe0b702ef1 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:52:41 -0700 Subject: [PATCH 095/177] DriveConfigOverlay: move axis layout construction to dedicate method _define_axis_config_layout() ... open up adding and removing axes between 2 and 3 --- bapsf_motion/gui/configure/drive_overlay.py | 66 ++++++++++++++++----- 1 file changed, 51 insertions(+), 15 deletions(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index 9d735d3d..47bea811 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -890,6 +890,7 @@ def closeEvent(self, event): class DriveConfigOverlay(_ConfigOverlay): drive_loop = asyncio.new_event_loop() + _default_axis_names = ("X", "Y", "Z") def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): super().__init__(mg, parent) @@ -944,19 +945,7 @@ def _define_layout(self): layout.addWidget(HLinePlain(parent=self)) layout.addLayout(self._define_second_row_layout()) layout.addSpacing(24) - - drive_config = self._drive_config - for ii, name in enumerate(("X", "Y")): - layout.addWidget(self._spawn_axis_widget(name)) - - # initialize axis widget - if "axes" in drive_config: - try: - ax_config = drive_config["axes"][ii] - self.axis_widgets[ii].axis_config = ax_config - except KeyError: - continue - + layout.addLayout(self._define_axis_config_layout()) layout.addStretch(1) return layout @@ -985,14 +974,61 @@ def _define_second_row_layout(self): layout.addWidget(name_label) layout.addWidget(self.drive_name_input) layout.addStretch() - layout.addWidget(self.add_axis_btn) - layout.addStretch() layout.addWidget(self.validate_btn) layout.addWidget(self.validate_led) layout.addSpacing(18) return layout + def _define_axis_config_layout(self): + layout = QVBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.setObjectName("axis_vbox_layout") + + drive_config = self._drive_config + axis_names = [] + if "axes" in drive_config: + axis_names = [] + for ii, ax in drive_config["axes"].items(): + ax_name = ax.get("name", self._default_axis_names[ii]) + axis_names.append(ax_name) + axis_names = tuple(axis_names) + + if len(axis_names) == 0: + axis_names = self._default_axis_names[:2] + + for ii, name in enumerate(axis_names): + layout.addWidget(self._spawn_axis_widget(name)) + + # initialize axis widget + if "axes" in drive_config: + try: + ax_config = drive_config["axes"][ii] + self.axis_widgets[ii].axis_config = ax_config + except KeyError: + continue + + sub_layout = QHBoxLayout() + sub_layout.setContentsMargins(0, 0, 0, 0) + sub_layout.addStretch(1) + sub_layout.addWidget(self.add_axis_btn) + sub_layout.addSpacing(8) + sub_layout.addWidget(self.remove_axis_btn) + sub_layout.addStretch(1) + + layout.addLayout(sub_layout) + + if len(self.axis_widgets) == 2: + # can not have less that 2 axes (at the moment) + self.remove_axis_btn.setVisible(False) + self.remove_axis_btn.setEnabled(False) + elif len(self.axis_widgets) == 3: + # can not have more than 3 axes (at the moment) + self.add_axis_btn.setVisible(False) + self.add_axis_btn.setEnabled(False) + + return layout + def _init_add_axis_btn(self): _btn = StyleButton("ADD Axis", parent=self) _btn.setFixedWidth(180) From 03aa913ff6f23da35aaa28f9bb42709e61133d39 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:53:46 -0700 Subject: [PATCH 096/177] DriveConfigOverlay: create and connect functionality for adding a new axis --- bapsf_motion/gui/configure/drive_overlay.py | 22 +++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index 47bea811..c9053482 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -933,6 +933,7 @@ def _connect_signals(self): super()._connect_signals() self.validate_btn.clicked.connect(self._validate_drive) + self.add_axis_btn.clicked.connect(self._add_axis) self.configChanged.connect(self._update_drive_name_input) @@ -1117,6 +1118,27 @@ def axis_ips(self): return [axw.axis_config["ip"] for axw in self.axis_widgets] + @Slot() + def _add_axis(self): + # Currently the number of axes is restricted to 2 or 3. Thus, + # adding an axis is always a request to add the 3rd axis. + # + ax_name = self._default_axis_names[2] + acw = self._spawn_axis_widget(ax_name) + + ax_layout = self.findChild(QVBoxLayout, "axis_vbox_layout") + ax_layout.insertWidget(2, acw) + + # hide and disable the add btn + self.add_axis_btn.setVisible(False) + self.add_axis_btn.setEnabled(False) + + # show and enable the remove btn + self.remove_axis_btn.setVisible(True) + self.remove_axis_btn.setEnabled(True) + + self._change_validation_state(False) + @Slot() def _change_drive_name(self): self.logger.info("Renaming drive...") From 71e29018a4930703e552d442bfae1bfb0132e143 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:54:22 -0700 Subject: [PATCH 097/177] DriveConfigOverlay: add annotation to _change_validation_state() --- bapsf_motion/gui/configure/drive_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index c9053482..2a8a7dc8 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -1151,7 +1151,7 @@ def _change_drive_name(self): self.configChanged.emit() @Slot() - def _change_validation_state(self, validate=False): + def _change_validation_state(self, validate: bool = False): self.logger.info(f"Changing validation state to {validate}.") self.validate_led.setChecked(validate) self.done_btn.setEnabled(validate) From 8d0d6dc14cb416d06163e1ef12b9db08e08217ee Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:55:10 -0700 Subject: [PATCH 098/177] DriveConfigOverlay: make the parent of AxisConfigWidget() the frame it's placed in (the parent to that QFrame is DriveConfigOverlay) --- bapsf_motion/gui/configure/drive_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index 2a8a7dc8..ce921484 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -1218,7 +1218,7 @@ def _spawn_axis_widget(self, name): _frame = QFrame(parent=self) _frame.setLayout(QVBoxLayout()) - _widget = AxisConfigWidget(name, parent=self) + _widget = AxisConfigWidget(name, parent=_frame) _widget.set_ip_handler(self._validate_ip) _widget.configChanged.connect( partial(self._change_validation_state, validate=False), From 52ea4e730f41a7b39f3389626a61709509689a68 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:55:32 -0700 Subject: [PATCH 099/177] DriveConfigOverlay: create and connect functionality for removing an axis --- bapsf_motion/gui/configure/drive_overlay.py | 24 +++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index ce921484..c020d048 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -934,6 +934,7 @@ def _connect_signals(self): self.validate_btn.clicked.connect(self._validate_drive) self.add_axis_btn.clicked.connect(self._add_axis) + self.remove_axis_btn.clicked.connect(self._remove_axis) self.configChanged.connect(self._update_drive_name_input) @@ -1139,6 +1140,29 @@ def _add_axis(self): self._change_validation_state(False) + @Slot() + def _remove_axis(self): + # Currently the number of axes is restricted to 2 or 3. Thus, + # removing an axis is always a request to remove the 3rd axis. + # + ax_layout = self.findChild(QVBoxLayout, "axis_vbox_layout") + + acw = self.axis_widgets[2] + ax_layout.removeWidget(acw.parentWidget()) + acw.parentWidget().close() # using parent to close since acw lives inside a QFrame + acw.parentWidget().deleteLater() + self.axis_widgets.remove(acw) + + # hide and disable the remove btn + self.remove_axis_btn.setVisible(False) + self.remove_axis_btn.setEnabled(False) + + # show and enable the add btn + self.add_axis_btn.setVisible(True) + self.add_axis_btn.setEnabled(True) + + self._change_validation_state(False) + @Slot() def _change_drive_name(self): self.logger.info("Renaming drive...") From 8645eec6d6e071a9f079a696fc501cc5b7f9c171 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 11:57:49 -0700 Subject: [PATCH 100/177] DriveConfigOverlay: cleanup comment --- bapsf_motion/gui/configure/drive_overlay.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/drive_overlay.py b/bapsf_motion/gui/configure/drive_overlay.py index c020d048..c3271203 100644 --- a/bapsf_motion/gui/configure/drive_overlay.py +++ b/bapsf_motion/gui/configure/drive_overlay.py @@ -1147,9 +1147,12 @@ def _remove_axis(self): # ax_layout = self.findChild(QVBoxLayout, "axis_vbox_layout") + # remove and cleanup the removed AxisConfigWidget + # - using parentWidget() here to ensure the QFrame the widget AxisConfigWidget + # lives in is properly removed acw = self.axis_widgets[2] ax_layout.removeWidget(acw.parentWidget()) - acw.parentWidget().close() # using parent to close since acw lives inside a QFrame + acw.parentWidget().close() acw.parentWidget().deleteLater() self.axis_widgets.remove(acw) From c80259607b3c7bddb9cc90db4f687545c289f769 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 13:39:13 -0700 Subject: [PATCH 101/177] ConfigureGUI: allow drives with dimensionality of 2 or 3 --- bapsf_motion/gui/configure/configure_.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/configure_.py b/bapsf_motion/gui/configure/configure_.py index d2ce0304..fc967723 100644 --- a/bapsf_motion/gui/configure/configure_.py +++ b/bapsf_motion/gui/configure/configure_.py @@ -528,10 +528,10 @@ def replace_rm(self, config): _remove = [] for key, mg in _rm.mgs.items(): - if mg.drive.naxes != 2: + if mg.drive.naxes not in (2, 3): self.logger.warning( f"The Configuration GUI currently only supports motion" - f" groups with a dimensionality of 2, got {mg.drive.naxes}" + f" groups with a dimensionality of 2 or 3, got {mg.drive.naxes}" f" for motion group '{mg.name}'. Removing motion group." ) _remove.append(key) From 61830da1939423fdc166eb506005e6c5d9aaad19 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:02:19 -0700 Subject: [PATCH 102/177] move pygame functionality to dedicated module bapsf_motion.gui.configure.pygame_ --- .../gui/configure/motion_group_widget.py | 165 +--------------- bapsf_motion/gui/configure/pygame_.py | 180 ++++++++++++++++++ 2 files changed, 181 insertions(+), 164 deletions(-) create mode 100644 bapsf_motion/gui/configure/pygame_.py diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 962da994..d83acce5 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -20,8 +20,6 @@ from abc import abstractmethod from PySide6.QtCore import ( - QObject, - QRunnable, QSize, Qt, QThreadPool, @@ -55,6 +53,7 @@ from bapsf_motion.gui.configure.message_boxes import WarningMessageBox from bapsf_motion.gui.configure.motion_builder_overlay import MotionBuilderConfigOverlay from bapsf_motion.gui.configure.motion_space_display import MotionSpaceDisplay +from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner from bapsf_motion.gui.configure.transform_overlay import TransformConfigOverlay from bapsf_motion.gui.icons import icon_name_dict from bapsf_motion.gui.widgets import ( @@ -228,168 +227,6 @@ def exec(self) -> bool: return True -class PyGameJoystickRunnerSignals(QObject): - buttonPressed = Signal(int) - hatPressed = Signal(int, int) - axisMoved = Signal(int, float) - joystickConnected = Signal(bool) - shutdownLoop = Signal() - stopMovement = Signal() - - -class PyGameJoystickRunner(QRunnable): - # signals must be patterned in separate class, otherwise we can not - # connect the signals in out __init__ - signals = PyGameJoystickRunnerSignals() - - def __init__(self, joystick: pygame.joystick.JoystickType): - super().__init__() - - self._logger = gui_logger - self._axis_dead_zone = 0.25 - self._run_loop = False - - # Re-instantiate the joystick since the given joystick was probably - # instantiated in a different thread. - self._joystick = joystick - - self.signals.shutdownLoop.connect(self.run_shutdown) - - def run(self) -> None: - self.logger.info("Starting PyGame Joystick runner") - - if not pygame.get_init(): - pygame.init() - - if not pygame.joystick.get_init(): - pygame.joystick.init() - - js = self.joystick - if not isinstance(self.joystick, pygame.joystick.JoystickType): - pygame.quit() - return - - js.init() - self.run_loop = js.get_init() - self.signals.joystickConnected.emit(self.run_loop) - - clock = pygame.time.Clock() - screen = pygame.display.set_mode((100, 100), flags=pygame.HIDDEN) - - # pygame while loop - # - joystick events - # https://www.pygame.org/docs/ref/event.html - # - # JOYAXISMOTION - # JOYBALLMOTION - # JOYHATMOTION - # JOYBUTTONUP - # JOYBUTTONDOWN - # JOYDEVICEADDED - # JOYDEVICEREMOVED - # - # _joy_axis_values = {} - while self.run_loop: - for event in pygame.event.get(): - if event.type == pygame.QUIT: - self.run_loop = False - elif event.type == pygame.JOYBUTTONDOWN: - self.signals.buttonPressed.emit(event.dict["button"]) - - # TODO: add an immediate caller to handle emergency - # stop scenarios - elif event.type == pygame.JOYHATMOTION: - value = event.dict["value"] - axis_id = 0 if value[0] != 0 else 1 - direction = value[axis_id] - self.signals.hatPressed.emit(axis_id, direction) - - elif event.type == pygame.JOYAXISMOTION: - jaxis = event.dict["axis"] - value = event.dict["value"] - - if np.abs(value) <= self.axis_dead_zone: - continue - - value2 = self.joystick.get_axis(jaxis) - if np.abs(value2) - np.abs(value) < -0.01: - # joystick is moving back towards the neutral position - value = 0.0 - - self.signals.axisMoved.emit(jaxis, value) - - # self.logger.info( - # f"PyGame event {event.type} - Data = {event.dict}." - # ) - - clock.tick(20) - - self.logger.info("PyGame loop ended.") - self.run_shutdown() - - @Slot() - def run_shutdown(self): - self.signals.stopMovement.emit() - - if self.run_loop: - self.quit() - self.signals.shutdownLoop.emit() - return - - try: - pygame.quit() - except pygame.error as err: - self.logger.warning( - "The pygame event loop did not safely shut down and was " - "forced to shut down.", - exc_info=err, - ) - - self.signals.joystickConnected.emit(self.run_loop) - - @property - def axis_dead_zone(self) -> float: - return self._axis_dead_zone - - @axis_dead_zone.setter - def axis_dead_zone(self, value: float) -> None: - try: - value = float(value) - except TypeError: - return - - if -1.0 >= value >= 1.0: - self._axis_dead_zone = np.absolute(value) - - @property - def joystick(self) -> pygame.joystick.JoystickType: - return self._joystick - - @property - def logger(self) -> logging.Logger: - return self._logger - - @property - def run_loop(self) -> bool: - return self._run_loop - - @run_loop.setter - def run_loop(self, value: bool) -> None: - if isinstance(value, bool): - self._run_loop = value - - def set_immediate_handler(self, func, event_type): ... - - def quit(self) -> None: - if pygame.get_init(): - pygame.joystick.quit() - pygame.event.clear() - pygame.event.post(pygame.event.Event(pygame.QUIT)) - self.run_loop = False - - self.signals.joystickConnected.emit(self.run_loop) - - class AxisControlWidget(QWidget): axisLinked = Signal() axisUnlinked = Signal() diff --git a/bapsf_motion/gui/configure/pygame_.py b/bapsf_motion/gui/configure/pygame_.py new file mode 100644 index 00000000..7c7b9cb5 --- /dev/null +++ b/bapsf_motion/gui/configure/pygame_.py @@ -0,0 +1,180 @@ +import logging +import numpy as np +import os + +# ensure joystick events are monitored when the pygame window +# is not in focus ... this needs to be done before importing pygame +os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" + +import pygame # noqa + +from PySide6.QtCore import ( + QObject, + QRunnable, + Signal, + Slot, +) + +from bapsf_motion.gui.configure.helpers import gui_logger + + +class PyGameJoystickRunnerSignals(QObject): + buttonPressed = Signal(int) + hatPressed = Signal(int, int) + axisMoved = Signal(int, float) + joystickConnected = Signal(bool) + shutdownLoop = Signal() + stopMovement = Signal() + + +class PyGameJoystickRunner(QRunnable): + # signals must be patterned in separate class, otherwise we can not + # connect the signals in out __init__ + signals = PyGameJoystickRunnerSignals() + + def __init__(self, joystick: pygame.joystick.JoystickType): + super().__init__() + + self._logger = gui_logger + self._axis_dead_zone = 0.25 + self._run_loop = False + + # Re-instantiate the joystick since the given joystick was probably + # instantiated in a different thread. + self._joystick = joystick + + self.signals.shutdownLoop.connect(self.run_shutdown) + + def run(self) -> None: + self.logger.info("Starting PyGame Joystick runner") + + if not pygame.get_init(): + pygame.init() + + if not pygame.joystick.get_init(): + pygame.joystick.init() + + js = self.joystick + if not isinstance(self.joystick, pygame.joystick.JoystickType): + pygame.quit() + return + + js.init() + self.run_loop = js.get_init() + self.signals.joystickConnected.emit(self.run_loop) + + clock = pygame.time.Clock() + screen = pygame.display.set_mode((100, 100), flags=pygame.HIDDEN) + + # pygame while loop + # - joystick events + # https://www.pygame.org/docs/ref/event.html + # + # JOYAXISMOTION + # JOYBALLMOTION + # JOYHATMOTION + # JOYBUTTONUP + # JOYBUTTONDOWN + # JOYDEVICEADDED + # JOYDEVICEREMOVED + # + # _joy_axis_values = {} + while self.run_loop: + for event in pygame.event.get(): + if event.type == pygame.QUIT: + self.run_loop = False + elif event.type == pygame.JOYBUTTONDOWN: + self.signals.buttonPressed.emit(event.dict["button"]) + + # TODO: add an immediate caller to handle emergency + # stop scenarios + elif event.type == pygame.JOYHATMOTION: + value = event.dict["value"] + axis_id = 0 if value[0] != 0 else 1 + direction = value[axis_id] + self.signals.hatPressed.emit(axis_id, direction) + + elif event.type == pygame.JOYAXISMOTION: + jaxis = event.dict["axis"] + value = event.dict["value"] + + if np.abs(value) <= self.axis_dead_zone: + continue + + value2 = self.joystick.get_axis(jaxis) + if np.abs(value2) - np.abs(value) < -0.01: + # joystick is moving back towards the neutral position + value = 0.0 + + self.signals.axisMoved.emit(jaxis, value) + + # self.logger.info( + # f"PyGame event {event.type} - Data = {event.dict}." + # ) + + clock.tick(20) + + self.logger.info("PyGame loop ended.") + self.run_shutdown() + + @Slot() + def run_shutdown(self): + self.signals.stopMovement.emit() + + if self.run_loop: + self.quit() + self.signals.shutdownLoop.emit() + return + + try: + pygame.quit() + except pygame.error as err: + self.logger.warning( + "The pygame event loop did not safely shut down and was " + "forced to shut down.", + exc_info=err, + ) + + self.signals.joystickConnected.emit(self.run_loop) + + @property + def axis_dead_zone(self) -> float: + return self._axis_dead_zone + + @axis_dead_zone.setter + def axis_dead_zone(self, value: float) -> None: + try: + value = float(value) + except TypeError: + return + + if -1.0 >= value >= 1.0: + self._axis_dead_zone = np.absolute(value) + + @property + def joystick(self) -> pygame.joystick.JoystickType: + return self._joystick + + @property + def logger(self) -> logging.Logger: + return self._logger + + @property + def run_loop(self) -> bool: + return self._run_loop + + @run_loop.setter + def run_loop(self, value: bool) -> None: + if isinstance(value, bool): + self._run_loop = value + + def set_immediate_handler(self, func, event_type): ... + + def quit(self) -> None: + if pygame.get_init(): + pygame.joystick.quit() + pygame.event.clear() + pygame.event.post(pygame.event.Event(pygame.QUIT)) + self.run_loop = False + + self.signals.joystickConnected.emit(self.run_loop) From b534c2253a5a4689b79f680660c87e3e4afd537b Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:03:30 -0700 Subject: [PATCH 103/177] add docstring --- bapsf_motion/gui/configure/pygame_.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/bapsf_motion/gui/configure/pygame_.py b/bapsf_motion/gui/configure/pygame_.py index 7c7b9cb5..df16174b 100644 --- a/bapsf_motion/gui/configure/pygame_.py +++ b/bapsf_motion/gui/configure/pygame_.py @@ -1,3 +1,8 @@ +""" +Module contains functionality related to interfacing with `pygame-ce` +joysticks. +""" + import logging import numpy as np import os From 3fa100063d0c63f383b09547b0fc8c063f48f2a3 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:07:27 -0700 Subject: [PATCH 104/177] move MSpaceMessageBox to bapsf_motion.gui.configure.message_boxes --- bapsf_motion/gui/configure/message_boxes.py | 76 ++++++++++++++++++- .../gui/configure/motion_group_widget.py | 70 +---------------- 2 files changed, 75 insertions(+), 71 deletions(-) diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py index 25728965..c32d0aa1 100644 --- a/bapsf_motion/gui/configure/message_boxes.py +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -1,8 +1,12 @@ -__all__ = ["WarningMessageBox"] +__all__ = [ + "WarningMessageBox", + "MSpaceMessageBox", +] from pathlib import Path +from PySide6.QtCore import Qt, Slot from PySide6.QtGui import QIcon -from PySide6.QtWidgets import QDialog, QMessageBox, QWidget +from PySide6.QtWidgets import QDialog, QMessageBox, QWidget, QCheckBox from typing import Union _HERE = Path(__file__).parent @@ -102,3 +106,71 @@ def exec(self, /) -> int: return self._acknowledge_exec() return self._approve_exec() + + +class MSpaceMessageBox(QMessageBox): + """ + Modal warning dialog box to warn the user the motion space has yet + to be defined. Thus, there are no restrictions on probe drive + movement, and it is up to the user to prevent any collisions. + """ + + def __init__(self, parent: QWidget): + super().__init__(parent) + + self._display_dialog = True + + self.setWindowTitle("Motion Space NOT Defined") + self.setText( + "Motion Space is NOT defined, so there are no restrictions " + "on probe drive motion. It is up to the user to avoid " + "collisions.\n\n" + "Proceed with movement?" + ) + self.setIcon(QMessageBox.Icon.Warning) + self.setStandardButtons( + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Abort + ) + self.setDefaultButton(QMessageBox.StandardButton.Abort) + + _cb = QCheckBox("Suppress future warnings for this motion group.") + self.setCheckBox(_cb) + + self.checkBox().checkStateChanged.connect(self._update_display_dialog) + + @property + def display_dialog(self) -> bool: + return self._display_dialog + + @display_dialog.setter + def display_dialog(self, value: bool) -> None: + if not isinstance(value, bool): + return + + # ensure the display boolean (display_dialog) is in sync + # with the dialog check box ... these two values are supposed + # to be NOTs of each other + check_state = self.checkBox().checkState() + if check_state is Qt.CheckState.Checked is value: + self.checkBox().setChecked(not value) + + self._display_dialog = value + + @Slot(Qt.CheckState) + def _update_display_dialog(self, state: Qt.CheckState) -> None: + self.display_dialog = not (state is Qt.CheckState.Checked) + + def exec(self) -> bool: + if not self.display_dialog: + return True + + button = super().exec() + + if button == QMessageBox.StandardButton.Yes: + # Make sure the Abort button always remains the default choice + self.setDefaultButton(QMessageBox.StandardButton.Abort) + return True + elif button == QMessageBox.StandardButton.Abort: + return False + + return False diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index d83acce5..9db4620d 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -50,7 +50,7 @@ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger -from bapsf_motion.gui.configure.message_boxes import WarningMessageBox +from bapsf_motion.gui.configure.message_boxes import WarningMessageBox, MSpaceMessageBox from bapsf_motion.gui.configure.motion_builder_overlay import MotionBuilderConfigOverlay from bapsf_motion.gui.configure.motion_space_display import MotionSpaceDisplay from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner @@ -80,74 +80,6 @@ import qtawesome as qta # noqa -class MSpaceMessageBox(QMessageBox): - """ - Modal warning dialog box to warn the user the motion space has yet - to be defined. Thus, there are no restrictions on probe drive - movement, and it is up to the user to prevent any collisions. - """ - - def __init__(self, parent: QWidget): - super().__init__(parent) - - self._display_dialog = True - - self.setWindowTitle("Motion Space NOT Defined") - self.setText( - "Motion Space is NOT defined, so there are no restrictions " - "on probe drive motion. It is up to the user to avoid " - "collisions.\n\n" - "Proceed with movement?" - ) - self.setIcon(QMessageBox.Icon.Warning) - self.setStandardButtons( - QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Abort - ) - self.setDefaultButton(QMessageBox.StandardButton.Abort) - - _cb = QCheckBox("Suppress future warnings for this motion group.") - self.setCheckBox(_cb) - - self.checkBox().checkStateChanged.connect(self._update_display_dialog) - - @property - def display_dialog(self) -> bool: - return self._display_dialog - - @display_dialog.setter - def display_dialog(self, value: bool) -> None: - if not isinstance(value, bool): - return - - # ensure the display boolean (display_dialog) is in sync - # with the dialog check box ... these two values are supposed - # to be NOTs of each other - check_state = self.checkBox().checkState() - if check_state is Qt.CheckState.Checked is value: - self.checkBox().setChecked(not value) - - self._display_dialog = value - - @Slot(Qt.CheckState) - def _update_display_dialog(self, state: Qt.CheckState) -> None: - self.display_dialog = not (state is Qt.CheckState.Checked) - - def exec(self) -> bool: - if not self.display_dialog: - return True - - button = super().exec() - - if button == QMessageBox.StandardButton.Yes: - # Make sure the Abort button always remains the default choice - self.setDefaultButton(QMessageBox.StandardButton.Abort) - return True - elif button == QMessageBox.StandardButton.Abort: - return False - - return False - - class LostConnectionMessageBox(QMessageBox): """ Modal warning dialog box to warn the user that the TCP connection From 193b851e9b4ee972f83383906a005b2b6a550447 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:10:08 -0700 Subject: [PATCH 105/177] move LostConnectionMessageBox to bapsf_motion.gui.configure.message_boxes --- bapsf_motion/gui/configure/message_boxes.py | 82 +++++++++++++++++- .../gui/configure/motion_group_widget.py | 85 ++----------------- 2 files changed, 86 insertions(+), 81 deletions(-) diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py index c32d0aa1..20e1131d 100644 --- a/bapsf_motion/gui/configure/message_boxes.py +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -1,6 +1,7 @@ __all__ = [ - "WarningMessageBox", + "LostConnectionMessageBox", "MSpaceMessageBox", + "WarningMessageBox", ] from pathlib import Path @@ -108,6 +109,85 @@ def exec(self, /) -> int: return self._approve_exec() +class LostConnectionMessageBox(QMessageBox): + """ + Modal warning dialog box to warn the user that the TCP connection + to a physical motor was lost. + """ + + def __init__(self, parent: QWidget): + super().__init__(parent) + + self._display_dialog = True + + self.setWindowTitle("Lost TCP Connection to Motor") + self._base_message = "Lost TCP connection to physical motor." + self._lost_motors = {} + font = self.font() + font.setPointSize(14) + self.setFont(font) + self.setText(self._base_message) + + self.setIcon(QMessageBox.Icon.Warning) + self.setStandardButtons(QMessageBox.StandardButton.Discard) + self.setDefaultButton(QMessageBox.StandardButton.Discard) + + @property + def display_dialog(self) -> bool: + return self._display_dialog + + @display_dialog.setter + def display_dialog(self, value: bool) -> None: + if not isinstance(value, bool): + return + + self._display_dialog = value + + def _update_display_dialog(self) -> None: + if len(self._lost_motors) == 0: + self.setText(self._base_message) + + if self.isVisible(): + self.defaultButton().click() + return None + + msg = self._base_message + "\n\n" + for name, ip in self._lost_motors.items(): + msg += f" {name} : {ip}\n" + + self.setText(msg) + + if not self.isVisible(): + self.exec() + + return None + + def register_lost_motor(self, name: str, ip: str) -> None: + if name in self._lost_motors: + return + + self._lost_motors[name] = ip + self._update_display_dialog() + + def register_resolved_motor(self, name): + if name not in self._lost_motors: + return + + self._lost_motors.pop(name) + self._update_display_dialog() + + def exec(self) -> bool: + if not self.display_dialog: + return True + + if not self.isEnabled(): + return True + + super().exec() + + return True + + class MSpaceMessageBox(QMessageBox): """ Modal warning dialog box to warn the user the motion space has yet diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 9db4620d..bbc31b00 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -50,7 +50,11 @@ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger -from bapsf_motion.gui.configure.message_boxes import WarningMessageBox, MSpaceMessageBox +from bapsf_motion.gui.configure.message_boxes import ( + LostConnectionMessageBox, + MSpaceMessageBox, + WarningMessageBox, +) from bapsf_motion.gui.configure.motion_builder_overlay import MotionBuilderConfigOverlay from bapsf_motion.gui.configure.motion_space_display import MotionSpaceDisplay from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner @@ -80,85 +84,6 @@ import qtawesome as qta # noqa -class LostConnectionMessageBox(QMessageBox): - """ - Modal warning dialog box to warn the user that the TCP connection - to a physical motor was lost. - """ - - def __init__(self, parent: QWidget): - super().__init__(parent) - - self._display_dialog = True - - self.setWindowTitle("Lost TCP Connection to Motor") - self._base_message = "Lost TCP connection to physical motor." - self._lost_motors = {} - font = self.font() - font.setPointSize(14) - self.setFont(font) - self.setText(self._base_message) - - self.setIcon(QMessageBox.Icon.Warning) - self.setStandardButtons(QMessageBox.StandardButton.Discard) - self.setDefaultButton(QMessageBox.StandardButton.Discard) - - @property - def display_dialog(self) -> bool: - return self._display_dialog - - @display_dialog.setter - def display_dialog(self, value: bool) -> None: - if not isinstance(value, bool): - return - - self._display_dialog = value - - def _update_display_dialog(self) -> None: - if len(self._lost_motors) == 0: - self.setText(self._base_message) - - if self.isVisible(): - self.defaultButton().click() - return None - - msg = self._base_message + "\n\n" - for name, ip in self._lost_motors.items(): - msg += f" {name} : {ip}\n" - - self.setText(msg) - - if not self.isVisible(): - self.exec() - - return None - - def register_lost_motor(self, name: str, ip: str) -> None: - if name in self._lost_motors: - return - - self._lost_motors[name] = ip - self._update_display_dialog() - - def register_resolved_motor(self, name): - if name not in self._lost_motors: - return - - self._lost_motors.pop(name) - self._update_display_dialog() - - def exec(self) -> bool: - if not self.display_dialog: - return True - - if not self.isEnabled(): - return True - - super().exec() - - return True - - class AxisControlWidget(QWidget): axisLinked = Signal() axisUnlinked = Signal() From 3b48ce55ad857605d0b64d57f696a0c045234315 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:11:49 -0700 Subject: [PATCH 106/177] add docstring --- bapsf_motion/gui/configure/message_boxes.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py index 20e1131d..7c405708 100644 --- a/bapsf_motion/gui/configure/message_boxes.py +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -1,3 +1,7 @@ +""" +Module containg custom `QDialog` and `QMessageBox` classes. +""" + __all__ = [ "LostConnectionMessageBox", "MSpaceMessageBox", From fe269d52043d0f8cb92cc139338802652dc022f0 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:27:20 -0700 Subject: [PATCH 107/177] move AxisControlWidget to bapsf_motion.gui.configure.controllers --- bapsf_motion/gui/configure/controllers.py | 672 ++++++++++++++++++ .../gui/configure/motion_group_widget.py | 644 +---------------- 2 files changed, 673 insertions(+), 643 deletions(-) create mode 100644 bapsf_motion/gui/configure/controllers.py diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py new file mode 100644 index 00000000..4fcaf0ad --- /dev/null +++ b/bapsf_motion/gui/configure/controllers.py @@ -0,0 +1,672 @@ + + +import logging +import numpy as np + +from PySide6.QtCore import Signal, QTimer, Qt, Slot +from PySide6.QtGui import QDoubleValidator +from PySide6.QtWidgets import ( + QWidget, + QLabel, + QLineEdit, + QVBoxLayout, + QHBoxLayout, + QGridLayout, +) + +from bapsf_motion.actors import MotionGroup, Drive, Axis, Motor +from bapsf_motion.gui.configure.helpers import gui_logger +from bapsf_motion.gui.configure.message_boxes import LostConnectionMessageBox +from bapsf_motion.gui.icons import icon_name_dict +from bapsf_motion.gui.widgets import ( + EnableIndicator, + IconButton, + ValidButton, + StyleButton, + ZeroButton, + HLinePlain, +) +from bapsf_motion.utils import units as u + + +class AxisControlWidget(QWidget): + axisLinked = Signal() + axisUnlinked = Signal() + movementStarted = Signal(int) + movementStopped = Signal(int) + axisStatusChanged = Signal() + targetPositionChanged = Signal(float) + lostConnection = Signal() + establishedConnection = Signal() + + def __init__( + self, + axis_display_mode="interactive", + parent=None, + ): + super().__init__(parent) + + self._logger = gui_logger + + self._mg = None + self._axis_index = None + + self._update_display_interval = 250 # in msec + self._update_display_timer = QTimer() + self._update_display_timer.setSingleShot(True) + self._display_timer_issue_new_single_shot = False + + if axis_display_mode not in ("interactive", "readonly"): + self._logger.info( + f"Forcing display mode of {self.__class__.__name__} to be" + f" interactive." + ) + axis_display_mode = "interactive" + self._interactive_display_mode = ( + True if axis_display_mode == "interactive" else False + ) + + self.setFixedWidth(120) + + # Define BUTTONS + _btn = IconButton(icon_name_dict["arrow-up"], parent=self) + _btn.setIconSize(42) + self.jog_forward_btn = _btn + + _btn = IconButton(icon_name_dict["arrow-down"], parent=self) + _btn.setIconSize(42) + self.jog_backward_btn = _btn + + _btn = ValidButton("FWD LIMIT", parent=self) + _btn.update_style_sheet( + {"background-color": "rgb(255, 95, 95)"}, + action="checked", + ) + self.limit_fwd_btn = _btn + + _btn = ValidButton("BWD LIMIT", parent=self) + _btn.update_style_sheet( + {"background-color": "rgb(255, 95, 95)"}, + action="checked", + ) + self.limit_bwd_btn = _btn + + _btn = StyleButton("HOME", parent=self) + _btn.setEnabled(False) + self.home_btn = _btn + self.home_btn.setHidden(True) + + _btn = ZeroButton("ZERO", parent=self) + self.zero_btn = _btn + + _btn = EnableIndicator(parent=self) + font = self.font() + font.setPointSize(8) + font.setBold(True) + _btn.setFont(font) + _btn.setFixedHeight(24) + _btn.setFixedWidth(70) + self.enable_btn = _btn + + # Define TEXT WIDGETS + _txt = QLabel("Name", parent=self) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setFixedHeight(18) + self.axis_name_label = _txt + + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setReadOnly(True) + _txt.setToolTip("Motor Position") + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + self.position_label = _txt + + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setReadOnly(True) + _txt.setToolTip( + "Encoder read position.\n\n If different than motor position, " + "then the motor is likely slipping / stalling." + ) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + self.encoder_label = _txt + + _txt = QLabel("E", parent=self) + _txt.setObjectName("encoder_icon") + _txt.setStyleSheet(""" + QLabel#encoder_icon { + color: grey; + padding: 2px; + } + """) + font = _txt.font() + font.setPointSize(8) + font.setBold(True) + _txt.setFont(font) + _txt.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction) + self.encoder_label_icon = _txt + + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setValidator(QDoubleValidator(decimals=2)) + self.target_position_label = _txt + + _txt = QLineEdit("0", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setValidator(QDoubleValidator(decimals=2)) + self.jog_delta_label = _txt + + # Define ADVANCED WIDGETS + + self.mspace_warning_dialog = None + if hasattr(parent, "mspace_warning_dialog"): + self.mspace_warning_dialog = parent.mspace_warning_dialog + + self.lost_connection_dialog = None # type: LostConnectionMessageBox | None + if hasattr(parent, "lost_connection_dialog"): + self.lost_connection_dialog = parent.lost_connection_dialog + + self.setLayout(self._define_layout()) + self._connect_signals() + + def _connect_signals(self): + # Note: Connecting/disconnecting of SimpleSignals happens in + # the link_axis and unlink_axis methods respectively + # + self._update_display_timer.timeout.connect(self._update_display_of_axis_status) + + self.limit_fwd_btn.clicked.connect(self._move_off_limit) + self.limit_bwd_btn.clicked.connect(self._move_off_limit) + + self.jog_forward_btn.clicked.connect(self.jog_forward) + self.jog_backward_btn.clicked.connect(self.jog_backward) + self.zero_btn.clicked.connect(self._zero_axis) + self.jog_delta_label.editingFinished.connect(self._validate_jog_value) + self.target_position_label.editingFinished.connect( + self._validate_target_position_value + ) + self.enable_btn.clicked.connect(self._set_motor_enabled_state) + self.movementStopped.connect(self._disable_motor) + self.movementStopped.connect(self._update_display_of_axis_status) + + self.establishedConnection.connect(self._handle_connection_established) + self.lostConnection.connect(self._handle_connection_lost) + + def _define_layout(self): + layout = QVBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.setSpacing(8) + + if self.interactive_display_mode: + layout = self._define_interactive_layout(layout) + else: + layout = self._define_readonly_layout() + + return layout + + def _define_interactive_layout(self, layout: QVBoxLayout = None): + if layout is None: + layout = QVBoxLayout() + + layout.addLayout(self._define_title_and_enable_btn_layout()) + layout.addWidget( + self.position_label, + alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, + ) + layout.addLayout(self._define_encoder_label_layout()) + layout.addWidget(HLinePlain(parent=self)) + layout.addWidget( + self.target_position_label, + alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, + ) + layout.addWidget(self.limit_fwd_btn, alignment=Qt.AlignmentFlag.AlignTop) + layout.addWidget(self.jog_forward_btn) + layout.addStretch(1) + layout.addWidget(self.jog_delta_label) + layout.addWidget(self.home_btn) + layout.addStretch(1) + layout.addWidget(self.jog_backward_btn, alignment=Qt.AlignmentFlag.AlignBottom) + layout.addWidget(self.limit_bwd_btn, alignment=Qt.AlignmentFlag.AlignBottom) + layout.addWidget(self.zero_btn, alignment=Qt.AlignmentFlag.AlignBottom) + layout.addStretch(1) + + return layout + + def _define_readonly_layout(self, layout: QVBoxLayout = None): + if layout is None: + layout = QVBoxLayout() + + self.target_position_label.setEnabled(False) + self.target_position_label.setVisible(False) + + self.jog_forward_btn.setEnabled(False) + self.jog_forward_btn.setVisible(False) + + self.jog_backward_btn.setEnabled(False) + self.jog_backward_btn.setVisible(False) + + self.home_btn.setEnabled(False) + self.home_btn.setVisible(False) + + self.zero_btn.setEnabled(False) + self.zero_btn.setVisible(False) + + self.limit_fwd_btn.setFixedHeight(24) + self.limit_bwd_btn.setFixedHeight(24) + + self.jog_delta_label.setText("0.1") + + _fine_step_label = QLabel("Fine Step", parent=self) + _font = _fine_step_label.font() + _font.setPointSize(12) + _fine_step_label.setFont(_font) + + layout.addLayout(self._define_title_and_enable_btn_layout()) + layout.addSpacing(4) + layout.addWidget(self.limit_fwd_btn, alignment=Qt.AlignmentFlag.AlignTop) + layout.addSpacing(8) + layout.addWidget( + self.position_label, + alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, + ) + layout.addLayout(self._define_encoder_label_layout()) + layout.addSpacing(8) + layout.addWidget(self.limit_bwd_btn, alignment=Qt.AlignmentFlag.AlignBottom) + layout.addSpacing(24) + layout.addWidget( + _fine_step_label, + alignment=Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignBaseline, + ) + layout.addWidget(self.jog_delta_label) + layout.addStretch(1) + + return layout + + def _define_title_and_enable_btn_layout(self): + layout = QHBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addStretch(1) + layout.addWidget(self.axis_name_label) + layout.addSpacing(2) + layout.addWidget(self.enable_btn) + layout.addStretch(1) + + return layout + + def _define_encoder_label_layout(self): + layout = QGridLayout() + layout.setContentsMargins(0, 0, 0, 0) + + layout.addWidget( + self.encoder_label, + 0, + 0, + 5, + 8, + alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, + ) + layout.addWidget( + self.encoder_label_icon, + 4, + 7, + 1, + 1, + alignment=Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight, + ) + + return layout + + @property + def logger(self) -> logging.Logger: + return self._logger + + @property + def mg(self) -> MotionGroup | None: + return self._mg + + @property + def axis_index(self) -> int: + return self._axis_index + + @property + def axis(self) -> Axis | None: + if self.mg is None or self.axis_index is None: + return None + + return self.mg.drive.axes[self.axis_index] + + @property + def encoder(self) -> u.Quantity: + encoder = self.mg.encoder + val = encoder.value[self.axis_index] + unit = encoder.unit + return val * unit + + @property + def position(self) -> u.Quantity: + position = self.mg.position + val = position.value[self.axis_index] + unit = position.unit + return val * unit + + @property + def target_position(self) -> float | int | None: + try: + pos = float(self.target_position_label.text()) + except ValueError: + pos = None + return pos + + @property + def interactive_display_mode(self): + return self._interactive_display_mode + + def _get_jog_delta(self): + delta_str = self.jog_delta_label.text() + return float(delta_str) + + @Slot() + def jog_forward(self): + pos = self.position.value + self._get_jog_delta() + self._move_to(pos) + + @Slot() + def jog_backward(self): + pos = self.position.value - self._get_jog_delta() + self._move_to(pos) + + def update_encoder_display(self, position: u.Quantity | float | int): + if not isinstance(position, (u.Quantity, float)): + return + elif isinstance(position, u.Quantity): + _txt = f"{position.value:.2f} {position.unit}" + else: + _txt = f"{position:.2f}" + + self.encoder_label.setText(_txt) + + def update_position_display(self, position: u.Quantity | float | int): + if not isinstance(position, (u.Quantity, float)): + return + elif isinstance(position, u.Quantity): + _txt = f"{position.value:.2f} {position.unit}" + else: + _txt = f"{position:.2f}" + + self.position_label.setText(_txt) + + def update_target_position_display(self, position): + if not isinstance(position, (u.Quantity, float)): + return + elif isinstance(position, u.Quantity): + _txt = f"{position.value:.2f}" + else: + _txt = f"{position:.2f}" + + self.target_position_label.setText(_txt) + + @Slot() + def _disable_motor(self): + self.axis.send_command("disable") + + @Slot() + def _move_off_limit(self): + axis = self.axis + if axis is None: + return + + axis.motor.move_off_limit() + + def _move_to(self, target_ax_pos): + target_pos = self.mg.position.value + target_pos[self.axis_index] = target_ax_pos + + if self.mg.drive.is_moving: + self.logger.info( + "Probe drive is currently moving. Did NOT perform move " + f"to {target_pos}." + ) + return + + try: + proceed = self.mspace_warning_dialog.exec() + except AttributeError: + proceed = False + + if proceed: + self.mg.move_to(target_pos) + + @Slot() + def _set_motor_enabled_state(self): + current_enabled_state = self.axis.motor.status["enabled"] + cmd_string = "disable" if current_enabled_state else "enable" + self.axis.send_command(cmd_string) + + @Slot() + def update_display_of_axis_status(self): + timer_active = self._update_display_timer.isActive() + if timer_active: + self._display_timer_issue_new_single_shot = True + else: + self._update_display_of_axis_status() + + # start a timed update to start update frequency control + self._update_display_timer.start(self._update_display_interval) + self._display_timer_issue_new_single_shot = False + + @Slot() + def _update_display_of_axis_status(self): + if self._mg.terminated: + self.setEnabled(False) + return + + self.setEnabled(self.axis.connected) + if not self.isEnabled(): + return + + pos = self.position + self.update_position_display(pos) + if self.target_position_label.text() == "": + self.update_target_position_display(pos) + + encoder = self.encoder + self.update_encoder_display(encoder) + + if np.isclose(pos.value, encoder.value, rtol=0.0, atol=0.02): + # encoder and absolute readingss are conssistent + self.position_label.setStyleSheet("color: black;") + self.encoder_label.setStyleSheet("color: black;") + else: + self.position_label.setStyleSheet("color: red;") + self.encoder_label.setStyleSheet("color: red;") + + _motor_status = self.axis.motor.status + + limits = _motor_status["limits"] + self.limit_fwd_btn.set_valid(state=limits["CW"]) + self.limit_bwd_btn.set_valid(state=limits["CCW"]) + + enabled_state = _motor_status["enabled"] + self.enable_btn.setChecked(enabled_state) + + if self._display_timer_issue_new_single_shot: + # start another single shot if update_display_of_axis_status() + # was triggered during the wait for the last single shot + self._update_display_timer.start(self._update_display_interval) + self._display_timer_issue_new_single_shot = False + + @Slot() + def _validate_jog_value(self): + _txt = self.jog_delta_label.text() + val = 0.0 if _txt == "" else float(_txt) + val = abs(val) + self.jog_delta_label.setText(f"{val:.2f}") + + @Slot() + def _validate_target_position_value(self): + self.targetPositionChanged.emit(self.target_position) + + @Slot() + def _zero_axis(self): + self.logger.info(f"Setting zero of axis {self.axis_index}") + self.mg.set_zero(axis=self.axis_index) + + def link_axis(self, mg: MotionGroup, ax_index: int): + if ( + not isinstance(ax_index, int) + or ax_index < 0 + or ax_index >= len(mg.drive.axes) + ): + self.unlink_axis() + return + + axis = mg.drive.axes[ax_index] + if self.axis is not None and self.axis is axis: + pass + else: + self.unlink_axis() + + self._mg = mg + self._axis_index = ax_index + + self.axis_name_label.setText(self.axis.name) + + # connect motor SimpleSignals + self.axis.motor.signals.connection_established.connect( + self._emit_connection_established + ) + self.axis.motor.signals.connection_lost.connect(self._emit_connection_lost) + self.axis.motor.signals.status_changed.connect(self.update_display_of_axis_status) + self.axis.motor.signals.status_changed.connect(self.axisStatusChanged.emit) + self.axis.motor.signals.movement_started.connect(self._emit_movement_started) + self.axis.motor.signals.movement_finished.connect(self._emit_movement_finished) + self.axis.motor.signals.movement_finished.connect( + self.update_display_of_axis_status + ) + + self.update_display_of_axis_status() + self.axisLinked.emit() + + def unlink_axis(self): + if self.axis is not None: + # disconnect all motor SimpleSignals + self.axis.motor.signals.connection_established.disconnect( + self._emit_connection_established + ) + self.axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) + self.axis.motor.signals.status_changed.disconnect( + self.update_display_of_axis_status + ) + self.axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) + self.axis.motor.signals.movement_started.disconnect( + self._emit_movement_started + ) + self.axis.motor.signals.movement_finished.disconnect( + self._emit_movement_finished + ) + self.axis.motor.signals.movement_finished.disconnect( + self.update_display_of_axis_status + ) + + self._mg = None + self._axis_index = None + self.axisUnlinked.emit() + + @Slot() + def _emit_connection_established(self): + self.establishedConnection.emit() + + @Slot() + def _emit_connection_lost(self): + self.lostConnection.emit() + + @Slot() + def _handle_connection_lost(self): + # Note: This slot needs to be trigger from a PySide6 signal and + # not from any of the SimpleSignals attached to Motor. + # Having the SimpleSignal execute this code risks the + # execution of an unsafe thread operation. The Motor + # event-loop is executing in a different thread that is + # unmanaged by PySide6. + if self.lost_connection_dialog is None: + return None + + self.lost_connection_dialog.register_lost_motor( + self.axis.name, + self.axis.motor.ip, + ) + self.setEnabled(False) + + @Slot() + def _handle_connection_established(self): + # Note: This slot needs to be trigger from a PySide6 signal and + # not from any of the SimpleSignals attached to Motor. + # Having the SimpleSignal execute this code risks the + # execution of an unsafe thread operation. The Motor + # event-loop is executing in a different thread that is + # unmanaged by PySide6. + if self.lost_connection_dialog is None: + return None + + self.lost_connection_dialog.register_resolved_motor(self.axis.name) + + self.setEnabled(True) + self.update_display_of_axis_status() + self.axisStatusChanged.emit() + + @Slot() + def _emit_movement_started(self): + self.movementStarted.emit(self.axis_index) + + @Slot() + def _emit_movement_finished(self): + self.movementStopped.emit(self.axis_index) + + def enable_motion_buttons(self): + self.zero_btn.setEnabled(True) + self.jog_forward_btn.setEnabled(True) + self.jog_backward_btn.setEnabled(True) + self.enable_btn.setEnabled(True) + + def disable_motion_buttons(self): + self.zero_btn.setEnabled(False) + self.jog_forward_btn.setEnabled(False) + self.jog_backward_btn.setEnabled(False) + self.enable_btn.setEnabled(False) + + def closeEvent(self, event): + self.logger.info("Closing AxisControlWidget") + + if isinstance(self.axis, Axis): + self.axis.motor.signals.connection_established.disconnect( + self._emit_connection_established + ) + self.axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) + self.axis.motor.signals.status_changed.disconnect( + self.update_display_of_axis_status + ) + self.axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) + self.axis.motor.signals.movement_started.disconnect( + self._emit_movement_started + ) + self.axis.motor.signals.movement_finished.disconnect( + self._emit_movement_finished + ) + self.axis.motor.signals.movement_finished.disconnect( + self.update_display_of_axis_status + ) + + event.accept() diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index bbc31b00..df29947d 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -48,6 +48,7 @@ from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure import configure_ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget +from bapsf_motion.gui.configure.controllers import AxisControlWidget from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.gui.configure.message_boxes import ( @@ -84,649 +85,6 @@ import qtawesome as qta # noqa -class AxisControlWidget(QWidget): - axisLinked = Signal() - axisUnlinked = Signal() - movementStarted = Signal(int) - movementStopped = Signal(int) - axisStatusChanged = Signal() - targetPositionChanged = Signal(float) - lostConnection = Signal() - establishedConnection = Signal() - - def __init__( - self, - axis_display_mode="interactive", - parent=None, - ): - super().__init__(parent) - - self._logger = gui_logger - - self._mg = None - self._axis_index = None - - self._update_display_interval = 250 # in msec - self._update_display_timer = QTimer() - self._update_display_timer.setSingleShot(True) - self._display_timer_issue_new_single_shot = False - - if axis_display_mode not in ("interactive", "readonly"): - self._logger.info( - f"Forcing display mode of {self.__class__.__name__} to be" - f" interactive." - ) - axis_display_mode = "interactive" - self._interactive_display_mode = ( - True if axis_display_mode == "interactive" else False - ) - - self.setFixedWidth(120) - - # Define BUTTONS - _btn = IconButton(icon_name_dict["arrow-up"], parent=self) - _btn.setIconSize(42) - self.jog_forward_btn = _btn - - _btn = IconButton(icon_name_dict["arrow-down"], parent=self) - _btn.setIconSize(42) - self.jog_backward_btn = _btn - - _btn = ValidButton("FWD LIMIT", parent=self) - _btn.update_style_sheet( - {"background-color": "rgb(255, 95, 95)"}, - action="checked", - ) - self.limit_fwd_btn = _btn - - _btn = ValidButton("BWD LIMIT", parent=self) - _btn.update_style_sheet( - {"background-color": "rgb(255, 95, 95)"}, - action="checked", - ) - self.limit_bwd_btn = _btn - - _btn = StyleButton("HOME", parent=self) - _btn.setEnabled(False) - self.home_btn = _btn - self.home_btn.setHidden(True) - - _btn = ZeroButton("ZERO", parent=self) - self.zero_btn = _btn - - _btn = EnableIndicator(parent=self) - font = self.font() - font.setPointSize(8) - font.setBold(True) - _btn.setFont(font) - _btn.setFixedHeight(24) - _btn.setFixedWidth(70) - self.enable_btn = _btn - - # Define TEXT WIDGETS - _txt = QLabel("Name", parent=self) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setFixedHeight(18) - self.axis_name_label = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setReadOnly(True) - _txt.setToolTip("Motor Position") - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - self.position_label = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setReadOnly(True) - _txt.setToolTip( - "Encoder read position.\n\n If different than motor position, " - "then the motor is likely slipping / stalling." - ) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - self.encoder_label = _txt - - _txt = QLabel("E", parent=self) - _txt.setObjectName("encoder_icon") - _txt.setStyleSheet(""" - QLabel#encoder_icon { - color: grey; - padding: 2px; - } - """) - font = _txt.font() - font.setPointSize(8) - font.setBold(True) - _txt.setFont(font) - _txt.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction) - self.encoder_label_icon = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setValidator(QDoubleValidator(decimals=2)) - self.target_position_label = _txt - - _txt = QLineEdit("0", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setValidator(QDoubleValidator(decimals=2)) - self.jog_delta_label = _txt - - # Define ADVANCED WIDGETS - - self.mspace_warning_dialog = None - if hasattr(parent, "mspace_warning_dialog"): - self.mspace_warning_dialog = parent.mspace_warning_dialog - - self.lost_connection_dialog = None # type: Union[LostConnectionMessageBox, None] - if hasattr(parent, "lost_connection_dialog"): - self.lost_connection_dialog = parent.lost_connection_dialog - - self.setLayout(self._define_layout()) - self._connect_signals() - - def _connect_signals(self): - # Note: Connecting/disconnecting of SimpleSignals happens in - # the link_axis and unlink_axis methods respectively - # - self._update_display_timer.timeout.connect(self._update_display_of_axis_status) - - self.limit_fwd_btn.clicked.connect(self._move_off_limit) - self.limit_bwd_btn.clicked.connect(self._move_off_limit) - - self.jog_forward_btn.clicked.connect(self.jog_forward) - self.jog_backward_btn.clicked.connect(self.jog_backward) - self.zero_btn.clicked.connect(self._zero_axis) - self.jog_delta_label.editingFinished.connect(self._validate_jog_value) - self.target_position_label.editingFinished.connect( - self._validate_target_position_value - ) - self.enable_btn.clicked.connect(self._set_motor_enabled_state) - self.movementStopped.connect(self._disable_motor) - self.movementStopped.connect(self._update_display_of_axis_status) - - self.establishedConnection.connect(self._handle_connection_established) - self.lostConnection.connect(self._handle_connection_lost) - - def _define_layout(self): - layout = QVBoxLayout() - layout.setContentsMargins(0, 0, 0, 0) - layout.setSpacing(8) - - if self.interactive_display_mode: - layout = self._define_interactive_layout(layout) - else: - layout = self._define_readonly_layout() - - return layout - - def _define_interactive_layout(self, layout: QVBoxLayout = None): - if layout is None: - layout = QVBoxLayout() - - layout.addLayout(self._define_title_and_enable_btn_layout()) - layout.addWidget( - self.position_label, - alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, - ) - layout.addLayout(self._define_encoder_label_layout()) - layout.addWidget(HLinePlain(parent=self)) - layout.addWidget( - self.target_position_label, - alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, - ) - layout.addWidget(self.limit_fwd_btn, alignment=Qt.AlignmentFlag.AlignTop) - layout.addWidget(self.jog_forward_btn) - layout.addStretch(1) - layout.addWidget(self.jog_delta_label) - layout.addWidget(self.home_btn) - layout.addStretch(1) - layout.addWidget(self.jog_backward_btn, alignment=Qt.AlignmentFlag.AlignBottom) - layout.addWidget(self.limit_bwd_btn, alignment=Qt.AlignmentFlag.AlignBottom) - layout.addWidget(self.zero_btn, alignment=Qt.AlignmentFlag.AlignBottom) - layout.addStretch(1) - - return layout - - def _define_readonly_layout(self, layout: QVBoxLayout = None): - if layout is None: - layout = QVBoxLayout() - - self.target_position_label.setEnabled(False) - self.target_position_label.setVisible(False) - - self.jog_forward_btn.setEnabled(False) - self.jog_forward_btn.setVisible(False) - - self.jog_backward_btn.setEnabled(False) - self.jog_backward_btn.setVisible(False) - - self.home_btn.setEnabled(False) - self.home_btn.setVisible(False) - - self.zero_btn.setEnabled(False) - self.zero_btn.setVisible(False) - - self.limit_fwd_btn.setFixedHeight(24) - self.limit_bwd_btn.setFixedHeight(24) - - self.jog_delta_label.setText("0.1") - - _fine_step_label = QLabel("Fine Step", parent=self) - _font = _fine_step_label.font() - _font.setPointSize(12) - _fine_step_label.setFont(_font) - - layout.addLayout(self._define_title_and_enable_btn_layout()) - layout.addSpacing(4) - layout.addWidget(self.limit_fwd_btn, alignment=Qt.AlignmentFlag.AlignTop) - layout.addSpacing(8) - layout.addWidget( - self.position_label, - alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, - ) - layout.addLayout(self._define_encoder_label_layout()) - layout.addSpacing(8) - layout.addWidget(self.limit_bwd_btn, alignment=Qt.AlignmentFlag.AlignBottom) - layout.addSpacing(24) - layout.addWidget( - _fine_step_label, - alignment=Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignBaseline, - ) - layout.addWidget(self.jog_delta_label) - layout.addStretch(1) - - return layout - - def _define_title_and_enable_btn_layout(self): - layout = QHBoxLayout() - layout.setContentsMargins(0, 0, 0, 0) - layout.addStretch(1) - layout.addWidget(self.axis_name_label) - layout.addSpacing(2) - layout.addWidget(self.enable_btn) - layout.addStretch(1) - - return layout - - def _define_encoder_label_layout(self): - layout = QGridLayout() - layout.setContentsMargins(0, 0, 0, 0) - - layout.addWidget( - self.encoder_label, - 0, - 0, - 5, - 8, - alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignCenter, - ) - layout.addWidget( - self.encoder_label_icon, - 4, - 7, - 1, - 1, - alignment=Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight, - ) - - return layout - - @property - def logger(self) -> logging.Logger: - return self._logger - - @property - def mg(self) -> Union[MotionGroup, None]: - return self._mg - - @property - def axis_index(self) -> int: - return self._axis_index - - @property - def axis(self) -> Union[Axis, None]: - if self.mg is None or self.axis_index is None: - return None - - return self.mg.drive.axes[self.axis_index] - - @property - def encoder(self) -> u.Quantity: - encoder = self.mg.encoder - val = encoder.value[self.axis_index] - unit = encoder.unit - return val * unit - - @property - def position(self) -> u.Quantity: - position = self.mg.position - val = position.value[self.axis_index] - unit = position.unit - return val * unit - - @property - def target_position(self) -> Union[float, None]: - try: - pos = float(self.target_position_label.text()) - except ValueError: - pos = None - return pos - - @property - def interactive_display_mode(self): - return self._interactive_display_mode - - def _get_jog_delta(self): - delta_str = self.jog_delta_label.text() - return float(delta_str) - - @Slot() - def jog_forward(self): - pos = self.position.value + self._get_jog_delta() - self._move_to(pos) - - @Slot() - def jog_backward(self): - pos = self.position.value - self._get_jog_delta() - self._move_to(pos) - - def update_encoder_display(self, position: Union[u.Quantity, float]): - if not isinstance(position, (u.Quantity, float)): - return - elif isinstance(position, u.Quantity): - _txt = f"{position.value:.2f} {position.unit}" - else: - _txt = f"{position:.2f}" - - self.encoder_label.setText(_txt) - - def update_position_display(self, position: Union[u.Quantity, float]): - if not isinstance(position, (u.Quantity, float)): - return - elif isinstance(position, u.Quantity): - _txt = f"{position.value:.2f} {position.unit}" - else: - _txt = f"{position:.2f}" - - self.position_label.setText(_txt) - - def update_target_position_display(self, position): - if not isinstance(position, (u.Quantity, float)): - return - elif isinstance(position, u.Quantity): - _txt = f"{position.value:.2f}" - else: - _txt = f"{position:.2f}" - - self.target_position_label.setText(_txt) - - @Slot() - def _disable_motor(self): - self.axis.send_command("disable") - - @Slot() - def _move_off_limit(self): - axis = self.axis - if axis is None: - return - - axis.motor.move_off_limit() - - def _move_to(self, target_ax_pos): - target_pos = self.mg.position.value - target_pos[self.axis_index] = target_ax_pos - - if self.mg.drive.is_moving: - self.logger.info( - "Probe drive is currently moving. Did NOT perform move " - f"to {target_pos}." - ) - return - - try: - proceed = self.mspace_warning_dialog.exec() - except AttributeError: - proceed = False - - if proceed: - self.mg.move_to(target_pos) - - @Slot() - def _set_motor_enabled_state(self): - current_enabled_state = self.axis.motor.status["enabled"] - cmd_string = "disable" if current_enabled_state else "enable" - self.axis.send_command(cmd_string) - - @Slot() - def update_display_of_axis_status(self): - timer_active = self._update_display_timer.isActive() - if timer_active: - self._display_timer_issue_new_single_shot = True - else: - self._update_display_of_axis_status() - - # start a timed update to start update frequency control - self._update_display_timer.start(self._update_display_interval) - self._display_timer_issue_new_single_shot = False - - @Slot() - def _update_display_of_axis_status(self): - if self._mg.terminated: - self.setEnabled(False) - return - - self.setEnabled(self.axis.connected) - if not self.isEnabled(): - return - - pos = self.position - self.update_position_display(pos) - if self.target_position_label.text() == "": - self.update_target_position_display(pos) - - encoder = self.encoder - self.update_encoder_display(encoder) - - if np.isclose(pos.value, encoder.value, rtol=0.0, atol=0.02): - # encoder and absolute readingss are conssistent - self.position_label.setStyleSheet("color: black;") - self.encoder_label.setStyleSheet("color: black;") - else: - self.position_label.setStyleSheet("color: red;") - self.encoder_label.setStyleSheet("color: red;") - - _motor_status = self.axis.motor.status - - limits = _motor_status["limits"] - self.limit_fwd_btn.set_valid(state=limits["CW"]) - self.limit_bwd_btn.set_valid(state=limits["CCW"]) - - enabled_state = _motor_status["enabled"] - self.enable_btn.setChecked(enabled_state) - - if self._display_timer_issue_new_single_shot: - # start another single shot if update_display_of_axis_status() - # was triggered during the wait for the last single shot - self._update_display_timer.start(self._update_display_interval) - self._display_timer_issue_new_single_shot = False - - @Slot() - def _validate_jog_value(self): - _txt = self.jog_delta_label.text() - val = 0.0 if _txt == "" else float(_txt) - val = abs(val) - self.jog_delta_label.setText(f"{val:.2f}") - - @Slot() - def _validate_target_position_value(self): - self.targetPositionChanged.emit(self.target_position) - - @Slot() - def _zero_axis(self): - self.logger.info(f"Setting zero of axis {self.axis_index}") - self.mg.set_zero(axis=self.axis_index) - - def link_axis(self, mg: MotionGroup, ax_index: int): - if ( - not isinstance(ax_index, int) - or ax_index < 0 - or ax_index >= len(mg.drive.axes) - ): - self.unlink_axis() - return - - axis = mg.drive.axes[ax_index] - if self.axis is not None and self.axis is axis: - pass - else: - self.unlink_axis() - - self._mg = mg - self._axis_index = ax_index - - self.axis_name_label.setText(self.axis.name) - - # connect motor SimpleSignals - self.axis.motor.signals.connection_established.connect( - self._emit_connection_established - ) - self.axis.motor.signals.connection_lost.connect(self._emit_connection_lost) - self.axis.motor.signals.status_changed.connect(self.update_display_of_axis_status) - self.axis.motor.signals.status_changed.connect(self.axisStatusChanged.emit) - self.axis.motor.signals.movement_started.connect(self._emit_movement_started) - self.axis.motor.signals.movement_finished.connect(self._emit_movement_finished) - self.axis.motor.signals.movement_finished.connect( - self.update_display_of_axis_status - ) - - self.update_display_of_axis_status() - self.axisLinked.emit() - - def unlink_axis(self): - if self.axis is not None: - # disconnect all motor SimpleSignals - self.axis.motor.signals.connection_established.disconnect( - self._emit_connection_established - ) - self.axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) - self.axis.motor.signals.status_changed.disconnect( - self.update_display_of_axis_status - ) - self.axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) - self.axis.motor.signals.movement_started.disconnect( - self._emit_movement_started - ) - self.axis.motor.signals.movement_finished.disconnect( - self._emit_movement_finished - ) - self.axis.motor.signals.movement_finished.disconnect( - self.update_display_of_axis_status - ) - - self._mg = None - self._axis_index = None - self.axisUnlinked.emit() - - @Slot() - def _emit_connection_established(self): - self.establishedConnection.emit() - - @Slot() - def _emit_connection_lost(self): - self.lostConnection.emit() - - @Slot() - def _handle_connection_lost(self): - # Note: This slot needs to be trigger from a PySide6 signal and - # not from any of the SimpleSignals attached to Motor. - # Having the SimpleSignal execute this code risks the - # execution of an unsafe thread operation. The Motor - # event-loop is executing in a different thread that is - # unmanaged by PySide6. - if self.lost_connection_dialog is None: - return None - - self.lost_connection_dialog.register_lost_motor( - self.axis.name, - self.axis.motor.ip, - ) - self.setEnabled(False) - - @Slot() - def _handle_connection_established(self): - # Note: This slot needs to be trigger from a PySide6 signal and - # not from any of the SimpleSignals attached to Motor. - # Having the SimpleSignal execute this code risks the - # execution of an unsafe thread operation. The Motor - # event-loop is executing in a different thread that is - # unmanaged by PySide6. - if self.lost_connection_dialog is None: - return None - - self.lost_connection_dialog.register_resolved_motor(self.axis.name) - - self.setEnabled(True) - self.update_display_of_axis_status() - self.axisStatusChanged.emit() - - @Slot() - def _emit_movement_started(self): - self.movementStarted.emit(self.axis_index) - - @Slot() - def _emit_movement_finished(self): - self.movementStopped.emit(self.axis_index) - - def enable_motion_buttons(self): - self.zero_btn.setEnabled(True) - self.jog_forward_btn.setEnabled(True) - self.jog_backward_btn.setEnabled(True) - self.enable_btn.setEnabled(True) - - def disable_motion_buttons(self): - self.zero_btn.setEnabled(False) - self.jog_forward_btn.setEnabled(False) - self.jog_backward_btn.setEnabled(False) - self.enable_btn.setEnabled(False) - - def closeEvent(self, event): - self.logger.info("Closing AxisControlWidget") - - if isinstance(self.axis, Axis): - self.axis.motor.signals.connection_established.disconnect( - self._emit_connection_established - ) - self.axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) - self.axis.motor.signals.status_changed.disconnect( - self.update_display_of_axis_status - ) - self.axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) - self.axis.motor.signals.movement_started.disconnect( - self._emit_movement_started - ) - self.axis.motor.signals.movement_finished.disconnect( - self._emit_movement_finished - ) - self.axis.motor.signals.movement_finished.disconnect( - self.update_display_of_axis_status - ) - - event.accept() - - class DriveBaseController(QWidget): driveStatusChanged = Signal() movementStarted = Signal() From 60cd7d324875f7864fa8e3e50ca38a41ebf31444 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:32:44 -0700 Subject: [PATCH 108/177] move DriveBaseController to bapsf_motion.gui.configure.controllers --- bapsf_motion/gui/configure/controllers.py | 248 ++++++++++++++++++ .../gui/configure/motion_group_widget.py | 246 +---------------- 2 files changed, 249 insertions(+), 245 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 4fcaf0ad..e42c0fa8 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -2,7 +2,9 @@ import logging import numpy as np +import warnings +from abc import abstractmethod from PySide6.QtCore import Signal, QTimer, Qt, Slot from PySide6.QtGui import QDoubleValidator from PySide6.QtWidgets import ( @@ -12,7 +14,9 @@ QVBoxLayout, QHBoxLayout, QGridLayout, + QLayout, ) +from typing import List from bapsf_motion.actors import MotionGroup, Drive, Axis, Motor from bapsf_motion.gui.configure.helpers import gui_logger @@ -670,3 +674,247 @@ def closeEvent(self, event): ) event.accept() + + +class DriveBaseController(QWidget): + driveStatusChanged = Signal() + movementStarted = Signal() + movementStopped = Signal() + moveTo = Signal(list) + zeroDrive = Signal() + targetPositionChanged = Signal(list) + + def __init__(self, axis_display_mode="interactive", parent=None): + # axis_display_mode == "interactive" or "readonly" + super().__init__(parent=parent) + + self._logger = gui_logger + + self._axis_display_mode = axis_display_mode + self.mspace_warning_dialog = None + if hasattr(parent, "mspace_warning_dialog"): + self.mspace_warning_dialog = parent.mspace_warning_dialog + + self.lost_connection_dialog = None + if hasattr(parent, "lost_connection_dialog"): + self.lost_connection_dialog = parent.lost_connection_dialog + + self._mg = None + self._mspace_drive_polarity = None + + self._axis_control_widgets = [] # type: List[AxisControlWidget] + self._initialize_axis_control_widgets() + + self._initialize_widgets() + + self.setLayout(self._define_layout()) + self._connect_signals() + + @abstractmethod + def _initialize_widgets(self): ... + + def _initialize_axis_control_widgets(self): + for ii in range(4): + acw = AxisControlWidget( + axis_display_mode=self._axis_display_mode, + parent=self, + ) + visible = True if ii == 0 else False + acw.setVisible(visible) + self._axis_control_widgets.append(acw) + + def _connect_signals(self): + self.movementStarted.connect(self.disable_motion_buttons) + self.movementStopped.connect(self.enable_motion_buttons) + + for acw in self._axis_control_widgets: + acw.targetPositionChanged.connect(self._target_position_changed) + + @abstractmethod + def _define_layout(self) -> QLayout: ... + + @property + def logger(self): + return self._logger + + @property + def mg(self) -> MotionGroup | None: + return self._mg + + @property + def mspace_drive_polarity(self): + return self._mspace_drive_polarity + + @property + def position(self) -> List[float]: + position = [] + for acw in self._axis_control_widgets: + if acw.isHidden(): + continue + + position.append(acw.position.value) + + return position + + @property + def target_position(self) -> List[float] | None: + target_position = [] + for acw in self._axis_control_widgets: + if acw.isHidden(): + continue + + target_position.append(acw.target_position) + + if not bool(target_position): + # no values in target position + return None + + if any(pos is None for pos in target_position): + # some target positions are not valid + return None + + return target_position + + @Slot() + def _target_position_changed(self, position): + self.logger.info(f"DBC target position changed {self.target_position}") + tpos = self.target_position + if tpos is None: + tpos = [] + self.targetPositionChanged.emit(tpos) + + def link_motion_group(self, mg: MotionGroup): + if not isinstance(mg, MotionGroup): + self.logger.warning( + f"Expected type {MotionGroup} for motion group, but got type" + f" {type(mg)}." + ) + + if not isinstance(mg.drive, Drive): + # drive has not been set yet + self.unlink_motion_group() + return + + if ( + isinstance(self.mg, MotionGroup) + and isinstance(self.mg.drive, Drive) + and mg.drive is self.mg.drive + ): + pass + else: + self.unlink_motion_group() + self._mg = mg + + for ii, ax in enumerate(self.mg.drive.axes): + acw = self._axis_control_widgets[ii] + acw.link_axis(self.mg, ii) + acw.establishedConnection.connect(self._drive_connection_established) + acw.lostConnection.connect(self._drive_connection_lost) + acw.movementStarted.connect(self._drive_movement_started) + acw.movementStopped.connect(self._drive_movement_finished) + acw.axisStatusChanged.connect(self.update_all_axis_displays) + acw.axisStatusChanged.connect(self.driveStatusChanged.emit) + acw.show() + + self.setEnabled(not (self._mg.terminated or not self._mg.connected)) + self._determine_mspace_drive_polarity() + + def unlink_motion_group(self): + for ii, acw in enumerate(self._axis_control_widgets): + visible = True if ii == 0 else False + + acw.unlink_axis() + + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=RuntimeWarning) + acw.establishedConnection.disconnect(self._drive_connection_established) + acw.lostConnection.disconnect(self._drive_connection_lost) + acw.movementStarted.disconnect(self._drive_movement_started) + acw.movementStopped.disconnect(self._drive_movement_finished) + acw.axisStatusChanged.disconnect(self.update_all_axis_displays) + acw.axisStatusChanged.disconnect(self.driveStatusChanged.emit) + + acw.setVisible(visible) + + # self.mg.terminate(delay_loop_stop=True) + self._mg = None + self._mspace_drive_polarity = None + self.setEnabled(False) + + @Slot() + def update_all_axis_displays(self): + for acw in self._axis_control_widgets: + if acw.isHidden(): + continue + # elif acw.axis.is_moving: + # continue + + acw.update_display_of_axis_status() + + @Slot() + def disable_motion_buttons(self): + for acw in self._axis_control_widgets: + if acw.isHidden(): + continue + + acw.disable_motion_buttons() + + @Slot() + def enable_motion_buttons(self): + for acw in self._axis_control_widgets: + if acw.isHidden(): + continue + + acw.enable_motion_buttons() + + @Slot() + def _drive_connection_lost(self): + self.mg.drive.stop() + self.setEnabled(False) + + @Slot() + def _drive_connection_established(self): + if not isinstance(self.mg, MotionGroup) or not isinstance(self.mg.drive, Drive): + return + + if self.mg.drive.connected: + self.setEnabled(True) + + @Slot(int) + def _drive_movement_started(self, axis_index): + self.movementStarted.emit() + + @Slot(int) + def _drive_movement_finished(self, axis_index): + if not isinstance(self.mg, MotionGroup) or not isinstance(self.mg.drive, Drive): + return + + is_moving = [ax.is_moving for ax in self.mg.drive.axes] + is_moving[axis_index] = False + if not any(is_moving): + self.movementStopped.emit() + + def _determine_mspace_drive_polarity(self): + naxes = self.mg.drive.naxes + polarity = [1] * naxes + mspace_zero = [0] * naxes + drive_zero = self.mg.transform(mspace_zero, to_coords="drive") + + for ii in range(naxes): + test_pt = [0] * naxes + test_pt[ii] = 10 + drive_pt = self.mg.transform(test_pt, to_coords="drive") + delta = drive_pt[0][ii] - drive_zero[0][ii] + + pt_polarity = 1 if delta > 0 else -1 + polarity[ii] = pt_polarity + + self._mspace_drive_polarity = polarity + + def closeEvent(self, event): + self.logger.info(f"Closing {self.__class__.__name__}.") + + for acw in self._axis_control_widgets: + acw.close() + + event.accept() diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index df29947d..9f954772 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -48,7 +48,7 @@ from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure import configure_ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget -from bapsf_motion.gui.configure.controllers import AxisControlWidget +from bapsf_motion.gui.configure.controllers import DriveBaseController from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.gui.configure.message_boxes import ( @@ -85,250 +85,6 @@ import qtawesome as qta # noqa -class DriveBaseController(QWidget): - driveStatusChanged = Signal() - movementStarted = Signal() - movementStopped = Signal() - moveTo = Signal(list) - zeroDrive = Signal() - targetPositionChanged = Signal(list) - - def __init__(self, axis_display_mode="interactive", parent=None): - # axis_display_mode == "interactive" or "readonly" - super().__init__(parent=parent) - - self._logger = gui_logger - - self._axis_display_mode = axis_display_mode - self.mspace_warning_dialog = None - if hasattr(parent, "mspace_warning_dialog"): - self.mspace_warning_dialog = parent.mspace_warning_dialog - - self.lost_connection_dialog = None - if hasattr(parent, "lost_connection_dialog"): - self.lost_connection_dialog = parent.lost_connection_dialog - - self._mg = None - self._mspace_drive_polarity = None - - self._axis_control_widgets = [] # type: List[AxisControlWidget] - self._initialize_axis_control_widgets() - - self._initialize_widgets() - - self.setLayout(self._define_layout()) - self._connect_signals() - - @abstractmethod - def _initialize_widgets(self): ... - - def _initialize_axis_control_widgets(self): - for ii in range(4): - acw = AxisControlWidget( - axis_display_mode=self._axis_display_mode, - parent=self, - ) - visible = True if ii == 0 else False - acw.setVisible(visible) - self._axis_control_widgets.append(acw) - - def _connect_signals(self): - self.movementStarted.connect(self.disable_motion_buttons) - self.movementStopped.connect(self.enable_motion_buttons) - - for acw in self._axis_control_widgets: - acw.targetPositionChanged.connect(self._target_position_changed) - - @abstractmethod - def _define_layout(self) -> QLayout: ... - - @property - def logger(self): - return self._logger - - @property - def mg(self) -> Union[MotionGroup, None]: - return self._mg - - @property - def mspace_drive_polarity(self): - return self._mspace_drive_polarity - - @property - def position(self) -> List[float]: - position = [] - for acw in self._axis_control_widgets: - if acw.isHidden(): - continue - - position.append(acw.position.value) - - return position - - @property - def target_position(self) -> Union[List[float], None]: - target_position = [] - for acw in self._axis_control_widgets: - if acw.isHidden(): - continue - - target_position.append(acw.target_position) - - if not bool(target_position): - # no values in target position - return None - - if any(pos is None for pos in target_position): - # some target positions are not valid - return None - - return target_position - - @Slot() - def _target_position_changed(self, position): - self.logger.info(f"DBC target position changed {self.target_position}") - tpos = self.target_position - if tpos is None: - tpos = [] - self.targetPositionChanged.emit(tpos) - - def link_motion_group(self, mg: MotionGroup): - if not isinstance(mg, MotionGroup): - self.logger.warning( - f"Expected type {MotionGroup} for motion group, but got type" - f" {type(mg)}." - ) - - if not isinstance(mg.drive, Drive): - # drive has not been set yet - self.unlink_motion_group() - return - - if ( - isinstance(self.mg, MotionGroup) - and isinstance(self.mg.drive, Drive) - and mg.drive is self.mg.drive - ): - pass - else: - self.unlink_motion_group() - self._mg = mg - - for ii, ax in enumerate(self.mg.drive.axes): - acw = self._axis_control_widgets[ii] - acw.link_axis(self.mg, ii) - acw.establishedConnection.connect(self._drive_connection_established) - acw.lostConnection.connect(self._drive_connection_lost) - acw.movementStarted.connect(self._drive_movement_started) - acw.movementStopped.connect(self._drive_movement_finished) - acw.axisStatusChanged.connect(self.update_all_axis_displays) - acw.axisStatusChanged.connect(self.driveStatusChanged.emit) - acw.show() - - self.setEnabled(not (self._mg.terminated or not self._mg.connected)) - self._determine_mspace_drive_polarity() - - def unlink_motion_group(self): - for ii, acw in enumerate(self._axis_control_widgets): - visible = True if ii == 0 else False - - acw.unlink_axis() - - with warnings.catch_warnings(): - warnings.simplefilter("ignore", category=RuntimeWarning) - acw.establishedConnection.disconnect(self._drive_connection_established) - acw.lostConnection.disconnect(self._drive_connection_lost) - acw.movementStarted.disconnect(self._drive_movement_started) - acw.movementStopped.disconnect(self._drive_movement_finished) - acw.axisStatusChanged.disconnect(self.update_all_axis_displays) - acw.axisStatusChanged.disconnect(self.driveStatusChanged.emit) - - acw.setVisible(visible) - - # self.mg.terminate(delay_loop_stop=True) - self._mg = None - self._mspace_drive_polarity = None - self.setEnabled(False) - - @Slot() - def update_all_axis_displays(self): - for acw in self._axis_control_widgets: - if acw.isHidden(): - continue - # elif acw.axis.is_moving: - # continue - - acw.update_display_of_axis_status() - - @Slot() - def disable_motion_buttons(self): - for acw in self._axis_control_widgets: - if acw.isHidden(): - continue - - acw.disable_motion_buttons() - - @Slot() - def enable_motion_buttons(self): - for acw in self._axis_control_widgets: - if acw.isHidden(): - continue - - acw.enable_motion_buttons() - - @Slot() - def _drive_connection_lost(self): - self.mg.drive.stop() - self.setEnabled(False) - - @Slot() - def _drive_connection_established(self): - if not isinstance(self.mg, MotionGroup) or not isinstance(self.mg.drive, Drive): - return - - if self.mg.drive.connected: - self.setEnabled(True) - - @Slot(int) - def _drive_movement_started(self, axis_index): - self.movementStarted.emit() - - @Slot(int) - def _drive_movement_finished(self, axis_index): - if not isinstance(self.mg, MotionGroup) or not isinstance(self.mg.drive, Drive): - return - - is_moving = [ax.is_moving for ax in self.mg.drive.axes] - is_moving[axis_index] = False - if not any(is_moving): - self.movementStopped.emit() - - def _determine_mspace_drive_polarity(self): - naxes = self.mg.drive.naxes - polarity = [1] * naxes - mspace_zero = [0] * naxes - drive_zero = self.mg.transform(mspace_zero, to_coords="drive") - - for ii in range(naxes): - test_pt = [0] * naxes - test_pt[ii] = 10 - drive_pt = self.mg.transform(test_pt, to_coords="drive") - delta = drive_pt[0][ii] - drive_zero[0][ii] - - pt_polarity = 1 if delta > 0 else -1 - polarity[ii] = pt_polarity - - self._mspace_drive_polarity = polarity - - def closeEvent(self, event): - self.logger.info(f"Closing {self.__class__.__name__}.") - - for acw in self._axis_control_widgets: - acw.close() - - event.accept() - - class DriveDesktopController(DriveBaseController): def __init__(self, parent=None): super().__init__(axis_display_mode="interactive", parent=parent) From 3659ca3dced588720ae6b10043d51a027e4002d3 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:37:36 -0700 Subject: [PATCH 109/177] move DriveDesktopController to bapsf_motion.gui.configure.controllers --- bapsf_motion/gui/configure/controllers.py | 236 ++++++++++++++++++ .../gui/configure/motion_group_widget.py | 236 +----------------- 2 files changed, 237 insertions(+), 235 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index e42c0fa8..6f771d95 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -2,6 +2,7 @@ import logging import numpy as np +import re import warnings from abc import abstractmethod @@ -15,6 +16,7 @@ QHBoxLayout, QGridLayout, QLayout, + QSizePolicy, ) from typing import List @@ -918,3 +920,237 @@ def closeEvent(self, event): acw.close() event.accept() + + +class DriveDesktopController(DriveBaseController): + def __init__(self, parent: QWidget | None = None): + super().__init__(axis_display_mode="interactive", parent=parent) + + def _initialize_widgets(self): + # BUTTON WIDGETS + _btn = StyleButton("Move \n To", parent=self) + _btn.setMinimumHeight(100) + font = _btn.font() + font.setPointSize(20) + _btn.setFont(font) + self.move_to_btn = _btn + + _btn = StyleButton("Home \n All", parent=self) + _btn.setMinimumHeight(100) + _btn.setFont(font) + _btn.setEnabled(False) + self.home_btn = _btn + self.home_btn.setVisible(False) + + _btn = ZeroButton("Zero \n All", parent=self) + _btn.setMinimumHeight(100) + _btn.setFont(font) + self.zero_all_btn = _btn + + _btn = StyleButton("Holding\nCurrent", parent=self) + _btn.setFixedHeight(44) + font = _btn.font() + font.setPointSize(10) + _btn.setFont(font) + _btn.update_style_sheet( + styles={ + "background-color": re.sub( + " +", + " ", + """qlineargradient( + x1:0, + y1:0, + x2:1, + y2:0, + stop: 0 rgb(52, 161, 219), + stop: 0.1 rgb(52, 161, 219), + stop: 0.4 rgb(163, 163, 163), + stop: 1 rgb(163, 163, 163) + )""".replace("\n", ""), + ), + }, + action="base", + ) + _btn.update_style_sheet( + styles={ + "background-color": re.sub( + " +", + " ", + """qlineargradient( + x1:0, + y1:0, + x2:1, + y2:0, + stop: 0 rgb(163, 163, 163), + stop: 0.6 rgb(163, 163, 163), + stop: 0.9 rgb(250, 66, 45) + stop: 1 rgb(250, 66, 45) + )""".replace("\n", ""), + ), + }, + action="checked", + ) + _btn.setCheckable(True) + _btn.setChecked(False) + self.hold_current_btn = _btn + + def _connect_signals(self): + super()._connect_signals() + + self.zero_all_btn.clicked.connect(self.zeroDrive.emit) + self.move_to_btn.clicked.connect(self._move_to) + self.hold_current_btn.clicked.connect(self._toggle_holding_current) + + def _define_layout(self) -> QLayout: + _on = QLabel("O\nN", parent=self) + font = _on.font() + font.setBold(True) + _on.setFont(font) + _on.setAlignment(Qt.AlignmentFlag.AlignCenter) + _on.setFixedWidth(10) + _on.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum) + + _off = QLabel("O\nF\nF", parent=self) + _off.setFont(font) + _off.setAlignment(Qt.AlignmentFlag.AlignCenter) + _off.setFixedWidth(10) + _off.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum) + + holding_current_layout = QHBoxLayout() + holding_current_layout.setContentsMargins(0, 0, 0, 0) + holding_current_layout.addWidget( + _on, + alignment=Qt.AlignmentFlag.AlignVCenter, + ) + holding_current_layout.addWidget(self.hold_current_btn) + holding_current_layout.addWidget( + _off, + alignment=Qt.AlignmentFlag.AlignVCenter, + ) + _on.setVisible(False) + _off.setVisible(False) + self.hold_current_btn.setVisible(False) + + # Sub-Layout #1 + sub_layout = QVBoxLayout() + sub_layout.setContentsMargins(0, 0, 0, 0) + sub_layout.addWidget(self.move_to_btn) + sub_layout.addStretch() + # sub_layout.addWidget(self.home_btn) + sub_layout.addLayout(holding_current_layout) + sub_layout.addStretch() + sub_layout.addWidget(self.zero_all_btn) + sub_widget = QWidget(parent=self) + sub_widget.setLayout(sub_layout) + sub_widget.setFixedWidth(140) + + # Sub-Layout #2 + _text = QLabel("Position", parent=self) + font = _text.font() + font.setPointSize(14) + _text.setFont(font) + _pos_label = _text + + _text = QLabel("Target", parent=self) + font = _text.font() + font.setPointSize(14) + _text.setFont(font) + _target_label = _text + + _text = QLabel("Jog Δ", parent=self) + font = _text.font() + font.setPointSize(14) + _text.setFont(font) + _jog_delta_label = _text + + sub_layout2 = QVBoxLayout() + sub_layout2.setSpacing(8) + sub_layout2.addSpacing(54) + sub_layout2.addWidget( + _pos_label, + alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, + ) + sub_layout2.addSpacing(42) + sub_layout2.addWidget( + _target_label, + alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, + ) + sub_layout2.addSpacing(86) + sub_layout2.addWidget( + _jog_delta_label, + alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, + ) + sub_layout2.addStretch(1) + + layout = QHBoxLayout() + layout.addWidget(sub_widget) + layout.addLayout(sub_layout2) + for acw in self._axis_control_widgets: + layout.addWidget(acw) + layout.addSpacing(2) + layout.addStretch() + + return layout + + @Slot() + def _move_to(self): + target_pos = [ + acw.target_position + for acw in self._axis_control_widgets + if not acw.isHidden() + ] + + if self.mg.drive.is_moving: + self.logger.info( + "Probe drive is currently moving. Did NOT perform move " + f"to {target_pos}." + ) + target_pos = [] + + if any(p is None for p in target_pos): + self.logger.warning( + f"Requested target position ({target_pos}) is not valid," + f" NOT performing move to." + ) + return + + self.moveTo.emit(target_pos) + + @Slot() + def _toggle_holding_current(self): + hold_current = not self.hold_current_btn.isChecked() + if hold_current: + self.mg.drive.send_command("reset_currents") + else: + idle_currents = [0] * self.mg.drive.naxes + self.mg.drive.send_command("set_idle_current", *idle_currents) + + def set_target_position(self, target_position: List[float]): + npos = len(target_position) + naxes = self.mg.drive.naxes + + if npos != naxes: + self.logger.warning( + f"Received target position {target_position} does NOT " + f"have the same dimensionality as the drive " + f"({naxes})." + ) + return + + for ii, pos in enumerate(target_position): + acw = self._axis_control_widgets[ii] + acw.update_target_position_display(pos) + + def disable_motion_buttons(self): + self.move_to_btn.setEnabled(False) + self.zero_all_btn.setEnabled(False) + self.hold_current_btn.setEnabled(False) + + super().disable_motion_buttons() + + def enable_motion_buttons(self): + self.move_to_btn.setEnabled(True) + self.zero_all_btn.setEnabled(True) + self.hold_current_btn.setEnabled(True) + + super().enable_motion_buttons() diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 9f954772..42281225 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -48,7 +48,7 @@ from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure import configure_ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget -from bapsf_motion.gui.configure.controllers import DriveBaseController +from bapsf_motion.gui.configure.controllers import DriveBaseController, DriveDesktopController from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.gui.configure.message_boxes import ( @@ -85,240 +85,6 @@ import qtawesome as qta # noqa -class DriveDesktopController(DriveBaseController): - def __init__(self, parent=None): - super().__init__(axis_display_mode="interactive", parent=parent) - - def _initialize_widgets(self): - # BUTTON WIDGETS - _btn = StyleButton("Move \n To", parent=self) - _btn.setMinimumHeight(100) - font = _btn.font() - font.setPointSize(20) - _btn.setFont(font) - self.move_to_btn = _btn - - _btn = StyleButton("Home \n All", parent=self) - _btn.setMinimumHeight(100) - _btn.setFont(font) - _btn.setEnabled(False) - self.home_btn = _btn - self.home_btn.setVisible(False) - - _btn = ZeroButton("Zero \n All", parent=self) - _btn.setMinimumHeight(100) - _btn.setFont(font) - self.zero_all_btn = _btn - - _btn = StyleButton("Holding\nCurrent", parent=self) - _btn.setFixedHeight(44) - font = _btn.font() - font.setPointSize(10) - _btn.setFont(font) - _btn.update_style_sheet( - styles={ - "background-color": re.sub( - " +", - " ", - """qlineargradient( - x1:0, - y1:0, - x2:1, - y2:0, - stop: 0 rgb(52, 161, 219), - stop: 0.1 rgb(52, 161, 219), - stop: 0.4 rgb(163, 163, 163), - stop: 1 rgb(163, 163, 163) - )""".replace("\n", ""), - ), - }, - action="base", - ) - _btn.update_style_sheet( - styles={ - "background-color": re.sub( - " +", - " ", - """qlineargradient( - x1:0, - y1:0, - x2:1, - y2:0, - stop: 0 rgb(163, 163, 163), - stop: 0.6 rgb(163, 163, 163), - stop: 0.9 rgb(250, 66, 45) - stop: 1 rgb(250, 66, 45) - )""".replace("\n", ""), - ), - }, - action="checked", - ) - _btn.setCheckable(True) - _btn.setChecked(False) - self.hold_current_btn = _btn - - def _connect_signals(self): - super()._connect_signals() - - self.zero_all_btn.clicked.connect(self.zeroDrive.emit) - self.move_to_btn.clicked.connect(self._move_to) - self.hold_current_btn.clicked.connect(self._toggle_holding_current) - - def _define_layout(self) -> QLayout: - _on = QLabel("O\nN", parent=self) - font = _on.font() - font.setBold(True) - _on.setFont(font) - _on.setAlignment(Qt.AlignmentFlag.AlignCenter) - _on.setFixedWidth(10) - _on.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum) - - _off = QLabel("O\nF\nF", parent=self) - _off.setFont(font) - _off.setAlignment(Qt.AlignmentFlag.AlignCenter) - _off.setFixedWidth(10) - _off.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum) - - holding_current_layout = QHBoxLayout() - holding_current_layout.setContentsMargins(0, 0, 0, 0) - holding_current_layout.addWidget( - _on, - alignment=Qt.AlignmentFlag.AlignVCenter, - ) - holding_current_layout.addWidget(self.hold_current_btn) - holding_current_layout.addWidget( - _off, - alignment=Qt.AlignmentFlag.AlignVCenter, - ) - _on.setVisible(False) - _off.setVisible(False) - self.hold_current_btn.setVisible(False) - - # Sub-Layout #1 - sub_layout = QVBoxLayout() - sub_layout.setContentsMargins(0, 0, 0, 0) - sub_layout.addWidget(self.move_to_btn) - sub_layout.addStretch() - # sub_layout.addWidget(self.home_btn) - sub_layout.addLayout(holding_current_layout) - sub_layout.addStretch() - sub_layout.addWidget(self.zero_all_btn) - sub_widget = QWidget(parent=self) - sub_widget.setLayout(sub_layout) - sub_widget.setFixedWidth(140) - - # Sub-Layout #2 - _text = QLabel("Position", parent=self) - font = _text.font() - font.setPointSize(14) - _text.setFont(font) - _pos_label = _text - - _text = QLabel("Target", parent=self) - font = _text.font() - font.setPointSize(14) - _text.setFont(font) - _target_label = _text - - _text = QLabel("Jog Δ", parent=self) - font = _text.font() - font.setPointSize(14) - _text.setFont(font) - _jog_delta_label = _text - - sub_layout2 = QVBoxLayout() - sub_layout2.setSpacing(8) - sub_layout2.addSpacing(54) - sub_layout2.addWidget( - _pos_label, - alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, - ) - sub_layout2.addSpacing(42) - sub_layout2.addWidget( - _target_label, - alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, - ) - sub_layout2.addSpacing(86) - sub_layout2.addWidget( - _jog_delta_label, - alignment=Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight, - ) - sub_layout2.addStretch(1) - - layout = QHBoxLayout() - layout.addWidget(sub_widget) - layout.addLayout(sub_layout2) - for acw in self._axis_control_widgets: - layout.addWidget(acw) - layout.addSpacing(2) - layout.addStretch() - - return layout - - @Slot() - def _move_to(self): - target_pos = [ - acw.target_position - for acw in self._axis_control_widgets - if not acw.isHidden() - ] - - if self.mg.drive.is_moving: - self.logger.info( - "Probe drive is currently moving. Did NOT perform move " - f"to {target_pos}." - ) - target_pos = [] - - if any(p is None for p in target_pos): - self.logger.warning( - f"Requested target position ({target_pos}) is not valid," - f" NOT performing move to." - ) - return - - self.moveTo.emit(target_pos) - - @Slot() - def _toggle_holding_current(self): - hold_current = not self.hold_current_btn.isChecked() - if hold_current: - self.mg.drive.send_command("reset_currents") - else: - idle_currents = [0] * self.mg.drive.naxes - self.mg.drive.send_command("set_idle_current", *idle_currents) - - def set_target_position(self, target_position: List[float]): - npos = len(target_position) - naxes = self.mg.drive.naxes - - if npos != naxes: - self.logger.warning( - f"Received target position {target_position} does NOT " - f"have the same dimensionality as the drive " - f"({naxes})." - ) - return - - for ii, pos in enumerate(target_position): - acw = self._axis_control_widgets[ii] - acw.update_target_position_display(pos) - - def disable_motion_buttons(self): - self.move_to_btn.setEnabled(False) - self.zero_all_btn.setEnabled(False) - self.hold_current_btn.setEnabled(False) - - super().disable_motion_buttons() - - def enable_motion_buttons(self): - self.move_to_btn.setEnabled(True) - self.zero_all_btn.setEnabled(True) - self.hold_current_btn.setEnabled(True) - - super().enable_motion_buttons() - - class DriveGameController(DriveBaseController): def __init__(self, parent=None): super().__init__(axis_display_mode="readonly", parent=parent) From 2ac46b5a49cbfd6a0f6f5ac9c9a0de8e29124f36 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:43:04 -0700 Subject: [PATCH 110/177] move DriveGameController to bapsf_motion.gui.configure.controllers --- bapsf_motion/gui/configure/controllers.py | 320 +++++++++++++++++- .../gui/configure/motion_group_widget.py | 313 +---------------- 2 files changed, 323 insertions(+), 310 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 6f771d95..ee0abcf8 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -2,12 +2,19 @@ import logging import numpy as np +import os import re import warnings +# ensure joystick events are monitored when the pygame window +# is not in focus ... this needs to be done before importing pygame +os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" + +import pygame # noqa + from abc import abstractmethod -from PySide6.QtCore import Signal, QTimer, Qt, Slot -from PySide6.QtGui import QDoubleValidator +from PySide6.QtCore import Signal, QTimer, Qt, Slot, QThreadPool +from PySide6.QtGui import QDoubleValidator, QFont from PySide6.QtWidgets import ( QWidget, QLabel, @@ -17,12 +24,14 @@ QGridLayout, QLayout, QSizePolicy, + QComboBox, ) from typing import List from bapsf_motion.actors import MotionGroup, Drive, Axis, Motor from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.gui.configure.message_boxes import LostConnectionMessageBox +from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner from bapsf_motion.gui.icons import icon_name_dict from bapsf_motion.gui.widgets import ( EnableIndicator, @@ -31,6 +40,7 @@ StyleButton, ZeroButton, HLinePlain, + LED, ) from bapsf_motion.utils import units as u @@ -1154,3 +1164,309 @@ def enable_motion_buttons(self): self.hold_current_btn.setEnabled(True) super().enable_motion_buttons() + + +class DriveGameController(DriveBaseController): + def __init__(self, parent=None): + super().__init__(axis_display_mode="readonly", parent=parent) + + def _connect_signals(self): + super()._connect_signals() + + self.refresh_controller_list_btn.clicked.connect(self.refresh_controller_combo) + self.connect_btn.clicked.connect(self.connect_controller) + self.controller_combo_widget.currentIndexChanged.connect( + self.disconnect_controller + ) + + def _initialize_widgets(self): + self._pygame_joystick_runner = None # type: PyGameJoystickRunner | None + self._thread_pool = QThreadPool(parent=self) + + # BUTTON WIDGETS + _btn = StyleButton("Refresh List", parent=self) + _btn.setFixedHeight(32) + _font = _btn.font() + _font.setPointSize(12) + _btn.setFont(_font) + self.refresh_controller_list_btn = _btn + + _btn = StyleButton("Connect", parent=self) + _btn.setFixedHeight(32) + _btn.setFont(_font) + _btn.setFixedWidth(100) + self.connect_btn = _btn + + # TEXT/ICON WIDGETS + _led = LED(parent=self) + _led.set_fixed_height(24) + self.connected_led = _led + + # ADVANCED WIDGETS + _combo = QComboBox(parent=self) + _combo.setEditable(True) + _combo.lineEdit().setReadOnly(True) + _combo.lineEdit().setAlignment( + Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter + ) + _combo.setFixedHeight(32) + _combo.setFont(_font) + self.controller_combo_widget = _combo + + def _define_layout(self) -> QLayout: + self.refresh_controller_combo() + + connect_layout = QHBoxLayout() + connect_layout.setContentsMargins(0, 0, 0, 0) + connect_layout.addStretch(1) + connect_layout.addWidget(self.connect_btn) + connect_layout.addWidget(self.connected_led) + connect_layout.addStretch(1) + + _label_font = QFont() + _label_font.setPointSize(12) + _left_stick = QLabel("Left Stick :", parent=self) + _left_stick.setFont(_label_font) + _right_stick = QLabel("Right Stick :", parent=self) + _right_stick.setFont(_label_font) + _dpad_vert_stick = QLabel("DPad Up/Down :", parent=self) + _dpad_vert_stick.setFont(_label_font) + _dpad_horz_stick = QLabel("DPad Left/Right :", parent=self) + _dpad_horz_stick.setFont(_label_font) + _ab = QLabel("A / B :", parent=self) + _ab.setFont(_label_font) + _y = QLabel("Y :", parent=self) + _y.setFont(_label_font) + _move_y = QLabel("Move Y", parent=self) + _move_y.setFont(_label_font) + _move_x = QLabel("Move X", parent=self) + _move_x.setFont(_label_font) + _fine_y = QLabel("Fine Y", parent=self) + _fine_y.setFont(_label_font) + _fine_x = QLabel("Fine X", parent=self) + _fine_x.setFont(_label_font) + _stop = QLabel("STOP", parent=self) + _stop.setFont(_label_font) + _zero = QLabel("Zero", parent=self) + _zero.setFont(_label_font) + + btn_label_layout = QGridLayout() + btn_label_layout.setContentsMargins(0, 0, 0, 0) + btn_label_layout.setColumnMinimumWidth(1, 8) + btn_label_layout.addWidget( + _left_stick, 0, 0, alignment=Qt.AlignmentFlag.AlignRight + ) + btn_label_layout.addWidget( + _right_stick, 1, 0, alignment=Qt.AlignmentFlag.AlignRight + ) + btn_label_layout.addWidget( + _dpad_vert_stick, 2, 0, alignment=Qt.AlignmentFlag.AlignRight + ) + btn_label_layout.addWidget( + _dpad_horz_stick, 3, 0, alignment=Qt.AlignmentFlag.AlignRight + ) + btn_label_layout.addWidget(_ab, 4, 0, alignment=Qt.AlignmentFlag.AlignRight) + btn_label_layout.addWidget(_y, 5, 0, alignment=Qt.AlignmentFlag.AlignRight) + + btn_label_layout.addWidget(_move_y, 0, 2, alignment=Qt.AlignmentFlag.AlignLeft) + btn_label_layout.addWidget(_move_x, 1, 2, alignment=Qt.AlignmentFlag.AlignLeft) + btn_label_layout.addWidget(_fine_y, 2, 2, alignment=Qt.AlignmentFlag.AlignLeft) + btn_label_layout.addWidget(_fine_x, 3, 2, alignment=Qt.AlignmentFlag.AlignLeft) + btn_label_layout.addWidget(_stop, 4, 2, alignment=Qt.AlignmentFlag.AlignLeft) + btn_label_layout.addWidget(_zero, 5, 2, alignment=Qt.AlignmentFlag.AlignLeft) + + sub_layout_1 = QVBoxLayout() + sub_layout_1.setContentsMargins(0, 0, 0, 0) + sub_layout_1.addSpacing(16) + sub_layout_1.addWidget(self.refresh_controller_list_btn) + sub_layout_1.addWidget(self.controller_combo_widget) + sub_layout_1.addLayout(connect_layout) + sub_layout_1.addSpacing(24) + sub_layout_1.addLayout(btn_label_layout) + sub_layout_1.addStretch(1) + + sub_widget_1 = QWidget(parent=self) + sub_widget_1.setLayout(sub_layout_1) + sub_widget_1.setMaximumWidth(200) + sub_widget_1.setMinimumWidth(100) + sub_widget_1.setSizePolicy( + QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred + ) + + layout = QHBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addWidget(sub_widget_1) + layout.addSpacing(2) + for acw in self._axis_control_widgets: + layout.addWidget(acw) + layout.addSpacing(2) + layout.addStretch() + + return layout + + @property + def available_controllers(self) -> List[pygame.joystick.JoystickType]: + _joystick = pygame.joystick + + if not _joystick.get_init(): + _joystick.init() + + return [_joystick.Joystick(_id) for _id in range(_joystick.get_count())] + + @property + def joystick(self) -> pygame.joystick.JoystickType | None: + js_name = self.controller_combo_widget.currentText() + self.logger.info(f"Selected joystick: {js_name} - {self.available_controllers}") + js = None + for _js in self.available_controllers: + if _js.get_name() == js_name: + js = _js + break + + return js + + @Slot() + def refresh_controller_combo(self): + self.disconnect_controller() + + current_controller_name = self.controller_combo_widget.currentText() + + self.controller_combo_widget.clear() + + controller_names = [ + controller.get_name() for controller in self.available_controllers + ] + controller_names.append("") + self.controller_combo_widget.addItems(controller_names) + + if current_controller_name != "" and current_controller_name in controller_names: + self.controller_combo_widget.setCurrentText(current_controller_name) + self.connect_controller() + else: + self.controller_combo_widget.setCurrentText("") + + @Slot() + def connect_controller(self): + self.logger.info("Connecting controller.") + + if isinstance(self._pygame_joystick_runner, PyGameJoystickRunner): + self.disconnect_controller() + + self._pygame_joystick_runner = PyGameJoystickRunner(self.joystick) + + self._pygame_joystick_runner.signals.joystickConnected.connect( + self._update_connect_led + ) + self._pygame_joystick_runner.signals.axisMoved.connect(self._handle_axis_move) + self._pygame_joystick_runner.signals.buttonPressed.connect( + self._handle_button_press + ) + self._pygame_joystick_runner.signals.hatPressed.connect(self._handle_hat_press) + self._pygame_joystick_runner.signals.stopMovement.connect(self.stop_move) + + self._thread_pool.start(self._pygame_joystick_runner) + + @Slot() + def disconnect_controller(self): + if isinstance(self.mg, MotionGroup) and self.mg.is_moving: + self.stop_move() + + if self._pygame_joystick_runner is None: + return + + self._pygame_joystick_runner.quit() + self._pygame_joystick_runner = None + self._thread_pool.waitForDone(200) + self._thread_pool.clear() + + if isinstance(self.mg, MotionGroup) and self.mg.is_moving: + self.stop_move() + + def stop_move(self, axis=None, soft=False): + self.logger.debug("Stopping move.") + + if axis is None: + self.mg.stop(soft=soft) + return + + try: + self.mg.drive.send_command("stop", soft, axis=axis) + except Exception: # noqa + self.mg.stop() + + def zero_drive(self): + self.mg.set_zero() + + @Slot() + def _drive_connection_lost(self): + super()._drive_connection_lost() + self.disconnect_controller() + + @Slot(bool) + def _update_connect_led(self, value): + self.connected_led.setChecked(value) + + @Slot(int, float) + def _handle_axis_move(self, jaxis, value): + if jaxis not in (1, 3): + # moved joystick axis is not utilized + return + elif jaxis == 1: + axis_id = 1 + else: # jaxis == 3: + axis_id = 0 + + ax = self.mg.drive.axes[axis_id] + + if np.absolute(value) < 0.5: + self.stop_move(axis=axis_id, soft=True) + elif ax.is_moving: + pass + else: + try: + proceed = self.mspace_warning_dialog.exec() + except AttributeError: + proceed = False + + if not proceed: + return + + # pygame up-down axes are inverted + sign = 1 if value <= 0 else -1 + sign = self.mspace_drive_polarity[axis_id] * sign + direction = "forward" if sign > 0 else "backward" + + self.mg.drive.send_command("continuous_jog", direction, axis=axis_id) + + @Slot(int) + def _handle_button_press(self, button): + if button in (0, 1): + self.stop_move() + elif button == 3: + self.zero_drive() + + @Slot(int, int) + def _handle_hat_press(self, hat_id, direction): + if direction == 0: + # hat (dpad) button returned to unpressed state + # do nothing + return + + try: + proceed = self.mspace_warning_dialog.exec() + except AttributeError: + proceed = False + + if not proceed: + return + + acw = self._axis_control_widgets[hat_id] + if direction > 0: + acw.jog_forward() + else: + acw.jog_backward() + + def closeEvent(self, event): + self.disconnect_controller() + self._thread_pool.deleteLater() + super().closeEvent(event) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 42281225..8871bf03 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -48,7 +48,10 @@ from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure import configure_ from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget -from bapsf_motion.gui.configure.controllers import DriveBaseController, DriveDesktopController +from bapsf_motion.gui.configure.controllers import ( + DriveDesktopController, + DriveGameController, +) from bapsf_motion.gui.configure.drive_overlay import DriveConfigOverlay from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.gui.configure.message_boxes import ( @@ -85,312 +88,6 @@ import qtawesome as qta # noqa -class DriveGameController(DriveBaseController): - def __init__(self, parent=None): - super().__init__(axis_display_mode="readonly", parent=parent) - - def _connect_signals(self): - super()._connect_signals() - - self.refresh_controller_list_btn.clicked.connect(self.refresh_controller_combo) - self.connect_btn.clicked.connect(self.connect_controller) - self.controller_combo_widget.currentIndexChanged.connect( - self.disconnect_controller - ) - - def _initialize_widgets(self): - self._pygame_joystick_runner = None # type: Union[PyGameJoystickRunner, None] - self._thread_pool = QThreadPool(parent=self) - - # BUTTON WIDGETS - _btn = StyleButton("Refresh List", parent=self) - _btn.setFixedHeight(32) - _font = _btn.font() - _font.setPointSize(12) - _btn.setFont(_font) - self.refresh_controller_list_btn = _btn - - _btn = StyleButton("Connect", parent=self) - _btn.setFixedHeight(32) - _btn.setFont(_font) - _btn.setFixedWidth(100) - self.connect_btn = _btn - - # TEXT/ICON WIDGETS - _led = LED(parent=self) - _led.set_fixed_height(24) - self.connected_led = _led - - # ADVANCED WIDGETS - _combo = QComboBox(parent=self) - _combo.setEditable(True) - _combo.lineEdit().setReadOnly(True) - _combo.lineEdit().setAlignment( - Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter - ) - _combo.setFixedHeight(32) - _combo.setFont(_font) - self.controller_combo_widget = _combo - - def _define_layout(self) -> QLayout: - self.refresh_controller_combo() - - connect_layout = QHBoxLayout() - connect_layout.setContentsMargins(0, 0, 0, 0) - connect_layout.addStretch(1) - connect_layout.addWidget(self.connect_btn) - connect_layout.addWidget(self.connected_led) - connect_layout.addStretch(1) - - _label_font = QFont() - _label_font.setPointSize(12) - _left_stick = QLabel("Left Stick :", parent=self) - _left_stick.setFont(_label_font) - _right_stick = QLabel("Right Stick :", parent=self) - _right_stick.setFont(_label_font) - _dpad_vert_stick = QLabel("DPad Up/Down :", parent=self) - _dpad_vert_stick.setFont(_label_font) - _dpad_horz_stick = QLabel("DPad Left/Right :", parent=self) - _dpad_horz_stick.setFont(_label_font) - _ab = QLabel("A / B :", parent=self) - _ab.setFont(_label_font) - _y = QLabel("Y :", parent=self) - _y.setFont(_label_font) - _move_y = QLabel("Move Y", parent=self) - _move_y.setFont(_label_font) - _move_x = QLabel("Move X", parent=self) - _move_x.setFont(_label_font) - _fine_y = QLabel("Fine Y", parent=self) - _fine_y.setFont(_label_font) - _fine_x = QLabel("Fine X", parent=self) - _fine_x.setFont(_label_font) - _stop = QLabel("STOP", parent=self) - _stop.setFont(_label_font) - _zero = QLabel("Zero", parent=self) - _zero.setFont(_label_font) - - btn_label_layout = QGridLayout() - btn_label_layout.setContentsMargins(0, 0, 0, 0) - btn_label_layout.setColumnMinimumWidth(1, 8) - btn_label_layout.addWidget( - _left_stick, 0, 0, alignment=Qt.AlignmentFlag.AlignRight - ) - btn_label_layout.addWidget( - _right_stick, 1, 0, alignment=Qt.AlignmentFlag.AlignRight - ) - btn_label_layout.addWidget( - _dpad_vert_stick, 2, 0, alignment=Qt.AlignmentFlag.AlignRight - ) - btn_label_layout.addWidget( - _dpad_horz_stick, 3, 0, alignment=Qt.AlignmentFlag.AlignRight - ) - btn_label_layout.addWidget(_ab, 4, 0, alignment=Qt.AlignmentFlag.AlignRight) - btn_label_layout.addWidget(_y, 5, 0, alignment=Qt.AlignmentFlag.AlignRight) - - btn_label_layout.addWidget(_move_y, 0, 2, alignment=Qt.AlignmentFlag.AlignLeft) - btn_label_layout.addWidget(_move_x, 1, 2, alignment=Qt.AlignmentFlag.AlignLeft) - btn_label_layout.addWidget(_fine_y, 2, 2, alignment=Qt.AlignmentFlag.AlignLeft) - btn_label_layout.addWidget(_fine_x, 3, 2, alignment=Qt.AlignmentFlag.AlignLeft) - btn_label_layout.addWidget(_stop, 4, 2, alignment=Qt.AlignmentFlag.AlignLeft) - btn_label_layout.addWidget(_zero, 5, 2, alignment=Qt.AlignmentFlag.AlignLeft) - - sub_layout_1 = QVBoxLayout() - sub_layout_1.setContentsMargins(0, 0, 0, 0) - sub_layout_1.addSpacing(16) - sub_layout_1.addWidget(self.refresh_controller_list_btn) - sub_layout_1.addWidget(self.controller_combo_widget) - sub_layout_1.addLayout(connect_layout) - sub_layout_1.addSpacing(24) - sub_layout_1.addLayout(btn_label_layout) - sub_layout_1.addStretch(1) - - sub_widget_1 = QWidget(parent=self) - sub_widget_1.setLayout(sub_layout_1) - sub_widget_1.setMaximumWidth(200) - sub_widget_1.setMinimumWidth(100) - sub_widget_1.setSizePolicy( - QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred - ) - - layout = QHBoxLayout() - layout.setContentsMargins(0, 0, 0, 0) - layout.addWidget(sub_widget_1) - layout.addSpacing(2) - for acw in self._axis_control_widgets: - layout.addWidget(acw) - layout.addSpacing(2) - layout.addStretch() - - return layout - - @property - def available_controllers(self) -> List[pygame.joystick.JoystickType]: - _joystick = pygame.joystick - - if not _joystick.get_init(): - _joystick.init() - - return [_joystick.Joystick(_id) for _id in range(_joystick.get_count())] - - @property - def joystick(self) -> Union[pygame.joystick.JoystickType, None]: - js_name = self.controller_combo_widget.currentText() - self.logger.info(f"Selected joystick: {js_name} - {self.available_controllers}") - js = None - for _js in self.available_controllers: - if _js.get_name() == js_name: - js = _js - break - - return js - - @Slot() - def refresh_controller_combo(self): - self.disconnect_controller() - - current_controller_name = self.controller_combo_widget.currentText() - - self.controller_combo_widget.clear() - - controller_names = [ - controller.get_name() for controller in self.available_controllers - ] - controller_names.append("") - self.controller_combo_widget.addItems(controller_names) - - if current_controller_name != "" and current_controller_name in controller_names: - self.controller_combo_widget.setCurrentText(current_controller_name) - self.connect_controller() - else: - self.controller_combo_widget.setCurrentText("") - - @Slot() - def connect_controller(self): - self.logger.info("Connecting controller.") - - if isinstance(self._pygame_joystick_runner, PyGameJoystickRunner): - self.disconnect_controller() - - self._pygame_joystick_runner = PyGameJoystickRunner(self.joystick) - - self._pygame_joystick_runner.signals.joystickConnected.connect( - self._update_connect_led - ) - self._pygame_joystick_runner.signals.axisMoved.connect(self._handle_axis_move) - self._pygame_joystick_runner.signals.buttonPressed.connect( - self._handle_button_press - ) - self._pygame_joystick_runner.signals.hatPressed.connect(self._handle_hat_press) - self._pygame_joystick_runner.signals.stopMovement.connect(self.stop_move) - - self._thread_pool.start(self._pygame_joystick_runner) - - @Slot() - def disconnect_controller(self): - if isinstance(self.mg, MotionGroup) and self.mg.is_moving: - self.stop_move() - - if self._pygame_joystick_runner is None: - return - - self._pygame_joystick_runner.quit() - self._pygame_joystick_runner = None - self._thread_pool.waitForDone(200) - self._thread_pool.clear() - - if isinstance(self.mg, MotionGroup) and self.mg.is_moving: - self.stop_move() - - def stop_move(self, axis=None, soft=False): - self.logger.debug("Stopping move.") - - if axis is None: - self.mg.stop(soft=soft) - return - - try: - self.mg.drive.send_command("stop", soft, axis=axis) - except Exception: # noqa - self.mg.stop() - - def zero_drive(self): - self.mg.set_zero() - - @Slot() - def _drive_connection_lost(self): - super()._drive_connection_lost() - self.disconnect_controller() - - @Slot(bool) - def _update_connect_led(self, value): - self.connected_led.setChecked(value) - - @Slot(int, float) - def _handle_axis_move(self, jaxis, value): - if jaxis not in (1, 3): - # moved joystick axis is not utilized - return - elif jaxis == 1: - axis_id = 1 - else: # jaxis == 3: - axis_id = 0 - - ax = self.mg.drive.axes[axis_id] - - if np.absolute(value) < 0.5: - self.stop_move(axis=axis_id, soft=True) - elif ax.is_moving: - pass - else: - try: - proceed = self.mspace_warning_dialog.exec() - except AttributeError: - proceed = False - - if not proceed: - return - - # pygame up-down axes are inverted - sign = 1 if value <= 0 else -1 - sign = self.mspace_drive_polarity[axis_id] * sign - direction = "forward" if sign > 0 else "backward" - - self.mg.drive.send_command("continuous_jog", direction, axis=axis_id) - - @Slot(int) - def _handle_button_press(self, button): - if button in (0, 1): - self.stop_move() - elif button == 3: - self.zero_drive() - - @Slot(int, int) - def _handle_hat_press(self, hat_id, direction): - if direction == 0: - # hat (dpad) button returned to unpressed state - # do nothing - return - - try: - proceed = self.mspace_warning_dialog.exec() - except AttributeError: - proceed = False - - if not proceed: - return - - acw = self._axis_control_widgets[hat_id] - if direction > 0: - acw.jog_forward() - else: - acw.jog_backward() - - def closeEvent(self, event): - self.disconnect_controller() - self._thread_pool.deleteLater() - super().closeEvent(event) - - class DriveControlWidget(QWidget): movementStarted = Signal() movementStopped = Signal() @@ -434,7 +131,7 @@ def __init__(self, parent=None): self.lost_connection_dialog = LostConnectionMessageBox(parent=self) self.desktop_controller_widget = DriveDesktopController(parent=self) - self.game_controller_widget = None # type: Union[DriveBaseController, None] + self.game_controller_widget = None # type: Union[DriveGameController, None] self.stacked_controller_widget = QStackedWidget(parent=self) self.stacked_controller_widget.addWidget(self.desktop_controller_widget) From 14a9ad6f789250bf538201e8d8c3f1b8230fd62a Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:52:57 -0700 Subject: [PATCH 111/177] replace uses of Union[] with pipe | --- .../gui/configure/motion_group_widget.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 8871bf03..98fa0931 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -43,7 +43,7 @@ QVBoxLayout, QWidget, ) -from typing import Any, Dict, List, Optional, Tuple, Union +from typing import Any, Dict, List, Optional, Tuple from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure import configure_ @@ -131,7 +131,7 @@ def __init__(self, parent=None): self.lost_connection_dialog = LostConnectionMessageBox(parent=self) self.desktop_controller_widget = DriveDesktopController(parent=self) - self.game_controller_widget = None # type: Union[DriveGameController, None] + self.game_controller_widget = None # type: DriveGameController | None self.stacked_controller_widget = QStackedWidget(parent=self) self.stacked_controller_widget.addWidget(self.desktop_controller_widget) @@ -218,7 +218,7 @@ def logger(self): return self._logger @property - def mg(self) -> Union[MotionGroup, None]: + def mg(self) -> MotionGroup | None: return self._mg @property @@ -547,7 +547,7 @@ def __init__( self.transform_btn = _btn # Define ADVANCED WIDGETS - self._overlay_widget = None # type: Union[_ConfigOverlay, None] + self._overlay_widget = None # type: _ConfigOverlay | None self._overlay_shown = False self.drive_control_widget = DriveControlWidget(parent=self) @@ -1311,7 +1311,7 @@ def mg(self) -> "MotionGroup": """Current working Motion Group""" return self._mg - def _set_mg(self, mg: Union[MotionGroup, None]): + def _set_mg(self, mg: MotionGroup| None): if not (isinstance(mg, MotionGroup) or mg is None): return @@ -1319,7 +1319,7 @@ def _set_mg(self, mg: Union[MotionGroup, None]): self.configChanged.emit() @property - def mg_config(self) -> Union[Dict[str, Any], "MotionGroupConfig"]: + def mg_config(self) -> "Dict[str, Any] | MotionGroupConfig": if isinstance(self.mg, MotionGroup): self._mg_config = _deepcopy_dict(self.mg.config) elif self._mg_config is None: @@ -1551,7 +1551,7 @@ def split_motion_group_name(mg_name): return drive_name, ml_name @staticmethod - def _spawn_motion_builder(config: Dict[str, Any]) -> Union[MotionBuilder, None]: + def _spawn_motion_builder(config: Dict[str, Any]) -> MotionBuilder | None: """Return an instance of |MotionBuilder|.""" if config is None or not config: return None @@ -1806,7 +1806,7 @@ def _transform_dropdown_new_selection(self, index): if index == -1: return - tr_default_config = None # type: Union[Dict[str, Any], None] + tr_default_config = None # type: Dict[str, Any] | None for _name, _config in self.transform_defaults: if tr_name != _name: continue From a8ea5a7fbcbac4c73160feab4be626027d863aa9 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:53:16 -0700 Subject: [PATCH 112/177] motion_group_widget.py : cleanup imports --- .../gui/configure/motion_group_widget.py | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 98fa0931..7296bb34 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -7,36 +7,21 @@ import asyncio import logging -import numpy as np import os import re -import warnings -# ensure joystick events are monitored when the pygame window -# is not in focus ... this needs to be done before importing pygame -os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" - -import pygame # noqa - -from abc import abstractmethod from PySide6.QtCore import ( QSize, Qt, - QThreadPool, QTimer, Signal, Slot, ) -from PySide6.QtGui import QDoubleValidator, QFont from PySide6.QtWidgets import ( - QCheckBox, QComboBox, - QGridLayout, QHBoxLayout, QLabel, - QLayout, QLineEdit, - QMessageBox, QPlainTextEdit, QSizePolicy, QStackedWidget, @@ -61,28 +46,20 @@ ) from bapsf_motion.gui.configure.motion_builder_overlay import MotionBuilderConfigOverlay from bapsf_motion.gui.configure.motion_space_display import MotionSpaceDisplay -from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner from bapsf_motion.gui.configure.transform_overlay import TransformConfigOverlay from bapsf_motion.gui.icons import icon_name_dict from bapsf_motion.gui.widgets import ( DiscardButton, DoneButton, - EnableIndicator, GearValidButton, HLinePlain, - IconButton, - LED, QTAIconLabel, StopButton, - StyleButton, - ValidButton, - ZeroButton, ) from bapsf_motion.motion_builder import MotionBuilder from bapsf_motion.transform import BaseTransform from bapsf_motion.transform.helpers import transform_registry from bapsf_motion.utils import _deepcopy_dict, dict_equal, loop_safe_stop, toml -from bapsf_motion.utils import units as u # import of qtawesome must happen after the PySide6 imports import qtawesome as qta # noqa From 5a6e253fde42292dc74cf349eece4b609eaec8b0 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:54:36 -0700 Subject: [PATCH 113/177] motion_group_widget.py : appease black and isort --- bapsf_motion/gui/configure/motion_group_widget.py | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 7296bb34..2d362c72 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -10,13 +10,7 @@ import os import re -from PySide6.QtCore import ( - QSize, - Qt, - QTimer, - Signal, - Slot, -) +from PySide6.QtCore import QSize, Qt, QTimer, Signal, Slot from PySide6.QtWidgets import ( QComboBox, QHBoxLayout, @@ -1288,7 +1282,7 @@ def mg(self) -> "MotionGroup": """Current working Motion Group""" return self._mg - def _set_mg(self, mg: MotionGroup| None): + def _set_mg(self, mg: MotionGroup | None): if not (isinstance(mg, MotionGroup) or mg is None): return From 16b1cbaa4b7231281da2c5f498cb6a1c97176a88 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 16:59:40 -0700 Subject: [PATCH 114/177] motion_group_widget.py : handle type checking imports --- bapsf_motion/gui/configure/motion_group_widget.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 2d362c72..84044a02 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -3,6 +3,8 @@ configuration portion of the configuration GUI. """ +from __future__ import annotations + __all__ = ["MGWidget"] import asyncio @@ -22,11 +24,9 @@ QVBoxLayout, QWidget, ) -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING -from bapsf_motion.actors import Axis, Drive, MotionGroup, MotionGroupConfig, RunManager -from bapsf_motion.gui.configure import configure_ -from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget +from bapsf_motion.actors import Drive, MotionGroup, MotionGroupConfig, RunManager from bapsf_motion.gui.configure.controllers import ( DriveDesktopController, DriveGameController, @@ -55,6 +55,10 @@ from bapsf_motion.transform.helpers import transform_registry from bapsf_motion.utils import _deepcopy_dict, dict_equal, loop_safe_stop, toml +if TYPE_CHECKING: + from bapsf_motion.gui.configure import configure_ + from bapsf_motion.gui.configure.bases import _ConfigOverlay, _OverlayWidget + # import of qtawesome must happen after the PySide6 imports import qtawesome as qta # noqa From 25dcd8f60b023e7beb792ebacbb6c6d2c34534c6 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 17:06:50 -0700 Subject: [PATCH 115/177] controllers.py : cleanup imports --- bapsf_motion/gui/configure/controllers.py | 35 ++++++++++++++--------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index ee0abcf8..2291b6f9 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -1,4 +1,9 @@ +""" +Module containing "controller" classes that control the actual movement +of the probe dirves (i.e. motion groups). +""" +__all__ = ["DriveDesktopController", "DriveGameController"] import logging import numpy as np @@ -8,42 +13,44 @@ # ensure joystick events are monitored when the pygame window # is not in focus ... this needs to be done before importing pygame -os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" +os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" # noqa import pygame # noqa from abc import abstractmethod -from PySide6.QtCore import Signal, QTimer, Qt, Slot, QThreadPool +from PySide6.QtCore import Qt, QThreadPool, QTimer, Signal, Slot from PySide6.QtGui import QDoubleValidator, QFont from PySide6.QtWidgets import ( - QWidget, - QLabel, - QLineEdit, - QVBoxLayout, - QHBoxLayout, + QComboBox, QGridLayout, + QHBoxLayout, + QLabel, QLayout, + QLineEdit, QSizePolicy, - QComboBox, + QVBoxLayout, + QWidget, ) -from typing import List +from typing import List, TYPE_CHECKING -from bapsf_motion.actors import MotionGroup, Drive, Axis, Motor +from bapsf_motion.actors import Axis, Drive, MotionGroup from bapsf_motion.gui.configure.helpers import gui_logger -from bapsf_motion.gui.configure.message_boxes import LostConnectionMessageBox from bapsf_motion.gui.configure.pygame_ import PyGameJoystickRunner from bapsf_motion.gui.icons import icon_name_dict from bapsf_motion.gui.widgets import ( EnableIndicator, + HLinePlain, IconButton, - ValidButton, + LED, StyleButton, + ValidButton, ZeroButton, - HLinePlain, - LED, ) from bapsf_motion.utils import units as u +if TYPE_CHECKING: + from bapsf_motion.gui.configure.message_boxes import LostConnectionMessageBox + class AxisControlWidget(QWidget): axisLinked = Signal() From f00080d32b58e9b49cf21e8de9a7b6339be40c5d Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 17:08:35 -0700 Subject: [PATCH 116/177] replace use of Union[] with pipe | --- bapsf_motion/gui/configure/message_boxes.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py index 7c405708..6753f66a 100644 --- a/bapsf_motion/gui/configure/message_boxes.py +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -12,7 +12,6 @@ from PySide6.QtCore import Qt, Slot from PySide6.QtGui import QIcon from PySide6.QtWidgets import QDialog, QMessageBox, QWidget, QCheckBox -from typing import Union _HERE = Path(__file__).parent @@ -35,7 +34,7 @@ class WarningMessageBox(QMessageBox): and NO button is displayed and the user must choose how to proceed. - parent : Union[QWidget, None] + parent : QWidget | None The parent / owning widget. """ @@ -43,7 +42,7 @@ def __init__( self, message: str, button_layout: str = "acknowledge", - parent: Union[QWidget, None] = None, + parent: QWidget | None = None, ): super().__init__(parent) From 5c87b52adcec6ca43ea35b8fa7ee5c5c068e9ead Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 17:08:52 -0700 Subject: [PATCH 117/177] message_boxes.py : appease isort and black --- bapsf_motion/gui/configure/message_boxes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/message_boxes.py b/bapsf_motion/gui/configure/message_boxes.py index 6753f66a..3a74843b 100644 --- a/bapsf_motion/gui/configure/message_boxes.py +++ b/bapsf_motion/gui/configure/message_boxes.py @@ -11,7 +11,7 @@ from pathlib import Path from PySide6.QtCore import Qt, Slot from PySide6.QtGui import QIcon -from PySide6.QtWidgets import QDialog, QMessageBox, QWidget, QCheckBox +from PySide6.QtWidgets import QCheckBox, QDialog, QMessageBox, QWidget _HERE = Path(__file__).parent From 865eaf435af75d0c8c2eefdb76e35036c172dd6f Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 17:09:50 -0700 Subject: [PATCH 118/177] pygame_.py : appease isort and black --- bapsf_motion/gui/configure/pygame_.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/bapsf_motion/gui/configure/pygame_.py b/bapsf_motion/gui/configure/pygame_.py index df16174b..3df05e6f 100644 --- a/bapsf_motion/gui/configure/pygame_.py +++ b/bapsf_motion/gui/configure/pygame_.py @@ -9,16 +9,11 @@ # ensure joystick events are monitored when the pygame window # is not in focus ... this needs to be done before importing pygame -os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" +os.environ["SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"] = "1" # noqa import pygame # noqa -from PySide6.QtCore import ( - QObject, - QRunnable, - Signal, - Slot, -) +from PySide6.QtCore import QObject, QRunnable, Signal, Slot from bapsf_motion.gui.configure.helpers import gui_logger From 52708acf8616f8b055f7f913854529c8148cfcd9 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 18:30:16 -0700 Subject: [PATCH 119/177] AxisControlWidget: add annotations and clarifying comments --- bapsf_motion/gui/configure/controllers.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 2291b6f9..9ad1e6c6 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -64,8 +64,8 @@ class AxisControlWidget(QWidget): def __init__( self, - axis_display_mode="interactive", - parent=None, + axis_display_mode: Literal["interactive", "readonly"] = "interactive", + parent: QWidget | None = None, ): super().__init__(parent) @@ -74,11 +74,14 @@ def __init__( self._mg = None self._axis_index = None + # Configure display update timer + # - to update widgets during a motor movement self._update_display_interval = 250 # in msec self._update_display_timer = QTimer() self._update_display_timer.setSingleShot(True) self._display_timer_issue_new_single_shot = False + # Configure display interactive-ness if axis_display_mode not in ("interactive", "readonly"): self._logger.info( f"Forcing display mode of {self.__class__.__name__} to be" From e341d46b4277965e176dab20026d1e5142cd452e Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 18:31:36 -0700 Subject: [PATCH 120/177] AxisControlWidget: move some widget instantiation into dedicated methods --- bapsf_motion/gui/configure/controllers.py | 94 +++++++++++++---------- 1 file changed, 54 insertions(+), 40 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 9ad1e6c6..e9ebf43e 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -31,7 +31,7 @@ QVBoxLayout, QWidget, ) -from typing import List, TYPE_CHECKING +from typing import List, Literal, TYPE_CHECKING from bapsf_motion.actors import Axis, Drive, MotionGroup from bapsf_motion.gui.configure.helpers import gui_logger @@ -94,45 +94,14 @@ def __init__( self.setFixedWidth(120) - # Define BUTTONS - _btn = IconButton(icon_name_dict["arrow-up"], parent=self) - _btn.setIconSize(42) - self.jog_forward_btn = _btn - - _btn = IconButton(icon_name_dict["arrow-down"], parent=self) - _btn.setIconSize(42) - self.jog_backward_btn = _btn - - _btn = ValidButton("FWD LIMIT", parent=self) - _btn.update_style_sheet( - {"background-color": "rgb(255, 95, 95)"}, - action="checked", - ) - self.limit_fwd_btn = _btn - - _btn = ValidButton("BWD LIMIT", parent=self) - _btn.update_style_sheet( - {"background-color": "rgb(255, 95, 95)"}, - action="checked", - ) - self.limit_bwd_btn = _btn - - _btn = StyleButton("HOME", parent=self) - _btn.setEnabled(False) - self.home_btn = _btn - self.home_btn.setHidden(True) - - _btn = ZeroButton("ZERO", parent=self) - self.zero_btn = _btn - - _btn = EnableIndicator(parent=self) - font = self.font() - font.setPointSize(8) - font.setBold(True) - _btn.setFont(font) - _btn.setFixedHeight(24) - _btn.setFixedWidth(70) - self.enable_btn = _btn + # Define WIDGETS + self.enable_btn = self._init_enable_btn() + self.home_btn = self._init_home_btn() + self.jog_forward_btn = self._init_jog_forward_btn() + self.jog_backward_btn = self._init_jog_backward_btn() + self.limit_fwd_btn = self._init_limit_fwd_btn() + self.limit_bwd_btn = self._init_limit_bwd_btn() + self.zero_btn = self._init_zero_btn() # Define TEXT WIDGETS _txt = QLabel("Name", parent=self) @@ -355,6 +324,51 @@ def _define_encoder_label_layout(self): return layout + def _init_enable_btn(self): + _btn = EnableIndicator(parent=self) + font = self.font() + font.setPointSize(8) + font.setBold(True) + _btn.setFont(font) + _btn.setFixedHeight(24) + _btn.setFixedWidth(70) + return _btn + + def _init_home_btn(self): + _btn = StyleButton("HOME", parent=self) + _btn.setEnabled(False) + _btn.setVisible(False) + return _btn + + def _init_jog_forward_btn(self): + _btn = IconButton(icon_name_dict["arrow-up"], parent=self) + _btn.setIconSize(42) + return _btn + + def _init_jog_backward_btn(self): + _btn = IconButton(icon_name_dict["arrow-down"], parent=self) + _btn.setIconSize(42) + return _btn + + def _init_limit_fwd_btn(self): + _btn = ValidButton("FWD LIMIT", parent=self) + _btn.update_style_sheet( + {"background-color": "rgb(255, 95, 95)"}, + action="checked", + ) + return _btn + + def _init_limit_bwd_btn(self): + _btn = ValidButton("BWD LIMIT", parent=self) + _btn.update_style_sheet( + {"background-color": "rgb(255, 95, 95)"}, + action="checked", + ) + return _btn + + def _init_zero_btn(self): + return ZeroButton("ZERO", parent=self) + @property def logger(self) -> logging.Logger: return self._logger From e86008717693862f50113ee6183700501f208ece Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 18:43:38 -0700 Subject: [PATCH 121/177] AxisControlWidget: move remaining widget instantiation into dedicated methods --- bapsf_motion/gui/configure/controllers.py | 156 ++++++++++++---------- 1 file changed, 83 insertions(+), 73 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index e9ebf43e..923030e9 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -95,78 +95,22 @@ def __init__( self.setFixedWidth(120) # Define WIDGETS + self.axis_name_label = self._init_axis_name_label() self.enable_btn = self._init_enable_btn() + self.encoder_label = self._init_encoder_label() + self.encoder_label_icon = self._init_encoder_label_icon() self.home_btn = self._init_home_btn() - self.jog_forward_btn = self._init_jog_forward_btn() self.jog_backward_btn = self._init_jog_backward_btn() - self.limit_fwd_btn = self._init_limit_fwd_btn() + self.jog_delta_label = self._init_jog_delta_label() + self.jog_forward_btn = self._init_jog_forward_btn() self.limit_bwd_btn = self._init_limit_bwd_btn() + self.limit_fwd_btn = self._init_limit_fwd_btn() + self.position_label = self._init_position_label() + self.target_position_label = self._init_target_position_label() self.zero_btn = self._init_zero_btn() - # Define TEXT WIDGETS - _txt = QLabel("Name", parent=self) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setFixedHeight(18) - self.axis_name_label = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setReadOnly(True) - _txt.setToolTip("Motor Position") - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - self.position_label = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - _txt.setReadOnly(True) - _txt.setToolTip( - "Encoder read position.\n\n If different than motor position, " - "then the motor is likely slipping / stalling." - ) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - self.encoder_label = _txt - - _txt = QLabel("E", parent=self) - _txt.setObjectName("encoder_icon") - _txt.setStyleSheet(""" - QLabel#encoder_icon { - color: grey; - padding: 2px; - } - """) - font = _txt.font() - font.setPointSize(8) - font.setBold(True) - _txt.setFont(font) - _txt.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction) - self.encoder_label_icon = _txt - - _txt = QLineEdit("", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setValidator(QDoubleValidator(decimals=2)) - self.target_position_label = _txt - - _txt = QLineEdit("0", parent=self) - _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) - font = _txt.font() - font.setPointSize(14) - _txt.setFont(font) - _txt.setValidator(QDoubleValidator(decimals=2)) - self.jog_delta_label = _txt - - # Define ADVANCED WIDGETS - self.mspace_warning_dialog = None + # Retrieve Warning Dialogs from Parent if hasattr(parent, "mspace_warning_dialog"): self.mspace_warning_dialog = parent.mspace_warning_dialog @@ -324,6 +268,15 @@ def _define_encoder_label_layout(self): return layout + def _init_axis_name_label(self): + _txt = QLabel("Name", parent=self) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setFixedHeight(18) + return _txt + def _init_enable_btn(self): _btn = EnableIndicator(parent=self) font = self.font() @@ -334,38 +287,95 @@ def _init_enable_btn(self): _btn.setFixedWidth(70) return _btn + def _init_encoder_label(self): + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setReadOnly(True) + _txt.setToolTip( + "Encoder read position.\n\n If different than motor position, " + "then the motor is likely slipping / stalling." + ) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + return _txt + + def _init_encoder_label_icon(self): + _txt = QLabel("E", parent=self) + _txt.setObjectName("encoder_icon") + _txt.setStyleSheet(""" + QLabel#encoder_icon { + color: grey; + padding: 2px; + } + """) + font = _txt.font() + font.setPointSize(8) + font.setBold(True) + _txt.setFont(font) + _txt.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction) + return _txt + def _init_home_btn(self): _btn = StyleButton("HOME", parent=self) _btn.setEnabled(False) _btn.setVisible(False) return _btn - def _init_jog_forward_btn(self): - _btn = IconButton(icon_name_dict["arrow-up"], parent=self) + def _init_jog_backward_btn(self): + _btn = IconButton(icon_name_dict["arrow-down"], parent=self) _btn.setIconSize(42) return _btn - def _init_jog_backward_btn(self): - _btn = IconButton(icon_name_dict["arrow-down"], parent=self) + def _init_jog_delta_label(self): + _txt = QLineEdit("0", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setValidator(QDoubleValidator(decimals=2)) + return _txt + + def _init_jog_forward_btn(self): + _btn = IconButton(icon_name_dict["arrow-up"], parent=self) _btn.setIconSize(42) return _btn - def _init_limit_fwd_btn(self): - _btn = ValidButton("FWD LIMIT", parent=self) + def _init_limit_bwd_btn(self): + _btn = ValidButton("BWD LIMIT", parent=self) _btn.update_style_sheet( {"background-color": "rgb(255, 95, 95)"}, action="checked", ) return _btn - def _init_limit_bwd_btn(self): - _btn = ValidButton("BWD LIMIT", parent=self) + def _init_limit_fwd_btn(self): + _btn = ValidButton("FWD LIMIT", parent=self) _btn.update_style_sheet( {"background-color": "rgb(255, 95, 95)"}, action="checked", ) return _btn + def _init_position_label(self): + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + _txt.setReadOnly(True) + _txt.setToolTip("Motor Position") + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + return _txt + + def _init_target_position_label(self): + _txt = QLineEdit("", parent=self) + _txt.setAlignment(Qt.AlignmentFlag.AlignCenter) + font = _txt.font() + font.setPointSize(14) + _txt.setFont(font) + _txt.setValidator(QDoubleValidator(decimals=2)) + return _txt + def _init_zero_btn(self): return ZeroButton("ZERO", parent=self) From 7eb01b07ef406339ff2be0a66002a0909a7db7c5 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 18:44:13 -0700 Subject: [PATCH 122/177] AxisControlWidget: message box annotations --- bapsf_motion/gui/configure/controllers.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 923030e9..476ed5b4 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -49,7 +49,10 @@ from bapsf_motion.utils import units as u if TYPE_CHECKING: - from bapsf_motion.gui.configure.message_boxes import LostConnectionMessageBox + from bapsf_motion.gui.configure.message_boxes import ( + LostConnectionMessageBox, + MSpaceMessageBox, + ) class AxisControlWidget(QWidget): @@ -109,8 +112,8 @@ def __init__( self.target_position_label = self._init_target_position_label() self.zero_btn = self._init_zero_btn() - self.mspace_warning_dialog = None # Retrieve Warning Dialogs from Parent + self.mspace_warning_dialog = None # type: MSpaceMessageBox | None if hasattr(parent, "mspace_warning_dialog"): self.mspace_warning_dialog = parent.mspace_warning_dialog From a4ec4e7303d210ec7c54dd889bd2a151a90d9c08 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 18:44:46 -0700 Subject: [PATCH 123/177] AxisControlWidget: collect widget layout definition code-blocks --- bapsf_motion/gui/configure/controllers.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 476ed5b4..b59a5199 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -95,8 +95,6 @@ def __init__( True if axis_display_mode == "interactive" else False ) - self.setFixedWidth(120) - # Define WIDGETS self.axis_name_label = self._init_axis_name_label() self.enable_btn = self._init_enable_btn() @@ -121,6 +119,7 @@ def __init__( if hasattr(parent, "lost_connection_dialog"): self.lost_connection_dialog = parent.lost_connection_dialog + self.setFixedWidth(120) self.setLayout(self._define_layout()) self._connect_signals() From 42d559b3da4687a6b33d3206ff7ae52bd7309445 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:06:43 -0700 Subject: [PATCH 124/177] add some annotations --- bapsf_motion/gui/configure/controllers.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index b59a5199..b7b8c49f 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -158,7 +158,7 @@ def _define_layout(self): return layout - def _define_interactive_layout(self, layout: QVBoxLayout = None): + def _define_interactive_layout(self, layout: QVBoxLayout | None = None): if layout is None: layout = QVBoxLayout() @@ -186,7 +186,7 @@ def _define_interactive_layout(self, layout: QVBoxLayout = None): return layout - def _define_readonly_layout(self, layout: QVBoxLayout = None): + def _define_readonly_layout(self, layout: QVBoxLayout | None = None): if layout is None: layout = QVBoxLayout() @@ -732,7 +732,11 @@ class DriveBaseController(QWidget): zeroDrive = Signal() targetPositionChanged = Signal(list) - def __init__(self, axis_display_mode="interactive", parent=None): + def __init__( + self, + axis_display_mode: Literal["interactive", "readonly"] = "interactive", + parent: QWidget | None = None, + ): # axis_display_mode == "interactive" or "readonly" super().__init__(parent=parent) @@ -1204,6 +1208,8 @@ def enable_motion_buttons(self): class DriveGameController(DriveBaseController): def __init__(self, parent=None): + self._pygame_joystick_runner = None # type: PyGameJoystickRunner | None + super().__init__(axis_display_mode="readonly", parent=parent) def _connect_signals(self): @@ -1216,7 +1222,6 @@ def _connect_signals(self): ) def _initialize_widgets(self): - self._pygame_joystick_runner = None # type: PyGameJoystickRunner | None self._thread_pool = QThreadPool(parent=self) # BUTTON WIDGETS From 6be887e79d70ff6e528cc2cd2269964b8fbd3c21 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:10:23 -0700 Subject: [PATCH 125/177] use direct isinstance() of an actor class instead of checking for None --- bapsf_motion/gui/configure/controllers.py | 64 +++++++++++++---------- 1 file changed, 37 insertions(+), 27 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index b7b8c49f..d5b5f79e 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -395,10 +395,18 @@ def axis_index(self) -> int: @property def axis(self) -> Axis | None: - if self.mg is None or self.axis_index is None: + if ( + not isinstance(self.mg, MotionGroup) + or not isinstance(self.mg.drive, Drive) + or self.axis_index is None + ): return None - return self.mg.drive.axes[self.axis_index] + axis = self.mg.drive.axes[self.axis_index] + if not isinstance(axis, Axis): + return None + + return axis @property def encoder(self) -> u.Quantity: @@ -576,9 +584,11 @@ def _zero_axis(self): self.logger.info(f"Setting zero of axis {self.axis_index}") self.mg.set_zero(axis=self.axis_index) - def link_axis(self, mg: MotionGroup, ax_index: int): + def link_axis(self, mg: MotionGroup | None, ax_index: int): if ( - not isinstance(ax_index, int) + not isinstance(mg, MotionGroup) + or not isinstance(mg.drive, Drive) + or not isinstance(ax_index, int) or ax_index < 0 or ax_index >= len(mg.drive.axes) ): @@ -586,7 +596,7 @@ def link_axis(self, mg: MotionGroup, ax_index: int): return axis = mg.drive.axes[ax_index] - if self.axis is not None and self.axis is axis: + if isinstance(self.axis, Axis) and self.axis is axis: pass else: self.unlink_axis() @@ -594,42 +604,42 @@ def link_axis(self, mg: MotionGroup, ax_index: int): self._mg = mg self._axis_index = ax_index - self.axis_name_label.setText(self.axis.name) + axis = self.axis + if not isinstance(axis, Axis): + self.logger.error("Linking axis failed.") + return + + self.axis_name_label.setText(axis.name) # connect motor SimpleSignals - self.axis.motor.signals.connection_established.connect( + axis.motor.signals.connection_established.connect( self._emit_connection_established ) - self.axis.motor.signals.connection_lost.connect(self._emit_connection_lost) - self.axis.motor.signals.status_changed.connect(self.update_display_of_axis_status) - self.axis.motor.signals.status_changed.connect(self.axisStatusChanged.emit) - self.axis.motor.signals.movement_started.connect(self._emit_movement_started) - self.axis.motor.signals.movement_finished.connect(self._emit_movement_finished) - self.axis.motor.signals.movement_finished.connect( - self.update_display_of_axis_status - ) + axis.motor.signals.connection_lost.connect(self._emit_connection_lost) + axis.motor.signals.status_changed.connect(self.update_display_of_axis_status) + axis.motor.signals.status_changed.connect(self.axisStatusChanged.emit) + axis.motor.signals.movement_started.connect(self._emit_movement_started) + axis.motor.signals.movement_finished.connect(self._emit_movement_finished) + axis.motor.signals.movement_finished.connect(self.update_display_of_axis_status) self.update_display_of_axis_status() self.axisLinked.emit() def unlink_axis(self): - if self.axis is not None: + axis = self.axis + if isinstance(axis, Axis): # disconnect all motor SimpleSignals - self.axis.motor.signals.connection_established.disconnect( + axis.motor.signals.connection_established.disconnect( self._emit_connection_established ) - self.axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) - self.axis.motor.signals.status_changed.disconnect( + axis.motor.signals.connection_lost.disconnect(self._emit_connection_lost) + axis.motor.signals.status_changed.disconnect( self.update_display_of_axis_status ) - self.axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) - self.axis.motor.signals.movement_started.disconnect( - self._emit_movement_started - ) - self.axis.motor.signals.movement_finished.disconnect( - self._emit_movement_finished - ) - self.axis.motor.signals.movement_finished.disconnect( + axis.motor.signals.status_changed.disconnect(self.axisStatusChanged.emit) + axis.motor.signals.movement_started.disconnect(self._emit_movement_started) + axis.motor.signals.movement_finished.disconnect(self._emit_movement_finished) + axis.motor.signals.movement_finished.disconnect( self.update_display_of_axis_status ) From 027460d1ff57a9fcc8732ddabce1505e559e8fe2 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:10:38 -0700 Subject: [PATCH 126/177] cleanup vestige code --- bapsf_motion/gui/configure/controllers.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index d5b5f79e..7d99a246 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -908,8 +908,6 @@ def update_all_axis_displays(self): for acw in self._axis_control_widgets: if acw.isHidden(): continue - # elif acw.axis.is_moving: - # continue acw.update_display_of_axis_status() From df0a22faa8858c2dd43bd484c8291575738ccedd Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:10:54 -0700 Subject: [PATCH 127/177] better handle joystick selection --- bapsf_motion/gui/configure/controllers.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 7d99a246..133dbf1a 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -1401,7 +1401,12 @@ def connect_controller(self): if isinstance(self._pygame_joystick_runner, PyGameJoystickRunner): self.disconnect_controller() - self._pygame_joystick_runner = PyGameJoystickRunner(self.joystick) + selected_joystick = self.joystick + if not isinstance(selected_joystick, pygame.joystick.JoystickType): + self.logger.warning("Selected joystick not found.") + return + + self._pygame_joystick_runner = PyGameJoystickRunner(selected_joystick) self._pygame_joystick_runner.signals.joystickConnected.connect( self._update_connect_led From e4408111c3ca278814a433b9e338bae22dfc50bb Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:19:08 -0700 Subject: [PATCH 128/177] Motor.config handle if speed is an AckFlags from the motor not being connected --- bapsf_motion/actors/motor_.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/actors/motor_.py b/bapsf_motion/actors/motor_.py index a09edc31..bc6735c8 100644 --- a/bapsf_motion/actors/motor_.py +++ b/bapsf_motion/actors/motor_.py @@ -1009,7 +1009,11 @@ def config(self) -> Dict[str, Any]: speed = self.motor["speed"] if isinstance(speed, u.Quantity): speed = speed.value - speed = float(speed) + try: + speed = float(speed) + except TypeError: + # Motor is likely connected and the stored value is an AckFlags + speed = 0.0 return { "name": self.name, From e4156c3d3026dc69ed7c3e73c6e5c37f42d65d47 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:19:25 -0700 Subject: [PATCH 129/177] add QCloseEvent annotation --- bapsf_motion/gui/configure/controllers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index 133dbf1a..ae40cd21 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -19,7 +19,7 @@ from abc import abstractmethod from PySide6.QtCore import Qt, QThreadPool, QTimer, Signal, Slot -from PySide6.QtGui import QDoubleValidator, QFont +from PySide6.QtGui import QDoubleValidator, QFont, QCloseEvent from PySide6.QtWidgets import ( QComboBox, QGridLayout, @@ -709,7 +709,7 @@ def disable_motion_buttons(self): self.jog_backward_btn.setEnabled(False) self.enable_btn.setEnabled(False) - def closeEvent(self, event): + def closeEvent(self, event: QCloseEvent): self.logger.info("Closing AxisControlWidget") if isinstance(self.axis, Axis): From bcd752866a1953ad1056b2ea0a91253191596bb6 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 19:48:51 -0700 Subject: [PATCH 130/177] replace uses of Union[] with pipe | --- bapsf_motion/gui/configure/motion_builder_overlay.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index a06f1664..86d698b3 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -27,7 +27,7 @@ QVBoxLayout, QWidget, ) -from typing import Any, Dict, Optional, Union +from typing import Any, Dict, Optional from bapsf_motion.actors import MotionGroup from bapsf_motion.gui.configure import motion_group_widget as mgw @@ -104,13 +104,13 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): # SET UP LEFT WIDGETS (i.e. list boxes) - self.exclusion_list_box = None # type: Union[QListWidget, None] + self.exclusion_list_box = None # type: QListWidget | None self.add_ex_btn = None self.remove_ex_btn = None self.edit_ex_btn = None self._initialize_exclusion_list_layout_widgets() - self.layer_list_box = None # type: Union[QListWidget, None] + self.layer_list_box = None # type: QListWidget | None self.add_ly_btn = None self.remove_ly_btn = None self.edit_ly_btn = None @@ -274,7 +274,7 @@ def axis_names(self): return self.mg.drive.anames @property - def mb(self) -> Union[MotionBuilder, None]: + def mb(self) -> MotionBuilder| None: if ( self._mb is None and isinstance(self.mg, MotionGroup) From 682d4b096c6c7f905e9c84cc94ee125c2972a54f Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:04:39 -0700 Subject: [PATCH 131/177] replace uses of Union[] with pipe | --- bapsf_motion/gui/configure/motion_space_display.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 366cfb63..c80e27eb 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -13,8 +13,8 @@ from PySide6.QtCore import QTimer, Signal, Slot from PySide6.QtGui import QMouseEvent -from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout -from typing import List, Union +from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout, QWidget +from typing import List from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.motion_builder import MotionBuilder @@ -46,7 +46,7 @@ class MotionSpaceDisplay(QFrame): "insertion_point", ] - def __init__(self, mb: MotionBuilder = None, parent=None): + def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = None): super().__init__(parent=parent) self._logger = logging.getLogger(f"{gui_logger.name}.MSD") @@ -58,9 +58,7 @@ def __init__(self, mb: MotionBuilder = None, parent=None): self._display_probe = True self._animate_payload = None - self._motionlist_plot_names = None # type: Union[None, List[str]] - - self._motionlist_plot_names = None # type: Union[None, List[str]] + self._motionlist_plot_names = None # type: List[str] | None self.setStyleSheet(""" MotionSpaceDisplay { @@ -111,7 +109,7 @@ def logger(self) -> logging.Logger: return self._logger @property - def mb(self) -> Union[MotionBuilder, None]: + def mb(self) -> MotionBuilder | None: return self._mb @property @@ -375,7 +373,7 @@ def on_pick(self, event: PickEvent): self.logger.info(f"target position = {target_position}") self.targetPositionSelected.emit(target_position) - def link_motion_builder(self, mb: Union[MotionBuilder, None]): + def link_motion_builder(self, mb: MotionBuilder | None): self.logger.info(f"Linking Motion Builder {mb}") self.blockSignals(True) From 6ff83b0a32d0c07b02e62573a73fb141b600b779 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:04:50 -0700 Subject: [PATCH 132/177] add noqa --- bapsf_motion/gui/configure/motion_space_display.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index c80e27eb..ba1e95c5 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -27,7 +27,7 @@ from matplotlib.backends.backend_qtagg import ( # noqa NavigationToolbar2QT as NavigationToolbar, ) -from matplotlib.collections import PathCollection +from matplotlib.collections import PathCollection # noqa class MotionSpaceDisplay(QFrame): From 0eccd3315a6a72f3708f0d1986078cef36085b2e Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:48:18 -0700 Subject: [PATCH 133/177] move motion builder validation into dedicated method _init_motion_builder() --- bapsf_motion/gui/configure/motion_space_display.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index ba1e95c5..d2051027 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -50,9 +50,8 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non super().__init__(parent=parent) self._logger = logging.getLogger(f"{gui_logger.name}.MSD") + self._mb = self._init_motion_builder(mb) - self._mb = None - self.link_motion_builder(mb) self._display_position = True self._display_target_position = True self._display_probe = True @@ -104,6 +103,16 @@ def _define_layout(self): return layout + @staticmethod + def _init_motion_builder(mb: MotionBuilder | None) -> MotionBuilder | None: + if mb is not None and not isinstance(mb, MotionBuilder): + raise TypeError( + "Argument 'mb' must be None or an instance of MotionBuilder, " + f"got type {type(mb)} instead." + ) + + return mb + @property def logger(self) -> logging.Logger: return self._logger From 795ba7feb68a393b527cc8ccebf7cdc0dda96772 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:50:56 -0700 Subject: [PATCH 134/177] reorganized / collect attribute instantiation --- .../gui/configure/motion_space_display.py | 36 +++++++++++++++---- 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index d2051027..aa240cb9 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -52,11 +52,37 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self._logger = logging.getLogger(f"{gui_logger.name}.MSD") self._mb = self._init_motion_builder(mb) + # Initialize plotting control attributes + # + # _display_position : bool + # If True, plot the current position of the probe drive. + # _display_target_position : bool + # If True, plot the target position. + # _display_probe : bool + # If True, add to the plot a representation of the probe [shaft] + # _animate_payload : dict + # A dictionary payload when animating the motion list. + # "finished" - bool - has the animation finsihed + # "timer" - QTimer - timer instance + # "delay" - int - timer interval + # "index" - int - next motionlist index to animate to + # "index_step" - int - delta / step between animated index + # _motionlist_plot_names : list[str] + # list of motionlist names ... these are the same as the + # MotionBuilder layer names + # _draw_all : True + # If True, then (re)draw everything. If False, then only redraw + # the artists that are marked animated=True. (Note this is + # matplotlib's animated, and not our motion list animateion.) + # _cid_on_draw : + # matplotlib call back ID for the "draw_event" + # _mpl_pick_callback_id : + # matplotlib call back ID for the "pick_event" + # self._display_position = True self._display_target_position = True self._display_probe = True self._animate_payload = None - self._motionlist_plot_names = None # type: List[str] | None self.setStyleSheet(""" @@ -68,6 +94,9 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non } """) self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) + self._draw_all = True + self._cid_on_draw = None + self._mpl_pick_callback_id = None self.mpl_canvas = FigureCanvas() self.mpl_canvas.setParent(self) @@ -75,11 +104,6 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self.mpl_toolbar = NavigationToolbar(self.mpl_canvas, parent=self) self.setLayout(self._define_layout()) - - self._cid_on_draw = None - self._draw_all = True - - self._mpl_pick_callback_id = None self._connect_signals() def _connect_signals(self): From 948797b88bfe840b65a52ea2db5034a379f3ad1c Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:51:58 -0700 Subject: [PATCH 135/177] move widget instantiation into dedicated methods --- .../gui/configure/motion_space_display.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index aa240cb9..b83c4b19 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -98,10 +98,9 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self._cid_on_draw = None self._mpl_pick_callback_id = None - self.mpl_canvas = FigureCanvas() - self.mpl_canvas.setParent(self) - - self.mpl_toolbar = NavigationToolbar(self.mpl_canvas, parent=self) + # Define WIDGETS + self.mpl_canvas = self._init_mpl_canvas() + self.mpl_toolbar = self._init_mpl_toolbar() self.setLayout(self._define_layout()) self._connect_signals() @@ -137,6 +136,15 @@ def _init_motion_builder(mb: MotionBuilder | None) -> MotionBuilder | None: return mb + def _init_mpl_canvas(self): + canvas = FigureCanvas() + canvas.setParent(self) + return canvas + + def _init_mpl_toolbar(self): + toolbar = NavigationToolbar(self.mpl_canvas, parent=self) + return toolbar + @property def logger(self) -> logging.Logger: return self._logger From 0fc75c607842c6b7bfe7d85057014de9a02e0d06 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:52:37 -0700 Subject: [PATCH 136/177] put self widget configuration into dedicated method _init_self() --- .../gui/configure/motion_space_display.py | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index b83c4b19..61c01bd3 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -84,16 +84,6 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self._display_probe = True self._animate_payload = None self._motionlist_plot_names = None # type: List[str] | None - - self.setStyleSheet(""" - MotionSpaceDisplay { - border: 2px solid rgb(125, 125, 125); - border-radius: 5px; - padding: 0px; - margin: 0px; - } - """) - self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) self._draw_all = True self._cid_on_draw = None self._mpl_pick_callback_id = None @@ -102,6 +92,7 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self.mpl_canvas = self._init_mpl_canvas() self.mpl_toolbar = self._init_mpl_toolbar() + self._init_self() self.setLayout(self._define_layout()) self._connect_signals() @@ -145,6 +136,17 @@ def _init_mpl_toolbar(self): toolbar = NavigationToolbar(self.mpl_canvas, parent=self) return toolbar + def _init_self(self): + self.setStyleSheet(""" + MotionSpaceDisplay { + border: 2px solid rgb(125, 125, 125); + border-radius: 5px; + padding: 0px; + margin: 0px; + } + """) + self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) + @property def logger(self) -> logging.Logger: return self._logger From 372f2341f7056ababe9302528232e2bbe2271818 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:55:35 -0700 Subject: [PATCH 137/177] put import behind typing.TYPE_CHECKING --- bapsf_motion/gui/configure/motion_builder_overlay.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index 86d698b3..dc453d37 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -27,10 +27,9 @@ QVBoxLayout, QWidget, ) -from typing import Any, Dict, Optional +from typing import Any, Dict, Optional, TYPE_CHECKING, Union from bapsf_motion.actors import MotionGroup -from bapsf_motion.gui.configure import motion_group_widget as mgw from bapsf_motion.gui.configure.bases import _ConfigOverlay from bapsf_motion.gui.configure.helpers import read_parameter_hints from bapsf_motion.gui.configure.motion_space_display import MotionSpaceDisplay @@ -50,6 +49,9 @@ from bapsf_motion.utils import _deepcopy_dict from bapsf_motion.utils import units as u +if TYPE_CHECKING: + from bapsf_motion.gui.configure import motion_group_widget as mgw + # import of qtawesome must happen after the PySide6 imports import qtawesome as qta # noqa @@ -62,7 +64,7 @@ class MotionBuilderConfigOverlay(_ConfigOverlay): layer_registry = layer_registry exclusion_registry = exclusion_registry - def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget" = None): + def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): super().__init__(mg, parent) self._mb = None From a63b2665b6e3194e9df1ff0ec7adf85b38f7f75f Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Thu, 11 Jun 2026 22:56:31 -0700 Subject: [PATCH 138/177] put poseidon test TOMLs into examples --- bapsf_motion/examples/poseidon_mg_test.toml | 50 +++++++++++++++++++ bapsf_motion/examples/poseidon_test.toml | 54 +++++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 bapsf_motion/examples/poseidon_mg_test.toml create mode 100644 bapsf_motion/examples/poseidon_test.toml diff --git a/bapsf_motion/examples/poseidon_mg_test.toml b/bapsf_motion/examples/poseidon_mg_test.toml new file mode 100644 index 00000000..8b021f4a --- /dev/null +++ b/bapsf_motion/examples/poseidon_mg_test.toml @@ -0,0 +1,50 @@ +[mg] +name = "Poseidon Test" + +[mg.drive] +name = "Poseidon" +axes.0.name = "X" +axes.0.ip = "192.168.17.135" +axes.0.units = "cm" +axes.0.units_per_rev = 0.254 +axes.0.motor_settings.current = 0.8 +axes.0.motor_settings.limit_mode = 2 +axes.0.motor_settings.speed = 4.0 +axes.1.name = "Y" +axes.1.ip = "192.168.17.137" +axes.1.units = "cm" +axes.1.units_per_rev = 0.254 +axes.1.motor_settings.current = 1.0 +axes.1.motor_settings.limit_mode = 2 +axes.1.motor_settings.speed = 4.0 +axes.2.name = "Z" +axes.2.ip = "192.168.17.134" +axes.2.units = "cm" +axes.2.units_per_rev = 0.254 +axes.2.motor_settings.current = 0.8 +axes.2.motor_settings.limit_mode = 2 +axes.2.motor_settings.speed = 4.0 + +[mg.motion_builder] +space.0.label = "X" +space.0.range = [-55, 55] +space.0.num = 111 +space.1.label = "Y" +space.1.range = [-55, 55] +space.1.num = 111 +space.2.label = "Z" +space.2.range = [-30, 30] +space.2.num = 61 +layers.0.type = "grid_CNStep" +layers.0.center = [0, 0, 0] +layers.0.npoints = [1, 1, 1] +layers.0.step_size = [1, 1, 1] + +[mg.transform] +type = "lapd_xyz" +pivot_to_center = 58.771 +pivot_to_xzcross = 142.4804 # 0.81" + 54.9cm + 0.75" + 79.3cm + 1.7" +probe_axis_offset = 30.47 # 0.5" + 15.1cm + 5.4cm + 8.7cm +table_pivot_to_zlead_screw = 12.488 # 0.5" + 2.5cm + 4.4cm + 1.7" +drive_polarity = [1, -1, 1] +mspace_polarity = [-1, 1, -1] diff --git a/bapsf_motion/examples/poseidon_test.toml b/bapsf_motion/examples/poseidon_test.toml new file mode 100644 index 00000000..d9b5f9b9 --- /dev/null +++ b/bapsf_motion/examples/poseidon_test.toml @@ -0,0 +1,54 @@ +[run] +name = "poseidon-test" +date = "2026-06-27 21:48 UTC" + +[run.motion_group.0] +name = "Poseidon Test" + +[run.motion_group.0.drive] +name = "Poseidon" +axes.0.name = "X" +axes.0.ip = "192.168.17.135" +axes.0.units = "cm" +axes.0.units_per_rev = 0.254 +axes.0.motor_settings.current = 0.8 +axes.0.motor_settings.limit_mode = 2 +axes.0.motor_settings.speed = 4.0 +axes.1.name = "Y" +axes.1.ip = "192.168.17.137" +axes.1.units = "cm" +axes.1.units_per_rev = 0.254 +axes.1.motor_settings.current = 1.0 +axes.1.motor_settings.limit_mode = 2 +axes.1.motor_settings.speed = 4.0 +axes.2.name = "Z" +axes.2.ip = "192.168.17.134" +axes.2.units = "cm" +axes.2.units_per_rev = 0.254 +axes.2.motor_settings.current = 0.8 +axes.2.motor_settings.limit_mode = 2 +axes.2.motor_settings.speed = 4.0 + +[run.motion_group.0.motion_builder] +space.0.label = "X" +space.0.range = [-55, 55] +space.0.num = 111 +space.1.label = "Y" +space.1.range = [-55, 55] +space.1.num = 111 +space.2.label = "Z" +space.2.range = [-30, 30] +space.2.num = 61 +layers.0.type = "grid_CNStep" +layers.0.center = [0, 0, 0] +layers.0.npoints = [1, 1, 1] +layers.0.step_size = [1, 1, 1] + +[run.motion_group.0.transform] +type = "lapd_xyz" +pivot_to_center = 58.771 +pivot_to_xzcross = 142.4804 # 0.81" + 54.9cm + 0.75" + 79.3cm + 1.7" +probe_axis_offset = 30.47 # 0.5" + 15.1cm + 5.4cm + 8.7cm +table_pivot_to_zlead_screw = 12.488 # 0.5" + 2.5cm + 4.4cm + 1.7" +drive_polarity = [1, -1, 1] +mspace_polarity = [-1, 1, -1] From 5736bbb27fb62a15effb31eca2480412c07392db Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Fri, 12 Jun 2026 13:39:04 -0700 Subject: [PATCH 139/177] cleanup MGWidget.__init__, and put all of the widget instantiation into dedicated methods --- .../gui/configure/motion_group_widget.py | 248 ++++++++++-------- 1 file changed, 143 insertions(+), 105 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 84044a02..30e1cdf0 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -402,137 +402,63 @@ def __init__( self._logger = logging.getLogger(f"{gui_logger.name}.MGW") + # Initialize motion group and motion group config attributes self._mg = None self._mg_index = None - self._mg_config = None if isinstance(mg_config, MotionGroupConfig): self._mg_config = _deepcopy_dict(mg_config) + # Initialize default entries for the dropdowns self._defaults = None if defaults is None else _deepcopy_dict(defaults) + + # Initialized the drive dropdown self._drive_defaults = None self._custom_drive_index = -1 self._build_drive_defaults() - self._transform_defaults = None - self._build_transform_defaults() - + # Initialized the motion builder dropdown self._mb_defaults = None self._custom_mb_index = -1 self._mb_combo_last_index = -1 self._build_mb_defaults() + # Initialized the transform drowpdown + self._transform_defaults = None + self._build_transform_defaults() + + # Initialize the plot update timeer attributes self._update_plot_interval = 200 # in msec self._update_plot_timer = QTimer() self._update_plot_timer.setSingleShot(True) self._plot_timer_issue_new_single_shot = False - # Define TEXT WIDGETS - - _widget = QPlainTextEdit(parent=self) - _widget.setSizePolicy( - QSizePolicy.Policy.Preferred, - QSizePolicy.Policy.Expanding, - ) - _widget.setReadOnly(True) - _widget.font().setPointSize(14) - _widget.font().setFamily("Courier New") - _widget.setMinimumWidth(350) - self.toml_widget = _widget - - _widget = QLineEdit(parent=self) - font = _widget.font() - font.setPointSize(16) - _widget.setFont(font) - _widget.setMinimumWidth(220) - self.ml_name_widget = _widget - - # Define BUTTONS - - _btn = DoneButton("Add / Update", parent=self) - _btn.setEnabled(False) - self.done_btn = _btn - - _btn = DiscardButton(parent=self) - self.discard_btn = _btn - - _icon = QTAIconLabel("mdi.steering", parent=self) - _icon.setFixedSize(32) - _icon.setIconSize(24) - self.drive_label = _icon + # Initialize overlay control attributes + self._overlay_widget = None # type: _ConfigOverlay | None + self._overlay_shown = False - _w = QComboBox(parent=self) - _w.setEditable(False) - font = _w.font() - font.setPointSize(16) - _w.setFont(font) - _w.setSizeAdjustPolicy( - QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon - ) - self._drive_dropdown = _w + # Define WIDGETS + self._drive_dropdown = self._init_drive_dropdown() + self._mb_dropdown = self._init_mb_dropdown() + self._transform_dropdown = self._init_transform_dropdown() + self.discard_btn = self._init_discard_btn() + self.done_btn = self._init_done_btn() + self.drive_btn = self._init_drive_btn() + self.drive_control_widget = self._init_drive_control_widget() + self.drive_label = self._init_drive_label() + self.mb_btn = self._init_mb_btn() + self.mb_label = self._init_mb_label() + self.ml_name_widget = self._init_ml_name_widget() + self.mpl_canvas = self._init_mpl_canvas() + self.toml_widget = self._init_toml_widget() + self.transform_btn = self._init_transform_btn() + self.transform_label = self._init_transform_label() + + # initialize dropdowns self._populate_drive_dropdown() - - _btn = GearValidButton(parent=self) - self.drive_btn = _btn - - _icon.setAlignment(Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignVCenter) - _icon = QTAIconLabel("mdi.motion", parent=self) - _icon.setFixedSize(32) - _icon.setIconSize(24) - self.mb_label = _icon - - _w = QComboBox(parent=self) - _w.setEditable(False) - font = _w.font() - font.setPointSize(16) - _w.setFont(font) - _w.setSizeAdjustPolicy( - QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon - ) - self._mb_dropdown = _w self._populate_mb_dropdown() - - _btn = GearValidButton(parent=self) - _btn.setEnabled(False) - self.mb_btn = _btn - - _icon = QTAIconLabel(icon_name_dict["exchange-alt"], parent=self) - _icon.setFixedSize(32) - _icon.setIconSize(24) - self.transform_label = _icon - - _w = QComboBox(parent=self) - _w.setEditable(False) - font = _w.font() - font.setPointSize(16) - _w.setFont(font) - _w.setSizeAdjustPolicy( - QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon - ) - _w.setIconSize(QSize(20, 20)) - _w.setToolTip( - "Flagged items indicate the base transforms, which are not pre-configured." - ) - _w.setToolTipDuration(30000) - self._transform_dropdown = _w self._populate_transform_dropdown() - _btn = GearValidButton(parent=self) - _btn.setEnabled(False) - self.transform_btn = _btn - - # Define ADVANCED WIDGETS - self._overlay_widget = None # type: _ConfigOverlay | None - self._overlay_shown = False - - self.drive_control_widget = DriveControlWidget(parent=self) - self.drive_control_widget.setEnabled(False) - - self.mpl_canvas = MotionSpaceDisplay(parent=self) - _policy = self.mpl_canvas.sizePolicy() - _policy.setRetainSizeWhenHidden(True) - self.mpl_canvas.setSizePolicy(_policy) - self.setLayout(self._define_layout()) self._connect_signals() @@ -812,6 +738,118 @@ def _define_central_builder_widget(self): _widget.setFixedWidth(335) return _widget + def _init_discard_btn(self): + return DiscardButton(parent=self) + + def _init_done_btn(self): + _btn = DoneButton("Add / Update", parent=self) + _btn.setEnabled(False) + return _btn + + def _init_drive_btn(self): + return GearValidButton(parent=self) + + def _init_drive_control_widget(self): + _w = DriveControlWidget(parent=self) + _w.setEnabled(False) + return _w + + def _init_drive_dropdown(self): + _w = QComboBox(parent=self) + _w.setEditable(False) + font = _w.font() + font.setPointSize(16) + _w.setFont(font) + _w.setSizeAdjustPolicy( + QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon + ) + return _w + + def _init_drive_label(self): + _icon = QTAIconLabel("mdi.steering", parent=self) + _icon.setFixedSize(32) + _icon.setIconSize(24) + _icon.setAlignment(Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignVCenter) + return _icon + + def _init_mb_btn(self): + _btn = GearValidButton(parent=self) + _btn.setEnabled(False) + return _btn + + def _init_mb_dropdown(self): + _w = QComboBox(parent=self) + _w.setEditable(False) + font = _w.font() + font.setPointSize(16) + _w.setFont(font) + _w.setSizeAdjustPolicy( + QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon + ) + return _w + + def _init_mb_label(self): + _icon = QTAIconLabel("mdi.motion", parent=self) + _icon.setFixedSize(32) + _icon.setIconSize(24) + _icon.setAlignment(Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignVCenter) + return _icon + + def _init_ml_name_widget(self): + _widget = QLineEdit(parent=self) + font = _widget.font() + font.setPointSize(16) + _widget.setFont(font) + _widget.setMinimumWidth(220) + return _widget + + def _init_mpl_canvas(self): + canvas = MotionSpaceDisplay(parent=self) + _policy = canvas.sizePolicy() + _policy.setRetainSizeWhenHidden(True) + canvas.setSizePolicy(_policy) + return canvas + + def _init_toml_widget(self): + _widget = QPlainTextEdit(parent=self) + _widget.setSizePolicy( + QSizePolicy.Policy.Preferred, + QSizePolicy.Policy.Expanding, + ) + _widget.setReadOnly(True) + _widget.font().setPointSize(14) + _widget.font().setFamily("Courier New") + _widget.setMinimumWidth(350) + return _widget + + def _init_transform_btn(self): + _btn = GearValidButton(parent=self) + _btn.setEnabled(False) + return _btn + + def _init_transform_dropdown(self): + _w = QComboBox(parent=self) + _w.setEditable(False) + font = _w.font() + font.setPointSize(16) + _w.setFont(font) + _w.setSizeAdjustPolicy( + QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon + ) + _w.setIconSize(QSize(20, 20)) + _w.setToolTip( + "Flagged items indicate the base transforms, which are not pre-configured." + ) + _w.setToolTipDuration(30000) + return _w + + def _init_transform_label(self): + _icon = QTAIconLabel(icon_name_dict["exchange-alt"], parent=self) + _icon.setFixedSize(32) + _icon.setIconSize(24) + _icon.setAlignment(Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignVCenter) + return _icon + def _build_drive_defaults(self) -> List[Tuple[str, Dict[str, Any]]]: # Returned _drive_defaults is a List of Tuple pairs # - 1st Tuple element is the dropdown name From 4bdf7750822d43e887c579506547adbcd948b78e Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Fri, 12 Jun 2026 14:13:41 -0700 Subject: [PATCH 140/177] MGWidget: rename mpl_canvas -> mspace_display --- .../gui/configure/motion_group_widget.py | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 30e1cdf0..2322653a 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -449,7 +449,7 @@ def __init__( self.mb_btn = self._init_mb_btn() self.mb_label = self._init_mb_label() self.ml_name_widget = self._init_ml_name_widget() - self.mpl_canvas = self._init_mpl_canvas() + self.mspace_display = self._init_mspace_display() self.toml_widget = self._init_toml_widget() self.transform_btn = self._init_transform_btn() self.transform_label = self._init_transform_label() @@ -531,13 +531,13 @@ def _connect_signals(self): self._transform_dropdown_new_selection ) - self.mpl_canvas.targetPositionSelected.connect(self._update_target_position) + self.mspace_display.targetPositionSelected.connect(self._update_target_position) self.drive_control_widget.movementStarted.connect(self.disable_config_controls) self.drive_control_widget.movementStopped.connect(self.enable_config_controls) self.drive_control_widget.movementStopped.connect(self._update_position_in_plot) self.drive_control_widget.targetPositionChanged.connect( - self.mpl_canvas.update_target_position_plot + self.mspace_display.update_target_position_plot ) self.drive_control_widget.driveStatusChanged.connect(self.update_position_in_plot) @@ -570,7 +570,7 @@ def _update_position_in_plot(self): position = self.drive_control_widget.position else: position = None - self.mpl_canvas.update_position_plot(position) + self.mspace_display.update_position_plot(position) if self._plot_timer_issue_new_single_shot: # start another single shot if update_position_in_plot() was @@ -606,7 +606,7 @@ def _define_mg_builder_layout(self): layout.addSpacing(8) layout.addWidget(self._define_central_builder_widget()) layout.addSpacing(8) - layout.addWidget(self.mpl_canvas) + layout.addWidget(self.mspace_display) return layout @@ -803,7 +803,7 @@ def _init_ml_name_widget(self): _widget.setMinimumWidth(220) return _widget - def _init_mpl_canvas(self): + def _init_mspace_display(self): canvas = MotionSpaceDisplay(parent=self) _policy = canvas.sizePolicy() _policy.setRetainSizeWhenHidden(True) @@ -1028,7 +1028,7 @@ def _config_changed_handler(self): self._update_mb_dropdown() self._update_transform_dropdown() self._update_toml_widget() - self._update_mpl_canvas_mb() + self._update_mspace_display_mb() # updating the drive control widget should always be the last # step @@ -1502,22 +1502,22 @@ def _update_drive_control_widget(self): self._refresh_drive_control() - def _update_mpl_canvas_mb(self): + def _update_mspace_display_mb(self): if not isinstance(self.mg, MotionGroup) or not isinstance( self.mg.mb, MotionBuilder ): - self.mpl_canvas.unlink_motion_builder() + self.mspace_display.unlink_motion_builder() return - if not isinstance(self.mpl_canvas.mb, MotionBuilder): - self.mpl_canvas.link_motion_builder(self.mg.mb) + if not isinstance(self.mspace_display.mb, MotionBuilder): + self.mspace_display.link_motion_builder(self.mg.mb) return - if dict_equal(self.mg.mb.config, self.mpl_canvas.mb.config): + if dict_equal(self.mg.mb.config, self.mspace_display.mb.config): # canvas already had current motion builder return - self.mpl_canvas.link_motion_builder(self.mg.mb) + self.mspace_display.link_motion_builder(self.mg.mb) @Slot(list) def _update_target_position(self, target_position: List[float]): From d0e91ebc334c65ec52943364fa64b8d0e9a9581d Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Fri, 12 Jun 2026 18:47:33 -0700 Subject: [PATCH 141/177] ensure targetPositionChanged is always emitted with a list and never None --- bapsf_motion/gui/configure/controllers.py | 13 ++++++++----- bapsf_motion/gui/configure/motion_group_widget.py | 2 ++ 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/gui/configure/controllers.py b/bapsf_motion/gui/configure/controllers.py index ae40cd21..15d9a2a8 100644 --- a/bapsf_motion/gui/configure/controllers.py +++ b/bapsf_motion/gui/configure/controllers.py @@ -577,7 +577,10 @@ def _validate_jog_value(self): @Slot() def _validate_target_position_value(self): - self.targetPositionChanged.emit(self.target_position) + target_position = self.target_position + if not isinstance(target_position, list): + target_position = [] + self.targetPositionChanged.emit(target_position) @Slot() def _zero_axis(self): @@ -840,10 +843,10 @@ def target_position(self) -> List[float] | None: @Slot() def _target_position_changed(self, position): self.logger.info(f"DBC target position changed {self.target_position}") - tpos = self.target_position - if tpos is None: - tpos = [] - self.targetPositionChanged.emit(tpos) + target_position = self.target_position + if target_position is None: + target_position = [] + self.targetPositionChanged.emit(target_position) def link_motion_group(self, mg: MotionGroup): if not isinstance(mg, MotionGroup): diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 2322653a..12e3711f 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -1424,6 +1424,8 @@ def _refresh_drive_control(self): self.drive_control_widget.link_motion_group(self.mg) target_position = self.drive_control_widget.target_position + if not isinstance(target_position, list): + target_position = [] self.drive_control_widget.targetPositionChanged.emit(target_position) self._update_position_in_plot() From 861eb2b1c629d4024abaf17349437ff00592e570 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sat, 13 Jun 2026 13:02:16 -0700 Subject: [PATCH 142/177] add CLI flag --debug to bapsf_motion.gui.configure --- bapsf_motion/gui/configure/__init__.py | 33 ++++++++++++++++++++------ 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/bapsf_motion/gui/configure/__init__.py b/bapsf_motion/gui/configure/__init__.py index a478a0ee..82e09368 100644 --- a/bapsf_motion/gui/configure/__init__.py +++ b/bapsf_motion/gui/configure/__init__.py @@ -3,10 +3,12 @@ """ __all__ = ["ConfigureGUI"] + from bapsf_motion.gui.configure.configure_ import ConfigureGUI if __name__ == "__main__": import argparse + import os import pathlib # from PySide6.QtWidgets import QApplication @@ -29,26 +31,43 @@ default=None, type=pathlib.Path, ) + default_debug = ( + "*.debug=true;" + "qt.text.emojisegmenter.debug=false;" + "qt.widgets.showhide.debug=false" + ) + parser.add_argument( + "--debug", + nargs="?", + const=default_debug, + type=str, + default=None, + help=( + "Sets the QT_LOGGING_RULES environment variable. If not " + f"specified, then will default to '{default_debug}'." + ), + ) args = parser.parse_args() + # Hanlde --default-file if args.defaults_file is not None and not args.defaults_file.exists(): args.defaults_file = None elif args.defaults_file is not None: args.defaults_file = args.defaults_file.resolve() + # Hanlde --config-file if args.config_file is not None and not args.config_file.exists(): args.config_file = None elif args.config_file is not None: args.config_file = args.config_file.resolve() - # app = QApplication([]) - # - # window = ConfigureGUI( - # config=args.config_file, - # defaults=args.defaults_file, - # ) - # window.show() + # Hanlde --debug + if args.debug is not None: + os.environ["SHIBOKEN_DEBUG"] = "1" + os.environ["QT_DEBUG_PLUGINS"] = "1" + os.environ["QT_LOGGING_RULES"] = args.debug + # Launch App app = ConfigureApp( [], config=args.config_file, From 15e8fb95bf172215e4589b15a3b11ba14823d74f Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sun, 14 Jun 2026 11:44:27 -0700 Subject: [PATCH 143/177] rename mpl_canvas -> mspace_dispaly --- .../gui/configure/motion_builder_overlay.py | 56 +++++++++---------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index dc453d37..b52c94aa 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -70,7 +70,7 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): self._mb = None self._space_input_widgets = {} # type: Dict[str, Dict[str, QLineEditSpecialized]] - self._mpl_canvas_full_draw = True + self._mspace_display_full_draw = True _parameter_hints = read_parameter_hints() self._parameter_hints_layer = _parameter_hints.pop("layer", None) @@ -122,11 +122,11 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): self._initialize_layer_list_layout_widgets() # SET UP PLOT WIDGET - self.mpl_canvas = MotionSpaceDisplay(parent=self) - self.mpl_canvas.display_position = False - self.mpl_canvas.display_target_position = False + self.mspace_display = MotionSpaceDisplay(parent=self) + self.mspace_display.display_position = False + self.mspace_display.display_target_position = False if isinstance(self.mg, MotionGroup) and isinstance(self.mg.mb, MotionBuilder): - self.mpl_canvas.link_motion_builder(self.mg.mb) + self.mspace_display.link_motion_builder(self.mg.mb) self.animate_ml_widget = QFrame(parent=self) self.animate_ml_widget.setObjectName("animate_ml_controls") @@ -207,21 +207,21 @@ def _connect_signals(self): self.layer_move_up_btn.clicked.connect(self._layer_list_item_move_up) self.layer_move_down_btn.clicked.connect(self._layer_list_item_move_down) - self.mpl_canvas.animateMotionListFinished.connect( + self.mspace_display.animateMotionListFinished.connect( self._animate_motion_list_finished ) - self.mpl_canvas.animateMotionListCleared.connect( + self.mspace_display.animateMotionListCleared.connect( self._animate_motion_list_finished ) - self.mpl_canvas.animateMotionListStarted.connect( + self.mspace_display.animateMotionListStarted.connect( self._animate_motion_list_btn_txt_to_pause ) - self.mpl_canvas.animateMotionListPaused.connect( + self.mspace_display.animateMotionListPaused.connect( self._animate_motion_list_btn_txt_to_animate ) self.animate_ml_btn.clicked.connect(self._animate_motion_list) self.animate_ml_clear_btn.clicked.connect( - self.mpl_canvas.animate_motion_list_clear + self.mspace_display.animate_motion_list_clear ) def _define_layout(self): @@ -358,7 +358,7 @@ def _define_right_area_widget(self): plot_layout = QHBoxLayout() plot_layout.setContentsMargins(0, 0, 0, 0) plot_layout.addLayout(side_control_layout) - plot_layout.addWidget(self.mpl_canvas) + plot_layout.addWidget(self.mspace_display) layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) @@ -960,9 +960,9 @@ def _config_changed_handler(self): def _animate_motion_list(self): _btn_text = self.animate_ml_btn.text().replace("\n", "") if _btn_text == "PAUSE": - self.mpl_canvas.animate_motion_list_pause() + self.mspace_display.animate_motion_list_pause() else: - self.mpl_canvas.animate_motion_list() + self.mspace_display.animate_motion_list() @Slot() def _animate_motion_list_btn_txt_to_animate(self): @@ -1075,7 +1075,7 @@ def _exclusion_remove_from_mb(self): # TODO: remove params_widget if the removed exclusion is currently # populating the params_widget - self._mpl_canvas_full_draw = True + self._mspace_display_full_draw = True self.configChanged.emit() @Slot() @@ -1124,7 +1124,7 @@ def _layer_list_item_move_up(self): layer = self.mb.layers.pop(current_index) # noqa self.mb.layers.insert(move_to_index, layer) self.mb.generate() - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False self.configChanged.emit() self.layer_list_box.setCurrentRow(move_to_index) @@ -1154,7 +1154,7 @@ def _layer_list_item_move_down(self): layer = self.mb.layers.pop(current_index) # noqa self.mb.layers.insert(move_to_index, layer) self.mb.generate() - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False self.configChanged.emit() self.layer_list_box.setCurrentRow(move_to_index) @@ -1203,7 +1203,7 @@ def _layer_remove_from_mb(self): # TODO: remove params_widget if the removed exclusion is currently # populating the params_widget - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False self.configChanged.emit() def _refresh_params_combo_box( @@ -1291,7 +1291,7 @@ def _toggle_layer_to_motionlist_scheme(self): _scheme = "merge" if self.layer_ml_combine_toggle.isChecked() else "sequential" self.logger.info(f"Toggling motion list scheme to {_scheme}.") self.mb.layer_to_motionlist_scheme = _scheme - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False self.configChanged.emit() @Slot(object) @@ -1500,12 +1500,12 @@ def layer_list_box_set_btn_enable(self, enable=True): self.remove_ly_btn.setEnabled(enable) def update_canvas(self): - if self._mpl_canvas_full_draw: - self.mpl_canvas.update_canvas() + if self._mspace_display_full_draw: + self.mspace_display.update_canvas() else: - self.mpl_canvas.update_motion_list() + self.mspace_display.update_motion_list() - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False def update_exclusion_list_box(self): self.logger.info("Updating Exclusion List Box") @@ -1558,19 +1558,19 @@ def _add_to_mb(self): if _registry is self.exclusion_registry and _name == "New Exclusion": self.mb.add_exclusion(_type, **_inputs) - self._mpl_canvas_full_draw = True + self._mspace_display_full_draw = True elif _registry is self.exclusion_registry: # modifying existing exclusion self.mb.remove_exclusion(_name) self.mb.add_exclusion(_type, **_inputs) - self._mpl_canvas_full_draw = True + self._mspace_display_full_draw = True elif _name == "New Layer": self.mb.add_layer(_type, **_inputs) - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False else: self.mb.remove_layer(_name) self.mb.add_layer(_type, **_inputs) - self._mpl_canvas_full_draw = False + self._mspace_display_full_draw = False self._hide_and_clear_params_widget() self.configChanged.emit() @@ -1658,8 +1658,8 @@ def _spawn_motion_builder(self, config): self.logger.info(f"layer looks like : {mb_config.get('layers', None)}") self._mb = MotionBuilder(**mb_config) - self.mpl_canvas.link_motion_builder(self._mb) - self._mpl_canvas_full_draw = True + self.mspace_display.link_motion_builder(self._mb) + self._mspace_display_full_draw = True self.configChanged.emit() return self._mb From 93ac71bbeccfb9ed75567ceea893cb982016efec Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sun, 14 Jun 2026 11:45:38 -0700 Subject: [PATCH 144/177] create abstract base class _ABCMotionSpaceDisplay --- bapsf_motion/gui/configure/motion_space_display.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 61c01bd3..2ba6f9e0 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -11,6 +11,7 @@ import numpy as np import warnings +from abc import ABC, ABCMeta, abstractmethod from PySide6.QtCore import QTimer, Signal, Slot from PySide6.QtGui import QMouseEvent from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout, QWidget @@ -30,6 +31,9 @@ from matplotlib.collections import PathCollection # noqa +class _ABCMotionSpaceDisplay(ABCMeta, type(QWidget)): ... + + class MotionSpaceDisplay(QFrame): mbChanged = Signal() targetPositionSelected = Signal(list) From 60e29a4354b7563d7164148ce5278f8f90cf7a0b Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sun, 14 Jun 2026 11:54:32 -0700 Subject: [PATCH 145/177] create _MSDBase class --- .../gui/configure/motion_space_display.py | 110 +++++++++++++++++- 1 file changed, 106 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 2ba6f9e0..444167ee 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -15,11 +15,14 @@ from PySide6.QtCore import QTimer, Signal, Slot from PySide6.QtGui import QMouseEvent from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout, QWidget -from typing import List +from typing import List, TYPE_CHECKING from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.motion_builder import MotionBuilder +if TYPE_CHECKING: + from PySide6.QtGui import QCloseEvent + # the matplotlib backend imports must happen after import matplotlib and PySide6 mpl.use("qtagg") # matplotlib's backend for Qt bindings from matplotlib import pyplot as plt # noqa @@ -34,7 +37,7 @@ class _ABCMotionSpaceDisplay(ABCMeta, type(QWidget)): ... -class MotionSpaceDisplay(QFrame): +class _MSDBase(QWidget, ABC, metaclass=_ABCMotionSpaceDisplay): mbChanged = Signal() targetPositionSelected = Signal(list) animateMotionListStarted = Signal() @@ -50,10 +53,15 @@ class MotionSpaceDisplay(QFrame): "insertion_point", ] - def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = None): + def __init__( + self, + logger: logging.Logger, + mb: MotionBuilder | None = None, + parent: QWidget | None = None, + ): super().__init__(parent=parent) - self._logger = logging.getLogger(f"{gui_logger.name}.MSD") + self._logger = self._init_logger(logger) self._mb = self._init_motion_builder(mb) # Initialize plotting control attributes @@ -92,6 +100,100 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self._cid_on_draw = None self._mpl_pick_callback_id = None + @abstractmethod + def link_motion_builder(self, mb: MotionBuilder | None): ... + + @abstractmethod + def unlink_motion_builder(self): ... + + @abstractmethod + @Slot(list) + def update_target_position_plot(self, position): ... + + @abstractmethod + @Slot(list) + def update_position_plot(self, position): + ... + + @staticmethod + def _init_logger(logger: logging.Logger) -> logging.Logger: + if not isinstance(logger, logging.Logger): + logger = logging.getLogger("MSD") + + return logger + + @staticmethod + def _init_motion_builder(mb: MotionBuilder | None) -> MotionBuilder | None: + if mb is not None and not isinstance(mb, MotionBuilder): + raise TypeError( + "Argument 'mb' must be None or an instance of MotionBuilder, " + f"got type {type(mb)} instead." + ) + + return mb + + @property + def logger(self) -> logging.Logger: + return self._logger + + @property + def mb(self) -> MotionBuilder | None: + return self._mb + + @property + def display_position(self) -> bool: + return self._display_position + + @display_position.setter + def display_position(self, value: bool): + if not isinstance(value, bool): + return + + self._display_position = value + if not value: + self._display_probe = value + + @property + def display_target_position(self) -> bool: + return self._display_target_position + + @display_target_position.setter + def display_target_position(self, value: bool): + if not isinstance(value, bool): + return + + self._display_target_position = value + + @property + def display_probe(self) -> bool: + return self._display_probe + + @display_probe.setter + def display_probe(self, value: bool): + if not isinstance(value, bool): + return + + self._display_probe = value + if value: + self._display_position = value + + @property + def is_animating_motion_list(self): + if self._animate_payload is None: + return False + + if self._animate_payload["finished"]: + return False + + _timer = self._animate_payload["timer"] # type: QTimer + return _timer.isActive() + + def closeEvent(self, event: "QCloseEvent"): + self.logger.info(f"Closing {self.__class__.__name__}") + super().closeEvent(event) + + + # Define WIDGETS self.mpl_canvas = self._init_mpl_canvas() self.mpl_toolbar = self._init_mpl_toolbar() From b79513e5c934173289e4aa7340f18194e7beed91 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sun, 14 Jun 2026 11:57:14 -0700 Subject: [PATCH 146/177] Move 2D plotting functionality to dedicated class MotionSpaceDisplay2D --- .../gui/configure/motion_space_display.py | 92 +++---------------- 1 file changed, 13 insertions(+), 79 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 444167ee..691be145 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -193,12 +193,23 @@ def closeEvent(self, event: "QCloseEvent"): super().closeEvent(event) +class MotionSpaceDisplay2D(_MSDBase): + dimensionality = 2 + + def __init__( + self, + logger: logging.Logger, + mb: MotionBuilder | None = None, + parent: QWidget | None = None, + ): + super().__init__( + logger=logger, mb=mb, parent=parent + ) # Define WIDGETS self.mpl_canvas = self._init_mpl_canvas() self.mpl_toolbar = self._init_mpl_toolbar() - self._init_self() self.setLayout(self._define_layout()) self._connect_signals() @@ -223,16 +234,6 @@ def _define_layout(self): return layout - @staticmethod - def _init_motion_builder(mb: MotionBuilder | None) -> MotionBuilder | None: - if mb is not None and not isinstance(mb, MotionBuilder): - raise TypeError( - "Argument 'mb' must be None or an instance of MotionBuilder, " - f"got type {type(mb)} instead." - ) - - return mb - def _init_mpl_canvas(self): canvas = FigureCanvas() canvas.setParent(self) @@ -242,73 +243,6 @@ def _init_mpl_toolbar(self): toolbar = NavigationToolbar(self.mpl_canvas, parent=self) return toolbar - def _init_self(self): - self.setStyleSheet(""" - MotionSpaceDisplay { - border: 2px solid rgb(125, 125, 125); - border-radius: 5px; - padding: 0px; - margin: 0px; - } - """) - self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) - - @property - def logger(self) -> logging.Logger: - return self._logger - - @property - def mb(self) -> MotionBuilder | None: - return self._mb - - @property - def display_position(self) -> bool: - return self._display_position - - @display_position.setter - def display_position(self, value: bool): - if not isinstance(value, bool): - return - - self._display_position = value - if not value: - self._display_probe = value - - @property - def display_target_position(self) -> bool: - return self._display_target_position - - @display_target_position.setter - def display_target_position(self, value: bool): - if not isinstance(value, bool): - return - - self._display_target_position = value - - @property - def display_probe(self) -> bool: - return self._display_probe - - @display_probe.setter - def display_probe(self, value: bool): - if not isinstance(value, bool): - return - - self._display_probe = value - if value: - self._display_position = value - - @property - def is_animating_motion_list(self): - if self._animate_payload is None: - return False - - if self._animate_payload["finished"]: - return False - - _timer = self._animate_payload["timer"] # type: QTimer - return _timer.isActive() - def _get_plot_axis_by_name(self, name: str): fig_axes = self.mpl_canvas.figure.axes for ax in fig_axes: @@ -394,7 +328,7 @@ def animate_motion_list_clear(self): self.animateMotionListCleared.emit() @Slot() - def _update_motion_list_trace(self, *, to_index: int = None): + def _update_motion_list_trace(self, *, to_index: int | None = None): if to_index is None and self._animate_payload is None: return elif to_index is None: From d315d255e15f96bcef9c5abcd4c7bbb776910d59 Mon Sep 17 00:00:00 2001 From: Erik Everson Date: Sun, 14 Jun 2026 11:58:05 -0700 Subject: [PATCH 147/177] Update MotionSpaceDispaly to be a factory class for _MSDBase subclasses --- .../gui/configure/motion_space_display.py | 231 +++++++++++++++++- 1 file changed, 230 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 691be145..909a03c9 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -841,6 +841,235 @@ def update_position_plot(self, position): self.update_legend() self.mpl_canvas.draw() - def closeEvent(self, event): + +class MotionSpaceDisplay(QFrame): + mbChanged = Signal() + targetPositionSelected = Signal(list) + animateMotionListStarted = Signal() + animateMotionListFinished = Signal() + animateMotionListPaused = Signal() + animateMotionListCleared = Signal() + + _default_legend_names = [ + "motion_list", + "probe", + "position", + "target", + "insertion_point", + ] + + def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = None): + super().__init__(parent=parent) + + self._logger = logging.getLogger(f"{gui_logger.name}.MSD") + self._mb = self._init_motion_builder(mb) + + # Define WIDGETS + self.display = self._init_display() + + self._init_self() + self.setLayout(self._define_layout()) + self._connect_signals() + + def _connect_signals(self): + self._connect_display_signals() + + def _connect_display_signals(self): + if not isinstance(self.display, _MSDBase): + return + + self.display.mbChanged.connect(self.mbChanged.emit) + self.display.animateMotionListFinished.connect( + self.animateMotionListFinished.emit + ) + + self.targetPositionSelected.connect(self.display.targetPositionSelected.emit) + + def _disconnect_display_signals(self): + if not isinstance(self.display, _MSDBase): + return + + self.display.mbChanged.disconnect() + self.display.animateMotionListFinished.disconnect() + + self.targetPositionSelected.disconnect(self.display.targetPositionSelected.emit) + + def _define_layout(self): + layout = QVBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addWidget(self.display) + + return layout + + @staticmethod + def _init_motion_builder(mb: MotionBuilder | None) -> MotionBuilder | None: + if mb is not None and not isinstance(mb, MotionBuilder): + raise TypeError( + "Argument 'mb' must be None or an instance of MotionBuilder, " + f"got type {type(mb)} instead." + ) + + return mb + + def _init_display(self) -> QWidget | _MSDBase: + if self._mb is None: + display = QWidget(parent=self) + elif not isinstance(self._mb, MotionBuilder): + raise RuntimeError( + "Can not create a display for the motion space. The " + "motion builder is not the right type. Expected type " + f"MotionBuilder, but got type {type(self._mb)}. " + ) + elif self._mb.mspace_ndims == 2: + display = MotionSpaceDisplay2D( + logger=self._logger, mb=self._mb, parent=self + ) + else: + raise RuntimeError( + "Can not create a display for the motion space. The " + "motion builder has an unsupported dimenstioality. Got " + f"dimensionality {type(self._mb.mspace_ndims)}, but can only " + f"support 2 or 3 dimensions." + ) + + display.setObjectName("motion_space_display") + return display + + def _init_self(self): + self.setStyleSheet(""" + MotionSpaceDisplay { + border: 2px solid rgb(125, 125, 125); + border-radius: 5px; + padding: 0px; + margin: 0px; + } + """) + self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) + + @property + def logger(self) -> logging.Logger: + return self._logger + + @property + def mb(self) -> MotionBuilder | None: + return self._mb + + @property + def display_position(self) -> bool: + if not isinstance(self.display, _MSDBase): + return False + + return self.display.display_position + + @display_position.setter + def display_position(self, value: bool): + if not isinstance(self.display, _MSDBase): + return + + self.display.display_position = value + + @property + def display_target_position(self) -> bool: + if not isinstance(self.display, _MSDBase): + return False + + return self.display.display_target_position + + @display_target_position.setter + def display_target_position(self, value: bool): + if not isinstance(self.display, _MSDBase): + return + + self.display.display_target_position = value + + @property + def display_probe(self) -> bool: + if not isinstance(self.display, _MSDBase): + return False + + return self.display.display_probe + + @display_probe.setter + def display_probe(self, value: bool): + if not isinstance(self.display, _MSDBase): + return + + self.display.display_probe = value + + @property + def is_animating_motion_list(self): + if not isinstance(self.display, _MSDBase): + return False + + return self.display.is_animating_motion_list + + def link_motion_builder(self, mb: MotionBuilder | None = None): + display_dimensionality = None + if isinstance(self.display, _MSDBase): + display_dimensionality = self.display.dimensionality + + new_mspace_dimensionality = None + if isinstance(mb, MotionBuilder): + new_mspace_dimensionality = mb.mspace_ndims + + if mb is not None or not isinstance(mb, MotionBuilder): + mb = None + + if display_dimensionality is None and new_mspace_dimensionality is None: + # nothing has changed + self.unlink_motion_builder() + return + + if ( + new_mspace_dimensionality is None + or new_mspace_dimensionality == display_dimensionality + ): + self.unlink_motion_builder() + self.display.link_motion_builder(mb) + return + + if new_mspace_dimensionality != display_dimensionality: + self.unlink_motion_builder() + self._mb = mb + self.display.setVisible(False) + self._replace_display() + + def unlink_motion_builder(self, mb: MotionBuilder | None = None): + self._mb = None + + if isinstance(self.display, _MSDBase): + self.display.unlink_motion_builder() + self.display.setVisible(False) + + def _replace_display(self): + self._disconnect_display_signals() + + old_display = self.display + new_display = self._init_display() + self.layout().replaceWidget(old_display, new_display) + + old_display.blockSignals(True) + old_display.setVisible(False) + old_display.close() + old_display.deleteLater() + + self.display = new_display + self._connect_display_signals() + + @Slot(list) + def update_position_plot(self, position): + if not isinstance(self.display, _MSDBase): + return + + self.display.update_position_plot(position) + + @Slot(list) + def update_target_position_plot(self, position): + if not isinstance(self.display, _MSDBase): + return + + self.display.update_target_position_plot(position) + + def closeEvent(self, event: "QCloseEvent"): self.logger.info(f"Closing {self.__class__.__name__}") super().closeEvent(event) From 9da028f26d7f925522b98d90c6d7f19e76f482e7 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:22:58 -0700 Subject: [PATCH 148/177] add class attribute _default_logger_name to _MSDBase and give _MSDBase.logger the specific name --- bapsf_motion/gui/configure/motion_space_display.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 909a03c9..03f7a18c 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -45,6 +45,7 @@ class _MSDBase(QWidget, ABC, metaclass=_ABCMotionSpaceDisplay): animateMotionListPaused = Signal() animateMotionListCleared = Signal() + _default_logger_name = "MSD-Base" _default_legend_names = [ "motion_list", "probe", @@ -115,10 +116,11 @@ def update_target_position_plot(self, position): ... def update_position_plot(self, position): ... - @staticmethod - def _init_logger(logger: logging.Logger) -> logging.Logger: + def _init_logger(self, logger: logging.Logger) -> logging.Logger: if not isinstance(logger, logging.Logger): - logger = logging.getLogger("MSD") + logger = logging.getLogger(f"{gui_logger.name}.{self._default_logger_name}") + else: + logger = logging.getLogger(f"{logger.name}.{self._default_logger_name}") return logger @@ -195,6 +197,7 @@ def closeEvent(self, event: "QCloseEvent"): class MotionSpaceDisplay2D(_MSDBase): dimensionality = 2 + _default_logger_name = "MSD-2D" def __init__( self, From f2f2323476798aeb63f45e2d144bd5c530dc3690 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:24:26 -0700 Subject: [PATCH 149/177] add to _MSDBase abstract methods animate_motion_list(), animate_motion_list_clear(), animate_motion_pause(), update_canvas(), update_motion_list() --- .../gui/configure/motion_space_display.py | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 03f7a18c..e1e9c210 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -107,6 +107,28 @@ def link_motion_builder(self, mb: MotionBuilder | None): ... @abstractmethod def unlink_motion_builder(self): ... + @abstractmethod + @Slot() + def animate_motion_list(self): + ... + + @abstractmethod + @Slot() + def animate_motion_list_clear(self): ... + + @abstractmethod + @Slot() + def animate_motion_list_pause(self): + ... + + @abstractmethod + @Slot() + def update_canvas(self): ... + + @abstractmethod + @Slot() + def update_motion_list(self): ... + @abstractmethod @Slot(list) def update_target_position_plot(self, position): ... From 348c5e16bfd46a943340eb9bc9eb7b04202ef9d5 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:25:13 -0700 Subject: [PATCH 150/177] decorate MotionSpaceDisplay2D.animate_motion_list as a @Slot --- bapsf_motion/gui/configure/motion_space_display.py | 1 + 1 file changed, 1 insertion(+) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index e1e9c210..dc695f1e 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -285,6 +285,7 @@ def _get_plot_axis_by_name(self, name: str): return None + @Slot() def animate_motion_list(self): if self._animate_payload is not None and not self._animate_payload["finished"]: self._animate_payload["timer"].start() From dc9b24d81322d19f1f1b9d2998e4a8e3aa29dc06 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:26:52 -0700 Subject: [PATCH 151/177] MotionSpaceDisplay add logging.info --- bapsf_motion/gui/configure/motion_space_display.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index dc695f1e..36f967ba 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -1030,6 +1030,8 @@ def is_animating_motion_list(self): return self.display.is_animating_motion_list def link_motion_builder(self, mb: MotionBuilder | None = None): + self.logger.info(f"Linking motion builder {mb}") + display_dimensionality = None if isinstance(self.display, _MSDBase): display_dimensionality = self.display.dimensionality @@ -1060,7 +1062,8 @@ def link_motion_builder(self, mb: MotionBuilder | None = None): self.display.setVisible(False) self._replace_display() - def unlink_motion_builder(self, mb: MotionBuilder | None = None): + def unlink_motion_builder(self): + self.logger.info(f"Un-Linking motion builder.") self._mb = None if isinstance(self.display, _MSDBase): @@ -1068,6 +1071,7 @@ def unlink_motion_builder(self, mb: MotionBuilder | None = None): self.display.setVisible(False) def _replace_display(self): + self.logger.info("Replacing the display widget") self._disconnect_display_signals() old_display = self.display From 56bad69846f44aa5a76a678fdfca9f88a8dac253 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:27:56 -0700 Subject: [PATCH 152/177] MotionSpaceDisplay.link_motion_builder(): only to wrong type check with isinstance() --- bapsf_motion/gui/configure/motion_space_display.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 36f967ba..628d7f7a 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -1040,7 +1040,7 @@ def link_motion_builder(self, mb: MotionBuilder | None = None): if isinstance(mb, MotionBuilder): new_mspace_dimensionality = mb.mspace_ndims - if mb is not None or not isinstance(mb, MotionBuilder): + if not isinstance(mb, MotionBuilder): mb = None if display_dimensionality is None and new_mspace_dimensionality is None: From 655e72f29f980eacf82f458d466332ee85c982c7 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:29:30 -0700 Subject: [PATCH 153/177] MotionSpaceDisplay: add and connect signals animateMotionListStart, animateMotionListPause, animateMotionListClear, updateDisplay, updateDisplayMotionList, updateDisplayPosition, updateDisplayTargetPosition --- .../gui/configure/motion_space_display.py | 57 +++++++++++++++++-- 1 file changed, 53 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 628d7f7a..e3fbfe2e 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -870,12 +870,23 @@ def update_position_plot(self, position): class MotionSpaceDisplay(QFrame): mbChanged = Signal() + targetPositionSelected = Signal(list) + animateMotionListStarted = Signal() animateMotionListFinished = Signal() animateMotionListPaused = Signal() animateMotionListCleared = Signal() + animateMotionListStart = Signal() + animateMotionListPause = Signal() + animateMotionListClear = Signal() + + updateDisplay = Signal() + updateDisplayMotionList = Signal() + updateDisplayPosition = Signal(list) + updateDisplayTargetPosition = Signal(list) + _default_legend_names = [ "motion_list", "probe", @@ -904,10 +915,26 @@ def _connect_display_signals(self): if not isinstance(self.display, _MSDBase): return - self.display.mbChanged.connect(self.mbChanged.emit) + self.display.animateMotionListCleared.connect(self.animateMotionListCleared.emit) self.display.animateMotionListFinished.connect( self.animateMotionListFinished.emit ) + self.display.animateMotionListPaused.connect(self.animateMotionListPaused.emit) + self.display.animateMotionListStarted.connect(self.animateMotionListStarted.emit) + + self.display.mbChanged.connect(self.mbChanged.emit) + self.display.targetPositionSelected.connect(self.targetPositionSelected.emit) + + self.animateMotionListClear.connect(self.display.animate_motion_list_clear) + self.animateMotionListPause.connect(self.display.animate_motion_list_pause) + self.animateMotionListStart.connect(self.display.animate_motion_list) + + self.updateDisplay.connect(self.display.update_canvas) + self.updateDisplayMotionList.connect(self.display.update_motion_list) + self.updateDisplayPosition.connect(self.display.update_position_plot) + self.updateDisplayTargetPosition.connect( + self.display.update_target_position_plot + ) self.targetPositionSelected.connect(self.display.targetPositionSelected.emit) @@ -915,10 +942,32 @@ def _disconnect_display_signals(self): if not isinstance(self.display, _MSDBase): return - self.display.mbChanged.disconnect() - self.display.animateMotionListFinished.disconnect() + self.display.animateMotionListCleared.disconnect( + self.animateMotionListCleared.emit + ) + self.display.animateMotionListFinished.disconnect( + self.animateMotionListFinished.emit + ) + self.display.animateMotionListPaused.disconnect( + self.animateMotionListPaused.emit + ) + self.display.animateMotionListStarted.disconnect( + self.animateMotionListStarted.emit + ) + + self.display.mbChanged.disconnect(self.mbChanged.emit) + self.display.targetPositionSelected.disconnect(self.targetPositionSelected.emit) - self.targetPositionSelected.disconnect(self.display.targetPositionSelected.emit) + self.animateMotionListClear.disconnect(self.display.animate_motion_list_clear) + self.animateMotionListPause.disconnect(self.display.animate_motion_list_pause) + self.animateMotionListStart.disconnect(self.display.animate_motion_list) + + self.updateDisplay.disconnect(self.display.update_canvas) + self.updateDisplayMotionList.disconnect(self.display.update_motion_list) + self.updateDisplayPosition.disconnect(self.display.update_position_plot) + self.updateDisplayTargetPosition.disconnect( + self.display.update_target_position_plot + ) def _define_layout(self): layout = QVBoxLayout() From 780b4d83dd70d1f98b97f06aa609f03632203819 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:31:24 -0700 Subject: [PATCH 154/177] remove MotionSpaceDisplay.update_target_position_plot() and replace with emitting signal updateDisplayTargetPosition --- bapsf_motion/gui/configure/motion_group_widget.py | 2 +- bapsf_motion/gui/configure/motion_space_display.py | 7 ------- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 12e3711f..2cafd8cb 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -537,7 +537,7 @@ def _connect_signals(self): self.drive_control_widget.movementStopped.connect(self.enable_config_controls) self.drive_control_widget.movementStopped.connect(self._update_position_in_plot) self.drive_control_widget.targetPositionChanged.connect( - self.mspace_display.update_target_position_plot + self.mspace_display.updateDisplayTargetPosition.emit ) self.drive_control_widget.driveStatusChanged.connect(self.update_position_in_plot) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index e3fbfe2e..cf5c7bbf 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -1142,13 +1142,6 @@ def update_position_plot(self, position): self.display.update_position_plot(position) - @Slot(list) - def update_target_position_plot(self, position): - if not isinstance(self.display, _MSDBase): - return - - self.display.update_target_position_plot(position) - def closeEvent(self, event: "QCloseEvent"): self.logger.info(f"Closing {self.__class__.__name__}") super().closeEvent(event) From 22763fe2ce2f14ccf74febfa4ed942b8998b9995 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:32:47 -0700 Subject: [PATCH 155/177] remove MotionSpaceDisplay.update_position_plot() and replace with emitting signal updateDisplayPosition --- bapsf_motion/gui/configure/motion_group_widget.py | 2 +- bapsf_motion/gui/configure/motion_space_display.py | 9 --------- 2 files changed, 1 insertion(+), 10 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 2cafd8cb..9b498ad2 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -570,7 +570,7 @@ def _update_position_in_plot(self): position = self.drive_control_widget.position else: position = None - self.mspace_display.update_position_plot(position) + self.mspace_display.updateDisplayPosition.emit(position) if self._plot_timer_issue_new_single_shot: # start another single shot if update_position_in_plot() was diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index cf5c7bbf..befdc5f7 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -936,8 +936,6 @@ def _connect_display_signals(self): self.display.update_target_position_plot ) - self.targetPositionSelected.connect(self.display.targetPositionSelected.emit) - def _disconnect_display_signals(self): if not isinstance(self.display, _MSDBase): return @@ -1135,13 +1133,6 @@ def _replace_display(self): self.display = new_display self._connect_display_signals() - @Slot(list) - def update_position_plot(self, position): - if not isinstance(self.display, _MSDBase): - return - - self.display.update_position_plot(position) - def closeEvent(self, event: "QCloseEvent"): self.logger.info(f"Closing {self.__class__.__name__}") super().closeEvent(event) From 7a697a6ff38cf806862b16a5a5e48ff81f2661ca Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:33:47 -0700 Subject: [PATCH 156/177] add fully named logger to MotionBuilderConfigOverlay --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index b52c94aa..3de69eca 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -7,6 +7,7 @@ import ast import inspect +import logging import math import matplotlib as mpl import numpy as np @@ -66,6 +67,7 @@ class MotionBuilderConfigOverlay(_ConfigOverlay): def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): super().__init__(mg, parent) + self._logger = logging.getLogger(f"{self.logger.name}.MBCO") self._mb = None From 9213c8cfbd9f7561a5cad45f7ed49c9984bfccb0 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:34:32 -0700 Subject: [PATCH 157/177] replace use of MotionSpaceDispaly.animate_motion_list_clear() with emitting signal animateMotionListClear --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index 3de69eca..50225fc5 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -223,7 +223,7 @@ def _connect_signals(self): ) self.animate_ml_btn.clicked.connect(self._animate_motion_list) self.animate_ml_clear_btn.clicked.connect( - self.mspace_display.animate_motion_list_clear + self.mspace_display.animateMotionListClear.emit ) def _define_layout(self): From 0043086bfe1ace3646435e882921421df37f7447 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:34:49 -0700 Subject: [PATCH 158/177] replace use of MotionSpaceDispaly.animate_motion_list_pause() with emitting signal animateMotionListPause --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index 50225fc5..5ea4bd5c 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -962,7 +962,7 @@ def _config_changed_handler(self): def _animate_motion_list(self): _btn_text = self.animate_ml_btn.text().replace("\n", "") if _btn_text == "PAUSE": - self.mspace_display.animate_motion_list_pause() + self.mspace_display.animateMotionListPause.emit() else: self.mspace_display.animate_motion_list() From 00bbf8ffb6cc5a9e5de6b9ef24211cb23563729c Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:35:05 -0700 Subject: [PATCH 159/177] replace use of MotionSpaceDispaly.animate_motion_list() with emitting signal animateMotionListStart --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index 5ea4bd5c..a04c74e2 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -964,7 +964,7 @@ def _animate_motion_list(self): if _btn_text == "PAUSE": self.mspace_display.animateMotionListPause.emit() else: - self.mspace_display.animate_motion_list() + self.mspace_display.animateMotionListStart.emit() @Slot() def _animate_motion_list_btn_txt_to_animate(self): From 484ab13b80feb98756233b3172cd9fe56b572514 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:35:32 -0700 Subject: [PATCH 160/177] replace use of MotionSpaceDispaly.update_canvas() with emitting signal updateDisplay --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index a04c74e2..d6fd9e32 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -1503,7 +1503,7 @@ def layer_list_box_set_btn_enable(self, enable=True): def update_canvas(self): if self._mspace_display_full_draw: - self.mspace_display.update_canvas() + self.mspace_display.updateDisplay.emit() else: self.mspace_display.update_motion_list() From 711bcdacae015bfa9da91b41b1b711140b37cfb8 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 16:35:50 -0700 Subject: [PATCH 161/177] replace use of MotionSpaceDispaly.update_motion_list() with emitting signal updateDisplayMotionList --- bapsf_motion/gui/configure/motion_builder_overlay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index d6fd9e32..f9b84fdf 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -1505,7 +1505,7 @@ def update_canvas(self): if self._mspace_display_full_draw: self.mspace_display.updateDisplay.emit() else: - self.mspace_display.update_motion_list() + self.mspace_display.updateDisplayMotionList.emit() self._mspace_display_full_draw = False From 19c41879595342d5a614d51cff878f3612b11b78 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 17:06:54 -0700 Subject: [PATCH 162/177] bundle all animation signals into one animate class _AnimationSignals --- .../gui/configure/motion_builder_overlay.py | 14 ++-- .../gui/configure/motion_space_display.py | 80 ++++++++++--------- 2 files changed, 49 insertions(+), 45 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index f9b84fdf..b2802797 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -209,21 +209,21 @@ def _connect_signals(self): self.layer_move_up_btn.clicked.connect(self._layer_list_item_move_up) self.layer_move_down_btn.clicked.connect(self._layer_list_item_move_down) - self.mspace_display.animateMotionListFinished.connect( + self.mspace_display.animateMotionList.Finished.connect( self._animate_motion_list_finished ) - self.mspace_display.animateMotionListCleared.connect( + self.mspace_display.animateMotionList.Cleared.connect( self._animate_motion_list_finished ) - self.mspace_display.animateMotionListStarted.connect( + self.mspace_display.animateMotionList.Started.connect( self._animate_motion_list_btn_txt_to_pause ) - self.mspace_display.animateMotionListPaused.connect( + self.mspace_display.animateMotionList.Paused.connect( self._animate_motion_list_btn_txt_to_animate ) self.animate_ml_btn.clicked.connect(self._animate_motion_list) self.animate_ml_clear_btn.clicked.connect( - self.mspace_display.animateMotionListClear.emit + self.mspace_display.animateMotionList.Clear.emit ) def _define_layout(self): @@ -962,9 +962,9 @@ def _config_changed_handler(self): def _animate_motion_list(self): _btn_text = self.animate_ml_btn.text().replace("\n", "") if _btn_text == "PAUSE": - self.mspace_display.animateMotionListPause.emit() + self.mspace_display.animateMotionList.Pause.emit() else: - self.mspace_display.animateMotionListStart.emit() + self.mspace_display.animateMotionList.Start.emit() @Slot() def _animate_motion_list_btn_txt_to_animate(self): diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index befdc5f7..6ae08430 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -12,7 +12,7 @@ import warnings from abc import ABC, ABCMeta, abstractmethod -from PySide6.QtCore import QTimer, Signal, Slot +from PySide6.QtCore import QObject, QTimer, Signal, Slot from PySide6.QtGui import QMouseEvent from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout, QWidget from typing import List, TYPE_CHECKING @@ -37,13 +37,22 @@ class _ABCMotionSpaceDisplay(ABCMeta, type(QWidget)): ... +class _AnimationSignals(QObject): + Cleared = Signal() + Finished = Signal() + Paused = Signal() + Started = Signal() + + Clear = Signal() + Pause = Signal() + Start = Signal() + Stop = Signal() + + class _MSDBase(QWidget, ABC, metaclass=_ABCMotionSpaceDisplay): mbChanged = Signal() targetPositionSelected = Signal(list) - animateMotionListStarted = Signal() - animateMotionListFinished = Signal() - animateMotionListPaused = Signal() - animateMotionListCleared = Signal() + animateMotionList = _AnimationSignals() _default_logger_name = "MSD-Base" _default_legend_names = [ @@ -241,7 +250,7 @@ def __init__( def _connect_signals(self): self.mbChanged.connect(self.update_canvas) self.targetPositionSelected.connect(self.update_target_position_plot) - self.animateMotionListFinished.connect(self.animate_motion_list_pause) + self.animateMotionList.Finished.connect(self.animate_motion_list_pause) # matplotlib events self._mpl_pick_callback_id = self.mpl_canvas.mpl_connect( @@ -289,7 +298,7 @@ def _get_plot_axis_by_name(self, name: str): def animate_motion_list(self): if self._animate_payload is not None and not self._animate_payload["finished"]: self._animate_payload["timer"].start() - self.animateMotionListStarted.emit() + self.animateMotionList.Started.emit() return elif self._animate_payload is not None: self.animate_motion_list_clear() @@ -301,7 +310,7 @@ def animate_motion_list(self): self._animate_motion_list_init_payload() self._animate_payload["timer"].start() # noqa - self.animateMotionListStarted.emit() + self.animateMotionList.Started.emit() def _animate_motion_list_init_payload(self): delay = 200 # msec @@ -329,7 +338,7 @@ def animate_motion_list_pause(self): self._animate_payload["timer"].stop() if not self._animate_payload["finished"]: - self.animateMotionListPaused.emit() + self.animateMotionList.Paused.emit() @Slot() def animate_motion_list_clear(self): @@ -351,7 +360,7 @@ def animate_motion_list_clear(self): self.mpl_canvas.draw() - self.animateMotionListCleared.emit() + self.animateMotionList.Cleared.emit() @Slot() def _update_motion_list_trace(self, *, to_index: int | None = None): @@ -421,7 +430,7 @@ def _update_motion_list_trace(self, *, to_index: int | None = None): self.mpl_canvas.draw() if to_index == self.mb.motion_list.shape[0] - 1: self._animate_payload["finished"] = True - self.animateMotionListFinished.emit() + self.animateMotionList.Finished.emit() return to_index += self._animate_payload["index_step"] @@ -873,14 +882,7 @@ class MotionSpaceDisplay(QFrame): targetPositionSelected = Signal(list) - animateMotionListStarted = Signal() - animateMotionListFinished = Signal() - animateMotionListPaused = Signal() - animateMotionListCleared = Signal() - - animateMotionListStart = Signal() - animateMotionListPause = Signal() - animateMotionListClear = Signal() + animateMotionList = _AnimationSignals() updateDisplay = Signal() updateDisplayMotionList = Signal() @@ -915,19 +917,21 @@ def _connect_display_signals(self): if not isinstance(self.display, _MSDBase): return - self.display.animateMotionListCleared.connect(self.animateMotionListCleared.emit) - self.display.animateMotionListFinished.connect( - self.animateMotionListFinished.emit + self.display.animateMotionList.Cleared.connect(self.animateMotionList.Cleared.emit) + self.display.animateMotionList.Finished.connect( + self.animateMotionList.Finished.emit + ) + self.display.animateMotionList.Paused.connect(self.animateMotionList.Paused.emit) + self.display.animateMotionList.Started.connect( + self.animateMotionList.Started.emit ) - self.display.animateMotionListPaused.connect(self.animateMotionListPaused.emit) - self.display.animateMotionListStarted.connect(self.animateMotionListStarted.emit) self.display.mbChanged.connect(self.mbChanged.emit) self.display.targetPositionSelected.connect(self.targetPositionSelected.emit) - self.animateMotionListClear.connect(self.display.animate_motion_list_clear) - self.animateMotionListPause.connect(self.display.animate_motion_list_pause) - self.animateMotionListStart.connect(self.display.animate_motion_list) + self.animateMotionList.Clear.connect(self.display.animate_motion_list_clear) + self.animateMotionList.Pause.connect(self.display.animate_motion_list_pause) + self.animateMotionList.Start.connect(self.display.animate_motion_list) self.updateDisplay.connect(self.display.update_canvas) self.updateDisplayMotionList.connect(self.display.update_motion_list) @@ -940,25 +944,25 @@ def _disconnect_display_signals(self): if not isinstance(self.display, _MSDBase): return - self.display.animateMotionListCleared.disconnect( - self.animateMotionListCleared.emit + self.display.animateMotionList.Cleared.disconnect( + self.animateMotionList.Cleared.emit ) - self.display.animateMotionListFinished.disconnect( - self.animateMotionListFinished.emit + self.display.animateMotionList.Finished.disconnect( + self.animateMotionList.Finished.emit ) - self.display.animateMotionListPaused.disconnect( - self.animateMotionListPaused.emit + self.display.animateMotionList.Paused.disconnect( + self.animateMotionList.Paused.emit ) - self.display.animateMotionListStarted.disconnect( - self.animateMotionListStarted.emit + self.display.animateMotionList.Started.disconnect( + self.animateMotionList.Started.emit ) self.display.mbChanged.disconnect(self.mbChanged.emit) self.display.targetPositionSelected.disconnect(self.targetPositionSelected.emit) - self.animateMotionListClear.disconnect(self.display.animate_motion_list_clear) - self.animateMotionListPause.disconnect(self.display.animate_motion_list_pause) - self.animateMotionListStart.disconnect(self.display.animate_motion_list) + self.animateMotionList.Clear.disconnect(self.display.animate_motion_list_clear) + self.animateMotionList.Pause.disconnect(self.display.animate_motion_list_pause) + self.animateMotionList.Start.disconnect(self.display.animate_motion_list) self.updateDisplay.disconnect(self.display.update_canvas) self.updateDisplayMotionList.disconnect(self.display.update_motion_list) From 5378e8213ca827433ff9660ffca0bde5b55d5728 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 17:07:23 -0700 Subject: [PATCH 163/177] MotionSpaceDisplay2D emit mbChanged() at the ned of __init__ --- bapsf_motion/gui/configure/motion_space_display.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 6ae08430..48c4c6a8 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -247,6 +247,8 @@ def __init__( self.setLayout(self._define_layout()) self._connect_signals() + self.mbChanged.emit() + def _connect_signals(self): self.mbChanged.connect(self.update_canvas) self.targetPositionSelected.connect(self.update_target_position_plot) From 64cfdb43dd4f24bbb7635379278de9f3f47665af Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 17:39:15 -0700 Subject: [PATCH 164/177] bundle all redraw signals into one redraw class _RedrawDisplaySignals --- .../gui/configure/motion_builder_overlay.py | 4 +-- .../gui/configure/motion_group_widget.py | 4 +-- .../gui/configure/motion_space_display.py | 30 +++++++++++-------- 3 files changed, 21 insertions(+), 17 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index b2802797..36697267 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -1503,9 +1503,9 @@ def layer_list_box_set_btn_enable(self, enable=True): def update_canvas(self): if self._mspace_display_full_draw: - self.mspace_display.updateDisplay.emit() + self.mspace_display.redrawSignals.All.emit() else: - self.mspace_display.updateDisplayMotionList.emit() + self.mspace_display.redrawSignals.MotionList.emit() self._mspace_display_full_draw = False diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 9b498ad2..9ca9a69b 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -537,7 +537,7 @@ def _connect_signals(self): self.drive_control_widget.movementStopped.connect(self.enable_config_controls) self.drive_control_widget.movementStopped.connect(self._update_position_in_plot) self.drive_control_widget.targetPositionChanged.connect( - self.mspace_display.updateDisplayTargetPosition.emit + self.mspace_display.redrawSignals.TargetPosition.emit ) self.drive_control_widget.driveStatusChanged.connect(self.update_position_in_plot) @@ -570,7 +570,7 @@ def _update_position_in_plot(self): position = self.drive_control_widget.position else: position = None - self.mspace_display.updateDisplayPosition.emit(position) + self.mspace_display.redrawSignals.Position.emit(position) if self._plot_timer_issue_new_single_shot: # start another single shot if update_position_in_plot() was diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 48c4c6a8..bb7c1c47 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -37,6 +37,13 @@ class _ABCMotionSpaceDisplay(ABCMeta, type(QWidget)): ... +class _RedrawDisplaySignals(QObject): + All = Signal() + MotionList = Signal() + Position = Signal(list) + TargetPosition = Signal(list) + + class _AnimationSignals(QObject): Cleared = Signal() Finished = Signal() @@ -53,6 +60,7 @@ class _MSDBase(QWidget, ABC, metaclass=_ABCMotionSpaceDisplay): mbChanged = Signal() targetPositionSelected = Signal(list) animateMotionList = _AnimationSignals() + redrawSignals = _RedrawDisplaySignals() _default_logger_name = "MSD-Base" _default_legend_names = [ @@ -885,11 +893,7 @@ class MotionSpaceDisplay(QFrame): targetPositionSelected = Signal(list) animateMotionList = _AnimationSignals() - - updateDisplay = Signal() - updateDisplayMotionList = Signal() - updateDisplayPosition = Signal(list) - updateDisplayTargetPosition = Signal(list) + redrawSignals = _RedrawDisplaySignals() _default_legend_names = [ "motion_list", @@ -935,10 +939,10 @@ def _connect_display_signals(self): self.animateMotionList.Pause.connect(self.display.animate_motion_list_pause) self.animateMotionList.Start.connect(self.display.animate_motion_list) - self.updateDisplay.connect(self.display.update_canvas) - self.updateDisplayMotionList.connect(self.display.update_motion_list) - self.updateDisplayPosition.connect(self.display.update_position_plot) - self.updateDisplayTargetPosition.connect( + self.redrawSignals.All.connect(self.display.update_canvas) + self.redrawSignals.MotionList.connect(self.display.update_motion_list) + self.redrawSignals.Position.connect(self.display.update_position_plot) + self.redrawSignals.TargetPosition.connect( self.display.update_target_position_plot ) @@ -966,10 +970,10 @@ def _disconnect_display_signals(self): self.animateMotionList.Pause.disconnect(self.display.animate_motion_list_pause) self.animateMotionList.Start.disconnect(self.display.animate_motion_list) - self.updateDisplay.disconnect(self.display.update_canvas) - self.updateDisplayMotionList.disconnect(self.display.update_motion_list) - self.updateDisplayPosition.disconnect(self.display.update_position_plot) - self.updateDisplayTargetPosition.disconnect( + self.redrawSignals.All.disconnect(self.display.update_canvas) + self.redrawSignals.MotionList.disconnect(self.display.update_motion_list) + self.redrawSignals.Position.disconnect(self.display.update_position_plot) + self.redrawSignals.TargetPosition.disconnect( self.display.update_target_position_plot ) From 15f4178a66c2b9b5c4efdcde6e3a3e52129b19f6 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 17:59:23 -0700 Subject: [PATCH 165/177] create _MSDBase._connect_animate_motion_list_signals() and have outside classes trigger those signals instead of calling methods directly --- .../gui/configure/motion_space_display.py | 29 ++++++++++++------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index bb7c1c47..fcbeb06b 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -118,6 +118,14 @@ def __init__( self._cid_on_draw = None self._mpl_pick_callback_id = None + def _connect_animate_motion_list_signals(self): + self.animateMotionList.Clear.connect(self.animate_motion_list_clear) + self.animateMotionList.Pause.connect(self.animate_motion_list_pause) + self.animateMotionList.Start.connect(self.animate_motion_list) + self.animateMotionList.Stop.connect(self.animate_motion_list_pause) + + self.animateMotionList.Finished.connect(self.animate_motion_list_pause) + @abstractmethod def link_motion_builder(self, mb: MotionBuilder | None): ... @@ -126,8 +134,7 @@ def unlink_motion_builder(self): ... @abstractmethod @Slot() - def animate_motion_list(self): - ... + def animate_motion_list(self): ... @abstractmethod @Slot() @@ -135,8 +142,7 @@ def animate_motion_list_clear(self): ... @abstractmethod @Slot() - def animate_motion_list_pause(self): - ... + def animate_motion_list_pause(self): ... @abstractmethod @Slot() @@ -258,9 +264,10 @@ def __init__( self.mbChanged.emit() def _connect_signals(self): + self._connect_animate_motion_list_signals() + self.mbChanged.connect(self.update_canvas) self.targetPositionSelected.connect(self.update_target_position_plot) - self.animateMotionList.Finished.connect(self.animate_motion_list_pause) # matplotlib events self._mpl_pick_callback_id = self.mpl_canvas.mpl_connect( @@ -935,9 +942,9 @@ def _connect_display_signals(self): self.display.mbChanged.connect(self.mbChanged.emit) self.display.targetPositionSelected.connect(self.targetPositionSelected.emit) - self.animateMotionList.Clear.connect(self.display.animate_motion_list_clear) - self.animateMotionList.Pause.connect(self.display.animate_motion_list_pause) - self.animateMotionList.Start.connect(self.display.animate_motion_list) + self.animateMotionList.Clear.connect(self.display.animateMotionList.Clear.emit) + self.animateMotionList.Pause.connect(self.display.animateMotionList.Pause.emit) + self.animateMotionList.Start.connect(self.display.animateMotionList.Start.emit) self.redrawSignals.All.connect(self.display.update_canvas) self.redrawSignals.MotionList.connect(self.display.update_motion_list) @@ -966,9 +973,9 @@ def _disconnect_display_signals(self): self.display.mbChanged.disconnect(self.mbChanged.emit) self.display.targetPositionSelected.disconnect(self.targetPositionSelected.emit) - self.animateMotionList.Clear.disconnect(self.display.animate_motion_list_clear) - self.animateMotionList.Pause.disconnect(self.display.animate_motion_list_pause) - self.animateMotionList.Start.disconnect(self.display.animate_motion_list) + self.animateMotionList.Clear.disconnect(self.display.animateMotionList.Clear.emit) + self.animateMotionList.Pause.disconnect(self.display.animateMotionList.Pause.emit) + self.animateMotionList.Start.disconnect(self.display.animateMotionList.Start.emit) self.redrawSignals.All.disconnect(self.display.update_canvas) self.redrawSignals.MotionList.disconnect(self.display.update_motion_list) From 230cf9bb8839eb3fc2f27311f4ee53bea2971e0b Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:00:31 -0700 Subject: [PATCH 166/177] refactor animate_motion_list() -> animate_motion_list_start() --- bapsf_motion/gui/configure/motion_space_display.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index fcbeb06b..dc198fed 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -118,10 +118,12 @@ def __init__( self._cid_on_draw = None self._mpl_pick_callback_id = None + def _connect_redraw_signals(self): ... + def _connect_animate_motion_list_signals(self): self.animateMotionList.Clear.connect(self.animate_motion_list_clear) self.animateMotionList.Pause.connect(self.animate_motion_list_pause) - self.animateMotionList.Start.connect(self.animate_motion_list) + self.animateMotionList.Start.connect(self.animate_motion_list_start) self.animateMotionList.Stop.connect(self.animate_motion_list_pause) self.animateMotionList.Finished.connect(self.animate_motion_list_pause) @@ -134,7 +136,7 @@ def unlink_motion_builder(self): ... @abstractmethod @Slot() - def animate_motion_list(self): ... + def animate_motion_list_start(self): ... @abstractmethod @Slot() @@ -312,7 +314,7 @@ def _get_plot_axis_by_name(self, name: str): return None @Slot() - def animate_motion_list(self): + def animate_motion_list_start(self): if self._animate_payload is not None and not self._animate_payload["finished"]: self._animate_payload["timer"].start() self.animateMotionList.Started.emit() @@ -619,7 +621,7 @@ def update_canvas(self): # re-start the motion list animation if is_animating: self.blockSignals(True) - self.animate_motion_list() + self.animate_motion_list_start() self.blockSignals(False) self.logger.info("Re-draw DONE.") From a813246a307c68b432cf4a2a760ce728633dee29 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:04:51 -0700 Subject: [PATCH 167/177] create abstract method _MSDBase.animate_motion_list_stop() ... and reorder animate methods --- .../gui/configure/motion_space_display.py | 74 ++++++++++--------- 1 file changed, 41 insertions(+), 33 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index dc198fed..4937a381 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -124,9 +124,9 @@ def _connect_animate_motion_list_signals(self): self.animateMotionList.Clear.connect(self.animate_motion_list_clear) self.animateMotionList.Pause.connect(self.animate_motion_list_pause) self.animateMotionList.Start.connect(self.animate_motion_list_start) - self.animateMotionList.Stop.connect(self.animate_motion_list_pause) + self.animateMotionList.Stop.connect(self.animate_motion_list_stop) - self.animateMotionList.Finished.connect(self.animate_motion_list_pause) + self.animateMotionList.Finished.connect(self.animate_motion_list_stop) @abstractmethod def link_motion_builder(self, mb: MotionBuilder | None): ... @@ -136,15 +136,19 @@ def unlink_motion_builder(self): ... @abstractmethod @Slot() - def animate_motion_list_start(self): ... + def animate_motion_list_clear(self): ... @abstractmethod @Slot() - def animate_motion_list_clear(self): ... + def animate_motion_list_pause(self): ... @abstractmethod @Slot() - def animate_motion_list_pause(self): ... + def animate_motion_list_start(self): ... + + @abstractmethod + @Slot() + def animate_motion_list_stop(self): ... @abstractmethod @Slot() @@ -313,24 +317,6 @@ def _get_plot_axis_by_name(self, name: str): return None - @Slot() - def animate_motion_list_start(self): - if self._animate_payload is not None and not self._animate_payload["finished"]: - self._animate_payload["timer"].start() - self.animateMotionList.Started.emit() - return - elif self._animate_payload is not None: - self.animate_motion_list_clear() - self._animate_payload = None - elif self.mb.motion_list is None: - self.animate_motion_list_clear() - return - - self._animate_motion_list_init_payload() - self._animate_payload["timer"].start() # noqa - - self.animateMotionList.Started.emit() - def _animate_motion_list_init_payload(self): delay = 200 # msec _timer = QTimer(parent=self) @@ -349,16 +335,6 @@ def _animate_motion_list_init_payload(self): "finished": False, } - @Slot() - def animate_motion_list_pause(self): - if self._animate_payload is None: - return - - self._animate_payload["timer"].stop() - - if not self._animate_payload["finished"]: - self.animateMotionList.Paused.emit() - @Slot() def animate_motion_list_clear(self): if self._animate_payload is None: @@ -381,6 +357,38 @@ def animate_motion_list_clear(self): self.animateMotionList.Cleared.emit() + @Slot() + def animate_motion_list_pause(self): + if self._animate_payload is None: + return + + self._animate_payload["timer"].stop() + + if not self._animate_payload["finished"]: + self.animateMotionList.Paused.emit() + + @Slot() + def animate_motion_list_start(self): + if self._animate_payload is not None and not self._animate_payload["finished"]: + self._animate_payload["timer"].start() + self.animateMotionList.Started.emit() + return + elif self._animate_payload is not None: + self.animate_motion_list_clear() + self._animate_payload = None + elif self.mb.motion_list is None: + self.animate_motion_list_clear() + return + + self._animate_motion_list_init_payload() + self._animate_payload["timer"].start() # noqa + + self.animateMotionList.Started.emit() + + @Slot() + def animate_motion_list_stop(self): + self.animate_motion_list_pause() + @Slot() def _update_motion_list_trace(self, *, to_index: int | None = None): if to_index is None and self._animate_payload is None: From b9175bed1277965269b21b4341a6a16907f7a054 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:24:04 -0700 Subject: [PATCH 168/177] create _MSDBase._connect_redraw_signals() and have outside classes trigger those signals instead of calling methods directly --- .../gui/configure/motion_space_display.py | 23 +++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 4937a381..229f4c7f 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -118,7 +118,11 @@ def __init__( self._cid_on_draw = None self._mpl_pick_callback_id = None - def _connect_redraw_signals(self): ... + def _connect_redraw_signals(self): + self.redrawSignals.All.connect(self.update_canvas) + self.redrawSignals.MotionList.connect(self.update_motion_list) + self.redrawSignals.Position.connect(self.update_position_plot) + self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) def _connect_animate_motion_list_signals(self): self.animateMotionList.Clear.connect(self.animate_motion_list_clear) @@ -271,6 +275,7 @@ def __init__( def _connect_signals(self): self._connect_animate_motion_list_signals() + self._connect_redraw_signals() self.mbChanged.connect(self.update_canvas) self.targetPositionSelected.connect(self.update_target_position_plot) @@ -956,11 +961,11 @@ def _connect_display_signals(self): self.animateMotionList.Pause.connect(self.display.animateMotionList.Pause.emit) self.animateMotionList.Start.connect(self.display.animateMotionList.Start.emit) - self.redrawSignals.All.connect(self.display.update_canvas) - self.redrawSignals.MotionList.connect(self.display.update_motion_list) - self.redrawSignals.Position.connect(self.display.update_position_plot) + self.redrawSignals.All.connect(self.display.redrawSignals.All.emit) + self.redrawSignals.MotionList.connect(self.display.redrawSignals.MotionList.emit) + self.redrawSignals.Position.connect(self.display.redrawSignals.Position.emit) self.redrawSignals.TargetPosition.connect( - self.display.update_target_position_plot + self.display.redrawSignals.TargetPosition.emit ) def _disconnect_display_signals(self): @@ -987,11 +992,11 @@ def _disconnect_display_signals(self): self.animateMotionList.Pause.disconnect(self.display.animateMotionList.Pause.emit) self.animateMotionList.Start.disconnect(self.display.animateMotionList.Start.emit) - self.redrawSignals.All.disconnect(self.display.update_canvas) - self.redrawSignals.MotionList.disconnect(self.display.update_motion_list) - self.redrawSignals.Position.disconnect(self.display.update_position_plot) + self.redrawSignals.All.disconnect(self.display.redrawSignals.All.emit) + self.redrawSignals.MotionList.disconnect(self.display.redrawSignals.MotionList.emit) + self.redrawSignals.Position.disconnect(self.display.redrawSignals.Position.emit) self.redrawSignals.TargetPosition.disconnect( - self.display.update_target_position_plot + self.display.redrawSignals.TargetPosition.emit ) def _define_layout(self): From 7642486d738f9483b7ec0e431b2c7cb31d4a606f Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:24:16 -0700 Subject: [PATCH 169/177] add missing slot decorations --- bapsf_motion/gui/configure/motion_space_display.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 229f4c7f..a316df81 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -664,6 +664,7 @@ def update_legend(self): self.mpl_canvas.draw() + @Slot() def update_motion_list(self): self.animate_motion_list_clear() @@ -824,6 +825,7 @@ def update_target_position_plot(self, position): self.update_legend() self.mpl_canvas.draw() + @Slot(list) def update_position_plot(self, position): self.logger.info(f"Drawing position {position}") From 5922f4b3a9af56d3c1e505e74b20b5fa1dd391fc Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:25:04 -0700 Subject: [PATCH 170/177] increase plot interval time to avoid observed random segmentation faults --- bapsf_motion/gui/configure/motion_group_widget.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index 9ca9a69b..c69f2546 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -428,7 +428,7 @@ def __init__( self._build_transform_defaults() # Initialize the plot update timeer attributes - self._update_plot_interval = 200 # in msec + self._update_plot_interval = 300 # in msec self._update_plot_timer = QTimer() self._update_plot_timer.setSingleShot(True) self._plot_timer_issue_new_single_shot = False From fcd47da16cff4de91970178e5a70d6ce597b81a9 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:28:11 -0700 Subject: [PATCH 171/177] refactor update_canvas() -> redraw_display() --- bapsf_motion/gui/configure/motion_builder_overlay.py | 6 +++--- bapsf_motion/gui/configure/motion_space_display.py | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index 36697267..ae0288cb 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -171,7 +171,7 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): self.update_exclusion_list_box() self.update_layer_list_box() self.update_layer_ml_combine_toggle() - self.update_canvas() + self.redraw_display() self._connect_signals() @@ -956,7 +956,7 @@ def _config_changed_handler(self): self.update_exclusion_list_box() self.update_layer_list_box() self.update_layer_ml_combine_toggle() - self.update_canvas() + self.redraw_display() @Slot() def _animate_motion_list(self): @@ -1501,7 +1501,7 @@ def layer_list_box_set_btn_enable(self, enable=True): self.edit_ly_btn.setEnabled(enable) self.remove_ly_btn.setEnabled(enable) - def update_canvas(self): + def redraw_display(self): if self._mspace_display_full_draw: self.mspace_display.redrawSignals.All.emit() else: diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index a316df81..42a0ec73 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -119,7 +119,7 @@ def __init__( self._mpl_pick_callback_id = None def _connect_redraw_signals(self): - self.redrawSignals.All.connect(self.update_canvas) + self.redrawSignals.All.connect(self.redraw_display) self.redrawSignals.MotionList.connect(self.update_motion_list) self.redrawSignals.Position.connect(self.update_position_plot) self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) @@ -156,7 +156,7 @@ def animate_motion_list_stop(self): ... @abstractmethod @Slot() - def update_canvas(self): ... + def redraw_display(self): ... @abstractmethod @Slot() @@ -277,7 +277,7 @@ def _connect_signals(self): self._connect_animate_motion_list_signals() self._connect_redraw_signals() - self.mbChanged.connect(self.update_canvas) + self.mbChanged.connect(self.redraw_display) self.targetPositionSelected.connect(self.update_target_position_plot) # matplotlib events @@ -544,7 +544,7 @@ def unlink_motion_builder(self): self.mbChanged.emit() @Slot() - def update_canvas(self): + def redraw_display(self): if not isinstance(self.mb, MotionBuilder): self.setHidden(True) return From efa6a11769fbc4320dcc766a1c27e8b9edbafca4 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:31:26 -0700 Subject: [PATCH 172/177] refactor update_motion_list() -> redraw_motion_list() --- bapsf_motion/gui/configure/motion_space_display.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 42a0ec73..65b49b03 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -120,7 +120,7 @@ def __init__( def _connect_redraw_signals(self): self.redrawSignals.All.connect(self.redraw_display) - self.redrawSignals.MotionList.connect(self.update_motion_list) + self.redrawSignals.MotionList.connect(self.redraw_motion_list) self.redrawSignals.Position.connect(self.update_position_plot) self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) @@ -160,7 +160,7 @@ def redraw_display(self): ... @abstractmethod @Slot() - def update_motion_list(self): ... + def redraw_motion_list(self): ... @abstractmethod @Slot(list) @@ -587,7 +587,7 @@ def redraw_display(self): fig.tight_layout() # Draw motion list - self.update_motion_list() + self.redraw_motion_list() # Draw insertion point insertion_point = self.mb.get_insertion_point() @@ -665,7 +665,7 @@ def update_legend(self): self.mpl_canvas.draw() @Slot() - def update_motion_list(self): + def redraw_motion_list(self): self.animate_motion_list_clear() # plot the individual point layers (if join scheme is sequential) From c4ec0435900458451207d8422c0a816e5d45bad6 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:32:22 -0700 Subject: [PATCH 173/177] refactor update_motion_list() -> redraw_motion_list_plot() --- bapsf_motion/gui/configure/motion_space_display.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 65b49b03..138e0356 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -120,7 +120,7 @@ def __init__( def _connect_redraw_signals(self): self.redrawSignals.All.connect(self.redraw_display) - self.redrawSignals.MotionList.connect(self.redraw_motion_list) + self.redrawSignals.MotionList.connect(self.redraw_motion_list_plot) self.redrawSignals.Position.connect(self.update_position_plot) self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) @@ -160,7 +160,7 @@ def redraw_display(self): ... @abstractmethod @Slot() - def redraw_motion_list(self): ... + def redraw_motion_list_plot(self): ... @abstractmethod @Slot(list) @@ -587,7 +587,7 @@ def redraw_display(self): fig.tight_layout() # Draw motion list - self.redraw_motion_list() + self.redraw_motion_list_plot() # Draw insertion point insertion_point = self.mb.get_insertion_point() @@ -665,7 +665,7 @@ def update_legend(self): self.mpl_canvas.draw() @Slot() - def redraw_motion_list(self): + def redraw_motion_list_plot(self): self.animate_motion_list_clear() # plot the individual point layers (if join scheme is sequential) From db6c31fdfc60cf3c483eea5c072ba1cba032ef49 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:33:28 -0700 Subject: [PATCH 174/177] refactor update_position_plot() -> redraw_position_plot() --- bapsf_motion/gui/configure/motion_space_display.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 138e0356..d206381d 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -121,7 +121,7 @@ def __init__( def _connect_redraw_signals(self): self.redrawSignals.All.connect(self.redraw_display) self.redrawSignals.MotionList.connect(self.redraw_motion_list_plot) - self.redrawSignals.Position.connect(self.update_position_plot) + self.redrawSignals.Position.connect(self.redraw_position_plot) self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) def _connect_animate_motion_list_signals(self): @@ -168,7 +168,7 @@ def update_target_position_plot(self, position): ... @abstractmethod @Slot(list) - def update_position_plot(self, position): + def redraw_position_plot(self, position): ... def _init_logger(self, logger: logging.Logger) -> logging.Logger: @@ -624,7 +624,7 @@ def redraw_display(self): # Draw current position if self.display_position: - self.update_position_plot(position=position) + self.redraw_position_plot(position=position) # Draw legend self.update_legend() @@ -826,7 +826,7 @@ def update_target_position_plot(self, position): self.mpl_canvas.draw() @Slot(list) - def update_position_plot(self, position): + def redraw_position_plot(self, position): self.logger.info(f"Drawing position {position}") if not self.display_position: From a7d52c9598a3ccf0b19b73a2b85c56faeec99473 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:34:13 -0700 Subject: [PATCH 175/177] refactor update_target_position_plot() -> redraw_target_position_plot() --- bapsf_motion/gui/configure/motion_space_display.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index d206381d..74de57ab 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -122,7 +122,7 @@ def _connect_redraw_signals(self): self.redrawSignals.All.connect(self.redraw_display) self.redrawSignals.MotionList.connect(self.redraw_motion_list_plot) self.redrawSignals.Position.connect(self.redraw_position_plot) - self.redrawSignals.TargetPosition.connect(self.update_target_position_plot) + self.redrawSignals.TargetPosition.connect(self.redraw_target_position_plot) def _connect_animate_motion_list_signals(self): self.animateMotionList.Clear.connect(self.animate_motion_list_clear) @@ -164,7 +164,7 @@ def redraw_motion_list_plot(self): ... @abstractmethod @Slot(list) - def update_target_position_plot(self, position): ... + def redraw_target_position_plot(self, position): ... @abstractmethod @Slot(list) @@ -278,7 +278,7 @@ def _connect_signals(self): self._connect_redraw_signals() self.mbChanged.connect(self.redraw_display) - self.targetPositionSelected.connect(self.update_target_position_plot) + self.targetPositionSelected.connect(self.redraw_target_position_plot) # matplotlib events self._mpl_pick_callback_id = self.mpl_canvas.mpl_connect( @@ -620,7 +620,7 @@ def redraw_display(self): # Draw target position if self.display_target_position: - self.update_target_position_plot(position=target_position) + self.redraw_target_position_plot(position=target_position) # Draw current position if self.display_position: @@ -783,7 +783,7 @@ def redraw_motion_list_plot(self): self.mpl_canvas.draw() @Slot(list) - def update_target_position_plot(self, position): + def redraw_target_position_plot(self, position): self.logger.info(f"Drawing target position {position}") if not self.display_target_position: From bf1272502233c0daa2768a4f6db1603a974300a6 Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 18:35:18 -0700 Subject: [PATCH 176/177] refactor update_legend() -> redraw_legend() --- bapsf_motion/gui/configure/motion_space_display.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index 74de57ab..ec1d669e 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -627,7 +627,7 @@ def redraw_display(self): self.redraw_position_plot(position=position) # Draw legend - self.update_legend() + self.redraw_legend() self.mpl_canvas.draw() @@ -639,7 +639,7 @@ def redraw_display(self): self.logger.info("Re-draw DONE.") - def update_legend(self): + def redraw_legend(self): _plotted_layers = ( [] if self._motionlist_plot_names is None else self._motionlist_plot_names ) @@ -779,7 +779,7 @@ def redraw_motion_list_plot(self): animated=True, ) - self.update_legend() + self.redraw_legend() self.mpl_canvas.draw() @Slot(list) @@ -822,7 +822,7 @@ def redraw_target_position_plot(self, position): animated=True, ) - self.update_legend() + self.redraw_legend() self.mpl_canvas.draw() @Slot(list) @@ -907,7 +907,7 @@ def redraw_position_plot(self, position): animated=True, ) - self.update_legend() + self.redraw_legend() self.mpl_canvas.draw() From 0f9c18083ebaa1a14e17d19623cd7c2273bb4efc Mon Sep 17 00:00:00 2001 From: Erik Date: Mon, 15 Jun 2026 19:06:59 -0700 Subject: [PATCH 177/177] MotionSpaceDisplay: fix setting (and consistency) of display visibility if the display type changes --- .../gui/configure/motion_builder_overlay.py | 2 - .../gui/configure/motion_group_widget.py | 3 ++ .../gui/configure/motion_space_display.py | 46 ++++++++++++++++--- 3 files changed, 42 insertions(+), 9 deletions(-) diff --git a/bapsf_motion/gui/configure/motion_builder_overlay.py b/bapsf_motion/gui/configure/motion_builder_overlay.py index ae0288cb..87fc31dd 100644 --- a/bapsf_motion/gui/configure/motion_builder_overlay.py +++ b/bapsf_motion/gui/configure/motion_builder_overlay.py @@ -125,8 +125,6 @@ def __init__(self, mg: MotionGroup, parent: "mgw.MGWidget | None" = None): # SET UP PLOT WIDGET self.mspace_display = MotionSpaceDisplay(parent=self) - self.mspace_display.display_position = False - self.mspace_display.display_target_position = False if isinstance(self.mg, MotionGroup) and isinstance(self.mg.mb, MotionBuilder): self.mspace_display.link_motion_builder(self.mg.mb) diff --git a/bapsf_motion/gui/configure/motion_group_widget.py b/bapsf_motion/gui/configure/motion_group_widget.py index c69f2546..0a935a4e 100644 --- a/bapsf_motion/gui/configure/motion_group_widget.py +++ b/bapsf_motion/gui/configure/motion_group_widget.py @@ -808,6 +808,9 @@ def _init_mspace_display(self): _policy = canvas.sizePolicy() _policy.setRetainSizeWhenHidden(True) canvas.setSizePolicy(_policy) + canvas.display_position = True + canvas.display_target_position = True + canvas.display_probe = True return canvas def _init_toml_widget(self): diff --git a/bapsf_motion/gui/configure/motion_space_display.py b/bapsf_motion/gui/configure/motion_space_display.py index ec1d669e..d566de61 100644 --- a/bapsf_motion/gui/configure/motion_space_display.py +++ b/bapsf_motion/gui/configure/motion_space_display.py @@ -15,7 +15,7 @@ from PySide6.QtCore import QObject, QTimer, Signal, Slot from PySide6.QtGui import QMouseEvent from PySide6.QtWidgets import QFrame, QSizePolicy, QVBoxLayout, QWidget -from typing import List, TYPE_CHECKING +from typing import Dict, List, TYPE_CHECKING from bapsf_motion.gui.configure.helpers import gui_logger from bapsf_motion.motion_builder import MotionBuilder @@ -933,6 +933,14 @@ def __init__(self, mb: MotionBuilder | None = None, parent: QWidget | None = Non self._logger = logging.getLogger(f"{gui_logger.name}.MSD") self._mb = self._init_motion_builder(mb) + # Initialize display attributes + self._display_visibility = { + "position": False, + "target_position": False, + "probe": False, + # "insertion_point": False, + } # type: Dict[str, bool] + # Define WIDGETS self.display = self._init_display() @@ -1031,6 +1039,9 @@ def _init_display(self) -> QWidget | _MSDBase: display = MotionSpaceDisplay2D( logger=self._logger, mb=self._mb, parent=self ) + display.display_position = self._display_visibility["position"] + display.display_target_position = self._display_visibility["target_position"] + display.display_probe = self._display_visibility["probe"] else: raise RuntimeError( "Can not create a display for the motion space. The " @@ -1064,44 +1075,65 @@ def mb(self) -> MotionBuilder | None: @property def display_position(self) -> bool: if not isinstance(self.display, _MSDBase): - return False + return self._display_visibility["position"] - return self.display.display_position + visibility = self.display.display_position + self._display_visibility["position"] = visibility + return visibility @display_position.setter def display_position(self, value: bool): + if not isinstance(value, bool): + return + if not isinstance(self.display, _MSDBase): + self._display_visibility["position"] = value return self.display.display_position = value + self._display_visibility["position"] = self.display.display_position @property def display_target_position(self) -> bool: if not isinstance(self.display, _MSDBase): - return False + return self._display_visibility["target_position"] - return self.display.display_target_position + visibility = self.display.display_target_position + self._display_visibility["target_position"] = visibility + return visibility @display_target_position.setter def display_target_position(self, value: bool): + if not isinstance(value, bool): + return + if not isinstance(self.display, _MSDBase): + self._display_visibility["target_position"] = value return self.display.display_target_position = value + self._display_visibility["target_position"] = self.display.display_target_position @property def display_probe(self) -> bool: if not isinstance(self.display, _MSDBase): - return False + return self._display_visibility["probe"] - return self.display.display_probe + visibility = self.display.display_probe + self._display_visibility["probe"] = visibility + return visibility @display_probe.setter def display_probe(self, value: bool): + if not isinstance(value, bool): + return + if not isinstance(self.display, _MSDBase): + self._display_visibility["probe"] = value return self.display.display_probe = value + self._display_visibility["probe"] = self.display.display_probe @property def is_animating_motion_list(self):