TOOLS2.C

Go to the documentation of this file.

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


/* file TOOLS2.C  second designer tools file */

#define MODULE_TOOLS2 1

#include "design.h"

//#define DIS2(a) ((double)(a[0]-NpointerX)*(double)(a[0]-NpointerX)+  \
//                 (double)(a[1]-NpointerY)*(double)(a[1]-NpointerY)+  \
//                 (double)(a[2]-NpointerZ)*(double)(a[2]-NpointerZ))

typedef struct tagVERTEXVERTEX{
 long vl,vr;
} VERTEXVERTEX;

typedef struct tagFACEEXTRA{
 long extra,xxtra;
} FACEEXTRA;

static int squeeze(int how);
static double dspacing(long Va1, long Va2);

/* making list of vertices adjacent to new vertices improves effiency     */
/* it uses the vertex ID to store index to array giving adjacent vertices */
/* effient could be further improved by making a list of relevant faces   */

int Subdivide(long down_to_f, long down_to_e, long draw){
 face *fp;
 edge *ep;
 vertex *V0,*V1,*V2;
 long i,j,vl,vr,id,nf=0,ne=0,n,Nedge1,Nface1,Nv1;
 VERTEXVERTEX *vlist=NULL;
 FACEEXTRA    *MainLp=NULL,*lp;
 HCURSOR hSave;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return FAIL;
 }
 /* get upper bound for number of faces selected */
 if(down_to_f < Nface){
   if((MainLp=(FACEEXTRA *)X__Malloc(Nface*sizeof(FACEEXTRA))) == NULL){
     SendPrgmQuery(IDQ_NOMEM1,0);
     return FAIL;
   }
   fp=(MainFp+down_to_f); lp=(MainLp+down_to_f); nf=0;
   for(i=down_to_f;i<Nface;i++){
     lp->extra = -1;
     lp->xxtra = -1;
     V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
     if((V0->status == SELECTED && V1->status == SELECTED) ||
        (V1->status == SELECTED && V2->status == SELECTED) ||
        (V2->status == SELECTED && V0->status == SELECTED))nf++;
     fp++; lp++;
   }
 }
 for(ep=(MainEp+down_to_e),ne=0,i=down_to_e;i<Nedge;i++){
   if((MainVp+ep->V[0])->status == SELECTED &&
      (MainVp+ep->V[1])->status == SELECTED)ne++; // number of edges to be divided
   ep++;
 }
 if(ne == 0){
   if(MainLp != NULL)X__Free(MainLp);
   return FAIL;
 }
 /* extend the Vertices Edges and Faces arrays to their upper bounds */
 if((vlist=(VERTEXVERTEX *)X__Malloc(ne*sizeof(VERTEXVERTEX))) == NULL){
   if(MainLp != NULL)X__Free(MainLp);
   return FAIL;
 }
 if(!UpdateVertexHeap(Nvert+ne))goto EP1;
 if(!UpdateEdgeHeap(Nedge+ne+nf*3))goto EP1;
 if(!UpdateFaceHeap(Nface+nf*3))goto EP1;
 Nface1=Nface; Nedge1=Nedge;
 if(draw)hSave=SetCursor(ghcurWait);
 ep=(MainEp+down_to_e); n=0;
 for(i=down_to_e;i<Nedge1;i++){
   vl=ep->V[0]; V0=(MainVp+vl); vr=ep->V[1]; V1=(MainVp+vr);
   if(V0->status == SELECTED && V1->status == SELECTED){
     CreateVertex(); Nv1=Nvert-1;
     vlist[n].vl=vl; vlist[n].vr=vr; (MainVp+Nv1)->id=n; n++;
     (MainVp+Nv1)->xyz[0]=(V0->xyz[0] + V1->xyz[0])/2;
     (MainVp+Nv1)->xyz[1]=(V0->xyz[1] + V1->xyz[1])/2;
     (MainVp+Nv1)->xyz[2]=(V0->xyz[2] + V1->xyz[2])/2;
     CreateEdge(Nv1,ep->V[1]);
     ep->V[1]=Nv1;
     if(down_to_f < Nface1){
       fp=(MainFp+down_to_f); lp=(MainLp+down_to_f);
       for(j=down_to_f;j<Nface1;j++){
        id=0;
        if     ((fp->V[0] == vl && fp->V[1] == vr) ||
                (fp->V[0] == vr && fp->V[1] == vl) )id=1;
        else if((fp->V[1] == vl && fp->V[2] == vr) ||
                (fp->V[1] == vr && fp->V[2] == vl) )id=2;
        else if((fp->V[2] == vl && fp->V[0] == vr) ||
                (fp->V[2] == vr && fp->V[0] == vl) )id=3;
        if(id != 0){
          if(lp->extra < 0)lp->extra=Nv1;
          else{
            if(lp->xxtra < 0)lp->xxtra=Nv1;
            else{
               CreateEdge(Nv1,lp->extra);
               CreateEdge(Nv1,lp->xxtra);
               CreateEdge(lp->extra,lp->xxtra);
               if     (id == 1){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[2],lp->xxtra,lp->extra))
                   CreateFace(fp->V[2],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[2],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[0] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[0]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->extra))
                     CreateFace(fp->V[0],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[0],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->xxtra))
                     CreateFace(fp->V[1],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[1],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->extra))
                     CreateFace(fp->V[1],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[1],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->xxtra))
                     CreateFace(fp->V[0],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[0],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               else if(id == 2){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[0],lp->xxtra,lp->extra))
                   CreateFace(fp->V[0],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[0],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[1] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[1]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->extra))
                     CreateFace(fp->V[1],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[1],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->xxtra))
                     CreateFace(fp->V[2],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[2],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->extra))
                     CreateFace(fp->V[2],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[2],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[1],Nv1,lp->xxtra))
                     CreateFace(fp->V[1],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[1],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               else if(id == 3){
                 if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                             fp->V[1],lp->xxtra,lp->extra))
                   CreateFace(fp->V[1],lp->xxtra,lp->extra);
                 else
                   CreateFace(fp->V[1],lp->extra,lp->xxtra);
                 CopyFaceProp(fp,(MainFp+Nface-1));
                 if(vlist[(MainVp+lp->extra)->id].vl == fp->V[2] ||
                    vlist[(MainVp+lp->extra)->id].vr == fp->V[2]){
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->extra))
                     CreateFace(fp->V[2],Nv1,lp->extra);
                   else
                     CreateFace(fp->V[2],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->xxtra))
                     CreateFace(fp->V[0],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[0],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
                 else{
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[0],Nv1,lp->extra))
                     CreateFace(fp->V[0],Nv1,lp->extra);
                   else
                    CreateFace(fp->V[0],lp->extra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                   if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                               fp->V[2],Nv1,lp->xxtra))
                     CreateFace(fp->V[2],Nv1,lp->xxtra);
                   else
                     CreateFace(fp->V[2],lp->xxtra,Nv1);
                   CopyFaceProp(fp,(MainFp+Nface-1));
                 }
               }
               if(IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                          lp->xxtra,lp->extra,Nv1)){
                 fp->V[0]=lp->xxtra;
                 fp->V[1]=lp->extra;
                 fp->V[2]=Nv1;
               }
               else{
                 fp->V[0]=lp->xxtra;
                 fp->V[1]=Nv1;
                 fp->V[2]=lp->extra;
               }
               lp->extra = -1;
               lp->xxtra = -1;
            }
          }
        }
        fp++; lp++;
       }
     }
   }
   ep++;
 }
 if(down_to_f < Nface1){
   fp=(MainFp+down_to_f); lp=(MainLp+down_to_f);
   for(i=down_to_f;i<Nface1;i++){
     V0=(MainVp+fp->V[0]);
     V1=(MainVp+fp->V[1]);
     V2=(MainVp+fp->V[2]);
     if(lp->extra >= 0){
       if(V0->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[0],lp->extra,fp->V[2]))
           CreateFace(fp->V[0],lp->extra,fp->V[2]);
         else
           CreateFace(fp->V[0],fp->V[2],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[0],lp->extra);
         fp->V[2] = lp->extra;
       }
       else if(V1->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[1],lp->extra,fp->V[0]))
           CreateFace(fp->V[1],lp->extra,fp->V[0]);
         else
           CreateFace(fp->V[1],fp->V[0],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[1],lp->extra);
         fp->V[0] = lp->extra;
       }
       else if(V2->status == DESELECTED){
         if( IsFOSame(fp->V[0],fp->V[1],fp->V[2],
                      fp->V[2],lp->extra,fp->V[1]))
           CreateFace(fp->V[2],lp->extra,fp->V[1]);
         else
           CreateFace(fp->V[2],fp->V[1],lp->extra);
         CopyFaceProp(fp,(MainFp+Nface-1));
         CreateEdge(fp->V[2],lp->extra);
         fp->V[1] = lp->extra;
       }
     }
     fp++; lp++;
   }
 }
 X__Free(vlist);
 if(MainLp != NULL)X__Free(MainLp);
 if(draw)SetCursor(hSave);
 return OK;
 EP1:
 if(MainLp != NULL)X__Free(MainLp);
 X__Free(vlist);
 return FAIL;
}

