Solving Anim Curves And Tangents... How?

[mduffy]

I'm writing an exporter, but I can't figure out how to covert the key and tangent values from Maya into the equivalent Hermite or Bezier curves to use in my own code. I've studied the documentation for the MFnAnimCurve class, but something isn't adding up. Has anyone successfully taken key and tangent data out of Maya and used it in another package/program?

I've included a MEL script below which creates a simple scene (a null animated on translateY with keys on frames 1, 10, and 20), and then tries to solve the animation curve for frame 16. Tangents are unweighted. The code follows the procedures laid out in the documentation, but the values just don't match up. So what is missing in the code (and documentation) that allows one to solve the curves exactly.

I know that tangent values vary based on the current UI units (both linear and fps), but none of the UI values match the calculated values. I've tried to do these calcuations both through the API and through MEL, but I thought releasing a MEL sample would be more general and easier to test.

I've searched for other threads on this topic, but all the responses simply refer the original poster to the documentation for MFnAnimCurve. Well, I've implemented the docs and it still doesn't work. Anyone know what's wrong with these equations?

Thanks for any and all help,
Michael Duffy

(can't find any attachment commands, so just cut the following text, put it in a file called TestTangents.mel, and then run it. Results are printed out to the MELScript window.)

CODE
//------------------------------------------------------------------------------
//  This sample code is used to test the equations used to solve animation
//   curves in Maya.  Run TestTangents () in order to create the
//   objects in Maya and to run the Test_SolveCurve code that tries to calculate
//   the value of the animation curve at a given frame (frame 16 by default)
//   according to the documentation in the Maya API for MFnAnimCurve
//
//  The results differ between the documentation and the actual Maya program.
//   According to the equations in the documentation, the value for frame
//   16 should be 2.192126032, but Maya calculates it as 2.4799998404 .
//
//  What needs to be done to the calculations to make the script
//   calculated value match the Maya calculated value?
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
global proc TestTangents ()
 {
 // create a new scene
 file -f -new;
 // create an object
 group -em -n "null";
 // set the animation range
 playbackOptions -min 1 -ast 1 -max 20 -aet 20;
 // set some keyframes.  Make sure default settings of in and out tangents are spline,
 //   and weighted tangents are turned off.
 setKeyframe -t 1  -v 0 "null.ty";
 setKeyframe -t 10 -v 5 "null.ty";
 setKeyframe -t 20 -v 0 "null.ty";

 // Decide which frame to test.  Must be between keyframes 1 and 2 (value 10 - 20)
 int  $KeyToTest = 16;

 // now run the test
 Test_SolveCurve ($KeyToTest);

 // go to the tested frame so we can look at the value
 currentTime  $KeyToTest;

 select "null";
 };

//------------------------------------------------------------------------------
global proc Test_SolveCurve (int $KeyToTest)
 {
 // frame 16 gives a value of 2.48.  Let's try to reproduce this from just
 //  the key values and tangents.

 // first query and display our in and out tangent values.
 float $afInTanX  [] = keyTangent -q -ix null.ty;
 float $afInTanY  [] = keyTangent -q -iy null.ty;
 float $afOutTanX [] = keyTangent -q -ox null.ty;
 float $afOutTanY [] = keyTangent -q -oy null.ty;

 print ("--ix---\n");  print ($afInTanX);
 print ("--iy---\n");  print ($afInTanY);
 print ("--ox---\n");  print ($afOutTanX);
 print ("--oy---\n");  print ($afOutTanY);

 // Frame 16 lies between keys 1 and 2 (0-based indexing).  For the cubic
 //  curve solving, we know that the X axis is time, and the Y axis is
 //  value.  P1 and P4 are the endpoints of the cubic segment, and
 //  either the bezier points of P2 and P3 are used to solve the
 //  cubic equation, or normals N1 and N4 are used in the case of
 //  hermite curves.
 //
 // P1 = (10, 5)
 // P4 = (20, 0)

 float $P1X = 10;
 float $afP1Value [] = keyframe -t $P1X -q -eval "null.ty";
 float $P1Y = $afP1Value [0];

 float $P4X = 20;
 float $afP4Value [] = keyframe -t $P4X -q -eval "null.ty";
 float $P4Y = $afP4Value [0];

 // From the above keyTangent calls, we can get our normals
 //
 // N1 = (1, 0)
 // N4 = (0.000833, -1)

 float $N1X = $afOutTanX [1];
 float $N1Y = $afOutTanY [1];

 float $N4X = $afInTanX [2];
 float $N4Y = $afInTanY [2];

 print "\n";
 print ("P1 (" + $P1X + "," + $P1Y + ")\n");
 print ("P4 (" + $P4X + "," + $P4Y + ")\n");
 print ("N1 (" + $N1X + "," + $N1Y + ")\n");
 print ("N4 (" + $N4X + "," + $N4Y + ")\n");

 // The MFnAnimCurve docs say the normals are vectors stored as N1 = 3*(P2-P1)
 // and N4 = 3*(P4-P3).  From this we can solve for P2 and P3.
 // N1=3(P2-P1)  --> P2 = (N1 + 3P1) / 3
 // N4=3(P4-P3)  --> P3 = (3P4 - N4) / 3

 float $P2X = ($N1X + 3.0 * $P1X) / 3.0;
 float $P2Y = ($N1Y + 3.0 * $P1Y) / 3.0;

 float $P3X = (3.0 * $P4X - $N4X) / 3.0;
 float $P3Y = (3.0 * $P4Y - $N4Y) / 3.0;

 print ("P2 (" + $P2X + "," + $P2Y + ")\n");
 print ("P3 (" + $P3X + "," + $P3Y + ")\n");
 print "\n";

 // The next step to solving the equation is to find out where frame 16 falls.
 // To accomplish this the MFnAnimCurve docs say you solve F(u) for X (time)
 // and then plug that into F(u) to find Y (value)
 //
 //  F(u) = [ u^3 u^2 u 1 ] * B * | P1 |   ,  0 <= u <= 1
 //                               | P2 |
 //                               | P3 |
 //                               | P4 |)
 //
 // where B is the Bezier Basis matrix  | -1  3  -3  1 |
 //                                     |  3 -6   3  0 |
 //                                     | -3  3   0  0 |
 //                                     |  1  0   0  0 |

 // we will use piecewise approximation to solve for 'u'.  Basically the
 // question is, what 'u' value to we plug into the Bezier basis matrix
 // in order for it to kick out the X that equals frame 16.

 float  $LeftU  = 0.0;
 float  $RightU = 1.0;
 float  $TargetX = $KeyToTest; // frame 16
 float  $MidpointU;
 int    $iCurrStep;

 float  $LeftX  = SolveBezierMatrix ($LeftU,  $P1X, $P2X, $P3X, $P4X); // should be 10
 float  $RightX = SolveBezierMatrix ($RightU, $P1X, $P2X, $P3X, $P4X); // should be 20

 print ("LeftX  should be 10 : " + $LeftX  + "\n");
 print ("RightX should be 20 : " + $RightX + "\n");

 // 10 steps of recursion should get us close enough.
 for ($iCurrStep = 0; $iCurrStep < 10; ++$iCurrStep)
   {
   $MidpointU = ($LeftU + $RightU) / 2.0;

   float  $MidpointX = SolveBezierMatrix ($MidpointU,  $P1X, $P2X, $P3X, $P4X);

   if ($MidpointX > $TargetX)
     {
     // midpoint is to the right of our target
     $RightX = $MidpointX;
     $RightU = $MidpointU;
     }
   else
     {
     // midpoint is to the left of our target
     $LeftX = $MidpointX;
     $LeftU = $MidpointU;
     };
   };

 // Our right and left U values are close enough around the target U that
 //  we can now LERP the values and our margin of error should be very small.
 float  $T = ($TargetX - $LeftX) / ($RightX - $LeftX);
 float  $TargetU = $LeftU + (($RightU - $LeftU) * $T);

 float  $ActualX = SolveBezierMatrix ($TargetU, $P1X, $P2X, $P3X, $P4X);

 // we have the U value for frame 16 now.
 print ("U value for frame " + $KeyToTest + " is " + $TargetU + "  (Actual X value " + $ActualX + ")\n");

 // we plug this U value into the bezier equation for Y, and we should get the
 // value of the curve at frame 16

 float  $FinalY = SolveBezierMatrix ($TargetU, $P1Y, $P2Y, $P3Y, $P4Y);
 float  $fActualY = getAttr -t $KeyToTest "null.ty";

 print ("The curve at frame " + $KeyToTest + " evaluates to " + $FinalY + " but Maya calculates a value of " +  $fActualY + "\n");
 };

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

 // B is the Bezier Basis matrix  | -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));  
 };

