topology.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_ALGORITHMS_MESH_UPDATE_TOPOLOGY_H
#define VCL_ALGORITHMS_MESH_UPDATE_TOPOLOGY_H
 
#include <vclib/algorithms/mesh/sort.h>
#include <vclib/mesh/requirements.h>
 
namespace vcl {
 
template<MeshConcept MeshType>
void clearPerVertexAdjacentFaces(MeshType& m)
{
    requirePerVertexAdjacentFaces(m);
 
    using VertexType = MeshType::VertexType;
 
    for (VertexType& v : m.vertices()) {
        v.clearAdjFaces();
    }
}
 
template<FaceMeshConcept MeshType>
void updatePerVertexAdjacentFaces(MeshType& m)
{
    clearPerVertexAdjacentFaces(m);
 
    using VertexType = MeshType::VertexType;
    using FaceType   = MeshType::FaceType;
 
    for (VertexType& v : m.vertices()) {
        v.clearAdjFaces();
    }
 
    for (FaceType& f : m.faces()) {
        for (VertexType* v : f.vertices()) {
            v->pushAdjFace(&f);
        }
    }
}
 
template<MeshConcept MeshType>
void clearPerVertexAdjacentVertices(MeshType& m)
{
    requirePerVertexAdjacentVertices(m);
 
    using VertexType = MeshType::VertexType;
 
    for (VertexType& v : m.vertices()) {
        v.clearAdjVertices();
    }
}
 
template<FaceMeshConcept MeshType>
void updatePerVertexAdjacentVertices(MeshType& m)
{
    clearPerVertexAdjacentVertices(m);
 
    using VertexType = MeshType::VertexType;
 
    // vector that contains edges sorted trough unordered vertex pointers
    // it contains clusters of "same" edges, but each one of them has its face
    // pointer note that in case on non-manifold mesh, clusters may be of size
    // >= 2
    std::vector<MeshEdgeUtil<MeshType>> vec = fillAndSortMeshEdgeUtilVector(m);
 
    // store the last pair of vertices
    VertexType* v1 = nullptr;
    VertexType* v2 = nullptr;
    for (uint i = 0; i < vec.size(); ++i) {
        // if this pair is different from the last pair
        if (vec[i].v[0] != v1 || vec[i].v[1] != v2) {
            // update last pair
            v1 = vec[i].v[0];
            v2 = vec[i].v[1];
            v1->pushAdjVertex(v2); // set the pair as adjacent
            v2->pushAdjVertex(v1);
        }
    }
}
 
template<FaceMeshConcept MeshType>
void clearPerFaceAdjacentFaces(MeshType& m)
{
    requirePerFaceAdjacentFaces(m);
 
    using FaceType = MeshType::FaceType;
 
    for (FaceType& f : m.faces()) {
        for (uint i = 0; i < f.adjFacesNumber(); ++i) {
            f.setAdjFace(i, nullptr);
        }
    }
}
 
template<FaceMeshConcept MeshType>
void updatePerFaceAdjacentFaces(MeshType& m)
{
    requirePerFaceAdjacentFaces(m);
 
    // vector that contains edges sorted trough unordered vertex pointers
    // it contains clusters of "same" edges, but each one of them has its face
    // pointer note that in case on non-manifold mesh, clusters may be of size
    // >= 2
    std::vector<MeshEdgeUtil<MeshType>> vec = fillAndSortMeshEdgeUtilVector(m);
 
    if (vec.size() > 0) {
        // in this loop, base will point to the first element of a cluster of
        // edges
        // increment of clusters into loop
        for (auto base = vec.begin(); base != vec.end();) {
            auto first = base; // remember the first to set adj to the last
 
            // i and j will increment together, and if i == j, i will be adj to
            // j, but j will not be adj to i (to manage non manifold edges and
            // make cyclic adj on the same edge)
            auto i = base;
            auto j = i + 1;
            if (j != vec.end()) {
                // case of cluster composed of one element. adj of i is nullptr
                if (*i != *j) {
                    i->f->setAdjFace(i->e, nullptr);
                }
                else { // at least two edges in the cluster
                    while (j != vec.end() && *i == *j) {
                        i->f->setAdjFace(i->e, j->f);
                        ++i;
                        ++j;
                    }
                    // i now is the last element that was equal to first
                    i->f->setAdjFace(i->e, first->f);
                }
            }
 
            // j is the first different edge from first (or it is vec.end()!)
            base = j;
        }
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_UPDATE_TOPOLOGY_H