int connected(long v1, long v2){
 edge *ep;
 long i;
 ep=MainEp; for(i=0;i<Nedge;i++){
   if( ((ep->V[0] == v1 && ep->V[1] == v2))
     ||((ep->V[0] == v2 && ep->V[1] == v1))
     )return 1;
   ep++;
 }
 return 0;
}

int AutoFillFace(long down_to){
 long i,node,vp,NewVertex;
 long face_count,*face_list;
 if(down_to >= Nvert)return 0;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return 0;
 }
 face_list = (long *)X__Malloc((NvertSelect+1)*10*sizeof(long));
 if(face_list == NULL)return 0;
 if(!UpdateVertexHeap(Nvert+1))return 0;
 if(!UpdateEdgeHeap(Nedge+(NvertSelect+1)*10))return 0;
 if(!UpdateFaceHeap(Nface+(NvertSelect+1)*10))return 0;
 NewVertex=Nvert;
 CreateVertex();
 (MainVp+NewVertex)->status=DESELECTED;
 (MainVp+NewVertex)->xyz[0]=NpointerX;
 (MainVp+NewVertex)->xyz[1]=NpointerY;
 (MainVp+NewVertex)->xyz[2]=NpointerZ;
 NvertSelect--; NvertDeselect++;
 for(i=0;i<Nvert;i++)(MainVp+i)->id=0;
 face_count=0;
 for(node=down_to;node<NewVertex;node++){;
   if((MainVp+node)->status == SELECTED){
     (MainVp+node)->id=1;
     CreateEdge(node,NewVertex);
     if(node < NewVertex-1)for(vp=node+1;vp < NewVertex; vp++){
       if((MainVp+vp)->status == SELECTED && (MainVp+vp)->id != 1){
          if(connected(node,vp)){
            CreateFace(node,vp,NewVertex);
            face_list[face_count]=(Nface-1);
            face_count++;
          }
       }
     }
   }
 }
 UpdateFaceHeap(Nface);
 UpdateEdgeHeap(Nedge);
 OrientateFaceNormals(-1,face_count,face_list);
 X__Free(face_list);
 return 1;
}

static int squeeze(int how){
 long i,j,NewVertex;
 point p,TVp;
 vertex *V0,*V1;
 if(NvertSelect < 2)return 0;
 if(how == 1){p[0]=NpointerX; p[1]=NpointerY; p[2]=NpointerZ;}
 if(how == 2)get_centre(0,p,TVp,FALSE);  /* the centroid */
 for(i=0;i<Nvert;i++)(MainVp+i)->id=0;
 if(Nedge > 0)for(i=0;i<Nedge;i++){
   V0=(MainVp+(MainEp+i)->V[0]);
   V1=(MainVp+(MainEp+i)->V[1]);
   if(V0->status == SELECTED || V1->status == SELECTED){
     V0->id = -1;
     V1->id = -1;
   }
 }
 EraseVertex(1);
 NewVertex=0; if(Nvert > 0)for(i=0;i<Nvert;i++){
   if((MainVp+i)->id < 0)NewVertex++;
 }
 if(!UpdateVertexHeap(Nvert+1))return 0;
 if(!UpdateEdgeHeap(Nedge+NewVertex+1))return 0;
 if(!UpdateFaceHeap(Nface+NewVertex+1))return 0;
 NewVertex=Nvert;
 CreateVertex();
 (MainVp+NewVertex)->status=DESELECTED;
 (MainVp+NewVertex)->xyz[0]=p[0];
 (MainVp+NewVertex)->xyz[1]=p[1];
 (MainVp+NewVertex)->xyz[2]=p[2];
 NvertSelect--; NvertDeselect++;
 if(Nvert > 1)for(i=0;i<Nvert-1;i++){
   if((MainVp+i)->id < 0)CreateEdge(i,NewVertex);
 }
 /* put in the faces where there are triangles */
 if(Nvert > 1)for(i=0;i<Nvert-1;i++){
   if((MainVp+i)->id < 0){
     for(j=0;j<Nvert-1;j++){
       if((MainVp+j)->id < 0 && connected(i,j))CreateFace(i,j,NewVertex);
     }
     (MainVp+i)->id=0;
   }
 }
 return 1;
}

