Thanks, but I want it to work WITHIN pov. It's the angle of rotation of a knee in a
walk cycle.  This is come kind of "C" code, no?

Ben Birdsey wrote:

>         There are a whole lotta representations for splines.  It is pretty hard
> to make a suggestion, since I don't know what you want your spline to
> look like.
>
>         So, let me suggest a beta-spline.  This is a cubic spline, but two of
> the end matching conditions are relaxed to give you two more parameters
> to tweak (skewness and tension).  This can give you all sorts of cool
> effects including "sharp" corners id you turn up the tension at a node.
>
>         If you're up to it, you could probably convert this C-code to POV, but
> I'm not sure if this'll compile without errors as is.
>
>         Good luck on finding your spline solution!
>
>         In Him,
>         Ben
>
> /* C-code follows */
>
> float BernsteinP3(int order, float u)  {
>
>         float rv;
>
>         if(order>3 || order<0) return -HUGEVAL; /* return an error */
>
>         switch(order) {
>                 case 0:
>                         rv = (1-u)*(1-u)*(1-u);
>                         break;
>                 case 1:
>                         rv = 3*u*(1-u)*(1-u);
>                         break;
>                 case 2:
>                         rv = 3*u*u*(1-u);
>                         break;
>                 case 3:
>                         rv = u*u*u;
>         };
>
>         return rv;
> }
>
> float BetaP(int order, float s, float t, float u)  {
>
>         float rv;
>         float delta = 2*s*s*s + 4*s*s + 4*s + t + 2;
>
>         if(order>1 || order<-2) return -HUGEVAL; /* return an error */
>
>         switch(order) {
>                 case -2:
>                         rv = 12./d * s*s*s * BernsteinP3(0.,u);
>                         break;
>                 case -1:
>                         rv =
>                                 2.*s*(s+1.)/d*(
>                                         2.*BernsteinP3(0,u) +
>                                         (1.+s)*BernsteinP3(1,u) +
>                                         s*BernsteinP3(2,u) +
>                                         s*s*BernsteinP3(3,u)
>                                 ) +
>                                 t/d*(BernsteinP3(0,u) + BernsteinP3(1,u));
>                         break;
>                 case 0:
>                         rv =
>                                 2./d*(
>                                         BernsteinP3(0,u) +
>                                         (1+s)*BernsteinP3(1,u) +
>                                         (1+s)*(1+s)*BernsteinP3(2,u) +
>                                         2*s*(1+s)*BernsteinP3(3,u)
>                                 ) +
>                                 t/d*(BernsteinP3(2,u) + BernsteinP3(3,u));
>                         break;
>                 case 1:
>                         rv = 2./d * BernsteinP3(3,u);
>         };
>
>         return rv;
> }
>
> float BetaSpline( float control_point[], int i, float s[], float t[],
> float u ) {
>         float rv;
>         int j;
>
>         if( u<0. || u>1.) return -HUGEVAL; /* return an error */
>
>         /* the array must be defined to be as large as MAXVAL, or you might get
> an error */
>         for(j=-2, rv=0; j<2; j++)
>                 if(i+j>=0 && i+j <MAXVAL)
>                         rv += control_point[i+j] * BetaP(j, s[i], t[i], u);
>
>         return rv;
>
> }
>
> /* end C-code */

Post a reply to this message