tatooine::mesh< Real, N > Class Template Reference

#include <mesh.h>

Inheritance diagram for tatooine::mesh< Real, N >:

Collaboration diagram for tatooine::mesh< Real, N >:

Classes
struct	face
struct	face_container
struct	face_iterator
struct	face_prop
struct	rotation_independent_face_equal

Public Types
using	this_type = mesh< Real, N >
using	parent_type = edgeset< Real, N >
template<typename T >
using	vertex_prop = typename parent_type::template vertex_prop< T >
template<typename T >
using	edge_prop = typename parent_type::template edge_prop< T >
Public Types inherited from tatooine::edgeset< Real, N >
using	this_type = edgeset< Real, NumDimensions >
using	parent_type = unstructured_simplicial_grid< Real, NumDimensions, 1 >
using	edge_handle = typename parent_type::simplex_handle
Public Types inherited from tatooine::unstructured_simplicial_grid< Real, NumDimensions, 1 >
using	this_type = unstructured_simplicial_grid< Real, NumDimensions, SimplexDim >
using	real_type = Real
using	parent_type = detail::unstructured_simplicial_grid::parent< this_type, Real, NumDimensions, SimplexDim >
using	vertex_property_sampler_type = detail::unstructured_simplicial_grid::vertex_property_sampler< Real, NumDimensions, SimplexDim, T >
using	typed_vertex_property_type = typename parent_type::template typed_vertex_property_type< T >
using	hierarchy_type = typename parent_type::hierarchy_type
using	simplex_container = detail::unstructured_simplicial_grid::simplex_container< Real, NumDimensions, SimplexDim >
using	simplex_property_type = typed_vector_property< simplex_handle, T >
using	simplex_property_container_type = std::map< std::string, std::unique_ptr< vector_property< simplex_handle > > >
using	const_simplex_at_return_type = detail::unstructured_simplicial_grid::simplex_at_return_type< vertex_handle const &, SimplexDim+1 >
using	simplex_at_return_type = detail::unstructured_simplicial_grid::simplex_at_return_type< vertex_handle &, SimplexDim+1 >
Public Types inherited from tatooine::detail::unstructured_simplicial_grid::parent< unstructured_simplicial_grid< Real, NumDimensions, SimplexDim >, Real, NumDimensions, SimplexDim >
using	parent_type = pointset< Real, NumDimensions >
using	hierarchy_type = hierarchy< unstructured_simplicial_grid< Real, NumDimensions, SimplexDim >, Real, NumDimensions, SimplexDim >
using	const_simplex_at_return_type = detail::unstructured_simplicial_grid::simplex_at_return_type< vertex_handle const &, SimplexDim+1 >
using	simplex_at_return_type = detail::unstructured_simplicial_grid::simplex_at_return_type< vertex_handle &, SimplexDim+1 >
Public Types inherited from tatooine::pointset< Real, NumDimensions >
using	real_type = Real
using	this_type = pointset< Real, NumDimensions >
using	vec_type = vec< Real, NumDimensions >
using	pos_type = vec_type
using	flann_index_type = flann::Index< flann::L2< Real > >
using	vertex_container = detail::pointset::vertex_container< Real, NumDimensions >
using	const_vertex_container = detail::pointset::const_vertex_container< Real, NumDimensions >
using	vertex_property_type = vector_property< vertex_handle >
template<typename T >
using	typed_vertex_property_type = typed_vector_property< vertex_handle, T >
using	vertex_property_container_type = std::map< std::string, std::unique_ptr< vertex_property_type > >
template<typename T >
using	inverse_distance_weighting_sampler_type = detail::pointset::inverse_distance_weighting_sampler< Real, NumDimensions, T >
template<typename T >
using	natural_neighbor_coordinates_sampler_type = detail::pointset::natural_neighbor_coordinates_sampler< Real, NumDimensions, T >
template<typename T , typename Gradient >
using	natural_neighbor_coordinates_sampler_with_gradients_type = detail::pointset::natural_neighbor_coordinates_sampler_with_gradients< Real, NumDimensions, T, Gradient >