[queequeg]

One thing to note is that the -ix, -iy, -ox, -oy values are very weird. Their definition seems to change when you switch from weighted to non-weighted tangents. I would simply ignore them and use -ia and -oa instead. Before you do this, it's a good idea to set the angular unit to radians. You can reset this when your script is finished. (It would be appreciated though if someone could explain how -ix, -iy work.)

As the docs state, first thing to do is compute the u value. To do this, you don't need any recursion. You just normalize your interval to [0,1]. So, if x1 is the start time, x4 is the end time of the interval, and x is the coordinate where you want to evaluate the curve, you need to translate everything by -x1, and then normalize it by dividing: u = (x-x1)/(x4-x1). This of course only works for non-weighted tangents, but since I neither like nor use weighted tangents, I can only help you with non-weighted tangents. You'd have to solve a cubic polynomial for weighted, the formula can be found on the net (simply ignore the complex-valued solutions).

Now we need the 4 Bezier points P1-P4. The first and the fourth are straight-forward. For the second we need the out-angle of the first key, let's call it alpha. Likewise we need the in-angle of the second key, beta. Then
P2 = P1 + tan(alpha)/3.;
P3 = P4 + (or was it - ?) tan(beta)/3.;
Now plug this into the F(u) from the docs.
To check if you got the correct values for P2 and P3, (temporarily) switch to weighted tangents and look at the y-value of the in-/out-tangent's handle.

