Added --points and --lines command line options that do a very simplistic conversion of geometry primitives to points or lines respectively, used to aid testing of intersectors
This commit is contained in:
Robert Osfield
parent
03f73d3aad
commit
6e1866ac18
@ -408,6 +408,36 @@ protected:
|
||||
|
||||
};
|
||||
|
||||
class ConvertPrimitives : public osg::NodeVisitor
|
||||
{
|
||||
public:
|
||||
|
||||
osg::PrimitiveSet::Mode _mode;
|
||||
|
||||
ConvertPrimitives(osg::PrimitiveSet::Mode mode):
|
||||
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
|
||||
_mode(mode) {}
|
||||
|
||||
void apply(osg::Geometry& geometry)
|
||||
{
|
||||
if (!geometry.getVertexArray()) return;
|
||||
|
||||
unsigned int numVertices = geometry.getVertexArray()->getNumElements();
|
||||
|
||||
if (_mode==osg::PrimitiveSet::POINTS)
|
||||
{
|
||||
// remove previous primitive sets.
|
||||
geometry.removePrimitiveSet(0, geometry.getNumPrimitiveSets());
|
||||
geometry.addPrimitiveSet(new osg::DrawArrays(_mode, 0,numVertices));
|
||||
}
|
||||
else if (_mode==osg::PrimitiveSet::LINES)
|
||||
{
|
||||
geometry.removePrimitiveSet(0, geometry.getNumPrimitiveSets());
|
||||
geometry.addPrimitiveSet(new osg::DrawArrays(_mode, 0,numVertices));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main( int argc, char **argv )
|
||||
{
|
||||
osg::ArgumentParser arguments(&argc, argv);
|
||||
@ -433,6 +463,9 @@ int main( int argc, char **argv )
|
||||
return 1;
|
||||
}
|
||||
|
||||
while(arguments.read("--points")) { ConvertPrimitives cp(osg::PrimitiveSet::POINTS); loadedModel->accept(cp); }
|
||||
while(arguments.read("--lines")) { ConvertPrimitives cp(osg::PrimitiveSet::LINES); loadedModel->accept(cp); }
|
||||
|
||||
if (useKdTree)
|
||||
{
|
||||
OSG_NOTICE<<"Buildering KdTrees"<<std::endl;
|
||||
@ -440,6 +473,7 @@ int main( int argc, char **argv )
|
||||
loadedModel->accept(*builder);
|
||||
}
|
||||
|
||||
|
||||
// assign the scene graph to viewer
|
||||
viewer.setSceneData(loadedModel);
|
||||
|
||||
|
||||
@ -48,42 +48,65 @@ class OSG_EXPORT KdTree : public osg::Shape
|
||||
* retun true on success. */
|
||||
virtual bool build(BuildOptions& buildOptions, osg::Geometry* geometry);
|
||||
|
||||
struct LineSegmentIntersection
|
||||
|
||||
void setVertices(osg::Vec3Array* vertices) { _vertices = vertices; }
|
||||
const osg::Vec3Array* getVertices() const { return _vertices.get(); }
|
||||
|
||||
|
||||
typedef std::vector< unsigned int > Indices;
|
||||
|
||||
// index in the VertexIndices vector
|
||||
void setPrimitiveIndices(const Indices& indices) { _primitiveIndices = indices; }
|
||||
Indices& getPrimitiveIndices() { return _primitiveIndices; }
|
||||
const Indices& getPrimitiveIndices() const { return _primitiveIndices; }
|
||||
|
||||
// vector containing the primitive vertex index data packed as no_vertice_indices then vertex indices ie. for points it's (1, p0), for lines (2, p0, p1) etc.
|
||||
void setVertexIndices(const Indices& indices) { _vertexIndices = indices; }
|
||||
Indices& getVertexIndices() { return _vertexIndices; }
|
||||
const Indices& getVertexIndices() const { return _vertexIndices; }
|
||||
|
||||
|
||||
inline unsigned int addPoint(unsigned int p0)
|
||||
{
|
||||
LineSegmentIntersection():
|
||||
ratio(-1.0),
|
||||
p0(0),
|
||||
p1(0),
|
||||
p2(0),
|
||||
r0(0.0f),
|
||||
r1(0.0f),
|
||||
r2(0.0f),
|
||||
primitiveIndex(0) {}
|
||||
unsigned int i = _vertexIndices.size();
|
||||
_primitiveIndices.push_back(i);
|
||||
_vertexIndices.push_back(1);
|
||||
_vertexIndices.push_back(p0);
|
||||
return i;
|
||||
}
|
||||
inline unsigned int addLine(unsigned int p0, unsigned int p1)
|
||||
{
|
||||
unsigned int i = _vertexIndices.size();
|
||||
_primitiveIndices.push_back(i);
|
||||
_vertexIndices.push_back(2);
|
||||
_vertexIndices.push_back(p0);
|
||||
_vertexIndices.push_back(p1);
|
||||
return i;
|
||||
}
|
||||
|
||||
bool operator < (const LineSegmentIntersection& rhs) const { return ratio < rhs.ratio; }
|
||||
inline unsigned int addTriangle(unsigned int p0, unsigned int p1, unsigned int p2)
|
||||
{
|
||||
unsigned int i = _vertexIndices.size();
|
||||
_primitiveIndices.push_back(i);
|
||||
_vertexIndices.push_back(3);
|
||||
_vertexIndices.push_back(p0);
|
||||
_vertexIndices.push_back(p1);
|
||||
_vertexIndices.push_back(p2);
|
||||
return i;
|
||||
}
|
||||
|
||||
typedef std::vector<unsigned int> IndexList;
|
||||
typedef std::vector<double> RatioList;
|
||||
inline unsigned int addQuad(unsigned int p0, unsigned int p1, unsigned int p2, unsigned int p3)
|
||||
{
|
||||
unsigned int i = _vertexIndices.size();
|
||||
_primitiveIndices.push_back(i);
|
||||
_vertexIndices.push_back(4);
|
||||
_vertexIndices.push_back(p0);
|
||||
_vertexIndices.push_back(p1);
|
||||
_vertexIndices.push_back(p2);
|
||||
_vertexIndices.push_back(p3);
|
||||
return i;
|
||||
}
|
||||
|
||||
double ratio;
|
||||
osg::Vec3d intersectionPoint;
|
||||
osg::Vec3 intersectionNormal;
|
||||
|
||||
unsigned int p0;
|
||||
unsigned int p1;
|
||||
unsigned int p2;
|
||||
float r0;
|
||||
float r1;
|
||||
float r2;
|
||||
|
||||
unsigned int primitiveIndex;
|
||||
};
|
||||
|
||||
|
||||
typedef std::vector<LineSegmentIntersection> LineSegmentIntersections;
|
||||
|
||||
/** compute the intersection of a line segment and the kdtree, return true if an intersection has been found.*/
|
||||
virtual bool intersect(const osg::Vec3d& start, const osg::Vec3d& end, LineSegmentIntersections& intersections) const;
|
||||
|
||||
|
||||
typedef int value_type;
|
||||
@ -103,31 +126,7 @@ class OSG_EXPORT KdTree : public osg::Shape
|
||||
value_type first;
|
||||
value_type second;
|
||||
};
|
||||
|
||||
struct Triangle
|
||||
{
|
||||
Triangle():
|
||||
p0(0),p1(0),p2(0) {}
|
||||
|
||||
Triangle(unsigned int ip0, unsigned int ip1, unsigned int ip2):
|
||||
p0(ip0), p1(ip1), p2(ip2) {}
|
||||
|
||||
bool operator < (const Triangle& rhs) const
|
||||
{
|
||||
if (p0<rhs.p0) return true;
|
||||
if (p0>rhs.p0) return false;
|
||||
if (p1<rhs.p1) return true;
|
||||
if (p1>rhs.p1) return false;
|
||||
return p2<rhs.p2;
|
||||
}
|
||||
|
||||
unsigned int p0;
|
||||
unsigned int p1;
|
||||
unsigned int p2;
|
||||
};
|
||||
|
||||
typedef std::vector< KdNode > KdNodeList;
|
||||
typedef std::vector< Triangle > TriangleList;
|
||||
|
||||
int addNode(const KdNode& node)
|
||||
{
|
||||
@ -142,21 +141,6 @@ class OSG_EXPORT KdTree : public osg::Shape
|
||||
KdNodeList& getNodes() { return _kdNodes; }
|
||||
const KdNodeList& getNodes() const { return _kdNodes; }
|
||||
|
||||
void setVertices(osg::Vec3Array* vertices) { _vertices = vertices; }
|
||||
const osg::Vec3Array* getVertices() const { return _vertices.get(); }
|
||||
|
||||
unsigned int addTriangle(const Triangle& tri)
|
||||
{
|
||||
unsigned int num = static_cast<unsigned int>(_triangles.size());
|
||||
_triangles.push_back(tri);
|
||||
return num;
|
||||
}
|
||||
|
||||
Triangle& getTriangle(unsigned int i) { return _triangles[i]; }
|
||||
const Triangle& getTriangle(unsigned int i) const { return _triangles[i]; }
|
||||
|
||||
TriangleList& getTriangles() { return _triangles; }
|
||||
const TriangleList& getTriangles() const { return _triangles; }
|
||||
|
||||
template<class IntersectFunctor>
|
||||
void intersect(IntersectFunctor& functor, const KdNode& node) const
|
||||
@ -169,11 +153,16 @@ class OSG_EXPORT KdTree : public osg::Shape
|
||||
|
||||
for(int i=istart; i<iend; ++i)
|
||||
{
|
||||
const KdTree::Triangle& tri = _triangles[i];
|
||||
|
||||
// OSG_NOTICE<<" tri("<<tri.p1<<","<<tri.p2<<","<<tri.p3<<")"<<std::endl;
|
||||
|
||||
functor.intersect(_vertices.get(), i, tri.p0, tri.p1, tri.p2);
|
||||
unsigned int primitiveIndex = _primitiveIndices[i];
|
||||
unsigned int numVertices = _vertexIndices[primitiveIndex++];
|
||||
switch(numVertices)
|
||||
{
|
||||
case(1): functor.intersect(_vertices.get(), i, _vertexIndices[primitiveIndex]); break;
|
||||
case(2): functor.intersect(_vertices.get(), i, _vertexIndices[primitiveIndex], _vertexIndices[primitiveIndex]+1); break;
|
||||
case(3): functor.intersect(_vertices.get(), i, _vertexIndices[primitiveIndex], _vertexIndices[primitiveIndex]+1, _vertexIndices[primitiveIndex]+2); break;
|
||||
case(4): functor.intersect(_vertices.get(), i, _vertexIndices[primitiveIndex], _vertexIndices[primitiveIndex]+1, _vertexIndices[primitiveIndex]+2, _vertexIndices[primitiveIndex]+3); break;
|
||||
default : OSG_NOTICE<<"Warning: KdTree::intersect() encounted unsupported primitive size of "<<numVertices<<std::endl; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (functor.enter(node.bb))
|
||||
@ -190,9 +179,9 @@ class OSG_EXPORT KdTree : public osg::Shape
|
||||
protected:
|
||||
|
||||
osg::ref_ptr<osg::Vec3Array> _vertices;
|
||||
Indices _primitiveIndices;
|
||||
Indices _vertexIndices;
|
||||
KdNodeList _kdNodes;
|
||||
TriangleList _triangles;
|
||||
|
||||
};
|
||||
|
||||
class OSG_EXPORT KdTreeBuilder : public osg::NodeVisitor
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include <osg/KdTree>
|
||||
#include <osg/Geode>
|
||||
#include <osg/TriangleIndexFunctor>
|
||||
#include <osg/TemplatePrimitiveIndexFunctor>
|
||||
#include <osg/Timer>
|
||||
|
||||
#include <osg/io_utils>
|
||||
@ -26,6 +27,7 @@ using namespace osg;
|
||||
//
|
||||
// BuildKdTree Declarartion - class used for building an single KdTree
|
||||
|
||||
|
||||
struct BuildKdTree
|
||||
{
|
||||
BuildKdTree(KdTree& kdTree):
|
||||
@ -53,19 +55,54 @@ protected:
|
||||
BuildKdTree& operator = (const BuildKdTree&) { return *this; }
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Functor for collecting triangle indices from Geometry
|
||||
|
||||
struct TriangleIndicesCollector
|
||||
struct PrimitiveIndicesCollector
|
||||
{
|
||||
TriangleIndicesCollector():
|
||||
PrimitiveIndicesCollector():
|
||||
_buildKdTree(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline void operator () (unsigned int p0)
|
||||
{
|
||||
OSG_NOTICE<<" point ("<<p0<<")"<<std::endl;
|
||||
const osg::Vec3& v0 = (*(_buildKdTree->_kdTree.getVertices()))[p0];
|
||||
|
||||
_buildKdTree->_kdTree.addPoint(p0);
|
||||
|
||||
osg::BoundingBox bb;
|
||||
bb.expandBy(v0);
|
||||
|
||||
_buildKdTree->_primitiveIndices.push_back(_buildKdTree->_centers.size());
|
||||
_buildKdTree->_centers.push_back(bb.center());
|
||||
}
|
||||
|
||||
inline void operator () (unsigned int p0, unsigned int p1)
|
||||
{
|
||||
OSG_NOTICE<<" line ("<<p0<<", "<<p1<<")"<<std::endl;
|
||||
const osg::Vec3& v0 = (*(_buildKdTree->_kdTree.getVertices()))[p0];
|
||||
const osg::Vec3& v1 = (*(_buildKdTree->_kdTree.getVertices()))[p1];
|
||||
|
||||
// discard degenerate points
|
||||
if (v0==v1)
|
||||
{
|
||||
//OSG_NOTICE<<"Disgarding degenerate triangle"<<std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
_buildKdTree->_kdTree.addLine(p0,p1);
|
||||
|
||||
osg::BoundingBox bb;
|
||||
bb.expandBy(v0);
|
||||
bb.expandBy(v1);
|
||||
|
||||
_buildKdTree->_primitiveIndices.push_back(_buildKdTree->_centers.size());
|
||||
_buildKdTree->_centers.push_back(bb.center());
|
||||
}
|
||||
|
||||
inline void operator () (unsigned int p0, unsigned int p1, unsigned int p2)
|
||||
{
|
||||
// OSG_NOTICE<<" triangle ("<<p0<<", "<<p1<<", "<<p2<<")"<<std::endl;
|
||||
|
||||
const osg::Vec3& v0 = (*(_buildKdTree->_kdTree.getVertices()))[p0];
|
||||
const osg::Vec3& v1 = (*(_buildKdTree->_kdTree.getVertices()))[p1];
|
||||
const osg::Vec3& v2 = (*(_buildKdTree->_kdTree.getVertices()))[p2];
|
||||
@ -77,16 +114,43 @@ struct TriangleIndicesCollector
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned int i = _buildKdTree->_kdTree.addTriangle(KdTree::Triangle(p0,p1,p2));
|
||||
_buildKdTree->_kdTree.addTriangle(p0,p1,p2);
|
||||
|
||||
osg::BoundingBox bb;
|
||||
bb.expandBy(v0);
|
||||
bb.expandBy(v1);
|
||||
bb.expandBy(v2);
|
||||
|
||||
_buildKdTree->_primitiveIndices.push_back(_buildKdTree->_centers.size());
|
||||
_buildKdTree->_centers.push_back(bb.center());
|
||||
_buildKdTree->_primitiveIndices.push_back(i);
|
||||
}
|
||||
|
||||
inline void operator () (unsigned int p0, unsigned int p1, unsigned int p2, unsigned int p3)
|
||||
{
|
||||
OSG_NOTICE<<" quad ("<<p0<<", "<<p1<<", "<<p2<<", "<<p3<<")"<<std::endl;
|
||||
|
||||
const osg::Vec3& v0 = (*(_buildKdTree->_kdTree.getVertices()))[p0];
|
||||
const osg::Vec3& v1 = (*(_buildKdTree->_kdTree.getVertices()))[p1];
|
||||
const osg::Vec3& v2 = (*(_buildKdTree->_kdTree.getVertices()))[p2];
|
||||
const osg::Vec3& v3 = (*(_buildKdTree->_kdTree.getVertices()))[p3];
|
||||
|
||||
// discard degenerate points
|
||||
if (v0==v1 || v1==v2 || v2==v0 || v3==v0 || v3==v1 || v3==v2)
|
||||
{
|
||||
//OSG_NOTICE<<"Disgarding degenerate quad"<<std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
_buildKdTree->_kdTree.addQuad(p0,p1,p2,p3);
|
||||
|
||||
osg::BoundingBox bb;
|
||||
bb.expandBy(v0);
|
||||
bb.expandBy(v1);
|
||||
bb.expandBy(v2);
|
||||
bb.expandBy(v3);
|
||||
|
||||
_buildKdTree->_primitiveIndices.push_back(_buildKdTree->_centers.size());
|
||||
_buildKdTree->_centers.push_back(bb.center());
|
||||
}
|
||||
|
||||
BuildKdTree* _buildKdTree;
|
||||
@ -129,11 +193,9 @@ bool BuildKdTree::build(KdTree::BuildOptions& options, osg::Geometry* geometry)
|
||||
_primitiveIndices.reserve(estimatedNumTriangles);
|
||||
_centers.reserve(estimatedNumTriangles);
|
||||
|
||||
_kdTree.getTriangles().reserve(estimatedNumTriangles);
|
||||
|
||||
osg::TriangleIndexFunctor<TriangleIndicesCollector> collectTriangleIndices;
|
||||
collectTriangleIndices._buildKdTree = this;
|
||||
geometry->accept(collectTriangleIndices);
|
||||
osg::TemplatePrimitiveIndexFunctor<PrimitiveIndicesCollector> collectIndices;
|
||||
collectIndices._buildKdTree = this;
|
||||
geometry->accept(collectIndices);
|
||||
|
||||
_primitiveIndices.reserve(vertices->size());
|
||||
|
||||
@ -145,14 +207,18 @@ bool BuildKdTree::build(KdTree::BuildOptions& options, osg::Geometry* geometry)
|
||||
osg::BoundingBox bb = _bb;
|
||||
nodeNum = divide(options, bb, nodeNum, 0);
|
||||
|
||||
// now reorder the triangle list so that it's in order as per the primitiveIndex list.
|
||||
KdTree::TriangleList triangleList(_kdTree.getTriangles().size());
|
||||
for(unsigned int i=0; i<_primitiveIndices.size(); ++i)
|
||||
{
|
||||
triangleList[i] = _kdTree.getTriangle(_primitiveIndices[i]);
|
||||
}
|
||||
OSG_NOTICE<<"After KdTree setup"<<std::endl;
|
||||
osg::KdTree::Indices& primitiveIndices = _kdTree.getPrimitiveIndices();
|
||||
|
||||
_kdTree.getTriangles().swap(triangleList);
|
||||
KdTree::Indices new_indices;
|
||||
new_indices.reserve(_primitiveIndices.size());
|
||||
for(Indices::iterator itr = _primitiveIndices.begin();
|
||||
itr != _primitiveIndices.end();
|
||||
++itr)
|
||||
{
|
||||
new_indices.push_back(primitiveIndices[*itr]);
|
||||
}
|
||||
primitiveIndices.swap(new_indices);
|
||||
|
||||
|
||||
#ifdef VERBOSE_OUTPUT
|
||||
@ -217,18 +283,22 @@ int BuildKdTree::divide(KdTree::BuildOptions& options, osg::BoundingBox& bb, int
|
||||
int istart = -node.first-1;
|
||||
int iend = istart+node.second-1;
|
||||
|
||||
OSG_NOTICE<<"Computing bb on KdNode, numPrimitives="<<node.second<<std::endl;
|
||||
|
||||
// leaf is done, now compute bound on it.
|
||||
node.bb.init();
|
||||
for(int i=istart; i<=iend; ++i)
|
||||
{
|
||||
const KdTree::Triangle& tri = _kdTree.getTriangle(_primitiveIndices[i]);
|
||||
const osg::Vec3& v0 = (*_kdTree.getVertices())[tri.p0];
|
||||
const osg::Vec3& v1 = (*_kdTree.getVertices())[tri.p1];
|
||||
const osg::Vec3& v2 = (*_kdTree.getVertices())[tri.p2];
|
||||
node.bb.expandBy(v0);
|
||||
node.bb.expandBy(v1);
|
||||
node.bb.expandBy(v2);
|
||||
|
||||
unsigned int primitiveIndex = _kdTree.getPrimitiveIndices()[_primitiveIndices[i]];
|
||||
unsigned int numPoints = _kdTree.getVertexIndices()[primitiveIndex++];
|
||||
OSG_NOTICE<<" Primitive "<<primitiveIndex<<", numPoints="<<numPoints<<std::endl;
|
||||
for(; numPoints>0; --numPoints)
|
||||
{
|
||||
unsigned int vi = _kdTree.getVertexIndices()[primitiveIndex++];
|
||||
const osg::Vec3& v = (*_kdTree.getVertices())[vi];
|
||||
node.bb.expandBy(v);
|
||||
OSG_NOTICE<<" vi="<<vi<<", v="<<v<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
if (node.bb.valid())
|
||||
@ -314,26 +384,6 @@ int BuildKdTree::divide(KdTree::BuildOptions& options, osg::BoundingBox& bb, int
|
||||
KdTree::KdNode leftLeaf(-istart-1, (right-istart)+1);
|
||||
KdTree::KdNode rightLeaf(-left-1, (iend-left)+1);
|
||||
|
||||
#if 0
|
||||
OSG_NOTICE<<"In node.first ="<<node.first <<" node.second ="<<node.second<<std::endl;
|
||||
OSG_NOTICE<<" leftLeaf.first ="<<leftLeaf.first <<" leftLeaf.second ="<<leftLeaf.second<<std::endl;
|
||||
OSG_NOTICE<<" rightLeaf.first="<<rightLeaf.first<<" rightLeaf.second="<<rightLeaf.second<<std::endl;
|
||||
OSG_NOTICE<<" left="<<left<<" right="<<right<<std::endl;
|
||||
|
||||
if (node.second != (leftLeaf.second +rightLeaf.second))
|
||||
{
|
||||
OSG_NOTICE<<"*** Error in size, leaf.second="<<node.second
|
||||
<<", leftLeaf.second="<<leftLeaf.second
|
||||
<<", rightLeaf.second="<<rightLeaf.second<<std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
OSG_NOTICE<<"Size OK, leaf.second="<<node.second
|
||||
<<", leftLeaf.second="<<leftLeaf.second
|
||||
<<", rightLeaf.second="<<rightLeaf.second<<std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (leftLeaf.second<=0)
|
||||
{
|
||||
//OSG_NOTICE<<"LeftLeaf empty"<<std::endl;
|
||||
@ -421,316 +471,6 @@ int BuildKdTree::divide(KdTree::BuildOptions& options, osg::BoundingBox& bb, int
|
||||
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IntersectKdTree
|
||||
//
|
||||
struct IntersectKdTree
|
||||
{
|
||||
IntersectKdTree(const osg::Vec3Array& vertices,
|
||||
const KdTree::KdNodeList& nodes,
|
||||
const KdTree::TriangleList& triangles,
|
||||
KdTree::LineSegmentIntersections& intersections,
|
||||
const osg::Vec3d& s, const osg::Vec3d& e):
|
||||
_vertices(vertices),
|
||||
_kdNodes(nodes),
|
||||
_triangles(triangles),
|
||||
_intersections(intersections),
|
||||
_s(s),
|
||||
_e(e)
|
||||
{
|
||||
_d = e - s;
|
||||
_length = _d.length();
|
||||
_inverse_length = _length!=0.0f ? 1.0f/_length : 0.0;
|
||||
_d *= _inverse_length;
|
||||
|
||||
_d_invX = _d.x()!=0.0f ? _d/_d.x() : osg::Vec3(0.0f,0.0f,0.0f);
|
||||
_d_invY = _d.y()!=0.0f ? _d/_d.y() : osg::Vec3(0.0f,0.0f,0.0f);
|
||||
_d_invZ = _d.z()!=0.0f ? _d/_d.z() : osg::Vec3(0.0f,0.0f,0.0f);
|
||||
}
|
||||
|
||||
void intersect(const KdTree::KdNode& node, const osg::Vec3& s, const osg::Vec3& e) const;
|
||||
bool intersectAndClip(osg::Vec3& s, osg::Vec3& e, const osg::BoundingBox& bb) const;
|
||||
|
||||
const osg::Vec3Array& _vertices;
|
||||
const KdTree::KdNodeList& _kdNodes;
|
||||
const KdTree::TriangleList& _triangles;
|
||||
KdTree::LineSegmentIntersections& _intersections;
|
||||
|
||||
osg::Vec3 _s;
|
||||
osg::Vec3 _e;
|
||||
|
||||
osg::Vec3 _d;
|
||||
float _length;
|
||||
float _inverse_length;
|
||||
|
||||
osg::Vec3 _d_invX;
|
||||
osg::Vec3 _d_invY;
|
||||
osg::Vec3 _d_invZ;
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
IntersectKdTree& operator = (const IntersectKdTree&) { return *this; }
|
||||
};
|
||||
|
||||
|
||||
void IntersectKdTree::intersect(const KdTree::KdNode& node, const osg::Vec3& ls, const osg::Vec3& le) const
|
||||
{
|
||||
if (node.first<0)
|
||||
{
|
||||
// treat as a leaf
|
||||
|
||||
//OSG_NOTICE<<"KdTree::intersect("<<&leaf<<")"<<std::endl;
|
||||
int istart = -node.first-1;
|
||||
int iend = istart + node.second;
|
||||
|
||||
for(int i=istart; i<iend; ++i)
|
||||
{
|
||||
//const Triangle& tri = _triangles[_primitiveIndices[i]];
|
||||
const KdTree::Triangle& tri = _triangles[i];
|
||||
// OSG_NOTICE<<" tri("<<tri.p1<<","<<tri.p2<<","<<tri.p3<<")"<<std::endl;
|
||||
|
||||
const osg::Vec3& v0 = _vertices[tri.p0];
|
||||
const osg::Vec3& v1 = _vertices[tri.p1];
|
||||
const osg::Vec3& v2 = _vertices[tri.p2];
|
||||
|
||||
osg::Vec3 T = _s - v0;
|
||||
osg::Vec3 E2 = v2 - v0;
|
||||
osg::Vec3 E1 = v1 - v0;
|
||||
|
||||
osg::Vec3 P = _d ^ E2;
|
||||
|
||||
float det = P * E1;
|
||||
|
||||
float r,r0,r1,r2;
|
||||
|
||||
const float esplison = 1e-10f;
|
||||
if (det>esplison)
|
||||
{
|
||||
float u = (P*T);
|
||||
if (u<0.0 || u>det) continue;
|
||||
|
||||
osg::Vec3 Q = T ^ E1;
|
||||
float v = (Q*_d);
|
||||
if (v<0.0 || v>det) continue;
|
||||
|
||||
if ((u+v)> det) continue;
|
||||
|
||||
float inv_det = 1.0f/det;
|
||||
float t = (Q*E2)*inv_det;
|
||||
if (t<0.0 || t>_length) continue;
|
||||
|
||||
u *= inv_det;
|
||||
v *= inv_det;
|
||||
|
||||
r0 = 1.0f-u-v;
|
||||
r1 = u;
|
||||
r2 = v;
|
||||
r = t * _inverse_length;
|
||||
}
|
||||
else if (det<-esplison)
|
||||
{
|
||||
|
||||
float u = (P*T);
|
||||
if (u>0.0 || u<det) continue;
|
||||
|
||||
osg::Vec3 Q = T ^ E1;
|
||||
float v = (Q*_d);
|
||||
if (v>0.0 || v<det) continue;
|
||||
|
||||
if ((u+v) < det) continue;
|
||||
|
||||
float inv_det = 1.0f/det;
|
||||
float t = (Q*E2)*inv_det;
|
||||
if (t<0.0 || t>_length) continue;
|
||||
|
||||
u *= inv_det;
|
||||
v *= inv_det;
|
||||
|
||||
r0 = 1.0f-u-v;
|
||||
r1 = u;
|
||||
r2 = v;
|
||||
r = t * _inverse_length;
|
||||
}
|
||||
else
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
osg::Vec3 in = v0*r0 + v1*r1 + v2*r2;
|
||||
osg::Vec3 normal = E1^E2;
|
||||
normal.normalize();
|
||||
|
||||
#if 1
|
||||
_intersections.push_back(KdTree::LineSegmentIntersection());
|
||||
KdTree::LineSegmentIntersection& intersection = _intersections.back();
|
||||
|
||||
intersection.ratio = r;
|
||||
intersection.primitiveIndex = i;
|
||||
intersection.intersectionPoint = in;
|
||||
intersection.intersectionNormal = normal;
|
||||
|
||||
intersection.p0 = tri.p0;
|
||||
intersection.p1 = tri.p1;
|
||||
intersection.p2 = tri.p2;
|
||||
intersection.r0 = r0;
|
||||
intersection.r1 = r1;
|
||||
intersection.r2 = r2;
|
||||
|
||||
#endif
|
||||
// OSG_NOTICE<<" got intersection ("<<in<<") ratio="<<r<<std::endl;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (node.first>0)
|
||||
{
|
||||
osg::Vec3 l(ls), e(le);
|
||||
if (intersectAndClip(l,e, _kdNodes[node.first].bb))
|
||||
{
|
||||
intersect(_kdNodes[node.first], l, e);
|
||||
}
|
||||
}
|
||||
if (node.second>0)
|
||||
{
|
||||
osg::Vec3 l(ls), e(le);
|
||||
if (intersectAndClip(l,e, _kdNodes[node.second].bb))
|
||||
{
|
||||
intersect(_kdNodes[node.second], l, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool IntersectKdTree::intersectAndClip(osg::Vec3& s, osg::Vec3& e, const osg::BoundingBox& bb) const
|
||||
{
|
||||
//return true;
|
||||
|
||||
//if (!bb.valid()) return true;
|
||||
|
||||
// compate s and e against the xMin to xMax range of bb.
|
||||
if (s.x()<=e.x())
|
||||
{
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.x()<bb.xMin()) return false;
|
||||
if (s.x()>bb.xMax()) return false;
|
||||
|
||||
if (s.x()<bb.xMin())
|
||||
{
|
||||
// clip s to xMin.
|
||||
s = s+_d_invX*(bb.xMin()-s.x());
|
||||
}
|
||||
|
||||
if (e.x()>bb.xMax())
|
||||
{
|
||||
// clip e to xMax.
|
||||
e = s+_d_invX*(bb.xMax()-s.x());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s.x()<bb.xMin()) return false;
|
||||
if (e.x()>bb.xMax()) return false;
|
||||
|
||||
if (e.x()<bb.xMin())
|
||||
{
|
||||
// clip s to xMin.
|
||||
e = s+_d_invX*(bb.xMin()-s.x());
|
||||
}
|
||||
|
||||
if (s.x()>bb.xMax())
|
||||
{
|
||||
// clip e to xMax.
|
||||
s = s+_d_invX*(bb.xMax()-s.x());
|
||||
}
|
||||
}
|
||||
|
||||
// compate s and e against the yMin to yMax range of bb.
|
||||
if (s.y()<=e.y())
|
||||
{
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.y()<bb.yMin()) return false;
|
||||
if (s.y()>bb.yMax()) return false;
|
||||
|
||||
if (s.y()<bb.yMin())
|
||||
{
|
||||
// clip s to yMin.
|
||||
s = s+_d_invY*(bb.yMin()-s.y());
|
||||
}
|
||||
|
||||
if (e.y()>bb.yMax())
|
||||
{
|
||||
// clip e to yMax.
|
||||
e = s+_d_invY*(bb.yMax()-s.y());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s.y()<bb.yMin()) return false;
|
||||
if (e.y()>bb.yMax()) return false;
|
||||
|
||||
if (e.y()<bb.yMin())
|
||||
{
|
||||
// clip s to yMin.
|
||||
e = s+_d_invY*(bb.yMin()-s.y());
|
||||
}
|
||||
|
||||
if (s.y()>bb.yMax())
|
||||
{
|
||||
// clip e to yMax.
|
||||
s = s+_d_invY*(bb.yMax()-s.y());
|
||||
}
|
||||
}
|
||||
|
||||
// compate s and e against the zMin to zMax range of bb.
|
||||
if (s.z()<=e.z())
|
||||
{
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.z()<bb.zMin()) return false;
|
||||
if (s.z()>bb.zMax()) return false;
|
||||
|
||||
if (s.z()<bb.zMin())
|
||||
{
|
||||
// clip s to zMin.
|
||||
s = s+_d_invZ*(bb.zMin()-s.z());
|
||||
}
|
||||
|
||||
if (e.z()>bb.zMax())
|
||||
{
|
||||
// clip e to zMax.
|
||||
e = s+_d_invZ*(bb.zMax()-s.z());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s.z()<bb.zMin()) return false;
|
||||
if (e.z()>bb.zMax()) return false;
|
||||
|
||||
if (e.z()<bb.zMin())
|
||||
{
|
||||
// clip s to zMin.
|
||||
e = s+_d_invZ*(bb.zMin()-s.z());
|
||||
}
|
||||
|
||||
if (s.z()>bb.zMax())
|
||||
{
|
||||
// clip e to zMax.
|
||||
s = s+_d_invZ*(bb.zMax()-s.z());
|
||||
}
|
||||
}
|
||||
|
||||
// OSG_NOTICE<<"clampped segment "<<s<<" "<<e<<std::endl;
|
||||
|
||||
// if (s==e) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// KdTree::BuildOptions
|
||||
@ -753,8 +493,7 @@ KdTree::KdTree()
|
||||
KdTree::KdTree(const KdTree& rhs, const osg::CopyOp& copyop):
|
||||
Shape(rhs, copyop),
|
||||
_vertices(rhs._vertices),
|
||||
_kdNodes(rhs._kdNodes),
|
||||
_triangles(rhs._triangles)
|
||||
_kdNodes(rhs._kdNodes)
|
||||
{
|
||||
}
|
||||
|
||||
@ -764,27 +503,6 @@ bool KdTree::build(BuildOptions& options, osg::Geometry* geometry)
|
||||
return build.build(options, geometry);
|
||||
}
|
||||
|
||||
bool KdTree::intersect(const osg::Vec3d& start, const osg::Vec3d& end, LineSegmentIntersections& intersections) const
|
||||
{
|
||||
if (_kdNodes.empty())
|
||||
{
|
||||
OSG_NOTICE<<"Warning: _kdTree is empty"<<std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned int numIntersectionsBefore = intersections.size();
|
||||
|
||||
IntersectKdTree intersector(*_vertices,
|
||||
_kdNodes,
|
||||
_triangles,
|
||||
intersections,
|
||||
start, end);
|
||||
|
||||
intersector.intersect(getNode(0), start, end);
|
||||
|
||||
return numIntersectionsBefore != intersections.size();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// KdTreeBuilder
|
||||
|
||||
@ -21,187 +21,393 @@
|
||||
#include <osg/KdTree>
|
||||
#include <osg/Timer>
|
||||
#include <osg/TexMat>
|
||||
#include <osg/TemplatePrimitiveFunctor>
|
||||
|
||||
using namespace osgUtil;
|
||||
|
||||
namespace LineSegmentIntersectorUtils
|
||||
{
|
||||
struct TriangleIntersection
|
||||
|
||||
struct Settings : public osg::Referenced
|
||||
{
|
||||
TriangleIntersection(unsigned int index, const osg::Vec3& normal, float r1, const osg::Vec3* v1, float r2, const osg::Vec3* v2, float r3, const osg::Vec3* v3):
|
||||
_index(index),
|
||||
_normal(normal),
|
||||
_r1(r1),
|
||||
_v1(v1),
|
||||
_r2(r2),
|
||||
_v2(v2),
|
||||
_r3(r3),
|
||||
_v3(v3) {}
|
||||
Settings() :
|
||||
_lineSegIntersector(0),
|
||||
_iv(0),
|
||||
_drawable(0),
|
||||
_limitOneIntersection(false) {}
|
||||
|
||||
unsigned int _index;
|
||||
const osg::Vec3 _normal;
|
||||
float _r1;
|
||||
const osg::Vec3* _v1;
|
||||
float _r2;
|
||||
const osg::Vec3* _v2;
|
||||
float _r3;
|
||||
const osg::Vec3* _v3;
|
||||
|
||||
protected:
|
||||
|
||||
TriangleIntersection& operator = (const TriangleIntersection&) { return *this; }
|
||||
osgUtil::LineSegmentIntersector* _lineSegIntersector;
|
||||
osgUtil::IntersectionVisitor* _iv;
|
||||
osg::Drawable* _drawable;
|
||||
osg::ref_ptr<osg::Vec3Array> _vertices;
|
||||
bool _limitOneIntersection;
|
||||
};
|
||||
|
||||
typedef std::multimap<float,TriangleIntersection> TriangleIntersections;
|
||||
|
||||
|
||||
template<typename Vec3, typename value_type>
|
||||
struct TriangleIntersector
|
||||
struct IntersectFunctor
|
||||
{
|
||||
Vec3 _s;
|
||||
osg::ref_ptr<Settings> _settings;
|
||||
|
||||
unsigned int _primitiveIndex;
|
||||
Vec3 _start;
|
||||
Vec3 _end;
|
||||
|
||||
typedef std::pair< Vec3, Vec3> StartEnd;
|
||||
typedef std::vector< StartEnd > StartEndStack;
|
||||
|
||||
StartEndStack _startEndStack;
|
||||
|
||||
Vec3 _d;
|
||||
value_type _length;
|
||||
value_type _inverse_length;
|
||||
|
||||
Vec3 _d_invX;
|
||||
Vec3 _d_invY;
|
||||
Vec3 _d_invZ;
|
||||
|
||||
int _index;
|
||||
value_type _ratio;
|
||||
bool _hit;
|
||||
bool _limitOneIntersection;
|
||||
TriangleIntersections* _intersections;
|
||||
|
||||
TriangleIntersector()
|
||||
IntersectFunctor():
|
||||
_primitiveIndex(0),
|
||||
_hit(false)
|
||||
{
|
||||
_intersections = 0;
|
||||
_length = 0.0f;
|
||||
_index = 0;
|
||||
_ratio = 0.0f;
|
||||
_hit = false;
|
||||
_limitOneIntersection = false;
|
||||
}
|
||||
|
||||
void set(TriangleIntersections* intersections)
|
||||
{
|
||||
_intersections = intersections;
|
||||
}
|
||||
|
||||
void set(const osg::Vec3d& start, const osg::Vec3d& end, value_type ratio=FLT_MAX)
|
||||
void set(const osg::Vec3d& s, const osg::Vec3d& e, Settings* settings)
|
||||
{
|
||||
_hit=false;
|
||||
_index = 0;
|
||||
_ratio = ratio;
|
||||
_settings = settings;
|
||||
|
||||
_s = start;
|
||||
_d = end - start;
|
||||
_start = s;
|
||||
_end = e;
|
||||
|
||||
_startEndStack.push_back(StartEnd(_start,_end));
|
||||
|
||||
_d = e - s;
|
||||
_length = _d.length();
|
||||
_d /= _length;
|
||||
_inverse_length = (_length!=0.0) ? 1.0/_length : 0.0;
|
||||
_d *= _inverse_length;
|
||||
|
||||
_d_invX = _d.x()!=0.0 ? _d/_d.x() : Vec3(0.0,0.0,0.0);
|
||||
_d_invY = _d.y()!=0.0 ? _d/_d.y() : Vec3(0.0,0.0,0.0);
|
||||
_d_invZ = _d.z()!=0.0 ? _d/_d.z() : Vec3(0.0,0.0,0.0);
|
||||
}
|
||||
|
||||
inline void operator () (const osg::Vec3& v1,const osg::Vec3& v2,const osg::Vec3& v3)
|
||||
bool enter(const osg::BoundingBox& bb)
|
||||
{
|
||||
++_index;
|
||||
StartEnd startend = _startEndStack.back();
|
||||
Vec3& s = startend.first;
|
||||
Vec3& e = startend.second;
|
||||
|
||||
if (_limitOneIntersection && _hit) return;
|
||||
//return true;
|
||||
|
||||
if (v1==v2 || v2==v3 || v1==v3) return;
|
||||
//if (!bb.valid()) return true;
|
||||
|
||||
Vec3 v12 = v2-v1;
|
||||
Vec3 n12 = v12^_d;
|
||||
value_type ds12 = (_s-v1)*n12;
|
||||
value_type d312 = (v3-v1)*n12;
|
||||
if (d312>=0.0f)
|
||||
// compare s and e against the xMin to xMax range of bb.
|
||||
if (s.x()<=e.x())
|
||||
{
|
||||
if (ds12<0.0f) return;
|
||||
if (ds12>d312) return;
|
||||
}
|
||||
else // d312 < 0
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.x()<bb.xMin()) return false;
|
||||
if (s.x()>bb.xMax()) return false;
|
||||
|
||||
if (s.x()<bb.xMin())
|
||||
{
|
||||
if (ds12>0.0f) return;
|
||||
if (ds12<d312) return;
|
||||
// clip s to xMin.
|
||||
s = s+_d_invX*(bb.xMin()-s.x());
|
||||
}
|
||||
|
||||
Vec3 v23 = v3-v2;
|
||||
Vec3 n23 = v23^_d;
|
||||
value_type ds23 = (_s-v2)*n23;
|
||||
value_type d123 = (v1-v2)*n23;
|
||||
if (d123>=0.0f)
|
||||
if (e.x()>bb.xMax())
|
||||
{
|
||||
if (ds23<0.0f) return;
|
||||
if (ds23>d123) return;
|
||||
// clip e to xMax.
|
||||
e = s+_d_invX*(bb.xMax()-s.x());
|
||||
}
|
||||
else // d123 < 0
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ds23>0.0f) return;
|
||||
if (ds23<d123) return;
|
||||
if (s.x()<bb.xMin()) return false;
|
||||
if (e.x()>bb.xMax()) return false;
|
||||
|
||||
if (e.x()<bb.xMin())
|
||||
{
|
||||
// clip s to xMin.
|
||||
e = s+_d_invX*(bb.xMin()-s.x());
|
||||
}
|
||||
|
||||
Vec3 v31 = v1-v3;
|
||||
Vec3 n31 = v31^_d;
|
||||
value_type ds31 = (_s-v3)*n31;
|
||||
value_type d231 = (v2-v3)*n31;
|
||||
if (d231>=0.0f)
|
||||
if (s.x()>bb.xMax())
|
||||
{
|
||||
if (ds31<0.0f) return;
|
||||
if (ds31>d231) return;
|
||||
// clip e to xMax.
|
||||
s = s+_d_invX*(bb.xMax()-s.x());
|
||||
}
|
||||
else // d231 < 0
|
||||
{
|
||||
if (ds31>0.0f) return;
|
||||
if (ds31<d231) return;
|
||||
}
|
||||
|
||||
|
||||
value_type r3;
|
||||
if (ds12==0.0f) r3=0.0f;
|
||||
else if (d312!=0.0f) r3 = ds12/d312;
|
||||
else return; // the triangle and the line must be parallel intersection.
|
||||
|
||||
value_type r1;
|
||||
if (ds23==0.0f) r1=0.0f;
|
||||
else if (d123!=0.0f) r1 = ds23/d123;
|
||||
else return; // the triangle and the line must be parallel intersection.
|
||||
|
||||
value_type r2;
|
||||
if (ds31==0.0f) r2=0.0f;
|
||||
else if (d231!=0.0f) r2 = ds31/d231;
|
||||
else return; // the triangle and the line must be parallel intersection.
|
||||
|
||||
value_type total_r = (r1+r2+r3);
|
||||
if (total_r!=1.0f)
|
||||
// compate s and e against the yMin to yMax range of bb.
|
||||
if (s.y()<=e.y())
|
||||
{
|
||||
if (total_r==0.0f) return; // the triangle and the line must be parallel intersection.
|
||||
value_type inv_total_r = 1.0f/total_r;
|
||||
r1 *= inv_total_r;
|
||||
r2 *= inv_total_r;
|
||||
r3 *= inv_total_r;
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.y()<bb.yMin()) return false;
|
||||
if (s.y()>bb.yMax()) return false;
|
||||
|
||||
if (s.y()<bb.yMin())
|
||||
{
|
||||
// clip s to yMin.
|
||||
s = s+_d_invY*(bb.yMin()-s.y());
|
||||
}
|
||||
|
||||
Vec3 in = v1*r1+v2*r2+v3*r3;
|
||||
if (!in.valid())
|
||||
if (e.y()>bb.yMax())
|
||||
{
|
||||
// clip e to yMax.
|
||||
e = s+_d_invY*(bb.yMax()-s.y());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s.y()<bb.yMin()) return false;
|
||||
if (e.y()>bb.yMax()) return false;
|
||||
|
||||
if (e.y()<bb.yMin())
|
||||
{
|
||||
// clip s to yMin.
|
||||
e = s+_d_invY*(bb.yMin()-s.y());
|
||||
}
|
||||
|
||||
if (s.y()>bb.yMax())
|
||||
{
|
||||
// clip e to yMax.
|
||||
s = s+_d_invY*(bb.yMax()-s.y());
|
||||
}
|
||||
}
|
||||
|
||||
// compate s and e against the zMin to zMax range of bb.
|
||||
if (s.z()<=e.z())
|
||||
{
|
||||
|
||||
// trivial reject of segment wholely outside.
|
||||
if (e.z()<bb.zMin()) return false;
|
||||
if (s.z()>bb.zMax()) return false;
|
||||
|
||||
if (s.z()<bb.zMin())
|
||||
{
|
||||
// clip s to zMin.
|
||||
s = s+_d_invZ*(bb.zMin()-s.z());
|
||||
}
|
||||
|
||||
if (e.z()>bb.zMax())
|
||||
{
|
||||
// clip e to zMax.
|
||||
e = s+_d_invZ*(bb.zMax()-s.z());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s.z()<bb.zMin()) return false;
|
||||
if (e.z()>bb.zMax()) return false;
|
||||
|
||||
if (e.z()<bb.zMin())
|
||||
{
|
||||
// clip s to zMin.
|
||||
e = s+_d_invZ*(bb.zMin()-s.z());
|
||||
}
|
||||
|
||||
if (s.z()>bb.zMax())
|
||||
{
|
||||
// clip e to zMax.
|
||||
s = s+_d_invZ*(bb.zMax()-s.z());
|
||||
}
|
||||
}
|
||||
|
||||
// OSG_NOTICE<<"clampped segment "<<s<<" "<<e<<std::endl;
|
||||
_startEndStack.push_back(startend);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void leave()
|
||||
{
|
||||
// OSG_NOTICE<<"leave() "<<_startEndStack.size()<<std::endl;
|
||||
_startEndStack.pop_back();
|
||||
}
|
||||
|
||||
void intersect(const osg::Vec3& v0, const osg::Vec3& v1, const osg::Vec3& v2)
|
||||
{
|
||||
if (_settings->_limitOneIntersection && _hit) return;
|
||||
|
||||
// OSG_NOTICE<<" intersect(v0=("<<v0<<"), v1=("<<v1<<"), v2=("<<v2<<") )"<<std::endl;
|
||||
|
||||
// const StartEnd startend = _startEndStack.back();
|
||||
// const osg::Vec3& ls = startend.first;
|
||||
// const osg::Vec3& le = startend.second;
|
||||
|
||||
Vec3 T = _start - v0;
|
||||
Vec3 E2 = v2 - v0;
|
||||
Vec3 E1 = v1 - v0;
|
||||
|
||||
Vec3 P = _d ^ E2;
|
||||
|
||||
value_type det = P * E1;
|
||||
|
||||
value_type r,r0,r1,r2;
|
||||
|
||||
const value_type esplison = 1e-10;
|
||||
if (det>esplison)
|
||||
{
|
||||
value_type u = (P*T);
|
||||
if (u<0.0 || u>det) return;
|
||||
|
||||
osg::Vec3 Q = T ^ E1;
|
||||
value_type v = (Q*_d);
|
||||
if (v<0.0 || v>det) return;
|
||||
|
||||
if ((u+v)> det) return;
|
||||
|
||||
value_type inv_det = 1.0/det;
|
||||
value_type t = (Q*E2)*inv_det;
|
||||
if (t<0.0 || t>_length) return;
|
||||
|
||||
u *= inv_det;
|
||||
v *= inv_det;
|
||||
|
||||
r0 = 1.0-u-v;
|
||||
r1 = u;
|
||||
r2 = v;
|
||||
r = t * _inverse_length;
|
||||
}
|
||||
else if (det<-esplison)
|
||||
{
|
||||
value_type u = (P*T);
|
||||
if (u>0.0 || u<det) return;
|
||||
|
||||
Vec3 Q = T ^ E1;
|
||||
value_type v = (Q*_d);
|
||||
if (v>0.0 || v<det) return;
|
||||
|
||||
if ((u+v) < det) return;
|
||||
|
||||
value_type inv_det = 1.0/det;
|
||||
value_type t = (Q*E2)*inv_det;
|
||||
if (t<0.0 || t>_length) return;
|
||||
|
||||
u *= inv_det;
|
||||
v *= inv_det;
|
||||
|
||||
r0 = 1.0-u-v;
|
||||
r1 = u;
|
||||
r2 = v;
|
||||
r = t * _inverse_length;
|
||||
}
|
||||
else
|
||||
{
|
||||
OSG_WARN<<"Warning:: Picked up error in TriangleIntersect"<<std::endl;
|
||||
OSG_WARN<<" ("<<v1<<",\t"<<v2<<",\t"<<v3<<")"<<std::endl;
|
||||
OSG_WARN<<" ("<<r1<<",\t"<<r2<<",\t"<<r3<<")"<<std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
value_type d = (in-_s)*_d;
|
||||
|
||||
if (d<0.0f) return;
|
||||
if (d>_length) return;
|
||||
|
||||
Vec3 normal = v12^v23;
|
||||
Vec3 in = v0*r0 + v1*r1 + v2*r2;
|
||||
Vec3 normal = E1^E2;
|
||||
normal.normalize();
|
||||
|
||||
value_type r = d/_length;
|
||||
|
||||
LineSegmentIntersector::Intersection hit;
|
||||
hit.ratio = r;
|
||||
hit.matrix = _settings->_iv->getModelMatrix();
|
||||
hit.nodePath = _settings->_iv->getNodePath();
|
||||
hit.drawable = _settings->_drawable;
|
||||
hit.primitiveIndex = _primitiveIndex;
|
||||
|
||||
_intersections->insert(std::pair<const float,TriangleIntersection>(r,TriangleIntersection(_index-1,normal,r1,&v1,r2,&v2,r3,&v3)));
|
||||
_hit = true;
|
||||
hit.localIntersectionPoint = in;
|
||||
|
||||
//OSG_NOTICE<<" intersection ("<<in<<") ratio="<<hit.ratio<<", _start=("<<_start<<"), _end=("<<_end<<")"<<std::endl;
|
||||
// osg::Vec3 computed_inttersection = _start*(1.0-r)+_end*r;
|
||||
//OSG_NOTICE<<" computed_intersection("<<computed_inttersection<<")"<<std::endl;
|
||||
|
||||
hit.localIntersectionNormal = normal;
|
||||
|
||||
if (_settings->_vertices.valid())
|
||||
{
|
||||
const osg::Vec3* first = &(_settings->_vertices->front());
|
||||
hit.indexList.reserve(3);
|
||||
hit.ratioList.reserve(3);
|
||||
|
||||
if (r0!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(&v0-first);
|
||||
hit.ratioList.push_back(r0);
|
||||
}
|
||||
|
||||
if (r1!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(&v1-first);
|
||||
hit.ratioList.push_back(r1);
|
||||
}
|
||||
|
||||
if (r2!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(&v2-first);
|
||||
hit.ratioList.push_back(r2);
|
||||
}
|
||||
}
|
||||
|
||||
_settings->_lineSegIntersector->insertIntersection(hit);
|
||||
_hit = true;
|
||||
}
|
||||
|
||||
// handle lines
|
||||
void operator()(const osg::Vec3&, bool /*treatVertexDataAsTemporary*/)
|
||||
{
|
||||
++_primitiveIndex;
|
||||
}
|
||||
|
||||
void operator()(const osg::Vec3&, const osg::Vec3&, bool /*treatVertexDataAsTemporary*/)
|
||||
{
|
||||
++_primitiveIndex;
|
||||
}
|
||||
|
||||
// handle triangles
|
||||
void operator()(const osg::Vec3& v0, const osg::Vec3& v1, const osg::Vec3& v2, bool /*treatVertexDataAsTemporary*/)
|
||||
{
|
||||
++_primitiveIndex;
|
||||
intersect(v0,v1,v2);
|
||||
}
|
||||
|
||||
void operator()(const osg::Vec3& v0, const osg::Vec3& v1, const osg::Vec3& v2, const osg::Vec3& v3, bool /*treatVertexDataAsTemporary*/)
|
||||
{
|
||||
++_primitiveIndex;
|
||||
intersect(v0,v1,v3);
|
||||
intersect(v1,v2,v3);
|
||||
}
|
||||
|
||||
bool intersect(const osg::Vec3Array*, int , unsigned int)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool intersect(const osg::Vec3Array*, int, unsigned int, unsigned int)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool intersect(const osg::Vec3Array* vertices, int primitiveIndex, unsigned int p0, unsigned int p1, unsigned int p2)
|
||||
{
|
||||
if (_settings->_limitOneIntersection && _hit) return false;
|
||||
|
||||
_primitiveIndex = primitiveIndex;
|
||||
|
||||
intersect((*vertices)[p0], (*vertices)[p1], (*vertices)[p2]);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool intersect(const osg::Vec3Array* vertices, int primitiveIndex, unsigned int p0, unsigned int p1, unsigned int p2, unsigned int p3)
|
||||
{
|
||||
if (_settings->_limitOneIntersection && _hit) return false;
|
||||
|
||||
_primitiveIndex = primitiveIndex;
|
||||
|
||||
intersect((*vertices)[p0], (*vertices)[p1], (*vertices)[p3]);
|
||||
intersect((*vertices)[p1], (*vertices)[p2], (*vertices)[p3]);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
} // namespace LineSegmentIntersectorUtils
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -315,157 +521,37 @@ void LineSegmentIntersector::intersect(osgUtil::IntersectionVisitor& iv, osg::Dr
|
||||
void LineSegmentIntersector::intersect(osgUtil::IntersectionVisitor& iv, osg::Drawable* drawable,
|
||||
const osg::Vec3d& s, const osg::Vec3d& e)
|
||||
{
|
||||
if (reachedLimit()) return;
|
||||
|
||||
osg::ref_ptr<LineSegmentIntersectorUtils::Settings> settings = new LineSegmentIntersectorUtils::Settings;
|
||||
settings->_lineSegIntersector = this;
|
||||
settings->_iv = &iv;
|
||||
settings->_drawable = drawable;
|
||||
settings->_limitOneIntersection = (_intersectionLimit == LIMIT_ONE_PER_DRAWABLE || _intersectionLimit == LIMIT_ONE);
|
||||
|
||||
osg::Geometry* geometry = drawable->asGeometry();
|
||||
if (geometry)
|
||||
{
|
||||
settings->_vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
|
||||
}
|
||||
|
||||
osg::KdTree* kdTree = iv.getUseKdTreeWhenAvailable() ? dynamic_cast<osg::KdTree*>(drawable->getShape()) : 0;
|
||||
if (kdTree)
|
||||
{
|
||||
osg::KdTree::LineSegmentIntersections intersections;
|
||||
intersections.reserve(4);
|
||||
if (kdTree->intersect(s,e,intersections))
|
||||
{
|
||||
// OSG_NOTICE<<"Got KdTree intersections"<<std::endl;
|
||||
for(osg::KdTree::LineSegmentIntersections::iterator itr = intersections.begin();
|
||||
itr != intersections.end();
|
||||
++itr)
|
||||
{
|
||||
osg::KdTree::LineSegmentIntersection& lsi = *(itr);
|
||||
|
||||
// get ratio in s,e range
|
||||
double ratio = lsi.ratio;
|
||||
|
||||
// remap ratio into _start, _end range
|
||||
double remap_ratio = ((s-_start).length() + ratio * (e-s).length() )/(_end-_start).length();
|
||||
|
||||
|
||||
Intersection hit;
|
||||
hit.ratio = remap_ratio;
|
||||
hit.matrix = iv.getModelMatrix();
|
||||
hit.nodePath = iv.getNodePath();
|
||||
hit.drawable = drawable;
|
||||
hit.primitiveIndex = lsi.primitiveIndex;
|
||||
|
||||
hit.localIntersectionPoint = _start*(1.0-remap_ratio) + _end*remap_ratio;
|
||||
|
||||
// OSG_NOTICE<<"KdTree: ratio="<<hit.ratio<<" ("<<hit.localIntersectionPoint<<")"<<std::endl;
|
||||
|
||||
hit.localIntersectionNormal = lsi.intersectionNormal;
|
||||
|
||||
hit.indexList.reserve(3);
|
||||
hit.ratioList.reserve(3);
|
||||
if (lsi.r0!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(lsi.p0);
|
||||
hit.ratioList.push_back(lsi.r0);
|
||||
}
|
||||
|
||||
if (lsi.r1!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(lsi.p1);
|
||||
hit.ratioList.push_back(lsi.r1);
|
||||
}
|
||||
|
||||
if (lsi.r2!=0.0f)
|
||||
{
|
||||
hit.indexList.push_back(lsi.p2);
|
||||
hit.ratioList.push_back(lsi.r2);
|
||||
}
|
||||
|
||||
insertIntersection(hit);
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
LineSegmentIntersectorUtils::TriangleIntersections intersections;
|
||||
|
||||
if (getPrecisionHint()==USE_DOUBLE_CALCULATIONS)
|
||||
{
|
||||
OSG_INFO<<"Using double intersections"<<std::endl;
|
||||
typedef LineSegmentIntersectorUtils::TriangleIntersector<osg::Vec3d, osg::Vec3d::value_type> TriangleIntersector;
|
||||
osg::TriangleFunctor< TriangleIntersector > ti;
|
||||
osg::TemplatePrimitiveFunctor<LineSegmentIntersectorUtils::IntersectFunctor<osg::Vec3d, double> > intersector;
|
||||
intersector.set(s,e, settings.get());
|
||||
|
||||
ti.set(&intersections);
|
||||
ti.set(s,e);
|
||||
ti._limitOneIntersection = (_intersectionLimit == LIMIT_ONE_PER_DRAWABLE || _intersectionLimit == LIMIT_ONE);
|
||||
drawable->accept(ti);
|
||||
if (kdTree) kdTree->intersect(intersector, kdTree->getNode(0));
|
||||
else drawable->accept(intersector);
|
||||
}
|
||||
else
|
||||
{
|
||||
OSG_INFO<<"Using float intersections"<<std::endl;
|
||||
typedef LineSegmentIntersectorUtils::TriangleIntersector<osg::Vec3f, osg::Vec3f::value_type> TriangleIntersector;
|
||||
osg::TriangleFunctor< TriangleIntersector > ti;
|
||||
osg::TemplatePrimitiveFunctor<LineSegmentIntersectorUtils::IntersectFunctor<osg::Vec3f, float> > intersector;
|
||||
intersector.set(s,e, settings.get());
|
||||
|
||||
ti.set(&intersections);
|
||||
ti.set(s,e);
|
||||
ti._limitOneIntersection = (_intersectionLimit == LIMIT_ONE_PER_DRAWABLE || _intersectionLimit == LIMIT_ONE);
|
||||
drawable->accept(ti);
|
||||
}
|
||||
|
||||
if (!intersections.empty())
|
||||
{
|
||||
osg::Geometry* geometry = drawable->asGeometry();
|
||||
|
||||
for(LineSegmentIntersectorUtils::TriangleIntersections::iterator thitr = intersections.begin();
|
||||
thitr != intersections.end();
|
||||
++thitr)
|
||||
{
|
||||
|
||||
// get ratio in s,e range
|
||||
double ratio = thitr->first;
|
||||
|
||||
// remap ratio into _start, _end range
|
||||
double remap_ratio = ((s-_start).length() + ratio * (e-s).length() )/(_end-_start).length();
|
||||
|
||||
if ( _intersectionLimit == LIMIT_NEAREST && !getIntersections().empty() )
|
||||
{
|
||||
if (remap_ratio >= getIntersections().begin()->ratio )
|
||||
break;
|
||||
else
|
||||
getIntersections().clear();
|
||||
}
|
||||
|
||||
LineSegmentIntersectorUtils::TriangleIntersection& triHit = thitr->second;
|
||||
|
||||
Intersection hit;
|
||||
hit.ratio = remap_ratio;
|
||||
hit.matrix = iv.getModelMatrix();
|
||||
hit.nodePath = iv.getNodePath();
|
||||
hit.drawable = drawable;
|
||||
hit.primitiveIndex = triHit._index;
|
||||
|
||||
hit.localIntersectionPoint = _start*(1.0-remap_ratio) + _end*remap_ratio;
|
||||
|
||||
// OSG_NOTICE<<"Conventional: ratio="<<hit.ratio<<" ("<<hit.localIntersectionPoint<<")"<<std::endl;
|
||||
|
||||
hit.localIntersectionNormal = triHit._normal;
|
||||
|
||||
if (geometry)
|
||||
{
|
||||
osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
|
||||
if (vertices)
|
||||
{
|
||||
osg::Vec3* first = &(vertices->front());
|
||||
if (triHit._v1)
|
||||
{
|
||||
hit.indexList.push_back(triHit._v1-first);
|
||||
hit.ratioList.push_back(triHit._r1);
|
||||
}
|
||||
if (triHit._v2)
|
||||
{
|
||||
hit.indexList.push_back(triHit._v2-first);
|
||||
hit.ratioList.push_back(triHit._r2);
|
||||
}
|
||||
if (triHit._v3)
|
||||
{
|
||||
hit.indexList.push_back(triHit._v3-first);
|
||||
hit.ratioList.push_back(triHit._r3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
insertIntersection(hit);
|
||||
|
||||
}
|
||||
if (kdTree) kdTree->intersect(intersector, kdTree->getNode(0));
|
||||
else drawable->accept(intersector);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user