PATHS.C

Go to the documentation of this file.

/* file PATHS.C - Path functions */

#define MODULE_PATH

#include "animate.h"

static short    Ni;
static double dtau;    /* 1.0/Ni  */

static void DrawEndOfPath(HDC hdc[],
                            point v1,
                            short status, short pointstatus);
static void DrawPathSegment(HDC hdc [],
                            point vl ,point v1, point v2, point vn,
                            short status, short pointstatus,
                            double ts, double te);
static double SegmentLength(point vl, point v1, point v2, point vn,
                            double ts, double te);
static void DrawPathCurve(HDC hDC);
static void DrawLagrangePathCurve(HDC hDC);
static PATHEDITCONTROL *GetPathEditPoint(int x, int y);
static void CalculatePathPositions(object *op);
//int GetYpathCoord(int x, PATHEDITCONTROL *pe);

long SplinesP(double k[], double tau){
 return (long)(tau*(tau*(tau*k[3] + k[2]) + k[1]) + k[0]);
}

double SplinesR(double k[], double tau){
 return (double)(tau*(tau*(tau*k[3] + k[2]) + k[1]) + k[0]);
}

void SplinesK(double k[], long vl, long v1, long v2, long vn){
  k[0] = (double)v1;
  k[1] = -0.5*(double)vl+0.5*(double)v2;
  k[2] = (double)vl-2.5*(double)v1+2.0*(double)v2-0.5*(double)vn;
  k[3] = -0.5*(double)vl+1.5*(double)v1-1.5*(double)v2+0.5*(double)vn;
}

void SplinesG(double k[], double xi, double xi1, double xig, double xig1){
  k[0] = xi;
  k[1] = xig;
  k[2] = -3.0*xi+3.0*xi1-2.0*xig-xig1;
  k[3] = 2.0*xi-2.0*xi1+xig+xig1;
}

static void DrawEndOfPath(HDC hdc[],
                            point v1,
                            short status, short pointstatus){
 int  i,sh1,sv1;
 int ifd,ild;
 HPEN holdpen;
 HBRUSH holdbrush;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(in_stage_triview(v1)){
   for(i=ifd;i<ild;i++){
     GetWindowCoords(i,v1[0],v1[1],v1[2],&sh1,&sv1);
     if(tool == NOTOOL  || tool == PAN || tool == INZOOM ||
        status == DESELECTED){
       if     (status == SELECTED)holdpen=SelectObject(hdc[i],ghSelectedPen);
       else                       holdpen=SelectObject(hdc[i],ghDeselectedPen);
     }
     else{
       if(status == EDITING)holdpen=SelectObject(hdc[i],ghEditPen);
       else                 holdpen=SelectObject(hdc[i],ghInvertPen);
     }
     if(status == EDITING && pointstatus == SELECTED){
       SelectObject(hdc[i],ghSelectedPen);
       holdbrush=SelectObject(hdc[i],ghInvertBrush);
       Rectangle(hdc[i],
                (int)sh1-SelectPointSize-1,(int)sv1-SelectPointSize-1,
                (int)sh1+SelectPointSize+2,(int)sv1+SelectPointSize+2);
       SelectObject(hdc[i],holdbrush);
     }
     else{
       holdbrush=SelectObject(hdc[i],ghSelectedBrush);
       Rectangle(hdc[i],
                (int)sh1-SelectPointSize,(int)sv1-SelectPointSize,
                (int)sh1+SelectPointSize,(int)sv1+SelectPointSize);
       SelectObject(hdc[i],holdbrush);
     }
     SelectObject(hdc[i],holdpen);
   }
 }
}

static void DrawPathSegment(HDC hdc[],
                            point vl ,point v1, point v2, point vn,
                            short status, short pointstatus,
                            double ts, double te){
 int  i,j,sh1,sv1,sh2,sv2;
 int ifd,ild;
 long   x,y,z,xl,yl,zl;
 double tau,kx[4],ky[4],kz[4];
 HPEN holdpen;
 HBRUSH holdbrush;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(in_stage_triview(v1) || in_stage_triview(v2)){
   double gs,ge;
   gs=(double)(v2[0]-vl[0])*ts; ge=(double)(vn[0]-v1[0])*te;
   SplinesG(kx,v1[0],v2[0],gs,ge);
   gs=(double)(v2[1]-vl[1])*ts; ge=(double)(vn[1]-v1[1])*te;
   SplinesG(ky,v1[1],v2[1],gs,ge);
   gs=(double)(v2[2]-vl[2])*ts; ge=(double)(vn[2]-v1[2])*te;
   SplinesG(kz,v1[2],v2[2],gs,ge);
//  SplinesK(kx,vl[0],v1[0],v2[0],vn[0]);
//  SplinesK(ky,vl[1],v1[1],v2[1],vn[1]);
//  SplinesK(kz,vl[2],v1[2],v2[2],vn[2]);
  tau=0.0;
  for(j = 0; j <= Ni; j++){
    x = SplinesP(kx,tau);
    y = SplinesP(ky,tau);
    z = SplinesP(kz,tau);
    for(i=ifd;i<ild;i++){
      GetWindowCoords(i,x,y,z,&sh1,&sv1);
      if(j != 0)GetWindowCoords(i,xl,yl,zl,&sh2,&sv2);
      if(tool == NOTOOL  || tool == PAN || tool == INZOOM ||
          status == DESELECTED){
        if     (status == SELECTED)holdpen=SelectObject(hdc[i],ghSelectedPen);
        else                       holdpen=SelectObject(hdc[i],ghDeselectedPen);
      }
      else {
        if(status == EDITING)holdpen=SelectObject(hdc[i],ghEditPen);
        else                 holdpen=SelectObject(hdc[i],ghInvertPen);
      }
      MoveToEx(hdc[i],sh1,sv1,NULL);
      if(j != 0)LineTo(hdc[i],sh2,sv2);
      else{   /* draw the control point */
        if(status == EDITING && pointstatus == SELECTED){
          SelectObject(hdc[i],ghSelectedPen);
          holdbrush=SelectObject(hdc[i],ghInvertBrush);
          Rectangle(hdc[i],
                   (int)sh1-SelectPointSize-1,(int)sv1-SelectPointSize-1,
                   (int)sh1+SelectPointSize+2,(int)sv1+SelectPointSize+2);
          SelectObject(hdc[i],holdbrush);
        }
        else{
          Rectangle(hdc[i],
                   (int)sh1-SelectPointSize,(int)sv1-SelectPointSize,
                   (int)sh1+SelectPointSize+1,(int)sv1+SelectPointSize+1);
        }
      }
      SelectObject(hdc[i],holdpen);
    }
    tau += dtau;
    xl=x; yl=y; zl=z;
  }
 }
}

