OpenMesh
OpenMesh::BaseKernel Class Reference

This class provides low-level property management like adding/removing properties and access to properties. More...

#include <OpenMesh/Core/Mesh/BaseKernel.hh>

Inheritance diagram for OpenMesh::BaseKernel:

Public Types

typedef PropertyContainer::iterator prop_iterator
 
typedef PropertyContainer::const_iterator const_prop_iterator
 

Public Member Functions

template<class T >
void copy_property (VPropHandleT< T > &_ph, VertexHandle _vh_from, VertexHandle _vh_to)
 You should not use this function directly. More...
 
template<class T >
void copy_property (HPropHandleT< T > _ph, HalfedgeHandle _hh_from, HalfedgeHandle _hh_to)
 You should not use this function directly. More...
 
template<class T >
void copy_property (EPropHandleT< T > _ph, EdgeHandle _eh_from, EdgeHandle _eh_to)
 You should not use this function directly. More...
 
template<class T >
void copy_property (FPropHandleT< T > _ph, FaceHandle _fh_from, FaceHandle _fh_to)
 You should not use this function directly. More...
 
void copy_all_properties (VertexHandle _vh_from, VertexHandle _vh_to, bool _copyBuildIn=false)
 Copies all properties from one mesh element to another (of the same type) More...
 
void copy_all_properties (HalfedgeHandle _hh_from, HalfedgeHandle _hh_to, bool _copyBuildIn=false)
 Copies all properties from one mesh element to another (of the same type) More...
 
void copy_all_properties (EdgeHandle _eh_from, EdgeHandle _eh_to, bool _copyBuildIn=false)
 Copies all properties from one mesh element to another (of the same type) More...
 
void copy_all_properties (FaceHandle _fh_from, FaceHandle _fh_to, bool _copyBuildIn=false)
 Copies all properties from one mesh element to another (of the same type) More...
 
void copy_all_kernel_properties (const BaseKernel &_other)
 copy_all_kernel_properties uses the = operator to copy all properties from a given other BaseKernel. More...
 
size_t n_vprops (void) const
 
size_t n_eprops (void) const
 
size_t n_hprops (void) const
 
size_t n_fprops (void) const
 
size_t n_mprops (void) const
 
BaseProperty_get_vprop (const std::string &_name)
 
BaseProperty_get_eprop (const std::string &_name)
 
BaseProperty_get_hprop (const std::string &_name)
 
BaseProperty_get_fprop (const std::string &_name)
 
BaseProperty_get_mprop (const std::string &_name)
 
const BaseProperty_get_vprop (const std::string &_name) const
 
const BaseProperty_get_eprop (const std::string &_name) const
 
const BaseProperty_get_hprop (const std::string &_name) const
 
const BaseProperty_get_fprop (const std::string &_name) const
 
const BaseProperty_get_mprop (const std::string &_name) const
 
BaseProperty_vprop (size_t _idx)
 
BaseProperty_eprop (size_t _idx)
 
BaseProperty_hprop (size_t _idx)
 
BaseProperty_fprop (size_t _idx)
 
BaseProperty_mprop (size_t _idx)
 
const BaseProperty_vprop (size_t _idx) const
 
const BaseProperty_eprop (size_t _idx) const
 
const BaseProperty_hprop (size_t _idx) const
 
const BaseProperty_fprop (size_t _idx) const
 
const BaseProperty_mprop (size_t _idx) const
 
size_t _add_vprop (BaseProperty *_bp)
 
size_t _add_eprop (BaseProperty *_bp)
 
size_t _add_hprop (BaseProperty *_bp)
 
size_t _add_fprop (BaseProperty *_bp)
 
size_t _add_mprop (BaseProperty *_bp)
 
virtual size_t n_vertices () const
 
virtual size_t n_halfedges () const
 
virtual size_t n_edges () const
 
virtual size_t n_faces () const
 
template<typename HandleT >
size_t n_elements () const
 
void property_stats () const
 
void property_stats (std::ostream &_ostr) const
 
void vprop_stats (std::string &_string) const
 
