face_container.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_MESH_CONTAINERS_FACE_CONTAINER_H
#define VCL_MESH_CONTAINERS_FACE_CONTAINER_H
 
#include "base/element_container.h"
 
#include <vclib/mesh/elem_algorithms.h>
#include <vclib/mesh/elements/face.h>
#include <vclib/mesh/elements/face_components.h>
 
#include <vclib/algorithms/core.h>
 
namespace vcl {
namespace mesh {
 
template<FaceConcept T>
class FaceContainer : public ElementContainer<T>
{
    template<FaceConcept U>
    friend class FaceContainer;
 
    using FaceContainerType = FaceContainer<T>;
    using Base              = ElementContainer<T>;
 
public:
    using Face              = T;
    using FaceType          = T;
    using FaceIterator      = Base::ElementIterator;
    using ConstFaceIterator = Base::ConstElementIterator;
 
    FaceContainer() = default;
 
    const FaceType& face(uint i) const { return Base::element(i); }
 
    FaceType& face(uint i) { return Base::element(i); }
 
    uint faceNumber() const { return Base::elementNumber(); }
 
    uint faceContainerSize() const { return Base::elementContainerSize(); }
 
    uint deletedFaceNumber() const { return Base::deletedElementNumber(); }
 
    uint addFace() { return Base::addElement(); }
 
    template<typename... V>
    uint addFace(V... args) requires (sizeof...(args) >= 3)
    {
        uint  fid = addFace();
        Face& f   = face(fid);
 
        constexpr uint n = sizeof...(args);
 
        if constexpr (T::VERTEX_NUMBER < 0) {
            f.resizeVertices(n);
        }
        else {
            static_assert(
                n == T::VERTEX_NUMBER,
                "Wrong number of vertices in Mesh::addFace.");
        }
 
        addFaceHelper(f, args...);
        return fid;
    }
 
    template<Range Rng>
    uint addFace(Rng&& r) requires (
        InputRange<Rng, typename Face::VertexType*> || InputRange<Rng, uint>)
    {
        auto begin = std::ranges::begin(r);
        auto end   = std::ranges::end(r);
 
        if (begin == end)
            return UINT_NULL;
        uint n = std::distance(begin, end);
 
        uint fid = UINT_NULL;
 
        assert(n >= 3);
        if (n < 3)
            return UINT_NULL;
 
        if constexpr (T::VERTEX_NUMBER < 0) {
            fid = addFace();
            face(fid).resizeVertices(n);
        }
        else {
            assert(n == T::VERTEX_NUMBER);
            if (n == T::VERTEX_NUMBER)
                fid = addFace();
        }
 
        if (fid != UINT_NULL) {
            Face& f = face(fid);
 
            unsigned int i = 0;
            for (auto it = begin; it != end; ++it) {
                f.setVertex(i, *it);
                ++i;
            }
        }
        return fid;
    }
 
    uint addFaces(uint n) { return Base::addElements(n); }
 
    void clearFaces() { Base::clearElements(); }
 
    void resizeFaces(uint n) { Base::resizeElements(n); }
 
    void reserveFaces(uint n) { Base::reserveElements(n); }
 
    void compactFaces() { Base::compactElements(); }
 
    void deleteFace(uint i) { Base::deleteElement(i); }
 
    void deleteFace(const FaceType* f) { Base::deleteElement(f); }
 
    uint faceIndexIfCompact(uint i) const
    {
        return Base::elementIndexIfCompact(i);
    }
 
    std::vector<uint> faceCompactIndices() const
    {
        return Base::elementCompactIndices();
    }
 
    void updateFaceReferences(const std::vector<uint>& newIndices)
    {
        Base::updateElementReferences(newIndices);
    }
 
    FaceIterator faceBegin(bool jumpDeleted = true)
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    FaceIterator faceEnd() { return Base::elementEnd(); }
 
    ConstFaceIterator faceBegin(bool jumpDeleted = true) const
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    ConstFaceIterator faceEnd() const { return Base::elementEnd(); }
 
    auto faces(bool jumpDeleted = true) { return Base::elements(jumpDeleted); }
 
    auto faces(uint begin, uint end = UINT_NULL)
    {
        return Base::elements(begin, end);
    }
 
