u

src/yapsut/geometry.py

 import numpy as np
+from .roto_translation import transform,roto_trans_matrix
+from .vectorized_elemental_rotations import vERotX, vERotY, vERotZ, vAX3D, vAY3D, vAZ3D
 class ElipsoidTriangulation :
    """ creates an elipsoid triangulated """
    @property

src/yapsut/roto_translation.py

+__DESCRIPTION__="""
+
+not vectorized rototranslation library
+
+M.Maris - V0.0 - 2018 May 03 -
+
+
+"""
+import numpy as np
+
+
+def transform(point, TransformArray):
+   """ apply a transformation to a 4d point """
+   p = np.array([0,0,0,1])
+   for i in range (0,len(point)-1):
+       p[i] = point[i]
+   p=np.dot(TransformArray,np.transpose(p))
+   for i in range (0,len(point)-1):
+       point[i]=p[i]
+   return point
+
+def roto_trans_matrix(rotation, translation):
+   """returns a rototranslation matrix 
+   """
+   xC, xS = trig(rotation[0])
+   yC, yS = trig(rotation[1])
+   zC, zS = trig(rotation[2])
+   dX = translation[0]
+   dY = translation[1]
+   dZ = translation[2]
+   Translate_matrix = np.array([[1, 0, 0, dX],
+                                [0, 1, 0, dY],
+                                [0, 0, 1, dZ],
+                                [0, 0, 0, 1]])
+   Rotate_X_matrix = np.array([[1, 0, 0, 0],
+                               [0, xC, -xS, 0],
+                               [0, xS, xC, 0],
+                               [0, 0, 0, 1]])
+   Rotate_Y_matrix = np.array([[yC, 0, yS, 0],
+                               [0, 1, 0, 0],
+                               [-yS, 0, yC, 0],
+                               [0, 0, 0, 1]])
+   Rotate_Z_matrix = np.array([[zC, -zS, 0, 0],
+                               [zS, zC, 0, 0],
+                               [0, 0, 1, 0],
+                               [0, 0, 0, 1]])
+   return np.dot(Rotate_Z_matrix,np.dot(Rotate_Y_matrix,np.dot(Rotate_X_matrix,Translate_matrix)))
+

src/yapsut/vectorized_elemental_rotations.py

+__DESCRIPTION__="""
+
+vectorized elemental rotations
+
+M.Maris - V0.0 - 2023 Aug 05 -
+
+
+"""
+import numpy as np
+
+# 3D versors X, Y, Z
+vAX3D = np.array([1,0,0])
+vAY3D = np.array([0,1,0])
+vAZ3D = np.array([0,0,1])
+
+
+def _vectorized_rotation_base_matrix(self,Angle) :
+   """
+commodity function to define a base for a vectorized rotation matrix, returns the components 
+I, c, s of a list of elemental 3D rotation matrices with 
+
+   I.shape=(N,3,3),
+   c.shape=N, 
+   s.shape=N.
+
+with N = 1 is Angle is scalar, otherwise N=len(Angle)
+   
+   Parameters
+   ----------
+      :Angle: scalar or array of rotation angle(s) in radiants
+   """
+   _angle=np.array([Angle]) if np.isscalar(Angle) else Angle
+   c=np.cos(_angle)
+   s=np.sin(_angle)
+   I=np.zeros([len(_angle),3,3])
+   I[:,0,0]=1
+   I[:,1,1]=1
+   I[:,2,2]=1
+   return I,c,s
+
+def vERotX(Angle) :
+   """Vectorized elemental rotations about X axis
+   
+   returns a list of elemental 3D rotation matrices with shape (N,3,3)
+   with N = 1 if Angle is scalar, otherwise N=len(Angle)
+   
+   Parameters
+   ----------
+      :Angle: scalar or array of rotation angle(s) in radiants
+   """
+   R,c,s=_vectorized_rotation_base_matrix(Angle)
+   R[:,1,1]= c
+   R[:,1,2]=-s
+   R[:,2,1]= s
+   R[:,2,2]= c
+   return R
+
+def vERotY(Angle) :
+   """Vectorized elemental rotations about Y axis
+   
+   returns a list of elemental 3D rotation matrices with shape (N,3,3)
+   with N = 1 if Angle is scalar, otherwise N=len(Angle)
+   
+   Parameters
+   ----------
+      :Angle: scalar or array of rotation angle(s) in radiants
+   """
+   R,c,s=_vectorized_rotation_base_matrix(Angle)
+   R[:,0,0]= c
+   R[:,0,2]= s
+   R[:,2,0]=-s
+   R[:,2,2]= c
+   return R
+
+def vERotZ(Angle) :
+   """Vectorized elemental rotations about Z axis
+   
+   returns a list of elemental 3D rotation matrices with shape (N,3,3)
+   with N = 1 if Angle is scalar, otherwise N=len(Angle)
+   
+   Parameters
+   ----------
+      :Angle: scalar or array of rotation angle(s) in radiants
+   """
+   R,c,s=_vectorized_rotation_base_matrix(Angle)
+   R[:,0,0]= c
+   R[:,0,1]=-s
+   R[:,1,0]= s
+   R[:,1,1]= c
+   return R
+