hpp-corbaserver: hpp.quaternion.Quaternion Class Reference

hpp-corbaserver 9.0.2 Corba server for Humanoid Path Planner applications

Public Member Functions | Public Attributes | List of all members
hpp.quaternion.Quaternion Class Reference

## Public Member Functions
def | __init__ (self, *args)
def | __str__ (self)
def | __neg__ (self)
def | __add__ (self, other)
def | __sub__ (self, other)
def | __mul__ (self, other)
def | __rmul__ (self, other)
def | transform (self, v)
def | __abs__ (self)
def | conjugate (self)
def | inv (self)
def | __div__ (self, other)
def | __pow__ (self, n)
def | normalize (self)
def | normalized (self)
def | toRotationMatrix (self)
def | toRotationVector (self)
def | copy (self)
def | toRPY (self)
def | fromRPY (self, R, P, Y)
def | toTuple (self)
def | fromTwoVector (self, a, b)
def | fromAngleAxis (self, axis, angle, degree=False)

## Public Attributes
| array

## Detailed Description

    Quaternion class :
    ------------------

    A quaternion has a scalar part and a vector part.
    In this class the quaternion is represented as an array of 4 elements :
      - the 3 first elements represent the vector part
      - the last element represents the scalar part

    One can acces to the array directly with the attribute "array"
      e.g. q1=Quaternion(0,0,0,1) --> q1.array

    A quaternion can be instanciated with 1, 2 or 4 elements
      (see : __init__() for more information).

    It can also return a rotation vector, a rotation matrix, or a SO3
      (see the methods : to...() for more information).

## Constructor & Destructor Documentation

## ◆ __init__()

def hpp.quaternion.Quaternion.__init__ | ( |  | self,
|  | * | args
| ) |  |

    Instanciation of the quaternion with 1, 2 or 4 arguments  :
    -----------------------------------------------------------
    This creates a 4-sized array (self.array) representing the quaternion
    with the first element representing the scalar part
    and the 3 others the vector part.

    With 4 arguments :
    ------------------
      - the 3 first one are used as the vector part,
      - the last one as the scalar part.

    With 2 arguments :
    ------------------
      - the 3-sized argument is used as the vector part.
      - the 1-sized argument is used as the scalar part,

    With 1 argument :
    -----------------
      - if it is a quaternion it will create a copy of this quaternion.
      - if it is a scalar, the scalar will be used as the scalar part
        and the vector part will be set at (0,0,0).
      - if it is an array, matrix, tuple or list of 4 elements,
        the last element is used as the scalar part
        and the first elements as the vector part.
      - if it is an array, matrix, tuple or list of 3 elements,
        the 3 elements are interpreted as a rotation vector,
        this creates a quaternion representing the same rotation.
      - if it is a 2 dimension array convertible array, matrix, tuple
        or list with at least (3*3) elements,
        the upper left (3*3) elements are interpreted as a rotation matrix,
        this creates a quaternion representing the same rotation.
      - if it is an instance of SO3, quaternion is built from rotation
        matrix.

    With 0 arguments :
    ------------------
    If no argument is given, than the quaternion will be set by default
    to with the scalar part set to 1 and the vector part to (0,0,0).
    (this is the neutral element for multiplication in quaternion space)

    To create a quaternion from Roll, Pitch, Yaw angles :
    -----------------------------------------------------
    first instanciate a quaternion and than use the method fromRPY()
    to change the values of it to the dezired ones.
      e.g. : quat().fromRPY(R,P,Y)

## Member Function Documentation

## ◆ __abs__()

def hpp.quaternion.Quaternion.__abs__ | ( |  | self | ) |

    Returns the norm of the quaternion.

## ◆ __add__()

def hpp.quaternion.Quaternion.__add__ | ( |  | self,
|  |  | other
| ) |  |

    If other is not a quaternion it is casted to a quaternion,
    the elements are added one to one.

## ◆ __div__()

def hpp.quaternion.Quaternion.__div__ | ( |  | self,
|  |  | other
| ) |  |

    If other is not a quaternion it is casted to a quaternion,
    the result of the quaternion multiplication with the inverse of other
    is returned.

## ◆ __mul__()

def hpp.quaternion.Quaternion.__mul__ | ( |  | self,
|  |  | other
| ) |  |

    If other is not a quaternion it is casted to a quaternion,
    the result of the quaternion multiplication is returned.

## ◆ __neg__()

def hpp.quaternion.Quaternion.__neg__ | ( |  | self | ) |

    Returns a quaternion which elements are the opposite of the original,
    (this opposite quaternion represents the same rotation).

## ◆ __pow__()