Public Member Functions
constexpr	mesh ()
constexpr	mesh (std::initializer_list< pos_type > &&vertices)
	mesh (const triangle::io &io)
	mesh (const mesh &other)
	mesh (mesh &&other)
auto &	operator= (const mesh &other)
auto &	operator= (mesh &&other)
constexpr auto &	at (face f)
constexpr const auto &	at (face f) const
constexpr auto &	operator[] (face f)
constexpr const auto &	operator[] (face f) const
constexpr auto	insert_face (same_as< vertex > auto const ... vs)
constexpr auto	insert_face (std::vector< vertex > new_face)
void	remove (vertex v)
void	remove (edge e, bool remove_orphaned_vertices=true)
constexpr void	remove (face f, bool remove_orphaned_vertices=true, bool remove_orphaned_edges=true)
void	triangulate_face (const std::vector< vertex > &polygon)
auto	triangulate_face (face f)
void	tidy_up ()
	tidies up invalid vertices, edges and faces More...
constexpr bool	is_valid (face f) const
constexpr auto	insert_edges (face f)
constexpr void	clear_faces ()
void	clear ()
constexpr auto	num_faces (vertex v) const
constexpr auto	num_faces (edge e) const
constexpr auto	num_faces () const
constexpr auto	num_edges (face f) const
constexpr auto	faces () const
auto &	faces (vertex v)
const auto &	faces (vertex v) const
auto &	faces (edge e)
const auto &	faces (edge e) const
auto &	edges (face f)
const auto &	edges (face f) const
auto &	vertices (face f)
const auto &	vertices (face f) const
auto	neighbor_faces (face f) const
constexpr bool	has_vertex (face f, vertex v) const
constexpr bool	face_has_edge (face f, edge e) const
constexpr auto	num_vertices (face f) const
auto	to_triangle_io () const
auto	to_triangle_io (const std::vector< vertex > &vertices) const
template<typename T >
auto &	face_property (const std::string &name)
template<typename T >
const auto &	face_property (std::string const &name) const
template<typename T >
auto &	add_face_property (const std::string &name, const T &value=T{})
void	write (const std::string &path)
void	write_obj (const std::string &path)
void	write_vtk (const std::string &path, const std::string &title="tatooine mesh") const
bool	are_neighbors (face f0, face f1)
	checks if two faces are neighbors More...
template<typename face_cont_t >
auto	adjacent_faces (const face_cont_t &faces)
template<typename face_cont_t >
auto	border_edges (const face_cont_t &faces) const
template<typename edge_cont_t >
auto	split_border_edges (const edge_cont_t &edges)
	searches coherent border edge loops More...
template<typename edge_cont_t >
auto	border_edges_to_vertices (const edge_cont_t &edges)
bool	polygon_is_counter_clockwise (const std::vector< vertex > &polygon)
template<typename face_cont_t >
auto	border_polygons (const face_cont_t &faces, bool check_counterclockwise=true)
Public Member Functions inherited from tatooine::edgeset< Real, N >
auto	insert_edge (vertex_handle const v0, vertex_handle const v1)
auto	edge_at (edge_handle const h)
auto	edge_at (edge_handle const h) const
auto	edges () const
auto	are_connected (vertex_handle const v0, vertex_handle const v1) const
Public Member Functions inherited from tatooine::unstructured_simplicial_grid< Real, NumDimensions, 1 >
auto	simplex_index_data () const -> auto const &
auto	invalid_simplices () const -> auto const &
auto	simplex_properties () const -> auto const &
constexpr	unstructured_simplicial_grid ()=default
	unstructured_simplicial_grid (unstructured_simplicial_grid const &other)
	unstructured_simplicial_grid (unstructured_simplicial_grid &&other) noexcept=default
	unstructured_simplicial_grid (std::filesystem::path const &path)
	unstructured_simplicial_grid (std::initializer_list< pos_type > &&vertices)
	unstructured_simplicial_grid (std::vector< vec< Real, NumDimensions > > const &positions)
	unstructured_simplicial_grid (std::vector< vec< Real, NumDimensions > > &&positions)
	unstructured_simplicial_grid (rectilinear_grid< DimX, DimY > const &g)
	unstructured_simplicial_grid (rectilinear_grid< DimX, DimY, DimZ > const &g)
