songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

class interface keeps a pointer to const mesh

This commit is contained in:
Lingjie Zhu 2017-08-15 11:18:22 +08:00
parent b7870fb39c
commit b965ad45ca
1 changed files with 86 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
Surface_mesh_approximation/include/CGAL/VSA_approximation.h
View File

@ -107,8 +107,7 @@ public:
// member variables // member variables
private: private:
// TODO, update mesh, keep a copy const TriangleMesh *m_pmesh;
TriangleMesh mesh;
VertexPointMap point_pmap; VertexPointMap point_pmap;
Construct_vector_3 vector_functor; Construct_vector_3 vector_functor;
Construct_scaled_vector_3 scale_functor; Construct_scaled_vector_3 scale_functor;
@ -161,6 +160,7 @@ public:
const ProxyFitting &_proxy_fitting) : const ProxyFitting &_proxy_fitting) :
fit_error(_fit_error), fit_error(_fit_error),
proxy_fitting(_proxy_fitting), proxy_fitting(_proxy_fitting),
m_pmesh(nullptr),
seg_pmap(internal_fidx_map), seg_pmap(internal_fidx_map),
vanchor_map(vertex_int_map), vanchor_map(vertex_int_map),
num_proxies(0) { num_proxies(0) {
@ -177,8 +177,8 @@ public:
* @param _mesh `CGAL TriangleMesh` on which approximation operate. * @param _mesh `CGAL TriangleMesh` on which approximation operate.
*/ */
void set_mesh(const TriangleMesh &_mesh) { void set_mesh(const TriangleMesh &_mesh) {
mesh = _mesh; m_pmesh = &_mesh;
point_pmap = get(boost::vertex_point, const_cast<TriangleMesh &>(mesh)); point_pmap = get(boost::vertex_point, const_cast<TriangleMesh &>(*m_pmesh));
rebuild(); rebuild();
} }
@ -188,7 +188,7 @@ public:
void rebuild() { void rebuild() {
proxies.clear(); proxies.clear();
internal_fidx_map.clear(); internal_fidx_map.clear();
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
internal_fidx_map[f] = 0; internal_fidx_map[f] = 0;
} }
@ -200,7 +200,7 @@ public:
*/ */
std::size_t init_proxies(const std::size_t num_proxy, const Initialization &seeding_method) { std::size_t init_proxies(const std::size_t num_proxy, const Initialization &seeding_method) {
proxies.clear(); proxies.clear();
if (num_faces(mesh) < num_proxy) if (num_faces(*m_pmesh) < num_proxy)
return 0; return 0;
switch (seeding_method) { switch (seeding_method) {
@ -253,7 +253,7 @@ public:
* Propagates the proxy seed facets and floods the whole mesh to minimize the fitting error. * Propagates the proxy seed facets and floods the whole mesh to minimize the fitting error.
*/ */
void partition() { void partition() {
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
seg_pmap[f] = CGAL_NOT_TAGGED_ID; seg_pmap[f] = CGAL_NOT_TAGGED_ID;
std::priority_queue<FacetToIntegrate> facet_pqueue; std::priority_queue<FacetToIntegrate> facet_pqueue;
@ -261,7 +261,7 @@ public:
face_descriptor f = proxies[i].seed; face_descriptor f = proxies[i].seed;
seg_pmap[f] = i; seg_pmap[f] = i;
BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(f, mesh), mesh)) { BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(f, *m_pmesh), *m_pmesh)) {
if (fadj != boost::graph_traits<TriangleMesh>::null_face() if (fadj != boost::graph_traits<TriangleMesh>::null_face()
&& seg_pmap[fadj] == CGAL_NOT_TAGGED_ID) { && seg_pmap[fadj] == CGAL_NOT_TAGGED_ID) {
FacetToIntegrate cand; FacetToIntegrate cand;
@ -278,7 +278,7 @@ public:
facet_pqueue.pop(); facet_pqueue.pop();
if (seg_pmap[c.f] == CGAL_NOT_TAGGED_ID) { if (seg_pmap[c.f] == CGAL_NOT_TAGGED_ID) {
seg_pmap[c.f] = c.i; seg_pmap[c.f] = c.i;
BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(c.f, mesh), mesh)) { BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(c.f, *m_pmesh), *m_pmesh)) {
if (fadj != boost::graph_traits<TriangleMesh>::null_face() if (fadj != boost::graph_traits<TriangleMesh>::null_face()
&& seg_pmap[fadj] == CGAL_NOT_TAGGED_ID) { && seg_pmap[fadj] == CGAL_NOT_TAGGED_ID) {
FacetToIntegrate cand; FacetToIntegrate cand;
@ -299,7 +299,7 @@ public:
*/ */
FT fit() { FT fit() {
std::vector<std::list<face_descriptor> > px_facets(proxies.size()); std::vector<std::list<face_descriptor> > px_facets(proxies.size());
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
px_facets[seg_pmap[f]].push_back(f); px_facets[seg_pmap[f]].push_back(f);
// update proxy parameters and seed // update proxy parameters and seed
@ -351,7 +351,7 @@ public:
} }
} }
std::list<face_descriptor> worst_patch; std::list<face_descriptor> worst_patch;
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
if (seg_pmap[f] == px_worst) if (seg_pmap[f] == px_worst)
worst_patch.push_back(f); worst_patch.push_back(f);
} }
@ -398,7 +398,7 @@ public:
FT merge(const std::size_t &px_enlarged, const std::size_t &px_merged) { FT merge(const std::size_t &px_enlarged, const std::size_t &px_merged) {
// merge // merge
std::list<face_descriptor> merged_patch; std::list<face_descriptor> merged_patch;
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
if (seg_pmap[f] == px_enlarged || seg_pmap[f] == px_merged) { if (seg_pmap[f] == px_enlarged || seg_pmap[f] == px_merged) {
seg_pmap[f] = px_enlarged; seg_pmap[f] = px_enlarged;
merged_patch.push_back(f); merged_patch.push_back(f);
@ -407,7 +407,7 @@ public:
proxies[px_enlarged] = fit_new_proxy(merged_patch.begin(), merged_patch.end()); proxies[px_enlarged] = fit_new_proxy(merged_patch.begin(), merged_patch.end());
proxies.erase(proxies.begin() + px_merged); proxies.erase(proxies.begin() + px_merged);
// update facet proxy map // update facet proxy map
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
if (seg_pmap[f] > px_merged) if (seg_pmap[f] > px_merged)
--seg_pmap[f]; --seg_pmap[f];
} }
@ -448,11 +448,11 @@ public:
if (pca_plane) if (pca_plane)
init_proxy_planes( init_proxy_planes(
CGAL::PCAPlaneFitting<TriangleMesh, VertexPointMap, GeomTraits>( CGAL::PCAPlaneFitting<TriangleMesh, VertexPointMap, GeomTraits>(
mesh, point_pmap)); *m_pmesh, point_pmap));
else else
init_proxy_planes( init_proxy_planes(
CGAL::PlaneFitting<TriangleMesh, VertexPointMap, GeomTraits>( CGAL::PlaneFitting<TriangleMesh, VertexPointMap, GeomTraits>(
mesh, point_pmap)); *m_pmesh, point_pmap));
anchor_index = 0; anchor_index = 0;
find_anchors(); find_anchors();
@ -477,7 +477,7 @@ public:
*/ */
template <typename FacetProxyMap> template <typename FacetProxyMap>
void get_proxy_map(FacetProxyMap &facet_proxy_map) { void get_proxy_map(FacetProxyMap &facet_proxy_map) {
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
facet_proxy_map[f] = seg_pmap[f]; facet_proxy_map[f] = seg_pmap[f];
} }
@ -533,7 +533,7 @@ public:
do { do {
ChordVector chord; ChordVector chord;
walk_to_next_anchor(he, chord); walk_to_next_anchor(he, chord);
bdr.push_back(vanchor_map[target(he, mesh)]); bdr.push_back(vanchor_map[target(he, *m_pmesh)]);
} while(he != he_mark); } while(he != he_mark);
bdrs.push_back(bdr); bdrs.push_back(bdr);
} }
@ -547,9 +547,9 @@ private:
* @return #proxies initialized * @return #proxies initialized
*/ */
std::size_t seed_random(const std::size_t initial_px) { std::size_t seed_random(const std::size_t initial_px) {
const std::size_t interval = num_faces(mesh) / initial_px; const std::size_t interval = num_faces(*m_pmesh) / initial_px;
std::size_t index = 0; std::size_t index = 0;
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
if ((index++) % interval == 0) { if ((index++) % interval == 0) {
proxies.push_back(fit_new_proxy(f)); proxies.push_back(fit_new_proxy(f));
} }
@ -567,8 +567,8 @@ private:
*/ */
std::size_t seed_incremental(const std::size_t initial_px) { std::size_t seed_incremental(const std::size_t initial_px) {
// initialize a proxy and the proxy map to prepare for the insertion // initialize a proxy and the proxy map to prepare for the insertion
proxies.push_back(fit_new_proxy(*(faces(mesh).first))); proxies.push_back(fit_new_proxy(*(faces(*m_pmesh).first)));
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
seg_pmap[f] = 0; seg_pmap[f] = 0;
insert_proxy_furthest(initial_px - 1); insert_proxy_furthest(initial_px - 1);
@ -583,7 +583,7 @@ private:
std::size_t seed_hierarchical(const std::size_t initial_px) { std::size_t seed_hierarchical(const std::size_t initial_px) {
// initialize 2 proxy // initialize 2 proxy
typename boost::graph_traits<TriangleMesh>::face_iterator typename boost::graph_traits<TriangleMesh>::face_iterator
fitr = faces(mesh).first; fitr = faces(*m_pmesh).first;
proxies.push_back(fit_new_proxy(*fitr)); proxies.push_back(fit_new_proxy(*fitr));
proxies.push_back(fit_new_proxy(*(++fitr))); proxies.push_back(fit_new_proxy(*(++fitr)));
@ -613,7 +613,7 @@ private:
std::vector<FT> max_facet_error(proxies.size(), FT(0.0)); std::vector<FT> max_facet_error(proxies.size(), FT(0.0));
std::vector<face_descriptor> max_facet(proxies.size()); std::vector<face_descriptor> max_facet(proxies.size());
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
std::size_t px_idx = seg_pmap[f]; std::size_t px_idx = seg_pmap[f];
FT err = fit_error(f, proxies[px_idx]); FT err = fit_error(f, proxies[px_idx]);
px_error[px_idx] += err; px_error[px_idx] += err;
@ -702,7 +702,7 @@ private:
<< ", #num_to_add " << num_to_add[px_error[i].px_idx] << std::endl; << ", #num_to_add " << num_to_add[px_error[i].px_idx] << std::endl;
std::size_t num_inserted = 0; std::size_t num_inserted = 0;
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
const std::size_t px_id = seg_pmap[f]; const std::size_t px_id = seg_pmap[f];
if (proxies[px_id].seed == f) if (proxies[px_id].seed == f)
continue; continue;
@ -733,7 +733,7 @@ private:
typedef std::set<ProxyPair> MergedPair; typedef std::set<ProxyPair> MergedPair;
std::vector<std::list<face_descriptor> > px_facets(proxies.size()); std::vector<std::list<face_descriptor> > px_facets(proxies.size());
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
px_facets[seg_pmap[f]].push_back(f); px_facets[seg_pmap[f]].push_back(f);
// find best merge // find best merge
@ -741,11 +741,11 @@ private:
// Proxy merged_px; // Proxy merged_px;
FT min_merged_error = FT(0); FT min_merged_error = FT(0);
bool first_merge = true; bool first_merge = true;
BOOST_FOREACH(edge_descriptor e, edges(mesh)) { BOOST_FOREACH(edge_descriptor e, edges(*m_pmesh)) {
if (CGAL::is_border(e, mesh)) if (CGAL::is_border(e, *m_pmesh))
continue; continue;
std::size_t pxi = seg_pmap[face(halfedge(e, mesh), mesh)]; std::size_t pxi = seg_pmap[face(halfedge(e, *m_pmesh), *m_pmesh)];
std::size_t pxj = seg_pmap[face(opposite(halfedge(e, mesh), mesh), mesh)]; std::size_t pxj = seg_pmap[face(opposite(halfedge(e, *m_pmesh), *m_pmesh), *m_pmesh)];
if (pxi == pxj) if (pxi == pxj)
continue; continue;
if (pxi > pxj) if (pxi > pxj)
@ -844,7 +844,7 @@ private:
*/ */
FT fitting_error() { FT fitting_error() {
FT sum_error(0); FT sum_error(0);
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
sum_error += fit_error(f, proxies[seg_pmap[f]]); sum_error += fit_error(f, proxies[seg_pmap[f]]);
return sum_error; return sum_error;
} }
@ -857,7 +857,7 @@ private:
*/ */
FT fitting_error(std::vector<FT> &px_error) { FT fitting_error(std::vector<FT> &px_error) {
FT sum_error(0); FT sum_error(0);
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
const std::size_t px_idx = seg_pmap[f]; const std::size_t px_idx = seg_pmap[f];
FT err = fit_error(f, proxies[px_idx]); FT err = fit_error(f, proxies[px_idx]);
px_error[px_idx] += err; px_error[px_idx] += err;
@ -876,17 +876,17 @@ private:
void init_proxy_planes(const PlaneFitting &_plane_fitting) { void init_proxy_planes(const PlaneFitting &_plane_fitting) {
// initialize all vertex anchor status // initialize all vertex anchor status
enum Vertex_status { NO_ANCHOR = -1 }; enum Vertex_status { NO_ANCHOR = -1 };
BOOST_FOREACH(vertex_descriptor v, vertices(mesh)) BOOST_FOREACH(vertex_descriptor v, vertices(*m_pmesh))
vertex_int_map.insert(std::pair<vertex_descriptor, int>(v, static_cast<int>(NO_ANCHOR))); vertex_int_map.insert(std::pair<vertex_descriptor, int>(v, static_cast<int>(NO_ANCHOR)));
// count number of proxies // count number of proxies
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
num_proxies = num_proxies < seg_pmap[f] ? seg_pmap[f] : num_proxies; num_proxies = num_proxies < seg_pmap[f] ? seg_pmap[f] : num_proxies;
++num_proxies; ++num_proxies;
// fit proxy planes, areas, normals // fit proxy planes, areas, normals
std::vector<std::list<face_descriptor> > px_facets(num_proxies); std::vector<std::list<face_descriptor> > px_facets(num_proxies);
BOOST_FOREACH(face_descriptor f, faces(mesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
px_facets[seg_pmap[f]].push_back(f); px_facets[seg_pmap[f]].push_back(f);
BOOST_FOREACH(const std::list<face_descriptor> &px_patch, px_facets) { BOOST_FOREACH(const std::list<face_descriptor> &px_patch, px_facets) {
@ -895,10 +895,10 @@ private:
Vector_3 norm = CGAL::NULL_VECTOR; Vector_3 norm = CGAL::NULL_VECTOR;
FT area(0); FT area(0);
BOOST_FOREACH(face_descriptor f, px_patch) { BOOST_FOREACH(face_descriptor f, px_patch) {
halfedge_descriptor he = halfedge(f, mesh); halfedge_descriptor he = halfedge(f, *m_pmesh);
const Point_3 p0 = point_pmap[source(he, mesh)]; const Point_3 p0 = point_pmap[source(he, *m_pmesh)];
const Point_3 p1 = point_pmap[target(he, mesh)]; const Point_3 p1 = point_pmap[target(he, *m_pmesh)];
const Point_3 p2 = point_pmap[target(next(he, mesh), mesh)]; const Point_3 p2 = point_pmap[target(next(he, *m_pmesh), *m_pmesh)];
FT farea(std::sqrt(CGAL::to_double(CGAL::squared_area(p0, p1, p2)))); FT farea(std::sqrt(CGAL::to_double(CGAL::squared_area(p0, p1, p2))));
Vector_3 fnorm = CGAL::unit_normal(p0, p1, p2); Vector_3 fnorm = CGAL::unit_normal(p0, p1, p2);
@ -920,13 +920,13 @@ private:
void find_anchors() { void find_anchors() {
anchors.clear(); anchors.clear();
BOOST_FOREACH(vertex_descriptor vtx, vertices(mesh)) { BOOST_FOREACH(vertex_descriptor vtx, vertices(*m_pmesh)) {
std::size_t border_count = 0; std::size_t border_count = 0;
BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(vtx, mesh)) { BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(vtx, *m_pmesh)) {
if (CGAL::is_border_edge(h, mesh)) if (CGAL::is_border_edge(h, *m_pmesh))
++border_count; ++border_count;
else if (seg_pmap[face(h, mesh)] != seg_pmap[face(opposite(h, mesh), mesh)]) else if (seg_pmap[face(h, *m_pmesh)] != seg_pmap[face(opposite(h, *m_pmesh), *m_pmesh)])
++border_count; ++border_count;
} }
if (border_count >= 3) if (border_count >= 3)
@ -940,10 +940,10 @@ private:
void find_edges() { void find_edges() {
// collect candidate halfedges in a set // collect candidate halfedges in a set
std::set<halfedge_descriptor> he_candidates; std::set<halfedge_descriptor> he_candidates;
BOOST_FOREACH(halfedge_descriptor h, halfedges(mesh)) { BOOST_FOREACH(halfedge_descriptor h, halfedges(*m_pmesh)) {
if (!CGAL::is_border(h, mesh) if (!CGAL::is_border(h, *m_pmesh)
&& (CGAL::is_border(opposite(h, mesh), mesh) && (CGAL::is_border(opposite(h, *m_pmesh), *m_pmesh)
|| seg_pmap[face(h, mesh)] != seg_pmap[face(opposite(h, mesh), mesh)])) || seg_pmap[face(h, *m_pmesh)] != seg_pmap[face(opposite(h, *m_pmesh), *m_pmesh)]))
he_candidates.insert(h); he_candidates.insert(h);
} }
@ -985,7 +985,7 @@ private:
CGAL_assertion(bitr->num_anchors == 2); CGAL_assertion(bitr->num_anchors == 2);
// borders with only 2 initial anchors // borders with only 2 initial anchors
const halfedge_descriptor he_mark = bitr->he_head; const halfedge_descriptor he_mark = bitr->he_head;
Point_3 pt_begin = point_pmap[target(he_mark, mesh)]; Point_3 pt_begin = point_pmap[target(he_mark, *m_pmesh)];
Point_3 pt_end = pt_begin; Point_3 pt_end = pt_begin;
halfedge_descriptor he = he_mark; halfedge_descriptor he = he_mark;
@ -997,7 +997,7 @@ private:
chord.push_back(he); chord.push_back(he);
else { else {
if (count == 0) if (count == 0)
pt_end = point_pmap[target(he, mesh)]; pt_end = point_pmap[target(he, *m_pmesh)];
++count; ++count;
} }
} while(he != he_mark); } while(he != he_mark);
@ -1015,7 +1015,7 @@ private:
chord_vec = scale_functor(chord_vec, chord_vec = scale_functor(chord_vec,
FT(1.0 / std::sqrt(CGAL::to_double(chord_vec.squared_length())))); FT(1.0 / std::sqrt(CGAL::to_double(chord_vec.squared_length()))));
for (ChordVectorIterator citr = chord.begin(); citr != chord.end(); ++citr) { for (ChordVectorIterator citr = chord.begin(); citr != chord.end(); ++citr) {
Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, mesh)]); Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, *m_pmesh)]);
vec = CGAL::cross_product(chord_vec, vec); vec = CGAL::cross_product(chord_vec, vec);
FT dist(std::sqrt(CGAL::to_double(vec.squared_length()))); FT dist(std::sqrt(CGAL::to_double(vec.squared_length())));
if (dist > dist_max) { if (dist > dist_max) {
@ -1060,24 +1060,24 @@ private:
VertexIndex1Map global_vanchor_map = get(boost::vertex_index1, gmain); VertexIndex1Map global_vanchor_map = get(boost::vertex_index1, gmain);
VertexIndex2Map global_vtag_map = get(boost::vertex_index2, gmain); VertexIndex2Map global_vtag_map = get(boost::vertex_index2, gmain);
EdgeWeightMap global_eweight_map = get(boost::edge_weight, gmain); EdgeWeightMap global_eweight_map = get(boost::edge_weight, gmain);
BOOST_FOREACH(vertex_descriptor v, vertices(mesh)) { BOOST_FOREACH(vertex_descriptor v, vertices(*m_pmesh)) {
sg_vertex_descriptor sgv = add_vertex(gmain); sg_vertex_descriptor sgv = add_vertex(gmain);
global_vanchor_map[sgv] = vanchor_map[v]; global_vanchor_map[sgv] = vanchor_map[v];
global_vtag_map[sgv] = vanchor_map[v]; global_vtag_map[sgv] = vanchor_map[v];
vmap.insert(std::pair<vertex_descriptor, sg_vertex_descriptor>(v, sgv)); vmap.insert(std::pair<vertex_descriptor, sg_vertex_descriptor>(v, sgv));
} }
BOOST_FOREACH(edge_descriptor e, edges(mesh)) { BOOST_FOREACH(edge_descriptor e, edges(*m_pmesh)) {
vertex_descriptor vs = source(e, mesh); vertex_descriptor vs = source(e, *m_pmesh);
vertex_descriptor vt = target(e, mesh); vertex_descriptor vt = target(e, *m_pmesh);
FT len(std::sqrt(CGAL::to_double( FT len(std::sqrt(CGAL::to_double(
CGAL::squared_distance(point_pmap[vs], point_pmap[vt])))); CGAL::squared_distance(point_pmap[vs], point_pmap[vt]))));
add_edge(to_sgv_map[vs], to_sgv_map[vt], len, gmain); add_edge(to_sgv_map[vs], to_sgv_map[vt], len, gmain);
} }
std::vector<VertexVector> vertex_patches(num_proxies); std::vector<VertexVector> vertex_patches(num_proxies);
BOOST_FOREACH(vertex_descriptor v, vertices(mesh)) { BOOST_FOREACH(vertex_descriptor v, vertices(*m_pmesh)) {
std::set<std::size_t> px_set; std::set<std::size_t> px_set;
BOOST_FOREACH(face_descriptor f, faces_around_target(halfedge(v, mesh), mesh)) { BOOST_FOREACH(face_descriptor f, faces_around_target(halfedge(v, *m_pmesh), *m_pmesh)) {
if (f != boost::graph_traits<TriangleMesh>::null_face()) if (f != boost::graph_traits<TriangleMesh>::null_face())
px_set.insert(seg_pmap[f]); px_set.insert(seg_pmap[f]);
} }
@ -1134,32 +1134,32 @@ private:
vdist.push_back(FT(0)); vdist.push_back(FT(0));
BOOST_FOREACH(halfedge_descriptor h, chord) { BOOST_FOREACH(halfedge_descriptor h, chord) {
FT elen = global_eweight_map[edge( FT elen = global_eweight_map[edge(
to_sgv_map[source(h, mesh)], to_sgv_map[source(h, *m_pmesh)],
to_sgv_map[target(h, mesh)], to_sgv_map[target(h, *m_pmesh)],
gmain).first]; gmain).first];
vdist.push_back(vdist.back() + elen); vdist.push_back(vdist.back() + elen);
} }
FT half_chord_len = vdist.back() / FT(2); FT half_chord_len = vdist.back() / FT(2);
const int anchorleft = vanchor_map[source(chord.front(), mesh)]; const int anchorleft = vanchor_map[source(chord.front(), *m_pmesh)];
const int anchorright = vanchor_map[target(chord.back(), mesh)]; const int anchorright = vanchor_map[target(chord.back(), *m_pmesh)];
typename std::vector<FT>::iterator ditr = vdist.begin() + 1; typename std::vector<FT>::iterator ditr = vdist.begin() + 1;
for (typename ChordVector::iterator hitr = chord.begin(); for (typename ChordVector::iterator hitr = chord.begin();
hitr != chord.end() - 1; ++hitr, ++ditr) { hitr != chord.end() - 1; ++hitr, ++ditr) {
if (*ditr < half_chord_len) if (*ditr < half_chord_len)
global_vtag_map[to_sgv_map[target(*hitr, mesh)]] = anchorleft; global_vtag_map[to_sgv_map[target(*hitr, *m_pmesh)]] = anchorleft;
else else
global_vtag_map[to_sgv_map[target(*hitr, mesh)]] = anchorright; global_vtag_map[to_sgv_map[target(*hitr, *m_pmesh)]] = anchorright;
} }
} while(he != he_mark); } while(he != he_mark);
} }
// collect triangles // collect triangles
BOOST_FOREACH(face_descriptor f, faces(mesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
halfedge_descriptor he = halfedge(f, mesh); halfedge_descriptor he = halfedge(f, *m_pmesh);
int i = global_vtag_map[to_sgv_map[source(he, mesh)]]; int i = global_vtag_map[to_sgv_map[source(he, *m_pmesh)]];
int j = global_vtag_map[to_sgv_map[target(he, mesh)]]; int j = global_vtag_map[to_sgv_map[target(he, *m_pmesh)]];
int k = global_vtag_map[to_sgv_map[target(next(he, mesh), mesh)]]; int k = global_vtag_map[to_sgv_map[target(next(he, *m_pmesh), *m_pmesh)]];
if (i != j && i != k && j != k) { if (i != j && i != k && j != k) {
tris.push_back(i); tris.push_back(i);
tris.push_back(j); tris.push_back(j);
@ -1199,10 +1199,10 @@ private:
* @param[in/out] he_start region border halfedge * @param[in/out] he_start region border halfedge
*/ */
void walk_to_next_border_halfedge(halfedge_descriptor &he_start) { void walk_to_next_border_halfedge(halfedge_descriptor &he_start) {
const std::size_t px_idx = seg_pmap[face(he_start, mesh)]; const std::size_t px_idx = seg_pmap[face(he_start, *m_pmesh)];
BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(he_start, mesh)) { BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(he_start, *m_pmesh)) {
if (CGAL::is_border(h, mesh) || seg_pmap[face(h, mesh)] != px_idx) { if (CGAL::is_border(h, *m_pmesh) || seg_pmap[face(h, *m_pmesh)] != px_idx) {
he_start = opposite(h, mesh); he_start = opposite(h, *m_pmesh);
return; return;
} }
} }
@ -1224,14 +1224,14 @@ private:
return 1; return 1;
halfedge_descriptor he_start = *chord_begin; halfedge_descriptor he_start = *chord_begin;
std::size_t px_left = seg_pmap[face(he_start, mesh)]; std::size_t px_left = seg_pmap[face(he_start, *m_pmesh)];
std::size_t px_right = px_left; std::size_t px_right = px_left;
if (!CGAL::is_border(opposite(he_start, mesh), mesh)) if (!CGAL::is_border(opposite(he_start, *m_pmesh), *m_pmesh))
px_right = seg_pmap[face(opposite(he_start, mesh), mesh)]; px_right = seg_pmap[face(opposite(he_start, *m_pmesh), *m_pmesh)];
// suppose the proxy normal angle is acute // suppose the proxy normal angle is acute
FT norm_sin(1.0); FT norm_sin(1.0);
if (!CGAL::is_border(opposite(he_start, mesh), mesh)) { if (!CGAL::is_border(opposite(he_start, *m_pmesh), *m_pmesh)) {
Vector_3 vec = CGAL::cross_product(px_normals[px_left], px_normals[px_right]); Vector_3 vec = CGAL::cross_product(px_normals[px_left], px_normals[px_right]);
norm_sin = FT(std::sqrt(CGAL::to_double(scalar_product_functor(vec, vec)))); norm_sin = FT(std::sqrt(CGAL::to_double(scalar_product_functor(vec, vec))));
} }
@ -1239,10 +1239,10 @@ private:
ChordVectorIterator he_max; ChordVectorIterator he_max;
const ChordVectorIterator chord_last = chord_end - 1; const ChordVectorIterator chord_last = chord_end - 1;
std::size_t anchor_begin = vanchor_map[source(he_start, mesh)]; std::size_t anchor_begin = vanchor_map[source(he_start, *m_pmesh)];
std::size_t anchor_end = vanchor_map[target(*chord_last, mesh)]; std::size_t anchor_end = vanchor_map[target(*chord_last, *m_pmesh)];
const Point_3 &pt_begin = point_pmap[source(he_start, mesh)]; const Point_3 &pt_begin = point_pmap[source(he_start, *m_pmesh)];
const Point_3 &pt_end = point_pmap[target(*chord_last, mesh)]; const Point_3 &pt_end = point_pmap[target(*chord_last, *m_pmesh)];
if (anchor_begin == anchor_end) { if (anchor_begin == anchor_end) {
// circular chord // circular chord
CGAL_assertion(chord_size > 2); CGAL_assertion(chord_size > 2);
@ -1251,7 +1251,7 @@ private:
FT dist_max(0.0); FT dist_max(0.0);
for (ChordVectorIterator citr = chord_begin; citr != chord_last; ++citr) { for (ChordVectorIterator citr = chord_begin; citr != chord_last; ++citr) {
FT dist = CGAL::squared_distance(pt_begin, point_pmap[target(*citr, mesh)]); FT dist = CGAL::squared_distance(pt_begin, point_pmap[target(*citr, *m_pmesh)]);
dist = FT(std::sqrt(CGAL::to_double(dist))); dist = FT(std::sqrt(CGAL::to_double(dist)));
if (dist > dist_max) { if (dist > dist_max) {
he_max = citr; he_max = citr;
@ -1266,7 +1266,7 @@ private:
chord_vec = scale_functor(chord_vec, FT(1.0) / chord_len); chord_vec = scale_functor(chord_vec, FT(1.0) / chord_len);
for (ChordVectorIterator citr = chord_begin; citr != chord_last; ++citr) { for (ChordVectorIterator citr = chord_begin; citr != chord_last; ++citr) {
Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, mesh)]); Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, *m_pmesh)]);
vec = CGAL::cross_product(chord_vec, vec); vec = CGAL::cross_product(chord_vec, vec);
FT dist(std::sqrt(CGAL::to_double(vec.squared_length()))); FT dist(std::sqrt(CGAL::to_double(vec.squared_length())));
if (dist > dist_max) { if (dist > dist_max) {
@ -1296,7 +1296,7 @@ private:
* @param he halfedge * @param he halfedge
*/ */
bool is_anchor_attached(const halfedge_descriptor &he) { bool is_anchor_attached(const halfedge_descriptor &he) {
return is_anchor_attached(target(he, mesh), vanchor_map); return is_anchor_attached(target(he, *m_pmesh), vanchor_map);
} }
/*! /*!
@ -1325,7 +1325,7 @@ private:
* @param he halfedge * @param he halfedge
*/ */
void attach_anchor(const halfedge_descriptor &he) { void attach_anchor(const halfedge_descriptor &he) {
vertex_descriptor vtx = target(he, mesh); vertex_descriptor vtx = target(he, *m_pmesh);
attach_anchor(vtx); attach_anchor(vtx);
} }
@ -1334,13 +1334,13 @@ private:
*/ */
void compute_anchor_position() { void compute_anchor_position() {
anchors = std::vector<Anchor>(anchor_index); anchors = std::vector<Anchor>(anchor_index);
BOOST_FOREACH(vertex_descriptor v, vertices(mesh)) { BOOST_FOREACH(vertex_descriptor v, vertices(*m_pmesh)) {
if (is_anchor_attached(v, vanchor_map)) { if (is_anchor_attached(v, vanchor_map)) {
// construct an anchor from vertex and the incident proxies // construct an anchor from vertex and the incident proxies
std::set<std::size_t> px_set; std::set<std::size_t> px_set;
BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(v, mesh)) { BOOST_FOREACH(halfedge_descriptor h, halfedges_around_target(v, *m_pmesh)) {
if (!CGAL::is_border(h, mesh)) if (!CGAL::is_border(h, *m_pmesh))
px_set.insert(seg_pmap[face(h, mesh)]); px_set.insert(seg_pmap[face(h, *m_pmesh)]);
} }
// construct an anchor from vertex and the incident proxies // construct an anchor from vertex and the incident proxies