GU_PathHedge.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:        GU_PathHedge.C
 *
 * COMMENTS:
 */


#ifndef __GU_PathHedge_h__
#define __GU_PathHedge_h__

#include "GU_API.h"
#include "GU_Detail.h"
#include <GEO/GEO_Hedge.h>
#include <GEO/GEO_Primitive.h>
#include <GA/GA_Edge.h>
#include <GA/GA_Types.h>

#include <UT/UT_Array.h>
#include <UT/UT_Assert.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_Function.h>
#include <UT/UT_Map.h>
#include <UT/UT_Vector3.h>

#include <SYS/SYS_Hash.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Types.h>

#include <stddef.h>

class GU_PathSHedge;
class GA_Primitive;
class GA_PrimitiveGroup;

class GU_API GU_PathHedge {
    public:
        GU_PathHedge(GA_Offset v0, GA_Offset v1)
            : myV0{v0},
              myV1{v1}
        {}

        GU_PathHedge() : myV0{GA_INVALID_OFFSET}, myV1{GA_INVALID_OFFSET} {}

        SYS_FORCE_INLINE GEO_Hedge hedge() const
        {
            return GEO_Hedge(myV0);
        }

        SYS_FORCE_INLINE GA_Offset v0() const
        {
            return myV0;
        }

        SYS_FORCE_INLINE GA_Offset v1() const
        {
            return myV1;
        }

        SYS_FORCE_INLINE bool isValid() const
        {
            return GAisValid(myV0) && GAisValid(myV1);
        }

        SYS_FORCE_INLINE bool operator==(const GU_PathHedge & other) const
        {
            return myV0 == other.myV0
                    && myV1 == other.myV1;
        }
        SYS_FORCE_INLINE bool operator!=(const GU_PathHedge & other) const
        {
            return !(*this == other);
        }

        SYS_FORCE_INLINE GU_PathHedge & set(GA_Offset new_v0, GA_Offset new_v1)
        {
            myV0 = new_v0;
            myV1 = new_v1;
            return *this;
        }

        SYS_FORCE_INLINE GU_PathHedge & reset()
        {
            myV0 = GA_INVALID_OFFSET;
            myV1 = GA_INVALID_OFFSET;
            return *this;
        }

        //The same hash that GA_Edge uses
        SYS_FORCE_INLINE size_t hash() const
        {
            size_t hash_val = GA_Size(myV0);
            SYShashCombine(hash_val, GA_Size(myV1));
            return hash_val;
        }
private:
    GA_Offset myV0;
    GA_Offset myV1;

public:
    class GU_API Interface
    {
    public:
        Interface(const GU_Detail & gdp,
            const GA_PrimitiveGroup * prim_group = nullptr,
            bool exclude_prims = true);

        //Get the first Hedge using this vertex
        void fromVertex(GU_PathHedge & out, GA_Offset vtx);

        //Get the next/prev hedge on this poly
        //These are the next or previous hedge on the polygon
        void lnext(GU_PathHedge & out, const GU_PathHedge & hedge);
        void lprev(GU_PathHedge & out, const GU_PathHedge & hedge);

        //Get the Hedge on this poly with the lowest vtx offset
        void primaryLNext(GU_PathHedge & out, const GU_PathHedge & hedge);

        //Go through all the equivalent hedges, hedges are equivalent if the end points
        //are equal
        void iterEquivalentHedges(
            GA_Offset p0, GA_Offset p1,
            const UT_Function<bool(const GU_PathHedge &)> & fn);

        void iterEquivalentHedges(
            const GU_PathHedge & hedge,
            const UT_Function<bool(const GU_PathHedge &)> & fn);

        //Return the first hedge found with the given end points.
        GU_PathHedge findHedgeWithEndpoints(GA_Offset p0, GA_Offset p1);

        //Get the next hedge that is equivalent.
        //The order is the order specified by iterEquivalentHedges
        GU_PathHedge nextEquivalentHedge(const GU_PathHedge & hedge);
        //alias for nextequivalenthedge
        GU_PathHedge sym(const GU_PathHedge & hedge)
        {
            return nextEquivalentHedge(hedge);
        }

        //find first equivalent hedge
        GU_PathHedge primary(const GU_PathHedge & e);
        GU_PathSHedge primary(const GU_PathSHedge & e);

        //Go through hedges incident with this point (one of points on hedge is pt)
        void iterIncidentHedges(GA_Offset pt,
                const UT_Function<bool(const GU_PathHedge &)> &fn);