auto	operator= (unstructured_simplicial_grid const &other) -> unstructured_simplicial_grid &
auto	operator= (unstructured_simplicial_grid &&other) noexcept -> unstructured_simplicial_grid &=default
auto	operator[] (simplex_handle t) const -> auto
auto	operator[] (simplex_handle t) -> auto
auto	at (simplex_handle t) const -> auto
auto	at (simplex_handle t) -> auto
auto	simplex_at (simplex_handle t) const -> auto
auto	simplex_at (simplex_handle t) -> auto
auto	simplex_at (std::size_t const i) const
auto	simplex_at (std::size_t const i)
auto	insert_vertex (arithmetic auto const ... comps)
auto	insert_vertex (pos_type const &v)
auto	insert_vertex (pos_type &&v)
auto	remove (vertex_handle const vh)
auto	remove (simplex_handle const ch)
auto	remove_duplicate_vertices (Real const eps=Real{})
auto	remove_duplicate_vertices (execution_policy::parallel_t, Real const eps=Real{})
auto	remove_duplicate_vertices (execution_policy::sequential_t, Real const eps=Real{})
auto	insert_simplex (Handles const ... handles)
auto	barycentric_coordinate (simplex_handle const &s, pos_type const &q) const
auto	tidy_up ()
auto	clear ()
auto	simplices () const
auto	clean_simplex_index_list () const
auto	contains (simplex_handle const ch, vertex_handle const vh) const
auto	build_delaunay_mesh ()
auto	build_delaunay_mesh (std::vector< std::pair< vertex_handle, vertex_handle > > const &constraints) -> void requires(NumDimensions==2)||(NumDimensions==3)
auto	build_sub_delaunay_mesh (std::vector< vertex_handle > const &vertices)
auto	simplex_property (std::string const &name) -> auto &
auto	simplex_property (std::string const &name) const -> const auto &
auto	scalar_simplex_property (std::string const &name) const -> auto const &
auto	scalar_simplex_property (std::string const &name) -> auto &
auto	vec2_simplex_property (std::string const &name) const -> auto const &
auto	vec2_simplex_property (std::string const &name) -> auto &
auto	vec3_simplex_property (std::string const &name) const -> auto const &
auto	vec3_simplex_property (std::string const &name) -> auto &
auto	vec4_simplex_property (std::string const &name) const -> auto const &
auto	vec4_simplex_property (std::string const &name) -> auto &
auto	mat2_simplex_property (std::string const &name) const -> auto const &
auto	mat2_simplex_property (std::string const &name) -> auto &
auto	mat3_simplex_property (std::string const &name) const -> auto const &
auto	mat3_simplex_property (std::string const &name) -> auto &
auto	mat4_simplex_property (std::string const &name) const -> auto const &
auto	mat4_simplex_property (std::string const &name) -> auto &
auto	insert_simplex_property (std::string const &name, T const &value=T{}) -> auto &
auto	write (filesystem::path const &path) const
auto	write_vtk (std::filesystem::path const &path, std::string const &title="tatooine grid") const
auto	write_vtp (filesystem::path const &path) const
auto	write_vtu (filesystem::path const &path) const
auto	write_vtp_edges (filesystem::path const &path) const
auto	write_vtp_triangles (filesystem::path const &path) const
auto	write_vtu_triangular (filesystem::path const &path) const
auto	write_vtu_tetrahedral (filesystem::path const &path) const
auto	write_unstructured_triangular_grid_vtk (std::filesystem::path const &path, std::string const &title) const -> bool requires(SimplexDim==2)
auto	write_unstructured_tetrahedral_grid_vtk (std::filesystem::path const &path, std::string const &title) const -> bool requires(SimplexDim==2)
auto	read (std::filesystem::path const &path)
auto	read_vtk (std::filesystem::path const &path)
constexpr auto	is_valid (simplex_handle t) const
auto	build_hierarchy () const
auto	clear_hierarchy () const
auto	hierarchy () const -> auto &
auto	sampler (typed_vertex_property_type< T > const &prop) const
auto	vertex_property_sampler (std::string const &name) const
auto	sample_to_vertex_property (F &&f, std::string const &name) -> auto &
auto	sample_to_vertex_property (F &&f, std::string const &name, execution_policy_tag auto tag) -> auto &
Public Member Functions inherited from tatooine::pointset< Real, NumDimensions >
	pointset ()=default
	~pointset ()=default
	pointset (std::initializer_list< pos_type > &&vertices)
	pointset (pointset const &other)
	pointset (pointset &&other) noexcept
	pointset (std::vector< pos_type > const &vertices)
	pointset (std::vector< pos_type > &&vertices)
	pointset (filesystem::path const &path)
