From 0217136b5e03613aa499353bb46d7ff54acc57c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20M=C3=B6bius?= Date: Wed, 7 Aug 2013 11:18:44 +0000 Subject: [PATCH] Next changeset git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@907 fdac6126-5c0c-442c-9429-916003d36597 --- src/OpenMesh/Core/IO/importer/ImporterT.hh | 4 +- src/OpenMesh/Core/Mesh/PolyConnectivity.cc | 78 ++--- src/OpenMesh/Core/Mesh/PolyMeshT.cc | 8 +- src/OpenMesh/Core/Mesh/TriConnectivity.cc | 24 +- src/OpenMesh/Core/Mesh/TriMeshT.cc | 6 +- src/OpenMesh/Tools/Decimater/DecimaterT.cc | 14 +- .../Tools/Decimater/ModAspectRatioT.cc | 4 +- src/OpenMesh/Tools/Decimater/ModHausdorffT.cc | 4 +- .../Tools/Decimater/ModIndependentSetsT.hh | 4 +- .../Tools/Decimater/ModNormalDeviationT.hh | 4 +- .../Tools/Decimater/ModNormalFlippingT.hh | 2 +- src/OpenMesh/Tools/Decimater/ModRoundnessT.hh | 4 +- src/OpenMesh/Tools/Dualizer/meshDualT.hh | 8 +- .../Tools/Smoother/JacobiLaplaceSmootherT.cc | 22 +- src/OpenMesh/Tools/Smoother/SmootherT.cc | 30 +- .../Subdivider/Adaptive/Composite/RulesT.cc | 294 +++++++++--------- .../Tools/Subdivider/Uniform/Sqrt3T.hh | 8 +- 17 files changed, 259 insertions(+), 259 deletions(-) diff --git a/src/OpenMesh/Core/IO/importer/ImporterT.hh b/src/OpenMesh/Core/IO/importer/ImporterT.hh index 23ee4c37..d1910b67 100644 --- a/src/OpenMesh/Core/IO/importer/ImporterT.hh +++ b/src/OpenMesh/Core/IO/importer/ImporterT.hh @@ -349,8 +349,8 @@ public: // Mark edges of failed face as non-two-manifold if (mesh_.has_edge_status()) { typename Mesh::FaceEdgeIter fe_it = mesh_.fe_iter(fh); - for(; fe_it; ++fe_it) { - mesh_.status(fe_it).set_fixed_nonmanifold(true); + for(; fe_it.is_valid(); ++fe_it) { + mesh_.status(*fe_it).set_fixed_nonmanifold(true); } } } diff --git a/src/OpenMesh/Core/Mesh/PolyConnectivity.cc b/src/OpenMesh/Core/Mesh/PolyConnectivity.cc index db314d77..80847857 100644 --- a/src/OpenMesh/Core/Mesh/PolyConnectivity.cc +++ b/src/OpenMesh/Core/Mesh/PolyConnectivity.cc @@ -57,8 +57,8 @@ PolyConnectivity::find_halfedge(VertexHandle _start_vh, VertexHandle _end_vh ) c { assert(_start_vh.is_valid() && _end_vh.is_valid()); - for (ConstVertexVertexIter vvIt=cvv_iter(_start_vh); vvIt; ++vvIt) - if (vvIt.handle() == _end_vh) + for (ConstVertexVertexIter vvIt=cvv_iter(_start_vh); vvIt.is_valid(); ++vvIt) + if (*vvIt == _end_vh) return vvIt.current_halfedge_handle(); return InvalidHalfedgeHandle; @@ -67,14 +67,14 @@ PolyConnectivity::find_halfedge(VertexHandle _start_vh, VertexHandle _end_vh ) c bool PolyConnectivity::is_boundary(FaceHandle _fh, bool _check_vertex) const { - for (ConstFaceEdgeIter cfeit = cfe_iter( _fh ); cfeit; ++cfeit) - if (is_boundary( cfeit.handle() ) ) + for (ConstFaceEdgeIter cfeit = cfe_iter( _fh ); cfeit.is_valid(); ++cfeit) + if (is_boundary( *cfeit ) ) return true; if (_check_vertex) { - for (ConstFaceVertexIter cfvit = cfv_iter( _fh ); cfvit; ++cfvit) - if (is_boundary( cfvit.handle() ) ) + for (ConstFaceVertexIter cfvit = cfv_iter( _fh ); cfvit.is_valid(); ++cfvit) + if (is_boundary( *cfvit ) ) return true; } return false; @@ -89,9 +89,9 @@ bool PolyConnectivity::is_manifold(VertexHandle _vh) const boundary halfedge, the vertex is non-manifold. */ ConstVertexOHalfedgeIter vh_it(*this, _vh); - if (vh_it) - for (++vh_it; vh_it; ++vh_it) - if (is_boundary(vh_it.handle())) + if (vh_it.is_valid()) + for (++vh_it; vh_it.is_valid(); ++vh_it) + if (is_boundary(*vh_it)) return false; return true; } @@ -99,11 +99,11 @@ bool PolyConnectivity::is_manifold(VertexHandle _vh) const //----------------------------------------------------------------------------- void PolyConnectivity::adjust_outgoing_halfedge(VertexHandle _vh) { - for (ConstVertexOHalfedgeIter vh_it=cvoh_iter(_vh); vh_it; ++vh_it) + for (ConstVertexOHalfedgeIter vh_it=cvoh_iter(_vh); vh_it.is_valid(); ++vh_it) { - if (is_boundary(vh_it.handle())) + if (is_boundary(*vh_it)) { - set_halfedge_handle(_vh, vh_it.handle()); + set_halfedge_handle(_vh, *vh_it); break; } } @@ -388,19 +388,19 @@ bool PolyConnectivity::is_collapse_ok(HalfedgeHandle v0v1) VertexVertexIter vv_it; // test intersection of the one-rings of v0 and v1 - for (vv_it = vv_iter(v0); vv_it; ++vv_it) + for (vv_it = vv_iter(v0); vv_it.is_valid(); ++vv_it) { - status(vv_it).set_tagged(false); + status(*vv_it).set_tagged(false); } - for (vv_it = vv_iter(v1); vv_it; ++vv_it) + for (vv_it = vv_iter(v1); vv_it.is_valid(); ++vv_it) { - status(vv_it).set_tagged(true); + status(*vv_it).set_tagged(true); } - for (vv_it = vv_iter(v0); vv_it; ++vv_it) + for (vv_it = vv_iter(v0); vv_it.is_valid(); ++vv_it) { - if (status(vv_it).tagged() && + if (status(*vv_it).tagged() && !(*vv_it == v_01_n && v0v1_triangle) && !(*vv_it == v_10_n && v1v0_triangle) ) @@ -440,7 +440,7 @@ bool PolyConnectivity::is_collapse_ok(HalfedgeHandle v0v1) } } - if (status(vv_it).tagged() && v_01_n == v_10_n && v0v1_triangle && v1v0_triangle) + if (status(*vv_it).tagged() && v_01_n == v_10_n && v0v1_triangle && v1v0_triangle) { return false; } @@ -456,8 +456,8 @@ void PolyConnectivity::delete_vertex(VertexHandle _vh, bool _delete_isolated_ver // store incident faces std::vector face_handles; face_handles.reserve(8); - for (VFIter vf_it(vf_iter(_vh)); vf_it; ++vf_it) - face_handles.push_back(vf_it.handle()); + for (VFIter vf_it(vf_iter(_vh)); vf_it.is_valid(); ++vf_it) + face_handles.push_back(*vf_it); // delete collected faces @@ -524,9 +524,9 @@ void PolyConnectivity::delete_face(FaceHandle _fh, bool _delete_isolated_vertice // 2) collect all boundary halfedges, set them deleted // 3) store vertex handles HalfedgeHandle hh; - for (FaceHalfedgeIter fh_it(fh_iter(_fh)); fh_it; ++fh_it) + for (FaceHalfedgeIter fh_it(fh_iter(_fh)); fh_it.is_valid(); ++fh_it) { - hh = fh_it.handle(); + hh = *fh_it; set_boundary(hh);//set_face_handle(hh, InvalidFaceHandle); @@ -745,8 +745,8 @@ void PolyConnectivity::collapse_edge(HalfedgeHandle _hh) // halfedge -> vertex - for (VertexIHalfedgeIter vih_it(vih_iter(vo)); vih_it; ++vih_it) - set_vertex_handle(vih_it.handle(), vh); + for (VertexIHalfedgeIter vih_it(vih_iter(vo)); vih_it.is_valid(); ++vih_it) + set_vertex_handle(*vih_it, vh); // halfedge -> halfedge @@ -844,11 +844,11 @@ bool PolyConnectivity::is_simple_link(EdgeHandle _eh) const bool PolyConnectivity::is_simply_connected(FaceHandle _fh) const { std::set nb_fhs; - for (ConstFaceFaceIter cff_it = cff_iter(_fh); cff_it; ++cff_it) + for (ConstFaceFaceIter cff_it = cff_iter(_fh); cff_it.is_valid(); ++cff_it) { - if (nb_fhs.find(cff_it) == nb_fhs.end()) + if (nb_fhs.find(*cff_it) == nb_fhs.end()) { - nb_fhs.insert(cff_it); + nb_fhs.insert(*cff_it); } else {//there is more than one link @@ -910,9 +910,9 @@ PolyConnectivity::remove_edge(EdgeHandle _eh) {//rem_fh is the face at heh1 set_halfedge_handle(rem_fh, prev_heh0); } - for (FaceHalfedgeIter fh_it = fh_iter(rem_fh); fh_it; ++fh_it) + for (FaceHalfedgeIter fh_it = fh_iter(rem_fh); fh_it.is_valid(); ++fh_it) {//set the face handle of the halfedges of del_fh to point to rem_fh - set_face_handle(fh_it, rem_fh); + set_face_handle(*fh_it, rem_fh); } status(_eh).set_deleted(true); @@ -952,9 +952,9 @@ void PolyConnectivity::reinsert_edge(EdgeHandle _eh) set_next_halfedge_handle(prev_heh1, heh1); set_prev_halfedge_handle(next_heh1, heh1); - for (FaceHalfedgeIter fh_it = fh_iter(del_fh); fh_it; ++fh_it) + for (FaceHalfedgeIter fh_it = fh_iter(del_fh); fh_it.is_valid(); ++fh_it) {//reassign halfedges to del_fh - set_face_handle(fh_it, del_fh); + set_face_handle(*fh_it, del_fh); } if (face_handle(halfedge_handle(rem_fh)) == del_fh) @@ -992,9 +992,9 @@ PolyConnectivity::insert_edge(HalfedgeHandle _prev_heh, HalfedgeHandle _next_heh //now set the face handles - the new face is assigned to heh0 FaceHandle new_fh = new_face(); set_halfedge_handle(new_fh, heh0); - for (FaceHalfedgeIter fh_it = fh_iter(new_fh); fh_it; ++fh_it) + for (FaceHalfedgeIter fh_it = fh_iter(new_fh); fh_it.is_valid(); ++fh_it) { - set_face_handle(fh_it, new_fh); + set_face_handle(*fh_it, new_fh); } FaceHandle old_fh = face_handle(next_prev_heh); set_face_handle(heh1, old_fh); @@ -1061,7 +1061,7 @@ void PolyConnectivity::triangulate() */ FaceIter f_it(faces_begin()), f_end(faces_end()); for (; f_it!=f_end; ++f_it) - triangulate(f_it); + triangulate(*f_it); } //----------------------------------------------------------------------------- @@ -1114,15 +1114,15 @@ void PolyConnectivity::split_copy(FaceHandle fh, VertexHandle vh) { split(fh, vh); // Copy the property of the original face to all new faces - for(VertexFaceIter vf_it = vf_iter(vh); vf_it; ++vf_it) - copy_all_properties(fh, vf_it); + for(VertexFaceIter vf_it = vf_iter(vh); vf_it.is_valid(); ++vf_it) + copy_all_properties(fh, *vf_it); } //----------------------------------------------------------------------------- uint PolyConnectivity::valence(VertexHandle _vh) const { uint count(0); - for (ConstVertexVertexIter vv_it=cvv_iter(_vh); vv_it; ++vv_it) + for (ConstVertexVertexIter vv_it=cvv_iter(_vh); vv_it.is_valid(); ++vv_it) ++count; return count; } @@ -1131,7 +1131,7 @@ uint PolyConnectivity::valence(VertexHandle _vh) const uint PolyConnectivity::valence(FaceHandle _fh) const { uint count(0); - for (ConstFaceVertexIter fv_it=cfv_iter(_fh); fv_it; ++fv_it) + for (ConstFaceVertexIter fv_it=cfv_iter(_fh); fv_it.is_valid(); ++fv_it) ++count; return count; } diff --git a/src/OpenMesh/Core/Mesh/PolyMeshT.cc b/src/OpenMesh/Core/Mesh/PolyMeshT.cc index 999bff6e..19f206e2 100644 --- a/src/OpenMesh/Core/Mesh/PolyMeshT.cc +++ b/src/OpenMesh/Core/Mesh/PolyMeshT.cc @@ -96,10 +96,10 @@ calc_face_normal(FaceHandle _fh) const assert(this->halfedge_handle(_fh).is_valid()); ConstFaceVertexIter fv_it(this->cfv_iter(_fh)); - Point p0 = this->point(fv_it); + Point p0 = this->point(*fv_it); Point p0i = p0; //save point of vertex 0 ++fv_it; - Point p1 = this->point(fv_it); + Point p1 = this->point(*fv_it); Point p1i = p1; //save point of vertex 1 ++fv_it; Point p2; @@ -108,7 +108,7 @@ calc_face_normal(FaceHandle _fh) const Normal n(0,0,0); for(; fv_it.is_valid(); ++fv_it) { - p2 = this->point(fv_it); + p2 = this->point(*fv_it); n += vector_cast(calc_face_normal(p0, p1, p2)); p0 = p1; p1 = p2; @@ -331,7 +331,7 @@ void PolyMeshT:: calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const { _n.vectorize(0.0); - for (ConstVertexFaceIter vf_it=this->cvf_iter(_vh); vf_it; ++vf_it) + for (ConstVertexFaceIter vf_it=this->cvf_iter(_vh); vf_it.is_valid(); ++vf_it) _n += this->normal(*vf_it); } diff --git a/src/OpenMesh/Core/Mesh/TriConnectivity.cc b/src/OpenMesh/Core/Mesh/TriConnectivity.cc index 4013327b..4b51f5c4 100644 --- a/src/OpenMesh/Core/Mesh/TriConnectivity.cc +++ b/src/OpenMesh/Core/Mesh/TriConnectivity.cc @@ -153,14 +153,14 @@ bool TriConnectivity::is_collapse_ok(HalfedgeHandle v0v1) VertexVertexIter vv_it; // test intersection of the one-rings of v0 and v1 - for (vv_it = vv_iter(v0); vv_it; ++vv_it) - status(vv_it).set_tagged(false); + for (vv_it = vv_iter(v0); vv_it.is_valid(); ++vv_it) + status(*vv_it).set_tagged(false); - for (vv_it = vv_iter(v1); vv_it; ++vv_it) - status(vv_it).set_tagged(true); + for (vv_it = vv_iter(v1); vv_it.is_valid(); ++vv_it) + status(*vv_it).set_tagged(true); - for (vv_it = vv_iter(v0); vv_it; ++vv_it) - if (status(vv_it).tagged() && *vv_it != vl && *vv_it != vr) + for (vv_it = vv_iter(v0); vv_it.is_valid(); ++vv_it) + if (status(*vv_it).tagged() && *vv_it != vl && *vv_it != vr) return false; @@ -279,8 +279,8 @@ TriConnectivity::insert_edge(VertexHandle _vh, HalfedgeHandle _h0, HalfedgeHandl // halfedge -> vertex - for (VertexIHalfedgeIter vih_it(vih_iter(v0)); vih_it; ++vih_it) - set_vertex_handle(vih_it.handle(), v0); + for (VertexIHalfedgeIter vih_it(vih_iter(v0)); vih_it.is_valid(); ++vih_it) + set_vertex_handle(*vih_it, v0); // halfedge -> face @@ -323,8 +323,8 @@ bool TriConnectivity::is_flip_ok(EdgeHandle _eh) const if (ah == bh) // this is generally a bad sign !!! return false; - for (ConstVertexVertexIter vvi(*this, ah); vvi; ++vvi) - if (vvi.handle() == bh) + for (ConstVertexVertexIter vvi(*this, ah); vvi.is_valid(); ++vvi) + if (*vvi == bh) return false; return true; @@ -487,8 +487,8 @@ void TriConnectivity::split_copy(EdgeHandle _eh, VertexHandle _vh) // Copy the properties of the original edge to all neighbor edges that // have been created - for(VEIter ve_it = ve_iter(_vh); ve_it; ++ve_it) - copy_all_properties(_eh, ve_it); + for(VEIter ve_it = ve_iter(_vh); ve_it.is_valid(); ++ve_it) + copy_all_properties(_eh, *ve_it); } }// namespace OpenMesh diff --git a/src/OpenMesh/Core/Mesh/TriMeshT.cc b/src/OpenMesh/Core/Mesh/TriMeshT.cc index 8570a15f..d3372dc6 100644 --- a/src/OpenMesh/Core/Mesh/TriMeshT.cc +++ b/src/OpenMesh/Core/Mesh/TriMeshT.cc @@ -74,9 +74,9 @@ calc_face_normal(FaceHandle _fh) const assert(this->halfedge_handle(_fh).is_valid()); ConstFaceVertexIter fv_it(this->cfv_iter(_fh)); - const Point& p0(this->point(fv_it)); ++fv_it; - const Point& p1(this->point(fv_it)); ++fv_it; - const Point& p2(this->point(fv_it)); + const Point& p0(this->point(*fv_it)); ++fv_it; + const Point& p1(this->point(*fv_it)); ++fv_it; + const Point& p2(this->point(*fv_it)); return PolyMesh::calc_face_normal(p0, p1, p2); } diff --git a/src/OpenMesh/Tools/Decimater/DecimaterT.cc b/src/OpenMesh/Tools/Decimater/DecimaterT.cc index 0e17aaae..4c1c41b0 100644 --- a/src/OpenMesh/Tools/Decimater/DecimaterT.cc +++ b/src/OpenMesh/Tools/Decimater/DecimaterT.cc @@ -101,7 +101,7 @@ void DecimaterT::heap_vertex(VertexHandle _vh) { // find best target in one ring typename Mesh::VertexOHalfedgeIter voh_it(mesh_, _vh); - for (; voh_it; ++voh_it) { + for (; voh_it.is_valid(); ++voh_it) { heh = *voh_it; CollapseInfo ci(mesh_, heh); @@ -168,8 +168,8 @@ size_t DecimaterT::decimate(size_t _n_collapses) { for (v_it = mesh_.vertices_begin(); v_it != v_end; ++v_it) { heap_->reset_heap_position(v_it.handle()); - if (!mesh_.status(v_it).deleted()) - heap_vertex(v_it.handle()); + if (!mesh_.status(*v_it).deleted()) + heap_vertex(*v_it); } // process heap @@ -189,7 +189,7 @@ size_t DecimaterT::decimate(size_t _n_collapses) { // store support (= one ring of *vp) vv_it = mesh_.vv_iter(ci.v0); support.clear(); - for (; vv_it; ++vv_it) + for (; vv_it.is_valid(); ++vv_it) support.push_back(*vv_it); // perform collapse @@ -198,9 +198,9 @@ size_t DecimaterT::decimate(size_t _n_collapses) { // update triangle normals vf_it = mesh_.vf_iter(ci.v1); - for (; vf_it; ++vf_it) - if (!mesh_.status(vf_it).deleted()) - mesh_.set_normal(vf_it, mesh_.calc_face_normal(vf_it.handle())); + for (; vf_it.is_valid(); ++vf_it) + if (!mesh_.status(*vf_it).deleted()) + mesh_.set_normal(*vf_it, mesh_.calc_face_normal(*vf_it)); // post-process collapse this->postprocess_collapse(ci); diff --git a/src/OpenMesh/Tools/Decimater/ModAspectRatioT.cc b/src/OpenMesh/Tools/Decimater/ModAspectRatioT.cc index 4a0effbb..48ea3652 100644 --- a/src/OpenMesh/Tools/Decimater/ModAspectRatioT.cc +++ b/src/OpenMesh/Tools/Decimater/ModAspectRatioT.cc @@ -112,7 +112,7 @@ void ModAspectRatioT::preprocess_collapse(const CollapseInfo& _ci) { typename Mesh::FaceHandle fh; typename Mesh::FVIter fv_it; - for (typename Mesh::VFIter vf_it = mesh_.vf_iter(_ci.v0); vf_it; ++vf_it) { + for (typename Mesh::VFIter vf_it = mesh_.vf_iter(_ci.v0); vf_it.is_valid(); ++vf_it) { fh = *vf_it; if (fh != _ci.fl && fh != _ci.fr) { typename Mesh::Point& p0 = mesh_.point(fv_it = mesh_.fv_iter(fh)); @@ -137,7 +137,7 @@ float ModAspectRatioT::collapse_priority(const CollapseInfo& _ci) { v3 = *vv_it; p3 = &mesh_.point(v3); - while (vv_it) { + while (vv_it.is_valid()) { v2 = v3; p2 = p3; diff --git a/src/OpenMesh/Tools/Decimater/ModHausdorffT.cc b/src/OpenMesh/Tools/Decimater/ModHausdorffT.cc index 82f27579..976dc2f3 100644 --- a/src/OpenMesh/Tools/Decimater/ModHausdorffT.cc +++ b/src/OpenMesh/Tools/Decimater/ModHausdorffT.cc @@ -215,7 +215,7 @@ collapse_priority(const CollapseInfo& _ci) // collect all points to be tested // collect all faces to be tested against - for (vf_it=mesh_.vf_iter(_ci.v0); vf_it; ++vf_it) { + for (vf_it=mesh_.vf_iter(_ci.v0); vf_it.is_valid(); ++vf_it) { fh = *vf_it; if (fh != _ci.fl && fh != _ci.fr) @@ -289,7 +289,7 @@ postprocess_collapse(const CollapseInfo& _ci) faces.reserve(20); // collect active faces and their points - for (vf_it=mesh_.vf_iter(_ci.v1); vf_it; ++vf_it) { + for (vf_it=mesh_.vf_iter(_ci.v1); vf_it.is_valid(); ++vf_it) { fh = *vf_it; faces.push_back(fh); diff --git a/src/OpenMesh/Tools/Decimater/ModIndependentSetsT.hh b/src/OpenMesh/Tools/Decimater/ModIndependentSetsT.hh index b569e70f..a464138e 100644 --- a/src/OpenMesh/Tools/Decimater/ModIndependentSetsT.hh +++ b/src/OpenMesh/Tools/Decimater/ModIndependentSetsT.hh @@ -82,8 +82,8 @@ class ModIndependentSetsT: public ModBaseT { Base::mesh().status(_ci.v1).set_locked(true); vv_it = Base::mesh().vv_iter(_ci.v1); - for (; vv_it; ++vv_it) - Base::mesh().status(vv_it).set_locked(true); + for (; vv_it.is_valid(); ++vv_it) + Base::mesh().status(*vv_it).set_locked(true); } private: diff --git a/src/OpenMesh/Tools/Decimater/ModNormalDeviationT.hh b/src/OpenMesh/Tools/Decimater/ModNormalDeviationT.hh index 746fe02d..3fda7f83 100644 --- a/src/OpenMesh/Tools/Decimater/ModNormalDeviationT.hh +++ b/src/OpenMesh/Tools/Decimater/ModNormalDeviationT.hh @@ -166,7 +166,7 @@ public: if (_ci.v0vl.is_valid()) fhl = mesh_.face_handle(_ci.v0vl); if (_ci.vrv0.is_valid()) fhr = mesh_.face_handle(_ci.vrv0); - for (; vf_it; ++vf_it) { + for (; vf_it.is_valid(); ++vf_it) { fh = *vf_it; if (fh != _ci.fl && fh != _ci.fr) { NormalCone nc = mesh_.property(normal_cones_, fh); @@ -207,7 +207,7 @@ public: void postprocess_collapse(const CollapseInfo& _ci) { // account for changed normals typename Mesh::VertexFaceIter vf_it(mesh_, _ci.v1); - for (; vf_it; ++vf_it) + for (; vf_it.is_valid(); ++vf_it) mesh_.property(normal_cones_, vf_it). merge(NormalCone(mesh_.normal(vf_it))); diff --git a/src/OpenMesh/Tools/Decimater/ModNormalFlippingT.hh b/src/OpenMesh/Tools/Decimater/ModNormalFlippingT.hh index 9cb92a2f..89e81eb8 100644 --- a/src/OpenMesh/Tools/Decimater/ModNormalFlippingT.hh +++ b/src/OpenMesh/Tools/Decimater/ModNormalFlippingT.hh @@ -120,7 +120,7 @@ public: typename Mesh::FaceHandle fh; typename Mesh::Scalar c(1.0); - for (; vf_it; ++vf_it) + for (; vf_it.is_valid(); ++vf_it) { fh = *vf_it; if (fh != _ci.fl && fh != _ci.fr) diff --git a/src/OpenMesh/Tools/Decimater/ModRoundnessT.hh b/src/OpenMesh/Tools/Decimater/ModRoundnessT.hh index 1252264f..e29b1afd 100644 --- a/src/OpenMesh/Tools/Decimater/ModRoundnessT.hh +++ b/src/OpenMesh/Tools/Decimater/ModRoundnessT.hh @@ -130,7 +130,7 @@ class ModRoundnessT : public ModBaseT C = vector_cast(Base::mesh().point( Base::mesh().to_vertex_handle(voh_it))); fhC = Base::mesh().face_handle( *voh_it ); - for (++voh_it; voh_it; ++voh_it) + for (++voh_it; voh_it.is_valid(); ++voh_it) { B = C; fhB = fhC; @@ -153,7 +153,7 @@ class ModRoundnessT : public ModBaseT C = vector_cast(Base::mesh().point( Base::mesh().to_vertex_handle(voh_it))); fhC = Base::mesh().face_handle( *voh_it ); - for (++voh_it; voh_it && (priority==Base::LEGAL_COLLAPSE); ++voh_it) + for (++voh_it; voh_it.is_valid() && (priority==Base::LEGAL_COLLAPSE); ++voh_it) { B = C; fhB = fhC; diff --git a/src/OpenMesh/Tools/Dualizer/meshDualT.hh b/src/OpenMesh/Tools/Dualizer/meshDualT.hh index 57d9b658..5a0f5fab 100644 --- a/src/OpenMesh/Tools/Dualizer/meshDualT.hh +++ b/src/OpenMesh/Tools/Dualizer/meshDualT.hh @@ -100,11 +100,11 @@ PolyMesh_ArrayKernelT* MeshDual (PolyMesh_ArrayKernelT & { typename PolyMesh_ArrayKernelT::Point centerPoint(0,0,0); unsigned int degree= 0; - for(typename PolyMesh_ArrayKernelT::ConstFaceVertexIter vit=primal.cfv_iter(fit); vit; ++vit, ++degree) + for(typename PolyMesh_ArrayKernelT::ConstFaceVertexIter vit=primal.cfv_iter(fit); vit.is_valid(); ++vit, ++degree) centerPoint += primal.point(*vit); assert(degree!=0); centerPoint /= degree; - primal.property(primalToDual, fit) = dual->add_vertex(centerPoint); + primal.property(primalToDual, *fit) = dual->add_vertex(centerPoint); } //for each vertex in the primal, add a face in the dual @@ -114,8 +114,8 @@ PolyMesh_ArrayKernelT* MeshDual (PolyMesh_ArrayKernelT & if(!primal.is_boundary(*vit)) { face_vhandles.clear(); - for(typename PolyMesh_ArrayKernelT::ConstVertexFaceIter fit=primal.cvf_iter(vit); fit; ++fit) - face_vhandles.push_back(primal.property(primalToDual, fit)); + for(typename PolyMesh_ArrayKernelT::ConstVertexFaceIter fit=primal.cvf_iter(vit); fit.is_valid(); ++fit) + face_vhandles.push_back(primal.property(primalToDual, *fit)); dual->add_face(face_vhandles); } } diff --git a/src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc b/src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc index 04bc4f29..33cc1add 100644 --- a/src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc +++ b/src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc @@ -108,21 +108,21 @@ compute_new_positions_C0() { // compute umbrella u = zero; - for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it) + for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it.is_valid(); ++vv_it) { w = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle())); - u += vector_cast(Base::mesh_.point(vv_it)) * w; + u += vector_cast(Base::mesh_.point(*vv_it)) * w; } u *= this->weight(v_it); - u -= vector_cast(Base::mesh_.point(v_it)); + u -= vector_cast(Base::mesh_.point(*v_it)); // damping u *= 0.5; // store new position - p = vector_cast(Base::mesh_.point(v_it)); + p = vector_cast(Base::mesh_.point(*v_it)); p += u; - this->set_new_position(v_it, p); + this->set_new_position(*v_it, p); } } } @@ -146,10 +146,10 @@ compute_new_positions_C1() for (v_it=Base::mesh_.vertices_begin(); v_it!=v_end; ++v_it) { u = zero; - for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it) + for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it.is_valid(); ++vv_it) { w = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle())); - u -= vector_cast(Base::mesh_.point(vv_it))*w; + u -= vector_cast(Base::mesh_.point(*vv_it))*w; } u *= this->weight(v_it); u += vector_cast(Base::mesh_.point(v_it)); @@ -165,11 +165,11 @@ compute_new_positions_C1() { uu = zero; diag = 0.0; - for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it) + for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it.is_valid(); ++vv_it) { - w = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle())); - uu -= Base::mesh_.property(umbrellas_, vv_it); - diag += (w * this->weight(vv_it) + 1.0) * w; + w = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle())); + uu -= Base::mesh_.property(umbrellas_, *vv_it); + diag += (w * this->weight(*vv_it) + 1.0) * w; } uu *= this->weight(v_it); diag *= this->weight(v_it); diff --git a/src/OpenMesh/Tools/Smoother/SmootherT.cc b/src/OpenMesh/Tools/Smoother/SmootherT.cc index 41db991f..316ad244 100644 --- a/src/OpenMesh/Tools/Smoother/SmootherT.cc +++ b/src/OpenMesh/Tools/Smoother/SmootherT.cc @@ -172,7 +172,7 @@ set_active_vertices() active = active && !mesh_.status(v_it).feature(); typename Mesh::VertexOHalfedgeIter voh_it(mesh_,v_it); - for ( ; voh_it ; ++voh_it ) { + for ( ; voh_it.is_valid() ; ++voh_it ) { // If the edge is a feature edge, skip the current vertex while smoothing if ( mesh_.status(mesh_.edge_handle(*voh_it)).feature() ) @@ -201,8 +201,8 @@ set_active_vertices() for (v_it=mesh_.vertices_begin(); v_it!=v_end; ++v_it) if (mesh_.is_boundary(v_it)) - for (vv_it=mesh_.vv_iter(v_it); vv_it; ++vv_it) - mesh_.property(is_active_, vv_it) = false; + for (vv_it=mesh_.vv_iter(*v_it); vv_it.is_valid(); ++vv_it) + mesh_.property(is_active_, *vv_it) = false; } @@ -213,26 +213,26 @@ set_active_vertices() for (v_it=mesh_.vertices_begin(); v_it!=v_end; ++v_it) { - mesh_.status(v_it).set_tagged(false); - mesh_.status(v_it).set_tagged2(false); + mesh_.status(*v_it).set_tagged(false); + mesh_.status(*v_it).set_tagged2(false); } for (v_it=mesh_.vertices_begin(); v_it!=v_end; ++v_it) - if (mesh_.is_boundary(v_it)) - for (vv_it=mesh_.vv_iter(v_it); vv_it; ++vv_it) - mesh_.status(v_it).set_tagged(true); + if (mesh_.is_boundary(*v_it)) + for (vv_it=mesh_.vv_iter(*v_it); vv_it.is_valid(); ++vv_it) + mesh_.status(*v_it).set_tagged(true); for (v_it=mesh_.vertices_begin(); v_it!=v_end; ++v_it) - if (mesh_.status(v_it).tagged()) - for (vv_it=mesh_.vv_iter(v_it); vv_it; ++vv_it) - mesh_.status(v_it).set_tagged2(true); + if (mesh_.status(*v_it).tagged()) + for (vv_it=mesh_.vv_iter(*v_it); vv_it.is_valid(); ++vv_it) + mesh_.status(*v_it).set_tagged2(true); for (v_it=mesh_.vertices_begin(); v_it!=v_end; ++v_it) { - if (mesh_.status(v_it).tagged2()) - mesh_.property(is_active_, vv_it) = false; - mesh_.status(v_it).set_tagged(false); - mesh_.status(v_it).set_tagged2(false); + if (mesh_.status(*v_it).tagged2()) + mesh_.property(is_active_, *vv_it) = false; + mesh_.status(*v_it).set_tagged(false); + mesh_.status(*v_it).set_tagged2(false); } } } diff --git a/src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.cc b/src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.cc index 7a5bdbac..eb4f4809 100644 --- a/src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.cc +++ b/src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.cc @@ -674,7 +674,7 @@ void Tvv4::split_edge(typename M::HalfedgeHandle &_hh, typename M::VertexHandle &_vh, state_t _target_state) -{ + { typename M::HalfedgeHandle temp_hh; if (Base::mesh_.FH(Base::mesh_.OHEH(_hh)).is_valid()) @@ -683,22 +683,22 @@ Tvv4::split_edge(typename M::HalfedgeHandle &_hh, { if (MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).red_halfedge().is_valid()) { - temp_hh = MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).red_halfedge(); + temp_hh = MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).red_halfedge(); } else { - // two cases for divided, but not visited face - if (MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.PHEH(Base::mesh_.OHEH(_hh))))).state() + // two cases for divided, but not visited face + if (MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.PHEH(Base::mesh_.OHEH(_hh))))).state() == MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).state()) { - temp_hh = Base::mesh_.PHEH(Base::mesh_.OHEH(_hh)); - } + temp_hh = Base::mesh_.PHEH(Base::mesh_.OHEH(_hh)); + } - else if (MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(Base::mesh_.OHEH(_hh))))).state() - == MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).state()) + else if (MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(Base::mesh_.OHEH(_hh))))).state() + == MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(_hh))).state()) { - temp_hh = Base::mesh_.NHEH(Base::mesh_.OHEH(_hh)); - } + temp_hh = Base::mesh_.NHEH(Base::mesh_.OHEH(_hh)); + } } } else @@ -706,10 +706,10 @@ Tvv4::split_edge(typename M::HalfedgeHandle &_hh, } else temp_hh = Base::mesh_.InvalidHalfedgeHandle; - + // split edge Base::mesh_.split(Base::mesh_.EH(_hh), _vh); - + if (Base::mesh_.FVH(_hh) == _vh) { MOBJ(Base::mesh_.EH(Base::mesh_.PHEH(Base::mesh_.OHEH(Base::mesh_.PHEH(_hh))))).set_state(MOBJ(Base::mesh_.EH(_hh)).state()); @@ -817,7 +817,7 @@ void VF::raise(typename M::FaceHandle& _fh, state_t _target_state) this->update(_fh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::FaceVertexIter fv_it; typename M::VertexHandle vh; std::vector vertex_vector; @@ -826,15 +826,15 @@ void VF::raise(typename M::FaceHandle& _fh, state_t _target_state) for (fv_it = Base::mesh_.fv_iter(_fh); fv_it.is_valid(); ++fv_it) { - vertex_vector.push_back(*fv_it); + vertex_vector.push_back(*fv_it); } while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } } @@ -874,7 +874,7 @@ void FF::raise(typename M::FaceHandle& _fh, state_t _target_state) { this->update(_fh, _target_state); - // raise all neighbour faces to level x-1 + // raise all neighbor faces to level x-1 typename M::FaceFaceIter ff_it; typename M::FaceHandle fh; std::vector face_vector; @@ -901,11 +901,11 @@ void FF::raise(typename M::FaceHandle& _fh, state_t _target_state) { while (!face_vector.empty()) { - fh = face_vector.back(); - face_vector.pop_back(); + fh = face_vector.back(); + face_vector.pop_back(); - while (MOBJ(fh).state() < _target_state - 1) - Base::prev_rule()->raise(fh, _target_state - 1); + while (MOBJ(fh).state() < _target_state - 1) + Base::prev_rule()->raise(fh, _target_state - 1); } } @@ -938,7 +938,7 @@ void FFc::raise(typename M::FaceHandle& _fh, state_t _target_state) this->update(_fh, _target_state); - // raise all neighbour faces to level x-1 + // raise all neighbor faces to level x-1 typename M::FaceFaceIter ff_it(Base::mesh_.ff_iter(_fh)); typename M::FaceHandle fh; std::vector face_vector; @@ -955,7 +955,7 @@ void FFc::raise(typename M::FaceHandle& _fh, state_t _target_state) Base::prev_rule()->raise(fh, _target_state - 1); } - for (ff_it = Base::mesh_.ff_iter(_fh); ff_it; ++ff_it) + for (ff_it = Base::mesh_.ff_iter(_fh); ff_it.is_valid(); ++ff_it) face_vector.push_back(*ff_it); while (!face_vector.empty()) { @@ -972,7 +972,7 @@ void FFc::raise(typename M::FaceHandle& _fh, state_t _target_state) typename M::Point position(0.0, 0.0, 0.0); int valence(0); - for (ff_it = Base::mesh_.ff_iter(_fh); ff_it; ++ff_it) + for (ff_it = Base::mesh_.ff_iter(_fh); ff_it.is_valid(); ++ff_it) { ++valence; position += Base::mesh_.data(ff_it).position(_target_state - 1); @@ -1003,7 +1003,7 @@ void FV::raise(typename M::VertexHandle& _vh, state_t _target_state) this->update(_vh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexFaceIter vf_it(Base::mesh_.vf_iter(_vh)); typename M::FaceHandle fh; std::vector face_vector; @@ -1023,7 +1023,7 @@ void FV::raise(typename M::VertexHandle& _vh, state_t _target_state) Base::prev_rule()->raise(fh, _target_state - 1); } - for (vf_it = Base::mesh_.vf_iter(_vh); vf_it; ++vf_it) { + for (vf_it = Base::mesh_.vf_iter(_vh); vf_it.is_valid(); ++vf_it) { face_vector.push_back(*vf_it); } @@ -1042,7 +1042,7 @@ void FV::raise(typename M::VertexHandle& _vh, state_t _target_state) typename M::Point position(0.0, 0.0, 0.0); int valence(0); - for (vf_it = Base::mesh_.vf_iter(_vh); vf_it; ++vf_it) { + for (vf_it = Base::mesh_.vf_iter(_vh); vf_it.is_valid(); ++vf_it) { ++valence; position += Base::mesh_.data(vf_it).position(_target_state - 1); @@ -1082,69 +1082,69 @@ void FVc::raise(typename M::VertexHandle& _vh, state_t _target_state) // raise all neighbour faces to level x-1 if (_target_state > 1) { - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { - if (Base::mesh_.FH(*voh_it).is_valid()) { + if (Base::mesh_.FH(*voh_it).is_valid()) { - face_vector.push_back(Base::mesh_.FH(*voh_it)); + face_vector.push_back(Base::mesh_.FH(*voh_it)); - if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { + if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { - face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); - } - } + face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); + } + } } while (!face_vector.empty()) { - fh = face_vector.back(); - face_vector.pop_back(); + fh = face_vector.back(); + face_vector.pop_back(); - Base::prev_rule()->raise(fh, _target_state - 1); + Base::prev_rule()->raise(fh, _target_state - 1); } - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { - if (Base::mesh_.FH(*voh_it).is_valid()) { + if (Base::mesh_.FH(*voh_it).is_valid()) { - face_vector.push_back(Base::mesh_.FH(*voh_it)); + face_vector.push_back(Base::mesh_.FH(*voh_it)); - if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { + if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { - face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); - } - } + face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); + } + } } while (!face_vector.empty()) { - fh = face_vector.back(); - face_vector.pop_back(); + fh = face_vector.back(); + face_vector.pop_back(); - while (MOBJ(fh).state() < _target_state - 1) - Base::prev_rule()->raise(fh, _target_state - 1); + while (MOBJ(fh).state() < _target_state - 1) + Base::prev_rule()->raise(fh, _target_state - 1); } - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { - if (Base::mesh_.FH(*voh_it).is_valid()) { + if (Base::mesh_.FH(*voh_it).is_valid()) { - face_vector.push_back(Base::mesh_.FH(*voh_it)); + face_vector.push_back(Base::mesh_.FH(*voh_it)); - if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { + if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { - face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); - } - } + face_vector.push_back(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))); + } + } } while (!face_vector.empty()) { - fh = face_vector.back(); - face_vector.pop_back(); + fh = face_vector.back(); + face_vector.pop_back(); - while (MOBJ(fh).state() < _target_state - 1) - Base::prev_rule()->raise(fh, _target_state - 1); + while (MOBJ(fh).state() < _target_state - 1) + Base::prev_rule()->raise(fh, _target_state - 1); } } @@ -1168,43 +1168,43 @@ void FVc::raise(typename M::VertexHandle& _vh, state_t _target_state) #endif - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { fh = Base::mesh_.FH(*voh_it); if (fh.is_valid()) - Base::prev_rule()->raise(fh, _target_state - 1); + Base::prev_rule()->raise(fh, _target_state - 1); fh = Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))); if (fh.is_valid()) - Base::prev_rule()->raise(fh, _target_state - 1); + Base::prev_rule()->raise(fh, _target_state - 1); if (Base::mesh_.FH(*voh_it).is_valid()) { - if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { + if (Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it))).is_valid()) { - position += MOBJ(Base::mesh_.FH(*voh_it)).position(_target_state - 1) * c; + position += MOBJ(Base::mesh_.FH(*voh_it)).position(_target_state - 1) * c; - position += MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))).position(_target_state - 1) * (1.0 - c); - } - else { + position += MOBJ(Base::mesh_.FH(Base::mesh_.OHEH(Base::mesh_.NHEH(*voh_it)))).position(_target_state - 1) * (1.0 - c); + } + else { - position += MOBJ(Base::mesh_.FH(*voh_it)).position(_target_state - 1); - } + position += MOBJ(Base::mesh_.FH(*voh_it)).position(_target_state - 1); + } } else { - --valence; + --valence; } } - + position /= valence; MOBJ(_vh).set_position(_target_state, position); MOBJ(_vh).inc_state(); assert(MOBJ(_vh).state() == _target_state); - + // check if last rule if (Base::number() == Base::n_rules() - 1) { @@ -1247,37 +1247,37 @@ void VV::raise(typename M::VertexHandle& _vh, state_t _target_state) { this->update(_vh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexVertexIter vv_it(Base::mesh_.vv_iter(_vh)); typename M::VertexHandle vh; std::vector vertex_vector; if (_target_state > 1) { - for (; vv_it; ++vv_it) { + for (; vv_it.is_valid(); ++vv_it) { - vertex_vector.push_back(*vv_it); + vertex_vector.push_back(*vv_it); } while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } - for (; vv_it; ++vv_it) { + for (; vv_it.is_valid(); ++vv_it) { - vertex_vector.push_back(*vv_it); + vertex_vector.push_back(*vv_it); } while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } } @@ -1285,7 +1285,7 @@ void VV::raise(typename M::VertexHandle& _vh, state_t _target_state) typename M::Point position(0.0, 0.0, 0.0); int valence(0); - for (vv_it = Base::mesh_.vv_iter(_vh); vv_it; ++vv_it) { + for (vv_it = Base::mesh_.vv_iter(_vh); vv_it.is_valid(); ++vv_it) { ++valence; @@ -1317,37 +1317,37 @@ void VVc::raise(typename M::VertexHandle& _vh, state_t _target_state) this->update(_vh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexVertexIter vv_it(Base::mesh_.vv_iter(_vh)); typename M::VertexHandle vh; std::vector vertex_vector; if (_target_state > 1) { - for (; vv_it; ++vv_it) { + for (; vv_it.is_valid(); ++vv_it) { - vertex_vector.push_back(*vv_it); + vertex_vector.push_back(*vv_it); } while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } - for (; vv_it; ++vv_it) { + for (; vv_it.is_valid(); ++vv_it) { - vertex_vector.push_back(*vv_it); + vertex_vector.push_back(*vv_it); } while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } } @@ -1356,7 +1356,7 @@ void VVc::raise(typename M::VertexHandle& _vh, state_t _target_state) int valence(0); typename M::Scalar c; - for (vv_it = Base::mesh_.vv_iter(_vh); vv_it; ++vv_it) + for (vv_it = Base::mesh_.vv_iter(_vh); vv_it.is_valid(); ++vv_it) { ++valence; position += Base::mesh_.data(vv_it).position(_target_state - 1); @@ -1364,7 +1364,7 @@ void VVc::raise(typename M::VertexHandle& _vh, state_t _target_state) position /= valence; - // choose coefficcient c + // choose coefficient c c = Base::coeff(); position *= (1.0 - c); @@ -1434,10 +1434,10 @@ void VdE::raise(typename M::EdgeHandle& _eh, state_t _target_state) { this->update(_eh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexHandle vh; typename M::HalfedgeHandle hh1(Base::mesh_.HEH(_eh, 0)), - hh2(Base::mesh_.HEH(_eh, 1)); + hh2(Base::mesh_.HEH(_eh, 1)); typename M::FaceHandle fh1, fh2; if (_target_state > 1) { @@ -1447,20 +1447,20 @@ void VdE::raise(typename M::EdgeHandle& _eh, state_t _target_state) if (fh1.is_valid()) { - Base::prev_rule()->raise(fh1, _target_state - 1); + Base::prev_rule()->raise(fh1, _target_state - 1); - vh = Base::mesh_.TVH(Base::mesh_.NHEH(hh1)); - Base::prev_rule()->raise(vh, _target_state - 1); + vh = Base::mesh_.TVH(Base::mesh_.NHEH(hh1)); + Base::prev_rule()->raise(vh, _target_state - 1); } - + if (fh2.is_valid()) { - Base::prev_rule()->raise(fh2, _target_state - 1); + Base::prev_rule()->raise(fh2, _target_state - 1); - vh = Base::mesh_.TVH(Base::mesh_.NHEH(hh2)); - Base::prev_rule()->raise(vh, _target_state - 1); + vh = Base::mesh_.TVH(Base::mesh_.NHEH(hh2)); + Base::prev_rule()->raise(vh, _target_state - 1); } - + vh = Base::mesh_.TVH(hh1); Base::prev_rule()->raise(vh, _target_state - 1); @@ -1510,7 +1510,7 @@ VdEc::raise(typename M::EdgeHandle& _eh, state_t _target_state) { this->update(_eh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexHandle vh; typename M::HalfedgeHandle hh1(Base::mesh_.HEH(_eh, 0)), hh2(Base::mesh_.HEH(_eh, 1)); @@ -1533,10 +1533,10 @@ VdEc::raise(typename M::EdgeHandle& _eh, state_t _target_state) while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } vertex_vector.push_back(Base::mesh_.TVH(hh1)); @@ -1547,10 +1547,10 @@ VdEc::raise(typename M::EdgeHandle& _eh, state_t _target_state) while (!vertex_vector.empty()) { - vh = vertex_vector.back(); - vertex_vector.pop_back(); + vh = vertex_vector.back(); + vertex_vector.pop_back(); - Base::prev_rule()->raise(vh, _target_state - 1); + Base::prev_rule()->raise(vh, _target_state - 1); } } @@ -1586,14 +1586,14 @@ void EV::raise(typename M::VertexHandle& _vh, state_t _target_state) this->update(_vh, _target_state); - // raise all neighbour vertices to level x-1 + // raise all neighbor vertices to level x-1 typename M::VertexEdgeIter ve_it(Base::mesh_.ve_iter(_vh)); typename M::EdgeHandle eh; std::vector edge_vector; if (_target_state > 1) { - for (; ve_it; ++ve_it) { + for (; ve_it.is_valid(); ++ve_it) { edge_vector.push_back(*ve_it); } @@ -1606,7 +1606,7 @@ void EV::raise(typename M::VertexHandle& _vh, state_t _target_state) Base::prev_rule()->raise(eh, _target_state - 1); } - for (ve_it = Base::mesh_.ve_iter(_vh); ve_it; ++ve_it) { + for (ve_it = Base::mesh_.ve_iter(_vh); ve_it.is_valid(); ++ve_it) { edge_vector.push_back(*ve_it); } @@ -1625,7 +1625,7 @@ void EV::raise(typename M::VertexHandle& _vh, state_t _target_state) typename M::Point position(0.0, 0.0, 0.0); int valence(0); - for (ve_it = Base::mesh_.ve_iter(_vh); ve_it; ++ve_it) { + for (ve_it = Base::mesh_.ve_iter(_vh); ve_it.is_valid(); ++ve_it) { if (Base::mesh_.data(ve_it).final()) { @@ -1671,34 +1671,34 @@ void EVc::raise(typename M::VertexHandle& _vh, state_t _target_state) if (_target_state > 1) { - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { - face_vector.push_back(Base::mesh_.FH(*voh_it)); + face_vector.push_back(Base::mesh_.FH(*voh_it)); } while (!face_vector.empty()) { - fh = face_vector.back(); - face_vector.pop_back(); + fh = face_vector.back(); + face_vector.pop_back(); - if (fh.is_valid()) - Base::prev_rule()->raise(fh, _target_state - 1); + if (fh.is_valid()) + Base::prev_rule()->raise(fh, _target_state - 1); } - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) { + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { - edge_vector.push_back(Base::mesh_.EH(*voh_it)); + edge_vector.push_back(Base::mesh_.EH(*voh_it)); - edge_vector.push_back(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))); + edge_vector.push_back(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))); } while (!edge_vector.empty()) { - eh = edge_vector.back(); - edge_vector.pop_back(); + eh = edge_vector.back(); + edge_vector.pop_back(); - while (MOBJ(eh).state() < _target_state - 1) - Base::prev_rule()->raise(eh, _target_state - 1); + while (MOBJ(eh).state() < _target_state - 1) + Base::prev_rule()->raise(eh, _target_state - 1); } } @@ -1712,21 +1712,21 @@ void EVc::raise(typename M::VertexHandle& _vh, state_t _target_state) valence = Base::mesh_.valence(_vh); c = coeff( valence ); - for (voh_it = Base::mesh_.voh_iter(_vh); voh_it; ++voh_it) + for (voh_it = Base::mesh_.voh_iter(_vh); voh_it.is_valid(); ++voh_it) { if (MOBJ(Base::mesh_.EH(*voh_it)).final()) { - position += MOBJ(Base::mesh_.EH(*voh_it)).position(_target_state-1)*c; + position += MOBJ(Base::mesh_.EH(*voh_it)).position(_target_state-1)*c; if ( Base::mesh_.FH(*voh_it).is_valid() && - MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).final() && - MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).position(_target_state - 1) != zero_point) + MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).final() && + MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).position(_target_state - 1) != zero_point) { - position += MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).position(_target_state-1) * (1.0-c); - } - else { - position += MOBJ(Base::mesh_.EH(*voh_it)).position(_target_state - 1) * (1.0 - c); - } + position += MOBJ(Base::mesh_.EH(Base::mesh_.NHEH(*voh_it))).position(_target_state-1) * (1.0-c); + } + else { + position += MOBJ(Base::mesh_.EH(*voh_it)).position(_target_state - 1) * (1.0 - c); + } } else { --valence; @@ -1791,7 +1791,7 @@ EF::raise(typename M::FaceHandle& _fh, state_t _target_state) { if (_target_state > 1) { - for (; fe_it; ++fe_it) { + for (; fe_it.is_valid(); ++fe_it) { edge_vector.push_back(*fe_it); } @@ -1804,7 +1804,7 @@ EF::raise(typename M::FaceHandle& _fh, state_t _target_state) { Base::prev_rule()->raise(eh, _target_state - 1); } - for (fe_it = Base::mesh_.fe_iter(_fh); fe_it; ++fe_it) { + for (fe_it = Base::mesh_.fe_iter(_fh); fe_it.is_valid(); ++fe_it) { edge_vector.push_back(*fe_it); } @@ -1823,7 +1823,7 @@ EF::raise(typename M::FaceHandle& _fh, state_t _target_state) { typename M::Point position(0.0, 0.0, 0.0); int valence(0); - for (fe_it = Base::mesh_.fe_iter(_fh); fe_it; ++fe_it) { + for (fe_it = Base::mesh_.fe_iter(_fh); fe_it.is_valid(); ++fe_it) { if (Base::mesh_.data(fe_it).final()) { @@ -1854,7 +1854,7 @@ FE::raise(typename M::EdgeHandle& _eh, state_t _target_state) { this->update(_eh, _target_state); - // raise all neighbour faces to level x-1 + // raise all neighbor faces to level x-1 typename M::FaceHandle fh; if (_target_state > 1) { @@ -1899,7 +1899,7 @@ EdE::raise(typename M::EdgeHandle& _eh, state_t _target_state) { this->update(_eh, _target_state); - // raise all neighbour faces and edges to level x-1 + // raise all neighbor faces and edges to level x-1 typename M::HalfedgeHandle hh1, hh2; typename M::FaceHandle fh; typename M::EdgeHandle eh; @@ -1956,7 +1956,7 @@ EdEc::raise(typename M::EdgeHandle& _eh, state_t _target_state) this->update(_eh, _target_state); - // raise all neighbour faces and edges to level x-1 + // raise all neighbor faces and edges to level x-1 typename M::HalfedgeHandle hh1, hh2; typename M::FaceHandle fh; typename M::EdgeHandle eh; diff --git a/src/OpenMesh/Tools/Subdivider/Uniform/Sqrt3T.hh b/src/OpenMesh/Tools/Subdivider/Uniform/Sqrt3T.hh index 669f4906..deb48da5 100644 --- a/src/OpenMesh/Tools/Subdivider/Uniform/Sqrt3T.hh +++ b/src/OpenMesh/Tools/Subdivider/Uniform/Sqrt3T.hh @@ -215,7 +215,7 @@ protected: size_t valence=0; pos = zero; - for ( vvit = _m.vv_iter(vit); vvit; ++vvit) + for ( vvit = _m.vv_iter(vit); vvit.is_valid(); ++vvit) { pos += _m.point( vvit ); ++valence; @@ -232,12 +232,12 @@ protected: { if ( (gen%2) && _m.is_boundary(fit)) { - boundary_split( _m, fit ); + boundary_split( _m, *fit ); } else { - fvit = _m.fv_iter( fit ); - pos = _m.point( fvit); + fvit = _m.fv_iter( *fit ); + pos = _m.point( *fvit); pos += _m.point(++fvit); pos += _m.point(++fvit); pos *= _1over3;