        GU_PathHedge firstIncidentHedge(GA_Offset pt);

        //Similar to iterIncidentHedges but only considers each edge once
        void iterIncidentEdges(GA_Offset pt,
            const UT_Function<bool(const GU_PathHedge &)> & fn);

        GU_PathHedge firstIncidentEdge(GA_Offset pt)
        {
            return firstIncidentHedge(pt);
        }

        //Only goes through edges where dstPoint == pt
        void iterIncomingHedges(GA_Offset pt,
            const UT_Function<bool(const GU_PathHedge &)> & fn);

        GU_PathHedge firstIncomingHedge(GA_Offset pt);

        //Get the array of vertices that are reached by a hedge from vtx
        const GA_OffsetArray & getVtxNexts(GA_Offset vtx);

        //Get the array of vertices that can reach vtx by a hedge
        const GA_OffsetArray & getVtxPrevs(GA_Offset vtx);

        //Check if the vertices on hedge are valid
        SYS_FORCE_INLINE bool isValidHedge(const GU_PathHedge & hedge) const
        {
            return hedge.isValid();
        }

        //check if h1, h2 have the same end points
        SYS_FORCE_INLINE bool areEquivalent(const GU_PathHedge & h1,
                                            const GU_PathHedge & h2)
        {
            GA_Offset h1_p0 = srcPoint(h1);
            GA_Offset h1_p1 = dstPoint(h1);
            GA_Offset h2_p0 = srcPoint(h2);
            GA_Offset h2_p1 = dstPoint(h2);

            return (h1_p0 == h2_p0 && h1_p1 == h2_p1) ||
                    (h1_p0 == h2_p1 && h1_p1 == h2_p0);
        }

        //Signed Hedges are equivelent if they have the same primary
        bool areEquivalent(const GU_PathSHedge & sh1,
                                            const GU_PathSHedge & sh2);

        SYS_FORCE_INLINE GA_Offset srcVertex(const GU_PathHedge & h) const
        {
            return h.v0();
        }

        SYS_FORCE_INLINE GA_Offset dstVertex(const GU_PathHedge & h) const
        {
            return h.v1();
        }

        SYS_FORCE_INLINE GA_Offset srcPoint(const GU_PathHedge &h) const
        {
            return GAisValid(srcVertex(h)) ?
                        myGdp.vertexPoint(srcVertex(h)) : GA_INVALID_OFFSET;
        }

        SYS_FORCE_INLINE GA_Offset dstPoint(const GU_PathHedge &h) const
        {
            return GAisValid(dstVertex(h)) ?
                        myGdp.vertexPoint(dstVertex(h)) : GA_INVALID_OFFSET;
        }

        GA_Offset srcVertex(const GU_PathSHedge & sh) const;

        GA_Offset dstVertex(const GU_PathSHedge & sh) const;

        GA_Offset srcPoint(const GU_PathSHedge & sh) const;

        GA_Offset dstPoint(const GU_PathSHedge & sh) const;

        SYS_FORCE_INLINE GA_Offset hedgePrimitiveOffset(const GU_PathHedge &h) const
        {
            return GAisValid(srcVertex(h)) ? myGdp.vertexPrimitive(srcVertex(h)) :
                                             GA_INVALID_OFFSET;
        }

        SYS_FORCE_INLINE const GEO_Primitive * hedgePrimitive(const GU_PathHedge &h) const
        {
            if (!GAisValid(h.v0()))
                return nullptr;

            return static_cast<const GEO_Primitive *>(
                myGdp.getPrimitive(myGdp.vertexPrimitive(h.v0())));
        }

        //
        SYS_FORCE_INLINE bool isHedgeValidPolygon(const GU_PathHedge & h)
        {
            //By storing the vertices that are polygons in a bit array
            //We see a significant speed up as this allows fast use of
            //polygon specific caches. Using this way to text if polygon
            //We get a 20% speed up over converting to primitive then checking type

            exploreVtxPrim(h.v0());
            return GAisValid(h.v0()) && myPolyVtx.getBitFast(h.v0());
        }

        bool isHedgeValidPolygon(const GU_PathSHedge & hedge);

        SYS_FORCE_INLINE fpreal length(const GU_PathHedge & h) const
        {
            UT_ASSERT(isValidHedge(h));
            return isValidHedge(h) ? distance3d(myGdp.getPos3(srcPoint(h)),
                                    myGdp.getPos3(dstPoint(h))) : 0;
        }

        SYS_FORCE_INLINE const GU_Detail * getDetail() const
        { return &myGdp; }

