loadedCliqueAbstraction Class Reference

A loaded abstraction based on the reduction of cliques. More...

#include <loadedCliqueAbstraction.h>

Inheritance diagram for loadedCliqueAbstraction:

[legend]Collaboration diagram for loadedCliqueAbstraction:

[legend]List of all members.


Public Member Functions
	loadedCliqueAbstraction (char *)
	Construct a new graph hierarchy.
virtual	~loadedCliqueAbstraction ()
virtual void	verifyHierarchy ()
	verify that the hierarchy is consistent
double	h (node a, node b)
	heuristic cost between any two nodes
bool	pathable (node from, node to)
	is there a legal path between these 2 nodes?
bool	pathable (unsigned int from, unsigned int to)
void	getParentHierarchy (node from, node to, std::vector< node * > &fromChain, std::vector< node * > &toChain)
	given 2 nodes, find as much of their hierarchy that exists in the graph
void	clearDisplayLists ()
void	openGLDraw ()
void	toggleDrawAbstraction (int which)
void	drawLevelConnections (node *n)
void	drawGraph (graph *g)
recVec	getNodeLoc (node *n)
virtual void	removeNode (node *n)
	remove node from abstraction
void	removeEdge (edge *e, unsigned int absLevel)
	remove edge from abstraction
virtual void	addNode (node *n)
	add node to abstraction
virtual void	addEdge (edge *e, unsigned int absLevel)
	add edge to abstraction
void	repairAbstraction ()
	This must be called after any of the above add/remove operations.
node *	findNodeParent (node *n)
edge *	findEdgeParent (edge *e, unsigned int absLevel)
Protected Member Functions
graph *	loadGraph (char *fname)
virtual graph *	abstractGraph (graph *g)
virtual graph *	cliqueAbstractGraph (graph *g)
virtual graph *	neighborAbstractGraph (graph *g, int width=1)
void	addNodesToParent (graph g, node n, node *parent, int width)
void	addTunnel (node n, graph g, node *newNode)
void	renameNodeInAbstraction (node *which, unsigned int oldID)
int	getChildGroups (node *which)
void	splitNode (node *which, int numGroups)
void	addNodeToRepairQ (node *n)
void	removeNodeFromRepairQ (node *n)
void	resetLocationCache (node *n)
void	checkAndCreateParent (node *which)
void	insertNodeIntoHierarchy (node *newNode)
void	transferGroup (int group, node oldParent, node newParent)
void	abstractUpEdge (unsigned int absLevel, edge *e)
void	extractGroupIntoNewNode (node *parent, int group)
void	mergeGroupIntoNeighbor (node parent, int group, node neighbor=0)
bool	checkNeighborClique (node child, node neighbor)
node *	findNeighborCliques (node *parent, int group)
node *	findNeighborCliques (node *)
int	getGroupSize (node *parent, int group)
node *	getNodeInGroup (node *parent, int group)
Private Member Functions
void	buildAbstractions (graph *)
void	cleanMemory ()
Private Attributes
unsigned long	levelDraw
std::vector< GLuint >	displayLists
std::vector< node * >	modifiedNodeQ

Detailed Description

A loaded abstraction based on the reduction of cliques.

Constructor & Destructor Documentation

loadedCliqueAbstraction::loadedCliqueAbstraction ( char * fname )

Construct a new graph hierarchy.
Constructions a new graph abstraction hierarchy from the graph using the designated abstraction method.

loadedCliqueAbstraction::~loadedCliqueAbstraction ( ) [virtual]

Member Function Documentation

graph * loadedCliqueAbstraction::abstractGraph ( graph * g ) [protected, virtual]

void loadedCliqueAbstraction::abstractUpEdge ( unsigned int absLevel,

edge * e

) [protected]

void loadedCliqueAbstraction::addEdge ( edge * e,

unsigned int absLevel

) [virtual]

add edge to abstraction

