CollisionDetectionNamespace::Collision_detector_Triangles_Distance Class Reference

Collision detector to test 2 Triangles with distance calculation. More...

#include <collision_detectors.h>

Inheritance diagram for CollisionDetectionNamespace::Collision_detector_Triangles_Distance:

List of all members.

Public Member Functions
	Collision_detector_Triangles_Distance ()
	Class constructor.
CollisionReport	FindCollision (void *pNode1, void *pNode2)
Private Member Functions
float	closestPointsSegmentSegment (VECTOR3 p1, VECTOR3 q1, VECTOR3 p2, VECTOR3 q2, VECTOR3 &C1, VECTOR3 &C2)
float	distanceSegmentSegment (VECTOR3 p1, VECTOR3 q1, VECTOR3 p2, VECTOR3 q2)
float	distanceVertexTriangle (VECTOR3 P, Triangle triangle)
VECTOR3	closestPointVertexTriangle (VECTOR3 p, Triangle triangle)
float	clamp (float n, float min, float max)

---

Detailed Description

Collision detector to test 2 Triangles with distance calculation.

Definition at line 101 of file collision_detectors.h.

---

Constructor & Destructor Documentation

CollisionDetectionNamespace::Collision_detector_Triangles_Distance::Collision_detector_Triangles_Distance

(

)

[inline]

Class constructor.

Definition at line 105 of file collision_detectors.h.

{;}

---

Member Function Documentation

CollisionReport Collision_detector_Triangles_Distance::FindCollision	(	void *	pNode1,
		void *	pNode2
	)			[virtual]

Detect collision

Parameters:

[in]	object	1
[in]	object	2

Returns:

CollisionReport filled with collision detection results

Implements CollisionDetectionNamespace::Collison_Detector_IFace.

Definition at line 271 of file collision_detectors.cpp.

{
       CollisionReport collisionReport;

       Triangle* a = (Triangle*) pNode1;
       Triangle* b = (Triangle*) pNode2;

       //float fDistance = 0;
       VECTOR3 C1, C2;

       VECTOR3 closestPt;

       // test all segments against both triangles
       
       collisionReport.fSqueredSeparationDistance = closestPointsSegmentSegment(a->v1,a->v2,b->v1,b->v2,C1,C2);
       closestPt = (C1 + (C2 - C1)/2);
       //fDistance = distanceSegmentSegment(a->v1,a->v2,b->v1,b->v2);

       float d = closestPointsSegmentSegment(a->v1,a->v2,b->v1,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }
       //float d = distanceSegmentSegment(a->v1,a->v2,b->v1,b->v3);
       //if (d < fDistance)
       //     fDistance = d;

       d = closestPointsSegmentSegment(a->v1,a->v2,b->v2,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v1,a->v2,b->v2,b->v3);
       //if (d < fDistance)
       //     fDistance = d;
       

       d = closestPointsSegmentSegment(a->v1,a->v3,b->v1,b->v2,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v1,a->v3,b->v1,b->v2);
       //if (d < fDistance)
       //     fDistance = d;


       d = closestPointsSegmentSegment(a->v1,a->v3,b->v1,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v1,a->v3,b->v1,b->v3);
       //if (d < fDistance)
       //     fDistance = d;

       d = closestPointsSegmentSegment(a->v1,a->v3,b->v2,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v1,a->v3,b->v2,b->v3);
       //if (d < fDistance)
       //     fDistance = d;


       d = closestPointsSegmentSegment(a->v2,a->v3,b->v1,b->v2,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v2,a->v3,b->v1,b->v2);
       //if (d < fDistance)
       //     fDistance = d;


       d = closestPointsSegmentSegment(a->v2,a->v3,b->v1,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v2,a->v3,b->v1,b->v3);
       //if (d < fDistance)
       //     fDistance = d;


       d = closestPointsSegmentSegment(a->v2,a->v3,b->v2,b->v3,C1,C2);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {      
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (C1 + (C2 - C1)/2);
       }

       //d = distanceSegmentSegment(a->v2,a->v3,b->v2,b->v3);
       //if (d < fDistance)
       //     fDistance = d;


       // Test all points against both triangles


       VECTOR3 pt = closestPointVertexTriangle(a->v1,*b);
       VECTOR3 v = (a->v1 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }


       //d = distanceVertexTriangle(a->v1,*b);
       //if (d < fDistance)
       //     fDistance = d;


       pt = closestPointVertexTriangle(a->v2,*b);
       v = (a->v2 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }


       //d = distanceVertexTriangle(a->v2,*b);
       //if (d < fDistance)
       //     fDistance = d;

       pt = closestPointVertexTriangle(a->v3,*b);
       v = (a->v3 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }

       //d = distanceVertexTriangle(a->v3,*b);
       //if (d < fDistance)
       //     fDistance = d;


       pt = closestPointVertexTriangle(b->v1,*a);
       v = (b->v1 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }


       //d = distanceVertexTriangle(b->v1,*a);
       //if (d < fDistance)
       //     fDistance = d;

       pt = closestPointVertexTriangle(b->v2,*a);
       v = (b->v2 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }

       //d = distanceVertexTriangle(b->v2,*a);
       //if (d < fDistance)
       //     fDistance = d;

       pt = closestPointVertexTriangle(b->v3,*a);
       v = (b->v3 - pt);
       d =  v.Dot(v);
       if ( d < collisionReport.fSqueredSeparationDistance)
       {
              collisionReport.fSqueredSeparationDistance = d;
              closestPt = (pt + (v / 2));
       }

       collisionReport.collisionPoints.push_back(closestPt);
       //d = distanceVertexTriangle(b->v3,*a);
       //if (d < fDistance)
       //     fDistance = d;


       return collisionReport;
}

