 |
OpenMesh
|
|
OpenMesh
|
Adaptive Composite Subdivision framework. More...
#include <OpenMesh/Tools/Subdivider/Adaptive/Composite/CompositeT.hh>
Public Types | |
| typedef RuleInterfaceT< M > | Rule |
| typedef M | Mesh |
| typedef std::vector< Rule * > | RuleSequence |
| typedef M::VertexHandle | VH |
| typedef M::FaceHandle | FH |
| typedef M::EdgeHandle | EH |
| typedef M::HalfedgeHandle | HH |
Public Member Functions | |
| CompositeT (Mesh &_mesh) | |
| Constructor. | |
| void | cleanup (void) |
Reset self to state after the default constructor except of the mesh. More... | |
| bool | initialize (void) |
| Initialize faces, edges, vertices, and rules. | |
| void | refine (typename M::FaceHandle &_fh) |
| Refine one face. | |
| void | refine (typename M::VertexHandle &_vh) |
| Raise one vertex to next final level. | |
| int | subdiv_type () |
| Return subdivision split type (3 for 1-to-3 split, 4 for 1-to-4 split). | |
| const Rule & | subdiv_rule () const |
Managing composite rules | |
| template<typename R > | |
| RuleHandleT< R > | add () |
| Add new rule to rule sequence by passing the type of the wanted rule as template argument to the method. More... | |
| template<typename R > | |
| RuleHandleT< R > & | add (RuleHandleT< R > &_rh) |
| Add new rule to rule sequence by passing an appropriate handle to the method. More... | |
| template<typename R > | |
| RuleHandleT< R >::Rule & | rule (const RuleHandleT< R > &_rh) |
| Get rule in the rule sequence by a handle. More... | |
| RuleInterfaceT< M > & | rule (size_t _idx) |
| Get rule (interface) by index. More... | |
| size_t | n_rules () const |
| Number of rules in the rule sequence. | |
| std::string | rules_as_string (const std::string &_sep=" * ") const |
| Return the sequence as string. | |
Protected Member Functions | |
| const RuleSequence & | rules () const |
| The rule sequence. | |
| state_t | generation (state_t _s) |
| state_t | generation (VH _vh) |
| state_t | generation (EH _eh) |
| state_t | generation (FH _fh) |
Adaptive Composite Subdivision framework.
The adaptive composite subdivision framework is based on the work done by P. Oswald and P. Schroeder. This framework elevates the uniform case of the composite scheme to the adaptive setting.
For details on the composite scheme refer to
For details on the transition from uniform to adaptive composite subdivision please refer to
In the composite scheme a subdivision operator is created by combining smaller "atomic" rules. Depending on the selection and ordering of the operator many known subdivision schemes can be created.
Every rule inherits from RuleInterfaceT and is represented out of the subdivider object by a RuleHandleT (as usual within OpenMesh). You can add rules using the CompositeT::add() functions. The correct order of adding the rules is very important, and furthermore not all rules get along with each other very well. (Please read the given literature, especially the paper by Oswald and Schr�der.)
To use a composite subdivider first define a rule sequence describing the order of execution of the rules. In the order the rules habe been added they will be executed. E.g. the rules given in operator notation have to added from right to left.
After the rule sequence has been defined the subdivider has to be intialized using CompositeT::initialize(). If everything went well, use CompositeT::refine() to subdivide locally a face or vertex.
|
inline |
Add new rule to rule sequence by passing the type of the wanted rule as template argument to the method.
|
inline |
Add new rule to rule sequence by passing an appropriate handle to the method.
|
inline |
Reset self to state after the default constructor except of the mesh.
|
inline |
Get rule in the rule sequence by a handle.
|
inline |
Get rule (interface) by index.