有关Triangle的计算

最新推荐文章于 2022-02-25 19:38:17 发布
最新推荐文章于 2022-02-25 19:38:17 发布
阅读量782 收藏
点赞数
分类专栏： COMPUTATION GEOMETRY 文章标签： float intervals n2 up c parameters

 /* Triangle/triangle intersection test routine,
 * by Tomas Moller, 1997.
 * See article "A Fast Triangle-Triangle Intersection Test",
 * Journal of Graphics Tools, 2(2), 1997
 * updated: 2001-06-20 (added line of intersection)
 *
 * int tri_tri_intersect(float V0[3],float V1[3],float V2[3],
 *                       float U0[3],float U1[3],float U2[3])
 *
 * parameters: vertices of triangle 1: V0,V1,V2
 *             vertices of triangle 2: U0,U1,U2
 * result    : returns 1 if the triangles intersect, otherwise 0
 *
 * Here is a version withouts divisions (a little faster)
 * int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
 *                      float U0[3],float U1[3],float U2[3]);
 *
 * This version computes the line of intersection as well (if they are not coplanar):
 * int tri_tri_intersect_with_isectline(float V0[3],float V1[3],float V2[3],
 *            float U0[3],float U1[3],float U2[3],int *coplanar,
 *            float isectpt1[3],float isectpt2[3]);
 * coplanar returns whether the tris are coplanar
 * isectpt1, isectpt2 are the endpoints of the line of intersection
 */

#include <math.h>

#define FABS(x) ((float)fabs(x))        /* implement as is fastest on your machine */

/* if USE_EPSILON_TEST is true then we do a check:
         if |dv|<EPSILON then dv=0.0;
   else no check is done (which is less robust)
*/
#define USE_EPSILON_TEST TRUE
#define EPSILON 0.000001


/* some macros */
#define CROSS(dest,v1,v2)                      /
              dest[0]=v1[1]*v2[2]-v1[2]*v2[1]; /
              dest[1]=v1[2]*v2[0]-v1[0]*v2[2]; /
              dest[2]=v1[0]*v2[1]-v1[1]*v2[0];

#define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])

#define SUB(dest,v1,v2) dest[0]=v1[0]-v2[0]; dest[1]=v1[1]-v2[1]; dest[2]=v1[2]-v2[2];

#define ADD(dest,v1,v2) dest[0]=v1[0]+v2[0]; dest[1]=v1[1]+v2[1]; dest[2]=v1[2]+v2[2];

#define MULT(dest,v,factor) dest[0]=factor*v[0]; dest[1]=factor*v[1]; dest[2]=factor*v[2];

#define SET(dest,src) dest[0]=src[0]; dest[1]=src[1]; dest[2]=src[2];

/* sort so that a<=b */
#define SORT(a,b)       /
             if(a>b)    /
             {          /
               float c; /
               c=a;     /
               a=b;     /
               b=c;     /
             }

#define ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1) /
              isect0=VV0+(VV1-VV0)*D0/(D0-D1);    /
              isect1=VV0+(VV2-VV0)*D0/(D0-D2);


#define COMPUTE_INTERVALS(VV0,VV1,VV2,D0,D1,D2,D0D1,D0D2,isect0,isect1) /
  if(D0D1>0.0f)                                         /
  {                                                     /
    /* here we know that D0D2<=0.0 */                   /
    /* that is D0, D1 are on the same side, D2 on the other or on the plane */ /
    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          /
  }                                                     /
  else if(D0D2>0.0f)                                    /
  {                                                     /
    /* here we know that d0d1<=0.0 */                   /
    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          /
  }                                                     /
  else if(D1*D2>0.0f || D0!=0.0f)                       /
  {                                                     /
    /* here we know that d0d1<=0.0 or that D0!=0.0 */   /
    ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1);          /
  }                                                     /
  else if(D1!=0.0f)                                     /
  {                                                     /
    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          /
  }                                                     /
  else if(D2!=0.0f)                                     /
  {                                                     /
    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          /
  }                                                     /
  else                                                  /
  {                                                     /
    /* triangles are coplanar */                        /
    return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2);      /
  }

 

