olb::STLtriangle< T > Struct Template Reference

#include <stlReader.h>

Collaboration diagram for olb::STLtriangle< T >:

Public Member Functions
bool	testRayIntersect (const Vector< T, 3 > &pt, const Vector< T, 3 > &dir, Vector< T, 3 > &q, T &alpha, const T &rad=T(), bool print=false)
	Test intersection between ray and triangle.
Vector< T, 3 >	closestPtPointTriangle (const Vector< T, 3 > &pt) const
	computes closest Point in a triangle to another point.
	STLtriangle ()
	Constructor constructs.
	STLtriangle (STLtriangle< T > const &tri)
	CopyConstructor copies.
STLtriangle< T > &	operator= (STLtriangle< T > const &tri)
	Operator= equals.
	~STLtriangle ()
void	init ()
	Initializes triangle and precomputes member variables.
Vector< T, 3 > &	getNormal ()
	Return write access to normal.
const Vector< T, 3 > &	getNormal () const
	Return read access to normal.
Vector< T, 3 >	getCenter ()
	Returns center.
std::vector< T >	getE0 ()
	Returns Pt0-Pt1.
std::vector< T >	getE1 ()
	Returns Pt0-Pt2.
bool	isPointInside (const PhysR< T, 3 > &pt) const
	Check whether a point is inside a triangle.

Public Attributes
std::vector< Vertex< T, 3 > >	point
	A triangle contains 3 Points.
Vector< T, 3 >	normal
	normal of triangle
Vector< T, 3 >	uBeta
	variables explained in http://www.uninformativ.de/bin/RaytracingSchnitttests-76a577a-CC-BY.pdf page 7-12 precomputed for speedup
Vector< T, 3 >	uGamma
T	d
T	kBeta
T	kGamma

Detailed Description

template<typename T>
struct olb::STLtriangle< T >

Definition at line 79 of file stlReader.h.

Constructor & Destructor Documentation

STLtriangle() [1/2]

template<typename T >

olb::STLtriangle< T >::STLtriangle ( )

inline

Constructor constructs.

Definition at line 104 of file stlReader.h.

:point(3, Vertex<T,3>()), normal(T()), uBeta(T()), uGamma(T()), d(T()), kBeta(T()), kGamma(T()) {};

STLtriangle() [2/2]

template<typename T >

olb::STLtriangle< T >::STLtriangle ( STLtriangle< T > const & tri )

inline

CopyConstructor copies.

Definition at line 106 of file stlReader.h.

:point(tri.point), normal(tri.normal), uBeta(tri.uBeta), uGamma(tri.uGamma), d(tri.d), kBeta(tri.kBeta), kGamma(tri.kGamma) {};

~STLtriangle()

template<typename T >

olb::STLtriangle< T >::~STLtriangle ( )

inline

Definition at line 120 of file stlReader.h.

{};

Member Function Documentation

closestPtPointTriangle()

template<typename T >

Vector< T, 3 > olb::STLtriangle< T >::closestPtPointTriangle

(

const Vector< T, 3 > &

pt

)

const

computes closest Point in a triangle to another point.

source: Real-Time Collision Detection. Christer Ericson. ISBN-10: 1558607323

Definition at line 261 of file stlReader.hh.

