AABB Class Reference

#include <AABB.h>

Classes
struct	MySegmentPrimitive
struct	MyTriangle
struct	MyTrianglePrimitive

Public Types
typedef Vector< double, 3 >	Vec3D

Public Member Functions
	AABB (const Mesh &mesh)
bool	hasIntersectionWithSegment (Vec3D a, Vec3D b)
bool	hasIntersectionWithTriangle (Vec3D a, Vec3D b, Vec3D c)
int	meshIntersections (const Mesh &mesh)
int	findOrientedSide (Vec3D p)

Private Types
typedef CGAL::Simple_cartesian < double >	K
typedef K::Point_3	Point
typedef K::Point_2	Point2D
typedef K::Triangle_3	Triangle
typedef K::Plane_3	Plane
typedef K::Line_2	Line2D
typedef std::vector < MyTriangle * > ::const_iterator	MyTriangleIterator
typedef CGAL::AABB_traits< K, MyTrianglePrimitive >	My_AABB_traits
typedef CGAL::AABB_tree < My_AABB_traits >	CGAL_Tree
typedef CGAL::AABB_traits< K, MySegmentPrimitive >	My_AABB_traits_2D
typedef CGAL::AABB_tree < My_AABB_traits_2D >	CGAL_Tree_2D

Private Attributes
bool	_is2D
std::vector< MyTriangle * >	_triangles
boost::shared_ptr< CGAL_Tree >	_tree
boost::shared_ptr< CGAL_Tree_2D >	_tree_2D

Detailed Description

A wrapper for CGAL's axis aligned bounding box concept. We use this to compute intersections of the fluid mesh with the boundary mesh representing the solid. The tree is constructed with the faces of the latter and then we go through all the faces of the fluid mesh to find the ones that have intersections with any of the tree faces.

Definition at line 29 of file AABB.h.

Member Typedef Documentation

typedef CGAL::AABB_tree<My_AABB_traits> AABB::CGAL_Tree

private

Definition at line 255 of file AABB.h.

typedef CGAL::AABB_tree<My_AABB_traits_2D> AABB::CGAL_Tree_2D

private

Definition at line 258 of file AABB.h.

typedef CGAL::Simple_cartesian<double> AABB::K

private

Definition at line 67 of file AABB.h.

typedef K::Line_2 AABB::Line2D

private

Definition at line 73 of file AABB.h.

typedef CGAL::AABB_traits<K, MyTrianglePrimitive> AABB::My_AABB_traits

private

Definition at line 254 of file AABB.h.

typedef CGAL::AABB_traits<K, MySegmentPrimitive> AABB::My_AABB_traits_2D

private

Definition at line 257 of file AABB.h.

typedef std::vector<MyTriangle*>::const_iterator AABB::MyTriangleIterator

private

Definition at line 161 of file AABB.h.

typedef K::Plane_3 AABB::Plane

private

Definition at line 72 of file AABB.h.

typedef K::Point_3 AABB::Point

private

Definition at line 68 of file AABB.h.

typedef K::Point_2 AABB::Point2D

private

Definition at line 69 of file AABB.h.

typedef K::Triangle_3 AABB::Triangle

private

Definition at line 71 of file AABB.h.

typedef Vector<double,3> AABB::Vec3D

Definition at line 32 of file AABB.h.

Constructor & Destructor Documentation

AABB::AABB

(

const Mesh &

mesh

)

Definition at line 10 of file AABB.cpp.

