The logarithmic and exponential mapping are useful for several algorithms and allow mapping to and from vector spaces.

See math: https://www.sciencedirect.com/science/article/pii/S0022247X12000327
or: http://www.roboticsproceedings.org/rss08/p04.pdf

This issue stems from:
moble/quaternion#42

The current solution is to install numpy before installing this package.

Unnormalized dual quaternions are rather useless, one of the reasons to use dual quaternions is that normalization is so efficient. Include it in __init__.

e.g. Sullivan et al. Skinning with Dual Quaternions and K. Daniilidis Hand-eye calibration using DQs

Currently CI only hits kinetic

See https://docs.readthedocs.io/en/stable/intro/getting-started-with-sphinx.html

Properties really only are meant for 'properties' of a class that can't be readily derived from other instance attributes.

Consider changing these to regular methods. Would need to change all code that uses these properties since you can invoke them as dq.ros_pose instead of dq.ros_pose().

Tests only test a few random dqs. Extend coverage by testing edge cases and so on

Currently it is assumed that the dual quaternion doesn't have a rotation and the unit quaternion is returned for the rotation part. Instead, the quaternions should simply be added:

dq1 + dq2 = (dqr1 + dqr2) + e(dqd1 + dqd2)

The formula for the inverse of a not necessarily unit DQ is

Inv(a +eb) = inv(a) (1 - eb inv(a)) # a != 0

, not sure if we need to replace the current formulation or have a separate formulation

For packages like:

https://github.com/ros-industrial-consortium/fermi/tree/hydro-devel/moveit_cartesian_plan_plugin

We sometimes need to convert between quaternions and euler angles. It owuld be nice to have a .euler property. Youd have to be explicit about the convention.

There's

1. Dual number conjugate p-eq
2. Classical quaternion conjugate p* + eq*
3. Combo p* - eq*

Clarify which one we're using and explain in readme what each one does. We're using 1 and 2. Provide link to Yan-Bin Jia's notes

Dependency on ROS is pretty light already and it would be nice if this could be used in non-ROS projects as well. Could still host in same repo but have the ROS pkg have a dependency on the python pkg.

Run dual_quaternions tests with Python3 in Travis CI. This requires a few modifications:

1. In setup.py, from distutils.core import setup --> from setuptools import setup although this old article says it doesn't like it but I think that can be disregarded.
2. Code needs to become python3 compatible. Just need to fix one test!
3. Modify Travis config to run python3. Not sure how that would work with ROS installation.

A dual quaternion corresponds nicely to a screw transformation. Allow a user to get this screw 6D vector.
Optionally also include a distance metric based on the screw representation

A simple and clear visualization tool could be useful to help visualize results from algorithms like ScLERP, DLB, ...

See rosdistro/#23261.

Useful docu: setup.py in ros packages

Got following error on a fresh install:

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Could not import from scipy, which means that derivatives
and integrals will use less accurate finite-differencing
techniques.  You may want to install scipy.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

A dual quaternion sigma = p+eq is unit if, when multiplied with its quaternion_conjugate(), results in 1.

In the current definition of us_unit, it just checks if the norm of the real part (q_r) of the DQ has norm 1 which I think is incorrect.

See https://discourse.ros.org/t/new-gpg-keys-deployed-for-packages-ros-org/9454

The code of transform_point is as follows:

        # dq_point = DualQuaternion.identity()
        # dq_point.q_d = np.quaternion(0., point_xyz[0], point_xyz[1], point_xyz[2])
        # transformed_dq = (self * dq_point) * (self.conjugate())
        # return [transformed_dq.q_d.x, transformed_dq.q_d.y, transformed_dq.q_d.z]

        # this works, but not mathematically elegant (?)
        dq_point = DualQuaternion.from_translation_vector(point_xyz)
        transformed_dq = self * dq_point

        return transformed_dq.translation

Seems like I was confused writing this down. The commented out code describes a similarity transform, which is used to relate transformation between frames, not points. I would educate but let the user do the similarity transform if they need it.

The norm of a dual quaternion is |q| = sqrt(qq*). Currently the normalized rotation is used. Should make this clear and have a separate norm() method

There are several definitions of a conjugate or an inverse. Documentation also does not indicate if a DQ will be normalized or not.

Add verbosity, explicit math, potentially different new methods

See this paper on SPLIT, SE3UP, SCLERP, DLB