vertex_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_VERTEX_CONTAINER_H
#define VCL_MESH_CONTAINERS_VERTEX_CONTAINER_H
 
#include "element_container.h"
 
#include <vclib/mesh/elements/vertex.h>
#include <vclib/mesh/elements/vertex_components.h>
 
#include <typeindex>
 
namespace vcl::mesh {
 
template<VertexConcept T>
class VertexContainer : public ElementContainer<T>
{
    template<VertexConcept U>
    friend class VertexContainer;
 
    using VertexContainerType = VertexContainer<T>;
    using Base                = ElementContainer<T>;
 
public:
    using Vertex              = T;
    using VertexType          = T;
    using VertexIterator      = Base::ElementIterator;
    using ConstVertexIterator = Base::ConstElementIterator;
 
    VertexContainer() = default;
 
    const VertexType& vertex(uint i) const { return Base::element(i); }
 
    VertexType& vertex(uint i) { return Base::element(i); }
 
    uint vertexNumber() const { return Base::elementNumber(); }
 
    uint vertexContainerSize() const { return Base::elementContainerSize(); }
 
    uint deletedVertexNumber() const { return Base::deletedElementNumber(); }
 
    uint addVertex() { return Base::addElement(); }
 
    uint addVertex(const typename T::CoordType& p)
    {
        uint vid            = addVertex();
        vertex(vid).coord() = p; // set the coordinate to the vertex
        return vid;
    }
 
    uint addVertices(uint n) { return Base::addElements(n); }
 
    template<typename... VC>
    uint addVertices(const typename T::CoordType& p, const VC&... v)
    {
        uint vid = vertexContainerSize();
        // reserve the new number of vertices
        reserveVertices(vid + sizeof...(VC) + 1);
        addVertex(p);
        // pack expansion: will be translated at compile time as an addVertex()
        // call for each argument of the addVertices member function
        (addVertex(v), ...);
        return vid;
    }
 
    template<vcl::Range R>
    uint addVertices(R&& range) requires RangeOf<R, typename T::CoordType>
    {
        uint vid = vertexContainerSize();
        reserveVertices(vid + std::ranges::size(range));
        for (const auto& v : range) {
            addVertex(v);
        }
        return vid;
    }
 
    void clearVertices() { Base::clearElements(); }
 
    void resizeVertices(uint n) { Base::resizeElements(n); }
 
    void reserveVertices(uint n) { Base::reserveElements(n); }
 
    void compactVertices() { Base::compactElements(); }
 
    void deleteVertex(uint i) { Base::deleteElement(i); }
 
    void deleteVertex(const VertexType* v) { Base::deleteElement(v); }
 
    uint vertexIndexIfCompact(uint i) const
    {
        return Base::elementIndexIfCompact(i);
    }
 
    std::vector<uint> vertexCompactIndices() const
    {
        return Base::elementCompactIndices();
    }
 
    void updateVertexIndices(const std::vector<uint>& newIndices)
    {
        Base::updateElementIndices(newIndices);
    }
 
    VertexIterator vertexBegin(bool jumpDeleted = true)
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    VertexIterator vertexEnd() { return Base::elementEnd(); }
 
    ConstVertexIterator vertexBegin(bool jumpDeleted = true) const
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    ConstVertexIterator vertexEnd() const { return Base::elementEnd(); }
 
    auto vertices(bool jumpDeleted = true)
    {
        return Base::elements(jumpDeleted);
    }
 
    auto vertices(bool jumpDeleted = true) const
    {
        return Base::elements(jumpDeleted);
    }
 
    void enableAllPerVertexOptionalComponents()
    {
        Base::enableAllOptionalComponents();
    }
 
    void disableAllPerVertexOptionalComponents()
    {
        Base::disableAllOptionalComponents();
    }
 
    // Adjacent Edges
 
    bool isPerVertexAdjacentEdgesEnabled() const
        requires vert::HasOptionalAdjacentEdges<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentEdges>();
    }
 
    void enablePerVertexAdjacentEdges()
        requires vert::HasOptionalAdjacentEdges<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    void disablePerVertexAdjacentEdges()
        requires vert::HasOptionalAdjacentEdges<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    // Adjacent Faces
 