void Replace_Faces(int how, double threshold){   /* gather in */
 /* how=0 for Normal function  how=1/2/3 for flip+weld */
 int id;
 long count;
 long i,vf;
 double th,d;
 vertex *vp,*vff;
 char temp[10];
 if(NvertSelect < 2){
   if(how == 0)SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return;
 }
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 if(how == 0){
   d=(double)TVsizeX*(double)TVsizeY;
   for(i=0;i<Nvert;i++){
     vp=(MainVp+i);
     if(vp->status == SELECTED)d=min(d,DIS2(vp->xyz));
   }
   d=sqrt(fabs(d))/ruler; if(d < 0.001)d=0.0;
   if((id=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_SQUEEZE),
     ghwnd_main,(DLGPROC)SqueezeDlgProc,(LPARAM)&d)) < 1)return;
   th=d;
   Save_Undo(2);
 }
 else {
   id=3;
   th=threshold*threshold;
 }
 if(id < 3)squeeze(id);
 else{   /* Weld */
   if(th >= 0.0){
     if(how == 0){th=th*ruler; th *= th;}
     for(i=0;i<Nvert;i++){
       vp=(MainVp+i);
       if(vp->status == SELECTED)vp->status = INEDITOR;
     }
     while(1){
       vf = -1;
       for(i=0;i<Nvert;i++){ /* find first vertex */
         vp=(MainVp+i);
         if(vp->status == INEDITOR){vf=i; break;}
       }
       if(vf < 0)break;
       vff=(MainVp+vf); vff->status = SELECTED; count=1;
       for(i=0;i<Nvert;i++){ /* find first vertex */
         vp=(MainVp+i);
         if(vp->status == INEDITOR){
           d=(double)(vff->xyz[0]-vp->xyz[0])*(double)(vff->xyz[0]-vp->xyz[0])
                    +(vff->xyz[1]-vp->xyz[1])*(double)(vff->xyz[1]-vp->xyz[1])
                    +(vff->xyz[2]-vp->xyz[2])*(double)(vff->xyz[2]-vp->xyz[2]);
           if(d < th){count++; vp->status=SELECTED;}
         }
       }
       if(count == 1){ /* if only one ignore */
         vff->status=DESELECTED; NvertSelect--; NvertDeselect++;
       }
       else squeeze(2);
     }
   }
 }
}

void ActionRotate(int axis, double angle, int draw){
 short shiftkey;
 double theta,ctheta,stheta
        ,dx,dy,dz;
 long i,tx,ty,tz;
 vertex *vp;
 struct np {int a; BOOL clock;} np;
 EDIT_ACTION=YES;
 theta = angle*PI/180.0;
 if(axis != 0 && WindowBox_view)theta *= -1.0;
 if(draw){
//   if     (GetAsyncKeyState(VK_SHIFT  ) & 0x8000)theta *=  9.0;
//   else if(GetAsyncKeyState(VK_MENU   ) & 0x8000)theta *= 18.0;
//   else if(GetAsyncKeyState(VK_CONTROL) & 0x8000){
   np.a=(int)angle;
   if(angle < 0)np.clock=TRUE;
   else         np.clock=FALSE;
   if(!DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_ROTATE),ghwnd_main,
                      (DLGPROC)RotateDlgProc,(LPARAM)&np))return;
   shiftkey=np.a;
   if(np.clock)angle = -1.0;
   else        angle =  1.0;
   theta = (double)shiftkey*PI/180.0;
   if(angle < 0)theta *= -1.0;
   RotateNurbsAction(axis,theta);
 }
// if(tool == SKANIMATE){
//   SkRotate(axis,theta);
//   return;
// }
// else if(sktool)return; /* do nothing if skeleton tool is active */
 if(theta == 0.0)return;
 if(Nnurbs == 0 && NvertSelect == 0)return;
 if(NvertSelect == 0)goto UPDATE;
 ctheta=cos(theta);
 stheta=sin(theta);

 vp=MainVp; for(i=0;i<Nvert;i++){
  if(vp->status == SELECTED){
   if     (axis == 0){
    dx=(double)(vp->xyz[0]-NpointerX);
    dy=(double)(vp->xyz[1]-NpointerY);
    tx=NpointerX+(long)(ctheta*dx-stheta*dy);
    ty=NpointerY+(long)(stheta*dx+ctheta*dy);
    vp->xyz[0]=tx;
    vp->xyz[1]=ty;
   }
   else if(axis == 1){
    dx=(double)(vp->xyz[0]-NpointerX);
    dz=(double)(vp->xyz[2]-NpointerZ);
    tx=NpointerX+(long)(ctheta*dx-stheta*dz);
    tz=NpointerZ+(long)(stheta*dx+ctheta*dz);
    vp->xyz[0]=tx;
    vp->xyz[2]=tz;
   }
   else if(axis == 2){
    dy=(double)(vp->xyz[1]-NpointerY);
    dz=(double)(vp->xyz[2]-NpointerZ);
    ty=NpointerY+(long)(ctheta*dy-stheta*dz);
    tz=NpointerZ+(long)(stheta*dy+ctheta*dz);
    vp->xyz[1]=ty;
    vp->xyz[2]=tz;
   }
  }
  vp++;
 }
 UPDATE:
 RecalibrateAllBezier(); RecalibrateMapLocks();
 if(draw)DrawModel();
}