void DrawPath(HDC hdc[], object *Op, point Offset,
              double p, double t, double a,
              short im, double ima, short status){
 int i;
 short pointstatus;
 point Vpp,Vpn,Vpnn,*Vp;
 pathpoint *Pp;
 double ts,te;
 pointstatus=DESELECTED;
// if(View == TRIVIEW){ Ni= 5; dtau=0.2; }
// else               { Ni=10; dtau=0.1; }
 if(View == TRIVIEW){ Ni= 3; dtau=0.3333333; }
 else               { Ni= 4; dtau=0.25; }
 if((Vp=(point *)X__Malloc(Op->npathpoints * sizeof(point))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return;
 }
 Pp=Op->firstpathpoint; i=0; while(Pp != NULL){
  CopyPoint(Pp->p,Vp[i]);
  i++; Pp=Pp->next;
 }
 if(i != Op->npathpoints){
   SendPrgmQuery(IDQ_PATH1,0);
   if(Vp != NULL)X__Free(Vp);
   return;
 }
 Transform((long)(Op->npathpoints),Vp,Vp,Offset,p,t,a,im,ima);
 if(status == SELECTED || status == EDITING){
   DrawArrow(hdc,Offset,p,t,a,im,ima,(double)UNIT/8);
 }
 /* Vpp is extrapolated point before first Vpn is extrapolated after last */
 if(Op->pathtype == OPEN){ /* prepare extrapolation points from Vp[] */
   SubPoints(Vp[1],Vp[0],Vpp);
   SubPoints(Vp[0],Vpp,Vpp);
   SubPoints(Vp[Op->npathpoints - 1],Vp[Op->npathpoints - 2],Vpnn);
   AddPoints(Vp[Op->npathpoints - 1],Vpnn,Vpn);
 }
 Pp=Op->firstpathpoint; i=0; while(Pp != NULL){ /* loop thru all points */
  pointstatus=DESELECTED;
  ts=Pp->tension_n;
  if(Pp->next != NULL)te=Pp->next->tension_p;
  else{
    if(Op->pathtype == OPEN)te=0.5;
    else                    te=Op->firstpathpoint->tension_p;
  }
  if(Pp == SelectedPathPoint)pointstatus=SELECTED;
  if(Op->pathtype == OPEN){
    if(i == 0 && Op->npathpoints == 2)DrawPathSegment(hdc,
      Vpp,Vp[0],Vp[1],Vpn,status,pointstatus,ts,te);
    else if(i == 0)DrawPathSegment(hdc,Vpp,Vp[0],Vp[1],Vp[2],
      status,pointstatus,ts,te);
    else if(i == Op->npathpoints - 2)DrawPathSegment(hdc,
      Vp[i-1],Vp[i],Vp[i+1],Vpn,status,pointstatus,ts,te);
    else if(i == Op->npathpoints - 1)
      DrawEndOfPath(hdc,Vp[Op->npathpoints - 1],status,pointstatus);
    else
      DrawPathSegment(hdc,Vp[i-1],Vp[i],Vp[i+1],Vp[i+2],
                      status,pointstatus,ts,te);
  }
  else{ /* closed path */
    if(i == 0 && Op->npathpoints == 3)DrawPathSegment(hdc,
      Vp[2],Vp[0],Vp[1],Vp[2],status,pointstatus,ts,te);
    else if(i == 0)DrawPathSegment(hdc,Vp[Op->npathpoints - 1],
      Vp[0],Vp[1],Vp[2],status,pointstatus,ts,te);
    else if(i == Op->npathpoints - 2)DrawPathSegment(hdc,
      Vp[i-1],Vp[i],Vp[i+1],Vp[0],status,pointstatus,ts,te);
    else if(i == Op->npathpoints - 1)DrawPathSegment(hdc,
      Vp[i-1],Vp[i],Vp[0],Vp[1],status,pointstatus,ts,te);
    else
      DrawPathSegment(hdc,Vp[i-1],Vp[i],Vp[i+1],Vp[i+2],
                      status,pointstatus,ts,te);
  }
  i++; Pp=Pp->next;
 }
 X__Free(Vp);
}


static double SegmentLength(point vl, point v1, point v2, point vn,
                            double ts, double te){
 short j;
 long x,y,z,xl,yl,zl;
 double result,tau,kx[4],ky[4],kz[4];
 double gs,ge;
 gs=(double)(v2[0]-vl[0])*ts; ge=(double)(vn[0]-v1[0])*te;
 SplinesG(kx,v1[0],v2[0],gs,ge);
 gs=(double)(v2[1]-vl[1])*ts; ge=(double)(vn[1]-v1[1])*te;
 SplinesG(ky,v1[1],v2[1],gs,ge);
 gs=(double)(v2[2]-vl[2])*ts; ge=(double)(vn[2]-v1[2])*te;
 SplinesG(kz,v1[2],v2[2],gs,ge);
 tau=0.0;
 result=0.0;
 for(j = 0; j <= Ni; j++){
   x = SplinesP(kx,tau);
   y = SplinesP(ky,tau);
   z = SplinesP(kz,tau);
   if(j > 0)result += sqrt((double)(x-xl)*(double)(x-xl)
                          +(double)(y-yl)*(double)(y-yl)
                          +(double)(z-zl)*(double)(z-zl) );
   tau += dtau;
   xl=x; yl=y; zl=z;
 }
 return result;
}

static double GetSegmentPositionForLength(point vl, point v1, point v2, point vn,
                                 double ts, double te, double d, vector p){
 short j;
 long x,y,z,xl,yl,zl;
 double result,tau,kx[4],ky[4],kz[4];
 double gs,ge;
 gs=(double)(v2[0]-vl[0])*ts; ge=(double)(vn[0]-v1[0])*te;
 SplinesG(kx,v1[0],v2[0],gs,ge);
 gs=(double)(v2[1]-vl[1])*ts; ge=(double)(vn[1]-v1[1])*te;
 SplinesG(ky,v1[1],v2[1],gs,ge);
 gs=(double)(v2[2]-vl[2])*ts; ge=(double)(vn[2]-v1[2])*te;
 SplinesG(kz,v1[2],v2[2],gs,ge);
 tau=0.0;
 result=0.0;
 for(j = 0; j <= Ni; j++){
   x = SplinesP(kx,tau);
   y = SplinesP(ky,tau);
   z = SplinesP(kz,tau);
   if(j > 0)result += sqrt((double)(x-xl)*(double)(x-xl)
                          +(double)(y-yl)*(double)(y-yl)
                          +(double)(z-zl)*(double)(z-zl) );
   if(result > d){
     p[0]=x; p[1]=y; p[2]=z;
     return -1.0; // we have exceeded the distance so 
   }  
   tau += dtau;
   xl=x; yl=y; zl=z;
 }
 return result;
}


void ReversePathDirection(object *op){
 double t;
 pathpoint *p,*pn,*lp,*fp;
 if(op == NULL)return;
 pn=op->firstpathpoint;
 if(pn == NULL)return;
 if(op->pathtype == OPEN){
   while(pn != NULL){
     p=pn;
     pn=p->next;
     p->next=p->last;
     p->last=pn;
     t=p->tension_n;
     p->tension_n=p->tension_p;
     p->tension_p=t;
   }
   op->firstpathpoint=p;
 }
 else{
   p=pn; fp=pn; while(p != NULL){lp=p; p=p->next;} pn=pn->next;
   while(pn != NULL){
     p=pn;
     pn=p->next;
     p->next=p->last;
     p->last=pn;
     t=p->tension_n;
     p->tension_n=p->tension_p;
     p->tension_p=t;
   }
   fp->next->next=NULL;
   fp->next=lp;
   lp->last=fp;
 }
 PathLength(op->firstpathpoint,op->pathtype,op->npathpoints);
}


double PathLength(pathpoint *Ppp, short type, short Npoints){
 pathpoint *tp,*fp,*fp1,*lp,*lp1;
 double length;
 point Vpp,Vpn,Vpnn;
 Ni=10; dtau=0.1; length = 0.0;
 fp=Ppp;
 if((tp=fp) != NULL){
   while(tp != NULL){lp=tp; tp=tp->next;}
   fp1=fp->next;
   lp1=lp->last;
   if(lp == NULL || fp1 == NULL || lp1 == NULL){
      SendPrgmQuery(IDQ_CATAF,0);
      exit(0);
   }
   if(type == OPEN){
     SubPoints(fp1->p,fp->p,Vpp);
     SubPoints(fp->p,Vpp,Vpp);
     SubPoints(lp->p,lp1->p,Vpnn);
     AddPoints(lp->p,Vpnn,Vpn);
   }
   tp=fp; while(tp != NULL){
     tp->distance=length;
     if(type == OPEN){
       if(tp == fp && fp1->next == NULL)
         length += SegmentLength(Vpp,fp->p,fp1->p,Vpn,
                                 fp->tension_n,fp1->tension_p);
       else if(tp == fp)
         length += SegmentLength(Vpp,fp->p,fp1->p,fp1->next->p,
                                 fp->tension_n,fp1->tension_p);
       else if(tp == lp1)
         length += SegmentLength(tp->last->p,tp->p,lp->p,Vpn,
                                 tp->tension_n,lp->tension_p);
       else if(tp == lp)
         ;/* no length calc necessary for last segment */
       else
         length += SegmentLength(tp->last->p,tp->p,
                                 tp->next->p,tp->next->next->p,
                                 tp->tension_n,tp->next->tension_p);
       }
     else{ /* closed path */
       if(tp == fp)
         length += SegmentLength(lp->p,fp->p,fp1->p,fp1->next->p,
                                 fp->tension_n,fp1->tension_p);
       else if(tp == lp1)
         length += SegmentLength(tp->last->p,tp->p,lp->p,fp->p,
                                 tp->tension_n,lp->tension_p);
       else if(tp == lp)
         length += SegmentLength(lp1->p,lp->p,fp->p,fp1->p,
                                 lp->tension_n,fp->tension_p);
       else
         length += SegmentLength(tp->last->p,tp->p,
                                 tp->next->p,tp->next->next->p,
                                 tp->tension_n,tp->next->tension_p);
     }
   tp=tp->next;}
 }
//if(debug != NULL)fprintf(debug,"path length %lf\n",length);
 return length;
}


#define TAUTOL 64.0
#define TAUITR 50
#define TAUN   10

void PathInterp(double pathposition, pathpoint *Lpp, /* new iterative method */
                pathpoint *Ppp, point ObjectOffset,  /* to try and smooth    */
                double distance, pathpoint *Fpp,     /* jumps in movement    */
                pathpoint *Epp, short type){
 long nc,j;
 double d,tau,taul,taur,taux,kx[4],ky[4],kz[4],x,y,z,xl,yl,zl;
 double gs,ge;
 pathpoint *p1,*p2,*p3,*p4;
 pathpoint Vpp,Vpn,Vpnn;
 p2=Lpp; p3=Ppp;                     /* measured from start of path */
 if(type == OPEN){
   SubPoints(Fpp->next->p,Fpp->p,Vpp.p);
   SubPoints(Fpp->p,Vpp.p,Vpp.p);
   SubPoints(Epp->p,Epp->last->p,Vpnn.p);
   AddPoints(Epp->p,Vpnn.p,Vpn.p);
   if     (Lpp == Fpp && Ppp->next == NULL){p1=&Vpp; p4=&Vpn;}
   else if(Lpp == Fpp)                     {p1=&Vpp; p4=Ppp->next;}
   else if(Lpp == Epp->last)               {p1=Lpp->last; p4=&Vpn;}
   else                                    {p1=Lpp->last; p4=Ppp->next;}
 }
 else{
   if     (Lpp == Fpp)      {p1=Epp; p4=Ppp->next;}
   else if(Lpp == Epp->last){p1=Lpp->last; p4=Fpp;}
   else                     {p1=Lpp->last; p4=Ppp->next;}
 }
 gs=(double)(p3->p[0]-p1->p[0])*p2->tension_n;
 ge=(double)(p4->p[0]-p2->p[0])*p3->tension_p;
 SplinesG(kx,p2->p[0],p3->p[0],gs,ge);
 gs=(double)(p3->p[1]-p1->p[1])*p2->tension_n;
 ge=(double)(p4->p[1]-p2->p[1])*p3->tension_p;
 SplinesG(ky,p2->p[1],p3->p[1],gs,ge);
 gs=(double)(p3->p[2]-p1->p[2])*p2->tension_n;
 ge=(double)(p4->p[2]-p2->p[2])*p3->tension_p;
 SplinesG(kz,p2->p[2],p3->p[2],gs,ge);
// SplinesK(kx,p1->p[0],p2->p[0],p3->p[0],p4->p[0]);
// SplinesK(ky,p1->p[1],p2->p[1],p3->p[1],p4->p[1]);
// SplinesK(kz,p1->p[2],p2->p[2],p3->p[2],p4->p[2]);
 taul=0.0; taur=1.0; nc=0;
 tau=pathposition  - Lpp->distance;  /* Lpp is start of segment     */
 tau /= (distance  - Lpp->distance); /* distance is end of segment  */
//if(debug != NULL)fprintf(debug,"%ld t=%.3lf  d=%.1lf Lpp=%.1lf",CurrentFrame,tau,
//pathposition,Lpp->distance);
 for(;;){
   dtau=tau/TAUN; d=Lpp->distance; taux=dtau;
   xl=Lpp->p[0]; yl=Lpp->p[1]; zl=Lpp->p[2];
   for(j=0;j<TAUN;j++){
     x = SplinesP(kx,taux);
     y = SplinesP(ky,taux);
     z = SplinesP(kz,taux);
     d += sqrt((double)(x-xl)*(double)(x-xl)
              +(double)(y-yl)*(double)(y-yl)
              +(double)(z-zl)*(double)(z-zl) );
     taux += dtau;
     xl=x; yl=y; zl=z;
   }
//if(nc == 0)dotau=d;
   if(fabs(d-pathposition) < TAUTOL)break;
   if(++nc > TAUITR)break;
   if(d < pathposition)taul=tau;
   else                taur=tau;
   tau=0.5*(taul+taur);
 }
//if(debug != NULL)fprintf(debug," it=%ld nt=%.3lf nd=%.1lf od=%.1lf\n",nc,tau,d,dotau);
 ObjectOffset[0] = SplinesP(kx,tau);
 ObjectOffset[1] = SplinesP(ky,tau);
 ObjectOffset[2] = SplinesP(kz,tau);
}

void GetPathPositionAtDistance(node *Np, object *Op, double d, point pout){
 // used by robot position to determine the location of a point on a path
 // we will need to take into accout any position of the path with a position Pp 
 pathpoint *Ppp;
 short Npoints,type;
 pathpoint *tp,*fp,*fp1,*lp,*lp1;
 double length,dd;
 vector pos;
 point Vpp,Vpn,Vpnn;
 Ppp=Op->firstpathpoint;
 type=Op->pathtype;
 Npoints=Op->npathpoints;

 Ni=200; dtau=0.005; length = 0.0;
 fp=Ppp;
 if((tp=fp) != NULL){
   while(tp != NULL){
     lp=tp; tp=tp->next;
   }
   fp1=fp->next;
   lp1=lp->last;
   if(lp == NULL || fp1 == NULL || lp1 == NULL){
      SendPrgmQuery(IDQ_CATAF,0);
      exit(0);
   }
   if(type == OPEN){
     SubPoints(fp1->p,fp->p,Vpp);
     SubPoints(fp->p,Vpp,Vpp);
     SubPoints(lp->p,lp1->p,Vpnn);
     AddPoints(lp->p,Vpnn,Vpn);
   }
   tp=fp; while(tp != NULL){
     if(type == OPEN){
       if(tp == fp && fp1->next == NULL){
         dd = GetSegmentPositionForLength(Vpp,fp->p,fp1->p,Vpn,
                                 fp->tension_n,fp1->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else if(tp == fp){
         dd = GetSegmentPositionForLength(Vpp,fp->p,fp1->p,fp1->next->p,
                                 fp->tension_n,fp1->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else if(tp == lp1){
         dd = GetSegmentPositionForLength(tp->last->p,tp->p,lp->p,Vpn,
                                 tp->tension_n,lp->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else if(tp == lp)
         ;/* no length calc necessary for last segment */
       else {
         dd = GetSegmentPositionForLength(tp->last->p,tp->p,
                                 tp->next->p,tp->next->next->p,
                                 tp->tension_n,tp->next->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
     }
     else{ /* closed path */
       if(tp == fp){
         dd = GetSegmentPositionForLength(lp->p,fp->p,fp1->p,fp1->next->p,
                                 fp->tension_n,fp1->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else if(tp == lp1){
         dd = GetSegmentPositionForLength(tp->last->p,tp->p,lp->p,fp->p,
                                 tp->tension_n,lp->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else if(tp == lp){
         dd = GetSegmentPositionForLength(lp1->p,lp->p,fp->p,fp1->p,
                                 lp->tension_n,fp->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
       else {
         dd = GetSegmentPositionForLength(tp->last->p,tp->p,
                                 tp->next->p,tp->next->next->p,
                                 tp->tension_n,tp->next->tension_p,d-length,pos);
         if(dd < 0.0)goto GOTIT;
         else length += dd;
       }
     }
     tp=tp->next;
   }
   // get to this point we are beyond the end of the path
   VECCOPY(lp->p,pout)
   return;
   GOTIT:
   VECCOPY((long)pos,pout)
   return;
 }
 pout[0]=pout[1]=pout[2]=0;
}

object *GetPathPosition(node *Np, long frame, double dframe,
                        point ObjectOffset,
                        double *position0_1, double *lengthonpath){
 object    *Op; /* Np is pointer to Path type object Op will be current path*/
 pathpoint *Ppp,*Lpp,*Fpp,*Epp;
 double pathposition;
 if((Op=Np->fobj) != NULL && Op->type == PATH)while(Op != NULL){
   if(frame >= Op->firstframe && frame <= Op->lastframe){
     if((Ppp=Op->firstpathpoint) == NULL)return NULL;
     if(Op->firstframe == Op->lastframe){ /* only 1 frame for path */
       CopyPoint(Op->firstpathpoint->p,ObjectOffset);
     }
     else{ /* get (0-1)position parameter */
       if(*position0_1 < 0.0){  /* get path posn from path look up table */
         if(Op->v != NULL){
           long ip;
           ip=frame - Op->firstframe;
           if(ip > 0){       // use dframe as fraction (dframe default is 1.0
             *position0_1=(Op->v[ip])*dframe+(Op->v[ip-1])*(1.0-dframe);
           }
           else *position0_1=(Op->v[ip]);
         }
         else  *position0_1=0.0;
       }
       pathposition = *position0_1 * Op->pathlength; /* scale to length */
       if(pathposition == 0.0){
         CopyPoint(Op->firstpathpoint->p,ObjectOffset);
       }
       else{
         Fpp=Epp=Lpp=Ppp;
         while(Lpp != NULL){Epp=Lpp; Lpp=Lpp->next;}
         Lpp=Ppp; Ppp=Ppp->next;     /* always at least 2 points in path */
         while(Ppp != NULL && pathposition >= Ppp->distance){
               Lpp=Ppp; Ppp=Ppp->next;}
         if(Ppp == NULL){  /* after last pathpoint  Lpp points to last point*/
           if(Op->pathtype == CLOSED)
             PathInterp(pathposition,Lpp,Op->firstpathpoint,ObjectOffset
                      ,Op->pathlength,Fpp,Epp,Op->pathtype);
           else
             CopyPoint(Lpp->p,ObjectOffset);
         }
         else{
           PathInterp(pathposition,Lpp,Ppp,ObjectOffset
                    ,Ppp->distance,Fpp,Epp,Op->pathtype);
         }
       }
/*     rotational transform is not allowed for paths if it is in future  */
/*     do it here                                                        */
     }
     *lengthonpath=pathposition;
     return Op;
   }
   Op=Op->next;
 }
 return NULL; /* no path at this frame to follow etc */
}

double *ReTweenVelocity(object *op, double *v,
                        int oldn, int newn,
                        double pathlength,
                        int copy){
 double *nv,Xscale,error,ds;
 short i,j,lf,lc;
 PATHEDITCONTROL *pe,*pe1;
 if(v != NULL && oldn == newn && copy == 0)return v;/* no changes necessary */
 if( (nv=(double *)X__Malloc(sizeof(double)*newn) ) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return NULL;
 }
 if((pe=op->pec) != NULL)while(pe != NULL){
    pe1=pe;
    pe=pe->next;
    X__Free(pe1);
 }
 op->pec=NULL; op->npec=0;
 if(v == NULL){/* allocate a new velocity(distance) profile */
   ds=1.0/(double)newn;
   for(i=0;i<newn;i++)nv[i]=ds*i;
 }
 else if(newn == oldn){
   for(i=0;i<newn;i++)nv[i]=v[i];
   if(copy == 0)X__Free(v);   /* if not copying then X__Free old memory */
 }
 else{
   if(oldn < 0){ /* old n not available - just reset */
     ds=1.0/(double)newn;
     for(i=0;i<newn;i++)nv[i]=ds*i;
   }
   else if(oldn <= 1){
     Xscale=1.0/newn;
     for(i=0;i<newn;i++){ /* interpolate onto new path position array */
       nv[i]=(double)i*Xscale;
     }
   }
   else{
     Xscale=(double)(oldn-1)/(double)(newn-1);
     for(i=0;i<newn;i++){ /* interpolate onto new path position array */
       j=floor(Xscale*i);
       error=Xscale*i - j;
       if(error < 0.001 || j == oldn-1)nv[i] = v[j];
       else                            nv[i] = (v[j+1]-v[j])*error+v[j];
     }
   }
   if(copy == 0)X__Free(v);
 }
 return nv;
}

#define XFROMFRAME(f) ((int)(                                             \
   (double)(f-SelectedPath->firstframe)*(double)(CurveRect.right-1)/      \
   (double)(SelectedPath->lastframe-SelectedPath->firstframe)             \
                            ))
#define YFROMDIST(d) (CurveRect.bottom-1-(int)(                           \
   d*(double)(CurveRect.bottom-1)/1.0                                     \
                            ))
#define FRAMEFROMX(x) ((int)(                                             \
   (double)SelectedPath->firstframe+(double)x*                            \
   (double)(SelectedPath->lastframe-SelectedPath->firstframe)/            \
   (double)(CurveRect.right-1)                                            \
                             ))
#define DISTFROMY(y) ((double)(                                           \
   (double)(CurveRect.bottom-1-y)/                                        \
   (double)(CurveRect.bottom-1)                                           \
                             ))
#define TOLL (CurveRect.right/30)

static HWND hPathEditorFrameID,hPathEditorDistanceID;
static RECT CurveRect;
static BOOL RingScale=FALSE;
static int nPec=0;
static PATHEDITCONTROL *Pec=NULL;

static BOOL CALLBACK PathPositionEditorDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 static HWND hWndStatus;
 static int cx,cy,ox,oy;
 HWND hctl;
 int tx,ty;
 RECT wRect;
 LPRECT lpRect;
 PATHEDITCONTROL *pe;
 switch( msg ) {
   case WM_INITDIALOG:
     SetClassLong(hwnd,GCL_HICON,
                 (LONG)LoadIcon(ghinst_main,"ANIMATORICON"));
     hPathEditorFrameID=GetDlgItem(hwnd,DLG_PATHEDITOR_FRAME);
     hPathEditorDistanceID=GetDlgItem(hwnd,DLG_PATHEDITOR_DISTANCE);
     pe=Pec; while(pe != NULL){
       pe->x=XFROMFRAME(pe->frame);
       pe->y=YFROMDIST(pe->distance);
       pe=pe->next;
     }
     if(RingScale)SendDlgItemMessage(hwnd,DLG_PATHEDITOR_LOOP,BM_SETCHECK,TRUE,0);
     SetDlgItemInt(hwnd,DLG_PATHEDITOR_FRAME1,SelectedPath->firstframe,TRUE);
     SetDlgItemInt(hwnd,DLG_PATHEDITOR_FRAMEN,SelectedPath->lastframe,TRUE);
     hWndStatus=CreateWindowEx(0L,STATUSCLASSNAME,"",
                WS_CHILD | !WS_BORDER | WS_VISIBLE,
                0,0,0,0,
                hwnd,
                (HMENU)NULL,
                (HINSTANCE)NULL,
                NULL);
     SendMessage(hWndStatus,SB_SETTEXT,(WPARAM)SBT_NOBORDERS,(LPARAM)NULL);
//     CentreDialogOnScreen(hwnd);
     GetWindowRect(hwnd,&wRect);
     ox=wRect.right-wRect.left;
     oy=wRect.bottom-wRect.top;
     GetClientRect(hwnd,&wRect);
     cx=wRect.right;
     cy=wRect.bottom;
     PostMessage(hwnd,(WM_USER+100),0,0);
     return (TRUE);
   case (WM_USER+100):{
       int xp,yp,xl,yl;
       xp=GetPrivateProfileInt(IniSection,"PEPOSX",-1,IniFilename);
       yp=GetPrivateProfileInt(IniSection,"PEPOSY",-1,IniFilename);
       xl=GetPrivateProfileInt(IniSection,"PESIZX",-1,IniFilename);
       yl=GetPrivateProfileInt(IniSection,"PESIZY",-1,IniFilename);
       if(xp < 0 || yp < 0 || xl < 0 || yl < 0)CentreDialogOnScreen(hwnd);
       else     SetWindowPos(hwnd,NULL,xp,yp,xl,yl,SWP_NOZORDER);
       ShowWindow(hwnd,SW_SHOW);
     }
     break;
   case WM_DESTROY:{
       RECT rc; char str[32];
       GetWindowRect(hwnd,&rc);
       sprintf(str,"%ld",rc.left);
       WritePrivateProfileString(IniSection,"PEPOSX",str,IniFilename);
       sprintf(str,"%ld",rc.top);
       WritePrivateProfileString(IniSection,"PEPOSY",str,IniFilename);
       sprintf(str,"%ld",rc.right-rc.left);
       WritePrivateProfileString(IniSection,"PESIZX",str,IniFilename);
       sprintf(str,"%ld",rc.bottom-rc.top);
       WritePrivateProfileString(IniSection,"PESIZY",str,IniFilename);
     }
     break;
   case WM_MOUSEMOVE:
     SendMessage(hPathEditorFrameID,WM_SETTEXT,0,(LPARAM)" ");
     SendMessage(hPathEditorDistanceID,WM_SETTEXT,0,(LPARAM)" ");
     break;
   case WM_SIZING:
     lpRect=(LPRECT)lparam;
     if((lpRect->right - lpRect->left) < ox)
       lpRect->right = lpRect->left+ox;
     if((lpRect->bottom - lpRect->top) < oy)
       lpRect->bottom = lpRect->top+oy;
     return TRUE;
     break;
   case WM_SIZE:
     SendMessage(hWndStatus,WM_SIZE,wparam,lparam);
     tx=LOWORD(lparam); ty=HIWORD(lparam);
     MoveCtrlWindow(hwnd,IDCANCEL,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,IDOK,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAME,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_DISTANCE,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_DISTANCETEXT,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAMETEXT,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_HELPTEXT,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_LOOP,tx,ty,cx,cy,1);

     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_STARTTEXT,tx,ty,cx,cy,2);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAMESTEXT,tx,ty,cx,cy,2);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAME1,tx,ty,cx,cy,2);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAMEN,tx,ty,cx,cy,1);
     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_FRAMEN,tx,ty,cx,cy,2);

     MoveCtrlWindow(hwnd,DLG_PATHEDITOR_EDITWINDOW,tx,ty,cx,cy,0);
     GetClientRect(GetDlgItem(hwnd,DLG_PATHEDITOR_EDITWINDOW),&CurveRect);
     pe=Pec; while(pe != NULL){
       pe->x=XFROMFRAME(pe->frame);
       pe->y=YFROMDIST(pe->distance);
       pe=pe->next;
     }

     InvalidateRect(hwnd,NULL,TRUE);
     cx=tx; cy=ty;
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
       case DLG_PATHEDITOR_LOOP:
         RingScale = !RingScale;
         break;
       case IDCANCEL:
         EndDialog(hwnd, FAIL);
         return(TRUE);
       case IDOK:
         EndDialog(hwnd,OK);
         return(TRUE);
       default:
         break;
     }
     break;
   default: break;
 }
 return(FALSE);
}

