FindBoundaryPoints()

bool Spices::MeshProcessor::FindBoundaryPoints ( MeshPack * meshPack, const std::vector< glm::uvec3 > & primVertices, std::unordered_map< uint32_t, bool > & boundaryPoints, std::unordered_map< uint32_t, bool > & stableBoundaryPoints, std::unordered_map< uint32_t, EdgePoint > & boundaryEdgePoints, std::unordered_map< uint32_t, std::unordered_map< uint32_t, bool > > & pointConnect )

staticprivate

Find Points located in Boundaries.

Parameters

[in]	meshPack	MeshPack.
[in]	primVertices	.
[in,out]	boundaryPoints	.
[in,out]	stableBoundaryPoints	.
[in,out]	boundaryEdgePoints	.
[in,out]	pointConnect	.

Returns

Returns true if succeed.

Get edge connected primitive.

Get pointconnect.

get bound edge points.

only stable points with high curvature.

Get edge connected primitive.

Get pointconnect.

get bound edge points.

only stable points with high curvature.

Definition at line 809 of file MeshProcessor.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        std::unordered_map<Edge, uint32_t> edgesConnects;
        auto& vertices = *meshPack->m_MeshResource.vertices.attributes;
        for (uint32_t triangleIndex = 0; triangleIndex < primVertices.size(); triangleIndex++)
        {
            auto& primVertex = primVertices[triangleIndex];
            std::array<uint32_t, 3> primVertexArray = { primVertex.x, primVertex.y, primVertex.z };
 
            for (uint32_t i = 0; i < 3; i++)
            {
                Edge edge;
                edge.first  = vertices[primVertexArray[i]].x;
                edge.second = vertices[primVertexArray[(i + 1) % 3]].x;
 
                if (edgesConnects.find(edge) == edgesConnects.end())
                {
                    edgesConnects[edge] = 1;
                }
                else
                {
                    edgesConnects[edge]++;
                }
            }
        }
 
        for (auto& [edge, connects] : edgesConnects)
        {
            pointConnect[edge.first][edge.second] = true;
            pointConnect[edge.first][edge.first]  = true;
 
            pointConnect[edge.second][edge.first]  = true;
            pointConnect[edge.second][edge.second] = true;
        }
 
        /*
        * @brief remove internal edge.
        */
        for (auto first = edgesConnects.begin(), last = edgesConnects.end(); first != last;)
        {
            if ((*first).second != 1)
            {
                first = edgesConnects.erase(first);
            }
            else
            {
                ++first;
            }
        }
 
        for (auto& [edge, connects] : edgesConnects)
        {
            boundaryPoints[edge.first]  = true;
            boundaryPoints[edge.second] = true;
        }
 
        for (auto& [edge, connects] : edgesConnects)
        {
            if (boundaryEdgePoints.find(edge.first) == boundaryEdgePoints.end())
            {
                boundaryEdgePoints[edge.first].self = edge.first;
                boundaryEdgePoints[edge.first].next = edge.second;
            }
            else
            {
                boundaryEdgePoints[edge.first].prev = edge.second;
            }
 
            if (boundaryEdgePoints.find(edge.second) == boundaryEdgePoints.end())
            {
                boundaryEdgePoints[edge.second].self = edge.second;
                boundaryEdgePoints[edge.second].next = edge.first;
            }
            else
            {
                boundaryEdgePoints[edge.second].prev = edge.first;
            }
        }
 
        auto& position = *meshPack->m_MeshResource.positions.attributes;
        for (auto& pair : boundaryEdgePoints)
        {
            if (!pair.second.valid()) continue;
 
            glm::vec3 l = glm::normalize(position[pair.second.next] - position[pair.first]);
            glm::vec3 r = glm::normalize(position[pair.second.prev] - position[pair.first]);
            
            if (glm::dot(l, r) > -0.98f)
            {
                stableBoundaryPoints[pair.second.self] = true;
 
#define ExpandStablePoint
#ifdef ExpandStablePoint
 
                stableBoundaryPoints[pair.second.next] = true;
                stableBoundaryPoints[pair.second.prev] = true;
 
#endif
 
            }
        }
 
        return true;
    }