cgse-coordinates 0.17.2__py3-none-any.whl → 0.17.4__py3-none-any.whl

cgse_coordinates/settings.yaml

@@ -1,16 +0,0 @@
-Field-Of-View:
-
-    RADIUS_DEGREES:              18.8908        # Radius of the field-of-view [degrees]
-    RADIUS_PIXELS:                  4706        # Radius of the field-of-view [pixels]
-    RADIUS_MM:                      84.7        # Radius of the field-of-view [mm]
-    DISTORTION_COEFFICIENTS:  [0.316257210577,  0.066373219688,  0.372589221219]    # Distortion coefficients [k1, k3, k5]
-    FOCAL_LENGTH:                 247.52        # Focal length [mm]
-
-CCD:
-
-    ZEROPOINT:          [-1.3, 82.48]       # CCD zeropoint (x, y) [mm]
-    ORIENTATION:    [180, 270, 0, 90]       # Orientation of the CCD w.r.t. the focal plane [degrees]
-    PIXEL_SIZE:                    18       # Pixel size [µm]
-    NUM_ROWS:                    4510       # Number of rows
-    NUM_COLUMNS:                 4510       # Number of columns
-    LENGTH_SERIAL_PRESCAN:    25            # Number of columns in the serial pre-scan

{cgse_coordinates-0.17.2.dist-info → cgse_coordinates-0.17.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-coordinates
-Version: 0.17.2
+Version: 0.17.4
 Summary: Reference Frames and Coordinate Transofrmations for CGSE
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

cgse_coordinates-0.17.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+cgse_coordinates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cgse_coordinates/settings.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+egse/coordinates/__init__.py,sha256=2qscgRB43o1CHbwsPeXS6Jwpxf0yP2-5IiIksN0Wy4g,7154
+egse/coordinates/avoidance.py,sha256=m1707fSoOYibgbwtU3gG5Q7CgepjKpGISWvUqRj0ECw,4205
+egse/coordinates/cslmodel.py,sha256=7Ss5IAnoeW3UEu_C_HLsF9lWLH-FTaJPYs7FkVgQm68,5099
+egse/coordinates/laser_tracker_to_dict.py,sha256=-KVSHGDtvSGuOdGn35cWcrNHWhnNZuFjw_avJpYbLkU,3559
+egse/coordinates/point.py,sha256=IaXZpQqXidTF7Vtj9tgK-LtlEZjyUkx73gKg91-7aEw,30149
+egse/coordinates/pyplot.py,sha256=x8O2j0JcIJb1z-V1TJznzmTrS9Ux0UGM5lEe3a5zquI,6943
+egse/coordinates/reference_frame.py,sha256=VoMjwWrp7W_p_ECtawgH9TJTjQKxcn4xMbuvcqw8pMs,59780
+egse/coordinates/refmodel.py,sha256=9-pzy6mqcNRQnGTB23GRNEHd39Yt2idpd-GlJS31U9Q,29255
+egse/coordinates/rotation_matrix.py,sha256=I-IM3BQaLfA9UmDUWg223YPKgf2PLatiwe5OVNI_eM4,3941
+egse/coordinates/transform3d_addon.py,sha256=eEn1lPUNoEaZP4TBKRhUbu_AFwO1mHLSSh_Ja8Cc5Jc,19669
+cgse_coordinates-0.17.4.dist-info/METADATA,sha256=cA9cHNeRAU53hQVndnpd-D2ijM8wHNfvGrMgD758i2E,538
+cgse_coordinates-0.17.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cgse_coordinates-0.17.4.dist-info/entry_points.txt,sha256=0fHQmE6H38oAJq4DDdC39cikkIGQM23ZHMa-oXK8zq8,69
+cgse_coordinates-0.17.4.dist-info/RECORD,,

{cgse_coordinates-0.17.2.dist-info → cgse_coordinates-0.17.4.dist-info}/entry_points.txt

@@ -1,5 +1,2 @@
-[cgse.settings]
-cgse-coordinates = cgse_coordinates:settings.yaml
-
 [cgse.version]
 cgse-coordinates = egse.version:get_version_installed

egse/coordinates/__init__.py

@@ -1,334 +1,24 @@
 import ast
 import logging
 import re
-from math import atan
-from math import atan2
-from math import cos
-from math import degrees
-from math import pow
-from math import radians
-from math import sin
-from math import sqrt
-from math import tan
 from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Union
 
 import numpy as np
-from numpy.polynomial import Polynomial
-
-from egse.coordinates.referenceFrame import ReferenceFrame
-from egse.settings import Settings
-from egse.setup import Setup
-from egse.setup import load_setup
-from egse.state import GlobalState
 from egse.setup import navdict
 
 logger = logging.getLogger(__name__)
 
-FOV_SETTINGS = Settings.load("Field-Of-View")
-CCD_SETTINGS = Settings.load("CCD")
-
-
-def undistorted_to_distorted_focal_plane_coordinates(
-    x_undistorted, y_undistorted, distortion_coefficients, focal_length
-):
-    """
-    Conversion from undistorted to distorted focal-plane coordinates.  The distortion is a
-    radial effect and is defined as the difference in radial distance to the optical axis
-    between the distorted and undistorted coordinates, and can be expressed in terms of the
-    undistorted radial distance r as follows:
-
-        Δr = r * [(k1 * r**2) + (k2 * r**4) + (k3 * r**6)],
-
-    where the distortion and r are expressed in normalised focal-plane coordinates (i.e. divided
-    by the focal length, expressed in the same unit), and (k1, k2, k3) are the distortion
-    coefficients.
-
-    Args:
-        x_undistorted: Undistorted x-coordinate on the focal plane [mm].
-        y_undistorted: Undistorted y-coordinate on the focal plane [mm].
-        distortion_coefficients: List of polynomial coefficients for the field distortion.
-        focal_length: Focal length [mm].
-    Returns:
-        x_distorted: Distorted x-coordinate on the focal plane [mm].
-        y_distorted: Distorted y-coordinate on the focal plane [mm].
-    """
-
-    # Distortion coefficients -> (0, 0, 0, k1, 0, k2, 0, k3)
-
-    coefficients = [
-        0,
-        0,
-        0,
-        distortion_coefficients[0],
-        0,
-        distortion_coefficients[1],
-        0,
-        distortion_coefficients[2],
-    ]
-    distortion_polynomial = Polynomial(coefficients)
-
-    # Position on the focal plane:
-    #   - field angle [radians]
-    #   - radial distance from the optical axis [normalised pixels]
-
-    angle = atan2(y_undistorted, x_undistorted)
-    distance_undistorted = sqrt(pow(x_undistorted, 2) + pow(y_undistorted, 2)) / focal_length
-
-    # Distortion [mm]
-    # Source moves away from the optical axis (radially)
-
-    distortion = distortion_polynomial(distance_undistorted) * focal_length
-
-    # The field angle remains the same
-
-    x_distorted = x_undistorted + cos(angle) * distortion
-    y_distorted = y_undistorted + sin(angle) * distortion
-
-    return x_distorted, y_distorted
-
-
-def distorted_to_undistorted_focal_plane_coordinates(
-    x_distorted, y_distorted, inverse_distortion_coefficients, focal_length
-):
-    """
-    Conversion from distorted to undistorted focal-plane coordinates.  The inverse distortion is a
-    radial effect and is defined as the difference in radial distance to the optical axis
-    between the distorted and undistorted coordinates, and can be expressed in terms of the
-    undistorted radial distance r as follows:
-
-        Δr = r * [(k1 * r**2) + (k2 * r**4) + (k3 * r**6)],
-
-    where the inverse distortion and r are expressed in normalised focal-plane coordinates (i.e. divided
-    by the focal length, expressed in the same unit), and (k1, k2, k3) are the inverse distortion
-    coefficients.
-
-    Args:
-        x_distorted: Distorted x-coordinate on the focal plane [mm].
-        y_distorted: Distorted y-coordinate on the focal plane [mm].
-        inverse_distortion_coefficients: List of polynomial coefficients for the inverse field distortion.
-        focal_length: Focal length [mm].
-    Returns:
-        x_undistorted: Undistorted x-coordinate on the focal plane [mm].
-        y_undistorted: Undistorted y-coordinate on the focal plane [mm].
-    """
-
-    # Inverse distortion coefficients -> (0, 0, 0, k1, 0, k2, 0, k3)
-
-    coefficients = [
-        0,
-        0,
-        0,
-        inverse_distortion_coefficients[0],
-        0,
-        inverse_distortion_coefficients[1],
-        0,
-        inverse_distortion_coefficients[2],
-    ]
-    inverse_distortion_polynomial = Polynomial(coefficients)
-
-    # Position on the focal plane:
-    #   - field angle [radians]
-    #   - radial distance from the optical axis [normalised pixels]
-
-    angle = atan2(y_distorted, x_distorted)
-    distance_distorted = sqrt(pow(x_distorted, 2) + pow(y_distorted, 2)) / focal_length
-
-    # Inverse distortion [mm]
-    # Source moves towards the optical axis (radially) -> negative!
-
-    inverse_distortion = inverse_distortion_polynomial(distance_distorted) * focal_length
-
-    # The field angle remains the same
-
-    x_undistorted = x_distorted + cos(angle) * inverse_distortion
-    y_undistorted = y_distorted + sin(angle) * inverse_distortion
-
-    return x_undistorted, y_undistorted
-
-
-def focal_plane_to_ccd_coordinates(x_fp, y_fp, setup: Setup = None):
-    """
-    Conversion from focal-plane to pixel coordinates on the appropriate CCD.
-
-    Args:
-        x_fp: Focal-plane x-coordinate [mm].
-        y_fp: Focal-plane y-coordinate [mm].
-        setup: Setup
-    Returns:
-        Pixel coordinates (row, column) and the corresponding CCD.  If the given
-        focal-plane coordinates do not fall on any CCD, (None, None, None) is
-        returned.
-    """
-
-    setup = setup or load_setup()
-
-    if setup is not None:
-        num_rows = setup.camera.ccd.num_rows
-        num_cols = setup.camera.ccd.num_column
-    else:
-        num_rows = CCD_SETTINGS.NUM_ROWS
-        num_cols = CCD_SETTINGS.NUM_COLUMNS
-
-    for ccd_code in range(1, 5):
-        (row, column) = __focal_plane_to_ccd_coordinates__(x_fp, y_fp, ccd_code)
-
-        if (row < 0) or (column < 0):
-            continue
-
-        if (row >= num_rows) or (column >= num_cols):
-            continue
-
-        return row, column, ccd_code
-
-    return None, None, None
-
-
-def __focal_plane_to_ccd_coordinates__(x_fp, y_fp, ccd_code):
-    """
-    Conversion from focal-plane coordinates to pixel coordinates on the given CCD.
-
-    Args:
-        x_fp: Focal-plane x-coordinate [mm].
-        y_fp: Focal-plane y-coordinate [mm].
-        ccd_code: Code of the CCD for which to calculate the pixel coordinates [1, 2, 3, 4].
-    Returns:
-        Pixel coordinates (row, column) on the given CCD.
-    """
-
-    if GlobalState.setup is None:
-        ccd_orientation = CCD_SETTINGS.ORIENTATION[int(ccd_code) - 1]
-        pixel_size = CCD_SETTINGS.PIXEL_SIZE / 1000  # Pixel size [mm]
-        ccd_origin_x = CCD_SETTINGS.ZEROPOINT[0]
-        ccd_origin_y = CCD_SETTINGS.ZEROPOINT[1]
-    else:
-        ccd_orientation = GlobalState.setup.camera.ccd.orientation[int(ccd_code) - 1]
-        pixel_size = GlobalState.setup.camera.ccd.pixel_size / 1000.0  # [mm]
-        ccd_origin_x = GlobalState.setup.camera.ccd.origin_offset_x[int(ccd_code) - 1]
-        ccd_origin_y = GlobalState.setup.camera.ccd.origin_offset_y[int(ccd_code) - 1]
-
-    ccd_angle = radians(ccd_orientation)
-
-    # CCD coordinates [mm]
-
-    row = ccd_origin_y - x_fp * sin(ccd_angle) + y_fp * cos(ccd_angle)
-    column = ccd_origin_x + x_fp * cos(ccd_angle) + y_fp * sin(ccd_angle)
-
-    row /= pixel_size
-    column /= pixel_size
-
-    return row, column
-
-
-def focal_plane_coordinates_to_angles(x_fp, y_fp):
-    """
-    Conversion from focal-plane coordinates to the gnomonic distance from the optical axis and
-    the in-field angle.
-
-    NOTE: if no valid Setup is loaded in the global state, the FOV_SETTINGS will be used to
-          determine the focal length.
-
-    Args:
-        x_fp: Focal-plane x-coordinate [mm].
-        y_fp: Focal-plane y-coordinate [mm].
-    Returns:
-        Gnomonic distance from the optical axis and in-field angle [degrees].
-    """
-
-    if GlobalState.setup is None:
-        focal_length_mm = FOV_SETTINGS.FOCAL_LENGTH
-    else:
-        focal_length_mm = GlobalState.setup.camera.fov.focal_length_mm
-
-    theta = degrees(atan(sqrt(pow(x_fp, 2) + pow(y_fp, 2)) / focal_length_mm))
-    phi = degrees(atan2(y_fp, x_fp))
-
-    return theta, phi
-
-
-def ccd_to_focal_plane_coordinates(row, column, ccd_code):
-    """
-    Conversion from pixel-coordinates on the given CCD to focal-plane coordinates.
-
-    NOTE: if no valid Setup is loaded in the global state, the CCD_SETTINGS will be used to
-          determine the ccd information.
-
-    Args:
-        row: Row coordinate [pixels].
-        column: Column coordinate [pixels].
-        ccd_code: Code of the CCD for which the pixel coordinates are given.
-    Returns:
-        Focal-plane coordinates (x, y) [mm].
-    """
-
-    if GlobalState.setup is None:
-        ccd_orientation = CCD_SETTINGS.ORIENTATION[int(ccd_code) - 1]
-        pixel_size_mm = CCD_SETTINGS.PIXEL_SIZE / 1000  # Pixel size [mm]
-        ccd_origin_x = CCD_SETTINGS.ZEROPOINT[0]
-        ccd_origin_y = CCD_SETTINGS.ZEROPOINT[1]
-    else:
-        ccd_orientation = GlobalState.setup.camera.ccd.orientation[int(ccd_code) - 1]
-        pixel_size_mm = GlobalState.setup.camera.ccd.pixel_size / 1000.0  # [mm]
-        ccd_origin_x = GlobalState.setup.camera.ccd.origin_offset_x[int(ccd_code) - 1]
-        ccd_origin_y = GlobalState.setup.camera.ccd.origin_offset_y[int(ccd_code) - 1]
-
-    # Convert the pixel coordinates into [mm] coordinates
-
-    row_mm = row * pixel_size_mm
-    column_mm = column * pixel_size_mm
-
-    # Convert the CCD coordinates into FP coordinates [mm]
-
-    ccd_angle = radians(ccd_orientation)
-
-    x_fp = (column_mm - ccd_origin_x) * cos(ccd_angle) - (row_mm - ccd_origin_y) * sin(ccd_angle)
-    y_fp = (column_mm - ccd_origin_x) * sin(ccd_angle) + (row_mm - ccd_origin_y) * cos(ccd_angle)
-
-    # That's it
-
-    return x_fp, y_fp
-
-
-def angles_to_focal_plane_coordinates(theta, phi):
-    """
-    Conversion from the gnomonic distance from the optical axis and
-    the in-field angle to focal-plane coordinates.
-
-    NOTE: if no valid Setup is loaded in the global state, the FOV_SETTINGS will be used to
-          determine the focal length.
-
-    Args:
-        theta: Gnomonic distance from the optical axis [degrees].
-        phi: In-field angle [degrees].
-    Returns:
-        Focal-plane coordinates (x, y) [mm].
-    """
-
-    if GlobalState.setup is None:
-        focal_length_mm = FOV_SETTINGS.FOCAL_LENGTH
-    else:
-        focal_length_mm = GlobalState.setup.camera.fov.focal_length_mm
-
-    distance = focal_length_mm * tan(radians(theta))  # [mm]
-
-    phi_radians = radians(phi)
-
-    x_fp = distance * cos(phi_radians)
-    y_fp = distance * sin(phi_radians)
-
-    return x_fp, y_fp
-
 
 def dict_to_ref_model(model_def: Union[Dict, List]) -> navdict:
-    """
-    Creates a reference frames model from a dictionary or list of reference frame definitions.
+    """Creates a reference frames model from a dictionary or list of reference frame definitions.
 
     When a list is provided, the items in the list must be ReferenceFrames.
 
-    The reference frame definitions are usually read from a YAML file or returned by a Setup,
-    but can also be just ReferenceFrame objects.
+    The reference frame definitions are usually read from a YAML file or returned by a Setup, but can also be just
+    ReferenceFrame objects.
 
     ReferenceFrame definitions have the following format:
 
@@ -343,15 +33,17 @@ def dict_to_ref_model(model_def: Union[Dict, List]) -> navdict:
     * a dictionary of links
 
     Args:
-        model_def (dict or list): the definition of the reference model
+        model_def (dict or list): Definition of the reference model.
 
     Returns:
-        A dictionary representing the reference frames model.
+        Dictionary representing the reference frames model.
     """
 
     ref_model = navdict()
     ref_links = {}
 
+    from egse.coordinates.reference_frame import ReferenceFrame
+
     def create_ref_frame(name, data) -> Union[ReferenceFrame, str]:
         # This is a recursive function that creates a reference frame based on the given data.
         # * When the data is already a ReferenceFrame, it just returns data
@@ -371,22 +63,22 @@ def dict_to_ref_model(model_def: Union[Dict, List]) -> navdict:
 
         translation, rotation, name, ref_name, links = match[1].split(" | ")
 
-        # all links are processed later..
+        # All links are processed later
 
         ref_links[name] = ast.literal_eval(links)
 
         if ref_name == name == "Master":
-            ref_model.add(ref_name, ReferenceFrame.createMaster())
+            ref_model.add(ref_name, ReferenceFrame.create_master())
             return ref_model["Master"]
 
         if ref_name not in ref_model:
             ref_model.add(ref_name, create_ref_frame(ref_name, model_def[ref_name]))
 
-        ref_frame = ReferenceFrame.fromTranslationRotation(
+        ref_frame = ReferenceFrame.from_translation_rotation(
             deserialize_array(translation),
             deserialize_array(rotation),
             name=name,
-            ref=ref_model[ref_name],
+            reference_frame=ref_model[ref_name],
         )
 
         return ref_frame
@@ -405,8 +97,8 @@ def dict_to_ref_model(model_def: Union[Dict, List]) -> navdict:
     for ref_name, link_names in ref_links.items():
         ref = ref_model[ref_name]
         for link_name in link_names:
-            if link_name not in ref.linkedTo:
-                ref.addLink(ref_model[link_name])
+            if link_name not in ref.linked_to:
+                ref.add_link(ref_model[link_name])
 
     return ref_model
 
@@ -415,10 +107,10 @@ def ref_model_to_dict(ref_model) -> navdict:
     """Creates a dictionary with reference frames definitions that define a reference model.
 
     Args:
-        ref_model: A dictionary representing the reference frames model or a list of reference
-            frames.
+        ref_model: A dictionary representing the reference frames model or a list of reference frames.
+
     Returns:
-        A dictionary of reference frame definitions.
+        Dictionary of reference frame definitions.
     """
 
     if isinstance(ref_model, dict):
@@ -429,14 +121,14 @@ def ref_model_to_dict(ref_model) -> navdict:
     model_def = {}
 
     for ref in ref_model:
-        translation, rotation = ref.getTranslationRotationVectors()
-        links = [ref.name for ref in ref.linkedTo]
+        translation, rotation = ref.get_translation_rotation_vectors()
+        links = [ref.name for ref in ref.linked_to]
         model_def[ref.name] = (
             f"ReferenceFrame//("
             f"{serialize_array(translation, precision=6)} | "
             f"{serialize_array(rotation, precision=6)} | "
             f"{ref.name} | "
-            f"{ref.ref.name} | "
+            f"{ref.reference_frame.name} | "
             f"{links})"
         )
 
@@ -456,7 +148,7 @@ def serialize_array(arr: Union[np.ndarray, list], precision: int = 4) -> str:
     '[[1.00, 2.20, 3.00], [4.30, 5.00, 6.00]]'
 
     Args:
-        arr: a one or two dimensional numpy array or list.
+        arr: One- or-two dimensional numpy array or list.
         precision (int): number of digits of precision
     Returns:
         A string representing the input array.
@@ -475,8 +167,8 @@ def serialize_array(arr: Union[np.ndarray, list], precision: int = 4) -> str:
 def deserialize_array(arr_str: str) -> Optional[np.ndarray]:
     """Returns a numpy array from the given string.
 
-    The input string is interpreted as a one or two-dimensional array, with commas or spaces
-    separating the columns, and semi-colons separating the rows.
+    The input string is interpreted as a one or two-dimensional array, with commas or spaces separating the columns,
+    and semicolons separating the rows.
 
     >>> deserialize_array('1,2,3')
     array([1, 2, 3])
@@ -490,10 +182,10 @@ def deserialize_array(arr_str: str) -> Optional[np.ndarray]:
            [4, 5, 6]])
 
     Args:
