skrobot.coordinates.dual_quaternion.DualQuaternion¶

class skrobot.coordinates.dual_quaternion.DualQuaternion(qr=[1, 0, 0, 0], qd=[0, 0, 0, 0], enforce_unit_norm=False)[source]¶

Class for handling dual quaternions and their interpolations.

Parameters:

qr (list or numpy.ndarray) –
qd (list or numpy.ndarray) – element of dual quaternion
enforce_unit_norm (bool (optional)) – if True, norm should be 1.0.

Methods

T()[source]¶

Return 4x4 homogeneous transformation matrix.

Returns:: matrix – homogeneous transformation matrix shape of (4, 4)
Return type:: numpy.ndarray

Examples

>>> from numpy import pi
>>> from skrobot.coordinates import Coordinates
>>> from skrobot.coordinates.dual_quaternion import DualQuaternion
>>> dq = DualQuaternion()
>>> dq.T()
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
>>> dq = Coordinates().rotate(pi / 2.0, 'y').        ...                    translate((0.1, 0.2, 0.3)).        ...                    dual_quaternion
>>> dq.T()
array([[ 2.22044605e-16,  0.00000000e+00,  1.00000000e+00,
         3.00000000e-01],
       [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00,
         2.00000000e-01],
       [-1.00000000e+00,  0.00000000e+00,  2.22044605e-16,
        -1.00000000e-01],
       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,
         1.00000000e+00]])

copy()[source]¶

Return a copy of this quaternion.

Returns:: copied DualQuaternion instance
Return type:: DualQuaternion

difference_position(other_dq)[source]¶

Return difference position

Parameters:: other_dq (skrobot.coordinates.dual_quaternion.DualQuaternion) – dual quaternion
Returns:: dif_pos – difference position’s norm
Return type:: float

difference_rotation(other_dq)[source]¶

Return difference rotation distance

Parameters:: other_dq (skrobot.coordinates.dual_quaternion.DualQuaternion) – dual quaternion
Returns:: dif_rot – angle distance in radian.
Return type:: float

enforce_positive_q_rot_w()[source]¶

static interpolate(dq0, dq1, t)[source]¶

Return interpolated dual quaternion

Parameters:

dq0 (skrobot.coordinates.dual_quaternion.DualQuaternion) –
dq1 (skrobot.coordinates.dual_quaternion.DualQuaternion) – dual quaternion
t (float) – ratio of interpolation. Must be 0 <= t <= 1.0.

normalize()[source]¶

Normalize this dual quaternion

Note that this function changes property.

Returns:: self – return self
Return type:: skrobot.coordinates.dual_quaternion.DualQuaternion

pose()[source]¶

Return [x, y, z, wx, wy, wz, wq] elements.

Returns:: pose – [x, y, z, wx, wy, wz, wq] pose
Return type:: numpy.ndarray

screw_axis()[source]¶

Return screw axis

Calculates rotation, translation and screw axis from dual quaternion.

Returns:: screw_axis, theta, translation – screw axis of this dual quaternion. rotation angle in radian. translation
Return type:: tuple(numpy.ndarray, float, float)

__eq__(value, /)¶: Return self==value.

__ne__(value, /)¶: Return self!=value.

__lt__(value, /)¶: Return self<value.

__le__(value, /)¶: Return self<=value.

__gt__(value, /)¶: Return self>value.

__ge__(value, /)¶: Return self>=value.

__add__(val)[source]¶

__mul__(val)[source]¶

__rmul__(val)[source]¶

Attributes

angle¶

Return rotation angle of this dual quaternion

Returns:: self.qr.angle – this dual quaternion’s rotation angle with respect to self.axis. See skrobot.coordinates.quaternion.Quaternion.angle.
Return type:: float

axis¶

Return axis of this dual quaternion

Returns:: self.qr.axis – this dual quaternion’s axis. See See skrobot.coordinates.quaternion.Quaternion.axis.
Return type:: numpy.ndarray

conjugate¶

Return conjugate of this dual quaternion

Returns:: DualQuaternion – new DualQuaternion class has this dual quaternion’s conjugate
Return type:: skrobot.coordinates.dual_quaternion.DualQuaternion

dq¶

Return flatten vector of this dual quaternion

Returns:: np.concatenate([self.qr.q, self.qd.q]) – (1x8) vector of this dual quaternion
Return type:: numpy.ndarray

Examples

>>> from skrobot.coordinates.dual_quaternion import DualQuaternion
>>> dq = DualQuaternion()
>>> dq.dq
array([1., 0., 0., 0., 0., 0., 0., 0.])

inverse¶

Return inverse of this dual quaternion

Returns:: dq – new DualQuaternion class has inverse of this dual quaternion
Return type:: skrobot.coordinates.dual_quaternion.DualQuaternion

norm¶

Return pair of norm of this dual quaternion

Returns:: qr_norm, qd_norm – qr and qd’s norm
Return type:: tuple(float, float)

Examples

>>> from skrobot.coordinates.dual_quaternion import DualQuaternion
>>> dq = DualQuaternion()
>>> dq.norm
(1.0, 0.0)

normalized¶

Return normalized this dual quaternion

Returns:: skrobot.coordinates.dual_quaternion.DualQuaternion normalized dual quaternion
Return type:: DualQuaternion(qr, qd, True)

qd¶

Return translation quaternion

Returns:: self._qd – quaternion indicating translation
Return type:: skrobot.coordinates.quaternion.Quaternion

qr¶

Return orientation

Returns:: self._qr – [w, x, y, z] order
Return type:: numpy.narray

quaternion¶

Return this dual quaternion’s qr (rotation)

Returns:: dq.qr – rotation quaternion
Return type:: skrobot.coordinates.quaternion.Quaternion

rotation¶

Return rotation matrix of this dual quaternion

Returns:: dq.qr.rotation – 3x3 rotation matrix
Return type:: numpy.ndarray

Examples

>>> import numpy as np
>>> from skrobot.coordinates import Coordinates
>>> c = Coordinates()
>>> c.dual_quaternion.rotation
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> c.rotate(np.pi / 2.0, 'y')
>>> c.dual_quaternion.rotation
array([[ 2.22044605e-16,  0.00000000e+00,  1.00000000e+00],
       [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
       [-1.00000000e+00,  0.00000000e+00,  2.22044605e-16]])

scalar¶

The scalar part of the dual quaternion.

Returns:: scalar – scalar
Return type:: float

translation¶

Return translation of this dual quaternion.

Returns:: q_translation.xyz – vector shape of (3, ). unit is [m]
Return type:: numpy.ndarray

Examples

>>> from skrobot.coordinates import Coordinates
>>> c = Coordinates()
>>> c.dual_quaternion.translation
array([0., 0., 0.])
>>> c.translate([0.1, 0.2, 0.3])
>>> c.dual_quaternion.translation
array([0.1, 0.2, 0.3])