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 >
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
114 typedef typename M::Scalar scalar_t;
129 virtual const char *type()
const = 0;
136 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);
170 if (subdiv_type() == 3) {
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; ++fe_it) {
243 prev_rule()->
raise(eh, _target_state - 1);
246 for (fv_it = mesh_.fv_iter(_fh); fv_it; ++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; ++voh_it) {
308 halfedge_vector.push_back(voh_it.handle());
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; ++voh_it) {
319 halfedge_vector.push_back(voh_it.handle());
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