TOOLS4.C

Go to the documentation of this file.

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

/* file TOOLS4.C  4th designer tools file */

#define MODULE_TOOLS4 1

#include "design.h"

typedef struct WORKFACE {
  long f;       // id of the actual face
  long fa[3];   // id of adjacent faces in the workface list
  int  id;
  vector n;
} workface;

typedef struct VTXADJ {
  long nf;
  long *flist;
} vtxadj;

static int Nchange,Npieces;
static workface *WF;

static void xMakeSameOrientation(long last, long id){
 face *f;
 long i0,i1,i2,l0,l1,l2,a0,a1,a2;
 f=(MainFp+WF[last].f); l0=f->V[0]; l1=f->V[1]; l2=f->V[2];
 f=(MainFp+WF[id].f);   i0=f->V[0]; i1=f->V[1]; i2=f->V[2];
 a0=WF[id].fa[0]; a1=WF[id].fa[1]; a2=WF[id].fa[2];
 if((i2 == l2 && i1 == l1) ||
    (i2 == l1 && i1 == l0) ||
    (i2 == l0 && i1 == l2)){
   WF[id].fa[2]=a0; WF[id].fa[0]=a2;
   f->V[2]=i1; f->V[1]=i2; Nchange++;
   return;
 }
 if((i0 == l2 && i2 == l1) ||
    (i0 == l1 && i2 == l0) ||
    (i0 == l0 && i2 == l2)){
   WF[id].fa[0]=a1; WF[id].fa[1]=a0;
   f->V[0]=i2; f->V[2]=i0; Nchange++;
   return;
 }
 if((i1 == l1 && i0 == l0) ||
    (i1 == l2 && i0 == l1) ||
    (i1 == l0 && i0 == l2)){
   WF[id].fa[1]=a2; WF[id].fa[2]=a1;
   f->V[1]=i0; f->V[0]=i1; Nchange++;
   return;
 }
 return;
}

static void xSetConnectingID(long last,long id){
 if(WF[id].id == 1)return;
 WF[id].id=1;
 if(last >= 0)xMakeSameOrientation(last,id);
 last=id;
 if(WF[id].fa[0] >= 0)xSetConnectingID(last,WF[id].fa[0]);
 if(WF[id].fa[1] >= 0)xSetConnectingID(last,WF[id].fa[1]);
 if(WF[id].fa[2] >= 0)xSetConnectingID(last,WF[id].fa[2]);
}

static void xReorientate(workface *wf, long nf){
 long i,id;
 WF=wf;
 Nchange=0; Npieces=0;
 for(i=0;i<nf;i++)wf[i].id = -1;
 while(1){ /* keep going until all the bits have been processed */
   for(id=0;id<nf;id++){
     if(wf[id].id == -1)goto PROCESSIT;
   }
   break;      /* no bits have been found - so breakout */
   PROCESSIT:
   xSetConnectingID(-1,id);
   Npieces++;
 }
 return;
}

