GEO_Hedge.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GEO_Hedge.h ( GEO Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GEO_Hedge__
#define __GEO_Hedge__

#include "GEO_API.h"
#include <GA/GA_Detail.h>
#include <GA/GA_Types.h>
#include <UT/UT_Assert.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_Types.h>

#include <math.h>

class GEO_Detail;
class GEO_Hedge;
class GEO_PrimPoly;

class GA_ElementWranglerCache;

/// An invalid hedge is sometimes returned if an operation is unsuccessful
#define GEO_INVALID_HEDGE       GEO_Hedge(GA_INVALID_OFFSET)

namespace geo_hedge
{

GA_Offset srcVertex(GEO_Hedge);

}; // namespace geo_hedge

/// GEO_Hedge encapsulates a half-edge (hedge) which is the *restriction* of
//  an edge to one primitive incident to that edge, or equivalently the
//  contribution to an edge of one primitive incident to it. It essentially
//  stores only one GA_Offset which is the source (src) vertex for the
//  half-edge it represents. It can therefore be freely copied and assigned.

class GEO_API GEO_Hedge
{
public:
    explicit constexpr   GEO_Hedge() : mySrcVertex(GA_INVALID_OFFSET) { }
    explicit constexpr   GEO_Hedge(GA_Offset vtx) : mySrcVertex(vtx) { }

    SYS_FORCE_INLINE
    bool                 operator==(GEO_Hedge h) const
                            { return mySrcVertex == h.mySrcVertex; }

    SYS_FORCE_INLINE
    bool                 operator!=(GEO_Hedge h) const
                            { return mySrcVertex != h.mySrcVertex; }

    SYS_FORCE_INLINE
    size_t               hash() const { return SYShash(int64(mySrcVertex)); }

    friend class         GEO_SHedge;
    friend GA_Offset     geo_hedge::srcVertex(GEO_Hedge);

private:
    GA_Offset            mySrcVertex;
};

SYS_FORCE_INLINE
size_t hash_value(const GEO_Hedge &h)
{
    return h.hash();
}

/// GEO_SHedge encapsulates a *signed* half-edge. It is a half-edge together
//  with a sign in {+1, -1}. It is implemented by using the second most
//  significant bit of a half-edge's source vertex offset for the sign bit.
//  This means that a signed half-edge cannot have a source vertex offset
//  between 2^62 and 2^63 - 1.

#define GEO_INVALID_SHEDGE      GEO_SHedge(GEO_INVALID_HEDGE, 1)
#define NEG_MASK                (1ll << 62)

class GEO_API GEO_SHedge
{
public:
    explicit constexpr   GEO_SHedge() : myBits(-1) { }

    explicit             GEO_SHedge(GEO_Hedge hedge, int sign = 1) :
                            myBits(hedge.mySrcVertex) { setSign(sign); }

                         GEO_SHedge(const GEO_SHedge &other) = default;

    int                  sign() const { return isPositive() ? 1 : -1; }
    bool                 isPositive() const { return !isNegative(); }
    bool                 isNegative() const { return (myBits & NEG_MASK); }
    bool                 isValid() const { return myBits >= 0; }

    SYS_FORCE_INLINE
    void                 setSign(int sign);

    SYS_FORCE_INLINE
    GEO_Hedge            hedge() const;

    SYS_FORCE_INLINE
    GEO_SHedge           &operator=(const GEO_SHedge &other);

    SYS_FORCE_INLINE
    bool                 operator==(const GEO_SHedge& other) const
                            { return myBits == other.myBits; }

    SYS_FORCE_INLINE
    bool                 operator!=(const GEO_SHedge& other) const
                            { return myBits != other.myBits; }

    SYS_FORCE_INLINE
    GEO_SHedge           operator-()
                            { return GEO_SHedge(hedge(), -sign()); }

    SYS_FORCE_INLINE
    size_t               hash() const { return SYShash(int64(myBits)); }

private:
    GA_Size              myBits;

#ifndef SESI_LITTLE_ENDIAN
#error "Make sure the bitfields in the union work on big endian platforms!"
#endif
};

void
GEO_SHedge::setSign(int sign)
{
    if (sign >= 0)
        myBits &= (~NEG_MASK);
    else
        myBits |= NEG_MASK;
}

SYS_FORCE_INLINE
GEO_SHedge &
GEO_SHedge::operator=(const GEO_SHedge &other)
{
    myBits = other.myBits;
    return *this;
}

GEO_Hedge
GEO_SHedge::hedge() const
{
    if (myBits < 0)
        return GEO_INVALID_HEDGE;

    return GEO_Hedge(GA_Offset(myBits & (~NEG_MASK)));
}

SYS_FORCE_INLINE
size_t hash_value(const GEO_SHedge &h)
{
    return h.hash();
}


namespace geo_hedge
{
// static methods for common use with a given detail, or a templated
// interface parameter that supplies nextEquivalentHedge() or other
// half-edge supporting interface methods.

// NOTE: You probably shouldn't be calling these directly! Instead use
// an interface class that binds to your detail and provides a wrapper
// for all or most of these.


SYS_FORCE_INLINE
GA_Offset
srcVertex(GEO_Hedge h)
{
    return h.mySrcVertex;
}

SYS_FORCE_INLINE
GA_Offset
srcPoint(const GA_Detail *gdp, GEO_Hedge h)
{
    return gdp->vertexPoint(geo_hedge::srcVertex(h));
}

SYS_FORCE_INLINE
GA_Offset
hedgePrimitiveOffset(const GA_Detail *gdp, GEO_Hedge h)
{
    return gdp->vertexPrimitive(geo_hedge::srcVertex(h));
}

SYS_FORCE_INLINE
const GA_Primitive*
hedgePrimitive(const GA_Detail *gdp, GEO_Hedge h)
{
    return gdp->getPrimitive(hedgePrimitiveOffset(gdp, h));
}

SYS_FORCE_INLINE
GA_Primitive*
hedgePrimitive(GA_Detail *gdp, GEO_Hedge h)
{
    return gdp->getPrimitive(hedgePrimitiveOffset(gdp, h));
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
dstVertex(T &iface, GEO_Hedge h)
{
    return iface.polyNext(srcVertex(h));
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
preSrcVertex(T &iface, GEO_Hedge h)
{
    return iface.polyPrev(srcVertex(h));
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
postDstVertex(T &iface, GEO_Hedge h)
{
    GA_Offset next_v;
    next_v = iface.polyNext(geo_hedge::srcVertex(h));
    if (!GAisValid(next_v))
        return GA_INVALID_OFFSET;

    return iface.polyNext(next_v);
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
dstPoint(T &iface, GEO_Hedge h)
{
    return iface.vertexPoint(dstVertex(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
preSrcPoint(T &iface, GEO_Hedge h)
{
    return iface.vertexPoint(preSrcVertex(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
GA_Offset
postDstPoint(T &iface, GEO_Hedge h)
{
    return iface.vertexPoint(postDstVertex(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
GEO_Hedge
nextPrimitiveHedge(T &iface, GEO_Hedge h)
{
    return GEO_Hedge(dstVertex(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
GEO_Hedge
prevPrimitiveHedge(T &iface, GEO_Hedge h)
{
    return GEO_Hedge(preSrcVertex(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
GEO_Hedge
coincidentPolyHedge(T &iface, GEO_Hedge h, GA_Offset pt)
{
    if (iface.srcPoint(h) == pt)
        return iface.lprev(h);

    if (iface.dstPoint(h) == pt)
        return iface.lnext(h);

    return GEO_INVALID_HEDGE;
}

template <typename T>
SYS_FORCE_INLINE
bool
areEquivalent(T &iface, GEO_Hedge h1, GEO_Hedge h2)
{
    auto dst1 = iface.dstPoint(h1);
    auto src1 = iface.srcPoint(h1);
    auto dst2 = iface.dstPoint(h2);
    auto src2 = iface.srcPoint(h2);
    return ((dst1 == dst2 && src1 == src2) || (dst1 == src2 && src1 == dst2));
}

template<typename T>
SYS_FORCE_INLINE bool
isBoundaryHedge(T &iface, GEO_Hedge h)
{
    return iface.nextEquivalentHedge(h) == h;
}

template<typename T>
bool
isBridgeHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge h0 = iface.nextEquivalentHedge(h);
    if (h0 == h)
        return false;

    GA_Offset esrcv = iface.srcVertex(h);
    GA_Offset eprim = iface.vertexPrimitive(esrcv);
    GA_Offset esrcp = iface.vertexPoint(esrcv);

    while (h0 != h)
    {
        GA_Offset e0srcv = iface.srcVertex(h);
        if (iface.vertexPrimitive(e0srcv) == eprim &&
            iface.vertexPoint(e0srcv) != esrcp)
            return true;
        h0 = iface.nextEquivalentHedge(h0);
    }

    return false;
}

template<typename T>
SYS_FORCE_INLINE
bool
isManifoldHedge(T &iface, GEO_Hedge h, bool accept_bd)
{
    GEO_Hedge ne = iface.nextEquivalentHedge(h);

    if (ne == h)
        return accept_bd;

    if (iface.nextEquivalentHedge(ne) != h)
        return false;

    return (iface.srcPoint(h) != iface.srcPoint(ne));
}

template<typename T>
SYS_FORCE_INLINE
GA_Size
numEquivalentHedges(T &iface, GEO_Hedge h)
{
    int res = 0;
    GEO_Hedge h0 = h;
    do
    {
        res++;
        h0 = iface.nextEquivalentHedge(h0);
    } while (h0 != h);

    return res;
}

template <typename T>
SYS_FORCE_INLINE
bool
areOpposite(T &iface, GEO_Hedge h1, GEO_Hedge h2)
{
    auto dst1 = iface.dstPoint(h1);
    auto src1 = iface.srcPoint(h1);
    auto dst2 = iface.dstPoint(h2);
    auto src2 = iface.srcPoint(h2);
    return (src1 == dst2 && dst1 == src2);
}

/// [first/next]IncidentHedge run over all half-edges incident
/// at src or dst to the given point in a specific order as
/// follows: all candiate vertices for incident half-edges are
/// traversed, by going over the vertices wired to the given point
/// in the order determined by GA_Topology and interleaving these
/// with (potential) half-edges that precede the one determined
/// by each vertex on its respective primitive.

template <typename T>
GEO_Hedge
firstIncidentHedge(T &iface, GA_Offset pt)
{
    for (auto vtx = iface.pointVertex(pt); GAisValid(vtx);
        vtx = iface.vertexToNextVertex(vtx))
    {
        // try outoing hedge at vtx, its dst must differ from pt
        GEO_Hedge h(vtx);
        if (iface.isValidHedge(h) && iface.dstPoint(h) != pt)
            return h;

        // now try the previous vertex on primitive, its src shouldn't be pt
        GEO_Hedge hprev(iface.polyPrev(vtx));
        if (iface.isValidHedge(hprev) && iface.srcPoint(hprev) != pt)
            return hprev;
    }

    return GEO_INVALID_HEDGE;
}

template <typename T>
GEO_Hedge
nextIncidentHedge(T &iface, GEO_Hedge h, GA_Offset pt)
{
    UT_ASSERT_P(iface.isValidHedge(h));

    GA_Offset vtx = srcVertex(h);
    GA_Offset v0;
    auto vprev = GA_INVALID_OFFSET;
    auto vnext = iface.polyNext(vtx, vprev);

    // figure out whether to return the previous edge on the same poly
    // or continue with next vertex wired to poin.

    if (iface.vertexPoint(vtx) == pt && iface.vertexPoint(vnext) != pt)
    {
        // pt is src of h: return previous hedge unless invalid
        GEO_Hedge hprev(vprev);
        if (iface.isValidHedge(hprev) && iface.vertexPoint(vprev) != pt)
            return hprev;
        v0 = vtx;
    }
    else
    {
        // pt must be dst of h: move to the next wired vertex
        UT_ASSERT_P(iface.vertexPoint(vnext) == pt);
        v0 = vnext;
    }

    UT_ASSERT_P(iface.vertexPoint(v0) == pt);

    auto vtmp = GA_INVALID_OFFSET;
    for (GA_Offset v = GAisValid(vtmp = iface.vertexToNextVertex(v0)) ?
                       vtmp : iface.pointVertex(pt); true;
         v = GAisValid(vtmp = iface.vertexToNextVertex(v)) ? vtmp :
             iface.pointVertex(pt))
    {
        UT_ASSERT_P(iface.vertexPoint(v) == pt);
        GEO_Hedge h0(v);
        if (iface.isValidHedge(h0) && iface.dstPoint(h0) != pt)
            return h0;

        GEO_Hedge hprev(iface.polyPrev(v));
        if (iface.isValidHedge(hprev) && iface.srcPoint(hprev) != pt)
            return hprev;

        // shouldn't be getting to here since by this time we
        // should have returned h itself
        UT_ASSERT_P(v != v0);
        if (v == v0)
            break;
    }

    UT_ASSERT_MSG(0, "Control should not reach this pt!");
    return GEO_INVALID_HEDGE;
}

/// firstIncidentEdge and nextIncidentEdge, simply filter out
/// non-primary half-edges out of the results of firstIncidentHedge
/// and nextIncidentHedge

template <typename T>
GEO_Hedge
firstIncidentEdge(T &iface, GA_Offset pt)
{
    GEO_Hedge h = iface.firstIncidentHedge(pt);
    if (!iface.isValidHedge(h))
        return GEO_INVALID_HEDGE;

    while (!iface.isPrimary(h))
    {
        h = iface.nextIncidentHedge(h, pt);

        UT_ASSERT_P(iface.isValidHedge(h));

        if (!iface.isValidHedge(h))
            return GEO_INVALID_HEDGE;
    }
    return h;
}

template <typename T>
GEO_Hedge
nextIncidentEdge(T &iface, GEO_Hedge h, GA_Offset point)
{
    GEO_Hedge h0 = iface.nextIncidentHedge(h, point);
    if (!iface.isValidHedge(h0))
        return GEO_INVALID_HEDGE;

    while (!iface.isPrimary(h0))
    {
        h0 = iface.nextIncidentHedge(h0, point);
        if (!iface.isValidHedge(h0))
            return GEO_INVALID_HEDGE;
    }
    return h0;
}

template <typename T>
GEO_Hedge
firstOutgoingHedge(T &iface, GA_Offset point)
{
    for (GA_Offset vtx = iface.pointVertex(point); GAisValid(vtx);
        vtx = iface.vertexToNextVertex(vtx))
    {
        GEO_Hedge h(vtx);
        if (iface.isValidHedge(h))
            return h;
    }
    return GEO_INVALID_HEDGE;
}

template <typename T>
GEO_Hedge
nextOutgoingHedge(T &iface, GEO_Hedge h)
{
    GA_Offset vtx = iface.srcVertex(h);
    if (!GAisValid(vtx))
        return GEO_INVALID_HEDGE;

    GA_Offset point = iface.vertexPoint(vtx);

    if (!GAisValid(point))
        return h;

    GA_Offset v0 = vtx;

    auto vtmp = GA_INVALID_OFFSET;
    for (GA_Offset v = GAisValid(vtmp = iface.vertexToNextVertex(v0)) ? vtmp :
            iface.pointVertex(point); true;
        v = GAisValid(vtmp = iface.vertexToNextVertex(v)) ? vtmp :
            iface.pointVertex(point))
    {
        GEO_Hedge h0(v);
        if (iface.isValidHedge(h0))
            return h0;

        if (v == v0)
            break;
    }

    UT_ASSERT(0 && "Cotnrol should not reach this point!");
    return GEO_INVALID_HEDGE;
}

template <typename T>
GEO_Hedge
firstIncomingHedge(T &iface, GA_Offset pt)
{
    for (GA_Offset vtx = iface.pointVertex(pt); GAisValid(vtx);
        vtx = iface.vertexToNextVertex(vtx))
    {
        GA_Offset vprev =  iface.polyPrev(vtx);
        if (GAisValid(vprev))
        {
            GEO_Hedge hprev(vprev);
            if (iface.isValidHedge(hprev))
                return hprev;
        }
    }
    return GEO_INVALID_HEDGE;
}

template <typename T>
GEO_Hedge
nextIncomingHedge(T &iface, GEO_Hedge h)
{
    GA_Offset vtx = iface.dstVertex(h);
    if (!GAisValid(vtx))
        return GEO_INVALID_HEDGE;

    GA_Offset point = iface.vertexPoint(vtx);
    if (!GAisValid(point))
        return h;

    GA_Offset v0 = vtx;
    auto vtmp = GA_INVALID_OFFSET;
    for (auto v = GAisValid(vtmp = iface.vertexToNextVertex(v0)) ? vtmp :
            iface.pointVertex(point); true;
        v = GAisValid(vtmp = iface.vertexToNextVertex(v)) ? vtmp :
            iface.pointVertex(point))
    {

        GA_Offset vprev = iface.polyPrev(v);
        if (GAisValid(vprev))
        {
            GEO_Hedge hprev(vprev);
            if (iface.isValidHedge(hprev))
                return hprev;
        }

        if (v == v0)
            break;
    }

    UT_ASSERT(0 && "Cotnrol should not reach this point!");
    return GEO_INVALID_HEDGE;

}

template<typename T>
GEO_Hedge
nextManifoldOutgoingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge hprev = iface.prevPrimitiveHedge(h);
    if (!iface.isValidHedge(hprev))
        return GEO_INVALID_HEDGE;
    GEO_Hedge hprevmate = iface.nextEquivalentHedge(hprev);
    if (hprevmate == hprev ||
        iface.nextEquivalentHedge(hprevmate) != hprev)
        return GEO_INVALID_HEDGE;

    if (iface.srcPoint(hprev) != iface.dstPoint(hprevmate))
        return GEO_INVALID_HEDGE;

    return hprevmate;
}

template<typename T>
GEO_Hedge
prevManifoldOutgoingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge hmate = iface.nextEquivalentHedge(h);
    if (!iface.isValidHedge(hmate))
        return GEO_INVALID_HEDGE;
    if (hmate == h || iface.nextEquivalentHedge(hmate) != h)
        return GEO_INVALID_HEDGE;

    if (iface.srcPoint(h) != iface.dstPoint(hmate))
        return GEO_INVALID_HEDGE;

    GEO_Hedge hmatenext = iface.nextPrimitiveHedge(hmate);
    if (!iface.isValidHedge(hmatenext))
        return GEO_INVALID_HEDGE;
    return hmatenext;
}

template<typename T>
GEO_Hedge
prevManifoldIncomingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge hnext = iface.nextPrimitiveHedge(h);
    if (!iface.isValidHedge(hnext))
        return GEO_INVALID_HEDGE;
    GEO_Hedge hnextmate = iface.nextEquivalentHedge(hnext);
    if (hnextmate == hnext ||
        iface.nextEquivalentHedge(hnextmate) != hnext)
        return GEO_INVALID_HEDGE;
    if (iface.srcPoint(hnext) != iface.dstPoint(hnextmate))
        return GEO_INVALID_HEDGE;
    return hnextmate;
}

template<typename T>
GEO_Hedge
nextManifoldIncomingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge hmate = iface.nextEquivalentHedge(h);
    if (hmate == h || iface.nextEquivalentHedge(hmate) != h)
        return GEO_INVALID_HEDGE;
    if (iface.srcPoint(h) != iface.dstPoint(hmate))
                return GEO_INVALID_HEDGE;
    GEO_Hedge hmateprev = iface.prevPrimitiveHedge(hmate);
    if (!iface.isValidHedge(hmateprev))
        return GEO_INVALID_HEDGE;
    return hmateprev;
}

template<typename T>
GEO_Hedge
firstManifoldOutgoingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge h0 = h;
    do
    {
        GEO_Hedge hprev = prevManifoldOutgoingHedge(iface, h);
        if (!iface.isValidHedge(hprev))
            return h;
        h = hprev;
    } while (h0 != h);
    return h0;
}

template<typename T>
GEO_Hedge
firstManifoldIncomingHedge(T &iface, GEO_Hedge h)
{
    GEO_Hedge h0 = h;
    do
    {
        GEO_Hedge hprev = prevManifoldIncomingHedge(iface, h);
        if (!iface.isValidHedge(hprev))
            return h;
        h = hprev;
    } while (h0 != h);
    return h0;
}

template <typename T>
SYS_FORCE_INLINE
fpreal
length(T &iface, GEO_Hedge h)
{
    auto gdp = iface.getDetail();
    return distance3d(gdp->getPos3(srcPoint(gdp, h)),
                      gdp->getPos3(dstPoint(iface, h)));
}

template <typename T>
SYS_FORCE_INLINE
fpreal vertexAngle(T &iface, GA_Offset v, UT_Vector3 *nml)
{
    const GA_Detail *gdp = iface.getDetail();
    auto v_prev = GA_INVALID_OFFSET;
    auto v_next = iface.polyNext(v, v_prev);

    if (!GAisValid(v_prev) || !GAisValid(v_next))
        return M_PI / 2.0;

    UT_Vector3 v1 = gdp->getPos3(iface.vertexPoint(v_next));
    UT_Vector3 v0 = gdp->getPos3(iface.vertexPoint(v));
    v1 -= v0;
    v0 = gdp->getPos3(iface.vertexPoint(v_prev)) - v0;

    fpreal angle = UTangleBetween(v0, v1);
    if (!nml || dot(v1, cross(*nml, v0)) >= 0.0)
        return angle;

    return (2.0 * M_PI - angle);
}

SYS_FORCE_INLINE
UT_Vector3
srcPos3(const GA_Detail *gdp , GEO_Hedge h)
{
    return gdp->getPos3(srcPoint(gdp, h));
}

template <typename T>
SYS_FORCE_INLINE
UT_Vector3
dstPos3(T &iface, GEO_Hedge h)
{
    return iface.getDetail()->getPos3(dstPoint(iface, h));
}

template <typename T>
SYS_FORCE_INLINE
fpreal srcPrimitiveAngle(T &iface, GEO_Hedge h, UT_Vector3 *nml)
{
    return vertexAngle(iface, srcVertex(h), nml);
}

template <typename T>
SYS_FORCE_INLINE
fpreal dstPrimitiveAngle(T &iface, GEO_Hedge h, UT_Vector3 *nml)
{
    return vertexAngle(iface, dstVertex(iface, h), nml);
}

SYS_FORCE_INLINE
fpreal angleCos(const UT_Vector3 &u, const UT_Vector3 &v)
{
    fpreal udotv = dot(u, v);

    fpreal ulen = u.length();
    if (SYSequalZero(ulen))
        return udotv >= 0.0 ? 1.0 : -1.0;

    fpreal vlen = v.length();
    if (SYSequalZero(vlen))
        return udotv >= 0.0 ? 1.0 : -1.0;

    return udotv/(ulen * vlen);
}

template <typename T>
SYS_FORCE_INLINE
fpreal srcPrimitiveAngleCos(T &iface, GEO_Hedge h)
{
    auto gdp = iface.getDetail();
    UT_Vector3 pos = gdp->getPos3(srcPoint(gdp, h));
    return angleCos(gdp->getPos3(dstPoint(iface, h)) - pos,
                    gdp->getPos3(preSrcPoint(iface, h)) - pos);
}

template <typename T>
SYS_FORCE_INLINE
fpreal dstPrimitiveAngleCos(T &iface, GEO_Hedge h)
{
    auto gdp = iface.getDetail();
    UT_Vector3 pos = gdp->getPos3(dstPoint(iface, h));
    return angleCos(gdp->getPos3(postDstPoint(iface, h)) - pos,
                    gdp->getPos3(srcPoint(gdp, h)) - pos);
}

template <typename T>
GEO_Hedge
findHedgeWithEndpoints(T &iface, GA_Offset p0, GA_Offset p1)
{
    auto gdp = iface.getDetail();
    for (GA_Offset v = gdp->pointVertex(p0); GAisValid(v);
        v = gdp->vertexToNextVertex(v))
    {
        auto v_prev = GA_INVALID_OFFSET;
        auto v_next = iface.polyNext(v, v_prev);
        if (GAisValid(v_prev))
            if (iface.vertexPoint(v_prev) == p1)
                return GEO_Hedge(v_prev);
        if (GAisValid(v_next))
            if (iface.vertexPoint(v_next) == p1)
                return GEO_Hedge(v);
    }
    return GEO_INVALID_HEDGE;
}

template <typename T>
GA_Size
numIncidentEdges(T &iface, GA_Offset pt)
{
    GEO_Hedge h0 = iface.firstIncidentEdge(pt);
    if (!iface.isValidHedge(h0))
        return 0;

    int res = 1;
    GEO_Hedge h1 = iface.nextIncidentEdge(h0, pt);
    while (h0 != h1)
    {
        res++;
        h1 = iface.nextIncidentEdge(h1, pt);
    }
    return res;
}

template <typename T>
GA_Size
numIncidentHedges(T &iface, GA_Offset pt)
{
    GEO_Hedge h0 = iface.firstIncidentHedge(pt);
    if (!iface.isValidHedge(h0))
        return 0;

    int res = 1;
    GEO_Hedge h1 = iface.nextIncidentHedge(h0, pt);
    while (h1 != h0)
    {
        res++;
        h1 = iface.nextIncidentHedge(h1, pt);
    }
    return res;
}

}; // namespace geo_hedge_private


#endif