def hpp.quaternion.Quaternion.__pow__ | ( |  | self,
|  |  | n
| ) |  |

    Returns quaternion**n with quaternion**0 = Quaternion(1,0,0,0).

## ◆ __rmul__()

def hpp.quaternion.Quaternion.__rmul__ | ( |  | self,
|  |  | other
| ) |  |

    other is casted to a quaternion,
    the result of the quaternion multiplication is returned.

## ◆ __str__()

def hpp.quaternion.Quaternion.__str__ | ( |  | self | ) |

    String representation of the quaternion.

## ◆ __sub__()

def hpp.quaternion.Quaternion.__sub__ | ( |  | self,
|  |  | other
| ) |  |

    If other is not a quaternion it is casted to a quaternion,
    the elements are substracted one to one.

## ◆ conjugate()

def hpp.quaternion.Quaternion.conjugate | ( |  | self | ) |

    Returns the conjugate of the quaternion.

## ◆ copy()

def hpp.quaternion.Quaternion.copy | ( |  | self | ) |

    Returns a copy of the quaternion.

## ◆ fromAngleAxis()

def hpp.quaternion.Quaternion.fromAngleAxis | ( |  | self,
|  |  | axis,
|  |  | angle,
|  |  | degree = `False`
| ) |  |

    Build a quaternion from an axis of rotation and an angle.
    The angle is in radians by default and in degree if degree is set to True.
    The axis is normalized.

## ◆ fromRPY()

def hpp.quaternion.Quaternion.fromRPY | ( |  | self,
|  |  | R,
|  |  | P,
|  |  | Y
| ) |  |

    Set the values of the quaternion to the values of a unit quaternion
    representing the same rotation as the one performed by Roll Pitch Yaw :
      - A rotation of R (Roll) about the original x-axis,
        followed by a rotation of P (Pitch) about the original y-axis,
        followed by a rotation of Y (Yaw) about the original z-axis.
      - Or otherwise a rotation of Y about the original z-axis,
        followed by a rotation of P about the new y-axis,
        followed by a rotation of R about the new x-axis.

## ◆ fromTwoVector()

def hpp.quaternion.Quaternion.fromTwoVector | ( |  | self,
|  |  | a,
|  |  | b
| ) |  |

    Return a quaternion build representing the rotation between the two vectors.
    In other words, the built rotation represent a rotation sending
    the line of direction a to the line of direction b,
    both lines passing through the origin.
    Equations from Eigen
    https://eigen.tuxfamily.org/dox/classEigen_1_1Quaternion.html#title13

## ◆ inv()

def hpp.quaternion.Quaternion.inv | ( |  | self | ) |

    Returns the inverse of the quaternion.

## ◆ normalize()

def hpp.quaternion.Quaternion.normalize | ( |  | self | ) |

    Changes the values of the quaternion to make it a unit quaternion
    representing the same rotation as the original one
    and returns the updated version.

## ◆ normalized()

def hpp.quaternion.Quaternion.normalized | ( |  | self | ) |

    Returns the unit quaternion representation of the quaternion
    without changing the original.

## ◆ toRotationMatrix()

def hpp.quaternion.Quaternion.toRotationMatrix | ( |  | self | ) |

    Returns a (3*3) array (rotation matrix)
    representing the same rotation as the (normalized) quaternion.

## ◆ toRotationVector()

def hpp.quaternion.Quaternion.toRotationVector | ( |  | self | ) |

    Returns a 3-sized array (rotation vector)
    representing the same rotation as the (normalized) quaternion.

## ◆ toRPY()

def hpp.quaternion.Quaternion.toRPY | ( |  | self | ) |

    Returns a 3-sized array with representing the same rotation
    as the (normalized) quaternion. With :
      - the first element representing the Roll,
      - the second the Pitch
      - the third the Yaw
    Where Roll Pitch and Yaw are the angles so that the rotation
    with the quaternion represents the same rotation as :
      - A rotation of R (Roll) about the original x-axis,
        followed by a rotation of P (Pitch) about the original y-axis,
        followed by a rotation of Y (Yaw) about the original z-axis.
      - Or otherwise a rotation of Y about the original z-axis,
        followed by a rotation of P about the new y-axis,
        followed by a rotation of R about the new x-axis.

## ◆ toTuple()

def hpp.quaternion.Quaternion.toTuple | ( |  | self | ) |

    Return quaternion as a tuple a float starting with real part.

## ◆ transform()

def hpp.quaternion.Quaternion.transform | ( |  | self,
|  |  | v
| ) |  |

    apply rotation to a vector

## Member Data Documentation

## ◆ array

hpp.quaternion.Quaternion.array

The documentation for this class was generated from the following file:

- src/hpp/quaternion.py