inline Bvert_list
reorder(CBedge_list& edges)
{
Bvert_list ret;
Bvert_list verts = edges.get_verts();
for (Bvert_list::size_type i = 0; i < verts.size(); i++)
if (Bpoint::find_controller(verts[i]) || Bcurve::find_controller(verts[i])) {
ret.push_back(verts[i]);
break;
}
if (ret.empty())
return ret;
for (Bvert_list::size_type i = 1; i < verts.size(); i++) {
for (Bedge_list::size_type j = 0; j < edges.size(); j++) {
Bvert* v = edges[j]->other_vertex(ret.back());
if (v && std::find(ret.begin(), ret.end(), v) == ret.end()) {
ret.push_back(v);
break;
}
}
}
err_adv(debug, " reorder: num of verts: %d", ret.size());
return ret;
}
void
EdgeStrip::build_with_tips(CBedge_list& edges, CSimplexFilter& filter)
{
// Build the strip from the given pool of edges, with the
// given filter. Try to start the edge strip at the "tips" of
// chains of edges of the desired type. The given filter
// should just screen for edges of the desired kind;
// internally this method also screens for edges that have not
// yet been reached (added to the strip).
// Clear edge flags to screen for unreached edges:
set_adjacent_edges(edges.get_verts(), 1);
edges.clear_flags();
// Pull out the edge tips:
Bedge_list tips = edges.filter(ChainTipEdgeFilter(filter));
// Construct the filter that screens out previously reached
// edges:
UnreachedSimplexFilter unreached;
AndFilter wanted = unreached + filter;
int k;
// Start from all the tips first:
for (k=0; k<tips.num(); k++) {
Bedge* e = tips[k];
Bvert* v = (e->v2()->degree(filter) != 2) ? e->v2() : e->v1();
build(v, e, wanted);
}
// Now check the rest:
for (k=0; k<edges.num(); k++)
build(0, edges[k], wanted);
}
void
Bbase::add_edge_memes(CBedge_list& edges)
{
if (!(_mesh && _mesh == edges.mesh())) {
err_msg("Bbase::add_edge_memes: Error: bad mesh");
return;
}
for (int i=0; i<edges.num(); i++)
add_edge_meme((Ledge*)edges[i]);
}
void
EdgeStrip::build_ccw_boundaries(
CBedge_list& edges,
CSimplexFilter& face_filter
)
{
// Similar to previous...
//
// XXX - needs comments
// Clear edge flags to screen for unreached edges:
// set edge flags to 1 in 1-ring of verts,
// then clear edge flags of internal edges
set_adjacent_edges(edges.get_verts(), 1);
edges.clear_flags();
// get an edge filter that accepts "boundary" edges WRT the
// given face filter
BoundaryEdgeFilter boundary(face_filter);
// Pull out the edge tips:
Bedge_list tips = edges.filter(ChainTipEdgeFilter(boundary));
// Construct the filter that screens out previously reached
// edges:
UnreachedSimplexFilter unreached;
AndFilter wanted = unreached + boundary;
int k;
// Start from all the tips first:
for (k=0; k<tips.num(); k++) {
Bedge* e = tips[k];
Bvert* v = (e->v2()->degree(boundary) != 2) ? e->v2() : e->v1();
Bface* f = e->screen_face(face_filter);
assert(f); // e must have 1 face satisfying the filter
// If this will start out running ccw, take it.
// otherwise skip:
if (f->next_vert_ccw(v) == e->other_vertex(v))
build(v, e, wanted);
}
// Now check the rest:
for (k=0; k<edges.num(); k++) {
Bedge* e = edges[k];
Bface* f = e->screen_face(face_filter);
assert(f); // e must have 1 face satisfying the filter
// Go CCW around faces
build(f->leading_vert_ccw(e), e, wanted);
}
}
inline Bface_list
ctrl_faces(CBedge_list& edges)
{
if (!dynamic_pointer_cast<LMESH>(edges.mesh()))
return Bface_list();
Bface_list ret(edges.size());
for (Bedge_list::size_type i=0; i<edges.size(); i++) {
Bface* f = ((Ledge*)edges[i])->ctrl_face();
if (f)
ret.push_back(f);
}
return ret.unique_elements().quad_complete_faces();
}
EdgeMemeList
Bbase::find_boss_ememes(CBedge_list& edges)
{
// Convenience: lookup boss memes for a whole list of edges
EdgeMemeList ret(edges.num());
for (int i=0; i<edges.num(); i++) {
EdgeMeme* vm = find_boss_ememe(edges[i]);
if (vm)
ret += vm;
}
return ret;
}
Bbase_list
Bbase::find_owners(CBedge_list& edges)
{
Bbase_list ret = find_owners(edges.get_verts());
_find_owners(edges, ret);
return ret;
}
inline void
update_edges(CBedge_list& edges)
{
// helper for LMESH::update_subdivision(CBface_list& faces)
for (Bedge_list::size_type i=0; i<edges.size(); i++)
((Ledge*)edges[i])->update_subdivision();
}
inline void
update_edges(CBedge_list& edges)
{
// helper for LMESH::update_subdivision(CBface_list& faces)
for (int i=0; i<edges.num(); i++)
((Ledge*)edges[i])->update_subdivision();
}
inline bool
copy_edges(CBedge_list& edges, CVertMapper& vmap)
{
bool ret = true;
for (Bedge_list::size_type i=0; i<edges.size(); i++)
if (!copy_edge(edges[i], vmap))
ret = false;
return ret;
}
bool
Skin::copy_edges(CBedge_list& edges) const
{
bool ret = true;
for (int i=0; i<edges.num(); i++)
if (!copy_edge(edges[i]))
ret = false;
return ret;
}
inline double
compute_yardstick(CBedge_list& edges, bool debug=false)
{
double ret = 0.6 * edges.strong_edges().avg_len();
BMESHptr mk = edges.mesh();
BMESHptr m0 = get_top_level(edges.get_faces()).mesh();
int lk = 0; // mesh level of edges
int l0 = 0; // mesh level of edges' control region
double s = 1; // scaling factor
if (mk && m0) {
lk = mk->subdiv_level();
l0 = m0->subdiv_level();
s = (1 << (lk - l0));
}
err_adv(debug, "lk: %d, l0: %d, scaling: %f", lk, l0, s);
return s * ret;
}
void
EdgeStrip::build(CBedge_list& edges, CSimplexFilter& filter)
{
// Given a list of edges to search, build the strip from edges
// that satisfy a given property.
reset();
for (int k=0; k<edges.num(); k++)
build(0, edges[k], filter);
}
