libMesh::TriangleInterface Class Reference

A C++ interface between LibMesh and the Triangle library written by J.R. More...

#include <mesh_triangle_interface.h>

Classes
class	ArbitraryHole
	Another concrete instantiation of the hole, this one should be sufficiently general for most non-polygonal purposes. More...
class	Hole
	An abstract class for defining a 2-dimensional hole. More...
class	PolygonHole
	A concrete instantiation of the Hole class that describes polygonal (triangular, square, pentagonal, ...) holes. More...
class	Region
	A class for defining a 2-dimensional region for Triangle. More...

Public Types
enum	TriangulationType { GENERATE_CONVEX_HULL = 0, PSLG = 1, INVALID_TRIANGULATION_TYPE }
	The TriangulationType is used with the general triangulate function defined below. More...

Public Member Functions
	TriangleInterface (UnstructuredMesh &mesh)
	The constructor. More...
	~TriangleInterface ()
	Empty destructor. More...
void	triangulate ()
	This is the main public interface for this function. More...
ElemType &	elem_type ()
	Sets and/or gets the desired element type. More...
Real &	desired_area ()
	Sets and/or gets the desired triangle area. More...
Real &	minimum_angle ()
	Sets and/or gets the minimum angle. More...
std::string &	extra_flags ()
	Sets and/or gets additional flags to be passed to triangle. More...
TriangulationType &	triangulation_type ()
	Sets and/or gets the desired triangulation type. More...
bool &	insert_extra_points ()
	Sets and/or gets the flag for inserting add'l points. More...
bool &	smooth_after_generating ()
	Sets/gets flag which tells whether to do Delaunay mesh smoothing after generating the grid. More...
bool &	quiet ()
	Whether or not to make Triangle quiet. More...
void	attach_hole_list (const std::vector< Hole * > *holes)
	Attaches a vector of Hole* pointers which will be meshed around. More...
void	attach_boundary_marker (const std::vector< int > *markers)
	Attaches boundary markers. More...
void	attach_region_list (const std::vector< Region * > *regions)
	Attaches regions for using attribute to set subdomain IDs and better controlling the triangle sizes within the regions. More...

Public Attributes
std::vector< std::pair< unsigned int, unsigned int > >	segments
	When constructing a PSLG, it is often not possible to do so implicitly through the ordering of the points. More...

Private Attributes
UnstructuredMesh &	_mesh
	Reference to the mesh which is to be created by triangle. More...
const std::vector< Hole * > *	_holes
	A pointer to a vector of Hole*s. More...
const std::vector< int > *	_markers
	Boundary markers. More...
const std::vector< Region * > *	_regions
	A pointer to a vector of Regions*s. More...
ElemType	_elem_type
	The type of elements to generate. More...
Real	_desired_area
	The desired area for the elements in the resulting mesh. More...
Real	_minimum_angle
	Minimum angle in triangles. More...
std::string	_extra_flags
	Additional flags to be passed to triangle. More...
TriangulationType	_triangulation_type
	The type of triangulation to perform: choices are: convex hull PSLG. More...
bool	_insert_extra_points
	Flag which tells whether or not to insert additional nodes before triangulation. More...
bool	_smooth_after_generating
	Flag which tells whether we should smooth the mesh after it is generated. More...
bool	_quiet
	Flag which tells if we want to suppress Triangle outputs. More...
MeshSerializer	_serializer
	Triangle only operates on serial meshes. More...

Detailed Description

A C++ interface between LibMesh and the Triangle library written by J.R.

Shewchuk.

Author

John W. Peterson

Date

2011

Definition at line 57 of file mesh_triangle_interface.h.

Member Enumeration Documentation

TriangulationType

enum libMesh::TriangleInterface::TriangulationType

The TriangulationType is used with the general triangulate function defined below.

Enumerator
GENERATE_CONVEX_HULL	Uses the triangle library to first generate a convex hull from the set of points passed in, and then triangulate this set of points. This is probably the most common type of usage.
PSLG	Use the triangle library to triangulate a Planar Straight Line Graph which is defined implicitly by the order of the "points" vector: a straight line is assumed to lie between each successive pair of points, with an additional line joining the final and first points. In case your triangulation is a little too "structured" looking (which can happen when the initial PSLG is really simple) you can try to make the resulting triangulation a little more "unstructured" looking by setting insert_points to true in the triangulate() function.
INVALID_TRIANGULATION_TYPE	Does nothing, used as a default value.

