libMesh::TriangulatorInterface::Hole Class Reference

An abstract class for defining a 2-dimensional hole. More...

#include <mesh_triangle_holes.h>

Inheritance diagram for libMesh::TriangulatorInterface::Hole:

Public Member Functions
	Hole ()=default
	Constructor. More...
virtual	~Hole ()=default
	Destructor. More...
virtual unsigned int	n_points () const =0
	The number of geometric points which define the hole. More...
virtual unsigned int	n_midpoints () const
	The number of geometric midpoints along each of the sides defining the hole. More...
virtual Point	point (const unsigned int n) const =0
	Return the nth point defining the hole. More...
virtual Point	midpoint (const unsigned int, const unsigned int) const
	Return the midpoint m along the side n defining the hole. More...
virtual Point	inside () const =0
	Return an (arbitrary) point which lies inside the hole. More...
bool	contains (Point p) const
	Return true iff p lies inside the hole. More...
Real	area () const
	Return the area of the hole. More...
RealGradient	areavec () const
	Return a vector with right-hand-rule orientation and length of twice area() squared. More...
virtual std::vector< unsigned int >	segment_indices () const
	Starting indices of points for a hole with multiple disconnected boundaries. More...
virtual void	set_refine_boundary_allowed (bool refine_bdy_allowed)
	Set whether or not a triangulator is allowed to refine the hole boundary when refining the mesh interior. More...
virtual bool	refine_boundary_allowed () const
	Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior. More...

Protected Member Functions
std::vector< Real >	find_ray_intersections (Point ray_start, Point ray_target) const
	Helper function for contains(), also useful for MeshedHole::inside() More...
Point	calculate_inside_point () const
	Calculate an inside point based on our boundary. More...

Protected Attributes
bool	_refine_bdy_allowed = true
	Whether to allow boundary refinement. More...

Detailed Description

An abstract class for defining a 2-dimensional hole.

We assume that the connectivity of the hole is implicit in the numbering of the points, controlled by segment_indices vector. The size of segment_indices is equal to the number of segments plus one. Each segment has segment_indices[i+1]-segment_indices[i] connected points, with node segment_indices[i] is connected to node segment_indices[i+1], node segment_indices[i+1] is connected to node segment_indices[i+2], etc, and the last node "wraps around" to connect back to node segment_indices[i].

Author

John W. Peterson

Date

2011 Class for parameterizing 2D holes to be meshed with Triangle.

Definition at line 48 of file mesh_triangle_holes.h.

Constructor & Destructor Documentation

Hole()

libMesh::TriangulatorInterface::Hole::Hole ( )

default

Constructor.

~Hole()

virtual libMesh::TriangulatorInterface::Hole::~Hole ( )

virtualdefault

Destructor.

Member Function Documentation

area()

Real libMesh::TriangulatorInterface::Hole::area

(

)

const

Return the area of the hole.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 184 of file mesh_triangle_holes.C.

References areavec(), and libMesh::TypeVector< T >::norm().

Referenced by libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), and MeshTriangulationTest::testTriangleHoleArea().

{
  return this->areavec().norm() / 2;
}

areavec()

RealGradient libMesh::TriangulatorInterface::Hole::areavec

(

)

const

Return a vector with right-hand-rule orientation and length of twice area() squared.

This is useful for determining orientation of non-planar or non-counter-clockwise holes.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 190 of file mesh_triangle_holes.C.

References libMesh::TypeVector< T >::cross().

Referenced by area().

{
  const unsigned int np = this->n_points();

  if (np < 3)
    return 0;

  const Point p0 = this->point(0);

  // Every segment (p_{i-1},p_i) from i=2 on defines a triangle w.r.t.
  // p_0.  Add up the cross products of those triangles.  We'll save
  // the division by 2 and the norm for the end.
  //
  // Your hole points had best be coplanar, but this should work
  // regardless of which plane they're in.  If you're in the XY plane,
  // then the standard counter-clockwise hole point ordering gives you
  // a positive areavec(2);

  RealGradient areavec = 0;

  for (unsigned int i=2; i != np; ++i)
    {
      const Point e_0im = this->point(i-1) - p0,
                  e_0i  = this->point(i) - p0;

      areavec += e_0i.cross(e_0im);
    }

  return areavec;
}

