Copies of graphs supporting edge splitting. More...

#include <ogdf/basic/GraphCopy.h>

Inheritance diagram for ogdf::GraphCopy:

Public Member Functions
	GraphCopy (const Graph &G)
	Creates a graph copy of G.
	GraphCopy ()
	Default constructor (does nothing!).
	GraphCopy (const GraphCopy &GC)
	Copy constructor.
virtual	~GraphCopy ()
Mapping between original graph and copy

const Graph &	original () const
	Returns a reference to the original graph.
node	original (node v) const
	Returns the node in the original graph corresponding to v.
edge	original (edge e) const
	Returns the edge in the original graph corresponding to e.
node	copy (node v) const
	Returns the node in the graph copy corresponding to v.
const List< edge > &	chain (edge e) const
	Returns the list of edges coresponding to edge e.
edge	copy (edge e) const
	Returns the first edge in the list of edges coresponding to edge e.
bool	isDummy (node v) const
	Returns true iff v has no corresponding node in the original graph.
bool	isDummy (edge e) const
	Returns true iff e has no corresponding edge in the original graph.
bool	isReversed (edge e) const
	Returns true iff edge e has been reversed.
Creation and deletion of nodes and edges

node	newNode ()
	Creates a new node in the graph copy.
node	newNode (node vOrig)
	Creates a new node in the graph copy with original node vOrig.
void	delCopy (node v)
	Removes node v and all its adjacent edges cleaning-up their corresponding lists of original edges.
void	delCopy (edge e)
	Removes edge e and clears the list of edges corresponding to e's original edge.
virtual edge	split (edge e)
	Splits edge e.
void	unsplit (edge eIn, edge eOut)
	Undoes a previous split operation. The two edges eIn and eOut are merged to a single edge eIn.
edge	newEdge (edge eOrig)
	Creates a new edge (v,w) with original edge eOrig.
edge	newEdge (edge eOrig, adjEntry adjSrc, node w)
	Creates a new edge with original edge eOrig at predefined positions in the adjacency lists.
edge	newEdge (edge eOrig, node v, adjEntry adjTgt)
	Creates a new edge with original edge eOrig at predefined positions in the adjacency lists.
edge	newEdge (node v, node w)
	Creates a new edge (v,w) and returns it.
edge	newEdge (adjEntry adjSrc, adjEntry adjTgt)
edge	newEdge (node v, adjEntry adjTgt)
	Creates a new edge at predefined positions in the adjacency lists.
edge	newEdge (adjEntry adjSrc, node w)
	Creates a new edge at predefined positions in the adjacency lists.
void	setEdge (edge eOrig, edge eCopy)
	sets eOrig to be the corresponding original edge of eCopy and vice versa
void	insertEdgePath (edge eOrig, const SList< adjEntry > &crossedEdges)
	Re-inserts edge eOrig by "crossing" the edges in crossedEdges.
void	insertEdgePath (node srcOrig, node tgtOrig, const SList< adjEntry > &crossedEdges)
void	removeEdgePath (edge eOrig)
	Removes the complete edge path for edge eOrig.
edge	insertCrossing (edge &crossingEdge, edge crossedEdge, bool topDown)
	Inserts crossings between already existing edges (used in TopologyModule).
Combinatorial Embeddings

edge	newEdge (node v, adjEntry adj, edge eOrig, CombinatorialEmbedding &E)
	Creates a new edge with original edge eOrig in an embedding E.
void	setOriginalEmbedding ()
	Sets the embedding of the graph copy to the embedding of the original graph.
void	insertEdgePathEmbedded (edge eOrig, CombinatorialEmbedding &E, const SList< adjEntry > &crossedEdges)
	Re-inserts edge eOrig by "crossing" the edges in crossedEdges in embedding E.
void	removeEdgePathEmbedded (CombinatorialEmbedding &E, edge eOrig, FaceSetPure &newFaces)
Miscellaneous

bool	consistencyCheck () const
	Checks the consistency of the data structure (for debugging only).
void	createEmpty (const Graph &G)
	Associates the graph copy with G, but does not create any nodes or edges.
void	initByNodes (const List< node > &nodes, EdgeArray< edge > &eCopy)
	Initializes the graph copy for the nodes in a component.
void	initByActiveNodes (const List< node > &nodes, const NodeArray< bool > &activeNodes, EdgeArray< edge > &eCopy)
	Initializes the graph copy for the nodes in nodes.
Operators

GraphCopy &	operator= (const GraphCopy &GC)
	Assignment operator.
Protected Attributes
const Graph *	m_pGraph
	The original graph.