auto	operator= (pointset const &other) -> pointset &
auto	operator= (pointset &&other) noexcept -> pointset &=default
auto	axis_aligned_bounding_box () const
auto	vertex_properties () const -> auto const &
auto	vertex_properties () -> auto &
auto	has_vertex_property (std::string const &name) const
auto	at (vertex_handle const v) -> auto &
auto	at (vertex_handle const v) const -> auto const &
auto	vertex_at (vertex_handle const v) -> auto &
auto	vertex_at (vertex_handle const v) const -> auto const &
auto	vertex_at (std::size_t const i) -> auto &
auto	vertex_at (std::size_t const i) const -> auto const &
auto	operator[] (vertex_handle const v) -> auto &
auto	operator[] (vertex_handle const v) const -> auto const &
auto	vertices () const
auto	vertices ()
auto	num_vertices () const
auto	num_vertex_properties () const
auto	vertex_position_data () const -> auto const &
auto	invalid_vertices () const -> auto const &
auto	tidy_up ()
	tidies up invalid vertices More...
auto	remove (vertex_handle const v)
constexpr auto	is_valid (vertex_handle const v) const -> bool
auto	clear_vertices ()
auto	clear ()
template<invocable< pos_type > F>
auto	sample_to_vertex_property (F &&f, std::string const &name) -> auto &
template<invocable< pos_type > F>
auto	sample_to_vertex_property (F &&f, std::string const &name, execution_policy::sequential_t) -> auto &
template<invocable< pos_type > F>
auto	sample_to_vertex_property (F &&f, std::string const &name, execution_policy::parallel_t) -> auto &
auto	join (this_type const &other)
auto	find_duplicates (Real eps=1e-6)
template<typename T >
auto	radial_basis_functions_sampler_with_linear_kernel (typed_vertex_property_type< T > const &prop) const
	Constructs a radial basis functions interpolator. More...
template<typename T >
auto	radial_basis_functions_sampler_with_cubic_kernel (typed_vertex_property_type< T > const &prop) const
	Constructs a radial basis functions interpolator. More...
template<typename T >
auto	radial_basis_functions_sampler_with_gaussian_kernel (typed_vertex_property_type< T > const &prop, Real const epsilon) const
	Constructs a radial basis functions interpolator. More...
template<typename T >
auto	radial_basis_functions_sampler_with_thin_plate_spline_kernel (typed_vertex_property_type< T > const &prop) const
	Constructs a radial basis functions interpolator. More...
template<typename T >
auto	radial_basis_functions_sampler (typed_vertex_property_type< T > const &prop, invocable< Real > auto &&f) const
	Constructs a radial basis functions interpolator. More...
template<typename T >
auto	radial_basis_functions_sampler (typed_vertex_property_type< T > const &prop) const
	Constructs a radial basis functions interpolator with thin plate spline kernel. More...
