Math: Add DualQuaternion/DualComplex::from(rotation, translation)

Signed-off-by: Squareys <squareys@googlemail.com>

src/Magnum/Math/DualComplex.h

@@ -106,6 +106,22 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
             return {Implementation::complexFromMatrix(matrix.rotationScaling()), Complex<T>(matrix.translation())};
         }
 
+        /**
+         * @brief Create dual complext from rotation complex and translation vector
+         *
+         * @f[
+         *      \hat c = r + \epsilon (r(v_x + iv_y))
+         * @f]
+         *
+         * @see @ref translation(), @ref rotation()
+         *      @ref Matrix3::from(const Matrix2x2<T>&, const Vector2<T>&),
+         *      @ref Matrix4::from(const Matrix3x3<T>&, const Vector3<T>&),
+         *      @ref DualQuaternion::from(const Quaternion<T>&, const Vector3<T>&)
+         */
+        static DualComplex<T> from(const Complex<T>& rotation, const Vector2<T>& translation) {
+            return DualComplex<T>::translation(translation)*DualComplex<T>(rotation, {{}, {}});
+        }
+
         /**
          * @brief Default constructor
          *

src/Magnum/Math/DualQuaternion.h

@@ -246,6 +246,22 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
             return {q, Quaternion<T>(matrix.translation()/2)*q};
         }
 
+        /**
+         * @brief Create dual quaternion from rotation quaternion and translation vector
+         *
+         * @f[
+         *      \hat q = r + \epsilon (r[\frac{\boldsymbol t}{2}, 0])
+         * @f]
+         *
+         * @see @ref translation(), @ref rotation(),
+         *      @ref Matrix3::from(const Matrix2x2<T>&, const Vector2<T>&),
+         *      @ref Matrix4::from(const Matrix3x3<T>&, const Vector3<T>&),
+         *      @ref DualComplex::from(const Complex<T>&, const Vector2<T>&)
+         */
+        static DualQuaternion<T> from(const Quaternion<T>& rotation, const Vector3<T>& translation) {
+            return {rotation, Quaternion<T>(translation/T(2))*rotation};
+        }
+
         /**
          * @brief Default constructor
          *

src/Magnum/Math/Matrix3.h

@@ -188,7 +188,10 @@ template<class T> class Matrix3: public Matrix3x3<T> {
          * @param translation       Translation part (first two elements of
          *      third column)
          *
-         * @see @ref rotationScaling(), @ref translation() const
+         * @see @ref rotationScaling(), @ref translation() const,
+         *      @ref Matrix4::from(const Matrix3x3<T>&, const Vector3<T>&),
+         *      @ref DualComplex::from(const Complex<T>&, const Vector2<T>&),
+         *      @ref DualQuaternion::from(const Quaternion<T>&, const Vector3<T>&)
          */
         constexpr static Matrix3<T> from(const Matrix2x2<T>& rotationScaling, const Vector2<T>& translation) {
             return {{rotationScaling[0], T(0)},

src/Magnum/Math/Matrix4.h

@@ -421,7 +421,10 @@ template<class T> class Matrix4: public Matrix4x4<T> {
          * @param translation       Translation part (first three elements of
          *      fourth column)
          *
-         * @see @ref rotationScaling(), @ref translation() const
+         * @see @ref rotationScaling(), @ref translation() const,
+         *      @ref Matrix3::from(const Matrix2x2<T>&, const Vector2<T>&),
+         *      @ref DualComplex::from(const Complex<T>&, const Vector2<T>&),
+         *      @ref DualQuaternion::from(const Quaternion<T>&, const Vector3<T>&)
          */
         constexpr static Matrix4<T> from(const Matrix3x3<T>& rotationScaling, const Vector3<T>& translation) {
             return {{rotationScaling[0], T(0)},

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -87,6 +87,7 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
 
     void rotation();
     void translation();
+    void rotationTranslation();
     void combinedTransformParts();
     void matrix();
     void matrixNotOrthogonal();
@@ -145,6 +146,7 @@ DualComplexTest::DualComplexTest() {
 
               &DualComplexTest::rotation,
               &DualComplexTest::translation,
+              &DualComplexTest::rotationTranslation,
               &DualComplexTest::combinedTransformParts,
               &DualComplexTest::matrix,
               &DualComplexTest::matrixNotOrthogonal,
@@ -414,6 +416,17 @@ void DualComplexTest::translation() {
     CORRADE_COMPARE(a.translation(), vec);
 }
 
+void DualComplexTest::rotationTranslation() {
+    const Complex r = Complex::rotation(120.0_degf);
+
+    const Vector2 vec(1.0f, -3.5f);
+    const DualComplex t = DualComplex::translation(vec);
+
+    const DualComplex rt = t*DualComplex{r};
+    CORRADE_COMPARE(DualComplex::from(r, vec), rt);
+}
+
+
 void DualComplexTest::combinedTransformParts() {
     Vector2 translation = Vector2(-1.5f, 2.75f);
     DualComplex a = DualComplex::translation(translation)*DualComplex::rotation(23.0_degf);

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -89,6 +89,7 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     void rotation();
     void rotationNotNormalized();
     void translation();
+    void rotationTranslation();
     void combinedTransformParts();
     void matrix();
     void matrixNotOrthogonal();
@@ -154,6 +155,7 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::rotation,
               &DualQuaternionTest::rotationNotNormalized,
               &DualQuaternionTest::translation,
+              &DualQuaternionTest::rotationTranslation,
               &DualQuaternionTest::combinedTransformParts,
               &DualQuaternionTest::matrix,
               &DualQuaternionTest::matrixNotOrthogonal,
@@ -469,6 +471,17 @@ void DualQuaternionTest::translation() {
     CORRADE_COMPARE(q.translation(), vec);
 }
 
+void DualQuaternionTest::rotationTranslation() {
+    Vector3 axis(1.0f/Constants<Float>::sqrt3());
+    Quaternion r = Quaternion::rotation(120.0_degf, axis);
+
+    Vector3 vec(1.0f, -3.5f, 0.5f);
+    DualQuaternion t = DualQuaternion::translation(vec);
+
+    DualQuaternion rt = t*DualQuaternion{r};
+    CORRADE_COMPARE(DualQuaternion::from(r, vec), rt);
+}
+
 void DualQuaternionTest::combinedTransformParts() {
     Vector3 translation = Vector3(-1.0f, 2.0f, 3.0f);
     DualQuaternion a = DualQuaternion::translation(translation)*DualQuaternion::rotation(23.0_degf, Vector3::xAxis());