TOOLS3.C

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */


/* file TOOLS3.C  designer's 3rd tools file */

#define MODULE_TOOLS3 1

#include "design.h"


void ShatterEffect(void){
 face *fp;
 FILE *tf;
 vertex *vp1,*vp2,*vp3;
 long count,i,k,v1,v2,v3;
 char workfile[64];
 char t1[64],t2[64];
 Save_Undo(2);
 if(NvertSelect == 0 || MainFp == NULL){
   SendPrgmQuery(IDQ_NOSHATTER,0);
   return;
 }
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 LoadString(ghinst_main,IDX_MISC_CONFIRM,t1,63);
 LoadString(ghinst_main,IDS_DEFAULT,t2,63);
 if(MessageBox(NULL,t1,t2,
               MB_YESNO|MB_ICONQUESTION|MB_TASKMODAL) != IDYES)return;
 count=0;
 sprintf(workfile,"%swork_$.$$$",TempPath);
 if((tf=fopen(workfile,"wb")) == NULL){
   SendPrgmQuery(IDQ_TFWE,0);
   return;
 }
 fp=MainFp; for(k=0;k<Nface;k++){
   vp1=(MainVp+fp->V[0]); vp2=(MainVp+fp->V[1]); vp3=(MainVp+fp->V[2]);
   if(vp1->status == SELECTED ||
      vp1->status == SELECTED ||
      vp1->status == SELECTED){
     count++;
     if((fwrite(vp1->xyz,sizeof(long),3,tf) != 3) ||
        (fwrite(vp2->xyz,sizeof(long),3,tf) != 3) ||
        (fwrite(vp3->xyz,sizeof(long),3,tf) != 3) ||
        (fwrite(fp->color,sizeof(unsigned char),3,tf) != 3) ||
        (fwrite(&fp->bSmooth,sizeof(unsigned char),1,tf) != 1) ||
        (fwrite(&fp->imagemap,sizeof(short),1,tf) != 1) ||
        (fwrite(&fp->material,sizeof(short),1,tf) != 1)){
       SendPrgmQuery(IDQ_TFWE,0);
       fclose(tf);
       remove(workfile);
       return;
     }
   }
   fp++;
 }
 fclose(tf);
 if(count > 0){
   if((tf=fopen(workfile,"rb")) == NULL){
     SendPrgmQuery(IDQ_NOOPENWORKFILE,0);
     return;
   }
   EraseVertex(0);
   if(!UpdateVertexHeap(Nvert+count*3))goto EP1;
   if(!UpdateEdgeHeap(Nedge+count*3))goto EP1;
   if(!UpdateFaceHeap(Nface+count))goto EP1;
   for(i=0;i<count;i++){
     CreateVertex(); v1=Nvert-1; vp1=(MainVp+v1);
     CreateVertex(); v2=Nvert-1; vp2=(MainVp+v2);
     CreateVertex(); v3=Nvert-1; vp3=(MainVp+v3);
     CreateEdge(v1,v2);
     CreateEdge(v2,v3);
     CreateEdge(v3,v1);
     CreateFace(v1,v2,v3); fp=(MainFp+Nface-1);
     fread(vp1->xyz,sizeof(long),3,tf);
     fread(vp2->xyz,sizeof(long),3,tf);
     fread(vp3->xyz,sizeof(long),3,tf);
     fread(fp->color,sizeof(unsigned char),3,tf);
     fread(&fp->bSmooth,sizeof(unsigned char),1,tf);
     fread(&fp->imagemap,sizeof(short),1,tf);
     fread(&fp->material,sizeof(short),1,tf);
   }
   UpdateCounters();
   fclose(tf);
 }
 remove(workfile);
 return;
 EP1:
 SendPrgmQuery(IDQ_NOMEM1,0);
 DrawModel();
 UpdateCounters();
 fclose(tf);
 remove(workfile);
 return;
}

long *GetPathList(long *np){
 vertex *Vp;
 long vp,vf,*va;
 double d,dmin,drange;
 long Npath=0;
 if(NvertSelect < 1)return NULL;
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/1024;
 vf= -1; vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && intriview(Vp)){
     d=(double)(Vp->xyz[0]-NpointerX)*(double)(Vp->xyz[0]-NpointerX)
      +(double)(Vp->xyz[1]-NpointerY)*(double)(Vp->xyz[1]-NpointerY)
      +(double)(Vp->xyz[2]-NpointerZ)*(double)(Vp->xyz[2]-NpointerZ);
     if(d < dmin && d < drange){
       dmin=d;
       vf=vp;
     }
   }
   Vp->id=0; /* use this bit for found flag */
   vp++;
 }
 if(vf < 0){
   SendPrgmQuery(IDQ_NOPATHSTART,0);
   return NULL;
 }
 if((va=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return NULL;
 }
 Npath=0; va[0]=vf; (MainVp+va[0])->id=1;
 (MainVp+vf)->status=DESELECTED; NvertSelect--; NvertDeselect++;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(va[Npath],vp)){
     Npath++;
     va[Npath]=vp;
     Vp->id=1;
     Vp->status=DESELECTED;
     NvertSelect--; NvertDeselect++;
     vp=0;
   }
   else vp++;
 }
 Npath++;
 *np=Npath;
 return va;
}

static void SetAccurateControl(HWND hwnd,int ID, double value){
 char tempstr[16];
 sprintf(tempstr,"%.2lf",value);
 SendDlgItemMessage(hwnd,ID,WM_SETTEXT,0,(LPARAM)tempstr);
 SendDlgItemMessage(hwnd,ID,EM_LIMITTEXT,(WPARAM)12,0);
}

static double GetAccurateControl(HWND hwnd,int ID, double value){
 char tempstr[16];
 if(GetDlgItemText(hwnd,ID,tempstr,12) == 0)return value;
 value=atof(tempstr);
 return value;
}

