Unexpected results from GLKQuaternion conversion (from CMQuaternion)

Question

I'm working on an iOS app that will use CoreMotion to calculate range of motion.

I quickly abandoned Euler angles due to gimbal lock. So, now I'm trying to use quaternions.

As you probably know, CMMotionManager reports device motion data through the CMDeviceMotion class. The pertinent property here (for my purposes) is the attitude property, an instance of CMAttitude. From this, of course, you can access pitch, roll and yaw. I am still doing this when logging results just to get a better idea of the data that's coming off the device (since these values are fairly intuitive to envision). It also provides a quaternion property, which is an instance of CMQuaternion.

Based on many hours of research here and elsewhere, I was convinced that using quaternions was the correct approach to have correct results in any orientation. The problem is that I have found the CMQuaternion class/structure to be very dense and difficult to understand. Apple's documentation is sparse, and I couldn't ever back out what I considered to be a valid axis-angle representation from a CMQuaternion. (If someone has the math for calculating an axis-angle representation from a CMQuaternion, I'm all ears!)

I thought I had this issue solved when I stumbled across Apple's GLKQuaternion structure in their GLKit library. GLKit has methods that provide the axis and angle from an instance of GLKQuaternion. There's even a nice constructor method: GLKQuaternionMake(x, y, z, w).

Since CMQuaternion had x, y, z, and w properties, I reasoned that I could use this method to basically "cast" between instances of CMQuaternion and GLKQuaternion. I'm still not sure if that was correct or not.

In any case, I was logging results from my iPhone when I came across some particularly weird results.

The code that I've written has the intended purpose of capturing an initial attitude (when the user taps a button) and then sampling the CoreMotion data and determining the difference between the starting position and the current position.

Here's the code:

- (void)sampleDeviceMotion {
    // I've tested this, and "self.startingAttitude" is set/reset correctly
    if (self.startingAttitude == nil) {
        self.startingAttitude = self.motionManager.deviceMotion.attitude;
    }

    CMQuaternion quaternion1  = self.startingAttitude.quaternion;
    GLKQuaternion q1          = GLKQuaternionMake(quaternion1.x, quaternion1.y, quaternion1.z, quaternion1.w);
    GLKVector3 v1             = GLKQuaternionAxis(q1);
    float angle1              = GLKQuaternionAngle(q1);

    CMQuaternion quaternion2  = self.motionManager.deviceMotion.attitude.quaternion;
    GLKQuaternion q2          = GLKQuaternionMake(quaternion2.x, quaternion2.y, quaternion2.z, quaternion2.w);
    GLKVector3 v2             = GLKQuaternionAxis(q2);
    float angle2              = GLKQuaternionAngle(q2);

    float dotProduct          = GLKVector3DotProduct(v1, v2);
    float length1             = GLKVector3Length(v1);
    float length2             = GLKVector3Length(v2);
    float cosineOfTheta       = dotProduct / (length1 * length2);
    float theta               = acosf(cosineOfTheta);
    theta                     = radiansToDegrees(theta);

    float rotationDelta       = angle2 - angle1;
    rotationDelta             = radiansToDegrees(rotationDelta);

    printf("v1: (%.02f, %.02f, %.02f) v2: (%.02f, %.02f, %.02f) angle1: %.02f, angle2: %.02f - vectorDelta: %dº. rotationDelta: %dº (pitch: %.02f, roll: %.02f, yaw: %.02f)\n", v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, angle1, angle2, (int)theta, (int)rotationDelta, self.motionManager.deviceMotion.attitude.pitch, self.motionManager.deviceMotion.attitude.roll, self.motionManager.deviceMotion.attitude.yaw);

}

I've looked that code over 20 times, and I don't see any flaws in it, unless my assumption about the ability to move between CMQuaternion and GLKQuaternion is flawed.

I would expect that when the device is lying flat on a table, tapping the button and leaving the device still would give me results where q1 and q2 are essentially identical. I would understand a slight amount of "wobble" in the data, but if the device doesn't move, the axis and angle of the different quaternions should be (almost) the same.

Sometimes I get that (when the button is tapped and the device is left still), but sometimes the "initial" (self.startingAttitude) and subsequent values are off by a lot (40º-70º).

Also, in one case where the initial and subsequent values were in line, I had a weird result when then attempting to measure a rotation.

I "spun" the phone (rotation around the "Z" axis), and go the following results:

BEFORE:

v1: (-0.03, -0.03, -1.00) v2: (0.01, -0.04, -1.00) angle1: 0.02, angle2: 0.01 - vectorDelta: 2º. rotationDelta: 0º (pitch: 0.00, roll: -0.00, yaw: -0.01)

AFTER:

v1: (-0.03, -0.03, -1.00) v2: (-0.00, -0.01, 1.00) angle1: 0.02, angle2: 0.14 - vectorDelta: 176º. rotationDelta: 7º (pitch: -0.00, roll: -0.00, yaw: 0.14)

I believe the pitch/roll/yaw data to be correct both times. That is, I imparted a small amount of yaw rotation to the phone. So, why the did Z axis flip completely with just a small change in yaw?