Calculate average of arbitrary amount of quaternions (recursion)

Question

Simply calculate the average for 2 Quaternions should work like follows right? :

Quaternion.Lerp(rotationlist[0].transform.rotation, rotationlist[1].transform.rotation, 0.5f);

And now I tried to put this into a recursive function, like this:

private Quaternion calcAvg(int pos, List<GameObject> rotationlist)
{
    if (pos < rotationlist.Count)
    {
        return Quaternion.Lerp(rotationlist[pos].transform.rotation, calcAvg(++pos, rotationlist), 0.5f);
    }
    return ???;
}

But I'm not absolutely sure, what to put into the second return.

Edit, I added the last position into the second return but now I get an out of bounds exception:

private Quaternion calcAvg(int pos, List<GameObject> markerList)
{
        if (pos < markerList.Count)
        {
            return Quaternion.Lerp(markerList[pos].transform.rotation, calcAvg(++pos, markerList), 0.5f);
        }
        return markerList[pos].transform.rotation;
}

Edit, fixed the issue, I will test this now but it looks alright :

private Quaternion calcAvg(int pos, List<GameObject> markerList)
{
        if (pos < markerList.Count)
        {
            return Quaternion.Lerp(markerList[pos].transform.rotation, calcAvg(++pos, markerList), 0.5f);
        }
        return markerList[pos].transform.rotation;
}

Answer 1

Under the hood, Lerp will simply lerp each component of the quaternion, then normalise the result. A square root is hidden in there for each call to Lerp. It is therefore very inefficient. Also, any floating point rounding errors will accumulate.

This will be a lot faster, and also a lot more precise:

private Quaternion calcAvg(List<GameObject> rotationlist)
{
    if (rotationlist.Count == 0)
        throw new ArgumentException();
float x, y, z, w;
foreach (var go in rotationlist)
{
    var q = go.transform.rotation;
    x += q.x; y += q.y; z += q.z; w += q.w;
}
float k = 1.0f / Mathf.Sqrt(x * x + y * y + z * z + w * w);
return new Quaternion(x * k, y * k, z * k, w * k);

}

Answer 2

In your approach, the first quat in the list gets weighted at 50%, and all the rest together will be weighted for the other 50%.

If you had 4 quats, with your approach, their relative weightings will be 0.5, 0.25, 0.125, 0.125.

You could fix this my changing the 0.5f to something computed based on list and position.

You could also make the recursion more balanced with something like:

calcAvg(List<quat> quats):
  if(quats.size == 0): ERROR
  if(quats.size == 1):
    return quats[0]
  List<quat> firstHalf = first half of quats list
  List<quat> secondHalf = second half of quats list
  q1 = calcAvg(firstHalf)
  q2 = calcAvg(secondHalf)
  return Lerp(q1, q2, firstHalf.size / quats.size)

I'm not completely certain of the geometric characteristics of this kind of Angle Averaging. Probably fine for game use...

Answer 3

Sam's logic above is sound, but the code had some errors.

private static Quaternion CalcAvg(List<Transform> rotationlist)
{
    if (rotationlist.Count == 0)
        throw new ArgumentException();
float x = 0, y = 0, z = 0, w = 0;
foreach (Transform t in rotationlist)
{
    x += t.rotation.x;
    y += t.rotation.y;
    z += t.rotation.z;
    w += t.rotation.w;
}
float k = 1.0f / Mathf.Sqrt(x * x + y * y + z * z + w * w);
return new Quaternion(x * k, y * k, z * k, w * k);

}

Answer 4

1. Convert the quaternions into angle-vectors by using Quaternion.eulerAngles
2. Calculate the average of each of the three axis' of these vectors.
3. Convert the resulting axis-averages back to a Quaternion using Quaternion.Euler.