void hprop_stats (std::string &_string) const
 
void eprop_stats (std::string &_string) const
 
void fprop_stats (std::string &_string) const
 
void mprop_stats (std::string &_string) const
 
void vprop_stats () const
 
void hprop_stats () const
 
void eprop_stats () const
 
void fprop_stats () const
 
void mprop_stats () const
 
void vprop_stats (std::ostream &_ostr) const
 
void hprop_stats (std::ostream &_ostr) const
 
void eprop_stats (std::ostream &_ostr) const
 
void fprop_stats (std::ostream &_ostr) const
 
void mprop_stats (std::ostream &_ostr) const
 
prop_iterator vprops_begin ()
 
prop_iterator vprops_end ()
 
const_prop_iterator vprops_begin () const
 
const_prop_iterator vprops_end () const
 
prop_iterator eprops_begin ()
 
prop_iterator eprops_end ()
 
const_prop_iterator eprops_begin () const
 
const_prop_iterator eprops_end () const
 
prop_iterator hprops_begin ()
 
prop_iterator hprops_end ()
 
const_prop_iterator hprops_begin () const
 
const_prop_iterator hprops_end () const
 
prop_iterator fprops_begin ()
 
prop_iterator fprops_end ()
 
const_prop_iterator fprops_begin () const
 
const_prop_iterator fprops_end () const
 
prop_iterator mprops_begin ()
 
prop_iterator mprops_end ()
 
const_prop_iterator mprops_begin () const
 
const_prop_iterator mprops_end () const
 
template<>
size_t n_elements () const
 
template<>
size_t n_elements () const
 
template<>
size_t n_elements () const
 
template<>
size_t n_elements () const
 
Add a property to a mesh item
template<class T >
void add_property (VPropHandleT< T > &_ph, const std::string &_name="<vprop>")
 You should not use this function directly. More...
 
template<class T >
void add_property (HPropHandleT< T > &_ph, const std::string &_name="<hprop>")
 You should not use this function directly. More...
 
template<class T >
void add_property (EPropHandleT< T > &_ph, const std::string &_name="<eprop>")
 You should not use this function directly. More...
 
template<class T >
void add_property (FPropHandleT< T > &_ph, const std::string &_name="<fprop>")
 You should not use this function directly. More...
 
template<class T >
void add_property (MPropHandleT< T > &_ph, const std::string &_name="<mprop>")
 You should not use this function directly. More...
 
Removing a property from a mesh tiem
template<typename T >
void remove_property (VPropHandleT< T > &_ph)
 You should not use this function directly. More...
 
template<typename T >
void remove_property (HPropHandleT< T > &_ph)
 You should not use this function directly. More...
 
template<typename T >
void remove_property (EPropHandleT< T > &_ph)
 You should not use this function directly. More...
 
template<typename T >
void remove_property (FPropHandleT< T > &_ph)
 You should not use this function directly. More...
 
template<typename T >
void remove_property (MPropHandleT< T > &_ph)
 You should not use this function directly. More...
 
Get property handle by name
template<class T >
bool get_property_handle (VPropHandleT< T > &_ph, const std::string &_name) const
 You should not use this function directly. More...
 
template<class T >
bool get_property_handle (HPropHandleT< T > &_ph, const std::string &_name) const
 You should not use this function directly. More...
 
template<class T >
bool get_property_handle (EPropHandleT< T > &_ph, const std::string &_name) const
 You should not use this function directly. More...
 
template<class T >
bool get_property_handle (FPropHandleT< T > &_ph, const std::string &_name) const
 You should not use this function directly. More...
 
template<class T >
bool get_property_handle (MPropHandleT< T > &_ph, const std::string &_name) const
 You should not use this function directly. More...
 