/* this edge to edge test is based on Franlin Antonio's gem:
   "Faster Line Segment Intersection", in Graphics Gems III,
   pp. 199-202 */
#define EDGE_EDGE_TEST(V0,U0,U1)                      /
  Bx=U0[i0]-U1[i0];                                   /
  By=U0[i1]-U1[i1];                                   /
  Cx=V0[i0]-U0[i0];                                   /
  Cy=V0[i1]-U0[i1];                                   /
  f=Ay*Bx-Ax*By;                                      /
  d=By*Cx-Bx*Cy;                                      /
  if((f>0 && d>=0 && d<=f) || (f<0 && d<=0 && d>=f))  /
  {                                                   /
    e=Ax*Cy-Ay*Cx;                                    /
    if(f>0)                                           /
    {                                                 /
      if(e>=0 && e<=f) return 1;                      /
    }                                                 /
    else                                              /
    {                                                 /
      if(e<=0 && e>=f) return 1;                      /
    }                                                 /
  }

#define EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2) /
{                                              /
  float Ax,Ay,Bx,By,Cx,Cy,e,d,f;               /
  Ax=V1[i0]-V0[i0];                            /
  Ay=V1[i1]-V0[i1];                            /
  /* test edge U0,U1 against V0,V1 */          /
  EDGE_EDGE_TEST(V0,U0,U1);                    /
  /* test edge U1,U2 against V0,V1 */          /
  EDGE_EDGE_TEST(V0,U1,U2);                    /
  /* test edge U2,U1 against V0,V1 */          /
  EDGE_EDGE_TEST(V0,U2,U0);                    /
}

#define POINT_IN_TRI(V0,U0,U1,U2)           /
{                                           /
  float a,b,c,d0,d1,d2;                     /
  /* is T1 completly inside T2? */          /
  /* check if V0 is inside tri(U0,U1,U2) */ /
  a=U1[i1]-U0[i1];                          /
  b=-(U1[i0]-U0[i0]);                       /
  c=-a*U0[i0]-b*U0[i1];                     /
  d0=a*V0[i0]+b*V0[i1]+c;                   /
                                            /
  a=U2[i1]-U1[i1];                          /
  b=-(U2[i0]-U1[i0]);                       /
  c=-a*U1[i0]-b*U1[i1];                     /
  d1=a*V0[i0]+b*V0[i1]+c;                   /
                                            /
  a=U0[i1]-U2[i1];                          /
  b=-(U0[i0]-U2[i0]);                       /
  c=-a*U2[i0]-b*U2[i1];                     /
  d2=a*V0[i0]+b*V0[i1]+c;                   /
  if(d0*d1>0.0)                             /
  {                                         /
    if(d0*d2>0.0) return 1;                 /
  }                                         /
}

int coplanar_tri_tri(float N[3],float V0[3],float V1[3],float V2[3],
                     float U0[3],float U1[3],float U2[3])
{
   float A[3];
   short i0,i1;
   /* first project onto an axis-aligned plane, that maximizes the area */
   /* of the triangles, compute indices: i0,i1. */
   A[0]=fabs(N[0]);
   A[1]=fabs(N[1]);
   A[2]=fabs(N[2]);
   if(A[0]>A[1])
   {
      if(A[0]>A[2])
      {
          i0=1;      /* A[0] is greatest */
          i1=2;
      }
      else
      {
          i0=0;      /* A[2] is greatest */
          i1=1;
      }
   }
   else   /* A[0]<=A[1] */
   {
      if(A[2]>A[1])
      {
          i0=0;      /* A[2] is greatest */
          i1=1;
      }
      else
      {
          i0=0;      /* A[1] is greatest */
          i1=2;
      }
    }

    /* test all edges of triangle 1 against the edges of triangle 2 */
    EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2);
    EDGE_AGAINST_TRI_EDGES(V1,V2,U0,U1,U2);
    EDGE_AGAINST_TRI_EDGES(V2,V0,U0,U1,U2);

    /* finally, test if tri1 is totally contained in tri2 or vice versa */
    POINT_IN_TRI(V0,U0,U1,U2);
    POINT_IN_TRI(U0,V0,V1,V2);

    return 0;
}


