Interpolating Maya Anim Curve

[_dk_]

Hi,

I wanted to export animation curves from Maya (yeah, no Ik, neither expressions - only simple key-framed curves) to be able to exactly reproduce them in my application (sampling the values at each frame is not an option).

After a few tests and having read this thread I found out Maya has some very special spline evaluation procedure. I.e. following instructions described in the docs for MFnAnimCurve doesn't result in the same curve as Maya produces.
Using natural splines or Hermite curves also gives slighly different results (as expected due to different constrainats on the values of derivatives).

So does anyone know how to retrieve P2,P3 vectors from Maya to have exactly the same curves as seen in Maya?

Thank you.

[joojaa]

QUOTE(_DK_ @ 04/10/09, 01:48 AM) [snapback]305373[/snapback]
I found out Maya has some very special spline evaluation procedure. I.e. following instructions described in the docs for MFnAnimCurve doesn't result in the same curve as Maya produces.

in my brief test it does! how do you do it then?

QUOTE
So does anyone know how to retrieve P2,P3 vectors from Maya to have exactly the same curves as seen in Maya?

well i rerieved them in mel so it was pretty trivial but it depends on where you read the values form. So si your exporter working out form maya or just pasring a maya scii file.

Also in the api it depends on wether or not tangents are weighted or not.

[_dk_]

Ok, here we go. For simplicity I've converted the MEL test from the original post I've mentioned:

CODE
global float $keyframes[] = {
   1,     0,  
   10,    5,
   20,    0
};

global string $animName;

global proc runTest()
{  
    global float $keyframes[];
    global string $animName;

    // create a new scene
    file -f -new;
    // create an object
    string $group = group -empty;
    // set the animation range
    playbackOptions -min 1 -ast 1 -max 20 -aet 20;

    $animName = $group + ".ty";

    // set 3 keyframes.  Make sure default settings of in and out tangents are spline,
    //   and weighted tangents are turned off.    
    for($i=0; $i < size($keyframes) / 2; $i++ ) {
      setKeyframe -t $keyframes[$i * 2]  -v $keyframes[($i * 2)+1] $animName;
    }  

    testBezierCurve (1, $animName);
    testBezierCurve (3, $animName);
    testBezierCurve (6, $animName);
    testBezierCurve (10, $animName);

}

global proc float testBezierCurve (int $keyToTest, string $animName)
{

    global float $keyframes[];

    // getting the needed tangent values
    float $inTangentX  [] = keyTangent -q -ix $animName;
    float $inTangentY  [] = keyTangent -q -iy $animName;
    float $outTangentX [] = keyTangent -q -ox $animName;
    float $outTangentY [] = keyTangent -q -oy $animName;

    // for simplicity only checking first interval of the curve here (only testing values within this interval)    
    float $p1X = $keyframes[0];
    float $p1Y = $keyframes[1];
    float $p4X = $keyframes[1 * 2];
    float $p4Y = $keyframes[(1*2) + 1];    

    // in for the first keyframe
    float $n1X = $outTangentX [0];
    float $n1Y = $outTangentY [0];

    // out for the second keyframe
    float $n4X = $inTangentX [1];
    float $n4Y = $inTangentY [1];

    // MFnAnimCurve docs state that out tangent at P1 is N1 = 3*(P2-P1)
    // and in tangent at P4 is  N4 = 3*(P4-P3). Hence:
    // P2 = N1 / 3 + P1
    // P3 = P4 - N4 / 3    
    float $p2X = ($n1X / 3.0 + $p1X);
    float $p2Y = ($n1Y / 3.0 + $p1Y);

    float $p3X = $p4X - $n4X / 3.0;
    float $p3Y = $p4Y - $n4Y / 3.0;

    // normalized time value  
    float $u = ($keyToTest - $p1X) / ($p4X - $p1X);

    float $curveValue = getBezierValue($u, $p1Y, $p2Y, $p3Y, $p4Y);

    float $mayaValue = getAttr -t $keyToTest $animName;

    print("Keyframe = " + $keyToTest + "; Maya value = " + $mayaValue + "; Calced value = " + $curveValue + "; Diff. = " + ($mayaValue - $curveValue) + "\n");

    return $curveValue;  
};

global proc float getBezierValue (float $U, float $P1, float $P2, float $P3, float $P4)
{
    float   $U2 = $U * $U;
    float   $U3 = $U2 * $U;

    // | -1  3  -3  1 |
    // |  3 -6   3  0 |
    // | -3  3   0  0 |
    // |  1  0   0  0 |

    float   $H1 =  (-1.0 * $U3) + ( 3.0 * $U2) + (-3.0 * $U) +  1.0;
    float   $H2 =  ( 3.0 * $U3) + (-6.0 * $U2) + ( 3.0 * $U) +  0.0;
    float   $H3 =  (-3.0 * $U3) + ( 3.0 * $U2) + ( 0.0 * $U) +  0.0;
    float   $H4 =  ( 1.0 * $U3) + ( 0.0 * $U2) + ( 0.0 * $U) +  0.0;

    return  ($P1 * $H1) +
            ($P2 * $H2) +
            ($P3 * $H3) +
            ($P4 * $H4);  
};

Source it and call runTest()