-        arr_str: string representation of a numpy array
+        arr_str: String representation of a numpy array.
+
     Returns:
-        A one or two-dimensional numpy array or `None` when input string cannot be parsed into a
-        numpy array.
+        One- or two-dimensional numpy array or `None` when input string cannot be parsed into a numpy array.
     """
 
     import re
@@ -507,7 +199,7 @@ def deserialize_array(arr_str: str) -> Optional[np.ndarray]:
     return None
 
 
-def _convert_from_string(data):
+def _convert_from_string(data: str) -> list[list]:
     # This function was copied from:
     #   https://github.com/numpy/numpy/blob/v1.19.0/numpy/matrixlib/defmatrix.py#L14
     # We include the function here because the np.matrix class is deprecated and will be removed.
@@ -533,4 +225,5 @@ def _convert_from_string(data):
             raise ValueError("Rows not the same size.")
         count += 1
         new_data.append(new_row)
+
     return new_data

egse/coordinates/avoidance.py

@@ -1,61 +1,50 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Wed Sep  9 17:19:47 2020
-
-@author: pierre
-"""
-
 import numpy as np
 
 from egse.coordinates.point import Points
+from egse.coordinates.reference_frame import ReferenceFrame
 from egse.setup import Setup, load_setup
 
 
-def is_avoidance_ok(hexusr, hexobj, setup: Setup = None, verbose=False):
-    """
-    is_avoidance_ok(hexusr,hexobj,setup=None)
+def is_avoidance_ok(hexusr: ReferenceFrame, hexobj: ReferenceFrame, setup: Setup = None, verbose: bool = False):
+    """Checks whether the FPA is outside the avoidance volume around L6.
 