    auto faces(bool jumpDeleted = true) const
    {
        return Base::elements(jumpDeleted);
    }
 
    auto faces(uint begin, uint end = UINT_NULL) const
    {
        return Base::elements(begin, end);
    }
 
    void enableAllPerFaceOptionalComponents()
    {
        Base::enableAllOptionalComponents();
    }
 
    void disableAllPerFaceOptionalComponents()
    {
        Base::disableAllOptionalComponents();
    }
 
    // AdjacentEdges
 
    bool isPerFaceAdjacentEdgesEnabled() const
        requires face::HasOptionalAdjacentEdges<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentEdges>();
    }
 
    void enablePerFaceAdjacentEdges() requires face::HasOptionalAdjacentEdges<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    void disablePerFaceAdjacentEdges()
        requires face::HasOptionalAdjacentEdges<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    // AdjacentFaces
 
    bool isPerFaceAdjacentFacesEnabled() const
        requires face::HasOptionalAdjacentFaces<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentFaces>();
    }
 
    void enablePerFaceAdjacentFaces() requires face::HasOptionalAdjacentFaces<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    void disablePerFaceAdjacentFaces()
        requires face::HasOptionalAdjacentFaces<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    // Color
 
    bool isPerFaceColorEnabled() const requires face::HasOptionalColor<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Color>();
    }
 
    void enablePerFaceColor() requires face::HasOptionalColor<T>
    {
        Base::template enableOptionalComponent<typename T::Color>();
    }
 
    void disablePerFaceColor() requires face::HasOptionalColor<T>
    {
        Base::template disableOptionalComponent<typename T::Color>();
    }
 
    // Mark
 
    bool isPerFaceMarkEnabled() const requires face::HasOptionalMark<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Mark>();
    }
 
    void enablePerFaceMark() requires face::HasOptionalMark<T>
    {
        Base::template enableOptionalComponent<typename T::Mark>();
    }
 
    void disablePerFaceMark() requires face::HasOptionalMark<T>
    {
        Base::template disableOptionalComponent<typename T::Mark>();
    }
 
    // MaterialIndex
 
    bool isPerFaceMaterialIndexEnabled() const
        requires face::HasOptionalMaterialIndex<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::MaterialIndex>();
    }
 
    void enablePerFaceMaterialIndex() requires face::HasOptionalMaterialIndex<T>
    {
        Base::template enableOptionalComponent<typename T::MaterialIndex>();
    }
 
    void disablePerFaceMaterialIndex()
        requires face::HasOptionalMaterialIndex<T>
    {
        Base::template disableOptionalComponent<typename T::MaterialIndex>();
    }
 
    // Normal
 
    bool isPerFaceNormalEnabled() const requires face::HasOptionalNormal<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Normal>();
    }
 
    void enablePerFaceNormal() requires face::HasOptionalNormal<T>
    {
        Base::template enableOptionalComponent<typename T::Normal>();
    }
 
    void disablePerFaceNormal() requires face::HasOptionalNormal<T>
    {
        Base::template disableOptionalComponent<typename T::Normal>();
    }
 
    // PrincipalCurvature
 
    bool isPerFacePrincipalCurvatureEnabled() const
        requires face::HasOptionalPrincipalCurvature<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::PrincipalCurvature>();
    }
 
    void enablePerFacePrincipalCurvature()
        requires face::HasOptionalPrincipalCurvature<T>
    {
        Base::template enableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    void disablePerFacePrincipalCurvature()
        requires face::HasOptionalPrincipalCurvature<T>
    {
        Base::template disableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    // Quality
 
    bool isPerFaceQualityEnabled() const requires face::HasOptionalQuality<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Quality>();
    }
 
    void enablePerFaceQuality() requires face::HasOptionalQuality<T>
    {
        Base::template enableOptionalComponent<typename T::Quality>();
    }
 
    void disablePerFaceQuality() requires face::HasOptionalQuality<T>
    {
        Base::template disableOptionalComponent<typename T::Quality>();
    }
 
    // WedgeColors
 
    bool isPerFaceWedgeColorsEnabled() const
        requires face::HasOptionalWedgeColors<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::WedgeColors>();
    }
 
    void enablePerFaceWedgeColors() requires face::HasOptionalWedgeColors<T>
    {
        Base::template enableOptionalComponent<typename T::WedgeColors>();
    }
 
    void disablePerFaceWedgeColors() requires face::HasOptionalWedgeColors<T>
    {
        Base::template disableOptionalComponent<typename T::WedgeColors>();
    }
 
    // WedgeTexCoords
 
    bool isPerFaceWedgeTexCoordsEnabled() const
        requires face::HasOptionalWedgeTexCoords<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::WedgeTexCoords>();
    }
 
    void enablePerFaceWedgeTexCoords()
        requires face::HasOptionalWedgeTexCoords<T>
    {
        Base::template enableOptionalComponent<typename T::WedgeTexCoords>();
    }
 
    void disablePerFaceWedgeTexCoords()
        requires face::HasOptionalWedgeTexCoords<T>
    {
        Base::template disableOptionalComponent<typename T::WedgeTexCoords>();
    }
 
    // Custom Components
 
    bool hasPerFaceCustomComponent(const std::string& name) const
        requires face::HasCustomComponents<T>
    {
        return Base::hasElemCustomComponent(name);
    }
 
    std::vector<std::string> perFaceCustomComponentNames() const
        requires face::HasCustomComponents<T>
    {
        return Base::elemCustomComponentNames();
    }
 
    template<typename K>
    bool isPerFaceCustomComponentOfType(const std::string& name) const
        requires face::HasCustomComponents<T>
    {
        return Base::template isElemCustomComponentOfType<K>(name);
    }
 
    std::type_index perFaceCustomComponentType(const std::string& name) const
        requires face::HasCustomComponents<T>
    {
        return Base::elemComponentType(name);
    }
 
    template<typename K>
    std::vector<std::string> perFaceCustomComponentNamesOfType() const
        requires face::HasCustomComponents<T>
    {
        return Base::template elemCustomComponentNamesOfType<K>();
    }
 
    template<typename K>
    void addPerFaceCustomComponent(const std::string& name)
        requires face::HasCustomComponents<T>
    {
        Base::template addElemCustomComponent<K>(name);
    }
 
    void deletePerFaceCustomComponent(const std::string& name)
        requires face::HasCustomComponents<T>
    {
        Base::deleteElemCustomComponent(name);
    }
 
    template<typename K>
    CustomComponentVectorHandle<K> perFaceCustomComponentVectorHandle(
        const std::string& name) requires face::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    ConstCustomComponentVectorHandle<K> perFaceCustomComponentVectorHandle(
        const std::string& name) const requires face::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    void serializePerFaceCustomComponentsOfType(std::ostream& os) const
        requires face::HasCustomComponents<T>
    {
        Base::template serializePerElementCustomComponentsOfType<K>(os);
    }
 
    template<typename K>
    void deserializePerFaceCustomComponentsOfType(std::istream& is)
        requires face::HasCustomComponents<T>
    {
        Base::template deserializePerElementCustomComponentsOfType<K>(is);
    }
 