int tri_tri_intersect(float V0[3],float V1[3],float V2[3],
                      float U0[3],float U1[3],float U2[3])
{
  float E1[3],E2[3];
  float N1[3],N2[3],d1,d2;
  float du0,du1,du2,dv0,dv1,dv2;
  float D[3];
  float isect1[2], isect2[2];
  float du0du1,du0du2,dv0dv1,dv0dv2;
  short index;
  float vp0,vp1,vp2;
  float up0,up1,up2;
  float b,c,max;

  /* compute plane equation of triangle(V0,V1,V2) */
  SUB(E1,V1,V0);
  SUB(E2,V2,V0);
  CROSS(N1,E1,E2);
  d1=-DOT(N1,V0);
  /* plane equation 1: N1.X+d1=0 */

  /* put U0,U1,U2 into plane equation 1 to compute signed distances to the plane*/
  du0=DOT(N1,U0)+d1;
  du1=DOT(N1,U1)+d1;
  du2=DOT(N1,U2)+d1;

  /* coplanarity robustness check */
#if USE_EPSILON_TEST==TRUE
  if(fabs(du0)<EPSILON) du0=0.0;
  if(fabs(du1)<EPSILON) du1=0.0;
  if(fabs(du2)<EPSILON) du2=0.0;
#endif
  du0du1=du0*du1;
  du0du2=du0*du2;

  if(du0du1>0.0f && du0du2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute plane of triangle (U0,U1,U2) */
  SUB(E1,U1,U0);
  SUB(E2,U2,U0);
  CROSS(N2,E1,E2);
  d2=-DOT(N2,U0);
  /* plane equation 2: N2.X+d2=0 */

  /* put V0,V1,V2 into plane equation 2 */
  dv0=DOT(N2,V0)+d2;
  dv1=DOT(N2,V1)+d2;
  dv2=DOT(N2,V2)+d2;

#if USE_EPSILON_TEST==TRUE
  if(fabs(dv0)<EPSILON) dv0=0.0;
  if(fabs(dv1)<EPSILON) dv1=0.0;
  if(fabs(dv2)<EPSILON) dv2=0.0;
#endif

  dv0dv1=dv0*dv1;
  dv0dv2=dv0*dv2;

  if(dv0dv1>0.0f && dv0dv2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute direction of intersection line */
  CROSS(D,N1,N2);

  /* compute and index to the largest component of D */
  max=fabs(D[0]);
  index=0;
  b=fabs(D[1]);
  c=fabs(D[2]);
  if(b>max) max=b,index=1;
  if(c>max) max=c,index=2;

  /* this is the simplified projection onto L*/
  vp0=V0[index];
  vp1=V1[index];
  vp2=V2[index];

  up0=U0[index];
  up1=U1[index];
  up2=U2[index];

  /* compute interval for triangle 1 */
  COMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,isect1[0],isect1[1]);

  /* compute interval for triangle 2 */
  COMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,isect2[0],isect2[1]);

  SORT(isect1[0],isect1[1]);
  SORT(isect2[0],isect2[1]);

  if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return 0;
  return 1;
}