static void xFindAdjFaces(workface *wf, long nf){
 face *f;
 vertex *vp;
 vtxadj *vl=NULL;
 long c,nvl=0;
 long *fl,i,j,k,id,id0,id1,id2,fjd,fkd,n,m,kk,nl[3],ml[3];
 vp=MainVp; for(c=0;c<Nvert;c++){
   if(vp->id == -1){
     vp->id=nvl;
     nvl++;
   }
   else vp->id = -10;
   vp++;
 }
 if((vl=(vtxadj *)X__Malloc(nvl*sizeof(vtxadj))) == NULL)return;
 for(i=0;i<nvl;i++){
   vl[i].nf=0;
   vl[i].flist=NULL;
 }
 for(i=0;i<nf;i++){ /* make list of work faces attached to each vertex */
   f=(MainFp+wf[i].f);
   for(j=0;j<3;j++){
     id=(MainVp+(f->V[j]))->id;
     fl=vl[id].flist;
     n=vl[id].nf;
     if(fl == NULL){
       if((fl=(long *)X__Malloc(sizeof(long))) == NULL)return;
     }
     else{
       if((fl=(long *)X__Realloc(fl,(n+1)*sizeof(long))) == NULL)return;
     }
     fl[n]=i;
     vl[id].flist=fl;
     vl[id].nf=n+1;
   }
 }
 for(i=0;i<nf;i++){ /* find faces that are adjacent to workface face i */
   f=(MainFp+wf[i].f);
   id0=(MainVp+(f->V[0]))->id;
   id1=(MainVp+(f->V[1]))->id;
   id2=(MainVp+(f->V[2]))->id;
   nl[0]=id0; ml[0]=id1;
   nl[1]=id1; ml[1]=id2;
   nl[2]=id2; ml[2]=id0;
   for(kk=0;kk<3;kk++){
     wf[i].fa[kk] = -1; 
     if((n=vl[nl[kk]].nf) > 0 && (m=vl[ml[kk]].nf) > 0){
       for(j=0;j<n;j++){
         fjd=vl[nl[kk]].flist[j];
         for(k=0;k<m;k++){
           fkd=vl[ml[kk]].flist[k];
           if(fkd == fjd && fkd != i){
             wf[i].fa[kk]=fkd;  
             goto ENDF;
           }
         }
       }
     }
     ENDF:;
   }
 }
 for(i=0;i<nvl;i++){
   if(vl[i].flist != NULL)X__Free(vl[i].flist);
 }
 X__Free(vl);
 return;
}

void OrientateFaceNormals(long sas, long n_work_face, long *face_list){
 // sas = same orientation as face ID. If < 0 then make arbitrary.
 // then a lsit of Faces
 workface *w;
 long i,j,v0,v1,v2;
 w=NULL;
 if(sas >= 0){
  v0=(MainFp+sas)->V[0];
  v1=(MainFp+sas)->V[1];
  v2=(MainFp+sas)->V[2];
 }
 if((w=(workface *)X__Malloc(n_work_face*(long)sizeof(workface)))
       == NULL)return;
 for(i=0;i<Nvert;i++)(MainVp+i)->id = 0;
 for(j=0;j<n_work_face;j++){
   w[j].f=face_list[j];
   for(i=0;i<3;i++){
     w[j].fa[i] = -1;
     (MainVp+(MainFp+w[j].f)->V[i])->id = -1;
   }
 }
 xFindAdjFaces(w,n_work_face);
 xReorientate(w,n_work_face);
 if(sas >= 0){
   if(!IsFOSame(v0,v1,v2,
                (MainFp+face_list[0])->V[0],
                (MainFp+face_list[0])->V[1],
                (MainFp+face_list[0])->V[2]))
     ReverseFaceOrientation(n_work_face,face_list);
 }
 if(w != NULL)X__Free(w);
 return;
}

void ReverseFaceOrientation(long nf, long *face_list){
 long i,id;
 face *fp;
 for(i=0;i<nf;i++){
   fp=(MainFp+face_list[i]);
   id=fp->V[2];
   fp->V[2]=fp->V[0];
   fp->V[0]=id;
 }
 return;
}

BOOL IsFOSame(long s0, long s1, long s2,
                     long v0, long v1, long v2){
  vector u,v,n1,n2;
  VECSUB((double)(MainVp+s1)->xyz,
         (double)(MainVp+s0)->xyz,u)
  VECSUB((double)(MainVp+s2)->xyz,
         (double)(MainVp+s0)->xyz,v)
  CROSS(u,v,n1)
  VECSUB((double)(MainVp+v1)->xyz,
         (double)(MainVp+v0)->xyz,u)
  VECSUB((double)(MainVp+v2)->xyz,
         (double)(MainVp+v0)->xyz,v)
  CROSS(u,v,n2)
  if(DOT(n1,n2) < 0)return FALSE;
  return TRUE;
}