float Collision_detector_Triangles_Distance::closestPointsSegmentSegment	(	VECTOR3	p1,
		VECTOR3	q1,
		VECTOR3	p2,
		VECTOR3	q2,
		VECTOR3 &	C1,
		VECTOR3 &	C2
	)			[private]

Closest points test for 2 segments

Parameters:

[in]	start	point of segment 1
[in]	end	point of segment 1
[in]	start	point of segment 2
[in]	end	point of segment 2
[out]	closest	point on segment 1
[out]	closest	point on segment 2

Returns:

minimal distance between segments

Definition at line 474 of file collision_detectors.cpp.

{
       float fDistance = 0;
       float s,t;    // parameters of closest points

       VECTOR3 d1 = q1 - p1; // Direction vector of S1
       VECTOR3 d2 = q2 - p2; // Direction vector of S2

       VECTOR3 r = p1 - p2;

       float a = d1.Dot(d1); // Squered lenght of S1
       float e = d2.Dot(d2); // Squered lenght of S2

       float f = d2.Dot(r);
       
       if (a <= EPSILON && e <= EPSILON)
       {
              // Both segments degenerate into points
              s = t = 0.0f;
       }
       else if (a <= EPSILON)
       {
              // first segment degenerates into point
              s = 0.0f;
              t = clamp(f/e,0.0f,1.0f);
       }
       else
       {
              float c = d1.Dot(r);
              if ( e <= EPSILON)
              {
                     // second segment degenerates into point
                     t = 0.0f;
                     s = clamp(-c/a,0.0f,1.0f);
              }
              else
              {
                     float b = d1.Dot(d2);
                     float denom = a*e - b*b;

                     // if segments not parallel compute closest point on L1 to L2
                     //     and clamp it to segment S1, else pick s
                     if (denom != 0.0f)
                            s = clamp((b*f-c*e)/denom,0.0f,1.0f);
                     else
                            s = 0.0f;

                     // Compute closest point on L2 closest to S1(s)
                     t = (b*s + f) / e;

                     // if t in [0,1] done. Else clamp t, recompute s for the new value t
                     if ( t < 0.0f)
                     {
                            t = 0.0f;
                            s = clamp(-c/a,0.0f, 1.0f);
                     }
                     else if (t > 1.0f)
                     {
                            t = 1.0f;
                            s = clamp((b-c)/a,0.0f, 1.0f);
                     }
              }
       }

       C1 = p1 + d1*s;
       C2 = p2 + d2*t;

       VECTOR3 x = C2-C1;

       fDistance = x.Dot(x);

       return fDistance;
}

float Collision_detector_Triangles_Distance::distanceSegmentSegment	(	VECTOR3	p1,
		VECTOR3	q1,
		VECTOR3	p2,
		VECTOR3	q2
	)			[private]

Distance test for 2 segments

Parameters:

[in]	start	point of segment 1
[in]	end	point of segment 1
[in]	start	point of segment 2
[in]	end	point of segment 2

Returns:

minimal distance between segments

Definition at line 549 of file collision_detectors.cpp.

