openmesh: CompositeT.cc Source File

00001 /*===========================================================================*\
00002  *                                                                           *
00003  *                               OpenMesh                                    *
00004  *      Copyright (C) 2001-2011 by Computer Graphics Group, RWTH Aachen      *
00005  *                           www.openmesh.org                                *
00006  *                                                                           *
00007  *---------------------------------------------------------------------------* 
00008  *  This file is part of OpenMesh.                                           *
00009  *                                                                           *
00010  *  OpenMesh is free software: you can redistribute it and/or modify         * 
00011  *  it under the terms of the GNU Lesser General Public License as           *
00012  *  published by the Free Software Foundation, either version 3 of           *
00013  *  the License, or (at your option) any later version with the              *
00014  *  following exceptions:                                                    *
00015  *                                                                           *
00016  *  If other files instantiate templates or use macros                       *
00017  *  or inline functions from this file, or you compile this file and         *
00018  *  link it with other files to produce an executable, this file does        *
00019  *  not by itself cause the resulting executable to be covered by the        *
00020  *  GNU Lesser General Public License. This exception does not however       *
00021  *  invalidate any other reasons why the executable file might be            *
00022  *  covered by the GNU Lesser General Public License.                        *
00023  *                                                                           *
00024  *  OpenMesh is distributed in the hope that it will be useful,              *
00025  *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
00026  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
00027  *  GNU Lesser General Public License for more details.                      *
00028  *                                                                           *
00029  *  You should have received a copy of the GNU LesserGeneral Public          *
00030  *  License along with OpenMesh.  If not,                                    *
00031  *  see <http://www.gnu.org/licenses/>.                                      *
00032  *                                                                           *
00033 \*===========================================================================*/ 
00034 
00035 /*===========================================================================*\
00036  *                                                                           *             
00037  *   $Revision: 362 $                                                         *
00038  *   $Date: 2011-01-26 10:21:12 +0100 (Mi, 26 Jan 2011) $                   *
00039  *                                                                           *
00040 \*===========================================================================*/
00041 
00046 //=============================================================================
00047 //
00048 //  CLASS CompositeT - IMPLEMENTATION
00049 //
00050 //=============================================================================
00051 
00052 #ifndef OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC
00053 #define OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC
00054 
00055 
00056 //== INCLUDES =================================================================
00057 
00058 
00059 #include <vector>
00060 #include <OpenMesh/Tools/Subdivider/Uniform/Composite/CompositeT.hh>
00061 
00062 
00063 //== NAMESPACE ================================================================
00064 
00065 namespace OpenMesh   { // BEGIN_NS_OPENMESH
00066 namespace Subdivider { // BEGIN_NS_DECIMATER
00067 namespace Uniform    { // BEGIN_NS_UNIFORM
00068 
00069 
00070 //== IMPLEMENTATION ==========================================================
00071 
00072 
00073 template <typename MeshType, typename RealType>
00074 bool CompositeT<MeshType,RealType>::prepare( MeshType& _m )
00075 {
00076   // store mesh for later usage in subdivide(), cleanup() and all rules.
00077   p_mesh_ = &_m;
00078 
00079   typename MeshType::VertexIter v_it(_m.vertices_begin());
00080 
00081   for (; v_it != _m.vertices_end(); ++v_it)
00082     _m.data(v_it).set_position(_m.point(v_it.handle()));
00083 
00084   return true;
00085 }
00086 
00087 
00088 
00089 template<typename MeshType, typename RealType>
00090 void CompositeT<MeshType,RealType>::Tvv3()
00091 {
00092   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00093 
00094   typename MeshType::VertexHandle vh;
00095   typename MeshType::FaceIter     f_it;
00096   typename MeshType::EdgeIter     e_it;
00097   typename MeshType::VertexIter   v_it;
00098   typename MeshType::Point        zero_point(0.0, 0.0, 0.0);
00099   size_t                          n_edges, n_faces, n_vertices, j;
00100 
00101   // Store number of original edges
00102   n_faces    = mesh_.n_faces();
00103   n_edges    = mesh_.n_edges();
00104   n_vertices = mesh_.n_vertices();
00105 
00106   // reserve enough memory for iterator
00107   mesh_.reserve(n_vertices + n_faces, n_edges + 3 * n_faces, 3 * n_faces);
00108 
00109   // set new positions for vertices
00110   v_it = mesh_.vertices_begin();
00111   for (j = 0; j < n_vertices; ++j) {
00112     mesh_.data(v_it).set_position(mesh_.data(v_it).position() * 3.0);
00113     ++v_it;
00114   }
00115 
00116   // Split each face
00117   f_it = mesh_.faces_begin();
00118   for (j = 0; j < n_faces; ++j) {
00119 
00120     vh = mesh_.add_vertex(zero_point);
00121 
00122     mesh_.data(vh).set_position(zero_point);
00123 
00124     mesh_.split(f_it.handle(), vh);
00125 
00126     ++f_it;
00127   }
00128 
00129   // Flip each old edge
00130   std::vector<typename MeshType::EdgeHandle> edge_vector;
00131   edge_vector.clear();
00132 
00133   e_it = mesh_.edges_begin();
00134   for (j = 0; j < n_edges; ++j) {
00135     if (mesh_.is_flip_ok(e_it.handle())) {
00136       mesh_.flip(e_it.handle());
00137     } else {
00138       edge_vector.push_back(e_it.handle());
00139     }
00140     ++e_it;
00141   }
00142 
00143   // split all boundary edges
00144   while (!edge_vector.empty()) {
00145     vh = mesh_.add_vertex(zero_point);
00146     mesh_.data(vh).set_position(zero_point);
00147     mesh_.split(edge_vector.back(), vh);
00148     edge_vector.pop_back();
00149   }
00150 }
00151 
00152 
00153 template<typename MeshType, typename RealType>
00154 void CompositeT<MeshType,RealType>::Tvv4()
00155 {
00156   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00157 
00158   typename MeshType::VertexHandle     vh;
00159   typename MeshType::FaceIter         f_it;
00160   typename MeshType::EdgeIter         e_it;
00161   typename MeshType::VertexIter       v_it;
00162   typename MeshType::Point            zero_point(0.0, 0.0, 0.0);
00163   unsigned int                    n_edges, n_faces, n_vertices, j;
00164 
00165   // Store number of original edges
00166   n_faces    = mesh_.n_faces();
00167   n_edges    = mesh_.n_edges();
00168   n_vertices = mesh_.n_vertices();
00169 
00170   // reserve memory ahead for the succeeding operations
00171   mesh_.reserve(n_vertices + n_edges, 2 * n_edges + 3 * n_faces, 4 * n_faces);
00172 
00173   // set new positions for vertices
00174   v_it = mesh_.vertices_begin();
00175   for (j = 0; j < n_vertices; ++j) {
00176     mesh_.data(v_it).set_position(mesh_.data(v_it).position() * 4.0);
00177     ++v_it;
00178   }
00179 
00180   // Split each edge
00181   e_it = mesh_.edges_begin();
00182   for (j = 0; j < n_edges; ++j) {
00183 
00184     vh = split_edge(mesh_.halfedge_handle(e_it.handle(), 0));
00185     mesh_.data(vh).set_position(zero_point);
00186 
00187     ++e_it;
00188   }
00189 
00190   // Corner Cutting of Each Face
00191   f_it = mesh_.faces_begin();
00192   for (j = 0; j < n_faces; ++j) {
00193     typename MeshType::HalfedgeHandle heh1(mesh_.halfedge_handle(f_it.handle()));
00194     typename MeshType::HalfedgeHandle heh2(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh1)));
00195     typename MeshType::HalfedgeHandle heh3(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh2)));
00196 
00197     // Cutting off every corner of the 6_gon
00198 
00199     corner_cutting(heh1);
00200     corner_cutting(heh2);
00201     corner_cutting(heh3);
00202 
00203     ++f_it;
00204   }
00205 }
00206 
00207 
00208 template<typename MeshType, typename RealType>
00209 void CompositeT<MeshType,RealType>::Tfv()
00210 {
00211   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00212 
00213   typename MeshType::VertexHandle     vh;
00214   typename MeshType::FaceIter         f_it;
00215   typename MeshType::EdgeIter         e_it;
00216   typename MeshType::VertexIter       v_it;
00217   typename MeshType::VertexFaceIter   vf_it;
00218   typename MeshType::FaceFaceIter     ff_it;
00219   typename MeshType::Point            cog;
00220   const typename MeshType::Point      zero_point(0.0, 0.0, 0.0);
00221   unsigned int                    n_edges, n_faces, n_vertices, j, valence;
00222 
00223   // Store number of original edges
00224   n_faces = mesh_.n_faces();
00225   n_edges = mesh_.n_edges();
00226   n_vertices = mesh_.n_vertices();
00227 
00228   // reserve enough space for iterator
00229   mesh_.reserve(n_vertices + n_faces, n_edges + 3 * n_faces, 3 * n_faces);
00230 
00231   // set new positions for vertices
00232   v_it = mesh_.vertices_begin();
00233   for (j = 0; j < n_vertices; ++j) {
00234     valence = 0;
00235     cog = zero_point;
00236     for (vf_it = mesh_.vf_iter(v_it.handle()); vf_it; ++vf_it) {
00237       ++valence;
00238       cog += vf_it->position();
00239     }
00240     cog /= valence;
00241 
00242     v_it->set_position(cog);
00243     ++v_it;
00244   }
00245 
00246   // Split each face, insert new vertex and calculate position
00247   f_it = mesh_.faces_begin();
00248   for (j = 0; j < n_faces; ++j) {
00249 
00250     vh = mesh_.add_vertex();
00251 
00252     valence = 0;
00253     cog = zero_point;
00254     for (ff_it = mesh_.ff_iter(f_it.handle()); ff_it; ++ff_it) {
00255       ++valence;
00256       cog += ff_it->position();
00257     }
00258     cog /= valence;
00259 
00260     mesh_.split(f_it.handle(), vh);
00261 
00262     for (vf_it = mesh_.vf_iter(vh); vf_it; ++vf_it) {
00263       vf_it->set_position(f_it->position());
00264     }
00265 
00266     mesh_.deref(vh).set_position(cog);
00267 
00268     mesh_.set_point(vh, cog);
00269 
00270     ++f_it;
00271   }
00272 
00273   // Flip each old edge
00274   e_it = mesh_.edges_begin();
00275   for (j = 0; j < n_edges; ++j) {
00276     if (mesh_.is_flip_ok(e_it.handle()))
00277       mesh_.flip(e_it.handle());
00278     ++e_it;
00279   }
00280 }
00281 
00282 
00283 
00284 template<typename MeshType, typename RealType>
00285 void CompositeT<MeshType,RealType>::VF()
00286 {
00287   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00288 
00289   unsigned int                  valence;
00290   typename MeshType::Point          cog,
00291                                 zero_point(0.0, 0.0, 0.0);
00292   typename MeshType::FaceVertexIter fv_it;
00293   typename MeshType::FaceIter       f_it;
00294 
00295   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00296 
00297     valence = 0;
00298     cog = zero_point;
00299 
00300     for (fv_it = mesh_.fv_iter(f_it.handle()); fv_it; ++fv_it) {
00301       cog += mesh_.data(fv_it).position();
00302       ++valence;
00303     }
00304     cog /= valence;
00305     mesh_.data(f_it).set_position(cog);
00306   }
00307 }
00308 
00309 
00310 template<typename MeshType, typename RealType>
00311 void CompositeT<MeshType,RealType>::VFa(Coeff& _coeff)
00312 {
00313   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00314 
00315   unsigned int                        valence[3], i;
00316   typename MeshType::Point                cog,
00317                                       zero_point(0.0, 0.0, 0.0);
00318   typename MeshType::Scalar               alpha;
00319   typename MeshType::FaceIter             f_it;
00320   typename MeshType::HalfedgeHandle       heh;
00321   typename MeshType::VertexHandle         vh[3];
00322   typename MeshType::VertexOHalfedgeIter  voh_it;
00323   typename MeshType::FaceVertexIter       fv_it;
00324 
00325   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00326 
00327     heh = mesh_.halfedge_handle(f_it.handle());
00328     for (i = 0; i <= 2; ++i) {
00329 
00330       valence[i] = 0;
00331       vh[i] = mesh_.to_vertex_handle(heh);
00332 
00333       for (voh_it = mesh_.voh_iter(vh[i]); voh_it; ++voh_it) {
00334   ++valence[i];
00335       }
00336 
00337       heh = mesh_.next_halfedge_handle(heh);
00338     }
00339 
00340     if (valence[0] <= valence[1])
00341       if (valence[0] <= valence[2])
00342   i = 0;
00343       else
00344   i = 2;
00345     else
00346       if (valence[1] <= valence[2])
00347   i = 1;
00348       else
00349   i = 2;
00350 
00351     alpha = _coeff(valence[i]);
00352 
00353     cog = zero_point;
00354 
00355     for (fv_it = mesh_.fv_iter(f_it.handle()); fv_it; ++fv_it) {
00356       if (fv_it.handle() == vh[i]) {
00357   cog += fv_it->position() * alpha;
00358       } else {
00359   cog += fv_it->position() * (1.0 - alpha) / 2.0;
00360       }
00361     }
00362 
00363     f_it->set_position(cog);
00364   }
00365 }
00366 
00367 
00368 template<typename MeshType, typename RealType>
00369 void CompositeT<MeshType,RealType>::VFa(scalar_t _alpha)
00370 {
00371   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00372 
00373   unsigned int                        valence[3], i;
00374   typename MeshType::Point                cog,
00375                                       zero_point(0.0, 0.0, 0.0);
00376   typename MeshType::FaceIter             f_it;
00377   typename MeshType::HalfedgeHandle       heh;
00378   typename MeshType::VertexHandle         vh[3];
00379   typename MeshType::VertexOHalfedgeIter  voh_it;
00380   typename MeshType::FaceVertexIter       fv_it;
00381 
00382   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00383 
00384     heh = mesh_.halfedge_handle(f_it.handle());
00385     for (i = 0; i <= 2; ++i) {
00386 
00387       valence[i] = 0;
00388       vh[i] = mesh_.to_vertex_handle(heh);
00389 
00390       for (voh_it = mesh_.voh_iter(vh[i]); voh_it; ++voh_it) {
00391   ++valence[i];
00392       }
00393 
00394       heh = mesh_.next_halfedge_handle(heh);
00395     }
00396 
00397     if (valence[0] <= valence[1])
00398       if (valence[0] <= valence[2])
00399   i = 0;
00400       else
00401   i = 2;
00402     else
00403       if (valence[1] <= valence[2])
00404   i = 1;
00405       else
00406   i = 2;
00407 
00408     cog = zero_point;
00409 
00410     for (fv_it = mesh_.fv_iter(f_it.handle()); fv_it; ++fv_it) {
00411       if (fv_it.handle() == vh[i]) {
00412   cog += fv_it->position() * _alpha;
00413       } else {
00414   cog += fv_it->position() * (1.0 - _alpha) / 2.0;
00415       }
00416     }
00417 
00418     f_it->set_position(cog);
00419   }
00420 }
00421 
00422 
00423 template<typename MeshType, typename RealType>
00424 void CompositeT<MeshType,RealType>::FF()
00425 {
00426   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00427 
00428   unsigned int valence;
00429   typename MeshType::Point              cog,
00430                                     zero_point(0.0, 0.0, 0.0);
00431   typename MeshType::FaceFaceIter       ff_it;
00432   typename MeshType::FaceIter           f_it;
00433   std::vector<typename MeshType::Point> point_vector;
00434 
00435   point_vector.clear();
00436 
00437   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it)
00438   {
00439     valence = 0;
00440     cog = zero_point;
00441 
00442     for (ff_it = mesh_.ff_iter(f_it.handle()); ff_it; ++ff_it)
00443     {
00444       cog += mesh_.data(ff_it).position();
00445       ++valence;
00446     }
00447     cog /= valence;
00448     point_vector.push_back(cog);
00449   }
00450 
00451   for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); )
00452   {
00453     --f_it;
00454     mesh_.data(f_it).set_position(point_vector.back());
00455     point_vector.pop_back();
00456   }
00457 }
00458 
00459 
00460 template<typename MeshType, typename RealType>
00461 void CompositeT<MeshType,RealType>::FFc(Coeff& _coeff)
00462 {
00463   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00464 
00465   unsigned int                   valence;
00466   typename MeshType::Point           cog,
00467                                  zero_point(0.0, 0.0, 0.0);
00468   typename MeshType::FaceFaceIter    ff_it;
00469   typename MeshType::FaceIter        f_it;
00470   typename MeshType::Scalar          c;
00471   std::vector<typename MeshType::Point> point_vector;
00472 
00473   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00474 
00475     valence = 0;
00476     cog = zero_point;
00477 
00478     for (ff_it = mesh_.ff_iter(f_it.handle()); ff_it; ++ff_it) {
00479       cog += ff_it->position();
00480       ++valence;
00481     }
00482     cog /= valence;
00483 
00484     c = _coeff(valence);
00485 
00486     cog = cog * (1.0 - c) + f_it->position() * c;
00487 
00488     point_vector.push_back(cog);
00489 
00490   }
00491   for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); ) {
00492 
00493     --f_it;
00494     f_it->set_position(point_vector.back());
00495     point_vector.pop_back();
00496 
00497   }
00498 }
00499 
00500 
00501 template<typename MeshType, typename RealType>
00502 void CompositeT<MeshType,RealType>::FFc(scalar_t _c)
00503 {
00504   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00505 
00506   unsigned int                   valence;
00507   typename MeshType::Point           cog,
00508     zero_point(0.0, 0.0, 0.0);
00509   typename MeshType::FaceFaceIter    ff_it;
00510   typename MeshType::FaceIter        f_it;
00511   std::vector<typename MeshType::Point> point_vector;
00512 
00513   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00514 
00515     valence = 0;
00516     cog = zero_point;
00517 
00518     for (ff_it = mesh_.ff_iter(f_it.handle()); ff_it; ++ff_it) {
00519       cog += ff_it->position();
00520       ++valence;
00521     }
00522     cog /= valence;
00523 
00524     cog = cog * (1.0 - _c) + f_it->position() * _c;
00525 
00526     point_vector.push_back(cog);
00527 
00528   }
00529   for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); ) {
00530 
00531     --f_it;
00532     f_it->set_position(point_vector.back());
00533     point_vector.pop_back();
00534   }
00535 }
00536 
00537 
00538 template<typename MeshType, typename RealType>
00539 void CompositeT<MeshType,RealType>::FV()
00540 {
00541   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00542 
00543   unsigned int                  valence;
00544   typename MeshType::Point          cog,
00545                                 zero_point(0.0, 0.0, 0.0);
00546   typename MeshType::VertexFaceIter vf_it;
00547   typename MeshType::VertexIter     v_it;
00548 
00549   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
00550 
00551     valence = 0;
00552     cog = zero_point;
00553 
00554     for (vf_it = mesh_.vf_iter(v_it.handle()); vf_it; ++vf_it) {
00555       cog += vf_it->position();
00556       ++valence;
00557     }
00558     cog /= valence;
00559     v_it->set_position(cog);
00560   }
00561 }
00562 
00563 
00564 template<typename MeshType, typename RealType>
00565 void CompositeT<MeshType,RealType>::FVc(Coeff& _coeff)
00566 {
00567   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00568 
00569   unsigned int                        valence;
00570   typename MeshType::Point                cog,
00571                                       zero_point(0.0, 0.0, 0.0);
00572   scalar_t               c;
00573   typename MeshType::VertexOHalfedgeIter  voh_it;
00574   typename MeshType::VertexIter           v_it;
00575 
00576   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
00577 
00578     valence = 0;
00579     cog = zero_point;
00580 
00581     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00582       ++valence;
00583     }
00584 
00585     c = _coeff(valence);
00586 
00587     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00588 
00589       if (mesh_.face_handle(voh_it.handle()).is_valid()) {
00590 
00591   if (mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(voh_it.handle()))).is_valid()) {
00592     cog += mesh_.data(mesh_.face_handle(voh_it.handle())).position() * c;
00593     cog += mesh_.data(mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(voh_it.handle())))).position() * (1.0 - c);
00594   } else {
00595     cog += mesh_.data(mesh_.face_handle(voh_it.handle())).position();
00596   }
00597       } else {
00598   --valence;
00599       }
00600     }
00601 
00602     if (valence > 0)
00603       cog /= valence;
00604 
00605     mesh_.data(v_it).set_position(cog);
00606   }
00607 }
00608 
00609 
00610 template<typename MeshType, typename RealType>
00611 void CompositeT<MeshType,RealType>::FVc(scalar_t _c)
00612 {
00613   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00614 
00615   unsigned int                       valence;
00616   typename MeshType::Point               cog,
00617                                      zero_point(0.0, 0.0, 0.0);
00618   typename MeshType::VertexOHalfedgeIter voh_it;
00619   typename MeshType::VertexIter          v_it;
00620 
00621   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
00622 
00623     valence = 0;
00624     cog = zero_point;
00625 
00626     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00627       ++valence;
00628     }
00629 
00630     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00631 
00632       if (mesh_.face_handle(voh_it.handle()).is_valid()) {
00633 
00634   if (mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(voh_it.handle()))).is_valid()) {
00635     cog += mesh_.deref(mesh_.face_handle(voh_it.handle())).position() * _c;
00636     cog += mesh_.deref(mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(voh_it.handle())))).position() * (1.0 - _c);
00637   } else {
00638     cog += mesh_.deref(mesh_.face_handle(voh_it.handle())).position();
00639   }
00640       } else {
00641   --valence;
00642       }
00643     }
00644 
00645     if (valence > 0)
00646       cog /= valence;
00647 
00648     v_it->set_position(cog);
00649   }
00650 }
00651 
00652 
00653 template<typename MeshType, typename RealType>
00654 void CompositeT<MeshType,RealType>::VdE()
00655 {
00656   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00657 
00658   typename MeshType::EdgeIter             e_it;
00659   typename MeshType::Point                cog,
00660                                       zero_point(0.0, 0.0, 0.0);
00661   typename MeshType::HalfedgeHandle       heh1, heh2;
00662   unsigned int                        valence;
00663 
00664   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
00665 
00666     cog = zero_point;
00667     valence = 2;
00668 
00669     heh1 = mesh_.halfedge_handle(e_it.handle(), 0);
00670     heh2 = mesh_.opposite_halfedge_handle(heh1);
00671     cog += mesh_.data(mesh_.to_vertex_handle(heh1)).position();
00672     cog += mesh_.data(mesh_.to_vertex_handle(heh2)).position();
00673 
00674     if (!mesh_.is_boundary(heh1)) {
00675       cog += mesh_.data(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh1))).position();
00676       ++valence;
00677     }
00678 
00679     if (!mesh_.is_boundary(heh2)) {
00680       cog += mesh_.data(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh2))).position();
00681       ++valence;
00682     }
00683 
00684     cog /= valence;
00685 
00686     mesh_.data(e_it).set_position(cog);
00687   }
00688 }
00689 
00690 
00691 template<typename MeshType, typename RealType>
00692 void CompositeT<MeshType,RealType>::VdEc(scalar_t _c)
00693 {
00694   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00695 
00696   typename MeshType::EdgeIter           e_it;
00697   typename MeshType::Point              cog,
00698                                     zero_point(0.0, 0.0, 0.0);
00699   typename MeshType::HalfedgeHandle     heh;
00700 
00701   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
00702 
00703     cog = zero_point;
00704 
00705     for (int i = 0; i <= 1; ++i) {
00706 
00707       heh = mesh_.halfedge_handle(e_it.handle(), i);
00708       if (!mesh_.is_boundary(heh))
00709       {
00710         cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (0.5 - _c);
00711         cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * _c;
00712       }
00713       else
00714       {
00715         cog += mesh_.data(mesh_.to_vertex_handle(heh)).position();
00716       }
00717     }
00718 
00719     mesh_.data(e_it).set_position(cog);
00720   }
00721 }
00722 
00723 
00724 template<typename MeshType, typename RealType>
00725 void CompositeT<MeshType,RealType>::VdEg(scalar_t _gamma)
00726 {
00727   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00728 
00729   typename MeshType::EdgeIter             e_it;
00730   typename MeshType::Point                cog,
00731                                       zero_point(0.0, 0.0, 0.0);
00732   typename MeshType::HalfedgeHandle       heh;
00733   typename MeshType::VertexOHalfedgeIter  voh_it;
00734   unsigned int                        valence[2], i;
00735 
00736   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
00737 
00738     cog = zero_point;
00739 
00740     for (i = 0; i <= 1; ++i)
00741     {
00742       heh = mesh_.halfedge_handle(e_it.handle(), i);
00743       valence[i] = 0;
00744 
00745       // look for lowest valence vertex
00746       for (voh_it = mesh_.voh_iter(mesh_.to_vertex_handle(heh)); voh_it; ++voh_it)
00747       {
00748         ++valence[i];
00749       }
00750     }
00751 
00752     if (valence[0] < valence[1])
00753       i = 0;
00754     else
00755       i = 1;
00756 
00757     heh = mesh_.halfedge_handle(e_it.handle(), i);
00758 
00759     if (!mesh_.is_boundary(heh)) {
00760       cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (_gamma);
00761       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 3.0 * _gamma);
00762     } else {
00763       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 2.0 * _gamma);
00764     }
00765 
00766 
00767     heh = mesh_.halfedge_handle(e_it.handle(), 1-i);
00768 
00769     if (!mesh_.is_boundary(heh))
00770     {
00771       cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (_gamma);
00772       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * _gamma;
00773     }
00774     else
00775     {
00776       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * 2.0 * _gamma;
00777     }
00778 
00779     mesh_.data(e_it).set_position(cog);
00780   }
00781 }
00782 
00783 
00784 template<typename MeshType, typename RealType>
00785 void CompositeT<MeshType,RealType>::VdEg(Coeff& _coeff)
00786 {
00787   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00788 
00789   typename MeshType::EdgeIter             e_it;
00790   typename MeshType::Point                cog,
00791                                       zero_point(0.0, 0.0, 0.0);
00792   typename MeshType::HalfedgeHandle       heh;
00793   typename MeshType::VertexOHalfedgeIter  voh_it;
00794   unsigned int                        valence[2], i;
00795   scalar_t               gamma;
00796 
00797   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
00798 
00799     cog = zero_point;
00800 
00801     for (i = 0; i <= 1; ++i) {
00802 
00803       heh = mesh_.halfedge_handle(e_it.handle(), i);
00804       valence[i] = 0;
00805 
00806       // look for lowest valence vertex
00807       for (voh_it = mesh_.voh_iter(mesh_.to_vertex_handle(heh)); voh_it; ++voh_it)
00808       {
00809         ++valence[i];
00810       }
00811     }
00812 
00813     if (valence[0] < valence[1])
00814       i = 0;
00815     else
00816       i = 1;
00817 
00818     gamma = _coeff(valence[i]);
00819 
00820     heh = mesh_.halfedge_handle(e_it.handle(), i);
00821 
00822     if (!mesh_.is_boundary(heh))
00823     {
00824       cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (gamma);
00825       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 3.0 * gamma);
00826     }
00827     else
00828     {
00829       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 2.0 * gamma);
00830     }
00831 
00832 
00833     heh = mesh_.halfedge_handle(e_it.handle(), 1-i);
00834 
00835     if (!mesh_.is_boundary(heh)) {
00836       cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (gamma);
00837       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * gamma;
00838     } else {
00839       cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * 2.0 * gamma;
00840     }
00841 
00842     mesh_.data(e_it).set_position(cog);
00843   }
00844 }
00845 
00846 
00847 template<typename MeshType, typename RealType>
00848 void CompositeT<MeshType,RealType>::EV()
00849 {
00850   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00851 
00852   typename MeshType::VertexIter       v_it;
00853   typename MeshType::Point            cog,
00854                                   zero_point(0.0, 0.0, 0.0);
00855   unsigned int                    valence;
00856   typename MeshType::VertexEdgeIter   ve_it;
00857 
00858   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
00859   {
00860     valence = 0;
00861     cog = zero_point;
00862 
00863     for (ve_it = mesh_.ve_iter(v_it.handle()); ve_it; ++ve_it) {
00864       cog += mesh_.data(ve_it).position();
00865       ++valence;
00866     }
00867 
00868     cog /= valence;
00869 
00870     mesh_.data(v_it).set_position(cog);
00871   }
00872 }
00873 
00874 
00875 template<typename MeshType, typename RealType>
00876 void CompositeT<MeshType,RealType>::EVc(Coeff& _coeff)
00877 {
00878   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00879 
00880   typename MeshType::VertexIter            v_it;
00881   typename MeshType::Point                 cog,
00882                                        zero_point(0.0, 0.0, 0.0);
00883   unsigned int                         valence;
00884   typename MeshType::VertexOHalfedgeIter   voh_it;
00885   scalar_t                c;
00886 
00887   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
00888   {
00889     valence = 0;
00890     cog = zero_point;
00891 
00892     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it)
00893     {
00894       ++valence;
00895     }
00896 
00897     c = _coeff(valence);
00898 
00899     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00900       cog += mesh_.data(mesh_.edge_handle(voh_it.handle())).position() * c;
00901       cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(voh_it.handle()))).position() * (1.0 - c);
00902     }
00903 
00904     cog /= valence;
00905 
00906     mesh_.data(v_it).set_position(cog);
00907   }
00908 }
00909 
00910 
00911 template<typename MeshType, typename RealType>
00912 void CompositeT<MeshType,RealType>::EVc(scalar_t _c)
00913 {
00914   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00915   typename MeshType::VertexIter           v_it;
00916   typename MeshType::Point                cog,
00917                                       zero_point(0.0, 0.0, 0.0);
00918   unsigned int                        valence;
00919   typename MeshType::VertexOHalfedgeIter  voh_it;
00920 
00921   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
00922     valence = 0;
00923     cog = zero_point;
00924 
00925     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00926       ++valence;
00927     }
00928 
00929     for (voh_it = mesh_.voh_iter(v_it.handle()); voh_it; ++voh_it) {
00930       cog += mesh_.data(mesh_.edge_handle(voh_it.handle())).position() * _c;
00931       cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(voh_it.handle()))).position() * (1.0 - _c);
00932     }
00933 
00934     cog /= valence;
00935 
00936     mesh_.data(v_it).set_position(cog);
00937   }
00938 }
00939 
00940 
00941 template<typename MeshType, typename RealType>
00942 void CompositeT<MeshType,RealType>::EF()
00943 {
00944   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00945 
00946   typename MeshType::FaceIter         f_it;
00947   typename MeshType::FaceEdgeIter     fe_it;
00948   unsigned int                    valence;
00949   typename MeshType::Point            cog,
00950                                   zero_point(0.0, 0.0, 0.0);
00951 
00952   for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
00953     valence = 0;
00954     cog = zero_point;
00955 
00956     for (fe_it = mesh_.fe_iter(f_it.handle()); fe_it; ++fe_it) {
00957       ++valence;
00958       cog += mesh_.data(fe_it).position();
00959     }
00960 
00961     cog /= valence;
00962     mesh_.data(f_it).set_position(cog);
00963   }
00964 }
00965 
00966 
00967 template<typename MeshType, typename RealType>
00968 void CompositeT<MeshType,RealType>::FE()
00969 {
00970   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
00971 
00972   typename MeshType::EdgeIter       e_it;
00973   unsigned int                  valence;
00974   typename MeshType::Point          cog,
00975                                 zero_point(0.0, 0.0, 0.0);
00976 
00977   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
00978     valence = 0;
00979     cog = zero_point;
00980 
00981     if (mesh_.face_handle(mesh_.halfedge_handle(e_it.handle(), 0)).is_valid()) {
00982       cog += mesh_.data(mesh_.face_handle(mesh_.halfedge_handle(e_it.handle(), 0))).position();
00983       ++valence;
00984     }
00985 
00986     if (mesh_.face_handle(mesh_.halfedge_handle(e_it.handle(), 1)).is_valid()) {
00987       cog += mesh_.data(mesh_.face_handle(mesh_.halfedge_handle(e_it.handle(), 1))).position();
00988       ++valence;
00989     }
00990 
00991     cog /= valence;
00992     mesh_.data(e_it).set_position(cog);
00993   }
00994 }
00995 
00996 
00997 template<typename MeshType, typename RealType>
00998 void CompositeT<MeshType,RealType>::VE()
00999 {
01000   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01001 
01002   typename MeshType::EdgeIter      e_it;
01003   typename MeshType::Point         cog;
01004 
01005   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it)
01006   {
01007     cog = mesh_.data(mesh_.to_vertex_handle(mesh_.halfedge_handle(e_it.handle(), 0))).position();
01008     cog += mesh_.data(mesh_.to_vertex_handle(mesh_.halfedge_handle(e_it.handle(), 1))).position();
01009     cog /= 2.0;
01010     mesh_.data(e_it).set_position(cog);
01011   }
01012 }
01013 
01014 
01015 template<typename MeshType, typename RealType>
01016 void CompositeT<MeshType,RealType>::VV()
01017 {
01018   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01019 
01020   unsigned int                        valence;
01021   typename MeshType::Point                cog,
01022                                       zero_point(0.0, 0.0, 0.0);
01023   typename MeshType::VertexVertexIter     vv_it;
01024   typename MeshType::VertexIter           v_it;
01025   std::vector<typename MeshType::Point>   point_vector;
01026 
01027   point_vector.clear();
01028 
01029   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
01030 
01031     valence = 0;
01032     cog = zero_point;
01033 
01034     for (vv_it = mesh_.vv_iter(v_it.handle()); vv_it; ++vv_it) {
01035       cog += vv_it->position();
01036       ++valence;
01037     }
01038     cog /= valence;
01039     point_vector.push_back(cog);
01040   }
01041 
01042   for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); )
01043   {
01044     --v_it;
01045     mesh_.data(v_it).set_position(point_vector.back());
01046     point_vector.pop_back();
01047   }
01048 }
01049 
01050 
01051 template<typename MeshType, typename RealType>
01052 void CompositeT<MeshType,RealType>::VVc(Coeff& _coeff)
01053 {
01054   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01055 
01056   unsigned int                      valence;
01057   typename MeshType::Point              cog,
01058                                     zero_point(0.0, 0.0, 0.0);
01059   typename MeshType::VertexVertexIter   vv_it;
01060   typename MeshType::VertexIter         v_it;
01061   scalar_t             c;
01062   std::vector<typename MeshType::Point> point_vector;
01063 
01064   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
01065   {
01066     valence = 0;
01067     cog = zero_point;
01068 
01069     for (vv_it = mesh_.vv_iter(v_it.handle()); vv_it; ++vv_it)
01070     {
01071       cog += vv_it->position();
01072       ++valence;
01073     }
01074     cog /= valence;
01075     c = _coeff(valence);
01076     cog = cog * (1 - c) + mesh_.data(v_it).position() * c;
01077     point_vector.push_back(cog);
01078   }
01079   for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); )
01080   {
01081     --v_it;
01082     mesh_.data(v_it).set_position(point_vector.back());
01083     point_vector.pop_back();
01084   }
01085 }
01086 
01087 
01088 template<typename MeshType, typename RealType>
01089 void CompositeT<MeshType,RealType>::VVc(scalar_t _c)
01090 {
01091   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01092 
01093   unsigned int                      valence;
01094   typename MeshType::Point              cog,
01095                                     zero_point(0.0, 0.0, 0.0);
01096   typename MeshType::VertexVertexIter   vv_it;
01097   typename MeshType::VertexIter         v_it;
01098   std::vector<typename MeshType::Point> point_vector;
01099 
01100   for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
01101 
01102     valence = 0;
01103     cog = zero_point;
01104 
01105     for (vv_it = mesh_.vv_iter(v_it.handle()); vv_it; ++vv_it) {
01106       cog += mesh_.data(vv_it).position();
01107       ++valence;
01108     }
01109     cog /= valence;
01110 
01111     cog = cog * (1.0 - _c) + v_it->position() * _c;
01112 
01113     point_vector.push_back(cog);
01114 
01115   }
01116   for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); ) {
01117 
01118     --v_it;
01119     mesh_.data(v_it).set_position(point_vector.back());
01120     point_vector.pop_back();
01121 
01122   }
01123 }
01124 
01125 
01126 template<typename MeshType, typename RealType>
01127 void CompositeT<MeshType,RealType>::EdE()
01128 {
01129   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01130 
01131   unsigned int                      valence;
01132   typename MeshType::Point              cog,
01133                                     zero_point(0.0, 0.0, 0.0);
01134   typename MeshType::EdgeIter           e_it;
01135   typename MeshType::HalfedgeHandle     heh;
01136   std::vector<typename MeshType::Point> point_vector;
01137 
01138   point_vector.clear();
01139 
01140   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
01141 
01142     valence = 0;
01143     cog = zero_point;
01144 
01145     for (int i = 0; i <= 1; ++i) {
01146       heh = mesh_.halfedge_handle(e_it.handle(), i);
01147       if (mesh_.face_handle(heh).is_valid())
01148       {
01149         cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(heh))).position();
01150         cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh)))).position();
01151         ++valence;
01152         ++valence;
01153       }
01154     }
01155 
01156     cog /= valence;
01157     point_vector.push_back(cog);
01158   }
01159 
01160   for (e_it = mesh_.edges_end(); e_it != mesh_.edges_begin(); )
01161   {
01162     --e_it;
01163     mesh_.data(e_it).set_position(point_vector.back());
01164     point_vector.pop_back();
01165   }
01166 }
01167 
01168 
01169 template<typename MeshType, typename RealType>
01170 void CompositeT<MeshType,RealType>::EdEc(scalar_t _c)
01171 {
01172   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01173 
01174   unsigned int                         valence;
01175   typename MeshType::Point                 cog,
01176                                        zero_point(0.0, 0.0, 0.0);
01177   typename MeshType::EdgeIter              e_it;
01178   typename MeshType::HalfedgeHandle        heh;
01179   std::vector<typename MeshType::Point>    point_vector;
01180 
01181   point_vector.clear();
01182 
01183   for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it)
01184   {
01185     valence = 0;
01186     cog = zero_point;
01187 
01188     for (int i = 0; i <= 1; ++i) {
01189       heh = mesh_.halfedge_handle(e_it.handle(), i);
01190       if (mesh_.face_handle(heh).is_valid())
01191       {
01192         cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(heh))).position() * (1.0 - _c);
01193         cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh)))).position() * (1.0 - _c);
01194         ++valence;
01195         ++valence;
01196       }
01197     }
01198 
01199     cog /= valence;
01200     cog += mesh_.data(e_it).position() * _c;
01201     point_vector.push_back(cog);
01202   }
01203 
01204   for (e_it = mesh_.edges_end(); e_it != mesh_.edges_begin(); ) {
01205 
01206     --e_it;
01207     mesh_.data(e_it).set_position(point_vector.back());
01208     point_vector.pop_back();
01209   }
01210 }
01211 
01212 
01214 template<typename MeshType, typename RealType>
01215 void CompositeT<MeshType,RealType>::corner_cutting(HalfedgeHandle _heh)
01216 {
01217   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01218 
01219   // Define Halfedge Handles
01220   typename MeshType::HalfedgeHandle heh5(_heh);
01221   typename MeshType::HalfedgeHandle heh6(mesh_.next_halfedge_handle(_heh));
01222 
01223   // Cycle around the polygon to find correct Halfedge
01224   for (; mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh5)) != _heh;
01225        heh5 = mesh_.next_halfedge_handle(heh5)) {};
01226 
01227   typename MeshType::HalfedgeHandle heh2(mesh_.next_halfedge_handle(heh5));
01228   typename MeshType::HalfedgeHandle
01229     heh3(mesh_.new_edge(mesh_.to_vertex_handle(_heh),
01230       mesh_.to_vertex_handle(heh5)));
01231   typename MeshType::HalfedgeHandle heh4(mesh_.opposite_halfedge_handle(heh3));
01232 
01233   // Old and new Face
01234   typename MeshType::FaceHandle     fh_old(mesh_.face_handle(heh6));
01235   typename MeshType::FaceHandle     fh_new(mesh_.new_face());
01236 
01237   // Init new face
01238   mesh_.data(fh_new).set_position(mesh_.data(fh_old).position());
01239 
01240   // Re-Set Handles around old Face
01241   mesh_.set_next_halfedge_handle(heh4, heh6);
01242   mesh_.set_next_halfedge_handle(heh5, heh4);
01243 
01244   mesh_.set_face_handle(heh4, fh_old);
01245   mesh_.set_face_handle(heh5, fh_old);
01246   mesh_.set_face_handle(heh6, fh_old);
01247   mesh_.set_halfedge_handle(fh_old, heh4);
01248 
01249   // Re-Set Handles around new Face
01250   mesh_.set_next_halfedge_handle(_heh, heh3);
01251   mesh_.set_next_halfedge_handle(heh3, heh2);
01252 
01253   mesh_.set_face_handle(_heh, fh_new);
01254   mesh_.set_face_handle(heh2, fh_new);
01255   mesh_.set_face_handle(heh3, fh_new);
01256 
01257   mesh_.set_halfedge_handle(fh_new, _heh);
01258 }
01259 
01260 
01262 template<typename MeshType, typename RealType>
01263 typename MeshType::VertexHandle
01264 CompositeT<MeshType,RealType>::split_edge(HalfedgeHandle _heh)
01265 {
01266   assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
01267 
01268   HalfedgeHandle heh1;
01269   HalfedgeHandle heh2;
01270   HalfedgeHandle heh3;
01271   HalfedgeHandle temp_heh;
01272 
01273   VertexHandle
01274     vh,
01275     vh1(mesh_.to_vertex_handle(_heh)),
01276     vh2(mesh_.from_vertex_handle(_heh));
01277 
01278   // Calculate and Insert Midpoint of Edge
01279   vh = mesh_.add_vertex((mesh_.point(vh2) + mesh_.point(vh1)) / 2.0);
01280   // Re-Set Handles
01281   heh2 = mesh_.opposite_halfedge_handle(_heh);
01282 
01283   if (!mesh_.is_boundary(mesh_.edge_handle(_heh))) {
01284 
01285     for (temp_heh = mesh_.next_halfedge_handle(heh2);
01286    mesh_.next_halfedge_handle(temp_heh) != heh2;
01287    temp_heh = mesh_.next_halfedge_handle(temp_heh) ) {}
01288   } else {
01289     for (temp_heh = _heh;
01290    mesh_.next_halfedge_handle(temp_heh) != heh2;
01291    temp_heh = mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(temp_heh))) {}
01292   }
01293 
01294   heh1 = mesh_.new_edge(vh, vh1);
01295   heh3 = mesh_.opposite_halfedge_handle(heh1);
01296   mesh_.set_vertex_handle(_heh, vh);
01297   mesh_.set_next_halfedge_handle(temp_heh, heh3);
01298   mesh_.set_next_halfedge_handle(heh1, mesh_.next_halfedge_handle(_heh));
01299   mesh_.set_next_halfedge_handle(_heh, heh1);
01300   mesh_.set_next_halfedge_handle(heh3, heh2);
01301   if (mesh_.face_handle(heh2).is_valid()) {
01302     mesh_.set_face_handle(heh3, mesh_.face_handle(heh2));
01303     mesh_.set_halfedge_handle(mesh_.face_handle(heh3), heh3);
01304   }
01305   mesh_.set_face_handle(heh1, mesh_.face_handle(_heh));
01306   mesh_.set_halfedge_handle(vh, heh1);
01307   mesh_.set_halfedge_handle(mesh_.face_handle(_heh), _heh);
01308   mesh_.set_halfedge_handle(vh1, heh3);
01309 
01310   return vh;
01311 }
01312 
01313 
01314 //=============================================================================
01315 } // END_NS_UNIFORM
01316 } // END_NS_SUBDIVIDER
01317 } // END_NS_OPENMESH
01318 //=============================================================================
01319 #endif // OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC defined
01320 //=============================================================================
01321