template<typename ValueType , typename GradientType >
auto	radial_basis_functions_sampler (typed_vertex_property_type< ValueType > const &values, typed_vertex_property_type< GradientType > const &gradients) const
	Constructs a radial basis functions interpolator that also takes the gradients of the property. More...
auto	insert_vertex (arithmetic auto const ... ts)
auto	insert_vertex (pos_type const &v)
auto	insert_vertex (pos_type &&v)
template<typename T >
auto	vertex_property (std::string const &name) -> auto &
	using specified vertices of point_set More...
template<typename T >
auto	vertex_property (std::string const &name) const -> const auto &
auto	scalar_vertex_property (std::string const &name) const -> auto const &
auto	scalar_vertex_property (std::string const &name) -> auto &
auto	vec2_vertex_property (std::string const &name) const -> auto const &
auto	vec2_vertex_property (std::string const &name) -> auto &
auto	vec3_vertex_property (std::string const &name) const -> auto const &
auto	vec3_vertex_property (std::string const &name) -> auto &
auto	vec4_vertex_property (std::string const &name) const -> auto const &
auto	vec4_vertex_property (std::string const &name) -> auto &
auto	mat2_vertex_property (std::string const &name) const -> auto const &
auto	mat2_vertex_property (std::string const &name) -> auto &
auto	mat3_vertex_property (std::string const &name) const -> auto const &
auto	mat3_vertex_property (std::string const &name) -> auto &
auto	mat4_vertex_property (std::string const &name) const -> auto const &
auto	mat4_vertex_property (std::string const &name) -> auto &
template<typename T >
auto	insert_vertex_property (std::string const &name, T const &value=T{}) -> auto &
auto	insert_scalar_vertex_property (std::string const &name, tatooine::real_number const value=tatooine::real_number{}) -> auto &
auto	insert_vec2_vertex_property (std::string const &name, tatooine::vec2 const value=tatooine::vec2{}) -> auto &
auto	insert_vec3_vertex_property (std::string const &name, tatooine::vec3 const value=tatooine::vec3{}) -> auto &
auto	insert_vec4_vertex_property (std::string const &name, tatooine::vec4 const value=tatooine::vec4{}) -> auto &
auto	insert_mat2_vertex_property (std::string const &name, tatooine::mat2 const value=tatooine::mat2{}) -> auto &
auto	insert_mat3_vertex_property (std::string const &name, tatooine::mat3 const value=tatooine::mat3{}) -> auto &
auto	insert_mat4_vertex_property (std::string const &name, tatooine::mat4 const value=tatooine::mat4{}) -> auto &
auto	read (filesystem::path const &p)
auto	read_vtp (filesystem::path const &path) -> void requires(NumDimensions==2)||(NumDimensions==3)
template<typename T >
auto	inverse_distance_weighting_sampler (typed_vertex_property_type< T > const &prop, Real const radius=1) const
template<typename T > requires (NumDimensions == 3 || NumDimensions == 2)
auto	moving_least_squares_sampler (typed_vertex_property_type< T > const &prop, Real const radius, invocable< real_type > auto &&weighting) const
	Moving Least Squares Sampler. More...
template<typename T > requires (NumDimensions == 3 || NumDimensions == 2)
auto	moving_least_squares_sampler (typed_vertex_property_type< T > const &prop, Real const radius) const
	Moving Least Squares Sampler. More...