void OrientateSelectedFaces(void){
 face *fp;
 long i,face_count,*face_list;
 face_count=0; face_list=NULL;
 if(Nface == 0)return;
 for(i=0,fp=MainFp;i<Nface;i++,fp++){
   if((MainVp+fp->V[0])->status == SELECTED ||
      (MainVp+fp->V[1])->status == SELECTED ||
      (MainVp+fp->V[2])->status == SELECTED)face_count++;
 }
 face_list = (long *)X__Malloc((face_count)*sizeof(long));
 if(face_list == NULL)return;
 for(i=0,face_count=0,fp=MainFp;i<Nface;i++,fp++){
   if((MainVp+fp->V[0])->status == SELECTED ||
      (MainVp+fp->V[1])->status == SELECTED ||
      (MainVp+fp->V[2])->status == SELECTED){
     face_list[face_count]=i;
     face_count++;
   }
 }
 if(face_count > 0){
   OrientateFaceNormals(0,face_count,face_list);
 }
 X__Free(face_list);
}

int TurnIndicatedEdge(void){
 int i,sh1,sh2,sv1,sv2,npx,npy,v1,v2,vx,vy,ord1,ord2;
 double x,y,z,mu,a,b,c,d,dmin;
 edge     *ep,*epid;
 vertex   *vp,*vp1,*vp2;
 face     *fp,*fp1,*fp2;
 if(Nedge == 0 || MainEp == NULL || MainVp == NULL || MainFp == NULL || Nface == 0)return NO;
 dmin=(double)TVsizeX*(double)TVsizeX;
 epid=NULL;
 for(ep=MainEp,i=0;i<Nedge;i++,ep++){
   vp1=(MainVp+ep->V[0]); vp2=(MainVp+ep->V[1]);
   if(intriview(vp1) || intriview(vp2)){
     GetWindowCoords(ActiveView,
                     vp1->xyz[0],vp1->xyz[1],vp1->xyz[2],&sh1,&sv1);
     GetWindowCoords(ActiveView,
                     vp2->xyz[0],vp2->xyz[1],vp2->xyz[2],&sh2,&sv2);
     a=(double)(sh2-sh1); b=(double)(sv2-sv1);
     GetWindowCoords(ActiveView,
                     NpointerX,NpointerY,NpointerZ,&npx,&npy);
     if((sh2-sh1) != 0 ||  (sv2-sv1) != 0){
       x=(double)npx; y=(double)npy;
       mu=(a*(x-(double)sh1) + b*(y-(double)sv1))/(a*a+b*b);
       if(mu > 0.0001 && mu < 0.9999){
         x=a*mu+(double)sh1; y=b*mu+(double)sv1;
         sh1=(short)x; sv1=(short)y;
         if(abs(npx-sh1) < 3 && abs(npy-sv1) < 3){/* in 2D range */
           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)NpointerX-(double)(vp1->xyz[0]))
              +b*((double)NpointerY-(double)(vp1->xyz[1]))
              +c*((double)NpointerZ-(double)(vp1->xyz[2])))/(a*a+b*b+c*c);
           x=a*mu+(double)(vp1->xyz[0]);
           y=b*mu+(double)(vp1->xyz[1]);
           z=c*mu+(double)(vp1->xyz[2]);
           d=(x-(double)NpointerX)*(x-(double)NpointerX)
            +(y-(double)NpointerY)*(y-(double)NpointerY)
            +(z-(double)NpointerZ)*(z-(double)NpointerZ);
           if(d < dmin){/* closest in 3D */
             dmin=d;
             epid=ep;
           }
         }
       }
     }
   }
 }
 if(epid == NULL)return NO;
 v1=epid->V[0]; v2=epid->V[1];
 vp1=(MainVp+v1); vp2=(MainVp+v2);
 fp1=fp2=NULL;
 for(i=0,fp=MainFp;i<Nface;i++,fp++){
   if     (fp->V[0] == v1 && fp->V[1] == v2){
     if(fp1 == NULL){fp1=fp; vx=fp->V[2]; ord1=1;} else {fp2=fp; vy=fp->V[2]; ord2=1; goto GOTTWO;}}
   else if(fp->V[0] == v2 && fp->V[1] == v1){
     if(fp1 == NULL){fp1=fp; vx=fp->V[2]; ord1=2;} else {fp2=fp; vy=fp->V[2]; ord2=2; goto GOTTWO;}}
   else if(fp->V[1] == v1 && fp->V[2] == v2){
     if(fp1 == NULL){fp1=fp; vx=fp->V[0]; ord1=1;} else {fp2=fp; vy=fp->V[0]; ord2=1; goto GOTTWO;}}
   else if(fp->V[1] == v2 && fp->V[2] == v1){
     if(fp1 == NULL){fp1=fp; vx=fp->V[0]; ord1=2;} else {fp2=fp; vy=fp->V[0]; ord2=2; goto GOTTWO;}}
   else if(fp->V[2] == v1 && fp->V[0] == v2){
     if(fp1 == NULL){fp1=fp; vx=fp->V[1]; ord1=1;} else {fp2=fp; vy=fp->V[1]; ord2=1; goto GOTTWO;}}
   else if(fp->V[2] == v2 && fp->V[0] == v1){
     if(fp1 == NULL){fp1=fp; vx=fp->V[1]; ord1=2;} else {fp2=fp; vy=fp->V[1]; ord2=2; goto GOTTWO;}}
 }
 return NO;  // one or no adjacent faces to edge
 GOTTWO:     // swap 
 if(fp1 == NULL || fp2 == NULL)return NO;
 //MessageBox(NULL,"Got Faces","Turn Edge",MB_OK);
 // swap edges and faces
 epid->V[0]=vx; epid->V[1]=vy;
 if(ord1 == 1){fp1->V[0]=vx; fp1->V[1]=v1; fp1->V[2]=vy;}
 else         {fp1->V[0]=vx; fp1->V[1]=vy; fp1->V[2]=v1;}
 if(ord2 == 2){fp2->V[0]=vx; fp2->V[1]=vy; fp2->V[2]=v2;}
 else         {fp2->V[0]=vx; fp2->V[1]=v2; fp2->V[2]=vy;}
 return YES;
}

