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 <UT/UT_IntArray.h>

class GB_Edge;
class GB_BaseGroup;
class GB_PointGroup;
class GB_EdgeGroup;
class GB_PrimitiveGroup;
class GB_VertexGroup;
class GB_BreakpointGroup;
class GB_PointRefArray;
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 GB_Edge *edge, 
                                            GB_PrimitiveGroup *edgeprimsgrp,
                                            GB_PointRefArray &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,
                                            GB_PrimitiveGroup *edgeprimsgrp,
                                            GB_PointRefArray &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,
                                            GB_PointRefArray &prefarr);

    void                 findPrimsUsingPoint(const GEO_Point *pt,
                                             GB_PrimitiveGroup *primgrp,
                                             GB_PointRefArray &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,
                                             GB_PointRefArray &prefarr,
                                             unsigned int primmask=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, 
                                           GB_PointRefArray &prefarr);

    GB_PrimitiveGroup   *getPrimitiveClosure(const GB_EdgeGroup &edgegroup, 
                                             GEO_PointRefArray *&prefarr);
    GB_PrimitiveGroup   *getEdgePointClosure(const GEO_PointRefArray &prefarr, 
                                             const GB_Edge &edge,
                                             GB_PrimitiveGroup *primgrp = 0);

    // If the group is not given, all the prims of type mask are returned
    // in the primitive group.
    GB_PrimitiveGroup   *getPrimitiveClosure(const GB_BreakpointGroup *grp = 0,
                                             unsigned int mask = GEOSPLINE);

    // Point closures
    GB_PointGroup       *getPointClosure(const GB_BaseGroup &group);
    GB_PointGroup       *getPointClosure(const GB_PointGroup &ptgroup);
    GB_PointGroup       *getPointClosure(const GB_EdgeGroup &edgegroup);
    GB_PointGroup       *getPointClosure(const GB_PrimitiveGroup &primgroup);
    GB_PointGroup       *getPointClosure(const GB_VertexGroup &vtxgroup);

    // Vertex closures
    GB_VertexGroup      *getVertexClosure(const GB_BaseGroup &group);
    GB_VertexGroup      *getVertexClosure(const GB_PointGroup &ptgroup);
    GB_VertexGroup      *getVertexClosure(const GB_EdgeGroup &edgegroup);
    GB_VertexGroup      *getVertexClosure(const GB_PrimitiveGroup &primgroup);
    GB_VertexGroup      *getVertexClosure(const GB_VertexGroup &vtxgroup);

    // Primitive closures
    GB_PrimitiveGroup   *getPrimitiveClosure(const GB_BaseGroup &group);
    GB_PrimitiveGroup   *getPrimitiveClosure(const GB_PointGroup &ptgroup);
    GB_PrimitiveGroup   *getPrimitiveClosure(
                                            const GB_PrimitiveGroup &primgroup);
    GB_PrimitiveGroup   *getPrimitiveClosure(const GB_VertexGroup &vtxgroup);

private:
    GEO_Detail                      &myGdp;
};
#endif

---