[rob-bateman]

the animEngine example in the devkit interpolates the anim curves correctly. I just use a simple 1D hermite curve using the values/tamgent values over scaled 0 to 1 ranges between keframes.

[mduffy]

QUOTE(Queequeg @ 09/10/05, 06:18 AM)
Now we need the 4 Bezier points P1-P4. The first and the fourth are straight-forward. For the second we need the out-angle of the first key, let's call it alpha. Likewise we need the in-angle of the second key, beta. Then
P2 = P1 + tan(alpha)/3.;
P3 = P4 + (or was it - ?) tan(beta)/3.;
Now plug this into the F(u) from the docs.
To check if you got the correct values for P2 and P3, (temporarily) switch to weighted tangents and look at the y-value of the in-/out-tangent's handle.
[snapback]214634[/snapback]

How are you deriving P2 from P1 with just the angle? Don't you need to take into consideration the weight (magnitude) of the tangent vector as well, or is it always 1.0 in the non-weighted tangent case? Either way, your tan(alpha)/3 calculation will give you a scalar which you are then trying to add to a vector.

If I use sin and cos with the angles, I can add code like the following after the N1X, N1Y, N4X, N4Y assignments to extract the normal from the angle/weight, right?

CODE
 string $strSavedUnit = currentUnit -q -a;
 currentUnit -a "rad";
 float $afInTanA  [] = keyTangent -q -ia null.ty;
 float $afInTanW  [] = keyTangent -q -iw null.ty;
 float $afOutTanA [] = keyTangent -q -oa null.ty;
 float $afOutTanW [] = keyTangent -q -ow null.ty;
 currentUnit -a $strSavedUnit;

 print ("--ia---\n");  print ($afInTanA);
 print ("--iw---\n");  print ($afInTanW);
 print ("--oa---\n");  print ($afOutTanA);
 print ("--ow---\n");  print ($afOutTanW);

 $N1X = cos ($afOutTanA [1]) * $afOutTanW [1];
 $N1Y = sin ($afOutTanA [1]) * $afOutTanW [1];

 $N4X = cos ($afInTanA [2]) * $afInTanW [2];
 $N4Y = sin ($afInTanA [2]) * $afInTanW [2]