    bool isPerVertexAdjacentFacesEnabled() const
        requires vert::HasOptionalAdjacentFaces<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentFaces>();
    }
 
    void enablePerVertexAdjacentFaces()
        requires vert::HasOptionalAdjacentFaces<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    void disablePerVertexAdjacentFaces()
        requires vert::HasOptionalAdjacentFaces<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    // Adjacent Vertices
 
    bool isPerVertexAdjacentVerticesEnabled() const
        requires vert::HasOptionalAdjacentVertices<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentVertices>();
    }
 
    void enablePerVertexAdjacentVertices()
        requires vert::HasOptionalAdjacentVertices<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentVertices>();
    }
 
    void disablePerVertexAdjacentVertices()
        requires vert::HasOptionalAdjacentVertices<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentVertices>();
    }
 
    // Color
 
    bool isPerVertexColorEnabled() const requires vert::HasOptionalColor<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Color>();
    }
 
    void enablePerVertexColor() requires vert::HasOptionalColor<T>
    {
        return Base::template enableOptionalComponent<typename T::Color>();
    }
 
    void disablePerVertexColor() requires vert::HasOptionalColor<T>
    {
        Base::template disableOptionalComponent<typename T::Color>();
    }
 
    // Mark
 
    bool isPerVertexMarkEnabled() const requires vert::HasOptionalMark<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Mark>();
    }
 
    void enablePerVertexMark() requires vert::HasOptionalMark<T>
    {
        Base::template enableOptionalComponent<typename T::Mark>();
    }
 
    void disablePerVertexMark() requires vert::HasOptionalMark<T>
    {
        Base::template disableOptionalComponent<typename T::Mark>();
    }
 
    // Normal
 
    bool isPerVertexNormalEnabled() const requires vert::HasOptionalNormal<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Normal>();
    }
 
    void enablePerVertexNormal() requires vert::HasOptionalNormal<T>
    {
        Base::template enableOptionalComponent<typename T::Normal>();
    }
 
    void disablePerVertexNormal() requires vert::HasOptionalNormal<T>
    {
        Base::template disableOptionalComponent<typename T::Normal>();
    }
 
    // PrincipalCurvature
 
    bool isPerVertexPrincipalCurvatureEnabled() const
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::PrincipalCurvature>();
    }
 
    void enablePerVertexPrincipalCurvature()
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        Base::template enableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    void disablePerVertexPrincipalCurvature()
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        Base::template disableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    // Quality
 
    bool isPerVertexQualityEnabled() const requires vert::HasOptionalQuality<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Quality>();
    }
 
    void enablePerVertexQuality() requires vert::HasOptionalQuality<T>
    {
        Base::template enableOptionalComponent<typename T::Quality>();
    }
 
    void disablePerVertexQuality() requires vert::HasOptionalQuality<T>
    {
        Base::template disableOptionalComponente<typename T::Quality>();
    }
 
    // TexCoord
 
    bool isPerVertexTexCoordEnabled() const
        requires vert::HasOptionalTexCoord<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::TexCoord>();
    }
 
    void enablePerVertexTexCoord() requires vert::HasOptionalTexCoord<T>
    {
        Base::template enableOptionalComponent<typename T::TexCoord>();
    }
 
    void disablePerVertexTexCoord() requires vert::HasOptionalTexCoord<T>
    {
        Base::template disableOptionalComponent<typename T::TexCoord>();
    }
 
    // Custom Components
 
    bool hasPerVertexCustomComponent(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::hasElemCustomComponent(name);
    }
 
    std::vector<std::string> perVertexCustomComponentNames() const
        requires vert::HasCustomComponents<T>
    {
        return Base::elemCustomComponentNames();
    }
 
    template<typename K>
    bool isPerVertexCustomComponentOfType(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::template isElemCustomComponentOfType<K>(name);
    }
 
    std::type_index perVertexCustomComponentType(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::elemComponentType(name);
    }
 
    template<typename K>
    std::vector<std::string> perVertexCustomComponentNamesOfType() const
        requires vert::HasCustomComponents<T>
    {
        return Base::template elemCustomComponentNamesOfType<K>();
    }
 
    template<typename K>
    void addPerVertexCustomComponent(const std::string& name)
        requires vert::HasCustomComponents<T>
    {
        Base::template addElemCustomComponent<K>(name);
    }
 
    void deletePerVertexCustomComponent(const std::string& name)
        requires vert::HasCustomComponents<T>
    {
        Base::deleteElemCustomComponent(name);
    }
 
    template<typename K>
    CustomComponentVectorHandle<K> perVertexCustomComponentVectorHandle(
        const std::string& name) requires vert::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    ConstCustomComponentVectorHandle<K> perVertexCustomComponentVectorHandle(
        const std::string& name) const requires vert::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
};
 
} // namespace vcl::mesh
 
#endif // VCL_MESH_CONTAINERS_VERTEX_CONTAINER_H