void Explode(int type){
 struct TEMP {int id,id1; double dxx,dyy,dzz;} tc;
 double radius,distance,dmin,dmax;
 vertex *vp,*V0,*V1,*V2;
 int id,id1;
 face *fp;
 long i,g2;
 double medianX,medianY,medianZ,nmX,nmY,nmZ,dx,dy,dz,dxx,dyy,dzz;
 if(NvertSelect == 0){
   SendPrgmQuery(IDQ_OLD2,0);
 }
 else{
   if(type > 0){
     Save_Undo(1);
   }
   dmin=(double)MAXUNIT;
   dmax=0.0;
   if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
     if(vp->status == SELECTED){
       distance=sqrt(
         (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(distance < dmin)dmin=distance;
        if(distance > dmax)dmax=distance;
     }
     vp++;
   }
   if(dmin < MINUNIT)dmin=(double)MINUNIT;
   if(type > 0){
     dxx=1.5; dyy=1.5; dzz=1.5;
     tc.id=5; tc.id1=1;
     tc.dxx=dxx; tc.dyy=dyy; tc.dzz=dzz;
     DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_EXPLODE),
           ghwnd_main,(DLGPROC)ExplodeDlgProc,(LPARAM)&tc);
     id=tc.id; id1=tc.id1; dxx=tc.dxx; dyy=tc.dyy; dzz=tc.dzz;
   }
   else id=1;
   if(id <= 0)return;
   else if(id < 5){
     radius=(double)TVsizeX/2;
     if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
       if(vp->status == SELECTED){
         if(id == 1){
           distance=sqrt(
            (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(distance > 32){ /* any small number will do */
           distance = radius/distance;
             vp->xyz[0]=NpointerX+(vp->xyz[0]-NpointerX)*distance;
             vp->xyz[1]=NpointerY+(vp->xyz[1]-NpointerY)*distance;
             vp->xyz[2]=NpointerZ+(vp->xyz[2]-NpointerZ)*distance;
           }
         }
         else if(id == 2){
           vp->xyz[2]=NpointerZ;
         }
         else if(id == 3){
           vp->xyz[0]=NpointerX;
         }
         else if(id == 4){
           vp->xyz[1]=NpointerY;
         }
       }
       vp++;
     }
   }
   else if(id == 5){
     if((fp=MainFp) != NULL)for(i=0;i<Nface;i++){
       V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
       if(V0->status == SELECTED ||
          V1->status == SELECTED ||
          V2->status == SELECTED){
         medianX=(V0->xyz[0] + V1->xyz[0] + V2->xyz[0])/3.0;
         medianY=(V0->xyz[1] + V1->xyz[1] + V2->xyz[1])/3.0;
         medianZ=(V0->xyz[2] + V1->xyz[2] + V2->xyz[2])/3.0;
         if(id1 < 1){dx=dxx; dy=dyy; dz=dzz;}
         else if(id1 == 1){
           dx=1.0+dxx*(double)(rand())/32767.0;
           dy=1.0+dyy*(double)(rand())/32767.0;
           dz=1.0+dzz*(double)(rand())/32767.0;
         }
         else{
           distance=sqrt((medianX-NpointerX)*(medianX-NpointerX) +
                         (medianY-NpointerY)*(medianY-NpointerY) +
                         (medianZ-NpointerZ)*(medianZ-NpointerZ));
           if(distance > dmax){dx=1.0; dy=1.0; dz=1.0;}
           else{
             dx = dxx*0.666667/(1.0+distance/dmax);
             dy = dyy*0.666667/(1.0+distance/dmax);
             dz = dzz*0.666667/(1.0+distance/dmax);
           }
         }
         nmX = NpointerX+(medianX-NpointerX)*dx;
         nmY = NpointerY+(medianY-NpointerY)*dy;
         nmZ = NpointerZ+(medianZ-NpointerZ)*dz;
         V0->xyz[0] = V0->xyz[0] - medianX + nmX;
         V0->xyz[1] = V0->xyz[1] - medianY + nmY;
         V0->xyz[2] = V0->xyz[2] - medianZ + nmZ;
         V1->xyz[0] = V1->xyz[0] - medianX + nmX;
         V1->xyz[1] = V1->xyz[1] - medianY + nmY;
         V1->xyz[2] = V1->xyz[2] - medianZ + nmZ;
         V2->xyz[0] = V2->xyz[0] - medianX + nmX;
         V2->xyz[1] = V2->xyz[1] - medianY + nmY;
         V2->xyz[2] = V2->xyz[2] - medianZ + nmZ;
       }
       fp++;
     }
   }
   else if(id == 6){ /* explode to grid */
     if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
       if(vp->status == SELECTED){
         g2=grid_size/2;
         vp->xyz[0] = lrulerx+((vp->xyz[0]+
           (vp->xyz[0] >= 0 ? g2 : -g2)-lrulerx)/grid_size)*grid_size;
         vp->xyz[1] = lrulery+((vp->xyz[1]+
           (vp->xyz[1] >= 0 ? g2 : -g2)-lrulery)/grid_size)*grid_size;
         vp->xyz[2] = lrulerz+((vp->xyz[2]+
           (vp->xyz[2] >= 0 ? g2 : -g2)-lrulerz)/grid_size)*grid_size;
       }
       vp++;
     }
   }
   if(type > 0)DrawModel();
 }
}

long get_closest_vertex(void){
 vertex *vp;
 long i,vf;
 double dmin,drange,d;
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/1024;
 vf = -1;
 if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
   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=i;
     }
   }
   vp->id=0; /* use this bit for found flag */
   vp++;
 }
 if(vf < 0){
   SendPrgmQuery(IDQ_NOPATHSTART,0);
   return -1;
 }
 return vf;
}