Definition at line 78 of file mesh_triangle_interface.h.

    {
      GENERATE_CONVEX_HULL = 0,
 
      PSLG = 1,
 
      INVALID_TRIANGULATION_TYPE
    };

Constructor & Destructor Documentation

TriangleInterface()

libMesh::TriangleInterface::TriangleInterface ( UnstructuredMesh &  mesh )

explicit

The constructor.

A reference to the mesh containing the points which are to be triangulated must be provided. Unless otherwise specified, a convex hull will be computed for the set of input points and the convex hull will be meshed.

Definition at line 44 of file mesh_triangle_interface.C.

  : _mesh(mesh),
    _holes(nullptr),
    _markers(nullptr),
    _regions(nullptr),
    _elem_type(TRI3),
    _desired_area(0.1),
    _minimum_angle(20.0),
    _extra_flags(""),
    _triangulation_type(GENERATE_CONVEX_HULL),
    _insert_extra_points(false),
    _smooth_after_generating(true),
    _quiet(true),
    _serializer(_mesh)
{}

~TriangleInterface()

libMesh::TriangleInterface::~TriangleInterface ( )

inline

Empty destructor.

Definition at line 72 of file mesh_triangle_interface.h.

{}

Member Function Documentation

attach_boundary_marker()

void libMesh::TriangleInterface::attach_boundary_marker ( const std::vector< int > *  markers )

inline

Attaches boundary markers.

If segments is set, the number of markers must be equal to the size of segments, otherwise, it is equal to the number of points.

Definition at line 194 of file mesh_triangle_interface.h.

{ _markers = markers; }

References _markers.

attach_hole_list()

void libMesh::TriangleInterface::attach_hole_list ( const std::vector< Hole * > *  holes )

inline

Attaches a vector of Hole* pointers which will be meshed around.

Definition at line 174 of file mesh_triangle_interface.h.

{_holes = holes;}

References _holes.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), and triangulate_domain().

attach_region_list()

void libMesh::TriangleInterface::attach_region_list ( const std::vector< Region * > *  regions )

inline

Attaches regions for using attribute to set subdomain IDs and better controlling the triangle sizes within the regions.

Definition at line 200 of file mesh_triangle_interface.h.

{ _regions = regions; }

References _regions.

desired_area()

Real& libMesh::TriangleInterface::desired_area ( )

inline

Sets and/or gets the desired triangle area.

Set to zero to disable area constraint.

Definition at line 136 of file mesh_triangle_interface.h.

{return _desired_area;}

References _desired_area.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), and triangulate_domain().

elem_type()

ElemType& libMesh::TriangleInterface::elem_type ( )

inline

Sets and/or gets the desired element type.

Definition at line 130 of file mesh_triangle_interface.h.

{return _elem_type;}

References _elem_type.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square().

extra_flags()

std::string& libMesh::TriangleInterface::extra_flags ( )

inline

Sets and/or gets additional flags to be passed to triangle.

Definition at line 147 of file mesh_triangle_interface.h.

{return _extra_flags;}

References _extra_flags.

insert_extra_points()

bool& libMesh::TriangleInterface::insert_extra_points ( )

inline

Sets and/or gets the flag for inserting add'l points.

Definition at line 157 of file mesh_triangle_interface.h.

{return _insert_extra_points;}

References _insert_extra_points.

minimum_angle()

Real& libMesh::TriangleInterface::minimum_angle ( )

inline

Sets and/or gets the minimum angle.

Set to zero to disable area constraint.

Definition at line 142 of file mesh_triangle_interface.h.

{return _minimum_angle;}

References _minimum_angle.

quiet()

bool& libMesh::TriangleInterface::quiet ( )

inline

Whether or not to make Triangle quiet.

Definition at line 168 of file mesh_triangle_interface.h.

{return _quiet;}

References _quiet.

smooth_after_generating()

bool& libMesh::TriangleInterface::smooth_after_generating ( )

inline

Sets/gets flag which tells whether to do Delaunay mesh smoothing after generating the grid.

Definition at line 163 of file mesh_triangle_interface.h.

{return _smooth_after_generating;}

References _smooth_after_generating.

Referenced by triangulate_domain().

triangulate()

void libMesh::TriangleInterface::triangulate

(

)