References _is2D, _tree, _tree_2D, _triangles, Mesh::getBoundaryFaceGroups(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getDimension(), Mesh::getFaceNodes(), Mesh::getNodeCoordinates(), and FaceGroup::site.

{
  _is2D = mesh.getDimension() == 2;
  
  const Array<Vector<double,3> >& meshCoords = mesh.getNodeCoordinates();
  
  
  foreach(const FaceGroupPtr fgPtr, mesh.getBoundaryFaceGroups())
  {
      const FaceGroup& fg = *fgPtr;
      const StorageSite& faces = fg.site;
      const CRConnectivity& faceNodes = mesh.getFaceNodes(faces);
      
      const int nFaces = faces.getCount();
      
      for(int f=0; f<nFaces; f++)
      {
          if (_is2D)
          {
              _triangles.push_back(new MyTriangle(f,meshCoords,
                                                  faceNodes(f,0),
                                                  faceNodes(f,1)));
          }
          else
          {
              _triangles.push_back(new MyTriangle(f,0,meshCoords,
                                                  faceNodes(f,0),
                                                  faceNodes(f,1),
                                                  faceNodes(f,2)));
              if (faceNodes.getCount(f) == 4)
              {
                  
                  _triangles.push_back(new MyTriangle(f,1,meshCoords,
                                                      faceNodes(f,2),
                                                      faceNodes(f,3),
                                                      faceNodes(f,0)));
              }
          }
      }
  }
  
  if (_is2D)
    _tree_2D = boost::shared_ptr<CGAL_Tree_2D>(new CGAL_Tree_2D(_triangles.begin(),
                                                                _triangles.end()));
  else
  {
      _tree = boost::shared_ptr<CGAL_Tree>(new CGAL_Tree(_triangles.begin(),
                                                         _triangles.end()));
      
      //  _bbox = _tree->bbox();
  }
}

Member Function Documentation

int AABB::findOrientedSide

(

AABB::Vec3D

p

)

locate the side on which a given point lies. returns 0 if the point is on one of the faces of the tree, -1 if it's inside and 1 if it is outside. This check is only meaningful if the faces of the tree form a closed surface.

Definition at line 156 of file AABB.cpp.

References _is2D, _triangles, AABB::MyTriangle::getLine2D(), AABB::MyTriangle::getPlane(), AABB::MyTriangle::getSegment2D(), and AABB::MyTriangle::getTriangle().

{
  if (_is2D)
  {
      K::Point_2 query(p[0], p[1]);
      foreach(const MyTriangle* myt, _triangles)
      {
          Line2D line = myt->getLine2D();
          CGAL::Oriented_side orientation = line.oriented_side(query);
          if (orientation == CGAL::ON_POSITIVE_SIDE)
            return 1;
          else if (orientation == CGAL::ON_ORIENTED_BOUNDARY)
          {
              K::Segment_2 segment = myt->getSegment2D();
              if (segment.has_on(query))
                return 0;
          }
      }
      return -1;
  }
  else
  {
      K::Point_3 query(p[0], p[1], p[2]);
      foreach(const MyTriangle* myt, _triangles)
      {
          Plane plane = myt->getPlane();
          CGAL::Oriented_side orientation = plane.oriented_side(query);
          if (orientation == CGAL::ON_POSITIVE_SIDE)
            return 1;
          else if (orientation == CGAL::ON_ORIENTED_BOUNDARY)
          {
              Triangle triangle = myt->getTriangle();
              if (triangle.has_on(query))
                return 0;
          }
      }
      return -1;
  }
}

bool AABB::hasIntersectionWithSegment	(	AABB::Vec3D	a,
		AABB::Vec3D	b
	)

check whether a segment defined by the two points a and b has any intersections with the faces of the tree

Definition at line 64 of file AABB.cpp.

References _is2D, and _tree.

{
  if (_is2D)
  {
      // can't do this check sine we are using 3d segments
      return false;
  }
  else
  {
      K::Segment_3 query(K::Point_3(a[0], a[1], a[2]),
                         K::Point_3(b[0], b[1], b[2]));
      return _tree->do_intersect(query); 
  }
}

bool AABB::hasIntersectionWithTriangle	(	AABB::Vec3D	a,
		AABB::Vec3D	b,
		AABB::Vec3D	c
	)

check whether a triangle defined by the three points a, b and c has any intersections with the faces of the tree

Definition at line 81 of file AABB.cpp.

References _is2D, _tree, and _tree_2D.

Referenced by IBManager::markIntersections(), and meshIntersections().

{
  K::Triangle_3 query(K::Point_3(a[0], a[1], a[2]),
                      K::Point_3(b[0], b[1], b[2]),
                      K::Point_3(c[0], c[1], c[2])
                      );
  if (_is2D)
    return _tree_2D->do_intersect(query);
  else
    return _tree->do_intersect(query); 
}

int AABB::meshIntersections

(

const Mesh &

mesh

)

Definition at line 94 of file AABB.cpp.

References _is2D, Mesh::getAllFaceNodes(), Mesh::getCellNodes(), Mesh::getCells(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaces(), Mesh::getNodeCoordinates(), StorageSite::getSelfCount(), and hasIntersectionWithTriangle().

{
  const Array<Vector<double,3> >& meshCoords = mesh.getNodeCoordinates();
  int nIntersections = 0;

  if (_is2D)
  {
      const StorageSite& cells = mesh.getCells();
      const CRConnectivity& cellNodes = mesh.getCellNodes();
      
      const int nCells = cells.getSelfCount();
      for(int n=0; n<nCells; n++)
      {
          const Vec3D& a = meshCoords[cellNodes(n,0)];
          const Vec3D& b = meshCoords[cellNodes(n,1)];
          const Vec3D& c = meshCoords[cellNodes(n,2)];
          
          if (hasIntersectionWithTriangle(a,b,c))
          {
              nIntersections++;
          }
          else if (cellNodes.getCount(n) == 4)
          {
              
              const Vec3D& d = meshCoords[cellNodes(n,3)];
              if (hasIntersectionWithTriangle(c,d,a))
              {
                  nIntersections++;
              }
          }
      }
  }
  else
  {
      const StorageSite& faces = mesh.getFaces();
      const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
      
      const int nFaces = faces.getCount();
      for(int n=0; n<nFaces; n++)
      {
          const Vec3D& a = meshCoords[faceNodes(n,0)];
          const Vec3D& b = meshCoords[faceNodes(n,1)];
          const Vec3D& c = meshCoords[faceNodes(n,2)];
          
          if (hasIntersectionWithTriangle(a,b,c))
          {
              nIntersections++;
          }
          else if (faceNodes.getCount(n) == 4)
          {
              
              const Vec3D& d = meshCoords[faceNodes(n,3)];
              if (hasIntersectionWithTriangle(c,d,a))
              {
                  nIntersections++;
              }
          }
      }
  }
  return nIntersections;
}

Member Data Documentation

bool AABB::_is2D

private

Definition at line 260 of file AABB.h.

Referenced by AABB(), findOrientedSide(), hasIntersectionWithSegment(), hasIntersectionWithTriangle(), and meshIntersections().

boost::shared_ptr<CGAL_Tree> AABB::_tree

private

Definition at line 262 of file AABB.h.

Referenced by AABB(), hasIntersectionWithSegment(), and hasIntersectionWithTriangle().

boost::shared_ptr<CGAL_Tree_2D> AABB::_tree_2D

private

Definition at line 263 of file AABB.h.

Referenced by AABB(), and hasIntersectionWithTriangle().

std::vector<MyTriangle*> AABB::_triangles

private

Definition at line 261 of file AABB.h.

Referenced by AABB(), and findOrientedSide().

---

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

• AABB.h
• AABB.cpp