Ejemplo n.º 1
0
float CalcBox(Face *f, Point3 *v, Line *Lc, UG *G,
				IntPoint3 *vn, IntPoint3 *vp, float Radius)
{
 Point3 BoxCenter;
 float FaceRadius;
 float offset;

 FaceRadius=V3DistanceBetween2Points(&(Lc->Lu), &(v[f->v[0]]));

 offset=sqrt(Radius*Radius - FaceRadius*FaceRadius);

 BoxCenter.x=Lc->Lu.x+Lc->Lv.x*offset;
 BoxCenter.y=Lc->Lu.y+Lc->Lv.y*offset;
 BoxCenter.z=Lc->Lu.z+Lc->Lv.z*offset;

 vn->x = (int)((BoxCenter.x - G->vn.x - Radius)/G->side);
 vn->y = (int)((BoxCenter.y - G->vn.y - Radius)/G->side);
 vn->z = (int)((BoxCenter.z - G->vn.z - Radius)/G->side);

 vp->x = (int)((BoxCenter.x - G->vn.x + Radius)/G->side);
 vp->y = (int)((BoxCenter.y - G->vn.y + Radius)/G->side);
 vp->z = (int)((BoxCenter.z - G->vn.z + Radius)/G->side);

 vn->x=max(0,vn->x);
 vn->y=max(0,vn->y);
 vn->z=max(0,vn->z);
 vp->x=min(G->x-1,vp->x);
 vp->y=min(G->y-1,vp->y);
 vp->z=min(G->z-1,vp->z);

 return(Radius*Radius);
}
Ejemplo n.º 2
0
Tetra *MakeTetra(Face *f,Point3 *v[], int n)
{
 Plane p,Mp;
 boolean found=FALSE;
 double Radius=BIGNUMBER,  rad;
 Line Lc;
 int pind=0;
 Tetra *t;
 Point3 Center, c;
 int i;

 if(!CalcPlane(f->v[0],f->v[1],f->v[2],&p))
		Error("MakeTetra, Face with collinar vertices!\n",EXIT);

 CalcLineofCenter(f->v[0],f->v[1],f->v[2],&Lc);

 for(i=0;i<n;i++)
 {
  if((v[i]!=f->v[0]) &&
     (v[i]!=f->v[1]) &&
     (v[i]!=f->v[2]) &&
     RightSide(&p,v[i]) )
		{
		 CalcMiddlePlane(v[i],f->v[0],&Mp);
		 if(CalcLinePlaneInter(&Lc,&Mp,&c))
		      {
			rad=V3SquaredDistanceBetween2Points(&c, v[i]);

			if(!RightSide(&p,&c)) rad=-rad;
			if(rad==Radius) Error("MakeTetra, Five cocircular points!\n",EXIT);
			if(rad<Radius)
				{
				 found=TRUE;
				 Radius=rad;
				 Center=c;
				 pind=i;
				}
		      }
		}
 }

 if(!found) return NULL;

 t=BuildTetra(f,v[pind]);

 if(CheckFlag)	CheckTetra(t,v,n);

 if(StatFlag)
 {Point3 C;
  CalcSphereCenter(f->v[0], f->v[1], f->v[2], v[pind], &C);
  SI.Radius+=V3DistanceBetween2Points(&C, v[pind]);
 }

 return t;
}
Ejemplo n.º 3
0
void CheckTetra(Tetra *t, Point3 *v[], int n)
{
 int i;
 Point3 Center;
 double Radius;
 double d;

 if(!CalcSphereCenter(t->f[0]->v[0],
		      t->f[0]->v[1],
		      t->f[0]->v[2],
		      t->f[1]->v[1], &Center ))
			  Error("CheckTetra, Bad Tetrahedron, CalcSphereCenter Failed!\n",EXIT);

 Radius = V3DistanceBetween2Points(&Center, t->f[0]->v[0]);
 for(i=0;i<n;i++)
 {
   d=V3DistanceBetween2Points(&Center,v[i]);
   if( d < Radius - EPSILON)
     Error("CheckTetra, A not Delaunay Tetrahedron was built!\n",EXIT);
 }
}
Ejemplo n.º 4
0
Tetra *FirstTetra(Point3 *v[], int n)
{
 int i, MinIndex=0;
 double Radius, MinRadius=BIGNUMBER;

 Tetra *t;
 Plane p[3], Mp;
 Line Lc;
 Face f;
 Point3 c;

 boolean found=FALSE;

 f.v[0]=v[n/2-1];	/* The first point of the face is the	*/
			/* nearest to middle plane in negative	*/
			/* halfspace.				*/

			/* The 2nd point of the face is the	*/
			/* euclidean nearest to first point	*/
 for(i=n/2;i<n;i++)	/* that is in the positive halfspace	*/
    {
     Radius=V3SquaredDistanceBetween2Points(f.v[0], v[i]);
     if(Radius<MinRadius)
	{
	 MinRadius=Radius;
	 MinIndex=i;
	}
    }

 f.v[1]=v[MinIndex];
			/* The 3rd point is that with previous	*/
			/* ones builds the smallest circle.	*/

 CalcMiddlePlane(f.v[0],f.v[1], &(p[0]));

 MinRadius=BIGNUMBER;

 for(i=0;i<n;i++)
  if(v[i]!=f.v[0] && v[i]!=f.v[1])
   {
    CalcMiddlePlane(f.v[0], v[i],&(p[1]));
    if(CalcPlane(f.v[0],f.v[1],v[i],&(p[2])))
      if(CalcPlaneInter(&(p[0]), &(p[1]), &(p[2]), &c))
	{
	 Radius=V3DistanceBetween2Points(&c, f.v[0]);
	  if(Radius<MinRadius)
		{
		 MinRadius=Radius;
		 MinIndex=i;
		}
	}
   }

 f.v[2]=v[MinIndex];


 /* The first tetrahedron construction is analogous to normal */
 /* MakeTetra, only we dont limit search to an halfspace.     */

 MinRadius=BIGNUMBER;

 CalcPlane(f.v[0], f.v[1], f.v[2],&p[0]);
 CalcLineofCenter(f.v[0], f.v[1], f.v[2], &Lc);

 for(i=0;i<n;i++)
  if(v[i]!=f.v[0] && v[i]!=f.v[1] && v[i]!=f.v[2] )
   {
    CalcMiddlePlane(v[i], f.v[0], &Mp);
    if(CalcLinePlaneInter(&Lc, &Mp, &c))
	 {
	   Radius=V3SquaredDistanceBetween2Points(&c, v[i]);

	   if(MinRadius==Radius) Error("FirstTetra, Five cocircular points!\n",EXIT);
	   if(Radius<MinRadius)
		   {
		    found=TRUE;
		    MinRadius=Radius;
		    MinIndex=i;
		   }
	 }
   }

 if(!found) Error("FirstTetra, Planar dataset, unable to build first tetrahedron.\n",EXIT);

 if(!RightSide(&p[0],v[MinIndex]))	ReverseFace(&f);

 t=BuildTetra(&f, v[MinIndex]);

 CheckTetra(t,v,n);

 ReverseFace(t->f[0]); /* First Face in first Tetra   */
		       /* must be outward oriented    */
 return t;

}
Ejemplo n.º 5
0
Tetra *FastMakeTetra(Face *f, Point3 *v, int n, UG *G)
{
 Plane p;
 Tetra *t;
 float CellBoxRadius= 0.0,	/* Radius of Cell Box to scan for dd-nearest */
	BoxRadius,
	FaceRadius,
	MinRadius=BIGNUMBER;

 struct argGroup args;
 Line Lc;
 IntPoint3 vn,vp, start, end, inc;
 int Index=-1;
 boolean Found=FALSE;

 SI.MakeTetra++;

 UGResetMark(G);

 if(!CalcPlane(&(v[f->v[0]]),&(v[f->v[1]]),&(v[f->v[2]]),&p))
		Error("Faccia composta da tre punti allineati!!\n",EXIT);

 CalcLineofCenter(&(v[f->v[0]]),&(v[f->v[1]]),&(v[f->v[2]]),&Lc);

 FaceRadius=V3DistanceBetween2Points(&(Lc.Lu), &(v[f->v[0]]));

  args.f = f;
  args.Lc = &Lc;
  args.p = &p; 
  args.G = G;
 // printf("checkpoint 0\n");
 do
 {
  CellBoxRadius++;
  BoxRadius=CalcBox(f,v,&Lc,G,&vn,&vp, CellBoxRadius*FaceRadius);

  Found=ScanCellBox(&vn, &vp, v,&args,&Index, &MinRadius);
 }
 while(!Found && CellBoxRadius <= 1);
 //printf("checkpoint 1\n");
// printf("MinRadius = %f BoxRadius = %f\n",MinRadius, BoxRadius);
 if(Found && MinRadius>BoxRadius)
 {float oldMinRadius=MinRadius;

  SI.SecondBox++;
//  printf("f->v[0] = %d, f->v[1] = %d, f->v[2] = %d, sqrt(MinRadius) = %f\n",f->v[0],f->v[1],f->v[2], sqrt(MinRadius));
  BoxRadius=CalcBox(f,v,&Lc,G,&vn,&vp, sqrt(MinRadius));
 // printf("checkpoint 2\n");
//printf("vn->x = %d ,vn->y = %d, vn->z = %d, vp->x = %d, vp->y = %d, vp->z = %d, radius = %f\n",vn.x, vn.y, vn.z, vp.x, vp.y,vp.z,MinRadius);


  ScanCellBox(&vn, &vp, v, &args, &Index, &MinRadius);
   //printf("checkpoint 2.1\n");
  if(oldMinRadius>MinRadius) SI.UsefulSecondBox++;
 }
 
 if(!Found)
 {
  //printf("checkpoint 3\n");
  SI.EmptyBox++;
  CalcLastScan(G, &start, &end, &inc, &p);
  //printf("checkpoint 4\n"); 
  Found=MakeLastScan(&start, &end, &inc, v, &args, &Index,&MinRadius);
 }
 //printf("chekpoint 5\n");
 if(!Found) return NULL;
 if(MinRadius>0)
 {
  SI.MinRadius+=sqrt(MinRadius);
  SI.MinRadiusNum++;
 }


 t=BuildTetra(f,Index);
 if(StatFlag)
 {Point3 C;
  CalcSphereCenter(&(v[f->v[0]]),&(v[f->v[1]]),&(v[f->v[2]]),&(v[Index]),&C);
  SI.Radius+=V3DistanceBetween2Points(&C, &(v[Index]));
 }
 if(CheckFlag)  CheckTetra(t,v,n);

 return t;
}