{
       float fDistance = 0;
       float s,t;    // parameters of closest points

       VECTOR3 d1 = q1 - p1; // Direction vector of S1
       VECTOR3 d2 = q2 - p2; // Direction vector of S2

       VECTOR3 r = p1 - p2;

       float a = d1.Dot(d1); // Squered lenght of S1
       float e = d2.Dot(d2); // Squered lenght of S2

       float f = d2.Dot(r);
       
       if (a <= EPSILON && e <= EPSILON)
       {
              // Both segments degenerate into points
              s = t = 0.0f;
       }
       else if (a <= EPSILON)
       {
              // first segment degenerates into point
              s = 0.0f;
              t = clamp(f/e,0.0f,1.0f);
       }
       else
       {
              float c = d1.Dot(r);
              if ( e <= EPSILON)
              {
                     // second segment degenerates into point
                     t = 0.0f;
                     s = clamp(-c/a,0.0f,1.0f);
              }
              else
              {
                     float b = d1.Dot(d2);
                     float denom = a*e - b*b;

                     // if segments not parallel compute closest point on L1 to L2
                     //     and clamp it to segment S1, else pick s
                     if (denom != 0.0f)
                            s = clamp((b*f-c*e)/denom,0.0f,1.0f);
                     else
                            s = 0.0f;

                     // Compute closest point on L2 closest to S1(s)
                     t = (b*s + f) / e;

                     // if t in [0,1] done. Else clamp t, recompute s for the new value t
                     if ( t < 0.0f)
                     {
                            t = 0.0f;
                            s = clamp(-c/a,0.0f, 1.0f);
                     }
                     else if (t > 1.0f)
                     {
                            t = 1.0f;
                            s = clamp((b-c)/a,0.0f, 1.0f);
                     }
              }
       }

       VECTOR3 c1 = p1 + d1*s;
       VECTOR3 c2 = p2 + d2*t;

       VECTOR3 x = c2-c1;

       fDistance = x.Dot(x);

       return fDistance;
}

float Collision_detector_Triangles_Distance::distanceVertexTriangle	(	VECTOR3	P,
		Triangle	triangle
	)			[private]

Distance test for vertex and triangle

Parameters:

[in]	vertex
[in]	triangle

Returns:

minimal distance between vertex and triangle

Definition at line 630 of file collision_detectors.cpp.

{
       float fDistance = 0;
       VECTOR3 closestPoint = closestPointVertexTriangle(p,triangle);

       
       VECTOR3 d = p - closestPoint;


       fDistance = d.Dot(d);

       return fDistance;
}

VECTOR3 Collision_detector_Triangles_Distance::closestPointVertexTriangle	(	VECTOR3	p,
		Triangle	triangle
	)			[private]

Closest point test for vertex and triangle

Parameters:

[in]	vertex
[in]	triangle

Returns:

closest point between vertex and triangle on triangle

Definition at line 644 of file collision_detectors.cpp.

{
       VECTOR3 ab = triangle.v2 - triangle.v1;
       VECTOR3 ac = triangle.v3 - triangle.v1;
       VECTOR3 ap = p - triangle.v1;

       float d1 = ab.Dot(ap);
       float d2 = ac.Dot(ap);

       // check if p in vertex region outside A
       if ( d1 <= 0.0f && d2 <= 0.0f) // Barycentric coordinates (1,0,0)
       {
              return triangle.v1;
       }
       
       // check if p in vertex region outside B
       VECTOR3 bp = p - triangle.v2;
       float d3 = ab.Dot(bp);
       float d4 = ac.Dot(bp);

       if (d3 >= 0.0f && d4 <= d3) // Barycentric coordinates (0,1,0)
              return triangle.v2;
              
       // check if p in edge projection of AB
       float vc = d1*d4 - d3*d2;
       if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f)
       {
              float v = d1 / (d1-d3);
              return triangle.v1+v*ab;
       }

       // check if p in vertex region outside A
       VECTOR3 cp = p - triangle.v3;
       float d5 = ab.Dot(cp);
       float d6 = ac.Dot(cp);
       if (d6 >= 0.0f && d5 <= d6) // Barycentric coordinates (0,0,1)
              return triangle.v3;

       // check if p in edge projection of AC
       float vb = d5*d2 - d1*d6;
       if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f)
       {
              float w = d2 / (d2-d6);
              return triangle.v1+w*ac;
       }

       // check if p in edge projection of BC
       float va = d3*d6 - d5*d4;
       if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f)
       {
              float w = (d4 - d3) / ((d4-d3)+(d5-d6));
              return triangle.v2 + w * (triangle.v3-triangle.v2);
       }

       // p is inside face region
       float denom = 1.0f / (va +vb +vc);
       float v = vb * denom;
       float w = vc * denom;

       return triangle.v1 + ab*v + ac*w;
}

float Collision_detector_Triangles_Distance::clamp	(	float	n,
		float	min,
		float	max
	)			[private]

clamp number into an interval

Parameters:

[in]	number	to clamp
[in]	interval	min
[in]	interval	max

Returns:

clamped number

Definition at line 623 of file collision_detectors.cpp.

{
       if (n < min) return min;
       if (n > max) return max;
       return n;
}

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/modules/collision_detection/collision_detectors.h
• /cygdrive/d/src/svn/vrut/trunk/modules/collision_detection/collision_detectors.cpp