49 #ifndef OPENMESH_SUBDIVIDER_ADAPTIVE_RULEINTERFACET_HH
50 #define OPENMESH_SUBDIVIDER_ADAPTIVE_RULEINTERFACET_HH
61 namespace Subdivider {
67 template <
typename M>
class CompositeT;
68 template <
typename M>
class RuleInterfaceT;
80 template <
typename R >
81 struct RuleHandleT :
public BaseHandle
83 explicit RuleHandleT(
int _idx=-1) : BaseHandle(_idx) {}
86 operator bool()
const {
return is_valid(); }
93 #define COMPOSITE_RULE( classname, mesh_type ) \
95 friend class CompositeT<mesh_type>; \
97 const char *type() const { return #classname; } \
98 typedef classname<mesh_type> Self; \
99 typedef RuleHandleT< Self > Handle
106 template <
typename M>
class RuleInterfaceT
111 typedef RuleInterfaceT<M> Self;
112 typedef RuleHandleT< Self > Rule;
114 typedef typename M::Scalar scalar_t;
129 virtual const char *
type()
const = 0;
135 virtual void raise(
typename M::FaceHandle& _fh,
state_t _target_state)
138 if (mesh_.data(_fh).state() < _target_state) {
139 update(_fh, _target_state);
140 mesh_.data(_fh).inc_state();
144 virtual void raise(
typename M::EdgeHandle& _eh,
state_t _target_state)
146 if (mesh_.data(_eh).state() < _target_state) {
147 update(_eh, _target_state);
148 mesh_.data(_eh).inc_state();
152 virtual void raise(
typename M::VertexHandle& _vh,
state_t _target_state)
154 if (mesh_.data(_vh).state() < _target_state) {
155 update(_vh, _target_state);
156 mesh_.data(_vh).inc_state();
161 void update(
typename M::FaceHandle& _fh,
state_t _target_state)
163 typename M::FaceHandle opp_fh;
165 while (mesh_.data(_fh).state() < _target_state - 1) {
166 prev_rule()->
raise(_fh, _target_state - 1);
172 if (mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.halfedge_handle(_fh))).is_valid()) {
174 while (!mesh_.data(_fh).final()) {
176 opp_fh = mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.halfedge_handle(_fh)));
178 assert (mesh_.data(_fh).state() >=
179 mesh_.data(opp_fh).state());
182 if (mesh_.data(_fh).state() > mesh_.data(opp_fh).state()){
185 prev_rule()->
raise(opp_fh, _target_state - 1);
227 mesh_.data(_fh).final() ||
228 _target_state%n_rules() == (subdiv_rule()->
number() + 1)%n_rules() );
230 typename M::FaceEdgeIter fe_it;
231 typename M::FaceVertexIter fv_it;
232 typename M::EdgeHandle eh;
233 typename M::VertexHandle vh;
235 std::vector<typename M::FaceHandle> face_vector;
238 if (_target_state > 1) {
240 for (fe_it = mesh_.fe_iter(_fh); fe_it.is_valid(); ++fe_it) {
243 prev_rule()->
raise(eh, _target_state - 1);
246 for (fv_it = mesh_.fv_iter(_fh); fv_it.is_valid(); ++fv_it) {
249 prev_rule()->
raise(vh, _target_state - 1);
255 void update(
typename M::EdgeHandle& _eh,
state_t _target_state)
257 state_t state(mesh_.data(_eh).state());
260 if (state + 1 < _target_state && _target_state > 0) {
262 prev_rule()->
raise(_eh, _target_state - 1);
265 typename M::VertexHandle vh;
266 typename M::FaceHandle fh;
268 if (_target_state > 1)
270 vh = mesh_.to_vertex_handle(mesh_.halfedge_handle(_eh, 0));
271 prev_rule()->
raise(vh, _target_state - 1);
273 vh = mesh_.to_vertex_handle(mesh_.halfedge_handle(_eh, 1));
274 prev_rule()->
raise(vh, _target_state - 1);
276 fh = mesh_.face_handle(mesh_.halfedge_handle(_eh, 0));
278 prev_rule()->
raise(fh, _target_state - 1);
280 fh = mesh_.face_handle(mesh_.halfedge_handle(_eh, 1));
282 prev_rule()->
raise(fh, _target_state - 1);
287 void update(
typename M::VertexHandle& _vh,
state_t _target_state) {
289 state_t state(mesh_.data(_vh).state());
292 if (state + 1 < _target_state)
294 prev_rule()->
raise(_vh, _target_state - 1);
297 std::vector<typename M::HalfedgeHandle> halfedge_vector;
298 halfedge_vector.clear();
300 typename M::VertexOHalfedgeIter voh_it;
301 typename M::EdgeHandle eh;
302 typename M::FaceHandle fh;
304 if (_target_state > 1)
307 for (voh_it = mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) {
308 halfedge_vector.push_back(*voh_it);
311 while ( !halfedge_vector.empty() ) {
312 eh = mesh_.edge_handle(halfedge_vector.back());
313 halfedge_vector.pop_back();
315 prev_rule()->
raise(eh, _target_state - 1);
318 for (voh_it = mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) {
319 halfedge_vector.push_back(*voh_it);
322 while ( !halfedge_vector.empty() ) {
323 fh = mesh_.face_handle(halfedge_vector.back());
324 halfedge_vector.pop_back();
327 prev_rule()->
raise(fh, _target_state - 1);
346 virtual void set_coeff( scalar_t _coeff ) { coeff_ = _coeff; }
349 scalar_t
coeff()
const {
return coeff_; }
355 void set_prev_rule(Self*& _p) { prev_rule_ = _p; }
356 Self* prev_rule() {
return prev_rule_; }
358 void set_subdiv_rule(Self*& _n) { subdiv_rule_ = _n; }
359 Self* subdiv_rule() {
return subdiv_rule_; }
361 void set_number(
int _n) { number_ = _n; }
363 void set_n_rules(
int _n) { n_rules_ = _n; }
364 int n_rules() {
return n_rules_; }
366 void set_subdiv_type(
int _n)
367 { assert(_n == 3 || _n == 4); subdiv_type_ = _n; }
369 friend class CompositeT<M>;
398 #endif // OPENMESH_SUBDIVIDER_ADAPTIVE_RULEINTERFACET_HH defined
bool is_valid() const
The handle is valid iff the index is not equal to -1.
Definition: Handles.hh:70
Mesh traits for adaptive composite subdivider.
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:56
CompositeTraits::state_t state_t
Adaptive Composite Subdivision framework.
Definition: CompositeTraits.hh:248
virtual void raise(typename M::FaceHandle &_fh, state_t _target_state)
Raise item to target state _target_state.
Definition: RuleInterfaceT.hh:136
virtual const char * type() const =0
Returns the name of the rule.
virtual void set_coeff(scalar_t _coeff)
Set coefficient - ignored by non-parameterized rules.
Definition: RuleInterfaceT.hh:346
int number() const
Position in rule sequence.
Definition: RuleInterfaceT.hh:340
RuleInterfaceT(Mesh &_mesh)
Default constructor.
Definition: RuleInterfaceT.hh:119
virtual ~RuleInterfaceT()
Destructor.
Definition: RuleInterfaceT.hh:124
scalar_t coeff() const
Get coefficient - ignored by non-parameterized rules.
Definition: RuleInterfaceT.hh:349
int subdiv_type() const
Type of split operation, if it is a topological operator.
Definition: RuleInterfaceT.hh:336