Access a property
template<class T >
PropertyT< T > & property (VPropHandleT< T > _ph)
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
const PropertyT< T > & property (VPropHandleT< T > _ph) const
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
PropertyT< T > & property (HPropHandleT< T > _ph)
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
const PropertyT< T > & property (HPropHandleT< T > _ph) const
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
PropertyT< T > & property (EPropHandleT< T > _ph)
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
const PropertyT< T > & property (EPropHandleT< T > _ph) const
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
PropertyT< T > & property (FPropHandleT< T > _ph)
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
const PropertyT< T > & property (FPropHandleT< T > _ph) const
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
PropertyT< T > & mproperty (MPropHandleT< T > _ph)
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
template<class T >
const PropertyT< T > & mproperty (MPropHandleT< T > _ph) const
 In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary. More...
 
Access a property element using a handle to a mesh item
template<class T >
VPropHandleT< T >::reference property (VPropHandleT< T > _ph, VertexHandle _vh)
 You should not use this function directly. More...
 
template<class T >
VPropHandleT< T >::const_reference property (VPropHandleT< T > _ph, VertexHandle _vh) const
 You should not use this function directly. More...
 
template<class T >
HPropHandleT< T >::reference property (HPropHandleT< T > _ph, HalfedgeHandle _hh)
 You should not use this function directly. More...
 
template<class T >
HPropHandleT< T >::const_reference property (HPropHandleT< T > _ph, HalfedgeHandle _hh) const
 You should not use this function directly. More...
 
template<class T >
EPropHandleT< T >::reference property (EPropHandleT< T > _ph, EdgeHandle _eh)
 You should not use this function directly. More...
 
template<class T >
EPropHandleT< T >::const_reference property (EPropHandleT< T > _ph, EdgeHandle _eh) const
 You should not use this function directly. More...
 
template<class T >
FPropHandleT< T >::reference property (FPropHandleT< T > _ph, FaceHandle _fh)
 You should not use this function directly. More...
 
template<class T >
FPropHandleT< T >::const_reference property (FPropHandleT< T > _ph, FaceHandle _fh) const
 You should not use this function directly. More...
 
template<class T >
MPropHandleT< T >::reference property (MPropHandleT< T > _ph)
 You should not use this function directly. More...
 
template<class T >
MPropHandleT< T >::const_reference property (MPropHandleT< T > _ph) const
 You should not use this function directly. More...
 

Protected Member Functions

BaseProperty_vprop (BaseHandle _h)
 
BaseProperty_eprop (BaseHandle _h)
 
BaseProperty_hprop (BaseHandle _h)
 
BaseProperty_fprop (BaseHandle _h)
 
BaseProperty_mprop (BaseHandle _h)
 
const BaseProperty_vprop (BaseHandle _h) const
 
const BaseProperty_eprop (BaseHandle _h) const
 
const BaseProperty_hprop (BaseHandle _h) const
 
const BaseProperty_fprop (BaseHandle _h) const
 
const BaseProperty_mprop (BaseHandle _h) const
 
void vprops_reserve (size_t _n) const
 Reserves space for _n elements in all vertex property vectors.
 
void vprops_resize (size_t _n) const
 Resizes all vertex property vectors to the specified size.
 
void vprops_resize_if_smaller (size_t _n) const
 Same as vprops_resize() but ignores vertex property vectors that have a size larger than _n. More...
 
void vprops_clear ()
 
void vprops_swap (unsigned int _i0, unsigned int _i1) const
 
void hprops_reserve (size_t _n) const
 
void hprops_resize (size_t _n) const
 
void hprops_clear ()
 
void hprops_swap (unsigned int _i0, unsigned int _i1) const
 
void eprops_reserve (size_t _n) const
 
void eprops_resize (size_t _n) const
 
void eprops_clear ()
 
void eprops_swap (unsigned int _i0, unsigned int _i1) const
 
void fprops_reserve (size_t _n) const
 
void fprops_resize (size_t _n) const
 
void fprops_clear ()
 
void fprops_swap (unsigned int _i0, unsigned int _i1) const
 
void mprops_resize (size_t _n) const
 
void mprops_clear ()
 

Detailed Description

This class provides low-level property management like adding/removing properties and access to properties.

Under most circumstances, it is advisable to use the high-level property management provided by PropertyManager, instead.