#define NEWCOMPUTE_INTERVALS(VV0,VV1,VV2,D0,D1,D2,D0D1,D0D2,A,B,C,X0,X1) /
{ /
        if(D0D1>0.0f) /
        { /
                /* here we know that D0D2<=0.0 */ /
            /* that is D0, D1 are on the same side, D2 on the other or on the plane */ /
                A=VV2; B=(VV0-VV2)*D2; C=(VV1-VV2)*D2; X0=D2-D0; X1=D2-D1; /
        } /
        else if(D0D2>0.0f)/
        { /
                /* here we know that d0d1<=0.0 */ /
            A=VV1; B=(VV0-VV1)*D1; C=(VV2-VV1)*D1; X0=D1-D0; X1=D1-D2; /
        } /
        else if(D1*D2>0.0f || D0!=0.0f) /
        { /
                /* here we know that d0d1<=0.0 or that D0!=0.0 */ /
                A=VV0; B=(VV1-VV0)*D0; C=(VV2-VV0)*D0; X0=D0-D1; X1=D0-D2; /
        } /
        else if(D1!=0.0f) /
        { /
                A=VV1; B=(VV0-VV1)*D1; C=(VV2-VV1)*D1; X0=D1-D0; X1=D1-D2; /
        } /
        else if(D2!=0.0f) /
        { /
                A=VV2; B=(VV0-VV2)*D2; C=(VV1-VV2)*D2; X0=D2-D0; X1=D2-D1; /
        } /
        else /
        { /
                /* triangles are coplanar */ /
                return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2); /
        } /
}

 

int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
                     float U0[3],float U1[3],float U2[3])
{
  float E1[3],E2[3];
  float N1[3],N2[3],d1,d2;
  float du0,du1,du2,dv0,dv1,dv2;
  float D[3];
  float isect1[2], isect2[2];
  float du0du1,du0du2,dv0dv1,dv0dv2;
  short index;
  float vp0,vp1,vp2;
  float up0,up1,up2;
  float bb,cc,max;
  float a,b,c,x0,x1;
  float d,e,f,y0,y1;
  float xx,yy,xxyy,tmp;

  /* compute plane equation of triangle(V0,V1,V2) */
  SUB(E1,V1,V0);
  SUB(E2,V2,V0);
  CROSS(N1,E1,E2);
  d1=-DOT(N1,V0);
  /* plane equation 1: N1.X+d1=0 */

  /* put U0,U1,U2 into plane equation 1 to compute signed distances to the plane*/
  du0=DOT(N1,U0)+d1;
  du1=DOT(N1,U1)+d1;
  du2=DOT(N1,U2)+d1;

  /* coplanarity robustness check */
#if USE_EPSILON_TEST==TRUE
  if(FABS(du0)<EPSILON) du0=0.0;
  if(FABS(du1)<EPSILON) du1=0.0;
  if(FABS(du2)<EPSILON) du2=0.0;
#endif
  du0du1=du0*du1;
  du0du2=du0*du2;

  if(du0du1>0.0f && du0du2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute plane of triangle (U0,U1,U2) */
  SUB(E1,U1,U0);
  SUB(E2,U2,U0);
  CROSS(N2,E1,E2);
  d2=-DOT(N2,U0);
  /* plane equation 2: N2.X+d2=0 */

  /* put V0,V1,V2 into plane equation 2 */
  dv0=DOT(N2,V0)+d2;
  dv1=DOT(N2,V1)+d2;
  dv2=DOT(N2,V2)+d2;

#if USE_EPSILON_TEST==TRUE
  if(FABS(dv0)<EPSILON) dv0=0.0;
  if(FABS(dv1)<EPSILON) dv1=0.0;
  if(FABS(dv2)<EPSILON) dv2=0.0;
#endif

  dv0dv1=dv0*dv1;
  dv0dv2=dv0*dv2;

  if(dv0dv1>0.0f && dv0dv2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute direction of intersection line */
  CROSS(D,N1,N2);

  /* compute and index to the largest component of D */
  max=(float)FABS(D[0]);
  index=0;
  bb=(float)FABS(D[1]);
  cc=(float)FABS(D[2]);
  if(bb>max) max=bb,index=1;
  if(cc>max) max=cc,index=2;

  /* this is the simplified projection onto L*/
  vp0=V0[index];
  vp1=V1[index];
  vp2=V2[index];

  up0=U0[index];
  up1=U1[index];
  up2=U2[index];

  /* compute interval for triangle 1 */
  NEWCOMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,a,b,c,x0,x1);

  /* compute interval for triangle 2 */
  NEWCOMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,d,e,f,y0,y1);

  xx=x0*x1;
  yy=y0*y1;
  xxyy=xx*yy;

  tmp=a*xxyy;
  isect1[0]=tmp+b*x1*yy;
  isect1[1]=tmp+c*x0*yy;

  tmp=d*xxyy;
  isect2[0]=tmp+e*xx*y1;
  isect2[1]=tmp+f*xx*y0;

  SORT(isect1[0],isect1[1]);
  SORT(isect2[0],isect2[1]);

  if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return 0;
  return 1;
}