NodeArray< node >	m_vOrig
	The corresponding node in the original graph.
EdgeArray< edge >	m_eOrig
	The corresponding edge in the original graph.
EdgeArray< ListIterator< edge > >	m_eIterator
	The position of copy edge in the list.
NodeArray< node >	m_vCopy
	The corresponding node in the graph copy.
EdgeArray< List< edge > >	m_eCopy
	The corresponding list of edges in the graph copy.
Private Member Functions
void	initGC (const GraphCopy &GC, NodeArray< node > &vCopy, EdgeArray< edge > &eCopy)

Detailed Description

Copies of graphs supporting edge splitting.

The class GraphCopy represents a copy of a graph and maintains a mapping between the nodes and edges of the original graph to the copy and vice versa.

New nodes and edges can be added to the copy; the counterpart of those nodes and edges is 0 indicating that there is no counterpart. GraphCopy also support splitting of edges in such a way that both edges resulting from the split are mapped to the same original edge, and each edge of the original graph is mapped to a list of edges. Furthermore, it is allowed to reverse edges in the graph copy.

Do's and Dont's

Here is a short summary, what can be done with GraphCopy, and what should not be done. The following operations are safely supported:

Splitting of edges such that an original edge is represented by a path in the copy (split(), unsplit()).
Reversing edges in the copy (Graph::reverseEdge(), Graph::reverseAllEdges()).
Reinsertion of original edges such that they are represented by a path in the copy (insertEdgePath(), insertEdgePathEmbedded(), removeEdgePath(), removeEdgePathEmbedded()).
Inserting and removing dummy edges in the copy which are not associated with edges in the original graph.

The following operations are not supported and are thus dangerous:

Any modifications on the original graph, since the copy will not be notified.
Moving the source or target node of an edge in the copy to a different node.
Removing edges in the graph copy that belong to a path representing an original edge.
... (better think first!)

Definition at line 235 of file GraphCopy.h.

Constructor & Destructor Documentation

ogdf::GraphCopy::GraphCopy ( const Graph & G )

Creates a graph copy of G.

The constructor assures that the adjacency lists of nodes in the constructed copy are in the same order as the adjacency lists in G. This is in particular important when dealing with embedded graphs.

ogdf::GraphCopy::GraphCopy ( ) [inline]

Default constructor (does nothing!).

Definition at line 256 of file GraphCopy.h.

ogdf::GraphCopy::GraphCopy ( const GraphCopy & GC )

Copy constructor.

Creates a graph copy that is a copy of GC and represents a graph copy of the original graph of GC.

virtual ogdf::GraphCopy::~GraphCopy ( ) [inline, virtual]

Definition at line 265 of file GraphCopy.h.

Member Function Documentation

const List<edge>& ogdf::GraphCopy::chain ( edge e ) const [inline]

Returns the list of edges coresponding to edge e.

Parameters:

e

is an edge in the original graph.

Returns:: the corresponding list of edges in the graph copy.

Definition at line 304 of file GraphCopy.h.

bool ogdf::GraphCopy::consistencyCheck ( ) const

Checks the consistency of the data structure (for debugging only).

Reimplemented from ogdf::Graph.

node ogdf::GraphCopy::copy ( node v ) const [inline]

Returns the node in the graph copy corresponding to v.

Parameters:

v

is a node in the original graph.

Returns:: the corresponding node in the graph copy.

Definition at line 297 of file GraphCopy.h.

edge ogdf::GraphCopy::copy ( edge e ) const [inline]

Returns the first edge in the list of edges coresponding to edge e.

Parameters:

e

is an edge in the original graph.

Returns:: the first edge in the corresponding list of edges in the graph copy.

Definition at line 313 of file GraphCopy.h.

void ogdf::GraphCopy::createEmpty ( const Graph & G )

Associates the graph copy with G, but does not create any nodes or edges.

This method is used for a special creation of the graph copy. The graph copy needs to be constructed with the default constructor, gets associated with G using this method, and then is initialized using either initByNodes() or initByActiveNodes().

The following code snippet shows a typical application of this functionality:

   GraphCopy GC;
   GC.createEmpty(G);

   // compute connected components of G
   NodeArray<int> component(G);
   int numCC = connectedComponents(G,component);

   // intialize the array of lists of nodes contained in a CC
   Array<List<node> > nodesInCC(numCC);

   node v;
   forall_nodes(v,G)
       nodesInCC[component[v]].pushBack(v);

   EdgeArray<edge> auxCopy(G);
   Array<DPoint> boundingBox(numCC);

   for(int i = 0; i < numCC; ++i) {
     GC.initByNodes(nodesInCC[i],auxCopy);
     ...
   }