All operations provided by BaseKernel need at least a property handle (VPropHandleT, EPropHandleT, HPropHandleT, FPropHandleT, MPropHandleT). which keeps the data type of the property, too.

There are two types of properties:

  1. Standard properties - mesh data (e.g. vertex normal or face color)
  2. Custom properties - user defined data

The differentiation is only semantically, technically both are equally handled. Therefore the methods provided by the BaseKernel are applicable to both property types.

Attention
Since the class PolyMeshT derives from a kernel, hence all public elements of BaseKernel are usable.

Member Function Documentation

◆ add_property() [1/5]

template<class T >
void OpenMesh::BaseKernel::add_property ( VPropHandleT< T > &  _ph,
const std::string &  _name = "<vprop>" 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper and/or one of its helper functions such as makePropertyManagerFromNew, makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Adds a property

Depending on the property handle type a vertex, (half-)edge, face or mesh property is added to the mesh. If the action fails the handle is invalid. On success the handle must be used to access the property data with property().

Parameters
_phA property handle defining the data type to bind to mesh. On success the handle is valid else invalid.
_nameOptional name of property. Following restrictions apply to the name:
  1. Maximum length of name is 256 characters
  2. The prefixes matching "^[vhefm]:" are reserved for internal usage.
  3. The expression "^<.*>$" is reserved for internal usage.

◆ add_property() [2/5]

template<class T >
void OpenMesh::BaseKernel::add_property ( HPropHandleT< T > &  _ph,
const std::string &  _name = "<hprop>" 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper and/or one of its helper functions such as makePropertyManagerFromNew, makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Adds a property

Depending on the property handle type a vertex, (half-)edge, face or mesh property is added to the mesh. If the action fails the handle is invalid. On success the handle must be used to access the property data with property().

Parameters
_phA property handle defining the data type to bind to mesh. On success the handle is valid else invalid.
_nameOptional name of property. Following restrictions apply to the name:
  1. Maximum length of name is 256 characters
  2. The prefixes matching "^[vhefm]:" are reserved for internal usage.
  3. The expression "^<.*>$" is reserved for internal usage.

◆ add_property() [3/5]

template<class T >
void OpenMesh::BaseKernel::add_property ( EPropHandleT< T > &  _ph,
const std::string &  _name = "<eprop>" 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper and/or one of its helper functions such as makePropertyManagerFromNew, makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Adds a property

Depending on the property handle type a vertex, (half-)edge, face or mesh property is added to the mesh. If the action fails the handle is invalid. On success the handle must be used to access the property data with property().

Parameters
_phA property handle defining the data type to bind to mesh. On success the handle is valid else invalid.
_nameOptional name of property. Following restrictions apply to the name:
  1. Maximum length of name is 256 characters
  2. The prefixes matching "^[vhefm]:" are reserved for internal usage.
  3. The expression "^<.*>$" is reserved for internal usage.

◆ add_property() [4/5]

template<class T >
void OpenMesh::BaseKernel::add_property ( FPropHandleT< T > &  _ph,
const std::string &  _name = "<fprop>" 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper and/or one of its helper functions such as makePropertyManagerFromNew, makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Adds a property

Depending on the property handle type a vertex, (half-)edge, face or mesh property is added to the mesh. If the action fails the handle is invalid. On success the handle must be used to access the property data with property().

Parameters
_phA property handle defining the data type to bind to mesh. On success the handle is valid else invalid.
_nameOptional name of property. Following restrictions apply to the name:
  1. Maximum length of name is 256 characters
  2. The prefixes matching "^[vhefm]:" are reserved for internal usage.
  3. The expression "^<.*>$" is reserved for internal usage.

◆ add_property() [5/5]

template<class T >
void OpenMesh::BaseKernel::add_property ( MPropHandleT< T > &  _ph,
const std::string &  _name = "<mprop>" 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper and/or one of its helper functions such as makePropertyManagerFromNew, makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Adds a property

Depending on the property handle type a vertex, (half-)edge, face or mesh property is added to the mesh. If the action fails the handle is invalid. On success the handle must be used to access the property data with property().

Parameters
_phA property handle defining the data type to bind to mesh. On success the handle is valid else invalid.
_nameOptional name of property. Following restrictions apply to the name:
  1. Maximum length of name is 256 characters
  2. The prefixes matching "^[vhefm]:" are reserved for internal usage.
  3. The expression "^<.*>$" is reserved for internal usage.

◆ copy_all_kernel_properties()

void OpenMesh::BaseKernel::copy_all_kernel_properties ( const BaseKernel _other)
inline

copy_all_kernel_properties uses the = operator to copy all properties from a given other BaseKernel.

Parameters
_otherAnother BaseKernel, to copy the properties from.

◆ copy_all_properties() [1/4]

void OpenMesh::BaseKernel::copy_all_properties ( VertexHandle  _vh_from,
VertexHandle  _vh_to,
bool  _copyBuildIn = false 
)
inline

Copies all properties from one mesh element to another (of the same type)

Parameters
_vh_fromA vertex handle - source
_vh_toA vertex handle - target
_copyBuildInShould the internal properties (position, normal, texture coordinate,..) be copied?

◆ copy_all_properties() [2/4]

void OpenMesh::BaseKernel::copy_all_properties ( HalfedgeHandle  _hh_from,
HalfedgeHandle  _hh_to,
bool  _copyBuildIn = false 
)
inline

Copies all properties from one mesh element to another (of the same type)

Parameters
_hh_fromA halfedge handle - source
_hh_toA halfedge handle - target
_copyBuildInShould the internal properties (position, normal, texture coordinate,..) be copied?

◆ copy_all_properties() [3/4]

void OpenMesh::BaseKernel::copy_all_properties ( EdgeHandle  _eh_from,
EdgeHandle  _eh_to,
bool  _copyBuildIn = false 
)
inline

Copies all properties from one mesh element to another (of the same type)

Parameters
_eh_fromAn edge handle - source
_eh_toAn edge handle - target
_copyBuildInShould the internal properties (position, normal, texture coordinate,..) be copied?

◆ copy_all_properties() [4/4]

void OpenMesh::BaseKernel::copy_all_properties ( FaceHandle  _fh_from,
FaceHandle  _fh_to,
bool  _copyBuildIn = false 
)
inline

Copies all properties from one mesh element to another (of the same type)

Parameters
_fh_fromA face handle - source
_fh_toA face handle - target
_copyBuildInShould the internal properties (position, normal, texture coordinate,..) be copied?

◆ copy_property() [1/4]

template<class T >
void OpenMesh::BaseKernel::copy_property ( VPropHandleT< T > &  _ph,
VertexHandle  _vh_from,
VertexHandle  _vh_to 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::copy_to or PropertyManager::copy).

Copies a single property from one mesh element to another (of the same type)

Parameters
_phA vertex property handle
_vh_fromFrom vertex handle
_vh_toTo vertex handle

◆ copy_property() [2/4]

template<class T >
void OpenMesh::BaseKernel::copy_property ( HPropHandleT< T >  _ph,
HalfedgeHandle  _hh_from,
HalfedgeHandle  _hh_to 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::copy_to or PropertyManager::copy).

Copies a single property from one mesh element to another (of the same type)

Parameters
_phA halfedge property handle
_hh_fromFrom halfedge handle
_hh_toTo halfedge handle

◆ copy_property() [3/4]

template<class T >
void OpenMesh::BaseKernel::copy_property ( EPropHandleT< T >  _ph,
EdgeHandle  _eh_from,
EdgeHandle  _eh_to 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::copy_to or PropertyManager::copy).

Copies a single property from one mesh element to another (of the same type)

Parameters
_phAn edge property handle
_eh_fromFrom edge handle
_eh_toTo edge handle

◆ copy_property() [4/4]

template<class T >
void OpenMesh::BaseKernel::copy_property ( FPropHandleT< T >  _ph,
FaceHandle  _fh_from,
FaceHandle  _fh_to 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::copy_to or PropertyManager::copy).

Copies a single property from one mesh element to another (of the same type)

Parameters
_phA face property handle
_fh_fromFrom face handle
_fh_toTo face handle

◆ get_property_handle() [1/5]

template<class T >
bool OpenMesh::BaseKernel::get_property_handle ( VPropHandleT< T > &  _ph,
const std::string &  _name 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::propertyExists) or one of its higher level helper functions such as makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Retrieves the handle to a named property by it's name.

Parameters
_phA property handle. On success the handle is valid else invalid.
_nameName of wanted property.
Returns
true if such a named property is available, else false.

◆ get_property_handle() [2/5]

template<class T >
bool OpenMesh::BaseKernel::get_property_handle ( HPropHandleT< T > &  _ph,
const std::string &  _name 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::propertyExists) or one of its higher level helper functions such as makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Retrieves the handle to a named property by it's name.

Parameters
_phA property handle. On success the handle is valid else invalid.
_nameName of wanted property.
Returns
true if such a named property is available, else false.

◆ get_property_handle() [3/5]

template<class T >
bool OpenMesh::BaseKernel::get_property_handle ( EPropHandleT< T > &  _ph,
const std::string &  _name 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::propertyExists) or one of its higher level helper functions such as makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Retrieves the handle to a named property by it's name.

Parameters
_phA property handle. On success the handle is valid else invalid.
_nameName of wanted property.
Returns
true if such a named property is available, else false.

◆ get_property_handle() [4/5]

template<class T >
bool OpenMesh::BaseKernel::get_property_handle ( FPropHandleT< T > &  _ph,
const std::string &  _name 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::propertyExists) or one of its higher level helper functions such as makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Retrieves the handle to a named property by it's name.

Parameters
_phA property handle. On success the handle is valid else invalid.
_nameName of wanted property.
Returns
true if such a named property is available, else false.

◆ get_property_handle() [5/5]

template<class T >
bool OpenMesh::BaseKernel::get_property_handle ( MPropHandleT< T > &  _ph,
const std::string &  _name 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper (e.g. PropertyManager::propertyExists) or one of its higher level helper functions such as makePropertyManagerFromExisting, or makePropertyManagerFromExistingOrNew.

Retrieves the handle to a named property by it's name.

Parameters
_phA property handle. On success the handle is valid else invalid.
_nameName of wanted property.
Returns
true if such a named property is available, else false.

◆ mproperty() [1/2]

template<class T >
PropertyT<T>& OpenMesh::BaseKernel::mproperty ( MPropHandleT< T >  _ph)
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ mproperty() [2/2]

template<class T >
const PropertyT<T>& OpenMesh::BaseKernel::mproperty ( MPropHandleT< T >  _ph) const
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [1/18]

template<class T >
PropertyT<T>& OpenMesh::BaseKernel::property ( VPropHandleT< T >  _ph)
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [2/18]

template<class T >
const PropertyT<T>& OpenMesh::BaseKernel::property ( VPropHandleT< T >  _ph) const
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [3/18]

template<class T >
PropertyT<T>& OpenMesh::BaseKernel::property ( HPropHandleT< T >  _ph)
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [4/18]

template<class T >
const PropertyT<T>& OpenMesh::BaseKernel::property ( HPropHandleT< T >  _ph) const
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [5/18]

template<class T >
PropertyT<T>& OpenMesh::BaseKernel::property ( EPropHandleT< T >  _ph)
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [6/18]

template<class T >
const PropertyT<T>& OpenMesh::BaseKernel::property ( EPropHandleT< T >  _ph) const
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [7/18]

template<class T >
PropertyT<T>& OpenMesh::BaseKernel::property ( FPropHandleT< T >  _ph)
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [8/18]

template<class T >
const PropertyT<T>& OpenMesh::BaseKernel::property ( FPropHandleT< T >  _ph) const
inline

In most cases you should use the convenient PropertyManager wrapper and use of this function should not be necessary.

Under some circumstances, however (i.e. making a property persistent), it might be necessary to use this function.

Access a property

This method returns a reference to property. The property handle must be valid! The result is unpredictable if the handle is invalid!

Parameters
_phA valid (!) property handle.
Returns
The wanted property if the handle is valid.

◆ property() [9/18]

template<class T >
VPropHandleT<T>::reference OpenMesh::BaseKernel::property ( VPropHandleT< T >  _ph,
VertexHandle  _vh 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [10/18]

template<class T >
VPropHandleT<T>::const_reference OpenMesh::BaseKernel::property ( VPropHandleT< T >  _ph,
VertexHandle  _vh 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [11/18]

template<class T >
HPropHandleT<T>::reference OpenMesh::BaseKernel::property ( HPropHandleT< T >  _ph,
HalfedgeHandle  _hh 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [12/18]

template<class T >
HPropHandleT<T>::const_reference OpenMesh::BaseKernel::property ( HPropHandleT< T >  _ph,
HalfedgeHandle  _hh 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [13/18]

template<class T >
EPropHandleT<T>::reference OpenMesh::BaseKernel::property ( EPropHandleT< T >  _ph,
EdgeHandle  _eh 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [14/18]

template<class T >
EPropHandleT<T>::const_reference OpenMesh::BaseKernel::property ( EPropHandleT< T >  _ph,
EdgeHandle  _eh 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [15/18]

template<class T >
FPropHandleT<T>::reference OpenMesh::BaseKernel::property ( FPropHandleT< T >  _ph,
FaceHandle  _fh 
)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [16/18]

template<class T >
FPropHandleT<T>::const_reference OpenMesh::BaseKernel::property ( FPropHandleT< T >  _ph,
FaceHandle  _fh 
) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [17/18]

template<class T >
MPropHandleT<T>::reference OpenMesh::BaseKernel::property ( MPropHandleT< T >  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ property() [18/18]

template<class T >
MPropHandleT<T>::const_reference OpenMesh::BaseKernel::property ( MPropHandleT< T >  _ph) const
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper.

Return value of property for an item

◆ remove_property() [1/5]

template<typename T >
void OpenMesh::BaseKernel::remove_property ( VPropHandleT< T > &  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper to manage (and remove) properties.

Remove a property.

Removes the property represented by the handle from the apropriate mesh item.

Parameters
_phProperty to be removed. The handle is invalid afterwords.

◆ remove_property() [2/5]

template<typename T >
void OpenMesh::BaseKernel::remove_property ( HPropHandleT< T > &  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper to manage (and remove) properties.

Remove a property.

Removes the property represented by the handle from the apropriate mesh item.

Parameters
_phProperty to be removed. The handle is invalid afterwords.

◆ remove_property() [3/5]

template<typename T >
void OpenMesh::BaseKernel::remove_property ( EPropHandleT< T > &  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper to manage (and remove) properties.

Remove a property.

Removes the property represented by the handle from the apropriate mesh item.

Parameters
_phProperty to be removed. The handle is invalid afterwords.

◆ remove_property() [4/5]

template<typename T >
void OpenMesh::BaseKernel::remove_property ( FPropHandleT< T > &  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper to manage (and remove) properties.

Remove a property.

Removes the property represented by the handle from the apropriate mesh item.

Parameters
_phProperty to be removed. The handle is invalid afterwords.

◆ remove_property() [5/5]

template<typename T >
void OpenMesh::BaseKernel::remove_property ( MPropHandleT< T > &  _ph)
inline

You should not use this function directly.

Instead, use the convenient PropertyManager wrapper to manage (and remove) properties.

Remove a property.

Removes the property represented by the handle from the apropriate mesh item.

Parameters
_phProperty to be removed. The handle is invalid afterwords.

◆ vprops_resize_if_smaller()

void OpenMesh::BaseKernel::vprops_resize_if_smaller ( size_t  _n) const
inlineprotected

Same as vprops_resize() but ignores vertex property vectors that have a size larger than _n.

Use this method instead of vprops_resize() if you plan to frequently reduce and enlarge the property container and you don't want to waste time reallocating the property vectors every time.


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

Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .