Mesh Oriented datABase  (version 5.5.1)
An array-based unstructured mesh library
moab::GQT_IntRegCtxt Class Reference

An implementation of an Intersection Registration Context for use GQT ray-firing. More...

+ Inheritance diagram for moab::GQT_IntRegCtxt:
+ Collaboration diagram for moab::GQT_IntRegCtxt:

Public Member Functions

 GQT_IntRegCtxt (OrientedBoxTreeTool *obbtool, const double ray_point[3], const double ray_dir[3], double tolerance, int min_tolerance_intersections, const EntityHandle *root_set, const EntityHandle *geom_volume, const Tag *sense_tag, const int *desired_orient, const std::vector< EntityHandle > *prev_facets)
 
virtual ErrorCode register_intersection (EntityHandle set, EntityHandle triangle, double distance, OrientedBoxTreeTool::IntersectSearchWindow &, GeomUtil::intersection_type int_type)
 
virtual ErrorCode update_orient (EntityHandle set, int *surfTriOrient)
 
virtual const int * getDesiredOrient ()
 
- Public Member Functions inherited from moab::OrientedBoxTreeTool::IntRegCtxt
std::vector< double > get_intersections ()
 
std::vector< EntityHandleget_facets ()
 
std::vector< EntityHandleget_sets ()
 

Private Member Functions

void add_intersection (EntityHandle set, EntityHandle tri, double dist, OrientedBoxTreeTool::IntersectSearchWindow &search_win)
 
void append_intersection (EntityHandle set, EntityHandle facet, double dist)
 
void set_intersection (int len_idx, EntityHandle set, EntityHandle facet, double dist)
 
void add_mode1_intersection (EntityHandle set, EntityHandle facet, double dist, OrientedBoxTreeTool::IntersectSearchWindow &search_win)
 
bool edge_node_piercing_intersect (const EntityHandle tri, const CartVect &ray_direction, const GeomUtil::intersection_type int_type, const std::vector< EntityHandle > &close_tris, const std::vector< int > &close_senses, const Interface *MBI, std::vector< EntityHandle > *neighborhood_tris=0)
 Determine if a ray-edge/node intersection is glancing or piercing. This function avoids asking for upward adjacencies to prevent their creation. More...
 
bool in_prevFacets (const EntityHandle tri)
 
bool in_neighborhoods (const EntityHandle tri)
 

Private Attributes

OrientedBoxTreeTooltool
 
const CartVect ray_origin
 
const CartVect ray_direction
 
const double tol
 
const int minTolInt
 
const EntityHandlerootSet
 
const EntityHandlegeomVol
 
const TagsenseTag
 
const int * desiredOrient
 
const std::vector< EntityHandle > * prevFacets
 
std::vector< std::vector< EntityHandle > > neighborhoods
 
std::vector< EntityHandleneighborhood
 

Additional Inherited Members

- Protected Attributes inherited from moab::OrientedBoxTreeTool::IntRegCtxt
std::vector< double > intersections
 
std::vector< EntityHandlesets
 
std::vector< EntityHandlefacets
 

Detailed Description

An implementation of an Intersection Registration Context for use GQT ray-firing.

This context uses a variety of tests and conditions to confirm whether or not to accumulate an intersection, to ensure robustness for ray firing.

This context only accumulates intersections that are oriented parallel to the 'desiredOrient', if provided, with respect to 'geomVol', using information in the in 'senseTag'.

This context only accumulates a single intersection out of a set of multiple intersections that fall in the same 'neighborhood', where a 'neighborhood' is defined as facets that share edges or vertices.

This context only accumulates piercing intersections. This is relevant for intersections that are found to be on an edge or vertex by the Plucker test. Such intersections are piercing if the ray has the same orientation w.r.t. to all fecets that share that edge or vertex.

This context tests intersections against a list of 'prevFacets' to prevent a ray from crossing the same facet more than once. The user is responsible for ensuring that this list is reset when appropriate.

This context accumulates all intersections within 'tol' of the start of the ray and if the number of intersections within the 'tol' of the ray start point is less than 'minTolInt', the next closest intersection. If the desired result is only the closest intersection, 'minTolInt' should be 0. This function will return all intersections, regardless of distance from the start of the ray, if 'minTolInt' is negative.

Definition at line 123 of file GeomQueryTool.cpp.

Constructor & Destructor Documentation

◆ GQT_IntRegCtxt()

moab::GQT_IntRegCtxt::GQT_IntRegCtxt ( OrientedBoxTreeTool obbtool,
const double  ray_point[3],
const double  ray_dir[3],
double  tolerance,
int  min_tolerance_intersections,
const EntityHandle root_set,
const EntityHandle geom_volume,
const Tag sense_tag,
const int *  desired_orient,
const std::vector< EntityHandle > *  prev_facets 
)
inline

Definition at line 176 of file GeomQueryTool.cpp.

186  : tool( obbtool ), ray_origin( ray_point ), ray_direction( ray_dir ), tol( tolerance ),
187  minTolInt( min_tolerance_intersections ), rootSet( root_set ), geomVol( geom_volume ), senseTag( sense_tag ),
188  desiredOrient( desired_orient ), prevFacets( prev_facets ){
189 
190  };

Member Function Documentation

◆ add_intersection()

void moab::GQT_IntRegCtxt::add_intersection ( EntityHandle  set,
EntityHandle  tri,
double  dist,
OrientedBoxTreeTool::IntersectSearchWindow search_win 
)
private

Definition at line 532 of file GeomQueryTool.cpp.

536 {
537 
538  // Mode 1, detected by non-null neg_ray_len pointer
539  // keep the closest nonneg intersection and one negative intersection, if closer
540  if( search_win.second && search_win.first )
541  {
542  return add_mode1_intersection( set, facet, dist, search_win );
543  }
544 
545  // ---------------------------------------------------------------------------
546  /* Mode 2: Used if neg_ray_len is not specified
547  variables used: min_tol_int, tol, search_win.first
548  variables not used: neg_ray_len
549  1) if(min_tol_int<0) return all intersections
550  2) otherwise return all inside tolerance and unless there are >min_tol_int
551  inside of tolerance, return the closest outside of tolerance */
552  // Mode 2
553  // If minTolInt is less than zero, return all intersections
554  if( minTolInt < 0 && dist > -tol )
555  {
556  append_intersection( set, facet, dist );
557  neighborhoods.push_back( neighborhood );
558  return;
559  }
560 
561  // Check if the 'len' pointer is pointing into the intersection
562  // list. If this is the case, then the list contains, at that
563  // location, an intersection greater than the tolerance away from
564  // the base point of the ray.
565  int len_idx = -1;
566  if( search_win.first && search_win.first >= &intersections[0] &&
567  search_win.first < &intersections[0] + intersections.size() )
568  len_idx = search_win.first - &intersections[0];
569 
570  // If the intersection is within tol of the ray base point, we
571  // always add it to the list.
572  if( dist <= tol )
573  {
574  // If the list contains an intersection outside the tolerance...
575  if( len_idx >= 0 )
576  {
577  // If we no longer want an intersection outside the tolerance,
578  // remove it.
579  if( (int)intersections.size() >= minTolInt )
580  {
581  set_intersection( len_idx, set, facet, dist );
582  // From now on, we want only intersections within the tolerance,
583  // so update length accordingly
584  search_win.first = &tol;
585  }
586  // Otherwise appended to the list and update pointer
587  else
588  {
589  append_intersection( set, facet, dist );
590  search_win.first = &intersections[len_idx];
591  }
592  }
593  // Otherwise just append it
594  else
595  {
596  append_intersection( set, facet, dist );
597  // If we have all the intersections we want, set
598  // length such that we will only find further intersections
599  // within the tolerance
600  if( (int)intersections.size() >= minTolInt ) search_win.first = &tol;
601  }
602  }
603  // Otherwise the intersection is outside the tolerance
604  // If we already have an intersection outside the tolerance and
605  // this one is closer, replace the existing one with this one.
606  else if( len_idx >= 0 )
607  {
608  if( dist <= *search_win.first )
609  {
610  set_intersection( len_idx, set, facet, dist );
611  }
612  }
613  // Otherwise if we want an intersection outside the tolerance
614  // and don'thave one yet, add it.
615  else if( (int)intersections.size() < minTolInt )
616  {
617  append_intersection( set, facet, dist );
618  // update length. this is currently the closest intersection, so
619  // only want further intersections that are closer than this one.
620  search_win.first = &intersections.back();
621  }
622 }

References add_mode1_intersection(), append_intersection(), moab::OrientedBoxTreeTool::IntRegCtxt::intersections, minTolInt, neighborhood, neighborhoods, set_intersection(), and tol.

Referenced by register_intersection().

◆ add_mode1_intersection()

void moab::GQT_IntRegCtxt::add_mode1_intersection ( EntityHandle  set,
EntityHandle  facet,
double  dist,
OrientedBoxTreeTool::IntersectSearchWindow search_win 
)
private

Definition at line 494 of file GeomQueryTool.cpp.

498 {
499  if( 2 != intersections.size() )
500  {
501  intersections.resize( 2, 0 );
502  sets.resize( 2, 0 );
503  facets.resize( 2, 0 );
504  // must initialize this for comparison below
505  intersections[0] = -std::numeric_limits< double >::max();
506  }
507 
508  // negative case
509  if( 0.0 > dist )
510  {
511  set_intersection( 0, set, facet, dist );
512  search_win.second = &intersections[0];
513  // nonnegative case
514  }
515  else
516  {
517  set_intersection( 1, set, facet, dist );
518  search_win.first = &intersections[1];
519  // if the intersection is closer than the negative one, remove the negative one
520  if( dist < -*( search_win.second ) )
521  {
522  set_intersection( 0, 0, 0, -intersections[1] );
523  search_win.second = &intersections[0];
524  }
525  }
526  // std::cout << "add_intersection: dist = " << dist << " search_win.second=" <<
527  // *search_win.second
528  // << " search_win.first=" << *search_win.first << std::endl;
529  return;
530 }

References moab::OrientedBoxTreeTool::IntRegCtxt::facets, moab::OrientedBoxTreeTool::IntRegCtxt::intersections, set_intersection(), and moab::OrientedBoxTreeTool::IntRegCtxt::sets.

Referenced by add_intersection().

◆ append_intersection()

void moab::GQT_IntRegCtxt::append_intersection ( EntityHandle  set,
EntityHandle  facet,
double  dist 
)
private

Definition at line 472 of file GeomQueryTool.cpp.

473 {
474  intersections.push_back( dist );
475  sets.push_back( set );
476  facets.push_back( facet );
477  neighborhoods.push_back( neighborhood );
478  return;
479 }

References moab::OrientedBoxTreeTool::IntRegCtxt::facets, moab::OrientedBoxTreeTool::IntRegCtxt::intersections, neighborhood, neighborhoods, and moab::OrientedBoxTreeTool::IntRegCtxt::sets.

Referenced by add_intersection().

◆ edge_node_piercing_intersect()

bool moab::GQT_IntRegCtxt::edge_node_piercing_intersect ( const EntityHandle  tri,
const CartVect ray_dir,
const GeomUtil::intersection_type  int_type,
const std::vector< EntityHandle > &  close_tris,
const std::vector< int > &  close_senses,
const Interface MBI,
std::vector< EntityHandle > *  neighborhood_tris = 0 
)
private

Determine if a ray-edge/node intersection is glancing or piercing. This function avoids asking for upward adjacencies to prevent their creation.

Parameters
triThe intersected triangle
ray_dirThe direction of the ray
int_typeThe type of intersection (EDGE0, EDGE1, NODE2, ...)
close_trisVector of triangles in the proximity of the intersection
close_sensesVector of surface senses for tris in the proximity of the intersection
neighborhoodVector of triangles in the topological neighborhood of the intersection
Returns
True if piercing, false otherwise.

Definition at line 278 of file GeomQueryTool.cpp.

285 {
286 
287  // get the node of the triangle
288  const EntityHandle* conn = NULL;
289  int len = 0;
290  ErrorCode rval = MBI->get_connectivity( tri, conn, len );MB_CHK_ERR_RET_VAL( rval, false );
291  // NOTE: original code is next line, but return type was wrong; returning true to get same net effect
292  if( 3 != len ) return false;
293 
294  // get adjacent tris (and keep their corresponding senses)
295  std::vector< EntityHandle > adj_tris;
296  std::vector< int > adj_senses;
297 
298  // node intersection
299  if( GeomUtil::NODE0 == int_type || GeomUtil::NODE1 == int_type || GeomUtil::NODE2 == int_type )
300  {
301 
302  // get the intersected node
303  EntityHandle node;
304  if( GeomUtil::NODE0 == int_type )
305  node = conn[0];
306  else if( GeomUtil::NODE1 == int_type )
307  node = conn[1];
308  else
309  node = conn[2];
310 
311  // get tris adjacent to node
312  for( unsigned i = 0; i < close_tris.size(); ++i )
313  {
314  const EntityHandle* con = NULL;
315  rval = MBI->get_connectivity( close_tris[i], con, len );MB_CHK_ERR_RET_VAL( rval, false );
316  if( 3 != len ) return false;
317 
318  if( node == con[0] || node == con[1] || node == con[2] )
319  {
320  adj_tris.push_back( close_tris[i] );
321  adj_senses.push_back( close_senses[i] );
322  }
323  }
324  if( adj_tris.empty() )
325  {
326  std::cerr << "error: no tris are adjacent to the node" << std::endl;
327  return false;
328  }
329  // edge intersection
330  }
331  else if( GeomUtil::EDGE0 == int_type || GeomUtil::EDGE1 == int_type || GeomUtil::EDGE2 == int_type )
332  {
333 
334  // get the endpoints of the edge
335  EntityHandle endpts[2];
336  if( GeomUtil::EDGE0 == int_type )
337  {
338  endpts[0] = conn[0];
339  endpts[1] = conn[1];
340  }
341  else if( GeomUtil::EDGE1 == int_type )
342  {
343  endpts[0] = conn[1];
344  endpts[1] = conn[2];
345  }
346  else
347  {
348  endpts[0] = conn[2];
349  endpts[1] = conn[0];
350  }
351 
352  // get tris adjacent to edge
353  for( unsigned i = 0; i < close_tris.size(); ++i )
354  {
355  const EntityHandle* con = NULL;
356  rval = MBI->get_connectivity( close_tris[i], con, len );MB_CHK_ERR_RET_VAL( rval, false );
357  if( 3 != len ) return false;
358 
359  // check both orientations in case close_tris are not on the same surface
360  if( ( endpts[0] == con[0] && endpts[1] == con[1] ) || ( endpts[0] == con[1] && endpts[1] == con[0] ) ||
361  ( endpts[0] == con[1] && endpts[1] == con[2] ) || ( endpts[0] == con[2] && endpts[1] == con[1] ) ||
362  ( endpts[0] == con[2] && endpts[1] == con[0] ) || ( endpts[0] == con[0] && endpts[1] == con[2] ) )
363  {
364  adj_tris.push_back( close_tris[i] );
365  adj_senses.push_back( close_senses[i] );
366  }
367  }
368  // In a 2-manifold each edge is adjacent to exactly 2 tris
369  if( 2 != adj_tris.size() )
370  {
371  std::cerr << "error: edge of a manifold must be topologically adjacent to exactly 2 tris" << std::endl;
372  MBI->list_entities( endpts, 2 );
373  return true;
374  }
375  }
376  else
377  {
378  std::cerr << "error: special case not an node/edge intersection" << std::endl;
379  return false;
380  }
381 
382  // The close tris were in proximity to the intersection. The adj_tris are
383  // topologically adjacent to the intersection (the neighborhood).
384  if( neighborhood_tris ) ( *neighborhood_tris ).assign( adj_tris.begin(), adj_tris.end() );
385 
386  // determine glancing/piercing
387  // If a desired_orientation was used in this call to ray_intersect_sets,
388  // the plucker_ray_tri_intersect will have already used it. For a piercing
389  // intersection, the normal of all tris must have the same orientation.
390  int sign = 0;
391  for( unsigned i = 0; i < adj_tris.size(); ++i )
392  {
393  const EntityHandle* con = NULL;
394  rval = MBI->get_connectivity( adj_tris[i], con, len );MB_CHK_ERR_RET_VAL( rval, false );
395  if( 3 != len ) return false;
396 
397  CartVect coords[3];
398  rval = MBI->get_coords( con, len, coords[0].array() );MB_CHK_ERR_RET_VAL( rval, false );
399 
400  // get normal of triangle
401  CartVect v0 = coords[1] - coords[0];
402  CartVect v1 = coords[2] - coords[0];
403  CartVect norm = adj_senses[i] * ( v0 * v1 );
404  double dot_prod = norm % ray_dir;
405 
406  // if the sign has not yet been decided, choose it
407  if( 0 == sign && 0 != dot_prod )
408  {
409  if( 0 < dot_prod )
410  sign = 1;
411  else
412  sign = -1;
413  }
414 
415  // intersection is glancing if tri and ray do not point in same direction
416  // for every triangle
417  if( 0 != sign && 0 > sign * dot_prod ) return false;
418  }
419  return true;
420 }

References moab::GeomUtil::EDGE0, moab::GeomUtil::EDGE1, moab::GeomUtil::EDGE2, ErrorCode, MB_CHK_ERR_RET_VAL, MBI, moab::GeomUtil::NODE0, moab::GeomUtil::NODE1, and moab::GeomUtil::NODE2.

Referenced by register_intersection().

◆ getDesiredOrient()

virtual const int* moab::GQT_IntRegCtxt::getDesiredOrient ( )
inlinevirtual

Reimplemented from moab::OrientedBoxTreeTool::IntRegCtxt.

Definition at line 199 of file GeomQueryTool.cpp.

200  {
201  return desiredOrient;
202  };

References desiredOrient.

◆ in_neighborhoods()

bool moab::GQT_IntRegCtxt::in_neighborhoods ( const EntityHandle  tri)
private

Definition at line 252 of file GeomQueryTool.cpp.

253 {
254  bool same_neighborhood = false;
255  for( unsigned i = 0; i < neighborhoods.size(); ++i )
256  {
257  if( neighborhoods[i].end() != find( neighborhoods[i].begin(), neighborhoods[i].end(), tri ) )
258  {
259  same_neighborhood = true;
260  continue;
261  }
262  }
263  return same_neighborhood;
264 }

References neighborhoods.

Referenced by register_intersection().

◆ in_prevFacets()

bool moab::GQT_IntRegCtxt::in_prevFacets ( const EntityHandle  tri)
private

Definition at line 247 of file GeomQueryTool.cpp.

248 {
249  return ( prevFacets && ( ( *prevFacets ).end() != find( ( *prevFacets ).begin(), ( *prevFacets ).end(), tri ) ) );
250 }

References prevFacets.

Referenced by register_intersection().

◆ register_intersection()

ErrorCode moab::GQT_IntRegCtxt::register_intersection ( EntityHandle  set,
EntityHandle  triangle,
double  distance,
OrientedBoxTreeTool::IntersectSearchWindow search_win,
GeomUtil::intersection_type  int_type 
)
virtual

Reimplemented from moab::OrientedBoxTreeTool::IntRegCtxt.

Definition at line 422 of file GeomQueryTool.cpp.

427 {
428  ErrorCode rval;
429 
430  // Do not accept intersections if they are in the vector of previously intersected
431  // facets.
432  if( in_prevFacets( t ) ) return MB_SUCCESS;
433 
434  // Do not accept intersections if they are in the neighborhood of previous
435  // intersections.
436  if( in_neighborhoods( t ) ) return MB_SUCCESS;
437 
438  neighborhood.clear();
439 
440  // Handle special case of edge/node intersection. Accept piercing
441  // intersections and reject glancing intersections.
442  // The edge_node_intersection function needs to know surface sense wrt volume.
443  // A less-robust implementation could work without sense information.
444  // Would it ever be useful to accept a glancing intersection?
445  if( GeomUtil::INTERIOR != int_type && rootSet && geomVol && senseTag )
446  {
447  // get triangles in the proximity of the intersection
448  std::vector< EntityHandle > close_tris;
449  std::vector< int > close_senses;
450  rval = tool->get_close_tris( ray_origin + int_dist * ray_direction, tol, rootSet, geomVol, senseTag, close_tris,
451  close_senses );
452 
453  if( MB_SUCCESS != rval ) return rval;
454 
455  if( !edge_node_piercing_intersect( t, ray_direction, int_type, close_tris, close_senses,
457  return MB_SUCCESS;
458  }
459  else
460  {
461  neighborhood.push_back( t );
462  }
463 
464  // NOTE: add_intersection may modify the 'neg_ray_len' and 'nonneg_ray_len'
465  // members, which will affect subsequent calls to ray_tri_intersect
466  // in this loop.
467  add_intersection( set, t, int_dist, search_win );
468 
469  return MB_SUCCESS;
470 }

References add_intersection(), edge_node_piercing_intersect(), ErrorCode, geomVol, moab::OrientedBoxTreeTool::get_close_tris(), moab::OrientedBoxTreeTool::get_moab_instance(), in_neighborhoods(), in_prevFacets(), moab::GeomUtil::INTERIOR, MB_SUCCESS, neighborhood, ray_direction, ray_origin, rootSet, senseTag, tol, and tool.

◆ set_intersection()

void moab::GQT_IntRegCtxt::set_intersection ( int  len_idx,
EntityHandle  set,
EntityHandle  facet,
double  dist 
)
private

Definition at line 481 of file GeomQueryTool.cpp.

482 {
483  intersections[len_idx] = dist;
484  sets[len_idx] = set;
485  facets[len_idx] = facet;
486  return;
487 }

References moab::OrientedBoxTreeTool::IntRegCtxt::facets, moab::OrientedBoxTreeTool::IntRegCtxt::intersections, and moab::OrientedBoxTreeTool::IntRegCtxt::sets.

Referenced by add_intersection(), and add_mode1_intersection().

◆ update_orient()

ErrorCode moab::GQT_IntRegCtxt::update_orient ( EntityHandle  set,
int *  surfTriOrient 
)
virtual

Reimplemented from moab::OrientedBoxTreeTool::IntRegCtxt.

Definition at line 205 of file GeomQueryTool.cpp.

206 {
207 
208  ErrorCode rval;
209 
210  // Get desired orientation of surface wrt volume. Use this to return only
211  // exit or entrance intersections.
212  if( geomVol && senseTag && desiredOrient && surfTriOrient )
213  {
214  if( 1 != *desiredOrient && -1 != *desiredOrient )
215  {
216  std::cerr << "error: desired orientation must be 1 (forward) or -1 (reverse)" << std::endl;
217  }
218  EntityHandle vols[2];
219  rval = tool->get_moab_instance()->tag_get_data( *senseTag, &set, 1, vols );
220  assert( MB_SUCCESS == rval );
221  if( MB_SUCCESS != rval ) return rval;
222  if( vols[0] == vols[1] )
223  {
224  std::cerr << "error: surface has positive and negative sense wrt same volume" << std::endl;
225  return MB_FAILURE;
226  }
227  // surfTriOrient will be used by plucker_ray_tri_intersect to avoid
228  // intersections with wrong orientation.
229  if( *geomVol == vols[0] )
230  {
231  *surfTriOrient = *desiredOrient * 1;
232  }
233  else if( *geomVol == vols[1] )
234  {
235  *surfTriOrient = *desiredOrient * ( -1 );
236  }
237  else
238  {
239  assert( false );
240  return MB_FAILURE;
241  }
242  }
243 
244  return MB_SUCCESS;
245 }

References desiredOrient, ErrorCode, geomVol, moab::OrientedBoxTreeTool::get_moab_instance(), MB_SUCCESS, senseTag, moab::Interface::tag_get_data(), and tool.

Member Data Documentation

◆ desiredOrient

const int* moab::GQT_IntRegCtxt::desiredOrient
private

Definition at line 141 of file GeomQueryTool.cpp.

Referenced by getDesiredOrient(), and update_orient().

◆ geomVol

const EntityHandle* moab::GQT_IntRegCtxt::geomVol
private

Definition at line 138 of file GeomQueryTool.cpp.

Referenced by register_intersection(), and update_orient().

◆ minTolInt

const int moab::GQT_IntRegCtxt::minTolInt
private

Definition at line 134 of file GeomQueryTool.cpp.

Referenced by add_intersection().

◆ neighborhood

std::vector< EntityHandle > moab::GQT_IntRegCtxt::neighborhood
private

Definition at line 152 of file GeomQueryTool.cpp.

Referenced by add_intersection(), append_intersection(), and register_intersection().

◆ neighborhoods

std::vector< std::vector< EntityHandle > > moab::GQT_IntRegCtxt::neighborhoods
private

Definition at line 151 of file GeomQueryTool.cpp.

Referenced by add_intersection(), append_intersection(), and in_neighborhoods().

◆ prevFacets

const std::vector< EntityHandle >* moab::GQT_IntRegCtxt::prevFacets
private

Definition at line 147 of file GeomQueryTool.cpp.

Referenced by in_prevFacets().

◆ ray_direction

const CartVect moab::GQT_IntRegCtxt::ray_direction
private

Definition at line 130 of file GeomQueryTool.cpp.

Referenced by register_intersection().

◆ ray_origin

const CartVect moab::GQT_IntRegCtxt::ray_origin
private

Definition at line 129 of file GeomQueryTool.cpp.

Referenced by register_intersection().

◆ rootSet

const EntityHandle* moab::GQT_IntRegCtxt::rootSet
private

Definition at line 137 of file GeomQueryTool.cpp.

Referenced by register_intersection().

◆ senseTag

const Tag* moab::GQT_IntRegCtxt::senseTag
private

Definition at line 139 of file GeomQueryTool.cpp.

Referenced by register_intersection(), and update_orient().

◆ tol

const double moab::GQT_IntRegCtxt::tol
private

Definition at line 131 of file GeomQueryTool.cpp.

Referenced by add_intersection(), and register_intersection().

◆ tool

OrientedBoxTreeTool* moab::GQT_IntRegCtxt::tool
private

Definition at line 128 of file GeomQueryTool.cpp.

Referenced by register_intersection(), and update_orient().


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