For visual results this part can be added:
CODE
global proc runTestGeom()
{
   global string $animName;

   runTest();

   int $lastFrame = 10;

   for($i=1; $i <= $lastFrame; $i++ ) {

      // our vlaue
      float $val = testBezierCurve($i, $animName);
      // maya value
      float $mayaValue = getAttr -t $i $animName;

      spaceLocator -p $i $val 0;

      string $sphere[] = sphere -r 0.4;

      setAttr ($sphere[0]+".t") $i $mayaValue 0;

   }  

}

Spheres are for points produced by maya and locators are for our custom points. It can be seen that the control points are well interpolated, but intermediate values are not exactly the same.

So can you share your code? Or point out whgere the mistake is?

Thank you.

[_dk_]

I've got slightly better results using approach with angles (as in devkit\animEngine) instead of getting tangent vectors

CODE
    float $inAngle  [] = anglesToRadians(keyTangent -q -inAngle $animName);
    float $outAngle  [] = anglesToRadians(keyTangent -q -outAngle $animName);

    float $multiplier = 3.0;

    float $p2X = $p1X + cos($outAngle[0]) * $multiplier;
    float $p2Y = $p1Y + sin($outAngle[0]) * $multiplier;    

    float $p3X = $p4X - cos($inAngle[1]) * $multiplier;
    float $p3Y = $p4Y - sin($inAngle[1]) * $multiplier;

But there're still some errors (seriously growing when tangent angles are increasing):

[joojaa]

did you read the exmple provided in mayadir/devkit/animDemo.c? It has code and all you need to export the values is in maya allready. Will take a look later if i have time.

Anyway your biggest mistake is to think mel somehow reflects api! Also dont use anglesToRadians use sind and cos instead hgis way you wont accumulate as much error

[_dk_]

Lol, we've posted at the same time 8)
I've used the angle approach from this example as you can see above.

[joojaa]

Ok your tangent values are wrong your calculating them to be

p2x= 1.023938 while the true value is closer to 4.0 and
p2y=0.332473while its true value is closer to 1.67 (with quick iteration it appears to be 1+2/3)

And for

p3x=7
p3y=5

[joojaa]

Oh an ps please dont equate this error metric as a inaccuracy in the manual. Its just that the mel command never said it retrieves the internal value it may be well something thatch already computed on, otherwiseyoud use getAttr. Wich is the case when you ask -ox for nonweighted tangents.

I used a nifty mel trick to querry the values directly but thet wont help you compute on the data

[rob-bateman]

I can't see anywhere where you solve the bezier equation to get the correct 't' value. You only seem to scale 't' with respect to the start and end points. You should be using the cubic equation to solve the equation to get 't', and then pump that value into the bezier curve for the value.

post on gamedev.net about the same thing: http://www.gamedev.net/community/forums/to...topic\_id=474094

\edit some very dodgy code that guestimates the correct interpolation value.

CODE
global proc float testBezierCurve (int $keyToTest, string $animName)
{

    global float $keyframes[];

    // getting the needed tangent values
    float $inTangentX  [] = keyTangent -q -ix $animName;
    float $inTangentY  [] = keyTangent -q -iy $animName;
    float $outTangentX [] = keyTangent -q -ox $animName;
    float $outTangentY [] = keyTangent -q -oy $animName;

    // for simplicity only checking first interval of the curve here (only testing values within this interval)    
    float $p1X = $keyframes[0];
    float $p1Y = $keyframes[1];
    float $p4X = $keyframes[1 * 2];
    float $p4Y = $keyframes[(1*2) + 1];    

    // in for the first keyframe
    float $n1X = $outTangentX [0];
    float $n1Y = $outTangentY [0];

    // out for the second keyframe
    float $n4X = $inTangentX [1];
    float $n4Y = $inTangentY [1];

    // MFnAnimCurve docs state that out tangent at P1 is N1 = 3*(P2-P1)
    // and in tangent at P4 is  N4 = 3*(P4-P3). Hence:
    // P2 = N1 / 3 + P1
    // P3 = P4 - N4 / 3    
    float $p2X = ($n1X / 3.0 + $p1X);
    float $p2Y = ($n1Y / 3.0 + $p1Y);

    float $p3X = $p4X - $n4X / 3.0;
    float $p3Y = $p4Y - $n4Y / 3.0;

    // NOTE! You need to solve the equation using the X values first.
    float $curveTime = findApproxTime($keyToTest, $p1X, $p2X, $p3X, $p4X);

    // this then gives you the correct interpolation value for the Y's
    float $curveValue = getBezierValue($curveTime, $p1Y, $p2Y, $p3Y, $p4Y);

    float $mayaValue = getAttr -t $keyToTest $animName;

    print("Keyframe = " + $keyToTest + "; Maya value = " + $mayaValue + "; Calced value = " + $curveValue + "; Diff. = " + ($mayaValue - $curveValue) + "\n");

    return $curveValue;  
};

// this function can be replaced with one to correctly solve the cubic
// equation. This is just a nasty hack. It only works because you
// know that $v0 < $v1 < $v2 < $v3. That constraint makes the cubic
// eqn solvable.
global proc float findApproxTime(float $t,float $v0,float $v1,float $v2,float $v3)
{
  float $value=0;
  float $start=0;
  float $mid=0;
  float $end = 1.0;

  // do 30 iterations to find an interpolation value
  // that produces the output value $t
  for($i=0;$i<30;++$i)
  {
    $mid = ($start+$end)*0.5;
    $value = getBezierValue($mid,$v0,$v1,$v2,$v3);
    if($value>$t)
    {
      $start = $mid;
    }
    else
    {
      $end = $mid;
    }
  }
  return $mid;
}