static LRESULT CALLBACK PathEditorWndFn(HWND hWnd,UINT uMsg,WPARAM wParam,
                                                            LPARAM lParam){
 HDC hDC;
 RECT rc;
 PAINTSTRUCT ps;
 short x,y;
 int f;
 static int xl,xr;
 double d;
 char temp[64];
 BOOL bOutside;
 PATHEDITCONTROL *pf,*pl,*p;
 static PATHEDITCONTROL *pe;
 static BOOL bCaptured=FALSE,bDeleted=FALSE;
 switch (uMsg) {
   case WM_CREATE:
     pe=NULL;
     GetClientRect(hWnd,&CurveRect);
     break;
   case WM_PAINT:
     hDC = BeginPaint(hWnd,&ps);
     Rectangle(hDC,CurveRect.left,CurveRect.top
                  ,CurveRect.right,CurveRect.bottom);
     DrawPathCurve(hDC);
     EndPaint(hWnd, &ps);
     break;
   case WM_LBUTTONDOWN:
     x=(short)LOWORD(lParam); y=(short)HIWORD(lParam);
     x=max(0,min(CurveRect.right-1,x));
     y=max(0,min(CurveRect.bottom-1,y));
     f=FRAMEFROMX(x);
     d=DISTFROMY(y);
     sprintf(temp,"%ld",f);
     SendMessage(hPathEditorFrameID,WM_SETTEXT,0,(LPARAM)temp);
     sprintf(temp,"%ld",(int)(d*100.0+0.0001));
     SendMessage(hPathEditorDistanceID,WM_SETTEXT,0,(LPARAM)temp);
     SetCapture(hWnd);
     pe=GetPathEditPoint((int)x,(int)y);
     if(pe != NULL){
       if(pe->last != NULL)x=max(pe->last->x+TOLL,x);
       if(pe->next != NULL)x=min(pe->next->x-TOLL,x);
       pe->x=x; pe->y=y;
     }
     InvalidateRect(hWnd,NULL,FALSE);
     bCaptured=TRUE;
     bDeleted=FALSE;
     break;
   case WM_LBUTTONUP:
     if(pe != NULL){
       pe->frame=FRAMEFROMX(pe->x);
       pe->distance=DISTFROMY(pe->y);
     }
     pe=NULL;
     ReleaseCapture();
     bCaptured=FALSE;
     bDeleted=FALSE;
     break;
   case WM_MOUSEMOVE:
     x=(short)LOWORD(lParam); y=(short)HIWORD(lParam);
     if(x < 0 || x > CurveRect.right-1 ||
        y < 0 || y > CurveRect.bottom-1)bOutside=TRUE;
     else bOutside=FALSE;
     x=max(0,min(CurveRect.right-1,x));
     y=max(0,min(CurveRect.bottom-1,y));
     f=FRAMEFROMX(x);
     d=DISTFROMY(y);
     sprintf(temp,"%ld",f);
     SendMessage(hPathEditorFrameID,WM_SETTEXT,0,(LPARAM)temp);
     sprintf(temp,"%ld",(int)(d*100.0+0.0001));
     SendMessage(hPathEditorDistanceID,WM_SETTEXT,0,(LPARAM)temp);
     if(bCaptured){
       if(pe != NULL){
         pf=p=Pec; while(p != NULL){pl=p; p=p->next;}
         if(pf == NULL || pl == NULL)break;
         if(pe == pf || pe == pl){
           if(pe->last != NULL)x=max(pe->last->x+TOLL,x);
           if(pe->next != NULL)x=min(pe->next->x-TOLL,x);
           pe->x=x; pe->y=y;
         }
         else{
           if(pe->last == NULL || pe->next == NULL)break; /* should not happen */
           d=abs(pe->x - pe->last->x);
           if(d < abs(pe->x - pe->next->x))p=pe->last;
           else                            p=pe->next;
           if(pe->x <= pe->last->x || pe->x >= pe->next->x)bOutside=TRUE;
           if(abs(p->x - pe->x) < TOLL || bOutside){
             xl=pe->last->x + TOLL; xr=pe->next->x - TOLL;
             bDeleted=TRUE;
             DeletePathEditControlPoint(&nPec,&Pec,pe);
             pe=NULL;
           }
           else{
             pe->x=x; pe->y=y;
           }
         }
         InvalidateRect(hWnd,NULL,FALSE);
       }
       else if(bDeleted){
         if(x > xl && x < xr && !bOutside){
           pe=GetPathEditPoint((int)x,(int)y);
           if(pe != NULL){
             if(pe->last != NULL)x=max(pe->last->x+TOLL,x);
             if(pe->next != NULL)x=min(pe->next->x-TOLL,x);
            pe->x=x; pe->y=y;
           }
           bDeleted=FALSE;
           InvalidateRect(hWnd,NULL,FALSE);
         }
       }
     }
     break;
   default:
     return(DefWindowProc(hWnd,uMsg,wParam,lParam));
 }
 return( 0L );
}

