gsHalfEdgeMesh.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsUtils/gsMesh/gsMesh.h>
#include <queue>
 
namespace gismo
{
 
template <class T>
class GISMO_EXPORT gsHalfEdgeMesh : public gsMesh<T>
{
public:
    class Halfedge
    {
    public:
        explicit Halfedge(const size_t origin = 0,
                          const size_t end = 0,
                          const T length = 0)
        : m_origin(origin), m_end(end), m_length(length)
        {
            if (length < 0)
                gsWarn << "Halfedge: Origin and end must be indices > 0 and length should be positiv or 0. One of the values is not correct:"
                          << std::endl << "origin: " << origin << std::endl << "end: " << end << std::endl
                          << "length: "
                          << length;
        }
 
        size_t getOrigin() const { return m_origin; }
 
        size_t getEnd() const { return m_end; }
 
        T getLength() const { return m_length; }
 
        bool isPrev(const Halfedge &nextHalfedge) const
        { return (m_end == nextHalfedge.m_origin); }
 
        bool isNext(const Halfedge &previousHalfedge) const
        { return (m_origin == previousHalfedge.m_end); }
 
        bool isTwin(const Halfedge &halfedge) const
        { return (m_origin == halfedge.m_end && m_end == halfedge.m_origin); }
 
    private:
        size_t m_origin; 
        size_t m_end;    
        T m_length;      
    };
 
    class Chain
    {
    public:
 
        bool isEmpty() const { return m_chainedHalfedges.empty(); }
 
        bool isClosed() const;
 
        size_t getNumberOfVertices() const;
 
        T getLength() const;
 
        std::vector<T> getHalfedgeLengths() const;
 
        const Halfedge &getFirstHalfedge() const;
 
        const Halfedge &getLastHalfedge() const;
 
        const std::list<size_t> getVertexIndices() const;
 
        T getShortestDistanceBetween(size_t i, size_t j, T precision) const;
 
        T getDistanceBetween(size_t i, size_t j) const;
 
        bool isVertexContained(const size_t &vertexIndex) const;
 
        bool isAppendableAsPrev(const Halfedge &previousHalfedge) const;
 
        bool isAppendableAsNext(const Halfedge &nextHalfedge) const;
 
        void appendPrevHalfedge(const Halfedge &prevHalfedge);
 
        void appendNextHalfedge(const Halfedge &nextHalfedge, bool ignoreWarning = false);
 
    private:
        std::list<Halfedge> m_chainedHalfedges; 
    };
 
private:
    class Boundary // todo: replace by Chain
    {
    public:
 
        Boundary() { }
 
        Boundary(const std::vector<Halfedge> &halfedges);
 
        size_t getNumberOfVertices() const
        {
            size_t result = 0;
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
                result += it->getNumberOfVertices();
            return result;
        }
 
        T getLength() const
        {
            T result = 0;
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
                result += it->getLength();         
            return result;
        }
 
        const std::vector<T> getHalfedgeLengths() const
        {
            std::vector<T> result;
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
            {
                const std::vector<T> lengthsOneComp = it->getHalfedgeLengths();
                result.insert(result.end(), lengthsOneComp.begin(), lengthsOneComp.end());
            }
            return result;
        }
 
        const std::list<size_t > getVertexIndices() const
        {
            std::list<size_t> result;
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
            {
                const std::list<size_t>& indicesOneComp = it->getVertexIndices();
                result.insert(result.end(), indicesOneComp.begin(), indicesOneComp.end());
            }       
            return result;
        }
 
        T getShortestDistanceBetween(const size_t &i, const size_t &j, T precision) const
        {
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
            {
                T dist = it->getShortestDistanceBetween(i, j, precision);
                if(dist > 0)
                    return dist;
            }
            return 0;
        }
 
        T getDistanceBetween(const size_t &i, const size_t &j) const
        {
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
            {
                T dist = it->getDistanceBetween(i, j);
                if(dist > 0)
                    return dist;
            }
            return 0;
        }
 
        bool isVertexContained(const size_t &internVertexIndex) const
        {
            for(typename std::vector<Chain>::const_iterator it=m_boundary.begin(); it!=m_boundary.end(); ++it)
                if(it->isVertexContained(internVertexIndex))
                    return true;
            return false;
        }
 
    private:
        const std::list<Halfedge> findNonTwinHalfedges(const std::vector<Halfedge> &allHalfedges);
 
        std::vector<Chain> m_boundary; 
    };
 
public:
 
    explicit gsHalfEdgeMesh(size_t nv = 0) : m_n(nv) { }
 
    explicit gsHalfEdgeMesh(const gsMesh<T> &mesh, T precision = 1e-8, bool periodic = false);
 
    virtual ~gsHalfEdgeMesh() { }
 
    size_t getNumberOfVertices() const;
 
    size_t getNumberOfTriangles() const;
 
    size_t getNumberOfInnerVertices() const;
 
    size_t getNumberOfBoundaryVertices() const;
 
    const typename gsMesh<T>::gsVertexHandle &getVertex(const size_t vertexIndex) const;
 
    /*
    size_t getVertexIndex(const typename gsMesh<T>::gsVertexHandle &vertex) const;
 
    size_t getGlobalVertexIndex(const size_t localVertexIndex, const size_t triangleIndex) const;
 
    T getBoundaryLength() const;
 
    std::vector<T> getCornerLengths(/*const*/ std::vector<index_t> &corners) const;
    //std::vector<T> getBoundaryPartLengths(const std::vector<size_t >& corners) const;
 
    const std::vector<T> getBoundaryChordLengths() const;
 
    T getShortestBoundaryDistanceBetween(size_t i, size_t j) const;
 
    T getHalfedgeLength(const size_t originVertexIndex, const size_t endVertexIndex) const;
 
    const std::queue<Halfedge>
    getOppositeHalfedges(const size_t vertexIndex, const bool innerVertex = 1) const;
 
    short_t isTriangleVertex(size_t vertexIndex, size_t triangleIndex) const;
 
    std::list<size_t> getBoundaryVertexIndices() const
    {
        return m_boundary.getVertexIndices();
    }
 
    size_t findVertex(const typename gsMesh<T>::gsVertexHandle& vertex) const
    {
        return findVertex(vertex->x(), vertex->y(), vertex->z());
    }
 
    size_t findVertex(T x, T y, T z, bool sorted = false, real_t tol = 1e-6) const;
 
    const typename gsMesh<T>::gsVertexHandle &getVertexUnsorted(const size_t globIndex) const
    {
        return this->m_vertex[globIndex];
    }
 
    size_t unsorted(const size_t index) const
    {
        return m_inverseSorting[index];
    }
 
private:
    bool isBoundaryVertex(const size_t internVertexIndex) const;
 
    public:
    size_t getInternVertexIndex(const typename gsMesh<T>::gsVertexHandle &vertex) const;
 
    private:
    const Halfedge
    getInternHalfedge(const typename gsMesh<T>::gsFaceHandle &triangle, size_t numberOfHalfedge) const;
 
    void sortVertices();
 
    std::vector<Halfedge> m_halfedges; 
    Boundary m_boundary; 
    size_t m_n; 
 
    std::vector<index_t> m_inverseSorting; 
    std::vector<index_t> m_sorting; 
    T m_precision;
 
 
};//class gsHalfEdgeMesh
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsHalfEdgeMesh.hpp)
#endif