-    INPUT
-    hexusr : ReferenceFrame
-             xy plane = maximal height of the FPA_SEN
-             z axis  pointing away from the FPA
+    This function is used to verify that a requested movement of the PUNA hexapod will not cause the FPA to enter the
+    avoidance volume around L6.
 
-    hexobj : ReferenceFrame
-             xy plane = FPA_SEN
-             z axis pointing towards L6
 
-    setup  : optional, if not provided, load_setup() is used
+    Args:
+        hexusr (ReferenceFrame): User Reference Frame for the PUNA hexapod.  Its xy-plane corresponds to the maximum
+                                 height of FPA_SEN.  Its z-axis points away from the FPA.
+        hexobj (ReferenceFrame): Object Reference Frame for the PUNA hexapod.  Its xy-plane coincides with FPA_SEN. Its
+                                 z-axis points towards L6.
+        setup (Setup): Setup object containing the default reference frames.
+        verbose (bool): Indicates whether to print verbose output.
 
-
-    OUTPUT :  Boolean indicating whether the FPA is outside the avoidance volume around L6
+    Returns:
+        True if the FPA is outside the avoidance volume around L6; False otherwise.
     """
 
     setup = setup or load_setup()
 
-    """
-    A. HORIZONTAL AVOIDANCE
-    Ensure that the center of L6, materialised by HEX_USR (incl. z-direction security wrt TOU_L6)
-    stays within a given radius of the origin of FPA_SEN
-    """
+    # A. HORIZONTAL AVOIDANCE
+    # Ensure that the centre of L6, materialised by HEX_USR (incl. z-direction security wrt TOU_L6) stays within a
+    # given radius of the origin of FPA_SEN
 
     # Clearance = the tolerance in every horizontal direction (3 mm; PLATO-KUL-PL-ICD-0001 v1.2)
     clearance_xy = setup.camera.fpa.avoidance.clearance_xy
 
-    # l6xy = the projection of the origin of HEX_USR on the X-Y plane of FPA_SEN
-    l6xy = hexusr.getOrigin().expressIn(hexobj)[:2]
+    # Projection of the origin of HEX_USR on the xy-plane of FPA_SEN
+    l6xy = hexusr.get_origin().express_in(hexobj)[:2]
 
-    # !! This is a verification of the current situation --> need to replace by a simulation of the forthcoming
-    # movement in the building block
+    # !! This is a verification of the current situation
+    # -> need to replace by a simulation of the forthcoming movement in the building block
     horizontal_check = (l6xy[0] ** 2.0 + l6xy[1] ** 2.0) < clearance_xy * clearance_xy
 
-    """
-    B. VERTICAL AVOIDANCE
-    Ensure that the CCD never hits L6.
-    The definition of HEX_USR includes a tolerance below L6 (1.65 mm)
-    We include a tolerance above FPA_SEN here (0.3 mm)
-    We define a collection of points to act at the vertices of the avoidance volume above the FPA
-    """
+    # B. VERTICAL AVOIDANCE
+    # Ensure that the CCD never hits L6.
+    #   - The definition of HEX_USR includes a tolerance below L6 (1.65 mm).
+    #   - We include a tolerance above FPA_SEN here (0.3 mm).
+    #   - We define a collection of points to act at the vertices. of the avoidance volume above the FPA
 
     # Clearance = vertical uncertainty on the CCD location (0.3 mm; PLATO-KUL-PL-ICD-0001 v1.2)
     clearance_z = setup.camera.fpa.avoidance.clearance_z
@@ -70,12 +59,15 @@ def is_avoidance_ok(hexusr, hexobj, setup: Setup = None, verbose=False):
     vertices_y = np.sin(angles) * vertices_radius
     vertices_z = np.ones_like(angles) * clearance_z
 
-    # The collection of Points defining the avoidance volume around FPA_SEN
-    vert_obj = Points(coordinates=np.array([vertices_x, vertices_y, vertices_z]), ref=hexobj, name="vert_obj")
+    # The collection of points defining the avoidance volume around FPA_SEN
+
+    vert_obj = Points(
+        coordinates=np.array([vertices_x, vertices_y, vertices_z]), reference_frame=hexobj, name="vert_obj"
+    )
 
     # Their coordinates in HEX_USR
-    # NB: vert_obj is a Points, vert_usr is an array
-    vert_usr = vert_obj.expressIn(hexusr)
+    # NB: vert_obj is a Points object, vert_usr is an array
+    vert_usr = vert_obj.express_in(hexusr)
 
     # !! Same as above : this is verifying the current situation, not the one after a planned movement
     # Verify that all vertices ("protecting" FPA_SEN) are below the x-y plane of HEX_USR ("protecting" L6)