mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-11 10:06:47 +00:00
Replace threeyd tri-tri intersect library with physx implementation.
This commit is contained in:
Dion Moult
@@ -55,7 +55,6 @@
|
||||
#include <IntTools_FaceFace.hxx>
|
||||
#include <STEPConstruct_PointHasher.hxx>
|
||||
#include <boost/stacktrace.hpp>
|
||||
#include "triangleintersects.hpp"
|
||||
#include "clash_utils.h"
|
||||
|
||||
|
||||
@@ -755,9 +754,9 @@ namespace IfcGeom {
|
||||
const gp_Pnt& v3_a_pnt = verts[2];
|
||||
const gp_Vec& normal_a = normals_a.at(i);
|
||||
|
||||
std::array<double, 3> t1a = {v1_a_pnt.X(), v1_a_pnt.Y(), v1_a_pnt.Z()};
|
||||
std::array<double, 3> t1b = {v2_a_pnt.X(), v2_a_pnt.Y(), v2_a_pnt.Z()};
|
||||
std::array<double, 3> t1c = {v3_a_pnt.X(), v3_a_pnt.Y(), v3_a_pnt.Z()};
|
||||
const gp_Vec v1_a_vec(v1_a_pnt.XYZ());
|
||||
const gp_Vec v2_a_vec(v2_a_pnt.XYZ());
|
||||
const gp_Vec v3_a_vec(v3_a_pnt.XYZ());
|
||||
|
||||
for (const auto& bvh_b_i : bvh_b_is) {
|
||||
for (int j=bvh_b->BegPrimitive(bvh_b_i); j<=bvh_b->EndPrimitive(bvh_b_i); ++j) {
|
||||
@@ -773,29 +772,19 @@ namespace IfcGeom {
|
||||
|
||||
tri_count_++;
|
||||
|
||||
std::array<double, 3> t2a = {v1_b_pnt.X(), v1_b_pnt.Y(), v1_b_pnt.Z()};
|
||||
std::array<double, 3> t2b = {v2_b_pnt.X(), v2_b_pnt.Y(), v2_b_pnt.Z()};
|
||||
std::array<double, 3> t2c = {v3_b_pnt.X(), v3_b_pnt.Y(), v3_b_pnt.Z()};
|
||||
const gp_Vec v1_b_vec(v1_b_pnt.XYZ());
|
||||
const gp_Vec v2_b_vec(v2_b_pnt.XYZ());
|
||||
const gp_Vec v3_b_vec(v3_b_pnt.XYZ());
|
||||
|
||||
// Allow a deviation of 0.25 degrees in coplanarity check
|
||||
if (std::abs(normal_a.Dot(normal_b)) >= 0.99999f) {
|
||||
continue;
|
||||
}
|
||||
|
||||
std::array<double, 3> int1, int2;
|
||||
bool is_coplanar;
|
||||
|
||||
// From 3YOURMIND / 3YDMoeller - MIT license
|
||||
// https://github.com/3YOURMIND/3YDMoeller
|
||||
// Perhaps this can be replaced with NVIDIA's method?
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
if (threeyd::moeller::TriangleIntersects<std::array<double, 3>>::triangle(t1a, t1b, t1c, t2a, t2b, t2c, int1, int2, is_coplanar)) {
|
||||
if (is_coplanar) {
|
||||
continue; // Touching, but not intersecting.
|
||||
}
|
||||
|
||||
gp_Vec int1, int2;
|
||||
if (trianglesIntersect(v1_a_vec, v2_a_vec, v3_a_vec, v1_b_vec, v2_b_vec, v3_b_vec, int1, int2, ! allow_touching)) {
|
||||
if (allow_touching) {
|
||||
protrusion_points_.push_back(int1);
|
||||
protrusion_points_.push_back({int1.X(), int1.Y(), int1.Z()});
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -804,65 +793,62 @@ namespace IfcGeom {
|
||||
// 2. The point of intersection is not along the edge of triangle A.
|
||||
// 3. The point of intersection is not a vertex of triangle B.
|
||||
|
||||
gp_Pnt int1_pnt(int1[0], int1[1], int1[2]);
|
||||
gp_Pnt int2_pnt(int2[0], int2[1], int2[2]);
|
||||
|
||||
if (
|
||||
! is_point_on_line(int1_pnt, v1_a_pnt, v2_a_pnt)
|
||||
&& ! is_point_on_line(int1_pnt, v1_a_pnt, v3_a_pnt)
|
||||
&& ! is_point_on_line(int1_pnt, v2_a_pnt, v3_a_pnt)
|
||||
! is_point_on_line(int1, v1_a_vec, v2_a_vec)
|
||||
&& ! is_point_on_line(int1, v1_a_vec, v3_a_vec)
|
||||
&& ! is_point_on_line(int1, v2_a_vec, v3_a_vec)
|
||||
) {
|
||||
if (
|
||||
int1_pnt.Distance(v1_b_pnt) > 1e-4
|
||||
&& int1_pnt.Distance(v2_b_pnt) > 1e-4
|
||||
&& int1_pnt.Distance(v3_b_pnt) > 1e-4
|
||||
(v1_b_vec - int1).Magnitude() > 1e-4
|
||||
&& (v2_b_vec - int1).Magnitude() > 1e-4
|
||||
&& (v3_b_vec - int1).Magnitude() > 1e-4
|
||||
) {
|
||||
protrusion_points_.push_back(int1);
|
||||
protrusion_points_.push_back({int1.X(), int1.Y(), int1.Z()});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
! is_point_on_line(int1_pnt, v1_b_pnt, v2_b_pnt)
|
||||
&& ! is_point_on_line(int1_pnt, v1_b_pnt, v3_b_pnt)
|
||||
&& ! is_point_on_line(int1_pnt, v2_b_pnt, v3_b_pnt)
|
||||
! is_point_on_line(int1, v1_b_vec, v2_b_vec)
|
||||
&& ! is_point_on_line(int1, v1_b_vec, v3_b_vec)
|
||||
&& ! is_point_on_line(int1, v2_b_vec, v3_b_vec)
|
||||
) {
|
||||
if (
|
||||
int1_pnt.Distance(v1_a_pnt) > 1e-4
|
||||
&& int1_pnt.Distance(v2_a_pnt) > 1e-4
|
||||
&& int1_pnt.Distance(v3_a_pnt) > 1e-4
|
||||
(v1_a_vec - int1).Magnitude() > 1e-4
|
||||
&& (v2_a_vec - int1).Magnitude() > 1e-4
|
||||
&& (v3_a_vec - int1).Magnitude() > 1e-4
|
||||
) {
|
||||
protrusion_points_.push_back(int1);
|
||||
protrusion_points_.push_back({int1.X(), int1.Y(), int1.Z()});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
! is_point_on_line(int2_pnt, v1_a_pnt, v2_a_pnt)
|
||||
&& ! is_point_on_line(int2_pnt, v1_a_pnt, v3_a_pnt)
|
||||
&& ! is_point_on_line(int2_pnt, v2_a_pnt, v3_a_pnt)
|
||||
! is_point_on_line(int2, v1_a_vec, v2_a_vec)
|
||||
&& ! is_point_on_line(int2, v1_a_vec, v3_a_vec)
|
||||
&& ! is_point_on_line(int2, v2_a_vec, v3_a_vec)
|
||||
) {
|
||||
if (
|
||||
int2_pnt.Distance(v1_b_pnt) > 1e-4
|
||||
&& int2_pnt.Distance(v2_b_pnt) > 1e-4
|
||||
&& int2_pnt.Distance(v3_b_pnt) > 1e-4
|
||||
(v1_b_vec - int2).Magnitude() > 1e-4
|
||||
&& (v2_b_vec - int2).Magnitude() > 1e-4
|
||||
&& (v3_b_vec - int2).Magnitude() > 1e-4
|
||||
) {
|
||||
protrusion_points_.push_back(int2);
|
||||
protrusion_points_.push_back({int2.X(), int2.Y(), int2.Z()});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
! is_point_on_line(int2_pnt, v1_b_pnt, v2_b_pnt)
|
||||
&& ! is_point_on_line(int2_pnt, v1_b_pnt, v3_b_pnt)
|
||||
&& ! is_point_on_line(int2_pnt, v2_b_pnt, v3_b_pnt)
|
||||
! is_point_on_line(int2, v1_b_vec, v2_b_vec)
|
||||
&& ! is_point_on_line(int2, v1_b_vec, v3_b_vec)
|
||||
&& ! is_point_on_line(int2, v2_b_vec, v3_b_vec)
|
||||
) {
|
||||
if (
|
||||
int2_pnt.Distance(v1_a_pnt) > 1e-4
|
||||
&& int2_pnt.Distance(v2_a_pnt) > 1e-4
|
||||
&& int2_pnt.Distance(v3_a_pnt) > 1e-4
|
||||
(v1_a_vec - int2).Magnitude() > 1e-4
|
||||
&& (v2_a_vec - int2).Magnitude() > 1e-4
|
||||
&& (v3_a_vec - int2).Magnitude() > 1e-4
|
||||
) {
|
||||
protrusion_points_.push_back(int2);
|
||||
protrusion_points_.push_back({int2.X(), int2.Y(), int2.Z()});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -957,9 +943,9 @@ namespace IfcGeom {
|
||||
const gp_Pnt& v2_a_pnt = verts[1];
|
||||
const gp_Pnt& v3_a_pnt = verts[2];
|
||||
|
||||
const gp_Vec v1_a_vec(v1_a_pnt.X(), v1_a_pnt.Y(), v1_a_pnt.Z());
|
||||
const gp_Vec v2_a_vec(v2_a_pnt.X(), v2_a_pnt.Y(), v2_a_pnt.Z());
|
||||
const gp_Vec v3_a_vec(v3_a_pnt.X(), v3_a_pnt.Y(), v3_a_pnt.Z());
|
||||
const gp_Vec v1_a_vec(v1_a_pnt.XYZ());
|
||||
const gp_Vec v2_a_vec(v2_a_pnt.XYZ());
|
||||
const gp_Vec v3_a_vec(v3_a_pnt.XYZ());
|
||||
|
||||
const std::array<gp_Vec, 3> p = {v1_a_vec, v2_a_vec, v3_a_vec};
|
||||
|
||||
@@ -972,9 +958,9 @@ namespace IfcGeom {
|
||||
|
||||
tri_count_++;
|
||||
|
||||
const gp_Vec v1_b_vec(v1_b_pnt.X(), v1_b_pnt.Y(), v1_b_pnt.Z());
|
||||
const gp_Vec v2_b_vec(v2_b_pnt.X(), v2_b_pnt.Y(), v2_b_pnt.Z());
|
||||
const gp_Vec v3_b_vec(v3_b_pnt.X(), v3_b_pnt.Y(), v3_b_pnt.Z());
|
||||
const gp_Vec v1_b_vec(v1_b_pnt.XYZ());
|
||||
const gp_Vec v2_b_vec(v2_b_pnt.XYZ());
|
||||
const gp_Vec v3_b_vec(v3_b_pnt.XYZ());
|
||||
|
||||
const std::array<gp_Vec, 3> q = {v1_b_vec, v2_b_vec, v3_b_vec};
|
||||
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
#define GU_CULLING_EPSILON_RAY_TRIANGLE FLT_EPSILON*FLT_EPSILON
|
||||
#define PX_MAX_F32 3.4028234663852885981170418348452e+38F
|
||||
|
||||
typedef uint32_t PxU32;
|
||||
|
||||
// Why can't I use std::clamp?
|
||||
template<typename TC>
|
||||
const TC& ios_clamp(const TC& v, const TC& lo, const TC& hi) {
|
||||
@@ -345,3 +347,246 @@ float distanceTriangleTriangleSquared(gp_Vec& cp, gp_Vec& cq, const std::array<g
|
||||
}
|
||||
else return 0.0f;
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
//Based on the paper A Fast Triangle-Triangle Intersection Test by T. Moeller
|
||||
//http://web.stanford.edu/class/cs277/resources/papers/Moller1997b.pdf
|
||||
struct Interval
|
||||
{
|
||||
Standard_Real min;
|
||||
Standard_Real max;
|
||||
gp_Vec minPoint;
|
||||
gp_Vec maxPoint;
|
||||
|
||||
Interval() : min(FLT_MAX), max(-FLT_MAX), minPoint(gp_Vec(NAN, NAN, NAN)), maxPoint(gp_Vec(NAN, NAN, NAN)) { }
|
||||
|
||||
static bool overlapOrTouch(const Interval& a, const Interval& b)
|
||||
{
|
||||
return !(a.min > b.max || b.min > a.max);
|
||||
}
|
||||
|
||||
static Interval intersection(const Interval& a, const Interval& b)
|
||||
{
|
||||
Interval result;
|
||||
if (!overlapOrTouch(a, b))
|
||||
return result;
|
||||
|
||||
if (a.min > b.min)
|
||||
{
|
||||
result.min = a.min;
|
||||
result.minPoint = a.minPoint;
|
||||
}
|
||||
else
|
||||
{
|
||||
result.min = b.min;
|
||||
result.minPoint = b.minPoint;
|
||||
}
|
||||
|
||||
if (a.max < b.max)
|
||||
{
|
||||
result.max = a.max;
|
||||
result.maxPoint = a.maxPoint;
|
||||
}
|
||||
else
|
||||
{
|
||||
result.max = b.max;
|
||||
result.maxPoint = b.maxPoint;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void include(Standard_Real d, const gp_Vec& p)
|
||||
{
|
||||
if (d < min) { min = d; minPoint = p; }
|
||||
if (d > max) { max = d; maxPoint = p; }
|
||||
}
|
||||
};
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
static Interval computeInterval(Standard_Real distanceA, Standard_Real distanceB, Standard_Real distanceC, const gp_Vec& a, const gp_Vec& b, const gp_Vec& c, const gp_Vec& dir)
|
||||
{
|
||||
Interval i;
|
||||
|
||||
const bool bA = distanceA > 0;
|
||||
const bool bB = distanceB > 0;
|
||||
const bool bC = distanceC > 0;
|
||||
distanceA = std::abs(distanceA);
|
||||
distanceB = std::abs(distanceB);
|
||||
distanceC = std::abs(distanceC);
|
||||
|
||||
if (bA != bB)
|
||||
{
|
||||
const gp_Vec p = (distanceA / (distanceA + distanceB)) * b + (distanceB / (distanceA + distanceB)) * a;
|
||||
i.include(dir.Dot(p), p);
|
||||
}
|
||||
if (bA != bC)
|
||||
{
|
||||
const gp_Vec p = (distanceA / (distanceA + distanceC)) * c + (distanceC / (distanceA + distanceC)) * a;
|
||||
i.include(dir.Dot(p), p);
|
||||
}
|
||||
if (bB != bC)
|
||||
{
|
||||
const gp_Vec p = (distanceB / (distanceB + distanceC)) * c + (distanceC / (distanceB + distanceC)) * b;
|
||||
i.include(dir.Dot(p), p);
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
Standard_Real orient2d(const gp_Vec& a, const gp_Vec& b, const gp_Vec& c, PxU32 x, PxU32 y)
|
||||
{
|
||||
return (a.Coord(y) - c.Coord(y)) * (b.Coord(x) - c.Coord(x)) - (a.Coord(x) - c.Coord(x)) * (b.Coord(y) - c.Coord(y));
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
Standard_Real pointInTriangle(const gp_Vec& a, const gp_Vec& b, const gp_Vec& c, const gp_Vec& point, PxU32 x, PxU32 y)
|
||||
{
|
||||
const Standard_Real ab = orient2d(a, b, point, x, y);
|
||||
const Standard_Real bc = orient2d(b, c, point, x, y);
|
||||
const Standard_Real ca = orient2d(c, a, point, x, y);
|
||||
|
||||
if ((ab >= 0) == (bc >= 0) && (ab >= 0) == (ca >= 0))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
Standard_Real linesIntersect(const gp_Vec& startA, const gp_Vec& endA, const gp_Vec& startB, const gp_Vec& endB, PxU32 x, PxU32 y)
|
||||
{
|
||||
const Standard_Real aaS = orient2d(startA, endA, startB, x, y);
|
||||
const Standard_Real aaE = orient2d(startA, endA, endB, x, y);
|
||||
|
||||
if ((aaS >= 0) == (aaE >= 0))
|
||||
return false;
|
||||
|
||||
const Standard_Real bbS = orient2d(startB, endB, startA, x, y);
|
||||
const Standard_Real bbE = orient2d(startB, endB, endA, x, y);
|
||||
|
||||
if ((bbS >= 0) == (bbE >= 0))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
void getProjectionIndices(gp_Vec normal, PxU32& x, PxU32& y)
|
||||
{
|
||||
normal.SetCoord(std::abs(normal.X()), std::abs(normal.Y()), std::abs(normal.Z()));
|
||||
|
||||
if (normal.X() >= normal.Y() && normal.X() >= normal.Z())
|
||||
{
|
||||
//x is the dominant normal direction
|
||||
x = 1;
|
||||
y = 2;
|
||||
}
|
||||
else if (normal.Y() >= normal.X() && normal.Y() >= normal.Z())
|
||||
{
|
||||
//y is the dominant normal direction
|
||||
x = 2;
|
||||
y = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
//z is the dominant normal direction
|
||||
x = 0;
|
||||
y = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
bool trianglesIntersectCoplanar(const gp_Vec& p1_n, const gp_Vec& a1, const gp_Vec& b1, const gp_Vec& c1, const gp_Vec& a2, const gp_Vec& b2, const gp_Vec& c2)
|
||||
{
|
||||
PxU32 x = 0;
|
||||
PxU32 y = 0;
|
||||
getProjectionIndices(p1_n, x, y);
|
||||
|
||||
const Standard_Real third = (1.0f / 3.0f);
|
||||
|
||||
//A bit of the computations done inside the following functions could be shared but it's kept simple since the
|
||||
//difference is not very big and the coplanar case is not expected to be the most common case
|
||||
if (linesIntersect(a1, b1, a2, b2, x, y) || linesIntersect(a1, b1, b2, c2, x, y) || linesIntersect(a1, b1, c2, a2, x, y) ||
|
||||
linesIntersect(b1, c1, a2, b2, x, y) || linesIntersect(b1, c1, b2, c2, x, y) || linesIntersect(b1, c1, c2, a2, x, y) ||
|
||||
linesIntersect(c1, a1, a2, b2, x, y) || linesIntersect(c1, a1, b2, c2, x, y) || linesIntersect(c1, a1, c2, a2, x, y) ||
|
||||
pointInTriangle(a1, b1, c1, third * (a2 + b2 + c2), x, y) || pointInTriangle(a2, b2, c2, third * (a1 + b1 + c1), x, y))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// From NVIDIA-Omniverse PhysX - BSD 3-Clause "New" or "Revised" License
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/LICENSE.md
|
||||
// https://github.com/NVIDIA-Omniverse/PhysX/blob/main/physx/source/geomutils/src/intersection/GuIntersectionTriangleTriangle.cpp
|
||||
// With minor modifications to use gp_Vec type.
|
||||
// Also with minor modification to return intersection points.
|
||||
bool trianglesIntersect(const gp_Vec& a1, const gp_Vec& b1, const gp_Vec& c1, const gp_Vec& a2, const gp_Vec& b2, const gp_Vec& c2/*, Segment* intersection*/, gp_Vec& int1, gp_Vec& int2, bool ignoreCoplanar)
|
||||
{
|
||||
const Standard_Real tolerance = 1e-8f;
|
||||
|
||||
gp_Vec p1_n((b1 - a1).Crossed(c1 - a1).Normalized());
|
||||
double p1_d = -a1.Dot(p1_n);
|
||||
// const PxPlane p1(a1, b1, c1);
|
||||
const Standard_Real p1ToA = a2.Dot(p1_n) + p1_d;
|
||||
const Standard_Real p1ToB = b2.Dot(p1_n) + p1_d;
|
||||
const Standard_Real p1ToC = c2.Dot(p1_n) + p1_d;
|
||||
|
||||
if(std::abs(p1ToA) < tolerance && std::abs(p1ToB) < tolerance &&std::abs(p1ToC) < tolerance)
|
||||
return ignoreCoplanar ? false : trianglesIntersectCoplanar(p1_n, a1, b1, c1, a2, b2, c2); //Coplanar triangles
|
||||
|
||||
if ((p1ToA > 0) == (p1ToB > 0) && (p1ToA > 0) == (p1ToC > 0))
|
||||
return false; //All points of triangle 2 on same side of triangle 1 -> no intersection
|
||||
|
||||
gp_Dir p2_n((b2 - a2).Crossed(c2 - a2).Normalized());
|
||||
double p2_d = -a2.Dot(p2_n);
|
||||
// const PxPlane p2(a2, b2, c2);
|
||||
const Standard_Real p2ToA = a1.Dot(p2_n) + p2_d;
|
||||
const Standard_Real p2ToB = b1.Dot(p2_n) + p2_d;
|
||||
const Standard_Real p2ToC = c1.Dot(p2_n) + p2_d;
|
||||
|
||||
if ((p2ToA > 0) == (p2ToB > 0) && (p2ToA > 0) == (p2ToC > 0))
|
||||
return false; //All points of triangle 1 on same side of triangle 2 -> no intersection
|
||||
|
||||
gp_Vec intersectionDirection = p1_n.Crossed(p2_n);
|
||||
const Standard_Real l2 = intersectionDirection.SquareMagnitude();
|
||||
intersectionDirection *= 1.0f / std::sqrt(l2);
|
||||
|
||||
const Interval i1 = computeInterval(p2ToA, p2ToB, p2ToC, a1, b1, c1, intersectionDirection);
|
||||
const Interval i2 = computeInterval(p1ToA, p1ToB, p1ToC, a2, b2, c2, intersectionDirection);
|
||||
|
||||
if (Interval::overlapOrTouch(i1, i2))
|
||||
{
|
||||
/*if (intersection)
|
||||
{
|
||||
const Interval i = Interval::intersection(i1, i2);
|
||||
intersection->p0 = i.minPoint;
|
||||
intersection->p1 = i.maxPoint;
|
||||
}*/
|
||||
const Interval i = Interval::intersection(i1, i2);
|
||||
int1 = i.minPoint;
|
||||
int2 = i.maxPoint;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -25,3 +25,5 @@ void edgeEdgeDist(gp_Vec& x, gp_Vec& y, // closest points
|
||||
const gp_Vec& q, const gp_Vec& b); // seg 2 origin, vector
|
||||
|
||||
float distanceTriangleTriangleSquared(gp_Vec& cp, gp_Vec& cq, const std::array<gp_Vec, 3> p, const std::array<gp_Vec, 3> q);
|
||||
|
||||
bool trianglesIntersect(const gp_Vec& a1, const gp_Vec& b1, const gp_Vec& c1, const gp_Vec& a2, const gp_Vec& b2, const gp_Vec& c2/*, Segment* intersection*/, gp_Vec& int1, gp_Vec& int2, bool ignoreCoplanar);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user