BOOL CALLBACK BuildAccurateCurveDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 static double x,y,z,rx,ry,rz,x0,y0,z0;
 static long LastAccurateVertex= -1;
 static BOOL locked;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:
     x0=x=(double)(NpointerX-rulerx)/ruler; rx=0.0;
     y0=y=(double)(NpointerY-rulery)/ruler; ry=0.0;
     z0=z=(double)(NpointerZ-rulerz)/ruler; rz=0.0;
     locked=TRUE;
     SetAccurateControl(hwnd,DLG_BUILD_AX,x);
     SetAccurateControl(hwnd,DLG_BUILD_AY,y);
     SetAccurateControl(hwnd,DLG_BUILD_AZ,z);
     SetAccurateControl(hwnd,DLG_BUILD_RX,rx);
     SetAccurateControl(hwnd,DLG_BUILD_RY,ry);
     SetAccurateControl(hwnd,DLG_BUILD_RZ,rz);
     locked=FALSE;
     CentreDialogOnCursor(hwnd);
     return (TRUE);
   case WM_COMMAND:
      switch(HIWORD(wparam)){
        case EN_CHANGE:
          if(LOWORD(wparam) == DLG_BUILD_AX && !locked){
            locked=TRUE;
            x=GetAccurateControl(hwnd,DLG_BUILD_AX,x);
            rx=x-x0;
            SetAccurateControl(hwnd,DLG_BUILD_RX,rx);
            locked=FALSE;
          }
          else if(LOWORD(wparam) == DLG_BUILD_RX && !locked){
            locked=TRUE;
            rx=GetAccurateControl(hwnd,DLG_BUILD_RX,rx);
            x=x0+rx;
            SetAccurateControl(hwnd,DLG_BUILD_AX,x);
            locked=FALSE;
          }
          if(LOWORD(wparam) == DLG_BUILD_AY && !locked){
            locked=TRUE;
            y=GetAccurateControl(hwnd,DLG_BUILD_AY,y);
            ry=y-y0;
            SetAccurateControl(hwnd,DLG_BUILD_RY,ry);
            locked=FALSE;
          }
          else if(LOWORD(wparam) == DLG_BUILD_RY && !locked){
            locked=TRUE;
            ry=GetAccurateControl(hwnd,DLG_BUILD_RY,ry);
            y=y0+ry;
            SetAccurateControl(hwnd,DLG_BUILD_AY,y);
            locked=FALSE;
          }
          if(LOWORD(wparam) == DLG_BUILD_AZ && !locked){
            locked=TRUE;
            z=GetAccurateControl(hwnd,DLG_BUILD_AZ,z);
            rz=z-z0;
            SetAccurateControl(hwnd,DLG_BUILD_RZ,rz);
            locked=FALSE;
          }
          else if(LOWORD(wparam) == DLG_BUILD_RZ && !locked){
            locked=TRUE;
            rz=GetAccurateControl(hwnd,DLG_BUILD_RZ,rz);
            z=z0+rz;
            SetAccurateControl(hwnd,DLG_BUILD_AZ,z);
            locked=FALSE;
          }
          break;
        default: break;
      }
      switch(LOWORD(wparam)){
        case DLG_BUILD_START:
          LastAccurateVertex= -1;
        case DLG_BUILD_MAKE:
          UpdateVertexHeap(Nvert+1);  CreateVertex();
          (MainVp+Nvert-1)->xyz[0]=(long)(x*ruler)+rulerx;
          (MainVp+Nvert-1)->xyz[1]=(long)(y*ruler)+rulery;
          (MainVp+Nvert-1)->xyz[2]=(long)(z*ruler)+rulerz;
          DrawVerticesOnly((MainVp+Nvert-1));
          if(LastAccurateVertex >= 0){
            UpdateEdgeHeap(Nedge+1);
            CreateEdge(Nvert-1,LastAccurateVertex);
            DrawOneEdgeOnly((MainVp+Nvert-1),(MainVp+LastAccurateVertex));
          }
          LastAccurateVertex=Nvert-1;
          rx=ry=rz=0.0; x0=x; y0=y; z0=z;
          UpdateCounters();
          locked=TRUE;
          SetAccurateControl(hwnd,DLG_BUILD_AX,x);
          SetAccurateControl(hwnd,DLG_BUILD_AY,y);
          SetAccurateControl(hwnd,DLG_BUILD_AZ,z);
          SetAccurateControl(hwnd,DLG_BUILD_RX,rx);
          SetAccurateControl(hwnd,DLG_BUILD_RY,ry);
          SetAccurateControl(hwnd,DLG_BUILD_RZ,rz);
         locked=FALSE;
          break;
        case DLG_BUILD_DONE:
          LastAccurateVertex= -1;
          EndDialog(hwnd,0);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

typedef struct FACEEDGE {
  long   v;
  long   last,next,inc;
  vector n;   /* normal defining plane with edge; plane parallel to curve N */
  vector p;   /* vector corresponding to vertex v */
} faceedge;

typedef struct FACEEDGELIST {
  struct FACEEDGE *f;
  long   n,I,done_count;
  vector normal;
} faceedgelist;

typedef struct NORMALS {
  vector n,nav;
} normals;

static void  ReverseCurve(faceedge *af, long Npath);
static int CurveNormal(faceedgelist *fli);
static void MakeNewCurveNormals(long i, faceedgelist *facelist);
static long  CurveInside(faceedgelist *fl, long i, long Ncurves);
static void RemakeTheCurve(long i, long Ncurves,faceedgelist *facelist);
static int edge_is_internal(faceedge *af, long Npath,
                              long te, long ne, long fe,
                              vector new_normal, vector N,
                              int allow_all);
static int edge_is_ok(long n,faceedge *f, vector ph, vector po,
                        long ex1, long ex2);
static void BevelCurve(long Ncurves, faceedgelist *facelist, double d,
                       double angle, vector direction);
static int point_inside_curve(vector v2, vector Nav, faceedge *af,
                                long Npath, vector N);
double GetDistanceFromCurves(point c_point, long Ncurves,
                             faceedgelist *facelist);

static double bevel_angle=45.0;

static void MakeNewCurveNormals(long i, faceedgelist *facelist){
 long j,k,Npath;
 faceedge *af;
 vector v1,v2,v3;
 Npath=facelist[i].n;
 af=facelist[i].f;
 for(j=0;j<Npath;j++){ /* need an inside edge */
   VECCOPY(af[j].p,v1)
   k=af[j].next;
   VECCOPY(af[k].p,v2)
   VECSUB(v2,v1,v3)
   O_normalize(v3);
   CROSS(v3,facelist[i].normal,af[j].n)
   O_normalize(af[j].n);
 }
}

static int edge_is_internal(faceedge *af, long Npath,
                              long te, long ne, long fe,
                              vector new_normal, vector N,
                              int allow_all){
 vector p0,p1,pa,pb,p10,pba,pc; /* p0/1 define the potential internal edge */
 vector pte,pne,pac,n,vi,da,db,p01,vilast;
 vector vj,pn,pnb;
 long i,j,k,le,cross_count=0,last_allowed;
 double mu,mu1,dmin,d0,d1,d01;
 VECCOPY(af[te].p,pa)
 VECCOPY(af[ne].p,pb)
 VECSUB(pb,pa,pte)
 if(O_normalize(pte) == FAIL)return 0;
 VECCOPY(af[ne].p,pa)
 VECCOPY(af[fe].p,pb)
 VECSUB(pb,pa,pne)
 if(O_normalize(pne) == FAIL)return 0;
 if((d0=DOT(pte,pne)) > 0.9999){  /* 0.99 is too restrictive */
   return 0; /* co-linear */
 }
 else if(allow_all == 0 && d0 < -0.95){
   return 0; /* angle too acute */
 }
 VECCOPY(af[te].p,p0)
 VECCOPY(af[fe].p,p1)
 VECSUB(p1,p0,p10)
 VECCOPY(p10,p01)
 if(O_normalize(p01) == FAIL)return 0;
 CROSS(p01,N,new_normal)
 if(O_normalize(new_normal) == FAIL)return 0;
 VECSCALE(0.5,p10,pc)
 VECSUM(p0,pc,pc)      /* half way along new edge  */
 last_allowed = -1;    /* id of last edge with intersect at end*/
 for(i=0;i<Npath;i++){ /* check to see if internal */
   if(af[i].inc == 1){
     VECCOPY(af[i].p,pa)
     j=af[i].next;
     VECCOPY(af[j].p,pb)
     VECCOPY(af[i].n,n)
     VECSUB(pa,pc,pac)
     mu1=DOT(n,new_normal);
     if(fabs(mu1) > 0.0001){
       mu=DOT(pac,n)/mu1;
       if(mu > 0.0000){ /* look for intersections on one side */
         VECSCALE(mu,new_normal,vi) /* intersection to plane of test edge */
         VECSUM(pc,vi,vi)
         VECSUB(pb,pa,pba)
         k = -1; dmin = 1.0;
         if(fabs(pba[0]) > dmin){k=0; dmin =fabs(pba[0]);}
         if(fabs(pba[1]) > dmin){k=1; dmin =fabs(pba[1]);}
         if(fabs(pba[2]) > dmin){k=2; dmin =fabs(pba[2]);}
         if(k >= 0){
           mu1=(vi[k]-pa[k])/pba[k];
           if(fabs(mu1) < 0.0000001){ /* at start of segment */
             k=af[i].last;  /* for vector leading up to edge i */
             VECCOPY(af[k].p,pn)
             VECSUB(pa,pn,pnb)
             d0=DOT(pba,p01); d1=DOT(pnb,p01);
             if(d0*d1 > 0.0 && k != last_allowed){
               cross_count++;
             }
           }
           else if(fabs(1.0-mu1) < 0.0000001){
             k=af[j].next;   /* k is at end of edge next to end of i  */
             VECCOPY(af[k].p,pn)
             VECSUB(pn,pb,pnb)
             d0=DOT(pba,p01); d1=DOT(pnb,p01);
             if(d0*d1 > 0.0){
               cross_count++; last_allowed=i;
             }
           }
           else if(mu1 > 0.0 && mu1 < 1.0){
             cross_count++;
           }
         }
       }
     }
   }
 }
 if(cross_count%2 == 0)return 0; /* external to curve */
 le = af[te].last;
 for(i=0;i<Npath;i++){ /* check for edge in way */
   /* if either end of the edge is at the same place as vertices at        */
   /* TE or LE then it must be ignored (it is probably a hole join         */
   /* we also must not consider edges taking part in the possible new edge */
   /* edges with a vertex at the same place as NE must be considered       */
   if( !( i == le || i == te || i == ne || i == fe)  && af[i].inc == 1){
     j=af[i].next;
     VECCOPY(af[i].p,pa)
     VECCOPY(af[j].p,pb)
     VECCOPY(af[i].n,n)
     VECSUB(pa,p0,da)  d0=DOT(da,n);
     VECSUB(pa,p1,db)  d1=DOT(db,n);
     d01=d0*d1;
     if(d01 < 0.0){ /* new edge crosses other edge plane, is it inside ? */
       mu1=DOT(p10,n);
       if(fabs(mu1) > 1.0){
         mu=d0/mu1;
         VECSCALE(mu,p10,vi)
         VECSUM(p0,vi,vi)
         VECSUB(pb,pa,pba)
         k = -1; dmin = 1.0;
         if(fabs(pba[0]) > dmin){k=0; dmin =fabs(pba[0]);}
         if(fabs(pba[1]) > dmin){k=1; dmin =fabs(pba[1]);}
         if(fabs(pba[2]) > dmin){k=2; dmin =fabs(pba[2]);}
         if(k >= 0){
           mu1=(vi[k]-pa[k])/pba[k];
           if(mu1 >= -0.0001 && mu1 < 1.0001){
             return 0;
           }
         }
       }
     }
   }
 }
 return 1;
}

static int CurveNormal(faceedgelist *fli){
/* return a normal to the plane of the curve, the normal may point to */
/* either side a consistant normal will be calculated later.          */
/* This must use the Vertex pointer since the curve point vector has  */
/* not yet been assigned.                                             */
 long i,j,Npath;
 faceedge *af;
 vector v1,v2,v3,new_normal;
 Npath=fli->n;
 af=fli->f;
 POINT2VECTOR((MainVp+(af[0].v))->xyz,v1)
 j=1; /* try to get the normal to the plane */
 RETRY:
 for(i=1;i<Npath-j;i++){
   POINT2VECTOR((MainVp+(af[i  ].v))->xyz,v2)
   POINT2VECTOR((MainVp+(af[i+j].v))->xyz,v3)
   VECSUB(v2,v1,v2)
   VECSUB(v3,v1,v3)
   if(O_normalize(v2) != FAIL && O_normalize(v3) != FAIL &&
     fabs(DOT(v2,v3)) < 0.9){
     CROSS(v2,v3,new_normal)
     if(O_normalize(new_normal) != FAIL){
       goto GOTNORMAL;
     }
   }
 }
 if(j < Npath-3){
   j++;
   goto RETRY;
 }
 SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
 return FAIL;
 GOTNORMAL:
 VECCOPY(new_normal,fli->normal);
 return OK;
}

static long CurveInside(faceedgelist *fl, long ii, long Ncurves){
/* this may use either the vertex pointer or vertex vector since they */
/* are still co-incident at this point in the algorithm               */
 vector pc,p0,p1,p10,p01,new_normal,pa,pb,n,pac,pn,pnb,pba,vi;
 long i,j,k,l,cross_count,Npath,curvid = -1;
 double mu,mu1,dmin,mumin,mumumin=1.0e35;
 faceedge *af;
 af=fl[ii].f;
 POINT2VECTOR((MainVp+(af[0].v))->xyz,p0)
 POINT2VECTOR((MainVp+(af[1].v))->xyz,p1)
 VECSUB(p1,p0,p10)
 VECCOPY(p10,p01)
 if(O_normalize(p01) == FAIL)return -1;
 CROSS(p01,fl[ii].normal,new_normal)
 if(O_normalize(new_normal) == FAIL)return -1; /* rt angl to first edge */
 VECSCALE(0.5,p10,pc)
 VECSUM(p0,pc,pc)   /* mid point of first edge */
 for(l=0;l<Ncurves;l++){
   if(l == ii)continue;
   cross_count=0;
   af=fl[l].f;
   Npath=fl[l].n;
   mumin=1.0e35;
   for(i=0;i<Npath;i++){ /* check to see if new_normal crosses edges in path */
     POINT2VECTOR((MainVp+(af[i].v))->xyz,pa)
     j=af[i].next;
     POINT2VECTOR((MainVp+(af[j].v))->xyz,pb)
     VECCOPY(af[i].n,n)
     VECSUB(pa,pc,pac)
     mu1=DOT(n,new_normal);
     if(fabs(mu1) > 0.0001){
       mu=DOT(pac,n)/mu1;
       if(mu > 0.0000){   /* look for intersections on one side */
         VECSCALE(mu,new_normal,vi)
         VECSUM(pc,vi,vi) /* intersection to plane of test edge */
         VECSUB(pb,pa,pba)
         k = -1; dmin = 1.0;
         if(fabs(pba[0]) > dmin){k=0; dmin =fabs(pba[0]);}
         if(fabs(pba[1]) > dmin){k=1; dmin =fabs(pba[1]);}
         if(fabs(pba[2]) > dmin){k=2; dmin =fabs(pba[2]);}
         if(k >= 0){
           mu1=(vi[k]-pa[k])/pba[k];
           if(fabs(mu1) < 0.0000001){ /* at start of segment */
             k=af[i].last;
             POINT2VECTOR((MainVp+(af[k].v))->xyz,pn)
             VECSUB(pa,pn,pnb)
             if(DOT(pba,p01)*DOT(pnb,p01) > 0.0)cross_count++;
           }
           else if(fabs(1.0-mu1) < 0.0000001){ /* at end of segment */
             k=af[j].next;
             POINT2VECTOR((MainVp+(af[k].v))->xyz,pn)
             VECSUB(pn,pb,pnb)
             if(DOT(pba,p01)*DOT(pnb,p01) > 0.0)cross_count++;
           }
           else if(mu1 > 0.0 && mu1 < 1.0){
             cross_count++;
           }
           if(mu < mumin)mumin=mu;
         }
       }
     }
   }
   if(cross_count%2 == 1 && mumin <= mumumin){curvid=l; mumumin=mumin;}
 }
 return curvid;
}

static int edge_is_ok(long Npath, faceedge *af, vector p0, vector p1,
                        long ex1, long ex2){
/* check whether the vector po->p1 crosses any edges in the curve  */
/* with the exception of edges ex1 and ex2                         */
 vector n,pa,pb,pba,vi,da,db,p10;
 double d0,d1,d01,mu,mu1,dmin;
 long i,j,k;
 VECSUB(p1,p0,p10)
 for(i=0;i<Npath;i++){
   if(i != ex1 && i != ex2){
     VECCOPY(af[i].p,pa)
     j=af[i].next;
     VECCOPY(af[j].p,pb)
     VECCOPY(af[i].n,n)
     VECSUB(pa,p0,da)  d0=DOT(da,n);
     VECSUB(pa,p1,db)  d1=DOT(db,n);
     d01=d0*d1;
     if(d01 < 0.0){ /* new edge crosses other edge plane, is it inside ? */
       mu1=DOT(p10,n);
       if(fabs(mu1) > 1.0){
         mu=d0/mu1;
         VECSCALE(mu,p10,vi)
         VECSUM(p0,vi,vi)
         VECSUB(pb,pa,pba)
         k = -1; dmin = 1.0;
         if(fabs(pba[0]) > dmin){k=0; dmin =fabs(pba[0]);}
         if(fabs(pba[1]) > dmin){k=1; dmin =fabs(pba[1]);}
         if(fabs(pba[2]) > dmin){k=2; dmin =fabs(pba[2]);}
         if(k >= 0){
           mu1=(vi[k]-pa[k])/pba[k];
           if(mu1 >= -0.0001 && mu1 < 1.0001){
             return 0;
           }
         }
       }
     }
   }
 }
 return 1;
}

static void RemakeTheCurve(long ii, long Ncurves, faceedgelist *fl){
/* first find a point of attachment for the hole to the curve         */
/* this is the edge of closest approach that does not cross the hole  */
/* the curve of any hole that is a hole of the curve                  */
 vector ph,po,pho,jv;
 long vh,vo;
 long i,j,k,id,nph,npo,npk,idh = -1,ido = -1,NNpath,je1,je2,j0,j1,j2,j3;
 faceedge *afh,*afo,*afk,*afn;
 double d,dmin=1.e35;
 nph=fl[ii].n;
 afh=fl[ii].f;
 id=fl[ii].I;
 npo=fl[id].n;
 afo=fl[id].f;
 for(i=0;i<nph;i++){
    for(j=0;j<npo;j++){
       vh=afh[i].v; vo=afo[j].v;
       VECCOPY(afh[i].p,ph)
       VECCOPY(afo[j].p,po)
       if(edge_is_ok(nph,afh,ph,po,i,afh[i].last) &&
          edge_is_ok(npo,afo,ph,po,j,afo[j].last) ){
         for(k=0;k<Ncurves;k++){         /* check the other holes   */
           if(k != ii && fl[k].I == id){ /* in curve round this one */
             npk=fl[k].n;
             afk=fl[k].f;
             if( ! edge_is_ok(npk,afk,ph,po, -1, -1))goto NOTOK;
           }
         }
         d=(po[0]-ph[0])*(po[0]-ph[0]) +
           (po[1]-ph[1])*(po[1]-ph[1]) +
           (po[2]-ph[2])*(po[2]-ph[2]);
         if(d < dmin){
           dmin=d; idh=i, ido=j;
         }
         NOTOK:;
       }
    }
 }
 if(idh == -1 || ido == -1)return;   /* defer or can't do attachment */
 fl[ii].done_count=YES;              /* this hole has been processed */
 NNpath=nph+npo+2;
 /* make space for the new curve  do it in 6 bits  */
 if((afn=(faceedge *)X__Malloc(NNpath*sizeof(faceedge))) == NULL)return;
 j=0;
 if(ido > 0)for(i=0;i<ido;i++){
   afn[j].v=afo[i].v; VECCOPY(afo[i].n,afn[j].n) VECCOPY(afo[i].p,afn[j].p)
   j++;
 }
 afn[j].v=afo[ido].v; je1=j; VECCOPY(afo[ido].p,afn[j].p) j++;
 if(idh < nph)for(i=idh;i<nph;i++){
   afn[j].v=afh[i].v; VECCOPY(afh[i].n,afn[j].n) VECCOPY(afh[i].p,afn[j].p)
   j++;
 }
 if(idh > 0)for(i=0;i<idh;i++){
   afn[j].v=afh[i].v; VECCOPY(afh[i].n,afn[j].n) VECCOPY(afh[i].p,afn[j].p)
   j++;
 }
 afn[j].v=afh[idh].v; je2=j; VECCOPY(afh[idh].p,afn[j].p) j++;
 if(ido < npo)for(i=ido;i<npo;i++){
   afn[j].v=afo[i].v; VECCOPY(afo[i].n,afn[j].n) VECCOPY(afo[i].p,afn[j].p)
   j++;
 }
 /* now update the conectivity matrix */
 for(j=0;j<NNpath;j++){
   afn[j].inc=1;
   if     (j == 0)       {afn[j].last=NNpath-1; afn[j].next=1;  }
   else if(j == NNpath-1){afn[j].last=j-1;      afn[j].next=0;  }
   else                  {afn[j].last=j-1;      afn[j].next=j+1;}
 }
 /* separate the curve at the join and calculate normals for the new edges */
 /* add a small displacement to the vector */
 for(j1=0;j1<NNpath;j1++){
   if(j1 == je1 || j1== je2){
     j0=afn[j1].last; j2=afn[j1].next; j3=afn[j2].next;
     VECSUB(afn[j1].p,afn[j0].p,pho) /* up to edge j */
     d=(pho[0]*pho[0])+(pho[1]*pho[1])+(pho[2]*pho[2]);
     if(d > 5.0e4){ /* arbitrary */
       VECSCALE((1.0 - 200.0/sqrt(d)),pho,pho)
       VECSUM(afn[j0].p,pho,afn[j1].p)
     }
     VECSUB(afn[j3].p,afn[j2].p,pho) /* after edge j */
     d=(pho[0]*pho[0])+(pho[1]*pho[1])+(pho[2]*pho[2]);
     if(d > 5.0e4){ /* arbitrary */
       VECSCALE((1.0 - 200.0/sqrt(d)),pho,pho)
       VECSUB(afn[j3].p,pho,afn[j2].p)
     }
     VECSUB(afn[j2].p,afn[j1].p,pho) /* make the normal */
     CROSS(pho,fl[id].normal,afn[j1].n)
     O_normalize(afn[j1].n); /* vector WILL be OK it it got here */
   }
 }
 vh=afh[idh].v; vo=afo[ido].v;

 /* free up the old memory */
 X__Free(afo); fl[id].f=afn;  fl[id].n=NNpath;
 X__Free(afh); fl[ii].f=NULL; fl[ii].n=0; fl[ii].I = -1;
 /* update the new curve (curve + hole) normmals */
 MakeNewCurveNormals(id,fl);
 CreateEdge(vh,vo); /* draw in new edge */
// DrawOneEdge(vh,vo);
 return;
}

int AutoFacetCurveWithHoles(int function, int visible, int atm,
                              double ba, double bd){
 HCURSOR hSave;
 long vp,vf,lastface[3],vstart,vrestart;
 long i,j,k,Ncurves,Npath,NpathMax,te,ne,fe,iteration_count,iteration_max;
 int allow_all,loop_count,hole_cross_count,round_count,nround,ifail=OK;
 faceedgelist *facelist,*newfacelist;
 faceedge *af;
 double d,dx,angle;
 point c_point;
 vector v1,v2,v3,N,new_normal,bevel_normal;
 if(NvertSelect < 1 || NvertSelect > 32000)return FAIL;
 vrestart=-1;
 round_count=0; nround=0;
 if(function == 1){
   angle=(double)RequestNumEntry((short)bevel_angle,
                5,90,"Bevel angle"," Angle");
   if(angle < 0)return FAIL;
   bevel_angle=angle;
 }
 else if(function == 2){
  angle=90;
  nround=4;
  angle /= nround;
 }
 else if(function == 3){ /* bevel from font  -ve for back face*/
   bevel_angle=ba;
 }
 EDIT_ACTION=YES;
 if(visible){
   hSave=SetCursor(ghcurWait);
   Save_Undo(0);
 }
 STARTAGAIN:
 vstart=vrestart;
 vrestart=Nvert-1;
 vp=Nvert-1; while(vp != vstart){(MainVp+vp)->id=0; vp--;}
 Ncurves=0; facelist=NULL; newfacelist=NULL;
 STILLCOUNTING:
 vp=Nvert-1; vf = -1; while(vp != vstart){
   if((MainVp+vp)->status == SELECTED && (MainVp+vp)->id == 0){vf=vp; break;}
   vp--;
 }
 if(vf < 0){
   if(Ncurves > 0)goto PROCESSNOW;
   else {ifail=FAIL; goto EXIT;}
 }
 Ncurves++;
 if(facelist == NULL)newfacelist=
   (faceedgelist *)X__Malloc(sizeof(faceedgelist)*Ncurves);
 else newfacelist=(faceedgelist *)X__Realloc(facelist,
                     sizeof(faceedgelist)*Ncurves);
 if(newfacelist == NULL){
   if(facelist != NULL){
     for(i=0;i<Ncurves-1;i++){
       if(facelist[i].n > 0 && facelist[i].f != NULL)X__Free(facelist[i].f);
     }
     X__Free(facelist);
     SendPrgmQuery(IDQ_NOMEM2,0);
   }
   ifail=FAIL;
   goto EXIT;
 }
 facelist=newfacelist; facelist[Ncurves-1].n=0;
 if((af = /* this is over estimate but who's counting */
       (faceedge *)X__Malloc(NvertSelect*sizeof(faceedge))) == NULL){
   for(i=0;i<Ncurves;i++){
     if(facelist[i].n > 0 && facelist[i].f != NULL)X__Free(facelist[i].f);
   }
   X__Free(facelist);
   SendPrgmQuery(IDQ_NOMEM2,0);
   ifail=FAIL;
   goto EXIT;
 }
 facelist[Ncurves-1].f=af;
 af[0].v=vf; (MainVp+(af[0].v))->id=1; Npath=1;
 vp=Nvert-1; while(vp != vstart){ /* get the next curve */
   if((MainVp+vp)->status == SELECTED &&
      (MainVp+vp)->id == 0 && connected(af[Npath-1].v,vp)){
     af[Npath  ].v=vp;
     (MainVp+vp)->id=1;
     vp=Nvert-1;
     Npath++;    /* add the point to the path list */
   }
   else vp--;
 }
 facelist[Ncurves-1].n=Npath;
 facelist[Ncurves-1].f = (faceedge *)X__Realloc(facelist[Ncurves-1].f,
                      Npath*sizeof(faceedge)); /* cut back */
 goto STILLCOUNTING;
 PROCESSNOW:  /* we now have all the curves */
 for(k=0;k<Ncurves;k++){ /* get curve normals and get normal to each edge */
   if(CurveNormal(&(facelist[k])) == FAIL){
     goto TERMINATE;
     ifail=FAIL;
   }
   Npath=facelist[k].n;
   af=facelist[k].f;
   for(i=0;i<Npath;i++){
     af[i].inc=1;
     if     (i == 0)      {af[i].next=1;   af[i].last=Npath-1;}
     else if(i == Npath-1){af[i].next=0;   af[i].last=i-1;    }
     else                 {af[i].next=i+1; af[i].last=i-1;    }
     POINT2VECTOR((MainVp+(af[i].v))->xyz,v1)
     VECCOPY(v1,af[i].p)                /* set up the point vector */
     j=af[i].next;
     POINT2VECTOR((MainVp+(af[j].v))->xyz,v2)
     VECSUB(v2,v1,v3)
     if(O_normalize(v3) == FAIL){
       SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
       ifail=FAIL; goto TERMINATE;
     }
     if(fabs(DOT(v3,facelist[k].normal)) > 0.05){
       SendPrgmQuery(IDQ_NOTPLANECURVE,0);
       ifail=FAIL; goto TERMINATE;
     }
     CROSS(v3,facelist[k].normal,af[i].n)
     if(O_normalize(af[i].n) == FAIL){
       SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
       ifail=FAIL; goto TERMINATE;
     }
   }
 }
 if(Ncurves > 1){ /* check all curves are same planar  */
   for(i=0;i<Ncurves-1;i++)for(j=i+1;j<Ncurves;j++){
    if(fabs(DOT(facelist[i].normal,facelist[j].normal)) < 0.99999){
       SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
       ifail=FAIL; goto TERMINATE;
    }
  }
 }
 for(i=0;i<Ncurves;i++){ /* is curve inside another curve */
   facelist[i].I=CurveInside(facelist,i,Ncurves); /* return -1 if not   */
   facelist[i].done_count=NO;
 }
 for(i=0;i<Ncurves;i++){/* is it a hole or inside a hole ? */
   hole_cross_count=0;
   if((j=facelist[i].I) >= 0)while(j >= 0){
     hole_cross_count++;
     j=facelist[j].I;
   }
   if(hole_cross_count %2 == 0)facelist[i].I = -1; /* curve inside a hole */
 }
 for(i=0;i<Ncurves;i++){  /* make normals consistent for outline curves */
   if(facelist[i].I < 0){
     Npath=facelist[i].n;
     af=facelist[i].f;
     for(j=0;j<Npath;j++){ /* we need an inside edge to make the normal */
       te=j; ne=af[te].next; fe=af[ne].next;
       if(edge_is_internal(af,Npath,te,ne,fe,v1,facelist[i].normal,1)){
         goto FOUNDPLANENORMAL1;
       }
     }
     SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
     ifail=FAIL;
     goto TERMINATE;
     FOUNDPLANENORMAL1:
     VECCOPY(af[te].p,v1) /* v1 returned is not required */
     VECCOPY(af[ne].p,v2)
     VECCOPY(af[fe].p,v3)
     VECSUB(v2,v1,v2)
     VECSUB(v3,v1,v3)
     CROSS(v2,v3,v1)
     if(O_normalize(v1) == FAIL){
       SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
       ifail=FAIL; goto TERMINATE;
     }
     VECCOPY(v1,facelist[i].normal) /* overwrite the temp normal */
     /* update the normals for each edge to reflect this new curve normal */
     MakeNewCurveNormals(i,facelist);
   }
 }
 for(i=0;i<Ncurves;i++){  /* make normals consistent for hole curves*/
   if(facelist[i].I >= 0){
     Npath=facelist[i].n;  /* v2 will be the normal for hole         */
     af=facelist[i].f;
     for(j=0;j<Npath;j++){ /* need an inside edge */
       te=j; ne=af[te].next; fe=af[ne].next;
       if(edge_is_internal(af,Npath,te,ne,fe,v1,facelist[i].normal,1)){
         goto FOUNDPLANENORMAL2;
       }
     }
     SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
     ifail=FAIL;
     goto TERMINATE;
     FOUNDPLANENORMAL2:
     VECCOPY(af[te].p,v1) /* v1 returned was not required */
     VECCOPY(af[ne].p,v2)
     VECCOPY(af[fe].p,v3)
     VECSUB(v2,v1,v2)
     VECSUB(v3,v1,v3)
     CROSS(v2,v3,v1)
     if(O_normalize(v1) == FAIL){
       SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
       ifail=FAIL; goto TERMINATE;
     } /* if the hole N is same direction as the outer N reverse hole */
     if(DOT(v1,facelist[facelist[i].I].normal) > 0.0){
       ReverseCurve(af,Npath);
       VECSCALE( -1.0,v1,facelist[i].normal)
     }
     else  VECCOPY(v1,facelist[i].normal)
     /* update the normals for this new hole curve */
     MakeNewCurveNormals(i,facelist);
   }
 }
 if(function > 0){
   if(function == 3){ /* bevel from font */
     dx=bd;
     if(bevel_angle >= 0.0)bevel_normal[0]=1.0;
     else{
       bevel_normal[0] = -1.0;
       bevel_angle *= -1.0;
     }
     bevel_normal[1]=0.0;
     bevel_normal[2]=0.0;
   }
   else if(round_count == 0){
     c_point[0]=NpointerX; c_point[1]=NpointerY; c_point[2]=NpointerZ;
     dx=d=GetDistanceFromCurves(c_point,Ncurves,facelist);
     v1[0]= (double)NpointerX - facelist[0].f[0].p[0]; /* Np - Pi */
     v1[1]= (double)NpointerY - facelist[0].f[0].p[1]; /* any point will do */
     v1[2]= (double)NpointerZ - facelist[0].f[0].p[2];
     VECCOPY(facelist[0].normal,bevel_normal); /* bevel to side of cursor */
     if(DOT(bevel_normal,v1) < 0.0)VECSCALE(-1.0,bevel_normal,bevel_normal);
   }
   if(function == 2){
     dx=d*(cos((double)(round_count)*angle*PI/180.0) -
           cos((double)(round_count+1)*angle*PI/180.0));
     bevel_angle=angle*((double)round_count+0.5);
   }
   BevelCurve(Ncurves,facelist,dx,bevel_angle,bevel_normal);
   goto TERMINATE;
 }
/* Set an upper bound on the number of edges and faces required */
 Npath=2*Ncurves;
 for(k=0;k<Ncurves;k++){
   i=facelist[k].n+1;
   Npath += ((i+1)*i)/2;
 }
 if(!UpdateEdgeHeap(Nedge+Npath))goto TERMINATE;
 if(!UpdateFaceHeap(Nface+Npath+2))goto TERMINATE;
/* NB NB  we must have some iteration here in case hole inside    */
/* a piece cannot be attached due to another hole in the way, in  */
/* such a case the intervening hole must be attached first        */
 for(k=0;k<2;k++){ /* 2 iterations may be enough */
   for(i=0;i<Ncurves;i++){
     if(facelist[i].I >= 0 && facelist[i].done_count == NO)
        RemakeTheCurve(i,Ncurves,facelist);
   }
 }
 /* now fill the curves */
 for(k=0;k<Ncurves;k++){
   Npath=facelist[k].n;
   if(Npath >=4){ /* at least 4 points  Npath set to 0 for hole outlines */
     af=facelist[k].f;
     VECCOPY(facelist[k].normal,N);
     NpathMax=Npath;
     te=0; loop_count=0; allow_all=0;
     iteration_count=0; iteration_max=2*Npath;
     while(Npath > 3){
       ne=af[te].next; fe=af[ne].next;
       if(edge_is_internal(af,NpathMax,te,ne,fe,new_normal,N,allow_all)){
         CreateEdge(af[te].v,af[fe].v);
         CreateFace(af[te].v,af[ne].v,af[fe].v);
//         DrawOneEdge(af[te].v,af[fe].v);
         af[ne].inc=0;
         af[te].next=fe;
         af[fe].last=te;
         VECCOPY(new_normal,af[te].n)
         Npath--;
         loop_count=0;
         allow_all=0;
         iteration_count=0;
         te=fe; /* move on - not really necesary */
       }
       else{ /* move to next edge to try again */
         te=ne;
       }
       loop_count++;
       if(loop_count > Npath+3)allow_all=1;
       if(allow_all)iteration_count++;
       if(iteration_count > iteration_max){
         if(atm)SendPrgmQuery(IDQ_ATMFILLFAIL,0);
         else   SendPrgmQuery(IDQ_FAILED,0);
         ifail=FAIL; goto TERMINATE;
       }
       if(GetAsyncKeyState(VK_ESCAPE) & 0x8000){ifail=FAIL; goto TERMINATE;}
     }
     for(j=0,i=0;i<NpathMax;i++){
       if(af[i].inc == 1){
         if(j > 2){
           if(atm)SendPrgmQuery(IDQ_ATMFILLFAIL,0);
           else   SendPrgmQuery(IDQ_FAILED,0);
           ifail=FAIL; goto TERMINATE;
         }
         lastface[j++]=af[i].v;
       }
     }
     CreateFace(lastface[0],lastface[1],lastface[2]);
   }
 }
 TERMINATE:
 for(i=0;i<Ncurves;i++){
   if(facelist[i].n > 0 && facelist[i].f != NULL)X__Free(facelist[i].f);
 }
 X__Free(facelist);
 UpdateEdgeHeap(Nedge);
 UpdateFaceHeap(Nface);
 if(++round_count < nround)goto STARTAGAIN;
 if(visible){
   DrawModel();
   UpdateCounters();
 }
 EXIT:
 if(visible){
   SetCursor(hSave);
 }
 return ifail;
}

static void  ReverseCurve(faceedge *af, long Npath){
  long i;
  long vt;
  vector pt;
  for(i=0;i<Npath/2;i++){
     vt=af[i].v; af[i].v = af[Npath-1-i].v; af[Npath-1-i].v=vt;
     VECCOPY(af[i].p,pt)
     VECCOPY(af[Npath-1-i].p,af[i].p)
     VECCOPY(pt,af[Npath-1-i].p)
  }
}

static void BevelCurve(long Ncurves, faceedgelist *facelist, double d,
                       double angle, vector direction){
 long i,j,k,Npath;
 faceedge *af;
 normals *VV;
 vector N,Nav,v1,v2,v3,vab;
 double dd,dplane;
 int inside,add_point,first_vertex;
 long lv,fv,sv,vp;
/* Set an upper bound on the number of edges and faces required */
 Npath=1; for(k=0;k<Ncurves;k++)Npath +=facelist[k].n+1;
 if(!UpdateVertexHeap(Nvert+Npath*2))return;  /* gross over estimates */
 if(!UpdateEdgeHeap(Nedge+Npath*4))return;
 if(!UpdateFaceHeap(Nface+Npath*4))return;
/* now do the bevel */
 sv=Nvert-1;
 for(i=0;i<Ncurves;i++){
   Npath=facelist[i].n;
   af=facelist[i].f;
   VECCOPY(facelist[i].normal,N)
   if((VV=(normals *)X__Malloc(Npath*sizeof(normals))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
     continue; /* continue on to next curve */
   }
   for(j=0;j<Npath;j++){ /* make each edge normal point in same way */
     POINT2VECTOR((MainVp+(af[j].v))->xyz,v1)
     k=af[j].next;
     POINT2VECTOR((MainVp+(af[k].v))->xyz,v2)
     VECSUB(v2,v1,v3)
     O_normalize(v3);
     CROSS(v3,N,af[j].n)
     O_normalize(af[j].n);
   }
   for(j=0;j<Npath;j++){ /* set up direction vectors */
     k=af[j].last;
     VECSUM(af[j].n,af[k].n,Nav);
     O_normalize(Nav);   /* may point to the inside or outside */
     POINT2VECTOR((MainVp+(af[j].v))->xyz,v1)
     VECSUM(v1,Nav,v2)
     inside=point_inside_curve(v2,Nav,af,Npath,N);
     if((inside && facelist[i].I >= 0) || ((! inside) && facelist[i].I < 0)){
       VECSCALE(-1.0,Nav,VV[j].nav)
       VECSCALE(-1.0,af[j].n,VV[j].n)
     }
     else{
       VECCOPY(Nav,VV[j].nav)
       VECCOPY(af[j].n,VV[j].n)
     }
   }
   lv = -1, fv = -1; first_vertex=YES;
   for(j=0;j<Npath;j++){
     POINT2VECTOR((MainVp+(af[j].v))->xyz,v1)
     k=af[j].next;
     POINT2VECTOR((MainVp+(af[k].v))->xyz,v2)
     VECSUB(v2,v1,vab)
     O_normalize(vab); /* vab will be non zero */
     k=af[j].last;
#define OBTUSE_A -0.7071
     if(DOT(vab,VV[j].nav) < OBTUSE_A){ /* large obtuse angle add vertex */
       VECSCALE(d,VV[k].n,v2)
       VECSUM(v1,v2,v3)
       CreateVertex(); if(fv < 0)fv=Nvert-1;
       VECTOR2POINT(v3,(MainVp+Nvert-1)->xyz)
       CreateEdge(af[j].v,Nvert-1);
       if(lv >= 0){
         CreateEdge(Nvert-1,lv);
         CreateEdge(Nvert-1,af[k].v);
         CreateFace(Nvert-1,af[k].v,af[j].v);
         CreateFace(Nvert-1,lv,af[k].v);
       }
       lv=Nvert-1;
       VECSCALE(d,VV[j].n,v2)
       VECSUM(v1,v2,v3)
       CreateVertex(); if(fv < 0)fv=Nvert-1;
       VECTOR2POINT(v3,(MainVp+Nvert-1)->xyz)
       CreateEdge(af[j].v,Nvert-1);
       CreateEdge(lv,Nvert-1);
       CreateFace(lv,Nvert-1,af[j].v);
       lv=Nvert-1;
     }
     else{   /* acute angle check to see if a vertex should be added */
       dd=fabs(DOT(VV[j].nav,VV[j].n)); /* get angular distance    */
       if(dd < 1.e-10)dd=d;             /* to keep bevel same size */
       else           dd=d/dd;
       POINT2VECTOR((MainVp+(af[k].v))->xyz,v2)
       CROSS(N,VV[k].nav,Nav)
       O_normalize(Nav);  /* normal vector to plane of Nav of last bevel */
       dplane=DOT(VV[j].nav,Nav);
       if(fabs(dplane) < 1.e-10)add_point=YES;
       else{
         VECSUB(v2,v1,v3);
         dplane=DOT(v3,Nav)/dplane;
         if(dplane < 0.0 || dplane >= dd)add_point=YES;
         else add_point=NO;
       }
       if(add_point == YES){ /* add a vertex */
         VECSCALE(dd,VV[j].nav,v2)
         VECSUM(v1,v2,v3)
         CreateVertex(); if(fv < 0)fv=Nvert-1;
         if(lv >= 0){
           CreateEdge(lv,Nvert-1);
           CreateEdge(Nvert-1,af[k].v);
           CreateFace(Nvert-1,af[k].v,af[j].v);
           CreateFace(Nvert-1,lv,af[k].v);
         }
         lv=Nvert-1;
         VECTOR2POINT(v3,(MainVp+Nvert-1)->xyz)
         CreateEdge(af[j].v,Nvert-1);
       }
       else{
         if(lv >= 0){
           CreateEdge(af[j].v,lv);
           CreateFace(af[j].v,lv,af[k].v);
           /* update the average normal for edge j to take account of   */
           /* fact that it must be shifted forward to line up with last */
           VV[j].nav[0]=(double)((MainVp+lv)->xyz[0] - (MainVp+af[j].v)->xyz[0]);
           VV[j].nav[1]=(double)((MainVp+lv)->xyz[1] - (MainVp+af[j].v)->xyz[1]);
           VV[j].nav[2]=(double)((MainVp+lv)->xyz[2] - (MainVp+af[j].v)->xyz[2]);
           O_normalize(VV[j].nav);
         }
         if(j == 0)first_vertex=NO;
       }
     }
     (MainVp+af[j].v)->status=DESELECTED; NvertSelect--; NvertDeselect++;
   }
   /* now fix up the loop end->start */
   if(fv >= 0 && lv >= 0){
     CreateEdge(lv,fv);
     CreateEdge(lv,af[0].v);
     CreateFace(lv,fv,af[0].v);
     CreateFace(lv,af[0].v,af[Npath-1].v);
     if(first_vertex == NO){
       CreateEdge(fv,af[0].v);
       CreateFace(fv,af[1].v,af[0].v);
     }
   }
   X__Free(VV);
 }
 if(angle < 89){ /* move the vertices to their new position */
   d=d/tan(angle/180.0*PI);
   vp=Nvert-1; while(vp != sv){
     (MainVp+vp)->xyz[0]=(long)((double)(MainVp+vp)->xyz[0] + d*direction[0]);
     (MainVp+vp)->xyz[1]=(long)((double)(MainVp+vp)->xyz[1] + d*direction[1]);
     (MainVp+vp)->xyz[2]=(long)((double)(MainVp+vp)->xyz[2] + d*direction[2]);
     vp--;
   }
 }
 UpdateVertexHeap(Nvert);  /* edge heaps are fixed in main routine */
 return;
}

static int point_inside_curve(vector v2, vector Nav, faceedge *af,
                                long Npath, vector N){
/* determine wheter point v2 is inside the curve  Nav is the vector v1->v2 */
 vector pa,pb,pba,pav,n,vi,pn,pnb,p01;
 double mu,mu1,dmin;
 long i,j,k,cross_count=0;
 CROSS(Nav,N,p01)
 for(i=0;i<Npath;i++){ /* check to see if new_normal crosses edges in path */
   POINT2VECTOR((MainVp+(af[i].v))->xyz,pa)
   j=af[i].next;
   POINT2VECTOR((MainVp+(af[j].v))->xyz,pb)
   VECCOPY(af[i].n,n)
   VECSUB(pa,v2,pav)
   mu1=DOT(n,Nav);
   if(fabs(mu1) > 0.0001){
     mu=DOT(pav,n)/mu1;
     if(mu > 0.0000){   /* look for intersections on one side */
       VECSCALE(mu,Nav,vi)
       VECSUM(v2,vi,vi) /* intersection to plane of test edge */
       VECSUB(pb,pa,pba)
       k = -1; dmin = 1.0;
       if(fabs(pba[0]) > dmin){k=0; dmin =fabs(pba[0]);}
        if(fabs(pba[1]) > dmin){k=1; dmin =fabs(pba[1]);}
       if(fabs(pba[2]) > dmin){k=2; dmin =fabs(pba[2]);}
       if(k >= 0){
         mu1=(vi[k]-pa[k])/pba[k];
         /* as above needs a test for edge along normal */
         if(fabs(mu1) < 0.0001){ /* at start of segment */
           k=af[j].last;
           POINT2VECTOR((MainVp+(af[k].v))->xyz,pn)
           VECSUB(pa,pn,pnb)
           if(DOT(pba,p01)*DOT(pnb,p01) > 0.0)cross_count++;
         }
         else if(fabs(1.0-mu1) < 0.0001){ /* at end of segment */
           k=af[j].next;
           POINT2VECTOR((MainVp+(af[k].v))->xyz,pn)
           VECSUB(pn,pb,pnb)
           if(DOT(pba,p01)*DOT(pnb,p01) > 0.0)cross_count++;
         }
         else if(mu1 >= 0.0001 && mu1 <= 0.9999)cross_count++;
       }
     }
   }
 }
 if(cross_count%2 == 1)return 1;
 return 0;
}

double GetDistanceFromCurves(point c_point, long Ncurves,
                             faceedgelist *facelist){
/* check from point and then from the edge */
  vector dp;
  double a,b,c,d,dmin=1.e35,mu;
  long i,j,Npath,found=0;
  faceedge *af;
  vertex *vp1,*vp2;
  for(i=0;i<Ncurves;i++){
    Npath=facelist[i].n;
    af=facelist[i].f;
    for(j=0;j<Npath;j++){
      vp1=(MainVp+af[j].v); vp2=(MainVp+af[af[j].next].v);
      a=(double)(vp2->xyz[0]-vp1->xyz[0]);
      b=(double)(vp2->xyz[1]-vp1->xyz[1]);
      c=(double)(vp2->xyz[2]-vp1->xyz[2]);
      mu=(a*((double)c_point[0]-(double)(vp1->xyz[0]))
         +b*((double)c_point[1]-(double)(vp1->xyz[1]))
         +c*((double)c_point[2]-(double)(vp1->xyz[2])))/(a*a+b*b+c*c);
      if(mu > 0.0 && mu < 1.0){
        found=1;
        dp[0]=(double)(vp1->xyz[0] - c_point[0]);
        dp[1]=(double)(vp1->xyz[1] - c_point[1]);
        dp[2]=(double)(vp1->xyz[2] - c_point[2]);
        d=fabs(DOT(af[j].n,dp));
        if(d < dmin)dmin=d;
      }
    }
  }
  if(found)return dmin;
  else     return TVsizeX/20;
}

// Functions for UNPLAN action

static int sort_sections(long *i, long *j){
  if     (*i < *j)return -1;
  else if(*i > *j)return  1;
  else            return  0;
}

static long section_intersect(long x, long x1, long x2, long y1, long y2){
 double grad;
 grad = (double)(y2-y1)/(double)(x2-x1);
 return (long)( (double)y1 + grad*((double)(x-x1)) );
}

void UnPlan(void){
 HCURSOR hSave;
 vertex *Vp,*V0,*V1;
 long vp,vx,*vo=NULL,vlast,vend;
 double d,dmin,drange,zscale,xscale,zdif,xdif;
 long NpathX,Nsections=0,i,j,k,l,m,ymin1,ymax1,ymin2,ymax2,
      ymax,ymin,xmin,xmax,zmin,zmax,zcentre,xcentre,zc,xc,
      y,z1,z2,x1,x2,*sections=NULL,Ne1=0,Ne2=0,Nvo=0,TOLL=MINUNIT;
 long ep,*el1=NULL,*el2=NULL;
 int p,special=0;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 if(NvertSelect == 0){
#if 0
   vlast=MainVp;
   LoadDXF(0);
   if(MainVp == vlast)goto EXIT;
   special=1;
   vp=vlast; while(vp != NULL){
     if(vp->status == DESELECTED)vp->status=INEDITOR;
     vp->id=0;
     vp=vp->last;
   }
   vend=MainVp;
   HideCursor();  DrawCursor(waiticon);  ShowCursor();
   j=k=l=0;
   vp=MainVp; while(vp != vlast){ /* go thro all vertices fixing up */
     if(vp->id == 20){          /* plan */
       m=vp->xyz[0]; vp->xyz[0]=vp->xyz[1]; vp->xyz[1] = -m;
       vp->id=0; j++;
     }
     else if(vp->id == 40){     /* rear */
       m=vp->xyz[0]; vp->xyz[0]=vp->xyz[1]; vp->xyz[1] = -m;
       m=vp->xyz[2]; vp->xyz[2]=vp->xyz[1]; vp->xyz[1] =  m;
       vp->id=1; k++;
     }
     else if(vp->id == 30){     /* side */
       m=vp->xyz[0]; vp->xyz[0]=vp->xyz[1]; vp->xyz[1] = -m;
       m=vp->xyz[0]; vp->xyz[0]=vp->xyz[2]; vp->xyz[2] = -m;
       vp->id=0; vp->status=DESELECTED; NvertSelect--; NvertDeselect++; l++;
     }
     else{
       vp->id=0; vp->status=INEDITOR; NvertSelect--; NvertDeselect++;
     }
     vp=vp->last;
   }
   if(j == 0 || k == 0 || l == 0)goto EXIT;
   TOLL = MINUNIT/4;
   goto DOIT;
#endif
 }
 if(NvertSelect < 4 || NvertDeselect < 4 || Nedge < 12)return;
 dmin=(double)TVsizeX*(double)TVsizeX; drange=dmin/1024;
 vx=-1;
 vp=0; Vp=MainVp;
 while(vp < Nvert){ /* find the first vertex of path closest to cursor */
   if(Vp->status == SELECTED && intriview(Vp)){
     d=(double)(Vp->xyz[0]-NpointerX)*(double)(Vp->xyz[0]-NpointerX)
      +(double)(Vp->xyz[1]-NpointerY)*(double)(Vp->xyz[1]-NpointerY)
      +(double)(Vp->xyz[2]-NpointerZ)*(double)(Vp->xyz[2]-NpointerZ);
     if(d < dmin && d < drange){
       dmin=d;
       vx=vp;
     }
   }
   Vp->id=0; /* clear ready to use for found flag   */
   vp++; Vp++;
 }
 if(vx < 0){
   SendPrgmQuery(IDQ_NOPATHSTART,0);
   return;
 }
 else if(SendPrgmQuery(IDQ_UNPLAN,2) != IDYES)return;
 if     (GetAsyncKeyState(VK_SHIFT)   & 0x8000)TOLL = MINUNIT/2;
 else if(GetAsyncKeyState(VK_CONTROL) & 0x8000)TOLL = MINUNIT/4;
 else if(GetAsyncKeyState(VK_MENU)    & 0x8000)TOLL = MINUNIT/8;
 else                                          TOLL = MINUNIT;
 hSave=SetCursor(ghcurWait);
 Save_Undo(0);
 (MainVp+vx)->id=1;
 vp=0; while(vp < Nvert){ /* flag the vertices in extruded curve */
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(vx,vp)){
     vx=vp;
     Vp->id=1;
     vp=0;  /* go back and look for the next connected vertex */
   }
   else vp++;
 }
// DOIT:
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if((Vp->status == SELECTED && Vp->id == 0) ||
       Vp->status == DESELECTED){
     if(Nsections == 0){
       if((sections=(long *)X__Malloc(sizeof(long))) == NULL)goto ABRT;
       *(sections) = Vp->xyz[1];
       Nsections=1;
     }
     else{
       for(i=0;i<Nsections;i++){
         if(abs(Vp->xyz[1] - *(sections+i)) < TOLL)goto BYPASS;
       }
       if((sections=(long *)X__Realloc(sections,(Nsections+1)*sizeof(long)))
                  == NULL)goto ABRT;
       *(sections+Nsections)=Vp->xyz[1];
       Nsections++;
       BYPASS:;
     }
   }
   vp++;
 }
 qsort(sections,Nsections,sizeof(long),(void *)sort_sections);
 ep=0; while(ep < Nedge){
   V0=(MainVp+(MainEp+ep)->V[0]); V1=(MainVp+(MainEp+ep)->V[1]);
   if(V0->status == DESELECTED &&
      V1->status == DESELECTED){ /* add to el1  vertical section */
     if(el1 == NULL){
       if( (el1=(long *)X__Malloc((long)sizeof(long)) ) == NULL)goto ABRT;
     }
     else{
       if( (el1=(long *)X__Realloc(el1,(Ne1+1)*(long)sizeof(long)) )
             == NULL)goto ABRT;
     }
     el1[Ne1]=ep;
     Ne1++;
   }
   else if(V0->status == SELECTED && V0->id == 0 &&
           V1->status == SELECTED && V1->id == 0){ /* horiz S */
     if(el2 == NULL){
       if( (el2=(long *)X__Malloc((long)sizeof(long)) ) == NULL)goto ABRT;
     }
     else {
       if( (el2=(long *)X__Realloc(el2,(Ne2+1)*(long)sizeof(long)) )
               == NULL)goto ABRT;
     }
     el2[Ne2]=ep;
     Ne2++;
   }
   ep++;
 }
 xmin = zmin =  MAXUNIT;
 xmax = zmax = -MAXUNIT;
 vp=0; Vp=MainVp; while(vp < Nvert){
   if(Vp->status == SELECTED){
     if(Vp->id == 0){
       Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
     }
     else{
       if(Vp->xyz[0] < xmin)xmin=Vp->xyz[0];
       if(Vp->xyz[0] > xmax)xmax=Vp->xyz[0];
       if(Vp->xyz[2] < zmin)zmin=Vp->xyz[2];
       if(Vp->xyz[2] > zmax)zmax=Vp->xyz[2];
       if(vo == NULL){
         if( (vo=(long *)X__Malloc((Nvo+1)*(long)sizeof(long)) )
                 == NULL)goto ABRT;
       }
       else {
         if( (vo=(long *)X__Realloc(vo,(Nvo+1)*(long)sizeof(long)) )
                 == NULL)goto ABRT;
       }
       vo[Nvo++]=vp;
     }
   }
   vp++; Vp++;
 }
 zcentre=(zmax+zmin)/2; xcentre=(xmax+xmin)/2;
 if(zmax == zmin || xmax == xmin)goto EXIT;
 zdif=(double)(zmax-zmin); xdif=(double)(xmax-xmin);
 ymax1 = -MAXUNIT;  ymin1 =  MAXUNIT;
 for(i=0;i<Ne1;i++){
   ep=el1[i];
   V0=(MainVp+(MainEp+ep)->V[0]); V1=(MainVp+(MainEp+ep)->V[1]);
   if(V0->xyz[1] < ymin1)ymin1=V0->xyz[1];
   if(V1->xyz[1] < ymin1)ymin1=V1->xyz[1];
   if(V0->xyz[1] > ymax1)ymax1=V0->xyz[1];
   if(V1->xyz[1] > ymax1)ymax1=V1->xyz[1];
 }
 ymax2 = -MAXUNIT;  ymin2 =  MAXUNIT;
 for(i=0;i<Ne2;i++){
   ep=el2[i];
   V0=(MainVp+(MainEp+ep)->V[0]); V1=(MainVp+(MainEp+ep)->V[1]);
   if(V0->xyz[1] < ymin2)ymin2=V0->xyz[1];
   if(V1->xyz[1] < ymin2)ymin2=V1->xyz[1];
   if(V0->xyz[1] > ymax2)ymax2=V0->xyz[1];
   if(V1->xyz[1] > ymax2)ymax2=V1->xyz[1];
 }
 ymin=max(ymin1,ymin2); ymax=min(ymax1,ymax2);
 for(i=0,p=0;i<Nsections;i++){
   y=sections[i];
   if(y >= ymin && y <= ymax){
     z1 = MAXUNIT; z2 = -MAXUNIT;
     for(j=0;j<Ne1;j++){
       ep=el1[j];  /* vertical yZ section  */
       V0=(MainVp+(MainEp+ep)->V[0]); V1=(MainVp+(MainEp+ep)->V[1]);
       if( (V0->xyz[1] <= y && V1->xyz[1] >= y ) ||
           (V1->xyz[1] <= y && V0->xyz[1] >= y ) ){/* spans */
         if(!(V0->xyz[1] == y && V1->xyz[1] == y)){/* not vert */
           m=section_intersect(y,V0->xyz[1],V1->xyz[1],
                                 V0->xyz[2],V1->xyz[2]);
           if(m <= z1)z1=m;
           if(m >= z2)z2=m;
         }
       }
     }
     x1 = MAXUNIT; x2 = -MAXUNIT;
     for(j=0;j<Ne2;j++){
       ep=el2[j];  /* horizontal section Xy */
       V0=(MainVp+(MainEp+ep)->V[0]); V1=(MainVp+(MainEp+ep)->V[1]);
       if( (V0->xyz[1] <= y && V1->xyz[1] >= y ) ||
           (V1->xyz[1] <= y && V0->xyz[1] >= y ) ){/* spans    */
         if(!(V0->xyz[1] == y && V1->xyz[1] == y)){/* not vert */
           m=section_intersect(y,V0->xyz[1],V1->xyz[1],
                                 V0->xyz[0],V1->xyz[0]);
           if(m <= x1)x1=m;
           if(m >= x2)x2=m;
         }
       }
     }
     if(z1 == MAXUNIT || x1 == MAXUNIT || z2 == -MAXUNIT || x2 == -MAXUNIT)
       goto OMIT;
     zc=(z1+z2)/2; xc=(x1+x2)/2;
     if    (p == 0)AddCopy(0);
     else  if(!CreateAttachedCopy(1))goto ABRT;
     if(zmax-zmin == 0)zscale=0.0;
     zscale=(double)(z2-z1)/zdif;
     xscale=(double)(x2-x1)/xdif;
     m=0;
     vp=0; Vp=MainVp; while(vp < Nvert){
       if(Vp->status == SELECTED){ /* move into position */
         Vp->xyz[1]=y;
         Vp->xyz[2]=(long)(zscale*(double)((MainVp+vo[m])->xyz[2]-zcentre)
                   +(double)zc);
         Vp->xyz[0]=(long)(xscale*(double)((MainVp+vo[m])->xyz[0]-xcentre)
                   +(double)xc);
         m++;
       }
       vp++; Vp++;
     }
     p++;
     OMIT:;
   }
 }
 goto EXIT;
 ABRT:;
 EXIT:;
 vp=0; Vp=MainVp; while(vp < Nvert){
   if(Vp->status == SELECTED){
     Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
   }
   vp++; Vp++;
 }
 if(vo != NULL)X__Free(vo);
 if(sections != NULL)X__Free(sections);
 if(el1 != NULL)X__Free(el1);
 if(el2 != NULL)X__Free(el2);
 if(special){
#if 0
   vp=vend; while(vp != NULL){
     if(vp->status == INEDITOR)vp->status=DESELECTED;
     vp=vp->last;
   }
   vp=vend; while(vp != vlast){
     if(vp->status == DESELECTED){
       vp->status=SELECTED; NvertSelect++; NvertDeselect--;
     }
     vp=vp->last;
   }
   EraseVertex(0);
#endif
 }
 SetCursor(hSave);
 reset_mod_maxview(1);
 DrawModel(); UpdateCounters();
}