planners/obsolete/PL_SimplexSubdivision.h

Go to the documentation of this file.

//## begin module%39864C6600AA.cm preserve=no
//        %X% %Q% %Z% %W%
//## end module%39864C6600AA.cm

//## begin module%39864C6600AA.cp preserve=no
//## end module%39864C6600AA.cp

//## Module: PL_SimplexSubdivision%39864C6600AA; Pseudo Package specification
//## Source file: C:\project\mpk\code\Planners\PL_SimplexSubdivision.h

#ifndef PL_SimplexSubdivision_h
#define PL_SimplexSubdivision_h 1

//## begin module%39864C6600AA.additionalIncludes preserve=no
//## end module%39864C6600AA.additionalIncludes

//## begin module%39864C6600AA.includes preserve=yes
//## end module%39864C6600AA.includes

#include "Planners\PL_OpenGL.h"
#include "Planners\obsolete\PL_LinearCollision.h"
#include <set>

//## begin PL_SimplexSubdivision%39864C6600AA.preface preserve=yes
#pragma warning( disable : 4250 )
#pragma warning( disable : 4786 )
//## end PL_SimplexSubdivision%39864C6600AA.preface

//## Class: PL_SimplexSubdivision%39864C6600AA
//## Category: Planners%36FB140B003C
//## Persistence: Transient
//## Cardinality/Multiplicity: n
//=============================================================================
class PL_SimplexSubdivision 
: 
        public PL_LinearCollision, //## Inherits: <unnamed>%39864C740230
    public PL_OpenGL  //## Inherits: <unnamed>%39864C77032A
{
  //## begin PL_SimplexSubdivision%39864C6600AA.initialDeclarations preserve=yes
public:
        //=========================================================================
        enum CollisionType
        {
                CT_FREE,
                CT_COLLISION,
                CT_MIXED,
                CT_UNKNOWN
        };
        //=========================================================================
protected:
        //=========================================================================
        struct Node
        {
                //adds an adjacent node
                void AddNeighbor( const int node );

                //gets the center of the node
                Configuration Center() const;

                //is this configuration in this node?
                bool Contains( const Configuration& c ) const;

                //is this configuration in this node?
                bool ContainsCompletely( const Configuration& c ) const;

                //draws the node
                void DrawExplicit() const;

                //sets the color of this node
                void GlColor() const;

                //determines if the node is free of any colliding neighbors
                bool IsClean() const;

                //removes a neighbor
                void RemoveNeighbor( const int node );

                //returns the size of the node
                double Volume() const;

                bool m_Alive;
                double m_DistanceFromStart;
                Configuration m_Min;
                Configuration m_Max;
                std::vector< int > m_NodesAdjacent;
                std::vector< CollisionType > m_LinkType;
                Configuration m_LocationOfCollision;
        };
        //=========================================================================

  //## end PL_SimplexSubdivision%39864C6600AA.initialDeclarations

  public:
          //constructor
      PL_SimplexSubdivision();

      //destructor
      virtual ~PL_SimplexSubdivision();

      virtual bool DrawExplicit () const;

      virtual bool Plan ();

          //returns the volume of a node
          double Volume( const int i ) const;


  protected:

    //## Other Operations (specified)
      //## Operation: AddEdge%965103447
      void AddEdge( const int node0, const int node1 );

      //## Operation: AddNode%965103446
      int AddNode ( const Configuration& min, const Configuration& max );

          //adds a suspicious node to the set
          void AddSuspiciousNode( const int nodeNum );

          //adds a node to the open list - if it's not in the closed list already
          void AddToOpenList( const int nodeNum );

          //checks two nodes for collisions between them
          CollisionType CollisionCheck( const int n0, const int n1 );

          //deletes an already existing node
          void DeleteEdge( const int node0, const int node1 );

          //deletes an already existing node
          void DeleteNode( const int nodeNum );

          //connects the start and the goal to the tree
          void ConnectStartAndGoal();

          //test if two nodes are adjacent 
          bool IsAdjacent( int node0, int node1 );

          //searches for the goal until no nodes remain on the open list
          bool SearchForGoal();

          //subdivides the largest node on the list of suspicious nodes
          void SubdivideLargestNode();

      //## Operation: SubdivideSimplex%965161039
      void SubdivideNode( int nodeNum );

          //this is the vector of nodes
          std::vector< Node > m_Nodes;

          //these are the numbers for the start and goal nodes
          int m_NodeStart;
          int m_NodeGoal;

          std::set< int > m_OpenList;
          std::set< int > m_ClosedList;
          struct ComparisonFunction
          {
          public:
                  ComparisonFunction( const PL_SimplexSubdivision* planner );
                  ComparisonFunction( const ComparisonFunction& right );
                  bool operator()( const int a, const int b );
                  const PL_SimplexSubdivision* m_Planner;
          };
          ComparisonFunction m_Compare;
          typedef std::set< int, ComparisonFunction > INTSET;
          INTSET m_SuspiciousNodesAndVolumes;

      //## end PL_SimplexSubdivision%39864C6600AA.protected
  private:
    // Additional Private Declarations
      //## begin PL_SimplexSubdivision%39864C6600AA.private preserve=yes
      //## end PL_SimplexSubdivision%39864C6600AA.private

  private: //## implementation
    // Additional Implementation Declarations
      //## begin PL_SimplexSubdivision%39864C6600AA.implementation preserve=yes
      //## end PL_SimplexSubdivision%39864C6600AA.implementation

};

//## begin PL_SimplexSubdivision%39864C6600AA.postscript preserve=yes
//## end PL_SimplexSubdivision%39864C6600AA.postscript

// Class PL_SimplexSubdivision 

//## begin module%39864C6600AA.epilog preserve=yes
//## end module%39864C6600AA.epilog


#endif

---