include/gdb/vtxMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: vtxMgr.h,v $ $Revision: 1.11 $ $State: Exp $
*********************************************************************/

#ifndef vtxMgr_H_
#define vtxMgr_H_

#include "gdb/gdbDefines.h"
#include "geometry/point.h"
#include <vector>

typedef int DtVertexID;

#define DEFAULT_VERT_MGR_EXPANSION_AMOUNT 50000

//
// class DtVertexManager:
//
// DtVertexManager represents a general vertex list. It is used in 
// DtPolygonIndirect and in various types of Features.
//
class DT_DLL_gdb DtVertexManager
{
public:

   // default constructor
   DtVertexManager();

   // additional constructor
   DtVertexManager(unsigned int size);

   // destructor
   virtual ~DtVertexManager();

   // copy constructor
   DtVertexManager(const DtVertexManager& orig);

   // assignment operator
   DtVertexManager& operator=(const DtVertexManager& orig);

   // If the vertex associated with the specified vertex ID is managed by
   // the vertex manager, returns true and sets retVal to be a reference to 
   // the associated vertex.  Otherwise, returns false.
   virtual bool vertex(DtVertexID vertID, DtVertex& vertex) const;

   // Provided for performance reasons.  
   // ASSUMES that the ID provided is valid.
   virtual DtVertex& vertex(DtVertexID vertID);
   virtual const DtVertex& vertex(DtVertexID vertID) const;

   // add vertex v to the DtVertexManager object.
   // If allowDuplicate is true, then the vertex manager will add the 
   // vertex even if it is could be considered a duplicate of an existing 
   // managed vertex.  vertID will be set to a new vertex ID associated with 
   // the newly added vertex.  
   // If the manager does not allow duplicates (see allowDuplicates below), 
   // vertID will be set to the ID of the first vertex it finds that is within 
   // tolerance of being equal to it. 
   // If it doesn't find an approximately equal vertex, it adds it as a 
   // new vertex and sets vertID to the associated ID.
   // If it fails to add the vertex due to lack of memory, it throws a 
   // std::bad_alloc exception. If for some other reason, it cannot add the 
   // vertex at all, it returns false and leaves vertID untouched.
   // \throws std:bad_alloc
   virtual bool addVertex(const DtVertex& vertex, 
                          DtVertexID& vertID, 
                          const double tolerance = 0.0000);

   // Analyzes the managed vertices and removes multiple instances of 
   // the same vertex where the same is defined by the fitness function.
   // All duplicate vertices will be collapsed and mapped to one vert ID.
   // If the manager cannot remove the duplicates for any reason, it returns 
   // false.
   // Otherwise, it removes the duplicates and sets oldIDToNewIDMapping[OldID]
   // to be a the new vertex ID that is associated with the original ID's vertex.
   // This function guarantees that all original IDs will be valid indices into
   // the oldIDToNewIDMapping.  The user is responsible for deleting the memory
   // allocated by this function for oldIDToNewIDMapping. (use delete[]).
   virtual bool removeDuplicates(double tolerance,
                                 int& numDuplicates,
                                 int& numEntries, 
                                 DtVertexID*& oldIDToNewIDMapping);

   // Returns the number of vertices currently managed by the manager.
   virtual unsigned int numberOfVertices() const;

   // Determines if a given vertex ID is valid.  Returns true if the
   // ID maps to a managed vertex and false if it doesn't.
   virtual bool isValidID(DtVertexID vertID) const;

   virtual bool assignFrom(const DtVertex* vertices, int numVertices);

   // debugging aid
   virtual void dump(int indexLevel) const;

   // If numVertices is greater than the current number of vertices managed,
   // the the vertex manager increases its storage to be able to handle the
   // specified number of vertices.  This is useful when a large number of 
   // vertices will be given to the manager as it will reduce the number
   // of memory operations the manager needs to use to grow to accommodate
   // the new vertices as well as reduces the likelihood that the system will
   // run out of memory.
   // Returns true if the operation was a success or if the number specified
   // is smaller than the amount already capable of being managed. Returns false
   // otherwise. However, if the manager cannot be expanded due to lack of memory, 
   // it throws a std::bad_alloc exception. 
   // \throws std::bad_alloc   
   virtual bool expandToManage(unsigned int numVertices = DEFAULT_VERT_MGR_EXPANSION_AMOUNT);

   // Returns the size (in bytes) of this object
   virtual int sizeInBytes();

   // This const accessor allows direct access to the vertex array. In practice,
   // only the vertex() accessor should be used to get vertices from the array.
   // This access is currently only used by DtOpcodeGdbInterfaceImpl to provide
   // the Opcode mesh interface with direct, read access to the array.
   virtual const DtVertex* getVertexArray();

   // Returns the lowest and highest points (in the Z coordinate) stored in the manager
   virtual bool extremePoints(DtVertex& highest, DtVertex& lowest) const;

   // Sets/gets whether the manager should allow duplicate vertices when being
   // added.
   virtual void setAllowDuplicates(bool flag);
   virtual bool allowDuplicates() const;

protected:
   // tests the invariants of the class.  
   // Should be called first in every const public member 
   // function and both first and last in every other function
   virtual bool testInvariant() const;

   // Adds the vertex to the vertex manager and sets vertID to be the 
   // associated vertex ID.  If it fails to add the vertex due to lack of memory,
   // it throws std::bad_alloc exception. If it fails to add the vertex due to any
   // other issue - it returns false.
   // \throws std:bad_alloc
   bool addNewVertex(const DtVertex& vertexToAdd, DtVertexID& vertID);

   // Looks for a duplicate vertex in the group of managed vertices.
   // If it finds one, it returns true and sets managedVertID to the
   // associated vertex ID.  If not, it returns false and leaves managedVertID
   // alone.
   // Does NOT sort - performance for large numbers of surfaces may be
   // very slow.  (O(n^2))
   bool isDuplicate(const DtVertex& vertex, 
                    DtVertexID& managedVertID, 
                    const double tol) const;

   // Checks to see if the vertex associated with the specified  
   // ID is a duplicate of a vertex stored BEFORE the specified ID in 
   // the manager.  If one is found, the function returns true and 
   // sets managedVertID to the associated vertex ID.  If the comparisonID 
   // is not a valid ID, or if no duplicate is found BEFORE the specified ID,
   // it returns false and leaves managedVertID alone.
   // Does NOT sort - performance for large numbers of surfaces may be
   // very slow.  (O(n^2))
   bool isDuplicate(const DtVertexID& comparisonVertID, 
                    DtVertexID& managedVertID, 
                    const double tol) const;

   // If the vertex manager is not managing any vertices, then 
   // expand to a default amount.  If it is managing vertices,
   // then expand by the specified amount.  Maintains the order of the
   // vertices managed.
   // \throws std::bad_alloc if there is not enough memory to expand the array
   virtual bool expandVertexArray(unsigned int numToExpandBy);

   unsigned int myNumberOfVertices;
   unsigned int myMaxNumberOfVertices;

   // Vector of vertices.
   std::vector<DtVertex> myVertexArray;

   // Memory-management flag for vertex array
   bool myArrayIsMemoryManaged;
  
   bool myManagerAllowsDuplicates;
};

inline unsigned int DtVertexManager::numberOfVertices() const
{
   return myNumberOfVertices;
}

#endif