MergeByDistance()

bool Spices::MeshProcessor::MergeByDistance ( MeshPack * meshPack, std::vector< glm::uvec3 > & primVertices, scl::kd_tree< 6 > & kdTree, float maxDistance, float maxUVDistance )

staticprivate

Merge Vertex by Distance.

Parameters

[in]	meshPack	MeshPack.
[in]	kdTree	kd_tree.
[in]	maxDistance	allowed merge by vertex position.
[in]	maxUVDistance	allowed merge by vertex uv.

Returns

Returns Merged Vertex Map.

Get boundary points.

Find merged vertices.

Find near vertex.

Only allow near merge.

Can merge if this vertex is in stableboundary.

Attention

This situation not allowed merge to line and point here.

Can merge when target is not in stableboundary if this vertex is in boundary.

Attention

boundarypoint can only be merged when connected.

Can merge when target is not in boundary if this vertex is not in boundary.

Copy primVertices and merge.

Remove lines and poins merged from triangles;

Get boundary points.

Find merged vertices.

Find near vertex.

Only allow near merge.

Can merge if this vertex is in stableboundary.

Attention

This situation not allowed merge to line and point here.

Can merge when target is not in stableboundary if this vertex is in boundary.

Attention

boundarypoint can only be merged when connected.

Can merge when target is not in boundary if this vertex is not in boundary.

Copy primVertices and merge.

Remove lines and poins merged from triangles;

Definition at line 504 of file MeshProcessor.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        auto& positions = *meshPack->m_MeshResource.positions.attributes;
        auto& texCoords = *meshPack->m_MeshResource.texCoords.attributes;
        auto& vertices  = *meshPack->m_MeshResource.vertices .attributes;
 
        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;
        FindBoundaryPoints(
            meshPack             , 
            primVertices         , 
            boundaryPoints       , 
            stableBoundaryPoints , 
            boundaryEdgePoints   , 
            pointConnect
        );
 
        std::unordered_map<uint32_t, uint32_t> primVerticesMap;
        auto addToMap = [&](const uint32_t& k, const uint32_t& v) {
            if (primVerticesMap.find(k) == primVerticesMap.end())
            {
                primVerticesMap[k] = v;
            }
        };
 
        for (int i = 0; i < primVertices.size(); i++)
        {
            auto& primVertex = primVertices[i];
        
            std::array<uint32_t, 3> primVertexArray = { primVertex.x, primVertex.y, primVertex.z };
        
            for (int j = 0; j < 3; j++)
            {
                const glm::uvec4& vertex = vertices[primVertexArray[j]];
        
                scl::kd_tree<6>::item item = { 
                    positions[vertex.x].x, 
                    positions[vertex.x].y, 
                    positions[vertex.x].z, 
                    texCoords[vertex.w].x, 
                    texCoords[vertex.w].y, 
                    (float)primVertexArray[j] 
                };
                auto rangeVts = kdTree.range_search(item, { 
                    maxDistance   , 
                    maxDistance   , 
                    maxDistance   , 
                    maxUVDistance , 
                    maxUVDistance , 
                    (float)UINT32_MAX 
                });
        
                std::vector<scl::kd_tree<6>::item> nearVts;
                for (auto& vt : rangeVts)
                {
                    uint32_t pt = vertices[(uint32_t)vt[5]].x;
                
                    if (pointConnect[vertex.x].find(pt) != pointConnect[vertex.x].end())
                    {
                        nearVts.push_back(vt);
                    }
                }
        
                if (stableBoundaryPoints.find(vertex.x) != stableBoundaryPoints.end())
                {
                    std::unordered_map<uint32_t, bool> mergedVertex;
        
                    for (auto& rangeVt : nearVts)
                    {
                        uint32_t primVertexIndex = (uint32_t)rangeVt[5];
                        mergedVertex[vertices[primVertexIndex].x] = true;
                    }
        
                    bool canBeTriangle = true;
                    for (int k = 0; k < primVertexArray.size(); k++)
                    {
                        if (mergedVertex.find(vertices[primVertexArray[k]].x) != mergedVertex.end())
                        {
                            canBeTriangle = false;
                            break;
                        }
                    }
        
                    if(canBeTriangle)
                    { 
                        for (auto& rangeVt : nearVts)
                        {
                            uint32_t primVertexIndex = (uint32_t)rangeVt[5];
                            addToMap(primVertexIndex, primVertexArray[j]);
                        }
                    }
                    else
                    {
                        addToMap(primVertexArray[j], primVertexArray[j]);
                    }
                }
        
                else if (boundaryPoints.find(vertex.x) != boundaryPoints.end())
                {
                    for (auto& rangeVt : nearVts)
                    {
                        uint32_t primVertexIndex = (uint32_t)rangeVt[5];
                        uint32_t pt = vertices[primVertexIndex].x;
        
                        if (boundaryPoints.find(pt) == boundaryPoints.end())
                        {
                            addToMap(primVertexIndex, primVertexArray[j]);
                        }
                        else if (stableBoundaryPoints.find(pt) == stableBoundaryPoints.end())
                        {
                            if (boundaryEdgePoints[vertex.x].next == pt ||
                                boundaryEdgePoints[vertex.x].prev == pt ||
                                boundaryEdgePoints[vertex.x].self == pt
                            )
                            {
                                addToMap(primVertexIndex, primVertexArray[j]);
                            }
                        }
                    }
                }
        
                else
                {
                    for (auto& rangeVt : nearVts)
                    {
                        uint32_t primVertexIndex = (uint32_t)rangeVt[5];
                        uint32_t pt = vertices[primVertexIndex].x;
        
                        if (boundaryPoints.find(pt) == boundaryPoints.end())
                        {
                            addToMap(primVertexIndex, primVertexArray[j]);
                        }
                    }
                }
            }
        }
 
        std::vector<glm::uvec3> tempPrimVertices = primVertices;
        for (int i = 0; i < primVertices.size(); i++)
        {
            auto primVertex = primVertices[i];
        
            if(primVerticesMap.find(primVertex.x) != primVerticesMap.end()) tempPrimVertices[i].x = primVerticesMap[primVertex.x];
            if(primVerticesMap.find(primVertex.y) != primVerticesMap.end()) tempPrimVertices[i].y = primVerticesMap[primVertex.y];
            if(primVerticesMap.find(primVertex.z) != primVerticesMap.end()) tempPrimVertices[i].z = primVerticesMap[primVertex.z];
        }
        
        primVertices.clear();
        for (auto& primVertex : tempPrimVertices)
        {
            std::set<uint32_t> set;
            
            set.insert(primVertex.x);
            set.insert(primVertex.y);
            set.insert(primVertex.z);
            
            if (set.size() < 3) continue;
        
            primVertices.push_back(primVertex);
        }
 
        return true;
    }