{
 
  const T nEps = -std::numeric_limits<T>::epsilon();
  const T Eps = std::numeric_limits<T>::epsilon();
 
  Vector<T,3> ab = point[1].coords - point[0].coords;
  Vector<T,3> ac = point[2].coords - point[0].coords;
  Vector<T,3> bc = point[2].coords - point[1].coords;
 
  T snom = (pt - point[0].coords)*ab;
  T sdenom = (pt - point[1].coords)*(point[0].coords - point[1].coords);
 
  T tnom = (pt - point[0].coords)*ac;
  T tdenom = (pt - point[2].coords)*(point[0].coords - point[2].coords);
 
  if (snom < nEps && tnom < nEps) {
    return point[0].coords;
  }
 
  T unom = (pt - point[1].coords)*bc;
  T udenom = (pt - point[2].coords)*(point[1].coords - point[2].coords);
 
  if (sdenom < nEps && unom < nEps) {
    return point[1].coords;
  }
  if (tdenom < nEps && udenom < nEps) {
    return point[2].coords;
  }
 
  T vc = normal*crossProduct3D(point[0].coords - pt, point[1].coords - pt);
 
  if (vc < nEps && snom > Eps && sdenom > Eps) {
    return point[0].coords + snom / (snom + sdenom) * ab;
  }
 
  T va = normal*crossProduct3D(point[1].coords - pt, point[2].coords - pt);
 
  if (va < nEps && unom > Eps && udenom > Eps) {
    return point[1].coords + unom / (unom + udenom) * bc;
  }
 
  T vb = normal*crossProduct3D(point[2].coords - pt, point[0].coords - pt);
 
  if (vb < nEps && tnom > Eps && tdenom > Eps) {
    return point[0].coords + tnom / (tnom + tdenom) * ac;
  }
 
  T u = va / (va + vb + vc);
  T v = vb / (va + vb + vc);
  T w = 1. - u - v;
 
  return u * point[0].coords + v * point[1].coords + w * point[2].coords;
}

References olb::crossProduct3D().

Here is the call graph for this function:

getCenter()

template<typename T >

Vector< T, 3 > olb::STLtriangle< T >::getCenter

(

)

Returns center.

Definition at line 91 of file stlReader.hh.

{
  Vector<T,3> center( T(0) );
 
  center[0] = (point[0].coords[0] + point[1].coords[0]
               + point[2].coords[0]) / 3.;
  center[1] = (point[0].coords[1] + point[1].coords[1]
               + point[2].coords[1]) / 3.;
  center[2] = (point[0].coords[2] + point[1].coords[2]
               + point[2].coords[2]) / 3.;
 
  return center;
}

getE0()

template<typename T >

std::vector< T > olb::STLtriangle< T >::getE0

(

)

Returns Pt0-Pt1.

Definition at line 106 of file stlReader.hh.

{
  Vector<T,3> vec;
  vec[0] = point[0].coords[0] - point[1].coords[0];
  vec[1] = point[0].coords[1] - point[1].coords[1];
  vec[2] = point[0].coords[2] - point[1].coords[2];
  return vec;
}

getE1()

template<typename T >

std::vector< T > olb::STLtriangle< T >::getE1

(

)

Returns Pt0-Pt2.

Definition at line 116 of file stlReader.hh.

{
  Vector<T,3> vec;
  vec[0] = point[0].coords[0] - point[2].coords[0];
  vec[1] = point[0].coords[1] - point[2].coords[1];
  vec[2] = point[0].coords[2] - point[2].coords[2];
  return vec;
}

getNormal() [1/2]

template<typename T >

Vector< T, 3 > & olb::STLtriangle< T >::getNormal ( )

inline

Return write access to normal.

Definition at line 125 of file stlReader.h.

  {
    return normal;
  }

References olb::STLtriangle< T >::normal.

Here is the caller graph for this function:

getNormal() [2/2]

template<typename T >

const Vector< T, 3 > & olb::STLtriangle< T >::getNormal ( ) const

inline

Return read access to normal.

Definition at line 130 of file stlReader.h.

  {
    return normal;
  }

References olb::STLtriangle< T >::normal.

init()

template<typename T >

void olb::STLtriangle< T >::init

(

)

Initializes triangle and precomputes member variables.

Definition at line 46 of file stlReader.hh.

