cgse 2023.38.0__py3-none-any.whl → 2024.1.3__py3-none-any.whl

egse/coordinates/rotationMatrix.py

@@ -1,85 +0,0 @@
-"""
-The RotationMatrix provides a number of convenience methods to define and apply rotations.
-
-@author: pierre
-"""
-
-import transforms3d as t3
-import numpy as np
-
-class RotationMatrix():
-    """
-    RotationMatrix(angle1, angle2, angle3, rot_config="sxyz", active=True)
-    
-    The ``angle`` parameters provide the amplitude of rotation around an axis 
-    according to the order of rotations corresponding to the ``rot_config`` parameter.
-
-    The ``rot_config`` parameter is a string that consists of four letter
-    indicating the rotation system and the order of applying the rotations. The default 
-    for this parameter is ``"rxyz"`` where the first character can be 'r' or 's' and 
-    the next three characters define the axes of rotation in the order specified, here 'xyz'.
-
-    * 'r' stands for rotating system (intrinsic rotations)
-    * 's' stands for static system (extrinsic rotations)
-    * "rxyz" imposes angle1 describes the rotation around X
-    * even if two angles = 0, the match between angle orders and rot_config is still critical
-    
-    :param str rot_config: otation system to be used, 4 characters. Default = "sxyz"
-
-    :param float angle1: amplitude of rotations around the first axis
-
-    :param float angle2: amplitude of rotations around the second axis
-    
-    :param float angle3: amplitude of rotations around the third axis
-    
-    :param bool active: when True the object rotates **in** a fixed coord system,
-        when False the coord system rotates **around** a fixed object
-        The default for the transform3d.euleur package is to represent movements
-        of the coordinate system itself --> **around** the object <==> passive
-    """
-    _ROT_CONFIG_DEFAULT = 'sxyz'
-
-    def __init__(self,angle1,angle2,angle3,rot_config=_ROT_CONFIG_DEFAULT,active=True):
-        R = t3.euler.euler2mat(angle1,angle2,angle3,rot_config)
-        if active:
-            self.R = R
-        else:
-            self.R = R.T
-        rot_config_array = np.array(list(rot_config[1:]))
-        angles_array = np.array([angle1,angle2,angle3])
-        self.angles_hash = {}
-        for axis in ['x','y','z']:
-            self.angles_hash[axis] = angles_array[np.where(rot_config_array==axis)[0][0]]
-        self.active=active
-
-
-    def getRotationMatrix(self):
-        '''Return the Rotation Matrix'''
-        return self.R
-
-
-    def trace(self):
-        return np.sum([self.R[i,i] for i in range(3)])
-
-
-    def getAngle(self, axis):
-        """
-        Returns the angle 
-
-        :param str axis: 'x', 'y', 'z'
-
-        :return: the angle 
-        """
-        return self.angles_hash[axis]
-
-
-    def apply(self, vectors):
-        """
-        if self = active, the output = the coords of these vectors after rotation
-
-        if self = passive, the ouput = the coords of these vectors after transformation to the rotated coordinate system
-
-        :param vectors: an array of shape [3,N] gathering a set of vectors along its columns
-        """
-        return np.dot(self.R, vectors)
-

egse/coordinates/transform3d_addon.py