template<typename T >
auto	natural_neighbor_coordinates_sampler (typed_vertex_property_type< T > const &prop) const
template<typename T , typename Gradient >
auto	natural_neighbor_coordinates_sampler_with_gradients (typed_vertex_property_type< T > const &prop, typed_vertex_property_type< Gradient > const &gradients) const
auto	write (filesystem::path const &path) const
auto	write_vtk (filesystem::path const &path, std::string const &title="Tatooine pointset") const -> void requires(NumDimensions==3||NumDimensions==2)
auto	write_vtp (filesystem::path const &path) const
auto	rebuild_kd_tree ()
auto	build_kd_tree_index ()
auto	invalidate_kd_tree () const
auto	nearest_neighbor (pos_type const &x) const
auto	nearest_neighbors_raw (pos_type const &x, std::size_t const num_nearest_neighbors, flann::SearchParams const params={}) const
auto	nearest_neighbors (pos_type const &x, std::size_t const num_nearest_neighbors) const
auto	nearest_neighbors_radius_raw (pos_type const &x, Real const radius, flann::SearchParams const params={}) const -> std::pair< std::vector< int >, std::vector< Real > >
auto	nearest_neighbors_radius (pos_type const &x, Real const radius) const

Static Public Member Functions
static bool	is_left (const pos_type &a, const pos_type &b, const pos_type &c)
Static Public Member Functions inherited from tatooine::unstructured_simplicial_grid< Real, NumDimensions, 1 >
static constexpr auto	num_vertices_per_simplex ()
static constexpr auto	simplex_dimension ()
Static Public Member Functions inherited from tatooine::pointset< Real, NumDimensions >
static constexpr auto	num_dimensions () -> std::size_t

Protected Attributes
std::vector< std::vector< vertex > >	m_faces
std::vector< face >	m_invalid_faces
std::map< std::string, std::unique_ptr< property > >	m_face_properties
vertex_prop< std::vector< face > > *	m_faces_of_vertices = nullptr
edge_prop< std::vector< face > > *	m_faces_of_edges = nullptr
face_prop< std::vector< edge > > *	m_edges_of_faces = nullptr
Protected Attributes inherited from tatooine::pointset< Real, NumDimensions >
std::vector< pos_type >	m_vertex_position_data

Private Member Functions
void	add_link_properties ()
void	find_link_properties ()

Member Typedef Documentation

edge_prop

template<typename Real , size_t N>

template<typename T >

using tatooine::mesh< Real, N >::edge_prop = typename parent_type::template edge_prop<T>

parent_type

template<typename Real , size_t N>

using tatooine::mesh< Real, N >::parent_type = edgeset<Real, N>

this_type

template<typename Real , size_t N>

using tatooine::mesh< Real, N >::this_type = mesh<Real, N>

vertex_prop

template<typename Real , size_t N>

template<typename T >

using tatooine::mesh< Real, N >::vertex_prop = typename parent_type::template vertex_prop<T>

Constructor & Destructor Documentation

mesh() [1/5]

template<typename Real , size_t N>

constexpr tatooine::mesh< Real, N >::mesh ( )

inlineconstexpr

mesh() [2/5]

template<typename Real , size_t N>

constexpr tatooine::mesh< Real, N >::mesh ( std::initializer_list< pos_type > &&  vertices )

inlineconstexpr

mesh() [3/5]

template<typename Real , size_t N>

tatooine::mesh< Real, N >::mesh ( const triangle::io &  io )

inline

mesh() [4/5]

template<typename Real , size_t N>

tatooine::mesh< Real, N >::mesh ( const mesh< Real, N > &  other )

inline

mesh() [5/5]

template<typename Real , size_t N>

tatooine::mesh< Real, N >::mesh ( mesh< Real, N > &&  other )

inline

Member Function Documentation

add_face_property()

template<typename Real , size_t N>

template<typename T >

auto & tatooine::mesh< Real, N >::add_face_property ( const std::string &  name, const T &  value = T{}  )

inline

add_link_properties()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::add_link_properties ( )

inlineprivate

adjacent_faces()

template<typename Real , size_t N>

template<typename face_cont_t >

auto tatooine::mesh< Real, N >::adjacent_faces ( const face_cont_t &  faces )

inline

are_neighbors()

template<typename Real , size_t N>

bool tatooine::mesh< Real, N >::are_neighbors ( face  f0, face  f1  )

inline

checks if two faces are neighbors

at() [1/2]