Parameters:

G

is the graph of which this graph copy shall be a copy.

void ogdf::GraphCopy::delCopy ( node v )

Removes node v and all its adjacent edges cleaning-up their corresponding lists of original edges.

Precondition:: The corresponding lists oforiginal edges contain each only one edge.

Parameters:

v

is a node in the graph copy.

void ogdf::GraphCopy::delCopy ( edge e )

Removes edge e and clears the list of edges corresponding to e's original edge.

Precondition:: The list of edges corresponding to e's original edge contains only e.

Parameters:

e

is an edge in the graph copy.

void ogdf::GraphCopy::initByActiveNodes	(	const List< node > &	nodes,
		const NodeArray< bool > &	activeNodes,
		EdgeArray< edge > &	eCopy
	)

Initializes the graph copy for the nodes in nodes.

Creates copies of all nodes in nodes and edges between two nodes which are both contained in nodes. Any nodes and edges allocated before are destroyed.

See also:: createEmpty()

Parameters:

	nodes	is the list of nodes in the original graph for which copies are created in the graph copy.
	activeNodes	must be true for every node in nodes, false otherwise.
	eCopy	is assigned the copy of each original edge.

void ogdf::GraphCopy::initByNodes	(	const List< node > &	nodes,
		EdgeArray< edge > &	eCopy
	)

Initializes the graph copy for the nodes in a component.

Creates copies of all nodes in nodes and their incident edges. Any nodes and edges allocated before are removed.

The order of entries in the adjacency lists is preserved, i.e., if the original graph is embedded, its embedding induces the embedding of the created copy.

It is important that nodes is the complete list of nodes in a connected component. If you wish to initialize the graph copy for an arbitrary set of nodes, use the method initByActiveNodes().

See also:: createEmpty() for an example.

Parameters:

	nodes	is the list of nodes in the original graph for which copies are created in the graph copy.
	eCopy	is assigned the copy of each original edge.

void ogdf::GraphCopy::initGC	(	const GraphCopy &	GC,
		NodeArray< node > &	vCopy,
		EdgeArray< edge > &	eCopy
	)			`[private]`

edge ogdf::GraphCopy::insertCrossing	(	edge &	crossingEdge,
		edge	crossedEdge,
		bool	topDown
	)

Inserts crossings between already existing edges (used in TopologyModule).

Replaces crossingEdge by first crossingEdge part and returns second.

Parameters:

topDown

describes the following: if the crossingEdge is running horizontally from left to right, is the crossedEdge direction top->down?

Reimplemented in ogdf::PlanRep.

void ogdf::GraphCopy::insertEdgePath	(	edge	eOrig,
		const SList< adjEntry > &	crossedEdges
	)

Re-inserts edge eOrig by "crossing" the edges in crossedEdges.

Let v and w be the copies of the source and target nodes of eOrig. Each edge in crossedEdges is split creating a sequence $u_1,\ldots,u_k$ of new nodes, and additional edges are inserted creating a path $v,u_1,\ldots,u_k,w$ .

Parameters:

	eOrig	is an edge in the original graph and becomes the original edge of all edges in the path $v,u_1,\ldots,u_k,w$ .
	crossedEdges	are edges in the graph copy.

Reimplemented in ogdf::PlanRep.

void ogdf::GraphCopy::insertEdgePath	(	node	srcOrig,
		node	tgtOrig,
		const SList< adjEntry > &	crossedEdges
	)

void ogdf::GraphCopy::insertEdgePathEmbedded	(	edge	eOrig,
		CombinatorialEmbedding &	E,
		const SList< adjEntry > &	crossedEdges
	)

Re-inserts edge eOrig by "crossing" the edges in crossedEdges in embedding E.

Let v and w be the copies of the source and target nodes of eOrig, and let $e_0,e_1,\ldots,e_k,e_{k+1}$ be the sequence of edges corresponding to the adjacency entries in crossedEdges. The first edge needs to be incident to v and the last to w; the edges $e_1,\ldots,e_k$ are each split creating a sequence $u_1,\ldots,u_k$ of new nodes, and additional edges are inserted creating a path $v,u_1,\ldots,u_k,w$ .

The following figure illustrates, which adjacency entries need to be in the list crossedEdges. It inserts an edge connecting v and w by passing through the faces $f_0,f_1,f_2$ ; in this case, the list crossedEdges must contain the adjacency entries $adj_0,\ldots,adj_3$ (in this order).