This is the main public interface for this function.

Internally, it calls Triangle's triangulate routine.

Definition at line 63 of file mesh_triangle_interface.C.

{
  // Will the triangulation have holes?
  const bool have_holes = ((_holes != nullptr) && (!_holes->empty()));
 
  // If the initial PSLG is really simple, e.g. an L-shaped domain or
  // a square/rectangle, the resulting triangulation may be very
  // "structured" looking.  Sometimes this is a problem if your
  // intention is to work with an "unstructured" looking grid.  We can
  // attempt to work around this limitation by inserting midpoints
  // into the original PSLG.  Inserting additional points into a
  // set of points meant to be a convex hull usually makes less sense.
 
  // May or may not need to insert new points ...
  if ((_triangulation_type==PSLG) && (_insert_extra_points))
    {
      // Make a copy of the original points from the Mesh
      std::vector<Point> original_points;
      original_points.reserve (_mesh.n_nodes());
      for (auto & node : _mesh.node_ptr_range())
        original_points.push_back(*node);
 
      // Clear out the mesh
      _mesh.clear();
 
      // Make sure the new Mesh will be 2D
      _mesh.set_mesh_dimension(2);
 
      // Insert a new point on each PSLG at some random location
      // np=index into new points vector
      // n =index into original points vector
      for (std::size_t np=0, n=0, tops=2*original_points.size(); np<tops; ++np)
        {
          // the even entries are the original points
          if (np%2==0)
            _mesh.add_point(original_points[n++]);
 
          else // the odd entries are the midpoints of the original PSLG segments
            _mesh.add_point ((original_points[n] + original_points[n-1])/2);
        }
    }
 
  // Regardless of whether we added additional points, the set of points to
  // triangulate is now sitting in the mesh.
 
  // If the holes vector is non-nullptr (and non-empty) we need to determine
  // the number of additional points which the holes will add to the
  // triangulation.
  // Note that the number of points is always equal to the number of segments
  // that form the holes.
  unsigned int n_hole_points = 0;
 
  if (have_holes)
    for (const auto & hole : *_holes)
    {
      n_hole_points += hole->n_points();
      // A hole at least has one enclosure.
      // Points on enclosures are ordered so that we can add segments implicitly.
      // Elements in segment_indices() indicates the starting points of all enclosures.
      // The last element in segment_indices() is the number of total points.
      libmesh_assert_greater(hole->segment_indices().size(), 1);
      libmesh_assert_equal_to(hole->segment_indices().back(), hole->n_points());
    }
 
  // Triangle data structure for the mesh
  TriangleWrapper::triangulateio initial;
  TriangleWrapper::triangulateio final;
  TriangleWrapper::triangulateio voronoi;
 
  // Pseudo-Constructor for the triangle io structs
  TriangleWrapper::init(initial);
  TriangleWrapper::init(final);
  TriangleWrapper::init(voronoi);
 
  initial.numberofpoints = _mesh.n_nodes() + n_hole_points;
  initial.pointlist      = static_cast<REAL*>(std::malloc(initial.numberofpoints * 2 * sizeof(REAL)));
 
  if (_triangulation_type==PSLG)
    {
      // Implicit segment ordering: One segment per point, including hole points
      if (this->segments.empty())
        initial.numberofsegments = initial.numberofpoints;
 
      // User-defined segment ordering: One segment per entry in the segments vector
      else
        initial.numberofsegments = this->segments.size() + n_hole_points;
    }
 
  else if (_triangulation_type==GENERATE_CONVEX_HULL)
    initial.numberofsegments = n_hole_points; // One segment for each hole point
 
  // Allocate space for the segments (2 int per segment)
  if (initial.numberofsegments > 0)
    {
      initial.segmentlist = static_cast<int *> (std::malloc(initial.numberofsegments * 2 * sizeof(int)));
      if (_markers)
        initial.segmentmarkerlist = static_cast<int *> (std::malloc(initial.numberofsegments * sizeof(int)));
    }
 
 
  // Copy all the holes' points and segments into the triangle struct.
 
  // The hole_offset is a constant offset into the points vector which points
  // past the end of the last hole point added.
  unsigned int hole_offset=0;
 
  if (have_holes)
    for (const auto & hole : *_holes)
      {
        for (unsigned int ctr=0, h=0, i=0, hsism=hole->segment_indices().size()-1; i<hsism; ++i)
          {
            unsigned int begp = hole_offset + hole->segment_indices()[i];
            unsigned int endp = hole->segment_indices()[i+1];
 
            for (; h<endp; ctr+=2, ++h)
              {
                Point p = hole->point(h);
 
                const unsigned int index0 = 2*hole_offset+ctr;
                const unsigned int index1 = 2*hole_offset+ctr+1;
 
                // Save the x,y locations in the triangle struct.
                initial.pointlist[index0] = p(0);
                initial.pointlist[index1] = p(1);
 
                // Set the points which define the segments
                initial.segmentlist[index0] = hole_offset+h;
                initial.segmentlist[index1] = (h == endp - 1) ? begp : hole_offset + h + 1; // wrap around
                if (_markers)
                  // 1 is reserved for boundaries of holes
                  initial.segmentmarkerlist[hole_offset+h] = 1;
              }
          }
 
        // Update the hole_offset for the next hole
        hole_offset += hole->n_points();
      }
 
 
  // Copy all the non-hole points and segments into the triangle struct.
  {
    dof_id_type ctr=0;
    for (auto & node : _mesh.node_ptr_range())
      {
        dof_id_type index = 2*hole_offset + ctr;
 
        // Set x,y values in pointlist
        initial.pointlist[index] = (*node)(0);
        initial.pointlist[index+1] = (*node)(1);
 
        // If the user requested a PSLG, the non-hole points are also segments
        if (_triangulation_type==PSLG)
          {
            // Use implicit ordering to define segments
            if (this->segments.empty())
              {
                dof_id_type n = ctr/2; // ctr is always even
                initial.segmentlist[index] = hole_offset+n;
                initial.segmentlist[index+1] = (n==_mesh.n_nodes()-1) ? hole_offset : hole_offset+n+1; // wrap around
                if (_markers)
                  initial.segmentmarkerlist[hole_offset + n] = (*_markers)[n];
              }
          }
 
        ctr +=2;
      }
  }
 
 
  // If the user provided it, use his ordering to define the segments
  for (std::size_t ctr=0, s=0, ss=this->segments.size(); s<ss; ctr+=2, ++s)
    {
      const unsigned int index0 = 2*hole_offset+ctr;
      const unsigned int index1 = 2*hole_offset+ctr+1;
 
      initial.segmentlist[index0] = hole_offset + this->segments[s].first;
      initial.segmentlist[index1] = hole_offset + this->segments[s].second;
      if (_markers)
        initial.segmentmarkerlist[hole_offset + s] = (*_markers)[s];
    }
 
 
 
  // Tell the input struct about the holes
  if (have_holes)
    {
      initial.numberofholes = _holes->size();
      initial.holelist      = static_cast<REAL*>(std::malloc(initial.numberofholes * 2 * sizeof(REAL)));
      for (std::size_t i=0, ctr=0, hs=_holes->size(); i<hs; ++i, ctr+=2)
        {
          Point inside_point = (*_holes)[i]->inside();
          initial.holelist[ctr]   = inside_point(0);
          initial.holelist[ctr+1] = inside_point(1);
        }
    }
 
  if (_regions)
    {
      initial.numberofregions = _regions->size();
      initial.regionlist      = static_cast<REAL*>(std::malloc(initial.numberofregions * 4 * sizeof(REAL)));
      for (std::size_t i=0, ctr=0, rs=_regions->size(); i<rs; ++i, ctr+=4)
        {
          Point inside_point = (*_regions)[i]->inside();
          initial.regionlist[ctr]   = inside_point(0);
          initial.regionlist[ctr+1] = inside_point(1);
          initial.regionlist[ctr+2] = (*_regions)[i]->attribute();
          initial.regionlist[ctr+3] = (*_regions)[i]->max_area();
        }
    }
 
  // Set the triangulation flags.
  // c ~ enclose convex hull with segments
  // z ~ use zero indexing
  // B ~ Suppresses boundary markers in the output
  // Q ~ run in "quiet" mode
  // p ~ Triangulates a Planar Straight Line Graph
  //     If the `p' switch is used, `segmentlist' must point to a list of
  //     segments, `numberofsegments' must be properly set, and
  //     `segmentmarkerlist' must either be set to nullptr (in which case all
  //     markers default to zero), or must point to a list of markers.
  // D ~ Conforming Delaunay: use this switch if you want all triangles
  //     in the mesh to be Delaunay, and not just constrained Delaunay
  // q ~  Quality mesh generation with no angles smaller than 20 degrees.
  //      An alternate minimum angle may be specified after the q
  // a ~ Imposes a maximum triangle area constraint.
  // -P  Suppresses the output .poly file. Saves disk space, but you lose the ability to maintain
  //     constraining segments on later refinements of the mesh.
  // -e  Outputs (to an .edge file) a list of edges of the triangulation.
  // -v  Outputs the Voronoi diagram associated with the triangulation.
  // Create the flag strings, depends on element type
  std::ostringstream flags;
 
  // Default flags always used
  flags << "z";
 
  if (_quiet)
    flags << "QP";
  else
    flags << "V";
 
  if (_markers)
    flags << "ev";
 
  // Flags which are specific to the type of triangulation
  switch (_triangulation_type)
    {
    case GENERATE_CONVEX_HULL:
      {
        flags << "c";
        break;
      }
 
    case PSLG:
      {
        flags << "p";
        break;
      }
 
    case INVALID_TRIANGULATION_TYPE:
      libmesh_error_msg("ERROR: INVALID_TRIANGULATION_TYPE selected!");
 
    default:
      libmesh_error_msg("Unrecognized _triangulation_type");
    }
 
 
  // Flags specific to the type of element
  switch (_elem_type)
    {
    case TRI3:
      {
        // do nothing.
        break;
      }
 
    case TRI6:
      {
        flags << "o2";
        break;
      }
 
    default:
      libmesh_error_msg("ERROR: Unrecognized triangular element type.");
    }
 
 
  // If we do have holes and the user asked to GENERATE_CONVEX_HULL,
  // need to add the p flag so the triangulation respects those segments.
  if ((_triangulation_type==GENERATE_CONVEX_HULL) && (have_holes))
    flags << "p";
 
  // Finally, add the area constraint
  if (_desired_area > TOLERANCE)
    flags << "a" << std::fixed << _desired_area;
 
  // add minimum angle constraint
  if (_minimum_angle > TOLERANCE)
    flags << "q" << std::fixed << _minimum_angle;
 
  if (_regions)
    flags << "Aa";
 
  // add user provided extra flags
  if (_extra_flags.size() > 0)
    flags << _extra_flags;
 
  // Refine the initial output to conform to the area constraint
  if (_markers)
  {
    // need Voronoi to generate boundary information
    TriangleWrapper::triangulate(const_cast<char *>(flags.str().c_str()),
                                 &initial,
                                 &final,
                                 &voronoi);
 
    // Send the information computed by Triangle to the Mesh.
    TriangleWrapper::copy_tri_to_mesh(final,
                                      _mesh,
                                      _elem_type,
                                      &voronoi);
  }
  else
  {
    TriangleWrapper::triangulate(const_cast<char *>(flags.str().c_str()),
                                 &initial,
                                 &final,
                                 nullptr);
    // Send the information computed by Triangle to the Mesh.
    TriangleWrapper::copy_tri_to_mesh(final,
                                      _mesh,
                                      _elem_type);
  }
 
 
 
  // To the naked eye, a few smoothing iterations usually looks better,
  // so we do this by default unless the user says not to.
  if (this->_smooth_after_generating)
    LaplaceMeshSmoother(_mesh).smooth(2);
 
 
  // Clean up.
  TriangleWrapper::destroy(initial,      TriangleWrapper::INPUT);
  TriangleWrapper::destroy(final,        TriangleWrapper::OUTPUT);
  TriangleWrapper::destroy(voronoi,      TriangleWrapper::OUTPUT);
 
  // Prepare the mesh for use before returning.  This ensures (among
  // other things) that it is partitioned and therefore users can
  // iterate over local elements, etc.
  _mesh.prepare_for_use();
}