static BOOL IdentifyFaceCommonEdge(face *cf,  face *af,  long *vcf1, long *vcf2, long *vcfx,
                                                         long *vaf1, long *vaf2, long *vafx){
  if     (cf->V[0] == af->V[0] && cf->V[1] == af->V[2]){
    *vcfx=2; *vcf1=0; *vcf2=1;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[0] == af->V[2] && cf->V[1] == af->V[1]){
    *vcfx=2; *vcf1=0; *vcf2=1;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[0] == af->V[1] && cf->V[1] == af->V[0]){
    *vcfx=2; *vcf1=0; *vcf2=1;    *vafx=2; *vaf1=1; *vaf2=0;
  }

  else if(cf->V[2] == af->V[0] && cf->V[0] == af->V[2]){
    *vcfx=1; *vcf1=2; *vcf2=0;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[2] == af->V[2] && cf->V[0] == af->V[1]){
    *vcfx=1; *vcf1=2; *vcf2=0;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[2] == af->V[1] && cf->V[0] == af->V[0]){
    *vcfx=1; *vcf1=2; *vcf2=0;    *vafx=2; *vaf1=1; *vaf2=0;
  }

  else if(cf->V[1] == af->V[0] && cf->V[2] == af->V[2]){
    *vcfx=0; *vcf1=1; *vcf2=2;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[1] == af->V[2] && cf->V[2] == af->V[1]){
    *vcfx=0; *vcf1=1; *vcf2=2;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[1] == af->V[1] && cf->V[2] == af->V[0]){
    *vcfx=0; *vcf1=1; *vcf2=2;    *vafx=2; *vaf1=1; *vaf2=0;
  }
  
  // same as first batch but with opposite sign
  else if(cf->V[1] == af->V[0] && cf->V[0] == af->V[2]){
    *vcfx=2; *vcf1=1; *vcf2=0;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[1] == af->V[2] && cf->V[0] == af->V[1]){
    *vcfx=2; *vcf1=1; *vcf2=0;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[1] == af->V[1] && cf->V[0] == af->V[0]){
    *vcfx=2; *vcf1=1; *vcf2=0;    *vafx=2; *vaf1=1; *vaf2=0;
  }

  else if(cf->V[0] == af->V[0] && cf->V[2] == af->V[2]){
    *vcfx=1; *vcf1=0; *vcf2=2;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[0] == af->V[2] && cf->V[2] == af->V[1]){
    *vcfx=1; *vcf1=0; *vcf2=2;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[0] == af->V[1] && cf->V[2] == af->V[0]){
    *vcfx=1; *vcf1=0; *vcf2=2;    *vafx=2; *vaf1=1; *vaf2=0;
  }

  else if(cf->V[2] == af->V[0] && cf->V[1] == af->V[2]){
    *vcfx=0; *vcf1=2; *vcf2=1;    *vafx=1; *vaf1=0; *vaf2=2;
  }
  else if(cf->V[2] == af->V[2] && cf->V[1] == af->V[1]){
    *vcfx=0; *vcf1=2; *vcf2=1;    *vafx=0; *vaf1=2; *vaf2=1;
  }
  else if(cf->V[2] == af->V[1] && cf->V[1] == af->V[0]){
    *vcfx=0; *vcf1=2; *vcf2=1;    *vafx=2; *vaf1=1; *vaf2=0;
  }
  else{ MessageBox(NULL,"Bad ordering",NULL,MB_OK); return FALSE;}
  return TRUE;
}
 
