GEO_HedgeInterface.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_HedgeInterface.h ( GEO Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GEO_HedgeInterface__
#define __GEO_HedgeInterface__

#include "GEO_Detail.h"
#include "GEO_Hedge.h"
#include "GEO_PrimType.h"
#include <GA/GA_Primitive.h>

class GEO_Primitive;
class GEO_PrimPoly;
class GA_ElementWranglerCache;

template <typename DERIVED>
class GEO_ConstHedgeInterface
{
public:
    using Point = GA_Offset;
    using Poly = GA_Offset;
    using Vertex = GA_Offset;
    using Hedge = GEO_Hedge;
    using SHedge = GEO_SHedge;

    virtual             ~GEO_ConstHedgeInterface() = default;

    SYS_FORCE_INLINE
    const DERIVED       &derived() const
                            { return static_cast<const DERIVED &>(*this); }

    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Fundamental methods:

    SYS_FORCE_INLINE
    bool                 isValidHedge(GEO_Hedge h) const
                            { return derived().isValidHedgeImpl(h); }
    SYS_FORCE_INLINE
    bool                 isPrimary(GEO_Hedge h) const
                            { return derived().isPrimaryImpl(h); }
    SYS_FORCE_INLINE
    GEO_Hedge            primary(GEO_Hedge h) const
                            { return derived().primaryImpl(h); }
    SYS_FORCE_INLINE
    GA_Offset            srcVertex(GEO_Hedge h) const
                            { return derived().srcVertexImpl(h); }
    SYS_FORCE_INLINE
    GA_Offset            dstVertex(GEO_Hedge h) const
                            { return derived().dstVertexImpl(h); }
    SYS_FORCE_INLINE
    GA_Offset            vertexPoint(GA_Offset vtx) const
                            { return derived().vertexPointImpl(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            vertexToNextVertex(GA_Offset vtx) const
                            { return derived().vertexToNextVertexImpl(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            pointVertex(GA_Offset vtx) const
                            { return derived().pointVertexImpl(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            vertexPrimitive(GA_Offset vtx) const
                            { return derived().vertexPrimitiveImpl(vtx); }

    /// Returns the next hedge in poly of h.
    SYS_FORCE_INLINE
    GEO_Hedge            lnext(GEO_Hedge h) const
                            { return derived().lnextImpl(h); }
    /// Returns the previous hedge in poly of h.
    SYS_FORCE_INLINE
    GEO_Hedge            lprev(GEO_Hedge e) const
                            { return derived().lprevImpl(e); }

    /// Returns the "next" equivalent (sym) hedge to h:
    /// Two hedges are equivalent if they have the same set of two points
    /// wired to their source and destination (regardless of which). Calling
    /// sym() repeatedly cycles through the equivalence class and returns back
    /// to the original hedge.
    SYS_FORCE_INLINE
    GEO_Hedge            sym(GEO_Hedge e) const
                            { return derived().symImpl(e); }

    SYS_FORCE_INLINE
    const GA_Detail     *getDetail() const
                            { return derived().getDetailImpl(); }

    SYS_FORCE_INLINE
    GA_Offset            polyPrev(GA_Offset v) const
                            { return derived().polyPrevImpl(v); }

    SYS_FORCE_INLINE
    GA_Offset            polyNext(GA_Offset v) const
                            { return derived().polyNextImpl(v); }

    SYS_FORCE_INLINE
    GA_Offset            polyNext(GA_Offset v, GA_Offset &vprev) const
                            { return derived().polyNextWithPrevImpl(v, vprev); }

    SYS_FORCE_INLINE
    GEO_Hedge            polyHedge(GA_Offset poly) const
                            { return derived().polyHedgeImpl(poly); }

    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Auxiliary methods:
    SYS_FORCE_INLINE
    GA_Offset            hedgePoly(GEO_Hedge h) const
                            { return vertexPrimitive(srcVertex(h)); }

    /// Returns the vertex before the source vertex of the hedge in the poly
    /// of the hedge.
    SYS_FORCE_INLINE
    GA_Offset            preSrcVertex(GEO_Hedge h) const
                            { return srcVertex(lprev(h)); }

    /// Returns the vertex after the destination vertex of the hedge in the
    /// poly of the hedge.
    GA_Offset            postDstVertex(GEO_Hedge h) const
                            { return dstVertex(lnext(h)); }

    SYS_FORCE_INLINE
    GA_Offset            srcPoint(GEO_Hedge h) const
                            { return vertexPoint(srcVertex(h)); }


    /// Returns the point to which the dst vertex is wired
    SYS_FORCE_INLINE
    GA_Offset            dstPoint(GEO_Hedge h) const
                            { return vertexPoint(dstVertex(h)); }

    /// @see: preSrcVertex()
    SYS_FORCE_INLINE
    GA_Offset            preSrcPoint(GEO_Hedge h) const
                            { return vertexPoint(preSrcVertex(h)); }

    /// @see: postDstVertex()
    SYS_FORCE_INLINE
    GA_Offset            postDstPoint(GEO_Hedge h) const
                            { return vertexPoint(postDstVertex(h)); }


    /// Returns a first incidentHedge to a point. Together with
    /// nextIncidentHedge, one can enumerate circularly over all hedges
    /// incident to a point.
    SYS_FORCE_INLINE
    GEO_Hedge            firstIncidentHedge(GA_Offset pt) const
                            { return geo_hedge::firstIncidentHedge(*this, pt); }

    SYS_FORCE_INLINE
    GEO_Hedge            nextIncidentHedge(GEO_Hedge h, GA_Offset pt) const
                            { return geo_hedge::nextIncidentHedge(*this, h, pt); }

    /// Similar to first/nextIncidentHedge but stops over only one of the
    /// hedges (the primary) in each equivalence class of hedges incident to
    /// the point.
    GEO_Hedge            firstIncidentEdge(GA_Offset pt) const
                            { return geo_hedge::firstIncidentEdge(*this, pt); }

    GEO_Hedge            nextIncidentEdge(GEO_Hedge e, GA_Offset pt) const
                            { return geo_hedge::nextIncidentEdge(*this, e, pt); }

    /// Similar to first/nextIncidentHedge but using only outgoing hedges.
    /// Note that nextOutgoingHedge does not need the parameter pt anymore.
    GEO_Hedge            firstOutgoingHedge(GA_Offset pt) const
                            { return geo_hedge::firstOutgoingHedge(*this, pt); }

    GEO_Hedge            nextOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextOutgoingHedge(*this, e); }

    /// Similar to first/nextIncidentHedge but using only incoming hedges.
    /// Note that nextOutgoingHedge does not need the parameter pt anymore.
    GEO_Hedge            firstIncomingHedge(GA_Offset pt) const
                            { return geo_hedge::firstIncomingHedge(*this, pt); }

    GEO_Hedge            nextIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            lcoincident(GEO_Hedge h, GA_Offset pt) const
                            { return geo_hedge::coincidentPolyHedge(*this, h, pt); }

    //~~~~~~~~~~~~~~~~~~~~~~~~
    // Manifold Scan Methods:

    /// A "manifold scan" around a point moves from one incoming (resp outgoing
    /// hedge incident to a point to the next in counterclockwise order as
    /// long as the hedge in question is a manifold hedge (i.e. it is
    /// equivalent to exactly one other hedge oriented oppositely).

    /// Returns the first hedge with the same dst as h that is reachable
    /// from e through a counterclockwise manifold scan around dst of e.
    /// Returns e itself if either:
    ///         1) e is already the first such hedge, or
    ///         2) the src of e is an interior point of a manifold,
    ///            ie the counterclockwise scan reaches back at e.
    GEO_Hedge            firstManifoldIncomingHedge(GEO_Hedge h) const
                            { return geo_hedge::firstManifoldIncomingHedge(*this, h); }

    SYS_FORCE_INLINE
    GEO_Hedge            dfirst(GEO_Hedge h) const
                            { return firstManifoldIncomingHedge(h); }

    /// Returns the previous hedge with the same dst as h in a
    /// counterclockwise manifold scan, returns GEO_INVALID_HEDGE if no
    /// such hedge exists.
    ///
    /// NOTE: This is equivalent to dprev() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            prevManifoldIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::prevManifoldIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            dprev(GEO_Hedge e) const
                            { return prevManifoldIncomingHedge(e); }

    /// Returns the next hedge with the same dst as e in a counterclockwise
    /// manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to dnext() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            nextManifoldIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextManifoldIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            dnext(GEO_Hedge e) const
                            { return nextManifoldIncomingHedge(e); }

    /// Similar to firstManifoldIncomingHedge but finds the first hedge with
    /// the same src as e in a counterclockwise scan from e.
    GEO_Hedge            firstManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::firstManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            ofirst(GEO_Hedge e) const
                            { return firstManifoldOutgoingHedge(e); }

    /// Returns the previous hedge with the same src as e in a counterclockwise
    // manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to oprev() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            prevManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::prevManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            oprev(GEO_Hedge e) const
                            { return prevManifoldOutgoingHedge(e); }

    /// Returns the next hedge with the same src as e in a counterclockwise
    /// manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to onext() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            nextManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            onext(GEO_Hedge e) const
                            { return nextManifoldOutgoingHedge(e); }

    /// Find a hedge with the given endpoints or return GEO_INVLAID_HEDGE
    GEO_Hedge            findHedgeWithEndpoints(GA_Offset p0, GA_Offset p1) const
                            { return geo_hedge::findHedgeWithEndpoints(*this, p0, p1); }

    /// Returns the length of the hedge e.
    /// Note that it requires the endpoints of e to be determiend.
    fpreal               length(GEO_Hedge e) const
                            { return geo_hedge::length(*this, e); }

    /// Returns the positions of the source point of e
    UT_Vector3           srcPos3(GEO_Hedge e) const
                            { return geo_hedge::srcPos3(getDetail(), e); }

    /// Returns the positions of the destination point of e
    UT_Vector3           dstPos3(GEO_Hedge e) const
                            { return geo_hedge::dstPos3(*this, e); }

    /// Returns the vector defined by the end-points of e
    UT_Vector3           hedgeVector(GEO_Hedge e) const
                            { return dstPos3(e) - srcPos3(e); }

    /// Returns the primitives angle at dst of the hedge.
    /// NB. If the angle in question is reflex, then its 2*pi complement is
    /// returned unless the normal of the primitive that contains e is
    /// passed using the optional nml parameter.
    fpreal               dstPrimitiveAngle(GEO_Hedge h,
                                UT_Vector3 *nml = nullptr) const
                            { return geo_hedge::dstPrimitiveAngle(*this, h, nml); }

    /// Returns the primitives angle at src of the hedge
    /// NB. If the angle in question is reflex, then its 2*pi complement is
    /// returned unless the normal of the primitive that contains e is
    /// passed using the optional nml parameter.
    fpreal               srcPrimitiveAngle(GEO_Hedge h,
                                UT_Vector3 *nml = nullptr) const
                            { return geo_hedge::srcPrimitiveAngle(*this, h, nml); }

    /// Returns the primitives angle at dst of the hedge
    fpreal               dstPrimitiveAngleCos(GEO_Hedge e) const
                            { return geo_hedge::dstPrimitiveAngleCos(*this, e); }

    /// Returns the primitives angle at src of the hedge
    fpreal               srcPrimitiveAngleCos(GEO_Hedge e) const
                            { return geo_hedge::srcPrimitiveAngleCos(*this, e); }

    /// Returns true if the hedge e is a manifold hedge, if accept_bd is
    /// false, this means that the equivalence class of e consists of
    /// exactly two hedges oriented oppositely. If accept_bd is true, then
    /// the equivalence class of e can also consist of a single (boundary)
    /// half-edge.
    bool                 isManifoldHedge(GEO_Hedge e, bool accept_bd = false) const
                            { return geo_hedge::isManifoldHedge(*this, e, accept_bd); }

    /// Returns true if the hedge e is a boundary hedge, i.e. if its
    /// equivalence class is singleton.
    bool                 isBoundaryHedge(GEO_Hedge e) const
                            { return geo_hedge::isBoundaryHedge(*this, e); }

    /// Returns true if the hedge e is a bridge hedge, i.e. if is a
    /// manifold hedge and its other equivalent hedge belongs to the
    /// same primitive as e does.
    bool                 isBridgeHedge(GEO_Hedge e) const
                            { return geo_hedge::isBridgeHedge(*this, e); }

    /// Returns true if e1 and e2 are equivalent hedges with opposite
    /// orientation.
    bool                 areOpposite(GEO_Hedge e1, GEO_Hedge e2) const
                            { return geo_hedge::areOpposite(*this, e1, e2); }

    bool                 areOpposite(GEO_SHedge e1, GEO_SHedge e2) const
                            { return areEquivalent(e1, -e2); }

    /// Returns true if e1 and e2 are equivalent hedges.
    bool                 areEquivalent(GEO_Hedge e1, GEO_Hedge e2) const
                            { return geo_hedge::areEquivalent(*this, e1, e2); }

    /// Returns true if e1 and e2 are equivalent signed hedges.
    bool                 areEquivalent(GEO_SHedge e1, GEO_SHedge e2) const
                            { return primary(e1) == primary(e2); }

    /// Returns the number of hedges in the equivalence class of e.
    GA_Size              numEquivalentHedges(GEO_Hedge e) const
                            { return geo_hedge::numEquivalentHedges(*this, e); }

    /// Returns the number if *edges* incident to a point (equivalent hedges
    /// count as 1).
    GA_Size              numIncidentEdges(GA_Offset pt) const
                            { return geo_hedge::numIncidentEdges(*this, pt); }

    /// Returns the number of distinct *hedges* incident to pt
    GA_Size              numIncidentHedges(GA_Offset pt) const
                            { return geo_hedge::numIncidentHedges(*this, pt); }


    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Signed Half-edge operations:

    /// Returns the source vertex of a signed hedge.
    SYS_FORCE_INLINE
    GA_Offset            srcVertex(const GEO_SHedge &sh) const
                            { return sh.isPositive() ? srcVertex(sh.hedge())
                                                     : dstVertex(sh.hedge()); }

    /// Returns the destination vertex of a signed hedge.
    SYS_FORCE_INLINE
    GA_Offset            dstVertex(const GEO_SHedge &sh) const
                            { return sh.isPositive() ? dstVertex(sh.hedge())
                                                     : srcVertex(sh.hedge()); }

    /// Returns the src vertex of a signed hedge.
    SYS_FORCE_INLINE
    GA_Offset            srcPoint(GEO_SHedge sh) const
                            { return vertexPoint(srcVertex(sh)); }

    /// Returns the src vertex of a signed hedge.
    SYS_FORCE_INLINE
    GA_Offset            dstPoint(GEO_SHedge sh) const
                            { return vertexPoint(dstVertex(sh)); }

    SYS_FORCE_INLINE
    GEO_SHedge           primary(GEO_SHedge sh) const
    {
        auto hp = primary(sh.hedge());
        return GEO_SHedge(hp, srcPoint(hp) == srcPoint(sh) ? 1 : -1);
    }

    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Legacy aliases: these are deprecated and should be substituted for
    // shorter names.

    SYS_FORCE_INLINE
    GEO_Hedge            nextEquivalentHedge(GEO_Hedge h) const
                            { return sym(h); }

    SYS_FORCE_INLINE
    GEO_Hedge            primaryEquivalentHedge(GEO_Hedge h) const
                            { return primary(h); }

    SYS_FORCE_INLINE
    GA_Offset            hedgePrimitiveOffset(GEO_Hedge h) const
                            { return hedgePoly(h); }

    SYS_FORCE_INLINE
    GEO_Hedge            nextPrimitiveHedge(GEO_Hedge h) const
                            { return lnext(h); }

    SYS_FORCE_INLINE
    GEO_Hedge            prevPrimitiveHedge(GEO_Hedge h) const
                            { return lprev(h); }

    SYS_FORCE_INLINE
    GA_Offset            prevPrimVertex(GA_Offset v) const
                            { return polyNext(v); }

    SYS_FORCE_INLINE
    GA_Offset            nextPrimVertex(GA_Offset v) const
                            { return polyPrev(v); }

    SYS_FORCE_INLINE
    GEO_Hedge            otherPrimitiveHedgeAtPoint(GEO_Hedge h,
                                GA_Offset pt) const
                            { return lcoincident(h, pt); }
};

//  GEO_DetachedHedgeInterface is a READ-ONLY half-edge interface and is
//  built with the assumption that the detail on which it is based stays
//  constant while the interface is in use. Useful facts:
//
//      1. It does not create additional topology attributes on the detail.
//      2. It stores primitive vertex order information internally and does
//         not access primitives.
//      3. It can be constructed for a primitive group, as though other
//         primitives do not exist.

#define PRIM_ORDER_VERTICES

class GEO_API GEO_DetachedHedgeInterface :
        public GEO_ConstHedgeInterface<GEO_DetachedHedgeInterface>
{
    friend class GEO_ConstHedgeInterface<GEO_DetachedHedgeInterface>;

public:
    explicit             GEO_DetachedHedgeInterface(const GA_Detail *gdp,
                               const GA_PrimitiveGroup *prims = nullptr,
                               bool exclude_prims = true) :
                            myGdp(gdp)
                            { buildHedgeTopologyLinks(prims, exclude_prims); }

    SYS_FORCE_INLINE
    bool                 isValidHedgeImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    bool                 isPrimaryImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    GEO_Hedge            primaryImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    GA_Offset            srcVertexImpl(GEO_Hedge h) const
                            { return geo_hedge::srcVertex(h); }
    SYS_FORCE_INLINE
    GA_Offset            dstVertexImpl(GEO_Hedge h) const
                            { return myPrimNextRef(geo_hedge::srcVertex(h)); }
    SYS_FORCE_INLINE
    GA_Offset            vertexPointImpl(GA_Offset vtx) const
                            { return GAisValid(vtx) ? myGdp->vertexPoint(vtx)
                                                    : GA_INVALID_OFFSET; }
    SYS_FORCE_INLINE
    GA_Offset            vertexPrimitiveImpl(GA_Offset vtx) const
                            { return GAisValid(vtx)
                                        ? myGdp->vertexPrimitive(vtx)
                                        : GA_INVALID_OFFSET; }

    SYS_FORCE_INLINE
    GA_Offset            vertexToNextVertexImpl(GA_Offset vtx) const
                            { return myGdp->vertexToNextVertex(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            pointVertexImpl(GA_Offset vtx) const
                            { return myGdp->pointVertex(vtx); }

    SYS_FORCE_INLINE
    GEO_Hedge            lnextImpl(GEO_Hedge h) const
                            { return GEO_Hedge(dstVertex(h)); }
    SYS_FORCE_INLINE
    GEO_Hedge            lprevImpl(GEO_Hedge h) const
                            { return GEO_Hedge(myPrimPrevRef(srcVertex(h))); }

    SYS_FORCE_INLINE
    GEO_Hedge            symImpl(GEO_Hedge h) const
                            { return GEO_Hedge(myHedgeNextRef(srcVertex(h))); }

    SYS_FORCE_INLINE
    const GA_Detail     *getDetailImpl() const { return myGdp; }

    SYS_FORCE_INLINE
    GA_Offset            polyPrevImpl(GA_Offset v) const
                            { return myPrimPrevRef(v); }

    SYS_FORCE_INLINE
    GA_Offset            polyNextImpl(GA_Offset v) const
                            { return myPrimNextRef(v); }

    SYS_FORCE_INLINE
    GEO_Hedge            polyHedgeImpl(GA_Offset poly) const;

    SYS_FORCE_INLINE
    GA_Offset            polyNextWithPrevImpl(GA_Offset v,
                                GA_Offset &vprev) const;

    const GEO_Primitive *hedgePrimitive(GEO_Hedge h) const;

private:
    void                 buildHedgeTopologyLinks(
                                const GA_PrimitiveGroup *group = nullptr,
                                bool exclude_prims = true);

    const GA_Detail     *myGdp;
    GA_OffsetArray       myHedgeNextRef;
    GA_OffsetArray       myPrimPrevRef;
    GA_OffsetArray       myPrimNextRef;
    UT_BitArray          myPrimaryMask;
};

// Bare-bones stand-in for the detached hedge interface without any caching.

class GEO_API GEO_UncachedHedgeInterface :
        public GEO_ConstHedgeInterface<GEO_UncachedHedgeInterface>
{
    friend class GEO_ConstHedgeInterface<GEO_UncachedHedgeInterface>;

public:
    explicit             GEO_UncachedHedgeInterface(const GA_Detail *gdp,
                                const GA_PrimitiveGroup *prims = nullptr);

    SYS_FORCE_INLINE
    bool                 isValidHedgeImpl(GEO_Hedge h) const
                            { return GAisValid(srcVertex(h))
                                        && isOurPoly(hedgePoly(h)); }

    SYS_FORCE_INLINE
    bool                 isPrimaryImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    GEO_Hedge            primaryImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    GA_Offset            srcVertexImpl(GEO_Hedge h) const
                            { return geo_hedge::srcVertex(h); }
    SYS_FORCE_INLINE
    GA_Offset            dstVertexImpl(GEO_Hedge h) const
                            { return polyNext(srcVertex(h)); }
    SYS_FORCE_INLINE
    GA_Offset            vertexPointImpl(GA_Offset vtx) const
                            { return GAisValid(vtx) ? myGdp->vertexPoint(vtx)
                                                    : GA_INVALID_OFFSET; }
    SYS_FORCE_INLINE
    GA_Offset            vertexPrimitiveImpl(GA_Offset vtx) const
                            { return GAisValid(vtx)
                                        ? myGdp->vertexPrimitive(vtx)
                                        : GA_INVALID_OFFSET; }

    SYS_FORCE_INLINE
    GA_Offset            vertexToNextVertexImpl(GA_Offset vtx) const
                            { return myGdp->vertexToNextVertex(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            pointVertexImpl(GA_Offset vtx) const
                            { return myGdp->pointVertex(vtx); }

    /// Returns the next hedge in poly of h.
    SYS_FORCE_INLINE
    GEO_Hedge            lnextImpl(GEO_Hedge h) const
                            { return GEO_Hedge(dstVertex(h)); }
    /// Returns the previous hedge in poly of h.
    SYS_FORCE_INLINE
    GEO_Hedge            lprevImpl(GEO_Hedge h) const
                            { return GEO_Hedge(polyPrev(srcVertex(h))); }

    /// Returns the "next" equivalent (sym) hedge to h:
    /// Two hedges are equivalent if they have the same set of two points
    /// wired to their source and destination (regardless of which). Calling
    /// sym() repeatedly cycles through the equivalence class and returns back
    /// to the original hedge.
    GEO_Hedge            symImpl(GEO_Hedge h) const;

    SYS_FORCE_INLINE
    const GA_Detail     *getDetailImpl() const { return myGdp; }

    SYS_FORCE_INLINE
    GA_Offset            polyPrevImpl(GA_Offset v) const;

    SYS_FORCE_INLINE
    GA_Offset            polyNextImpl(GA_Offset v) const;

    SYS_FORCE_INLINE
    GA_Offset            polyNextWithPrevImpl(GA_Offset v,
                                GA_Offset &vprev) const;
    SYS_FORCE_INLINE
    GEO_Hedge            polyHedgeImpl(GA_Offset poly) const;

private:
    SYS_FORCE_INLINE
    bool                 isOurPoly(GA_Offset poly) const;

    const GA_Detail         *myGdp;
    GA_PrimitiveGroupUPtr    myPolys;
};

/// GEO_HedgeInterface provides the interface to deal with a detail's
/// half-edges. Ultimately it's expected to replace GQ. By default the
/// constructor of the class adds two additional half-edge topology attributes
/// to the detail if they're not already present (unless the second parameter
/// is set to false, in which case all operations are handled without the
/// topology attributes and can therefore be much much slower). The
/// destructor of GEO_HedgeInterface removes these topology
/// attributes from detail if they were added by the constructor but leaves
/// them there if they already existed when the class was created.
///
/// NOTE: The merge code for topology attributes is not tested and is quite
/// like to fail. It is therefore highly advisable to remove the topology
/// attributes when you're done with them and thereby prevent them from
/// being passed to details downstream.

class GEO_API GEO_HedgeInterface
{
public:

    GEO_HedgeInterface(GA_Detail *gdp, bool use_hedge_topology = true);
    ~GEO_HedgeInterface();

    void                 destroyHedgeTopologyLinks();

    bool                 haveHedgeTopology() const
                            { return myHaveHedgeTopology; }

    /// If a wrangler cache is set, the operations involving hedges use it
    /// to wrangle attributes. To stop wrangling, the method can be called
    /// with NULL as parameter.

    void                 setWranglerCache(GA_ElementWranglerCache *wc)
                            { myWranglerCache = wc; }

    /// Return the polygon to which the hedge belongs.
    /// NOTE: may need to modify this if other primitives support hedges.
    GEO_Primitive       *hedgePrimitive(GEO_Hedge e) const
    {
        // NOTE: Not a static_cast to avoid needing definition of GEO_Primitive
        return (GEO_Primitive *) geo_hedge::hedgePrimitive(myGdp, e);
   }

    GA_Offset            hedgePrimitiveOffset(GEO_Hedge e) const
                            { return geo_hedge::hedgePrimitiveOffset(myGdp, e); }

    /// Check whether a hedge is valid: a hedge is valid if
    ///  1: its src vertex belongs to a primitive that supports hedges, and
    ///  2: the primitive returns a valid *next boundary vertex* for its dst
    ///     vertex.
    ///
    /// @see: GA_Topology.h
    bool                 isValidHedge(GEO_Hedge &e) const;

    SYS_FORCE_INLINE
    GA_Offset            vertexPoint(GA_Offset vtx) const
                            { return GAisValid(vtx) ? myGdp->vertexPoint(vtx)
                                                    : GA_INVALID_OFFSET; }
    SYS_FORCE_INLINE
    GA_Offset            vertexPrimitive(GA_Offset vtx) const
                            { return GAisValid(vtx)
                                        ? myGdp->vertexPrimitive(vtx)
                                        : GA_INVALID_OFFSET; }

    SYS_FORCE_INLINE
    GA_Offset            vertexToNextVertex(GA_Offset vtx) const
                            { return myGdp->vertexToNextVertex(vtx); }

    SYS_FORCE_INLINE
    GA_Offset            pointVertex(GA_Offset vtx) const
                            { return myGdp->pointVertex(vtx); }


    /// returns true of e is the *primary* hedge in its equivalence class.
    /// Each equivalence class of hedges at any time has a unique primary
    /// hedge. This is used for example to enumerate over all edges in the
    /// detail (as opposed to over all hedges).
    bool                 isPrimary(GEO_Hedge e) const;

    /// Returns the src vertex of the hedge
    GA_Offset            srcVertex(GEO_Hedge e) const
                            { return geo_hedge::srcVertex(e); }

    /// Returns the dst vertex of the hedge
    GA_Offset            dstVertex(GEO_Hedge e) const
                            { return geo_hedge::dstVertex(*this, e); }

    /// Returns the vertex before the src vertex of the hedge in the poly
    /// to which the hedge belongs
    GA_Offset            preSrcVertex(GEO_Hedge e) const
                            { return geo_hedge::preSrcVertex(*this, e); }

    /// Returns the vertex after the dst of the vertex of the hedge in
    /// the poly to which the hedge belongs
    GA_Offset            postDstVertex(GEO_Hedge e) const
                            { return geo_hedge::postDstVertex(*this, e); }

    /// Returns the point to which the src vertex is wired
    GA_Offset            srcPoint(GEO_Hedge e) const
                            {  return geo_hedge::srcPoint(myGdp, e); }

    /// Returns the point to which the dst vertex is wired
    GA_Offset            dstPoint(GEO_Hedge e) const
                            { return geo_hedge::dstPoint(*this, e); }

    /// Returns the point to which the pre-src vertex is wired.
    /// @see: preSrcVertex()
    GA_Offset            preSrcPoint(GEO_Hedge e) const
                            { return geo_hedge::preSrcPoint(*this, e); }

    /// Returns the point to which the post-dst vertex is wired
    /// @see: postDstVertex()
    GA_Offset            postDstPoint(GEO_Hedge e) const
                            { return geo_hedge::postDstPoint(*this, e); }

    /// Returns the next hedge (hedge with src equal to the dst of the
    /// parameter hedge) in the polygon that contains the parameter hedge
    GEO_Hedge            nextPrimitiveHedge(GEO_Hedge e) const
                            { return geo_hedge::nextPrimitiveHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            lnext(GEO_Hedge e) const
                            { return nextPrimitiveHedge(e); }

    /// Returns the previous hedge (hedge whose dst is the same as the src
    /// of the parameter hedge) in the polygon that contains the parameter
    /// hedge.
    GEO_Hedge            prevPrimitiveHedge(GEO_Hedge h) const
                            { return geo_hedge::prevPrimitiveHedge(*this, h); }

    SYS_FORCE_INLINE
    GEO_Hedge            lprev(GEO_Hedge h) const
                            { return prevPrimitiveHedge(h); }

    /// Returns the "other" (than h) hedge in the polygon of h that has the
    /// pt as an endpoint.
    GEO_Hedge            otherPrimitiveHedgeAtPoint(GEO_Hedge h, GA_Offset pt) const
                            { return geo_hedge::coincidentPolyHedge(*this, h, pt); }

    /// Returns the "next" equivalent hedge to e:
    /// two hedges are equivalent if either their dsts and srcs are
    /// respectively wired to the same points or if the dst of each is
    /// wired to the same point as the src of the other. calling
    /// nextEquivalentHedge() repeatedly returns back to the original hedge.
    /// Thus to check if hedge e is manifold hedge one can check that:
    /// nextEquivalentHedge(e) != e &&
    ///         nextEquivalentHedge(nextEquivalentHedge(e)) == e
    GEO_Hedge            nextEquivalentHedge(GEO_Hedge e) const;

    SYS_FORCE_INLINE
    GEO_Hedge            sym(GEO_Hedge e) const
                            { return nextEquivalentHedge(e); }

    /// Returns the primary hedge equivalent to the argument hedge.
    GEO_Hedge            primaryEquivalentHedge(GEO_Hedge e) const;

    SYS_FORCE_INLINE
    GEO_Hedge            primary(GEO_Hedge e) const
                            { return primaryEquivalentHedge(e); }

    /// Returns a first incidentHedge to a point. Together with
    /// nextIncidentHedge, one can enumerate circularly over all hedges
    /// incident to a point.
    GEO_Hedge            firstIncidentHedge(GA_Offset pt) const
                            { return geo_hedge::firstIncidentHedge(*this, pt); }

    GEO_Hedge            nextIncidentHedge(GEO_Hedge e, GA_Offset pt) const
                            { return geo_hedge::nextIncidentHedge(*this, e, pt); }

    /// Similar to first/nextIncidentHedge but stops over only one of the
    /// hedges in each equivalence class of hedges incident to the point
    GEO_Hedge            firstIncidentEdge(GA_Offset pt) const
                            { return geo_hedge::firstIncidentEdge(*this, pt); }

    GEO_Hedge            nextIncidentEdge(GEO_Hedge e, GA_Offset pt) const
                            { return geo_hedge::nextIncidentEdge(*this, e, pt); }

    /// Similar to first/nextIncidentHedge but using only outgoing hedges.
    /// Note that nextOutgoingHedge does not need the parameter pt anymore.
    GEO_Hedge            firstOutgoingHedge(GA_Offset pt) const
                            { return geo_hedge::firstOutgoingHedge(*this, pt); }

    GEO_Hedge            nextOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextOutgoingHedge(*this, e); }

    /// Similar to first/nextIncidentHedge but using only incoming hedges.
    /// Note that nextOutgoingHedge does not need the parameter pt anymore.
    GEO_Hedge            firstIncomingHedge(GA_Offset pt) const
                            { return geo_hedge::firstIncomingHedge(*this, pt); }

    GEO_Hedge            nextIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextIncomingHedge(*this, e); }

    /// Manifold Scan Methods:

    /// A "manifold scan" around a point moves from one incoming (resp outgoing
    /// hedge incident to a point to the next in counterclockwise order as
    /// long as the hedge in question is a manifold hedge (i.e. it is
    /// equivalent to exactly one other hedge oriented oppositely).

    /// Returns the first hedge with the same dst as e that is reachable
    /// from e through a counterclockwise manifold scan around dst of e.
    /// Returns e itself if either:
    ///         1) e is already the first such hedge, or
    ///         2) the src of e is an interior point of a manifold,
    ///            ie the counterclockwise scan reaches back at e.
    GEO_Hedge            firstManifoldIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::firstManifoldIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            dfirst(GEO_Hedge e) const
                            { return firstManifoldIncomingHedge(e); }
    /// Returns the previous hedge with the same dst as e in a
    /// counterclockwise manifold scan, returns GEO_INVALID_HEDGE if no
    /// such hedge exists.
    ///
    /// NOTE: This is equivalent to dprev() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            prevManifoldIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::prevManifoldIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            dprev(GEO_Hedge e) const
                            { return prevManifoldIncomingHedge(e); }

    /// Returns the next hedge with the same dst as e in a counterclockwise
    /// manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to dnext() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            nextManifoldIncomingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextManifoldIncomingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            dnext(GEO_Hedge e) const
                            { return nextManifoldIncomingHedge(e); }

    /// Similar to firstManifoldIncomingHedge but finds the first hedge with
    /// the same src as e in a counterclockwise scan from e.
    GEO_Hedge            firstManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::firstManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            ofirst(GEO_Hedge e) const
                            { return firstManifoldOutgoingHedge(e); }

    /// Returns the previous hedge with the same src as e in a counterclockwise
    // manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to oprev() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            prevManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::prevManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            oprev(GEO_Hedge e) const
                            { return prevManifoldOutgoingHedge(e); }

    /// Returns the next hedge with the same src as e in a counterclockwise
    /// manifold scan, returns GEO_INVALID_HEDGE if no such hedge exists.
    ///
    /// NOTE: This is equivalent to onext() operation in Quad-Edge
    /// terminology, which is also used in GQ.
    GEO_Hedge            nextManifoldOutgoingHedge(GEO_Hedge e) const
                            { return geo_hedge::nextManifoldOutgoingHedge(*this, e); }

    SYS_FORCE_INLINE
    GEO_Hedge            onext(GEO_Hedge e) const
                            { return nextManifoldOutgoingHedge(e); }

    /// Returns the length of the hedge e.
    /// Note that it requires the endpoints of e to be determined.
    fpreal               length(GEO_Hedge e) const
                            { return geo_hedge::length(*this, e); }

    /// Returns the positions of the source point of e
    UT_Vector3           srcPos3(GEO_Hedge e) const
                            { return geo_hedge::srcPos3(myGdp, e); }

    /// Returns the positions of the destination point of e
    UT_Vector3           dstPos3(GEO_Hedge e) const
                            { return geo_hedge::dstPos3(*this, e); }

    /// Returns the vector defined by the end-points of e
    UT_Vector3           hedgeVector(GEO_Hedge e) const
                            { return dstPos3(e) - srcPos3(e); }

    /// Returns the primitives angle at dst of the hedge
    /// NB. If the angle in question is reflex, then its 2*pi complement is
    /// returned unless the normal of the primitive that contains e is
    /// passed using the optional nml parameter.
    fpreal               dstPrimitiveAngle(GEO_Hedge e, UT_Vector3 *nml = 0) const
                            { return geo_hedge::dstPrimitiveAngle(*this, e, nml); }

    /// Returns the primitives angle at src of the hedge
    /// NB. If the angle in question is reflex, then its 2*pi complement is
    /// returned unless the normal of the primitive that contains e is
    /// passed using the optional nml parameter.
    fpreal               srcPrimitiveAngle(GEO_Hedge e, UT_Vector3 *nml = 0) const
                            { return geo_hedge::srcPrimitiveAngle(*this, e, nml); }

    /// Returns the primitives angle at dst of the hedge
    fpreal               dstPrimitiveAngleCos(GEO_Hedge e) const
                            { return geo_hedge::dstPrimitiveAngleCos(*this, e); }

    /// Returns the primitives angle at src of the hedge
    fpreal               srcPrimitiveAngleCos(GEO_Hedge e) const
                            { return geo_hedge::srcPrimitiveAngleCos(*this, e); }

    /// Returns true if the hedge e is a manifold hedge, if accept_bd is
    /// false, this means that the equivalence class of e consists of
    /// exactly two hedges oriented oppositely. If accept_bd is true, then
    /// the equivalence class of e can also consist of a single (boundary)
    /// half-edge.
    bool                 isManifoldHedge(GEO_Hedge e, bool accept_bd = false) const
                            { return geo_hedge::isManifoldHedge(*this, e, accept_bd); }

    /// Returns true if the hedge e is a boundary hedge, i.e. if its
    /// equivalence class is singleton.
    bool                 isBoundaryHedge(GEO_Hedge e) const
                            { return geo_hedge::isBoundaryHedge(*this, e); }

    /// Returns true if the hedge e is a bridge hedge, i.e. if is a
    /// manifold hedge and its other equivalent hedge belongs to the
    /// same primitive as e does.
    bool                 isBridgeHedge(GEO_Hedge e) const
                            { return geo_hedge::isBridgeHedge(*this, e); }

    /// Returns true if e1 and e2 are equivalent hedges with opposite
    /// orientation.
    bool                 areOpposite(GEO_Hedge e1, GEO_Hedge e2) const
                            { return geo_hedge::areOpposite(*this, e1, e2); }

    /// Returns true if e1 and e2 are equivalent hedges.
    bool                 areEquivalent(GEO_Hedge e1, GEO_Hedge e2) const
                            { return geo_hedge::areEquivalent(*this, e1, e2); }

    /// Returns the number of hedges in the equivalence class of e.
    GA_Size              numEquivalentHedges(GEO_Hedge e) const
                            { return geo_hedge::numEquivalentHedges(*this, e); }

    /// Returns the number if *edges* incident to a point (equivalent hedges
    /// count as 1).
    GA_Size              numIncidentEdges(GA_Offset pt) const
                            { return geo_hedge::numIncidentEdges(*this, pt); }

    /// Returns the number of distinct *hedges* incident to pt
    GA_Size              numIncidentHedges(GA_Offset pt) const
                            { return geo_hedge::numIncidentHedges(*this, pt); }

    /// Find a hedge with the given endpoints or return GEO_INVLAID_HEDGE
    GEO_Hedge            findHedgeWithEndpoints(GA_Offset p0, GA_Offset p1) const
                            { return geo_hedge::findHedgeWithEndpoints(*this, p0, p1); }

    /// Returns the number of primitives that have pt as a vertex and support
    /// hedges.
    GA_Size              numIncidentHedgeSupportingPrims(GA_Offset pt) const;

    // operations involving half-edges

    /// Rotate e forward, provided that e is a manifold hedge (equivalent
    /// to exactly one other hedge f oppositely oriented. This is not checked
    /// and the topology may be corrupted if rotate is applied to non-manifold
    /// or boundary edges. Returns the resulting hedge which happens to be
    /// equal to e (The input hedge will be the hedge that rotates (same src
    /// vertex) and the same holds for the equivalent edge of e.
    ///
    ///    ------>------>          ------>------>
    ///    ^     |^     |          ^          /7|
    ///    |     ||     |          |        //  |
    ///    |   e ||     |   ===>   |   e  //    |
    ///    |     ||     |          |    //      |
    ///    |     v|     v          |  //        v
    ///    <------<------          |L/<---<------
    ///
    /// Note that this operation is precisely an edge flip if the two
    /// primitives involved are triangles.

    GEO_Hedge            rotateForward(GEO_Hedge e);

    /// Complete reverse of rotateForward (all the point, vertex, and
    /// primitive offsets are restored). When the incident primitives are
    /// triangles, rotating forward or backward result in the same edge but
    /// they are not exactly identical. In particular, two consecutive flips
    /// on the same edge will reverse the orientation of the edge.

    GEO_Hedge            rotateBackward(GEO_Hedge e);

    /// Returns true if e can be flipped without the result overlapping an
    /// existing hedge. In other words, e is flippable if its endpoints are
    /// not endpoints of an existing edge in the geometry before the flip that
    /// is not equivalent to e.

    bool                 isFlippable(GEO_Hedge e) const;

    /// Flip e (provided that e is shared between two triangles) and is
    /// flippable. Returns the resulting (flipped) hedge (equal to e) or
    /// GEO_INVALID_HEDGE if e is not flippable.

    GEO_Hedge            flip(GEO_Hedge e);

    /// unflip is the reverse of a flip. Doing a flip followed by an unflip
    /// should result in the same mesh with the same vertex/point/primitive
    /// offsets and indices (but the vertices within primitives may shift).
    GEO_Hedge            unflip(GEO_Hedge e);

    /// Returns true if the hedge e is contractible, i.e. contracting e does
    /// not force a a non-trivial (separating) cycle to collapse. A separating
    /// cycle is a closed sequence of edges that if removed (together with
    /// their incident geometry elements) the number of connected components
    // increases. Contracting a non-contractible edge will split geometry into
    /// multiple components.
    bool                 isContractible(GEO_Hedge e) const;

    /// Contracts e.
    /// @parameter on_dst, if true, causes the src point to move to the
    ///                 position of the dst point. Otherwise, the dst point
    ///                 is moved to the src point's position.
    /// @parameter ratio, if not equal to 1.0, places the point of contraction
    ///                 in a convex combination with biases ratio and
    ///                 1.0 - ratio from src and dst (or the other way around
    ///                 if on_dst is false) respectively.
    GA_Offset            contract(GEO_Hedge e,
                                bool on_dst = true,
                                fpreal ratio = 1.0,
                                bool check_contractible = true);

#if 0
    GA_Offset    contractNew(GEO_Hedge e, bool on_dst = true, fpreal ratio = 1.0);
#endif

    /// Splits the hedge e and its incident polygon (assumed to be a triangle,
    /// although it doesn't fail if it isn't).
    /// @parameter ratio determines the position of the new point at which the
    ///                 hedge is split.
    /// @parameter and_equivalent if true also splits all other hedges
    ///                 equivalent to e at the same point.
    /// @parameter poff is an optional point offset assumed to be located in
    //                  the correct position (as given by ratio). This allows
    //                  the caller to reuse points already created.
    GEO_Hedge            split(GEO_Hedge e,
                                fpreal ratio,
                                bool and_equivalent = true,
                                GA_Offset poff = GA_INVALID_OFFSET);


    GEO_Hedge            reversibleSplit(GEO_Hedge e,
                                fpreal ratio,
                                bool and_equivalent = true,
                                GA_Offset poff = GA_INVALID_OFFSET);


    /// Inserts a point in the middle of a hedge and divides into two hedges.
    ///
    /// @parameter ratio determines the position of the new point at which the
    ///                 hedge is split.
    /// @parameter and_equivalent if true also divides all other hedges
    ///                 equivalent to e at the same point.
    /// @parameter poff is an optional point offset assumed to be located in
    //                  the correct position (as given by ratio). This allows
    //                  the caller to reuse points already created.
    GEO_Hedge            divideHedge(GEO_Hedge e, fpreal ratio,
                                bool and_equivalent = true,
                                GA_Offset poff = GA_INVALID_OFFSET);

    /// Splits the primitive of a hedge into two primitives by cutting it
    /// along a diagonal. The hedges starting from ekeep and ending
    /// before edrop are kept in the current primitive while the edges
    /// hedges starting at edrop and ending before ekeep end up in the
    /// new primitive.
    GEO_Hedge            divideHedgePrimitive(GEO_Hedge ekeep, GEO_Hedge edrop);

    /// Subdivides the polygon of e at its barycenter or the supplied point
    GA_Offset            splitHedgePrimitive(GEO_Hedge e,
                                GA_Offset pt = GA_INVALID_OFFSET);

    // Deletes the *star* of a point. The star of a point in a polygonal
    // complex consists of all edges and polygons incident to that point.
    // So, deleting the star of an internal point on a manifold should leave
    // a hole behind. If the patch_link is set to true, the hole is patched
    // (if possible) with a new polygon. For this be possible the point *must*
    // be an internal manifold point. If patching is possible then one of
    // the polygons previously incident to pt can be specified as patch_prim
    // to extend and become the patching polygon. If this polygon is not
    // specified or is not actually incident to pt, then a new polygon will
    // be created.
    void                 deletePointStar(GA_Offset pt, bool patch_link = true,
                                GA_Offset patch_prim = GA_INVALID_OFFSET);

    GA_Detail           *getDetail() const { return myGdp; }

    SYS_FORCE_INLINE
    GA_Offset            polyPrev(GA_Offset v) const;

    SYS_FORCE_INLINE
    GA_Offset            polyNext(GA_Offset v) const;

    SYS_FORCE_INLINE
    GA_Offset            polyNext(GA_Offset v, GA_Offset &vprev) const;
private:

    GA_Detail                   *myGdp;
    GA_Topology                 &myTopology;
    bool                         myKeepHedgeTopology;
    bool                         myHaveHedgeTopology;
    GA_ElementWranglerCache     *myWranglerCache;
};


GA_Offset
GEO_HedgeInterface::polyPrev(GA_Offset v) const
{
    GA_Offset vprev, vnext;
    myGdp->getTopology().getAdjacentBoundaryVertices(v, vprev, vnext);
    return vprev;
}


GA_Offset
GEO_HedgeInterface::polyNext(GA_Offset v) const
{
    GA_Offset vprev, vnext;
    myGdp->getTopology().getAdjacentBoundaryVertices(v, vprev, vnext);
    return vnext;
}

GA_Offset
GEO_HedgeInterface::polyNext(GA_Offset v, GA_Offset &vprev) const
{
    GA_Offset vnext;
    myGdp->getTopology().getAdjacentBoundaryVertices(v, vprev, vnext);
    return vnext;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

bool
GEO_DetachedHedgeInterface::isValidHedgeImpl(GEO_Hedge e) const
{
    GA_Offset srcvtx = srcVertex(e);
    if (!GAisValid(srcvtx))
        return false;

    return GAisValid(myHedgeNextRef(srcvtx));
}

bool
GEO_DetachedHedgeInterface::isPrimaryImpl(GEO_Hedge e) const
{
    GA_Offset esrc = srcVertex(e);

#ifdef PRIM_ORDER_VERTICES
    return myPrimaryMask.getBitFast(esrc);
#else

    // We are not keeping any primary hedge information since the
    // lexicographic sorting of the pairs orders the src vertices of the
    // equivalent hedges as well. Therefore, the linking of equivalent
    // hedges is always from lower offset to higher offset except at the
    // last linked element which points to a lower offset of the first
    // element. This essentially gives us a way of electing one member
    // of the equivalence class, i.e. the one with largest offset, as
    // primary since it is the only one that points to a lower offset.

    GA_Offset esrcnext = myHedgeNextRef(esrc);
    return (esrcnext <= esrc);
#endif
}

GEO_Hedge
GEO_DetachedHedgeInterface::primaryImpl(GEO_Hedge h) const
{
    while (!isPrimary(h))
        h = sym(h);
    return h;
}

GA_Offset
GEO_DetachedHedgeInterface::polyNextWithPrevImpl(GA_Offset v,
                                                 GA_Offset &vprev) const
{
    vprev = myPrimPrevRef(v);
    return myPrimNextRef(v);
}

GEO_Hedge
GEO_DetachedHedgeInterface::polyHedgeImpl(GA_Offset poly) const
{
    auto vtxs = myGdp->getPrimitiveVertexList(poly);
    if (vtxs.size() == 0 || !isValidHedge(GEO_Hedge(vtxs(0))))
        return GEO_INVALID_HEDGE;
    return GEO_Hedge(vtxs(0));
}

bool
GEO_UncachedHedgeInterface::isOurPoly(GA_Offset poly) const
{
    if (myPolys && !myPolys->containsOffset(poly))
        return false;

    return (myGdp->getPrimitiveTypeId(poly) == GEO_PRIMPOLY
            && myGdp->getPrimitiveClosedFlag(poly));
}

bool
GEO_UncachedHedgeInterface::isPrimaryImpl(GEO_Hedge h) const
{
    auto v0 = srcVertex(h);
    auto h0 = h;
    while (h = sym(h), h != h0)
        if (srcVertex(h) < v0)
            return false;
    return true;
}

GEO_Hedge
GEO_UncachedHedgeInterface::primaryImpl(GEO_Hedge h) const
{
    auto v0 = srcVertex(h);
    auto h0 = h;
    while (h = sym(h), h != h0)
        if (srcVertex(h) < v0)
            v0 = srcVertex(h);
    return GEO_Hedge(v0);
}

GA_Offset
GEO_UncachedHedgeInterface::polyNextImpl(GA_Offset v) const
{
    auto vtxs = myGdp->getPrimitiveVertexList(vertexPrimitive(v));
    auto k = vtxs.find(v);
    return vtxs((k + 1) % vtxs.size());
}

GA_Offset
GEO_UncachedHedgeInterface::polyPrevImpl(GA_Offset v) const
{
    auto vtxs = myGdp->getPrimitiveVertexList(vertexPrimitive(v));
    auto k = vtxs.find(v);
    auto n = vtxs.size();
    return vtxs((k + n - 1) % n);
}

GA_Offset
GEO_UncachedHedgeInterface::polyNextWithPrevImpl(GA_Offset v,
                                                 GA_Offset &vprev) const
{
    auto vtxs = myGdp->getPrimitiveVertexList(vertexPrimitive(v));
    auto k = vtxs.find(v);
    auto n = vtxs.size();
    vprev = vtxs((k + n - 1) % n);
    return vtxs((k + 1) % n);
}

GEO_Hedge
GEO_UncachedHedgeInterface::polyHedgeImpl(GA_Offset poly) const
{
    auto vtxs = myGdp->getPrimitiveVertexList(poly);
    if (vtxs.size() == 0 || !isOurPoly(poly))
        return GEO_INVALID_HEDGE;
    return GEO_Hedge(vtxs(0));
}



#endif