Implements graphAbstraction.

void loadedCliqueAbstraction::addNode ( node * n ) [virtual]

add node to abstraction

Implements graphAbstraction.

void loadedCliqueAbstraction::addNodesToParent ( graph * g,

node * n,

node * parent,

int width

) [protected]

void loadedCliqueAbstraction::addNodeToRepairQ ( node * n ) [protected]

void loadedCliqueAbstraction::addTunnel ( node * n,

graph * g,

node * newNode

) [protected]

void loadedCliqueAbstraction::buildAbstractions ( graph * ) [private]

void loadedCliqueAbstraction::checkAndCreateParent ( node * which ) [protected]

bool loadedCliqueAbstraction::checkNeighborClique ( node * child,

node * neighbor

) [protected]

void loadedCliqueAbstraction::cleanMemory ( ) [private]

void loadedCliqueAbstraction::clearDisplayLists ( )

graph * loadedCliqueAbstraction::cliqueAbstractGraph ( graph * g ) [protected, virtual]

void loadedCliqueAbstraction::drawGraph ( graph * g )

void loadedCliqueAbstraction::drawLevelConnections ( node * n )

void loadedCliqueAbstraction::extractGroupIntoNewNode ( node * parent,

int group

) [protected]

edge * loadedCliqueAbstraction::findEdgeParent ( edge * e,

unsigned int absLevel

)

node * loadedCliqueAbstraction::findNeighborCliques ( node * ) [protected]

node * loadedCliqueAbstraction::findNeighborCliques ( node * parent,

int group

) [protected]

node * loadedCliqueAbstraction::findNodeParent ( node * n )

int loadedCliqueAbstraction::getChildGroups ( node * which ) [protected]

int loadedCliqueAbstraction::getGroupSize ( node * parent,

int group

) [protected]

node * loadedCliqueAbstraction::getNodeInGroup ( node * parent,

int group

) [protected]

recVec loadedCliqueAbstraction::getNodeLoc ( node * n )

void loadedCliqueAbstraction::getParentHierarchy ( node * from,

node * to,

std::vector< node * > & fromChain,

std::vector< node * > & toChain

)

given 2 nodes, find as much of their hierarchy that exists in the graph

Reimplemented from graphAbstraction.

double loadedCliqueAbstraction::h ( node * a,

node * b

) [virtual]

heuristic cost between any two nodes

Implements graphAbstraction.

void loadedCliqueAbstraction::insertNodeIntoHierarchy ( node * newNode ) [protected]

graph * loadedCliqueAbstraction::loadGraph ( char * fname ) [protected]

void loadedCliqueAbstraction::mergeGroupIntoNeighbor ( node * parent,

int group,

node * neighbor = 0

) [protected]

graph * loadedCliqueAbstraction::neighborAbstractGraph ( graph * g,

int width = 1

) [protected, virtual]

void loadedCliqueAbstraction::openGLDraw ( )

bool loadedCliqueAbstraction::pathable ( unsigned int from,

unsigned int to

)

bool loadedCliqueAbstraction::pathable ( node * from,

node * to

) [virtual]

is there a legal path between these 2 nodes?

Implements graphAbstraction.

void loadedCliqueAbstraction::removeEdge ( edge * e,

unsigned int absLevel

) [virtual]

remove edge from abstraction

Implements graphAbstraction.

void loadedCliqueAbstraction::removeNode ( node * n ) [virtual]

remove node from abstraction

Implements graphAbstraction.

void loadedCliqueAbstraction::removeNodeFromRepairQ ( node * n ) [protected]

void loadedCliqueAbstraction::renameNodeInAbstraction ( node * which,

unsigned int oldID

) [protected]

void loadedCliqueAbstraction::repairAbstraction ( ) [virtual]

This must be called after any of the above add/remove operations.
But the operations can be stacked followed by a single repairAbstraction call.
Implements graphAbstraction.