mesh_pos.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_SPACE_COMPLEX_MESH_POS_H
#define VCL_SPACE_COMPLEX_MESH_POS_H
 
#include <vclib/mesh.h>
 
namespace vcl {
 
template<face::HasAdjacentFaces FaceType>
class MeshPos
{
    const FaceType* mFace = nullptr;
 
    const typename FaceType::VertexType* mVertex = nullptr;
 
    short mEdge = -1;
 
public:
    using VertexType = FaceType::VertexType;
 
    MeshPos() = default;
 
    MeshPos(const FaceType* f, short e) : mFace(f), mEdge(e)
    {
        if (f != nullptr)
            mVertex = f->vertex(e);
        assert(isValid(mFace, mVertex, mEdge));
    }
 
    MeshPos(const FaceType* f, const VertexType* v) : mFace(f), mVertex(v)
    {
        for (uint i = 0; i < f->vertexNumber(); i++)
            if (f->vertex(i) == v)
                mEdge = i;
        assert(isValid(mFace, mVertex, mEdge));
    }
 
    MeshPos(const FaceType* f, const VertexType* v, short e) :
            mFace(f), mVertex(v), mEdge(e)
    {
        assert(isValid(mFace, mVertex, mEdge));
    }
 
    static bool isValid(const FaceType* f, const VertexType* v, short e)
    {
        if (f == nullptr || v == nullptr || e < 0)
            return false;
        if (!comp::isAdjacentFacesAvailableOn(*f))
            return false;
        return (ushort) e < f->vertexNumber() &&
               (v == f->vertex(e) || v == f->vertexMod(e + 1));
    }
 
    const FaceType* face() const { return mFace; }
 
    const VertexType* vertex() const { return mVertex; }
 
    short edge() const { return mEdge; }
 
    const FaceType* adjFace() const { return mFace->adjFace(mEdge); }
 
    const VertexType* adjVertex() const
    {
        MeshPos<FaceType> tmpPos = *this;
        tmpPos.flipVertex();
        return tmpPos.vertex();
    }
 
    short adjEdge() const
    {
        MeshPos<FaceType> tmpPos = *this;
        tmpPos.flipEdge();
        return tmpPos.edge();
    }
 
    bool isValid() const { return isValid(mFace, mVertex, mEdge); }
 
    bool isNull() const
    {
        return mFace == nullptr || mVertex == nullptr || mEdge < 0;
    }
 
    bool isEdgeOnBorder() const { return mFace->adjFace(mEdge) == nullptr; }
 
    bool isCCWOriented() const { return mFace->vertex(mEdge) == mVertex; }
 
    bool flipFace()
    {
        const FaceType* nf = mFace->adjFace(mEdge);
        if (nf != nullptr) {
            short oldEdge = mEdge;
            mEdge         = nf->indexOfAdjFace(mFace);
            if (mEdge < 0) {
                // non-manifold edge. I need to find the edge that has the
                // current vertex
                const auto* v0 = mFace->vertex(oldEdge);
                const auto* v1 = mFace->vertexMod(oldEdge + 1);
                mEdge          = nf->indexOfEdge(v0, v1);
                // if this assert fails, it means that the edge was not found.
                // you probably need to update adjacency information of the mesh
                assert(mEdge >= 0 && mEdge < nf->vertexNumber());
                if (mEdge < 0) {
                    *this = MeshPos<FaceType>(); // reset to null
                    return false;
                }
            }
            mFace = nf;
            return true;
        }
        else {
            return false;
        }
    }
 
    void flipVertex()
    {
        if (mFace->vertexMod(mEdge) == mVertex) {
            mVertex = mFace->vertexMod(mEdge + 1);
        }
        else {
            mVertex = mFace->vertexMod(mEdge);
        }
    }
 
    void flipEdge()
    {
        if (mFace->vertexMod(mEdge + 1) == mVertex) {
            mEdge = (mEdge + 1) % (short) mFace->vertexNumber();
        }
        else {
            short n = mFace->vertexNumber();
            mEdge   = ((mEdge - 1) % n + n) %
                    n; // be sure to get the right index of the previous edge
        }
    }
 
    void nextEdgeAdjacentToV()
    {
        flipEdge();
        flipFace();
    }
 
    bool nextEdgeOnBorderAdjacentToV()
    {
        MeshPos<FaceType> startPos = *this;
        do {
            nextEdgeAdjacentToV();
        } while (*this != startPos && !isEdgeOnBorder());
        return (*this != startPos);
    }
 
    uint numberOfAdjacentFacesToV() const
    {
        bool onBorder = false;
        uint count    = countAdjacentFacesToV(onBorder);
        // if we visited a border, it means that we visited the all faces
        // adjacent to v twice to reach the same starting MeshPos.
        if (onBorder)
            count /= 2;
        return count;
    }
 
    bool operator==(const MeshPos& op) const
    {
        return mFace == op.mFace && mVertex == op.mVertex && mEdge == op.mEdge;
    }
 
    bool operator!=(const MeshPos& op) const { return !(*this == op); }
 
    bool operator<(const MeshPos& op) const
    {
        if (mFace == op.mFace) {
            if (mEdge == op.mEdge)
                return mVertex < op.mVertex;
            else
                return mEdge < op.mEdge;
        }
        else {
            return mFace < op.mFace;
        }
    }
 
private:
    uint countAdjacentFacesToV(bool& onBorder) const
    {
        uint count = 0;
        onBorder   = false;
        // start from this MeshPos
        MeshPos<FaceType> mp = *this;
        do {
            // go to the next edge in the star of v (if face is on border, will
            // change just edge)
            mp.nextEdgeAdjacentToV();
            ++count;
            // if we are visiting a border, it means that we will start to
            // navigate in the opposite sense as we were before.
            if (mp.isEdgeOnBorder()) // flag that we visited a border
                onBorder = true;
        }
        // we end when we will reach the same pos (same triplet f-v-e) of start
        while (mp != *this);
        return count;
    }
};
 
} // namespace vcl
 
#endif // VCL_SPACE_COMPLEX_MESH_POS_H