void ExtrudeAlong(void){
 struct np {double expan,repeat_map;} data;
 long vp,vf,*va;
 double ndv1,mu,expan=1.0,l,ll,dmap,repeat_map=4.0;
 long Npath,i;
 vector v1,v2,v3,n,dv,vp1,vp2;
 int id,use_map_coord=0;
 vertex *Vp,*Va,*Va1;
 HCURSOR hSave;
 if(NvertSelect < 1)return;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 if((vf=get_closest_vertex()) < 0)return; /* set ID to 0 */
 data.expan=expan;
 data.repeat_map=repeat_map;
 if((id=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_EXTRUDEALONG),
     ghwnd_main,(DLGPROC)ExtrudeAlongDlgProc,(LPARAM)&data)) == FAIL)return;
 expan=data.expan;
 repeat_map=data.repeat_map;
 /* found first vertex of path */
 /* find path connected to vf and store in array va[] */
 if((va=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 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++;    /* add the point to the path list */
     va[Npath]=vp;
     Vp->id=1;   /* flag so not used again also indicates in path */
     Vp->status=DESELECTED;
     NvertSelect--; NvertDeselect++; /* deselect the path points */
     vp=0;  /* go back and look for the next connected vertex */
   }
   else vp++;
 }
 Save_Undo(0);
 if(Npath > 0){ /* at least 2 points needed */
   if(id == 2){ /* calculate expansion factor for end of path*/
     expan = exp(log(expan)/(double)Npath);
   }
   use_map_coord=0;
   {
     vp=0; while(vp < Nvert){ /* find if some of curve is for extrude */
        Vp=(MainVp+vp);
        if(Vp->status == SELECTED && Vp->gp > 0){
          use_map_coord=1;
          break;
        }
        vp++;
     }
   }
   if(use_map_coord){
     l=0.0; ll=0.0; /* get length of path */
     for(i=1;i<=Npath;i++){
       Va=(MainVp+va[i]); Va1=(MainVp+va[i-1]);
       l += sqrt(
           (double)(Va->xyz[0] - Va1->xyz[0])*
           (double)(Va->xyz[0] - Va1->xyz[0])+
           (double)(Va->xyz[1] - Va1->xyz[1])*
           (double)(Va->xyz[1] - Va1->xyz[1])+
           (double)(Va->xyz[2] - Va1->xyz[2])*
           (double)(Va->xyz[2] - Va1->xyz[2]));
     }
   }
   hSave=SetCursor(ghcurWait);
   for(i=1;i<=Npath;i++){ /* extrude along each path segment */
     Va=(MainVp+va[i]); Va1=(MainVp+va[i-1]);
     if(use_map_coord){
       ll += sqrt(
         (double)(Va->xyz[0] - Va1->xyz[0])*
         (double)(Va->xyz[0] - Va1->xyz[0])+
         (double)(Va->xyz[1] - Va1->xyz[1])*
         (double)(Va->xyz[1] - Va1->xyz[1])+
         (double)(Va->xyz[2] - Va1->xyz[2])*
         (double)(Va->xyz[2] - Va1->xyz[2]));
       dmap=ll/l*repeat_map;
     }
     POINT2VECTOR(Va->xyz ,v2);
     POINT2VECTOR(Va1->xyz,v1);
     VECSUB(v2,v1,v1)
     if(O_normalize(v1) == FAIL){
       SendPrgmQuery(IDQ_POINTSTOOCLOSE,0);
       goto EXIT;
     }
     if(i<Npath){
       POINT2VECTOR((MainVp+va[i+1])->xyz,v3);
       VECSUB(v3,v2,v2)
       if(O_normalize(v2) == FAIL){
         SendPrgmQuery(IDQ_POINTSTOOCLOSE,0);
         goto EXIT;
       }
       VECSUM(v1,v2,n)   /* n is normal to plane at point  i */
     }
     else VECCOPY(v1,n)
     POINT2VECTOR((MainVp+va[i])->xyz,v2);
     ndv1=DOT(n,v1);       /* n.(vector point1 -> point2)  */
     if(fabs(ndv1) < 1.e-10){
        SendPrgmQuery(IDQ_NOLOOPBACK,0);
        goto EXIT;
     }
     if(!CreateAttachedCopy(1)){
       SendPrgmQuery(IDQ_NOMEM2,0);
       goto EXIT;
     }
     vp=0; while(vp < Nvert){ /* move new points into position */
       Vp=(MainVp+vp);
       if(Vp->status == SELECTED){
         if(use_map_coord && Vp->gp > 0){
           Vp->y = dmap;
         }
         POINT2VECTOR(Vp->xyz,v3);
         VECSUB(v2,v3,v3)         /* intersection of ray with plane */
         mu=DOT(n,v3)/ndv1;       /* at v2   */
         if(id < 2){
           Vp->xyz[0] += (long)(mu*v1[0]);
           Vp->xyz[1] += (long)(mu*v1[1]);
           Vp->xyz[2] += (long)(mu*v1[2]);
         }
         else{    /* expand while extruding along the curve */
           VECSCALE(mu,v1,dv)
           POINT2VECTOR(Vp->xyz,vp1);
           VECSUM(vp1,dv,vp2)
           POINT2VECTOR((MainVp+va[i])->xyz,vp1);
           VECSUB(vp2,vp1,dv)
           Vp->xyz[0] = (long)(vp1[0] + expan*dv[0]);
           Vp->xyz[1] = (long)(vp1[1] + expan*dv[1]);
           Vp->xyz[2] = (long)(vp1[2] + expan*dv[2]);
         }
       }
       vp++;
     }
   }
   /* set curve now as selected  everything else deselected*/
   vp=0; while(vp < Nvert){
     Vp=(MainVp+vp);
     if(Vp->status == SELECTED){
       Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
     }
     vp++;
   }
   for(i=0;i<=Npath;i++)if((MainVp+va[i])->status == DESELECTED){
     (MainVp+va[i])->status=SELECTED;
     NvertSelect++; NvertDeselect--;
   }
 }
 EXIT:
 SetCursor(hSave);
 X__Free(va);
 DrawModel(); UpdateCounters();
 return;
}

static double dspacing(long Va1, long Va2){
 vertex *va1,*va2;
 double d;
 va1=(MainVp+Va1); va2=(MainVp+Va2);
 d=(double)(va1->xyz[0] - va2->xyz[0]) *
   (double)(va1->xyz[0] - va2->xyz[0]) +
   (double)(va1->xyz[1] - va2->xyz[1]) *
   (double)(va1->xyz[1] - va2->xyz[1]) +
   (double)(va1->xyz[2] - va2->xyz[2]) *
   (double)(va1->xyz[2] - va2->xyz[2]);
 d=sqrt(d);
 return d;
}

