Renames UnitQuaternion to QuatRotation

See JuliaGeometry/Rotations.jl#201, from the latest Rotations.jl release https://github.com/JuliaGeometry/Rotations.jl/releases/tag/v1.1.0

(cherry picked from commit 0482ed2)

Author: ferrolho

src/joint_types/quaternion_floating.jl

@@ -27,13 +27,13 @@ has_fixed_subspaces(jt::QuaternionFloating) = true
 isfloating(::Type{<:QuaternionFloating}) = true
 
 @propagate_inbounds function rotation(jt::QuaternionFloating, q::AbstractVector, normalize::Bool = true)
-    quat = UnitQuaternion(q[1], q[2], q[3], q[4], normalize)
+    quat = QuatRotation(q[1], q[2], q[3], q[4], normalize)
     quat
 end
 
 @propagate_inbounds function set_rotation!(q::AbstractVector, jt::QuaternionFloating, rot::Rotation{3})
     T = eltype(rot)
-    quat = convert(UnitQuaternion{T}, rot)
+    quat = convert(QuatRotation{T}, rot)
     q[1] = quat.w
     q[2] = quat.x
     q[3] = quat.y
@@ -114,7 +114,7 @@ end
 
 @propagate_inbounds function configuration_derivative_to_velocity_adjoint!(fq, jt::QuaternionFloating, q::AbstractVector, fv)
     quatnorm = sqrt(q[1]^2 + q[2]^2 + q[3]^2 + q[4]^2) # TODO: make this nicer