/* sort so that a<=b */
#define SORT2(a,b,smallest)       /
             if(a>b)       /
             {             /
               float c;    /
               c=a;        /
               a=b;        /
               b=c;        /
               smallest=1; /
             }             /
             else smallest=0;


inline void isect2(float VTX0[3],float VTX1[3],float VTX2[3],float VV0,float VV1,float VV2,
     float D0,float D1,float D2,float *isect0,float *isect1,float isectpoint0[3],float isectpoint1[3])
{
  float tmp=D0/(D0-D1);
  float diff[3];
  *isect0=VV0+(VV1-VV0)*tmp;
  SUB(diff,VTX1,VTX0);
  MULT(diff,diff,tmp);
  ADD(isectpoint0,diff,VTX0);
  tmp=D0/(D0-D2);
  *isect1=VV0+(VV2-VV0)*tmp;
  SUB(diff,VTX2,VTX0);
  MULT(diff,diff,tmp);
  ADD(isectpoint1,VTX0,diff);
}


#if 0
#define ISECT2(VTX0,VTX1,VTX2,VV0,VV1,VV2,D0,D1,D2,isect0,isect1,isectpoint0,isectpoint1) /
              tmp=D0/(D0-D1);                    /
              isect0=VV0+(VV1-VV0)*tmp;          /
       SUB(diff,VTX1,VTX0);               /
       MULT(diff,diff,tmp);               /
              ADD(isectpoint0,diff,VTX0);        /
              tmp=D0/(D0-D2);
/*              isect1=VV0+(VV2-VV0)*tmp;          / */
/*              SUB(diff,VTX2,VTX0);               /     */
/*              MULT(diff,diff,tmp);               /   */
/*              ADD(isectpoint1,VTX0,diff);           */
#endif

inline int compute_intervals_isectline(float VERT0[3],float VERT1[3],float VERT2[3],
           float VV0,float VV1,float VV2,float D0,float D1,float D2,
           float D0D1,float D0D2,float *isect0,float *isect1,
           float isectpoint0[3],float isectpoint1[3])
{
  if(D0D1>0.0f)
  {
    /* here we know that D0D2<=0.0 */
    /* that is D0, D1 are on the same side, D2 on the other or on the plane */
    isect2(VERT2,VERT0,VERT1,VV2,VV0,VV1,D2,D0,D1,isect0,isect1,isectpoint0,isectpoint1);
  }
  else if(D0D2>0.0f)
    {
    /* here we know that d0d1<=0.0 */
    isect2(VERT1,VERT0,VERT2,VV1,VV0,VV2,D1,D0,D2,isect0,isect1,isectpoint0,isectpoint1);
  }
  else if(D1*D2>0.0f || D0!=0.0f)
  {
    /* here we know that d0d1<=0.0 or that D0!=0.0 */
    isect2(VERT0,VERT1,VERT2,VV0,VV1,VV2,D0,D1,D2,isect0,isect1,isectpoint0,isectpoint1);
  }
  else if(D1!=0.0f)
  {
    isect2(VERT1,VERT0,VERT2,VV1,VV0,VV2,D1,D0,D2,isect0,isect1,isectpoint0,isectpoint1);
  }
  else if(D2!=0.0f)
  {
    isect2(VERT2,VERT0,VERT1,VV2,VV0,VV1,D2,D0,D1,isect0,isect1,isectpoint0,isectpoint1);
  }
  else
  {
    /* triangles are coplanar */
    return 1;
  }
  return 0;
}