static void WrapMapExtraVertex(face *cf, face *af){
 long vcf1,vcf2,vcfx,vaf1,vaf2,vafx;
 double rota,d,cs,ss,a,b,uu,vv,uv,wu,wv;
 double x0,y0,x1,y1,x2,y2,x4,y4;
 vector u,v,w,ww,c,vn,cfn,afn;
 // first identify which vertex in "af" need to be mapped" 
 if(!IdentifyFaceCommonEdge(cf,af,&vcf1,&vcf2,&vcfx,&vaf1,&vaf2,&vafx))return;
 if(!O_Normalize((MainVp+(cf->V[vcfx]))->xyz,
             (MainVp+(cf->V[vcf1]))->xyz,
             (MainVp+(cf->V[vcf2]))->xyz,cfn))return; 
 if(!O_Normalize((MainVp+(af->V[vafx]))->xyz,
             (MainVp+(af->V[vaf2]))->xyz,
             (MainVp+(af->V[vaf1]))->xyz,afn))return;
 rota=DOT(cfn,afn); 
 if(rota > 1.0 || rota < -1.0)rota=0.0;
 else if(rota >= 0.0)rota=acos(rota); 
 else rota=PI2+acos(rota);
 //fprintf(debug,"Rotation %lf   [pt1- %ld %ld]  pt2- %ld %ld]\n",rota*180.0/PI,cf->V[vcf1],af->V[vaf1],cf->V[vcf2],af->V[vaf2]);
 VECSUB((double)(MainVp+(cf->V[vcf2]))->xyz,(double)(MainVp+(cf->V[vcf1]))->xyz,v)
 VECSUB((double)(MainVp+(cf->V[vcf1]))->xyz,(double)(MainVp+(cf->V[vcfx]))->xyz,u)
 VECSUB((double)(MainVp+(af->V[vafx]))->xyz,(double)(MainVp+(af->V[vaf1]))->xyz,w)

 VECCOPY(v,vn); O_normalize(vn); // rotate about edge to unfold
 CROSS(vn,w,c)
 d=DOT(vn,w);
 rota = - rota;
 cs=cos(rota); ss=sin(rota);
 VECSUM(cs*w,(1.0-cs)*d*vn,ww)
 VECSUM(ww,ss*c,w)  // rotated to unfold
 
 uv=DOT(u,v); uu=DOT(u,u); vv=DOT(v,v); wu=DOT(w,u); wv=DOT(w,v);
 d=uu*vv-uv*uv; d=1.0/d;
 a=(wu*vv-uv*wv)*d;
 b=(wv*uu-uv*wu)*d;
 x0=cf->x[vcfx]; y0=cf->y[vcfx];
 x1=cf->x[vcf1]; y1=cf->y[vcf1];
 x2=cf->x[vcf2]; y2=cf->y[vcf2];
 x4=x1+a*(x1-x0)+b*(x2-x1);
 y4=y1+a*(y1-y0)+b*(y2-y1);
 af->x[vafx]=x4; af->y[vafx]=y4;
 af->x[vaf1]=x1; af->y[vaf1]=y1;
 af->x[vaf2]=x2; af->y[vaf2]=y2;
}