{
  Vector<T,3> A = point[0].coords;
  Vector<T,3> B = point[1].coords;
  Vector<T,3> C = point[2].coords;
  Vector<T,3> b, c;
  T bb = 0., bc = 0., cc = 0.;
 
  for (int i = 0; i < 3; i++) {
    b[i] = B[i] - A[i];
    c[i] = C[i] - A[i];
    bb += b[i] * b[i];
    bc += b[i] * c[i];
    cc += c[i] * c[i];
  }
 
  normal[0] = b[1] * c[2] - b[2] * c[1];
  normal[1] = b[2] * c[0] - b[0] * c[2];
  normal[2] = b[0] * c[1] - b[1] * c[0];
 
  T norm = util::sqrt(
             util::pow(normal[0], 2) + util::pow(normal[1], 2) + util::pow(normal[2], 2));
  normal[0] /= norm;
  normal[1] /= norm;
  normal[2] /= norm;
 
  T D = 1.0 / (cc * bb - bc * bc);
  T bbD = bb * D;
  T bcD = bc * D;
  T ccD = cc * D;
 
  kBeta = 0.;
  kGamma = 0.;
  d = 0.;
 
  for (int i = 0; i < 3; i++) {
    uBeta[i] = b[i] * ccD - c[i] * bcD;
    uGamma[i] = c[i] * bbD - b[i] * bcD;
    kBeta -= A[i] * uBeta[i];
    kGamma -= A[i] * uGamma[i];
    d += A[i] * normal[i];
  }
}

References olb::norm(), olb::util::pow(), and olb::util::sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

isPointInside()

template<typename T >

bool olb::STLtriangle< T >::isPointInside

(

const PhysR< T, 3 > &

pt

)

const

Check whether a point is inside a triangle.

Definition at line 126 of file stlReader.hh.

{
  // tests with T=double and T=float show that the epsilon must be increased
  const T epsilon = std::numeric_limits<BaseType<T>>::epsilon()*T(10);
 
  const T beta = pt * uBeta + kBeta;
  const T gamma = pt * uGamma + kGamma;
 
  // check if approximately equal
  if ( util::nearZero(norm(pt - (point[0].coords + beta*(point[1].coords-point[0].coords) + gamma*(point[2].coords-point[0].coords))), epsilon) ) {
    const T alpha = T(1) - beta - gamma;
    return (beta >= T(0) || util::nearZero(beta, epsilon))
           && (gamma >= T(0) || util::nearZero(gamma, epsilon))
           && (alpha >= T(0) || util::nearZero(alpha, epsilon));
  }
  return false;
}

References olb::util::nearZero(), and olb::norm().

Here is the call graph for this function:

operator=()

template<typename T >

STLtriangle< T > & olb::STLtriangle< T >::operator= ( STLtriangle< T > const & tri )

inline

Operator= equals.

Definition at line 108 of file stlReader.h.

  {
    point = tri.point;
    normal = tri.normal;
    uBeta = tri.uBeta;
    uGamma = tri.uGamma;
    d = tri.d;
    kBeta = tri.kBeta;
    kGamma = tri.kGamma;
    return *this;
  };

References olb::STLtriangle< T >::d, olb::STLtriangle< T >::kBeta, olb::STLtriangle< T >::kGamma, olb::STLtriangle< T >::normal, olb::STLtriangle< T >::point, olb::STLtriangle< T >::uBeta, and olb::STLtriangle< T >::uGamma.

testRayIntersect()

template<typename T >

bool olb::STLtriangle< T >::testRayIntersect	(	const Vector< T, 3 > &	pt,
		const Vector< T, 3 > &	dir,
		Vector< T, 3 > &	q,
		T &	alpha,
		const T &	rad = T(),
		bool	print = false )

Test intersection between ray and triangle.

Parameters

pt	Raypoint
dir	Direction
q	Point of intersection (if intersection occurs)
alpha	Explained in http://www.uninformativ.de/bin/RaytracingSchnitttests-76a577a-CC-BY.pdf page 7-12 q = pt + alpha * dir
rad	It's complicated. Imagine you have a sphere with radius rad moving a long the ray. Then q becomes the first point of the sphere to touch the triangle.

Definition at line 154 of file stlReader.hh.