Parameters:

	eOrig	is an edge in the original graph and becomes the original edge of all edges in the path $v,u_1,\ldots,u_k,w$ .
	E	is an embedding of the graph copy.
	crossedEdges	are a list of adjacency entries in the graph copy.

Reimplemented in ogdf::ClusterPlanRep, and ogdf::PlanRep.

bool ogdf::GraphCopy::isDummy ( edge e ) const [inline]

Returns true iff e has no corresponding edge in the original graph.

Parameters:

e

is an edge in the graph copy.

Definition at line 325 of file GraphCopy.h.

bool ogdf::GraphCopy::isDummy ( node v ) const [inline]

Returns true iff v has no corresponding node in the original graph.

Parameters:

v

is a node in the graph copy.

Definition at line 319 of file GraphCopy.h.

bool ogdf::GraphCopy::isReversed ( edge e ) const [inline]

Returns true iff edge e has been reversed.

Parameters:

e

is an edge in the original graph.

Definition at line 331 of file GraphCopy.h.

edge ogdf::GraphCopy::newEdge ( edge eOrig )

Creates a new edge (v,w) with original edge eOrig.

edge ogdf::GraphCopy::newEdge	(	edge	eOrig,
		adjEntry	adjSrc,
		node	w
	)

Creates a new edge with original edge eOrig at predefined positions in the adjacency lists.

Let v be the node whose adjacency list contains adjSrc. Then, the created edge is (v,w).

Parameters:

	adjSrc	is the adjacency entry after which the new edge is inserted in the adjacency list of v.
	w	is the source node of the new edge; the edge is added at the end of the adjacency list of w.

Returns:: the created edge.

edge ogdf::GraphCopy::newEdge	(	node	v,
		node	w
	)			`[inline]`

Creates a new edge (v,w) and returns it.

Reimplemented from ogdf::Graph.

Definition at line 419 of file GraphCopy.h.

edge ogdf::GraphCopy::newEdge	(	adjEntry	adjSrc,
		adjEntry	adjTgt
	)			`[inline]`

Definition at line 420 of file GraphCopy.h.

edge ogdf::GraphCopy::newEdge	(	node	v,
		adjEntry	adjTgt
	)			`[inline]`

Creates a new edge at predefined positions in the adjacency lists.

Let w be the node whose adjacency list contains adjTgt. Then, the created edge is (v,w).

Parameters:

	v	is the source node of the new edge; the edge is added at the end of the adjacency list of v.
	adjTgt	is the adjacency entry after which the new edge is inserted in the adjacency list of w.

Reimplemented from ogdf::Graph.

Definition at line 421 of file GraphCopy.h.

edge ogdf::GraphCopy::newEdge	(	adjEntry	adjSrc,
		node	w
	)			`[inline]`

Creates a new edge at predefined positions in the adjacency lists.

Let v be the node whose adjacency list contains adjSrc. Then, the created edge is (v,w).

Parameters:

	adjSrc	is the adjacency entry after which the new edge is inserted in the adjacency list of v.
	w	is the source node of the new edge; the edge is added at the end of the adjacency list of w.

Reimplemented from ogdf::Graph.

Definition at line 422 of file GraphCopy.h.

edge ogdf::GraphCopy::newEdge	(	edge	eOrig,
		node	v,
		adjEntry	adjTgt
	)

Creates a new edge with original edge eOrig at predefined positions in the adjacency lists.

Let w be the node whose adjacency list contains adjTgt. Then, the created edge is (v,w).

Parameters:

	v	is the source node of the new edge; the edge is added at the end of the adjacency list of v.
	adjTgt	is the adjacency entry after which the new edge is inserted in the adjacency list of w.

Returns:: the created edge.

edge ogdf::GraphCopy::newEdge	(	node	v,
		adjEntry	adj,
		edge	eOrig,
		CombinatorialEmbedding &	E
	)

Creates a new edge with original edge eOrig in an embedding E.

Let w be the node whose adjacency list contains adjTgt. The original edge eOrig must connect the original nodes of v and w. If eOrig = (original(v),original(w)), then the created edge is (v,w), otherwise it is (w,v). The new edge e must split a face in E, such that e comes after adj in the adjacency list of v and at the end of the adjacency list of v.

Parameters:

	v	is a node in the graph copy.
	adj	is an adjacency entry in the graph copy.
	eOrig	is an edge in the original graph.
	E	is an embedding of the graph copy.

Returns:: the created edge.

node ogdf::GraphCopy::newNode ( node vOrig ) [inline]

Creates a new node in the graph copy with original node vOrig.

Warning:: You have to make sure that the original node makes sense, in particular that vOrig is not the original node of another node in the copy.

