quaternion.Quaternion Class Reference

Inheritance diagram for quaternion.Quaternion:

Public Member Functions
def	__abs__ (self)
def	__add__ (self, other)
def	__div__ (self, other)
def	__init__ (self, *args)
def	__mul__ (self, other)
def	__neg__ (self)
def	__pow__ (self, n)
def	__rmul__ (self, other)
def	__str__ (self)
def	__sub__ (self, other)
def	conjugate (self)
def	copy (self)
def	fromRPY (self, R, P, Y)
def	inv (self)
def	normalize (self)
def	normalized (self)
def	toRotationMatrix (self)
def	toRotationVector (self)
def	toRPY (self)
def	toSO3 (self)

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 first element is the scalar part
  - the next 3 elements represents the vector part

One can acces to the array directly with the attribute "array"
  e.g. q1=Quaternion(1,0,0,0) --> 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).

Definition at line 6 of file quaternion.py.

Constructor & Destructor Documentation

__init__()

def 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 first one is used as the scalar part,
    the other three as the vector part.

With 2 arguments :
------------------
  - the 1-sized argument is used as the scalar part,
    the 3-sized argument is used as the vector 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 first element is used as the scalar part
    and the rest 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 to 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.

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)

Definition at line 26 of file quaternion.py.

Member Function Documentation

__abs__()

def quaternion.Quaternion.__abs__

(

self

)

Returns the norm of the quaternion.

Definition at line 248 of file quaternion.py.

__add__()

def quaternion.Quaternion.__add__	(		self,
			other
	)

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

Definition at line 201 of file quaternion.py.

__div__()

def 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.

Definition at line 266 of file quaternion.py.

__mul__()

def 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.

Definition at line 223 of file quaternion.py.

__neg__()

def quaternion.Quaternion.__neg__

(

self

)

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

Definition at line 194 of file quaternion.py.

__pow__()

def quaternion.Quaternion.__pow__	(		self,
			n
	)

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

Definition at line 278 of file quaternion.py.

__rmul__()

def quaternion.Quaternion.__rmul__	(		self,
			other
	)

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

Definition at line 241 of file quaternion.py.

__str__()

def quaternion.Quaternion.__str__

(

self

)

String representation of the quaternion.

Definition at line 183 of file quaternion.py.

__sub__()

def quaternion.Quaternion.__sub__	(		self,
			other
	)

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

Definition at line 212 of file quaternion.py.

conjugate()

def quaternion.Quaternion.conjugate

(

self

)

Returns the conjugate of the quaternion.

Definition at line 254 of file quaternion.py.

copy()

def quaternion.Quaternion.copy

(

self

)

Returns a copy of the quaternion.

Definition at line 341 of file quaternion.py.

fromRPY()

def 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.

Definition at line 375 of file quaternion.py.

inv()

def quaternion.Quaternion.inv

(

self

)

Returns the inverse of the quaternion.

Definition at line 260 of file quaternion.py.

normalize()

def 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.

Definition at line 287 of file quaternion.py.

normalized()

def quaternion.Quaternion.normalized

(

self

)

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

Definition at line 296 of file quaternion.py.

toRotationMatrix()

def quaternion.Quaternion.toRotationMatrix

(

self

)

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

Definition at line 311 of file quaternion.py.

toRotationVector()

def quaternion.Quaternion.toRotationVector

(

self

)

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

Definition at line 329 of file quaternion.py.

toRPY()

def 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.

Definition at line 347 of file quaternion.py.

toSO3()

def quaternion.Quaternion.toSO3

(

self

)

Returns the corresponding SO3.

Definition at line 305 of file quaternion.py.

Member Data Documentation

array

quaternion.Quaternion.array

Definition at line 75 of file quaternion.py.

---

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

• quaternion.py