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

fix demo 

cgal class naming convention
coherent if/for block style
new API
This commit is contained in:
Lingjie Zhu 2017-11-15 22:55:50 +08:00
parent f06c302c3a
commit 4e81f58d84
1 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
Surface_mesh_approximation/include/CGAL/vsa_approximation.h
View File

@ -98,17 +98,17 @@ private:
typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor; typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
// internal typedefs // internal typedefs
typedef boost::associative_property_map<std::map<vertex_descriptor, int> > VertexAnchorMap; typedef boost::associative_property_map<std::map<vertex_descriptor, int> > Vertex_anchor_map;
typedef std::vector<halfedge_descriptor> ChordVector; typedef std::vector<halfedge_descriptor> Chord_vector;
typedef typename ChordVector::iterator ChordVectorIterator; typedef typename Chord_vector::iterator Chord_vector_iterator;
#ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG #ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG
public: public:
#endif #endif
// The proxy wrapper for approximation. // The proxy wrapper for approximation.
struct ProxyWrapper { struct Proxy_wrapper {
ProxyWrapper(const Proxy &_p, const face_descriptor &_s) Proxy_wrapper(const Proxy &_p, const face_descriptor &_s)
: px(_p), seed(_s), err(0) {} : px(_p), seed(_s), err(0) {}
Proxy px; // parameterized proxy Proxy px; // parameterized proxy
@ -120,8 +120,8 @@ private:
#endif #endif
// The proxy fitting plane for meshing. // The proxy fitting plane for meshing.
struct ProxyPlane { struct Proxy_plane {
ProxyPlane(const Plane_3 &_p, const Vector_3 &_n, const FT &_a) Proxy_plane(const Plane_3 &_p, const Vector_3 &_n, const FT &_a)
: plane(_p), normal(_n), area(_a) {} : plane(_p), normal(_n), area(_a) {}
Plane_3 plane; Plane_3 plane;
@ -130,11 +130,11 @@ private:
}; };
// The facet candidate to be queued. // The facet candidate to be queued.
struct FacetToIntegrate { struct Facet_to_integrate {
FacetToIntegrate(const face_descriptor &_f, const std::size_t &_px, const FT &_err) Facet_to_integrate(const face_descriptor &_f, const std::size_t &_px, const FT &_err)
: f(_f), px(_px), err(_err) {} : f(_f), px(_px), err(_err) {}
bool operator<(const FacetToIntegrate &rhs) const { bool operator<(const Facet_to_integrate &rhs) const {
return err > rhs.err; return err > rhs.err;
} }
@ -144,12 +144,12 @@ private:
}; };
// Proxy error with its index. // Proxy error with its index.
struct ProxyError { struct Proxy_error {
ProxyError(const std::size_t &_px, const FT &_err) Proxy_error(const std::size_t &_px, const FT &_err)
: px(_px), err(_err) {} : px(_px), err(_err) {}
// in ascending order // in ascending order
bool operator<(const ProxyError &rhs) const { bool operator<(const Proxy_error &rhs) const {
return err < rhs.err; return err < rhs.err;
} }
@ -178,12 +178,12 @@ private:
// Triangle polyhedron builder. // Triangle polyhedron builder.
template <typename HDS> template <typename HDS>
class TrianglePolyhedronBuilder : public CGAL::Modifier_base<HDS> { class Triangle_polyhedron_builder : public CGAL::Modifier_base<HDS> {
const std::vector<Point_3> &vtxs; const std::vector<Point_3> &vtxs;
const std::vector<std::vector<std::size_t> > &tris; const std::vector<std::vector<std::size_t> > &tris;
public: public:
bool is_manifold; bool is_manifold;
TrianglePolyhedronBuilder(const std::vector<Point_3> &_vtxs, Triangle_polyhedron_builder(const std::vector<Point_3> &_vtxs,
const std::vector<std::vector<std::size_t> > &_tris) const std::vector<std::vector<std::size_t> > &_tris)
: vtxs(_vtxs), tris(_tris), is_manifold(true) {} : vtxs(_vtxs), tris(_tris), is_manifold(true) {}
@ -230,12 +230,12 @@ private:
boost::associative_property_map<std::map<face_descriptor, std::size_t> > fproxy_map; boost::associative_property_map<std::map<face_descriptor, std::size_t> > fproxy_map;
// The attached anchor index of a vertex. // The attached anchor index of a vertex.
std::map<vertex_descriptor, int> internal_vidx_map; std::map<vertex_descriptor, int> internal_vidx_map;
VertexAnchorMap vanchor_map; Vertex_anchor_map vanchor_map;
// Proxies. // Proxies.
std::vector<ProxyWrapper> proxies; std::vector<Proxy_wrapper> proxies;
// Proxy planes // Proxy planes
std::vector<ProxyPlane> px_planes; std::vector<Proxy_plane> px_planes;
// All anchors. // All anchors.
std::vector<Anchor> anchors; std::vector<Anchor> anchors;
@ -438,7 +438,7 @@ public:
BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) BOOST_FOREACH(face_descriptor f, faces(*m_pmesh))
fproxy_map[f] = CGAL_NOT_TAGGED_ID; fproxy_map[f] = CGAL_NOT_TAGGED_ID;
std::priority_queue<FacetToIntegrate> facet_pqueue; std::priority_queue<Facet_to_integrate> facet_pqueue;
for (std::size_t i = 0; i < proxies.size(); ++i) { for (std::size_t i = 0; i < proxies.size(); ++i) {
face_descriptor f = proxies[i].seed; face_descriptor f = proxies[i].seed;
fproxy_map[f] = i; fproxy_map[f] = i;
@ -446,21 +446,21 @@ public:
BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(f, *m_pmesh), *m_pmesh)) { 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()
&& fproxy_map[fadj] == CGAL_NOT_TAGGED_ID) { && fproxy_map[fadj] == CGAL_NOT_TAGGED_ID) {
facet_pqueue.push(FacetToIntegrate( facet_pqueue.push(Facet_to_integrate(
fadj, i, (*fit_error)(fadj, proxies[i].px))); fadj, i, (*fit_error)(fadj, proxies[i].px)));
} }
} }
} }
while (!facet_pqueue.empty()) { while (!facet_pqueue.empty()) {
const FacetToIntegrate c = facet_pqueue.top(); const Facet_to_integrate c = facet_pqueue.top();
facet_pqueue.pop(); facet_pqueue.pop();
if (fproxy_map[c.f] == CGAL_NOT_TAGGED_ID) { if (fproxy_map[c.f] == CGAL_NOT_TAGGED_ID) {
fproxy_map[c.f] = c.px; fproxy_map[c.f] = c.px;
BOOST_FOREACH(face_descriptor fadj, faces_around_face(halfedge(c.f, *m_pmesh), *m_pmesh)) { 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()
&& fproxy_map[fadj] == CGAL_NOT_TAGGED_ID) { && fproxy_map[fadj] == CGAL_NOT_TAGGED_ID) {
facet_pqueue.push(FacetToIntegrate( facet_pqueue.push(Facet_to_integrate(
fadj, c.px, (*fit_error)(fadj, proxies[c.px].px))); fadj, c.px, (*fit_error)(fadj, proxies[c.px].px)));
} }
} }
@ -522,9 +522,9 @@ public:
const FT sum_error = compute_fitting_error(); const FT sum_error = compute_fitting_error();
const FT avg_error = sum_error / FT(static_cast<double>(num_proxies)); const FT avg_error = sum_error / FT(static_cast<double>(num_proxies));
std::vector<ProxyError> px_error; std::vector<Proxy_error> px_error;
for (std::size_t i = 0; i < proxies.size(); ++i) for (std::size_t i = 0; i < proxies.size(); ++i)
px_error.push_back(ProxyError(i, proxies[i].err)); px_error.push_back(Proxy_error(i, proxies[i].err));
// sort partition by error // sort partition by error
std::sort(px_error.begin(), px_error.end()); std::sort(px_error.begin(), px_error.end());
@ -553,7 +553,7 @@ public:
else { else {
// residual from previous proxy in range (-0.5, 0.5] * avg_error // residual from previous proxy in range (-0.5, 0.5] * avg_error
FT residual(0); FT residual(0);
BOOST_FOREACH(const ProxyError &pxe, px_error) { BOOST_FOREACH(const Proxy_error &pxe, px_error) {
// add error residual from previous proxy // add error residual from previous proxy
// to_add maybe negative but greater than -0.5 // to_add maybe negative but greater than -0.5
FT to_add = (residual + pxe.err) / avg_error; FT to_add = (residual + pxe.err) / avg_error;
@ -748,7 +748,7 @@ public:
BOOST_FOREACH(face_descriptor f, px_facets[pxj]) BOOST_FOREACH(face_descriptor f, px_facets[pxj])
merged_patch.push_back(f); merged_patch.push_back(f);
ProxyWrapper pxw = fit_new_proxy(merged_patch.begin(), merged_patch.end()); Proxy_wrapper pxw = fit_new_proxy(merged_patch.begin(), merged_patch.end());
FT sum_error(0); FT sum_error(0);
BOOST_FOREACH(face_descriptor f, merged_patch) BOOST_FOREACH(face_descriptor f, merged_patch)
sum_error += (*fit_error)(f, pxw.px); sum_error += (*fit_error)(f, pxw.px);
@ -857,19 +857,19 @@ public:
*/ */
template <typename OutputIterator> template <typename OutputIterator>
void get_proxies(OutputIterator out_itr) const { void get_proxies(OutputIterator out_itr) const {
BOOST_FOREACH(const ProxyWrapper &pxw, proxies) BOOST_FOREACH(const Proxy_wrapper &pxw, proxies)
*out_itr++ = pxw.px; *out_itr++ = pxw.px;
} }
#ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG #ifdef CGAL_SURFACE_MESH_APPROXIMATION_DEBUG
/*! /*!
* @brief Get the wrapped proxies. * @brief Get the wrapped proxies.
* @tparam OutputIterator output iterator with ProxyWrapper as value type * @tparam OutputIterator output iterator with Proxy_wrapper as value type
* @param out_itr output iterator * @param out_itr output iterator
*/ */
template <typename OutputIterator> template <typename OutputIterator>
void get_wrapped_proxies(OutputIterator out_itr) const { void get_wrapped_proxies(OutputIterator out_itr) const {
BOOST_FOREACH(const ProxyWrapper &pxw, proxies) BOOST_FOREACH(const Proxy_wrapper &pxw, proxies)
*out_itr++ = pxw; *out_itr++ = pxw;
} }
#endif #endif
@ -926,7 +926,7 @@ public:
const halfedge_descriptor he_mark = bitr->he_head; const halfedge_descriptor he_mark = bitr->he_head;
halfedge_descriptor he = he_mark; halfedge_descriptor he = he_mark;
do { do {
ChordVector chord; Chord_vector chord;
walk_to_next_anchor(he, chord); walk_to_next_anchor(he, chord);
bdr.push_back(vanchor_map[target(he, *m_pmesh)]); bdr.push_back(vanchor_map[target(he, *m_pmesh)]);
} while(he != he_mark); } while(he != he_mark);
@ -1177,7 +1177,7 @@ private:
* @param end container end * @param end container end
*/ */
template<typename FacetIterator> template<typename FacetIterator>
ProxyWrapper fit_new_proxy(const FacetIterator &beg, const FacetIterator &end) { Proxy_wrapper fit_new_proxy(const FacetIterator &beg, const FacetIterator &end) {
CGAL_assertion(beg != end); CGAL_assertion(beg != end);
// use proxy_fitting functor to fit proxy parameters // use proxy_fitting functor to fit proxy parameters
@ -1195,7 +1195,7 @@ private:
} }
} }
return ProxyWrapper(px, seed); return Proxy_wrapper(px, seed);
} }
/*! /*!
@ -1204,12 +1204,12 @@ private:
* 2. Set seed. * 2. Set seed.
* @param face_descriptor facet * @param face_descriptor facet
*/ */
ProxyWrapper fit_new_proxy(const face_descriptor &f) { Proxy_wrapper fit_new_proxy(const face_descriptor &f) {
std::vector<face_descriptor> fvec(1, f); std::vector<face_descriptor> fvec(1, f);
// fit proxy parameters // fit proxy parameters
Proxy px = (*proxy_fitting)(fvec.begin(), fvec.end()); Proxy px = (*proxy_fitting)(fvec.begin(), fvec.end());
return ProxyWrapper(px, f); return Proxy_wrapper(px, f);
} }
/*! /*!
@ -1217,7 +1217,7 @@ private:
* @return total fitting error * @return total fitting error
*/ */
FT compute_fitting_error() { FT compute_fitting_error() {
BOOST_FOREACH(ProxyWrapper &pxw, proxies) BOOST_FOREACH(Proxy_wrapper &pxw, proxies)
pxw.err = FT(0); pxw.err = FT(0);
BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) { BOOST_FOREACH(face_descriptor f, faces(*m_pmesh)) {
std::size_t pxidx = fproxy_map[f]; std::size_t pxidx = fproxy_map[f];
@ -1225,7 +1225,7 @@ private:
} }
FT sum_error(0); FT sum_error(0);
BOOST_FOREACH(const ProxyWrapper &pxw, proxies) BOOST_FOREACH(const Proxy_wrapper &pxw, proxies)
sum_error += pxw.err; sum_error += pxw.err;
return sum_error; return sum_error;
@ -1261,7 +1261,7 @@ private:
} }
norm = scale_functor(norm, FT(1.0 / std::sqrt(CGAL::to_double(norm.squared_length())))); norm = scale_functor(norm, FT(1.0 / std::sqrt(CGAL::to_double(norm.squared_length()))));
px_planes.push_back(ProxyPlane(fit_plane, norm, area)); px_planes.push_back(Proxy_plane(fit_plane, norm, area));
} }
} }
@ -1314,7 +1314,7 @@ private:
const halfedge_descriptor he_mark = he_start; const halfedge_descriptor he_mark = he_start;
do { do {
ChordVector chord; Chord_vector chord;
walk_to_next_anchor(he_start, chord); walk_to_next_anchor(he_start, chord);
borders.back().num_anchors += subdivide_chord(chord.begin(), chord.end(), split_criterion); borders.back().num_anchors += subdivide_chord(chord.begin(), chord.end(), split_criterion);
@ -1322,7 +1322,7 @@ private:
std::cerr << "#chord_anchor " << borders.back().num_anchors << std::endl; std::cerr << "#chord_anchor " << borders.back().num_anchors << std::endl;
#endif #endif
for (ChordVectorIterator citr = chord.begin(); citr != chord.end(); ++citr) for (Chord_vector_iterator citr = chord.begin(); citr != chord.end(); ++citr)
he_candidates.erase(*citr); he_candidates.erase(*citr);
} while (he_start != he_mark); } while (he_start != he_mark);
} }
@ -1345,7 +1345,7 @@ private:
Point_3 pt_end = pt_begin; Point_3 pt_end = pt_begin;
halfedge_descriptor he = he_mark; halfedge_descriptor he = he_mark;
ChordVector chord; Chord_vector chord;
std::size_t count = 0; std::size_t count = 0;
do { do {
walk_to_next_border_halfedge(he); walk_to_next_border_halfedge(he);
@ -1370,7 +1370,7 @@ private:
Vector_3 chord_vec = vector_functor(pt_begin, pt_end); Vector_3 chord_vec = vector_functor(pt_begin, pt_end);
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 (Chord_vector_iterator citr = chord.begin(); citr != chord.end(); ++citr) {
Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, *m_pmesh)]); 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())));
@ -1481,7 +1481,7 @@ private:
const halfedge_descriptor he_mark = bdr.he_head; const halfedge_descriptor he_mark = bdr.he_head;
halfedge_descriptor he = he_mark; halfedge_descriptor he = he_mark;
do { do {
ChordVector chord; Chord_vector chord;
walk_to_next_anchor(he, chord); walk_to_next_anchor(he, chord);
std::vector<FT> vdist; std::vector<FT> vdist;
@ -1498,7 +1498,7 @@ private:
const int anchorleft = vanchor_map[source(chord.front(), *m_pmesh)]; const int anchorleft = vanchor_map[source(chord.front(), *m_pmesh)];
const int anchorright = vanchor_map[target(chord.back(), *m_pmesh)]; 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 Chord_vector::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, *m_pmesh)]] = anchorleft; global_vtag_map[to_sgv_map[target(*hitr, *m_pmesh)]] = anchorleft;
@ -1543,7 +1543,7 @@ private:
* @param[in/out] he_start starting region border halfedge pointing to a vertex associated with an anchor * @param[in/out] he_start starting region border halfedge pointing to a vertex associated with an anchor
* @param[out] chord recorded path chord * @param[out] chord recorded path chord
*/ */
void walk_to_next_anchor(halfedge_descriptor &he_start, ChordVector &chord) const { void walk_to_next_anchor(halfedge_descriptor &he_start, Chord_vector &chord) const {
do { do {
walk_to_next_border_halfedge(he_start); walk_to_next_border_halfedge(he_start);
chord.push_back(he_start); chord.push_back(he_start);
@ -1572,8 +1572,8 @@ private:
* @return the number of anchors of the chord apart from the first one * @return the number of anchors of the chord apart from the first one
*/ */
std::size_t subdivide_chord( std::size_t subdivide_chord(
const ChordVectorIterator &chord_begin, const Chord_vector_iterator &chord_begin,
const ChordVectorIterator &chord_end, const Chord_vector_iterator &chord_end,
const FT thre) { const FT thre) {
const std::size_t chord_size = std::distance(chord_begin, chord_end); const std::size_t chord_size = std::distance(chord_begin, chord_end);
const halfedge_descriptor he_first = *chord_begin; const halfedge_descriptor he_first = *chord_begin;
@ -1586,7 +1586,7 @@ private:
return 1; return 1;
bool if_subdivide = false; bool if_subdivide = false;
ChordVectorIterator chord_max; Chord_vector_iterator chord_max;
const Point_3 &pt_begin = point_pmap[source(he_first, *m_pmesh)]; const Point_3 &pt_begin = point_pmap[source(he_first, *m_pmesh)];
const Point_3 &pt_end = point_pmap[target(he_last, *m_pmesh)]; const Point_3 &pt_end = point_pmap[target(he_last, *m_pmesh)];
if (anchor_first == anchor_last) { if (anchor_first == anchor_last) {
@ -1594,7 +1594,7 @@ private:
CGAL_assertion(chord_size > 2); CGAL_assertion(chord_size > 2);
FT dist_max(0.0); FT dist_max(0.0);
for (ChordVectorIterator citr = chord_begin; citr != chord_end; ++citr) { for (Chord_vector_iterator citr = chord_begin; citr != chord_end; ++citr) {
FT dist = CGAL::squared_distance(pt_begin, point_pmap[target(*citr, *m_pmesh)]); 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) {
@ -1611,7 +1611,7 @@ private:
FT chord_len(std::sqrt(CGAL::to_double(chord_vec.squared_length()))); FT chord_len(std::sqrt(CGAL::to_double(chord_vec.squared_length())));
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_end; ++citr) { for (Chord_vector_iterator citr = chord_begin; citr != chord_end; ++citr) {
Vector_3 vec = vector_functor(pt_begin, point_pmap[target(*citr, *m_pmesh)]); 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())));
@ -1731,7 +1731,7 @@ private:
vtx.push_back(a.pos); vtx.push_back(a.pos);
typedef typename PolyhedronSurface::HalfedgeDS HDS; typedef typename PolyhedronSurface::HalfedgeDS HDS;
TrianglePolyhedronBuilder<HDS> tpbuilder(vtx, tris); Triangle_polyhedron_builder<HDS> tpbuilder(vtx, tris);
poly.delegate(tpbuilder); poly.delegate(tpbuilder);
return tpbuilder.is_manifold; return tpbuilder.is_manifold;