void JoinTwoCurves(void){
 HCURSOR hSave;
 vertex *Vp;
 long vp,vf1,vf2,*va1,*va2,*tempva,tempv,vactive,vnext,vcurrent;
 double d,dmin=1e32;
 long Npath1,Npath2,i,j,k0,k1,k2,flag;
 if(NvertSelect<6){
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return;
 }
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 EDIT_ACTION=YES;
 hSave=SetCursor(ghcurWait);
 vp=0; vf1=vf2=-1;
 while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED)vf1=vp;
   Vp->id=0; /* use this bit for found flag */
   vp++;
 }
 if(vf1 < 0){
   SendPrgmQuery(IDQ_NOCURVE1,0);
   goto FINISH;
 }
 /* find path connected to vf1 and store in array va1[] */
 if((va1=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   goto FINISH;
 }
 Npath1=0; va1[0]=vf1; (MainVp+va1[0])->id=1;
 (MainVp+vf1)->status=DESELECTED; NvertSelect--; NvertDeselect++;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(va1[Npath1],vp)){
     Npath1++;    /* add the point to the path list */
     va1[Npath1]=vp;
     Vp->id=1;   /* flag so not used again also indicates in path */
     Vp->status=DESELECTED;
     NvertSelect--; NvertDeselect++; /* deselect the path points */
     vp=0;  /* go back and look for the next connected vertex */
   }
   else vp++;
 }
 /* now we've curve 1 get curve 2 */
 vp=0;
 while(vp < Nvert){
   if((MainVp+vp)->status == SELECTED){
     vf2=vp; break; /* first one found will be enough */
   }
   vp++;
 }
 if(vf2 < 0){
   SendPrgmQuery(IDQ_NOCURVE2,0);
   X__Free(va1);
   goto GETOUT;
 }
 /* find path connected to vf1 and store in array va1[] */
 if((va2=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   X__Free(va1);
   goto GETOUT;
 }
 Npath2=0; va2[0]=vf2; (MainVp+va2[0])->id=2;
 (MainVp+vf2)->status=DESELECTED; NvertSelect--; NvertDeselect++;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(va2[Npath2],vp)){
     Npath2++;    /* add the point to the path list */
     va2[Npath2]=vp;
     Vp->id=2;   /* flag so not used again also indicates in path */
     Vp->status=DESELECTED;
     NvertSelect--; NvertDeselect++; /* deselect the path points */
     vp=0;  /* go back and look for the next connected vertex */
   }
   else vp++;
 }
 Npath1++; Npath2++;   /* correct number of vertices */
 if(Npath1 < 3 || Npath2 < 3 || NvertSelect > 0){
   SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
   X__Free(va1);
   X__Free(va2);
   goto GETOUT;
 }
 Save_Undo(0);
 /* find the smallest distance between the two paths*/
 for(i=0;i<Npath1;i++)
   for(j=0;j<Npath2;j++){
     if((d=dspacing(va1[i],va2[j])) < dmin){
       dmin=d; vf1=va1[i]; vf2=va2[j];
     }
 }
 /* for the paths re-make with first vertex the closest */
 Npath1=0; va1[0]=vf1; (MainVp+va1[0])->id=0;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->id == 1 && connected(va1[Npath1],vp)){
     Npath1++;
     va1[Npath1]=vp;
     Vp->id=0;
     vp=0;
   }
   else vp++;
 }
 Npath2=0; va2[0]=vf2; (MainVp+va2[0])->id=0;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->id == 2 && connected(va2[Npath2],vp)){
     Npath2++;
     va2[Npath2]=vp;
     Vp->id=0;
     vp=0;
   }
   else vp++;
 }
 if(Npath1 == 0 || Npath2 == 0){
   SendPrgmQuery(IDQ_NOJOIN,0);
   goto GETOUT;
 }
 Npath1++; Npath2++;
//fprintf(debug,"1 %ld    2 %ld\n",Npath1,Npath2);
 /* make Npath1 the main path with the fewest vertices */
 if(Npath2 < Npath1){
//fprintf(debug,"swapping curves\n");
   tempv=vf1; vf1=vf2; vf2=tempv;
   tempva=va1; va1=va2; va2=tempva;
   i=Npath1; Npath1=Npath2; Npath2=i;
 }
 /* which way round the second loop */

 /* make a start */
 if(dspacing(va1[1],va2[1]) > dspacing(va1[1],va2[Npath2-1])){
   /* curve 2 must be reversed */
//fprintf(debug,"changing direction\n");
   for(i=1;i<=(Npath2-1)/2;i++){
     tempv=va2[i];
     va2[i]=va2[Npath2-i];
     va2[Npath2-i]=tempv;
   }
 }
 /* extend the arrays                 */
 if(!UpdateEdgeHeap(Nedge+2*(Npath1+Npath2+1)))goto UPDATE_HEAP;
 if(!UpdateFaceHeap(Nface+2*(Npath1+Npath2+4)))goto UPDATE_HEAP;
 /* vcurrent is on the larger curve   */
 k0=1;
 CreateEdge(va1[0],va2[0]);
 (MainVp+va1[0])->id=0;                    /* first has been found closest ! */
 for(i=1;i<Npath1;i++){
   dmin=1e32; k1= -1;
   if(k0 < Npath2)for(j=k0;j<Npath2;j++){
     if((d=dspacing(va1[i],va2[j])) < dmin){dmin=d; k1=j;}
   }
   if(k1 >= 0){
     k0=k1;
     (MainVp+va1[i])->id=k0;
     CreateEdge(va1[i],va2[k0]);
   }
 }
 /* we now have a list of best connections from smaller to larger - go to it*/
 for(i=0;i<Npath1;i++){
   flag=0;     /* flagged when moving closer to vertex i+1 */
   vactive=va1[i];
   flag=0;
   k0=(long)((MainVp+va1[i])->id);
   vcurrent=va2[k0];
   if(i < Npath1-1){
     vnext=va1[i+1];
     k1=(long)((MainVp+va1[i+1])->id);
     k2=k1;
   }
   else{  /* fizing up the last bit */
     vnext=va1[0]; k1=Npath2; k2=0;
   }
   if(k1 > k0){ /* at least one edge between i and i+1 */
     if(k1 > k0+1){ /* at least one vertex between i and i+1 */
       for(j=k0+1;j<k1;j++){
         vcurrent=va2[j];
         if(flag == 0){ /* check which end is closest */
           CreateEdge(vcurrent,vactive);
           CreateFace(vactive,vcurrent,va2[j-1]);
           if(dspacing(vcurrent,va2[k0]) > dspacing(vcurrent,va2[k2])){
             /* switch to connecting to i+1 */
             CreateEdge(vcurrent,vnext);
             CreateFace(vactive,vcurrent,vnext);
             flag=1;
           }
         }
         else{ /* no option must be vnext */
           CreateEdge(vcurrent,vnext);
           CreateFace(va2[j-1],vnext,vcurrent);
         }
       }
     }
     /* put in last bit */
     if(flag == 0){
       CreateEdge(vcurrent,vnext);  /* check closest ??? */
       CreateFace(vactive,vnext,vcurrent);
     }
     CreateFace(vcurrent,vnext,va2[k2]);
   }
   else{ /* both i and i+1 are attached to same point */
         /* edges in place just put in face           */
     CreateFace(vactive,vcurrent,vnext);
   }
 }
 UPDATE_HEAP:
 UpdateFaceHeap(Nface);    /* release any storage that was given as  */
 UpdateEdgeHeap(Nedge);    /* an over estimate when it was allocated */
 X__Free(va1);
 X__Free(va2);
 GETOUT:
 DrawModel();
 UpdateCounters();
 FINISH:
 SetCursor(hSave);
}