calculate_inside_point()

Point libMesh::TriangulatorInterface::Hole::calculate_inside_point ( ) const

protected

Calculate an inside point based on our boundary.

Definition at line 248 of file mesh_triangle_holes.C.

References libMesh::make_range(), and libMesh::Real.

Referenced by libMesh::TriangulatorInterface::ArbitraryHole::ArbitraryHole(), and libMesh::TriangulatorInterface::ArbitraryHole::set_points().

{
  // Start with the vertex average

  // Turns out "I'm a fully compliant C++17 compiler!" doesn't
  // mean "I have a full C++17 standard library!"
  // inside = std::reduce(points.begin(), points.end());
  Point inside = 0;
  for (auto i : make_range(this->n_points()))
    inside += this->point(i);

  inside /= this->n_points();

  // Count the number of intersections with a ray to the right,
  // keep track of how far they are
  Point ray_target = inside + Point(1);
  std::vector<Real> intersection_distances =
    this->find_ray_intersections(inside, ray_target);

  // The vertex average isn't on the interior, and we found no
  // intersections to the right?  Try looking to the left.
  if (!intersection_distances.size())
    {
      ray_target = inside - Point(1);
      intersection_distances =
        this->find_ray_intersections(inside, ray_target);
    }

  // I'd make this an assert, but I'm not 100% confident we can't
  // get here via some kind of FP error on a weird hole shape.
  libmesh_error_msg_if
    (!intersection_distances.size(),
     "Can't find a center for a MeshedHole!");

  if (intersection_distances.size() % 2)
    return inside;

  // The vertex average is outside.  So go from the vertex average to
  // the closest edge intersection, then halfway to the next-closest.

  // Find the nearest first.
  Real min_distance    = std::numeric_limits<Real>::max(),
       second_distance = std::numeric_limits<Real>::max();
  for (Real d : intersection_distances)
    if (d < min_distance)
      {
        second_distance = min_distance;
        min_distance = d;
      }

  const Point ray = ray_target - inside;
  inside += ray * (min_distance + second_distance)/2;

  return inside;
}

contains()

bool libMesh::TriangulatorInterface::Hole::contains

(

Point

p

)

const

Return true iff p lies inside the hole.

This method currently does not take any higher-order hole geometry into account, but treats the hole as a polygon.

Definition at line 305 of file mesh_triangle_holes.C.

Referenced by libMesh::TriangulatorInterface::verify_holes().

{
  // Count the number of intersections with a ray to the right,
  // keep track of how far they are
  Point ray_target = p + Point(1);
  std::vector<Real> intersection_distances =
    this->find_ray_intersections(p, ray_target);

  // Odd number of intersections == we're inside
  // Even number == we're outside
  return intersection_distances.size() % 2;
}

find_ray_intersections()

std::vector< Real > libMesh::TriangulatorInterface::Hole::find_ray_intersections ( Point  ray_start, Point  ray_target  ) const

protected

Helper function for contains(), also useful for MeshedHole::inside()

Definition at line 224 of file mesh_triangle_holes.C.

References libMesh::make_range(), and libMesh::Real.

{
  const auto np = this->n_points();

  std::vector<Real> intersection_distances;

  for (auto i : make_range(np))
    {
      const Point & p0 = this->point(i),
                  & p1 = this->point((i+1)%np),
                  & p2 = this->point((i+2)%np);
      const Real intersection_distance =
        find_intersection(ray_start, ray_target, p0, p1, p2);
      if (intersection_distance >= 0)
        intersection_distances.push_back
          (intersection_distance);
    }

  return intersection_distances;
}

inside()

virtual Point libMesh::TriangulatorInterface::Hole::inside ( ) const

pure virtual

