GEO/GEO_PointConnector.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 (C++)
 *
 * COMMENTS:  This class builds a useful structure for determining the 
 *            connectivity of points.
 *             
 */

#ifndef __GEO_PointConnector_h__
#define __GEO_PointConnector_h__

#include "GEO_API.h"
#include <UT/UT_BitArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_RefArray.h>
#include <GB/GB_Group.h>
#include "GEO_Detail.h"
#include "GEO_PointRef.h"


typedef UT_PtrArray<GEO_Point *>        geo_PointArray;
typedef UT_PtrArray<GEO_Primitive *>    geo_PrimArray;


class GEO_API GEO_PointConnector
{
public:
    GEO_PointConnector(GEO_Detail &gdp, GEO_PointRefArray *ptrefarray = 0);
    GEO_PointConnector(GEO_Detail &gdp, const GB_PointGroup &ptgrp, 
                       bool collapse=false, GEO_PointRefArray *ptrefarray = 0);
    ~GEO_PointConnector();


    int                          getTreeCount() const 
                                 { return (int)myForest.entries(); }

    // points(i) returns the points list of tree i
    const geo_PointArray        &points(int i) const 
                                 { return myForest((unsigned)i).myPoints; }

    // connectedPoints(i) returns the connected points of tree i
    const geo_PointArray        &connectedPoints(int i) const
                                 { return myForest((unsigned)i).myConnectedPoints; }

    const geo_PrimArray         &connectedPrims(int i) const
                                 { return myForest((unsigned)i).myConnectedPrims; }

    // Clears the connections built
    void                         clear();

    // Returns the index of the tree with pt in it.
    int                          buildPointConnections(GEO_Point &pt,
                                                       bool collapse = false);
    // Returns the index of the last tree built.
    int                          buildPointConnections(
                                                  const GB_PointGroup &ptgroup, 
                                                  bool collapse = false);


    // These methods look for the point or primitive in the connected list
    // (the point one doesn't even look in the "points" list, so everything
    // should be collapsed.  This is so to avoid having to wonder which list
    // our point is in, and is in most cases the desired behaviour.  Returns
    // -1 if point or prim doesn't exist in what we've built.

    // The parameters to these functions are not const because UT_PtrArray's
    // find method doesn't take a const
    int                          getPointTree(GEO_Point &pt);
    int                          getPrimTree(GEO_Primitive &prim);

    // Returns true if both points are connected to one another, and
    // false otherwise
    bool                         arePointsConnected(GEO_Point &pt0,
                                                    GEO_Point &pt1);



    // This method is only public because a callback function needs to call it,
    int                          addPoint(GEO_Point *pt);
private:
        
    // geo_PointConnectivity class represents two lists of points, one that
    // contains the connected points that we were in our original point group
    // (those points whose connectivity we want to establish), and the other
    // contains all the points connected to them. 

    // When the methods that build these guys have collapse set to true,
    // myPoints will be empty and all the points will be added to 
    // myConnectedPoints
    class GEO_API geo_PointConnectivity
    {
    public:
#ifdef INTEL_COMPILER
        geo_PointConnectivity() { }
#endif
        geo_PointArray  myPoints;               // Points we know about
        geo_PointArray  myConnectedPoints;      // Points connected to them
        geo_PrimArray   myConnectedPrims;       // Primitives in the closure
        private:
#ifdef INTEL_COMPILER           
        geo_PointConnectivity(const geo_PointConnectivity& ) { }
#endif
    };


    void                 buildConnections(const GB_PointGroup &ptgrp, 
                                          bool collapse = false);


    // Members:
    GEO_Detail          &myGdp;
    const GB_PointGroup *mySourcePtGroup;
    GEO_PointRefArray   *myPointRefArray;
    bool                 myOwnRefArray;   // do we own the point ref array
    UT_BitArray          myVisitedPoints; // bits of "used" source points
    UT_BitArray          myAddedPrims;    // Tracks which prims are added.
    int                  myCurrentTree;   // keeps track of the tree we're 
                                          // working on

    bool                 myCollapse;      // Are we collapsing the structure

    // The forest contains the lists of connected points (trees)
    UT_RefArray<geo_PointConnectivity>   myForest;
};
#endif

---