#define COMPUTE_INTERVALS_ISECTLINE(VERT0,VERT1,VERT2,VV0,VV1,VV2,D0,D1,D2,D0D1,D0D2,isect0,isect1,isectpoint0,isectpoint1) /
  if(D0D1>0.0f)                                         /
  {                                                     /
    /* here we know that D0D2<=0.0 */                   /
    /* that is D0, D1 are on the same side, D2 on the other or on the plane */ /
    isect2(VERT2,VERT0,VERT1,VV2,VV0,VV1,D2,D0,D1,&isect0,&isect1,isectpoint0,isectpoint1);          /
  }
#if 0
  else if(D0D2>0.0f)                                    /
  {                                                     /
    /* here we know that d0d1<=0.0 */                   /
    isect2(VERT1,VERT0,VERT2,VV1,VV0,VV2,D1,D0,D2,&isect0,&isect1,isectpoint0,isectpoint1);          /
  }                                                     /
  else if(D1*D2>0.0f || D0!=0.0f)                       /
  {                                                     /
    /* here we know that d0d1<=0.0 or that D0!=0.0 */   /
    isect2(VERT0,VERT1,VERT2,VV0,VV1,VV2,D0,D1,D2,&isect0,&isect1,isectpoint0,isectpoint1);          /
  }                                                     /
  else if(D1!=0.0f)                                     /
  {                                                     /
    isect2(VERT1,VERT0,VERT2,VV1,VV0,VV2,D1,D0,D2,&isect0,&isect1,isectpoint0,isectpoint1);          /
  }                                                     /
  else if(D2!=0.0f)                                     /
  {                                                     /
    isect2(VERT2,VERT0,VERT1,VV2,VV0,VV1,D2,D0,D1,&isect0,&isect1,isectpoint0,isectpoint1);          /
  }                                                     /
  else                                                  /
  {                                                     /
    /* triangles are coplanar */                        /
    coplanar=1;                                         /
    return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2);      /
  }
#endif