-    quat = UnitQuaternion(q[1] / quatnorm, q[2] / quatnorm, q[3] / quatnorm, q[4] / quatnorm, false)
+    quat = QuatRotation(q[1] / quatnorm, q[2] / quatnorm, q[3] / quatnorm, q[4] / quatnorm, false)
     rot = (velocity_jacobian(angular_velocity_in_body, quat)' * angular_velocity(jt, fv)) ./ quatnorm
     trans = quat * linear_velocity(jt, fv)
     set_rotation!(fq, jt, rot)
@@ -166,14 +166,14 @@ end
 
 @propagate_inbounds function zero_configuration!(q::AbstractVector, jt::QuaternionFloating)
     T = eltype(q)
-    set_rotation!(q, jt, one(UnitQuaternion{T}))
+    set_rotation!(q, jt, one(QuatRotation{T}))
     set_translation!(q, jt, zero(SVector{3, T}))
     nothing
 end
 
 @propagate_inbounds function rand_configuration!(q::AbstractVector, jt::QuaternionFloating)
     T = eltype(q)
-    set_rotation!(q, jt, rand(UnitQuaternion{T}))
+    set_rotation!(q, jt, rand(QuatRotation{T}))
     set_translation!(q, jt, rand(SVector{3, T}) .- 0.5)
     nothing
 end

src/joint_types/quaternion_spherical.jl

@@ -24,12 +24,12 @@ has_fixed_subspaces(jt::QuaternionSpherical) = true
 isfloating(::Type{<:QuaternionSpherical}) = false
 
 @propagate_inbounds function rotation(jt::QuaternionSpherical, q::AbstractVector, normalize::Bool = true)
-    UnitQuaternion(q[1], q[2], q[3], q[4], normalize)
+    QuatRotation(q[1], q[2], q[3], q[4], normalize)
 end
 
 @propagate_inbounds function set_rotation!(q::AbstractVector, jt::QuaternionSpherical, rot::Rotation{3})
     T = eltype(rot)
-    quat = convert(UnitQuaternion{T}, rot)
+    quat = convert(QuatRotation{T}, rot)
     q[1] = quat.w
     q[2] = quat.x
     q[3] = quat.y
@@ -79,7 +79,7 @@ end
 
 @propagate_inbounds function configuration_derivative_to_velocity_adjoint!(fq, jt::QuaternionSpherical, q::AbstractVector, fv)
     quatnorm = sqrt(q[1]^2 + q[2]^2 + q[3]^2 + q[4]^2) # TODO: make this nicer
-    quat = UnitQuaternion(q[1] / quatnorm, q[2] / quatnorm, q[3] / quatnorm, q[4] / quatnorm, false)
+    quat = QuatRotation(q[1] / quatnorm, q[2] / quatnorm, q[3] / quatnorm, q[4] / quatnorm, false)
     fq .= (velocity_jacobian(angular_velocity_in_body, quat)' * fv) ./ quatnorm
     nothing
 end
@@ -103,13 +103,13 @@ end
 
 @propagate_inbounds function zero_configuration!(q::AbstractVector, jt::QuaternionSpherical)
     T = eltype(q)
-    set_rotation!(q, jt, one(UnitQuaternion{T}))
+    set_rotation!(q, jt, one(QuatRotation{T}))
     nothing
 end
 
 @propagate_inbounds function rand_configuration!(q::AbstractVector, jt::QuaternionSpherical)
     T = eltype(q)
-    set_rotation!(q, jt, rand(UnitQuaternion{T}))
+    set_rotation!(q, jt, rand(QuatRotation{T}))
     nothing
 end
 
@@ -147,7 +147,7 @@ end
 
 @propagate_inbounds function global_coordinates!(q::AbstractVector, jt::QuaternionSpherical, q0::AbstractVector, ϕ::AbstractVector)
     quat0 = rotation(jt, q0, false)
-    quat = quat0 * UnitQuaternion(RotationVec(ϕ[1], ϕ[2], ϕ[3]))
+    quat = quat0 * QuatRotation(RotationVec(ϕ[1], ϕ[2], ϕ[3]))
     set_rotation!(q, jt, quat)
     nothing
 end

src/spatial/util.jl

@@ -124,7 +124,7 @@ function quaternion_derivative end
 function spquat_derivative end
 function angular_velocity_in_body end
 
-@inline function velocity_jacobian(::typeof(quaternion_derivative), q::UnitQuaternion)
+@inline function velocity_jacobian(::typeof(quaternion_derivative), q::QuatRotation)
     (@SMatrix [
         -q.x -q.y -q.z;
         q.w -q.z  q.y;
@@ -133,27 +133,27 @@ function angular_velocity_in_body end
 end
 
 @inline function velocity_jacobian(::typeof(spquat_derivative), q::ModifiedRodriguesParam)
-    quat = UnitQuaternion(q)
+    quat = QuatRotation(q)
     dQuat_dW = velocity_jacobian(quaternion_derivative, quat)
     dSPQuat_dQuat = Rotations.jacobian(ModifiedRodriguesParam, quat)
     dSPQuat_dQuat * dQuat_dW
 end
 
-@inline function velocity_jacobian(::typeof(angular_velocity_in_body), q::UnitQuaternion)
+@inline function velocity_jacobian(::typeof(angular_velocity_in_body), q::QuatRotation)
     2 * @SMatrix [
     -q.x  q.w  q.z -q.y;
     -q.y -q.z  q.w  q.x;
     -q.z  q.y -q.x  q.w]
 end
 
 @inline function velocity_jacobian(::typeof(angular_velocity_in_body), q::ModifiedRodriguesParam)
-    quat = UnitQuaternion(q)
+    quat = QuatRotation(q)
     dW_dQuat = velocity_jacobian(angular_velocity_in_body, quat)
-    dQuat_dSPQuat = Rotations.jacobian(UnitQuaternion, q)
+    dQuat_dSPQuat = Rotations.jacobian(QuatRotation, q)
     dW_dQuat * dQuat_dSPQuat
 end
 
-@inline function quaternion_derivative(q::UnitQuaternion, angular_velocity_in_body::AbstractVector)
+@inline function quaternion_derivative(q::QuatRotation, angular_velocity_in_body::AbstractVector)
     @boundscheck length(angular_velocity_in_body) == 3 || error("size mismatch")
     velocity_jacobian(quaternion_derivative, q) * angular_velocity_in_body
 end
@@ -163,7 +163,7 @@ end
     velocity_jacobian(spquat_derivative, q) * angular_velocity_in_body
 end
 
-@inline function angular_velocity_in_body(q::UnitQuaternion, quat_derivative::AbstractVector)
+@inline function angular_velocity_in_body(q::QuatRotation, quat_derivative::AbstractVector)
     @boundscheck length(quat_derivative) == 4 || error("size mismatch")
     velocity_jacobian(angular_velocity_in_body, q) * quat_derivative
 end

src/util.jl

@@ -44,7 +44,7 @@ end
 ## VectorSegment: type of a view of a vector
 const VectorSegment{T} = SubArray{T,1,Array{T, 1},Tuple{UnitRange{Int64}},true} # TODO: a bit too specific
 
-quatnorm(quat::UnitQuaternion) = sqrt(quat.w^2 + quat.x^2 + quat.y^2 + quat.z^2)
+quatnorm(quat::QuatRotation) = sqrt(quat.w^2 + quat.x^2 + quat.y^2 + quat.z^2)
 
 
 ## Modification count stuff

test/test_mechanism_algorithms.jl

@@ -242,10 +242,10 @@ end
                 @test velocity(x, joint)[1] == vj
             end
             if joint_type(joint) isa QuaternionSpherical
-                quat = rand(UnitQuaternion{Float64})
+                quat = rand(QuatRotation{Float64})
                 set_configuration!(x, joint, quat)
                 tf = RigidBodyDynamics.joint_transform(joint, configuration(x, joint))
-                @test UnitQuaternion(rotation(tf)) ≈ quat atol = 1e-12
+                @test QuatRotation(rotation(tf)) ≈ quat atol = 1e-12
             end
             if joint_type(joint) isa SinCosRevolute
                 qj = rand()
@@ -886,7 +886,7 @@ end
         for joint_k = tree_joints(state_orig.mechanism)
             joint_type_k = joint_type(joint_k)
             if isa(joint_type_k, SPQuatFloating)
-                RigidBodyDynamics.set_rotation!(state_orig.q[joint_k], joint_type_k, ModifiedRodriguesParam(UnitQuaternion(-0.5, randn(), randn(), randn())))
+                RigidBodyDynamics.set_rotation!(state_orig.q[joint_k], joint_type_k, ModifiedRodriguesParam(QuatRotation(-0.5, randn(), randn(), randn())))
             end
         end
         setdirty!(state_orig)