From 9dbd8c9356d9dcd0bcfcc61d9bd10dd7cfd455f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Fri, 22 Feb 2013 11:47:13 +0100 Subject: [PATCH] Math: renamed Quaternion::rotateVector*() to transformVector*(). Now it is consistent with Matrix and can be easily used in templates. --- src/Math/DualQuaternion.h | 6 +++--- src/Math/Matrix4.h | 2 +- src/Math/Quaternion.h | 12 ++++++------ src/Math/Test/DualQuaternionTest.cpp | 2 +- src/Math/Test/QuaternionTest.cpp | 22 +++++++++++----------- 5 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/Math/DualQuaternion.h b/src/Math/DualQuaternion.h index 3230272c8..c83611238 100644 --- a/src/Math/DualQuaternion.h +++ b/src/Math/DualQuaternion.h @@ -246,11 +246,11 @@ template class DualQuaternion: public Dual> { /** * @brief Rotate and translate point with dual quaternion * - * See rotateVectorNormalized(), which is faster for normalized dual + * See transformPointNormalized(), which is faster for normalized dual * quaternions. @f[ * v' = qv \overline{\hat q^{-1}} = q ([\boldsymbol 0, 1] + \epsilon [\boldsymbol v, 0]) \overline{\hat q^{-1}} * @f] - * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::rotateVectorNormalized() + * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::transformVector() */ inline Vector3 transformPoint(const Vector3& vector) const { return ((*this)*DualQuaternion(vector)*inverted().dualConjugated()).dual().vector(); @@ -263,7 +263,7 @@ template class DualQuaternion: public Dual> { * quaternion is normalized. @f[ * v' = qv \overline{\hat q^{-1}} = qv \overline{\hat q^*} = q ([\boldsymbol 0, 1] + \epsilon [\boldsymbol v, 0]) \overline{\hat q^*} * @f] - * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::rotateVectorNormalized() + * @see DualQuaternion(const Vector3&), Matrix4::transformPoint(), Quaternion::transformVectorNormalized() */ inline Vector3 transformPointNormalized(const Vector3& vector) const { CORRADE_ASSERT(MathTypeTraits>::equals(lengthSquared(), Dual(1)), diff --git a/src/Math/Matrix4.h b/src/Math/Matrix4.h index 1684f816d..9b5f2a275 100644 --- a/src/Math/Matrix4.h +++ b/src/Math/Matrix4.h @@ -356,7 +356,7 @@ template class Matrix4: public Matrix<4, T> { * Translation is not involved in the transformation. @f[ * \boldsymbol v' = \boldsymbol M (v_x, v_y, v_z, 0)^T * @f] - * @see transformPoint(), Quaternion::rotateVector(), + * @see transformPoint(), Quaternion::transformVector(), * Matrix3::transformVector() */ inline Vector3 transformVector(const Vector3& vector) const { diff --git a/src/Math/Quaternion.h b/src/Math/Quaternion.h index ef87aa2ff..8fe41b9db 100644 --- a/src/Math/Quaternion.h +++ b/src/Math/Quaternion.h @@ -149,7 +149,7 @@ template class Quaternion { * To be used in transformations later. @f[ * q = [\boldsymbol v, 0] * @f] - * @see rotateVector(), rotateVectorNormalized() + * @see transformVector(), transformVectorNormalized() */ inline constexpr explicit Quaternion(const Vector3& vector): _vector(vector), _scalar(T(0)) {} @@ -403,28 +403,28 @@ template class Quaternion { /** * @brief Rotate vector with quaternion * - * See rotateVectorNormalized(), which is faster for normalized + * See transformVectorNormalized(), which is faster for normalized * quaternions. @f[ * v' = qvq^{-1} = q [\boldsymbol v, 0] q^{-1} * @f] * @see Quaternion(const Vector3&), Matrix4::transformVector(), DualQuaternion::transformPoint() */ - inline Vector3 rotateVector(const Vector3& vector) const { + inline Vector3 transformVector(const Vector3& vector) const { return ((*this)*Quaternion(vector)*inverted()).vector(); } /** * @brief Rotate vector with normalized quaternion * - * Faster alternative to rotateVector(), expects that the quaternion is + * Faster alternative to transformVector(), expects that the quaternion is * normalized. @f[ * v' = qvq^{-1} = qvq^* = q [\boldsymbol v, 0] q^* * @f] * @see Quaternion(const Vector3&), Matrix4::transformVector(), DualQuaternion::transformPointNormalized() */ - inline Vector3 rotateVectorNormalized(const Vector3& vector) const { + inline Vector3 transformVectorNormalized(const Vector3& vector) const { CORRADE_ASSERT(MathTypeTraits::equals(dot(), T(1)), - "Math::Quaternion::rotateVectorNormalized(): quaternion must be normalized", + "Math::Quaternion::transformVectorNormalized(): quaternion must be normalized", Vector3(std::numeric_limits::quiet_NaN())); return ((*this)*Quaternion(vector)*conjugated()).vector(); } diff --git a/src/Math/Test/DualQuaternionTest.cpp b/src/Math/Test/DualQuaternionTest.cpp index 4f905bf3f..771acf398 100644 --- a/src/Math/Test/DualQuaternionTest.cpp +++ b/src/Math/Test/DualQuaternionTest.cpp @@ -199,7 +199,7 @@ void DualQuaternionTest::combinedTransformParts() { CORRADE_COMPARE_AS(b.rotationAngle(), Deg(23.0f), Rad); CORRADE_COMPARE(a.translation(), translation); - CORRADE_COMPARE(b.translation(), Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).rotateVectorNormalized(translation)); + CORRADE_COMPARE(b.translation(), Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).transformVector(translation)); } void DualQuaternionTest::matrix() { diff --git a/src/Math/Test/QuaternionTest.cpp b/src/Math/Test/QuaternionTest.cpp index 9fd3b6fdf..250e958c7 100644 --- a/src/Math/Test/QuaternionTest.cpp +++ b/src/Math/Test/QuaternionTest.cpp @@ -51,8 +51,8 @@ class QuaternionTest: public Corrade::TestSuite::Tester { void matrix(); void lerp(); void slerp(); - void rotateVector(); - void rotateVectorNormalized(); + void transformVector(); + void transformVectorNormalized(); void debug(); }; @@ -92,8 +92,8 @@ QuaternionTest::QuaternionTest() { &QuaternionTest::matrix, &QuaternionTest::lerp, &QuaternionTest::slerp, - &QuaternionTest::rotateVector, - &QuaternionTest::rotateVectorNormalized, + &QuaternionTest::transformVector, + &QuaternionTest::transformVectorNormalized, &QuaternionTest::debug); } @@ -320,30 +320,30 @@ void QuaternionTest::slerp() { CORRADE_COMPARE(slerp, Quaternion({0.119165f, 0.0491109f, 0.0491109f}, 0.990442f)); } -void QuaternionTest::rotateVector() { +void QuaternionTest::transformVector() { Quaternion a = Quaternion::rotation(Deg(23.0f), Vector3::xAxis()); Matrix4 m = Matrix4::rotationX(Deg(23.0f)); Vector3 v(5.0f, -3.6f, 0.7f); - Vector3 rotated = a.rotateVector(v); + Vector3 rotated = a.transformVector(v); CORRADE_COMPARE(rotated, m.transformVector(v)); CORRADE_COMPARE(rotated, Vector3(5.0f, -3.58733f, -0.762279f)); } -void QuaternionTest::rotateVectorNormalized() { +void QuaternionTest::transformVectorNormalized() { Quaternion a = Quaternion::rotation(Deg(23.0f), Vector3::xAxis()); Matrix4 m = Matrix4::rotationX(Deg(23.0f)); Vector3 v(5.0f, -3.6f, 0.7f); std::ostringstream o; Corrade::Utility::Error::setOutput(&o); - Vector3 notRotated = (a*2).rotateVectorNormalized(v); + Vector3 notRotated = (a*2).transformVectorNormalized(v); CORRADE_VERIFY(notRotated != notRotated); - CORRADE_COMPARE(o.str(), "Math::Quaternion::rotateVectorNormalized(): quaternion must be normalized\n"); + CORRADE_COMPARE(o.str(), "Math::Quaternion::transformVectorNormalized(): quaternion must be normalized\n"); - Vector3 rotated = a.rotateVectorNormalized(v); + Vector3 rotated = a.transformVectorNormalized(v); CORRADE_COMPARE(rotated, m.transformVector(v)); - CORRADE_COMPARE(rotated, a.rotateVector(v)); + CORRADE_COMPARE(rotated, a.transformVector(v)); } void QuaternionTest::debug() {