protected:
    template<typename OthMesh>
    void manageImportTriFromPoly(const OthMesh& m)
    {
        using ParentMesh  = Base::ParentMeshType;
        using VertexType  = ParentMesh::VertexType;
        using MVertexType = OthMesh::VertexType;
        using MFaceType   = OthMesh::FaceType;
 
        using VertexContainer = ParentMesh::VertexContainer;
 
        // if this is not a triangle mesh nor a polygon mesh (meaning that we
        // can't control the number of vertex pointers in this mesh), and this
        // mesh does not have the same number of vertex pointers of the other,
        // it means that we don't know how to convert these type of meshes (e.g.
        // we don't know how to convert a polygon mesh into a quad mesh, or
        // convert a quad mesh into a pentagonal mesh...)
        static_assert(
            !(FaceType::VERTEX_NUMBER != 3 && FaceType::VERTEX_NUMBER > 0 &&
              FaceType::VERTEX_NUMBER != MFaceType::VERTEX_NUMBER),
            "Cannot import from that type of Mesh. Don't know how to "
            "convert faces.");
 
        // we need to manage conversion from poly or faces with cardinality > 3
        // (e.g. quads) to triangle meshes. In this case, we triangulate the
        // polygon using the earcut algorithm.
        if constexpr (
            FaceType::VERTEX_NUMBER == 3 &&
            (MFaceType::VERTEX_NUMBER > 3 || MFaceType::VERTEX_NUMBER < 0)) {
            VertexType*        base   = &Base::mParentMesh->vertex(0);
            const MVertexType* mvbase = &m.vertex(0);
 
            for (const MFaceType& mf : m.faces()) {
                // if the current face has the same number of vertices of this
                // faces (3), then the vertex pointers have been correctly
                // imported from the import pointers function. The import
                // pointers function does nothing when importing from a face
                // with at least 4 vertices
                if (mf.vertexNumber() != FaceType::VERTEX_NUMBER) {
                    // triangulate mf; the first triangle of the triangulation
                    // will be this->face(m.index(mf)); the other triangles will
                    // be added at the end of the container
                    std::vector<uint> tris =
                        earCut(mf.vertices() | views::positions);
                    FaceType& f = face(m.index(mf));
                    importTriPointersHelper(f, mf, base, mvbase, tris, 0);
 
                    // number of other faces to add
                    uint nf  = tris.size() / 3 - 1;
                    uint fid = addFaces(nf);
 
                    uint i = 3; // index that cycles into tris
                    for (; fid < faceContainerSize(); ++fid) {
                        FaceType& f = face(fid);
                        importTriPointersHelper(f, mf, base, mvbase, tris, i);
                        i += 3;
                    }
                }
            }
        }
    }
 