{
  T rn = 0.;
  Vector<T,3> testPt = pt + rad * normal;
  /* Vector<T,3> help; */
 
  for (int i = 0; i < 3; i++) {
    rn += dir[i] * normal[i];
  }
#ifdef OLB_DEBUG
 
  if (print) {
    std::cout << "Pt: " << pt[0] << " " << pt[1] << " " << pt[2] << std::endl;
  }
  if (print)
    std::cout << "testPt: " << testPt[0] << " " << testPt[1] << " " << testPt[2]
              << std::endl;
  if (print)
    std::cout << "PosNeg: "
              << normal[0] * testPt[0] + normal[1] * testPt[1] + normal[2] * testPt[2]
              - d << std::endl;
  if (print)
    std::cout << "Normal: " << normal[0] << " " << normal[1] << " " << normal[2]
              << std::endl;
#endif
 
  // Schnitttest Flugrichtung -> Ebene
  if (util::fabs(rn) < std::numeric_limits<T>::epsilon()) {
#ifdef OLB_DEBUG
    if (print) {
      std::cout << "FALSE 1" << std::endl;
    }
#endif
    return false;
  }
  alpha = d - testPt[0] * normal[0] - testPt[1] * normal[1] - testPt[2] * normal[2];
  //  alpha -= testPt[i] * normal[i];
  alpha /= rn;
 
  // Abstand Partikel Ebene
  if (alpha < -std::numeric_limits<T>::epsilon()) {
#ifdef OLB_DEBUG
    if (print) {
      std::cout << "FALSE 2" << std::endl;
    }
#endif
    return false;
  }
  for (int i = 0; i < 3; i++) {
    q[i] = testPt[i] + alpha * dir[i];
  }
  T beta = kBeta;
  for (int i = 0; i < 3; i++) {
    beta += uBeta[i] * q[i];
  }
#ifdef OLB_DEBUG
  T dist = util::sqrt(
             util::pow(q[0] - testPt[0], 2) + util::pow(q[1] - testPt[1], 2)
             + util::pow(q[2] - testPt[2], 2));
#endif
 
  // Schnittpunkt q in der Ebene?
  if (beta < -std::numeric_limits<T>::epsilon()) {
#ifdef OLB_DEBUG
 
    if (print) {
      std::cout << "FALSE 3 BETA " << beta << " DIST " << dist << std::endl;
    }
#endif
    return false;
  }
  T gamma = kGamma;
  for (int i = 0; i < 3; i++) {
    gamma += uGamma[i] * q[i];
  }
  if (gamma < -std::numeric_limits<T>::epsilon()) {
#ifdef OLB_DEBUG
    if (print) {
      std::cout << "FALSE 4 GAMMA " << gamma << " DIST " << dist << std::endl;
    }
#endif
    return false;
  }
  if (1. - beta - gamma < -std::numeric_limits<T>::epsilon()) {
#ifdef OLB_DEBUG
    if (print)
      std::cout << "FALSE 5 VAL " << 1 - beta - gamma << " DIST " << dist
                << std::endl;
#endif
    return false;
  }
#ifdef OLB_DEBUG
  if (print) {
    std::cout << "TRUE" << " GAMMA " << gamma << " BETA " << beta << std::endl;
  }
#endif
  return true;
}

References olb::util::fabs(), olb::util::pow(), and olb::util::sqrt().

Here is the call graph for this function:

Member Data Documentation

d

template<typename T >

T olb::STLtriangle< T >::d

Definition at line 100 of file stlReader.h.

kBeta

template<typename T >

T olb::STLtriangle< T >::kBeta

Definition at line 100 of file stlReader.h.

kGamma

template<typename T >

T olb::STLtriangle< T >::kGamma

Definition at line 100 of file stlReader.h.

normal

template<typename T >

Vector<T,3> olb::STLtriangle< T >::normal

normal of triangle

Definition at line 95 of file stlReader.h.

point

template<typename T >

std::vector<Vertex<T,3> > olb::STLtriangle< T >::point

A triangle contains 3 Points.

Definition at line 92 of file stlReader.h.

uBeta

template<typename T >

Vector<T,3> olb::STLtriangle< T >::uBeta

variables explained in http://www.uninformativ.de/bin/RaytracingSchnitttests-76a577a-CC-BY.pdf page 7-12 precomputed for speedup

Definition at line 99 of file stlReader.h.

uGamma

template<typename T >

Vector<T,3> olb::STLtriangle< T >::uGamma

Definition at line 99 of file stlReader.h.

---

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

• src/io/octree.h
• src/io/stlReader.h
• src/io/stlReader.hh