int tri_tri_intersect_with_isectline(float V0[3],float V1[3],float V2[3],
         float U0[3],float U1[3],float U2[3],int *coplanar,
         float isectpt1[3],float isectpt2[3])
{
  float E1[3],E2[3];
  float N1[3],N2[3],d1,d2;
  float du0,du1,du2,dv0,dv1,dv2;
  float D[3];
  float isect1[2], isect2[2];
  float isectpointA1[3],isectpointA2[3];
  float isectpointB1[3],isectpointB2[3];
  float du0du1,du0du2,dv0dv1,dv0dv2;
  short index;
  float vp0,vp1,vp2;
  float up0,up1,up2;
  float b,c,max;
  float tmp,diff[3];
  int smallest1,smallest2;

  /* compute plane equation of triangle(V0,V1,V2) */
  SUB(E1,V1,V0);
  SUB(E2,V2,V0);
  CROSS(N1,E1,E2);
  d1=-DOT(N1,V0);
  /* plane equation 1: N1.X+d1=0 */

  /* put U0,U1,U2 into plane equation 1 to compute signed distances to the plane*/
  du0=DOT(N1,U0)+d1;
  du1=DOT(N1,U1)+d1;
  du2=DOT(N1,U2)+d1;

  /* coplanarity robustness check */
#if USE_EPSILON_TEST==TRUE
  if(fabs(du0)<EPSILON) du0=0.0;
  if(fabs(du1)<EPSILON) du1=0.0;
  if(fabs(du2)<EPSILON) du2=0.0;
#endif
  du0du1=du0*du1;
  du0du2=du0*du2;

  if(du0du1>0.0f && du0du2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute plane of triangle (U0,U1,U2) */
  SUB(E1,U1,U0);
  SUB(E2,U2,U0);
  CROSS(N2,E1,E2);
  d2=-DOT(N2,U0);
  /* plane equation 2: N2.X+d2=0 */

  /* put V0,V1,V2 into plane equation 2 */
  dv0=DOT(N2,V0)+d2;
  dv1=DOT(N2,V1)+d2;
  dv2=DOT(N2,V2)+d2;

#if USE_EPSILON_TEST==TRUE
  if(fabs(dv0)<EPSILON) dv0=0.0;
  if(fabs(dv1)<EPSILON) dv1=0.0;
  if(fabs(dv2)<EPSILON) dv2=0.0;
#endif

  dv0dv1=dv0*dv1;
  dv0dv2=dv0*dv2;

  if(dv0dv1>0.0f && dv0dv2>0.0f) /* same sign on all of them + not equal 0 ? */
    return 0;                    /* no intersection occurs */

  /* compute direction of intersection line */
  CROSS(D,N1,N2);

  /* compute and index to the largest component of D */
  max=fabs(D[0]);
  index=0;
  b=fabs(D[1]);
  c=fabs(D[2]);
  if(b>max) max=b,index=1;
  if(c>max) max=c,index=2;

  /* this is the simplified projection onto L*/
  vp0=V0[index];
  vp1=V1[index];
  vp2=V2[index];

  up0=U0[index];
  up1=U1[index];
  up2=U2[index];

  /* compute interval for triangle 1 */
  *coplanar=compute_intervals_isectline(V0,V1,V2,vp0,vp1,vp2,dv0,dv1,dv2,
           dv0dv1,dv0dv2,&isect1[0],&isect1[1],isectpointA1,isectpointA2);
  if(*coplanar) return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2);


  /* compute interval for triangle 2 */
  compute_intervals_isectline(U0,U1,U2,up0,up1,up2,du0,du1,du2,
         du0du1,du0du2,&isect2[0],&isect2[1],isectpointB1,isectpointB2);

  SORT2(isect1[0],isect1[1],smallest1);
  SORT2(isect2[0],isect2[1],smallest2);

  if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return 0;

  /* at this point, we know that the triangles intersect */

  if(isect2[0]<isect1[0])
  {
    if(smallest1==0) { SET(isectpt1,isectpointA1); }
    else { SET(isectpt1,isectpointA2); }

    if(isect2[1]<isect1[1])
    {
      if(smallest2==0) { SET(isectpt2,isectpointB2); }
      else { SET(isectpt2,isectpointB1); }
    }
    else
    {
      if(smallest1==0) { SET(isectpt2,isectpointA2); }
      else { SET(isectpt2,isectpointA1); }
    }
  }
  else
  {
    if(smallest2==0) { SET(isectpt1,isectpointB1); }
    else { SET(isectpt1,isectpointB2); }

    if(isect2[1]>isect1[1])
    {
      if(smallest1==0) { SET(isectpt2,isectpointA2); }
      else { SET(isectpt2,isectpointA1); }
    }
    else
    {
      if(smallest2==0) { SET(isectpt2,isectpointB2); }
      else { SET(isectpt2,isectpointB1); }
    }
  }
  return 1;
}


 