template<typename Real , size_t N>

constexpr auto & tatooine::mesh< Real, N >::at ( face  f )

inlineconstexpr

at() [2/2]

template<typename Real , size_t N>

constexpr const auto & tatooine::mesh< Real, N >::at ( face  f ) const

inlineconstexpr

border_edges()

template<typename Real , size_t N>

template<typename face_cont_t >

auto tatooine::mesh< Real, N >::border_edges ( const face_cont_t &  faces ) const

inline

returns list of edges representing borders of list of faces. there might be more than one coherent border edge loop. use split_border_edges() for splitting coherent loops

border_edges_to_vertices()

template<typename Real , size_t N>

template<typename edge_cont_t >

auto tatooine::mesh< Real, N >::border_edges_to_vertices ( const edge_cont_t &  edges )

inline

converts list of border edges to ordered list of vertices. returned polygon has arbitrary rotation (clock-wise or counter-clockwise). if edges is no actual loop this function never returns.

border_polygons()

template<typename Real , size_t N>

template<typename face_cont_t >

auto tatooine::mesh< Real, N >::border_polygons ( const face_cont_t &  faces, bool  check_counterclockwise = true  )

inline

clear()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::clear ( )

inline

clear_faces()

template<typename Real , size_t N>

constexpr void tatooine::mesh< Real, N >::clear_faces ( )

inlineconstexpr

edges() [1/2]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::edges ( face  f )

inline

edges() [2/2]

template<typename Real , size_t N>

const auto & tatooine::mesh< Real, N >::edges ( face  f ) const

inline

face_has_edge()

template<typename Real , size_t N>

constexpr bool tatooine::mesh< Real, N >::face_has_edge ( face  f, edge  e  ) const

inlineconstexpr

face_property() [1/2]

template<typename Real , size_t N>

template<typename T >

auto & tatooine::mesh< Real, N >::face_property ( const std::string &  name )

inline

face_property() [2/2]

template<typename Real , size_t N>

template<typename T >

const auto & tatooine::mesh< Real, N >::face_property ( std::string const &  name ) const

inline

faces() [1/5]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::faces ( ) const

inlineconstexpr

faces() [2/5]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::faces ( edge  e )

inline

faces() [3/5]

template<typename Real , size_t N>

const auto & tatooine::mesh< Real, N >::faces ( edge  e ) const

inline

faces() [4/5]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::faces ( vertex  v )

inline

faces() [5/5]

template<typename Real , size_t N>

const auto & tatooine::mesh< Real, N >::faces ( vertex  v ) const

inline

find_link_properties()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::find_link_properties ( )

inlineprivate

has_vertex()

template<typename Real , size_t N>

constexpr bool tatooine::mesh< Real, N >::has_vertex ( face  f, vertex  v  ) const

inlineconstexpr

insert_edges()

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::insert_edges ( face  f )

inlineconstexpr

insert_face() [1/2]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::insert_face ( same_as< vertex > auto const ...  vs )

inlineconstexpr

insert_face() [2/2]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::insert_face ( std::vector< vertex >  new_face )

inlineconstexpr

is_left()

template<typename Real , size_t N>

static bool tatooine::mesh< Real, N >::is_left ( const pos_type &  a, const pos_type &  b, const pos_type &  c  )

inlinestatic

is_valid()

template<typename Real , size_t N>

constexpr bool tatooine::mesh< Real, N >::is_valid ( face  f ) const

inlineconstexpr

neighbor_faces()

template<typename Real , size_t N>

auto tatooine::mesh< Real, N >::neighbor_faces ( face  f ) const

inline

num_edges()

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::num_edges ( face  f ) const

inlineconstexpr

num_faces() [1/3]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::num_faces ( ) const

inlineconstexpr

num_faces() [2/3]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::num_faces ( edge  e ) const

inlineconstexpr

num_faces() [3/3]

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::num_faces ( vertex  v ) const

inlineconstexpr

num_vertices()

template<typename Real , size_t N>