void EditPathMovement(short type){
 long Npp;
 object *Op;
 char _szControlName[] = "OFX:PATHEDITORCLASS";
 PATHEDITCONTROL *pe,*pe1;
 WNDCLASS wc;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOACTORSELECTED,0);
   return;
 }
 if(tool != NOTOOL){
   SendPrgmQuery(IDQ_NOT_IN_TOOL,0);
   return;
 }
 if(SelectedNode->type != PATH){
   SendPrgmQuery(IDQ_NOPATH,0);
   return;
 }
 EDIT_ACTION=YES;
 Op=SelectedNode->fobj;
 while(Op != NULL){
   if(CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe){
     SelectedPath=Op;
     goto GOTIT;
   }
   Op=Op->next;
 }
 SendPrgmQuery(IDQ_NOPATH,0);
 return;
 GOTIT:
 Npp=SelectedPath->lastframe - SelectedPath->firstframe + 1;
 if(Npp < 5){
   SendPrgmQuery(IDQ_PATH2,0);
   SelectedPath=NULL;
   return;
 }
 wc.style         = CS_HREDRAW | CS_VREDRAW;
 wc.lpfnWndProc   = (WNDPROC)PathEditorWndFn;
 wc.cbClsExtra    = 0;
 wc.cbWndExtra    = 0;
 wc.hInstance     = ghinst_main;
 wc.hIcon         = (HICON) NULL;
 wc.hCursor       = ghcurX;
 wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 wc.lpszMenuName  = NULL;
 wc.lpszClassName = _szControlName;
 CurveRect.top=CurveRect.bottom=CurveRect.left=CurveRect.right=0;
 if(!RegisterClass(&wc)){
   SendPrgmQuery(IDQ_NOPATH,0);
   return;
 }
 nPec=0;
 Pec=NULL;
 if(SelectedPath->pathtype == CLOSED)RingScale=TRUE;
 else                                RingScale=FALSE;
 if(SelectedPath->pec != NULL && SelectedPath->npec > 0){
   pe1=NULL; pe=SelectedPath->pec; while(pe != NULL){
     pe1=CreatePathEditControlPoint(&nPec,&Pec,pe1,NULL,pe->frame,pe->distance);
     if(Pec == NULL){ SendPrgmQuery(IDQ_NOMEM1,0); return; }
     pe=pe->next;
   }
 }
 else {
   CreatePathEditControlPoint(&nPec,&Pec,NULL,NULL,
                              (int)SelectedPath->firstframe,0.0);
   if(Pec == NULL){ SendPrgmQuery(IDQ_NOMEM1,0); return; }
   CreatePathEditControlPoint(&nPec,&Pec,Pec,NULL,
                               (int)SelectedPath->lastframe,1.0);
   if(Pec == NULL){ SendPrgmQuery(IDQ_NOMEM1,0); return; }
 }
 EnableToolPannels(ALL_PANNELS,FALSE);
 if(DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_PATHEDITOR),ghwnd_main,
                (DLGPROC)PathPositionEditorDlgProc) == OK){
   if((pe=SelectedPath->pec) != NULL)while(pe != NULL){
     pe1=pe; pe=pe->next; X__Free(pe1);
   }
   SelectedPath->pec=NULL; SelectedPath->npec=0;
   pe1=NULL; if((pe=Pec) != NULL)while(pe != NULL){
     pe1=CreatePathEditControlPoint(&(SelectedPath->npec),
                                &(SelectedPath->pec),
                                pe1,NULL,pe->frame,pe->distance);
     if(SelectedPath->pec == NULL){
       SendPrgmQuery(IDQ_NOMEM1,0);
       return;
     }
     pe=pe->next;
   }
   CalculatePathPositions(SelectedPath);
 }
 EnableToolPannels(ALL_PANNELS,TRUE);
 if((pe=Pec) != NULL)while(pe != NULL){
     pe1=pe; pe=pe->next; X__Free(pe1);
 }
 UnregisterClass(_szControlName,ghinst_main);
 return;
}

