GEO/GEO_Closure.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.
 *
 * Produced by:
 *      George ElKoura
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GEO Library.
 *
 * COMMENTS:    This file contains useful tools for finding closures.
 *
 */
#ifndef __GEO_Closure_h__
#define __GEO_Closure_h__

#include "GEO_API.h"
#include "GEO_PrimType.h"
#include "GEO_PrimTypeCompat.h"

#include <UT/UT_IntArray.h>

class GA_Edge;
class GA_Group;
class GA_PointGroup;
class GA_EdgeGroup;
class GA_PrimitiveGroup;
class GA_VertexGroup;
class GA_BreakpointGroup;
namespace GA_PrimCompat { class TypeMask; }
class GA_GBPointRefArray;
class GEO_Face;
class GEO_Detail;
class GEO_Point;
class GEO_PointRefArray;

class GEO_API GEO_Closure
{
public:
    GEO_Closure(GEO_Detail &gdp);
    ~GEO_Closure();

    /// Return all primitives using the given edge in edgeprimsgrp.
    void                 findPrimsUsingEdge(const GA_Edge *edge, 
                                            GA_PrimitiveGroup *edgeprimsgrp,
                                            GA_GBPointRefArray &prefarr);
    /// A non-group version which is faster.
    void                 findPrimsUsingEdge(const GA_Edge *edge, 
                                            UT_IntArray &primlist,
                                            GA_GBPointRefArray &prefarr);

    // A faster way to find the polygons using an edge.  findPrimsUsingEdge
    // is more general, but this one is faster.
    void                 findPolysUsingEdge(const GEO_Point &pt0,
                                            const GEO_Point &pt1,
                                            GA_PrimitiveGroup *edgeprimsgrp,
                                            GA_GBPointRefArray &prefarr);

    // The non-group version of findPolysUsingEdge, if you don't need a group,
    // this is faster than having to manage a group
    void                 findPolysUsingEdge(const GEO_Point &pt0,
                                            const GEO_Point &pt1,
                                            UT_IntArray &primlist,
                                            GA_GBPointRefArray &prefarr);

    void                 findPrimsUsingPoint(const GEO_Point *pt,
                                             GA_PrimitiveGroup *primgrp,
                                             GA_GBPointRefArray &prefarr);

    // The non-group version of findPrimsUsingPoint, if you don't need
    // group, this is faster than having to manage a group
    void                 findPrimsUsingPoint(const GEO_Point *pt,
                                             UT_IntArray &primlist,
                                             GA_GBPointRefArray &prefarr,
                                             const GA_PrimCompat::TypeMask
                                             &primmask=GEO_PrimTypeCompat::GEOPRIMALL);

    // Return 1 if the two faces share a point, and 0 otherwise.  Also return 
    // the indices of the vertices on the two faces in vtxidx0 (for face 0) and
    // vtxidx1 (for face 1).  Assumes both faces are open.
    static int           getSharedPoint(GEO_Face *face0, GEO_Face *face1, 
                                        int &vtxidx0, int &vtxidx1);

    // Assumes both faces are open and returns 1 if they share a common point,
    // and 0 otherwise.
    static int           haveSharedPoint(GEO_Face *face0, GEO_Face *face1);

    // Returns the number of unique edges shared by this point.
    int                  getNumSharedEdges(GEO_Point &pt, 
                                           GA_GBPointRefArray &prefarr);

    GA_PrimitiveGroup   *getPrimitiveClosure(const GA_EdgeGroup &edgegroup, 
                                             GEO_PointRefArray *&prefarr);
    GA_PrimitiveGroup   *getEdgePointClosure(const GEO_PointRefArray &prefarr, 
                                             const GA_Edge &edge,
                                             GA_PrimitiveGroup *primgrp = 0);

    // If the group is not given, all the prims of type mask are returned
    // in the primitive group.
    GA_PrimitiveGroup   *getPrimitiveClosure(const GA_BreakpointGroup *grp = 0,
                                             const GA_PrimCompat::TypeMask
                                             &mask=GEO_PrimTypeCompat::GEOSPLINE);

    // Point closures
    GA_PointGroup       *getPointClosure(const GA_Group &group);
    GA_PointGroup       *getPointClosure(const GA_PointGroup &ptgroup);
    GA_PointGroup       *getPointClosure(const GA_EdgeGroup &edgegroup);
    GA_PointGroup       *getPointClosure(const GA_PrimitiveGroup &primgroup);
    GA_PointGroup       *getPointClosure(const GA_VertexGroup &vtxgroup);

    // Vertex closures
    GA_VertexGroup      *getVertexClosure(const GA_Group &group);
    GA_VertexGroup      *getVertexClosure(const GA_PointGroup &ptgroup);
    GA_VertexGroup      *getVertexClosure(const GA_EdgeGroup &edgegroup);
    GA_VertexGroup      *getVertexClosure(const GA_PrimitiveGroup &primgroup);
    GA_VertexGroup      *getVertexClosure(const GA_VertexGroup &vtxgroup);

    // Primitive closures
    GA_PrimitiveGroup   *getPrimitiveClosure(const GA_Group &group);
    GA_PrimitiveGroup   *getPrimitiveClosure(const GA_PointGroup &ptgroup);
    GA_PrimitiveGroup   *getPrimitiveClosure(
                                            const GA_PrimitiveGroup &primgroup);
    GA_PrimitiveGroup   *getPrimitiveClosure(const GA_VertexGroup &vtxgroup);

private:
    GEO_Detail                      &myGdp;
};
#endif

---