void Spin(int connect, int nsections, BOOL quiet, int Iaxis){
 HCURSOR hSave;
 int n=12,angle,i,axis,j,np1,np2;
 double theta=360.0,dmap=1.0;
 long *p1,*p2,vp,vps,vsave;
 vertex *Vp;
 if(NvertSelect < 1)return;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 if(!quiet){
   if(Read1Int1Real("Lathe","# Sections","Angle",&n,3,100,&theta,
                    -355.0,360.0,ghwnd_main) != OK)return;
   axis=ActiveView;
 }
 else{
   axis=Iaxis;
   n=nsections;
   theta=360.0;
 }
 angle=(int)theta;

 dmap=4.0/(double)n*(double)angle/360.0;
 if(abs(angle) < 2)return;
 p1=NULL; p2=NULL;
 if(angle == 360){
   if(n < 3)return;             /* insist on at least 3 points in full rot */
   theta =(double)angle/(double)n; n--;
   if(connect == 1){
     p1=(long *)X__Malloc(sizeof(long)*NvertSelect);
     if(p1 == NULL){
       SendPrgmQuery(IDQ_NOMEM2,0);
       return;
     }
     p2=(long *)X__Malloc(sizeof(long)*NvertSelect);
     if(p2 == NULL){
       SendPrgmQuery(IDQ_NOMEM2,0);
       X__Free(p1);
       return;
     }
     np1=0; vps=Nvert;
     vp=0; while(vp < Nvert){
       if((MainVp+vp)->status==SELECTED){*(p1+np1)=vp; np1++;}
       vp++;
     }
   }
 }
 else {
   n--;
   theta=(double)angle/(double)n;
 }
 if(!quiet){
   hSave=SetCursor(ghcurWait);
   Save_Undo(0);
 }
 for(i=0;i<n;i++){
   vsave=Nvert;
   if(connect==0 && !AddCopy(0))goto FINISHED;
   if(connect==1 && !CreateAttachedCopy(1)){
     if(p1 != NULL)X__Free(p1);
     if(p1 != NULL)X__Free(p2);
     goto FINISHED;
   }
   ActionRotate(axis,theta,0);
   {
     vp=vsave; while(vp < Nvert){
       Vp=(MainVp+vp);
       if(Vp->status == SELECTED && Vp->gp > 0)Vp->y += dmap;
       vp++;
     }
   }
 }
/* tidy up for 360  rotation  fill in the missing links */
 if(angle==360 && connect == 1){
   /* extend the Edge/Face heaps */
   if(!UpdateEdgeHeap(Nedge+2*np1))goto EXIT;
   if(!UpdateFaceHeap(Nface+2*np1))goto EXIT;
   np2=0;
   vp=vps; while(vp < Nvert){
     if((MainVp+vp)->status==SELECTED){
       *(p2+np2)=vp; np2++;
     }
     vp++;
   }
   if(np1 != np2){MessageBeep(MB_OK); goto EXIT;}
   for(i=0;i<np1;i++)CreateEdge(*(p1+i),*(p2+i));
   if(np1 > 1){
     for(i=0;i<np1-1;i++) for(j=i+1;j<np1;j++){
       if(connected(*(p1+i),*(p1+j))){
         CreateEdge(*(p1+i),*(p2+j));
         CreateFace(*(p1+i),*(p2+j),*(p2+i));
         CreateFace(*(p1+i),*(p1+j),*(p2+j));
       }
     }
   }
   EXIT:
   X__Free(p1);
   X__Free(p2);
   UpdateEdgeHeap(Nedge);
   UpdateFaceHeap(Nface);
 }
 FINISHED:
 if(!quiet){
   SetCursor(hSave);
   DrawModel(); UpdateCounters();
 }
}

void CopyConnected(void){
#define PATH 11
 int flag1=0,flag2=0;
 HCURSOR hSave;
 long vp,vp2,Nv;
 point centre,TVp;
 vector x;
 vertex *Vp;
 int i=0;
 if(NvertSelect < 1) return;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 Save_Undo(0);
 SelectConnected(PATH);                // Set all path points to PATH status.
 vp=0; vp2=-1;
 while(vp < Nvert){
  if((MainVp+vp)->status==PATH){
    flag1=1; vp2=vp;
  }
  else if((MainVp+vp)->status==SELECTED)flag2=1;
  vp++;
 }
 if(flag1 == 0){
   SendPrgmQuery(IDQ_NONEARVERTEX,0);
   return;
 }
 if(flag2 == 0){
   vp=0; while(vp < Nvert){
     if((MainVp+vp)->status==PATH)(MainVp+vp)->status=DESELECTED;
     vp++;
   }
   DrawModel(); UpdateCounters();
   SendPrgmQuery(IDQ_BADCURVE,0);
   return;
 }
 Nv=Nvert;
 hSave=SetCursor(ghcurWait);
 vp=0; while(vp < Nv){
   if((MainVp+vp)->status==PATH){
     if(i > 0){
       if(!AddCopy(0))goto FINISHED;
     }
     get_centre(1,centre,TVp,FALSE);
     Vp=(MainVp+vp);
     x[0]=Vp->xyz[0]-centre[0];          // Calculate distance to move.
     x[1]=Vp->xyz[1]-centre[1];
     x[2]=Vp->xyz[2]-centre[2];
     vp2=0; while(vp2 < Nvert){
       Vp=(MainVp+vp2);
       if(Vp->status==SELECTED){
         Vp->xyz[0]+=x[0];                // Move selected to new position.
         Vp->xyz[1]+=x[1];
         Vp->xyz[2]+=x[2];
       }
       vp2++;
     }
     ++i;
   }
   vp++;
 }
 FINISHED:
 vp=0; while(vp < Nvert){
   if(Vp->status==SELECTED) {
     Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
   }
   vp++;
 }
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status==PATH) {             // Select path on exit.
     Vp->status=SELECTED;  ++NvertSelect; --NvertDeselect;
   }
   vp++;
 }
 SetCursor(hSave);
 DrawModel(); UpdateCounters();
}