static PATHEDITCONTROL *GetPathEditPoint(int x, int y){
 int d;
 PATHEDITCONTROL *pe,*pf,*pl;
 pf=pl=NULL;
 pf=pe=Pec; while(pe != NULL){pl=pe; pe=pe->next;}
 if(pf == NULL || pl == NULL)return NULL;
 if(x < pf->x + TOLL){
   if(pf->next != NULL){
     d=abs(x - pf->x);
     if(abs(x - pf->next->x) < d)return pf->next;
     else return pf;
   }
   return pf;
 }
 if(x > pl->x - TOLL){
  if(pl->last != NULL){
    d=abs(x - pl->x);
     if(abs(x - pl->last->x) < d)return pl->last;
     else return pl;
   }
   return pl;
 }
 pf=NULL; d=10000;
 pe=Pec; while(pe != NULL){
   if(x > pe->x - TOLL && x < pe->x + TOLL){
     if(abs(x - pe->x) < d){
       d=abs(x - pe->x);
       pf=pe;
     }
   }
   pe=pe->next;
 }
 if(pf != NULL)return pf;
 pe=Pec; while(pe != NULL){
   if(pe->next != NULL){
     if(x > pe->x && x < pe->next->x){
       return CreatePathEditControlPoint(&nPec,&Pec,pe,pe->next,0,0.0);
     }
   }
   pe=pe->next;
 }
 return NULL;
}