@@ -1,419 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Jun 25 16:25:33 2018
-
-@author: pierre
-"""
-import numpy
-import numpy as np
-import math
-import transforms3d as t3
-
-from egse.coordinates.rotationMatrix import RotationMatrix
-
-def affine_isEuclidian(matrix):
-    """
-    Tests if a matrix is a pure solid-body euclidian rotation + translation (no shear or scaling)
-    
-    We only need to check that 
-    . the rotation part is orthogonal : R @ R.T = I
-    . the det(R) = 1  (=> this is not a reflexion) 
-    """
-    rotation = matrix[:3,:3]
-    return np.allclose((rotation @ rotation.T),np.identity(3)) & np.allclose(np.linalg.det(matrix),1)
-
-def affine_inverse(matrix):
-    """
-    affine_inverse(matrix)
-    
-    WARNING: 
-    This is NOT a generic inversion of an affine transformation matrix
-    
-    This returns the affine transformation inverting that produced by the input matrix, 
-    
-    ASSSUMING that only rotation and translation were involved 
-    in the affine transformation, no zoom, no shear!
-    
-    That preserves the fact that the orthogonal property of the part of the input matrix
-    corresponding to rotation => the inverse is simply the transpose.
-    
-    Pierre Royer
-    """
-    #import numpy as np
-
-    # Extract Rotation matrix and translation vector from input affine transformation
-    R = matrix[:3,:3]
-    t = matrix[:3,3]
-    #
-    # Invert the rotation and the translation
-    Rinv = R.T
-    tinv = -t
-    #
-    # The inverse affine is composed from R^-1 for the rotation and -(R^-1 . t) for the translation
-    result = np.identity(4)
-    result[:3,:3] = Rinv
-    result[:3,3]  = np.dot(Rinv,tinv)
-    
-    if affine_isEuclidian(result):
-        return result
-    else:
-        print("WARNING: This is not a rigid-body transformation matrix")
-        #print(f"R.T-based  (.6f) = \n {np.round(result,6)}")
-        #print(f"np.inverse (.6f) = \n {np.round(np.linalg.inv(matrix),6)}")
-        return np.linalg.inv(matrix)
-
-def affine_matrix_from_points(v0, v1, shear=False, scale=False, usesvd=True):
-    """affine_matrix_from_points(v0, v1, shear=False, scale=False, usesvd=True)
-    Return affine transform matrix to register two point sets.
-
-    v0 and v1 are shape (ndims, \*) arrays of at least ndims non-homogeneous
-    coordinates, where ndims is the dimensionality of the coordinate space.
-
-    If shear is False, a similarity transformation matrix is returned.
-    If also scale is False, a rigid/Euclidean transformation matrix
-    is returned.
-
-    By default the algorithm by Hartley and Zissermann [15] is used.
-    If usesvd is True, similarity and Euclidean transformation matrices
-    are calculated by minimizing the weighted sum of squared deviations
-    (RMSD) according to the algorithm by Kabsch [8].
-    Otherwise, and if ndims is 3, the quaternion based algorithm by Horn [9]
-    is used, which is slower when using this Python implementation.
-
-    The returned matrix performs rotation, translation and uniform scaling
-    (if specified).
-
-    >>> v0 = [[0, 1031, 1031, 0], [0, 0, 1600, 1600]]
-    >>> v1 = [[675, 826, 826, 677], [55, 52, 281, 277]]
-    >>> affine_matrix_from_points(v0, v1)
-    array([[   0.14549,    0.00062,  675.50008],
-           [   0.00048,    0.14094,   53.24971],
-           [   0.     ,    0.     ,    1.     ]])
-    >>> T = translation_matrix(numpy.random.random(3)-0.5)
-    >>> R = random_rotation_matrix(numpy.random.random(3))
-    >>> S = scale_matrix(random.random())
-    >>> M = concatenate_matrices(T, R, S)
-    >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20
-    >>> v0[3] = 1
-    >>> v1 = numpy.dot(M, v0)
-    >>> v0[:3] += numpy.random.normal(0, 1e-8, 300).reshape(3, -1)
-    >>> M = affine_matrix_from_points(v0[:3], v1[:3])
-    >>> numpy.allclose(v1, numpy.dot(M, v0))
-    True
-
-    More examples in superimposition_matrix()
-
-    Author: this function was extracted from the original transformations.py 
-            written by Christoph Golke:
-            https://www.lfd.uci.edu/~gohlke/code/transformations.py.html
-            
-    usesvd controls the use of a method based on Singular Value Decomposition (SVD)
-    --> when True, it is equivalent to rigid_transform_3D (see below)
-
-    """
-    import numpy
-    v0 = numpy.array(v0, dtype=numpy.float64, copy=True)
-    v1 = numpy.array(v1, dtype=numpy.float64, copy=True)
-
-    ndims = v0.shape[0]
-    if ndims < 2 or v0.shape[1] < ndims or v0.shape != v1.shape:
-        print(f"ndims {ndims} v0/1.shape {v0.shape} {v1.shape} v0/1 class {v0.__class__} {v1.__class__}")
-        raise ValueError('input arrays are of wrong shape or type')
-
-    # move centroids to origin
-    t0 = -numpy.mean(v0, axis=1)
-    M0 = numpy.identity(ndims+1)
-    M0[:ndims, ndims] = t0
-    v0 += t0.reshape(ndims, 1)
-    t1 = -numpy.mean(v1, axis=1)
-    M1 = numpy.identity(ndims+1)
-    M1[:ndims, ndims] = t1
-    v1 += t1.reshape(ndims, 1)
-
-    if shear:
-        # Affine transformation
-        A = numpy.concatenate((v0, v1), axis=0)
-        u, s, vh = numpy.linalg.svd(A.T)
-        vh = vh[:ndims].T
-        B = vh[:ndims]
-        C = vh[ndims:2*ndims]
-        t = numpy.dot(C, numpy.linalg.pinv(B))
-        t = numpy.concatenate((t, numpy.zeros((ndims, 1))), axis=1)
-        M = numpy.vstack((t, ((0.0,)*ndims) + (1.0,)))
-    elif usesvd or ndims != 3:
-        # Rigid transformation via SVD of covariance matrix
-        u, s, vh = numpy.linalg.svd(numpy.dot(v1, v0.T))
-        # rotation matrix from SVD orthonormal bases
-        R = numpy.dot(u, vh)
-        if numpy.linalg.det(R) < 0.0:
-            # R does not constitute right handed system
-            R -= numpy.outer(u[:, ndims-1], vh[ndims-1, :]*2.0)
-            s[-1] *= -1.0
-        # homogeneous transformation matrix
-        M = numpy.identity(ndims+1)
-        M[:ndims, :ndims] = R
-    else:
-        # Rigid transformation matrix via quaternion
-        # compute symmetric matrix N
-        xx, yy, zz = numpy.sum(v0 * v1, axis=1)
-        xy, yz, zx = numpy.sum(v0 * numpy.roll(v1, -1, axis=0), axis=1)
-        xz, yx, zy = numpy.sum(v0 * numpy.roll(v1, -2, axis=0), axis=1)
-        N = [[xx+yy+zz, 0.0,      0.0,      0.0],
-             [yz-zy,    xx-yy-zz, 0.0,      0.0],
-             [zx-xz,    xy+yx,    yy-xx-zz, 0.0],
-             [xy-yx,    zx+xz,    yz+zy,    zz-xx-yy]]
-        # quaternion: eigenvector corresponding to most positive eigenvalue
-        w, V = numpy.linalg.eigh(N)
-        q = V[:, numpy.argmax(w)]
-        q /= _vector_norm(q)  # unit quaternion
-        # homogeneous transformation matrix
-        M = _quaternion_matrix(q)
-
-    if scale and not shear:
-        # Affine transformation; scale is ratio of RMS deviations from centroid
-        v0 *= v0
-        v1 *= v1
-        M[:ndims, :ndims] *= math.sqrt(numpy.sum(v1) / numpy.sum(v0))
-
-    # move centroids back
-    M = numpy.dot(numpy.linalg.inv(M1), numpy.dot(M, M0))
-    M /= M[ndims, ndims]
-    return M
-
-
-def _vector_norm(data, axis=None, out=None):
-    """Return length, i.e. Euclidean norm, of ndarray along axis.
-
-    >>> v = numpy.random.random(3)
-    >>> n = vector_norm(v)
-    >>> numpy.allclose(n, numpy.linalg.norm(v))
-    True
-    >>> v = numpy.random.rand(6, 5, 3)
-    >>> n = vector_norm(v, axis=-1)
-    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=2)))
-    True
-    >>> n = vector_norm(v, axis=1)
-    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
-    True
-    >>> v = numpy.random.rand(5, 4, 3)
-    >>> n = numpy.empty((5, 3))
-    >>> vector_norm(v, axis=1, out=n)
-    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
-    True
-    >>> vector_norm([])
-    0.0
-    >>> vector_norm([1])
-    1.0
-    
-    This function is called by affine_matrix_from_points when usesvd=False
-
-    Author: this function was extracted from the original transformations.py 
-            written by Christoph Golke:
-            https://www.lfd.uci.edu/~gohlke/code/transformations.py.html
-
-    """
-    data = numpy.array(data, dtype=numpy.float64, copy=True)
-    if out is None:
-        if data.ndim == 1:
-            return math.sqrt(numpy.dot(data, data))
-        data *= data
-        out = numpy.atleast_1d(numpy.sum(data, axis=axis))
-        numpy.sqrt(out, out)
-        return out
-    else:
-        data *= data
-        numpy.sum(data, axis=axis, out=out)
-        numpy.sqrt(out, out)
-
-
-def _quaternion_matrix(quaternion):
-    """Return homogeneous rotation matrix from quaternion.
-
-    >>> M = quaternion_matrix([0.99810947, 0.06146124, 0, 0])
-    >>> numpy.allclose(M, rotation_matrix(0.123, [1, 0, 0]))
-    True
-    >>> M = quaternion_matrix([1, 0, 0, 0])
-    >>> numpy.allclose(M, numpy.identity(4))
-    True
-    >>> M = quaternion_matrix([0, 1, 0, 0])
-    >>> numpy.allclose(M, numpy.diag([1, -1, -1, 1]))
-    True
-
-    This function is called by affine_matrix_from_points when usesvd=False
-
-    Author: this function was extracted from the original transformations.py 
-            written by Christoph Golke:
-            https://www.lfd.uci.edu/~gohlke/code/transformations.py.html
-    """
-    _EPS = np.finfo(float).eps * 5
-    
-    q = numpy.array(quaternion, dtype=numpy.float64, copy=True)
-    n = numpy.dot(q, q)
-    if n < _EPS:
-        return numpy.identity(4)
-    q *= math.sqrt(2.0 / n)
-    q = numpy.outer(q, q)
-    return numpy.array([
-        [1.0-q[2, 2]-q[3, 3],     q[1, 2]-q[3, 0],     q[1, 3]+q[2, 0], 0.0],
-        [    q[1, 2]+q[3, 0], 1.0-q[1, 1]-q[3, 3],     q[2, 3]-q[1, 0], 0.0],
-        [    q[1, 3]-q[2, 0],     q[2, 3]+q[1, 0], 1.0-q[1, 1]-q[2, 2], 0.0],
-        [                0.0,                 0.0,                 0.0, 1.0]])
-
-
-def rigid_transform_3D(fromA, toB, verbose=True):
-    """rigid_transform_3D(fromA, toB, verbose=True)
-    
-    INPUT
-    Afrom, Bto 3xn arrays = xyz coords of n points to be registered
-    
-    OUTPUT
-    Rotation + translation transformation matrix registering fromA into toB
-    
-    Author : Nghia Ho - 2013 - http://nghiaho.com/?page_id=671
-            "Finding optimal rotation and translation between corresponding 3D points"
-             Based on "A Method for Registration of 3-D Shapes", by Besl and McKay, 1992.
-             
-    This is based on Singular Value Decomposition (SVD) 
-    --> it is equivalent to affine_matrix_from_points with parameter usesvd=True
-    """
-    A = fromA.T
-    B = toB.T
-    
-    assert len(A) == len(B)
-    
-    N = A.shape[0]; # total points
-
-    centroid_A = np.mean(A, axis=0)
-    centroid_B = np.mean(B, axis=0)
-    
-    # centre the points
-    AA = A - np.tile(centroid_A, (N, 1))
-    BB = B - np.tile(centroid_B, (N, 1))
-    
-    # @ is matrix multiplication for array
-    H = np.transpose(AA) @ BB
-    
-    U, S, Vt = np.linalg.svd(H)
-    
-    R = Vt.T @ U.T
-    
-    # special reflection case
-    if np.linalg.det(R) < 0:
-       print ("Reflection detected")
-       Vt[2,:] *= -1
-       R = Vt.T @ U.T
-       
-    t = -R @ centroid_A.T + centroid_B.T
-    
-    result = np.identity(4)
-    result[:3,:3] = R
-    result[:3,3]  = t
-    
-    return result
-
-
-def translationRotationToTransformation(translation,rotation,rot_config="sxyz",active=True,degrees=True,translationFirst=False):
-    """
-    translationRotationToTransformation(translation,rotation,rot_config="sxyz",active=True,degrees=True,translationFirst=False)
-    
-    translationFirst : translation first
-             False first 3 rows of transformation matrix = (R   t) [usual convention and default here]
-             True  first 3 rows of transformation matrix = (R  Rt) [used in the hexapod]
-    """
-    import transforms3d as t3
-    import numpy as np
-    # Zoom - unit
-    zdef = np.array([1,1,1])
-    # Shear
-    sdef = np.array([0,0,0])
-    translation = np.array(translation)
-    #if degrees: rotation = np.deg2rad(np.array(rotation))
-    if degrees: rotation = np.array([np.deg2rad(item) for item in rotation])
-    rotx,roty,rotz = rotation
-    rmat = RotationMatrix(rotx,roty,rotz,rot_config=rot_config,active=active)
-    #
-    if translationFirst:
-        result = np.identity(4)
-        result[:3,:3] = rmat.R
-        result[:3,3]  = rmat.R @ translation
-    else:
-        result = t3.affines.compose(translation,rmat.R,Z=zdef,S=sdef)
-    return result
-
-def translationRotationFromTransformation(transformation,rot_config="sxyz",active=True,degrees=True,translationFirst=False):
-    """
-    translationRotationFromTransformation(transformation,rot_config="sxyz",active=True,degrees=True,translationFirst=False)
-    
-    translationFirst : translation first
-             False first 3 rows of transformation matrix = (R   t) [usual convention and default here]
-             True  first 3 rows of transformation matrix = (R  Rt) [used in the hexapod]
-    """
-    translation = transformation[:3,3]
-    rotation = t3.euler.mat2euler(transformation,axes=rot_config)
-    if degrees: rotation = np.array([np.rad2deg(item) for item in rotation])
-    if translationFirst:
-        translation = transformation[:3,:3].T @ translation
-    return translation,rotation
-
-tr2T = translationRotationToTransformation
-T2tr = translationRotationFromTransformation
-
-
-def vectorPlaneIntersection(pt, frame, epsilon=1.e-6):
-    """
-    return the coordinates of the intersection of a vector with a plane.
-
-    pt = input vector. Point object, expressing the vector
-         vector origin = pt.ref.getOrigin().coordinates[:3]
-         vector direction = pt.coordinates[:3]
-    frame = input plane. ReferenceFrame object whose x-y plane is the target plane for intersection
-
-    If the vector's own reference frame is 'frame', the problem is trivial
-
-    In all cases, the coordinates of the interesection point are provided as a Point object, in "frame" coordinates
-
-    Ref:
-    https://stackoverflow.com/questions/5666222/3d-line-plane-intersection
-    """
-
-    from egse.coordinates.point import Point
-
-    if pt.ref == frame:
-        # The point is defined in frame => the origin of the vector is the origin of the target plane.
-        return np.array([0,0,0])
-    else:
-        # Express all inputs in 'frame'
-
-        # Vector Origin (p0)
-        vec_orig = Point(pt.ref.getOrigin().coordinates[:3],ref=pt.ref, name='ptorig').expressIn(frame)[:3]
-        # Vector End (p1)
-        vec_end  = pt.expressIn(frame)[:3]
-        # Vector (u)
-        vec = vec_end - vec_orig
-
-        # A point in Plane (pco)
-        #plane_orig = np.array([0,0,0],dtype=float)
-        plane_orig = frame.getOrigin().coordinates[:3]
-        # Normal to the plane (pno)
-        plane_normal = frame.getAxis('z').coordinates[:3]
-
-        # Vector to normal 'angle'
-        vec_x_normal = np.dot(vec, plane_normal)
-
-        # Test if there is an intersection (and if it's unique)
-        # --> input vector and normal mustn't be perpendicular, else the vector is // to the plane or inside it
-        #
-        if (np.allclose(vec_x_normal, 0., atol=epsilon)):
-            print('The input vector is // to the plane normal (or inside the plane)')
-            print('--> there exists no intersection (or an infinity of them)')
-            return None
-        else:
-            # Vector from the point in the plane to the origin of the vector (w)
-            plane_to_vec = vec_orig - plane_orig
-
-            # Solution  ("how many 'vectors' away is the interesection ?")
-            vec_multiplicator = - np.dot(plane_normal, plane_to_vec) / vec_x_normal
-
-            return Point(vec_orig + (vec * vec_multiplicator), ref=frame)
-

egse/csl/__init__.py

@@ -1,50 +0,0 @@
-from enum import Enum
-from pathlib import Path
-from executor import ExternalCommand
-from gui_executor.utils import read_id
-
-from egse.settings import Settings
-
-HERE = Path(__file__).parent.resolve()
-HOME_DIR = Path('~').expanduser()
-ID_FILE = HOME_DIR / "hexapod_id.txt"
-
-HEXAPODS = Settings.load(location=HOME_DIR,
-                         filename="mech_pos_settings.yaml",
-                         group_name="Hexapod",
-                         add_local_settings=False)
-
-
-class HexapodID(str, Enum):
-    H_1A = "1A"
-    H_1B = "1B"
-    H_2A = "2A"
-    H_2B = "2B"
-
-
-def get_endpoint_hexapod(hexapod_id: str = None):
-    """Returns the hostname and port number for the Hexapod."""
-
-    hexapod_id = hexapod_id or read_id(ID_FILE)
-
-    hostname = HEXAPODS[f"H_{hexapod_id}"]["HOSTNAME"]
-    port = HEXAPODS[f"H_{hexapod_id}"]["PORT"]
-
-    print(f"{hexapod_id=}, {hostname=}, {port=}")
-
-    return "PUNA", hexapod_id, hostname, port
-
-
-def mechanical_position_ui():
-    """ Definition of the UI for the mechanical position at CSL.
-
-    This UI is built using the gui-executor code, and uses the definitions from this module.
-    """
-    logo_path = HERE / "icons/logo-puna.svg"
-    cmd = ExternalCommand(
-        f"gui-executor --module-path egse.csl --logo {logo_path} --single "
-        f"--kernel-name plato-common-egse  "
-        f"--app-name 'CSL Operator GUI (M-position)'",
-        asynchronous=True
-    )
-    cmd.start()

egse/csl/commanding.py

@@ -1,78 +0,0 @@
-""" Content of the UI for the mechanical position at CSL.  This basically needs two buttons to command the hexapod:
-    - a button to go to the home position;
-    - a button to go to the retracted position.
-"""
-from pathlib import Path
-
-from gui_executor.exec import exec_ui
-
-from egse.csl import get_endpoint_hexapod
-from egse.hexapod.symetrie.puna import PunaController
-
-UI_MODULE_DISPLAY_NAME = "2 - Commanding"
-
-ID_FILE = Path('~').expanduser() / "id.txt"
-
-HERE = Path(__file__).parent.resolve()
-
-
-@exec_ui(display_name="Zero position",
-         icons=(HERE/"icons/hexapod-zero.svg", HERE/"icons/hexapod-zero-selected.svg"))
-def goto_zero_position():
-    """ Move the hexapod to the zero position."""
-
-    hexapod = None
-    hexapod_name, hexapod_id, hostname, port = get_endpoint_hexapod()
-    try:
-        from egse.hexapod.symetrie import ControllerFactory
-        factory = ControllerFactory()
-        hexapod = factory.create(hexapod_name, device_id=hexapod_id)
-        hexapod.connect()
-        hexapod.goto_zero_position()
-    except ConnectionError as exc:
-        print("[red]Couldn't connect to the Hexapod Controller. "
-              "Check if the Controller is switched on and no error is reported on the front panel of the controller.[/]")
-    finally:
-        if hexapod is not None:
-            hexapod.disconnect()
-
-
-@exec_ui(display_name="Retracted position",
-         icons=(HERE/"icons/hexapod-retract.svg", HERE/"icons/hexapod-retract-selected.svg"))
-def goto_retracted_position():
-    """ Move the hexapod to the retracted position."""
-
-    hexapod = None
-    hexapod_name, hexapod_id, hostname, port = get_endpoint_hexapod()
-    try:
-        from egse.hexapod.symetrie import ControllerFactory
-        factory = ControllerFactory()
-        hexapod = factory.create(hexapod_name, device_id=hexapod_id)
-        hexapod.connect()
-        hexapod.goto_retracted_position()
-    except ConnectionError as exc:
-        print("[red]Couldn't connect to the Hexapod Controller. "
-              "Check if the Controller is switched on and no error is reported on the front panel of the controller.[/]")
-    finally:
-        if hexapod is not None:
-            hexapod.disconnect()
-
-
-@exec_ui(display_name="Emergency stop", icons=(HERE / "icons/stop.svg", HERE / "icons/stop.svg"), immediate_run=True)
-def emergency_stop():
-    """ Emergency stop of the hexapod."""
-
-    hexapod = None
-    hexapod_name, hexapod_id, hostname, port = get_endpoint_hexapod()
-    try:
-        from egse.hexapod.symetrie import ControllerFactory
-        factory = ControllerFactory()
-        hexapod = factory.create(hexapod_name, device_id=hexapod_id)
-        hexapod.connect()
-        hexapod.stop()
-    except ConnectionError as exc:
-        print("[red]Couldn't connect to the Hexapod Controller. "
-              "Check if the Controller is switched on and no error is reported on the front panel of the controller.[/]")
-    finally:
-        if hexapod is not None:
-            hexapod.disconnect()

egse/csl/icons/hexapod-connected-selected.svg

@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0" y="0" width="512.004" height="512.004" viewBox="0, 0, 512.004, 512.004">
-  <g id="connected-selected">
-    <path d="M481.539,52.376 L458.251,29.089 C455.051,25.889 449.385,25.889 446.185,29.089 L376.314,98.96 C372.978,102.296 372.978,107.69 376.314,111.026 L399.601,134.313 C401.197,135.917 403.373,136.813 405.634,136.813 C407.895,136.813 410.063,135.917 411.667,134.313 L481.538,64.442 C484.875,61.106 484.875,55.713 481.539,52.376 z M405.635,116.214 L394.414,104.993 L452.219,47.188 L463.44,58.409 L405.635,116.214 z" fill="#126EFF"/>
-    <path d="M417.07,127.657 L382.971,93.558 C372.987,83.574 356.757,83.574 346.773,93.558 L335.543,104.779 C333.939,106.375 333.043,108.542 333.043,110.812 C333.043,113.073 333.939,115.241 335.543,116.845 L393.775,175.076 C395.371,176.68 397.547,177.576 399.808,177.576 C402.078,177.576 404.245,176.671 405.85,175.076 L417.071,163.855 C427.054,153.871 427.054,137.641 417.07,127.657 z M404.995,151.781 L399.807,156.969 L353.65,110.804 L358.838,105.616 C362.166,102.305 367.576,102.288 370.904,105.616 L404.995,139.715 C408.323,143.043 408.323,148.453 404.995,151.781 z" fill="#126EFF"/>
-    <path d="M410.192,167.354 L343.257,100.419 C330.363,87.525 313.228,80.425 294.992,80.425 C276.765,80.425 259.63,87.525 246.736,100.419 L195.801,151.354 C194.197,152.95 193.301,155.117 193.301,157.387 C193.301,159.657 194.197,161.816 195.801,163.42 L347.191,314.818 C348.855,316.482 351.04,317.318 353.224,317.318 C355.409,317.318 357.593,316.482 359.257,314.818 L410.192,263.883 C436.799,237.268 436.799,193.961 410.192,167.354 z M398.126,251.817 L353.224,296.719 L213.899,157.387 L258.801,112.493 C268.469,102.825 281.32,97.5 294.991,97.5 C308.67,97.5 321.521,102.825 331.189,112.493 L398.124,179.428 C418.076,199.38 418.076,231.858 398.126,251.817 z" fill="#126EFF"/>
-    <path d="M398.061,251.81 L353.159,296.712 L213.834,157.38 L258.736,112.486 C268.404,102.818 281.255,97.493 294.926,97.493 C308.605,97.493 321.456,102.818 331.124,112.486 L398.059,179.421 C418.011,199.373 418.011,231.851 398.061,251.81 z" fill="#E29AFF"/>
-    <path d="M341.797,145.543 L318.501,122.238 C305.539,109.284 284.47,109.284 271.517,122.238 L248.221,145.543 C244.884,148.88 244.884,154.273 248.221,157.609 C251.558,160.945 256.959,160.945 260.287,157.609 L283.583,134.304 C289.889,128.006 300.138,128.006 306.435,134.304 L329.731,157.609 C331.395,159.273 333.58,160.109 335.764,160.109 C337.94,160.109 340.124,159.273 341.797,157.609 C345.133,154.273 345.133,148.879 341.797,145.543 z" fill="#126EFF"/>
-    <path d="M134.093,400.187 L110.806,376.9 C109.21,375.296 107.034,374.4 104.773,374.4 C102.512,374.4 100.344,375.296 98.74,376.9 L28.868,446.771 C25.532,450.108 25.532,455.501 28.868,458.837 L52.155,482.124 C53.751,483.728 55.927,484.624 58.188,484.624 C60.458,484.624 62.625,483.728 64.221,482.124 L134.092,412.253 C137.429,408.917 137.429,403.524 134.093,400.187 z M58.189,464.025 L46.968,452.804 L104.773,394.999 L115.994,406.22 L58.189,464.025 z" fill="#126EFF"/>
-    <path d="M174.848,394.376 L116.617,336.145 C115.021,334.541 112.845,333.645 110.584,333.645 C108.323,333.645 106.155,334.541 104.551,336.145 L93.33,347.366 C83.346,357.35 83.346,373.58 93.33,383.564 L127.429,417.663 C132.421,422.655 138.975,425.147 145.528,425.147 C152.081,425.147 158.635,422.655 163.619,417.663 L174.849,406.442 C176.453,404.846 177.349,402.679 177.349,400.409 C177.348,398.148 176.452,395.981 174.848,394.376 z M151.578,405.589 C148.25,408.9 142.84,408.917 139.512,405.589 L105.413,371.49 C102.085,368.162 102.085,362.752 105.413,359.424 L110.601,354.236 L156.766,400.401 L151.578,405.589 z" fill="#126EFF"/>
-    <path d="M326.247,336.128 L174.857,184.738 C171.657,181.538 165.991,181.538 162.791,184.738 L100.208,247.321 C73.601,273.936 73.601,317.243 100.208,343.85 L167.143,410.785 C180.037,423.679 197.172,430.779 215.408,430.779 C233.644,430.779 250.779,423.679 263.673,410.777 L326.248,348.194 C329.583,344.857 329.583,339.464 326.247,336.128 z M251.597,398.72 C241.929,408.388 229.078,413.713 215.407,413.713 C201.728,413.713 188.877,408.388 179.209,398.72 L112.274,331.785 C92.323,311.834 92.323,279.356 112.274,259.397 L168.824,202.847 L308.139,342.171 L251.597,398.72 z" fill="#126EFF"/>
-    <path d="M251.597,398.72 C241.929,408.388 229.078,413.713 215.407,413.713 C201.728,413.713 188.877,408.388 179.209,398.72 L112.274,331.785 C92.323,311.834 92.323,279.356 112.274,259.397 L168.824,202.847 L308.139,342.171 L251.597,398.72 z" fill="#E29AFF"/>
-    <path d="M279.663,336.136 L174.857,231.33 C171.521,227.993 166.127,227.993 162.791,231.33 L116.208,277.913 C112.871,281.25 112.871,286.643 116.208,289.979 L221.023,394.785 C222.687,396.449 224.872,397.285 227.056,397.285 C229.232,397.285 231.417,396.449 233.081,394.785 L279.664,348.202 C283,344.866 283,339.473 279.663,336.136 z M227.047,376.687 L134.307,283.947 L168.824,249.43 L261.564,342.17 L227.047,376.687 z" fill="#126EFF"/>
-    <path d="M231.44,314.497 L196.505,279.553 C193.168,276.217 187.775,276.216 184.439,279.553 C181.103,282.89 181.103,288.283 184.439,291.619 L219.374,326.563 C221.038,328.227 223.223,329.063 225.407,329.063 C227.591,329.063 229.776,328.227 231.44,326.563 C234.777,323.226 234.777,317.833 231.44,314.497 z" fill="#126EFF"/>
-  </g>
-  <g id="connected" display="none">
-    <path d="M481.539,52.376 L458.251,29.089 C455.051,25.889 449.385,25.889 446.185,29.089 L376.314,98.96 C372.978,102.296 372.978,107.69 376.314,111.026 L399.601,134.313 C401.197,135.917 403.373,136.813 405.634,136.813 C407.895,136.813 410.063,135.917 411.667,134.313 L481.538,64.442 C484.875,61.106 484.875,55.713 481.539,52.376 z M405.635,116.214 L394.414,104.993 L452.219,47.188 L463.44,58.409 L405.635,116.214 z" fill="#126EFF"/>
-    <path d="M417.07,127.657 L382.971,93.558 C372.987,83.574 356.757,83.574 346.773,93.558 L335.543,104.779 C333.939,106.375 333.043,108.542 333.043,110.812 C333.043,113.073 333.939,115.241 335.543,116.845 L393.775,175.076 C395.371,176.68 397.547,177.576 399.808,177.576 C402.078,177.576 404.245,176.671 405.85,175.076 L417.071,163.855 C427.054,153.871 427.054,137.641 417.07,127.657 z M404.995,151.781 L399.807,156.969 L353.65,110.804 L358.838,105.616 C362.166,102.305 367.576,102.288 370.904,105.616 L404.995,139.715 C408.323,143.043 408.323,148.453 404.995,151.781 z" fill="#126EFF"/>
-    <path d="M410.192,167.354 L343.257,100.419 C330.363,87.525 313.228,80.425 294.992,80.425 C276.765,80.425 259.63,87.525 246.736,100.419 L195.801,151.354 C194.197,152.95 193.301,155.117 193.301,157.387 C193.301,159.657 194.197,161.816 195.801,163.42 L347.191,314.818 C348.855,316.482 351.04,317.318 353.224,317.318 C355.409,317.318 357.593,316.482 359.257,314.818 L410.192,263.883 C436.799,237.268 436.799,193.961 410.192,167.354 z M398.126,251.817 L353.224,296.719 L213.899,157.387 L258.801,112.493 C268.469,102.825 281.32,97.5 294.991,97.5 C308.67,97.5 321.521,102.825 331.189,112.493 L398.124,179.428 C418.076,199.38 418.076,231.858 398.126,251.817 z" fill="#126EFF"/>
-    <path d="M398.061,251.81 L353.159,296.712 L213.834,157.38 L258.736,112.486 C268.404,102.818 281.255,97.493 294.926,97.493 C308.605,97.493 321.456,102.818 331.124,112.486 L398.059,179.421 C418.011,199.373 418.011,231.851 398.061,251.81 z" fill="#A5CBFF"/>
-    <path d="M341.797,145.543 L318.501,122.238 C305.539,109.284 284.47,109.284 271.517,122.238 L248.221,145.543 C244.884,148.88 244.884,154.273 248.221,157.609 C251.558,160.945 256.959,160.945 260.287,157.609 L283.583,134.304 C289.889,128.006 300.138,128.006 306.435,134.304 L329.731,157.609 C331.395,159.273 333.58,160.109 335.764,160.109 C337.94,160.109 340.124,159.273 341.797,157.609 C345.133,154.273 345.133,148.879 341.797,145.543 z" fill="#126EFF"/>
-    <path d="M134.093,400.187 L110.806,376.9 C109.21,375.296 107.034,374.4 104.773,374.4 C102.512,374.4 100.344,375.296 98.74,376.9 L28.868,446.771 C25.532,450.108 25.532,455.501 28.868,458.837 L52.155,482.124 C53.751,483.728 55.927,484.624 58.188,484.624 C60.458,484.624 62.625,483.728 64.221,482.124 L134.092,412.253 C137.429,408.917 137.429,403.524 134.093,400.187 z M58.189,464.025 L46.968,452.804 L104.773,394.999 L115.994,406.22 L58.189,464.025 z" fill="#126EFF"/>
-    <path d="M174.848,394.376 L116.617,336.145 C115.021,334.541 112.845,333.645 110.584,333.645 C108.323,333.645 106.155,334.541 104.551,336.145 L93.33,347.366 C83.346,357.35 83.346,373.58 93.33,383.564 L127.429,417.663 C132.421,422.655 138.975,425.147 145.528,425.147 C152.081,425.147 158.635,422.655 163.619,417.663 L174.849,406.442 C176.453,404.846 177.349,402.679 177.349,400.409 C177.348,398.148 176.452,395.981 174.848,394.376 z M151.578,405.589 C148.25,408.9 142.84,408.917 139.512,405.589 L105.413,371.49 C102.085,368.162 102.085,362.752 105.413,359.424 L110.601,354.236 L156.766,400.401 L151.578,405.589 z" fill="#126EFF"/>
-    <path d="M326.247,336.128 L174.857,184.738 C171.657,181.538 165.991,181.538 162.791,184.738 L100.208,247.321 C73.601,273.936 73.601,317.243 100.208,343.85 L167.143,410.785 C180.037,423.679 197.172,430.779 215.408,430.779 C233.644,430.779 250.779,423.679 263.673,410.777 L326.248,348.194 C329.583,344.857 329.583,339.464 326.247,336.128 z M251.597,398.72 C241.929,408.388 229.078,413.713 215.407,413.713 C201.728,413.713 188.877,408.388 179.209,398.72 L112.274,331.785 C92.323,311.834 92.323,279.356 112.274,259.397 L168.824,202.847 L308.139,342.171 L251.597,398.72 z" fill="#126EFF"/>
-    <path d="M251.597,398.72 C241.929,408.388 229.078,413.713 215.407,413.713 C201.728,413.713 188.877,408.388 179.209,398.72 L112.274,331.785 C92.323,311.834 92.323,279.356 112.274,259.397 L168.824,202.847 L308.139,342.171 L251.597,398.72 z" fill="#A5CBFF"/>
-    <path d="M279.663,336.136 L174.857,231.33 C171.521,227.993 166.127,227.993 162.791,231.33 L116.208,277.913 C112.871,281.25 112.871,286.643 116.208,289.979 L221.023,394.785 C222.687,396.449 224.872,397.285 227.056,397.285 C229.232,397.285 231.417,396.449 233.081,394.785 L279.664,348.202 C283,344.866 283,339.473 279.663,336.136 z M227.047,376.687 L134.307,283.947 L168.824,249.43 L261.564,342.17 L227.047,376.687 z" fill="#126EFF"/>
-    <path d="M231.44,314.497 L196.505,279.553 C193.168,276.217 187.775,276.216 184.439,279.553 C181.103,282.89 181.103,288.283 184.439,291.619 L219.374,326.563 C221.038,328.227 223.223,329.063 225.407,329.063 C227.591,329.063 229.776,328.227 231.44,326.563 C234.777,323.226 234.777,317.833 231.44,314.497 z" fill="#126EFF"/>
-  </g>
-</svg>