Return an (arbitrary) point which lies inside the hole.

Implemented in libMesh::TriangulatorInterface::MeshedHole, libMesh::TriangulatorInterface::ArbitraryHole, libMesh::TriangulatorInterface::AffineHole, and libMesh::TriangulatorInterface::PolygonHole.

midpoint()

virtual Point libMesh::TriangulatorInterface::Hole::midpoint ( const unsigned int  , const unsigned int    ) const

inlinevirtual

Return the midpoint m along the side n defining the hole.

Reimplemented in libMesh::TriangulatorInterface::MeshedHole.

Definition at line 80 of file mesh_triangle_holes.h.

  { libmesh_error(); /* by default holes are polygonal */ }

n_midpoints()

virtual unsigned int libMesh::TriangulatorInterface::Hole::n_midpoints ( ) const

inlinevirtual

The number of geometric midpoints along each of the sides defining the hole.

Reimplemented in libMesh::TriangulatorInterface::MeshedHole.

Definition at line 70 of file mesh_triangle_holes.h.

{ return 0; }

n_points()

virtual unsigned int libMesh::TriangulatorInterface::Hole::n_points ( ) const

pure virtual

The number of geometric points which define the hole.

Implemented in libMesh::TriangulatorInterface::MeshedHole, libMesh::TriangulatorInterface::ArbitraryHole, libMesh::TriangulatorInterface::AffineHole, and libMesh::TriangulatorInterface::PolygonHole.

Referenced by libMesh::TriangulatorInterface::ArbitraryHole::ArbitraryHole(), libMesh::TriangulatorInterface::AffineHole::n_points(), segment_indices(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

point()

virtual Point libMesh::TriangulatorInterface::Hole::point ( const unsigned int  n ) const

pure virtual

Return the nth point defining the hole.

Implemented in libMesh::TriangulatorInterface::MeshedHole, libMesh::TriangulatorInterface::ArbitraryHole, libMesh::TriangulatorInterface::AffineHole, and libMesh::TriangulatorInterface::PolygonHole.

Referenced by libMesh::TriangulatorInterface::ArbitraryHole::ArbitraryHole(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

refine_boundary_allowed()

virtual bool libMesh::TriangulatorInterface::Hole::refine_boundary_allowed ( ) const

inlinevirtual

Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.

True by default.

Definition at line 140 of file mesh_triangle_holes.h.

References _refine_bdy_allowed.

Referenced by libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), and MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

  { return _refine_bdy_allowed; }

segment_indices()

virtual std::vector<unsigned int> libMesh::TriangulatorInterface::Hole::segment_indices ( ) const

inlinevirtual

Starting indices of points for a hole with multiple disconnected boundaries.

Reimplemented in libMesh::TriangulatorInterface::ArbitraryHole.

Definition at line 118 of file mesh_triangle_holes.h.

References n_points().

  {
    // default to only one enclosing boundary
    std::vector<unsigned int> seg;
    seg.push_back(0);
    seg.push_back(n_points());
    return seg;
  }

set_refine_boundary_allowed()

virtual void libMesh::TriangulatorInterface::Hole::set_refine_boundary_allowed ( bool  refine_bdy_allowed )

inlinevirtual

Set whether or not a triangulator is allowed to refine the hole boundary when refining the mesh interior.

This is true by default, but may be set to false to make the hole boundary more predictable (and so easier to stitch to other meshes) later.

Definition at line 133 of file mesh_triangle_holes.h.

References _refine_bdy_allowed.

Referenced by MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

  { _refine_bdy_allowed = refine_bdy_allowed; }

Member Data Documentation

_refine_bdy_allowed

bool libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed = true

protected

Whether to allow boundary refinement.

True by default; specified here so we can use the default constructor.

Definition at line 160 of file mesh_triangle_holes.h.

Referenced by refine_boundary_allowed(), and set_refine_boundary_allowed().

---

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

• include/mesh/mesh_triangle_holes.h
• src/mesh/mesh_triangle_holes.C