static void WrapMapFromAdj(face *f, face *af[2]){
  int i,j,k;
  for(k=0;k<2;k++)for(i=0;i<3;i++)for(j=0;j<3;j++){
    if(f->V[i] == af[k]->V[j]){
      f->x[i]=af[k]->x[j];
      f->y[i]=af[k]->y[j];
    }
  }
}

static void WrapMapFrom(workface *w, long face_count){
 BOOL baj;
 int i,k,id,done=1,loop=1,ac,odone;
 face *cf[3],*af;
 while(done < face_count){
   odone=done; 
   for(k=0;k<face_count;k++){ 
     if(w[k].id != 0)continue; // already processed
     //fprintf(debug,"Processing face %ld (%ld)\n",w[k].f,k);
     af=(MainFp+w[k].f);
     for(baj=FALSE,ac=0,i=0;i<3;i++){
         if((id=w[k].fa[i]) >= 0)baj=TRUE; // adjacent to something
         if(id >= 0 && w[id].id == loop){
         //fprintf(debug,"face %ld(%ld)  adjacent to face %ld(%ld) in loop %ld\n",w[k].f,k, w[id].f, id, loop,w[id].id); 
         cf[ac]=(MainFp+w[id].f);  ac++;
       }
     }
     if(!baj)done++; // this is not adjacent to anything
     else if(ac > 1){  // this face is enclosed by already mapped faces and should have its mapping assigned from the adjacent
       WrapMapFromAdj(af,cf);
       w[k].id=loop+1;
       done++;
     }
     else if(ac == 1){  // one vertex to be assigned from its neighbours
       WrapMapExtraVertex(cf[0],af);
       w[k].id=loop+1;
       done++;
     }
   }
   loop++;
   if(done == odone)break; // we can only have one connected piece as indicated - omit the rest
 }
}

void WrapMapSelectedFaces(void){
 face *fp;
 long id=-1,i,face_count,*face_list, first_face;
 face_count=0; face_list=NULL;
 if(Nface == 0)return;
 if((id=IdentifyIndicatedFace()) < 0)return;  // identify the face with inside the cursor
//MessageBox(NULL,"Wrap selected faces with map from indicated","Wrap ?",MB_OK);
 for(i=0,fp=MainFp;i<Nface;i++,fp++){
   if((MainVp+fp->V[0])->status == SELECTED &&
      (MainVp+fp->V[1])->status == SELECTED &&
      (MainVp+fp->V[2])->status == SELECTED)face_count++;
 }
 face_list = (long *)X__Malloc((face_count)*sizeof(long));
 if(face_list == NULL)return;
 for(i=0,face_count=0,fp=MainFp;i<Nface;i++,fp++){
   if((MainVp+fp->V[0])->status == SELECTED &&
      (MainVp+fp->V[1])->status == SELECTED &&
      (MainVp+fp->V[2])->status == SELECTED){
     face_list[face_count]=i;
     if(i == id)first_face=face_count;
     face_count++;
   }
 }
 if(face_count > 0){
   workface *w;
   long j,f;
   w=NULL;
   if((w=(workface *)X__Malloc(face_count*(long)sizeof(workface)))
         == NULL)return;
   for(i=0;i<Nvert;i++)(MainVp+i)->id = 0;
   for(j=0;j<face_count;j++){
     f=w[j].f=face_list[j];
     O_Normalize((MainVp+((MainFp+f)->V[0]))->xyz,
                 (MainVp+((MainFp+f)->V[1]))->xyz,
                 (MainVp+((MainFp+f)->V[2]))->xyz,w[j].n); // make face normals
     for(i=0;i<3;i++){
       w[j].fa[i] = -1;
       (MainVp+(MainFp+w[j].f)->V[i])->id = -1;
     }
   }
   xFindAdjFaces(w,face_count);
   for(j=0;j<face_count;j++)w[j].id=0;
   // now start with the first face and process the mapping coordinates of the adjacent faces
   w[first_face].id=1;
   WrapMapFrom(w,face_count);
   if(w != NULL)X__Free(w);
 }
 X__Free(face_list);
}