        //Check if elements are on a geometry boundary
        bool isVtxBoundary(GA_Offset vtx);

        bool isPointBoundary(GA_Offset pt);

        bool isHedgeBoundary(const GU_PathHedge & hedge)
        {
            if (!isValidHedge(hedge))
                return false;

            return sym(hedge) == hedge;
        }

        //check if an element is on a quad poly
        bool isQuadVtx(GA_Offset vtx);

        bool isQuadPt(GA_Offset pt);

        bool isQuadHedge(const GU_PathHedge & hedge)
        {
            return isQuadVtx(hedge.v0());
        }

        //convert to GA_Edge
        SYS_FORCE_INLINE GA_Edge hedgeToEdge(const GU_PathHedge & hedge) const
        {
            UT_ASSERT(hedge.isValid());
            return GA_Edge(srcPoint(hedge), dstPoint(hedge));
        }

        void reset()
        {
            exint nvtx = myGdp.getNumVertexOffsets();

            myVtxNextArr.clear();
            myVtxPrevArr.clear();
            myVtxNextArr.setSize(nvtx);
            myVtxPrevArr.setSize(nvtx);
            myLPrevMap.clear();
            myLNextMap.clear();
            myQuadVtx.setAllBits(false);
            myPolyVtx.setAllBits(false);
            myPolySymCache.clear();
            myPolyPrimaryCache.clear();
            myPolySymCache.setSize(nvtx);
            myPolyPrimaryCache.setSize(nvtx);

            mySymCache.clear();
            myPrimaryCache.clear();
        }
    private:
         void exploreVtxPrim(GA_Offset vtx);

        //in here I think we should check for boundaries as well
        void explorePrim(GA_Offset pr);

        void iterAreas(
                const GA_Primitive *prim,
                const UT_Function<bool(const GA_OffsetArray & /*vtxs*/)> &fn);

        const GU_Detail & myGdp;
        const GA_PrimitiveGroup * myPrimGroup = nullptr;
        bool myExcludePrims = true;

        UT_Array<GA_OffsetArray> myVtxNextArr;
        UT_Array<GA_OffsetArray> myVtxPrevArr;

        UT_BitArray myPolyVtx;
        UT_Array<GU_PathHedge> myPolySymCache;
        UT_Array<GU_PathHedge> myPolyPrimaryCache;
        //This is for anything that is not a polygon primitive
        //It is a bit slower however
        UT_BitArray myQuadVtx;

        //Caches, offer some speed up
        UT_Map<GU_PathHedge, GA_Offset> myLPrevMap, myLNextMap;
        UT_Map<GU_PathHedge, GU_PathHedge> mySymCache;
        UT_Map<GU_PathHedge, GU_PathHedge> myPrimaryCache;
    };
};

//To allow using in a set, or map
SYS_FORCE_INLINE size_t
hash_value(const GU_PathHedge & hedge)
{
    return hedge.hash();
}

namespace std {
    template <>
    struct hash<GU_PathHedge>
    {
        size_t operator()(const GU_PathHedge & hedge) const
        {
            return hedge.hash();
        }
    };
}

//A signed version of the hedge
class GU_API GU_PathSHedge {
public:
    GU_PathSHedge() {}

    GU_PathSHedge(const GU_PathHedge & hedge, int sign = 1)
        : myHedge{hedge}, mySign{sign} {}

    SYS_FORCE_INLINE bool isValid() const
    { return myHedge.isValid(); }

    SYS_FORCE_INLINE const GU_PathHedge & hedge() const
    { return myHedge; }

    SYS_FORCE_INLINE GEO_SHedge shedge() const
    {
        return GEO_SHedge(myHedge.hedge(), sign());
    }

    SYS_FORCE_INLINE int sign() const
    { return mySign; }

    SYS_FORCE_INLINE bool isPositive() const
    { return mySign >= 0; }

    SYS_FORCE_INLINE bool isNegative() const
    { return !isPositive(); }

    SYS_FORCE_INLINE bool isEqual(const GU_PathSHedge & other, bool has_sign = true) const
    {
        return myHedge == other.myHedge &&
                 (!has_sign || mySign == other.mySign);
    }

    SYS_FORCE_INLINE bool operator==(const GU_PathSHedge & other) const
    { return isEqual(other); }

    SYS_FORCE_INLINE bool operator!=(const GU_PathSHedge & other) const
    { return !(*this == other); }

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

private:
        GU_PathHedge myHedge;
        int mySign = 1;
};
#endif