vertex_references.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_COMPONENTS_VERTEX_REFERENCES_H
#define VCL_MESH_COMPONENTS_VERTEX_REFERENCES_H
 
#include "bases/reference_container_component.h"
 
#include <vclib/concepts/mesh/components/vertex_references.h>
#include <vclib/types/view.h>
 
namespace vcl::comp {
 
template<
    bool STORE_INDICES,
    typename Vertex,
    int N,
    typename ParentElemType = void,
    bool VERT               = false>
class VertexReferences :
        public ReferenceContainerComponent<
            STORE_INDICES,
            VertexReferences<STORE_INDICES, Vertex, N, ParentElemType, VERT>,
            CompId::VERTEX_REFERENCES,
            Vertex,
            N,
            ParentElemType,
            VERT,
            false,
            false>
{
    using Base = ReferenceContainerComponent<
        STORE_INDICES,
        VertexReferences<STORE_INDICES, Vertex, N, ParentElemType, VERT>,
        CompId::VERTEX_REFERENCES,
        Vertex,
        N,
        ParentElemType,
        VERT,
        false,
        false>;
 
public:
    using VertexType = Vertex;
 
    /* Iterator Types declaration */
 
    using VertexIterator           = Base::Iterator;
    using ConstVertexIterator      = Base::ConstIterator;
    using ConstVertexIndexIterator = Base::ConstIndexIterator;
 
    static const bool INDEXED       = STORE_INDICES;
    static const int  VERTEX_NUMBER = Base::SIZE;
 
    /* Constructors */
 
    VertexReferences() = default;
 
    /* Member functions */
 
    uint vertexNumber() const { return Base::size(); }
 
    Vertex* vertex(uint i) { return Base::element(i); }
 
    const Vertex* vertex(uint i) const { return Base::element(i); }
 
    uint vertexIndex(uint i) const { return Base::elementIndex(i); }
 
    Vertex* vertexMod(int i) { return Base::elementMod(i); }
 
    const Vertex* vertexMod(int i) const { return Base::elementMod(i); }
 
    uint vertexIndexMod(int i) const { return Base::elementIndexMod(i); }
 
    void setVertex(uint i, Vertex* v) { Base::setElement(i, v); }
 
    void setVertex(uint i, uint vi) { Base::setElement(i, vi); }
 
    void setVertex(ConstVertexIterator it, Vertex* v)
    {
        Base::setElement(it, v);
    }
 
    void setVertex(ConstVertexIterator it, uint vi)
    {
        Base::setElement(it, vi);
    }
 
    void setVertex(ConstVertexIndexIterator it, Vertex* v)
    {
        Base::setElement(it, v);
    }
 
    void setVertex(ConstVertexIndexIterator it, uint vi)
    {
        Base::setElement(it, vi);
    }
 
    void setVertexMod(int i, Vertex* v) { Base::setElementMod(i, v); }
 
    void setVertexMod(int i, uint vi) { Base::setElementMod(i, vi); }
 
    template<Range Rng>
    void setVertices(Rng&& r) requires InputRange<Rng, Vertex*>
    {
        Base::setElements(r);
    }
 
    template<Range Rng>
    void setVertices(Rng&& r) requires InputRange<Rng, uint>
    {
        Base::setElements(r);
    }
 
    bool containsVertex(const Vertex* v) const
    {
        return Base::containsElement(v);
    }
 
    bool containsVertex(uint vi) const { return Base::containsElement(vi); }
 
    uint indexOfVertex(const Vertex* v) const
    {
        return Base::indexOfElement(v);
    }
 
    uint indexOfVertex(uint vi) const { return Base::indexOfElement(vi); }
 
    uint indexOfEdge(const Vertex* v1, const Vertex* v2) const
    {
        if constexpr (STORE_INDICES) {
            return indexOfEdge(
                Base::indexFromPointer(v1), Base::indexFromPointer(v2));
        }
        else {
            uint vid = indexOfVertex(v1);
            if (vid == UINT_NULL) {
                return UINT_NULL;
            }
            else if (vertexMod(vid + 1) == v2) {
                return vid;
            }
            else if (vertexMod((int) vid - 1) == v2) {
                int n = vertexNumber(); // n must be int to avoid unwanted casts
                return (((int) vid - 1) % n + n) % n;
            }
            else {
                return UINT_NULL;
            }
        }
    }
 
    uint indexOfEdge(uint vi1, uint vi2) const
    {
        if constexpr (STORE_INDICES) {
            uint vid = indexOfVertex(vi1);
            if (vid == UINT_NULL) {
                return UINT_NULL;
            }
            else if (vertexIndexMod(vid + 1) == vi2) {
                return vid;
            }
            else if (vertexIndexMod((int) vid - 1) == vi2) {
                int n = vertexNumber(); // n must be int to avoid unwanted casts
                return (((int) vid - 1) % n + n) % n;
            }
            else {
                return UINT_NULL;
            }
        }
        else {
            return indexOfEdge(
                Base::elemFromParent(vi1), Base::elemFromParent(vi2));
        }
    }
 
    /* Member functions specific for dynamic vector of refs */
 
    void resizeVertices(uint n) requires (N < 0) { Base::resize(n); }
 
    void pushVertex(Vertex* v) requires (N < 0) { Base::pushBack(v); }
 
    void pushVertex(uint vi) requires (N < 0) { Base::pushBack(vi); }
 
    void insertVertex(uint i, Vertex* v) requires (N < 0)
    {
        Base::insert(i, v);
    }
 
    void insertVertex(uint i, uint vi) requires (N < 0) { Base::insert(i, vi); }
 
    void eraseVertex(uint i) requires (N < 0) { Base::erase(i); }
 
    void clearVertices() requires (N < 0) { Base::clear(); }
 
    /* Iterator Member functions */
 
    VertexIterator vertexBegin() { return Base::elementBegin(); }
 
    VertexIterator vertexEnd() { return Base::elementEnd(); }
 
    ConstVertexIterator vertexBegin() const { return Base::elementBegin(); }
 
    ConstVertexIterator vertexEnd() const { return Base::elementEnd(); }
 
    ConstVertexIndexIterator vertexIndexBegin() const
    {
        return Base::elementIndexBegin();
    }
 
    ConstVertexIndexIterator vertexIndexEnd() const
    {
        return Base::elementIndexEnd();
    }
 
    View<VertexIterator> vertices() { return Base::elements(); }
 
    View<ConstVertexIterator> vertices() const { return Base::elements(); }
 
    View<ConstVertexIndexIterator> vertexIndices() const
    {
        return Base::elementIndices();
    }
 
protected:
    // Component interface functions
    template<typename Element>
    void importFrom(const Element& e, bool importRefs = true)
    {
        if (importRefs) {
            if constexpr (HasVertexReferences<Element>) {
                if constexpr (N > 0) {
                    // same size non-polygonal faces
                    if constexpr (N == Element::VERTEX_NUMBER) {
                        importIndicesFrom(e);
                    }
                    // from polygonal to fixed size, but the polygon size == the
                    // fixed face size
                    else if constexpr (Element::VERTEX_NUMBER < 0) {
                        if (e.vertexNumber() == N) {
                            importIndicesFrom(e);
                        }
                    }
                    else {
                        // do not import in this case: cannot import from a face
                        // of different size
                    }
                }
                else {
                    // from fixed to polygonal size: need to resize first, then
                    // import
                    resizeVertices(e.vertexNumber());
                    importIndicesFrom(e);
                }
            }
        }
    }
 
    void serialize(std::ostream& os) const
    {
        // regardless of the type of the container (indices or pointers), the
        // serialization is always done using the indices
        if constexpr (N < 0) {
            vcl::serialize(os, vertexNumber());
        }
        for (uint i = 0; i < vertexNumber(); ++i) {
            vcl::serialize(os, vertexIndex(i));
        }
    }
 
    void deserialize(std::istream& is)
    {
        if constexpr (N < 0) {
            uint n;
            vcl::deserialize(is, n);
            resizeVertices(n);
        }
        for (uint i = 0; i < vertexNumber(); ++i) {
            uint vi;
            vcl::deserialize(is, vi);
            setVertex(i, vi);
        }
    }
 
private:
    template<typename Element>
    void importIndicesFrom(const Element& e)
    {
        for (uint i = 0; i < e.vertexNumber(); ++i) {
            setVertex(i, e.vertexIndex(i));
        }
    }
};
 
} // namespace vcl::comp
 
#endif // VCL_MESH_COMPONENTS_VERTEX_REFERENCES_H