bool
TopologyRefinerFactoryBase::prepareComponentTagsAndSharpness(TopologyRefiner& refiner) {
//
// This method combines the initialization of internal component tags with the sharpening
// of edges and vertices according to the given boundary interpolation rule in the Options.
// Since both involve traversing the edge and vertex lists and noting the presence of
// boundaries -- best to do both at once...
//
Vtr::internal::Level& baseLevel = refiner.getLevel(0);
Sdc::Options options = refiner.GetSchemeOptions();
Sdc::Crease creasing(options);
bool makeBoundaryFacesHoles = (options.GetVtxBoundaryInterpolation() == Sdc::Options::VTX_BOUNDARY_NONE);
bool sharpenCornerVerts = (options.GetVtxBoundaryInterpolation() == Sdc::Options::VTX_BOUNDARY_EDGE_AND_CORNER);
bool sharpenNonManFeatures = true; //(options.GetNonManifoldInterpolation() == Sdc::Options::NON_MANIFOLD_SHARP);
//
// Process the Edge tags first, as Vertex tags (notably the Rule) are dependent on
// properties of their incident edges.
//
for (Vtr::Index eIndex = 0; eIndex < baseLevel.getNumEdges(); ++eIndex) {
Vtr::internal::Level::ETag& eTag = baseLevel.getEdgeTag(eIndex);
float& eSharpness = baseLevel.getEdgeSharpness(eIndex);
eTag._boundary = (baseLevel.getNumEdgeFaces(eIndex) < 2);
if (eTag._boundary || (eTag._nonManifold && sharpenNonManFeatures)) {
eSharpness = Sdc::Crease::SHARPNESS_INFINITE;
}
eTag._infSharp = Sdc::Crease::IsInfinite(eSharpness);
eTag._semiSharp = Sdc::Crease::IsSharp(eSharpness) && !eTag._infSharp;
}
//
// Process the Vertex tags now -- for some tags (semi-sharp and its rule) we need
// to inspect all incident edges:
//
int schemeRegularInteriorValence = Sdc::SchemeTypeTraits::GetRegularVertexValence(refiner.GetSchemeType());
int schemeRegularBoundaryValence = schemeRegularInteriorValence / 2;
for (Vtr::Index vIndex = 0; vIndex < baseLevel.getNumVertices(); ++vIndex) {
Vtr::internal::Level::VTag& vTag = baseLevel.getVertexTag(vIndex);
float& vSharpness = baseLevel.getVertexSharpness(vIndex);
Vtr::ConstIndexArray vEdges = baseLevel.getVertexEdges(vIndex);
Vtr::ConstIndexArray vFaces = baseLevel.getVertexFaces(vIndex);
//
// Take inventory of properties of incident edges that affect this vertex:
//
int boundaryEdgeCount = 0;
int infSharpEdgeCount = 0;
int semiSharpEdgeCount = 0;
int nonManifoldEdgeCount = 0;
for (int i = 0; i < vEdges.size(); ++i) {
Vtr::internal::Level::ETag const& eTag = baseLevel.getEdgeTag(vEdges[i]);
boundaryEdgeCount += eTag._boundary;
infSharpEdgeCount += eTag._infSharp;
semiSharpEdgeCount += eTag._semiSharp;
nonManifoldEdgeCount += eTag._nonManifold;
}
int sharpEdgeCount = infSharpEdgeCount + semiSharpEdgeCount;
//
// Sharpen the vertex before using it in conjunction with incident edge
// properties to determine the semi-sharp tag and rule:
//
bool isTopologicalCorner = (vFaces.size() == 1) && (vEdges.size() == 2);
bool isSharpenedCorner = isTopologicalCorner && sharpenCornerVerts;
if (isSharpenedCorner) {
vSharpness = Sdc::Crease::SHARPNESS_INFINITE;
} else if (vTag._nonManifold && sharpenNonManFeatures) {
//
// We avoid sharpening non-manifold vertices when they occur on interior
// non-manifold creases, i.e. a pair of opposing non-manifold edges with
// more than two incident faces. In these cases there are more incident
// faces than edges (1 more for each additional "fin") and no boundaries.
//
if (not ((nonManifoldEdgeCount == 2) && (boundaryEdgeCount == 0) && (vFaces.size() > vEdges.size()))) {
vSharpness = Sdc::Crease::SHARPNESS_INFINITE;
}
}
vTag._infSharp = Sdc::Crease::IsInfinite(vSharpness);
vTag._semiSharp = Sdc::Crease::IsSemiSharp(vSharpness);
vTag._semiSharpEdges = (semiSharpEdgeCount > 0);
vTag._rule = (Vtr::internal::Level::VTag::VTagSize)creasing.DetermineVertexVertexRule(vSharpness, sharpEdgeCount);
//
// Assign topological tags -- note that the "xordinary" tag is not strictly
// correct (or relevant) if non-manifold:
//
vTag._boundary = (boundaryEdgeCount > 0);
vTag._corner = isSharpenedCorner;
if (vTag._corner) {
vTag._xordinary = false;
} else if (vTag._boundary) {
vTag._xordinary = (vFaces.size() != schemeRegularBoundaryValence);
} else {
vTag._xordinary = (vFaces.size() != schemeRegularInteriorValence);
}
vTag._incomplete = 0;
//
// Having just decided if a vertex is on a boundary, and with its incident faces
// available, mark incident faces as holes.
//
if (makeBoundaryFacesHoles && vTag._boundary) {
for (int i = 0; i < vFaces.size(); ++i) {
baseLevel.getFaceTag(vFaces[i])._hole = true;
// Don't forget this -- but it will eventually move to the Level
refiner._hasHoles = true;
}
}
}
return true;
}
