Open
Graph Drawing
Framework

 v. 2022.02 (Dogwood)
 

PlanRep.h
Go to the documentation of this file.
1 
34 // PlanRep should not know about generalizations and association,
35 // but we already set types in Attributedgraph, therefore set them
36 // in PlanRep, too
37 
38 #pragma once
39 
40 #include <ogdf/basic/GraphCopy.h>
43 #include <ogdf/basic/Layout.h>
44 #include <ogdf/basic/GridLayout.h>
45 
46 
47 namespace ogdf {
48 
49 class OrthoRep;
50 
51 
53 
60 {
61 public:
64  {
65  Deg1RestoreInfo() : m_eOriginal(nullptr), m_deg1Original(nullptr), m_adjRef(nullptr) { }
66  Deg1RestoreInfo(edge eOrig, node deg1Orig, adjEntry adjRef)
67  : m_eOriginal(eOrig), m_deg1Original(deg1Orig), m_adjRef(adjRef) { }
68 
72  };
73 
74 
76  explicit PlanRep(const Graph& G);
78 
80  explicit PlanRep(const GraphAttributes& AG);
81 
82  virtual ~PlanRep() { }
83 
85 
92 
94  int numberOfCCs() const {
95  return m_ccInfo.numberOfCCs();
96  }
97 
99  int currentCC() const {
100  return m_currentCC;
101  }
102 
104  const CCsInfo &ccInfo() const { return m_ccInfo; }
105 
107  int numberOfNodesInCC() const { return numberOfNodesInCC(m_currentCC); }
108 
110  int numberOfNodesInCC(int cc) const {
111  return stopNode(cc) - startNode(cc);
112  }
113 
115  node v(int i) const { return m_ccInfo.v(i); }
116 
118  edge e(int i) const { return m_ccInfo.e(i); }
119 
121  int startNode() const { return m_ccInfo.startNode(m_currentCC); }
122 
124  int startNode(int cc) const { return m_ccInfo.startNode(cc); }
125 
127  int stopNode() const { return m_ccInfo.stopNode(m_currentCC); }
128 
130  int stopNode(int cc) const { return m_ccInfo.stopNode(cc); }
131 
133  int startEdge() const { return m_ccInfo.startEdge(m_currentCC); }
134 
136  int stopEdge() const { return m_ccInfo.stopEdge(m_currentCC); }
137 
139 
145  void initCC(int cc);
146 
148 
153 
160  return m_expandAdj[v];
161  }
162 
164  return m_expandAdj[v];
165  }
166 
168 
172 
178  return m_boundaryAdj[v];
179  }
180 
186  return m_boundaryAdj[v];
187  }
188 
189  //edge on the clique boundary, adjSource
191  setEdgeTypeOf(e, edgeTypeOf(e) | cliquePattern());
192  }
193  bool isCliqueBoundary(edge e) const {
194  return (edgeTypeOf(e) & cliquePattern()) == cliquePattern();
195  }
196 
197 
199 
203 
209  return m_vType[v];
210  }
211 
217  return m_vType[v];
218  }
219 
228  inline bool isVertex(node v) const
229  {
230  return typeOf(v) == Graph::NodeType::vertex
231  || typeOf(v) == Graph::NodeType::associationClass;
232  }
233 
239  {
240  return m_nodeTypes[v];
241  }
242 
248  {
250  }
251 
256  bool isCrossingType(node v) const
257  {
258  return (m_nodeTypes[v] & (UMLNodeTypeConstants::TerCrossing << UMLNodeTypeOffsets::Tertiary)) != 0;
259  }
260 
262 
266 
271  EdgeType typeOf(edge e) const {
272  return m_eType[e];
273  }
274 
279  EdgeType& typeOf(edge e) {
280  return m_eType[e];
281  }
282 
288  {
289  return m_oriEdgeTypes[e];
290  }
291 
297  {
298  return m_edgeTypes[e];
299  }
300 
306  {
307  return m_edgeTypes[e];
308  }
309 
316  {
317  m_edgeTypes[e] = et;
318  }
319 
328  void setType(edge e, EdgeType et)
329  {
330  m_eType[e] = et;
331  switch (et)
332  {
333  case Graph::EdgeType::association: m_edgeTypes[e] = static_cast<edgeType>(UMLEdgeTypeConstants::PrimAssociation);break;
335  break;
336  case Graph::EdgeType::dependency: m_edgeTypes[e] = static_cast<edgeType>(UMLEdgeTypeConstants::PrimDependency); break;
337  default: break;
338  }
339  }
340 
341  // new edge types
342  // to set or check edge types use the pattern function in the private section
343 
344  // primary level types
345 
347  bool isGeneralization(edge e) const {
349  return check;
350  }
351 
354  setPrimaryType(e, UMLEdgeTypeConstants::PrimGeneralization);
355 
356  //preliminary set old array too
357  m_eType[e] = EdgeType::generalization; //can be removed if edgetypes work properly
358  }
359 
361  bool isDependency(edge e) const {
363  return check;
364  }
365 
367  void setDependency(edge e) {
368  setPrimaryType(e, UMLEdgeTypeConstants::PrimDependency);
369 
370  //preliminary set old array too
371  m_eType[e] = EdgeType::dependency; //can be removed if edgetypes work properly
372  }
373 
376  setPrimaryType(e, UMLEdgeTypeConstants::PrimAssociation);
377 
378  //preliminary set old array too
379  m_eType[e] = EdgeType::association; //can be removed if edgetypes work properly
380  }
381 
382  //second level types
383 
384  //in contrast to setsecondarytype: do not delete old value
385 
387  void setExpansion(edge e) {
388  m_edgeTypes[e] |= expansionPattern();
389 
390  //preliminary set old array too
391  m_expansionEdge[e] = 1;//can be removed if edgetypes work properly
392  }
393 
395  bool isExpansion(edge e) const {
396  return (m_edgeTypes[e] & expansionPattern()) == expansionPattern();
397  }
398 
399  //should add things like cluster and clique boundaries that need rectangle shape
400 
402  bool isBoundary(edge e) const {
403  return isCliqueBoundary(e);
404  }
405 
406  //tertiary types
407 
410  {
411  m_edgeTypes[e] |= assClassPattern();
412  }
413 
415  bool isAssClass(edge e) const
416  {
417  return (m_edgeTypes[e] & assClassPattern()) == assClassPattern();
418  }
419 
420  //fourth level types
421 
423  void setBrother(edge e) {
424  m_edgeTypes[e] |= brotherPattern();
425  }
426 
429  m_edgeTypes[e] |= halfBrotherPattern();
430  }
431 
433  bool isBrother(edge e) const {
434  return ( (m_edgeTypes[e] & UMLEdgeTypePatterns::Fourth & brotherPattern()) >> UMLEdgeTypeOffsets::Fourth) == UMLEdgeTypeConstants::Brother;
435  }
436 
438  bool isHalfBrother(edge e) const {
439  return ( (m_edgeTypes[e] & UMLEdgeTypePatterns::Fourth & halfBrotherPattern()) >> UMLEdgeTypeOffsets::Fourth) == UMLEdgeTypeConstants::HalfBrother;
440  }
441 
442  //set generic types
443 
445  edgeType edgeTypeAND(edge e, edgeType et) {m_edgeTypes[e] &= et; return m_edgeTypes[e];}
446 
448  edgeType edgeTypeOR(edge e, edgeType et) {m_edgeTypes[e] |= et; return m_edgeTypes[e];}
449 
452  m_edgeTypes[e] &= 0xfffffff0;
453  m_edgeTypes[e] |= (UMLEdgeTypePatterns::Primary & et);
454  }
455 
458  setPrimaryType(e, static_cast<edgeType>(et));
459  }
460 
463  m_edgeTypes[e] &= 0xffffff0f;
464  m_edgeTypes[e] |= (UMLEdgeTypePatterns::Secondary & ( et << UMLEdgeTypeOffsets::Secondary));
465  }
466 
468  edgeType edgeTypePrimaryAND(edge e, edgeType et) {m_edgeTypes[e] &= (UMLEdgeTypePatterns::All & et); return m_edgeTypes[e];}
469 
471  edgeType edgeTypePrimaryOR(edge e, edgeType et) {m_edgeTypes[e] |= et; return m_edgeTypes[e];}
472 
475  {
476  OGDF_ASSERT( et < 147);
477  m_edgeTypes[e] |= (et << UMLEdgeTypeOffsets::User);
478  }
479 
481  bool isUserType(edge e, edgeType et) const
482  {
483  OGDF_ASSERT( et < 147);
484  return (m_edgeTypes[e] & (et << UMLEdgeTypeOffsets::User)) == (et << UMLEdgeTypeOffsets::User);
485  }
486 
487  // old edge types
488 
489  //this is pure nonsense, cause we have uml-edgetype and m_etype, and should be able to
490  //use them with different types, but as long as they arent used correctly (switch instead of xor),
491  //use this function to return if e is expansionedge
492  //if it is implemented correctly later, delete the array and return m_etype == Graph::expand
493  //(the whole function then is obsolete, cause you can check it directly, but for convenience...)
494  //should use genexpand, nodeexpand, dissect instead of bool
495 
497  void setExpansionEdge(edge e, int expType) {
498  m_expansionEdge[e] = expType;
499  }
500 
502  bool isExpansionEdge(edge e) const {
503  return m_expansionEdge[e] > 0;
504  }
505 
507  int expansionType(edge e) const { return m_expansionEdge[e]; }
508 
509  //precondition normalized
511  bool isDegreeExpansionEdge(edge e) const {
512 #if 0
513  return (m_eType[e] == Graph::expand);
514 #else
515  return m_expansionEdge[e] == 2;
516 #endif
517  }
518 
519 
521 
527 
528 
530  const NodeArray<double> &widthOrig() const {
531  OGDF_ASSERT(m_pGraphAttributes != nullptr);
532  return m_pGraphAttributes->width();
533  }
534 
536  double widthOrig(node v) const {
537  OGDF_ASSERT(m_pGraphAttributes != nullptr);
538  return m_pGraphAttributes->width(v);
539  }
540 
542  const NodeArray<double> &heightOrig() const {
543  OGDF_ASSERT(m_pGraphAttributes != nullptr);
544  return m_pGraphAttributes->height();
545  }
546 
548  double heightOrig(node v) const {
549  OGDF_ASSERT(m_pGraphAttributes != nullptr);
550  return m_pGraphAttributes->height(v);
551  }
552 
554  EdgeType typeOrig(edge e) const {
555  OGDF_ASSERT(m_pGraphAttributes != nullptr);
556  return m_pGraphAttributes->type(e);
557  }
558 
561  OGDF_ASSERT(m_pGraphAttributes != nullptr);
562  return *m_pGraphAttributes;
563  }
564 
566 
570 
571  // Expands nodes with degree > 4 and merge nodes for generalizations
572  virtual void expand(bool lowDegreeExpand = false);
573 
574  void expandLowDegreeVertices(OrthoRep &OR);
575 
576  void collapseVertices(const OrthoRep &OR, Layout &drawing);
577  void collapseVertices(const OrthoRep &OR, GridLayout &drawing);
578 
579  void removeCrossing(node v); //removes the crossing at node v
580 
581  //model a boundary around a star subgraph centered at center
582  //and keep external face information (outside the clique
583  void insertBoundary(node center, adjEntry& adjExternal);
584 
585 
587 
591 
593  virtual edge split(edge e) override;
594 
595 
596  //returns node which was expanded using v
597  node expandedNode(node v) const { return m_expandedNode[v]; }
598 
599  void setExpandedNode(node v, node w) { m_expandedNode[v] = w; }
600 
601 
603 
607 
613  node newCopy(node vOrig, Graph::NodeType vType);
614 
622  edge newCopy(node v, adjEntry adjAfter, edge eOrig);
623 
632  edge newCopy(node v, adjEntry adjAfter, edge eOrig, CombinatorialEmbedding &E);
633 
634 
636 
640 
642 
647  void insertEdgePath(edge eOrig, const SList<adjEntry> &crossedEdges);
648 
650  void insertEdgePathEmbedded(
651  edge eOrig,
653  const SList<adjEntry> &crossedEdges);
654 
656 
660  edge eOrig,
661  FaceSet<false> &newFaces) {
662  GraphCopy::removeEdgePathEmbedded(E,eOrig,newFaces);
663  }
664 
666 
680  edge insertCrossing(
681  edge &crossingEdge,
682  edge crossedEdge,
683  bool topDown);
684 
686 
691 
699  void removeDeg1Nodes(ArrayBuffer<Deg1RestoreInfo> &S, const NodeArray<bool> &mark);
700 
706  void restoreDeg1Nodes(ArrayBuffer<Deg1RestoreInfo> &S, List<node> &deg1s);
707 
709  void writeGML(const char *fileName, const OrthoRep &OR, const GridLayout &drawing);
710  void writeGML(std::ostream &os, const OrthoRep &OR, const GridLayout &drawing);
711 
712 protected:
713 
716  //int m_numCC; //!< The number of components in the original graph.
717 
718  //Array<List<node> > m_nodesInCC; //!< The list of original nodes in each component.
719 
721 
722  // object types
723 
724  //set the type of eCopy according to the type of eOrig
725  //should be virtual if PlanRepUML gets its own
726  void setCopyType(edge eCopy, edge eOrig);
727 
728  //helper to cope with the edge types, shifting to the right place
736 
738 
740 
743 
744  //clique handling: We save an adjEntry of the first edge of an inserted
745  //boundary around a clique at its center v
747 
748  //zusammenlegbare Typen
749  EdgeArray<int> m_expansionEdge; //1 genmerge, 2 degree (2 highdegree, 3 lowdegree)
751 
752  //m_edgeTypes stores semantic edge type information on several levels:
753  //primary type: generalization, association,...
754  //secondary type: merger,...
755  //tertiary type: vertical in hierarchy, inner, outer, ...
756  //fourth type: neighbour relation (brother, cousin in hierarchy)
757  //user types: user defined for local changes
758  EdgeArray<edgeType> m_edgeTypes; //store all type information
759 
760  //workaround fuer typsuche in insertedgepathembed
761  //speichere kopietyp auf originalen
762  //maybe it's enough to set gen/ass without extra array
764 
765  EdgeArray<edge> m_eAuxCopy; // auxiliary (GraphCopy::initByNodes())
766 };
767 
768 }
ogdf::ArrayBuffer
An array that keeps track of the number of inserted elements; also usable as an efficient stack.
Definition: Array.h:45
ogdf::PlanRep::isVertex
bool isVertex(node v) const
Returns true if the node represents a "real" object in the original graph.
Definition: PlanRep.h:228
ogdf::PlanRep::edgeTypeOf
edgeType edgeTypeOf(edge e) const
Returns the new type field of e.
Definition: PlanRep.h:296
ogdf
The namespace for all OGDF objects.
Definition: AugmentationModule.h:36
ogdf::GraphAttributes
Stores additional attributes of a graph (like layout information).
Definition: GraphAttributes.h:67
ogdf::PlanRep::halfBrotherPattern
edgeType halfBrotherPattern() const
Definition: PlanRep.h:734
ogdf::PlanRep::setSecondaryType
void setSecondaryType(edge e, edgeType et)
Sets secondary edge type of edge e to primary edge type in et.
Definition: PlanRep.h:462
ogdf::PlanRep::m_oriEdgeTypes
EdgeArray< edgeType > m_oriEdgeTypes
Definition: PlanRep.h:763
ogdf::Graph::NodeType::vertex
@ vertex
ogdf::PlanRep::assClassPattern
edgeType assClassPattern() const
Definition: PlanRep.h:732
ogdf::Graph::CCsInfo
Info structure for maintaining connected components.
Definition: Graph_d.h:1320
ogdf::PlanRep::isCliqueBoundary
bool isCliqueBoundary(edge e) const
Definition: PlanRep.h:193
ogdf::PlanRep::m_eType
EdgeArray< EdgeType > m_eType
Definition: PlanRep.h:750
ogdf::PlanRep
Planarized representations (of a connected component) of a graph.
Definition: PlanRep.h:59
Layout.h
Declaration of class Layout.
ogdf::PlanRep::setBrother
void setBrother(edge e)
Classifies edge e as connection between hierarchy neighbours (fourth level type).
Definition: PlanRep.h:423
OGDF_ASSERT
#define OGDF_ASSERT(expr)
Assert condition expr. See doc/build.md for more information.
Definition: basic.h:41
ogdf::PlanRep::setExpandedNode
void setExpandedNode(node v, node w)
Definition: PlanRep.h:599
ogdf::UMLEdgeTypeOffsets::Tertiary
@ Tertiary
ogdf::PlanRep::m_boundaryAdj
NodeArray< adjEntry > m_boundaryAdj
Definition: PlanRep.h:746
ogdf::Graph::NodeType::associationClass
@ associationClass
ogdf::UMLEdgeTypeOffsets::Secondary
@ Secondary
ogdf::PlanRep::edgeTypeAND
edgeType edgeTypeAND(edge e, edgeType et)
Sets type of edge e to current type (bitwise) AND et.
Definition: PlanRep.h:445
ogdf::PlanRep::expansionPattern
edgeType expansionPattern() const
Definition: PlanRep.h:731
ogdf::PlanRep::stopNode
int stopNode(int cc) const
Returns the index of (one past) the last node in connected component cc.
Definition: PlanRep.h:130
ogdf::PlanRep::stopEdge
int stopEdge() const
Returns the index of (one past) the last edge in this connected component.
Definition: PlanRep.h:136
ogdf::PlanRep::Deg1RestoreInfo::Deg1RestoreInfo
Deg1RestoreInfo()
Definition: PlanRep.h:65
ogdf::PlanRep::typeOf
EdgeType & typeOf(edge e)
Returns a reference to the type of edge e.
Definition: PlanRep.h:279
ogdf::UMLNodeTypeConstants::TerCrossing
@ TerCrossing
ogdf::PlanRep::~PlanRep
virtual ~PlanRep()
Definition: PlanRep.h:82
ogdf::PlanRep::m_vType
NodeArray< NodeType > m_vType
Simple node types.
Definition: PlanRep.h:737
ogdf::PlanRep::isHalfBrother
bool isHalfBrother(edge e) const
Returns true if edge e is classified as half-brother.
Definition: PlanRep.h:438
ogdf::PlanRep::brotherPattern
edgeType brotherPattern() const
Definition: PlanRep.h:733
ogdf::SList
Singly linked lists (maintaining the length of the list).
Definition: SList.h:773
ogdf::nodeType
long long nodeType
Definition: NodeTypePatterns.h:44
ogdf::PlanRep::widthOrig
double widthOrig(node v) const
Returns the width of original node v.
Definition: PlanRep.h:536
ogdf::edgeType
long long edgeType
Definition: EdgeTypePatterns.h:42
ogdf::PlanRep::expandAdj
adjEntry expandAdj(node v) const
Returns the adjacency entry of a node of an expanded face.
Definition: PlanRep.h:159
ogdf::GraphCopy
Copies of graphs supporting edge splitting.
Definition: GraphCopy.h:255
ogdf::PlanRep::setType
void setType(edge e, EdgeType et)
Set both type values of e at once.
Definition: PlanRep.h:328
ogdf::PlanRep::Deg1RestoreInfo::Deg1RestoreInfo
Deg1RestoreInfo(edge eOrig, node deg1Orig, adjEntry adjRef)
Definition: PlanRep.h:66
ogdf::PlanRep::isExpansionEdge
bool isExpansionEdge(edge e) const
Returns if e is an expansion edge.
Definition: PlanRep.h:502
ogdf::PlanRep::m_expandAdj
NodeArray< adjEntry > m_expandAdj
Definition: PlanRep.h:742
ogdf::UMLEdgeTypeConstants::AssClass
@ AssClass
ogdf::UMLEdgeTypeConstants::PrimDependency
@ PrimDependency
ogdf::PlanRep::edgeTypePrimaryOR
edgeType edgeTypePrimaryOR(edge e, edgeType et)
Sets primary type of e to bitwise OR of et's primary value and old value.
Definition: PlanRep.h:471
ogdf::PlanRep::ccInfo
const CCsInfo & ccInfo() const
Returns the connected components info structure.
Definition: PlanRep.h:104
ogdf::PlanRep::setPrimaryType
void setPrimaryType(edge e, edgeType et)
Sets primary edge type of edge e to primary edge type in et (deletes old primary value).
Definition: PlanRep.h:451
ogdf::UMLNodeTypeOffsets::Tertiary
@ Tertiary
ogdf::UMLEdgeTypePatterns::Secondary
@ Secondary
ogdf::PlanRep::isExpansion
bool isExpansion(edge e) const
Returns true iff edge e is classified as expansion edge.
Definition: PlanRep.h:395
ogdf::NodeArray< double >
ogdf::PlanRep::Deg1RestoreInfo::m_adjRef
adjEntry m_adjRef
the reference adjacency entry for restoring the edge
Definition: PlanRep.h:71
ogdf::EdgeArray< int >
ogdf::PlanRep::v
node v(int i) const
Returns node i in the list of all original nodes.
Definition: PlanRep.h:115
ogdf::PlanRep::numberOfNodesInCC
int numberOfNodesInCC(int cc) const
Returns the number of nodes in connected component cc.
Definition: PlanRep.h:110
ogdf::AdjElement
Class for adjacency list elements.
Definition: Graph_d.h:79
ogdf::PlanRep::m_pGraphAttributes
const GraphAttributes * m_pGraphAttributes
Pointer to graph attributes of original graph.
Definition: PlanRep.h:720
ogdf::PlanRep::cliquePattern
edgeType cliquePattern() const
Definition: PlanRep.h:735
ogdf::PlanRep::isDegreeExpansionEdge
bool isDegreeExpansionEdge(edge e) const
Returns if e is a degree expansion edge.
Definition: PlanRep.h:511
ogdf::UMLEdgeTypePatterns::Primary
@ Primary
ogdf::UMLEdgeTypeOffsets::Fourth
@ Fourth
ogdf::PlanRep::setAssClass
void setAssClass(edge e)
Classifies edge e as connection at an association class (tertiary type).
Definition: PlanRep.h:409
ogdf::PlanRep::m_edgeTypes
EdgeArray< edgeType > m_edgeTypes
Definition: PlanRep.h:758
ogdf::Layout
Stores a layout of a graph (coordinates of nodes, bend points of edges).
Definition: Layout.h:46
ogdf::PlanRep::stopNode
int stopNode() const
Returns the index of (one past) the last node in this connected component.
Definition: PlanRep.h:127
ogdf::PlanRep::setAssociation
void setAssociation(edge e)
Classifies edge e as association (primary type).
Definition: PlanRep.h:375
ogdf::PlanRep::isBrother
bool isBrother(edge e) const
Returns true if edge e is classified as brother.
Definition: PlanRep.h:433
ogdf::Graph::EdgeType::association
@ association
ogdf::OrthoRep
Orthogonal representation of an embedded graph.
Definition: OrthoRep.h:236
ogdf::PlanRep::numberOfCCs
int numberOfCCs() const
Returns the number of connected components in the original graph.
Definition: PlanRep.h:94
ogdf::PlanRep::m_ccInfo
Graph::CCsInfo m_ccInfo
Definition: PlanRep.h:715
ogdf::PlanRep::startEdge
int startEdge() const
Returns the index of the first edge in this connected component.
Definition: PlanRep.h:133
ogdf::PlanRep::boundaryAdj
adjEntry boundaryAdj(node v) const
Returns the adjacency entry of the first edge of the inserted boundary at a center node (original) of...
Definition: PlanRep.h:177
ogdf::PlanRep::typeOf
Graph::NodeType typeOf(node v) const
Returns the type of node v.
Definition: PlanRep.h:208
ogdf::PlanRep::expandAdj
adjEntry & expandAdj(node v)
Definition: PlanRep.h:163
ogdf::PlanRep::m_currentCC
int m_currentCC
The index of the current component.
Definition: PlanRep.h:714
ogdf::FaceSet< false >
ogdf::PlanRep::typeOf
EdgeType typeOf(edge e) const
Returns the type of edge e.
Definition: PlanRep.h:271
ogdf::Graph::EdgeType::generalization
@ generalization
ogdf::UMLEdgeTypePatterns::Fourth
@ Fourth
ogdf::UMLEdgeTypeConstants::SecClique
@ SecClique
ogdf::PlanRep::setEdgeTypeOf
void setEdgeTypeOf(edge e, edgeType et)
Sets the new type field of edge e to et.
Definition: PlanRep.h:315
ogdf::PlanRep::boundaryAdj
adjEntry & boundaryAdj(node v)
Returns a reference to the adjacency entry of the first edge of the inserted boundary at a center nod...
Definition: PlanRep.h:185
GraphCopy.h
Declaration of graph copy classes.
ogdf::List
Doubly linked lists (maintaining the length of the list).
Definition: List.h:40
ogdf::PlanRep::e
edge e(int i) const
Returns edge i in the list of all original edges.
Definition: PlanRep.h:118
ogdf::PlanRep::expandedNode
node expandedNode(node v) const
Definition: PlanRep.h:597
ogdf::Graph
Data type for general directed graphs (adjacency list representation).
Definition: Graph_d.h:495
ogdf::PlanRep::removeEdgePathEmbedded
void removeEdgePathEmbedded(CombinatorialEmbedding &E, edge eOrig, FaceSet< false > &newFaces)
Removes the complete edge path for edge eOrig while preserving the embedding.
Definition: PlanRep.h:659
ogdf::PlanRep::isDependency
bool isDependency(edge e) const
Returns true iff edge e is classified as dependency.
Definition: PlanRep.h:361
ogdf::UMLEdgeTypeConstants::HalfBrother
@ HalfBrother
ogdf::GraphCopy::removeEdgePathEmbedded
void removeEdgePathEmbedded(CombinatorialEmbedding &E, edge eOrig, FaceSet< false > &newFaces)
Removes the complete edge path for edge eOrig while preserving the embedding.
ogdf::PlanRep::oriEdgeTypes
edgeType & oriEdgeTypes(edge e)
Returns a reference to the type of original edge e.
Definition: PlanRep.h:287
ogdf::PlanRep::Deg1RestoreInfo::m_eOriginal
edge m_eOriginal
the original edge leading to the deg-1 node
Definition: PlanRep.h:69
ogdf::PlanRep::associationPattern
edgeType associationPattern() const
Definition: PlanRep.h:730
ogdf::UMLEdgeTypeConstants::PrimAssociation
@ PrimAssociation
ogdf::PlanRep::edgeTypeOR
edgeType edgeTypeOR(edge e, edgeType et)
Sets type of edge e to current type (bitwise) OR et.
Definition: PlanRep.h:448
ogdf::UMLEdgeTypeConstants::Brother
@ Brother
ogdf::Graph::NodeType
NodeType
The type of nodes.
Definition: Graph_d.h:548
ogdf::PlanRep::heightOrig
double heightOrig(node v) const
Returns the height of original node v.
Definition: PlanRep.h:548
ogdf::PlanRep::setCrossingType
void setCrossingType(node v)
Classifies node v as a crossing.
Definition: PlanRep.h:247
ogdf::PlanRep::heightOrig
const NodeArray< double > & heightOrig() const
Gives access to the node array of the heights of original nodes.
Definition: PlanRep.h:542
NodeTypePatterns.h
Declaration of node types and patterns for planar representations.
ogdf::PlanRep::isBoundary
bool isBoundary(edge e) const
Returns true iff edge e is a clique boundary.
Definition: PlanRep.h:402
ogdf::PlanRep::nodeTypeOf
nodeType nodeTypeOf(node v)
Returns the extended node type of v.
Definition: PlanRep.h:238
ogdf::PlanRep::setGeneralization
void setGeneralization(edge e)
Classifies edge e as generalization (primary type).
Definition: PlanRep.h:353
ogdf::PlanRep::isCrossingType
bool isCrossingType(node v) const
Returns true iff node v is classified as a crossing.
Definition: PlanRep.h:256
ogdf::PlanRep::edgeTypePrimaryAND
edgeType edgeTypePrimaryAND(edge e, edgeType et)
Sets primary type of e to bitwise AND of et's primary value and old value.
Definition: PlanRep.h:468
ogdf::UMLEdgeTypeConstants
UMLEdgeTypeConstants
Definition: EdgeTypePatterns.h:65
ogdf::PlanRep::numberOfNodesInCC
int numberOfNodesInCC() const
Returns the number of nodes in the current connected component.
Definition: PlanRep.h:107
ogdf::PlanRep::setCliqueBoundary
void setCliqueBoundary(edge e)
Definition: PlanRep.h:190
ogdf::PlanRep::startNode
int startNode(int cc) const
Returns the index of the first node in connected component cc.
Definition: PlanRep.h:124
OGDF_EXPORT
#define OGDF_EXPORT
Specifies that a function or class is exported by the OGDF DLL.
Definition: config.h:99
ogdf::PlanRep::getGraphAttributes
const GraphAttributes & getGraphAttributes() const
Returns the graph attributes of the original graph (the pointer may be 0).
Definition: PlanRep.h:560
ogdf::PlanRep::setPrimaryType
void setPrimaryType(edge e, UMLEdgeTypeConstants et)
Sets primary edge type of edge e to primary edge type in et (deletes old primary value).
Definition: PlanRep.h:457
ogdf::PlanRep::currentCC
int currentCC() const
Returns the index of the current connected component (-1 if not yet initialized).
Definition: PlanRep.h:99
ogdf::CombinatorialEmbedding
Combinatorial embeddings of planar graphs with modification functionality.
Definition: CombinatorialEmbedding.h:409
ogdf::EdgeElement
Class for the representation of edges.
Definition: Graph_d.h:292
ogdf::PlanRep::setExpansionEdge
void setExpansionEdge(edge e, int expType)
Sets the expansion edge type of e to expType.
Definition: PlanRep.h:497
ogdf::PlanRep::expansionType
int expansionType(edge e) const
Returns the expansion edge type of e.
Definition: PlanRep.h:507
ogdf::PlanRep::setExpansion
void setExpansion(edge e)
Classifies edge e as expansion edge (secondary type).
Definition: PlanRep.h:387
ogdf::GridLayout
Representation of a graph's grid layout.
Definition: GridLayout.h:46
ogdf::PlanRep::isGeneralization
bool isGeneralization(edge e) const
Returns true iff edge e is classified as generalization.
Definition: PlanRep.h:347
ogdf::PlanRep::edgeTypes
edgeType & edgeTypes(edge e)
Returns a reference to the new type field of e.
Definition: PlanRep.h:305
ogdf::UMLEdgeTypeConstants::SecExpansion
@ SecExpansion
ogdf::PlanRep::setDependency
void setDependency(edge e)
Classifies edge e as dependency (primary type).
Definition: PlanRep.h:367
ogdf::PlanRep::widthOrig
const NodeArray< double > & widthOrig() const
Gives access to the node array of the widths of original nodes.
Definition: PlanRep.h:530
ogdf::PlanRep::Deg1RestoreInfo
Information for restoring degree-1 nodes.
Definition: PlanRep.h:63
ogdf::PlanRep::m_expandedNode
NodeArray< node > m_expandedNode
For all expansion nodes, save expanded node.
Definition: PlanRep.h:741
ogdf::Graph::EdgeType::dependency
@ dependency
ogdf::UMLEdgeTypeConstants::PrimGeneralization
@ PrimGeneralization
ogdf::UMLEdgeTypeOffsets::User
@ User
ogdf::NodeElement
Class for the representation of nodes.
Definition: Graph_d.h:169
ogdf::PlanRep::typeOf
Graph::NodeType & typeOf(node v)
Returns a reference to the type of node v.
Definition: PlanRep.h:216
GridLayout.h
Declaration of class GridLayout.
ogdf::PlanRep::setHalfBrother
void setHalfBrother(edge e)
Classifies edge e as connection between ... (fourth level type).
Definition: PlanRep.h:428
ogdf::PlanRep::Deg1RestoreInfo::m_deg1Original
node m_deg1Original
the original deg-1 node
Definition: PlanRep.h:70
ogdf::PlanRep::setUserType
void setUserType(edge e, edgeType et)
Sets user defined type locally.
Definition: PlanRep.h:474
ogdf::PlanRep::typeOrig
EdgeType typeOrig(edge e) const
Returns the type of original edge e.
Definition: PlanRep.h:554
ogdf::PlanRep::isAssClass
bool isAssClass(edge e) const
Returns true iff edge e is classified as connection at an association class.
Definition: PlanRep.h:415
ogdf::UMLEdgeTypePatterns::All
@ All
ogdf::PlanRep::isUserType
bool isUserType(edge e, edgeType et) const
Returns user defined type.
Definition: PlanRep.h:481
EdgeTypePatterns.h
Edge types and patterns for planar representations.
ogdf::PlanRep::startNode
int startNode() const
Returns the index of the first node in this connected component.
Definition: PlanRep.h:121
ogdf::PlanRep::generalizationPattern
edgeType generalizationPattern() const
Definition: PlanRep.h:729
ogdf::PlanRep::m_nodeTypes
NodeArray< nodeType > m_nodeTypes
Node types for extended semantic information.
Definition: PlanRep.h:739
ogdf::PlanRep::m_expansionEdge
EdgeArray< int > m_expansionEdge
Definition: PlanRep.h:749
ogdf::PlanRep::m_eAuxCopy
EdgeArray< edge > m_eAuxCopy
Definition: PlanRep.h:765