void SplitSelectedAlongMaterialsMaps(void){
 HCURSOR hSave;
 vertex *vp,*V0,*V1,*V2;
 face   *fp;
 long   i,k,ncopy;
 long   x,y,z;
 long   Nvertex_list,*vertex_list;
 if(NvertSelect == 0 || (nMats == 0 && nImaps == 0) || Nface == 0)return;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return;
 }
 if((vertex_list = (long *)X__Malloc(NvertSelect*sizeof(long))) == NULL)return;
 Nvertex_list=NvertSelect;
 hSave=SetCursor(ghcurWait);
 for(i=0,k=0,vp=MainVp;i<Nvert;i++,vp++){  // make a list of all vertices involved
   if(vp->status == SELECTED){vertex_list[k]=i; k++;}
 }
 for(i=0;i<Nvertex_list;i++){
  (MainVp+vertex_list[i])->status=DESELECTED; NvertSelect--; NvertDeselect++;}
 
 //For all materials make copy of vertices edges and faces by marking them as selected.
 if(nMats > 0)for(k=0;k<nMats;k++){
   for(i=0,vp=MainVp;i<Nvert;i++,vp++){
     vp->id = -1; 
     if(vp->status == SELECTED){ vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
   }
   for(i=0;i<Nvertex_list;i++)(MainVp+vertex_list[i])->id=1; // Flag this vertex is to be part of the copied object;
   for(ncopy=0,fp=MainFp,i=0;i<Nface;i++){
     V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
     if(V0->id == 1 &&  V1->id == 1 &&  V2->id == 1 &&   // this vertex is part of the 
        fp->material >= 0 && fp->material == k){         // required material
       if(V0->status != SELECTED){V0->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V1->status != SELECTED){V1->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V2->status != SELECTED){V2->status=SELECTED; NvertSelect++; NvertDeselect--;}
       ncopy++;
    }       
    fp++;
  }
  if(ncopy > 0)AddCopy(0);
 }

 //For all image maps make copy of vertices edges and faces by marking them as selected.
 if(nImaps > 0)for(k=0;k<nImaps;k++){
   for(i=0,vp=MainVp;i<Nvert;i++,vp++){
     vp->id = -1; 
     if(vp->status == SELECTED){ vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
   }
   for(i=0;i<Nvertex_list;i++)(MainVp+vertex_list[i])->id=1; // Flag this vertex is to be part of the copied object;
   for(ncopy=0,fp=MainFp,i=0;i<Nface;i++){
     V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
     if(V0->id == 1 &&  V1->id == 1 &&  V2->id == 1 &&   // this vertex is part of the 
        fp->imagemap >= 0 && fp->imagemap == k){         // required map
       if(V0->status != SELECTED){V0->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V1->status != SELECTED){V1->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V2->status != SELECTED){V2->status=SELECTED; NvertSelect++; NvertDeselect--;}
       ncopy++;
    }       
    fp++;
  }
  if(ncopy > 0)AddCopy(0);
 }

 //For all faces without ANY map or material
 for(i=0,vp=MainVp;i<Nvert;i++,vp++){
   vp->id = -1; 
   if(vp->status == SELECTED){ vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
 }
 for(i=0;i<Nvertex_list;i++)(MainVp+vertex_list[i])->id=1; // Flag this vertex is to be part of the copied object;
 for(ncopy=0,fp=MainFp,i=0;i<Nface;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(V0->id == 1 &&  V1->id == 1 &&  V2->id == 1 &&  // this vertex has no map
      fp->imagemap < 0 && fp->material < 0){          // or material
       if(V0->status != SELECTED){V0->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V1->status != SELECTED){V1->status=SELECTED; NvertSelect++; NvertDeselect--;}
       if(V2->status != SELECTED){V2->status=SELECTED; NvertSelect++; NvertDeselect--;}
       ncopy++;
    }       
    fp++;
 }
 if(ncopy > 0)AddCopy(0);

 // reset the selection status to the original and remove the original vertices 
 for(i=0,vp=MainVp;i<Nvert;i++,vp++){
   vp->id = -1; 
   if(vp->status == SELECTED){ vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
 }
 for(i=0;i<Nvertex_list;i++){
   (MainVp+vertex_list[i])->status=SELECTED;
   NvertSelect++; NvertDeselect--;
 }
 EraseVertex(YES); 
 X__Free(vertex_list);
 SetCursor(hSave);
}

void GrowSelectedAlongNormal(void){ // expand along the normal vector for each vertex
 HCURSOR hSave;
 vertex *vp,*V0,*V1,*V2;
 face   *fp;
 BOOL   bGo=FALSE;
 long   i,k;
 long   x,y,z;
 long   Nvertex_list;
 double grow_factor=1.0; // in units of ruler
 struct vector_list {vector vn; vertex * vp; long c;} *vertex_list;
 vector nv,a,b;
 if(NvertSelect < 3)return;
 if(Read1Real("Grow By","Factor (Current Units)",&grow_factor,-100.0,100.0,ghwnd_main) == FAIL)return;
 if((vertex_list = (struct vector_list *)X__Malloc(NvertSelect*sizeof(struct vector_list))) == NULL)return;
 Nvertex_list=NvertSelect;
 Save_Undo(1);
 grow_factor *= ruler;  // scale to ruler
 hSave=SetCursor(ghcurWait);
 for(i=0,k=0,vp=MainVp;i<Nvert;i++,vp++){  // make a list of all vertices involved
   if(vp->status == SELECTED){
     vp->id=k;  // vertex identifier to vertex_list
     vertex_list[k].c=0; 
     vertex_list[k].vp=vp; 
     vertex_list[k].vn[0]=vertex_list[k].vn[1]=vertex_list[k].vn[2]=0.0;
     k++;
   }
 }
 for(fp=MainFp,i=0;i<Nface;i++,fp++){  // get the vertex average normals of all faces connected to vertex
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(V0->status == SELECTED && V0->status == SELECTED && V0->status == SELECTED){
     VECSUB((double)V1->xyz,(double)V0->xyz,a)
     VECSUB((double)V2->xyz,(double)V0->xyz,b)
     CROSS(a,b,nv)
     if(O_normalize(nv) == OK){
       k=V0->id; VECSUM(vertex_list[k].vn,nv,vertex_list[k].vn) vertex_list[k].c += 1;  
       k=V1->id; VECSUM(vertex_list[k].vn,nv,vertex_list[k].vn) vertex_list[k].c += 1;  
       k=V2->id; VECSUM(vertex_list[k].vn,nv,vertex_list[k].vn) vertex_list[k].c += 1;  
       bGo=TRUE;
     }
   }  
 }
 if(bGo){
   for(i=0;i<Nvertex_list;i++){
     if(vertex_list[i].c > 0){ // scale normals
       VECSCALE(1.0/(double)vertex_list[i].c,vertex_list[i].vn,vertex_list[i].vn)
     }
     else{
       vertex_list[i].vn[0]=vertex_list[i].vn[1]=vertex_list[i].vn[2]=0.0;
     }
   }
   for(i=0;i<Nvertex_list;i++)if(vertex_list[i].c > 0){ // apply
     vp=vertex_list[i].vp;
     VECSUM(vp->xyz,grow_factor*vertex_list[i].vn,vp->xyz)   
   }
 }
 X__Free(vertex_list);
 SetCursor(hSave);
}