void Flip(void){ /* 0 = H 1= V */
 HCURSOR hSave;
 struct np {int plane,weld;} data;
 vertex *Vp;
 long vp,vps;
 long NpX2,NpY2,NpZ2,toll,x,y,z;
 int sx,sy,swi,kid = -1;
 int id,plane,weld;
 data.plane=0;
 data.weld=0;
 if((id=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_FLIP),
     ghwnd_main,(DLGPROC)FlipDlgProc,(LPARAM)&data)) == FAIL)return;
 plane=data.plane;
 weld=data.weld;
 if     (ActiveView == TRITOP){
   if(plane == 0)kid=2; else kid=1;
 }
 else if(ActiveView == TRIFRONT){
   if(plane == 0)kid=3; else kid=1;
 }
 else if(ActiveView == TRIRIGHT){
   if(plane == 0)kid=3; else kid=2;
 }
 if(NvertSelect == 0 || kid < 0)return;
 if(weld){
// below may not be a good idea for getting toll - might work now  ???
   GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&sx,&sy);
   if(plane == 0){if(sy < 4)sy += 3; else sy -= 3;}
   if(plane == 1){if(sx < 4)sx += 3; else sx -= 3;}
   GetWorldCoords(ActiveView,&x,&y,&z,sx,sy);
   if     (kid == 1)toll=labs(NpointerX-x);
   else if(kid == 2)toll=labs(NpointerY-y);
   else if(kid == 3)toll=labs(NpointerZ-z);
// otherwise
//   toll=MINUNIT/2;
   Save_Undo(2);
   hSave=SetCursor(ghcurWait);
   vps=Nvert;
   AddCopy(0);
 }
 else Save_Undo(1);
 NpX2=NpointerX*2;
 NpY2=NpointerY*2;
 NpZ2=NpointerZ*2;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED){
     switch(kid){
       case 1: Vp->xyz[0] = NpX2-Vp->xyz[0]; break;
       case 2: Vp->xyz[1] = NpY2-Vp->xyz[1]; break;
       case 3: Vp->xyz[2] = NpZ2-Vp->xyz[2]; break;
     }
   }
   vp++;
 }
 if(weld){
   vp=0; while(vp < vps){ /* get vertices on edge in old */
     Vp=(MainVp+vp);
     if(Vp->id >= 0 && Vp->status == DESELECTED){
       swi=0;
       switch(kid){
         case 1: if(labs(Vp->xyz[0] - NpointerX) < toll)swi=1; break;
         case 2: if(labs(Vp->xyz[1] - NpointerY) < toll)swi=1; break;
         case 3: if(labs(Vp->xyz[2] - NpointerZ) < toll)swi=1; break;
       }
       if(swi){Vp->status=SELECTED; NvertSelect++; NvertDeselect--;}
     }
     vp++;
   }
   vp=vps; while(vp < Nvert){ /* get vertices on edge in new */
     Vp=(MainVp+vp);
     if(Vp->status == SELECTED){
       swi=0;
       switch(kid){
         case 1: if(labs(Vp->xyz[0] - NpointerX) > toll)swi=1; break;
         case 2: if(labs(Vp->xyz[1] - NpointerY) > toll)swi=1; break;
         case 3: if(labs(Vp->xyz[2] - NpointerZ) > toll)swi=1; break;
       }
       if(swi){Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
     }
     vp++;
   }
   Replace_Faces(kid,(double)toll);
   SetCursor(hSave);
 }
 DrawModel(); UpdateCounters();
}

#include "splines.c"

void SmoothCurve(void){
 vertex *Vp;
 long vp,vf,*va;
 double d,dmin,drange,dist,gds,gde,gs,ge,kx[4],ky[4],kz[4];
 long Npath,i;
 int id;
 char response[20];
 if(NvertSelect < 1)return;
 if(NvertSelect > 100){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/1024;
 vp=0; vf= -1;
 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;
 }
 if((va=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 Save_Undo(1);
 Npath=0; va[0]=vf; (MainVp+va[0])->id=1;
 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=0;
   }
   else vp++;
 }
 Npath++;
 if(Npath > 4){ /* at least 5 points needed */
   dist=dspacing(va[Npath-2],va[1]);
   gds=dist/dspacing(va[1],va[0]); gde=dist/dspacing(va[Npath-1],va[Npath-2]);
   if(GetAsyncKeyState(VK_CONTROL) & 0x8000){
     sprintf(response,"1.0,1.0");
     RequestCharString(10,response,"Flexibility",ghwnd_main);
     if(sscanf(response,"%lf,%lf",&gs,&ge) == 2){
       if(gs < 0.01 || gs > 20)gs=1.0;
       if(ge < 0.01 || ge > 20)ge=1.0;
       gds *= gs; gde *= ge;
     }
   }
   else if(GetAsyncKeyState(VK_SHIFT) & 0x8000){
     gds *= 2; gde *= 2;
   }
   else if(GetAsyncKeyState(VK_MENU) & 0x8000){
     gds *= 4; gde *= 4;
   }
   gs = (double)((MainVp+va[1])->xyz[0] - (MainVp+va[0])->xyz[0])*gds;
   ge = (double)((MainVp+va[Npath-1])->xyz[0] - (MainVp+va[Npath-2])->xyz[0])*gde;
   SplinesG(kx,(double)(MainVp+va[1])->xyz[0],
               (double)(MainVp+va[Npath-2])->xyz[0],gs,ge);
   gs = (double)((MainVp+va[1])->xyz[1] - (MainVp+va[0])->xyz[1])*gds;
   ge = (double)((MainVp+va[Npath-1])->xyz[1] - (MainVp+va[Npath-2])->xyz[1])*gde;
   SplinesG(ky,(double)(MainVp+va[1])->xyz[1],
               (double)(MainVp+va[Npath-2])->xyz[1],gs,ge);
   gs = (double)((MainVp+va[1])->xyz[2] - (MainVp+va[0])->xyz[2])*gds;
   ge = (double)((MainVp+va[Npath-1])->xyz[2] - (MainVp+va[Npath-2])->xyz[2])*gde;
   SplinesG(kz,(double)(MainVp+va[1])->xyz[2],
               (double)(MainVp+va[Npath-2])->xyz[2],gs,ge);
   for(i=2;i<Npath-2;i++){
     gds=(double)(i-1)/(double)(Npath-3);
     (MainVp+va[i])->xyz[0] = (long)SplinesR(kx,gds);
     (MainVp+va[i])->xyz[1] = (long)SplinesR(ky,gds);
     (MainVp+va[i])->xyz[2] = (long)SplinesR(kz,gds);
   }
 }
 else{
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
 }
 X__Free(va);
 DrawModel();
}