static void DrawLagrangePathCurve(HDC hDC){ /* one Lagrangian */
 int i,j;
 HBRUSH holdBrush;
 PATHEDITCONTROL *pe,*pf,*pl,*p,*p1,*p2;
 double x,y;
 holdBrush=SelectObject(hDC,GetStockObject(BLACK_BRUSH));
 p=pf=pe=Pec; while(pe != NULL){pl=pe; pe=pe->next;}
 if(pf->x > 0){
   MoveToEx(hDC,0,pf->y,NULL); LineTo(hDC,pf->x,pf->y);
 }
 for(i=pf->x;i<=pl->x;i++){
   if(p != NULL && p->x == i){
     Rectangle(hDC,min(p->x-2,CurveRect.right-4),
                   min(p->y-2,CurveRect.bottom-4),
                   max(p->x+2,4),
                   max(p->y+2,4));
     p=p->next;
   }
   y=0.0;
   p1=Pec; while(p1 != NULL){
     x=1.0;
     p2=Pec; while (p2 != NULL){
       if(p2 != p1){
         x *= (double)(i - p2->x)/(double)(p1->x - p2->x);
       }
       p2=p2->next;
     }
     y +=  x*(double)p1->y;
     p1=p1->next;
   }
   j=(int)y;
   if(j < 1)j=1; if(j >= CurveRect.bottom-1)j=CurveRect.bottom-2;
   SetPixel(hDC,i,j,RGB(0,0,0));
 }
 if(pl->x < CurveRect.right-1){
   MoveToEx(hDC,pl->x,pl->y,NULL); LineTo(hDC,CurveRect.right-1,pl->y);
 }
 SelectObject(hDC,holdBrush);
}