embededvc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FZU2273：Triangles（计算几何 & 两三角形的位置）
junior19的博客
03-13 577
This is a simple problem. Given two triangles A and B, you should determine they are intersect, contain or disjoint. (Public edge or point are treated as intersect.)InputFirst line contains an integer...
codeforces 13D. Triangles（计算几何 dp）
小小西北风
10-31 823
D. Triangles time limit per test 2 seconds memory limit per test 64 megabytes input standard input output standard output Little Petya likes to draw. He drew N red and M
JAVA语言程序设计（基础篇）第十版——第三章 选择 编程练习题（参考答案）
陈美丽的小星球
03-17 2622
（3.2节+（3.8-3.16小节）+综合题） 3.2节 *3.1 import java.util.Scanner; public class T1 { public static void main(String[] args) { Scanner input=new Scanner(System.in); System.out.print("Enter a, b, c:...
三角法求深度（triangulation）
danmeng8068的博客
06-19 2467
https://blog.csdn.net/heyijia0327/article/details/50774104
Triangle中角度计算
xiweijie的博客
08-22 132
Triangle中角度计算Angle of vertex of triangle1. using cosine rule Angle of vertex of triangle 1. using cosine rule 计算公式: Using_cosine rule C++ codevoid internal_angles(const Eigen::MatrixXd & V, const Eigen::MatrixXi & F,
Triangle面积的三种计算方法
xiweijie的博客
08-22 524
triangle面积的三种计算方法Area of Triangle1. using coordinates2. Using Heron's formula3. Using vectors Area of Triangle 1. using coordinates 计算公式: Using_coordinates C++ code void doublearea(const Eigen::MatrixXd & V, const Eigen::MatrixXi &am
Area in Triangle （计算几何）
一只小菜鸡的博客
08-18 442
Given a triangle field and a rope of a certain length (Figure-1), you are required to use the rope to enclose a region within the field and make the region as large as possible. input The inpu
Triangle中face与vertex normal计算方法
xiweijie的博客
08-22 786
Triangle中face与vertex normal计算方法1. Per faces normal2. Per vertex normal 1. Per faces normal per-faces-normal也就是triangle每个面上的normal, 是constant的 计算公式: C++ code void per_face_normal(const Eigen::MatrixXd & V, const Eigen::Mat
triangle java_Triangle leetcode java
weixin_42523718的博客
02-12 64
题目：Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.For example, given the following triangle[[2],[3,4],[6,5,7],[4,1,8,3]]The...
Triangle
记录成长中的点点滴滴
07-28 201
题目描述： Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below. For example, given the following triangle [ [2],
triangle_matlab重载函数_triangle函数_三角形周长、面积计算_
09-29
本案例中，我们关注的是一个名为`triangle`的重载函数，该函数用于计算三角形的周长和面积。以下是关于这个主题的详细讲解。 首先，我们需要理解函数重载的概念。在MATLAB中，函数重载通过提供多个具有相同名称但...
Triangle-War.rar_triangle
09-14
标题中的“Triangle-War.rar_triangle”暗示我们关注的是与三角形相关的编程问题，可能是涉及到图形学、几何计算或算法优化的领域。描述中提到的“poj1085”是一个编程竞赛题目，通常这类题目会挑战参赛者的算法设计...
MATLAB.rar_triangle
09-24
从标签“triangle”我们可以推断，这个项目专门关注的是与三角波相关的计算。其他文件如`walshcode.m`可能涉及到沃尔什码，这是一种二进制序列，常用于编码和信号传输；`MUL_RAYLEITH.m`可能是关于Rayleigh乘法的一...
Triangle_linux.rar_triangle
09-14
下面将详细介绍这一领域的相关知识点。 一、Linux环境开发 Linux是一种开源的操作系统，为开发者提供了丰富的命令行工具和强大的开发环境。GCC是Linux下的标准C/C++编译器，支持多种编程语言，能生成高效的机器代码...
gl_triangle.zip_triangle
09-21
`Read me.txt`文件通常包含有关项目的基本信息，比如如何运行程序、注意事项或者开发者留下的注释。在这个例子中，它可能解释了如何启动`triangle.exe`，以及可能存在的依赖库或特定设置。 通过这个简单的“opengl ...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8818
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3265
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3708
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1539
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
开发者测试triangle
最新发布
10-30
Triangle是一个开发者测试期间常用的测试工具，其主要功能是用于评估和测试三角形对象的属性和方法。它可以验证三角形的类型、边长是否符合要求以及计算三角形的面积和周长等。 在使用Triangle进行测试时，我们需要提供一系列的测试用例，以覆盖各种情况。例如，我们可以测试三角形的边长为正数时，是否正确地识别为合法三角形；而当边长为非正数或非数字时，是否能正确地返回错误信息。 Triangle还可以验证三角形的类型是否正确。例如，我们可以测试边长分别为3、4和5的三角形，它应该被正确地识别为直角三角形。同样地，我们还可以测试等边三角形、等腰三角形和一般三角形等其他类型。 此外，Triangle还提供了计算面积和周长的方法。我们可以编写测试用例来检查这些方法的正确性。例如，我们可以测试边长为3、4和5的三角形的面积是否等于6，周长是否等于12。 通过使用Triangle进行开发者测试，我们可以更好地保证三角形对象的属性和方法的正确性。这些测试用例可以帮助我们及时发现和解决潜在的问题，提高代码的质量和可靠性。通过反复测试和不断改进，我们可以通过Triangle来构建高质量的三角形对象，并在应用程序中广泛使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值