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 (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 {rotation, Complex<T>{translation}};
+        }
+
         /**
          * @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 [\frac{\boldsymbol t}{2}, 0] r
+         * @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

@@ -88,6 +88,8 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
     void rotation();
     void translation();
     void combinedTransformParts();
+
+    void fromParts();
     void matrix();
     void matrixNotOrthogonal();
     void transformVector();
@@ -146,6 +148,8 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::rotation,
               &DualComplexTest::translation,
               &DualComplexTest::combinedTransformParts,
+
+              &DualComplexTest::fromParts,
               &DualComplexTest::matrix,
               &DualComplexTest::matrixNotOrthogonal,
               &DualComplexTest::transformVector,
@@ -414,6 +418,16 @@ void DualComplexTest::translation() {
     CORRADE_COMPARE(a.translation(), vec);
 }
 
+void DualComplexTest::fromParts() {
+    Complex r = Complex::rotation(120.0_degf);
+
+    Vector2 vec{1.0f, -3.5f};
+    DualComplex t = DualComplex::translation(vec);
+
+    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

@@ -90,6 +90,8 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     void rotationNotNormalized();
     void translation();
     void combinedTransformParts();
+
+    void fromParts();
     void matrix();
     void matrixNotOrthogonal();
     void transformVector();
@@ -155,6 +157,8 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::rotationNotNormalized,
               &DualQuaternionTest::translation,
               &DualQuaternionTest::combinedTransformParts,
+
+              &DualQuaternionTest::fromParts,
               &DualQuaternionTest::matrix,
               &DualQuaternionTest::matrixNotOrthogonal,
               &DualQuaternionTest::transformVector,
@@ -483,6 +487,17 @@ void DualQuaternionTest::combinedTransformParts() {
     CORRADE_COMPARE(b.translation(), Quaternion::rotation(23.0_degf, Vector3::xAxis()).transformVector(translation));
 }
 
+void DualQuaternionTest::fromParts() {
+    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::matrix() {
     DualQuaternion q = DualQuaternion::rotation(23.0_degf, Vector3::xAxis())*DualQuaternion::translation({-1.0f, 2.0f, 3.0f});
     Matrix4 m = Matrix4::rotationX(23.0_degf)*Matrix4::translation({-1.0f, 2.0f, 3.0f});