static void DrawPathCurve(HDC hDC){  /* spline */
 int i,j;
 HBRUSH holdBrush;
 PATHEDITCONTROL *pe,*pf,*pl;
 double x,y,a,b,c,d,h1,h2,ratio;
 if(nPec < 4){
   DrawLagrangePathCurve(hDC);
   return;
 }
 holdBrush=SelectObject(hDC,GetStockObject(BLACK_BRUSH));
 pf=pe=Pec; while(pe != NULL){pl=pe; pe=pe->next;}
 pe=pf; while(pe != NULL){
   pe->a=pe->b=pe->c=pe->S=pe->r=0.0;
   pe=pe->next;
 }
 pe=pf->next; while(pe != pl){
   h1=(double)(pe->x - pe->last->x);
   h2=(double)(pe->next->x - pe->x);
   pe->a=h1; pe->b=2.0*(h1+h2); pe->c=h2;
   pe->r=(double)(pe->next->y - pe->y)/h2
        -(double)(pe->y - pe->last->y)/h1;
   pe->r *= 6.0;
   pe=pe->next;
 }
 pf->next->a=0.0; pl->last->c=0.0;
 pe=pf->next->next; while(pe != pl){
   ratio = pe->a/pe->last->b;
   pe->b = pe->b - pe->last->c * ratio;
   pe->r = pe->r - pe->last->r * ratio;
   pe=pe->next;
 }
 pl->last->S=pl->last->r/pl->last->b;
 pe=pl->last->last; while(pe != pf){
   pe->S=(pe->r - pe->next->S * pe->c)/pe->b;
   pe=pe->last;
 }
 pe=Pec; while(pe != NULL){
   if(pe->last == NULL && pe->x > 0){
     MoveToEx(hDC,0,pe->y,NULL); LineTo(hDC,pe->x,pe->y);
   }
   Rectangle(hDC,min(pe->x-2,CurveRect.right-4),
                 min(pe->y-2,CurveRect.bottom-4),
                 max(pe->x+2,4),
                 max(pe->y+2,4));
   if(pe->next != NULL){
     h1=(double)(pe->next->x - pe->x);
     a=(pe->next->S - pe->S)/6.0/h1;
     b=pe->S/2.0;
     c=(double)(pe->next->y - pe->y)/h1 - (2.0*pe->S + pe->next->S)*h1/6.0;
     d=(double)pe->y;
     for(i=pe->x; i<pe->next->x;i++){
       x=(double)(i - pe->x) + 0.5;
       y=(x*(x*(x*a+b)+c))+d;
       j=(int)y;
       if(j < 1)j=1; if(j >= CurveRect.bottom-1)j=CurveRect.bottom-2;
       SetPixel(hDC,i,j,RGB(0,0,0));
     }
   }
   pe=pe->next;
 }
 if(pl->x < CurveRect.right-1){
   MoveToEx(hDC,pl->x,pl->y,NULL); LineTo(hDC,CurveRect.right-1,pl->y);
 }
 SelectObject(hDC,holdBrush);
}