constexpr auto tatooine::mesh< Real, N >::num_vertices ( face  f ) const

inlineconstexpr

operator=() [1/2]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::operator= ( const mesh< Real, N > &  other )

inline

operator=() [2/2]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::operator= ( mesh< Real, N > &&  other )

inline

operator[]() [1/2]

template<typename Real , size_t N>

constexpr auto & tatooine::mesh< Real, N >::operator[] ( face  f )

inlineconstexpr

operator[]() [2/2]

template<typename Real , size_t N>

constexpr const auto & tatooine::mesh< Real, N >::operator[] ( face  f ) const

inlineconstexpr

polygon_is_counter_clockwise()

template<typename Real , size_t N>

bool tatooine::mesh< Real, N >::polygon_is_counter_clockwise ( const std::vector< vertex > &  polygon )

inline

remove() [1/3]

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::remove ( edge  e, bool  remove_orphaned_vertices = true  )

inline

remove() [2/3]

template<typename Real , size_t N>

constexpr void tatooine::mesh< Real, N >::remove ( face  f, bool  remove_orphaned_vertices = true, bool  remove_orphaned_edges = true  )

inlineconstexpr

remove() [3/3]

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::remove ( vertex  v )

inline

split_border_edges()

template<typename Real , size_t N>

template<typename edge_cont_t >

auto tatooine::mesh< Real, N >::split_border_edges ( const edge_cont_t &  edges )

inline

searches coherent border edge loops

tidy_up()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::tidy_up ( )

inline

tidies up invalid vertices, edges and faces

to_triangle_io() [1/2]

template<typename Real , size_t N>

auto tatooine::mesh< Real, N >::to_triangle_io ( ) const

inline

to_triangle_io() [2/2]

template<typename Real , size_t N>

auto tatooine::mesh< Real, N >::to_triangle_io ( const std::vector< vertex > &  vertices ) const

inline

using specified vertices of mesh. automatically searches for faces using of of the vertices

triangulate_face() [1/2]

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::triangulate_face ( const std::vector< vertex > &  polygon )

inline

triangulate_face() [2/2]

template<typename Real , size_t N>

auto tatooine::mesh< Real, N >::triangulate_face ( face  f )

inline

vertices() [1/2]

template<typename Real , size_t N>

auto & tatooine::mesh< Real, N >::vertices ( face  f )

inline

vertices() [2/2]

template<typename Real , size_t N>

const auto & tatooine::mesh< Real, N >::vertices ( face  f ) const

inline

write()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::write ( const std::string &  path )

inline

write_obj()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::write_obj ( const std::string &  path )

inline

write_vtk()

template<typename Real , size_t N>

void tatooine::mesh< Real, N >::write_vtk ( const std::string &  path, const std::string &  title = "tatooine mesh< Real, N >"  ) const

inline

Member Data Documentation

m_edges_of_faces

template<typename Real , size_t N>

face_prop<std::vector<edge> >* tatooine::mesh< Real, N >::m_edges_of_faces = nullptr

protected

m_face_properties

template<typename Real , size_t N>

std::map<std::string, std::unique_ptr<property> > tatooine::mesh< Real, N >::m_face_properties

protected

m_faces

template<typename Real , size_t N>

std::vector<std::vector<vertex> > tatooine::mesh< Real, N >::m_faces

protected

m_faces_of_edges

template<typename Real , size_t N>

edge_prop<std::vector<face> >* tatooine::mesh< Real, N >::m_faces_of_edges = nullptr

protected

m_faces_of_vertices

template<typename Real , size_t N>

vertex_prop<std::vector<face> >* tatooine::mesh< Real, N >::m_faces_of_vertices = nullptr

protected

m_invalid_faces

template<typename Real , size_t N>

std::vector<face> tatooine::mesh< Real, N >::m_invalid_faces

protected

---

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

• /mnt/data/home/ci/builds/Bicifxyn/0/libs/tatooine2/include/tatooine/mesh.h