libMesh::TriangulatorInterface::AffineHole Class Reference

A way to translate and/or rotate an existing hole; perhaps to tile it in many places or to put it at an angle that the underlying hole doesn't support. More...

#include <mesh_triangle_holes.h>

Inheritance diagram for libMesh::TriangulatorInterface::AffineHole:

Public Member Functions
	AffineHole (const Hole &underlying, Real angle, const Point &shift)
	Constructor specifying the underlying hole, and the rotation angle (in radians, done first) and translation (done second) with which to transform it.
virtual unsigned int	n_points () const override
	The number of geometric points which define the hole.
virtual Point	point (const unsigned int n) const override
	Return the nth point defining the hole.
virtual Point	inside () const override
	Return an (arbitrary) point which lies inside the hole.
virtual unsigned int	n_midpoints () const
	The number of geometric midpoints along each of the sides defining the hole.
virtual Point	midpoint (const unsigned int, const unsigned int) const
	Return the midpoint m along the side n defining the hole.
bool	contains (Point p) const
	Return true iff p lies inside the hole.
Real	area () const
	Return the area of the hole.
RealGradient	areavec () const
	Return a vector with right-hand-rule orientation and length of twice area() squared.
virtual std::vector< unsigned int >	segment_indices () const
	Starting indices of points for a hole with multiple disconnected boundaries.
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.
virtual bool	refine_boundary_allowed () const
	Get whether or not the triangulation is allowed to refine the mesh boundary when refining the interior.

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()
Point	calculate_inside_point () const
	Calculate an inside point based on our boundary.

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

Private Member Functions
Point	transform (const Point &p) const
	Rotate-and-shift equations.

Private Attributes
const Hole &	_underlying
	Hole to transform.
Real	_angle
	Angle to rotate (counter-clockwise) by.
Point	_shift
	(x,y) location to shift (0,0) to

Detailed Description

A way to translate and/or rotate an existing hole; perhaps to tile it in many places or to put it at an angle that the underlying hole doesn't support.

Definition at line 213 of file mesh_triangle_holes.h.

Constructor & Destructor Documentation

AffineHole()

libMesh::TriangulatorInterface::AffineHole::AffineHole ( const Hole &  underlying, Real  angle, const Point &  shift  )

inline

Constructor specifying the underlying hole, and the rotation angle (in radians, done first) and translation (done second) with which to transform it.

Definition at line 221 of file mesh_triangle_holes.h.

    : _underlying(underlying), _angle(angle), _shift(shift) {}

Member Function Documentation

area()

Real libMesh::TriangulatorInterface::Hole::area ( ) const

inherited

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 190 of file mesh_triangle_holes.C.

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

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

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

areavec()

RealGradient libMesh::TriangulatorInterface::Hole::areavec ( ) const

inherited

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 196 of file mesh_triangle_holes.C.

{
  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;
}

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

Referenced by libMesh::TriangulatorInterface::Hole::area().

calculate_inside_point()

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

protectedinherited

Calculate an inside point based on our boundary.

Definition at line 254 of file mesh_triangle_holes.C.

{
  // 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;
}

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

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

contains()

bool libMesh::TriangulatorInterface::Hole::contains ( Point  p ) const

inherited

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 311 of file mesh_triangle_holes.C.

{
  // 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;
}

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

find_ray_intersections()

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

protectedinherited

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

Definition at line 230 of file mesh_triangle_holes.C.

{
  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;
}

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

inside()

Point libMesh::TriangulatorInterface::AffineHole::inside ( ) const

overridevirtual

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

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 371 of file mesh_triangle_holes.C.

{
  return this->transform(_underlying.inside());
}

midpoint()

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

inlinevirtualinherited

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

inlinevirtualinherited

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::AffineHole::n_points ( ) const

inlineoverridevirtual

The number of geometric points which define the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 224 of file mesh_triangle_holes.h.

  { return _underlying.n_points(); }

References _underlying, and libMesh::TriangulatorInterface::Hole::n_points().

point()

Point libMesh::TriangulatorInterface::AffineHole::point ( const unsigned int  n ) const

overridevirtual

Return the nth point defining the hole.

Implements libMesh::TriangulatorInterface::Hole.

Definition at line 365 of file mesh_triangle_holes.C.

{
  return this->transform(_underlying.point(n));
}

refine_boundary_allowed()

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

inlinevirtualinherited

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.

  { return _refine_bdy_allowed; }

References libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed.

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

segment_indices()

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

inlinevirtualinherited

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.

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

References libMesh::TriangulatorInterface::Hole::n_points().

set_refine_boundary_allowed()

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

inlinevirtualinherited

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.

  { _refine_bdy_allowed = refine_bdy_allowed; }

References libMesh::TriangulatorInterface::Hole::_refine_bdy_allowed.

Referenced by MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase().

transform()

Point libMesh::TriangulatorInterface::AffineHole::transform ( const Point &  p ) const

private

Rotate-and-shift equations.

Definition at line 377 of file mesh_triangle_holes.C.

{
  const Real cos_a = std::cos(_angle);
  const Real sin_a = std::sin(_angle);
  return Point(p(0)*cos_a-p(1)*sin_a + _shift(0),
               p(1)*cos_a+p(1)*sin_a + _shift(1));
}

References libMesh::Real.

Member Data Documentation

_angle

Real libMesh::TriangulatorInterface::AffineHole::_angle

private

Angle to rotate (counter-clockwise) by.

Definition at line 245 of file mesh_triangle_holes.h.

_refine_bdy_allowed

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

protectedinherited

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 libMesh::TriangulatorInterface::Hole::refine_boundary_allowed(), and libMesh::TriangulatorInterface::Hole::set_refine_boundary_allowed().

_shift

Point libMesh::TriangulatorInterface::AffineHole::_shift

private

(x,y) location to shift (0,0) to

Definition at line 250 of file mesh_triangle_holes.h.

_underlying

const Hole& libMesh::TriangulatorInterface::AffineHole::_underlying

private

Hole to transform.

Definition at line 240 of file mesh_triangle_holes.h.

Referenced by n_points().

---

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

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