References _desired_area, _elem_type, _extra_flags, _holes, _insert_extra_points, _markers, _mesh, _minimum_angle, _quiet, _regions, _smooth_after_generating, _triangulation_type, libMesh::MeshBase::add_point(), libMesh::MeshBase::clear(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::TriangleWrapper::destroy(), GENERATE_CONVEX_HULL, libMesh::TriangleWrapper::init(), libMesh::TriangleWrapper::INPUT, INVALID_TRIANGULATION_TYPE, libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr_range(), libMesh::TriangleWrapper::OUTPUT, libMesh::MeshBase::prepare_for_use(), PSLG, segments, libMesh::MeshBase::set_mesh_dimension(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::TOLERANCE, libMesh::TRI3, and libMesh::TRI6.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), and triangulate_domain().

triangulation_type()

TriangulationType& libMesh::TriangleInterface::triangulation_type ( )

inline

Sets and/or gets the desired triangulation type.

Definition at line 152 of file mesh_triangle_interface.h.

{return _triangulation_type;}

References _triangulation_type.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), and triangulate_domain().

Member Data Documentation

_desired_area

Real libMesh::TriangleInterface::_desired_area

private

The desired area for the elements in the resulting mesh.

Definition at line 234 of file mesh_triangle_interface.h.

Referenced by desired_area(), and triangulate().