private:
    void addFaceHelper(T& f) { /* base case: no need to add vertices */ }
 
    template<typename... V>
    void addFaceHelper(T& f, typename T::VertexType* v, V... args)
    {
        // position on which add the vertex
        const std::size_t n = f.vertexNumber() - sizeof...(args) - 1;
        f.setVertex(n, v); // set the vertex
        // set the remanining vertices, recursive variadics
        addFaceHelper(f, args...);
    }
 
    template<typename... V>
    void addFaceHelper(T& f, uint vid, V... args)
    {
        // position on which add the vertex
        const std::size_t n = f.vertexNumber() - sizeof...(args) - 1;
        f.setVertex(n, vid); // set the vertex
        // set the remanining vertices, recursive variadics
        addFaceHelper(f, args...);
    }
 
    template<typename MFaceType, typename VertexType, typename MVertexType>
    static void importTriPointersHelper(
        FaceType&                f,
        const MFaceType&         mf,
        VertexType*              base,
        const MVertexType*       mvbase,
        const std::vector<uint>& tris,
        uint                     basetri)
    {
        f.importFrom(mf); // import all the components from mf
        for (uint i = basetri, j = 0; i < basetri + 3; i++, j++) {
            f.setVertex(j, base + (mf.vertex(tris[i]) - mvbase));
 
            // wedge colors
            if constexpr (
                face::HasWedgeColors<FaceType> &&
                face::HasWedgeColors<MFaceType>) {
                if (comp::isWedgeColorsAvailableOn(f) &&
                    comp::isWedgeColorsAvailableOn(mf)) {
                    f.wedgeColor(j) = mf.wedgeColor(tris[i]);
                }
            }
 
            // wedge texcoords
            if constexpr (
                face::HasWedgeTexCoords<FaceType> &&
                face::HasWedgeTexCoords<MFaceType>) {
                if (comp::isWedgeTexCoordsAvailableOn(f) &&
                    comp::isWedgeTexCoordsAvailableOn(mf)) {
                    using ST = typename FaceType::WedgeTexCoordType::ScalarType;
                    f.wedgeTexCoord(j) =
                        mf.wedgeTexCoord(tris[i]).template cast<ST>();
                }
            }
        }
    }
};
 
/* Concepts */
 
template<typename T>
concept HasFaceContainer = std::derived_from< // same type or derived type
    std::remove_cvref_t<T>,
    FaceContainer<typename RemoveRef<T>::FaceType>>;
 
} // namespace mesh
 
template<typename... Args>
concept HasFaces = (mesh::HasFaceContainer<Args> || ...);
 
} // namespace vcl
 
#endif // VCL_MESH_CONTAINERS_FACE_CONTAINER_H