static void CalculatePathPositions(object *op){
 int i,j;
 PATHEDITCONTROL *pe,*pf,*pl;
 double x,y,a,b,c,d,h1,h2,ratio;
 if(nPec < 4){
   PATHEDITCONTROL *p1,*p2;
   pf=pe=Pec; while(pe != NULL){pl=pe; pe=pe->next;}
   if(pf->frame > op->firstframe){
     for(i=op->firstframe;i<pf->frame;i++){
       op->v[i - op->firstframe]=pf->distance;
     }
   }
   for(i=pf->frame;i<=pl->frame;i++){
     y=0.0;
     p1=Pec; while(p1 != NULL){
       x=1.0;
       p2=Pec; while (p2 != NULL){
         if(p2 != p1){
           x *= (double)(i - p2->frame)/(double)(p1->frame - p2->frame);
         }
         p2=p2->next;
       }
       y +=  x*(double)p1->distance;
       p1=p1->next;
     }
     y=min(1.0,max(0.0,y));
     op->v[i - op->firstframe]=y;
   }
   if(pl->frame < op->lastframe){
     for(i=pl->frame;i<=op->lastframe;i++){
       op->v[i - op->firstframe]=pl->distance;
     }
   }
   goto XXIT;
 }
 pf=pe=Pec; while(pe != NULL){pl=pe; pe=pe->next;}
 pe=pf; while(pe != NULL){
   pe->a=pe->b=pe->c=pe->S=pe->r=0.0;
   pe=pe->next;
 }
 pe=pf->next; while(pe != pl){
   h1=(double)(pe->frame - pe->last->frame);
   h2=(double)(pe->next->frame - pe->frame);
   pe->a=h1; pe->b=2.0*(h1+h2); pe->c=h2;
   pe->r=(double)(pe->next->distance - pe->distance)/h2
        -(double)(pe->distance - pe->last->distance)/h1;
   pe->r *= 6.0;
   pe=pe->next;
 }
 pf->next->a=0.0; pl->last->c=0.0;
 pe=pf->next->next; while(pe != pl){
   ratio = pe->a/pe->last->b;
   pe->b = pe->b - pe->last->c * ratio;
   pe->r = pe->r - pe->last->r * ratio;
   pe=pe->next;
 }
 pl->last->S=pl->last->r/pl->last->b;
 pe=pl->last->last; while(pe != pf){
   pe->S=(pe->r - pe->next->S * pe->c)/pe->b;
   pe=pe->last;
 }
 pe=Pec; while(pe != NULL){
   if(pe->last == NULL && pe->frame > op->firstframe){
     for(i=op->firstframe;i<pe->frame;i++){
       op->v[i - op->firstframe]=pe->distance;
     }
   }
   if(pe->next != NULL){
     h1=(double)(pe->next->frame - pe->frame);
     a=(pe->next->S - pe->S)/6.0/h1;
     b=pe->S/2.0;
     c=(double)(pe->next->distance - pe->distance)/h1
             - (2.0*pe->S + pe->next->S)*h1/6.0;
     d=(double)pe->distance;
     for(i=pe->frame; i < pe->next->frame; i++){
       x=(double)(i - pe->frame) + 0.5;
       y=(x*(x*(x*a+b)+c))+d;
       y=min(1.0,max(0.0,y));
       op->v[i - op->firstframe]=y;
     }
   }
   if(pe->next == NULL && pl->frame <= op->lastframe){
     for(i=pl->frame;i<=op->lastframe;i++){
       op->v[i - op->firstframe]=pl->distance;
     }
   }
   pe=pe->next;
 }
 XXIT:
 if(RingScale){ /* so loop is completed */
   j=op->lastframe - op->firstframe + 1;
   ratio = (double)j/(double)(j+1);
   for(i=0;i<j;i++){
     op->v[i] *= ratio;
   }
 }
 return;
}






#if 0
static void DrawPathCurve(HDC hDC){  /* pieces */
 int i,j,dx;
 HBRUSH holdBrush;
 PATHEDITCONTROL *pe;
 double a,b,c;
 holdBrush=SelectObject(hDC,GetStockObject(BLACK_BRUSH));
 pe=Pec; while(pe != NULL){
   if(pe->last == NULL && pe->x > 0){
     MoveToEx(hDC,0,pe->y,NULL); LineTo(hDC,pe->x,pe->y);
   }
   Rectangle(hDC,pe->x-2,pe->y-2,pe->x+2,pe->y+2);
   MoveToEx(hDC,pe->x,pe->y,NULL);
   if(pe->next == NULL){
     LineTo(hDC,CurveRect.right-1,pe->y);
   }
   else{
     if(pe->last == NULL && pe->next->next == NULL){
       LineTo(hDC,pe->next->x,pe->next->y);
     }
     else{
       for(i=pe->x;i<pe->next->x;i++){
         j=(int)GetYpathCoord(i,pe);
         SetPixel(hDC,i,j,RGB(0,0,0));
       }
     }
   }
   pe=pe->next;
 }
 SelectObject(hDC,holdBrush);
}
int GetYpathCoord(int ix, PATHEDITCONTROL *pe){
 int iy;
 double x,y,x1,x2,x3,x4,y1,y2,y3,y4;
 x=(double)ix;
 if(pe->next == NULL)return 0;
 if(pe->last == NULL){
   x1=(double)pe->x;              y1=(double)pe->y;
   x2=(double)pe->next->x;        y2=(double)pe->next->y;
   x3=(double)pe->next->next->x;  y3=(double)pe->next->next->y;
   y=(x-x2)*(x-x3)*y1/((x1-x2)*(x1-x3))+
     (x-x3)*(x-x1)*y2/((x2-x1)*(x2-x3))+
     (x-x1)*(x-x2)*y3/((x3-x1)*(x3-x2));
 }
 else if(pe->next->next == NULL){
   x1=(double)pe->last->x;        y1=(double)pe->last->y;
   x2=(double)pe->x;              y2=(double)pe->y;
   x3=(double)pe->next->x;        y3=(double)pe->next->y;
   y=(x-x2)*(x-x3)*y1/((x1-x2)*(x1-x3))+
     (x-x3)*(x-x1)*y2/((x2-x1)*(x2-x3))+
     (x-x1)*(x-x2)*y3/((x3-x1)*(x3-x2));
 }
 else{
   x1=(double)pe->last->x;        y1=(double)pe->last->y;
   x2=(double)pe->x;              y2=(double)pe->y;
   x3=(double)pe->next->x;        y3=(double)pe->next->y;
   x4=(double)pe->next->next->x;  y4=(double)pe->next->next->y;
   y=(x-x2)*(x-x3)*(x-x4)*y1/((x1-x2)*(x1-x3)*(x1-x4))+
     (x-x3)*(x-x4)*(x-x1)*y2/((x2-x1)*(x2-x3)*(x2-x4))+
     (x-x4)*(x-x1)*(x-x2)*y3/((x3-x1)*(x3-x2)*(x3-x4))+
     (x-x1)*(x-x2)*(x-x3)*y4/((x4-x1)*(x4-x2)*(x4-x3));
 }
 iy=(int)y;
 if(iy < 1)iy=1; if(iy >= CurveRect.bottom-1)iy=CurveRect.bottom-2;
 return iy;
}
#endif