_elem_type

ElemType libMesh::TriangleInterface::_elem_type

private

The type of elements to generate.

(Defaults to TRI3).

Definition at line 229 of file mesh_triangle_interface.h.

Referenced by elem_type(), and triangulate().

_extra_flags

std::string libMesh::TriangleInterface::_extra_flags

private

Additional flags to be passed to triangle.

Definition at line 244 of file mesh_triangle_interface.h.

Referenced by extra_flags(), and triangulate().

_holes

const std::vector<Hole*>* libMesh::TriangleInterface::_holes

private

A pointer to a vector of Hole*s.

If this is nullptr, there are no holes!

Definition at line 212 of file mesh_triangle_interface.h.

Referenced by attach_hole_list(), and triangulate().

_insert_extra_points

bool libMesh::TriangleInterface::_insert_extra_points

private

Flag which tells whether or not to insert additional nodes before triangulation.

This can sometimes be used to "de-regularize" the resulting triangulation.

Definition at line 258 of file mesh_triangle_interface.h.

Referenced by insert_extra_points(), and triangulate().

_markers

const std::vector<int>* libMesh::TriangleInterface::_markers

private

Boundary markers.

Definition at line 217 of file mesh_triangle_interface.h.

Referenced by attach_boundary_marker(), and triangulate().