But that still doesn't give the same answer as Maya does.

I've been able to successfully go between the x,y and angle,weight representations of tangents before, so I know one can be calcualted from the other (once you take unit conversions into account), but I still can't figure out how these relate to the Bezier/Hermite/Cubic curve calculations in textbooks and math literature (and in the MFnAnimCurve docs).

Thanks,
Michael Duffy

[mduffy]

QUOTE(Rob Bateman @ 09/12/05, 01:02 AM)
the animEngine example in the devkit interpolates the anim curves correctly. I just use a simple 1D hermite curve using the values/tamgent values over scaled 0 to 1 ranges between keframes.
[snapback]214690[/snapback]

I've been looking over the animEngine example this afternoon, and that is some really messed up math. I'm still trying to unravel it to see if it actually maps to the Hermite or Bezier basis functions.

Basically in the animEngine code for unweighted tangents, they don't use the approach of multiplying the Hermite basis function against the points and tangents to get the a,b,c,d coefficients that are multiplied against the time value. Also they don't normalize time "u" in F(u) to be between 0 and 1, so it looks like their math has to "undo" the cubing and squaring of the non-normalized time values within their a,b,c,d coefficients.

Definately not the simplest, most straightforward way to calculate a curve, and I'm not quite sure yet how to unwind these equations to see if they actualy match the Hermite basis functions or not. For all I know they used a different basis function, or have a subtle error in their math.... dunno yet.

I haven't even been able to get coefficient "c" to make sense yet, and that's the easy linear one! They use the equation " UnscaledT * (y1 - y0) / (x1 - x0) " whereas the standard Hermite equations reduce to " UnscaledT * (y1 - y0) / (x3 - x0) " where UnscaledT is their unscaled time value (not normalized between 0 and 1).

Thanks for the tip about the animEngine code. Unfortunately I can't use it directly in my code (which uses Hermite curves) since I need to use standard Hermite basis functions and not "Maya Hermite-ish functions". I'll continue digging into the animEngine code and try to unwrap their logic.

Has anyone else gone successfully between Maya Anim Curves and either Hermite or Bezier curves?

Cheers,
Michael Duffy

[mduffy]

I just wanted to follow up this thread with what I've learned from Maya's Tech Support / Hotline.

The animEngine example shows how Maya itself internally solves animation curves.

However, the algorithms used by the animEngine code do NOT implement Bezier/Hermite curves as the MFnAnimCurve documentation states. The overall pseudo code that the MFnAnimCurve docs lay out is followed, but when it comes time to actually solve the curve given the endpoints and the tangent vectors, the Bezier Basis function is not used. And the equations used do not reduce down to the Bezier/Hermite basis functions. I don't know if Alias chose to implement their own curve type or if they just got the math wrong, but it doesn't match up to the standard basis functions.

I have logged a bug report with Alias to have the MFnAnimCurve documentation updated to reflect this fact. No word on the timeframe in which this bug will be addressed.

Cheers,
Michael Duffy

[rob-bateman]

I would have assumed the use TCB splines (Tangent Continuity Bias). The are related to hermite but not quite the same.

[queequeg]

Ok, I got it slightly wrong earlier, this one should work though. I renamed P1,...,P4 to y1,...,y4 for clarity. Non-weighted tangents only.

CODE
file -f -new;
polyCube -w 1 -h 1 -d 1 -sx 1 -sy 1 -sz 1 -ax 0 0 1 -tx 1 -ch 1;
setKeyframe -t 0