Definition at line 351 of file GraphCopy.h.

node ogdf::GraphCopy::newNode ( ) [inline]

Creates a new node in the graph copy.

Reimplemented from ogdf::Graph.

Definition at line 342 of file GraphCopy.h.

GraphCopy& ogdf::GraphCopy::operator= ( const GraphCopy & GC )

Assignment operator.

Creates a graph copy that is a copy of GC and represents a graph copy of the original graph of GC.

The constructor assures that the adjacency lists of nodes in the constructed graph are in the same order as the adjacency lists in G. This is in particular important when dealing with embedded graphs.

const Graph& ogdf::GraphCopy::original ( ) const [inline]

Returns a reference to the original graph.

Definition at line 274 of file GraphCopy.h.

edge ogdf::GraphCopy::original ( edge e ) const [inline]

Returns the edge in the original graph corresponding to e.

Parameters:

e

is an edge in the graph copy.

Returns:: the corresponding edge in the original graph, or 0 if no such edge exists.

Definition at line 290 of file GraphCopy.h.

node ogdf::GraphCopy::original ( node v ) const [inline]

Returns the node in the original graph corresponding to v.

Parameters:

v

is a node in the graph copy.

Returns:: the corresponding node in the original graph, or 0 if no such node exists.

Definition at line 282 of file GraphCopy.h.

void ogdf::GraphCopy::removeEdgePath ( edge eOrig )

Removes the complete edge path for edge eOrig.

@param eOrig is an edge in the original graph.

void ogdf::GraphCopy::removeEdgePathEmbedded	(	CombinatorialEmbedding &	E,
		edge	eOrig,
		FaceSetPure &	newFaces
	)

Removes the complete edge path for edge eOrig while preserving the embedding.

Parameters:

	E	is an embedding of the graph copy.
	eOrig	is an edge in the original graph.
	newFaces	is assigned the set of new faces resulting from joining faces when removing edges.

Reimplemented in ogdf::PlanRep.

void ogdf::GraphCopy::setEdge	(	edge	eOrig,
		edge	eCopy
	)

sets eOrig to be the corresponding original edge of eCopy and vice versa

Parameters:

	eOrig	is the original edge
	eCopy	is the edge copy

void ogdf::GraphCopy::setOriginalEmbedding ( )

Sets the embedding of the graph copy to the embedding of the original graph.

Precondition:: The graph copy has not been changed after construction, i.e., no new nodes or edges have been added and no edges have been split.

virtual edge ogdf::GraphCopy::split ( edge e ) [virtual]

Splits edge e.

Parameters:

e

is an edge in the graph copy.

Reimplemented from ogdf::Graph.

Reimplemented in ogdf::ClusterPlanRep, ogdf::PlanRep, and ogdf::PlanRepUML.

void ogdf::GraphCopy::unsplit	(	edge	eIn,
		edge	eOut
	)			`[virtual]`

Undoes a previous split operation. The two edges eIn and eOut are merged to a single edge eIn.

Precondition:: The vertex u that was created by the previous split operation has exactly one incoming edge eIn and one outgoing edge eOut.

Parameters:

	eIn	is an edge (*,u) in the graph copy.
	eOut	is an edge (u,*) in the graph copy.

Reimplemented from ogdf::Graph.

Member Data Documentation

EdgeArray<List<edge> > ogdf::GraphCopy::m_eCopy [protected]

The corresponding list of edges in the graph copy.

Definition at line 244 of file GraphCopy.h.

EdgeArray<ListIterator<edge> > ogdf::GraphCopy::m_eIterator [protected]

The position of copy edge in the list.

Definition at line 241 of file GraphCopy.h.

EdgeArray<edge> ogdf::GraphCopy::m_eOrig [protected]

The corresponding edge in the original graph.

Definition at line 240 of file GraphCopy.h.

const Graph* ogdf::GraphCopy::m_pGraph [protected]

The original graph.

Definition at line 238 of file GraphCopy.h.

NodeArray<node> ogdf::GraphCopy::m_vCopy [protected]

The corresponding node in the graph copy.

Definition at line 243 of file GraphCopy.h.

NodeArray<node> ogdf::GraphCopy::m_vOrig [protected]

The corresponding node in the original graph.

Definition at line 239 of file GraphCopy.h.

The documentation for this class was generated from the following file:

ogdf/basic/GraphCopy.h

Open
Graph Drawing
Framework

ogdf::GraphCopy Class Reference

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Do's and Dont's

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

OpenGraph DrawingFramework

ogdf::GraphCopy Class Reference

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Do's and Dont's

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Open
Graph Drawing
Framework