_mesh

UnstructuredMesh& libMesh::TriangleInterface::_mesh

private

Reference to the mesh which is to be created by triangle.

Definition at line 206 of file mesh_triangle_interface.h.

Referenced by triangulate().

_minimum_angle

Real libMesh::TriangleInterface::_minimum_angle

private

Minimum angle in triangles.

Definition at line 239 of file mesh_triangle_interface.h.

Referenced by minimum_angle(), and triangulate().

_quiet

bool libMesh::TriangleInterface::_quiet

private

Flag which tells if we want to suppress Triangle outputs.

Definition at line 269 of file mesh_triangle_interface.h.

Referenced by quiet(), and triangulate().

_regions

const std::vector<Region*>* libMesh::TriangleInterface::_regions

private

A pointer to a vector of Regions*s.

If this is nullptr, there are no regions!

Definition at line 223 of file mesh_triangle_interface.h.

Referenced by attach_region_list(), and triangulate().

_serializer

MeshSerializer libMesh::TriangleInterface::_serializer

private

Triangle only operates on serial meshes.

Definition at line 274 of file mesh_triangle_interface.h.

_smooth_after_generating

bool libMesh::TriangleInterface::_smooth_after_generating

private

Flag which tells whether we should smooth the mesh after it is generated.

True by default.

Definition at line 264 of file mesh_triangle_interface.h.

Referenced by smooth_after_generating(), and triangulate().

_triangulation_type

TriangulationType libMesh::TriangleInterface::_triangulation_type

private

The type of triangulation to perform: choices are: convex hull PSLG.

Definition at line 251 of file mesh_triangle_interface.h.

Referenced by triangulate(), and triangulation_type().

segments

std::vector<std::pair<unsigned int, unsigned int> > libMesh::TriangleInterface::segments

When constructing a PSLG, it is often not possible to do so implicitly through the ordering of the points.

You can use the segments vector to specify the segments explicitly, Ex: unit square numbered counter-clockwise starting from origin segments[0] = (0,1) segments[1] = (1,2) segments[2] = (2,3) segments[3] = (3,0) For this case you could actually use the implicit ordering!

Definition at line 187 of file mesh_triangle_interface.h.

Referenced by triangulate().

---

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

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